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 2, or (at your option)
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 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 Lisp_Object specified_bg
= image_spec_value (spec
, QCbackground
, NULL
);
1646 int i
= hash
% IMAGE_CACHE_BUCKETS_SIZE
;
1648 /* If the image spec does not specify a background color, the cached
1649 image must have the same background color as the current frame.
1650 The following code be improved. For example, jpeg does not
1651 support transparency, but currently a jpeg image spec won't match
1652 a cached spec created with a different frame background. The
1653 extra memory usage is probably negligible in practice. */
1654 if (!c
) return NULL
;
1656 for (img
= c
->buckets
[i
]; img
; img
= img
->next
)
1657 if (img
->hash
== hash
1658 && !NILP (Fequal (img
->spec
, spec
))
1659 && (STRINGP (specified_bg
)
1660 || img
->background
== FRAME_BACKGROUND_PIXEL (f
)))
1666 /* Search frame F for an image with spec SPEC, and free it. */
1669 uncache_image (f
, spec
)
1673 struct image
*img
= search_image_cache (f
, spec
, sxhash (spec
, 0));
1675 free_image (f
, img
);
1679 /* Free image cache of frame F. Be aware that X frames share images
1683 free_image_cache (f
)
1686 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
1691 /* Cache should not be referenced by any frame when freed. */
1692 xassert (c
->refcount
== 0);
1694 for (i
= 0; i
< c
->used
; ++i
)
1695 free_image (f
, c
->images
[i
]);
1699 FRAME_X_IMAGE_CACHE (f
) = NULL
;
1704 /* Clear image cache of frame F. FORCE_P non-zero means free all
1705 images. FORCE_P zero means clear only images that haven't been
1706 displayed for some time. Should be called from time to time to
1707 reduce the number of loaded images. If image-eviction-seconds is
1708 non-nil, this frees images in the cache which weren't displayed for
1709 at least that many seconds. */
1712 clear_image_cache (f
, force_p
)
1716 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
1718 if (c
&& INTEGERP (Vimage_cache_eviction_delay
))
1725 old
= EMACS_SECS (t
) - XFASTINT (Vimage_cache_eviction_delay
);
1727 /* Block input so that we won't be interrupted by a SIGIO
1728 while being in an inconsistent state. */
1731 for (i
= nfreed
= 0; i
< c
->used
; ++i
)
1733 struct image
*img
= c
->images
[i
];
1735 && (force_p
|| img
->timestamp
< old
))
1737 free_image (f
, img
);
1742 /* We may be clearing the image cache because, for example,
1743 Emacs was iconified for a longer period of time. In that
1744 case, current matrices may still contain references to
1745 images freed above. So, clear these matrices. */
1748 Lisp_Object tail
, frame
;
1750 FOR_EACH_FRAME (tail
, frame
)
1752 struct frame
*f
= XFRAME (frame
);
1753 if (FRAME_WINDOW_P (f
)
1754 && FRAME_X_IMAGE_CACHE (f
) == c
)
1755 clear_current_matrices (f
);
1758 ++windows_or_buffers_changed
;
1766 DEFUN ("clear-image-cache", Fclear_image_cache
, Sclear_image_cache
,
1768 doc
: /* Clear the image cache of FRAME.
1769 FRAME nil or omitted means use the selected frame.
1770 FRAME t means clear the image caches of all frames. */)
1778 FOR_EACH_FRAME (tail
, frame
)
1779 if (FRAME_WINDOW_P (XFRAME (frame
)))
1780 clear_image_cache (XFRAME (frame
), 1);
1783 clear_image_cache (check_x_frame (frame
), 1);
1789 DEFUN ("image-refresh", Fimage_refresh
, Simage_refresh
,
1791 doc
: /* Refresh the image with specification SPEC on frame FRAME.
1792 If SPEC specifies an image file, the displayed image is updated with
1793 the current contents of that file.
1794 FRAME nil or omitted means use the selected frame.
1795 FRAME t means refresh the image on all frames. */)
1797 Lisp_Object spec
, frame
;
1799 if (!valid_image_p (spec
))
1800 error ("Invalid image specification");
1805 FOR_EACH_FRAME (tail
, frame
)
1807 struct frame
*f
= XFRAME (frame
);
1808 if (FRAME_WINDOW_P (f
))
1809 uncache_image (f
, spec
);
1813 uncache_image (check_x_frame (frame
), spec
);
1819 /* Compute masks and transform image IMG on frame F, as specified
1820 by the image's specification, */
1823 postprocess_image (f
, img
)
1827 /* Manipulation of the image's mask. */
1830 Lisp_Object conversion
, spec
;
1835 /* `:heuristic-mask t'
1837 means build a mask heuristically.
1838 `:heuristic-mask (R G B)'
1839 `:mask (heuristic (R G B))'
1840 means build a mask from color (R G B) in the
1843 means remove a mask, if any. */
1845 mask
= image_spec_value (spec
, QCheuristic_mask
, NULL
);
1847 x_build_heuristic_mask (f
, img
, mask
);
1852 mask
= image_spec_value (spec
, QCmask
, &found_p
);
1854 if (EQ (mask
, Qheuristic
))
1855 x_build_heuristic_mask (f
, img
, Qt
);
1856 else if (CONSP (mask
)
1857 && EQ (XCAR (mask
), Qheuristic
))
1859 if (CONSP (XCDR (mask
)))
1860 x_build_heuristic_mask (f
, img
, XCAR (XCDR (mask
)));
1862 x_build_heuristic_mask (f
, img
, XCDR (mask
));
1864 else if (NILP (mask
) && found_p
&& img
->mask
)
1866 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
1867 img
->mask
= NO_PIXMAP
;
1872 /* Should we apply an image transformation algorithm? */
1873 conversion
= image_spec_value (spec
, QCconversion
, NULL
);
1874 if (EQ (conversion
, Qdisabled
))
1875 x_disable_image (f
, img
);
1876 else if (EQ (conversion
, Qlaplace
))
1878 else if (EQ (conversion
, Qemboss
))
1880 else if (CONSP (conversion
)
1881 && EQ (XCAR (conversion
), Qedge_detection
))
1884 tem
= XCDR (conversion
);
1886 x_edge_detection (f
, img
,
1887 Fplist_get (tem
, QCmatrix
),
1888 Fplist_get (tem
, QCcolor_adjustment
));
1894 /* Return the id of image with Lisp specification SPEC on frame F.
1895 SPEC must be a valid Lisp image specification (see valid_image_p). */
1898 lookup_image (f
, spec
)
1904 struct gcpro gcpro1
;
1907 /* F must be a window-system frame, and SPEC must be a valid image
1909 xassert (FRAME_WINDOW_P (f
));
1910 xassert (valid_image_p (spec
));
1914 /* Look up SPEC in the hash table of the image cache. */
1915 hash
= sxhash (spec
, 0);
1916 img
= search_image_cache (f
, spec
, hash
);
1917 if (img
&& img
->load_failed_p
)
1919 free_image (f
, img
);
1923 /* If not found, create a new image and cache it. */
1926 extern Lisp_Object Qpostscript
;
1929 img
= make_image (spec
, hash
);
1930 cache_image (f
, img
);
1931 img
->load_failed_p
= img
->type
->load (f
, img
) == 0;
1933 /* If we can't load the image, and we don't have a width and
1934 height, use some arbitrary width and height so that we can
1935 draw a rectangle for it. */
1936 if (img
->load_failed_p
)
1940 value
= image_spec_value (spec
, QCwidth
, NULL
);
1941 img
->width
= (INTEGERP (value
)
1942 ? XFASTINT (value
) : DEFAULT_IMAGE_WIDTH
);
1943 value
= image_spec_value (spec
, QCheight
, NULL
);
1944 img
->height
= (INTEGERP (value
)
1945 ? XFASTINT (value
) : DEFAULT_IMAGE_HEIGHT
);
1949 /* Handle image type independent image attributes
1950 `:ascent ASCENT', `:margin MARGIN', `:relief RELIEF',
1951 `:background COLOR'. */
1952 Lisp_Object ascent
, margin
, relief
, bg
;
1954 ascent
= image_spec_value (spec
, QCascent
, NULL
);
1955 if (INTEGERP (ascent
))
1956 img
->ascent
= XFASTINT (ascent
);
1957 else if (EQ (ascent
, Qcenter
))
1958 img
->ascent
= CENTERED_IMAGE_ASCENT
;
1960 margin
= image_spec_value (spec
, QCmargin
, NULL
);
1961 if (INTEGERP (margin
) && XINT (margin
) >= 0)
1962 img
->vmargin
= img
->hmargin
= XFASTINT (margin
);
1963 else if (CONSP (margin
) && INTEGERP (XCAR (margin
))
1964 && INTEGERP (XCDR (margin
)))
1966 if (XINT (XCAR (margin
)) > 0)
1967 img
->hmargin
= XFASTINT (XCAR (margin
));
1968 if (XINT (XCDR (margin
)) > 0)
1969 img
->vmargin
= XFASTINT (XCDR (margin
));
1972 relief
= image_spec_value (spec
, QCrelief
, NULL
);
1973 if (INTEGERP (relief
))
1975 img
->relief
= XINT (relief
);
1976 img
->hmargin
+= abs (img
->relief
);
1977 img
->vmargin
+= abs (img
->relief
);
1980 if (! img
->background_valid
)
1982 bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
1986 = x_alloc_image_color (f
, img
, bg
,
1987 FRAME_BACKGROUND_PIXEL (f
));
1988 img
->background_valid
= 1;
1992 /* Do image transformations and compute masks, unless we
1993 don't have the image yet. */
1994 if (!EQ (*img
->type
->type
, Qpostscript
))
1995 postprocess_image (f
, img
);
2001 /* We're using IMG, so set its timestamp to `now'. */
2002 EMACS_GET_TIME (now
);
2003 img
->timestamp
= EMACS_SECS (now
);
2007 /* Value is the image id. */
2012 /* Cache image IMG in the image cache of frame F. */
2015 cache_image (f
, img
)
2019 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
2022 /* Find a free slot in c->images. */
2023 for (i
= 0; i
< c
->used
; ++i
)
2024 if (c
->images
[i
] == NULL
)
2027 /* If no free slot found, maybe enlarge c->images. */
2028 if (i
== c
->used
&& c
->used
== c
->size
)
2031 c
->images
= (struct image
**) xrealloc (c
->images
,
2032 c
->size
* sizeof *c
->images
);
2035 /* Add IMG to c->images, and assign IMG an id. */
2041 /* Add IMG to the cache's hash table. */
2042 i
= img
->hash
% IMAGE_CACHE_BUCKETS_SIZE
;
2043 img
->next
= c
->buckets
[i
];
2045 img
->next
->prev
= img
;
2047 c
->buckets
[i
] = img
;
2051 /* Call FN on every image in the image cache of frame F. Used to mark
2052 Lisp Objects in the image cache. */
2055 forall_images_in_image_cache (f
, fn
)
2057 void (*fn
) P_ ((struct image
*img
));
2059 if (FRAME_LIVE_P (f
) && FRAME_WINDOW_P (f
))
2061 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
2065 for (i
= 0; i
< c
->used
; ++i
)
2074 /***********************************************************************
2075 X / MAC / W32 support code
2076 ***********************************************************************/
2080 /* Macro for defining functions that will be loaded from image DLLs. */
2081 #define DEF_IMGLIB_FN(func) int (FAR CDECL *fn_##func)()
2083 /* Macro for loading those image functions from the library. */
2084 #define LOAD_IMGLIB_FN(lib,func) { \
2085 fn_##func = (void *) GetProcAddress (lib, #func); \
2086 if (!fn_##func) return 0; \
2089 /* Load a DLL implementing an image type.
2090 The `image-library-alist' variable associates a symbol,
2091 identifying an image type, to a list of possible filenames.
2092 The function returns NULL if no library could be loaded for
2093 the given image type, or if the library was previously loaded;
2094 else the handle of the DLL. */
2096 w32_delayed_load (Lisp_Object libraries
, Lisp_Object type
)
2098 HMODULE library
= NULL
;
2100 if (CONSP (libraries
) && NILP (Fassq (type
, Vimage_type_cache
)))
2102 Lisp_Object dlls
= Fassq (type
, libraries
);
2105 for (dlls
= XCDR (dlls
); CONSP (dlls
); dlls
= XCDR (dlls
))
2107 CHECK_STRING_CAR (dlls
);
2108 if (library
= LoadLibrary (SDATA (XCAR (dlls
))))
2116 #endif /* HAVE_NTGUI */
2118 static int x_create_x_image_and_pixmap
P_ ((struct frame
*, int, int, int,
2119 XImagePtr
*, Pixmap
*));
2120 static void x_destroy_x_image
P_ ((XImagePtr
));
2121 static void x_put_x_image
P_ ((struct frame
*, XImagePtr
, Pixmap
, int, int));
2124 /* Create an XImage and a pixmap of size WIDTH x HEIGHT for use on
2125 frame F. Set *XIMG and *PIXMAP to the XImage and Pixmap created.
2126 Set (*XIMG)->data to a raster of WIDTH x HEIGHT pixels allocated
2127 via xmalloc. Print error messages via image_error if an error
2128 occurs. Value is non-zero if successful.
2130 On W32, a DEPTH of zero signifies a 24 bit image, otherwise DEPTH
2131 should indicate the bit depth of the image. */
2134 x_create_x_image_and_pixmap (f
, width
, height
, depth
, ximg
, pixmap
)
2136 int width
, height
, depth
;
2140 #ifdef HAVE_X_WINDOWS
2141 Display
*display
= FRAME_X_DISPLAY (f
);
2142 Window window
= FRAME_X_WINDOW (f
);
2143 Screen
*screen
= FRAME_X_SCREEN (f
);
2145 xassert (interrupt_input_blocked
);
2148 depth
= DefaultDepthOfScreen (screen
);
2149 *ximg
= XCreateImage (display
, DefaultVisualOfScreen (screen
),
2150 depth
, ZPixmap
, 0, NULL
, width
, height
,
2151 depth
> 16 ? 32 : depth
> 8 ? 16 : 8, 0);
2154 image_error ("Unable to allocate X image", Qnil
, Qnil
);
2158 /* Allocate image raster. */
2159 (*ximg
)->data
= (char *) xmalloc ((*ximg
)->bytes_per_line
* height
);
2161 /* Allocate a pixmap of the same size. */
2162 *pixmap
= XCreatePixmap (display
, window
, width
, height
, depth
);
2163 if (*pixmap
== NO_PIXMAP
)
2165 x_destroy_x_image (*ximg
);
2167 image_error ("Unable to create X pixmap", Qnil
, Qnil
);
2172 #endif /* HAVE_X_WINDOWS */
2176 BITMAPINFOHEADER
*header
;
2178 int scanline_width_bits
;
2180 int palette_colors
= 0;
2185 if (depth
!= 1 && depth
!= 4 && depth
!= 8
2186 && depth
!= 16 && depth
!= 24 && depth
!= 32)
2188 image_error ("Invalid image bit depth specified", Qnil
, Qnil
);
2192 scanline_width_bits
= width
* depth
;
2193 remainder
= scanline_width_bits
% 32;
2196 scanline_width_bits
+= 32 - remainder
;
2198 /* Bitmaps with a depth less than 16 need a palette. */
2199 /* BITMAPINFO structure already contains the first RGBQUAD. */
2201 palette_colors
= 1 << depth
- 1;
2203 *ximg
= xmalloc (sizeof (XImage
) + palette_colors
* sizeof (RGBQUAD
));
2206 image_error ("Unable to allocate memory for XImage", Qnil
, Qnil
);
2210 header
= &((*ximg
)->info
.bmiHeader
);
2211 bzero (&((*ximg
)->info
), sizeof (BITMAPINFO
));
2212 header
->biSize
= sizeof (*header
);
2213 header
->biWidth
= width
;
2214 header
->biHeight
= -height
; /* negative indicates a top-down bitmap. */
2215 header
->biPlanes
= 1;
2216 header
->biBitCount
= depth
;
2217 header
->biCompression
= BI_RGB
;
2218 header
->biClrUsed
= palette_colors
;
2220 /* TODO: fill in palette. */
2223 (*ximg
)->info
.bmiColors
[0].rgbBlue
= 0;
2224 (*ximg
)->info
.bmiColors
[0].rgbGreen
= 0;
2225 (*ximg
)->info
.bmiColors
[0].rgbRed
= 0;
2226 (*ximg
)->info
.bmiColors
[0].rgbReserved
= 0;
2227 (*ximg
)->info
.bmiColors
[1].rgbBlue
= 255;
2228 (*ximg
)->info
.bmiColors
[1].rgbGreen
= 255;
2229 (*ximg
)->info
.bmiColors
[1].rgbRed
= 255;
2230 (*ximg
)->info
.bmiColors
[1].rgbReserved
= 0;
2233 hdc
= get_frame_dc (f
);
2235 /* Create a DIBSection and raster array for the bitmap,
2236 and store its handle in *pixmap. */
2237 *pixmap
= CreateDIBSection (hdc
, &((*ximg
)->info
),
2238 (depth
< 16) ? DIB_PAL_COLORS
: DIB_RGB_COLORS
,
2239 /* casting avoids a GCC warning */
2240 (void **)&((*ximg
)->data
), NULL
, 0);
2242 /* Realize display palette and garbage all frames. */
2243 release_frame_dc (f
, hdc
);
2245 if (*pixmap
== NULL
)
2247 DWORD err
= GetLastError();
2248 Lisp_Object errcode
;
2249 /* All system errors are < 10000, so the following is safe. */
2250 XSETINT (errcode
, (int) err
);
2251 image_error ("Unable to create bitmap, error code %d", errcode
, Qnil
);
2252 x_destroy_x_image (*ximg
);
2258 #endif /* HAVE_NTGUI */
2261 Display
*display
= FRAME_X_DISPLAY (f
);
2262 Window window
= FRAME_X_WINDOW (f
);
2264 xassert (interrupt_input_blocked
);
2266 /* Allocate a pixmap of the same size. */
2267 *pixmap
= XCreatePixmap (display
, window
, width
, height
, depth
);
2268 if (*pixmap
== NO_PIXMAP
)
2271 image_error ("Unable to create X pixmap", Qnil
, Qnil
);
2275 LockPixels (GetGWorldPixMap (*pixmap
));
2283 /* Destroy XImage XIMG. Free XIMG->data. */
2286 x_destroy_x_image (ximg
)
2289 xassert (interrupt_input_blocked
);
2292 #ifdef HAVE_X_WINDOWS
2295 XDestroyImage (ximg
);
2296 #endif /* HAVE_X_WINDOWS */
2298 /* Data will be freed by DestroyObject. */
2301 #endif /* HAVE_NTGUI */
2303 XDestroyImage (ximg
);
2309 /* Put XImage XIMG into pixmap PIXMAP on frame F. WIDTH and HEIGHT
2310 are width and height of both the image and pixmap. */
2313 x_put_x_image (f
, ximg
, pixmap
, width
, height
)
2319 #ifdef HAVE_X_WINDOWS
2322 xassert (interrupt_input_blocked
);
2323 gc
= XCreateGC (FRAME_X_DISPLAY (f
), pixmap
, 0, NULL
);
2324 XPutImage (FRAME_X_DISPLAY (f
), pixmap
, gc
, ximg
, 0, 0, 0, 0, width
, height
);
2325 XFreeGC (FRAME_X_DISPLAY (f
), gc
);
2326 #endif /* HAVE_X_WINDOWS */
2329 #if 0 /* I don't think this is necessary looking at where it is used. */
2330 HDC hdc
= get_frame_dc (f
);
2331 SetDIBits (hdc
, pixmap
, 0, height
, ximg
->data
, &(ximg
->info
), DIB_RGB_COLORS
);
2332 release_frame_dc (f
, hdc
);
2334 #endif /* HAVE_NTGUI */
2337 xassert (ximg
== pixmap
);
2342 /***********************************************************************
2344 ***********************************************************************/
2346 static unsigned char *slurp_file
P_ ((char *, int *));
2349 /* Find image file FILE. Look in data-directory, then
2350 x-bitmap-file-path. Value is the encoded full name of the file
2351 found, or nil if not found. */
2354 x_find_image_file (file
)
2357 Lisp_Object file_found
, search_path
;
2358 struct gcpro gcpro1
, gcpro2
;
2362 search_path
= Fcons (Vdata_directory
, Vx_bitmap_file_path
);
2363 GCPRO2 (file_found
, search_path
);
2365 /* Try to find FILE in data-directory, then x-bitmap-file-path. */
2366 fd
= openp (search_path
, file
, Qnil
, &file_found
, Qnil
);
2372 file_found
= ENCODE_FILE (file_found
);
2381 /* Read FILE into memory. Value is a pointer to a buffer allocated
2382 with xmalloc holding FILE's contents. Value is null if an error
2383 occurred. *SIZE is set to the size of the file. */
2385 static unsigned char *
2386 slurp_file (file
, size
)
2391 unsigned char *buf
= NULL
;
2394 if (stat (file
, &st
) == 0
2395 && (fp
= fopen (file
, "rb")) != NULL
2396 && (buf
= (unsigned char *) xmalloc (st
.st_size
),
2397 fread (buf
, 1, st
.st_size
, fp
) == st
.st_size
))
2420 /***********************************************************************
2421 MAC Image Load Functions
2422 ***********************************************************************/
2424 static int image_load_quicktime
P_ ((struct frame
*, struct image
*img
,
2427 static int image_load_quartz2d
P_ ((struct frame
*, struct image
*img
, int));
2431 find_image_fsspec (specified_file
, file
, fss
)
2432 Lisp_Object specified_file
, *file
;
2438 *file
= x_find_image_file (specified_file
);
2439 if (!STRINGP (*file
))
2440 return fnfErr
; /* file or directory not found;
2441 incomplete pathname */
2442 /* Try to open the image file. */
2443 err
= AECoercePtr (TYPE_FILE_NAME
, SDATA (*file
),
2444 SBYTES (*file
), typeFSS
, &desc
);
2447 #if TARGET_API_MAC_CARBON
2448 err
= AEGetDescData (&desc
, fss
, sizeof (FSSpec
));
2450 *fss
= *(FSSpec
*)(*(desc
.dataHandle
));
2452 AEDisposeDesc (&desc
);
2458 image_load_qt_1 (f
, img
, type
, fss
, dh
)
2465 ComponentResult err
;
2466 GraphicsImportComponent gi
;
2469 ImageDescriptionHandle desc_handle
;
2470 short draw_all_pixels
;
2471 Lisp_Object specified_bg
;
2476 err
= OpenADefaultComponent (GraphicsImporterComponentType
, type
, &gi
);
2479 image_error ("Cannot get importer component for `%s'", img
->spec
, Qnil
);
2484 /* read from file system spec */
2485 err
= GraphicsImportSetDataFile (gi
, fss
);
2488 image_error ("Cannot set fsspec to graphics importer for '%s'",
2495 /* read from data handle */
2496 err
= GraphicsImportSetDataHandle (gi
, dh
);
2499 image_error ("Cannot set data handle to graphics importer for `%s'",
2504 err
= GraphicsImportGetImageDescription (gi
, &desc_handle
);
2505 if (err
!= noErr
|| desc_handle
== NULL
)
2507 image_error ("Error reading `%s'", img
->spec
, Qnil
);
2510 width
= img
->width
= (*desc_handle
)->width
;
2511 height
= img
->height
= (*desc_handle
)->height
;
2512 DisposeHandle ((Handle
)desc_handle
);
2514 if (!check_image_size (f
, width
, height
))
2516 image_error ("Invalid image size", Qnil
, Qnil
);
2520 err
= GraphicsImportDoesDrawAllPixels (gi
, &draw_all_pixels
);
2522 /* Don't check the error code here. It may have an undocumented
2526 image_error ("Error reading `%s'", img
->spec
, Qnil
);
2530 if (draw_all_pixels
!= graphicsImporterDrawsAllPixels
)
2532 specified_bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
2533 if (!STRINGP (specified_bg
) ||
2534 !mac_defined_color (f
, SDATA (specified_bg
), &color
, 0))
2536 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
2537 color
.red
= RED16_FROM_ULONG (color
.pixel
);
2538 color
.green
= GREEN16_FROM_ULONG (color
.pixel
);
2539 color
.blue
= BLUE16_FROM_ULONG (color
.pixel
);
2543 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
2545 if (draw_all_pixels
!= graphicsImporterDrawsAllPixels
)
2550 GetGWorld (&old_port
, &old_gdh
);
2551 SetGWorld (ximg
, NULL
);
2552 bg_color
.red
= color
.red
;
2553 bg_color
.green
= color
.green
;
2554 bg_color
.blue
= color
.blue
;
2555 RGBBackColor (&bg_color
);
2556 #if TARGET_API_MAC_CARBON
2557 GetPortBounds (ximg
, &rect
);
2560 EraseRect (&(ximg
->portRect
));
2562 SetGWorld (old_port
, old_gdh
);
2564 GraphicsImportSetGWorld (gi
, ximg
, NULL
);
2565 GraphicsImportDraw (gi
);
2566 CloseComponent (gi
);
2568 /* Maybe fill in the background field while we have ximg handy. */
2569 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
2570 IMAGE_BACKGROUND (img
, f
, ximg
);
2572 /* Put the image into the pixmap. */
2573 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
2574 x_destroy_x_image (ximg
);
2578 CloseComponent (gi
);
2583 /* Load an image using the QuickTime Graphics Importer.
2584 Note: The alpha channel does not work for PNG images. */
2586 image_load_quicktime (f
, img
, type
)
2591 Lisp_Object specified_file
;
2592 Lisp_Object specified_data
;
2595 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
2596 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
2598 if (NILP (specified_data
))
2600 /* Read from a file */
2604 err
= find_image_fsspec (specified_file
, &file
, &fss
);
2608 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
2610 image_error ("Cannot open `%s'", file
, Qnil
);
2613 return image_load_qt_1 (f
, img
, type
, &fss
, NULL
);
2617 /* Memory source! */
2621 err
= PtrToHand (SDATA (specified_data
), &dh
, SBYTES (specified_data
));
2624 image_error ("Cannot allocate data handle for `%s'",
2628 success_p
= image_load_qt_1 (f
, img
, type
, NULL
, dh
);
2636 /* Load a PNG/JPEG image using Quartz 2D decoding routines.
2637 CGImageCreateWithPNGDataProvider is provided after Mac OS X 10.2.
2638 So don't use this function directly but determine at runtime
2639 whether it exists. */
2640 typedef CGImageRef (*CGImageCreateWithPNGDataProviderProcType
)
2641 (CGDataProviderRef
, const float [], bool, CGColorRenderingIntent
);
2642 static CGImageCreateWithPNGDataProviderProcType MyCGImageCreateWithPNGDataProvider
;
2646 init_image_func_pointer ()
2648 if (NSIsSymbolNameDefined ("_CGImageCreateWithPNGDataProvider"))
2650 MyCGImageCreateWithPNGDataProvider
2651 = (CGImageCreateWithPNGDataProviderProcType
)
2652 NSAddressOfSymbol (NSLookupAndBindSymbol
2653 ("_CGImageCreateWithPNGDataProvider"));
2656 MyCGImageCreateWithPNGDataProvider
= NULL
;
2661 image_load_quartz2d (f
, img
, png_p
)
2666 Lisp_Object file
, specified_file
;
2667 Lisp_Object specified_data
, specified_bg
;
2668 struct gcpro gcpro1
;
2669 CGDataProviderRef source
;
2673 XImagePtr ximg
= NULL
;
2674 CGContextRef context
;
2677 /* Open the file. */
2678 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
2679 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
2684 if (NILP (specified_data
))
2689 file
= x_find_image_file (specified_file
);
2690 if (!STRINGP (file
))
2692 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
2696 path
= cfstring_create_with_utf8_cstring (SDATA (file
));
2697 url
= CFURLCreateWithFileSystemPath (NULL
, path
,
2698 kCFURLPOSIXPathStyle
, 0);
2700 source
= CGDataProviderCreateWithURL (url
);
2704 source
= CGDataProviderCreateWithData (NULL
, SDATA (specified_data
),
2705 SBYTES (specified_data
), NULL
);
2708 image
= (*MyCGImageCreateWithPNGDataProvider
) (source
, NULL
, FALSE
,
2709 kCGRenderingIntentDefault
);
2711 image
= CGImageCreateWithJPEGDataProvider (source
, NULL
, FALSE
,
2712 kCGRenderingIntentDefault
);
2714 CGDataProviderRelease (source
);
2718 image_error ("Error reading image `%s'", img
->spec
, Qnil
);
2721 width
= img
->width
= CGImageGetWidth (image
);
2722 height
= img
->height
= CGImageGetHeight (image
);
2724 if (!check_image_size (f
, width
, height
))
2726 CGImageRelease (image
);
2728 image_error ("Invalid image size", Qnil
, Qnil
);
2734 specified_bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
2735 if (!STRINGP (specified_bg
) ||
2736 !mac_defined_color (f
, SDATA (specified_bg
), &color
, 0))
2738 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
2739 color
.red
= RED16_FROM_ULONG (color
.pixel
);
2740 color
.green
= GREEN16_FROM_ULONG (color
.pixel
);
2741 color
.blue
= BLUE16_FROM_ULONG (color
.pixel
);
2745 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
2747 CGImageRelease (image
);
2751 rectangle
= CGRectMake (0, 0, width
, height
);
2752 QDBeginCGContext (ximg
, &context
);
2755 CGContextSetRGBFillColor (context
, color
.red
/ 65535.0,
2756 color
.green
/ 65535.0,
2757 color
.blue
/ 65535.0, 1.0);
2758 CGContextFillRect (context
, rectangle
);
2760 CGContextDrawImage (context
, rectangle
, image
);
2761 QDEndCGContext (ximg
, &context
);
2762 CGImageRelease (image
);
2764 /* Maybe fill in the background field while we have ximg handy. */
2765 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
2766 IMAGE_BACKGROUND (img
, f
, ximg
);
2768 /* Put the image into the pixmap. */
2769 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
2770 x_destroy_x_image (ximg
);
2779 /***********************************************************************
2781 ***********************************************************************/
2783 static int xbm_scan
P_ ((unsigned char **, unsigned char *, char *, int *));
2784 static int xbm_load
P_ ((struct frame
*f
, struct image
*img
));
2785 static int xbm_load_image
P_ ((struct frame
*f
, struct image
*img
,
2786 unsigned char *, unsigned char *));
2787 static int xbm_image_p
P_ ((Lisp_Object object
));
2788 static int xbm_read_bitmap_data
P_ ((struct frame
*f
,
2789 unsigned char *, unsigned char *,
2790 int *, int *, unsigned char **));
2791 static int xbm_file_p
P_ ((Lisp_Object
));
2794 /* Indices of image specification fields in xbm_format, below. */
2796 enum xbm_keyword_index
2814 /* Vector of image_keyword structures describing the format
2815 of valid XBM image specifications. */
2817 static struct image_keyword xbm_format
[XBM_LAST
] =
2819 {":type", IMAGE_SYMBOL_VALUE
, 1},
2820 {":file", IMAGE_STRING_VALUE
, 0},
2821 {":width", IMAGE_POSITIVE_INTEGER_VALUE
, 0},
2822 {":height", IMAGE_POSITIVE_INTEGER_VALUE
, 0},
2823 {":data", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
2824 {":foreground", IMAGE_STRING_OR_NIL_VALUE
, 0},
2825 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0},
2826 {":ascent", IMAGE_ASCENT_VALUE
, 0},
2827 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
2828 {":relief", IMAGE_INTEGER_VALUE
, 0},
2829 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
2830 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
2831 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0}
2834 /* Structure describing the image type XBM. */
2836 static struct image_type xbm_type
=
2845 /* Tokens returned from xbm_scan. */
2854 /* Return non-zero if OBJECT is a valid XBM-type image specification.
2855 A valid specification is a list starting with the symbol `image'
2856 The rest of the list is a property list which must contain an
2859 If the specification specifies a file to load, it must contain
2860 an entry `:file FILENAME' where FILENAME is a string.
2862 If the specification is for a bitmap loaded from memory it must
2863 contain `:width WIDTH', `:height HEIGHT', and `:data DATA', where
2864 WIDTH and HEIGHT are integers > 0. DATA may be:
2866 1. a string large enough to hold the bitmap data, i.e. it must
2867 have a size >= (WIDTH + 7) / 8 * HEIGHT
2869 2. a bool-vector of size >= WIDTH * HEIGHT
2871 3. a vector of strings or bool-vectors, one for each line of the
2874 4. A string containing an in-memory XBM file. WIDTH and HEIGHT
2875 may not be specified in this case because they are defined in the
2878 Both the file and data forms may contain the additional entries
2879 `:background COLOR' and `:foreground COLOR'. If not present,
2880 foreground and background of the frame on which the image is
2881 displayed is used. */
2884 xbm_image_p (object
)
2887 struct image_keyword kw
[XBM_LAST
];
2889 bcopy (xbm_format
, kw
, sizeof kw
);
2890 if (!parse_image_spec (object
, kw
, XBM_LAST
, Qxbm
))
2893 xassert (EQ (kw
[XBM_TYPE
].value
, Qxbm
));
2895 if (kw
[XBM_FILE
].count
)
2897 if (kw
[XBM_WIDTH
].count
|| kw
[XBM_HEIGHT
].count
|| kw
[XBM_DATA
].count
)
2900 else if (kw
[XBM_DATA
].count
&& xbm_file_p (kw
[XBM_DATA
].value
))
2902 /* In-memory XBM file. */
2903 if (kw
[XBM_WIDTH
].count
|| kw
[XBM_HEIGHT
].count
|| kw
[XBM_FILE
].count
)
2911 /* Entries for `:width', `:height' and `:data' must be present. */
2912 if (!kw
[XBM_WIDTH
].count
2913 || !kw
[XBM_HEIGHT
].count
2914 || !kw
[XBM_DATA
].count
)
2917 data
= kw
[XBM_DATA
].value
;
2918 width
= XFASTINT (kw
[XBM_WIDTH
].value
);
2919 height
= XFASTINT (kw
[XBM_HEIGHT
].value
);
2921 /* Check type of data, and width and height against contents of
2927 /* Number of elements of the vector must be >= height. */
2928 if (XVECTOR (data
)->size
< height
)
2931 /* Each string or bool-vector in data must be large enough
2932 for one line of the image. */
2933 for (i
= 0; i
< height
; ++i
)
2935 Lisp_Object elt
= XVECTOR (data
)->contents
[i
];
2940 < (width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
)
2943 else if (BOOL_VECTOR_P (elt
))
2945 if (XBOOL_VECTOR (elt
)->size
< width
)
2952 else if (STRINGP (data
))
2955 < (width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
* height
)
2958 else if (BOOL_VECTOR_P (data
))
2960 if (XBOOL_VECTOR (data
)->size
< width
* height
)
2971 /* Scan a bitmap file. FP is the stream to read from. Value is
2972 either an enumerator from enum xbm_token, or a character for a
2973 single-character token, or 0 at end of file. If scanning an
2974 identifier, store the lexeme of the identifier in SVAL. If
2975 scanning a number, store its value in *IVAL. */
2978 xbm_scan (s
, end
, sval
, ival
)
2979 unsigned char **s
, *end
;
2987 /* Skip white space. */
2988 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
2993 else if (isdigit (c
))
2995 int value
= 0, digit
;
2997 if (c
== '0' && *s
< end
)
3000 if (c
== 'x' || c
== 'X')
3007 else if (c
>= 'a' && c
<= 'f')
3008 digit
= c
- 'a' + 10;
3009 else if (c
>= 'A' && c
<= 'F')
3010 digit
= c
- 'A' + 10;
3013 value
= 16 * value
+ digit
;
3016 else if (isdigit (c
))
3020 && (c
= *(*s
)++, isdigit (c
)))
3021 value
= 8 * value
+ c
- '0';
3028 && (c
= *(*s
)++, isdigit (c
)))
3029 value
= 10 * value
+ c
- '0';
3037 else if (isalpha (c
) || c
== '_')
3041 && (c
= *(*s
)++, (isalnum (c
) || c
== '_')))
3048 else if (c
== '/' && **s
== '*')
3050 /* C-style comment. */
3052 while (**s
&& (**s
!= '*' || *(*s
+ 1) != '/'))
3066 /* Create a Windows bitmap from X bitmap data. */
3068 w32_create_pixmap_from_bitmap_data (int width
, int height
, char *data
)
3070 static unsigned char swap_nibble
[16]
3071 = { 0x0, 0x8, 0x4, 0xc, /* 0000 1000 0100 1100 */
3072 0x2, 0xa, 0x6, 0xe, /* 0010 1010 0110 1110 */
3073 0x1, 0x9, 0x5, 0xd, /* 0001 1001 0101 1101 */
3074 0x3, 0xb, 0x7, 0xf }; /* 0011 1011 0111 1111 */
3076 unsigned char *bits
, *p
;
3079 w1
= (width
+ 7) / 8; /* nb of 8bits elt in X bitmap */
3080 w2
= ((width
+ 15) / 16) * 2; /* nb of 16bits elt in W32 bitmap */
3081 bits
= (unsigned char *) alloca (height
* w2
);
3082 bzero (bits
, height
* w2
);
3083 for (i
= 0; i
< height
; i
++)
3086 for (j
= 0; j
< w1
; j
++)
3088 /* Bitswap XBM bytes to match how Windows does things. */
3089 unsigned char c
= *data
++;
3090 *p
++ = (unsigned char)((swap_nibble
[c
& 0xf] << 4)
3091 | (swap_nibble
[(c
>>4) & 0xf]));
3094 bmp
= CreateBitmap (width
, height
, 1, 1, (char *) bits
);
3099 static void convert_mono_to_color_image (f
, img
, foreground
, background
)
3102 COLORREF foreground
, background
;
3104 HDC hdc
, old_img_dc
, new_img_dc
;
3105 HGDIOBJ old_prev
, new_prev
;
3108 hdc
= get_frame_dc (f
);
3109 old_img_dc
= CreateCompatibleDC (hdc
);
3110 new_img_dc
= CreateCompatibleDC (hdc
);
3111 new_pixmap
= CreateCompatibleBitmap (hdc
, img
->width
, img
->height
);
3112 release_frame_dc (f
, hdc
);
3113 old_prev
= SelectObject (old_img_dc
, img
->pixmap
);
3114 new_prev
= SelectObject (new_img_dc
, new_pixmap
);
3115 SetTextColor (new_img_dc
, foreground
);
3116 SetBkColor (new_img_dc
, background
);
3118 BitBlt (new_img_dc
, 0, 0, img
->width
, img
->height
, old_img_dc
,
3121 SelectObject (old_img_dc
, old_prev
);
3122 SelectObject (new_img_dc
, new_prev
);
3123 DeleteDC (old_img_dc
);
3124 DeleteDC (new_img_dc
);
3125 DeleteObject (img
->pixmap
);
3126 if (new_pixmap
== 0)
3127 fprintf (stderr
, "Failed to convert image to color.\n");
3129 img
->pixmap
= new_pixmap
;
3132 #define XBM_BIT_SHUFFLE(b) (~(b))
3136 #define XBM_BIT_SHUFFLE(b) (b)
3138 #endif /* HAVE_NTGUI */
3142 Create_Pixmap_From_Bitmap_Data(f
, img
, data
, fg
, bg
, non_default_colors
)
3146 RGB_PIXEL_COLOR fg
, bg
;
3147 int non_default_colors
;
3151 = w32_create_pixmap_from_bitmap_data (img
->width
, img
->height
, data
);
3153 /* If colors were specified, transfer the bitmap to a color one. */
3154 if (non_default_colors
)
3155 convert_mono_to_color_image (f
, img
, fg
, bg
);
3158 = XCreatePixmapFromBitmapData (FRAME_X_DISPLAY (f
),
3161 img
->width
, img
->height
,
3163 DefaultDepthOfScreen (FRAME_X_SCREEN (f
)));
3164 #endif /* HAVE_NTGUI */
3169 /* Replacement for XReadBitmapFileData which isn't available under old
3170 X versions. CONTENTS is a pointer to a buffer to parse; END is the
3171 buffer's end. Set *WIDTH and *HEIGHT to the width and height of
3172 the image. Return in *DATA the bitmap data allocated with xmalloc.
3173 Value is non-zero if successful. DATA null means just test if
3174 CONTENTS looks like an in-memory XBM file. */
3177 xbm_read_bitmap_data (f
, contents
, end
, width
, height
, data
)
3179 unsigned char *contents
, *end
;
3180 int *width
, *height
;
3181 unsigned char **data
;
3183 unsigned char *s
= contents
;
3184 char buffer
[BUFSIZ
];
3187 int bytes_per_line
, i
, nbytes
;
3193 LA1 = xbm_scan (&s, end, buffer, &value)
3195 #define expect(TOKEN) \
3196 if (LA1 != (TOKEN)) \
3201 #define expect_ident(IDENT) \
3202 if (LA1 == XBM_TK_IDENT && strcmp (buffer, (IDENT)) == 0) \
3207 *width
= *height
= -1;
3210 LA1
= xbm_scan (&s
, end
, buffer
, &value
);
3212 /* Parse defines for width, height and hot-spots. */
3216 expect_ident ("define");
3217 expect (XBM_TK_IDENT
);
3219 if (LA1
== XBM_TK_NUMBER
)
3221 char *p
= strrchr (buffer
, '_');
3222 p
= p
? p
+ 1 : buffer
;
3223 if (strcmp (p
, "width") == 0)
3225 else if (strcmp (p
, "height") == 0)
3228 expect (XBM_TK_NUMBER
);
3231 if (!check_image_size (f
, *width
, *height
))
3233 else if (data
== NULL
)
3236 /* Parse bits. Must start with `static'. */
3237 expect_ident ("static");
3238 if (LA1
== XBM_TK_IDENT
)
3240 if (strcmp (buffer
, "unsigned") == 0)
3243 expect_ident ("char");
3245 else if (strcmp (buffer
, "short") == 0)
3249 if (*width
% 16 && *width
% 16 < 9)
3252 else if (strcmp (buffer
, "char") == 0)
3260 expect (XBM_TK_IDENT
);
3266 bytes_per_line
= (*width
+ 7) / 8 + padding_p
;
3267 nbytes
= bytes_per_line
* *height
;
3268 p
= *data
= (unsigned char *) xmalloc (nbytes
);
3272 for (i
= 0; i
< nbytes
; i
+= 2)
3275 expect (XBM_TK_NUMBER
);
3277 *p
++ = XBM_BIT_SHUFFLE (val
);
3278 if (!padding_p
|| ((i
+ 2) % bytes_per_line
))
3279 *p
++ = XBM_BIT_SHUFFLE (value
>> 8);
3281 if (LA1
== ',' || LA1
== '}')
3289 for (i
= 0; i
< nbytes
; ++i
)
3292 expect (XBM_TK_NUMBER
);
3294 *p
++ = XBM_BIT_SHUFFLE (val
);
3296 if (LA1
== ',' || LA1
== '}')
3321 /* Load XBM image IMG which will be displayed on frame F from buffer
3322 CONTENTS. END is the end of the buffer. Value is non-zero if
3326 xbm_load_image (f
, img
, contents
, end
)
3329 unsigned char *contents
, *end
;
3332 unsigned char *data
;
3335 rc
= xbm_read_bitmap_data (f
, contents
, end
, &img
->width
, &img
->height
, &data
);
3338 unsigned long foreground
= FRAME_FOREGROUND_PIXEL (f
);
3339 unsigned long background
= FRAME_BACKGROUND_PIXEL (f
);
3340 int non_default_colors
= 0;
3343 xassert (img
->width
> 0 && img
->height
> 0);
3345 /* Get foreground and background colors, maybe allocate colors. */
3346 value
= image_spec_value (img
->spec
, QCforeground
, NULL
);
3349 foreground
= x_alloc_image_color (f
, img
, value
, foreground
);
3350 non_default_colors
= 1;
3352 value
= image_spec_value (img
->spec
, QCbackground
, NULL
);
3355 background
= x_alloc_image_color (f
, img
, value
, background
);
3356 img
->background
= background
;
3357 img
->background_valid
= 1;
3358 non_default_colors
= 1;
3361 Create_Pixmap_From_Bitmap_Data (f
, img
, data
,
3362 foreground
, background
,
3363 non_default_colors
);
3366 if (img
->pixmap
== NO_PIXMAP
)
3368 x_clear_image (f
, img
);
3369 image_error ("Unable to create X pixmap for `%s'", img
->spec
, Qnil
);
3375 image_error ("Error loading XBM image `%s'", img
->spec
, Qnil
);
3381 /* Value is non-zero if DATA looks like an in-memory XBM file. */
3388 return (STRINGP (data
)
3389 && xbm_read_bitmap_data (NULL
, SDATA (data
),
3396 /* Fill image IMG which is used on frame F with pixmap data. Value is
3397 non-zero if successful. */
3405 Lisp_Object file_name
;
3407 xassert (xbm_image_p (img
->spec
));
3409 /* If IMG->spec specifies a file name, create a non-file spec from it. */
3410 file_name
= image_spec_value (img
->spec
, QCfile
, NULL
);
3411 if (STRINGP (file_name
))
3414 unsigned char *contents
;
3416 struct gcpro gcpro1
;
3418 file
= x_find_image_file (file_name
);
3420 if (!STRINGP (file
))
3422 image_error ("Cannot find image file `%s'", file_name
, Qnil
);
3427 contents
= slurp_file (SDATA (file
), &size
);
3428 if (contents
== NULL
)
3430 image_error ("Error loading XBM image `%s'", img
->spec
, Qnil
);
3435 success_p
= xbm_load_image (f
, img
, contents
, contents
+ size
);
3440 struct image_keyword fmt
[XBM_LAST
];
3442 unsigned long foreground
= FRAME_FOREGROUND_PIXEL (f
);
3443 unsigned long background
= FRAME_BACKGROUND_PIXEL (f
);
3444 int non_default_colors
= 0;
3447 int in_memory_file_p
= 0;
3449 /* See if data looks like an in-memory XBM file. */
3450 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
3451 in_memory_file_p
= xbm_file_p (data
);
3453 /* Parse the image specification. */
3454 bcopy (xbm_format
, fmt
, sizeof fmt
);
3455 parsed_p
= parse_image_spec (img
->spec
, fmt
, XBM_LAST
, Qxbm
);
3458 /* Get specified width, and height. */
3459 if (!in_memory_file_p
)
3461 img
->width
= XFASTINT (fmt
[XBM_WIDTH
].value
);
3462 img
->height
= XFASTINT (fmt
[XBM_HEIGHT
].value
);
3463 xassert (img
->width
> 0 && img
->height
> 0);
3466 /* Get foreground and background colors, maybe allocate colors. */
3467 if (fmt
[XBM_FOREGROUND
].count
3468 && STRINGP (fmt
[XBM_FOREGROUND
].value
))
3470 foreground
= x_alloc_image_color (f
, img
, fmt
[XBM_FOREGROUND
].value
,
3472 non_default_colors
= 1;
3475 if (fmt
[XBM_BACKGROUND
].count
3476 && STRINGP (fmt
[XBM_BACKGROUND
].value
))
3478 background
= x_alloc_image_color (f
, img
, fmt
[XBM_BACKGROUND
].value
,
3480 non_default_colors
= 1;
3483 if (in_memory_file_p
)
3484 success_p
= xbm_load_image (f
, img
, SDATA (data
),
3493 int nbytes
= (img
->width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
;
3495 p
= bits
= (char *) alloca (nbytes
* img
->height
);
3496 for (i
= 0; i
< img
->height
; ++i
, p
+= nbytes
)
3498 Lisp_Object line
= XVECTOR (data
)->contents
[i
];
3500 bcopy (SDATA (line
), p
, nbytes
);
3502 bcopy (XBOOL_VECTOR (line
)->data
, p
, nbytes
);
3505 else if (STRINGP (data
))
3506 bits
= SDATA (data
);
3508 bits
= XBOOL_VECTOR (data
)->data
;
3510 /* Create the pixmap. */
3512 Create_Pixmap_From_Bitmap_Data (f
, img
, bits
,
3513 foreground
, background
,
3514 non_default_colors
);
3519 image_error ("Unable to create pixmap for XBM image `%s'",
3521 x_clear_image (f
, img
);
3531 /***********************************************************************
3533 ***********************************************************************/
3535 #if defined (HAVE_XPM) || defined (MAC_OS)
3537 static int xpm_image_p
P_ ((Lisp_Object object
));
3538 static int xpm_load
P_ ((struct frame
*f
, struct image
*img
));
3539 static int xpm_valid_color_symbols_p
P_ ((Lisp_Object
));
3541 #endif /* HAVE_XPM || MAC_OS */
3545 /* Indicate to xpm.h that we don't have Xlib. */
3547 /* simx.h in xpm defines XColor and XImage differently than Emacs. */
3548 /* It also defines Display the same way as Emacs, but gcc 3.3 still barfs. */
3549 #define XColor xpm_XColor
3550 #define XImage xpm_XImage
3551 #define Display xpm_Display
3552 #define PIXEL_ALREADY_TYPEDEFED
3553 #include "X11/xpm.h"
3558 #undef PIXEL_ALREADY_TYPEDEFED
3560 #include "X11/xpm.h"
3561 #endif /* HAVE_NTGUI */
3562 #endif /* HAVE_XPM */
3564 #if defined (HAVE_XPM) || defined (MAC_OS)
3565 /* The symbol `xpm' identifying XPM-format images. */
3569 /* Indices of image specification fields in xpm_format, below. */
3571 enum xpm_keyword_index
3587 /* Vector of image_keyword structures describing the format
3588 of valid XPM image specifications. */
3590 static struct image_keyword xpm_format
[XPM_LAST
] =
3592 {":type", IMAGE_SYMBOL_VALUE
, 1},
3593 {":file", IMAGE_STRING_VALUE
, 0},
3594 {":data", IMAGE_STRING_VALUE
, 0},
3595 {":ascent", IMAGE_ASCENT_VALUE
, 0},
3596 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
3597 {":relief", IMAGE_INTEGER_VALUE
, 0},
3598 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3599 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3600 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3601 {":color-symbols", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3602 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
3605 /* Structure describing the image type XPM. */
3607 static struct image_type xpm_type
=
3616 #ifdef HAVE_X_WINDOWS
3618 /* Define ALLOC_XPM_COLORS if we can use Emacs' own color allocation
3619 functions for allocating image colors. Our own functions handle
3620 color allocation failures more gracefully than the ones on the XPM
3623 #if defined XpmAllocColor && defined XpmFreeColors && defined XpmColorClosure
3624 #define ALLOC_XPM_COLORS
3626 #endif /* HAVE_X_WINDOWS */
3628 #ifdef ALLOC_XPM_COLORS
3630 static void xpm_init_color_cache
P_ ((struct frame
*, XpmAttributes
*));
3631 static void xpm_free_color_cache
P_ ((void));
3632 static int xpm_lookup_color
P_ ((struct frame
*, char *, XColor
*));
3633 static int xpm_color_bucket
P_ ((char *));
3634 static struct xpm_cached_color
*xpm_cache_color
P_ ((struct frame
*, char *,
3637 /* An entry in a hash table used to cache color definitions of named
3638 colors. This cache is necessary to speed up XPM image loading in
3639 case we do color allocations ourselves. Without it, we would need
3640 a call to XParseColor per pixel in the image. */
3642 struct xpm_cached_color
3644 /* Next in collision chain. */
3645 struct xpm_cached_color
*next
;
3647 /* Color definition (RGB and pixel color). */
3654 /* The hash table used for the color cache, and its bucket vector
3657 #define XPM_COLOR_CACHE_BUCKETS 1001
3658 struct xpm_cached_color
**xpm_color_cache
;
3660 /* Initialize the color cache. */
3663 xpm_init_color_cache (f
, attrs
)
3665 XpmAttributes
*attrs
;
3667 size_t nbytes
= XPM_COLOR_CACHE_BUCKETS
* sizeof *xpm_color_cache
;
3668 xpm_color_cache
= (struct xpm_cached_color
**) xmalloc (nbytes
);
3669 memset (xpm_color_cache
, 0, nbytes
);
3670 init_color_table ();
3672 if (attrs
->valuemask
& XpmColorSymbols
)
3677 for (i
= 0; i
< attrs
->numsymbols
; ++i
)
3678 if (XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
3679 attrs
->colorsymbols
[i
].value
, &color
))
3681 color
.pixel
= lookup_rgb_color (f
, color
.red
, color
.green
,
3683 xpm_cache_color (f
, attrs
->colorsymbols
[i
].name
, &color
, -1);
3688 /* Free the color cache. */
3691 xpm_free_color_cache ()
3693 struct xpm_cached_color
*p
, *next
;
3696 for (i
= 0; i
< XPM_COLOR_CACHE_BUCKETS
; ++i
)
3697 for (p
= xpm_color_cache
[i
]; p
; p
= next
)
3703 xfree (xpm_color_cache
);
3704 xpm_color_cache
= NULL
;
3705 free_color_table ();
3708 /* Return the bucket index for color named COLOR_NAME in the color
3712 xpm_color_bucket (color_name
)
3718 for (s
= color_name
; *s
; ++s
)
3720 return h
%= XPM_COLOR_CACHE_BUCKETS
;
3724 /* On frame F, cache values COLOR for color with name COLOR_NAME.
3725 BUCKET, if >= 0, is a precomputed bucket index. Value is the cache
3728 static struct xpm_cached_color
*
3729 xpm_cache_color (f
, color_name
, color
, bucket
)
3736 struct xpm_cached_color
*p
;
3739 bucket
= xpm_color_bucket (color_name
);
3741 nbytes
= sizeof *p
+ strlen (color_name
);
3742 p
= (struct xpm_cached_color
*) xmalloc (nbytes
);
3743 strcpy (p
->name
, color_name
);
3745 p
->next
= xpm_color_cache
[bucket
];
3746 xpm_color_cache
[bucket
] = p
;
3750 /* Look up color COLOR_NAME for frame F in the color cache. If found,
3751 return the cached definition in *COLOR. Otherwise, make a new
3752 entry in the cache and allocate the color. Value is zero if color
3753 allocation failed. */
3756 xpm_lookup_color (f
, color_name
, color
)
3761 struct xpm_cached_color
*p
;
3762 int h
= xpm_color_bucket (color_name
);
3764 for (p
= xpm_color_cache
[h
]; p
; p
= p
->next
)
3765 if (strcmp (p
->name
, color_name
) == 0)
3770 else if (XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
3773 color
->pixel
= lookup_rgb_color (f
, color
->red
, color
->green
,
3775 p
= xpm_cache_color (f
, color_name
, color
, h
);
3777 /* You get `opaque' at least from ImageMagick converting pbm to xpm
3778 with transparency, and it's useful. */
3779 else if (strcmp ("opaque", color_name
) == 0)
3781 bzero (color
, sizeof (XColor
)); /* Is this necessary/correct? */
3782 color
->pixel
= FRAME_FOREGROUND_PIXEL (f
);
3783 p
= xpm_cache_color (f
, color_name
, color
, h
);
3790 /* Callback for allocating color COLOR_NAME. Called from the XPM lib.
3791 CLOSURE is a pointer to the frame on which we allocate the
3792 color. Return in *COLOR the allocated color. Value is non-zero
3796 xpm_alloc_color (dpy
, cmap
, color_name
, color
, closure
)
3803 return xpm_lookup_color ((struct frame
*) closure
, color_name
, color
);
3807 /* Callback for freeing NPIXELS colors contained in PIXELS. CLOSURE
3808 is a pointer to the frame on which we allocate the color. Value is
3809 non-zero if successful. */
3812 xpm_free_colors (dpy
, cmap
, pixels
, npixels
, closure
)
3822 #endif /* ALLOC_XPM_COLORS */
3827 /* XPM library details. */
3829 DEF_IMGLIB_FN (XpmFreeAttributes
);
3830 DEF_IMGLIB_FN (XpmCreateImageFromBuffer
);
3831 DEF_IMGLIB_FN (XpmReadFileToImage
);
3832 DEF_IMGLIB_FN (XImageFree
);
3835 init_xpm_functions (Lisp_Object libraries
)
3839 if (!(library
= w32_delayed_load (libraries
, Qxpm
)))
3842 LOAD_IMGLIB_FN (library
, XpmFreeAttributes
);
3843 LOAD_IMGLIB_FN (library
, XpmCreateImageFromBuffer
);
3844 LOAD_IMGLIB_FN (library
, XpmReadFileToImage
);
3845 LOAD_IMGLIB_FN (library
, XImageFree
);
3849 #endif /* HAVE_NTGUI */
3852 /* Value is non-zero if COLOR_SYMBOLS is a valid color symbols list
3853 for XPM images. Such a list must consist of conses whose car and
3857 xpm_valid_color_symbols_p (color_symbols
)
3858 Lisp_Object color_symbols
;
3860 while (CONSP (color_symbols
))
3862 Lisp_Object sym
= XCAR (color_symbols
);
3864 || !STRINGP (XCAR (sym
))
3865 || !STRINGP (XCDR (sym
)))
3867 color_symbols
= XCDR (color_symbols
);
3870 return NILP (color_symbols
);
3874 /* Value is non-zero if OBJECT is a valid XPM image specification. */
3877 xpm_image_p (object
)
3880 struct image_keyword fmt
[XPM_LAST
];
3881 bcopy (xpm_format
, fmt
, sizeof fmt
);
3882 return (parse_image_spec (object
, fmt
, XPM_LAST
, Qxpm
)
3883 /* Either `:file' or `:data' must be present. */
3884 && fmt
[XPM_FILE
].count
+ fmt
[XPM_DATA
].count
== 1
3885 /* Either no `:color-symbols' or it's a list of conses
3886 whose car and cdr are strings. */
3887 && (fmt
[XPM_COLOR_SYMBOLS
].count
== 0
3888 || xpm_valid_color_symbols_p (fmt
[XPM_COLOR_SYMBOLS
].value
)));
3891 #endif /* HAVE_XPM || MAC_OS */
3893 #if defined (HAVE_XPM) && defined (HAVE_X_WINDOWS)
3895 x_create_bitmap_from_xpm_data (f
, bits
)
3899 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
3901 XpmAttributes attrs
;
3902 Pixmap bitmap
, mask
;
3904 bzero (&attrs
, sizeof attrs
);
3906 attrs
.visual
= FRAME_X_VISUAL (f
);
3907 attrs
.colormap
= FRAME_X_COLORMAP (f
);
3908 attrs
.valuemask
|= XpmVisual
;
3909 attrs
.valuemask
|= XpmColormap
;
3911 rc
= XpmCreatePixmapFromData (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3912 bits
, &bitmap
, &mask
, &attrs
);
3913 if (rc
!= XpmSuccess
)
3915 XpmFreeAttributes (&attrs
);
3919 id
= x_allocate_bitmap_record (f
);
3920 dpyinfo
->bitmaps
[id
- 1].pixmap
= bitmap
;
3921 dpyinfo
->bitmaps
[id
- 1].have_mask
= 1;
3922 dpyinfo
->bitmaps
[id
- 1].mask
= mask
;
3923 dpyinfo
->bitmaps
[id
- 1].file
= NULL
;
3924 dpyinfo
->bitmaps
[id
- 1].height
= attrs
.height
;
3925 dpyinfo
->bitmaps
[id
- 1].width
= attrs
.width
;
3926 dpyinfo
->bitmaps
[id
- 1].depth
= attrs
.depth
;
3927 dpyinfo
->bitmaps
[id
- 1].refcount
= 1;
3929 XpmFreeAttributes (&attrs
);
3932 #endif /* defined (HAVE_XPM) && defined (HAVE_X_WINDOWS) */
3934 /* Load image IMG which will be displayed on frame F. Value is
3935 non-zero if successful. */
3945 XpmAttributes attrs
;
3946 Lisp_Object specified_file
, color_symbols
;
3949 xpm_XImage
* xpm_image
= NULL
, * xpm_mask
= NULL
;
3950 #endif /* HAVE_NTGUI */
3952 /* Configure the XPM lib. Use the visual of frame F. Allocate
3953 close colors. Return colors allocated. */
3954 bzero (&attrs
, sizeof attrs
);
3957 attrs
.visual
= FRAME_X_VISUAL (f
);
3958 attrs
.colormap
= FRAME_X_COLORMAP (f
);
3959 attrs
.valuemask
|= XpmVisual
;
3960 attrs
.valuemask
|= XpmColormap
;
3961 #endif /* HAVE_NTGUI */
3963 #ifdef ALLOC_XPM_COLORS
3964 /* Allocate colors with our own functions which handle
3965 failing color allocation more gracefully. */
3966 attrs
.color_closure
= f
;
3967 attrs
.alloc_color
= xpm_alloc_color
;
3968 attrs
.free_colors
= xpm_free_colors
;
3969 attrs
.valuemask
|= XpmAllocColor
| XpmFreeColors
| XpmColorClosure
;
3970 #else /* not ALLOC_XPM_COLORS */
3971 /* Let the XPM lib allocate colors. */
3972 attrs
.valuemask
|= XpmReturnAllocPixels
;
3973 #ifdef XpmAllocCloseColors
3974 attrs
.alloc_close_colors
= 1;
3975 attrs
.valuemask
|= XpmAllocCloseColors
;
3976 #else /* not XpmAllocCloseColors */
3977 attrs
.closeness
= 600;
3978 attrs
.valuemask
|= XpmCloseness
;
3979 #endif /* not XpmAllocCloseColors */
3980 #endif /* ALLOC_XPM_COLORS */
3981 #ifdef ALLOC_XPM_COLORS
3982 xpm_init_color_cache (f
, &attrs
);
3985 /* If image specification contains symbolic color definitions, add
3986 these to `attrs'. */
3987 color_symbols
= image_spec_value (img
->spec
, QCcolor_symbols
, NULL
);
3988 if (CONSP (color_symbols
))
3991 XpmColorSymbol
*xpm_syms
;
3994 attrs
.valuemask
|= XpmColorSymbols
;
3996 /* Count number of symbols. */
3997 attrs
.numsymbols
= 0;
3998 for (tail
= color_symbols
; CONSP (tail
); tail
= XCDR (tail
))
4001 /* Allocate an XpmColorSymbol array. */
4002 size
= attrs
.numsymbols
* sizeof *xpm_syms
;
4003 xpm_syms
= (XpmColorSymbol
*) alloca (size
);
4004 bzero (xpm_syms
, size
);
4005 attrs
.colorsymbols
= xpm_syms
;
4007 /* Fill the color symbol array. */
4008 for (tail
= color_symbols
, i
= 0;
4010 ++i
, tail
= XCDR (tail
))
4012 Lisp_Object name
= XCAR (XCAR (tail
));
4013 Lisp_Object color
= XCDR (XCAR (tail
));
4014 xpm_syms
[i
].name
= (char *) alloca (SCHARS (name
) + 1);
4015 strcpy (xpm_syms
[i
].name
, SDATA (name
));
4016 xpm_syms
[i
].value
= (char *) alloca (SCHARS (color
) + 1);
4017 strcpy (xpm_syms
[i
].value
, SDATA (color
));
4021 /* Create a pixmap for the image, either from a file, or from a
4022 string buffer containing data in the same format as an XPM file. */
4023 #ifdef ALLOC_XPM_COLORS
4024 xpm_init_color_cache (f
, &attrs
);
4027 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
4031 HDC frame_dc
= get_frame_dc (f
);
4032 hdc
= CreateCompatibleDC (frame_dc
);
4033 release_frame_dc (f
, frame_dc
);
4035 #endif /* HAVE_NTGUI */
4037 if (STRINGP (specified_file
))
4039 Lisp_Object file
= x_find_image_file (specified_file
);
4040 if (!STRINGP (file
))
4042 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
4047 /* XpmReadFileToPixmap is not available in the Windows port of
4048 libxpm. But XpmReadFileToImage almost does what we want. */
4049 rc
= fn_XpmReadFileToImage (&hdc
, SDATA (file
),
4050 &xpm_image
, &xpm_mask
,
4053 rc
= XpmReadFileToPixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
4054 SDATA (file
), &img
->pixmap
, &img
->mask
,
4056 #endif /* HAVE_NTGUI */
4060 Lisp_Object buffer
= image_spec_value (img
->spec
, QCdata
, NULL
);
4062 /* XpmCreatePixmapFromBuffer is not available in the Windows port
4063 of libxpm. But XpmCreateImageFromBuffer almost does what we want. */
4064 rc
= fn_XpmCreateImageFromBuffer (&hdc
, SDATA (buffer
),
4065 &xpm_image
, &xpm_mask
,
4068 rc
= XpmCreatePixmapFromBuffer (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
4070 &img
->pixmap
, &img
->mask
,
4072 #endif /* HAVE_NTGUI */
4075 if (rc
== XpmSuccess
)
4077 #if defined (COLOR_TABLE_SUPPORT) && defined (ALLOC_XPM_COLORS)
4078 img
->colors
= colors_in_color_table (&img
->ncolors
);
4079 #else /* not ALLOC_XPM_COLORS */
4083 /* W32 XPM uses XImage to wrap what W32 Emacs calls a Pixmap,
4084 plus some duplicate attributes. */
4085 if (xpm_image
&& xpm_image
->bitmap
)
4087 img
->pixmap
= xpm_image
->bitmap
;
4088 /* XImageFree in libXpm frees XImage struct without destroying
4089 the bitmap, which is what we want. */
4090 fn_XImageFree (xpm_image
);
4092 if (xpm_mask
&& xpm_mask
->bitmap
)
4094 /* The mask appears to be inverted compared with what we expect.
4095 TODO: invert our expectations. See other places where we
4096 have to invert bits because our idea of masks is backwards. */
4098 old_obj
= SelectObject (hdc
, xpm_mask
->bitmap
);
4100 PatBlt (hdc
, 0, 0, xpm_mask
->width
, xpm_mask
->height
, DSTINVERT
);
4101 SelectObject (hdc
, old_obj
);
4103 img
->mask
= xpm_mask
->bitmap
;
4104 fn_XImageFree (xpm_mask
);
4109 #endif /* HAVE_NTGUI */
4111 /* Remember allocated colors. */
4112 img
->ncolors
= attrs
.nalloc_pixels
;
4113 img
->colors
= (unsigned long *) xmalloc (img
->ncolors
4114 * sizeof *img
->colors
);
4115 for (i
= 0; i
< attrs
.nalloc_pixels
; ++i
)
4117 img
->colors
[i
] = attrs
.alloc_pixels
[i
];
4118 #ifdef DEBUG_X_COLORS
4119 register_color (img
->colors
[i
]);
4122 #endif /* not ALLOC_XPM_COLORS */
4124 img
->width
= attrs
.width
;
4125 img
->height
= attrs
.height
;
4126 xassert (img
->width
> 0 && img
->height
> 0);
4128 /* The call to XpmFreeAttributes below frees attrs.alloc_pixels. */
4130 fn_XpmFreeAttributes (&attrs
);
4132 XpmFreeAttributes (&attrs
);
4133 #endif /* HAVE_NTGUI */
4139 #endif /* HAVE_NTGUI */
4144 image_error ("Error opening XPM file (%s)", img
->spec
, Qnil
);
4147 case XpmFileInvalid
:
4148 image_error ("Invalid XPM file (%s)", img
->spec
, Qnil
);
4152 image_error ("Out of memory (%s)", img
->spec
, Qnil
);
4155 case XpmColorFailed
:
4156 image_error ("Color allocation error (%s)", img
->spec
, Qnil
);
4160 image_error ("Unknown error (%s)", img
->spec
, Qnil
);
4165 #ifdef ALLOC_XPM_COLORS
4166 xpm_free_color_cache ();
4168 return rc
== XpmSuccess
;
4171 #endif /* HAVE_XPM */
4175 /* XPM support functions for Mac OS where libxpm is not available.
4176 Only XPM version 3 (without any extensions) is supported. */
4178 static int xpm_scan
P_ ((const unsigned char **, const unsigned char *,
4179 const unsigned char **, int *));
4180 static Lisp_Object xpm_make_color_table_v
4181 P_ ((void (**) (Lisp_Object
, const unsigned char *, int, Lisp_Object
),
4182 Lisp_Object (**) (Lisp_Object
, const unsigned char *, int)));
4183 static void xpm_put_color_table_v
P_ ((Lisp_Object
, const unsigned char *,
4185 static Lisp_Object xpm_get_color_table_v
P_ ((Lisp_Object
,
4186 const unsigned char *, int));
4187 static Lisp_Object xpm_make_color_table_h
4188 P_ ((void (**) (Lisp_Object
, const unsigned char *, int, Lisp_Object
),
4189 Lisp_Object (**) (Lisp_Object
, const unsigned char *, int)));
4190 static void xpm_put_color_table_h
P_ ((Lisp_Object
, const unsigned char *,
4192 static Lisp_Object xpm_get_color_table_h
P_ ((Lisp_Object
,
4193 const unsigned char *, int));
4194 static int xpm_str_to_color_key
P_ ((const char *));
4195 static int xpm_load_image
P_ ((struct frame
*, struct image
*,
4196 const unsigned char *, const unsigned char *));
4198 /* Tokens returned from xpm_scan. */
4207 /* Scan an XPM data and return a character (< 256) or a token defined
4208 by enum xpm_token above. *S and END are the start (inclusive) and
4209 the end (exclusive) addresses of the data, respectively. Advance
4210 *S while scanning. If token is either XPM_TK_IDENT or
4211 XPM_TK_STRING, *BEG and *LEN are set to the start address and the
4212 length of the corresponding token, respectively. */
4215 xpm_scan (s
, end
, beg
, len
)
4216 const unsigned char **s
, *end
, **beg
;
4223 /* Skip white-space. */
4224 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
4227 /* gnus-pointer.xpm uses '-' in its identifier.
4228 sb-dir-plus.xpm uses '+' in its identifier. */
4229 if (isalpha (c
) || c
== '_' || c
== '-' || c
== '+')
4233 (c
= **s
, isalnum (c
) || c
== '_' || c
== '-' || c
== '+'))
4236 return XPM_TK_IDENT
;
4241 while (*s
< end
&& **s
!= '"')
4246 return XPM_TK_STRING
;
4250 if (*s
< end
&& **s
== '*')
4252 /* C-style comment. */
4256 while (*s
< end
&& *(*s
)++ != '*')
4259 while (*s
< end
&& **s
!= '/');
4273 /* Functions for color table lookup in XPM data. A Key is a string
4274 specifying the color of each pixel in XPM data. A value is either
4275 an integer that specifies a pixel color, Qt that specifies
4276 transparency, or Qnil for the unspecified color. If the length of
4277 the key string is one, a vector is used as a table. Otherwise, a
4278 hash table is used. */
4281 xpm_make_color_table_v (put_func
, get_func
)
4282 void (**put_func
) (Lisp_Object
, const unsigned char *, int, Lisp_Object
);
4283 Lisp_Object (**get_func
) (Lisp_Object
, const unsigned char *, int);
4285 *put_func
= xpm_put_color_table_v
;
4286 *get_func
= xpm_get_color_table_v
;
4287 return Fmake_vector (make_number (256), Qnil
);
4291 xpm_put_color_table_v (color_table
, chars_start
, chars_len
, color
)
4292 Lisp_Object color_table
;
4293 const unsigned char *chars_start
;
4297 XVECTOR (color_table
)->contents
[*chars_start
] = color
;
4301 xpm_get_color_table_v (color_table
, chars_start
, chars_len
)
4302 Lisp_Object color_table
;
4303 const unsigned char *chars_start
;
4306 return XVECTOR (color_table
)->contents
[*chars_start
];
4310 xpm_make_color_table_h (put_func
, get_func
)
4311 void (**put_func
) (Lisp_Object
, const unsigned char *, int, Lisp_Object
);
4312 Lisp_Object (**get_func
) (Lisp_Object
, const unsigned char *, int);
4314 *put_func
= xpm_put_color_table_h
;
4315 *get_func
= xpm_get_color_table_h
;
4316 return make_hash_table (Qequal
, make_number (DEFAULT_HASH_SIZE
),
4317 make_float (DEFAULT_REHASH_SIZE
),
4318 make_float (DEFAULT_REHASH_THRESHOLD
),
4323 xpm_put_color_table_h (color_table
, chars_start
, chars_len
, color
)
4324 Lisp_Object color_table
;
4325 const unsigned char *chars_start
;
4329 struct Lisp_Hash_Table
*table
= XHASH_TABLE (color_table
);
4331 Lisp_Object chars
= make_unibyte_string (chars_start
, chars_len
);
4333 hash_lookup (table
, chars
, &hash_code
);
4334 hash_put (table
, chars
, color
, hash_code
);
4338 xpm_get_color_table_h (color_table
, chars_start
, chars_len
)
4339 Lisp_Object color_table
;
4340 const unsigned char *chars_start
;
4343 struct Lisp_Hash_Table
*table
= XHASH_TABLE (color_table
);
4344 int i
= hash_lookup (table
, make_unibyte_string (chars_start
, chars_len
),
4347 return i
>= 0 ? HASH_VALUE (table
, i
) : Qnil
;
4350 enum xpm_color_key
{
4358 static const char xpm_color_key_strings
[][4] = {"s", "m", "g4", "g", "c"};
4361 xpm_str_to_color_key (s
)
4367 i
< sizeof xpm_color_key_strings
/ sizeof xpm_color_key_strings
[0];
4369 if (strcmp (xpm_color_key_strings
[i
], s
) == 0)
4375 xpm_load_image (f
, img
, contents
, end
)
4378 const unsigned char *contents
, *end
;
4380 const unsigned char *s
= contents
, *beg
, *str
;
4381 unsigned char buffer
[BUFSIZ
];
4382 int width
, height
, x
, y
;
4383 int num_colors
, chars_per_pixel
;
4385 void (*put_color_table
) (Lisp_Object
, const unsigned char *, int, Lisp_Object
);
4386 Lisp_Object (*get_color_table
) (Lisp_Object
, const unsigned char *, int);
4387 Lisp_Object frame
, color_symbols
, color_table
;
4388 int best_key
, have_mask
= 0;
4389 XImagePtr ximg
= NULL
, mask_img
= NULL
;
4392 LA1 = xpm_scan (&s, end, &beg, &len)
4394 #define expect(TOKEN) \
4395 if (LA1 != (TOKEN)) \
4400 #define expect_ident(IDENT) \
4401 if (LA1 == XPM_TK_IDENT \
4402 && strlen ((IDENT)) == len && memcmp ((IDENT), beg, len) == 0) \
4407 if (!(end
- s
>= 9 && memcmp (s
, "/* XPM */", 9) == 0))
4411 expect_ident ("static");
4412 expect_ident ("char");
4414 expect (XPM_TK_IDENT
);
4419 expect (XPM_TK_STRING
);
4422 memcpy (buffer
, beg
, len
);
4424 if (sscanf (buffer
, "%d %d %d %d", &width
, &height
,
4425 &num_colors
, &chars_per_pixel
) != 4
4426 || width
<= 0 || height
<= 0
4427 || num_colors
<= 0 || chars_per_pixel
<= 0)
4430 if (!check_image_size (f
, width
, height
))
4432 image_error ("Invalid image size", Qnil
, Qnil
);
4438 XSETFRAME (frame
, f
);
4439 if (!NILP (Fxw_display_color_p (frame
)))
4440 best_key
= XPM_COLOR_KEY_C
;
4441 else if (!NILP (Fx_display_grayscale_p (frame
)))
4442 best_key
= (XFASTINT (Fx_display_planes (frame
)) > 2
4443 ? XPM_COLOR_KEY_G
: XPM_COLOR_KEY_G4
);
4445 best_key
= XPM_COLOR_KEY_M
;
4447 color_symbols
= image_spec_value (img
->spec
, QCcolor_symbols
, NULL
);
4448 if (chars_per_pixel
== 1)
4449 color_table
= xpm_make_color_table_v (&put_color_table
,
4452 color_table
= xpm_make_color_table_h (&put_color_table
,
4455 while (num_colors
-- > 0)
4457 unsigned char *color
, *max_color
;
4458 int key
, next_key
, max_key
= 0;
4459 Lisp_Object symbol_color
= Qnil
, color_val
;
4462 expect (XPM_TK_STRING
);
4463 if (len
<= chars_per_pixel
|| len
>= BUFSIZ
+ chars_per_pixel
)
4465 memcpy (buffer
, beg
+ chars_per_pixel
, len
- chars_per_pixel
);
4466 buffer
[len
- chars_per_pixel
] = '\0';
4468 str
= strtok (buffer
, " \t");
4471 key
= xpm_str_to_color_key (str
);
4476 color
= strtok (NULL
, " \t");
4480 while ((str
= strtok (NULL
, " \t")) != NULL
)
4482 next_key
= xpm_str_to_color_key (str
);
4485 color
[strlen (color
)] = ' ';
4488 if (key
== XPM_COLOR_KEY_S
)
4490 if (NILP (symbol_color
))
4491 symbol_color
= build_string (color
);
4493 else if (max_key
< key
&& key
<= best_key
)
4503 if (!NILP (color_symbols
) && !NILP (symbol_color
))
4505 Lisp_Object specified_color
= Fassoc (symbol_color
, color_symbols
);
4507 if (CONSP (specified_color
) && STRINGP (XCDR (specified_color
)))
4509 if (xstricmp (SDATA (XCDR (specified_color
)), "None") == 0)
4511 else if (x_defined_color (f
, SDATA (XCDR (specified_color
)),
4513 color_val
= make_number (cdef
.pixel
);
4516 if (NILP (color_val
) && max_key
> 0)
4518 if (xstricmp (max_color
, "None") == 0)
4520 else if (x_defined_color (f
, max_color
, &cdef
, 0))
4521 color_val
= make_number (cdef
.pixel
);
4523 if (!NILP (color_val
))
4524 (*put_color_table
) (color_table
, beg
, chars_per_pixel
, color_val
);
4529 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0,
4530 &ximg
, &img
->pixmap
)
4531 || !x_create_x_image_and_pixmap (f
, width
, height
, 1,
4532 &mask_img
, &img
->mask
))
4534 image_error ("Out of memory (%s)", img
->spec
, Qnil
);
4538 for (y
= 0; y
< height
; y
++)
4540 expect (XPM_TK_STRING
);
4542 if (len
< width
* chars_per_pixel
)
4544 for (x
= 0; x
< width
; x
++, str
+= chars_per_pixel
)
4546 Lisp_Object color_val
=
4547 (*get_color_table
) (color_table
, str
, chars_per_pixel
);
4549 XPutPixel (ximg
, x
, y
,
4550 (INTEGERP (color_val
) ? XINT (color_val
)
4551 : FRAME_FOREGROUND_PIXEL (f
)));
4552 XPutPixel (mask_img
, x
, y
,
4553 (!EQ (color_val
, Qt
) ? PIX_MASK_DRAW
4554 : (have_mask
= 1, PIX_MASK_RETAIN
)));
4561 img
->height
= height
;
4563 /* Maybe fill in the background field while we have ximg handy. */
4564 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
4565 IMAGE_BACKGROUND (img
, f
, ximg
);
4567 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
4568 x_destroy_x_image (ximg
);
4571 /* Fill in the background_transparent field while we have the
4573 image_background_transparent (img
, f
, mask_img
);
4575 x_put_x_image (f
, mask_img
, img
->mask
, width
, height
);
4576 x_destroy_x_image (mask_img
);
4580 x_destroy_x_image (mask_img
);
4581 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
4582 img
->mask
= NO_PIXMAP
;
4588 image_error ("Invalid XPM file (%s)", img
->spec
, Qnil
);
4590 x_destroy_x_image (ximg
);
4591 x_destroy_x_image (mask_img
);
4592 x_clear_image (f
, img
);
4606 Lisp_Object file_name
;
4608 /* If IMG->spec specifies a file name, create a non-file spec from it. */
4609 file_name
= image_spec_value (img
->spec
, QCfile
, NULL
);
4610 if (STRINGP (file_name
))
4613 unsigned char *contents
;
4615 struct gcpro gcpro1
;
4617 file
= x_find_image_file (file_name
);
4619 if (!STRINGP (file
))
4621 image_error ("Cannot find image file `%s'", file_name
, Qnil
);
4626 contents
= slurp_file (SDATA (file
), &size
);
4627 if (contents
== NULL
)
4629 image_error ("Error loading XPM image `%s'", img
->spec
, Qnil
);
4634 success_p
= xpm_load_image (f
, img
, contents
, contents
+ size
);
4642 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
4643 success_p
= xpm_load_image (f
, img
, SDATA (data
),
4644 SDATA (data
) + SBYTES (data
));
4654 /***********************************************************************
4656 ***********************************************************************/
4658 #ifdef COLOR_TABLE_SUPPORT
4660 /* An entry in the color table mapping an RGB color to a pixel color. */
4665 unsigned long pixel
;
4667 /* Next in color table collision list. */
4668 struct ct_color
*next
;
4671 /* The bucket vector size to use. Must be prime. */
4675 /* Value is a hash of the RGB color given by R, G, and B. */
4677 #define CT_HASH_RGB(R, G, B) (((R) << 16) ^ ((G) << 8) ^ (B))
4679 /* The color hash table. */
4681 struct ct_color
**ct_table
;
4683 /* Number of entries in the color table. */
4685 int ct_colors_allocated
;
4687 /* Initialize the color table. */
4692 int size
= CT_SIZE
* sizeof (*ct_table
);
4693 ct_table
= (struct ct_color
**) xmalloc (size
);
4694 bzero (ct_table
, size
);
4695 ct_colors_allocated
= 0;
4699 /* Free memory associated with the color table. */
4705 struct ct_color
*p
, *next
;
4707 for (i
= 0; i
< CT_SIZE
; ++i
)
4708 for (p
= ct_table
[i
]; p
; p
= next
)
4719 /* Value is a pixel color for RGB color R, G, B on frame F. If an
4720 entry for that color already is in the color table, return the
4721 pixel color of that entry. Otherwise, allocate a new color for R,
4722 G, B, and make an entry in the color table. */
4724 static unsigned long
4725 lookup_rgb_color (f
, r
, g
, b
)
4729 unsigned hash
= CT_HASH_RGB (r
, g
, b
);
4730 int i
= hash
% CT_SIZE
;
4732 Display_Info
*dpyinfo
;
4734 /* Handle TrueColor visuals specially, which improves performance by
4735 two orders of magnitude. Freeing colors on TrueColor visuals is
4736 a nop, and pixel colors specify RGB values directly. See also
4737 the Xlib spec, chapter 3.1. */
4738 dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
4739 if (dpyinfo
->red_bits
> 0)
4741 unsigned long pr
, pg
, pb
;
4743 /* Apply gamma-correction like normal color allocation does. */
4747 color
.red
= r
, color
.green
= g
, color
.blue
= b
;
4748 gamma_correct (f
, &color
);
4749 r
= color
.red
, g
= color
.green
, b
= color
.blue
;
4752 /* Scale down RGB values to the visual's bits per RGB, and shift
4753 them to the right position in the pixel color. Note that the
4754 original RGB values are 16-bit values, as usual in X. */
4755 pr
= (r
>> (16 - dpyinfo
->red_bits
)) << dpyinfo
->red_offset
;
4756 pg
= (g
>> (16 - dpyinfo
->green_bits
)) << dpyinfo
->green_offset
;
4757 pb
= (b
>> (16 - dpyinfo
->blue_bits
)) << dpyinfo
->blue_offset
;
4759 /* Assemble the pixel color. */
4760 return pr
| pg
| pb
;
4763 for (p
= ct_table
[i
]; p
; p
= p
->next
)
4764 if (p
->r
== r
&& p
->g
== g
&& p
->b
== b
)
4770 #ifdef HAVE_X_WINDOWS
4779 cmap
= FRAME_X_COLORMAP (f
);
4780 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
4783 ++ct_colors_allocated
;
4784 p
= (struct ct_color
*) xmalloc (sizeof *p
);
4788 p
->pixel
= color
.pixel
;
4789 p
->next
= ct_table
[i
];
4793 return FRAME_FOREGROUND_PIXEL (f
);
4798 color
= PALETTERGB (r
, g
, b
);
4800 color
= RGB_TO_ULONG (r
, g
, b
);
4801 #endif /* HAVE_NTGUI */
4802 ++ct_colors_allocated
;
4803 p
= (struct ct_color
*) xmalloc (sizeof *p
);
4808 p
->next
= ct_table
[i
];
4810 #endif /* HAVE_X_WINDOWS */
4818 /* Look up pixel color PIXEL which is used on frame F in the color
4819 table. If not already present, allocate it. Value is PIXEL. */
4821 static unsigned long
4822 lookup_pixel_color (f
, pixel
)
4824 unsigned long pixel
;
4826 int i
= pixel
% CT_SIZE
;
4829 for (p
= ct_table
[i
]; p
; p
= p
->next
)
4830 if (p
->pixel
== pixel
)
4839 #ifdef HAVE_X_WINDOWS
4840 cmap
= FRAME_X_COLORMAP (f
);
4841 color
.pixel
= pixel
;
4842 x_query_color (f
, &color
);
4843 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
4846 cmap
= DefaultColormapOfScreen (FRAME_X_SCREEN (f
));
4847 color
.pixel
= pixel
;
4848 XQueryColor (NULL
, cmap
, &color
);
4849 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
4851 #endif /* HAVE_X_WINDOWS */
4855 ++ct_colors_allocated
;
4857 p
= (struct ct_color
*) xmalloc (sizeof *p
);
4862 p
->next
= ct_table
[i
];
4866 return FRAME_FOREGROUND_PIXEL (f
);
4872 /* Value is a vector of all pixel colors contained in the color table,
4873 allocated via xmalloc. Set *N to the number of colors. */
4875 static unsigned long *
4876 colors_in_color_table (n
)
4881 unsigned long *colors
;
4883 if (ct_colors_allocated
== 0)
4890 colors
= (unsigned long *) xmalloc (ct_colors_allocated
4892 *n
= ct_colors_allocated
;
4894 for (i
= j
= 0; i
< CT_SIZE
; ++i
)
4895 for (p
= ct_table
[i
]; p
; p
= p
->next
)
4896 colors
[j
++] = p
->pixel
;
4902 #else /* COLOR_TABLE_SUPPORT */
4904 static unsigned long
4905 lookup_rgb_color (f
, r
, g
, b
)
4909 unsigned long pixel
;
4912 pixel
= RGB_TO_ULONG (r
>> 8, g
>> 8, b
>> 8);
4913 gamma_correct (f
, &pixel
);
4917 pixel
= PALETTERGB (r
>> 8, g
>> 8, b
>> 8);
4918 #endif /* HAVE_NTGUI */
4927 #endif /* COLOR_TABLE_SUPPORT */
4930 /***********************************************************************
4932 ***********************************************************************/
4934 static XColor
*x_to_xcolors
P_ ((struct frame
*, struct image
*, int));
4935 static void x_from_xcolors
P_ ((struct frame
*, struct image
*, XColor
*));
4936 static void x_detect_edges
P_ ((struct frame
*, struct image
*, int[9], int));
4939 static void XPutPixel (XImagePtr
, int, int, COLORREF
);
4940 #endif /* HAVE_NTGUI */
4942 /* Non-zero means draw a cross on images having `:conversion
4945 int cross_disabled_images
;
4947 /* Edge detection matrices for different edge-detection
4950 static int emboss_matrix
[9] = {
4952 2, -1, 0, /* y - 1 */
4954 0, 1, -2 /* y + 1 */
4957 static int laplace_matrix
[9] = {
4959 1, 0, 0, /* y - 1 */
4961 0, 0, -1 /* y + 1 */
4964 /* Value is the intensity of the color whose red/green/blue values
4967 #define COLOR_INTENSITY(R, G, B) ((2 * (R) + 3 * (G) + (B)) / 6)
4970 /* On frame F, return an array of XColor structures describing image
4971 IMG->pixmap. Each XColor structure has its pixel color set. RGB_P
4972 non-zero means also fill the red/green/blue members of the XColor
4973 structures. Value is a pointer to the array of XColors structures,
4974 allocated with xmalloc; it must be freed by the caller. */
4977 x_to_xcolors (f
, img
, rgb_p
)
4984 XImagePtr_or_DC ximg
;
4988 #endif /* HAVE_NTGUI */
4990 colors
= (XColor
*) xmalloc (img
->width
* img
->height
* sizeof *colors
);
4993 /* Get the X image IMG->pixmap. */
4994 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
4995 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
4997 /* Load the image into a memory device context. */
4998 hdc
= get_frame_dc (f
);
4999 ximg
= CreateCompatibleDC (hdc
);
5000 release_frame_dc (f
, hdc
);
5001 prev
= SelectObject (ximg
, img
->pixmap
);
5002 #endif /* HAVE_NTGUI */
5004 /* Fill the `pixel' members of the XColor array. I wished there
5005 were an easy and portable way to circumvent XGetPixel. */
5007 for (y
= 0; y
< img
->height
; ++y
)
5011 #ifdef HAVE_X_WINDOWS
5012 for (x
= 0; x
< img
->width
; ++x
, ++p
)
5013 p
->pixel
= XGetPixel (ximg
, x
, y
);
5015 x_query_colors (f
, row
, img
->width
);
5019 for (x
= 0; x
< img
->width
; ++x
, ++p
)
5021 /* W32_TODO: palette support needed here? */
5022 p
->pixel
= GET_PIXEL (ximg
, x
, y
);
5026 p
->red
= RED16_FROM_ULONG (p
->pixel
);
5027 p
->green
= GREEN16_FROM_ULONG (p
->pixel
);
5028 p
->blue
= BLUE16_FROM_ULONG (p
->pixel
);
5031 p
->red
= 256 * GetRValue (p
->pixel
);
5032 p
->green
= 256 * GetGValue (p
->pixel
);
5033 p
->blue
= 256 * GetBValue (p
->pixel
);
5034 #endif /* HAVE_NTGUI */
5037 #endif /* HAVE_X_WINDOWS */
5040 Destroy_Image (ximg
, prev
);
5047 /* Put a pixel of COLOR at position X, Y in XIMG. XIMG must have been
5048 created with CreateDIBSection, with the pointer to the bit values
5049 stored in ximg->data. */
5051 static void XPutPixel (ximg
, x
, y
, color
)
5056 int width
= ximg
->info
.bmiHeader
.biWidth
;
5057 int height
= ximg
->info
.bmiHeader
.biHeight
;
5058 unsigned char * pixel
;
5060 /* True color images. */
5061 if (ximg
->info
.bmiHeader
.biBitCount
== 24)
5063 int rowbytes
= width
* 3;
5064 /* Ensure scanlines are aligned on 4 byte boundaries. */
5066 rowbytes
+= 4 - (rowbytes
% 4);
5068 pixel
= ximg
->data
+ y
* rowbytes
+ x
* 3;
5069 /* Windows bitmaps are in BGR order. */
5070 *pixel
= GetBValue (color
);
5071 *(pixel
+ 1) = GetGValue (color
);
5072 *(pixel
+ 2) = GetRValue (color
);
5074 /* Monochrome images. */
5075 else if (ximg
->info
.bmiHeader
.biBitCount
== 1)
5077 int rowbytes
= width
/ 8;
5078 /* Ensure scanlines are aligned on 4 byte boundaries. */
5080 rowbytes
+= 4 - (rowbytes
% 4);
5081 pixel
= ximg
->data
+ y
* rowbytes
+ x
/ 8;
5082 /* Filter out palette info. */
5083 if (color
& 0x00ffffff)
5084 *pixel
= *pixel
| (1 << x
% 8);
5086 *pixel
= *pixel
& ~(1 << x
% 8);
5089 image_error ("XPutPixel: palette image not supported", Qnil
, Qnil
);
5092 #endif /* HAVE_NTGUI */
5094 /* Create IMG->pixmap from an array COLORS of XColor structures, whose
5095 RGB members are set. F is the frame on which this all happens.
5096 COLORS will be freed; an existing IMG->pixmap will be freed, too. */
5099 x_from_xcolors (f
, img
, colors
)
5109 init_color_table ();
5111 x_create_x_image_and_pixmap (f
, img
->width
, img
->height
, 0,
5114 for (y
= 0; y
< img
->height
; ++y
)
5115 for (x
= 0; x
< img
->width
; ++x
, ++p
)
5117 unsigned long pixel
;
5118 pixel
= lookup_rgb_color (f
, p
->red
, p
->green
, p
->blue
);
5119 XPutPixel (oimg
, x
, y
, pixel
);
5123 x_clear_image_1 (f
, img
, 1, 0, 1);
5125 x_put_x_image (f
, oimg
, pixmap
, img
->width
, img
->height
);
5126 x_destroy_x_image (oimg
);
5127 img
->pixmap
= pixmap
;
5128 #ifdef COLOR_TABLE_SUPPORT
5129 img
->colors
= colors_in_color_table (&img
->ncolors
);
5130 free_color_table ();
5131 #endif /* COLOR_TABLE_SUPPORT */
5135 /* On frame F, perform edge-detection on image IMG.
5137 MATRIX is a nine-element array specifying the transformation
5138 matrix. See emboss_matrix for an example.
5140 COLOR_ADJUST is a color adjustment added to each pixel of the
5144 x_detect_edges (f
, img
, matrix
, color_adjust
)
5147 int matrix
[9], color_adjust
;
5149 XColor
*colors
= x_to_xcolors (f
, img
, 1);
5153 for (i
= sum
= 0; i
< 9; ++i
)
5154 sum
+= abs (matrix
[i
]);
5156 #define COLOR(A, X, Y) ((A) + (Y) * img->width + (X))
5158 new = (XColor
*) xmalloc (img
->width
* img
->height
* sizeof *new);
5160 for (y
= 0; y
< img
->height
; ++y
)
5162 p
= COLOR (new, 0, y
);
5163 p
->red
= p
->green
= p
->blue
= 0xffff/2;
5164 p
= COLOR (new, img
->width
- 1, y
);
5165 p
->red
= p
->green
= p
->blue
= 0xffff/2;
5168 for (x
= 1; x
< img
->width
- 1; ++x
)
5170 p
= COLOR (new, x
, 0);
5171 p
->red
= p
->green
= p
->blue
= 0xffff/2;
5172 p
= COLOR (new, x
, img
->height
- 1);
5173 p
->red
= p
->green
= p
->blue
= 0xffff/2;
5176 for (y
= 1; y
< img
->height
- 1; ++y
)
5178 p
= COLOR (new, 1, y
);
5180 for (x
= 1; x
< img
->width
- 1; ++x
, ++p
)
5182 int r
, g
, b
, y1
, x1
;
5185 for (y1
= y
- 1; y1
< y
+ 2; ++y1
)
5186 for (x1
= x
- 1; x1
< x
+ 2; ++x1
, ++i
)
5189 XColor
*t
= COLOR (colors
, x1
, y1
);
5190 r
+= matrix
[i
] * t
->red
;
5191 g
+= matrix
[i
] * t
->green
;
5192 b
+= matrix
[i
] * t
->blue
;
5195 r
= (r
/ sum
+ color_adjust
) & 0xffff;
5196 g
= (g
/ sum
+ color_adjust
) & 0xffff;
5197 b
= (b
/ sum
+ color_adjust
) & 0xffff;
5198 p
->red
= p
->green
= p
->blue
= COLOR_INTENSITY (r
, g
, b
);
5203 x_from_xcolors (f
, img
, new);
5209 /* Perform the pre-defined `emboss' edge-detection on image IMG
5217 x_detect_edges (f
, img
, emboss_matrix
, 0xffff / 2);
5221 /* Transform image IMG which is used on frame F with a Laplace
5222 edge-detection algorithm. The result is an image that can be used
5223 to draw disabled buttons, for example. */
5230 x_detect_edges (f
, img
, laplace_matrix
, 45000);
5234 /* Perform edge-detection on image IMG on frame F, with specified
5235 transformation matrix MATRIX and color-adjustment COLOR_ADJUST.
5237 MATRIX must be either
5239 - a list of at least 9 numbers in row-major form
5240 - a vector of at least 9 numbers
5242 COLOR_ADJUST nil means use a default; otherwise it must be a
5246 x_edge_detection (f
, img
, matrix
, color_adjust
)
5249 Lisp_Object matrix
, color_adjust
;
5257 i
< 9 && CONSP (matrix
) && NUMBERP (XCAR (matrix
));
5258 ++i
, matrix
= XCDR (matrix
))
5259 trans
[i
] = XFLOATINT (XCAR (matrix
));
5261 else if (VECTORP (matrix
) && ASIZE (matrix
) >= 9)
5263 for (i
= 0; i
< 9 && NUMBERP (AREF (matrix
, i
)); ++i
)
5264 trans
[i
] = XFLOATINT (AREF (matrix
, i
));
5267 if (NILP (color_adjust
))
5268 color_adjust
= make_number (0xffff / 2);
5270 if (i
== 9 && NUMBERP (color_adjust
))
5271 x_detect_edges (f
, img
, trans
, (int) XFLOATINT (color_adjust
));
5275 /* Transform image IMG on frame F so that it looks disabled. */
5278 x_disable_image (f
, img
)
5282 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
5284 int n_planes
= dpyinfo
->n_planes
* dpyinfo
->n_cbits
;
5286 int n_planes
= dpyinfo
->n_planes
;
5287 #endif /* HAVE_NTGUI */
5291 /* Color (or grayscale). Convert to gray, and equalize. Just
5292 drawing such images with a stipple can look very odd, so
5293 we're using this method instead. */
5294 XColor
*colors
= x_to_xcolors (f
, img
, 1);
5296 const int h
= 15000;
5297 const int l
= 30000;
5299 for (p
= colors
, end
= colors
+ img
->width
* img
->height
;
5303 int i
= COLOR_INTENSITY (p
->red
, p
->green
, p
->blue
);
5304 int i2
= (0xffff - h
- l
) * i
/ 0xffff + l
;
5305 p
->red
= p
->green
= p
->blue
= i2
;
5308 x_from_xcolors (f
, img
, colors
);
5311 /* Draw a cross over the disabled image, if we must or if we
5313 if (n_planes
< 2 || cross_disabled_images
)
5316 Display
*dpy
= FRAME_X_DISPLAY (f
);
5320 #define MaskForeground(f) PIX_MASK_DRAW
5322 #define MaskForeground(f) WHITE_PIX_DEFAULT (f)
5325 gc
= XCreateGC (dpy
, img
->pixmap
, 0, NULL
);
5326 XSetForeground (dpy
, gc
, BLACK_PIX_DEFAULT (f
));
5327 XDrawLine (dpy
, img
->pixmap
, gc
, 0, 0,
5328 img
->width
- 1, img
->height
- 1);
5329 XDrawLine (dpy
, img
->pixmap
, gc
, 0, img
->height
- 1,
5335 gc
= XCreateGC (dpy
, img
->mask
, 0, NULL
);
5336 XSetForeground (dpy
, gc
, MaskForeground (f
));
5337 XDrawLine (dpy
, img
->mask
, gc
, 0, 0,
5338 img
->width
- 1, img
->height
- 1);
5339 XDrawLine (dpy
, img
->mask
, gc
, 0, img
->height
- 1,
5347 hdc
= get_frame_dc (f
);
5348 bmpdc
= CreateCompatibleDC (hdc
);
5349 release_frame_dc (f
, hdc
);
5351 prev
= SelectObject (bmpdc
, img
->pixmap
);
5353 SetTextColor (bmpdc
, BLACK_PIX_DEFAULT (f
));
5354 MoveToEx (bmpdc
, 0, 0, NULL
);
5355 LineTo (bmpdc
, img
->width
- 1, img
->height
- 1);
5356 MoveToEx (bmpdc
, 0, img
->height
- 1, NULL
);
5357 LineTo (bmpdc
, img
->width
- 1, 0);
5361 SelectObject (bmpdc
, img
->mask
);
5362 SetTextColor (bmpdc
, WHITE_PIX_DEFAULT (f
));
5363 MoveToEx (bmpdc
, 0, 0, NULL
);
5364 LineTo (bmpdc
, img
->width
- 1, img
->height
- 1);
5365 MoveToEx (bmpdc
, 0, img
->height
- 1, NULL
);
5366 LineTo (bmpdc
, img
->width
- 1, 0);
5368 SelectObject (bmpdc
, prev
);
5370 #endif /* HAVE_NTGUI */
5375 /* Build a mask for image IMG which is used on frame F. FILE is the
5376 name of an image file, for error messages. HOW determines how to
5377 determine the background color of IMG. If it is a list '(R G B)',
5378 with R, G, and B being integers >= 0, take that as the color of the
5379 background. Otherwise, determine the background color of IMG
5380 heuristically. Value is non-zero if successful. */
5383 x_build_heuristic_mask (f
, img
, how
)
5388 XImagePtr_or_DC ximg
;
5396 #endif /* HAVE_NTGUI */
5397 int x
, y
, rc
, use_img_background
;
5398 unsigned long bg
= 0;
5402 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
5403 img
->mask
= NO_PIXMAP
;
5404 img
->background_transparent_valid
= 0;
5408 /* Create an image and pixmap serving as mask. */
5409 rc
= x_create_x_image_and_pixmap (f
, img
->width
, img
->height
, 1,
5410 &mask_img
, &img
->mask
);
5414 /* Get the X image of IMG->pixmap. */
5415 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
, 0, 0,
5416 img
->width
, img
->height
,
5419 /* Create the bit array serving as mask. */
5420 row_width
= (img
->width
+ 7) / 8;
5421 mask_img
= xmalloc (row_width
* img
->height
);
5422 bzero (mask_img
, row_width
* img
->height
);
5424 /* Create a memory device context for IMG->pixmap. */
5425 frame_dc
= get_frame_dc (f
);
5426 ximg
= CreateCompatibleDC (frame_dc
);
5427 release_frame_dc (f
, frame_dc
);
5428 prev
= SelectObject (ximg
, img
->pixmap
);
5429 #endif /* HAVE_NTGUI */
5431 /* Determine the background color of ximg. If HOW is `(R G B)'
5432 take that as color. Otherwise, use the image's background color. */
5433 use_img_background
= 1;
5439 for (i
= 0; i
< 3 && CONSP (how
) && NATNUMP (XCAR (how
)); ++i
)
5441 rgb
[i
] = XFASTINT (XCAR (how
)) & 0xffff;
5445 if (i
== 3 && NILP (how
))
5447 char color_name
[30];
5448 sprintf (color_name
, "#%04x%04x%04x", rgb
[0], rgb
[1], rgb
[2]);
5451 0x00ffffff & /* Filter out palette info. */
5452 #endif /* HAVE_NTGUI */
5453 x_alloc_image_color (f
, img
, build_string (color_name
), 0));
5454 use_img_background
= 0;
5458 if (use_img_background
)
5459 bg
= four_corners_best (ximg
, img
->corners
, img
->width
, img
->height
);
5461 /* Set all bits in mask_img to 1 whose color in ximg is different
5462 from the background color bg. */
5464 for (y
= 0; y
< img
->height
; ++y
)
5465 for (x
= 0; x
< img
->width
; ++x
)
5466 XPutPixel (mask_img
, x
, y
, (XGetPixel (ximg
, x
, y
) != bg
5467 ? PIX_MASK_DRAW
: PIX_MASK_RETAIN
));
5469 /* Fill in the background_transparent field while we have the mask handy. */
5470 image_background_transparent (img
, f
, mask_img
);
5472 /* Put mask_img into img->mask. */
5473 x_put_x_image (f
, mask_img
, img
->mask
, img
->width
, img
->height
);
5474 x_destroy_x_image (mask_img
);
5477 for (y
= 0; y
< img
->height
; ++y
)
5478 for (x
= 0; x
< img
->width
; ++x
)
5480 COLORREF p
= GetPixel (ximg
, x
, y
);
5482 mask_img
[y
* row_width
+ x
/ 8] |= 1 << (x
% 8);
5485 /* Create the mask image. */
5486 img
->mask
= w32_create_pixmap_from_bitmap_data (img
->width
, img
->height
,
5488 /* Fill in the background_transparent field while we have the mask handy. */
5489 SelectObject (ximg
, img
->mask
);
5490 image_background_transparent (img
, f
, ximg
);
5492 /* Was: x_destroy_x_image ((XImagePtr )mask_img); which seems bogus ++kfs */
5494 #endif /* HAVE_NTGUI */
5496 Destroy_Image (ximg
, prev
);
5502 /***********************************************************************
5503 PBM (mono, gray, color)
5504 ***********************************************************************/
5506 static int pbm_image_p
P_ ((Lisp_Object object
));
5507 static int pbm_load
P_ ((struct frame
*f
, struct image
*img
));
5508 static int pbm_scan_number
P_ ((unsigned char **, unsigned char *));
5510 /* The symbol `pbm' identifying images of this type. */
5514 /* Indices of image specification fields in gs_format, below. */
5516 enum pbm_keyword_index
5532 /* Vector of image_keyword structures describing the format
5533 of valid user-defined image specifications. */
5535 static struct image_keyword pbm_format
[PBM_LAST
] =
5537 {":type", IMAGE_SYMBOL_VALUE
, 1},
5538 {":file", IMAGE_STRING_VALUE
, 0},
5539 {":data", IMAGE_STRING_VALUE
, 0},
5540 {":ascent", IMAGE_ASCENT_VALUE
, 0},
5541 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
5542 {":relief", IMAGE_INTEGER_VALUE
, 0},
5543 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5544 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5545 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5546 {":foreground", IMAGE_STRING_OR_NIL_VALUE
, 0},
5547 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
5550 /* Structure describing the image type `pbm'. */
5552 static struct image_type pbm_type
=
5562 /* Return non-zero if OBJECT is a valid PBM image specification. */
5565 pbm_image_p (object
)
5568 struct image_keyword fmt
[PBM_LAST
];
5570 bcopy (pbm_format
, fmt
, sizeof fmt
);
5572 if (!parse_image_spec (object
, fmt
, PBM_LAST
, Qpbm
))
5575 /* Must specify either :data or :file. */
5576 return fmt
[PBM_DATA
].count
+ fmt
[PBM_FILE
].count
== 1;
5580 /* Scan a decimal number from *S and return it. Advance *S while
5581 reading the number. END is the end of the string. Value is -1 at
5585 pbm_scan_number (s
, end
)
5586 unsigned char **s
, *end
;
5588 int c
= 0, val
= -1;
5592 /* Skip white-space. */
5593 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
5598 /* Skip comment to end of line. */
5599 while (*s
< end
&& (c
= *(*s
)++, c
!= '\n'))
5602 else if (isdigit (c
))
5604 /* Read decimal number. */
5606 while (*s
< end
&& (c
= *(*s
)++, isdigit (c
)))
5607 val
= 10 * val
+ c
- '0';
5619 #if 0 /* Unused. ++kfs */
5621 /* Read FILE into memory. Value is a pointer to a buffer allocated
5622 with xmalloc holding FILE's contents. Value is null if an error
5623 occurred. *SIZE is set to the size of the file. */
5626 pbm_read_file (file
, size
)
5634 if (stat (SDATA (file
), &st
) == 0
5635 && (fp
= fopen (SDATA (file
), "rb")) != NULL
5636 && (buf
= (char *) xmalloc (st
.st_size
),
5637 fread (buf
, 1, st
.st_size
, fp
) == st
.st_size
))
5656 #endif /* HAVE_NTGUI */
5658 /* Load PBM image IMG for use on frame F. */
5666 int width
, height
, max_color_idx
= 0;
5668 Lisp_Object file
, specified_file
;
5669 enum {PBM_MONO
, PBM_GRAY
, PBM_COLOR
} type
;
5670 struct gcpro gcpro1
;
5671 unsigned char *contents
= NULL
;
5672 unsigned char *end
, *p
;
5675 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
5679 if (STRINGP (specified_file
))
5681 file
= x_find_image_file (specified_file
);
5682 if (!STRINGP (file
))
5684 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
5689 contents
= slurp_file (SDATA (file
), &size
);
5690 if (contents
== NULL
)
5692 image_error ("Error reading `%s'", file
, Qnil
);
5698 end
= contents
+ size
;
5703 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
5705 end
= p
+ SBYTES (data
);
5708 /* Check magic number. */
5709 if (end
- p
< 2 || *p
++ != 'P')
5711 image_error ("Not a PBM image: `%s'", img
->spec
, Qnil
);
5721 raw_p
= 0, type
= PBM_MONO
;
5725 raw_p
= 0, type
= PBM_GRAY
;
5729 raw_p
= 0, type
= PBM_COLOR
;
5733 raw_p
= 1, type
= PBM_MONO
;
5737 raw_p
= 1, type
= PBM_GRAY
;
5741 raw_p
= 1, type
= PBM_COLOR
;
5745 image_error ("Not a PBM image: `%s'", img
->spec
, Qnil
);
5749 /* Read width, height, maximum color-component. Characters
5750 starting with `#' up to the end of a line are ignored. */
5751 width
= pbm_scan_number (&p
, end
);
5752 height
= pbm_scan_number (&p
, end
);
5754 if (type
!= PBM_MONO
)
5756 max_color_idx
= pbm_scan_number (&p
, end
);
5757 if (raw_p
&& max_color_idx
> 255)
5758 max_color_idx
= 255;
5761 if (!check_image_size (f
, width
, height
)
5762 || (type
!= PBM_MONO
&& max_color_idx
< 0))
5765 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0,
5766 &ximg
, &img
->pixmap
))
5769 /* Initialize the color hash table. */
5770 init_color_table ();
5772 if (type
== PBM_MONO
)
5775 struct image_keyword fmt
[PBM_LAST
];
5776 unsigned long fg
= FRAME_FOREGROUND_PIXEL (f
);
5777 unsigned long bg
= FRAME_BACKGROUND_PIXEL (f
);
5779 /* Parse the image specification. */
5780 bcopy (pbm_format
, fmt
, sizeof fmt
);
5781 parse_image_spec (img
->spec
, fmt
, PBM_LAST
, Qpbm
);
5783 /* Get foreground and background colors, maybe allocate colors. */
5784 if (fmt
[PBM_FOREGROUND
].count
5785 && STRINGP (fmt
[PBM_FOREGROUND
].value
))
5786 fg
= x_alloc_image_color (f
, img
, fmt
[PBM_FOREGROUND
].value
, fg
);
5787 if (fmt
[PBM_BACKGROUND
].count
5788 && STRINGP (fmt
[PBM_BACKGROUND
].value
))
5790 bg
= x_alloc_image_color (f
, img
, fmt
[PBM_BACKGROUND
].value
, bg
);
5791 img
->background
= bg
;
5792 img
->background_valid
= 1;
5795 for (y
= 0; y
< height
; ++y
)
5796 for (x
= 0; x
< width
; ++x
)
5804 x_destroy_x_image (ximg
);
5805 x_clear_image (f
, img
);
5806 image_error ("Invalid image size in image `%s'",
5816 g
= pbm_scan_number (&p
, end
);
5818 XPutPixel (ximg
, x
, y
, g
? fg
: bg
);
5824 && ((type
== PBM_GRAY
)
5825 ? (p
+ height
* width
> end
)
5826 : (p
+ 3 * height
* width
> end
)))
5828 x_destroy_x_image (ximg
);
5829 x_clear_image (f
, img
);
5830 image_error ("Invalid image size in image `%s'",
5835 for (y
= 0; y
< height
; ++y
)
5836 for (x
= 0; x
< width
; ++x
)
5840 if (type
== PBM_GRAY
)
5841 r
= g
= b
= raw_p
? *p
++ : pbm_scan_number (&p
, end
);
5850 r
= pbm_scan_number (&p
, end
);
5851 g
= pbm_scan_number (&p
, end
);
5852 b
= pbm_scan_number (&p
, end
);
5855 if (r
< 0 || g
< 0 || b
< 0)
5857 x_destroy_x_image (ximg
);
5858 image_error ("Invalid pixel value in image `%s'",
5863 /* RGB values are now in the range 0..max_color_idx.
5864 Scale this to the range 0..0xffff supported by X. */
5865 r
= (double) r
* 65535 / max_color_idx
;
5866 g
= (double) g
* 65535 / max_color_idx
;
5867 b
= (double) b
* 65535 / max_color_idx
;
5868 XPutPixel (ximg
, x
, y
, lookup_rgb_color (f
, r
, g
, b
));
5872 #ifdef COLOR_TABLE_SUPPORT
5873 /* Store in IMG->colors the colors allocated for the image, and
5874 free the color table. */
5875 img
->colors
= colors_in_color_table (&img
->ncolors
);
5876 free_color_table ();
5877 #endif /* COLOR_TABLE_SUPPORT */
5880 img
->height
= height
;
5882 /* Maybe fill in the background field while we have ximg handy. */
5884 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
5885 /* Casting avoids a GCC warning. */
5886 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
5888 /* Put the image into a pixmap. */
5889 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
5890 x_destroy_x_image (ximg
);
5892 /* X and W32 versions did it here, MAC version above. ++kfs
5894 img->height = height; */
5902 /***********************************************************************
5904 ***********************************************************************/
5906 #if defined (HAVE_PNG) || defined (MAC_OS)
5908 /* Function prototypes. */
5910 static int png_image_p
P_ ((Lisp_Object object
));
5911 static int png_load
P_ ((struct frame
*f
, struct image
*img
));
5913 /* The symbol `png' identifying images of this type. */
5917 /* Indices of image specification fields in png_format, below. */
5919 enum png_keyword_index
5934 /* Vector of image_keyword structures describing the format
5935 of valid user-defined image specifications. */
5937 static struct image_keyword png_format
[PNG_LAST
] =
5939 {":type", IMAGE_SYMBOL_VALUE
, 1},
5940 {":data", IMAGE_STRING_VALUE
, 0},
5941 {":file", IMAGE_STRING_VALUE
, 0},
5942 {":ascent", IMAGE_ASCENT_VALUE
, 0},
5943 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
5944 {":relief", IMAGE_INTEGER_VALUE
, 0},
5945 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5946 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5947 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5948 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
5951 /* Structure describing the image type `png'. */
5953 static struct image_type png_type
=
5962 /* Return non-zero if OBJECT is a valid PNG image specification. */
5965 png_image_p (object
)
5968 struct image_keyword fmt
[PNG_LAST
];
5969 bcopy (png_format
, fmt
, sizeof fmt
);
5971 if (!parse_image_spec (object
, fmt
, PNG_LAST
, Qpng
))
5974 /* Must specify either the :data or :file keyword. */
5975 return fmt
[PNG_FILE
].count
+ fmt
[PNG_DATA
].count
== 1;
5978 #endif /* HAVE_PNG || MAC_OS */
5983 #if defined HAVE_LIBPNG_PNG_H
5984 # include <libpng/png.h>
5990 /* PNG library details. */
5992 DEF_IMGLIB_FN (png_get_io_ptr
);
5993 DEF_IMGLIB_FN (png_check_sig
);
5994 DEF_IMGLIB_FN (png_create_read_struct
);
5995 DEF_IMGLIB_FN (png_create_info_struct
);
5996 DEF_IMGLIB_FN (png_destroy_read_struct
);
5997 DEF_IMGLIB_FN (png_set_read_fn
);
5998 DEF_IMGLIB_FN (png_set_sig_bytes
);
5999 DEF_IMGLIB_FN (png_read_info
);
6000 DEF_IMGLIB_FN (png_get_IHDR
);
6001 DEF_IMGLIB_FN (png_get_valid
);
6002 DEF_IMGLIB_FN (png_set_strip_16
);
6003 DEF_IMGLIB_FN (png_set_expand
);
6004 DEF_IMGLIB_FN (png_set_gray_to_rgb
);
6005 DEF_IMGLIB_FN (png_set_background
);
6006 DEF_IMGLIB_FN (png_get_bKGD
);
6007 DEF_IMGLIB_FN (png_read_update_info
);
6008 DEF_IMGLIB_FN (png_get_channels
);
6009 DEF_IMGLIB_FN (png_get_rowbytes
);
6010 DEF_IMGLIB_FN (png_read_image
);
6011 DEF_IMGLIB_FN (png_read_end
);
6012 DEF_IMGLIB_FN (png_error
);
6015 init_png_functions (Lisp_Object libraries
)
6019 /* Try loading libpng under probable names. */
6020 if (!(library
= w32_delayed_load (libraries
, Qpng
)))
6023 LOAD_IMGLIB_FN (library
, png_get_io_ptr
);
6024 LOAD_IMGLIB_FN (library
, png_check_sig
);
6025 LOAD_IMGLIB_FN (library
, png_create_read_struct
);
6026 LOAD_IMGLIB_FN (library
, png_create_info_struct
);
6027 LOAD_IMGLIB_FN (library
, png_destroy_read_struct
);
6028 LOAD_IMGLIB_FN (library
, png_set_read_fn
);
6029 LOAD_IMGLIB_FN (library
, png_set_sig_bytes
);
6030 LOAD_IMGLIB_FN (library
, png_read_info
);
6031 LOAD_IMGLIB_FN (library
, png_get_IHDR
);
6032 LOAD_IMGLIB_FN (library
, png_get_valid
);
6033 LOAD_IMGLIB_FN (library
, png_set_strip_16
);
6034 LOAD_IMGLIB_FN (library
, png_set_expand
);
6035 LOAD_IMGLIB_FN (library
, png_set_gray_to_rgb
);
6036 LOAD_IMGLIB_FN (library
, png_set_background
);
6037 LOAD_IMGLIB_FN (library
, png_get_bKGD
);
6038 LOAD_IMGLIB_FN (library
, png_read_update_info
);
6039 LOAD_IMGLIB_FN (library
, png_get_channels
);
6040 LOAD_IMGLIB_FN (library
, png_get_rowbytes
);
6041 LOAD_IMGLIB_FN (library
, png_read_image
);
6042 LOAD_IMGLIB_FN (library
, png_read_end
);
6043 LOAD_IMGLIB_FN (library
, png_error
);
6048 #define fn_png_get_io_ptr png_get_io_ptr
6049 #define fn_png_check_sig png_check_sig
6050 #define fn_png_create_read_struct png_create_read_struct
6051 #define fn_png_create_info_struct png_create_info_struct
6052 #define fn_png_destroy_read_struct png_destroy_read_struct
6053 #define fn_png_set_read_fn png_set_read_fn
6054 #define fn_png_set_sig_bytes png_set_sig_bytes
6055 #define fn_png_read_info png_read_info
6056 #define fn_png_get_IHDR png_get_IHDR
6057 #define fn_png_get_valid png_get_valid
6058 #define fn_png_set_strip_16 png_set_strip_16
6059 #define fn_png_set_expand png_set_expand
6060 #define fn_png_set_gray_to_rgb png_set_gray_to_rgb
6061 #define fn_png_set_background png_set_background
6062 #define fn_png_get_bKGD png_get_bKGD
6063 #define fn_png_read_update_info png_read_update_info
6064 #define fn_png_get_channels png_get_channels
6065 #define fn_png_get_rowbytes png_get_rowbytes
6066 #define fn_png_read_image png_read_image
6067 #define fn_png_read_end png_read_end
6068 #define fn_png_error png_error
6070 #endif /* HAVE_NTGUI */
6072 /* Error and warning handlers installed when the PNG library
6076 my_png_error (png_ptr
, msg
)
6077 png_struct
*png_ptr
;
6080 xassert (png_ptr
!= NULL
);
6081 image_error ("PNG error: %s", build_string (msg
), Qnil
);
6082 longjmp (png_ptr
->jmpbuf
, 1);
6087 my_png_warning (png_ptr
, msg
)
6088 png_struct
*png_ptr
;
6091 xassert (png_ptr
!= NULL
);
6092 image_error ("PNG warning: %s", build_string (msg
), Qnil
);
6095 /* Memory source for PNG decoding. */
6097 struct png_memory_storage
6099 unsigned char *bytes
; /* The data */
6100 size_t len
; /* How big is it? */
6101 int index
; /* Where are we? */
6105 /* Function set as reader function when reading PNG image from memory.
6106 PNG_PTR is a pointer to the PNG control structure. Copy LENGTH
6107 bytes from the input to DATA. */
6110 png_read_from_memory (png_ptr
, data
, length
)
6111 png_structp png_ptr
;
6115 struct png_memory_storage
*tbr
6116 = (struct png_memory_storage
*) fn_png_get_io_ptr (png_ptr
);
6118 if (length
> tbr
->len
- tbr
->index
)
6119 fn_png_error (png_ptr
, "Read error");
6121 bcopy (tbr
->bytes
+ tbr
->index
, data
, length
);
6122 tbr
->index
= tbr
->index
+ length
;
6126 /* Function set as reader function when reading PNG image from a file.
6127 PNG_PTR is a pointer to the PNG control structure. Copy LENGTH
6128 bytes from the input to DATA. */
6131 png_read_from_file (png_ptr
, data
, length
)
6132 png_structp png_ptr
;
6136 FILE *fp
= (FILE *) fn_png_get_io_ptr (png_ptr
);
6138 if (fread (data
, 1, length
, fp
) < length
)
6139 fn_png_error (png_ptr
, "Read error");
6143 /* Load PNG image IMG for use on frame F. Value is non-zero if
6151 Lisp_Object file
, specified_file
;
6152 Lisp_Object specified_data
;
6154 XImagePtr ximg
, mask_img
= NULL
;
6155 struct gcpro gcpro1
;
6156 png_struct
*png_ptr
= NULL
;
6157 png_info
*info_ptr
= NULL
, *end_info
= NULL
;
6158 FILE *volatile fp
= NULL
;
6160 png_byte
* volatile pixels
= NULL
;
6161 png_byte
** volatile rows
= NULL
;
6162 png_uint_32 width
, height
;
6163 int bit_depth
, color_type
, interlace_type
;
6165 png_uint_32 row_bytes
;
6167 double screen_gamma
;
6168 struct png_memory_storage tbr
; /* Data to be read */
6170 /* Find out what file to load. */
6171 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
6172 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
6176 if (NILP (specified_data
))
6178 file
= x_find_image_file (specified_file
);
6179 if (!STRINGP (file
))
6181 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
6186 /* Open the image file. */
6187 fp
= fopen (SDATA (file
), "rb");
6190 image_error ("Cannot open image file `%s'", file
, Qnil
);
6195 /* Check PNG signature. */
6196 if (fread (sig
, 1, sizeof sig
, fp
) != sizeof sig
6197 || !fn_png_check_sig (sig
, sizeof sig
))
6199 image_error ("Not a PNG file: `%s'", file
, Qnil
);
6207 /* Read from memory. */
6208 tbr
.bytes
= SDATA (specified_data
);
6209 tbr
.len
= SBYTES (specified_data
);
6212 /* Check PNG signature. */
6213 if (tbr
.len
< sizeof sig
6214 || !fn_png_check_sig (tbr
.bytes
, sizeof sig
))
6216 image_error ("Not a PNG image: `%s'", img
->spec
, Qnil
);
6221 /* Need to skip past the signature. */
6222 tbr
.bytes
+= sizeof (sig
);
6225 /* Initialize read and info structs for PNG lib. Casting return
6226 value avoids a GCC warning on W32. */
6227 png_ptr
= (png_structp
)fn_png_create_read_struct (PNG_LIBPNG_VER_STRING
,
6232 if (fp
) fclose (fp
);
6237 /* Casting return value avoids a GCC warning on W32. */
6238 info_ptr
= (png_infop
)fn_png_create_info_struct (png_ptr
);
6241 fn_png_destroy_read_struct (&png_ptr
, NULL
, NULL
);
6242 if (fp
) fclose (fp
);
6247 /* Casting return value avoids a GCC warning on W32. */
6248 end_info
= (png_infop
)fn_png_create_info_struct (png_ptr
);
6251 fn_png_destroy_read_struct (&png_ptr
, &info_ptr
, NULL
);
6252 if (fp
) fclose (fp
);
6257 /* Set error jump-back. We come back here when the PNG library
6258 detects an error. */
6259 if (setjmp (png_ptr
->jmpbuf
))
6263 fn_png_destroy_read_struct (&png_ptr
, &info_ptr
, &end_info
);
6266 if (fp
) fclose (fp
);
6271 /* Read image info. */
6272 if (!NILP (specified_data
))
6273 fn_png_set_read_fn (png_ptr
, (void *) &tbr
, png_read_from_memory
);
6275 fn_png_set_read_fn (png_ptr
, (void *) fp
, png_read_from_file
);
6277 fn_png_set_sig_bytes (png_ptr
, sizeof sig
);
6278 fn_png_read_info (png_ptr
, info_ptr
);
6279 fn_png_get_IHDR (png_ptr
, info_ptr
, &width
, &height
, &bit_depth
, &color_type
,
6280 &interlace_type
, NULL
, NULL
);
6282 if (!check_image_size (f
, width
, height
))
6285 /* If image contains simply transparency data, we prefer to
6286 construct a clipping mask. */
6287 if (fn_png_get_valid (png_ptr
, info_ptr
, PNG_INFO_tRNS
))
6292 /* This function is easier to write if we only have to handle
6293 one data format: RGB or RGBA with 8 bits per channel. Let's
6294 transform other formats into that format. */
6296 /* Strip more than 8 bits per channel. */
6297 if (bit_depth
== 16)
6298 fn_png_set_strip_16 (png_ptr
);
6300 /* Expand data to 24 bit RGB, or 8 bit grayscale, with alpha channel
6302 fn_png_set_expand (png_ptr
);
6304 /* Convert grayscale images to RGB. */
6305 if (color_type
== PNG_COLOR_TYPE_GRAY
6306 || color_type
== PNG_COLOR_TYPE_GRAY_ALPHA
)
6307 fn_png_set_gray_to_rgb (png_ptr
);
6309 screen_gamma
= (f
->gamma
? 1 / f
->gamma
/ 0.45455 : 2.2);
6311 #if 0 /* Avoid double gamma correction for PNG images. */
6312 { /* Tell the PNG lib to handle gamma correction for us. */
6315 #if defined(PNG_READ_sRGB_SUPPORTED) || defined(PNG_WRITE_sRGB_SUPPORTED)
6316 if (png_get_sRGB (png_ptr
, info_ptr
, &intent
))
6317 /* The libpng documentation says this is right in this case. */
6318 png_set_gamma (png_ptr
, screen_gamma
, 0.45455);
6321 if (png_get_gAMA (png_ptr
, info_ptr
, &image_gamma
))
6322 /* Image contains gamma information. */
6323 png_set_gamma (png_ptr
, screen_gamma
, image_gamma
);
6325 /* Use the standard default for the image gamma. */
6326 png_set_gamma (png_ptr
, screen_gamma
, 0.45455);
6330 /* Handle alpha channel by combining the image with a background
6331 color. Do this only if a real alpha channel is supplied. For
6332 simple transparency, we prefer a clipping mask. */
6335 png_color_16
*image_bg
;
6336 Lisp_Object specified_bg
6337 = image_spec_value (img
->spec
, QCbackground
, NULL
);
6339 if (STRINGP (specified_bg
))
6340 /* The user specified `:background', use that. */
6342 /* W32 version incorrectly used COLORREF here!! ++kfs */
6344 if (x_defined_color (f
, SDATA (specified_bg
), &color
, 0))
6346 png_color_16 user_bg
;
6348 bzero (&user_bg
, sizeof user_bg
);
6349 user_bg
.red
= color
.red
>> 8;
6350 user_bg
.green
= color
.green
>> 8;
6351 user_bg
.blue
= color
.blue
>> 8;
6353 fn_png_set_background (png_ptr
, &user_bg
,
6354 PNG_BACKGROUND_GAMMA_SCREEN
, 0, 1.0);
6357 else if (fn_png_get_bKGD (png_ptr
, info_ptr
, &image_bg
))
6358 /* Image contains a background color with which to
6359 combine the image. */
6360 fn_png_set_background (png_ptr
, image_bg
,
6361 PNG_BACKGROUND_GAMMA_FILE
, 1, 1.0);
6364 /* Image does not contain a background color with which
6365 to combine the image data via an alpha channel. Use
6366 the frame's background instead. */
6367 #ifdef HAVE_X_WINDOWS
6369 png_color_16 frame_background
;
6371 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
6372 x_query_color (f
, &color
);
6374 bzero (&frame_background
, sizeof frame_background
);
6375 frame_background
.red
= color
.red
>> 8;
6376 frame_background
.green
= color
.green
>> 8;
6377 frame_background
.blue
= color
.blue
>> 8;
6378 #endif /* HAVE_X_WINDOWS */
6382 png_color_16 frame_background
;
6383 color
= FRAME_BACKGROUND_PIXEL (f
);
6384 #if 0 /* W32 TODO : Colormap support. */
6385 x_query_color (f
, &color
);
6387 bzero (&frame_background
, sizeof frame_background
);
6388 frame_background
.red
= GetRValue (color
);
6389 frame_background
.green
= GetGValue (color
);
6390 frame_background
.blue
= GetBValue (color
);
6391 #endif /* HAVE_NTGUI */
6394 unsigned long color
;
6395 png_color_16 frame_background
;
6396 color
= FRAME_BACKGROUND_PIXEL (f
);
6397 #if 0 /* MAC/W32 TODO : Colormap support. */
6398 x_query_color (f
, &color
);
6400 bzero (&frame_background
, sizeof frame_background
);
6401 frame_background
.red
= RED_FROM_ULONG (color
);
6402 frame_background
.green
= GREEN_FROM_ULONG (color
);
6403 frame_background
.blue
= BLUE_FROM_ULONG (color
);
6406 fn_png_set_background (png_ptr
, &frame_background
,
6407 PNG_BACKGROUND_GAMMA_SCREEN
, 0, 1.0);
6411 /* Update info structure. */
6412 fn_png_read_update_info (png_ptr
, info_ptr
);
6414 /* Get number of channels. Valid values are 1 for grayscale images
6415 and images with a palette, 2 for grayscale images with transparency
6416 information (alpha channel), 3 for RGB images, and 4 for RGB
6417 images with alpha channel, i.e. RGBA. If conversions above were
6418 sufficient we should only have 3 or 4 channels here. */
6419 channels
= fn_png_get_channels (png_ptr
, info_ptr
);
6420 xassert (channels
== 3 || channels
== 4);
6422 /* Number of bytes needed for one row of the image. */
6423 row_bytes
= fn_png_get_rowbytes (png_ptr
, info_ptr
);
6425 /* Allocate memory for the image. */
6426 pixels
= (png_byte
*) xmalloc (row_bytes
* height
* sizeof *pixels
);
6427 rows
= (png_byte
**) xmalloc (height
* sizeof *rows
);
6428 for (i
= 0; i
< height
; ++i
)
6429 rows
[i
] = pixels
+ i
* row_bytes
;
6431 /* Read the entire image. */
6432 fn_png_read_image (png_ptr
, rows
);
6433 fn_png_read_end (png_ptr
, info_ptr
);
6440 /* Create the X image and pixmap. */
6441 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
,
6445 /* Create an image and pixmap serving as mask if the PNG image
6446 contains an alpha channel. */
6449 && !x_create_x_image_and_pixmap (f
, width
, height
, 1,
6450 &mask_img
, &img
->mask
))
6452 x_destroy_x_image (ximg
);
6453 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->pixmap
);
6454 img
->pixmap
= NO_PIXMAP
;
6458 /* Fill the X image and mask from PNG data. */
6459 init_color_table ();
6461 for (y
= 0; y
< height
; ++y
)
6463 png_byte
*p
= rows
[y
];
6465 for (x
= 0; x
< width
; ++x
)
6472 XPutPixel (ximg
, x
, y
, lookup_rgb_color (f
, r
, g
, b
));
6473 /* An alpha channel, aka mask channel, associates variable
6474 transparency with an image. Where other image formats
6475 support binary transparency---fully transparent or fully
6476 opaque---PNG allows up to 254 levels of partial transparency.
6477 The PNG library implements partial transparency by combining
6478 the image with a specified background color.
6480 I'm not sure how to handle this here nicely: because the
6481 background on which the image is displayed may change, for
6482 real alpha channel support, it would be necessary to create
6483 a new image for each possible background.
6485 What I'm doing now is that a mask is created if we have
6486 boolean transparency information. Otherwise I'm using
6487 the frame's background color to combine the image with. */
6492 XPutPixel (mask_img
, x
, y
, *p
> 0 ? PIX_MASK_DRAW
: PIX_MASK_RETAIN
);
6498 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
6499 /* Set IMG's background color from the PNG image, unless the user
6503 if (fn_png_get_bKGD (png_ptr
, info_ptr
, &bg
))
6505 img
->background
= lookup_rgb_color (f
, bg
->red
, bg
->green
, bg
->blue
);
6506 img
->background_valid
= 1;
6510 #ifdef COLOR_TABLE_SUPPORT
6511 /* Remember colors allocated for this image. */
6512 img
->colors
= colors_in_color_table (&img
->ncolors
);
6513 free_color_table ();
6514 #endif /* COLOR_TABLE_SUPPORT */
6517 fn_png_destroy_read_struct (&png_ptr
, &info_ptr
, &end_info
);
6522 img
->height
= height
;
6524 /* Maybe fill in the background field while we have ximg handy.
6525 Casting avoids a GCC warning. */
6526 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
6528 /* Put the image into the pixmap, then free the X image and its buffer. */
6529 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
6530 x_destroy_x_image (ximg
);
6532 /* Same for the mask. */
6535 /* Fill in the background_transparent field while we have the
6536 mask handy. Casting avoids a GCC warning. */
6537 image_background_transparent (img
, f
, (XImagePtr_or_DC
)mask_img
);
6539 x_put_x_image (f
, mask_img
, img
->mask
, img
->width
, img
->height
);
6540 x_destroy_x_image (mask_img
);
6547 #else /* HAVE_PNG */
6556 if (MyCGImageCreateWithPNGDataProvider
)
6557 return image_load_quartz2d (f
, img
, 1);
6560 return image_load_quicktime (f
, img
, kQTFileTypePNG
);
6564 #endif /* !HAVE_PNG */
6568 /***********************************************************************
6570 ***********************************************************************/
6572 #if defined (HAVE_JPEG) || defined (MAC_OS)
6574 static int jpeg_image_p
P_ ((Lisp_Object object
));
6575 static int jpeg_load
P_ ((struct frame
*f
, struct image
*img
));
6577 /* The symbol `jpeg' identifying images of this type. */
6581 /* Indices of image specification fields in gs_format, below. */
6583 enum jpeg_keyword_index
6592 JPEG_HEURISTIC_MASK
,
6598 /* Vector of image_keyword structures describing the format
6599 of valid user-defined image specifications. */
6601 static struct image_keyword jpeg_format
[JPEG_LAST
] =
6603 {":type", IMAGE_SYMBOL_VALUE
, 1},
6604 {":data", IMAGE_STRING_VALUE
, 0},
6605 {":file", IMAGE_STRING_VALUE
, 0},
6606 {":ascent", IMAGE_ASCENT_VALUE
, 0},
6607 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
6608 {":relief", IMAGE_INTEGER_VALUE
, 0},
6609 {":conversions", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6610 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6611 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6612 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
6615 /* Structure describing the image type `jpeg'. */
6617 static struct image_type jpeg_type
=
6626 /* Return non-zero if OBJECT is a valid JPEG image specification. */
6629 jpeg_image_p (object
)
6632 struct image_keyword fmt
[JPEG_LAST
];
6634 bcopy (jpeg_format
, fmt
, sizeof fmt
);
6636 if (!parse_image_spec (object
, fmt
, JPEG_LAST
, Qjpeg
))
6639 /* Must specify either the :data or :file keyword. */
6640 return fmt
[JPEG_FILE
].count
+ fmt
[JPEG_DATA
].count
== 1;
6643 #endif /* HAVE_JPEG || MAC_OS */
6647 /* Work around a warning about HAVE_STDLIB_H being redefined in
6649 #ifdef HAVE_STDLIB_H
6650 #define HAVE_STDLIB_H_1
6651 #undef HAVE_STDLIB_H
6652 #endif /* HAVE_STLIB_H */
6654 #if defined (HAVE_NTGUI) && !defined (__WIN32__)
6655 /* In older releases of the jpeg library, jpeglib.h will define boolean
6656 differently depending on __WIN32__, so make sure it is defined. */
6660 #include <jpeglib.h>
6664 #ifdef HAVE_STLIB_H_1
6665 #define HAVE_STDLIB_H 1
6670 /* JPEG library details. */
6671 DEF_IMGLIB_FN (jpeg_CreateDecompress
);
6672 DEF_IMGLIB_FN (jpeg_start_decompress
);
6673 DEF_IMGLIB_FN (jpeg_finish_decompress
);
6674 DEF_IMGLIB_FN (jpeg_destroy_decompress
);
6675 DEF_IMGLIB_FN (jpeg_read_header
);
6676 DEF_IMGLIB_FN (jpeg_read_scanlines
);
6677 DEF_IMGLIB_FN (jpeg_std_error
);
6678 DEF_IMGLIB_FN (jpeg_resync_to_restart
);
6681 init_jpeg_functions (Lisp_Object libraries
)
6685 if (!(library
= w32_delayed_load (libraries
, Qjpeg
)))
6688 LOAD_IMGLIB_FN (library
, jpeg_finish_decompress
);
6689 LOAD_IMGLIB_FN (library
, jpeg_read_scanlines
);
6690 LOAD_IMGLIB_FN (library
, jpeg_start_decompress
);
6691 LOAD_IMGLIB_FN (library
, jpeg_read_header
);
6692 LOAD_IMGLIB_FN (library
, jpeg_CreateDecompress
);
6693 LOAD_IMGLIB_FN (library
, jpeg_destroy_decompress
);
6694 LOAD_IMGLIB_FN (library
, jpeg_std_error
);
6695 LOAD_IMGLIB_FN (library
, jpeg_resync_to_restart
);
6699 /* Wrapper since we can't directly assign the function pointer
6700 to another function pointer that was declared more completely easily. */
6702 jpeg_resync_to_restart_wrapper(cinfo
, desired
)
6703 j_decompress_ptr cinfo
;
6706 return fn_jpeg_resync_to_restart (cinfo
, desired
);
6711 #define fn_jpeg_CreateDecompress(a,b,c) jpeg_create_decompress(a)
6712 #define fn_jpeg_start_decompress jpeg_start_decompress
6713 #define fn_jpeg_finish_decompress jpeg_finish_decompress
6714 #define fn_jpeg_destroy_decompress jpeg_destroy_decompress
6715 #define fn_jpeg_read_header jpeg_read_header
6716 #define fn_jpeg_read_scanlines jpeg_read_scanlines
6717 #define fn_jpeg_std_error jpeg_std_error
6718 #define jpeg_resync_to_restart_wrapper jpeg_resync_to_restart
6720 #endif /* HAVE_NTGUI */
6722 struct my_jpeg_error_mgr
6724 struct jpeg_error_mgr pub
;
6725 jmp_buf setjmp_buffer
;
6730 my_error_exit (cinfo
)
6733 struct my_jpeg_error_mgr
*mgr
= (struct my_jpeg_error_mgr
*) cinfo
->err
;
6734 longjmp (mgr
->setjmp_buffer
, 1);
6738 /* Init source method for JPEG data source manager. Called by
6739 jpeg_read_header() before any data is actually read. See
6740 libjpeg.doc from the JPEG lib distribution. */
6743 our_common_init_source (cinfo
)
6744 j_decompress_ptr cinfo
;
6749 /* Method to terminate data source. Called by
6750 jpeg_finish_decompress() after all data has been processed. */
6753 our_common_term_source (cinfo
)
6754 j_decompress_ptr cinfo
;
6759 /* Fill input buffer method for JPEG data source manager. Called
6760 whenever more data is needed. We read the whole image in one step,
6761 so this only adds a fake end of input marker at the end. */
6764 our_memory_fill_input_buffer (cinfo
)
6765 j_decompress_ptr cinfo
;
6767 /* Insert a fake EOI marker. */
6768 struct jpeg_source_mgr
*src
= cinfo
->src
;
6769 static JOCTET buffer
[2];
6771 buffer
[0] = (JOCTET
) 0xFF;
6772 buffer
[1] = (JOCTET
) JPEG_EOI
;
6774 src
->next_input_byte
= buffer
;
6775 src
->bytes_in_buffer
= 2;
6780 /* Method to skip over NUM_BYTES bytes in the image data. CINFO->src
6781 is the JPEG data source manager. */
6784 our_memory_skip_input_data (cinfo
, num_bytes
)
6785 j_decompress_ptr cinfo
;
6788 struct jpeg_source_mgr
*src
= (struct jpeg_source_mgr
*) cinfo
->src
;
6792 if (num_bytes
> src
->bytes_in_buffer
)
6793 ERREXIT (cinfo
, JERR_INPUT_EOF
);
6795 src
->bytes_in_buffer
-= num_bytes
;
6796 src
->next_input_byte
+= num_bytes
;
6801 /* Set up the JPEG lib for reading an image from DATA which contains
6802 LEN bytes. CINFO is the decompression info structure created for
6803 reading the image. */
6806 jpeg_memory_src (cinfo
, data
, len
)
6807 j_decompress_ptr cinfo
;
6811 struct jpeg_source_mgr
*src
;
6813 if (cinfo
->src
== NULL
)
6815 /* First time for this JPEG object? */
6816 cinfo
->src
= (struct jpeg_source_mgr
*)
6817 (*cinfo
->mem
->alloc_small
) ((j_common_ptr
) cinfo
, JPOOL_PERMANENT
,
6818 sizeof (struct jpeg_source_mgr
));
6819 src
= (struct jpeg_source_mgr
*) cinfo
->src
;
6820 src
->next_input_byte
= data
;
6823 src
= (struct jpeg_source_mgr
*) cinfo
->src
;
6824 src
->init_source
= our_common_init_source
;
6825 src
->fill_input_buffer
= our_memory_fill_input_buffer
;
6826 src
->skip_input_data
= our_memory_skip_input_data
;
6827 src
->resync_to_restart
= jpeg_resync_to_restart_wrapper
; /* Use default method. */
6828 src
->term_source
= our_common_term_source
;
6829 src
->bytes_in_buffer
= len
;
6830 src
->next_input_byte
= data
;
6834 struct jpeg_stdio_mgr
6836 struct jpeg_source_mgr mgr
;
6843 /* Size of buffer to read JPEG from file.
6844 Not too big, as we want to use alloc_small. */
6845 #define JPEG_STDIO_BUFFER_SIZE 8192
6848 /* Fill input buffer method for JPEG data source manager. Called
6849 whenever more data is needed. The data is read from a FILE *. */
6852 our_stdio_fill_input_buffer (cinfo
)
6853 j_decompress_ptr cinfo
;
6855 struct jpeg_stdio_mgr
*src
;
6857 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6862 bytes
= fread (src
->buffer
, 1, JPEG_STDIO_BUFFER_SIZE
, src
->file
);
6864 src
->mgr
.bytes_in_buffer
= bytes
;
6867 WARNMS (cinfo
, JWRN_JPEG_EOF
);
6869 src
->buffer
[0] = (JOCTET
) 0xFF;
6870 src
->buffer
[1] = (JOCTET
) JPEG_EOI
;
6871 src
->mgr
.bytes_in_buffer
= 2;
6873 src
->mgr
.next_input_byte
= src
->buffer
;
6880 /* Method to skip over NUM_BYTES bytes in the image data. CINFO->src
6881 is the JPEG data source manager. */
6884 our_stdio_skip_input_data (cinfo
, num_bytes
)
6885 j_decompress_ptr cinfo
;
6888 struct jpeg_stdio_mgr
*src
;
6889 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6891 while (num_bytes
> 0 && !src
->finished
)
6893 if (num_bytes
<= src
->mgr
.bytes_in_buffer
)
6895 src
->mgr
.bytes_in_buffer
-= num_bytes
;
6896 src
->mgr
.next_input_byte
+= num_bytes
;
6901 num_bytes
-= src
->mgr
.bytes_in_buffer
;
6902 src
->mgr
.bytes_in_buffer
= 0;
6903 src
->mgr
.next_input_byte
= NULL
;
6905 our_stdio_fill_input_buffer (cinfo
);
6911 /* Set up the JPEG lib for reading an image from a FILE *.
6912 CINFO is the decompression info structure created for
6913 reading the image. */
6916 jpeg_file_src (cinfo
, fp
)
6917 j_decompress_ptr cinfo
;
6920 struct jpeg_stdio_mgr
*src
;
6922 if (cinfo
->src
!= NULL
)
6923 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6926 /* First time for this JPEG object? */
6927 cinfo
->src
= (struct jpeg_source_mgr
*)
6928 (*cinfo
->mem
->alloc_small
) ((j_common_ptr
) cinfo
, JPOOL_PERMANENT
,
6929 sizeof (struct jpeg_stdio_mgr
));
6930 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6931 src
->buffer
= (JOCTET
*)
6932 (*cinfo
->mem
->alloc_small
) ((j_common_ptr
) cinfo
, JPOOL_PERMANENT
,
6933 JPEG_STDIO_BUFFER_SIZE
);
6938 src
->mgr
.init_source
= our_common_init_source
;
6939 src
->mgr
.fill_input_buffer
= our_stdio_fill_input_buffer
;
6940 src
->mgr
.skip_input_data
= our_stdio_skip_input_data
;
6941 src
->mgr
.resync_to_restart
= jpeg_resync_to_restart_wrapper
; /* Use default method. */
6942 src
->mgr
.term_source
= our_common_term_source
;
6943 src
->mgr
.bytes_in_buffer
= 0;
6944 src
->mgr
.next_input_byte
= NULL
;
6948 /* Load image IMG for use on frame F. Patterned after example.c
6949 from the JPEG lib. */
6956 struct jpeg_decompress_struct cinfo
;
6957 struct my_jpeg_error_mgr mgr
;
6958 Lisp_Object file
, specified_file
;
6959 Lisp_Object specified_data
;
6960 FILE * volatile fp
= NULL
;
6962 int row_stride
, x
, y
;
6963 XImagePtr ximg
= NULL
;
6965 unsigned long *colors
;
6967 struct gcpro gcpro1
;
6969 /* Open the JPEG file. */
6970 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
6971 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
6975 if (NILP (specified_data
))
6977 file
= x_find_image_file (specified_file
);
6978 if (!STRINGP (file
))
6980 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
6985 fp
= fopen (SDATA (file
), "rb");
6988 image_error ("Cannot open `%s'", file
, Qnil
);
6994 /* Customize libjpeg's error handling to call my_error_exit when an
6995 error is detected. This function will perform a longjmp.
6996 Casting return value avoids a GCC warning on W32. */
6997 cinfo
.err
= (struct jpeg_error_mgr
*)fn_jpeg_std_error (&mgr
.pub
);
6998 mgr
.pub
.error_exit
= my_error_exit
;
7000 if ((rc
= setjmp (mgr
.setjmp_buffer
)) != 0)
7004 /* Called from my_error_exit. Display a JPEG error. */
7005 char buffer
[JMSG_LENGTH_MAX
];
7006 cinfo
.err
->format_message ((j_common_ptr
) &cinfo
, buffer
);
7007 image_error ("Error reading JPEG image `%s': %s", img
->spec
,
7008 build_string (buffer
));
7011 /* Close the input file and destroy the JPEG object. */
7013 fclose ((FILE *) fp
);
7014 fn_jpeg_destroy_decompress (&cinfo
);
7016 /* If we already have an XImage, free that. */
7017 x_destroy_x_image (ximg
);
7019 /* Free pixmap and colors. */
7020 x_clear_image (f
, img
);
7026 /* Create the JPEG decompression object. Let it read from fp.
7027 Read the JPEG image header. */
7028 fn_jpeg_CreateDecompress (&cinfo
, JPEG_LIB_VERSION
, sizeof (cinfo
));
7030 if (NILP (specified_data
))
7031 jpeg_file_src (&cinfo
, (FILE *) fp
);
7033 jpeg_memory_src (&cinfo
, SDATA (specified_data
),
7034 SBYTES (specified_data
));
7036 fn_jpeg_read_header (&cinfo
, 1);
7038 /* Customize decompression so that color quantization will be used.
7039 Start decompression. */
7040 cinfo
.quantize_colors
= 1;
7041 fn_jpeg_start_decompress (&cinfo
);
7042 width
= img
->width
= cinfo
.output_width
;
7043 height
= img
->height
= cinfo
.output_height
;
7045 if (!check_image_size (f
, width
, height
))
7047 image_error ("Invalid image size", Qnil
, Qnil
);
7048 longjmp (mgr
.setjmp_buffer
, 2);
7051 /* Create X image and pixmap. */
7052 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
7053 longjmp (mgr
.setjmp_buffer
, 2);
7055 /* Allocate colors. When color quantization is used,
7056 cinfo.actual_number_of_colors has been set with the number of
7057 colors generated, and cinfo.colormap is a two-dimensional array
7058 of color indices in the range 0..cinfo.actual_number_of_colors.
7059 No more than 255 colors will be generated. */
7063 if (cinfo
.out_color_components
> 2)
7064 ir
= 0, ig
= 1, ib
= 2;
7065 else if (cinfo
.out_color_components
> 1)
7066 ir
= 0, ig
= 1, ib
= 0;
7068 ir
= 0, ig
= 0, ib
= 0;
7070 /* Use the color table mechanism because it handles colors that
7071 cannot be allocated nicely. Such colors will be replaced with
7072 a default color, and we don't have to care about which colors
7073 can be freed safely, and which can't. */
7074 init_color_table ();
7075 colors
= (unsigned long *) alloca (cinfo
.actual_number_of_colors
7078 for (i
= 0; i
< cinfo
.actual_number_of_colors
; ++i
)
7080 /* Multiply RGB values with 255 because X expects RGB values
7081 in the range 0..0xffff. */
7082 int r
= cinfo
.colormap
[ir
][i
] << 8;
7083 int g
= cinfo
.colormap
[ig
][i
] << 8;
7084 int b
= cinfo
.colormap
[ib
][i
] << 8;
7085 colors
[i
] = lookup_rgb_color (f
, r
, g
, b
);
7088 #ifdef COLOR_TABLE_SUPPORT
7089 /* Remember those colors actually allocated. */
7090 img
->colors
= colors_in_color_table (&img
->ncolors
);
7091 free_color_table ();
7092 #endif /* COLOR_TABLE_SUPPORT */
7096 row_stride
= width
* cinfo
.output_components
;
7097 buffer
= cinfo
.mem
->alloc_sarray ((j_common_ptr
) &cinfo
, JPOOL_IMAGE
,
7099 for (y
= 0; y
< height
; ++y
)
7101 fn_jpeg_read_scanlines (&cinfo
, buffer
, 1);
7102 for (x
= 0; x
< cinfo
.output_width
; ++x
)
7103 XPutPixel (ximg
, x
, y
, colors
[buffer
[0][x
]]);
7107 fn_jpeg_finish_decompress (&cinfo
);
7108 fn_jpeg_destroy_decompress (&cinfo
);
7110 fclose ((FILE *) fp
);
7112 /* Maybe fill in the background field while we have ximg handy. */
7113 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
7114 /* Casting avoids a GCC warning. */
7115 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
7117 /* Put the image into the pixmap. */
7118 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
7119 x_destroy_x_image (ximg
);
7124 #else /* HAVE_JPEG */
7133 return image_load_quartz2d (f
, img
, 0);
7135 return image_load_quicktime (f
, img
, kQTFileTypeJPEG
);
7140 #endif /* !HAVE_JPEG */
7144 /***********************************************************************
7146 ***********************************************************************/
7148 #if defined (HAVE_TIFF) || defined (MAC_OS)
7150 static int tiff_image_p
P_ ((Lisp_Object object
));
7151 static int tiff_load
P_ ((struct frame
*f
, struct image
*img
));
7153 /* The symbol `tiff' identifying images of this type. */
7157 /* Indices of image specification fields in tiff_format, below. */
7159 enum tiff_keyword_index
7168 TIFF_HEURISTIC_MASK
,
7174 /* Vector of image_keyword structures describing the format
7175 of valid user-defined image specifications. */
7177 static struct image_keyword tiff_format
[TIFF_LAST
] =
7179 {":type", IMAGE_SYMBOL_VALUE
, 1},
7180 {":data", IMAGE_STRING_VALUE
, 0},
7181 {":file", IMAGE_STRING_VALUE
, 0},
7182 {":ascent", IMAGE_ASCENT_VALUE
, 0},
7183 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
7184 {":relief", IMAGE_INTEGER_VALUE
, 0},
7185 {":conversions", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7186 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7187 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7188 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
7191 /* Structure describing the image type `tiff'. */
7193 static struct image_type tiff_type
=
7202 /* Return non-zero if OBJECT is a valid TIFF image specification. */
7205 tiff_image_p (object
)
7208 struct image_keyword fmt
[TIFF_LAST
];
7209 bcopy (tiff_format
, fmt
, sizeof fmt
);
7211 if (!parse_image_spec (object
, fmt
, TIFF_LAST
, Qtiff
))
7214 /* Must specify either the :data or :file keyword. */
7215 return fmt
[TIFF_FILE
].count
+ fmt
[TIFF_DATA
].count
== 1;
7218 #endif /* HAVE_TIFF || MAC_OS */
7226 /* TIFF library details. */
7227 DEF_IMGLIB_FN (TIFFSetErrorHandler
);
7228 DEF_IMGLIB_FN (TIFFSetWarningHandler
);
7229 DEF_IMGLIB_FN (TIFFOpen
);
7230 DEF_IMGLIB_FN (TIFFClientOpen
);
7231 DEF_IMGLIB_FN (TIFFGetField
);
7232 DEF_IMGLIB_FN (TIFFReadRGBAImage
);
7233 DEF_IMGLIB_FN (TIFFClose
);
7236 init_tiff_functions (Lisp_Object libraries
)
7240 if (!(library
= w32_delayed_load (libraries
, Qtiff
)))
7243 LOAD_IMGLIB_FN (library
, TIFFSetErrorHandler
);
7244 LOAD_IMGLIB_FN (library
, TIFFSetWarningHandler
);
7245 LOAD_IMGLIB_FN (library
, TIFFOpen
);
7246 LOAD_IMGLIB_FN (library
, TIFFClientOpen
);
7247 LOAD_IMGLIB_FN (library
, TIFFGetField
);
7248 LOAD_IMGLIB_FN (library
, TIFFReadRGBAImage
);
7249 LOAD_IMGLIB_FN (library
, TIFFClose
);
7255 #define fn_TIFFSetErrorHandler TIFFSetErrorHandler
7256 #define fn_TIFFSetWarningHandler TIFFSetWarningHandler
7257 #define fn_TIFFOpen TIFFOpen
7258 #define fn_TIFFClientOpen TIFFClientOpen
7259 #define fn_TIFFGetField TIFFGetField
7260 #define fn_TIFFReadRGBAImage TIFFReadRGBAImage
7261 #define fn_TIFFClose TIFFClose
7263 #endif /* HAVE_NTGUI */
7266 /* Reading from a memory buffer for TIFF images Based on the PNG
7267 memory source, but we have to provide a lot of extra functions.
7270 We really only need to implement read and seek, but I am not
7271 convinced that the TIFF library is smart enough not to destroy
7272 itself if we only hand it the function pointers we need to
7277 unsigned char *bytes
;
7284 tiff_read_from_memory (data
, buf
, size
)
7289 tiff_memory_source
*src
= (tiff_memory_source
*) data
;
7291 if (size
> src
->len
- src
->index
)
7293 bcopy (src
->bytes
+ src
->index
, buf
, size
);
7299 tiff_write_from_memory (data
, buf
, size
)
7308 tiff_seek_in_memory (data
, off
, whence
)
7313 tiff_memory_source
*src
= (tiff_memory_source
*) data
;
7318 case SEEK_SET
: /* Go from beginning of source. */
7322 case SEEK_END
: /* Go from end of source. */
7323 idx
= src
->len
+ off
;
7326 case SEEK_CUR
: /* Go from current position. */
7327 idx
= src
->index
+ off
;
7330 default: /* Invalid `whence'. */
7334 if (idx
> src
->len
|| idx
< 0)
7342 tiff_close_memory (data
)
7350 tiff_mmap_memory (data
, pbase
, psize
)
7355 /* It is already _IN_ memory. */
7360 tiff_unmap_memory (data
, base
, size
)
7365 /* We don't need to do this. */
7369 tiff_size_of_memory (data
)
7372 return ((tiff_memory_source
*) data
)->len
;
7377 tiff_error_handler (title
, format
, ap
)
7378 const char *title
, *format
;
7384 len
= sprintf (buf
, "TIFF error: %s ", title
);
7385 vsprintf (buf
+ len
, format
, ap
);
7386 add_to_log (buf
, Qnil
, Qnil
);
7391 tiff_warning_handler (title
, format
, ap
)
7392 const char *title
, *format
;
7398 len
= sprintf (buf
, "TIFF warning: %s ", title
);
7399 vsprintf (buf
+ len
, format
, ap
);
7400 add_to_log (buf
, Qnil
, Qnil
);
7404 /* Load TIFF image IMG for use on frame F. Value is non-zero if
7412 Lisp_Object file
, specified_file
;
7413 Lisp_Object specified_data
;
7415 int width
, height
, x
, y
;
7419 struct gcpro gcpro1
;
7420 tiff_memory_source memsrc
;
7422 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
7423 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
7427 fn_TIFFSetErrorHandler (tiff_error_handler
);
7428 fn_TIFFSetWarningHandler (tiff_warning_handler
);
7430 if (NILP (specified_data
))
7432 /* Read from a file */
7433 file
= x_find_image_file (specified_file
);
7434 if (!STRINGP (file
))
7436 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
7441 /* Try to open the image file. Casting return value avoids a
7442 GCC warning on W32. */
7443 tiff
= (TIFF
*)fn_TIFFOpen (SDATA (file
), "r");
7446 image_error ("Cannot open `%s'", file
, Qnil
);
7453 /* Memory source! */
7454 memsrc
.bytes
= SDATA (specified_data
);
7455 memsrc
.len
= SBYTES (specified_data
);
7458 /* Casting return value avoids a GCC warning on W32. */
7459 tiff
= (TIFF
*)fn_TIFFClientOpen ("memory_source", "r", &memsrc
,
7460 (TIFFReadWriteProc
) tiff_read_from_memory
,
7461 (TIFFReadWriteProc
) tiff_write_from_memory
,
7462 tiff_seek_in_memory
,
7464 tiff_size_of_memory
,
7470 image_error ("Cannot open memory source for `%s'", img
->spec
, Qnil
);
7476 /* Get width and height of the image, and allocate a raster buffer
7477 of width x height 32-bit values. */
7478 fn_TIFFGetField (tiff
, TIFFTAG_IMAGEWIDTH
, &width
);
7479 fn_TIFFGetField (tiff
, TIFFTAG_IMAGELENGTH
, &height
);
7481 if (!check_image_size (f
, width
, height
))
7483 image_error ("Invalid image size", Qnil
, Qnil
);
7488 buf
= (uint32
*) xmalloc (width
* height
* sizeof *buf
);
7490 rc
= fn_TIFFReadRGBAImage (tiff
, width
, height
, buf
, 0);
7491 fn_TIFFClose (tiff
);
7494 image_error ("Error reading TIFF image `%s'", img
->spec
, Qnil
);
7500 /* Create the X image and pixmap. */
7501 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
7508 /* Initialize the color table. */
7509 init_color_table ();
7511 /* Process the pixel raster. Origin is in the lower-left corner. */
7512 for (y
= 0; y
< height
; ++y
)
7514 uint32
*row
= buf
+ y
* width
;
7516 for (x
= 0; x
< width
; ++x
)
7518 uint32 abgr
= row
[x
];
7519 int r
= TIFFGetR (abgr
) << 8;
7520 int g
= TIFFGetG (abgr
) << 8;
7521 int b
= TIFFGetB (abgr
) << 8;
7522 XPutPixel (ximg
, x
, height
- 1 - y
, lookup_rgb_color (f
, r
, g
, b
));
7526 #ifdef COLOR_TABLE_SUPPORT
7527 /* Remember the colors allocated for the image. Free the color table. */
7528 img
->colors
= colors_in_color_table (&img
->ncolors
);
7529 free_color_table ();
7530 #endif /* COLOR_TABLE_SUPPORT */
7533 img
->height
= height
;
7535 /* Maybe fill in the background field while we have ximg handy. */
7536 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
7537 /* Casting avoids a GCC warning on W32. */
7538 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
7540 /* Put the image into the pixmap, then free the X image and its buffer. */
7541 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
7542 x_destroy_x_image (ximg
);
7549 #else /* HAVE_TIFF */
7557 return image_load_quicktime (f
, img
, kQTFileTypeTIFF
);
7561 #endif /* !HAVE_TIFF */
7565 /***********************************************************************
7567 ***********************************************************************/
7569 #if defined (HAVE_GIF) || defined (MAC_OS)
7571 static int gif_image_p
P_ ((Lisp_Object object
));
7572 static int gif_load
P_ ((struct frame
*f
, struct image
*img
));
7573 static void gif_clear_image
P_ ((struct frame
*f
, struct image
*img
));
7575 /* The symbol `gif' identifying images of this type. */
7579 /* Indices of image specification fields in gif_format, below. */
7581 enum gif_keyword_index
7597 /* Vector of image_keyword structures describing the format
7598 of valid user-defined image specifications. */
7600 static struct image_keyword gif_format
[GIF_LAST
] =
7602 {":type", IMAGE_SYMBOL_VALUE
, 1},
7603 {":data", IMAGE_STRING_VALUE
, 0},
7604 {":file", IMAGE_STRING_VALUE
, 0},
7605 {":ascent", IMAGE_ASCENT_VALUE
, 0},
7606 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
7607 {":relief", IMAGE_INTEGER_VALUE
, 0},
7608 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7609 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7610 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7611 {":image", IMAGE_NON_NEGATIVE_INTEGER_VALUE
, 0},
7612 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
7615 /* Structure describing the image type `gif'. */
7617 static struct image_type gif_type
=
7626 /* Free X resources of GIF image IMG which is used on frame F. */
7629 gif_clear_image (f
, img
)
7633 /* IMG->data.ptr_val may contain extension data. */
7634 img
->data
.lisp_val
= Qnil
;
7635 x_clear_image (f
, img
);
7638 /* Return non-zero if OBJECT is a valid GIF image specification. */
7641 gif_image_p (object
)
7644 struct image_keyword fmt
[GIF_LAST
];
7645 bcopy (gif_format
, fmt
, sizeof fmt
);
7647 if (!parse_image_spec (object
, fmt
, GIF_LAST
, Qgif
))
7650 /* Must specify either the :data or :file keyword. */
7651 return fmt
[GIF_FILE
].count
+ fmt
[GIF_DATA
].count
== 1;
7654 #endif /* HAVE_GIF || MAC_OS */
7658 #if defined (HAVE_NTGUI) || defined (MAC_OS)
7659 /* winuser.h might define DrawText to DrawTextA or DrawTextW.
7660 Undefine before redefining to avoid a preprocessor warning. */
7664 /* avoid conflict with QuickdrawText.h */
7665 #define DrawText gif_DrawText
7666 #include <gif_lib.h>
7669 #else /* HAVE_NTGUI || MAC_OS */
7671 #include <gif_lib.h>
7673 #endif /* HAVE_NTGUI || MAC_OS */
7678 /* GIF library details. */
7679 DEF_IMGLIB_FN (DGifCloseFile
);
7680 DEF_IMGLIB_FN (DGifSlurp
);
7681 DEF_IMGLIB_FN (DGifOpen
);
7682 DEF_IMGLIB_FN (DGifOpenFileName
);
7685 init_gif_functions (Lisp_Object libraries
)
7689 if (!(library
= w32_delayed_load (libraries
, Qgif
)))
7692 LOAD_IMGLIB_FN (library
, DGifCloseFile
);
7693 LOAD_IMGLIB_FN (library
, DGifSlurp
);
7694 LOAD_IMGLIB_FN (library
, DGifOpen
);
7695 LOAD_IMGLIB_FN (library
, DGifOpenFileName
);
7701 #define fn_DGifCloseFile DGifCloseFile
7702 #define fn_DGifSlurp DGifSlurp
7703 #define fn_DGifOpen DGifOpen
7704 #define fn_DGifOpenFileName DGifOpenFileName
7706 #endif /* HAVE_NTGUI */
7708 /* Reading a GIF image from memory
7709 Based on the PNG memory stuff to a certain extent. */
7713 unsigned char *bytes
;
7719 /* Make the current memory source available to gif_read_from_memory.
7720 It's done this way because not all versions of libungif support
7721 a UserData field in the GifFileType structure. */
7722 static gif_memory_source
*current_gif_memory_src
;
7725 gif_read_from_memory (file
, buf
, len
)
7730 gif_memory_source
*src
= current_gif_memory_src
;
7732 if (len
> src
->len
- src
->index
)
7735 bcopy (src
->bytes
+ src
->index
, buf
, len
);
7741 /* Load GIF image IMG for use on frame F. Value is non-zero if
7749 Lisp_Object file
, specified_file
;
7750 Lisp_Object specified_data
;
7751 int rc
, width
, height
, x
, y
, i
;
7753 ColorMapObject
*gif_color_map
;
7754 unsigned long pixel_colors
[256];
7756 struct gcpro gcpro1
;
7758 int ino
, image_height
, image_width
;
7759 gif_memory_source memsrc
;
7760 unsigned char *raster
;
7762 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
7763 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
7767 if (NILP (specified_data
))
7769 file
= x_find_image_file (specified_file
);
7770 if (!STRINGP (file
))
7772 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
7777 /* Open the GIF file. Casting return value avoids a GCC warning
7779 gif
= (GifFileType
*)fn_DGifOpenFileName (SDATA (file
));
7782 image_error ("Cannot open `%s'", file
, Qnil
);
7789 /* Read from memory! */
7790 current_gif_memory_src
= &memsrc
;
7791 memsrc
.bytes
= SDATA (specified_data
);
7792 memsrc
.len
= SBYTES (specified_data
);
7795 /* Casting return value avoids a GCC warning on W32. */
7796 gif
= (GifFileType
*)fn_DGifOpen(&memsrc
, gif_read_from_memory
);
7799 image_error ("Cannot open memory source `%s'", img
->spec
, Qnil
);
7805 /* Before reading entire contents, check the declared image size. */
7806 if (!check_image_size (f
, gif
->SWidth
, gif
->SHeight
))
7808 image_error ("Invalid image size", Qnil
, Qnil
);
7809 fn_DGifCloseFile (gif
);
7814 /* Read entire contents. */
7815 rc
= fn_DGifSlurp (gif
);
7816 if (rc
== GIF_ERROR
)
7818 image_error ("Error reading `%s'", img
->spec
, Qnil
);
7819 fn_DGifCloseFile (gif
);
7824 image
= image_spec_value (img
->spec
, QCindex
, NULL
);
7825 ino
= INTEGERP (image
) ? XFASTINT (image
) : 0;
7826 if (ino
>= gif
->ImageCount
)
7828 image_error ("Invalid image number `%s' in image `%s'",
7830 fn_DGifCloseFile (gif
);
7835 img
->corners
[TOP_CORNER
] = gif
->SavedImages
[ino
].ImageDesc
.Top
;
7836 img
->corners
[LEFT_CORNER
] = gif
->SavedImages
[ino
].ImageDesc
.Left
;
7837 image_height
= gif
->SavedImages
[ino
].ImageDesc
.Height
;
7838 img
->corners
[BOT_CORNER
] = img
->corners
[TOP_CORNER
] + image_height
;
7839 image_width
= gif
->SavedImages
[ino
].ImageDesc
.Width
;
7840 img
->corners
[RIGHT_CORNER
] = img
->corners
[LEFT_CORNER
] + image_width
;
7842 width
= img
->width
= max (gif
->SWidth
,
7843 max (gif
->Image
.Left
+ gif
->Image
.Width
,
7844 img
->corners
[RIGHT_CORNER
]));
7845 height
= img
->height
= max (gif
->SHeight
,
7846 max (gif
->Image
.Top
+ gif
->Image
.Height
,
7847 img
->corners
[BOT_CORNER
]));
7849 if (!check_image_size (f
, width
, height
))
7851 image_error ("Invalid image size", Qnil
, Qnil
);
7852 fn_DGifCloseFile (gif
);
7857 /* Create the X image and pixmap. */
7858 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
7860 fn_DGifCloseFile (gif
);
7865 /* Allocate colors. */
7866 gif_color_map
= gif
->SavedImages
[ino
].ImageDesc
.ColorMap
;
7868 gif_color_map
= gif
->SColorMap
;
7869 init_color_table ();
7870 bzero (pixel_colors
, sizeof pixel_colors
);
7872 for (i
= 0; i
< gif_color_map
->ColorCount
; ++i
)
7874 int r
= gif_color_map
->Colors
[i
].Red
<< 8;
7875 int g
= gif_color_map
->Colors
[i
].Green
<< 8;
7876 int b
= gif_color_map
->Colors
[i
].Blue
<< 8;
7877 pixel_colors
[i
] = lookup_rgb_color (f
, r
, g
, b
);
7880 #ifdef COLOR_TABLE_SUPPORT
7881 img
->colors
= colors_in_color_table (&img
->ncolors
);
7882 free_color_table ();
7883 #endif /* COLOR_TABLE_SUPPORT */
7885 /* Clear the part of the screen image that are not covered by
7886 the image from the GIF file. Full animated GIF support
7887 requires more than can be done here (see the gif89 spec,
7888 disposal methods). Let's simply assume that the part
7889 not covered by a sub-image is in the frame's background color. */
7890 for (y
= 0; y
< img
->corners
[TOP_CORNER
]; ++y
)
7891 for (x
= 0; x
< width
; ++x
)
7892 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7894 for (y
= img
->corners
[BOT_CORNER
]; y
< height
; ++y
)
7895 for (x
= 0; x
< width
; ++x
)
7896 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7898 for (y
= img
->corners
[TOP_CORNER
]; y
< img
->corners
[BOT_CORNER
]; ++y
)
7900 for (x
= 0; x
< img
->corners
[LEFT_CORNER
]; ++x
)
7901 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7902 for (x
= img
->corners
[RIGHT_CORNER
]; x
< width
; ++x
)
7903 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7906 /* Read the GIF image into the X image. We use a local variable
7907 `raster' here because RasterBits below is a char *, and invites
7908 problems with bytes >= 0x80. */
7909 raster
= (unsigned char *) gif
->SavedImages
[ino
].RasterBits
;
7911 if (gif
->SavedImages
[ino
].ImageDesc
.Interlace
)
7913 static int interlace_start
[] = {0, 4, 2, 1};
7914 static int interlace_increment
[] = {8, 8, 4, 2};
7916 int row
= interlace_start
[0];
7920 for (y
= 0; y
< image_height
; y
++)
7922 if (row
>= image_height
)
7924 row
= interlace_start
[++pass
];
7925 while (row
>= image_height
)
7926 row
= interlace_start
[++pass
];
7929 for (x
= 0; x
< image_width
; x
++)
7931 int i
= raster
[(y
* image_width
) + x
];
7932 XPutPixel (ximg
, x
+ img
->corners
[LEFT_CORNER
],
7933 row
+ img
->corners
[TOP_CORNER
], pixel_colors
[i
]);
7936 row
+= interlace_increment
[pass
];
7941 for (y
= 0; y
< image_height
; ++y
)
7942 for (x
= 0; x
< image_width
; ++x
)
7944 int i
= raster
[y
* image_width
+ x
];
7945 XPutPixel (ximg
, x
+ img
->corners
[LEFT_CORNER
],
7946 y
+ img
->corners
[TOP_CORNER
], pixel_colors
[i
]);
7950 /* Save GIF image extension data for `image-extension-data'.
7951 Format is (count IMAGES FUNCTION "BYTES" ...). */
7952 img
->data
.lisp_val
= Qnil
;
7953 if (gif
->SavedImages
[ino
].ExtensionBlockCount
> 0)
7955 ExtensionBlock
*ext
= gif
->SavedImages
[ino
].ExtensionBlocks
;
7956 for (i
= 0; i
< gif
->SavedImages
[ino
].ExtensionBlockCount
; i
++, ext
++)
7957 /* Append (... FUNCTION "BYTES") */
7958 img
->data
.lisp_val
= Fcons (make_unibyte_string (ext
->Bytes
, ext
->ByteCount
),
7959 Fcons (make_number (ext
->Function
),
7960 img
->data
.lisp_val
));
7961 img
->data
.lisp_val
= Fnreverse (img
->data
.lisp_val
);
7963 if (gif
->ImageCount
> 1)
7964 img
->data
.lisp_val
= Fcons (Qcount
,
7965 Fcons (make_number (gif
->ImageCount
),
7966 img
->data
.lisp_val
));
7968 fn_DGifCloseFile (gif
);
7970 /* Maybe fill in the background field while we have ximg handy. */
7971 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
7972 /* Casting avoids a GCC warning. */
7973 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
7975 /* Put the image into the pixmap, then free the X image and its buffer. */
7976 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
7977 x_destroy_x_image (ximg
);
7983 #else /* !HAVE_GIF */
7991 Lisp_Object specified_file
, file
;
7992 Lisp_Object specified_data
;
7994 Boolean graphic_p
, movie_p
, prefer_graphic_p
;
8002 Lisp_Object specified_bg
;
8007 TimeScale time_scale
;
8008 TimeValue time
, duration
;
8013 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
8014 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
8016 /* Animated gifs use QuickTime Movie Toolbox. So initialize it here. */
8019 if (NILP (specified_data
))
8021 /* Read from a file */
8025 err
= find_image_fsspec (specified_file
, &file
, &fss
);
8029 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
8034 err
= CanQuickTimeOpenFile (&fss
, kQTFileTypeGIF
, 0,
8035 &graphic_p
, &movie_p
, &prefer_graphic_p
, 0);
8039 if (!graphic_p
&& !movie_p
)
8041 if (prefer_graphic_p
)
8042 return image_load_qt_1 (f
, img
, kQTFileTypeGIF
, &fss
, NULL
);
8043 err
= OpenMovieFile (&fss
, &refnum
, fsRdPerm
);
8046 err
= NewMovieFromFile (&movie
, refnum
, NULL
, NULL
, 0, NULL
);
8047 CloseMovieFile (refnum
);
8050 image_error ("Error reading `%s'", file
, Qnil
);
8056 /* Memory source! */
8058 long file_type_atom
[3];
8060 err
= PtrToHand (SDATA (specified_data
), &dh
, SBYTES (specified_data
));
8063 image_error ("Cannot allocate data handle for `%s'",
8068 file_type_atom
[0] = EndianU32_NtoB (sizeof (long) * 3);
8069 file_type_atom
[1] = EndianU32_NtoB (kDataRefExtensionMacOSFileType
);
8070 file_type_atom
[2] = EndianU32_NtoB (kQTFileTypeGIF
);
8071 err
= PtrToHand (&dh
, &dref
, sizeof (Handle
));
8074 err
= PtrAndHand ("\p", dref
, 1);
8076 err
= PtrAndHand (file_type_atom
, dref
, sizeof (long) * 3);
8079 image_error ("Cannot allocate handle data ref for `%s'", img
->spec
, Qnil
);
8082 err
= CanQuickTimeOpenDataRef (dref
, HandleDataHandlerSubType
, &graphic_p
,
8083 &movie_p
, &prefer_graphic_p
, 0);
8087 if (!graphic_p
&& !movie_p
)
8089 if (prefer_graphic_p
)
8093 DisposeHandle (dref
);
8094 success_p
= image_load_qt_1 (f
, img
, kQTFileTypeGIF
, NULL
, dh
);
8098 err
= NewMovieFromDataRef (&movie
, 0, NULL
, dref
,
8099 HandleDataHandlerSubType
);
8100 DisposeHandle (dref
);
8105 image
= image_spec_value (img
->spec
, QCindex
, NULL
);
8106 ino
= INTEGERP (image
) ? XFASTINT (image
) : 0;
8107 track
= GetMovieIndTrack (movie
, 1);
8108 media
= GetTrackMedia (track
);
8109 nsamples
= GetMediaSampleCount (media
);
8110 if (ino
>= nsamples
)
8112 image_error ("Invalid image number `%s' in image `%s'",
8116 time_scale
= GetMediaTimeScale (media
);
8118 specified_bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
8119 if (!STRINGP (specified_bg
) ||
8120 !mac_defined_color (f
, SDATA (specified_bg
), &color
, 0))
8122 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
8123 color
.red
= RED16_FROM_ULONG (color
.pixel
);
8124 color
.green
= GREEN16_FROM_ULONG (color
.pixel
);
8125 color
.blue
= BLUE16_FROM_ULONG (color
.pixel
);
8127 GetMovieBox (movie
, &rect
);
8128 width
= img
->width
= rect
.right
- rect
.left
;
8129 height
= img
->height
= rect
.bottom
- rect
.top
;
8130 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
8133 GetGWorld (&old_port
, &old_gdh
);
8134 SetGWorld (ximg
, NULL
);
8135 bg_color
.red
= color
.red
;
8136 bg_color
.green
= color
.green
;
8137 bg_color
.blue
= color
.blue
;
8138 RGBBackColor (&bg_color
);
8139 SetGWorld (old_port
, old_gdh
);
8140 SetMovieActive (movie
, 1);
8141 SetMovieGWorld (movie
, ximg
, NULL
);
8142 SampleNumToMediaTime (media
, ino
+ 1, &time
, &duration
);
8143 SetMovieTimeValue (movie
, time
);
8144 MoviesTask (movie
, 0L);
8145 DisposeTrackMedia (media
);
8146 DisposeMovieTrack (track
);
8147 DisposeMovie (movie
);
8151 /* Save GIF image extension data for `image-extension-data'.
8152 Format is (count IMAGES 0xf9 GRAPHIC_CONTROL_EXTENSION_BLOCK). */
8154 Lisp_Object gce
= make_uninit_string (4);
8155 int centisec
= ((float)duration
/ time_scale
) * 100.0f
+ 0.5f
;
8157 /* Fill the delay time field. */
8158 SSET (gce
, 1, centisec
& 0xff);
8159 SSET (gce
, 2, (centisec
>> 8) & 0xff);
8160 /* We don't know about other fields. */
8164 img
->data
.lisp_val
= list4 (Qcount
, make_number (nsamples
),
8165 make_number (0xf9), gce
);
8168 /* Maybe fill in the background field while we have ximg handy. */
8169 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
8170 IMAGE_BACKGROUND (img
, f
, ximg
);
8172 /* Put the image into the pixmap. */
8173 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
8174 x_destroy_x_image (ximg
);
8178 image_error ("Cannot open `%s'", file
, Qnil
);
8181 DisposeTrackMedia (media
);
8183 DisposeMovieTrack (track
);
8185 DisposeMovie (movie
);
8192 #endif /* HAVE_GIF */
8196 /***********************************************************************
8198 ***********************************************************************/
8200 #ifdef HAVE_X_WINDOWS
8201 #define HAVE_GHOSTSCRIPT 1
8202 #endif /* HAVE_X_WINDOWS */
8204 /* The symbol `postscript' identifying images of this type. */
8206 Lisp_Object Qpostscript
;
8208 #ifdef HAVE_GHOSTSCRIPT
8210 static int gs_image_p
P_ ((Lisp_Object object
));
8211 static int gs_load
P_ ((struct frame
*f
, struct image
*img
));
8212 static void gs_clear_image
P_ ((struct frame
*f
, struct image
*img
));
8214 /* Keyword symbols. */
8216 Lisp_Object QCloader
, QCbounding_box
, QCpt_width
, QCpt_height
;
8218 /* Indices of image specification fields in gs_format, below. */
8220 enum gs_keyword_index
8238 /* Vector of image_keyword structures describing the format
8239 of valid user-defined image specifications. */
8241 static struct image_keyword gs_format
[GS_LAST
] =
8243 {":type", IMAGE_SYMBOL_VALUE
, 1},
8244 {":pt-width", IMAGE_POSITIVE_INTEGER_VALUE
, 1},
8245 {":pt-height", IMAGE_POSITIVE_INTEGER_VALUE
, 1},
8246 {":file", IMAGE_STRING_VALUE
, 1},
8247 {":loader", IMAGE_FUNCTION_VALUE
, 0},
8248 {":bounding-box", IMAGE_DONT_CHECK_VALUE_TYPE
, 1},
8249 {":ascent", IMAGE_ASCENT_VALUE
, 0},
8250 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
8251 {":relief", IMAGE_INTEGER_VALUE
, 0},
8252 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8253 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8254 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8255 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
8258 /* Structure describing the image type `ghostscript'. */
8260 static struct image_type gs_type
=
8270 /* Free X resources of Ghostscript image IMG which is used on frame F. */
8273 gs_clear_image (f
, img
)
8277 /* IMG->data.ptr_val may contain a recorded colormap. */
8278 xfree (img
->data
.ptr_val
);
8279 x_clear_image (f
, img
);
8283 /* Return non-zero if OBJECT is a valid Ghostscript image
8290 struct image_keyword fmt
[GS_LAST
];
8294 bcopy (gs_format
, fmt
, sizeof fmt
);
8296 if (!parse_image_spec (object
, fmt
, GS_LAST
, Qpostscript
))
8299 /* Bounding box must be a list or vector containing 4 integers. */
8300 tem
= fmt
[GS_BOUNDING_BOX
].value
;
8303 for (i
= 0; i
< 4; ++i
, tem
= XCDR (tem
))
8304 if (!CONSP (tem
) || !INTEGERP (XCAR (tem
)))
8309 else if (VECTORP (tem
))
8311 if (XVECTOR (tem
)->size
!= 4)
8313 for (i
= 0; i
< 4; ++i
)
8314 if (!INTEGERP (XVECTOR (tem
)->contents
[i
]))
8324 /* Load Ghostscript image IMG for use on frame F. Value is non-zero
8333 Lisp_Object window_and_pixmap_id
= Qnil
, loader
, pt_height
, pt_width
;
8334 struct gcpro gcpro1
, gcpro2
;
8336 double in_width
, in_height
;
8337 Lisp_Object pixel_colors
= Qnil
;
8339 /* Compute pixel size of pixmap needed from the given size in the
8340 image specification. Sizes in the specification are in pt. 1 pt
8341 = 1/72 in, xdpi and ydpi are stored in the frame's X display
8343 pt_width
= image_spec_value (img
->spec
, QCpt_width
, NULL
);
8344 in_width
= XFASTINT (pt_width
) / 72.0;
8345 img
->width
= in_width
* FRAME_X_DISPLAY_INFO (f
)->resx
;
8346 pt_height
= image_spec_value (img
->spec
, QCpt_height
, NULL
);
8347 in_height
= XFASTINT (pt_height
) / 72.0;
8348 img
->height
= in_height
* FRAME_X_DISPLAY_INFO (f
)->resy
;
8350 if (!check_image_size (f
, img
->width
, img
->height
))
8352 image_error ("Invalid image size", Qnil
, Qnil
);
8356 /* Create the pixmap. */
8357 xassert (img
->pixmap
== NO_PIXMAP
);
8359 /* Only W32 version did BLOCK_INPUT here. ++kfs */
8361 img
->pixmap
= XCreatePixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
8362 img
->width
, img
->height
,
8363 DefaultDepthOfScreen (FRAME_X_SCREEN (f
)));
8368 image_error ("Unable to create pixmap for `%s'", img
->spec
, Qnil
);
8372 /* Call the loader to fill the pixmap. It returns a process object
8373 if successful. We do not record_unwind_protect here because
8374 other places in redisplay like calling window scroll functions
8375 don't either. Let the Lisp loader use `unwind-protect' instead. */
8376 GCPRO2 (window_and_pixmap_id
, pixel_colors
);
8378 sprintf (buffer
, "%lu %lu",
8379 (unsigned long) FRAME_X_WINDOW (f
),
8380 (unsigned long) img
->pixmap
);
8381 window_and_pixmap_id
= build_string (buffer
);
8383 sprintf (buffer
, "%lu %lu",
8384 FRAME_FOREGROUND_PIXEL (f
),
8385 FRAME_BACKGROUND_PIXEL (f
));
8386 pixel_colors
= build_string (buffer
);
8388 XSETFRAME (frame
, f
);
8389 loader
= image_spec_value (img
->spec
, QCloader
, NULL
);
8391 loader
= intern ("gs-load-image");
8393 img
->data
.lisp_val
= call6 (loader
, frame
, img
->spec
,
8394 make_number (img
->width
),
8395 make_number (img
->height
),
8396 window_and_pixmap_id
,
8399 return PROCESSP (img
->data
.lisp_val
);
8403 /* Kill the Ghostscript process that was started to fill PIXMAP on
8404 frame F. Called from XTread_socket when receiving an event
8405 telling Emacs that Ghostscript has finished drawing. */
8408 x_kill_gs_process (pixmap
, f
)
8412 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
8416 /* Find the image containing PIXMAP. */
8417 for (i
= 0; i
< c
->used
; ++i
)
8418 if (c
->images
[i
]->pixmap
== pixmap
)
8421 /* Should someone in between have cleared the image cache, for
8422 instance, give up. */
8426 /* Kill the GS process. We should have found PIXMAP in the image
8427 cache and its image should contain a process object. */
8429 xassert (PROCESSP (img
->data
.lisp_val
));
8430 Fkill_process (img
->data
.lisp_val
, Qnil
);
8431 img
->data
.lisp_val
= Qnil
;
8433 #if defined (HAVE_X_WINDOWS)
8435 /* On displays with a mutable colormap, figure out the colors
8436 allocated for the image by looking at the pixels of an XImage for
8438 class = FRAME_X_VISUAL (f
)->class;
8439 if (class != StaticColor
&& class != StaticGray
&& class != TrueColor
)
8445 /* Try to get an XImage for img->pixmep. */
8446 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
8447 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
8452 /* Initialize the color table. */
8453 init_color_table ();
8455 /* For each pixel of the image, look its color up in the
8456 color table. After having done so, the color table will
8457 contain an entry for each color used by the image. */
8458 for (y
= 0; y
< img
->height
; ++y
)
8459 for (x
= 0; x
< img
->width
; ++x
)
8461 unsigned long pixel
= XGetPixel (ximg
, x
, y
);
8462 lookup_pixel_color (f
, pixel
);
8465 /* Record colors in the image. Free color table and XImage. */
8466 #ifdef COLOR_TABLE_SUPPORT
8467 img
->colors
= colors_in_color_table (&img
->ncolors
);
8468 free_color_table ();
8470 XDestroyImage (ximg
);
8472 #if 0 /* This doesn't seem to be the case. If we free the colors
8473 here, we get a BadAccess later in x_clear_image when
8474 freeing the colors. */
8475 /* We have allocated colors once, but Ghostscript has also
8476 allocated colors on behalf of us. So, to get the
8477 reference counts right, free them once. */
8479 x_free_colors (f
, img
->colors
, img
->ncolors
);
8483 image_error ("Cannot get X image of `%s'; colors will not be freed",
8488 #endif /* HAVE_X_WINDOWS */
8490 /* Now that we have the pixmap, compute mask and transform the
8491 image if requested. */
8493 postprocess_image (f
, img
);
8497 #endif /* HAVE_GHOSTSCRIPT */
8500 /***********************************************************************
8502 ***********************************************************************/
8506 DEFUN ("imagep", Fimagep
, Simagep
, 1, 1, 0,
8507 doc
: /* Value is non-nil if SPEC is a valid image specification. */)
8511 return valid_image_p (spec
) ? Qt
: Qnil
;
8515 DEFUN ("lookup-image", Flookup_image
, Slookup_image
, 1, 1, 0, "")
8521 if (valid_image_p (spec
))
8522 id
= lookup_image (SELECTED_FRAME (), spec
);
8525 return make_number (id
);
8528 #endif /* GLYPH_DEBUG != 0 */
8531 /***********************************************************************
8533 ***********************************************************************/
8536 /* Image types that rely on external libraries are loaded dynamically
8537 if the library is available. */
8538 #define CHECK_LIB_AVAILABLE(image_type, init_lib_fn, libraries) \
8539 define_image_type (image_type, init_lib_fn (libraries))
8541 #define CHECK_LIB_AVAILABLE(image_type, init_lib_fn, libraries) \
8542 define_image_type (image_type, 1)
8543 #endif /* HAVE_NTGUI */
8545 DEFUN ("init-image-library", Finit_image_library
, Sinit_image_library
, 2, 2, 0,
8546 doc
: /* Initialize image library implementing image type TYPE.
8547 Return non-nil if TYPE is a supported image type.
8549 Image types pbm and xbm are prebuilt; other types are loaded here.
8550 Libraries to load are specified in alist LIBRARIES (usually, the value
8551 of `image-library-alist', which see). */)
8553 Lisp_Object type
, libraries
;
8557 /* Don't try to reload the library. */
8558 tested
= Fassq (type
, Vimage_type_cache
);
8560 return XCDR (tested
);
8562 #if defined (HAVE_XPM) || defined (MAC_OS)
8563 if (EQ (type
, Qxpm
))
8564 return CHECK_LIB_AVAILABLE (&xpm_type
, init_xpm_functions
, libraries
);
8567 #if defined (HAVE_JPEG) || defined (MAC_OS)
8568 if (EQ (type
, Qjpeg
))
8569 return CHECK_LIB_AVAILABLE (&jpeg_type
, init_jpeg_functions
, libraries
);
8572 #if defined (HAVE_TIFF) || defined (MAC_OS)
8573 if (EQ (type
, Qtiff
))
8574 return CHECK_LIB_AVAILABLE (&tiff_type
, init_tiff_functions
, libraries
);
8577 #if defined (HAVE_GIF) || defined (MAC_OS)
8578 if (EQ (type
, Qgif
))
8579 return CHECK_LIB_AVAILABLE (&gif_type
, init_gif_functions
, libraries
);
8582 #if defined (HAVE_PNG) || defined (MAC_OS)
8583 if (EQ (type
, Qpng
))
8584 return CHECK_LIB_AVAILABLE (&png_type
, init_png_functions
, libraries
);
8587 #ifdef HAVE_GHOSTSCRIPT
8588 if (EQ (type
, Qpostscript
))
8589 return CHECK_LIB_AVAILABLE (&gs_type
, init_gs_functions
, libraries
);
8592 /* If the type is not recognized, avoid testing it ever again. */
8593 CACHE_IMAGE_TYPE (type
, Qnil
);
8600 extern Lisp_Object Qrisky_local_variable
; /* Syms_of_xdisp has already run. */
8602 /* Initialize this only once, since that's what we do with Vimage_types
8603 and they are supposed to be in sync. Initializing here gives correct
8604 operation on GNU/Linux of calling dump-emacs after loading some images. */
8607 /* Must be defined now becase we're going to update it below, while
8608 defining the supported image types. */
8609 DEFVAR_LISP ("image-types", &Vimage_types
,
8610 doc
: /* List of potentially supported image types.
8611 Each element of the list is a symbol for a image type, like 'jpeg or 'png.
8612 To check whether it is really supported, use `image-type-available-p'. */);
8613 Vimage_types
= Qnil
;
8615 DEFVAR_LISP ("image-library-alist", &Vimage_library_alist
,
8616 doc
: /* Alist of image types vs external libraries needed to display them.
8618 Each element is a list (IMAGE-TYPE LIBRARY...), where the car is a symbol
8619 representing a supported image type, and the rest are strings giving
8620 alternate filenames for the corresponding external libraries.
8622 Emacs tries to load the libraries in the order they appear on the
8623 list; if none is loaded, the running session of Emacs won't
8624 support the image type. Types 'pbm and 'xbm don't need to be
8625 listed; they're always supported. */);
8626 Vimage_library_alist
= Qnil
;
8627 Fput (intern ("image-library-alist"), Qrisky_local_variable
, Qt
);
8629 DEFVAR_LISP ("max-image-size", &Vmax_image_size
,
8630 doc
: /* Maximum size of images.
8631 Emacs will not load an image into memory if its pixel width or
8632 pixel height exceeds this limit.
8634 If the value is an integer, it directly specifies the maximum
8635 image height and width, measured in pixels. If it is a floating
8636 point number, it specifies the maximum image height and width
8637 as a ratio to the frame height and width. If the value is
8638 non-numeric, there is no explicit limit on the size of images. */);
8639 Vmax_image_size
= make_float (MAX_IMAGE_SIZE
);
8641 Vimage_type_cache
= Qnil
;
8642 staticpro (&Vimage_type_cache
);
8644 Qpbm
= intern ("pbm");
8646 ADD_IMAGE_TYPE(Qpbm
);
8648 Qxbm
= intern ("xbm");
8650 ADD_IMAGE_TYPE(Qxbm
);
8652 define_image_type (&xbm_type
, 1);
8653 define_image_type (&pbm_type
, 1);
8655 QCascent
= intern (":ascent");
8656 staticpro (&QCascent
);
8657 QCmargin
= intern (":margin");
8658 staticpro (&QCmargin
);
8659 QCrelief
= intern (":relief");
8660 staticpro (&QCrelief
);
8661 QCconversion
= intern (":conversion");
8662 staticpro (&QCconversion
);
8663 QCcolor_symbols
= intern (":color-symbols");
8664 staticpro (&QCcolor_symbols
);
8665 QCheuristic_mask
= intern (":heuristic-mask");
8666 staticpro (&QCheuristic_mask
);
8667 QCindex
= intern (":index");
8668 staticpro (&QCindex
);
8669 QCmatrix
= intern (":matrix");
8670 staticpro (&QCmatrix
);
8671 QCcolor_adjustment
= intern (":color-adjustment");
8672 staticpro (&QCcolor_adjustment
);
8673 QCmask
= intern (":mask");
8674 staticpro (&QCmask
);
8676 Qlaplace
= intern ("laplace");
8677 staticpro (&Qlaplace
);
8678 Qemboss
= intern ("emboss");
8679 staticpro (&Qemboss
);
8680 Qedge_detection
= intern ("edge-detection");
8681 staticpro (&Qedge_detection
);
8682 Qheuristic
= intern ("heuristic");
8683 staticpro (&Qheuristic
);
8685 Qpostscript
= intern ("postscript");
8686 staticpro (&Qpostscript
);
8687 #ifdef HAVE_GHOSTSCRIPT
8688 ADD_IMAGE_TYPE(Qpostscript
);
8689 QCloader
= intern (":loader");
8690 staticpro (&QCloader
);
8691 QCbounding_box
= intern (":bounding-box");
8692 staticpro (&QCbounding_box
);
8693 QCpt_width
= intern (":pt-width");
8694 staticpro (&QCpt_width
);
8695 QCpt_height
= intern (":pt-height");
8696 staticpro (&QCpt_height
);
8697 #endif /* HAVE_GHOSTSCRIPT */
8699 #if defined (HAVE_XPM) || defined (MAC_OS)
8700 Qxpm
= intern ("xpm");
8702 ADD_IMAGE_TYPE(Qxpm
);
8705 #if defined (HAVE_JPEG) || defined (MAC_OS)
8706 Qjpeg
= intern ("jpeg");
8708 ADD_IMAGE_TYPE(Qjpeg
);
8711 #if defined (HAVE_TIFF) || defined (MAC_OS)
8712 Qtiff
= intern ("tiff");
8714 ADD_IMAGE_TYPE(Qtiff
);
8717 #if defined (HAVE_GIF) || defined (MAC_OS)
8718 Qgif
= intern ("gif");
8720 ADD_IMAGE_TYPE(Qgif
);
8723 #if defined (HAVE_PNG) || defined (MAC_OS)
8724 Qpng
= intern ("png");
8726 ADD_IMAGE_TYPE(Qpng
);
8729 defsubr (&Sinit_image_library
);
8730 defsubr (&Sclear_image_cache
);
8731 defsubr (&Simage_refresh
);
8732 defsubr (&Simage_size
);
8733 defsubr (&Simage_mask_p
);
8734 defsubr (&Simage_extension_data
);
8738 defsubr (&Slookup_image
);
8741 DEFVAR_BOOL ("cross-disabled-images", &cross_disabled_images
,
8742 doc
: /* Non-nil means always draw a cross over disabled images.
8743 Disabled images are those having an `:conversion disabled' property.
8744 A cross is always drawn on black & white displays. */);
8745 cross_disabled_images
= 0;
8747 DEFVAR_LISP ("x-bitmap-file-path", &Vx_bitmap_file_path
,
8748 doc
: /* List of directories to search for window system bitmap files. */);
8749 Vx_bitmap_file_path
= decode_env_path ((char *) 0, PATH_BITMAPS
);
8751 DEFVAR_LISP ("image-cache-eviction-delay", &Vimage_cache_eviction_delay
,
8752 doc
: /* Time after which cached images are removed from the cache.
8753 When an image has not been displayed this many seconds, remove it
8754 from the image cache. Value must be an integer or nil with nil
8755 meaning don't clear the cache. */);
8756 Vimage_cache_eviction_delay
= make_number (30 * 60);
8762 #if defined (MAC_OSX) && TARGET_API_MAC_CARBON
8763 init_image_func_pointer ();
8767 /* arch-tag: 123c2a5e-14a8-4c53-ab95-af47d7db49b9
8768 (do not change this comment) */