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
;
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
));
1890 c
= FRAME_X_IMAGE_CACHE (f
);
1894 /* Look up SPEC in the hash table of the image cache. */
1895 hash
= sxhash (spec
, 0);
1896 i
= hash
% IMAGE_CACHE_BUCKETS_SIZE
;
1898 for (img
= c
->buckets
[i
]; img
; img
= img
->next
)
1899 if (img
->hash
== hash
&& !NILP (Fequal (img
->spec
, spec
)))
1902 if (img
&& img
->load_failed_p
)
1904 free_image (f
, img
);
1908 /* If not found, create a new image and cache it. */
1911 extern Lisp_Object Qpostscript
;
1914 img
= make_image (spec
, hash
);
1915 cache_image (f
, img
);
1916 img
->load_failed_p
= img
->type
->load (f
, img
) == 0;
1918 /* If we can't load the image, and we don't have a width and
1919 height, use some arbitrary width and height so that we can
1920 draw a rectangle for it. */
1921 if (img
->load_failed_p
)
1925 value
= image_spec_value (spec
, QCwidth
, NULL
);
1926 img
->width
= (INTEGERP (value
)
1927 ? XFASTINT (value
) : DEFAULT_IMAGE_WIDTH
);
1928 value
= image_spec_value (spec
, QCheight
, NULL
);
1929 img
->height
= (INTEGERP (value
)
1930 ? XFASTINT (value
) : DEFAULT_IMAGE_HEIGHT
);
1934 /* Handle image type independent image attributes
1935 `:ascent ASCENT', `:margin MARGIN', `:relief RELIEF',
1936 `:background COLOR'. */
1937 Lisp_Object ascent
, margin
, relief
, bg
;
1939 ascent
= image_spec_value (spec
, QCascent
, NULL
);
1940 if (INTEGERP (ascent
))
1941 img
->ascent
= XFASTINT (ascent
);
1942 else if (EQ (ascent
, Qcenter
))
1943 img
->ascent
= CENTERED_IMAGE_ASCENT
;
1945 margin
= image_spec_value (spec
, QCmargin
, NULL
);
1946 if (INTEGERP (margin
) && XINT (margin
) >= 0)
1947 img
->vmargin
= img
->hmargin
= XFASTINT (margin
);
1948 else if (CONSP (margin
) && INTEGERP (XCAR (margin
))
1949 && INTEGERP (XCDR (margin
)))
1951 if (XINT (XCAR (margin
)) > 0)
1952 img
->hmargin
= XFASTINT (XCAR (margin
));
1953 if (XINT (XCDR (margin
)) > 0)
1954 img
->vmargin
= XFASTINT (XCDR (margin
));
1957 relief
= image_spec_value (spec
, QCrelief
, NULL
);
1958 if (INTEGERP (relief
))
1960 img
->relief
= XINT (relief
);
1961 img
->hmargin
+= abs (img
->relief
);
1962 img
->vmargin
+= abs (img
->relief
);
1965 if (! img
->background_valid
)
1967 bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
1971 = x_alloc_image_color (f
, img
, bg
,
1972 FRAME_BACKGROUND_PIXEL (f
));
1973 img
->background_valid
= 1;
1977 /* Do image transformations and compute masks, unless we
1978 don't have the image yet. */
1979 if (!EQ (*img
->type
->type
, Qpostscript
))
1980 postprocess_image (f
, img
);
1986 /* We're using IMG, so set its timestamp to `now'. */
1987 EMACS_GET_TIME (now
);
1988 img
->timestamp
= EMACS_SECS (now
);
1992 /* Value is the image id. */
1997 /* Cache image IMG in the image cache of frame F. */
2000 cache_image (f
, img
)
2004 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
2007 /* Find a free slot in c->images. */
2008 for (i
= 0; i
< c
->used
; ++i
)
2009 if (c
->images
[i
] == NULL
)
2012 /* If no free slot found, maybe enlarge c->images. */
2013 if (i
== c
->used
&& c
->used
== c
->size
)
2016 c
->images
= (struct image
**) xrealloc (c
->images
,
2017 c
->size
* sizeof *c
->images
);
2020 /* Add IMG to c->images, and assign IMG an id. */
2026 /* Add IMG to the cache's hash table. */
2027 i
= img
->hash
% IMAGE_CACHE_BUCKETS_SIZE
;
2028 img
->next
= c
->buckets
[i
];
2030 img
->next
->prev
= img
;
2032 c
->buckets
[i
] = img
;
2036 /* Call FN on every image in the image cache of frame F. Used to mark
2037 Lisp Objects in the image cache. */
2040 forall_images_in_image_cache (f
, fn
)
2042 void (*fn
) P_ ((struct image
*img
));
2044 if (FRAME_LIVE_P (f
) && FRAME_WINDOW_P (f
))
2046 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
2050 for (i
= 0; i
< c
->used
; ++i
)
2059 /***********************************************************************
2060 X / MAC / W32 support code
2061 ***********************************************************************/
2065 /* Macro for defining functions that will be loaded from image DLLs. */
2066 #define DEF_IMGLIB_FN(func) int (FAR CDECL *fn_##func)()
2068 /* Macro for loading those image functions from the library. */
2069 #define LOAD_IMGLIB_FN(lib,func) { \
2070 fn_##func = (void *) GetProcAddress (lib, #func); \
2071 if (!fn_##func) return 0; \
2074 /* Load a DLL implementing an image type.
2075 The `image-library-alist' variable associates a symbol,
2076 identifying an image type, to a list of possible filenames.
2077 The function returns NULL if no library could be loaded for
2078 the given image type, or if the library was previously loaded;
2079 else the handle of the DLL. */
2081 w32_delayed_load (Lisp_Object libraries
, Lisp_Object type
)
2083 HMODULE library
= NULL
;
2085 if (CONSP (libraries
) && NILP (Fassq (type
, Vimage_type_cache
)))
2087 Lisp_Object dlls
= Fassq (type
, libraries
);
2090 for (dlls
= XCDR (dlls
); CONSP (dlls
); dlls
= XCDR (dlls
))
2092 CHECK_STRING_CAR (dlls
);
2093 if (library
= LoadLibrary (SDATA (XCAR (dlls
))))
2101 #endif /* HAVE_NTGUI */
2103 static int x_create_x_image_and_pixmap
P_ ((struct frame
*, int, int, int,
2104 XImagePtr
*, Pixmap
*));
2105 static void x_destroy_x_image
P_ ((XImagePtr
));
2106 static void x_put_x_image
P_ ((struct frame
*, XImagePtr
, Pixmap
, int, int));
2109 /* Create an XImage and a pixmap of size WIDTH x HEIGHT for use on
2110 frame F. Set *XIMG and *PIXMAP to the XImage and Pixmap created.
2111 Set (*XIMG)->data to a raster of WIDTH x HEIGHT pixels allocated
2112 via xmalloc. Print error messages via image_error if an error
2113 occurs. Value is non-zero if successful.
2115 On W32, a DEPTH of zero signifies a 24 bit image, otherwise DEPTH
2116 should indicate the bit depth of the image. */
2119 x_create_x_image_and_pixmap (f
, width
, height
, depth
, ximg
, pixmap
)
2121 int width
, height
, depth
;
2125 #ifdef HAVE_X_WINDOWS
2126 Display
*display
= FRAME_X_DISPLAY (f
);
2127 Window window
= FRAME_X_WINDOW (f
);
2128 Screen
*screen
= FRAME_X_SCREEN (f
);
2130 xassert (interrupt_input_blocked
);
2133 depth
= DefaultDepthOfScreen (screen
);
2134 *ximg
= XCreateImage (display
, DefaultVisualOfScreen (screen
),
2135 depth
, ZPixmap
, 0, NULL
, width
, height
,
2136 depth
> 16 ? 32 : depth
> 8 ? 16 : 8, 0);
2139 image_error ("Unable to allocate X image", Qnil
, Qnil
);
2143 /* Allocate image raster. */
2144 (*ximg
)->data
= (char *) xmalloc ((*ximg
)->bytes_per_line
* height
);
2146 /* Allocate a pixmap of the same size. */
2147 *pixmap
= XCreatePixmap (display
, window
, width
, height
, depth
);
2148 if (*pixmap
== NO_PIXMAP
)
2150 x_destroy_x_image (*ximg
);
2152 image_error ("Unable to create X pixmap", Qnil
, Qnil
);
2157 #endif /* HAVE_X_WINDOWS */
2161 BITMAPINFOHEADER
*header
;
2163 int scanline_width_bits
;
2165 int palette_colors
= 0;
2170 if (depth
!= 1 && depth
!= 4 && depth
!= 8
2171 && depth
!= 16 && depth
!= 24 && depth
!= 32)
2173 image_error ("Invalid image bit depth specified", Qnil
, Qnil
);
2177 scanline_width_bits
= width
* depth
;
2178 remainder
= scanline_width_bits
% 32;
2181 scanline_width_bits
+= 32 - remainder
;
2183 /* Bitmaps with a depth less than 16 need a palette. */
2184 /* BITMAPINFO structure already contains the first RGBQUAD. */
2186 palette_colors
= 1 << depth
- 1;
2188 *ximg
= xmalloc (sizeof (XImage
) + palette_colors
* sizeof (RGBQUAD
));
2191 image_error ("Unable to allocate memory for XImage", Qnil
, Qnil
);
2195 header
= &((*ximg
)->info
.bmiHeader
);
2196 bzero (&((*ximg
)->info
), sizeof (BITMAPINFO
));
2197 header
->biSize
= sizeof (*header
);
2198 header
->biWidth
= width
;
2199 header
->biHeight
= -height
; /* negative indicates a top-down bitmap. */
2200 header
->biPlanes
= 1;
2201 header
->biBitCount
= depth
;
2202 header
->biCompression
= BI_RGB
;
2203 header
->biClrUsed
= palette_colors
;
2205 /* TODO: fill in palette. */
2208 (*ximg
)->info
.bmiColors
[0].rgbBlue
= 0;
2209 (*ximg
)->info
.bmiColors
[0].rgbGreen
= 0;
2210 (*ximg
)->info
.bmiColors
[0].rgbRed
= 0;
2211 (*ximg
)->info
.bmiColors
[0].rgbReserved
= 0;
2212 (*ximg
)->info
.bmiColors
[1].rgbBlue
= 255;
2213 (*ximg
)->info
.bmiColors
[1].rgbGreen
= 255;
2214 (*ximg
)->info
.bmiColors
[1].rgbRed
= 255;
2215 (*ximg
)->info
.bmiColors
[1].rgbReserved
= 0;
2218 hdc
= get_frame_dc (f
);
2220 /* Create a DIBSection and raster array for the bitmap,
2221 and store its handle in *pixmap. */
2222 *pixmap
= CreateDIBSection (hdc
, &((*ximg
)->info
),
2223 (depth
< 16) ? DIB_PAL_COLORS
: DIB_RGB_COLORS
,
2224 /* casting avoids a GCC warning */
2225 (void **)&((*ximg
)->data
), NULL
, 0);
2227 /* Realize display palette and garbage all frames. */
2228 release_frame_dc (f
, hdc
);
2230 if (*pixmap
== NULL
)
2232 DWORD err
= GetLastError();
2233 Lisp_Object errcode
;
2234 /* All system errors are < 10000, so the following is safe. */
2235 XSETINT (errcode
, (int) err
);
2236 image_error ("Unable to create bitmap, error code %d", errcode
, Qnil
);
2237 x_destroy_x_image (*ximg
);
2243 #endif /* HAVE_NTGUI */
2246 Display
*display
= FRAME_X_DISPLAY (f
);
2247 Window window
= FRAME_X_WINDOW (f
);
2249 xassert (interrupt_input_blocked
);
2251 /* Allocate a pixmap of the same size. */
2252 *pixmap
= XCreatePixmap (display
, window
, width
, height
, depth
);
2253 if (*pixmap
== NO_PIXMAP
)
2256 image_error ("Unable to create X pixmap", Qnil
, Qnil
);
2260 LockPixels (GetGWorldPixMap (*pixmap
));
2268 /* Destroy XImage XIMG. Free XIMG->data. */
2271 x_destroy_x_image (ximg
)
2274 xassert (interrupt_input_blocked
);
2277 #ifdef HAVE_X_WINDOWS
2280 XDestroyImage (ximg
);
2281 #endif /* HAVE_X_WINDOWS */
2283 /* Data will be freed by DestroyObject. */
2286 #endif /* HAVE_NTGUI */
2288 XDestroyImage (ximg
);
2294 /* Put XImage XIMG into pixmap PIXMAP on frame F. WIDTH and HEIGHT
2295 are width and height of both the image and pixmap. */
2298 x_put_x_image (f
, ximg
, pixmap
, width
, height
)
2304 #ifdef HAVE_X_WINDOWS
2307 xassert (interrupt_input_blocked
);
2308 gc
= XCreateGC (FRAME_X_DISPLAY (f
), pixmap
, 0, NULL
);
2309 XPutImage (FRAME_X_DISPLAY (f
), pixmap
, gc
, ximg
, 0, 0, 0, 0, width
, height
);
2310 XFreeGC (FRAME_X_DISPLAY (f
), gc
);
2311 #endif /* HAVE_X_WINDOWS */
2314 #if 0 /* I don't think this is necessary looking at where it is used. */
2315 HDC hdc
= get_frame_dc (f
);
2316 SetDIBits (hdc
, pixmap
, 0, height
, ximg
->data
, &(ximg
->info
), DIB_RGB_COLORS
);
2317 release_frame_dc (f
, hdc
);
2319 #endif /* HAVE_NTGUI */
2322 xassert (ximg
== pixmap
);
2327 /***********************************************************************
2329 ***********************************************************************/
2331 static unsigned char *slurp_file
P_ ((char *, int *));
2334 /* Find image file FILE. Look in data-directory, then
2335 x-bitmap-file-path. Value is the encoded full name of the file
2336 found, or nil if not found. */
2339 x_find_image_file (file
)
2342 Lisp_Object file_found
, search_path
;
2343 struct gcpro gcpro1
, gcpro2
;
2347 search_path
= Fcons (Vdata_directory
, Vx_bitmap_file_path
);
2348 GCPRO2 (file_found
, search_path
);
2350 /* Try to find FILE in data-directory, then x-bitmap-file-path. */
2351 fd
= openp (search_path
, file
, Qnil
, &file_found
, Qnil
);
2357 file_found
= ENCODE_FILE (file_found
);
2366 /* Read FILE into memory. Value is a pointer to a buffer allocated
2367 with xmalloc holding FILE's contents. Value is null if an error
2368 occurred. *SIZE is set to the size of the file. */
2370 static unsigned char *
2371 slurp_file (file
, size
)
2376 unsigned char *buf
= NULL
;
2379 if (stat (file
, &st
) == 0
2380 && (fp
= fopen (file
, "rb")) != NULL
2381 && (buf
= (unsigned char *) xmalloc (st
.st_size
),
2382 fread (buf
, 1, st
.st_size
, fp
) == st
.st_size
))
2405 /***********************************************************************
2406 MAC Image Load Functions
2407 ***********************************************************************/
2409 static int image_load_quicktime
P_ ((struct frame
*, struct image
*img
,
2412 static int image_load_quartz2d
P_ ((struct frame
*, struct image
*img
, int));
2416 find_image_fsspec (specified_file
, file
, fss
)
2417 Lisp_Object specified_file
, *file
;
2423 *file
= x_find_image_file (specified_file
);
2424 if (!STRINGP (*file
))
2425 return fnfErr
; /* file or directory not found;
2426 incomplete pathname */
2427 /* Try to open the image file. */
2428 err
= AECoercePtr (TYPE_FILE_NAME
, SDATA (*file
),
2429 SBYTES (*file
), typeFSS
, &desc
);
2432 #if TARGET_API_MAC_CARBON
2433 err
= AEGetDescData (&desc
, fss
, sizeof (FSSpec
));
2435 *fss
= *(FSSpec
*)(*(desc
.dataHandle
));
2437 AEDisposeDesc (&desc
);
2443 image_load_qt_1 (f
, img
, type
, fss
, dh
)
2450 ComponentResult err
;
2451 GraphicsImportComponent gi
;
2454 ImageDescriptionHandle desc_handle
;
2455 short draw_all_pixels
;
2456 Lisp_Object specified_bg
;
2461 err
= OpenADefaultComponent (GraphicsImporterComponentType
, type
, &gi
);
2464 image_error ("Cannot get importer component for `%s'", img
->spec
, Qnil
);
2469 /* read from file system spec */
2470 err
= GraphicsImportSetDataFile (gi
, fss
);
2473 image_error ("Cannot set fsspec to graphics importer for '%s'",
2480 /* read from data handle */
2481 err
= GraphicsImportSetDataHandle (gi
, dh
);
2484 image_error ("Cannot set data handle to graphics importer for `%s'",
2489 err
= GraphicsImportGetImageDescription (gi
, &desc_handle
);
2490 if (err
!= noErr
|| desc_handle
== NULL
)
2492 image_error ("Error reading `%s'", img
->spec
, Qnil
);
2495 width
= img
->width
= (*desc_handle
)->width
;
2496 height
= img
->height
= (*desc_handle
)->height
;
2497 DisposeHandle ((Handle
)desc_handle
);
2499 if (!check_image_size (f
, width
, height
))
2501 image_error ("Invalid image size", Qnil
, Qnil
);
2505 err
= GraphicsImportDoesDrawAllPixels (gi
, &draw_all_pixels
);
2507 /* Don't check the error code here. It may have an undocumented
2511 image_error ("Error reading `%s'", img
->spec
, Qnil
);
2515 if (draw_all_pixels
!= graphicsImporterDrawsAllPixels
)
2517 specified_bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
2518 if (!STRINGP (specified_bg
) ||
2519 !mac_defined_color (f
, SDATA (specified_bg
), &color
, 0))
2521 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
2522 color
.red
= RED16_FROM_ULONG (color
.pixel
);
2523 color
.green
= GREEN16_FROM_ULONG (color
.pixel
);
2524 color
.blue
= BLUE16_FROM_ULONG (color
.pixel
);
2528 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
2530 if (draw_all_pixels
!= graphicsImporterDrawsAllPixels
)
2535 GetGWorld (&old_port
, &old_gdh
);
2536 SetGWorld (ximg
, NULL
);
2537 bg_color
.red
= color
.red
;
2538 bg_color
.green
= color
.green
;
2539 bg_color
.blue
= color
.blue
;
2540 RGBBackColor (&bg_color
);
2541 #if TARGET_API_MAC_CARBON
2542 GetPortBounds (ximg
, &rect
);
2545 EraseRect (&(ximg
->portRect
));
2547 SetGWorld (old_port
, old_gdh
);
2549 GraphicsImportSetGWorld (gi
, ximg
, NULL
);
2550 GraphicsImportDraw (gi
);
2551 CloseComponent (gi
);
2553 /* Maybe fill in the background field while we have ximg handy. */
2554 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
2555 IMAGE_BACKGROUND (img
, f
, ximg
);
2557 /* Put the image into the pixmap. */
2558 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
2559 x_destroy_x_image (ximg
);
2563 CloseComponent (gi
);
2568 /* Load an image using the QuickTime Graphics Importer.
2569 Note: The alpha channel does not work for PNG images. */
2571 image_load_quicktime (f
, img
, type
)
2576 Lisp_Object specified_file
;
2577 Lisp_Object specified_data
;
2580 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
2581 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
2583 if (NILP (specified_data
))
2585 /* Read from a file */
2589 err
= find_image_fsspec (specified_file
, &file
, &fss
);
2593 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
2595 image_error ("Cannot open `%s'", file
, Qnil
);
2598 return image_load_qt_1 (f
, img
, type
, &fss
, NULL
);
2602 /* Memory source! */
2606 err
= PtrToHand (SDATA (specified_data
), &dh
, SBYTES (specified_data
));
2609 image_error ("Cannot allocate data handle for `%s'",
2613 success_p
= image_load_qt_1 (f
, img
, type
, NULL
, dh
);
2621 /* Load a PNG/JPEG image using Quartz 2D decoding routines.
2622 CGImageCreateWithPNGDataProvider is provided after Mac OS X 10.2.
2623 So don't use this function directly but determine at runtime
2624 whether it exists. */
2625 typedef CGImageRef (*CGImageCreateWithPNGDataProviderProcType
)
2626 (CGDataProviderRef
, const float [], bool, CGColorRenderingIntent
);
2627 static CGImageCreateWithPNGDataProviderProcType MyCGImageCreateWithPNGDataProvider
;
2631 init_image_func_pointer ()
2633 if (NSIsSymbolNameDefined ("_CGImageCreateWithPNGDataProvider"))
2635 MyCGImageCreateWithPNGDataProvider
2636 = (CGImageCreateWithPNGDataProviderProcType
)
2637 NSAddressOfSymbol (NSLookupAndBindSymbol
2638 ("_CGImageCreateWithPNGDataProvider"));
2641 MyCGImageCreateWithPNGDataProvider
= NULL
;
2646 image_load_quartz2d (f
, img
, png_p
)
2651 Lisp_Object file
, specified_file
;
2652 Lisp_Object specified_data
, specified_bg
;
2653 struct gcpro gcpro1
;
2654 CGDataProviderRef source
;
2658 XImagePtr ximg
= NULL
;
2659 CGContextRef context
;
2662 /* Open the file. */
2663 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
2664 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
2669 if (NILP (specified_data
))
2674 file
= x_find_image_file (specified_file
);
2675 if (!STRINGP (file
))
2677 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
2681 path
= cfstring_create_with_utf8_cstring (SDATA (file
));
2682 url
= CFURLCreateWithFileSystemPath (NULL
, path
,
2683 kCFURLPOSIXPathStyle
, 0);
2685 source
= CGDataProviderCreateWithURL (url
);
2689 source
= CGDataProviderCreateWithData (NULL
, SDATA (specified_data
),
2690 SBYTES (specified_data
), NULL
);
2693 image
= (*MyCGImageCreateWithPNGDataProvider
) (source
, NULL
, FALSE
,
2694 kCGRenderingIntentDefault
);
2696 image
= CGImageCreateWithJPEGDataProvider (source
, NULL
, FALSE
,
2697 kCGRenderingIntentDefault
);
2699 CGDataProviderRelease (source
);
2703 image_error ("Error reading image `%s'", img
->spec
, Qnil
);
2706 width
= img
->width
= CGImageGetWidth (image
);
2707 height
= img
->height
= CGImageGetHeight (image
);
2709 if (!check_image_size (f
, width
, height
))
2711 CGImageRelease (image
);
2713 image_error ("Invalid image size", Qnil
, Qnil
);
2719 specified_bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
2720 if (!STRINGP (specified_bg
) ||
2721 !mac_defined_color (f
, SDATA (specified_bg
), &color
, 0))
2723 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
2724 color
.red
= RED16_FROM_ULONG (color
.pixel
);
2725 color
.green
= GREEN16_FROM_ULONG (color
.pixel
);
2726 color
.blue
= BLUE16_FROM_ULONG (color
.pixel
);
2730 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
2732 CGImageRelease (image
);
2736 rectangle
= CGRectMake (0, 0, width
, height
);
2737 QDBeginCGContext (ximg
, &context
);
2740 CGContextSetRGBFillColor (context
, color
.red
/ 65535.0,
2741 color
.green
/ 65535.0,
2742 color
.blue
/ 65535.0, 1.0);
2743 CGContextFillRect (context
, rectangle
);
2745 CGContextDrawImage (context
, rectangle
, image
);
2746 QDEndCGContext (ximg
, &context
);
2747 CGImageRelease (image
);
2749 /* Maybe fill in the background field while we have ximg handy. */
2750 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
2751 IMAGE_BACKGROUND (img
, f
, ximg
);
2753 /* Put the image into the pixmap. */
2754 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
2755 x_destroy_x_image (ximg
);
2764 /***********************************************************************
2766 ***********************************************************************/
2768 static int xbm_scan
P_ ((unsigned char **, unsigned char *, char *, int *));
2769 static int xbm_load
P_ ((struct frame
*f
, struct image
*img
));
2770 static int xbm_load_image
P_ ((struct frame
*f
, struct image
*img
,
2771 unsigned char *, unsigned char *));
2772 static int xbm_image_p
P_ ((Lisp_Object object
));
2773 static int xbm_read_bitmap_data
P_ ((struct frame
*f
,
2774 unsigned char *, unsigned char *,
2775 int *, int *, unsigned char **));
2776 static int xbm_file_p
P_ ((Lisp_Object
));
2779 /* Indices of image specification fields in xbm_format, below. */
2781 enum xbm_keyword_index
2799 /* Vector of image_keyword structures describing the format
2800 of valid XBM image specifications. */
2802 static struct image_keyword xbm_format
[XBM_LAST
] =
2804 {":type", IMAGE_SYMBOL_VALUE
, 1},
2805 {":file", IMAGE_STRING_VALUE
, 0},
2806 {":width", IMAGE_POSITIVE_INTEGER_VALUE
, 0},
2807 {":height", IMAGE_POSITIVE_INTEGER_VALUE
, 0},
2808 {":data", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
2809 {":foreground", IMAGE_STRING_OR_NIL_VALUE
, 0},
2810 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0},
2811 {":ascent", IMAGE_ASCENT_VALUE
, 0},
2812 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
2813 {":relief", IMAGE_INTEGER_VALUE
, 0},
2814 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
2815 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
2816 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0}
2819 /* Structure describing the image type XBM. */
2821 static struct image_type xbm_type
=
2830 /* Tokens returned from xbm_scan. */
2839 /* Return non-zero if OBJECT is a valid XBM-type image specification.
2840 A valid specification is a list starting with the symbol `image'
2841 The rest of the list is a property list which must contain an
2844 If the specification specifies a file to load, it must contain
2845 an entry `:file FILENAME' where FILENAME is a string.
2847 If the specification is for a bitmap loaded from memory it must
2848 contain `:width WIDTH', `:height HEIGHT', and `:data DATA', where
2849 WIDTH and HEIGHT are integers > 0. DATA may be:
2851 1. a string large enough to hold the bitmap data, i.e. it must
2852 have a size >= (WIDTH + 7) / 8 * HEIGHT
2854 2. a bool-vector of size >= WIDTH * HEIGHT
2856 3. a vector of strings or bool-vectors, one for each line of the
2859 4. A string containing an in-memory XBM file. WIDTH and HEIGHT
2860 may not be specified in this case because they are defined in the
2863 Both the file and data forms may contain the additional entries
2864 `:background COLOR' and `:foreground COLOR'. If not present,
2865 foreground and background of the frame on which the image is
2866 displayed is used. */
2869 xbm_image_p (object
)
2872 struct image_keyword kw
[XBM_LAST
];
2874 bcopy (xbm_format
, kw
, sizeof kw
);
2875 if (!parse_image_spec (object
, kw
, XBM_LAST
, Qxbm
))
2878 xassert (EQ (kw
[XBM_TYPE
].value
, Qxbm
));
2880 if (kw
[XBM_FILE
].count
)
2882 if (kw
[XBM_WIDTH
].count
|| kw
[XBM_HEIGHT
].count
|| kw
[XBM_DATA
].count
)
2885 else if (kw
[XBM_DATA
].count
&& xbm_file_p (kw
[XBM_DATA
].value
))
2887 /* In-memory XBM file. */
2888 if (kw
[XBM_WIDTH
].count
|| kw
[XBM_HEIGHT
].count
|| kw
[XBM_FILE
].count
)
2896 /* Entries for `:width', `:height' and `:data' must be present. */
2897 if (!kw
[XBM_WIDTH
].count
2898 || !kw
[XBM_HEIGHT
].count
2899 || !kw
[XBM_DATA
].count
)
2902 data
= kw
[XBM_DATA
].value
;
2903 width
= XFASTINT (kw
[XBM_WIDTH
].value
);
2904 height
= XFASTINT (kw
[XBM_HEIGHT
].value
);
2906 /* Check type of data, and width and height against contents of
2912 /* Number of elements of the vector must be >= height. */
2913 if (XVECTOR (data
)->size
< height
)
2916 /* Each string or bool-vector in data must be large enough
2917 for one line of the image. */
2918 for (i
= 0; i
< height
; ++i
)
2920 Lisp_Object elt
= XVECTOR (data
)->contents
[i
];
2925 < (width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
)
2928 else if (BOOL_VECTOR_P (elt
))
2930 if (XBOOL_VECTOR (elt
)->size
< width
)
2937 else if (STRINGP (data
))
2940 < (width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
* height
)
2943 else if (BOOL_VECTOR_P (data
))
2945 if (XBOOL_VECTOR (data
)->size
< width
* height
)
2956 /* Scan a bitmap file. FP is the stream to read from. Value is
2957 either an enumerator from enum xbm_token, or a character for a
2958 single-character token, or 0 at end of file. If scanning an
2959 identifier, store the lexeme of the identifier in SVAL. If
2960 scanning a number, store its value in *IVAL. */
2963 xbm_scan (s
, end
, sval
, ival
)
2964 unsigned char **s
, *end
;
2972 /* Skip white space. */
2973 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
2978 else if (isdigit (c
))
2980 int value
= 0, digit
;
2982 if (c
== '0' && *s
< end
)
2985 if (c
== 'x' || c
== 'X')
2992 else if (c
>= 'a' && c
<= 'f')
2993 digit
= c
- 'a' + 10;
2994 else if (c
>= 'A' && c
<= 'F')
2995 digit
= c
- 'A' + 10;
2998 value
= 16 * value
+ digit
;
3001 else if (isdigit (c
))
3005 && (c
= *(*s
)++, isdigit (c
)))
3006 value
= 8 * value
+ c
- '0';
3013 && (c
= *(*s
)++, isdigit (c
)))
3014 value
= 10 * value
+ c
- '0';
3022 else if (isalpha (c
) || c
== '_')
3026 && (c
= *(*s
)++, (isalnum (c
) || c
== '_')))
3033 else if (c
== '/' && **s
== '*')
3035 /* C-style comment. */
3037 while (**s
&& (**s
!= '*' || *(*s
+ 1) != '/'))
3051 /* Create a Windows bitmap from X bitmap data. */
3053 w32_create_pixmap_from_bitmap_data (int width
, int height
, char *data
)
3055 static unsigned char swap_nibble
[16]
3056 = { 0x0, 0x8, 0x4, 0xc, /* 0000 1000 0100 1100 */
3057 0x2, 0xa, 0x6, 0xe, /* 0010 1010 0110 1110 */
3058 0x1, 0x9, 0x5, 0xd, /* 0001 1001 0101 1101 */
3059 0x3, 0xb, 0x7, 0xf }; /* 0011 1011 0111 1111 */
3061 unsigned char *bits
, *p
;
3064 w1
= (width
+ 7) / 8; /* nb of 8bits elt in X bitmap */
3065 w2
= ((width
+ 15) / 16) * 2; /* nb of 16bits elt in W32 bitmap */
3066 bits
= (unsigned char *) alloca (height
* w2
);
3067 bzero (bits
, height
* w2
);
3068 for (i
= 0; i
< height
; i
++)
3071 for (j
= 0; j
< w1
; j
++)
3073 /* Bitswap XBM bytes to match how Windows does things. */
3074 unsigned char c
= *data
++;
3075 *p
++ = (unsigned char)((swap_nibble
[c
& 0xf] << 4)
3076 | (swap_nibble
[(c
>>4) & 0xf]));
3079 bmp
= CreateBitmap (width
, height
, 1, 1, (char *) bits
);
3084 static void convert_mono_to_color_image (f
, img
, foreground
, background
)
3087 COLORREF foreground
, background
;
3089 HDC hdc
, old_img_dc
, new_img_dc
;
3090 HGDIOBJ old_prev
, new_prev
;
3093 hdc
= get_frame_dc (f
);
3094 old_img_dc
= CreateCompatibleDC (hdc
);
3095 new_img_dc
= CreateCompatibleDC (hdc
);
3096 new_pixmap
= CreateCompatibleBitmap (hdc
, img
->width
, img
->height
);
3097 release_frame_dc (f
, hdc
);
3098 old_prev
= SelectObject (old_img_dc
, img
->pixmap
);
3099 new_prev
= SelectObject (new_img_dc
, new_pixmap
);
3100 SetTextColor (new_img_dc
, foreground
);
3101 SetBkColor (new_img_dc
, background
);
3103 BitBlt (new_img_dc
, 0, 0, img
->width
, img
->height
, old_img_dc
,
3106 SelectObject (old_img_dc
, old_prev
);
3107 SelectObject (new_img_dc
, new_prev
);
3108 DeleteDC (old_img_dc
);
3109 DeleteDC (new_img_dc
);
3110 DeleteObject (img
->pixmap
);
3111 if (new_pixmap
== 0)
3112 fprintf (stderr
, "Failed to convert image to color.\n");
3114 img
->pixmap
= new_pixmap
;
3117 #define XBM_BIT_SHUFFLE(b) (~(b))
3121 #define XBM_BIT_SHUFFLE(b) (b)
3123 #endif /* HAVE_NTGUI */
3127 Create_Pixmap_From_Bitmap_Data(f
, img
, data
, fg
, bg
, non_default_colors
)
3131 RGB_PIXEL_COLOR fg
, bg
;
3132 int non_default_colors
;
3136 = w32_create_pixmap_from_bitmap_data (img
->width
, img
->height
, data
);
3138 /* If colors were specified, transfer the bitmap to a color one. */
3139 if (non_default_colors
)
3140 convert_mono_to_color_image (f
, img
, fg
, bg
);
3143 = XCreatePixmapFromBitmapData (FRAME_X_DISPLAY (f
),
3146 img
->width
, img
->height
,
3148 DefaultDepthOfScreen (FRAME_X_SCREEN (f
)));
3149 #endif /* HAVE_NTGUI */
3154 /* Replacement for XReadBitmapFileData which isn't available under old
3155 X versions. CONTENTS is a pointer to a buffer to parse; END is the
3156 buffer's end. Set *WIDTH and *HEIGHT to the width and height of
3157 the image. Return in *DATA the bitmap data allocated with xmalloc.
3158 Value is non-zero if successful. DATA null means just test if
3159 CONTENTS looks like an in-memory XBM file. */
3162 xbm_read_bitmap_data (f
, contents
, end
, width
, height
, data
)
3164 unsigned char *contents
, *end
;
3165 int *width
, *height
;
3166 unsigned char **data
;
3168 unsigned char *s
= contents
;
3169 char buffer
[BUFSIZ
];
3172 int bytes_per_line
, i
, nbytes
;
3178 LA1 = xbm_scan (&s, end, buffer, &value)
3180 #define expect(TOKEN) \
3181 if (LA1 != (TOKEN)) \
3186 #define expect_ident(IDENT) \
3187 if (LA1 == XBM_TK_IDENT && strcmp (buffer, (IDENT)) == 0) \
3192 *width
= *height
= -1;
3195 LA1
= xbm_scan (&s
, end
, buffer
, &value
);
3197 /* Parse defines for width, height and hot-spots. */
3201 expect_ident ("define");
3202 expect (XBM_TK_IDENT
);
3204 if (LA1
== XBM_TK_NUMBER
)
3206 char *p
= strrchr (buffer
, '_');
3207 p
= p
? p
+ 1 : buffer
;
3208 if (strcmp (p
, "width") == 0)
3210 else if (strcmp (p
, "height") == 0)
3213 expect (XBM_TK_NUMBER
);
3216 if (!check_image_size (f
, *width
, *height
))
3218 else if (data
== NULL
)
3221 /* Parse bits. Must start with `static'. */
3222 expect_ident ("static");
3223 if (LA1
== XBM_TK_IDENT
)
3225 if (strcmp (buffer
, "unsigned") == 0)
3228 expect_ident ("char");
3230 else if (strcmp (buffer
, "short") == 0)
3234 if (*width
% 16 && *width
% 16 < 9)
3237 else if (strcmp (buffer
, "char") == 0)
3245 expect (XBM_TK_IDENT
);
3251 bytes_per_line
= (*width
+ 7) / 8 + padding_p
;
3252 nbytes
= bytes_per_line
* *height
;
3253 p
= *data
= (unsigned char *) xmalloc (nbytes
);
3257 for (i
= 0; i
< nbytes
; i
+= 2)
3260 expect (XBM_TK_NUMBER
);
3262 *p
++ = XBM_BIT_SHUFFLE (val
);
3263 if (!padding_p
|| ((i
+ 2) % bytes_per_line
))
3264 *p
++ = XBM_BIT_SHUFFLE (value
>> 8);
3266 if (LA1
== ',' || LA1
== '}')
3274 for (i
= 0; i
< nbytes
; ++i
)
3277 expect (XBM_TK_NUMBER
);
3279 *p
++ = XBM_BIT_SHUFFLE (val
);
3281 if (LA1
== ',' || LA1
== '}')
3306 /* Load XBM image IMG which will be displayed on frame F from buffer
3307 CONTENTS. END is the end of the buffer. Value is non-zero if
3311 xbm_load_image (f
, img
, contents
, end
)
3314 unsigned char *contents
, *end
;
3317 unsigned char *data
;
3320 rc
= xbm_read_bitmap_data (f
, contents
, end
, &img
->width
, &img
->height
, &data
);
3323 unsigned long foreground
= FRAME_FOREGROUND_PIXEL (f
);
3324 unsigned long background
= FRAME_BACKGROUND_PIXEL (f
);
3325 int non_default_colors
= 0;
3328 xassert (img
->width
> 0 && img
->height
> 0);
3330 /* Get foreground and background colors, maybe allocate colors. */
3331 value
= image_spec_value (img
->spec
, QCforeground
, NULL
);
3334 foreground
= x_alloc_image_color (f
, img
, value
, foreground
);
3335 non_default_colors
= 1;
3337 value
= image_spec_value (img
->spec
, QCbackground
, NULL
);
3340 background
= x_alloc_image_color (f
, img
, value
, background
);
3341 img
->background
= background
;
3342 img
->background_valid
= 1;
3343 non_default_colors
= 1;
3346 Create_Pixmap_From_Bitmap_Data (f
, img
, data
,
3347 foreground
, background
,
3348 non_default_colors
);
3351 if (img
->pixmap
== NO_PIXMAP
)
3353 x_clear_image (f
, img
);
3354 image_error ("Unable to create X pixmap for `%s'", img
->spec
, Qnil
);
3360 image_error ("Error loading XBM image `%s'", img
->spec
, Qnil
);
3366 /* Value is non-zero if DATA looks like an in-memory XBM file. */
3373 return (STRINGP (data
)
3374 && xbm_read_bitmap_data (NULL
, SDATA (data
),
3381 /* Fill image IMG which is used on frame F with pixmap data. Value is
3382 non-zero if successful. */
3390 Lisp_Object file_name
;
3392 xassert (xbm_image_p (img
->spec
));
3394 /* If IMG->spec specifies a file name, create a non-file spec from it. */
3395 file_name
= image_spec_value (img
->spec
, QCfile
, NULL
);
3396 if (STRINGP (file_name
))
3399 unsigned char *contents
;
3401 struct gcpro gcpro1
;
3403 file
= x_find_image_file (file_name
);
3405 if (!STRINGP (file
))
3407 image_error ("Cannot find image file `%s'", file_name
, Qnil
);
3412 contents
= slurp_file (SDATA (file
), &size
);
3413 if (contents
== NULL
)
3415 image_error ("Error loading XBM image `%s'", img
->spec
, Qnil
);
3420 success_p
= xbm_load_image (f
, img
, contents
, contents
+ size
);
3425 struct image_keyword fmt
[XBM_LAST
];
3427 unsigned long foreground
= FRAME_FOREGROUND_PIXEL (f
);
3428 unsigned long background
= FRAME_BACKGROUND_PIXEL (f
);
3429 int non_default_colors
= 0;
3432 int in_memory_file_p
= 0;
3434 /* See if data looks like an in-memory XBM file. */
3435 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
3436 in_memory_file_p
= xbm_file_p (data
);
3438 /* Parse the image specification. */
3439 bcopy (xbm_format
, fmt
, sizeof fmt
);
3440 parsed_p
= parse_image_spec (img
->spec
, fmt
, XBM_LAST
, Qxbm
);
3443 /* Get specified width, and height. */
3444 if (!in_memory_file_p
)
3446 img
->width
= XFASTINT (fmt
[XBM_WIDTH
].value
);
3447 img
->height
= XFASTINT (fmt
[XBM_HEIGHT
].value
);
3448 xassert (img
->width
> 0 && img
->height
> 0);
3451 /* Get foreground and background colors, maybe allocate colors. */
3452 if (fmt
[XBM_FOREGROUND
].count
3453 && STRINGP (fmt
[XBM_FOREGROUND
].value
))
3455 foreground
= x_alloc_image_color (f
, img
, fmt
[XBM_FOREGROUND
].value
,
3457 non_default_colors
= 1;
3460 if (fmt
[XBM_BACKGROUND
].count
3461 && STRINGP (fmt
[XBM_BACKGROUND
].value
))
3463 background
= x_alloc_image_color (f
, img
, fmt
[XBM_BACKGROUND
].value
,
3465 non_default_colors
= 1;
3468 if (in_memory_file_p
)
3469 success_p
= xbm_load_image (f
, img
, SDATA (data
),
3478 int nbytes
= (img
->width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
;
3480 p
= bits
= (char *) alloca (nbytes
* img
->height
);
3481 for (i
= 0; i
< img
->height
; ++i
, p
+= nbytes
)
3483 Lisp_Object line
= XVECTOR (data
)->contents
[i
];
3485 bcopy (SDATA (line
), p
, nbytes
);
3487 bcopy (XBOOL_VECTOR (line
)->data
, p
, nbytes
);
3490 else if (STRINGP (data
))
3491 bits
= SDATA (data
);
3493 bits
= XBOOL_VECTOR (data
)->data
;
3495 /* Create the pixmap. */
3497 Create_Pixmap_From_Bitmap_Data (f
, img
, bits
,
3498 foreground
, background
,
3499 non_default_colors
);
3504 image_error ("Unable to create pixmap for XBM image `%s'",
3506 x_clear_image (f
, img
);
3516 /***********************************************************************
3518 ***********************************************************************/
3520 #if defined (HAVE_XPM) || defined (MAC_OS)
3522 static int xpm_image_p
P_ ((Lisp_Object object
));
3523 static int xpm_load
P_ ((struct frame
*f
, struct image
*img
));
3524 static int xpm_valid_color_symbols_p
P_ ((Lisp_Object
));
3526 #endif /* HAVE_XPM || MAC_OS */
3530 /* Indicate to xpm.h that we don't have Xlib. */
3532 /* simx.h in xpm defines XColor and XImage differently than Emacs. */
3533 /* It also defines Display the same way as Emacs, but gcc 3.3 still barfs. */
3534 #define XColor xpm_XColor
3535 #define XImage xpm_XImage
3536 #define Display xpm_Display
3537 #define PIXEL_ALREADY_TYPEDEFED
3538 #include "X11/xpm.h"
3543 #undef PIXEL_ALREADY_TYPEDEFED
3545 #include "X11/xpm.h"
3546 #endif /* HAVE_NTGUI */
3547 #endif /* HAVE_XPM */
3549 #if defined (HAVE_XPM) || defined (MAC_OS)
3550 /* The symbol `xpm' identifying XPM-format images. */
3554 /* Indices of image specification fields in xpm_format, below. */
3556 enum xpm_keyword_index
3572 /* Vector of image_keyword structures describing the format
3573 of valid XPM image specifications. */
3575 static struct image_keyword xpm_format
[XPM_LAST
] =
3577 {":type", IMAGE_SYMBOL_VALUE
, 1},
3578 {":file", IMAGE_STRING_VALUE
, 0},
3579 {":data", IMAGE_STRING_VALUE
, 0},
3580 {":ascent", IMAGE_ASCENT_VALUE
, 0},
3581 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
3582 {":relief", IMAGE_INTEGER_VALUE
, 0},
3583 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3584 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3585 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3586 {":color-symbols", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3587 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
3590 /* Structure describing the image type XPM. */
3592 static struct image_type xpm_type
=
3601 #ifdef HAVE_X_WINDOWS
3603 /* Define ALLOC_XPM_COLORS if we can use Emacs' own color allocation
3604 functions for allocating image colors. Our own functions handle
3605 color allocation failures more gracefully than the ones on the XPM
3608 #if defined XpmAllocColor && defined XpmFreeColors && defined XpmColorClosure
3609 #define ALLOC_XPM_COLORS
3611 #endif /* HAVE_X_WINDOWS */
3613 #ifdef ALLOC_XPM_COLORS
3615 static void xpm_init_color_cache
P_ ((struct frame
*, XpmAttributes
*));
3616 static void xpm_free_color_cache
P_ ((void));
3617 static int xpm_lookup_color
P_ ((struct frame
*, char *, XColor
*));
3618 static int xpm_color_bucket
P_ ((char *));
3619 static struct xpm_cached_color
*xpm_cache_color
P_ ((struct frame
*, char *,
3622 /* An entry in a hash table used to cache color definitions of named
3623 colors. This cache is necessary to speed up XPM image loading in
3624 case we do color allocations ourselves. Without it, we would need
3625 a call to XParseColor per pixel in the image. */
3627 struct xpm_cached_color
3629 /* Next in collision chain. */
3630 struct xpm_cached_color
*next
;
3632 /* Color definition (RGB and pixel color). */
3639 /* The hash table used for the color cache, and its bucket vector
3642 #define XPM_COLOR_CACHE_BUCKETS 1001
3643 struct xpm_cached_color
**xpm_color_cache
;
3645 /* Initialize the color cache. */
3648 xpm_init_color_cache (f
, attrs
)
3650 XpmAttributes
*attrs
;
3652 size_t nbytes
= XPM_COLOR_CACHE_BUCKETS
* sizeof *xpm_color_cache
;
3653 xpm_color_cache
= (struct xpm_cached_color
**) xmalloc (nbytes
);
3654 memset (xpm_color_cache
, 0, nbytes
);
3655 init_color_table ();
3657 if (attrs
->valuemask
& XpmColorSymbols
)
3662 for (i
= 0; i
< attrs
->numsymbols
; ++i
)
3663 if (XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
3664 attrs
->colorsymbols
[i
].value
, &color
))
3666 color
.pixel
= lookup_rgb_color (f
, color
.red
, color
.green
,
3668 xpm_cache_color (f
, attrs
->colorsymbols
[i
].name
, &color
, -1);
3673 /* Free the color cache. */
3676 xpm_free_color_cache ()
3678 struct xpm_cached_color
*p
, *next
;
3681 for (i
= 0; i
< XPM_COLOR_CACHE_BUCKETS
; ++i
)
3682 for (p
= xpm_color_cache
[i
]; p
; p
= next
)
3688 xfree (xpm_color_cache
);
3689 xpm_color_cache
= NULL
;
3690 free_color_table ();
3693 /* Return the bucket index for color named COLOR_NAME in the color
3697 xpm_color_bucket (color_name
)
3703 for (s
= color_name
; *s
; ++s
)
3705 return h
%= XPM_COLOR_CACHE_BUCKETS
;
3709 /* On frame F, cache values COLOR for color with name COLOR_NAME.
3710 BUCKET, if >= 0, is a precomputed bucket index. Value is the cache
3713 static struct xpm_cached_color
*
3714 xpm_cache_color (f
, color_name
, color
, bucket
)
3721 struct xpm_cached_color
*p
;
3724 bucket
= xpm_color_bucket (color_name
);
3726 nbytes
= sizeof *p
+ strlen (color_name
);
3727 p
= (struct xpm_cached_color
*) xmalloc (nbytes
);
3728 strcpy (p
->name
, color_name
);
3730 p
->next
= xpm_color_cache
[bucket
];
3731 xpm_color_cache
[bucket
] = p
;
3735 /* Look up color COLOR_NAME for frame F in the color cache. If found,
3736 return the cached definition in *COLOR. Otherwise, make a new
3737 entry in the cache and allocate the color. Value is zero if color
3738 allocation failed. */
3741 xpm_lookup_color (f
, color_name
, color
)
3746 struct xpm_cached_color
*p
;
3747 int h
= xpm_color_bucket (color_name
);
3749 for (p
= xpm_color_cache
[h
]; p
; p
= p
->next
)
3750 if (strcmp (p
->name
, color_name
) == 0)
3755 else if (XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
3758 color
->pixel
= lookup_rgb_color (f
, color
->red
, color
->green
,
3760 p
= xpm_cache_color (f
, color_name
, color
, h
);
3762 /* You get `opaque' at least from ImageMagick converting pbm to xpm
3763 with transparency, and it's useful. */
3764 else if (strcmp ("opaque", color_name
) == 0)
3766 bzero (color
, sizeof (XColor
)); /* Is this necessary/correct? */
3767 color
->pixel
= FRAME_FOREGROUND_PIXEL (f
);
3768 p
= xpm_cache_color (f
, color_name
, color
, h
);
3775 /* Callback for allocating color COLOR_NAME. Called from the XPM lib.
3776 CLOSURE is a pointer to the frame on which we allocate the
3777 color. Return in *COLOR the allocated color. Value is non-zero
3781 xpm_alloc_color (dpy
, cmap
, color_name
, color
, closure
)
3788 return xpm_lookup_color ((struct frame
*) closure
, color_name
, color
);
3792 /* Callback for freeing NPIXELS colors contained in PIXELS. CLOSURE
3793 is a pointer to the frame on which we allocate the color. Value is
3794 non-zero if successful. */
3797 xpm_free_colors (dpy
, cmap
, pixels
, npixels
, closure
)
3807 #endif /* ALLOC_XPM_COLORS */
3812 /* XPM library details. */
3814 DEF_IMGLIB_FN (XpmFreeAttributes
);
3815 DEF_IMGLIB_FN (XpmCreateImageFromBuffer
);
3816 DEF_IMGLIB_FN (XpmReadFileToImage
);
3817 DEF_IMGLIB_FN (XImageFree
);
3820 init_xpm_functions (Lisp_Object libraries
)
3824 if (!(library
= w32_delayed_load (libraries
, Qxpm
)))
3827 LOAD_IMGLIB_FN (library
, XpmFreeAttributes
);
3828 LOAD_IMGLIB_FN (library
, XpmCreateImageFromBuffer
);
3829 LOAD_IMGLIB_FN (library
, XpmReadFileToImage
);
3830 LOAD_IMGLIB_FN (library
, XImageFree
);
3834 #endif /* HAVE_NTGUI */
3837 /* Value is non-zero if COLOR_SYMBOLS is a valid color symbols list
3838 for XPM images. Such a list must consist of conses whose car and
3842 xpm_valid_color_symbols_p (color_symbols
)
3843 Lisp_Object color_symbols
;
3845 while (CONSP (color_symbols
))
3847 Lisp_Object sym
= XCAR (color_symbols
);
3849 || !STRINGP (XCAR (sym
))
3850 || !STRINGP (XCDR (sym
)))
3852 color_symbols
= XCDR (color_symbols
);
3855 return NILP (color_symbols
);
3859 /* Value is non-zero if OBJECT is a valid XPM image specification. */
3862 xpm_image_p (object
)
3865 struct image_keyword fmt
[XPM_LAST
];
3866 bcopy (xpm_format
, fmt
, sizeof fmt
);
3867 return (parse_image_spec (object
, fmt
, XPM_LAST
, Qxpm
)
3868 /* Either `:file' or `:data' must be present. */
3869 && fmt
[XPM_FILE
].count
+ fmt
[XPM_DATA
].count
== 1
3870 /* Either no `:color-symbols' or it's a list of conses
3871 whose car and cdr are strings. */
3872 && (fmt
[XPM_COLOR_SYMBOLS
].count
== 0
3873 || xpm_valid_color_symbols_p (fmt
[XPM_COLOR_SYMBOLS
].value
)));
3876 #endif /* HAVE_XPM || MAC_OS */
3878 #if defined (HAVE_XPM) && defined (HAVE_X_WINDOWS)
3880 x_create_bitmap_from_xpm_data (f
, bits
)
3884 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
3886 XpmAttributes attrs
;
3887 Pixmap bitmap
, mask
;
3889 bzero (&attrs
, sizeof attrs
);
3891 attrs
.visual
= FRAME_X_VISUAL (f
);
3892 attrs
.colormap
= FRAME_X_COLORMAP (f
);
3893 attrs
.valuemask
|= XpmVisual
;
3894 attrs
.valuemask
|= XpmColormap
;
3896 rc
= XpmCreatePixmapFromData (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3897 bits
, &bitmap
, &mask
, &attrs
);
3898 if (rc
!= XpmSuccess
)
3900 XpmFreeAttributes (&attrs
);
3904 id
= x_allocate_bitmap_record (f
);
3905 dpyinfo
->bitmaps
[id
- 1].pixmap
= bitmap
;
3906 dpyinfo
->bitmaps
[id
- 1].have_mask
= 1;
3907 dpyinfo
->bitmaps
[id
- 1].mask
= mask
;
3908 dpyinfo
->bitmaps
[id
- 1].file
= NULL
;
3909 dpyinfo
->bitmaps
[id
- 1].height
= attrs
.height
;
3910 dpyinfo
->bitmaps
[id
- 1].width
= attrs
.width
;
3911 dpyinfo
->bitmaps
[id
- 1].depth
= attrs
.depth
;
3912 dpyinfo
->bitmaps
[id
- 1].refcount
= 1;
3914 XpmFreeAttributes (&attrs
);
3917 #endif /* defined (HAVE_XPM) && defined (HAVE_X_WINDOWS) */
3919 /* Load image IMG which will be displayed on frame F. Value is
3920 non-zero if successful. */
3930 XpmAttributes attrs
;
3931 Lisp_Object specified_file
, color_symbols
;
3934 xpm_XImage
* xpm_image
= NULL
, * xpm_mask
= NULL
;
3935 #endif /* HAVE_NTGUI */
3937 /* Configure the XPM lib. Use the visual of frame F. Allocate
3938 close colors. Return colors allocated. */
3939 bzero (&attrs
, sizeof attrs
);
3942 attrs
.visual
= FRAME_X_VISUAL (f
);
3943 attrs
.colormap
= FRAME_X_COLORMAP (f
);
3944 attrs
.valuemask
|= XpmVisual
;
3945 attrs
.valuemask
|= XpmColormap
;
3946 #endif /* HAVE_NTGUI */
3948 #ifdef ALLOC_XPM_COLORS
3949 /* Allocate colors with our own functions which handle
3950 failing color allocation more gracefully. */
3951 attrs
.color_closure
= f
;
3952 attrs
.alloc_color
= xpm_alloc_color
;
3953 attrs
.free_colors
= xpm_free_colors
;
3954 attrs
.valuemask
|= XpmAllocColor
| XpmFreeColors
| XpmColorClosure
;
3955 #else /* not ALLOC_XPM_COLORS */
3956 /* Let the XPM lib allocate colors. */
3957 attrs
.valuemask
|= XpmReturnAllocPixels
;
3958 #ifdef XpmAllocCloseColors
3959 attrs
.alloc_close_colors
= 1;
3960 attrs
.valuemask
|= XpmAllocCloseColors
;
3961 #else /* not XpmAllocCloseColors */
3962 attrs
.closeness
= 600;
3963 attrs
.valuemask
|= XpmCloseness
;
3964 #endif /* not XpmAllocCloseColors */
3965 #endif /* ALLOC_XPM_COLORS */
3966 #ifdef ALLOC_XPM_COLORS
3967 xpm_init_color_cache (f
, &attrs
);
3970 /* If image specification contains symbolic color definitions, add
3971 these to `attrs'. */
3972 color_symbols
= image_spec_value (img
->spec
, QCcolor_symbols
, NULL
);
3973 if (CONSP (color_symbols
))
3976 XpmColorSymbol
*xpm_syms
;
3979 attrs
.valuemask
|= XpmColorSymbols
;
3981 /* Count number of symbols. */
3982 attrs
.numsymbols
= 0;
3983 for (tail
= color_symbols
; CONSP (tail
); tail
= XCDR (tail
))
3986 /* Allocate an XpmColorSymbol array. */
3987 size
= attrs
.numsymbols
* sizeof *xpm_syms
;
3988 xpm_syms
= (XpmColorSymbol
*) alloca (size
);
3989 bzero (xpm_syms
, size
);
3990 attrs
.colorsymbols
= xpm_syms
;
3992 /* Fill the color symbol array. */
3993 for (tail
= color_symbols
, i
= 0;
3995 ++i
, tail
= XCDR (tail
))
3997 Lisp_Object name
= XCAR (XCAR (tail
));
3998 Lisp_Object color
= XCDR (XCAR (tail
));
3999 xpm_syms
[i
].name
= (char *) alloca (SCHARS (name
) + 1);
4000 strcpy (xpm_syms
[i
].name
, SDATA (name
));
4001 xpm_syms
[i
].value
= (char *) alloca (SCHARS (color
) + 1);
4002 strcpy (xpm_syms
[i
].value
, SDATA (color
));
4006 /* Create a pixmap for the image, either from a file, or from a
4007 string buffer containing data in the same format as an XPM file. */
4008 #ifdef ALLOC_XPM_COLORS
4009 xpm_init_color_cache (f
, &attrs
);
4012 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
4016 HDC frame_dc
= get_frame_dc (f
);
4017 hdc
= CreateCompatibleDC (frame_dc
);
4018 release_frame_dc (f
, frame_dc
);
4020 #endif /* HAVE_NTGUI */
4022 if (STRINGP (specified_file
))
4024 Lisp_Object file
= x_find_image_file (specified_file
);
4025 if (!STRINGP (file
))
4027 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
4032 /* XpmReadFileToPixmap is not available in the Windows port of
4033 libxpm. But XpmReadFileToImage almost does what we want. */
4034 rc
= fn_XpmReadFileToImage (&hdc
, SDATA (file
),
4035 &xpm_image
, &xpm_mask
,
4038 rc
= XpmReadFileToPixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
4039 SDATA (file
), &img
->pixmap
, &img
->mask
,
4041 #endif /* HAVE_NTGUI */
4045 Lisp_Object buffer
= image_spec_value (img
->spec
, QCdata
, NULL
);
4047 /* XpmCreatePixmapFromBuffer is not available in the Windows port
4048 of libxpm. But XpmCreateImageFromBuffer almost does what we want. */
4049 rc
= fn_XpmCreateImageFromBuffer (&hdc
, SDATA (buffer
),
4050 &xpm_image
, &xpm_mask
,
4053 rc
= XpmCreatePixmapFromBuffer (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
4055 &img
->pixmap
, &img
->mask
,
4057 #endif /* HAVE_NTGUI */
4060 if (rc
== XpmSuccess
)
4062 #if defined (COLOR_TABLE_SUPPORT) && defined (ALLOC_XPM_COLORS)
4063 img
->colors
= colors_in_color_table (&img
->ncolors
);
4064 #else /* not ALLOC_XPM_COLORS */
4068 /* W32 XPM uses XImage to wrap what W32 Emacs calls a Pixmap,
4069 plus some duplicate attributes. */
4070 if (xpm_image
&& xpm_image
->bitmap
)
4072 img
->pixmap
= xpm_image
->bitmap
;
4073 /* XImageFree in libXpm frees XImage struct without destroying
4074 the bitmap, which is what we want. */
4075 fn_XImageFree (xpm_image
);
4077 if (xpm_mask
&& xpm_mask
->bitmap
)
4079 /* The mask appears to be inverted compared with what we expect.
4080 TODO: invert our expectations. See other places where we
4081 have to invert bits because our idea of masks is backwards. */
4083 old_obj
= SelectObject (hdc
, xpm_mask
->bitmap
);
4085 PatBlt (hdc
, 0, 0, xpm_mask
->width
, xpm_mask
->height
, DSTINVERT
);
4086 SelectObject (hdc
, old_obj
);
4088 img
->mask
= xpm_mask
->bitmap
;
4089 fn_XImageFree (xpm_mask
);
4094 #endif /* HAVE_NTGUI */
4096 /* Remember allocated colors. */
4097 img
->ncolors
= attrs
.nalloc_pixels
;
4098 img
->colors
= (unsigned long *) xmalloc (img
->ncolors
4099 * sizeof *img
->colors
);
4100 for (i
= 0; i
< attrs
.nalloc_pixels
; ++i
)
4102 img
->colors
[i
] = attrs
.alloc_pixels
[i
];
4103 #ifdef DEBUG_X_COLORS
4104 register_color (img
->colors
[i
]);
4107 #endif /* not ALLOC_XPM_COLORS */
4109 img
->width
= attrs
.width
;
4110 img
->height
= attrs
.height
;
4111 xassert (img
->width
> 0 && img
->height
> 0);
4113 /* The call to XpmFreeAttributes below frees attrs.alloc_pixels. */
4115 fn_XpmFreeAttributes (&attrs
);
4117 XpmFreeAttributes (&attrs
);
4118 #endif /* HAVE_NTGUI */
4124 #endif /* HAVE_NTGUI */
4129 image_error ("Error opening XPM file (%s)", img
->spec
, Qnil
);
4132 case XpmFileInvalid
:
4133 image_error ("Invalid XPM file (%s)", img
->spec
, Qnil
);
4137 image_error ("Out of memory (%s)", img
->spec
, Qnil
);
4140 case XpmColorFailed
:
4141 image_error ("Color allocation error (%s)", img
->spec
, Qnil
);
4145 image_error ("Unknown error (%s)", img
->spec
, Qnil
);
4150 #ifdef ALLOC_XPM_COLORS
4151 xpm_free_color_cache ();
4153 return rc
== XpmSuccess
;
4156 #endif /* HAVE_XPM */
4160 /* XPM support functions for Mac OS where libxpm is not available.
4161 Only XPM version 3 (without any extensions) is supported. */
4163 static int xpm_scan
P_ ((const unsigned char **, const unsigned char *,
4164 const unsigned char **, int *));
4165 static Lisp_Object xpm_make_color_table_v
4166 P_ ((void (**) (Lisp_Object
, const unsigned char *, int, Lisp_Object
),
4167 Lisp_Object (**) (Lisp_Object
, const unsigned char *, int)));
4168 static void xpm_put_color_table_v
P_ ((Lisp_Object
, const unsigned char *,
4170 static Lisp_Object xpm_get_color_table_v
P_ ((Lisp_Object
,
4171 const unsigned char *, int));
4172 static Lisp_Object xpm_make_color_table_h
4173 P_ ((void (**) (Lisp_Object
, const unsigned char *, int, Lisp_Object
),
4174 Lisp_Object (**) (Lisp_Object
, const unsigned char *, int)));
4175 static void xpm_put_color_table_h
P_ ((Lisp_Object
, const unsigned char *,
4177 static Lisp_Object xpm_get_color_table_h
P_ ((Lisp_Object
,
4178 const unsigned char *, int));
4179 static int xpm_str_to_color_key
P_ ((const char *));
4180 static int xpm_load_image
P_ ((struct frame
*, struct image
*,
4181 const unsigned char *, const unsigned char *));
4183 /* Tokens returned from xpm_scan. */
4192 /* Scan an XPM data and return a character (< 256) or a token defined
4193 by enum xpm_token above. *S and END are the start (inclusive) and
4194 the end (exclusive) addresses of the data, respectively. Advance
4195 *S while scanning. If token is either XPM_TK_IDENT or
4196 XPM_TK_STRING, *BEG and *LEN are set to the start address and the
4197 length of the corresponding token, respectively. */
4200 xpm_scan (s
, end
, beg
, len
)
4201 const unsigned char **s
, *end
, **beg
;
4208 /* Skip white-space. */
4209 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
4212 /* gnus-pointer.xpm uses '-' in its identifier.
4213 sb-dir-plus.xpm uses '+' in its identifier. */
4214 if (isalpha (c
) || c
== '_' || c
== '-' || c
== '+')
4218 (c
= **s
, isalnum (c
) || c
== '_' || c
== '-' || c
== '+'))
4221 return XPM_TK_IDENT
;
4226 while (*s
< end
&& **s
!= '"')
4231 return XPM_TK_STRING
;
4235 if (*s
< end
&& **s
== '*')
4237 /* C-style comment. */
4241 while (*s
< end
&& *(*s
)++ != '*')
4244 while (*s
< end
&& **s
!= '/');
4258 /* Functions for color table lookup in XPM data. A Key is a string
4259 specifying the color of each pixel in XPM data. A value is either
4260 an integer that specifies a pixel color, Qt that specifies
4261 transparency, or Qnil for the unspecified color. If the length of
4262 the key string is one, a vector is used as a table. Otherwise, a
4263 hash table is used. */
4266 xpm_make_color_table_v (put_func
, get_func
)
4267 void (**put_func
) (Lisp_Object
, const unsigned char *, int, Lisp_Object
);
4268 Lisp_Object (**get_func
) (Lisp_Object
, const unsigned char *, int);
4270 *put_func
= xpm_put_color_table_v
;
4271 *get_func
= xpm_get_color_table_v
;
4272 return Fmake_vector (make_number (256), Qnil
);
4276 xpm_put_color_table_v (color_table
, chars_start
, chars_len
, color
)
4277 Lisp_Object color_table
;
4278 const unsigned char *chars_start
;
4282 XVECTOR (color_table
)->contents
[*chars_start
] = color
;
4286 xpm_get_color_table_v (color_table
, chars_start
, chars_len
)
4287 Lisp_Object color_table
;
4288 const unsigned char *chars_start
;
4291 return XVECTOR (color_table
)->contents
[*chars_start
];
4295 xpm_make_color_table_h (put_func
, get_func
)
4296 void (**put_func
) (Lisp_Object
, const unsigned char *, int, Lisp_Object
);
4297 Lisp_Object (**get_func
) (Lisp_Object
, const unsigned char *, int);
4299 *put_func
= xpm_put_color_table_h
;
4300 *get_func
= xpm_get_color_table_h
;
4301 return make_hash_table (Qequal
, make_number (DEFAULT_HASH_SIZE
),
4302 make_float (DEFAULT_REHASH_SIZE
),
4303 make_float (DEFAULT_REHASH_THRESHOLD
),
4308 xpm_put_color_table_h (color_table
, chars_start
, chars_len
, color
)
4309 Lisp_Object color_table
;
4310 const unsigned char *chars_start
;
4314 struct Lisp_Hash_Table
*table
= XHASH_TABLE (color_table
);
4316 Lisp_Object chars
= make_unibyte_string (chars_start
, chars_len
);
4318 hash_lookup (table
, chars
, &hash_code
);
4319 hash_put (table
, chars
, color
, hash_code
);
4323 xpm_get_color_table_h (color_table
, chars_start
, chars_len
)
4324 Lisp_Object color_table
;
4325 const unsigned char *chars_start
;
4328 struct Lisp_Hash_Table
*table
= XHASH_TABLE (color_table
);
4329 int i
= hash_lookup (table
, make_unibyte_string (chars_start
, chars_len
),
4332 return i
>= 0 ? HASH_VALUE (table
, i
) : Qnil
;
4335 enum xpm_color_key
{
4343 static const char xpm_color_key_strings
[][4] = {"s", "m", "g4", "g", "c"};
4346 xpm_str_to_color_key (s
)
4352 i
< sizeof xpm_color_key_strings
/ sizeof xpm_color_key_strings
[0];
4354 if (strcmp (xpm_color_key_strings
[i
], s
) == 0)
4360 xpm_load_image (f
, img
, contents
, end
)
4363 const unsigned char *contents
, *end
;
4365 const unsigned char *s
= contents
, *beg
, *str
;
4366 unsigned char buffer
[BUFSIZ
];
4367 int width
, height
, x
, y
;
4368 int num_colors
, chars_per_pixel
;
4370 void (*put_color_table
) (Lisp_Object
, const unsigned char *, int, Lisp_Object
);
4371 Lisp_Object (*get_color_table
) (Lisp_Object
, const unsigned char *, int);
4372 Lisp_Object frame
, color_symbols
, color_table
;
4373 int best_key
, have_mask
= 0;
4374 XImagePtr ximg
= NULL
, mask_img
= NULL
;
4377 LA1 = xpm_scan (&s, end, &beg, &len)
4379 #define expect(TOKEN) \
4380 if (LA1 != (TOKEN)) \
4385 #define expect_ident(IDENT) \
4386 if (LA1 == XPM_TK_IDENT \
4387 && strlen ((IDENT)) == len && memcmp ((IDENT), beg, len) == 0) \
4392 if (!(end
- s
>= 9 && memcmp (s
, "/* XPM */", 9) == 0))
4396 expect_ident ("static");
4397 expect_ident ("char");
4399 expect (XPM_TK_IDENT
);
4404 expect (XPM_TK_STRING
);
4407 memcpy (buffer
, beg
, len
);
4409 if (sscanf (buffer
, "%d %d %d %d", &width
, &height
,
4410 &num_colors
, &chars_per_pixel
) != 4
4411 || width
<= 0 || height
<= 0
4412 || num_colors
<= 0 || chars_per_pixel
<= 0)
4415 if (!check_image_size (f
, width
, height
))
4417 image_error ("Invalid image size", Qnil
, Qnil
);
4423 XSETFRAME (frame
, f
);
4424 if (!NILP (Fxw_display_color_p (frame
)))
4425 best_key
= XPM_COLOR_KEY_C
;
4426 else if (!NILP (Fx_display_grayscale_p (frame
)))
4427 best_key
= (XFASTINT (Fx_display_planes (frame
)) > 2
4428 ? XPM_COLOR_KEY_G
: XPM_COLOR_KEY_G4
);
4430 best_key
= XPM_COLOR_KEY_M
;
4432 color_symbols
= image_spec_value (img
->spec
, QCcolor_symbols
, NULL
);
4433 if (chars_per_pixel
== 1)
4434 color_table
= xpm_make_color_table_v (&put_color_table
,
4437 color_table
= xpm_make_color_table_h (&put_color_table
,
4440 while (num_colors
-- > 0)
4442 unsigned char *color
, *max_color
;
4443 int key
, next_key
, max_key
= 0;
4444 Lisp_Object symbol_color
= Qnil
, color_val
;
4447 expect (XPM_TK_STRING
);
4448 if (len
<= chars_per_pixel
|| len
>= BUFSIZ
+ chars_per_pixel
)
4450 memcpy (buffer
, beg
+ chars_per_pixel
, len
- chars_per_pixel
);
4451 buffer
[len
- chars_per_pixel
] = '\0';
4453 str
= strtok (buffer
, " \t");
4456 key
= xpm_str_to_color_key (str
);
4461 color
= strtok (NULL
, " \t");
4465 while ((str
= strtok (NULL
, " \t")) != NULL
)
4467 next_key
= xpm_str_to_color_key (str
);
4470 color
[strlen (color
)] = ' ';
4473 if (key
== XPM_COLOR_KEY_S
)
4475 if (NILP (symbol_color
))
4476 symbol_color
= build_string (color
);
4478 else if (max_key
< key
&& key
<= best_key
)
4488 if (!NILP (color_symbols
) && !NILP (symbol_color
))
4490 Lisp_Object specified_color
= Fassoc (symbol_color
, color_symbols
);
4492 if (CONSP (specified_color
) && STRINGP (XCDR (specified_color
)))
4494 if (xstricmp (SDATA (XCDR (specified_color
)), "None") == 0)
4496 else if (x_defined_color (f
, SDATA (XCDR (specified_color
)),
4498 color_val
= make_number (cdef
.pixel
);
4501 if (NILP (color_val
) && max_key
> 0)
4503 if (xstricmp (max_color
, "None") == 0)
4505 else if (x_defined_color (f
, max_color
, &cdef
, 0))
4506 color_val
= make_number (cdef
.pixel
);
4508 if (!NILP (color_val
))
4509 (*put_color_table
) (color_table
, beg
, chars_per_pixel
, color_val
);
4514 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0,
4515 &ximg
, &img
->pixmap
)
4516 || !x_create_x_image_and_pixmap (f
, width
, height
, 1,
4517 &mask_img
, &img
->mask
))
4519 image_error ("Out of memory (%s)", img
->spec
, Qnil
);
4523 for (y
= 0; y
< height
; y
++)
4525 expect (XPM_TK_STRING
);
4527 if (len
< width
* chars_per_pixel
)
4529 for (x
= 0; x
< width
; x
++, str
+= chars_per_pixel
)
4531 Lisp_Object color_val
=
4532 (*get_color_table
) (color_table
, str
, chars_per_pixel
);
4534 XPutPixel (ximg
, x
, y
,
4535 (INTEGERP (color_val
) ? XINT (color_val
)
4536 : FRAME_FOREGROUND_PIXEL (f
)));
4537 XPutPixel (mask_img
, x
, y
,
4538 (!EQ (color_val
, Qt
) ? PIX_MASK_DRAW
4539 : (have_mask
= 1, PIX_MASK_RETAIN
)));
4546 img
->height
= height
;
4548 /* Maybe fill in the background field while we have ximg handy. */
4549 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
4550 IMAGE_BACKGROUND (img
, f
, ximg
);
4552 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
4553 x_destroy_x_image (ximg
);
4556 /* Fill in the background_transparent field while we have the
4558 image_background_transparent (img
, f
, mask_img
);
4560 x_put_x_image (f
, mask_img
, img
->mask
, width
, height
);
4561 x_destroy_x_image (mask_img
);
4565 x_destroy_x_image (mask_img
);
4566 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
4567 img
->mask
= NO_PIXMAP
;
4573 image_error ("Invalid XPM file (%s)", img
->spec
, Qnil
);
4575 x_destroy_x_image (ximg
);
4576 x_destroy_x_image (mask_img
);
4577 x_clear_image (f
, img
);
4591 Lisp_Object file_name
;
4593 /* If IMG->spec specifies a file name, create a non-file spec from it. */
4594 file_name
= image_spec_value (img
->spec
, QCfile
, NULL
);
4595 if (STRINGP (file_name
))
4598 unsigned char *contents
;
4600 struct gcpro gcpro1
;
4602 file
= x_find_image_file (file_name
);
4604 if (!STRINGP (file
))
4606 image_error ("Cannot find image file `%s'", file_name
, Qnil
);
4611 contents
= slurp_file (SDATA (file
), &size
);
4612 if (contents
== NULL
)
4614 image_error ("Error loading XPM image `%s'", img
->spec
, Qnil
);
4619 success_p
= xpm_load_image (f
, img
, contents
, contents
+ size
);
4627 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
4628 success_p
= xpm_load_image (f
, img
, SDATA (data
),
4629 SDATA (data
) + SBYTES (data
));
4639 /***********************************************************************
4641 ***********************************************************************/
4643 #ifdef COLOR_TABLE_SUPPORT
4645 /* An entry in the color table mapping an RGB color to a pixel color. */
4650 unsigned long pixel
;
4652 /* Next in color table collision list. */
4653 struct ct_color
*next
;
4656 /* The bucket vector size to use. Must be prime. */
4660 /* Value is a hash of the RGB color given by R, G, and B. */
4662 #define CT_HASH_RGB(R, G, B) (((R) << 16) ^ ((G) << 8) ^ (B))
4664 /* The color hash table. */
4666 struct ct_color
**ct_table
;
4668 /* Number of entries in the color table. */
4670 int ct_colors_allocated
;
4672 /* Initialize the color table. */
4677 int size
= CT_SIZE
* sizeof (*ct_table
);
4678 ct_table
= (struct ct_color
**) xmalloc (size
);
4679 bzero (ct_table
, size
);
4680 ct_colors_allocated
= 0;
4684 /* Free memory associated with the color table. */
4690 struct ct_color
*p
, *next
;
4692 for (i
= 0; i
< CT_SIZE
; ++i
)
4693 for (p
= ct_table
[i
]; p
; p
= next
)
4704 /* Value is a pixel color for RGB color R, G, B on frame F. If an
4705 entry for that color already is in the color table, return the
4706 pixel color of that entry. Otherwise, allocate a new color for R,
4707 G, B, and make an entry in the color table. */
4709 static unsigned long
4710 lookup_rgb_color (f
, r
, g
, b
)
4714 unsigned hash
= CT_HASH_RGB (r
, g
, b
);
4715 int i
= hash
% CT_SIZE
;
4717 Display_Info
*dpyinfo
;
4719 /* Handle TrueColor visuals specially, which improves performance by
4720 two orders of magnitude. Freeing colors on TrueColor visuals is
4721 a nop, and pixel colors specify RGB values directly. See also
4722 the Xlib spec, chapter 3.1. */
4723 dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
4724 if (dpyinfo
->red_bits
> 0)
4726 unsigned long pr
, pg
, pb
;
4728 /* Apply gamma-correction like normal color allocation does. */
4732 color
.red
= r
, color
.green
= g
, color
.blue
= b
;
4733 gamma_correct (f
, &color
);
4734 r
= color
.red
, g
= color
.green
, b
= color
.blue
;
4737 /* Scale down RGB values to the visual's bits per RGB, and shift
4738 them to the right position in the pixel color. Note that the
4739 original RGB values are 16-bit values, as usual in X. */
4740 pr
= (r
>> (16 - dpyinfo
->red_bits
)) << dpyinfo
->red_offset
;
4741 pg
= (g
>> (16 - dpyinfo
->green_bits
)) << dpyinfo
->green_offset
;
4742 pb
= (b
>> (16 - dpyinfo
->blue_bits
)) << dpyinfo
->blue_offset
;
4744 /* Assemble the pixel color. */
4745 return pr
| pg
| pb
;
4748 for (p
= ct_table
[i
]; p
; p
= p
->next
)
4749 if (p
->r
== r
&& p
->g
== g
&& p
->b
== b
)
4755 #ifdef HAVE_X_WINDOWS
4764 cmap
= FRAME_X_COLORMAP (f
);
4765 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
4768 ++ct_colors_allocated
;
4769 p
= (struct ct_color
*) xmalloc (sizeof *p
);
4773 p
->pixel
= color
.pixel
;
4774 p
->next
= ct_table
[i
];
4778 return FRAME_FOREGROUND_PIXEL (f
);
4783 color
= PALETTERGB (r
, g
, b
);
4785 color
= RGB_TO_ULONG (r
, g
, b
);
4786 #endif /* HAVE_NTGUI */
4787 ++ct_colors_allocated
;
4788 p
= (struct ct_color
*) xmalloc (sizeof *p
);
4793 p
->next
= ct_table
[i
];
4795 #endif /* HAVE_X_WINDOWS */
4803 /* Look up pixel color PIXEL which is used on frame F in the color
4804 table. If not already present, allocate it. Value is PIXEL. */
4806 static unsigned long
4807 lookup_pixel_color (f
, pixel
)
4809 unsigned long pixel
;
4811 int i
= pixel
% CT_SIZE
;
4814 for (p
= ct_table
[i
]; p
; p
= p
->next
)
4815 if (p
->pixel
== pixel
)
4824 #ifdef HAVE_X_WINDOWS
4825 cmap
= FRAME_X_COLORMAP (f
);
4826 color
.pixel
= pixel
;
4827 x_query_color (f
, &color
);
4828 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
4831 cmap
= DefaultColormapOfScreen (FRAME_X_SCREEN (f
));
4832 color
.pixel
= pixel
;
4833 XQueryColor (NULL
, cmap
, &color
);
4834 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
4836 #endif /* HAVE_X_WINDOWS */
4840 ++ct_colors_allocated
;
4842 p
= (struct ct_color
*) xmalloc (sizeof *p
);
4847 p
->next
= ct_table
[i
];
4851 return FRAME_FOREGROUND_PIXEL (f
);
4857 /* Value is a vector of all pixel colors contained in the color table,
4858 allocated via xmalloc. Set *N to the number of colors. */
4860 static unsigned long *
4861 colors_in_color_table (n
)
4866 unsigned long *colors
;
4868 if (ct_colors_allocated
== 0)
4875 colors
= (unsigned long *) xmalloc (ct_colors_allocated
4877 *n
= ct_colors_allocated
;
4879 for (i
= j
= 0; i
< CT_SIZE
; ++i
)
4880 for (p
= ct_table
[i
]; p
; p
= p
->next
)
4881 colors
[j
++] = p
->pixel
;
4887 #else /* COLOR_TABLE_SUPPORT */
4889 static unsigned long
4890 lookup_rgb_color (f
, r
, g
, b
)
4894 unsigned long pixel
;
4897 pixel
= RGB_TO_ULONG (r
>> 8, g
>> 8, b
>> 8);
4898 gamma_correct (f
, &pixel
);
4902 pixel
= PALETTERGB (r
>> 8, g
>> 8, b
>> 8);
4903 #endif /* HAVE_NTGUI */
4912 #endif /* COLOR_TABLE_SUPPORT */
4915 /***********************************************************************
4917 ***********************************************************************/
4919 static XColor
*x_to_xcolors
P_ ((struct frame
*, struct image
*, int));
4920 static void x_from_xcolors
P_ ((struct frame
*, struct image
*, XColor
*));
4921 static void x_detect_edges
P_ ((struct frame
*, struct image
*, int[9], int));
4924 static void XPutPixel (XImagePtr
, int, int, COLORREF
);
4925 #endif /* HAVE_NTGUI */
4927 /* Non-zero means draw a cross on images having `:conversion
4930 int cross_disabled_images
;
4932 /* Edge detection matrices for different edge-detection
4935 static int emboss_matrix
[9] = {
4937 2, -1, 0, /* y - 1 */
4939 0, 1, -2 /* y + 1 */
4942 static int laplace_matrix
[9] = {
4944 1, 0, 0, /* y - 1 */
4946 0, 0, -1 /* y + 1 */
4949 /* Value is the intensity of the color whose red/green/blue values
4952 #define COLOR_INTENSITY(R, G, B) ((2 * (R) + 3 * (G) + (B)) / 6)
4955 /* On frame F, return an array of XColor structures describing image
4956 IMG->pixmap. Each XColor structure has its pixel color set. RGB_P
4957 non-zero means also fill the red/green/blue members of the XColor
4958 structures. Value is a pointer to the array of XColors structures,
4959 allocated with xmalloc; it must be freed by the caller. */
4962 x_to_xcolors (f
, img
, rgb_p
)
4969 XImagePtr_or_DC ximg
;
4973 #endif /* HAVE_NTGUI */
4975 colors
= (XColor
*) xmalloc (img
->width
* img
->height
* sizeof *colors
);
4978 /* Get the X image IMG->pixmap. */
4979 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
4980 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
4982 /* Load the image into a memory device context. */
4983 hdc
= get_frame_dc (f
);
4984 ximg
= CreateCompatibleDC (hdc
);
4985 release_frame_dc (f
, hdc
);
4986 prev
= SelectObject (ximg
, img
->pixmap
);
4987 #endif /* HAVE_NTGUI */
4989 /* Fill the `pixel' members of the XColor array. I wished there
4990 were an easy and portable way to circumvent XGetPixel. */
4992 for (y
= 0; y
< img
->height
; ++y
)
4996 #ifdef HAVE_X_WINDOWS
4997 for (x
= 0; x
< img
->width
; ++x
, ++p
)
4998 p
->pixel
= XGetPixel (ximg
, x
, y
);
5000 x_query_colors (f
, row
, img
->width
);
5004 for (x
= 0; x
< img
->width
; ++x
, ++p
)
5006 /* W32_TODO: palette support needed here? */
5007 p
->pixel
= GET_PIXEL (ximg
, x
, y
);
5011 p
->red
= RED16_FROM_ULONG (p
->pixel
);
5012 p
->green
= GREEN16_FROM_ULONG (p
->pixel
);
5013 p
->blue
= BLUE16_FROM_ULONG (p
->pixel
);
5016 p
->red
= 256 * GetRValue (p
->pixel
);
5017 p
->green
= 256 * GetGValue (p
->pixel
);
5018 p
->blue
= 256 * GetBValue (p
->pixel
);
5019 #endif /* HAVE_NTGUI */
5022 #endif /* HAVE_X_WINDOWS */
5025 Destroy_Image (ximg
, prev
);
5032 /* Put a pixel of COLOR at position X, Y in XIMG. XIMG must have been
5033 created with CreateDIBSection, with the pointer to the bit values
5034 stored in ximg->data. */
5036 static void XPutPixel (ximg
, x
, y
, color
)
5041 int width
= ximg
->info
.bmiHeader
.biWidth
;
5042 int height
= ximg
->info
.bmiHeader
.biHeight
;
5043 unsigned char * pixel
;
5045 /* True color images. */
5046 if (ximg
->info
.bmiHeader
.biBitCount
== 24)
5048 int rowbytes
= width
* 3;
5049 /* Ensure scanlines are aligned on 4 byte boundaries. */
5051 rowbytes
+= 4 - (rowbytes
% 4);
5053 pixel
= ximg
->data
+ y
* rowbytes
+ x
* 3;
5054 /* Windows bitmaps are in BGR order. */
5055 *pixel
= GetBValue (color
);
5056 *(pixel
+ 1) = GetGValue (color
);
5057 *(pixel
+ 2) = GetRValue (color
);
5059 /* Monochrome images. */
5060 else if (ximg
->info
.bmiHeader
.biBitCount
== 1)
5062 int rowbytes
= width
/ 8;
5063 /* Ensure scanlines are aligned on 4 byte boundaries. */
5065 rowbytes
+= 4 - (rowbytes
% 4);
5066 pixel
= ximg
->data
+ y
* rowbytes
+ x
/ 8;
5067 /* Filter out palette info. */
5068 if (color
& 0x00ffffff)
5069 *pixel
= *pixel
| (1 << x
% 8);
5071 *pixel
= *pixel
& ~(1 << x
% 8);
5074 image_error ("XPutPixel: palette image not supported", Qnil
, Qnil
);
5077 #endif /* HAVE_NTGUI */
5079 /* Create IMG->pixmap from an array COLORS of XColor structures, whose
5080 RGB members are set. F is the frame on which this all happens.
5081 COLORS will be freed; an existing IMG->pixmap will be freed, too. */
5084 x_from_xcolors (f
, img
, colors
)
5094 init_color_table ();
5096 x_create_x_image_and_pixmap (f
, img
->width
, img
->height
, 0,
5099 for (y
= 0; y
< img
->height
; ++y
)
5100 for (x
= 0; x
< img
->width
; ++x
, ++p
)
5102 unsigned long pixel
;
5103 pixel
= lookup_rgb_color (f
, p
->red
, p
->green
, p
->blue
);
5104 XPutPixel (oimg
, x
, y
, pixel
);
5108 x_clear_image_1 (f
, img
, 1, 0, 1);
5110 x_put_x_image (f
, oimg
, pixmap
, img
->width
, img
->height
);
5111 x_destroy_x_image (oimg
);
5112 img
->pixmap
= pixmap
;
5113 #ifdef COLOR_TABLE_SUPPORT
5114 img
->colors
= colors_in_color_table (&img
->ncolors
);
5115 free_color_table ();
5116 #endif /* COLOR_TABLE_SUPPORT */
5120 /* On frame F, perform edge-detection on image IMG.
5122 MATRIX is a nine-element array specifying the transformation
5123 matrix. See emboss_matrix for an example.
5125 COLOR_ADJUST is a color adjustment added to each pixel of the
5129 x_detect_edges (f
, img
, matrix
, color_adjust
)
5132 int matrix
[9], color_adjust
;
5134 XColor
*colors
= x_to_xcolors (f
, img
, 1);
5138 for (i
= sum
= 0; i
< 9; ++i
)
5139 sum
+= abs (matrix
[i
]);
5141 #define COLOR(A, X, Y) ((A) + (Y) * img->width + (X))
5143 new = (XColor
*) xmalloc (img
->width
* img
->height
* sizeof *new);
5145 for (y
= 0; y
< img
->height
; ++y
)
5147 p
= COLOR (new, 0, y
);
5148 p
->red
= p
->green
= p
->blue
= 0xffff/2;
5149 p
= COLOR (new, img
->width
- 1, y
);
5150 p
->red
= p
->green
= p
->blue
= 0xffff/2;
5153 for (x
= 1; x
< img
->width
- 1; ++x
)
5155 p
= COLOR (new, x
, 0);
5156 p
->red
= p
->green
= p
->blue
= 0xffff/2;
5157 p
= COLOR (new, x
, img
->height
- 1);
5158 p
->red
= p
->green
= p
->blue
= 0xffff/2;
5161 for (y
= 1; y
< img
->height
- 1; ++y
)
5163 p
= COLOR (new, 1, y
);
5165 for (x
= 1; x
< img
->width
- 1; ++x
, ++p
)
5167 int r
, g
, b
, y1
, x1
;
5170 for (y1
= y
- 1; y1
< y
+ 2; ++y1
)
5171 for (x1
= x
- 1; x1
< x
+ 2; ++x1
, ++i
)
5174 XColor
*t
= COLOR (colors
, x1
, y1
);
5175 r
+= matrix
[i
] * t
->red
;
5176 g
+= matrix
[i
] * t
->green
;
5177 b
+= matrix
[i
] * t
->blue
;
5180 r
= (r
/ sum
+ color_adjust
) & 0xffff;
5181 g
= (g
/ sum
+ color_adjust
) & 0xffff;
5182 b
= (b
/ sum
+ color_adjust
) & 0xffff;
5183 p
->red
= p
->green
= p
->blue
= COLOR_INTENSITY (r
, g
, b
);
5188 x_from_xcolors (f
, img
, new);
5194 /* Perform the pre-defined `emboss' edge-detection on image IMG
5202 x_detect_edges (f
, img
, emboss_matrix
, 0xffff / 2);
5206 /* Transform image IMG which is used on frame F with a Laplace
5207 edge-detection algorithm. The result is an image that can be used
5208 to draw disabled buttons, for example. */
5215 x_detect_edges (f
, img
, laplace_matrix
, 45000);
5219 /* Perform edge-detection on image IMG on frame F, with specified
5220 transformation matrix MATRIX and color-adjustment COLOR_ADJUST.
5222 MATRIX must be either
5224 - a list of at least 9 numbers in row-major form
5225 - a vector of at least 9 numbers
5227 COLOR_ADJUST nil means use a default; otherwise it must be a
5231 x_edge_detection (f
, img
, matrix
, color_adjust
)
5234 Lisp_Object matrix
, color_adjust
;
5242 i
< 9 && CONSP (matrix
) && NUMBERP (XCAR (matrix
));
5243 ++i
, matrix
= XCDR (matrix
))
5244 trans
[i
] = XFLOATINT (XCAR (matrix
));
5246 else if (VECTORP (matrix
) && ASIZE (matrix
) >= 9)
5248 for (i
= 0; i
< 9 && NUMBERP (AREF (matrix
, i
)); ++i
)
5249 trans
[i
] = XFLOATINT (AREF (matrix
, i
));
5252 if (NILP (color_adjust
))
5253 color_adjust
= make_number (0xffff / 2);
5255 if (i
== 9 && NUMBERP (color_adjust
))
5256 x_detect_edges (f
, img
, trans
, (int) XFLOATINT (color_adjust
));
5260 /* Transform image IMG on frame F so that it looks disabled. */
5263 x_disable_image (f
, img
)
5267 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
5269 int n_planes
= dpyinfo
->n_planes
* dpyinfo
->n_cbits
;
5271 int n_planes
= dpyinfo
->n_planes
;
5272 #endif /* HAVE_NTGUI */
5276 /* Color (or grayscale). Convert to gray, and equalize. Just
5277 drawing such images with a stipple can look very odd, so
5278 we're using this method instead. */
5279 XColor
*colors
= x_to_xcolors (f
, img
, 1);
5281 const int h
= 15000;
5282 const int l
= 30000;
5284 for (p
= colors
, end
= colors
+ img
->width
* img
->height
;
5288 int i
= COLOR_INTENSITY (p
->red
, p
->green
, p
->blue
);
5289 int i2
= (0xffff - h
- l
) * i
/ 0xffff + l
;
5290 p
->red
= p
->green
= p
->blue
= i2
;
5293 x_from_xcolors (f
, img
, colors
);
5296 /* Draw a cross over the disabled image, if we must or if we
5298 if (n_planes
< 2 || cross_disabled_images
)
5301 Display
*dpy
= FRAME_X_DISPLAY (f
);
5305 #define MaskForeground(f) PIX_MASK_DRAW
5307 #define MaskForeground(f) WHITE_PIX_DEFAULT (f)
5310 gc
= XCreateGC (dpy
, img
->pixmap
, 0, NULL
);
5311 XSetForeground (dpy
, gc
, BLACK_PIX_DEFAULT (f
));
5312 XDrawLine (dpy
, img
->pixmap
, gc
, 0, 0,
5313 img
->width
- 1, img
->height
- 1);
5314 XDrawLine (dpy
, img
->pixmap
, gc
, 0, img
->height
- 1,
5320 gc
= XCreateGC (dpy
, img
->mask
, 0, NULL
);
5321 XSetForeground (dpy
, gc
, MaskForeground (f
));
5322 XDrawLine (dpy
, img
->mask
, gc
, 0, 0,
5323 img
->width
- 1, img
->height
- 1);
5324 XDrawLine (dpy
, img
->mask
, gc
, 0, img
->height
- 1,
5332 hdc
= get_frame_dc (f
);
5333 bmpdc
= CreateCompatibleDC (hdc
);
5334 release_frame_dc (f
, hdc
);
5336 prev
= SelectObject (bmpdc
, img
->pixmap
);
5338 SetTextColor (bmpdc
, BLACK_PIX_DEFAULT (f
));
5339 MoveToEx (bmpdc
, 0, 0, NULL
);
5340 LineTo (bmpdc
, img
->width
- 1, img
->height
- 1);
5341 MoveToEx (bmpdc
, 0, img
->height
- 1, NULL
);
5342 LineTo (bmpdc
, img
->width
- 1, 0);
5346 SelectObject (bmpdc
, img
->mask
);
5347 SetTextColor (bmpdc
, WHITE_PIX_DEFAULT (f
));
5348 MoveToEx (bmpdc
, 0, 0, NULL
);
5349 LineTo (bmpdc
, img
->width
- 1, img
->height
- 1);
5350 MoveToEx (bmpdc
, 0, img
->height
- 1, NULL
);
5351 LineTo (bmpdc
, img
->width
- 1, 0);
5353 SelectObject (bmpdc
, prev
);
5355 #endif /* HAVE_NTGUI */
5360 /* Build a mask for image IMG which is used on frame F. FILE is the
5361 name of an image file, for error messages. HOW determines how to
5362 determine the background color of IMG. If it is a list '(R G B)',
5363 with R, G, and B being integers >= 0, take that as the color of the
5364 background. Otherwise, determine the background color of IMG
5365 heuristically. Value is non-zero if successful. */
5368 x_build_heuristic_mask (f
, img
, how
)
5373 XImagePtr_or_DC ximg
;
5381 #endif /* HAVE_NTGUI */
5382 int x
, y
, rc
, use_img_background
;
5383 unsigned long bg
= 0;
5387 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
5388 img
->mask
= NO_PIXMAP
;
5389 img
->background_transparent_valid
= 0;
5393 /* Create an image and pixmap serving as mask. */
5394 rc
= x_create_x_image_and_pixmap (f
, img
->width
, img
->height
, 1,
5395 &mask_img
, &img
->mask
);
5399 /* Get the X image of IMG->pixmap. */
5400 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
, 0, 0,
5401 img
->width
, img
->height
,
5404 /* Create the bit array serving as mask. */
5405 row_width
= (img
->width
+ 7) / 8;
5406 mask_img
= xmalloc (row_width
* img
->height
);
5407 bzero (mask_img
, row_width
* img
->height
);
5409 /* Create a memory device context for IMG->pixmap. */
5410 frame_dc
= get_frame_dc (f
);
5411 ximg
= CreateCompatibleDC (frame_dc
);
5412 release_frame_dc (f
, frame_dc
);
5413 prev
= SelectObject (ximg
, img
->pixmap
);
5414 #endif /* HAVE_NTGUI */
5416 /* Determine the background color of ximg. If HOW is `(R G B)'
5417 take that as color. Otherwise, use the image's background color. */
5418 use_img_background
= 1;
5424 for (i
= 0; i
< 3 && CONSP (how
) && NATNUMP (XCAR (how
)); ++i
)
5426 rgb
[i
] = XFASTINT (XCAR (how
)) & 0xffff;
5430 if (i
== 3 && NILP (how
))
5432 char color_name
[30];
5433 sprintf (color_name
, "#%04x%04x%04x", rgb
[0], rgb
[1], rgb
[2]);
5436 0x00ffffff & /* Filter out palette info. */
5437 #endif /* HAVE_NTGUI */
5438 x_alloc_image_color (f
, img
, build_string (color_name
), 0));
5439 use_img_background
= 0;
5443 if (use_img_background
)
5444 bg
= four_corners_best (ximg
, img
->corners
, img
->width
, img
->height
);
5446 /* Set all bits in mask_img to 1 whose color in ximg is different
5447 from the background color bg. */
5449 for (y
= 0; y
< img
->height
; ++y
)
5450 for (x
= 0; x
< img
->width
; ++x
)
5451 XPutPixel (mask_img
, x
, y
, (XGetPixel (ximg
, x
, y
) != bg
5452 ? PIX_MASK_DRAW
: PIX_MASK_RETAIN
));
5454 /* Fill in the background_transparent field while we have the mask handy. */
5455 image_background_transparent (img
, f
, mask_img
);
5457 /* Put mask_img into img->mask. */
5458 x_put_x_image (f
, mask_img
, img
->mask
, img
->width
, img
->height
);
5459 x_destroy_x_image (mask_img
);
5462 for (y
= 0; y
< img
->height
; ++y
)
5463 for (x
= 0; x
< img
->width
; ++x
)
5465 COLORREF p
= GetPixel (ximg
, x
, y
);
5467 mask_img
[y
* row_width
+ x
/ 8] |= 1 << (x
% 8);
5470 /* Create the mask image. */
5471 img
->mask
= w32_create_pixmap_from_bitmap_data (img
->width
, img
->height
,
5473 /* Fill in the background_transparent field while we have the mask handy. */
5474 SelectObject (ximg
, img
->mask
);
5475 image_background_transparent (img
, f
, ximg
);
5477 /* Was: x_destroy_x_image ((XImagePtr )mask_img); which seems bogus ++kfs */
5479 #endif /* HAVE_NTGUI */
5481 Destroy_Image (ximg
, prev
);
5487 /***********************************************************************
5488 PBM (mono, gray, color)
5489 ***********************************************************************/
5491 static int pbm_image_p
P_ ((Lisp_Object object
));
5492 static int pbm_load
P_ ((struct frame
*f
, struct image
*img
));
5493 static int pbm_scan_number
P_ ((unsigned char **, unsigned char *));
5495 /* The symbol `pbm' identifying images of this type. */
5499 /* Indices of image specification fields in gs_format, below. */
5501 enum pbm_keyword_index
5517 /* Vector of image_keyword structures describing the format
5518 of valid user-defined image specifications. */
5520 static struct image_keyword pbm_format
[PBM_LAST
] =
5522 {":type", IMAGE_SYMBOL_VALUE
, 1},
5523 {":file", IMAGE_STRING_VALUE
, 0},
5524 {":data", IMAGE_STRING_VALUE
, 0},
5525 {":ascent", IMAGE_ASCENT_VALUE
, 0},
5526 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
5527 {":relief", IMAGE_INTEGER_VALUE
, 0},
5528 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5529 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5530 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5531 {":foreground", IMAGE_STRING_OR_NIL_VALUE
, 0},
5532 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
5535 /* Structure describing the image type `pbm'. */
5537 static struct image_type pbm_type
=
5547 /* Return non-zero if OBJECT is a valid PBM image specification. */
5550 pbm_image_p (object
)
5553 struct image_keyword fmt
[PBM_LAST
];
5555 bcopy (pbm_format
, fmt
, sizeof fmt
);
5557 if (!parse_image_spec (object
, fmt
, PBM_LAST
, Qpbm
))
5560 /* Must specify either :data or :file. */
5561 return fmt
[PBM_DATA
].count
+ fmt
[PBM_FILE
].count
== 1;
5565 /* Scan a decimal number from *S and return it. Advance *S while
5566 reading the number. END is the end of the string. Value is -1 at
5570 pbm_scan_number (s
, end
)
5571 unsigned char **s
, *end
;
5573 int c
= 0, val
= -1;
5577 /* Skip white-space. */
5578 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
5583 /* Skip comment to end of line. */
5584 while (*s
< end
&& (c
= *(*s
)++, c
!= '\n'))
5587 else if (isdigit (c
))
5589 /* Read decimal number. */
5591 while (*s
< end
&& (c
= *(*s
)++, isdigit (c
)))
5592 val
= 10 * val
+ c
- '0';
5604 #if 0 /* Unused. ++kfs */
5606 /* Read FILE into memory. Value is a pointer to a buffer allocated
5607 with xmalloc holding FILE's contents. Value is null if an error
5608 occurred. *SIZE is set to the size of the file. */
5611 pbm_read_file (file
, size
)
5619 if (stat (SDATA (file
), &st
) == 0
5620 && (fp
= fopen (SDATA (file
), "rb")) != NULL
5621 && (buf
= (char *) xmalloc (st
.st_size
),
5622 fread (buf
, 1, st
.st_size
, fp
) == st
.st_size
))
5641 #endif /* HAVE_NTGUI */
5643 /* Load PBM image IMG for use on frame F. */
5651 int width
, height
, max_color_idx
= 0;
5653 Lisp_Object file
, specified_file
;
5654 enum {PBM_MONO
, PBM_GRAY
, PBM_COLOR
} type
;
5655 struct gcpro gcpro1
;
5656 unsigned char *contents
= NULL
;
5657 unsigned char *end
, *p
;
5660 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
5664 if (STRINGP (specified_file
))
5666 file
= x_find_image_file (specified_file
);
5667 if (!STRINGP (file
))
5669 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
5674 contents
= slurp_file (SDATA (file
), &size
);
5675 if (contents
== NULL
)
5677 image_error ("Error reading `%s'", file
, Qnil
);
5683 end
= contents
+ size
;
5688 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
5690 end
= p
+ SBYTES (data
);
5693 /* Check magic number. */
5694 if (end
- p
< 2 || *p
++ != 'P')
5696 image_error ("Not a PBM image: `%s'", img
->spec
, Qnil
);
5706 raw_p
= 0, type
= PBM_MONO
;
5710 raw_p
= 0, type
= PBM_GRAY
;
5714 raw_p
= 0, type
= PBM_COLOR
;
5718 raw_p
= 1, type
= PBM_MONO
;
5722 raw_p
= 1, type
= PBM_GRAY
;
5726 raw_p
= 1, type
= PBM_COLOR
;
5730 image_error ("Not a PBM image: `%s'", img
->spec
, Qnil
);
5734 /* Read width, height, maximum color-component. Characters
5735 starting with `#' up to the end of a line are ignored. */
5736 width
= pbm_scan_number (&p
, end
);
5737 height
= pbm_scan_number (&p
, end
);
5739 if (type
!= PBM_MONO
)
5741 max_color_idx
= pbm_scan_number (&p
, end
);
5742 if (raw_p
&& max_color_idx
> 255)
5743 max_color_idx
= 255;
5746 if (!check_image_size (f
, width
, height
)
5747 || (type
!= PBM_MONO
&& max_color_idx
< 0))
5750 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0,
5751 &ximg
, &img
->pixmap
))
5754 /* Initialize the color hash table. */
5755 init_color_table ();
5757 if (type
== PBM_MONO
)
5760 struct image_keyword fmt
[PBM_LAST
];
5761 unsigned long fg
= FRAME_FOREGROUND_PIXEL (f
);
5762 unsigned long bg
= FRAME_BACKGROUND_PIXEL (f
);
5764 /* Parse the image specification. */
5765 bcopy (pbm_format
, fmt
, sizeof fmt
);
5766 parse_image_spec (img
->spec
, fmt
, PBM_LAST
, Qpbm
);
5768 /* Get foreground and background colors, maybe allocate colors. */
5769 if (fmt
[PBM_FOREGROUND
].count
5770 && STRINGP (fmt
[PBM_FOREGROUND
].value
))
5771 fg
= x_alloc_image_color (f
, img
, fmt
[PBM_FOREGROUND
].value
, fg
);
5772 if (fmt
[PBM_BACKGROUND
].count
5773 && STRINGP (fmt
[PBM_BACKGROUND
].value
))
5775 bg
= x_alloc_image_color (f
, img
, fmt
[PBM_BACKGROUND
].value
, bg
);
5776 img
->background
= bg
;
5777 img
->background_valid
= 1;
5780 for (y
= 0; y
< height
; ++y
)
5781 for (x
= 0; x
< width
; ++x
)
5789 x_destroy_x_image (ximg
);
5790 x_clear_image (f
, img
);
5791 image_error ("Invalid image size in image `%s'",
5801 g
= pbm_scan_number (&p
, end
);
5803 XPutPixel (ximg
, x
, y
, g
? fg
: bg
);
5809 && ((type
== PBM_GRAY
)
5810 ? (p
+ height
* width
> end
)
5811 : (p
+ 3 * height
* width
> end
)))
5813 x_destroy_x_image (ximg
);
5814 x_clear_image (f
, img
);
5815 image_error ("Invalid image size in image `%s'",
5820 for (y
= 0; y
< height
; ++y
)
5821 for (x
= 0; x
< width
; ++x
)
5825 if (type
== PBM_GRAY
)
5826 r
= g
= b
= raw_p
? *p
++ : pbm_scan_number (&p
, end
);
5835 r
= pbm_scan_number (&p
, end
);
5836 g
= pbm_scan_number (&p
, end
);
5837 b
= pbm_scan_number (&p
, end
);
5840 if (r
< 0 || g
< 0 || b
< 0)
5842 x_destroy_x_image (ximg
);
5843 image_error ("Invalid pixel value in image `%s'",
5848 /* RGB values are now in the range 0..max_color_idx.
5849 Scale this to the range 0..0xffff supported by X. */
5850 r
= (double) r
* 65535 / max_color_idx
;
5851 g
= (double) g
* 65535 / max_color_idx
;
5852 b
= (double) b
* 65535 / max_color_idx
;
5853 XPutPixel (ximg
, x
, y
, lookup_rgb_color (f
, r
, g
, b
));
5857 #ifdef COLOR_TABLE_SUPPORT
5858 /* Store in IMG->colors the colors allocated for the image, and
5859 free the color table. */
5860 img
->colors
= colors_in_color_table (&img
->ncolors
);
5861 free_color_table ();
5862 #endif /* COLOR_TABLE_SUPPORT */
5865 img
->height
= height
;
5867 /* Maybe fill in the background field while we have ximg handy. */
5869 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
5870 /* Casting avoids a GCC warning. */
5871 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
5873 /* Put the image into a pixmap. */
5874 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
5875 x_destroy_x_image (ximg
);
5877 /* X and W32 versions did it here, MAC version above. ++kfs
5879 img->height = height; */
5887 /***********************************************************************
5889 ***********************************************************************/
5891 #if defined (HAVE_PNG) || defined (MAC_OS)
5893 /* Function prototypes. */
5895 static int png_image_p
P_ ((Lisp_Object object
));
5896 static int png_load
P_ ((struct frame
*f
, struct image
*img
));
5898 /* The symbol `png' identifying images of this type. */
5902 /* Indices of image specification fields in png_format, below. */
5904 enum png_keyword_index
5919 /* Vector of image_keyword structures describing the format
5920 of valid user-defined image specifications. */
5922 static struct image_keyword png_format
[PNG_LAST
] =
5924 {":type", IMAGE_SYMBOL_VALUE
, 1},
5925 {":data", IMAGE_STRING_VALUE
, 0},
5926 {":file", IMAGE_STRING_VALUE
, 0},
5927 {":ascent", IMAGE_ASCENT_VALUE
, 0},
5928 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
5929 {":relief", IMAGE_INTEGER_VALUE
, 0},
5930 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5931 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5932 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5933 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
5936 /* Structure describing the image type `png'. */
5938 static struct image_type png_type
=
5947 /* Return non-zero if OBJECT is a valid PNG image specification. */
5950 png_image_p (object
)
5953 struct image_keyword fmt
[PNG_LAST
];
5954 bcopy (png_format
, fmt
, sizeof fmt
);
5956 if (!parse_image_spec (object
, fmt
, PNG_LAST
, Qpng
))
5959 /* Must specify either the :data or :file keyword. */
5960 return fmt
[PNG_FILE
].count
+ fmt
[PNG_DATA
].count
== 1;
5963 #endif /* HAVE_PNG || MAC_OS */
5968 #if defined HAVE_LIBPNG_PNG_H
5969 # include <libpng/png.h>
5975 /* PNG library details. */
5977 DEF_IMGLIB_FN (png_get_io_ptr
);
5978 DEF_IMGLIB_FN (png_check_sig
);
5979 DEF_IMGLIB_FN (png_create_read_struct
);
5980 DEF_IMGLIB_FN (png_create_info_struct
);
5981 DEF_IMGLIB_FN (png_destroy_read_struct
);
5982 DEF_IMGLIB_FN (png_set_read_fn
);
5983 DEF_IMGLIB_FN (png_set_sig_bytes
);
5984 DEF_IMGLIB_FN (png_read_info
);
5985 DEF_IMGLIB_FN (png_get_IHDR
);
5986 DEF_IMGLIB_FN (png_get_valid
);
5987 DEF_IMGLIB_FN (png_set_strip_16
);
5988 DEF_IMGLIB_FN (png_set_expand
);
5989 DEF_IMGLIB_FN (png_set_gray_to_rgb
);
5990 DEF_IMGLIB_FN (png_set_background
);
5991 DEF_IMGLIB_FN (png_get_bKGD
);
5992 DEF_IMGLIB_FN (png_read_update_info
);
5993 DEF_IMGLIB_FN (png_get_channels
);
5994 DEF_IMGLIB_FN (png_get_rowbytes
);
5995 DEF_IMGLIB_FN (png_read_image
);
5996 DEF_IMGLIB_FN (png_read_end
);
5997 DEF_IMGLIB_FN (png_error
);
6000 init_png_functions (Lisp_Object libraries
)
6004 /* Try loading libpng under probable names. */
6005 if (!(library
= w32_delayed_load (libraries
, Qpng
)))
6008 LOAD_IMGLIB_FN (library
, png_get_io_ptr
);
6009 LOAD_IMGLIB_FN (library
, png_check_sig
);
6010 LOAD_IMGLIB_FN (library
, png_create_read_struct
);
6011 LOAD_IMGLIB_FN (library
, png_create_info_struct
);
6012 LOAD_IMGLIB_FN (library
, png_destroy_read_struct
);
6013 LOAD_IMGLIB_FN (library
, png_set_read_fn
);
6014 LOAD_IMGLIB_FN (library
, png_set_sig_bytes
);
6015 LOAD_IMGLIB_FN (library
, png_read_info
);
6016 LOAD_IMGLIB_FN (library
, png_get_IHDR
);
6017 LOAD_IMGLIB_FN (library
, png_get_valid
);
6018 LOAD_IMGLIB_FN (library
, png_set_strip_16
);
6019 LOAD_IMGLIB_FN (library
, png_set_expand
);
6020 LOAD_IMGLIB_FN (library
, png_set_gray_to_rgb
);
6021 LOAD_IMGLIB_FN (library
, png_set_background
);
6022 LOAD_IMGLIB_FN (library
, png_get_bKGD
);
6023 LOAD_IMGLIB_FN (library
, png_read_update_info
);
6024 LOAD_IMGLIB_FN (library
, png_get_channels
);
6025 LOAD_IMGLIB_FN (library
, png_get_rowbytes
);
6026 LOAD_IMGLIB_FN (library
, png_read_image
);
6027 LOAD_IMGLIB_FN (library
, png_read_end
);
6028 LOAD_IMGLIB_FN (library
, png_error
);
6033 #define fn_png_get_io_ptr png_get_io_ptr
6034 #define fn_png_check_sig png_check_sig
6035 #define fn_png_create_read_struct png_create_read_struct
6036 #define fn_png_create_info_struct png_create_info_struct
6037 #define fn_png_destroy_read_struct png_destroy_read_struct
6038 #define fn_png_set_read_fn png_set_read_fn
6039 #define fn_png_set_sig_bytes png_set_sig_bytes
6040 #define fn_png_read_info png_read_info
6041 #define fn_png_get_IHDR png_get_IHDR
6042 #define fn_png_get_valid png_get_valid
6043 #define fn_png_set_strip_16 png_set_strip_16
6044 #define fn_png_set_expand png_set_expand
6045 #define fn_png_set_gray_to_rgb png_set_gray_to_rgb
6046 #define fn_png_set_background png_set_background
6047 #define fn_png_get_bKGD png_get_bKGD
6048 #define fn_png_read_update_info png_read_update_info
6049 #define fn_png_get_channels png_get_channels
6050 #define fn_png_get_rowbytes png_get_rowbytes
6051 #define fn_png_read_image png_read_image
6052 #define fn_png_read_end png_read_end
6053 #define fn_png_error png_error
6055 #endif /* HAVE_NTGUI */
6057 /* Error and warning handlers installed when the PNG library
6061 my_png_error (png_ptr
, msg
)
6062 png_struct
*png_ptr
;
6065 xassert (png_ptr
!= NULL
);
6066 image_error ("PNG error: %s", build_string (msg
), Qnil
);
6067 longjmp (png_ptr
->jmpbuf
, 1);
6072 my_png_warning (png_ptr
, msg
)
6073 png_struct
*png_ptr
;
6076 xassert (png_ptr
!= NULL
);
6077 image_error ("PNG warning: %s", build_string (msg
), Qnil
);
6080 /* Memory source for PNG decoding. */
6082 struct png_memory_storage
6084 unsigned char *bytes
; /* The data */
6085 size_t len
; /* How big is it? */
6086 int index
; /* Where are we? */
6090 /* Function set as reader function when reading PNG image from memory.
6091 PNG_PTR is a pointer to the PNG control structure. Copy LENGTH
6092 bytes from the input to DATA. */
6095 png_read_from_memory (png_ptr
, data
, length
)
6096 png_structp png_ptr
;
6100 struct png_memory_storage
*tbr
6101 = (struct png_memory_storage
*) fn_png_get_io_ptr (png_ptr
);
6103 if (length
> tbr
->len
- tbr
->index
)
6104 fn_png_error (png_ptr
, "Read error");
6106 bcopy (tbr
->bytes
+ tbr
->index
, data
, length
);
6107 tbr
->index
= tbr
->index
+ length
;
6111 /* Function set as reader function when reading PNG image from a file.
6112 PNG_PTR is a pointer to the PNG control structure. Copy LENGTH
6113 bytes from the input to DATA. */
6116 png_read_from_file (png_ptr
, data
, length
)
6117 png_structp png_ptr
;
6121 FILE *fp
= (FILE *) fn_png_get_io_ptr (png_ptr
);
6123 if (fread (data
, 1, length
, fp
) < length
)
6124 fn_png_error (png_ptr
, "Read error");
6128 /* Load PNG image IMG for use on frame F. Value is non-zero if
6136 Lisp_Object file
, specified_file
;
6137 Lisp_Object specified_data
;
6139 XImagePtr ximg
, mask_img
= NULL
;
6140 struct gcpro gcpro1
;
6141 png_struct
*png_ptr
= NULL
;
6142 png_info
*info_ptr
= NULL
, *end_info
= NULL
;
6143 FILE *volatile fp
= NULL
;
6145 png_byte
* volatile pixels
= NULL
;
6146 png_byte
** volatile rows
= NULL
;
6147 png_uint_32 width
, height
;
6148 int bit_depth
, color_type
, interlace_type
;
6150 png_uint_32 row_bytes
;
6152 double screen_gamma
;
6153 struct png_memory_storage tbr
; /* Data to be read */
6155 /* Find out what file to load. */
6156 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
6157 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
6161 if (NILP (specified_data
))
6163 file
= x_find_image_file (specified_file
);
6164 if (!STRINGP (file
))
6166 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
6171 /* Open the image file. */
6172 fp
= fopen (SDATA (file
), "rb");
6175 image_error ("Cannot open image file `%s'", file
, Qnil
);
6180 /* Check PNG signature. */
6181 if (fread (sig
, 1, sizeof sig
, fp
) != sizeof sig
6182 || !fn_png_check_sig (sig
, sizeof sig
))
6184 image_error ("Not a PNG file: `%s'", file
, Qnil
);
6192 /* Read from memory. */
6193 tbr
.bytes
= SDATA (specified_data
);
6194 tbr
.len
= SBYTES (specified_data
);
6197 /* Check PNG signature. */
6198 if (tbr
.len
< sizeof sig
6199 || !fn_png_check_sig (tbr
.bytes
, sizeof sig
))
6201 image_error ("Not a PNG image: `%s'", img
->spec
, Qnil
);
6206 /* Need to skip past the signature. */
6207 tbr
.bytes
+= sizeof (sig
);
6210 /* Initialize read and info structs for PNG lib. Casting return
6211 value avoids a GCC warning on W32. */
6212 png_ptr
= (png_structp
)fn_png_create_read_struct (PNG_LIBPNG_VER_STRING
,
6217 if (fp
) fclose (fp
);
6222 /* Casting return value avoids a GCC warning on W32. */
6223 info_ptr
= (png_infop
)fn_png_create_info_struct (png_ptr
);
6226 fn_png_destroy_read_struct (&png_ptr
, NULL
, NULL
);
6227 if (fp
) fclose (fp
);
6232 /* Casting return value avoids a GCC warning on W32. */
6233 end_info
= (png_infop
)fn_png_create_info_struct (png_ptr
);
6236 fn_png_destroy_read_struct (&png_ptr
, &info_ptr
, NULL
);
6237 if (fp
) fclose (fp
);
6242 /* Set error jump-back. We come back here when the PNG library
6243 detects an error. */
6244 if (setjmp (png_ptr
->jmpbuf
))
6248 fn_png_destroy_read_struct (&png_ptr
, &info_ptr
, &end_info
);
6251 if (fp
) fclose (fp
);
6256 /* Read image info. */
6257 if (!NILP (specified_data
))
6258 fn_png_set_read_fn (png_ptr
, (void *) &tbr
, png_read_from_memory
);
6260 fn_png_set_read_fn (png_ptr
, (void *) fp
, png_read_from_file
);
6262 fn_png_set_sig_bytes (png_ptr
, sizeof sig
);
6263 fn_png_read_info (png_ptr
, info_ptr
);
6264 fn_png_get_IHDR (png_ptr
, info_ptr
, &width
, &height
, &bit_depth
, &color_type
,
6265 &interlace_type
, NULL
, NULL
);
6267 if (!check_image_size (f
, width
, height
))
6270 /* If image contains simply transparency data, we prefer to
6271 construct a clipping mask. */
6272 if (fn_png_get_valid (png_ptr
, info_ptr
, PNG_INFO_tRNS
))
6277 /* This function is easier to write if we only have to handle
6278 one data format: RGB or RGBA with 8 bits per channel. Let's
6279 transform other formats into that format. */
6281 /* Strip more than 8 bits per channel. */
6282 if (bit_depth
== 16)
6283 fn_png_set_strip_16 (png_ptr
);
6285 /* Expand data to 24 bit RGB, or 8 bit grayscale, with alpha channel
6287 fn_png_set_expand (png_ptr
);
6289 /* Convert grayscale images to RGB. */
6290 if (color_type
== PNG_COLOR_TYPE_GRAY
6291 || color_type
== PNG_COLOR_TYPE_GRAY_ALPHA
)
6292 fn_png_set_gray_to_rgb (png_ptr
);
6294 screen_gamma
= (f
->gamma
? 1 / f
->gamma
/ 0.45455 : 2.2);
6296 #if 0 /* Avoid double gamma correction for PNG images. */
6297 { /* Tell the PNG lib to handle gamma correction for us. */
6300 #if defined(PNG_READ_sRGB_SUPPORTED) || defined(PNG_WRITE_sRGB_SUPPORTED)
6301 if (png_get_sRGB (png_ptr
, info_ptr
, &intent
))
6302 /* The libpng documentation says this is right in this case. */
6303 png_set_gamma (png_ptr
, screen_gamma
, 0.45455);
6306 if (png_get_gAMA (png_ptr
, info_ptr
, &image_gamma
))
6307 /* Image contains gamma information. */
6308 png_set_gamma (png_ptr
, screen_gamma
, image_gamma
);
6310 /* Use the standard default for the image gamma. */
6311 png_set_gamma (png_ptr
, screen_gamma
, 0.45455);
6315 /* Handle alpha channel by combining the image with a background
6316 color. Do this only if a real alpha channel is supplied. For
6317 simple transparency, we prefer a clipping mask. */
6320 png_color_16
*image_bg
;
6321 Lisp_Object specified_bg
6322 = image_spec_value (img
->spec
, QCbackground
, NULL
);
6324 if (STRINGP (specified_bg
))
6325 /* The user specified `:background', use that. */
6327 /* W32 version incorrectly used COLORREF here!! ++kfs */
6329 if (x_defined_color (f
, SDATA (specified_bg
), &color
, 0))
6331 png_color_16 user_bg
;
6333 bzero (&user_bg
, sizeof user_bg
);
6334 user_bg
.red
= color
.red
>> 8;
6335 user_bg
.green
= color
.green
>> 8;
6336 user_bg
.blue
= color
.blue
>> 8;
6338 fn_png_set_background (png_ptr
, &user_bg
,
6339 PNG_BACKGROUND_GAMMA_SCREEN
, 0, 1.0);
6342 else if (fn_png_get_bKGD (png_ptr
, info_ptr
, &image_bg
))
6343 /* Image contains a background color with which to
6344 combine the image. */
6345 fn_png_set_background (png_ptr
, image_bg
,
6346 PNG_BACKGROUND_GAMMA_FILE
, 1, 1.0);
6349 /* Image does not contain a background color with which
6350 to combine the image data via an alpha channel. Use
6351 the frame's background instead. */
6352 #ifdef HAVE_X_WINDOWS
6354 png_color_16 frame_background
;
6356 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
6357 x_query_color (f
, &color
);
6359 bzero (&frame_background
, sizeof frame_background
);
6360 frame_background
.red
= color
.red
>> 8;
6361 frame_background
.green
= color
.green
>> 8;
6362 frame_background
.blue
= color
.blue
>> 8;
6363 #endif /* HAVE_X_WINDOWS */
6367 png_color_16 frame_background
;
6368 color
= FRAME_BACKGROUND_PIXEL (f
);
6369 #if 0 /* W32 TODO : Colormap support. */
6370 x_query_color (f
, &color
);
6372 bzero (&frame_background
, sizeof frame_background
);
6373 frame_background
.red
= GetRValue (color
);
6374 frame_background
.green
= GetGValue (color
);
6375 frame_background
.blue
= GetBValue (color
);
6376 #endif /* HAVE_NTGUI */
6379 unsigned long color
;
6380 png_color_16 frame_background
;
6381 color
= FRAME_BACKGROUND_PIXEL (f
);
6382 #if 0 /* MAC/W32 TODO : Colormap support. */
6383 x_query_color (f
, &color
);
6385 bzero (&frame_background
, sizeof frame_background
);
6386 frame_background
.red
= RED_FROM_ULONG (color
);
6387 frame_background
.green
= GREEN_FROM_ULONG (color
);
6388 frame_background
.blue
= BLUE_FROM_ULONG (color
);
6391 fn_png_set_background (png_ptr
, &frame_background
,
6392 PNG_BACKGROUND_GAMMA_SCREEN
, 0, 1.0);
6396 /* Update info structure. */
6397 fn_png_read_update_info (png_ptr
, info_ptr
);
6399 /* Get number of channels. Valid values are 1 for grayscale images
6400 and images with a palette, 2 for grayscale images with transparency
6401 information (alpha channel), 3 for RGB images, and 4 for RGB
6402 images with alpha channel, i.e. RGBA. If conversions above were
6403 sufficient we should only have 3 or 4 channels here. */
6404 channels
= fn_png_get_channels (png_ptr
, info_ptr
);
6405 xassert (channels
== 3 || channels
== 4);
6407 /* Number of bytes needed for one row of the image. */
6408 row_bytes
= fn_png_get_rowbytes (png_ptr
, info_ptr
);
6410 /* Allocate memory for the image. */
6411 pixels
= (png_byte
*) xmalloc (row_bytes
* height
* sizeof *pixels
);
6412 rows
= (png_byte
**) xmalloc (height
* sizeof *rows
);
6413 for (i
= 0; i
< height
; ++i
)
6414 rows
[i
] = pixels
+ i
* row_bytes
;
6416 /* Read the entire image. */
6417 fn_png_read_image (png_ptr
, rows
);
6418 fn_png_read_end (png_ptr
, info_ptr
);
6425 /* Create the X image and pixmap. */
6426 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
,
6430 /* Create an image and pixmap serving as mask if the PNG image
6431 contains an alpha channel. */
6434 && !x_create_x_image_and_pixmap (f
, width
, height
, 1,
6435 &mask_img
, &img
->mask
))
6437 x_destroy_x_image (ximg
);
6438 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->pixmap
);
6439 img
->pixmap
= NO_PIXMAP
;
6443 /* Fill the X image and mask from PNG data. */
6444 init_color_table ();
6446 for (y
= 0; y
< height
; ++y
)
6448 png_byte
*p
= rows
[y
];
6450 for (x
= 0; x
< width
; ++x
)
6457 XPutPixel (ximg
, x
, y
, lookup_rgb_color (f
, r
, g
, b
));
6458 /* An alpha channel, aka mask channel, associates variable
6459 transparency with an image. Where other image formats
6460 support binary transparency---fully transparent or fully
6461 opaque---PNG allows up to 254 levels of partial transparency.
6462 The PNG library implements partial transparency by combining
6463 the image with a specified background color.
6465 I'm not sure how to handle this here nicely: because the
6466 background on which the image is displayed may change, for
6467 real alpha channel support, it would be necessary to create
6468 a new image for each possible background.
6470 What I'm doing now is that a mask is created if we have
6471 boolean transparency information. Otherwise I'm using
6472 the frame's background color to combine the image with. */
6477 XPutPixel (mask_img
, x
, y
, *p
> 0 ? PIX_MASK_DRAW
: PIX_MASK_RETAIN
);
6483 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
6484 /* Set IMG's background color from the PNG image, unless the user
6488 if (fn_png_get_bKGD (png_ptr
, info_ptr
, &bg
))
6490 img
->background
= lookup_rgb_color (f
, bg
->red
, bg
->green
, bg
->blue
);
6491 img
->background_valid
= 1;
6495 #ifdef COLOR_TABLE_SUPPORT
6496 /* Remember colors allocated for this image. */
6497 img
->colors
= colors_in_color_table (&img
->ncolors
);
6498 free_color_table ();
6499 #endif /* COLOR_TABLE_SUPPORT */
6502 fn_png_destroy_read_struct (&png_ptr
, &info_ptr
, &end_info
);
6507 img
->height
= height
;
6509 /* Maybe fill in the background field while we have ximg handy.
6510 Casting avoids a GCC warning. */
6511 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
6513 /* Put the image into the pixmap, then free the X image and its buffer. */
6514 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
6515 x_destroy_x_image (ximg
);
6517 /* Same for the mask. */
6520 /* Fill in the background_transparent field while we have the
6521 mask handy. Casting avoids a GCC warning. */
6522 image_background_transparent (img
, f
, (XImagePtr_or_DC
)mask_img
);
6524 x_put_x_image (f
, mask_img
, img
->mask
, img
->width
, img
->height
);
6525 x_destroy_x_image (mask_img
);
6532 #else /* HAVE_PNG */
6541 if (MyCGImageCreateWithPNGDataProvider
)
6542 return image_load_quartz2d (f
, img
, 1);
6545 return image_load_quicktime (f
, img
, kQTFileTypePNG
);
6549 #endif /* !HAVE_PNG */
6553 /***********************************************************************
6555 ***********************************************************************/
6557 #if defined (HAVE_JPEG) || defined (MAC_OS)
6559 static int jpeg_image_p
P_ ((Lisp_Object object
));
6560 static int jpeg_load
P_ ((struct frame
*f
, struct image
*img
));
6562 /* The symbol `jpeg' identifying images of this type. */
6566 /* Indices of image specification fields in gs_format, below. */
6568 enum jpeg_keyword_index
6577 JPEG_HEURISTIC_MASK
,
6583 /* Vector of image_keyword structures describing the format
6584 of valid user-defined image specifications. */
6586 static struct image_keyword jpeg_format
[JPEG_LAST
] =
6588 {":type", IMAGE_SYMBOL_VALUE
, 1},
6589 {":data", IMAGE_STRING_VALUE
, 0},
6590 {":file", IMAGE_STRING_VALUE
, 0},
6591 {":ascent", IMAGE_ASCENT_VALUE
, 0},
6592 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
6593 {":relief", IMAGE_INTEGER_VALUE
, 0},
6594 {":conversions", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6595 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6596 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6597 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
6600 /* Structure describing the image type `jpeg'. */
6602 static struct image_type jpeg_type
=
6611 /* Return non-zero if OBJECT is a valid JPEG image specification. */
6614 jpeg_image_p (object
)
6617 struct image_keyword fmt
[JPEG_LAST
];
6619 bcopy (jpeg_format
, fmt
, sizeof fmt
);
6621 if (!parse_image_spec (object
, fmt
, JPEG_LAST
, Qjpeg
))
6624 /* Must specify either the :data or :file keyword. */
6625 return fmt
[JPEG_FILE
].count
+ fmt
[JPEG_DATA
].count
== 1;
6628 #endif /* HAVE_JPEG || MAC_OS */
6632 /* Work around a warning about HAVE_STDLIB_H being redefined in
6634 #ifdef HAVE_STDLIB_H
6635 #define HAVE_STDLIB_H_1
6636 #undef HAVE_STDLIB_H
6637 #endif /* HAVE_STLIB_H */
6639 #if defined (HAVE_NTGUI) && !defined (__WIN32__)
6640 /* In older releases of the jpeg library, jpeglib.h will define boolean
6641 differently depending on __WIN32__, so make sure it is defined. */
6645 #include <jpeglib.h>
6649 #ifdef HAVE_STLIB_H_1
6650 #define HAVE_STDLIB_H 1
6655 /* JPEG library details. */
6656 DEF_IMGLIB_FN (jpeg_CreateDecompress
);
6657 DEF_IMGLIB_FN (jpeg_start_decompress
);
6658 DEF_IMGLIB_FN (jpeg_finish_decompress
);
6659 DEF_IMGLIB_FN (jpeg_destroy_decompress
);
6660 DEF_IMGLIB_FN (jpeg_read_header
);
6661 DEF_IMGLIB_FN (jpeg_read_scanlines
);
6662 DEF_IMGLIB_FN (jpeg_std_error
);
6663 DEF_IMGLIB_FN (jpeg_resync_to_restart
);
6666 init_jpeg_functions (Lisp_Object libraries
)
6670 if (!(library
= w32_delayed_load (libraries
, Qjpeg
)))
6673 LOAD_IMGLIB_FN (library
, jpeg_finish_decompress
);
6674 LOAD_IMGLIB_FN (library
, jpeg_read_scanlines
);
6675 LOAD_IMGLIB_FN (library
, jpeg_start_decompress
);
6676 LOAD_IMGLIB_FN (library
, jpeg_read_header
);
6677 LOAD_IMGLIB_FN (library
, jpeg_CreateDecompress
);
6678 LOAD_IMGLIB_FN (library
, jpeg_destroy_decompress
);
6679 LOAD_IMGLIB_FN (library
, jpeg_std_error
);
6680 LOAD_IMGLIB_FN (library
, jpeg_resync_to_restart
);
6684 /* Wrapper since we can't directly assign the function pointer
6685 to another function pointer that was declared more completely easily. */
6687 jpeg_resync_to_restart_wrapper(cinfo
, desired
)
6688 j_decompress_ptr cinfo
;
6691 return fn_jpeg_resync_to_restart (cinfo
, desired
);
6696 #define fn_jpeg_CreateDecompress(a,b,c) jpeg_create_decompress(a)
6697 #define fn_jpeg_start_decompress jpeg_start_decompress
6698 #define fn_jpeg_finish_decompress jpeg_finish_decompress
6699 #define fn_jpeg_destroy_decompress jpeg_destroy_decompress
6700 #define fn_jpeg_read_header jpeg_read_header
6701 #define fn_jpeg_read_scanlines jpeg_read_scanlines
6702 #define fn_jpeg_std_error jpeg_std_error
6703 #define jpeg_resync_to_restart_wrapper jpeg_resync_to_restart
6705 #endif /* HAVE_NTGUI */
6707 struct my_jpeg_error_mgr
6709 struct jpeg_error_mgr pub
;
6710 jmp_buf setjmp_buffer
;
6715 my_error_exit (cinfo
)
6718 struct my_jpeg_error_mgr
*mgr
= (struct my_jpeg_error_mgr
*) cinfo
->err
;
6719 longjmp (mgr
->setjmp_buffer
, 1);
6723 /* Init source method for JPEG data source manager. Called by
6724 jpeg_read_header() before any data is actually read. See
6725 libjpeg.doc from the JPEG lib distribution. */
6728 our_common_init_source (cinfo
)
6729 j_decompress_ptr cinfo
;
6734 /* Method to terminate data source. Called by
6735 jpeg_finish_decompress() after all data has been processed. */
6738 our_common_term_source (cinfo
)
6739 j_decompress_ptr cinfo
;
6744 /* Fill input buffer method for JPEG data source manager. Called
6745 whenever more data is needed. We read the whole image in one step,
6746 so this only adds a fake end of input marker at the end. */
6749 our_memory_fill_input_buffer (cinfo
)
6750 j_decompress_ptr cinfo
;
6752 /* Insert a fake EOI marker. */
6753 struct jpeg_source_mgr
*src
= cinfo
->src
;
6754 static JOCTET buffer
[2];
6756 buffer
[0] = (JOCTET
) 0xFF;
6757 buffer
[1] = (JOCTET
) JPEG_EOI
;
6759 src
->next_input_byte
= buffer
;
6760 src
->bytes_in_buffer
= 2;
6765 /* Method to skip over NUM_BYTES bytes in the image data. CINFO->src
6766 is the JPEG data source manager. */
6769 our_memory_skip_input_data (cinfo
, num_bytes
)
6770 j_decompress_ptr cinfo
;
6773 struct jpeg_source_mgr
*src
= (struct jpeg_source_mgr
*) cinfo
->src
;
6777 if (num_bytes
> src
->bytes_in_buffer
)
6778 ERREXIT (cinfo
, JERR_INPUT_EOF
);
6780 src
->bytes_in_buffer
-= num_bytes
;
6781 src
->next_input_byte
+= num_bytes
;
6786 /* Set up the JPEG lib for reading an image from DATA which contains
6787 LEN bytes. CINFO is the decompression info structure created for
6788 reading the image. */
6791 jpeg_memory_src (cinfo
, data
, len
)
6792 j_decompress_ptr cinfo
;
6796 struct jpeg_source_mgr
*src
;
6798 if (cinfo
->src
== NULL
)
6800 /* First time for this JPEG object? */
6801 cinfo
->src
= (struct jpeg_source_mgr
*)
6802 (*cinfo
->mem
->alloc_small
) ((j_common_ptr
) cinfo
, JPOOL_PERMANENT
,
6803 sizeof (struct jpeg_source_mgr
));
6804 src
= (struct jpeg_source_mgr
*) cinfo
->src
;
6805 src
->next_input_byte
= data
;
6808 src
= (struct jpeg_source_mgr
*) cinfo
->src
;
6809 src
->init_source
= our_common_init_source
;
6810 src
->fill_input_buffer
= our_memory_fill_input_buffer
;
6811 src
->skip_input_data
= our_memory_skip_input_data
;
6812 src
->resync_to_restart
= jpeg_resync_to_restart_wrapper
; /* Use default method. */
6813 src
->term_source
= our_common_term_source
;
6814 src
->bytes_in_buffer
= len
;
6815 src
->next_input_byte
= data
;
6819 struct jpeg_stdio_mgr
6821 struct jpeg_source_mgr mgr
;
6828 /* Size of buffer to read JPEG from file.
6829 Not too big, as we want to use alloc_small. */
6830 #define JPEG_STDIO_BUFFER_SIZE 8192
6833 /* Fill input buffer method for JPEG data source manager. Called
6834 whenever more data is needed. The data is read from a FILE *. */
6837 our_stdio_fill_input_buffer (cinfo
)
6838 j_decompress_ptr cinfo
;
6840 struct jpeg_stdio_mgr
*src
;
6842 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6847 bytes
= fread (src
->buffer
, 1, JPEG_STDIO_BUFFER_SIZE
, src
->file
);
6849 src
->mgr
.bytes_in_buffer
= bytes
;
6852 WARNMS (cinfo
, JWRN_JPEG_EOF
);
6854 src
->buffer
[0] = (JOCTET
) 0xFF;
6855 src
->buffer
[1] = (JOCTET
) JPEG_EOI
;
6856 src
->mgr
.bytes_in_buffer
= 2;
6858 src
->mgr
.next_input_byte
= src
->buffer
;
6865 /* Method to skip over NUM_BYTES bytes in the image data. CINFO->src
6866 is the JPEG data source manager. */
6869 our_stdio_skip_input_data (cinfo
, num_bytes
)
6870 j_decompress_ptr cinfo
;
6873 struct jpeg_stdio_mgr
*src
;
6874 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6876 while (num_bytes
> 0 && !src
->finished
)
6878 if (num_bytes
<= src
->mgr
.bytes_in_buffer
)
6880 src
->mgr
.bytes_in_buffer
-= num_bytes
;
6881 src
->mgr
.next_input_byte
+= num_bytes
;
6886 num_bytes
-= src
->mgr
.bytes_in_buffer
;
6887 src
->mgr
.bytes_in_buffer
= 0;
6888 src
->mgr
.next_input_byte
= NULL
;
6890 our_stdio_fill_input_buffer (cinfo
);
6896 /* Set up the JPEG lib for reading an image from a FILE *.
6897 CINFO is the decompression info structure created for
6898 reading the image. */
6901 jpeg_file_src (cinfo
, fp
)
6902 j_decompress_ptr cinfo
;
6905 struct jpeg_stdio_mgr
*src
;
6907 if (cinfo
->src
!= NULL
)
6908 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6911 /* First time for this JPEG object? */
6912 cinfo
->src
= (struct jpeg_source_mgr
*)
6913 (*cinfo
->mem
->alloc_small
) ((j_common_ptr
) cinfo
, JPOOL_PERMANENT
,
6914 sizeof (struct jpeg_stdio_mgr
));
6915 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6916 src
->buffer
= (JOCTET
*)
6917 (*cinfo
->mem
->alloc_small
) ((j_common_ptr
) cinfo
, JPOOL_PERMANENT
,
6918 JPEG_STDIO_BUFFER_SIZE
);
6923 src
->mgr
.init_source
= our_common_init_source
;
6924 src
->mgr
.fill_input_buffer
= our_stdio_fill_input_buffer
;
6925 src
->mgr
.skip_input_data
= our_stdio_skip_input_data
;
6926 src
->mgr
.resync_to_restart
= jpeg_resync_to_restart_wrapper
; /* Use default method. */
6927 src
->mgr
.term_source
= our_common_term_source
;
6928 src
->mgr
.bytes_in_buffer
= 0;
6929 src
->mgr
.next_input_byte
= NULL
;
6933 /* Load image IMG for use on frame F. Patterned after example.c
6934 from the JPEG lib. */
6941 struct jpeg_decompress_struct cinfo
;
6942 struct my_jpeg_error_mgr mgr
;
6943 Lisp_Object file
, specified_file
;
6944 Lisp_Object specified_data
;
6945 FILE * volatile fp
= NULL
;
6947 int row_stride
, x
, y
;
6948 XImagePtr ximg
= NULL
;
6950 unsigned long *colors
;
6952 struct gcpro gcpro1
;
6954 /* Open the JPEG file. */
6955 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
6956 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
6960 if (NILP (specified_data
))
6962 file
= x_find_image_file (specified_file
);
6963 if (!STRINGP (file
))
6965 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
6970 fp
= fopen (SDATA (file
), "rb");
6973 image_error ("Cannot open `%s'", file
, Qnil
);
6979 /* Customize libjpeg's error handling to call my_error_exit when an
6980 error is detected. This function will perform a longjmp.
6981 Casting return value avoids a GCC warning on W32. */
6982 cinfo
.err
= (struct jpeg_error_mgr
*)fn_jpeg_std_error (&mgr
.pub
);
6983 mgr
.pub
.error_exit
= my_error_exit
;
6985 if ((rc
= setjmp (mgr
.setjmp_buffer
)) != 0)
6989 /* Called from my_error_exit. Display a JPEG error. */
6990 char buffer
[JMSG_LENGTH_MAX
];
6991 cinfo
.err
->format_message ((j_common_ptr
) &cinfo
, buffer
);
6992 image_error ("Error reading JPEG image `%s': %s", img
->spec
,
6993 build_string (buffer
));
6996 /* Close the input file and destroy the JPEG object. */
6998 fclose ((FILE *) fp
);
6999 fn_jpeg_destroy_decompress (&cinfo
);
7001 /* If we already have an XImage, free that. */
7002 x_destroy_x_image (ximg
);
7004 /* Free pixmap and colors. */
7005 x_clear_image (f
, img
);
7011 /* Create the JPEG decompression object. Let it read from fp.
7012 Read the JPEG image header. */
7013 fn_jpeg_CreateDecompress (&cinfo
, JPEG_LIB_VERSION
, sizeof (cinfo
));
7015 if (NILP (specified_data
))
7016 jpeg_file_src (&cinfo
, (FILE *) fp
);
7018 jpeg_memory_src (&cinfo
, SDATA (specified_data
),
7019 SBYTES (specified_data
));
7021 fn_jpeg_read_header (&cinfo
, 1);
7023 /* Customize decompression so that color quantization will be used.
7024 Start decompression. */
7025 cinfo
.quantize_colors
= 1;
7026 fn_jpeg_start_decompress (&cinfo
);
7027 width
= img
->width
= cinfo
.output_width
;
7028 height
= img
->height
= cinfo
.output_height
;
7030 if (!check_image_size (f
, width
, height
))
7032 image_error ("Invalid image size", Qnil
, Qnil
);
7033 longjmp (mgr
.setjmp_buffer
, 2);
7036 /* Create X image and pixmap. */
7037 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
7038 longjmp (mgr
.setjmp_buffer
, 2);
7040 /* Allocate colors. When color quantization is used,
7041 cinfo.actual_number_of_colors has been set with the number of
7042 colors generated, and cinfo.colormap is a two-dimensional array
7043 of color indices in the range 0..cinfo.actual_number_of_colors.
7044 No more than 255 colors will be generated. */
7048 if (cinfo
.out_color_components
> 2)
7049 ir
= 0, ig
= 1, ib
= 2;
7050 else if (cinfo
.out_color_components
> 1)
7051 ir
= 0, ig
= 1, ib
= 0;
7053 ir
= 0, ig
= 0, ib
= 0;
7055 /* Use the color table mechanism because it handles colors that
7056 cannot be allocated nicely. Such colors will be replaced with
7057 a default color, and we don't have to care about which colors
7058 can be freed safely, and which can't. */
7059 init_color_table ();
7060 colors
= (unsigned long *) alloca (cinfo
.actual_number_of_colors
7063 for (i
= 0; i
< cinfo
.actual_number_of_colors
; ++i
)
7065 /* Multiply RGB values with 255 because X expects RGB values
7066 in the range 0..0xffff. */
7067 int r
= cinfo
.colormap
[ir
][i
] << 8;
7068 int g
= cinfo
.colormap
[ig
][i
] << 8;
7069 int b
= cinfo
.colormap
[ib
][i
] << 8;
7070 colors
[i
] = lookup_rgb_color (f
, r
, g
, b
);
7073 #ifdef COLOR_TABLE_SUPPORT
7074 /* Remember those colors actually allocated. */
7075 img
->colors
= colors_in_color_table (&img
->ncolors
);
7076 free_color_table ();
7077 #endif /* COLOR_TABLE_SUPPORT */
7081 row_stride
= width
* cinfo
.output_components
;
7082 buffer
= cinfo
.mem
->alloc_sarray ((j_common_ptr
) &cinfo
, JPOOL_IMAGE
,
7084 for (y
= 0; y
< height
; ++y
)
7086 fn_jpeg_read_scanlines (&cinfo
, buffer
, 1);
7087 for (x
= 0; x
< cinfo
.output_width
; ++x
)
7088 XPutPixel (ximg
, x
, y
, colors
[buffer
[0][x
]]);
7092 fn_jpeg_finish_decompress (&cinfo
);
7093 fn_jpeg_destroy_decompress (&cinfo
);
7095 fclose ((FILE *) fp
);
7097 /* Maybe fill in the background field while we have ximg handy. */
7098 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
7099 /* Casting avoids a GCC warning. */
7100 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
7102 /* Put the image into the pixmap. */
7103 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
7104 x_destroy_x_image (ximg
);
7109 #else /* HAVE_JPEG */
7118 return image_load_quartz2d (f
, img
, 0);
7120 return image_load_quicktime (f
, img
, kQTFileTypeJPEG
);
7125 #endif /* !HAVE_JPEG */
7129 /***********************************************************************
7131 ***********************************************************************/
7133 #if defined (HAVE_TIFF) || defined (MAC_OS)
7135 static int tiff_image_p
P_ ((Lisp_Object object
));
7136 static int tiff_load
P_ ((struct frame
*f
, struct image
*img
));
7138 /* The symbol `tiff' identifying images of this type. */
7142 /* Indices of image specification fields in tiff_format, below. */
7144 enum tiff_keyword_index
7153 TIFF_HEURISTIC_MASK
,
7159 /* Vector of image_keyword structures describing the format
7160 of valid user-defined image specifications. */
7162 static struct image_keyword tiff_format
[TIFF_LAST
] =
7164 {":type", IMAGE_SYMBOL_VALUE
, 1},
7165 {":data", IMAGE_STRING_VALUE
, 0},
7166 {":file", IMAGE_STRING_VALUE
, 0},
7167 {":ascent", IMAGE_ASCENT_VALUE
, 0},
7168 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
7169 {":relief", IMAGE_INTEGER_VALUE
, 0},
7170 {":conversions", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7171 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7172 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7173 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
7176 /* Structure describing the image type `tiff'. */
7178 static struct image_type tiff_type
=
7187 /* Return non-zero if OBJECT is a valid TIFF image specification. */
7190 tiff_image_p (object
)
7193 struct image_keyword fmt
[TIFF_LAST
];
7194 bcopy (tiff_format
, fmt
, sizeof fmt
);
7196 if (!parse_image_spec (object
, fmt
, TIFF_LAST
, Qtiff
))
7199 /* Must specify either the :data or :file keyword. */
7200 return fmt
[TIFF_FILE
].count
+ fmt
[TIFF_DATA
].count
== 1;
7203 #endif /* HAVE_TIFF || MAC_OS */
7211 /* TIFF library details. */
7212 DEF_IMGLIB_FN (TIFFSetErrorHandler
);
7213 DEF_IMGLIB_FN (TIFFSetWarningHandler
);
7214 DEF_IMGLIB_FN (TIFFOpen
);
7215 DEF_IMGLIB_FN (TIFFClientOpen
);
7216 DEF_IMGLIB_FN (TIFFGetField
);
7217 DEF_IMGLIB_FN (TIFFReadRGBAImage
);
7218 DEF_IMGLIB_FN (TIFFClose
);
7221 init_tiff_functions (Lisp_Object libraries
)
7225 if (!(library
= w32_delayed_load (libraries
, Qtiff
)))
7228 LOAD_IMGLIB_FN (library
, TIFFSetErrorHandler
);
7229 LOAD_IMGLIB_FN (library
, TIFFSetWarningHandler
);
7230 LOAD_IMGLIB_FN (library
, TIFFOpen
);
7231 LOAD_IMGLIB_FN (library
, TIFFClientOpen
);
7232 LOAD_IMGLIB_FN (library
, TIFFGetField
);
7233 LOAD_IMGLIB_FN (library
, TIFFReadRGBAImage
);
7234 LOAD_IMGLIB_FN (library
, TIFFClose
);
7240 #define fn_TIFFSetErrorHandler TIFFSetErrorHandler
7241 #define fn_TIFFSetWarningHandler TIFFSetWarningHandler
7242 #define fn_TIFFOpen TIFFOpen
7243 #define fn_TIFFClientOpen TIFFClientOpen
7244 #define fn_TIFFGetField TIFFGetField
7245 #define fn_TIFFReadRGBAImage TIFFReadRGBAImage
7246 #define fn_TIFFClose TIFFClose
7248 #endif /* HAVE_NTGUI */
7251 /* Reading from a memory buffer for TIFF images Based on the PNG
7252 memory source, but we have to provide a lot of extra functions.
7255 We really only need to implement read and seek, but I am not
7256 convinced that the TIFF library is smart enough not to destroy
7257 itself if we only hand it the function pointers we need to
7262 unsigned char *bytes
;
7269 tiff_read_from_memory (data
, buf
, size
)
7274 tiff_memory_source
*src
= (tiff_memory_source
*) data
;
7276 if (size
> src
->len
- src
->index
)
7278 bcopy (src
->bytes
+ src
->index
, buf
, size
);
7284 tiff_write_from_memory (data
, buf
, size
)
7293 tiff_seek_in_memory (data
, off
, whence
)
7298 tiff_memory_source
*src
= (tiff_memory_source
*) data
;
7303 case SEEK_SET
: /* Go from beginning of source. */
7307 case SEEK_END
: /* Go from end of source. */
7308 idx
= src
->len
+ off
;
7311 case SEEK_CUR
: /* Go from current position. */
7312 idx
= src
->index
+ off
;
7315 default: /* Invalid `whence'. */
7319 if (idx
> src
->len
|| idx
< 0)
7327 tiff_close_memory (data
)
7335 tiff_mmap_memory (data
, pbase
, psize
)
7340 /* It is already _IN_ memory. */
7345 tiff_unmap_memory (data
, base
, size
)
7350 /* We don't need to do this. */
7354 tiff_size_of_memory (data
)
7357 return ((tiff_memory_source
*) data
)->len
;
7362 tiff_error_handler (title
, format
, ap
)
7363 const char *title
, *format
;
7369 len
= sprintf (buf
, "TIFF error: %s ", title
);
7370 vsprintf (buf
+ len
, format
, ap
);
7371 add_to_log (buf
, Qnil
, Qnil
);
7376 tiff_warning_handler (title
, format
, ap
)
7377 const char *title
, *format
;
7383 len
= sprintf (buf
, "TIFF warning: %s ", title
);
7384 vsprintf (buf
+ len
, format
, ap
);
7385 add_to_log (buf
, Qnil
, Qnil
);
7389 /* Load TIFF image IMG for use on frame F. Value is non-zero if
7397 Lisp_Object file
, specified_file
;
7398 Lisp_Object specified_data
;
7400 int width
, height
, x
, y
;
7404 struct gcpro gcpro1
;
7405 tiff_memory_source memsrc
;
7407 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
7408 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
7412 fn_TIFFSetErrorHandler (tiff_error_handler
);
7413 fn_TIFFSetWarningHandler (tiff_warning_handler
);
7415 if (NILP (specified_data
))
7417 /* Read from a file */
7418 file
= x_find_image_file (specified_file
);
7419 if (!STRINGP (file
))
7421 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
7426 /* Try to open the image file. Casting return value avoids a
7427 GCC warning on W32. */
7428 tiff
= (TIFF
*)fn_TIFFOpen (SDATA (file
), "r");
7431 image_error ("Cannot open `%s'", file
, Qnil
);
7438 /* Memory source! */
7439 memsrc
.bytes
= SDATA (specified_data
);
7440 memsrc
.len
= SBYTES (specified_data
);
7443 /* Casting return value avoids a GCC warning on W32. */
7444 tiff
= (TIFF
*)fn_TIFFClientOpen ("memory_source", "r", &memsrc
,
7445 (TIFFReadWriteProc
) tiff_read_from_memory
,
7446 (TIFFReadWriteProc
) tiff_write_from_memory
,
7447 tiff_seek_in_memory
,
7449 tiff_size_of_memory
,
7455 image_error ("Cannot open memory source for `%s'", img
->spec
, Qnil
);
7461 /* Get width and height of the image, and allocate a raster buffer
7462 of width x height 32-bit values. */
7463 fn_TIFFGetField (tiff
, TIFFTAG_IMAGEWIDTH
, &width
);
7464 fn_TIFFGetField (tiff
, TIFFTAG_IMAGELENGTH
, &height
);
7466 if (!check_image_size (f
, width
, height
))
7468 image_error ("Invalid image size", Qnil
, Qnil
);
7473 buf
= (uint32
*) xmalloc (width
* height
* sizeof *buf
);
7475 rc
= fn_TIFFReadRGBAImage (tiff
, width
, height
, buf
, 0);
7476 fn_TIFFClose (tiff
);
7479 image_error ("Error reading TIFF image `%s'", img
->spec
, Qnil
);
7485 /* Create the X image and pixmap. */
7486 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
7493 /* Initialize the color table. */
7494 init_color_table ();
7496 /* Process the pixel raster. Origin is in the lower-left corner. */
7497 for (y
= 0; y
< height
; ++y
)
7499 uint32
*row
= buf
+ y
* width
;
7501 for (x
= 0; x
< width
; ++x
)
7503 uint32 abgr
= row
[x
];
7504 int r
= TIFFGetR (abgr
) << 8;
7505 int g
= TIFFGetG (abgr
) << 8;
7506 int b
= TIFFGetB (abgr
) << 8;
7507 XPutPixel (ximg
, x
, height
- 1 - y
, lookup_rgb_color (f
, r
, g
, b
));
7511 #ifdef COLOR_TABLE_SUPPORT
7512 /* Remember the colors allocated for the image. Free the color table. */
7513 img
->colors
= colors_in_color_table (&img
->ncolors
);
7514 free_color_table ();
7515 #endif /* COLOR_TABLE_SUPPORT */
7518 img
->height
= height
;
7520 /* Maybe fill in the background field while we have ximg handy. */
7521 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
7522 /* Casting avoids a GCC warning on W32. */
7523 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
7525 /* Put the image into the pixmap, then free the X image and its buffer. */
7526 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
7527 x_destroy_x_image (ximg
);
7534 #else /* HAVE_TIFF */
7542 return image_load_quicktime (f
, img
, kQTFileTypeTIFF
);
7546 #endif /* !HAVE_TIFF */
7550 /***********************************************************************
7552 ***********************************************************************/
7554 #if defined (HAVE_GIF) || defined (MAC_OS)
7556 static int gif_image_p
P_ ((Lisp_Object object
));
7557 static int gif_load
P_ ((struct frame
*f
, struct image
*img
));
7558 static void gif_clear_image
P_ ((struct frame
*f
, struct image
*img
));
7560 /* The symbol `gif' identifying images of this type. */
7564 /* Indices of image specification fields in gif_format, below. */
7566 enum gif_keyword_index
7582 /* Vector of image_keyword structures describing the format
7583 of valid user-defined image specifications. */
7585 static struct image_keyword gif_format
[GIF_LAST
] =
7587 {":type", IMAGE_SYMBOL_VALUE
, 1},
7588 {":data", IMAGE_STRING_VALUE
, 0},
7589 {":file", IMAGE_STRING_VALUE
, 0},
7590 {":ascent", IMAGE_ASCENT_VALUE
, 0},
7591 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
7592 {":relief", IMAGE_INTEGER_VALUE
, 0},
7593 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7594 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7595 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7596 {":image", IMAGE_NON_NEGATIVE_INTEGER_VALUE
, 0},
7597 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
7600 /* Structure describing the image type `gif'. */
7602 static struct image_type gif_type
=
7611 /* Free X resources of GIF image IMG which is used on frame F. */
7614 gif_clear_image (f
, img
)
7618 /* IMG->data.ptr_val may contain extension data. */
7619 img
->data
.lisp_val
= Qnil
;
7620 x_clear_image (f
, img
);
7623 /* Return non-zero if OBJECT is a valid GIF image specification. */
7626 gif_image_p (object
)
7629 struct image_keyword fmt
[GIF_LAST
];
7630 bcopy (gif_format
, fmt
, sizeof fmt
);
7632 if (!parse_image_spec (object
, fmt
, GIF_LAST
, Qgif
))
7635 /* Must specify either the :data or :file keyword. */
7636 return fmt
[GIF_FILE
].count
+ fmt
[GIF_DATA
].count
== 1;
7639 #endif /* HAVE_GIF || MAC_OS */
7643 #if defined (HAVE_NTGUI) || defined (MAC_OS)
7644 /* winuser.h might define DrawText to DrawTextA or DrawTextW.
7645 Undefine before redefining to avoid a preprocessor warning. */
7649 /* avoid conflict with QuickdrawText.h */
7650 #define DrawText gif_DrawText
7651 #include <gif_lib.h>
7654 #else /* HAVE_NTGUI || MAC_OS */
7656 #include <gif_lib.h>
7658 #endif /* HAVE_NTGUI || MAC_OS */
7663 /* GIF library details. */
7664 DEF_IMGLIB_FN (DGifCloseFile
);
7665 DEF_IMGLIB_FN (DGifSlurp
);
7666 DEF_IMGLIB_FN (DGifOpen
);
7667 DEF_IMGLIB_FN (DGifOpenFileName
);
7670 init_gif_functions (Lisp_Object libraries
)
7674 if (!(library
= w32_delayed_load (libraries
, Qgif
)))
7677 LOAD_IMGLIB_FN (library
, DGifCloseFile
);
7678 LOAD_IMGLIB_FN (library
, DGifSlurp
);
7679 LOAD_IMGLIB_FN (library
, DGifOpen
);
7680 LOAD_IMGLIB_FN (library
, DGifOpenFileName
);
7686 #define fn_DGifCloseFile DGifCloseFile
7687 #define fn_DGifSlurp DGifSlurp
7688 #define fn_DGifOpen DGifOpen
7689 #define fn_DGifOpenFileName DGifOpenFileName
7691 #endif /* HAVE_NTGUI */
7693 /* Reading a GIF image from memory
7694 Based on the PNG memory stuff to a certain extent. */
7698 unsigned char *bytes
;
7704 /* Make the current memory source available to gif_read_from_memory.
7705 It's done this way because not all versions of libungif support
7706 a UserData field in the GifFileType structure. */
7707 static gif_memory_source
*current_gif_memory_src
;
7710 gif_read_from_memory (file
, buf
, len
)
7715 gif_memory_source
*src
= current_gif_memory_src
;
7717 if (len
> src
->len
- src
->index
)
7720 bcopy (src
->bytes
+ src
->index
, buf
, len
);
7726 /* Load GIF image IMG for use on frame F. Value is non-zero if
7734 Lisp_Object file
, specified_file
;
7735 Lisp_Object specified_data
;
7736 int rc
, width
, height
, x
, y
, i
;
7738 ColorMapObject
*gif_color_map
;
7739 unsigned long pixel_colors
[256];
7741 struct gcpro gcpro1
;
7743 int ino
, image_height
, image_width
;
7744 gif_memory_source memsrc
;
7745 unsigned char *raster
;
7747 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
7748 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
7752 if (NILP (specified_data
))
7754 file
= x_find_image_file (specified_file
);
7755 if (!STRINGP (file
))
7757 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
7762 /* Open the GIF file. Casting return value avoids a GCC warning
7764 gif
= (GifFileType
*)fn_DGifOpenFileName (SDATA (file
));
7767 image_error ("Cannot open `%s'", file
, Qnil
);
7774 /* Read from memory! */
7775 current_gif_memory_src
= &memsrc
;
7776 memsrc
.bytes
= SDATA (specified_data
);
7777 memsrc
.len
= SBYTES (specified_data
);
7780 /* Casting return value avoids a GCC warning on W32. */
7781 gif
= (GifFileType
*)fn_DGifOpen(&memsrc
, gif_read_from_memory
);
7784 image_error ("Cannot open memory source `%s'", img
->spec
, Qnil
);
7790 /* Before reading entire contents, check the declared image size. */
7791 if (!check_image_size (f
, gif
->SWidth
, gif
->SHeight
))
7793 image_error ("Invalid image size", Qnil
, Qnil
);
7794 fn_DGifCloseFile (gif
);
7799 /* Read entire contents. */
7800 rc
= fn_DGifSlurp (gif
);
7801 if (rc
== GIF_ERROR
)
7803 image_error ("Error reading `%s'", img
->spec
, Qnil
);
7804 fn_DGifCloseFile (gif
);
7809 image
= image_spec_value (img
->spec
, QCindex
, NULL
);
7810 ino
= INTEGERP (image
) ? XFASTINT (image
) : 0;
7811 if (ino
>= gif
->ImageCount
)
7813 image_error ("Invalid image number `%s' in image `%s'",
7815 fn_DGifCloseFile (gif
);
7820 img
->corners
[TOP_CORNER
] = gif
->SavedImages
[ino
].ImageDesc
.Top
;
7821 img
->corners
[LEFT_CORNER
] = gif
->SavedImages
[ino
].ImageDesc
.Left
;
7822 image_height
= gif
->SavedImages
[ino
].ImageDesc
.Height
;
7823 img
->corners
[BOT_CORNER
] = img
->corners
[TOP_CORNER
] + image_height
;
7824 image_width
= gif
->SavedImages
[ino
].ImageDesc
.Width
;
7825 img
->corners
[RIGHT_CORNER
] = img
->corners
[LEFT_CORNER
] + image_width
;
7827 width
= img
->width
= max (gif
->SWidth
,
7828 max (gif
->Image
.Left
+ gif
->Image
.Width
,
7829 img
->corners
[RIGHT_CORNER
]));
7830 height
= img
->height
= max (gif
->SHeight
,
7831 max (gif
->Image
.Top
+ gif
->Image
.Height
,
7832 img
->corners
[BOT_CORNER
]));
7834 if (!check_image_size (f
, width
, height
))
7836 image_error ("Invalid image size", Qnil
, Qnil
);
7837 fn_DGifCloseFile (gif
);
7842 /* Create the X image and pixmap. */
7843 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
7845 fn_DGifCloseFile (gif
);
7850 /* Allocate colors. */
7851 gif_color_map
= gif
->SavedImages
[ino
].ImageDesc
.ColorMap
;
7853 gif_color_map
= gif
->SColorMap
;
7854 init_color_table ();
7855 bzero (pixel_colors
, sizeof pixel_colors
);
7857 for (i
= 0; i
< gif_color_map
->ColorCount
; ++i
)
7859 int r
= gif_color_map
->Colors
[i
].Red
<< 8;
7860 int g
= gif_color_map
->Colors
[i
].Green
<< 8;
7861 int b
= gif_color_map
->Colors
[i
].Blue
<< 8;
7862 pixel_colors
[i
] = lookup_rgb_color (f
, r
, g
, b
);
7865 #ifdef COLOR_TABLE_SUPPORT
7866 img
->colors
= colors_in_color_table (&img
->ncolors
);
7867 free_color_table ();
7868 #endif /* COLOR_TABLE_SUPPORT */
7870 /* Clear the part of the screen image that are not covered by
7871 the image from the GIF file. Full animated GIF support
7872 requires more than can be done here (see the gif89 spec,
7873 disposal methods). Let's simply assume that the part
7874 not covered by a sub-image is in the frame's background color. */
7875 for (y
= 0; y
< img
->corners
[TOP_CORNER
]; ++y
)
7876 for (x
= 0; x
< width
; ++x
)
7877 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7879 for (y
= img
->corners
[BOT_CORNER
]; y
< height
; ++y
)
7880 for (x
= 0; x
< width
; ++x
)
7881 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7883 for (y
= img
->corners
[TOP_CORNER
]; y
< img
->corners
[BOT_CORNER
]; ++y
)
7885 for (x
= 0; x
< img
->corners
[LEFT_CORNER
]; ++x
)
7886 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7887 for (x
= img
->corners
[RIGHT_CORNER
]; x
< width
; ++x
)
7888 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7891 /* Read the GIF image into the X image. We use a local variable
7892 `raster' here because RasterBits below is a char *, and invites
7893 problems with bytes >= 0x80. */
7894 raster
= (unsigned char *) gif
->SavedImages
[ino
].RasterBits
;
7896 if (gif
->SavedImages
[ino
].ImageDesc
.Interlace
)
7898 static int interlace_start
[] = {0, 4, 2, 1};
7899 static int interlace_increment
[] = {8, 8, 4, 2};
7901 int row
= interlace_start
[0];
7905 for (y
= 0; y
< image_height
; y
++)
7907 if (row
>= image_height
)
7909 row
= interlace_start
[++pass
];
7910 while (row
>= image_height
)
7911 row
= interlace_start
[++pass
];
7914 for (x
= 0; x
< image_width
; x
++)
7916 int i
= raster
[(y
* image_width
) + x
];
7917 XPutPixel (ximg
, x
+ img
->corners
[LEFT_CORNER
],
7918 row
+ img
->corners
[TOP_CORNER
], pixel_colors
[i
]);
7921 row
+= interlace_increment
[pass
];
7926 for (y
= 0; y
< image_height
; ++y
)
7927 for (x
= 0; x
< image_width
; ++x
)
7929 int i
= raster
[y
* image_width
+ x
];
7930 XPutPixel (ximg
, x
+ img
->corners
[LEFT_CORNER
],
7931 y
+ img
->corners
[TOP_CORNER
], pixel_colors
[i
]);
7935 /* Save GIF image extension data for `image-extension-data'.
7936 Format is (count IMAGES FUNCTION "BYTES" ...). */
7937 img
->data
.lisp_val
= Qnil
;
7938 if (gif
->SavedImages
[ino
].ExtensionBlockCount
> 0)
7940 ExtensionBlock
*ext
= gif
->SavedImages
[ino
].ExtensionBlocks
;
7941 for (i
= 0; i
< gif
->SavedImages
[ino
].ExtensionBlockCount
; i
++, ext
++)
7942 /* Append (... FUNCTION "BYTES") */
7943 img
->data
.lisp_val
= Fcons (make_unibyte_string (ext
->Bytes
, ext
->ByteCount
),
7944 Fcons (make_number (ext
->Function
),
7945 img
->data
.lisp_val
));
7946 img
->data
.lisp_val
= Fnreverse (img
->data
.lisp_val
);
7948 if (gif
->ImageCount
> 1)
7949 img
->data
.lisp_val
= Fcons (Qcount
,
7950 Fcons (make_number (gif
->ImageCount
),
7951 img
->data
.lisp_val
));
7953 fn_DGifCloseFile (gif
);
7955 /* Maybe fill in the background field while we have ximg handy. */
7956 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
7957 /* Casting avoids a GCC warning. */
7958 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
7960 /* Put the image into the pixmap, then free the X image and its buffer. */
7961 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
7962 x_destroy_x_image (ximg
);
7968 #else /* !HAVE_GIF */
7976 Lisp_Object specified_file
, file
;
7977 Lisp_Object specified_data
;
7979 Boolean graphic_p
, movie_p
, prefer_graphic_p
;
7987 Lisp_Object specified_bg
;
7992 TimeScale time_scale
;
7993 TimeValue time
, duration
;
7998 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
7999 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
8001 /* Animated gifs use QuickTime Movie Toolbox. So initialize it here. */
8004 if (NILP (specified_data
))
8006 /* Read from a file */
8010 err
= find_image_fsspec (specified_file
, &file
, &fss
);
8014 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
8019 err
= CanQuickTimeOpenFile (&fss
, kQTFileTypeGIF
, 0,
8020 &graphic_p
, &movie_p
, &prefer_graphic_p
, 0);
8024 if (!graphic_p
&& !movie_p
)
8026 if (prefer_graphic_p
)
8027 return image_load_qt_1 (f
, img
, kQTFileTypeGIF
, &fss
, NULL
);
8028 err
= OpenMovieFile (&fss
, &refnum
, fsRdPerm
);
8031 err
= NewMovieFromFile (&movie
, refnum
, NULL
, NULL
, 0, NULL
);
8032 CloseMovieFile (refnum
);
8035 image_error ("Error reading `%s'", file
, Qnil
);
8041 /* Memory source! */
8043 long file_type_atom
[3];
8045 err
= PtrToHand (SDATA (specified_data
), &dh
, SBYTES (specified_data
));
8048 image_error ("Cannot allocate data handle for `%s'",
8053 file_type_atom
[0] = EndianU32_NtoB (sizeof (long) * 3);
8054 file_type_atom
[1] = EndianU32_NtoB (kDataRefExtensionMacOSFileType
);
8055 file_type_atom
[2] = EndianU32_NtoB (kQTFileTypeGIF
);
8056 err
= PtrToHand (&dh
, &dref
, sizeof (Handle
));
8059 err
= PtrAndHand ("\p", dref
, 1);
8061 err
= PtrAndHand (file_type_atom
, dref
, sizeof (long) * 3);
8064 image_error ("Cannot allocate handle data ref for `%s'", img
->spec
, Qnil
);
8067 err
= CanQuickTimeOpenDataRef (dref
, HandleDataHandlerSubType
, &graphic_p
,
8068 &movie_p
, &prefer_graphic_p
, 0);
8072 if (!graphic_p
&& !movie_p
)
8074 if (prefer_graphic_p
)
8078 DisposeHandle (dref
);
8079 success_p
= image_load_qt_1 (f
, img
, kQTFileTypeGIF
, NULL
, dh
);
8083 err
= NewMovieFromDataRef (&movie
, 0, NULL
, dref
,
8084 HandleDataHandlerSubType
);
8085 DisposeHandle (dref
);
8090 image
= image_spec_value (img
->spec
, QCindex
, NULL
);
8091 ino
= INTEGERP (image
) ? XFASTINT (image
) : 0;
8092 track
= GetMovieIndTrack (movie
, 1);
8093 media
= GetTrackMedia (track
);
8094 nsamples
= GetMediaSampleCount (media
);
8095 if (ino
>= nsamples
)
8097 image_error ("Invalid image number `%s' in image `%s'",
8101 time_scale
= GetMediaTimeScale (media
);
8103 specified_bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
8104 if (!STRINGP (specified_bg
) ||
8105 !mac_defined_color (f
, SDATA (specified_bg
), &color
, 0))
8107 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
8108 color
.red
= RED16_FROM_ULONG (color
.pixel
);
8109 color
.green
= GREEN16_FROM_ULONG (color
.pixel
);
8110 color
.blue
= BLUE16_FROM_ULONG (color
.pixel
);
8112 GetMovieBox (movie
, &rect
);
8113 width
= img
->width
= rect
.right
- rect
.left
;
8114 height
= img
->height
= rect
.bottom
- rect
.top
;
8115 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
8118 GetGWorld (&old_port
, &old_gdh
);
8119 SetGWorld (ximg
, NULL
);
8120 bg_color
.red
= color
.red
;
8121 bg_color
.green
= color
.green
;
8122 bg_color
.blue
= color
.blue
;
8123 RGBBackColor (&bg_color
);
8124 SetGWorld (old_port
, old_gdh
);
8125 SetMovieActive (movie
, 1);
8126 SetMovieGWorld (movie
, ximg
, NULL
);
8127 SampleNumToMediaTime (media
, ino
+ 1, &time
, &duration
);
8128 SetMovieTimeValue (movie
, time
);
8129 MoviesTask (movie
, 0L);
8130 DisposeTrackMedia (media
);
8131 DisposeMovieTrack (track
);
8132 DisposeMovie (movie
);
8136 /* Save GIF image extension data for `image-extension-data'.
8137 Format is (count IMAGES 0xf9 GRAPHIC_CONTROL_EXTENSION_BLOCK). */
8139 Lisp_Object gce
= make_uninit_string (4);
8140 int centisec
= ((float)duration
/ time_scale
) * 100.0f
+ 0.5f
;
8142 /* Fill the delay time field. */
8143 SSET (gce
, 1, centisec
& 0xff);
8144 SSET (gce
, 2, (centisec
>> 8) & 0xff);
8145 /* We don't know about other fields. */
8149 img
->data
.lisp_val
= list4 (Qcount
, make_number (nsamples
),
8150 make_number (0xf9), gce
);
8153 /* Maybe fill in the background field while we have ximg handy. */
8154 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
8155 IMAGE_BACKGROUND (img
, f
, ximg
);
8157 /* Put the image into the pixmap. */
8158 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
8159 x_destroy_x_image (ximg
);
8163 image_error ("Cannot open `%s'", file
, Qnil
);
8166 DisposeTrackMedia (media
);
8168 DisposeMovieTrack (track
);
8170 DisposeMovie (movie
);
8177 #endif /* HAVE_GIF */
8181 /***********************************************************************
8183 ***********************************************************************/
8185 #ifdef HAVE_X_WINDOWS
8186 #define HAVE_GHOSTSCRIPT 1
8187 #endif /* HAVE_X_WINDOWS */
8189 /* The symbol `postscript' identifying images of this type. */
8191 Lisp_Object Qpostscript
;
8193 #ifdef HAVE_GHOSTSCRIPT
8195 static int gs_image_p
P_ ((Lisp_Object object
));
8196 static int gs_load
P_ ((struct frame
*f
, struct image
*img
));
8197 static void gs_clear_image
P_ ((struct frame
*f
, struct image
*img
));
8199 /* Keyword symbols. */
8201 Lisp_Object QCloader
, QCbounding_box
, QCpt_width
, QCpt_height
;
8203 /* Indices of image specification fields in gs_format, below. */
8205 enum gs_keyword_index
8223 /* Vector of image_keyword structures describing the format
8224 of valid user-defined image specifications. */
8226 static struct image_keyword gs_format
[GS_LAST
] =
8228 {":type", IMAGE_SYMBOL_VALUE
, 1},
8229 {":pt-width", IMAGE_POSITIVE_INTEGER_VALUE
, 1},
8230 {":pt-height", IMAGE_POSITIVE_INTEGER_VALUE
, 1},
8231 {":file", IMAGE_STRING_VALUE
, 1},
8232 {":loader", IMAGE_FUNCTION_VALUE
, 0},
8233 {":bounding-box", IMAGE_DONT_CHECK_VALUE_TYPE
, 1},
8234 {":ascent", IMAGE_ASCENT_VALUE
, 0},
8235 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
8236 {":relief", IMAGE_INTEGER_VALUE
, 0},
8237 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8238 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8239 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8240 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
8243 /* Structure describing the image type `ghostscript'. */
8245 static struct image_type gs_type
=
8255 /* Free X resources of Ghostscript image IMG which is used on frame F. */
8258 gs_clear_image (f
, img
)
8262 /* IMG->data.ptr_val may contain a recorded colormap. */
8263 xfree (img
->data
.ptr_val
);
8264 x_clear_image (f
, img
);
8268 /* Return non-zero if OBJECT is a valid Ghostscript image
8275 struct image_keyword fmt
[GS_LAST
];
8279 bcopy (gs_format
, fmt
, sizeof fmt
);
8281 if (!parse_image_spec (object
, fmt
, GS_LAST
, Qpostscript
))
8284 /* Bounding box must be a list or vector containing 4 integers. */
8285 tem
= fmt
[GS_BOUNDING_BOX
].value
;
8288 for (i
= 0; i
< 4; ++i
, tem
= XCDR (tem
))
8289 if (!CONSP (tem
) || !INTEGERP (XCAR (tem
)))
8294 else if (VECTORP (tem
))
8296 if (XVECTOR (tem
)->size
!= 4)
8298 for (i
= 0; i
< 4; ++i
)
8299 if (!INTEGERP (XVECTOR (tem
)->contents
[i
]))
8309 /* Load Ghostscript image IMG for use on frame F. Value is non-zero
8318 Lisp_Object window_and_pixmap_id
= Qnil
, loader
, pt_height
, pt_width
;
8319 struct gcpro gcpro1
, gcpro2
;
8321 double in_width
, in_height
;
8322 Lisp_Object pixel_colors
= Qnil
;
8324 /* Compute pixel size of pixmap needed from the given size in the
8325 image specification. Sizes in the specification are in pt. 1 pt
8326 = 1/72 in, xdpi and ydpi are stored in the frame's X display
8328 pt_width
= image_spec_value (img
->spec
, QCpt_width
, NULL
);
8329 in_width
= XFASTINT (pt_width
) / 72.0;
8330 img
->width
= in_width
* FRAME_X_DISPLAY_INFO (f
)->resx
;
8331 pt_height
= image_spec_value (img
->spec
, QCpt_height
, NULL
);
8332 in_height
= XFASTINT (pt_height
) / 72.0;
8333 img
->height
= in_height
* FRAME_X_DISPLAY_INFO (f
)->resy
;
8335 if (!check_image_size (f
, img
->width
, img
->height
))
8337 image_error ("Invalid image size", Qnil
, Qnil
);
8341 /* Create the pixmap. */
8342 xassert (img
->pixmap
== NO_PIXMAP
);
8344 /* Only W32 version did BLOCK_INPUT here. ++kfs */
8346 img
->pixmap
= XCreatePixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
8347 img
->width
, img
->height
,
8348 DefaultDepthOfScreen (FRAME_X_SCREEN (f
)));
8353 image_error ("Unable to create pixmap for `%s'", img
->spec
, Qnil
);
8357 /* Call the loader to fill the pixmap. It returns a process object
8358 if successful. We do not record_unwind_protect here because
8359 other places in redisplay like calling window scroll functions
8360 don't either. Let the Lisp loader use `unwind-protect' instead. */
8361 GCPRO2 (window_and_pixmap_id
, pixel_colors
);
8363 sprintf (buffer
, "%lu %lu",
8364 (unsigned long) FRAME_X_WINDOW (f
),
8365 (unsigned long) img
->pixmap
);
8366 window_and_pixmap_id
= build_string (buffer
);
8368 sprintf (buffer
, "%lu %lu",
8369 FRAME_FOREGROUND_PIXEL (f
),
8370 FRAME_BACKGROUND_PIXEL (f
));
8371 pixel_colors
= build_string (buffer
);
8373 XSETFRAME (frame
, f
);
8374 loader
= image_spec_value (img
->spec
, QCloader
, NULL
);
8376 loader
= intern ("gs-load-image");
8378 img
->data
.lisp_val
= call6 (loader
, frame
, img
->spec
,
8379 make_number (img
->width
),
8380 make_number (img
->height
),
8381 window_and_pixmap_id
,
8384 return PROCESSP (img
->data
.lisp_val
);
8388 /* Kill the Ghostscript process that was started to fill PIXMAP on
8389 frame F. Called from XTread_socket when receiving an event
8390 telling Emacs that Ghostscript has finished drawing. */
8393 x_kill_gs_process (pixmap
, f
)
8397 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
8401 /* Find the image containing PIXMAP. */
8402 for (i
= 0; i
< c
->used
; ++i
)
8403 if (c
->images
[i
]->pixmap
== pixmap
)
8406 /* Should someone in between have cleared the image cache, for
8407 instance, give up. */
8411 /* Kill the GS process. We should have found PIXMAP in the image
8412 cache and its image should contain a process object. */
8414 xassert (PROCESSP (img
->data
.lisp_val
));
8415 Fkill_process (img
->data
.lisp_val
, Qnil
);
8416 img
->data
.lisp_val
= Qnil
;
8418 #if defined (HAVE_X_WINDOWS)
8420 /* On displays with a mutable colormap, figure out the colors
8421 allocated for the image by looking at the pixels of an XImage for
8423 class = FRAME_X_VISUAL (f
)->class;
8424 if (class != StaticColor
&& class != StaticGray
&& class != TrueColor
)
8430 /* Try to get an XImage for img->pixmep. */
8431 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
8432 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
8437 /* Initialize the color table. */
8438 init_color_table ();
8440 /* For each pixel of the image, look its color up in the
8441 color table. After having done so, the color table will
8442 contain an entry for each color used by the image. */
8443 for (y
= 0; y
< img
->height
; ++y
)
8444 for (x
= 0; x
< img
->width
; ++x
)
8446 unsigned long pixel
= XGetPixel (ximg
, x
, y
);
8447 lookup_pixel_color (f
, pixel
);
8450 /* Record colors in the image. Free color table and XImage. */
8451 #ifdef COLOR_TABLE_SUPPORT
8452 img
->colors
= colors_in_color_table (&img
->ncolors
);
8453 free_color_table ();
8455 XDestroyImage (ximg
);
8457 #if 0 /* This doesn't seem to be the case. If we free the colors
8458 here, we get a BadAccess later in x_clear_image when
8459 freeing the colors. */
8460 /* We have allocated colors once, but Ghostscript has also
8461 allocated colors on behalf of us. So, to get the
8462 reference counts right, free them once. */
8464 x_free_colors (f
, img
->colors
, img
->ncolors
);
8468 image_error ("Cannot get X image of `%s'; colors will not be freed",
8473 #endif /* HAVE_X_WINDOWS */
8475 /* Now that we have the pixmap, compute mask and transform the
8476 image if requested. */
8478 postprocess_image (f
, img
);
8482 #endif /* HAVE_GHOSTSCRIPT */
8485 /***********************************************************************
8487 ***********************************************************************/
8491 DEFUN ("imagep", Fimagep
, Simagep
, 1, 1, 0,
8492 doc
: /* Value is non-nil if SPEC is a valid image specification. */)
8496 return valid_image_p (spec
) ? Qt
: Qnil
;
8500 DEFUN ("lookup-image", Flookup_image
, Slookup_image
, 1, 1, 0, "")
8506 if (valid_image_p (spec
))
8507 id
= lookup_image (SELECTED_FRAME (), spec
);
8510 return make_number (id
);
8513 #endif /* GLYPH_DEBUG != 0 */
8516 /***********************************************************************
8518 ***********************************************************************/
8521 /* Image types that rely on external libraries are loaded dynamically
8522 if the library is available. */
8523 #define CHECK_LIB_AVAILABLE(image_type, init_lib_fn, libraries) \
8524 define_image_type (image_type, init_lib_fn (libraries))
8526 #define CHECK_LIB_AVAILABLE(image_type, init_lib_fn, libraries) \
8527 define_image_type (image_type, 1)
8528 #endif /* HAVE_NTGUI */
8530 DEFUN ("init-image-library", Finit_image_library
, Sinit_image_library
, 2, 2, 0,
8531 doc
: /* Initialize image library implementing image type TYPE.
8532 Return non-nil if TYPE is a supported image type.
8534 Image types pbm and xbm are prebuilt; other types are loaded here.
8535 Libraries to load are specified in alist LIBRARIES (usually, the value
8536 of `image-library-alist', which see). */)
8538 Lisp_Object type
, libraries
;
8542 /* Don't try to reload the library. */
8543 tested
= Fassq (type
, Vimage_type_cache
);
8545 return XCDR (tested
);
8547 #if defined (HAVE_XPM) || defined (MAC_OS)
8548 if (EQ (type
, Qxpm
))
8549 return CHECK_LIB_AVAILABLE (&xpm_type
, init_xpm_functions
, libraries
);
8552 #if defined (HAVE_JPEG) || defined (MAC_OS)
8553 if (EQ (type
, Qjpeg
))
8554 return CHECK_LIB_AVAILABLE (&jpeg_type
, init_jpeg_functions
, libraries
);
8557 #if defined (HAVE_TIFF) || defined (MAC_OS)
8558 if (EQ (type
, Qtiff
))
8559 return CHECK_LIB_AVAILABLE (&tiff_type
, init_tiff_functions
, libraries
);
8562 #if defined (HAVE_GIF) || defined (MAC_OS)
8563 if (EQ (type
, Qgif
))
8564 return CHECK_LIB_AVAILABLE (&gif_type
, init_gif_functions
, libraries
);
8567 #if defined (HAVE_PNG) || defined (MAC_OS)
8568 if (EQ (type
, Qpng
))
8569 return CHECK_LIB_AVAILABLE (&png_type
, init_png_functions
, libraries
);
8572 #ifdef HAVE_GHOSTSCRIPT
8573 if (EQ (type
, Qpostscript
))
8574 return CHECK_LIB_AVAILABLE (&gs_type
, init_gs_functions
, libraries
);
8577 /* If the type is not recognized, avoid testing it ever again. */
8578 CACHE_IMAGE_TYPE (type
, Qnil
);
8585 extern Lisp_Object Qrisky_local_variable
; /* Syms_of_xdisp has already run. */
8587 /* Initialize this only once, since that's what we do with Vimage_types
8588 and they are supposed to be in sync. Initializing here gives correct
8589 operation on GNU/Linux of calling dump-emacs after loading some images. */
8592 /* Must be defined now becase we're going to update it below, while
8593 defining the supported image types. */
8594 DEFVAR_LISP ("image-types", &Vimage_types
,
8595 doc
: /* List of potentially supported image types.
8596 Each element of the list is a symbol for a image type, like 'jpeg or 'png.
8597 To check whether it is really supported, use `image-type-available-p'. */);
8598 Vimage_types
= Qnil
;
8600 DEFVAR_LISP ("image-library-alist", &Vimage_library_alist
,
8601 doc
: /* Alist of image types vs external libraries needed to display them.
8603 Each element is a list (IMAGE-TYPE LIBRARY...), where the car is a symbol
8604 representing a supported image type, and the rest are strings giving
8605 alternate filenames for the corresponding external libraries.
8607 Emacs tries to load the libraries in the order they appear on the
8608 list; if none is loaded, the running session of Emacs won't
8609 support the image type. Types 'pbm and 'xbm don't need to be
8610 listed; they're always supported. */);
8611 Vimage_library_alist
= Qnil
;
8612 Fput (intern ("image-library-alist"), Qrisky_local_variable
, Qt
);
8614 DEFVAR_LISP ("max-image-size", &Vmax_image_size
,
8615 doc
: /* Maximum size of images.
8616 Emacs will not load an image into memory if its pixel width or
8617 pixel height exceeds this limit.
8619 If the value is an integer, it directly specifies the maximum
8620 image height and width, measured in pixels. If it is a floating
8621 point number, it specifies the maximum image height and width
8622 as a ratio to the frame height and width. If the value is
8623 non-numeric, there is no explicit limit on the size of images. */);
8624 Vmax_image_size
= make_float (MAX_IMAGE_SIZE
);
8626 Vimage_type_cache
= Qnil
;
8627 staticpro (&Vimage_type_cache
);
8629 Qpbm
= intern ("pbm");
8631 ADD_IMAGE_TYPE(Qpbm
);
8633 Qxbm
= intern ("xbm");
8635 ADD_IMAGE_TYPE(Qxbm
);
8637 define_image_type (&xbm_type
, 1);
8638 define_image_type (&pbm_type
, 1);
8640 QCascent
= intern (":ascent");
8641 staticpro (&QCascent
);
8642 QCmargin
= intern (":margin");
8643 staticpro (&QCmargin
);
8644 QCrelief
= intern (":relief");
8645 staticpro (&QCrelief
);
8646 QCconversion
= intern (":conversion");
8647 staticpro (&QCconversion
);
8648 QCcolor_symbols
= intern (":color-symbols");
8649 staticpro (&QCcolor_symbols
);
8650 QCheuristic_mask
= intern (":heuristic-mask");
8651 staticpro (&QCheuristic_mask
);
8652 QCindex
= intern (":index");
8653 staticpro (&QCindex
);
8654 QCmatrix
= intern (":matrix");
8655 staticpro (&QCmatrix
);
8656 QCcolor_adjustment
= intern (":color-adjustment");
8657 staticpro (&QCcolor_adjustment
);
8658 QCmask
= intern (":mask");
8659 staticpro (&QCmask
);
8661 Qlaplace
= intern ("laplace");
8662 staticpro (&Qlaplace
);
8663 Qemboss
= intern ("emboss");
8664 staticpro (&Qemboss
);
8665 Qedge_detection
= intern ("edge-detection");
8666 staticpro (&Qedge_detection
);
8667 Qheuristic
= intern ("heuristic");
8668 staticpro (&Qheuristic
);
8670 Qpostscript
= intern ("postscript");
8671 staticpro (&Qpostscript
);
8672 #ifdef HAVE_GHOSTSCRIPT
8673 ADD_IMAGE_TYPE(Qpostscript
);
8674 QCloader
= intern (":loader");
8675 staticpro (&QCloader
);
8676 QCbounding_box
= intern (":bounding-box");
8677 staticpro (&QCbounding_box
);
8678 QCpt_width
= intern (":pt-width");
8679 staticpro (&QCpt_width
);
8680 QCpt_height
= intern (":pt-height");
8681 staticpro (&QCpt_height
);
8682 #endif /* HAVE_GHOSTSCRIPT */
8684 #if defined (HAVE_XPM) || defined (MAC_OS)
8685 Qxpm
= intern ("xpm");
8687 ADD_IMAGE_TYPE(Qxpm
);
8690 #if defined (HAVE_JPEG) || defined (MAC_OS)
8691 Qjpeg
= intern ("jpeg");
8693 ADD_IMAGE_TYPE(Qjpeg
);
8696 #if defined (HAVE_TIFF) || defined (MAC_OS)
8697 Qtiff
= intern ("tiff");
8699 ADD_IMAGE_TYPE(Qtiff
);
8702 #if defined (HAVE_GIF) || defined (MAC_OS)
8703 Qgif
= intern ("gif");
8705 ADD_IMAGE_TYPE(Qgif
);
8708 #if defined (HAVE_PNG) || defined (MAC_OS)
8709 Qpng
= intern ("png");
8711 ADD_IMAGE_TYPE(Qpng
);
8714 defsubr (&Sinit_image_library
);
8715 defsubr (&Sclear_image_cache
);
8716 defsubr (&Simage_refresh
);
8717 defsubr (&Simage_size
);
8718 defsubr (&Simage_mask_p
);
8719 defsubr (&Simage_extension_data
);
8723 defsubr (&Slookup_image
);
8726 DEFVAR_BOOL ("cross-disabled-images", &cross_disabled_images
,
8727 doc
: /* Non-nil means always draw a cross over disabled images.
8728 Disabled images are those having an `:conversion disabled' property.
8729 A cross is always drawn on black & white displays. */);
8730 cross_disabled_images
= 0;
8732 DEFVAR_LISP ("x-bitmap-file-path", &Vx_bitmap_file_path
,
8733 doc
: /* List of directories to search for window system bitmap files. */);
8734 Vx_bitmap_file_path
= decode_env_path ((char *) 0, PATH_BITMAPS
);
8736 DEFVAR_LISP ("image-cache-eviction-delay", &Vimage_cache_eviction_delay
,
8737 doc
: /* Time after which cached images are removed from the cache.
8738 When an image has not been displayed this many seconds, remove it
8739 from the image cache. Value must be an integer or nil with nil
8740 meaning don't clear the cache. */);
8741 Vimage_cache_eviction_delay
= make_number (30 * 60);
8747 #if defined (MAC_OSX) && TARGET_API_MAC_CARBON
8748 init_image_func_pointer ();
8752 /* arch-tag: 123c2a5e-14a8-4c53-ab95-af47d7db49b9
8753 (do not change this comment) */