1 /* Functions for image support on window system.
2 Copyright (C) 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
20 Boston, MA 02110-1301, USA. */
31 /* This makes the fields of a Display accessible, in Xlib header files. */
33 #define XLIB_ILLEGAL_ACCESS
38 #include "dispextern.h"
39 #include "blockinput.h"
48 #include <sys/types.h>
51 #define COLOR_TABLE_SUPPORT 1
53 typedef struct x_bitmap_record Bitmap_Record
;
54 #define GET_PIXEL(ximg, x, y) XGetPixel(ximg, x, y)
55 #define NO_PIXMAP None
57 #define RGB_PIXEL_COLOR unsigned long
59 #define PIX_MASK_RETAIN 0
60 #define PIX_MASK_DRAW 1
61 #endif /* HAVE_X_WINDOWS */
67 /* W32_TODO : Color tables on W32. */
68 #undef COLOR_TABLE_SUPPORT
70 typedef struct w32_bitmap_record Bitmap_Record
;
71 #define GET_PIXEL(ximg, x, y) GetPixel(ximg, x, y)
74 #define RGB_PIXEL_COLOR COLORREF
76 #define PIX_MASK_RETAIN 0
77 #define PIX_MASK_DRAW 1
79 #define FRAME_X_VISUAL(f) FRAME_X_DISPLAY_INFO (f)->visual
80 #define x_defined_color w32_defined_color
81 #define DefaultDepthOfScreen(screen) (one_w32_display_info.n_cbits)
82 #endif /* HAVE_NTGUI */
90 #include <sys/param.h>
92 #if TARGET_API_MAC_CARBON
94 #include <QuickTime/QuickTime.h>
95 #else /* not MAC_OSX */
96 #include <QuickTime.h>
97 #endif /* not MAC_OSX */
98 #else /* not TARGET_API_MAC_CARBON */
101 #include <TextUtils.h>
102 #include <ImageCompression.h>
103 #include <QuickTimeComponents.h>
104 #endif /* not TARGET_API_MAC_CARBON */
106 /* MAC_TODO : Color tables on Mac. */
107 #undef COLOR_TABLE_SUPPORT
109 #define ZPixmap 0 /* arbitrary */
110 typedef struct mac_bitmap_record Bitmap_Record
;
112 #define GET_PIXEL(ximg, x, y) XGetPixel(ximg, x, y)
115 #define RGB_PIXEL_COLOR unsigned long
117 /* A black pixel in a mask bitmap/pixmap means ``draw a source
118 pixel''. A white pixel means ``retain the current pixel''. */
119 #define PIX_MASK_DRAW RGB_TO_ULONG(0,0,0)
120 #define PIX_MASK_RETAIN RGB_TO_ULONG(255,255,255)
122 #define FRAME_X_VISUAL(f) FRAME_X_DISPLAY_INFO (f)->visual
123 #define x_defined_color mac_defined_color
124 #define DefaultDepthOfScreen(screen) (one_mac_display_info.n_planes)
129 /* Search path for bitmap files. */
131 Lisp_Object Vx_bitmap_file_path
;
134 static void x_disable_image
P_ ((struct frame
*, struct image
*));
135 static void x_edge_detection
P_ ((struct frame
*, struct image
*, Lisp_Object
,
138 static void init_color_table
P_ ((void));
139 static unsigned long lookup_rgb_color
P_ ((struct frame
*f
, int r
, int g
, int b
));
140 #ifdef COLOR_TABLE_SUPPORT
141 static void free_color_table
P_ ((void));
142 static unsigned long *colors_in_color_table
P_ ((int *n
));
143 static unsigned long lookup_pixel_color
P_ ((struct frame
*f
, unsigned long p
));
146 /* Code to deal with bitmaps. Bitmaps are referenced by their bitmap
147 id, which is just an int that this section returns. Bitmaps are
148 reference counted so they can be shared among frames.
150 Bitmap indices are guaranteed to be > 0, so a negative number can
151 be used to indicate no bitmap.
153 If you use x_create_bitmap_from_data, then you must keep track of
154 the bitmaps yourself. That is, creating a bitmap from the same
155 data more than once will not be caught. */
160 XGetImage (display
, pixmap
, x
, y
, width
, height
, plane_mask
, format
)
161 Display
*display
; /* not used */
163 int x
, y
; /* not used */
164 unsigned int width
, height
; /* not used */
165 unsigned long plane_mask
; /* not used */
166 int format
; /* not used */
169 xassert (x
== 0 && y
== 0);
172 SetRect (&ri
, 0, 0, width
, height
);
173 xassert (EqualRect (&ri
, GetPixBounds (GetGWorldPixMap (pixmap
), &rp
)));
175 xassert (! (pixelsLocked
& GetPixelsState (GetGWorldPixMap (pixmap
))));
178 LockPixels (GetGWorldPixMap (pixmap
));
184 XPutPixel (ximage
, x
, y
, pixel
)
189 PixMapHandle pixmap
= GetGWorldPixMap (ximage
);
190 short depth
= GetPixDepth (pixmap
);
192 #if defined (WORDS_BIG_ENDIAN) || !USE_CG_DRAWING
195 char *base_addr
= GetPixBaseAddr (pixmap
);
196 short row_bytes
= GetPixRowBytes (pixmap
);
198 ((unsigned long *) (base_addr
+ y
* row_bytes
))[x
] = 0xff000000 | pixel
;
204 char *base_addr
= GetPixBaseAddr (pixmap
);
205 short row_bytes
= GetPixRowBytes (pixmap
);
207 if (pixel
== PIX_MASK_DRAW
)
208 base_addr
[y
* row_bytes
+ x
/ 8] |= (1 << 7) >> (x
& 7);
210 base_addr
[y
* row_bytes
+ x
/ 8] &= ~((1 << 7) >> (x
& 7));
218 GetGWorld (&old_port
, &old_gdh
);
219 SetGWorld (ximage
, NULL
);
221 color
.red
= RED16_FROM_ULONG (pixel
);
222 color
.green
= GREEN16_FROM_ULONG (pixel
);
223 color
.blue
= BLUE16_FROM_ULONG (pixel
);
225 SetCPixel (x
, y
, &color
);
227 SetGWorld (old_port
, old_gdh
);
232 XGetPixel (ximage
, x
, y
)
236 PixMapHandle pixmap
= GetGWorldPixMap (ximage
);
237 short depth
= GetPixDepth (pixmap
);
239 #if defined (WORDS_BIG_ENDIAN) || !USE_CG_DRAWING
242 char *base_addr
= GetPixBaseAddr (pixmap
);
243 short row_bytes
= GetPixRowBytes (pixmap
);
245 return ((unsigned long *) (base_addr
+ y
* row_bytes
))[x
] & 0x00ffffff;
251 char *base_addr
= GetPixBaseAddr (pixmap
);
252 short row_bytes
= GetPixRowBytes (pixmap
);
254 if (base_addr
[y
* row_bytes
+ x
/ 8] & (1 << (~x
& 7)))
255 return PIX_MASK_DRAW
;
257 return PIX_MASK_RETAIN
;
265 GetGWorld (&old_port
, &old_gdh
);
266 SetGWorld (ximage
, NULL
);
268 GetCPixel (x
, y
, &color
);
270 SetGWorld (old_port
, old_gdh
);
271 return RGB_TO_ULONG (color
.red
>> 8, color
.green
>> 8, color
.blue
>> 8);
279 UnlockPixels (GetGWorldPixMap (ximg
));
284 mac_create_cg_image_from_image (f
, img
)
289 CGImageRef result
= NULL
;
296 mask
= XCreatePixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
297 img
->width
, img
->height
, 1);
304 GetGWorld (&old_port
, &old_gdh
);
305 SetGWorld (mask
, NULL
);
306 BackColor (blackColor
); /* Don't mask. */
307 SetRect (&r
, 0, 0, img
->width
, img
->height
);
309 SetGWorld (old_port
, old_gdh
);
314 CreateCGImageFromPixMaps (GetGWorldPixMap (img
->pixmap
),
315 GetGWorldPixMap (mask
), &result
);
316 if (mask
!= img
->mask
)
317 XFreePixmap (FRAME_X_DISPLAY (f
), mask
);
323 #endif /* USE_CG_DRAWING */
327 /* Functions to access the contents of a bitmap, given an id. */
330 x_bitmap_height (f
, id
)
334 return FRAME_X_DISPLAY_INFO (f
)->bitmaps
[id
- 1].height
;
338 x_bitmap_width (f
, id
)
342 return FRAME_X_DISPLAY_INFO (f
)->bitmaps
[id
- 1].width
;
345 #if defined (HAVE_X_WINDOWS) || defined (HAVE_NTGUI)
347 x_bitmap_pixmap (f
, id
)
351 return (int) FRAME_X_DISPLAY_INFO (f
)->bitmaps
[id
- 1].pixmap
;
355 #ifdef HAVE_X_WINDOWS
357 x_bitmap_mask (f
, id
)
361 return FRAME_X_DISPLAY_INFO (f
)->bitmaps
[id
- 1].mask
;
365 /* Allocate a new bitmap record. Returns index of new record. */
368 x_allocate_bitmap_record (f
)
371 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
374 if (dpyinfo
->bitmaps
== NULL
)
376 dpyinfo
->bitmaps_size
= 10;
378 = (Bitmap_Record
*) xmalloc (dpyinfo
->bitmaps_size
* sizeof (Bitmap_Record
));
379 dpyinfo
->bitmaps_last
= 1;
383 if (dpyinfo
->bitmaps_last
< dpyinfo
->bitmaps_size
)
384 return ++dpyinfo
->bitmaps_last
;
386 for (i
= 0; i
< dpyinfo
->bitmaps_size
; ++i
)
387 if (dpyinfo
->bitmaps
[i
].refcount
== 0)
390 dpyinfo
->bitmaps_size
*= 2;
392 = (Bitmap_Record
*) xrealloc (dpyinfo
->bitmaps
,
393 dpyinfo
->bitmaps_size
* sizeof (Bitmap_Record
));
394 return ++dpyinfo
->bitmaps_last
;
397 /* Add one reference to the reference count of the bitmap with id ID. */
400 x_reference_bitmap (f
, id
)
404 ++FRAME_X_DISPLAY_INFO (f
)->bitmaps
[id
- 1].refcount
;
407 /* Create a bitmap for frame F from a HEIGHT x WIDTH array of bits at BITS. */
410 x_create_bitmap_from_data (f
, bits
, width
, height
)
413 unsigned int width
, height
;
415 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
418 #ifdef HAVE_X_WINDOWS
420 bitmap
= XCreateBitmapFromData (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
421 bits
, width
, height
);
424 #endif /* HAVE_X_WINDOWS */
428 bitmap
= CreateBitmap (width
, height
,
429 FRAME_X_DISPLAY_INFO (XFRAME (frame
))->n_planes
,
430 FRAME_X_DISPLAY_INFO (XFRAME (frame
))->n_cbits
,
434 #endif /* HAVE_NTGUI */
437 /* MAC_TODO: for now fail if width is not mod 16 (toolbox requires it) */
442 id
= x_allocate_bitmap_record (f
);
444 dpyinfo
->bitmaps
[id
- 1].bitmap_data
= (char *) xmalloc (height
* width
);
445 bcopy (bits
, dpyinfo
->bitmaps
[id
- 1].bitmap_data
, height
* width
);
448 dpyinfo
->bitmaps
[id
- 1].file
= NULL
;
449 dpyinfo
->bitmaps
[id
- 1].height
= height
;
450 dpyinfo
->bitmaps
[id
- 1].width
= width
;
451 dpyinfo
->bitmaps
[id
- 1].refcount
= 1;
453 #ifdef HAVE_X_WINDOWS
454 dpyinfo
->bitmaps
[id
- 1].pixmap
= bitmap
;
455 dpyinfo
->bitmaps
[id
- 1].have_mask
= 0;
456 dpyinfo
->bitmaps
[id
- 1].depth
= 1;
457 #endif /* HAVE_X_WINDOWS */
460 dpyinfo
->bitmaps
[id
- 1].pixmap
= bitmap
;
461 dpyinfo
->bitmaps
[id
- 1].hinst
= NULL
;
462 dpyinfo
->bitmaps
[id
- 1].depth
= 1;
463 #endif /* HAVE_NTGUI */
468 /* Create bitmap from file FILE for frame F. */
471 x_create_bitmap_from_file (f
, file
)
476 return -1; /* MAC_TODO : bitmap support */
480 return -1; /* W32_TODO : bitmap support */
481 #endif /* HAVE_NTGUI */
483 #ifdef HAVE_X_WINDOWS
484 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
485 unsigned int width
, height
;
487 int xhot
, yhot
, result
, id
;
492 /* Look for an existing bitmap with the same name. */
493 for (id
= 0; id
< dpyinfo
->bitmaps_last
; ++id
)
495 if (dpyinfo
->bitmaps
[id
].refcount
496 && dpyinfo
->bitmaps
[id
].file
497 && !strcmp (dpyinfo
->bitmaps
[id
].file
, (char *) SDATA (file
)))
499 ++dpyinfo
->bitmaps
[id
].refcount
;
504 /* Search bitmap-file-path for the file, if appropriate. */
505 fd
= openp (Vx_bitmap_file_path
, file
, Qnil
, &found
, Qnil
);
510 filename
= (char *) SDATA (found
);
512 result
= XReadBitmapFile (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
513 filename
, &width
, &height
, &bitmap
, &xhot
, &yhot
);
514 if (result
!= BitmapSuccess
)
517 id
= x_allocate_bitmap_record (f
);
518 dpyinfo
->bitmaps
[id
- 1].pixmap
= bitmap
;
519 dpyinfo
->bitmaps
[id
- 1].have_mask
= 0;
520 dpyinfo
->bitmaps
[id
- 1].refcount
= 1;
521 dpyinfo
->bitmaps
[id
- 1].file
= (char *) xmalloc (SBYTES (file
) + 1);
522 dpyinfo
->bitmaps
[id
- 1].depth
= 1;
523 dpyinfo
->bitmaps
[id
- 1].height
= height
;
524 dpyinfo
->bitmaps
[id
- 1].width
= width
;
525 strcpy (dpyinfo
->bitmaps
[id
- 1].file
, SDATA (file
));
528 #endif /* HAVE_X_WINDOWS */
534 Free_Bitmap_Record (dpyinfo
, bm
)
535 Display_Info
*dpyinfo
;
538 #ifdef HAVE_X_WINDOWS
539 XFreePixmap (dpyinfo
->display
, bm
->pixmap
);
541 XFreePixmap (dpyinfo
->display
, bm
->mask
);
542 #endif /* HAVE_X_WINDOWS */
545 DeleteObject (bm
->pixmap
);
546 #endif /* HAVE_NTGUI */
549 xfree (bm
->bitmap_data
); /* Added ++kfs */
550 bm
->bitmap_data
= NULL
;
560 /* Remove reference to bitmap with id number ID. */
563 x_destroy_bitmap (f
, id
)
567 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
571 Bitmap_Record
*bm
= &dpyinfo
->bitmaps
[id
- 1];
573 if (--bm
->refcount
== 0)
576 Free_Bitmap_Record (dpyinfo
, bm
);
582 /* Free all the bitmaps for the display specified by DPYINFO. */
585 x_destroy_all_bitmaps (dpyinfo
)
586 Display_Info
*dpyinfo
;
589 Bitmap_Record
*bm
= dpyinfo
->bitmaps
;
591 for (i
= 0; i
< dpyinfo
->bitmaps_last
; i
++, bm
++)
592 if (bm
->refcount
> 0)
593 Free_Bitmap_Record (dpyinfo
, bm
);
595 dpyinfo
->bitmaps_last
= 0;
599 #ifdef HAVE_X_WINDOWS
601 /* Useful functions defined in the section
602 `Image type independent image structures' below. */
604 static unsigned long four_corners_best
P_ ((XImagePtr ximg
,
607 unsigned long height
));
609 static int x_create_x_image_and_pixmap
P_ ((struct frame
*f
, int width
, int height
,
610 int depth
, XImagePtr
*ximg
,
613 static void x_destroy_x_image
P_ ((XImagePtr ximg
));
616 /* Create a mask of a bitmap. Note is this not a perfect mask.
617 It's nicer with some borders in this context */
620 x_create_bitmap_mask (f
, id
)
625 XImagePtr ximg
, mask_img
;
626 unsigned long width
, height
;
629 unsigned long x
, y
, xp
, xm
, yp
, ym
;
632 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
637 pixmap
= x_bitmap_pixmap (f
, id
);
638 width
= x_bitmap_width (f
, id
);
639 height
= x_bitmap_height (f
, id
);
642 ximg
= XGetImage (FRAME_X_DISPLAY (f
), pixmap
, 0, 0, width
, height
,
651 result
= x_create_x_image_and_pixmap (f
, width
, height
, 1, &mask_img
, &mask
);
656 XDestroyImage (ximg
);
660 bg
= four_corners_best (ximg
, NULL
, width
, height
);
662 for (y
= 0; y
< ximg
->height
; ++y
)
664 for (x
= 0; x
< ximg
->width
; ++x
)
666 xp
= x
!= ximg
->width
- 1 ? x
+ 1 : 0;
667 xm
= x
!= 0 ? x
- 1 : ximg
->width
- 1;
668 yp
= y
!= ximg
->height
- 1 ? y
+ 1 : 0;
669 ym
= y
!= 0 ? y
- 1 : ximg
->height
- 1;
670 if (XGetPixel (ximg
, x
, y
) == bg
671 && XGetPixel (ximg
, x
, yp
) == bg
672 && XGetPixel (ximg
, x
, ym
) == bg
673 && XGetPixel (ximg
, xp
, y
) == bg
674 && XGetPixel (ximg
, xp
, yp
) == bg
675 && XGetPixel (ximg
, xp
, ym
) == bg
676 && XGetPixel (ximg
, xm
, y
) == bg
677 && XGetPixel (ximg
, xm
, yp
) == bg
678 && XGetPixel (ximg
, xm
, ym
) == bg
)
679 XPutPixel (mask_img
, x
, y
, 0);
681 XPutPixel (mask_img
, x
, y
, 1);
685 xassert (interrupt_input_blocked
);
686 gc
= XCreateGC (FRAME_X_DISPLAY (f
), mask
, 0, NULL
);
687 XPutImage (FRAME_X_DISPLAY (f
), mask
, gc
, mask_img
, 0, 0, 0, 0,
689 XFreeGC (FRAME_X_DISPLAY (f
), gc
);
691 dpyinfo
->bitmaps
[id
- 1].have_mask
= 1;
692 dpyinfo
->bitmaps
[id
- 1].mask
= mask
;
694 XDestroyImage (ximg
);
695 x_destroy_x_image (mask_img
);
700 #endif /* HAVE_X_WINDOWS */
703 /***********************************************************************
705 ***********************************************************************/
707 /* Value is the number of elements of vector VECTOR. */
709 #define DIM(VECTOR) (sizeof (VECTOR) / sizeof *(VECTOR))
711 /* List of supported image types. Use define_image_type to add new
712 types. Use lookup_image_type to find a type for a given symbol. */
714 static struct image_type
*image_types
;
716 /* A list of symbols, one for each supported image type. */
718 Lisp_Object Vimage_types
;
720 /* An alist of image types and libraries that implement the type. */
722 Lisp_Object Vimage_library_alist
;
724 /* Cache for delayed-loading image types. */
726 static Lisp_Object Vimage_type_cache
;
728 /* The symbol `xbm' which is used as the type symbol for XBM images. */
734 extern Lisp_Object QCwidth
, QCheight
, QCforeground
, QCbackground
, QCfile
;
735 extern Lisp_Object QCdata
, QCtype
, Qcount
;
736 extern Lisp_Object Qcenter
;
737 Lisp_Object QCascent
, QCmargin
, QCrelief
;
738 Lisp_Object QCconversion
, QCcolor_symbols
, QCheuristic_mask
;
739 Lisp_Object QCindex
, QCmatrix
, QCcolor_adjustment
, QCmask
;
743 Lisp_Object Qlaplace
, Qemboss
, Qedge_detection
, Qheuristic
;
745 /* Time in seconds after which images should be removed from the cache
748 Lisp_Object Vimage_cache_eviction_delay
;
750 /* Function prototypes. */
752 static Lisp_Object define_image_type
P_ ((struct image_type
*type
, int loaded
));
753 static struct image_type
*lookup_image_type
P_ ((Lisp_Object symbol
));
754 static void image_error
P_ ((char *format
, Lisp_Object
, Lisp_Object
));
755 static void x_laplace
P_ ((struct frame
*, struct image
*));
756 static void x_emboss
P_ ((struct frame
*, struct image
*));
757 static int x_build_heuristic_mask
P_ ((struct frame
*, struct image
*,
760 #define CACHE_IMAGE_TYPE(type, status) \
761 do { Vimage_type_cache = Fcons (Fcons (type, status), Vimage_type_cache); } while (0)
763 #define ADD_IMAGE_TYPE(type) \
764 do { Vimage_types = Fcons (type, Vimage_types); } while (0)
766 /* Define a new image type from TYPE. This adds a copy of TYPE to
767 image_types and caches the loading status of TYPE. */
770 define_image_type (type
, loaded
)
771 struct image_type
*type
;
780 /* Make a copy of TYPE to avoid a bus error in a dumped Emacs.
781 The initialized data segment is read-only. */
782 struct image_type
*p
= (struct image_type
*) xmalloc (sizeof *p
);
783 bcopy (type
, p
, sizeof *p
);
784 p
->next
= image_types
;
789 CACHE_IMAGE_TYPE (*type
->type
, success
);
794 /* Look up image type SYMBOL, and return a pointer to its image_type
795 structure. Value is null if SYMBOL is not a known image type. */
797 static INLINE
struct image_type
*
798 lookup_image_type (symbol
)
801 struct image_type
*type
;
803 /* We must initialize the image-type if it hasn't been already. */
804 if (NILP (Finit_image_library (symbol
, Vimage_library_alist
)))
805 return 0; /* unimplemented */
807 for (type
= image_types
; type
; type
= type
->next
)
808 if (EQ (symbol
, *type
->type
))
815 /* Value is non-zero if OBJECT is a valid Lisp image specification. A
816 valid image specification is a list whose car is the symbol
817 `image', and whose rest is a property list. The property list must
818 contain a value for key `:type'. That value must be the name of a
819 supported image type. The rest of the property list depends on the
823 valid_image_p (object
)
832 for (tem
= XCDR (object
); CONSP (tem
); tem
= XCDR (tem
))
833 if (EQ (XCAR (tem
), QCtype
))
836 if (CONSP (tem
) && SYMBOLP (XCAR (tem
)))
838 struct image_type
*type
;
839 type
= lookup_image_type (XCAR (tem
));
841 valid_p
= type
->valid_p (object
);
852 /* Log error message with format string FORMAT and argument ARG.
853 Signaling an error, e.g. when an image cannot be loaded, is not a
854 good idea because this would interrupt redisplay, and the error
855 message display would lead to another redisplay. This function
856 therefore simply displays a message. */
859 image_error (format
, arg1
, arg2
)
861 Lisp_Object arg1
, arg2
;
863 add_to_log (format
, arg1
, arg2
);
868 /***********************************************************************
870 ***********************************************************************/
872 enum image_value_type
874 IMAGE_DONT_CHECK_VALUE_TYPE
,
876 IMAGE_STRING_OR_NIL_VALUE
,
878 IMAGE_POSITIVE_INTEGER_VALUE
,
879 IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
,
880 IMAGE_NON_NEGATIVE_INTEGER_VALUE
,
883 IMAGE_FUNCTION_VALUE
,
888 /* Structure used when parsing image specifications. */
892 /* Name of keyword. */
895 /* The type of value allowed. */
896 enum image_value_type type
;
898 /* Non-zero means key must be present. */
901 /* Used to recognize duplicate keywords in a property list. */
904 /* The value that was found. */
909 static int parse_image_spec
P_ ((Lisp_Object
, struct image_keyword
*,
911 static Lisp_Object image_spec_value
P_ ((Lisp_Object
, Lisp_Object
, int *));
914 /* Parse image spec SPEC according to KEYWORDS. A valid image spec
915 has the format (image KEYWORD VALUE ...). One of the keyword/
916 value pairs must be `:type TYPE'. KEYWORDS is a vector of
917 image_keywords structures of size NKEYWORDS describing other
918 allowed keyword/value pairs. Value is non-zero if SPEC is valid. */
921 parse_image_spec (spec
, keywords
, nkeywords
, type
)
923 struct image_keyword
*keywords
;
934 while (CONSP (plist
))
936 Lisp_Object key
, value
;
938 /* First element of a pair must be a symbol. */
940 plist
= XCDR (plist
);
944 /* There must follow a value. */
947 value
= XCAR (plist
);
948 plist
= XCDR (plist
);
950 /* Find key in KEYWORDS. Error if not found. */
951 for (i
= 0; i
< nkeywords
; ++i
)
952 if (strcmp (keywords
[i
].name
, SDATA (SYMBOL_NAME (key
))) == 0)
958 /* Record that we recognized the keyword. If a keywords
959 was found more than once, it's an error. */
960 keywords
[i
].value
= value
;
963 if (keywords
[i
].count
> 1)
966 /* Check type of value against allowed type. */
967 switch (keywords
[i
].type
)
969 case IMAGE_STRING_VALUE
:
970 if (!STRINGP (value
))
974 case IMAGE_STRING_OR_NIL_VALUE
:
975 if (!STRINGP (value
) && !NILP (value
))
979 case IMAGE_SYMBOL_VALUE
:
980 if (!SYMBOLP (value
))
984 case IMAGE_POSITIVE_INTEGER_VALUE
:
985 if (!INTEGERP (value
) || XINT (value
) <= 0)
989 case IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
:
990 if (INTEGERP (value
) && XINT (value
) >= 0)
993 && INTEGERP (XCAR (value
)) && INTEGERP (XCDR (value
))
994 && XINT (XCAR (value
)) >= 0 && XINT (XCDR (value
)) >= 0)
998 case IMAGE_ASCENT_VALUE
:
999 if (SYMBOLP (value
) && EQ (value
, Qcenter
))
1001 else if (INTEGERP (value
)
1002 && XINT (value
) >= 0
1003 && XINT (value
) <= 100)
1007 case IMAGE_NON_NEGATIVE_INTEGER_VALUE
:
1008 if (!INTEGERP (value
) || XINT (value
) < 0)
1012 case IMAGE_DONT_CHECK_VALUE_TYPE
:
1015 case IMAGE_FUNCTION_VALUE
:
1016 value
= indirect_function (value
);
1018 || COMPILEDP (value
)
1019 || (CONSP (value
) && EQ (XCAR (value
), Qlambda
)))
1023 case IMAGE_NUMBER_VALUE
:
1024 if (!INTEGERP (value
) && !FLOATP (value
))
1028 case IMAGE_INTEGER_VALUE
:
1029 if (!INTEGERP (value
))
1033 case IMAGE_BOOL_VALUE
:
1034 if (!NILP (value
) && !EQ (value
, Qt
))
1043 if (EQ (key
, QCtype
) && !EQ (type
, value
))
1047 /* Check that all mandatory fields are present. */
1048 for (i
= 0; i
< nkeywords
; ++i
)
1049 if (keywords
[i
].mandatory_p
&& keywords
[i
].count
== 0)
1052 return NILP (plist
);
1056 /* Return the value of KEY in image specification SPEC. Value is nil
1057 if KEY is not present in SPEC. if FOUND is not null, set *FOUND
1058 to 1 if KEY was found in SPEC, set it to 0 otherwise. */
1061 image_spec_value (spec
, key
, found
)
1062 Lisp_Object spec
, key
;
1067 xassert (valid_image_p (spec
));
1069 for (tail
= XCDR (spec
);
1070 CONSP (tail
) && CONSP (XCDR (tail
));
1071 tail
= XCDR (XCDR (tail
)))
1073 if (EQ (XCAR (tail
), key
))
1077 return XCAR (XCDR (tail
));
1087 DEFUN ("image-size", Fimage_size
, Simage_size
, 1, 3, 0,
1088 doc
: /* Return the size of image SPEC as pair (WIDTH . HEIGHT).
1089 PIXELS non-nil means return the size in pixels, otherwise return the
1090 size in canonical character units.
1091 FRAME is the frame on which the image will be displayed. FRAME nil
1092 or omitted means use the selected frame. */)
1093 (spec
, pixels
, frame
)
1094 Lisp_Object spec
, pixels
, frame
;
1099 if (valid_image_p (spec
))
1101 struct frame
*f
= check_x_frame (frame
);
1102 int id
= lookup_image (f
, spec
);
1103 struct image
*img
= IMAGE_FROM_ID (f
, id
);
1104 int width
= img
->width
+ 2 * img
->hmargin
;
1105 int height
= img
->height
+ 2 * img
->vmargin
;
1108 size
= Fcons (make_float ((double) width
/ FRAME_COLUMN_WIDTH (f
)),
1109 make_float ((double) height
/ FRAME_LINE_HEIGHT (f
)));
1111 size
= Fcons (make_number (width
), make_number (height
));
1114 error ("Invalid image specification");
1120 DEFUN ("image-mask-p", Fimage_mask_p
, Simage_mask_p
, 1, 2, 0,
1121 doc
: /* Return t if image SPEC has a mask bitmap.
1122 FRAME is the frame on which the image will be displayed. FRAME nil
1123 or omitted means use the selected frame. */)
1125 Lisp_Object spec
, frame
;
1130 if (valid_image_p (spec
))
1132 struct frame
*f
= check_x_frame (frame
);
1133 int id
= lookup_image (f
, spec
);
1134 struct image
*img
= IMAGE_FROM_ID (f
, id
);
1139 error ("Invalid image specification");
1144 DEFUN ("image-extension-data", Fimage_extension_data
, Simage_extension_data
, 1, 2, 0,
1145 doc
: /* Return extension data for image SPEC.
1146 FRAME is the frame on which the image will be displayed. FRAME nil
1147 or omitted means use the selected frame. */)
1149 Lisp_Object spec
, frame
;
1154 if (valid_image_p (spec
))
1156 struct frame
*f
= check_x_frame (frame
);
1157 int id
= lookup_image (f
, spec
);
1158 struct image
*img
= IMAGE_FROM_ID (f
, id
);
1159 ext
= img
->data
.lisp_val
;
1166 /***********************************************************************
1167 Image type independent image structures
1168 ***********************************************************************/
1170 static struct image
*make_image
P_ ((Lisp_Object spec
, unsigned hash
));
1171 static void free_image
P_ ((struct frame
*f
, struct image
*img
));
1172 static int check_image_size
P_ ((struct frame
*f
, int width
, int height
));
1174 #define MAX_IMAGE_SIZE 6.0
1175 Lisp_Object Vmax_image_size
;
1177 /* Allocate and return a new image structure for image specification
1178 SPEC. SPEC has a hash value of HASH. */
1180 static struct image
*
1181 make_image (spec
, hash
)
1185 struct image
*img
= (struct image
*) xmalloc (sizeof *img
);
1187 xassert (valid_image_p (spec
));
1188 bzero (img
, sizeof *img
);
1189 img
->type
= lookup_image_type (image_spec_value (spec
, QCtype
, NULL
));
1190 xassert (img
->type
!= NULL
);
1192 img
->data
.lisp_val
= Qnil
;
1193 img
->ascent
= DEFAULT_IMAGE_ASCENT
;
1195 img
->corners
[BOT_CORNER
] = -1; /* Full image */
1200 /* Free image IMG which was used on frame F, including its resources. */
1209 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
1211 /* Remove IMG from the hash table of its cache. */
1213 img
->prev
->next
= img
->next
;
1215 c
->buckets
[img
->hash
% IMAGE_CACHE_BUCKETS_SIZE
] = img
->next
;
1218 img
->next
->prev
= img
->prev
;
1220 c
->images
[img
->id
] = NULL
;
1222 /* Free resources, then free IMG. */
1223 img
->type
->free (f
, img
);
1228 /* Return 1 if the given widths and heights are valid for display;
1229 otherwise, return 0. */
1232 check_image_size (f
, width
, height
)
1239 if (width
<= 0 || height
<= 0)
1242 if (INTEGERP (Vmax_image_size
))
1243 w
= h
= XINT (Vmax_image_size
);
1244 else if (FLOATP (Vmax_image_size
))
1248 w
= FRAME_PIXEL_WIDTH (f
);
1249 h
= FRAME_PIXEL_HEIGHT (f
);
1252 w
= h
= 1024; /* Arbitrary size for unknown frame. */
1253 w
= (int) (XFLOAT_DATA (Vmax_image_size
) * w
);
1254 h
= (int) (XFLOAT_DATA (Vmax_image_size
) * h
);
1259 return (width
<= w
&& height
<= h
);
1262 /* Prepare image IMG for display on frame F. Must be called before
1263 drawing an image. */
1266 prepare_image_for_display (f
, img
)
1272 /* We're about to display IMG, so set its timestamp to `now'. */
1274 img
->timestamp
= EMACS_SECS (t
);
1276 /* If IMG doesn't have a pixmap yet, load it now, using the image
1277 type dependent loader function. */
1278 if (img
->pixmap
== NO_PIXMAP
&& !img
->load_failed_p
)
1279 img
->load_failed_p
= img
->type
->load (f
, img
) == 0;
1281 #if defined (MAC_OS) && USE_CG_DRAWING
1282 if (!img
->load_failed_p
&& img
->data
.ptr_val
== NULL
)
1284 img
->data
.ptr_val
= mac_create_cg_image_from_image (f
, img
);
1285 if (img
->data
.ptr_val
== NULL
)
1287 img
->load_failed_p
= 1;
1288 img
->type
->free (f
, img
);
1295 /* Value is the number of pixels for the ascent of image IMG when
1296 drawn in face FACE. */
1299 image_ascent (img
, face
, slice
)
1302 struct glyph_slice
*slice
;
1307 if (slice
->height
== img
->height
)
1308 height
= img
->height
+ img
->vmargin
;
1309 else if (slice
->y
== 0)
1310 height
= slice
->height
+ img
->vmargin
;
1312 height
= slice
->height
;
1314 if (img
->ascent
== CENTERED_IMAGE_ASCENT
)
1319 /* W32 specific version. Why?. ++kfs */
1320 ascent
= height
/ 2 - (FONT_DESCENT(face
->font
)
1321 - FONT_BASE(face
->font
)) / 2;
1323 /* This expression is arranged so that if the image can't be
1324 exactly centered, it will be moved slightly up. This is
1325 because a typical font is `top-heavy' (due to the presence
1326 uppercase letters), so the image placement should err towards
1327 being top-heavy too. It also just generally looks better. */
1328 ascent
= (height
+ face
->font
->ascent
- face
->font
->descent
+ 1) / 2;
1329 #endif /* HAVE_NTGUI */
1332 ascent
= height
/ 2;
1335 ascent
= (int) (height
* img
->ascent
/ 100.0);
1341 /* Image background colors. */
1343 /* Find the "best" corner color of a bitmap.
1344 On W32, XIMG is assumed to a device context with the bitmap selected. */
1346 static RGB_PIXEL_COLOR
1347 four_corners_best (ximg
, corners
, width
, height
)
1348 XImagePtr_or_DC ximg
;
1350 unsigned long width
, height
;
1352 RGB_PIXEL_COLOR corner_pixels
[4], best
;
1355 if (corners
&& corners
[BOT_CORNER
] >= 0)
1357 /* Get the colors at the corner_pixels of ximg. */
1358 corner_pixels
[0] = GET_PIXEL (ximg
, corners
[LEFT_CORNER
], corners
[TOP_CORNER
]);
1359 corner_pixels
[1] = GET_PIXEL (ximg
, corners
[RIGHT_CORNER
] - 1, corners
[TOP_CORNER
]);
1360 corner_pixels
[2] = GET_PIXEL (ximg
, corners
[RIGHT_CORNER
] - 1, corners
[BOT_CORNER
] - 1);
1361 corner_pixels
[3] = GET_PIXEL (ximg
, corners
[LEFT_CORNER
], corners
[BOT_CORNER
] - 1);
1365 /* Get the colors at the corner_pixels of ximg. */
1366 corner_pixels
[0] = GET_PIXEL (ximg
, 0, 0);
1367 corner_pixels
[1] = GET_PIXEL (ximg
, width
- 1, 0);
1368 corner_pixels
[2] = GET_PIXEL (ximg
, width
- 1, height
- 1);
1369 corner_pixels
[3] = GET_PIXEL (ximg
, 0, height
- 1);
1371 /* Choose the most frequently found color as background. */
1372 for (i
= best_count
= 0; i
< 4; ++i
)
1376 for (j
= n
= 0; j
< 4; ++j
)
1377 if (corner_pixels
[i
] == corner_pixels
[j
])
1381 best
= corner_pixels
[i
], best_count
= n
;
1387 /* Portability macros */
1391 #define Destroy_Image(img_dc, prev) \
1392 do { SelectObject (img_dc, prev); DeleteDC (img_dc); } while (0)
1394 #define Free_Pixmap(display, pixmap) \
1395 DeleteObject (pixmap)
1399 #define Destroy_Image(ximg, dummy) \
1400 XDestroyImage (ximg)
1402 #define Free_Pixmap(display, pixmap) \
1403 XFreePixmap (display, pixmap)
1405 #endif /* HAVE_NTGUI */
1408 /* Return the `background' field of IMG. If IMG doesn't have one yet,
1409 it is guessed heuristically. If non-zero, XIMG is an existing
1410 XImage object (or device context with the image selected on W32) to
1411 use for the heuristic. */
1414 image_background (img
, f
, ximg
)
1417 XImagePtr_or_DC ximg
;
1419 if (! img
->background_valid
)
1420 /* IMG doesn't have a background yet, try to guess a reasonable value. */
1422 int free_ximg
= !ximg
;
1425 #endif /* HAVE_NTGUI */
1430 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
1431 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
1433 HDC frame_dc
= get_frame_dc (f
);
1434 ximg
= CreateCompatibleDC (frame_dc
);
1435 release_frame_dc (f
, frame_dc
);
1436 prev
= SelectObject (ximg
, img
->pixmap
);
1437 #endif /* !HAVE_NTGUI */
1440 img
->background
= four_corners_best (ximg
, img
->corners
, img
->width
, img
->height
);
1443 Destroy_Image (ximg
, prev
);
1445 img
->background_valid
= 1;
1448 return img
->background
;
1451 /* Return the `background_transparent' field of IMG. If IMG doesn't
1452 have one yet, it is guessed heuristically. If non-zero, MASK is an
1453 existing XImage object to use for the heuristic. */
1456 image_background_transparent (img
, f
, mask
)
1459 XImagePtr_or_DC mask
;
1461 if (! img
->background_transparent_valid
)
1462 /* IMG doesn't have a background yet, try to guess a reasonable value. */
1466 int free_mask
= !mask
;
1469 #endif /* HAVE_NTGUI */
1474 mask
= XGetImage (FRAME_X_DISPLAY (f
), img
->mask
,
1475 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
1477 HDC frame_dc
= get_frame_dc (f
);
1478 mask
= CreateCompatibleDC (frame_dc
);
1479 release_frame_dc (f
, frame_dc
);
1480 prev
= SelectObject (mask
, img
->mask
);
1481 #endif /* HAVE_NTGUI */
1484 img
->background_transparent
1485 = (four_corners_best (mask
, img
->corners
, img
->width
, img
->height
) == PIX_MASK_RETAIN
);
1488 Destroy_Image (mask
, prev
);
1491 img
->background_transparent
= 0;
1493 img
->background_transparent_valid
= 1;
1496 return img
->background_transparent
;
1500 /***********************************************************************
1501 Helper functions for X image types
1502 ***********************************************************************/
1504 static void x_clear_image_1
P_ ((struct frame
*, struct image
*, int,
1506 static void x_clear_image
P_ ((struct frame
*f
, struct image
*img
));
1507 static unsigned long x_alloc_image_color
P_ ((struct frame
*f
,
1509 Lisp_Object color_name
,
1510 unsigned long dflt
));
1513 /* Clear X resources of image IMG on frame F. PIXMAP_P non-zero means
1514 free the pixmap if any. MASK_P non-zero means clear the mask
1515 pixmap if any. COLORS_P non-zero means free colors allocated for
1516 the image, if any. */
1519 x_clear_image_1 (f
, img
, pixmap_p
, mask_p
, colors_p
)
1522 int pixmap_p
, mask_p
, colors_p
;
1524 if (pixmap_p
&& img
->pixmap
)
1526 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->pixmap
);
1527 img
->pixmap
= NO_PIXMAP
;
1528 img
->background_valid
= 0;
1531 if (mask_p
&& img
->mask
)
1533 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
1534 img
->mask
= NO_PIXMAP
;
1535 img
->background_transparent_valid
= 0;
1538 if (colors_p
&& img
->ncolors
)
1540 /* MAC_TODO: color table support. */
1541 /* W32_TODO: color table support. */
1542 #ifdef HAVE_X_WINDOWS
1543 x_free_colors (f
, img
->colors
, img
->ncolors
);
1544 #endif /* HAVE_X_WINDOWS */
1545 xfree (img
->colors
);
1550 #if defined (MAC_OS) && USE_CG_DRAWING
1551 if (img
->data
.ptr_val
)
1553 CGImageRelease (img
->data
.ptr_val
);
1554 img
->data
.ptr_val
= NULL
;
1559 /* Free X resources of image IMG which is used on frame F. */
1562 x_clear_image (f
, img
)
1567 x_clear_image_1 (f
, img
, 1, 1, 1);
1572 /* Allocate color COLOR_NAME for image IMG on frame F. If color
1573 cannot be allocated, use DFLT. Add a newly allocated color to
1574 IMG->colors, so that it can be freed again. Value is the pixel
1577 static unsigned long
1578 x_alloc_image_color (f
, img
, color_name
, dflt
)
1581 Lisp_Object color_name
;
1585 unsigned long result
;
1587 xassert (STRINGP (color_name
));
1589 if (x_defined_color (f
, SDATA (color_name
), &color
, 1))
1591 /* This isn't called frequently so we get away with simply
1592 reallocating the color vector to the needed size, here. */
1595 (unsigned long *) xrealloc (img
->colors
,
1596 img
->ncolors
* sizeof *img
->colors
);
1597 img
->colors
[img
->ncolors
- 1] = color
.pixel
;
1598 result
= color
.pixel
;
1608 /***********************************************************************
1610 ***********************************************************************/
1612 static struct image
*search_image_cache
P_ ((struct frame
*, Lisp_Object
, unsigned));
1613 static void cache_image
P_ ((struct frame
*f
, struct image
*img
));
1614 static void postprocess_image
P_ ((struct frame
*, struct image
*));
1616 /* Return a new, initialized image cache that is allocated from the
1617 heap. Call free_image_cache to free an image cache. */
1619 struct image_cache
*
1622 struct image_cache
*c
= (struct image_cache
*) xmalloc (sizeof *c
);
1625 bzero (c
, sizeof *c
);
1627 c
->images
= (struct image
**) xmalloc (c
->size
* sizeof *c
->images
);
1628 size
= IMAGE_CACHE_BUCKETS_SIZE
* sizeof *c
->buckets
;
1629 c
->buckets
= (struct image
**) xmalloc (size
);
1630 bzero (c
->buckets
, size
);
1635 /* Find an image matching SPEC in the cache, and return it. If no
1636 image is found, return NULL. */
1637 static struct image
*
1638 search_image_cache (f
, spec
, hash
)
1644 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
1645 int i
= hash
% IMAGE_CACHE_BUCKETS_SIZE
;
1647 /* If the image spec does not specify a background color, the cached
1648 image must have the same background color as the current frame.
1649 The foreground color must also match, for the sake of monochrome
1652 In fact, we could ignore the foreground color matching condition
1653 for color images, or if the image spec specifies :foreground;
1654 similarly we could ignore the background color matching condition
1655 for formats that don't use transparency (such as jpeg), or if the
1656 image spec specifies :background. However, the extra memory
1657 usage is probably negligible in practice, so we don't bother. */
1658 if (!c
) return NULL
;
1660 for (img
= c
->buckets
[i
]; img
; img
= img
->next
)
1661 if (img
->hash
== hash
1662 && !NILP (Fequal (img
->spec
, spec
))
1663 /* If the image spec specifies a background, it doesn't matter
1664 what the frame background is. */
1665 && img
->frame_foreground
== FRAME_FOREGROUND_PIXEL (f
)
1666 && img
->frame_background
== FRAME_BACKGROUND_PIXEL (f
))
1672 /* Search frame F for an image with spec SPEC, and free it. */
1675 uncache_image (f
, spec
)
1679 struct image
*img
= search_image_cache (f
, spec
, sxhash (spec
, 0));
1681 free_image (f
, img
);
1685 /* Free image cache of frame F. Be aware that X frames share images
1689 free_image_cache (f
)
1692 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
1697 /* Cache should not be referenced by any frame when freed. */
1698 xassert (c
->refcount
== 0);
1700 for (i
= 0; i
< c
->used
; ++i
)
1701 free_image (f
, c
->images
[i
]);
1705 FRAME_X_IMAGE_CACHE (f
) = NULL
;
1710 /* Clear image cache of frame F. FORCE_P non-zero means free all
1711 images. FORCE_P zero means clear only images that haven't been
1712 displayed for some time. Should be called from time to time to
1713 reduce the number of loaded images. If image-eviction-seconds is
1714 non-nil, this frees images in the cache which weren't displayed for
1715 at least that many seconds. */
1718 clear_image_cache (f
, force_p
)
1722 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
1724 if (c
&& INTEGERP (Vimage_cache_eviction_delay
))
1731 old
= EMACS_SECS (t
) - XFASTINT (Vimage_cache_eviction_delay
);
1733 /* Block input so that we won't be interrupted by a SIGIO
1734 while being in an inconsistent state. */
1737 for (i
= nfreed
= 0; i
< c
->used
; ++i
)
1739 struct image
*img
= c
->images
[i
];
1741 && (force_p
|| img
->timestamp
< old
))
1743 free_image (f
, img
);
1748 /* We may be clearing the image cache because, for example,
1749 Emacs was iconified for a longer period of time. In that
1750 case, current matrices may still contain references to
1751 images freed above. So, clear these matrices. */
1754 Lisp_Object tail
, frame
;
1756 FOR_EACH_FRAME (tail
, frame
)
1758 struct frame
*f
= XFRAME (frame
);
1759 if (FRAME_WINDOW_P (f
)
1760 && FRAME_X_IMAGE_CACHE (f
) == c
)
1761 clear_current_matrices (f
);
1764 ++windows_or_buffers_changed
;
1772 DEFUN ("clear-image-cache", Fclear_image_cache
, Sclear_image_cache
,
1774 doc
: /* Clear the image cache of FRAME.
1775 FRAME nil or omitted means use the selected frame.
1776 FRAME t means clear the image caches of all frames. */)
1784 FOR_EACH_FRAME (tail
, frame
)
1785 if (FRAME_WINDOW_P (XFRAME (frame
)))
1786 clear_image_cache (XFRAME (frame
), 1);
1789 clear_image_cache (check_x_frame (frame
), 1);
1795 DEFUN ("image-refresh", Fimage_refresh
, Simage_refresh
,
1797 doc
: /* Refresh the image with specification SPEC on frame FRAME.
1798 If SPEC specifies an image file, the displayed image is updated with
1799 the current contents of that file.
1800 FRAME nil or omitted means use the selected frame.
1801 FRAME t means refresh the image on all frames. */)
1803 Lisp_Object spec
, frame
;
1805 if (!valid_image_p (spec
))
1806 error ("Invalid image specification");
1811 FOR_EACH_FRAME (tail
, frame
)
1813 struct frame
*f
= XFRAME (frame
);
1814 if (FRAME_WINDOW_P (f
))
1815 uncache_image (f
, spec
);
1819 uncache_image (check_x_frame (frame
), spec
);
1825 /* Compute masks and transform image IMG on frame F, as specified
1826 by the image's specification, */
1829 postprocess_image (f
, img
)
1833 /* Manipulation of the image's mask. */
1836 Lisp_Object conversion
, spec
;
1841 /* `:heuristic-mask t'
1843 means build a mask heuristically.
1844 `:heuristic-mask (R G B)'
1845 `:mask (heuristic (R G B))'
1846 means build a mask from color (R G B) in the
1849 means remove a mask, if any. */
1851 mask
= image_spec_value (spec
, QCheuristic_mask
, NULL
);
1853 x_build_heuristic_mask (f
, img
, mask
);
1858 mask
= image_spec_value (spec
, QCmask
, &found_p
);
1860 if (EQ (mask
, Qheuristic
))
1861 x_build_heuristic_mask (f
, img
, Qt
);
1862 else if (CONSP (mask
)
1863 && EQ (XCAR (mask
), Qheuristic
))
1865 if (CONSP (XCDR (mask
)))
1866 x_build_heuristic_mask (f
, img
, XCAR (XCDR (mask
)));
1868 x_build_heuristic_mask (f
, img
, XCDR (mask
));
1870 else if (NILP (mask
) && found_p
&& img
->mask
)
1872 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
1873 img
->mask
= NO_PIXMAP
;
1878 /* Should we apply an image transformation algorithm? */
1879 conversion
= image_spec_value (spec
, QCconversion
, NULL
);
1880 if (EQ (conversion
, Qdisabled
))
1881 x_disable_image (f
, img
);
1882 else if (EQ (conversion
, Qlaplace
))
1884 else if (EQ (conversion
, Qemboss
))
1886 else if (CONSP (conversion
)
1887 && EQ (XCAR (conversion
), Qedge_detection
))
1890 tem
= XCDR (conversion
);
1892 x_edge_detection (f
, img
,
1893 Fplist_get (tem
, QCmatrix
),
1894 Fplist_get (tem
, QCcolor_adjustment
));
1900 /* Return the id of image with Lisp specification SPEC on frame F.
1901 SPEC must be a valid Lisp image specification (see valid_image_p). */
1904 lookup_image (f
, spec
)
1908 struct image_cache
*c
;
1911 struct gcpro gcpro1
;
1914 /* F must be a window-system frame, and SPEC must be a valid image
1916 xassert (FRAME_WINDOW_P (f
));
1917 xassert (valid_image_p (spec
));
1919 c
= FRAME_X_IMAGE_CACHE (f
);
1923 /* Look up SPEC in the hash table of the image cache. */
1924 hash
= sxhash (spec
, 0);
1925 img
= search_image_cache (f
, spec
, hash
);
1926 if (img
&& img
->load_failed_p
)
1928 free_image (f
, img
);
1932 /* If not found, create a new image and cache it. */
1935 extern Lisp_Object Qpostscript
;
1938 img
= make_image (spec
, hash
);
1939 cache_image (f
, img
);
1940 img
->load_failed_p
= img
->type
->load (f
, img
) == 0;
1941 img
->frame_foreground
= FRAME_FOREGROUND_PIXEL (f
);
1942 img
->frame_background
= FRAME_BACKGROUND_PIXEL (f
);
1944 /* If we can't load the image, and we don't have a width and
1945 height, use some arbitrary width and height so that we can
1946 draw a rectangle for it. */
1947 if (img
->load_failed_p
)
1951 value
= image_spec_value (spec
, QCwidth
, NULL
);
1952 img
->width
= (INTEGERP (value
)
1953 ? XFASTINT (value
) : DEFAULT_IMAGE_WIDTH
);
1954 value
= image_spec_value (spec
, QCheight
, NULL
);
1955 img
->height
= (INTEGERP (value
)
1956 ? XFASTINT (value
) : DEFAULT_IMAGE_HEIGHT
);
1960 /* Handle image type independent image attributes
1961 `:ascent ASCENT', `:margin MARGIN', `:relief RELIEF',
1962 `:background COLOR'. */
1963 Lisp_Object ascent
, margin
, relief
, bg
;
1965 ascent
= image_spec_value (spec
, QCascent
, NULL
);
1966 if (INTEGERP (ascent
))
1967 img
->ascent
= XFASTINT (ascent
);
1968 else if (EQ (ascent
, Qcenter
))
1969 img
->ascent
= CENTERED_IMAGE_ASCENT
;
1971 margin
= image_spec_value (spec
, QCmargin
, NULL
);
1972 if (INTEGERP (margin
) && XINT (margin
) >= 0)
1973 img
->vmargin
= img
->hmargin
= XFASTINT (margin
);
1974 else if (CONSP (margin
) && INTEGERP (XCAR (margin
))
1975 && INTEGERP (XCDR (margin
)))
1977 if (XINT (XCAR (margin
)) > 0)
1978 img
->hmargin
= XFASTINT (XCAR (margin
));
1979 if (XINT (XCDR (margin
)) > 0)
1980 img
->vmargin
= XFASTINT (XCDR (margin
));
1983 relief
= image_spec_value (spec
, QCrelief
, NULL
);
1984 if (INTEGERP (relief
))
1986 img
->relief
= XINT (relief
);
1987 img
->hmargin
+= abs (img
->relief
);
1988 img
->vmargin
+= abs (img
->relief
);
1991 if (! img
->background_valid
)
1993 bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
1997 = x_alloc_image_color (f
, img
, bg
,
1998 FRAME_BACKGROUND_PIXEL (f
));
1999 img
->background_valid
= 1;
2003 /* Do image transformations and compute masks, unless we
2004 don't have the image yet. */
2005 if (!EQ (*img
->type
->type
, Qpostscript
))
2006 postprocess_image (f
, img
);
2012 /* We're using IMG, so set its timestamp to `now'. */
2013 EMACS_GET_TIME (now
);
2014 img
->timestamp
= EMACS_SECS (now
);
2018 /* Value is the image id. */
2023 /* Cache image IMG in the image cache of frame F. */
2026 cache_image (f
, img
)
2030 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
2033 /* Find a free slot in c->images. */
2034 for (i
= 0; i
< c
->used
; ++i
)
2035 if (c
->images
[i
] == NULL
)
2038 /* If no free slot found, maybe enlarge c->images. */
2039 if (i
== c
->used
&& c
->used
== c
->size
)
2042 c
->images
= (struct image
**) xrealloc (c
->images
,
2043 c
->size
* sizeof *c
->images
);
2046 /* Add IMG to c->images, and assign IMG an id. */
2052 /* Add IMG to the cache's hash table. */
2053 i
= img
->hash
% IMAGE_CACHE_BUCKETS_SIZE
;
2054 img
->next
= c
->buckets
[i
];
2056 img
->next
->prev
= img
;
2058 c
->buckets
[i
] = img
;
2062 /* Call FN on every image in the image cache of frame F. Used to mark
2063 Lisp Objects in the image cache. */
2066 forall_images_in_image_cache (f
, fn
)
2068 void (*fn
) P_ ((struct image
*img
));
2070 if (FRAME_LIVE_P (f
) && FRAME_WINDOW_P (f
))
2072 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
2076 for (i
= 0; i
< c
->used
; ++i
)
2085 /***********************************************************************
2086 X / MAC / W32 support code
2087 ***********************************************************************/
2091 /* Macro for defining functions that will be loaded from image DLLs. */
2092 #define DEF_IMGLIB_FN(func) int (FAR CDECL *fn_##func)()
2094 /* Macro for loading those image functions from the library. */
2095 #define LOAD_IMGLIB_FN(lib,func) { \
2096 fn_##func = (void *) GetProcAddress (lib, #func); \
2097 if (!fn_##func) return 0; \
2100 /* Load a DLL implementing an image type.
2101 The `image-library-alist' variable associates a symbol,
2102 identifying an image type, to a list of possible filenames.
2103 The function returns NULL if no library could be loaded for
2104 the given image type, or if the library was previously loaded;
2105 else the handle of the DLL. */
2107 w32_delayed_load (Lisp_Object libraries
, Lisp_Object type
)
2109 HMODULE library
= NULL
;
2111 if (CONSP (libraries
) && NILP (Fassq (type
, Vimage_type_cache
)))
2113 Lisp_Object dlls
= Fassq (type
, libraries
);
2116 for (dlls
= XCDR (dlls
); CONSP (dlls
); dlls
= XCDR (dlls
))
2118 CHECK_STRING_CAR (dlls
);
2119 if (library
= LoadLibrary (SDATA (XCAR (dlls
))))
2127 #endif /* HAVE_NTGUI */
2129 static int x_create_x_image_and_pixmap
P_ ((struct frame
*, int, int, int,
2130 XImagePtr
*, Pixmap
*));
2131 static void x_destroy_x_image
P_ ((XImagePtr
));
2132 static void x_put_x_image
P_ ((struct frame
*, XImagePtr
, Pixmap
, int, int));
2135 /* Create an XImage and a pixmap of size WIDTH x HEIGHT for use on
2136 frame F. Set *XIMG and *PIXMAP to the XImage and Pixmap created.
2137 Set (*XIMG)->data to a raster of WIDTH x HEIGHT pixels allocated
2138 via xmalloc. Print error messages via image_error if an error
2139 occurs. Value is non-zero if successful.
2141 On W32, a DEPTH of zero signifies a 24 bit image, otherwise DEPTH
2142 should indicate the bit depth of the image. */
2145 x_create_x_image_and_pixmap (f
, width
, height
, depth
, ximg
, pixmap
)
2147 int width
, height
, depth
;
2151 #ifdef HAVE_X_WINDOWS
2152 Display
*display
= FRAME_X_DISPLAY (f
);
2153 Window window
= FRAME_X_WINDOW (f
);
2154 Screen
*screen
= FRAME_X_SCREEN (f
);
2156 xassert (interrupt_input_blocked
);
2159 depth
= DefaultDepthOfScreen (screen
);
2160 *ximg
= XCreateImage (display
, DefaultVisualOfScreen (screen
),
2161 depth
, ZPixmap
, 0, NULL
, width
, height
,
2162 depth
> 16 ? 32 : depth
> 8 ? 16 : 8, 0);
2165 image_error ("Unable to allocate X image", Qnil
, Qnil
);
2169 /* Allocate image raster. */
2170 (*ximg
)->data
= (char *) xmalloc ((*ximg
)->bytes_per_line
* height
);
2172 /* Allocate a pixmap of the same size. */
2173 *pixmap
= XCreatePixmap (display
, window
, width
, height
, depth
);
2174 if (*pixmap
== NO_PIXMAP
)
2176 x_destroy_x_image (*ximg
);
2178 image_error ("Unable to create X pixmap", Qnil
, Qnil
);
2183 #endif /* HAVE_X_WINDOWS */
2187 BITMAPINFOHEADER
*header
;
2189 int scanline_width_bits
;
2191 int palette_colors
= 0;
2196 if (depth
!= 1 && depth
!= 4 && depth
!= 8
2197 && depth
!= 16 && depth
!= 24 && depth
!= 32)
2199 image_error ("Invalid image bit depth specified", Qnil
, Qnil
);
2203 scanline_width_bits
= width
* depth
;
2204 remainder
= scanline_width_bits
% 32;
2207 scanline_width_bits
+= 32 - remainder
;
2209 /* Bitmaps with a depth less than 16 need a palette. */
2210 /* BITMAPINFO structure already contains the first RGBQUAD. */
2212 palette_colors
= 1 << depth
- 1;
2214 *ximg
= xmalloc (sizeof (XImage
) + palette_colors
* sizeof (RGBQUAD
));
2217 image_error ("Unable to allocate memory for XImage", Qnil
, Qnil
);
2221 header
= &((*ximg
)->info
.bmiHeader
);
2222 bzero (&((*ximg
)->info
), sizeof (BITMAPINFO
));
2223 header
->biSize
= sizeof (*header
);
2224 header
->biWidth
= width
;
2225 header
->biHeight
= -height
; /* negative indicates a top-down bitmap. */
2226 header
->biPlanes
= 1;
2227 header
->biBitCount
= depth
;
2228 header
->biCompression
= BI_RGB
;
2229 header
->biClrUsed
= palette_colors
;
2231 /* TODO: fill in palette. */
2234 (*ximg
)->info
.bmiColors
[0].rgbBlue
= 0;
2235 (*ximg
)->info
.bmiColors
[0].rgbGreen
= 0;
2236 (*ximg
)->info
.bmiColors
[0].rgbRed
= 0;
2237 (*ximg
)->info
.bmiColors
[0].rgbReserved
= 0;
2238 (*ximg
)->info
.bmiColors
[1].rgbBlue
= 255;
2239 (*ximg
)->info
.bmiColors
[1].rgbGreen
= 255;
2240 (*ximg
)->info
.bmiColors
[1].rgbRed
= 255;
2241 (*ximg
)->info
.bmiColors
[1].rgbReserved
= 0;
2244 hdc
= get_frame_dc (f
);
2246 /* Create a DIBSection and raster array for the bitmap,
2247 and store its handle in *pixmap. */
2248 *pixmap
= CreateDIBSection (hdc
, &((*ximg
)->info
),
2249 (depth
< 16) ? DIB_PAL_COLORS
: DIB_RGB_COLORS
,
2250 /* casting avoids a GCC warning */
2251 (void **)&((*ximg
)->data
), NULL
, 0);
2253 /* Realize display palette and garbage all frames. */
2254 release_frame_dc (f
, hdc
);
2256 if (*pixmap
== NULL
)
2258 DWORD err
= GetLastError();
2259 Lisp_Object errcode
;
2260 /* All system errors are < 10000, so the following is safe. */
2261 XSETINT (errcode
, (int) err
);
2262 image_error ("Unable to create bitmap, error code %d", errcode
, Qnil
);
2263 x_destroy_x_image (*ximg
);
2269 #endif /* HAVE_NTGUI */
2272 Display
*display
= FRAME_X_DISPLAY (f
);
2273 Window window
= FRAME_X_WINDOW (f
);
2275 xassert (interrupt_input_blocked
);
2277 /* Allocate a pixmap of the same size. */
2278 *pixmap
= XCreatePixmap (display
, window
, width
, height
, depth
);
2279 if (*pixmap
== NO_PIXMAP
)
2282 image_error ("Unable to create X pixmap", Qnil
, Qnil
);
2286 LockPixels (GetGWorldPixMap (*pixmap
));
2294 /* Destroy XImage XIMG. Free XIMG->data. */
2297 x_destroy_x_image (ximg
)
2300 xassert (interrupt_input_blocked
);
2303 #ifdef HAVE_X_WINDOWS
2306 XDestroyImage (ximg
);
2307 #endif /* HAVE_X_WINDOWS */
2309 /* Data will be freed by DestroyObject. */
2312 #endif /* HAVE_NTGUI */
2314 XDestroyImage (ximg
);
2320 /* Put XImage XIMG into pixmap PIXMAP on frame F. WIDTH and HEIGHT
2321 are width and height of both the image and pixmap. */
2324 x_put_x_image (f
, ximg
, pixmap
, width
, height
)
2330 #ifdef HAVE_X_WINDOWS
2333 xassert (interrupt_input_blocked
);
2334 gc
= XCreateGC (FRAME_X_DISPLAY (f
), pixmap
, 0, NULL
);
2335 XPutImage (FRAME_X_DISPLAY (f
), pixmap
, gc
, ximg
, 0, 0, 0, 0, width
, height
);
2336 XFreeGC (FRAME_X_DISPLAY (f
), gc
);
2337 #endif /* HAVE_X_WINDOWS */
2340 #if 0 /* I don't think this is necessary looking at where it is used. */
2341 HDC hdc
= get_frame_dc (f
);
2342 SetDIBits (hdc
, pixmap
, 0, height
, ximg
->data
, &(ximg
->info
), DIB_RGB_COLORS
);
2343 release_frame_dc (f
, hdc
);
2345 #endif /* HAVE_NTGUI */
2348 xassert (ximg
== pixmap
);
2353 /***********************************************************************
2355 ***********************************************************************/
2357 static unsigned char *slurp_file
P_ ((char *, int *));
2360 /* Find image file FILE. Look in data-directory, then
2361 x-bitmap-file-path. Value is the encoded full name of the file
2362 found, or nil if not found. */
2365 x_find_image_file (file
)
2368 Lisp_Object file_found
, search_path
;
2369 struct gcpro gcpro1
, gcpro2
;
2373 search_path
= Fcons (Vdata_directory
, Vx_bitmap_file_path
);
2374 GCPRO2 (file_found
, search_path
);
2376 /* Try to find FILE in data-directory, then x-bitmap-file-path. */
2377 fd
= openp (search_path
, file
, Qnil
, &file_found
, Qnil
);
2383 file_found
= ENCODE_FILE (file_found
);
2392 /* Read FILE into memory. Value is a pointer to a buffer allocated
2393 with xmalloc holding FILE's contents. Value is null if an error
2394 occurred. *SIZE is set to the size of the file. */
2396 static unsigned char *
2397 slurp_file (file
, size
)
2402 unsigned char *buf
= NULL
;
2405 if (stat (file
, &st
) == 0
2406 && (fp
= fopen (file
, "rb")) != NULL
2407 && (buf
= (unsigned char *) xmalloc (st
.st_size
),
2408 fread (buf
, 1, st
.st_size
, fp
) == st
.st_size
))
2431 /***********************************************************************
2432 MAC Image Load Functions
2433 ***********************************************************************/
2435 static int image_load_quicktime
P_ ((struct frame
*, struct image
*img
,
2438 static int image_load_quartz2d
P_ ((struct frame
*, struct image
*img
, int));
2442 find_image_fsspec (specified_file
, file
, fss
)
2443 Lisp_Object specified_file
, *file
;
2449 *file
= x_find_image_file (specified_file
);
2450 if (!STRINGP (*file
))
2451 return fnfErr
; /* file or directory not found;
2452 incomplete pathname */
2453 /* Try to open the image file. */
2454 err
= AECoercePtr (TYPE_FILE_NAME
, SDATA (*file
),
2455 SBYTES (*file
), typeFSS
, &desc
);
2458 #if TARGET_API_MAC_CARBON
2459 err
= AEGetDescData (&desc
, fss
, sizeof (FSSpec
));
2461 *fss
= *(FSSpec
*)(*(desc
.dataHandle
));
2463 AEDisposeDesc (&desc
);
2469 image_load_qt_1 (f
, img
, type
, fss
, dh
)
2476 ComponentResult err
;
2477 GraphicsImportComponent gi
;
2480 ImageDescriptionHandle desc_handle
;
2481 short draw_all_pixels
;
2482 Lisp_Object specified_bg
;
2487 err
= OpenADefaultComponent (GraphicsImporterComponentType
, type
, &gi
);
2490 image_error ("Cannot get importer component for `%s'", img
->spec
, Qnil
);
2495 /* read from file system spec */
2496 err
= GraphicsImportSetDataFile (gi
, fss
);
2499 image_error ("Cannot set fsspec to graphics importer for '%s'",
2506 /* read from data handle */
2507 err
= GraphicsImportSetDataHandle (gi
, dh
);
2510 image_error ("Cannot set data handle to graphics importer for `%s'",
2515 err
= GraphicsImportGetImageDescription (gi
, &desc_handle
);
2516 if (err
!= noErr
|| desc_handle
== NULL
)
2518 image_error ("Error reading `%s'", img
->spec
, Qnil
);
2521 width
= img
->width
= (*desc_handle
)->width
;
2522 height
= img
->height
= (*desc_handle
)->height
;
2523 DisposeHandle ((Handle
)desc_handle
);
2525 if (!check_image_size (f
, width
, height
))
2527 image_error ("Invalid image size", Qnil
, Qnil
);
2531 err
= GraphicsImportDoesDrawAllPixels (gi
, &draw_all_pixels
);
2533 /* Don't check the error code here. It may have an undocumented
2537 image_error ("Error reading `%s'", img
->spec
, Qnil
);
2541 if (draw_all_pixels
!= graphicsImporterDrawsAllPixels
)
2543 specified_bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
2544 if (!STRINGP (specified_bg
) ||
2545 !mac_defined_color (f
, SDATA (specified_bg
), &color
, 0))
2547 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
2548 color
.red
= RED16_FROM_ULONG (color
.pixel
);
2549 color
.green
= GREEN16_FROM_ULONG (color
.pixel
);
2550 color
.blue
= BLUE16_FROM_ULONG (color
.pixel
);
2554 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
2556 if (draw_all_pixels
!= graphicsImporterDrawsAllPixels
)
2561 GetGWorld (&old_port
, &old_gdh
);
2562 SetGWorld (ximg
, NULL
);
2563 bg_color
.red
= color
.red
;
2564 bg_color
.green
= color
.green
;
2565 bg_color
.blue
= color
.blue
;
2566 RGBBackColor (&bg_color
);
2567 #if TARGET_API_MAC_CARBON
2568 GetPortBounds (ximg
, &rect
);
2571 EraseRect (&(ximg
->portRect
));
2573 SetGWorld (old_port
, old_gdh
);
2575 GraphicsImportSetGWorld (gi
, ximg
, NULL
);
2576 GraphicsImportDraw (gi
);
2577 CloseComponent (gi
);
2579 /* Maybe fill in the background field while we have ximg handy. */
2580 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
2581 IMAGE_BACKGROUND (img
, f
, ximg
);
2583 /* Put the image into the pixmap. */
2584 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
2585 x_destroy_x_image (ximg
);
2589 CloseComponent (gi
);
2594 /* Load an image using the QuickTime Graphics Importer.
2595 Note: The alpha channel does not work for PNG images. */
2597 image_load_quicktime (f
, img
, type
)
2602 Lisp_Object specified_file
;
2603 Lisp_Object specified_data
;
2606 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
2607 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
2609 if (NILP (specified_data
))
2611 /* Read from a file */
2615 err
= find_image_fsspec (specified_file
, &file
, &fss
);
2619 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
2621 image_error ("Cannot open `%s'", file
, Qnil
);
2624 return image_load_qt_1 (f
, img
, type
, &fss
, NULL
);
2628 /* Memory source! */
2632 err
= PtrToHand (SDATA (specified_data
), &dh
, SBYTES (specified_data
));
2635 image_error ("Cannot allocate data handle for `%s'",
2639 success_p
= image_load_qt_1 (f
, img
, type
, NULL
, dh
);
2647 /* Load a PNG/JPEG image using Quartz 2D decoding routines.
2648 CGImageCreateWithPNGDataProvider is provided after Mac OS X 10.2.
2649 So don't use this function directly but determine at runtime
2650 whether it exists. */
2651 typedef CGImageRef (*CGImageCreateWithPNGDataProviderProcType
)
2652 (CGDataProviderRef
, const float [], bool, CGColorRenderingIntent
);
2653 static CGImageCreateWithPNGDataProviderProcType MyCGImageCreateWithPNGDataProvider
;
2657 init_image_func_pointer ()
2659 if (NSIsSymbolNameDefined ("_CGImageCreateWithPNGDataProvider"))
2661 MyCGImageCreateWithPNGDataProvider
2662 = (CGImageCreateWithPNGDataProviderProcType
)
2663 NSAddressOfSymbol (NSLookupAndBindSymbol
2664 ("_CGImageCreateWithPNGDataProvider"));
2667 MyCGImageCreateWithPNGDataProvider
= NULL
;
2672 image_load_quartz2d (f
, img
, png_p
)
2677 Lisp_Object file
, specified_file
;
2678 Lisp_Object specified_data
, specified_bg
;
2679 struct gcpro gcpro1
;
2680 CGDataProviderRef source
;
2684 XImagePtr ximg
= NULL
;
2685 CGContextRef context
;
2688 /* Open the file. */
2689 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
2690 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
2695 if (NILP (specified_data
))
2700 file
= x_find_image_file (specified_file
);
2701 if (!STRINGP (file
))
2703 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
2707 path
= cfstring_create_with_utf8_cstring (SDATA (file
));
2708 url
= CFURLCreateWithFileSystemPath (NULL
, path
,
2709 kCFURLPOSIXPathStyle
, 0);
2711 source
= CGDataProviderCreateWithURL (url
);
2715 source
= CGDataProviderCreateWithData (NULL
, SDATA (specified_data
),
2716 SBYTES (specified_data
), NULL
);
2719 image
= (*MyCGImageCreateWithPNGDataProvider
) (source
, NULL
, FALSE
,
2720 kCGRenderingIntentDefault
);
2722 image
= CGImageCreateWithJPEGDataProvider (source
, NULL
, FALSE
,
2723 kCGRenderingIntentDefault
);
2725 CGDataProviderRelease (source
);
2729 image_error ("Error reading image `%s'", img
->spec
, Qnil
);
2732 width
= img
->width
= CGImageGetWidth (image
);
2733 height
= img
->height
= CGImageGetHeight (image
);
2735 if (!check_image_size (f
, width
, height
))
2737 CGImageRelease (image
);
2739 image_error ("Invalid image size", Qnil
, Qnil
);
2745 specified_bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
2746 if (!STRINGP (specified_bg
) ||
2747 !mac_defined_color (f
, SDATA (specified_bg
), &color
, 0))
2749 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
2750 color
.red
= RED16_FROM_ULONG (color
.pixel
);
2751 color
.green
= GREEN16_FROM_ULONG (color
.pixel
);
2752 color
.blue
= BLUE16_FROM_ULONG (color
.pixel
);
2756 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
2758 CGImageRelease (image
);
2762 rectangle
= CGRectMake (0, 0, width
, height
);
2763 QDBeginCGContext (ximg
, &context
);
2766 CGContextSetRGBFillColor (context
, color
.red
/ 65535.0,
2767 color
.green
/ 65535.0,
2768 color
.blue
/ 65535.0, 1.0);
2769 CGContextFillRect (context
, rectangle
);
2771 CGContextDrawImage (context
, rectangle
, image
);
2772 QDEndCGContext (ximg
, &context
);
2773 CGImageRelease (image
);
2775 /* Maybe fill in the background field while we have ximg handy. */
2776 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
2777 IMAGE_BACKGROUND (img
, f
, ximg
);
2779 /* Put the image into the pixmap. */
2780 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
2781 x_destroy_x_image (ximg
);
2790 /***********************************************************************
2792 ***********************************************************************/
2794 static int xbm_scan
P_ ((unsigned char **, unsigned char *, char *, int *));
2795 static int xbm_load
P_ ((struct frame
*f
, struct image
*img
));
2796 static int xbm_load_image
P_ ((struct frame
*f
, struct image
*img
,
2797 unsigned char *, unsigned char *));
2798 static int xbm_image_p
P_ ((Lisp_Object object
));
2799 static int xbm_read_bitmap_data
P_ ((struct frame
*f
,
2800 unsigned char *, unsigned char *,
2801 int *, int *, unsigned char **));
2802 static int xbm_file_p
P_ ((Lisp_Object
));
2805 /* Indices of image specification fields in xbm_format, below. */
2807 enum xbm_keyword_index
2825 /* Vector of image_keyword structures describing the format
2826 of valid XBM image specifications. */
2828 static struct image_keyword xbm_format
[XBM_LAST
] =
2830 {":type", IMAGE_SYMBOL_VALUE
, 1},
2831 {":file", IMAGE_STRING_VALUE
, 0},
2832 {":width", IMAGE_POSITIVE_INTEGER_VALUE
, 0},
2833 {":height", IMAGE_POSITIVE_INTEGER_VALUE
, 0},
2834 {":data", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
2835 {":foreground", IMAGE_STRING_OR_NIL_VALUE
, 0},
2836 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0},
2837 {":ascent", IMAGE_ASCENT_VALUE
, 0},
2838 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
2839 {":relief", IMAGE_INTEGER_VALUE
, 0},
2840 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
2841 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
2842 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0}
2845 /* Structure describing the image type XBM. */
2847 static struct image_type xbm_type
=
2856 /* Tokens returned from xbm_scan. */
2865 /* Return non-zero if OBJECT is a valid XBM-type image specification.
2866 A valid specification is a list starting with the symbol `image'
2867 The rest of the list is a property list which must contain an
2870 If the specification specifies a file to load, it must contain
2871 an entry `:file FILENAME' where FILENAME is a string.
2873 If the specification is for a bitmap loaded from memory it must
2874 contain `:width WIDTH', `:height HEIGHT', and `:data DATA', where
2875 WIDTH and HEIGHT are integers > 0. DATA may be:
2877 1. a string large enough to hold the bitmap data, i.e. it must
2878 have a size >= (WIDTH + 7) / 8 * HEIGHT
2880 2. a bool-vector of size >= WIDTH * HEIGHT
2882 3. a vector of strings or bool-vectors, one for each line of the
2885 4. A string containing an in-memory XBM file. WIDTH and HEIGHT
2886 may not be specified in this case because they are defined in the
2889 Both the file and data forms may contain the additional entries
2890 `:background COLOR' and `:foreground COLOR'. If not present,
2891 foreground and background of the frame on which the image is
2892 displayed is used. */
2895 xbm_image_p (object
)
2898 struct image_keyword kw
[XBM_LAST
];
2900 bcopy (xbm_format
, kw
, sizeof kw
);
2901 if (!parse_image_spec (object
, kw
, XBM_LAST
, Qxbm
))
2904 xassert (EQ (kw
[XBM_TYPE
].value
, Qxbm
));
2906 if (kw
[XBM_FILE
].count
)
2908 if (kw
[XBM_WIDTH
].count
|| kw
[XBM_HEIGHT
].count
|| kw
[XBM_DATA
].count
)
2911 else if (kw
[XBM_DATA
].count
&& xbm_file_p (kw
[XBM_DATA
].value
))
2913 /* In-memory XBM file. */
2914 if (kw
[XBM_WIDTH
].count
|| kw
[XBM_HEIGHT
].count
|| kw
[XBM_FILE
].count
)
2922 /* Entries for `:width', `:height' and `:data' must be present. */
2923 if (!kw
[XBM_WIDTH
].count
2924 || !kw
[XBM_HEIGHT
].count
2925 || !kw
[XBM_DATA
].count
)
2928 data
= kw
[XBM_DATA
].value
;
2929 width
= XFASTINT (kw
[XBM_WIDTH
].value
);
2930 height
= XFASTINT (kw
[XBM_HEIGHT
].value
);
2932 /* Check type of data, and width and height against contents of
2938 /* Number of elements of the vector must be >= height. */
2939 if (XVECTOR (data
)->size
< height
)
2942 /* Each string or bool-vector in data must be large enough
2943 for one line of the image. */
2944 for (i
= 0; i
< height
; ++i
)
2946 Lisp_Object elt
= XVECTOR (data
)->contents
[i
];
2951 < (width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
)
2954 else if (BOOL_VECTOR_P (elt
))
2956 if (XBOOL_VECTOR (elt
)->size
< width
)
2963 else if (STRINGP (data
))
2966 < (width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
* height
)
2969 else if (BOOL_VECTOR_P (data
))
2971 if (XBOOL_VECTOR (data
)->size
< width
* height
)
2982 /* Scan a bitmap file. FP is the stream to read from. Value is
2983 either an enumerator from enum xbm_token, or a character for a
2984 single-character token, or 0 at end of file. If scanning an
2985 identifier, store the lexeme of the identifier in SVAL. If
2986 scanning a number, store its value in *IVAL. */
2989 xbm_scan (s
, end
, sval
, ival
)
2990 unsigned char **s
, *end
;
2998 /* Skip white space. */
2999 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
3004 else if (isdigit (c
))
3006 int value
= 0, digit
;
3008 if (c
== '0' && *s
< end
)
3011 if (c
== 'x' || c
== 'X')
3018 else if (c
>= 'a' && c
<= 'f')
3019 digit
= c
- 'a' + 10;
3020 else if (c
>= 'A' && c
<= 'F')
3021 digit
= c
- 'A' + 10;
3024 value
= 16 * value
+ digit
;
3027 else if (isdigit (c
))
3031 && (c
= *(*s
)++, isdigit (c
)))
3032 value
= 8 * value
+ c
- '0';
3039 && (c
= *(*s
)++, isdigit (c
)))
3040 value
= 10 * value
+ c
- '0';
3048 else if (isalpha (c
) || c
== '_')
3052 && (c
= *(*s
)++, (isalnum (c
) || c
== '_')))
3059 else if (c
== '/' && **s
== '*')
3061 /* C-style comment. */
3063 while (**s
&& (**s
!= '*' || *(*s
+ 1) != '/'))
3077 /* Create a Windows bitmap from X bitmap data. */
3079 w32_create_pixmap_from_bitmap_data (int width
, int height
, char *data
)
3081 static unsigned char swap_nibble
[16]
3082 = { 0x0, 0x8, 0x4, 0xc, /* 0000 1000 0100 1100 */
3083 0x2, 0xa, 0x6, 0xe, /* 0010 1010 0110 1110 */
3084 0x1, 0x9, 0x5, 0xd, /* 0001 1001 0101 1101 */
3085 0x3, 0xb, 0x7, 0xf }; /* 0011 1011 0111 1111 */
3087 unsigned char *bits
, *p
;
3090 w1
= (width
+ 7) / 8; /* nb of 8bits elt in X bitmap */
3091 w2
= ((width
+ 15) / 16) * 2; /* nb of 16bits elt in W32 bitmap */
3092 bits
= (unsigned char *) alloca (height
* w2
);
3093 bzero (bits
, height
* w2
);
3094 for (i
= 0; i
< height
; i
++)
3097 for (j
= 0; j
< w1
; j
++)
3099 /* Bitswap XBM bytes to match how Windows does things. */
3100 unsigned char c
= *data
++;
3101 *p
++ = (unsigned char)((swap_nibble
[c
& 0xf] << 4)
3102 | (swap_nibble
[(c
>>4) & 0xf]));
3105 bmp
= CreateBitmap (width
, height
, 1, 1, (char *) bits
);
3110 static void convert_mono_to_color_image (f
, img
, foreground
, background
)
3113 COLORREF foreground
, background
;
3115 HDC hdc
, old_img_dc
, new_img_dc
;
3116 HGDIOBJ old_prev
, new_prev
;
3119 hdc
= get_frame_dc (f
);
3120 old_img_dc
= CreateCompatibleDC (hdc
);
3121 new_img_dc
= CreateCompatibleDC (hdc
);
3122 new_pixmap
= CreateCompatibleBitmap (hdc
, img
->width
, img
->height
);
3123 release_frame_dc (f
, hdc
);
3124 old_prev
= SelectObject (old_img_dc
, img
->pixmap
);
3125 new_prev
= SelectObject (new_img_dc
, new_pixmap
);
3126 SetTextColor (new_img_dc
, background
);
3127 SetBkColor (new_img_dc
, foreground
);
3129 BitBlt (new_img_dc
, 0, 0, img
->width
, img
->height
, old_img_dc
,
3132 SelectObject (old_img_dc
, old_prev
);
3133 SelectObject (new_img_dc
, new_prev
);
3134 DeleteDC (old_img_dc
);
3135 DeleteDC (new_img_dc
);
3136 DeleteObject (img
->pixmap
);
3137 if (new_pixmap
== 0)
3138 fprintf (stderr
, "Failed to convert image to color.\n");
3140 img
->pixmap
= new_pixmap
;
3143 #define XBM_BIT_SHUFFLE(b) (~(b))
3147 #define XBM_BIT_SHUFFLE(b) (b)
3149 #endif /* HAVE_NTGUI */
3153 Create_Pixmap_From_Bitmap_Data(f
, img
, data
, fg
, bg
, non_default_colors
)
3157 RGB_PIXEL_COLOR fg
, bg
;
3158 int non_default_colors
;
3162 = w32_create_pixmap_from_bitmap_data (img
->width
, img
->height
, data
);
3164 /* If colors were specified, transfer the bitmap to a color one. */
3165 if (non_default_colors
)
3166 convert_mono_to_color_image (f
, img
, fg
, bg
);
3169 = XCreatePixmapFromBitmapData (FRAME_X_DISPLAY (f
),
3172 img
->width
, img
->height
,
3174 DefaultDepthOfScreen (FRAME_X_SCREEN (f
)));
3175 #endif /* HAVE_NTGUI */
3180 /* Replacement for XReadBitmapFileData which isn't available under old
3181 X versions. CONTENTS is a pointer to a buffer to parse; END is the
3182 buffer's end. Set *WIDTH and *HEIGHT to the width and height of
3183 the image. Return in *DATA the bitmap data allocated with xmalloc.
3184 Value is non-zero if successful. DATA null means just test if
3185 CONTENTS looks like an in-memory XBM file. */
3188 xbm_read_bitmap_data (f
, contents
, end
, width
, height
, data
)
3190 unsigned char *contents
, *end
;
3191 int *width
, *height
;
3192 unsigned char **data
;
3194 unsigned char *s
= contents
;
3195 char buffer
[BUFSIZ
];
3198 int bytes_per_line
, i
, nbytes
;
3204 LA1 = xbm_scan (&s, end, buffer, &value)
3206 #define expect(TOKEN) \
3207 if (LA1 != (TOKEN)) \
3212 #define expect_ident(IDENT) \
3213 if (LA1 == XBM_TK_IDENT && strcmp (buffer, (IDENT)) == 0) \
3218 *width
= *height
= -1;
3221 LA1
= xbm_scan (&s
, end
, buffer
, &value
);
3223 /* Parse defines for width, height and hot-spots. */
3227 expect_ident ("define");
3228 expect (XBM_TK_IDENT
);
3230 if (LA1
== XBM_TK_NUMBER
)
3232 char *p
= strrchr (buffer
, '_');
3233 p
= p
? p
+ 1 : buffer
;
3234 if (strcmp (p
, "width") == 0)
3236 else if (strcmp (p
, "height") == 0)
3239 expect (XBM_TK_NUMBER
);
3242 if (!check_image_size (f
, *width
, *height
))
3244 else if (data
== NULL
)
3247 /* Parse bits. Must start with `static'. */
3248 expect_ident ("static");
3249 if (LA1
== XBM_TK_IDENT
)
3251 if (strcmp (buffer
, "unsigned") == 0)
3254 expect_ident ("char");
3256 else if (strcmp (buffer
, "short") == 0)
3260 if (*width
% 16 && *width
% 16 < 9)
3263 else if (strcmp (buffer
, "char") == 0)
3271 expect (XBM_TK_IDENT
);
3277 bytes_per_line
= (*width
+ 7) / 8 + padding_p
;
3278 nbytes
= bytes_per_line
* *height
;
3279 p
= *data
= (unsigned char *) xmalloc (nbytes
);
3283 for (i
= 0; i
< nbytes
; i
+= 2)
3286 expect (XBM_TK_NUMBER
);
3288 *p
++ = XBM_BIT_SHUFFLE (val
);
3289 if (!padding_p
|| ((i
+ 2) % bytes_per_line
))
3290 *p
++ = XBM_BIT_SHUFFLE (value
>> 8);
3292 if (LA1
== ',' || LA1
== '}')
3300 for (i
= 0; i
< nbytes
; ++i
)
3303 expect (XBM_TK_NUMBER
);
3305 *p
++ = XBM_BIT_SHUFFLE (val
);
3307 if (LA1
== ',' || LA1
== '}')
3332 /* Load XBM image IMG which will be displayed on frame F from buffer
3333 CONTENTS. END is the end of the buffer. Value is non-zero if
3337 xbm_load_image (f
, img
, contents
, end
)
3340 unsigned char *contents
, *end
;
3343 unsigned char *data
;
3346 rc
= xbm_read_bitmap_data (f
, contents
, end
, &img
->width
, &img
->height
, &data
);
3349 unsigned long foreground
= FRAME_FOREGROUND_PIXEL (f
);
3350 unsigned long background
= FRAME_BACKGROUND_PIXEL (f
);
3351 int non_default_colors
= 0;
3354 xassert (img
->width
> 0 && img
->height
> 0);
3356 /* Get foreground and background colors, maybe allocate colors. */
3357 value
= image_spec_value (img
->spec
, QCforeground
, NULL
);
3360 foreground
= x_alloc_image_color (f
, img
, value
, foreground
);
3361 non_default_colors
= 1;
3363 value
= image_spec_value (img
->spec
, QCbackground
, NULL
);
3366 background
= x_alloc_image_color (f
, img
, value
, background
);
3367 img
->background
= background
;
3368 img
->background_valid
= 1;
3369 non_default_colors
= 1;
3372 Create_Pixmap_From_Bitmap_Data (f
, img
, data
,
3373 foreground
, background
,
3374 non_default_colors
);
3377 if (img
->pixmap
== NO_PIXMAP
)
3379 x_clear_image (f
, img
);
3380 image_error ("Unable to create X pixmap for `%s'", img
->spec
, Qnil
);
3386 image_error ("Error loading XBM image `%s'", img
->spec
, Qnil
);
3392 /* Value is non-zero if DATA looks like an in-memory XBM file. */
3399 return (STRINGP (data
)
3400 && xbm_read_bitmap_data (NULL
, SDATA (data
),
3407 /* Fill image IMG which is used on frame F with pixmap data. Value is
3408 non-zero if successful. */
3416 Lisp_Object file_name
;
3418 xassert (xbm_image_p (img
->spec
));
3420 /* If IMG->spec specifies a file name, create a non-file spec from it. */
3421 file_name
= image_spec_value (img
->spec
, QCfile
, NULL
);
3422 if (STRINGP (file_name
))
3425 unsigned char *contents
;
3427 struct gcpro gcpro1
;
3429 file
= x_find_image_file (file_name
);
3431 if (!STRINGP (file
))
3433 image_error ("Cannot find image file `%s'", file_name
, Qnil
);
3438 contents
= slurp_file (SDATA (file
), &size
);
3439 if (contents
== NULL
)
3441 image_error ("Error loading XBM image `%s'", img
->spec
, Qnil
);
3446 success_p
= xbm_load_image (f
, img
, contents
, contents
+ size
);
3451 struct image_keyword fmt
[XBM_LAST
];
3453 unsigned long foreground
= FRAME_FOREGROUND_PIXEL (f
);
3454 unsigned long background
= FRAME_BACKGROUND_PIXEL (f
);
3455 int non_default_colors
= 0;
3458 int in_memory_file_p
= 0;
3460 /* See if data looks like an in-memory XBM file. */
3461 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
3462 in_memory_file_p
= xbm_file_p (data
);
3464 /* Parse the image specification. */
3465 bcopy (xbm_format
, fmt
, sizeof fmt
);
3466 parsed_p
= parse_image_spec (img
->spec
, fmt
, XBM_LAST
, Qxbm
);
3469 /* Get specified width, and height. */
3470 if (!in_memory_file_p
)
3472 img
->width
= XFASTINT (fmt
[XBM_WIDTH
].value
);
3473 img
->height
= XFASTINT (fmt
[XBM_HEIGHT
].value
);
3474 xassert (img
->width
> 0 && img
->height
> 0);
3477 /* Get foreground and background colors, maybe allocate colors. */
3478 if (fmt
[XBM_FOREGROUND
].count
3479 && STRINGP (fmt
[XBM_FOREGROUND
].value
))
3481 foreground
= x_alloc_image_color (f
, img
, fmt
[XBM_FOREGROUND
].value
,
3483 non_default_colors
= 1;
3486 if (fmt
[XBM_BACKGROUND
].count
3487 && STRINGP (fmt
[XBM_BACKGROUND
].value
))
3489 background
= x_alloc_image_color (f
, img
, fmt
[XBM_BACKGROUND
].value
,
3491 non_default_colors
= 1;
3494 if (in_memory_file_p
)
3495 success_p
= xbm_load_image (f
, img
, SDATA (data
),
3504 int nbytes
= (img
->width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
;
3506 p
= bits
= (char *) alloca (nbytes
* img
->height
);
3507 for (i
= 0; i
< img
->height
; ++i
, p
+= nbytes
)
3509 Lisp_Object line
= XVECTOR (data
)->contents
[i
];
3511 bcopy (SDATA (line
), p
, nbytes
);
3513 bcopy (XBOOL_VECTOR (line
)->data
, p
, nbytes
);
3516 else if (STRINGP (data
))
3517 bits
= SDATA (data
);
3519 bits
= XBOOL_VECTOR (data
)->data
;
3521 /* Create the pixmap. */
3523 Create_Pixmap_From_Bitmap_Data (f
, img
, bits
,
3524 foreground
, background
,
3525 non_default_colors
);
3530 image_error ("Unable to create pixmap for XBM image `%s'",
3532 x_clear_image (f
, img
);
3542 /***********************************************************************
3544 ***********************************************************************/
3546 #if defined (HAVE_XPM) || defined (MAC_OS)
3548 static int xpm_image_p
P_ ((Lisp_Object object
));
3549 static int xpm_load
P_ ((struct frame
*f
, struct image
*img
));
3550 static int xpm_valid_color_symbols_p
P_ ((Lisp_Object
));
3552 #endif /* HAVE_XPM || MAC_OS */
3556 /* Indicate to xpm.h that we don't have Xlib. */
3558 /* simx.h in xpm defines XColor and XImage differently than Emacs. */
3559 /* It also defines Display the same way as Emacs, but gcc 3.3 still barfs. */
3560 #define XColor xpm_XColor
3561 #define XImage xpm_XImage
3562 #define Display xpm_Display
3563 #define PIXEL_ALREADY_TYPEDEFED
3564 #include "X11/xpm.h"
3569 #undef PIXEL_ALREADY_TYPEDEFED
3571 #include "X11/xpm.h"
3572 #endif /* HAVE_NTGUI */
3573 #endif /* HAVE_XPM */
3575 #if defined (HAVE_XPM) || defined (MAC_OS)
3576 /* The symbol `xpm' identifying XPM-format images. */
3580 /* Indices of image specification fields in xpm_format, below. */
3582 enum xpm_keyword_index
3598 /* Vector of image_keyword structures describing the format
3599 of valid XPM image specifications. */
3601 static struct image_keyword xpm_format
[XPM_LAST
] =
3603 {":type", IMAGE_SYMBOL_VALUE
, 1},
3604 {":file", IMAGE_STRING_VALUE
, 0},
3605 {":data", IMAGE_STRING_VALUE
, 0},
3606 {":ascent", IMAGE_ASCENT_VALUE
, 0},
3607 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
3608 {":relief", IMAGE_INTEGER_VALUE
, 0},
3609 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3610 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3611 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3612 {":color-symbols", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3613 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
3616 /* Structure describing the image type XPM. */
3618 static struct image_type xpm_type
=
3627 #ifdef HAVE_X_WINDOWS
3629 /* Define ALLOC_XPM_COLORS if we can use Emacs' own color allocation
3630 functions for allocating image colors. Our own functions handle
3631 color allocation failures more gracefully than the ones on the XPM
3634 #if defined XpmAllocColor && defined XpmFreeColors && defined XpmColorClosure
3635 #define ALLOC_XPM_COLORS
3637 #endif /* HAVE_X_WINDOWS */
3639 #ifdef ALLOC_XPM_COLORS
3641 static void xpm_init_color_cache
P_ ((struct frame
*, XpmAttributes
*));
3642 static void xpm_free_color_cache
P_ ((void));
3643 static int xpm_lookup_color
P_ ((struct frame
*, char *, XColor
*));
3644 static int xpm_color_bucket
P_ ((char *));
3645 static struct xpm_cached_color
*xpm_cache_color
P_ ((struct frame
*, char *,
3648 /* An entry in a hash table used to cache color definitions of named
3649 colors. This cache is necessary to speed up XPM image loading in
3650 case we do color allocations ourselves. Without it, we would need
3651 a call to XParseColor per pixel in the image. */
3653 struct xpm_cached_color
3655 /* Next in collision chain. */
3656 struct xpm_cached_color
*next
;
3658 /* Color definition (RGB and pixel color). */
3665 /* The hash table used for the color cache, and its bucket vector
3668 #define XPM_COLOR_CACHE_BUCKETS 1001
3669 struct xpm_cached_color
**xpm_color_cache
;
3671 /* Initialize the color cache. */
3674 xpm_init_color_cache (f
, attrs
)
3676 XpmAttributes
*attrs
;
3678 size_t nbytes
= XPM_COLOR_CACHE_BUCKETS
* sizeof *xpm_color_cache
;
3679 xpm_color_cache
= (struct xpm_cached_color
**) xmalloc (nbytes
);
3680 memset (xpm_color_cache
, 0, nbytes
);
3681 init_color_table ();
3683 if (attrs
->valuemask
& XpmColorSymbols
)
3688 for (i
= 0; i
< attrs
->numsymbols
; ++i
)
3689 if (XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
3690 attrs
->colorsymbols
[i
].value
, &color
))
3692 color
.pixel
= lookup_rgb_color (f
, color
.red
, color
.green
,
3694 xpm_cache_color (f
, attrs
->colorsymbols
[i
].name
, &color
, -1);
3699 /* Free the color cache. */
3702 xpm_free_color_cache ()
3704 struct xpm_cached_color
*p
, *next
;
3707 for (i
= 0; i
< XPM_COLOR_CACHE_BUCKETS
; ++i
)
3708 for (p
= xpm_color_cache
[i
]; p
; p
= next
)
3714 xfree (xpm_color_cache
);
3715 xpm_color_cache
= NULL
;
3716 free_color_table ();
3719 /* Return the bucket index for color named COLOR_NAME in the color
3723 xpm_color_bucket (color_name
)
3729 for (s
= color_name
; *s
; ++s
)
3731 return h
%= XPM_COLOR_CACHE_BUCKETS
;
3735 /* On frame F, cache values COLOR for color with name COLOR_NAME.
3736 BUCKET, if >= 0, is a precomputed bucket index. Value is the cache
3739 static struct xpm_cached_color
*
3740 xpm_cache_color (f
, color_name
, color
, bucket
)
3747 struct xpm_cached_color
*p
;
3750 bucket
= xpm_color_bucket (color_name
);
3752 nbytes
= sizeof *p
+ strlen (color_name
);
3753 p
= (struct xpm_cached_color
*) xmalloc (nbytes
);
3754 strcpy (p
->name
, color_name
);
3756 p
->next
= xpm_color_cache
[bucket
];
3757 xpm_color_cache
[bucket
] = p
;
3761 /* Look up color COLOR_NAME for frame F in the color cache. If found,
3762 return the cached definition in *COLOR. Otherwise, make a new
3763 entry in the cache and allocate the color. Value is zero if color
3764 allocation failed. */
3767 xpm_lookup_color (f
, color_name
, color
)
3772 struct xpm_cached_color
*p
;
3773 int h
= xpm_color_bucket (color_name
);
3775 for (p
= xpm_color_cache
[h
]; p
; p
= p
->next
)
3776 if (strcmp (p
->name
, color_name
) == 0)
3781 else if (XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
3784 color
->pixel
= lookup_rgb_color (f
, color
->red
, color
->green
,
3786 p
= xpm_cache_color (f
, color_name
, color
, h
);
3788 /* You get `opaque' at least from ImageMagick converting pbm to xpm
3789 with transparency, and it's useful. */
3790 else if (strcmp ("opaque", color_name
) == 0)
3792 bzero (color
, sizeof (XColor
)); /* Is this necessary/correct? */
3793 color
->pixel
= FRAME_FOREGROUND_PIXEL (f
);
3794 p
= xpm_cache_color (f
, color_name
, color
, h
);
3801 /* Callback for allocating color COLOR_NAME. Called from the XPM lib.
3802 CLOSURE is a pointer to the frame on which we allocate the
3803 color. Return in *COLOR the allocated color. Value is non-zero
3807 xpm_alloc_color (dpy
, cmap
, color_name
, color
, closure
)
3814 return xpm_lookup_color ((struct frame
*) closure
, color_name
, color
);
3818 /* Callback for freeing NPIXELS colors contained in PIXELS. CLOSURE
3819 is a pointer to the frame on which we allocate the color. Value is
3820 non-zero if successful. */
3823 xpm_free_colors (dpy
, cmap
, pixels
, npixels
, closure
)
3833 #endif /* ALLOC_XPM_COLORS */
3838 /* XPM library details. */
3840 DEF_IMGLIB_FN (XpmFreeAttributes
);
3841 DEF_IMGLIB_FN (XpmCreateImageFromBuffer
);
3842 DEF_IMGLIB_FN (XpmReadFileToImage
);
3843 DEF_IMGLIB_FN (XImageFree
);
3846 init_xpm_functions (Lisp_Object libraries
)
3850 if (!(library
= w32_delayed_load (libraries
, Qxpm
)))
3853 LOAD_IMGLIB_FN (library
, XpmFreeAttributes
);
3854 LOAD_IMGLIB_FN (library
, XpmCreateImageFromBuffer
);
3855 LOAD_IMGLIB_FN (library
, XpmReadFileToImage
);
3856 LOAD_IMGLIB_FN (library
, XImageFree
);
3860 #endif /* HAVE_NTGUI */
3863 /* Value is non-zero if COLOR_SYMBOLS is a valid color symbols list
3864 for XPM images. Such a list must consist of conses whose car and
3868 xpm_valid_color_symbols_p (color_symbols
)
3869 Lisp_Object color_symbols
;
3871 while (CONSP (color_symbols
))
3873 Lisp_Object sym
= XCAR (color_symbols
);
3875 || !STRINGP (XCAR (sym
))
3876 || !STRINGP (XCDR (sym
)))
3878 color_symbols
= XCDR (color_symbols
);
3881 return NILP (color_symbols
);
3885 /* Value is non-zero if OBJECT is a valid XPM image specification. */
3888 xpm_image_p (object
)
3891 struct image_keyword fmt
[XPM_LAST
];
3892 bcopy (xpm_format
, fmt
, sizeof fmt
);
3893 return (parse_image_spec (object
, fmt
, XPM_LAST
, Qxpm
)
3894 /* Either `:file' or `:data' must be present. */
3895 && fmt
[XPM_FILE
].count
+ fmt
[XPM_DATA
].count
== 1
3896 /* Either no `:color-symbols' or it's a list of conses
3897 whose car and cdr are strings. */
3898 && (fmt
[XPM_COLOR_SYMBOLS
].count
== 0
3899 || xpm_valid_color_symbols_p (fmt
[XPM_COLOR_SYMBOLS
].value
)));
3902 #endif /* HAVE_XPM || MAC_OS */
3904 #if defined (HAVE_XPM) && defined (HAVE_X_WINDOWS)
3906 x_create_bitmap_from_xpm_data (f
, bits
)
3910 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
3912 XpmAttributes attrs
;
3913 Pixmap bitmap
, mask
;
3915 bzero (&attrs
, sizeof attrs
);
3917 attrs
.visual
= FRAME_X_VISUAL (f
);
3918 attrs
.colormap
= FRAME_X_COLORMAP (f
);
3919 attrs
.valuemask
|= XpmVisual
;
3920 attrs
.valuemask
|= XpmColormap
;
3922 rc
= XpmCreatePixmapFromData (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3923 bits
, &bitmap
, &mask
, &attrs
);
3924 if (rc
!= XpmSuccess
)
3926 XpmFreeAttributes (&attrs
);
3930 id
= x_allocate_bitmap_record (f
);
3931 dpyinfo
->bitmaps
[id
- 1].pixmap
= bitmap
;
3932 dpyinfo
->bitmaps
[id
- 1].have_mask
= 1;
3933 dpyinfo
->bitmaps
[id
- 1].mask
= mask
;
3934 dpyinfo
->bitmaps
[id
- 1].file
= NULL
;
3935 dpyinfo
->bitmaps
[id
- 1].height
= attrs
.height
;
3936 dpyinfo
->bitmaps
[id
- 1].width
= attrs
.width
;
3937 dpyinfo
->bitmaps
[id
- 1].depth
= attrs
.depth
;
3938 dpyinfo
->bitmaps
[id
- 1].refcount
= 1;
3940 XpmFreeAttributes (&attrs
);
3943 #endif /* defined (HAVE_XPM) && defined (HAVE_X_WINDOWS) */
3945 /* Load image IMG which will be displayed on frame F. Value is
3946 non-zero if successful. */
3956 XpmAttributes attrs
;
3957 Lisp_Object specified_file
, color_symbols
;
3960 xpm_XImage
* xpm_image
= NULL
, * xpm_mask
= NULL
;
3961 #endif /* HAVE_NTGUI */
3963 /* Configure the XPM lib. Use the visual of frame F. Allocate
3964 close colors. Return colors allocated. */
3965 bzero (&attrs
, sizeof attrs
);
3968 attrs
.visual
= FRAME_X_VISUAL (f
);
3969 attrs
.colormap
= FRAME_X_COLORMAP (f
);
3970 attrs
.valuemask
|= XpmVisual
;
3971 attrs
.valuemask
|= XpmColormap
;
3972 #endif /* HAVE_NTGUI */
3974 #ifdef ALLOC_XPM_COLORS
3975 /* Allocate colors with our own functions which handle
3976 failing color allocation more gracefully. */
3977 attrs
.color_closure
= f
;
3978 attrs
.alloc_color
= xpm_alloc_color
;
3979 attrs
.free_colors
= xpm_free_colors
;
3980 attrs
.valuemask
|= XpmAllocColor
| XpmFreeColors
| XpmColorClosure
;
3981 #else /* not ALLOC_XPM_COLORS */
3982 /* Let the XPM lib allocate colors. */
3983 attrs
.valuemask
|= XpmReturnAllocPixels
;
3984 #ifdef XpmAllocCloseColors
3985 attrs
.alloc_close_colors
= 1;
3986 attrs
.valuemask
|= XpmAllocCloseColors
;
3987 #else /* not XpmAllocCloseColors */
3988 attrs
.closeness
= 600;
3989 attrs
.valuemask
|= XpmCloseness
;
3990 #endif /* not XpmAllocCloseColors */
3991 #endif /* ALLOC_XPM_COLORS */
3993 /* If image specification contains symbolic color definitions, add
3994 these to `attrs'. */
3995 color_symbols
= image_spec_value (img
->spec
, QCcolor_symbols
, NULL
);
3996 if (CONSP (color_symbols
))
3999 XpmColorSymbol
*xpm_syms
;
4002 attrs
.valuemask
|= XpmColorSymbols
;
4004 /* Count number of symbols. */
4005 attrs
.numsymbols
= 0;
4006 for (tail
= color_symbols
; CONSP (tail
); tail
= XCDR (tail
))
4009 /* Allocate an XpmColorSymbol array. */
4010 size
= attrs
.numsymbols
* sizeof *xpm_syms
;
4011 xpm_syms
= (XpmColorSymbol
*) alloca (size
);
4012 bzero (xpm_syms
, size
);
4013 attrs
.colorsymbols
= xpm_syms
;
4015 /* Fill the color symbol array. */
4016 for (tail
= color_symbols
, i
= 0;
4018 ++i
, tail
= XCDR (tail
))
4020 Lisp_Object name
= XCAR (XCAR (tail
));
4021 Lisp_Object color
= XCDR (XCAR (tail
));
4022 xpm_syms
[i
].name
= (char *) alloca (SCHARS (name
) + 1);
4023 strcpy (xpm_syms
[i
].name
, SDATA (name
));
4024 xpm_syms
[i
].value
= (char *) alloca (SCHARS (color
) + 1);
4025 strcpy (xpm_syms
[i
].value
, SDATA (color
));
4029 /* Create a pixmap for the image, either from a file, or from a
4030 string buffer containing data in the same format as an XPM file. */
4031 #ifdef ALLOC_XPM_COLORS
4032 xpm_init_color_cache (f
, &attrs
);
4035 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
4039 HDC frame_dc
= get_frame_dc (f
);
4040 hdc
= CreateCompatibleDC (frame_dc
);
4041 release_frame_dc (f
, frame_dc
);
4043 #endif /* HAVE_NTGUI */
4045 if (STRINGP (specified_file
))
4047 Lisp_Object file
= x_find_image_file (specified_file
);
4048 if (!STRINGP (file
))
4050 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
4055 /* XpmReadFileToPixmap is not available in the Windows port of
4056 libxpm. But XpmReadFileToImage almost does what we want. */
4057 rc
= fn_XpmReadFileToImage (&hdc
, SDATA (file
),
4058 &xpm_image
, &xpm_mask
,
4061 rc
= XpmReadFileToPixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
4062 SDATA (file
), &img
->pixmap
, &img
->mask
,
4064 #endif /* HAVE_NTGUI */
4068 Lisp_Object buffer
= image_spec_value (img
->spec
, QCdata
, NULL
);
4070 /* XpmCreatePixmapFromBuffer is not available in the Windows port
4071 of libxpm. But XpmCreateImageFromBuffer almost does what we want. */
4072 rc
= fn_XpmCreateImageFromBuffer (&hdc
, SDATA (buffer
),
4073 &xpm_image
, &xpm_mask
,
4076 rc
= XpmCreatePixmapFromBuffer (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
4078 &img
->pixmap
, &img
->mask
,
4080 #endif /* HAVE_NTGUI */
4083 if (rc
== XpmSuccess
)
4085 #if defined (COLOR_TABLE_SUPPORT) && defined (ALLOC_XPM_COLORS)
4086 img
->colors
= colors_in_color_table (&img
->ncolors
);
4087 #else /* not ALLOC_XPM_COLORS */
4091 /* W32 XPM uses XImage to wrap what W32 Emacs calls a Pixmap,
4092 plus some duplicate attributes. */
4093 if (xpm_image
&& xpm_image
->bitmap
)
4095 img
->pixmap
= xpm_image
->bitmap
;
4096 /* XImageFree in libXpm frees XImage struct without destroying
4097 the bitmap, which is what we want. */
4098 fn_XImageFree (xpm_image
);
4100 if (xpm_mask
&& xpm_mask
->bitmap
)
4102 /* The mask appears to be inverted compared with what we expect.
4103 TODO: invert our expectations. See other places where we
4104 have to invert bits because our idea of masks is backwards. */
4106 old_obj
= SelectObject (hdc
, xpm_mask
->bitmap
);
4108 PatBlt (hdc
, 0, 0, xpm_mask
->width
, xpm_mask
->height
, DSTINVERT
);
4109 SelectObject (hdc
, old_obj
);
4111 img
->mask
= xpm_mask
->bitmap
;
4112 fn_XImageFree (xpm_mask
);
4117 #endif /* HAVE_NTGUI */
4119 /* Remember allocated colors. */
4120 img
->ncolors
= attrs
.nalloc_pixels
;
4121 img
->colors
= (unsigned long *) xmalloc (img
->ncolors
4122 * sizeof *img
->colors
);
4123 for (i
= 0; i
< attrs
.nalloc_pixels
; ++i
)
4125 img
->colors
[i
] = attrs
.alloc_pixels
[i
];
4126 #ifdef DEBUG_X_COLORS
4127 register_color (img
->colors
[i
]);
4130 #endif /* not ALLOC_XPM_COLORS */
4132 img
->width
= attrs
.width
;
4133 img
->height
= attrs
.height
;
4134 xassert (img
->width
> 0 && img
->height
> 0);
4136 /* The call to XpmFreeAttributes below frees attrs.alloc_pixels. */
4138 fn_XpmFreeAttributes (&attrs
);
4140 XpmFreeAttributes (&attrs
);
4141 #endif /* HAVE_NTGUI */
4147 #endif /* HAVE_NTGUI */
4152 image_error ("Error opening XPM file (%s)", img
->spec
, Qnil
);
4155 case XpmFileInvalid
:
4156 image_error ("Invalid XPM file (%s)", img
->spec
, Qnil
);
4160 image_error ("Out of memory (%s)", img
->spec
, Qnil
);
4163 case XpmColorFailed
:
4164 image_error ("Color allocation error (%s)", img
->spec
, Qnil
);
4168 image_error ("Unknown error (%s)", img
->spec
, Qnil
);
4173 #ifdef ALLOC_XPM_COLORS
4174 xpm_free_color_cache ();
4176 return rc
== XpmSuccess
;
4179 #endif /* HAVE_XPM */
4183 /* XPM support functions for Mac OS where libxpm is not available.
4184 Only XPM version 3 (without any extensions) is supported. */
4186 static int xpm_scan
P_ ((const unsigned char **, const unsigned char *,
4187 const unsigned char **, int *));
4188 static Lisp_Object xpm_make_color_table_v
4189 P_ ((void (**) (Lisp_Object
, const unsigned char *, int, Lisp_Object
),
4190 Lisp_Object (**) (Lisp_Object
, const unsigned char *, int)));
4191 static void xpm_put_color_table_v
P_ ((Lisp_Object
, const unsigned char *,
4193 static Lisp_Object xpm_get_color_table_v
P_ ((Lisp_Object
,
4194 const unsigned char *, int));
4195 static Lisp_Object xpm_make_color_table_h
4196 P_ ((void (**) (Lisp_Object
, const unsigned char *, int, Lisp_Object
),
4197 Lisp_Object (**) (Lisp_Object
, const unsigned char *, int)));
4198 static void xpm_put_color_table_h
P_ ((Lisp_Object
, const unsigned char *,
4200 static Lisp_Object xpm_get_color_table_h
P_ ((Lisp_Object
,
4201 const unsigned char *, int));
4202 static int xpm_str_to_color_key
P_ ((const char *));
4203 static int xpm_load_image
P_ ((struct frame
*, struct image
*,
4204 const unsigned char *, const unsigned char *));
4206 /* Tokens returned from xpm_scan. */
4215 /* Scan an XPM data and return a character (< 256) or a token defined
4216 by enum xpm_token above. *S and END are the start (inclusive) and
4217 the end (exclusive) addresses of the data, respectively. Advance
4218 *S while scanning. If token is either XPM_TK_IDENT or
4219 XPM_TK_STRING, *BEG and *LEN are set to the start address and the
4220 length of the corresponding token, respectively. */
4223 xpm_scan (s
, end
, beg
, len
)
4224 const unsigned char **s
, *end
, **beg
;
4231 /* Skip white-space. */
4232 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
4235 /* gnus-pointer.xpm uses '-' in its identifier.
4236 sb-dir-plus.xpm uses '+' in its identifier. */
4237 if (isalpha (c
) || c
== '_' || c
== '-' || c
== '+')
4241 (c
= **s
, isalnum (c
) || c
== '_' || c
== '-' || c
== '+'))
4244 return XPM_TK_IDENT
;
4249 while (*s
< end
&& **s
!= '"')
4254 return XPM_TK_STRING
;
4258 if (*s
< end
&& **s
== '*')
4260 /* C-style comment. */
4264 while (*s
< end
&& *(*s
)++ != '*')
4267 while (*s
< end
&& **s
!= '/');
4281 /* Functions for color table lookup in XPM data. A Key is a string
4282 specifying the color of each pixel in XPM data. A value is either
4283 an integer that specifies a pixel color, Qt that specifies
4284 transparency, or Qnil for the unspecified color. If the length of
4285 the key string is one, a vector is used as a table. Otherwise, a
4286 hash table is used. */
4289 xpm_make_color_table_v (put_func
, get_func
)
4290 void (**put_func
) (Lisp_Object
, const unsigned char *, int, Lisp_Object
);
4291 Lisp_Object (**get_func
) (Lisp_Object
, const unsigned char *, int);
4293 *put_func
= xpm_put_color_table_v
;
4294 *get_func
= xpm_get_color_table_v
;
4295 return Fmake_vector (make_number (256), Qnil
);
4299 xpm_put_color_table_v (color_table
, chars_start
, chars_len
, color
)
4300 Lisp_Object color_table
;
4301 const unsigned char *chars_start
;
4305 XVECTOR (color_table
)->contents
[*chars_start
] = color
;
4309 xpm_get_color_table_v (color_table
, chars_start
, chars_len
)
4310 Lisp_Object color_table
;
4311 const unsigned char *chars_start
;
4314 return XVECTOR (color_table
)->contents
[*chars_start
];
4318 xpm_make_color_table_h (put_func
, get_func
)
4319 void (**put_func
) (Lisp_Object
, const unsigned char *, int, Lisp_Object
);
4320 Lisp_Object (**get_func
) (Lisp_Object
, const unsigned char *, int);
4322 *put_func
= xpm_put_color_table_h
;
4323 *get_func
= xpm_get_color_table_h
;
4324 return make_hash_table (Qequal
, make_number (DEFAULT_HASH_SIZE
),
4325 make_float (DEFAULT_REHASH_SIZE
),
4326 make_float (DEFAULT_REHASH_THRESHOLD
),
4331 xpm_put_color_table_h (color_table
, chars_start
, chars_len
, color
)
4332 Lisp_Object color_table
;
4333 const unsigned char *chars_start
;
4337 struct Lisp_Hash_Table
*table
= XHASH_TABLE (color_table
);
4339 Lisp_Object chars
= make_unibyte_string (chars_start
, chars_len
);
4341 hash_lookup (table
, chars
, &hash_code
);
4342 hash_put (table
, chars
, color
, hash_code
);
4346 xpm_get_color_table_h (color_table
, chars_start
, chars_len
)
4347 Lisp_Object color_table
;
4348 const unsigned char *chars_start
;
4351 struct Lisp_Hash_Table
*table
= XHASH_TABLE (color_table
);
4352 int i
= hash_lookup (table
, make_unibyte_string (chars_start
, chars_len
),
4355 return i
>= 0 ? HASH_VALUE (table
, i
) : Qnil
;
4358 enum xpm_color_key
{
4366 static const char xpm_color_key_strings
[][4] = {"s", "m", "g4", "g", "c"};
4369 xpm_str_to_color_key (s
)
4375 i
< sizeof xpm_color_key_strings
/ sizeof xpm_color_key_strings
[0];
4377 if (strcmp (xpm_color_key_strings
[i
], s
) == 0)
4383 xpm_load_image (f
, img
, contents
, end
)
4386 const unsigned char *contents
, *end
;
4388 const unsigned char *s
= contents
, *beg
, *str
;
4389 unsigned char buffer
[BUFSIZ
];
4390 int width
, height
, x
, y
;
4391 int num_colors
, chars_per_pixel
;
4393 void (*put_color_table
) (Lisp_Object
, const unsigned char *, int, Lisp_Object
);
4394 Lisp_Object (*get_color_table
) (Lisp_Object
, const unsigned char *, int);
4395 Lisp_Object frame
, color_symbols
, color_table
;
4396 int best_key
, have_mask
= 0;
4397 XImagePtr ximg
= NULL
, mask_img
= NULL
;
4400 LA1 = xpm_scan (&s, end, &beg, &len)
4402 #define expect(TOKEN) \
4403 if (LA1 != (TOKEN)) \
4408 #define expect_ident(IDENT) \
4409 if (LA1 == XPM_TK_IDENT \
4410 && strlen ((IDENT)) == len && memcmp ((IDENT), beg, len) == 0) \
4415 if (!(end
- s
>= 9 && memcmp (s
, "/* XPM */", 9) == 0))
4419 expect_ident ("static");
4420 expect_ident ("char");
4422 expect (XPM_TK_IDENT
);
4427 expect (XPM_TK_STRING
);
4430 memcpy (buffer
, beg
, len
);
4432 if (sscanf (buffer
, "%d %d %d %d", &width
, &height
,
4433 &num_colors
, &chars_per_pixel
) != 4
4434 || width
<= 0 || height
<= 0
4435 || num_colors
<= 0 || chars_per_pixel
<= 0)
4438 if (!check_image_size (f
, width
, height
))
4440 image_error ("Invalid image size", Qnil
, Qnil
);
4446 XSETFRAME (frame
, f
);
4447 if (!NILP (Fxw_display_color_p (frame
)))
4448 best_key
= XPM_COLOR_KEY_C
;
4449 else if (!NILP (Fx_display_grayscale_p (frame
)))
4450 best_key
= (XFASTINT (Fx_display_planes (frame
)) > 2
4451 ? XPM_COLOR_KEY_G
: XPM_COLOR_KEY_G4
);
4453 best_key
= XPM_COLOR_KEY_M
;
4455 color_symbols
= image_spec_value (img
->spec
, QCcolor_symbols
, NULL
);
4456 if (chars_per_pixel
== 1)
4457 color_table
= xpm_make_color_table_v (&put_color_table
,
4460 color_table
= xpm_make_color_table_h (&put_color_table
,
4463 while (num_colors
-- > 0)
4465 unsigned char *color
, *max_color
;
4466 int key
, next_key
, max_key
= 0;
4467 Lisp_Object symbol_color
= Qnil
, color_val
;
4470 expect (XPM_TK_STRING
);
4471 if (len
<= chars_per_pixel
|| len
>= BUFSIZ
+ chars_per_pixel
)
4473 memcpy (buffer
, beg
+ chars_per_pixel
, len
- chars_per_pixel
);
4474 buffer
[len
- chars_per_pixel
] = '\0';
4476 str
= strtok (buffer
, " \t");
4479 key
= xpm_str_to_color_key (str
);
4484 color
= strtok (NULL
, " \t");
4488 while ((str
= strtok (NULL
, " \t")) != NULL
)
4490 next_key
= xpm_str_to_color_key (str
);
4493 color
[strlen (color
)] = ' ';
4496 if (key
== XPM_COLOR_KEY_S
)
4498 if (NILP (symbol_color
))
4499 symbol_color
= build_string (color
);
4501 else if (max_key
< key
&& key
<= best_key
)
4511 if (!NILP (color_symbols
) && !NILP (symbol_color
))
4513 Lisp_Object specified_color
= Fassoc (symbol_color
, color_symbols
);
4515 if (CONSP (specified_color
) && STRINGP (XCDR (specified_color
)))
4517 if (xstricmp (SDATA (XCDR (specified_color
)), "None") == 0)
4519 else if (x_defined_color (f
, SDATA (XCDR (specified_color
)),
4521 color_val
= make_number (cdef
.pixel
);
4524 if (NILP (color_val
) && max_key
> 0)
4526 if (xstricmp (max_color
, "None") == 0)
4528 else if (x_defined_color (f
, max_color
, &cdef
, 0))
4529 color_val
= make_number (cdef
.pixel
);
4531 if (!NILP (color_val
))
4532 (*put_color_table
) (color_table
, beg
, chars_per_pixel
, color_val
);
4537 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0,
4538 &ximg
, &img
->pixmap
)
4539 || !x_create_x_image_and_pixmap (f
, width
, height
, 1,
4540 &mask_img
, &img
->mask
))
4542 image_error ("Out of memory (%s)", img
->spec
, Qnil
);
4546 for (y
= 0; y
< height
; y
++)
4548 expect (XPM_TK_STRING
);
4550 if (len
< width
* chars_per_pixel
)
4552 for (x
= 0; x
< width
; x
++, str
+= chars_per_pixel
)
4554 Lisp_Object color_val
=
4555 (*get_color_table
) (color_table
, str
, chars_per_pixel
);
4557 XPutPixel (ximg
, x
, y
,
4558 (INTEGERP (color_val
) ? XINT (color_val
)
4559 : FRAME_FOREGROUND_PIXEL (f
)));
4560 XPutPixel (mask_img
, x
, y
,
4561 (!EQ (color_val
, Qt
) ? PIX_MASK_DRAW
4562 : (have_mask
= 1, PIX_MASK_RETAIN
)));
4569 img
->height
= height
;
4571 /* Maybe fill in the background field while we have ximg handy. */
4572 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
4573 IMAGE_BACKGROUND (img
, f
, ximg
);
4575 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
4576 x_destroy_x_image (ximg
);
4579 /* Fill in the background_transparent field while we have the
4581 image_background_transparent (img
, f
, mask_img
);
4583 x_put_x_image (f
, mask_img
, img
->mask
, width
, height
);
4584 x_destroy_x_image (mask_img
);
4588 x_destroy_x_image (mask_img
);
4589 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
4590 img
->mask
= NO_PIXMAP
;
4596 image_error ("Invalid XPM file (%s)", img
->spec
, Qnil
);
4598 x_destroy_x_image (ximg
);
4599 x_destroy_x_image (mask_img
);
4600 x_clear_image (f
, img
);
4614 Lisp_Object file_name
;
4616 /* If IMG->spec specifies a file name, create a non-file spec from it. */
4617 file_name
= image_spec_value (img
->spec
, QCfile
, NULL
);
4618 if (STRINGP (file_name
))
4621 unsigned char *contents
;
4623 struct gcpro gcpro1
;
4625 file
= x_find_image_file (file_name
);
4627 if (!STRINGP (file
))
4629 image_error ("Cannot find image file `%s'", file_name
, Qnil
);
4634 contents
= slurp_file (SDATA (file
), &size
);
4635 if (contents
== NULL
)
4637 image_error ("Error loading XPM image `%s'", img
->spec
, Qnil
);
4642 success_p
= xpm_load_image (f
, img
, contents
, contents
+ size
);
4650 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
4651 success_p
= xpm_load_image (f
, img
, SDATA (data
),
4652 SDATA (data
) + SBYTES (data
));
4662 /***********************************************************************
4664 ***********************************************************************/
4666 #ifdef COLOR_TABLE_SUPPORT
4668 /* An entry in the color table mapping an RGB color to a pixel color. */
4673 unsigned long pixel
;
4675 /* Next in color table collision list. */
4676 struct ct_color
*next
;
4679 /* The bucket vector size to use. Must be prime. */
4683 /* Value is a hash of the RGB color given by R, G, and B. */
4685 #define CT_HASH_RGB(R, G, B) (((R) << 16) ^ ((G) << 8) ^ (B))
4687 /* The color hash table. */
4689 struct ct_color
**ct_table
;
4691 /* Number of entries in the color table. */
4693 int ct_colors_allocated
;
4695 /* Initialize the color table. */
4700 int size
= CT_SIZE
* sizeof (*ct_table
);
4701 ct_table
= (struct ct_color
**) xmalloc (size
);
4702 bzero (ct_table
, size
);
4703 ct_colors_allocated
= 0;
4707 /* Free memory associated with the color table. */
4713 struct ct_color
*p
, *next
;
4715 for (i
= 0; i
< CT_SIZE
; ++i
)
4716 for (p
= ct_table
[i
]; p
; p
= next
)
4727 /* Value is a pixel color for RGB color R, G, B on frame F. If an
4728 entry for that color already is in the color table, return the
4729 pixel color of that entry. Otherwise, allocate a new color for R,
4730 G, B, and make an entry in the color table. */
4732 static unsigned long
4733 lookup_rgb_color (f
, r
, g
, b
)
4737 unsigned hash
= CT_HASH_RGB (r
, g
, b
);
4738 int i
= hash
% CT_SIZE
;
4740 Display_Info
*dpyinfo
;
4742 /* Handle TrueColor visuals specially, which improves performance by
4743 two orders of magnitude. Freeing colors on TrueColor visuals is
4744 a nop, and pixel colors specify RGB values directly. See also
4745 the Xlib spec, chapter 3.1. */
4746 dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
4747 if (dpyinfo
->red_bits
> 0)
4749 unsigned long pr
, pg
, pb
;
4751 /* Apply gamma-correction like normal color allocation does. */
4755 color
.red
= r
, color
.green
= g
, color
.blue
= b
;
4756 gamma_correct (f
, &color
);
4757 r
= color
.red
, g
= color
.green
, b
= color
.blue
;
4760 /* Scale down RGB values to the visual's bits per RGB, and shift
4761 them to the right position in the pixel color. Note that the
4762 original RGB values are 16-bit values, as usual in X. */
4763 pr
= (r
>> (16 - dpyinfo
->red_bits
)) << dpyinfo
->red_offset
;
4764 pg
= (g
>> (16 - dpyinfo
->green_bits
)) << dpyinfo
->green_offset
;
4765 pb
= (b
>> (16 - dpyinfo
->blue_bits
)) << dpyinfo
->blue_offset
;
4767 /* Assemble the pixel color. */
4768 return pr
| pg
| pb
;
4771 for (p
= ct_table
[i
]; p
; p
= p
->next
)
4772 if (p
->r
== r
&& p
->g
== g
&& p
->b
== b
)
4778 #ifdef HAVE_X_WINDOWS
4787 cmap
= FRAME_X_COLORMAP (f
);
4788 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
4791 ++ct_colors_allocated
;
4792 p
= (struct ct_color
*) xmalloc (sizeof *p
);
4796 p
->pixel
= color
.pixel
;
4797 p
->next
= ct_table
[i
];
4801 return FRAME_FOREGROUND_PIXEL (f
);
4806 color
= PALETTERGB (r
, g
, b
);
4808 color
= RGB_TO_ULONG (r
, g
, b
);
4809 #endif /* HAVE_NTGUI */
4810 ++ct_colors_allocated
;
4811 p
= (struct ct_color
*) xmalloc (sizeof *p
);
4816 p
->next
= ct_table
[i
];
4818 #endif /* HAVE_X_WINDOWS */
4826 /* Look up pixel color PIXEL which is used on frame F in the color
4827 table. If not already present, allocate it. Value is PIXEL. */
4829 static unsigned long
4830 lookup_pixel_color (f
, pixel
)
4832 unsigned long pixel
;
4834 int i
= pixel
% CT_SIZE
;
4837 for (p
= ct_table
[i
]; p
; p
= p
->next
)
4838 if (p
->pixel
== pixel
)
4847 #ifdef HAVE_X_WINDOWS
4848 cmap
= FRAME_X_COLORMAP (f
);
4849 color
.pixel
= pixel
;
4850 x_query_color (f
, &color
);
4851 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
4854 cmap
= DefaultColormapOfScreen (FRAME_X_SCREEN (f
));
4855 color
.pixel
= pixel
;
4856 XQueryColor (NULL
, cmap
, &color
);
4857 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
4859 #endif /* HAVE_X_WINDOWS */
4863 ++ct_colors_allocated
;
4865 p
= (struct ct_color
*) xmalloc (sizeof *p
);
4870 p
->next
= ct_table
[i
];
4874 return FRAME_FOREGROUND_PIXEL (f
);
4880 /* Value is a vector of all pixel colors contained in the color table,
4881 allocated via xmalloc. Set *N to the number of colors. */
4883 static unsigned long *
4884 colors_in_color_table (n
)
4889 unsigned long *colors
;
4891 if (ct_colors_allocated
== 0)
4898 colors
= (unsigned long *) xmalloc (ct_colors_allocated
4900 *n
= ct_colors_allocated
;
4902 for (i
= j
= 0; i
< CT_SIZE
; ++i
)
4903 for (p
= ct_table
[i
]; p
; p
= p
->next
)
4904 colors
[j
++] = p
->pixel
;
4910 #else /* COLOR_TABLE_SUPPORT */
4912 static unsigned long
4913 lookup_rgb_color (f
, r
, g
, b
)
4917 unsigned long pixel
;
4920 pixel
= RGB_TO_ULONG (r
>> 8, g
>> 8, b
>> 8);
4921 gamma_correct (f
, &pixel
);
4925 pixel
= PALETTERGB (r
>> 8, g
>> 8, b
>> 8);
4926 #endif /* HAVE_NTGUI */
4935 #endif /* COLOR_TABLE_SUPPORT */
4938 /***********************************************************************
4940 ***********************************************************************/
4942 static XColor
*x_to_xcolors
P_ ((struct frame
*, struct image
*, int));
4943 static void x_from_xcolors
P_ ((struct frame
*, struct image
*, XColor
*));
4944 static void x_detect_edges
P_ ((struct frame
*, struct image
*, int[9], int));
4947 static void XPutPixel (XImagePtr
, int, int, COLORREF
);
4948 #endif /* HAVE_NTGUI */
4950 /* Non-zero means draw a cross on images having `:conversion
4953 int cross_disabled_images
;
4955 /* Edge detection matrices for different edge-detection
4958 static int emboss_matrix
[9] = {
4960 2, -1, 0, /* y - 1 */
4962 0, 1, -2 /* y + 1 */
4965 static int laplace_matrix
[9] = {
4967 1, 0, 0, /* y - 1 */
4969 0, 0, -1 /* y + 1 */
4972 /* Value is the intensity of the color whose red/green/blue values
4975 #define COLOR_INTENSITY(R, G, B) ((2 * (R) + 3 * (G) + (B)) / 6)
4978 /* On frame F, return an array of XColor structures describing image
4979 IMG->pixmap. Each XColor structure has its pixel color set. RGB_P
4980 non-zero means also fill the red/green/blue members of the XColor
4981 structures. Value is a pointer to the array of XColors structures,
4982 allocated with xmalloc; it must be freed by the caller. */
4985 x_to_xcolors (f
, img
, rgb_p
)
4992 XImagePtr_or_DC ximg
;
4996 #endif /* HAVE_NTGUI */
4998 colors
= (XColor
*) xmalloc (img
->width
* img
->height
* sizeof *colors
);
5001 /* Get the X image IMG->pixmap. */
5002 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
5003 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
5005 /* Load the image into a memory device context. */
5006 hdc
= get_frame_dc (f
);
5007 ximg
= CreateCompatibleDC (hdc
);
5008 release_frame_dc (f
, hdc
);
5009 prev
= SelectObject (ximg
, img
->pixmap
);
5010 #endif /* HAVE_NTGUI */
5012 /* Fill the `pixel' members of the XColor array. I wished there
5013 were an easy and portable way to circumvent XGetPixel. */
5015 for (y
= 0; y
< img
->height
; ++y
)
5019 #ifdef HAVE_X_WINDOWS
5020 for (x
= 0; x
< img
->width
; ++x
, ++p
)
5021 p
->pixel
= XGetPixel (ximg
, x
, y
);
5023 x_query_colors (f
, row
, img
->width
);
5027 for (x
= 0; x
< img
->width
; ++x
, ++p
)
5029 /* W32_TODO: palette support needed here? */
5030 p
->pixel
= GET_PIXEL (ximg
, x
, y
);
5034 p
->red
= RED16_FROM_ULONG (p
->pixel
);
5035 p
->green
= GREEN16_FROM_ULONG (p
->pixel
);
5036 p
->blue
= BLUE16_FROM_ULONG (p
->pixel
);
5039 p
->red
= 256 * GetRValue (p
->pixel
);
5040 p
->green
= 256 * GetGValue (p
->pixel
);
5041 p
->blue
= 256 * GetBValue (p
->pixel
);
5042 #endif /* HAVE_NTGUI */
5045 #endif /* HAVE_X_WINDOWS */
5048 Destroy_Image (ximg
, prev
);
5055 /* Put a pixel of COLOR at position X, Y in XIMG. XIMG must have been
5056 created with CreateDIBSection, with the pointer to the bit values
5057 stored in ximg->data. */
5059 static void XPutPixel (ximg
, x
, y
, color
)
5064 int width
= ximg
->info
.bmiHeader
.biWidth
;
5065 int height
= ximg
->info
.bmiHeader
.biHeight
;
5066 unsigned char * pixel
;
5068 /* True color images. */
5069 if (ximg
->info
.bmiHeader
.biBitCount
== 24)
5071 int rowbytes
= width
* 3;
5072 /* Ensure scanlines are aligned on 4 byte boundaries. */
5074 rowbytes
+= 4 - (rowbytes
% 4);
5076 pixel
= ximg
->data
+ y
* rowbytes
+ x
* 3;
5077 /* Windows bitmaps are in BGR order. */
5078 *pixel
= GetBValue (color
);
5079 *(pixel
+ 1) = GetGValue (color
);
5080 *(pixel
+ 2) = GetRValue (color
);
5082 /* Monochrome images. */
5083 else if (ximg
->info
.bmiHeader
.biBitCount
== 1)
5085 int rowbytes
= width
/ 8;
5086 /* Ensure scanlines are aligned on 4 byte boundaries. */
5088 rowbytes
+= 4 - (rowbytes
% 4);
5089 pixel
= ximg
->data
+ y
* rowbytes
+ x
/ 8;
5090 /* Filter out palette info. */
5091 if (color
& 0x00ffffff)
5092 *pixel
= *pixel
| (1 << x
% 8);
5094 *pixel
= *pixel
& ~(1 << x
% 8);
5097 image_error ("XPutPixel: palette image not supported", Qnil
, Qnil
);
5100 #endif /* HAVE_NTGUI */
5102 /* Create IMG->pixmap from an array COLORS of XColor structures, whose
5103 RGB members are set. F is the frame on which this all happens.
5104 COLORS will be freed; an existing IMG->pixmap will be freed, too. */
5107 x_from_xcolors (f
, img
, colors
)
5117 init_color_table ();
5119 x_create_x_image_and_pixmap (f
, img
->width
, img
->height
, 0,
5122 for (y
= 0; y
< img
->height
; ++y
)
5123 for (x
= 0; x
< img
->width
; ++x
, ++p
)
5125 unsigned long pixel
;
5126 pixel
= lookup_rgb_color (f
, p
->red
, p
->green
, p
->blue
);
5127 XPutPixel (oimg
, x
, y
, pixel
);
5131 x_clear_image_1 (f
, img
, 1, 0, 1);
5133 x_put_x_image (f
, oimg
, pixmap
, img
->width
, img
->height
);
5134 x_destroy_x_image (oimg
);
5135 img
->pixmap
= pixmap
;
5136 #ifdef COLOR_TABLE_SUPPORT
5137 img
->colors
= colors_in_color_table (&img
->ncolors
);
5138 free_color_table ();
5139 #endif /* COLOR_TABLE_SUPPORT */
5143 /* On frame F, perform edge-detection on image IMG.
5145 MATRIX is a nine-element array specifying the transformation
5146 matrix. See emboss_matrix for an example.
5148 COLOR_ADJUST is a color adjustment added to each pixel of the
5152 x_detect_edges (f
, img
, matrix
, color_adjust
)
5155 int matrix
[9], color_adjust
;
5157 XColor
*colors
= x_to_xcolors (f
, img
, 1);
5161 for (i
= sum
= 0; i
< 9; ++i
)
5162 sum
+= abs (matrix
[i
]);
5164 #define COLOR(A, X, Y) ((A) + (Y) * img->width + (X))
5166 new = (XColor
*) xmalloc (img
->width
* img
->height
* sizeof *new);
5168 for (y
= 0; y
< img
->height
; ++y
)
5170 p
= COLOR (new, 0, y
);
5171 p
->red
= p
->green
= p
->blue
= 0xffff/2;
5172 p
= COLOR (new, img
->width
- 1, y
);
5173 p
->red
= p
->green
= p
->blue
= 0xffff/2;
5176 for (x
= 1; x
< img
->width
- 1; ++x
)
5178 p
= COLOR (new, x
, 0);
5179 p
->red
= p
->green
= p
->blue
= 0xffff/2;
5180 p
= COLOR (new, x
, img
->height
- 1);
5181 p
->red
= p
->green
= p
->blue
= 0xffff/2;
5184 for (y
= 1; y
< img
->height
- 1; ++y
)
5186 p
= COLOR (new, 1, y
);
5188 for (x
= 1; x
< img
->width
- 1; ++x
, ++p
)
5190 int r
, g
, b
, y1
, x1
;
5193 for (y1
= y
- 1; y1
< y
+ 2; ++y1
)
5194 for (x1
= x
- 1; x1
< x
+ 2; ++x1
, ++i
)
5197 XColor
*t
= COLOR (colors
, x1
, y1
);
5198 r
+= matrix
[i
] * t
->red
;
5199 g
+= matrix
[i
] * t
->green
;
5200 b
+= matrix
[i
] * t
->blue
;
5203 r
= (r
/ sum
+ color_adjust
) & 0xffff;
5204 g
= (g
/ sum
+ color_adjust
) & 0xffff;
5205 b
= (b
/ sum
+ color_adjust
) & 0xffff;
5206 p
->red
= p
->green
= p
->blue
= COLOR_INTENSITY (r
, g
, b
);
5211 x_from_xcolors (f
, img
, new);
5217 /* Perform the pre-defined `emboss' edge-detection on image IMG
5225 x_detect_edges (f
, img
, emboss_matrix
, 0xffff / 2);
5229 /* Transform image IMG which is used on frame F with a Laplace
5230 edge-detection algorithm. The result is an image that can be used
5231 to draw disabled buttons, for example. */
5238 x_detect_edges (f
, img
, laplace_matrix
, 45000);
5242 /* Perform edge-detection on image IMG on frame F, with specified
5243 transformation matrix MATRIX and color-adjustment COLOR_ADJUST.
5245 MATRIX must be either
5247 - a list of at least 9 numbers in row-major form
5248 - a vector of at least 9 numbers
5250 COLOR_ADJUST nil means use a default; otherwise it must be a
5254 x_edge_detection (f
, img
, matrix
, color_adjust
)
5257 Lisp_Object matrix
, color_adjust
;
5265 i
< 9 && CONSP (matrix
) && NUMBERP (XCAR (matrix
));
5266 ++i
, matrix
= XCDR (matrix
))
5267 trans
[i
] = XFLOATINT (XCAR (matrix
));
5269 else if (VECTORP (matrix
) && ASIZE (matrix
) >= 9)
5271 for (i
= 0; i
< 9 && NUMBERP (AREF (matrix
, i
)); ++i
)
5272 trans
[i
] = XFLOATINT (AREF (matrix
, i
));
5275 if (NILP (color_adjust
))
5276 color_adjust
= make_number (0xffff / 2);
5278 if (i
== 9 && NUMBERP (color_adjust
))
5279 x_detect_edges (f
, img
, trans
, (int) XFLOATINT (color_adjust
));
5283 /* Transform image IMG on frame F so that it looks disabled. */
5286 x_disable_image (f
, img
)
5290 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
5292 int n_planes
= dpyinfo
->n_planes
* dpyinfo
->n_cbits
;
5294 int n_planes
= dpyinfo
->n_planes
;
5295 #endif /* HAVE_NTGUI */
5299 /* Color (or grayscale). Convert to gray, and equalize. Just
5300 drawing such images with a stipple can look very odd, so
5301 we're using this method instead. */
5302 XColor
*colors
= x_to_xcolors (f
, img
, 1);
5304 const int h
= 15000;
5305 const int l
= 30000;
5307 for (p
= colors
, end
= colors
+ img
->width
* img
->height
;
5311 int i
= COLOR_INTENSITY (p
->red
, p
->green
, p
->blue
);
5312 int i2
= (0xffff - h
- l
) * i
/ 0xffff + l
;
5313 p
->red
= p
->green
= p
->blue
= i2
;
5316 x_from_xcolors (f
, img
, colors
);
5319 /* Draw a cross over the disabled image, if we must or if we
5321 if (n_planes
< 2 || cross_disabled_images
)
5324 Display
*dpy
= FRAME_X_DISPLAY (f
);
5328 #define MaskForeground(f) PIX_MASK_DRAW
5330 #define MaskForeground(f) WHITE_PIX_DEFAULT (f)
5333 gc
= XCreateGC (dpy
, img
->pixmap
, 0, NULL
);
5334 XSetForeground (dpy
, gc
, BLACK_PIX_DEFAULT (f
));
5335 XDrawLine (dpy
, img
->pixmap
, gc
, 0, 0,
5336 img
->width
- 1, img
->height
- 1);
5337 XDrawLine (dpy
, img
->pixmap
, gc
, 0, img
->height
- 1,
5343 gc
= XCreateGC (dpy
, img
->mask
, 0, NULL
);
5344 XSetForeground (dpy
, gc
, MaskForeground (f
));
5345 XDrawLine (dpy
, img
->mask
, gc
, 0, 0,
5346 img
->width
- 1, img
->height
- 1);
5347 XDrawLine (dpy
, img
->mask
, gc
, 0, img
->height
- 1,
5355 hdc
= get_frame_dc (f
);
5356 bmpdc
= CreateCompatibleDC (hdc
);
5357 release_frame_dc (f
, hdc
);
5359 prev
= SelectObject (bmpdc
, img
->pixmap
);
5361 SetTextColor (bmpdc
, BLACK_PIX_DEFAULT (f
));
5362 MoveToEx (bmpdc
, 0, 0, NULL
);
5363 LineTo (bmpdc
, img
->width
- 1, img
->height
- 1);
5364 MoveToEx (bmpdc
, 0, img
->height
- 1, NULL
);
5365 LineTo (bmpdc
, img
->width
- 1, 0);
5369 SelectObject (bmpdc
, img
->mask
);
5370 SetTextColor (bmpdc
, WHITE_PIX_DEFAULT (f
));
5371 MoveToEx (bmpdc
, 0, 0, NULL
);
5372 LineTo (bmpdc
, img
->width
- 1, img
->height
- 1);
5373 MoveToEx (bmpdc
, 0, img
->height
- 1, NULL
);
5374 LineTo (bmpdc
, img
->width
- 1, 0);
5376 SelectObject (bmpdc
, prev
);
5378 #endif /* HAVE_NTGUI */
5383 /* Build a mask for image IMG which is used on frame F. FILE is the
5384 name of an image file, for error messages. HOW determines how to
5385 determine the background color of IMG. If it is a list '(R G B)',
5386 with R, G, and B being integers >= 0, take that as the color of the
5387 background. Otherwise, determine the background color of IMG
5388 heuristically. Value is non-zero if successful. */
5391 x_build_heuristic_mask (f
, img
, how
)
5396 XImagePtr_or_DC ximg
;
5404 #endif /* HAVE_NTGUI */
5405 int x
, y
, rc
, use_img_background
;
5406 unsigned long bg
= 0;
5410 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
5411 img
->mask
= NO_PIXMAP
;
5412 img
->background_transparent_valid
= 0;
5416 /* Create an image and pixmap serving as mask. */
5417 rc
= x_create_x_image_and_pixmap (f
, img
->width
, img
->height
, 1,
5418 &mask_img
, &img
->mask
);
5422 /* Get the X image of IMG->pixmap. */
5423 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
, 0, 0,
5424 img
->width
, img
->height
,
5427 /* Create the bit array serving as mask. */
5428 row_width
= (img
->width
+ 7) / 8;
5429 mask_img
= xmalloc (row_width
* img
->height
);
5430 bzero (mask_img
, row_width
* img
->height
);
5432 /* Create a memory device context for IMG->pixmap. */
5433 frame_dc
= get_frame_dc (f
);
5434 ximg
= CreateCompatibleDC (frame_dc
);
5435 release_frame_dc (f
, frame_dc
);
5436 prev
= SelectObject (ximg
, img
->pixmap
);
5437 #endif /* HAVE_NTGUI */
5439 /* Determine the background color of ximg. If HOW is `(R G B)'
5440 take that as color. Otherwise, use the image's background color. */
5441 use_img_background
= 1;
5447 for (i
= 0; i
< 3 && CONSP (how
) && NATNUMP (XCAR (how
)); ++i
)
5449 rgb
[i
] = XFASTINT (XCAR (how
)) & 0xffff;
5453 if (i
== 3 && NILP (how
))
5455 char color_name
[30];
5456 sprintf (color_name
, "#%04x%04x%04x", rgb
[0], rgb
[1], rgb
[2]);
5459 0x00ffffff & /* Filter out palette info. */
5460 #endif /* HAVE_NTGUI */
5461 x_alloc_image_color (f
, img
, build_string (color_name
), 0));
5462 use_img_background
= 0;
5466 if (use_img_background
)
5467 bg
= four_corners_best (ximg
, img
->corners
, img
->width
, img
->height
);
5469 /* Set all bits in mask_img to 1 whose color in ximg is different
5470 from the background color bg. */
5472 for (y
= 0; y
< img
->height
; ++y
)
5473 for (x
= 0; x
< img
->width
; ++x
)
5474 XPutPixel (mask_img
, x
, y
, (XGetPixel (ximg
, x
, y
) != bg
5475 ? PIX_MASK_DRAW
: PIX_MASK_RETAIN
));
5477 /* Fill in the background_transparent field while we have the mask handy. */
5478 image_background_transparent (img
, f
, mask_img
);
5480 /* Put mask_img into img->mask. */
5481 x_put_x_image (f
, mask_img
, img
->mask
, img
->width
, img
->height
);
5482 x_destroy_x_image (mask_img
);
5485 for (y
= 0; y
< img
->height
; ++y
)
5486 for (x
= 0; x
< img
->width
; ++x
)
5488 COLORREF p
= GetPixel (ximg
, x
, y
);
5490 mask_img
[y
* row_width
+ x
/ 8] |= 1 << (x
% 8);
5493 /* Create the mask image. */
5494 img
->mask
= w32_create_pixmap_from_bitmap_data (img
->width
, img
->height
,
5496 /* Fill in the background_transparent field while we have the mask handy. */
5497 SelectObject (ximg
, img
->mask
);
5498 image_background_transparent (img
, f
, ximg
);
5500 /* Was: x_destroy_x_image ((XImagePtr )mask_img); which seems bogus ++kfs */
5502 #endif /* HAVE_NTGUI */
5504 Destroy_Image (ximg
, prev
);
5510 /***********************************************************************
5511 PBM (mono, gray, color)
5512 ***********************************************************************/
5514 static int pbm_image_p
P_ ((Lisp_Object object
));
5515 static int pbm_load
P_ ((struct frame
*f
, struct image
*img
));
5516 static int pbm_scan_number
P_ ((unsigned char **, unsigned char *));
5518 /* The symbol `pbm' identifying images of this type. */
5522 /* Indices of image specification fields in gs_format, below. */
5524 enum pbm_keyword_index
5540 /* Vector of image_keyword structures describing the format
5541 of valid user-defined image specifications. */
5543 static struct image_keyword pbm_format
[PBM_LAST
] =
5545 {":type", IMAGE_SYMBOL_VALUE
, 1},
5546 {":file", IMAGE_STRING_VALUE
, 0},
5547 {":data", IMAGE_STRING_VALUE
, 0},
5548 {":ascent", IMAGE_ASCENT_VALUE
, 0},
5549 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
5550 {":relief", IMAGE_INTEGER_VALUE
, 0},
5551 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5552 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5553 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5554 {":foreground", IMAGE_STRING_OR_NIL_VALUE
, 0},
5555 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
5558 /* Structure describing the image type `pbm'. */
5560 static struct image_type pbm_type
=
5570 /* Return non-zero if OBJECT is a valid PBM image specification. */
5573 pbm_image_p (object
)
5576 struct image_keyword fmt
[PBM_LAST
];
5578 bcopy (pbm_format
, fmt
, sizeof fmt
);
5580 if (!parse_image_spec (object
, fmt
, PBM_LAST
, Qpbm
))
5583 /* Must specify either :data or :file. */
5584 return fmt
[PBM_DATA
].count
+ fmt
[PBM_FILE
].count
== 1;
5588 /* Scan a decimal number from *S and return it. Advance *S while
5589 reading the number. END is the end of the string. Value is -1 at
5593 pbm_scan_number (s
, end
)
5594 unsigned char **s
, *end
;
5596 int c
= 0, val
= -1;
5600 /* Skip white-space. */
5601 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
5606 /* Skip comment to end of line. */
5607 while (*s
< end
&& (c
= *(*s
)++, c
!= '\n'))
5610 else if (isdigit (c
))
5612 /* Read decimal number. */
5614 while (*s
< end
&& (c
= *(*s
)++, isdigit (c
)))
5615 val
= 10 * val
+ c
- '0';
5627 #if 0 /* Unused. ++kfs */
5629 /* Read FILE into memory. Value is a pointer to a buffer allocated
5630 with xmalloc holding FILE's contents. Value is null if an error
5631 occurred. *SIZE is set to the size of the file. */
5634 pbm_read_file (file
, size
)
5642 if (stat (SDATA (file
), &st
) == 0
5643 && (fp
= fopen (SDATA (file
), "rb")) != NULL
5644 && (buf
= (char *) xmalloc (st
.st_size
),
5645 fread (buf
, 1, st
.st_size
, fp
) == st
.st_size
))
5664 #endif /* HAVE_NTGUI */
5666 /* Load PBM image IMG for use on frame F. */
5674 int width
, height
, max_color_idx
= 0;
5676 Lisp_Object file
, specified_file
;
5677 enum {PBM_MONO
, PBM_GRAY
, PBM_COLOR
} type
;
5678 struct gcpro gcpro1
;
5679 unsigned char *contents
= NULL
;
5680 unsigned char *end
, *p
;
5683 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
5687 if (STRINGP (specified_file
))
5689 file
= x_find_image_file (specified_file
);
5690 if (!STRINGP (file
))
5692 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
5697 contents
= slurp_file (SDATA (file
), &size
);
5698 if (contents
== NULL
)
5700 image_error ("Error reading `%s'", file
, Qnil
);
5706 end
= contents
+ size
;
5711 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
5713 end
= p
+ SBYTES (data
);
5716 /* Check magic number. */
5717 if (end
- p
< 2 || *p
++ != 'P')
5719 image_error ("Not a PBM image: `%s'", img
->spec
, Qnil
);
5729 raw_p
= 0, type
= PBM_MONO
;
5733 raw_p
= 0, type
= PBM_GRAY
;
5737 raw_p
= 0, type
= PBM_COLOR
;
5741 raw_p
= 1, type
= PBM_MONO
;
5745 raw_p
= 1, type
= PBM_GRAY
;
5749 raw_p
= 1, type
= PBM_COLOR
;
5753 image_error ("Not a PBM image: `%s'", img
->spec
, Qnil
);
5757 /* Read width, height, maximum color-component. Characters
5758 starting with `#' up to the end of a line are ignored. */
5759 width
= pbm_scan_number (&p
, end
);
5760 height
= pbm_scan_number (&p
, end
);
5762 if (type
!= PBM_MONO
)
5764 max_color_idx
= pbm_scan_number (&p
, end
);
5765 if (raw_p
&& max_color_idx
> 255)
5766 max_color_idx
= 255;
5769 if (!check_image_size (f
, width
, height
)
5770 || (type
!= PBM_MONO
&& max_color_idx
< 0))
5773 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0,
5774 &ximg
, &img
->pixmap
))
5777 /* Initialize the color hash table. */
5778 init_color_table ();
5780 if (type
== PBM_MONO
)
5783 struct image_keyword fmt
[PBM_LAST
];
5784 unsigned long fg
= FRAME_FOREGROUND_PIXEL (f
);
5785 unsigned long bg
= FRAME_BACKGROUND_PIXEL (f
);
5787 /* Parse the image specification. */
5788 bcopy (pbm_format
, fmt
, sizeof fmt
);
5789 parse_image_spec (img
->spec
, fmt
, PBM_LAST
, Qpbm
);
5791 /* Get foreground and background colors, maybe allocate colors. */
5792 if (fmt
[PBM_FOREGROUND
].count
5793 && STRINGP (fmt
[PBM_FOREGROUND
].value
))
5794 fg
= x_alloc_image_color (f
, img
, fmt
[PBM_FOREGROUND
].value
, fg
);
5795 if (fmt
[PBM_BACKGROUND
].count
5796 && STRINGP (fmt
[PBM_BACKGROUND
].value
))
5798 bg
= x_alloc_image_color (f
, img
, fmt
[PBM_BACKGROUND
].value
, bg
);
5799 img
->background
= bg
;
5800 img
->background_valid
= 1;
5803 for (y
= 0; y
< height
; ++y
)
5804 for (x
= 0; x
< width
; ++x
)
5812 x_destroy_x_image (ximg
);
5813 x_clear_image (f
, img
);
5814 image_error ("Invalid image size in image `%s'",
5824 g
= pbm_scan_number (&p
, end
);
5826 XPutPixel (ximg
, x
, y
, g
? fg
: bg
);
5832 && ((type
== PBM_GRAY
)
5833 ? (p
+ height
* width
> end
)
5834 : (p
+ 3 * height
* width
> end
)))
5836 x_destroy_x_image (ximg
);
5837 x_clear_image (f
, img
);
5838 image_error ("Invalid image size in image `%s'",
5843 for (y
= 0; y
< height
; ++y
)
5844 for (x
= 0; x
< width
; ++x
)
5848 if (type
== PBM_GRAY
)
5849 r
= g
= b
= raw_p
? *p
++ : pbm_scan_number (&p
, end
);
5858 r
= pbm_scan_number (&p
, end
);
5859 g
= pbm_scan_number (&p
, end
);
5860 b
= pbm_scan_number (&p
, end
);
5863 if (r
< 0 || g
< 0 || b
< 0)
5865 x_destroy_x_image (ximg
);
5866 image_error ("Invalid pixel value in image `%s'",
5871 /* RGB values are now in the range 0..max_color_idx.
5872 Scale this to the range 0..0xffff supported by X. */
5873 r
= (double) r
* 65535 / max_color_idx
;
5874 g
= (double) g
* 65535 / max_color_idx
;
5875 b
= (double) b
* 65535 / max_color_idx
;
5876 XPutPixel (ximg
, x
, y
, lookup_rgb_color (f
, r
, g
, b
));
5880 #ifdef COLOR_TABLE_SUPPORT
5881 /* Store in IMG->colors the colors allocated for the image, and
5882 free the color table. */
5883 img
->colors
= colors_in_color_table (&img
->ncolors
);
5884 free_color_table ();
5885 #endif /* COLOR_TABLE_SUPPORT */
5888 img
->height
= height
;
5890 /* Maybe fill in the background field while we have ximg handy. */
5892 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
5893 /* Casting avoids a GCC warning. */
5894 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
5896 /* Put the image into a pixmap. */
5897 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
5898 x_destroy_x_image (ximg
);
5900 /* X and W32 versions did it here, MAC version above. ++kfs
5902 img->height = height; */
5910 /***********************************************************************
5912 ***********************************************************************/
5914 #if defined (HAVE_PNG) || defined (MAC_OS)
5916 /* Function prototypes. */
5918 static int png_image_p
P_ ((Lisp_Object object
));
5919 static int png_load
P_ ((struct frame
*f
, struct image
*img
));
5921 /* The symbol `png' identifying images of this type. */
5925 /* Indices of image specification fields in png_format, below. */
5927 enum png_keyword_index
5942 /* Vector of image_keyword structures describing the format
5943 of valid user-defined image specifications. */
5945 static struct image_keyword png_format
[PNG_LAST
] =
5947 {":type", IMAGE_SYMBOL_VALUE
, 1},
5948 {":data", IMAGE_STRING_VALUE
, 0},
5949 {":file", IMAGE_STRING_VALUE
, 0},
5950 {":ascent", IMAGE_ASCENT_VALUE
, 0},
5951 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
5952 {":relief", IMAGE_INTEGER_VALUE
, 0},
5953 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5954 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5955 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5956 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
5959 /* Structure describing the image type `png'. */
5961 static struct image_type png_type
=
5970 /* Return non-zero if OBJECT is a valid PNG image specification. */
5973 png_image_p (object
)
5976 struct image_keyword fmt
[PNG_LAST
];
5977 bcopy (png_format
, fmt
, sizeof fmt
);
5979 if (!parse_image_spec (object
, fmt
, PNG_LAST
, Qpng
))
5982 /* Must specify either the :data or :file keyword. */
5983 return fmt
[PNG_FILE
].count
+ fmt
[PNG_DATA
].count
== 1;
5986 #endif /* HAVE_PNG || MAC_OS */
5991 #if defined HAVE_LIBPNG_PNG_H
5992 # include <libpng/png.h>
5998 /* PNG library details. */
6000 DEF_IMGLIB_FN (png_get_io_ptr
);
6001 DEF_IMGLIB_FN (png_check_sig
);
6002 DEF_IMGLIB_FN (png_create_read_struct
);
6003 DEF_IMGLIB_FN (png_create_info_struct
);
6004 DEF_IMGLIB_FN (png_destroy_read_struct
);
6005 DEF_IMGLIB_FN (png_set_read_fn
);
6006 DEF_IMGLIB_FN (png_set_sig_bytes
);
6007 DEF_IMGLIB_FN (png_read_info
);
6008 DEF_IMGLIB_FN (png_get_IHDR
);
6009 DEF_IMGLIB_FN (png_get_valid
);
6010 DEF_IMGLIB_FN (png_set_strip_16
);
6011 DEF_IMGLIB_FN (png_set_expand
);
6012 DEF_IMGLIB_FN (png_set_gray_to_rgb
);
6013 DEF_IMGLIB_FN (png_set_background
);
6014 DEF_IMGLIB_FN (png_get_bKGD
);
6015 DEF_IMGLIB_FN (png_read_update_info
);
6016 DEF_IMGLIB_FN (png_get_channels
);
6017 DEF_IMGLIB_FN (png_get_rowbytes
);
6018 DEF_IMGLIB_FN (png_read_image
);
6019 DEF_IMGLIB_FN (png_read_end
);
6020 DEF_IMGLIB_FN (png_error
);
6023 init_png_functions (Lisp_Object libraries
)
6027 /* Try loading libpng under probable names. */
6028 if (!(library
= w32_delayed_load (libraries
, Qpng
)))
6031 LOAD_IMGLIB_FN (library
, png_get_io_ptr
);
6032 LOAD_IMGLIB_FN (library
, png_check_sig
);
6033 LOAD_IMGLIB_FN (library
, png_create_read_struct
);
6034 LOAD_IMGLIB_FN (library
, png_create_info_struct
);
6035 LOAD_IMGLIB_FN (library
, png_destroy_read_struct
);
6036 LOAD_IMGLIB_FN (library
, png_set_read_fn
);
6037 LOAD_IMGLIB_FN (library
, png_set_sig_bytes
);
6038 LOAD_IMGLIB_FN (library
, png_read_info
);
6039 LOAD_IMGLIB_FN (library
, png_get_IHDR
);
6040 LOAD_IMGLIB_FN (library
, png_get_valid
);
6041 LOAD_IMGLIB_FN (library
, png_set_strip_16
);
6042 LOAD_IMGLIB_FN (library
, png_set_expand
);
6043 LOAD_IMGLIB_FN (library
, png_set_gray_to_rgb
);
6044 LOAD_IMGLIB_FN (library
, png_set_background
);
6045 LOAD_IMGLIB_FN (library
, png_get_bKGD
);
6046 LOAD_IMGLIB_FN (library
, png_read_update_info
);
6047 LOAD_IMGLIB_FN (library
, png_get_channels
);
6048 LOAD_IMGLIB_FN (library
, png_get_rowbytes
);
6049 LOAD_IMGLIB_FN (library
, png_read_image
);
6050 LOAD_IMGLIB_FN (library
, png_read_end
);
6051 LOAD_IMGLIB_FN (library
, png_error
);
6056 #define fn_png_get_io_ptr png_get_io_ptr
6057 #define fn_png_check_sig png_check_sig
6058 #define fn_png_create_read_struct png_create_read_struct
6059 #define fn_png_create_info_struct png_create_info_struct
6060 #define fn_png_destroy_read_struct png_destroy_read_struct
6061 #define fn_png_set_read_fn png_set_read_fn
6062 #define fn_png_set_sig_bytes png_set_sig_bytes
6063 #define fn_png_read_info png_read_info
6064 #define fn_png_get_IHDR png_get_IHDR
6065 #define fn_png_get_valid png_get_valid
6066 #define fn_png_set_strip_16 png_set_strip_16
6067 #define fn_png_set_expand png_set_expand
6068 #define fn_png_set_gray_to_rgb png_set_gray_to_rgb
6069 #define fn_png_set_background png_set_background
6070 #define fn_png_get_bKGD png_get_bKGD
6071 #define fn_png_read_update_info png_read_update_info
6072 #define fn_png_get_channels png_get_channels
6073 #define fn_png_get_rowbytes png_get_rowbytes
6074 #define fn_png_read_image png_read_image
6075 #define fn_png_read_end png_read_end
6076 #define fn_png_error png_error
6078 #endif /* HAVE_NTGUI */
6080 /* Error and warning handlers installed when the PNG library
6084 my_png_error (png_ptr
, msg
)
6085 png_struct
*png_ptr
;
6088 xassert (png_ptr
!= NULL
);
6089 image_error ("PNG error: %s", build_string (msg
), Qnil
);
6090 longjmp (png_ptr
->jmpbuf
, 1);
6095 my_png_warning (png_ptr
, msg
)
6096 png_struct
*png_ptr
;
6099 xassert (png_ptr
!= NULL
);
6100 image_error ("PNG warning: %s", build_string (msg
), Qnil
);
6103 /* Memory source for PNG decoding. */
6105 struct png_memory_storage
6107 unsigned char *bytes
; /* The data */
6108 size_t len
; /* How big is it? */
6109 int index
; /* Where are we? */
6113 /* Function set as reader function when reading PNG image from memory.
6114 PNG_PTR is a pointer to the PNG control structure. Copy LENGTH
6115 bytes from the input to DATA. */
6118 png_read_from_memory (png_ptr
, data
, length
)
6119 png_structp png_ptr
;
6123 struct png_memory_storage
*tbr
6124 = (struct png_memory_storage
*) fn_png_get_io_ptr (png_ptr
);
6126 if (length
> tbr
->len
- tbr
->index
)
6127 fn_png_error (png_ptr
, "Read error");
6129 bcopy (tbr
->bytes
+ tbr
->index
, data
, length
);
6130 tbr
->index
= tbr
->index
+ length
;
6134 /* Function set as reader function when reading PNG image from a file.
6135 PNG_PTR is a pointer to the PNG control structure. Copy LENGTH
6136 bytes from the input to DATA. */
6139 png_read_from_file (png_ptr
, data
, length
)
6140 png_structp png_ptr
;
6144 FILE *fp
= (FILE *) fn_png_get_io_ptr (png_ptr
);
6146 if (fread (data
, 1, length
, fp
) < length
)
6147 fn_png_error (png_ptr
, "Read error");
6151 /* Load PNG image IMG for use on frame F. Value is non-zero if
6159 Lisp_Object file
, specified_file
;
6160 Lisp_Object specified_data
;
6162 XImagePtr ximg
, mask_img
= NULL
;
6163 struct gcpro gcpro1
;
6164 png_struct
*png_ptr
= NULL
;
6165 png_info
*info_ptr
= NULL
, *end_info
= NULL
;
6166 FILE *volatile fp
= NULL
;
6168 png_byte
* volatile pixels
= NULL
;
6169 png_byte
** volatile rows
= NULL
;
6170 png_uint_32 width
, height
;
6171 int bit_depth
, color_type
, interlace_type
;
6173 png_uint_32 row_bytes
;
6175 double screen_gamma
;
6176 struct png_memory_storage tbr
; /* Data to be read */
6178 /* Find out what file to load. */
6179 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
6180 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
6184 if (NILP (specified_data
))
6186 file
= x_find_image_file (specified_file
);
6187 if (!STRINGP (file
))
6189 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
6194 /* Open the image file. */
6195 fp
= fopen (SDATA (file
), "rb");
6198 image_error ("Cannot open image file `%s'", file
, Qnil
);
6203 /* Check PNG signature. */
6204 if (fread (sig
, 1, sizeof sig
, fp
) != sizeof sig
6205 || !fn_png_check_sig (sig
, sizeof sig
))
6207 image_error ("Not a PNG file: `%s'", file
, Qnil
);
6215 /* Read from memory. */
6216 tbr
.bytes
= SDATA (specified_data
);
6217 tbr
.len
= SBYTES (specified_data
);
6220 /* Check PNG signature. */
6221 if (tbr
.len
< sizeof sig
6222 || !fn_png_check_sig (tbr
.bytes
, sizeof sig
))
6224 image_error ("Not a PNG image: `%s'", img
->spec
, Qnil
);
6229 /* Need to skip past the signature. */
6230 tbr
.bytes
+= sizeof (sig
);
6233 /* Initialize read and info structs for PNG lib. Casting return
6234 value avoids a GCC warning on W32. */
6235 png_ptr
= (png_structp
)fn_png_create_read_struct (PNG_LIBPNG_VER_STRING
,
6240 if (fp
) fclose (fp
);
6245 /* Casting return value avoids a GCC warning on W32. */
6246 info_ptr
= (png_infop
)fn_png_create_info_struct (png_ptr
);
6249 fn_png_destroy_read_struct (&png_ptr
, NULL
, NULL
);
6250 if (fp
) fclose (fp
);
6255 /* Casting return value avoids a GCC warning on W32. */
6256 end_info
= (png_infop
)fn_png_create_info_struct (png_ptr
);
6259 fn_png_destroy_read_struct (&png_ptr
, &info_ptr
, NULL
);
6260 if (fp
) fclose (fp
);
6265 /* Set error jump-back. We come back here when the PNG library
6266 detects an error. */
6267 if (setjmp (png_ptr
->jmpbuf
))
6271 fn_png_destroy_read_struct (&png_ptr
, &info_ptr
, &end_info
);
6274 if (fp
) fclose (fp
);
6279 /* Read image info. */
6280 if (!NILP (specified_data
))
6281 fn_png_set_read_fn (png_ptr
, (void *) &tbr
, png_read_from_memory
);
6283 fn_png_set_read_fn (png_ptr
, (void *) fp
, png_read_from_file
);
6285 fn_png_set_sig_bytes (png_ptr
, sizeof sig
);
6286 fn_png_read_info (png_ptr
, info_ptr
);
6287 fn_png_get_IHDR (png_ptr
, info_ptr
, &width
, &height
, &bit_depth
, &color_type
,
6288 &interlace_type
, NULL
, NULL
);
6290 if (!check_image_size (f
, width
, height
))
6293 /* If image contains simply transparency data, we prefer to
6294 construct a clipping mask. */
6295 if (fn_png_get_valid (png_ptr
, info_ptr
, PNG_INFO_tRNS
))
6300 /* This function is easier to write if we only have to handle
6301 one data format: RGB or RGBA with 8 bits per channel. Let's
6302 transform other formats into that format. */
6304 /* Strip more than 8 bits per channel. */
6305 if (bit_depth
== 16)
6306 fn_png_set_strip_16 (png_ptr
);
6308 /* Expand data to 24 bit RGB, or 8 bit grayscale, with alpha channel
6310 fn_png_set_expand (png_ptr
);
6312 /* Convert grayscale images to RGB. */
6313 if (color_type
== PNG_COLOR_TYPE_GRAY
6314 || color_type
== PNG_COLOR_TYPE_GRAY_ALPHA
)
6315 fn_png_set_gray_to_rgb (png_ptr
);
6317 screen_gamma
= (f
->gamma
? 1 / f
->gamma
/ 0.45455 : 2.2);
6319 #if 0 /* Avoid double gamma correction for PNG images. */
6320 { /* Tell the PNG lib to handle gamma correction for us. */
6323 #if defined(PNG_READ_sRGB_SUPPORTED) || defined(PNG_WRITE_sRGB_SUPPORTED)
6324 if (png_get_sRGB (png_ptr
, info_ptr
, &intent
))
6325 /* The libpng documentation says this is right in this case. */
6326 png_set_gamma (png_ptr
, screen_gamma
, 0.45455);
6329 if (png_get_gAMA (png_ptr
, info_ptr
, &image_gamma
))
6330 /* Image contains gamma information. */
6331 png_set_gamma (png_ptr
, screen_gamma
, image_gamma
);
6333 /* Use the standard default for the image gamma. */
6334 png_set_gamma (png_ptr
, screen_gamma
, 0.45455);
6338 /* Handle alpha channel by combining the image with a background
6339 color. Do this only if a real alpha channel is supplied. For
6340 simple transparency, we prefer a clipping mask. */
6343 png_color_16
*image_bg
;
6344 Lisp_Object specified_bg
6345 = image_spec_value (img
->spec
, QCbackground
, NULL
);
6347 if (STRINGP (specified_bg
))
6348 /* The user specified `:background', use that. */
6350 /* W32 version incorrectly used COLORREF here!! ++kfs */
6352 if (x_defined_color (f
, SDATA (specified_bg
), &color
, 0))
6354 png_color_16 user_bg
;
6356 bzero (&user_bg
, sizeof user_bg
);
6357 user_bg
.red
= color
.red
>> 8;
6358 user_bg
.green
= color
.green
>> 8;
6359 user_bg
.blue
= color
.blue
>> 8;
6361 fn_png_set_background (png_ptr
, &user_bg
,
6362 PNG_BACKGROUND_GAMMA_SCREEN
, 0, 1.0);
6365 else if (fn_png_get_bKGD (png_ptr
, info_ptr
, &image_bg
))
6366 /* Image contains a background color with which to
6367 combine the image. */
6368 fn_png_set_background (png_ptr
, image_bg
,
6369 PNG_BACKGROUND_GAMMA_FILE
, 1, 1.0);
6372 /* Image does not contain a background color with which
6373 to combine the image data via an alpha channel. Use
6374 the frame's background instead. */
6375 #ifdef HAVE_X_WINDOWS
6377 png_color_16 frame_background
;
6379 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
6380 x_query_color (f
, &color
);
6382 bzero (&frame_background
, sizeof frame_background
);
6383 frame_background
.red
= color
.red
>> 8;
6384 frame_background
.green
= color
.green
>> 8;
6385 frame_background
.blue
= color
.blue
>> 8;
6386 #endif /* HAVE_X_WINDOWS */
6390 png_color_16 frame_background
;
6391 color
= FRAME_BACKGROUND_PIXEL (f
);
6392 #if 0 /* W32 TODO : Colormap support. */
6393 x_query_color (f
, &color
);
6395 bzero (&frame_background
, sizeof frame_background
);
6396 frame_background
.red
= GetRValue (color
);
6397 frame_background
.green
= GetGValue (color
);
6398 frame_background
.blue
= GetBValue (color
);
6399 #endif /* HAVE_NTGUI */
6402 unsigned long color
;
6403 png_color_16 frame_background
;
6404 color
= FRAME_BACKGROUND_PIXEL (f
);
6405 #if 0 /* MAC/W32 TODO : Colormap support. */
6406 x_query_color (f
, &color
);
6408 bzero (&frame_background
, sizeof frame_background
);
6409 frame_background
.red
= RED_FROM_ULONG (color
);
6410 frame_background
.green
= GREEN_FROM_ULONG (color
);
6411 frame_background
.blue
= BLUE_FROM_ULONG (color
);
6414 fn_png_set_background (png_ptr
, &frame_background
,
6415 PNG_BACKGROUND_GAMMA_SCREEN
, 0, 1.0);
6419 /* Update info structure. */
6420 fn_png_read_update_info (png_ptr
, info_ptr
);
6422 /* Get number of channels. Valid values are 1 for grayscale images
6423 and images with a palette, 2 for grayscale images with transparency
6424 information (alpha channel), 3 for RGB images, and 4 for RGB
6425 images with alpha channel, i.e. RGBA. If conversions above were
6426 sufficient we should only have 3 or 4 channels here. */
6427 channels
= fn_png_get_channels (png_ptr
, info_ptr
);
6428 xassert (channels
== 3 || channels
== 4);
6430 /* Number of bytes needed for one row of the image. */
6431 row_bytes
= fn_png_get_rowbytes (png_ptr
, info_ptr
);
6433 /* Allocate memory for the image. */
6434 pixels
= (png_byte
*) xmalloc (row_bytes
* height
* sizeof *pixels
);
6435 rows
= (png_byte
**) xmalloc (height
* sizeof *rows
);
6436 for (i
= 0; i
< height
; ++i
)
6437 rows
[i
] = pixels
+ i
* row_bytes
;
6439 /* Read the entire image. */
6440 fn_png_read_image (png_ptr
, rows
);
6441 fn_png_read_end (png_ptr
, info_ptr
);
6448 /* Create the X image and pixmap. */
6449 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
,
6453 /* Create an image and pixmap serving as mask if the PNG image
6454 contains an alpha channel. */
6457 && !x_create_x_image_and_pixmap (f
, width
, height
, 1,
6458 &mask_img
, &img
->mask
))
6460 x_destroy_x_image (ximg
);
6461 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->pixmap
);
6462 img
->pixmap
= NO_PIXMAP
;
6466 /* Fill the X image and mask from PNG data. */
6467 init_color_table ();
6469 for (y
= 0; y
< height
; ++y
)
6471 png_byte
*p
= rows
[y
];
6473 for (x
= 0; x
< width
; ++x
)
6480 XPutPixel (ximg
, x
, y
, lookup_rgb_color (f
, r
, g
, b
));
6481 /* An alpha channel, aka mask channel, associates variable
6482 transparency with an image. Where other image formats
6483 support binary transparency---fully transparent or fully
6484 opaque---PNG allows up to 254 levels of partial transparency.
6485 The PNG library implements partial transparency by combining
6486 the image with a specified background color.
6488 I'm not sure how to handle this here nicely: because the
6489 background on which the image is displayed may change, for
6490 real alpha channel support, it would be necessary to create
6491 a new image for each possible background.
6493 What I'm doing now is that a mask is created if we have
6494 boolean transparency information. Otherwise I'm using
6495 the frame's background color to combine the image with. */
6500 XPutPixel (mask_img
, x
, y
, *p
> 0 ? PIX_MASK_DRAW
: PIX_MASK_RETAIN
);
6506 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
6507 /* Set IMG's background color from the PNG image, unless the user
6511 if (fn_png_get_bKGD (png_ptr
, info_ptr
, &bg
))
6513 img
->background
= lookup_rgb_color (f
, bg
->red
, bg
->green
, bg
->blue
);
6514 img
->background_valid
= 1;
6518 #ifdef COLOR_TABLE_SUPPORT
6519 /* Remember colors allocated for this image. */
6520 img
->colors
= colors_in_color_table (&img
->ncolors
);
6521 free_color_table ();
6522 #endif /* COLOR_TABLE_SUPPORT */
6525 fn_png_destroy_read_struct (&png_ptr
, &info_ptr
, &end_info
);
6530 img
->height
= height
;
6532 /* Maybe fill in the background field while we have ximg handy.
6533 Casting avoids a GCC warning. */
6534 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
6536 /* Put the image into the pixmap, then free the X image and its buffer. */
6537 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
6538 x_destroy_x_image (ximg
);
6540 /* Same for the mask. */
6543 /* Fill in the background_transparent field while we have the
6544 mask handy. Casting avoids a GCC warning. */
6545 image_background_transparent (img
, f
, (XImagePtr_or_DC
)mask_img
);
6547 x_put_x_image (f
, mask_img
, img
->mask
, img
->width
, img
->height
);
6548 x_destroy_x_image (mask_img
);
6555 #else /* HAVE_PNG */
6564 if (MyCGImageCreateWithPNGDataProvider
)
6565 return image_load_quartz2d (f
, img
, 1);
6568 return image_load_quicktime (f
, img
, kQTFileTypePNG
);
6572 #endif /* !HAVE_PNG */
6576 /***********************************************************************
6578 ***********************************************************************/
6580 #if defined (HAVE_JPEG) || defined (MAC_OS)
6582 static int jpeg_image_p
P_ ((Lisp_Object object
));
6583 static int jpeg_load
P_ ((struct frame
*f
, struct image
*img
));
6585 /* The symbol `jpeg' identifying images of this type. */
6589 /* Indices of image specification fields in gs_format, below. */
6591 enum jpeg_keyword_index
6600 JPEG_HEURISTIC_MASK
,
6606 /* Vector of image_keyword structures describing the format
6607 of valid user-defined image specifications. */
6609 static struct image_keyword jpeg_format
[JPEG_LAST
] =
6611 {":type", IMAGE_SYMBOL_VALUE
, 1},
6612 {":data", IMAGE_STRING_VALUE
, 0},
6613 {":file", IMAGE_STRING_VALUE
, 0},
6614 {":ascent", IMAGE_ASCENT_VALUE
, 0},
6615 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
6616 {":relief", IMAGE_INTEGER_VALUE
, 0},
6617 {":conversions", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6618 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6619 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6620 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
6623 /* Structure describing the image type `jpeg'. */
6625 static struct image_type jpeg_type
=
6634 /* Return non-zero if OBJECT is a valid JPEG image specification. */
6637 jpeg_image_p (object
)
6640 struct image_keyword fmt
[JPEG_LAST
];
6642 bcopy (jpeg_format
, fmt
, sizeof fmt
);
6644 if (!parse_image_spec (object
, fmt
, JPEG_LAST
, Qjpeg
))
6647 /* Must specify either the :data or :file keyword. */
6648 return fmt
[JPEG_FILE
].count
+ fmt
[JPEG_DATA
].count
== 1;
6651 #endif /* HAVE_JPEG || MAC_OS */
6655 /* Work around a warning about HAVE_STDLIB_H being redefined in
6657 #ifdef HAVE_STDLIB_H
6658 #define HAVE_STDLIB_H_1
6659 #undef HAVE_STDLIB_H
6660 #endif /* HAVE_STLIB_H */
6662 #if defined (HAVE_NTGUI) && !defined (__WIN32__)
6663 /* In older releases of the jpeg library, jpeglib.h will define boolean
6664 differently depending on __WIN32__, so make sure it is defined. */
6668 #include <jpeglib.h>
6672 #ifdef HAVE_STLIB_H_1
6673 #define HAVE_STDLIB_H 1
6678 /* JPEG library details. */
6679 DEF_IMGLIB_FN (jpeg_CreateDecompress
);
6680 DEF_IMGLIB_FN (jpeg_start_decompress
);
6681 DEF_IMGLIB_FN (jpeg_finish_decompress
);
6682 DEF_IMGLIB_FN (jpeg_destroy_decompress
);
6683 DEF_IMGLIB_FN (jpeg_read_header
);
6684 DEF_IMGLIB_FN (jpeg_read_scanlines
);
6685 DEF_IMGLIB_FN (jpeg_std_error
);
6686 DEF_IMGLIB_FN (jpeg_resync_to_restart
);
6689 init_jpeg_functions (Lisp_Object libraries
)
6693 if (!(library
= w32_delayed_load (libraries
, Qjpeg
)))
6696 LOAD_IMGLIB_FN (library
, jpeg_finish_decompress
);
6697 LOAD_IMGLIB_FN (library
, jpeg_read_scanlines
);
6698 LOAD_IMGLIB_FN (library
, jpeg_start_decompress
);
6699 LOAD_IMGLIB_FN (library
, jpeg_read_header
);
6700 LOAD_IMGLIB_FN (library
, jpeg_CreateDecompress
);
6701 LOAD_IMGLIB_FN (library
, jpeg_destroy_decompress
);
6702 LOAD_IMGLIB_FN (library
, jpeg_std_error
);
6703 LOAD_IMGLIB_FN (library
, jpeg_resync_to_restart
);
6707 /* Wrapper since we can't directly assign the function pointer
6708 to another function pointer that was declared more completely easily. */
6710 jpeg_resync_to_restart_wrapper(cinfo
, desired
)
6711 j_decompress_ptr cinfo
;
6714 return fn_jpeg_resync_to_restart (cinfo
, desired
);
6719 #define fn_jpeg_CreateDecompress(a,b,c) jpeg_create_decompress(a)
6720 #define fn_jpeg_start_decompress jpeg_start_decompress
6721 #define fn_jpeg_finish_decompress jpeg_finish_decompress
6722 #define fn_jpeg_destroy_decompress jpeg_destroy_decompress
6723 #define fn_jpeg_read_header jpeg_read_header
6724 #define fn_jpeg_read_scanlines jpeg_read_scanlines
6725 #define fn_jpeg_std_error jpeg_std_error
6726 #define jpeg_resync_to_restart_wrapper jpeg_resync_to_restart
6728 #endif /* HAVE_NTGUI */
6730 struct my_jpeg_error_mgr
6732 struct jpeg_error_mgr pub
;
6733 jmp_buf setjmp_buffer
;
6738 my_error_exit (cinfo
)
6741 struct my_jpeg_error_mgr
*mgr
= (struct my_jpeg_error_mgr
*) cinfo
->err
;
6742 longjmp (mgr
->setjmp_buffer
, 1);
6746 /* Init source method for JPEG data source manager. Called by
6747 jpeg_read_header() before any data is actually read. See
6748 libjpeg.doc from the JPEG lib distribution. */
6751 our_common_init_source (cinfo
)
6752 j_decompress_ptr cinfo
;
6757 /* Method to terminate data source. Called by
6758 jpeg_finish_decompress() after all data has been processed. */
6761 our_common_term_source (cinfo
)
6762 j_decompress_ptr cinfo
;
6767 /* Fill input buffer method for JPEG data source manager. Called
6768 whenever more data is needed. We read the whole image in one step,
6769 so this only adds a fake end of input marker at the end. */
6772 our_memory_fill_input_buffer (cinfo
)
6773 j_decompress_ptr cinfo
;
6775 /* Insert a fake EOI marker. */
6776 struct jpeg_source_mgr
*src
= cinfo
->src
;
6777 static JOCTET buffer
[2];
6779 buffer
[0] = (JOCTET
) 0xFF;
6780 buffer
[1] = (JOCTET
) JPEG_EOI
;
6782 src
->next_input_byte
= buffer
;
6783 src
->bytes_in_buffer
= 2;
6788 /* Method to skip over NUM_BYTES bytes in the image data. CINFO->src
6789 is the JPEG data source manager. */
6792 our_memory_skip_input_data (cinfo
, num_bytes
)
6793 j_decompress_ptr cinfo
;
6796 struct jpeg_source_mgr
*src
= (struct jpeg_source_mgr
*) cinfo
->src
;
6800 if (num_bytes
> src
->bytes_in_buffer
)
6801 ERREXIT (cinfo
, JERR_INPUT_EOF
);
6803 src
->bytes_in_buffer
-= num_bytes
;
6804 src
->next_input_byte
+= num_bytes
;
6809 /* Set up the JPEG lib for reading an image from DATA which contains
6810 LEN bytes. CINFO is the decompression info structure created for
6811 reading the image. */
6814 jpeg_memory_src (cinfo
, data
, len
)
6815 j_decompress_ptr cinfo
;
6819 struct jpeg_source_mgr
*src
;
6821 if (cinfo
->src
== NULL
)
6823 /* First time for this JPEG object? */
6824 cinfo
->src
= (struct jpeg_source_mgr
*)
6825 (*cinfo
->mem
->alloc_small
) ((j_common_ptr
) cinfo
, JPOOL_PERMANENT
,
6826 sizeof (struct jpeg_source_mgr
));
6827 src
= (struct jpeg_source_mgr
*) cinfo
->src
;
6828 src
->next_input_byte
= data
;
6831 src
= (struct jpeg_source_mgr
*) cinfo
->src
;
6832 src
->init_source
= our_common_init_source
;
6833 src
->fill_input_buffer
= our_memory_fill_input_buffer
;
6834 src
->skip_input_data
= our_memory_skip_input_data
;
6835 src
->resync_to_restart
= jpeg_resync_to_restart_wrapper
; /* Use default method. */
6836 src
->term_source
= our_common_term_source
;
6837 src
->bytes_in_buffer
= len
;
6838 src
->next_input_byte
= data
;
6842 struct jpeg_stdio_mgr
6844 struct jpeg_source_mgr mgr
;
6851 /* Size of buffer to read JPEG from file.
6852 Not too big, as we want to use alloc_small. */
6853 #define JPEG_STDIO_BUFFER_SIZE 8192
6856 /* Fill input buffer method for JPEG data source manager. Called
6857 whenever more data is needed. The data is read from a FILE *. */
6860 our_stdio_fill_input_buffer (cinfo
)
6861 j_decompress_ptr cinfo
;
6863 struct jpeg_stdio_mgr
*src
;
6865 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6870 bytes
= fread (src
->buffer
, 1, JPEG_STDIO_BUFFER_SIZE
, src
->file
);
6872 src
->mgr
.bytes_in_buffer
= bytes
;
6875 WARNMS (cinfo
, JWRN_JPEG_EOF
);
6877 src
->buffer
[0] = (JOCTET
) 0xFF;
6878 src
->buffer
[1] = (JOCTET
) JPEG_EOI
;
6879 src
->mgr
.bytes_in_buffer
= 2;
6881 src
->mgr
.next_input_byte
= src
->buffer
;
6888 /* Method to skip over NUM_BYTES bytes in the image data. CINFO->src
6889 is the JPEG data source manager. */
6892 our_stdio_skip_input_data (cinfo
, num_bytes
)
6893 j_decompress_ptr cinfo
;
6896 struct jpeg_stdio_mgr
*src
;
6897 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6899 while (num_bytes
> 0 && !src
->finished
)
6901 if (num_bytes
<= src
->mgr
.bytes_in_buffer
)
6903 src
->mgr
.bytes_in_buffer
-= num_bytes
;
6904 src
->mgr
.next_input_byte
+= num_bytes
;
6909 num_bytes
-= src
->mgr
.bytes_in_buffer
;
6910 src
->mgr
.bytes_in_buffer
= 0;
6911 src
->mgr
.next_input_byte
= NULL
;
6913 our_stdio_fill_input_buffer (cinfo
);
6919 /* Set up the JPEG lib for reading an image from a FILE *.
6920 CINFO is the decompression info structure created for
6921 reading the image. */
6924 jpeg_file_src (cinfo
, fp
)
6925 j_decompress_ptr cinfo
;
6928 struct jpeg_stdio_mgr
*src
;
6930 if (cinfo
->src
!= NULL
)
6931 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6934 /* First time for this JPEG object? */
6935 cinfo
->src
= (struct jpeg_source_mgr
*)
6936 (*cinfo
->mem
->alloc_small
) ((j_common_ptr
) cinfo
, JPOOL_PERMANENT
,
6937 sizeof (struct jpeg_stdio_mgr
));
6938 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6939 src
->buffer
= (JOCTET
*)
6940 (*cinfo
->mem
->alloc_small
) ((j_common_ptr
) cinfo
, JPOOL_PERMANENT
,
6941 JPEG_STDIO_BUFFER_SIZE
);
6946 src
->mgr
.init_source
= our_common_init_source
;
6947 src
->mgr
.fill_input_buffer
= our_stdio_fill_input_buffer
;
6948 src
->mgr
.skip_input_data
= our_stdio_skip_input_data
;
6949 src
->mgr
.resync_to_restart
= jpeg_resync_to_restart_wrapper
; /* Use default method. */
6950 src
->mgr
.term_source
= our_common_term_source
;
6951 src
->mgr
.bytes_in_buffer
= 0;
6952 src
->mgr
.next_input_byte
= NULL
;
6956 /* Load image IMG for use on frame F. Patterned after example.c
6957 from the JPEG lib. */
6964 struct jpeg_decompress_struct cinfo
;
6965 struct my_jpeg_error_mgr mgr
;
6966 Lisp_Object file
, specified_file
;
6967 Lisp_Object specified_data
;
6968 FILE * volatile fp
= NULL
;
6970 int row_stride
, x
, y
;
6971 XImagePtr ximg
= NULL
;
6973 unsigned long *colors
;
6975 struct gcpro gcpro1
;
6977 /* Open the JPEG file. */
6978 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
6979 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
6983 if (NILP (specified_data
))
6985 file
= x_find_image_file (specified_file
);
6986 if (!STRINGP (file
))
6988 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
6993 fp
= fopen (SDATA (file
), "rb");
6996 image_error ("Cannot open `%s'", file
, Qnil
);
7002 /* Customize libjpeg's error handling to call my_error_exit when an
7003 error is detected. This function will perform a longjmp.
7004 Casting return value avoids a GCC warning on W32. */
7005 cinfo
.err
= (struct jpeg_error_mgr
*)fn_jpeg_std_error (&mgr
.pub
);
7006 mgr
.pub
.error_exit
= my_error_exit
;
7008 if ((rc
= setjmp (mgr
.setjmp_buffer
)) != 0)
7012 /* Called from my_error_exit. Display a JPEG error. */
7013 char buffer
[JMSG_LENGTH_MAX
];
7014 cinfo
.err
->format_message ((j_common_ptr
) &cinfo
, buffer
);
7015 image_error ("Error reading JPEG image `%s': %s", img
->spec
,
7016 build_string (buffer
));
7019 /* Close the input file and destroy the JPEG object. */
7021 fclose ((FILE *) fp
);
7022 fn_jpeg_destroy_decompress (&cinfo
);
7024 /* If we already have an XImage, free that. */
7025 x_destroy_x_image (ximg
);
7027 /* Free pixmap and colors. */
7028 x_clear_image (f
, img
);
7034 /* Create the JPEG decompression object. Let it read from fp.
7035 Read the JPEG image header. */
7036 fn_jpeg_CreateDecompress (&cinfo
, JPEG_LIB_VERSION
, sizeof (cinfo
));
7038 if (NILP (specified_data
))
7039 jpeg_file_src (&cinfo
, (FILE *) fp
);
7041 jpeg_memory_src (&cinfo
, SDATA (specified_data
),
7042 SBYTES (specified_data
));
7044 fn_jpeg_read_header (&cinfo
, 1);
7046 /* Customize decompression so that color quantization will be used.
7047 Start decompression. */
7048 cinfo
.quantize_colors
= 1;
7049 fn_jpeg_start_decompress (&cinfo
);
7050 width
= img
->width
= cinfo
.output_width
;
7051 height
= img
->height
= cinfo
.output_height
;
7053 if (!check_image_size (f
, width
, height
))
7055 image_error ("Invalid image size", Qnil
, Qnil
);
7056 longjmp (mgr
.setjmp_buffer
, 2);
7059 /* Create X image and pixmap. */
7060 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
7061 longjmp (mgr
.setjmp_buffer
, 2);
7063 /* Allocate colors. When color quantization is used,
7064 cinfo.actual_number_of_colors has been set with the number of
7065 colors generated, and cinfo.colormap is a two-dimensional array
7066 of color indices in the range 0..cinfo.actual_number_of_colors.
7067 No more than 255 colors will be generated. */
7071 if (cinfo
.out_color_components
> 2)
7072 ir
= 0, ig
= 1, ib
= 2;
7073 else if (cinfo
.out_color_components
> 1)
7074 ir
= 0, ig
= 1, ib
= 0;
7076 ir
= 0, ig
= 0, ib
= 0;
7078 /* Use the color table mechanism because it handles colors that
7079 cannot be allocated nicely. Such colors will be replaced with
7080 a default color, and we don't have to care about which colors
7081 can be freed safely, and which can't. */
7082 init_color_table ();
7083 colors
= (unsigned long *) alloca (cinfo
.actual_number_of_colors
7086 for (i
= 0; i
< cinfo
.actual_number_of_colors
; ++i
)
7088 /* Multiply RGB values with 255 because X expects RGB values
7089 in the range 0..0xffff. */
7090 int r
= cinfo
.colormap
[ir
][i
] << 8;
7091 int g
= cinfo
.colormap
[ig
][i
] << 8;
7092 int b
= cinfo
.colormap
[ib
][i
] << 8;
7093 colors
[i
] = lookup_rgb_color (f
, r
, g
, b
);
7096 #ifdef COLOR_TABLE_SUPPORT
7097 /* Remember those colors actually allocated. */
7098 img
->colors
= colors_in_color_table (&img
->ncolors
);
7099 free_color_table ();
7100 #endif /* COLOR_TABLE_SUPPORT */
7104 row_stride
= width
* cinfo
.output_components
;
7105 buffer
= cinfo
.mem
->alloc_sarray ((j_common_ptr
) &cinfo
, JPOOL_IMAGE
,
7107 for (y
= 0; y
< height
; ++y
)
7109 fn_jpeg_read_scanlines (&cinfo
, buffer
, 1);
7110 for (x
= 0; x
< cinfo
.output_width
; ++x
)
7111 XPutPixel (ximg
, x
, y
, colors
[buffer
[0][x
]]);
7115 fn_jpeg_finish_decompress (&cinfo
);
7116 fn_jpeg_destroy_decompress (&cinfo
);
7118 fclose ((FILE *) fp
);
7120 /* Maybe fill in the background field while we have ximg handy. */
7121 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
7122 /* Casting avoids a GCC warning. */
7123 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
7125 /* Put the image into the pixmap. */
7126 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
7127 x_destroy_x_image (ximg
);
7132 #else /* HAVE_JPEG */
7141 return image_load_quartz2d (f
, img
, 0);
7143 return image_load_quicktime (f
, img
, kQTFileTypeJPEG
);
7148 #endif /* !HAVE_JPEG */
7152 /***********************************************************************
7154 ***********************************************************************/
7156 #if defined (HAVE_TIFF) || defined (MAC_OS)
7158 static int tiff_image_p
P_ ((Lisp_Object object
));
7159 static int tiff_load
P_ ((struct frame
*f
, struct image
*img
));
7161 /* The symbol `tiff' identifying images of this type. */
7165 /* Indices of image specification fields in tiff_format, below. */
7167 enum tiff_keyword_index
7176 TIFF_HEURISTIC_MASK
,
7182 /* Vector of image_keyword structures describing the format
7183 of valid user-defined image specifications. */
7185 static struct image_keyword tiff_format
[TIFF_LAST
] =
7187 {":type", IMAGE_SYMBOL_VALUE
, 1},
7188 {":data", IMAGE_STRING_VALUE
, 0},
7189 {":file", IMAGE_STRING_VALUE
, 0},
7190 {":ascent", IMAGE_ASCENT_VALUE
, 0},
7191 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
7192 {":relief", IMAGE_INTEGER_VALUE
, 0},
7193 {":conversions", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7194 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7195 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7196 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
7199 /* Structure describing the image type `tiff'. */
7201 static struct image_type tiff_type
=
7210 /* Return non-zero if OBJECT is a valid TIFF image specification. */
7213 tiff_image_p (object
)
7216 struct image_keyword fmt
[TIFF_LAST
];
7217 bcopy (tiff_format
, fmt
, sizeof fmt
);
7219 if (!parse_image_spec (object
, fmt
, TIFF_LAST
, Qtiff
))
7222 /* Must specify either the :data or :file keyword. */
7223 return fmt
[TIFF_FILE
].count
+ fmt
[TIFF_DATA
].count
== 1;
7226 #endif /* HAVE_TIFF || MAC_OS */
7234 /* TIFF library details. */
7235 DEF_IMGLIB_FN (TIFFSetErrorHandler
);
7236 DEF_IMGLIB_FN (TIFFSetWarningHandler
);
7237 DEF_IMGLIB_FN (TIFFOpen
);
7238 DEF_IMGLIB_FN (TIFFClientOpen
);
7239 DEF_IMGLIB_FN (TIFFGetField
);
7240 DEF_IMGLIB_FN (TIFFReadRGBAImage
);
7241 DEF_IMGLIB_FN (TIFFClose
);
7244 init_tiff_functions (Lisp_Object libraries
)
7248 if (!(library
= w32_delayed_load (libraries
, Qtiff
)))
7251 LOAD_IMGLIB_FN (library
, TIFFSetErrorHandler
);
7252 LOAD_IMGLIB_FN (library
, TIFFSetWarningHandler
);
7253 LOAD_IMGLIB_FN (library
, TIFFOpen
);
7254 LOAD_IMGLIB_FN (library
, TIFFClientOpen
);
7255 LOAD_IMGLIB_FN (library
, TIFFGetField
);
7256 LOAD_IMGLIB_FN (library
, TIFFReadRGBAImage
);
7257 LOAD_IMGLIB_FN (library
, TIFFClose
);
7263 #define fn_TIFFSetErrorHandler TIFFSetErrorHandler
7264 #define fn_TIFFSetWarningHandler TIFFSetWarningHandler
7265 #define fn_TIFFOpen TIFFOpen
7266 #define fn_TIFFClientOpen TIFFClientOpen
7267 #define fn_TIFFGetField TIFFGetField
7268 #define fn_TIFFReadRGBAImage TIFFReadRGBAImage
7269 #define fn_TIFFClose TIFFClose
7271 #endif /* HAVE_NTGUI */
7274 /* Reading from a memory buffer for TIFF images Based on the PNG
7275 memory source, but we have to provide a lot of extra functions.
7278 We really only need to implement read and seek, but I am not
7279 convinced that the TIFF library is smart enough not to destroy
7280 itself if we only hand it the function pointers we need to
7285 unsigned char *bytes
;
7292 tiff_read_from_memory (data
, buf
, size
)
7297 tiff_memory_source
*src
= (tiff_memory_source
*) data
;
7299 if (size
> src
->len
- src
->index
)
7301 bcopy (src
->bytes
+ src
->index
, buf
, size
);
7307 tiff_write_from_memory (data
, buf
, size
)
7316 tiff_seek_in_memory (data
, off
, whence
)
7321 tiff_memory_source
*src
= (tiff_memory_source
*) data
;
7326 case SEEK_SET
: /* Go from beginning of source. */
7330 case SEEK_END
: /* Go from end of source. */
7331 idx
= src
->len
+ off
;
7334 case SEEK_CUR
: /* Go from current position. */
7335 idx
= src
->index
+ off
;
7338 default: /* Invalid `whence'. */
7342 if (idx
> src
->len
|| idx
< 0)
7350 tiff_close_memory (data
)
7358 tiff_mmap_memory (data
, pbase
, psize
)
7363 /* It is already _IN_ memory. */
7368 tiff_unmap_memory (data
, base
, size
)
7373 /* We don't need to do this. */
7377 tiff_size_of_memory (data
)
7380 return ((tiff_memory_source
*) data
)->len
;
7385 tiff_error_handler (title
, format
, ap
)
7386 const char *title
, *format
;
7392 len
= sprintf (buf
, "TIFF error: %s ", title
);
7393 vsprintf (buf
+ len
, format
, ap
);
7394 add_to_log (buf
, Qnil
, Qnil
);
7399 tiff_warning_handler (title
, format
, ap
)
7400 const char *title
, *format
;
7406 len
= sprintf (buf
, "TIFF warning: %s ", title
);
7407 vsprintf (buf
+ len
, format
, ap
);
7408 add_to_log (buf
, Qnil
, Qnil
);
7412 /* Load TIFF image IMG for use on frame F. Value is non-zero if
7420 Lisp_Object file
, specified_file
;
7421 Lisp_Object specified_data
;
7423 int width
, height
, x
, y
;
7427 struct gcpro gcpro1
;
7428 tiff_memory_source memsrc
;
7430 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
7431 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
7435 fn_TIFFSetErrorHandler (tiff_error_handler
);
7436 fn_TIFFSetWarningHandler (tiff_warning_handler
);
7438 if (NILP (specified_data
))
7440 /* Read from a file */
7441 file
= x_find_image_file (specified_file
);
7442 if (!STRINGP (file
))
7444 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
7449 /* Try to open the image file. Casting return value avoids a
7450 GCC warning on W32. */
7451 tiff
= (TIFF
*)fn_TIFFOpen (SDATA (file
), "r");
7454 image_error ("Cannot open `%s'", file
, Qnil
);
7461 /* Memory source! */
7462 memsrc
.bytes
= SDATA (specified_data
);
7463 memsrc
.len
= SBYTES (specified_data
);
7466 /* Casting return value avoids a GCC warning on W32. */
7467 tiff
= (TIFF
*)fn_TIFFClientOpen ("memory_source", "r", &memsrc
,
7468 (TIFFReadWriteProc
) tiff_read_from_memory
,
7469 (TIFFReadWriteProc
) tiff_write_from_memory
,
7470 tiff_seek_in_memory
,
7472 tiff_size_of_memory
,
7478 image_error ("Cannot open memory source for `%s'", img
->spec
, Qnil
);
7484 /* Get width and height of the image, and allocate a raster buffer
7485 of width x height 32-bit values. */
7486 fn_TIFFGetField (tiff
, TIFFTAG_IMAGEWIDTH
, &width
);
7487 fn_TIFFGetField (tiff
, TIFFTAG_IMAGELENGTH
, &height
);
7489 if (!check_image_size (f
, width
, height
))
7491 image_error ("Invalid image size", Qnil
, Qnil
);
7496 buf
= (uint32
*) xmalloc (width
* height
* sizeof *buf
);
7498 rc
= fn_TIFFReadRGBAImage (tiff
, width
, height
, buf
, 0);
7499 fn_TIFFClose (tiff
);
7502 image_error ("Error reading TIFF image `%s'", img
->spec
, Qnil
);
7508 /* Create the X image and pixmap. */
7509 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
7516 /* Initialize the color table. */
7517 init_color_table ();
7519 /* Process the pixel raster. Origin is in the lower-left corner. */
7520 for (y
= 0; y
< height
; ++y
)
7522 uint32
*row
= buf
+ y
* width
;
7524 for (x
= 0; x
< width
; ++x
)
7526 uint32 abgr
= row
[x
];
7527 int r
= TIFFGetR (abgr
) << 8;
7528 int g
= TIFFGetG (abgr
) << 8;
7529 int b
= TIFFGetB (abgr
) << 8;
7530 XPutPixel (ximg
, x
, height
- 1 - y
, lookup_rgb_color (f
, r
, g
, b
));
7534 #ifdef COLOR_TABLE_SUPPORT
7535 /* Remember the colors allocated for the image. Free the color table. */
7536 img
->colors
= colors_in_color_table (&img
->ncolors
);
7537 free_color_table ();
7538 #endif /* COLOR_TABLE_SUPPORT */
7541 img
->height
= height
;
7543 /* Maybe fill in the background field while we have ximg handy. */
7544 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
7545 /* Casting avoids a GCC warning on W32. */
7546 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
7548 /* Put the image into the pixmap, then free the X image and its buffer. */
7549 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
7550 x_destroy_x_image (ximg
);
7557 #else /* HAVE_TIFF */
7565 return image_load_quicktime (f
, img
, kQTFileTypeTIFF
);
7569 #endif /* !HAVE_TIFF */
7573 /***********************************************************************
7575 ***********************************************************************/
7577 #if defined (HAVE_GIF) || defined (MAC_OS)
7579 static int gif_image_p
P_ ((Lisp_Object object
));
7580 static int gif_load
P_ ((struct frame
*f
, struct image
*img
));
7581 static void gif_clear_image
P_ ((struct frame
*f
, struct image
*img
));
7583 /* The symbol `gif' identifying images of this type. */
7587 /* Indices of image specification fields in gif_format, below. */
7589 enum gif_keyword_index
7605 /* Vector of image_keyword structures describing the format
7606 of valid user-defined image specifications. */
7608 static struct image_keyword gif_format
[GIF_LAST
] =
7610 {":type", IMAGE_SYMBOL_VALUE
, 1},
7611 {":data", IMAGE_STRING_VALUE
, 0},
7612 {":file", IMAGE_STRING_VALUE
, 0},
7613 {":ascent", IMAGE_ASCENT_VALUE
, 0},
7614 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
7615 {":relief", IMAGE_INTEGER_VALUE
, 0},
7616 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7617 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7618 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7619 {":image", IMAGE_NON_NEGATIVE_INTEGER_VALUE
, 0},
7620 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
7623 /* Structure describing the image type `gif'. */
7625 static struct image_type gif_type
=
7634 /* Free X resources of GIF image IMG which is used on frame F. */
7637 gif_clear_image (f
, img
)
7641 /* IMG->data.ptr_val may contain extension data. */
7642 img
->data
.lisp_val
= Qnil
;
7643 x_clear_image (f
, img
);
7646 /* Return non-zero if OBJECT is a valid GIF image specification. */
7649 gif_image_p (object
)
7652 struct image_keyword fmt
[GIF_LAST
];
7653 bcopy (gif_format
, fmt
, sizeof fmt
);
7655 if (!parse_image_spec (object
, fmt
, GIF_LAST
, Qgif
))
7658 /* Must specify either the :data or :file keyword. */
7659 return fmt
[GIF_FILE
].count
+ fmt
[GIF_DATA
].count
== 1;
7662 #endif /* HAVE_GIF || MAC_OS */
7666 #if defined (HAVE_NTGUI) || defined (MAC_OS)
7667 /* winuser.h might define DrawText to DrawTextA or DrawTextW.
7668 Undefine before redefining to avoid a preprocessor warning. */
7672 /* avoid conflict with QuickdrawText.h */
7673 #define DrawText gif_DrawText
7674 #include <gif_lib.h>
7677 #else /* HAVE_NTGUI || MAC_OS */
7679 #include <gif_lib.h>
7681 #endif /* HAVE_NTGUI || MAC_OS */
7686 /* GIF library details. */
7687 DEF_IMGLIB_FN (DGifCloseFile
);
7688 DEF_IMGLIB_FN (DGifSlurp
);
7689 DEF_IMGLIB_FN (DGifOpen
);
7690 DEF_IMGLIB_FN (DGifOpenFileName
);
7693 init_gif_functions (Lisp_Object libraries
)
7697 if (!(library
= w32_delayed_load (libraries
, Qgif
)))
7700 LOAD_IMGLIB_FN (library
, DGifCloseFile
);
7701 LOAD_IMGLIB_FN (library
, DGifSlurp
);
7702 LOAD_IMGLIB_FN (library
, DGifOpen
);
7703 LOAD_IMGLIB_FN (library
, DGifOpenFileName
);
7709 #define fn_DGifCloseFile DGifCloseFile
7710 #define fn_DGifSlurp DGifSlurp
7711 #define fn_DGifOpen DGifOpen
7712 #define fn_DGifOpenFileName DGifOpenFileName
7714 #endif /* HAVE_NTGUI */
7716 /* Reading a GIF image from memory
7717 Based on the PNG memory stuff to a certain extent. */
7721 unsigned char *bytes
;
7727 /* Make the current memory source available to gif_read_from_memory.
7728 It's done this way because not all versions of libungif support
7729 a UserData field in the GifFileType structure. */
7730 static gif_memory_source
*current_gif_memory_src
;
7733 gif_read_from_memory (file
, buf
, len
)
7738 gif_memory_source
*src
= current_gif_memory_src
;
7740 if (len
> src
->len
- src
->index
)
7743 bcopy (src
->bytes
+ src
->index
, buf
, len
);
7749 /* Load GIF image IMG for use on frame F. Value is non-zero if
7757 Lisp_Object file
, specified_file
;
7758 Lisp_Object specified_data
;
7759 int rc
, width
, height
, x
, y
, i
;
7761 ColorMapObject
*gif_color_map
;
7762 unsigned long pixel_colors
[256];
7764 struct gcpro gcpro1
;
7766 int ino
, image_height
, image_width
;
7767 gif_memory_source memsrc
;
7768 unsigned char *raster
;
7770 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
7771 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
7775 if (NILP (specified_data
))
7777 file
= x_find_image_file (specified_file
);
7778 if (!STRINGP (file
))
7780 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
7785 /* Open the GIF file. Casting return value avoids a GCC warning
7787 gif
= (GifFileType
*)fn_DGifOpenFileName (SDATA (file
));
7790 image_error ("Cannot open `%s'", file
, Qnil
);
7797 /* Read from memory! */
7798 current_gif_memory_src
= &memsrc
;
7799 memsrc
.bytes
= SDATA (specified_data
);
7800 memsrc
.len
= SBYTES (specified_data
);
7803 /* Casting return value avoids a GCC warning on W32. */
7804 gif
= (GifFileType
*)fn_DGifOpen(&memsrc
, gif_read_from_memory
);
7807 image_error ("Cannot open memory source `%s'", img
->spec
, Qnil
);
7813 /* Before reading entire contents, check the declared image size. */
7814 if (!check_image_size (f
, gif
->SWidth
, gif
->SHeight
))
7816 image_error ("Invalid image size", Qnil
, Qnil
);
7817 fn_DGifCloseFile (gif
);
7822 /* Read entire contents. */
7823 rc
= fn_DGifSlurp (gif
);
7824 if (rc
== GIF_ERROR
)
7826 image_error ("Error reading `%s'", img
->spec
, Qnil
);
7827 fn_DGifCloseFile (gif
);
7832 image
= image_spec_value (img
->spec
, QCindex
, NULL
);
7833 ino
= INTEGERP (image
) ? XFASTINT (image
) : 0;
7834 if (ino
>= gif
->ImageCount
)
7836 image_error ("Invalid image number `%s' in image `%s'",
7838 fn_DGifCloseFile (gif
);
7843 img
->corners
[TOP_CORNER
] = gif
->SavedImages
[ino
].ImageDesc
.Top
;
7844 img
->corners
[LEFT_CORNER
] = gif
->SavedImages
[ino
].ImageDesc
.Left
;
7845 image_height
= gif
->SavedImages
[ino
].ImageDesc
.Height
;
7846 img
->corners
[BOT_CORNER
] = img
->corners
[TOP_CORNER
] + image_height
;
7847 image_width
= gif
->SavedImages
[ino
].ImageDesc
.Width
;
7848 img
->corners
[RIGHT_CORNER
] = img
->corners
[LEFT_CORNER
] + image_width
;
7850 width
= img
->width
= max (gif
->SWidth
,
7851 max (gif
->Image
.Left
+ gif
->Image
.Width
,
7852 img
->corners
[RIGHT_CORNER
]));
7853 height
= img
->height
= max (gif
->SHeight
,
7854 max (gif
->Image
.Top
+ gif
->Image
.Height
,
7855 img
->corners
[BOT_CORNER
]));
7857 if (!check_image_size (f
, width
, height
))
7859 image_error ("Invalid image size", Qnil
, Qnil
);
7860 fn_DGifCloseFile (gif
);
7865 /* Create the X image and pixmap. */
7866 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
7868 fn_DGifCloseFile (gif
);
7873 /* Allocate colors. */
7874 gif_color_map
= gif
->SavedImages
[ino
].ImageDesc
.ColorMap
;
7876 gif_color_map
= gif
->SColorMap
;
7877 init_color_table ();
7878 bzero (pixel_colors
, sizeof pixel_colors
);
7880 for (i
= 0; i
< gif_color_map
->ColorCount
; ++i
)
7882 int r
= gif_color_map
->Colors
[i
].Red
<< 8;
7883 int g
= gif_color_map
->Colors
[i
].Green
<< 8;
7884 int b
= gif_color_map
->Colors
[i
].Blue
<< 8;
7885 pixel_colors
[i
] = lookup_rgb_color (f
, r
, g
, b
);
7888 #ifdef COLOR_TABLE_SUPPORT
7889 img
->colors
= colors_in_color_table (&img
->ncolors
);
7890 free_color_table ();
7891 #endif /* COLOR_TABLE_SUPPORT */
7893 /* Clear the part of the screen image that are not covered by
7894 the image from the GIF file. Full animated GIF support
7895 requires more than can be done here (see the gif89 spec,
7896 disposal methods). Let's simply assume that the part
7897 not covered by a sub-image is in the frame's background color. */
7898 for (y
= 0; y
< img
->corners
[TOP_CORNER
]; ++y
)
7899 for (x
= 0; x
< width
; ++x
)
7900 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7902 for (y
= img
->corners
[BOT_CORNER
]; y
< height
; ++y
)
7903 for (x
= 0; x
< width
; ++x
)
7904 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7906 for (y
= img
->corners
[TOP_CORNER
]; y
< img
->corners
[BOT_CORNER
]; ++y
)
7908 for (x
= 0; x
< img
->corners
[LEFT_CORNER
]; ++x
)
7909 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7910 for (x
= img
->corners
[RIGHT_CORNER
]; x
< width
; ++x
)
7911 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7914 /* Read the GIF image into the X image. We use a local variable
7915 `raster' here because RasterBits below is a char *, and invites
7916 problems with bytes >= 0x80. */
7917 raster
= (unsigned char *) gif
->SavedImages
[ino
].RasterBits
;
7919 if (gif
->SavedImages
[ino
].ImageDesc
.Interlace
)
7921 static int interlace_start
[] = {0, 4, 2, 1};
7922 static int interlace_increment
[] = {8, 8, 4, 2};
7924 int row
= interlace_start
[0];
7928 for (y
= 0; y
< image_height
; y
++)
7930 if (row
>= image_height
)
7932 row
= interlace_start
[++pass
];
7933 while (row
>= image_height
)
7934 row
= interlace_start
[++pass
];
7937 for (x
= 0; x
< image_width
; x
++)
7939 int i
= raster
[(y
* image_width
) + x
];
7940 XPutPixel (ximg
, x
+ img
->corners
[LEFT_CORNER
],
7941 row
+ img
->corners
[TOP_CORNER
], pixel_colors
[i
]);
7944 row
+= interlace_increment
[pass
];
7949 for (y
= 0; y
< image_height
; ++y
)
7950 for (x
= 0; x
< image_width
; ++x
)
7952 int i
= raster
[y
* image_width
+ x
];
7953 XPutPixel (ximg
, x
+ img
->corners
[LEFT_CORNER
],
7954 y
+ img
->corners
[TOP_CORNER
], pixel_colors
[i
]);
7958 /* Save GIF image extension data for `image-extension-data'.
7959 Format is (count IMAGES FUNCTION "BYTES" ...). */
7960 img
->data
.lisp_val
= Qnil
;
7961 if (gif
->SavedImages
[ino
].ExtensionBlockCount
> 0)
7963 ExtensionBlock
*ext
= gif
->SavedImages
[ino
].ExtensionBlocks
;
7964 for (i
= 0; i
< gif
->SavedImages
[ino
].ExtensionBlockCount
; i
++, ext
++)
7965 /* Append (... FUNCTION "BYTES") */
7966 img
->data
.lisp_val
= Fcons (make_unibyte_string (ext
->Bytes
, ext
->ByteCount
),
7967 Fcons (make_number (ext
->Function
),
7968 img
->data
.lisp_val
));
7969 img
->data
.lisp_val
= Fnreverse (img
->data
.lisp_val
);
7971 if (gif
->ImageCount
> 1)
7972 img
->data
.lisp_val
= Fcons (Qcount
,
7973 Fcons (make_number (gif
->ImageCount
),
7974 img
->data
.lisp_val
));
7976 fn_DGifCloseFile (gif
);
7978 /* Maybe fill in the background field while we have ximg handy. */
7979 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
7980 /* Casting avoids a GCC warning. */
7981 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
7983 /* Put the image into the pixmap, then free the X image and its buffer. */
7984 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
7985 x_destroy_x_image (ximg
);
7991 #else /* !HAVE_GIF */
7999 Lisp_Object specified_file
, file
;
8000 Lisp_Object specified_data
;
8002 Boolean graphic_p
, movie_p
, prefer_graphic_p
;
8010 Lisp_Object specified_bg
;
8015 TimeScale time_scale
;
8016 TimeValue time
, duration
;
8021 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
8022 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
8024 /* Animated gifs use QuickTime Movie Toolbox. So initialize it here. */
8027 if (NILP (specified_data
))
8029 /* Read from a file */
8033 err
= find_image_fsspec (specified_file
, &file
, &fss
);
8037 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
8042 err
= CanQuickTimeOpenFile (&fss
, kQTFileTypeGIF
, 0,
8043 &graphic_p
, &movie_p
, &prefer_graphic_p
, 0);
8047 if (!graphic_p
&& !movie_p
)
8049 if (prefer_graphic_p
)
8050 return image_load_qt_1 (f
, img
, kQTFileTypeGIF
, &fss
, NULL
);
8051 err
= OpenMovieFile (&fss
, &refnum
, fsRdPerm
);
8054 err
= NewMovieFromFile (&movie
, refnum
, NULL
, NULL
, 0, NULL
);
8055 CloseMovieFile (refnum
);
8058 image_error ("Error reading `%s'", file
, Qnil
);
8064 /* Memory source! */
8066 long file_type_atom
[3];
8068 err
= PtrToHand (SDATA (specified_data
), &dh
, SBYTES (specified_data
));
8071 image_error ("Cannot allocate data handle for `%s'",
8076 file_type_atom
[0] = EndianU32_NtoB (sizeof (long) * 3);
8077 file_type_atom
[1] = EndianU32_NtoB (kDataRefExtensionMacOSFileType
);
8078 file_type_atom
[2] = EndianU32_NtoB (kQTFileTypeGIF
);
8079 err
= PtrToHand (&dh
, &dref
, sizeof (Handle
));
8082 err
= PtrAndHand ("\p", dref
, 1);
8084 err
= PtrAndHand (file_type_atom
, dref
, sizeof (long) * 3);
8087 image_error ("Cannot allocate handle data ref for `%s'", img
->spec
, Qnil
);
8090 err
= CanQuickTimeOpenDataRef (dref
, HandleDataHandlerSubType
, &graphic_p
,
8091 &movie_p
, &prefer_graphic_p
, 0);
8095 if (!graphic_p
&& !movie_p
)
8097 if (prefer_graphic_p
)
8101 DisposeHandle (dref
);
8102 success_p
= image_load_qt_1 (f
, img
, kQTFileTypeGIF
, NULL
, dh
);
8106 err
= NewMovieFromDataRef (&movie
, 0, NULL
, dref
,
8107 HandleDataHandlerSubType
);
8108 DisposeHandle (dref
);
8113 image
= image_spec_value (img
->spec
, QCindex
, NULL
);
8114 ino
= INTEGERP (image
) ? XFASTINT (image
) : 0;
8115 track
= GetMovieIndTrack (movie
, 1);
8116 media
= GetTrackMedia (track
);
8117 nsamples
= GetMediaSampleCount (media
);
8118 if (ino
>= nsamples
)
8120 image_error ("Invalid image number `%s' in image `%s'",
8124 time_scale
= GetMediaTimeScale (media
);
8126 specified_bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
8127 if (!STRINGP (specified_bg
) ||
8128 !mac_defined_color (f
, SDATA (specified_bg
), &color
, 0))
8130 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
8131 color
.red
= RED16_FROM_ULONG (color
.pixel
);
8132 color
.green
= GREEN16_FROM_ULONG (color
.pixel
);
8133 color
.blue
= BLUE16_FROM_ULONG (color
.pixel
);
8135 GetMovieBox (movie
, &rect
);
8136 width
= img
->width
= rect
.right
- rect
.left
;
8137 height
= img
->height
= rect
.bottom
- rect
.top
;
8138 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
8141 GetGWorld (&old_port
, &old_gdh
);
8142 SetGWorld (ximg
, NULL
);
8143 bg_color
.red
= color
.red
;
8144 bg_color
.green
= color
.green
;
8145 bg_color
.blue
= color
.blue
;
8146 RGBBackColor (&bg_color
);
8147 SetGWorld (old_port
, old_gdh
);
8148 SetMovieActive (movie
, 1);
8149 SetMovieGWorld (movie
, ximg
, NULL
);
8150 SampleNumToMediaTime (media
, ino
+ 1, &time
, &duration
);
8151 SetMovieTimeValue (movie
, time
);
8152 MoviesTask (movie
, 0L);
8153 DisposeTrackMedia (media
);
8154 DisposeMovieTrack (track
);
8155 DisposeMovie (movie
);
8159 /* Save GIF image extension data for `image-extension-data'.
8160 Format is (count IMAGES 0xf9 GRAPHIC_CONTROL_EXTENSION_BLOCK). */
8162 Lisp_Object gce
= make_uninit_string (4);
8163 int centisec
= ((float)duration
/ time_scale
) * 100.0f
+ 0.5f
;
8165 /* Fill the delay time field. */
8166 SSET (gce
, 1, centisec
& 0xff);
8167 SSET (gce
, 2, (centisec
>> 8) & 0xff);
8168 /* We don't know about other fields. */
8172 img
->data
.lisp_val
= list4 (Qcount
, make_number (nsamples
),
8173 make_number (0xf9), gce
);
8176 /* Maybe fill in the background field while we have ximg handy. */
8177 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
8178 IMAGE_BACKGROUND (img
, f
, ximg
);
8180 /* Put the image into the pixmap. */
8181 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
8182 x_destroy_x_image (ximg
);
8186 image_error ("Cannot open `%s'", file
, Qnil
);
8189 DisposeTrackMedia (media
);
8191 DisposeMovieTrack (track
);
8193 DisposeMovie (movie
);
8200 #endif /* HAVE_GIF */
8204 /***********************************************************************
8206 ***********************************************************************/
8208 #ifdef HAVE_X_WINDOWS
8209 #define HAVE_GHOSTSCRIPT 1
8210 #endif /* HAVE_X_WINDOWS */
8212 /* The symbol `postscript' identifying images of this type. */
8214 Lisp_Object Qpostscript
;
8216 #ifdef HAVE_GHOSTSCRIPT
8218 static int gs_image_p
P_ ((Lisp_Object object
));
8219 static int gs_load
P_ ((struct frame
*f
, struct image
*img
));
8220 static void gs_clear_image
P_ ((struct frame
*f
, struct image
*img
));
8222 /* Keyword symbols. */
8224 Lisp_Object QCloader
, QCbounding_box
, QCpt_width
, QCpt_height
;
8226 /* Indices of image specification fields in gs_format, below. */
8228 enum gs_keyword_index
8246 /* Vector of image_keyword structures describing the format
8247 of valid user-defined image specifications. */
8249 static struct image_keyword gs_format
[GS_LAST
] =
8251 {":type", IMAGE_SYMBOL_VALUE
, 1},
8252 {":pt-width", IMAGE_POSITIVE_INTEGER_VALUE
, 1},
8253 {":pt-height", IMAGE_POSITIVE_INTEGER_VALUE
, 1},
8254 {":file", IMAGE_STRING_VALUE
, 1},
8255 {":loader", IMAGE_FUNCTION_VALUE
, 0},
8256 {":bounding-box", IMAGE_DONT_CHECK_VALUE_TYPE
, 1},
8257 {":ascent", IMAGE_ASCENT_VALUE
, 0},
8258 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
8259 {":relief", IMAGE_INTEGER_VALUE
, 0},
8260 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8261 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8262 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8263 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
8266 /* Structure describing the image type `ghostscript'. */
8268 static struct image_type gs_type
=
8278 /* Free X resources of Ghostscript image IMG which is used on frame F. */
8281 gs_clear_image (f
, img
)
8285 /* IMG->data.ptr_val may contain a recorded colormap. */
8286 xfree (img
->data
.ptr_val
);
8287 x_clear_image (f
, img
);
8291 /* Return non-zero if OBJECT is a valid Ghostscript image
8298 struct image_keyword fmt
[GS_LAST
];
8302 bcopy (gs_format
, fmt
, sizeof fmt
);
8304 if (!parse_image_spec (object
, fmt
, GS_LAST
, Qpostscript
))
8307 /* Bounding box must be a list or vector containing 4 integers. */
8308 tem
= fmt
[GS_BOUNDING_BOX
].value
;
8311 for (i
= 0; i
< 4; ++i
, tem
= XCDR (tem
))
8312 if (!CONSP (tem
) || !INTEGERP (XCAR (tem
)))
8317 else if (VECTORP (tem
))
8319 if (XVECTOR (tem
)->size
!= 4)
8321 for (i
= 0; i
< 4; ++i
)
8322 if (!INTEGERP (XVECTOR (tem
)->contents
[i
]))
8332 /* Load Ghostscript image IMG for use on frame F. Value is non-zero
8341 Lisp_Object window_and_pixmap_id
= Qnil
, loader
, pt_height
, pt_width
;
8342 struct gcpro gcpro1
, gcpro2
;
8344 double in_width
, in_height
;
8345 Lisp_Object pixel_colors
= Qnil
;
8347 /* Compute pixel size of pixmap needed from the given size in the
8348 image specification. Sizes in the specification are in pt. 1 pt
8349 = 1/72 in, xdpi and ydpi are stored in the frame's X display
8351 pt_width
= image_spec_value (img
->spec
, QCpt_width
, NULL
);
8352 in_width
= XFASTINT (pt_width
) / 72.0;
8353 img
->width
= in_width
* FRAME_X_DISPLAY_INFO (f
)->resx
;
8354 pt_height
= image_spec_value (img
->spec
, QCpt_height
, NULL
);
8355 in_height
= XFASTINT (pt_height
) / 72.0;
8356 img
->height
= in_height
* FRAME_X_DISPLAY_INFO (f
)->resy
;
8358 if (!check_image_size (f
, img
->width
, img
->height
))
8360 image_error ("Invalid image size", Qnil
, Qnil
);
8364 /* Create the pixmap. */
8365 xassert (img
->pixmap
== NO_PIXMAP
);
8367 /* Only W32 version did BLOCK_INPUT here. ++kfs */
8369 img
->pixmap
= XCreatePixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
8370 img
->width
, img
->height
,
8371 DefaultDepthOfScreen (FRAME_X_SCREEN (f
)));
8376 image_error ("Unable to create pixmap for `%s'", img
->spec
, Qnil
);
8380 /* Call the loader to fill the pixmap. It returns a process object
8381 if successful. We do not record_unwind_protect here because
8382 other places in redisplay like calling window scroll functions
8383 don't either. Let the Lisp loader use `unwind-protect' instead. */
8384 GCPRO2 (window_and_pixmap_id
, pixel_colors
);
8386 sprintf (buffer
, "%lu %lu",
8387 (unsigned long) FRAME_X_WINDOW (f
),
8388 (unsigned long) img
->pixmap
);
8389 window_and_pixmap_id
= build_string (buffer
);
8391 sprintf (buffer
, "%lu %lu",
8392 FRAME_FOREGROUND_PIXEL (f
),
8393 FRAME_BACKGROUND_PIXEL (f
));
8394 pixel_colors
= build_string (buffer
);
8396 XSETFRAME (frame
, f
);
8397 loader
= image_spec_value (img
->spec
, QCloader
, NULL
);
8399 loader
= intern ("gs-load-image");
8401 img
->data
.lisp_val
= call6 (loader
, frame
, img
->spec
,
8402 make_number (img
->width
),
8403 make_number (img
->height
),
8404 window_and_pixmap_id
,
8407 return PROCESSP (img
->data
.lisp_val
);
8411 /* Kill the Ghostscript process that was started to fill PIXMAP on
8412 frame F. Called from XTread_socket when receiving an event
8413 telling Emacs that Ghostscript has finished drawing. */
8416 x_kill_gs_process (pixmap
, f
)
8420 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
8424 /* Find the image containing PIXMAP. */
8425 for (i
= 0; i
< c
->used
; ++i
)
8426 if (c
->images
[i
]->pixmap
== pixmap
)
8429 /* Should someone in between have cleared the image cache, for
8430 instance, give up. */
8434 /* Kill the GS process. We should have found PIXMAP in the image
8435 cache and its image should contain a process object. */
8437 xassert (PROCESSP (img
->data
.lisp_val
));
8438 Fkill_process (img
->data
.lisp_val
, Qnil
);
8439 img
->data
.lisp_val
= Qnil
;
8441 #if defined (HAVE_X_WINDOWS)
8443 /* On displays with a mutable colormap, figure out the colors
8444 allocated for the image by looking at the pixels of an XImage for
8446 class = FRAME_X_VISUAL (f
)->class;
8447 if (class != StaticColor
&& class != StaticGray
&& class != TrueColor
)
8453 /* Try to get an XImage for img->pixmep. */
8454 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
8455 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
8460 /* Initialize the color table. */
8461 init_color_table ();
8463 /* For each pixel of the image, look its color up in the
8464 color table. After having done so, the color table will
8465 contain an entry for each color used by the image. */
8466 for (y
= 0; y
< img
->height
; ++y
)
8467 for (x
= 0; x
< img
->width
; ++x
)
8469 unsigned long pixel
= XGetPixel (ximg
, x
, y
);
8470 lookup_pixel_color (f
, pixel
);
8473 /* Record colors in the image. Free color table and XImage. */
8474 #ifdef COLOR_TABLE_SUPPORT
8475 img
->colors
= colors_in_color_table (&img
->ncolors
);
8476 free_color_table ();
8478 XDestroyImage (ximg
);
8480 #if 0 /* This doesn't seem to be the case. If we free the colors
8481 here, we get a BadAccess later in x_clear_image when
8482 freeing the colors. */
8483 /* We have allocated colors once, but Ghostscript has also
8484 allocated colors on behalf of us. So, to get the
8485 reference counts right, free them once. */
8487 x_free_colors (f
, img
->colors
, img
->ncolors
);
8491 image_error ("Cannot get X image of `%s'; colors will not be freed",
8496 #endif /* HAVE_X_WINDOWS */
8498 /* Now that we have the pixmap, compute mask and transform the
8499 image if requested. */
8501 postprocess_image (f
, img
);
8505 #endif /* HAVE_GHOSTSCRIPT */
8508 /***********************************************************************
8510 ***********************************************************************/
8514 DEFUN ("imagep", Fimagep
, Simagep
, 1, 1, 0,
8515 doc
: /* Value is non-nil if SPEC is a valid image specification. */)
8519 return valid_image_p (spec
) ? Qt
: Qnil
;
8523 DEFUN ("lookup-image", Flookup_image
, Slookup_image
, 1, 1, 0, "")
8529 if (valid_image_p (spec
))
8530 id
= lookup_image (SELECTED_FRAME (), spec
);
8533 return make_number (id
);
8536 #endif /* GLYPH_DEBUG != 0 */
8539 /***********************************************************************
8541 ***********************************************************************/
8544 /* Image types that rely on external libraries are loaded dynamically
8545 if the library is available. */
8546 #define CHECK_LIB_AVAILABLE(image_type, init_lib_fn, libraries) \
8547 define_image_type (image_type, init_lib_fn (libraries))
8549 #define CHECK_LIB_AVAILABLE(image_type, init_lib_fn, libraries) \
8550 define_image_type (image_type, 1)
8551 #endif /* HAVE_NTGUI */
8553 DEFUN ("init-image-library", Finit_image_library
, Sinit_image_library
, 2, 2, 0,
8554 doc
: /* Initialize image library implementing image type TYPE.
8555 Return non-nil if TYPE is a supported image type.
8557 Image types pbm and xbm are prebuilt; other types are loaded here.
8558 Libraries to load are specified in alist LIBRARIES (usually, the value
8559 of `image-library-alist', which see). */)
8561 Lisp_Object type
, libraries
;
8565 /* Don't try to reload the library. */
8566 tested
= Fassq (type
, Vimage_type_cache
);
8568 return XCDR (tested
);
8570 #if defined (HAVE_XPM) || defined (MAC_OS)
8571 if (EQ (type
, Qxpm
))
8572 return CHECK_LIB_AVAILABLE (&xpm_type
, init_xpm_functions
, libraries
);
8575 #if defined (HAVE_JPEG) || defined (MAC_OS)
8576 if (EQ (type
, Qjpeg
))
8577 return CHECK_LIB_AVAILABLE (&jpeg_type
, init_jpeg_functions
, libraries
);
8580 #if defined (HAVE_TIFF) || defined (MAC_OS)
8581 if (EQ (type
, Qtiff
))
8582 return CHECK_LIB_AVAILABLE (&tiff_type
, init_tiff_functions
, libraries
);
8585 #if defined (HAVE_GIF) || defined (MAC_OS)
8586 if (EQ (type
, Qgif
))
8587 return CHECK_LIB_AVAILABLE (&gif_type
, init_gif_functions
, libraries
);
8590 #if defined (HAVE_PNG) || defined (MAC_OS)
8591 if (EQ (type
, Qpng
))
8592 return CHECK_LIB_AVAILABLE (&png_type
, init_png_functions
, libraries
);
8595 #ifdef HAVE_GHOSTSCRIPT
8596 if (EQ (type
, Qpostscript
))
8597 return CHECK_LIB_AVAILABLE (&gs_type
, init_gs_functions
, libraries
);
8600 /* If the type is not recognized, avoid testing it ever again. */
8601 CACHE_IMAGE_TYPE (type
, Qnil
);
8608 extern Lisp_Object Qrisky_local_variable
; /* Syms_of_xdisp has already run. */
8610 /* Initialize this only once, since that's what we do with Vimage_types
8611 and they are supposed to be in sync. Initializing here gives correct
8612 operation on GNU/Linux of calling dump-emacs after loading some images. */
8615 /* Must be defined now becase we're going to update it below, while
8616 defining the supported image types. */
8617 DEFVAR_LISP ("image-types", &Vimage_types
,
8618 doc
: /* List of potentially supported image types.
8619 Each element of the list is a symbol for a image type, like 'jpeg or 'png.
8620 To check whether it is really supported, use `image-type-available-p'. */);
8621 Vimage_types
= Qnil
;
8623 DEFVAR_LISP ("image-library-alist", &Vimage_library_alist
,
8624 doc
: /* Alist of image types vs external libraries needed to display them.
8626 Each element is a list (IMAGE-TYPE LIBRARY...), where the car is a symbol
8627 representing a supported image type, and the rest are strings giving
8628 alternate filenames for the corresponding external libraries.
8630 Emacs tries to load the libraries in the order they appear on the
8631 list; if none is loaded, the running session of Emacs won't
8632 support the image type. Types 'pbm and 'xbm don't need to be
8633 listed; they're always supported. */);
8634 Vimage_library_alist
= Qnil
;
8635 Fput (intern ("image-library-alist"), Qrisky_local_variable
, Qt
);
8637 DEFVAR_LISP ("max-image-size", &Vmax_image_size
,
8638 doc
: /* Maximum size of images.
8639 Emacs will not load an image into memory if its pixel width or
8640 pixel height exceeds this limit.
8642 If the value is an integer, it directly specifies the maximum
8643 image height and width, measured in pixels. If it is a floating
8644 point number, it specifies the maximum image height and width
8645 as a ratio to the frame height and width. If the value is
8646 non-numeric, there is no explicit limit on the size of images. */);
8647 Vmax_image_size
= make_float (MAX_IMAGE_SIZE
);
8649 Vimage_type_cache
= Qnil
;
8650 staticpro (&Vimage_type_cache
);
8652 Qpbm
= intern ("pbm");
8654 ADD_IMAGE_TYPE(Qpbm
);
8656 Qxbm
= intern ("xbm");
8658 ADD_IMAGE_TYPE(Qxbm
);
8660 define_image_type (&xbm_type
, 1);
8661 define_image_type (&pbm_type
, 1);
8663 QCascent
= intern (":ascent");
8664 staticpro (&QCascent
);
8665 QCmargin
= intern (":margin");
8666 staticpro (&QCmargin
);
8667 QCrelief
= intern (":relief");
8668 staticpro (&QCrelief
);
8669 QCconversion
= intern (":conversion");
8670 staticpro (&QCconversion
);
8671 QCcolor_symbols
= intern (":color-symbols");
8672 staticpro (&QCcolor_symbols
);
8673 QCheuristic_mask
= intern (":heuristic-mask");
8674 staticpro (&QCheuristic_mask
);
8675 QCindex
= intern (":index");
8676 staticpro (&QCindex
);
8677 QCmatrix
= intern (":matrix");
8678 staticpro (&QCmatrix
);
8679 QCcolor_adjustment
= intern (":color-adjustment");
8680 staticpro (&QCcolor_adjustment
);
8681 QCmask
= intern (":mask");
8682 staticpro (&QCmask
);
8684 Qlaplace
= intern ("laplace");
8685 staticpro (&Qlaplace
);
8686 Qemboss
= intern ("emboss");
8687 staticpro (&Qemboss
);
8688 Qedge_detection
= intern ("edge-detection");
8689 staticpro (&Qedge_detection
);
8690 Qheuristic
= intern ("heuristic");
8691 staticpro (&Qheuristic
);
8693 Qpostscript
= intern ("postscript");
8694 staticpro (&Qpostscript
);
8695 #ifdef HAVE_GHOSTSCRIPT
8696 ADD_IMAGE_TYPE(Qpostscript
);
8697 QCloader
= intern (":loader");
8698 staticpro (&QCloader
);
8699 QCbounding_box
= intern (":bounding-box");
8700 staticpro (&QCbounding_box
);
8701 QCpt_width
= intern (":pt-width");
8702 staticpro (&QCpt_width
);
8703 QCpt_height
= intern (":pt-height");
8704 staticpro (&QCpt_height
);
8705 #endif /* HAVE_GHOSTSCRIPT */
8707 #if defined (HAVE_XPM) || defined (MAC_OS)
8708 Qxpm
= intern ("xpm");
8710 ADD_IMAGE_TYPE(Qxpm
);
8713 #if defined (HAVE_JPEG) || defined (MAC_OS)
8714 Qjpeg
= intern ("jpeg");
8716 ADD_IMAGE_TYPE(Qjpeg
);
8719 #if defined (HAVE_TIFF) || defined (MAC_OS)
8720 Qtiff
= intern ("tiff");
8722 ADD_IMAGE_TYPE(Qtiff
);
8725 #if defined (HAVE_GIF) || defined (MAC_OS)
8726 Qgif
= intern ("gif");
8728 ADD_IMAGE_TYPE(Qgif
);
8731 #if defined (HAVE_PNG) || defined (MAC_OS)
8732 Qpng
= intern ("png");
8734 ADD_IMAGE_TYPE(Qpng
);
8737 defsubr (&Sinit_image_library
);
8738 defsubr (&Sclear_image_cache
);
8739 defsubr (&Simage_refresh
);
8740 defsubr (&Simage_size
);
8741 defsubr (&Simage_mask_p
);
8742 defsubr (&Simage_extension_data
);
8746 defsubr (&Slookup_image
);
8749 DEFVAR_BOOL ("cross-disabled-images", &cross_disabled_images
,
8750 doc
: /* Non-nil means always draw a cross over disabled images.
8751 Disabled images are those having an `:conversion disabled' property.
8752 A cross is always drawn on black & white displays. */);
8753 cross_disabled_images
= 0;
8755 DEFVAR_LISP ("x-bitmap-file-path", &Vx_bitmap_file_path
,
8756 doc
: /* List of directories to search for window system bitmap files. */);
8757 Vx_bitmap_file_path
= decode_env_path ((char *) 0, PATH_BITMAPS
);
8759 DEFVAR_LISP ("image-cache-eviction-delay", &Vimage_cache_eviction_delay
,
8760 doc
: /* Time after which cached images are removed from the cache.
8761 When an image has not been displayed this many seconds, remove it
8762 from the image cache. Value must be an integer or nil with nil
8763 meaning don't clear the cache. */);
8764 Vimage_cache_eviction_delay
= make_number (30 * 60);
8770 #if defined (MAC_OSX) && TARGET_API_MAC_CARBON
8771 init_image_func_pointer ();
8775 /* arch-tag: 123c2a5e-14a8-4c53-ab95-af47d7db49b9
8776 (do not change this comment) */