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 void cache_image
P_ ((struct frame
*f
, struct image
*img
));
1613 static void postprocess_image
P_ ((struct frame
*, struct image
*));
1615 /* Return a new, initialized image cache that is allocated from the
1616 heap. Call free_image_cache to free an image cache. */
1618 struct image_cache
*
1621 struct image_cache
*c
= (struct image_cache
*) xmalloc (sizeof *c
);
1624 bzero (c
, sizeof *c
);
1626 c
->images
= (struct image
**) xmalloc (c
->size
* sizeof *c
->images
);
1627 size
= IMAGE_CACHE_BUCKETS_SIZE
* sizeof *c
->buckets
;
1628 c
->buckets
= (struct image
**) xmalloc (size
);
1629 bzero (c
->buckets
, size
);
1634 /* Search frame F for an images with spec SPEC, and free it. */
1637 uncache_image (f
, spec
)
1641 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
1642 struct image
*img
= IMAGE_FROM_ID (f
, lookup_image (f
, spec
));
1643 unsigned hash
= sxhash (spec
, 0);
1644 int i
= hash
% IMAGE_CACHE_BUCKETS_SIZE
;
1646 for (img
= c
->buckets
[i
]; img
; img
= img
->next
)
1647 if (img
->hash
== hash
&& !NILP (Fequal (img
->spec
, spec
)))
1649 free_image (f
, img
);
1655 /* Free image cache of frame F. Be aware that X frames share images
1659 free_image_cache (f
)
1662 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
1667 /* Cache should not be referenced by any frame when freed. */
1668 xassert (c
->refcount
== 0);
1670 for (i
= 0; i
< c
->used
; ++i
)
1671 free_image (f
, c
->images
[i
]);
1675 FRAME_X_IMAGE_CACHE (f
) = NULL
;
1680 /* Clear image cache of frame F. FORCE_P non-zero means free all
1681 images. FORCE_P zero means clear only images that haven't been
1682 displayed for some time. Should be called from time to time to
1683 reduce the number of loaded images. If image-eviction-seconds is
1684 non-nil, this frees images in the cache which weren't displayed for
1685 at least that many seconds. */
1688 clear_image_cache (f
, force_p
)
1692 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
1694 if (c
&& INTEGERP (Vimage_cache_eviction_delay
))
1701 old
= EMACS_SECS (t
) - XFASTINT (Vimage_cache_eviction_delay
);
1703 /* Block input so that we won't be interrupted by a SIGIO
1704 while being in an inconsistent state. */
1707 for (i
= nfreed
= 0; i
< c
->used
; ++i
)
1709 struct image
*img
= c
->images
[i
];
1711 && (force_p
|| img
->timestamp
< old
))
1713 free_image (f
, img
);
1718 /* We may be clearing the image cache because, for example,
1719 Emacs was iconified for a longer period of time. In that
1720 case, current matrices may still contain references to
1721 images freed above. So, clear these matrices. */
1724 Lisp_Object tail
, frame
;
1726 FOR_EACH_FRAME (tail
, frame
)
1728 struct frame
*f
= XFRAME (frame
);
1729 if (FRAME_WINDOW_P (f
)
1730 && FRAME_X_IMAGE_CACHE (f
) == c
)
1731 clear_current_matrices (f
);
1734 ++windows_or_buffers_changed
;
1742 DEFUN ("clear-image-cache", Fclear_image_cache
, Sclear_image_cache
,
1744 doc
: /* Clear the image cache of FRAME.
1745 FRAME nil or omitted means use the selected frame.
1746 FRAME t means clear the image caches of all frames. */)
1754 FOR_EACH_FRAME (tail
, frame
)
1755 if (FRAME_WINDOW_P (XFRAME (frame
)))
1756 clear_image_cache (XFRAME (frame
), 1);
1759 clear_image_cache (check_x_frame (frame
), 1);
1765 DEFUN ("image-refresh", Fimage_refresh
, Simage_refresh
,
1767 doc
: /* Refresh the image with specification SPEC on frame FRAME.
1768 If SPEC specifies an image file, the displayed image is updated with
1769 the current contents of that file.
1770 FRAME nil or omitted means use the selected frame.
1771 FRAME t means refresh the image on all frames. */)
1773 Lisp_Object spec
, frame
;
1775 if (!valid_image_p (spec
))
1776 error ("Invalid image specification");
1781 FOR_EACH_FRAME (tail
, frame
)
1783 struct frame
*f
= XFRAME (frame
);
1784 if (FRAME_WINDOW_P (f
))
1785 uncache_image (f
, spec
);
1789 uncache_image (check_x_frame (frame
), spec
);
1795 /* Compute masks and transform image IMG on frame F, as specified
1796 by the image's specification, */
1799 postprocess_image (f
, img
)
1803 /* Manipulation of the image's mask. */
1806 Lisp_Object conversion
, spec
;
1811 /* `:heuristic-mask t'
1813 means build a mask heuristically.
1814 `:heuristic-mask (R G B)'
1815 `:mask (heuristic (R G B))'
1816 means build a mask from color (R G B) in the
1819 means remove a mask, if any. */
1821 mask
= image_spec_value (spec
, QCheuristic_mask
, NULL
);
1823 x_build_heuristic_mask (f
, img
, mask
);
1828 mask
= image_spec_value (spec
, QCmask
, &found_p
);
1830 if (EQ (mask
, Qheuristic
))
1831 x_build_heuristic_mask (f
, img
, Qt
);
1832 else if (CONSP (mask
)
1833 && EQ (XCAR (mask
), Qheuristic
))
1835 if (CONSP (XCDR (mask
)))
1836 x_build_heuristic_mask (f
, img
, XCAR (XCDR (mask
)));
1838 x_build_heuristic_mask (f
, img
, XCDR (mask
));
1840 else if (NILP (mask
) && found_p
&& img
->mask
)
1842 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
1843 img
->mask
= NO_PIXMAP
;
1848 /* Should we apply an image transformation algorithm? */
1849 conversion
= image_spec_value (spec
, QCconversion
, NULL
);
1850 if (EQ (conversion
, Qdisabled
))
1851 x_disable_image (f
, img
);
1852 else if (EQ (conversion
, Qlaplace
))
1854 else if (EQ (conversion
, Qemboss
))
1856 else if (CONSP (conversion
)
1857 && EQ (XCAR (conversion
), Qedge_detection
))
1860 tem
= XCDR (conversion
);
1862 x_edge_detection (f
, img
,
1863 Fplist_get (tem
, QCmatrix
),
1864 Fplist_get (tem
, QCcolor_adjustment
));
1870 /* Return the id of image with Lisp specification SPEC on frame F.
1871 SPEC must be a valid Lisp image specification (see valid_image_p). */
1874 lookup_image (f
, spec
)
1878 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
1882 struct gcpro gcpro1
;
1885 /* F must be a window-system frame, and SPEC must be a valid image
1887 xassert (FRAME_WINDOW_P (f
));
1888 xassert (valid_image_p (spec
));
1892 /* Look up SPEC in the hash table of the image cache. */
1893 hash
= sxhash (spec
, 0);
1894 i
= hash
% IMAGE_CACHE_BUCKETS_SIZE
;
1896 for (img
= c
->buckets
[i
]; img
; img
= img
->next
)
1897 if (img
->hash
== hash
&& !NILP (Fequal (img
->spec
, spec
)))
1900 if (img
&& img
->load_failed_p
)
1902 free_image (f
, img
);
1906 /* If not found, create a new image and cache it. */
1909 extern Lisp_Object Qpostscript
;
1912 img
= make_image (spec
, hash
);
1913 cache_image (f
, img
);
1914 img
->load_failed_p
= img
->type
->load (f
, img
) == 0;
1916 /* If we can't load the image, and we don't have a width and
1917 height, use some arbitrary width and height so that we can
1918 draw a rectangle for it. */
1919 if (img
->load_failed_p
)
1923 value
= image_spec_value (spec
, QCwidth
, NULL
);
1924 img
->width
= (INTEGERP (value
)
1925 ? XFASTINT (value
) : DEFAULT_IMAGE_WIDTH
);
1926 value
= image_spec_value (spec
, QCheight
, NULL
);
1927 img
->height
= (INTEGERP (value
)
1928 ? XFASTINT (value
) : DEFAULT_IMAGE_HEIGHT
);
1932 /* Handle image type independent image attributes
1933 `:ascent ASCENT', `:margin MARGIN', `:relief RELIEF',
1934 `:background COLOR'. */
1935 Lisp_Object ascent
, margin
, relief
, bg
;
1937 ascent
= image_spec_value (spec
, QCascent
, NULL
);
1938 if (INTEGERP (ascent
))
1939 img
->ascent
= XFASTINT (ascent
);
1940 else if (EQ (ascent
, Qcenter
))
1941 img
->ascent
= CENTERED_IMAGE_ASCENT
;
1943 margin
= image_spec_value (spec
, QCmargin
, NULL
);
1944 if (INTEGERP (margin
) && XINT (margin
) >= 0)
1945 img
->vmargin
= img
->hmargin
= XFASTINT (margin
);
1946 else if (CONSP (margin
) && INTEGERP (XCAR (margin
))
1947 && INTEGERP (XCDR (margin
)))
1949 if (XINT (XCAR (margin
)) > 0)
1950 img
->hmargin
= XFASTINT (XCAR (margin
));
1951 if (XINT (XCDR (margin
)) > 0)
1952 img
->vmargin
= XFASTINT (XCDR (margin
));
1955 relief
= image_spec_value (spec
, QCrelief
, NULL
);
1956 if (INTEGERP (relief
))
1958 img
->relief
= XINT (relief
);
1959 img
->hmargin
+= abs (img
->relief
);
1960 img
->vmargin
+= abs (img
->relief
);
1963 if (! img
->background_valid
)
1965 bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
1969 = x_alloc_image_color (f
, img
, bg
,
1970 FRAME_BACKGROUND_PIXEL (f
));
1971 img
->background_valid
= 1;
1975 /* Do image transformations and compute masks, unless we
1976 don't have the image yet. */
1977 if (!EQ (*img
->type
->type
, Qpostscript
))
1978 postprocess_image (f
, img
);
1984 /* We're using IMG, so set its timestamp to `now'. */
1985 EMACS_GET_TIME (now
);
1986 img
->timestamp
= EMACS_SECS (now
);
1990 /* Value is the image id. */
1995 /* Cache image IMG in the image cache of frame F. */
1998 cache_image (f
, img
)
2002 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
2005 /* Find a free slot in c->images. */
2006 for (i
= 0; i
< c
->used
; ++i
)
2007 if (c
->images
[i
] == NULL
)
2010 /* If no free slot found, maybe enlarge c->images. */
2011 if (i
== c
->used
&& c
->used
== c
->size
)
2014 c
->images
= (struct image
**) xrealloc (c
->images
,
2015 c
->size
* sizeof *c
->images
);
2018 /* Add IMG to c->images, and assign IMG an id. */
2024 /* Add IMG to the cache's hash table. */
2025 i
= img
->hash
% IMAGE_CACHE_BUCKETS_SIZE
;
2026 img
->next
= c
->buckets
[i
];
2028 img
->next
->prev
= img
;
2030 c
->buckets
[i
] = img
;
2034 /* Call FN on every image in the image cache of frame F. Used to mark
2035 Lisp Objects in the image cache. */
2038 forall_images_in_image_cache (f
, fn
)
2040 void (*fn
) P_ ((struct image
*img
));
2042 if (FRAME_LIVE_P (f
) && FRAME_WINDOW_P (f
))
2044 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
2048 for (i
= 0; i
< c
->used
; ++i
)
2057 /***********************************************************************
2058 X / MAC / W32 support code
2059 ***********************************************************************/
2063 /* Macro for defining functions that will be loaded from image DLLs. */
2064 #define DEF_IMGLIB_FN(func) int (FAR CDECL *fn_##func)()
2066 /* Macro for loading those image functions from the library. */
2067 #define LOAD_IMGLIB_FN(lib,func) { \
2068 fn_##func = (void *) GetProcAddress (lib, #func); \
2069 if (!fn_##func) return 0; \
2072 /* Load a DLL implementing an image type.
2073 The `image-library-alist' variable associates a symbol,
2074 identifying an image type, to a list of possible filenames.
2075 The function returns NULL if no library could be loaded for
2076 the given image type, or if the library was previously loaded;
2077 else the handle of the DLL. */
2079 w32_delayed_load (Lisp_Object libraries
, Lisp_Object type
)
2081 HMODULE library
= NULL
;
2083 if (CONSP (libraries
) && NILP (Fassq (type
, Vimage_type_cache
)))
2085 Lisp_Object dlls
= Fassq (type
, libraries
);
2088 for (dlls
= XCDR (dlls
); CONSP (dlls
); dlls
= XCDR (dlls
))
2090 CHECK_STRING_CAR (dlls
);
2091 if (library
= LoadLibrary (SDATA (XCAR (dlls
))))
2099 #endif /* HAVE_NTGUI */
2101 static int x_create_x_image_and_pixmap
P_ ((struct frame
*, int, int, int,
2102 XImagePtr
*, Pixmap
*));
2103 static void x_destroy_x_image
P_ ((XImagePtr
));
2104 static void x_put_x_image
P_ ((struct frame
*, XImagePtr
, Pixmap
, int, int));
2107 /* Create an XImage and a pixmap of size WIDTH x HEIGHT for use on
2108 frame F. Set *XIMG and *PIXMAP to the XImage and Pixmap created.
2109 Set (*XIMG)->data to a raster of WIDTH x HEIGHT pixels allocated
2110 via xmalloc. Print error messages via image_error if an error
2111 occurs. Value is non-zero if successful.
2113 On W32, a DEPTH of zero signifies a 24 bit image, otherwise DEPTH
2114 should indicate the bit depth of the image. */
2117 x_create_x_image_and_pixmap (f
, width
, height
, depth
, ximg
, pixmap
)
2119 int width
, height
, depth
;
2123 #ifdef HAVE_X_WINDOWS
2124 Display
*display
= FRAME_X_DISPLAY (f
);
2125 Window window
= FRAME_X_WINDOW (f
);
2126 Screen
*screen
= FRAME_X_SCREEN (f
);
2128 xassert (interrupt_input_blocked
);
2131 depth
= DefaultDepthOfScreen (screen
);
2132 *ximg
= XCreateImage (display
, DefaultVisualOfScreen (screen
),
2133 depth
, ZPixmap
, 0, NULL
, width
, height
,
2134 depth
> 16 ? 32 : depth
> 8 ? 16 : 8, 0);
2137 image_error ("Unable to allocate X image", Qnil
, Qnil
);
2141 /* Allocate image raster. */
2142 (*ximg
)->data
= (char *) xmalloc ((*ximg
)->bytes_per_line
* height
);
2144 /* Allocate a pixmap of the same size. */
2145 *pixmap
= XCreatePixmap (display
, window
, width
, height
, depth
);
2146 if (*pixmap
== NO_PIXMAP
)
2148 x_destroy_x_image (*ximg
);
2150 image_error ("Unable to create X pixmap", Qnil
, Qnil
);
2155 #endif /* HAVE_X_WINDOWS */
2159 BITMAPINFOHEADER
*header
;
2161 int scanline_width_bits
;
2163 int palette_colors
= 0;
2168 if (depth
!= 1 && depth
!= 4 && depth
!= 8
2169 && depth
!= 16 && depth
!= 24 && depth
!= 32)
2171 image_error ("Invalid image bit depth specified", Qnil
, Qnil
);
2175 scanline_width_bits
= width
* depth
;
2176 remainder
= scanline_width_bits
% 32;
2179 scanline_width_bits
+= 32 - remainder
;
2181 /* Bitmaps with a depth less than 16 need a palette. */
2182 /* BITMAPINFO structure already contains the first RGBQUAD. */
2184 palette_colors
= 1 << depth
- 1;
2186 *ximg
= xmalloc (sizeof (XImage
) + palette_colors
* sizeof (RGBQUAD
));
2189 image_error ("Unable to allocate memory for XImage", Qnil
, Qnil
);
2193 header
= &((*ximg
)->info
.bmiHeader
);
2194 bzero (&((*ximg
)->info
), sizeof (BITMAPINFO
));
2195 header
->biSize
= sizeof (*header
);
2196 header
->biWidth
= width
;
2197 header
->biHeight
= -height
; /* negative indicates a top-down bitmap. */
2198 header
->biPlanes
= 1;
2199 header
->biBitCount
= depth
;
2200 header
->biCompression
= BI_RGB
;
2201 header
->biClrUsed
= palette_colors
;
2203 /* TODO: fill in palette. */
2206 (*ximg
)->info
.bmiColors
[0].rgbBlue
= 0;
2207 (*ximg
)->info
.bmiColors
[0].rgbGreen
= 0;
2208 (*ximg
)->info
.bmiColors
[0].rgbRed
= 0;
2209 (*ximg
)->info
.bmiColors
[0].rgbReserved
= 0;
2210 (*ximg
)->info
.bmiColors
[1].rgbBlue
= 255;
2211 (*ximg
)->info
.bmiColors
[1].rgbGreen
= 255;
2212 (*ximg
)->info
.bmiColors
[1].rgbRed
= 255;
2213 (*ximg
)->info
.bmiColors
[1].rgbReserved
= 0;
2216 hdc
= get_frame_dc (f
);
2218 /* Create a DIBSection and raster array for the bitmap,
2219 and store its handle in *pixmap. */
2220 *pixmap
= CreateDIBSection (hdc
, &((*ximg
)->info
),
2221 (depth
< 16) ? DIB_PAL_COLORS
: DIB_RGB_COLORS
,
2222 /* casting avoids a GCC warning */
2223 (void **)&((*ximg
)->data
), NULL
, 0);
2225 /* Realize display palette and garbage all frames. */
2226 release_frame_dc (f
, hdc
);
2228 if (*pixmap
== NULL
)
2230 DWORD err
= GetLastError();
2231 Lisp_Object errcode
;
2232 /* All system errors are < 10000, so the following is safe. */
2233 XSETINT (errcode
, (int) err
);
2234 image_error ("Unable to create bitmap, error code %d", errcode
, Qnil
);
2235 x_destroy_x_image (*ximg
);
2241 #endif /* HAVE_NTGUI */
2244 Display
*display
= FRAME_X_DISPLAY (f
);
2245 Window window
= FRAME_X_WINDOW (f
);
2247 xassert (interrupt_input_blocked
);
2249 /* Allocate a pixmap of the same size. */
2250 *pixmap
= XCreatePixmap (display
, window
, width
, height
, depth
);
2251 if (*pixmap
== NO_PIXMAP
)
2254 image_error ("Unable to create X pixmap", Qnil
, Qnil
);
2258 LockPixels (GetGWorldPixMap (*pixmap
));
2266 /* Destroy XImage XIMG. Free XIMG->data. */
2269 x_destroy_x_image (ximg
)
2272 xassert (interrupt_input_blocked
);
2275 #ifdef HAVE_X_WINDOWS
2278 XDestroyImage (ximg
);
2279 #endif /* HAVE_X_WINDOWS */
2281 /* Data will be freed by DestroyObject. */
2284 #endif /* HAVE_NTGUI */
2286 XDestroyImage (ximg
);
2292 /* Put XImage XIMG into pixmap PIXMAP on frame F. WIDTH and HEIGHT
2293 are width and height of both the image and pixmap. */
2296 x_put_x_image (f
, ximg
, pixmap
, width
, height
)
2302 #ifdef HAVE_X_WINDOWS
2305 xassert (interrupt_input_blocked
);
2306 gc
= XCreateGC (FRAME_X_DISPLAY (f
), pixmap
, 0, NULL
);
2307 XPutImage (FRAME_X_DISPLAY (f
), pixmap
, gc
, ximg
, 0, 0, 0, 0, width
, height
);
2308 XFreeGC (FRAME_X_DISPLAY (f
), gc
);
2309 #endif /* HAVE_X_WINDOWS */
2312 #if 0 /* I don't think this is necessary looking at where it is used. */
2313 HDC hdc
= get_frame_dc (f
);
2314 SetDIBits (hdc
, pixmap
, 0, height
, ximg
->data
, &(ximg
->info
), DIB_RGB_COLORS
);
2315 release_frame_dc (f
, hdc
);
2317 #endif /* HAVE_NTGUI */
2320 xassert (ximg
== pixmap
);
2325 /***********************************************************************
2327 ***********************************************************************/
2329 static unsigned char *slurp_file
P_ ((char *, int *));
2332 /* Find image file FILE. Look in data-directory, then
2333 x-bitmap-file-path. Value is the encoded full name of the file
2334 found, or nil if not found. */
2337 x_find_image_file (file
)
2340 Lisp_Object file_found
, search_path
;
2341 struct gcpro gcpro1
, gcpro2
;
2345 search_path
= Fcons (Vdata_directory
, Vx_bitmap_file_path
);
2346 GCPRO2 (file_found
, search_path
);
2348 /* Try to find FILE in data-directory, then x-bitmap-file-path. */
2349 fd
= openp (search_path
, file
, Qnil
, &file_found
, Qnil
);
2355 file_found
= ENCODE_FILE (file_found
);
2364 /* Read FILE into memory. Value is a pointer to a buffer allocated
2365 with xmalloc holding FILE's contents. Value is null if an error
2366 occurred. *SIZE is set to the size of the file. */
2368 static unsigned char *
2369 slurp_file (file
, size
)
2374 unsigned char *buf
= NULL
;
2377 if (stat (file
, &st
) == 0
2378 && (fp
= fopen (file
, "rb")) != NULL
2379 && (buf
= (unsigned char *) xmalloc (st
.st_size
),
2380 fread (buf
, 1, st
.st_size
, fp
) == st
.st_size
))
2403 /***********************************************************************
2404 MAC Image Load Functions
2405 ***********************************************************************/
2407 static int image_load_quicktime
P_ ((struct frame
*, struct image
*img
,
2410 static int image_load_quartz2d
P_ ((struct frame
*, struct image
*img
, int));
2414 find_image_fsspec (specified_file
, file
, fss
)
2415 Lisp_Object specified_file
, *file
;
2421 *file
= x_find_image_file (specified_file
);
2422 if (!STRINGP (*file
))
2423 return fnfErr
; /* file or directory not found;
2424 incomplete pathname */
2425 /* Try to open the image file. */
2426 err
= AECoercePtr (TYPE_FILE_NAME
, SDATA (*file
),
2427 SBYTES (*file
), typeFSS
, &desc
);
2430 #if TARGET_API_MAC_CARBON
2431 err
= AEGetDescData (&desc
, fss
, sizeof (FSSpec
));
2433 *fss
= *(FSSpec
*)(*(desc
.dataHandle
));
2435 AEDisposeDesc (&desc
);
2441 image_load_qt_1 (f
, img
, type
, fss
, dh
)
2448 ComponentResult err
;
2449 GraphicsImportComponent gi
;
2452 ImageDescriptionHandle desc_handle
;
2453 short draw_all_pixels
;
2454 Lisp_Object specified_bg
;
2459 err
= OpenADefaultComponent (GraphicsImporterComponentType
, type
, &gi
);
2462 image_error ("Cannot get importer component for `%s'", img
->spec
, Qnil
);
2467 /* read from file system spec */
2468 err
= GraphicsImportSetDataFile (gi
, fss
);
2471 image_error ("Cannot set fsspec to graphics importer for '%s'",
2478 /* read from data handle */
2479 err
= GraphicsImportSetDataHandle (gi
, dh
);
2482 image_error ("Cannot set data handle to graphics importer for `%s'",
2487 err
= GraphicsImportGetImageDescription (gi
, &desc_handle
);
2488 if (err
!= noErr
|| desc_handle
== NULL
)
2490 image_error ("Error reading `%s'", img
->spec
, Qnil
);
2493 width
= img
->width
= (*desc_handle
)->width
;
2494 height
= img
->height
= (*desc_handle
)->height
;
2495 DisposeHandle ((Handle
)desc_handle
);
2497 if (!check_image_size (f
, width
, height
))
2499 image_error ("Invalid image size", Qnil
, Qnil
);
2503 err
= GraphicsImportDoesDrawAllPixels (gi
, &draw_all_pixels
);
2505 /* Don't check the error code here. It may have an undocumented
2509 image_error ("Error reading `%s'", img
->spec
, Qnil
);
2513 if (draw_all_pixels
!= graphicsImporterDrawsAllPixels
)
2515 specified_bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
2516 if (!STRINGP (specified_bg
) ||
2517 !mac_defined_color (f
, SDATA (specified_bg
), &color
, 0))
2519 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
2520 color
.red
= RED16_FROM_ULONG (color
.pixel
);
2521 color
.green
= GREEN16_FROM_ULONG (color
.pixel
);
2522 color
.blue
= BLUE16_FROM_ULONG (color
.pixel
);
2526 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
2528 if (draw_all_pixels
!= graphicsImporterDrawsAllPixels
)
2533 GetGWorld (&old_port
, &old_gdh
);
2534 SetGWorld (ximg
, NULL
);
2535 bg_color
.red
= color
.red
;
2536 bg_color
.green
= color
.green
;
2537 bg_color
.blue
= color
.blue
;
2538 RGBBackColor (&bg_color
);
2539 #if TARGET_API_MAC_CARBON
2540 GetPortBounds (ximg
, &rect
);
2543 EraseRect (&(ximg
->portRect
));
2545 SetGWorld (old_port
, old_gdh
);
2547 GraphicsImportSetGWorld (gi
, ximg
, NULL
);
2548 GraphicsImportDraw (gi
);
2549 CloseComponent (gi
);
2551 /* Maybe fill in the background field while we have ximg handy. */
2552 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
2553 IMAGE_BACKGROUND (img
, f
, ximg
);
2555 /* Put the image into the pixmap. */
2556 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
2557 x_destroy_x_image (ximg
);
2561 CloseComponent (gi
);
2566 /* Load an image using the QuickTime Graphics Importer.
2567 Note: The alpha channel does not work for PNG images. */
2569 image_load_quicktime (f
, img
, type
)
2574 Lisp_Object specified_file
;
2575 Lisp_Object specified_data
;
2578 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
2579 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
2581 if (NILP (specified_data
))
2583 /* Read from a file */
2587 err
= find_image_fsspec (specified_file
, &file
, &fss
);
2591 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
2593 image_error ("Cannot open `%s'", file
, Qnil
);
2596 return image_load_qt_1 (f
, img
, type
, &fss
, NULL
);
2600 /* Memory source! */
2604 err
= PtrToHand (SDATA (specified_data
), &dh
, SBYTES (specified_data
));
2607 image_error ("Cannot allocate data handle for `%s'",
2611 success_p
= image_load_qt_1 (f
, img
, type
, NULL
, dh
);
2619 /* Load a PNG/JPEG image using Quartz 2D decoding routines.
2620 CGImageCreateWithPNGDataProvider is provided after Mac OS X 10.2.
2621 So don't use this function directly but determine at runtime
2622 whether it exists. */
2623 typedef CGImageRef (*CGImageCreateWithPNGDataProviderProcType
)
2624 (CGDataProviderRef
, const float [], bool, CGColorRenderingIntent
);
2625 static CGImageCreateWithPNGDataProviderProcType MyCGImageCreateWithPNGDataProvider
;
2629 init_image_func_pointer ()
2631 if (NSIsSymbolNameDefined ("_CGImageCreateWithPNGDataProvider"))
2633 MyCGImageCreateWithPNGDataProvider
2634 = (CGImageCreateWithPNGDataProviderProcType
)
2635 NSAddressOfSymbol (NSLookupAndBindSymbol
2636 ("_CGImageCreateWithPNGDataProvider"));
2639 MyCGImageCreateWithPNGDataProvider
= NULL
;
2644 image_load_quartz2d (f
, img
, png_p
)
2649 Lisp_Object file
, specified_file
;
2650 Lisp_Object specified_data
, specified_bg
;
2651 struct gcpro gcpro1
;
2652 CGDataProviderRef source
;
2656 XImagePtr ximg
= NULL
;
2657 CGContextRef context
;
2660 /* Open the file. */
2661 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
2662 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
2667 if (NILP (specified_data
))
2672 file
= x_find_image_file (specified_file
);
2673 if (!STRINGP (file
))
2675 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
2679 path
= cfstring_create_with_utf8_cstring (SDATA (file
));
2680 url
= CFURLCreateWithFileSystemPath (NULL
, path
,
2681 kCFURLPOSIXPathStyle
, 0);
2683 source
= CGDataProviderCreateWithURL (url
);
2687 source
= CGDataProviderCreateWithData (NULL
, SDATA (specified_data
),
2688 SBYTES (specified_data
), NULL
);
2691 image
= (*MyCGImageCreateWithPNGDataProvider
) (source
, NULL
, FALSE
,
2692 kCGRenderingIntentDefault
);
2694 image
= CGImageCreateWithJPEGDataProvider (source
, NULL
, FALSE
,
2695 kCGRenderingIntentDefault
);
2697 CGDataProviderRelease (source
);
2701 image_error ("Error reading image `%s'", img
->spec
, Qnil
);
2704 width
= img
->width
= CGImageGetWidth (image
);
2705 height
= img
->height
= CGImageGetHeight (image
);
2707 if (!check_image_size (f
, width
, height
))
2709 CGImageRelease (image
);
2711 image_error ("Invalid image size", Qnil
, Qnil
);
2717 specified_bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
2718 if (!STRINGP (specified_bg
) ||
2719 !mac_defined_color (f
, SDATA (specified_bg
), &color
, 0))
2721 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
2722 color
.red
= RED16_FROM_ULONG (color
.pixel
);
2723 color
.green
= GREEN16_FROM_ULONG (color
.pixel
);
2724 color
.blue
= BLUE16_FROM_ULONG (color
.pixel
);
2728 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
2730 CGImageRelease (image
);
2734 rectangle
= CGRectMake (0, 0, width
, height
);
2735 QDBeginCGContext (ximg
, &context
);
2738 CGContextSetRGBFillColor (context
, color
.red
/ 65535.0,
2739 color
.green
/ 65535.0,
2740 color
.blue
/ 65535.0, 1.0);
2741 CGContextFillRect (context
, rectangle
);
2743 CGContextDrawImage (context
, rectangle
, image
);
2744 QDEndCGContext (ximg
, &context
);
2745 CGImageRelease (image
);
2747 /* Maybe fill in the background field while we have ximg handy. */
2748 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
2749 IMAGE_BACKGROUND (img
, f
, ximg
);
2751 /* Put the image into the pixmap. */
2752 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
2753 x_destroy_x_image (ximg
);
2762 /***********************************************************************
2764 ***********************************************************************/
2766 static int xbm_scan
P_ ((unsigned char **, unsigned char *, char *, int *));
2767 static int xbm_load
P_ ((struct frame
*f
, struct image
*img
));
2768 static int xbm_load_image
P_ ((struct frame
*f
, struct image
*img
,
2769 unsigned char *, unsigned char *));
2770 static int xbm_image_p
P_ ((Lisp_Object object
));
2771 static int xbm_read_bitmap_data
P_ ((struct frame
*f
,
2772 unsigned char *, unsigned char *,
2773 int *, int *, unsigned char **));
2774 static int xbm_file_p
P_ ((Lisp_Object
));
2777 /* Indices of image specification fields in xbm_format, below. */
2779 enum xbm_keyword_index
2797 /* Vector of image_keyword structures describing the format
2798 of valid XBM image specifications. */
2800 static struct image_keyword xbm_format
[XBM_LAST
] =
2802 {":type", IMAGE_SYMBOL_VALUE
, 1},
2803 {":file", IMAGE_STRING_VALUE
, 0},
2804 {":width", IMAGE_POSITIVE_INTEGER_VALUE
, 0},
2805 {":height", IMAGE_POSITIVE_INTEGER_VALUE
, 0},
2806 {":data", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
2807 {":foreground", IMAGE_STRING_OR_NIL_VALUE
, 0},
2808 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0},
2809 {":ascent", IMAGE_ASCENT_VALUE
, 0},
2810 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
2811 {":relief", IMAGE_INTEGER_VALUE
, 0},
2812 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
2813 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
2814 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0}
2817 /* Structure describing the image type XBM. */
2819 static struct image_type xbm_type
=
2828 /* Tokens returned from xbm_scan. */
2837 /* Return non-zero if OBJECT is a valid XBM-type image specification.
2838 A valid specification is a list starting with the symbol `image'
2839 The rest of the list is a property list which must contain an
2842 If the specification specifies a file to load, it must contain
2843 an entry `:file FILENAME' where FILENAME is a string.
2845 If the specification is for a bitmap loaded from memory it must
2846 contain `:width WIDTH', `:height HEIGHT', and `:data DATA', where
2847 WIDTH and HEIGHT are integers > 0. DATA may be:
2849 1. a string large enough to hold the bitmap data, i.e. it must
2850 have a size >= (WIDTH + 7) / 8 * HEIGHT
2852 2. a bool-vector of size >= WIDTH * HEIGHT
2854 3. a vector of strings or bool-vectors, one for each line of the
2857 4. A string containing an in-memory XBM file. WIDTH and HEIGHT
2858 may not be specified in this case because they are defined in the
2861 Both the file and data forms may contain the additional entries
2862 `:background COLOR' and `:foreground COLOR'. If not present,
2863 foreground and background of the frame on which the image is
2864 displayed is used. */
2867 xbm_image_p (object
)
2870 struct image_keyword kw
[XBM_LAST
];
2872 bcopy (xbm_format
, kw
, sizeof kw
);
2873 if (!parse_image_spec (object
, kw
, XBM_LAST
, Qxbm
))
2876 xassert (EQ (kw
[XBM_TYPE
].value
, Qxbm
));
2878 if (kw
[XBM_FILE
].count
)
2880 if (kw
[XBM_WIDTH
].count
|| kw
[XBM_HEIGHT
].count
|| kw
[XBM_DATA
].count
)
2883 else if (kw
[XBM_DATA
].count
&& xbm_file_p (kw
[XBM_DATA
].value
))
2885 /* In-memory XBM file. */
2886 if (kw
[XBM_WIDTH
].count
|| kw
[XBM_HEIGHT
].count
|| kw
[XBM_FILE
].count
)
2894 /* Entries for `:width', `:height' and `:data' must be present. */
2895 if (!kw
[XBM_WIDTH
].count
2896 || !kw
[XBM_HEIGHT
].count
2897 || !kw
[XBM_DATA
].count
)
2900 data
= kw
[XBM_DATA
].value
;
2901 width
= XFASTINT (kw
[XBM_WIDTH
].value
);
2902 height
= XFASTINT (kw
[XBM_HEIGHT
].value
);
2904 /* Check type of data, and width and height against contents of
2910 /* Number of elements of the vector must be >= height. */
2911 if (XVECTOR (data
)->size
< height
)
2914 /* Each string or bool-vector in data must be large enough
2915 for one line of the image. */
2916 for (i
= 0; i
< height
; ++i
)
2918 Lisp_Object elt
= XVECTOR (data
)->contents
[i
];
2923 < (width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
)
2926 else if (BOOL_VECTOR_P (elt
))
2928 if (XBOOL_VECTOR (elt
)->size
< width
)
2935 else if (STRINGP (data
))
2938 < (width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
* height
)
2941 else if (BOOL_VECTOR_P (data
))
2943 if (XBOOL_VECTOR (data
)->size
< width
* height
)
2954 /* Scan a bitmap file. FP is the stream to read from. Value is
2955 either an enumerator from enum xbm_token, or a character for a
2956 single-character token, or 0 at end of file. If scanning an
2957 identifier, store the lexeme of the identifier in SVAL. If
2958 scanning a number, store its value in *IVAL. */
2961 xbm_scan (s
, end
, sval
, ival
)
2962 unsigned char **s
, *end
;
2970 /* Skip white space. */
2971 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
2976 else if (isdigit (c
))
2978 int value
= 0, digit
;
2980 if (c
== '0' && *s
< end
)
2983 if (c
== 'x' || c
== 'X')
2990 else if (c
>= 'a' && c
<= 'f')
2991 digit
= c
- 'a' + 10;
2992 else if (c
>= 'A' && c
<= 'F')
2993 digit
= c
- 'A' + 10;
2996 value
= 16 * value
+ digit
;
2999 else if (isdigit (c
))
3003 && (c
= *(*s
)++, isdigit (c
)))
3004 value
= 8 * value
+ c
- '0';
3011 && (c
= *(*s
)++, isdigit (c
)))
3012 value
= 10 * value
+ c
- '0';
3020 else if (isalpha (c
) || c
== '_')
3024 && (c
= *(*s
)++, (isalnum (c
) || c
== '_')))
3031 else if (c
== '/' && **s
== '*')
3033 /* C-style comment. */
3035 while (**s
&& (**s
!= '*' || *(*s
+ 1) != '/'))
3049 /* Create a Windows bitmap from X bitmap data. */
3051 w32_create_pixmap_from_bitmap_data (int width
, int height
, char *data
)
3053 static unsigned char swap_nibble
[16]
3054 = { 0x0, 0x8, 0x4, 0xc, /* 0000 1000 0100 1100 */
3055 0x2, 0xa, 0x6, 0xe, /* 0010 1010 0110 1110 */
3056 0x1, 0x9, 0x5, 0xd, /* 0001 1001 0101 1101 */
3057 0x3, 0xb, 0x7, 0xf }; /* 0011 1011 0111 1111 */
3059 unsigned char *bits
, *p
;
3062 w1
= (width
+ 7) / 8; /* nb of 8bits elt in X bitmap */
3063 w2
= ((width
+ 15) / 16) * 2; /* nb of 16bits elt in W32 bitmap */
3064 bits
= (unsigned char *) alloca (height
* w2
);
3065 bzero (bits
, height
* w2
);
3066 for (i
= 0; i
< height
; i
++)
3069 for (j
= 0; j
< w1
; j
++)
3071 /* Bitswap XBM bytes to match how Windows does things. */
3072 unsigned char c
= *data
++;
3073 *p
++ = (unsigned char)((swap_nibble
[c
& 0xf] << 4)
3074 | (swap_nibble
[(c
>>4) & 0xf]));
3077 bmp
= CreateBitmap (width
, height
, 1, 1, (char *) bits
);
3082 static void convert_mono_to_color_image (f
, img
, foreground
, background
)
3085 COLORREF foreground
, background
;
3087 HDC hdc
, old_img_dc
, new_img_dc
;
3088 HGDIOBJ old_prev
, new_prev
;
3091 hdc
= get_frame_dc (f
);
3092 old_img_dc
= CreateCompatibleDC (hdc
);
3093 new_img_dc
= CreateCompatibleDC (hdc
);
3094 new_pixmap
= CreateCompatibleBitmap (hdc
, img
->width
, img
->height
);
3095 release_frame_dc (f
, hdc
);
3096 old_prev
= SelectObject (old_img_dc
, img
->pixmap
);
3097 new_prev
= SelectObject (new_img_dc
, new_pixmap
);
3098 SetTextColor (new_img_dc
, foreground
);
3099 SetBkColor (new_img_dc
, background
);
3101 BitBlt (new_img_dc
, 0, 0, img
->width
, img
->height
, old_img_dc
,
3104 SelectObject (old_img_dc
, old_prev
);
3105 SelectObject (new_img_dc
, new_prev
);
3106 DeleteDC (old_img_dc
);
3107 DeleteDC (new_img_dc
);
3108 DeleteObject (img
->pixmap
);
3109 if (new_pixmap
== 0)
3110 fprintf (stderr
, "Failed to convert image to color.\n");
3112 img
->pixmap
= new_pixmap
;
3115 #define XBM_BIT_SHUFFLE(b) (~(b))
3119 #define XBM_BIT_SHUFFLE(b) (b)
3121 #endif /* HAVE_NTGUI */
3125 Create_Pixmap_From_Bitmap_Data(f
, img
, data
, fg
, bg
, non_default_colors
)
3129 RGB_PIXEL_COLOR fg
, bg
;
3130 int non_default_colors
;
3134 = w32_create_pixmap_from_bitmap_data (img
->width
, img
->height
, data
);
3136 /* If colors were specified, transfer the bitmap to a color one. */
3137 if (non_default_colors
)
3138 convert_mono_to_color_image (f
, img
, fg
, bg
);
3141 = XCreatePixmapFromBitmapData (FRAME_X_DISPLAY (f
),
3144 img
->width
, img
->height
,
3146 DefaultDepthOfScreen (FRAME_X_SCREEN (f
)));
3147 #endif /* HAVE_NTGUI */
3152 /* Replacement for XReadBitmapFileData which isn't available under old
3153 X versions. CONTENTS is a pointer to a buffer to parse; END is the
3154 buffer's end. Set *WIDTH and *HEIGHT to the width and height of
3155 the image. Return in *DATA the bitmap data allocated with xmalloc.
3156 Value is non-zero if successful. DATA null means just test if
3157 CONTENTS looks like an in-memory XBM file. */
3160 xbm_read_bitmap_data (f
, contents
, end
, width
, height
, data
)
3162 unsigned char *contents
, *end
;
3163 int *width
, *height
;
3164 unsigned char **data
;
3166 unsigned char *s
= contents
;
3167 char buffer
[BUFSIZ
];
3170 int bytes_per_line
, i
, nbytes
;
3176 LA1 = xbm_scan (&s, end, buffer, &value)
3178 #define expect(TOKEN) \
3179 if (LA1 != (TOKEN)) \
3184 #define expect_ident(IDENT) \
3185 if (LA1 == XBM_TK_IDENT && strcmp (buffer, (IDENT)) == 0) \
3190 *width
= *height
= -1;
3193 LA1
= xbm_scan (&s
, end
, buffer
, &value
);
3195 /* Parse defines for width, height and hot-spots. */
3199 expect_ident ("define");
3200 expect (XBM_TK_IDENT
);
3202 if (LA1
== XBM_TK_NUMBER
)
3204 char *p
= strrchr (buffer
, '_');
3205 p
= p
? p
+ 1 : buffer
;
3206 if (strcmp (p
, "width") == 0)
3208 else if (strcmp (p
, "height") == 0)
3211 expect (XBM_TK_NUMBER
);
3214 if (!check_image_size (f
, *width
, *height
))
3216 else if (data
== NULL
)
3219 /* Parse bits. Must start with `static'. */
3220 expect_ident ("static");
3221 if (LA1
== XBM_TK_IDENT
)
3223 if (strcmp (buffer
, "unsigned") == 0)
3226 expect_ident ("char");
3228 else if (strcmp (buffer
, "short") == 0)
3232 if (*width
% 16 && *width
% 16 < 9)
3235 else if (strcmp (buffer
, "char") == 0)
3243 expect (XBM_TK_IDENT
);
3249 bytes_per_line
= (*width
+ 7) / 8 + padding_p
;
3250 nbytes
= bytes_per_line
* *height
;
3251 p
= *data
= (unsigned char *) xmalloc (nbytes
);
3255 for (i
= 0; i
< nbytes
; i
+= 2)
3258 expect (XBM_TK_NUMBER
);
3260 *p
++ = XBM_BIT_SHUFFLE (val
);
3261 if (!padding_p
|| ((i
+ 2) % bytes_per_line
))
3262 *p
++ = XBM_BIT_SHUFFLE (value
>> 8);
3264 if (LA1
== ',' || LA1
== '}')
3272 for (i
= 0; i
< nbytes
; ++i
)
3275 expect (XBM_TK_NUMBER
);
3277 *p
++ = XBM_BIT_SHUFFLE (val
);
3279 if (LA1
== ',' || LA1
== '}')
3304 /* Load XBM image IMG which will be displayed on frame F from buffer
3305 CONTENTS. END is the end of the buffer. Value is non-zero if
3309 xbm_load_image (f
, img
, contents
, end
)
3312 unsigned char *contents
, *end
;
3315 unsigned char *data
;
3318 rc
= xbm_read_bitmap_data (f
, contents
, end
, &img
->width
, &img
->height
, &data
);
3321 unsigned long foreground
= FRAME_FOREGROUND_PIXEL (f
);
3322 unsigned long background
= FRAME_BACKGROUND_PIXEL (f
);
3323 int non_default_colors
= 0;
3326 xassert (img
->width
> 0 && img
->height
> 0);
3328 /* Get foreground and background colors, maybe allocate colors. */
3329 value
= image_spec_value (img
->spec
, QCforeground
, NULL
);
3332 foreground
= x_alloc_image_color (f
, img
, value
, foreground
);
3333 non_default_colors
= 1;
3335 value
= image_spec_value (img
->spec
, QCbackground
, NULL
);
3338 background
= x_alloc_image_color (f
, img
, value
, background
);
3339 img
->background
= background
;
3340 img
->background_valid
= 1;
3341 non_default_colors
= 1;
3344 Create_Pixmap_From_Bitmap_Data (f
, img
, data
,
3345 foreground
, background
,
3346 non_default_colors
);
3349 if (img
->pixmap
== NO_PIXMAP
)
3351 x_clear_image (f
, img
);
3352 image_error ("Unable to create X pixmap for `%s'", img
->spec
, Qnil
);
3358 image_error ("Error loading XBM image `%s'", img
->spec
, Qnil
);
3364 /* Value is non-zero if DATA looks like an in-memory XBM file. */
3371 return (STRINGP (data
)
3372 && xbm_read_bitmap_data (NULL
, SDATA (data
),
3379 /* Fill image IMG which is used on frame F with pixmap data. Value is
3380 non-zero if successful. */
3388 Lisp_Object file_name
;
3390 xassert (xbm_image_p (img
->spec
));
3392 /* If IMG->spec specifies a file name, create a non-file spec from it. */
3393 file_name
= image_spec_value (img
->spec
, QCfile
, NULL
);
3394 if (STRINGP (file_name
))
3397 unsigned char *contents
;
3399 struct gcpro gcpro1
;
3401 file
= x_find_image_file (file_name
);
3403 if (!STRINGP (file
))
3405 image_error ("Cannot find image file `%s'", file_name
, Qnil
);
3410 contents
= slurp_file (SDATA (file
), &size
);
3411 if (contents
== NULL
)
3413 image_error ("Error loading XBM image `%s'", img
->spec
, Qnil
);
3418 success_p
= xbm_load_image (f
, img
, contents
, contents
+ size
);
3423 struct image_keyword fmt
[XBM_LAST
];
3425 unsigned long foreground
= FRAME_FOREGROUND_PIXEL (f
);
3426 unsigned long background
= FRAME_BACKGROUND_PIXEL (f
);
3427 int non_default_colors
= 0;
3430 int in_memory_file_p
= 0;
3432 /* See if data looks like an in-memory XBM file. */
3433 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
3434 in_memory_file_p
= xbm_file_p (data
);
3436 /* Parse the image specification. */
3437 bcopy (xbm_format
, fmt
, sizeof fmt
);
3438 parsed_p
= parse_image_spec (img
->spec
, fmt
, XBM_LAST
, Qxbm
);
3441 /* Get specified width, and height. */
3442 if (!in_memory_file_p
)
3444 img
->width
= XFASTINT (fmt
[XBM_WIDTH
].value
);
3445 img
->height
= XFASTINT (fmt
[XBM_HEIGHT
].value
);
3446 xassert (img
->width
> 0 && img
->height
> 0);
3449 /* Get foreground and background colors, maybe allocate colors. */
3450 if (fmt
[XBM_FOREGROUND
].count
3451 && STRINGP (fmt
[XBM_FOREGROUND
].value
))
3453 foreground
= x_alloc_image_color (f
, img
, fmt
[XBM_FOREGROUND
].value
,
3455 non_default_colors
= 1;
3458 if (fmt
[XBM_BACKGROUND
].count
3459 && STRINGP (fmt
[XBM_BACKGROUND
].value
))
3461 background
= x_alloc_image_color (f
, img
, fmt
[XBM_BACKGROUND
].value
,
3463 non_default_colors
= 1;
3466 if (in_memory_file_p
)
3467 success_p
= xbm_load_image (f
, img
, SDATA (data
),
3476 int nbytes
= (img
->width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
;
3478 p
= bits
= (char *) alloca (nbytes
* img
->height
);
3479 for (i
= 0; i
< img
->height
; ++i
, p
+= nbytes
)
3481 Lisp_Object line
= XVECTOR (data
)->contents
[i
];
3483 bcopy (SDATA (line
), p
, nbytes
);
3485 bcopy (XBOOL_VECTOR (line
)->data
, p
, nbytes
);
3488 else if (STRINGP (data
))
3489 bits
= SDATA (data
);
3491 bits
= XBOOL_VECTOR (data
)->data
;
3493 /* Create the pixmap. */
3495 Create_Pixmap_From_Bitmap_Data (f
, img
, bits
,
3496 foreground
, background
,
3497 non_default_colors
);
3502 image_error ("Unable to create pixmap for XBM image `%s'",
3504 x_clear_image (f
, img
);
3514 /***********************************************************************
3516 ***********************************************************************/
3518 #if defined (HAVE_XPM) || defined (MAC_OS)
3520 static int xpm_image_p
P_ ((Lisp_Object object
));
3521 static int xpm_load
P_ ((struct frame
*f
, struct image
*img
));
3522 static int xpm_valid_color_symbols_p
P_ ((Lisp_Object
));
3524 #endif /* HAVE_XPM || MAC_OS */
3528 /* Indicate to xpm.h that we don't have Xlib. */
3530 /* simx.h in xpm defines XColor and XImage differently than Emacs. */
3531 /* It also defines Display the same way as Emacs, but gcc 3.3 still barfs. */
3532 #define XColor xpm_XColor
3533 #define XImage xpm_XImage
3534 #define Display xpm_Display
3535 #define PIXEL_ALREADY_TYPEDEFED
3536 #include "X11/xpm.h"
3541 #undef PIXEL_ALREADY_TYPEDEFED
3543 #include "X11/xpm.h"
3544 #endif /* HAVE_NTGUI */
3545 #endif /* HAVE_XPM */
3547 #if defined (HAVE_XPM) || defined (MAC_OS)
3548 /* The symbol `xpm' identifying XPM-format images. */
3552 /* Indices of image specification fields in xpm_format, below. */
3554 enum xpm_keyword_index
3570 /* Vector of image_keyword structures describing the format
3571 of valid XPM image specifications. */
3573 static struct image_keyword xpm_format
[XPM_LAST
] =
3575 {":type", IMAGE_SYMBOL_VALUE
, 1},
3576 {":file", IMAGE_STRING_VALUE
, 0},
3577 {":data", IMAGE_STRING_VALUE
, 0},
3578 {":ascent", IMAGE_ASCENT_VALUE
, 0},
3579 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
3580 {":relief", IMAGE_INTEGER_VALUE
, 0},
3581 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3582 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3583 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3584 {":color-symbols", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3585 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
3588 /* Structure describing the image type XPM. */
3590 static struct image_type xpm_type
=
3599 #ifdef HAVE_X_WINDOWS
3601 /* Define ALLOC_XPM_COLORS if we can use Emacs' own color allocation
3602 functions for allocating image colors. Our own functions handle
3603 color allocation failures more gracefully than the ones on the XPM
3606 #if defined XpmAllocColor && defined XpmFreeColors && defined XpmColorClosure
3607 #define ALLOC_XPM_COLORS
3609 #endif /* HAVE_X_WINDOWS */
3611 #ifdef ALLOC_XPM_COLORS
3613 static void xpm_init_color_cache
P_ ((struct frame
*, XpmAttributes
*));
3614 static void xpm_free_color_cache
P_ ((void));
3615 static int xpm_lookup_color
P_ ((struct frame
*, char *, XColor
*));
3616 static int xpm_color_bucket
P_ ((char *));
3617 static struct xpm_cached_color
*xpm_cache_color
P_ ((struct frame
*, char *,
3620 /* An entry in a hash table used to cache color definitions of named
3621 colors. This cache is necessary to speed up XPM image loading in
3622 case we do color allocations ourselves. Without it, we would need
3623 a call to XParseColor per pixel in the image. */
3625 struct xpm_cached_color
3627 /* Next in collision chain. */
3628 struct xpm_cached_color
*next
;
3630 /* Color definition (RGB and pixel color). */
3637 /* The hash table used for the color cache, and its bucket vector
3640 #define XPM_COLOR_CACHE_BUCKETS 1001
3641 struct xpm_cached_color
**xpm_color_cache
;
3643 /* Initialize the color cache. */
3646 xpm_init_color_cache (f
, attrs
)
3648 XpmAttributes
*attrs
;
3650 size_t nbytes
= XPM_COLOR_CACHE_BUCKETS
* sizeof *xpm_color_cache
;
3651 xpm_color_cache
= (struct xpm_cached_color
**) xmalloc (nbytes
);
3652 memset (xpm_color_cache
, 0, nbytes
);
3653 init_color_table ();
3655 if (attrs
->valuemask
& XpmColorSymbols
)
3660 for (i
= 0; i
< attrs
->numsymbols
; ++i
)
3661 if (XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
3662 attrs
->colorsymbols
[i
].value
, &color
))
3664 color
.pixel
= lookup_rgb_color (f
, color
.red
, color
.green
,
3666 xpm_cache_color (f
, attrs
->colorsymbols
[i
].name
, &color
, -1);
3671 /* Free the color cache. */
3674 xpm_free_color_cache ()
3676 struct xpm_cached_color
*p
, *next
;
3679 for (i
= 0; i
< XPM_COLOR_CACHE_BUCKETS
; ++i
)
3680 for (p
= xpm_color_cache
[i
]; p
; p
= next
)
3686 xfree (xpm_color_cache
);
3687 xpm_color_cache
= NULL
;
3688 free_color_table ();
3691 /* Return the bucket index for color named COLOR_NAME in the color
3695 xpm_color_bucket (color_name
)
3701 for (s
= color_name
; *s
; ++s
)
3703 return h
%= XPM_COLOR_CACHE_BUCKETS
;
3707 /* On frame F, cache values COLOR for color with name COLOR_NAME.
3708 BUCKET, if >= 0, is a precomputed bucket index. Value is the cache
3711 static struct xpm_cached_color
*
3712 xpm_cache_color (f
, color_name
, color
, bucket
)
3719 struct xpm_cached_color
*p
;
3722 bucket
= xpm_color_bucket (color_name
);
3724 nbytes
= sizeof *p
+ strlen (color_name
);
3725 p
= (struct xpm_cached_color
*) xmalloc (nbytes
);
3726 strcpy (p
->name
, color_name
);
3728 p
->next
= xpm_color_cache
[bucket
];
3729 xpm_color_cache
[bucket
] = p
;
3733 /* Look up color COLOR_NAME for frame F in the color cache. If found,
3734 return the cached definition in *COLOR. Otherwise, make a new
3735 entry in the cache and allocate the color. Value is zero if color
3736 allocation failed. */
3739 xpm_lookup_color (f
, color_name
, color
)
3744 struct xpm_cached_color
*p
;
3745 int h
= xpm_color_bucket (color_name
);
3747 for (p
= xpm_color_cache
[h
]; p
; p
= p
->next
)
3748 if (strcmp (p
->name
, color_name
) == 0)
3753 else if (XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
3756 color
->pixel
= lookup_rgb_color (f
, color
->red
, color
->green
,
3758 p
= xpm_cache_color (f
, color_name
, color
, h
);
3760 /* You get `opaque' at least from ImageMagick converting pbm to xpm
3761 with transparency, and it's useful. */
3762 else if (strcmp ("opaque", color_name
) == 0)
3764 bzero (color
, sizeof (XColor
)); /* Is this necessary/correct? */
3765 color
->pixel
= FRAME_FOREGROUND_PIXEL (f
);
3766 p
= xpm_cache_color (f
, color_name
, color
, h
);
3773 /* Callback for allocating color COLOR_NAME. Called from the XPM lib.
3774 CLOSURE is a pointer to the frame on which we allocate the
3775 color. Return in *COLOR the allocated color. Value is non-zero
3779 xpm_alloc_color (dpy
, cmap
, color_name
, color
, closure
)
3786 return xpm_lookup_color ((struct frame
*) closure
, color_name
, color
);
3790 /* Callback for freeing NPIXELS colors contained in PIXELS. CLOSURE
3791 is a pointer to the frame on which we allocate the color. Value is
3792 non-zero if successful. */
3795 xpm_free_colors (dpy
, cmap
, pixels
, npixels
, closure
)
3805 #endif /* ALLOC_XPM_COLORS */
3810 /* XPM library details. */
3812 DEF_IMGLIB_FN (XpmFreeAttributes
);
3813 DEF_IMGLIB_FN (XpmCreateImageFromBuffer
);
3814 DEF_IMGLIB_FN (XpmReadFileToImage
);
3815 DEF_IMGLIB_FN (XImageFree
);
3818 init_xpm_functions (Lisp_Object libraries
)
3822 if (!(library
= w32_delayed_load (libraries
, Qxpm
)))
3825 LOAD_IMGLIB_FN (library
, XpmFreeAttributes
);
3826 LOAD_IMGLIB_FN (library
, XpmCreateImageFromBuffer
);
3827 LOAD_IMGLIB_FN (library
, XpmReadFileToImage
);
3828 LOAD_IMGLIB_FN (library
, XImageFree
);
3832 #endif /* HAVE_NTGUI */
3835 /* Value is non-zero if COLOR_SYMBOLS is a valid color symbols list
3836 for XPM images. Such a list must consist of conses whose car and
3840 xpm_valid_color_symbols_p (color_symbols
)
3841 Lisp_Object color_symbols
;
3843 while (CONSP (color_symbols
))
3845 Lisp_Object sym
= XCAR (color_symbols
);
3847 || !STRINGP (XCAR (sym
))
3848 || !STRINGP (XCDR (sym
)))
3850 color_symbols
= XCDR (color_symbols
);
3853 return NILP (color_symbols
);
3857 /* Value is non-zero if OBJECT is a valid XPM image specification. */
3860 xpm_image_p (object
)
3863 struct image_keyword fmt
[XPM_LAST
];
3864 bcopy (xpm_format
, fmt
, sizeof fmt
);
3865 return (parse_image_spec (object
, fmt
, XPM_LAST
, Qxpm
)
3866 /* Either `:file' or `:data' must be present. */
3867 && fmt
[XPM_FILE
].count
+ fmt
[XPM_DATA
].count
== 1
3868 /* Either no `:color-symbols' or it's a list of conses
3869 whose car and cdr are strings. */
3870 && (fmt
[XPM_COLOR_SYMBOLS
].count
== 0
3871 || xpm_valid_color_symbols_p (fmt
[XPM_COLOR_SYMBOLS
].value
)));
3874 #endif /* HAVE_XPM || MAC_OS */
3876 #if defined (HAVE_XPM) && defined (HAVE_X_WINDOWS)
3878 x_create_bitmap_from_xpm_data (f
, bits
)
3882 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
3884 XpmAttributes attrs
;
3885 Pixmap bitmap
, mask
;
3887 bzero (&attrs
, sizeof attrs
);
3889 attrs
.visual
= FRAME_X_VISUAL (f
);
3890 attrs
.colormap
= FRAME_X_COLORMAP (f
);
3891 attrs
.valuemask
|= XpmVisual
;
3892 attrs
.valuemask
|= XpmColormap
;
3894 rc
= XpmCreatePixmapFromData (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3895 bits
, &bitmap
, &mask
, &attrs
);
3896 if (rc
!= XpmSuccess
)
3898 XpmFreeAttributes (&attrs
);
3902 id
= x_allocate_bitmap_record (f
);
3903 dpyinfo
->bitmaps
[id
- 1].pixmap
= bitmap
;
3904 dpyinfo
->bitmaps
[id
- 1].have_mask
= 1;
3905 dpyinfo
->bitmaps
[id
- 1].mask
= mask
;
3906 dpyinfo
->bitmaps
[id
- 1].file
= NULL
;
3907 dpyinfo
->bitmaps
[id
- 1].height
= attrs
.height
;
3908 dpyinfo
->bitmaps
[id
- 1].width
= attrs
.width
;
3909 dpyinfo
->bitmaps
[id
- 1].depth
= attrs
.depth
;
3910 dpyinfo
->bitmaps
[id
- 1].refcount
= 1;
3912 XpmFreeAttributes (&attrs
);
3915 #endif /* defined (HAVE_XPM) && defined (HAVE_X_WINDOWS) */
3917 /* Load image IMG which will be displayed on frame F. Value is
3918 non-zero if successful. */
3928 XpmAttributes attrs
;
3929 Lisp_Object specified_file
, color_symbols
;
3932 xpm_XImage
* xpm_image
= NULL
, * xpm_mask
= NULL
;
3933 #endif /* HAVE_NTGUI */
3935 /* Configure the XPM lib. Use the visual of frame F. Allocate
3936 close colors. Return colors allocated. */
3937 bzero (&attrs
, sizeof attrs
);
3940 attrs
.visual
= FRAME_X_VISUAL (f
);
3941 attrs
.colormap
= FRAME_X_COLORMAP (f
);
3942 attrs
.valuemask
|= XpmVisual
;
3943 attrs
.valuemask
|= XpmColormap
;
3944 #endif /* HAVE_NTGUI */
3946 #ifdef ALLOC_XPM_COLORS
3947 /* Allocate colors with our own functions which handle
3948 failing color allocation more gracefully. */
3949 attrs
.color_closure
= f
;
3950 attrs
.alloc_color
= xpm_alloc_color
;
3951 attrs
.free_colors
= xpm_free_colors
;
3952 attrs
.valuemask
|= XpmAllocColor
| XpmFreeColors
| XpmColorClosure
;
3953 #else /* not ALLOC_XPM_COLORS */
3954 /* Let the XPM lib allocate colors. */
3955 attrs
.valuemask
|= XpmReturnAllocPixels
;
3956 #ifdef XpmAllocCloseColors
3957 attrs
.alloc_close_colors
= 1;
3958 attrs
.valuemask
|= XpmAllocCloseColors
;
3959 #else /* not XpmAllocCloseColors */
3960 attrs
.closeness
= 600;
3961 attrs
.valuemask
|= XpmCloseness
;
3962 #endif /* not XpmAllocCloseColors */
3963 #endif /* ALLOC_XPM_COLORS */
3964 #ifdef ALLOC_XPM_COLORS
3965 xpm_init_color_cache (f
, &attrs
);
3968 /* If image specification contains symbolic color definitions, add
3969 these to `attrs'. */
3970 color_symbols
= image_spec_value (img
->spec
, QCcolor_symbols
, NULL
);
3971 if (CONSP (color_symbols
))
3974 XpmColorSymbol
*xpm_syms
;
3977 attrs
.valuemask
|= XpmColorSymbols
;
3979 /* Count number of symbols. */
3980 attrs
.numsymbols
= 0;
3981 for (tail
= color_symbols
; CONSP (tail
); tail
= XCDR (tail
))
3984 /* Allocate an XpmColorSymbol array. */
3985 size
= attrs
.numsymbols
* sizeof *xpm_syms
;
3986 xpm_syms
= (XpmColorSymbol
*) alloca (size
);
3987 bzero (xpm_syms
, size
);
3988 attrs
.colorsymbols
= xpm_syms
;
3990 /* Fill the color symbol array. */
3991 for (tail
= color_symbols
, i
= 0;
3993 ++i
, tail
= XCDR (tail
))
3995 Lisp_Object name
= XCAR (XCAR (tail
));
3996 Lisp_Object color
= XCDR (XCAR (tail
));
3997 xpm_syms
[i
].name
= (char *) alloca (SCHARS (name
) + 1);
3998 strcpy (xpm_syms
[i
].name
, SDATA (name
));
3999 xpm_syms
[i
].value
= (char *) alloca (SCHARS (color
) + 1);
4000 strcpy (xpm_syms
[i
].value
, SDATA (color
));
4004 /* Create a pixmap for the image, either from a file, or from a
4005 string buffer containing data in the same format as an XPM file. */
4006 #ifdef ALLOC_XPM_COLORS
4007 xpm_init_color_cache (f
, &attrs
);
4010 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
4014 HDC frame_dc
= get_frame_dc (f
);
4015 hdc
= CreateCompatibleDC (frame_dc
);
4016 release_frame_dc (f
, frame_dc
);
4018 #endif /* HAVE_NTGUI */
4020 if (STRINGP (specified_file
))
4022 Lisp_Object file
= x_find_image_file (specified_file
);
4023 if (!STRINGP (file
))
4025 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
4030 /* XpmReadFileToPixmap is not available in the Windows port of
4031 libxpm. But XpmReadFileToImage almost does what we want. */
4032 rc
= fn_XpmReadFileToImage (&hdc
, SDATA (file
),
4033 &xpm_image
, &xpm_mask
,
4036 rc
= XpmReadFileToPixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
4037 SDATA (file
), &img
->pixmap
, &img
->mask
,
4039 #endif /* HAVE_NTGUI */
4043 Lisp_Object buffer
= image_spec_value (img
->spec
, QCdata
, NULL
);
4045 /* XpmCreatePixmapFromBuffer is not available in the Windows port
4046 of libxpm. But XpmCreateImageFromBuffer almost does what we want. */
4047 rc
= fn_XpmCreateImageFromBuffer (&hdc
, SDATA (buffer
),
4048 &xpm_image
, &xpm_mask
,
4051 rc
= XpmCreatePixmapFromBuffer (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
4053 &img
->pixmap
, &img
->mask
,
4055 #endif /* HAVE_NTGUI */
4058 if (rc
== XpmSuccess
)
4060 #if defined (COLOR_TABLE_SUPPORT) && defined (ALLOC_XPM_COLORS)
4061 img
->colors
= colors_in_color_table (&img
->ncolors
);
4062 #else /* not ALLOC_XPM_COLORS */
4066 /* W32 XPM uses XImage to wrap what W32 Emacs calls a Pixmap,
4067 plus some duplicate attributes. */
4068 if (xpm_image
&& xpm_image
->bitmap
)
4070 img
->pixmap
= xpm_image
->bitmap
;
4071 /* XImageFree in libXpm frees XImage struct without destroying
4072 the bitmap, which is what we want. */
4073 fn_XImageFree (xpm_image
);
4075 if (xpm_mask
&& xpm_mask
->bitmap
)
4077 /* The mask appears to be inverted compared with what we expect.
4078 TODO: invert our expectations. See other places where we
4079 have to invert bits because our idea of masks is backwards. */
4081 old_obj
= SelectObject (hdc
, xpm_mask
->bitmap
);
4083 PatBlt (hdc
, 0, 0, xpm_mask
->width
, xpm_mask
->height
, DSTINVERT
);
4084 SelectObject (hdc
, old_obj
);
4086 img
->mask
= xpm_mask
->bitmap
;
4087 fn_XImageFree (xpm_mask
);
4092 #endif /* HAVE_NTGUI */
4094 /* Remember allocated colors. */
4095 img
->ncolors
= attrs
.nalloc_pixels
;
4096 img
->colors
= (unsigned long *) xmalloc (img
->ncolors
4097 * sizeof *img
->colors
);
4098 for (i
= 0; i
< attrs
.nalloc_pixels
; ++i
)
4100 img
->colors
[i
] = attrs
.alloc_pixels
[i
];
4101 #ifdef DEBUG_X_COLORS
4102 register_color (img
->colors
[i
]);
4105 #endif /* not ALLOC_XPM_COLORS */
4107 img
->width
= attrs
.width
;
4108 img
->height
= attrs
.height
;
4109 xassert (img
->width
> 0 && img
->height
> 0);
4111 /* The call to XpmFreeAttributes below frees attrs.alloc_pixels. */
4113 fn_XpmFreeAttributes (&attrs
);
4115 XpmFreeAttributes (&attrs
);
4116 #endif /* HAVE_NTGUI */
4122 #endif /* HAVE_NTGUI */
4127 image_error ("Error opening XPM file (%s)", img
->spec
, Qnil
);
4130 case XpmFileInvalid
:
4131 image_error ("Invalid XPM file (%s)", img
->spec
, Qnil
);
4135 image_error ("Out of memory (%s)", img
->spec
, Qnil
);
4138 case XpmColorFailed
:
4139 image_error ("Color allocation error (%s)", img
->spec
, Qnil
);
4143 image_error ("Unknown error (%s)", img
->spec
, Qnil
);
4148 #ifdef ALLOC_XPM_COLORS
4149 xpm_free_color_cache ();
4151 return rc
== XpmSuccess
;
4154 #endif /* HAVE_XPM */
4158 /* XPM support functions for Mac OS where libxpm is not available.
4159 Only XPM version 3 (without any extensions) is supported. */
4161 static int xpm_scan
P_ ((const unsigned char **, const unsigned char *,
4162 const unsigned char **, int *));
4163 static Lisp_Object xpm_make_color_table_v
4164 P_ ((void (**) (Lisp_Object
, const unsigned char *, int, Lisp_Object
),
4165 Lisp_Object (**) (Lisp_Object
, const unsigned char *, int)));
4166 static void xpm_put_color_table_v
P_ ((Lisp_Object
, const unsigned char *,
4168 static Lisp_Object xpm_get_color_table_v
P_ ((Lisp_Object
,
4169 const unsigned char *, int));
4170 static Lisp_Object xpm_make_color_table_h
4171 P_ ((void (**) (Lisp_Object
, const unsigned char *, int, Lisp_Object
),
4172 Lisp_Object (**) (Lisp_Object
, const unsigned char *, int)));
4173 static void xpm_put_color_table_h
P_ ((Lisp_Object
, const unsigned char *,
4175 static Lisp_Object xpm_get_color_table_h
P_ ((Lisp_Object
,
4176 const unsigned char *, int));
4177 static int xpm_str_to_color_key
P_ ((const char *));
4178 static int xpm_load_image
P_ ((struct frame
*, struct image
*,
4179 const unsigned char *, const unsigned char *));
4181 /* Tokens returned from xpm_scan. */
4190 /* Scan an XPM data and return a character (< 256) or a token defined
4191 by enum xpm_token above. *S and END are the start (inclusive) and
4192 the end (exclusive) addresses of the data, respectively. Advance
4193 *S while scanning. If token is either XPM_TK_IDENT or
4194 XPM_TK_STRING, *BEG and *LEN are set to the start address and the
4195 length of the corresponding token, respectively. */
4198 xpm_scan (s
, end
, beg
, len
)
4199 const unsigned char **s
, *end
, **beg
;
4206 /* Skip white-space. */
4207 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
4210 /* gnus-pointer.xpm uses '-' in its identifier.
4211 sb-dir-plus.xpm uses '+' in its identifier. */
4212 if (isalpha (c
) || c
== '_' || c
== '-' || c
== '+')
4216 (c
= **s
, isalnum (c
) || c
== '_' || c
== '-' || c
== '+'))
4219 return XPM_TK_IDENT
;
4224 while (*s
< end
&& **s
!= '"')
4229 return XPM_TK_STRING
;
4233 if (*s
< end
&& **s
== '*')
4235 /* C-style comment. */
4239 while (*s
< end
&& *(*s
)++ != '*')
4242 while (*s
< end
&& **s
!= '/');
4256 /* Functions for color table lookup in XPM data. A Key is a string
4257 specifying the color of each pixel in XPM data. A value is either
4258 an integer that specifies a pixel color, Qt that specifies
4259 transparency, or Qnil for the unspecified color. If the length of
4260 the key string is one, a vector is used as a table. Otherwise, a
4261 hash table is used. */
4264 xpm_make_color_table_v (put_func
, get_func
)
4265 void (**put_func
) (Lisp_Object
, const unsigned char *, int, Lisp_Object
);
4266 Lisp_Object (**get_func
) (Lisp_Object
, const unsigned char *, int);
4268 *put_func
= xpm_put_color_table_v
;
4269 *get_func
= xpm_get_color_table_v
;
4270 return Fmake_vector (make_number (256), Qnil
);
4274 xpm_put_color_table_v (color_table
, chars_start
, chars_len
, color
)
4275 Lisp_Object color_table
;
4276 const unsigned char *chars_start
;
4280 XVECTOR (color_table
)->contents
[*chars_start
] = color
;
4284 xpm_get_color_table_v (color_table
, chars_start
, chars_len
)
4285 Lisp_Object color_table
;
4286 const unsigned char *chars_start
;
4289 return XVECTOR (color_table
)->contents
[*chars_start
];
4293 xpm_make_color_table_h (put_func
, get_func
)
4294 void (**put_func
) (Lisp_Object
, const unsigned char *, int, Lisp_Object
);
4295 Lisp_Object (**get_func
) (Lisp_Object
, const unsigned char *, int);
4297 *put_func
= xpm_put_color_table_h
;
4298 *get_func
= xpm_get_color_table_h
;
4299 return make_hash_table (Qequal
, make_number (DEFAULT_HASH_SIZE
),
4300 make_float (DEFAULT_REHASH_SIZE
),
4301 make_float (DEFAULT_REHASH_THRESHOLD
),
4306 xpm_put_color_table_h (color_table
, chars_start
, chars_len
, color
)
4307 Lisp_Object color_table
;
4308 const unsigned char *chars_start
;
4312 struct Lisp_Hash_Table
*table
= XHASH_TABLE (color_table
);
4314 Lisp_Object chars
= make_unibyte_string (chars_start
, chars_len
);
4316 hash_lookup (table
, chars
, &hash_code
);
4317 hash_put (table
, chars
, color
, hash_code
);
4321 xpm_get_color_table_h (color_table
, chars_start
, chars_len
)
4322 Lisp_Object color_table
;
4323 const unsigned char *chars_start
;
4326 struct Lisp_Hash_Table
*table
= XHASH_TABLE (color_table
);
4327 int i
= hash_lookup (table
, make_unibyte_string (chars_start
, chars_len
),
4330 return i
>= 0 ? HASH_VALUE (table
, i
) : Qnil
;
4333 enum xpm_color_key
{
4341 static const char xpm_color_key_strings
[][4] = {"s", "m", "g4", "g", "c"};
4344 xpm_str_to_color_key (s
)
4350 i
< sizeof xpm_color_key_strings
/ sizeof xpm_color_key_strings
[0];
4352 if (strcmp (xpm_color_key_strings
[i
], s
) == 0)
4358 xpm_load_image (f
, img
, contents
, end
)
4361 const unsigned char *contents
, *end
;
4363 const unsigned char *s
= contents
, *beg
, *str
;
4364 unsigned char buffer
[BUFSIZ
];
4365 int width
, height
, x
, y
;
4366 int num_colors
, chars_per_pixel
;
4368 void (*put_color_table
) (Lisp_Object
, const unsigned char *, int, Lisp_Object
);
4369 Lisp_Object (*get_color_table
) (Lisp_Object
, const unsigned char *, int);
4370 Lisp_Object frame
, color_symbols
, color_table
;
4371 int best_key
, have_mask
= 0;
4372 XImagePtr ximg
= NULL
, mask_img
= NULL
;
4375 LA1 = xpm_scan (&s, end, &beg, &len)
4377 #define expect(TOKEN) \
4378 if (LA1 != (TOKEN)) \
4383 #define expect_ident(IDENT) \
4384 if (LA1 == XPM_TK_IDENT \
4385 && strlen ((IDENT)) == len && memcmp ((IDENT), beg, len) == 0) \
4390 if (!(end
- s
>= 9 && memcmp (s
, "/* XPM */", 9) == 0))
4394 expect_ident ("static");
4395 expect_ident ("char");
4397 expect (XPM_TK_IDENT
);
4402 expect (XPM_TK_STRING
);
4405 memcpy (buffer
, beg
, len
);
4407 if (sscanf (buffer
, "%d %d %d %d", &width
, &height
,
4408 &num_colors
, &chars_per_pixel
) != 4
4409 || width
<= 0 || height
<= 0
4410 || num_colors
<= 0 || chars_per_pixel
<= 0)
4413 if (!check_image_size (f
, width
, height
))
4415 image_error ("Invalid image size", Qnil
, Qnil
);
4421 XSETFRAME (frame
, f
);
4422 if (!NILP (Fxw_display_color_p (frame
)))
4423 best_key
= XPM_COLOR_KEY_C
;
4424 else if (!NILP (Fx_display_grayscale_p (frame
)))
4425 best_key
= (XFASTINT (Fx_display_planes (frame
)) > 2
4426 ? XPM_COLOR_KEY_G
: XPM_COLOR_KEY_G4
);
4428 best_key
= XPM_COLOR_KEY_M
;
4430 color_symbols
= image_spec_value (img
->spec
, QCcolor_symbols
, NULL
);
4431 if (chars_per_pixel
== 1)
4432 color_table
= xpm_make_color_table_v (&put_color_table
,
4435 color_table
= xpm_make_color_table_h (&put_color_table
,
4438 while (num_colors
-- > 0)
4440 unsigned char *color
, *max_color
;
4441 int key
, next_key
, max_key
= 0;
4442 Lisp_Object symbol_color
= Qnil
, color_val
;
4445 expect (XPM_TK_STRING
);
4446 if (len
<= chars_per_pixel
|| len
>= BUFSIZ
+ chars_per_pixel
)
4448 memcpy (buffer
, beg
+ chars_per_pixel
, len
- chars_per_pixel
);
4449 buffer
[len
- chars_per_pixel
] = '\0';
4451 str
= strtok (buffer
, " \t");
4454 key
= xpm_str_to_color_key (str
);
4459 color
= strtok (NULL
, " \t");
4463 while ((str
= strtok (NULL
, " \t")) != NULL
)
4465 next_key
= xpm_str_to_color_key (str
);
4468 color
[strlen (color
)] = ' ';
4471 if (key
== XPM_COLOR_KEY_S
)
4473 if (NILP (symbol_color
))
4474 symbol_color
= build_string (color
);
4476 else if (max_key
< key
&& key
<= best_key
)
4486 if (!NILP (color_symbols
) && !NILP (symbol_color
))
4488 Lisp_Object specified_color
= Fassoc (symbol_color
, color_symbols
);
4490 if (CONSP (specified_color
) && STRINGP (XCDR (specified_color
)))
4492 if (xstricmp (SDATA (XCDR (specified_color
)), "None") == 0)
4494 else if (x_defined_color (f
, SDATA (XCDR (specified_color
)),
4496 color_val
= make_number (cdef
.pixel
);
4499 if (NILP (color_val
) && max_key
> 0)
4501 if (xstricmp (max_color
, "None") == 0)
4503 else if (x_defined_color (f
, max_color
, &cdef
, 0))
4504 color_val
= make_number (cdef
.pixel
);
4506 if (!NILP (color_val
))
4507 (*put_color_table
) (color_table
, beg
, chars_per_pixel
, color_val
);
4512 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0,
4513 &ximg
, &img
->pixmap
)
4514 || !x_create_x_image_and_pixmap (f
, width
, height
, 1,
4515 &mask_img
, &img
->mask
))
4517 image_error ("Out of memory (%s)", img
->spec
, Qnil
);
4521 for (y
= 0; y
< height
; y
++)
4523 expect (XPM_TK_STRING
);
4525 if (len
< width
* chars_per_pixel
)
4527 for (x
= 0; x
< width
; x
++, str
+= chars_per_pixel
)
4529 Lisp_Object color_val
=
4530 (*get_color_table
) (color_table
, str
, chars_per_pixel
);
4532 XPutPixel (ximg
, x
, y
,
4533 (INTEGERP (color_val
) ? XINT (color_val
)
4534 : FRAME_FOREGROUND_PIXEL (f
)));
4535 XPutPixel (mask_img
, x
, y
,
4536 (!EQ (color_val
, Qt
) ? PIX_MASK_DRAW
4537 : (have_mask
= 1, PIX_MASK_RETAIN
)));
4544 img
->height
= height
;
4546 /* Maybe fill in the background field while we have ximg handy. */
4547 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
4548 IMAGE_BACKGROUND (img
, f
, ximg
);
4550 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
4551 x_destroy_x_image (ximg
);
4554 /* Fill in the background_transparent field while we have the
4556 image_background_transparent (img
, f
, mask_img
);
4558 x_put_x_image (f
, mask_img
, img
->mask
, width
, height
);
4559 x_destroy_x_image (mask_img
);
4563 x_destroy_x_image (mask_img
);
4564 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
4565 img
->mask
= NO_PIXMAP
;
4571 image_error ("Invalid XPM file (%s)", img
->spec
, Qnil
);
4573 x_destroy_x_image (ximg
);
4574 x_destroy_x_image (mask_img
);
4575 x_clear_image (f
, img
);
4589 Lisp_Object file_name
;
4591 /* If IMG->spec specifies a file name, create a non-file spec from it. */
4592 file_name
= image_spec_value (img
->spec
, QCfile
, NULL
);
4593 if (STRINGP (file_name
))
4596 unsigned char *contents
;
4598 struct gcpro gcpro1
;
4600 file
= x_find_image_file (file_name
);
4602 if (!STRINGP (file
))
4604 image_error ("Cannot find image file `%s'", file_name
, Qnil
);
4609 contents
= slurp_file (SDATA (file
), &size
);
4610 if (contents
== NULL
)
4612 image_error ("Error loading XPM image `%s'", img
->spec
, Qnil
);
4617 success_p
= xpm_load_image (f
, img
, contents
, contents
+ size
);
4625 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
4626 success_p
= xpm_load_image (f
, img
, SDATA (data
),
4627 SDATA (data
) + SBYTES (data
));
4637 /***********************************************************************
4639 ***********************************************************************/
4641 #ifdef COLOR_TABLE_SUPPORT
4643 /* An entry in the color table mapping an RGB color to a pixel color. */
4648 unsigned long pixel
;
4650 /* Next in color table collision list. */
4651 struct ct_color
*next
;
4654 /* The bucket vector size to use. Must be prime. */
4658 /* Value is a hash of the RGB color given by R, G, and B. */
4660 #define CT_HASH_RGB(R, G, B) (((R) << 16) ^ ((G) << 8) ^ (B))
4662 /* The color hash table. */
4664 struct ct_color
**ct_table
;
4666 /* Number of entries in the color table. */
4668 int ct_colors_allocated
;
4670 /* Initialize the color table. */
4675 int size
= CT_SIZE
* sizeof (*ct_table
);
4676 ct_table
= (struct ct_color
**) xmalloc (size
);
4677 bzero (ct_table
, size
);
4678 ct_colors_allocated
= 0;
4682 /* Free memory associated with the color table. */
4688 struct ct_color
*p
, *next
;
4690 for (i
= 0; i
< CT_SIZE
; ++i
)
4691 for (p
= ct_table
[i
]; p
; p
= next
)
4702 /* Value is a pixel color for RGB color R, G, B on frame F. If an
4703 entry for that color already is in the color table, return the
4704 pixel color of that entry. Otherwise, allocate a new color for R,
4705 G, B, and make an entry in the color table. */
4707 static unsigned long
4708 lookup_rgb_color (f
, r
, g
, b
)
4712 unsigned hash
= CT_HASH_RGB (r
, g
, b
);
4713 int i
= hash
% CT_SIZE
;
4715 Display_Info
*dpyinfo
;
4717 /* Handle TrueColor visuals specially, which improves performance by
4718 two orders of magnitude. Freeing colors on TrueColor visuals is
4719 a nop, and pixel colors specify RGB values directly. See also
4720 the Xlib spec, chapter 3.1. */
4721 dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
4722 if (dpyinfo
->red_bits
> 0)
4724 unsigned long pr
, pg
, pb
;
4726 /* Apply gamma-correction like normal color allocation does. */
4730 color
.red
= r
, color
.green
= g
, color
.blue
= b
;
4731 gamma_correct (f
, &color
);
4732 r
= color
.red
, g
= color
.green
, b
= color
.blue
;
4735 /* Scale down RGB values to the visual's bits per RGB, and shift
4736 them to the right position in the pixel color. Note that the
4737 original RGB values are 16-bit values, as usual in X. */
4738 pr
= (r
>> (16 - dpyinfo
->red_bits
)) << dpyinfo
->red_offset
;
4739 pg
= (g
>> (16 - dpyinfo
->green_bits
)) << dpyinfo
->green_offset
;
4740 pb
= (b
>> (16 - dpyinfo
->blue_bits
)) << dpyinfo
->blue_offset
;
4742 /* Assemble the pixel color. */
4743 return pr
| pg
| pb
;
4746 for (p
= ct_table
[i
]; p
; p
= p
->next
)
4747 if (p
->r
== r
&& p
->g
== g
&& p
->b
== b
)
4753 #ifdef HAVE_X_WINDOWS
4762 cmap
= FRAME_X_COLORMAP (f
);
4763 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
4766 ++ct_colors_allocated
;
4767 p
= (struct ct_color
*) xmalloc (sizeof *p
);
4771 p
->pixel
= color
.pixel
;
4772 p
->next
= ct_table
[i
];
4776 return FRAME_FOREGROUND_PIXEL (f
);
4781 color
= PALETTERGB (r
, g
, b
);
4783 color
= RGB_TO_ULONG (r
, g
, b
);
4784 #endif /* HAVE_NTGUI */
4785 ++ct_colors_allocated
;
4786 p
= (struct ct_color
*) xmalloc (sizeof *p
);
4791 p
->next
= ct_table
[i
];
4793 #endif /* HAVE_X_WINDOWS */
4801 /* Look up pixel color PIXEL which is used on frame F in the color
4802 table. If not already present, allocate it. Value is PIXEL. */
4804 static unsigned long
4805 lookup_pixel_color (f
, pixel
)
4807 unsigned long pixel
;
4809 int i
= pixel
% CT_SIZE
;
4812 for (p
= ct_table
[i
]; p
; p
= p
->next
)
4813 if (p
->pixel
== pixel
)
4822 #ifdef HAVE_X_WINDOWS
4823 cmap
= FRAME_X_COLORMAP (f
);
4824 color
.pixel
= pixel
;
4825 x_query_color (f
, &color
);
4826 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
4829 cmap
= DefaultColormapOfScreen (FRAME_X_SCREEN (f
));
4830 color
.pixel
= pixel
;
4831 XQueryColor (NULL
, cmap
, &color
);
4832 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
4834 #endif /* HAVE_X_WINDOWS */
4838 ++ct_colors_allocated
;
4840 p
= (struct ct_color
*) xmalloc (sizeof *p
);
4845 p
->next
= ct_table
[i
];
4849 return FRAME_FOREGROUND_PIXEL (f
);
4855 /* Value is a vector of all pixel colors contained in the color table,
4856 allocated via xmalloc. Set *N to the number of colors. */
4858 static unsigned long *
4859 colors_in_color_table (n
)
4864 unsigned long *colors
;
4866 if (ct_colors_allocated
== 0)
4873 colors
= (unsigned long *) xmalloc (ct_colors_allocated
4875 *n
= ct_colors_allocated
;
4877 for (i
= j
= 0; i
< CT_SIZE
; ++i
)
4878 for (p
= ct_table
[i
]; p
; p
= p
->next
)
4879 colors
[j
++] = p
->pixel
;
4885 #else /* COLOR_TABLE_SUPPORT */
4887 static unsigned long
4888 lookup_rgb_color (f
, r
, g
, b
)
4892 unsigned long pixel
;
4895 pixel
= RGB_TO_ULONG (r
>> 8, g
>> 8, b
>> 8);
4896 gamma_correct (f
, &pixel
);
4900 pixel
= PALETTERGB (r
>> 8, g
>> 8, b
>> 8);
4901 #endif /* HAVE_NTGUI */
4910 #endif /* COLOR_TABLE_SUPPORT */
4913 /***********************************************************************
4915 ***********************************************************************/
4917 static XColor
*x_to_xcolors
P_ ((struct frame
*, struct image
*, int));
4918 static void x_from_xcolors
P_ ((struct frame
*, struct image
*, XColor
*));
4919 static void x_detect_edges
P_ ((struct frame
*, struct image
*, int[9], int));
4922 static void XPutPixel (XImagePtr
, int, int, COLORREF
);
4923 #endif /* HAVE_NTGUI */
4925 /* Non-zero means draw a cross on images having `:conversion
4928 int cross_disabled_images
;
4930 /* Edge detection matrices for different edge-detection
4933 static int emboss_matrix
[9] = {
4935 2, -1, 0, /* y - 1 */
4937 0, 1, -2 /* y + 1 */
4940 static int laplace_matrix
[9] = {
4942 1, 0, 0, /* y - 1 */
4944 0, 0, -1 /* y + 1 */
4947 /* Value is the intensity of the color whose red/green/blue values
4950 #define COLOR_INTENSITY(R, G, B) ((2 * (R) + 3 * (G) + (B)) / 6)
4953 /* On frame F, return an array of XColor structures describing image
4954 IMG->pixmap. Each XColor structure has its pixel color set. RGB_P
4955 non-zero means also fill the red/green/blue members of the XColor
4956 structures. Value is a pointer to the array of XColors structures,
4957 allocated with xmalloc; it must be freed by the caller. */
4960 x_to_xcolors (f
, img
, rgb_p
)
4967 XImagePtr_or_DC ximg
;
4971 #endif /* HAVE_NTGUI */
4973 colors
= (XColor
*) xmalloc (img
->width
* img
->height
* sizeof *colors
);
4976 /* Get the X image IMG->pixmap. */
4977 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
4978 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
4980 /* Load the image into a memory device context. */
4981 hdc
= get_frame_dc (f
);
4982 ximg
= CreateCompatibleDC (hdc
);
4983 release_frame_dc (f
, hdc
);
4984 prev
= SelectObject (ximg
, img
->pixmap
);
4985 #endif /* HAVE_NTGUI */
4987 /* Fill the `pixel' members of the XColor array. I wished there
4988 were an easy and portable way to circumvent XGetPixel. */
4990 for (y
= 0; y
< img
->height
; ++y
)
4994 #ifdef HAVE_X_WINDOWS
4995 for (x
= 0; x
< img
->width
; ++x
, ++p
)
4996 p
->pixel
= XGetPixel (ximg
, x
, y
);
4998 x_query_colors (f
, row
, img
->width
);
5002 for (x
= 0; x
< img
->width
; ++x
, ++p
)
5004 /* W32_TODO: palette support needed here? */
5005 p
->pixel
= GET_PIXEL (ximg
, x
, y
);
5009 p
->red
= RED16_FROM_ULONG (p
->pixel
);
5010 p
->green
= GREEN16_FROM_ULONG (p
->pixel
);
5011 p
->blue
= BLUE16_FROM_ULONG (p
->pixel
);
5014 p
->red
= 256 * GetRValue (p
->pixel
);
5015 p
->green
= 256 * GetGValue (p
->pixel
);
5016 p
->blue
= 256 * GetBValue (p
->pixel
);
5017 #endif /* HAVE_NTGUI */
5020 #endif /* HAVE_X_WINDOWS */
5023 Destroy_Image (ximg
, prev
);
5030 /* Put a pixel of COLOR at position X, Y in XIMG. XIMG must have been
5031 created with CreateDIBSection, with the pointer to the bit values
5032 stored in ximg->data. */
5034 static void XPutPixel (ximg
, x
, y
, color
)
5039 int width
= ximg
->info
.bmiHeader
.biWidth
;
5040 int height
= ximg
->info
.bmiHeader
.biHeight
;
5041 unsigned char * pixel
;
5043 /* True color images. */
5044 if (ximg
->info
.bmiHeader
.biBitCount
== 24)
5046 int rowbytes
= width
* 3;
5047 /* Ensure scanlines are aligned on 4 byte boundaries. */
5049 rowbytes
+= 4 - (rowbytes
% 4);
5051 pixel
= ximg
->data
+ y
* rowbytes
+ x
* 3;
5052 /* Windows bitmaps are in BGR order. */
5053 *pixel
= GetBValue (color
);
5054 *(pixel
+ 1) = GetGValue (color
);
5055 *(pixel
+ 2) = GetRValue (color
);
5057 /* Monochrome images. */
5058 else if (ximg
->info
.bmiHeader
.biBitCount
== 1)
5060 int rowbytes
= width
/ 8;
5061 /* Ensure scanlines are aligned on 4 byte boundaries. */
5063 rowbytes
+= 4 - (rowbytes
% 4);
5064 pixel
= ximg
->data
+ y
* rowbytes
+ x
/ 8;
5065 /* Filter out palette info. */
5066 if (color
& 0x00ffffff)
5067 *pixel
= *pixel
| (1 << x
% 8);
5069 *pixel
= *pixel
& ~(1 << x
% 8);
5072 image_error ("XPutPixel: palette image not supported", Qnil
, Qnil
);
5075 #endif /* HAVE_NTGUI */
5077 /* Create IMG->pixmap from an array COLORS of XColor structures, whose
5078 RGB members are set. F is the frame on which this all happens.
5079 COLORS will be freed; an existing IMG->pixmap will be freed, too. */
5082 x_from_xcolors (f
, img
, colors
)
5092 init_color_table ();
5094 x_create_x_image_and_pixmap (f
, img
->width
, img
->height
, 0,
5097 for (y
= 0; y
< img
->height
; ++y
)
5098 for (x
= 0; x
< img
->width
; ++x
, ++p
)
5100 unsigned long pixel
;
5101 pixel
= lookup_rgb_color (f
, p
->red
, p
->green
, p
->blue
);
5102 XPutPixel (oimg
, x
, y
, pixel
);
5106 x_clear_image_1 (f
, img
, 1, 0, 1);
5108 x_put_x_image (f
, oimg
, pixmap
, img
->width
, img
->height
);
5109 x_destroy_x_image (oimg
);
5110 img
->pixmap
= pixmap
;
5111 #ifdef COLOR_TABLE_SUPPORT
5112 img
->colors
= colors_in_color_table (&img
->ncolors
);
5113 free_color_table ();
5114 #endif /* COLOR_TABLE_SUPPORT */
5118 /* On frame F, perform edge-detection on image IMG.
5120 MATRIX is a nine-element array specifying the transformation
5121 matrix. See emboss_matrix for an example.
5123 COLOR_ADJUST is a color adjustment added to each pixel of the
5127 x_detect_edges (f
, img
, matrix
, color_adjust
)
5130 int matrix
[9], color_adjust
;
5132 XColor
*colors
= x_to_xcolors (f
, img
, 1);
5136 for (i
= sum
= 0; i
< 9; ++i
)
5137 sum
+= abs (matrix
[i
]);
5139 #define COLOR(A, X, Y) ((A) + (Y) * img->width + (X))
5141 new = (XColor
*) xmalloc (img
->width
* img
->height
* sizeof *new);
5143 for (y
= 0; y
< img
->height
; ++y
)
5145 p
= COLOR (new, 0, y
);
5146 p
->red
= p
->green
= p
->blue
= 0xffff/2;
5147 p
= COLOR (new, img
->width
- 1, y
);
5148 p
->red
= p
->green
= p
->blue
= 0xffff/2;
5151 for (x
= 1; x
< img
->width
- 1; ++x
)
5153 p
= COLOR (new, x
, 0);
5154 p
->red
= p
->green
= p
->blue
= 0xffff/2;
5155 p
= COLOR (new, x
, img
->height
- 1);
5156 p
->red
= p
->green
= p
->blue
= 0xffff/2;
5159 for (y
= 1; y
< img
->height
- 1; ++y
)
5161 p
= COLOR (new, 1, y
);
5163 for (x
= 1; x
< img
->width
- 1; ++x
, ++p
)
5165 int r
, g
, b
, y1
, x1
;
5168 for (y1
= y
- 1; y1
< y
+ 2; ++y1
)
5169 for (x1
= x
- 1; x1
< x
+ 2; ++x1
, ++i
)
5172 XColor
*t
= COLOR (colors
, x1
, y1
);
5173 r
+= matrix
[i
] * t
->red
;
5174 g
+= matrix
[i
] * t
->green
;
5175 b
+= matrix
[i
] * t
->blue
;
5178 r
= (r
/ sum
+ color_adjust
) & 0xffff;
5179 g
= (g
/ sum
+ color_adjust
) & 0xffff;
5180 b
= (b
/ sum
+ color_adjust
) & 0xffff;
5181 p
->red
= p
->green
= p
->blue
= COLOR_INTENSITY (r
, g
, b
);
5186 x_from_xcolors (f
, img
, new);
5192 /* Perform the pre-defined `emboss' edge-detection on image IMG
5200 x_detect_edges (f
, img
, emboss_matrix
, 0xffff / 2);
5204 /* Transform image IMG which is used on frame F with a Laplace
5205 edge-detection algorithm. The result is an image that can be used
5206 to draw disabled buttons, for example. */
5213 x_detect_edges (f
, img
, laplace_matrix
, 45000);
5217 /* Perform edge-detection on image IMG on frame F, with specified
5218 transformation matrix MATRIX and color-adjustment COLOR_ADJUST.
5220 MATRIX must be either
5222 - a list of at least 9 numbers in row-major form
5223 - a vector of at least 9 numbers
5225 COLOR_ADJUST nil means use a default; otherwise it must be a
5229 x_edge_detection (f
, img
, matrix
, color_adjust
)
5232 Lisp_Object matrix
, color_adjust
;
5240 i
< 9 && CONSP (matrix
) && NUMBERP (XCAR (matrix
));
5241 ++i
, matrix
= XCDR (matrix
))
5242 trans
[i
] = XFLOATINT (XCAR (matrix
));
5244 else if (VECTORP (matrix
) && ASIZE (matrix
) >= 9)
5246 for (i
= 0; i
< 9 && NUMBERP (AREF (matrix
, i
)); ++i
)
5247 trans
[i
] = XFLOATINT (AREF (matrix
, i
));
5250 if (NILP (color_adjust
))
5251 color_adjust
= make_number (0xffff / 2);
5253 if (i
== 9 && NUMBERP (color_adjust
))
5254 x_detect_edges (f
, img
, trans
, (int) XFLOATINT (color_adjust
));
5258 /* Transform image IMG on frame F so that it looks disabled. */
5261 x_disable_image (f
, img
)
5265 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
5267 int n_planes
= dpyinfo
->n_planes
* dpyinfo
->n_cbits
;
5269 int n_planes
= dpyinfo
->n_planes
;
5270 #endif /* HAVE_NTGUI */
5274 /* Color (or grayscale). Convert to gray, and equalize. Just
5275 drawing such images with a stipple can look very odd, so
5276 we're using this method instead. */
5277 XColor
*colors
= x_to_xcolors (f
, img
, 1);
5279 const int h
= 15000;
5280 const int l
= 30000;
5282 for (p
= colors
, end
= colors
+ img
->width
* img
->height
;
5286 int i
= COLOR_INTENSITY (p
->red
, p
->green
, p
->blue
);
5287 int i2
= (0xffff - h
- l
) * i
/ 0xffff + l
;
5288 p
->red
= p
->green
= p
->blue
= i2
;
5291 x_from_xcolors (f
, img
, colors
);
5294 /* Draw a cross over the disabled image, if we must or if we
5296 if (n_planes
< 2 || cross_disabled_images
)
5299 Display
*dpy
= FRAME_X_DISPLAY (f
);
5303 #define MaskForeground(f) PIX_MASK_DRAW
5305 #define MaskForeground(f) WHITE_PIX_DEFAULT (f)
5308 gc
= XCreateGC (dpy
, img
->pixmap
, 0, NULL
);
5309 XSetForeground (dpy
, gc
, BLACK_PIX_DEFAULT (f
));
5310 XDrawLine (dpy
, img
->pixmap
, gc
, 0, 0,
5311 img
->width
- 1, img
->height
- 1);
5312 XDrawLine (dpy
, img
->pixmap
, gc
, 0, img
->height
- 1,
5318 gc
= XCreateGC (dpy
, img
->mask
, 0, NULL
);
5319 XSetForeground (dpy
, gc
, MaskForeground (f
));
5320 XDrawLine (dpy
, img
->mask
, gc
, 0, 0,
5321 img
->width
- 1, img
->height
- 1);
5322 XDrawLine (dpy
, img
->mask
, gc
, 0, img
->height
- 1,
5330 hdc
= get_frame_dc (f
);
5331 bmpdc
= CreateCompatibleDC (hdc
);
5332 release_frame_dc (f
, hdc
);
5334 prev
= SelectObject (bmpdc
, img
->pixmap
);
5336 SetTextColor (bmpdc
, BLACK_PIX_DEFAULT (f
));
5337 MoveToEx (bmpdc
, 0, 0, NULL
);
5338 LineTo (bmpdc
, img
->width
- 1, img
->height
- 1);
5339 MoveToEx (bmpdc
, 0, img
->height
- 1, NULL
);
5340 LineTo (bmpdc
, img
->width
- 1, 0);
5344 SelectObject (bmpdc
, img
->mask
);
5345 SetTextColor (bmpdc
, WHITE_PIX_DEFAULT (f
));
5346 MoveToEx (bmpdc
, 0, 0, NULL
);
5347 LineTo (bmpdc
, img
->width
- 1, img
->height
- 1);
5348 MoveToEx (bmpdc
, 0, img
->height
- 1, NULL
);
5349 LineTo (bmpdc
, img
->width
- 1, 0);
5351 SelectObject (bmpdc
, prev
);
5353 #endif /* HAVE_NTGUI */
5358 /* Build a mask for image IMG which is used on frame F. FILE is the
5359 name of an image file, for error messages. HOW determines how to
5360 determine the background color of IMG. If it is a list '(R G B)',
5361 with R, G, and B being integers >= 0, take that as the color of the
5362 background. Otherwise, determine the background color of IMG
5363 heuristically. Value is non-zero if successful. */
5366 x_build_heuristic_mask (f
, img
, how
)
5371 XImagePtr_or_DC ximg
;
5379 #endif /* HAVE_NTGUI */
5380 int x
, y
, rc
, use_img_background
;
5381 unsigned long bg
= 0;
5385 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
5386 img
->mask
= NO_PIXMAP
;
5387 img
->background_transparent_valid
= 0;
5391 /* Create an image and pixmap serving as mask. */
5392 rc
= x_create_x_image_and_pixmap (f
, img
->width
, img
->height
, 1,
5393 &mask_img
, &img
->mask
);
5397 /* Get the X image of IMG->pixmap. */
5398 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
, 0, 0,
5399 img
->width
, img
->height
,
5402 /* Create the bit array serving as mask. */
5403 row_width
= (img
->width
+ 7) / 8;
5404 mask_img
= xmalloc (row_width
* img
->height
);
5405 bzero (mask_img
, row_width
* img
->height
);
5407 /* Create a memory device context for IMG->pixmap. */
5408 frame_dc
= get_frame_dc (f
);
5409 ximg
= CreateCompatibleDC (frame_dc
);
5410 release_frame_dc (f
, frame_dc
);
5411 prev
= SelectObject (ximg
, img
->pixmap
);
5412 #endif /* HAVE_NTGUI */
5414 /* Determine the background color of ximg. If HOW is `(R G B)'
5415 take that as color. Otherwise, use the image's background color. */
5416 use_img_background
= 1;
5422 for (i
= 0; i
< 3 && CONSP (how
) && NATNUMP (XCAR (how
)); ++i
)
5424 rgb
[i
] = XFASTINT (XCAR (how
)) & 0xffff;
5428 if (i
== 3 && NILP (how
))
5430 char color_name
[30];
5431 sprintf (color_name
, "#%04x%04x%04x", rgb
[0], rgb
[1], rgb
[2]);
5434 0x00ffffff & /* Filter out palette info. */
5435 #endif /* HAVE_NTGUI */
5436 x_alloc_image_color (f
, img
, build_string (color_name
), 0));
5437 use_img_background
= 0;
5441 if (use_img_background
)
5442 bg
= four_corners_best (ximg
, img
->corners
, img
->width
, img
->height
);
5444 /* Set all bits in mask_img to 1 whose color in ximg is different
5445 from the background color bg. */
5447 for (y
= 0; y
< img
->height
; ++y
)
5448 for (x
= 0; x
< img
->width
; ++x
)
5449 XPutPixel (mask_img
, x
, y
, (XGetPixel (ximg
, x
, y
) != bg
5450 ? PIX_MASK_DRAW
: PIX_MASK_RETAIN
));
5452 /* Fill in the background_transparent field while we have the mask handy. */
5453 image_background_transparent (img
, f
, mask_img
);
5455 /* Put mask_img into img->mask. */
5456 x_put_x_image (f
, mask_img
, img
->mask
, img
->width
, img
->height
);
5457 x_destroy_x_image (mask_img
);
5460 for (y
= 0; y
< img
->height
; ++y
)
5461 for (x
= 0; x
< img
->width
; ++x
)
5463 COLORREF p
= GetPixel (ximg
, x
, y
);
5465 mask_img
[y
* row_width
+ x
/ 8] |= 1 << (x
% 8);
5468 /* Create the mask image. */
5469 img
->mask
= w32_create_pixmap_from_bitmap_data (img
->width
, img
->height
,
5471 /* Fill in the background_transparent field while we have the mask handy. */
5472 SelectObject (ximg
, img
->mask
);
5473 image_background_transparent (img
, f
, ximg
);
5475 /* Was: x_destroy_x_image ((XImagePtr )mask_img); which seems bogus ++kfs */
5477 #endif /* HAVE_NTGUI */
5479 Destroy_Image (ximg
, prev
);
5485 /***********************************************************************
5486 PBM (mono, gray, color)
5487 ***********************************************************************/
5489 static int pbm_image_p
P_ ((Lisp_Object object
));
5490 static int pbm_load
P_ ((struct frame
*f
, struct image
*img
));
5491 static int pbm_scan_number
P_ ((unsigned char **, unsigned char *));
5493 /* The symbol `pbm' identifying images of this type. */
5497 /* Indices of image specification fields in gs_format, below. */
5499 enum pbm_keyword_index
5515 /* Vector of image_keyword structures describing the format
5516 of valid user-defined image specifications. */
5518 static struct image_keyword pbm_format
[PBM_LAST
] =
5520 {":type", IMAGE_SYMBOL_VALUE
, 1},
5521 {":file", IMAGE_STRING_VALUE
, 0},
5522 {":data", IMAGE_STRING_VALUE
, 0},
5523 {":ascent", IMAGE_ASCENT_VALUE
, 0},
5524 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
5525 {":relief", IMAGE_INTEGER_VALUE
, 0},
5526 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5527 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5528 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5529 {":foreground", IMAGE_STRING_OR_NIL_VALUE
, 0},
5530 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
5533 /* Structure describing the image type `pbm'. */
5535 static struct image_type pbm_type
=
5545 /* Return non-zero if OBJECT is a valid PBM image specification. */
5548 pbm_image_p (object
)
5551 struct image_keyword fmt
[PBM_LAST
];
5553 bcopy (pbm_format
, fmt
, sizeof fmt
);
5555 if (!parse_image_spec (object
, fmt
, PBM_LAST
, Qpbm
))
5558 /* Must specify either :data or :file. */
5559 return fmt
[PBM_DATA
].count
+ fmt
[PBM_FILE
].count
== 1;
5563 /* Scan a decimal number from *S and return it. Advance *S while
5564 reading the number. END is the end of the string. Value is -1 at
5568 pbm_scan_number (s
, end
)
5569 unsigned char **s
, *end
;
5571 int c
= 0, val
= -1;
5575 /* Skip white-space. */
5576 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
5581 /* Skip comment to end of line. */
5582 while (*s
< end
&& (c
= *(*s
)++, c
!= '\n'))
5585 else if (isdigit (c
))
5587 /* Read decimal number. */
5589 while (*s
< end
&& (c
= *(*s
)++, isdigit (c
)))
5590 val
= 10 * val
+ c
- '0';
5602 #if 0 /* Unused. ++kfs */
5604 /* Read FILE into memory. Value is a pointer to a buffer allocated
5605 with xmalloc holding FILE's contents. Value is null if an error
5606 occurred. *SIZE is set to the size of the file. */
5609 pbm_read_file (file
, size
)
5617 if (stat (SDATA (file
), &st
) == 0
5618 && (fp
= fopen (SDATA (file
), "rb")) != NULL
5619 && (buf
= (char *) xmalloc (st
.st_size
),
5620 fread (buf
, 1, st
.st_size
, fp
) == st
.st_size
))
5639 #endif /* HAVE_NTGUI */
5641 /* Load PBM image IMG for use on frame F. */
5649 int width
, height
, max_color_idx
= 0;
5651 Lisp_Object file
, specified_file
;
5652 enum {PBM_MONO
, PBM_GRAY
, PBM_COLOR
} type
;
5653 struct gcpro gcpro1
;
5654 unsigned char *contents
= NULL
;
5655 unsigned char *end
, *p
;
5658 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
5662 if (STRINGP (specified_file
))
5664 file
= x_find_image_file (specified_file
);
5665 if (!STRINGP (file
))
5667 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
5672 contents
= slurp_file (SDATA (file
), &size
);
5673 if (contents
== NULL
)
5675 image_error ("Error reading `%s'", file
, Qnil
);
5681 end
= contents
+ size
;
5686 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
5688 end
= p
+ SBYTES (data
);
5691 /* Check magic number. */
5692 if (end
- p
< 2 || *p
++ != 'P')
5694 image_error ("Not a PBM image: `%s'", img
->spec
, Qnil
);
5704 raw_p
= 0, type
= PBM_MONO
;
5708 raw_p
= 0, type
= PBM_GRAY
;
5712 raw_p
= 0, type
= PBM_COLOR
;
5716 raw_p
= 1, type
= PBM_MONO
;
5720 raw_p
= 1, type
= PBM_GRAY
;
5724 raw_p
= 1, type
= PBM_COLOR
;
5728 image_error ("Not a PBM image: `%s'", img
->spec
, Qnil
);
5732 /* Read width, height, maximum color-component. Characters
5733 starting with `#' up to the end of a line are ignored. */
5734 width
= pbm_scan_number (&p
, end
);
5735 height
= pbm_scan_number (&p
, end
);
5737 if (type
!= PBM_MONO
)
5739 max_color_idx
= pbm_scan_number (&p
, end
);
5740 if (raw_p
&& max_color_idx
> 255)
5741 max_color_idx
= 255;
5744 if (!check_image_size (f
, width
, height
)
5745 || (type
!= PBM_MONO
&& max_color_idx
< 0))
5748 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0,
5749 &ximg
, &img
->pixmap
))
5752 /* Initialize the color hash table. */
5753 init_color_table ();
5755 if (type
== PBM_MONO
)
5758 struct image_keyword fmt
[PBM_LAST
];
5759 unsigned long fg
= FRAME_FOREGROUND_PIXEL (f
);
5760 unsigned long bg
= FRAME_BACKGROUND_PIXEL (f
);
5762 /* Parse the image specification. */
5763 bcopy (pbm_format
, fmt
, sizeof fmt
);
5764 parse_image_spec (img
->spec
, fmt
, PBM_LAST
, Qpbm
);
5766 /* Get foreground and background colors, maybe allocate colors. */
5767 if (fmt
[PBM_FOREGROUND
].count
5768 && STRINGP (fmt
[PBM_FOREGROUND
].value
))
5769 fg
= x_alloc_image_color (f
, img
, fmt
[PBM_FOREGROUND
].value
, fg
);
5770 if (fmt
[PBM_BACKGROUND
].count
5771 && STRINGP (fmt
[PBM_BACKGROUND
].value
))
5773 bg
= x_alloc_image_color (f
, img
, fmt
[PBM_BACKGROUND
].value
, bg
);
5774 img
->background
= bg
;
5775 img
->background_valid
= 1;
5778 for (y
= 0; y
< height
; ++y
)
5779 for (x
= 0; x
< width
; ++x
)
5787 x_destroy_x_image (ximg
);
5788 x_clear_image (f
, img
);
5789 image_error ("Invalid image size in image `%s'",
5799 g
= pbm_scan_number (&p
, end
);
5801 XPutPixel (ximg
, x
, y
, g
? fg
: bg
);
5807 && ((type
== PBM_GRAY
)
5808 ? (p
+ height
* width
> end
)
5809 : (p
+ 3 * height
* width
> end
)))
5811 x_destroy_x_image (ximg
);
5812 x_clear_image (f
, img
);
5813 image_error ("Invalid image size in image `%s'",
5818 for (y
= 0; y
< height
; ++y
)
5819 for (x
= 0; x
< width
; ++x
)
5823 if (type
== PBM_GRAY
)
5824 r
= g
= b
= raw_p
? *p
++ : pbm_scan_number (&p
, end
);
5833 r
= pbm_scan_number (&p
, end
);
5834 g
= pbm_scan_number (&p
, end
);
5835 b
= pbm_scan_number (&p
, end
);
5838 if (r
< 0 || g
< 0 || b
< 0)
5840 x_destroy_x_image (ximg
);
5841 image_error ("Invalid pixel value in image `%s'",
5846 /* RGB values are now in the range 0..max_color_idx.
5847 Scale this to the range 0..0xffff supported by X. */
5848 r
= (double) r
* 65535 / max_color_idx
;
5849 g
= (double) g
* 65535 / max_color_idx
;
5850 b
= (double) b
* 65535 / max_color_idx
;
5851 XPutPixel (ximg
, x
, y
, lookup_rgb_color (f
, r
, g
, b
));
5855 #ifdef COLOR_TABLE_SUPPORT
5856 /* Store in IMG->colors the colors allocated for the image, and
5857 free the color table. */
5858 img
->colors
= colors_in_color_table (&img
->ncolors
);
5859 free_color_table ();
5860 #endif /* COLOR_TABLE_SUPPORT */
5863 img
->height
= height
;
5865 /* Maybe fill in the background field while we have ximg handy. */
5867 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
5868 /* Casting avoids a GCC warning. */
5869 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
5871 /* Put the image into a pixmap. */
5872 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
5873 x_destroy_x_image (ximg
);
5875 /* X and W32 versions did it here, MAC version above. ++kfs
5877 img->height = height; */
5885 /***********************************************************************
5887 ***********************************************************************/
5889 #if defined (HAVE_PNG) || defined (MAC_OS)
5891 /* Function prototypes. */
5893 static int png_image_p
P_ ((Lisp_Object object
));
5894 static int png_load
P_ ((struct frame
*f
, struct image
*img
));
5896 /* The symbol `png' identifying images of this type. */
5900 /* Indices of image specification fields in png_format, below. */
5902 enum png_keyword_index
5917 /* Vector of image_keyword structures describing the format
5918 of valid user-defined image specifications. */
5920 static struct image_keyword png_format
[PNG_LAST
] =
5922 {":type", IMAGE_SYMBOL_VALUE
, 1},
5923 {":data", IMAGE_STRING_VALUE
, 0},
5924 {":file", IMAGE_STRING_VALUE
, 0},
5925 {":ascent", IMAGE_ASCENT_VALUE
, 0},
5926 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
5927 {":relief", IMAGE_INTEGER_VALUE
, 0},
5928 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5929 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5930 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5931 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
5934 /* Structure describing the image type `png'. */
5936 static struct image_type png_type
=
5945 /* Return non-zero if OBJECT is a valid PNG image specification. */
5948 png_image_p (object
)
5951 struct image_keyword fmt
[PNG_LAST
];
5952 bcopy (png_format
, fmt
, sizeof fmt
);
5954 if (!parse_image_spec (object
, fmt
, PNG_LAST
, Qpng
))
5957 /* Must specify either the :data or :file keyword. */
5958 return fmt
[PNG_FILE
].count
+ fmt
[PNG_DATA
].count
== 1;
5961 #endif /* HAVE_PNG || MAC_OS */
5966 #if defined HAVE_LIBPNG_PNG_H
5967 # include <libpng/png.h>
5973 /* PNG library details. */
5975 DEF_IMGLIB_FN (png_get_io_ptr
);
5976 DEF_IMGLIB_FN (png_check_sig
);
5977 DEF_IMGLIB_FN (png_create_read_struct
);
5978 DEF_IMGLIB_FN (png_create_info_struct
);
5979 DEF_IMGLIB_FN (png_destroy_read_struct
);
5980 DEF_IMGLIB_FN (png_set_read_fn
);
5981 DEF_IMGLIB_FN (png_set_sig_bytes
);
5982 DEF_IMGLIB_FN (png_read_info
);
5983 DEF_IMGLIB_FN (png_get_IHDR
);
5984 DEF_IMGLIB_FN (png_get_valid
);
5985 DEF_IMGLIB_FN (png_set_strip_16
);
5986 DEF_IMGLIB_FN (png_set_expand
);
5987 DEF_IMGLIB_FN (png_set_gray_to_rgb
);
5988 DEF_IMGLIB_FN (png_set_background
);
5989 DEF_IMGLIB_FN (png_get_bKGD
);
5990 DEF_IMGLIB_FN (png_read_update_info
);
5991 DEF_IMGLIB_FN (png_get_channels
);
5992 DEF_IMGLIB_FN (png_get_rowbytes
);
5993 DEF_IMGLIB_FN (png_read_image
);
5994 DEF_IMGLIB_FN (png_read_end
);
5995 DEF_IMGLIB_FN (png_error
);
5998 init_png_functions (Lisp_Object libraries
)
6002 /* Try loading libpng under probable names. */
6003 if (!(library
= w32_delayed_load (libraries
, Qpng
)))
6006 LOAD_IMGLIB_FN (library
, png_get_io_ptr
);
6007 LOAD_IMGLIB_FN (library
, png_check_sig
);
6008 LOAD_IMGLIB_FN (library
, png_create_read_struct
);
6009 LOAD_IMGLIB_FN (library
, png_create_info_struct
);
6010 LOAD_IMGLIB_FN (library
, png_destroy_read_struct
);
6011 LOAD_IMGLIB_FN (library
, png_set_read_fn
);
6012 LOAD_IMGLIB_FN (library
, png_set_sig_bytes
);
6013 LOAD_IMGLIB_FN (library
, png_read_info
);
6014 LOAD_IMGLIB_FN (library
, png_get_IHDR
);
6015 LOAD_IMGLIB_FN (library
, png_get_valid
);
6016 LOAD_IMGLIB_FN (library
, png_set_strip_16
);
6017 LOAD_IMGLIB_FN (library
, png_set_expand
);
6018 LOAD_IMGLIB_FN (library
, png_set_gray_to_rgb
);
6019 LOAD_IMGLIB_FN (library
, png_set_background
);
6020 LOAD_IMGLIB_FN (library
, png_get_bKGD
);
6021 LOAD_IMGLIB_FN (library
, png_read_update_info
);
6022 LOAD_IMGLIB_FN (library
, png_get_channels
);
6023 LOAD_IMGLIB_FN (library
, png_get_rowbytes
);
6024 LOAD_IMGLIB_FN (library
, png_read_image
);
6025 LOAD_IMGLIB_FN (library
, png_read_end
);
6026 LOAD_IMGLIB_FN (library
, png_error
);
6031 #define fn_png_get_io_ptr png_get_io_ptr
6032 #define fn_png_check_sig png_check_sig
6033 #define fn_png_create_read_struct png_create_read_struct
6034 #define fn_png_create_info_struct png_create_info_struct
6035 #define fn_png_destroy_read_struct png_destroy_read_struct
6036 #define fn_png_set_read_fn png_set_read_fn
6037 #define fn_png_set_sig_bytes png_set_sig_bytes
6038 #define fn_png_read_info png_read_info
6039 #define fn_png_get_IHDR png_get_IHDR
6040 #define fn_png_get_valid png_get_valid
6041 #define fn_png_set_strip_16 png_set_strip_16
6042 #define fn_png_set_expand png_set_expand
6043 #define fn_png_set_gray_to_rgb png_set_gray_to_rgb
6044 #define fn_png_set_background png_set_background
6045 #define fn_png_get_bKGD png_get_bKGD
6046 #define fn_png_read_update_info png_read_update_info
6047 #define fn_png_get_channels png_get_channels
6048 #define fn_png_get_rowbytes png_get_rowbytes
6049 #define fn_png_read_image png_read_image
6050 #define fn_png_read_end png_read_end
6051 #define fn_png_error png_error
6053 #endif /* HAVE_NTGUI */
6055 /* Error and warning handlers installed when the PNG library
6059 my_png_error (png_ptr
, msg
)
6060 png_struct
*png_ptr
;
6063 xassert (png_ptr
!= NULL
);
6064 image_error ("PNG error: %s", build_string (msg
), Qnil
);
6065 longjmp (png_ptr
->jmpbuf
, 1);
6070 my_png_warning (png_ptr
, msg
)
6071 png_struct
*png_ptr
;
6074 xassert (png_ptr
!= NULL
);
6075 image_error ("PNG warning: %s", build_string (msg
), Qnil
);
6078 /* Memory source for PNG decoding. */
6080 struct png_memory_storage
6082 unsigned char *bytes
; /* The data */
6083 size_t len
; /* How big is it? */
6084 int index
; /* Where are we? */
6088 /* Function set as reader function when reading PNG image from memory.
6089 PNG_PTR is a pointer to the PNG control structure. Copy LENGTH
6090 bytes from the input to DATA. */
6093 png_read_from_memory (png_ptr
, data
, length
)
6094 png_structp png_ptr
;
6098 struct png_memory_storage
*tbr
6099 = (struct png_memory_storage
*) fn_png_get_io_ptr (png_ptr
);
6101 if (length
> tbr
->len
- tbr
->index
)
6102 fn_png_error (png_ptr
, "Read error");
6104 bcopy (tbr
->bytes
+ tbr
->index
, data
, length
);
6105 tbr
->index
= tbr
->index
+ length
;
6109 /* Function set as reader function when reading PNG image from a file.
6110 PNG_PTR is a pointer to the PNG control structure. Copy LENGTH
6111 bytes from the input to DATA. */
6114 png_read_from_file (png_ptr
, data
, length
)
6115 png_structp png_ptr
;
6119 FILE *fp
= (FILE *) fn_png_get_io_ptr (png_ptr
);
6121 if (fread (data
, 1, length
, fp
) < length
)
6122 fn_png_error (png_ptr
, "Read error");
6126 /* Load PNG image IMG for use on frame F. Value is non-zero if
6134 Lisp_Object file
, specified_file
;
6135 Lisp_Object specified_data
;
6137 XImagePtr ximg
, mask_img
= NULL
;
6138 struct gcpro gcpro1
;
6139 png_struct
*png_ptr
= NULL
;
6140 png_info
*info_ptr
= NULL
, *end_info
= NULL
;
6141 FILE *volatile fp
= NULL
;
6143 png_byte
* volatile pixels
= NULL
;
6144 png_byte
** volatile rows
= NULL
;
6145 png_uint_32 width
, height
;
6146 int bit_depth
, color_type
, interlace_type
;
6148 png_uint_32 row_bytes
;
6150 double screen_gamma
;
6151 struct png_memory_storage tbr
; /* Data to be read */
6153 /* Find out what file to load. */
6154 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
6155 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
6159 if (NILP (specified_data
))
6161 file
= x_find_image_file (specified_file
);
6162 if (!STRINGP (file
))
6164 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
6169 /* Open the image file. */
6170 fp
= fopen (SDATA (file
), "rb");
6173 image_error ("Cannot open image file `%s'", file
, Qnil
);
6178 /* Check PNG signature. */
6179 if (fread (sig
, 1, sizeof sig
, fp
) != sizeof sig
6180 || !fn_png_check_sig (sig
, sizeof sig
))
6182 image_error ("Not a PNG file: `%s'", file
, Qnil
);
6190 /* Read from memory. */
6191 tbr
.bytes
= SDATA (specified_data
);
6192 tbr
.len
= SBYTES (specified_data
);
6195 /* Check PNG signature. */
6196 if (tbr
.len
< sizeof sig
6197 || !fn_png_check_sig (tbr
.bytes
, sizeof sig
))
6199 image_error ("Not a PNG image: `%s'", img
->spec
, Qnil
);
6204 /* Need to skip past the signature. */
6205 tbr
.bytes
+= sizeof (sig
);
6208 /* Initialize read and info structs for PNG lib. Casting return
6209 value avoids a GCC warning on W32. */
6210 png_ptr
= (png_structp
)fn_png_create_read_struct (PNG_LIBPNG_VER_STRING
,
6215 if (fp
) fclose (fp
);
6220 /* Casting return value avoids a GCC warning on W32. */
6221 info_ptr
= (png_infop
)fn_png_create_info_struct (png_ptr
);
6224 fn_png_destroy_read_struct (&png_ptr
, NULL
, NULL
);
6225 if (fp
) fclose (fp
);
6230 /* Casting return value avoids a GCC warning on W32. */
6231 end_info
= (png_infop
)fn_png_create_info_struct (png_ptr
);
6234 fn_png_destroy_read_struct (&png_ptr
, &info_ptr
, NULL
);
6235 if (fp
) fclose (fp
);
6240 /* Set error jump-back. We come back here when the PNG library
6241 detects an error. */
6242 if (setjmp (png_ptr
->jmpbuf
))
6246 fn_png_destroy_read_struct (&png_ptr
, &info_ptr
, &end_info
);
6249 if (fp
) fclose (fp
);
6254 /* Read image info. */
6255 if (!NILP (specified_data
))
6256 fn_png_set_read_fn (png_ptr
, (void *) &tbr
, png_read_from_memory
);
6258 fn_png_set_read_fn (png_ptr
, (void *) fp
, png_read_from_file
);
6260 fn_png_set_sig_bytes (png_ptr
, sizeof sig
);
6261 fn_png_read_info (png_ptr
, info_ptr
);
6262 fn_png_get_IHDR (png_ptr
, info_ptr
, &width
, &height
, &bit_depth
, &color_type
,
6263 &interlace_type
, NULL
, NULL
);
6265 if (!check_image_size (f
, width
, height
))
6268 /* If image contains simply transparency data, we prefer to
6269 construct a clipping mask. */
6270 if (fn_png_get_valid (png_ptr
, info_ptr
, PNG_INFO_tRNS
))
6275 /* This function is easier to write if we only have to handle
6276 one data format: RGB or RGBA with 8 bits per channel. Let's
6277 transform other formats into that format. */
6279 /* Strip more than 8 bits per channel. */
6280 if (bit_depth
== 16)
6281 fn_png_set_strip_16 (png_ptr
);
6283 /* Expand data to 24 bit RGB, or 8 bit grayscale, with alpha channel
6285 fn_png_set_expand (png_ptr
);
6287 /* Convert grayscale images to RGB. */
6288 if (color_type
== PNG_COLOR_TYPE_GRAY
6289 || color_type
== PNG_COLOR_TYPE_GRAY_ALPHA
)
6290 fn_png_set_gray_to_rgb (png_ptr
);
6292 screen_gamma
= (f
->gamma
? 1 / f
->gamma
/ 0.45455 : 2.2);
6294 #if 0 /* Avoid double gamma correction for PNG images. */
6295 { /* Tell the PNG lib to handle gamma correction for us. */
6298 #if defined(PNG_READ_sRGB_SUPPORTED) || defined(PNG_WRITE_sRGB_SUPPORTED)
6299 if (png_get_sRGB (png_ptr
, info_ptr
, &intent
))
6300 /* The libpng documentation says this is right in this case. */
6301 png_set_gamma (png_ptr
, screen_gamma
, 0.45455);
6304 if (png_get_gAMA (png_ptr
, info_ptr
, &image_gamma
))
6305 /* Image contains gamma information. */
6306 png_set_gamma (png_ptr
, screen_gamma
, image_gamma
);
6308 /* Use the standard default for the image gamma. */
6309 png_set_gamma (png_ptr
, screen_gamma
, 0.45455);
6313 /* Handle alpha channel by combining the image with a background
6314 color. Do this only if a real alpha channel is supplied. For
6315 simple transparency, we prefer a clipping mask. */
6318 png_color_16
*image_bg
;
6319 Lisp_Object specified_bg
6320 = image_spec_value (img
->spec
, QCbackground
, NULL
);
6322 if (STRINGP (specified_bg
))
6323 /* The user specified `:background', use that. */
6325 /* W32 version incorrectly used COLORREF here!! ++kfs */
6327 if (x_defined_color (f
, SDATA (specified_bg
), &color
, 0))
6329 png_color_16 user_bg
;
6331 bzero (&user_bg
, sizeof user_bg
);
6332 user_bg
.red
= color
.red
>> 8;
6333 user_bg
.green
= color
.green
>> 8;
6334 user_bg
.blue
= color
.blue
>> 8;
6336 fn_png_set_background (png_ptr
, &user_bg
,
6337 PNG_BACKGROUND_GAMMA_SCREEN
, 0, 1.0);
6340 else if (fn_png_get_bKGD (png_ptr
, info_ptr
, &image_bg
))
6341 /* Image contains a background color with which to
6342 combine the image. */
6343 fn_png_set_background (png_ptr
, image_bg
,
6344 PNG_BACKGROUND_GAMMA_FILE
, 1, 1.0);
6347 /* Image does not contain a background color with which
6348 to combine the image data via an alpha channel. Use
6349 the frame's background instead. */
6350 #ifdef HAVE_X_WINDOWS
6352 png_color_16 frame_background
;
6354 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
6355 x_query_color (f
, &color
);
6357 bzero (&frame_background
, sizeof frame_background
);
6358 frame_background
.red
= color
.red
>> 8;
6359 frame_background
.green
= color
.green
>> 8;
6360 frame_background
.blue
= color
.blue
>> 8;
6361 #endif /* HAVE_X_WINDOWS */
6365 png_color_16 frame_background
;
6366 color
= FRAME_BACKGROUND_PIXEL (f
);
6367 #if 0 /* W32 TODO : Colormap support. */
6368 x_query_color (f
, &color
);
6370 bzero (&frame_background
, sizeof frame_background
);
6371 frame_background
.red
= GetRValue (color
);
6372 frame_background
.green
= GetGValue (color
);
6373 frame_background
.blue
= GetBValue (color
);
6374 #endif /* HAVE_NTGUI */
6377 unsigned long color
;
6378 png_color_16 frame_background
;
6379 color
= FRAME_BACKGROUND_PIXEL (f
);
6380 #if 0 /* MAC/W32 TODO : Colormap support. */
6381 x_query_color (f
, &color
);
6383 bzero (&frame_background
, sizeof frame_background
);
6384 frame_background
.red
= RED_FROM_ULONG (color
);
6385 frame_background
.green
= GREEN_FROM_ULONG (color
);
6386 frame_background
.blue
= BLUE_FROM_ULONG (color
);
6389 fn_png_set_background (png_ptr
, &frame_background
,
6390 PNG_BACKGROUND_GAMMA_SCREEN
, 0, 1.0);
6394 /* Update info structure. */
6395 fn_png_read_update_info (png_ptr
, info_ptr
);
6397 /* Get number of channels. Valid values are 1 for grayscale images
6398 and images with a palette, 2 for grayscale images with transparency
6399 information (alpha channel), 3 for RGB images, and 4 for RGB
6400 images with alpha channel, i.e. RGBA. If conversions above were
6401 sufficient we should only have 3 or 4 channels here. */
6402 channels
= fn_png_get_channels (png_ptr
, info_ptr
);
6403 xassert (channels
== 3 || channels
== 4);
6405 /* Number of bytes needed for one row of the image. */
6406 row_bytes
= fn_png_get_rowbytes (png_ptr
, info_ptr
);
6408 /* Allocate memory for the image. */
6409 pixels
= (png_byte
*) xmalloc (row_bytes
* height
* sizeof *pixels
);
6410 rows
= (png_byte
**) xmalloc (height
* sizeof *rows
);
6411 for (i
= 0; i
< height
; ++i
)
6412 rows
[i
] = pixels
+ i
* row_bytes
;
6414 /* Read the entire image. */
6415 fn_png_read_image (png_ptr
, rows
);
6416 fn_png_read_end (png_ptr
, info_ptr
);
6423 /* Create the X image and pixmap. */
6424 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
,
6428 /* Create an image and pixmap serving as mask if the PNG image
6429 contains an alpha channel. */
6432 && !x_create_x_image_and_pixmap (f
, width
, height
, 1,
6433 &mask_img
, &img
->mask
))
6435 x_destroy_x_image (ximg
);
6436 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->pixmap
);
6437 img
->pixmap
= NO_PIXMAP
;
6441 /* Fill the X image and mask from PNG data. */
6442 init_color_table ();
6444 for (y
= 0; y
< height
; ++y
)
6446 png_byte
*p
= rows
[y
];
6448 for (x
= 0; x
< width
; ++x
)
6455 XPutPixel (ximg
, x
, y
, lookup_rgb_color (f
, r
, g
, b
));
6456 /* An alpha channel, aka mask channel, associates variable
6457 transparency with an image. Where other image formats
6458 support binary transparency---fully transparent or fully
6459 opaque---PNG allows up to 254 levels of partial transparency.
6460 The PNG library implements partial transparency by combining
6461 the image with a specified background color.
6463 I'm not sure how to handle this here nicely: because the
6464 background on which the image is displayed may change, for
6465 real alpha channel support, it would be necessary to create
6466 a new image for each possible background.
6468 What I'm doing now is that a mask is created if we have
6469 boolean transparency information. Otherwise I'm using
6470 the frame's background color to combine the image with. */
6475 XPutPixel (mask_img
, x
, y
, *p
> 0 ? PIX_MASK_DRAW
: PIX_MASK_RETAIN
);
6481 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
6482 /* Set IMG's background color from the PNG image, unless the user
6486 if (fn_png_get_bKGD (png_ptr
, info_ptr
, &bg
))
6488 img
->background
= lookup_rgb_color (f
, bg
->red
, bg
->green
, bg
->blue
);
6489 img
->background_valid
= 1;
6493 #ifdef COLOR_TABLE_SUPPORT
6494 /* Remember colors allocated for this image. */
6495 img
->colors
= colors_in_color_table (&img
->ncolors
);
6496 free_color_table ();
6497 #endif /* COLOR_TABLE_SUPPORT */
6500 fn_png_destroy_read_struct (&png_ptr
, &info_ptr
, &end_info
);
6505 img
->height
= height
;
6507 /* Maybe fill in the background field while we have ximg handy.
6508 Casting avoids a GCC warning. */
6509 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
6511 /* Put the image into the pixmap, then free the X image and its buffer. */
6512 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
6513 x_destroy_x_image (ximg
);
6515 /* Same for the mask. */
6518 /* Fill in the background_transparent field while we have the
6519 mask handy. Casting avoids a GCC warning. */
6520 image_background_transparent (img
, f
, (XImagePtr_or_DC
)mask_img
);
6522 x_put_x_image (f
, mask_img
, img
->mask
, img
->width
, img
->height
);
6523 x_destroy_x_image (mask_img
);
6530 #else /* HAVE_PNG */
6539 if (MyCGImageCreateWithPNGDataProvider
)
6540 return image_load_quartz2d (f
, img
, 1);
6543 return image_load_quicktime (f
, img
, kQTFileTypePNG
);
6547 #endif /* !HAVE_PNG */
6551 /***********************************************************************
6553 ***********************************************************************/
6555 #if defined (HAVE_JPEG) || defined (MAC_OS)
6557 static int jpeg_image_p
P_ ((Lisp_Object object
));
6558 static int jpeg_load
P_ ((struct frame
*f
, struct image
*img
));
6560 /* The symbol `jpeg' identifying images of this type. */
6564 /* Indices of image specification fields in gs_format, below. */
6566 enum jpeg_keyword_index
6575 JPEG_HEURISTIC_MASK
,
6581 /* Vector of image_keyword structures describing the format
6582 of valid user-defined image specifications. */
6584 static struct image_keyword jpeg_format
[JPEG_LAST
] =
6586 {":type", IMAGE_SYMBOL_VALUE
, 1},
6587 {":data", IMAGE_STRING_VALUE
, 0},
6588 {":file", IMAGE_STRING_VALUE
, 0},
6589 {":ascent", IMAGE_ASCENT_VALUE
, 0},
6590 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
6591 {":relief", IMAGE_INTEGER_VALUE
, 0},
6592 {":conversions", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6593 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6594 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6595 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
6598 /* Structure describing the image type `jpeg'. */
6600 static struct image_type jpeg_type
=
6609 /* Return non-zero if OBJECT is a valid JPEG image specification. */
6612 jpeg_image_p (object
)
6615 struct image_keyword fmt
[JPEG_LAST
];
6617 bcopy (jpeg_format
, fmt
, sizeof fmt
);
6619 if (!parse_image_spec (object
, fmt
, JPEG_LAST
, Qjpeg
))
6622 /* Must specify either the :data or :file keyword. */
6623 return fmt
[JPEG_FILE
].count
+ fmt
[JPEG_DATA
].count
== 1;
6626 #endif /* HAVE_JPEG || MAC_OS */
6630 /* Work around a warning about HAVE_STDLIB_H being redefined in
6632 #ifdef HAVE_STDLIB_H
6633 #define HAVE_STDLIB_H_1
6634 #undef HAVE_STDLIB_H
6635 #endif /* HAVE_STLIB_H */
6637 #if defined (HAVE_NTGUI) && !defined (__WIN32__)
6638 /* In older releases of the jpeg library, jpeglib.h will define boolean
6639 differently depending on __WIN32__, so make sure it is defined. */
6643 #include <jpeglib.h>
6647 #ifdef HAVE_STLIB_H_1
6648 #define HAVE_STDLIB_H 1
6653 /* JPEG library details. */
6654 DEF_IMGLIB_FN (jpeg_CreateDecompress
);
6655 DEF_IMGLIB_FN (jpeg_start_decompress
);
6656 DEF_IMGLIB_FN (jpeg_finish_decompress
);
6657 DEF_IMGLIB_FN (jpeg_destroy_decompress
);
6658 DEF_IMGLIB_FN (jpeg_read_header
);
6659 DEF_IMGLIB_FN (jpeg_read_scanlines
);
6660 DEF_IMGLIB_FN (jpeg_std_error
);
6661 DEF_IMGLIB_FN (jpeg_resync_to_restart
);
6664 init_jpeg_functions (Lisp_Object libraries
)
6668 if (!(library
= w32_delayed_load (libraries
, Qjpeg
)))
6671 LOAD_IMGLIB_FN (library
, jpeg_finish_decompress
);
6672 LOAD_IMGLIB_FN (library
, jpeg_read_scanlines
);
6673 LOAD_IMGLIB_FN (library
, jpeg_start_decompress
);
6674 LOAD_IMGLIB_FN (library
, jpeg_read_header
);
6675 LOAD_IMGLIB_FN (library
, jpeg_CreateDecompress
);
6676 LOAD_IMGLIB_FN (library
, jpeg_destroy_decompress
);
6677 LOAD_IMGLIB_FN (library
, jpeg_std_error
);
6678 LOAD_IMGLIB_FN (library
, jpeg_resync_to_restart
);
6682 /* Wrapper since we can't directly assign the function pointer
6683 to another function pointer that was declared more completely easily. */
6685 jpeg_resync_to_restart_wrapper(cinfo
, desired
)
6686 j_decompress_ptr cinfo
;
6689 return fn_jpeg_resync_to_restart (cinfo
, desired
);
6694 #define fn_jpeg_CreateDecompress(a,b,c) jpeg_create_decompress(a)
6695 #define fn_jpeg_start_decompress jpeg_start_decompress
6696 #define fn_jpeg_finish_decompress jpeg_finish_decompress
6697 #define fn_jpeg_destroy_decompress jpeg_destroy_decompress
6698 #define fn_jpeg_read_header jpeg_read_header
6699 #define fn_jpeg_read_scanlines jpeg_read_scanlines
6700 #define fn_jpeg_std_error jpeg_std_error
6701 #define jpeg_resync_to_restart_wrapper jpeg_resync_to_restart
6703 #endif /* HAVE_NTGUI */
6705 struct my_jpeg_error_mgr
6707 struct jpeg_error_mgr pub
;
6708 jmp_buf setjmp_buffer
;
6713 my_error_exit (cinfo
)
6716 struct my_jpeg_error_mgr
*mgr
= (struct my_jpeg_error_mgr
*) cinfo
->err
;
6717 longjmp (mgr
->setjmp_buffer
, 1);
6721 /* Init source method for JPEG data source manager. Called by
6722 jpeg_read_header() before any data is actually read. See
6723 libjpeg.doc from the JPEG lib distribution. */
6726 our_common_init_source (cinfo
)
6727 j_decompress_ptr cinfo
;
6732 /* Method to terminate data source. Called by
6733 jpeg_finish_decompress() after all data has been processed. */
6736 our_common_term_source (cinfo
)
6737 j_decompress_ptr cinfo
;
6742 /* Fill input buffer method for JPEG data source manager. Called
6743 whenever more data is needed. We read the whole image in one step,
6744 so this only adds a fake end of input marker at the end. */
6747 our_memory_fill_input_buffer (cinfo
)
6748 j_decompress_ptr cinfo
;
6750 /* Insert a fake EOI marker. */
6751 struct jpeg_source_mgr
*src
= cinfo
->src
;
6752 static JOCTET buffer
[2];
6754 buffer
[0] = (JOCTET
) 0xFF;
6755 buffer
[1] = (JOCTET
) JPEG_EOI
;
6757 src
->next_input_byte
= buffer
;
6758 src
->bytes_in_buffer
= 2;
6763 /* Method to skip over NUM_BYTES bytes in the image data. CINFO->src
6764 is the JPEG data source manager. */
6767 our_memory_skip_input_data (cinfo
, num_bytes
)
6768 j_decompress_ptr cinfo
;
6771 struct jpeg_source_mgr
*src
= (struct jpeg_source_mgr
*) cinfo
->src
;
6775 if (num_bytes
> src
->bytes_in_buffer
)
6776 ERREXIT (cinfo
, JERR_INPUT_EOF
);
6778 src
->bytes_in_buffer
-= num_bytes
;
6779 src
->next_input_byte
+= num_bytes
;
6784 /* Set up the JPEG lib for reading an image from DATA which contains
6785 LEN bytes. CINFO is the decompression info structure created for
6786 reading the image. */
6789 jpeg_memory_src (cinfo
, data
, len
)
6790 j_decompress_ptr cinfo
;
6794 struct jpeg_source_mgr
*src
;
6796 if (cinfo
->src
== NULL
)
6798 /* First time for this JPEG object? */
6799 cinfo
->src
= (struct jpeg_source_mgr
*)
6800 (*cinfo
->mem
->alloc_small
) ((j_common_ptr
) cinfo
, JPOOL_PERMANENT
,
6801 sizeof (struct jpeg_source_mgr
));
6802 src
= (struct jpeg_source_mgr
*) cinfo
->src
;
6803 src
->next_input_byte
= data
;
6806 src
= (struct jpeg_source_mgr
*) cinfo
->src
;
6807 src
->init_source
= our_common_init_source
;
6808 src
->fill_input_buffer
= our_memory_fill_input_buffer
;
6809 src
->skip_input_data
= our_memory_skip_input_data
;
6810 src
->resync_to_restart
= jpeg_resync_to_restart_wrapper
; /* Use default method. */
6811 src
->term_source
= our_common_term_source
;
6812 src
->bytes_in_buffer
= len
;
6813 src
->next_input_byte
= data
;
6817 struct jpeg_stdio_mgr
6819 struct jpeg_source_mgr mgr
;
6826 /* Size of buffer to read JPEG from file.
6827 Not too big, as we want to use alloc_small. */
6828 #define JPEG_STDIO_BUFFER_SIZE 8192
6831 /* Fill input buffer method for JPEG data source manager. Called
6832 whenever more data is needed. The data is read from a FILE *. */
6835 our_stdio_fill_input_buffer (cinfo
)
6836 j_decompress_ptr cinfo
;
6838 struct jpeg_stdio_mgr
*src
;
6840 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6845 bytes
= fread (src
->buffer
, 1, JPEG_STDIO_BUFFER_SIZE
, src
->file
);
6847 src
->mgr
.bytes_in_buffer
= bytes
;
6850 WARNMS (cinfo
, JWRN_JPEG_EOF
);
6852 src
->buffer
[0] = (JOCTET
) 0xFF;
6853 src
->buffer
[1] = (JOCTET
) JPEG_EOI
;
6854 src
->mgr
.bytes_in_buffer
= 2;
6856 src
->mgr
.next_input_byte
= src
->buffer
;
6863 /* Method to skip over NUM_BYTES bytes in the image data. CINFO->src
6864 is the JPEG data source manager. */
6867 our_stdio_skip_input_data (cinfo
, num_bytes
)
6868 j_decompress_ptr cinfo
;
6871 struct jpeg_stdio_mgr
*src
;
6872 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6874 while (num_bytes
> 0 && !src
->finished
)
6876 if (num_bytes
<= src
->mgr
.bytes_in_buffer
)
6878 src
->mgr
.bytes_in_buffer
-= num_bytes
;
6879 src
->mgr
.next_input_byte
+= num_bytes
;
6884 num_bytes
-= src
->mgr
.bytes_in_buffer
;
6885 src
->mgr
.bytes_in_buffer
= 0;
6886 src
->mgr
.next_input_byte
= NULL
;
6888 our_stdio_fill_input_buffer (cinfo
);
6894 /* Set up the JPEG lib for reading an image from a FILE *.
6895 CINFO is the decompression info structure created for
6896 reading the image. */
6899 jpeg_file_src (cinfo
, fp
)
6900 j_decompress_ptr cinfo
;
6903 struct jpeg_stdio_mgr
*src
;
6905 if (cinfo
->src
!= NULL
)
6906 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6909 /* First time for this JPEG object? */
6910 cinfo
->src
= (struct jpeg_source_mgr
*)
6911 (*cinfo
->mem
->alloc_small
) ((j_common_ptr
) cinfo
, JPOOL_PERMANENT
,
6912 sizeof (struct jpeg_stdio_mgr
));
6913 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6914 src
->buffer
= (JOCTET
*)
6915 (*cinfo
->mem
->alloc_small
) ((j_common_ptr
) cinfo
, JPOOL_PERMANENT
,
6916 JPEG_STDIO_BUFFER_SIZE
);
6921 src
->mgr
.init_source
= our_common_init_source
;
6922 src
->mgr
.fill_input_buffer
= our_stdio_fill_input_buffer
;
6923 src
->mgr
.skip_input_data
= our_stdio_skip_input_data
;
6924 src
->mgr
.resync_to_restart
= jpeg_resync_to_restart_wrapper
; /* Use default method. */
6925 src
->mgr
.term_source
= our_common_term_source
;
6926 src
->mgr
.bytes_in_buffer
= 0;
6927 src
->mgr
.next_input_byte
= NULL
;
6931 /* Load image IMG for use on frame F. Patterned after example.c
6932 from the JPEG lib. */
6939 struct jpeg_decompress_struct cinfo
;
6940 struct my_jpeg_error_mgr mgr
;
6941 Lisp_Object file
, specified_file
;
6942 Lisp_Object specified_data
;
6943 FILE * volatile fp
= NULL
;
6945 int row_stride
, x
, y
;
6946 XImagePtr ximg
= NULL
;
6948 unsigned long *colors
;
6950 struct gcpro gcpro1
;
6952 /* Open the JPEG file. */
6953 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
6954 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
6958 if (NILP (specified_data
))
6960 file
= x_find_image_file (specified_file
);
6961 if (!STRINGP (file
))
6963 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
6968 fp
= fopen (SDATA (file
), "rb");
6971 image_error ("Cannot open `%s'", file
, Qnil
);
6977 /* Customize libjpeg's error handling to call my_error_exit when an
6978 error is detected. This function will perform a longjmp.
6979 Casting return value avoids a GCC warning on W32. */
6980 cinfo
.err
= (struct jpeg_error_mgr
*)fn_jpeg_std_error (&mgr
.pub
);
6981 mgr
.pub
.error_exit
= my_error_exit
;
6983 if ((rc
= setjmp (mgr
.setjmp_buffer
)) != 0)
6987 /* Called from my_error_exit. Display a JPEG error. */
6988 char buffer
[JMSG_LENGTH_MAX
];
6989 cinfo
.err
->format_message ((j_common_ptr
) &cinfo
, buffer
);
6990 image_error ("Error reading JPEG image `%s': %s", img
->spec
,
6991 build_string (buffer
));
6994 /* Close the input file and destroy the JPEG object. */
6996 fclose ((FILE *) fp
);
6997 fn_jpeg_destroy_decompress (&cinfo
);
6999 /* If we already have an XImage, free that. */
7000 x_destroy_x_image (ximg
);
7002 /* Free pixmap and colors. */
7003 x_clear_image (f
, img
);
7009 /* Create the JPEG decompression object. Let it read from fp.
7010 Read the JPEG image header. */
7011 fn_jpeg_CreateDecompress (&cinfo
, JPEG_LIB_VERSION
, sizeof (cinfo
));
7013 if (NILP (specified_data
))
7014 jpeg_file_src (&cinfo
, (FILE *) fp
);
7016 jpeg_memory_src (&cinfo
, SDATA (specified_data
),
7017 SBYTES (specified_data
));
7019 fn_jpeg_read_header (&cinfo
, 1);
7021 /* Customize decompression so that color quantization will be used.
7022 Start decompression. */
7023 cinfo
.quantize_colors
= 1;
7024 fn_jpeg_start_decompress (&cinfo
);
7025 width
= img
->width
= cinfo
.output_width
;
7026 height
= img
->height
= cinfo
.output_height
;
7028 if (!check_image_size (f
, width
, height
))
7030 image_error ("Invalid image size", Qnil
, Qnil
);
7031 longjmp (mgr
.setjmp_buffer
, 2);
7034 /* Create X image and pixmap. */
7035 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
7036 longjmp (mgr
.setjmp_buffer
, 2);
7038 /* Allocate colors. When color quantization is used,
7039 cinfo.actual_number_of_colors has been set with the number of
7040 colors generated, and cinfo.colormap is a two-dimensional array
7041 of color indices in the range 0..cinfo.actual_number_of_colors.
7042 No more than 255 colors will be generated. */
7046 if (cinfo
.out_color_components
> 2)
7047 ir
= 0, ig
= 1, ib
= 2;
7048 else if (cinfo
.out_color_components
> 1)
7049 ir
= 0, ig
= 1, ib
= 0;
7051 ir
= 0, ig
= 0, ib
= 0;
7053 /* Use the color table mechanism because it handles colors that
7054 cannot be allocated nicely. Such colors will be replaced with
7055 a default color, and we don't have to care about which colors
7056 can be freed safely, and which can't. */
7057 init_color_table ();
7058 colors
= (unsigned long *) alloca (cinfo
.actual_number_of_colors
7061 for (i
= 0; i
< cinfo
.actual_number_of_colors
; ++i
)
7063 /* Multiply RGB values with 255 because X expects RGB values
7064 in the range 0..0xffff. */
7065 int r
= cinfo
.colormap
[ir
][i
] << 8;
7066 int g
= cinfo
.colormap
[ig
][i
] << 8;
7067 int b
= cinfo
.colormap
[ib
][i
] << 8;
7068 colors
[i
] = lookup_rgb_color (f
, r
, g
, b
);
7071 #ifdef COLOR_TABLE_SUPPORT
7072 /* Remember those colors actually allocated. */
7073 img
->colors
= colors_in_color_table (&img
->ncolors
);
7074 free_color_table ();
7075 #endif /* COLOR_TABLE_SUPPORT */
7079 row_stride
= width
* cinfo
.output_components
;
7080 buffer
= cinfo
.mem
->alloc_sarray ((j_common_ptr
) &cinfo
, JPOOL_IMAGE
,
7082 for (y
= 0; y
< height
; ++y
)
7084 fn_jpeg_read_scanlines (&cinfo
, buffer
, 1);
7085 for (x
= 0; x
< cinfo
.output_width
; ++x
)
7086 XPutPixel (ximg
, x
, y
, colors
[buffer
[0][x
]]);
7090 fn_jpeg_finish_decompress (&cinfo
);
7091 fn_jpeg_destroy_decompress (&cinfo
);
7093 fclose ((FILE *) fp
);
7095 /* Maybe fill in the background field while we have ximg handy. */
7096 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
7097 /* Casting avoids a GCC warning. */
7098 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
7100 /* Put the image into the pixmap. */
7101 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
7102 x_destroy_x_image (ximg
);
7107 #else /* HAVE_JPEG */
7116 return image_load_quartz2d (f
, img
, 0);
7118 return image_load_quicktime (f
, img
, kQTFileTypeJPEG
);
7123 #endif /* !HAVE_JPEG */
7127 /***********************************************************************
7129 ***********************************************************************/
7131 #if defined (HAVE_TIFF) || defined (MAC_OS)
7133 static int tiff_image_p
P_ ((Lisp_Object object
));
7134 static int tiff_load
P_ ((struct frame
*f
, struct image
*img
));
7136 /* The symbol `tiff' identifying images of this type. */
7140 /* Indices of image specification fields in tiff_format, below. */
7142 enum tiff_keyword_index
7151 TIFF_HEURISTIC_MASK
,
7157 /* Vector of image_keyword structures describing the format
7158 of valid user-defined image specifications. */
7160 static struct image_keyword tiff_format
[TIFF_LAST
] =
7162 {":type", IMAGE_SYMBOL_VALUE
, 1},
7163 {":data", IMAGE_STRING_VALUE
, 0},
7164 {":file", IMAGE_STRING_VALUE
, 0},
7165 {":ascent", IMAGE_ASCENT_VALUE
, 0},
7166 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
7167 {":relief", IMAGE_INTEGER_VALUE
, 0},
7168 {":conversions", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7169 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7170 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7171 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
7174 /* Structure describing the image type `tiff'. */
7176 static struct image_type tiff_type
=
7185 /* Return non-zero if OBJECT is a valid TIFF image specification. */
7188 tiff_image_p (object
)
7191 struct image_keyword fmt
[TIFF_LAST
];
7192 bcopy (tiff_format
, fmt
, sizeof fmt
);
7194 if (!parse_image_spec (object
, fmt
, TIFF_LAST
, Qtiff
))
7197 /* Must specify either the :data or :file keyword. */
7198 return fmt
[TIFF_FILE
].count
+ fmt
[TIFF_DATA
].count
== 1;
7201 #endif /* HAVE_TIFF || MAC_OS */
7209 /* TIFF library details. */
7210 DEF_IMGLIB_FN (TIFFSetErrorHandler
);
7211 DEF_IMGLIB_FN (TIFFSetWarningHandler
);
7212 DEF_IMGLIB_FN (TIFFOpen
);
7213 DEF_IMGLIB_FN (TIFFClientOpen
);
7214 DEF_IMGLIB_FN (TIFFGetField
);
7215 DEF_IMGLIB_FN (TIFFReadRGBAImage
);
7216 DEF_IMGLIB_FN (TIFFClose
);
7219 init_tiff_functions (Lisp_Object libraries
)
7223 if (!(library
= w32_delayed_load (libraries
, Qtiff
)))
7226 LOAD_IMGLIB_FN (library
, TIFFSetErrorHandler
);
7227 LOAD_IMGLIB_FN (library
, TIFFSetWarningHandler
);
7228 LOAD_IMGLIB_FN (library
, TIFFOpen
);
7229 LOAD_IMGLIB_FN (library
, TIFFClientOpen
);
7230 LOAD_IMGLIB_FN (library
, TIFFGetField
);
7231 LOAD_IMGLIB_FN (library
, TIFFReadRGBAImage
);
7232 LOAD_IMGLIB_FN (library
, TIFFClose
);
7238 #define fn_TIFFSetErrorHandler TIFFSetErrorHandler
7239 #define fn_TIFFSetWarningHandler TIFFSetWarningHandler
7240 #define fn_TIFFOpen TIFFOpen
7241 #define fn_TIFFClientOpen TIFFClientOpen
7242 #define fn_TIFFGetField TIFFGetField
7243 #define fn_TIFFReadRGBAImage TIFFReadRGBAImage
7244 #define fn_TIFFClose TIFFClose
7246 #endif /* HAVE_NTGUI */
7249 /* Reading from a memory buffer for TIFF images Based on the PNG
7250 memory source, but we have to provide a lot of extra functions.
7253 We really only need to implement read and seek, but I am not
7254 convinced that the TIFF library is smart enough not to destroy
7255 itself if we only hand it the function pointers we need to
7260 unsigned char *bytes
;
7267 tiff_read_from_memory (data
, buf
, size
)
7272 tiff_memory_source
*src
= (tiff_memory_source
*) data
;
7274 if (size
> src
->len
- src
->index
)
7276 bcopy (src
->bytes
+ src
->index
, buf
, size
);
7282 tiff_write_from_memory (data
, buf
, size
)
7291 tiff_seek_in_memory (data
, off
, whence
)
7296 tiff_memory_source
*src
= (tiff_memory_source
*) data
;
7301 case SEEK_SET
: /* Go from beginning of source. */
7305 case SEEK_END
: /* Go from end of source. */
7306 idx
= src
->len
+ off
;
7309 case SEEK_CUR
: /* Go from current position. */
7310 idx
= src
->index
+ off
;
7313 default: /* Invalid `whence'. */
7317 if (idx
> src
->len
|| idx
< 0)
7325 tiff_close_memory (data
)
7333 tiff_mmap_memory (data
, pbase
, psize
)
7338 /* It is already _IN_ memory. */
7343 tiff_unmap_memory (data
, base
, size
)
7348 /* We don't need to do this. */
7352 tiff_size_of_memory (data
)
7355 return ((tiff_memory_source
*) data
)->len
;
7360 tiff_error_handler (title
, format
, ap
)
7361 const char *title
, *format
;
7367 len
= sprintf (buf
, "TIFF error: %s ", title
);
7368 vsprintf (buf
+ len
, format
, ap
);
7369 add_to_log (buf
, Qnil
, Qnil
);
7374 tiff_warning_handler (title
, format
, ap
)
7375 const char *title
, *format
;
7381 len
= sprintf (buf
, "TIFF warning: %s ", title
);
7382 vsprintf (buf
+ len
, format
, ap
);
7383 add_to_log (buf
, Qnil
, Qnil
);
7387 /* Load TIFF image IMG for use on frame F. Value is non-zero if
7395 Lisp_Object file
, specified_file
;
7396 Lisp_Object specified_data
;
7398 int width
, height
, x
, y
;
7402 struct gcpro gcpro1
;
7403 tiff_memory_source memsrc
;
7405 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
7406 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
7410 fn_TIFFSetErrorHandler (tiff_error_handler
);
7411 fn_TIFFSetWarningHandler (tiff_warning_handler
);
7413 if (NILP (specified_data
))
7415 /* Read from a file */
7416 file
= x_find_image_file (specified_file
);
7417 if (!STRINGP (file
))
7419 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
7424 /* Try to open the image file. Casting return value avoids a
7425 GCC warning on W32. */
7426 tiff
= (TIFF
*)fn_TIFFOpen (SDATA (file
), "r");
7429 image_error ("Cannot open `%s'", file
, Qnil
);
7436 /* Memory source! */
7437 memsrc
.bytes
= SDATA (specified_data
);
7438 memsrc
.len
= SBYTES (specified_data
);
7441 /* Casting return value avoids a GCC warning on W32. */
7442 tiff
= (TIFF
*)fn_TIFFClientOpen ("memory_source", "r", &memsrc
,
7443 (TIFFReadWriteProc
) tiff_read_from_memory
,
7444 (TIFFReadWriteProc
) tiff_write_from_memory
,
7445 tiff_seek_in_memory
,
7447 tiff_size_of_memory
,
7453 image_error ("Cannot open memory source for `%s'", img
->spec
, Qnil
);
7459 /* Get width and height of the image, and allocate a raster buffer
7460 of width x height 32-bit values. */
7461 fn_TIFFGetField (tiff
, TIFFTAG_IMAGEWIDTH
, &width
);
7462 fn_TIFFGetField (tiff
, TIFFTAG_IMAGELENGTH
, &height
);
7464 if (!check_image_size (f
, width
, height
))
7466 image_error ("Invalid image size", Qnil
, Qnil
);
7471 buf
= (uint32
*) xmalloc (width
* height
* sizeof *buf
);
7473 rc
= fn_TIFFReadRGBAImage (tiff
, width
, height
, buf
, 0);
7474 fn_TIFFClose (tiff
);
7477 image_error ("Error reading TIFF image `%s'", img
->spec
, Qnil
);
7483 /* Create the X image and pixmap. */
7484 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
7491 /* Initialize the color table. */
7492 init_color_table ();
7494 /* Process the pixel raster. Origin is in the lower-left corner. */
7495 for (y
= 0; y
< height
; ++y
)
7497 uint32
*row
= buf
+ y
* width
;
7499 for (x
= 0; x
< width
; ++x
)
7501 uint32 abgr
= row
[x
];
7502 int r
= TIFFGetR (abgr
) << 8;
7503 int g
= TIFFGetG (abgr
) << 8;
7504 int b
= TIFFGetB (abgr
) << 8;
7505 XPutPixel (ximg
, x
, height
- 1 - y
, lookup_rgb_color (f
, r
, g
, b
));
7509 #ifdef COLOR_TABLE_SUPPORT
7510 /* Remember the colors allocated for the image. Free the color table. */
7511 img
->colors
= colors_in_color_table (&img
->ncolors
);
7512 free_color_table ();
7513 #endif /* COLOR_TABLE_SUPPORT */
7516 img
->height
= height
;
7518 /* Maybe fill in the background field while we have ximg handy. */
7519 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
7520 /* Casting avoids a GCC warning on W32. */
7521 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
7523 /* Put the image into the pixmap, then free the X image and its buffer. */
7524 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
7525 x_destroy_x_image (ximg
);
7532 #else /* HAVE_TIFF */
7540 return image_load_quicktime (f
, img
, kQTFileTypeTIFF
);
7544 #endif /* !HAVE_TIFF */
7548 /***********************************************************************
7550 ***********************************************************************/
7552 #if defined (HAVE_GIF) || defined (MAC_OS)
7554 static int gif_image_p
P_ ((Lisp_Object object
));
7555 static int gif_load
P_ ((struct frame
*f
, struct image
*img
));
7556 static void gif_clear_image
P_ ((struct frame
*f
, struct image
*img
));
7558 /* The symbol `gif' identifying images of this type. */
7562 /* Indices of image specification fields in gif_format, below. */
7564 enum gif_keyword_index
7580 /* Vector of image_keyword structures describing the format
7581 of valid user-defined image specifications. */
7583 static struct image_keyword gif_format
[GIF_LAST
] =
7585 {":type", IMAGE_SYMBOL_VALUE
, 1},
7586 {":data", IMAGE_STRING_VALUE
, 0},
7587 {":file", IMAGE_STRING_VALUE
, 0},
7588 {":ascent", IMAGE_ASCENT_VALUE
, 0},
7589 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
7590 {":relief", IMAGE_INTEGER_VALUE
, 0},
7591 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7592 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7593 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7594 {":image", IMAGE_NON_NEGATIVE_INTEGER_VALUE
, 0},
7595 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
7598 /* Structure describing the image type `gif'. */
7600 static struct image_type gif_type
=
7609 /* Free X resources of GIF image IMG which is used on frame F. */
7612 gif_clear_image (f
, img
)
7616 /* IMG->data.ptr_val may contain extension data. */
7617 img
->data
.lisp_val
= Qnil
;
7618 x_clear_image (f
, img
);
7621 /* Return non-zero if OBJECT is a valid GIF image specification. */
7624 gif_image_p (object
)
7627 struct image_keyword fmt
[GIF_LAST
];
7628 bcopy (gif_format
, fmt
, sizeof fmt
);
7630 if (!parse_image_spec (object
, fmt
, GIF_LAST
, Qgif
))
7633 /* Must specify either the :data or :file keyword. */
7634 return fmt
[GIF_FILE
].count
+ fmt
[GIF_DATA
].count
== 1;
7637 #endif /* HAVE_GIF || MAC_OS */
7641 #if defined (HAVE_NTGUI) || defined (MAC_OS)
7642 /* winuser.h might define DrawText to DrawTextA or DrawTextW.
7643 Undefine before redefining to avoid a preprocessor warning. */
7647 /* avoid conflict with QuickdrawText.h */
7648 #define DrawText gif_DrawText
7649 #include <gif_lib.h>
7652 #else /* HAVE_NTGUI || MAC_OS */
7654 #include <gif_lib.h>
7656 #endif /* HAVE_NTGUI || MAC_OS */
7661 /* GIF library details. */
7662 DEF_IMGLIB_FN (DGifCloseFile
);
7663 DEF_IMGLIB_FN (DGifSlurp
);
7664 DEF_IMGLIB_FN (DGifOpen
);
7665 DEF_IMGLIB_FN (DGifOpenFileName
);
7668 init_gif_functions (Lisp_Object libraries
)
7672 if (!(library
= w32_delayed_load (libraries
, Qgif
)))
7675 LOAD_IMGLIB_FN (library
, DGifCloseFile
);
7676 LOAD_IMGLIB_FN (library
, DGifSlurp
);
7677 LOAD_IMGLIB_FN (library
, DGifOpen
);
7678 LOAD_IMGLIB_FN (library
, DGifOpenFileName
);
7684 #define fn_DGifCloseFile DGifCloseFile
7685 #define fn_DGifSlurp DGifSlurp
7686 #define fn_DGifOpen DGifOpen
7687 #define fn_DGifOpenFileName DGifOpenFileName
7689 #endif /* HAVE_NTGUI */
7691 /* Reading a GIF image from memory
7692 Based on the PNG memory stuff to a certain extent. */
7696 unsigned char *bytes
;
7702 /* Make the current memory source available to gif_read_from_memory.
7703 It's done this way because not all versions of libungif support
7704 a UserData field in the GifFileType structure. */
7705 static gif_memory_source
*current_gif_memory_src
;
7708 gif_read_from_memory (file
, buf
, len
)
7713 gif_memory_source
*src
= current_gif_memory_src
;
7715 if (len
> src
->len
- src
->index
)
7718 bcopy (src
->bytes
+ src
->index
, buf
, len
);
7724 /* Load GIF image IMG for use on frame F. Value is non-zero if
7732 Lisp_Object file
, specified_file
;
7733 Lisp_Object specified_data
;
7734 int rc
, width
, height
, x
, y
, i
;
7736 ColorMapObject
*gif_color_map
;
7737 unsigned long pixel_colors
[256];
7739 struct gcpro gcpro1
;
7741 int ino
, image_height
, image_width
;
7742 gif_memory_source memsrc
;
7743 unsigned char *raster
;
7745 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
7746 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
7750 if (NILP (specified_data
))
7752 file
= x_find_image_file (specified_file
);
7753 if (!STRINGP (file
))
7755 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
7760 /* Open the GIF file. Casting return value avoids a GCC warning
7762 gif
= (GifFileType
*)fn_DGifOpenFileName (SDATA (file
));
7765 image_error ("Cannot open `%s'", file
, Qnil
);
7772 /* Read from memory! */
7773 current_gif_memory_src
= &memsrc
;
7774 memsrc
.bytes
= SDATA (specified_data
);
7775 memsrc
.len
= SBYTES (specified_data
);
7778 /* Casting return value avoids a GCC warning on W32. */
7779 gif
= (GifFileType
*)fn_DGifOpen(&memsrc
, gif_read_from_memory
);
7782 image_error ("Cannot open memory source `%s'", img
->spec
, Qnil
);
7788 /* Before reading entire contents, check the declared image size. */
7789 if (!check_image_size (f
, gif
->SWidth
, gif
->SHeight
))
7791 image_error ("Invalid image size", Qnil
, Qnil
);
7792 fn_DGifCloseFile (gif
);
7797 /* Read entire contents. */
7798 rc
= fn_DGifSlurp (gif
);
7799 if (rc
== GIF_ERROR
)
7801 image_error ("Error reading `%s'", img
->spec
, Qnil
);
7802 fn_DGifCloseFile (gif
);
7807 image
= image_spec_value (img
->spec
, QCindex
, NULL
);
7808 ino
= INTEGERP (image
) ? XFASTINT (image
) : 0;
7809 if (ino
>= gif
->ImageCount
)
7811 image_error ("Invalid image number `%s' in image `%s'",
7813 fn_DGifCloseFile (gif
);
7818 img
->corners
[TOP_CORNER
] = gif
->SavedImages
[ino
].ImageDesc
.Top
;
7819 img
->corners
[LEFT_CORNER
] = gif
->SavedImages
[ino
].ImageDesc
.Left
;
7820 image_height
= gif
->SavedImages
[ino
].ImageDesc
.Height
;
7821 img
->corners
[BOT_CORNER
] = img
->corners
[TOP_CORNER
] + image_height
;
7822 image_width
= gif
->SavedImages
[ino
].ImageDesc
.Width
;
7823 img
->corners
[RIGHT_CORNER
] = img
->corners
[LEFT_CORNER
] + image_width
;
7825 width
= img
->width
= max (gif
->SWidth
,
7826 max (gif
->Image
.Left
+ gif
->Image
.Width
,
7827 img
->corners
[RIGHT_CORNER
]));
7828 height
= img
->height
= max (gif
->SHeight
,
7829 max (gif
->Image
.Top
+ gif
->Image
.Height
,
7830 img
->corners
[BOT_CORNER
]));
7832 if (!check_image_size (f
, width
, height
))
7834 image_error ("Invalid image size", Qnil
, Qnil
);
7835 fn_DGifCloseFile (gif
);
7840 /* Create the X image and pixmap. */
7841 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
7843 fn_DGifCloseFile (gif
);
7848 /* Allocate colors. */
7849 gif_color_map
= gif
->SavedImages
[ino
].ImageDesc
.ColorMap
;
7851 gif_color_map
= gif
->SColorMap
;
7852 init_color_table ();
7853 bzero (pixel_colors
, sizeof pixel_colors
);
7855 for (i
= 0; i
< gif_color_map
->ColorCount
; ++i
)
7857 int r
= gif_color_map
->Colors
[i
].Red
<< 8;
7858 int g
= gif_color_map
->Colors
[i
].Green
<< 8;
7859 int b
= gif_color_map
->Colors
[i
].Blue
<< 8;
7860 pixel_colors
[i
] = lookup_rgb_color (f
, r
, g
, b
);
7863 #ifdef COLOR_TABLE_SUPPORT
7864 img
->colors
= colors_in_color_table (&img
->ncolors
);
7865 free_color_table ();
7866 #endif /* COLOR_TABLE_SUPPORT */
7868 /* Clear the part of the screen image that are not covered by
7869 the image from the GIF file. Full animated GIF support
7870 requires more than can be done here (see the gif89 spec,
7871 disposal methods). Let's simply assume that the part
7872 not covered by a sub-image is in the frame's background color. */
7873 for (y
= 0; y
< img
->corners
[TOP_CORNER
]; ++y
)
7874 for (x
= 0; x
< width
; ++x
)
7875 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7877 for (y
= img
->corners
[BOT_CORNER
]; y
< height
; ++y
)
7878 for (x
= 0; x
< width
; ++x
)
7879 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7881 for (y
= img
->corners
[TOP_CORNER
]; y
< img
->corners
[BOT_CORNER
]; ++y
)
7883 for (x
= 0; x
< img
->corners
[LEFT_CORNER
]; ++x
)
7884 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7885 for (x
= img
->corners
[RIGHT_CORNER
]; x
< width
; ++x
)
7886 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7889 /* Read the GIF image into the X image. We use a local variable
7890 `raster' here because RasterBits below is a char *, and invites
7891 problems with bytes >= 0x80. */
7892 raster
= (unsigned char *) gif
->SavedImages
[ino
].RasterBits
;
7894 if (gif
->SavedImages
[ino
].ImageDesc
.Interlace
)
7896 static int interlace_start
[] = {0, 4, 2, 1};
7897 static int interlace_increment
[] = {8, 8, 4, 2};
7899 int row
= interlace_start
[0];
7903 for (y
= 0; y
< image_height
; y
++)
7905 if (row
>= image_height
)
7907 row
= interlace_start
[++pass
];
7908 while (row
>= image_height
)
7909 row
= interlace_start
[++pass
];
7912 for (x
= 0; x
< image_width
; x
++)
7914 int i
= raster
[(y
* image_width
) + x
];
7915 XPutPixel (ximg
, x
+ img
->corners
[LEFT_CORNER
],
7916 row
+ img
->corners
[TOP_CORNER
], pixel_colors
[i
]);
7919 row
+= interlace_increment
[pass
];
7924 for (y
= 0; y
< image_height
; ++y
)
7925 for (x
= 0; x
< image_width
; ++x
)
7927 int i
= raster
[y
* image_width
+ x
];
7928 XPutPixel (ximg
, x
+ img
->corners
[LEFT_CORNER
],
7929 y
+ img
->corners
[TOP_CORNER
], pixel_colors
[i
]);
7933 /* Save GIF image extension data for `image-extension-data'.
7934 Format is (count IMAGES FUNCTION "BYTES" ...). */
7935 img
->data
.lisp_val
= Qnil
;
7936 if (gif
->SavedImages
[ino
].ExtensionBlockCount
> 0)
7938 ExtensionBlock
*ext
= gif
->SavedImages
[ino
].ExtensionBlocks
;
7939 for (i
= 0; i
< gif
->SavedImages
[ino
].ExtensionBlockCount
; i
++, ext
++)
7940 /* Append (... FUNCTION "BYTES") */
7941 img
->data
.lisp_val
= Fcons (make_unibyte_string (ext
->Bytes
, ext
->ByteCount
),
7942 Fcons (make_number (ext
->Function
),
7943 img
->data
.lisp_val
));
7944 img
->data
.lisp_val
= Fnreverse (img
->data
.lisp_val
);
7946 if (gif
->ImageCount
> 1)
7947 img
->data
.lisp_val
= Fcons (Qcount
,
7948 Fcons (make_number (gif
->ImageCount
),
7949 img
->data
.lisp_val
));
7951 fn_DGifCloseFile (gif
);
7953 /* Maybe fill in the background field while we have ximg handy. */
7954 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
7955 /* Casting avoids a GCC warning. */
7956 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
7958 /* Put the image into the pixmap, then free the X image and its buffer. */
7959 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
7960 x_destroy_x_image (ximg
);
7966 #else /* !HAVE_GIF */
7974 Lisp_Object specified_file
, file
;
7975 Lisp_Object specified_data
;
7977 Boolean graphic_p
, movie_p
, prefer_graphic_p
;
7985 Lisp_Object specified_bg
;
7990 TimeScale time_scale
;
7991 TimeValue time
, duration
;
7996 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
7997 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
7999 /* Animated gifs use QuickTime Movie Toolbox. So initialize it here. */
8002 if (NILP (specified_data
))
8004 /* Read from a file */
8008 err
= find_image_fsspec (specified_file
, &file
, &fss
);
8012 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
8017 err
= CanQuickTimeOpenFile (&fss
, kQTFileTypeGIF
, 0,
8018 &graphic_p
, &movie_p
, &prefer_graphic_p
, 0);
8022 if (!graphic_p
&& !movie_p
)
8024 if (prefer_graphic_p
)
8025 return image_load_qt_1 (f
, img
, kQTFileTypeGIF
, &fss
, NULL
);
8026 err
= OpenMovieFile (&fss
, &refnum
, fsRdPerm
);
8029 err
= NewMovieFromFile (&movie
, refnum
, NULL
, NULL
, 0, NULL
);
8030 CloseMovieFile (refnum
);
8033 image_error ("Error reading `%s'", file
, Qnil
);
8039 /* Memory source! */
8041 long file_type_atom
[3];
8043 err
= PtrToHand (SDATA (specified_data
), &dh
, SBYTES (specified_data
));
8046 image_error ("Cannot allocate data handle for `%s'",
8051 file_type_atom
[0] = EndianU32_NtoB (sizeof (long) * 3);
8052 file_type_atom
[1] = EndianU32_NtoB (kDataRefExtensionMacOSFileType
);
8053 file_type_atom
[2] = EndianU32_NtoB (kQTFileTypeGIF
);
8054 err
= PtrToHand (&dh
, &dref
, sizeof (Handle
));
8057 err
= PtrAndHand ("\p", dref
, 1);
8059 err
= PtrAndHand (file_type_atom
, dref
, sizeof (long) * 3);
8062 image_error ("Cannot allocate handle data ref for `%s'", img
->spec
, Qnil
);
8065 err
= CanQuickTimeOpenDataRef (dref
, HandleDataHandlerSubType
, &graphic_p
,
8066 &movie_p
, &prefer_graphic_p
, 0);
8070 if (!graphic_p
&& !movie_p
)
8072 if (prefer_graphic_p
)
8076 DisposeHandle (dref
);
8077 success_p
= image_load_qt_1 (f
, img
, kQTFileTypeGIF
, NULL
, dh
);
8081 err
= NewMovieFromDataRef (&movie
, 0, NULL
, dref
,
8082 HandleDataHandlerSubType
);
8083 DisposeHandle (dref
);
8088 image
= image_spec_value (img
->spec
, QCindex
, NULL
);
8089 ino
= INTEGERP (image
) ? XFASTINT (image
) : 0;
8090 track
= GetMovieIndTrack (movie
, 1);
8091 media
= GetTrackMedia (track
);
8092 nsamples
= GetMediaSampleCount (media
);
8093 if (ino
>= nsamples
)
8095 image_error ("Invalid image number `%s' in image `%s'",
8099 time_scale
= GetMediaTimeScale (media
);
8101 specified_bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
8102 if (!STRINGP (specified_bg
) ||
8103 !mac_defined_color (f
, SDATA (specified_bg
), &color
, 0))
8105 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
8106 color
.red
= RED16_FROM_ULONG (color
.pixel
);
8107 color
.green
= GREEN16_FROM_ULONG (color
.pixel
);
8108 color
.blue
= BLUE16_FROM_ULONG (color
.pixel
);
8110 GetMovieBox (movie
, &rect
);
8111 width
= img
->width
= rect
.right
- rect
.left
;
8112 height
= img
->height
= rect
.bottom
- rect
.top
;
8113 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
8116 GetGWorld (&old_port
, &old_gdh
);
8117 SetGWorld (ximg
, NULL
);
8118 bg_color
.red
= color
.red
;
8119 bg_color
.green
= color
.green
;
8120 bg_color
.blue
= color
.blue
;
8121 RGBBackColor (&bg_color
);
8122 SetGWorld (old_port
, old_gdh
);
8123 SetMovieActive (movie
, 1);
8124 SetMovieGWorld (movie
, ximg
, NULL
);
8125 SampleNumToMediaTime (media
, ino
+ 1, &time
, &duration
);
8126 SetMovieTimeValue (movie
, time
);
8127 MoviesTask (movie
, 0L);
8128 DisposeTrackMedia (media
);
8129 DisposeMovieTrack (track
);
8130 DisposeMovie (movie
);
8134 /* Save GIF image extension data for `image-extension-data'.
8135 Format is (count IMAGES 0xf9 GRAPHIC_CONTROL_EXTENSION_BLOCK). */
8137 Lisp_Object gce
= make_uninit_string (4);
8138 int centisec
= ((float)duration
/ time_scale
) * 100.0f
+ 0.5f
;
8140 /* Fill the delay time field. */
8141 SSET (gce
, 1, centisec
& 0xff);
8142 SSET (gce
, 2, (centisec
>> 8) & 0xff);
8143 /* We don't know about other fields. */
8147 img
->data
.lisp_val
= list4 (Qcount
, make_number (nsamples
),
8148 make_number (0xf9), gce
);
8151 /* Maybe fill in the background field while we have ximg handy. */
8152 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
8153 IMAGE_BACKGROUND (img
, f
, ximg
);
8155 /* Put the image into the pixmap. */
8156 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
8157 x_destroy_x_image (ximg
);
8161 image_error ("Cannot open `%s'", file
, Qnil
);
8164 DisposeTrackMedia (media
);
8166 DisposeMovieTrack (track
);
8168 DisposeMovie (movie
);
8175 #endif /* HAVE_GIF */
8179 /***********************************************************************
8181 ***********************************************************************/
8183 #ifdef HAVE_X_WINDOWS
8184 #define HAVE_GHOSTSCRIPT 1
8185 #endif /* HAVE_X_WINDOWS */
8187 /* The symbol `postscript' identifying images of this type. */
8189 Lisp_Object Qpostscript
;
8191 #ifdef HAVE_GHOSTSCRIPT
8193 static int gs_image_p
P_ ((Lisp_Object object
));
8194 static int gs_load
P_ ((struct frame
*f
, struct image
*img
));
8195 static void gs_clear_image
P_ ((struct frame
*f
, struct image
*img
));
8197 /* Keyword symbols. */
8199 Lisp_Object QCloader
, QCbounding_box
, QCpt_width
, QCpt_height
;
8201 /* Indices of image specification fields in gs_format, below. */
8203 enum gs_keyword_index
8221 /* Vector of image_keyword structures describing the format
8222 of valid user-defined image specifications. */
8224 static struct image_keyword gs_format
[GS_LAST
] =
8226 {":type", IMAGE_SYMBOL_VALUE
, 1},
8227 {":pt-width", IMAGE_POSITIVE_INTEGER_VALUE
, 1},
8228 {":pt-height", IMAGE_POSITIVE_INTEGER_VALUE
, 1},
8229 {":file", IMAGE_STRING_VALUE
, 1},
8230 {":loader", IMAGE_FUNCTION_VALUE
, 0},
8231 {":bounding-box", IMAGE_DONT_CHECK_VALUE_TYPE
, 1},
8232 {":ascent", IMAGE_ASCENT_VALUE
, 0},
8233 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
8234 {":relief", IMAGE_INTEGER_VALUE
, 0},
8235 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8236 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8237 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8238 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
8241 /* Structure describing the image type `ghostscript'. */
8243 static struct image_type gs_type
=
8253 /* Free X resources of Ghostscript image IMG which is used on frame F. */
8256 gs_clear_image (f
, img
)
8260 /* IMG->data.ptr_val may contain a recorded colormap. */
8261 xfree (img
->data
.ptr_val
);
8262 x_clear_image (f
, img
);
8266 /* Return non-zero if OBJECT is a valid Ghostscript image
8273 struct image_keyword fmt
[GS_LAST
];
8277 bcopy (gs_format
, fmt
, sizeof fmt
);
8279 if (!parse_image_spec (object
, fmt
, GS_LAST
, Qpostscript
))
8282 /* Bounding box must be a list or vector containing 4 integers. */
8283 tem
= fmt
[GS_BOUNDING_BOX
].value
;
8286 for (i
= 0; i
< 4; ++i
, tem
= XCDR (tem
))
8287 if (!CONSP (tem
) || !INTEGERP (XCAR (tem
)))
8292 else if (VECTORP (tem
))
8294 if (XVECTOR (tem
)->size
!= 4)
8296 for (i
= 0; i
< 4; ++i
)
8297 if (!INTEGERP (XVECTOR (tem
)->contents
[i
]))
8307 /* Load Ghostscript image IMG for use on frame F. Value is non-zero
8316 Lisp_Object window_and_pixmap_id
= Qnil
, loader
, pt_height
, pt_width
;
8317 struct gcpro gcpro1
, gcpro2
;
8319 double in_width
, in_height
;
8320 Lisp_Object pixel_colors
= Qnil
;
8322 /* Compute pixel size of pixmap needed from the given size in the
8323 image specification. Sizes in the specification are in pt. 1 pt
8324 = 1/72 in, xdpi and ydpi are stored in the frame's X display
8326 pt_width
= image_spec_value (img
->spec
, QCpt_width
, NULL
);
8327 in_width
= XFASTINT (pt_width
) / 72.0;
8328 img
->width
= in_width
* FRAME_X_DISPLAY_INFO (f
)->resx
;
8329 pt_height
= image_spec_value (img
->spec
, QCpt_height
, NULL
);
8330 in_height
= XFASTINT (pt_height
) / 72.0;
8331 img
->height
= in_height
* FRAME_X_DISPLAY_INFO (f
)->resy
;
8333 if (!check_image_size (f
, img
->width
, img
->height
))
8335 image_error ("Invalid image size", Qnil
, Qnil
);
8339 /* Create the pixmap. */
8340 xassert (img
->pixmap
== NO_PIXMAP
);
8342 /* Only W32 version did BLOCK_INPUT here. ++kfs */
8344 img
->pixmap
= XCreatePixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
8345 img
->width
, img
->height
,
8346 DefaultDepthOfScreen (FRAME_X_SCREEN (f
)));
8351 image_error ("Unable to create pixmap for `%s'", img
->spec
, Qnil
);
8355 /* Call the loader to fill the pixmap. It returns a process object
8356 if successful. We do not record_unwind_protect here because
8357 other places in redisplay like calling window scroll functions
8358 don't either. Let the Lisp loader use `unwind-protect' instead. */
8359 GCPRO2 (window_and_pixmap_id
, pixel_colors
);
8361 sprintf (buffer
, "%lu %lu",
8362 (unsigned long) FRAME_X_WINDOW (f
),
8363 (unsigned long) img
->pixmap
);
8364 window_and_pixmap_id
= build_string (buffer
);
8366 sprintf (buffer
, "%lu %lu",
8367 FRAME_FOREGROUND_PIXEL (f
),
8368 FRAME_BACKGROUND_PIXEL (f
));
8369 pixel_colors
= build_string (buffer
);
8371 XSETFRAME (frame
, f
);
8372 loader
= image_spec_value (img
->spec
, QCloader
, NULL
);
8374 loader
= intern ("gs-load-image");
8376 img
->data
.lisp_val
= call6 (loader
, frame
, img
->spec
,
8377 make_number (img
->width
),
8378 make_number (img
->height
),
8379 window_and_pixmap_id
,
8382 return PROCESSP (img
->data
.lisp_val
);
8386 /* Kill the Ghostscript process that was started to fill PIXMAP on
8387 frame F. Called from XTread_socket when receiving an event
8388 telling Emacs that Ghostscript has finished drawing. */
8391 x_kill_gs_process (pixmap
, f
)
8395 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
8399 /* Find the image containing PIXMAP. */
8400 for (i
= 0; i
< c
->used
; ++i
)
8401 if (c
->images
[i
]->pixmap
== pixmap
)
8404 /* Should someone in between have cleared the image cache, for
8405 instance, give up. */
8409 /* Kill the GS process. We should have found PIXMAP in the image
8410 cache and its image should contain a process object. */
8412 xassert (PROCESSP (img
->data
.lisp_val
));
8413 Fkill_process (img
->data
.lisp_val
, Qnil
);
8414 img
->data
.lisp_val
= Qnil
;
8416 #if defined (HAVE_X_WINDOWS)
8418 /* On displays with a mutable colormap, figure out the colors
8419 allocated for the image by looking at the pixels of an XImage for
8421 class = FRAME_X_VISUAL (f
)->class;
8422 if (class != StaticColor
&& class != StaticGray
&& class != TrueColor
)
8428 /* Try to get an XImage for img->pixmep. */
8429 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
8430 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
8435 /* Initialize the color table. */
8436 init_color_table ();
8438 /* For each pixel of the image, look its color up in the
8439 color table. After having done so, the color table will
8440 contain an entry for each color used by the image. */
8441 for (y
= 0; y
< img
->height
; ++y
)
8442 for (x
= 0; x
< img
->width
; ++x
)
8444 unsigned long pixel
= XGetPixel (ximg
, x
, y
);
8445 lookup_pixel_color (f
, pixel
);
8448 /* Record colors in the image. Free color table and XImage. */
8449 #ifdef COLOR_TABLE_SUPPORT
8450 img
->colors
= colors_in_color_table (&img
->ncolors
);
8451 free_color_table ();
8453 XDestroyImage (ximg
);
8455 #if 0 /* This doesn't seem to be the case. If we free the colors
8456 here, we get a BadAccess later in x_clear_image when
8457 freeing the colors. */
8458 /* We have allocated colors once, but Ghostscript has also
8459 allocated colors on behalf of us. So, to get the
8460 reference counts right, free them once. */
8462 x_free_colors (f
, img
->colors
, img
->ncolors
);
8466 image_error ("Cannot get X image of `%s'; colors will not be freed",
8471 #endif /* HAVE_X_WINDOWS */
8473 /* Now that we have the pixmap, compute mask and transform the
8474 image if requested. */
8476 postprocess_image (f
, img
);
8480 #endif /* HAVE_GHOSTSCRIPT */
8483 /***********************************************************************
8485 ***********************************************************************/
8489 DEFUN ("imagep", Fimagep
, Simagep
, 1, 1, 0,
8490 doc
: /* Value is non-nil if SPEC is a valid image specification. */)
8494 return valid_image_p (spec
) ? Qt
: Qnil
;
8498 DEFUN ("lookup-image", Flookup_image
, Slookup_image
, 1, 1, 0, "")
8504 if (valid_image_p (spec
))
8505 id
= lookup_image (SELECTED_FRAME (), spec
);
8508 return make_number (id
);
8511 #endif /* GLYPH_DEBUG != 0 */
8514 /***********************************************************************
8516 ***********************************************************************/
8519 /* Image types that rely on external libraries are loaded dynamically
8520 if the library is available. */
8521 #define CHECK_LIB_AVAILABLE(image_type, init_lib_fn, libraries) \
8522 define_image_type (image_type, init_lib_fn (libraries))
8524 #define CHECK_LIB_AVAILABLE(image_type, init_lib_fn, libraries) \
8525 define_image_type (image_type, 1)
8526 #endif /* HAVE_NTGUI */
8528 DEFUN ("init-image-library", Finit_image_library
, Sinit_image_library
, 2, 2, 0,
8529 doc
: /* Initialize image library implementing image type TYPE.
8530 Return non-nil if TYPE is a supported image type.
8532 Image types pbm and xbm are prebuilt; other types are loaded here.
8533 Libraries to load are specified in alist LIBRARIES (usually, the value
8534 of `image-library-alist', which see). */)
8536 Lisp_Object type
, libraries
;
8540 /* Don't try to reload the library. */
8541 tested
= Fassq (type
, Vimage_type_cache
);
8543 return XCDR (tested
);
8545 #if defined (HAVE_XPM) || defined (MAC_OS)
8546 if (EQ (type
, Qxpm
))
8547 return CHECK_LIB_AVAILABLE (&xpm_type
, init_xpm_functions
, libraries
);
8550 #if defined (HAVE_JPEG) || defined (MAC_OS)
8551 if (EQ (type
, Qjpeg
))
8552 return CHECK_LIB_AVAILABLE (&jpeg_type
, init_jpeg_functions
, libraries
);
8555 #if defined (HAVE_TIFF) || defined (MAC_OS)
8556 if (EQ (type
, Qtiff
))
8557 return CHECK_LIB_AVAILABLE (&tiff_type
, init_tiff_functions
, libraries
);
8560 #if defined (HAVE_GIF) || defined (MAC_OS)
8561 if (EQ (type
, Qgif
))
8562 return CHECK_LIB_AVAILABLE (&gif_type
, init_gif_functions
, libraries
);
8565 #if defined (HAVE_PNG) || defined (MAC_OS)
8566 if (EQ (type
, Qpng
))
8567 return CHECK_LIB_AVAILABLE (&png_type
, init_png_functions
, libraries
);
8570 #ifdef HAVE_GHOSTSCRIPT
8571 if (EQ (type
, Qpostscript
))
8572 return CHECK_LIB_AVAILABLE (&gs_type
, init_gs_functions
, libraries
);
8575 /* If the type is not recognized, avoid testing it ever again. */
8576 CACHE_IMAGE_TYPE (type
, Qnil
);
8583 extern Lisp_Object Qrisky_local_variable
; /* Syms_of_xdisp has already run. */
8585 /* Initialize this only once, since that's what we do with Vimage_types
8586 and they are supposed to be in sync. Initializing here gives correct
8587 operation on GNU/Linux of calling dump-emacs after loading some images. */
8590 /* Must be defined now becase we're going to update it below, while
8591 defining the supported image types. */
8592 DEFVAR_LISP ("image-types", &Vimage_types
,
8593 doc
: /* List of potentially supported image types.
8594 Each element of the list is a symbol for a image type, like 'jpeg or 'png.
8595 To check whether it is really supported, use `image-type-available-p'. */);
8596 Vimage_types
= Qnil
;
8598 DEFVAR_LISP ("image-library-alist", &Vimage_library_alist
,
8599 doc
: /* Alist of image types vs external libraries needed to display them.
8601 Each element is a list (IMAGE-TYPE LIBRARY...), where the car is a symbol
8602 representing a supported image type, and the rest are strings giving
8603 alternate filenames for the corresponding external libraries.
8605 Emacs tries to load the libraries in the order they appear on the
8606 list; if none is loaded, the running session of Emacs won't
8607 support the image type. Types 'pbm and 'xbm don't need to be
8608 listed; they're always supported. */);
8609 Vimage_library_alist
= Qnil
;
8610 Fput (intern ("image-library-alist"), Qrisky_local_variable
, Qt
);
8612 DEFVAR_LISP ("max-image-size", &Vmax_image_size
,
8613 doc
: /* Maximum size of images.
8614 Emacs will not load an image into memory if its pixel width or
8615 pixel height exceeds this limit.
8617 If the value is an integer, it directly specifies the maximum
8618 image height and width, measured in pixels. If it is a floating
8619 point number, it specifies the maximum image height and width
8620 as a ratio to the frame height and width. If the value is
8621 non-numeric, there is no explicit limit on the size of images. */);
8622 Vmax_image_size
= make_float (MAX_IMAGE_SIZE
);
8624 Vimage_type_cache
= Qnil
;
8625 staticpro (&Vimage_type_cache
);
8627 Qpbm
= intern ("pbm");
8629 ADD_IMAGE_TYPE(Qpbm
);
8631 Qxbm
= intern ("xbm");
8633 ADD_IMAGE_TYPE(Qxbm
);
8635 define_image_type (&xbm_type
, 1);
8636 define_image_type (&pbm_type
, 1);
8638 QCascent
= intern (":ascent");
8639 staticpro (&QCascent
);
8640 QCmargin
= intern (":margin");
8641 staticpro (&QCmargin
);
8642 QCrelief
= intern (":relief");
8643 staticpro (&QCrelief
);
8644 QCconversion
= intern (":conversion");
8645 staticpro (&QCconversion
);
8646 QCcolor_symbols
= intern (":color-symbols");
8647 staticpro (&QCcolor_symbols
);
8648 QCheuristic_mask
= intern (":heuristic-mask");
8649 staticpro (&QCheuristic_mask
);
8650 QCindex
= intern (":index");
8651 staticpro (&QCindex
);
8652 QCmatrix
= intern (":matrix");
8653 staticpro (&QCmatrix
);
8654 QCcolor_adjustment
= intern (":color-adjustment");
8655 staticpro (&QCcolor_adjustment
);
8656 QCmask
= intern (":mask");
8657 staticpro (&QCmask
);
8659 Qlaplace
= intern ("laplace");
8660 staticpro (&Qlaplace
);
8661 Qemboss
= intern ("emboss");
8662 staticpro (&Qemboss
);
8663 Qedge_detection
= intern ("edge-detection");
8664 staticpro (&Qedge_detection
);
8665 Qheuristic
= intern ("heuristic");
8666 staticpro (&Qheuristic
);
8668 Qpostscript
= intern ("postscript");
8669 staticpro (&Qpostscript
);
8670 #ifdef HAVE_GHOSTSCRIPT
8671 ADD_IMAGE_TYPE(Qpostscript
);
8672 QCloader
= intern (":loader");
8673 staticpro (&QCloader
);
8674 QCbounding_box
= intern (":bounding-box");
8675 staticpro (&QCbounding_box
);
8676 QCpt_width
= intern (":pt-width");
8677 staticpro (&QCpt_width
);
8678 QCpt_height
= intern (":pt-height");
8679 staticpro (&QCpt_height
);
8680 #endif /* HAVE_GHOSTSCRIPT */
8682 #if defined (HAVE_XPM) || defined (MAC_OS)
8683 Qxpm
= intern ("xpm");
8685 ADD_IMAGE_TYPE(Qxpm
);
8688 #if defined (HAVE_JPEG) || defined (MAC_OS)
8689 Qjpeg
= intern ("jpeg");
8691 ADD_IMAGE_TYPE(Qjpeg
);
8694 #if defined (HAVE_TIFF) || defined (MAC_OS)
8695 Qtiff
= intern ("tiff");
8697 ADD_IMAGE_TYPE(Qtiff
);
8700 #if defined (HAVE_GIF) || defined (MAC_OS)
8701 Qgif
= intern ("gif");
8703 ADD_IMAGE_TYPE(Qgif
);
8706 #if defined (HAVE_PNG) || defined (MAC_OS)
8707 Qpng
= intern ("png");
8709 ADD_IMAGE_TYPE(Qpng
);
8712 defsubr (&Sinit_image_library
);
8713 defsubr (&Sclear_image_cache
);
8714 defsubr (&Simage_refresh
);
8715 defsubr (&Simage_size
);
8716 defsubr (&Simage_mask_p
);
8717 defsubr (&Simage_extension_data
);
8721 defsubr (&Slookup_image
);
8724 DEFVAR_BOOL ("cross-disabled-images", &cross_disabled_images
,
8725 doc
: /* Non-nil means always draw a cross over disabled images.
8726 Disabled images are those having an `:conversion disabled' property.
8727 A cross is always drawn on black & white displays. */);
8728 cross_disabled_images
= 0;
8730 DEFVAR_LISP ("x-bitmap-file-path", &Vx_bitmap_file_path
,
8731 doc
: /* List of directories to search for window system bitmap files. */);
8732 Vx_bitmap_file_path
= decode_env_path ((char *) 0, PATH_BITMAPS
);
8734 DEFVAR_LISP ("image-cache-eviction-delay", &Vimage_cache_eviction_delay
,
8735 doc
: /* Time after which cached images are removed from the cache.
8736 When an image has not been displayed this many seconds, remove it
8737 from the image cache. Value must be an integer or nil with nil
8738 meaning don't clear the cache. */);
8739 Vimage_cache_eviction_delay
= make_number (30 * 60);
8745 #if defined (MAC_OSX) && TARGET_API_MAC_CARBON
8746 init_image_func_pointer ();
8750 /* arch-tag: 123c2a5e-14a8-4c53-ab95-af47d7db49b9
8751 (do not change this comment) */