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 /* Free image cache of frame F. Be aware that X frames share images
1638 free_image_cache (f
)
1641 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
1646 /* Cache should not be referenced by any frame when freed. */
1647 xassert (c
->refcount
== 0);
1649 for (i
= 0; i
< c
->used
; ++i
)
1650 free_image (f
, c
->images
[i
]);
1654 FRAME_X_IMAGE_CACHE (f
) = NULL
;
1659 /* Clear image cache of frame F. FORCE_P non-zero means free all
1660 images. FORCE_P zero means clear only images that haven't been
1661 displayed for some time. Should be called from time to time to
1662 reduce the number of loaded images. If image-eviction-seconds is
1663 non-nil, this frees images in the cache which weren't displayed for
1664 at least that many seconds. */
1667 clear_image_cache (f
, force_p
)
1671 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
1673 if (c
&& INTEGERP (Vimage_cache_eviction_delay
))
1680 old
= EMACS_SECS (t
) - XFASTINT (Vimage_cache_eviction_delay
);
1682 /* Block input so that we won't be interrupted by a SIGIO
1683 while being in an inconsistent state. */
1686 for (i
= nfreed
= 0; i
< c
->used
; ++i
)
1688 struct image
*img
= c
->images
[i
];
1690 && (force_p
|| img
->timestamp
< old
))
1692 free_image (f
, img
);
1697 /* We may be clearing the image cache because, for example,
1698 Emacs was iconified for a longer period of time. In that
1699 case, current matrices may still contain references to
1700 images freed above. So, clear these matrices. */
1703 Lisp_Object tail
, frame
;
1705 FOR_EACH_FRAME (tail
, frame
)
1707 struct frame
*f
= XFRAME (frame
);
1708 if (FRAME_WINDOW_P (f
)
1709 && FRAME_X_IMAGE_CACHE (f
) == c
)
1710 clear_current_matrices (f
);
1713 ++windows_or_buffers_changed
;
1721 DEFUN ("clear-image-cache", Fclear_image_cache
, Sclear_image_cache
,
1723 doc
: /* Clear the image cache of FRAME.
1724 FRAME nil or omitted means use the selected frame.
1725 FRAME t means clear the image caches of all frames. */)
1733 FOR_EACH_FRAME (tail
, frame
)
1734 if (FRAME_WINDOW_P (XFRAME (frame
)))
1735 clear_image_cache (XFRAME (frame
), 1);
1738 clear_image_cache (check_x_frame (frame
), 1);
1744 /* Compute masks and transform image IMG on frame F, as specified
1745 by the image's specification, */
1748 postprocess_image (f
, img
)
1752 /* Manipulation of the image's mask. */
1755 Lisp_Object conversion
, spec
;
1760 /* `:heuristic-mask t'
1762 means build a mask heuristically.
1763 `:heuristic-mask (R G B)'
1764 `:mask (heuristic (R G B))'
1765 means build a mask from color (R G B) in the
1768 means remove a mask, if any. */
1770 mask
= image_spec_value (spec
, QCheuristic_mask
, NULL
);
1772 x_build_heuristic_mask (f
, img
, mask
);
1777 mask
= image_spec_value (spec
, QCmask
, &found_p
);
1779 if (EQ (mask
, Qheuristic
))
1780 x_build_heuristic_mask (f
, img
, Qt
);
1781 else if (CONSP (mask
)
1782 && EQ (XCAR (mask
), Qheuristic
))
1784 if (CONSP (XCDR (mask
)))
1785 x_build_heuristic_mask (f
, img
, XCAR (XCDR (mask
)));
1787 x_build_heuristic_mask (f
, img
, XCDR (mask
));
1789 else if (NILP (mask
) && found_p
&& img
->mask
)
1791 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
1792 img
->mask
= NO_PIXMAP
;
1797 /* Should we apply an image transformation algorithm? */
1798 conversion
= image_spec_value (spec
, QCconversion
, NULL
);
1799 if (EQ (conversion
, Qdisabled
))
1800 x_disable_image (f
, img
);
1801 else if (EQ (conversion
, Qlaplace
))
1803 else if (EQ (conversion
, Qemboss
))
1805 else if (CONSP (conversion
)
1806 && EQ (XCAR (conversion
), Qedge_detection
))
1809 tem
= XCDR (conversion
);
1811 x_edge_detection (f
, img
,
1812 Fplist_get (tem
, QCmatrix
),
1813 Fplist_get (tem
, QCcolor_adjustment
));
1819 /* Return the id of image with Lisp specification SPEC on frame F.
1820 SPEC must be a valid Lisp image specification (see valid_image_p). */
1823 lookup_image (f
, spec
)
1827 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
1831 struct gcpro gcpro1
;
1834 /* F must be a window-system frame, and SPEC must be a valid image
1836 xassert (FRAME_WINDOW_P (f
));
1837 xassert (valid_image_p (spec
));
1841 /* Look up SPEC in the hash table of the image cache. */
1842 hash
= sxhash (spec
, 0);
1843 i
= hash
% IMAGE_CACHE_BUCKETS_SIZE
;
1845 for (img
= c
->buckets
[i
]; img
; img
= img
->next
)
1846 if (img
->hash
== hash
&& !NILP (Fequal (img
->spec
, spec
)))
1849 if (img
&& img
->load_failed_p
)
1851 free_image (f
, img
);
1855 /* If not found, create a new image and cache it. */
1858 extern Lisp_Object Qpostscript
;
1861 img
= make_image (spec
, hash
);
1862 cache_image (f
, img
);
1863 img
->load_failed_p
= img
->type
->load (f
, img
) == 0;
1865 /* If we can't load the image, and we don't have a width and
1866 height, use some arbitrary width and height so that we can
1867 draw a rectangle for it. */
1868 if (img
->load_failed_p
)
1872 value
= image_spec_value (spec
, QCwidth
, NULL
);
1873 img
->width
= (INTEGERP (value
)
1874 ? XFASTINT (value
) : DEFAULT_IMAGE_WIDTH
);
1875 value
= image_spec_value (spec
, QCheight
, NULL
);
1876 img
->height
= (INTEGERP (value
)
1877 ? XFASTINT (value
) : DEFAULT_IMAGE_HEIGHT
);
1881 /* Handle image type independent image attributes
1882 `:ascent ASCENT', `:margin MARGIN', `:relief RELIEF',
1883 `:background COLOR'. */
1884 Lisp_Object ascent
, margin
, relief
, bg
;
1886 ascent
= image_spec_value (spec
, QCascent
, NULL
);
1887 if (INTEGERP (ascent
))
1888 img
->ascent
= XFASTINT (ascent
);
1889 else if (EQ (ascent
, Qcenter
))
1890 img
->ascent
= CENTERED_IMAGE_ASCENT
;
1892 margin
= image_spec_value (spec
, QCmargin
, NULL
);
1893 if (INTEGERP (margin
) && XINT (margin
) >= 0)
1894 img
->vmargin
= img
->hmargin
= XFASTINT (margin
);
1895 else if (CONSP (margin
) && INTEGERP (XCAR (margin
))
1896 && INTEGERP (XCDR (margin
)))
1898 if (XINT (XCAR (margin
)) > 0)
1899 img
->hmargin
= XFASTINT (XCAR (margin
));
1900 if (XINT (XCDR (margin
)) > 0)
1901 img
->vmargin
= XFASTINT (XCDR (margin
));
1904 relief
= image_spec_value (spec
, QCrelief
, NULL
);
1905 if (INTEGERP (relief
))
1907 img
->relief
= XINT (relief
);
1908 img
->hmargin
+= abs (img
->relief
);
1909 img
->vmargin
+= abs (img
->relief
);
1912 if (! img
->background_valid
)
1914 bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
1918 = x_alloc_image_color (f
, img
, bg
,
1919 FRAME_BACKGROUND_PIXEL (f
));
1920 img
->background_valid
= 1;
1924 /* Do image transformations and compute masks, unless we
1925 don't have the image yet. */
1926 if (!EQ (*img
->type
->type
, Qpostscript
))
1927 postprocess_image (f
, img
);
1933 /* We're using IMG, so set its timestamp to `now'. */
1934 EMACS_GET_TIME (now
);
1935 img
->timestamp
= EMACS_SECS (now
);
1939 /* Value is the image id. */
1944 /* Cache image IMG in the image cache of frame F. */
1947 cache_image (f
, img
)
1951 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
1954 /* Find a free slot in c->images. */
1955 for (i
= 0; i
< c
->used
; ++i
)
1956 if (c
->images
[i
] == NULL
)
1959 /* If no free slot found, maybe enlarge c->images. */
1960 if (i
== c
->used
&& c
->used
== c
->size
)
1963 c
->images
= (struct image
**) xrealloc (c
->images
,
1964 c
->size
* sizeof *c
->images
);
1967 /* Add IMG to c->images, and assign IMG an id. */
1973 /* Add IMG to the cache's hash table. */
1974 i
= img
->hash
% IMAGE_CACHE_BUCKETS_SIZE
;
1975 img
->next
= c
->buckets
[i
];
1977 img
->next
->prev
= img
;
1979 c
->buckets
[i
] = img
;
1983 /* Call FN on every image in the image cache of frame F. Used to mark
1984 Lisp Objects in the image cache. */
1987 forall_images_in_image_cache (f
, fn
)
1989 void (*fn
) P_ ((struct image
*img
));
1991 if (FRAME_LIVE_P (f
) && FRAME_WINDOW_P (f
))
1993 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
1997 for (i
= 0; i
< c
->used
; ++i
)
2006 /***********************************************************************
2007 X / MAC / W32 support code
2008 ***********************************************************************/
2012 /* Macro for defining functions that will be loaded from image DLLs. */
2013 #define DEF_IMGLIB_FN(func) int (FAR CDECL *fn_##func)()
2015 /* Macro for loading those image functions from the library. */
2016 #define LOAD_IMGLIB_FN(lib,func) { \
2017 fn_##func = (void *) GetProcAddress (lib, #func); \
2018 if (!fn_##func) return 0; \
2021 /* Load a DLL implementing an image type.
2022 The `image-library-alist' variable associates a symbol,
2023 identifying an image type, to a list of possible filenames.
2024 The function returns NULL if no library could be loaded for
2025 the given image type, or if the library was previously loaded;
2026 else the handle of the DLL. */
2028 w32_delayed_load (Lisp_Object libraries
, Lisp_Object type
)
2030 HMODULE library
= NULL
;
2032 if (CONSP (libraries
) && NILP (Fassq (type
, Vimage_type_cache
)))
2034 Lisp_Object dlls
= Fassq (type
, libraries
);
2037 for (dlls
= XCDR (dlls
); CONSP (dlls
); dlls
= XCDR (dlls
))
2039 CHECK_STRING_CAR (dlls
);
2040 if (library
= LoadLibrary (SDATA (XCAR (dlls
))))
2048 #endif /* HAVE_NTGUI */
2050 static int x_create_x_image_and_pixmap
P_ ((struct frame
*, int, int, int,
2051 XImagePtr
*, Pixmap
*));
2052 static void x_destroy_x_image
P_ ((XImagePtr
));
2053 static void x_put_x_image
P_ ((struct frame
*, XImagePtr
, Pixmap
, int, int));
2056 /* Create an XImage and a pixmap of size WIDTH x HEIGHT for use on
2057 frame F. Set *XIMG and *PIXMAP to the XImage and Pixmap created.
2058 Set (*XIMG)->data to a raster of WIDTH x HEIGHT pixels allocated
2059 via xmalloc. Print error messages via image_error if an error
2060 occurs. Value is non-zero if successful.
2062 On W32, a DEPTH of zero signifies a 24 bit image, otherwise DEPTH
2063 should indicate the bit depth of the image. */
2066 x_create_x_image_and_pixmap (f
, width
, height
, depth
, ximg
, pixmap
)
2068 int width
, height
, depth
;
2072 #ifdef HAVE_X_WINDOWS
2073 Display
*display
= FRAME_X_DISPLAY (f
);
2074 Window window
= FRAME_X_WINDOW (f
);
2075 Screen
*screen
= FRAME_X_SCREEN (f
);
2077 xassert (interrupt_input_blocked
);
2080 depth
= DefaultDepthOfScreen (screen
);
2081 *ximg
= XCreateImage (display
, DefaultVisualOfScreen (screen
),
2082 depth
, ZPixmap
, 0, NULL
, width
, height
,
2083 depth
> 16 ? 32 : depth
> 8 ? 16 : 8, 0);
2086 image_error ("Unable to allocate X image", Qnil
, Qnil
);
2090 /* Allocate image raster. */
2091 (*ximg
)->data
= (char *) xmalloc ((*ximg
)->bytes_per_line
* height
);
2093 /* Allocate a pixmap of the same size. */
2094 *pixmap
= XCreatePixmap (display
, window
, width
, height
, depth
);
2095 if (*pixmap
== NO_PIXMAP
)
2097 x_destroy_x_image (*ximg
);
2099 image_error ("Unable to create X pixmap", Qnil
, Qnil
);
2104 #endif /* HAVE_X_WINDOWS */
2108 BITMAPINFOHEADER
*header
;
2110 int scanline_width_bits
;
2112 int palette_colors
= 0;
2117 if (depth
!= 1 && depth
!= 4 && depth
!= 8
2118 && depth
!= 16 && depth
!= 24 && depth
!= 32)
2120 image_error ("Invalid image bit depth specified", Qnil
, Qnil
);
2124 scanline_width_bits
= width
* depth
;
2125 remainder
= scanline_width_bits
% 32;
2128 scanline_width_bits
+= 32 - remainder
;
2130 /* Bitmaps with a depth less than 16 need a palette. */
2131 /* BITMAPINFO structure already contains the first RGBQUAD. */
2133 palette_colors
= 1 << depth
- 1;
2135 *ximg
= xmalloc (sizeof (XImage
) + palette_colors
* sizeof (RGBQUAD
));
2138 image_error ("Unable to allocate memory for XImage", Qnil
, Qnil
);
2142 header
= &((*ximg
)->info
.bmiHeader
);
2143 bzero (&((*ximg
)->info
), sizeof (BITMAPINFO
));
2144 header
->biSize
= sizeof (*header
);
2145 header
->biWidth
= width
;
2146 header
->biHeight
= -height
; /* negative indicates a top-down bitmap. */
2147 header
->biPlanes
= 1;
2148 header
->biBitCount
= depth
;
2149 header
->biCompression
= BI_RGB
;
2150 header
->biClrUsed
= palette_colors
;
2152 /* TODO: fill in palette. */
2155 (*ximg
)->info
.bmiColors
[0].rgbBlue
= 0;
2156 (*ximg
)->info
.bmiColors
[0].rgbGreen
= 0;
2157 (*ximg
)->info
.bmiColors
[0].rgbRed
= 0;
2158 (*ximg
)->info
.bmiColors
[0].rgbReserved
= 0;
2159 (*ximg
)->info
.bmiColors
[1].rgbBlue
= 255;
2160 (*ximg
)->info
.bmiColors
[1].rgbGreen
= 255;
2161 (*ximg
)->info
.bmiColors
[1].rgbRed
= 255;
2162 (*ximg
)->info
.bmiColors
[1].rgbReserved
= 0;
2165 hdc
= get_frame_dc (f
);
2167 /* Create a DIBSection and raster array for the bitmap,
2168 and store its handle in *pixmap. */
2169 *pixmap
= CreateDIBSection (hdc
, &((*ximg
)->info
),
2170 (depth
< 16) ? DIB_PAL_COLORS
: DIB_RGB_COLORS
,
2171 /* casting avoids a GCC warning */
2172 (void **)&((*ximg
)->data
), NULL
, 0);
2174 /* Realize display palette and garbage all frames. */
2175 release_frame_dc (f
, hdc
);
2177 if (*pixmap
== NULL
)
2179 DWORD err
= GetLastError();
2180 Lisp_Object errcode
;
2181 /* All system errors are < 10000, so the following is safe. */
2182 XSETINT (errcode
, (int) err
);
2183 image_error ("Unable to create bitmap, error code %d", errcode
, Qnil
);
2184 x_destroy_x_image (*ximg
);
2190 #endif /* HAVE_NTGUI */
2193 Display
*display
= FRAME_X_DISPLAY (f
);
2194 Window window
= FRAME_X_WINDOW (f
);
2196 xassert (interrupt_input_blocked
);
2198 /* Allocate a pixmap of the same size. */
2199 *pixmap
= XCreatePixmap (display
, window
, width
, height
, depth
);
2200 if (*pixmap
== NO_PIXMAP
)
2203 image_error ("Unable to create X pixmap", Qnil
, Qnil
);
2207 LockPixels (GetGWorldPixMap (*pixmap
));
2215 /* Destroy XImage XIMG. Free XIMG->data. */
2218 x_destroy_x_image (ximg
)
2221 xassert (interrupt_input_blocked
);
2224 #ifdef HAVE_X_WINDOWS
2227 XDestroyImage (ximg
);
2228 #endif /* HAVE_X_WINDOWS */
2230 /* Data will be freed by DestroyObject. */
2233 #endif /* HAVE_NTGUI */
2235 XDestroyImage (ximg
);
2241 /* Put XImage XIMG into pixmap PIXMAP on frame F. WIDTH and HEIGHT
2242 are width and height of both the image and pixmap. */
2245 x_put_x_image (f
, ximg
, pixmap
, width
, height
)
2251 #ifdef HAVE_X_WINDOWS
2254 xassert (interrupt_input_blocked
);
2255 gc
= XCreateGC (FRAME_X_DISPLAY (f
), pixmap
, 0, NULL
);
2256 XPutImage (FRAME_X_DISPLAY (f
), pixmap
, gc
, ximg
, 0, 0, 0, 0, width
, height
);
2257 XFreeGC (FRAME_X_DISPLAY (f
), gc
);
2258 #endif /* HAVE_X_WINDOWS */
2261 #if 0 /* I don't think this is necessary looking at where it is used. */
2262 HDC hdc
= get_frame_dc (f
);
2263 SetDIBits (hdc
, pixmap
, 0, height
, ximg
->data
, &(ximg
->info
), DIB_RGB_COLORS
);
2264 release_frame_dc (f
, hdc
);
2266 #endif /* HAVE_NTGUI */
2269 xassert (ximg
== pixmap
);
2274 /***********************************************************************
2276 ***********************************************************************/
2278 static unsigned char *slurp_file
P_ ((char *, int *));
2281 /* Find image file FILE. Look in data-directory, then
2282 x-bitmap-file-path. Value is the encoded full name of the file
2283 found, or nil if not found. */
2286 x_find_image_file (file
)
2289 Lisp_Object file_found
, search_path
;
2290 struct gcpro gcpro1
, gcpro2
;
2294 search_path
= Fcons (Vdata_directory
, Vx_bitmap_file_path
);
2295 GCPRO2 (file_found
, search_path
);
2297 /* Try to find FILE in data-directory, then x-bitmap-file-path. */
2298 fd
= openp (search_path
, file
, Qnil
, &file_found
, Qnil
);
2304 file_found
= ENCODE_FILE (file_found
);
2313 /* Read FILE into memory. Value is a pointer to a buffer allocated
2314 with xmalloc holding FILE's contents. Value is null if an error
2315 occurred. *SIZE is set to the size of the file. */
2317 static unsigned char *
2318 slurp_file (file
, size
)
2323 unsigned char *buf
= NULL
;
2326 if (stat (file
, &st
) == 0
2327 && (fp
= fopen (file
, "rb")) != NULL
2328 && (buf
= (unsigned char *) xmalloc (st
.st_size
),
2329 fread (buf
, 1, st
.st_size
, fp
) == st
.st_size
))
2352 /***********************************************************************
2353 MAC Image Load Functions
2354 ***********************************************************************/
2356 static int image_load_quicktime
P_ ((struct frame
*, struct image
*img
,
2359 static int image_load_quartz2d
P_ ((struct frame
*, struct image
*img
, int));
2363 find_image_fsspec (specified_file
, file
, fss
)
2364 Lisp_Object specified_file
, *file
;
2370 *file
= x_find_image_file (specified_file
);
2371 if (!STRINGP (*file
))
2372 return fnfErr
; /* file or directory not found;
2373 incomplete pathname */
2374 /* Try to open the image file. */
2375 err
= AECoercePtr (TYPE_FILE_NAME
, SDATA (*file
),
2376 SBYTES (*file
), typeFSS
, &desc
);
2379 #if TARGET_API_MAC_CARBON
2380 err
= AEGetDescData (&desc
, fss
, sizeof (FSSpec
));
2382 *fss
= *(FSSpec
*)(*(desc
.dataHandle
));
2384 AEDisposeDesc (&desc
);
2390 image_load_qt_1 (f
, img
, type
, fss
, dh
)
2397 ComponentResult err
;
2398 GraphicsImportComponent gi
;
2401 ImageDescriptionHandle desc_handle
;
2402 short draw_all_pixels
;
2403 Lisp_Object specified_bg
;
2408 err
= OpenADefaultComponent (GraphicsImporterComponentType
, type
, &gi
);
2411 image_error ("Cannot get importer component for `%s'", img
->spec
, Qnil
);
2416 /* read from file system spec */
2417 err
= GraphicsImportSetDataFile (gi
, fss
);
2420 image_error ("Cannot set fsspec to graphics importer for '%s'",
2427 /* read from data handle */
2428 err
= GraphicsImportSetDataHandle (gi
, dh
);
2431 image_error ("Cannot set data handle to graphics importer for `%s'",
2436 err
= GraphicsImportGetImageDescription (gi
, &desc_handle
);
2437 if (err
!= noErr
|| desc_handle
== NULL
)
2439 image_error ("Error reading `%s'", img
->spec
, Qnil
);
2442 width
= img
->width
= (*desc_handle
)->width
;
2443 height
= img
->height
= (*desc_handle
)->height
;
2444 DisposeHandle ((Handle
)desc_handle
);
2446 if (!check_image_size (f
, width
, height
))
2448 image_error ("Invalid image size", Qnil
, Qnil
);
2452 err
= GraphicsImportDoesDrawAllPixels (gi
, &draw_all_pixels
);
2454 /* Don't check the error code here. It may have an undocumented
2458 image_error ("Error reading `%s'", img
->spec
, Qnil
);
2462 if (draw_all_pixels
!= graphicsImporterDrawsAllPixels
)
2464 specified_bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
2465 if (!STRINGP (specified_bg
) ||
2466 !mac_defined_color (f
, SDATA (specified_bg
), &color
, 0))
2468 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
2469 color
.red
= RED16_FROM_ULONG (color
.pixel
);
2470 color
.green
= GREEN16_FROM_ULONG (color
.pixel
);
2471 color
.blue
= BLUE16_FROM_ULONG (color
.pixel
);
2475 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
2477 if (draw_all_pixels
!= graphicsImporterDrawsAllPixels
)
2482 GetGWorld (&old_port
, &old_gdh
);
2483 SetGWorld (ximg
, NULL
);
2484 bg_color
.red
= color
.red
;
2485 bg_color
.green
= color
.green
;
2486 bg_color
.blue
= color
.blue
;
2487 RGBBackColor (&bg_color
);
2488 #if TARGET_API_MAC_CARBON
2489 GetPortBounds (ximg
, &rect
);
2492 EraseRect (&(ximg
->portRect
));
2494 SetGWorld (old_port
, old_gdh
);
2496 GraphicsImportSetGWorld (gi
, ximg
, NULL
);
2497 GraphicsImportDraw (gi
);
2498 CloseComponent (gi
);
2500 /* Maybe fill in the background field while we have ximg handy. */
2501 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
2502 IMAGE_BACKGROUND (img
, f
, ximg
);
2504 /* Put the image into the pixmap. */
2505 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
2506 x_destroy_x_image (ximg
);
2510 CloseComponent (gi
);
2515 /* Load an image using the QuickTime Graphics Importer.
2516 Note: The alpha channel does not work for PNG images. */
2518 image_load_quicktime (f
, img
, type
)
2523 Lisp_Object specified_file
;
2524 Lisp_Object specified_data
;
2527 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
2528 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
2530 if (NILP (specified_data
))
2532 /* Read from a file */
2536 err
= find_image_fsspec (specified_file
, &file
, &fss
);
2540 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
2542 image_error ("Cannot open `%s'", file
, Qnil
);
2545 return image_load_qt_1 (f
, img
, type
, &fss
, NULL
);
2549 /* Memory source! */
2553 err
= PtrToHand (SDATA (specified_data
), &dh
, SBYTES (specified_data
));
2556 image_error ("Cannot allocate data handle for `%s'",
2560 success_p
= image_load_qt_1 (f
, img
, type
, NULL
, dh
);
2568 /* Load a PNG/JPEG image using Quartz 2D decoding routines.
2569 CGImageCreateWithPNGDataProvider is provided after Mac OS X 10.2.
2570 So don't use this function directly but determine at runtime
2571 whether it exists. */
2572 typedef CGImageRef (*CGImageCreateWithPNGDataProviderProcType
)
2573 (CGDataProviderRef
, const float [], bool, CGColorRenderingIntent
);
2574 static CGImageCreateWithPNGDataProviderProcType MyCGImageCreateWithPNGDataProvider
;
2578 init_image_func_pointer ()
2580 if (NSIsSymbolNameDefined ("_CGImageCreateWithPNGDataProvider"))
2582 MyCGImageCreateWithPNGDataProvider
2583 = (CGImageCreateWithPNGDataProviderProcType
)
2584 NSAddressOfSymbol (NSLookupAndBindSymbol
2585 ("_CGImageCreateWithPNGDataProvider"));
2588 MyCGImageCreateWithPNGDataProvider
= NULL
;
2593 image_load_quartz2d (f
, img
, png_p
)
2598 Lisp_Object file
, specified_file
;
2599 Lisp_Object specified_data
, specified_bg
;
2600 struct gcpro gcpro1
;
2601 CGDataProviderRef source
;
2605 XImagePtr ximg
= NULL
;
2606 CGContextRef context
;
2609 /* Open the file. */
2610 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
2611 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
2616 if (NILP (specified_data
))
2621 file
= x_find_image_file (specified_file
);
2622 if (!STRINGP (file
))
2624 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
2628 path
= cfstring_create_with_utf8_cstring (SDATA (file
));
2629 url
= CFURLCreateWithFileSystemPath (NULL
, path
,
2630 kCFURLPOSIXPathStyle
, 0);
2632 source
= CGDataProviderCreateWithURL (url
);
2636 source
= CGDataProviderCreateWithData (NULL
, SDATA (specified_data
),
2637 SBYTES (specified_data
), NULL
);
2640 image
= (*MyCGImageCreateWithPNGDataProvider
) (source
, NULL
, FALSE
,
2641 kCGRenderingIntentDefault
);
2643 image
= CGImageCreateWithJPEGDataProvider (source
, NULL
, FALSE
,
2644 kCGRenderingIntentDefault
);
2646 CGDataProviderRelease (source
);
2650 image_error ("Error reading image `%s'", img
->spec
, Qnil
);
2653 width
= img
->width
= CGImageGetWidth (image
);
2654 height
= img
->height
= CGImageGetHeight (image
);
2656 if (!check_image_size (f
, width
, height
))
2658 CGImageRelease (image
);
2660 image_error ("Invalid image size", Qnil
, Qnil
);
2666 specified_bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
2667 if (!STRINGP (specified_bg
) ||
2668 !mac_defined_color (f
, SDATA (specified_bg
), &color
, 0))
2670 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
2671 color
.red
= RED16_FROM_ULONG (color
.pixel
);
2672 color
.green
= GREEN16_FROM_ULONG (color
.pixel
);
2673 color
.blue
= BLUE16_FROM_ULONG (color
.pixel
);
2677 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
2679 CGImageRelease (image
);
2683 rectangle
= CGRectMake (0, 0, width
, height
);
2684 QDBeginCGContext (ximg
, &context
);
2687 CGContextSetRGBFillColor (context
, color
.red
/ 65535.0,
2688 color
.green
/ 65535.0,
2689 color
.blue
/ 65535.0, 1.0);
2690 CGContextFillRect (context
, rectangle
);
2692 CGContextDrawImage (context
, rectangle
, image
);
2693 QDEndCGContext (ximg
, &context
);
2694 CGImageRelease (image
);
2696 /* Maybe fill in the background field while we have ximg handy. */
2697 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
2698 IMAGE_BACKGROUND (img
, f
, ximg
);
2700 /* Put the image into the pixmap. */
2701 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
2702 x_destroy_x_image (ximg
);
2711 /***********************************************************************
2713 ***********************************************************************/
2715 static int xbm_scan
P_ ((unsigned char **, unsigned char *, char *, int *));
2716 static int xbm_load
P_ ((struct frame
*f
, struct image
*img
));
2717 static int xbm_load_image
P_ ((struct frame
*f
, struct image
*img
,
2718 unsigned char *, unsigned char *));
2719 static int xbm_image_p
P_ ((Lisp_Object object
));
2720 static int xbm_read_bitmap_data
P_ ((struct frame
*f
,
2721 unsigned char *, unsigned char *,
2722 int *, int *, unsigned char **));
2723 static int xbm_file_p
P_ ((Lisp_Object
));
2726 /* Indices of image specification fields in xbm_format, below. */
2728 enum xbm_keyword_index
2746 /* Vector of image_keyword structures describing the format
2747 of valid XBM image specifications. */
2749 static struct image_keyword xbm_format
[XBM_LAST
] =
2751 {":type", IMAGE_SYMBOL_VALUE
, 1},
2752 {":file", IMAGE_STRING_VALUE
, 0},
2753 {":width", IMAGE_POSITIVE_INTEGER_VALUE
, 0},
2754 {":height", IMAGE_POSITIVE_INTEGER_VALUE
, 0},
2755 {":data", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
2756 {":foreground", IMAGE_STRING_OR_NIL_VALUE
, 0},
2757 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0},
2758 {":ascent", IMAGE_ASCENT_VALUE
, 0},
2759 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
2760 {":relief", IMAGE_INTEGER_VALUE
, 0},
2761 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
2762 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
2763 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0}
2766 /* Structure describing the image type XBM. */
2768 static struct image_type xbm_type
=
2777 /* Tokens returned from xbm_scan. */
2786 /* Return non-zero if OBJECT is a valid XBM-type image specification.
2787 A valid specification is a list starting with the symbol `image'
2788 The rest of the list is a property list which must contain an
2791 If the specification specifies a file to load, it must contain
2792 an entry `:file FILENAME' where FILENAME is a string.
2794 If the specification is for a bitmap loaded from memory it must
2795 contain `:width WIDTH', `:height HEIGHT', and `:data DATA', where
2796 WIDTH and HEIGHT are integers > 0. DATA may be:
2798 1. a string large enough to hold the bitmap data, i.e. it must
2799 have a size >= (WIDTH + 7) / 8 * HEIGHT
2801 2. a bool-vector of size >= WIDTH * HEIGHT
2803 3. a vector of strings or bool-vectors, one for each line of the
2806 4. A string containing an in-memory XBM file. WIDTH and HEIGHT
2807 may not be specified in this case because they are defined in the
2810 Both the file and data forms may contain the additional entries
2811 `:background COLOR' and `:foreground COLOR'. If not present,
2812 foreground and background of the frame on which the image is
2813 displayed is used. */
2816 xbm_image_p (object
)
2819 struct image_keyword kw
[XBM_LAST
];
2821 bcopy (xbm_format
, kw
, sizeof kw
);
2822 if (!parse_image_spec (object
, kw
, XBM_LAST
, Qxbm
))
2825 xassert (EQ (kw
[XBM_TYPE
].value
, Qxbm
));
2827 if (kw
[XBM_FILE
].count
)
2829 if (kw
[XBM_WIDTH
].count
|| kw
[XBM_HEIGHT
].count
|| kw
[XBM_DATA
].count
)
2832 else if (kw
[XBM_DATA
].count
&& xbm_file_p (kw
[XBM_DATA
].value
))
2834 /* In-memory XBM file. */
2835 if (kw
[XBM_WIDTH
].count
|| kw
[XBM_HEIGHT
].count
|| kw
[XBM_FILE
].count
)
2843 /* Entries for `:width', `:height' and `:data' must be present. */
2844 if (!kw
[XBM_WIDTH
].count
2845 || !kw
[XBM_HEIGHT
].count
2846 || !kw
[XBM_DATA
].count
)
2849 data
= kw
[XBM_DATA
].value
;
2850 width
= XFASTINT (kw
[XBM_WIDTH
].value
);
2851 height
= XFASTINT (kw
[XBM_HEIGHT
].value
);
2853 /* Check type of data, and width and height against contents of
2859 /* Number of elements of the vector must be >= height. */
2860 if (XVECTOR (data
)->size
< height
)
2863 /* Each string or bool-vector in data must be large enough
2864 for one line of the image. */
2865 for (i
= 0; i
< height
; ++i
)
2867 Lisp_Object elt
= XVECTOR (data
)->contents
[i
];
2872 < (width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
)
2875 else if (BOOL_VECTOR_P (elt
))
2877 if (XBOOL_VECTOR (elt
)->size
< width
)
2884 else if (STRINGP (data
))
2887 < (width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
* height
)
2890 else if (BOOL_VECTOR_P (data
))
2892 if (XBOOL_VECTOR (data
)->size
< width
* height
)
2903 /* Scan a bitmap file. FP is the stream to read from. Value is
2904 either an enumerator from enum xbm_token, or a character for a
2905 single-character token, or 0 at end of file. If scanning an
2906 identifier, store the lexeme of the identifier in SVAL. If
2907 scanning a number, store its value in *IVAL. */
2910 xbm_scan (s
, end
, sval
, ival
)
2911 unsigned char **s
, *end
;
2919 /* Skip white space. */
2920 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
2925 else if (isdigit (c
))
2927 int value
= 0, digit
;
2929 if (c
== '0' && *s
< end
)
2932 if (c
== 'x' || c
== 'X')
2939 else if (c
>= 'a' && c
<= 'f')
2940 digit
= c
- 'a' + 10;
2941 else if (c
>= 'A' && c
<= 'F')
2942 digit
= c
- 'A' + 10;
2945 value
= 16 * value
+ digit
;
2948 else if (isdigit (c
))
2952 && (c
= *(*s
)++, isdigit (c
)))
2953 value
= 8 * value
+ c
- '0';
2960 && (c
= *(*s
)++, isdigit (c
)))
2961 value
= 10 * value
+ c
- '0';
2969 else if (isalpha (c
) || c
== '_')
2973 && (c
= *(*s
)++, (isalnum (c
) || c
== '_')))
2980 else if (c
== '/' && **s
== '*')
2982 /* C-style comment. */
2984 while (**s
&& (**s
!= '*' || *(*s
+ 1) != '/'))
2998 /* Create a Windows bitmap from X bitmap data. */
3000 w32_create_pixmap_from_bitmap_data (int width
, int height
, char *data
)
3002 static unsigned char swap_nibble
[16]
3003 = { 0x0, 0x8, 0x4, 0xc, /* 0000 1000 0100 1100 */
3004 0x2, 0xa, 0x6, 0xe, /* 0010 1010 0110 1110 */
3005 0x1, 0x9, 0x5, 0xd, /* 0001 1001 0101 1101 */
3006 0x3, 0xb, 0x7, 0xf }; /* 0011 1011 0111 1111 */
3008 unsigned char *bits
, *p
;
3011 w1
= (width
+ 7) / 8; /* nb of 8bits elt in X bitmap */
3012 w2
= ((width
+ 15) / 16) * 2; /* nb of 16bits elt in W32 bitmap */
3013 bits
= (unsigned char *) alloca (height
* w2
);
3014 bzero (bits
, height
* w2
);
3015 for (i
= 0; i
< height
; i
++)
3018 for (j
= 0; j
< w1
; j
++)
3020 /* Bitswap XBM bytes to match how Windows does things. */
3021 unsigned char c
= *data
++;
3022 *p
++ = (unsigned char)((swap_nibble
[c
& 0xf] << 4)
3023 | (swap_nibble
[(c
>>4) & 0xf]));
3026 bmp
= CreateBitmap (width
, height
, 1, 1, (char *) bits
);
3031 static void convert_mono_to_color_image (f
, img
, foreground
, background
)
3034 COLORREF foreground
, background
;
3036 HDC hdc
, old_img_dc
, new_img_dc
;
3037 HGDIOBJ old_prev
, new_prev
;
3040 hdc
= get_frame_dc (f
);
3041 old_img_dc
= CreateCompatibleDC (hdc
);
3042 new_img_dc
= CreateCompatibleDC (hdc
);
3043 new_pixmap
= CreateCompatibleBitmap (hdc
, img
->width
, img
->height
);
3044 release_frame_dc (f
, hdc
);
3045 old_prev
= SelectObject (old_img_dc
, img
->pixmap
);
3046 new_prev
= SelectObject (new_img_dc
, new_pixmap
);
3047 SetTextColor (new_img_dc
, foreground
);
3048 SetBkColor (new_img_dc
, background
);
3050 BitBlt (new_img_dc
, 0, 0, img
->width
, img
->height
, old_img_dc
,
3053 SelectObject (old_img_dc
, old_prev
);
3054 SelectObject (new_img_dc
, new_prev
);
3055 DeleteDC (old_img_dc
);
3056 DeleteDC (new_img_dc
);
3057 DeleteObject (img
->pixmap
);
3058 if (new_pixmap
== 0)
3059 fprintf (stderr
, "Failed to convert image to color.\n");
3061 img
->pixmap
= new_pixmap
;
3064 #define XBM_BIT_SHUFFLE(b) (~(b))
3068 #define XBM_BIT_SHUFFLE(b) (b)
3070 #endif /* HAVE_NTGUI */
3074 Create_Pixmap_From_Bitmap_Data(f
, img
, data
, fg
, bg
, non_default_colors
)
3078 RGB_PIXEL_COLOR fg
, bg
;
3079 int non_default_colors
;
3083 = w32_create_pixmap_from_bitmap_data (img
->width
, img
->height
, data
);
3085 /* If colors were specified, transfer the bitmap to a color one. */
3086 if (non_default_colors
)
3087 convert_mono_to_color_image (f
, img
, fg
, bg
);
3090 = XCreatePixmapFromBitmapData (FRAME_X_DISPLAY (f
),
3093 img
->width
, img
->height
,
3095 DefaultDepthOfScreen (FRAME_X_SCREEN (f
)));
3096 #endif /* HAVE_NTGUI */
3101 /* Replacement for XReadBitmapFileData which isn't available under old
3102 X versions. CONTENTS is a pointer to a buffer to parse; END is the
3103 buffer's end. Set *WIDTH and *HEIGHT to the width and height of
3104 the image. Return in *DATA the bitmap data allocated with xmalloc.
3105 Value is non-zero if successful. DATA null means just test if
3106 CONTENTS looks like an in-memory XBM file. */
3109 xbm_read_bitmap_data (f
, contents
, end
, width
, height
, data
)
3111 unsigned char *contents
, *end
;
3112 int *width
, *height
;
3113 unsigned char **data
;
3115 unsigned char *s
= contents
;
3116 char buffer
[BUFSIZ
];
3119 int bytes_per_line
, i
, nbytes
;
3125 LA1 = xbm_scan (&s, end, buffer, &value)
3127 #define expect(TOKEN) \
3128 if (LA1 != (TOKEN)) \
3133 #define expect_ident(IDENT) \
3134 if (LA1 == XBM_TK_IDENT && strcmp (buffer, (IDENT)) == 0) \
3139 *width
= *height
= -1;
3142 LA1
= xbm_scan (&s
, end
, buffer
, &value
);
3144 /* Parse defines for width, height and hot-spots. */
3148 expect_ident ("define");
3149 expect (XBM_TK_IDENT
);
3151 if (LA1
== XBM_TK_NUMBER
)
3153 char *p
= strrchr (buffer
, '_');
3154 p
= p
? p
+ 1 : buffer
;
3155 if (strcmp (p
, "width") == 0)
3157 else if (strcmp (p
, "height") == 0)
3160 expect (XBM_TK_NUMBER
);
3163 if (!check_image_size (f
, *width
, *height
))
3165 else if (data
== NULL
)
3168 /* Parse bits. Must start with `static'. */
3169 expect_ident ("static");
3170 if (LA1
== XBM_TK_IDENT
)
3172 if (strcmp (buffer
, "unsigned") == 0)
3175 expect_ident ("char");
3177 else if (strcmp (buffer
, "short") == 0)
3181 if (*width
% 16 && *width
% 16 < 9)
3184 else if (strcmp (buffer
, "char") == 0)
3192 expect (XBM_TK_IDENT
);
3198 bytes_per_line
= (*width
+ 7) / 8 + padding_p
;
3199 nbytes
= bytes_per_line
* *height
;
3200 p
= *data
= (unsigned char *) xmalloc (nbytes
);
3204 for (i
= 0; i
< nbytes
; i
+= 2)
3207 expect (XBM_TK_NUMBER
);
3209 *p
++ = XBM_BIT_SHUFFLE (val
);
3210 if (!padding_p
|| ((i
+ 2) % bytes_per_line
))
3211 *p
++ = XBM_BIT_SHUFFLE (value
>> 8);
3213 if (LA1
== ',' || LA1
== '}')
3221 for (i
= 0; i
< nbytes
; ++i
)
3224 expect (XBM_TK_NUMBER
);
3226 *p
++ = XBM_BIT_SHUFFLE (val
);
3228 if (LA1
== ',' || LA1
== '}')
3253 /* Load XBM image IMG which will be displayed on frame F from buffer
3254 CONTENTS. END is the end of the buffer. Value is non-zero if
3258 xbm_load_image (f
, img
, contents
, end
)
3261 unsigned char *contents
, *end
;
3264 unsigned char *data
;
3267 rc
= xbm_read_bitmap_data (f
, contents
, end
, &img
->width
, &img
->height
, &data
);
3270 unsigned long foreground
= FRAME_FOREGROUND_PIXEL (f
);
3271 unsigned long background
= FRAME_BACKGROUND_PIXEL (f
);
3272 int non_default_colors
= 0;
3275 xassert (img
->width
> 0 && img
->height
> 0);
3277 /* Get foreground and background colors, maybe allocate colors. */
3278 value
= image_spec_value (img
->spec
, QCforeground
, NULL
);
3281 foreground
= x_alloc_image_color (f
, img
, value
, foreground
);
3282 non_default_colors
= 1;
3284 value
= image_spec_value (img
->spec
, QCbackground
, NULL
);
3287 background
= x_alloc_image_color (f
, img
, value
, background
);
3288 img
->background
= background
;
3289 img
->background_valid
= 1;
3290 non_default_colors
= 1;
3293 Create_Pixmap_From_Bitmap_Data (f
, img
, data
,
3294 foreground
, background
,
3295 non_default_colors
);
3298 if (img
->pixmap
== NO_PIXMAP
)
3300 x_clear_image (f
, img
);
3301 image_error ("Unable to create X pixmap for `%s'", img
->spec
, Qnil
);
3307 image_error ("Error loading XBM image `%s'", img
->spec
, Qnil
);
3313 /* Value is non-zero if DATA looks like an in-memory XBM file. */
3320 return (STRINGP (data
)
3321 && xbm_read_bitmap_data (NULL
, SDATA (data
),
3328 /* Fill image IMG which is used on frame F with pixmap data. Value is
3329 non-zero if successful. */
3337 Lisp_Object file_name
;
3339 xassert (xbm_image_p (img
->spec
));
3341 /* If IMG->spec specifies a file name, create a non-file spec from it. */
3342 file_name
= image_spec_value (img
->spec
, QCfile
, NULL
);
3343 if (STRINGP (file_name
))
3346 unsigned char *contents
;
3348 struct gcpro gcpro1
;
3350 file
= x_find_image_file (file_name
);
3352 if (!STRINGP (file
))
3354 image_error ("Cannot find image file `%s'", file_name
, Qnil
);
3359 contents
= slurp_file (SDATA (file
), &size
);
3360 if (contents
== NULL
)
3362 image_error ("Error loading XBM image `%s'", img
->spec
, Qnil
);
3367 success_p
= xbm_load_image (f
, img
, contents
, contents
+ size
);
3372 struct image_keyword fmt
[XBM_LAST
];
3374 unsigned long foreground
= FRAME_FOREGROUND_PIXEL (f
);
3375 unsigned long background
= FRAME_BACKGROUND_PIXEL (f
);
3376 int non_default_colors
= 0;
3379 int in_memory_file_p
= 0;
3381 /* See if data looks like an in-memory XBM file. */
3382 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
3383 in_memory_file_p
= xbm_file_p (data
);
3385 /* Parse the image specification. */
3386 bcopy (xbm_format
, fmt
, sizeof fmt
);
3387 parsed_p
= parse_image_spec (img
->spec
, fmt
, XBM_LAST
, Qxbm
);
3390 /* Get specified width, and height. */
3391 if (!in_memory_file_p
)
3393 img
->width
= XFASTINT (fmt
[XBM_WIDTH
].value
);
3394 img
->height
= XFASTINT (fmt
[XBM_HEIGHT
].value
);
3395 xassert (img
->width
> 0 && img
->height
> 0);
3398 /* Get foreground and background colors, maybe allocate colors. */
3399 if (fmt
[XBM_FOREGROUND
].count
3400 && STRINGP (fmt
[XBM_FOREGROUND
].value
))
3402 foreground
= x_alloc_image_color (f
, img
, fmt
[XBM_FOREGROUND
].value
,
3404 non_default_colors
= 1;
3407 if (fmt
[XBM_BACKGROUND
].count
3408 && STRINGP (fmt
[XBM_BACKGROUND
].value
))
3410 background
= x_alloc_image_color (f
, img
, fmt
[XBM_BACKGROUND
].value
,
3412 non_default_colors
= 1;
3415 if (in_memory_file_p
)
3416 success_p
= xbm_load_image (f
, img
, SDATA (data
),
3425 int nbytes
= (img
->width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
;
3427 p
= bits
= (char *) alloca (nbytes
* img
->height
);
3428 for (i
= 0; i
< img
->height
; ++i
, p
+= nbytes
)
3430 Lisp_Object line
= XVECTOR (data
)->contents
[i
];
3432 bcopy (SDATA (line
), p
, nbytes
);
3434 bcopy (XBOOL_VECTOR (line
)->data
, p
, nbytes
);
3437 else if (STRINGP (data
))
3438 bits
= SDATA (data
);
3440 bits
= XBOOL_VECTOR (data
)->data
;
3442 /* Create the pixmap. */
3444 Create_Pixmap_From_Bitmap_Data (f
, img
, bits
,
3445 foreground
, background
,
3446 non_default_colors
);
3451 image_error ("Unable to create pixmap for XBM image `%s'",
3453 x_clear_image (f
, img
);
3463 /***********************************************************************
3465 ***********************************************************************/
3467 #if defined (HAVE_XPM) || defined (MAC_OS)
3469 static int xpm_image_p
P_ ((Lisp_Object object
));
3470 static int xpm_load
P_ ((struct frame
*f
, struct image
*img
));
3471 static int xpm_valid_color_symbols_p
P_ ((Lisp_Object
));
3473 #endif /* HAVE_XPM || MAC_OS */
3477 /* Indicate to xpm.h that we don't have Xlib. */
3479 /* simx.h in xpm defines XColor and XImage differently than Emacs. */
3480 /* It also defines Display the same way as Emacs, but gcc 3.3 still barfs. */
3481 #define XColor xpm_XColor
3482 #define XImage xpm_XImage
3483 #define Display xpm_Display
3484 #define PIXEL_ALREADY_TYPEDEFED
3485 #include "X11/xpm.h"
3490 #undef PIXEL_ALREADY_TYPEDEFED
3492 #include "X11/xpm.h"
3493 #endif /* HAVE_NTGUI */
3494 #endif /* HAVE_XPM */
3496 #if defined (HAVE_XPM) || defined (MAC_OS)
3497 /* The symbol `xpm' identifying XPM-format images. */
3501 /* Indices of image specification fields in xpm_format, below. */
3503 enum xpm_keyword_index
3519 /* Vector of image_keyword structures describing the format
3520 of valid XPM image specifications. */
3522 static struct image_keyword xpm_format
[XPM_LAST
] =
3524 {":type", IMAGE_SYMBOL_VALUE
, 1},
3525 {":file", IMAGE_STRING_VALUE
, 0},
3526 {":data", IMAGE_STRING_VALUE
, 0},
3527 {":ascent", IMAGE_ASCENT_VALUE
, 0},
3528 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
3529 {":relief", IMAGE_INTEGER_VALUE
, 0},
3530 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3531 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3532 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3533 {":color-symbols", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3534 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
3537 /* Structure describing the image type XPM. */
3539 static struct image_type xpm_type
=
3548 #ifdef HAVE_X_WINDOWS
3550 /* Define ALLOC_XPM_COLORS if we can use Emacs' own color allocation
3551 functions for allocating image colors. Our own functions handle
3552 color allocation failures more gracefully than the ones on the XPM
3555 #if defined XpmAllocColor && defined XpmFreeColors && defined XpmColorClosure
3556 #define ALLOC_XPM_COLORS
3558 #endif /* HAVE_X_WINDOWS */
3560 #ifdef ALLOC_XPM_COLORS
3562 static void xpm_init_color_cache
P_ ((struct frame
*, XpmAttributes
*));
3563 static void xpm_free_color_cache
P_ ((void));
3564 static int xpm_lookup_color
P_ ((struct frame
*, char *, XColor
*));
3565 static int xpm_color_bucket
P_ ((char *));
3566 static struct xpm_cached_color
*xpm_cache_color
P_ ((struct frame
*, char *,
3569 /* An entry in a hash table used to cache color definitions of named
3570 colors. This cache is necessary to speed up XPM image loading in
3571 case we do color allocations ourselves. Without it, we would need
3572 a call to XParseColor per pixel in the image. */
3574 struct xpm_cached_color
3576 /* Next in collision chain. */
3577 struct xpm_cached_color
*next
;
3579 /* Color definition (RGB and pixel color). */
3586 /* The hash table used for the color cache, and its bucket vector
3589 #define XPM_COLOR_CACHE_BUCKETS 1001
3590 struct xpm_cached_color
**xpm_color_cache
;
3592 /* Initialize the color cache. */
3595 xpm_init_color_cache (f
, attrs
)
3597 XpmAttributes
*attrs
;
3599 size_t nbytes
= XPM_COLOR_CACHE_BUCKETS
* sizeof *xpm_color_cache
;
3600 xpm_color_cache
= (struct xpm_cached_color
**) xmalloc (nbytes
);
3601 memset (xpm_color_cache
, 0, nbytes
);
3602 init_color_table ();
3604 if (attrs
->valuemask
& XpmColorSymbols
)
3609 for (i
= 0; i
< attrs
->numsymbols
; ++i
)
3610 if (XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
3611 attrs
->colorsymbols
[i
].value
, &color
))
3613 color
.pixel
= lookup_rgb_color (f
, color
.red
, color
.green
,
3615 xpm_cache_color (f
, attrs
->colorsymbols
[i
].name
, &color
, -1);
3620 /* Free the color cache. */
3623 xpm_free_color_cache ()
3625 struct xpm_cached_color
*p
, *next
;
3628 for (i
= 0; i
< XPM_COLOR_CACHE_BUCKETS
; ++i
)
3629 for (p
= xpm_color_cache
[i
]; p
; p
= next
)
3635 xfree (xpm_color_cache
);
3636 xpm_color_cache
= NULL
;
3637 free_color_table ();
3640 /* Return the bucket index for color named COLOR_NAME in the color
3644 xpm_color_bucket (color_name
)
3650 for (s
= color_name
; *s
; ++s
)
3652 return h
%= XPM_COLOR_CACHE_BUCKETS
;
3656 /* On frame F, cache values COLOR for color with name COLOR_NAME.
3657 BUCKET, if >= 0, is a precomputed bucket index. Value is the cache
3660 static struct xpm_cached_color
*
3661 xpm_cache_color (f
, color_name
, color
, bucket
)
3668 struct xpm_cached_color
*p
;
3671 bucket
= xpm_color_bucket (color_name
);
3673 nbytes
= sizeof *p
+ strlen (color_name
);
3674 p
= (struct xpm_cached_color
*) xmalloc (nbytes
);
3675 strcpy (p
->name
, color_name
);
3677 p
->next
= xpm_color_cache
[bucket
];
3678 xpm_color_cache
[bucket
] = p
;
3682 /* Look up color COLOR_NAME for frame F in the color cache. If found,
3683 return the cached definition in *COLOR. Otherwise, make a new
3684 entry in the cache and allocate the color. Value is zero if color
3685 allocation failed. */
3688 xpm_lookup_color (f
, color_name
, color
)
3693 struct xpm_cached_color
*p
;
3694 int h
= xpm_color_bucket (color_name
);
3696 for (p
= xpm_color_cache
[h
]; p
; p
= p
->next
)
3697 if (strcmp (p
->name
, color_name
) == 0)
3702 else if (XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
3705 color
->pixel
= lookup_rgb_color (f
, color
->red
, color
->green
,
3707 p
= xpm_cache_color (f
, color_name
, color
, h
);
3709 /* You get `opaque' at least from ImageMagick converting pbm to xpm
3710 with transparency, and it's useful. */
3711 else if (strcmp ("opaque", color_name
) == 0)
3713 bzero (color
, sizeof (XColor
)); /* Is this necessary/correct? */
3714 color
->pixel
= FRAME_FOREGROUND_PIXEL (f
);
3715 p
= xpm_cache_color (f
, color_name
, color
, h
);
3722 /* Callback for allocating color COLOR_NAME. Called from the XPM lib.
3723 CLOSURE is a pointer to the frame on which we allocate the
3724 color. Return in *COLOR the allocated color. Value is non-zero
3728 xpm_alloc_color (dpy
, cmap
, color_name
, color
, closure
)
3735 return xpm_lookup_color ((struct frame
*) closure
, color_name
, color
);
3739 /* Callback for freeing NPIXELS colors contained in PIXELS. CLOSURE
3740 is a pointer to the frame on which we allocate the color. Value is
3741 non-zero if successful. */
3744 xpm_free_colors (dpy
, cmap
, pixels
, npixels
, closure
)
3754 #endif /* ALLOC_XPM_COLORS */
3759 /* XPM library details. */
3761 DEF_IMGLIB_FN (XpmFreeAttributes
);
3762 DEF_IMGLIB_FN (XpmCreateImageFromBuffer
);
3763 DEF_IMGLIB_FN (XpmReadFileToImage
);
3764 DEF_IMGLIB_FN (XImageFree
);
3767 init_xpm_functions (Lisp_Object libraries
)
3771 if (!(library
= w32_delayed_load (libraries
, Qxpm
)))
3774 LOAD_IMGLIB_FN (library
, XpmFreeAttributes
);
3775 LOAD_IMGLIB_FN (library
, XpmCreateImageFromBuffer
);
3776 LOAD_IMGLIB_FN (library
, XpmReadFileToImage
);
3777 LOAD_IMGLIB_FN (library
, XImageFree
);
3781 #endif /* HAVE_NTGUI */
3784 /* Value is non-zero if COLOR_SYMBOLS is a valid color symbols list
3785 for XPM images. Such a list must consist of conses whose car and
3789 xpm_valid_color_symbols_p (color_symbols
)
3790 Lisp_Object color_symbols
;
3792 while (CONSP (color_symbols
))
3794 Lisp_Object sym
= XCAR (color_symbols
);
3796 || !STRINGP (XCAR (sym
))
3797 || !STRINGP (XCDR (sym
)))
3799 color_symbols
= XCDR (color_symbols
);
3802 return NILP (color_symbols
);
3806 /* Value is non-zero if OBJECT is a valid XPM image specification. */
3809 xpm_image_p (object
)
3812 struct image_keyword fmt
[XPM_LAST
];
3813 bcopy (xpm_format
, fmt
, sizeof fmt
);
3814 return (parse_image_spec (object
, fmt
, XPM_LAST
, Qxpm
)
3815 /* Either `:file' or `:data' must be present. */
3816 && fmt
[XPM_FILE
].count
+ fmt
[XPM_DATA
].count
== 1
3817 /* Either no `:color-symbols' or it's a list of conses
3818 whose car and cdr are strings. */
3819 && (fmt
[XPM_COLOR_SYMBOLS
].count
== 0
3820 || xpm_valid_color_symbols_p (fmt
[XPM_COLOR_SYMBOLS
].value
)));
3823 #endif /* HAVE_XPM || MAC_OS */
3825 #if defined (HAVE_XPM) && defined (HAVE_X_WINDOWS)
3827 x_create_bitmap_from_xpm_data (f
, bits
)
3831 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
3833 XpmAttributes attrs
;
3834 Pixmap bitmap
, mask
;
3836 bzero (&attrs
, sizeof attrs
);
3838 attrs
.visual
= FRAME_X_VISUAL (f
);
3839 attrs
.colormap
= FRAME_X_COLORMAP (f
);
3840 attrs
.valuemask
|= XpmVisual
;
3841 attrs
.valuemask
|= XpmColormap
;
3843 rc
= XpmCreatePixmapFromData (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3844 bits
, &bitmap
, &mask
, &attrs
);
3845 if (rc
!= XpmSuccess
)
3847 XpmFreeAttributes (&attrs
);
3851 id
= x_allocate_bitmap_record (f
);
3852 dpyinfo
->bitmaps
[id
- 1].pixmap
= bitmap
;
3853 dpyinfo
->bitmaps
[id
- 1].have_mask
= 1;
3854 dpyinfo
->bitmaps
[id
- 1].mask
= mask
;
3855 dpyinfo
->bitmaps
[id
- 1].file
= NULL
;
3856 dpyinfo
->bitmaps
[id
- 1].height
= attrs
.height
;
3857 dpyinfo
->bitmaps
[id
- 1].width
= attrs
.width
;
3858 dpyinfo
->bitmaps
[id
- 1].depth
= attrs
.depth
;
3859 dpyinfo
->bitmaps
[id
- 1].refcount
= 1;
3861 XpmFreeAttributes (&attrs
);
3864 #endif /* defined (HAVE_XPM) && defined (HAVE_X_WINDOWS) */
3866 /* Load image IMG which will be displayed on frame F. Value is
3867 non-zero if successful. */
3877 XpmAttributes attrs
;
3878 Lisp_Object specified_file
, color_symbols
;
3881 xpm_XImage
* xpm_image
= NULL
, * xpm_mask
= NULL
;
3882 #endif /* HAVE_NTGUI */
3884 /* Configure the XPM lib. Use the visual of frame F. Allocate
3885 close colors. Return colors allocated. */
3886 bzero (&attrs
, sizeof attrs
);
3889 attrs
.visual
= FRAME_X_VISUAL (f
);
3890 attrs
.colormap
= FRAME_X_COLORMAP (f
);
3891 attrs
.valuemask
|= XpmVisual
;
3892 attrs
.valuemask
|= XpmColormap
;
3893 #endif /* HAVE_NTGUI */
3895 #ifdef ALLOC_XPM_COLORS
3896 /* Allocate colors with our own functions which handle
3897 failing color allocation more gracefully. */
3898 attrs
.color_closure
= f
;
3899 attrs
.alloc_color
= xpm_alloc_color
;
3900 attrs
.free_colors
= xpm_free_colors
;
3901 attrs
.valuemask
|= XpmAllocColor
| XpmFreeColors
| XpmColorClosure
;
3902 #else /* not ALLOC_XPM_COLORS */
3903 /* Let the XPM lib allocate colors. */
3904 attrs
.valuemask
|= XpmReturnAllocPixels
;
3905 #ifdef XpmAllocCloseColors
3906 attrs
.alloc_close_colors
= 1;
3907 attrs
.valuemask
|= XpmAllocCloseColors
;
3908 #else /* not XpmAllocCloseColors */
3909 attrs
.closeness
= 600;
3910 attrs
.valuemask
|= XpmCloseness
;
3911 #endif /* not XpmAllocCloseColors */
3912 #endif /* ALLOC_XPM_COLORS */
3913 #ifdef ALLOC_XPM_COLORS
3914 xpm_init_color_cache (f
, &attrs
);
3917 /* If image specification contains symbolic color definitions, add
3918 these to `attrs'. */
3919 color_symbols
= image_spec_value (img
->spec
, QCcolor_symbols
, NULL
);
3920 if (CONSP (color_symbols
))
3923 XpmColorSymbol
*xpm_syms
;
3926 attrs
.valuemask
|= XpmColorSymbols
;
3928 /* Count number of symbols. */
3929 attrs
.numsymbols
= 0;
3930 for (tail
= color_symbols
; CONSP (tail
); tail
= XCDR (tail
))
3933 /* Allocate an XpmColorSymbol array. */
3934 size
= attrs
.numsymbols
* sizeof *xpm_syms
;
3935 xpm_syms
= (XpmColorSymbol
*) alloca (size
);
3936 bzero (xpm_syms
, size
);
3937 attrs
.colorsymbols
= xpm_syms
;
3939 /* Fill the color symbol array. */
3940 for (tail
= color_symbols
, i
= 0;
3942 ++i
, tail
= XCDR (tail
))
3944 Lisp_Object name
= XCAR (XCAR (tail
));
3945 Lisp_Object color
= XCDR (XCAR (tail
));
3946 xpm_syms
[i
].name
= (char *) alloca (SCHARS (name
) + 1);
3947 strcpy (xpm_syms
[i
].name
, SDATA (name
));
3948 xpm_syms
[i
].value
= (char *) alloca (SCHARS (color
) + 1);
3949 strcpy (xpm_syms
[i
].value
, SDATA (color
));
3953 /* Create a pixmap for the image, either from a file, or from a
3954 string buffer containing data in the same format as an XPM file. */
3955 #ifdef ALLOC_XPM_COLORS
3956 xpm_init_color_cache (f
, &attrs
);
3959 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
3963 HDC frame_dc
= get_frame_dc (f
);
3964 hdc
= CreateCompatibleDC (frame_dc
);
3965 release_frame_dc (f
, frame_dc
);
3967 #endif /* HAVE_NTGUI */
3969 if (STRINGP (specified_file
))
3971 Lisp_Object file
= x_find_image_file (specified_file
);
3972 if (!STRINGP (file
))
3974 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
3979 /* XpmReadFileToPixmap is not available in the Windows port of
3980 libxpm. But XpmReadFileToImage almost does what we want. */
3981 rc
= fn_XpmReadFileToImage (&hdc
, SDATA (file
),
3982 &xpm_image
, &xpm_mask
,
3985 rc
= XpmReadFileToPixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3986 SDATA (file
), &img
->pixmap
, &img
->mask
,
3988 #endif /* HAVE_NTGUI */
3992 Lisp_Object buffer
= image_spec_value (img
->spec
, QCdata
, NULL
);
3994 /* XpmCreatePixmapFromBuffer is not available in the Windows port
3995 of libxpm. But XpmCreateImageFromBuffer almost does what we want. */
3996 rc
= fn_XpmCreateImageFromBuffer (&hdc
, SDATA (buffer
),
3997 &xpm_image
, &xpm_mask
,
4000 rc
= XpmCreatePixmapFromBuffer (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
4002 &img
->pixmap
, &img
->mask
,
4004 #endif /* HAVE_NTGUI */
4007 if (rc
== XpmSuccess
)
4009 #if defined (COLOR_TABLE_SUPPORT) && defined (ALLOC_XPM_COLORS)
4010 img
->colors
= colors_in_color_table (&img
->ncolors
);
4011 #else /* not ALLOC_XPM_COLORS */
4015 /* W32 XPM uses XImage to wrap what W32 Emacs calls a Pixmap,
4016 plus some duplicate attributes. */
4017 if (xpm_image
&& xpm_image
->bitmap
)
4019 img
->pixmap
= xpm_image
->bitmap
;
4020 /* XImageFree in libXpm frees XImage struct without destroying
4021 the bitmap, which is what we want. */
4022 fn_XImageFree (xpm_image
);
4024 if (xpm_mask
&& xpm_mask
->bitmap
)
4026 /* The mask appears to be inverted compared with what we expect.
4027 TODO: invert our expectations. See other places where we
4028 have to invert bits because our idea of masks is backwards. */
4030 old_obj
= SelectObject (hdc
, xpm_mask
->bitmap
);
4032 PatBlt (hdc
, 0, 0, xpm_mask
->width
, xpm_mask
->height
, DSTINVERT
);
4033 SelectObject (hdc
, old_obj
);
4035 img
->mask
= xpm_mask
->bitmap
;
4036 fn_XImageFree (xpm_mask
);
4041 #endif /* HAVE_NTGUI */
4043 /* Remember allocated colors. */
4044 img
->ncolors
= attrs
.nalloc_pixels
;
4045 img
->colors
= (unsigned long *) xmalloc (img
->ncolors
4046 * sizeof *img
->colors
);
4047 for (i
= 0; i
< attrs
.nalloc_pixels
; ++i
)
4049 img
->colors
[i
] = attrs
.alloc_pixels
[i
];
4050 #ifdef DEBUG_X_COLORS
4051 register_color (img
->colors
[i
]);
4054 #endif /* not ALLOC_XPM_COLORS */
4056 img
->width
= attrs
.width
;
4057 img
->height
= attrs
.height
;
4058 xassert (img
->width
> 0 && img
->height
> 0);
4060 /* The call to XpmFreeAttributes below frees attrs.alloc_pixels. */
4062 fn_XpmFreeAttributes (&attrs
);
4064 XpmFreeAttributes (&attrs
);
4065 #endif /* HAVE_NTGUI */
4071 #endif /* HAVE_NTGUI */
4076 image_error ("Error opening XPM file (%s)", img
->spec
, Qnil
);
4079 case XpmFileInvalid
:
4080 image_error ("Invalid XPM file (%s)", img
->spec
, Qnil
);
4084 image_error ("Out of memory (%s)", img
->spec
, Qnil
);
4087 case XpmColorFailed
:
4088 image_error ("Color allocation error (%s)", img
->spec
, Qnil
);
4092 image_error ("Unknown error (%s)", img
->spec
, Qnil
);
4097 #ifdef ALLOC_XPM_COLORS
4098 xpm_free_color_cache ();
4100 return rc
== XpmSuccess
;
4103 #endif /* HAVE_XPM */
4107 /* XPM support functions for Mac OS where libxpm is not available.
4108 Only XPM version 3 (without any extensions) is supported. */
4110 static int xpm_scan
P_ ((const unsigned char **, const unsigned char *,
4111 const unsigned char **, int *));
4112 static Lisp_Object xpm_make_color_table_v
4113 P_ ((void (**) (Lisp_Object
, const unsigned char *, int, Lisp_Object
),
4114 Lisp_Object (**) (Lisp_Object
, const unsigned char *, int)));
4115 static void xpm_put_color_table_v
P_ ((Lisp_Object
, const unsigned char *,
4117 static Lisp_Object xpm_get_color_table_v
P_ ((Lisp_Object
,
4118 const unsigned char *, int));
4119 static Lisp_Object xpm_make_color_table_h
4120 P_ ((void (**) (Lisp_Object
, const unsigned char *, int, Lisp_Object
),
4121 Lisp_Object (**) (Lisp_Object
, const unsigned char *, int)));
4122 static void xpm_put_color_table_h
P_ ((Lisp_Object
, const unsigned char *,
4124 static Lisp_Object xpm_get_color_table_h
P_ ((Lisp_Object
,
4125 const unsigned char *, int));
4126 static int xpm_str_to_color_key
P_ ((const char *));
4127 static int xpm_load_image
P_ ((struct frame
*, struct image
*,
4128 const unsigned char *, const unsigned char *));
4130 /* Tokens returned from xpm_scan. */
4139 /* Scan an XPM data and return a character (< 256) or a token defined
4140 by enum xpm_token above. *S and END are the start (inclusive) and
4141 the end (exclusive) addresses of the data, respectively. Advance
4142 *S while scanning. If token is either XPM_TK_IDENT or
4143 XPM_TK_STRING, *BEG and *LEN are set to the start address and the
4144 length of the corresponding token, respectively. */
4147 xpm_scan (s
, end
, beg
, len
)
4148 const unsigned char **s
, *end
, **beg
;
4155 /* Skip white-space. */
4156 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
4159 /* gnus-pointer.xpm uses '-' in its identifier.
4160 sb-dir-plus.xpm uses '+' in its identifier. */
4161 if (isalpha (c
) || c
== '_' || c
== '-' || c
== '+')
4165 (c
= **s
, isalnum (c
) || c
== '_' || c
== '-' || c
== '+'))
4168 return XPM_TK_IDENT
;
4173 while (*s
< end
&& **s
!= '"')
4178 return XPM_TK_STRING
;
4182 if (*s
< end
&& **s
== '*')
4184 /* C-style comment. */
4188 while (*s
< end
&& *(*s
)++ != '*')
4191 while (*s
< end
&& **s
!= '/');
4205 /* Functions for color table lookup in XPM data. A Key is a string
4206 specifying the color of each pixel in XPM data. A value is either
4207 an integer that specifies a pixel color, Qt that specifies
4208 transparency, or Qnil for the unspecified color. If the length of
4209 the key string is one, a vector is used as a table. Otherwise, a
4210 hash table is used. */
4213 xpm_make_color_table_v (put_func
, get_func
)
4214 void (**put_func
) (Lisp_Object
, const unsigned char *, int, Lisp_Object
);
4215 Lisp_Object (**get_func
) (Lisp_Object
, const unsigned char *, int);
4217 *put_func
= xpm_put_color_table_v
;
4218 *get_func
= xpm_get_color_table_v
;
4219 return Fmake_vector (make_number (256), Qnil
);
4223 xpm_put_color_table_v (color_table
, chars_start
, chars_len
, color
)
4224 Lisp_Object color_table
;
4225 const unsigned char *chars_start
;
4229 XVECTOR (color_table
)->contents
[*chars_start
] = color
;
4233 xpm_get_color_table_v (color_table
, chars_start
, chars_len
)
4234 Lisp_Object color_table
;
4235 const unsigned char *chars_start
;
4238 return XVECTOR (color_table
)->contents
[*chars_start
];
4242 xpm_make_color_table_h (put_func
, get_func
)
4243 void (**put_func
) (Lisp_Object
, const unsigned char *, int, Lisp_Object
);
4244 Lisp_Object (**get_func
) (Lisp_Object
, const unsigned char *, int);
4246 *put_func
= xpm_put_color_table_h
;
4247 *get_func
= xpm_get_color_table_h
;
4248 return make_hash_table (Qequal
, make_number (DEFAULT_HASH_SIZE
),
4249 make_float (DEFAULT_REHASH_SIZE
),
4250 make_float (DEFAULT_REHASH_THRESHOLD
),
4255 xpm_put_color_table_h (color_table
, chars_start
, chars_len
, color
)
4256 Lisp_Object color_table
;
4257 const unsigned char *chars_start
;
4261 struct Lisp_Hash_Table
*table
= XHASH_TABLE (color_table
);
4263 Lisp_Object chars
= make_unibyte_string (chars_start
, chars_len
);
4265 hash_lookup (table
, chars
, &hash_code
);
4266 hash_put (table
, chars
, color
, hash_code
);
4270 xpm_get_color_table_h (color_table
, chars_start
, chars_len
)
4271 Lisp_Object color_table
;
4272 const unsigned char *chars_start
;
4275 struct Lisp_Hash_Table
*table
= XHASH_TABLE (color_table
);
4276 int i
= hash_lookup (table
, make_unibyte_string (chars_start
, chars_len
),
4279 return i
>= 0 ? HASH_VALUE (table
, i
) : Qnil
;
4282 enum xpm_color_key
{
4290 static const char xpm_color_key_strings
[][4] = {"s", "m", "g4", "g", "c"};
4293 xpm_str_to_color_key (s
)
4299 i
< sizeof xpm_color_key_strings
/ sizeof xpm_color_key_strings
[0];
4301 if (strcmp (xpm_color_key_strings
[i
], s
) == 0)
4307 xpm_load_image (f
, img
, contents
, end
)
4310 const unsigned char *contents
, *end
;
4312 const unsigned char *s
= contents
, *beg
, *str
;
4313 unsigned char buffer
[BUFSIZ
];
4314 int width
, height
, x
, y
;
4315 int num_colors
, chars_per_pixel
;
4317 void (*put_color_table
) (Lisp_Object
, const unsigned char *, int, Lisp_Object
);
4318 Lisp_Object (*get_color_table
) (Lisp_Object
, const unsigned char *, int);
4319 Lisp_Object frame
, color_symbols
, color_table
;
4320 int best_key
, have_mask
= 0;
4321 XImagePtr ximg
= NULL
, mask_img
= NULL
;
4324 LA1 = xpm_scan (&s, end, &beg, &len)
4326 #define expect(TOKEN) \
4327 if (LA1 != (TOKEN)) \
4332 #define expect_ident(IDENT) \
4333 if (LA1 == XPM_TK_IDENT \
4334 && strlen ((IDENT)) == len && memcmp ((IDENT), beg, len) == 0) \
4339 if (!(end
- s
>= 9 && memcmp (s
, "/* XPM */", 9) == 0))
4343 expect_ident ("static");
4344 expect_ident ("char");
4346 expect (XPM_TK_IDENT
);
4351 expect (XPM_TK_STRING
);
4354 memcpy (buffer
, beg
, len
);
4356 if (sscanf (buffer
, "%d %d %d %d", &width
, &height
,
4357 &num_colors
, &chars_per_pixel
) != 4
4358 || width
<= 0 || height
<= 0
4359 || num_colors
<= 0 || chars_per_pixel
<= 0)
4362 if (!check_image_size (f
, width
, height
))
4364 image_error ("Invalid image size", Qnil
, Qnil
);
4370 XSETFRAME (frame
, f
);
4371 if (!NILP (Fxw_display_color_p (frame
)))
4372 best_key
= XPM_COLOR_KEY_C
;
4373 else if (!NILP (Fx_display_grayscale_p (frame
)))
4374 best_key
= (XFASTINT (Fx_display_planes (frame
)) > 2
4375 ? XPM_COLOR_KEY_G
: XPM_COLOR_KEY_G4
);
4377 best_key
= XPM_COLOR_KEY_M
;
4379 color_symbols
= image_spec_value (img
->spec
, QCcolor_symbols
, NULL
);
4380 if (chars_per_pixel
== 1)
4381 color_table
= xpm_make_color_table_v (&put_color_table
,
4384 color_table
= xpm_make_color_table_h (&put_color_table
,
4387 while (num_colors
-- > 0)
4389 unsigned char *color
, *max_color
;
4390 int key
, next_key
, max_key
= 0;
4391 Lisp_Object symbol_color
= Qnil
, color_val
;
4394 expect (XPM_TK_STRING
);
4395 if (len
<= chars_per_pixel
|| len
>= BUFSIZ
+ chars_per_pixel
)
4397 memcpy (buffer
, beg
+ chars_per_pixel
, len
- chars_per_pixel
);
4398 buffer
[len
- chars_per_pixel
] = '\0';
4400 str
= strtok (buffer
, " \t");
4403 key
= xpm_str_to_color_key (str
);
4408 color
= strtok (NULL
, " \t");
4412 while ((str
= strtok (NULL
, " \t")) != NULL
)
4414 next_key
= xpm_str_to_color_key (str
);
4417 color
[strlen (color
)] = ' ';
4420 if (key
== XPM_COLOR_KEY_S
)
4422 if (NILP (symbol_color
))
4423 symbol_color
= build_string (color
);
4425 else if (max_key
< key
&& key
<= best_key
)
4435 if (!NILP (color_symbols
) && !NILP (symbol_color
))
4437 Lisp_Object specified_color
= Fassoc (symbol_color
, color_symbols
);
4439 if (CONSP (specified_color
) && STRINGP (XCDR (specified_color
)))
4441 if (xstricmp (SDATA (XCDR (specified_color
)), "None") == 0)
4443 else if (x_defined_color (f
, SDATA (XCDR (specified_color
)),
4445 color_val
= make_number (cdef
.pixel
);
4448 if (NILP (color_val
) && max_key
> 0)
4450 if (xstricmp (max_color
, "None") == 0)
4452 else if (x_defined_color (f
, max_color
, &cdef
, 0))
4453 color_val
= make_number (cdef
.pixel
);
4455 if (!NILP (color_val
))
4456 (*put_color_table
) (color_table
, beg
, chars_per_pixel
, color_val
);
4461 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0,
4462 &ximg
, &img
->pixmap
)
4463 || !x_create_x_image_and_pixmap (f
, width
, height
, 1,
4464 &mask_img
, &img
->mask
))
4466 image_error ("Out of memory (%s)", img
->spec
, Qnil
);
4470 for (y
= 0; y
< height
; y
++)
4472 expect (XPM_TK_STRING
);
4474 if (len
< width
* chars_per_pixel
)
4476 for (x
= 0; x
< width
; x
++, str
+= chars_per_pixel
)
4478 Lisp_Object color_val
=
4479 (*get_color_table
) (color_table
, str
, chars_per_pixel
);
4481 XPutPixel (ximg
, x
, y
,
4482 (INTEGERP (color_val
) ? XINT (color_val
)
4483 : FRAME_FOREGROUND_PIXEL (f
)));
4484 XPutPixel (mask_img
, x
, y
,
4485 (!EQ (color_val
, Qt
) ? PIX_MASK_DRAW
4486 : (have_mask
= 1, PIX_MASK_RETAIN
)));
4493 img
->height
= height
;
4495 /* Maybe fill in the background field while we have ximg handy. */
4496 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
4497 IMAGE_BACKGROUND (img
, f
, ximg
);
4499 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
4500 x_destroy_x_image (ximg
);
4503 /* Fill in the background_transparent field while we have the
4505 image_background_transparent (img
, f
, mask_img
);
4507 x_put_x_image (f
, mask_img
, img
->mask
, width
, height
);
4508 x_destroy_x_image (mask_img
);
4512 x_destroy_x_image (mask_img
);
4513 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
4514 img
->mask
= NO_PIXMAP
;
4520 image_error ("Invalid XPM file (%s)", img
->spec
, Qnil
);
4522 x_destroy_x_image (ximg
);
4523 x_destroy_x_image (mask_img
);
4524 x_clear_image (f
, img
);
4538 Lisp_Object file_name
;
4540 /* If IMG->spec specifies a file name, create a non-file spec from it. */
4541 file_name
= image_spec_value (img
->spec
, QCfile
, NULL
);
4542 if (STRINGP (file_name
))
4545 unsigned char *contents
;
4547 struct gcpro gcpro1
;
4549 file
= x_find_image_file (file_name
);
4551 if (!STRINGP (file
))
4553 image_error ("Cannot find image file `%s'", file_name
, Qnil
);
4558 contents
= slurp_file (SDATA (file
), &size
);
4559 if (contents
== NULL
)
4561 image_error ("Error loading XPM image `%s'", img
->spec
, Qnil
);
4566 success_p
= xpm_load_image (f
, img
, contents
, contents
+ size
);
4574 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
4575 success_p
= xpm_load_image (f
, img
, SDATA (data
),
4576 SDATA (data
) + SBYTES (data
));
4586 /***********************************************************************
4588 ***********************************************************************/
4590 #ifdef COLOR_TABLE_SUPPORT
4592 /* An entry in the color table mapping an RGB color to a pixel color. */
4597 unsigned long pixel
;
4599 /* Next in color table collision list. */
4600 struct ct_color
*next
;
4603 /* The bucket vector size to use. Must be prime. */
4607 /* Value is a hash of the RGB color given by R, G, and B. */
4609 #define CT_HASH_RGB(R, G, B) (((R) << 16) ^ ((G) << 8) ^ (B))
4611 /* The color hash table. */
4613 struct ct_color
**ct_table
;
4615 /* Number of entries in the color table. */
4617 int ct_colors_allocated
;
4619 /* Initialize the color table. */
4624 int size
= CT_SIZE
* sizeof (*ct_table
);
4625 ct_table
= (struct ct_color
**) xmalloc (size
);
4626 bzero (ct_table
, size
);
4627 ct_colors_allocated
= 0;
4631 /* Free memory associated with the color table. */
4637 struct ct_color
*p
, *next
;
4639 for (i
= 0; i
< CT_SIZE
; ++i
)
4640 for (p
= ct_table
[i
]; p
; p
= next
)
4651 /* Value is a pixel color for RGB color R, G, B on frame F. If an
4652 entry for that color already is in the color table, return the
4653 pixel color of that entry. Otherwise, allocate a new color for R,
4654 G, B, and make an entry in the color table. */
4656 static unsigned long
4657 lookup_rgb_color (f
, r
, g
, b
)
4661 unsigned hash
= CT_HASH_RGB (r
, g
, b
);
4662 int i
= hash
% CT_SIZE
;
4664 Display_Info
*dpyinfo
;
4666 /* Handle TrueColor visuals specially, which improves performance by
4667 two orders of magnitude. Freeing colors on TrueColor visuals is
4668 a nop, and pixel colors specify RGB values directly. See also
4669 the Xlib spec, chapter 3.1. */
4670 dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
4671 if (dpyinfo
->red_bits
> 0)
4673 unsigned long pr
, pg
, pb
;
4675 /* Apply gamma-correction like normal color allocation does. */
4679 color
.red
= r
, color
.green
= g
, color
.blue
= b
;
4680 gamma_correct (f
, &color
);
4681 r
= color
.red
, g
= color
.green
, b
= color
.blue
;
4684 /* Scale down RGB values to the visual's bits per RGB, and shift
4685 them to the right position in the pixel color. Note that the
4686 original RGB values are 16-bit values, as usual in X. */
4687 pr
= (r
>> (16 - dpyinfo
->red_bits
)) << dpyinfo
->red_offset
;
4688 pg
= (g
>> (16 - dpyinfo
->green_bits
)) << dpyinfo
->green_offset
;
4689 pb
= (b
>> (16 - dpyinfo
->blue_bits
)) << dpyinfo
->blue_offset
;
4691 /* Assemble the pixel color. */
4692 return pr
| pg
| pb
;
4695 for (p
= ct_table
[i
]; p
; p
= p
->next
)
4696 if (p
->r
== r
&& p
->g
== g
&& p
->b
== b
)
4702 #ifdef HAVE_X_WINDOWS
4711 cmap
= FRAME_X_COLORMAP (f
);
4712 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
4715 ++ct_colors_allocated
;
4716 p
= (struct ct_color
*) xmalloc (sizeof *p
);
4720 p
->pixel
= color
.pixel
;
4721 p
->next
= ct_table
[i
];
4725 return FRAME_FOREGROUND_PIXEL (f
);
4730 color
= PALETTERGB (r
, g
, b
);
4732 color
= RGB_TO_ULONG (r
, g
, b
);
4733 #endif /* HAVE_NTGUI */
4734 ++ct_colors_allocated
;
4735 p
= (struct ct_color
*) xmalloc (sizeof *p
);
4740 p
->next
= ct_table
[i
];
4742 #endif /* HAVE_X_WINDOWS */
4750 /* Look up pixel color PIXEL which is used on frame F in the color
4751 table. If not already present, allocate it. Value is PIXEL. */
4753 static unsigned long
4754 lookup_pixel_color (f
, pixel
)
4756 unsigned long pixel
;
4758 int i
= pixel
% CT_SIZE
;
4761 for (p
= ct_table
[i
]; p
; p
= p
->next
)
4762 if (p
->pixel
== pixel
)
4771 #ifdef HAVE_X_WINDOWS
4772 cmap
= FRAME_X_COLORMAP (f
);
4773 color
.pixel
= pixel
;
4774 x_query_color (f
, &color
);
4775 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
4778 cmap
= DefaultColormapOfScreen (FRAME_X_SCREEN (f
));
4779 color
.pixel
= pixel
;
4780 XQueryColor (NULL
, cmap
, &color
);
4781 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
4783 #endif /* HAVE_X_WINDOWS */
4787 ++ct_colors_allocated
;
4789 p
= (struct ct_color
*) xmalloc (sizeof *p
);
4794 p
->next
= ct_table
[i
];
4798 return FRAME_FOREGROUND_PIXEL (f
);
4804 /* Value is a vector of all pixel colors contained in the color table,
4805 allocated via xmalloc. Set *N to the number of colors. */
4807 static unsigned long *
4808 colors_in_color_table (n
)
4813 unsigned long *colors
;
4815 if (ct_colors_allocated
== 0)
4822 colors
= (unsigned long *) xmalloc (ct_colors_allocated
4824 *n
= ct_colors_allocated
;
4826 for (i
= j
= 0; i
< CT_SIZE
; ++i
)
4827 for (p
= ct_table
[i
]; p
; p
= p
->next
)
4828 colors
[j
++] = p
->pixel
;
4834 #else /* COLOR_TABLE_SUPPORT */
4836 static unsigned long
4837 lookup_rgb_color (f
, r
, g
, b
)
4841 unsigned long pixel
;
4844 pixel
= RGB_TO_ULONG (r
>> 8, g
>> 8, b
>> 8);
4845 gamma_correct (f
, &pixel
);
4849 pixel
= PALETTERGB (r
>> 8, g
>> 8, b
>> 8);
4850 #endif /* HAVE_NTGUI */
4859 #endif /* COLOR_TABLE_SUPPORT */
4862 /***********************************************************************
4864 ***********************************************************************/
4866 static XColor
*x_to_xcolors
P_ ((struct frame
*, struct image
*, int));
4867 static void x_from_xcolors
P_ ((struct frame
*, struct image
*, XColor
*));
4868 static void x_detect_edges
P_ ((struct frame
*, struct image
*, int[9], int));
4871 static void XPutPixel (XImagePtr
, int, int, COLORREF
);
4872 #endif /* HAVE_NTGUI */
4874 /* Non-zero means draw a cross on images having `:conversion
4877 int cross_disabled_images
;
4879 /* Edge detection matrices for different edge-detection
4882 static int emboss_matrix
[9] = {
4884 2, -1, 0, /* y - 1 */
4886 0, 1, -2 /* y + 1 */
4889 static int laplace_matrix
[9] = {
4891 1, 0, 0, /* y - 1 */
4893 0, 0, -1 /* y + 1 */
4896 /* Value is the intensity of the color whose red/green/blue values
4899 #define COLOR_INTENSITY(R, G, B) ((2 * (R) + 3 * (G) + (B)) / 6)
4902 /* On frame F, return an array of XColor structures describing image
4903 IMG->pixmap. Each XColor structure has its pixel color set. RGB_P
4904 non-zero means also fill the red/green/blue members of the XColor
4905 structures. Value is a pointer to the array of XColors structures,
4906 allocated with xmalloc; it must be freed by the caller. */
4909 x_to_xcolors (f
, img
, rgb_p
)
4916 XImagePtr_or_DC ximg
;
4920 #endif /* HAVE_NTGUI */
4922 colors
= (XColor
*) xmalloc (img
->width
* img
->height
* sizeof *colors
);
4925 /* Get the X image IMG->pixmap. */
4926 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
4927 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
4929 /* Load the image into a memory device context. */
4930 hdc
= get_frame_dc (f
);
4931 ximg
= CreateCompatibleDC (hdc
);
4932 release_frame_dc (f
, hdc
);
4933 prev
= SelectObject (ximg
, img
->pixmap
);
4934 #endif /* HAVE_NTGUI */
4936 /* Fill the `pixel' members of the XColor array. I wished there
4937 were an easy and portable way to circumvent XGetPixel. */
4939 for (y
= 0; y
< img
->height
; ++y
)
4943 #ifdef HAVE_X_WINDOWS
4944 for (x
= 0; x
< img
->width
; ++x
, ++p
)
4945 p
->pixel
= XGetPixel (ximg
, x
, y
);
4947 x_query_colors (f
, row
, img
->width
);
4951 for (x
= 0; x
< img
->width
; ++x
, ++p
)
4953 /* W32_TODO: palette support needed here? */
4954 p
->pixel
= GET_PIXEL (ximg
, x
, y
);
4958 p
->red
= RED16_FROM_ULONG (p
->pixel
);
4959 p
->green
= GREEN16_FROM_ULONG (p
->pixel
);
4960 p
->blue
= BLUE16_FROM_ULONG (p
->pixel
);
4963 p
->red
= 256 * GetRValue (p
->pixel
);
4964 p
->green
= 256 * GetGValue (p
->pixel
);
4965 p
->blue
= 256 * GetBValue (p
->pixel
);
4966 #endif /* HAVE_NTGUI */
4969 #endif /* HAVE_X_WINDOWS */
4972 Destroy_Image (ximg
, prev
);
4979 /* Put a pixel of COLOR at position X, Y in XIMG. XIMG must have been
4980 created with CreateDIBSection, with the pointer to the bit values
4981 stored in ximg->data. */
4983 static void XPutPixel (ximg
, x
, y
, color
)
4988 int width
= ximg
->info
.bmiHeader
.biWidth
;
4989 int height
= ximg
->info
.bmiHeader
.biHeight
;
4990 unsigned char * pixel
;
4992 /* True color images. */
4993 if (ximg
->info
.bmiHeader
.biBitCount
== 24)
4995 int rowbytes
= width
* 3;
4996 /* Ensure scanlines are aligned on 4 byte boundaries. */
4998 rowbytes
+= 4 - (rowbytes
% 4);
5000 pixel
= ximg
->data
+ y
* rowbytes
+ x
* 3;
5001 /* Windows bitmaps are in BGR order. */
5002 *pixel
= GetBValue (color
);
5003 *(pixel
+ 1) = GetGValue (color
);
5004 *(pixel
+ 2) = GetRValue (color
);
5006 /* Monochrome images. */
5007 else if (ximg
->info
.bmiHeader
.biBitCount
== 1)
5009 int rowbytes
= width
/ 8;
5010 /* Ensure scanlines are aligned on 4 byte boundaries. */
5012 rowbytes
+= 4 - (rowbytes
% 4);
5013 pixel
= ximg
->data
+ y
* rowbytes
+ x
/ 8;
5014 /* Filter out palette info. */
5015 if (color
& 0x00ffffff)
5016 *pixel
= *pixel
| (1 << x
% 8);
5018 *pixel
= *pixel
& ~(1 << x
% 8);
5021 image_error ("XPutPixel: palette image not supported", Qnil
, Qnil
);
5024 #endif /* HAVE_NTGUI */
5026 /* Create IMG->pixmap from an array COLORS of XColor structures, whose
5027 RGB members are set. F is the frame on which this all happens.
5028 COLORS will be freed; an existing IMG->pixmap will be freed, too. */
5031 x_from_xcolors (f
, img
, colors
)
5041 init_color_table ();
5043 x_create_x_image_and_pixmap (f
, img
->width
, img
->height
, 0,
5046 for (y
= 0; y
< img
->height
; ++y
)
5047 for (x
= 0; x
< img
->width
; ++x
, ++p
)
5049 unsigned long pixel
;
5050 pixel
= lookup_rgb_color (f
, p
->red
, p
->green
, p
->blue
);
5051 XPutPixel (oimg
, x
, y
, pixel
);
5055 x_clear_image_1 (f
, img
, 1, 0, 1);
5057 x_put_x_image (f
, oimg
, pixmap
, img
->width
, img
->height
);
5058 x_destroy_x_image (oimg
);
5059 img
->pixmap
= pixmap
;
5060 #ifdef COLOR_TABLE_SUPPORT
5061 img
->colors
= colors_in_color_table (&img
->ncolors
);
5062 free_color_table ();
5063 #endif /* COLOR_TABLE_SUPPORT */
5067 /* On frame F, perform edge-detection on image IMG.
5069 MATRIX is a nine-element array specifying the transformation
5070 matrix. See emboss_matrix for an example.
5072 COLOR_ADJUST is a color adjustment added to each pixel of the
5076 x_detect_edges (f
, img
, matrix
, color_adjust
)
5079 int matrix
[9], color_adjust
;
5081 XColor
*colors
= x_to_xcolors (f
, img
, 1);
5085 for (i
= sum
= 0; i
< 9; ++i
)
5086 sum
+= abs (matrix
[i
]);
5088 #define COLOR(A, X, Y) ((A) + (Y) * img->width + (X))
5090 new = (XColor
*) xmalloc (img
->width
* img
->height
* sizeof *new);
5092 for (y
= 0; y
< img
->height
; ++y
)
5094 p
= COLOR (new, 0, y
);
5095 p
->red
= p
->green
= p
->blue
= 0xffff/2;
5096 p
= COLOR (new, img
->width
- 1, y
);
5097 p
->red
= p
->green
= p
->blue
= 0xffff/2;
5100 for (x
= 1; x
< img
->width
- 1; ++x
)
5102 p
= COLOR (new, x
, 0);
5103 p
->red
= p
->green
= p
->blue
= 0xffff/2;
5104 p
= COLOR (new, x
, img
->height
- 1);
5105 p
->red
= p
->green
= p
->blue
= 0xffff/2;
5108 for (y
= 1; y
< img
->height
- 1; ++y
)
5110 p
= COLOR (new, 1, y
);
5112 for (x
= 1; x
< img
->width
- 1; ++x
, ++p
)
5114 int r
, g
, b
, y1
, x1
;
5117 for (y1
= y
- 1; y1
< y
+ 2; ++y1
)
5118 for (x1
= x
- 1; x1
< x
+ 2; ++x1
, ++i
)
5121 XColor
*t
= COLOR (colors
, x1
, y1
);
5122 r
+= matrix
[i
] * t
->red
;
5123 g
+= matrix
[i
] * t
->green
;
5124 b
+= matrix
[i
] * t
->blue
;
5127 r
= (r
/ sum
+ color_adjust
) & 0xffff;
5128 g
= (g
/ sum
+ color_adjust
) & 0xffff;
5129 b
= (b
/ sum
+ color_adjust
) & 0xffff;
5130 p
->red
= p
->green
= p
->blue
= COLOR_INTENSITY (r
, g
, b
);
5135 x_from_xcolors (f
, img
, new);
5141 /* Perform the pre-defined `emboss' edge-detection on image IMG
5149 x_detect_edges (f
, img
, emboss_matrix
, 0xffff / 2);
5153 /* Transform image IMG which is used on frame F with a Laplace
5154 edge-detection algorithm. The result is an image that can be used
5155 to draw disabled buttons, for example. */
5162 x_detect_edges (f
, img
, laplace_matrix
, 45000);
5166 /* Perform edge-detection on image IMG on frame F, with specified
5167 transformation matrix MATRIX and color-adjustment COLOR_ADJUST.
5169 MATRIX must be either
5171 - a list of at least 9 numbers in row-major form
5172 - a vector of at least 9 numbers
5174 COLOR_ADJUST nil means use a default; otherwise it must be a
5178 x_edge_detection (f
, img
, matrix
, color_adjust
)
5181 Lisp_Object matrix
, color_adjust
;
5189 i
< 9 && CONSP (matrix
) && NUMBERP (XCAR (matrix
));
5190 ++i
, matrix
= XCDR (matrix
))
5191 trans
[i
] = XFLOATINT (XCAR (matrix
));
5193 else if (VECTORP (matrix
) && ASIZE (matrix
) >= 9)
5195 for (i
= 0; i
< 9 && NUMBERP (AREF (matrix
, i
)); ++i
)
5196 trans
[i
] = XFLOATINT (AREF (matrix
, i
));
5199 if (NILP (color_adjust
))
5200 color_adjust
= make_number (0xffff / 2);
5202 if (i
== 9 && NUMBERP (color_adjust
))
5203 x_detect_edges (f
, img
, trans
, (int) XFLOATINT (color_adjust
));
5207 /* Transform image IMG on frame F so that it looks disabled. */
5210 x_disable_image (f
, img
)
5214 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
5216 int n_planes
= dpyinfo
->n_planes
* dpyinfo
->n_cbits
;
5218 int n_planes
= dpyinfo
->n_planes
;
5219 #endif /* HAVE_NTGUI */
5223 /* Color (or grayscale). Convert to gray, and equalize. Just
5224 drawing such images with a stipple can look very odd, so
5225 we're using this method instead. */
5226 XColor
*colors
= x_to_xcolors (f
, img
, 1);
5228 const int h
= 15000;
5229 const int l
= 30000;
5231 for (p
= colors
, end
= colors
+ img
->width
* img
->height
;
5235 int i
= COLOR_INTENSITY (p
->red
, p
->green
, p
->blue
);
5236 int i2
= (0xffff - h
- l
) * i
/ 0xffff + l
;
5237 p
->red
= p
->green
= p
->blue
= i2
;
5240 x_from_xcolors (f
, img
, colors
);
5243 /* Draw a cross over the disabled image, if we must or if we
5245 if (n_planes
< 2 || cross_disabled_images
)
5248 Display
*dpy
= FRAME_X_DISPLAY (f
);
5252 #define MaskForeground(f) PIX_MASK_DRAW
5254 #define MaskForeground(f) WHITE_PIX_DEFAULT (f)
5257 gc
= XCreateGC (dpy
, img
->pixmap
, 0, NULL
);
5258 XSetForeground (dpy
, gc
, BLACK_PIX_DEFAULT (f
));
5259 XDrawLine (dpy
, img
->pixmap
, gc
, 0, 0,
5260 img
->width
- 1, img
->height
- 1);
5261 XDrawLine (dpy
, img
->pixmap
, gc
, 0, img
->height
- 1,
5267 gc
= XCreateGC (dpy
, img
->mask
, 0, NULL
);
5268 XSetForeground (dpy
, gc
, MaskForeground (f
));
5269 XDrawLine (dpy
, img
->mask
, gc
, 0, 0,
5270 img
->width
- 1, img
->height
- 1);
5271 XDrawLine (dpy
, img
->mask
, gc
, 0, img
->height
- 1,
5279 hdc
= get_frame_dc (f
);
5280 bmpdc
= CreateCompatibleDC (hdc
);
5281 release_frame_dc (f
, hdc
);
5283 prev
= SelectObject (bmpdc
, img
->pixmap
);
5285 SetTextColor (bmpdc
, BLACK_PIX_DEFAULT (f
));
5286 MoveToEx (bmpdc
, 0, 0, NULL
);
5287 LineTo (bmpdc
, img
->width
- 1, img
->height
- 1);
5288 MoveToEx (bmpdc
, 0, img
->height
- 1, NULL
);
5289 LineTo (bmpdc
, img
->width
- 1, 0);
5293 SelectObject (bmpdc
, img
->mask
);
5294 SetTextColor (bmpdc
, WHITE_PIX_DEFAULT (f
));
5295 MoveToEx (bmpdc
, 0, 0, NULL
);
5296 LineTo (bmpdc
, img
->width
- 1, img
->height
- 1);
5297 MoveToEx (bmpdc
, 0, img
->height
- 1, NULL
);
5298 LineTo (bmpdc
, img
->width
- 1, 0);
5300 SelectObject (bmpdc
, prev
);
5302 #endif /* HAVE_NTGUI */
5307 /* Build a mask for image IMG which is used on frame F. FILE is the
5308 name of an image file, for error messages. HOW determines how to
5309 determine the background color of IMG. If it is a list '(R G B)',
5310 with R, G, and B being integers >= 0, take that as the color of the
5311 background. Otherwise, determine the background color of IMG
5312 heuristically. Value is non-zero if successful. */
5315 x_build_heuristic_mask (f
, img
, how
)
5320 XImagePtr_or_DC ximg
;
5328 #endif /* HAVE_NTGUI */
5329 int x
, y
, rc
, use_img_background
;
5330 unsigned long bg
= 0;
5334 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
5335 img
->mask
= NO_PIXMAP
;
5336 img
->background_transparent_valid
= 0;
5340 /* Create an image and pixmap serving as mask. */
5341 rc
= x_create_x_image_and_pixmap (f
, img
->width
, img
->height
, 1,
5342 &mask_img
, &img
->mask
);
5346 /* Get the X image of IMG->pixmap. */
5347 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
, 0, 0,
5348 img
->width
, img
->height
,
5351 /* Create the bit array serving as mask. */
5352 row_width
= (img
->width
+ 7) / 8;
5353 mask_img
= xmalloc (row_width
* img
->height
);
5354 bzero (mask_img
, row_width
* img
->height
);
5356 /* Create a memory device context for IMG->pixmap. */
5357 frame_dc
= get_frame_dc (f
);
5358 ximg
= CreateCompatibleDC (frame_dc
);
5359 release_frame_dc (f
, frame_dc
);
5360 prev
= SelectObject (ximg
, img
->pixmap
);
5361 #endif /* HAVE_NTGUI */
5363 /* Determine the background color of ximg. If HOW is `(R G B)'
5364 take that as color. Otherwise, use the image's background color. */
5365 use_img_background
= 1;
5371 for (i
= 0; i
< 3 && CONSP (how
) && NATNUMP (XCAR (how
)); ++i
)
5373 rgb
[i
] = XFASTINT (XCAR (how
)) & 0xffff;
5377 if (i
== 3 && NILP (how
))
5379 char color_name
[30];
5380 sprintf (color_name
, "#%04x%04x%04x", rgb
[0], rgb
[1], rgb
[2]);
5383 0x00ffffff & /* Filter out palette info. */
5384 #endif /* HAVE_NTGUI */
5385 x_alloc_image_color (f
, img
, build_string (color_name
), 0));
5386 use_img_background
= 0;
5390 if (use_img_background
)
5391 bg
= four_corners_best (ximg
, img
->corners
, img
->width
, img
->height
);
5393 /* Set all bits in mask_img to 1 whose color in ximg is different
5394 from the background color bg. */
5396 for (y
= 0; y
< img
->height
; ++y
)
5397 for (x
= 0; x
< img
->width
; ++x
)
5398 XPutPixel (mask_img
, x
, y
, (XGetPixel (ximg
, x
, y
) != bg
5399 ? PIX_MASK_DRAW
: PIX_MASK_RETAIN
));
5401 /* Fill in the background_transparent field while we have the mask handy. */
5402 image_background_transparent (img
, f
, mask_img
);
5404 /* Put mask_img into img->mask. */
5405 x_put_x_image (f
, mask_img
, img
->mask
, img
->width
, img
->height
);
5406 x_destroy_x_image (mask_img
);
5409 for (y
= 0; y
< img
->height
; ++y
)
5410 for (x
= 0; x
< img
->width
; ++x
)
5412 COLORREF p
= GetPixel (ximg
, x
, y
);
5414 mask_img
[y
* row_width
+ x
/ 8] |= 1 << (x
% 8);
5417 /* Create the mask image. */
5418 img
->mask
= w32_create_pixmap_from_bitmap_data (img
->width
, img
->height
,
5420 /* Fill in the background_transparent field while we have the mask handy. */
5421 SelectObject (ximg
, img
->mask
);
5422 image_background_transparent (img
, f
, ximg
);
5424 /* Was: x_destroy_x_image ((XImagePtr )mask_img); which seems bogus ++kfs */
5426 #endif /* HAVE_NTGUI */
5428 Destroy_Image (ximg
, prev
);
5434 /***********************************************************************
5435 PBM (mono, gray, color)
5436 ***********************************************************************/
5438 static int pbm_image_p
P_ ((Lisp_Object object
));
5439 static int pbm_load
P_ ((struct frame
*f
, struct image
*img
));
5440 static int pbm_scan_number
P_ ((unsigned char **, unsigned char *));
5442 /* The symbol `pbm' identifying images of this type. */
5446 /* Indices of image specification fields in gs_format, below. */
5448 enum pbm_keyword_index
5464 /* Vector of image_keyword structures describing the format
5465 of valid user-defined image specifications. */
5467 static struct image_keyword pbm_format
[PBM_LAST
] =
5469 {":type", IMAGE_SYMBOL_VALUE
, 1},
5470 {":file", IMAGE_STRING_VALUE
, 0},
5471 {":data", IMAGE_STRING_VALUE
, 0},
5472 {":ascent", IMAGE_ASCENT_VALUE
, 0},
5473 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
5474 {":relief", IMAGE_INTEGER_VALUE
, 0},
5475 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5476 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5477 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5478 {":foreground", IMAGE_STRING_OR_NIL_VALUE
, 0},
5479 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
5482 /* Structure describing the image type `pbm'. */
5484 static struct image_type pbm_type
=
5494 /* Return non-zero if OBJECT is a valid PBM image specification. */
5497 pbm_image_p (object
)
5500 struct image_keyword fmt
[PBM_LAST
];
5502 bcopy (pbm_format
, fmt
, sizeof fmt
);
5504 if (!parse_image_spec (object
, fmt
, PBM_LAST
, Qpbm
))
5507 /* Must specify either :data or :file. */
5508 return fmt
[PBM_DATA
].count
+ fmt
[PBM_FILE
].count
== 1;
5512 /* Scan a decimal number from *S and return it. Advance *S while
5513 reading the number. END is the end of the string. Value is -1 at
5517 pbm_scan_number (s
, end
)
5518 unsigned char **s
, *end
;
5520 int c
= 0, val
= -1;
5524 /* Skip white-space. */
5525 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
5530 /* Skip comment to end of line. */
5531 while (*s
< end
&& (c
= *(*s
)++, c
!= '\n'))
5534 else if (isdigit (c
))
5536 /* Read decimal number. */
5538 while (*s
< end
&& (c
= *(*s
)++, isdigit (c
)))
5539 val
= 10 * val
+ c
- '0';
5551 #if 0 /* Unused. ++kfs */
5553 /* Read FILE into memory. Value is a pointer to a buffer allocated
5554 with xmalloc holding FILE's contents. Value is null if an error
5555 occurred. *SIZE is set to the size of the file. */
5558 pbm_read_file (file
, size
)
5566 if (stat (SDATA (file
), &st
) == 0
5567 && (fp
= fopen (SDATA (file
), "rb")) != NULL
5568 && (buf
= (char *) xmalloc (st
.st_size
),
5569 fread (buf
, 1, st
.st_size
, fp
) == st
.st_size
))
5588 #endif /* HAVE_NTGUI */
5590 /* Load PBM image IMG for use on frame F. */
5598 int width
, height
, max_color_idx
= 0;
5600 Lisp_Object file
, specified_file
;
5601 enum {PBM_MONO
, PBM_GRAY
, PBM_COLOR
} type
;
5602 struct gcpro gcpro1
;
5603 unsigned char *contents
= NULL
;
5604 unsigned char *end
, *p
;
5607 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
5611 if (STRINGP (specified_file
))
5613 file
= x_find_image_file (specified_file
);
5614 if (!STRINGP (file
))
5616 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
5621 contents
= slurp_file (SDATA (file
), &size
);
5622 if (contents
== NULL
)
5624 image_error ("Error reading `%s'", file
, Qnil
);
5630 end
= contents
+ size
;
5635 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
5637 end
= p
+ SBYTES (data
);
5640 /* Check magic number. */
5641 if (end
- p
< 2 || *p
++ != 'P')
5643 image_error ("Not a PBM image: `%s'", img
->spec
, Qnil
);
5653 raw_p
= 0, type
= PBM_MONO
;
5657 raw_p
= 0, type
= PBM_GRAY
;
5661 raw_p
= 0, type
= PBM_COLOR
;
5665 raw_p
= 1, type
= PBM_MONO
;
5669 raw_p
= 1, type
= PBM_GRAY
;
5673 raw_p
= 1, type
= PBM_COLOR
;
5677 image_error ("Not a PBM image: `%s'", img
->spec
, Qnil
);
5681 /* Read width, height, maximum color-component. Characters
5682 starting with `#' up to the end of a line are ignored. */
5683 width
= pbm_scan_number (&p
, end
);
5684 height
= pbm_scan_number (&p
, end
);
5686 if (type
!= PBM_MONO
)
5688 max_color_idx
= pbm_scan_number (&p
, end
);
5689 if (raw_p
&& max_color_idx
> 255)
5690 max_color_idx
= 255;
5693 if (!check_image_size (f
, width
, height
)
5694 || (type
!= PBM_MONO
&& max_color_idx
< 0))
5697 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0,
5698 &ximg
, &img
->pixmap
))
5701 /* Initialize the color hash table. */
5702 init_color_table ();
5704 if (type
== PBM_MONO
)
5707 struct image_keyword fmt
[PBM_LAST
];
5708 unsigned long fg
= FRAME_FOREGROUND_PIXEL (f
);
5709 unsigned long bg
= FRAME_BACKGROUND_PIXEL (f
);
5711 /* Parse the image specification. */
5712 bcopy (pbm_format
, fmt
, sizeof fmt
);
5713 parse_image_spec (img
->spec
, fmt
, PBM_LAST
, Qpbm
);
5715 /* Get foreground and background colors, maybe allocate colors. */
5716 if (fmt
[PBM_FOREGROUND
].count
5717 && STRINGP (fmt
[PBM_FOREGROUND
].value
))
5718 fg
= x_alloc_image_color (f
, img
, fmt
[PBM_FOREGROUND
].value
, fg
);
5719 if (fmt
[PBM_BACKGROUND
].count
5720 && STRINGP (fmt
[PBM_BACKGROUND
].value
))
5722 bg
= x_alloc_image_color (f
, img
, fmt
[PBM_BACKGROUND
].value
, bg
);
5723 img
->background
= bg
;
5724 img
->background_valid
= 1;
5727 for (y
= 0; y
< height
; ++y
)
5728 for (x
= 0; x
< width
; ++x
)
5736 x_destroy_x_image (ximg
);
5737 x_clear_image (f
, img
);
5738 image_error ("Invalid image size in image `%s'",
5748 g
= pbm_scan_number (&p
, end
);
5750 XPutPixel (ximg
, x
, y
, g
? fg
: bg
);
5756 && ((type
== PBM_GRAY
)
5757 ? (p
+ height
* width
> end
)
5758 : (p
+ 3 * height
* width
> end
)))
5760 x_destroy_x_image (ximg
);
5761 x_clear_image (f
, img
);
5762 image_error ("Invalid image size in image `%s'",
5767 for (y
= 0; y
< height
; ++y
)
5768 for (x
= 0; x
< width
; ++x
)
5772 if (type
== PBM_GRAY
)
5773 r
= g
= b
= raw_p
? *p
++ : pbm_scan_number (&p
, end
);
5782 r
= pbm_scan_number (&p
, end
);
5783 g
= pbm_scan_number (&p
, end
);
5784 b
= pbm_scan_number (&p
, end
);
5787 if (r
< 0 || g
< 0 || b
< 0)
5789 x_destroy_x_image (ximg
);
5790 image_error ("Invalid pixel value in image `%s'",
5795 /* RGB values are now in the range 0..max_color_idx.
5796 Scale this to the range 0..0xffff supported by X. */
5797 r
= (double) r
* 65535 / max_color_idx
;
5798 g
= (double) g
* 65535 / max_color_idx
;
5799 b
= (double) b
* 65535 / max_color_idx
;
5800 XPutPixel (ximg
, x
, y
, lookup_rgb_color (f
, r
, g
, b
));
5804 #ifdef COLOR_TABLE_SUPPORT
5805 /* Store in IMG->colors the colors allocated for the image, and
5806 free the color table. */
5807 img
->colors
= colors_in_color_table (&img
->ncolors
);
5808 free_color_table ();
5809 #endif /* COLOR_TABLE_SUPPORT */
5812 img
->height
= height
;
5814 /* Maybe fill in the background field while we have ximg handy. */
5816 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
5817 /* Casting avoids a GCC warning. */
5818 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
5820 /* Put the image into a pixmap. */
5821 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
5822 x_destroy_x_image (ximg
);
5824 /* X and W32 versions did it here, MAC version above. ++kfs
5826 img->height = height; */
5834 /***********************************************************************
5836 ***********************************************************************/
5838 #if defined (HAVE_PNG) || defined (MAC_OS)
5840 /* Function prototypes. */
5842 static int png_image_p
P_ ((Lisp_Object object
));
5843 static int png_load
P_ ((struct frame
*f
, struct image
*img
));
5845 /* The symbol `png' identifying images of this type. */
5849 /* Indices of image specification fields in png_format, below. */
5851 enum png_keyword_index
5866 /* Vector of image_keyword structures describing the format
5867 of valid user-defined image specifications. */
5869 static struct image_keyword png_format
[PNG_LAST
] =
5871 {":type", IMAGE_SYMBOL_VALUE
, 1},
5872 {":data", IMAGE_STRING_VALUE
, 0},
5873 {":file", IMAGE_STRING_VALUE
, 0},
5874 {":ascent", IMAGE_ASCENT_VALUE
, 0},
5875 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
5876 {":relief", IMAGE_INTEGER_VALUE
, 0},
5877 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5878 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5879 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5880 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
5883 /* Structure describing the image type `png'. */
5885 static struct image_type png_type
=
5894 /* Return non-zero if OBJECT is a valid PNG image specification. */
5897 png_image_p (object
)
5900 struct image_keyword fmt
[PNG_LAST
];
5901 bcopy (png_format
, fmt
, sizeof fmt
);
5903 if (!parse_image_spec (object
, fmt
, PNG_LAST
, Qpng
))
5906 /* Must specify either the :data or :file keyword. */
5907 return fmt
[PNG_FILE
].count
+ fmt
[PNG_DATA
].count
== 1;
5910 #endif /* HAVE_PNG || MAC_OS */
5915 #if defined HAVE_LIBPNG_PNG_H
5916 # include <libpng/png.h>
5922 /* PNG library details. */
5924 DEF_IMGLIB_FN (png_get_io_ptr
);
5925 DEF_IMGLIB_FN (png_check_sig
);
5926 DEF_IMGLIB_FN (png_create_read_struct
);
5927 DEF_IMGLIB_FN (png_create_info_struct
);
5928 DEF_IMGLIB_FN (png_destroy_read_struct
);
5929 DEF_IMGLIB_FN (png_set_read_fn
);
5930 DEF_IMGLIB_FN (png_set_sig_bytes
);
5931 DEF_IMGLIB_FN (png_read_info
);
5932 DEF_IMGLIB_FN (png_get_IHDR
);
5933 DEF_IMGLIB_FN (png_get_valid
);
5934 DEF_IMGLIB_FN (png_set_strip_16
);
5935 DEF_IMGLIB_FN (png_set_expand
);
5936 DEF_IMGLIB_FN (png_set_gray_to_rgb
);
5937 DEF_IMGLIB_FN (png_set_background
);
5938 DEF_IMGLIB_FN (png_get_bKGD
);
5939 DEF_IMGLIB_FN (png_read_update_info
);
5940 DEF_IMGLIB_FN (png_get_channels
);
5941 DEF_IMGLIB_FN (png_get_rowbytes
);
5942 DEF_IMGLIB_FN (png_read_image
);
5943 DEF_IMGLIB_FN (png_read_end
);
5944 DEF_IMGLIB_FN (png_error
);
5947 init_png_functions (Lisp_Object libraries
)
5951 /* Try loading libpng under probable names. */
5952 if (!(library
= w32_delayed_load (libraries
, Qpng
)))
5955 LOAD_IMGLIB_FN (library
, png_get_io_ptr
);
5956 LOAD_IMGLIB_FN (library
, png_check_sig
);
5957 LOAD_IMGLIB_FN (library
, png_create_read_struct
);
5958 LOAD_IMGLIB_FN (library
, png_create_info_struct
);
5959 LOAD_IMGLIB_FN (library
, png_destroy_read_struct
);
5960 LOAD_IMGLIB_FN (library
, png_set_read_fn
);
5961 LOAD_IMGLIB_FN (library
, png_set_sig_bytes
);
5962 LOAD_IMGLIB_FN (library
, png_read_info
);
5963 LOAD_IMGLIB_FN (library
, png_get_IHDR
);
5964 LOAD_IMGLIB_FN (library
, png_get_valid
);
5965 LOAD_IMGLIB_FN (library
, png_set_strip_16
);
5966 LOAD_IMGLIB_FN (library
, png_set_expand
);
5967 LOAD_IMGLIB_FN (library
, png_set_gray_to_rgb
);
5968 LOAD_IMGLIB_FN (library
, png_set_background
);
5969 LOAD_IMGLIB_FN (library
, png_get_bKGD
);
5970 LOAD_IMGLIB_FN (library
, png_read_update_info
);
5971 LOAD_IMGLIB_FN (library
, png_get_channels
);
5972 LOAD_IMGLIB_FN (library
, png_get_rowbytes
);
5973 LOAD_IMGLIB_FN (library
, png_read_image
);
5974 LOAD_IMGLIB_FN (library
, png_read_end
);
5975 LOAD_IMGLIB_FN (library
, png_error
);
5980 #define fn_png_get_io_ptr png_get_io_ptr
5981 #define fn_png_check_sig png_check_sig
5982 #define fn_png_create_read_struct png_create_read_struct
5983 #define fn_png_create_info_struct png_create_info_struct
5984 #define fn_png_destroy_read_struct png_destroy_read_struct
5985 #define fn_png_set_read_fn png_set_read_fn
5986 #define fn_png_set_sig_bytes png_set_sig_bytes
5987 #define fn_png_read_info png_read_info
5988 #define fn_png_get_IHDR png_get_IHDR
5989 #define fn_png_get_valid png_get_valid
5990 #define fn_png_set_strip_16 png_set_strip_16
5991 #define fn_png_set_expand png_set_expand
5992 #define fn_png_set_gray_to_rgb png_set_gray_to_rgb
5993 #define fn_png_set_background png_set_background
5994 #define fn_png_get_bKGD png_get_bKGD
5995 #define fn_png_read_update_info png_read_update_info
5996 #define fn_png_get_channels png_get_channels
5997 #define fn_png_get_rowbytes png_get_rowbytes
5998 #define fn_png_read_image png_read_image
5999 #define fn_png_read_end png_read_end
6000 #define fn_png_error png_error
6002 #endif /* HAVE_NTGUI */
6004 /* Error and warning handlers installed when the PNG library
6008 my_png_error (png_ptr
, msg
)
6009 png_struct
*png_ptr
;
6012 xassert (png_ptr
!= NULL
);
6013 image_error ("PNG error: %s", build_string (msg
), Qnil
);
6014 longjmp (png_ptr
->jmpbuf
, 1);
6019 my_png_warning (png_ptr
, msg
)
6020 png_struct
*png_ptr
;
6023 xassert (png_ptr
!= NULL
);
6024 image_error ("PNG warning: %s", build_string (msg
), Qnil
);
6027 /* Memory source for PNG decoding. */
6029 struct png_memory_storage
6031 unsigned char *bytes
; /* The data */
6032 size_t len
; /* How big is it? */
6033 int index
; /* Where are we? */
6037 /* Function set as reader function when reading PNG image from memory.
6038 PNG_PTR is a pointer to the PNG control structure. Copy LENGTH
6039 bytes from the input to DATA. */
6042 png_read_from_memory (png_ptr
, data
, length
)
6043 png_structp png_ptr
;
6047 struct png_memory_storage
*tbr
6048 = (struct png_memory_storage
*) fn_png_get_io_ptr (png_ptr
);
6050 if (length
> tbr
->len
- tbr
->index
)
6051 fn_png_error (png_ptr
, "Read error");
6053 bcopy (tbr
->bytes
+ tbr
->index
, data
, length
);
6054 tbr
->index
= tbr
->index
+ length
;
6058 /* Function set as reader function when reading PNG image from a file.
6059 PNG_PTR is a pointer to the PNG control structure. Copy LENGTH
6060 bytes from the input to DATA. */
6063 png_read_from_file (png_ptr
, data
, length
)
6064 png_structp png_ptr
;
6068 FILE *fp
= (FILE *) fn_png_get_io_ptr (png_ptr
);
6070 if (fread (data
, 1, length
, fp
) < length
)
6071 fn_png_error (png_ptr
, "Read error");
6075 /* Load PNG image IMG for use on frame F. Value is non-zero if
6083 Lisp_Object file
, specified_file
;
6084 Lisp_Object specified_data
;
6086 XImagePtr ximg
, mask_img
= NULL
;
6087 struct gcpro gcpro1
;
6088 png_struct
*png_ptr
= NULL
;
6089 png_info
*info_ptr
= NULL
, *end_info
= NULL
;
6090 FILE *volatile fp
= NULL
;
6092 png_byte
* volatile pixels
= NULL
;
6093 png_byte
** volatile rows
= NULL
;
6094 png_uint_32 width
, height
;
6095 int bit_depth
, color_type
, interlace_type
;
6097 png_uint_32 row_bytes
;
6099 double screen_gamma
;
6100 struct png_memory_storage tbr
; /* Data to be read */
6102 /* Find out what file to load. */
6103 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
6104 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
6108 if (NILP (specified_data
))
6110 file
= x_find_image_file (specified_file
);
6111 if (!STRINGP (file
))
6113 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
6118 /* Open the image file. */
6119 fp
= fopen (SDATA (file
), "rb");
6122 image_error ("Cannot open image file `%s'", file
, Qnil
);
6127 /* Check PNG signature. */
6128 if (fread (sig
, 1, sizeof sig
, fp
) != sizeof sig
6129 || !fn_png_check_sig (sig
, sizeof sig
))
6131 image_error ("Not a PNG file: `%s'", file
, Qnil
);
6139 /* Read from memory. */
6140 tbr
.bytes
= SDATA (specified_data
);
6141 tbr
.len
= SBYTES (specified_data
);
6144 /* Check PNG signature. */
6145 if (tbr
.len
< sizeof sig
6146 || !fn_png_check_sig (tbr
.bytes
, sizeof sig
))
6148 image_error ("Not a PNG image: `%s'", img
->spec
, Qnil
);
6153 /* Need to skip past the signature. */
6154 tbr
.bytes
+= sizeof (sig
);
6157 /* Initialize read and info structs for PNG lib. Casting return
6158 value avoids a GCC warning on W32. */
6159 png_ptr
= (png_structp
)fn_png_create_read_struct (PNG_LIBPNG_VER_STRING
,
6164 if (fp
) fclose (fp
);
6169 /* Casting return value avoids a GCC warning on W32. */
6170 info_ptr
= (png_infop
)fn_png_create_info_struct (png_ptr
);
6173 fn_png_destroy_read_struct (&png_ptr
, NULL
, NULL
);
6174 if (fp
) fclose (fp
);
6179 /* Casting return value avoids a GCC warning on W32. */
6180 end_info
= (png_infop
)fn_png_create_info_struct (png_ptr
);
6183 fn_png_destroy_read_struct (&png_ptr
, &info_ptr
, NULL
);
6184 if (fp
) fclose (fp
);
6189 /* Set error jump-back. We come back here when the PNG library
6190 detects an error. */
6191 if (setjmp (png_ptr
->jmpbuf
))
6195 fn_png_destroy_read_struct (&png_ptr
, &info_ptr
, &end_info
);
6198 if (fp
) fclose (fp
);
6203 /* Read image info. */
6204 if (!NILP (specified_data
))
6205 fn_png_set_read_fn (png_ptr
, (void *) &tbr
, png_read_from_memory
);
6207 fn_png_set_read_fn (png_ptr
, (void *) fp
, png_read_from_file
);
6209 fn_png_set_sig_bytes (png_ptr
, sizeof sig
);
6210 fn_png_read_info (png_ptr
, info_ptr
);
6211 fn_png_get_IHDR (png_ptr
, info_ptr
, &width
, &height
, &bit_depth
, &color_type
,
6212 &interlace_type
, NULL
, NULL
);
6214 if (!check_image_size (f
, width
, height
))
6217 /* If image contains simply transparency data, we prefer to
6218 construct a clipping mask. */
6219 if (fn_png_get_valid (png_ptr
, info_ptr
, PNG_INFO_tRNS
))
6224 /* This function is easier to write if we only have to handle
6225 one data format: RGB or RGBA with 8 bits per channel. Let's
6226 transform other formats into that format. */
6228 /* Strip more than 8 bits per channel. */
6229 if (bit_depth
== 16)
6230 fn_png_set_strip_16 (png_ptr
);
6232 /* Expand data to 24 bit RGB, or 8 bit grayscale, with alpha channel
6234 fn_png_set_expand (png_ptr
);
6236 /* Convert grayscale images to RGB. */
6237 if (color_type
== PNG_COLOR_TYPE_GRAY
6238 || color_type
== PNG_COLOR_TYPE_GRAY_ALPHA
)
6239 fn_png_set_gray_to_rgb (png_ptr
);
6241 screen_gamma
= (f
->gamma
? 1 / f
->gamma
/ 0.45455 : 2.2);
6243 #if 0 /* Avoid double gamma correction for PNG images. */
6244 { /* Tell the PNG lib to handle gamma correction for us. */
6247 #if defined(PNG_READ_sRGB_SUPPORTED) || defined(PNG_WRITE_sRGB_SUPPORTED)
6248 if (png_get_sRGB (png_ptr
, info_ptr
, &intent
))
6249 /* The libpng documentation says this is right in this case. */
6250 png_set_gamma (png_ptr
, screen_gamma
, 0.45455);
6253 if (png_get_gAMA (png_ptr
, info_ptr
, &image_gamma
))
6254 /* Image contains gamma information. */
6255 png_set_gamma (png_ptr
, screen_gamma
, image_gamma
);
6257 /* Use the standard default for the image gamma. */
6258 png_set_gamma (png_ptr
, screen_gamma
, 0.45455);
6262 /* Handle alpha channel by combining the image with a background
6263 color. Do this only if a real alpha channel is supplied. For
6264 simple transparency, we prefer a clipping mask. */
6267 png_color_16
*image_bg
;
6268 Lisp_Object specified_bg
6269 = image_spec_value (img
->spec
, QCbackground
, NULL
);
6271 if (STRINGP (specified_bg
))
6272 /* The user specified `:background', use that. */
6274 /* W32 version incorrectly used COLORREF here!! ++kfs */
6276 if (x_defined_color (f
, SDATA (specified_bg
), &color
, 0))
6278 png_color_16 user_bg
;
6280 bzero (&user_bg
, sizeof user_bg
);
6281 user_bg
.red
= color
.red
>> 8;
6282 user_bg
.green
= color
.green
>> 8;
6283 user_bg
.blue
= color
.blue
>> 8;
6285 fn_png_set_background (png_ptr
, &user_bg
,
6286 PNG_BACKGROUND_GAMMA_SCREEN
, 0, 1.0);
6289 else if (fn_png_get_bKGD (png_ptr
, info_ptr
, &image_bg
))
6290 /* Image contains a background color with which to
6291 combine the image. */
6292 fn_png_set_background (png_ptr
, image_bg
,
6293 PNG_BACKGROUND_GAMMA_FILE
, 1, 1.0);
6296 /* Image does not contain a background color with which
6297 to combine the image data via an alpha channel. Use
6298 the frame's background instead. */
6299 #ifdef HAVE_X_WINDOWS
6301 png_color_16 frame_background
;
6303 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
6304 x_query_color (f
, &color
);
6306 bzero (&frame_background
, sizeof frame_background
);
6307 frame_background
.red
= color
.red
>> 8;
6308 frame_background
.green
= color
.green
>> 8;
6309 frame_background
.blue
= color
.blue
>> 8;
6310 #endif /* HAVE_X_WINDOWS */
6314 png_color_16 frame_background
;
6315 color
= FRAME_BACKGROUND_PIXEL (f
);
6316 #if 0 /* W32 TODO : Colormap support. */
6317 x_query_color (f
, &color
);
6319 bzero (&frame_background
, sizeof frame_background
);
6320 frame_background
.red
= GetRValue (color
);
6321 frame_background
.green
= GetGValue (color
);
6322 frame_background
.blue
= GetBValue (color
);
6323 #endif /* HAVE_NTGUI */
6326 unsigned long color
;
6327 png_color_16 frame_background
;
6328 color
= FRAME_BACKGROUND_PIXEL (f
);
6329 #if 0 /* MAC/W32 TODO : Colormap support. */
6330 x_query_color (f
, &color
);
6332 bzero (&frame_background
, sizeof frame_background
);
6333 frame_background
.red
= RED_FROM_ULONG (color
);
6334 frame_background
.green
= GREEN_FROM_ULONG (color
);
6335 frame_background
.blue
= BLUE_FROM_ULONG (color
);
6338 fn_png_set_background (png_ptr
, &frame_background
,
6339 PNG_BACKGROUND_GAMMA_SCREEN
, 0, 1.0);
6343 /* Update info structure. */
6344 fn_png_read_update_info (png_ptr
, info_ptr
);
6346 /* Get number of channels. Valid values are 1 for grayscale images
6347 and images with a palette, 2 for grayscale images with transparency
6348 information (alpha channel), 3 for RGB images, and 4 for RGB
6349 images with alpha channel, i.e. RGBA. If conversions above were
6350 sufficient we should only have 3 or 4 channels here. */
6351 channels
= fn_png_get_channels (png_ptr
, info_ptr
);
6352 xassert (channels
== 3 || channels
== 4);
6354 /* Number of bytes needed for one row of the image. */
6355 row_bytes
= fn_png_get_rowbytes (png_ptr
, info_ptr
);
6357 /* Allocate memory for the image. */
6358 pixels
= (png_byte
*) xmalloc (row_bytes
* height
* sizeof *pixels
);
6359 rows
= (png_byte
**) xmalloc (height
* sizeof *rows
);
6360 for (i
= 0; i
< height
; ++i
)
6361 rows
[i
] = pixels
+ i
* row_bytes
;
6363 /* Read the entire image. */
6364 fn_png_read_image (png_ptr
, rows
);
6365 fn_png_read_end (png_ptr
, info_ptr
);
6372 /* Create the X image and pixmap. */
6373 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
,
6377 /* Create an image and pixmap serving as mask if the PNG image
6378 contains an alpha channel. */
6381 && !x_create_x_image_and_pixmap (f
, width
, height
, 1,
6382 &mask_img
, &img
->mask
))
6384 x_destroy_x_image (ximg
);
6385 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->pixmap
);
6386 img
->pixmap
= NO_PIXMAP
;
6390 /* Fill the X image and mask from PNG data. */
6391 init_color_table ();
6393 for (y
= 0; y
< height
; ++y
)
6395 png_byte
*p
= rows
[y
];
6397 for (x
= 0; x
< width
; ++x
)
6404 XPutPixel (ximg
, x
, y
, lookup_rgb_color (f
, r
, g
, b
));
6405 /* An alpha channel, aka mask channel, associates variable
6406 transparency with an image. Where other image formats
6407 support binary transparency---fully transparent or fully
6408 opaque---PNG allows up to 254 levels of partial transparency.
6409 The PNG library implements partial transparency by combining
6410 the image with a specified background color.
6412 I'm not sure how to handle this here nicely: because the
6413 background on which the image is displayed may change, for
6414 real alpha channel support, it would be necessary to create
6415 a new image for each possible background.
6417 What I'm doing now is that a mask is created if we have
6418 boolean transparency information. Otherwise I'm using
6419 the frame's background color to combine the image with. */
6424 XPutPixel (mask_img
, x
, y
, *p
> 0 ? PIX_MASK_DRAW
: PIX_MASK_RETAIN
);
6430 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
6431 /* Set IMG's background color from the PNG image, unless the user
6435 if (fn_png_get_bKGD (png_ptr
, info_ptr
, &bg
))
6437 img
->background
= lookup_rgb_color (f
, bg
->red
, bg
->green
, bg
->blue
);
6438 img
->background_valid
= 1;
6442 #ifdef COLOR_TABLE_SUPPORT
6443 /* Remember colors allocated for this image. */
6444 img
->colors
= colors_in_color_table (&img
->ncolors
);
6445 free_color_table ();
6446 #endif /* COLOR_TABLE_SUPPORT */
6449 fn_png_destroy_read_struct (&png_ptr
, &info_ptr
, &end_info
);
6454 img
->height
= height
;
6456 /* Maybe fill in the background field while we have ximg handy.
6457 Casting avoids a GCC warning. */
6458 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
6460 /* Put the image into the pixmap, then free the X image and its buffer. */
6461 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
6462 x_destroy_x_image (ximg
);
6464 /* Same for the mask. */
6467 /* Fill in the background_transparent field while we have the
6468 mask handy. Casting avoids a GCC warning. */
6469 image_background_transparent (img
, f
, (XImagePtr_or_DC
)mask_img
);
6471 x_put_x_image (f
, mask_img
, img
->mask
, img
->width
, img
->height
);
6472 x_destroy_x_image (mask_img
);
6479 #else /* HAVE_PNG */
6488 if (MyCGImageCreateWithPNGDataProvider
)
6489 return image_load_quartz2d (f
, img
, 1);
6492 return image_load_quicktime (f
, img
, kQTFileTypePNG
);
6496 #endif /* !HAVE_PNG */
6500 /***********************************************************************
6502 ***********************************************************************/
6504 #if defined (HAVE_JPEG) || defined (MAC_OS)
6506 static int jpeg_image_p
P_ ((Lisp_Object object
));
6507 static int jpeg_load
P_ ((struct frame
*f
, struct image
*img
));
6509 /* The symbol `jpeg' identifying images of this type. */
6513 /* Indices of image specification fields in gs_format, below. */
6515 enum jpeg_keyword_index
6524 JPEG_HEURISTIC_MASK
,
6530 /* Vector of image_keyword structures describing the format
6531 of valid user-defined image specifications. */
6533 static struct image_keyword jpeg_format
[JPEG_LAST
] =
6535 {":type", IMAGE_SYMBOL_VALUE
, 1},
6536 {":data", IMAGE_STRING_VALUE
, 0},
6537 {":file", IMAGE_STRING_VALUE
, 0},
6538 {":ascent", IMAGE_ASCENT_VALUE
, 0},
6539 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
6540 {":relief", IMAGE_INTEGER_VALUE
, 0},
6541 {":conversions", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6542 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6543 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6544 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
6547 /* Structure describing the image type `jpeg'. */
6549 static struct image_type jpeg_type
=
6558 /* Return non-zero if OBJECT is a valid JPEG image specification. */
6561 jpeg_image_p (object
)
6564 struct image_keyword fmt
[JPEG_LAST
];
6566 bcopy (jpeg_format
, fmt
, sizeof fmt
);
6568 if (!parse_image_spec (object
, fmt
, JPEG_LAST
, Qjpeg
))
6571 /* Must specify either the :data or :file keyword. */
6572 return fmt
[JPEG_FILE
].count
+ fmt
[JPEG_DATA
].count
== 1;
6575 #endif /* HAVE_JPEG || MAC_OS */
6579 /* Work around a warning about HAVE_STDLIB_H being redefined in
6581 #ifdef HAVE_STDLIB_H
6582 #define HAVE_STDLIB_H_1
6583 #undef HAVE_STDLIB_H
6584 #endif /* HAVE_STLIB_H */
6586 #if defined (HAVE_NTGUI) && !defined (__WIN32__)
6587 /* In older releases of the jpeg library, jpeglib.h will define boolean
6588 differently depending on __WIN32__, so make sure it is defined. */
6592 #include <jpeglib.h>
6596 #ifdef HAVE_STLIB_H_1
6597 #define HAVE_STDLIB_H 1
6602 /* JPEG library details. */
6603 DEF_IMGLIB_FN (jpeg_CreateDecompress
);
6604 DEF_IMGLIB_FN (jpeg_start_decompress
);
6605 DEF_IMGLIB_FN (jpeg_finish_decompress
);
6606 DEF_IMGLIB_FN (jpeg_destroy_decompress
);
6607 DEF_IMGLIB_FN (jpeg_read_header
);
6608 DEF_IMGLIB_FN (jpeg_read_scanlines
);
6609 DEF_IMGLIB_FN (jpeg_std_error
);
6610 DEF_IMGLIB_FN (jpeg_resync_to_restart
);
6613 init_jpeg_functions (Lisp_Object libraries
)
6617 if (!(library
= w32_delayed_load (libraries
, Qjpeg
)))
6620 LOAD_IMGLIB_FN (library
, jpeg_finish_decompress
);
6621 LOAD_IMGLIB_FN (library
, jpeg_read_scanlines
);
6622 LOAD_IMGLIB_FN (library
, jpeg_start_decompress
);
6623 LOAD_IMGLIB_FN (library
, jpeg_read_header
);
6624 LOAD_IMGLIB_FN (library
, jpeg_CreateDecompress
);
6625 LOAD_IMGLIB_FN (library
, jpeg_destroy_decompress
);
6626 LOAD_IMGLIB_FN (library
, jpeg_std_error
);
6627 LOAD_IMGLIB_FN (library
, jpeg_resync_to_restart
);
6631 /* Wrapper since we can't directly assign the function pointer
6632 to another function pointer that was declared more completely easily. */
6634 jpeg_resync_to_restart_wrapper(cinfo
, desired
)
6635 j_decompress_ptr cinfo
;
6638 return fn_jpeg_resync_to_restart (cinfo
, desired
);
6643 #define fn_jpeg_CreateDecompress(a,b,c) jpeg_create_decompress(a)
6644 #define fn_jpeg_start_decompress jpeg_start_decompress
6645 #define fn_jpeg_finish_decompress jpeg_finish_decompress
6646 #define fn_jpeg_destroy_decompress jpeg_destroy_decompress
6647 #define fn_jpeg_read_header jpeg_read_header
6648 #define fn_jpeg_read_scanlines jpeg_read_scanlines
6649 #define fn_jpeg_std_error jpeg_std_error
6650 #define jpeg_resync_to_restart_wrapper jpeg_resync_to_restart
6652 #endif /* HAVE_NTGUI */
6654 struct my_jpeg_error_mgr
6656 struct jpeg_error_mgr pub
;
6657 jmp_buf setjmp_buffer
;
6662 my_error_exit (cinfo
)
6665 struct my_jpeg_error_mgr
*mgr
= (struct my_jpeg_error_mgr
*) cinfo
->err
;
6666 longjmp (mgr
->setjmp_buffer
, 1);
6670 /* Init source method for JPEG data source manager. Called by
6671 jpeg_read_header() before any data is actually read. See
6672 libjpeg.doc from the JPEG lib distribution. */
6675 our_common_init_source (cinfo
)
6676 j_decompress_ptr cinfo
;
6681 /* Method to terminate data source. Called by
6682 jpeg_finish_decompress() after all data has been processed. */
6685 our_common_term_source (cinfo
)
6686 j_decompress_ptr cinfo
;
6691 /* Fill input buffer method for JPEG data source manager. Called
6692 whenever more data is needed. We read the whole image in one step,
6693 so this only adds a fake end of input marker at the end. */
6696 our_memory_fill_input_buffer (cinfo
)
6697 j_decompress_ptr cinfo
;
6699 /* Insert a fake EOI marker. */
6700 struct jpeg_source_mgr
*src
= cinfo
->src
;
6701 static JOCTET buffer
[2];
6703 buffer
[0] = (JOCTET
) 0xFF;
6704 buffer
[1] = (JOCTET
) JPEG_EOI
;
6706 src
->next_input_byte
= buffer
;
6707 src
->bytes_in_buffer
= 2;
6712 /* Method to skip over NUM_BYTES bytes in the image data. CINFO->src
6713 is the JPEG data source manager. */
6716 our_memory_skip_input_data (cinfo
, num_bytes
)
6717 j_decompress_ptr cinfo
;
6720 struct jpeg_source_mgr
*src
= (struct jpeg_source_mgr
*) cinfo
->src
;
6724 if (num_bytes
> src
->bytes_in_buffer
)
6725 ERREXIT (cinfo
, JERR_INPUT_EOF
);
6727 src
->bytes_in_buffer
-= num_bytes
;
6728 src
->next_input_byte
+= num_bytes
;
6733 /* Set up the JPEG lib for reading an image from DATA which contains
6734 LEN bytes. CINFO is the decompression info structure created for
6735 reading the image. */
6738 jpeg_memory_src (cinfo
, data
, len
)
6739 j_decompress_ptr cinfo
;
6743 struct jpeg_source_mgr
*src
;
6745 if (cinfo
->src
== NULL
)
6747 /* First time for this JPEG object? */
6748 cinfo
->src
= (struct jpeg_source_mgr
*)
6749 (*cinfo
->mem
->alloc_small
) ((j_common_ptr
) cinfo
, JPOOL_PERMANENT
,
6750 sizeof (struct jpeg_source_mgr
));
6751 src
= (struct jpeg_source_mgr
*) cinfo
->src
;
6752 src
->next_input_byte
= data
;
6755 src
= (struct jpeg_source_mgr
*) cinfo
->src
;
6756 src
->init_source
= our_common_init_source
;
6757 src
->fill_input_buffer
= our_memory_fill_input_buffer
;
6758 src
->skip_input_data
= our_memory_skip_input_data
;
6759 src
->resync_to_restart
= jpeg_resync_to_restart_wrapper
; /* Use default method. */
6760 src
->term_source
= our_common_term_source
;
6761 src
->bytes_in_buffer
= len
;
6762 src
->next_input_byte
= data
;
6766 struct jpeg_stdio_mgr
6768 struct jpeg_source_mgr mgr
;
6775 /* Size of buffer to read JPEG from file.
6776 Not too big, as we want to use alloc_small. */
6777 #define JPEG_STDIO_BUFFER_SIZE 8192
6780 /* Fill input buffer method for JPEG data source manager. Called
6781 whenever more data is needed. The data is read from a FILE *. */
6784 our_stdio_fill_input_buffer (cinfo
)
6785 j_decompress_ptr cinfo
;
6787 struct jpeg_stdio_mgr
*src
;
6789 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6794 bytes
= fread (src
->buffer
, 1, JPEG_STDIO_BUFFER_SIZE
, src
->file
);
6796 src
->mgr
.bytes_in_buffer
= bytes
;
6799 WARNMS (cinfo
, JWRN_JPEG_EOF
);
6801 src
->buffer
[0] = (JOCTET
) 0xFF;
6802 src
->buffer
[1] = (JOCTET
) JPEG_EOI
;
6803 src
->mgr
.bytes_in_buffer
= 2;
6805 src
->mgr
.next_input_byte
= src
->buffer
;
6812 /* Method to skip over NUM_BYTES bytes in the image data. CINFO->src
6813 is the JPEG data source manager. */
6816 our_stdio_skip_input_data (cinfo
, num_bytes
)
6817 j_decompress_ptr cinfo
;
6820 struct jpeg_stdio_mgr
*src
;
6821 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6823 while (num_bytes
> 0 && !src
->finished
)
6825 if (num_bytes
<= src
->mgr
.bytes_in_buffer
)
6827 src
->mgr
.bytes_in_buffer
-= num_bytes
;
6828 src
->mgr
.next_input_byte
+= num_bytes
;
6833 num_bytes
-= src
->mgr
.bytes_in_buffer
;
6834 src
->mgr
.bytes_in_buffer
= 0;
6835 src
->mgr
.next_input_byte
= NULL
;
6837 our_stdio_fill_input_buffer (cinfo
);
6843 /* Set up the JPEG lib for reading an image from a FILE *.
6844 CINFO is the decompression info structure created for
6845 reading the image. */
6848 jpeg_file_src (cinfo
, fp
)
6849 j_decompress_ptr cinfo
;
6852 struct jpeg_stdio_mgr
*src
;
6854 if (cinfo
->src
!= NULL
)
6855 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6858 /* First time for this JPEG object? */
6859 cinfo
->src
= (struct jpeg_source_mgr
*)
6860 (*cinfo
->mem
->alloc_small
) ((j_common_ptr
) cinfo
, JPOOL_PERMANENT
,
6861 sizeof (struct jpeg_stdio_mgr
));
6862 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6863 src
->buffer
= (JOCTET
*)
6864 (*cinfo
->mem
->alloc_small
) ((j_common_ptr
) cinfo
, JPOOL_PERMANENT
,
6865 JPEG_STDIO_BUFFER_SIZE
);
6870 src
->mgr
.init_source
= our_common_init_source
;
6871 src
->mgr
.fill_input_buffer
= our_stdio_fill_input_buffer
;
6872 src
->mgr
.skip_input_data
= our_stdio_skip_input_data
;
6873 src
->mgr
.resync_to_restart
= jpeg_resync_to_restart_wrapper
; /* Use default method. */
6874 src
->mgr
.term_source
= our_common_term_source
;
6875 src
->mgr
.bytes_in_buffer
= 0;
6876 src
->mgr
.next_input_byte
= NULL
;
6880 /* Load image IMG for use on frame F. Patterned after example.c
6881 from the JPEG lib. */
6888 struct jpeg_decompress_struct cinfo
;
6889 struct my_jpeg_error_mgr mgr
;
6890 Lisp_Object file
, specified_file
;
6891 Lisp_Object specified_data
;
6892 FILE * volatile fp
= NULL
;
6894 int row_stride
, x
, y
;
6895 XImagePtr ximg
= NULL
;
6897 unsigned long *colors
;
6899 struct gcpro gcpro1
;
6901 /* Open the JPEG file. */
6902 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
6903 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
6907 if (NILP (specified_data
))
6909 file
= x_find_image_file (specified_file
);
6910 if (!STRINGP (file
))
6912 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
6917 fp
= fopen (SDATA (file
), "rb");
6920 image_error ("Cannot open `%s'", file
, Qnil
);
6926 /* Customize libjpeg's error handling to call my_error_exit when an
6927 error is detected. This function will perform a longjmp.
6928 Casting return value avoids a GCC warning on W32. */
6929 cinfo
.err
= (struct jpeg_error_mgr
*)fn_jpeg_std_error (&mgr
.pub
);
6930 mgr
.pub
.error_exit
= my_error_exit
;
6932 if ((rc
= setjmp (mgr
.setjmp_buffer
)) != 0)
6936 /* Called from my_error_exit. Display a JPEG error. */
6937 char buffer
[JMSG_LENGTH_MAX
];
6938 cinfo
.err
->format_message ((j_common_ptr
) &cinfo
, buffer
);
6939 image_error ("Error reading JPEG image `%s': %s", img
->spec
,
6940 build_string (buffer
));
6943 /* Close the input file and destroy the JPEG object. */
6945 fclose ((FILE *) fp
);
6946 fn_jpeg_destroy_decompress (&cinfo
);
6948 /* If we already have an XImage, free that. */
6949 x_destroy_x_image (ximg
);
6951 /* Free pixmap and colors. */
6952 x_clear_image (f
, img
);
6958 /* Create the JPEG decompression object. Let it read from fp.
6959 Read the JPEG image header. */
6960 fn_jpeg_CreateDecompress (&cinfo
, JPEG_LIB_VERSION
, sizeof (cinfo
));
6962 if (NILP (specified_data
))
6963 jpeg_file_src (&cinfo
, (FILE *) fp
);
6965 jpeg_memory_src (&cinfo
, SDATA (specified_data
),
6966 SBYTES (specified_data
));
6968 fn_jpeg_read_header (&cinfo
, 1);
6970 /* Customize decompression so that color quantization will be used.
6971 Start decompression. */
6972 cinfo
.quantize_colors
= 1;
6973 fn_jpeg_start_decompress (&cinfo
);
6974 width
= img
->width
= cinfo
.output_width
;
6975 height
= img
->height
= cinfo
.output_height
;
6977 if (!check_image_size (f
, width
, height
))
6979 image_error ("Invalid image size", Qnil
, Qnil
);
6980 longjmp (mgr
.setjmp_buffer
, 2);
6983 /* Create X image and pixmap. */
6984 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
6985 longjmp (mgr
.setjmp_buffer
, 2);
6987 /* Allocate colors. When color quantization is used,
6988 cinfo.actual_number_of_colors has been set with the number of
6989 colors generated, and cinfo.colormap is a two-dimensional array
6990 of color indices in the range 0..cinfo.actual_number_of_colors.
6991 No more than 255 colors will be generated. */
6995 if (cinfo
.out_color_components
> 2)
6996 ir
= 0, ig
= 1, ib
= 2;
6997 else if (cinfo
.out_color_components
> 1)
6998 ir
= 0, ig
= 1, ib
= 0;
7000 ir
= 0, ig
= 0, ib
= 0;
7002 /* Use the color table mechanism because it handles colors that
7003 cannot be allocated nicely. Such colors will be replaced with
7004 a default color, and we don't have to care about which colors
7005 can be freed safely, and which can't. */
7006 init_color_table ();
7007 colors
= (unsigned long *) alloca (cinfo
.actual_number_of_colors
7010 for (i
= 0; i
< cinfo
.actual_number_of_colors
; ++i
)
7012 /* Multiply RGB values with 255 because X expects RGB values
7013 in the range 0..0xffff. */
7014 int r
= cinfo
.colormap
[ir
][i
] << 8;
7015 int g
= cinfo
.colormap
[ig
][i
] << 8;
7016 int b
= cinfo
.colormap
[ib
][i
] << 8;
7017 colors
[i
] = lookup_rgb_color (f
, r
, g
, b
);
7020 #ifdef COLOR_TABLE_SUPPORT
7021 /* Remember those colors actually allocated. */
7022 img
->colors
= colors_in_color_table (&img
->ncolors
);
7023 free_color_table ();
7024 #endif /* COLOR_TABLE_SUPPORT */
7028 row_stride
= width
* cinfo
.output_components
;
7029 buffer
= cinfo
.mem
->alloc_sarray ((j_common_ptr
) &cinfo
, JPOOL_IMAGE
,
7031 for (y
= 0; y
< height
; ++y
)
7033 fn_jpeg_read_scanlines (&cinfo
, buffer
, 1);
7034 for (x
= 0; x
< cinfo
.output_width
; ++x
)
7035 XPutPixel (ximg
, x
, y
, colors
[buffer
[0][x
]]);
7039 fn_jpeg_finish_decompress (&cinfo
);
7040 fn_jpeg_destroy_decompress (&cinfo
);
7042 fclose ((FILE *) fp
);
7044 /* Maybe fill in the background field while we have ximg handy. */
7045 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
7046 /* Casting avoids a GCC warning. */
7047 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
7049 /* Put the image into the pixmap. */
7050 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
7051 x_destroy_x_image (ximg
);
7056 #else /* HAVE_JPEG */
7065 return image_load_quartz2d (f
, img
, 0);
7067 return image_load_quicktime (f
, img
, kQTFileTypeJPEG
);
7072 #endif /* !HAVE_JPEG */
7076 /***********************************************************************
7078 ***********************************************************************/
7080 #if defined (HAVE_TIFF) || defined (MAC_OS)
7082 static int tiff_image_p
P_ ((Lisp_Object object
));
7083 static int tiff_load
P_ ((struct frame
*f
, struct image
*img
));
7085 /* The symbol `tiff' identifying images of this type. */
7089 /* Indices of image specification fields in tiff_format, below. */
7091 enum tiff_keyword_index
7100 TIFF_HEURISTIC_MASK
,
7106 /* Vector of image_keyword structures describing the format
7107 of valid user-defined image specifications. */
7109 static struct image_keyword tiff_format
[TIFF_LAST
] =
7111 {":type", IMAGE_SYMBOL_VALUE
, 1},
7112 {":data", IMAGE_STRING_VALUE
, 0},
7113 {":file", IMAGE_STRING_VALUE
, 0},
7114 {":ascent", IMAGE_ASCENT_VALUE
, 0},
7115 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
7116 {":relief", IMAGE_INTEGER_VALUE
, 0},
7117 {":conversions", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7118 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7119 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7120 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
7123 /* Structure describing the image type `tiff'. */
7125 static struct image_type tiff_type
=
7134 /* Return non-zero if OBJECT is a valid TIFF image specification. */
7137 tiff_image_p (object
)
7140 struct image_keyword fmt
[TIFF_LAST
];
7141 bcopy (tiff_format
, fmt
, sizeof fmt
);
7143 if (!parse_image_spec (object
, fmt
, TIFF_LAST
, Qtiff
))
7146 /* Must specify either the :data or :file keyword. */
7147 return fmt
[TIFF_FILE
].count
+ fmt
[TIFF_DATA
].count
== 1;
7150 #endif /* HAVE_TIFF || MAC_OS */
7158 /* TIFF library details. */
7159 DEF_IMGLIB_FN (TIFFSetErrorHandler
);
7160 DEF_IMGLIB_FN (TIFFSetWarningHandler
);
7161 DEF_IMGLIB_FN (TIFFOpen
);
7162 DEF_IMGLIB_FN (TIFFClientOpen
);
7163 DEF_IMGLIB_FN (TIFFGetField
);
7164 DEF_IMGLIB_FN (TIFFReadRGBAImage
);
7165 DEF_IMGLIB_FN (TIFFClose
);
7168 init_tiff_functions (Lisp_Object libraries
)
7172 if (!(library
= w32_delayed_load (libraries
, Qtiff
)))
7175 LOAD_IMGLIB_FN (library
, TIFFSetErrorHandler
);
7176 LOAD_IMGLIB_FN (library
, TIFFSetWarningHandler
);
7177 LOAD_IMGLIB_FN (library
, TIFFOpen
);
7178 LOAD_IMGLIB_FN (library
, TIFFClientOpen
);
7179 LOAD_IMGLIB_FN (library
, TIFFGetField
);
7180 LOAD_IMGLIB_FN (library
, TIFFReadRGBAImage
);
7181 LOAD_IMGLIB_FN (library
, TIFFClose
);
7187 #define fn_TIFFSetErrorHandler TIFFSetErrorHandler
7188 #define fn_TIFFSetWarningHandler TIFFSetWarningHandler
7189 #define fn_TIFFOpen TIFFOpen
7190 #define fn_TIFFClientOpen TIFFClientOpen
7191 #define fn_TIFFGetField TIFFGetField
7192 #define fn_TIFFReadRGBAImage TIFFReadRGBAImage
7193 #define fn_TIFFClose TIFFClose
7195 #endif /* HAVE_NTGUI */
7198 /* Reading from a memory buffer for TIFF images Based on the PNG
7199 memory source, but we have to provide a lot of extra functions.
7202 We really only need to implement read and seek, but I am not
7203 convinced that the TIFF library is smart enough not to destroy
7204 itself if we only hand it the function pointers we need to
7209 unsigned char *bytes
;
7216 tiff_read_from_memory (data
, buf
, size
)
7221 tiff_memory_source
*src
= (tiff_memory_source
*) data
;
7223 if (size
> src
->len
- src
->index
)
7225 bcopy (src
->bytes
+ src
->index
, buf
, size
);
7231 tiff_write_from_memory (data
, buf
, size
)
7240 tiff_seek_in_memory (data
, off
, whence
)
7245 tiff_memory_source
*src
= (tiff_memory_source
*) data
;
7250 case SEEK_SET
: /* Go from beginning of source. */
7254 case SEEK_END
: /* Go from end of source. */
7255 idx
= src
->len
+ off
;
7258 case SEEK_CUR
: /* Go from current position. */
7259 idx
= src
->index
+ off
;
7262 default: /* Invalid `whence'. */
7266 if (idx
> src
->len
|| idx
< 0)
7274 tiff_close_memory (data
)
7282 tiff_mmap_memory (data
, pbase
, psize
)
7287 /* It is already _IN_ memory. */
7292 tiff_unmap_memory (data
, base
, size
)
7297 /* We don't need to do this. */
7301 tiff_size_of_memory (data
)
7304 return ((tiff_memory_source
*) data
)->len
;
7309 tiff_error_handler (title
, format
, ap
)
7310 const char *title
, *format
;
7316 len
= sprintf (buf
, "TIFF error: %s ", title
);
7317 vsprintf (buf
+ len
, format
, ap
);
7318 add_to_log (buf
, Qnil
, Qnil
);
7323 tiff_warning_handler (title
, format
, ap
)
7324 const char *title
, *format
;
7330 len
= sprintf (buf
, "TIFF warning: %s ", title
);
7331 vsprintf (buf
+ len
, format
, ap
);
7332 add_to_log (buf
, Qnil
, Qnil
);
7336 /* Load TIFF image IMG for use on frame F. Value is non-zero if
7344 Lisp_Object file
, specified_file
;
7345 Lisp_Object specified_data
;
7347 int width
, height
, x
, y
;
7351 struct gcpro gcpro1
;
7352 tiff_memory_source memsrc
;
7354 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
7355 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
7359 fn_TIFFSetErrorHandler (tiff_error_handler
);
7360 fn_TIFFSetWarningHandler (tiff_warning_handler
);
7362 if (NILP (specified_data
))
7364 /* Read from a file */
7365 file
= x_find_image_file (specified_file
);
7366 if (!STRINGP (file
))
7368 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
7373 /* Try to open the image file. Casting return value avoids a
7374 GCC warning on W32. */
7375 tiff
= (TIFF
*)fn_TIFFOpen (SDATA (file
), "r");
7378 image_error ("Cannot open `%s'", file
, Qnil
);
7385 /* Memory source! */
7386 memsrc
.bytes
= SDATA (specified_data
);
7387 memsrc
.len
= SBYTES (specified_data
);
7390 /* Casting return value avoids a GCC warning on W32. */
7391 tiff
= (TIFF
*)fn_TIFFClientOpen ("memory_source", "r", &memsrc
,
7392 (TIFFReadWriteProc
) tiff_read_from_memory
,
7393 (TIFFReadWriteProc
) tiff_write_from_memory
,
7394 tiff_seek_in_memory
,
7396 tiff_size_of_memory
,
7402 image_error ("Cannot open memory source for `%s'", img
->spec
, Qnil
);
7408 /* Get width and height of the image, and allocate a raster buffer
7409 of width x height 32-bit values. */
7410 fn_TIFFGetField (tiff
, TIFFTAG_IMAGEWIDTH
, &width
);
7411 fn_TIFFGetField (tiff
, TIFFTAG_IMAGELENGTH
, &height
);
7413 if (!check_image_size (f
, width
, height
))
7415 image_error ("Invalid image size", Qnil
, Qnil
);
7420 buf
= (uint32
*) xmalloc (width
* height
* sizeof *buf
);
7422 rc
= fn_TIFFReadRGBAImage (tiff
, width
, height
, buf
, 0);
7423 fn_TIFFClose (tiff
);
7426 image_error ("Error reading TIFF image `%s'", img
->spec
, Qnil
);
7432 /* Create the X image and pixmap. */
7433 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
7440 /* Initialize the color table. */
7441 init_color_table ();
7443 /* Process the pixel raster. Origin is in the lower-left corner. */
7444 for (y
= 0; y
< height
; ++y
)
7446 uint32
*row
= buf
+ y
* width
;
7448 for (x
= 0; x
< width
; ++x
)
7450 uint32 abgr
= row
[x
];
7451 int r
= TIFFGetR (abgr
) << 8;
7452 int g
= TIFFGetG (abgr
) << 8;
7453 int b
= TIFFGetB (abgr
) << 8;
7454 XPutPixel (ximg
, x
, height
- 1 - y
, lookup_rgb_color (f
, r
, g
, b
));
7458 #ifdef COLOR_TABLE_SUPPORT
7459 /* Remember the colors allocated for the image. Free the color table. */
7460 img
->colors
= colors_in_color_table (&img
->ncolors
);
7461 free_color_table ();
7462 #endif /* COLOR_TABLE_SUPPORT */
7465 img
->height
= height
;
7467 /* Maybe fill in the background field while we have ximg handy. */
7468 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
7469 /* Casting avoids a GCC warning on W32. */
7470 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
7472 /* Put the image into the pixmap, then free the X image and its buffer. */
7473 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
7474 x_destroy_x_image (ximg
);
7481 #else /* HAVE_TIFF */
7489 return image_load_quicktime (f
, img
, kQTFileTypeTIFF
);
7493 #endif /* !HAVE_TIFF */
7497 /***********************************************************************
7499 ***********************************************************************/
7501 #if defined (HAVE_GIF) || defined (MAC_OS)
7503 static int gif_image_p
P_ ((Lisp_Object object
));
7504 static int gif_load
P_ ((struct frame
*f
, struct image
*img
));
7505 static void gif_clear_image
P_ ((struct frame
*f
, struct image
*img
));
7507 /* The symbol `gif' identifying images of this type. */
7511 /* Indices of image specification fields in gif_format, below. */
7513 enum gif_keyword_index
7529 /* Vector of image_keyword structures describing the format
7530 of valid user-defined image specifications. */
7532 static struct image_keyword gif_format
[GIF_LAST
] =
7534 {":type", IMAGE_SYMBOL_VALUE
, 1},
7535 {":data", IMAGE_STRING_VALUE
, 0},
7536 {":file", IMAGE_STRING_VALUE
, 0},
7537 {":ascent", IMAGE_ASCENT_VALUE
, 0},
7538 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
7539 {":relief", IMAGE_INTEGER_VALUE
, 0},
7540 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7541 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7542 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7543 {":image", IMAGE_NON_NEGATIVE_INTEGER_VALUE
, 0},
7544 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
7547 /* Structure describing the image type `gif'. */
7549 static struct image_type gif_type
=
7558 /* Free X resources of GIF image IMG which is used on frame F. */
7561 gif_clear_image (f
, img
)
7565 /* IMG->data.ptr_val may contain extension data. */
7566 img
->data
.lisp_val
= Qnil
;
7567 x_clear_image (f
, img
);
7570 /* Return non-zero if OBJECT is a valid GIF image specification. */
7573 gif_image_p (object
)
7576 struct image_keyword fmt
[GIF_LAST
];
7577 bcopy (gif_format
, fmt
, sizeof fmt
);
7579 if (!parse_image_spec (object
, fmt
, GIF_LAST
, Qgif
))
7582 /* Must specify either the :data or :file keyword. */
7583 return fmt
[GIF_FILE
].count
+ fmt
[GIF_DATA
].count
== 1;
7586 #endif /* HAVE_GIF || MAC_OS */
7590 #if defined (HAVE_NTGUI) || defined (MAC_OS)
7591 /* winuser.h might define DrawText to DrawTextA or DrawTextW.
7592 Undefine before redefining to avoid a preprocessor warning. */
7596 /* avoid conflict with QuickdrawText.h */
7597 #define DrawText gif_DrawText
7598 #include <gif_lib.h>
7601 #else /* HAVE_NTGUI || MAC_OS */
7603 #include <gif_lib.h>
7605 #endif /* HAVE_NTGUI || MAC_OS */
7610 /* GIF library details. */
7611 DEF_IMGLIB_FN (DGifCloseFile
);
7612 DEF_IMGLIB_FN (DGifSlurp
);
7613 DEF_IMGLIB_FN (DGifOpen
);
7614 DEF_IMGLIB_FN (DGifOpenFileName
);
7617 init_gif_functions (Lisp_Object libraries
)
7621 if (!(library
= w32_delayed_load (libraries
, Qgif
)))
7624 LOAD_IMGLIB_FN (library
, DGifCloseFile
);
7625 LOAD_IMGLIB_FN (library
, DGifSlurp
);
7626 LOAD_IMGLIB_FN (library
, DGifOpen
);
7627 LOAD_IMGLIB_FN (library
, DGifOpenFileName
);
7633 #define fn_DGifCloseFile DGifCloseFile
7634 #define fn_DGifSlurp DGifSlurp
7635 #define fn_DGifOpen DGifOpen
7636 #define fn_DGifOpenFileName DGifOpenFileName
7638 #endif /* HAVE_NTGUI */
7640 /* Reading a GIF image from memory
7641 Based on the PNG memory stuff to a certain extent. */
7645 unsigned char *bytes
;
7651 /* Make the current memory source available to gif_read_from_memory.
7652 It's done this way because not all versions of libungif support
7653 a UserData field in the GifFileType structure. */
7654 static gif_memory_source
*current_gif_memory_src
;
7657 gif_read_from_memory (file
, buf
, len
)
7662 gif_memory_source
*src
= current_gif_memory_src
;
7664 if (len
> src
->len
- src
->index
)
7667 bcopy (src
->bytes
+ src
->index
, buf
, len
);
7673 /* Load GIF image IMG for use on frame F. Value is non-zero if
7681 Lisp_Object file
, specified_file
;
7682 Lisp_Object specified_data
;
7683 int rc
, width
, height
, x
, y
, i
;
7685 ColorMapObject
*gif_color_map
;
7686 unsigned long pixel_colors
[256];
7688 struct gcpro gcpro1
;
7690 int ino
, image_height
, image_width
;
7691 gif_memory_source memsrc
;
7692 unsigned char *raster
;
7694 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
7695 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
7699 if (NILP (specified_data
))
7701 file
= x_find_image_file (specified_file
);
7702 if (!STRINGP (file
))
7704 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
7709 /* Open the GIF file. Casting return value avoids a GCC warning
7711 gif
= (GifFileType
*)fn_DGifOpenFileName (SDATA (file
));
7714 image_error ("Cannot open `%s'", file
, Qnil
);
7721 /* Read from memory! */
7722 current_gif_memory_src
= &memsrc
;
7723 memsrc
.bytes
= SDATA (specified_data
);
7724 memsrc
.len
= SBYTES (specified_data
);
7727 /* Casting return value avoids a GCC warning on W32. */
7728 gif
= (GifFileType
*)fn_DGifOpen(&memsrc
, gif_read_from_memory
);
7731 image_error ("Cannot open memory source `%s'", img
->spec
, Qnil
);
7737 /* Before reading entire contents, check the declared image size. */
7738 if (!check_image_size (f
, gif
->SWidth
, gif
->SHeight
))
7740 image_error ("Invalid image size", Qnil
, Qnil
);
7741 fn_DGifCloseFile (gif
);
7746 /* Read entire contents. */
7747 rc
= fn_DGifSlurp (gif
);
7748 if (rc
== GIF_ERROR
)
7750 image_error ("Error reading `%s'", img
->spec
, Qnil
);
7751 fn_DGifCloseFile (gif
);
7756 image
= image_spec_value (img
->spec
, QCindex
, NULL
);
7757 ino
= INTEGERP (image
) ? XFASTINT (image
) : 0;
7758 if (ino
>= gif
->ImageCount
)
7760 image_error ("Invalid image number `%s' in image `%s'",
7762 fn_DGifCloseFile (gif
);
7767 img
->corners
[TOP_CORNER
] = gif
->SavedImages
[ino
].ImageDesc
.Top
;
7768 img
->corners
[LEFT_CORNER
] = gif
->SavedImages
[ino
].ImageDesc
.Left
;
7769 image_height
= gif
->SavedImages
[ino
].ImageDesc
.Height
;
7770 img
->corners
[BOT_CORNER
] = img
->corners
[TOP_CORNER
] + image_height
;
7771 image_width
= gif
->SavedImages
[ino
].ImageDesc
.Width
;
7772 img
->corners
[RIGHT_CORNER
] = img
->corners
[LEFT_CORNER
] + image_width
;
7774 width
= img
->width
= max (gif
->SWidth
,
7775 max (gif
->Image
.Left
+ gif
->Image
.Width
,
7776 img
->corners
[RIGHT_CORNER
]));
7777 height
= img
->height
= max (gif
->SHeight
,
7778 max (gif
->Image
.Top
+ gif
->Image
.Height
,
7779 img
->corners
[BOT_CORNER
]));
7781 if (!check_image_size (f
, width
, height
))
7783 image_error ("Invalid image size", Qnil
, Qnil
);
7784 fn_DGifCloseFile (gif
);
7789 /* Create the X image and pixmap. */
7790 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
7792 fn_DGifCloseFile (gif
);
7797 /* Allocate colors. */
7798 gif_color_map
= gif
->SavedImages
[ino
].ImageDesc
.ColorMap
;
7800 gif_color_map
= gif
->SColorMap
;
7801 init_color_table ();
7802 bzero (pixel_colors
, sizeof pixel_colors
);
7804 for (i
= 0; i
< gif_color_map
->ColorCount
; ++i
)
7806 int r
= gif_color_map
->Colors
[i
].Red
<< 8;
7807 int g
= gif_color_map
->Colors
[i
].Green
<< 8;
7808 int b
= gif_color_map
->Colors
[i
].Blue
<< 8;
7809 pixel_colors
[i
] = lookup_rgb_color (f
, r
, g
, b
);
7812 #ifdef COLOR_TABLE_SUPPORT
7813 img
->colors
= colors_in_color_table (&img
->ncolors
);
7814 free_color_table ();
7815 #endif /* COLOR_TABLE_SUPPORT */
7817 /* Clear the part of the screen image that are not covered by
7818 the image from the GIF file. Full animated GIF support
7819 requires more than can be done here (see the gif89 spec,
7820 disposal methods). Let's simply assume that the part
7821 not covered by a sub-image is in the frame's background color. */
7822 for (y
= 0; y
< img
->corners
[TOP_CORNER
]; ++y
)
7823 for (x
= 0; x
< width
; ++x
)
7824 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7826 for (y
= img
->corners
[BOT_CORNER
]; y
< height
; ++y
)
7827 for (x
= 0; x
< width
; ++x
)
7828 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7830 for (y
= img
->corners
[TOP_CORNER
]; y
< img
->corners
[BOT_CORNER
]; ++y
)
7832 for (x
= 0; x
< img
->corners
[LEFT_CORNER
]; ++x
)
7833 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7834 for (x
= img
->corners
[RIGHT_CORNER
]; x
< width
; ++x
)
7835 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7838 /* Read the GIF image into the X image. We use a local variable
7839 `raster' here because RasterBits below is a char *, and invites
7840 problems with bytes >= 0x80. */
7841 raster
= (unsigned char *) gif
->SavedImages
[ino
].RasterBits
;
7843 if (gif
->SavedImages
[ino
].ImageDesc
.Interlace
)
7845 static int interlace_start
[] = {0, 4, 2, 1};
7846 static int interlace_increment
[] = {8, 8, 4, 2};
7848 int row
= interlace_start
[0];
7852 for (y
= 0; y
< image_height
; y
++)
7854 if (row
>= image_height
)
7856 row
= interlace_start
[++pass
];
7857 while (row
>= image_height
)
7858 row
= interlace_start
[++pass
];
7861 for (x
= 0; x
< image_width
; x
++)
7863 int i
= raster
[(y
* image_width
) + x
];
7864 XPutPixel (ximg
, x
+ img
->corners
[LEFT_CORNER
],
7865 row
+ img
->corners
[TOP_CORNER
], pixel_colors
[i
]);
7868 row
+= interlace_increment
[pass
];
7873 for (y
= 0; y
< image_height
; ++y
)
7874 for (x
= 0; x
< image_width
; ++x
)
7876 int i
= raster
[y
* image_width
+ x
];
7877 XPutPixel (ximg
, x
+ img
->corners
[LEFT_CORNER
],
7878 y
+ img
->corners
[TOP_CORNER
], pixel_colors
[i
]);
7882 /* Save GIF image extension data for `image-extension-data'.
7883 Format is (count IMAGES FUNCTION "BYTES" ...). */
7884 img
->data
.lisp_val
= Qnil
;
7885 if (gif
->SavedImages
[ino
].ExtensionBlockCount
> 0)
7887 ExtensionBlock
*ext
= gif
->SavedImages
[ino
].ExtensionBlocks
;
7888 for (i
= 0; i
< gif
->SavedImages
[ino
].ExtensionBlockCount
; i
++, ext
++)
7889 /* Append (... FUNCTION "BYTES") */
7890 img
->data
.lisp_val
= Fcons (make_unibyte_string (ext
->Bytes
, ext
->ByteCount
),
7891 Fcons (make_number (ext
->Function
),
7892 img
->data
.lisp_val
));
7893 img
->data
.lisp_val
= Fnreverse (img
->data
.lisp_val
);
7895 if (gif
->ImageCount
> 1)
7896 img
->data
.lisp_val
= Fcons (Qcount
,
7897 Fcons (make_number (gif
->ImageCount
),
7898 img
->data
.lisp_val
));
7900 fn_DGifCloseFile (gif
);
7902 /* Maybe fill in the background field while we have ximg handy. */
7903 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
7904 /* Casting avoids a GCC warning. */
7905 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
7907 /* Put the image into the pixmap, then free the X image and its buffer. */
7908 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
7909 x_destroy_x_image (ximg
);
7915 #else /* !HAVE_GIF */
7923 Lisp_Object specified_file
, file
;
7924 Lisp_Object specified_data
;
7926 Boolean graphic_p
, movie_p
, prefer_graphic_p
;
7934 Lisp_Object specified_bg
;
7939 TimeScale time_scale
;
7940 TimeValue time
, duration
;
7945 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
7946 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
7948 /* Animated gifs use QuickTime Movie Toolbox. So initialize it here. */
7951 if (NILP (specified_data
))
7953 /* Read from a file */
7957 err
= find_image_fsspec (specified_file
, &file
, &fss
);
7961 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
7966 err
= CanQuickTimeOpenFile (&fss
, kQTFileTypeGIF
, 0,
7967 &graphic_p
, &movie_p
, &prefer_graphic_p
, 0);
7971 if (!graphic_p
&& !movie_p
)
7973 if (prefer_graphic_p
)
7974 return image_load_qt_1 (f
, img
, kQTFileTypeGIF
, &fss
, NULL
);
7975 err
= OpenMovieFile (&fss
, &refnum
, fsRdPerm
);
7978 err
= NewMovieFromFile (&movie
, refnum
, NULL
, NULL
, 0, NULL
);
7979 CloseMovieFile (refnum
);
7982 image_error ("Error reading `%s'", file
, Qnil
);
7988 /* Memory source! */
7990 long file_type_atom
[3];
7992 err
= PtrToHand (SDATA (specified_data
), &dh
, SBYTES (specified_data
));
7995 image_error ("Cannot allocate data handle for `%s'",
8000 file_type_atom
[0] = EndianU32_NtoB (sizeof (long) * 3);
8001 file_type_atom
[1] = EndianU32_NtoB (kDataRefExtensionMacOSFileType
);
8002 file_type_atom
[2] = EndianU32_NtoB (kQTFileTypeGIF
);
8003 err
= PtrToHand (&dh
, &dref
, sizeof (Handle
));
8006 err
= PtrAndHand ("\p", dref
, 1);
8008 err
= PtrAndHand (file_type_atom
, dref
, sizeof (long) * 3);
8011 image_error ("Cannot allocate handle data ref for `%s'", img
->spec
, Qnil
);
8014 err
= CanQuickTimeOpenDataRef (dref
, HandleDataHandlerSubType
, &graphic_p
,
8015 &movie_p
, &prefer_graphic_p
, 0);
8019 if (!graphic_p
&& !movie_p
)
8021 if (prefer_graphic_p
)
8025 DisposeHandle (dref
);
8026 success_p
= image_load_qt_1 (f
, img
, kQTFileTypeGIF
, NULL
, dh
);
8030 err
= NewMovieFromDataRef (&movie
, 0, NULL
, dref
,
8031 HandleDataHandlerSubType
);
8032 DisposeHandle (dref
);
8037 image
= image_spec_value (img
->spec
, QCindex
, NULL
);
8038 ino
= INTEGERP (image
) ? XFASTINT (image
) : 0;
8039 track
= GetMovieIndTrack (movie
, 1);
8040 media
= GetTrackMedia (track
);
8041 nsamples
= GetMediaSampleCount (media
);
8042 if (ino
>= nsamples
)
8044 image_error ("Invalid image number `%s' in image `%s'",
8048 time_scale
= GetMediaTimeScale (media
);
8050 specified_bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
8051 if (!STRINGP (specified_bg
) ||
8052 !mac_defined_color (f
, SDATA (specified_bg
), &color
, 0))
8054 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
8055 color
.red
= RED16_FROM_ULONG (color
.pixel
);
8056 color
.green
= GREEN16_FROM_ULONG (color
.pixel
);
8057 color
.blue
= BLUE16_FROM_ULONG (color
.pixel
);
8059 GetMovieBox (movie
, &rect
);
8060 width
= img
->width
= rect
.right
- rect
.left
;
8061 height
= img
->height
= rect
.bottom
- rect
.top
;
8062 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
8065 GetGWorld (&old_port
, &old_gdh
);
8066 SetGWorld (ximg
, NULL
);
8067 bg_color
.red
= color
.red
;
8068 bg_color
.green
= color
.green
;
8069 bg_color
.blue
= color
.blue
;
8070 RGBBackColor (&bg_color
);
8071 SetGWorld (old_port
, old_gdh
);
8072 SetMovieActive (movie
, 1);
8073 SetMovieGWorld (movie
, ximg
, NULL
);
8074 SampleNumToMediaTime (media
, ino
+ 1, &time
, &duration
);
8075 SetMovieTimeValue (movie
, time
);
8076 MoviesTask (movie
, 0L);
8077 DisposeTrackMedia (media
);
8078 DisposeMovieTrack (track
);
8079 DisposeMovie (movie
);
8083 /* Save GIF image extension data for `image-extension-data'.
8084 Format is (count IMAGES 0xf9 GRAPHIC_CONTROL_EXTENSION_BLOCK). */
8086 Lisp_Object gce
= make_uninit_string (4);
8087 int centisec
= ((float)duration
/ time_scale
) * 100.0f
+ 0.5f
;
8089 /* Fill the delay time field. */
8090 SSET (gce
, 1, centisec
& 0xff);
8091 SSET (gce
, 2, (centisec
>> 8) & 0xff);
8092 /* We don't know about other fields. */
8096 img
->data
.lisp_val
= list4 (Qcount
, make_number (nsamples
),
8097 make_number (0xf9), gce
);
8100 /* Maybe fill in the background field while we have ximg handy. */
8101 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
8102 IMAGE_BACKGROUND (img
, f
, ximg
);
8104 /* Put the image into the pixmap. */
8105 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
8106 x_destroy_x_image (ximg
);
8110 image_error ("Cannot open `%s'", file
, Qnil
);
8113 DisposeTrackMedia (media
);
8115 DisposeMovieTrack (track
);
8117 DisposeMovie (movie
);
8124 #endif /* HAVE_GIF */
8128 /***********************************************************************
8130 ***********************************************************************/
8132 #ifdef HAVE_X_WINDOWS
8133 #define HAVE_GHOSTSCRIPT 1
8134 #endif /* HAVE_X_WINDOWS */
8136 /* The symbol `postscript' identifying images of this type. */
8138 Lisp_Object Qpostscript
;
8140 #ifdef HAVE_GHOSTSCRIPT
8142 static int gs_image_p
P_ ((Lisp_Object object
));
8143 static int gs_load
P_ ((struct frame
*f
, struct image
*img
));
8144 static void gs_clear_image
P_ ((struct frame
*f
, struct image
*img
));
8146 /* Keyword symbols. */
8148 Lisp_Object QCloader
, QCbounding_box
, QCpt_width
, QCpt_height
;
8150 /* Indices of image specification fields in gs_format, below. */
8152 enum gs_keyword_index
8170 /* Vector of image_keyword structures describing the format
8171 of valid user-defined image specifications. */
8173 static struct image_keyword gs_format
[GS_LAST
] =
8175 {":type", IMAGE_SYMBOL_VALUE
, 1},
8176 {":pt-width", IMAGE_POSITIVE_INTEGER_VALUE
, 1},
8177 {":pt-height", IMAGE_POSITIVE_INTEGER_VALUE
, 1},
8178 {":file", IMAGE_STRING_VALUE
, 1},
8179 {":loader", IMAGE_FUNCTION_VALUE
, 0},
8180 {":bounding-box", IMAGE_DONT_CHECK_VALUE_TYPE
, 1},
8181 {":ascent", IMAGE_ASCENT_VALUE
, 0},
8182 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
8183 {":relief", IMAGE_INTEGER_VALUE
, 0},
8184 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8185 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8186 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8187 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
8190 /* Structure describing the image type `ghostscript'. */
8192 static struct image_type gs_type
=
8202 /* Free X resources of Ghostscript image IMG which is used on frame F. */
8205 gs_clear_image (f
, img
)
8209 /* IMG->data.ptr_val may contain a recorded colormap. */
8210 xfree (img
->data
.ptr_val
);
8211 x_clear_image (f
, img
);
8215 /* Return non-zero if OBJECT is a valid Ghostscript image
8222 struct image_keyword fmt
[GS_LAST
];
8226 bcopy (gs_format
, fmt
, sizeof fmt
);
8228 if (!parse_image_spec (object
, fmt
, GS_LAST
, Qpostscript
))
8231 /* Bounding box must be a list or vector containing 4 integers. */
8232 tem
= fmt
[GS_BOUNDING_BOX
].value
;
8235 for (i
= 0; i
< 4; ++i
, tem
= XCDR (tem
))
8236 if (!CONSP (tem
) || !INTEGERP (XCAR (tem
)))
8241 else if (VECTORP (tem
))
8243 if (XVECTOR (tem
)->size
!= 4)
8245 for (i
= 0; i
< 4; ++i
)
8246 if (!INTEGERP (XVECTOR (tem
)->contents
[i
]))
8256 /* Load Ghostscript image IMG for use on frame F. Value is non-zero
8265 Lisp_Object window_and_pixmap_id
= Qnil
, loader
, pt_height
, pt_width
;
8266 struct gcpro gcpro1
, gcpro2
;
8268 double in_width
, in_height
;
8269 Lisp_Object pixel_colors
= Qnil
;
8271 /* Compute pixel size of pixmap needed from the given size in the
8272 image specification. Sizes in the specification are in pt. 1 pt
8273 = 1/72 in, xdpi and ydpi are stored in the frame's X display
8275 pt_width
= image_spec_value (img
->spec
, QCpt_width
, NULL
);
8276 in_width
= XFASTINT (pt_width
) / 72.0;
8277 img
->width
= in_width
* FRAME_X_DISPLAY_INFO (f
)->resx
;
8278 pt_height
= image_spec_value (img
->spec
, QCpt_height
, NULL
);
8279 in_height
= XFASTINT (pt_height
) / 72.0;
8280 img
->height
= in_height
* FRAME_X_DISPLAY_INFO (f
)->resy
;
8282 if (!check_image_size (f
, img
->width
, img
->height
))
8284 image_error ("Invalid image size", Qnil
, Qnil
);
8288 /* Create the pixmap. */
8289 xassert (img
->pixmap
== NO_PIXMAP
);
8291 /* Only W32 version did BLOCK_INPUT here. ++kfs */
8293 img
->pixmap
= XCreatePixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
8294 img
->width
, img
->height
,
8295 DefaultDepthOfScreen (FRAME_X_SCREEN (f
)));
8300 image_error ("Unable to create pixmap for `%s'", img
->spec
, Qnil
);
8304 /* Call the loader to fill the pixmap. It returns a process object
8305 if successful. We do not record_unwind_protect here because
8306 other places in redisplay like calling window scroll functions
8307 don't either. Let the Lisp loader use `unwind-protect' instead. */
8308 GCPRO2 (window_and_pixmap_id
, pixel_colors
);
8310 sprintf (buffer
, "%lu %lu",
8311 (unsigned long) FRAME_X_WINDOW (f
),
8312 (unsigned long) img
->pixmap
);
8313 window_and_pixmap_id
= build_string (buffer
);
8315 sprintf (buffer
, "%lu %lu",
8316 FRAME_FOREGROUND_PIXEL (f
),
8317 FRAME_BACKGROUND_PIXEL (f
));
8318 pixel_colors
= build_string (buffer
);
8320 XSETFRAME (frame
, f
);
8321 loader
= image_spec_value (img
->spec
, QCloader
, NULL
);
8323 loader
= intern ("gs-load-image");
8325 img
->data
.lisp_val
= call6 (loader
, frame
, img
->spec
,
8326 make_number (img
->width
),
8327 make_number (img
->height
),
8328 window_and_pixmap_id
,
8331 return PROCESSP (img
->data
.lisp_val
);
8335 /* Kill the Ghostscript process that was started to fill PIXMAP on
8336 frame F. Called from XTread_socket when receiving an event
8337 telling Emacs that Ghostscript has finished drawing. */
8340 x_kill_gs_process (pixmap
, f
)
8344 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
8348 /* Find the image containing PIXMAP. */
8349 for (i
= 0; i
< c
->used
; ++i
)
8350 if (c
->images
[i
]->pixmap
== pixmap
)
8353 /* Should someone in between have cleared the image cache, for
8354 instance, give up. */
8358 /* Kill the GS process. We should have found PIXMAP in the image
8359 cache and its image should contain a process object. */
8361 xassert (PROCESSP (img
->data
.lisp_val
));
8362 Fkill_process (img
->data
.lisp_val
, Qnil
);
8363 img
->data
.lisp_val
= Qnil
;
8365 #if defined (HAVE_X_WINDOWS)
8367 /* On displays with a mutable colormap, figure out the colors
8368 allocated for the image by looking at the pixels of an XImage for
8370 class = FRAME_X_VISUAL (f
)->class;
8371 if (class != StaticColor
&& class != StaticGray
&& class != TrueColor
)
8377 /* Try to get an XImage for img->pixmep. */
8378 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
8379 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
8384 /* Initialize the color table. */
8385 init_color_table ();
8387 /* For each pixel of the image, look its color up in the
8388 color table. After having done so, the color table will
8389 contain an entry for each color used by the image. */
8390 for (y
= 0; y
< img
->height
; ++y
)
8391 for (x
= 0; x
< img
->width
; ++x
)
8393 unsigned long pixel
= XGetPixel (ximg
, x
, y
);
8394 lookup_pixel_color (f
, pixel
);
8397 /* Record colors in the image. Free color table and XImage. */
8398 #ifdef COLOR_TABLE_SUPPORT
8399 img
->colors
= colors_in_color_table (&img
->ncolors
);
8400 free_color_table ();
8402 XDestroyImage (ximg
);
8404 #if 0 /* This doesn't seem to be the case. If we free the colors
8405 here, we get a BadAccess later in x_clear_image when
8406 freeing the colors. */
8407 /* We have allocated colors once, but Ghostscript has also
8408 allocated colors on behalf of us. So, to get the
8409 reference counts right, free them once. */
8411 x_free_colors (f
, img
->colors
, img
->ncolors
);
8415 image_error ("Cannot get X image of `%s'; colors will not be freed",
8420 #endif /* HAVE_X_WINDOWS */
8422 /* Now that we have the pixmap, compute mask and transform the
8423 image if requested. */
8425 postprocess_image (f
, img
);
8429 #endif /* HAVE_GHOSTSCRIPT */
8432 /***********************************************************************
8434 ***********************************************************************/
8438 DEFUN ("imagep", Fimagep
, Simagep
, 1, 1, 0,
8439 doc
: /* Value is non-nil if SPEC is a valid image specification. */)
8443 return valid_image_p (spec
) ? Qt
: Qnil
;
8447 DEFUN ("lookup-image", Flookup_image
, Slookup_image
, 1, 1, 0, "")
8453 if (valid_image_p (spec
))
8454 id
= lookup_image (SELECTED_FRAME (), spec
);
8457 return make_number (id
);
8460 #endif /* GLYPH_DEBUG != 0 */
8463 /***********************************************************************
8465 ***********************************************************************/
8468 /* Image types that rely on external libraries are loaded dynamically
8469 if the library is available. */
8470 #define CHECK_LIB_AVAILABLE(image_type, init_lib_fn, libraries) \
8471 define_image_type (image_type, init_lib_fn (libraries))
8473 #define CHECK_LIB_AVAILABLE(image_type, init_lib_fn, libraries) \
8474 define_image_type (image_type, 1)
8475 #endif /* HAVE_NTGUI */
8477 DEFUN ("init-image-library", Finit_image_library
, Sinit_image_library
, 2, 2, 0,
8478 doc
: /* Initialize image library implementing image type TYPE.
8479 Return non-nil if TYPE is a supported image type.
8481 Image types pbm and xbm are prebuilt; other types are loaded here.
8482 Libraries to load are specified in alist LIBRARIES (usually, the value
8483 of `image-library-alist', which see). */)
8485 Lisp_Object type
, libraries
;
8489 /* Don't try to reload the library. */
8490 tested
= Fassq (type
, Vimage_type_cache
);
8492 return XCDR (tested
);
8494 #if defined (HAVE_XPM) || defined (MAC_OS)
8495 if (EQ (type
, Qxpm
))
8496 return CHECK_LIB_AVAILABLE (&xpm_type
, init_xpm_functions
, libraries
);
8499 #if defined (HAVE_JPEG) || defined (MAC_OS)
8500 if (EQ (type
, Qjpeg
))
8501 return CHECK_LIB_AVAILABLE (&jpeg_type
, init_jpeg_functions
, libraries
);
8504 #if defined (HAVE_TIFF) || defined (MAC_OS)
8505 if (EQ (type
, Qtiff
))
8506 return CHECK_LIB_AVAILABLE (&tiff_type
, init_tiff_functions
, libraries
);
8509 #if defined (HAVE_GIF) || defined (MAC_OS)
8510 if (EQ (type
, Qgif
))
8511 return CHECK_LIB_AVAILABLE (&gif_type
, init_gif_functions
, libraries
);
8514 #if defined (HAVE_PNG) || defined (MAC_OS)
8515 if (EQ (type
, Qpng
))
8516 return CHECK_LIB_AVAILABLE (&png_type
, init_png_functions
, libraries
);
8519 #ifdef HAVE_GHOSTSCRIPT
8520 if (EQ (type
, Qpostscript
))
8521 return CHECK_LIB_AVAILABLE (&gs_type
, init_gs_functions
, libraries
);
8524 /* If the type is not recognized, avoid testing it ever again. */
8525 CACHE_IMAGE_TYPE (type
, Qnil
);
8532 extern Lisp_Object Qrisky_local_variable
; /* Syms_of_xdisp has already run. */
8534 /* Initialize this only once, since that's what we do with Vimage_types
8535 and they are supposed to be in sync. Initializing here gives correct
8536 operation on GNU/Linux of calling dump-emacs after loading some images. */
8539 /* Must be defined now becase we're going to update it below, while
8540 defining the supported image types. */
8541 DEFVAR_LISP ("image-types", &Vimage_types
,
8542 doc
: /* List of potentially supported image types.
8543 Each element of the list is a symbol for a image type, like 'jpeg or 'png.
8544 To check whether it is really supported, use `image-type-available-p'. */);
8545 Vimage_types
= Qnil
;
8547 DEFVAR_LISP ("image-library-alist", &Vimage_library_alist
,
8548 doc
: /* Alist of image types vs external libraries needed to display them.
8550 Each element is a list (IMAGE-TYPE LIBRARY...), where the car is a symbol
8551 representing a supported image type, and the rest are strings giving
8552 alternate filenames for the corresponding external libraries.
8554 Emacs tries to load the libraries in the order they appear on the
8555 list; if none is loaded, the running session of Emacs won't
8556 support the image type. Types 'pbm and 'xbm don't need to be
8557 listed; they're always supported. */);
8558 Vimage_library_alist
= Qnil
;
8559 Fput (intern ("image-library-alist"), Qrisky_local_variable
, Qt
);
8561 DEFVAR_LISP ("max-image-size", &Vmax_image_size
,
8562 doc
: /* Maximum size of images.
8563 Emacs will not load an image into memory if its pixel width or
8564 pixel height exceeds this limit.
8566 If the value is an integer, it directly specifies the maximum
8567 image height and width, measured in pixels. If it is a floating
8568 point number, it specifies the maximum image height and width
8569 as a ratio to the frame height and width. If the value is
8570 non-numeric, there is no explicit limit on the size of images. */);
8571 Vmax_image_size
= make_float (MAX_IMAGE_SIZE
);
8573 Vimage_type_cache
= Qnil
;
8574 staticpro (&Vimage_type_cache
);
8576 Qpbm
= intern ("pbm");
8578 ADD_IMAGE_TYPE(Qpbm
);
8580 Qxbm
= intern ("xbm");
8582 ADD_IMAGE_TYPE(Qxbm
);
8584 define_image_type (&xbm_type
, 1);
8585 define_image_type (&pbm_type
, 1);
8587 QCascent
= intern (":ascent");
8588 staticpro (&QCascent
);
8589 QCmargin
= intern (":margin");
8590 staticpro (&QCmargin
);
8591 QCrelief
= intern (":relief");
8592 staticpro (&QCrelief
);
8593 QCconversion
= intern (":conversion");
8594 staticpro (&QCconversion
);
8595 QCcolor_symbols
= intern (":color-symbols");
8596 staticpro (&QCcolor_symbols
);
8597 QCheuristic_mask
= intern (":heuristic-mask");
8598 staticpro (&QCheuristic_mask
);
8599 QCindex
= intern (":index");
8600 staticpro (&QCindex
);
8601 QCmatrix
= intern (":matrix");
8602 staticpro (&QCmatrix
);
8603 QCcolor_adjustment
= intern (":color-adjustment");
8604 staticpro (&QCcolor_adjustment
);
8605 QCmask
= intern (":mask");
8606 staticpro (&QCmask
);
8608 Qlaplace
= intern ("laplace");
8609 staticpro (&Qlaplace
);
8610 Qemboss
= intern ("emboss");
8611 staticpro (&Qemboss
);
8612 Qedge_detection
= intern ("edge-detection");
8613 staticpro (&Qedge_detection
);
8614 Qheuristic
= intern ("heuristic");
8615 staticpro (&Qheuristic
);
8617 Qpostscript
= intern ("postscript");
8618 staticpro (&Qpostscript
);
8619 #ifdef HAVE_GHOSTSCRIPT
8620 ADD_IMAGE_TYPE(Qpostscript
);
8621 QCloader
= intern (":loader");
8622 staticpro (&QCloader
);
8623 QCbounding_box
= intern (":bounding-box");
8624 staticpro (&QCbounding_box
);
8625 QCpt_width
= intern (":pt-width");
8626 staticpro (&QCpt_width
);
8627 QCpt_height
= intern (":pt-height");
8628 staticpro (&QCpt_height
);
8629 #endif /* HAVE_GHOSTSCRIPT */
8631 #if defined (HAVE_XPM) || defined (MAC_OS)
8632 Qxpm
= intern ("xpm");
8634 ADD_IMAGE_TYPE(Qxpm
);
8637 #if defined (HAVE_JPEG) || defined (MAC_OS)
8638 Qjpeg
= intern ("jpeg");
8640 ADD_IMAGE_TYPE(Qjpeg
);
8643 #if defined (HAVE_TIFF) || defined (MAC_OS)
8644 Qtiff
= intern ("tiff");
8646 ADD_IMAGE_TYPE(Qtiff
);
8649 #if defined (HAVE_GIF) || defined (MAC_OS)
8650 Qgif
= intern ("gif");
8652 ADD_IMAGE_TYPE(Qgif
);
8655 #if defined (HAVE_PNG) || defined (MAC_OS)
8656 Qpng
= intern ("png");
8658 ADD_IMAGE_TYPE(Qpng
);
8661 defsubr (&Sinit_image_library
);
8662 defsubr (&Sclear_image_cache
);
8663 defsubr (&Simage_size
);
8664 defsubr (&Simage_mask_p
);
8665 defsubr (&Simage_extension_data
);
8669 defsubr (&Slookup_image
);
8672 DEFVAR_BOOL ("cross-disabled-images", &cross_disabled_images
,
8673 doc
: /* Non-nil means always draw a cross over disabled images.
8674 Disabled images are those having an `:conversion disabled' property.
8675 A cross is always drawn on black & white displays. */);
8676 cross_disabled_images
= 0;
8678 DEFVAR_LISP ("x-bitmap-file-path", &Vx_bitmap_file_path
,
8679 doc
: /* List of directories to search for window system bitmap files. */);
8680 Vx_bitmap_file_path
= decode_env_path ((char *) 0, PATH_BITMAPS
);
8682 DEFVAR_LISP ("image-cache-eviction-delay", &Vimage_cache_eviction_delay
,
8683 doc
: /* Time after which cached images are removed from the cache.
8684 When an image has not been displayed this many seconds, remove it
8685 from the image cache. Value must be an integer or nil with nil
8686 meaning don't clear the cache. */);
8687 Vimage_cache_eviction_delay
= make_number (30 * 60);
8693 #if defined (MAC_OSX) && TARGET_API_MAC_CARBON
8694 init_image_func_pointer ();
8698 /* arch-tag: 123c2a5e-14a8-4c53-ab95-af47d7db49b9
8699 (do not change this comment) */