1 /* Functions for image support on window system.
2 Copyright (C) 1989, 1992-2011 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
6 GNU Emacs is free software: you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation, either version 3 of the License, or
9 (at your option) any later version.
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
26 #if defined HAVE_LIBPNG_PNG_H
27 # include <libpng/png.h>
35 /* This makes the fields of a Display accessible, in Xlib header files. */
37 #define XLIB_ILLEGAL_ACCESS
42 #include "dispextern.h"
43 #include "blockinput.h"
46 #include "character.h"
48 #include "termhooks.h"
53 #include <sys/types.h>
56 #define COLOR_TABLE_SUPPORT 1
58 typedef struct x_bitmap_record Bitmap_Record
;
59 #define GET_PIXEL(ximg, x, y) XGetPixel(ximg, x, y)
60 #define NO_PIXMAP None
62 #define RGB_PIXEL_COLOR unsigned long
64 #define PIX_MASK_RETAIN 0
65 #define PIX_MASK_DRAW 1
66 #endif /* HAVE_X_WINDOWS */
73 /* W32_TODO : Color tables on W32. */
74 #undef COLOR_TABLE_SUPPORT
76 typedef struct w32_bitmap_record Bitmap_Record
;
77 #define GET_PIXEL(ximg, x, y) GetPixel(ximg, x, y)
80 #define RGB_PIXEL_COLOR COLORREF
82 #define PIX_MASK_RETAIN 0
83 #define PIX_MASK_DRAW 1
85 #define FRAME_X_VISUAL(f) FRAME_X_DISPLAY_INFO (f)->visual
86 #define x_defined_color w32_defined_color
87 #define DefaultDepthOfScreen(screen) (one_w32_display_info.n_cbits)
89 /* Functions from w32term.c that depend on XColor (so can't go in w32term.h
90 without modifying lots of files). */
91 extern void x_query_colors (struct frame
*f
, XColor
*colors
, int ncolors
);
92 extern void x_query_color (struct frame
*f
, XColor
*color
);
94 /* Version of libpng that we were compiled with, or -1 if no PNG
95 support was compiled in. This is tested by w32-win.el to correctly
96 set up the alist used to search for PNG libraries. */
97 Lisp_Object Qlibpng_version
;
98 #endif /* HAVE_NTGUI */
102 #include <sys/types.h>
103 #include <sys/stat.h>
105 #undef COLOR_TABLE_SUPPORT
107 typedef struct ns_bitmap_record Bitmap_Record
;
109 #define GET_PIXEL(ximg, x, y) XGetPixel(ximg, x, y)
112 #define RGB_PIXEL_COLOR unsigned long
115 #define PIX_MASK_RETAIN 0
116 #define PIX_MASK_DRAW 1
118 #define FRAME_X_VISUAL FRAME_NS_DISPLAY_INFO(f)->visual
119 #define x_defined_color(f, name, color_def, alloc) \
120 ns_defined_color (f, name, color_def, alloc, 0)
121 #define FRAME_X_SCREEN(f) 0
122 #define DefaultDepthOfScreen(screen) x_display_list->n_planes
126 /* The symbol `postscript' identifying images of this type. */
128 static Lisp_Object Qpostscript
;
130 static void x_disable_image (struct frame
*, struct image
*);
131 static void x_edge_detection (struct frame
*, struct image
*, Lisp_Object
,
134 static void init_color_table (void);
135 static unsigned long lookup_rgb_color (struct frame
*f
, int r
, int g
, int b
);
136 #ifdef COLOR_TABLE_SUPPORT
137 static void free_color_table (void);
138 static unsigned long *colors_in_color_table (int *n
);
139 static unsigned long lookup_pixel_color (struct frame
*f
, unsigned long p
);
141 static Lisp_Object
Finit_image_library (Lisp_Object
, Lisp_Object
);
143 /* Code to deal with bitmaps. Bitmaps are referenced by their bitmap
144 id, which is just an int that this section returns. Bitmaps are
145 reference counted so they can be shared among frames.
147 Bitmap indices are guaranteed to be > 0, so a negative number can
148 be used to indicate no bitmap.
150 If you use x_create_bitmap_from_data, then you must keep track of
151 the bitmaps yourself. That is, creating a bitmap from the same
152 data more than once will not be caught. */
156 XGetImage (Display
*display
, Pixmap pixmap
, int x
, int y
,
157 unsigned int width
, unsigned int height
,
158 unsigned long plane_mask
, int format
)
160 /* TODO: not sure what this function is supposed to do.. */
161 ns_retain_object (pixmap
);
165 /* use with imgs created by ns_image_for_XPM */
167 XGetPixel (XImagePtr ximage
, int x
, int y
)
169 return ns_get_pixel (ximage
, x
, y
);
172 /* use with imgs created by ns_image_for_XPM; alpha set to 1;
173 pixel is assumed to be in form RGB */
175 XPutPixel (XImagePtr ximage
, int x
, int y
, unsigned long pixel
)
177 ns_put_pixel (ximage
, x
, y
, pixel
);
182 /* Functions to access the contents of a bitmap, given an id. */
185 x_bitmap_height (FRAME_PTR f
, ptrdiff_t id
)
187 return FRAME_X_DISPLAY_INFO (f
)->bitmaps
[id
- 1].height
;
191 x_bitmap_width (FRAME_PTR f
, ptrdiff_t id
)
193 return FRAME_X_DISPLAY_INFO (f
)->bitmaps
[id
- 1].width
;
196 #if defined (HAVE_X_WINDOWS) || defined (HAVE_NTGUI)
198 x_bitmap_pixmap (FRAME_PTR f
, ptrdiff_t id
)
200 return (int) FRAME_X_DISPLAY_INFO (f
)->bitmaps
[id
- 1].pixmap
;
204 #ifdef HAVE_X_WINDOWS
206 x_bitmap_mask (FRAME_PTR f
, ptrdiff_t id
)
208 return FRAME_X_DISPLAY_INFO (f
)->bitmaps
[id
- 1].mask
;
212 /* Allocate a new bitmap record. Returns index of new record. */
215 x_allocate_bitmap_record (FRAME_PTR f
)
217 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
220 if (dpyinfo
->bitmaps
== NULL
)
222 dpyinfo
->bitmaps_size
= 10;
224 = (Bitmap_Record
*) xmalloc (dpyinfo
->bitmaps_size
* sizeof (Bitmap_Record
));
225 dpyinfo
->bitmaps_last
= 1;
229 if (dpyinfo
->bitmaps_last
< dpyinfo
->bitmaps_size
)
230 return ++dpyinfo
->bitmaps_last
;
232 for (i
= 0; i
< dpyinfo
->bitmaps_size
; ++i
)
233 if (dpyinfo
->bitmaps
[i
].refcount
== 0)
236 if (min (PTRDIFF_MAX
, SIZE_MAX
) / sizeof (Bitmap_Record
) / 2
237 < dpyinfo
->bitmaps_size
)
238 memory_full (SIZE_MAX
);
239 dpyinfo
->bitmaps_size
*= 2;
241 = (Bitmap_Record
*) xrealloc (dpyinfo
->bitmaps
,
242 dpyinfo
->bitmaps_size
* sizeof (Bitmap_Record
));
243 return ++dpyinfo
->bitmaps_last
;
246 /* Add one reference to the reference count of the bitmap with id ID. */
249 x_reference_bitmap (FRAME_PTR f
, int id
)
251 ++FRAME_X_DISPLAY_INFO (f
)->bitmaps
[id
- 1].refcount
;
254 /* Create a bitmap for frame F from a HEIGHT x WIDTH array of bits at BITS. */
257 x_create_bitmap_from_data (struct frame
*f
, char *bits
, unsigned int width
, unsigned int height
)
259 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
262 #ifdef HAVE_X_WINDOWS
264 bitmap
= XCreateBitmapFromData (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
265 bits
, width
, height
);
268 #endif /* HAVE_X_WINDOWS */
272 bitmap
= CreateBitmap (width
, height
,
273 FRAME_X_DISPLAY_INFO (XFRAME (frame
))->n_planes
,
274 FRAME_X_DISPLAY_INFO (XFRAME (frame
))->n_cbits
,
278 #endif /* HAVE_NTGUI */
281 void *bitmap
= ns_image_from_XBM (bits
, width
, height
);
286 id
= x_allocate_bitmap_record (f
);
289 dpyinfo
->bitmaps
[id
- 1].img
= bitmap
;
290 dpyinfo
->bitmaps
[id
- 1].depth
= 1;
293 dpyinfo
->bitmaps
[id
- 1].file
= NULL
;
294 dpyinfo
->bitmaps
[id
- 1].height
= height
;
295 dpyinfo
->bitmaps
[id
- 1].width
= width
;
296 dpyinfo
->bitmaps
[id
- 1].refcount
= 1;
298 #ifdef HAVE_X_WINDOWS
299 dpyinfo
->bitmaps
[id
- 1].pixmap
= bitmap
;
300 dpyinfo
->bitmaps
[id
- 1].have_mask
= 0;
301 dpyinfo
->bitmaps
[id
- 1].depth
= 1;
302 #endif /* HAVE_X_WINDOWS */
305 dpyinfo
->bitmaps
[id
- 1].pixmap
= bitmap
;
306 dpyinfo
->bitmaps
[id
- 1].hinst
= NULL
;
307 dpyinfo
->bitmaps
[id
- 1].depth
= 1;
308 #endif /* HAVE_NTGUI */
313 /* Create bitmap from file FILE for frame F. */
316 x_create_bitmap_from_file (struct frame
*f
, Lisp_Object file
)
318 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
321 return -1; /* W32_TODO : bitmap support */
322 #endif /* HAVE_NTGUI */
326 void *bitmap
= ns_image_from_file (file
);
332 id
= x_allocate_bitmap_record (f
);
333 dpyinfo
->bitmaps
[id
- 1].img
= bitmap
;
334 dpyinfo
->bitmaps
[id
- 1].refcount
= 1;
335 dpyinfo
->bitmaps
[id
- 1].file
= (char *) xmalloc (SBYTES (file
) + 1);
336 dpyinfo
->bitmaps
[id
- 1].depth
= 1;
337 dpyinfo
->bitmaps
[id
- 1].height
= ns_image_width (bitmap
);
338 dpyinfo
->bitmaps
[id
- 1].width
= ns_image_height (bitmap
);
339 strcpy (dpyinfo
->bitmaps
[id
- 1].file
, SDATA (file
));
343 #ifdef HAVE_X_WINDOWS
344 unsigned int width
, height
;
346 int xhot
, yhot
, result
;
352 /* Look for an existing bitmap with the same name. */
353 for (id
= 0; id
< dpyinfo
->bitmaps_last
; ++id
)
355 if (dpyinfo
->bitmaps
[id
].refcount
356 && dpyinfo
->bitmaps
[id
].file
357 && !strcmp (dpyinfo
->bitmaps
[id
].file
, SSDATA (file
)))
359 ++dpyinfo
->bitmaps
[id
].refcount
;
364 /* Search bitmap-file-path for the file, if appropriate. */
365 fd
= openp (Vx_bitmap_file_path
, file
, Qnil
, &found
, Qnil
);
370 filename
= SSDATA (found
);
372 result
= XReadBitmapFile (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
373 filename
, &width
, &height
, &bitmap
, &xhot
, &yhot
);
374 if (result
!= BitmapSuccess
)
377 id
= x_allocate_bitmap_record (f
);
378 dpyinfo
->bitmaps
[id
- 1].pixmap
= bitmap
;
379 dpyinfo
->bitmaps
[id
- 1].have_mask
= 0;
380 dpyinfo
->bitmaps
[id
- 1].refcount
= 1;
381 dpyinfo
->bitmaps
[id
- 1].file
= (char *) xmalloc (SBYTES (file
) + 1);
382 dpyinfo
->bitmaps
[id
- 1].depth
= 1;
383 dpyinfo
->bitmaps
[id
- 1].height
= height
;
384 dpyinfo
->bitmaps
[id
- 1].width
= width
;
385 strcpy (dpyinfo
->bitmaps
[id
- 1].file
, SSDATA (file
));
388 #endif /* HAVE_X_WINDOWS */
394 free_bitmap_record (Display_Info
*dpyinfo
, Bitmap_Record
*bm
)
396 #ifdef HAVE_X_WINDOWS
397 XFreePixmap (dpyinfo
->display
, bm
->pixmap
);
399 XFreePixmap (dpyinfo
->display
, bm
->mask
);
400 #endif /* HAVE_X_WINDOWS */
403 DeleteObject (bm
->pixmap
);
404 #endif /* HAVE_NTGUI */
407 ns_release_object (bm
->img
);
417 /* Remove reference to bitmap with id number ID. */
420 x_destroy_bitmap (FRAME_PTR f
, ptrdiff_t id
)
422 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
426 Bitmap_Record
*bm
= &dpyinfo
->bitmaps
[id
- 1];
428 if (--bm
->refcount
== 0)
431 free_bitmap_record (dpyinfo
, bm
);
437 /* Free all the bitmaps for the display specified by DPYINFO. */
440 x_destroy_all_bitmaps (Display_Info
*dpyinfo
)
443 Bitmap_Record
*bm
= dpyinfo
->bitmaps
;
445 for (i
= 0; i
< dpyinfo
->bitmaps_last
; i
++, bm
++)
446 if (bm
->refcount
> 0)
447 free_bitmap_record (dpyinfo
, bm
);
449 dpyinfo
->bitmaps_last
= 0;
453 #ifdef HAVE_X_WINDOWS
455 /* Useful functions defined in the section
456 `Image type independent image structures' below. */
458 static unsigned long four_corners_best (XImagePtr ximg
,
461 unsigned long height
);
463 static int x_create_x_image_and_pixmap (struct frame
*f
, int width
, int height
,
464 int depth
, XImagePtr
*ximg
,
467 static void x_destroy_x_image (XImagePtr ximg
);
470 /* Create a mask of a bitmap. Note is this not a perfect mask.
471 It's nicer with some borders in this context */
474 x_create_bitmap_mask (struct frame
*f
, ptrdiff_t id
)
477 XImagePtr ximg
, mask_img
;
478 unsigned long width
, height
;
481 unsigned long x
, y
, xp
, xm
, yp
, ym
;
484 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
489 pixmap
= x_bitmap_pixmap (f
, id
);
490 width
= x_bitmap_width (f
, id
);
491 height
= x_bitmap_height (f
, id
);
494 ximg
= XGetImage (FRAME_X_DISPLAY (f
), pixmap
, 0, 0, width
, height
,
503 result
= x_create_x_image_and_pixmap (f
, width
, height
, 1, &mask_img
, &mask
);
508 XDestroyImage (ximg
);
512 bg
= four_corners_best (ximg
, NULL
, width
, height
);
514 for (y
= 0; y
< ximg
->height
; ++y
)
516 for (x
= 0; x
< ximg
->width
; ++x
)
518 xp
= x
!= ximg
->width
- 1 ? x
+ 1 : 0;
519 xm
= x
!= 0 ? x
- 1 : ximg
->width
- 1;
520 yp
= y
!= ximg
->height
- 1 ? y
+ 1 : 0;
521 ym
= y
!= 0 ? y
- 1 : ximg
->height
- 1;
522 if (XGetPixel (ximg
, x
, y
) == bg
523 && XGetPixel (ximg
, x
, yp
) == bg
524 && XGetPixel (ximg
, x
, ym
) == bg
525 && XGetPixel (ximg
, xp
, y
) == bg
526 && XGetPixel (ximg
, xp
, yp
) == bg
527 && XGetPixel (ximg
, xp
, ym
) == bg
528 && XGetPixel (ximg
, xm
, y
) == bg
529 && XGetPixel (ximg
, xm
, yp
) == bg
530 && XGetPixel (ximg
, xm
, ym
) == bg
)
531 XPutPixel (mask_img
, x
, y
, 0);
533 XPutPixel (mask_img
, x
, y
, 1);
537 xassert (interrupt_input_blocked
);
538 gc
= XCreateGC (FRAME_X_DISPLAY (f
), mask
, 0, NULL
);
539 XPutImage (FRAME_X_DISPLAY (f
), mask
, gc
, mask_img
, 0, 0, 0, 0,
541 XFreeGC (FRAME_X_DISPLAY (f
), gc
);
543 dpyinfo
->bitmaps
[id
- 1].have_mask
= 1;
544 dpyinfo
->bitmaps
[id
- 1].mask
= mask
;
546 XDestroyImage (ximg
);
547 x_destroy_x_image (mask_img
);
552 #endif /* HAVE_X_WINDOWS */
555 /***********************************************************************
557 ***********************************************************************/
559 /* List of supported image types. Use define_image_type to add new
560 types. Use lookup_image_type to find a type for a given symbol. */
562 static struct image_type
*image_types
;
564 /* The symbol `xbm' which is used as the type symbol for XBM images. */
566 static Lisp_Object Qxbm
;
570 Lisp_Object QCascent
, QCmargin
, QCrelief
;
571 Lisp_Object QCconversion
;
572 static Lisp_Object QCheuristic_mask
;
573 static Lisp_Object QCcolor_symbols
;
574 static Lisp_Object QCindex
, QCmatrix
, QCcolor_adjustment
, QCmask
, QCgeometry
;
575 static Lisp_Object QCcrop
, QCrotation
;
579 static Lisp_Object Qcount
, Qextension_data
, Qdelay
;
580 static Lisp_Object Qlaplace
, Qemboss
, Qedge_detection
, Qheuristic
;
582 /* Function prototypes. */
584 static Lisp_Object
define_image_type (struct image_type
*type
, int loaded
);
585 static struct image_type
*lookup_image_type (Lisp_Object symbol
);
586 static void image_error (const char *format
, Lisp_Object
, Lisp_Object
);
587 static void x_laplace (struct frame
*, struct image
*);
588 static void x_emboss (struct frame
*, struct image
*);
589 static int x_build_heuristic_mask (struct frame
*, struct image
*,
592 #define CACHE_IMAGE_TYPE(type, status) \
593 do { Vlibrary_cache = Fcons (Fcons (type, status), Vlibrary_cache); } while (0)
595 #define CACHE_IMAGE_TYPE(type, status)
598 #define ADD_IMAGE_TYPE(type) \
599 do { Vimage_types = Fcons (type, Vimage_types); } while (0)
601 /* Define a new image type from TYPE. This adds a copy of TYPE to
602 image_types and caches the loading status of TYPE. */
605 define_image_type (struct image_type
*type
, int loaded
)
613 /* Make a copy of TYPE to avoid a bus error in a dumped Emacs.
614 The initialized data segment is read-only. */
615 struct image_type
*p
= (struct image_type
*) xmalloc (sizeof *p
);
616 memcpy (p
, type
, sizeof *p
);
617 p
->next
= image_types
;
622 CACHE_IMAGE_TYPE (*type
->type
, success
);
627 /* Look up image type SYMBOL, and return a pointer to its image_type
628 structure. Value is null if SYMBOL is not a known image type. */
630 static inline struct image_type
*
631 lookup_image_type (Lisp_Object symbol
)
633 struct image_type
*type
;
635 /* We must initialize the image-type if it hasn't been already. */
636 if (NILP (Finit_image_library (symbol
, Vdynamic_library_alist
)))
637 return 0; /* unimplemented */
639 for (type
= image_types
; type
; type
= type
->next
)
640 if (EQ (symbol
, *type
->type
))
647 /* Value is non-zero if OBJECT is a valid Lisp image specification. A
648 valid image specification is a list whose car is the symbol
649 `image', and whose rest is a property list. The property list must
650 contain a value for key `:type'. That value must be the name of a
651 supported image type. The rest of the property list depends on the
655 valid_image_p (Lisp_Object object
)
663 for (tem
= XCDR (object
); CONSP (tem
); tem
= XCDR (tem
))
664 if (EQ (XCAR (tem
), QCtype
))
667 if (CONSP (tem
) && SYMBOLP (XCAR (tem
)))
669 struct image_type
*type
;
670 type
= lookup_image_type (XCAR (tem
));
672 valid_p
= type
->valid_p (object
);
683 /* Log error message with format string FORMAT and argument ARG.
684 Signaling an error, e.g. when an image cannot be loaded, is not a
685 good idea because this would interrupt redisplay, and the error
686 message display would lead to another redisplay. This function
687 therefore simply displays a message. */
690 image_error (const char *format
, Lisp_Object arg1
, Lisp_Object arg2
)
692 add_to_log (format
, arg1
, arg2
);
697 /***********************************************************************
699 ***********************************************************************/
701 enum image_value_type
703 IMAGE_DONT_CHECK_VALUE_TYPE
,
705 IMAGE_STRING_OR_NIL_VALUE
,
707 IMAGE_POSITIVE_INTEGER_VALUE
,
708 IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
,
709 IMAGE_NON_NEGATIVE_INTEGER_VALUE
,
712 IMAGE_FUNCTION_VALUE
,
717 /* Structure used when parsing image specifications. */
721 /* Name of keyword. */
724 /* The type of value allowed. */
725 enum image_value_type type
;
727 /* Non-zero means key must be present. */
730 /* Used to recognize duplicate keywords in a property list. */
733 /* The value that was found. */
738 static int parse_image_spec (Lisp_Object
, struct image_keyword
*,
740 static Lisp_Object
image_spec_value (Lisp_Object
, Lisp_Object
, int *);
743 /* Parse image spec SPEC according to KEYWORDS. A valid image spec
744 has the format (image KEYWORD VALUE ...). One of the keyword/
745 value pairs must be `:type TYPE'. KEYWORDS is a vector of
746 image_keywords structures of size NKEYWORDS describing other
747 allowed keyword/value pairs. Value is non-zero if SPEC is valid. */
750 parse_image_spec (Lisp_Object spec
, struct image_keyword
*keywords
,
751 int nkeywords
, Lisp_Object type
)
760 while (CONSP (plist
))
762 Lisp_Object key
, value
;
764 /* First element of a pair must be a symbol. */
766 plist
= XCDR (plist
);
770 /* There must follow a value. */
773 value
= XCAR (plist
);
774 plist
= XCDR (plist
);
776 /* Find key in KEYWORDS. Error if not found. */
777 for (i
= 0; i
< nkeywords
; ++i
)
778 if (strcmp (keywords
[i
].name
, SSDATA (SYMBOL_NAME (key
))) == 0)
784 /* Record that we recognized the keyword. If a keywords
785 was found more than once, it's an error. */
786 keywords
[i
].value
= value
;
789 if (keywords
[i
].count
> 1)
792 /* Check type of value against allowed type. */
793 switch (keywords
[i
].type
)
795 case IMAGE_STRING_VALUE
:
796 if (!STRINGP (value
))
800 case IMAGE_STRING_OR_NIL_VALUE
:
801 if (!STRINGP (value
) && !NILP (value
))
805 case IMAGE_SYMBOL_VALUE
:
806 if (!SYMBOLP (value
))
810 case IMAGE_POSITIVE_INTEGER_VALUE
:
811 if (!INTEGERP (value
) || XINT (value
) <= 0)
815 case IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
:
816 if (INTEGERP (value
) && XINT (value
) >= 0)
819 && INTEGERP (XCAR (value
)) && INTEGERP (XCDR (value
))
820 && XINT (XCAR (value
)) >= 0 && XINT (XCDR (value
)) >= 0)
824 case IMAGE_ASCENT_VALUE
:
825 if (SYMBOLP (value
) && EQ (value
, Qcenter
))
827 else if (INTEGERP (value
)
829 && XINT (value
) <= 100)
833 case IMAGE_NON_NEGATIVE_INTEGER_VALUE
:
834 if (!INTEGERP (value
) || XINT (value
) < 0)
838 case IMAGE_DONT_CHECK_VALUE_TYPE
:
841 case IMAGE_FUNCTION_VALUE
:
842 value
= indirect_function (value
);
843 if (!NILP (Ffunctionp (value
)))
847 case IMAGE_NUMBER_VALUE
:
848 if (!INTEGERP (value
) && !FLOATP (value
))
852 case IMAGE_INTEGER_VALUE
:
853 if (!INTEGERP (value
))
857 case IMAGE_BOOL_VALUE
:
858 if (!NILP (value
) && !EQ (value
, Qt
))
867 if (EQ (key
, QCtype
) && !EQ (type
, value
))
871 /* Check that all mandatory fields are present. */
872 for (i
= 0; i
< nkeywords
; ++i
)
873 if (keywords
[i
].mandatory_p
&& keywords
[i
].count
== 0)
880 /* Return the value of KEY in image specification SPEC. Value is nil
881 if KEY is not present in SPEC. if FOUND is not null, set *FOUND
882 to 1 if KEY was found in SPEC, set it to 0 otherwise. */
885 image_spec_value (Lisp_Object spec
, Lisp_Object key
, int *found
)
889 xassert (valid_image_p (spec
));
891 for (tail
= XCDR (spec
);
892 CONSP (tail
) && CONSP (XCDR (tail
));
893 tail
= XCDR (XCDR (tail
)))
895 if (EQ (XCAR (tail
), key
))
899 return XCAR (XCDR (tail
));
909 DEFUN ("image-size", Fimage_size
, Simage_size
, 1, 3, 0,
910 doc
: /* Return the size of image SPEC as pair (WIDTH . HEIGHT).
911 PIXELS non-nil means return the size in pixels, otherwise return the
912 size in canonical character units.
913 FRAME is the frame on which the image will be displayed. FRAME nil
914 or omitted means use the selected frame. */)
915 (Lisp_Object spec
, Lisp_Object pixels
, Lisp_Object frame
)
920 if (valid_image_p (spec
))
922 struct frame
*f
= check_x_frame (frame
);
923 int id
= lookup_image (f
, spec
);
924 struct image
*img
= IMAGE_FROM_ID (f
, id
);
925 int width
= img
->width
+ 2 * img
->hmargin
;
926 int height
= img
->height
+ 2 * img
->vmargin
;
929 size
= Fcons (make_float ((double) width
/ FRAME_COLUMN_WIDTH (f
)),
930 make_float ((double) height
/ FRAME_LINE_HEIGHT (f
)));
932 size
= Fcons (make_number (width
), make_number (height
));
935 error ("Invalid image specification");
941 DEFUN ("image-mask-p", Fimage_mask_p
, Simage_mask_p
, 1, 2, 0,
942 doc
: /* Return t if image SPEC has a mask bitmap.
943 FRAME is the frame on which the image will be displayed. FRAME nil
944 or omitted means use the selected frame. */)
945 (Lisp_Object spec
, Lisp_Object frame
)
950 if (valid_image_p (spec
))
952 struct frame
*f
= check_x_frame (frame
);
953 int id
= lookup_image (f
, spec
);
954 struct image
*img
= IMAGE_FROM_ID (f
, id
);
959 error ("Invalid image specification");
964 DEFUN ("image-metadata", Fimage_metadata
, Simage_metadata
, 1, 2, 0,
965 doc
: /* Return metadata for image SPEC.
966 FRAME is the frame on which the image will be displayed. FRAME nil
967 or omitted means use the selected frame. */)
968 (Lisp_Object spec
, Lisp_Object frame
)
973 if (valid_image_p (spec
))
975 struct frame
*f
= check_x_frame (frame
);
976 int id
= lookup_image (f
, spec
);
977 struct image
*img
= IMAGE_FROM_ID (f
, id
);
978 ext
= img
->lisp_data
;
985 /***********************************************************************
986 Image type independent image structures
987 ***********************************************************************/
989 static void free_image (struct frame
*f
, struct image
*img
);
990 static int check_image_size (struct frame
*f
, int width
, int height
);
992 #define MAX_IMAGE_SIZE 6.0
993 /* Allocate and return a new image structure for image specification
994 SPEC. SPEC has a hash value of HASH. */
996 static struct image
*
997 make_image (Lisp_Object spec
, EMACS_UINT hash
)
999 struct image
*img
= (struct image
*) xmalloc (sizeof *img
);
1000 Lisp_Object file
= image_spec_value (spec
, QCfile
, NULL
);
1002 xassert (valid_image_p (spec
));
1003 memset (img
, 0, sizeof *img
);
1004 img
->dependencies
= NILP (file
) ? Qnil
: list1 (file
);
1005 img
->type
= lookup_image_type (image_spec_value (spec
, QCtype
, NULL
));
1006 xassert (img
->type
!= NULL
);
1008 img
->lisp_data
= Qnil
;
1009 img
->ascent
= DEFAULT_IMAGE_ASCENT
;
1011 img
->corners
[BOT_CORNER
] = -1; /* Full image */
1016 /* Free image IMG which was used on frame F, including its resources. */
1019 free_image (struct frame
*f
, struct image
*img
)
1023 struct image_cache
*c
= FRAME_IMAGE_CACHE (f
);
1025 /* Remove IMG from the hash table of its cache. */
1027 img
->prev
->next
= img
->next
;
1029 c
->buckets
[img
->hash
% IMAGE_CACHE_BUCKETS_SIZE
] = img
->next
;
1032 img
->next
->prev
= img
->prev
;
1034 c
->images
[img
->id
] = NULL
;
1036 /* Free resources, then free IMG. */
1037 img
->type
->free (f
, img
);
1042 /* Return 1 if the given widths and heights are valid for display;
1043 otherwise, return 0. */
1046 check_image_size (struct frame
*f
, int width
, int height
)
1050 if (width
<= 0 || height
<= 0)
1053 if (INTEGERP (Vmax_image_size
))
1054 w
= h
= XINT (Vmax_image_size
);
1055 else if (FLOATP (Vmax_image_size
))
1059 w
= FRAME_PIXEL_WIDTH (f
);
1060 h
= FRAME_PIXEL_HEIGHT (f
);
1063 w
= h
= 1024; /* Arbitrary size for unknown frame. */
1064 w
= (int) (XFLOAT_DATA (Vmax_image_size
) * w
);
1065 h
= (int) (XFLOAT_DATA (Vmax_image_size
) * h
);
1070 return (width
<= w
&& height
<= h
);
1073 /* Prepare image IMG for display on frame F. Must be called before
1074 drawing an image. */
1077 prepare_image_for_display (struct frame
*f
, struct image
*img
)
1081 /* We're about to display IMG, so set its timestamp to `now'. */
1083 img
->timestamp
= EMACS_SECS (t
);
1085 /* If IMG doesn't have a pixmap yet, load it now, using the image
1086 type dependent loader function. */
1087 if (img
->pixmap
== NO_PIXMAP
&& !img
->load_failed_p
)
1088 img
->load_failed_p
= img
->type
->load (f
, img
) == 0;
1093 /* Value is the number of pixels for the ascent of image IMG when
1094 drawn in face FACE. */
1097 image_ascent (struct image
*img
, struct face
*face
, struct glyph_slice
*slice
)
1102 if (slice
->height
== img
->height
)
1103 height
= img
->height
+ img
->vmargin
;
1104 else if (slice
->y
== 0)
1105 height
= slice
->height
+ img
->vmargin
;
1107 height
= slice
->height
;
1109 if (img
->ascent
== CENTERED_IMAGE_ASCENT
)
1114 /* W32 specific version. Why?. ++kfs */
1115 ascent
= height
/ 2 - (FONT_DESCENT (face
->font
)
1116 - FONT_BASE (face
->font
)) / 2;
1118 /* This expression is arranged so that if the image can't be
1119 exactly centered, it will be moved slightly up. This is
1120 because a typical font is `top-heavy' (due to the presence
1121 uppercase letters), so the image placement should err towards
1122 being top-heavy too. It also just generally looks better. */
1123 ascent
= (height
+ FONT_BASE(face
->font
)
1124 - FONT_DESCENT(face
->font
) + 1) / 2;
1125 #endif /* HAVE_NTGUI */
1128 ascent
= height
/ 2;
1131 ascent
= (int) (height
* img
->ascent
/ 100.0);
1137 /* Image background colors. */
1139 /* Find the "best" corner color of a bitmap.
1140 On W32, XIMG is assumed to a device context with the bitmap selected. */
1142 static RGB_PIXEL_COLOR
1143 four_corners_best (XImagePtr_or_DC ximg
, int *corners
,
1144 unsigned long width
, unsigned long height
)
1146 RGB_PIXEL_COLOR corner_pixels
[4], best
IF_LINT (= 0);
1149 if (corners
&& corners
[BOT_CORNER
] >= 0)
1151 /* Get the colors at the corner_pixels of ximg. */
1152 corner_pixels
[0] = GET_PIXEL (ximg
, corners
[LEFT_CORNER
], corners
[TOP_CORNER
]);
1153 corner_pixels
[1] = GET_PIXEL (ximg
, corners
[RIGHT_CORNER
] - 1, corners
[TOP_CORNER
]);
1154 corner_pixels
[2] = GET_PIXEL (ximg
, corners
[RIGHT_CORNER
] - 1, corners
[BOT_CORNER
] - 1);
1155 corner_pixels
[3] = GET_PIXEL (ximg
, corners
[LEFT_CORNER
], corners
[BOT_CORNER
] - 1);
1159 /* Get the colors at the corner_pixels of ximg. */
1160 corner_pixels
[0] = GET_PIXEL (ximg
, 0, 0);
1161 corner_pixels
[1] = GET_PIXEL (ximg
, width
- 1, 0);
1162 corner_pixels
[2] = GET_PIXEL (ximg
, width
- 1, height
- 1);
1163 corner_pixels
[3] = GET_PIXEL (ximg
, 0, height
- 1);
1165 /* Choose the most frequently found color as background. */
1166 for (i
= best_count
= 0; i
< 4; ++i
)
1170 for (j
= n
= 0; j
< 4; ++j
)
1171 if (corner_pixels
[i
] == corner_pixels
[j
])
1175 best
= corner_pixels
[i
], best_count
= n
;
1181 /* Portability macros */
1185 #define Destroy_Image(img_dc, prev) \
1186 do { SelectObject (img_dc, prev); DeleteDC (img_dc); } while (0)
1188 #define Free_Pixmap(display, pixmap) \
1189 DeleteObject (pixmap)
1191 #elif defined (HAVE_NS)
1193 #define Destroy_Image(ximg, dummy) \
1194 ns_release_object (ximg)
1196 #define Free_Pixmap(display, pixmap) \
1197 ns_release_object (pixmap)
1201 #define Destroy_Image(ximg, dummy) \
1202 XDestroyImage (ximg)
1204 #define Free_Pixmap(display, pixmap) \
1205 XFreePixmap (display, pixmap)
1207 #endif /* !HAVE_NTGUI && !HAVE_NS */
1210 /* Return the `background' field of IMG. If IMG doesn't have one yet,
1211 it is guessed heuristically. If non-zero, XIMG is an existing
1212 XImage object (or device context with the image selected on W32) to
1213 use for the heuristic. */
1216 image_background (struct image
*img
, struct frame
*f
, XImagePtr_or_DC ximg
)
1218 if (! img
->background_valid
)
1219 /* IMG doesn't have a background yet, try to guess a reasonable value. */
1221 int free_ximg
= !ximg
;
1224 #endif /* HAVE_NTGUI */
1229 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
1230 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
1232 HDC frame_dc
= get_frame_dc (f
);
1233 ximg
= CreateCompatibleDC (frame_dc
);
1234 release_frame_dc (f
, frame_dc
);
1235 prev
= SelectObject (ximg
, img
->pixmap
);
1236 #endif /* !HAVE_NTGUI */
1239 img
->background
= four_corners_best (ximg
, img
->corners
, img
->width
, img
->height
);
1242 Destroy_Image (ximg
, prev
);
1244 img
->background_valid
= 1;
1247 return img
->background
;
1250 /* Return the `background_transparent' field of IMG. If IMG doesn't
1251 have one yet, it is guessed heuristically. If non-zero, MASK is an
1252 existing XImage object to use for the heuristic. */
1255 image_background_transparent (struct image
*img
, struct frame
*f
, XImagePtr_or_DC mask
)
1257 if (! img
->background_transparent_valid
)
1258 /* IMG doesn't have a background yet, try to guess a reasonable value. */
1262 int free_mask
= !mask
;
1265 #endif /* HAVE_NTGUI */
1270 mask
= XGetImage (FRAME_X_DISPLAY (f
), img
->mask
,
1271 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
1273 HDC frame_dc
= get_frame_dc (f
);
1274 mask
= CreateCompatibleDC (frame_dc
);
1275 release_frame_dc (f
, frame_dc
);
1276 prev
= SelectObject (mask
, img
->mask
);
1277 #endif /* HAVE_NTGUI */
1280 img
->background_transparent
1281 = (four_corners_best (mask
, img
->corners
, img
->width
, img
->height
) == PIX_MASK_RETAIN
);
1284 Destroy_Image (mask
, prev
);
1287 img
->background_transparent
= 0;
1289 img
->background_transparent_valid
= 1;
1292 return img
->background_transparent
;
1296 /***********************************************************************
1297 Helper functions for X image types
1298 ***********************************************************************/
1300 static void x_clear_image_1 (struct frame
*, struct image
*, int,
1302 static void x_clear_image (struct frame
*f
, struct image
*img
);
1303 static unsigned long x_alloc_image_color (struct frame
*f
,
1305 Lisp_Object color_name
,
1306 unsigned long dflt
);
1309 /* Clear X resources of image IMG on frame F. PIXMAP_P non-zero means
1310 free the pixmap if any. MASK_P non-zero means clear the mask
1311 pixmap if any. COLORS_P non-zero means free colors allocated for
1312 the image, if any. */
1315 x_clear_image_1 (struct frame
*f
, struct image
*img
, int pixmap_p
, int mask_p
,
1318 if (pixmap_p
&& img
->pixmap
)
1320 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->pixmap
);
1321 img
->pixmap
= NO_PIXMAP
;
1322 /* NOTE (HAVE_NS): background color is NOT an indexed color! */
1323 img
->background_valid
= 0;
1326 if (mask_p
&& img
->mask
)
1328 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
1329 img
->mask
= NO_PIXMAP
;
1330 img
->background_transparent_valid
= 0;
1333 if (colors_p
&& img
->ncolors
)
1335 /* W32_TODO: color table support. */
1336 #ifdef HAVE_X_WINDOWS
1337 x_free_colors (f
, img
->colors
, img
->ncolors
);
1338 #endif /* HAVE_X_WINDOWS */
1339 xfree (img
->colors
);
1346 /* Free X resources of image IMG which is used on frame F. */
1349 x_clear_image (struct frame
*f
, struct image
*img
)
1352 x_clear_image_1 (f
, img
, 1, 1, 1);
1357 /* Allocate color COLOR_NAME for image IMG on frame F. If color
1358 cannot be allocated, use DFLT. Add a newly allocated color to
1359 IMG->colors, so that it can be freed again. Value is the pixel
1362 static unsigned long
1363 x_alloc_image_color (struct frame
*f
, struct image
*img
, Lisp_Object color_name
,
1367 unsigned long result
;
1369 xassert (STRINGP (color_name
));
1371 if (x_defined_color (f
, SSDATA (color_name
), &color
, 1))
1373 /* This isn't called frequently so we get away with simply
1374 reallocating the color vector to the needed size, here. */
1377 (unsigned long *) xrealloc (img
->colors
,
1378 img
->ncolors
* sizeof *img
->colors
);
1379 img
->colors
[img
->ncolors
- 1] = color
.pixel
;
1380 result
= color
.pixel
;
1390 /***********************************************************************
1392 ***********************************************************************/
1394 static void cache_image (struct frame
*f
, struct image
*img
);
1395 static void postprocess_image (struct frame
*, struct image
*);
1397 /* Return a new, initialized image cache that is allocated from the
1398 heap. Call free_image_cache to free an image cache. */
1400 struct image_cache
*
1401 make_image_cache (void)
1403 struct image_cache
*c
= (struct image_cache
*) xmalloc (sizeof *c
);
1406 memset (c
, 0, sizeof *c
);
1408 c
->images
= (struct image
**) xmalloc (c
->size
* sizeof *c
->images
);
1409 size
= IMAGE_CACHE_BUCKETS_SIZE
* sizeof *c
->buckets
;
1410 c
->buckets
= (struct image
**) xmalloc (size
);
1411 memset (c
->buckets
, 0, size
);
1416 /* Find an image matching SPEC in the cache, and return it. If no
1417 image is found, return NULL. */
1418 static struct image
*
1419 search_image_cache (struct frame
*f
, Lisp_Object spec
, EMACS_UINT hash
)
1422 struct image_cache
*c
= FRAME_IMAGE_CACHE (f
);
1423 int i
= hash
% IMAGE_CACHE_BUCKETS_SIZE
;
1425 if (!c
) return NULL
;
1427 /* If the image spec does not specify a background color, the cached
1428 image must have the same background color as the current frame.
1429 The foreground color must also match, for the sake of monochrome
1432 In fact, we could ignore the foreground color matching condition
1433 for color images, or if the image spec specifies :foreground;
1434 similarly we could ignore the background color matching condition
1435 for formats that don't use transparency (such as jpeg), or if the
1436 image spec specifies :background. However, the extra memory
1437 usage is probably negligible in practice, so we don't bother. */
1439 for (img
= c
->buckets
[i
]; img
; img
= img
->next
)
1440 if (img
->hash
== hash
1441 && !NILP (Fequal (img
->spec
, spec
))
1442 && img
->frame_foreground
== FRAME_FOREGROUND_PIXEL (f
)
1443 && img
->frame_background
== FRAME_BACKGROUND_PIXEL (f
))
1449 /* Search frame F for an image with spec SPEC, and free it. */
1452 uncache_image (struct frame
*f
, Lisp_Object spec
)
1454 struct image
*img
= search_image_cache (f
, spec
, sxhash (spec
, 0));
1457 free_image (f
, img
);
1458 /* As display glyphs may still be referring to the image ID, we
1459 must garbage the frame (Bug#6426). */
1460 SET_FRAME_GARBAGED (f
);
1465 /* Free image cache of frame F. Be aware that X frames share images
1469 free_image_cache (struct frame
*f
)
1471 struct image_cache
*c
= FRAME_IMAGE_CACHE (f
);
1476 /* Cache should not be referenced by any frame when freed. */
1477 xassert (c
->refcount
== 0);
1479 for (i
= 0; i
< c
->used
; ++i
)
1480 free_image (f
, c
->images
[i
]);
1484 FRAME_IMAGE_CACHE (f
) = NULL
;
1489 /* Clear image cache of frame F. FILTER=t means free all images.
1490 FILTER=nil means clear only images that haven't been
1491 displayed for some time.
1492 Else, only free the images which have FILTER in their `dependencies'.
1493 Should be called from time to time to reduce the number of loaded images.
1494 If image-cache-eviction-delay is non-nil, this frees images in the cache
1495 which weren't displayed for at least that many seconds. */
1498 clear_image_cache (struct frame
*f
, Lisp_Object filter
)
1500 struct image_cache
*c
= FRAME_IMAGE_CACHE (f
);
1506 /* Block input so that we won't be interrupted by a SIGIO
1507 while being in an inconsistent state. */
1512 /* Filter image cache. */
1513 for (i
= 0; i
< c
->used
; ++i
)
1515 struct image
*img
= c
->images
[i
];
1516 if (img
&& (EQ (Qt
, filter
)
1517 || !NILP (Fmember (filter
, img
->dependencies
))))
1519 free_image (f
, img
);
1524 else if (INTEGERP (Vimage_cache_eviction_delay
))
1526 /* Free cache based on timestamp. */
1529 int delay
, nimages
= 0;
1531 for (i
= 0; i
< c
->used
; ++i
)
1535 /* If the number of cached images has grown unusually large,
1536 decrease the cache eviction delay (Bug#6230). */
1537 delay
= XFASTINT (Vimage_cache_eviction_delay
);
1539 delay
= max (1, 1600 * delay
/ (nimages
*nimages
));
1542 old
= EMACS_SECS (t
) - delay
;
1544 for (i
= 0; i
< c
->used
; ++i
)
1546 struct image
*img
= c
->images
[i
];
1547 if (img
&& img
->timestamp
< old
)
1549 free_image (f
, img
);
1555 /* We may be clearing the image cache because, for example,
1556 Emacs was iconified for a longer period of time. In that
1557 case, current matrices may still contain references to
1558 images freed above. So, clear these matrices. */
1561 Lisp_Object tail
, frame
;
1563 FOR_EACH_FRAME (tail
, frame
)
1565 struct frame
*fr
= XFRAME (frame
);
1566 if (FRAME_IMAGE_CACHE (fr
) == c
)
1567 clear_current_matrices (fr
);
1570 ++windows_or_buffers_changed
;
1578 clear_image_caches (Lisp_Object filter
)
1580 /* FIXME: We want to do
1581 * struct terminal *t;
1582 * for (t = terminal_list; t; t = t->next_terminal)
1583 * clear_image_cache (t, filter); */
1584 Lisp_Object tail
, frame
;
1585 FOR_EACH_FRAME (tail
, frame
)
1586 if (FRAME_WINDOW_P (XFRAME (frame
)))
1587 clear_image_cache (XFRAME (frame
), filter
);
1590 DEFUN ("clear-image-cache", Fclear_image_cache
, Sclear_image_cache
,
1592 doc
: /* Clear the image cache.
1593 FILTER nil or a frame means clear all images in the selected frame.
1594 FILTER t means clear the image caches of all frames.
1595 Anything else, means only clear those images which refer to FILTER,
1596 which is then usually a filename. */)
1597 (Lisp_Object filter
)
1599 if (!(EQ (filter
, Qnil
) || FRAMEP (filter
)))
1600 clear_image_caches (filter
);
1602 clear_image_cache (check_x_frame (filter
), Qt
);
1608 DEFUN ("image-flush", Fimage_flush
, Simage_flush
,
1610 doc
: /* Fush the image with specification SPEC on frame FRAME.
1611 This removes the image from the Emacs image cache. If SPEC specifies
1612 an image file, the next redisplay of this image will read from the
1613 current contents of that file.
1615 FRAME nil or omitted means use the selected frame.
1616 FRAME t means refresh the image on all frames. */)
1617 (Lisp_Object spec
, Lisp_Object frame
)
1619 if (!valid_image_p (spec
))
1620 error ("Invalid image specification");
1625 FOR_EACH_FRAME (tail
, frame
)
1627 struct frame
*f
= XFRAME (frame
);
1628 if (FRAME_WINDOW_P (f
))
1629 uncache_image (f
, spec
);
1633 uncache_image (check_x_frame (frame
), spec
);
1639 /* Compute masks and transform image IMG on frame F, as specified
1640 by the image's specification, */
1643 postprocess_image (struct frame
*f
, struct image
*img
)
1645 /* Manipulation of the image's mask. */
1648 Lisp_Object conversion
, spec
;
1653 /* `:heuristic-mask t'
1655 means build a mask heuristically.
1656 `:heuristic-mask (R G B)'
1657 `:mask (heuristic (R G B))'
1658 means build a mask from color (R G B) in the
1661 means remove a mask, if any. */
1663 mask
= image_spec_value (spec
, QCheuristic_mask
, NULL
);
1665 x_build_heuristic_mask (f
, img
, mask
);
1670 mask
= image_spec_value (spec
, QCmask
, &found_p
);
1672 if (EQ (mask
, Qheuristic
))
1673 x_build_heuristic_mask (f
, img
, Qt
);
1674 else if (CONSP (mask
)
1675 && EQ (XCAR (mask
), Qheuristic
))
1677 if (CONSP (XCDR (mask
)))
1678 x_build_heuristic_mask (f
, img
, XCAR (XCDR (mask
)));
1680 x_build_heuristic_mask (f
, img
, XCDR (mask
));
1682 else if (NILP (mask
) && found_p
&& img
->mask
)
1684 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
1685 img
->mask
= NO_PIXMAP
;
1690 /* Should we apply an image transformation algorithm? */
1691 conversion
= image_spec_value (spec
, QCconversion
, NULL
);
1692 if (EQ (conversion
, Qdisabled
))
1693 x_disable_image (f
, img
);
1694 else if (EQ (conversion
, Qlaplace
))
1696 else if (EQ (conversion
, Qemboss
))
1698 else if (CONSP (conversion
)
1699 && EQ (XCAR (conversion
), Qedge_detection
))
1702 tem
= XCDR (conversion
);
1704 x_edge_detection (f
, img
,
1705 Fplist_get (tem
, QCmatrix
),
1706 Fplist_get (tem
, QCcolor_adjustment
));
1712 /* Return the id of image with Lisp specification SPEC on frame F.
1713 SPEC must be a valid Lisp image specification (see valid_image_p). */
1716 lookup_image (struct frame
*f
, Lisp_Object spec
)
1722 /* F must be a window-system frame, and SPEC must be a valid image
1724 xassert (FRAME_WINDOW_P (f
));
1725 xassert (valid_image_p (spec
));
1727 /* Look up SPEC in the hash table of the image cache. */
1728 hash
= sxhash (spec
, 0);
1729 img
= search_image_cache (f
, spec
, hash
);
1730 if (img
&& img
->load_failed_p
)
1732 free_image (f
, img
);
1736 /* If not found, create a new image and cache it. */
1740 img
= make_image (spec
, hash
);
1741 cache_image (f
, img
);
1742 img
->load_failed_p
= img
->type
->load (f
, img
) == 0;
1743 img
->frame_foreground
= FRAME_FOREGROUND_PIXEL (f
);
1744 img
->frame_background
= FRAME_BACKGROUND_PIXEL (f
);
1746 /* If we can't load the image, and we don't have a width and
1747 height, use some arbitrary width and height so that we can
1748 draw a rectangle for it. */
1749 if (img
->load_failed_p
)
1753 value
= image_spec_value (spec
, QCwidth
, NULL
);
1754 img
->width
= (INTEGERP (value
)
1755 ? XFASTINT (value
) : DEFAULT_IMAGE_WIDTH
);
1756 value
= image_spec_value (spec
, QCheight
, NULL
);
1757 img
->height
= (INTEGERP (value
)
1758 ? XFASTINT (value
) : DEFAULT_IMAGE_HEIGHT
);
1762 /* Handle image type independent image attributes
1763 `:ascent ASCENT', `:margin MARGIN', `:relief RELIEF',
1764 `:background COLOR'. */
1765 Lisp_Object ascent
, margin
, relief
, bg
;
1767 ascent
= image_spec_value (spec
, QCascent
, NULL
);
1768 if (INTEGERP (ascent
))
1769 img
->ascent
= XFASTINT (ascent
);
1770 else if (EQ (ascent
, Qcenter
))
1771 img
->ascent
= CENTERED_IMAGE_ASCENT
;
1773 margin
= image_spec_value (spec
, QCmargin
, NULL
);
1774 if (INTEGERP (margin
) && XINT (margin
) >= 0)
1775 img
->vmargin
= img
->hmargin
= XFASTINT (margin
);
1776 else if (CONSP (margin
) && INTEGERP (XCAR (margin
))
1777 && INTEGERP (XCDR (margin
)))
1779 if (XINT (XCAR (margin
)) > 0)
1780 img
->hmargin
= XFASTINT (XCAR (margin
));
1781 if (XINT (XCDR (margin
)) > 0)
1782 img
->vmargin
= XFASTINT (XCDR (margin
));
1785 relief
= image_spec_value (spec
, QCrelief
, NULL
);
1786 if (INTEGERP (relief
))
1788 img
->relief
= XINT (relief
);
1789 img
->hmargin
+= eabs (img
->relief
);
1790 img
->vmargin
+= eabs (img
->relief
);
1793 if (! img
->background_valid
)
1795 bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
1799 = x_alloc_image_color (f
, img
, bg
,
1800 FRAME_BACKGROUND_PIXEL (f
));
1801 img
->background_valid
= 1;
1805 /* Do image transformations and compute masks, unless we
1806 don't have the image yet. */
1807 if (!EQ (*img
->type
->type
, Qpostscript
))
1808 postprocess_image (f
, img
);
1814 /* We're using IMG, so set its timestamp to `now'. */
1815 EMACS_GET_TIME (now
);
1816 img
->timestamp
= EMACS_SECS (now
);
1818 /* Value is the image id. */
1823 /* Cache image IMG in the image cache of frame F. */
1826 cache_image (struct frame
*f
, struct image
*img
)
1828 struct image_cache
*c
= FRAME_IMAGE_CACHE (f
);
1831 /* Find a free slot in c->images. */
1832 for (i
= 0; i
< c
->used
; ++i
)
1833 if (c
->images
[i
] == NULL
)
1836 /* If no free slot found, maybe enlarge c->images. */
1837 if (i
== c
->used
&& c
->used
== c
->size
)
1840 c
->images
= (struct image
**) xrealloc (c
->images
,
1841 c
->size
* sizeof *c
->images
);
1844 /* Add IMG to c->images, and assign IMG an id. */
1850 /* Add IMG to the cache's hash table. */
1851 i
= img
->hash
% IMAGE_CACHE_BUCKETS_SIZE
;
1852 img
->next
= c
->buckets
[i
];
1854 img
->next
->prev
= img
;
1856 c
->buckets
[i
] = img
;
1860 /* Call FN on every image in the image cache of frame F. Used to mark
1861 Lisp Objects in the image cache. */
1863 /* Mark Lisp objects in image IMG. */
1866 mark_image (struct image
*img
)
1868 mark_object (img
->spec
);
1869 mark_object (img
->dependencies
);
1871 if (!NILP (img
->lisp_data
))
1872 mark_object (img
->lisp_data
);
1877 mark_image_cache (struct image_cache
*c
)
1882 for (i
= 0; i
< c
->used
; ++i
)
1884 mark_image (c
->images
[i
]);
1890 /***********************************************************************
1891 X / NS / W32 support code
1892 ***********************************************************************/
1896 /* Macro for defining functions that will be loaded from image DLLs. */
1897 #define DEF_IMGLIB_FN(rettype,func,args) static rettype (FAR CDECL *fn_##func)args
1899 /* Macro for loading those image functions from the library. */
1900 #define LOAD_IMGLIB_FN(lib,func) { \
1901 fn_##func = (void *) GetProcAddress (lib, #func); \
1902 if (!fn_##func) return 0; \
1905 #endif /* HAVE_NTGUI */
1907 static int x_create_x_image_and_pixmap (struct frame
*, int, int, int,
1908 XImagePtr
*, Pixmap
*);
1909 static void x_destroy_x_image (XImagePtr
);
1910 static void x_put_x_image (struct frame
*, XImagePtr
, Pixmap
, int, int);
1913 /* Create an XImage and a pixmap of size WIDTH x HEIGHT for use on
1914 frame F. Set *XIMG and *PIXMAP to the XImage and Pixmap created.
1915 Set (*XIMG)->data to a raster of WIDTH x HEIGHT pixels allocated
1916 via xmalloc. Print error messages via image_error if an error
1917 occurs. Value is non-zero if successful.
1919 On W32, a DEPTH of zero signifies a 24 bit image, otherwise DEPTH
1920 should indicate the bit depth of the image. */
1923 x_create_x_image_and_pixmap (struct frame
*f
, int width
, int height
, int depth
,
1924 XImagePtr
*ximg
, Pixmap
*pixmap
)
1926 #ifdef HAVE_X_WINDOWS
1927 Display
*display
= FRAME_X_DISPLAY (f
);
1928 Window window
= FRAME_X_WINDOW (f
);
1929 Screen
*screen
= FRAME_X_SCREEN (f
);
1931 xassert (interrupt_input_blocked
);
1934 depth
= DefaultDepthOfScreen (screen
);
1935 *ximg
= XCreateImage (display
, DefaultVisualOfScreen (screen
),
1936 depth
, ZPixmap
, 0, NULL
, width
, height
,
1937 depth
> 16 ? 32 : depth
> 8 ? 16 : 8, 0);
1940 image_error ("Unable to allocate X image", Qnil
, Qnil
);
1944 /* Allocate image raster. */
1945 (*ximg
)->data
= (char *) xmalloc ((*ximg
)->bytes_per_line
* height
);
1947 /* Allocate a pixmap of the same size. */
1948 *pixmap
= XCreatePixmap (display
, window
, width
, height
, depth
);
1949 if (*pixmap
== NO_PIXMAP
)
1951 x_destroy_x_image (*ximg
);
1953 image_error ("Unable to create X pixmap", Qnil
, Qnil
);
1958 #endif /* HAVE_X_WINDOWS */
1962 BITMAPINFOHEADER
*header
;
1964 int scanline_width_bits
;
1966 int palette_colors
= 0;
1971 if (depth
!= 1 && depth
!= 4 && depth
!= 8
1972 && depth
!= 16 && depth
!= 24 && depth
!= 32)
1974 image_error ("Invalid image bit depth specified", Qnil
, Qnil
);
1978 scanline_width_bits
= width
* depth
;
1979 remainder
= scanline_width_bits
% 32;
1982 scanline_width_bits
+= 32 - remainder
;
1984 /* Bitmaps with a depth less than 16 need a palette. */
1985 /* BITMAPINFO structure already contains the first RGBQUAD. */
1987 palette_colors
= 1 << depth
- 1;
1989 *ximg
= xmalloc (sizeof (XImage
) + palette_colors
* sizeof (RGBQUAD
));
1992 image_error ("Unable to allocate memory for XImage", Qnil
, Qnil
);
1996 header
= &(*ximg
)->info
.bmiHeader
;
1997 memset (&(*ximg
)->info
, 0, sizeof (BITMAPINFO
));
1998 header
->biSize
= sizeof (*header
);
1999 header
->biWidth
= width
;
2000 header
->biHeight
= -height
; /* negative indicates a top-down bitmap. */
2001 header
->biPlanes
= 1;
2002 header
->biBitCount
= depth
;
2003 header
->biCompression
= BI_RGB
;
2004 header
->biClrUsed
= palette_colors
;
2006 /* TODO: fill in palette. */
2009 (*ximg
)->info
.bmiColors
[0].rgbBlue
= 0;
2010 (*ximg
)->info
.bmiColors
[0].rgbGreen
= 0;
2011 (*ximg
)->info
.bmiColors
[0].rgbRed
= 0;
2012 (*ximg
)->info
.bmiColors
[0].rgbReserved
= 0;
2013 (*ximg
)->info
.bmiColors
[1].rgbBlue
= 255;
2014 (*ximg
)->info
.bmiColors
[1].rgbGreen
= 255;
2015 (*ximg
)->info
.bmiColors
[1].rgbRed
= 255;
2016 (*ximg
)->info
.bmiColors
[1].rgbReserved
= 0;
2019 hdc
= get_frame_dc (f
);
2021 /* Create a DIBSection and raster array for the bitmap,
2022 and store its handle in *pixmap. */
2023 *pixmap
= CreateDIBSection (hdc
, &((*ximg
)->info
),
2024 (depth
< 16) ? DIB_PAL_COLORS
: DIB_RGB_COLORS
,
2025 /* casting avoids a GCC warning */
2026 (void **)&((*ximg
)->data
), NULL
, 0);
2028 /* Realize display palette and garbage all frames. */
2029 release_frame_dc (f
, hdc
);
2031 if (*pixmap
== NULL
)
2033 DWORD err
= GetLastError ();
2034 Lisp_Object errcode
;
2035 /* All system errors are < 10000, so the following is safe. */
2036 XSETINT (errcode
, (int) err
);
2037 image_error ("Unable to create bitmap, error code %d", errcode
, Qnil
);
2038 x_destroy_x_image (*ximg
);
2044 #endif /* HAVE_NTGUI */
2047 *pixmap
= ns_image_for_XPM (width
, height
, depth
);
2051 image_error ("Unable to allocate NSImage for XPM pixmap", Qnil
, Qnil
);
2060 /* Destroy XImage XIMG. Free XIMG->data. */
2063 x_destroy_x_image (XImagePtr ximg
)
2065 xassert (interrupt_input_blocked
);
2068 #ifdef HAVE_X_WINDOWS
2071 XDestroyImage (ximg
);
2072 #endif /* HAVE_X_WINDOWS */
2074 /* Data will be freed by DestroyObject. */
2077 #endif /* HAVE_NTGUI */
2079 ns_release_object (ximg
);
2080 #endif /* HAVE_NS */
2085 /* Put XImage XIMG into pixmap PIXMAP on frame F. WIDTH and HEIGHT
2086 are width and height of both the image and pixmap. */
2089 x_put_x_image (struct frame
*f
, XImagePtr ximg
, Pixmap pixmap
, int width
, int height
)
2091 #ifdef HAVE_X_WINDOWS
2094 xassert (interrupt_input_blocked
);
2095 gc
= XCreateGC (FRAME_X_DISPLAY (f
), pixmap
, 0, NULL
);
2096 XPutImage (FRAME_X_DISPLAY (f
), pixmap
, gc
, ximg
, 0, 0, 0, 0, width
, height
);
2097 XFreeGC (FRAME_X_DISPLAY (f
), gc
);
2098 #endif /* HAVE_X_WINDOWS */
2101 #if 0 /* I don't think this is necessary looking at where it is used. */
2102 HDC hdc
= get_frame_dc (f
);
2103 SetDIBits (hdc
, pixmap
, 0, height
, ximg
->data
, &(ximg
->info
), DIB_RGB_COLORS
);
2104 release_frame_dc (f
, hdc
);
2106 #endif /* HAVE_NTGUI */
2109 xassert (ximg
== pixmap
);
2110 ns_retain_object (ximg
);
2115 /***********************************************************************
2117 ***********************************************************************/
2119 /* Find image file FILE. Look in data-directory/images, then
2120 x-bitmap-file-path. Value is the encoded full name of the file
2121 found, or nil if not found. */
2124 x_find_image_file (Lisp_Object file
)
2126 Lisp_Object file_found
, search_path
;
2129 /* TODO I think this should use something like image-load-path
2130 instead. Unfortunately, that can contain non-string elements. */
2131 search_path
= Fcons (Fexpand_file_name (build_string ("images"),
2133 Vx_bitmap_file_path
);
2135 /* Try to find FILE in data-directory/images, then x-bitmap-file-path. */
2136 fd
= openp (search_path
, file
, Qnil
, &file_found
, Qnil
);
2142 file_found
= ENCODE_FILE (file_found
);
2150 /* Read FILE into memory. Value is a pointer to a buffer allocated
2151 with xmalloc holding FILE's contents. Value is null if an error
2152 occurred. *SIZE is set to the size of the file. */
2154 static unsigned char *
2155 slurp_file (char *file
, ptrdiff_t *size
)
2158 unsigned char *buf
= NULL
;
2161 if (stat (file
, &st
) == 0
2162 && (fp
= fopen (file
, "rb")) != NULL
2163 && 0 <= st
.st_size
&& st
.st_size
<= min (PTRDIFF_MAX
, SIZE_MAX
)
2164 && (buf
= (unsigned char *) xmalloc (st
.st_size
),
2165 fread (buf
, 1, st
.st_size
, fp
) == st
.st_size
))
2186 /***********************************************************************
2188 ***********************************************************************/
2190 static int xbm_scan (unsigned char **, unsigned char *, char *, int *);
2191 static int xbm_load (struct frame
*f
, struct image
*img
);
2192 static int xbm_load_image (struct frame
*f
, struct image
*img
,
2193 unsigned char *, unsigned char *);
2194 static int xbm_image_p (Lisp_Object object
);
2195 static int xbm_read_bitmap_data (struct frame
*f
,
2196 unsigned char *, unsigned char *,
2197 int *, int *, char **, int);
2198 static int xbm_file_p (Lisp_Object
);
2201 /* Indices of image specification fields in xbm_format, below. */
2203 enum xbm_keyword_index
2221 /* Vector of image_keyword structures describing the format
2222 of valid XBM image specifications. */
2224 static const struct image_keyword xbm_format
[XBM_LAST
] =
2226 {":type", IMAGE_SYMBOL_VALUE
, 1},
2227 {":file", IMAGE_STRING_VALUE
, 0},
2228 {":width", IMAGE_POSITIVE_INTEGER_VALUE
, 0},
2229 {":height", IMAGE_POSITIVE_INTEGER_VALUE
, 0},
2230 {":data", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
2231 {":foreground", IMAGE_STRING_OR_NIL_VALUE
, 0},
2232 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0},
2233 {":ascent", IMAGE_ASCENT_VALUE
, 0},
2234 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
2235 {":relief", IMAGE_INTEGER_VALUE
, 0},
2236 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
2237 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
2238 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0}
2241 /* Structure describing the image type XBM. */
2243 static struct image_type xbm_type
=
2252 /* Tokens returned from xbm_scan. */
2261 /* Return non-zero if OBJECT is a valid XBM-type image specification.
2262 A valid specification is a list starting with the symbol `image'
2263 The rest of the list is a property list which must contain an
2266 If the specification specifies a file to load, it must contain
2267 an entry `:file FILENAME' where FILENAME is a string.
2269 If the specification is for a bitmap loaded from memory it must
2270 contain `:width WIDTH', `:height HEIGHT', and `:data DATA', where
2271 WIDTH and HEIGHT are integers > 0. DATA may be:
2273 1. a string large enough to hold the bitmap data, i.e. it must
2274 have a size >= (WIDTH + 7) / 8 * HEIGHT
2276 2. a bool-vector of size >= WIDTH * HEIGHT
2278 3. a vector of strings or bool-vectors, one for each line of the
2281 4. a string containing an in-memory XBM file. WIDTH and HEIGHT
2282 may not be specified in this case because they are defined in the
2285 Both the file and data forms may contain the additional entries
2286 `:background COLOR' and `:foreground COLOR'. If not present,
2287 foreground and background of the frame on which the image is
2288 displayed is used. */
2291 xbm_image_p (Lisp_Object object
)
2293 struct image_keyword kw
[XBM_LAST
];
2295 memcpy (kw
, xbm_format
, sizeof kw
);
2296 if (!parse_image_spec (object
, kw
, XBM_LAST
, Qxbm
))
2299 xassert (EQ (kw
[XBM_TYPE
].value
, Qxbm
));
2301 if (kw
[XBM_FILE
].count
)
2303 if (kw
[XBM_WIDTH
].count
|| kw
[XBM_HEIGHT
].count
|| kw
[XBM_DATA
].count
)
2306 else if (kw
[XBM_DATA
].count
&& xbm_file_p (kw
[XBM_DATA
].value
))
2308 /* In-memory XBM file. */
2309 if (kw
[XBM_WIDTH
].count
|| kw
[XBM_HEIGHT
].count
|| kw
[XBM_FILE
].count
)
2315 EMACS_INT width
, height
;
2317 /* Entries for `:width', `:height' and `:data' must be present. */
2318 if (!kw
[XBM_WIDTH
].count
2319 || !kw
[XBM_HEIGHT
].count
2320 || !kw
[XBM_DATA
].count
)
2323 data
= kw
[XBM_DATA
].value
;
2324 width
= XFASTINT (kw
[XBM_WIDTH
].value
);
2325 height
= XFASTINT (kw
[XBM_HEIGHT
].value
);
2327 /* Check type of data, and width and height against contents of
2333 /* Number of elements of the vector must be >= height. */
2334 if (ASIZE (data
) < height
)
2337 /* Each string or bool-vector in data must be large enough
2338 for one line of the image. */
2339 for (i
= 0; i
< height
; ++i
)
2341 Lisp_Object elt
= XVECTOR (data
)->contents
[i
];
2346 < (width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
)
2349 else if (BOOL_VECTOR_P (elt
))
2351 if (XBOOL_VECTOR (elt
)->size
< width
)
2358 else if (STRINGP (data
))
2361 < (width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
* height
)
2364 else if (BOOL_VECTOR_P (data
))
2366 if (XBOOL_VECTOR (data
)->size
< width
* height
)
2377 /* Scan a bitmap file. FP is the stream to read from. Value is
2378 either an enumerator from enum xbm_token, or a character for a
2379 single-character token, or 0 at end of file. If scanning an
2380 identifier, store the lexeme of the identifier in SVAL. If
2381 scanning a number, store its value in *IVAL. */
2384 xbm_scan (unsigned char **s
, unsigned char *end
, char *sval
, int *ival
)
2390 /* Skip white space. */
2391 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
2396 else if (isdigit (c
))
2398 int value
= 0, digit
;
2400 if (c
== '0' && *s
< end
)
2403 if (c
== 'x' || c
== 'X')
2410 else if (c
>= 'a' && c
<= 'f')
2411 digit
= c
- 'a' + 10;
2412 else if (c
>= 'A' && c
<= 'F')
2413 digit
= c
- 'A' + 10;
2416 value
= 16 * value
+ digit
;
2419 else if (isdigit (c
))
2423 && (c
= *(*s
)++, isdigit (c
)))
2424 value
= 8 * value
+ c
- '0';
2431 && (c
= *(*s
)++, isdigit (c
)))
2432 value
= 10 * value
+ c
- '0';
2440 else if (isalpha (c
) || c
== '_')
2444 && (c
= *(*s
)++, (isalnum (c
) || c
== '_')))
2451 else if (c
== '/' && **s
== '*')
2453 /* C-style comment. */
2455 while (**s
&& (**s
!= '*' || *(*s
+ 1) != '/'))
2469 /* Create a Windows bitmap from X bitmap data. */
2471 w32_create_pixmap_from_bitmap_data (int width
, int height
, char *data
)
2473 static unsigned char swap_nibble
[16]
2474 = { 0x0, 0x8, 0x4, 0xc, /* 0000 1000 0100 1100 */
2475 0x2, 0xa, 0x6, 0xe, /* 0010 1010 0110 1110 */
2476 0x1, 0x9, 0x5, 0xd, /* 0001 1001 0101 1101 */
2477 0x3, 0xb, 0x7, 0xf }; /* 0011 1011 0111 1111 */
2479 unsigned char *bits
, *p
;
2482 w1
= (width
+ 7) / 8; /* nb of 8bits elt in X bitmap */
2483 w2
= ((width
+ 15) / 16) * 2; /* nb of 16bits elt in W32 bitmap */
2484 bits
= (unsigned char *) alloca (height
* w2
);
2485 memset (bits
, 0, height
* w2
);
2486 for (i
= 0; i
< height
; i
++)
2489 for (j
= 0; j
< w1
; j
++)
2491 /* Bitswap XBM bytes to match how Windows does things. */
2492 unsigned char c
= *data
++;
2493 *p
++ = (unsigned char)((swap_nibble
[c
& 0xf] << 4)
2494 | (swap_nibble
[(c
>>4) & 0xf]));
2497 bmp
= CreateBitmap (width
, height
, 1, 1, (char *) bits
);
2503 convert_mono_to_color_image (struct frame
*f
, struct image
*img
,
2504 COLORREF foreground
, COLORREF background
)
2506 HDC hdc
, old_img_dc
, new_img_dc
;
2507 HGDIOBJ old_prev
, new_prev
;
2510 hdc
= get_frame_dc (f
);
2511 old_img_dc
= CreateCompatibleDC (hdc
);
2512 new_img_dc
= CreateCompatibleDC (hdc
);
2513 new_pixmap
= CreateCompatibleBitmap (hdc
, img
->width
, img
->height
);
2514 release_frame_dc (f
, hdc
);
2515 old_prev
= SelectObject (old_img_dc
, img
->pixmap
);
2516 new_prev
= SelectObject (new_img_dc
, new_pixmap
);
2517 /* Windows convention for mono bitmaps is black = background,
2518 white = foreground. */
2519 SetTextColor (new_img_dc
, background
);
2520 SetBkColor (new_img_dc
, foreground
);
2522 BitBlt (new_img_dc
, 0, 0, img
->width
, img
->height
, old_img_dc
,
2525 SelectObject (old_img_dc
, old_prev
);
2526 SelectObject (new_img_dc
, new_prev
);
2527 DeleteDC (old_img_dc
);
2528 DeleteDC (new_img_dc
);
2529 DeleteObject (img
->pixmap
);
2530 if (new_pixmap
== 0)
2531 fprintf (stderr
, "Failed to convert image to color.\n");
2533 img
->pixmap
= new_pixmap
;
2536 #define XBM_BIT_SHUFFLE(b) (~(b))
2540 #define XBM_BIT_SHUFFLE(b) (b)
2542 #endif /* HAVE_NTGUI */
2546 Create_Pixmap_From_Bitmap_Data (struct frame
*f
, struct image
*img
, char *data
,
2547 RGB_PIXEL_COLOR fg
, RGB_PIXEL_COLOR bg
,
2548 int non_default_colors
)
2552 = w32_create_pixmap_from_bitmap_data (img
->width
, img
->height
, data
);
2554 /* If colors were specified, transfer the bitmap to a color one. */
2555 if (non_default_colors
)
2556 convert_mono_to_color_image (f
, img
, fg
, bg
);
2558 #elif defined (HAVE_NS)
2559 img
->pixmap
= ns_image_from_XBM (data
, img
->width
, img
->height
);
2563 = XCreatePixmapFromBitmapData (FRAME_X_DISPLAY (f
),
2566 img
->width
, img
->height
,
2568 DefaultDepthOfScreen (FRAME_X_SCREEN (f
)));
2569 #endif /* !HAVE_NTGUI && !HAVE_NS */
2574 /* Replacement for XReadBitmapFileData which isn't available under old
2575 X versions. CONTENTS is a pointer to a buffer to parse; END is the
2576 buffer's end. Set *WIDTH and *HEIGHT to the width and height of
2577 the image. Return in *DATA the bitmap data allocated with xmalloc.
2578 Value is non-zero if successful. DATA null means just test if
2579 CONTENTS looks like an in-memory XBM file. If INHIBIT_IMAGE_ERROR
2580 is non-zero, inhibit the call to image_error when the image size is
2581 invalid (the bitmap remains unread). */
2584 xbm_read_bitmap_data (struct frame
*f
, unsigned char *contents
, unsigned char *end
,
2585 int *width
, int *height
, char **data
,
2586 int inhibit_image_error
)
2588 unsigned char *s
= contents
;
2589 char buffer
[BUFSIZ
];
2592 int bytes_per_line
, i
, nbytes
;
2598 LA1 = xbm_scan (&s, end, buffer, &value)
2600 #define expect(TOKEN) \
2601 if (LA1 != (TOKEN)) \
2606 #define expect_ident(IDENT) \
2607 if (LA1 == XBM_TK_IDENT && strcmp (buffer, (IDENT)) == 0) \
2612 *width
= *height
= -1;
2615 LA1
= xbm_scan (&s
, end
, buffer
, &value
);
2617 /* Parse defines for width, height and hot-spots. */
2621 expect_ident ("define");
2622 expect (XBM_TK_IDENT
);
2624 if (LA1
== XBM_TK_NUMBER
)
2626 char *q
= strrchr (buffer
, '_');
2627 q
= q
? q
+ 1 : buffer
;
2628 if (strcmp (q
, "width") == 0)
2630 else if (strcmp (q
, "height") == 0)
2633 expect (XBM_TK_NUMBER
);
2636 if (!check_image_size (f
, *width
, *height
))
2638 if (!inhibit_image_error
)
2639 image_error ("Invalid image size (see `max-image-size')", Qnil
, Qnil
);
2642 else if (data
== NULL
)
2645 /* Parse bits. Must start with `static'. */
2646 expect_ident ("static");
2647 if (LA1
== XBM_TK_IDENT
)
2649 if (strcmp (buffer
, "unsigned") == 0)
2652 expect_ident ("char");
2654 else if (strcmp (buffer
, "short") == 0)
2658 if (*width
% 16 && *width
% 16 < 9)
2661 else if (strcmp (buffer
, "char") == 0)
2669 expect (XBM_TK_IDENT
);
2675 bytes_per_line
= (*width
+ 7) / 8 + padding_p
;
2676 nbytes
= bytes_per_line
* *height
;
2677 p
= *data
= (char *) xmalloc (nbytes
);
2681 for (i
= 0; i
< nbytes
; i
+= 2)
2684 expect (XBM_TK_NUMBER
);
2686 *p
++ = XBM_BIT_SHUFFLE (val
);
2687 if (!padding_p
|| ((i
+ 2) % bytes_per_line
))
2688 *p
++ = XBM_BIT_SHUFFLE (value
>> 8);
2690 if (LA1
== ',' || LA1
== '}')
2698 for (i
= 0; i
< nbytes
; ++i
)
2701 expect (XBM_TK_NUMBER
);
2703 *p
++ = XBM_BIT_SHUFFLE (val
);
2705 if (LA1
== ',' || LA1
== '}')
2730 /* Load XBM image IMG which will be displayed on frame F from buffer
2731 CONTENTS. END is the end of the buffer. Value is non-zero if
2735 xbm_load_image (struct frame
*f
, struct image
*img
, unsigned char *contents
,
2742 rc
= xbm_read_bitmap_data (f
, contents
, end
, &img
->width
, &img
->height
,
2746 unsigned long foreground
= FRAME_FOREGROUND_PIXEL (f
);
2747 unsigned long background
= FRAME_BACKGROUND_PIXEL (f
);
2748 int non_default_colors
= 0;
2751 xassert (img
->width
> 0 && img
->height
> 0);
2753 /* Get foreground and background colors, maybe allocate colors. */
2754 value
= image_spec_value (img
->spec
, QCforeground
, NULL
);
2757 foreground
= x_alloc_image_color (f
, img
, value
, foreground
);
2758 non_default_colors
= 1;
2760 value
= image_spec_value (img
->spec
, QCbackground
, NULL
);
2763 background
= x_alloc_image_color (f
, img
, value
, background
);
2764 img
->background
= background
;
2765 img
->background_valid
= 1;
2766 non_default_colors
= 1;
2769 Create_Pixmap_From_Bitmap_Data (f
, img
, data
,
2770 foreground
, background
,
2771 non_default_colors
);
2774 if (img
->pixmap
== NO_PIXMAP
)
2776 x_clear_image (f
, img
);
2777 image_error ("Unable to create X pixmap for `%s'", img
->spec
, Qnil
);
2783 image_error ("Error loading XBM image `%s'", img
->spec
, Qnil
);
2789 /* Value is non-zero if DATA looks like an in-memory XBM file. */
2792 xbm_file_p (Lisp_Object data
)
2795 return (STRINGP (data
)
2796 && xbm_read_bitmap_data (NULL
, SDATA (data
),
2797 (SDATA (data
) + SBYTES (data
)),
2802 /* Fill image IMG which is used on frame F with pixmap data. Value is
2803 non-zero if successful. */
2806 xbm_load (struct frame
*f
, struct image
*img
)
2809 Lisp_Object file_name
;
2811 xassert (xbm_image_p (img
->spec
));
2813 /* If IMG->spec specifies a file name, create a non-file spec from it. */
2814 file_name
= image_spec_value (img
->spec
, QCfile
, NULL
);
2815 if (STRINGP (file_name
))
2818 unsigned char *contents
;
2821 file
= x_find_image_file (file_name
);
2822 if (!STRINGP (file
))
2824 image_error ("Cannot find image file `%s'", file_name
, Qnil
);
2828 contents
= slurp_file (SSDATA (file
), &size
);
2829 if (contents
== NULL
)
2831 image_error ("Error loading XBM image `%s'", img
->spec
, Qnil
);
2835 success_p
= xbm_load_image (f
, img
, contents
, contents
+ size
);
2840 struct image_keyword fmt
[XBM_LAST
];
2842 unsigned long foreground
= FRAME_FOREGROUND_PIXEL (f
);
2843 unsigned long background
= FRAME_BACKGROUND_PIXEL (f
);
2844 int non_default_colors
= 0;
2847 int in_memory_file_p
= 0;
2849 /* See if data looks like an in-memory XBM file. */
2850 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
2851 in_memory_file_p
= xbm_file_p (data
);
2853 /* Parse the image specification. */
2854 memcpy (fmt
, xbm_format
, sizeof fmt
);
2855 parsed_p
= parse_image_spec (img
->spec
, fmt
, XBM_LAST
, Qxbm
);
2859 /* Get specified width, and height. */
2860 if (!in_memory_file_p
)
2862 img
->width
= XFASTINT (fmt
[XBM_WIDTH
].value
);
2863 img
->height
= XFASTINT (fmt
[XBM_HEIGHT
].value
);
2864 xassert (img
->width
> 0 && img
->height
> 0);
2867 /* Get foreground and background colors, maybe allocate colors. */
2868 if (fmt
[XBM_FOREGROUND
].count
2869 && STRINGP (fmt
[XBM_FOREGROUND
].value
))
2871 foreground
= x_alloc_image_color (f
, img
, fmt
[XBM_FOREGROUND
].value
,
2873 non_default_colors
= 1;
2876 if (fmt
[XBM_BACKGROUND
].count
2877 && STRINGP (fmt
[XBM_BACKGROUND
].value
))
2879 background
= x_alloc_image_color (f
, img
, fmt
[XBM_BACKGROUND
].value
,
2881 non_default_colors
= 1;
2884 if (in_memory_file_p
)
2885 success_p
= xbm_load_image (f
, img
, SDATA (data
),
2894 int nbytes
= (img
->width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
;
2896 p
= bits
= (char *) alloca (nbytes
* img
->height
);
2897 for (i
= 0; i
< img
->height
; ++i
, p
+= nbytes
)
2899 Lisp_Object line
= XVECTOR (data
)->contents
[i
];
2901 memcpy (p
, SDATA (line
), nbytes
);
2903 memcpy (p
, XBOOL_VECTOR (line
)->data
, nbytes
);
2906 else if (STRINGP (data
))
2907 bits
= SSDATA (data
);
2909 bits
= (char *) XBOOL_VECTOR (data
)->data
;
2915 /* Windows mono bitmaps are reversed compared with X. */
2916 invertedBits
= bits
;
2917 nbytes
= (img
->width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
2919 bits
= (char *) alloca (nbytes
);
2920 for (i
= 0; i
< nbytes
; i
++)
2921 bits
[i
] = XBM_BIT_SHUFFLE (invertedBits
[i
]);
2924 /* Create the pixmap. */
2926 Create_Pixmap_From_Bitmap_Data (f
, img
, bits
,
2927 foreground
, background
,
2928 non_default_colors
);
2933 image_error ("Unable to create pixmap for XBM image `%s'",
2935 x_clear_image (f
, img
);
2945 /***********************************************************************
2947 ***********************************************************************/
2949 #if defined (HAVE_XPM) || defined (HAVE_NS)
2951 static int xpm_image_p (Lisp_Object object
);
2952 static int xpm_load (struct frame
*f
, struct image
*img
);
2953 static int xpm_valid_color_symbols_p (Lisp_Object
);
2955 #endif /* HAVE_XPM || HAVE_NS */
2959 /* Indicate to xpm.h that we don't have Xlib. */
2961 /* simx.h in xpm defines XColor and XImage differently than Emacs. */
2962 /* It also defines Display the same way as Emacs, but gcc 3.3 still barfs. */
2963 #define XColor xpm_XColor
2964 #define XImage xpm_XImage
2965 #define Display xpm_Display
2966 #define PIXEL_ALREADY_TYPEDEFED
2967 #include "X11/xpm.h"
2972 #undef PIXEL_ALREADY_TYPEDEFED
2974 #include "X11/xpm.h"
2975 #endif /* HAVE_NTGUI */
2976 #endif /* HAVE_XPM */
2978 #if defined (HAVE_XPM) || defined (HAVE_NS)
2979 /* The symbol `xpm' identifying XPM-format images. */
2981 static Lisp_Object Qxpm
;
2983 /* Indices of image specification fields in xpm_format, below. */
2985 enum xpm_keyword_index
3001 /* Vector of image_keyword structures describing the format
3002 of valid XPM image specifications. */
3004 static const struct image_keyword xpm_format
[XPM_LAST
] =
3006 {":type", IMAGE_SYMBOL_VALUE
, 1},
3007 {":file", IMAGE_STRING_VALUE
, 0},
3008 {":data", IMAGE_STRING_VALUE
, 0},
3009 {":ascent", IMAGE_ASCENT_VALUE
, 0},
3010 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
3011 {":relief", IMAGE_INTEGER_VALUE
, 0},
3012 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3013 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3014 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3015 {":color-symbols", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3016 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
3019 /* Structure describing the image type XPM. */
3021 static struct image_type xpm_type
=
3030 #ifdef HAVE_X_WINDOWS
3032 /* Define ALLOC_XPM_COLORS if we can use Emacs' own color allocation
3033 functions for allocating image colors. Our own functions handle
3034 color allocation failures more gracefully than the ones on the XPM
3037 #if defined XpmAllocColor && defined XpmFreeColors && defined XpmColorClosure
3038 #define ALLOC_XPM_COLORS
3040 #endif /* HAVE_X_WINDOWS */
3042 #ifdef ALLOC_XPM_COLORS
3044 static void xpm_init_color_cache (struct frame
*, XpmAttributes
*);
3045 static void xpm_free_color_cache (void);
3046 static int xpm_lookup_color (struct frame
*, char *, XColor
*);
3047 static int xpm_color_bucket (char *);
3048 static struct xpm_cached_color
*xpm_cache_color (struct frame
*, char *,
3051 /* An entry in a hash table used to cache color definitions of named
3052 colors. This cache is necessary to speed up XPM image loading in
3053 case we do color allocations ourselves. Without it, we would need
3054 a call to XParseColor per pixel in the image. */
3056 struct xpm_cached_color
3058 /* Next in collision chain. */
3059 struct xpm_cached_color
*next
;
3061 /* Color definition (RGB and pixel color). */
3068 /* The hash table used for the color cache, and its bucket vector
3071 #define XPM_COLOR_CACHE_BUCKETS 1001
3072 static struct xpm_cached_color
**xpm_color_cache
;
3074 /* Initialize the color cache. */
3077 xpm_init_color_cache (struct frame
*f
, XpmAttributes
*attrs
)
3079 size_t nbytes
= XPM_COLOR_CACHE_BUCKETS
* sizeof *xpm_color_cache
;
3080 xpm_color_cache
= (struct xpm_cached_color
**) xmalloc (nbytes
);
3081 memset (xpm_color_cache
, 0, nbytes
);
3082 init_color_table ();
3084 if (attrs
->valuemask
& XpmColorSymbols
)
3089 for (i
= 0; i
< attrs
->numsymbols
; ++i
)
3090 if (XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
3091 attrs
->colorsymbols
[i
].value
, &color
))
3093 color
.pixel
= lookup_rgb_color (f
, color
.red
, color
.green
,
3095 xpm_cache_color (f
, attrs
->colorsymbols
[i
].name
, &color
, -1);
3100 /* Free the color cache. */
3103 xpm_free_color_cache (void)
3105 struct xpm_cached_color
*p
, *next
;
3108 for (i
= 0; i
< XPM_COLOR_CACHE_BUCKETS
; ++i
)
3109 for (p
= xpm_color_cache
[i
]; p
; p
= next
)
3115 xfree (xpm_color_cache
);
3116 xpm_color_cache
= NULL
;
3117 free_color_table ();
3120 /* Return the bucket index for color named COLOR_NAME in the color
3124 xpm_color_bucket (char *color_name
)
3129 for (s
= color_name
; *s
; ++s
)
3131 return h
%= XPM_COLOR_CACHE_BUCKETS
;
3135 /* On frame F, cache values COLOR for color with name COLOR_NAME.
3136 BUCKET, if >= 0, is a precomputed bucket index. Value is the cache
3139 static struct xpm_cached_color
*
3140 xpm_cache_color (struct frame
*f
, char *color_name
, XColor
*color
, int bucket
)
3143 struct xpm_cached_color
*p
;
3146 bucket
= xpm_color_bucket (color_name
);
3148 nbytes
= sizeof *p
+ strlen (color_name
);
3149 p
= (struct xpm_cached_color
*) xmalloc (nbytes
);
3150 strcpy (p
->name
, color_name
);
3152 p
->next
= xpm_color_cache
[bucket
];
3153 xpm_color_cache
[bucket
] = p
;
3157 /* Look up color COLOR_NAME for frame F in the color cache. If found,
3158 return the cached definition in *COLOR. Otherwise, make a new
3159 entry in the cache and allocate the color. Value is zero if color
3160 allocation failed. */
3163 xpm_lookup_color (struct frame
*f
, char *color_name
, XColor
*color
)
3165 struct xpm_cached_color
*p
;
3166 int h
= xpm_color_bucket (color_name
);
3168 for (p
= xpm_color_cache
[h
]; p
; p
= p
->next
)
3169 if (strcmp (p
->name
, color_name
) == 0)
3174 else if (XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
3177 color
->pixel
= lookup_rgb_color (f
, color
->red
, color
->green
,
3179 p
= xpm_cache_color (f
, color_name
, color
, h
);
3181 /* You get `opaque' at least from ImageMagick converting pbm to xpm
3182 with transparency, and it's useful. */
3183 else if (strcmp ("opaque", color_name
) == 0)
3185 memset (color
, 0, sizeof (XColor
)); /* Is this necessary/correct? */
3186 color
->pixel
= FRAME_FOREGROUND_PIXEL (f
);
3187 p
= xpm_cache_color (f
, color_name
, color
, h
);
3194 /* Callback for allocating color COLOR_NAME. Called from the XPM lib.
3195 CLOSURE is a pointer to the frame on which we allocate the
3196 color. Return in *COLOR the allocated color. Value is non-zero
3200 xpm_alloc_color (Display
*dpy
, Colormap cmap
, char *color_name
, XColor
*color
,
3203 return xpm_lookup_color ((struct frame
*) closure
, color_name
, color
);
3207 /* Callback for freeing NPIXELS colors contained in PIXELS. CLOSURE
3208 is a pointer to the frame on which we allocate the color. Value is
3209 non-zero if successful. */
3212 xpm_free_colors (Display
*dpy
, Colormap cmap
, Pixel
*pixels
, int npixels
, void *closure
)
3217 #endif /* ALLOC_XPM_COLORS */
3222 /* XPM library details. */
3224 DEF_IMGLIB_FN (void, XpmFreeAttributes
, (XpmAttributes
*));
3225 DEF_IMGLIB_FN (int, XpmCreateImageFromBuffer
, (Display
*, char *, xpm_XImage
**,
3226 xpm_XImage
**, XpmAttributes
*));
3227 DEF_IMGLIB_FN (int, XpmReadFileToImage
, (Display
*, char *, xpm_XImage
**,
3228 xpm_XImage
**, XpmAttributes
*));
3229 DEF_IMGLIB_FN (void, XImageFree
, (xpm_XImage
*));
3232 init_xpm_functions (Lisp_Object libraries
)
3236 if (!(library
= w32_delayed_load (libraries
, Qxpm
)))
3239 LOAD_IMGLIB_FN (library
, XpmFreeAttributes
);
3240 LOAD_IMGLIB_FN (library
, XpmCreateImageFromBuffer
);
3241 LOAD_IMGLIB_FN (library
, XpmReadFileToImage
);
3242 LOAD_IMGLIB_FN (library
, XImageFree
);
3246 #endif /* HAVE_NTGUI */
3249 /* Value is non-zero if COLOR_SYMBOLS is a valid color symbols list
3250 for XPM images. Such a list must consist of conses whose car and
3254 xpm_valid_color_symbols_p (Lisp_Object color_symbols
)
3256 while (CONSP (color_symbols
))
3258 Lisp_Object sym
= XCAR (color_symbols
);
3260 || !STRINGP (XCAR (sym
))
3261 || !STRINGP (XCDR (sym
)))
3263 color_symbols
= XCDR (color_symbols
);
3266 return NILP (color_symbols
);
3270 /* Value is non-zero if OBJECT is a valid XPM image specification. */
3273 xpm_image_p (Lisp_Object object
)
3275 struct image_keyword fmt
[XPM_LAST
];
3276 memcpy (fmt
, xpm_format
, sizeof fmt
);
3277 return (parse_image_spec (object
, fmt
, XPM_LAST
, Qxpm
)
3278 /* Either `:file' or `:data' must be present. */
3279 && fmt
[XPM_FILE
].count
+ fmt
[XPM_DATA
].count
== 1
3280 /* Either no `:color-symbols' or it's a list of conses
3281 whose car and cdr are strings. */
3282 && (fmt
[XPM_COLOR_SYMBOLS
].count
== 0
3283 || xpm_valid_color_symbols_p (fmt
[XPM_COLOR_SYMBOLS
].value
)));
3286 #endif /* HAVE_XPM || HAVE_NS */
3288 #if defined HAVE_XPM && defined HAVE_X_WINDOWS && !defined USE_GTK
3290 x_create_bitmap_from_xpm_data (struct frame
*f
, const char **bits
)
3292 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
3295 XpmAttributes attrs
;
3296 Pixmap bitmap
, mask
;
3298 memset (&attrs
, 0, sizeof attrs
);
3300 attrs
.visual
= FRAME_X_VISUAL (f
);
3301 attrs
.colormap
= FRAME_X_COLORMAP (f
);
3302 attrs
.valuemask
|= XpmVisual
;
3303 attrs
.valuemask
|= XpmColormap
;
3305 rc
= XpmCreatePixmapFromData (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3306 (char **) bits
, &bitmap
, &mask
, &attrs
);
3307 if (rc
!= XpmSuccess
)
3309 XpmFreeAttributes (&attrs
);
3313 id
= x_allocate_bitmap_record (f
);
3314 dpyinfo
->bitmaps
[id
- 1].pixmap
= bitmap
;
3315 dpyinfo
->bitmaps
[id
- 1].have_mask
= 1;
3316 dpyinfo
->bitmaps
[id
- 1].mask
= mask
;
3317 dpyinfo
->bitmaps
[id
- 1].file
= NULL
;
3318 dpyinfo
->bitmaps
[id
- 1].height
= attrs
.height
;
3319 dpyinfo
->bitmaps
[id
- 1].width
= attrs
.width
;
3320 dpyinfo
->bitmaps
[id
- 1].depth
= attrs
.depth
;
3321 dpyinfo
->bitmaps
[id
- 1].refcount
= 1;
3323 XpmFreeAttributes (&attrs
);
3326 #endif /* defined (HAVE_XPM) && defined (HAVE_X_WINDOWS) */
3328 /* Load image IMG which will be displayed on frame F. Value is
3329 non-zero if successful. */
3334 xpm_load (struct frame
*f
, struct image
*img
)
3337 XpmAttributes attrs
;
3338 Lisp_Object specified_file
, color_symbols
;
3341 xpm_XImage
* xpm_image
= NULL
, * xpm_mask
= NULL
;
3342 #endif /* HAVE_NTGUI */
3344 /* Configure the XPM lib. Use the visual of frame F. Allocate
3345 close colors. Return colors allocated. */
3346 memset (&attrs
, 0, sizeof attrs
);
3349 attrs
.visual
= FRAME_X_VISUAL (f
);
3350 attrs
.colormap
= FRAME_X_COLORMAP (f
);
3351 attrs
.valuemask
|= XpmVisual
;
3352 attrs
.valuemask
|= XpmColormap
;
3353 #endif /* HAVE_NTGUI */
3355 #ifdef ALLOC_XPM_COLORS
3356 /* Allocate colors with our own functions which handle
3357 failing color allocation more gracefully. */
3358 attrs
.color_closure
= f
;
3359 attrs
.alloc_color
= xpm_alloc_color
;
3360 attrs
.free_colors
= xpm_free_colors
;
3361 attrs
.valuemask
|= XpmAllocColor
| XpmFreeColors
| XpmColorClosure
;
3362 #else /* not ALLOC_XPM_COLORS */
3363 /* Let the XPM lib allocate colors. */
3364 attrs
.valuemask
|= XpmReturnAllocPixels
;
3365 #ifdef XpmAllocCloseColors
3366 attrs
.alloc_close_colors
= 1;
3367 attrs
.valuemask
|= XpmAllocCloseColors
;
3368 #else /* not XpmAllocCloseColors */
3369 attrs
.closeness
= 600;
3370 attrs
.valuemask
|= XpmCloseness
;
3371 #endif /* not XpmAllocCloseColors */
3372 #endif /* ALLOC_XPM_COLORS */
3374 /* If image specification contains symbolic color definitions, add
3375 these to `attrs'. */
3376 color_symbols
= image_spec_value (img
->spec
, QCcolor_symbols
, NULL
);
3377 if (CONSP (color_symbols
))
3380 XpmColorSymbol
*xpm_syms
;
3383 attrs
.valuemask
|= XpmColorSymbols
;
3385 /* Count number of symbols. */
3386 attrs
.numsymbols
= 0;
3387 for (tail
= color_symbols
; CONSP (tail
); tail
= XCDR (tail
))
3390 /* Allocate an XpmColorSymbol array. */
3391 size
= attrs
.numsymbols
* sizeof *xpm_syms
;
3392 xpm_syms
= (XpmColorSymbol
*) alloca (size
);
3393 memset (xpm_syms
, 0, size
);
3394 attrs
.colorsymbols
= xpm_syms
;
3396 /* Fill the color symbol array. */
3397 for (tail
= color_symbols
, i
= 0;
3399 ++i
, tail
= XCDR (tail
))
3403 char *empty_string
= (char *) "";
3405 if (!CONSP (XCAR (tail
)))
3407 xpm_syms
[i
].name
= empty_string
;
3408 xpm_syms
[i
].value
= empty_string
;
3411 name
= XCAR (XCAR (tail
));
3412 color
= XCDR (XCAR (tail
));
3415 xpm_syms
[i
].name
= (char *) alloca (SCHARS (name
) + 1);
3416 strcpy (xpm_syms
[i
].name
, SSDATA (name
));
3419 xpm_syms
[i
].name
= empty_string
;
3420 if (STRINGP (color
))
3422 xpm_syms
[i
].value
= (char *) alloca (SCHARS (color
) + 1);
3423 strcpy (xpm_syms
[i
].value
, SSDATA (color
));
3426 xpm_syms
[i
].value
= empty_string
;
3430 /* Create a pixmap for the image, either from a file, or from a
3431 string buffer containing data in the same format as an XPM file. */
3432 #ifdef ALLOC_XPM_COLORS
3433 xpm_init_color_cache (f
, &attrs
);
3436 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
3440 HDC frame_dc
= get_frame_dc (f
);
3441 hdc
= CreateCompatibleDC (frame_dc
);
3442 release_frame_dc (f
, frame_dc
);
3444 #endif /* HAVE_NTGUI */
3446 if (STRINGP (specified_file
))
3448 Lisp_Object file
= x_find_image_file (specified_file
);
3449 if (!STRINGP (file
))
3451 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
3452 #ifdef ALLOC_XPM_COLORS
3453 xpm_free_color_cache ();
3459 /* XpmReadFileToPixmap is not available in the Windows port of
3460 libxpm. But XpmReadFileToImage almost does what we want. */
3461 rc
= fn_XpmReadFileToImage (&hdc
, SDATA (file
),
3462 &xpm_image
, &xpm_mask
,
3465 rc
= XpmReadFileToPixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3466 SSDATA (file
), &img
->pixmap
, &img
->mask
,
3468 #endif /* HAVE_NTGUI */
3472 Lisp_Object buffer
= image_spec_value (img
->spec
, QCdata
, NULL
);
3473 if (!STRINGP (buffer
))
3475 image_error ("Invalid image data `%s'", buffer
, Qnil
);
3476 #ifdef ALLOC_XPM_COLORS
3477 xpm_free_color_cache ();
3482 /* XpmCreatePixmapFromBuffer is not available in the Windows port
3483 of libxpm. But XpmCreateImageFromBuffer almost does what we want. */
3484 rc
= fn_XpmCreateImageFromBuffer (&hdc
, SDATA (buffer
),
3485 &xpm_image
, &xpm_mask
,
3488 rc
= XpmCreatePixmapFromBuffer (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3490 &img
->pixmap
, &img
->mask
,
3492 #endif /* HAVE_NTGUI */
3495 if (rc
== XpmSuccess
)
3497 #if defined (COLOR_TABLE_SUPPORT) && defined (ALLOC_XPM_COLORS)
3498 img
->colors
= colors_in_color_table (&img
->ncolors
);
3499 #else /* not ALLOC_XPM_COLORS */
3503 /* W32 XPM uses XImage to wrap what W32 Emacs calls a Pixmap,
3504 plus some duplicate attributes. */
3505 if (xpm_image
&& xpm_image
->bitmap
)
3507 img
->pixmap
= xpm_image
->bitmap
;
3508 /* XImageFree in libXpm frees XImage struct without destroying
3509 the bitmap, which is what we want. */
3510 fn_XImageFree (xpm_image
);
3512 if (xpm_mask
&& xpm_mask
->bitmap
)
3514 /* The mask appears to be inverted compared with what we expect.
3515 TODO: invert our expectations. See other places where we
3516 have to invert bits because our idea of masks is backwards. */
3518 old_obj
= SelectObject (hdc
, xpm_mask
->bitmap
);
3520 PatBlt (hdc
, 0, 0, xpm_mask
->width
, xpm_mask
->height
, DSTINVERT
);
3521 SelectObject (hdc
, old_obj
);
3523 img
->mask
= xpm_mask
->bitmap
;
3524 fn_XImageFree (xpm_mask
);
3529 #endif /* HAVE_NTGUI */
3531 /* Remember allocated colors. */
3532 img
->ncolors
= attrs
.nalloc_pixels
;
3533 img
->colors
= (unsigned long *) xmalloc (img
->ncolors
3534 * sizeof *img
->colors
);
3535 for (i
= 0; i
< attrs
.nalloc_pixels
; ++i
)
3537 img
->colors
[i
] = attrs
.alloc_pixels
[i
];
3538 #ifdef DEBUG_X_COLORS
3539 register_color (img
->colors
[i
]);
3542 #endif /* not ALLOC_XPM_COLORS */
3544 img
->width
= attrs
.width
;
3545 img
->height
= attrs
.height
;
3546 xassert (img
->width
> 0 && img
->height
> 0);
3548 /* The call to XpmFreeAttributes below frees attrs.alloc_pixels. */
3550 fn_XpmFreeAttributes (&attrs
);
3552 XpmFreeAttributes (&attrs
);
3553 #endif /* HAVE_NTGUI */
3559 #endif /* HAVE_NTGUI */
3564 image_error ("Error opening XPM file (%s)", img
->spec
, Qnil
);
3567 case XpmFileInvalid
:
3568 image_error ("Invalid XPM file (%s)", img
->spec
, Qnil
);
3572 image_error ("Out of memory (%s)", img
->spec
, Qnil
);
3575 case XpmColorFailed
:
3576 image_error ("Color allocation error (%s)", img
->spec
, Qnil
);
3580 image_error ("Unknown error (%s)", img
->spec
, Qnil
);
3585 #ifdef ALLOC_XPM_COLORS
3586 xpm_free_color_cache ();
3588 return rc
== XpmSuccess
;
3591 #endif /* HAVE_XPM */
3593 #if defined (HAVE_NS) && !defined (HAVE_XPM)
3595 /* XPM support functions for NS where libxpm is not available.
3596 Only XPM version 3 (without any extensions) is supported. */
3598 static void xpm_put_color_table_v (Lisp_Object
, const unsigned char *,
3600 static Lisp_Object
xpm_get_color_table_v (Lisp_Object
,
3601 const unsigned char *, int);
3602 static void xpm_put_color_table_h (Lisp_Object
, const unsigned char *,
3604 static Lisp_Object
xpm_get_color_table_h (Lisp_Object
,
3605 const unsigned char *, int);
3607 /* Tokens returned from xpm_scan. */
3616 /* Scan an XPM data and return a character (< 256) or a token defined
3617 by enum xpm_token above. *S and END are the start (inclusive) and
3618 the end (exclusive) addresses of the data, respectively. Advance
3619 *S while scanning. If token is either XPM_TK_IDENT or
3620 XPM_TK_STRING, *BEG and *LEN are set to the start address and the
3621 length of the corresponding token, respectively. */
3624 xpm_scan (const unsigned char **s
,
3625 const unsigned char *end
,
3626 const unsigned char **beg
,
3633 /* Skip white-space. */
3634 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
3637 /* gnus-pointer.xpm uses '-' in its identifier.
3638 sb-dir-plus.xpm uses '+' in its identifier. */
3639 if (isalpha (c
) || c
== '_' || c
== '-' || c
== '+')
3643 && (c
= **s
, isalnum (c
) || c
== '_' || c
== '-' || c
== '+'))
3646 return XPM_TK_IDENT
;
3651 while (*s
< end
&& **s
!= '"')
3656 return XPM_TK_STRING
;
3660 if (*s
< end
&& **s
== '*')
3662 /* C-style comment. */
3666 while (*s
< end
&& *(*s
)++ != '*')
3669 while (*s
< end
&& **s
!= '/');
3683 /* Functions for color table lookup in XPM data. A key is a string
3684 specifying the color of each pixel in XPM data. A value is either
3685 an integer that specifies a pixel color, Qt that specifies
3686 transparency, or Qnil for the unspecified color. If the length of
3687 the key string is one, a vector is used as a table. Otherwise, a
3688 hash table is used. */
3691 xpm_make_color_table_v (void (**put_func
) (Lisp_Object
,
3692 const unsigned char *,
3695 Lisp_Object (**get_func
) (Lisp_Object
,
3696 const unsigned char *,
3699 *put_func
= xpm_put_color_table_v
;
3700 *get_func
= xpm_get_color_table_v
;
3701 return Fmake_vector (make_number (256), Qnil
);
3705 xpm_put_color_table_v (Lisp_Object color_table
,
3706 const unsigned char *chars_start
,
3710 XVECTOR (color_table
)->contents
[*chars_start
] = color
;
3714 xpm_get_color_table_v (Lisp_Object color_table
,
3715 const unsigned char *chars_start
,
3718 return XVECTOR (color_table
)->contents
[*chars_start
];
3722 xpm_make_color_table_h (void (**put_func
) (Lisp_Object
,
3723 const unsigned char *,
3726 Lisp_Object (**get_func
) (Lisp_Object
,
3727 const unsigned char *,
3730 *put_func
= xpm_put_color_table_h
;
3731 *get_func
= xpm_get_color_table_h
;
3732 return make_hash_table (Qequal
, make_number (DEFAULT_HASH_SIZE
),
3733 make_float (DEFAULT_REHASH_SIZE
),
3734 make_float (DEFAULT_REHASH_THRESHOLD
),
3739 xpm_put_color_table_h (Lisp_Object color_table
,
3740 const unsigned char *chars_start
,
3744 struct Lisp_Hash_Table
*table
= XHASH_TABLE (color_table
);
3745 EMACS_UINT hash_code
;
3746 Lisp_Object chars
= make_unibyte_string (chars_start
, chars_len
);
3748 hash_lookup (table
, chars
, &hash_code
);
3749 hash_put (table
, chars
, color
, hash_code
);
3753 xpm_get_color_table_h (Lisp_Object color_table
,
3754 const unsigned char *chars_start
,
3757 struct Lisp_Hash_Table
*table
= XHASH_TABLE (color_table
);
3758 int i
= hash_lookup (table
, make_unibyte_string (chars_start
, chars_len
),
3761 return i
>= 0 ? HASH_VALUE (table
, i
) : Qnil
;
3764 enum xpm_color_key
{
3772 static const char xpm_color_key_strings
[][4] = {"s", "m", "g4", "g", "c"};
3775 xpm_str_to_color_key (const char *s
)
3780 i
< sizeof xpm_color_key_strings
/ sizeof xpm_color_key_strings
[0];
3782 if (strcmp (xpm_color_key_strings
[i
], s
) == 0)
3788 xpm_load_image (struct frame
*f
,
3790 const unsigned char *contents
,
3791 const unsigned char *end
)
3793 const unsigned char *s
= contents
, *beg
, *str
;
3794 unsigned char buffer
[BUFSIZ
];
3795 int width
, height
, x
, y
;
3796 int num_colors
, chars_per_pixel
;
3799 void (*put_color_table
) (Lisp_Object
, const unsigned char *, int, Lisp_Object
);
3800 Lisp_Object (*get_color_table
) (Lisp_Object
, const unsigned char *, int);
3801 Lisp_Object frame
, color_symbols
, color_table
;
3802 int best_key
, have_mask
= 0;
3803 XImagePtr ximg
= NULL
, mask_img
= NULL
;
3806 LA1 = xpm_scan (&s, end, &beg, &len)
3808 #define expect(TOKEN) \
3809 if (LA1 != (TOKEN)) \
3814 #define expect_ident(IDENT) \
3815 if (LA1 == XPM_TK_IDENT \
3816 && strlen ((IDENT)) == len && memcmp ((IDENT), beg, len) == 0) \
3821 if (!(end
- s
>= 9 && memcmp (s
, "/* XPM */", 9) == 0))
3825 expect_ident ("static");
3826 expect_ident ("char");
3828 expect (XPM_TK_IDENT
);
3833 expect (XPM_TK_STRING
);
3836 memcpy (buffer
, beg
, len
);
3838 if (sscanf (buffer
, "%d %d %d %d", &width
, &height
,
3839 &num_colors
, &chars_per_pixel
) != 4
3840 || width
<= 0 || height
<= 0
3841 || num_colors
<= 0 || chars_per_pixel
<= 0)
3844 if (!check_image_size (f
, width
, height
))
3846 image_error ("Invalid image size (see `max-image-size')", Qnil
, Qnil
);
3852 XSETFRAME (frame
, f
);
3853 if (!NILP (Fxw_display_color_p (frame
)))
3854 best_key
= XPM_COLOR_KEY_C
;
3855 else if (!NILP (Fx_display_grayscale_p (frame
)))
3856 best_key
= (XFASTINT (Fx_display_planes (frame
)) > 2
3857 ? XPM_COLOR_KEY_G
: XPM_COLOR_KEY_G4
);
3859 best_key
= XPM_COLOR_KEY_M
;
3861 color_symbols
= image_spec_value (img
->spec
, QCcolor_symbols
, NULL
);
3862 if (chars_per_pixel
== 1)
3863 color_table
= xpm_make_color_table_v (&put_color_table
,
3866 color_table
= xpm_make_color_table_h (&put_color_table
,
3869 while (num_colors
-- > 0)
3871 char *color
, *max_color
;
3872 int key
, next_key
, max_key
= 0;
3873 Lisp_Object symbol_color
= Qnil
, color_val
;
3876 expect (XPM_TK_STRING
);
3877 if (len
<= chars_per_pixel
|| len
>= BUFSIZ
+ chars_per_pixel
)
3879 memcpy (buffer
, beg
+ chars_per_pixel
, len
- chars_per_pixel
);
3880 buffer
[len
- chars_per_pixel
] = '\0';
3882 str
= strtok (buffer
, " \t");
3885 key
= xpm_str_to_color_key (str
);
3890 color
= strtok (NULL
, " \t");
3894 while ((str
= strtok (NULL
, " \t")) != NULL
)
3896 next_key
= xpm_str_to_color_key (str
);
3899 color
[strlen (color
)] = ' ';
3902 if (key
== XPM_COLOR_KEY_S
)
3904 if (NILP (symbol_color
))
3905 symbol_color
= build_string (color
);
3907 else if (max_key
< key
&& key
<= best_key
)
3917 if (!NILP (color_symbols
) && !NILP (symbol_color
))
3919 Lisp_Object specified_color
= Fassoc (symbol_color
, color_symbols
);
3921 if (CONSP (specified_color
) && STRINGP (XCDR (specified_color
)))
3923 if (xstrcasecmp (SSDATA (XCDR (specified_color
)), "None") == 0)
3925 else if (x_defined_color (f
, SDATA (XCDR (specified_color
)),
3927 color_val
= make_number (cdef
.pixel
);
3930 if (NILP (color_val
) && max_key
> 0)
3932 if (xstrcasecmp (max_color
, "None") == 0)
3934 else if (x_defined_color (f
, max_color
, &cdef
, 0))
3935 color_val
= make_number (cdef
.pixel
);
3937 if (!NILP (color_val
))
3938 (*put_color_table
) (color_table
, beg
, chars_per_pixel
, color_val
);
3943 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0,
3944 &ximg
, &img
->pixmap
)
3946 || !x_create_x_image_and_pixmap (f
, width
, height
, 1,
3947 &mask_img
, &img
->mask
)
3951 image_error ("Out of memory (%s)", img
->spec
, Qnil
);
3955 for (y
= 0; y
< height
; y
++)
3957 expect (XPM_TK_STRING
);
3959 if (len
< width
* chars_per_pixel
)
3961 for (x
= 0; x
< width
; x
++, str
+= chars_per_pixel
)
3963 Lisp_Object color_val
=
3964 (*get_color_table
) (color_table
, str
, chars_per_pixel
);
3966 XPutPixel (ximg
, x
, y
,
3967 (INTEGERP (color_val
) ? XINT (color_val
)
3968 : FRAME_FOREGROUND_PIXEL (f
)));
3970 XPutPixel (mask_img
, x
, y
,
3971 (!EQ (color_val
, Qt
) ? PIX_MASK_DRAW
3972 : (have_mask
= 1, PIX_MASK_RETAIN
)));
3974 if (EQ (color_val
, Qt
))
3975 ns_set_alpha (ximg
, x
, y
, 0);
3983 img
->height
= height
;
3985 /* Maybe fill in the background field while we have ximg handy. */
3986 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
3987 IMAGE_BACKGROUND (img
, f
, ximg
);
3989 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
3990 x_destroy_x_image (ximg
);
3994 /* Fill in the background_transparent field while we have the
3996 image_background_transparent (img
, f
, mask_img
);
3998 x_put_x_image (f
, mask_img
, img
->mask
, width
, height
);
3999 x_destroy_x_image (mask_img
);
4003 x_destroy_x_image (mask_img
);
4004 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
4005 img
->mask
= NO_PIXMAP
;
4011 image_error ("Invalid XPM file (%s)", img
->spec
, Qnil
);
4013 x_destroy_x_image (ximg
);
4014 x_destroy_x_image (mask_img
);
4015 x_clear_image (f
, img
);
4024 xpm_load (struct frame
*f
,
4028 Lisp_Object file_name
;
4030 /* If IMG->spec specifies a file name, create a non-file spec from it. */
4031 file_name
= image_spec_value (img
->spec
, QCfile
, NULL
);
4032 if (STRINGP (file_name
))
4035 unsigned char *contents
;
4038 file
= x_find_image_file (file_name
);
4039 if (!STRINGP (file
))
4041 image_error ("Cannot find image file `%s'", file_name
, Qnil
);
4045 contents
= slurp_file (SDATA (file
), &size
);
4046 if (contents
== NULL
)
4048 image_error ("Error loading XPM image `%s'", img
->spec
, Qnil
);
4052 success_p
= xpm_load_image (f
, img
, contents
, contents
+ size
);
4059 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
4060 if (!STRINGP (data
))
4062 image_error ("Invalid image data `%s'", data
, Qnil
);
4065 success_p
= xpm_load_image (f
, img
, SDATA (data
),
4066 SDATA (data
) + SBYTES (data
));
4072 #endif /* HAVE_NS && !HAVE_XPM */
4076 /***********************************************************************
4078 ***********************************************************************/
4080 #ifdef COLOR_TABLE_SUPPORT
4082 /* An entry in the color table mapping an RGB color to a pixel color. */
4087 unsigned long pixel
;
4089 /* Next in color table collision list. */
4090 struct ct_color
*next
;
4093 /* The bucket vector size to use. Must be prime. */
4097 /* Value is a hash of the RGB color given by R, G, and B. */
4099 #define CT_HASH_RGB(R, G, B) (((R) << 16) ^ ((G) << 8) ^ (B))
4101 /* The color hash table. */
4103 static struct ct_color
**ct_table
;
4105 /* Number of entries in the color table. */
4107 static int ct_colors_allocated
;
4109 /* Initialize the color table. */
4112 init_color_table (void)
4114 int size
= CT_SIZE
* sizeof (*ct_table
);
4115 ct_table
= (struct ct_color
**) xmalloc (size
);
4116 memset (ct_table
, 0, size
);
4117 ct_colors_allocated
= 0;
4121 /* Free memory associated with the color table. */
4124 free_color_table (void)
4127 struct ct_color
*p
, *next
;
4129 for (i
= 0; i
< CT_SIZE
; ++i
)
4130 for (p
= ct_table
[i
]; p
; p
= next
)
4141 /* Value is a pixel color for RGB color R, G, B on frame F. If an
4142 entry for that color already is in the color table, return the
4143 pixel color of that entry. Otherwise, allocate a new color for R,
4144 G, B, and make an entry in the color table. */
4146 static unsigned long
4147 lookup_rgb_color (struct frame
*f
, int r
, int g
, int b
)
4149 unsigned hash
= CT_HASH_RGB (r
, g
, b
);
4150 int i
= hash
% CT_SIZE
;
4152 Display_Info
*dpyinfo
;
4154 /* Handle TrueColor visuals specially, which improves performance by
4155 two orders of magnitude. Freeing colors on TrueColor visuals is
4156 a nop, and pixel colors specify RGB values directly. See also
4157 the Xlib spec, chapter 3.1. */
4158 dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
4159 if (dpyinfo
->red_bits
> 0)
4161 unsigned long pr
, pg
, pb
;
4163 /* Apply gamma-correction like normal color allocation does. */
4167 color
.red
= r
, color
.green
= g
, color
.blue
= b
;
4168 gamma_correct (f
, &color
);
4169 r
= color
.red
, g
= color
.green
, b
= color
.blue
;
4172 /* Scale down RGB values to the visual's bits per RGB, and shift
4173 them to the right position in the pixel color. Note that the
4174 original RGB values are 16-bit values, as usual in X. */
4175 pr
= (r
>> (16 - dpyinfo
->red_bits
)) << dpyinfo
->red_offset
;
4176 pg
= (g
>> (16 - dpyinfo
->green_bits
)) << dpyinfo
->green_offset
;
4177 pb
= (b
>> (16 - dpyinfo
->blue_bits
)) << dpyinfo
->blue_offset
;
4179 /* Assemble the pixel color. */
4180 return pr
| pg
| pb
;
4183 for (p
= ct_table
[i
]; p
; p
= p
->next
)
4184 if (p
->r
== r
&& p
->g
== g
&& p
->b
== b
)
4190 #ifdef HAVE_X_WINDOWS
4199 cmap
= FRAME_X_COLORMAP (f
);
4200 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
4203 ++ct_colors_allocated
;
4204 p
= (struct ct_color
*) xmalloc (sizeof *p
);
4208 p
->pixel
= color
.pixel
;
4209 p
->next
= ct_table
[i
];
4213 return FRAME_FOREGROUND_PIXEL (f
);
4218 color
= PALETTERGB (r
, g
, b
);
4220 color
= RGB_TO_ULONG (r
, g
, b
);
4221 #endif /* HAVE_NTGUI */
4222 ++ct_colors_allocated
;
4223 p
= (struct ct_color
*) xmalloc (sizeof *p
);
4228 p
->next
= ct_table
[i
];
4230 #endif /* HAVE_X_WINDOWS */
4238 /* Look up pixel color PIXEL which is used on frame F in the color
4239 table. If not already present, allocate it. Value is PIXEL. */
4241 static unsigned long
4242 lookup_pixel_color (struct frame
*f
, unsigned long pixel
)
4244 int i
= pixel
% CT_SIZE
;
4247 for (p
= ct_table
[i
]; p
; p
= p
->next
)
4248 if (p
->pixel
== pixel
)
4257 #ifdef HAVE_X_WINDOWS
4258 cmap
= FRAME_X_COLORMAP (f
);
4259 color
.pixel
= pixel
;
4260 x_query_color (f
, &color
);
4261 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
4264 cmap
= DefaultColormapOfScreen (FRAME_X_SCREEN (f
));
4265 color
.pixel
= pixel
;
4266 XQueryColor (NULL
, cmap
, &color
);
4267 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
4269 #endif /* HAVE_X_WINDOWS */
4273 ++ct_colors_allocated
;
4275 p
= (struct ct_color
*) xmalloc (sizeof *p
);
4280 p
->next
= ct_table
[i
];
4284 return FRAME_FOREGROUND_PIXEL (f
);
4290 /* Value is a vector of all pixel colors contained in the color table,
4291 allocated via xmalloc. Set *N to the number of colors. */
4293 static unsigned long *
4294 colors_in_color_table (int *n
)
4298 unsigned long *colors
;
4300 if (ct_colors_allocated
== 0)
4307 colors
= (unsigned long *) xmalloc (ct_colors_allocated
4309 *n
= ct_colors_allocated
;
4311 for (i
= j
= 0; i
< CT_SIZE
; ++i
)
4312 for (p
= ct_table
[i
]; p
; p
= p
->next
)
4313 colors
[j
++] = p
->pixel
;
4319 #else /* COLOR_TABLE_SUPPORT */
4321 static unsigned long
4322 lookup_rgb_color (struct frame
*f
, int r
, int g
, int b
)
4324 unsigned long pixel
;
4327 pixel
= PALETTERGB (r
>> 8, g
>> 8, b
>> 8);
4328 #endif /* HAVE_NTGUI */
4331 pixel
= RGB_TO_ULONG (r
>> 8, g
>> 8, b
>> 8);
4332 #endif /* HAVE_NS */
4337 init_color_table (void)
4340 #endif /* COLOR_TABLE_SUPPORT */
4343 /***********************************************************************
4345 ***********************************************************************/
4347 static XColor
*x_to_xcolors (struct frame
*, struct image
*, int);
4348 static void x_from_xcolors (struct frame
*, struct image
*, XColor
*);
4349 static void x_detect_edges (struct frame
*, struct image
*, int[9], int);
4352 static void XPutPixel (XImagePtr
, int, int, COLORREF
);
4353 #endif /* HAVE_NTGUI */
4355 /* Edge detection matrices for different edge-detection
4358 static int emboss_matrix
[9] = {
4360 2, -1, 0, /* y - 1 */
4362 0, 1, -2 /* y + 1 */
4365 static int laplace_matrix
[9] = {
4367 1, 0, 0, /* y - 1 */
4369 0, 0, -1 /* y + 1 */
4372 /* Value is the intensity of the color whose red/green/blue values
4375 #define COLOR_INTENSITY(R, G, B) ((2 * (R) + 3 * (G) + (B)) / 6)
4378 /* On frame F, return an array of XColor structures describing image
4379 IMG->pixmap. Each XColor structure has its pixel color set. RGB_P
4380 non-zero means also fill the red/green/blue members of the XColor
4381 structures. Value is a pointer to the array of XColors structures,
4382 allocated with xmalloc; it must be freed by the caller. */
4385 x_to_xcolors (struct frame
*f
, struct image
*img
, int rgb_p
)
4389 XImagePtr_or_DC ximg
;
4393 #endif /* HAVE_NTGUI */
4395 colors
= (XColor
*) xmalloc (img
->width
* img
->height
* sizeof *colors
);
4398 /* Get the X image IMG->pixmap. */
4399 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
4400 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
4402 /* Load the image into a memory device context. */
4403 hdc
= get_frame_dc (f
);
4404 ximg
= CreateCompatibleDC (hdc
);
4405 release_frame_dc (f
, hdc
);
4406 prev
= SelectObject (ximg
, img
->pixmap
);
4407 #endif /* HAVE_NTGUI */
4409 /* Fill the `pixel' members of the XColor array. I wished there
4410 were an easy and portable way to circumvent XGetPixel. */
4412 for (y
= 0; y
< img
->height
; ++y
)
4416 #if defined (HAVE_X_WINDOWS) || defined (HAVE_NTGUI)
4417 for (x
= 0; x
< img
->width
; ++x
, ++p
)
4418 p
->pixel
= GET_PIXEL (ximg
, x
, y
);
4420 x_query_colors (f
, row
, img
->width
);
4424 for (x
= 0; x
< img
->width
; ++x
, ++p
)
4426 /* W32_TODO: palette support needed here? */
4427 p
->pixel
= GET_PIXEL (ximg
, x
, y
);
4430 p
->red
= RED16_FROM_ULONG (p
->pixel
);
4431 p
->green
= GREEN16_FROM_ULONG (p
->pixel
);
4432 p
->blue
= BLUE16_FROM_ULONG (p
->pixel
);
4435 #endif /* HAVE_X_WINDOWS */
4438 Destroy_Image (ximg
, prev
);
4445 /* Put a pixel of COLOR at position X, Y in XIMG. XIMG must have been
4446 created with CreateDIBSection, with the pointer to the bit values
4447 stored in ximg->data. */
4450 XPutPixel (XImagePtr ximg
, int x
, int y
, COLORREF color
)
4452 int width
= ximg
->info
.bmiHeader
.biWidth
;
4453 unsigned char * pixel
;
4455 /* True color images. */
4456 if (ximg
->info
.bmiHeader
.biBitCount
== 24)
4458 int rowbytes
= width
* 3;
4459 /* Ensure scanlines are aligned on 4 byte boundaries. */
4461 rowbytes
+= 4 - (rowbytes
% 4);
4463 pixel
= ximg
->data
+ y
* rowbytes
+ x
* 3;
4464 /* Windows bitmaps are in BGR order. */
4465 *pixel
= GetBValue (color
);
4466 *(pixel
+ 1) = GetGValue (color
);
4467 *(pixel
+ 2) = GetRValue (color
);
4469 /* Monochrome images. */
4470 else if (ximg
->info
.bmiHeader
.biBitCount
== 1)
4472 int rowbytes
= width
/ 8;
4473 /* Ensure scanlines are aligned on 4 byte boundaries. */
4475 rowbytes
+= 4 - (rowbytes
% 4);
4476 pixel
= ximg
->data
+ y
* rowbytes
+ x
/ 8;
4477 /* Filter out palette info. */
4478 if (color
& 0x00ffffff)
4479 *pixel
= *pixel
| (1 << x
% 8);
4481 *pixel
= *pixel
& ~(1 << x
% 8);
4484 image_error ("XPutPixel: palette image not supported", Qnil
, Qnil
);
4487 #endif /* HAVE_NTGUI */
4489 /* Create IMG->pixmap from an array COLORS of XColor structures, whose
4490 RGB members are set. F is the frame on which this all happens.
4491 COLORS will be freed; an existing IMG->pixmap will be freed, too. */
4494 x_from_xcolors (struct frame
*f
, struct image
*img
, XColor
*colors
)
4497 XImagePtr oimg
= NULL
;
4501 init_color_table ();
4503 x_create_x_image_and_pixmap (f
, img
->width
, img
->height
, 0,
4506 for (y
= 0; y
< img
->height
; ++y
)
4507 for (x
= 0; x
< img
->width
; ++x
, ++p
)
4509 unsigned long pixel
;
4510 pixel
= lookup_rgb_color (f
, p
->red
, p
->green
, p
->blue
);
4511 XPutPixel (oimg
, x
, y
, pixel
);
4515 x_clear_image_1 (f
, img
, 1, 0, 1);
4517 x_put_x_image (f
, oimg
, pixmap
, img
->width
, img
->height
);
4518 x_destroy_x_image (oimg
);
4519 img
->pixmap
= pixmap
;
4520 #ifdef COLOR_TABLE_SUPPORT
4521 img
->colors
= colors_in_color_table (&img
->ncolors
);
4522 free_color_table ();
4523 #endif /* COLOR_TABLE_SUPPORT */
4527 /* On frame F, perform edge-detection on image IMG.
4529 MATRIX is a nine-element array specifying the transformation
4530 matrix. See emboss_matrix for an example.
4532 COLOR_ADJUST is a color adjustment added to each pixel of the
4536 x_detect_edges (struct frame
*f
, struct image
*img
, int *matrix
, int color_adjust
)
4538 XColor
*colors
= x_to_xcolors (f
, img
, 1);
4542 for (i
= sum
= 0; i
< 9; ++i
)
4543 sum
+= eabs (matrix
[i
]);
4545 #define COLOR(A, X, Y) ((A) + (Y) * img->width + (X))
4547 new = (XColor
*) xmalloc (img
->width
* img
->height
* sizeof *new);
4549 for (y
= 0; y
< img
->height
; ++y
)
4551 p
= COLOR (new, 0, y
);
4552 p
->red
= p
->green
= p
->blue
= 0xffff/2;
4553 p
= COLOR (new, img
->width
- 1, y
);
4554 p
->red
= p
->green
= p
->blue
= 0xffff/2;
4557 for (x
= 1; x
< img
->width
- 1; ++x
)
4559 p
= COLOR (new, x
, 0);
4560 p
->red
= p
->green
= p
->blue
= 0xffff/2;
4561 p
= COLOR (new, x
, img
->height
- 1);
4562 p
->red
= p
->green
= p
->blue
= 0xffff/2;
4565 for (y
= 1; y
< img
->height
- 1; ++y
)
4567 p
= COLOR (new, 1, y
);
4569 for (x
= 1; x
< img
->width
- 1; ++x
, ++p
)
4571 int r
, g
, b
, yy
, xx
;
4574 for (yy
= y
- 1; yy
< y
+ 2; ++yy
)
4575 for (xx
= x
- 1; xx
< x
+ 2; ++xx
, ++i
)
4578 XColor
*t
= COLOR (colors
, xx
, yy
);
4579 r
+= matrix
[i
] * t
->red
;
4580 g
+= matrix
[i
] * t
->green
;
4581 b
+= matrix
[i
] * t
->blue
;
4584 r
= (r
/ sum
+ color_adjust
) & 0xffff;
4585 g
= (g
/ sum
+ color_adjust
) & 0xffff;
4586 b
= (b
/ sum
+ color_adjust
) & 0xffff;
4587 p
->red
= p
->green
= p
->blue
= COLOR_INTENSITY (r
, g
, b
);
4592 x_from_xcolors (f
, img
, new);
4598 /* Perform the pre-defined `emboss' edge-detection on image IMG
4602 x_emboss (struct frame
*f
, struct image
*img
)
4604 x_detect_edges (f
, img
, emboss_matrix
, 0xffff / 2);
4608 /* Transform image IMG which is used on frame F with a Laplace
4609 edge-detection algorithm. The result is an image that can be used
4610 to draw disabled buttons, for example. */
4613 x_laplace (struct frame
*f
, struct image
*img
)
4615 x_detect_edges (f
, img
, laplace_matrix
, 45000);
4619 /* Perform edge-detection on image IMG on frame F, with specified
4620 transformation matrix MATRIX and color-adjustment COLOR_ADJUST.
4622 MATRIX must be either
4624 - a list of at least 9 numbers in row-major form
4625 - a vector of at least 9 numbers
4627 COLOR_ADJUST nil means use a default; otherwise it must be a
4631 x_edge_detection (struct frame
*f
, struct image
*img
, Lisp_Object matrix
,
4632 Lisp_Object color_adjust
)
4640 i
< 9 && CONSP (matrix
) && NUMBERP (XCAR (matrix
));
4641 ++i
, matrix
= XCDR (matrix
))
4642 trans
[i
] = XFLOATINT (XCAR (matrix
));
4644 else if (VECTORP (matrix
) && ASIZE (matrix
) >= 9)
4646 for (i
= 0; i
< 9 && NUMBERP (AREF (matrix
, i
)); ++i
)
4647 trans
[i
] = XFLOATINT (AREF (matrix
, i
));
4650 if (NILP (color_adjust
))
4651 color_adjust
= make_number (0xffff / 2);
4653 if (i
== 9 && NUMBERP (color_adjust
))
4654 x_detect_edges (f
, img
, trans
, XFLOATINT (color_adjust
));
4658 /* Transform image IMG on frame F so that it looks disabled. */
4661 x_disable_image (struct frame
*f
, struct image
*img
)
4663 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
4665 int n_planes
= dpyinfo
->n_planes
* dpyinfo
->n_cbits
;
4667 int n_planes
= dpyinfo
->n_planes
;
4668 #endif /* HAVE_NTGUI */
4672 /* Color (or grayscale). Convert to gray, and equalize. Just
4673 drawing such images with a stipple can look very odd, so
4674 we're using this method instead. */
4675 XColor
*colors
= x_to_xcolors (f
, img
, 1);
4677 const int h
= 15000;
4678 const int l
= 30000;
4680 for (p
= colors
, end
= colors
+ img
->width
* img
->height
;
4684 int i
= COLOR_INTENSITY (p
->red
, p
->green
, p
->blue
);
4685 int i2
= (0xffff - h
- l
) * i
/ 0xffff + l
;
4686 p
->red
= p
->green
= p
->blue
= i2
;
4689 x_from_xcolors (f
, img
, colors
);
4692 /* Draw a cross over the disabled image, if we must or if we
4694 if (n_planes
< 2 || cross_disabled_images
)
4697 Display
*dpy
= FRAME_X_DISPLAY (f
);
4700 #ifndef HAVE_NS /* TODO: NS support, however this not needed for toolbars */
4702 #define MaskForeground(f) WHITE_PIX_DEFAULT (f)
4704 gc
= XCreateGC (dpy
, img
->pixmap
, 0, NULL
);
4705 XSetForeground (dpy
, gc
, BLACK_PIX_DEFAULT (f
));
4706 XDrawLine (dpy
, img
->pixmap
, gc
, 0, 0,
4707 img
->width
- 1, img
->height
- 1);
4708 XDrawLine (dpy
, img
->pixmap
, gc
, 0, img
->height
- 1,
4714 gc
= XCreateGC (dpy
, img
->mask
, 0, NULL
);
4715 XSetForeground (dpy
, gc
, MaskForeground (f
));
4716 XDrawLine (dpy
, img
->mask
, gc
, 0, 0,
4717 img
->width
- 1, img
->height
- 1);
4718 XDrawLine (dpy
, img
->mask
, gc
, 0, img
->height
- 1,
4722 #endif /* !HAVE_NS */
4727 hdc
= get_frame_dc (f
);
4728 bmpdc
= CreateCompatibleDC (hdc
);
4729 release_frame_dc (f
, hdc
);
4731 prev
= SelectObject (bmpdc
, img
->pixmap
);
4733 SetTextColor (bmpdc
, BLACK_PIX_DEFAULT (f
));
4734 MoveToEx (bmpdc
, 0, 0, NULL
);
4735 LineTo (bmpdc
, img
->width
- 1, img
->height
- 1);
4736 MoveToEx (bmpdc
, 0, img
->height
- 1, NULL
);
4737 LineTo (bmpdc
, img
->width
- 1, 0);
4741 SelectObject (bmpdc
, img
->mask
);
4742 SetTextColor (bmpdc
, WHITE_PIX_DEFAULT (f
));
4743 MoveToEx (bmpdc
, 0, 0, NULL
);
4744 LineTo (bmpdc
, img
->width
- 1, img
->height
- 1);
4745 MoveToEx (bmpdc
, 0, img
->height
- 1, NULL
);
4746 LineTo (bmpdc
, img
->width
- 1, 0);
4748 SelectObject (bmpdc
, prev
);
4750 #endif /* HAVE_NTGUI */
4755 /* Build a mask for image IMG which is used on frame F. FILE is the
4756 name of an image file, for error messages. HOW determines how to
4757 determine the background color of IMG. If it is a list '(R G B)',
4758 with R, G, and B being integers >= 0, take that as the color of the
4759 background. Otherwise, determine the background color of IMG
4760 heuristically. Value is non-zero if successful. */
4763 x_build_heuristic_mask (struct frame
*f
, struct image
*img
, Lisp_Object how
)
4765 XImagePtr_or_DC ximg
;
4773 #endif /* HAVE_NTGUI */
4774 int x
, y
, rc
, use_img_background
;
4775 unsigned long bg
= 0;
4779 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
4780 img
->mask
= NO_PIXMAP
;
4781 img
->background_transparent_valid
= 0;
4786 /* Create an image and pixmap serving as mask. */
4787 rc
= x_create_x_image_and_pixmap (f
, img
->width
, img
->height
, 1,
4788 &mask_img
, &img
->mask
);
4791 #endif /* !HAVE_NS */
4793 /* Get the X image of IMG->pixmap. */
4794 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
, 0, 0,
4795 img
->width
, img
->height
,
4798 /* Create the bit array serving as mask. */
4799 row_width
= (img
->width
+ 7) / 8;
4800 mask_img
= xmalloc (row_width
* img
->height
);
4801 memset (mask_img
, 0, row_width
* img
->height
);
4803 /* Create a memory device context for IMG->pixmap. */
4804 frame_dc
= get_frame_dc (f
);
4805 ximg
= CreateCompatibleDC (frame_dc
);
4806 release_frame_dc (f
, frame_dc
);
4807 prev
= SelectObject (ximg
, img
->pixmap
);
4808 #endif /* HAVE_NTGUI */
4810 /* Determine the background color of ximg. If HOW is `(R G B)'
4811 take that as color. Otherwise, use the image's background color. */
4812 use_img_background
= 1;
4818 for (i
= 0; i
< 3 && CONSP (how
) && NATNUMP (XCAR (how
)); ++i
)
4820 rgb
[i
] = XFASTINT (XCAR (how
)) & 0xffff;
4824 if (i
== 3 && NILP (how
))
4826 char color_name
[30];
4827 sprintf (color_name
, "#%04x%04x%04x", rgb
[0], rgb
[1], rgb
[2]);
4830 0x00ffffff & /* Filter out palette info. */
4831 #endif /* HAVE_NTGUI */
4832 x_alloc_image_color (f
, img
, build_string (color_name
), 0));
4833 use_img_background
= 0;
4837 if (use_img_background
)
4838 bg
= four_corners_best (ximg
, img
->corners
, img
->width
, img
->height
);
4840 /* Set all bits in mask_img to 1 whose color in ximg is different
4841 from the background color bg. */
4843 for (y
= 0; y
< img
->height
; ++y
)
4844 for (x
= 0; x
< img
->width
; ++x
)
4846 XPutPixel (mask_img
, x
, y
, (XGetPixel (ximg
, x
, y
) != bg
4847 ? PIX_MASK_DRAW
: PIX_MASK_RETAIN
));
4849 if (XGetPixel (ximg
, x
, y
) == bg
)
4850 ns_set_alpha (ximg
, x
, y
, 0);
4851 #endif /* HAVE_NS */
4853 /* Fill in the background_transparent field while we have the mask handy. */
4854 image_background_transparent (img
, f
, mask_img
);
4856 /* Put mask_img into img->mask. */
4857 x_put_x_image (f
, mask_img
, img
->mask
, img
->width
, img
->height
);
4858 x_destroy_x_image (mask_img
);
4859 #endif /* !HAVE_NS */
4861 for (y
= 0; y
< img
->height
; ++y
)
4862 for (x
= 0; x
< img
->width
; ++x
)
4864 COLORREF p
= GetPixel (ximg
, x
, y
);
4866 mask_img
[y
* row_width
+ x
/ 8] |= 1 << (x
% 8);
4869 /* Create the mask image. */
4870 img
->mask
= w32_create_pixmap_from_bitmap_data (img
->width
, img
->height
,
4872 /* Fill in the background_transparent field while we have the mask handy. */
4873 SelectObject (ximg
, img
->mask
);
4874 image_background_transparent (img
, f
, ximg
);
4876 /* Was: x_destroy_x_image ((XImagePtr )mask_img); which seems bogus ++kfs */
4878 #endif /* HAVE_NTGUI */
4880 Destroy_Image (ximg
, prev
);
4886 /***********************************************************************
4887 PBM (mono, gray, color)
4888 ***********************************************************************/
4890 static int pbm_image_p (Lisp_Object object
);
4891 static int pbm_load (struct frame
*f
, struct image
*img
);
4892 static int pbm_scan_number (unsigned char **, unsigned char *);
4894 /* The symbol `pbm' identifying images of this type. */
4896 static Lisp_Object Qpbm
;
4898 /* Indices of image specification fields in gs_format, below. */
4900 enum pbm_keyword_index
4916 /* Vector of image_keyword structures describing the format
4917 of valid user-defined image specifications. */
4919 static const struct image_keyword pbm_format
[PBM_LAST
] =
4921 {":type", IMAGE_SYMBOL_VALUE
, 1},
4922 {":file", IMAGE_STRING_VALUE
, 0},
4923 {":data", IMAGE_STRING_VALUE
, 0},
4924 {":ascent", IMAGE_ASCENT_VALUE
, 0},
4925 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
4926 {":relief", IMAGE_INTEGER_VALUE
, 0},
4927 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
4928 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
4929 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
4930 {":foreground", IMAGE_STRING_OR_NIL_VALUE
, 0},
4931 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
4934 /* Structure describing the image type `pbm'. */
4936 static struct image_type pbm_type
=
4946 /* Return non-zero if OBJECT is a valid PBM image specification. */
4949 pbm_image_p (Lisp_Object object
)
4951 struct image_keyword fmt
[PBM_LAST
];
4953 memcpy (fmt
, pbm_format
, sizeof fmt
);
4955 if (!parse_image_spec (object
, fmt
, PBM_LAST
, Qpbm
))
4958 /* Must specify either :data or :file. */
4959 return fmt
[PBM_DATA
].count
+ fmt
[PBM_FILE
].count
== 1;
4963 /* Scan a decimal number from *S and return it. Advance *S while
4964 reading the number. END is the end of the string. Value is -1 at
4968 pbm_scan_number (unsigned char **s
, unsigned char *end
)
4970 int c
= 0, val
= -1;
4974 /* Skip white-space. */
4975 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
4980 /* Skip comment to end of line. */
4981 while (*s
< end
&& (c
= *(*s
)++, c
!= '\n'))
4984 else if (isdigit (c
))
4986 /* Read decimal number. */
4988 while (*s
< end
&& (c
= *(*s
)++, isdigit (c
)))
4989 val
= 10 * val
+ c
- '0';
5001 #if 0 /* Unused. ++kfs */
5003 /* Read FILE into memory. Value is a pointer to a buffer allocated
5004 with xmalloc holding FILE's contents. Value is null if an error
5005 occurred. *SIZE is set to the size of the file. */
5008 pbm_read_file (file
, size
)
5016 if (stat (SDATA (file
), &st
) == 0
5017 && (fp
= fopen (SDATA (file
), "rb")) != NULL
5018 && 0 <= st
.st_size
&& st
.st_size
<= min (PTRDIFF_MAX
, SIZE_MAX
)
5019 && (buf
= (char *) xmalloc (st
.st_size
),
5020 fread (buf
, 1, st
.st_size
, fp
) == st
.st_size
))
5039 #endif /* HAVE_NTGUI */
5041 /* Load PBM image IMG for use on frame F. */
5044 pbm_load (struct frame
*f
, struct image
*img
)
5047 int width
, height
, max_color_idx
= 0;
5049 Lisp_Object file
, specified_file
;
5050 enum {PBM_MONO
, PBM_GRAY
, PBM_COLOR
} type
;
5051 unsigned char *contents
= NULL
;
5052 unsigned char *end
, *p
;
5055 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
5057 if (STRINGP (specified_file
))
5059 file
= x_find_image_file (specified_file
);
5060 if (!STRINGP (file
))
5062 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
5066 contents
= slurp_file (SSDATA (file
), &size
);
5067 if (contents
== NULL
)
5069 image_error ("Error reading `%s'", file
, Qnil
);
5074 end
= contents
+ size
;
5079 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
5080 if (!STRINGP (data
))
5082 image_error ("Invalid image data `%s'", data
, Qnil
);
5086 end
= p
+ SBYTES (data
);
5089 /* Check magic number. */
5090 if (end
- p
< 2 || *p
++ != 'P')
5092 image_error ("Not a PBM image: `%s'", img
->spec
, Qnil
);
5101 raw_p
= 0, type
= PBM_MONO
;
5105 raw_p
= 0, type
= PBM_GRAY
;
5109 raw_p
= 0, type
= PBM_COLOR
;
5113 raw_p
= 1, type
= PBM_MONO
;
5117 raw_p
= 1, type
= PBM_GRAY
;
5121 raw_p
= 1, type
= PBM_COLOR
;
5125 image_error ("Not a PBM image: `%s'", img
->spec
, Qnil
);
5129 /* Read width, height, maximum color-component. Characters
5130 starting with `#' up to the end of a line are ignored. */
5131 width
= pbm_scan_number (&p
, end
);
5132 height
= pbm_scan_number (&p
, end
);
5134 if (type
!= PBM_MONO
)
5136 max_color_idx
= pbm_scan_number (&p
, end
);
5137 if (max_color_idx
> 65535 || max_color_idx
< 0)
5139 image_error ("Unsupported maximum PBM color value", Qnil
, Qnil
);
5144 if (!check_image_size (f
, width
, height
))
5146 image_error ("Invalid image size (see `max-image-size')", Qnil
, Qnil
);
5150 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0,
5151 &ximg
, &img
->pixmap
))
5154 /* Initialize the color hash table. */
5155 init_color_table ();
5157 if (type
== PBM_MONO
)
5160 struct image_keyword fmt
[PBM_LAST
];
5161 unsigned long fg
= FRAME_FOREGROUND_PIXEL (f
);
5162 unsigned long bg
= FRAME_BACKGROUND_PIXEL (f
);
5164 /* Parse the image specification. */
5165 memcpy (fmt
, pbm_format
, sizeof fmt
);
5166 parse_image_spec (img
->spec
, fmt
, PBM_LAST
, Qpbm
);
5168 /* Get foreground and background colors, maybe allocate colors. */
5169 if (fmt
[PBM_FOREGROUND
].count
5170 && STRINGP (fmt
[PBM_FOREGROUND
].value
))
5171 fg
= x_alloc_image_color (f
, img
, fmt
[PBM_FOREGROUND
].value
, fg
);
5172 if (fmt
[PBM_BACKGROUND
].count
5173 && STRINGP (fmt
[PBM_BACKGROUND
].value
))
5175 bg
= x_alloc_image_color (f
, img
, fmt
[PBM_BACKGROUND
].value
, bg
);
5176 img
->background
= bg
;
5177 img
->background_valid
= 1;
5180 for (y
= 0; y
< height
; ++y
)
5181 for (x
= 0; x
< width
; ++x
)
5189 x_destroy_x_image (ximg
);
5190 x_clear_image (f
, img
);
5191 image_error ("Invalid image size in image `%s'",
5201 g
= pbm_scan_number (&p
, end
);
5203 XPutPixel (ximg
, x
, y
, g
? fg
: bg
);
5208 int expected_size
= height
* width
;
5209 if (max_color_idx
> 255)
5211 if (type
== PBM_COLOR
)
5214 if (raw_p
&& p
+ expected_size
> end
)
5216 x_destroy_x_image (ximg
);
5217 x_clear_image (f
, img
);
5218 image_error ("Invalid image size in image `%s'",
5223 for (y
= 0; y
< height
; ++y
)
5224 for (x
= 0; x
< width
; ++x
)
5228 if (type
== PBM_GRAY
&& raw_p
)
5231 if (max_color_idx
> 255)
5232 r
= g
= b
= r
* 256 + *p
++;
5234 else if (type
== PBM_GRAY
)
5235 r
= g
= b
= pbm_scan_number (&p
, end
);
5239 if (max_color_idx
> 255)
5242 if (max_color_idx
> 255)
5245 if (max_color_idx
> 255)
5250 r
= pbm_scan_number (&p
, end
);
5251 g
= pbm_scan_number (&p
, end
);
5252 b
= pbm_scan_number (&p
, end
);
5255 if (r
< 0 || g
< 0 || b
< 0)
5257 x_destroy_x_image (ximg
);
5258 image_error ("Invalid pixel value in image `%s'",
5263 /* RGB values are now in the range 0..max_color_idx.
5264 Scale this to the range 0..0xffff supported by X. */
5265 r
= (double) r
* 65535 / max_color_idx
;
5266 g
= (double) g
* 65535 / max_color_idx
;
5267 b
= (double) b
* 65535 / max_color_idx
;
5268 XPutPixel (ximg
, x
, y
, lookup_rgb_color (f
, r
, g
, b
));
5272 #ifdef COLOR_TABLE_SUPPORT
5273 /* Store in IMG->colors the colors allocated for the image, and
5274 free the color table. */
5275 img
->colors
= colors_in_color_table (&img
->ncolors
);
5276 free_color_table ();
5277 #endif /* COLOR_TABLE_SUPPORT */
5280 img
->height
= height
;
5282 /* Maybe fill in the background field while we have ximg handy. */
5284 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
5285 /* Casting avoids a GCC warning. */
5286 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
5288 /* Put the image into a pixmap. */
5289 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
5290 x_destroy_x_image (ximg
);
5292 /* X and W32 versions did it here, MAC version above. ++kfs
5294 img->height = height; */
5301 /***********************************************************************
5303 ***********************************************************************/
5305 #if defined (HAVE_PNG) || defined (HAVE_NS)
5307 /* Function prototypes. */
5309 static int png_image_p (Lisp_Object object
);
5310 static int png_load (struct frame
*f
, struct image
*img
);
5312 /* The symbol `png' identifying images of this type. */
5314 static Lisp_Object Qpng
;
5316 /* Indices of image specification fields in png_format, below. */
5318 enum png_keyword_index
5333 /* Vector of image_keyword structures describing the format
5334 of valid user-defined image specifications. */
5336 static const struct image_keyword png_format
[PNG_LAST
] =
5338 {":type", IMAGE_SYMBOL_VALUE
, 1},
5339 {":data", IMAGE_STRING_VALUE
, 0},
5340 {":file", IMAGE_STRING_VALUE
, 0},
5341 {":ascent", IMAGE_ASCENT_VALUE
, 0},
5342 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
5343 {":relief", IMAGE_INTEGER_VALUE
, 0},
5344 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5345 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5346 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5347 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
5350 /* Structure describing the image type `png'. */
5352 static struct image_type png_type
=
5361 /* Return non-zero if OBJECT is a valid PNG image specification. */
5364 png_image_p (Lisp_Object object
)
5366 struct image_keyword fmt
[PNG_LAST
];
5367 memcpy (fmt
, png_format
, sizeof fmt
);
5369 if (!parse_image_spec (object
, fmt
, PNG_LAST
, Qpng
))
5372 /* Must specify either the :data or :file keyword. */
5373 return fmt
[PNG_FILE
].count
+ fmt
[PNG_DATA
].count
== 1;
5376 #endif /* HAVE_PNG || HAVE_NS */
5382 /* PNG library details. */
5384 DEF_IMGLIB_FN (png_voidp
, png_get_io_ptr
, (png_structp
));
5385 DEF_IMGLIB_FN (int, png_sig_cmp
, (png_bytep
, png_size_t
, png_size_t
));
5386 DEF_IMGLIB_FN (png_structp
, png_create_read_struct
, (png_const_charp
, png_voidp
,
5387 png_error_ptr
, png_error_ptr
));
5388 DEF_IMGLIB_FN (png_infop
, png_create_info_struct
, (png_structp
));
5389 DEF_IMGLIB_FN (void, png_destroy_read_struct
, (png_structpp
, png_infopp
, png_infopp
));
5390 DEF_IMGLIB_FN (void, png_set_read_fn
, (png_structp
, png_voidp
, png_rw_ptr
));
5391 DEF_IMGLIB_FN (void, png_set_sig_bytes
, (png_structp
, int));
5392 DEF_IMGLIB_FN (void, png_read_info
, (png_structp
, png_infop
));
5393 DEF_IMGLIB_FN (png_uint_32
, png_get_IHDR
, (png_structp
, png_infop
,
5394 png_uint_32
*, png_uint_32
*,
5395 int *, int *, int *, int *, int *));
5396 DEF_IMGLIB_FN (png_uint_32
, png_get_valid
, (png_structp
, png_infop
, png_uint_32
));
5397 DEF_IMGLIB_FN (void, png_set_strip_16
, (png_structp
));
5398 DEF_IMGLIB_FN (void, png_set_expand
, (png_structp
));
5399 DEF_IMGLIB_FN (void, png_set_gray_to_rgb
, (png_structp
));
5400 DEF_IMGLIB_FN (void, png_set_background
, (png_structp
, png_color_16p
,
5402 DEF_IMGLIB_FN (png_uint_32
, png_get_bKGD
, (png_structp
, png_infop
, png_color_16p
*));
5403 DEF_IMGLIB_FN (void, png_read_update_info
, (png_structp
, png_infop
));
5404 DEF_IMGLIB_FN (png_byte
, png_get_channels
, (png_structp
, png_infop
));
5405 DEF_IMGLIB_FN (png_size_t
, png_get_rowbytes
, (png_structp
, png_infop
));
5406 DEF_IMGLIB_FN (void, png_read_image
, (png_structp
, png_bytepp
));
5407 DEF_IMGLIB_FN (void, png_read_end
, (png_structp
, png_infop
));
5408 DEF_IMGLIB_FN (void, png_error
, (png_structp
, png_const_charp
));
5410 #if (PNG_LIBPNG_VER >= 10500)
5411 DEF_IMGLIB_FN (void, png_longjmp
, (png_structp
, int));
5412 DEF_IMGLIB_FN (jmp_buf *, png_set_longjmp_fn
, (png_structp
, png_longjmp_ptr
, size_t));
5413 #endif /* libpng version >= 1.5 */
5416 init_png_functions (Lisp_Object libraries
)
5420 if (!(library
= w32_delayed_load (libraries
, Qpng
)))
5423 LOAD_IMGLIB_FN (library
, png_get_io_ptr
);
5424 LOAD_IMGLIB_FN (library
, png_sig_cmp
);
5425 LOAD_IMGLIB_FN (library
, png_create_read_struct
);
5426 LOAD_IMGLIB_FN (library
, png_create_info_struct
);
5427 LOAD_IMGLIB_FN (library
, png_destroy_read_struct
);
5428 LOAD_IMGLIB_FN (library
, png_set_read_fn
);
5429 LOAD_IMGLIB_FN (library
, png_set_sig_bytes
);
5430 LOAD_IMGLIB_FN (library
, png_read_info
);
5431 LOAD_IMGLIB_FN (library
, png_get_IHDR
);
5432 LOAD_IMGLIB_FN (library
, png_get_valid
);
5433 LOAD_IMGLIB_FN (library
, png_set_strip_16
);
5434 LOAD_IMGLIB_FN (library
, png_set_expand
);
5435 LOAD_IMGLIB_FN (library
, png_set_gray_to_rgb
);
5436 LOAD_IMGLIB_FN (library
, png_set_background
);
5437 LOAD_IMGLIB_FN (library
, png_get_bKGD
);
5438 LOAD_IMGLIB_FN (library
, png_read_update_info
);
5439 LOAD_IMGLIB_FN (library
, png_get_channels
);
5440 LOAD_IMGLIB_FN (library
, png_get_rowbytes
);
5441 LOAD_IMGLIB_FN (library
, png_read_image
);
5442 LOAD_IMGLIB_FN (library
, png_read_end
);
5443 LOAD_IMGLIB_FN (library
, png_error
);
5445 #if (PNG_LIBPNG_VER >= 10500)
5446 LOAD_IMGLIB_FN (library
, png_longjmp
);
5447 LOAD_IMGLIB_FN (library
, png_set_longjmp_fn
);
5448 #endif /* libpng version >= 1.5 */
5454 #define fn_png_get_io_ptr png_get_io_ptr
5455 #define fn_png_sig_cmp png_sig_cmp
5456 #define fn_png_create_read_struct png_create_read_struct
5457 #define fn_png_create_info_struct png_create_info_struct
5458 #define fn_png_destroy_read_struct png_destroy_read_struct
5459 #define fn_png_set_read_fn png_set_read_fn
5460 #define fn_png_set_sig_bytes png_set_sig_bytes
5461 #define fn_png_read_info png_read_info
5462 #define fn_png_get_IHDR png_get_IHDR
5463 #define fn_png_get_valid png_get_valid
5464 #define fn_png_set_strip_16 png_set_strip_16
5465 #define fn_png_set_expand png_set_expand
5466 #define fn_png_set_gray_to_rgb png_set_gray_to_rgb
5467 #define fn_png_set_background png_set_background
5468 #define fn_png_get_bKGD png_get_bKGD
5469 #define fn_png_read_update_info png_read_update_info
5470 #define fn_png_get_channels png_get_channels
5471 #define fn_png_get_rowbytes png_get_rowbytes
5472 #define fn_png_read_image png_read_image
5473 #define fn_png_read_end png_read_end
5474 #define fn_png_error png_error
5476 #if (PNG_LIBPNG_VER >= 10500)
5477 #define fn_png_longjmp png_longjmp
5478 #define fn_png_set_longjmp_fn png_set_longjmp_fn
5479 #endif /* libpng version >= 1.5 */
5481 #endif /* HAVE_NTGUI */
5484 #if (PNG_LIBPNG_VER < 10500)
5485 #define PNG_LONGJMP(ptr) (longjmp ((ptr)->jmpbuf, 1))
5486 #define PNG_JMPBUF(ptr) ((ptr)->jmpbuf)
5488 /* In libpng version 1.5, the jmpbuf member is hidden. (Bug#7908) */
5489 #define PNG_LONGJMP(ptr) (fn_png_longjmp ((ptr), 1))
5490 #define PNG_JMPBUF(ptr) \
5491 (*fn_png_set_longjmp_fn((ptr), longjmp, sizeof (jmp_buf)))
5494 /* Error and warning handlers installed when the PNG library
5497 static void my_png_error (png_struct
*, const char *) NO_RETURN
;
5499 my_png_error (png_struct
*png_ptr
, const char *msg
)
5501 xassert (png_ptr
!= NULL
);
5502 /* Avoid compiler warning about deprecated direct access to
5503 png_ptr's fields in libpng versions 1.4.x. */
5504 image_error ("PNG error: %s", build_string (msg
), Qnil
);
5505 PNG_LONGJMP (png_ptr
);
5510 my_png_warning (png_struct
*png_ptr
, const char *msg
)
5512 xassert (png_ptr
!= NULL
);
5513 image_error ("PNG warning: %s", build_string (msg
), Qnil
);
5516 /* Memory source for PNG decoding. */
5518 struct png_memory_storage
5520 unsigned char *bytes
; /* The data */
5521 size_t len
; /* How big is it? */
5522 int index
; /* Where are we? */
5526 /* Function set as reader function when reading PNG image from memory.
5527 PNG_PTR is a pointer to the PNG control structure. Copy LENGTH
5528 bytes from the input to DATA. */
5531 png_read_from_memory (png_structp png_ptr
, png_bytep data
, png_size_t length
)
5533 struct png_memory_storage
*tbr
5534 = (struct png_memory_storage
*) fn_png_get_io_ptr (png_ptr
);
5536 if (length
> tbr
->len
- tbr
->index
)
5537 fn_png_error (png_ptr
, "Read error");
5539 memcpy (data
, tbr
->bytes
+ tbr
->index
, length
);
5540 tbr
->index
= tbr
->index
+ length
;
5544 /* Function set as reader function when reading PNG image from a file.
5545 PNG_PTR is a pointer to the PNG control structure. Copy LENGTH
5546 bytes from the input to DATA. */
5549 png_read_from_file (png_structp png_ptr
, png_bytep data
, png_size_t length
)
5551 FILE *fp
= (FILE *) fn_png_get_io_ptr (png_ptr
);
5553 if (fread (data
, 1, length
, fp
) < length
)
5554 fn_png_error (png_ptr
, "Read error");
5558 /* Load PNG image IMG for use on frame F. Value is non-zero if
5562 png_load (struct frame
*f
, struct image
*img
)
5564 Lisp_Object file
, specified_file
;
5565 Lisp_Object specified_data
;
5567 XImagePtr ximg
, mask_img
= NULL
;
5568 png_struct
*png_ptr
= NULL
;
5569 png_info
*info_ptr
= NULL
, *end_info
= NULL
;
5570 FILE *volatile fp
= NULL
;
5572 png_byte
* volatile pixels
= NULL
;
5573 png_byte
** volatile rows
= NULL
;
5574 png_uint_32 width
, height
;
5575 int bit_depth
, color_type
, interlace_type
;
5577 png_uint_32 row_bytes
;
5579 struct png_memory_storage tbr
; /* Data to be read */
5581 /* Find out what file to load. */
5582 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
5583 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
5585 if (NILP (specified_data
))
5587 file
= x_find_image_file (specified_file
);
5588 if (!STRINGP (file
))
5590 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
5594 /* Open the image file. */
5595 fp
= fopen (SSDATA (file
), "rb");
5598 image_error ("Cannot open image file `%s'", file
, Qnil
);
5602 /* Check PNG signature. */
5603 if (fread (sig
, 1, sizeof sig
, fp
) != sizeof sig
5604 || fn_png_sig_cmp (sig
, 0, sizeof sig
))
5606 image_error ("Not a PNG file: `%s'", file
, Qnil
);
5613 if (!STRINGP (specified_data
))
5615 image_error ("Invalid image data `%s'", specified_data
, Qnil
);
5619 /* Read from memory. */
5620 tbr
.bytes
= SDATA (specified_data
);
5621 tbr
.len
= SBYTES (specified_data
);
5624 /* Check PNG signature. */
5625 if (tbr
.len
< sizeof sig
5626 || fn_png_sig_cmp (tbr
.bytes
, 0, sizeof sig
))
5628 image_error ("Not a PNG image: `%s'", img
->spec
, Qnil
);
5632 /* Need to skip past the signature. */
5633 tbr
.bytes
+= sizeof (sig
);
5636 /* Initialize read and info structs for PNG lib. */
5637 png_ptr
= fn_png_create_read_struct (PNG_LIBPNG_VER_STRING
,
5642 if (fp
) fclose (fp
);
5646 info_ptr
= fn_png_create_info_struct (png_ptr
);
5649 fn_png_destroy_read_struct (&png_ptr
, NULL
, NULL
);
5650 if (fp
) fclose (fp
);
5654 end_info
= fn_png_create_info_struct (png_ptr
);
5657 fn_png_destroy_read_struct (&png_ptr
, &info_ptr
, NULL
);
5658 if (fp
) fclose (fp
);
5662 /* Set error jump-back. We come back here when the PNG library
5663 detects an error. */
5664 if (setjmp (PNG_JMPBUF (png_ptr
)))
5668 fn_png_destroy_read_struct (&png_ptr
, &info_ptr
, &end_info
);
5671 if (fp
) fclose (fp
);
5675 /* Read image info. */
5676 if (!NILP (specified_data
))
5677 fn_png_set_read_fn (png_ptr
, (void *) &tbr
, png_read_from_memory
);
5679 fn_png_set_read_fn (png_ptr
, (void *) fp
, png_read_from_file
);
5681 fn_png_set_sig_bytes (png_ptr
, sizeof sig
);
5682 fn_png_read_info (png_ptr
, info_ptr
);
5683 fn_png_get_IHDR (png_ptr
, info_ptr
, &width
, &height
, &bit_depth
, &color_type
,
5684 &interlace_type
, NULL
, NULL
);
5686 if (!check_image_size (f
, width
, height
))
5688 image_error ("Invalid image size (see `max-image-size')", Qnil
, Qnil
);
5691 /* If image contains simply transparency data, we prefer to
5692 construct a clipping mask. */
5693 if (fn_png_get_valid (png_ptr
, info_ptr
, PNG_INFO_tRNS
))
5698 /* This function is easier to write if we only have to handle
5699 one data format: RGB or RGBA with 8 bits per channel. Let's
5700 transform other formats into that format. */
5702 /* Strip more than 8 bits per channel. */
5703 if (bit_depth
== 16)
5704 fn_png_set_strip_16 (png_ptr
);
5706 /* Expand data to 24 bit RGB, or 8 bit grayscale, with alpha channel
5708 fn_png_set_expand (png_ptr
);
5710 /* Convert grayscale images to RGB. */
5711 if (color_type
== PNG_COLOR_TYPE_GRAY
5712 || color_type
== PNG_COLOR_TYPE_GRAY_ALPHA
)
5713 fn_png_set_gray_to_rgb (png_ptr
);
5715 /* Handle alpha channel by combining the image with a background
5716 color. Do this only if a real alpha channel is supplied. For
5717 simple transparency, we prefer a clipping mask. */
5720 /* png_color_16 *image_bg; */
5721 Lisp_Object specified_bg
5722 = image_spec_value (img
->spec
, QCbackground
, NULL
);
5723 int shift
= (bit_depth
== 16) ? 0 : 8;
5725 if (STRINGP (specified_bg
))
5726 /* The user specified `:background', use that. */
5729 if (x_defined_color (f
, SSDATA (specified_bg
), &color
, 0))
5731 png_color_16 user_bg
;
5733 memset (&user_bg
, 0, sizeof user_bg
);
5734 user_bg
.red
= color
.red
>> shift
;
5735 user_bg
.green
= color
.green
>> shift
;
5736 user_bg
.blue
= color
.blue
>> shift
;
5738 fn_png_set_background (png_ptr
, &user_bg
,
5739 PNG_BACKGROUND_GAMMA_SCREEN
, 0, 1.0);
5744 /* We use the current frame background, ignoring any default
5745 background color set by the image. */
5746 #if defined (HAVE_X_WINDOWS) || defined (HAVE_NTGUI)
5748 png_color_16 frame_background
;
5750 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
5751 x_query_color (f
, &color
);
5753 memset (&frame_background
, 0, sizeof frame_background
);
5754 frame_background
.red
= color
.red
>> shift
;
5755 frame_background
.green
= color
.green
>> shift
;
5756 frame_background
.blue
= color
.blue
>> shift
;
5757 #endif /* HAVE_X_WINDOWS */
5759 fn_png_set_background (png_ptr
, &frame_background
,
5760 PNG_BACKGROUND_GAMMA_SCREEN
, 0, 1.0);
5764 /* Update info structure. */
5765 fn_png_read_update_info (png_ptr
, info_ptr
);
5767 /* Get number of channels. Valid values are 1 for grayscale images
5768 and images with a palette, 2 for grayscale images with transparency
5769 information (alpha channel), 3 for RGB images, and 4 for RGB
5770 images with alpha channel, i.e. RGBA. If conversions above were
5771 sufficient we should only have 3 or 4 channels here. */
5772 channels
= fn_png_get_channels (png_ptr
, info_ptr
);
5773 xassert (channels
== 3 || channels
== 4);
5775 /* Number of bytes needed for one row of the image. */
5776 row_bytes
= fn_png_get_rowbytes (png_ptr
, info_ptr
);
5778 /* Allocate memory for the image. */
5779 pixels
= (png_byte
*) xmalloc (row_bytes
* height
* sizeof *pixels
);
5780 rows
= (png_byte
**) xmalloc (height
* sizeof *rows
);
5781 for (i
= 0; i
< height
; ++i
)
5782 rows
[i
] = pixels
+ i
* row_bytes
;
5784 /* Read the entire image. */
5785 fn_png_read_image (png_ptr
, rows
);
5786 fn_png_read_end (png_ptr
, info_ptr
);
5793 /* Create the X image and pixmap. */
5794 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
,
5798 /* Create an image and pixmap serving as mask if the PNG image
5799 contains an alpha channel. */
5802 && !x_create_x_image_and_pixmap (f
, width
, height
, 1,
5803 &mask_img
, &img
->mask
))
5805 x_destroy_x_image (ximg
);
5806 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->pixmap
);
5807 img
->pixmap
= NO_PIXMAP
;
5811 /* Fill the X image and mask from PNG data. */
5812 init_color_table ();
5814 for (y
= 0; y
< height
; ++y
)
5816 png_byte
*p
= rows
[y
];
5818 for (x
= 0; x
< width
; ++x
)
5825 XPutPixel (ximg
, x
, y
, lookup_rgb_color (f
, r
, g
, b
));
5826 /* An alpha channel, aka mask channel, associates variable
5827 transparency with an image. Where other image formats
5828 support binary transparency---fully transparent or fully
5829 opaque---PNG allows up to 254 levels of partial transparency.
5830 The PNG library implements partial transparency by combining
5831 the image with a specified background color.
5833 I'm not sure how to handle this here nicely: because the
5834 background on which the image is displayed may change, for
5835 real alpha channel support, it would be necessary to create
5836 a new image for each possible background.
5838 What I'm doing now is that a mask is created if we have
5839 boolean transparency information. Otherwise I'm using
5840 the frame's background color to combine the image with. */
5845 XPutPixel (mask_img
, x
, y
, *p
> 0 ? PIX_MASK_DRAW
: PIX_MASK_RETAIN
);
5851 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
5852 /* Set IMG's background color from the PNG image, unless the user
5856 if (fn_png_get_bKGD (png_ptr
, info_ptr
, &bg
))
5858 img
->background
= lookup_rgb_color (f
, bg
->red
, bg
->green
, bg
->blue
);
5859 img
->background_valid
= 1;
5863 #ifdef COLOR_TABLE_SUPPORT
5864 /* Remember colors allocated for this image. */
5865 img
->colors
= colors_in_color_table (&img
->ncolors
);
5866 free_color_table ();
5867 #endif /* COLOR_TABLE_SUPPORT */
5870 fn_png_destroy_read_struct (&png_ptr
, &info_ptr
, &end_info
);
5875 img
->height
= height
;
5877 /* Maybe fill in the background field while we have ximg handy.
5878 Casting avoids a GCC warning. */
5879 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
5881 /* Put the image into the pixmap, then free the X image and its buffer. */
5882 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
5883 x_destroy_x_image (ximg
);
5885 /* Same for the mask. */
5888 /* Fill in the background_transparent field while we have the
5889 mask handy. Casting avoids a GCC warning. */
5890 image_background_transparent (img
, f
, (XImagePtr_or_DC
)mask_img
);
5892 x_put_x_image (f
, mask_img
, img
->mask
, img
->width
, img
->height
);
5893 x_destroy_x_image (mask_img
);
5899 #else /* HAVE_PNG */
5903 png_load (struct frame
*f
, struct image
*img
)
5905 return ns_load_image(f
, img
,
5906 image_spec_value (img
->spec
, QCfile
, NULL
),
5907 image_spec_value (img
->spec
, QCdata
, NULL
));
5909 #endif /* HAVE_NS */
5912 #endif /* !HAVE_PNG */
5916 /***********************************************************************
5918 ***********************************************************************/
5920 #if defined (HAVE_JPEG) || defined (HAVE_NS)
5922 static int jpeg_image_p (Lisp_Object object
);
5923 static int jpeg_load (struct frame
*f
, struct image
*img
);
5925 /* The symbol `jpeg' identifying images of this type. */
5927 static Lisp_Object Qjpeg
;
5929 /* Indices of image specification fields in gs_format, below. */
5931 enum jpeg_keyword_index
5940 JPEG_HEURISTIC_MASK
,
5946 /* Vector of image_keyword structures describing the format
5947 of valid user-defined image specifications. */
5949 static const struct image_keyword jpeg_format
[JPEG_LAST
] =
5951 {":type", IMAGE_SYMBOL_VALUE
, 1},
5952 {":data", IMAGE_STRING_VALUE
, 0},
5953 {":file", IMAGE_STRING_VALUE
, 0},
5954 {":ascent", IMAGE_ASCENT_VALUE
, 0},
5955 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
5956 {":relief", IMAGE_INTEGER_VALUE
, 0},
5957 {":conversions", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5958 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5959 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5960 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
5963 /* Structure describing the image type `jpeg'. */
5965 static struct image_type jpeg_type
=
5974 /* Return non-zero if OBJECT is a valid JPEG image specification. */
5977 jpeg_image_p (Lisp_Object object
)
5979 struct image_keyword fmt
[JPEG_LAST
];
5981 memcpy (fmt
, jpeg_format
, sizeof fmt
);
5983 if (!parse_image_spec (object
, fmt
, JPEG_LAST
, Qjpeg
))
5986 /* Must specify either the :data or :file keyword. */
5987 return fmt
[JPEG_FILE
].count
+ fmt
[JPEG_DATA
].count
== 1;
5990 #endif /* HAVE_JPEG || HAVE_NS */
5994 /* Work around a warning about HAVE_STDLIB_H being redefined in
5996 #ifdef HAVE_STDLIB_H
5997 #undef HAVE_STDLIB_H
5998 #endif /* HAVE_STLIB_H */
6000 #if defined (HAVE_NTGUI) && !defined (__WIN32__)
6001 /* In older releases of the jpeg library, jpeglib.h will define boolean
6002 differently depending on __WIN32__, so make sure it is defined. */
6006 #include <jpeglib.h>
6009 #ifdef HAVE_STLIB_H_1
6010 #define HAVE_STDLIB_H 1
6015 /* JPEG library details. */
6016 DEF_IMGLIB_FN (void, jpeg_CreateDecompress
, (j_decompress_ptr
, int, size_t));
6017 DEF_IMGLIB_FN (boolean
, jpeg_start_decompress
, (j_decompress_ptr
));
6018 DEF_IMGLIB_FN (boolean
, jpeg_finish_decompress
, (j_decompress_ptr
));
6019 DEF_IMGLIB_FN (void, jpeg_destroy_decompress
, (j_decompress_ptr
));
6020 DEF_IMGLIB_FN (int, jpeg_read_header
, (j_decompress_ptr
, boolean
));
6021 DEF_IMGLIB_FN (JDIMENSION
, jpeg_read_scanlines
, (j_decompress_ptr
, JSAMPARRAY
, JDIMENSION
));
6022 DEF_IMGLIB_FN (struct jpeg_error_mgr
*, jpeg_std_error
, (struct jpeg_error_mgr
*));
6023 DEF_IMGLIB_FN (boolean
, jpeg_resync_to_restart
, (j_decompress_ptr
, int));
6026 init_jpeg_functions (Lisp_Object libraries
)
6030 if (!(library
= w32_delayed_load (libraries
, Qjpeg
)))
6033 LOAD_IMGLIB_FN (library
, jpeg_finish_decompress
);
6034 LOAD_IMGLIB_FN (library
, jpeg_read_scanlines
);
6035 LOAD_IMGLIB_FN (library
, jpeg_start_decompress
);
6036 LOAD_IMGLIB_FN (library
, jpeg_read_header
);
6037 LOAD_IMGLIB_FN (library
, jpeg_CreateDecompress
);
6038 LOAD_IMGLIB_FN (library
, jpeg_destroy_decompress
);
6039 LOAD_IMGLIB_FN (library
, jpeg_std_error
);
6040 LOAD_IMGLIB_FN (library
, jpeg_resync_to_restart
);
6044 /* Wrapper since we can't directly assign the function pointer
6045 to another function pointer that was declared more completely easily. */
6047 jpeg_resync_to_restart_wrapper (j_decompress_ptr cinfo
, int desired
)
6049 return fn_jpeg_resync_to_restart (cinfo
, desired
);
6054 #define fn_jpeg_CreateDecompress(a,b,c) jpeg_create_decompress(a)
6055 #define fn_jpeg_start_decompress jpeg_start_decompress
6056 #define fn_jpeg_finish_decompress jpeg_finish_decompress
6057 #define fn_jpeg_destroy_decompress jpeg_destroy_decompress
6058 #define fn_jpeg_read_header jpeg_read_header
6059 #define fn_jpeg_read_scanlines jpeg_read_scanlines
6060 #define fn_jpeg_std_error jpeg_std_error
6061 #define jpeg_resync_to_restart_wrapper jpeg_resync_to_restart
6063 #endif /* HAVE_NTGUI */
6065 struct my_jpeg_error_mgr
6067 struct jpeg_error_mgr pub
;
6068 jmp_buf setjmp_buffer
;
6072 static void my_error_exit (j_common_ptr
) NO_RETURN
;
6074 my_error_exit (j_common_ptr cinfo
)
6076 struct my_jpeg_error_mgr
*mgr
= (struct my_jpeg_error_mgr
*) cinfo
->err
;
6077 longjmp (mgr
->setjmp_buffer
, 1);
6081 /* Init source method for JPEG data source manager. Called by
6082 jpeg_read_header() before any data is actually read. See
6083 libjpeg.doc from the JPEG lib distribution. */
6086 our_common_init_source (j_decompress_ptr cinfo
)
6091 /* Method to terminate data source. Called by
6092 jpeg_finish_decompress() after all data has been processed. */
6095 our_common_term_source (j_decompress_ptr cinfo
)
6100 /* Fill input buffer method for JPEG data source manager. Called
6101 whenever more data is needed. We read the whole image in one step,
6102 so this only adds a fake end of input marker at the end. */
6104 static JOCTET our_memory_buffer
[2];
6107 our_memory_fill_input_buffer (j_decompress_ptr cinfo
)
6109 /* Insert a fake EOI marker. */
6110 struct jpeg_source_mgr
*src
= cinfo
->src
;
6112 our_memory_buffer
[0] = (JOCTET
) 0xFF;
6113 our_memory_buffer
[1] = (JOCTET
) JPEG_EOI
;
6115 src
->next_input_byte
= our_memory_buffer
;
6116 src
->bytes_in_buffer
= 2;
6121 /* Method to skip over NUM_BYTES bytes in the image data. CINFO->src
6122 is the JPEG data source manager. */
6125 our_memory_skip_input_data (j_decompress_ptr cinfo
, long int num_bytes
)
6127 struct jpeg_source_mgr
*src
= (struct jpeg_source_mgr
*) cinfo
->src
;
6131 if (num_bytes
> src
->bytes_in_buffer
)
6132 ERREXIT (cinfo
, JERR_INPUT_EOF
);
6134 src
->bytes_in_buffer
-= num_bytes
;
6135 src
->next_input_byte
+= num_bytes
;
6140 /* Set up the JPEG lib for reading an image from DATA which contains
6141 LEN bytes. CINFO is the decompression info structure created for
6142 reading the image. */
6145 jpeg_memory_src (j_decompress_ptr cinfo
, JOCTET
*data
, unsigned int len
)
6147 struct jpeg_source_mgr
*src
;
6149 if (cinfo
->src
== NULL
)
6151 /* First time for this JPEG object? */
6152 cinfo
->src
= (struct jpeg_source_mgr
*)
6153 (*cinfo
->mem
->alloc_small
) ((j_common_ptr
) cinfo
, JPOOL_PERMANENT
,
6154 sizeof (struct jpeg_source_mgr
));
6155 src
= (struct jpeg_source_mgr
*) cinfo
->src
;
6156 src
->next_input_byte
= data
;
6159 src
= (struct jpeg_source_mgr
*) cinfo
->src
;
6160 src
->init_source
= our_common_init_source
;
6161 src
->fill_input_buffer
= our_memory_fill_input_buffer
;
6162 src
->skip_input_data
= our_memory_skip_input_data
;
6163 src
->resync_to_restart
= jpeg_resync_to_restart_wrapper
; /* Use default method. */
6164 src
->term_source
= our_common_term_source
;
6165 src
->bytes_in_buffer
= len
;
6166 src
->next_input_byte
= data
;
6170 struct jpeg_stdio_mgr
6172 struct jpeg_source_mgr mgr
;
6179 /* Size of buffer to read JPEG from file.
6180 Not too big, as we want to use alloc_small. */
6181 #define JPEG_STDIO_BUFFER_SIZE 8192
6184 /* Fill input buffer method for JPEG data source manager. Called
6185 whenever more data is needed. The data is read from a FILE *. */
6188 our_stdio_fill_input_buffer (j_decompress_ptr cinfo
)
6190 struct jpeg_stdio_mgr
*src
;
6192 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6197 bytes
= fread (src
->buffer
, 1, JPEG_STDIO_BUFFER_SIZE
, src
->file
);
6199 src
->mgr
.bytes_in_buffer
= bytes
;
6202 WARNMS (cinfo
, JWRN_JPEG_EOF
);
6204 src
->buffer
[0] = (JOCTET
) 0xFF;
6205 src
->buffer
[1] = (JOCTET
) JPEG_EOI
;
6206 src
->mgr
.bytes_in_buffer
= 2;
6208 src
->mgr
.next_input_byte
= src
->buffer
;
6215 /* Method to skip over NUM_BYTES bytes in the image data. CINFO->src
6216 is the JPEG data source manager. */
6219 our_stdio_skip_input_data (j_decompress_ptr cinfo
, long int num_bytes
)
6221 struct jpeg_stdio_mgr
*src
;
6222 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6224 while (num_bytes
> 0 && !src
->finished
)
6226 if (num_bytes
<= src
->mgr
.bytes_in_buffer
)
6228 src
->mgr
.bytes_in_buffer
-= num_bytes
;
6229 src
->mgr
.next_input_byte
+= num_bytes
;
6234 num_bytes
-= src
->mgr
.bytes_in_buffer
;
6235 src
->mgr
.bytes_in_buffer
= 0;
6236 src
->mgr
.next_input_byte
= NULL
;
6238 our_stdio_fill_input_buffer (cinfo
);
6244 /* Set up the JPEG lib for reading an image from a FILE *.
6245 CINFO is the decompression info structure created for
6246 reading the image. */
6249 jpeg_file_src (j_decompress_ptr cinfo
, FILE *fp
)
6251 struct jpeg_stdio_mgr
*src
;
6253 if (cinfo
->src
!= NULL
)
6254 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6257 /* First time for this JPEG object? */
6258 cinfo
->src
= (struct jpeg_source_mgr
*)
6259 (*cinfo
->mem
->alloc_small
) ((j_common_ptr
) cinfo
, JPOOL_PERMANENT
,
6260 sizeof (struct jpeg_stdio_mgr
));
6261 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6262 src
->buffer
= (JOCTET
*)
6263 (*cinfo
->mem
->alloc_small
) ((j_common_ptr
) cinfo
, JPOOL_PERMANENT
,
6264 JPEG_STDIO_BUFFER_SIZE
);
6269 src
->mgr
.init_source
= our_common_init_source
;
6270 src
->mgr
.fill_input_buffer
= our_stdio_fill_input_buffer
;
6271 src
->mgr
.skip_input_data
= our_stdio_skip_input_data
;
6272 src
->mgr
.resync_to_restart
= jpeg_resync_to_restart_wrapper
; /* Use default method. */
6273 src
->mgr
.term_source
= our_common_term_source
;
6274 src
->mgr
.bytes_in_buffer
= 0;
6275 src
->mgr
.next_input_byte
= NULL
;
6279 /* Load image IMG for use on frame F. Patterned after example.c
6280 from the JPEG lib. */
6283 jpeg_load (struct frame
*f
, struct image
*img
)
6285 struct jpeg_decompress_struct cinfo
;
6286 struct my_jpeg_error_mgr mgr
;
6287 Lisp_Object file
, specified_file
;
6288 Lisp_Object specified_data
;
6289 FILE * volatile fp
= NULL
;
6291 int row_stride
, x
, y
;
6292 XImagePtr ximg
= NULL
;
6294 unsigned long *colors
;
6297 /* Open the JPEG file. */
6298 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
6299 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
6301 if (NILP (specified_data
))
6303 file
= x_find_image_file (specified_file
);
6304 if (!STRINGP (file
))
6306 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
6310 fp
= fopen (SSDATA (file
), "rb");
6313 image_error ("Cannot open `%s'", file
, Qnil
);
6317 else if (!STRINGP (specified_data
))
6319 image_error ("Invalid image data `%s'", specified_data
, Qnil
);
6323 /* Customize libjpeg's error handling to call my_error_exit when an
6324 error is detected. This function will perform a longjmp. */
6325 cinfo
.err
= fn_jpeg_std_error (&mgr
.pub
);
6326 mgr
.pub
.error_exit
= my_error_exit
;
6328 if ((rc
= setjmp (mgr
.setjmp_buffer
)) != 0)
6332 /* Called from my_error_exit. Display a JPEG error. */
6333 char buf
[JMSG_LENGTH_MAX
];
6334 cinfo
.err
->format_message ((j_common_ptr
) &cinfo
, buf
);
6335 image_error ("Error reading JPEG image `%s': %s", img
->spec
,
6336 build_string (buf
));
6339 /* Close the input file and destroy the JPEG object. */
6341 fclose ((FILE *) fp
);
6342 fn_jpeg_destroy_decompress (&cinfo
);
6344 /* If we already have an XImage, free that. */
6345 x_destroy_x_image (ximg
);
6347 /* Free pixmap and colors. */
6348 x_clear_image (f
, img
);
6352 /* Create the JPEG decompression object. Let it read from fp.
6353 Read the JPEG image header. */
6354 fn_jpeg_CreateDecompress (&cinfo
, JPEG_LIB_VERSION
, sizeof (cinfo
));
6356 if (NILP (specified_data
))
6357 jpeg_file_src (&cinfo
, (FILE *) fp
);
6359 jpeg_memory_src (&cinfo
, SDATA (specified_data
),
6360 SBYTES (specified_data
));
6362 fn_jpeg_read_header (&cinfo
, 1);
6364 /* Customize decompression so that color quantization will be used.
6365 Start decompression. */
6366 cinfo
.quantize_colors
= 1;
6367 fn_jpeg_start_decompress (&cinfo
);
6368 width
= img
->width
= cinfo
.output_width
;
6369 height
= img
->height
= cinfo
.output_height
;
6371 if (!check_image_size (f
, width
, height
))
6373 image_error ("Invalid image size (see `max-image-size')", Qnil
, Qnil
);
6374 longjmp (mgr
.setjmp_buffer
, 2);
6377 /* Create X image and pixmap. */
6378 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
6379 longjmp (mgr
.setjmp_buffer
, 2);
6381 /* Allocate colors. When color quantization is used,
6382 cinfo.actual_number_of_colors has been set with the number of
6383 colors generated, and cinfo.colormap is a two-dimensional array
6384 of color indices in the range 0..cinfo.actual_number_of_colors.
6385 No more than 255 colors will be generated. */
6389 if (cinfo
.out_color_components
> 2)
6390 ir
= 0, ig
= 1, ib
= 2;
6391 else if (cinfo
.out_color_components
> 1)
6392 ir
= 0, ig
= 1, ib
= 0;
6394 ir
= 0, ig
= 0, ib
= 0;
6396 /* Use the color table mechanism because it handles colors that
6397 cannot be allocated nicely. Such colors will be replaced with
6398 a default color, and we don't have to care about which colors
6399 can be freed safely, and which can't. */
6400 init_color_table ();
6401 colors
= (unsigned long *) alloca (cinfo
.actual_number_of_colors
6404 for (i
= 0; i
< cinfo
.actual_number_of_colors
; ++i
)
6406 /* Multiply RGB values with 255 because X expects RGB values
6407 in the range 0..0xffff. */
6408 int r
= cinfo
.colormap
[ir
][i
] << 8;
6409 int g
= cinfo
.colormap
[ig
][i
] << 8;
6410 int b
= cinfo
.colormap
[ib
][i
] << 8;
6411 colors
[i
] = lookup_rgb_color (f
, r
, g
, b
);
6414 #ifdef COLOR_TABLE_SUPPORT
6415 /* Remember those colors actually allocated. */
6416 img
->colors
= colors_in_color_table (&img
->ncolors
);
6417 free_color_table ();
6418 #endif /* COLOR_TABLE_SUPPORT */
6422 row_stride
= width
* cinfo
.output_components
;
6423 buffer
= cinfo
.mem
->alloc_sarray ((j_common_ptr
) &cinfo
, JPOOL_IMAGE
,
6425 for (y
= 0; y
< height
; ++y
)
6427 fn_jpeg_read_scanlines (&cinfo
, buffer
, 1);
6428 for (x
= 0; x
< cinfo
.output_width
; ++x
)
6429 XPutPixel (ximg
, x
, y
, colors
[buffer
[0][x
]]);
6433 fn_jpeg_finish_decompress (&cinfo
);
6434 fn_jpeg_destroy_decompress (&cinfo
);
6436 fclose ((FILE *) fp
);
6438 /* Maybe fill in the background field while we have ximg handy. */
6439 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
6440 /* Casting avoids a GCC warning. */
6441 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
6443 /* Put the image into the pixmap. */
6444 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
6445 x_destroy_x_image (ximg
);
6449 #else /* HAVE_JPEG */
6453 jpeg_load (struct frame
*f
, struct image
*img
)
6455 return ns_load_image (f
, img
,
6456 image_spec_value (img
->spec
, QCfile
, NULL
),
6457 image_spec_value (img
->spec
, QCdata
, NULL
));
6459 #endif /* HAVE_NS */
6461 #endif /* !HAVE_JPEG */
6465 /***********************************************************************
6467 ***********************************************************************/
6469 #if defined (HAVE_TIFF) || defined (HAVE_NS)
6471 static int tiff_image_p (Lisp_Object object
);
6472 static int tiff_load (struct frame
*f
, struct image
*img
);
6474 /* The symbol `tiff' identifying images of this type. */
6476 static Lisp_Object Qtiff
;
6478 /* Indices of image specification fields in tiff_format, below. */
6480 enum tiff_keyword_index
6489 TIFF_HEURISTIC_MASK
,
6496 /* Vector of image_keyword structures describing the format
6497 of valid user-defined image specifications. */
6499 static const struct image_keyword tiff_format
[TIFF_LAST
] =
6501 {":type", IMAGE_SYMBOL_VALUE
, 1},
6502 {":data", IMAGE_STRING_VALUE
, 0},
6503 {":file", IMAGE_STRING_VALUE
, 0},
6504 {":ascent", IMAGE_ASCENT_VALUE
, 0},
6505 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
6506 {":relief", IMAGE_INTEGER_VALUE
, 0},
6507 {":conversions", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6508 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6509 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6510 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0},
6511 {":index", IMAGE_NON_NEGATIVE_INTEGER_VALUE
, 0}
6514 /* Structure describing the image type `tiff'. */
6516 static struct image_type tiff_type
=
6525 /* Return non-zero if OBJECT is a valid TIFF image specification. */
6528 tiff_image_p (Lisp_Object object
)
6530 struct image_keyword fmt
[TIFF_LAST
];
6531 memcpy (fmt
, tiff_format
, sizeof fmt
);
6533 if (!parse_image_spec (object
, fmt
, TIFF_LAST
, Qtiff
))
6536 /* Must specify either the :data or :file keyword. */
6537 return fmt
[TIFF_FILE
].count
+ fmt
[TIFF_DATA
].count
== 1;
6540 #endif /* HAVE_TIFF || HAVE_NS */
6548 /* TIFF library details. */
6549 DEF_IMGLIB_FN (TIFFErrorHandler
, TIFFSetErrorHandler
, (TIFFErrorHandler
));
6550 DEF_IMGLIB_FN (TIFFErrorHandler
, TIFFSetWarningHandler
, (TIFFErrorHandler
));
6551 DEF_IMGLIB_FN (TIFF
*, TIFFOpen
, (const char *, const char *));
6552 DEF_IMGLIB_FN (TIFF
*, TIFFClientOpen
, (const char *, const char *, thandle_t
,
6553 TIFFReadWriteProc
, TIFFReadWriteProc
,
6554 TIFFSeekProc
, TIFFCloseProc
, TIFFSizeProc
,
6555 TIFFMapFileProc
, TIFFUnmapFileProc
));
6556 DEF_IMGLIB_FN (int, TIFFGetField
, (TIFF
*, ttag_t
, ...));
6557 DEF_IMGLIB_FN (int, TIFFReadRGBAImage
, (TIFF
*, uint32
, uint32
, uint32
*, int));
6558 DEF_IMGLIB_FN (void, TIFFClose
, (TIFF
*));
6559 DEF_IMGLIB_FN (int, TIFFSetDirectory
, (TIFF
*, tdir_t
));
6562 init_tiff_functions (Lisp_Object libraries
)
6566 if (!(library
= w32_delayed_load (libraries
, Qtiff
)))
6569 LOAD_IMGLIB_FN (library
, TIFFSetErrorHandler
);
6570 LOAD_IMGLIB_FN (library
, TIFFSetWarningHandler
);
6571 LOAD_IMGLIB_FN (library
, TIFFOpen
);
6572 LOAD_IMGLIB_FN (library
, TIFFClientOpen
);
6573 LOAD_IMGLIB_FN (library
, TIFFGetField
);
6574 LOAD_IMGLIB_FN (library
, TIFFReadRGBAImage
);
6575 LOAD_IMGLIB_FN (library
, TIFFClose
);
6576 LOAD_IMGLIB_FN (library
, TIFFSetDirectory
);
6582 #define fn_TIFFSetErrorHandler TIFFSetErrorHandler
6583 #define fn_TIFFSetWarningHandler TIFFSetWarningHandler
6584 #define fn_TIFFOpen TIFFOpen
6585 #define fn_TIFFClientOpen TIFFClientOpen
6586 #define fn_TIFFGetField TIFFGetField
6587 #define fn_TIFFReadRGBAImage TIFFReadRGBAImage
6588 #define fn_TIFFClose TIFFClose
6589 #define fn_TIFFSetDirectory TIFFSetDirectory
6590 #endif /* HAVE_NTGUI */
6593 /* Reading from a memory buffer for TIFF images Based on the PNG
6594 memory source, but we have to provide a lot of extra functions.
6597 We really only need to implement read and seek, but I am not
6598 convinced that the TIFF library is smart enough not to destroy
6599 itself if we only hand it the function pointers we need to
6604 unsigned char *bytes
;
6611 tiff_read_from_memory (thandle_t data
, tdata_t buf
, tsize_t size
)
6613 tiff_memory_source
*src
= (tiff_memory_source
*) data
;
6615 if (size
> src
->len
- src
->index
)
6617 memcpy (buf
, src
->bytes
+ src
->index
, size
);
6623 tiff_write_from_memory (thandle_t data
, tdata_t buf
, tsize_t size
)
6629 tiff_seek_in_memory (thandle_t data
, toff_t off
, int whence
)
6631 tiff_memory_source
*src
= (tiff_memory_source
*) data
;
6636 case SEEK_SET
: /* Go from beginning of source. */
6640 case SEEK_END
: /* Go from end of source. */
6641 idx
= src
->len
+ off
;
6644 case SEEK_CUR
: /* Go from current position. */
6645 idx
= src
->index
+ off
;
6648 default: /* Invalid `whence'. */
6652 if (idx
> src
->len
|| idx
< 0)
6660 tiff_close_memory (thandle_t data
)
6667 tiff_mmap_memory (thandle_t data
, tdata_t
*pbase
, toff_t
*psize
)
6669 /* It is already _IN_ memory. */
6674 tiff_unmap_memory (thandle_t data
, tdata_t base
, toff_t size
)
6676 /* We don't need to do this. */
6680 tiff_size_of_memory (thandle_t data
)
6682 return ((tiff_memory_source
*) data
)->len
;
6686 static void tiff_error_handler (const char *, const char *, va_list)
6687 ATTRIBUTE_FORMAT_PRINTF (2, 0);
6689 tiff_error_handler (const char *title
, const char *format
, va_list ap
)
6694 len
= sprintf (buf
, "TIFF error: %s ", title
);
6695 vsprintf (buf
+ len
, format
, ap
);
6696 add_to_log (buf
, Qnil
, Qnil
);
6700 static void tiff_warning_handler (const char *, const char *, va_list)
6701 ATTRIBUTE_FORMAT_PRINTF (2, 0);
6703 tiff_warning_handler (const char *title
, const char *format
, va_list ap
)
6708 len
= sprintf (buf
, "TIFF warning: %s ", title
);
6709 vsprintf (buf
+ len
, format
, ap
);
6710 add_to_log (buf
, Qnil
, Qnil
);
6714 /* Load TIFF image IMG for use on frame F. Value is non-zero if
6718 tiff_load (struct frame
*f
, struct image
*img
)
6720 Lisp_Object file
, specified_file
;
6721 Lisp_Object specified_data
;
6723 int width
, height
, x
, y
, count
;
6727 tiff_memory_source memsrc
;
6730 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
6731 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
6733 fn_TIFFSetErrorHandler ((TIFFErrorHandler
) tiff_error_handler
);
6734 fn_TIFFSetWarningHandler ((TIFFErrorHandler
) tiff_warning_handler
);
6736 if (NILP (specified_data
))
6738 /* Read from a file */
6739 file
= x_find_image_file (specified_file
);
6740 if (!STRINGP (file
))
6742 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
6746 /* Try to open the image file. */
6747 tiff
= fn_TIFFOpen (SSDATA (file
), "r");
6750 image_error ("Cannot open `%s'", file
, Qnil
);
6756 if (!STRINGP (specified_data
))
6758 image_error ("Invalid image data `%s'", specified_data
, Qnil
);
6762 /* Memory source! */
6763 memsrc
.bytes
= SDATA (specified_data
);
6764 memsrc
.len
= SBYTES (specified_data
);
6767 tiff
= fn_TIFFClientOpen ("memory_source", "r", (thandle_t
)&memsrc
,
6768 (TIFFReadWriteProc
) tiff_read_from_memory
,
6769 (TIFFReadWriteProc
) tiff_write_from_memory
,
6770 tiff_seek_in_memory
,
6772 tiff_size_of_memory
,
6778 image_error ("Cannot open memory source for `%s'", img
->spec
, Qnil
);
6783 image
= image_spec_value (img
->spec
, QCindex
, NULL
);
6784 if (INTEGERP (image
))
6786 int ino
= XFASTINT (image
);
6787 if (!fn_TIFFSetDirectory (tiff
, ino
))
6789 image_error ("Invalid image number `%s' in image `%s'",
6791 fn_TIFFClose (tiff
);
6796 /* Get width and height of the image, and allocate a raster buffer
6797 of width x height 32-bit values. */
6798 fn_TIFFGetField (tiff
, TIFFTAG_IMAGEWIDTH
, &width
);
6799 fn_TIFFGetField (tiff
, TIFFTAG_IMAGELENGTH
, &height
);
6801 if (!check_image_size (f
, width
, height
))
6803 image_error ("Invalid image size (see `max-image-size')", Qnil
, Qnil
);
6804 fn_TIFFClose (tiff
);
6808 buf
= (uint32
*) xmalloc (width
* height
* sizeof *buf
);
6810 rc
= fn_TIFFReadRGBAImage (tiff
, width
, height
, buf
, 0);
6812 /* Count the number of images in the file. */
6813 for (count
= 1; fn_TIFFSetDirectory (tiff
, count
); count
++)
6817 img
->lisp_data
= Fcons (Qcount
,
6818 Fcons (make_number (count
),
6821 fn_TIFFClose (tiff
);
6824 image_error ("Error reading TIFF image `%s'", img
->spec
, Qnil
);
6829 /* Create the X image and pixmap. */
6830 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
6836 /* Initialize the color table. */
6837 init_color_table ();
6839 /* Process the pixel raster. Origin is in the lower-left corner. */
6840 for (y
= 0; y
< height
; ++y
)
6842 uint32
*row
= buf
+ y
* width
;
6844 for (x
= 0; x
< width
; ++x
)
6846 uint32 abgr
= row
[x
];
6847 int r
= TIFFGetR (abgr
) << 8;
6848 int g
= TIFFGetG (abgr
) << 8;
6849 int b
= TIFFGetB (abgr
) << 8;
6850 XPutPixel (ximg
, x
, height
- 1 - y
, lookup_rgb_color (f
, r
, g
, b
));
6854 #ifdef COLOR_TABLE_SUPPORT
6855 /* Remember the colors allocated for the image. Free the color table. */
6856 img
->colors
= colors_in_color_table (&img
->ncolors
);
6857 free_color_table ();
6858 #endif /* COLOR_TABLE_SUPPORT */
6861 img
->height
= height
;
6863 /* Maybe fill in the background field while we have ximg handy. */
6864 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
6865 /* Casting avoids a GCC warning on W32. */
6866 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
6868 /* Put the image into the pixmap, then free the X image and its buffer. */
6869 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
6870 x_destroy_x_image (ximg
);
6876 #else /* HAVE_TIFF */
6880 tiff_load (struct frame
*f
, struct image
*img
)
6882 return ns_load_image (f
, img
,
6883 image_spec_value (img
->spec
, QCfile
, NULL
),
6884 image_spec_value (img
->spec
, QCdata
, NULL
));
6886 #endif /* HAVE_NS */
6888 #endif /* !HAVE_TIFF */
6892 /***********************************************************************
6894 ***********************************************************************/
6896 #if defined (HAVE_GIF) || defined (HAVE_NS)
6898 static int gif_image_p (Lisp_Object object
);
6899 static int gif_load (struct frame
*f
, struct image
*img
);
6900 static void gif_clear_image (struct frame
*f
, struct image
*img
);
6902 /* The symbol `gif' identifying images of this type. */
6904 static Lisp_Object Qgif
;
6906 /* Indices of image specification fields in gif_format, below. */
6908 enum gif_keyword_index
6924 /* Vector of image_keyword structures describing the format
6925 of valid user-defined image specifications. */
6927 static const struct image_keyword gif_format
[GIF_LAST
] =
6929 {":type", IMAGE_SYMBOL_VALUE
, 1},
6930 {":data", IMAGE_STRING_VALUE
, 0},
6931 {":file", IMAGE_STRING_VALUE
, 0},
6932 {":ascent", IMAGE_ASCENT_VALUE
, 0},
6933 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
6934 {":relief", IMAGE_INTEGER_VALUE
, 0},
6935 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6936 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6937 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6938 {":index", IMAGE_NON_NEGATIVE_INTEGER_VALUE
, 0},
6939 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
6942 /* Structure describing the image type `gif'. */
6944 static struct image_type gif_type
=
6953 /* Free X resources of GIF image IMG which is used on frame F. */
6956 gif_clear_image (struct frame
*f
, struct image
*img
)
6958 img
->lisp_data
= Qnil
;
6959 x_clear_image (f
, img
);
6962 /* Return non-zero if OBJECT is a valid GIF image specification. */
6965 gif_image_p (Lisp_Object object
)
6967 struct image_keyword fmt
[GIF_LAST
];
6968 memcpy (fmt
, gif_format
, sizeof fmt
);
6970 if (!parse_image_spec (object
, fmt
, GIF_LAST
, Qgif
))
6973 /* Must specify either the :data or :file keyword. */
6974 return fmt
[GIF_FILE
].count
+ fmt
[GIF_DATA
].count
== 1;
6977 #endif /* HAVE_GIF */
6981 #if defined (HAVE_NTGUI)
6982 /* winuser.h might define DrawText to DrawTextA or DrawTextW.
6983 Undefine before redefining to avoid a preprocessor warning. */
6987 /* avoid conflict with QuickdrawText.h */
6988 #define DrawText gif_DrawText
6989 #include <gif_lib.h>
6992 #else /* HAVE_NTGUI */
6994 #include <gif_lib.h>
6996 #endif /* HAVE_NTGUI */
7001 /* GIF library details. */
7002 DEF_IMGLIB_FN (int, DGifCloseFile
, (GifFileType
*));
7003 DEF_IMGLIB_FN (int, DGifSlurp
, (GifFileType
*));
7004 DEF_IMGLIB_FN (GifFileType
*, DGifOpen
, (void *, InputFunc
));
7005 DEF_IMGLIB_FN (GifFileType
*, DGifOpenFileName
, (const char *));
7008 init_gif_functions (Lisp_Object libraries
)
7012 if (!(library
= w32_delayed_load (libraries
, Qgif
)))
7015 LOAD_IMGLIB_FN (library
, DGifCloseFile
);
7016 LOAD_IMGLIB_FN (library
, DGifSlurp
);
7017 LOAD_IMGLIB_FN (library
, DGifOpen
);
7018 LOAD_IMGLIB_FN (library
, DGifOpenFileName
);
7024 #define fn_DGifCloseFile DGifCloseFile
7025 #define fn_DGifSlurp DGifSlurp
7026 #define fn_DGifOpen DGifOpen
7027 #define fn_DGifOpenFileName DGifOpenFileName
7029 #endif /* HAVE_NTGUI */
7031 /* Reading a GIF image from memory
7032 Based on the PNG memory stuff to a certain extent. */
7036 unsigned char *bytes
;
7042 /* Make the current memory source available to gif_read_from_memory.
7043 It's done this way because not all versions of libungif support
7044 a UserData field in the GifFileType structure. */
7045 static gif_memory_source
*current_gif_memory_src
;
7048 gif_read_from_memory (GifFileType
*file
, GifByteType
*buf
, int len
)
7050 gif_memory_source
*src
= current_gif_memory_src
;
7052 if (len
> src
->len
- src
->index
)
7055 memcpy (buf
, src
->bytes
+ src
->index
, len
);
7061 /* Load GIF image IMG for use on frame F. Value is non-zero if
7064 static const int interlace_start
[] = {0, 4, 2, 1};
7065 static const int interlace_increment
[] = {8, 8, 4, 2};
7067 #define GIF_LOCAL_DESCRIPTOR_EXTENSION 249
7070 gif_load (struct frame
*f
, struct image
*img
)
7073 int rc
, width
, height
, x
, y
, i
, j
;
7075 ColorMapObject
*gif_color_map
;
7076 unsigned long pixel_colors
[256];
7078 int image_height
, image_width
;
7079 gif_memory_source memsrc
;
7080 Lisp_Object specified_bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
7081 Lisp_Object specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
7082 Lisp_Object specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
7083 unsigned long bgcolor
= 0;
7086 if (NILP (specified_data
))
7088 file
= x_find_image_file (specified_file
);
7089 if (!STRINGP (file
))
7091 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
7095 /* Open the GIF file. */
7096 gif
= fn_DGifOpenFileName (SSDATA (file
));
7099 image_error ("Cannot open `%s'", file
, Qnil
);
7105 if (!STRINGP (specified_data
))
7107 image_error ("Invalid image data `%s'", specified_data
, Qnil
);
7111 /* Read from memory! */
7112 current_gif_memory_src
= &memsrc
;
7113 memsrc
.bytes
= SDATA (specified_data
);
7114 memsrc
.len
= SBYTES (specified_data
);
7117 gif
= fn_DGifOpen (&memsrc
, gif_read_from_memory
);
7120 image_error ("Cannot open memory source `%s'", img
->spec
, Qnil
);
7125 /* Before reading entire contents, check the declared image size. */
7126 if (!check_image_size (f
, gif
->SWidth
, gif
->SHeight
))
7128 image_error ("Invalid image size (see `max-image-size')", Qnil
, Qnil
);
7129 fn_DGifCloseFile (gif
);
7133 /* Read entire contents. */
7134 rc
= fn_DGifSlurp (gif
);
7135 if (rc
== GIF_ERROR
|| gif
->ImageCount
<= 0)
7137 image_error ("Error reading `%s'", img
->spec
, Qnil
);
7138 fn_DGifCloseFile (gif
);
7142 /* Which sub-image are we to display? */
7144 Lisp_Object image_number
= image_spec_value (img
->spec
, QCindex
, NULL
);
7145 idx
= INTEGERP (image_number
) ? XFASTINT (image_number
) : 0;
7146 if (idx
< 0 || idx
>= gif
->ImageCount
)
7148 image_error ("Invalid image number `%s' in image `%s'",
7149 image_number
, img
->spec
);
7150 fn_DGifCloseFile (gif
);
7155 img
->corners
[TOP_CORNER
] = gif
->SavedImages
[idx
].ImageDesc
.Top
;
7156 img
->corners
[LEFT_CORNER
] = gif
->SavedImages
[idx
].ImageDesc
.Left
;
7157 image_height
= gif
->SavedImages
[idx
].ImageDesc
.Height
;
7158 img
->corners
[BOT_CORNER
] = img
->corners
[TOP_CORNER
] + image_height
;
7159 image_width
= gif
->SavedImages
[idx
].ImageDesc
.Width
;
7160 img
->corners
[RIGHT_CORNER
] = img
->corners
[LEFT_CORNER
] + image_width
;
7162 width
= img
->width
= max (gif
->SWidth
,
7163 max (gif
->Image
.Left
+ gif
->Image
.Width
,
7164 img
->corners
[RIGHT_CORNER
]));
7165 height
= img
->height
= max (gif
->SHeight
,
7166 max (gif
->Image
.Top
+ gif
->Image
.Height
,
7167 img
->corners
[BOT_CORNER
]));
7169 if (!check_image_size (f
, width
, height
))
7171 image_error ("Invalid image size (see `max-image-size')", Qnil
, Qnil
);
7172 fn_DGifCloseFile (gif
);
7176 /* Create the X image and pixmap. */
7177 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
7179 fn_DGifCloseFile (gif
);
7183 /* Clear the part of the screen image not covered by the image.
7184 Full animated GIF support requires more here (see the gif89 spec,
7185 disposal methods). Let's simply assume that the part not covered
7186 by a sub-image is in the frame's background color. */
7187 for (y
= 0; y
< img
->corners
[TOP_CORNER
]; ++y
)
7188 for (x
= 0; x
< width
; ++x
)
7189 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7191 for (y
= img
->corners
[BOT_CORNER
]; y
< height
; ++y
)
7192 for (x
= 0; x
< width
; ++x
)
7193 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7195 for (y
= img
->corners
[TOP_CORNER
]; y
< img
->corners
[BOT_CORNER
]; ++y
)
7197 for (x
= 0; x
< img
->corners
[LEFT_CORNER
]; ++x
)
7198 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7199 for (x
= img
->corners
[RIGHT_CORNER
]; x
< width
; ++x
)
7200 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7203 /* Read the GIF image into the X image. */
7205 /* FIXME: With the current implementation, loading an animated gif
7206 is quadratic in the number of animation frames, since each frame
7207 is a separate struct image. We must provide a way for a single
7208 gif_load call to construct and save all animation frames. */
7210 init_color_table ();
7211 if (STRINGP (specified_bg
))
7212 bgcolor
= x_alloc_image_color (f
, img
, specified_bg
,
7213 FRAME_BACKGROUND_PIXEL (f
));
7214 for (j
= 0; j
<= idx
; ++j
)
7216 /* We use a local variable `raster' here because RasterBits is a
7217 char *, which invites problems with bytes >= 0x80. */
7218 struct SavedImage
*subimage
= gif
->SavedImages
+ j
;
7219 unsigned char *raster
= (unsigned char *) subimage
->RasterBits
;
7220 int transparency_color_index
= -1;
7223 /* Find the Graphic Control Extension block for this sub-image.
7224 Extract the disposal method and transparency color. */
7225 for (i
= 0; i
< subimage
->ExtensionBlockCount
; i
++)
7227 ExtensionBlock
*extblock
= subimage
->ExtensionBlocks
+ i
;
7229 if ((extblock
->Function
== GIF_LOCAL_DESCRIPTOR_EXTENSION
)
7230 && extblock
->ByteCount
== 4
7231 && extblock
->Bytes
[0] & 1)
7233 /* From gif89a spec: 1 = "keep in place", 2 = "restore
7234 to background". Treat any other value like 2. */
7235 disposal
= (extblock
->Bytes
[0] >> 2) & 7;
7236 transparency_color_index
= (unsigned char) extblock
->Bytes
[3];
7241 /* We can't "keep in place" the first subimage. */
7245 /* Allocate subimage colors. */
7246 memset (pixel_colors
, 0, sizeof pixel_colors
);
7247 gif_color_map
= subimage
->ImageDesc
.ColorMap
;
7249 gif_color_map
= gif
->SColorMap
;
7252 for (i
= 0; i
< gif_color_map
->ColorCount
; ++i
)
7254 if (transparency_color_index
== i
)
7255 pixel_colors
[i
] = STRINGP (specified_bg
)
7256 ? bgcolor
: FRAME_BACKGROUND_PIXEL (f
);
7259 int r
= gif_color_map
->Colors
[i
].Red
<< 8;
7260 int g
= gif_color_map
->Colors
[i
].Green
<< 8;
7261 int b
= gif_color_map
->Colors
[i
].Blue
<< 8;
7262 pixel_colors
[i
] = lookup_rgb_color (f
, r
, g
, b
);
7266 /* Apply the pixel values. */
7267 if (gif
->SavedImages
[j
].ImageDesc
.Interlace
)
7271 for (y
= 0, row
= interlace_start
[0], pass
= 0;
7273 y
++, row
+= interlace_increment
[pass
])
7275 if (row
>= image_height
)
7277 row
= interlace_start
[++pass
];
7278 while (row
>= image_height
)
7279 row
= interlace_start
[++pass
];
7282 for (x
= 0; x
< image_width
; x
++)
7284 int c
= raster
[y
* image_width
+ x
];
7285 if (transparency_color_index
!= c
|| disposal
!= 1)
7286 XPutPixel (ximg
, x
+ img
->corners
[LEFT_CORNER
],
7287 row
+ img
->corners
[TOP_CORNER
], pixel_colors
[c
]);
7293 for (y
= 0; y
< image_height
; ++y
)
7294 for (x
= 0; x
< image_width
; ++x
)
7296 int c
= raster
[y
* image_width
+ x
];
7297 if (transparency_color_index
!= c
|| disposal
!= 1)
7298 XPutPixel (ximg
, x
+ img
->corners
[LEFT_CORNER
],
7299 y
+ img
->corners
[TOP_CORNER
], pixel_colors
[c
]);
7304 #ifdef COLOR_TABLE_SUPPORT
7305 img
->colors
= colors_in_color_table (&img
->ncolors
);
7306 free_color_table ();
7307 #endif /* COLOR_TABLE_SUPPORT */
7309 /* Save GIF image extension data for `image-metadata'.
7310 Format is (count IMAGES extension-data (FUNCTION "BYTES" ...)). */
7311 img
->lisp_data
= Qnil
;
7312 if (gif
->SavedImages
[idx
].ExtensionBlockCount
> 0)
7314 unsigned int delay
= 0;
7315 ExtensionBlock
*ext
= gif
->SavedImages
[idx
].ExtensionBlocks
;
7316 for (i
= 0; i
< gif
->SavedImages
[idx
].ExtensionBlockCount
; i
++, ext
++)
7317 /* Append (... FUNCTION "BYTES") */
7320 = Fcons (make_number (ext
->Function
),
7321 Fcons (make_unibyte_string (ext
->Bytes
, ext
->ByteCount
),
7323 if (ext
->Function
== GIF_LOCAL_DESCRIPTOR_EXTENSION
7324 && ext
->ByteCount
== 4)
7326 delay
= ext
->Bytes
[2] << CHAR_BIT
;
7327 delay
|= ext
->Bytes
[1];
7330 img
->lisp_data
= Fcons (Qextension_data
,
7331 Fcons (img
->lisp_data
, Qnil
));
7335 Fcons (make_float (((double) delay
) * 0.01),
7339 if (gif
->ImageCount
> 1)
7340 img
->lisp_data
= Fcons (Qcount
,
7341 Fcons (make_number (gif
->ImageCount
),
7344 fn_DGifCloseFile (gif
);
7346 /* Maybe fill in the background field while we have ximg handy. */
7347 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
7348 /* Casting avoids a GCC warning. */
7349 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
7351 /* Put the image into the pixmap, then free the X image and its buffer. */
7352 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
7353 x_destroy_x_image (ximg
);
7358 #else /* !HAVE_GIF */
7362 gif_load (struct frame
*f
, struct image
*img
)
7364 return ns_load_image (f
, img
,
7365 image_spec_value (img
->spec
, QCfile
, NULL
),
7366 image_spec_value (img
->spec
, QCdata
, NULL
));
7368 #endif /* HAVE_NS */
7370 #endif /* HAVE_GIF */
7373 /***********************************************************************
7375 ***********************************************************************/
7376 #if defined (HAVE_IMAGEMAGICK)
7378 static Lisp_Object Qimagemagick
;
7380 static int imagemagick_image_p (Lisp_Object
);
7381 static int imagemagick_load (struct frame
*, struct image
*);
7382 static void imagemagick_clear_image (struct frame
*, struct image
*);
7384 /* Indices of image specification fields in imagemagick_format. */
7386 enum imagemagick_keyword_index
7394 IMAGEMAGICK_ALGORITHM
,
7395 IMAGEMAGICK_HEURISTIC_MASK
,
7397 IMAGEMAGICK_BACKGROUND
,
7400 IMAGEMAGICK_ROTATION
,
7405 /* Vector of image_keyword structures describing the format
7406 of valid user-defined image specifications. */
7408 static struct image_keyword imagemagick_format
[IMAGEMAGICK_LAST
] =
7410 {":type", IMAGE_SYMBOL_VALUE
, 1},
7411 {":data", IMAGE_STRING_VALUE
, 0},
7412 {":file", IMAGE_STRING_VALUE
, 0},
7413 {":ascent", IMAGE_ASCENT_VALUE
, 0},
7414 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
7415 {":relief", IMAGE_INTEGER_VALUE
, 0},
7416 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7417 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7418 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7419 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0},
7420 {":height", IMAGE_INTEGER_VALUE
, 0},
7421 {":width", IMAGE_INTEGER_VALUE
, 0},
7422 {":rotation", IMAGE_NUMBER_VALUE
, 0},
7423 {":crop", IMAGE_DONT_CHECK_VALUE_TYPE
, 0}
7426 /* Structure describing the image type for any image handled via
7429 static struct image_type imagemagick_type
=
7432 imagemagick_image_p
,
7434 imagemagick_clear_image
,
7438 /* Free X resources of imagemagick image IMG which is used on frame F. */
7441 imagemagick_clear_image (struct frame
*f
,
7444 x_clear_image (f
, img
);
7447 /* Return non-zero if OBJECT is a valid IMAGEMAGICK image specification. Do
7448 this by calling parse_image_spec and supplying the keywords that
7449 identify the IMAGEMAGICK format. */
7452 imagemagick_image_p (Lisp_Object object
)
7454 struct image_keyword fmt
[IMAGEMAGICK_LAST
];
7455 memcpy (fmt
, imagemagick_format
, sizeof fmt
);
7457 if (!parse_image_spec (object
, fmt
, IMAGEMAGICK_LAST
, Qimagemagick
))
7460 /* Must specify either the :data or :file keyword. */
7461 return fmt
[IMAGEMAGICK_FILE
].count
+ fmt
[IMAGEMAGICK_DATA
].count
== 1;
7464 /* The GIF library also defines DrawRectangle, but its never used in Emacs.
7465 Therefore rename the function so it doesnt collide with ImageMagick. */
7466 #define DrawRectangle DrawRectangleGif
7467 #include <wand/MagickWand.h>
7469 /* ImageMagick 6.5.3 through 6.6.5 hid PixelGetMagickColor for some reason.
7470 Emacs seems to work fine with the hidden version, so unhide it. */
7471 #include <magick/version.h>
7472 #if 0x653 <= MagickLibVersion && MagickLibVersion <= 0x665
7473 extern WandExport
void PixelGetMagickColor (const PixelWand
*,
7474 MagickPixelPacket
*);
7477 /* Helper function for imagemagick_load, which does the actual loading
7478 given contents and size, apart from frame and image structures,
7479 passed from imagemagick_load. Uses librimagemagick to do most of
7480 the image processing.
7482 F is a pointer to the Emacs frame; IMG to the image structure to
7483 prepare; CONTENTS is the string containing the IMAGEMAGICK data to
7484 be parsed; SIZE is the number of bytes of data; and FILENAME is
7485 either the file name or the image data.
7487 Return non-zero if successful. */
7490 imagemagick_load_image (struct frame
*f
, struct image
*img
,
7491 unsigned char *contents
, unsigned int size
,
7497 MagickBooleanType status
;
7503 MagickWand
*image_wand
;
7504 MagickWand
*ping_wand
;
7505 PixelIterator
*iterator
;
7507 MagickPixelPacket pixel
;
7512 int desired_width
, desired_height
;
7514 int imagemagick_rendermethod
;
7516 ImageInfo
*image_info
;
7517 ExceptionInfo
*exception
;
7521 /* Handle image index for image types who can contain more than one image.
7522 Interface :index is same as for GIF. First we "ping" the image to see how
7523 many sub-images it contains. Pinging is faster than loading the image to
7524 find out things about it. */
7526 /* Initialize the imagemagick environment. */
7527 MagickWandGenesis ();
7528 image
= image_spec_value (img
->spec
, QCindex
, NULL
);
7529 ino
= INTEGERP (image
) ? XFASTINT (image
) : 0;
7530 ping_wand
= NewMagickWand ();
7531 MagickSetResolution (ping_wand
, 2, 2);
7532 if (filename
!= NULL
)
7534 status
= MagickPingImage (ping_wand
, filename
);
7538 status
= MagickPingImageBlob (ping_wand
, contents
, size
);
7541 if (ino
>= MagickGetNumberImages (ping_wand
))
7543 image_error ("Invalid image number `%s' in image `%s'",
7545 DestroyMagickWand (ping_wand
);
7549 if (MagickGetNumberImages(ping_wand
) > 1)
7552 Fcons (make_number (MagickGetNumberImages (ping_wand
)),
7555 DestroyMagickWand (ping_wand
);
7557 /* Now we know how many images are inside the file. If it's not a
7558 bundle, the number is one. */
7560 if (filename
!= NULL
)
7562 image_info
= CloneImageInfo ((ImageInfo
*) NULL
);
7563 (void) strcpy (image_info
->filename
, filename
);
7564 image_info
->number_scenes
= 1;
7565 image_info
->scene
= ino
;
7566 exception
= AcquireExceptionInfo ();
7568 im_image
= ReadImage (image_info
, exception
);
7569 DestroyExceptionInfo (exception
);
7571 if (im_image
== NULL
)
7572 goto imagemagick_no_wand
;
7573 image_wand
= NewMagickWandFromImage (im_image
);
7574 DestroyImage(im_image
);
7578 image_wand
= NewMagickWand ();
7579 if (MagickReadImageBlob (image_wand
, contents
, size
) == MagickFalse
)
7580 goto imagemagick_error
;
7583 /* If width and/or height is set in the display spec assume we want
7584 to scale to those values. If either h or w is unspecified, the
7585 unspecified should be calculated from the specified to preserve
7588 value
= image_spec_value (img
->spec
, QCwidth
, NULL
);
7589 desired_width
= (INTEGERP (value
) ? XFASTINT (value
) : -1);
7590 value
= image_spec_value (img
->spec
, QCheight
, NULL
);
7591 desired_height
= (INTEGERP (value
) ? XFASTINT (value
) : -1);
7593 height
= MagickGetImageHeight (image_wand
);
7594 width
= MagickGetImageWidth (image_wand
);
7596 if (desired_width
!= -1 && desired_height
== -1)
7597 /* w known, calculate h. */
7598 desired_height
= (double) desired_width
/ width
* height
;
7599 if (desired_width
== -1 && desired_height
!= -1)
7600 /* h known, calculate w. */
7601 desired_width
= (double) desired_height
/ height
* width
;
7602 if (desired_width
!= -1 && desired_height
!= -1)
7604 status
= MagickScaleImage (image_wand
, desired_width
, desired_height
);
7605 if (status
== MagickFalse
)
7607 image_error ("Imagemagick scale failed", Qnil
, Qnil
);
7608 goto imagemagick_error
;
7612 /* crop behaves similar to image slicing in Emacs but is more memory
7614 crop
= image_spec_value (img
->spec
, QCcrop
, NULL
);
7616 if (CONSP (crop
) && INTEGERP (XCAR (crop
)))
7618 /* After some testing, it seems MagickCropImage is the fastest crop
7619 function in ImageMagick. This crop function seems to do less copying
7620 than the alternatives, but it still reads the entire image into memory
7621 before croping, which is aparently difficult to avoid when using
7624 w
= XFASTINT (XCAR (crop
));
7626 if (CONSP (crop
) && INTEGERP (XCAR (crop
)))
7628 h
= XFASTINT (XCAR (crop
));
7630 if (CONSP (crop
) && INTEGERP (XCAR (crop
)))
7632 x
= XFASTINT (XCAR (crop
));
7634 if (CONSP (crop
) && INTEGERP (XCAR (crop
)))
7636 y
= XFASTINT (XCAR (crop
));
7637 MagickCropImage (image_wand
, w
, h
, x
, y
);
7643 /* Furthermore :rotation. we need background color and angle for
7646 TODO background handling for rotation specified_bg =
7647 image_spec_value (img->spec, QCbackground, NULL); if (!STRINGP
7649 value
= image_spec_value (img
->spec
, QCrotation
, NULL
);
7652 PixelWand
* background
= NewPixelWand ();
7653 PixelSetColor (background
, "#ffffff");/*TODO remove hardcode*/
7655 rotation
= extract_float (value
);
7657 status
= MagickRotateImage (image_wand
, background
, rotation
);
7658 DestroyPixelWand (background
);
7659 if (status
== MagickFalse
)
7661 image_error ("Imagemagick image rotate failed", Qnil
, Qnil
);
7662 goto imagemagick_error
;
7666 /* Finally we are done manipulating the image. Figure out the
7667 resulting width/height and transfer ownerwship to Emacs. */
7668 height
= MagickGetImageHeight (image_wand
);
7669 width
= MagickGetImageWidth (image_wand
);
7671 if (! check_image_size (f
, width
, height
))
7673 image_error ("Invalid image size (see `max-image-size')", Qnil
, Qnil
);
7674 goto imagemagick_error
;
7677 /* We can now get a valid pixel buffer from the imagemagick file, if all
7680 init_color_table ();
7681 imagemagick_rendermethod
= (INTEGERP (Vimagemagick_render_type
)
7682 ? XFASTINT (Vimagemagick_render_type
) : 0);
7683 if (imagemagick_rendermethod
== 0)
7685 /* Try to create a x pixmap to hold the imagemagick pixmap. */
7686 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0,
7687 &ximg
, &img
->pixmap
))
7689 #ifdef COLOR_TABLE_SUPPORT
7690 free_color_table ();
7692 image_error("Imagemagick X bitmap allocation failure", Qnil
, Qnil
);
7693 goto imagemagick_error
;
7696 /* Copy imagegmagick image to x with primitive yet robust pixel
7697 pusher loop. This has been tested a lot with many different
7700 /* Copy pixels from the imagemagick image structure to the x image map. */
7701 iterator
= NewPixelIterator (image_wand
);
7702 if (iterator
== (PixelIterator
*) NULL
)
7704 #ifdef COLOR_TABLE_SUPPORT
7705 free_color_table ();
7707 x_destroy_x_image (ximg
);
7708 image_error ("Imagemagick pixel iterator creation failed",
7710 goto imagemagick_error
;
7713 for (y
= 0; y
< (long) MagickGetImageHeight (image_wand
); y
++)
7715 pixels
= PixelGetNextIteratorRow (iterator
, &width
);
7716 if (pixels
== (PixelWand
**) NULL
)
7718 for (x
= 0; x
< (long) width
; x
++)
7720 PixelGetMagickColor (pixels
[x
], &pixel
);
7721 XPutPixel (ximg
, x
, y
,
7722 lookup_rgb_color (f
,
7728 DestroyPixelIterator (iterator
);
7731 if (imagemagick_rendermethod
== 1)
7733 /* Magicexportimage is normaly faster than pixelpushing. This
7734 method is also well tested. Some aspects of this method are
7735 ad-hoc and needs to be more researched. */
7736 int imagedepth
= 24;/*MagickGetImageDepth(image_wand);*/
7737 const char *exportdepth
= imagedepth
<= 8 ? "I" : "BGRP";/*"RGBP";*/
7738 /* Try to create a x pixmap to hold the imagemagick pixmap. */
7739 if (!x_create_x_image_and_pixmap (f
, width
, height
, imagedepth
,
7740 &ximg
, &img
->pixmap
))
7742 #ifdef COLOR_TABLE_SUPPORT
7743 free_color_table ();
7745 image_error("Imagemagick X bitmap allocation failure", Qnil
, Qnil
);
7746 goto imagemagick_error
;
7750 /* Oddly, the below code doesnt seem to work:*/
7751 /* switch(ximg->bitmap_unit){ */
7753 /* pixelwidth=CharPixel; */
7756 /* pixelwidth=ShortPixel; */
7759 /* pixelwidth=LongPixel; */
7763 Here im just guessing the format of the bitmap.
7764 happens to work fine for:
7767 seems about 3 times as fast as pixel pushing(not carefully measured)
7769 pixelwidth
= CharPixel
;/*??? TODO figure out*/
7770 #ifdef HAVE_MAGICKEXPORTIMAGEPIXELS
7771 MagickExportImagePixels (image_wand
,
7776 /*&(img->pixmap));*/
7779 image_error ("You dont have MagickExportImagePixels, upgrade ImageMagick!",
7785 #ifdef COLOR_TABLE_SUPPORT
7786 /* Remember colors allocated for this image. */
7787 img
->colors
= colors_in_color_table (&img
->ncolors
);
7788 free_color_table ();
7789 #endif /* COLOR_TABLE_SUPPORT */
7793 img
->height
= height
;
7795 /* Put the image into the pixmap, then free the X image and its
7797 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
7798 x_destroy_x_image (ximg
);
7801 /* Final cleanup. image_wand should be the only resource left. */
7802 DestroyMagickWand (image_wand
);
7803 /* `MagickWandTerminus' terminates the imagemagick environment. */
7804 MagickWandTerminus ();
7809 DestroyMagickWand (image_wand
);
7810 imagemagick_no_wand
:
7811 MagickWandTerminus ();
7812 /* TODO more cleanup. */
7813 image_error ("Error parsing IMAGEMAGICK image `%s'", img
->spec
, Qnil
);
7818 /* Load IMAGEMAGICK image IMG for use on frame F. Value is non-zero if
7819 successful. this function will go into the imagemagick_type structure, and
7820 the prototype thus needs to be compatible with that structure. */
7823 imagemagick_load (struct frame
*f
, struct image
*img
)
7826 Lisp_Object file_name
;
7828 /* If IMG->spec specifies a file name, create a non-file spec from it. */
7829 file_name
= image_spec_value (img
->spec
, QCfile
, NULL
);
7830 if (STRINGP (file_name
))
7834 file
= x_find_image_file (file_name
);
7835 if (!STRINGP (file
))
7837 image_error ("Cannot find image file `%s'", file_name
, Qnil
);
7840 success_p
= imagemagick_load_image (f
, img
, 0, 0, SSDATA (file
));
7842 /* Else its not a file, its a lisp object. Load the image from a
7843 lisp object rather than a file. */
7848 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
7849 if (!STRINGP (data
))
7851 image_error ("Invalid image data `%s'", data
, Qnil
);
7854 success_p
= imagemagick_load_image (f
, img
, SDATA (data
),
7855 SBYTES (data
), NULL
);
7861 DEFUN ("imagemagick-types", Fimagemagick_types
, Simagemagick_types
, 0, 0, 0,
7862 doc
: /* Return a list of image types supported by ImageMagick.
7863 Each entry in this list is a symbol named after an ImageMagick format
7864 tag. See the ImageMagick manual for a list of ImageMagick formats and
7865 their descriptions (http://www.imagemagick.org/script/formats.php).
7867 Note that ImageMagick recognizes many file-types that Emacs does not
7868 recognize as images, such as C. See `imagemagick-types-inhibit'. */)
7871 Lisp_Object typelist
= Qnil
;
7874 char **imtypes
= GetMagickList ("*", &numf
, &ex
);
7876 Lisp_Object Qimagemagicktype
;
7877 for (i
= 0; i
< numf
; i
++)
7879 Qimagemagicktype
= intern (imtypes
[i
]);
7880 typelist
= Fcons (Qimagemagicktype
, typelist
);
7885 #endif /* defined (HAVE_IMAGEMAGICK) */
7889 /***********************************************************************
7891 ***********************************************************************/
7893 #if defined (HAVE_RSVG)
7895 /* Function prototypes. */
7897 static int svg_image_p (Lisp_Object object
);
7898 static int svg_load (struct frame
*f
, struct image
*img
);
7900 static int svg_load_image (struct frame
*, struct image
*,
7901 unsigned char *, ptrdiff_t);
7903 /* The symbol `svg' identifying images of this type. */
7905 static Lisp_Object Qsvg
;
7907 /* Indices of image specification fields in svg_format, below. */
7909 enum svg_keyword_index
7924 /* Vector of image_keyword structures describing the format
7925 of valid user-defined image specifications. */
7927 static const struct image_keyword svg_format
[SVG_LAST
] =
7929 {":type", IMAGE_SYMBOL_VALUE
, 1},
7930 {":data", IMAGE_STRING_VALUE
, 0},
7931 {":file", IMAGE_STRING_VALUE
, 0},
7932 {":ascent", IMAGE_ASCENT_VALUE
, 0},
7933 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
7934 {":relief", IMAGE_INTEGER_VALUE
, 0},
7935 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7936 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7937 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7938 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
7941 /* Structure describing the image type `svg'. Its the same type of
7942 structure defined for all image formats, handled by emacs image
7943 functions. See struct image_type in dispextern.h. */
7945 static struct image_type svg_type
=
7947 /* An identifier showing that this is an image structure for the SVG format. */
7949 /* Handle to a function that can be used to identify a SVG file. */
7951 /* Handle to function used to load a SVG file. */
7953 /* Handle to function to free sresources for SVG. */
7955 /* An internal field to link to the next image type in a list of
7956 image types, will be filled in when registering the format. */
7961 /* Return non-zero if OBJECT is a valid SVG image specification. Do
7962 this by calling parse_image_spec and supplying the keywords that
7963 identify the SVG format. */
7966 svg_image_p (Lisp_Object object
)
7968 struct image_keyword fmt
[SVG_LAST
];
7969 memcpy (fmt
, svg_format
, sizeof fmt
);
7971 if (!parse_image_spec (object
, fmt
, SVG_LAST
, Qsvg
))
7974 /* Must specify either the :data or :file keyword. */
7975 return fmt
[SVG_FILE
].count
+ fmt
[SVG_DATA
].count
== 1;
7978 #include <librsvg/rsvg.h>
7982 /* SVG library functions. */
7983 DEF_IMGLIB_FN (RsvgHandle
*, rsvg_handle_new
);
7984 DEF_IMGLIB_FN (void, rsvg_handle_get_dimensions
);
7985 DEF_IMGLIB_FN (gboolean
, rsvg_handle_write
);
7986 DEF_IMGLIB_FN (gboolean
, rsvg_handle_close
);
7987 DEF_IMGLIB_FN (GdkPixbuf
*, rsvg_handle_get_pixbuf
);
7989 DEF_IMGLIB_FN (int, gdk_pixbuf_get_width
);
7990 DEF_IMGLIB_FN (int, gdk_pixbuf_get_height
);
7991 DEF_IMGLIB_FN (guchar
*, gdk_pixbuf_get_pixels
);
7992 DEF_IMGLIB_FN (int, gdk_pixbuf_get_rowstride
);
7993 DEF_IMGLIB_FN (GdkColorspace
, gdk_pixbuf_get_colorspace
);
7994 DEF_IMGLIB_FN (int, gdk_pixbuf_get_n_channels
);
7995 DEF_IMGLIB_FN (gboolean
, gdk_pixbuf_get_has_alpha
);
7996 DEF_IMGLIB_FN (int, gdk_pixbuf_get_bits_per_sample
);
7998 DEF_IMGLIB_FN (void, g_type_init
);
7999 DEF_IMGLIB_FN (void, g_object_unref
);
8000 DEF_IMGLIB_FN (void, g_error_free
);
8002 Lisp_Object Qgdk_pixbuf
, Qglib
, Qgobject
;
8005 init_svg_functions (Lisp_Object libraries
)
8007 HMODULE library
, gdklib
, glib
, gobject
;
8009 if (!(glib
= w32_delayed_load (libraries
, Qglib
))
8010 || !(gobject
= w32_delayed_load (libraries
, Qgobject
))
8011 || !(gdklib
= w32_delayed_load (libraries
, Qgdk_pixbuf
))
8012 || !(library
= w32_delayed_load (libraries
, Qsvg
)))
8015 LOAD_IMGLIB_FN (library
, rsvg_handle_new
);
8016 LOAD_IMGLIB_FN (library
, rsvg_handle_get_dimensions
);
8017 LOAD_IMGLIB_FN (library
, rsvg_handle_write
);
8018 LOAD_IMGLIB_FN (library
, rsvg_handle_close
);
8019 LOAD_IMGLIB_FN (library
, rsvg_handle_get_pixbuf
);
8021 LOAD_IMGLIB_FN (gdklib
, gdk_pixbuf_get_width
);
8022 LOAD_IMGLIB_FN (gdklib
, gdk_pixbuf_get_height
);
8023 LOAD_IMGLIB_FN (gdklib
, gdk_pixbuf_get_pixels
);
8024 LOAD_IMGLIB_FN (gdklib
, gdk_pixbuf_get_rowstride
);
8025 LOAD_IMGLIB_FN (gdklib
, gdk_pixbuf_get_colorspace
);
8026 LOAD_IMGLIB_FN (gdklib
, gdk_pixbuf_get_n_channels
);
8027 LOAD_IMGLIB_FN (gdklib
, gdk_pixbuf_get_has_alpha
);
8028 LOAD_IMGLIB_FN (gdklib
, gdk_pixbuf_get_bits_per_sample
);
8030 LOAD_IMGLIB_FN (gobject
, g_type_init
);
8031 LOAD_IMGLIB_FN (gobject
, g_object_unref
);
8032 LOAD_IMGLIB_FN (glib
, g_error_free
);
8038 /* The following aliases for library functions allow dynamic loading
8039 to be used on some platforms. */
8040 #define fn_rsvg_handle_new rsvg_handle_new
8041 #define fn_rsvg_handle_get_dimensions rsvg_handle_get_dimensions
8042 #define fn_rsvg_handle_write rsvg_handle_write
8043 #define fn_rsvg_handle_close rsvg_handle_close
8044 #define fn_rsvg_handle_get_pixbuf rsvg_handle_get_pixbuf
8046 #define fn_gdk_pixbuf_get_width gdk_pixbuf_get_width
8047 #define fn_gdk_pixbuf_get_height gdk_pixbuf_get_height
8048 #define fn_gdk_pixbuf_get_pixels gdk_pixbuf_get_pixels
8049 #define fn_gdk_pixbuf_get_rowstride gdk_pixbuf_get_rowstride
8050 #define fn_gdk_pixbuf_get_colorspace gdk_pixbuf_get_colorspace
8051 #define fn_gdk_pixbuf_get_n_channels gdk_pixbuf_get_n_channels
8052 #define fn_gdk_pixbuf_get_has_alpha gdk_pixbuf_get_has_alpha
8053 #define fn_gdk_pixbuf_get_bits_per_sample gdk_pixbuf_get_bits_per_sample
8055 #define fn_g_type_init g_type_init
8056 #define fn_g_object_unref g_object_unref
8057 #define fn_g_error_free g_error_free
8058 #endif /* !HAVE_NTGUI */
8060 /* Load SVG image IMG for use on frame F. Value is non-zero if
8061 successful. this function will go into the svg_type structure, and
8062 the prototype thus needs to be compatible with that structure. */
8065 svg_load (struct frame
*f
, struct image
*img
)
8068 Lisp_Object file_name
;
8070 /* If IMG->spec specifies a file name, create a non-file spec from it. */
8071 file_name
= image_spec_value (img
->spec
, QCfile
, NULL
);
8072 if (STRINGP (file_name
))
8075 unsigned char *contents
;
8078 file
= x_find_image_file (file_name
);
8079 if (!STRINGP (file
))
8081 image_error ("Cannot find image file `%s'", file_name
, Qnil
);
8085 /* Read the entire file into memory. */
8086 contents
= slurp_file (SSDATA (file
), &size
);
8087 if (contents
== NULL
)
8089 image_error ("Error loading SVG image `%s'", img
->spec
, Qnil
);
8092 /* If the file was slurped into memory properly, parse it. */
8093 success_p
= svg_load_image (f
, img
, contents
, size
);
8096 /* Else its not a file, its a lisp object. Load the image from a
8097 lisp object rather than a file. */
8102 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
8103 if (!STRINGP (data
))
8105 image_error ("Invalid image data `%s'", data
, Qnil
);
8108 success_p
= svg_load_image (f
, img
, SDATA (data
), SBYTES (data
));
8114 /* svg_load_image is a helper function for svg_load, which does the
8115 actual loading given contents and size, apart from frame and image
8116 structures, passed from svg_load.
8118 Uses librsvg to do most of the image processing.
8120 Returns non-zero when successful. */
8122 svg_load_image (struct frame
*f
, /* Pointer to emacs frame structure. */
8123 struct image
*img
, /* Pointer to emacs image structure. */
8124 unsigned char *contents
, /* String containing the SVG XML data to be parsed. */
8125 ptrdiff_t size
) /* Size of data in bytes. */
8127 RsvgHandle
*rsvg_handle
;
8128 RsvgDimensionData dimension_data
;
8133 const guint8
*pixels
;
8136 Lisp_Object specified_bg
;
8141 /* g_type_init is a glib function that must be called prior to using
8142 gnome type library functions. */
8144 /* Make a handle to a new rsvg object. */
8145 rsvg_handle
= fn_rsvg_handle_new ();
8147 /* Parse the contents argument and fill in the rsvg_handle. */
8148 fn_rsvg_handle_write (rsvg_handle
, contents
, size
, &err
);
8149 if (err
) goto rsvg_error
;
8151 /* The parsing is complete, rsvg_handle is ready to used, close it
8152 for further writes. */
8153 fn_rsvg_handle_close (rsvg_handle
, &err
);
8154 if (err
) goto rsvg_error
;
8156 fn_rsvg_handle_get_dimensions (rsvg_handle
, &dimension_data
);
8157 if (! check_image_size (f
, dimension_data
.width
, dimension_data
.height
))
8159 image_error ("Invalid image size (see `max-image-size')", Qnil
, Qnil
);
8163 /* We can now get a valid pixel buffer from the svg file, if all
8165 pixbuf
= fn_rsvg_handle_get_pixbuf (rsvg_handle
);
8166 if (!pixbuf
) goto rsvg_error
;
8167 fn_g_object_unref (rsvg_handle
);
8169 /* Extract some meta data from the svg handle. */
8170 width
= fn_gdk_pixbuf_get_width (pixbuf
);
8171 height
= fn_gdk_pixbuf_get_height (pixbuf
);
8172 pixels
= fn_gdk_pixbuf_get_pixels (pixbuf
);
8173 rowstride
= fn_gdk_pixbuf_get_rowstride (pixbuf
);
8175 /* Validate the svg meta data. */
8176 eassert (fn_gdk_pixbuf_get_colorspace (pixbuf
) == GDK_COLORSPACE_RGB
);
8177 eassert (fn_gdk_pixbuf_get_n_channels (pixbuf
) == 4);
8178 eassert (fn_gdk_pixbuf_get_has_alpha (pixbuf
));
8179 eassert (fn_gdk_pixbuf_get_bits_per_sample (pixbuf
) == 8);
8181 /* Try to create a x pixmap to hold the svg pixmap. */
8182 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
8184 fn_g_object_unref (pixbuf
);
8188 init_color_table ();
8190 /* Handle alpha channel by combining the image with a background
8192 specified_bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
8193 if (!STRINGP (specified_bg
)
8194 || !x_defined_color (f
, SSDATA (specified_bg
), &background
, 0))
8197 background
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
8198 x_query_color (f
, &background
);
8200 ns_query_color (FRAME_BACKGROUND_COLOR (f
), &background
, 1);
8204 /* SVG pixmaps specify transparency in the last byte, so right
8205 shift 8 bits to get rid of it, since emacs doesn't support
8207 background
.red
>>= 8;
8208 background
.green
>>= 8;
8209 background
.blue
>>= 8;
8211 /* This loop handles opacity values, since Emacs assumes
8212 non-transparent images. Each pixel must be "flattened" by
8213 calculating the resulting color, given the transparency of the
8214 pixel, and the image background color. */
8215 for (y
= 0; y
< height
; ++y
)
8217 for (x
= 0; x
< width
; ++x
)
8227 opacity
= *pixels
++;
8229 red
= ((red
* opacity
)
8230 + (background
.red
* ((1 << 8) - opacity
)));
8231 green
= ((green
* opacity
)
8232 + (background
.green
* ((1 << 8) - opacity
)));
8233 blue
= ((blue
* opacity
)
8234 + (background
.blue
* ((1 << 8) - opacity
)));
8236 XPutPixel (ximg
, x
, y
, lookup_rgb_color (f
, red
, green
, blue
));
8239 pixels
+= rowstride
- 4 * width
;
8242 #ifdef COLOR_TABLE_SUPPORT
8243 /* Remember colors allocated for this image. */
8244 img
->colors
= colors_in_color_table (&img
->ncolors
);
8245 free_color_table ();
8246 #endif /* COLOR_TABLE_SUPPORT */
8248 fn_g_object_unref (pixbuf
);
8251 img
->height
= height
;
8253 /* Maybe fill in the background field while we have ximg handy.
8254 Casting avoids a GCC warning. */
8255 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
8257 /* Put the image into the pixmap, then free the X image and its
8259 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
8260 x_destroy_x_image (ximg
);
8265 fn_g_object_unref (rsvg_handle
);
8266 /* FIXME: Use error->message so the user knows what is the actual
8267 problem with the image. */
8268 image_error ("Error parsing SVG image `%s'", img
->spec
, Qnil
);
8269 fn_g_error_free (err
);
8273 #endif /* defined (HAVE_RSVG) */
8278 /***********************************************************************
8280 ***********************************************************************/
8282 #ifdef HAVE_X_WINDOWS
8283 #define HAVE_GHOSTSCRIPT 1
8284 #endif /* HAVE_X_WINDOWS */
8286 #ifdef HAVE_GHOSTSCRIPT
8288 static int gs_image_p (Lisp_Object object
);
8289 static int gs_load (struct frame
*f
, struct image
*img
);
8290 static void gs_clear_image (struct frame
*f
, struct image
*img
);
8292 /* Keyword symbols. */
8294 static Lisp_Object QCloader
, QCbounding_box
, QCpt_width
, QCpt_height
;
8296 /* Indices of image specification fields in gs_format, below. */
8298 enum gs_keyword_index
8316 /* Vector of image_keyword structures describing the format
8317 of valid user-defined image specifications. */
8319 static const struct image_keyword gs_format
[GS_LAST
] =
8321 {":type", IMAGE_SYMBOL_VALUE
, 1},
8322 {":pt-width", IMAGE_POSITIVE_INTEGER_VALUE
, 1},
8323 {":pt-height", IMAGE_POSITIVE_INTEGER_VALUE
, 1},
8324 {":file", IMAGE_STRING_VALUE
, 1},
8325 {":loader", IMAGE_FUNCTION_VALUE
, 0},
8326 {":bounding-box", IMAGE_DONT_CHECK_VALUE_TYPE
, 1},
8327 {":ascent", IMAGE_ASCENT_VALUE
, 0},
8328 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
8329 {":relief", IMAGE_INTEGER_VALUE
, 0},
8330 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8331 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8332 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8333 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
8336 /* Structure describing the image type `ghostscript'. */
8338 static struct image_type gs_type
=
8348 /* Free X resources of Ghostscript image IMG which is used on frame F. */
8351 gs_clear_image (struct frame
*f
, struct image
*img
)
8353 x_clear_image (f
, img
);
8357 /* Return non-zero if OBJECT is a valid Ghostscript image
8361 gs_image_p (Lisp_Object object
)
8363 struct image_keyword fmt
[GS_LAST
];
8367 memcpy (fmt
, gs_format
, sizeof fmt
);
8369 if (!parse_image_spec (object
, fmt
, GS_LAST
, Qpostscript
))
8372 /* Bounding box must be a list or vector containing 4 integers. */
8373 tem
= fmt
[GS_BOUNDING_BOX
].value
;
8376 for (i
= 0; i
< 4; ++i
, tem
= XCDR (tem
))
8377 if (!CONSP (tem
) || !INTEGERP (XCAR (tem
)))
8382 else if (VECTORP (tem
))
8384 if (ASIZE (tem
) != 4)
8386 for (i
= 0; i
< 4; ++i
)
8387 if (!INTEGERP (XVECTOR (tem
)->contents
[i
]))
8397 /* Load Ghostscript image IMG for use on frame F. Value is non-zero
8401 gs_load (struct frame
*f
, struct image
*img
)
8404 Lisp_Object window_and_pixmap_id
= Qnil
, loader
, pt_height
, pt_width
;
8406 double in_width
, in_height
;
8407 Lisp_Object pixel_colors
= Qnil
;
8409 /* Compute pixel size of pixmap needed from the given size in the
8410 image specification. Sizes in the specification are in pt. 1 pt
8411 = 1/72 in, xdpi and ydpi are stored in the frame's X display
8413 pt_width
= image_spec_value (img
->spec
, QCpt_width
, NULL
);
8414 in_width
= INTEGERP (pt_width
) ? XFASTINT (pt_width
) / 72.0 : 0;
8415 img
->width
= in_width
* FRAME_X_DISPLAY_INFO (f
)->resx
;
8416 pt_height
= image_spec_value (img
->spec
, QCpt_height
, NULL
);
8417 in_height
= INTEGERP (pt_height
) ? XFASTINT (pt_height
) / 72.0 : 0;
8418 img
->height
= in_height
* FRAME_X_DISPLAY_INFO (f
)->resy
;
8420 if (!check_image_size (f
, img
->width
, img
->height
))
8422 image_error ("Invalid image size (see `max-image-size')", Qnil
, Qnil
);
8426 /* Create the pixmap. */
8427 xassert (img
->pixmap
== NO_PIXMAP
);
8429 /* Only W32 version did BLOCK_INPUT here. ++kfs */
8431 img
->pixmap
= XCreatePixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
8432 img
->width
, img
->height
,
8433 DefaultDepthOfScreen (FRAME_X_SCREEN (f
)));
8438 image_error ("Unable to create pixmap for `%s'", img
->spec
, Qnil
);
8442 /* Call the loader to fill the pixmap. It returns a process object
8443 if successful. We do not record_unwind_protect here because
8444 other places in redisplay like calling window scroll functions
8445 don't either. Let the Lisp loader use `unwind-protect' instead. */
8446 sprintf (buffer
, "%lu %lu",
8447 (unsigned long) FRAME_X_WINDOW (f
),
8448 (unsigned long) img
->pixmap
);
8449 window_and_pixmap_id
= build_string (buffer
);
8451 sprintf (buffer
, "%lu %lu",
8452 FRAME_FOREGROUND_PIXEL (f
),
8453 FRAME_BACKGROUND_PIXEL (f
));
8454 pixel_colors
= build_string (buffer
);
8456 XSETFRAME (frame
, f
);
8457 loader
= image_spec_value (img
->spec
, QCloader
, NULL
);
8459 loader
= intern ("gs-load-image");
8461 img
->lisp_data
= call6 (loader
, frame
, img
->spec
,
8462 make_number (img
->width
),
8463 make_number (img
->height
),
8464 window_and_pixmap_id
,
8466 return PROCESSP (img
->lisp_data
);
8470 /* Kill the Ghostscript process that was started to fill PIXMAP on
8471 frame F. Called from XTread_socket when receiving an event
8472 telling Emacs that Ghostscript has finished drawing. */
8475 x_kill_gs_process (Pixmap pixmap
, struct frame
*f
)
8477 struct image_cache
*c
= FRAME_IMAGE_CACHE (f
);
8481 /* Find the image containing PIXMAP. */
8482 for (i
= 0; i
< c
->used
; ++i
)
8483 if (c
->images
[i
]->pixmap
== pixmap
)
8486 /* Should someone in between have cleared the image cache, for
8487 instance, give up. */
8491 /* Kill the GS process. We should have found PIXMAP in the image
8492 cache and its image should contain a process object. */
8494 xassert (PROCESSP (img
->lisp_data
));
8495 Fkill_process (img
->lisp_data
, Qnil
);
8496 img
->lisp_data
= Qnil
;
8498 #if defined (HAVE_X_WINDOWS)
8500 /* On displays with a mutable colormap, figure out the colors
8501 allocated for the image by looking at the pixels of an XImage for
8503 class = FRAME_X_VISUAL (f
)->class;
8504 if (class != StaticColor
&& class != StaticGray
&& class != TrueColor
)
8510 /* Try to get an XImage for img->pixmep. */
8511 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
8512 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
8517 /* Initialize the color table. */
8518 init_color_table ();
8520 /* For each pixel of the image, look its color up in the
8521 color table. After having done so, the color table will
8522 contain an entry for each color used by the image. */
8523 for (y
= 0; y
< img
->height
; ++y
)
8524 for (x
= 0; x
< img
->width
; ++x
)
8526 unsigned long pixel
= XGetPixel (ximg
, x
, y
);
8527 lookup_pixel_color (f
, pixel
);
8530 /* Record colors in the image. Free color table and XImage. */
8531 #ifdef COLOR_TABLE_SUPPORT
8532 img
->colors
= colors_in_color_table (&img
->ncolors
);
8533 free_color_table ();
8535 XDestroyImage (ximg
);
8537 #if 0 /* This doesn't seem to be the case. If we free the colors
8538 here, we get a BadAccess later in x_clear_image when
8539 freeing the colors. */
8540 /* We have allocated colors once, but Ghostscript has also
8541 allocated colors on behalf of us. So, to get the
8542 reference counts right, free them once. */
8544 x_free_colors (f
, img
->colors
, img
->ncolors
);
8548 image_error ("Cannot get X image of `%s'; colors will not be freed",
8553 #endif /* HAVE_X_WINDOWS */
8555 /* Now that we have the pixmap, compute mask and transform the
8556 image if requested. */
8558 postprocess_image (f
, img
);
8562 #endif /* HAVE_GHOSTSCRIPT */
8565 /***********************************************************************
8567 ***********************************************************************/
8571 DEFUN ("imagep", Fimagep
, Simagep
, 1, 1, 0,
8572 doc
: /* Value is non-nil if SPEC is a valid image specification. */)
8575 return valid_image_p (spec
) ? Qt
: Qnil
;
8579 DEFUN ("lookup-image", Flookup_image
, Slookup_image
, 1, 1, 0, "")
8584 if (valid_image_p (spec
))
8585 id
= lookup_image (SELECTED_FRAME (), spec
);
8588 return make_number (id
);
8591 #endif /* GLYPH_DEBUG != 0 */
8594 /***********************************************************************
8596 ***********************************************************************/
8599 /* Image types that rely on external libraries are loaded dynamically
8600 if the library is available. */
8601 #define CHECK_LIB_AVAILABLE(image_type, init_lib_fn, libraries) \
8602 define_image_type (image_type, init_lib_fn (libraries))
8604 #define CHECK_LIB_AVAILABLE(image_type, init_lib_fn, libraries) \
8605 define_image_type (image_type, 1)
8606 #endif /* HAVE_NTGUI */
8608 DEFUN ("init-image-library", Finit_image_library
, Sinit_image_library
, 2, 2, 0,
8609 doc
: /* Initialize image library implementing image type TYPE.
8610 Return non-nil if TYPE is a supported image type.
8612 Image types pbm and xbm are prebuilt; other types are loaded here.
8613 Libraries to load are specified in alist LIBRARIES (usually, the value
8614 of `dynamic-library-alist', which see). */)
8615 (Lisp_Object type
, Lisp_Object libraries
)
8618 /* Don't try to reload the library. */
8619 Lisp_Object tested
= Fassq (type
, Vlibrary_cache
);
8621 return XCDR (tested
);
8624 /* Types pbm and xbm are built-in and always available. */
8625 if (EQ (type
, Qpbm
) || EQ (type
, Qxbm
))
8628 #if defined (HAVE_XPM) || defined (HAVE_NS)
8629 if (EQ (type
, Qxpm
))
8630 return CHECK_LIB_AVAILABLE (&xpm_type
, init_xpm_functions
, libraries
);
8633 #if defined (HAVE_JPEG) || defined (HAVE_NS)
8634 if (EQ (type
, Qjpeg
))
8635 return CHECK_LIB_AVAILABLE (&jpeg_type
, init_jpeg_functions
, libraries
);
8638 #if defined (HAVE_TIFF) || defined (HAVE_NS)
8639 if (EQ (type
, Qtiff
))
8640 return CHECK_LIB_AVAILABLE (&tiff_type
, init_tiff_functions
, libraries
);
8643 #if defined (HAVE_GIF) || defined (HAVE_NS)
8644 if (EQ (type
, Qgif
))
8645 return CHECK_LIB_AVAILABLE (&gif_type
, init_gif_functions
, libraries
);
8648 #if defined (HAVE_PNG) || defined (HAVE_NS)
8649 if (EQ (type
, Qpng
))
8650 return CHECK_LIB_AVAILABLE (&png_type
, init_png_functions
, libraries
);
8653 #if defined (HAVE_RSVG)
8654 if (EQ (type
, Qsvg
))
8655 return CHECK_LIB_AVAILABLE (&svg_type
, init_svg_functions
, libraries
);
8658 #if defined (HAVE_IMAGEMAGICK)
8659 if (EQ (type
, Qimagemagick
))
8660 return CHECK_LIB_AVAILABLE (&imagemagick_type
, init_imagemagick_functions
,
8664 #ifdef HAVE_GHOSTSCRIPT
8665 if (EQ (type
, Qpostscript
))
8666 return CHECK_LIB_AVAILABLE (&gs_type
, init_gs_functions
, libraries
);
8669 /* If the type is not recognized, avoid testing it ever again. */
8670 CACHE_IMAGE_TYPE (type
, Qnil
);
8675 syms_of_image (void)
8677 /* Initialize this only once, since that's what we do with Vimage_types
8678 and they are supposed to be in sync. Initializing here gives correct
8679 operation on GNU/Linux of calling dump-emacs after loading some images. */
8682 /* Must be defined now becase we're going to update it below, while
8683 defining the supported image types. */
8684 DEFVAR_LISP ("image-types", Vimage_types
,
8685 doc
: /* List of potentially supported image types.
8686 Each element of the list is a symbol for an image type, like 'jpeg or 'png.
8687 To check whether it is really supported, use `image-type-available-p'. */);
8688 Vimage_types
= Qnil
;
8690 DEFVAR_LISP ("max-image-size", Vmax_image_size
,
8691 doc
: /* Maximum size of images.
8692 Emacs will not load an image into memory if its pixel width or
8693 pixel height exceeds this limit.
8695 If the value is an integer, it directly specifies the maximum
8696 image height and width, measured in pixels. If it is a floating
8697 point number, it specifies the maximum image height and width
8698 as a ratio to the frame height and width. If the value is
8699 non-numeric, there is no explicit limit on the size of images. */);
8700 Vmax_image_size
= make_float (MAX_IMAGE_SIZE
);
8702 DEFSYM (Qpbm
, "pbm");
8703 ADD_IMAGE_TYPE (Qpbm
);
8705 DEFSYM (Qxbm
, "xbm");
8706 ADD_IMAGE_TYPE (Qxbm
);
8708 define_image_type (&xbm_type
, 1);
8709 define_image_type (&pbm_type
, 1);
8711 DEFSYM (Qcount
, "count");
8712 DEFSYM (Qextension_data
, "extension-data");
8713 DEFSYM (Qdelay
, "delay");
8715 DEFSYM (QCascent
, ":ascent");
8716 DEFSYM (QCmargin
, ":margin");
8717 DEFSYM (QCrelief
, ":relief");
8718 DEFSYM (QCconversion
, ":conversion");
8719 DEFSYM (QCcolor_symbols
, ":color-symbols");
8720 DEFSYM (QCheuristic_mask
, ":heuristic-mask");
8721 DEFSYM (QCindex
, ":index");
8722 DEFSYM (QCgeometry
, ":geometry");
8723 DEFSYM (QCcrop
, ":crop");
8724 DEFSYM (QCrotation
, ":rotation");
8725 DEFSYM (QCmatrix
, ":matrix");
8726 DEFSYM (QCcolor_adjustment
, ":color-adjustment");
8727 DEFSYM (QCmask
, ":mask");
8729 DEFSYM (Qlaplace
, "laplace");
8730 DEFSYM (Qemboss
, "emboss");
8731 DEFSYM (Qedge_detection
, "edge-detection");
8732 DEFSYM (Qheuristic
, "heuristic");
8734 DEFSYM (Qpostscript
, "postscript");
8735 #ifdef HAVE_GHOSTSCRIPT
8736 ADD_IMAGE_TYPE (Qpostscript
);
8737 DEFSYM (QCloader
, ":loader");
8738 DEFSYM (QCbounding_box
, ":bounding-box");
8739 DEFSYM (QCpt_width
, ":pt-width");
8740 DEFSYM (QCpt_height
, ":pt-height");
8741 #endif /* HAVE_GHOSTSCRIPT */
8744 DEFSYM (Qlibpng_version
, "libpng-version");
8745 Fset (Qlibpng_version
,
8747 make_number (PNG_LIBPNG_VER
)
8754 #if defined (HAVE_XPM) || defined (HAVE_NS)
8755 DEFSYM (Qxpm
, "xpm");
8756 ADD_IMAGE_TYPE (Qxpm
);
8759 #if defined (HAVE_JPEG) || defined (HAVE_NS)
8760 DEFSYM (Qjpeg
, "jpeg");
8761 ADD_IMAGE_TYPE (Qjpeg
);
8764 #if defined (HAVE_TIFF) || defined (HAVE_NS)
8765 DEFSYM (Qtiff
, "tiff");
8766 ADD_IMAGE_TYPE (Qtiff
);
8769 #if defined (HAVE_GIF) || defined (HAVE_NS)
8770 DEFSYM (Qgif
, "gif");
8771 ADD_IMAGE_TYPE (Qgif
);
8774 #if defined (HAVE_PNG) || defined (HAVE_NS)
8775 DEFSYM (Qpng
, "png");
8776 ADD_IMAGE_TYPE (Qpng
);
8779 #if defined (HAVE_IMAGEMAGICK)
8780 DEFSYM (Qimagemagick
, "imagemagick");
8781 ADD_IMAGE_TYPE (Qimagemagick
);
8784 #if defined (HAVE_RSVG)
8785 DEFSYM (Qsvg
, "svg");
8786 ADD_IMAGE_TYPE (Qsvg
);
8788 /* Other libraries used directly by svg code. */
8789 DEFSYM (Qgdk_pixbuf
, "gdk-pixbuf");
8790 DEFSYM (Qglib
, "glib");
8791 DEFSYM (Qgobject
, "gobject");
8792 #endif /* HAVE_NTGUI */
8793 #endif /* HAVE_RSVG */
8795 defsubr (&Sinit_image_library
);
8796 #ifdef HAVE_IMAGEMAGICK
8797 defsubr (&Simagemagick_types
);
8799 defsubr (&Sclear_image_cache
);
8800 defsubr (&Simage_flush
);
8801 defsubr (&Simage_size
);
8802 defsubr (&Simage_mask_p
);
8803 defsubr (&Simage_metadata
);
8807 defsubr (&Slookup_image
);
8810 DEFVAR_BOOL ("cross-disabled-images", cross_disabled_images
,
8811 doc
: /* Non-nil means always draw a cross over disabled images.
8812 Disabled images are those having a `:conversion disabled' property.
8813 A cross is always drawn on black & white displays. */);
8814 cross_disabled_images
= 0;
8816 DEFVAR_LISP ("x-bitmap-file-path", Vx_bitmap_file_path
,
8817 doc
: /* List of directories to search for window system bitmap files. */);
8818 Vx_bitmap_file_path
= decode_env_path ((char *) 0, PATH_BITMAPS
);
8820 DEFVAR_LISP ("image-cache-eviction-delay", Vimage_cache_eviction_delay
,
8821 doc
: /* Maximum time after which images are removed from the cache.
8822 When an image has not been displayed this many seconds, Emacs
8823 automatically removes it from the image cache. If the cache contains
8824 a large number of images, the actual eviction time may be shorter.
8825 The value can also be nil, meaning the cache is never cleared.
8827 The function `clear-image-cache' disregards this variable. */);
8828 Vimage_cache_eviction_delay
= make_number (300);
8829 #ifdef HAVE_IMAGEMAGICK
8830 DEFVAR_LISP ("imagemagick-render-type", Vimagemagick_render_type
,
8831 doc
: /* Choose between ImageMagick render methods. */);