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 (!c
) return NULL
;
1649 /* If the image spec does not specify a background color, the cached
1650 image must have the same background color as the current frame.
1651 The foreground color must also match, for the sake of monochrome
1654 In fact, we could ignore the foreground color matching condition
1655 for color images, or if the image spec specifies :foreground;
1656 similarly we could ignore the background color matching condition
1657 for formats that don't use transparency (such as jpeg), or if the
1658 image spec specifies :background. However, the extra memory
1659 usage is probably negligible in practice, so we don't bother. */
1661 for (img
= c
->buckets
[i
]; img
; img
= img
->next
)
1662 if (img
->hash
== hash
1663 && !NILP (Fequal (img
->spec
, spec
))
1664 && img
->frame_foreground
== FRAME_FOREGROUND_PIXEL (f
)
1665 && img
->frame_background
== FRAME_BACKGROUND_PIXEL (f
))
1671 /* Search frame F for an image with spec SPEC, and free it. */
1674 uncache_image (f
, spec
)
1678 struct image
*img
= search_image_cache (f
, spec
, sxhash (spec
, 0));
1680 free_image (f
, img
);
1684 /* Free image cache of frame F. Be aware that X frames share images
1688 free_image_cache (f
)
1691 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
1696 /* Cache should not be referenced by any frame when freed. */
1697 xassert (c
->refcount
== 0);
1699 for (i
= 0; i
< c
->used
; ++i
)
1700 free_image (f
, c
->images
[i
]);
1704 FRAME_X_IMAGE_CACHE (f
) = NULL
;
1709 /* Clear image cache of frame F. FORCE_P non-zero means free all
1710 images. FORCE_P zero means clear only images that haven't been
1711 displayed for some time. Should be called from time to time to
1712 reduce the number of loaded images. If image-cache-eviction-delay
1713 is non-nil, this frees images in the cache which weren't displayed
1714 for at least that many seconds. */
1717 clear_image_cache (f
, force_p
)
1721 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
1723 if (c
&& INTEGERP (Vimage_cache_eviction_delay
))
1730 old
= EMACS_SECS (t
) - XFASTINT (Vimage_cache_eviction_delay
);
1732 /* Block input so that we won't be interrupted by a SIGIO
1733 while being in an inconsistent state. */
1736 for (i
= nfreed
= 0; i
< c
->used
; ++i
)
1738 struct image
*img
= c
->images
[i
];
1740 && (force_p
|| img
->timestamp
< old
))
1742 free_image (f
, img
);
1747 /* We may be clearing the image cache because, for example,
1748 Emacs was iconified for a longer period of time. In that
1749 case, current matrices may still contain references to
1750 images freed above. So, clear these matrices. */
1753 Lisp_Object tail
, frame
;
1755 FOR_EACH_FRAME (tail
, frame
)
1757 struct frame
*f
= XFRAME (frame
);
1758 if (FRAME_WINDOW_P (f
)
1759 && FRAME_X_IMAGE_CACHE (f
) == c
)
1760 clear_current_matrices (f
);
1763 ++windows_or_buffers_changed
;
1771 DEFUN ("clear-image-cache", Fclear_image_cache
, Sclear_image_cache
,
1773 doc
: /* Clear the image cache of FRAME.
1774 FRAME nil or omitted means use the selected frame.
1775 FRAME t means clear the image caches of all frames. */)
1783 FOR_EACH_FRAME (tail
, frame
)
1784 if (FRAME_WINDOW_P (XFRAME (frame
)))
1785 clear_image_cache (XFRAME (frame
), 1);
1788 clear_image_cache (check_x_frame (frame
), 1);
1794 DEFUN ("image-refresh", Fimage_refresh
, Simage_refresh
,
1796 doc
: /* Refresh the image with specification SPEC on frame FRAME.
1797 If SPEC specifies an image file, the displayed image is updated with
1798 the current contents of that file.
1799 FRAME nil or omitted means use the selected frame.
1800 FRAME t means refresh the image on all frames. */)
1802 Lisp_Object spec
, frame
;
1804 if (!valid_image_p (spec
))
1805 error ("Invalid image specification");
1810 FOR_EACH_FRAME (tail
, frame
)
1812 struct frame
*f
= XFRAME (frame
);
1813 if (FRAME_WINDOW_P (f
))
1814 uncache_image (f
, spec
);
1818 uncache_image (check_x_frame (frame
), spec
);
1824 /* Compute masks and transform image IMG on frame F, as specified
1825 by the image's specification, */
1828 postprocess_image (f
, img
)
1832 /* Manipulation of the image's mask. */
1835 Lisp_Object conversion
, spec
;
1840 /* `:heuristic-mask t'
1842 means build a mask heuristically.
1843 `:heuristic-mask (R G B)'
1844 `:mask (heuristic (R G B))'
1845 means build a mask from color (R G B) in the
1848 means remove a mask, if any. */
1850 mask
= image_spec_value (spec
, QCheuristic_mask
, NULL
);
1852 x_build_heuristic_mask (f
, img
, mask
);
1857 mask
= image_spec_value (spec
, QCmask
, &found_p
);
1859 if (EQ (mask
, Qheuristic
))
1860 x_build_heuristic_mask (f
, img
, Qt
);
1861 else if (CONSP (mask
)
1862 && EQ (XCAR (mask
), Qheuristic
))
1864 if (CONSP (XCDR (mask
)))
1865 x_build_heuristic_mask (f
, img
, XCAR (XCDR (mask
)));
1867 x_build_heuristic_mask (f
, img
, XCDR (mask
));
1869 else if (NILP (mask
) && found_p
&& img
->mask
)
1871 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
1872 img
->mask
= NO_PIXMAP
;
1877 /* Should we apply an image transformation algorithm? */
1878 conversion
= image_spec_value (spec
, QCconversion
, NULL
);
1879 if (EQ (conversion
, Qdisabled
))
1880 x_disable_image (f
, img
);
1881 else if (EQ (conversion
, Qlaplace
))
1883 else if (EQ (conversion
, Qemboss
))
1885 else if (CONSP (conversion
)
1886 && EQ (XCAR (conversion
), Qedge_detection
))
1889 tem
= XCDR (conversion
);
1891 x_edge_detection (f
, img
,
1892 Fplist_get (tem
, QCmatrix
),
1893 Fplist_get (tem
, QCcolor_adjustment
));
1899 /* Return the id of image with Lisp specification SPEC on frame F.
1900 SPEC must be a valid Lisp image specification (see valid_image_p). */
1903 lookup_image (f
, spec
)
1909 struct gcpro gcpro1
;
1912 /* F must be a window-system frame, and SPEC must be a valid image
1914 xassert (FRAME_WINDOW_P (f
));
1915 xassert (valid_image_p (spec
));
1919 /* Look up SPEC in the hash table of the image cache. */
1920 hash
= sxhash (spec
, 0);
1921 img
= search_image_cache (f
, spec
, hash
);
1922 if (img
&& img
->load_failed_p
)
1924 free_image (f
, img
);
1928 /* If not found, create a new image and cache it. */
1931 extern Lisp_Object Qpostscript
;
1934 img
= make_image (spec
, hash
);
1935 cache_image (f
, img
);
1936 img
->load_failed_p
= img
->type
->load (f
, img
) == 0;
1937 img
->frame_foreground
= FRAME_FOREGROUND_PIXEL (f
);
1938 img
->frame_background
= FRAME_BACKGROUND_PIXEL (f
);
1940 /* If we can't load the image, and we don't have a width and
1941 height, use some arbitrary width and height so that we can
1942 draw a rectangle for it. */
1943 if (img
->load_failed_p
)
1947 value
= image_spec_value (spec
, QCwidth
, NULL
);
1948 img
->width
= (INTEGERP (value
)
1949 ? XFASTINT (value
) : DEFAULT_IMAGE_WIDTH
);
1950 value
= image_spec_value (spec
, QCheight
, NULL
);
1951 img
->height
= (INTEGERP (value
)
1952 ? XFASTINT (value
) : DEFAULT_IMAGE_HEIGHT
);
1956 /* Handle image type independent image attributes
1957 `:ascent ASCENT', `:margin MARGIN', `:relief RELIEF',
1958 `:background COLOR'. */
1959 Lisp_Object ascent
, margin
, relief
, bg
;
1961 ascent
= image_spec_value (spec
, QCascent
, NULL
);
1962 if (INTEGERP (ascent
))
1963 img
->ascent
= XFASTINT (ascent
);
1964 else if (EQ (ascent
, Qcenter
))
1965 img
->ascent
= CENTERED_IMAGE_ASCENT
;
1967 margin
= image_spec_value (spec
, QCmargin
, NULL
);
1968 if (INTEGERP (margin
) && XINT (margin
) >= 0)
1969 img
->vmargin
= img
->hmargin
= XFASTINT (margin
);
1970 else if (CONSP (margin
) && INTEGERP (XCAR (margin
))
1971 && INTEGERP (XCDR (margin
)))
1973 if (XINT (XCAR (margin
)) > 0)
1974 img
->hmargin
= XFASTINT (XCAR (margin
));
1975 if (XINT (XCDR (margin
)) > 0)
1976 img
->vmargin
= XFASTINT (XCDR (margin
));
1979 relief
= image_spec_value (spec
, QCrelief
, NULL
);
1980 if (INTEGERP (relief
))
1982 img
->relief
= XINT (relief
);
1983 img
->hmargin
+= abs (img
->relief
);
1984 img
->vmargin
+= abs (img
->relief
);
1987 if (! img
->background_valid
)
1989 bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
1993 = x_alloc_image_color (f
, img
, bg
,
1994 FRAME_BACKGROUND_PIXEL (f
));
1995 img
->background_valid
= 1;
1999 /* Do image transformations and compute masks, unless we
2000 don't have the image yet. */
2001 if (!EQ (*img
->type
->type
, Qpostscript
))
2002 postprocess_image (f
, img
);
2008 /* We're using IMG, so set its timestamp to `now'. */
2009 EMACS_GET_TIME (now
);
2010 img
->timestamp
= EMACS_SECS (now
);
2014 /* Value is the image id. */
2019 /* Cache image IMG in the image cache of frame F. */
2022 cache_image (f
, img
)
2026 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
2029 /* Find a free slot in c->images. */
2030 for (i
= 0; i
< c
->used
; ++i
)
2031 if (c
->images
[i
] == NULL
)
2034 /* If no free slot found, maybe enlarge c->images. */
2035 if (i
== c
->used
&& c
->used
== c
->size
)
2038 c
->images
= (struct image
**) xrealloc (c
->images
,
2039 c
->size
* sizeof *c
->images
);
2042 /* Add IMG to c->images, and assign IMG an id. */
2048 /* Add IMG to the cache's hash table. */
2049 i
= img
->hash
% IMAGE_CACHE_BUCKETS_SIZE
;
2050 img
->next
= c
->buckets
[i
];
2052 img
->next
->prev
= img
;
2054 c
->buckets
[i
] = img
;
2058 /* Call FN on every image in the image cache of frame F. Used to mark
2059 Lisp Objects in the image cache. */
2062 forall_images_in_image_cache (f
, fn
)
2064 void (*fn
) P_ ((struct image
*img
));
2066 if (FRAME_LIVE_P (f
) && FRAME_WINDOW_P (f
))
2068 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
2072 for (i
= 0; i
< c
->used
; ++i
)
2081 /***********************************************************************
2082 X / MAC / W32 support code
2083 ***********************************************************************/
2087 /* Macro for defining functions that will be loaded from image DLLs. */
2088 #define DEF_IMGLIB_FN(func) int (FAR CDECL *fn_##func)()
2090 /* Macro for loading those image functions from the library. */
2091 #define LOAD_IMGLIB_FN(lib,func) { \
2092 fn_##func = (void *) GetProcAddress (lib, #func); \
2093 if (!fn_##func) return 0; \
2096 /* Load a DLL implementing an image type.
2097 The `image-library-alist' variable associates a symbol,
2098 identifying an image type, to a list of possible filenames.
2099 The function returns NULL if no library could be loaded for
2100 the given image type, or if the library was previously loaded;
2101 else the handle of the DLL. */
2103 w32_delayed_load (Lisp_Object libraries
, Lisp_Object type
)
2105 HMODULE library
= NULL
;
2107 if (CONSP (libraries
) && NILP (Fassq (type
, Vimage_type_cache
)))
2109 Lisp_Object dlls
= Fassq (type
, libraries
);
2112 for (dlls
= XCDR (dlls
); CONSP (dlls
); dlls
= XCDR (dlls
))
2114 CHECK_STRING_CAR (dlls
);
2115 if (library
= LoadLibrary (SDATA (XCAR (dlls
))))
2123 #endif /* HAVE_NTGUI */
2125 static int x_create_x_image_and_pixmap
P_ ((struct frame
*, int, int, int,
2126 XImagePtr
*, Pixmap
*));
2127 static void x_destroy_x_image
P_ ((XImagePtr
));
2128 static void x_put_x_image
P_ ((struct frame
*, XImagePtr
, Pixmap
, int, int));
2131 /* Create an XImage and a pixmap of size WIDTH x HEIGHT for use on
2132 frame F. Set *XIMG and *PIXMAP to the XImage and Pixmap created.
2133 Set (*XIMG)->data to a raster of WIDTH x HEIGHT pixels allocated
2134 via xmalloc. Print error messages via image_error if an error
2135 occurs. Value is non-zero if successful.
2137 On W32, a DEPTH of zero signifies a 24 bit image, otherwise DEPTH
2138 should indicate the bit depth of the image. */
2141 x_create_x_image_and_pixmap (f
, width
, height
, depth
, ximg
, pixmap
)
2143 int width
, height
, depth
;
2147 #ifdef HAVE_X_WINDOWS
2148 Display
*display
= FRAME_X_DISPLAY (f
);
2149 Window window
= FRAME_X_WINDOW (f
);
2150 Screen
*screen
= FRAME_X_SCREEN (f
);
2152 xassert (interrupt_input_blocked
);
2155 depth
= DefaultDepthOfScreen (screen
);
2156 *ximg
= XCreateImage (display
, DefaultVisualOfScreen (screen
),
2157 depth
, ZPixmap
, 0, NULL
, width
, height
,
2158 depth
> 16 ? 32 : depth
> 8 ? 16 : 8, 0);
2161 image_error ("Unable to allocate X image", Qnil
, Qnil
);
2165 /* Allocate image raster. */
2166 (*ximg
)->data
= (char *) xmalloc ((*ximg
)->bytes_per_line
* height
);
2168 /* Allocate a pixmap of the same size. */
2169 *pixmap
= XCreatePixmap (display
, window
, width
, height
, depth
);
2170 if (*pixmap
== NO_PIXMAP
)
2172 x_destroy_x_image (*ximg
);
2174 image_error ("Unable to create X pixmap", Qnil
, Qnil
);
2179 #endif /* HAVE_X_WINDOWS */
2183 BITMAPINFOHEADER
*header
;
2185 int scanline_width_bits
;
2187 int palette_colors
= 0;
2192 if (depth
!= 1 && depth
!= 4 && depth
!= 8
2193 && depth
!= 16 && depth
!= 24 && depth
!= 32)
2195 image_error ("Invalid image bit depth specified", Qnil
, Qnil
);
2199 scanline_width_bits
= width
* depth
;
2200 remainder
= scanline_width_bits
% 32;
2203 scanline_width_bits
+= 32 - remainder
;
2205 /* Bitmaps with a depth less than 16 need a palette. */
2206 /* BITMAPINFO structure already contains the first RGBQUAD. */
2208 palette_colors
= 1 << depth
- 1;
2210 *ximg
= xmalloc (sizeof (XImage
) + palette_colors
* sizeof (RGBQUAD
));
2213 image_error ("Unable to allocate memory for XImage", Qnil
, Qnil
);
2217 header
= &((*ximg
)->info
.bmiHeader
);
2218 bzero (&((*ximg
)->info
), sizeof (BITMAPINFO
));
2219 header
->biSize
= sizeof (*header
);
2220 header
->biWidth
= width
;
2221 header
->biHeight
= -height
; /* negative indicates a top-down bitmap. */
2222 header
->biPlanes
= 1;
2223 header
->biBitCount
= depth
;
2224 header
->biCompression
= BI_RGB
;
2225 header
->biClrUsed
= palette_colors
;
2227 /* TODO: fill in palette. */
2230 (*ximg
)->info
.bmiColors
[0].rgbBlue
= 0;
2231 (*ximg
)->info
.bmiColors
[0].rgbGreen
= 0;
2232 (*ximg
)->info
.bmiColors
[0].rgbRed
= 0;
2233 (*ximg
)->info
.bmiColors
[0].rgbReserved
= 0;
2234 (*ximg
)->info
.bmiColors
[1].rgbBlue
= 255;
2235 (*ximg
)->info
.bmiColors
[1].rgbGreen
= 255;
2236 (*ximg
)->info
.bmiColors
[1].rgbRed
= 255;
2237 (*ximg
)->info
.bmiColors
[1].rgbReserved
= 0;
2240 hdc
= get_frame_dc (f
);
2242 /* Create a DIBSection and raster array for the bitmap,
2243 and store its handle in *pixmap. */
2244 *pixmap
= CreateDIBSection (hdc
, &((*ximg
)->info
),
2245 (depth
< 16) ? DIB_PAL_COLORS
: DIB_RGB_COLORS
,
2246 /* casting avoids a GCC warning */
2247 (void **)&((*ximg
)->data
), NULL
, 0);
2249 /* Realize display palette and garbage all frames. */
2250 release_frame_dc (f
, hdc
);
2252 if (*pixmap
== NULL
)
2254 DWORD err
= GetLastError();
2255 Lisp_Object errcode
;
2256 /* All system errors are < 10000, so the following is safe. */
2257 XSETINT (errcode
, (int) err
);
2258 image_error ("Unable to create bitmap, error code %d", errcode
, Qnil
);
2259 x_destroy_x_image (*ximg
);
2265 #endif /* HAVE_NTGUI */
2268 Display
*display
= FRAME_X_DISPLAY (f
);
2269 Window window
= FRAME_X_WINDOW (f
);
2271 xassert (interrupt_input_blocked
);
2273 /* Allocate a pixmap of the same size. */
2274 *pixmap
= XCreatePixmap (display
, window
, width
, height
, depth
);
2275 if (*pixmap
== NO_PIXMAP
)
2278 image_error ("Unable to create X pixmap", Qnil
, Qnil
);
2282 LockPixels (GetGWorldPixMap (*pixmap
));
2290 /* Destroy XImage XIMG. Free XIMG->data. */
2293 x_destroy_x_image (ximg
)
2296 xassert (interrupt_input_blocked
);
2299 #ifdef HAVE_X_WINDOWS
2302 XDestroyImage (ximg
);
2303 #endif /* HAVE_X_WINDOWS */
2305 /* Data will be freed by DestroyObject. */
2308 #endif /* HAVE_NTGUI */
2310 XDestroyImage (ximg
);
2316 /* Put XImage XIMG into pixmap PIXMAP on frame F. WIDTH and HEIGHT
2317 are width and height of both the image and pixmap. */
2320 x_put_x_image (f
, ximg
, pixmap
, width
, height
)
2326 #ifdef HAVE_X_WINDOWS
2329 xassert (interrupt_input_blocked
);
2330 gc
= XCreateGC (FRAME_X_DISPLAY (f
), pixmap
, 0, NULL
);
2331 XPutImage (FRAME_X_DISPLAY (f
), pixmap
, gc
, ximg
, 0, 0, 0, 0, width
, height
);
2332 XFreeGC (FRAME_X_DISPLAY (f
), gc
);
2333 #endif /* HAVE_X_WINDOWS */
2336 #if 0 /* I don't think this is necessary looking at where it is used. */
2337 HDC hdc
= get_frame_dc (f
);
2338 SetDIBits (hdc
, pixmap
, 0, height
, ximg
->data
, &(ximg
->info
), DIB_RGB_COLORS
);
2339 release_frame_dc (f
, hdc
);
2341 #endif /* HAVE_NTGUI */
2344 xassert (ximg
== pixmap
);
2349 /***********************************************************************
2351 ***********************************************************************/
2353 static unsigned char *slurp_file
P_ ((char *, int *));
2356 /* Find image file FILE. Look in data-directory, then
2357 x-bitmap-file-path. Value is the encoded full name of the file
2358 found, or nil if not found. */
2361 x_find_image_file (file
)
2364 Lisp_Object file_found
, search_path
;
2365 struct gcpro gcpro1
, gcpro2
;
2369 search_path
= Fcons (Vdata_directory
, Vx_bitmap_file_path
);
2370 GCPRO2 (file_found
, search_path
);
2372 /* Try to find FILE in data-directory, then x-bitmap-file-path. */
2373 fd
= openp (search_path
, file
, Qnil
, &file_found
, Qnil
);
2379 file_found
= ENCODE_FILE (file_found
);
2388 /* Read FILE into memory. Value is a pointer to a buffer allocated
2389 with xmalloc holding FILE's contents. Value is null if an error
2390 occurred. *SIZE is set to the size of the file. */
2392 static unsigned char *
2393 slurp_file (file
, size
)
2398 unsigned char *buf
= NULL
;
2401 if (stat (file
, &st
) == 0
2402 && (fp
= fopen (file
, "rb")) != NULL
2403 && (buf
= (unsigned char *) xmalloc (st
.st_size
),
2404 fread (buf
, 1, st
.st_size
, fp
) == st
.st_size
))
2427 /***********************************************************************
2428 MAC Image Load Functions
2429 ***********************************************************************/
2431 static int image_load_quicktime
P_ ((struct frame
*, struct image
*img
,
2434 static int image_load_quartz2d
P_ ((struct frame
*, struct image
*img
, int));
2438 find_image_fsspec (specified_file
, file
, fss
)
2439 Lisp_Object specified_file
, *file
;
2445 *file
= x_find_image_file (specified_file
);
2446 if (!STRINGP (*file
))
2447 return fnfErr
; /* file or directory not found;
2448 incomplete pathname */
2449 /* Try to open the image file. */
2450 err
= AECoercePtr (TYPE_FILE_NAME
, SDATA (*file
),
2451 SBYTES (*file
), typeFSS
, &desc
);
2454 #if TARGET_API_MAC_CARBON
2455 err
= AEGetDescData (&desc
, fss
, sizeof (FSSpec
));
2457 *fss
= *(FSSpec
*)(*(desc
.dataHandle
));
2459 AEDisposeDesc (&desc
);
2465 image_load_qt_1 (f
, img
, type
, fss
, dh
)
2472 ComponentResult err
;
2473 GraphicsImportComponent gi
;
2476 ImageDescriptionHandle desc_handle
;
2477 short draw_all_pixels
;
2478 Lisp_Object specified_bg
;
2483 err
= OpenADefaultComponent (GraphicsImporterComponentType
, type
, &gi
);
2486 image_error ("Cannot get importer component for `%s'", img
->spec
, Qnil
);
2491 /* read from file system spec */
2492 err
= GraphicsImportSetDataFile (gi
, fss
);
2495 image_error ("Cannot set fsspec to graphics importer for '%s'",
2502 /* read from data handle */
2503 err
= GraphicsImportSetDataHandle (gi
, dh
);
2506 image_error ("Cannot set data handle to graphics importer for `%s'",
2511 err
= GraphicsImportGetImageDescription (gi
, &desc_handle
);
2512 if (err
!= noErr
|| desc_handle
== NULL
)
2514 image_error ("Error reading `%s'", img
->spec
, Qnil
);
2517 width
= img
->width
= (*desc_handle
)->width
;
2518 height
= img
->height
= (*desc_handle
)->height
;
2519 DisposeHandle ((Handle
)desc_handle
);
2521 if (!check_image_size (f
, width
, height
))
2523 image_error ("Invalid image size", Qnil
, Qnil
);
2527 err
= GraphicsImportDoesDrawAllPixels (gi
, &draw_all_pixels
);
2529 /* Don't check the error code here. It may have an undocumented
2533 image_error ("Error reading `%s'", img
->spec
, Qnil
);
2537 if (draw_all_pixels
!= graphicsImporterDrawsAllPixels
)
2539 specified_bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
2540 if (!STRINGP (specified_bg
) ||
2541 !mac_defined_color (f
, SDATA (specified_bg
), &color
, 0))
2543 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
2544 color
.red
= RED16_FROM_ULONG (color
.pixel
);
2545 color
.green
= GREEN16_FROM_ULONG (color
.pixel
);
2546 color
.blue
= BLUE16_FROM_ULONG (color
.pixel
);
2550 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
2552 if (draw_all_pixels
!= graphicsImporterDrawsAllPixels
)
2557 GetGWorld (&old_port
, &old_gdh
);
2558 SetGWorld (ximg
, NULL
);
2559 bg_color
.red
= color
.red
;
2560 bg_color
.green
= color
.green
;
2561 bg_color
.blue
= color
.blue
;
2562 RGBBackColor (&bg_color
);
2563 #if TARGET_API_MAC_CARBON
2564 GetPortBounds (ximg
, &rect
);
2567 EraseRect (&(ximg
->portRect
));
2569 SetGWorld (old_port
, old_gdh
);
2571 GraphicsImportSetGWorld (gi
, ximg
, NULL
);
2572 GraphicsImportDraw (gi
);
2573 CloseComponent (gi
);
2575 /* Maybe fill in the background field while we have ximg handy. */
2576 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
2577 IMAGE_BACKGROUND (img
, f
, ximg
);
2579 /* Put the image into the pixmap. */
2580 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
2581 x_destroy_x_image (ximg
);
2585 CloseComponent (gi
);
2590 /* Load an image using the QuickTime Graphics Importer.
2591 Note: The alpha channel does not work for PNG images. */
2593 image_load_quicktime (f
, img
, type
)
2598 Lisp_Object specified_file
;
2599 Lisp_Object specified_data
;
2602 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
2603 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
2605 if (NILP (specified_data
))
2607 /* Read from a file */
2611 err
= find_image_fsspec (specified_file
, &file
, &fss
);
2615 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
2617 image_error ("Cannot open `%s'", file
, Qnil
);
2620 return image_load_qt_1 (f
, img
, type
, &fss
, NULL
);
2624 /* Memory source! */
2628 err
= PtrToHand (SDATA (specified_data
), &dh
, SBYTES (specified_data
));
2631 image_error ("Cannot allocate data handle for `%s'",
2635 success_p
= image_load_qt_1 (f
, img
, type
, NULL
, dh
);
2643 /* Load a PNG/JPEG image using Quartz 2D decoding routines.
2644 CGImageCreateWithPNGDataProvider is provided after Mac OS X 10.2.
2645 So don't use this function directly but determine at runtime
2646 whether it exists. */
2647 typedef CGImageRef (*CGImageCreateWithPNGDataProviderProcType
)
2648 (CGDataProviderRef
, const float [], bool, CGColorRenderingIntent
);
2649 static CGImageCreateWithPNGDataProviderProcType MyCGImageCreateWithPNGDataProvider
;
2653 init_image_func_pointer ()
2655 if (NSIsSymbolNameDefined ("_CGImageCreateWithPNGDataProvider"))
2657 MyCGImageCreateWithPNGDataProvider
2658 = (CGImageCreateWithPNGDataProviderProcType
)
2659 NSAddressOfSymbol (NSLookupAndBindSymbol
2660 ("_CGImageCreateWithPNGDataProvider"));
2663 MyCGImageCreateWithPNGDataProvider
= NULL
;
2668 image_load_quartz2d (f
, img
, png_p
)
2673 Lisp_Object file
, specified_file
;
2674 Lisp_Object specified_data
, specified_bg
;
2675 struct gcpro gcpro1
;
2676 CGDataProviderRef source
;
2680 XImagePtr ximg
= NULL
;
2681 CGContextRef context
;
2684 /* Open the file. */
2685 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
2686 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
2691 if (NILP (specified_data
))
2696 file
= x_find_image_file (specified_file
);
2697 if (!STRINGP (file
))
2699 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
2703 path
= cfstring_create_with_utf8_cstring (SDATA (file
));
2704 url
= CFURLCreateWithFileSystemPath (NULL
, path
,
2705 kCFURLPOSIXPathStyle
, 0);
2707 source
= CGDataProviderCreateWithURL (url
);
2711 source
= CGDataProviderCreateWithData (NULL
, SDATA (specified_data
),
2712 SBYTES (specified_data
), NULL
);
2715 image
= (*MyCGImageCreateWithPNGDataProvider
) (source
, NULL
, FALSE
,
2716 kCGRenderingIntentDefault
);
2718 image
= CGImageCreateWithJPEGDataProvider (source
, NULL
, FALSE
,
2719 kCGRenderingIntentDefault
);
2721 CGDataProviderRelease (source
);
2725 image_error ("Error reading image `%s'", img
->spec
, Qnil
);
2728 width
= img
->width
= CGImageGetWidth (image
);
2729 height
= img
->height
= CGImageGetHeight (image
);
2731 if (!check_image_size (f
, width
, height
))
2733 CGImageRelease (image
);
2735 image_error ("Invalid image size", Qnil
, Qnil
);
2741 specified_bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
2742 if (!STRINGP (specified_bg
) ||
2743 !mac_defined_color (f
, SDATA (specified_bg
), &color
, 0))
2745 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
2746 color
.red
= RED16_FROM_ULONG (color
.pixel
);
2747 color
.green
= GREEN16_FROM_ULONG (color
.pixel
);
2748 color
.blue
= BLUE16_FROM_ULONG (color
.pixel
);
2752 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
2754 CGImageRelease (image
);
2758 rectangle
= CGRectMake (0, 0, width
, height
);
2759 QDBeginCGContext (ximg
, &context
);
2762 CGContextSetRGBFillColor (context
, color
.red
/ 65535.0,
2763 color
.green
/ 65535.0,
2764 color
.blue
/ 65535.0, 1.0);
2765 CGContextFillRect (context
, rectangle
);
2767 CGContextDrawImage (context
, rectangle
, image
);
2768 QDEndCGContext (ximg
, &context
);
2769 CGImageRelease (image
);
2771 /* Maybe fill in the background field while we have ximg handy. */
2772 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
2773 IMAGE_BACKGROUND (img
, f
, ximg
);
2775 /* Put the image into the pixmap. */
2776 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
2777 x_destroy_x_image (ximg
);
2786 /***********************************************************************
2788 ***********************************************************************/
2790 static int xbm_scan
P_ ((unsigned char **, unsigned char *, char *, int *));
2791 static int xbm_load
P_ ((struct frame
*f
, struct image
*img
));
2792 static int xbm_load_image
P_ ((struct frame
*f
, struct image
*img
,
2793 unsigned char *, unsigned char *));
2794 static int xbm_image_p
P_ ((Lisp_Object object
));
2795 static int xbm_read_bitmap_data
P_ ((struct frame
*f
,
2796 unsigned char *, unsigned char *,
2797 int *, int *, unsigned char **));
2798 static int xbm_file_p
P_ ((Lisp_Object
));
2801 /* Indices of image specification fields in xbm_format, below. */
2803 enum xbm_keyword_index
2821 /* Vector of image_keyword structures describing the format
2822 of valid XBM image specifications. */
2824 static struct image_keyword xbm_format
[XBM_LAST
] =
2826 {":type", IMAGE_SYMBOL_VALUE
, 1},
2827 {":file", IMAGE_STRING_VALUE
, 0},
2828 {":width", IMAGE_POSITIVE_INTEGER_VALUE
, 0},
2829 {":height", IMAGE_POSITIVE_INTEGER_VALUE
, 0},
2830 {":data", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
2831 {":foreground", IMAGE_STRING_OR_NIL_VALUE
, 0},
2832 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0},
2833 {":ascent", IMAGE_ASCENT_VALUE
, 0},
2834 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
2835 {":relief", IMAGE_INTEGER_VALUE
, 0},
2836 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
2837 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
2838 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0}
2841 /* Structure describing the image type XBM. */
2843 static struct image_type xbm_type
=
2852 /* Tokens returned from xbm_scan. */
2861 /* Return non-zero if OBJECT is a valid XBM-type image specification.
2862 A valid specification is a list starting with the symbol `image'
2863 The rest of the list is a property list which must contain an
2866 If the specification specifies a file to load, it must contain
2867 an entry `:file FILENAME' where FILENAME is a string.
2869 If the specification is for a bitmap loaded from memory it must
2870 contain `:width WIDTH', `:height HEIGHT', and `:data DATA', where
2871 WIDTH and HEIGHT are integers > 0. DATA may be:
2873 1. a string large enough to hold the bitmap data, i.e. it must
2874 have a size >= (WIDTH + 7) / 8 * HEIGHT
2876 2. a bool-vector of size >= WIDTH * HEIGHT
2878 3. a vector of strings or bool-vectors, one for each line of the
2881 4. a string containing an in-memory XBM file. WIDTH and HEIGHT
2882 may not be specified in this case because they are defined in the
2885 Both the file and data forms may contain the additional entries
2886 `:background COLOR' and `:foreground COLOR'. If not present,
2887 foreground and background of the frame on which the image is
2888 displayed is used. */
2891 xbm_image_p (object
)
2894 struct image_keyword kw
[XBM_LAST
];
2896 bcopy (xbm_format
, kw
, sizeof kw
);
2897 if (!parse_image_spec (object
, kw
, XBM_LAST
, Qxbm
))
2900 xassert (EQ (kw
[XBM_TYPE
].value
, Qxbm
));
2902 if (kw
[XBM_FILE
].count
)
2904 if (kw
[XBM_WIDTH
].count
|| kw
[XBM_HEIGHT
].count
|| kw
[XBM_DATA
].count
)
2907 else if (kw
[XBM_DATA
].count
&& xbm_file_p (kw
[XBM_DATA
].value
))
2909 /* In-memory XBM file. */
2910 if (kw
[XBM_WIDTH
].count
|| kw
[XBM_HEIGHT
].count
|| kw
[XBM_FILE
].count
)
2918 /* Entries for `:width', `:height' and `:data' must be present. */
2919 if (!kw
[XBM_WIDTH
].count
2920 || !kw
[XBM_HEIGHT
].count
2921 || !kw
[XBM_DATA
].count
)
2924 data
= kw
[XBM_DATA
].value
;
2925 width
= XFASTINT (kw
[XBM_WIDTH
].value
);
2926 height
= XFASTINT (kw
[XBM_HEIGHT
].value
);
2928 /* Check type of data, and width and height against contents of
2934 /* Number of elements of the vector must be >= height. */
2935 if (XVECTOR (data
)->size
< height
)
2938 /* Each string or bool-vector in data must be large enough
2939 for one line of the image. */
2940 for (i
= 0; i
< height
; ++i
)
2942 Lisp_Object elt
= XVECTOR (data
)->contents
[i
];
2947 < (width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
)
2950 else if (BOOL_VECTOR_P (elt
))
2952 if (XBOOL_VECTOR (elt
)->size
< width
)
2959 else if (STRINGP (data
))
2962 < (width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
* height
)
2965 else if (BOOL_VECTOR_P (data
))
2967 if (XBOOL_VECTOR (data
)->size
< width
* height
)
2978 /* Scan a bitmap file. FP is the stream to read from. Value is
2979 either an enumerator from enum xbm_token, or a character for a
2980 single-character token, or 0 at end of file. If scanning an
2981 identifier, store the lexeme of the identifier in SVAL. If
2982 scanning a number, store its value in *IVAL. */
2985 xbm_scan (s
, end
, sval
, ival
)
2986 unsigned char **s
, *end
;
2994 /* Skip white space. */
2995 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
3000 else if (isdigit (c
))
3002 int value
= 0, digit
;
3004 if (c
== '0' && *s
< end
)
3007 if (c
== 'x' || c
== 'X')
3014 else if (c
>= 'a' && c
<= 'f')
3015 digit
= c
- 'a' + 10;
3016 else if (c
>= 'A' && c
<= 'F')
3017 digit
= c
- 'A' + 10;
3020 value
= 16 * value
+ digit
;
3023 else if (isdigit (c
))
3027 && (c
= *(*s
)++, isdigit (c
)))
3028 value
= 8 * value
+ c
- '0';
3035 && (c
= *(*s
)++, isdigit (c
)))
3036 value
= 10 * value
+ c
- '0';
3044 else if (isalpha (c
) || c
== '_')
3048 && (c
= *(*s
)++, (isalnum (c
) || c
== '_')))
3055 else if (c
== '/' && **s
== '*')
3057 /* C-style comment. */
3059 while (**s
&& (**s
!= '*' || *(*s
+ 1) != '/'))
3073 /* Create a Windows bitmap from X bitmap data. */
3075 w32_create_pixmap_from_bitmap_data (int width
, int height
, char *data
)
3077 static unsigned char swap_nibble
[16]
3078 = { 0x0, 0x8, 0x4, 0xc, /* 0000 1000 0100 1100 */
3079 0x2, 0xa, 0x6, 0xe, /* 0010 1010 0110 1110 */
3080 0x1, 0x9, 0x5, 0xd, /* 0001 1001 0101 1101 */
3081 0x3, 0xb, 0x7, 0xf }; /* 0011 1011 0111 1111 */
3083 unsigned char *bits
, *p
;
3086 w1
= (width
+ 7) / 8; /* nb of 8bits elt in X bitmap */
3087 w2
= ((width
+ 15) / 16) * 2; /* nb of 16bits elt in W32 bitmap */
3088 bits
= (unsigned char *) alloca (height
* w2
);
3089 bzero (bits
, height
* w2
);
3090 for (i
= 0; i
< height
; i
++)
3093 for (j
= 0; j
< w1
; j
++)
3095 /* Bitswap XBM bytes to match how Windows does things. */
3096 unsigned char c
= *data
++;
3097 *p
++ = (unsigned char)((swap_nibble
[c
& 0xf] << 4)
3098 | (swap_nibble
[(c
>>4) & 0xf]));
3101 bmp
= CreateBitmap (width
, height
, 1, 1, (char *) bits
);
3107 convert_mono_to_color_image (f
, img
, foreground
, background
)
3110 COLORREF foreground
, background
;
3112 HDC hdc
, old_img_dc
, new_img_dc
;
3113 HGDIOBJ old_prev
, new_prev
;
3116 hdc
= get_frame_dc (f
);
3117 old_img_dc
= CreateCompatibleDC (hdc
);
3118 new_img_dc
= CreateCompatibleDC (hdc
);
3119 new_pixmap
= CreateCompatibleBitmap (hdc
, img
->width
, img
->height
);
3120 release_frame_dc (f
, hdc
);
3121 old_prev
= SelectObject (old_img_dc
, img
->pixmap
);
3122 new_prev
= SelectObject (new_img_dc
, new_pixmap
);
3123 /* Windows convention for mono bitmaps is black = background,
3124 white = foreground. */
3125 SetTextColor (new_img_dc
, background
);
3126 SetBkColor (new_img_dc
, foreground
);
3128 BitBlt (new_img_dc
, 0, 0, img
->width
, img
->height
, old_img_dc
,
3131 SelectObject (old_img_dc
, old_prev
);
3132 SelectObject (new_img_dc
, new_prev
);
3133 DeleteDC (old_img_dc
);
3134 DeleteDC (new_img_dc
);
3135 DeleteObject (img
->pixmap
);
3136 if (new_pixmap
== 0)
3137 fprintf (stderr
, "Failed to convert image to color.\n");
3139 img
->pixmap
= new_pixmap
;
3142 #define XBM_BIT_SHUFFLE(b) (~(b))
3146 #define XBM_BIT_SHUFFLE(b) (b)
3148 #endif /* HAVE_NTGUI */
3152 Create_Pixmap_From_Bitmap_Data(f
, img
, data
, fg
, bg
, non_default_colors
)
3156 RGB_PIXEL_COLOR fg
, bg
;
3157 int non_default_colors
;
3161 = w32_create_pixmap_from_bitmap_data (img
->width
, img
->height
, data
);
3163 /* If colors were specified, transfer the bitmap to a color one. */
3164 if (non_default_colors
)
3165 convert_mono_to_color_image (f
, img
, fg
, bg
);
3168 = XCreatePixmapFromBitmapData (FRAME_X_DISPLAY (f
),
3171 img
->width
, img
->height
,
3173 DefaultDepthOfScreen (FRAME_X_SCREEN (f
)));
3174 #endif /* HAVE_NTGUI */
3179 /* Replacement for XReadBitmapFileData which isn't available under old
3180 X versions. CONTENTS is a pointer to a buffer to parse; END is the
3181 buffer's end. Set *WIDTH and *HEIGHT to the width and height of
3182 the image. Return in *DATA the bitmap data allocated with xmalloc.
3183 Value is non-zero if successful. DATA null means just test if
3184 CONTENTS looks like an in-memory XBM file. */
3187 xbm_read_bitmap_data (f
, contents
, end
, width
, height
, data
)
3189 unsigned char *contents
, *end
;
3190 int *width
, *height
;
3191 unsigned char **data
;
3193 unsigned char *s
= contents
;
3194 char buffer
[BUFSIZ
];
3197 int bytes_per_line
, i
, nbytes
;
3203 LA1 = xbm_scan (&s, end, buffer, &value)
3205 #define expect(TOKEN) \
3206 if (LA1 != (TOKEN)) \
3211 #define expect_ident(IDENT) \
3212 if (LA1 == XBM_TK_IDENT && strcmp (buffer, (IDENT)) == 0) \
3217 *width
= *height
= -1;
3220 LA1
= xbm_scan (&s
, end
, buffer
, &value
);
3222 /* Parse defines for width, height and hot-spots. */
3226 expect_ident ("define");
3227 expect (XBM_TK_IDENT
);
3229 if (LA1
== XBM_TK_NUMBER
)
3231 char *p
= strrchr (buffer
, '_');
3232 p
= p
? p
+ 1 : buffer
;
3233 if (strcmp (p
, "width") == 0)
3235 else if (strcmp (p
, "height") == 0)
3238 expect (XBM_TK_NUMBER
);
3241 if (!check_image_size (f
, *width
, *height
))
3243 else if (data
== NULL
)
3246 /* Parse bits. Must start with `static'. */
3247 expect_ident ("static");
3248 if (LA1
== XBM_TK_IDENT
)
3250 if (strcmp (buffer
, "unsigned") == 0)
3253 expect_ident ("char");
3255 else if (strcmp (buffer
, "short") == 0)
3259 if (*width
% 16 && *width
% 16 < 9)
3262 else if (strcmp (buffer
, "char") == 0)
3270 expect (XBM_TK_IDENT
);
3276 bytes_per_line
= (*width
+ 7) / 8 + padding_p
;
3277 nbytes
= bytes_per_line
* *height
;
3278 p
= *data
= (unsigned char *) xmalloc (nbytes
);
3282 for (i
= 0; i
< nbytes
; i
+= 2)
3285 expect (XBM_TK_NUMBER
);
3287 *p
++ = XBM_BIT_SHUFFLE (val
);
3288 if (!padding_p
|| ((i
+ 2) % bytes_per_line
))
3289 *p
++ = XBM_BIT_SHUFFLE (value
>> 8);
3291 if (LA1
== ',' || LA1
== '}')
3299 for (i
= 0; i
< nbytes
; ++i
)
3302 expect (XBM_TK_NUMBER
);
3304 *p
++ = XBM_BIT_SHUFFLE (val
);
3306 if (LA1
== ',' || LA1
== '}')
3331 /* Load XBM image IMG which will be displayed on frame F from buffer
3332 CONTENTS. END is the end of the buffer. Value is non-zero if
3336 xbm_load_image (f
, img
, contents
, end
)
3339 unsigned char *contents
, *end
;
3342 unsigned char *data
;
3345 rc
= xbm_read_bitmap_data (f
, contents
, end
, &img
->width
, &img
->height
, &data
);
3348 unsigned long foreground
= FRAME_FOREGROUND_PIXEL (f
);
3349 unsigned long background
= FRAME_BACKGROUND_PIXEL (f
);
3350 int non_default_colors
= 0;
3353 xassert (img
->width
> 0 && img
->height
> 0);
3355 /* Get foreground and background colors, maybe allocate colors. */
3356 value
= image_spec_value (img
->spec
, QCforeground
, NULL
);
3359 foreground
= x_alloc_image_color (f
, img
, value
, foreground
);
3360 non_default_colors
= 1;
3362 value
= image_spec_value (img
->spec
, QCbackground
, NULL
);
3365 background
= x_alloc_image_color (f
, img
, value
, background
);
3366 img
->background
= background
;
3367 img
->background_valid
= 1;
3368 non_default_colors
= 1;
3371 Create_Pixmap_From_Bitmap_Data (f
, img
, data
,
3372 foreground
, background
,
3373 non_default_colors
);
3376 if (img
->pixmap
== NO_PIXMAP
)
3378 x_clear_image (f
, img
);
3379 image_error ("Unable to create X pixmap for `%s'", img
->spec
, Qnil
);
3385 image_error ("Error loading XBM image `%s'", img
->spec
, Qnil
);
3391 /* Value is non-zero if DATA looks like an in-memory XBM file. */
3398 return (STRINGP (data
)
3399 && xbm_read_bitmap_data (NULL
, SDATA (data
),
3406 /* Fill image IMG which is used on frame F with pixmap data. Value is
3407 non-zero if successful. */
3415 Lisp_Object file_name
;
3417 xassert (xbm_image_p (img
->spec
));
3419 /* If IMG->spec specifies a file name, create a non-file spec from it. */
3420 file_name
= image_spec_value (img
->spec
, QCfile
, NULL
);
3421 if (STRINGP (file_name
))
3424 unsigned char *contents
;
3426 struct gcpro gcpro1
;
3428 file
= x_find_image_file (file_name
);
3430 if (!STRINGP (file
))
3432 image_error ("Cannot find image file `%s'", file_name
, Qnil
);
3437 contents
= slurp_file (SDATA (file
), &size
);
3438 if (contents
== NULL
)
3440 image_error ("Error loading XBM image `%s'", img
->spec
, Qnil
);
3445 success_p
= xbm_load_image (f
, img
, contents
, contents
+ size
);
3450 struct image_keyword fmt
[XBM_LAST
];
3452 unsigned long foreground
= FRAME_FOREGROUND_PIXEL (f
);
3453 unsigned long background
= FRAME_BACKGROUND_PIXEL (f
);
3454 int non_default_colors
= 0;
3457 int in_memory_file_p
= 0;
3459 /* See if data looks like an in-memory XBM file. */
3460 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
3461 in_memory_file_p
= xbm_file_p (data
);
3463 /* Parse the image specification. */
3464 bcopy (xbm_format
, fmt
, sizeof fmt
);
3465 parsed_p
= parse_image_spec (img
->spec
, fmt
, XBM_LAST
, Qxbm
);
3468 /* Get specified width, and height. */
3469 if (!in_memory_file_p
)
3471 img
->width
= XFASTINT (fmt
[XBM_WIDTH
].value
);
3472 img
->height
= XFASTINT (fmt
[XBM_HEIGHT
].value
);
3473 xassert (img
->width
> 0 && img
->height
> 0);
3476 /* Get foreground and background colors, maybe allocate colors. */
3477 if (fmt
[XBM_FOREGROUND
].count
3478 && STRINGP (fmt
[XBM_FOREGROUND
].value
))
3480 foreground
= x_alloc_image_color (f
, img
, fmt
[XBM_FOREGROUND
].value
,
3482 non_default_colors
= 1;
3485 if (fmt
[XBM_BACKGROUND
].count
3486 && STRINGP (fmt
[XBM_BACKGROUND
].value
))
3488 background
= x_alloc_image_color (f
, img
, fmt
[XBM_BACKGROUND
].value
,
3490 non_default_colors
= 1;
3493 if (in_memory_file_p
)
3494 success_p
= xbm_load_image (f
, img
, SDATA (data
),
3503 int nbytes
= (img
->width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
;
3505 p
= bits
= (char *) alloca (nbytes
* img
->height
);
3506 for (i
= 0; i
< img
->height
; ++i
, p
+= nbytes
)
3508 Lisp_Object line
= XVECTOR (data
)->contents
[i
];
3510 bcopy (SDATA (line
), p
, nbytes
);
3512 bcopy (XBOOL_VECTOR (line
)->data
, p
, nbytes
);
3515 else if (STRINGP (data
))
3516 bits
= SDATA (data
);
3518 bits
= XBOOL_VECTOR (data
)->data
;
3524 /* Windows mono bitmaps are reversed compared with X. */
3525 invertedBits
= bits
;
3526 nbytes
= (img
->width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
3528 bits
= (char *) alloca(nbytes
);
3529 for (i
= 0; i
< nbytes
; i
++)
3530 bits
[i
] = XBM_BIT_SHUFFLE (invertedBits
[i
]);
3533 /* Create the pixmap. */
3535 Create_Pixmap_From_Bitmap_Data (f
, img
, bits
,
3536 foreground
, background
,
3537 non_default_colors
);
3542 image_error ("Unable to create pixmap for XBM image `%s'",
3544 x_clear_image (f
, img
);
3554 /***********************************************************************
3556 ***********************************************************************/
3558 #if defined (HAVE_XPM) || defined (MAC_OS)
3560 static int xpm_image_p
P_ ((Lisp_Object object
));
3561 static int xpm_load
P_ ((struct frame
*f
, struct image
*img
));
3562 static int xpm_valid_color_symbols_p
P_ ((Lisp_Object
));
3564 #endif /* HAVE_XPM || MAC_OS */
3568 /* Indicate to xpm.h that we don't have Xlib. */
3570 /* simx.h in xpm defines XColor and XImage differently than Emacs. */
3571 /* It also defines Display the same way as Emacs, but gcc 3.3 still barfs. */
3572 #define XColor xpm_XColor
3573 #define XImage xpm_XImage
3574 #define Display xpm_Display
3575 #define PIXEL_ALREADY_TYPEDEFED
3576 #include "X11/xpm.h"
3581 #undef PIXEL_ALREADY_TYPEDEFED
3583 #include "X11/xpm.h"
3584 #endif /* HAVE_NTGUI */
3585 #endif /* HAVE_XPM */
3587 #if defined (HAVE_XPM) || defined (MAC_OS)
3588 /* The symbol `xpm' identifying XPM-format images. */
3592 /* Indices of image specification fields in xpm_format, below. */
3594 enum xpm_keyword_index
3610 /* Vector of image_keyword structures describing the format
3611 of valid XPM image specifications. */
3613 static struct image_keyword xpm_format
[XPM_LAST
] =
3615 {":type", IMAGE_SYMBOL_VALUE
, 1},
3616 {":file", IMAGE_STRING_VALUE
, 0},
3617 {":data", IMAGE_STRING_VALUE
, 0},
3618 {":ascent", IMAGE_ASCENT_VALUE
, 0},
3619 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
3620 {":relief", IMAGE_INTEGER_VALUE
, 0},
3621 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3622 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3623 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3624 {":color-symbols", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3625 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
3628 /* Structure describing the image type XPM. */
3630 static struct image_type xpm_type
=
3639 #ifdef HAVE_X_WINDOWS
3641 /* Define ALLOC_XPM_COLORS if we can use Emacs' own color allocation
3642 functions for allocating image colors. Our own functions handle
3643 color allocation failures more gracefully than the ones on the XPM
3646 #if defined XpmAllocColor && defined XpmFreeColors && defined XpmColorClosure
3647 #define ALLOC_XPM_COLORS
3649 #endif /* HAVE_X_WINDOWS */
3651 #ifdef ALLOC_XPM_COLORS
3653 static void xpm_init_color_cache
P_ ((struct frame
*, XpmAttributes
*));
3654 static void xpm_free_color_cache
P_ ((void));
3655 static int xpm_lookup_color
P_ ((struct frame
*, char *, XColor
*));
3656 static int xpm_color_bucket
P_ ((char *));
3657 static struct xpm_cached_color
*xpm_cache_color
P_ ((struct frame
*, char *,
3660 /* An entry in a hash table used to cache color definitions of named
3661 colors. This cache is necessary to speed up XPM image loading in
3662 case we do color allocations ourselves. Without it, we would need
3663 a call to XParseColor per pixel in the image. */
3665 struct xpm_cached_color
3667 /* Next in collision chain. */
3668 struct xpm_cached_color
*next
;
3670 /* Color definition (RGB and pixel color). */
3677 /* The hash table used for the color cache, and its bucket vector
3680 #define XPM_COLOR_CACHE_BUCKETS 1001
3681 struct xpm_cached_color
**xpm_color_cache
;
3683 /* Initialize the color cache. */
3686 xpm_init_color_cache (f
, attrs
)
3688 XpmAttributes
*attrs
;
3690 size_t nbytes
= XPM_COLOR_CACHE_BUCKETS
* sizeof *xpm_color_cache
;
3691 xpm_color_cache
= (struct xpm_cached_color
**) xmalloc (nbytes
);
3692 memset (xpm_color_cache
, 0, nbytes
);
3693 init_color_table ();
3695 if (attrs
->valuemask
& XpmColorSymbols
)
3700 for (i
= 0; i
< attrs
->numsymbols
; ++i
)
3701 if (XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
3702 attrs
->colorsymbols
[i
].value
, &color
))
3704 color
.pixel
= lookup_rgb_color (f
, color
.red
, color
.green
,
3706 xpm_cache_color (f
, attrs
->colorsymbols
[i
].name
, &color
, -1);
3711 /* Free the color cache. */
3714 xpm_free_color_cache ()
3716 struct xpm_cached_color
*p
, *next
;
3719 for (i
= 0; i
< XPM_COLOR_CACHE_BUCKETS
; ++i
)
3720 for (p
= xpm_color_cache
[i
]; p
; p
= next
)
3726 xfree (xpm_color_cache
);
3727 xpm_color_cache
= NULL
;
3728 free_color_table ();
3731 /* Return the bucket index for color named COLOR_NAME in the color
3735 xpm_color_bucket (color_name
)
3741 for (s
= color_name
; *s
; ++s
)
3743 return h
%= XPM_COLOR_CACHE_BUCKETS
;
3747 /* On frame F, cache values COLOR for color with name COLOR_NAME.
3748 BUCKET, if >= 0, is a precomputed bucket index. Value is the cache
3751 static struct xpm_cached_color
*
3752 xpm_cache_color (f
, color_name
, color
, bucket
)
3759 struct xpm_cached_color
*p
;
3762 bucket
= xpm_color_bucket (color_name
);
3764 nbytes
= sizeof *p
+ strlen (color_name
);
3765 p
= (struct xpm_cached_color
*) xmalloc (nbytes
);
3766 strcpy (p
->name
, color_name
);
3768 p
->next
= xpm_color_cache
[bucket
];
3769 xpm_color_cache
[bucket
] = p
;
3773 /* Look up color COLOR_NAME for frame F in the color cache. If found,
3774 return the cached definition in *COLOR. Otherwise, make a new
3775 entry in the cache and allocate the color. Value is zero if color
3776 allocation failed. */
3779 xpm_lookup_color (f
, color_name
, color
)
3784 struct xpm_cached_color
*p
;
3785 int h
= xpm_color_bucket (color_name
);
3787 for (p
= xpm_color_cache
[h
]; p
; p
= p
->next
)
3788 if (strcmp (p
->name
, color_name
) == 0)
3793 else if (XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
3796 color
->pixel
= lookup_rgb_color (f
, color
->red
, color
->green
,
3798 p
= xpm_cache_color (f
, color_name
, color
, h
);
3800 /* You get `opaque' at least from ImageMagick converting pbm to xpm
3801 with transparency, and it's useful. */
3802 else if (strcmp ("opaque", color_name
) == 0)
3804 bzero (color
, sizeof (XColor
)); /* Is this necessary/correct? */
3805 color
->pixel
= FRAME_FOREGROUND_PIXEL (f
);
3806 p
= xpm_cache_color (f
, color_name
, color
, h
);
3813 /* Callback for allocating color COLOR_NAME. Called from the XPM lib.
3814 CLOSURE is a pointer to the frame on which we allocate the
3815 color. Return in *COLOR the allocated color. Value is non-zero
3819 xpm_alloc_color (dpy
, cmap
, color_name
, color
, closure
)
3826 return xpm_lookup_color ((struct frame
*) closure
, color_name
, color
);
3830 /* Callback for freeing NPIXELS colors contained in PIXELS. CLOSURE
3831 is a pointer to the frame on which we allocate the color. Value is
3832 non-zero if successful. */
3835 xpm_free_colors (dpy
, cmap
, pixels
, npixels
, closure
)
3845 #endif /* ALLOC_XPM_COLORS */
3850 /* XPM library details. */
3852 DEF_IMGLIB_FN (XpmFreeAttributes
);
3853 DEF_IMGLIB_FN (XpmCreateImageFromBuffer
);
3854 DEF_IMGLIB_FN (XpmReadFileToImage
);
3855 DEF_IMGLIB_FN (XImageFree
);
3858 init_xpm_functions (Lisp_Object libraries
)
3862 if (!(library
= w32_delayed_load (libraries
, Qxpm
)))
3865 LOAD_IMGLIB_FN (library
, XpmFreeAttributes
);
3866 LOAD_IMGLIB_FN (library
, XpmCreateImageFromBuffer
);
3867 LOAD_IMGLIB_FN (library
, XpmReadFileToImage
);
3868 LOAD_IMGLIB_FN (library
, XImageFree
);
3872 #endif /* HAVE_NTGUI */
3875 /* Value is non-zero if COLOR_SYMBOLS is a valid color symbols list
3876 for XPM images. Such a list must consist of conses whose car and
3880 xpm_valid_color_symbols_p (color_symbols
)
3881 Lisp_Object color_symbols
;
3883 while (CONSP (color_symbols
))
3885 Lisp_Object sym
= XCAR (color_symbols
);
3887 || !STRINGP (XCAR (sym
))
3888 || !STRINGP (XCDR (sym
)))
3890 color_symbols
= XCDR (color_symbols
);
3893 return NILP (color_symbols
);
3897 /* Value is non-zero if OBJECT is a valid XPM image specification. */
3900 xpm_image_p (object
)
3903 struct image_keyword fmt
[XPM_LAST
];
3904 bcopy (xpm_format
, fmt
, sizeof fmt
);
3905 return (parse_image_spec (object
, fmt
, XPM_LAST
, Qxpm
)
3906 /* Either `:file' or `:data' must be present. */
3907 && fmt
[XPM_FILE
].count
+ fmt
[XPM_DATA
].count
== 1
3908 /* Either no `:color-symbols' or it's a list of conses
3909 whose car and cdr are strings. */
3910 && (fmt
[XPM_COLOR_SYMBOLS
].count
== 0
3911 || xpm_valid_color_symbols_p (fmt
[XPM_COLOR_SYMBOLS
].value
)));
3914 #endif /* HAVE_XPM || MAC_OS */
3916 #if defined (HAVE_XPM) && defined (HAVE_X_WINDOWS)
3918 x_create_bitmap_from_xpm_data (f
, bits
)
3922 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
3924 XpmAttributes attrs
;
3925 Pixmap bitmap
, mask
;
3927 bzero (&attrs
, sizeof attrs
);
3929 attrs
.visual
= FRAME_X_VISUAL (f
);
3930 attrs
.colormap
= FRAME_X_COLORMAP (f
);
3931 attrs
.valuemask
|= XpmVisual
;
3932 attrs
.valuemask
|= XpmColormap
;
3934 rc
= XpmCreatePixmapFromData (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3935 bits
, &bitmap
, &mask
, &attrs
);
3936 if (rc
!= XpmSuccess
)
3938 XpmFreeAttributes (&attrs
);
3942 id
= x_allocate_bitmap_record (f
);
3943 dpyinfo
->bitmaps
[id
- 1].pixmap
= bitmap
;
3944 dpyinfo
->bitmaps
[id
- 1].have_mask
= 1;
3945 dpyinfo
->bitmaps
[id
- 1].mask
= mask
;
3946 dpyinfo
->bitmaps
[id
- 1].file
= NULL
;
3947 dpyinfo
->bitmaps
[id
- 1].height
= attrs
.height
;
3948 dpyinfo
->bitmaps
[id
- 1].width
= attrs
.width
;
3949 dpyinfo
->bitmaps
[id
- 1].depth
= attrs
.depth
;
3950 dpyinfo
->bitmaps
[id
- 1].refcount
= 1;
3952 XpmFreeAttributes (&attrs
);
3955 #endif /* defined (HAVE_XPM) && defined (HAVE_X_WINDOWS) */
3957 /* Load image IMG which will be displayed on frame F. Value is
3958 non-zero if successful. */
3968 XpmAttributes attrs
;
3969 Lisp_Object specified_file
, color_symbols
;
3972 xpm_XImage
* xpm_image
= NULL
, * xpm_mask
= NULL
;
3973 #endif /* HAVE_NTGUI */
3975 /* Configure the XPM lib. Use the visual of frame F. Allocate
3976 close colors. Return colors allocated. */
3977 bzero (&attrs
, sizeof attrs
);
3980 attrs
.visual
= FRAME_X_VISUAL (f
);
3981 attrs
.colormap
= FRAME_X_COLORMAP (f
);
3982 attrs
.valuemask
|= XpmVisual
;
3983 attrs
.valuemask
|= XpmColormap
;
3984 #endif /* HAVE_NTGUI */
3986 #ifdef ALLOC_XPM_COLORS
3987 /* Allocate colors with our own functions which handle
3988 failing color allocation more gracefully. */
3989 attrs
.color_closure
= f
;
3990 attrs
.alloc_color
= xpm_alloc_color
;
3991 attrs
.free_colors
= xpm_free_colors
;
3992 attrs
.valuemask
|= XpmAllocColor
| XpmFreeColors
| XpmColorClosure
;
3993 #else /* not ALLOC_XPM_COLORS */
3994 /* Let the XPM lib allocate colors. */
3995 attrs
.valuemask
|= XpmReturnAllocPixels
;
3996 #ifdef XpmAllocCloseColors
3997 attrs
.alloc_close_colors
= 1;
3998 attrs
.valuemask
|= XpmAllocCloseColors
;
3999 #else /* not XpmAllocCloseColors */
4000 attrs
.closeness
= 600;
4001 attrs
.valuemask
|= XpmCloseness
;
4002 #endif /* not XpmAllocCloseColors */
4003 #endif /* ALLOC_XPM_COLORS */
4005 /* If image specification contains symbolic color definitions, add
4006 these to `attrs'. */
4007 color_symbols
= image_spec_value (img
->spec
, QCcolor_symbols
, NULL
);
4008 if (CONSP (color_symbols
))
4011 XpmColorSymbol
*xpm_syms
;
4014 attrs
.valuemask
|= XpmColorSymbols
;
4016 /* Count number of symbols. */
4017 attrs
.numsymbols
= 0;
4018 for (tail
= color_symbols
; CONSP (tail
); tail
= XCDR (tail
))
4021 /* Allocate an XpmColorSymbol array. */
4022 size
= attrs
.numsymbols
* sizeof *xpm_syms
;
4023 xpm_syms
= (XpmColorSymbol
*) alloca (size
);
4024 bzero (xpm_syms
, size
);
4025 attrs
.colorsymbols
= xpm_syms
;
4027 /* Fill the color symbol array. */
4028 for (tail
= color_symbols
, i
= 0;
4030 ++i
, tail
= XCDR (tail
))
4032 Lisp_Object name
= XCAR (XCAR (tail
));
4033 Lisp_Object color
= XCDR (XCAR (tail
));
4034 xpm_syms
[i
].name
= (char *) alloca (SCHARS (name
) + 1);
4035 strcpy (xpm_syms
[i
].name
, SDATA (name
));
4036 xpm_syms
[i
].value
= (char *) alloca (SCHARS (color
) + 1);
4037 strcpy (xpm_syms
[i
].value
, SDATA (color
));
4041 /* Create a pixmap for the image, either from a file, or from a
4042 string buffer containing data in the same format as an XPM file. */
4043 #ifdef ALLOC_XPM_COLORS
4044 xpm_init_color_cache (f
, &attrs
);
4047 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
4051 HDC frame_dc
= get_frame_dc (f
);
4052 hdc
= CreateCompatibleDC (frame_dc
);
4053 release_frame_dc (f
, frame_dc
);
4055 #endif /* HAVE_NTGUI */
4057 if (STRINGP (specified_file
))
4059 Lisp_Object file
= x_find_image_file (specified_file
);
4060 if (!STRINGP (file
))
4062 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
4067 /* XpmReadFileToPixmap is not available in the Windows port of
4068 libxpm. But XpmReadFileToImage almost does what we want. */
4069 rc
= fn_XpmReadFileToImage (&hdc
, SDATA (file
),
4070 &xpm_image
, &xpm_mask
,
4073 rc
= XpmReadFileToPixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
4074 SDATA (file
), &img
->pixmap
, &img
->mask
,
4076 #endif /* HAVE_NTGUI */
4080 Lisp_Object buffer
= image_spec_value (img
->spec
, QCdata
, NULL
);
4082 /* XpmCreatePixmapFromBuffer is not available in the Windows port
4083 of libxpm. But XpmCreateImageFromBuffer almost does what we want. */
4084 rc
= fn_XpmCreateImageFromBuffer (&hdc
, SDATA (buffer
),
4085 &xpm_image
, &xpm_mask
,
4088 rc
= XpmCreatePixmapFromBuffer (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
4090 &img
->pixmap
, &img
->mask
,
4092 #endif /* HAVE_NTGUI */
4095 if (rc
== XpmSuccess
)
4097 #if defined (COLOR_TABLE_SUPPORT) && defined (ALLOC_XPM_COLORS)
4098 img
->colors
= colors_in_color_table (&img
->ncolors
);
4099 #else /* not ALLOC_XPM_COLORS */
4103 /* W32 XPM uses XImage to wrap what W32 Emacs calls a Pixmap,
4104 plus some duplicate attributes. */
4105 if (xpm_image
&& xpm_image
->bitmap
)
4107 img
->pixmap
= xpm_image
->bitmap
;
4108 /* XImageFree in libXpm frees XImage struct without destroying
4109 the bitmap, which is what we want. */
4110 fn_XImageFree (xpm_image
);
4112 if (xpm_mask
&& xpm_mask
->bitmap
)
4114 /* The mask appears to be inverted compared with what we expect.
4115 TODO: invert our expectations. See other places where we
4116 have to invert bits because our idea of masks is backwards. */
4118 old_obj
= SelectObject (hdc
, xpm_mask
->bitmap
);
4120 PatBlt (hdc
, 0, 0, xpm_mask
->width
, xpm_mask
->height
, DSTINVERT
);
4121 SelectObject (hdc
, old_obj
);
4123 img
->mask
= xpm_mask
->bitmap
;
4124 fn_XImageFree (xpm_mask
);
4129 #endif /* HAVE_NTGUI */
4131 /* Remember allocated colors. */
4132 img
->ncolors
= attrs
.nalloc_pixels
;
4133 img
->colors
= (unsigned long *) xmalloc (img
->ncolors
4134 * sizeof *img
->colors
);
4135 for (i
= 0; i
< attrs
.nalloc_pixels
; ++i
)
4137 img
->colors
[i
] = attrs
.alloc_pixels
[i
];
4138 #ifdef DEBUG_X_COLORS
4139 register_color (img
->colors
[i
]);
4142 #endif /* not ALLOC_XPM_COLORS */
4144 img
->width
= attrs
.width
;
4145 img
->height
= attrs
.height
;
4146 xassert (img
->width
> 0 && img
->height
> 0);
4148 /* The call to XpmFreeAttributes below frees attrs.alloc_pixels. */
4150 fn_XpmFreeAttributes (&attrs
);
4152 XpmFreeAttributes (&attrs
);
4153 #endif /* HAVE_NTGUI */
4159 #endif /* HAVE_NTGUI */
4164 image_error ("Error opening XPM file (%s)", img
->spec
, Qnil
);
4167 case XpmFileInvalid
:
4168 image_error ("Invalid XPM file (%s)", img
->spec
, Qnil
);
4172 image_error ("Out of memory (%s)", img
->spec
, Qnil
);
4175 case XpmColorFailed
:
4176 image_error ("Color allocation error (%s)", img
->spec
, Qnil
);
4180 image_error ("Unknown error (%s)", img
->spec
, Qnil
);
4185 #ifdef ALLOC_XPM_COLORS
4186 xpm_free_color_cache ();
4188 return rc
== XpmSuccess
;
4191 #endif /* HAVE_XPM */
4195 /* XPM support functions for Mac OS where libxpm is not available.
4196 Only XPM version 3 (without any extensions) is supported. */
4198 static int xpm_scan
P_ ((const unsigned char **, const unsigned char *,
4199 const unsigned char **, int *));
4200 static Lisp_Object xpm_make_color_table_v
4201 P_ ((void (**) (Lisp_Object
, const unsigned char *, int, Lisp_Object
),
4202 Lisp_Object (**) (Lisp_Object
, const unsigned char *, int)));
4203 static void xpm_put_color_table_v
P_ ((Lisp_Object
, const unsigned char *,
4205 static Lisp_Object xpm_get_color_table_v
P_ ((Lisp_Object
,
4206 const unsigned char *, int));
4207 static Lisp_Object xpm_make_color_table_h
4208 P_ ((void (**) (Lisp_Object
, const unsigned char *, int, Lisp_Object
),
4209 Lisp_Object (**) (Lisp_Object
, const unsigned char *, int)));
4210 static void xpm_put_color_table_h
P_ ((Lisp_Object
, const unsigned char *,
4212 static Lisp_Object xpm_get_color_table_h
P_ ((Lisp_Object
,
4213 const unsigned char *, int));
4214 static int xpm_str_to_color_key
P_ ((const char *));
4215 static int xpm_load_image
P_ ((struct frame
*, struct image
*,
4216 const unsigned char *, const unsigned char *));
4218 /* Tokens returned from xpm_scan. */
4227 /* Scan an XPM data and return a character (< 256) or a token defined
4228 by enum xpm_token above. *S and END are the start (inclusive) and
4229 the end (exclusive) addresses of the data, respectively. Advance
4230 *S while scanning. If token is either XPM_TK_IDENT or
4231 XPM_TK_STRING, *BEG and *LEN are set to the start address and the
4232 length of the corresponding token, respectively. */
4235 xpm_scan (s
, end
, beg
, len
)
4236 const unsigned char **s
, *end
, **beg
;
4243 /* Skip white-space. */
4244 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
4247 /* gnus-pointer.xpm uses '-' in its identifier.
4248 sb-dir-plus.xpm uses '+' in its identifier. */
4249 if (isalpha (c
) || c
== '_' || c
== '-' || c
== '+')
4253 (c
= **s
, isalnum (c
) || c
== '_' || c
== '-' || c
== '+'))
4256 return XPM_TK_IDENT
;
4261 while (*s
< end
&& **s
!= '"')
4266 return XPM_TK_STRING
;
4270 if (*s
< end
&& **s
== '*')
4272 /* C-style comment. */
4276 while (*s
< end
&& *(*s
)++ != '*')
4279 while (*s
< end
&& **s
!= '/');
4293 /* Functions for color table lookup in XPM data. A key is a string
4294 specifying the color of each pixel in XPM data. A value is either
4295 an integer that specifies a pixel color, Qt that specifies
4296 transparency, or Qnil for the unspecified color. If the length of
4297 the key string is one, a vector is used as a table. Otherwise, a
4298 hash table is used. */
4301 xpm_make_color_table_v (put_func
, get_func
)
4302 void (**put_func
) (Lisp_Object
, const unsigned char *, int, Lisp_Object
);
4303 Lisp_Object (**get_func
) (Lisp_Object
, const unsigned char *, int);
4305 *put_func
= xpm_put_color_table_v
;
4306 *get_func
= xpm_get_color_table_v
;
4307 return Fmake_vector (make_number (256), Qnil
);
4311 xpm_put_color_table_v (color_table
, chars_start
, chars_len
, color
)
4312 Lisp_Object color_table
;
4313 const unsigned char *chars_start
;
4317 XVECTOR (color_table
)->contents
[*chars_start
] = color
;
4321 xpm_get_color_table_v (color_table
, chars_start
, chars_len
)
4322 Lisp_Object color_table
;
4323 const unsigned char *chars_start
;
4326 return XVECTOR (color_table
)->contents
[*chars_start
];
4330 xpm_make_color_table_h (put_func
, get_func
)
4331 void (**put_func
) (Lisp_Object
, const unsigned char *, int, Lisp_Object
);
4332 Lisp_Object (**get_func
) (Lisp_Object
, const unsigned char *, int);
4334 *put_func
= xpm_put_color_table_h
;
4335 *get_func
= xpm_get_color_table_h
;
4336 return make_hash_table (Qequal
, make_number (DEFAULT_HASH_SIZE
),
4337 make_float (DEFAULT_REHASH_SIZE
),
4338 make_float (DEFAULT_REHASH_THRESHOLD
),
4343 xpm_put_color_table_h (color_table
, chars_start
, chars_len
, color
)
4344 Lisp_Object color_table
;
4345 const unsigned char *chars_start
;
4349 struct Lisp_Hash_Table
*table
= XHASH_TABLE (color_table
);
4351 Lisp_Object chars
= make_unibyte_string (chars_start
, chars_len
);
4353 hash_lookup (table
, chars
, &hash_code
);
4354 hash_put (table
, chars
, color
, hash_code
);
4358 xpm_get_color_table_h (color_table
, chars_start
, chars_len
)
4359 Lisp_Object color_table
;
4360 const unsigned char *chars_start
;
4363 struct Lisp_Hash_Table
*table
= XHASH_TABLE (color_table
);
4364 int i
= hash_lookup (table
, make_unibyte_string (chars_start
, chars_len
),
4367 return i
>= 0 ? HASH_VALUE (table
, i
) : Qnil
;
4370 enum xpm_color_key
{
4378 static const char xpm_color_key_strings
[][4] = {"s", "m", "g4", "g", "c"};
4381 xpm_str_to_color_key (s
)
4387 i
< sizeof xpm_color_key_strings
/ sizeof xpm_color_key_strings
[0];
4389 if (strcmp (xpm_color_key_strings
[i
], s
) == 0)
4395 xpm_load_image (f
, img
, contents
, end
)
4398 const unsigned char *contents
, *end
;
4400 const unsigned char *s
= contents
, *beg
, *str
;
4401 unsigned char buffer
[BUFSIZ
];
4402 int width
, height
, x
, y
;
4403 int num_colors
, chars_per_pixel
;
4405 void (*put_color_table
) (Lisp_Object
, const unsigned char *, int, Lisp_Object
);
4406 Lisp_Object (*get_color_table
) (Lisp_Object
, const unsigned char *, int);
4407 Lisp_Object frame
, color_symbols
, color_table
;
4408 int best_key
, have_mask
= 0;
4409 XImagePtr ximg
= NULL
, mask_img
= NULL
;
4412 LA1 = xpm_scan (&s, end, &beg, &len)
4414 #define expect(TOKEN) \
4415 if (LA1 != (TOKEN)) \
4420 #define expect_ident(IDENT) \
4421 if (LA1 == XPM_TK_IDENT \
4422 && strlen ((IDENT)) == len && memcmp ((IDENT), beg, len) == 0) \
4427 if (!(end
- s
>= 9 && memcmp (s
, "/* XPM */", 9) == 0))
4431 expect_ident ("static");
4432 expect_ident ("char");
4434 expect (XPM_TK_IDENT
);
4439 expect (XPM_TK_STRING
);
4442 memcpy (buffer
, beg
, len
);
4444 if (sscanf (buffer
, "%d %d %d %d", &width
, &height
,
4445 &num_colors
, &chars_per_pixel
) != 4
4446 || width
<= 0 || height
<= 0
4447 || num_colors
<= 0 || chars_per_pixel
<= 0)
4450 if (!check_image_size (f
, width
, height
))
4452 image_error ("Invalid image size", Qnil
, Qnil
);
4458 XSETFRAME (frame
, f
);
4459 if (!NILP (Fxw_display_color_p (frame
)))
4460 best_key
= XPM_COLOR_KEY_C
;
4461 else if (!NILP (Fx_display_grayscale_p (frame
)))
4462 best_key
= (XFASTINT (Fx_display_planes (frame
)) > 2
4463 ? XPM_COLOR_KEY_G
: XPM_COLOR_KEY_G4
);
4465 best_key
= XPM_COLOR_KEY_M
;
4467 color_symbols
= image_spec_value (img
->spec
, QCcolor_symbols
, NULL
);
4468 if (chars_per_pixel
== 1)
4469 color_table
= xpm_make_color_table_v (&put_color_table
,
4472 color_table
= xpm_make_color_table_h (&put_color_table
,
4475 while (num_colors
-- > 0)
4477 unsigned char *color
, *max_color
;
4478 int key
, next_key
, max_key
= 0;
4479 Lisp_Object symbol_color
= Qnil
, color_val
;
4482 expect (XPM_TK_STRING
);
4483 if (len
<= chars_per_pixel
|| len
>= BUFSIZ
+ chars_per_pixel
)
4485 memcpy (buffer
, beg
+ chars_per_pixel
, len
- chars_per_pixel
);
4486 buffer
[len
- chars_per_pixel
] = '\0';
4488 str
= strtok (buffer
, " \t");
4491 key
= xpm_str_to_color_key (str
);
4496 color
= strtok (NULL
, " \t");
4500 while ((str
= strtok (NULL
, " \t")) != NULL
)
4502 next_key
= xpm_str_to_color_key (str
);
4505 color
[strlen (color
)] = ' ';
4508 if (key
== XPM_COLOR_KEY_S
)
4510 if (NILP (symbol_color
))
4511 symbol_color
= build_string (color
);
4513 else if (max_key
< key
&& key
<= best_key
)
4523 if (!NILP (color_symbols
) && !NILP (symbol_color
))
4525 Lisp_Object specified_color
= Fassoc (symbol_color
, color_symbols
);
4527 if (CONSP (specified_color
) && STRINGP (XCDR (specified_color
)))
4529 if (xstricmp (SDATA (XCDR (specified_color
)), "None") == 0)
4531 else if (x_defined_color (f
, SDATA (XCDR (specified_color
)),
4533 color_val
= make_number (cdef
.pixel
);
4536 if (NILP (color_val
) && max_key
> 0)
4538 if (xstricmp (max_color
, "None") == 0)
4540 else if (x_defined_color (f
, max_color
, &cdef
, 0))
4541 color_val
= make_number (cdef
.pixel
);
4543 if (!NILP (color_val
))
4544 (*put_color_table
) (color_table
, beg
, chars_per_pixel
, color_val
);
4549 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0,
4550 &ximg
, &img
->pixmap
)
4551 || !x_create_x_image_and_pixmap (f
, width
, height
, 1,
4552 &mask_img
, &img
->mask
))
4554 image_error ("Out of memory (%s)", img
->spec
, Qnil
);
4558 for (y
= 0; y
< height
; y
++)
4560 expect (XPM_TK_STRING
);
4562 if (len
< width
* chars_per_pixel
)
4564 for (x
= 0; x
< width
; x
++, str
+= chars_per_pixel
)
4566 Lisp_Object color_val
=
4567 (*get_color_table
) (color_table
, str
, chars_per_pixel
);
4569 XPutPixel (ximg
, x
, y
,
4570 (INTEGERP (color_val
) ? XINT (color_val
)
4571 : FRAME_FOREGROUND_PIXEL (f
)));
4572 XPutPixel (mask_img
, x
, y
,
4573 (!EQ (color_val
, Qt
) ? PIX_MASK_DRAW
4574 : (have_mask
= 1, PIX_MASK_RETAIN
)));
4581 img
->height
= height
;
4583 /* Maybe fill in the background field while we have ximg handy. */
4584 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
4585 IMAGE_BACKGROUND (img
, f
, ximg
);
4587 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
4588 x_destroy_x_image (ximg
);
4591 /* Fill in the background_transparent field while we have the
4593 image_background_transparent (img
, f
, mask_img
);
4595 x_put_x_image (f
, mask_img
, img
->mask
, width
, height
);
4596 x_destroy_x_image (mask_img
);
4600 x_destroy_x_image (mask_img
);
4601 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
4602 img
->mask
= NO_PIXMAP
;
4608 image_error ("Invalid XPM file (%s)", img
->spec
, Qnil
);
4610 x_destroy_x_image (ximg
);
4611 x_destroy_x_image (mask_img
);
4612 x_clear_image (f
, img
);
4626 Lisp_Object file_name
;
4628 /* If IMG->spec specifies a file name, create a non-file spec from it. */
4629 file_name
= image_spec_value (img
->spec
, QCfile
, NULL
);
4630 if (STRINGP (file_name
))
4633 unsigned char *contents
;
4635 struct gcpro gcpro1
;
4637 file
= x_find_image_file (file_name
);
4639 if (!STRINGP (file
))
4641 image_error ("Cannot find image file `%s'", file_name
, Qnil
);
4646 contents
= slurp_file (SDATA (file
), &size
);
4647 if (contents
== NULL
)
4649 image_error ("Error loading XPM image `%s'", img
->spec
, Qnil
);
4654 success_p
= xpm_load_image (f
, img
, contents
, contents
+ size
);
4662 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
4663 success_p
= xpm_load_image (f
, img
, SDATA (data
),
4664 SDATA (data
) + SBYTES (data
));
4674 /***********************************************************************
4676 ***********************************************************************/
4678 #ifdef COLOR_TABLE_SUPPORT
4680 /* An entry in the color table mapping an RGB color to a pixel color. */
4685 unsigned long pixel
;
4687 /* Next in color table collision list. */
4688 struct ct_color
*next
;
4691 /* The bucket vector size to use. Must be prime. */
4695 /* Value is a hash of the RGB color given by R, G, and B. */
4697 #define CT_HASH_RGB(R, G, B) (((R) << 16) ^ ((G) << 8) ^ (B))
4699 /* The color hash table. */
4701 struct ct_color
**ct_table
;
4703 /* Number of entries in the color table. */
4705 int ct_colors_allocated
;
4707 /* Initialize the color table. */
4712 int size
= CT_SIZE
* sizeof (*ct_table
);
4713 ct_table
= (struct ct_color
**) xmalloc (size
);
4714 bzero (ct_table
, size
);
4715 ct_colors_allocated
= 0;
4719 /* Free memory associated with the color table. */
4725 struct ct_color
*p
, *next
;
4727 for (i
= 0; i
< CT_SIZE
; ++i
)
4728 for (p
= ct_table
[i
]; p
; p
= next
)
4739 /* Value is a pixel color for RGB color R, G, B on frame F. If an
4740 entry for that color already is in the color table, return the
4741 pixel color of that entry. Otherwise, allocate a new color for R,
4742 G, B, and make an entry in the color table. */
4744 static unsigned long
4745 lookup_rgb_color (f
, r
, g
, b
)
4749 unsigned hash
= CT_HASH_RGB (r
, g
, b
);
4750 int i
= hash
% CT_SIZE
;
4752 Display_Info
*dpyinfo
;
4754 /* Handle TrueColor visuals specially, which improves performance by
4755 two orders of magnitude. Freeing colors on TrueColor visuals is
4756 a nop, and pixel colors specify RGB values directly. See also
4757 the Xlib spec, chapter 3.1. */
4758 dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
4759 if (dpyinfo
->red_bits
> 0)
4761 unsigned long pr
, pg
, pb
;
4763 /* Apply gamma-correction like normal color allocation does. */
4767 color
.red
= r
, color
.green
= g
, color
.blue
= b
;
4768 gamma_correct (f
, &color
);
4769 r
= color
.red
, g
= color
.green
, b
= color
.blue
;
4772 /* Scale down RGB values to the visual's bits per RGB, and shift
4773 them to the right position in the pixel color. Note that the
4774 original RGB values are 16-bit values, as usual in X. */
4775 pr
= (r
>> (16 - dpyinfo
->red_bits
)) << dpyinfo
->red_offset
;
4776 pg
= (g
>> (16 - dpyinfo
->green_bits
)) << dpyinfo
->green_offset
;
4777 pb
= (b
>> (16 - dpyinfo
->blue_bits
)) << dpyinfo
->blue_offset
;
4779 /* Assemble the pixel color. */
4780 return pr
| pg
| pb
;
4783 for (p
= ct_table
[i
]; p
; p
= p
->next
)
4784 if (p
->r
== r
&& p
->g
== g
&& p
->b
== b
)
4790 #ifdef HAVE_X_WINDOWS
4799 cmap
= FRAME_X_COLORMAP (f
);
4800 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
4803 ++ct_colors_allocated
;
4804 p
= (struct ct_color
*) xmalloc (sizeof *p
);
4808 p
->pixel
= color
.pixel
;
4809 p
->next
= ct_table
[i
];
4813 return FRAME_FOREGROUND_PIXEL (f
);
4818 color
= PALETTERGB (r
, g
, b
);
4820 color
= RGB_TO_ULONG (r
, g
, b
);
4821 #endif /* HAVE_NTGUI */
4822 ++ct_colors_allocated
;
4823 p
= (struct ct_color
*) xmalloc (sizeof *p
);
4828 p
->next
= ct_table
[i
];
4830 #endif /* HAVE_X_WINDOWS */
4838 /* Look up pixel color PIXEL which is used on frame F in the color
4839 table. If not already present, allocate it. Value is PIXEL. */
4841 static unsigned long
4842 lookup_pixel_color (f
, pixel
)
4844 unsigned long pixel
;
4846 int i
= pixel
% CT_SIZE
;
4849 for (p
= ct_table
[i
]; p
; p
= p
->next
)
4850 if (p
->pixel
== pixel
)
4859 #ifdef HAVE_X_WINDOWS
4860 cmap
= FRAME_X_COLORMAP (f
);
4861 color
.pixel
= pixel
;
4862 x_query_color (f
, &color
);
4863 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
4866 cmap
= DefaultColormapOfScreen (FRAME_X_SCREEN (f
));
4867 color
.pixel
= pixel
;
4868 XQueryColor (NULL
, cmap
, &color
);
4869 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
4871 #endif /* HAVE_X_WINDOWS */
4875 ++ct_colors_allocated
;
4877 p
= (struct ct_color
*) xmalloc (sizeof *p
);
4882 p
->next
= ct_table
[i
];
4886 return FRAME_FOREGROUND_PIXEL (f
);
4892 /* Value is a vector of all pixel colors contained in the color table,
4893 allocated via xmalloc. Set *N to the number of colors. */
4895 static unsigned long *
4896 colors_in_color_table (n
)
4901 unsigned long *colors
;
4903 if (ct_colors_allocated
== 0)
4910 colors
= (unsigned long *) xmalloc (ct_colors_allocated
4912 *n
= ct_colors_allocated
;
4914 for (i
= j
= 0; i
< CT_SIZE
; ++i
)
4915 for (p
= ct_table
[i
]; p
; p
= p
->next
)
4916 colors
[j
++] = p
->pixel
;
4922 #else /* COLOR_TABLE_SUPPORT */
4924 static unsigned long
4925 lookup_rgb_color (f
, r
, g
, b
)
4929 unsigned long pixel
;
4932 pixel
= RGB_TO_ULONG (r
>> 8, g
>> 8, b
>> 8);
4933 gamma_correct (f
, &pixel
);
4937 pixel
= PALETTERGB (r
>> 8, g
>> 8, b
>> 8);
4938 #endif /* HAVE_NTGUI */
4947 #endif /* COLOR_TABLE_SUPPORT */
4950 /***********************************************************************
4952 ***********************************************************************/
4954 static XColor
*x_to_xcolors
P_ ((struct frame
*, struct image
*, int));
4955 static void x_from_xcolors
P_ ((struct frame
*, struct image
*, XColor
*));
4956 static void x_detect_edges
P_ ((struct frame
*, struct image
*, int[9], int));
4959 static void XPutPixel (XImagePtr
, int, int, COLORREF
);
4960 #endif /* HAVE_NTGUI */
4962 /* Non-zero means draw a cross on images having `:conversion
4965 int cross_disabled_images
;
4967 /* Edge detection matrices for different edge-detection
4970 static int emboss_matrix
[9] = {
4972 2, -1, 0, /* y - 1 */
4974 0, 1, -2 /* y + 1 */
4977 static int laplace_matrix
[9] = {
4979 1, 0, 0, /* y - 1 */
4981 0, 0, -1 /* y + 1 */
4984 /* Value is the intensity of the color whose red/green/blue values
4987 #define COLOR_INTENSITY(R, G, B) ((2 * (R) + 3 * (G) + (B)) / 6)
4990 /* On frame F, return an array of XColor structures describing image
4991 IMG->pixmap. Each XColor structure has its pixel color set. RGB_P
4992 non-zero means also fill the red/green/blue members of the XColor
4993 structures. Value is a pointer to the array of XColors structures,
4994 allocated with xmalloc; it must be freed by the caller. */
4997 x_to_xcolors (f
, img
, rgb_p
)
5004 XImagePtr_or_DC ximg
;
5008 #endif /* HAVE_NTGUI */
5010 colors
= (XColor
*) xmalloc (img
->width
* img
->height
* sizeof *colors
);
5013 /* Get the X image IMG->pixmap. */
5014 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
5015 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
5017 /* Load the image into a memory device context. */
5018 hdc
= get_frame_dc (f
);
5019 ximg
= CreateCompatibleDC (hdc
);
5020 release_frame_dc (f
, hdc
);
5021 prev
= SelectObject (ximg
, img
->pixmap
);
5022 #endif /* HAVE_NTGUI */
5024 /* Fill the `pixel' members of the XColor array. I wished there
5025 were an easy and portable way to circumvent XGetPixel. */
5027 for (y
= 0; y
< img
->height
; ++y
)
5031 #ifdef HAVE_X_WINDOWS
5032 for (x
= 0; x
< img
->width
; ++x
, ++p
)
5033 p
->pixel
= XGetPixel (ximg
, x
, y
);
5035 x_query_colors (f
, row
, img
->width
);
5039 for (x
= 0; x
< img
->width
; ++x
, ++p
)
5041 /* W32_TODO: palette support needed here? */
5042 p
->pixel
= GET_PIXEL (ximg
, x
, y
);
5046 p
->red
= RED16_FROM_ULONG (p
->pixel
);
5047 p
->green
= GREEN16_FROM_ULONG (p
->pixel
);
5048 p
->blue
= BLUE16_FROM_ULONG (p
->pixel
);
5051 p
->red
= 256 * GetRValue (p
->pixel
);
5052 p
->green
= 256 * GetGValue (p
->pixel
);
5053 p
->blue
= 256 * GetBValue (p
->pixel
);
5054 #endif /* HAVE_NTGUI */
5057 #endif /* HAVE_X_WINDOWS */
5060 Destroy_Image (ximg
, prev
);
5067 /* Put a pixel of COLOR at position X, Y in XIMG. XIMG must have been
5068 created with CreateDIBSection, with the pointer to the bit values
5069 stored in ximg->data. */
5072 XPutPixel (ximg
, x
, y
, color
)
5077 int width
= ximg
->info
.bmiHeader
.biWidth
;
5078 int height
= ximg
->info
.bmiHeader
.biHeight
;
5079 unsigned char * pixel
;
5081 /* True color images. */
5082 if (ximg
->info
.bmiHeader
.biBitCount
== 24)
5084 int rowbytes
= width
* 3;
5085 /* Ensure scanlines are aligned on 4 byte boundaries. */
5087 rowbytes
+= 4 - (rowbytes
% 4);
5089 pixel
= ximg
->data
+ y
* rowbytes
+ x
* 3;
5090 /* Windows bitmaps are in BGR order. */
5091 *pixel
= GetBValue (color
);
5092 *(pixel
+ 1) = GetGValue (color
);
5093 *(pixel
+ 2) = GetRValue (color
);
5095 /* Monochrome images. */
5096 else if (ximg
->info
.bmiHeader
.biBitCount
== 1)
5098 int rowbytes
= width
/ 8;
5099 /* Ensure scanlines are aligned on 4 byte boundaries. */
5101 rowbytes
+= 4 - (rowbytes
% 4);
5102 pixel
= ximg
->data
+ y
* rowbytes
+ x
/ 8;
5103 /* Filter out palette info. */
5104 if (color
& 0x00ffffff)
5105 *pixel
= *pixel
| (1 << x
% 8);
5107 *pixel
= *pixel
& ~(1 << x
% 8);
5110 image_error ("XPutPixel: palette image not supported", Qnil
, Qnil
);
5113 #endif /* HAVE_NTGUI */
5115 /* Create IMG->pixmap from an array COLORS of XColor structures, whose
5116 RGB members are set. F is the frame on which this all happens.
5117 COLORS will be freed; an existing IMG->pixmap will be freed, too. */
5120 x_from_xcolors (f
, img
, colors
)
5130 init_color_table ();
5132 x_create_x_image_and_pixmap (f
, img
->width
, img
->height
, 0,
5135 for (y
= 0; y
< img
->height
; ++y
)
5136 for (x
= 0; x
< img
->width
; ++x
, ++p
)
5138 unsigned long pixel
;
5139 pixel
= lookup_rgb_color (f
, p
->red
, p
->green
, p
->blue
);
5140 XPutPixel (oimg
, x
, y
, pixel
);
5144 x_clear_image_1 (f
, img
, 1, 0, 1);
5146 x_put_x_image (f
, oimg
, pixmap
, img
->width
, img
->height
);
5147 x_destroy_x_image (oimg
);
5148 img
->pixmap
= pixmap
;
5149 #ifdef COLOR_TABLE_SUPPORT
5150 img
->colors
= colors_in_color_table (&img
->ncolors
);
5151 free_color_table ();
5152 #endif /* COLOR_TABLE_SUPPORT */
5156 /* On frame F, perform edge-detection on image IMG.
5158 MATRIX is a nine-element array specifying the transformation
5159 matrix. See emboss_matrix for an example.
5161 COLOR_ADJUST is a color adjustment added to each pixel of the
5165 x_detect_edges (f
, img
, matrix
, color_adjust
)
5168 int matrix
[9], color_adjust
;
5170 XColor
*colors
= x_to_xcolors (f
, img
, 1);
5174 for (i
= sum
= 0; i
< 9; ++i
)
5175 sum
+= abs (matrix
[i
]);
5177 #define COLOR(A, X, Y) ((A) + (Y) * img->width + (X))
5179 new = (XColor
*) xmalloc (img
->width
* img
->height
* sizeof *new);
5181 for (y
= 0; y
< img
->height
; ++y
)
5183 p
= COLOR (new, 0, y
);
5184 p
->red
= p
->green
= p
->blue
= 0xffff/2;
5185 p
= COLOR (new, img
->width
- 1, y
);
5186 p
->red
= p
->green
= p
->blue
= 0xffff/2;
5189 for (x
= 1; x
< img
->width
- 1; ++x
)
5191 p
= COLOR (new, x
, 0);
5192 p
->red
= p
->green
= p
->blue
= 0xffff/2;
5193 p
= COLOR (new, x
, img
->height
- 1);
5194 p
->red
= p
->green
= p
->blue
= 0xffff/2;
5197 for (y
= 1; y
< img
->height
- 1; ++y
)
5199 p
= COLOR (new, 1, y
);
5201 for (x
= 1; x
< img
->width
- 1; ++x
, ++p
)
5203 int r
, g
, b
, y1
, x1
;
5206 for (y1
= y
- 1; y1
< y
+ 2; ++y1
)
5207 for (x1
= x
- 1; x1
< x
+ 2; ++x1
, ++i
)
5210 XColor
*t
= COLOR (colors
, x1
, y1
);
5211 r
+= matrix
[i
] * t
->red
;
5212 g
+= matrix
[i
] * t
->green
;
5213 b
+= matrix
[i
] * t
->blue
;
5216 r
= (r
/ sum
+ color_adjust
) & 0xffff;
5217 g
= (g
/ sum
+ color_adjust
) & 0xffff;
5218 b
= (b
/ sum
+ color_adjust
) & 0xffff;
5219 p
->red
= p
->green
= p
->blue
= COLOR_INTENSITY (r
, g
, b
);
5224 x_from_xcolors (f
, img
, new);
5230 /* Perform the pre-defined `emboss' edge-detection on image IMG
5238 x_detect_edges (f
, img
, emboss_matrix
, 0xffff / 2);
5242 /* Transform image IMG which is used on frame F with a Laplace
5243 edge-detection algorithm. The result is an image that can be used
5244 to draw disabled buttons, for example. */
5251 x_detect_edges (f
, img
, laplace_matrix
, 45000);
5255 /* Perform edge-detection on image IMG on frame F, with specified
5256 transformation matrix MATRIX and color-adjustment COLOR_ADJUST.
5258 MATRIX must be either
5260 - a list of at least 9 numbers in row-major form
5261 - a vector of at least 9 numbers
5263 COLOR_ADJUST nil means use a default; otherwise it must be a
5267 x_edge_detection (f
, img
, matrix
, color_adjust
)
5270 Lisp_Object matrix
, color_adjust
;
5278 i
< 9 && CONSP (matrix
) && NUMBERP (XCAR (matrix
));
5279 ++i
, matrix
= XCDR (matrix
))
5280 trans
[i
] = XFLOATINT (XCAR (matrix
));
5282 else if (VECTORP (matrix
) && ASIZE (matrix
) >= 9)
5284 for (i
= 0; i
< 9 && NUMBERP (AREF (matrix
, i
)); ++i
)
5285 trans
[i
] = XFLOATINT (AREF (matrix
, i
));
5288 if (NILP (color_adjust
))
5289 color_adjust
= make_number (0xffff / 2);
5291 if (i
== 9 && NUMBERP (color_adjust
))
5292 x_detect_edges (f
, img
, trans
, (int) XFLOATINT (color_adjust
));
5296 /* Transform image IMG on frame F so that it looks disabled. */
5299 x_disable_image (f
, img
)
5303 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
5305 int n_planes
= dpyinfo
->n_planes
* dpyinfo
->n_cbits
;
5307 int n_planes
= dpyinfo
->n_planes
;
5308 #endif /* HAVE_NTGUI */
5312 /* Color (or grayscale). Convert to gray, and equalize. Just
5313 drawing such images with a stipple can look very odd, so
5314 we're using this method instead. */
5315 XColor
*colors
= x_to_xcolors (f
, img
, 1);
5317 const int h
= 15000;
5318 const int l
= 30000;
5320 for (p
= colors
, end
= colors
+ img
->width
* img
->height
;
5324 int i
= COLOR_INTENSITY (p
->red
, p
->green
, p
->blue
);
5325 int i2
= (0xffff - h
- l
) * i
/ 0xffff + l
;
5326 p
->red
= p
->green
= p
->blue
= i2
;
5329 x_from_xcolors (f
, img
, colors
);
5332 /* Draw a cross over the disabled image, if we must or if we
5334 if (n_planes
< 2 || cross_disabled_images
)
5337 Display
*dpy
= FRAME_X_DISPLAY (f
);
5341 #define MaskForeground(f) PIX_MASK_DRAW
5343 #define MaskForeground(f) WHITE_PIX_DEFAULT (f)
5346 gc
= XCreateGC (dpy
, img
->pixmap
, 0, NULL
);
5347 XSetForeground (dpy
, gc
, BLACK_PIX_DEFAULT (f
));
5348 XDrawLine (dpy
, img
->pixmap
, gc
, 0, 0,
5349 img
->width
- 1, img
->height
- 1);
5350 XDrawLine (dpy
, img
->pixmap
, gc
, 0, img
->height
- 1,
5356 gc
= XCreateGC (dpy
, img
->mask
, 0, NULL
);
5357 XSetForeground (dpy
, gc
, MaskForeground (f
));
5358 XDrawLine (dpy
, img
->mask
, gc
, 0, 0,
5359 img
->width
- 1, img
->height
- 1);
5360 XDrawLine (dpy
, img
->mask
, gc
, 0, img
->height
- 1,
5368 hdc
= get_frame_dc (f
);
5369 bmpdc
= CreateCompatibleDC (hdc
);
5370 release_frame_dc (f
, hdc
);
5372 prev
= SelectObject (bmpdc
, img
->pixmap
);
5374 SetTextColor (bmpdc
, BLACK_PIX_DEFAULT (f
));
5375 MoveToEx (bmpdc
, 0, 0, NULL
);
5376 LineTo (bmpdc
, img
->width
- 1, img
->height
- 1);
5377 MoveToEx (bmpdc
, 0, img
->height
- 1, NULL
);
5378 LineTo (bmpdc
, img
->width
- 1, 0);
5382 SelectObject (bmpdc
, img
->mask
);
5383 SetTextColor (bmpdc
, WHITE_PIX_DEFAULT (f
));
5384 MoveToEx (bmpdc
, 0, 0, NULL
);
5385 LineTo (bmpdc
, img
->width
- 1, img
->height
- 1);
5386 MoveToEx (bmpdc
, 0, img
->height
- 1, NULL
);
5387 LineTo (bmpdc
, img
->width
- 1, 0);
5389 SelectObject (bmpdc
, prev
);
5391 #endif /* HAVE_NTGUI */
5396 /* Build a mask for image IMG which is used on frame F. FILE is the
5397 name of an image file, for error messages. HOW determines how to
5398 determine the background color of IMG. If it is a list '(R G B)',
5399 with R, G, and B being integers >= 0, take that as the color of the
5400 background. Otherwise, determine the background color of IMG
5401 heuristically. Value is non-zero if successful. */
5404 x_build_heuristic_mask (f
, img
, how
)
5409 XImagePtr_or_DC ximg
;
5417 #endif /* HAVE_NTGUI */
5418 int x
, y
, rc
, use_img_background
;
5419 unsigned long bg
= 0;
5423 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
5424 img
->mask
= NO_PIXMAP
;
5425 img
->background_transparent_valid
= 0;
5429 /* Create an image and pixmap serving as mask. */
5430 rc
= x_create_x_image_and_pixmap (f
, img
->width
, img
->height
, 1,
5431 &mask_img
, &img
->mask
);
5435 /* Get the X image of IMG->pixmap. */
5436 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
, 0, 0,
5437 img
->width
, img
->height
,
5440 /* Create the bit array serving as mask. */
5441 row_width
= (img
->width
+ 7) / 8;
5442 mask_img
= xmalloc (row_width
* img
->height
);
5443 bzero (mask_img
, row_width
* img
->height
);
5445 /* Create a memory device context for IMG->pixmap. */
5446 frame_dc
= get_frame_dc (f
);
5447 ximg
= CreateCompatibleDC (frame_dc
);
5448 release_frame_dc (f
, frame_dc
);
5449 prev
= SelectObject (ximg
, img
->pixmap
);
5450 #endif /* HAVE_NTGUI */
5452 /* Determine the background color of ximg. If HOW is `(R G B)'
5453 take that as color. Otherwise, use the image's background color. */
5454 use_img_background
= 1;
5460 for (i
= 0; i
< 3 && CONSP (how
) && NATNUMP (XCAR (how
)); ++i
)
5462 rgb
[i
] = XFASTINT (XCAR (how
)) & 0xffff;
5466 if (i
== 3 && NILP (how
))
5468 char color_name
[30];
5469 sprintf (color_name
, "#%04x%04x%04x", rgb
[0], rgb
[1], rgb
[2]);
5472 0x00ffffff & /* Filter out palette info. */
5473 #endif /* HAVE_NTGUI */
5474 x_alloc_image_color (f
, img
, build_string (color_name
), 0));
5475 use_img_background
= 0;
5479 if (use_img_background
)
5480 bg
= four_corners_best (ximg
, img
->corners
, img
->width
, img
->height
);
5482 /* Set all bits in mask_img to 1 whose color in ximg is different
5483 from the background color bg. */
5485 for (y
= 0; y
< img
->height
; ++y
)
5486 for (x
= 0; x
< img
->width
; ++x
)
5487 XPutPixel (mask_img
, x
, y
, (XGetPixel (ximg
, x
, y
) != bg
5488 ? PIX_MASK_DRAW
: PIX_MASK_RETAIN
));
5490 /* Fill in the background_transparent field while we have the mask handy. */
5491 image_background_transparent (img
, f
, mask_img
);
5493 /* Put mask_img into img->mask. */
5494 x_put_x_image (f
, mask_img
, img
->mask
, img
->width
, img
->height
);
5495 x_destroy_x_image (mask_img
);
5498 for (y
= 0; y
< img
->height
; ++y
)
5499 for (x
= 0; x
< img
->width
; ++x
)
5501 COLORREF p
= GetPixel (ximg
, x
, y
);
5503 mask_img
[y
* row_width
+ x
/ 8] |= 1 << (x
% 8);
5506 /* Create the mask image. */
5507 img
->mask
= w32_create_pixmap_from_bitmap_data (img
->width
, img
->height
,
5509 /* Fill in the background_transparent field while we have the mask handy. */
5510 SelectObject (ximg
, img
->mask
);
5511 image_background_transparent (img
, f
, ximg
);
5513 /* Was: x_destroy_x_image ((XImagePtr )mask_img); which seems bogus ++kfs */
5515 #endif /* HAVE_NTGUI */
5517 Destroy_Image (ximg
, prev
);
5523 /***********************************************************************
5524 PBM (mono, gray, color)
5525 ***********************************************************************/
5527 static int pbm_image_p
P_ ((Lisp_Object object
));
5528 static int pbm_load
P_ ((struct frame
*f
, struct image
*img
));
5529 static int pbm_scan_number
P_ ((unsigned char **, unsigned char *));
5531 /* The symbol `pbm' identifying images of this type. */
5535 /* Indices of image specification fields in gs_format, below. */
5537 enum pbm_keyword_index
5553 /* Vector of image_keyword structures describing the format
5554 of valid user-defined image specifications. */
5556 static struct image_keyword pbm_format
[PBM_LAST
] =
5558 {":type", IMAGE_SYMBOL_VALUE
, 1},
5559 {":file", IMAGE_STRING_VALUE
, 0},
5560 {":data", IMAGE_STRING_VALUE
, 0},
5561 {":ascent", IMAGE_ASCENT_VALUE
, 0},
5562 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
5563 {":relief", IMAGE_INTEGER_VALUE
, 0},
5564 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5565 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5566 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5567 {":foreground", IMAGE_STRING_OR_NIL_VALUE
, 0},
5568 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
5571 /* Structure describing the image type `pbm'. */
5573 static struct image_type pbm_type
=
5583 /* Return non-zero if OBJECT is a valid PBM image specification. */
5586 pbm_image_p (object
)
5589 struct image_keyword fmt
[PBM_LAST
];
5591 bcopy (pbm_format
, fmt
, sizeof fmt
);
5593 if (!parse_image_spec (object
, fmt
, PBM_LAST
, Qpbm
))
5596 /* Must specify either :data or :file. */
5597 return fmt
[PBM_DATA
].count
+ fmt
[PBM_FILE
].count
== 1;
5601 /* Scan a decimal number from *S and return it. Advance *S while
5602 reading the number. END is the end of the string. Value is -1 at
5606 pbm_scan_number (s
, end
)
5607 unsigned char **s
, *end
;
5609 int c
= 0, val
= -1;
5613 /* Skip white-space. */
5614 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
5619 /* Skip comment to end of line. */
5620 while (*s
< end
&& (c
= *(*s
)++, c
!= '\n'))
5623 else if (isdigit (c
))
5625 /* Read decimal number. */
5627 while (*s
< end
&& (c
= *(*s
)++, isdigit (c
)))
5628 val
= 10 * val
+ c
- '0';
5640 #if 0 /* Unused. ++kfs */
5642 /* Read FILE into memory. Value is a pointer to a buffer allocated
5643 with xmalloc holding FILE's contents. Value is null if an error
5644 occurred. *SIZE is set to the size of the file. */
5647 pbm_read_file (file
, size
)
5655 if (stat (SDATA (file
), &st
) == 0
5656 && (fp
= fopen (SDATA (file
), "rb")) != NULL
5657 && (buf
= (char *) xmalloc (st
.st_size
),
5658 fread (buf
, 1, st
.st_size
, fp
) == st
.st_size
))
5677 #endif /* HAVE_NTGUI */
5679 /* Load PBM image IMG for use on frame F. */
5687 int width
, height
, max_color_idx
= 0;
5689 Lisp_Object file
, specified_file
;
5690 enum {PBM_MONO
, PBM_GRAY
, PBM_COLOR
} type
;
5691 struct gcpro gcpro1
;
5692 unsigned char *contents
= NULL
;
5693 unsigned char *end
, *p
;
5696 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
5700 if (STRINGP (specified_file
))
5702 file
= x_find_image_file (specified_file
);
5703 if (!STRINGP (file
))
5705 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
5710 contents
= slurp_file (SDATA (file
), &size
);
5711 if (contents
== NULL
)
5713 image_error ("Error reading `%s'", file
, Qnil
);
5719 end
= contents
+ size
;
5724 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
5726 end
= p
+ SBYTES (data
);
5729 /* Check magic number. */
5730 if (end
- p
< 2 || *p
++ != 'P')
5732 image_error ("Not a PBM image: `%s'", img
->spec
, Qnil
);
5742 raw_p
= 0, type
= PBM_MONO
;
5746 raw_p
= 0, type
= PBM_GRAY
;
5750 raw_p
= 0, type
= PBM_COLOR
;
5754 raw_p
= 1, type
= PBM_MONO
;
5758 raw_p
= 1, type
= PBM_GRAY
;
5762 raw_p
= 1, type
= PBM_COLOR
;
5766 image_error ("Not a PBM image: `%s'", img
->spec
, Qnil
);
5770 /* Read width, height, maximum color-component. Characters
5771 starting with `#' up to the end of a line are ignored. */
5772 width
= pbm_scan_number (&p
, end
);
5773 height
= pbm_scan_number (&p
, end
);
5775 if (type
!= PBM_MONO
)
5777 max_color_idx
= pbm_scan_number (&p
, end
);
5778 if (raw_p
&& max_color_idx
> 255)
5779 max_color_idx
= 255;
5782 if (!check_image_size (f
, width
, height
)
5783 || (type
!= PBM_MONO
&& max_color_idx
< 0))
5786 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0,
5787 &ximg
, &img
->pixmap
))
5790 /* Initialize the color hash table. */
5791 init_color_table ();
5793 if (type
== PBM_MONO
)
5796 struct image_keyword fmt
[PBM_LAST
];
5797 unsigned long fg
= FRAME_FOREGROUND_PIXEL (f
);
5798 unsigned long bg
= FRAME_BACKGROUND_PIXEL (f
);
5800 /* Parse the image specification. */
5801 bcopy (pbm_format
, fmt
, sizeof fmt
);
5802 parse_image_spec (img
->spec
, fmt
, PBM_LAST
, Qpbm
);
5804 /* Get foreground and background colors, maybe allocate colors. */
5805 if (fmt
[PBM_FOREGROUND
].count
5806 && STRINGP (fmt
[PBM_FOREGROUND
].value
))
5807 fg
= x_alloc_image_color (f
, img
, fmt
[PBM_FOREGROUND
].value
, fg
);
5808 if (fmt
[PBM_BACKGROUND
].count
5809 && STRINGP (fmt
[PBM_BACKGROUND
].value
))
5811 bg
= x_alloc_image_color (f
, img
, fmt
[PBM_BACKGROUND
].value
, bg
);
5812 img
->background
= bg
;
5813 img
->background_valid
= 1;
5816 for (y
= 0; y
< height
; ++y
)
5817 for (x
= 0; x
< width
; ++x
)
5825 x_destroy_x_image (ximg
);
5826 x_clear_image (f
, img
);
5827 image_error ("Invalid image size in image `%s'",
5837 g
= pbm_scan_number (&p
, end
);
5839 XPutPixel (ximg
, x
, y
, g
? fg
: bg
);
5845 && ((type
== PBM_GRAY
)
5846 ? (p
+ height
* width
> end
)
5847 : (p
+ 3 * height
* width
> end
)))
5849 x_destroy_x_image (ximg
);
5850 x_clear_image (f
, img
);
5851 image_error ("Invalid image size in image `%s'",
5856 for (y
= 0; y
< height
; ++y
)
5857 for (x
= 0; x
< width
; ++x
)
5861 if (type
== PBM_GRAY
)
5862 r
= g
= b
= raw_p
? *p
++ : pbm_scan_number (&p
, end
);
5871 r
= pbm_scan_number (&p
, end
);
5872 g
= pbm_scan_number (&p
, end
);
5873 b
= pbm_scan_number (&p
, end
);
5876 if (r
< 0 || g
< 0 || b
< 0)
5878 x_destroy_x_image (ximg
);
5879 image_error ("Invalid pixel value in image `%s'",
5884 /* RGB values are now in the range 0..max_color_idx.
5885 Scale this to the range 0..0xffff supported by X. */
5886 r
= (double) r
* 65535 / max_color_idx
;
5887 g
= (double) g
* 65535 / max_color_idx
;
5888 b
= (double) b
* 65535 / max_color_idx
;
5889 XPutPixel (ximg
, x
, y
, lookup_rgb_color (f
, r
, g
, b
));
5893 #ifdef COLOR_TABLE_SUPPORT
5894 /* Store in IMG->colors the colors allocated for the image, and
5895 free the color table. */
5896 img
->colors
= colors_in_color_table (&img
->ncolors
);
5897 free_color_table ();
5898 #endif /* COLOR_TABLE_SUPPORT */
5901 img
->height
= height
;
5903 /* Maybe fill in the background field while we have ximg handy. */
5905 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
5906 /* Casting avoids a GCC warning. */
5907 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
5909 /* Put the image into a pixmap. */
5910 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
5911 x_destroy_x_image (ximg
);
5913 /* X and W32 versions did it here, MAC version above. ++kfs
5915 img->height = height; */
5923 /***********************************************************************
5925 ***********************************************************************/
5927 #if defined (HAVE_PNG) || defined (MAC_OS)
5929 /* Function prototypes. */
5931 static int png_image_p
P_ ((Lisp_Object object
));
5932 static int png_load
P_ ((struct frame
*f
, struct image
*img
));
5934 /* The symbol `png' identifying images of this type. */
5938 /* Indices of image specification fields in png_format, below. */
5940 enum png_keyword_index
5955 /* Vector of image_keyword structures describing the format
5956 of valid user-defined image specifications. */
5958 static struct image_keyword png_format
[PNG_LAST
] =
5960 {":type", IMAGE_SYMBOL_VALUE
, 1},
5961 {":data", IMAGE_STRING_VALUE
, 0},
5962 {":file", IMAGE_STRING_VALUE
, 0},
5963 {":ascent", IMAGE_ASCENT_VALUE
, 0},
5964 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
5965 {":relief", IMAGE_INTEGER_VALUE
, 0},
5966 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5967 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5968 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5969 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
5972 /* Structure describing the image type `png'. */
5974 static struct image_type png_type
=
5983 /* Return non-zero if OBJECT is a valid PNG image specification. */
5986 png_image_p (object
)
5989 struct image_keyword fmt
[PNG_LAST
];
5990 bcopy (png_format
, fmt
, sizeof fmt
);
5992 if (!parse_image_spec (object
, fmt
, PNG_LAST
, Qpng
))
5995 /* Must specify either the :data or :file keyword. */
5996 return fmt
[PNG_FILE
].count
+ fmt
[PNG_DATA
].count
== 1;
5999 #endif /* HAVE_PNG || MAC_OS */
6004 #if defined HAVE_LIBPNG_PNG_H
6005 # include <libpng/png.h>
6011 /* PNG library details. */
6013 DEF_IMGLIB_FN (png_get_io_ptr
);
6014 DEF_IMGLIB_FN (png_check_sig
);
6015 DEF_IMGLIB_FN (png_create_read_struct
);
6016 DEF_IMGLIB_FN (png_create_info_struct
);
6017 DEF_IMGLIB_FN (png_destroy_read_struct
);
6018 DEF_IMGLIB_FN (png_set_read_fn
);
6019 DEF_IMGLIB_FN (png_set_sig_bytes
);
6020 DEF_IMGLIB_FN (png_read_info
);
6021 DEF_IMGLIB_FN (png_get_IHDR
);
6022 DEF_IMGLIB_FN (png_get_valid
);
6023 DEF_IMGLIB_FN (png_set_strip_16
);
6024 DEF_IMGLIB_FN (png_set_expand
);
6025 DEF_IMGLIB_FN (png_set_gray_to_rgb
);
6026 DEF_IMGLIB_FN (png_set_background
);
6027 DEF_IMGLIB_FN (png_get_bKGD
);
6028 DEF_IMGLIB_FN (png_read_update_info
);
6029 DEF_IMGLIB_FN (png_get_channels
);
6030 DEF_IMGLIB_FN (png_get_rowbytes
);
6031 DEF_IMGLIB_FN (png_read_image
);
6032 DEF_IMGLIB_FN (png_read_end
);
6033 DEF_IMGLIB_FN (png_error
);
6036 init_png_functions (Lisp_Object libraries
)
6040 /* Try loading libpng under probable names. */
6041 if (!(library
= w32_delayed_load (libraries
, Qpng
)))
6044 LOAD_IMGLIB_FN (library
, png_get_io_ptr
);
6045 LOAD_IMGLIB_FN (library
, png_check_sig
);
6046 LOAD_IMGLIB_FN (library
, png_create_read_struct
);
6047 LOAD_IMGLIB_FN (library
, png_create_info_struct
);
6048 LOAD_IMGLIB_FN (library
, png_destroy_read_struct
);
6049 LOAD_IMGLIB_FN (library
, png_set_read_fn
);
6050 LOAD_IMGLIB_FN (library
, png_set_sig_bytes
);
6051 LOAD_IMGLIB_FN (library
, png_read_info
);
6052 LOAD_IMGLIB_FN (library
, png_get_IHDR
);
6053 LOAD_IMGLIB_FN (library
, png_get_valid
);
6054 LOAD_IMGLIB_FN (library
, png_set_strip_16
);
6055 LOAD_IMGLIB_FN (library
, png_set_expand
);
6056 LOAD_IMGLIB_FN (library
, png_set_gray_to_rgb
);
6057 LOAD_IMGLIB_FN (library
, png_set_background
);
6058 LOAD_IMGLIB_FN (library
, png_get_bKGD
);
6059 LOAD_IMGLIB_FN (library
, png_read_update_info
);
6060 LOAD_IMGLIB_FN (library
, png_get_channels
);
6061 LOAD_IMGLIB_FN (library
, png_get_rowbytes
);
6062 LOAD_IMGLIB_FN (library
, png_read_image
);
6063 LOAD_IMGLIB_FN (library
, png_read_end
);
6064 LOAD_IMGLIB_FN (library
, png_error
);
6069 #define fn_png_get_io_ptr png_get_io_ptr
6070 #define fn_png_check_sig png_check_sig
6071 #define fn_png_create_read_struct png_create_read_struct
6072 #define fn_png_create_info_struct png_create_info_struct
6073 #define fn_png_destroy_read_struct png_destroy_read_struct
6074 #define fn_png_set_read_fn png_set_read_fn
6075 #define fn_png_set_sig_bytes png_set_sig_bytes
6076 #define fn_png_read_info png_read_info
6077 #define fn_png_get_IHDR png_get_IHDR
6078 #define fn_png_get_valid png_get_valid
6079 #define fn_png_set_strip_16 png_set_strip_16
6080 #define fn_png_set_expand png_set_expand
6081 #define fn_png_set_gray_to_rgb png_set_gray_to_rgb
6082 #define fn_png_set_background png_set_background
6083 #define fn_png_get_bKGD png_get_bKGD
6084 #define fn_png_read_update_info png_read_update_info
6085 #define fn_png_get_channels png_get_channels
6086 #define fn_png_get_rowbytes png_get_rowbytes
6087 #define fn_png_read_image png_read_image
6088 #define fn_png_read_end png_read_end
6089 #define fn_png_error png_error
6091 #endif /* HAVE_NTGUI */
6093 /* Error and warning handlers installed when the PNG library
6097 my_png_error (png_ptr
, msg
)
6098 png_struct
*png_ptr
;
6101 xassert (png_ptr
!= NULL
);
6102 image_error ("PNG error: %s", build_string (msg
), Qnil
);
6103 longjmp (png_ptr
->jmpbuf
, 1);
6108 my_png_warning (png_ptr
, msg
)
6109 png_struct
*png_ptr
;
6112 xassert (png_ptr
!= NULL
);
6113 image_error ("PNG warning: %s", build_string (msg
), Qnil
);
6116 /* Memory source for PNG decoding. */
6118 struct png_memory_storage
6120 unsigned char *bytes
; /* The data */
6121 size_t len
; /* How big is it? */
6122 int index
; /* Where are we? */
6126 /* Function set as reader function when reading PNG image from memory.
6127 PNG_PTR is a pointer to the PNG control structure. Copy LENGTH
6128 bytes from the input to DATA. */
6131 png_read_from_memory (png_ptr
, data
, length
)
6132 png_structp png_ptr
;
6136 struct png_memory_storage
*tbr
6137 = (struct png_memory_storage
*) fn_png_get_io_ptr (png_ptr
);
6139 if (length
> tbr
->len
- tbr
->index
)
6140 fn_png_error (png_ptr
, "Read error");
6142 bcopy (tbr
->bytes
+ tbr
->index
, data
, length
);
6143 tbr
->index
= tbr
->index
+ length
;
6147 /* Function set as reader function when reading PNG image from a file.
6148 PNG_PTR is a pointer to the PNG control structure. Copy LENGTH
6149 bytes from the input to DATA. */
6152 png_read_from_file (png_ptr
, data
, length
)
6153 png_structp png_ptr
;
6157 FILE *fp
= (FILE *) fn_png_get_io_ptr (png_ptr
);
6159 if (fread (data
, 1, length
, fp
) < length
)
6160 fn_png_error (png_ptr
, "Read error");
6164 /* Load PNG image IMG for use on frame F. Value is non-zero if
6172 Lisp_Object file
, specified_file
;
6173 Lisp_Object specified_data
;
6175 XImagePtr ximg
, mask_img
= NULL
;
6176 struct gcpro gcpro1
;
6177 png_struct
*png_ptr
= NULL
;
6178 png_info
*info_ptr
= NULL
, *end_info
= NULL
;
6179 FILE *volatile fp
= NULL
;
6181 png_byte
* volatile pixels
= NULL
;
6182 png_byte
** volatile rows
= NULL
;
6183 png_uint_32 width
, height
;
6184 int bit_depth
, color_type
, interlace_type
;
6186 png_uint_32 row_bytes
;
6188 double screen_gamma
;
6189 struct png_memory_storage tbr
; /* Data to be read */
6191 /* Find out what file to load. */
6192 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
6193 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
6197 if (NILP (specified_data
))
6199 file
= x_find_image_file (specified_file
);
6200 if (!STRINGP (file
))
6202 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
6207 /* Open the image file. */
6208 fp
= fopen (SDATA (file
), "rb");
6211 image_error ("Cannot open image file `%s'", file
, Qnil
);
6216 /* Check PNG signature. */
6217 if (fread (sig
, 1, sizeof sig
, fp
) != sizeof sig
6218 || !fn_png_check_sig (sig
, sizeof sig
))
6220 image_error ("Not a PNG file: `%s'", file
, Qnil
);
6228 /* Read from memory. */
6229 tbr
.bytes
= SDATA (specified_data
);
6230 tbr
.len
= SBYTES (specified_data
);
6233 /* Check PNG signature. */
6234 if (tbr
.len
< sizeof sig
6235 || !fn_png_check_sig (tbr
.bytes
, sizeof sig
))
6237 image_error ("Not a PNG image: `%s'", img
->spec
, Qnil
);
6242 /* Need to skip past the signature. */
6243 tbr
.bytes
+= sizeof (sig
);
6246 /* Initialize read and info structs for PNG lib. Casting return
6247 value avoids a GCC warning on W32. */
6248 png_ptr
= (png_structp
)fn_png_create_read_struct (PNG_LIBPNG_VER_STRING
,
6253 if (fp
) fclose (fp
);
6258 /* Casting return value avoids a GCC warning on W32. */
6259 info_ptr
= (png_infop
)fn_png_create_info_struct (png_ptr
);
6262 fn_png_destroy_read_struct (&png_ptr
, NULL
, NULL
);
6263 if (fp
) fclose (fp
);
6268 /* Casting return value avoids a GCC warning on W32. */
6269 end_info
= (png_infop
)fn_png_create_info_struct (png_ptr
);
6272 fn_png_destroy_read_struct (&png_ptr
, &info_ptr
, NULL
);
6273 if (fp
) fclose (fp
);
6278 /* Set error jump-back. We come back here when the PNG library
6279 detects an error. */
6280 if (setjmp (png_ptr
->jmpbuf
))
6284 fn_png_destroy_read_struct (&png_ptr
, &info_ptr
, &end_info
);
6287 if (fp
) fclose (fp
);
6292 /* Read image info. */
6293 if (!NILP (specified_data
))
6294 fn_png_set_read_fn (png_ptr
, (void *) &tbr
, png_read_from_memory
);
6296 fn_png_set_read_fn (png_ptr
, (void *) fp
, png_read_from_file
);
6298 fn_png_set_sig_bytes (png_ptr
, sizeof sig
);
6299 fn_png_read_info (png_ptr
, info_ptr
);
6300 fn_png_get_IHDR (png_ptr
, info_ptr
, &width
, &height
, &bit_depth
, &color_type
,
6301 &interlace_type
, NULL
, NULL
);
6303 if (!check_image_size (f
, width
, height
))
6306 /* If image contains simply transparency data, we prefer to
6307 construct a clipping mask. */
6308 if (fn_png_get_valid (png_ptr
, info_ptr
, PNG_INFO_tRNS
))
6313 /* This function is easier to write if we only have to handle
6314 one data format: RGB or RGBA with 8 bits per channel. Let's
6315 transform other formats into that format. */
6317 /* Strip more than 8 bits per channel. */
6318 if (bit_depth
== 16)
6319 fn_png_set_strip_16 (png_ptr
);
6321 /* Expand data to 24 bit RGB, or 8 bit grayscale, with alpha channel
6323 fn_png_set_expand (png_ptr
);
6325 /* Convert grayscale images to RGB. */
6326 if (color_type
== PNG_COLOR_TYPE_GRAY
6327 || color_type
== PNG_COLOR_TYPE_GRAY_ALPHA
)
6328 fn_png_set_gray_to_rgb (png_ptr
);
6330 screen_gamma
= (f
->gamma
? 1 / f
->gamma
/ 0.45455 : 2.2);
6332 #if 0 /* Avoid double gamma correction for PNG images. */
6333 { /* Tell the PNG lib to handle gamma correction for us. */
6336 #if defined(PNG_READ_sRGB_SUPPORTED) || defined(PNG_WRITE_sRGB_SUPPORTED)
6337 if (png_get_sRGB (png_ptr
, info_ptr
, &intent
))
6338 /* The libpng documentation says this is right in this case. */
6339 png_set_gamma (png_ptr
, screen_gamma
, 0.45455);
6342 if (png_get_gAMA (png_ptr
, info_ptr
, &image_gamma
))
6343 /* Image contains gamma information. */
6344 png_set_gamma (png_ptr
, screen_gamma
, image_gamma
);
6346 /* Use the standard default for the image gamma. */
6347 png_set_gamma (png_ptr
, screen_gamma
, 0.45455);
6351 /* Handle alpha channel by combining the image with a background
6352 color. Do this only if a real alpha channel is supplied. For
6353 simple transparency, we prefer a clipping mask. */
6356 png_color_16
*image_bg
;
6357 Lisp_Object specified_bg
6358 = image_spec_value (img
->spec
, QCbackground
, NULL
);
6360 if (STRINGP (specified_bg
))
6361 /* The user specified `:background', use that. */
6363 /* W32 version incorrectly used COLORREF here!! ++kfs */
6365 if (x_defined_color (f
, SDATA (specified_bg
), &color
, 0))
6367 png_color_16 user_bg
;
6369 bzero (&user_bg
, sizeof user_bg
);
6370 user_bg
.red
= color
.red
>> 8;
6371 user_bg
.green
= color
.green
>> 8;
6372 user_bg
.blue
= color
.blue
>> 8;
6374 fn_png_set_background (png_ptr
, &user_bg
,
6375 PNG_BACKGROUND_GAMMA_SCREEN
, 0, 1.0);
6378 /* The commented-out code checked if the png specifies a default
6379 background color, and uses that. Since we use the current
6380 frame background, it is OK for us to ignore this.
6382 else if (fn_png_get_bKGD (png_ptr, info_ptr, &image_bg))
6383 fn_png_set_background (png_ptr, image_bg,
6384 PNG_BACKGROUND_GAMMA_FILE, 1, 1.0);
6388 /* Image does not contain a background color with which
6389 to combine the image data via an alpha channel. Use
6390 the frame's background instead. */
6391 #ifdef HAVE_X_WINDOWS
6393 png_color_16 frame_background
;
6395 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
6396 x_query_color (f
, &color
);
6398 bzero (&frame_background
, sizeof frame_background
);
6399 frame_background
.red
= color
.red
>> 8;
6400 frame_background
.green
= color
.green
>> 8;
6401 frame_background
.blue
= color
.blue
>> 8;
6402 #endif /* HAVE_X_WINDOWS */
6406 png_color_16 frame_background
;
6407 color
= FRAME_BACKGROUND_PIXEL (f
);
6408 #if 0 /* W32 TODO : Colormap support. */
6409 x_query_color (f
, &color
);
6411 bzero (&frame_background
, sizeof frame_background
);
6412 frame_background
.red
= GetRValue (color
);
6413 frame_background
.green
= GetGValue (color
);
6414 frame_background
.blue
= GetBValue (color
);
6415 #endif /* HAVE_NTGUI */
6418 unsigned long color
;
6419 png_color_16 frame_background
;
6420 color
= FRAME_BACKGROUND_PIXEL (f
);
6421 #if 0 /* MAC/W32 TODO : Colormap support. */
6422 x_query_color (f
, &color
);
6424 bzero (&frame_background
, sizeof frame_background
);
6425 frame_background
.red
= RED_FROM_ULONG (color
);
6426 frame_background
.green
= GREEN_FROM_ULONG (color
);
6427 frame_background
.blue
= BLUE_FROM_ULONG (color
);
6430 fn_png_set_background (png_ptr
, &frame_background
,
6431 PNG_BACKGROUND_GAMMA_SCREEN
, 0, 1.0);
6435 /* Update info structure. */
6436 fn_png_read_update_info (png_ptr
, info_ptr
);
6438 /* Get number of channels. Valid values are 1 for grayscale images
6439 and images with a palette, 2 for grayscale images with transparency
6440 information (alpha channel), 3 for RGB images, and 4 for RGB
6441 images with alpha channel, i.e. RGBA. If conversions above were
6442 sufficient we should only have 3 or 4 channels here. */
6443 channels
= fn_png_get_channels (png_ptr
, info_ptr
);
6444 xassert (channels
== 3 || channels
== 4);
6446 /* Number of bytes needed for one row of the image. */
6447 row_bytes
= fn_png_get_rowbytes (png_ptr
, info_ptr
);
6449 /* Allocate memory for the image. */
6450 pixels
= (png_byte
*) xmalloc (row_bytes
* height
* sizeof *pixels
);
6451 rows
= (png_byte
**) xmalloc (height
* sizeof *rows
);
6452 for (i
= 0; i
< height
; ++i
)
6453 rows
[i
] = pixels
+ i
* row_bytes
;
6455 /* Read the entire image. */
6456 fn_png_read_image (png_ptr
, rows
);
6457 fn_png_read_end (png_ptr
, info_ptr
);
6464 /* Create the X image and pixmap. */
6465 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
,
6469 /* Create an image and pixmap serving as mask if the PNG image
6470 contains an alpha channel. */
6473 && !x_create_x_image_and_pixmap (f
, width
, height
, 1,
6474 &mask_img
, &img
->mask
))
6476 x_destroy_x_image (ximg
);
6477 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->pixmap
);
6478 img
->pixmap
= NO_PIXMAP
;
6482 /* Fill the X image and mask from PNG data. */
6483 init_color_table ();
6485 for (y
= 0; y
< height
; ++y
)
6487 png_byte
*p
= rows
[y
];
6489 for (x
= 0; x
< width
; ++x
)
6496 XPutPixel (ximg
, x
, y
, lookup_rgb_color (f
, r
, g
, b
));
6497 /* An alpha channel, aka mask channel, associates variable
6498 transparency with an image. Where other image formats
6499 support binary transparency---fully transparent or fully
6500 opaque---PNG allows up to 254 levels of partial transparency.
6501 The PNG library implements partial transparency by combining
6502 the image with a specified background color.
6504 I'm not sure how to handle this here nicely: because the
6505 background on which the image is displayed may change, for
6506 real alpha channel support, it would be necessary to create
6507 a new image for each possible background.
6509 What I'm doing now is that a mask is created if we have
6510 boolean transparency information. Otherwise I'm using
6511 the frame's background color to combine the image with. */
6516 XPutPixel (mask_img
, x
, y
, *p
> 0 ? PIX_MASK_DRAW
: PIX_MASK_RETAIN
);
6522 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
6523 /* Set IMG's background color from the PNG image, unless the user
6527 if (fn_png_get_bKGD (png_ptr
, info_ptr
, &bg
))
6529 img
->background
= lookup_rgb_color (f
, bg
->red
, bg
->green
, bg
->blue
);
6530 img
->background_valid
= 1;
6534 #ifdef COLOR_TABLE_SUPPORT
6535 /* Remember colors allocated for this image. */
6536 img
->colors
= colors_in_color_table (&img
->ncolors
);
6537 free_color_table ();
6538 #endif /* COLOR_TABLE_SUPPORT */
6541 fn_png_destroy_read_struct (&png_ptr
, &info_ptr
, &end_info
);
6546 img
->height
= height
;
6548 /* Maybe fill in the background field while we have ximg handy.
6549 Casting avoids a GCC warning. */
6550 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
6552 /* Put the image into the pixmap, then free the X image and its buffer. */
6553 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
6554 x_destroy_x_image (ximg
);
6556 /* Same for the mask. */
6559 /* Fill in the background_transparent field while we have the
6560 mask handy. Casting avoids a GCC warning. */
6561 image_background_transparent (img
, f
, (XImagePtr_or_DC
)mask_img
);
6563 x_put_x_image (f
, mask_img
, img
->mask
, img
->width
, img
->height
);
6564 x_destroy_x_image (mask_img
);
6571 #else /* HAVE_PNG */
6580 if (MyCGImageCreateWithPNGDataProvider
)
6581 return image_load_quartz2d (f
, img
, 1);
6584 return image_load_quicktime (f
, img
, kQTFileTypePNG
);
6588 #endif /* !HAVE_PNG */
6592 /***********************************************************************
6594 ***********************************************************************/
6596 #if defined (HAVE_JPEG) || defined (MAC_OS)
6598 static int jpeg_image_p
P_ ((Lisp_Object object
));
6599 static int jpeg_load
P_ ((struct frame
*f
, struct image
*img
));
6601 /* The symbol `jpeg' identifying images of this type. */
6605 /* Indices of image specification fields in gs_format, below. */
6607 enum jpeg_keyword_index
6616 JPEG_HEURISTIC_MASK
,
6622 /* Vector of image_keyword structures describing the format
6623 of valid user-defined image specifications. */
6625 static struct image_keyword jpeg_format
[JPEG_LAST
] =
6627 {":type", IMAGE_SYMBOL_VALUE
, 1},
6628 {":data", IMAGE_STRING_VALUE
, 0},
6629 {":file", IMAGE_STRING_VALUE
, 0},
6630 {":ascent", IMAGE_ASCENT_VALUE
, 0},
6631 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
6632 {":relief", IMAGE_INTEGER_VALUE
, 0},
6633 {":conversions", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6634 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6635 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6636 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
6639 /* Structure describing the image type `jpeg'. */
6641 static struct image_type jpeg_type
=
6650 /* Return non-zero if OBJECT is a valid JPEG image specification. */
6653 jpeg_image_p (object
)
6656 struct image_keyword fmt
[JPEG_LAST
];
6658 bcopy (jpeg_format
, fmt
, sizeof fmt
);
6660 if (!parse_image_spec (object
, fmt
, JPEG_LAST
, Qjpeg
))
6663 /* Must specify either the :data or :file keyword. */
6664 return fmt
[JPEG_FILE
].count
+ fmt
[JPEG_DATA
].count
== 1;
6667 #endif /* HAVE_JPEG || MAC_OS */
6671 /* Work around a warning about HAVE_STDLIB_H being redefined in
6673 #ifdef HAVE_STDLIB_H
6674 #define HAVE_STDLIB_H_1
6675 #undef HAVE_STDLIB_H
6676 #endif /* HAVE_STLIB_H */
6678 #if defined (HAVE_NTGUI) && !defined (__WIN32__)
6679 /* In older releases of the jpeg library, jpeglib.h will define boolean
6680 differently depending on __WIN32__, so make sure it is defined. */
6684 #include <jpeglib.h>
6688 #ifdef HAVE_STLIB_H_1
6689 #define HAVE_STDLIB_H 1
6694 /* JPEG library details. */
6695 DEF_IMGLIB_FN (jpeg_CreateDecompress
);
6696 DEF_IMGLIB_FN (jpeg_start_decompress
);
6697 DEF_IMGLIB_FN (jpeg_finish_decompress
);
6698 DEF_IMGLIB_FN (jpeg_destroy_decompress
);
6699 DEF_IMGLIB_FN (jpeg_read_header
);
6700 DEF_IMGLIB_FN (jpeg_read_scanlines
);
6701 DEF_IMGLIB_FN (jpeg_std_error
);
6702 DEF_IMGLIB_FN (jpeg_resync_to_restart
);
6705 init_jpeg_functions (Lisp_Object libraries
)
6709 if (!(library
= w32_delayed_load (libraries
, Qjpeg
)))
6712 LOAD_IMGLIB_FN (library
, jpeg_finish_decompress
);
6713 LOAD_IMGLIB_FN (library
, jpeg_read_scanlines
);
6714 LOAD_IMGLIB_FN (library
, jpeg_start_decompress
);
6715 LOAD_IMGLIB_FN (library
, jpeg_read_header
);
6716 LOAD_IMGLIB_FN (library
, jpeg_CreateDecompress
);
6717 LOAD_IMGLIB_FN (library
, jpeg_destroy_decompress
);
6718 LOAD_IMGLIB_FN (library
, jpeg_std_error
);
6719 LOAD_IMGLIB_FN (library
, jpeg_resync_to_restart
);
6723 /* Wrapper since we can't directly assign the function pointer
6724 to another function pointer that was declared more completely easily. */
6726 jpeg_resync_to_restart_wrapper(cinfo
, desired
)
6727 j_decompress_ptr cinfo
;
6730 return fn_jpeg_resync_to_restart (cinfo
, desired
);
6735 #define fn_jpeg_CreateDecompress(a,b,c) jpeg_create_decompress(a)
6736 #define fn_jpeg_start_decompress jpeg_start_decompress
6737 #define fn_jpeg_finish_decompress jpeg_finish_decompress
6738 #define fn_jpeg_destroy_decompress jpeg_destroy_decompress
6739 #define fn_jpeg_read_header jpeg_read_header
6740 #define fn_jpeg_read_scanlines jpeg_read_scanlines
6741 #define fn_jpeg_std_error jpeg_std_error
6742 #define jpeg_resync_to_restart_wrapper jpeg_resync_to_restart
6744 #endif /* HAVE_NTGUI */
6746 struct my_jpeg_error_mgr
6748 struct jpeg_error_mgr pub
;
6749 jmp_buf setjmp_buffer
;
6754 my_error_exit (cinfo
)
6757 struct my_jpeg_error_mgr
*mgr
= (struct my_jpeg_error_mgr
*) cinfo
->err
;
6758 longjmp (mgr
->setjmp_buffer
, 1);
6762 /* Init source method for JPEG data source manager. Called by
6763 jpeg_read_header() before any data is actually read. See
6764 libjpeg.doc from the JPEG lib distribution. */
6767 our_common_init_source (cinfo
)
6768 j_decompress_ptr cinfo
;
6773 /* Method to terminate data source. Called by
6774 jpeg_finish_decompress() after all data has been processed. */
6777 our_common_term_source (cinfo
)
6778 j_decompress_ptr cinfo
;
6783 /* Fill input buffer method for JPEG data source manager. Called
6784 whenever more data is needed. We read the whole image in one step,
6785 so this only adds a fake end of input marker at the end. */
6787 static JOCTET our_memory_buffer
[2];
6790 our_memory_fill_input_buffer (cinfo
)
6791 j_decompress_ptr cinfo
;
6793 /* Insert a fake EOI marker. */
6794 struct jpeg_source_mgr
*src
= cinfo
->src
;
6796 our_memory_buffer
[0] = (JOCTET
) 0xFF;
6797 our_memory_buffer
[1] = (JOCTET
) JPEG_EOI
;
6799 src
->next_input_byte
= our_memory_buffer
;
6800 src
->bytes_in_buffer
= 2;
6805 /* Method to skip over NUM_BYTES bytes in the image data. CINFO->src
6806 is the JPEG data source manager. */
6809 our_memory_skip_input_data (cinfo
, num_bytes
)
6810 j_decompress_ptr cinfo
;
6813 struct jpeg_source_mgr
*src
= (struct jpeg_source_mgr
*) cinfo
->src
;
6817 if (num_bytes
> src
->bytes_in_buffer
)
6818 ERREXIT (cinfo
, JERR_INPUT_EOF
);
6820 src
->bytes_in_buffer
-= num_bytes
;
6821 src
->next_input_byte
+= num_bytes
;
6826 /* Set up the JPEG lib for reading an image from DATA which contains
6827 LEN bytes. CINFO is the decompression info structure created for
6828 reading the image. */
6831 jpeg_memory_src (cinfo
, data
, len
)
6832 j_decompress_ptr cinfo
;
6836 struct jpeg_source_mgr
*src
;
6838 if (cinfo
->src
== NULL
)
6840 /* First time for this JPEG object? */
6841 cinfo
->src
= (struct jpeg_source_mgr
*)
6842 (*cinfo
->mem
->alloc_small
) ((j_common_ptr
) cinfo
, JPOOL_PERMANENT
,
6843 sizeof (struct jpeg_source_mgr
));
6844 src
= (struct jpeg_source_mgr
*) cinfo
->src
;
6845 src
->next_input_byte
= data
;
6848 src
= (struct jpeg_source_mgr
*) cinfo
->src
;
6849 src
->init_source
= our_common_init_source
;
6850 src
->fill_input_buffer
= our_memory_fill_input_buffer
;
6851 src
->skip_input_data
= our_memory_skip_input_data
;
6852 src
->resync_to_restart
= jpeg_resync_to_restart_wrapper
; /* Use default method. */
6853 src
->term_source
= our_common_term_source
;
6854 src
->bytes_in_buffer
= len
;
6855 src
->next_input_byte
= data
;
6859 struct jpeg_stdio_mgr
6861 struct jpeg_source_mgr mgr
;
6868 /* Size of buffer to read JPEG from file.
6869 Not too big, as we want to use alloc_small. */
6870 #define JPEG_STDIO_BUFFER_SIZE 8192
6873 /* Fill input buffer method for JPEG data source manager. Called
6874 whenever more data is needed. The data is read from a FILE *. */
6877 our_stdio_fill_input_buffer (cinfo
)
6878 j_decompress_ptr cinfo
;
6880 struct jpeg_stdio_mgr
*src
;
6882 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6887 bytes
= fread (src
->buffer
, 1, JPEG_STDIO_BUFFER_SIZE
, src
->file
);
6889 src
->mgr
.bytes_in_buffer
= bytes
;
6892 WARNMS (cinfo
, JWRN_JPEG_EOF
);
6894 src
->buffer
[0] = (JOCTET
) 0xFF;
6895 src
->buffer
[1] = (JOCTET
) JPEG_EOI
;
6896 src
->mgr
.bytes_in_buffer
= 2;
6898 src
->mgr
.next_input_byte
= src
->buffer
;
6905 /* Method to skip over NUM_BYTES bytes in the image data. CINFO->src
6906 is the JPEG data source manager. */
6909 our_stdio_skip_input_data (cinfo
, num_bytes
)
6910 j_decompress_ptr cinfo
;
6913 struct jpeg_stdio_mgr
*src
;
6914 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6916 while (num_bytes
> 0 && !src
->finished
)
6918 if (num_bytes
<= src
->mgr
.bytes_in_buffer
)
6920 src
->mgr
.bytes_in_buffer
-= num_bytes
;
6921 src
->mgr
.next_input_byte
+= num_bytes
;
6926 num_bytes
-= src
->mgr
.bytes_in_buffer
;
6927 src
->mgr
.bytes_in_buffer
= 0;
6928 src
->mgr
.next_input_byte
= NULL
;
6930 our_stdio_fill_input_buffer (cinfo
);
6936 /* Set up the JPEG lib for reading an image from a FILE *.
6937 CINFO is the decompression info structure created for
6938 reading the image. */
6941 jpeg_file_src (cinfo
, fp
)
6942 j_decompress_ptr cinfo
;
6945 struct jpeg_stdio_mgr
*src
;
6947 if (cinfo
->src
!= NULL
)
6948 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6951 /* First time for this JPEG object? */
6952 cinfo
->src
= (struct jpeg_source_mgr
*)
6953 (*cinfo
->mem
->alloc_small
) ((j_common_ptr
) cinfo
, JPOOL_PERMANENT
,
6954 sizeof (struct jpeg_stdio_mgr
));
6955 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6956 src
->buffer
= (JOCTET
*)
6957 (*cinfo
->mem
->alloc_small
) ((j_common_ptr
) cinfo
, JPOOL_PERMANENT
,
6958 JPEG_STDIO_BUFFER_SIZE
);
6963 src
->mgr
.init_source
= our_common_init_source
;
6964 src
->mgr
.fill_input_buffer
= our_stdio_fill_input_buffer
;
6965 src
->mgr
.skip_input_data
= our_stdio_skip_input_data
;
6966 src
->mgr
.resync_to_restart
= jpeg_resync_to_restart_wrapper
; /* Use default method. */
6967 src
->mgr
.term_source
= our_common_term_source
;
6968 src
->mgr
.bytes_in_buffer
= 0;
6969 src
->mgr
.next_input_byte
= NULL
;
6973 /* Load image IMG for use on frame F. Patterned after example.c
6974 from the JPEG lib. */
6981 struct jpeg_decompress_struct cinfo
;
6982 struct my_jpeg_error_mgr mgr
;
6983 Lisp_Object file
, specified_file
;
6984 Lisp_Object specified_data
;
6985 FILE * volatile fp
= NULL
;
6987 int row_stride
, x
, y
;
6988 XImagePtr ximg
= NULL
;
6990 unsigned long *colors
;
6992 struct gcpro gcpro1
;
6994 /* Open the JPEG file. */
6995 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
6996 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
7000 if (NILP (specified_data
))
7002 file
= x_find_image_file (specified_file
);
7003 if (!STRINGP (file
))
7005 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
7010 fp
= fopen (SDATA (file
), "rb");
7013 image_error ("Cannot open `%s'", file
, Qnil
);
7019 /* Customize libjpeg's error handling to call my_error_exit when an
7020 error is detected. This function will perform a longjmp.
7021 Casting return value avoids a GCC warning on W32. */
7022 cinfo
.err
= (struct jpeg_error_mgr
*)fn_jpeg_std_error (&mgr
.pub
);
7023 mgr
.pub
.error_exit
= my_error_exit
;
7025 if ((rc
= setjmp (mgr
.setjmp_buffer
)) != 0)
7029 /* Called from my_error_exit. Display a JPEG error. */
7030 char buffer
[JMSG_LENGTH_MAX
];
7031 cinfo
.err
->format_message ((j_common_ptr
) &cinfo
, buffer
);
7032 image_error ("Error reading JPEG image `%s': %s", img
->spec
,
7033 build_string (buffer
));
7036 /* Close the input file and destroy the JPEG object. */
7038 fclose ((FILE *) fp
);
7039 fn_jpeg_destroy_decompress (&cinfo
);
7041 /* If we already have an XImage, free that. */
7042 x_destroy_x_image (ximg
);
7044 /* Free pixmap and colors. */
7045 x_clear_image (f
, img
);
7051 /* Create the JPEG decompression object. Let it read from fp.
7052 Read the JPEG image header. */
7053 fn_jpeg_CreateDecompress (&cinfo
, JPEG_LIB_VERSION
, sizeof (cinfo
));
7055 if (NILP (specified_data
))
7056 jpeg_file_src (&cinfo
, (FILE *) fp
);
7058 jpeg_memory_src (&cinfo
, SDATA (specified_data
),
7059 SBYTES (specified_data
));
7061 fn_jpeg_read_header (&cinfo
, 1);
7063 /* Customize decompression so that color quantization will be used.
7064 Start decompression. */
7065 cinfo
.quantize_colors
= 1;
7066 fn_jpeg_start_decompress (&cinfo
);
7067 width
= img
->width
= cinfo
.output_width
;
7068 height
= img
->height
= cinfo
.output_height
;
7070 if (!check_image_size (f
, width
, height
))
7072 image_error ("Invalid image size", Qnil
, Qnil
);
7073 longjmp (mgr
.setjmp_buffer
, 2);
7076 /* Create X image and pixmap. */
7077 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
7078 longjmp (mgr
.setjmp_buffer
, 2);
7080 /* Allocate colors. When color quantization is used,
7081 cinfo.actual_number_of_colors has been set with the number of
7082 colors generated, and cinfo.colormap is a two-dimensional array
7083 of color indices in the range 0..cinfo.actual_number_of_colors.
7084 No more than 255 colors will be generated. */
7088 if (cinfo
.out_color_components
> 2)
7089 ir
= 0, ig
= 1, ib
= 2;
7090 else if (cinfo
.out_color_components
> 1)
7091 ir
= 0, ig
= 1, ib
= 0;
7093 ir
= 0, ig
= 0, ib
= 0;
7095 /* Use the color table mechanism because it handles colors that
7096 cannot be allocated nicely. Such colors will be replaced with
7097 a default color, and we don't have to care about which colors
7098 can be freed safely, and which can't. */
7099 init_color_table ();
7100 colors
= (unsigned long *) alloca (cinfo
.actual_number_of_colors
7103 for (i
= 0; i
< cinfo
.actual_number_of_colors
; ++i
)
7105 /* Multiply RGB values with 255 because X expects RGB values
7106 in the range 0..0xffff. */
7107 int r
= cinfo
.colormap
[ir
][i
] << 8;
7108 int g
= cinfo
.colormap
[ig
][i
] << 8;
7109 int b
= cinfo
.colormap
[ib
][i
] << 8;
7110 colors
[i
] = lookup_rgb_color (f
, r
, g
, b
);
7113 #ifdef COLOR_TABLE_SUPPORT
7114 /* Remember those colors actually allocated. */
7115 img
->colors
= colors_in_color_table (&img
->ncolors
);
7116 free_color_table ();
7117 #endif /* COLOR_TABLE_SUPPORT */
7121 row_stride
= width
* cinfo
.output_components
;
7122 buffer
= cinfo
.mem
->alloc_sarray ((j_common_ptr
) &cinfo
, JPOOL_IMAGE
,
7124 for (y
= 0; y
< height
; ++y
)
7126 fn_jpeg_read_scanlines (&cinfo
, buffer
, 1);
7127 for (x
= 0; x
< cinfo
.output_width
; ++x
)
7128 XPutPixel (ximg
, x
, y
, colors
[buffer
[0][x
]]);
7132 fn_jpeg_finish_decompress (&cinfo
);
7133 fn_jpeg_destroy_decompress (&cinfo
);
7135 fclose ((FILE *) fp
);
7137 /* Maybe fill in the background field while we have ximg handy. */
7138 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
7139 /* Casting avoids a GCC warning. */
7140 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
7142 /* Put the image into the pixmap. */
7143 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
7144 x_destroy_x_image (ximg
);
7149 #else /* HAVE_JPEG */
7158 return image_load_quartz2d (f
, img
, 0);
7160 return image_load_quicktime (f
, img
, kQTFileTypeJPEG
);
7165 #endif /* !HAVE_JPEG */
7169 /***********************************************************************
7171 ***********************************************************************/
7173 #if defined (HAVE_TIFF) || defined (MAC_OS)
7175 static int tiff_image_p
P_ ((Lisp_Object object
));
7176 static int tiff_load
P_ ((struct frame
*f
, struct image
*img
));
7178 /* The symbol `tiff' identifying images of this type. */
7182 /* Indices of image specification fields in tiff_format, below. */
7184 enum tiff_keyword_index
7193 TIFF_HEURISTIC_MASK
,
7199 /* Vector of image_keyword structures describing the format
7200 of valid user-defined image specifications. */
7202 static struct image_keyword tiff_format
[TIFF_LAST
] =
7204 {":type", IMAGE_SYMBOL_VALUE
, 1},
7205 {":data", IMAGE_STRING_VALUE
, 0},
7206 {":file", IMAGE_STRING_VALUE
, 0},
7207 {":ascent", IMAGE_ASCENT_VALUE
, 0},
7208 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
7209 {":relief", IMAGE_INTEGER_VALUE
, 0},
7210 {":conversions", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7211 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7212 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7213 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
7216 /* Structure describing the image type `tiff'. */
7218 static struct image_type tiff_type
=
7227 /* Return non-zero if OBJECT is a valid TIFF image specification. */
7230 tiff_image_p (object
)
7233 struct image_keyword fmt
[TIFF_LAST
];
7234 bcopy (tiff_format
, fmt
, sizeof fmt
);
7236 if (!parse_image_spec (object
, fmt
, TIFF_LAST
, Qtiff
))
7239 /* Must specify either the :data or :file keyword. */
7240 return fmt
[TIFF_FILE
].count
+ fmt
[TIFF_DATA
].count
== 1;
7243 #endif /* HAVE_TIFF || MAC_OS */
7251 /* TIFF library details. */
7252 DEF_IMGLIB_FN (TIFFSetErrorHandler
);
7253 DEF_IMGLIB_FN (TIFFSetWarningHandler
);
7254 DEF_IMGLIB_FN (TIFFOpen
);
7255 DEF_IMGLIB_FN (TIFFClientOpen
);
7256 DEF_IMGLIB_FN (TIFFGetField
);
7257 DEF_IMGLIB_FN (TIFFReadRGBAImage
);
7258 DEF_IMGLIB_FN (TIFFClose
);
7261 init_tiff_functions (Lisp_Object libraries
)
7265 if (!(library
= w32_delayed_load (libraries
, Qtiff
)))
7268 LOAD_IMGLIB_FN (library
, TIFFSetErrorHandler
);
7269 LOAD_IMGLIB_FN (library
, TIFFSetWarningHandler
);
7270 LOAD_IMGLIB_FN (library
, TIFFOpen
);
7271 LOAD_IMGLIB_FN (library
, TIFFClientOpen
);
7272 LOAD_IMGLIB_FN (library
, TIFFGetField
);
7273 LOAD_IMGLIB_FN (library
, TIFFReadRGBAImage
);
7274 LOAD_IMGLIB_FN (library
, TIFFClose
);
7280 #define fn_TIFFSetErrorHandler TIFFSetErrorHandler
7281 #define fn_TIFFSetWarningHandler TIFFSetWarningHandler
7282 #define fn_TIFFOpen TIFFOpen
7283 #define fn_TIFFClientOpen TIFFClientOpen
7284 #define fn_TIFFGetField TIFFGetField
7285 #define fn_TIFFReadRGBAImage TIFFReadRGBAImage
7286 #define fn_TIFFClose TIFFClose
7288 #endif /* HAVE_NTGUI */
7291 /* Reading from a memory buffer for TIFF images Based on the PNG
7292 memory source, but we have to provide a lot of extra functions.
7295 We really only need to implement read and seek, but I am not
7296 convinced that the TIFF library is smart enough not to destroy
7297 itself if we only hand it the function pointers we need to
7302 unsigned char *bytes
;
7309 tiff_read_from_memory (data
, buf
, size
)
7314 tiff_memory_source
*src
= (tiff_memory_source
*) data
;
7316 if (size
> src
->len
- src
->index
)
7318 bcopy (src
->bytes
+ src
->index
, buf
, size
);
7324 tiff_write_from_memory (data
, buf
, size
)
7333 tiff_seek_in_memory (data
, off
, whence
)
7338 tiff_memory_source
*src
= (tiff_memory_source
*) data
;
7343 case SEEK_SET
: /* Go from beginning of source. */
7347 case SEEK_END
: /* Go from end of source. */
7348 idx
= src
->len
+ off
;
7351 case SEEK_CUR
: /* Go from current position. */
7352 idx
= src
->index
+ off
;
7355 default: /* Invalid `whence'. */
7359 if (idx
> src
->len
|| idx
< 0)
7367 tiff_close_memory (data
)
7375 tiff_mmap_memory (data
, pbase
, psize
)
7380 /* It is already _IN_ memory. */
7385 tiff_unmap_memory (data
, base
, size
)
7390 /* We don't need to do this. */
7394 tiff_size_of_memory (data
)
7397 return ((tiff_memory_source
*) data
)->len
;
7402 tiff_error_handler (title
, format
, ap
)
7403 const char *title
, *format
;
7409 len
= sprintf (buf
, "TIFF error: %s ", title
);
7410 vsprintf (buf
+ len
, format
, ap
);
7411 add_to_log (buf
, Qnil
, Qnil
);
7416 tiff_warning_handler (title
, format
, ap
)
7417 const char *title
, *format
;
7423 len
= sprintf (buf
, "TIFF warning: %s ", title
);
7424 vsprintf (buf
+ len
, format
, ap
);
7425 add_to_log (buf
, Qnil
, Qnil
);
7429 /* Load TIFF image IMG for use on frame F. Value is non-zero if
7437 Lisp_Object file
, specified_file
;
7438 Lisp_Object specified_data
;
7440 int width
, height
, x
, y
;
7444 struct gcpro gcpro1
;
7445 tiff_memory_source memsrc
;
7447 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
7448 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
7452 fn_TIFFSetErrorHandler (tiff_error_handler
);
7453 fn_TIFFSetWarningHandler (tiff_warning_handler
);
7455 if (NILP (specified_data
))
7457 /* Read from a file */
7458 file
= x_find_image_file (specified_file
);
7459 if (!STRINGP (file
))
7461 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
7466 /* Try to open the image file. Casting return value avoids a
7467 GCC warning on W32. */
7468 tiff
= (TIFF
*)fn_TIFFOpen (SDATA (file
), "r");
7471 image_error ("Cannot open `%s'", file
, Qnil
);
7478 /* Memory source! */
7479 memsrc
.bytes
= SDATA (specified_data
);
7480 memsrc
.len
= SBYTES (specified_data
);
7483 /* Casting return value avoids a GCC warning on W32. */
7484 tiff
= (TIFF
*)fn_TIFFClientOpen ("memory_source", "r", &memsrc
,
7485 (TIFFReadWriteProc
) tiff_read_from_memory
,
7486 (TIFFReadWriteProc
) tiff_write_from_memory
,
7487 tiff_seek_in_memory
,
7489 tiff_size_of_memory
,
7495 image_error ("Cannot open memory source for `%s'", img
->spec
, Qnil
);
7501 /* Get width and height of the image, and allocate a raster buffer
7502 of width x height 32-bit values. */
7503 fn_TIFFGetField (tiff
, TIFFTAG_IMAGEWIDTH
, &width
);
7504 fn_TIFFGetField (tiff
, TIFFTAG_IMAGELENGTH
, &height
);
7506 if (!check_image_size (f
, width
, height
))
7508 image_error ("Invalid image size", Qnil
, Qnil
);
7513 buf
= (uint32
*) xmalloc (width
* height
* sizeof *buf
);
7515 rc
= fn_TIFFReadRGBAImage (tiff
, width
, height
, buf
, 0);
7516 fn_TIFFClose (tiff
);
7519 image_error ("Error reading TIFF image `%s'", img
->spec
, Qnil
);
7525 /* Create the X image and pixmap. */
7526 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
7533 /* Initialize the color table. */
7534 init_color_table ();
7536 /* Process the pixel raster. Origin is in the lower-left corner. */
7537 for (y
= 0; y
< height
; ++y
)
7539 uint32
*row
= buf
+ y
* width
;
7541 for (x
= 0; x
< width
; ++x
)
7543 uint32 abgr
= row
[x
];
7544 int r
= TIFFGetR (abgr
) << 8;
7545 int g
= TIFFGetG (abgr
) << 8;
7546 int b
= TIFFGetB (abgr
) << 8;
7547 XPutPixel (ximg
, x
, height
- 1 - y
, lookup_rgb_color (f
, r
, g
, b
));
7551 #ifdef COLOR_TABLE_SUPPORT
7552 /* Remember the colors allocated for the image. Free the color table. */
7553 img
->colors
= colors_in_color_table (&img
->ncolors
);
7554 free_color_table ();
7555 #endif /* COLOR_TABLE_SUPPORT */
7558 img
->height
= height
;
7560 /* Maybe fill in the background field while we have ximg handy. */
7561 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
7562 /* Casting avoids a GCC warning on W32. */
7563 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
7565 /* Put the image into the pixmap, then free the X image and its buffer. */
7566 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
7567 x_destroy_x_image (ximg
);
7574 #else /* HAVE_TIFF */
7582 return image_load_quicktime (f
, img
, kQTFileTypeTIFF
);
7586 #endif /* !HAVE_TIFF */
7590 /***********************************************************************
7592 ***********************************************************************/
7594 #if defined (HAVE_GIF) || defined (MAC_OS)
7596 static int gif_image_p
P_ ((Lisp_Object object
));
7597 static int gif_load
P_ ((struct frame
*f
, struct image
*img
));
7598 static void gif_clear_image
P_ ((struct frame
*f
, struct image
*img
));
7600 /* The symbol `gif' identifying images of this type. */
7604 /* Indices of image specification fields in gif_format, below. */
7606 enum gif_keyword_index
7622 /* Vector of image_keyword structures describing the format
7623 of valid user-defined image specifications. */
7625 static struct image_keyword gif_format
[GIF_LAST
] =
7627 {":type", IMAGE_SYMBOL_VALUE
, 1},
7628 {":data", IMAGE_STRING_VALUE
, 0},
7629 {":file", IMAGE_STRING_VALUE
, 0},
7630 {":ascent", IMAGE_ASCENT_VALUE
, 0},
7631 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
7632 {":relief", IMAGE_INTEGER_VALUE
, 0},
7633 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7634 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7635 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7636 {":image", IMAGE_NON_NEGATIVE_INTEGER_VALUE
, 0},
7637 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
7640 /* Structure describing the image type `gif'. */
7642 static struct image_type gif_type
=
7651 /* Free X resources of GIF image IMG which is used on frame F. */
7654 gif_clear_image (f
, img
)
7658 /* IMG->data.ptr_val may contain extension data. */
7659 img
->data
.lisp_val
= Qnil
;
7660 x_clear_image (f
, img
);
7663 /* Return non-zero if OBJECT is a valid GIF image specification. */
7666 gif_image_p (object
)
7669 struct image_keyword fmt
[GIF_LAST
];
7670 bcopy (gif_format
, fmt
, sizeof fmt
);
7672 if (!parse_image_spec (object
, fmt
, GIF_LAST
, Qgif
))
7675 /* Must specify either the :data or :file keyword. */
7676 return fmt
[GIF_FILE
].count
+ fmt
[GIF_DATA
].count
== 1;
7679 #endif /* HAVE_GIF || MAC_OS */
7683 #if defined (HAVE_NTGUI) || defined (MAC_OS)
7684 /* winuser.h might define DrawText to DrawTextA or DrawTextW.
7685 Undefine before redefining to avoid a preprocessor warning. */
7689 /* avoid conflict with QuickdrawText.h */
7690 #define DrawText gif_DrawText
7691 #include <gif_lib.h>
7694 #else /* HAVE_NTGUI || MAC_OS */
7696 #include <gif_lib.h>
7698 #endif /* HAVE_NTGUI || MAC_OS */
7703 /* GIF library details. */
7704 DEF_IMGLIB_FN (DGifCloseFile
);
7705 DEF_IMGLIB_FN (DGifSlurp
);
7706 DEF_IMGLIB_FN (DGifOpen
);
7707 DEF_IMGLIB_FN (DGifOpenFileName
);
7710 init_gif_functions (Lisp_Object libraries
)
7714 if (!(library
= w32_delayed_load (libraries
, Qgif
)))
7717 LOAD_IMGLIB_FN (library
, DGifCloseFile
);
7718 LOAD_IMGLIB_FN (library
, DGifSlurp
);
7719 LOAD_IMGLIB_FN (library
, DGifOpen
);
7720 LOAD_IMGLIB_FN (library
, DGifOpenFileName
);
7726 #define fn_DGifCloseFile DGifCloseFile
7727 #define fn_DGifSlurp DGifSlurp
7728 #define fn_DGifOpen DGifOpen
7729 #define fn_DGifOpenFileName DGifOpenFileName
7731 #endif /* HAVE_NTGUI */
7733 /* Reading a GIF image from memory
7734 Based on the PNG memory stuff to a certain extent. */
7738 unsigned char *bytes
;
7744 /* Make the current memory source available to gif_read_from_memory.
7745 It's done this way because not all versions of libungif support
7746 a UserData field in the GifFileType structure. */
7747 static gif_memory_source
*current_gif_memory_src
;
7750 gif_read_from_memory (file
, buf
, len
)
7755 gif_memory_source
*src
= current_gif_memory_src
;
7757 if (len
> src
->len
- src
->index
)
7760 bcopy (src
->bytes
+ src
->index
, buf
, len
);
7766 /* Load GIF image IMG for use on frame F. Value is non-zero if
7769 static int interlace_start
[] = {0, 4, 2, 1};
7770 static int interlace_increment
[] = {8, 8, 4, 2};
7777 Lisp_Object file
, specified_file
;
7778 Lisp_Object specified_data
;
7779 int rc
, width
, height
, x
, y
, i
;
7781 ColorMapObject
*gif_color_map
;
7782 unsigned long pixel_colors
[256];
7784 struct gcpro gcpro1
;
7786 int ino
, image_height
, image_width
;
7787 gif_memory_source memsrc
;
7788 unsigned char *raster
;
7790 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
7791 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
7795 if (NILP (specified_data
))
7797 file
= x_find_image_file (specified_file
);
7798 if (!STRINGP (file
))
7800 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
7805 /* Open the GIF file. Casting return value avoids a GCC warning
7807 gif
= (GifFileType
*)fn_DGifOpenFileName (SDATA (file
));
7810 image_error ("Cannot open `%s'", file
, Qnil
);
7817 /* Read from memory! */
7818 current_gif_memory_src
= &memsrc
;
7819 memsrc
.bytes
= SDATA (specified_data
);
7820 memsrc
.len
= SBYTES (specified_data
);
7823 /* Casting return value avoids a GCC warning on W32. */
7824 gif
= (GifFileType
*)fn_DGifOpen(&memsrc
, gif_read_from_memory
);
7827 image_error ("Cannot open memory source `%s'", img
->spec
, Qnil
);
7833 /* Before reading entire contents, check the declared image size. */
7834 if (!check_image_size (f
, gif
->SWidth
, gif
->SHeight
))
7836 image_error ("Invalid image size", Qnil
, Qnil
);
7837 fn_DGifCloseFile (gif
);
7842 /* Read entire contents. */
7843 rc
= fn_DGifSlurp (gif
);
7844 if (rc
== GIF_ERROR
)
7846 image_error ("Error reading `%s'", img
->spec
, Qnil
);
7847 fn_DGifCloseFile (gif
);
7852 image
= image_spec_value (img
->spec
, QCindex
, NULL
);
7853 ino
= INTEGERP (image
) ? XFASTINT (image
) : 0;
7854 if (ino
>= gif
->ImageCount
)
7856 image_error ("Invalid image number `%s' in image `%s'",
7858 fn_DGifCloseFile (gif
);
7863 img
->corners
[TOP_CORNER
] = gif
->SavedImages
[ino
].ImageDesc
.Top
;
7864 img
->corners
[LEFT_CORNER
] = gif
->SavedImages
[ino
].ImageDesc
.Left
;
7865 image_height
= gif
->SavedImages
[ino
].ImageDesc
.Height
;
7866 img
->corners
[BOT_CORNER
] = img
->corners
[TOP_CORNER
] + image_height
;
7867 image_width
= gif
->SavedImages
[ino
].ImageDesc
.Width
;
7868 img
->corners
[RIGHT_CORNER
] = img
->corners
[LEFT_CORNER
] + image_width
;
7870 width
= img
->width
= max (gif
->SWidth
,
7871 max (gif
->Image
.Left
+ gif
->Image
.Width
,
7872 img
->corners
[RIGHT_CORNER
]));
7873 height
= img
->height
= max (gif
->SHeight
,
7874 max (gif
->Image
.Top
+ gif
->Image
.Height
,
7875 img
->corners
[BOT_CORNER
]));
7877 if (!check_image_size (f
, width
, height
))
7879 image_error ("Invalid image size", Qnil
, Qnil
);
7880 fn_DGifCloseFile (gif
);
7885 /* Create the X image and pixmap. */
7886 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
7888 fn_DGifCloseFile (gif
);
7893 /* Allocate colors. */
7894 gif_color_map
= gif
->SavedImages
[ino
].ImageDesc
.ColorMap
;
7896 gif_color_map
= gif
->SColorMap
;
7897 init_color_table ();
7898 bzero (pixel_colors
, sizeof pixel_colors
);
7901 for (i
= 0; i
< gif_color_map
->ColorCount
; ++i
)
7903 int r
= gif_color_map
->Colors
[i
].Red
<< 8;
7904 int g
= gif_color_map
->Colors
[i
].Green
<< 8;
7905 int b
= gif_color_map
->Colors
[i
].Blue
<< 8;
7906 pixel_colors
[i
] = lookup_rgb_color (f
, r
, g
, b
);
7909 #ifdef COLOR_TABLE_SUPPORT
7910 img
->colors
= colors_in_color_table (&img
->ncolors
);
7911 free_color_table ();
7912 #endif /* COLOR_TABLE_SUPPORT */
7914 /* Clear the part of the screen image that are not covered by
7915 the image from the GIF file. Full animated GIF support
7916 requires more than can be done here (see the gif89 spec,
7917 disposal methods). Let's simply assume that the part
7918 not covered by a sub-image is in the frame's background color. */
7919 for (y
= 0; y
< img
->corners
[TOP_CORNER
]; ++y
)
7920 for (x
= 0; x
< width
; ++x
)
7921 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7923 for (y
= img
->corners
[BOT_CORNER
]; y
< height
; ++y
)
7924 for (x
= 0; x
< width
; ++x
)
7925 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7927 for (y
= img
->corners
[TOP_CORNER
]; y
< img
->corners
[BOT_CORNER
]; ++y
)
7929 for (x
= 0; x
< img
->corners
[LEFT_CORNER
]; ++x
)
7930 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7931 for (x
= img
->corners
[RIGHT_CORNER
]; x
< width
; ++x
)
7932 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7935 /* Read the GIF image into the X image. We use a local variable
7936 `raster' here because RasterBits below is a char *, and invites
7937 problems with bytes >= 0x80. */
7938 raster
= (unsigned char *) gif
->SavedImages
[ino
].RasterBits
;
7940 if (gif
->SavedImages
[ino
].ImageDesc
.Interlace
)
7943 int row
= interlace_start
[0];
7947 for (y
= 0; y
< image_height
; y
++)
7949 if (row
>= image_height
)
7951 row
= interlace_start
[++pass
];
7952 while (row
>= image_height
)
7953 row
= interlace_start
[++pass
];
7956 for (x
= 0; x
< image_width
; x
++)
7958 int i
= raster
[(y
* image_width
) + x
];
7959 XPutPixel (ximg
, x
+ img
->corners
[LEFT_CORNER
],
7960 row
+ img
->corners
[TOP_CORNER
], pixel_colors
[i
]);
7963 row
+= interlace_increment
[pass
];
7968 for (y
= 0; y
< image_height
; ++y
)
7969 for (x
= 0; x
< image_width
; ++x
)
7971 int i
= raster
[y
* image_width
+ x
];
7972 XPutPixel (ximg
, x
+ img
->corners
[LEFT_CORNER
],
7973 y
+ img
->corners
[TOP_CORNER
], pixel_colors
[i
]);
7977 /* Save GIF image extension data for `image-extension-data'.
7978 Format is (count IMAGES FUNCTION "BYTES" ...). */
7979 img
->data
.lisp_val
= Qnil
;
7980 if (gif
->SavedImages
[ino
].ExtensionBlockCount
> 0)
7982 ExtensionBlock
*ext
= gif
->SavedImages
[ino
].ExtensionBlocks
;
7983 for (i
= 0; i
< gif
->SavedImages
[ino
].ExtensionBlockCount
; i
++, ext
++)
7984 /* Append (... FUNCTION "BYTES") */
7985 img
->data
.lisp_val
= Fcons (make_unibyte_string (ext
->Bytes
, ext
->ByteCount
),
7986 Fcons (make_number (ext
->Function
),
7987 img
->data
.lisp_val
));
7988 img
->data
.lisp_val
= Fnreverse (img
->data
.lisp_val
);
7990 if (gif
->ImageCount
> 1)
7991 img
->data
.lisp_val
= Fcons (Qcount
,
7992 Fcons (make_number (gif
->ImageCount
),
7993 img
->data
.lisp_val
));
7995 fn_DGifCloseFile (gif
);
7997 /* Maybe fill in the background field while we have ximg handy. */
7998 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
7999 /* Casting avoids a GCC warning. */
8000 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
8002 /* Put the image into the pixmap, then free the X image and its buffer. */
8003 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
8004 x_destroy_x_image (ximg
);
8010 #else /* !HAVE_GIF */
8018 Lisp_Object specified_file
, file
;
8019 Lisp_Object specified_data
;
8021 Boolean graphic_p
, movie_p
, prefer_graphic_p
;
8029 Lisp_Object specified_bg
;
8034 TimeScale time_scale
;
8035 TimeValue time
, duration
;
8040 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
8041 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
8043 /* Animated gifs use QuickTime Movie Toolbox. So initialize it here. */
8046 if (NILP (specified_data
))
8048 /* Read from a file */
8052 err
= find_image_fsspec (specified_file
, &file
, &fss
);
8056 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
8061 err
= CanQuickTimeOpenFile (&fss
, kQTFileTypeGIF
, 0,
8062 &graphic_p
, &movie_p
, &prefer_graphic_p
, 0);
8066 if (!graphic_p
&& !movie_p
)
8068 if (prefer_graphic_p
)
8069 return image_load_qt_1 (f
, img
, kQTFileTypeGIF
, &fss
, NULL
);
8070 err
= OpenMovieFile (&fss
, &refnum
, fsRdPerm
);
8073 err
= NewMovieFromFile (&movie
, refnum
, NULL
, NULL
, 0, NULL
);
8074 CloseMovieFile (refnum
);
8077 image_error ("Error reading `%s'", file
, Qnil
);
8083 /* Memory source! */
8085 long file_type_atom
[3];
8087 err
= PtrToHand (SDATA (specified_data
), &dh
, SBYTES (specified_data
));
8090 image_error ("Cannot allocate data handle for `%s'",
8095 file_type_atom
[0] = EndianU32_NtoB (sizeof (long) * 3);
8096 file_type_atom
[1] = EndianU32_NtoB (kDataRefExtensionMacOSFileType
);
8097 file_type_atom
[2] = EndianU32_NtoB (kQTFileTypeGIF
);
8098 err
= PtrToHand (&dh
, &dref
, sizeof (Handle
));
8101 err
= PtrAndHand ("\p", dref
, 1);
8103 err
= PtrAndHand (file_type_atom
, dref
, sizeof (long) * 3);
8106 image_error ("Cannot allocate handle data ref for `%s'", img
->spec
, Qnil
);
8109 err
= CanQuickTimeOpenDataRef (dref
, HandleDataHandlerSubType
, &graphic_p
,
8110 &movie_p
, &prefer_graphic_p
, 0);
8114 if (!graphic_p
&& !movie_p
)
8116 if (prefer_graphic_p
)
8120 DisposeHandle (dref
);
8121 success_p
= image_load_qt_1 (f
, img
, kQTFileTypeGIF
, NULL
, dh
);
8125 err
= NewMovieFromDataRef (&movie
, 0, NULL
, dref
,
8126 HandleDataHandlerSubType
);
8127 DisposeHandle (dref
);
8132 image
= image_spec_value (img
->spec
, QCindex
, NULL
);
8133 ino
= INTEGERP (image
) ? XFASTINT (image
) : 0;
8134 track
= GetMovieIndTrack (movie
, 1);
8135 media
= GetTrackMedia (track
);
8136 nsamples
= GetMediaSampleCount (media
);
8137 if (ino
>= nsamples
)
8139 image_error ("Invalid image number `%s' in image `%s'",
8143 time_scale
= GetMediaTimeScale (media
);
8145 specified_bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
8146 if (!STRINGP (specified_bg
) ||
8147 !mac_defined_color (f
, SDATA (specified_bg
), &color
, 0))
8149 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
8150 color
.red
= RED16_FROM_ULONG (color
.pixel
);
8151 color
.green
= GREEN16_FROM_ULONG (color
.pixel
);
8152 color
.blue
= BLUE16_FROM_ULONG (color
.pixel
);
8154 GetMovieBox (movie
, &rect
);
8155 width
= img
->width
= rect
.right
- rect
.left
;
8156 height
= img
->height
= rect
.bottom
- rect
.top
;
8157 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
8160 GetGWorld (&old_port
, &old_gdh
);
8161 SetGWorld (ximg
, NULL
);
8162 bg_color
.red
= color
.red
;
8163 bg_color
.green
= color
.green
;
8164 bg_color
.blue
= color
.blue
;
8165 RGBBackColor (&bg_color
);
8166 SetGWorld (old_port
, old_gdh
);
8167 SetMovieActive (movie
, 1);
8168 SetMovieGWorld (movie
, ximg
, NULL
);
8169 SampleNumToMediaTime (media
, ino
+ 1, &time
, &duration
);
8170 SetMovieTimeValue (movie
, time
);
8171 MoviesTask (movie
, 0L);
8172 DisposeTrackMedia (media
);
8173 DisposeMovieTrack (track
);
8174 DisposeMovie (movie
);
8178 /* Save GIF image extension data for `image-extension-data'.
8179 Format is (count IMAGES 0xf9 GRAPHIC_CONTROL_EXTENSION_BLOCK). */
8181 Lisp_Object gce
= make_uninit_string (4);
8182 int centisec
= ((float)duration
/ time_scale
) * 100.0f
+ 0.5f
;
8184 /* Fill the delay time field. */
8185 SSET (gce
, 1, centisec
& 0xff);
8186 SSET (gce
, 2, (centisec
>> 8) & 0xff);
8187 /* We don't know about other fields. */
8191 img
->data
.lisp_val
= list4 (Qcount
, make_number (nsamples
),
8192 make_number (0xf9), gce
);
8195 /* Maybe fill in the background field while we have ximg handy. */
8196 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
8197 IMAGE_BACKGROUND (img
, f
, ximg
);
8199 /* Put the image into the pixmap. */
8200 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
8201 x_destroy_x_image (ximg
);
8205 image_error ("Cannot open `%s'", file
, Qnil
);
8208 DisposeTrackMedia (media
);
8210 DisposeMovieTrack (track
);
8212 DisposeMovie (movie
);
8219 #endif /* HAVE_GIF */
8223 /***********************************************************************
8225 ***********************************************************************/
8227 #ifdef HAVE_X_WINDOWS
8228 #define HAVE_GHOSTSCRIPT 1
8229 #endif /* HAVE_X_WINDOWS */
8231 /* The symbol `postscript' identifying images of this type. */
8233 Lisp_Object Qpostscript
;
8235 #ifdef HAVE_GHOSTSCRIPT
8237 static int gs_image_p
P_ ((Lisp_Object object
));
8238 static int gs_load
P_ ((struct frame
*f
, struct image
*img
));
8239 static void gs_clear_image
P_ ((struct frame
*f
, struct image
*img
));
8241 /* Keyword symbols. */
8243 Lisp_Object QCloader
, QCbounding_box
, QCpt_width
, QCpt_height
;
8245 /* Indices of image specification fields in gs_format, below. */
8247 enum gs_keyword_index
8265 /* Vector of image_keyword structures describing the format
8266 of valid user-defined image specifications. */
8268 static struct image_keyword gs_format
[GS_LAST
] =
8270 {":type", IMAGE_SYMBOL_VALUE
, 1},
8271 {":pt-width", IMAGE_POSITIVE_INTEGER_VALUE
, 1},
8272 {":pt-height", IMAGE_POSITIVE_INTEGER_VALUE
, 1},
8273 {":file", IMAGE_STRING_VALUE
, 1},
8274 {":loader", IMAGE_FUNCTION_VALUE
, 0},
8275 {":bounding-box", IMAGE_DONT_CHECK_VALUE_TYPE
, 1},
8276 {":ascent", IMAGE_ASCENT_VALUE
, 0},
8277 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
8278 {":relief", IMAGE_INTEGER_VALUE
, 0},
8279 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8280 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8281 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8282 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
8285 /* Structure describing the image type `ghostscript'. */
8287 static struct image_type gs_type
=
8297 /* Free X resources of Ghostscript image IMG which is used on frame F. */
8300 gs_clear_image (f
, img
)
8304 /* IMG->data.ptr_val may contain a recorded colormap. */
8305 xfree (img
->data
.ptr_val
);
8306 x_clear_image (f
, img
);
8310 /* Return non-zero if OBJECT is a valid Ghostscript image
8317 struct image_keyword fmt
[GS_LAST
];
8321 bcopy (gs_format
, fmt
, sizeof fmt
);
8323 if (!parse_image_spec (object
, fmt
, GS_LAST
, Qpostscript
))
8326 /* Bounding box must be a list or vector containing 4 integers. */
8327 tem
= fmt
[GS_BOUNDING_BOX
].value
;
8330 for (i
= 0; i
< 4; ++i
, tem
= XCDR (tem
))
8331 if (!CONSP (tem
) || !INTEGERP (XCAR (tem
)))
8336 else if (VECTORP (tem
))
8338 if (XVECTOR (tem
)->size
!= 4)
8340 for (i
= 0; i
< 4; ++i
)
8341 if (!INTEGERP (XVECTOR (tem
)->contents
[i
]))
8351 /* Load Ghostscript image IMG for use on frame F. Value is non-zero
8360 Lisp_Object window_and_pixmap_id
= Qnil
, loader
, pt_height
, pt_width
;
8361 struct gcpro gcpro1
, gcpro2
;
8363 double in_width
, in_height
;
8364 Lisp_Object pixel_colors
= Qnil
;
8366 /* Compute pixel size of pixmap needed from the given size in the
8367 image specification. Sizes in the specification are in pt. 1 pt
8368 = 1/72 in, xdpi and ydpi are stored in the frame's X display
8370 pt_width
= image_spec_value (img
->spec
, QCpt_width
, NULL
);
8371 in_width
= XFASTINT (pt_width
) / 72.0;
8372 img
->width
= in_width
* FRAME_X_DISPLAY_INFO (f
)->resx
;
8373 pt_height
= image_spec_value (img
->spec
, QCpt_height
, NULL
);
8374 in_height
= XFASTINT (pt_height
) / 72.0;
8375 img
->height
= in_height
* FRAME_X_DISPLAY_INFO (f
)->resy
;
8377 if (!check_image_size (f
, img
->width
, img
->height
))
8379 image_error ("Invalid image size", Qnil
, Qnil
);
8383 /* Create the pixmap. */
8384 xassert (img
->pixmap
== NO_PIXMAP
);
8386 /* Only W32 version did BLOCK_INPUT here. ++kfs */
8388 img
->pixmap
= XCreatePixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
8389 img
->width
, img
->height
,
8390 DefaultDepthOfScreen (FRAME_X_SCREEN (f
)));
8395 image_error ("Unable to create pixmap for `%s'", img
->spec
, Qnil
);
8399 /* Call the loader to fill the pixmap. It returns a process object
8400 if successful. We do not record_unwind_protect here because
8401 other places in redisplay like calling window scroll functions
8402 don't either. Let the Lisp loader use `unwind-protect' instead. */
8403 GCPRO2 (window_and_pixmap_id
, pixel_colors
);
8405 sprintf (buffer
, "%lu %lu",
8406 (unsigned long) FRAME_X_WINDOW (f
),
8407 (unsigned long) img
->pixmap
);
8408 window_and_pixmap_id
= build_string (buffer
);
8410 sprintf (buffer
, "%lu %lu",
8411 FRAME_FOREGROUND_PIXEL (f
),
8412 FRAME_BACKGROUND_PIXEL (f
));
8413 pixel_colors
= build_string (buffer
);
8415 XSETFRAME (frame
, f
);
8416 loader
= image_spec_value (img
->spec
, QCloader
, NULL
);
8418 loader
= intern ("gs-load-image");
8420 img
->data
.lisp_val
= call6 (loader
, frame
, img
->spec
,
8421 make_number (img
->width
),
8422 make_number (img
->height
),
8423 window_and_pixmap_id
,
8426 return PROCESSP (img
->data
.lisp_val
);
8430 /* Kill the Ghostscript process that was started to fill PIXMAP on
8431 frame F. Called from XTread_socket when receiving an event
8432 telling Emacs that Ghostscript has finished drawing. */
8435 x_kill_gs_process (pixmap
, f
)
8439 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
8443 /* Find the image containing PIXMAP. */
8444 for (i
= 0; i
< c
->used
; ++i
)
8445 if (c
->images
[i
]->pixmap
== pixmap
)
8448 /* Should someone in between have cleared the image cache, for
8449 instance, give up. */
8453 /* Kill the GS process. We should have found PIXMAP in the image
8454 cache and its image should contain a process object. */
8456 xassert (PROCESSP (img
->data
.lisp_val
));
8457 Fkill_process (img
->data
.lisp_val
, Qnil
);
8458 img
->data
.lisp_val
= Qnil
;
8460 #if defined (HAVE_X_WINDOWS)
8462 /* On displays with a mutable colormap, figure out the colors
8463 allocated for the image by looking at the pixels of an XImage for
8465 class = FRAME_X_VISUAL (f
)->class;
8466 if (class != StaticColor
&& class != StaticGray
&& class != TrueColor
)
8472 /* Try to get an XImage for img->pixmep. */
8473 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
8474 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
8479 /* Initialize the color table. */
8480 init_color_table ();
8482 /* For each pixel of the image, look its color up in the
8483 color table. After having done so, the color table will
8484 contain an entry for each color used by the image. */
8485 for (y
= 0; y
< img
->height
; ++y
)
8486 for (x
= 0; x
< img
->width
; ++x
)
8488 unsigned long pixel
= XGetPixel (ximg
, x
, y
);
8489 lookup_pixel_color (f
, pixel
);
8492 /* Record colors in the image. Free color table and XImage. */
8493 #ifdef COLOR_TABLE_SUPPORT
8494 img
->colors
= colors_in_color_table (&img
->ncolors
);
8495 free_color_table ();
8497 XDestroyImage (ximg
);
8499 #if 0 /* This doesn't seem to be the case. If we free the colors
8500 here, we get a BadAccess later in x_clear_image when
8501 freeing the colors. */
8502 /* We have allocated colors once, but Ghostscript has also
8503 allocated colors on behalf of us. So, to get the
8504 reference counts right, free them once. */
8506 x_free_colors (f
, img
->colors
, img
->ncolors
);
8510 image_error ("Cannot get X image of `%s'; colors will not be freed",
8515 #endif /* HAVE_X_WINDOWS */
8517 /* Now that we have the pixmap, compute mask and transform the
8518 image if requested. */
8520 postprocess_image (f
, img
);
8524 #endif /* HAVE_GHOSTSCRIPT */
8527 /***********************************************************************
8529 ***********************************************************************/
8533 DEFUN ("imagep", Fimagep
, Simagep
, 1, 1, 0,
8534 doc
: /* Value is non-nil if SPEC is a valid image specification. */)
8538 return valid_image_p (spec
) ? Qt
: Qnil
;
8542 DEFUN ("lookup-image", Flookup_image
, Slookup_image
, 1, 1, 0, "")
8548 if (valid_image_p (spec
))
8549 id
= lookup_image (SELECTED_FRAME (), spec
);
8552 return make_number (id
);
8555 #endif /* GLYPH_DEBUG != 0 */
8558 /***********************************************************************
8560 ***********************************************************************/
8563 /* Image types that rely on external libraries are loaded dynamically
8564 if the library is available. */
8565 #define CHECK_LIB_AVAILABLE(image_type, init_lib_fn, libraries) \
8566 define_image_type (image_type, init_lib_fn (libraries))
8568 #define CHECK_LIB_AVAILABLE(image_type, init_lib_fn, libraries) \
8569 define_image_type (image_type, 1)
8570 #endif /* HAVE_NTGUI */
8572 DEFUN ("init-image-library", Finit_image_library
, Sinit_image_library
, 2, 2, 0,
8573 doc
: /* Initialize image library implementing image type TYPE.
8574 Return non-nil if TYPE is a supported image type.
8576 Image types pbm and xbm are prebuilt; other types are loaded here.
8577 Libraries to load are specified in alist LIBRARIES (usually, the value
8578 of `image-library-alist', which see). */)
8580 Lisp_Object type
, libraries
;
8584 /* Don't try to reload the library. */
8585 tested
= Fassq (type
, Vimage_type_cache
);
8587 return XCDR (tested
);
8589 #if defined (HAVE_XPM) || defined (MAC_OS)
8590 if (EQ (type
, Qxpm
))
8591 return CHECK_LIB_AVAILABLE (&xpm_type
, init_xpm_functions
, libraries
);
8594 #if defined (HAVE_JPEG) || defined (MAC_OS)
8595 if (EQ (type
, Qjpeg
))
8596 return CHECK_LIB_AVAILABLE (&jpeg_type
, init_jpeg_functions
, libraries
);
8599 #if defined (HAVE_TIFF) || defined (MAC_OS)
8600 if (EQ (type
, Qtiff
))
8601 return CHECK_LIB_AVAILABLE (&tiff_type
, init_tiff_functions
, libraries
);
8604 #if defined (HAVE_GIF) || defined (MAC_OS)
8605 if (EQ (type
, Qgif
))
8606 return CHECK_LIB_AVAILABLE (&gif_type
, init_gif_functions
, libraries
);
8609 #if defined (HAVE_PNG) || defined (MAC_OS)
8610 if (EQ (type
, Qpng
))
8611 return CHECK_LIB_AVAILABLE (&png_type
, init_png_functions
, libraries
);
8614 #ifdef HAVE_GHOSTSCRIPT
8615 if (EQ (type
, Qpostscript
))
8616 return CHECK_LIB_AVAILABLE (&gs_type
, init_gs_functions
, libraries
);
8619 /* If the type is not recognized, avoid testing it ever again. */
8620 CACHE_IMAGE_TYPE (type
, Qnil
);
8627 extern Lisp_Object Qrisky_local_variable
; /* Syms_of_xdisp has already run. */
8629 /* Initialize this only once, since that's what we do with Vimage_types
8630 and they are supposed to be in sync. Initializing here gives correct
8631 operation on GNU/Linux of calling dump-emacs after loading some images. */
8634 /* Must be defined now becase we're going to update it below, while
8635 defining the supported image types. */
8636 DEFVAR_LISP ("image-types", &Vimage_types
,
8637 doc
: /* List of potentially supported image types.
8638 Each element of the list is a symbol for an image type, like 'jpeg or 'png.
8639 To check whether it is really supported, use `image-type-available-p'. */);
8640 Vimage_types
= Qnil
;
8642 DEFVAR_LISP ("image-library-alist", &Vimage_library_alist
,
8643 doc
: /* Alist of image types vs external libraries needed to display them.
8645 Each element is a list (IMAGE-TYPE LIBRARY...), where the car is a symbol
8646 representing a supported image type, and the rest are strings giving
8647 alternate filenames for the corresponding external libraries.
8649 Emacs tries to load the libraries in the order they appear on the
8650 list; if none is loaded, the running session of Emacs won't
8651 support the image type. Types 'pbm and 'xbm don't need to be
8652 listed; they are always supported. */);
8653 Vimage_library_alist
= Qnil
;
8654 Fput (intern ("image-library-alist"), Qrisky_local_variable
, Qt
);
8656 DEFVAR_LISP ("max-image-size", &Vmax_image_size
,
8657 doc
: /* Maximum size of images.
8658 Emacs will not load an image into memory if its pixel width or
8659 pixel height exceeds this limit.
8661 If the value is an integer, it directly specifies the maximum
8662 image height and width, measured in pixels. If it is a floating
8663 point number, it specifies the maximum image height and width
8664 as a ratio to the frame height and width. If the value is
8665 non-numeric, there is no explicit limit on the size of images. */);
8666 Vmax_image_size
= make_float (MAX_IMAGE_SIZE
);
8668 Vimage_type_cache
= Qnil
;
8669 staticpro (&Vimage_type_cache
);
8671 Qpbm
= intern ("pbm");
8673 ADD_IMAGE_TYPE(Qpbm
);
8675 Qxbm
= intern ("xbm");
8677 ADD_IMAGE_TYPE(Qxbm
);
8679 define_image_type (&xbm_type
, 1);
8680 define_image_type (&pbm_type
, 1);
8682 QCascent
= intern (":ascent");
8683 staticpro (&QCascent
);
8684 QCmargin
= intern (":margin");
8685 staticpro (&QCmargin
);
8686 QCrelief
= intern (":relief");
8687 staticpro (&QCrelief
);
8688 QCconversion
= intern (":conversion");
8689 staticpro (&QCconversion
);
8690 QCcolor_symbols
= intern (":color-symbols");
8691 staticpro (&QCcolor_symbols
);
8692 QCheuristic_mask
= intern (":heuristic-mask");
8693 staticpro (&QCheuristic_mask
);
8694 QCindex
= intern (":index");
8695 staticpro (&QCindex
);
8696 QCmatrix
= intern (":matrix");
8697 staticpro (&QCmatrix
);
8698 QCcolor_adjustment
= intern (":color-adjustment");
8699 staticpro (&QCcolor_adjustment
);
8700 QCmask
= intern (":mask");
8701 staticpro (&QCmask
);
8703 Qlaplace
= intern ("laplace");
8704 staticpro (&Qlaplace
);
8705 Qemboss
= intern ("emboss");
8706 staticpro (&Qemboss
);
8707 Qedge_detection
= intern ("edge-detection");
8708 staticpro (&Qedge_detection
);
8709 Qheuristic
= intern ("heuristic");
8710 staticpro (&Qheuristic
);
8712 Qpostscript
= intern ("postscript");
8713 staticpro (&Qpostscript
);
8714 #ifdef HAVE_GHOSTSCRIPT
8715 ADD_IMAGE_TYPE(Qpostscript
);
8716 QCloader
= intern (":loader");
8717 staticpro (&QCloader
);
8718 QCbounding_box
= intern (":bounding-box");
8719 staticpro (&QCbounding_box
);
8720 QCpt_width
= intern (":pt-width");
8721 staticpro (&QCpt_width
);
8722 QCpt_height
= intern (":pt-height");
8723 staticpro (&QCpt_height
);
8724 #endif /* HAVE_GHOSTSCRIPT */
8726 #if defined (HAVE_XPM) || defined (MAC_OS)
8727 Qxpm
= intern ("xpm");
8729 ADD_IMAGE_TYPE(Qxpm
);
8732 #if defined (HAVE_JPEG) || defined (MAC_OS)
8733 Qjpeg
= intern ("jpeg");
8735 ADD_IMAGE_TYPE(Qjpeg
);
8738 #if defined (HAVE_TIFF) || defined (MAC_OS)
8739 Qtiff
= intern ("tiff");
8741 ADD_IMAGE_TYPE(Qtiff
);
8744 #if defined (HAVE_GIF) || defined (MAC_OS)
8745 Qgif
= intern ("gif");
8747 ADD_IMAGE_TYPE(Qgif
);
8750 #if defined (HAVE_PNG) || defined (MAC_OS)
8751 Qpng
= intern ("png");
8753 ADD_IMAGE_TYPE(Qpng
);
8756 defsubr (&Sinit_image_library
);
8757 defsubr (&Sclear_image_cache
);
8758 defsubr (&Simage_refresh
);
8759 defsubr (&Simage_size
);
8760 defsubr (&Simage_mask_p
);
8761 defsubr (&Simage_extension_data
);
8765 defsubr (&Slookup_image
);
8768 DEFVAR_BOOL ("cross-disabled-images", &cross_disabled_images
,
8769 doc
: /* Non-nil means always draw a cross over disabled images.
8770 Disabled images are those having a `:conversion disabled' property.
8771 A cross is always drawn on black & white displays. */);
8772 cross_disabled_images
= 0;
8774 DEFVAR_LISP ("x-bitmap-file-path", &Vx_bitmap_file_path
,
8775 doc
: /* List of directories to search for window system bitmap files. */);
8776 Vx_bitmap_file_path
= decode_env_path ((char *) 0, PATH_BITMAPS
);
8778 DEFVAR_LISP ("image-cache-eviction-delay", &Vimage_cache_eviction_delay
,
8779 doc
: /* Time after which cached images are removed from the cache.
8780 When an image has not been displayed this many seconds, remove it
8781 from the image cache. Value must be an integer or nil with nil
8782 meaning don't clear the cache. */);
8783 Vimage_cache_eviction_delay
= make_number (30 * 60);
8789 #if defined (MAC_OSX) && TARGET_API_MAC_CARBON
8790 init_image_func_pointer ();
8794 /* arch-tag: 123c2a5e-14a8-4c53-ab95-af47d7db49b9
8795 (do not change this comment) */