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
);
2839 struct image_keyword fmt
[XBM_LAST
];
2841 unsigned long foreground
= FRAME_FOREGROUND_PIXEL (f
);
2842 unsigned long background
= FRAME_BACKGROUND_PIXEL (f
);
2843 int non_default_colors
= 0;
2846 int in_memory_file_p
= 0;
2848 /* See if data looks like an in-memory XBM file. */
2849 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
2850 in_memory_file_p
= xbm_file_p (data
);
2852 /* Parse the image specification. */
2853 memcpy (fmt
, xbm_format
, sizeof fmt
);
2854 parsed_p
= parse_image_spec (img
->spec
, fmt
, XBM_LAST
, Qxbm
);
2858 /* Get specified width, and height. */
2859 if (!in_memory_file_p
)
2861 img
->width
= XFASTINT (fmt
[XBM_WIDTH
].value
);
2862 img
->height
= XFASTINT (fmt
[XBM_HEIGHT
].value
);
2863 xassert (img
->width
> 0 && img
->height
> 0);
2866 /* Get foreground and background colors, maybe allocate colors. */
2867 if (fmt
[XBM_FOREGROUND
].count
2868 && STRINGP (fmt
[XBM_FOREGROUND
].value
))
2870 foreground
= x_alloc_image_color (f
, img
, fmt
[XBM_FOREGROUND
].value
,
2872 non_default_colors
= 1;
2875 if (fmt
[XBM_BACKGROUND
].count
2876 && STRINGP (fmt
[XBM_BACKGROUND
].value
))
2878 background
= x_alloc_image_color (f
, img
, fmt
[XBM_BACKGROUND
].value
,
2880 non_default_colors
= 1;
2883 if (in_memory_file_p
)
2884 success_p
= xbm_load_image (f
, img
, SDATA (data
),
2893 int nbytes
= (img
->width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
;
2895 p
= bits
= (char *) alloca (nbytes
* img
->height
);
2896 for (i
= 0; i
< img
->height
; ++i
, p
+= nbytes
)
2898 Lisp_Object line
= XVECTOR (data
)->contents
[i
];
2900 memcpy (p
, SDATA (line
), nbytes
);
2902 memcpy (p
, XBOOL_VECTOR (line
)->data
, nbytes
);
2905 else if (STRINGP (data
))
2906 bits
= SSDATA (data
);
2908 bits
= (char *) XBOOL_VECTOR (data
)->data
;
2914 /* Windows mono bitmaps are reversed compared with X. */
2915 invertedBits
= bits
;
2916 nbytes
= (img
->width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
2918 bits
= (char *) alloca (nbytes
);
2919 for (i
= 0; i
< nbytes
; i
++)
2920 bits
[i
] = XBM_BIT_SHUFFLE (invertedBits
[i
]);
2923 /* Create the pixmap. */
2925 Create_Pixmap_From_Bitmap_Data (f
, img
, bits
,
2926 foreground
, background
,
2927 non_default_colors
);
2932 image_error ("Unable to create pixmap for XBM image `%s'",
2934 x_clear_image (f
, img
);
2944 /***********************************************************************
2946 ***********************************************************************/
2948 #if defined (HAVE_XPM) || defined (HAVE_NS)
2950 static int xpm_image_p (Lisp_Object object
);
2951 static int xpm_load (struct frame
*f
, struct image
*img
);
2952 static int xpm_valid_color_symbols_p (Lisp_Object
);
2954 #endif /* HAVE_XPM || HAVE_NS */
2958 /* Indicate to xpm.h that we don't have Xlib. */
2960 /* simx.h in xpm defines XColor and XImage differently than Emacs. */
2961 /* It also defines Display the same way as Emacs, but gcc 3.3 still barfs. */
2962 #define XColor xpm_XColor
2963 #define XImage xpm_XImage
2964 #define Display xpm_Display
2965 #define PIXEL_ALREADY_TYPEDEFED
2966 #include "X11/xpm.h"
2971 #undef PIXEL_ALREADY_TYPEDEFED
2973 #include "X11/xpm.h"
2974 #endif /* HAVE_NTGUI */
2975 #endif /* HAVE_XPM */
2977 #if defined (HAVE_XPM) || defined (HAVE_NS)
2978 /* The symbol `xpm' identifying XPM-format images. */
2980 static Lisp_Object Qxpm
;
2982 /* Indices of image specification fields in xpm_format, below. */
2984 enum xpm_keyword_index
3000 /* Vector of image_keyword structures describing the format
3001 of valid XPM image specifications. */
3003 static const struct image_keyword xpm_format
[XPM_LAST
] =
3005 {":type", IMAGE_SYMBOL_VALUE
, 1},
3006 {":file", IMAGE_STRING_VALUE
, 0},
3007 {":data", IMAGE_STRING_VALUE
, 0},
3008 {":ascent", IMAGE_ASCENT_VALUE
, 0},
3009 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
3010 {":relief", IMAGE_INTEGER_VALUE
, 0},
3011 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3012 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3013 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3014 {":color-symbols", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3015 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
3018 /* Structure describing the image type XPM. */
3020 static struct image_type xpm_type
=
3029 #ifdef HAVE_X_WINDOWS
3031 /* Define ALLOC_XPM_COLORS if we can use Emacs' own color allocation
3032 functions for allocating image colors. Our own functions handle
3033 color allocation failures more gracefully than the ones on the XPM
3036 #if defined XpmAllocColor && defined XpmFreeColors && defined XpmColorClosure
3037 #define ALLOC_XPM_COLORS
3039 #endif /* HAVE_X_WINDOWS */
3041 #ifdef ALLOC_XPM_COLORS
3043 static void xpm_init_color_cache (struct frame
*, XpmAttributes
*);
3044 static void xpm_free_color_cache (void);
3045 static int xpm_lookup_color (struct frame
*, char *, XColor
*);
3046 static int xpm_color_bucket (char *);
3047 static struct xpm_cached_color
*xpm_cache_color (struct frame
*, char *,
3050 /* An entry in a hash table used to cache color definitions of named
3051 colors. This cache is necessary to speed up XPM image loading in
3052 case we do color allocations ourselves. Without it, we would need
3053 a call to XParseColor per pixel in the image. */
3055 struct xpm_cached_color
3057 /* Next in collision chain. */
3058 struct xpm_cached_color
*next
;
3060 /* Color definition (RGB and pixel color). */
3067 /* The hash table used for the color cache, and its bucket vector
3070 #define XPM_COLOR_CACHE_BUCKETS 1001
3071 static struct xpm_cached_color
**xpm_color_cache
;
3073 /* Initialize the color cache. */
3076 xpm_init_color_cache (struct frame
*f
, XpmAttributes
*attrs
)
3078 size_t nbytes
= XPM_COLOR_CACHE_BUCKETS
* sizeof *xpm_color_cache
;
3079 xpm_color_cache
= (struct xpm_cached_color
**) xmalloc (nbytes
);
3080 memset (xpm_color_cache
, 0, nbytes
);
3081 init_color_table ();
3083 if (attrs
->valuemask
& XpmColorSymbols
)
3088 for (i
= 0; i
< attrs
->numsymbols
; ++i
)
3089 if (XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
3090 attrs
->colorsymbols
[i
].value
, &color
))
3092 color
.pixel
= lookup_rgb_color (f
, color
.red
, color
.green
,
3094 xpm_cache_color (f
, attrs
->colorsymbols
[i
].name
, &color
, -1);
3099 /* Free the color cache. */
3102 xpm_free_color_cache (void)
3104 struct xpm_cached_color
*p
, *next
;
3107 for (i
= 0; i
< XPM_COLOR_CACHE_BUCKETS
; ++i
)
3108 for (p
= xpm_color_cache
[i
]; p
; p
= next
)
3114 xfree (xpm_color_cache
);
3115 xpm_color_cache
= NULL
;
3116 free_color_table ();
3119 /* Return the bucket index for color named COLOR_NAME in the color
3123 xpm_color_bucket (char *color_name
)
3128 for (s
= color_name
; *s
; ++s
)
3130 return h
%= XPM_COLOR_CACHE_BUCKETS
;
3134 /* On frame F, cache values COLOR for color with name COLOR_NAME.
3135 BUCKET, if >= 0, is a precomputed bucket index. Value is the cache
3138 static struct xpm_cached_color
*
3139 xpm_cache_color (struct frame
*f
, char *color_name
, XColor
*color
, int bucket
)
3142 struct xpm_cached_color
*p
;
3145 bucket
= xpm_color_bucket (color_name
);
3147 nbytes
= sizeof *p
+ strlen (color_name
);
3148 p
= (struct xpm_cached_color
*) xmalloc (nbytes
);
3149 strcpy (p
->name
, color_name
);
3151 p
->next
= xpm_color_cache
[bucket
];
3152 xpm_color_cache
[bucket
] = p
;
3156 /* Look up color COLOR_NAME for frame F in the color cache. If found,
3157 return the cached definition in *COLOR. Otherwise, make a new
3158 entry in the cache and allocate the color. Value is zero if color
3159 allocation failed. */
3162 xpm_lookup_color (struct frame
*f
, char *color_name
, XColor
*color
)
3164 struct xpm_cached_color
*p
;
3165 int h
= xpm_color_bucket (color_name
);
3167 for (p
= xpm_color_cache
[h
]; p
; p
= p
->next
)
3168 if (strcmp (p
->name
, color_name
) == 0)
3173 else if (XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
3176 color
->pixel
= lookup_rgb_color (f
, color
->red
, color
->green
,
3178 p
= xpm_cache_color (f
, color_name
, color
, h
);
3180 /* You get `opaque' at least from ImageMagick converting pbm to xpm
3181 with transparency, and it's useful. */
3182 else if (strcmp ("opaque", color_name
) == 0)
3184 memset (color
, 0, sizeof (XColor
)); /* Is this necessary/correct? */
3185 color
->pixel
= FRAME_FOREGROUND_PIXEL (f
);
3186 p
= xpm_cache_color (f
, color_name
, color
, h
);
3193 /* Callback for allocating color COLOR_NAME. Called from the XPM lib.
3194 CLOSURE is a pointer to the frame on which we allocate the
3195 color. Return in *COLOR the allocated color. Value is non-zero
3199 xpm_alloc_color (Display
*dpy
, Colormap cmap
, char *color_name
, XColor
*color
,
3202 return xpm_lookup_color ((struct frame
*) closure
, color_name
, color
);
3206 /* Callback for freeing NPIXELS colors contained in PIXELS. CLOSURE
3207 is a pointer to the frame on which we allocate the color. Value is
3208 non-zero if successful. */
3211 xpm_free_colors (Display
*dpy
, Colormap cmap
, Pixel
*pixels
, int npixels
, void *closure
)
3216 #endif /* ALLOC_XPM_COLORS */
3221 /* XPM library details. */
3223 DEF_IMGLIB_FN (void, XpmFreeAttributes
, (XpmAttributes
*));
3224 DEF_IMGLIB_FN (int, XpmCreateImageFromBuffer
, (Display
*, char *, xpm_XImage
**,
3225 xpm_XImage
**, XpmAttributes
*));
3226 DEF_IMGLIB_FN (int, XpmReadFileToImage
, (Display
*, char *, xpm_XImage
**,
3227 xpm_XImage
**, XpmAttributes
*));
3228 DEF_IMGLIB_FN (void, XImageFree
, (xpm_XImage
*));
3231 init_xpm_functions (Lisp_Object libraries
)
3235 if (!(library
= w32_delayed_load (libraries
, Qxpm
)))
3238 LOAD_IMGLIB_FN (library
, XpmFreeAttributes
);
3239 LOAD_IMGLIB_FN (library
, XpmCreateImageFromBuffer
);
3240 LOAD_IMGLIB_FN (library
, XpmReadFileToImage
);
3241 LOAD_IMGLIB_FN (library
, XImageFree
);
3245 #endif /* HAVE_NTGUI */
3248 /* Value is non-zero if COLOR_SYMBOLS is a valid color symbols list
3249 for XPM images. Such a list must consist of conses whose car and
3253 xpm_valid_color_symbols_p (Lisp_Object color_symbols
)
3255 while (CONSP (color_symbols
))
3257 Lisp_Object sym
= XCAR (color_symbols
);
3259 || !STRINGP (XCAR (sym
))
3260 || !STRINGP (XCDR (sym
)))
3262 color_symbols
= XCDR (color_symbols
);
3265 return NILP (color_symbols
);
3269 /* Value is non-zero if OBJECT is a valid XPM image specification. */
3272 xpm_image_p (Lisp_Object object
)
3274 struct image_keyword fmt
[XPM_LAST
];
3275 memcpy (fmt
, xpm_format
, sizeof fmt
);
3276 return (parse_image_spec (object
, fmt
, XPM_LAST
, Qxpm
)
3277 /* Either `:file' or `:data' must be present. */
3278 && fmt
[XPM_FILE
].count
+ fmt
[XPM_DATA
].count
== 1
3279 /* Either no `:color-symbols' or it's a list of conses
3280 whose car and cdr are strings. */
3281 && (fmt
[XPM_COLOR_SYMBOLS
].count
== 0
3282 || xpm_valid_color_symbols_p (fmt
[XPM_COLOR_SYMBOLS
].value
)));
3285 #endif /* HAVE_XPM || HAVE_NS */
3287 #if defined HAVE_XPM && defined HAVE_X_WINDOWS && !defined USE_GTK
3289 x_create_bitmap_from_xpm_data (struct frame
*f
, const char **bits
)
3291 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
3294 XpmAttributes attrs
;
3295 Pixmap bitmap
, mask
;
3297 memset (&attrs
, 0, sizeof attrs
);
3299 attrs
.visual
= FRAME_X_VISUAL (f
);
3300 attrs
.colormap
= FRAME_X_COLORMAP (f
);
3301 attrs
.valuemask
|= XpmVisual
;
3302 attrs
.valuemask
|= XpmColormap
;
3304 rc
= XpmCreatePixmapFromData (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3305 (char **) bits
, &bitmap
, &mask
, &attrs
);
3306 if (rc
!= XpmSuccess
)
3308 XpmFreeAttributes (&attrs
);
3312 id
= x_allocate_bitmap_record (f
);
3313 dpyinfo
->bitmaps
[id
- 1].pixmap
= bitmap
;
3314 dpyinfo
->bitmaps
[id
- 1].have_mask
= 1;
3315 dpyinfo
->bitmaps
[id
- 1].mask
= mask
;
3316 dpyinfo
->bitmaps
[id
- 1].file
= NULL
;
3317 dpyinfo
->bitmaps
[id
- 1].height
= attrs
.height
;
3318 dpyinfo
->bitmaps
[id
- 1].width
= attrs
.width
;
3319 dpyinfo
->bitmaps
[id
- 1].depth
= attrs
.depth
;
3320 dpyinfo
->bitmaps
[id
- 1].refcount
= 1;
3322 XpmFreeAttributes (&attrs
);
3325 #endif /* defined (HAVE_XPM) && defined (HAVE_X_WINDOWS) */
3327 /* Load image IMG which will be displayed on frame F. Value is
3328 non-zero if successful. */
3333 xpm_load (struct frame
*f
, struct image
*img
)
3336 XpmAttributes attrs
;
3337 Lisp_Object specified_file
, color_symbols
;
3340 xpm_XImage
* xpm_image
= NULL
, * xpm_mask
= NULL
;
3341 #endif /* HAVE_NTGUI */
3343 /* Configure the XPM lib. Use the visual of frame F. Allocate
3344 close colors. Return colors allocated. */
3345 memset (&attrs
, 0, sizeof attrs
);
3348 attrs
.visual
= FRAME_X_VISUAL (f
);
3349 attrs
.colormap
= FRAME_X_COLORMAP (f
);
3350 attrs
.valuemask
|= XpmVisual
;
3351 attrs
.valuemask
|= XpmColormap
;
3352 #endif /* HAVE_NTGUI */
3354 #ifdef ALLOC_XPM_COLORS
3355 /* Allocate colors with our own functions which handle
3356 failing color allocation more gracefully. */
3357 attrs
.color_closure
= f
;
3358 attrs
.alloc_color
= xpm_alloc_color
;
3359 attrs
.free_colors
= xpm_free_colors
;
3360 attrs
.valuemask
|= XpmAllocColor
| XpmFreeColors
| XpmColorClosure
;
3361 #else /* not ALLOC_XPM_COLORS */
3362 /* Let the XPM lib allocate colors. */
3363 attrs
.valuemask
|= XpmReturnAllocPixels
;
3364 #ifdef XpmAllocCloseColors
3365 attrs
.alloc_close_colors
= 1;
3366 attrs
.valuemask
|= XpmAllocCloseColors
;
3367 #else /* not XpmAllocCloseColors */
3368 attrs
.closeness
= 600;
3369 attrs
.valuemask
|= XpmCloseness
;
3370 #endif /* not XpmAllocCloseColors */
3371 #endif /* ALLOC_XPM_COLORS */
3373 /* If image specification contains symbolic color definitions, add
3374 these to `attrs'. */
3375 color_symbols
= image_spec_value (img
->spec
, QCcolor_symbols
, NULL
);
3376 if (CONSP (color_symbols
))
3379 XpmColorSymbol
*xpm_syms
;
3382 attrs
.valuemask
|= XpmColorSymbols
;
3384 /* Count number of symbols. */
3385 attrs
.numsymbols
= 0;
3386 for (tail
= color_symbols
; CONSP (tail
); tail
= XCDR (tail
))
3389 /* Allocate an XpmColorSymbol array. */
3390 size
= attrs
.numsymbols
* sizeof *xpm_syms
;
3391 xpm_syms
= (XpmColorSymbol
*) alloca (size
);
3392 memset (xpm_syms
, 0, size
);
3393 attrs
.colorsymbols
= xpm_syms
;
3395 /* Fill the color symbol array. */
3396 for (tail
= color_symbols
, i
= 0;
3398 ++i
, tail
= XCDR (tail
))
3402 char *empty_string
= (char *) "";
3404 if (!CONSP (XCAR (tail
)))
3406 xpm_syms
[i
].name
= empty_string
;
3407 xpm_syms
[i
].value
= empty_string
;
3410 name
= XCAR (XCAR (tail
));
3411 color
= XCDR (XCAR (tail
));
3414 xpm_syms
[i
].name
= (char *) alloca (SCHARS (name
) + 1);
3415 strcpy (xpm_syms
[i
].name
, SSDATA (name
));
3418 xpm_syms
[i
].name
= empty_string
;
3419 if (STRINGP (color
))
3421 xpm_syms
[i
].value
= (char *) alloca (SCHARS (color
) + 1);
3422 strcpy (xpm_syms
[i
].value
, SSDATA (color
));
3425 xpm_syms
[i
].value
= empty_string
;
3429 /* Create a pixmap for the image, either from a file, or from a
3430 string buffer containing data in the same format as an XPM file. */
3431 #ifdef ALLOC_XPM_COLORS
3432 xpm_init_color_cache (f
, &attrs
);
3435 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
3439 HDC frame_dc
= get_frame_dc (f
);
3440 hdc
= CreateCompatibleDC (frame_dc
);
3441 release_frame_dc (f
, frame_dc
);
3443 #endif /* HAVE_NTGUI */
3445 if (STRINGP (specified_file
))
3447 Lisp_Object file
= x_find_image_file (specified_file
);
3448 if (!STRINGP (file
))
3450 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
3451 #ifdef ALLOC_XPM_COLORS
3452 xpm_free_color_cache ();
3458 /* XpmReadFileToPixmap is not available in the Windows port of
3459 libxpm. But XpmReadFileToImage almost does what we want. */
3460 rc
= fn_XpmReadFileToImage (&hdc
, SDATA (file
),
3461 &xpm_image
, &xpm_mask
,
3464 rc
= XpmReadFileToPixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3465 SSDATA (file
), &img
->pixmap
, &img
->mask
,
3467 #endif /* HAVE_NTGUI */
3471 Lisp_Object buffer
= image_spec_value (img
->spec
, QCdata
, NULL
);
3472 if (!STRINGP (buffer
))
3474 image_error ("Invalid image data `%s'", buffer
, Qnil
);
3475 #ifdef ALLOC_XPM_COLORS
3476 xpm_free_color_cache ();
3481 /* XpmCreatePixmapFromBuffer is not available in the Windows port
3482 of libxpm. But XpmCreateImageFromBuffer almost does what we want. */
3483 rc
= fn_XpmCreateImageFromBuffer (&hdc
, SDATA (buffer
),
3484 &xpm_image
, &xpm_mask
,
3487 rc
= XpmCreatePixmapFromBuffer (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3489 &img
->pixmap
, &img
->mask
,
3491 #endif /* HAVE_NTGUI */
3494 if (rc
== XpmSuccess
)
3496 #if defined (COLOR_TABLE_SUPPORT) && defined (ALLOC_XPM_COLORS)
3497 img
->colors
= colors_in_color_table (&img
->ncolors
);
3498 #else /* not ALLOC_XPM_COLORS */
3502 /* W32 XPM uses XImage to wrap what W32 Emacs calls a Pixmap,
3503 plus some duplicate attributes. */
3504 if (xpm_image
&& xpm_image
->bitmap
)
3506 img
->pixmap
= xpm_image
->bitmap
;
3507 /* XImageFree in libXpm frees XImage struct without destroying
3508 the bitmap, which is what we want. */
3509 fn_XImageFree (xpm_image
);
3511 if (xpm_mask
&& xpm_mask
->bitmap
)
3513 /* The mask appears to be inverted compared with what we expect.
3514 TODO: invert our expectations. See other places where we
3515 have to invert bits because our idea of masks is backwards. */
3517 old_obj
= SelectObject (hdc
, xpm_mask
->bitmap
);
3519 PatBlt (hdc
, 0, 0, xpm_mask
->width
, xpm_mask
->height
, DSTINVERT
);
3520 SelectObject (hdc
, old_obj
);
3522 img
->mask
= xpm_mask
->bitmap
;
3523 fn_XImageFree (xpm_mask
);
3528 #endif /* HAVE_NTGUI */
3530 /* Remember allocated colors. */
3531 img
->ncolors
= attrs
.nalloc_pixels
;
3532 img
->colors
= (unsigned long *) xmalloc (img
->ncolors
3533 * sizeof *img
->colors
);
3534 for (i
= 0; i
< attrs
.nalloc_pixels
; ++i
)
3536 img
->colors
[i
] = attrs
.alloc_pixels
[i
];
3537 #ifdef DEBUG_X_COLORS
3538 register_color (img
->colors
[i
]);
3541 #endif /* not ALLOC_XPM_COLORS */
3543 img
->width
= attrs
.width
;
3544 img
->height
= attrs
.height
;
3545 xassert (img
->width
> 0 && img
->height
> 0);
3547 /* The call to XpmFreeAttributes below frees attrs.alloc_pixels. */
3549 fn_XpmFreeAttributes (&attrs
);
3551 XpmFreeAttributes (&attrs
);
3552 #endif /* HAVE_NTGUI */
3558 #endif /* HAVE_NTGUI */
3563 image_error ("Error opening XPM file (%s)", img
->spec
, Qnil
);
3566 case XpmFileInvalid
:
3567 image_error ("Invalid XPM file (%s)", img
->spec
, Qnil
);
3571 image_error ("Out of memory (%s)", img
->spec
, Qnil
);
3574 case XpmColorFailed
:
3575 image_error ("Color allocation error (%s)", img
->spec
, Qnil
);
3579 image_error ("Unknown error (%s)", img
->spec
, Qnil
);
3584 #ifdef ALLOC_XPM_COLORS
3585 xpm_free_color_cache ();
3587 return rc
== XpmSuccess
;
3590 #endif /* HAVE_XPM */
3592 #if defined (HAVE_NS) && !defined (HAVE_XPM)
3594 /* XPM support functions for NS where libxpm is not available.
3595 Only XPM version 3 (without any extensions) is supported. */
3597 static void xpm_put_color_table_v (Lisp_Object
, const unsigned char *,
3599 static Lisp_Object
xpm_get_color_table_v (Lisp_Object
,
3600 const unsigned char *, int);
3601 static void xpm_put_color_table_h (Lisp_Object
, const unsigned char *,
3603 static Lisp_Object
xpm_get_color_table_h (Lisp_Object
,
3604 const unsigned char *, int);
3606 /* Tokens returned from xpm_scan. */
3615 /* Scan an XPM data and return a character (< 256) or a token defined
3616 by enum xpm_token above. *S and END are the start (inclusive) and
3617 the end (exclusive) addresses of the data, respectively. Advance
3618 *S while scanning. If token is either XPM_TK_IDENT or
3619 XPM_TK_STRING, *BEG and *LEN are set to the start address and the
3620 length of the corresponding token, respectively. */
3623 xpm_scan (const unsigned char **s
,
3624 const unsigned char *end
,
3625 const unsigned char **beg
,
3632 /* Skip white-space. */
3633 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
3636 /* gnus-pointer.xpm uses '-' in its identifier.
3637 sb-dir-plus.xpm uses '+' in its identifier. */
3638 if (isalpha (c
) || c
== '_' || c
== '-' || c
== '+')
3642 && (c
= **s
, isalnum (c
) || c
== '_' || c
== '-' || c
== '+'))
3645 return XPM_TK_IDENT
;
3650 while (*s
< end
&& **s
!= '"')
3655 return XPM_TK_STRING
;
3659 if (*s
< end
&& **s
== '*')
3661 /* C-style comment. */
3665 while (*s
< end
&& *(*s
)++ != '*')
3668 while (*s
< end
&& **s
!= '/');
3682 /* Functions for color table lookup in XPM data. A key is a string
3683 specifying the color of each pixel in XPM data. A value is either
3684 an integer that specifies a pixel color, Qt that specifies
3685 transparency, or Qnil for the unspecified color. If the length of
3686 the key string is one, a vector is used as a table. Otherwise, a
3687 hash table is used. */
3690 xpm_make_color_table_v (void (**put_func
) (Lisp_Object
,
3691 const unsigned char *,
3694 Lisp_Object (**get_func
) (Lisp_Object
,
3695 const unsigned char *,
3698 *put_func
= xpm_put_color_table_v
;
3699 *get_func
= xpm_get_color_table_v
;
3700 return Fmake_vector (make_number (256), Qnil
);
3704 xpm_put_color_table_v (Lisp_Object color_table
,
3705 const unsigned char *chars_start
,
3709 XVECTOR (color_table
)->contents
[*chars_start
] = color
;
3713 xpm_get_color_table_v (Lisp_Object color_table
,
3714 const unsigned char *chars_start
,
3717 return XVECTOR (color_table
)->contents
[*chars_start
];
3721 xpm_make_color_table_h (void (**put_func
) (Lisp_Object
,
3722 const unsigned char *,
3725 Lisp_Object (**get_func
) (Lisp_Object
,
3726 const unsigned char *,
3729 *put_func
= xpm_put_color_table_h
;
3730 *get_func
= xpm_get_color_table_h
;
3731 return make_hash_table (Qequal
, make_number (DEFAULT_HASH_SIZE
),
3732 make_float (DEFAULT_REHASH_SIZE
),
3733 make_float (DEFAULT_REHASH_THRESHOLD
),
3738 xpm_put_color_table_h (Lisp_Object color_table
,
3739 const unsigned char *chars_start
,
3743 struct Lisp_Hash_Table
*table
= XHASH_TABLE (color_table
);
3744 EMACS_UINT hash_code
;
3745 Lisp_Object chars
= make_unibyte_string (chars_start
, chars_len
);
3747 hash_lookup (table
, chars
, &hash_code
);
3748 hash_put (table
, chars
, color
, hash_code
);
3752 xpm_get_color_table_h (Lisp_Object color_table
,
3753 const unsigned char *chars_start
,
3756 struct Lisp_Hash_Table
*table
= XHASH_TABLE (color_table
);
3757 int i
= hash_lookup (table
, make_unibyte_string (chars_start
, chars_len
),
3760 return i
>= 0 ? HASH_VALUE (table
, i
) : Qnil
;
3763 enum xpm_color_key
{
3771 static const char xpm_color_key_strings
[][4] = {"s", "m", "g4", "g", "c"};
3774 xpm_str_to_color_key (const char *s
)
3779 i
< sizeof xpm_color_key_strings
/ sizeof xpm_color_key_strings
[0];
3781 if (strcmp (xpm_color_key_strings
[i
], s
) == 0)
3787 xpm_load_image (struct frame
*f
,
3789 const unsigned char *contents
,
3790 const unsigned char *end
)
3792 const unsigned char *s
= contents
, *beg
, *str
;
3793 unsigned char buffer
[BUFSIZ
];
3794 int width
, height
, x
, y
;
3795 int num_colors
, chars_per_pixel
;
3798 void (*put_color_table
) (Lisp_Object
, const unsigned char *, int, Lisp_Object
);
3799 Lisp_Object (*get_color_table
) (Lisp_Object
, const unsigned char *, int);
3800 Lisp_Object frame
, color_symbols
, color_table
;
3801 int best_key
, have_mask
= 0;
3802 XImagePtr ximg
= NULL
, mask_img
= NULL
;
3805 LA1 = xpm_scan (&s, end, &beg, &len)
3807 #define expect(TOKEN) \
3808 if (LA1 != (TOKEN)) \
3813 #define expect_ident(IDENT) \
3814 if (LA1 == XPM_TK_IDENT \
3815 && strlen ((IDENT)) == len && memcmp ((IDENT), beg, len) == 0) \
3820 if (!(end
- s
>= 9 && memcmp (s
, "/* XPM */", 9) == 0))
3824 expect_ident ("static");
3825 expect_ident ("char");
3827 expect (XPM_TK_IDENT
);
3832 expect (XPM_TK_STRING
);
3835 memcpy (buffer
, beg
, len
);
3837 if (sscanf (buffer
, "%d %d %d %d", &width
, &height
,
3838 &num_colors
, &chars_per_pixel
) != 4
3839 || width
<= 0 || height
<= 0
3840 || num_colors
<= 0 || chars_per_pixel
<= 0)
3843 if (!check_image_size (f
, width
, height
))
3845 image_error ("Invalid image size (see `max-image-size')", Qnil
, Qnil
);
3851 XSETFRAME (frame
, f
);
3852 if (!NILP (Fxw_display_color_p (frame
)))
3853 best_key
= XPM_COLOR_KEY_C
;
3854 else if (!NILP (Fx_display_grayscale_p (frame
)))
3855 best_key
= (XFASTINT (Fx_display_planes (frame
)) > 2
3856 ? XPM_COLOR_KEY_G
: XPM_COLOR_KEY_G4
);
3858 best_key
= XPM_COLOR_KEY_M
;
3860 color_symbols
= image_spec_value (img
->spec
, QCcolor_symbols
, NULL
);
3861 if (chars_per_pixel
== 1)
3862 color_table
= xpm_make_color_table_v (&put_color_table
,
3865 color_table
= xpm_make_color_table_h (&put_color_table
,
3868 while (num_colors
-- > 0)
3870 char *color
, *max_color
;
3871 int key
, next_key
, max_key
= 0;
3872 Lisp_Object symbol_color
= Qnil
, color_val
;
3875 expect (XPM_TK_STRING
);
3876 if (len
<= chars_per_pixel
|| len
>= BUFSIZ
+ chars_per_pixel
)
3878 memcpy (buffer
, beg
+ chars_per_pixel
, len
- chars_per_pixel
);
3879 buffer
[len
- chars_per_pixel
] = '\0';
3881 str
= strtok (buffer
, " \t");
3884 key
= xpm_str_to_color_key (str
);
3889 color
= strtok (NULL
, " \t");
3893 while ((str
= strtok (NULL
, " \t")) != NULL
)
3895 next_key
= xpm_str_to_color_key (str
);
3898 color
[strlen (color
)] = ' ';
3901 if (key
== XPM_COLOR_KEY_S
)
3903 if (NILP (symbol_color
))
3904 symbol_color
= build_string (color
);
3906 else if (max_key
< key
&& key
<= best_key
)
3916 if (!NILP (color_symbols
) && !NILP (symbol_color
))
3918 Lisp_Object specified_color
= Fassoc (symbol_color
, color_symbols
);
3920 if (CONSP (specified_color
) && STRINGP (XCDR (specified_color
)))
3922 if (xstrcasecmp (SSDATA (XCDR (specified_color
)), "None") == 0)
3924 else if (x_defined_color (f
, SDATA (XCDR (specified_color
)),
3926 color_val
= make_number (cdef
.pixel
);
3929 if (NILP (color_val
) && max_key
> 0)
3931 if (xstrcasecmp (max_color
, "None") == 0)
3933 else if (x_defined_color (f
, max_color
, &cdef
, 0))
3934 color_val
= make_number (cdef
.pixel
);
3936 if (!NILP (color_val
))
3937 (*put_color_table
) (color_table
, beg
, chars_per_pixel
, color_val
);
3942 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0,
3943 &ximg
, &img
->pixmap
)
3945 || !x_create_x_image_and_pixmap (f
, width
, height
, 1,
3946 &mask_img
, &img
->mask
)
3950 image_error ("Out of memory (%s)", img
->spec
, Qnil
);
3954 for (y
= 0; y
< height
; y
++)
3956 expect (XPM_TK_STRING
);
3958 if (len
< width
* chars_per_pixel
)
3960 for (x
= 0; x
< width
; x
++, str
+= chars_per_pixel
)
3962 Lisp_Object color_val
=
3963 (*get_color_table
) (color_table
, str
, chars_per_pixel
);
3965 XPutPixel (ximg
, x
, y
,
3966 (INTEGERP (color_val
) ? XINT (color_val
)
3967 : FRAME_FOREGROUND_PIXEL (f
)));
3969 XPutPixel (mask_img
, x
, y
,
3970 (!EQ (color_val
, Qt
) ? PIX_MASK_DRAW
3971 : (have_mask
= 1, PIX_MASK_RETAIN
)));
3973 if (EQ (color_val
, Qt
))
3974 ns_set_alpha (ximg
, x
, y
, 0);
3982 img
->height
= height
;
3984 /* Maybe fill in the background field while we have ximg handy. */
3985 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
3986 IMAGE_BACKGROUND (img
, f
, ximg
);
3988 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
3989 x_destroy_x_image (ximg
);
3993 /* Fill in the background_transparent field while we have the
3995 image_background_transparent (img
, f
, mask_img
);
3997 x_put_x_image (f
, mask_img
, img
->mask
, width
, height
);
3998 x_destroy_x_image (mask_img
);
4002 x_destroy_x_image (mask_img
);
4003 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
4004 img
->mask
= NO_PIXMAP
;
4010 image_error ("Invalid XPM file (%s)", img
->spec
, Qnil
);
4012 x_destroy_x_image (ximg
);
4013 x_destroy_x_image (mask_img
);
4014 x_clear_image (f
, img
);
4023 xpm_load (struct frame
*f
,
4027 Lisp_Object file_name
;
4029 /* If IMG->spec specifies a file name, create a non-file spec from it. */
4030 file_name
= image_spec_value (img
->spec
, QCfile
, NULL
);
4031 if (STRINGP (file_name
))
4034 unsigned char *contents
;
4037 file
= x_find_image_file (file_name
);
4038 if (!STRINGP (file
))
4040 image_error ("Cannot find image file `%s'", file_name
, Qnil
);
4044 contents
= slurp_file (SDATA (file
), &size
);
4045 if (contents
== NULL
)
4047 image_error ("Error loading XPM image `%s'", img
->spec
, Qnil
);
4051 success_p
= xpm_load_image (f
, img
, contents
, contents
+ size
);
4058 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
4059 if (!STRINGP (data
))
4061 image_error ("Invalid image data `%s'", data
, Qnil
);
4064 success_p
= xpm_load_image (f
, img
, SDATA (data
),
4065 SDATA (data
) + SBYTES (data
));
4071 #endif /* HAVE_NS && !HAVE_XPM */
4075 /***********************************************************************
4077 ***********************************************************************/
4079 #ifdef COLOR_TABLE_SUPPORT
4081 /* An entry in the color table mapping an RGB color to a pixel color. */
4086 unsigned long pixel
;
4088 /* Next in color table collision list. */
4089 struct ct_color
*next
;
4092 /* The bucket vector size to use. Must be prime. */
4096 /* Value is a hash of the RGB color given by R, G, and B. */
4098 #define CT_HASH_RGB(R, G, B) (((R) << 16) ^ ((G) << 8) ^ (B))
4100 /* The color hash table. */
4102 static struct ct_color
**ct_table
;
4104 /* Number of entries in the color table. */
4106 static int ct_colors_allocated
;
4108 /* Initialize the color table. */
4111 init_color_table (void)
4113 int size
= CT_SIZE
* sizeof (*ct_table
);
4114 ct_table
= (struct ct_color
**) xmalloc (size
);
4115 memset (ct_table
, 0, size
);
4116 ct_colors_allocated
= 0;
4120 /* Free memory associated with the color table. */
4123 free_color_table (void)
4126 struct ct_color
*p
, *next
;
4128 for (i
= 0; i
< CT_SIZE
; ++i
)
4129 for (p
= ct_table
[i
]; p
; p
= next
)
4140 /* Value is a pixel color for RGB color R, G, B on frame F. If an
4141 entry for that color already is in the color table, return the
4142 pixel color of that entry. Otherwise, allocate a new color for R,
4143 G, B, and make an entry in the color table. */
4145 static unsigned long
4146 lookup_rgb_color (struct frame
*f
, int r
, int g
, int b
)
4148 unsigned hash
= CT_HASH_RGB (r
, g
, b
);
4149 int i
= hash
% CT_SIZE
;
4151 Display_Info
*dpyinfo
;
4153 /* Handle TrueColor visuals specially, which improves performance by
4154 two orders of magnitude. Freeing colors on TrueColor visuals is
4155 a nop, and pixel colors specify RGB values directly. See also
4156 the Xlib spec, chapter 3.1. */
4157 dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
4158 if (dpyinfo
->red_bits
> 0)
4160 unsigned long pr
, pg
, pb
;
4162 /* Apply gamma-correction like normal color allocation does. */
4166 color
.red
= r
, color
.green
= g
, color
.blue
= b
;
4167 gamma_correct (f
, &color
);
4168 r
= color
.red
, g
= color
.green
, b
= color
.blue
;
4171 /* Scale down RGB values to the visual's bits per RGB, and shift
4172 them to the right position in the pixel color. Note that the
4173 original RGB values are 16-bit values, as usual in X. */
4174 pr
= (r
>> (16 - dpyinfo
->red_bits
)) << dpyinfo
->red_offset
;
4175 pg
= (g
>> (16 - dpyinfo
->green_bits
)) << dpyinfo
->green_offset
;
4176 pb
= (b
>> (16 - dpyinfo
->blue_bits
)) << dpyinfo
->blue_offset
;
4178 /* Assemble the pixel color. */
4179 return pr
| pg
| pb
;
4182 for (p
= ct_table
[i
]; p
; p
= p
->next
)
4183 if (p
->r
== r
&& p
->g
== g
&& p
->b
== b
)
4189 #ifdef HAVE_X_WINDOWS
4198 cmap
= FRAME_X_COLORMAP (f
);
4199 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
4202 ++ct_colors_allocated
;
4203 p
= (struct ct_color
*) xmalloc (sizeof *p
);
4207 p
->pixel
= color
.pixel
;
4208 p
->next
= ct_table
[i
];
4212 return FRAME_FOREGROUND_PIXEL (f
);
4217 color
= PALETTERGB (r
, g
, b
);
4219 color
= RGB_TO_ULONG (r
, g
, b
);
4220 #endif /* HAVE_NTGUI */
4221 ++ct_colors_allocated
;
4222 p
= (struct ct_color
*) xmalloc (sizeof *p
);
4227 p
->next
= ct_table
[i
];
4229 #endif /* HAVE_X_WINDOWS */
4237 /* Look up pixel color PIXEL which is used on frame F in the color
4238 table. If not already present, allocate it. Value is PIXEL. */
4240 static unsigned long
4241 lookup_pixel_color (struct frame
*f
, unsigned long pixel
)
4243 int i
= pixel
% CT_SIZE
;
4246 for (p
= ct_table
[i
]; p
; p
= p
->next
)
4247 if (p
->pixel
== pixel
)
4256 #ifdef HAVE_X_WINDOWS
4257 cmap
= FRAME_X_COLORMAP (f
);
4258 color
.pixel
= pixel
;
4259 x_query_color (f
, &color
);
4260 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
4263 cmap
= DefaultColormapOfScreen (FRAME_X_SCREEN (f
));
4264 color
.pixel
= pixel
;
4265 XQueryColor (NULL
, cmap
, &color
);
4266 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
4268 #endif /* HAVE_X_WINDOWS */
4272 ++ct_colors_allocated
;
4274 p
= (struct ct_color
*) xmalloc (sizeof *p
);
4279 p
->next
= ct_table
[i
];
4283 return FRAME_FOREGROUND_PIXEL (f
);
4289 /* Value is a vector of all pixel colors contained in the color table,
4290 allocated via xmalloc. Set *N to the number of colors. */
4292 static unsigned long *
4293 colors_in_color_table (int *n
)
4297 unsigned long *colors
;
4299 if (ct_colors_allocated
== 0)
4306 colors
= (unsigned long *) xmalloc (ct_colors_allocated
4308 *n
= ct_colors_allocated
;
4310 for (i
= j
= 0; i
< CT_SIZE
; ++i
)
4311 for (p
= ct_table
[i
]; p
; p
= p
->next
)
4312 colors
[j
++] = p
->pixel
;
4318 #else /* COLOR_TABLE_SUPPORT */
4320 static unsigned long
4321 lookup_rgb_color (struct frame
*f
, int r
, int g
, int b
)
4323 unsigned long pixel
;
4326 pixel
= PALETTERGB (r
>> 8, g
>> 8, b
>> 8);
4327 #endif /* HAVE_NTGUI */
4330 pixel
= RGB_TO_ULONG (r
>> 8, g
>> 8, b
>> 8);
4331 #endif /* HAVE_NS */
4336 init_color_table (void)
4339 #endif /* COLOR_TABLE_SUPPORT */
4342 /***********************************************************************
4344 ***********************************************************************/
4346 static XColor
*x_to_xcolors (struct frame
*, struct image
*, int);
4347 static void x_from_xcolors (struct frame
*, struct image
*, XColor
*);
4348 static void x_detect_edges (struct frame
*, struct image
*, int[9], int);
4351 static void XPutPixel (XImagePtr
, int, int, COLORREF
);
4352 #endif /* HAVE_NTGUI */
4354 /* Edge detection matrices for different edge-detection
4357 static int emboss_matrix
[9] = {
4359 2, -1, 0, /* y - 1 */
4361 0, 1, -2 /* y + 1 */
4364 static int laplace_matrix
[9] = {
4366 1, 0, 0, /* y - 1 */
4368 0, 0, -1 /* y + 1 */
4371 /* Value is the intensity of the color whose red/green/blue values
4374 #define COLOR_INTENSITY(R, G, B) ((2 * (R) + 3 * (G) + (B)) / 6)
4377 /* On frame F, return an array of XColor structures describing image
4378 IMG->pixmap. Each XColor structure has its pixel color set. RGB_P
4379 non-zero means also fill the red/green/blue members of the XColor
4380 structures. Value is a pointer to the array of XColors structures,
4381 allocated with xmalloc; it must be freed by the caller. */
4384 x_to_xcolors (struct frame
*f
, struct image
*img
, int rgb_p
)
4388 XImagePtr_or_DC ximg
;
4392 #endif /* HAVE_NTGUI */
4394 colors
= (XColor
*) xmalloc (img
->width
* img
->height
* sizeof *colors
);
4397 /* Get the X image IMG->pixmap. */
4398 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
4399 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
4401 /* Load the image into a memory device context. */
4402 hdc
= get_frame_dc (f
);
4403 ximg
= CreateCompatibleDC (hdc
);
4404 release_frame_dc (f
, hdc
);
4405 prev
= SelectObject (ximg
, img
->pixmap
);
4406 #endif /* HAVE_NTGUI */
4408 /* Fill the `pixel' members of the XColor array. I wished there
4409 were an easy and portable way to circumvent XGetPixel. */
4411 for (y
= 0; y
< img
->height
; ++y
)
4415 #if defined (HAVE_X_WINDOWS) || defined (HAVE_NTGUI)
4416 for (x
= 0; x
< img
->width
; ++x
, ++p
)
4417 p
->pixel
= GET_PIXEL (ximg
, x
, y
);
4419 x_query_colors (f
, row
, img
->width
);
4423 for (x
= 0; x
< img
->width
; ++x
, ++p
)
4425 /* W32_TODO: palette support needed here? */
4426 p
->pixel
= GET_PIXEL (ximg
, x
, y
);
4429 p
->red
= RED16_FROM_ULONG (p
->pixel
);
4430 p
->green
= GREEN16_FROM_ULONG (p
->pixel
);
4431 p
->blue
= BLUE16_FROM_ULONG (p
->pixel
);
4434 #endif /* HAVE_X_WINDOWS */
4437 Destroy_Image (ximg
, prev
);
4444 /* Put a pixel of COLOR at position X, Y in XIMG. XIMG must have been
4445 created with CreateDIBSection, with the pointer to the bit values
4446 stored in ximg->data. */
4449 XPutPixel (XImagePtr ximg
, int x
, int y
, COLORREF color
)
4451 int width
= ximg
->info
.bmiHeader
.biWidth
;
4452 unsigned char * pixel
;
4454 /* True color images. */
4455 if (ximg
->info
.bmiHeader
.biBitCount
== 24)
4457 int rowbytes
= width
* 3;
4458 /* Ensure scanlines are aligned on 4 byte boundaries. */
4460 rowbytes
+= 4 - (rowbytes
% 4);
4462 pixel
= ximg
->data
+ y
* rowbytes
+ x
* 3;
4463 /* Windows bitmaps are in BGR order. */
4464 *pixel
= GetBValue (color
);
4465 *(pixel
+ 1) = GetGValue (color
);
4466 *(pixel
+ 2) = GetRValue (color
);
4468 /* Monochrome images. */
4469 else if (ximg
->info
.bmiHeader
.biBitCount
== 1)
4471 int rowbytes
= width
/ 8;
4472 /* Ensure scanlines are aligned on 4 byte boundaries. */
4474 rowbytes
+= 4 - (rowbytes
% 4);
4475 pixel
= ximg
->data
+ y
* rowbytes
+ x
/ 8;
4476 /* Filter out palette info. */
4477 if (color
& 0x00ffffff)
4478 *pixel
= *pixel
| (1 << x
% 8);
4480 *pixel
= *pixel
& ~(1 << x
% 8);
4483 image_error ("XPutPixel: palette image not supported", Qnil
, Qnil
);
4486 #endif /* HAVE_NTGUI */
4488 /* Create IMG->pixmap from an array COLORS of XColor structures, whose
4489 RGB members are set. F is the frame on which this all happens.
4490 COLORS will be freed; an existing IMG->pixmap will be freed, too. */
4493 x_from_xcolors (struct frame
*f
, struct image
*img
, XColor
*colors
)
4496 XImagePtr oimg
= NULL
;
4500 init_color_table ();
4502 x_create_x_image_and_pixmap (f
, img
->width
, img
->height
, 0,
4505 for (y
= 0; y
< img
->height
; ++y
)
4506 for (x
= 0; x
< img
->width
; ++x
, ++p
)
4508 unsigned long pixel
;
4509 pixel
= lookup_rgb_color (f
, p
->red
, p
->green
, p
->blue
);
4510 XPutPixel (oimg
, x
, y
, pixel
);
4514 x_clear_image_1 (f
, img
, 1, 0, 1);
4516 x_put_x_image (f
, oimg
, pixmap
, img
->width
, img
->height
);
4517 x_destroy_x_image (oimg
);
4518 img
->pixmap
= pixmap
;
4519 #ifdef COLOR_TABLE_SUPPORT
4520 img
->colors
= colors_in_color_table (&img
->ncolors
);
4521 free_color_table ();
4522 #endif /* COLOR_TABLE_SUPPORT */
4526 /* On frame F, perform edge-detection on image IMG.
4528 MATRIX is a nine-element array specifying the transformation
4529 matrix. See emboss_matrix for an example.
4531 COLOR_ADJUST is a color adjustment added to each pixel of the
4535 x_detect_edges (struct frame
*f
, struct image
*img
, int *matrix
, int color_adjust
)
4537 XColor
*colors
= x_to_xcolors (f
, img
, 1);
4541 for (i
= sum
= 0; i
< 9; ++i
)
4542 sum
+= eabs (matrix
[i
]);
4544 #define COLOR(A, X, Y) ((A) + (Y) * img->width + (X))
4546 new = (XColor
*) xmalloc (img
->width
* img
->height
* sizeof *new);
4548 for (y
= 0; y
< img
->height
; ++y
)
4550 p
= COLOR (new, 0, y
);
4551 p
->red
= p
->green
= p
->blue
= 0xffff/2;
4552 p
= COLOR (new, img
->width
- 1, y
);
4553 p
->red
= p
->green
= p
->blue
= 0xffff/2;
4556 for (x
= 1; x
< img
->width
- 1; ++x
)
4558 p
= COLOR (new, x
, 0);
4559 p
->red
= p
->green
= p
->blue
= 0xffff/2;
4560 p
= COLOR (new, x
, img
->height
- 1);
4561 p
->red
= p
->green
= p
->blue
= 0xffff/2;
4564 for (y
= 1; y
< img
->height
- 1; ++y
)
4566 p
= COLOR (new, 1, y
);
4568 for (x
= 1; x
< img
->width
- 1; ++x
, ++p
)
4570 int r
, g
, b
, yy
, xx
;
4573 for (yy
= y
- 1; yy
< y
+ 2; ++yy
)
4574 for (xx
= x
- 1; xx
< x
+ 2; ++xx
, ++i
)
4577 XColor
*t
= COLOR (colors
, xx
, yy
);
4578 r
+= matrix
[i
] * t
->red
;
4579 g
+= matrix
[i
] * t
->green
;
4580 b
+= matrix
[i
] * t
->blue
;
4583 r
= (r
/ sum
+ color_adjust
) & 0xffff;
4584 g
= (g
/ sum
+ color_adjust
) & 0xffff;
4585 b
= (b
/ sum
+ color_adjust
) & 0xffff;
4586 p
->red
= p
->green
= p
->blue
= COLOR_INTENSITY (r
, g
, b
);
4591 x_from_xcolors (f
, img
, new);
4597 /* Perform the pre-defined `emboss' edge-detection on image IMG
4601 x_emboss (struct frame
*f
, struct image
*img
)
4603 x_detect_edges (f
, img
, emboss_matrix
, 0xffff / 2);
4607 /* Transform image IMG which is used on frame F with a Laplace
4608 edge-detection algorithm. The result is an image that can be used
4609 to draw disabled buttons, for example. */
4612 x_laplace (struct frame
*f
, struct image
*img
)
4614 x_detect_edges (f
, img
, laplace_matrix
, 45000);
4618 /* Perform edge-detection on image IMG on frame F, with specified
4619 transformation matrix MATRIX and color-adjustment COLOR_ADJUST.
4621 MATRIX must be either
4623 - a list of at least 9 numbers in row-major form
4624 - a vector of at least 9 numbers
4626 COLOR_ADJUST nil means use a default; otherwise it must be a
4630 x_edge_detection (struct frame
*f
, struct image
*img
, Lisp_Object matrix
,
4631 Lisp_Object color_adjust
)
4639 i
< 9 && CONSP (matrix
) && NUMBERP (XCAR (matrix
));
4640 ++i
, matrix
= XCDR (matrix
))
4641 trans
[i
] = XFLOATINT (XCAR (matrix
));
4643 else if (VECTORP (matrix
) && ASIZE (matrix
) >= 9)
4645 for (i
= 0; i
< 9 && NUMBERP (AREF (matrix
, i
)); ++i
)
4646 trans
[i
] = XFLOATINT (AREF (matrix
, i
));
4649 if (NILP (color_adjust
))
4650 color_adjust
= make_number (0xffff / 2);
4652 if (i
== 9 && NUMBERP (color_adjust
))
4653 x_detect_edges (f
, img
, trans
, XFLOATINT (color_adjust
));
4657 /* Transform image IMG on frame F so that it looks disabled. */
4660 x_disable_image (struct frame
*f
, struct image
*img
)
4662 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
4664 int n_planes
= dpyinfo
->n_planes
* dpyinfo
->n_cbits
;
4666 int n_planes
= dpyinfo
->n_planes
;
4667 #endif /* HAVE_NTGUI */
4671 /* Color (or grayscale). Convert to gray, and equalize. Just
4672 drawing such images with a stipple can look very odd, so
4673 we're using this method instead. */
4674 XColor
*colors
= x_to_xcolors (f
, img
, 1);
4676 const int h
= 15000;
4677 const int l
= 30000;
4679 for (p
= colors
, end
= colors
+ img
->width
* img
->height
;
4683 int i
= COLOR_INTENSITY (p
->red
, p
->green
, p
->blue
);
4684 int i2
= (0xffff - h
- l
) * i
/ 0xffff + l
;
4685 p
->red
= p
->green
= p
->blue
= i2
;
4688 x_from_xcolors (f
, img
, colors
);
4691 /* Draw a cross over the disabled image, if we must or if we
4693 if (n_planes
< 2 || cross_disabled_images
)
4696 Display
*dpy
= FRAME_X_DISPLAY (f
);
4699 #ifndef HAVE_NS /* TODO: NS support, however this not needed for toolbars */
4701 #define MaskForeground(f) WHITE_PIX_DEFAULT (f)
4703 gc
= XCreateGC (dpy
, img
->pixmap
, 0, NULL
);
4704 XSetForeground (dpy
, gc
, BLACK_PIX_DEFAULT (f
));
4705 XDrawLine (dpy
, img
->pixmap
, gc
, 0, 0,
4706 img
->width
- 1, img
->height
- 1);
4707 XDrawLine (dpy
, img
->pixmap
, gc
, 0, img
->height
- 1,
4713 gc
= XCreateGC (dpy
, img
->mask
, 0, NULL
);
4714 XSetForeground (dpy
, gc
, MaskForeground (f
));
4715 XDrawLine (dpy
, img
->mask
, gc
, 0, 0,
4716 img
->width
- 1, img
->height
- 1);
4717 XDrawLine (dpy
, img
->mask
, gc
, 0, img
->height
- 1,
4721 #endif /* !HAVE_NS */
4726 hdc
= get_frame_dc (f
);
4727 bmpdc
= CreateCompatibleDC (hdc
);
4728 release_frame_dc (f
, hdc
);
4730 prev
= SelectObject (bmpdc
, img
->pixmap
);
4732 SetTextColor (bmpdc
, BLACK_PIX_DEFAULT (f
));
4733 MoveToEx (bmpdc
, 0, 0, NULL
);
4734 LineTo (bmpdc
, img
->width
- 1, img
->height
- 1);
4735 MoveToEx (bmpdc
, 0, img
->height
- 1, NULL
);
4736 LineTo (bmpdc
, img
->width
- 1, 0);
4740 SelectObject (bmpdc
, img
->mask
);
4741 SetTextColor (bmpdc
, WHITE_PIX_DEFAULT (f
));
4742 MoveToEx (bmpdc
, 0, 0, NULL
);
4743 LineTo (bmpdc
, img
->width
- 1, img
->height
- 1);
4744 MoveToEx (bmpdc
, 0, img
->height
- 1, NULL
);
4745 LineTo (bmpdc
, img
->width
- 1, 0);
4747 SelectObject (bmpdc
, prev
);
4749 #endif /* HAVE_NTGUI */
4754 /* Build a mask for image IMG which is used on frame F. FILE is the
4755 name of an image file, for error messages. HOW determines how to
4756 determine the background color of IMG. If it is a list '(R G B)',
4757 with R, G, and B being integers >= 0, take that as the color of the
4758 background. Otherwise, determine the background color of IMG
4759 heuristically. Value is non-zero if successful. */
4762 x_build_heuristic_mask (struct frame
*f
, struct image
*img
, Lisp_Object how
)
4764 XImagePtr_or_DC ximg
;
4772 #endif /* HAVE_NTGUI */
4773 int x
, y
, rc
, use_img_background
;
4774 unsigned long bg
= 0;
4778 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
4779 img
->mask
= NO_PIXMAP
;
4780 img
->background_transparent_valid
= 0;
4785 /* Create an image and pixmap serving as mask. */
4786 rc
= x_create_x_image_and_pixmap (f
, img
->width
, img
->height
, 1,
4787 &mask_img
, &img
->mask
);
4790 #endif /* !HAVE_NS */
4792 /* Get the X image of IMG->pixmap. */
4793 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
, 0, 0,
4794 img
->width
, img
->height
,
4797 /* Create the bit array serving as mask. */
4798 row_width
= (img
->width
+ 7) / 8;
4799 mask_img
= xmalloc (row_width
* img
->height
);
4800 memset (mask_img
, 0, row_width
* img
->height
);
4802 /* Create a memory device context for IMG->pixmap. */
4803 frame_dc
= get_frame_dc (f
);
4804 ximg
= CreateCompatibleDC (frame_dc
);
4805 release_frame_dc (f
, frame_dc
);
4806 prev
= SelectObject (ximg
, img
->pixmap
);
4807 #endif /* HAVE_NTGUI */
4809 /* Determine the background color of ximg. If HOW is `(R G B)'
4810 take that as color. Otherwise, use the image's background color. */
4811 use_img_background
= 1;
4817 for (i
= 0; i
< 3 && CONSP (how
) && NATNUMP (XCAR (how
)); ++i
)
4819 rgb
[i
] = XFASTINT (XCAR (how
)) & 0xffff;
4823 if (i
== 3 && NILP (how
))
4825 char color_name
[30];
4826 sprintf (color_name
, "#%04x%04x%04x", rgb
[0], rgb
[1], rgb
[2]);
4829 0x00ffffff & /* Filter out palette info. */
4830 #endif /* HAVE_NTGUI */
4831 x_alloc_image_color (f
, img
, build_string (color_name
), 0));
4832 use_img_background
= 0;
4836 if (use_img_background
)
4837 bg
= four_corners_best (ximg
, img
->corners
, img
->width
, img
->height
);
4839 /* Set all bits in mask_img to 1 whose color in ximg is different
4840 from the background color bg. */
4842 for (y
= 0; y
< img
->height
; ++y
)
4843 for (x
= 0; x
< img
->width
; ++x
)
4845 XPutPixel (mask_img
, x
, y
, (XGetPixel (ximg
, x
, y
) != bg
4846 ? PIX_MASK_DRAW
: PIX_MASK_RETAIN
));
4848 if (XGetPixel (ximg
, x
, y
) == bg
)
4849 ns_set_alpha (ximg
, x
, y
, 0);
4850 #endif /* HAVE_NS */
4852 /* Fill in the background_transparent field while we have the mask handy. */
4853 image_background_transparent (img
, f
, mask_img
);
4855 /* Put mask_img into img->mask. */
4856 x_put_x_image (f
, mask_img
, img
->mask
, img
->width
, img
->height
);
4857 x_destroy_x_image (mask_img
);
4858 #endif /* !HAVE_NS */
4860 for (y
= 0; y
< img
->height
; ++y
)
4861 for (x
= 0; x
< img
->width
; ++x
)
4863 COLORREF p
= GetPixel (ximg
, x
, y
);
4865 mask_img
[y
* row_width
+ x
/ 8] |= 1 << (x
% 8);
4868 /* Create the mask image. */
4869 img
->mask
= w32_create_pixmap_from_bitmap_data (img
->width
, img
->height
,
4871 /* Fill in the background_transparent field while we have the mask handy. */
4872 SelectObject (ximg
, img
->mask
);
4873 image_background_transparent (img
, f
, ximg
);
4875 /* Was: x_destroy_x_image ((XImagePtr )mask_img); which seems bogus ++kfs */
4877 #endif /* HAVE_NTGUI */
4879 Destroy_Image (ximg
, prev
);
4885 /***********************************************************************
4886 PBM (mono, gray, color)
4887 ***********************************************************************/
4889 static int pbm_image_p (Lisp_Object object
);
4890 static int pbm_load (struct frame
*f
, struct image
*img
);
4891 static int pbm_scan_number (unsigned char **, unsigned char *);
4893 /* The symbol `pbm' identifying images of this type. */
4895 static Lisp_Object Qpbm
;
4897 /* Indices of image specification fields in gs_format, below. */
4899 enum pbm_keyword_index
4915 /* Vector of image_keyword structures describing the format
4916 of valid user-defined image specifications. */
4918 static const struct image_keyword pbm_format
[PBM_LAST
] =
4920 {":type", IMAGE_SYMBOL_VALUE
, 1},
4921 {":file", IMAGE_STRING_VALUE
, 0},
4922 {":data", IMAGE_STRING_VALUE
, 0},
4923 {":ascent", IMAGE_ASCENT_VALUE
, 0},
4924 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
4925 {":relief", IMAGE_INTEGER_VALUE
, 0},
4926 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
4927 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
4928 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
4929 {":foreground", IMAGE_STRING_OR_NIL_VALUE
, 0},
4930 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
4933 /* Structure describing the image type `pbm'. */
4935 static struct image_type pbm_type
=
4945 /* Return non-zero if OBJECT is a valid PBM image specification. */
4948 pbm_image_p (Lisp_Object object
)
4950 struct image_keyword fmt
[PBM_LAST
];
4952 memcpy (fmt
, pbm_format
, sizeof fmt
);
4954 if (!parse_image_spec (object
, fmt
, PBM_LAST
, Qpbm
))
4957 /* Must specify either :data or :file. */
4958 return fmt
[PBM_DATA
].count
+ fmt
[PBM_FILE
].count
== 1;
4962 /* Scan a decimal number from *S and return it. Advance *S while
4963 reading the number. END is the end of the string. Value is -1 at
4967 pbm_scan_number (unsigned char **s
, unsigned char *end
)
4969 int c
= 0, val
= -1;
4973 /* Skip white-space. */
4974 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
4979 /* Skip comment to end of line. */
4980 while (*s
< end
&& (c
= *(*s
)++, c
!= '\n'))
4983 else if (isdigit (c
))
4985 /* Read decimal number. */
4987 while (*s
< end
&& (c
= *(*s
)++, isdigit (c
)))
4988 val
= 10 * val
+ c
- '0';
5000 #if 0 /* Unused. ++kfs */
5002 /* Read FILE into memory. Value is a pointer to a buffer allocated
5003 with xmalloc holding FILE's contents. Value is null if an error
5004 occurred. *SIZE is set to the size of the file. */
5007 pbm_read_file (file
, size
)
5015 if (stat (SDATA (file
), &st
) == 0
5016 && (fp
= fopen (SDATA (file
), "rb")) != NULL
5017 && 0 <= st
.st_size
&& st
.st_size
<= min (PTRDIFF_MAX
, SIZE_MAX
)
5018 && (buf
= (char *) xmalloc (st
.st_size
),
5019 fread (buf
, 1, st
.st_size
, fp
) == st
.st_size
))
5038 #endif /* HAVE_NTGUI */
5040 /* Load PBM image IMG for use on frame F. */
5043 pbm_load (struct frame
*f
, struct image
*img
)
5046 int width
, height
, max_color_idx
= 0;
5048 Lisp_Object file
, specified_file
;
5049 enum {PBM_MONO
, PBM_GRAY
, PBM_COLOR
} type
;
5050 unsigned char *contents
= NULL
;
5051 unsigned char *end
, *p
;
5054 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
5056 if (STRINGP (specified_file
))
5058 file
= x_find_image_file (specified_file
);
5059 if (!STRINGP (file
))
5061 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
5065 contents
= slurp_file (SSDATA (file
), &size
);
5066 if (contents
== NULL
)
5068 image_error ("Error reading `%s'", file
, Qnil
);
5073 end
= contents
+ size
;
5078 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
5079 if (!STRINGP (data
))
5081 image_error ("Invalid image data `%s'", data
, Qnil
);
5085 end
= p
+ SBYTES (data
);
5088 /* Check magic number. */
5089 if (end
- p
< 2 || *p
++ != 'P')
5091 image_error ("Not a PBM image: `%s'", img
->spec
, Qnil
);
5100 raw_p
= 0, type
= PBM_MONO
;
5104 raw_p
= 0, type
= PBM_GRAY
;
5108 raw_p
= 0, type
= PBM_COLOR
;
5112 raw_p
= 1, type
= PBM_MONO
;
5116 raw_p
= 1, type
= PBM_GRAY
;
5120 raw_p
= 1, type
= PBM_COLOR
;
5124 image_error ("Not a PBM image: `%s'", img
->spec
, Qnil
);
5128 /* Read width, height, maximum color-component. Characters
5129 starting with `#' up to the end of a line are ignored. */
5130 width
= pbm_scan_number (&p
, end
);
5131 height
= pbm_scan_number (&p
, end
);
5133 if (type
!= PBM_MONO
)
5135 max_color_idx
= pbm_scan_number (&p
, end
);
5136 if (max_color_idx
> 65535 || max_color_idx
< 0)
5138 image_error ("Unsupported maximum PBM color value", Qnil
, Qnil
);
5143 if (!check_image_size (f
, width
, height
))
5145 image_error ("Invalid image size (see `max-image-size')", Qnil
, Qnil
);
5149 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0,
5150 &ximg
, &img
->pixmap
))
5153 /* Initialize the color hash table. */
5154 init_color_table ();
5156 if (type
== PBM_MONO
)
5159 struct image_keyword fmt
[PBM_LAST
];
5160 unsigned long fg
= FRAME_FOREGROUND_PIXEL (f
);
5161 unsigned long bg
= FRAME_BACKGROUND_PIXEL (f
);
5163 /* Parse the image specification. */
5164 memcpy (fmt
, pbm_format
, sizeof fmt
);
5165 parse_image_spec (img
->spec
, fmt
, PBM_LAST
, Qpbm
);
5167 /* Get foreground and background colors, maybe allocate colors. */
5168 if (fmt
[PBM_FOREGROUND
].count
5169 && STRINGP (fmt
[PBM_FOREGROUND
].value
))
5170 fg
= x_alloc_image_color (f
, img
, fmt
[PBM_FOREGROUND
].value
, fg
);
5171 if (fmt
[PBM_BACKGROUND
].count
5172 && STRINGP (fmt
[PBM_BACKGROUND
].value
))
5174 bg
= x_alloc_image_color (f
, img
, fmt
[PBM_BACKGROUND
].value
, bg
);
5175 img
->background
= bg
;
5176 img
->background_valid
= 1;
5179 for (y
= 0; y
< height
; ++y
)
5180 for (x
= 0; x
< width
; ++x
)
5188 x_destroy_x_image (ximg
);
5189 x_clear_image (f
, img
);
5190 image_error ("Invalid image size in image `%s'",
5200 g
= pbm_scan_number (&p
, end
);
5202 XPutPixel (ximg
, x
, y
, g
? fg
: bg
);
5207 int expected_size
= height
* width
;
5208 if (max_color_idx
> 255)
5210 if (type
== PBM_COLOR
)
5213 if (raw_p
&& p
+ expected_size
> end
)
5215 x_destroy_x_image (ximg
);
5216 x_clear_image (f
, img
);
5217 image_error ("Invalid image size in image `%s'",
5222 for (y
= 0; y
< height
; ++y
)
5223 for (x
= 0; x
< width
; ++x
)
5227 if (type
== PBM_GRAY
&& raw_p
)
5230 if (max_color_idx
> 255)
5231 r
= g
= b
= r
* 256 + *p
++;
5233 else if (type
== PBM_GRAY
)
5234 r
= g
= b
= pbm_scan_number (&p
, end
);
5238 if (max_color_idx
> 255)
5241 if (max_color_idx
> 255)
5244 if (max_color_idx
> 255)
5249 r
= pbm_scan_number (&p
, end
);
5250 g
= pbm_scan_number (&p
, end
);
5251 b
= pbm_scan_number (&p
, end
);
5254 if (r
< 0 || g
< 0 || b
< 0)
5256 x_destroy_x_image (ximg
);
5257 image_error ("Invalid pixel value in image `%s'",
5262 /* RGB values are now in the range 0..max_color_idx.
5263 Scale this to the range 0..0xffff supported by X. */
5264 r
= (double) r
* 65535 / max_color_idx
;
5265 g
= (double) g
* 65535 / max_color_idx
;
5266 b
= (double) b
* 65535 / max_color_idx
;
5267 XPutPixel (ximg
, x
, y
, lookup_rgb_color (f
, r
, g
, b
));
5271 #ifdef COLOR_TABLE_SUPPORT
5272 /* Store in IMG->colors the colors allocated for the image, and
5273 free the color table. */
5274 img
->colors
= colors_in_color_table (&img
->ncolors
);
5275 free_color_table ();
5276 #endif /* COLOR_TABLE_SUPPORT */
5279 img
->height
= height
;
5281 /* Maybe fill in the background field while we have ximg handy. */
5283 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
5284 /* Casting avoids a GCC warning. */
5285 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
5287 /* Put the image into a pixmap. */
5288 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
5289 x_destroy_x_image (ximg
);
5291 /* X and W32 versions did it here, MAC version above. ++kfs
5293 img->height = height; */
5300 /***********************************************************************
5302 ***********************************************************************/
5304 #if defined (HAVE_PNG) || defined (HAVE_NS)
5306 /* Function prototypes. */
5308 static int png_image_p (Lisp_Object object
);
5309 static int png_load (struct frame
*f
, struct image
*img
);
5311 /* The symbol `png' identifying images of this type. */
5313 static Lisp_Object Qpng
;
5315 /* Indices of image specification fields in png_format, below. */
5317 enum png_keyword_index
5332 /* Vector of image_keyword structures describing the format
5333 of valid user-defined image specifications. */
5335 static const struct image_keyword png_format
[PNG_LAST
] =
5337 {":type", IMAGE_SYMBOL_VALUE
, 1},
5338 {":data", IMAGE_STRING_VALUE
, 0},
5339 {":file", IMAGE_STRING_VALUE
, 0},
5340 {":ascent", IMAGE_ASCENT_VALUE
, 0},
5341 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
5342 {":relief", IMAGE_INTEGER_VALUE
, 0},
5343 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5344 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5345 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5346 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
5349 /* Structure describing the image type `png'. */
5351 static struct image_type png_type
=
5360 /* Return non-zero if OBJECT is a valid PNG image specification. */
5363 png_image_p (Lisp_Object object
)
5365 struct image_keyword fmt
[PNG_LAST
];
5366 memcpy (fmt
, png_format
, sizeof fmt
);
5368 if (!parse_image_spec (object
, fmt
, PNG_LAST
, Qpng
))
5371 /* Must specify either the :data or :file keyword. */
5372 return fmt
[PNG_FILE
].count
+ fmt
[PNG_DATA
].count
== 1;
5375 #endif /* HAVE_PNG || HAVE_NS */
5381 /* PNG library details. */
5383 DEF_IMGLIB_FN (png_voidp
, png_get_io_ptr
, (png_structp
));
5384 DEF_IMGLIB_FN (int, png_sig_cmp
, (png_bytep
, png_size_t
, png_size_t
));
5385 DEF_IMGLIB_FN (png_structp
, png_create_read_struct
, (png_const_charp
, png_voidp
,
5386 png_error_ptr
, png_error_ptr
));
5387 DEF_IMGLIB_FN (png_infop
, png_create_info_struct
, (png_structp
));
5388 DEF_IMGLIB_FN (void, png_destroy_read_struct
, (png_structpp
, png_infopp
, png_infopp
));
5389 DEF_IMGLIB_FN (void, png_set_read_fn
, (png_structp
, png_voidp
, png_rw_ptr
));
5390 DEF_IMGLIB_FN (void, png_set_sig_bytes
, (png_structp
, int));
5391 DEF_IMGLIB_FN (void, png_read_info
, (png_structp
, png_infop
));
5392 DEF_IMGLIB_FN (png_uint_32
, png_get_IHDR
, (png_structp
, png_infop
,
5393 png_uint_32
*, png_uint_32
*,
5394 int *, int *, int *, int *, int *));
5395 DEF_IMGLIB_FN (png_uint_32
, png_get_valid
, (png_structp
, png_infop
, png_uint_32
));
5396 DEF_IMGLIB_FN (void, png_set_strip_16
, (png_structp
));
5397 DEF_IMGLIB_FN (void, png_set_expand
, (png_structp
));
5398 DEF_IMGLIB_FN (void, png_set_gray_to_rgb
, (png_structp
));
5399 DEF_IMGLIB_FN (void, png_set_background
, (png_structp
, png_color_16p
,
5401 DEF_IMGLIB_FN (png_uint_32
, png_get_bKGD
, (png_structp
, png_infop
, png_color_16p
*));
5402 DEF_IMGLIB_FN (void, png_read_update_info
, (png_structp
, png_infop
));
5403 DEF_IMGLIB_FN (png_byte
, png_get_channels
, (png_structp
, png_infop
));
5404 DEF_IMGLIB_FN (png_size_t
, png_get_rowbytes
, (png_structp
, png_infop
));
5405 DEF_IMGLIB_FN (void, png_read_image
, (png_structp
, png_bytepp
));
5406 DEF_IMGLIB_FN (void, png_read_end
, (png_structp
, png_infop
));
5407 DEF_IMGLIB_FN (void, png_error
, (png_structp
, png_const_charp
));
5409 #if (PNG_LIBPNG_VER >= 10500)
5410 DEF_IMGLIB_FN (void, png_longjmp
, (png_structp
, int));
5411 DEF_IMGLIB_FN (jmp_buf *, png_set_longjmp_fn
, (png_structp
, png_longjmp_ptr
, size_t));
5412 #endif /* libpng version >= 1.5 */
5415 init_png_functions (Lisp_Object libraries
)
5419 if (!(library
= w32_delayed_load (libraries
, Qpng
)))
5422 LOAD_IMGLIB_FN (library
, png_get_io_ptr
);
5423 LOAD_IMGLIB_FN (library
, png_sig_cmp
);
5424 LOAD_IMGLIB_FN (library
, png_create_read_struct
);
5425 LOAD_IMGLIB_FN (library
, png_create_info_struct
);
5426 LOAD_IMGLIB_FN (library
, png_destroy_read_struct
);
5427 LOAD_IMGLIB_FN (library
, png_set_read_fn
);
5428 LOAD_IMGLIB_FN (library
, png_set_sig_bytes
);
5429 LOAD_IMGLIB_FN (library
, png_read_info
);
5430 LOAD_IMGLIB_FN (library
, png_get_IHDR
);
5431 LOAD_IMGLIB_FN (library
, png_get_valid
);
5432 LOAD_IMGLIB_FN (library
, png_set_strip_16
);
5433 LOAD_IMGLIB_FN (library
, png_set_expand
);
5434 LOAD_IMGLIB_FN (library
, png_set_gray_to_rgb
);
5435 LOAD_IMGLIB_FN (library
, png_set_background
);
5436 LOAD_IMGLIB_FN (library
, png_get_bKGD
);
5437 LOAD_IMGLIB_FN (library
, png_read_update_info
);
5438 LOAD_IMGLIB_FN (library
, png_get_channels
);
5439 LOAD_IMGLIB_FN (library
, png_get_rowbytes
);
5440 LOAD_IMGLIB_FN (library
, png_read_image
);
5441 LOAD_IMGLIB_FN (library
, png_read_end
);
5442 LOAD_IMGLIB_FN (library
, png_error
);
5444 #if (PNG_LIBPNG_VER >= 10500)
5445 LOAD_IMGLIB_FN (library
, png_longjmp
);
5446 LOAD_IMGLIB_FN (library
, png_set_longjmp_fn
);
5447 #endif /* libpng version >= 1.5 */
5453 #define fn_png_get_io_ptr png_get_io_ptr
5454 #define fn_png_sig_cmp png_sig_cmp
5455 #define fn_png_create_read_struct png_create_read_struct
5456 #define fn_png_create_info_struct png_create_info_struct
5457 #define fn_png_destroy_read_struct png_destroy_read_struct
5458 #define fn_png_set_read_fn png_set_read_fn
5459 #define fn_png_set_sig_bytes png_set_sig_bytes
5460 #define fn_png_read_info png_read_info
5461 #define fn_png_get_IHDR png_get_IHDR
5462 #define fn_png_get_valid png_get_valid
5463 #define fn_png_set_strip_16 png_set_strip_16
5464 #define fn_png_set_expand png_set_expand
5465 #define fn_png_set_gray_to_rgb png_set_gray_to_rgb
5466 #define fn_png_set_background png_set_background
5467 #define fn_png_get_bKGD png_get_bKGD
5468 #define fn_png_read_update_info png_read_update_info
5469 #define fn_png_get_channels png_get_channels
5470 #define fn_png_get_rowbytes png_get_rowbytes
5471 #define fn_png_read_image png_read_image
5472 #define fn_png_read_end png_read_end
5473 #define fn_png_error png_error
5475 #if (PNG_LIBPNG_VER >= 10500)
5476 #define fn_png_longjmp png_longjmp
5477 #define fn_png_set_longjmp_fn png_set_longjmp_fn
5478 #endif /* libpng version >= 1.5 */
5480 #endif /* HAVE_NTGUI */
5483 #if (PNG_LIBPNG_VER < 10500)
5484 #define PNG_LONGJMP(ptr) (longjmp ((ptr)->jmpbuf, 1))
5485 #define PNG_JMPBUF(ptr) ((ptr)->jmpbuf)
5487 /* In libpng version 1.5, the jmpbuf member is hidden. (Bug#7908) */
5488 #define PNG_LONGJMP(ptr) (fn_png_longjmp ((ptr), 1))
5489 #define PNG_JMPBUF(ptr) \
5490 (*fn_png_set_longjmp_fn((ptr), longjmp, sizeof (jmp_buf)))
5493 /* Error and warning handlers installed when the PNG library
5496 static void my_png_error (png_struct
*, const char *) NO_RETURN
;
5498 my_png_error (png_struct
*png_ptr
, const char *msg
)
5500 xassert (png_ptr
!= NULL
);
5501 /* Avoid compiler warning about deprecated direct access to
5502 png_ptr's fields in libpng versions 1.4.x. */
5503 image_error ("PNG error: %s", build_string (msg
), Qnil
);
5504 PNG_LONGJMP (png_ptr
);
5509 my_png_warning (png_struct
*png_ptr
, const char *msg
)
5511 xassert (png_ptr
!= NULL
);
5512 image_error ("PNG warning: %s", build_string (msg
), Qnil
);
5515 /* Memory source for PNG decoding. */
5517 struct png_memory_storage
5519 unsigned char *bytes
; /* The data */
5520 size_t len
; /* How big is it? */
5521 int index
; /* Where are we? */
5525 /* Function set as reader function when reading PNG image from memory.
5526 PNG_PTR is a pointer to the PNG control structure. Copy LENGTH
5527 bytes from the input to DATA. */
5530 png_read_from_memory (png_structp png_ptr
, png_bytep data
, png_size_t length
)
5532 struct png_memory_storage
*tbr
5533 = (struct png_memory_storage
*) fn_png_get_io_ptr (png_ptr
);
5535 if (length
> tbr
->len
- tbr
->index
)
5536 fn_png_error (png_ptr
, "Read error");
5538 memcpy (data
, tbr
->bytes
+ tbr
->index
, length
);
5539 tbr
->index
= tbr
->index
+ length
;
5543 /* Function set as reader function when reading PNG image from a file.
5544 PNG_PTR is a pointer to the PNG control structure. Copy LENGTH
5545 bytes from the input to DATA. */
5548 png_read_from_file (png_structp png_ptr
, png_bytep data
, png_size_t length
)
5550 FILE *fp
= (FILE *) fn_png_get_io_ptr (png_ptr
);
5552 if (fread (data
, 1, length
, fp
) < length
)
5553 fn_png_error (png_ptr
, "Read error");
5557 /* Load PNG image IMG for use on frame F. Value is non-zero if
5561 png_load (struct frame
*f
, struct image
*img
)
5563 Lisp_Object file
, specified_file
;
5564 Lisp_Object specified_data
;
5566 XImagePtr ximg
, mask_img
= NULL
;
5567 png_struct
*png_ptr
= NULL
;
5568 png_info
*info_ptr
= NULL
, *end_info
= NULL
;
5569 FILE *volatile fp
= NULL
;
5571 png_byte
* volatile pixels
= NULL
;
5572 png_byte
** volatile rows
= NULL
;
5573 png_uint_32 width
, height
;
5574 int bit_depth
, color_type
, interlace_type
;
5576 png_uint_32 row_bytes
;
5578 struct png_memory_storage tbr
; /* Data to be read */
5580 /* Find out what file to load. */
5581 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
5582 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
5584 if (NILP (specified_data
))
5586 file
= x_find_image_file (specified_file
);
5587 if (!STRINGP (file
))
5589 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
5593 /* Open the image file. */
5594 fp
= fopen (SSDATA (file
), "rb");
5597 image_error ("Cannot open image file `%s'", file
, Qnil
);
5601 /* Check PNG signature. */
5602 if (fread (sig
, 1, sizeof sig
, fp
) != sizeof sig
5603 || fn_png_sig_cmp (sig
, 0, sizeof sig
))
5605 image_error ("Not a PNG file: `%s'", file
, Qnil
);
5612 if (!STRINGP (specified_data
))
5614 image_error ("Invalid image data `%s'", specified_data
, Qnil
);
5618 /* Read from memory. */
5619 tbr
.bytes
= SDATA (specified_data
);
5620 tbr
.len
= SBYTES (specified_data
);
5623 /* Check PNG signature. */
5624 if (tbr
.len
< sizeof sig
5625 || fn_png_sig_cmp (tbr
.bytes
, 0, sizeof sig
))
5627 image_error ("Not a PNG image: `%s'", img
->spec
, Qnil
);
5631 /* Need to skip past the signature. */
5632 tbr
.bytes
+= sizeof (sig
);
5635 /* Initialize read and info structs for PNG lib. */
5636 png_ptr
= fn_png_create_read_struct (PNG_LIBPNG_VER_STRING
,
5641 if (fp
) fclose (fp
);
5645 info_ptr
= fn_png_create_info_struct (png_ptr
);
5648 fn_png_destroy_read_struct (&png_ptr
, NULL
, NULL
);
5649 if (fp
) fclose (fp
);
5653 end_info
= fn_png_create_info_struct (png_ptr
);
5656 fn_png_destroy_read_struct (&png_ptr
, &info_ptr
, NULL
);
5657 if (fp
) fclose (fp
);
5661 /* Set error jump-back. We come back here when the PNG library
5662 detects an error. */
5663 if (setjmp (PNG_JMPBUF (png_ptr
)))
5667 fn_png_destroy_read_struct (&png_ptr
, &info_ptr
, &end_info
);
5670 if (fp
) fclose (fp
);
5674 /* Read image info. */
5675 if (!NILP (specified_data
))
5676 fn_png_set_read_fn (png_ptr
, (void *) &tbr
, png_read_from_memory
);
5678 fn_png_set_read_fn (png_ptr
, (void *) fp
, png_read_from_file
);
5680 fn_png_set_sig_bytes (png_ptr
, sizeof sig
);
5681 fn_png_read_info (png_ptr
, info_ptr
);
5682 fn_png_get_IHDR (png_ptr
, info_ptr
, &width
, &height
, &bit_depth
, &color_type
,
5683 &interlace_type
, NULL
, NULL
);
5685 if (!check_image_size (f
, width
, height
))
5687 image_error ("Invalid image size (see `max-image-size')", Qnil
, Qnil
);
5690 /* If image contains simply transparency data, we prefer to
5691 construct a clipping mask. */
5692 if (fn_png_get_valid (png_ptr
, info_ptr
, PNG_INFO_tRNS
))
5697 /* This function is easier to write if we only have to handle
5698 one data format: RGB or RGBA with 8 bits per channel. Let's
5699 transform other formats into that format. */
5701 /* Strip more than 8 bits per channel. */
5702 if (bit_depth
== 16)
5703 fn_png_set_strip_16 (png_ptr
);
5705 /* Expand data to 24 bit RGB, or 8 bit grayscale, with alpha channel
5707 fn_png_set_expand (png_ptr
);
5709 /* Convert grayscale images to RGB. */
5710 if (color_type
== PNG_COLOR_TYPE_GRAY
5711 || color_type
== PNG_COLOR_TYPE_GRAY_ALPHA
)
5712 fn_png_set_gray_to_rgb (png_ptr
);
5714 /* Handle alpha channel by combining the image with a background
5715 color. Do this only if a real alpha channel is supplied. For
5716 simple transparency, we prefer a clipping mask. */
5719 /* png_color_16 *image_bg; */
5720 Lisp_Object specified_bg
5721 = image_spec_value (img
->spec
, QCbackground
, NULL
);
5722 int shift
= (bit_depth
== 16) ? 0 : 8;
5724 if (STRINGP (specified_bg
))
5725 /* The user specified `:background', use that. */
5728 if (x_defined_color (f
, SSDATA (specified_bg
), &color
, 0))
5730 png_color_16 user_bg
;
5732 memset (&user_bg
, 0, sizeof user_bg
);
5733 user_bg
.red
= color
.red
>> shift
;
5734 user_bg
.green
= color
.green
>> shift
;
5735 user_bg
.blue
= color
.blue
>> shift
;
5737 fn_png_set_background (png_ptr
, &user_bg
,
5738 PNG_BACKGROUND_GAMMA_SCREEN
, 0, 1.0);
5743 /* We use the current frame background, ignoring any default
5744 background color set by the image. */
5745 #if defined (HAVE_X_WINDOWS) || defined (HAVE_NTGUI)
5747 png_color_16 frame_background
;
5749 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
5750 x_query_color (f
, &color
);
5752 memset (&frame_background
, 0, sizeof frame_background
);
5753 frame_background
.red
= color
.red
>> shift
;
5754 frame_background
.green
= color
.green
>> shift
;
5755 frame_background
.blue
= color
.blue
>> shift
;
5756 #endif /* HAVE_X_WINDOWS */
5758 fn_png_set_background (png_ptr
, &frame_background
,
5759 PNG_BACKGROUND_GAMMA_SCREEN
, 0, 1.0);
5763 /* Update info structure. */
5764 fn_png_read_update_info (png_ptr
, info_ptr
);
5766 /* Get number of channels. Valid values are 1 for grayscale images
5767 and images with a palette, 2 for grayscale images with transparency
5768 information (alpha channel), 3 for RGB images, and 4 for RGB
5769 images with alpha channel, i.e. RGBA. If conversions above were
5770 sufficient we should only have 3 or 4 channels here. */
5771 channels
= fn_png_get_channels (png_ptr
, info_ptr
);
5772 xassert (channels
== 3 || channels
== 4);
5774 /* Number of bytes needed for one row of the image. */
5775 row_bytes
= fn_png_get_rowbytes (png_ptr
, info_ptr
);
5777 /* Allocate memory for the image. */
5778 pixels
= (png_byte
*) xmalloc (row_bytes
* height
* sizeof *pixels
);
5779 rows
= (png_byte
**) xmalloc (height
* sizeof *rows
);
5780 for (i
= 0; i
< height
; ++i
)
5781 rows
[i
] = pixels
+ i
* row_bytes
;
5783 /* Read the entire image. */
5784 fn_png_read_image (png_ptr
, rows
);
5785 fn_png_read_end (png_ptr
, info_ptr
);
5792 /* Create the X image and pixmap. */
5793 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
,
5797 /* Create an image and pixmap serving as mask if the PNG image
5798 contains an alpha channel. */
5801 && !x_create_x_image_and_pixmap (f
, width
, height
, 1,
5802 &mask_img
, &img
->mask
))
5804 x_destroy_x_image (ximg
);
5805 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->pixmap
);
5806 img
->pixmap
= NO_PIXMAP
;
5810 /* Fill the X image and mask from PNG data. */
5811 init_color_table ();
5813 for (y
= 0; y
< height
; ++y
)
5815 png_byte
*p
= rows
[y
];
5817 for (x
= 0; x
< width
; ++x
)
5824 XPutPixel (ximg
, x
, y
, lookup_rgb_color (f
, r
, g
, b
));
5825 /* An alpha channel, aka mask channel, associates variable
5826 transparency with an image. Where other image formats
5827 support binary transparency---fully transparent or fully
5828 opaque---PNG allows up to 254 levels of partial transparency.
5829 The PNG library implements partial transparency by combining
5830 the image with a specified background color.
5832 I'm not sure how to handle this here nicely: because the
5833 background on which the image is displayed may change, for
5834 real alpha channel support, it would be necessary to create
5835 a new image for each possible background.
5837 What I'm doing now is that a mask is created if we have
5838 boolean transparency information. Otherwise I'm using
5839 the frame's background color to combine the image with. */
5844 XPutPixel (mask_img
, x
, y
, *p
> 0 ? PIX_MASK_DRAW
: PIX_MASK_RETAIN
);
5850 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
5851 /* Set IMG's background color from the PNG image, unless the user
5855 if (fn_png_get_bKGD (png_ptr
, info_ptr
, &bg
))
5857 img
->background
= lookup_rgb_color (f
, bg
->red
, bg
->green
, bg
->blue
);
5858 img
->background_valid
= 1;
5862 #ifdef COLOR_TABLE_SUPPORT
5863 /* Remember colors allocated for this image. */
5864 img
->colors
= colors_in_color_table (&img
->ncolors
);
5865 free_color_table ();
5866 #endif /* COLOR_TABLE_SUPPORT */
5869 fn_png_destroy_read_struct (&png_ptr
, &info_ptr
, &end_info
);
5874 img
->height
= height
;
5876 /* Maybe fill in the background field while we have ximg handy.
5877 Casting avoids a GCC warning. */
5878 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
5880 /* Put the image into the pixmap, then free the X image and its buffer. */
5881 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
5882 x_destroy_x_image (ximg
);
5884 /* Same for the mask. */
5887 /* Fill in the background_transparent field while we have the
5888 mask handy. Casting avoids a GCC warning. */
5889 image_background_transparent (img
, f
, (XImagePtr_or_DC
)mask_img
);
5891 x_put_x_image (f
, mask_img
, img
->mask
, img
->width
, img
->height
);
5892 x_destroy_x_image (mask_img
);
5898 #else /* HAVE_PNG */
5902 png_load (struct frame
*f
, struct image
*img
)
5904 return ns_load_image(f
, img
,
5905 image_spec_value (img
->spec
, QCfile
, NULL
),
5906 image_spec_value (img
->spec
, QCdata
, NULL
));
5908 #endif /* HAVE_NS */
5911 #endif /* !HAVE_PNG */
5915 /***********************************************************************
5917 ***********************************************************************/
5919 #if defined (HAVE_JPEG) || defined (HAVE_NS)
5921 static int jpeg_image_p (Lisp_Object object
);
5922 static int jpeg_load (struct frame
*f
, struct image
*img
);
5924 /* The symbol `jpeg' identifying images of this type. */
5926 static Lisp_Object Qjpeg
;
5928 /* Indices of image specification fields in gs_format, below. */
5930 enum jpeg_keyword_index
5939 JPEG_HEURISTIC_MASK
,
5945 /* Vector of image_keyword structures describing the format
5946 of valid user-defined image specifications. */
5948 static const struct image_keyword jpeg_format
[JPEG_LAST
] =
5950 {":type", IMAGE_SYMBOL_VALUE
, 1},
5951 {":data", IMAGE_STRING_VALUE
, 0},
5952 {":file", IMAGE_STRING_VALUE
, 0},
5953 {":ascent", IMAGE_ASCENT_VALUE
, 0},
5954 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
5955 {":relief", IMAGE_INTEGER_VALUE
, 0},
5956 {":conversions", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5957 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5958 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5959 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
5962 /* Structure describing the image type `jpeg'. */
5964 static struct image_type jpeg_type
=
5973 /* Return non-zero if OBJECT is a valid JPEG image specification. */
5976 jpeg_image_p (Lisp_Object object
)
5978 struct image_keyword fmt
[JPEG_LAST
];
5980 memcpy (fmt
, jpeg_format
, sizeof fmt
);
5982 if (!parse_image_spec (object
, fmt
, JPEG_LAST
, Qjpeg
))
5985 /* Must specify either the :data or :file keyword. */
5986 return fmt
[JPEG_FILE
].count
+ fmt
[JPEG_DATA
].count
== 1;
5989 #endif /* HAVE_JPEG || HAVE_NS */
5993 /* Work around a warning about HAVE_STDLIB_H being redefined in
5995 #ifdef HAVE_STDLIB_H
5996 #undef HAVE_STDLIB_H
5997 #endif /* HAVE_STLIB_H */
5999 #if defined (HAVE_NTGUI) && !defined (__WIN32__)
6000 /* In older releases of the jpeg library, jpeglib.h will define boolean
6001 differently depending on __WIN32__, so make sure it is defined. */
6005 #include <jpeglib.h>
6008 #ifdef HAVE_STLIB_H_1
6009 #define HAVE_STDLIB_H 1
6014 /* JPEG library details. */
6015 DEF_IMGLIB_FN (void, jpeg_CreateDecompress
, (j_decompress_ptr
, int, size_t));
6016 DEF_IMGLIB_FN (boolean
, jpeg_start_decompress
, (j_decompress_ptr
));
6017 DEF_IMGLIB_FN (boolean
, jpeg_finish_decompress
, (j_decompress_ptr
));
6018 DEF_IMGLIB_FN (void, jpeg_destroy_decompress
, (j_decompress_ptr
));
6019 DEF_IMGLIB_FN (int, jpeg_read_header
, (j_decompress_ptr
, boolean
));
6020 DEF_IMGLIB_FN (JDIMENSION
, jpeg_read_scanlines
, (j_decompress_ptr
, JSAMPARRAY
, JDIMENSION
));
6021 DEF_IMGLIB_FN (struct jpeg_error_mgr
*, jpeg_std_error
, (struct jpeg_error_mgr
*));
6022 DEF_IMGLIB_FN (boolean
, jpeg_resync_to_restart
, (j_decompress_ptr
, int));
6025 init_jpeg_functions (Lisp_Object libraries
)
6029 if (!(library
= w32_delayed_load (libraries
, Qjpeg
)))
6032 LOAD_IMGLIB_FN (library
, jpeg_finish_decompress
);
6033 LOAD_IMGLIB_FN (library
, jpeg_read_scanlines
);
6034 LOAD_IMGLIB_FN (library
, jpeg_start_decompress
);
6035 LOAD_IMGLIB_FN (library
, jpeg_read_header
);
6036 LOAD_IMGLIB_FN (library
, jpeg_CreateDecompress
);
6037 LOAD_IMGLIB_FN (library
, jpeg_destroy_decompress
);
6038 LOAD_IMGLIB_FN (library
, jpeg_std_error
);
6039 LOAD_IMGLIB_FN (library
, jpeg_resync_to_restart
);
6043 /* Wrapper since we can't directly assign the function pointer
6044 to another function pointer that was declared more completely easily. */
6046 jpeg_resync_to_restart_wrapper (j_decompress_ptr cinfo
, int desired
)
6048 return fn_jpeg_resync_to_restart (cinfo
, desired
);
6053 #define fn_jpeg_CreateDecompress(a,b,c) jpeg_create_decompress(a)
6054 #define fn_jpeg_start_decompress jpeg_start_decompress
6055 #define fn_jpeg_finish_decompress jpeg_finish_decompress
6056 #define fn_jpeg_destroy_decompress jpeg_destroy_decompress
6057 #define fn_jpeg_read_header jpeg_read_header
6058 #define fn_jpeg_read_scanlines jpeg_read_scanlines
6059 #define fn_jpeg_std_error jpeg_std_error
6060 #define jpeg_resync_to_restart_wrapper jpeg_resync_to_restart
6062 #endif /* HAVE_NTGUI */
6064 struct my_jpeg_error_mgr
6066 struct jpeg_error_mgr pub
;
6067 jmp_buf setjmp_buffer
;
6071 static void my_error_exit (j_common_ptr
) NO_RETURN
;
6073 my_error_exit (j_common_ptr cinfo
)
6075 struct my_jpeg_error_mgr
*mgr
= (struct my_jpeg_error_mgr
*) cinfo
->err
;
6076 longjmp (mgr
->setjmp_buffer
, 1);
6080 /* Init source method for JPEG data source manager. Called by
6081 jpeg_read_header() before any data is actually read. See
6082 libjpeg.doc from the JPEG lib distribution. */
6085 our_common_init_source (j_decompress_ptr cinfo
)
6090 /* Method to terminate data source. Called by
6091 jpeg_finish_decompress() after all data has been processed. */
6094 our_common_term_source (j_decompress_ptr cinfo
)
6099 /* Fill input buffer method for JPEG data source manager. Called
6100 whenever more data is needed. We read the whole image in one step,
6101 so this only adds a fake end of input marker at the end. */
6103 static JOCTET our_memory_buffer
[2];
6106 our_memory_fill_input_buffer (j_decompress_ptr cinfo
)
6108 /* Insert a fake EOI marker. */
6109 struct jpeg_source_mgr
*src
= cinfo
->src
;
6111 our_memory_buffer
[0] = (JOCTET
) 0xFF;
6112 our_memory_buffer
[1] = (JOCTET
) JPEG_EOI
;
6114 src
->next_input_byte
= our_memory_buffer
;
6115 src
->bytes_in_buffer
= 2;
6120 /* Method to skip over NUM_BYTES bytes in the image data. CINFO->src
6121 is the JPEG data source manager. */
6124 our_memory_skip_input_data (j_decompress_ptr cinfo
, long int num_bytes
)
6126 struct jpeg_source_mgr
*src
= (struct jpeg_source_mgr
*) cinfo
->src
;
6130 if (num_bytes
> src
->bytes_in_buffer
)
6131 ERREXIT (cinfo
, JERR_INPUT_EOF
);
6133 src
->bytes_in_buffer
-= num_bytes
;
6134 src
->next_input_byte
+= num_bytes
;
6139 /* Set up the JPEG lib for reading an image from DATA which contains
6140 LEN bytes. CINFO is the decompression info structure created for
6141 reading the image. */
6144 jpeg_memory_src (j_decompress_ptr cinfo
, JOCTET
*data
, unsigned int len
)
6146 struct jpeg_source_mgr
*src
;
6148 if (cinfo
->src
== NULL
)
6150 /* First time for this JPEG object? */
6151 cinfo
->src
= (struct jpeg_source_mgr
*)
6152 (*cinfo
->mem
->alloc_small
) ((j_common_ptr
) cinfo
, JPOOL_PERMANENT
,
6153 sizeof (struct jpeg_source_mgr
));
6154 src
= (struct jpeg_source_mgr
*) cinfo
->src
;
6155 src
->next_input_byte
= data
;
6158 src
= (struct jpeg_source_mgr
*) cinfo
->src
;
6159 src
->init_source
= our_common_init_source
;
6160 src
->fill_input_buffer
= our_memory_fill_input_buffer
;
6161 src
->skip_input_data
= our_memory_skip_input_data
;
6162 src
->resync_to_restart
= jpeg_resync_to_restart_wrapper
; /* Use default method. */
6163 src
->term_source
= our_common_term_source
;
6164 src
->bytes_in_buffer
= len
;
6165 src
->next_input_byte
= data
;
6169 struct jpeg_stdio_mgr
6171 struct jpeg_source_mgr mgr
;
6178 /* Size of buffer to read JPEG from file.
6179 Not too big, as we want to use alloc_small. */
6180 #define JPEG_STDIO_BUFFER_SIZE 8192
6183 /* Fill input buffer method for JPEG data source manager. Called
6184 whenever more data is needed. The data is read from a FILE *. */
6187 our_stdio_fill_input_buffer (j_decompress_ptr cinfo
)
6189 struct jpeg_stdio_mgr
*src
;
6191 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6196 bytes
= fread (src
->buffer
, 1, JPEG_STDIO_BUFFER_SIZE
, src
->file
);
6198 src
->mgr
.bytes_in_buffer
= bytes
;
6201 WARNMS (cinfo
, JWRN_JPEG_EOF
);
6203 src
->buffer
[0] = (JOCTET
) 0xFF;
6204 src
->buffer
[1] = (JOCTET
) JPEG_EOI
;
6205 src
->mgr
.bytes_in_buffer
= 2;
6207 src
->mgr
.next_input_byte
= src
->buffer
;
6214 /* Method to skip over NUM_BYTES bytes in the image data. CINFO->src
6215 is the JPEG data source manager. */
6218 our_stdio_skip_input_data (j_decompress_ptr cinfo
, long int num_bytes
)
6220 struct jpeg_stdio_mgr
*src
;
6221 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6223 while (num_bytes
> 0 && !src
->finished
)
6225 if (num_bytes
<= src
->mgr
.bytes_in_buffer
)
6227 src
->mgr
.bytes_in_buffer
-= num_bytes
;
6228 src
->mgr
.next_input_byte
+= num_bytes
;
6233 num_bytes
-= src
->mgr
.bytes_in_buffer
;
6234 src
->mgr
.bytes_in_buffer
= 0;
6235 src
->mgr
.next_input_byte
= NULL
;
6237 our_stdio_fill_input_buffer (cinfo
);
6243 /* Set up the JPEG lib for reading an image from a FILE *.
6244 CINFO is the decompression info structure created for
6245 reading the image. */
6248 jpeg_file_src (j_decompress_ptr cinfo
, FILE *fp
)
6250 struct jpeg_stdio_mgr
*src
;
6252 if (cinfo
->src
!= NULL
)
6253 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6256 /* First time for this JPEG object? */
6257 cinfo
->src
= (struct jpeg_source_mgr
*)
6258 (*cinfo
->mem
->alloc_small
) ((j_common_ptr
) cinfo
, JPOOL_PERMANENT
,
6259 sizeof (struct jpeg_stdio_mgr
));
6260 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6261 src
->buffer
= (JOCTET
*)
6262 (*cinfo
->mem
->alloc_small
) ((j_common_ptr
) cinfo
, JPOOL_PERMANENT
,
6263 JPEG_STDIO_BUFFER_SIZE
);
6268 src
->mgr
.init_source
= our_common_init_source
;
6269 src
->mgr
.fill_input_buffer
= our_stdio_fill_input_buffer
;
6270 src
->mgr
.skip_input_data
= our_stdio_skip_input_data
;
6271 src
->mgr
.resync_to_restart
= jpeg_resync_to_restart_wrapper
; /* Use default method. */
6272 src
->mgr
.term_source
= our_common_term_source
;
6273 src
->mgr
.bytes_in_buffer
= 0;
6274 src
->mgr
.next_input_byte
= NULL
;
6278 /* Load image IMG for use on frame F. Patterned after example.c
6279 from the JPEG lib. */
6282 jpeg_load (struct frame
*f
, struct image
*img
)
6284 struct jpeg_decompress_struct cinfo
;
6285 struct my_jpeg_error_mgr mgr
;
6286 Lisp_Object file
, specified_file
;
6287 Lisp_Object specified_data
;
6288 FILE * volatile fp
= NULL
;
6290 int row_stride
, x
, y
;
6291 XImagePtr ximg
= NULL
;
6293 unsigned long *colors
;
6296 /* Open the JPEG file. */
6297 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
6298 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
6300 if (NILP (specified_data
))
6302 file
= x_find_image_file (specified_file
);
6303 if (!STRINGP (file
))
6305 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
6309 fp
= fopen (SSDATA (file
), "rb");
6312 image_error ("Cannot open `%s'", file
, Qnil
);
6316 else if (!STRINGP (specified_data
))
6318 image_error ("Invalid image data `%s'", specified_data
, Qnil
);
6322 /* Customize libjpeg's error handling to call my_error_exit when an
6323 error is detected. This function will perform a longjmp. */
6324 cinfo
.err
= fn_jpeg_std_error (&mgr
.pub
);
6325 mgr
.pub
.error_exit
= my_error_exit
;
6327 if ((rc
= setjmp (mgr
.setjmp_buffer
)) != 0)
6331 /* Called from my_error_exit. Display a JPEG error. */
6332 char buf
[JMSG_LENGTH_MAX
];
6333 cinfo
.err
->format_message ((j_common_ptr
) &cinfo
, buf
);
6334 image_error ("Error reading JPEG image `%s': %s", img
->spec
,
6335 build_string (buf
));
6338 /* Close the input file and destroy the JPEG object. */
6340 fclose ((FILE *) fp
);
6341 fn_jpeg_destroy_decompress (&cinfo
);
6343 /* If we already have an XImage, free that. */
6344 x_destroy_x_image (ximg
);
6346 /* Free pixmap and colors. */
6347 x_clear_image (f
, img
);
6351 /* Create the JPEG decompression object. Let it read from fp.
6352 Read the JPEG image header. */
6353 fn_jpeg_CreateDecompress (&cinfo
, JPEG_LIB_VERSION
, sizeof (cinfo
));
6355 if (NILP (specified_data
))
6356 jpeg_file_src (&cinfo
, (FILE *) fp
);
6358 jpeg_memory_src (&cinfo
, SDATA (specified_data
),
6359 SBYTES (specified_data
));
6361 fn_jpeg_read_header (&cinfo
, 1);
6363 /* Customize decompression so that color quantization will be used.
6364 Start decompression. */
6365 cinfo
.quantize_colors
= 1;
6366 fn_jpeg_start_decompress (&cinfo
);
6367 width
= img
->width
= cinfo
.output_width
;
6368 height
= img
->height
= cinfo
.output_height
;
6370 if (!check_image_size (f
, width
, height
))
6372 image_error ("Invalid image size (see `max-image-size')", Qnil
, Qnil
);
6373 longjmp (mgr
.setjmp_buffer
, 2);
6376 /* Create X image and pixmap. */
6377 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
6378 longjmp (mgr
.setjmp_buffer
, 2);
6380 /* Allocate colors. When color quantization is used,
6381 cinfo.actual_number_of_colors has been set with the number of
6382 colors generated, and cinfo.colormap is a two-dimensional array
6383 of color indices in the range 0..cinfo.actual_number_of_colors.
6384 No more than 255 colors will be generated. */
6388 if (cinfo
.out_color_components
> 2)
6389 ir
= 0, ig
= 1, ib
= 2;
6390 else if (cinfo
.out_color_components
> 1)
6391 ir
= 0, ig
= 1, ib
= 0;
6393 ir
= 0, ig
= 0, ib
= 0;
6395 /* Use the color table mechanism because it handles colors that
6396 cannot be allocated nicely. Such colors will be replaced with
6397 a default color, and we don't have to care about which colors
6398 can be freed safely, and which can't. */
6399 init_color_table ();
6400 colors
= (unsigned long *) alloca (cinfo
.actual_number_of_colors
6403 for (i
= 0; i
< cinfo
.actual_number_of_colors
; ++i
)
6405 /* Multiply RGB values with 255 because X expects RGB values
6406 in the range 0..0xffff. */
6407 int r
= cinfo
.colormap
[ir
][i
] << 8;
6408 int g
= cinfo
.colormap
[ig
][i
] << 8;
6409 int b
= cinfo
.colormap
[ib
][i
] << 8;
6410 colors
[i
] = lookup_rgb_color (f
, r
, g
, b
);
6413 #ifdef COLOR_TABLE_SUPPORT
6414 /* Remember those colors actually allocated. */
6415 img
->colors
= colors_in_color_table (&img
->ncolors
);
6416 free_color_table ();
6417 #endif /* COLOR_TABLE_SUPPORT */
6421 row_stride
= width
* cinfo
.output_components
;
6422 buffer
= cinfo
.mem
->alloc_sarray ((j_common_ptr
) &cinfo
, JPOOL_IMAGE
,
6424 for (y
= 0; y
< height
; ++y
)
6426 fn_jpeg_read_scanlines (&cinfo
, buffer
, 1);
6427 for (x
= 0; x
< cinfo
.output_width
; ++x
)
6428 XPutPixel (ximg
, x
, y
, colors
[buffer
[0][x
]]);
6432 fn_jpeg_finish_decompress (&cinfo
);
6433 fn_jpeg_destroy_decompress (&cinfo
);
6435 fclose ((FILE *) fp
);
6437 /* Maybe fill in the background field while we have ximg handy. */
6438 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
6439 /* Casting avoids a GCC warning. */
6440 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
6442 /* Put the image into the pixmap. */
6443 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
6444 x_destroy_x_image (ximg
);
6448 #else /* HAVE_JPEG */
6452 jpeg_load (struct frame
*f
, struct image
*img
)
6454 return ns_load_image (f
, img
,
6455 image_spec_value (img
->spec
, QCfile
, NULL
),
6456 image_spec_value (img
->spec
, QCdata
, NULL
));
6458 #endif /* HAVE_NS */
6460 #endif /* !HAVE_JPEG */
6464 /***********************************************************************
6466 ***********************************************************************/
6468 #if defined (HAVE_TIFF) || defined (HAVE_NS)
6470 static int tiff_image_p (Lisp_Object object
);
6471 static int tiff_load (struct frame
*f
, struct image
*img
);
6473 /* The symbol `tiff' identifying images of this type. */
6475 static Lisp_Object Qtiff
;
6477 /* Indices of image specification fields in tiff_format, below. */
6479 enum tiff_keyword_index
6488 TIFF_HEURISTIC_MASK
,
6495 /* Vector of image_keyword structures describing the format
6496 of valid user-defined image specifications. */
6498 static const struct image_keyword tiff_format
[TIFF_LAST
] =
6500 {":type", IMAGE_SYMBOL_VALUE
, 1},
6501 {":data", IMAGE_STRING_VALUE
, 0},
6502 {":file", IMAGE_STRING_VALUE
, 0},
6503 {":ascent", IMAGE_ASCENT_VALUE
, 0},
6504 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
6505 {":relief", IMAGE_INTEGER_VALUE
, 0},
6506 {":conversions", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6507 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6508 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6509 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0},
6510 {":index", IMAGE_NON_NEGATIVE_INTEGER_VALUE
, 0}
6513 /* Structure describing the image type `tiff'. */
6515 static struct image_type tiff_type
=
6524 /* Return non-zero if OBJECT is a valid TIFF image specification. */
6527 tiff_image_p (Lisp_Object object
)
6529 struct image_keyword fmt
[TIFF_LAST
];
6530 memcpy (fmt
, tiff_format
, sizeof fmt
);
6532 if (!parse_image_spec (object
, fmt
, TIFF_LAST
, Qtiff
))
6535 /* Must specify either the :data or :file keyword. */
6536 return fmt
[TIFF_FILE
].count
+ fmt
[TIFF_DATA
].count
== 1;
6539 #endif /* HAVE_TIFF || HAVE_NS */
6547 /* TIFF library details. */
6548 DEF_IMGLIB_FN (TIFFErrorHandler
, TIFFSetErrorHandler
, (TIFFErrorHandler
));
6549 DEF_IMGLIB_FN (TIFFErrorHandler
, TIFFSetWarningHandler
, (TIFFErrorHandler
));
6550 DEF_IMGLIB_FN (TIFF
*, TIFFOpen
, (const char *, const char *));
6551 DEF_IMGLIB_FN (TIFF
*, TIFFClientOpen
, (const char *, const char *, thandle_t
,
6552 TIFFReadWriteProc
, TIFFReadWriteProc
,
6553 TIFFSeekProc
, TIFFCloseProc
, TIFFSizeProc
,
6554 TIFFMapFileProc
, TIFFUnmapFileProc
));
6555 DEF_IMGLIB_FN (int, TIFFGetField
, (TIFF
*, ttag_t
, ...));
6556 DEF_IMGLIB_FN (int, TIFFReadRGBAImage
, (TIFF
*, uint32
, uint32
, uint32
*, int));
6557 DEF_IMGLIB_FN (void, TIFFClose
, (TIFF
*));
6558 DEF_IMGLIB_FN (int, TIFFSetDirectory
, (TIFF
*, tdir_t
));
6561 init_tiff_functions (Lisp_Object libraries
)
6565 if (!(library
= w32_delayed_load (libraries
, Qtiff
)))
6568 LOAD_IMGLIB_FN (library
, TIFFSetErrorHandler
);
6569 LOAD_IMGLIB_FN (library
, TIFFSetWarningHandler
);
6570 LOAD_IMGLIB_FN (library
, TIFFOpen
);
6571 LOAD_IMGLIB_FN (library
, TIFFClientOpen
);
6572 LOAD_IMGLIB_FN (library
, TIFFGetField
);
6573 LOAD_IMGLIB_FN (library
, TIFFReadRGBAImage
);
6574 LOAD_IMGLIB_FN (library
, TIFFClose
);
6575 LOAD_IMGLIB_FN (library
, TIFFSetDirectory
);
6581 #define fn_TIFFSetErrorHandler TIFFSetErrorHandler
6582 #define fn_TIFFSetWarningHandler TIFFSetWarningHandler
6583 #define fn_TIFFOpen TIFFOpen
6584 #define fn_TIFFClientOpen TIFFClientOpen
6585 #define fn_TIFFGetField TIFFGetField
6586 #define fn_TIFFReadRGBAImage TIFFReadRGBAImage
6587 #define fn_TIFFClose TIFFClose
6588 #define fn_TIFFSetDirectory TIFFSetDirectory
6589 #endif /* HAVE_NTGUI */
6592 /* Reading from a memory buffer for TIFF images Based on the PNG
6593 memory source, but we have to provide a lot of extra functions.
6596 We really only need to implement read and seek, but I am not
6597 convinced that the TIFF library is smart enough not to destroy
6598 itself if we only hand it the function pointers we need to
6603 unsigned char *bytes
;
6610 tiff_read_from_memory (thandle_t data
, tdata_t buf
, tsize_t size
)
6612 tiff_memory_source
*src
= (tiff_memory_source
*) data
;
6614 if (size
> src
->len
- src
->index
)
6616 memcpy (buf
, src
->bytes
+ src
->index
, size
);
6622 tiff_write_from_memory (thandle_t data
, tdata_t buf
, tsize_t size
)
6628 tiff_seek_in_memory (thandle_t data
, toff_t off
, int whence
)
6630 tiff_memory_source
*src
= (tiff_memory_source
*) data
;
6635 case SEEK_SET
: /* Go from beginning of source. */
6639 case SEEK_END
: /* Go from end of source. */
6640 idx
= src
->len
+ off
;
6643 case SEEK_CUR
: /* Go from current position. */
6644 idx
= src
->index
+ off
;
6647 default: /* Invalid `whence'. */
6651 if (idx
> src
->len
|| idx
< 0)
6659 tiff_close_memory (thandle_t data
)
6666 tiff_mmap_memory (thandle_t data
, tdata_t
*pbase
, toff_t
*psize
)
6668 /* It is already _IN_ memory. */
6673 tiff_unmap_memory (thandle_t data
, tdata_t base
, toff_t size
)
6675 /* We don't need to do this. */
6679 tiff_size_of_memory (thandle_t data
)
6681 return ((tiff_memory_source
*) data
)->len
;
6685 static void tiff_error_handler (const char *, const char *, va_list)
6686 ATTRIBUTE_FORMAT_PRINTF (2, 0);
6688 tiff_error_handler (const char *title
, const char *format
, va_list ap
)
6693 len
= sprintf (buf
, "TIFF error: %s ", title
);
6694 vsprintf (buf
+ len
, format
, ap
);
6695 add_to_log (buf
, Qnil
, Qnil
);
6699 static void tiff_warning_handler (const char *, const char *, va_list)
6700 ATTRIBUTE_FORMAT_PRINTF (2, 0);
6702 tiff_warning_handler (const char *title
, const char *format
, va_list ap
)
6707 len
= sprintf (buf
, "TIFF warning: %s ", title
);
6708 vsprintf (buf
+ len
, format
, ap
);
6709 add_to_log (buf
, Qnil
, Qnil
);
6713 /* Load TIFF image IMG for use on frame F. Value is non-zero if
6717 tiff_load (struct frame
*f
, struct image
*img
)
6719 Lisp_Object file
, specified_file
;
6720 Lisp_Object specified_data
;
6722 int width
, height
, x
, y
, count
;
6726 tiff_memory_source memsrc
;
6729 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
6730 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
6732 fn_TIFFSetErrorHandler ((TIFFErrorHandler
) tiff_error_handler
);
6733 fn_TIFFSetWarningHandler ((TIFFErrorHandler
) tiff_warning_handler
);
6735 if (NILP (specified_data
))
6737 /* Read from a file */
6738 file
= x_find_image_file (specified_file
);
6739 if (!STRINGP (file
))
6741 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
6745 /* Try to open the image file. */
6746 tiff
= fn_TIFFOpen (SSDATA (file
), "r");
6749 image_error ("Cannot open `%s'", file
, Qnil
);
6755 if (!STRINGP (specified_data
))
6757 image_error ("Invalid image data `%s'", specified_data
, Qnil
);
6761 /* Memory source! */
6762 memsrc
.bytes
= SDATA (specified_data
);
6763 memsrc
.len
= SBYTES (specified_data
);
6766 tiff
= fn_TIFFClientOpen ("memory_source", "r", (thandle_t
)&memsrc
,
6767 (TIFFReadWriteProc
) tiff_read_from_memory
,
6768 (TIFFReadWriteProc
) tiff_write_from_memory
,
6769 tiff_seek_in_memory
,
6771 tiff_size_of_memory
,
6777 image_error ("Cannot open memory source for `%s'", img
->spec
, Qnil
);
6782 image
= image_spec_value (img
->spec
, QCindex
, NULL
);
6783 if (INTEGERP (image
))
6785 int ino
= XFASTINT (image
);
6786 if (!fn_TIFFSetDirectory (tiff
, ino
))
6788 image_error ("Invalid image number `%s' in image `%s'",
6790 fn_TIFFClose (tiff
);
6795 /* Get width and height of the image, and allocate a raster buffer
6796 of width x height 32-bit values. */
6797 fn_TIFFGetField (tiff
, TIFFTAG_IMAGEWIDTH
, &width
);
6798 fn_TIFFGetField (tiff
, TIFFTAG_IMAGELENGTH
, &height
);
6800 if (!check_image_size (f
, width
, height
))
6802 image_error ("Invalid image size (see `max-image-size')", Qnil
, Qnil
);
6803 fn_TIFFClose (tiff
);
6807 buf
= (uint32
*) xmalloc (width
* height
* sizeof *buf
);
6809 rc
= fn_TIFFReadRGBAImage (tiff
, width
, height
, buf
, 0);
6811 /* Count the number of images in the file. */
6812 for (count
= 1; fn_TIFFSetDirectory (tiff
, count
); count
++)
6816 img
->lisp_data
= Fcons (Qcount
,
6817 Fcons (make_number (count
),
6820 fn_TIFFClose (tiff
);
6823 image_error ("Error reading TIFF image `%s'", img
->spec
, Qnil
);
6828 /* Create the X image and pixmap. */
6829 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
6835 /* Initialize the color table. */
6836 init_color_table ();
6838 /* Process the pixel raster. Origin is in the lower-left corner. */
6839 for (y
= 0; y
< height
; ++y
)
6841 uint32
*row
= buf
+ y
* width
;
6843 for (x
= 0; x
< width
; ++x
)
6845 uint32 abgr
= row
[x
];
6846 int r
= TIFFGetR (abgr
) << 8;
6847 int g
= TIFFGetG (abgr
) << 8;
6848 int b
= TIFFGetB (abgr
) << 8;
6849 XPutPixel (ximg
, x
, height
- 1 - y
, lookup_rgb_color (f
, r
, g
, b
));
6853 #ifdef COLOR_TABLE_SUPPORT
6854 /* Remember the colors allocated for the image. Free the color table. */
6855 img
->colors
= colors_in_color_table (&img
->ncolors
);
6856 free_color_table ();
6857 #endif /* COLOR_TABLE_SUPPORT */
6860 img
->height
= height
;
6862 /* Maybe fill in the background field while we have ximg handy. */
6863 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
6864 /* Casting avoids a GCC warning on W32. */
6865 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
6867 /* Put the image into the pixmap, then free the X image and its buffer. */
6868 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
6869 x_destroy_x_image (ximg
);
6875 #else /* HAVE_TIFF */
6879 tiff_load (struct frame
*f
, struct image
*img
)
6881 return ns_load_image (f
, img
,
6882 image_spec_value (img
->spec
, QCfile
, NULL
),
6883 image_spec_value (img
->spec
, QCdata
, NULL
));
6885 #endif /* HAVE_NS */
6887 #endif /* !HAVE_TIFF */
6891 /***********************************************************************
6893 ***********************************************************************/
6895 #if defined (HAVE_GIF) || defined (HAVE_NS)
6897 static int gif_image_p (Lisp_Object object
);
6898 static int gif_load (struct frame
*f
, struct image
*img
);
6899 static void gif_clear_image (struct frame
*f
, struct image
*img
);
6901 /* The symbol `gif' identifying images of this type. */
6903 static Lisp_Object Qgif
;
6905 /* Indices of image specification fields in gif_format, below. */
6907 enum gif_keyword_index
6923 /* Vector of image_keyword structures describing the format
6924 of valid user-defined image specifications. */
6926 static const struct image_keyword gif_format
[GIF_LAST
] =
6928 {":type", IMAGE_SYMBOL_VALUE
, 1},
6929 {":data", IMAGE_STRING_VALUE
, 0},
6930 {":file", IMAGE_STRING_VALUE
, 0},
6931 {":ascent", IMAGE_ASCENT_VALUE
, 0},
6932 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
6933 {":relief", IMAGE_INTEGER_VALUE
, 0},
6934 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6935 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6936 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6937 {":index", IMAGE_NON_NEGATIVE_INTEGER_VALUE
, 0},
6938 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
6941 /* Structure describing the image type `gif'. */
6943 static struct image_type gif_type
=
6952 /* Free X resources of GIF image IMG which is used on frame F. */
6955 gif_clear_image (struct frame
*f
, struct image
*img
)
6957 img
->lisp_data
= Qnil
;
6958 x_clear_image (f
, img
);
6961 /* Return non-zero if OBJECT is a valid GIF image specification. */
6964 gif_image_p (Lisp_Object object
)
6966 struct image_keyword fmt
[GIF_LAST
];
6967 memcpy (fmt
, gif_format
, sizeof fmt
);
6969 if (!parse_image_spec (object
, fmt
, GIF_LAST
, Qgif
))
6972 /* Must specify either the :data or :file keyword. */
6973 return fmt
[GIF_FILE
].count
+ fmt
[GIF_DATA
].count
== 1;
6976 #endif /* HAVE_GIF */
6980 #if defined (HAVE_NTGUI)
6981 /* winuser.h might define DrawText to DrawTextA or DrawTextW.
6982 Undefine before redefining to avoid a preprocessor warning. */
6986 /* avoid conflict with QuickdrawText.h */
6987 #define DrawText gif_DrawText
6988 #include <gif_lib.h>
6991 #else /* HAVE_NTGUI */
6993 #include <gif_lib.h>
6995 #endif /* HAVE_NTGUI */
7000 /* GIF library details. */
7001 DEF_IMGLIB_FN (int, DGifCloseFile
, (GifFileType
*));
7002 DEF_IMGLIB_FN (int, DGifSlurp
, (GifFileType
*));
7003 DEF_IMGLIB_FN (GifFileType
*, DGifOpen
, (void *, InputFunc
));
7004 DEF_IMGLIB_FN (GifFileType
*, DGifOpenFileName
, (const char *));
7007 init_gif_functions (Lisp_Object libraries
)
7011 if (!(library
= w32_delayed_load (libraries
, Qgif
)))
7014 LOAD_IMGLIB_FN (library
, DGifCloseFile
);
7015 LOAD_IMGLIB_FN (library
, DGifSlurp
);
7016 LOAD_IMGLIB_FN (library
, DGifOpen
);
7017 LOAD_IMGLIB_FN (library
, DGifOpenFileName
);
7023 #define fn_DGifCloseFile DGifCloseFile
7024 #define fn_DGifSlurp DGifSlurp
7025 #define fn_DGifOpen DGifOpen
7026 #define fn_DGifOpenFileName DGifOpenFileName
7028 #endif /* HAVE_NTGUI */
7030 /* Reading a GIF image from memory
7031 Based on the PNG memory stuff to a certain extent. */
7035 unsigned char *bytes
;
7041 /* Make the current memory source available to gif_read_from_memory.
7042 It's done this way because not all versions of libungif support
7043 a UserData field in the GifFileType structure. */
7044 static gif_memory_source
*current_gif_memory_src
;
7047 gif_read_from_memory (GifFileType
*file
, GifByteType
*buf
, int len
)
7049 gif_memory_source
*src
= current_gif_memory_src
;
7051 if (len
> src
->len
- src
->index
)
7054 memcpy (buf
, src
->bytes
+ src
->index
, len
);
7060 /* Load GIF image IMG for use on frame F. Value is non-zero if
7063 static const int interlace_start
[] = {0, 4, 2, 1};
7064 static const int interlace_increment
[] = {8, 8, 4, 2};
7066 #define GIF_LOCAL_DESCRIPTOR_EXTENSION 249
7069 gif_load (struct frame
*f
, struct image
*img
)
7072 int rc
, width
, height
, x
, y
, i
, j
;
7074 ColorMapObject
*gif_color_map
;
7075 unsigned long pixel_colors
[256];
7077 int image_height
, image_width
;
7078 gif_memory_source memsrc
;
7079 Lisp_Object specified_bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
7080 Lisp_Object specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
7081 Lisp_Object specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
7082 unsigned long bgcolor
= 0;
7085 if (NILP (specified_data
))
7087 file
= x_find_image_file (specified_file
);
7088 if (!STRINGP (file
))
7090 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
7094 /* Open the GIF file. */
7095 gif
= fn_DGifOpenFileName (SSDATA (file
));
7098 image_error ("Cannot open `%s'", file
, Qnil
);
7104 if (!STRINGP (specified_data
))
7106 image_error ("Invalid image data `%s'", specified_data
, Qnil
);
7110 /* Read from memory! */
7111 current_gif_memory_src
= &memsrc
;
7112 memsrc
.bytes
= SDATA (specified_data
);
7113 memsrc
.len
= SBYTES (specified_data
);
7116 gif
= fn_DGifOpen (&memsrc
, gif_read_from_memory
);
7119 image_error ("Cannot open memory source `%s'", img
->spec
, Qnil
);
7124 /* Before reading entire contents, check the declared image size. */
7125 if (!check_image_size (f
, gif
->SWidth
, gif
->SHeight
))
7127 image_error ("Invalid image size (see `max-image-size')", Qnil
, Qnil
);
7128 fn_DGifCloseFile (gif
);
7132 /* Read entire contents. */
7133 rc
= fn_DGifSlurp (gif
);
7134 if (rc
== GIF_ERROR
|| gif
->ImageCount
<= 0)
7136 image_error ("Error reading `%s'", img
->spec
, Qnil
);
7137 fn_DGifCloseFile (gif
);
7141 /* Which sub-image are we to display? */
7143 Lisp_Object image_number
= image_spec_value (img
->spec
, QCindex
, NULL
);
7144 idx
= INTEGERP (image_number
) ? XFASTINT (image_number
) : 0;
7145 if (idx
< 0 || idx
>= gif
->ImageCount
)
7147 image_error ("Invalid image number `%s' in image `%s'",
7148 image_number
, img
->spec
);
7149 fn_DGifCloseFile (gif
);
7154 img
->corners
[TOP_CORNER
] = gif
->SavedImages
[idx
].ImageDesc
.Top
;
7155 img
->corners
[LEFT_CORNER
] = gif
->SavedImages
[idx
].ImageDesc
.Left
;
7156 image_height
= gif
->SavedImages
[idx
].ImageDesc
.Height
;
7157 img
->corners
[BOT_CORNER
] = img
->corners
[TOP_CORNER
] + image_height
;
7158 image_width
= gif
->SavedImages
[idx
].ImageDesc
.Width
;
7159 img
->corners
[RIGHT_CORNER
] = img
->corners
[LEFT_CORNER
] + image_width
;
7161 width
= img
->width
= max (gif
->SWidth
,
7162 max (gif
->Image
.Left
+ gif
->Image
.Width
,
7163 img
->corners
[RIGHT_CORNER
]));
7164 height
= img
->height
= max (gif
->SHeight
,
7165 max (gif
->Image
.Top
+ gif
->Image
.Height
,
7166 img
->corners
[BOT_CORNER
]));
7168 if (!check_image_size (f
, width
, height
))
7170 image_error ("Invalid image size (see `max-image-size')", Qnil
, Qnil
);
7171 fn_DGifCloseFile (gif
);
7175 /* Create the X image and pixmap. */
7176 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
7178 fn_DGifCloseFile (gif
);
7182 /* Clear the part of the screen image not covered by the image.
7183 Full animated GIF support requires more here (see the gif89 spec,
7184 disposal methods). Let's simply assume that the part not covered
7185 by a sub-image is in the frame's background color. */
7186 for (y
= 0; y
< img
->corners
[TOP_CORNER
]; ++y
)
7187 for (x
= 0; x
< width
; ++x
)
7188 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7190 for (y
= img
->corners
[BOT_CORNER
]; y
< height
; ++y
)
7191 for (x
= 0; x
< width
; ++x
)
7192 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7194 for (y
= img
->corners
[TOP_CORNER
]; y
< img
->corners
[BOT_CORNER
]; ++y
)
7196 for (x
= 0; x
< img
->corners
[LEFT_CORNER
]; ++x
)
7197 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7198 for (x
= img
->corners
[RIGHT_CORNER
]; x
< width
; ++x
)
7199 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7202 /* Read the GIF image into the X image. */
7204 /* FIXME: With the current implementation, loading an animated gif
7205 is quadratic in the number of animation frames, since each frame
7206 is a separate struct image. We must provide a way for a single
7207 gif_load call to construct and save all animation frames. */
7209 init_color_table ();
7210 if (STRINGP (specified_bg
))
7211 bgcolor
= x_alloc_image_color (f
, img
, specified_bg
,
7212 FRAME_BACKGROUND_PIXEL (f
));
7213 for (j
= 0; j
<= idx
; ++j
)
7215 /* We use a local variable `raster' here because RasterBits is a
7216 char *, which invites problems with bytes >= 0x80. */
7217 struct SavedImage
*subimage
= gif
->SavedImages
+ j
;
7218 unsigned char *raster
= (unsigned char *) subimage
->RasterBits
;
7219 int transparency_color_index
= -1;
7222 /* Find the Graphic Control Extension block for this sub-image.
7223 Extract the disposal method and transparency color. */
7224 for (i
= 0; i
< subimage
->ExtensionBlockCount
; i
++)
7226 ExtensionBlock
*extblock
= subimage
->ExtensionBlocks
+ i
;
7228 if ((extblock
->Function
== GIF_LOCAL_DESCRIPTOR_EXTENSION
)
7229 && extblock
->ByteCount
== 4
7230 && extblock
->Bytes
[0] & 1)
7232 /* From gif89a spec: 1 = "keep in place", 2 = "restore
7233 to background". Treat any other value like 2. */
7234 disposal
= (extblock
->Bytes
[0] >> 2) & 7;
7235 transparency_color_index
= (unsigned char) extblock
->Bytes
[3];
7240 /* We can't "keep in place" the first subimage. */
7244 /* Allocate subimage colors. */
7245 memset (pixel_colors
, 0, sizeof pixel_colors
);
7246 gif_color_map
= subimage
->ImageDesc
.ColorMap
;
7248 gif_color_map
= gif
->SColorMap
;
7251 for (i
= 0; i
< gif_color_map
->ColorCount
; ++i
)
7253 if (transparency_color_index
== i
)
7254 pixel_colors
[i
] = STRINGP (specified_bg
)
7255 ? bgcolor
: FRAME_BACKGROUND_PIXEL (f
);
7258 int r
= gif_color_map
->Colors
[i
].Red
<< 8;
7259 int g
= gif_color_map
->Colors
[i
].Green
<< 8;
7260 int b
= gif_color_map
->Colors
[i
].Blue
<< 8;
7261 pixel_colors
[i
] = lookup_rgb_color (f
, r
, g
, b
);
7265 /* Apply the pixel values. */
7266 if (gif
->SavedImages
[j
].ImageDesc
.Interlace
)
7270 for (y
= 0, row
= interlace_start
[0], pass
= 0;
7272 y
++, row
+= interlace_increment
[pass
])
7274 if (row
>= image_height
)
7276 row
= interlace_start
[++pass
];
7277 while (row
>= image_height
)
7278 row
= interlace_start
[++pass
];
7281 for (x
= 0; x
< image_width
; x
++)
7283 int c
= raster
[y
* image_width
+ x
];
7284 if (transparency_color_index
!= c
|| disposal
!= 1)
7285 XPutPixel (ximg
, x
+ img
->corners
[LEFT_CORNER
],
7286 row
+ img
->corners
[TOP_CORNER
], pixel_colors
[c
]);
7292 for (y
= 0; y
< image_height
; ++y
)
7293 for (x
= 0; x
< image_width
; ++x
)
7295 int c
= raster
[y
* image_width
+ x
];
7296 if (transparency_color_index
!= c
|| disposal
!= 1)
7297 XPutPixel (ximg
, x
+ img
->corners
[LEFT_CORNER
],
7298 y
+ img
->corners
[TOP_CORNER
], pixel_colors
[c
]);
7303 #ifdef COLOR_TABLE_SUPPORT
7304 img
->colors
= colors_in_color_table (&img
->ncolors
);
7305 free_color_table ();
7306 #endif /* COLOR_TABLE_SUPPORT */
7308 /* Save GIF image extension data for `image-metadata'.
7309 Format is (count IMAGES extension-data (FUNCTION "BYTES" ...)). */
7310 img
->lisp_data
= Qnil
;
7311 if (gif
->SavedImages
[idx
].ExtensionBlockCount
> 0)
7313 unsigned int delay
= 0;
7314 ExtensionBlock
*ext
= gif
->SavedImages
[idx
].ExtensionBlocks
;
7315 for (i
= 0; i
< gif
->SavedImages
[idx
].ExtensionBlockCount
; i
++, ext
++)
7316 /* Append (... FUNCTION "BYTES") */
7319 = Fcons (make_number (ext
->Function
),
7320 Fcons (make_unibyte_string (ext
->Bytes
, ext
->ByteCount
),
7322 if (ext
->Function
== GIF_LOCAL_DESCRIPTOR_EXTENSION
7323 && ext
->ByteCount
== 4)
7325 delay
= ext
->Bytes
[2] << CHAR_BIT
;
7326 delay
|= ext
->Bytes
[1];
7329 img
->lisp_data
= Fcons (Qextension_data
,
7330 Fcons (img
->lisp_data
, Qnil
));
7334 Fcons (make_float (((double) delay
) * 0.01),
7338 if (gif
->ImageCount
> 1)
7339 img
->lisp_data
= Fcons (Qcount
,
7340 Fcons (make_number (gif
->ImageCount
),
7343 fn_DGifCloseFile (gif
);
7345 /* Maybe fill in the background field while we have ximg handy. */
7346 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
7347 /* Casting avoids a GCC warning. */
7348 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
7350 /* Put the image into the pixmap, then free the X image and its buffer. */
7351 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
7352 x_destroy_x_image (ximg
);
7357 #else /* !HAVE_GIF */
7361 gif_load (struct frame
*f
, struct image
*img
)
7363 return ns_load_image (f
, img
,
7364 image_spec_value (img
->spec
, QCfile
, NULL
),
7365 image_spec_value (img
->spec
, QCdata
, NULL
));
7367 #endif /* HAVE_NS */
7369 #endif /* HAVE_GIF */
7372 /***********************************************************************
7374 ***********************************************************************/
7375 #if defined (HAVE_IMAGEMAGICK)
7377 static Lisp_Object Qimagemagick
;
7379 static int imagemagick_image_p (Lisp_Object
);
7380 static int imagemagick_load (struct frame
*, struct image
*);
7381 static void imagemagick_clear_image (struct frame
*, struct image
*);
7383 /* Indices of image specification fields in imagemagick_format. */
7385 enum imagemagick_keyword_index
7393 IMAGEMAGICK_ALGORITHM
,
7394 IMAGEMAGICK_HEURISTIC_MASK
,
7396 IMAGEMAGICK_BACKGROUND
,
7399 IMAGEMAGICK_ROTATION
,
7404 /* Vector of image_keyword structures describing the format
7405 of valid user-defined image specifications. */
7407 static struct image_keyword imagemagick_format
[IMAGEMAGICK_LAST
] =
7409 {":type", IMAGE_SYMBOL_VALUE
, 1},
7410 {":data", IMAGE_STRING_VALUE
, 0},
7411 {":file", IMAGE_STRING_VALUE
, 0},
7412 {":ascent", IMAGE_ASCENT_VALUE
, 0},
7413 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
7414 {":relief", IMAGE_INTEGER_VALUE
, 0},
7415 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7416 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7417 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7418 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0},
7419 {":height", IMAGE_INTEGER_VALUE
, 0},
7420 {":width", IMAGE_INTEGER_VALUE
, 0},
7421 {":rotation", IMAGE_NUMBER_VALUE
, 0},
7422 {":crop", IMAGE_DONT_CHECK_VALUE_TYPE
, 0}
7425 /* Structure describing the image type for any image handled via
7428 static struct image_type imagemagick_type
=
7431 imagemagick_image_p
,
7433 imagemagick_clear_image
,
7437 /* Free X resources of imagemagick image IMG which is used on frame F. */
7440 imagemagick_clear_image (struct frame
*f
,
7443 x_clear_image (f
, img
);
7446 /* Return non-zero if OBJECT is a valid IMAGEMAGICK image specification. Do
7447 this by calling parse_image_spec and supplying the keywords that
7448 identify the IMAGEMAGICK format. */
7451 imagemagick_image_p (Lisp_Object object
)
7453 struct image_keyword fmt
[IMAGEMAGICK_LAST
];
7454 memcpy (fmt
, imagemagick_format
, sizeof fmt
);
7456 if (!parse_image_spec (object
, fmt
, IMAGEMAGICK_LAST
, Qimagemagick
))
7459 /* Must specify either the :data or :file keyword. */
7460 return fmt
[IMAGEMAGICK_FILE
].count
+ fmt
[IMAGEMAGICK_DATA
].count
== 1;
7463 /* The GIF library also defines DrawRectangle, but its never used in Emacs.
7464 Therefore rename the function so it doesnt collide with ImageMagick. */
7465 #define DrawRectangle DrawRectangleGif
7466 #include <wand/MagickWand.h>
7468 /* ImageMagick 6.5.3 through 6.6.5 hid PixelGetMagickColor for some reason.
7469 Emacs seems to work fine with the hidden version, so unhide it. */
7470 #include <magick/version.h>
7471 #if 0x653 <= MagickLibVersion && MagickLibVersion <= 0x665
7472 extern WandExport
void PixelGetMagickColor (const PixelWand
*,
7473 MagickPixelPacket
*);
7476 /* Helper function for imagemagick_load, which does the actual loading
7477 given contents and size, apart from frame and image structures,
7478 passed from imagemagick_load. Uses librimagemagick to do most of
7479 the image processing.
7481 F is a pointer to the Emacs frame; IMG to the image structure to
7482 prepare; CONTENTS is the string containing the IMAGEMAGICK data to
7483 be parsed; SIZE is the number of bytes of data; and FILENAME is
7484 either the file name or the image data.
7486 Return non-zero if successful. */
7489 imagemagick_load_image (struct frame
*f
, struct image
*img
,
7490 unsigned char *contents
, unsigned int size
,
7496 MagickBooleanType status
;
7502 MagickWand
*image_wand
;
7503 MagickWand
*ping_wand
;
7504 PixelIterator
*iterator
;
7506 MagickPixelPacket pixel
;
7511 int desired_width
, desired_height
;
7513 int imagemagick_rendermethod
;
7515 ImageInfo
*image_info
;
7516 ExceptionInfo
*exception
;
7520 /* Handle image index for image types who can contain more than one image.
7521 Interface :index is same as for GIF. First we "ping" the image to see how
7522 many sub-images it contains. Pinging is faster than loading the image to
7523 find out things about it. */
7525 /* Initialize the imagemagick environment. */
7526 MagickWandGenesis ();
7527 image
= image_spec_value (img
->spec
, QCindex
, NULL
);
7528 ino
= INTEGERP (image
) ? XFASTINT (image
) : 0;
7529 ping_wand
= NewMagickWand ();
7530 MagickSetResolution (ping_wand
, 2, 2);
7531 if (filename
!= NULL
)
7533 status
= MagickPingImage (ping_wand
, filename
);
7537 status
= MagickPingImageBlob (ping_wand
, contents
, size
);
7540 if (ino
>= MagickGetNumberImages (ping_wand
))
7542 image_error ("Invalid image number `%s' in image `%s'",
7544 DestroyMagickWand (ping_wand
);
7548 if (MagickGetNumberImages(ping_wand
) > 1)
7551 Fcons (make_number (MagickGetNumberImages (ping_wand
)),
7554 DestroyMagickWand (ping_wand
);
7556 /* Now we know how many images are inside the file. If it's not a
7557 bundle, the number is one. */
7559 if (filename
!= NULL
)
7561 image_info
= CloneImageInfo ((ImageInfo
*) NULL
);
7562 (void) strcpy (image_info
->filename
, filename
);
7563 image_info
->number_scenes
= 1;
7564 image_info
->scene
= ino
;
7565 exception
= AcquireExceptionInfo ();
7567 im_image
= ReadImage (image_info
, exception
);
7568 DestroyExceptionInfo (exception
);
7570 if (im_image
== NULL
)
7571 goto imagemagick_no_wand
;
7572 image_wand
= NewMagickWandFromImage (im_image
);
7573 DestroyImage(im_image
);
7577 image_wand
= NewMagickWand ();
7578 if (MagickReadImageBlob (image_wand
, contents
, size
) == MagickFalse
)
7579 goto imagemagick_error
;
7582 /* If width and/or height is set in the display spec assume we want
7583 to scale to those values. If either h or w is unspecified, the
7584 unspecified should be calculated from the specified to preserve
7587 value
= image_spec_value (img
->spec
, QCwidth
, NULL
);
7588 desired_width
= (INTEGERP (value
) ? XFASTINT (value
) : -1);
7589 value
= image_spec_value (img
->spec
, QCheight
, NULL
);
7590 desired_height
= (INTEGERP (value
) ? XFASTINT (value
) : -1);
7592 height
= MagickGetImageHeight (image_wand
);
7593 width
= MagickGetImageWidth (image_wand
);
7595 if (desired_width
!= -1 && desired_height
== -1)
7596 /* w known, calculate h. */
7597 desired_height
= (double) desired_width
/ width
* height
;
7598 if (desired_width
== -1 && desired_height
!= -1)
7599 /* h known, calculate w. */
7600 desired_width
= (double) desired_height
/ height
* width
;
7601 if (desired_width
!= -1 && desired_height
!= -1)
7603 status
= MagickScaleImage (image_wand
, desired_width
, desired_height
);
7604 if (status
== MagickFalse
)
7606 image_error ("Imagemagick scale failed", Qnil
, Qnil
);
7607 goto imagemagick_error
;
7611 /* crop behaves similar to image slicing in Emacs but is more memory
7613 crop
= image_spec_value (img
->spec
, QCcrop
, NULL
);
7615 if (CONSP (crop
) && INTEGERP (XCAR (crop
)))
7617 /* After some testing, it seems MagickCropImage is the fastest crop
7618 function in ImageMagick. This crop function seems to do less copying
7619 than the alternatives, but it still reads the entire image into memory
7620 before croping, which is aparently difficult to avoid when using
7623 w
= XFASTINT (XCAR (crop
));
7625 if (CONSP (crop
) && INTEGERP (XCAR (crop
)))
7627 h
= XFASTINT (XCAR (crop
));
7629 if (CONSP (crop
) && INTEGERP (XCAR (crop
)))
7631 x
= XFASTINT (XCAR (crop
));
7633 if (CONSP (crop
) && INTEGERP (XCAR (crop
)))
7635 y
= XFASTINT (XCAR (crop
));
7636 MagickCropImage (image_wand
, w
, h
, x
, y
);
7642 /* Furthermore :rotation. we need background color and angle for
7645 TODO background handling for rotation specified_bg =
7646 image_spec_value (img->spec, QCbackground, NULL); if (!STRINGP
7648 value
= image_spec_value (img
->spec
, QCrotation
, NULL
);
7651 PixelWand
* background
= NewPixelWand ();
7652 PixelSetColor (background
, "#ffffff");/*TODO remove hardcode*/
7654 rotation
= extract_float (value
);
7656 status
= MagickRotateImage (image_wand
, background
, rotation
);
7657 DestroyPixelWand (background
);
7658 if (status
== MagickFalse
)
7660 image_error ("Imagemagick image rotate failed", Qnil
, Qnil
);
7661 goto imagemagick_error
;
7665 /* Finally we are done manipulating the image. Figure out the
7666 resulting width/height and transfer ownerwship to Emacs. */
7667 height
= MagickGetImageHeight (image_wand
);
7668 width
= MagickGetImageWidth (image_wand
);
7670 if (! check_image_size (f
, width
, height
))
7672 image_error ("Invalid image size (see `max-image-size')", Qnil
, Qnil
);
7673 goto imagemagick_error
;
7676 /* We can now get a valid pixel buffer from the imagemagick file, if all
7679 init_color_table ();
7680 imagemagick_rendermethod
= (INTEGERP (Vimagemagick_render_type
)
7681 ? XFASTINT (Vimagemagick_render_type
) : 0);
7682 if (imagemagick_rendermethod
== 0)
7684 /* Try to create a x pixmap to hold the imagemagick pixmap. */
7685 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0,
7686 &ximg
, &img
->pixmap
))
7688 #ifdef COLOR_TABLE_SUPPORT
7689 free_color_table ();
7691 image_error("Imagemagick X bitmap allocation failure", Qnil
, Qnil
);
7692 goto imagemagick_error
;
7695 /* Copy imagegmagick image to x with primitive yet robust pixel
7696 pusher loop. This has been tested a lot with many different
7699 /* Copy pixels from the imagemagick image structure to the x image map. */
7700 iterator
= NewPixelIterator (image_wand
);
7701 if (iterator
== (PixelIterator
*) NULL
)
7703 #ifdef COLOR_TABLE_SUPPORT
7704 free_color_table ();
7706 x_destroy_x_image (ximg
);
7707 image_error ("Imagemagick pixel iterator creation failed",
7709 goto imagemagick_error
;
7712 for (y
= 0; y
< (long) MagickGetImageHeight (image_wand
); y
++)
7714 pixels
= PixelGetNextIteratorRow (iterator
, &width
);
7715 if (pixels
== (PixelWand
**) NULL
)
7717 for (x
= 0; x
< (long) width
; x
++)
7719 PixelGetMagickColor (pixels
[x
], &pixel
);
7720 XPutPixel (ximg
, x
, y
,
7721 lookup_rgb_color (f
,
7727 DestroyPixelIterator (iterator
);
7730 if (imagemagick_rendermethod
== 1)
7732 /* Magicexportimage is normaly faster than pixelpushing. This
7733 method is also well tested. Some aspects of this method are
7734 ad-hoc and needs to be more researched. */
7735 int imagedepth
= 24;/*MagickGetImageDepth(image_wand);*/
7736 const char *exportdepth
= imagedepth
<= 8 ? "I" : "BGRP";/*"RGBP";*/
7737 /* Try to create a x pixmap to hold the imagemagick pixmap. */
7738 if (!x_create_x_image_and_pixmap (f
, width
, height
, imagedepth
,
7739 &ximg
, &img
->pixmap
))
7741 #ifdef COLOR_TABLE_SUPPORT
7742 free_color_table ();
7744 image_error("Imagemagick X bitmap allocation failure", Qnil
, Qnil
);
7745 goto imagemagick_error
;
7749 /* Oddly, the below code doesnt seem to work:*/
7750 /* switch(ximg->bitmap_unit){ */
7752 /* pixelwidth=CharPixel; */
7755 /* pixelwidth=ShortPixel; */
7758 /* pixelwidth=LongPixel; */
7762 Here im just guessing the format of the bitmap.
7763 happens to work fine for:
7766 seems about 3 times as fast as pixel pushing(not carefully measured)
7768 pixelwidth
= CharPixel
;/*??? TODO figure out*/
7769 #ifdef HAVE_MAGICKEXPORTIMAGEPIXELS
7770 MagickExportImagePixels (image_wand
,
7775 /*&(img->pixmap));*/
7778 image_error ("You dont have MagickExportImagePixels, upgrade ImageMagick!",
7784 #ifdef COLOR_TABLE_SUPPORT
7785 /* Remember colors allocated for this image. */
7786 img
->colors
= colors_in_color_table (&img
->ncolors
);
7787 free_color_table ();
7788 #endif /* COLOR_TABLE_SUPPORT */
7792 img
->height
= height
;
7794 /* Put the image into the pixmap, then free the X image and its
7796 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
7797 x_destroy_x_image (ximg
);
7800 /* Final cleanup. image_wand should be the only resource left. */
7801 DestroyMagickWand (image_wand
);
7802 /* `MagickWandTerminus' terminates the imagemagick environment. */
7803 MagickWandTerminus ();
7808 DestroyMagickWand (image_wand
);
7809 imagemagick_no_wand
:
7810 MagickWandTerminus ();
7811 /* TODO more cleanup. */
7812 image_error ("Error parsing IMAGEMAGICK image `%s'", img
->spec
, Qnil
);
7817 /* Load IMAGEMAGICK image IMG for use on frame F. Value is non-zero if
7818 successful. this function will go into the imagemagick_type structure, and
7819 the prototype thus needs to be compatible with that structure. */
7822 imagemagick_load (struct frame
*f
, struct image
*img
)
7825 Lisp_Object file_name
;
7827 /* If IMG->spec specifies a file name, create a non-file spec from it. */
7828 file_name
= image_spec_value (img
->spec
, QCfile
, NULL
);
7829 if (STRINGP (file_name
))
7833 file
= x_find_image_file (file_name
);
7834 if (!STRINGP (file
))
7836 image_error ("Cannot find image file `%s'", file_name
, Qnil
);
7839 success_p
= imagemagick_load_image (f
, img
, 0, 0, SSDATA (file
));
7841 /* Else its not a file, its a lisp object. Load the image from a
7842 lisp object rather than a file. */
7847 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
7848 if (!STRINGP (data
))
7850 image_error ("Invalid image data `%s'", data
, Qnil
);
7853 success_p
= imagemagick_load_image (f
, img
, SDATA (data
),
7854 SBYTES (data
), NULL
);
7860 DEFUN ("imagemagick-types", Fimagemagick_types
, Simagemagick_types
, 0, 0, 0,
7861 doc
: /* Return a list of image types supported by ImageMagick.
7862 Each entry in this list is a symbol named after an ImageMagick format
7863 tag. See the ImageMagick manual for a list of ImageMagick formats and
7864 their descriptions (http://www.imagemagick.org/script/formats.php).
7866 Note that ImageMagick recognizes many file-types that Emacs does not
7867 recognize as images, such as C. See `imagemagick-types-inhibit'. */)
7870 Lisp_Object typelist
= Qnil
;
7873 char **imtypes
= GetMagickList ("*", &numf
, &ex
);
7875 Lisp_Object Qimagemagicktype
;
7876 for (i
= 0; i
< numf
; i
++)
7878 Qimagemagicktype
= intern (imtypes
[i
]);
7879 typelist
= Fcons (Qimagemagicktype
, typelist
);
7884 #endif /* defined (HAVE_IMAGEMAGICK) */
7888 /***********************************************************************
7890 ***********************************************************************/
7892 #if defined (HAVE_RSVG)
7894 /* Function prototypes. */
7896 static int svg_image_p (Lisp_Object object
);
7897 static int svg_load (struct frame
*f
, struct image
*img
);
7899 static int svg_load_image (struct frame
*, struct image
*,
7900 unsigned char *, ptrdiff_t);
7902 /* The symbol `svg' identifying images of this type. */
7904 static Lisp_Object Qsvg
;
7906 /* Indices of image specification fields in svg_format, below. */
7908 enum svg_keyword_index
7923 /* Vector of image_keyword structures describing the format
7924 of valid user-defined image specifications. */
7926 static const struct image_keyword svg_format
[SVG_LAST
] =
7928 {":type", IMAGE_SYMBOL_VALUE
, 1},
7929 {":data", IMAGE_STRING_VALUE
, 0},
7930 {":file", IMAGE_STRING_VALUE
, 0},
7931 {":ascent", IMAGE_ASCENT_VALUE
, 0},
7932 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
7933 {":relief", IMAGE_INTEGER_VALUE
, 0},
7934 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7935 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7936 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7937 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
7940 /* Structure describing the image type `svg'. Its the same type of
7941 structure defined for all image formats, handled by emacs image
7942 functions. See struct image_type in dispextern.h. */
7944 static struct image_type svg_type
=
7946 /* An identifier showing that this is an image structure for the SVG format. */
7948 /* Handle to a function that can be used to identify a SVG file. */
7950 /* Handle to function used to load a SVG file. */
7952 /* Handle to function to free sresources for SVG. */
7954 /* An internal field to link to the next image type in a list of
7955 image types, will be filled in when registering the format. */
7960 /* Return non-zero if OBJECT is a valid SVG image specification. Do
7961 this by calling parse_image_spec and supplying the keywords that
7962 identify the SVG format. */
7965 svg_image_p (Lisp_Object object
)
7967 struct image_keyword fmt
[SVG_LAST
];
7968 memcpy (fmt
, svg_format
, sizeof fmt
);
7970 if (!parse_image_spec (object
, fmt
, SVG_LAST
, Qsvg
))
7973 /* Must specify either the :data or :file keyword. */
7974 return fmt
[SVG_FILE
].count
+ fmt
[SVG_DATA
].count
== 1;
7977 #include <librsvg/rsvg.h>
7981 /* SVG library functions. */
7982 DEF_IMGLIB_FN (RsvgHandle
*, rsvg_handle_new
);
7983 DEF_IMGLIB_FN (void, rsvg_handle_get_dimensions
);
7984 DEF_IMGLIB_FN (gboolean
, rsvg_handle_write
);
7985 DEF_IMGLIB_FN (gboolean
, rsvg_handle_close
);
7986 DEF_IMGLIB_FN (GdkPixbuf
*, rsvg_handle_get_pixbuf
);
7988 DEF_IMGLIB_FN (int, gdk_pixbuf_get_width
);
7989 DEF_IMGLIB_FN (int, gdk_pixbuf_get_height
);
7990 DEF_IMGLIB_FN (guchar
*, gdk_pixbuf_get_pixels
);
7991 DEF_IMGLIB_FN (int, gdk_pixbuf_get_rowstride
);
7992 DEF_IMGLIB_FN (GdkColorspace
, gdk_pixbuf_get_colorspace
);
7993 DEF_IMGLIB_FN (int, gdk_pixbuf_get_n_channels
);
7994 DEF_IMGLIB_FN (gboolean
, gdk_pixbuf_get_has_alpha
);
7995 DEF_IMGLIB_FN (int, gdk_pixbuf_get_bits_per_sample
);
7997 DEF_IMGLIB_FN (void, g_type_init
);
7998 DEF_IMGLIB_FN (void, g_object_unref
);
7999 DEF_IMGLIB_FN (void, g_error_free
);
8001 Lisp_Object Qgdk_pixbuf
, Qglib
, Qgobject
;
8004 init_svg_functions (Lisp_Object libraries
)
8006 HMODULE library
, gdklib
, glib
, gobject
;
8008 if (!(glib
= w32_delayed_load (libraries
, Qglib
))
8009 || !(gobject
= w32_delayed_load (libraries
, Qgobject
))
8010 || !(gdklib
= w32_delayed_load (libraries
, Qgdk_pixbuf
))
8011 || !(library
= w32_delayed_load (libraries
, Qsvg
)))
8014 LOAD_IMGLIB_FN (library
, rsvg_handle_new
);
8015 LOAD_IMGLIB_FN (library
, rsvg_handle_get_dimensions
);
8016 LOAD_IMGLIB_FN (library
, rsvg_handle_write
);
8017 LOAD_IMGLIB_FN (library
, rsvg_handle_close
);
8018 LOAD_IMGLIB_FN (library
, rsvg_handle_get_pixbuf
);
8020 LOAD_IMGLIB_FN (gdklib
, gdk_pixbuf_get_width
);
8021 LOAD_IMGLIB_FN (gdklib
, gdk_pixbuf_get_height
);
8022 LOAD_IMGLIB_FN (gdklib
, gdk_pixbuf_get_pixels
);
8023 LOAD_IMGLIB_FN (gdklib
, gdk_pixbuf_get_rowstride
);
8024 LOAD_IMGLIB_FN (gdklib
, gdk_pixbuf_get_colorspace
);
8025 LOAD_IMGLIB_FN (gdklib
, gdk_pixbuf_get_n_channels
);
8026 LOAD_IMGLIB_FN (gdklib
, gdk_pixbuf_get_has_alpha
);
8027 LOAD_IMGLIB_FN (gdklib
, gdk_pixbuf_get_bits_per_sample
);
8029 LOAD_IMGLIB_FN (gobject
, g_type_init
);
8030 LOAD_IMGLIB_FN (gobject
, g_object_unref
);
8031 LOAD_IMGLIB_FN (glib
, g_error_free
);
8037 /* The following aliases for library functions allow dynamic loading
8038 to be used on some platforms. */
8039 #define fn_rsvg_handle_new rsvg_handle_new
8040 #define fn_rsvg_handle_get_dimensions rsvg_handle_get_dimensions
8041 #define fn_rsvg_handle_write rsvg_handle_write
8042 #define fn_rsvg_handle_close rsvg_handle_close
8043 #define fn_rsvg_handle_get_pixbuf rsvg_handle_get_pixbuf
8045 #define fn_gdk_pixbuf_get_width gdk_pixbuf_get_width
8046 #define fn_gdk_pixbuf_get_height gdk_pixbuf_get_height
8047 #define fn_gdk_pixbuf_get_pixels gdk_pixbuf_get_pixels
8048 #define fn_gdk_pixbuf_get_rowstride gdk_pixbuf_get_rowstride
8049 #define fn_gdk_pixbuf_get_colorspace gdk_pixbuf_get_colorspace
8050 #define fn_gdk_pixbuf_get_n_channels gdk_pixbuf_get_n_channels
8051 #define fn_gdk_pixbuf_get_has_alpha gdk_pixbuf_get_has_alpha
8052 #define fn_gdk_pixbuf_get_bits_per_sample gdk_pixbuf_get_bits_per_sample
8054 #define fn_g_type_init g_type_init
8055 #define fn_g_object_unref g_object_unref
8056 #define fn_g_error_free g_error_free
8057 #endif /* !HAVE_NTGUI */
8059 /* Load SVG image IMG for use on frame F. Value is non-zero if
8060 successful. this function will go into the svg_type structure, and
8061 the prototype thus needs to be compatible with that structure. */
8064 svg_load (struct frame
*f
, struct image
*img
)
8067 Lisp_Object file_name
;
8069 /* If IMG->spec specifies a file name, create a non-file spec from it. */
8070 file_name
= image_spec_value (img
->spec
, QCfile
, NULL
);
8071 if (STRINGP (file_name
))
8074 unsigned char *contents
;
8077 file
= x_find_image_file (file_name
);
8078 if (!STRINGP (file
))
8080 image_error ("Cannot find image file `%s'", file_name
, Qnil
);
8084 /* Read the entire file into memory. */
8085 contents
= slurp_file (SSDATA (file
), &size
);
8086 if (contents
== NULL
)
8088 image_error ("Error loading SVG image `%s'", img
->spec
, Qnil
);
8091 /* If the file was slurped into memory properly, parse it. */
8092 success_p
= svg_load_image (f
, img
, contents
, size
);
8095 /* Else its not a file, its a lisp object. Load the image from a
8096 lisp object rather than a file. */
8101 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
8102 if (!STRINGP (data
))
8104 image_error ("Invalid image data `%s'", data
, Qnil
);
8107 success_p
= svg_load_image (f
, img
, SDATA (data
), SBYTES (data
));
8113 /* svg_load_image is a helper function for svg_load, which does the
8114 actual loading given contents and size, apart from frame and image
8115 structures, passed from svg_load.
8117 Uses librsvg to do most of the image processing.
8119 Returns non-zero when successful. */
8121 svg_load_image (struct frame
*f
, /* Pointer to emacs frame structure. */
8122 struct image
*img
, /* Pointer to emacs image structure. */
8123 unsigned char *contents
, /* String containing the SVG XML data to be parsed. */
8124 ptrdiff_t size
) /* Size of data in bytes. */
8126 RsvgHandle
*rsvg_handle
;
8127 RsvgDimensionData dimension_data
;
8132 const guint8
*pixels
;
8135 Lisp_Object specified_bg
;
8140 /* g_type_init is a glib function that must be called prior to using
8141 gnome type library functions. */
8143 /* Make a handle to a new rsvg object. */
8144 rsvg_handle
= fn_rsvg_handle_new ();
8146 /* Parse the contents argument and fill in the rsvg_handle. */
8147 fn_rsvg_handle_write (rsvg_handle
, contents
, size
, &err
);
8148 if (err
) goto rsvg_error
;
8150 /* The parsing is complete, rsvg_handle is ready to used, close it
8151 for further writes. */
8152 fn_rsvg_handle_close (rsvg_handle
, &err
);
8153 if (err
) goto rsvg_error
;
8155 fn_rsvg_handle_get_dimensions (rsvg_handle
, &dimension_data
);
8156 if (! check_image_size (f
, dimension_data
.width
, dimension_data
.height
))
8158 image_error ("Invalid image size (see `max-image-size')", Qnil
, Qnil
);
8162 /* We can now get a valid pixel buffer from the svg file, if all
8164 pixbuf
= fn_rsvg_handle_get_pixbuf (rsvg_handle
);
8165 if (!pixbuf
) goto rsvg_error
;
8166 fn_g_object_unref (rsvg_handle
);
8168 /* Extract some meta data from the svg handle. */
8169 width
= fn_gdk_pixbuf_get_width (pixbuf
);
8170 height
= fn_gdk_pixbuf_get_height (pixbuf
);
8171 pixels
= fn_gdk_pixbuf_get_pixels (pixbuf
);
8172 rowstride
= fn_gdk_pixbuf_get_rowstride (pixbuf
);
8174 /* Validate the svg meta data. */
8175 eassert (fn_gdk_pixbuf_get_colorspace (pixbuf
) == GDK_COLORSPACE_RGB
);
8176 eassert (fn_gdk_pixbuf_get_n_channels (pixbuf
) == 4);
8177 eassert (fn_gdk_pixbuf_get_has_alpha (pixbuf
));
8178 eassert (fn_gdk_pixbuf_get_bits_per_sample (pixbuf
) == 8);
8180 /* Try to create a x pixmap to hold the svg pixmap. */
8181 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
8183 fn_g_object_unref (pixbuf
);
8187 init_color_table ();
8189 /* Handle alpha channel by combining the image with a background
8191 specified_bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
8192 if (!STRINGP (specified_bg
)
8193 || !x_defined_color (f
, SSDATA (specified_bg
), &background
, 0))
8196 background
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
8197 x_query_color (f
, &background
);
8199 ns_query_color (FRAME_BACKGROUND_COLOR (f
), &background
, 1);
8203 /* SVG pixmaps specify transparency in the last byte, so right
8204 shift 8 bits to get rid of it, since emacs doesn't support
8206 background
.red
>>= 8;
8207 background
.green
>>= 8;
8208 background
.blue
>>= 8;
8210 /* This loop handles opacity values, since Emacs assumes
8211 non-transparent images. Each pixel must be "flattened" by
8212 calculating the resulting color, given the transparency of the
8213 pixel, and the image background color. */
8214 for (y
= 0; y
< height
; ++y
)
8216 for (x
= 0; x
< width
; ++x
)
8226 opacity
= *pixels
++;
8228 red
= ((red
* opacity
)
8229 + (background
.red
* ((1 << 8) - opacity
)));
8230 green
= ((green
* opacity
)
8231 + (background
.green
* ((1 << 8) - opacity
)));
8232 blue
= ((blue
* opacity
)
8233 + (background
.blue
* ((1 << 8) - opacity
)));
8235 XPutPixel (ximg
, x
, y
, lookup_rgb_color (f
, red
, green
, blue
));
8238 pixels
+= rowstride
- 4 * width
;
8241 #ifdef COLOR_TABLE_SUPPORT
8242 /* Remember colors allocated for this image. */
8243 img
->colors
= colors_in_color_table (&img
->ncolors
);
8244 free_color_table ();
8245 #endif /* COLOR_TABLE_SUPPORT */
8247 fn_g_object_unref (pixbuf
);
8250 img
->height
= height
;
8252 /* Maybe fill in the background field while we have ximg handy.
8253 Casting avoids a GCC warning. */
8254 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
8256 /* Put the image into the pixmap, then free the X image and its
8258 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
8259 x_destroy_x_image (ximg
);
8264 fn_g_object_unref (rsvg_handle
);
8265 /* FIXME: Use error->message so the user knows what is the actual
8266 problem with the image. */
8267 image_error ("Error parsing SVG image `%s'", img
->spec
, Qnil
);
8268 fn_g_error_free (err
);
8272 #endif /* defined (HAVE_RSVG) */
8277 /***********************************************************************
8279 ***********************************************************************/
8281 #ifdef HAVE_X_WINDOWS
8282 #define HAVE_GHOSTSCRIPT 1
8283 #endif /* HAVE_X_WINDOWS */
8285 #ifdef HAVE_GHOSTSCRIPT
8287 static int gs_image_p (Lisp_Object object
);
8288 static int gs_load (struct frame
*f
, struct image
*img
);
8289 static void gs_clear_image (struct frame
*f
, struct image
*img
);
8291 /* Keyword symbols. */
8293 static Lisp_Object QCloader
, QCbounding_box
, QCpt_width
, QCpt_height
;
8295 /* Indices of image specification fields in gs_format, below. */
8297 enum gs_keyword_index
8315 /* Vector of image_keyword structures describing the format
8316 of valid user-defined image specifications. */
8318 static const struct image_keyword gs_format
[GS_LAST
] =
8320 {":type", IMAGE_SYMBOL_VALUE
, 1},
8321 {":pt-width", IMAGE_POSITIVE_INTEGER_VALUE
, 1},
8322 {":pt-height", IMAGE_POSITIVE_INTEGER_VALUE
, 1},
8323 {":file", IMAGE_STRING_VALUE
, 1},
8324 {":loader", IMAGE_FUNCTION_VALUE
, 0},
8325 {":bounding-box", IMAGE_DONT_CHECK_VALUE_TYPE
, 1},
8326 {":ascent", IMAGE_ASCENT_VALUE
, 0},
8327 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
8328 {":relief", IMAGE_INTEGER_VALUE
, 0},
8329 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8330 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8331 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8332 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
8335 /* Structure describing the image type `ghostscript'. */
8337 static struct image_type gs_type
=
8347 /* Free X resources of Ghostscript image IMG which is used on frame F. */
8350 gs_clear_image (struct frame
*f
, struct image
*img
)
8352 x_clear_image (f
, img
);
8356 /* Return non-zero if OBJECT is a valid Ghostscript image
8360 gs_image_p (Lisp_Object object
)
8362 struct image_keyword fmt
[GS_LAST
];
8366 memcpy (fmt
, gs_format
, sizeof fmt
);
8368 if (!parse_image_spec (object
, fmt
, GS_LAST
, Qpostscript
))
8371 /* Bounding box must be a list or vector containing 4 integers. */
8372 tem
= fmt
[GS_BOUNDING_BOX
].value
;
8375 for (i
= 0; i
< 4; ++i
, tem
= XCDR (tem
))
8376 if (!CONSP (tem
) || !INTEGERP (XCAR (tem
)))
8381 else if (VECTORP (tem
))
8383 if (ASIZE (tem
) != 4)
8385 for (i
= 0; i
< 4; ++i
)
8386 if (!INTEGERP (XVECTOR (tem
)->contents
[i
]))
8396 /* Load Ghostscript image IMG for use on frame F. Value is non-zero
8400 gs_load (struct frame
*f
, struct image
*img
)
8403 Lisp_Object window_and_pixmap_id
= Qnil
, loader
, pt_height
, pt_width
;
8405 double in_width
, in_height
;
8406 Lisp_Object pixel_colors
= Qnil
;
8408 /* Compute pixel size of pixmap needed from the given size in the
8409 image specification. Sizes in the specification are in pt. 1 pt
8410 = 1/72 in, xdpi and ydpi are stored in the frame's X display
8412 pt_width
= image_spec_value (img
->spec
, QCpt_width
, NULL
);
8413 in_width
= INTEGERP (pt_width
) ? XFASTINT (pt_width
) / 72.0 : 0;
8414 img
->width
= in_width
* FRAME_X_DISPLAY_INFO (f
)->resx
;
8415 pt_height
= image_spec_value (img
->spec
, QCpt_height
, NULL
);
8416 in_height
= INTEGERP (pt_height
) ? XFASTINT (pt_height
) / 72.0 : 0;
8417 img
->height
= in_height
* FRAME_X_DISPLAY_INFO (f
)->resy
;
8419 if (!check_image_size (f
, img
->width
, img
->height
))
8421 image_error ("Invalid image size (see `max-image-size')", Qnil
, Qnil
);
8425 /* Create the pixmap. */
8426 xassert (img
->pixmap
== NO_PIXMAP
);
8428 /* Only W32 version did BLOCK_INPUT here. ++kfs */
8430 img
->pixmap
= XCreatePixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
8431 img
->width
, img
->height
,
8432 DefaultDepthOfScreen (FRAME_X_SCREEN (f
)));
8437 image_error ("Unable to create pixmap for `%s'", img
->spec
, Qnil
);
8441 /* Call the loader to fill the pixmap. It returns a process object
8442 if successful. We do not record_unwind_protect here because
8443 other places in redisplay like calling window scroll functions
8444 don't either. Let the Lisp loader use `unwind-protect' instead. */
8445 sprintf (buffer
, "%lu %lu",
8446 (unsigned long) FRAME_X_WINDOW (f
),
8447 (unsigned long) img
->pixmap
);
8448 window_and_pixmap_id
= build_string (buffer
);
8450 sprintf (buffer
, "%lu %lu",
8451 FRAME_FOREGROUND_PIXEL (f
),
8452 FRAME_BACKGROUND_PIXEL (f
));
8453 pixel_colors
= build_string (buffer
);
8455 XSETFRAME (frame
, f
);
8456 loader
= image_spec_value (img
->spec
, QCloader
, NULL
);
8458 loader
= intern ("gs-load-image");
8460 img
->lisp_data
= call6 (loader
, frame
, img
->spec
,
8461 make_number (img
->width
),
8462 make_number (img
->height
),
8463 window_and_pixmap_id
,
8465 return PROCESSP (img
->lisp_data
);
8469 /* Kill the Ghostscript process that was started to fill PIXMAP on
8470 frame F. Called from XTread_socket when receiving an event
8471 telling Emacs that Ghostscript has finished drawing. */
8474 x_kill_gs_process (Pixmap pixmap
, struct frame
*f
)
8476 struct image_cache
*c
= FRAME_IMAGE_CACHE (f
);
8480 /* Find the image containing PIXMAP. */
8481 for (i
= 0; i
< c
->used
; ++i
)
8482 if (c
->images
[i
]->pixmap
== pixmap
)
8485 /* Should someone in between have cleared the image cache, for
8486 instance, give up. */
8490 /* Kill the GS process. We should have found PIXMAP in the image
8491 cache and its image should contain a process object. */
8493 xassert (PROCESSP (img
->lisp_data
));
8494 Fkill_process (img
->lisp_data
, Qnil
);
8495 img
->lisp_data
= Qnil
;
8497 #if defined (HAVE_X_WINDOWS)
8499 /* On displays with a mutable colormap, figure out the colors
8500 allocated for the image by looking at the pixels of an XImage for
8502 class = FRAME_X_VISUAL (f
)->class;
8503 if (class != StaticColor
&& class != StaticGray
&& class != TrueColor
)
8509 /* Try to get an XImage for img->pixmep. */
8510 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
8511 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
8516 /* Initialize the color table. */
8517 init_color_table ();
8519 /* For each pixel of the image, look its color up in the
8520 color table. After having done so, the color table will
8521 contain an entry for each color used by the image. */
8522 for (y
= 0; y
< img
->height
; ++y
)
8523 for (x
= 0; x
< img
->width
; ++x
)
8525 unsigned long pixel
= XGetPixel (ximg
, x
, y
);
8526 lookup_pixel_color (f
, pixel
);
8529 /* Record colors in the image. Free color table and XImage. */
8530 #ifdef COLOR_TABLE_SUPPORT
8531 img
->colors
= colors_in_color_table (&img
->ncolors
);
8532 free_color_table ();
8534 XDestroyImage (ximg
);
8536 #if 0 /* This doesn't seem to be the case. If we free the colors
8537 here, we get a BadAccess later in x_clear_image when
8538 freeing the colors. */
8539 /* We have allocated colors once, but Ghostscript has also
8540 allocated colors on behalf of us. So, to get the
8541 reference counts right, free them once. */
8543 x_free_colors (f
, img
->colors
, img
->ncolors
);
8547 image_error ("Cannot get X image of `%s'; colors will not be freed",
8552 #endif /* HAVE_X_WINDOWS */
8554 /* Now that we have the pixmap, compute mask and transform the
8555 image if requested. */
8557 postprocess_image (f
, img
);
8561 #endif /* HAVE_GHOSTSCRIPT */
8564 /***********************************************************************
8566 ***********************************************************************/
8570 DEFUN ("imagep", Fimagep
, Simagep
, 1, 1, 0,
8571 doc
: /* Value is non-nil if SPEC is a valid image specification. */)
8574 return valid_image_p (spec
) ? Qt
: Qnil
;
8578 DEFUN ("lookup-image", Flookup_image
, Slookup_image
, 1, 1, 0, "")
8583 if (valid_image_p (spec
))
8584 id
= lookup_image (SELECTED_FRAME (), spec
);
8587 return make_number (id
);
8590 #endif /* GLYPH_DEBUG != 0 */
8593 /***********************************************************************
8595 ***********************************************************************/
8598 /* Image types that rely on external libraries are loaded dynamically
8599 if the library is available. */
8600 #define CHECK_LIB_AVAILABLE(image_type, init_lib_fn, libraries) \
8601 define_image_type (image_type, init_lib_fn (libraries))
8603 #define CHECK_LIB_AVAILABLE(image_type, init_lib_fn, libraries) \
8604 define_image_type (image_type, 1)
8605 #endif /* HAVE_NTGUI */
8607 DEFUN ("init-image-library", Finit_image_library
, Sinit_image_library
, 2, 2, 0,
8608 doc
: /* Initialize image library implementing image type TYPE.
8609 Return non-nil if TYPE is a supported image type.
8611 Image types pbm and xbm are prebuilt; other types are loaded here.
8612 Libraries to load are specified in alist LIBRARIES (usually, the value
8613 of `dynamic-library-alist', which see). */)
8614 (Lisp_Object type
, Lisp_Object libraries
)
8617 /* Don't try to reload the library. */
8618 Lisp_Object tested
= Fassq (type
, Vlibrary_cache
);
8620 return XCDR (tested
);
8623 /* Types pbm and xbm are built-in and always available. */
8624 if (EQ (type
, Qpbm
) || EQ (type
, Qxbm
))
8627 #if defined (HAVE_XPM) || defined (HAVE_NS)
8628 if (EQ (type
, Qxpm
))
8629 return CHECK_LIB_AVAILABLE (&xpm_type
, init_xpm_functions
, libraries
);
8632 #if defined (HAVE_JPEG) || defined (HAVE_NS)
8633 if (EQ (type
, Qjpeg
))
8634 return CHECK_LIB_AVAILABLE (&jpeg_type
, init_jpeg_functions
, libraries
);
8637 #if defined (HAVE_TIFF) || defined (HAVE_NS)
8638 if (EQ (type
, Qtiff
))
8639 return CHECK_LIB_AVAILABLE (&tiff_type
, init_tiff_functions
, libraries
);
8642 #if defined (HAVE_GIF) || defined (HAVE_NS)
8643 if (EQ (type
, Qgif
))
8644 return CHECK_LIB_AVAILABLE (&gif_type
, init_gif_functions
, libraries
);
8647 #if defined (HAVE_PNG) || defined (HAVE_NS)
8648 if (EQ (type
, Qpng
))
8649 return CHECK_LIB_AVAILABLE (&png_type
, init_png_functions
, libraries
);
8652 #if defined (HAVE_RSVG)
8653 if (EQ (type
, Qsvg
))
8654 return CHECK_LIB_AVAILABLE (&svg_type
, init_svg_functions
, libraries
);
8657 #if defined (HAVE_IMAGEMAGICK)
8658 if (EQ (type
, Qimagemagick
))
8659 return CHECK_LIB_AVAILABLE (&imagemagick_type
, init_imagemagick_functions
,
8663 #ifdef HAVE_GHOSTSCRIPT
8664 if (EQ (type
, Qpostscript
))
8665 return CHECK_LIB_AVAILABLE (&gs_type
, init_gs_functions
, libraries
);
8668 /* If the type is not recognized, avoid testing it ever again. */
8669 CACHE_IMAGE_TYPE (type
, Qnil
);
8674 syms_of_image (void)
8676 /* Initialize this only once, since that's what we do with Vimage_types
8677 and they are supposed to be in sync. Initializing here gives correct
8678 operation on GNU/Linux of calling dump-emacs after loading some images. */
8681 /* Must be defined now becase we're going to update it below, while
8682 defining the supported image types. */
8683 DEFVAR_LISP ("image-types", Vimage_types
,
8684 doc
: /* List of potentially supported image types.
8685 Each element of the list is a symbol for an image type, like 'jpeg or 'png.
8686 To check whether it is really supported, use `image-type-available-p'. */);
8687 Vimage_types
= Qnil
;
8689 DEFVAR_LISP ("max-image-size", Vmax_image_size
,
8690 doc
: /* Maximum size of images.
8691 Emacs will not load an image into memory if its pixel width or
8692 pixel height exceeds this limit.
8694 If the value is an integer, it directly specifies the maximum
8695 image height and width, measured in pixels. If it is a floating
8696 point number, it specifies the maximum image height and width
8697 as a ratio to the frame height and width. If the value is
8698 non-numeric, there is no explicit limit on the size of images. */);
8699 Vmax_image_size
= make_float (MAX_IMAGE_SIZE
);
8701 DEFSYM (Qpbm
, "pbm");
8702 ADD_IMAGE_TYPE (Qpbm
);
8704 DEFSYM (Qxbm
, "xbm");
8705 ADD_IMAGE_TYPE (Qxbm
);
8707 define_image_type (&xbm_type
, 1);
8708 define_image_type (&pbm_type
, 1);
8710 DEFSYM (Qcount
, "count");
8711 DEFSYM (Qextension_data
, "extension-data");
8712 DEFSYM (Qdelay
, "delay");
8714 DEFSYM (QCascent
, ":ascent");
8715 DEFSYM (QCmargin
, ":margin");
8716 DEFSYM (QCrelief
, ":relief");
8717 DEFSYM (QCconversion
, ":conversion");
8718 DEFSYM (QCcolor_symbols
, ":color-symbols");
8719 DEFSYM (QCheuristic_mask
, ":heuristic-mask");
8720 DEFSYM (QCindex
, ":index");
8721 DEFSYM (QCgeometry
, ":geometry");
8722 DEFSYM (QCcrop
, ":crop");
8723 DEFSYM (QCrotation
, ":rotation");
8724 DEFSYM (QCmatrix
, ":matrix");
8725 DEFSYM (QCcolor_adjustment
, ":color-adjustment");
8726 DEFSYM (QCmask
, ":mask");
8728 DEFSYM (Qlaplace
, "laplace");
8729 DEFSYM (Qemboss
, "emboss");
8730 DEFSYM (Qedge_detection
, "edge-detection");
8731 DEFSYM (Qheuristic
, "heuristic");
8733 DEFSYM (Qpostscript
, "postscript");
8734 #ifdef HAVE_GHOSTSCRIPT
8735 ADD_IMAGE_TYPE (Qpostscript
);
8736 DEFSYM (QCloader
, ":loader");
8737 DEFSYM (QCbounding_box
, ":bounding-box");
8738 DEFSYM (QCpt_width
, ":pt-width");
8739 DEFSYM (QCpt_height
, ":pt-height");
8740 #endif /* HAVE_GHOSTSCRIPT */
8743 DEFSYM (Qlibpng_version
, "libpng-version");
8744 Fset (Qlibpng_version
,
8746 make_number (PNG_LIBPNG_VER
)
8753 #if defined (HAVE_XPM) || defined (HAVE_NS)
8754 DEFSYM (Qxpm
, "xpm");
8755 ADD_IMAGE_TYPE (Qxpm
);
8758 #if defined (HAVE_JPEG) || defined (HAVE_NS)
8759 DEFSYM (Qjpeg
, "jpeg");
8760 ADD_IMAGE_TYPE (Qjpeg
);
8763 #if defined (HAVE_TIFF) || defined (HAVE_NS)
8764 DEFSYM (Qtiff
, "tiff");
8765 ADD_IMAGE_TYPE (Qtiff
);
8768 #if defined (HAVE_GIF) || defined (HAVE_NS)
8769 DEFSYM (Qgif
, "gif");
8770 ADD_IMAGE_TYPE (Qgif
);
8773 #if defined (HAVE_PNG) || defined (HAVE_NS)
8774 DEFSYM (Qpng
, "png");
8775 ADD_IMAGE_TYPE (Qpng
);
8778 #if defined (HAVE_IMAGEMAGICK)
8779 DEFSYM (Qimagemagick
, "imagemagick");
8780 ADD_IMAGE_TYPE (Qimagemagick
);
8783 #if defined (HAVE_RSVG)
8784 DEFSYM (Qsvg
, "svg");
8785 ADD_IMAGE_TYPE (Qsvg
);
8787 /* Other libraries used directly by svg code. */
8788 DEFSYM (Qgdk_pixbuf
, "gdk-pixbuf");
8789 DEFSYM (Qglib
, "glib");
8790 DEFSYM (Qgobject
, "gobject");
8791 #endif /* HAVE_NTGUI */
8792 #endif /* HAVE_RSVG */
8794 defsubr (&Sinit_image_library
);
8795 #ifdef HAVE_IMAGEMAGICK
8796 defsubr (&Simagemagick_types
);
8798 defsubr (&Sclear_image_cache
);
8799 defsubr (&Simage_flush
);
8800 defsubr (&Simage_size
);
8801 defsubr (&Simage_mask_p
);
8802 defsubr (&Simage_metadata
);
8806 defsubr (&Slookup_image
);
8809 DEFVAR_BOOL ("cross-disabled-images", cross_disabled_images
,
8810 doc
: /* Non-nil means always draw a cross over disabled images.
8811 Disabled images are those having a `:conversion disabled' property.
8812 A cross is always drawn on black & white displays. */);
8813 cross_disabled_images
= 0;
8815 DEFVAR_LISP ("x-bitmap-file-path", Vx_bitmap_file_path
,
8816 doc
: /* List of directories to search for window system bitmap files. */);
8817 Vx_bitmap_file_path
= decode_env_path ((char *) 0, PATH_BITMAPS
);
8819 DEFVAR_LISP ("image-cache-eviction-delay", Vimage_cache_eviction_delay
,
8820 doc
: /* Maximum time after which images are removed from the cache.
8821 When an image has not been displayed this many seconds, Emacs
8822 automatically removes it from the image cache. If the cache contains
8823 a large number of images, the actual eviction time may be shorter.
8824 The value can also be nil, meaning the cache is never cleared.
8826 The function `clear-image-cache' disregards this variable. */);
8827 Vimage_cache_eviction_delay
= make_number (300);
8828 #ifdef HAVE_IMAGEMAGICK
8829 DEFVAR_LISP ("imagemagick-render-type", Vimagemagick_render_type
,
8830 doc
: /* Choose between ImageMagick render methods. */);