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
;
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
));
1839 c
= FRAME_X_IMAGE_CACHE (f
);
1843 /* Look up SPEC in the hash table of the image cache. */
1844 hash
= sxhash (spec
, 0);
1845 i
= hash
% IMAGE_CACHE_BUCKETS_SIZE
;
1847 for (img
= c
->buckets
[i
]; img
; img
= img
->next
)
1848 if (img
->hash
== hash
&& !NILP (Fequal (img
->spec
, spec
)))
1851 if (img
&& img
->load_failed_p
)
1853 free_image (f
, img
);
1857 /* If not found, create a new image and cache it. */
1860 extern Lisp_Object Qpostscript
;
1863 img
= make_image (spec
, hash
);
1864 cache_image (f
, img
);
1865 img
->load_failed_p
= img
->type
->load (f
, img
) == 0;
1867 /* If we can't load the image, and we don't have a width and
1868 height, use some arbitrary width and height so that we can
1869 draw a rectangle for it. */
1870 if (img
->load_failed_p
)
1874 value
= image_spec_value (spec
, QCwidth
, NULL
);
1875 img
->width
= (INTEGERP (value
)
1876 ? XFASTINT (value
) : DEFAULT_IMAGE_WIDTH
);
1877 value
= image_spec_value (spec
, QCheight
, NULL
);
1878 img
->height
= (INTEGERP (value
)
1879 ? XFASTINT (value
) : DEFAULT_IMAGE_HEIGHT
);
1883 /* Handle image type independent image attributes
1884 `:ascent ASCENT', `:margin MARGIN', `:relief RELIEF',
1885 `:background COLOR'. */
1886 Lisp_Object ascent
, margin
, relief
, bg
;
1888 ascent
= image_spec_value (spec
, QCascent
, NULL
);
1889 if (INTEGERP (ascent
))
1890 img
->ascent
= XFASTINT (ascent
);
1891 else if (EQ (ascent
, Qcenter
))
1892 img
->ascent
= CENTERED_IMAGE_ASCENT
;
1894 margin
= image_spec_value (spec
, QCmargin
, NULL
);
1895 if (INTEGERP (margin
) && XINT (margin
) >= 0)
1896 img
->vmargin
= img
->hmargin
= XFASTINT (margin
);
1897 else if (CONSP (margin
) && INTEGERP (XCAR (margin
))
1898 && INTEGERP (XCDR (margin
)))
1900 if (XINT (XCAR (margin
)) > 0)
1901 img
->hmargin
= XFASTINT (XCAR (margin
));
1902 if (XINT (XCDR (margin
)) > 0)
1903 img
->vmargin
= XFASTINT (XCDR (margin
));
1906 relief
= image_spec_value (spec
, QCrelief
, NULL
);
1907 if (INTEGERP (relief
))
1909 img
->relief
= XINT (relief
);
1910 img
->hmargin
+= abs (img
->relief
);
1911 img
->vmargin
+= abs (img
->relief
);
1914 if (! img
->background_valid
)
1916 bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
1920 = x_alloc_image_color (f
, img
, bg
,
1921 FRAME_BACKGROUND_PIXEL (f
));
1922 img
->background_valid
= 1;
1926 /* Do image transformations and compute masks, unless we
1927 don't have the image yet. */
1928 if (!EQ (*img
->type
->type
, Qpostscript
))
1929 postprocess_image (f
, img
);
1935 /* We're using IMG, so set its timestamp to `now'. */
1936 EMACS_GET_TIME (now
);
1937 img
->timestamp
= EMACS_SECS (now
);
1941 /* Value is the image id. */
1946 /* Cache image IMG in the image cache of frame F. */
1949 cache_image (f
, img
)
1953 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
1956 /* Find a free slot in c->images. */
1957 for (i
= 0; i
< c
->used
; ++i
)
1958 if (c
->images
[i
] == NULL
)
1961 /* If no free slot found, maybe enlarge c->images. */
1962 if (i
== c
->used
&& c
->used
== c
->size
)
1965 c
->images
= (struct image
**) xrealloc (c
->images
,
1966 c
->size
* sizeof *c
->images
);
1969 /* Add IMG to c->images, and assign IMG an id. */
1975 /* Add IMG to the cache's hash table. */
1976 i
= img
->hash
% IMAGE_CACHE_BUCKETS_SIZE
;
1977 img
->next
= c
->buckets
[i
];
1979 img
->next
->prev
= img
;
1981 c
->buckets
[i
] = img
;
1985 /* Call FN on every image in the image cache of frame F. Used to mark
1986 Lisp Objects in the image cache. */
1989 forall_images_in_image_cache (f
, fn
)
1991 void (*fn
) P_ ((struct image
*img
));
1993 if (FRAME_LIVE_P (f
) && FRAME_WINDOW_P (f
))
1995 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
1999 for (i
= 0; i
< c
->used
; ++i
)
2008 /***********************************************************************
2009 X / MAC / W32 support code
2010 ***********************************************************************/
2014 /* Macro for defining functions that will be loaded from image DLLs. */
2015 #define DEF_IMGLIB_FN(func) int (FAR CDECL *fn_##func)()
2017 /* Macro for loading those image functions from the library. */
2018 #define LOAD_IMGLIB_FN(lib,func) { \
2019 fn_##func = (void *) GetProcAddress (lib, #func); \
2020 if (!fn_##func) return 0; \
2023 /* Load a DLL implementing an image type.
2024 The `image-library-alist' variable associates a symbol,
2025 identifying an image type, to a list of possible filenames.
2026 The function returns NULL if no library could be loaded for
2027 the given image type, or if the library was previously loaded;
2028 else the handle of the DLL. */
2030 w32_delayed_load (Lisp_Object libraries
, Lisp_Object type
)
2032 HMODULE library
= NULL
;
2034 if (CONSP (libraries
) && NILP (Fassq (type
, Vimage_type_cache
)))
2036 Lisp_Object dlls
= Fassq (type
, libraries
);
2039 for (dlls
= XCDR (dlls
); CONSP (dlls
); dlls
= XCDR (dlls
))
2041 CHECK_STRING_CAR (dlls
);
2042 if (library
= LoadLibrary (SDATA (XCAR (dlls
))))
2050 #endif /* HAVE_NTGUI */
2052 static int x_create_x_image_and_pixmap
P_ ((struct frame
*, int, int, int,
2053 XImagePtr
*, Pixmap
*));
2054 static void x_destroy_x_image
P_ ((XImagePtr
));
2055 static void x_put_x_image
P_ ((struct frame
*, XImagePtr
, Pixmap
, int, int));
2058 /* Create an XImage and a pixmap of size WIDTH x HEIGHT for use on
2059 frame F. Set *XIMG and *PIXMAP to the XImage and Pixmap created.
2060 Set (*XIMG)->data to a raster of WIDTH x HEIGHT pixels allocated
2061 via xmalloc. Print error messages via image_error if an error
2062 occurs. Value is non-zero if successful.
2064 On W32, a DEPTH of zero signifies a 24 bit image, otherwise DEPTH
2065 should indicate the bit depth of the image. */
2068 x_create_x_image_and_pixmap (f
, width
, height
, depth
, ximg
, pixmap
)
2070 int width
, height
, depth
;
2074 #ifdef HAVE_X_WINDOWS
2075 Display
*display
= FRAME_X_DISPLAY (f
);
2076 Window window
= FRAME_X_WINDOW (f
);
2077 Screen
*screen
= FRAME_X_SCREEN (f
);
2079 xassert (interrupt_input_blocked
);
2082 depth
= DefaultDepthOfScreen (screen
);
2083 *ximg
= XCreateImage (display
, DefaultVisualOfScreen (screen
),
2084 depth
, ZPixmap
, 0, NULL
, width
, height
,
2085 depth
> 16 ? 32 : depth
> 8 ? 16 : 8, 0);
2088 image_error ("Unable to allocate X image", Qnil
, Qnil
);
2092 /* Allocate image raster. */
2093 (*ximg
)->data
= (char *) xmalloc ((*ximg
)->bytes_per_line
* height
);
2095 /* Allocate a pixmap of the same size. */
2096 *pixmap
= XCreatePixmap (display
, window
, width
, height
, depth
);
2097 if (*pixmap
== NO_PIXMAP
)
2099 x_destroy_x_image (*ximg
);
2101 image_error ("Unable to create X pixmap", Qnil
, Qnil
);
2106 #endif /* HAVE_X_WINDOWS */
2110 BITMAPINFOHEADER
*header
;
2112 int scanline_width_bits
;
2114 int palette_colors
= 0;
2119 if (depth
!= 1 && depth
!= 4 && depth
!= 8
2120 && depth
!= 16 && depth
!= 24 && depth
!= 32)
2122 image_error ("Invalid image bit depth specified", Qnil
, Qnil
);
2126 scanline_width_bits
= width
* depth
;
2127 remainder
= scanline_width_bits
% 32;
2130 scanline_width_bits
+= 32 - remainder
;
2132 /* Bitmaps with a depth less than 16 need a palette. */
2133 /* BITMAPINFO structure already contains the first RGBQUAD. */
2135 palette_colors
= 1 << depth
- 1;
2137 *ximg
= xmalloc (sizeof (XImage
) + palette_colors
* sizeof (RGBQUAD
));
2140 image_error ("Unable to allocate memory for XImage", Qnil
, Qnil
);
2144 header
= &((*ximg
)->info
.bmiHeader
);
2145 bzero (&((*ximg
)->info
), sizeof (BITMAPINFO
));
2146 header
->biSize
= sizeof (*header
);
2147 header
->biWidth
= width
;
2148 header
->biHeight
= -height
; /* negative indicates a top-down bitmap. */
2149 header
->biPlanes
= 1;
2150 header
->biBitCount
= depth
;
2151 header
->biCompression
= BI_RGB
;
2152 header
->biClrUsed
= palette_colors
;
2154 /* TODO: fill in palette. */
2157 (*ximg
)->info
.bmiColors
[0].rgbBlue
= 0;
2158 (*ximg
)->info
.bmiColors
[0].rgbGreen
= 0;
2159 (*ximg
)->info
.bmiColors
[0].rgbRed
= 0;
2160 (*ximg
)->info
.bmiColors
[0].rgbReserved
= 0;
2161 (*ximg
)->info
.bmiColors
[1].rgbBlue
= 255;
2162 (*ximg
)->info
.bmiColors
[1].rgbGreen
= 255;
2163 (*ximg
)->info
.bmiColors
[1].rgbRed
= 255;
2164 (*ximg
)->info
.bmiColors
[1].rgbReserved
= 0;
2167 hdc
= get_frame_dc (f
);
2169 /* Create a DIBSection and raster array for the bitmap,
2170 and store its handle in *pixmap. */
2171 *pixmap
= CreateDIBSection (hdc
, &((*ximg
)->info
),
2172 (depth
< 16) ? DIB_PAL_COLORS
: DIB_RGB_COLORS
,
2173 /* casting avoids a GCC warning */
2174 (void **)&((*ximg
)->data
), NULL
, 0);
2176 /* Realize display palette and garbage all frames. */
2177 release_frame_dc (f
, hdc
);
2179 if (*pixmap
== NULL
)
2181 DWORD err
= GetLastError();
2182 Lisp_Object errcode
;
2183 /* All system errors are < 10000, so the following is safe. */
2184 XSETINT (errcode
, (int) err
);
2185 image_error ("Unable to create bitmap, error code %d", errcode
, Qnil
);
2186 x_destroy_x_image (*ximg
);
2192 #endif /* HAVE_NTGUI */
2195 Display
*display
= FRAME_X_DISPLAY (f
);
2196 Window window
= FRAME_X_WINDOW (f
);
2198 xassert (interrupt_input_blocked
);
2200 /* Allocate a pixmap of the same size. */
2201 *pixmap
= XCreatePixmap (display
, window
, width
, height
, depth
);
2202 if (*pixmap
== NO_PIXMAP
)
2205 image_error ("Unable to create X pixmap", Qnil
, Qnil
);
2209 LockPixels (GetGWorldPixMap (*pixmap
));
2217 /* Destroy XImage XIMG. Free XIMG->data. */
2220 x_destroy_x_image (ximg
)
2223 xassert (interrupt_input_blocked
);
2226 #ifdef HAVE_X_WINDOWS
2229 XDestroyImage (ximg
);
2230 #endif /* HAVE_X_WINDOWS */
2232 /* Data will be freed by DestroyObject. */
2235 #endif /* HAVE_NTGUI */
2237 XDestroyImage (ximg
);
2243 /* Put XImage XIMG into pixmap PIXMAP on frame F. WIDTH and HEIGHT
2244 are width and height of both the image and pixmap. */
2247 x_put_x_image (f
, ximg
, pixmap
, width
, height
)
2253 #ifdef HAVE_X_WINDOWS
2256 xassert (interrupt_input_blocked
);
2257 gc
= XCreateGC (FRAME_X_DISPLAY (f
), pixmap
, 0, NULL
);
2258 XPutImage (FRAME_X_DISPLAY (f
), pixmap
, gc
, ximg
, 0, 0, 0, 0, width
, height
);
2259 XFreeGC (FRAME_X_DISPLAY (f
), gc
);
2260 #endif /* HAVE_X_WINDOWS */
2263 #if 0 /* I don't think this is necessary looking at where it is used. */
2264 HDC hdc
= get_frame_dc (f
);
2265 SetDIBits (hdc
, pixmap
, 0, height
, ximg
->data
, &(ximg
->info
), DIB_RGB_COLORS
);
2266 release_frame_dc (f
, hdc
);
2268 #endif /* HAVE_NTGUI */
2271 xassert (ximg
== pixmap
);
2276 /***********************************************************************
2278 ***********************************************************************/
2280 static unsigned char *slurp_file
P_ ((char *, int *));
2283 /* Find image file FILE. Look in data-directory, then
2284 x-bitmap-file-path. Value is the encoded full name of the file
2285 found, or nil if not found. */
2288 x_find_image_file (file
)
2291 Lisp_Object file_found
, search_path
;
2292 struct gcpro gcpro1
, gcpro2
;
2296 search_path
= Fcons (Vdata_directory
, Vx_bitmap_file_path
);
2297 GCPRO2 (file_found
, search_path
);
2299 /* Try to find FILE in data-directory, then x-bitmap-file-path. */
2300 fd
= openp (search_path
, file
, Qnil
, &file_found
, Qnil
);
2306 file_found
= ENCODE_FILE (file_found
);
2315 /* Read FILE into memory. Value is a pointer to a buffer allocated
2316 with xmalloc holding FILE's contents. Value is null if an error
2317 occurred. *SIZE is set to the size of the file. */
2319 static unsigned char *
2320 slurp_file (file
, size
)
2325 unsigned char *buf
= NULL
;
2328 if (stat (file
, &st
) == 0
2329 && (fp
= fopen (file
, "rb")) != NULL
2330 && (buf
= (unsigned char *) xmalloc (st
.st_size
),
2331 fread (buf
, 1, st
.st_size
, fp
) == st
.st_size
))
2354 /***********************************************************************
2355 MAC Image Load Functions
2356 ***********************************************************************/
2358 static int image_load_quicktime
P_ ((struct frame
*, struct image
*img
,
2361 static int image_load_quartz2d
P_ ((struct frame
*, struct image
*img
, int));
2365 find_image_fsspec (specified_file
, file
, fss
)
2366 Lisp_Object specified_file
, *file
;
2372 *file
= x_find_image_file (specified_file
);
2373 if (!STRINGP (*file
))
2374 return fnfErr
; /* file or directory not found;
2375 incomplete pathname */
2376 /* Try to open the image file. */
2377 err
= AECoercePtr (TYPE_FILE_NAME
, SDATA (*file
),
2378 SBYTES (*file
), typeFSS
, &desc
);
2381 #if TARGET_API_MAC_CARBON
2382 err
= AEGetDescData (&desc
, fss
, sizeof (FSSpec
));
2384 *fss
= *(FSSpec
*)(*(desc
.dataHandle
));
2386 AEDisposeDesc (&desc
);
2392 image_load_qt_1 (f
, img
, type
, fss
, dh
)
2399 ComponentResult err
;
2400 GraphicsImportComponent gi
;
2403 ImageDescriptionHandle desc_handle
;
2404 short draw_all_pixels
;
2405 Lisp_Object specified_bg
;
2410 err
= OpenADefaultComponent (GraphicsImporterComponentType
, type
, &gi
);
2413 image_error ("Cannot get importer component for `%s'", img
->spec
, Qnil
);
2418 /* read from file system spec */
2419 err
= GraphicsImportSetDataFile (gi
, fss
);
2422 image_error ("Cannot set fsspec to graphics importer for '%s'",
2429 /* read from data handle */
2430 err
= GraphicsImportSetDataHandle (gi
, dh
);
2433 image_error ("Cannot set data handle to graphics importer for `%s'",
2438 err
= GraphicsImportGetImageDescription (gi
, &desc_handle
);
2439 if (err
!= noErr
|| desc_handle
== NULL
)
2441 image_error ("Error reading `%s'", img
->spec
, Qnil
);
2444 width
= img
->width
= (*desc_handle
)->width
;
2445 height
= img
->height
= (*desc_handle
)->height
;
2446 DisposeHandle ((Handle
)desc_handle
);
2448 if (!check_image_size (f
, width
, height
))
2450 image_error ("Invalid image size", Qnil
, Qnil
);
2454 err
= GraphicsImportDoesDrawAllPixels (gi
, &draw_all_pixels
);
2456 /* Don't check the error code here. It may have an undocumented
2460 image_error ("Error reading `%s'", img
->spec
, Qnil
);
2464 if (draw_all_pixels
!= graphicsImporterDrawsAllPixels
)
2466 specified_bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
2467 if (!STRINGP (specified_bg
) ||
2468 !mac_defined_color (f
, SDATA (specified_bg
), &color
, 0))
2470 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
2471 color
.red
= RED16_FROM_ULONG (color
.pixel
);
2472 color
.green
= GREEN16_FROM_ULONG (color
.pixel
);
2473 color
.blue
= BLUE16_FROM_ULONG (color
.pixel
);
2477 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
2479 if (draw_all_pixels
!= graphicsImporterDrawsAllPixels
)
2484 GetGWorld (&old_port
, &old_gdh
);
2485 SetGWorld (ximg
, NULL
);
2486 bg_color
.red
= color
.red
;
2487 bg_color
.green
= color
.green
;
2488 bg_color
.blue
= color
.blue
;
2489 RGBBackColor (&bg_color
);
2490 #if TARGET_API_MAC_CARBON
2491 GetPortBounds (ximg
, &rect
);
2494 EraseRect (&(ximg
->portRect
));
2496 SetGWorld (old_port
, old_gdh
);
2498 GraphicsImportSetGWorld (gi
, ximg
, NULL
);
2499 GraphicsImportDraw (gi
);
2500 CloseComponent (gi
);
2502 /* Maybe fill in the background field while we have ximg handy. */
2503 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
2504 IMAGE_BACKGROUND (img
, f
, ximg
);
2506 /* Put the image into the pixmap. */
2507 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
2508 x_destroy_x_image (ximg
);
2512 CloseComponent (gi
);
2517 /* Load an image using the QuickTime Graphics Importer.
2518 Note: The alpha channel does not work for PNG images. */
2520 image_load_quicktime (f
, img
, type
)
2525 Lisp_Object specified_file
;
2526 Lisp_Object specified_data
;
2529 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
2530 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
2532 if (NILP (specified_data
))
2534 /* Read from a file */
2538 err
= find_image_fsspec (specified_file
, &file
, &fss
);
2542 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
2544 image_error ("Cannot open `%s'", file
, Qnil
);
2547 return image_load_qt_1 (f
, img
, type
, &fss
, NULL
);
2551 /* Memory source! */
2555 err
= PtrToHand (SDATA (specified_data
), &dh
, SBYTES (specified_data
));
2558 image_error ("Cannot allocate data handle for `%s'",
2562 success_p
= image_load_qt_1 (f
, img
, type
, NULL
, dh
);
2570 /* Load a PNG/JPEG image using Quartz 2D decoding routines.
2571 CGImageCreateWithPNGDataProvider is provided after Mac OS X 10.2.
2572 So don't use this function directly but determine at runtime
2573 whether it exists. */
2574 typedef CGImageRef (*CGImageCreateWithPNGDataProviderProcType
)
2575 (CGDataProviderRef
, const float [], bool, CGColorRenderingIntent
);
2576 static CGImageCreateWithPNGDataProviderProcType MyCGImageCreateWithPNGDataProvider
;
2580 init_image_func_pointer ()
2582 if (NSIsSymbolNameDefined ("_CGImageCreateWithPNGDataProvider"))
2584 MyCGImageCreateWithPNGDataProvider
2585 = (CGImageCreateWithPNGDataProviderProcType
)
2586 NSAddressOfSymbol (NSLookupAndBindSymbol
2587 ("_CGImageCreateWithPNGDataProvider"));
2590 MyCGImageCreateWithPNGDataProvider
= NULL
;
2595 image_load_quartz2d (f
, img
, png_p
)
2600 Lisp_Object file
, specified_file
;
2601 Lisp_Object specified_data
, specified_bg
;
2602 struct gcpro gcpro1
;
2603 CGDataProviderRef source
;
2607 XImagePtr ximg
= NULL
;
2608 CGContextRef context
;
2611 /* Open the file. */
2612 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
2613 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
2618 if (NILP (specified_data
))
2623 file
= x_find_image_file (specified_file
);
2624 if (!STRINGP (file
))
2626 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
2630 path
= cfstring_create_with_utf8_cstring (SDATA (file
));
2631 url
= CFURLCreateWithFileSystemPath (NULL
, path
,
2632 kCFURLPOSIXPathStyle
, 0);
2634 source
= CGDataProviderCreateWithURL (url
);
2638 source
= CGDataProviderCreateWithData (NULL
, SDATA (specified_data
),
2639 SBYTES (specified_data
), NULL
);
2642 image
= (*MyCGImageCreateWithPNGDataProvider
) (source
, NULL
, FALSE
,
2643 kCGRenderingIntentDefault
);
2645 image
= CGImageCreateWithJPEGDataProvider (source
, NULL
, FALSE
,
2646 kCGRenderingIntentDefault
);
2648 CGDataProviderRelease (source
);
2652 image_error ("Error reading image `%s'", img
->spec
, Qnil
);
2655 width
= img
->width
= CGImageGetWidth (image
);
2656 height
= img
->height
= CGImageGetHeight (image
);
2658 if (!check_image_size (f
, width
, height
))
2660 CGImageRelease (image
);
2662 image_error ("Invalid image size", Qnil
, Qnil
);
2668 specified_bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
2669 if (!STRINGP (specified_bg
) ||
2670 !mac_defined_color (f
, SDATA (specified_bg
), &color
, 0))
2672 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
2673 color
.red
= RED16_FROM_ULONG (color
.pixel
);
2674 color
.green
= GREEN16_FROM_ULONG (color
.pixel
);
2675 color
.blue
= BLUE16_FROM_ULONG (color
.pixel
);
2679 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
2681 CGImageRelease (image
);
2685 rectangle
= CGRectMake (0, 0, width
, height
);
2686 QDBeginCGContext (ximg
, &context
);
2689 CGContextSetRGBFillColor (context
, color
.red
/ 65535.0,
2690 color
.green
/ 65535.0,
2691 color
.blue
/ 65535.0, 1.0);
2692 CGContextFillRect (context
, rectangle
);
2694 CGContextDrawImage (context
, rectangle
, image
);
2695 QDEndCGContext (ximg
, &context
);
2696 CGImageRelease (image
);
2698 /* Maybe fill in the background field while we have ximg handy. */
2699 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
2700 IMAGE_BACKGROUND (img
, f
, ximg
);
2702 /* Put the image into the pixmap. */
2703 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
2704 x_destroy_x_image (ximg
);
2713 /***********************************************************************
2715 ***********************************************************************/
2717 static int xbm_scan
P_ ((unsigned char **, unsigned char *, char *, int *));
2718 static int xbm_load
P_ ((struct frame
*f
, struct image
*img
));
2719 static int xbm_load_image
P_ ((struct frame
*f
, struct image
*img
,
2720 unsigned char *, unsigned char *));
2721 static int xbm_image_p
P_ ((Lisp_Object object
));
2722 static int xbm_read_bitmap_data
P_ ((struct frame
*f
,
2723 unsigned char *, unsigned char *,
2724 int *, int *, unsigned char **));
2725 static int xbm_file_p
P_ ((Lisp_Object
));
2728 /* Indices of image specification fields in xbm_format, below. */
2730 enum xbm_keyword_index
2748 /* Vector of image_keyword structures describing the format
2749 of valid XBM image specifications. */
2751 static struct image_keyword xbm_format
[XBM_LAST
] =
2753 {":type", IMAGE_SYMBOL_VALUE
, 1},
2754 {":file", IMAGE_STRING_VALUE
, 0},
2755 {":width", IMAGE_POSITIVE_INTEGER_VALUE
, 0},
2756 {":height", IMAGE_POSITIVE_INTEGER_VALUE
, 0},
2757 {":data", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
2758 {":foreground", IMAGE_STRING_OR_NIL_VALUE
, 0},
2759 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0},
2760 {":ascent", IMAGE_ASCENT_VALUE
, 0},
2761 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
2762 {":relief", IMAGE_INTEGER_VALUE
, 0},
2763 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
2764 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
2765 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0}
2768 /* Structure describing the image type XBM. */
2770 static struct image_type xbm_type
=
2779 /* Tokens returned from xbm_scan. */
2788 /* Return non-zero if OBJECT is a valid XBM-type image specification.
2789 A valid specification is a list starting with the symbol `image'
2790 The rest of the list is a property list which must contain an
2793 If the specification specifies a file to load, it must contain
2794 an entry `:file FILENAME' where FILENAME is a string.
2796 If the specification is for a bitmap loaded from memory it must
2797 contain `:width WIDTH', `:height HEIGHT', and `:data DATA', where
2798 WIDTH and HEIGHT are integers > 0. DATA may be:
2800 1. a string large enough to hold the bitmap data, i.e. it must
2801 have a size >= (WIDTH + 7) / 8 * HEIGHT
2803 2. a bool-vector of size >= WIDTH * HEIGHT
2805 3. a vector of strings or bool-vectors, one for each line of the
2808 4. A string containing an in-memory XBM file. WIDTH and HEIGHT
2809 may not be specified in this case because they are defined in the
2812 Both the file and data forms may contain the additional entries
2813 `:background COLOR' and `:foreground COLOR'. If not present,
2814 foreground and background of the frame on which the image is
2815 displayed is used. */
2818 xbm_image_p (object
)
2821 struct image_keyword kw
[XBM_LAST
];
2823 bcopy (xbm_format
, kw
, sizeof kw
);
2824 if (!parse_image_spec (object
, kw
, XBM_LAST
, Qxbm
))
2827 xassert (EQ (kw
[XBM_TYPE
].value
, Qxbm
));
2829 if (kw
[XBM_FILE
].count
)
2831 if (kw
[XBM_WIDTH
].count
|| kw
[XBM_HEIGHT
].count
|| kw
[XBM_DATA
].count
)
2834 else if (kw
[XBM_DATA
].count
&& xbm_file_p (kw
[XBM_DATA
].value
))
2836 /* In-memory XBM file. */
2837 if (kw
[XBM_WIDTH
].count
|| kw
[XBM_HEIGHT
].count
|| kw
[XBM_FILE
].count
)
2845 /* Entries for `:width', `:height' and `:data' must be present. */
2846 if (!kw
[XBM_WIDTH
].count
2847 || !kw
[XBM_HEIGHT
].count
2848 || !kw
[XBM_DATA
].count
)
2851 data
= kw
[XBM_DATA
].value
;
2852 width
= XFASTINT (kw
[XBM_WIDTH
].value
);
2853 height
= XFASTINT (kw
[XBM_HEIGHT
].value
);
2855 /* Check type of data, and width and height against contents of
2861 /* Number of elements of the vector must be >= height. */
2862 if (XVECTOR (data
)->size
< height
)
2865 /* Each string or bool-vector in data must be large enough
2866 for one line of the image. */
2867 for (i
= 0; i
< height
; ++i
)
2869 Lisp_Object elt
= XVECTOR (data
)->contents
[i
];
2874 < (width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
)
2877 else if (BOOL_VECTOR_P (elt
))
2879 if (XBOOL_VECTOR (elt
)->size
< width
)
2886 else if (STRINGP (data
))
2889 < (width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
* height
)
2892 else if (BOOL_VECTOR_P (data
))
2894 if (XBOOL_VECTOR (data
)->size
< width
* height
)
2905 /* Scan a bitmap file. FP is the stream to read from. Value is
2906 either an enumerator from enum xbm_token, or a character for a
2907 single-character token, or 0 at end of file. If scanning an
2908 identifier, store the lexeme of the identifier in SVAL. If
2909 scanning a number, store its value in *IVAL. */
2912 xbm_scan (s
, end
, sval
, ival
)
2913 unsigned char **s
, *end
;
2921 /* Skip white space. */
2922 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
2927 else if (isdigit (c
))
2929 int value
= 0, digit
;
2931 if (c
== '0' && *s
< end
)
2934 if (c
== 'x' || c
== 'X')
2941 else if (c
>= 'a' && c
<= 'f')
2942 digit
= c
- 'a' + 10;
2943 else if (c
>= 'A' && c
<= 'F')
2944 digit
= c
- 'A' + 10;
2947 value
= 16 * value
+ digit
;
2950 else if (isdigit (c
))
2954 && (c
= *(*s
)++, isdigit (c
)))
2955 value
= 8 * value
+ c
- '0';
2962 && (c
= *(*s
)++, isdigit (c
)))
2963 value
= 10 * value
+ c
- '0';
2971 else if (isalpha (c
) || c
== '_')
2975 && (c
= *(*s
)++, (isalnum (c
) || c
== '_')))
2982 else if (c
== '/' && **s
== '*')
2984 /* C-style comment. */
2986 while (**s
&& (**s
!= '*' || *(*s
+ 1) != '/'))
3000 /* Create a Windows bitmap from X bitmap data. */
3002 w32_create_pixmap_from_bitmap_data (int width
, int height
, char *data
)
3004 static unsigned char swap_nibble
[16]
3005 = { 0x0, 0x8, 0x4, 0xc, /* 0000 1000 0100 1100 */
3006 0x2, 0xa, 0x6, 0xe, /* 0010 1010 0110 1110 */
3007 0x1, 0x9, 0x5, 0xd, /* 0001 1001 0101 1101 */
3008 0x3, 0xb, 0x7, 0xf }; /* 0011 1011 0111 1111 */
3010 unsigned char *bits
, *p
;
3013 w1
= (width
+ 7) / 8; /* nb of 8bits elt in X bitmap */
3014 w2
= ((width
+ 15) / 16) * 2; /* nb of 16bits elt in W32 bitmap */
3015 bits
= (unsigned char *) alloca (height
* w2
);
3016 bzero (bits
, height
* w2
);
3017 for (i
= 0; i
< height
; i
++)
3020 for (j
= 0; j
< w1
; j
++)
3022 /* Bitswap XBM bytes to match how Windows does things. */
3023 unsigned char c
= *data
++;
3024 *p
++ = (unsigned char)((swap_nibble
[c
& 0xf] << 4)
3025 | (swap_nibble
[(c
>>4) & 0xf]));
3028 bmp
= CreateBitmap (width
, height
, 1, 1, (char *) bits
);
3033 static void convert_mono_to_color_image (f
, img
, foreground
, background
)
3036 COLORREF foreground
, background
;
3038 HDC hdc
, old_img_dc
, new_img_dc
;
3039 HGDIOBJ old_prev
, new_prev
;
3042 hdc
= get_frame_dc (f
);
3043 old_img_dc
= CreateCompatibleDC (hdc
);
3044 new_img_dc
= CreateCompatibleDC (hdc
);
3045 new_pixmap
= CreateCompatibleBitmap (hdc
, img
->width
, img
->height
);
3046 release_frame_dc (f
, hdc
);
3047 old_prev
= SelectObject (old_img_dc
, img
->pixmap
);
3048 new_prev
= SelectObject (new_img_dc
, new_pixmap
);
3049 SetTextColor (new_img_dc
, foreground
);
3050 SetBkColor (new_img_dc
, background
);
3052 BitBlt (new_img_dc
, 0, 0, img
->width
, img
->height
, old_img_dc
,
3055 SelectObject (old_img_dc
, old_prev
);
3056 SelectObject (new_img_dc
, new_prev
);
3057 DeleteDC (old_img_dc
);
3058 DeleteDC (new_img_dc
);
3059 DeleteObject (img
->pixmap
);
3060 if (new_pixmap
== 0)
3061 fprintf (stderr
, "Failed to convert image to color.\n");
3063 img
->pixmap
= new_pixmap
;
3066 #define XBM_BIT_SHUFFLE(b) (~(b))
3070 #define XBM_BIT_SHUFFLE(b) (b)
3072 #endif /* HAVE_NTGUI */
3076 Create_Pixmap_From_Bitmap_Data(f
, img
, data
, fg
, bg
, non_default_colors
)
3080 RGB_PIXEL_COLOR fg
, bg
;
3081 int non_default_colors
;
3085 = w32_create_pixmap_from_bitmap_data (img
->width
, img
->height
, data
);
3087 /* If colors were specified, transfer the bitmap to a color one. */
3088 if (non_default_colors
)
3089 convert_mono_to_color_image (f
, img
, fg
, bg
);
3092 = XCreatePixmapFromBitmapData (FRAME_X_DISPLAY (f
),
3095 img
->width
, img
->height
,
3097 DefaultDepthOfScreen (FRAME_X_SCREEN (f
)));
3098 #endif /* HAVE_NTGUI */
3103 /* Replacement for XReadBitmapFileData which isn't available under old
3104 X versions. CONTENTS is a pointer to a buffer to parse; END is the
3105 buffer's end. Set *WIDTH and *HEIGHT to the width and height of
3106 the image. Return in *DATA the bitmap data allocated with xmalloc.
3107 Value is non-zero if successful. DATA null means just test if
3108 CONTENTS looks like an in-memory XBM file. */
3111 xbm_read_bitmap_data (f
, contents
, end
, width
, height
, data
)
3113 unsigned char *contents
, *end
;
3114 int *width
, *height
;
3115 unsigned char **data
;
3117 unsigned char *s
= contents
;
3118 char buffer
[BUFSIZ
];
3121 int bytes_per_line
, i
, nbytes
;
3127 LA1 = xbm_scan (&s, end, buffer, &value)
3129 #define expect(TOKEN) \
3130 if (LA1 != (TOKEN)) \
3135 #define expect_ident(IDENT) \
3136 if (LA1 == XBM_TK_IDENT && strcmp (buffer, (IDENT)) == 0) \
3141 *width
= *height
= -1;
3144 LA1
= xbm_scan (&s
, end
, buffer
, &value
);
3146 /* Parse defines for width, height and hot-spots. */
3150 expect_ident ("define");
3151 expect (XBM_TK_IDENT
);
3153 if (LA1
== XBM_TK_NUMBER
)
3155 char *p
= strrchr (buffer
, '_');
3156 p
= p
? p
+ 1 : buffer
;
3157 if (strcmp (p
, "width") == 0)
3159 else if (strcmp (p
, "height") == 0)
3162 expect (XBM_TK_NUMBER
);
3165 if (!check_image_size (f
, *width
, *height
))
3167 else if (data
== NULL
)
3170 /* Parse bits. Must start with `static'. */
3171 expect_ident ("static");
3172 if (LA1
== XBM_TK_IDENT
)
3174 if (strcmp (buffer
, "unsigned") == 0)
3177 expect_ident ("char");
3179 else if (strcmp (buffer
, "short") == 0)
3183 if (*width
% 16 && *width
% 16 < 9)
3186 else if (strcmp (buffer
, "char") == 0)
3194 expect (XBM_TK_IDENT
);
3200 bytes_per_line
= (*width
+ 7) / 8 + padding_p
;
3201 nbytes
= bytes_per_line
* *height
;
3202 p
= *data
= (unsigned char *) xmalloc (nbytes
);
3206 for (i
= 0; i
< nbytes
; i
+= 2)
3209 expect (XBM_TK_NUMBER
);
3211 *p
++ = XBM_BIT_SHUFFLE (val
);
3212 if (!padding_p
|| ((i
+ 2) % bytes_per_line
))
3213 *p
++ = XBM_BIT_SHUFFLE (value
>> 8);
3215 if (LA1
== ',' || LA1
== '}')
3223 for (i
= 0; i
< nbytes
; ++i
)
3226 expect (XBM_TK_NUMBER
);
3228 *p
++ = XBM_BIT_SHUFFLE (val
);
3230 if (LA1
== ',' || LA1
== '}')
3255 /* Load XBM image IMG which will be displayed on frame F from buffer
3256 CONTENTS. END is the end of the buffer. Value is non-zero if
3260 xbm_load_image (f
, img
, contents
, end
)
3263 unsigned char *contents
, *end
;
3266 unsigned char *data
;
3269 rc
= xbm_read_bitmap_data (f
, contents
, end
, &img
->width
, &img
->height
, &data
);
3272 unsigned long foreground
= FRAME_FOREGROUND_PIXEL (f
);
3273 unsigned long background
= FRAME_BACKGROUND_PIXEL (f
);
3274 int non_default_colors
= 0;
3277 xassert (img
->width
> 0 && img
->height
> 0);
3279 /* Get foreground and background colors, maybe allocate colors. */
3280 value
= image_spec_value (img
->spec
, QCforeground
, NULL
);
3283 foreground
= x_alloc_image_color (f
, img
, value
, foreground
);
3284 non_default_colors
= 1;
3286 value
= image_spec_value (img
->spec
, QCbackground
, NULL
);
3289 background
= x_alloc_image_color (f
, img
, value
, background
);
3290 img
->background
= background
;
3291 img
->background_valid
= 1;
3292 non_default_colors
= 1;
3295 Create_Pixmap_From_Bitmap_Data (f
, img
, data
,
3296 foreground
, background
,
3297 non_default_colors
);
3300 if (img
->pixmap
== NO_PIXMAP
)
3302 x_clear_image (f
, img
);
3303 image_error ("Unable to create X pixmap for `%s'", img
->spec
, Qnil
);
3309 image_error ("Error loading XBM image `%s'", img
->spec
, Qnil
);
3315 /* Value is non-zero if DATA looks like an in-memory XBM file. */
3322 return (STRINGP (data
)
3323 && xbm_read_bitmap_data (NULL
, SDATA (data
),
3330 /* Fill image IMG which is used on frame F with pixmap data. Value is
3331 non-zero if successful. */
3339 Lisp_Object file_name
;
3341 xassert (xbm_image_p (img
->spec
));
3343 /* If IMG->spec specifies a file name, create a non-file spec from it. */
3344 file_name
= image_spec_value (img
->spec
, QCfile
, NULL
);
3345 if (STRINGP (file_name
))
3348 unsigned char *contents
;
3350 struct gcpro gcpro1
;
3352 file
= x_find_image_file (file_name
);
3354 if (!STRINGP (file
))
3356 image_error ("Cannot find image file `%s'", file_name
, Qnil
);
3361 contents
= slurp_file (SDATA (file
), &size
);
3362 if (contents
== NULL
)
3364 image_error ("Error loading XBM image `%s'", img
->spec
, Qnil
);
3369 success_p
= xbm_load_image (f
, img
, contents
, contents
+ size
);
3374 struct image_keyword fmt
[XBM_LAST
];
3376 unsigned long foreground
= FRAME_FOREGROUND_PIXEL (f
);
3377 unsigned long background
= FRAME_BACKGROUND_PIXEL (f
);
3378 int non_default_colors
= 0;
3381 int in_memory_file_p
= 0;
3383 /* See if data looks like an in-memory XBM file. */
3384 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
3385 in_memory_file_p
= xbm_file_p (data
);
3387 /* Parse the image specification. */
3388 bcopy (xbm_format
, fmt
, sizeof fmt
);
3389 parsed_p
= parse_image_spec (img
->spec
, fmt
, XBM_LAST
, Qxbm
);
3392 /* Get specified width, and height. */
3393 if (!in_memory_file_p
)
3395 img
->width
= XFASTINT (fmt
[XBM_WIDTH
].value
);
3396 img
->height
= XFASTINT (fmt
[XBM_HEIGHT
].value
);
3397 xassert (img
->width
> 0 && img
->height
> 0);
3400 /* Get foreground and background colors, maybe allocate colors. */
3401 if (fmt
[XBM_FOREGROUND
].count
3402 && STRINGP (fmt
[XBM_FOREGROUND
].value
))
3404 foreground
= x_alloc_image_color (f
, img
, fmt
[XBM_FOREGROUND
].value
,
3406 non_default_colors
= 1;
3409 if (fmt
[XBM_BACKGROUND
].count
3410 && STRINGP (fmt
[XBM_BACKGROUND
].value
))
3412 background
= x_alloc_image_color (f
, img
, fmt
[XBM_BACKGROUND
].value
,
3414 non_default_colors
= 1;
3417 if (in_memory_file_p
)
3418 success_p
= xbm_load_image (f
, img
, SDATA (data
),
3427 int nbytes
= (img
->width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
;
3429 p
= bits
= (char *) alloca (nbytes
* img
->height
);
3430 for (i
= 0; i
< img
->height
; ++i
, p
+= nbytes
)
3432 Lisp_Object line
= XVECTOR (data
)->contents
[i
];
3434 bcopy (SDATA (line
), p
, nbytes
);
3436 bcopy (XBOOL_VECTOR (line
)->data
, p
, nbytes
);
3439 else if (STRINGP (data
))
3440 bits
= SDATA (data
);
3442 bits
= XBOOL_VECTOR (data
)->data
;
3444 /* Create the pixmap. */
3446 Create_Pixmap_From_Bitmap_Data (f
, img
, bits
,
3447 foreground
, background
,
3448 non_default_colors
);
3453 image_error ("Unable to create pixmap for XBM image `%s'",
3455 x_clear_image (f
, img
);
3465 /***********************************************************************
3467 ***********************************************************************/
3469 #if defined (HAVE_XPM) || defined (MAC_OS)
3471 static int xpm_image_p
P_ ((Lisp_Object object
));
3472 static int xpm_load
P_ ((struct frame
*f
, struct image
*img
));
3473 static int xpm_valid_color_symbols_p
P_ ((Lisp_Object
));
3475 #endif /* HAVE_XPM || MAC_OS */
3479 /* Indicate to xpm.h that we don't have Xlib. */
3481 /* simx.h in xpm defines XColor and XImage differently than Emacs. */
3482 /* It also defines Display the same way as Emacs, but gcc 3.3 still barfs. */
3483 #define XColor xpm_XColor
3484 #define XImage xpm_XImage
3485 #define Display xpm_Display
3486 #define PIXEL_ALREADY_TYPEDEFED
3487 #include "X11/xpm.h"
3492 #undef PIXEL_ALREADY_TYPEDEFED
3494 #include "X11/xpm.h"
3495 #endif /* HAVE_NTGUI */
3496 #endif /* HAVE_XPM */
3498 #if defined (HAVE_XPM) || defined (MAC_OS)
3499 /* The symbol `xpm' identifying XPM-format images. */
3503 /* Indices of image specification fields in xpm_format, below. */
3505 enum xpm_keyword_index
3521 /* Vector of image_keyword structures describing the format
3522 of valid XPM image specifications. */
3524 static struct image_keyword xpm_format
[XPM_LAST
] =
3526 {":type", IMAGE_SYMBOL_VALUE
, 1},
3527 {":file", IMAGE_STRING_VALUE
, 0},
3528 {":data", IMAGE_STRING_VALUE
, 0},
3529 {":ascent", IMAGE_ASCENT_VALUE
, 0},
3530 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
3531 {":relief", IMAGE_INTEGER_VALUE
, 0},
3532 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3533 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3534 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3535 {":color-symbols", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3536 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
3539 /* Structure describing the image type XPM. */
3541 static struct image_type xpm_type
=
3550 #ifdef HAVE_X_WINDOWS
3552 /* Define ALLOC_XPM_COLORS if we can use Emacs' own color allocation
3553 functions for allocating image colors. Our own functions handle
3554 color allocation failures more gracefully than the ones on the XPM
3557 #if defined XpmAllocColor && defined XpmFreeColors && defined XpmColorClosure
3558 #define ALLOC_XPM_COLORS
3560 #endif /* HAVE_X_WINDOWS */
3562 #ifdef ALLOC_XPM_COLORS
3564 static void xpm_init_color_cache
P_ ((struct frame
*, XpmAttributes
*));
3565 static void xpm_free_color_cache
P_ ((void));
3566 static int xpm_lookup_color
P_ ((struct frame
*, char *, XColor
*));
3567 static int xpm_color_bucket
P_ ((char *));
3568 static struct xpm_cached_color
*xpm_cache_color
P_ ((struct frame
*, char *,
3571 /* An entry in a hash table used to cache color definitions of named
3572 colors. This cache is necessary to speed up XPM image loading in
3573 case we do color allocations ourselves. Without it, we would need
3574 a call to XParseColor per pixel in the image. */
3576 struct xpm_cached_color
3578 /* Next in collision chain. */
3579 struct xpm_cached_color
*next
;
3581 /* Color definition (RGB and pixel color). */
3588 /* The hash table used for the color cache, and its bucket vector
3591 #define XPM_COLOR_CACHE_BUCKETS 1001
3592 struct xpm_cached_color
**xpm_color_cache
;
3594 /* Initialize the color cache. */
3597 xpm_init_color_cache (f
, attrs
)
3599 XpmAttributes
*attrs
;
3601 size_t nbytes
= XPM_COLOR_CACHE_BUCKETS
* sizeof *xpm_color_cache
;
3602 xpm_color_cache
= (struct xpm_cached_color
**) xmalloc (nbytes
);
3603 memset (xpm_color_cache
, 0, nbytes
);
3604 init_color_table ();
3606 if (attrs
->valuemask
& XpmColorSymbols
)
3611 for (i
= 0; i
< attrs
->numsymbols
; ++i
)
3612 if (XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
3613 attrs
->colorsymbols
[i
].value
, &color
))
3615 color
.pixel
= lookup_rgb_color (f
, color
.red
, color
.green
,
3617 xpm_cache_color (f
, attrs
->colorsymbols
[i
].name
, &color
, -1);
3622 /* Free the color cache. */
3625 xpm_free_color_cache ()
3627 struct xpm_cached_color
*p
, *next
;
3630 for (i
= 0; i
< XPM_COLOR_CACHE_BUCKETS
; ++i
)
3631 for (p
= xpm_color_cache
[i
]; p
; p
= next
)
3637 xfree (xpm_color_cache
);
3638 xpm_color_cache
= NULL
;
3639 free_color_table ();
3642 /* Return the bucket index for color named COLOR_NAME in the color
3646 xpm_color_bucket (color_name
)
3652 for (s
= color_name
; *s
; ++s
)
3654 return h
%= XPM_COLOR_CACHE_BUCKETS
;
3658 /* On frame F, cache values COLOR for color with name COLOR_NAME.
3659 BUCKET, if >= 0, is a precomputed bucket index. Value is the cache
3662 static struct xpm_cached_color
*
3663 xpm_cache_color (f
, color_name
, color
, bucket
)
3670 struct xpm_cached_color
*p
;
3673 bucket
= xpm_color_bucket (color_name
);
3675 nbytes
= sizeof *p
+ strlen (color_name
);
3676 p
= (struct xpm_cached_color
*) xmalloc (nbytes
);
3677 strcpy (p
->name
, color_name
);
3679 p
->next
= xpm_color_cache
[bucket
];
3680 xpm_color_cache
[bucket
] = p
;
3684 /* Look up color COLOR_NAME for frame F in the color cache. If found,
3685 return the cached definition in *COLOR. Otherwise, make a new
3686 entry in the cache and allocate the color. Value is zero if color
3687 allocation failed. */
3690 xpm_lookup_color (f
, color_name
, color
)
3695 struct xpm_cached_color
*p
;
3696 int h
= xpm_color_bucket (color_name
);
3698 for (p
= xpm_color_cache
[h
]; p
; p
= p
->next
)
3699 if (strcmp (p
->name
, color_name
) == 0)
3704 else if (XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
3707 color
->pixel
= lookup_rgb_color (f
, color
->red
, color
->green
,
3709 p
= xpm_cache_color (f
, color_name
, color
, h
);
3711 /* You get `opaque' at least from ImageMagick converting pbm to xpm
3712 with transparency, and it's useful. */
3713 else if (strcmp ("opaque", color_name
) == 0)
3715 bzero (color
, sizeof (XColor
)); /* Is this necessary/correct? */
3716 color
->pixel
= FRAME_FOREGROUND_PIXEL (f
);
3717 p
= xpm_cache_color (f
, color_name
, color
, h
);
3724 /* Callback for allocating color COLOR_NAME. Called from the XPM lib.
3725 CLOSURE is a pointer to the frame on which we allocate the
3726 color. Return in *COLOR the allocated color. Value is non-zero
3730 xpm_alloc_color (dpy
, cmap
, color_name
, color
, closure
)
3737 return xpm_lookup_color ((struct frame
*) closure
, color_name
, color
);
3741 /* Callback for freeing NPIXELS colors contained in PIXELS. CLOSURE
3742 is a pointer to the frame on which we allocate the color. Value is
3743 non-zero if successful. */
3746 xpm_free_colors (dpy
, cmap
, pixels
, npixels
, closure
)
3756 #endif /* ALLOC_XPM_COLORS */
3761 /* XPM library details. */
3763 DEF_IMGLIB_FN (XpmFreeAttributes
);
3764 DEF_IMGLIB_FN (XpmCreateImageFromBuffer
);
3765 DEF_IMGLIB_FN (XpmReadFileToImage
);
3766 DEF_IMGLIB_FN (XImageFree
);
3769 init_xpm_functions (Lisp_Object libraries
)
3773 if (!(library
= w32_delayed_load (libraries
, Qxpm
)))
3776 LOAD_IMGLIB_FN (library
, XpmFreeAttributes
);
3777 LOAD_IMGLIB_FN (library
, XpmCreateImageFromBuffer
);
3778 LOAD_IMGLIB_FN (library
, XpmReadFileToImage
);
3779 LOAD_IMGLIB_FN (library
, XImageFree
);
3783 #endif /* HAVE_NTGUI */
3786 /* Value is non-zero if COLOR_SYMBOLS is a valid color symbols list
3787 for XPM images. Such a list must consist of conses whose car and
3791 xpm_valid_color_symbols_p (color_symbols
)
3792 Lisp_Object color_symbols
;
3794 while (CONSP (color_symbols
))
3796 Lisp_Object sym
= XCAR (color_symbols
);
3798 || !STRINGP (XCAR (sym
))
3799 || !STRINGP (XCDR (sym
)))
3801 color_symbols
= XCDR (color_symbols
);
3804 return NILP (color_symbols
);
3808 /* Value is non-zero if OBJECT is a valid XPM image specification. */
3811 xpm_image_p (object
)
3814 struct image_keyword fmt
[XPM_LAST
];
3815 bcopy (xpm_format
, fmt
, sizeof fmt
);
3816 return (parse_image_spec (object
, fmt
, XPM_LAST
, Qxpm
)
3817 /* Either `:file' or `:data' must be present. */
3818 && fmt
[XPM_FILE
].count
+ fmt
[XPM_DATA
].count
== 1
3819 /* Either no `:color-symbols' or it's a list of conses
3820 whose car and cdr are strings. */
3821 && (fmt
[XPM_COLOR_SYMBOLS
].count
== 0
3822 || xpm_valid_color_symbols_p (fmt
[XPM_COLOR_SYMBOLS
].value
)));
3825 #endif /* HAVE_XPM || MAC_OS */
3827 #if defined (HAVE_XPM) && defined (HAVE_X_WINDOWS)
3829 x_create_bitmap_from_xpm_data (f
, bits
)
3833 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
3835 XpmAttributes attrs
;
3836 Pixmap bitmap
, mask
;
3838 bzero (&attrs
, sizeof attrs
);
3840 attrs
.visual
= FRAME_X_VISUAL (f
);
3841 attrs
.colormap
= FRAME_X_COLORMAP (f
);
3842 attrs
.valuemask
|= XpmVisual
;
3843 attrs
.valuemask
|= XpmColormap
;
3845 rc
= XpmCreatePixmapFromData (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3846 bits
, &bitmap
, &mask
, &attrs
);
3847 if (rc
!= XpmSuccess
)
3849 XpmFreeAttributes (&attrs
);
3853 id
= x_allocate_bitmap_record (f
);
3854 dpyinfo
->bitmaps
[id
- 1].pixmap
= bitmap
;
3855 dpyinfo
->bitmaps
[id
- 1].have_mask
= 1;
3856 dpyinfo
->bitmaps
[id
- 1].mask
= mask
;
3857 dpyinfo
->bitmaps
[id
- 1].file
= NULL
;
3858 dpyinfo
->bitmaps
[id
- 1].height
= attrs
.height
;
3859 dpyinfo
->bitmaps
[id
- 1].width
= attrs
.width
;
3860 dpyinfo
->bitmaps
[id
- 1].depth
= attrs
.depth
;
3861 dpyinfo
->bitmaps
[id
- 1].refcount
= 1;
3863 XpmFreeAttributes (&attrs
);
3866 #endif /* defined (HAVE_XPM) && defined (HAVE_X_WINDOWS) */
3868 /* Load image IMG which will be displayed on frame F. Value is
3869 non-zero if successful. */
3879 XpmAttributes attrs
;
3880 Lisp_Object specified_file
, color_symbols
;
3883 xpm_XImage
* xpm_image
= NULL
, * xpm_mask
= NULL
;
3884 #endif /* HAVE_NTGUI */
3886 /* Configure the XPM lib. Use the visual of frame F. Allocate
3887 close colors. Return colors allocated. */
3888 bzero (&attrs
, sizeof attrs
);
3891 attrs
.visual
= FRAME_X_VISUAL (f
);
3892 attrs
.colormap
= FRAME_X_COLORMAP (f
);
3893 attrs
.valuemask
|= XpmVisual
;
3894 attrs
.valuemask
|= XpmColormap
;
3895 #endif /* HAVE_NTGUI */
3897 #ifdef ALLOC_XPM_COLORS
3898 /* Allocate colors with our own functions which handle
3899 failing color allocation more gracefully. */
3900 attrs
.color_closure
= f
;
3901 attrs
.alloc_color
= xpm_alloc_color
;
3902 attrs
.free_colors
= xpm_free_colors
;
3903 attrs
.valuemask
|= XpmAllocColor
| XpmFreeColors
| XpmColorClosure
;
3904 #else /* not ALLOC_XPM_COLORS */
3905 /* Let the XPM lib allocate colors. */
3906 attrs
.valuemask
|= XpmReturnAllocPixels
;
3907 #ifdef XpmAllocCloseColors
3908 attrs
.alloc_close_colors
= 1;
3909 attrs
.valuemask
|= XpmAllocCloseColors
;
3910 #else /* not XpmAllocCloseColors */
3911 attrs
.closeness
= 600;
3912 attrs
.valuemask
|= XpmCloseness
;
3913 #endif /* not XpmAllocCloseColors */
3914 #endif /* ALLOC_XPM_COLORS */
3915 #ifdef ALLOC_XPM_COLORS
3916 xpm_init_color_cache (f
, &attrs
);
3919 /* If image specification contains symbolic color definitions, add
3920 these to `attrs'. */
3921 color_symbols
= image_spec_value (img
->spec
, QCcolor_symbols
, NULL
);
3922 if (CONSP (color_symbols
))
3925 XpmColorSymbol
*xpm_syms
;
3928 attrs
.valuemask
|= XpmColorSymbols
;
3930 /* Count number of symbols. */
3931 attrs
.numsymbols
= 0;
3932 for (tail
= color_symbols
; CONSP (tail
); tail
= XCDR (tail
))
3935 /* Allocate an XpmColorSymbol array. */
3936 size
= attrs
.numsymbols
* sizeof *xpm_syms
;
3937 xpm_syms
= (XpmColorSymbol
*) alloca (size
);
3938 bzero (xpm_syms
, size
);
3939 attrs
.colorsymbols
= xpm_syms
;
3941 /* Fill the color symbol array. */
3942 for (tail
= color_symbols
, i
= 0;
3944 ++i
, tail
= XCDR (tail
))
3946 Lisp_Object name
= XCAR (XCAR (tail
));
3947 Lisp_Object color
= XCDR (XCAR (tail
));
3948 xpm_syms
[i
].name
= (char *) alloca (SCHARS (name
) + 1);
3949 strcpy (xpm_syms
[i
].name
, SDATA (name
));
3950 xpm_syms
[i
].value
= (char *) alloca (SCHARS (color
) + 1);
3951 strcpy (xpm_syms
[i
].value
, SDATA (color
));
3955 /* Create a pixmap for the image, either from a file, or from a
3956 string buffer containing data in the same format as an XPM file. */
3957 #ifdef ALLOC_XPM_COLORS
3958 xpm_init_color_cache (f
, &attrs
);
3961 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
3965 HDC frame_dc
= get_frame_dc (f
);
3966 hdc
= CreateCompatibleDC (frame_dc
);
3967 release_frame_dc (f
, frame_dc
);
3969 #endif /* HAVE_NTGUI */
3971 if (STRINGP (specified_file
))
3973 Lisp_Object file
= x_find_image_file (specified_file
);
3974 if (!STRINGP (file
))
3976 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
3981 /* XpmReadFileToPixmap is not available in the Windows port of
3982 libxpm. But XpmReadFileToImage almost does what we want. */
3983 rc
= fn_XpmReadFileToImage (&hdc
, SDATA (file
),
3984 &xpm_image
, &xpm_mask
,
3987 rc
= XpmReadFileToPixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3988 SDATA (file
), &img
->pixmap
, &img
->mask
,
3990 #endif /* HAVE_NTGUI */
3994 Lisp_Object buffer
= image_spec_value (img
->spec
, QCdata
, NULL
);
3996 /* XpmCreatePixmapFromBuffer is not available in the Windows port
3997 of libxpm. But XpmCreateImageFromBuffer almost does what we want. */
3998 rc
= fn_XpmCreateImageFromBuffer (&hdc
, SDATA (buffer
),
3999 &xpm_image
, &xpm_mask
,
4002 rc
= XpmCreatePixmapFromBuffer (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
4004 &img
->pixmap
, &img
->mask
,
4006 #endif /* HAVE_NTGUI */
4009 if (rc
== XpmSuccess
)
4011 #if defined (COLOR_TABLE_SUPPORT) && defined (ALLOC_XPM_COLORS)
4012 img
->colors
= colors_in_color_table (&img
->ncolors
);
4013 #else /* not ALLOC_XPM_COLORS */
4017 /* W32 XPM uses XImage to wrap what W32 Emacs calls a Pixmap,
4018 plus some duplicate attributes. */
4019 if (xpm_image
&& xpm_image
->bitmap
)
4021 img
->pixmap
= xpm_image
->bitmap
;
4022 /* XImageFree in libXpm frees XImage struct without destroying
4023 the bitmap, which is what we want. */
4024 fn_XImageFree (xpm_image
);
4026 if (xpm_mask
&& xpm_mask
->bitmap
)
4028 /* The mask appears to be inverted compared with what we expect.
4029 TODO: invert our expectations. See other places where we
4030 have to invert bits because our idea of masks is backwards. */
4032 old_obj
= SelectObject (hdc
, xpm_mask
->bitmap
);
4034 PatBlt (hdc
, 0, 0, xpm_mask
->width
, xpm_mask
->height
, DSTINVERT
);
4035 SelectObject (hdc
, old_obj
);
4037 img
->mask
= xpm_mask
->bitmap
;
4038 fn_XImageFree (xpm_mask
);
4043 #endif /* HAVE_NTGUI */
4045 /* Remember allocated colors. */
4046 img
->ncolors
= attrs
.nalloc_pixels
;
4047 img
->colors
= (unsigned long *) xmalloc (img
->ncolors
4048 * sizeof *img
->colors
);
4049 for (i
= 0; i
< attrs
.nalloc_pixels
; ++i
)
4051 img
->colors
[i
] = attrs
.alloc_pixels
[i
];
4052 #ifdef DEBUG_X_COLORS
4053 register_color (img
->colors
[i
]);
4056 #endif /* not ALLOC_XPM_COLORS */
4058 img
->width
= attrs
.width
;
4059 img
->height
= attrs
.height
;
4060 xassert (img
->width
> 0 && img
->height
> 0);
4062 /* The call to XpmFreeAttributes below frees attrs.alloc_pixels. */
4064 fn_XpmFreeAttributes (&attrs
);
4066 XpmFreeAttributes (&attrs
);
4067 #endif /* HAVE_NTGUI */
4073 #endif /* HAVE_NTGUI */
4078 image_error ("Error opening XPM file (%s)", img
->spec
, Qnil
);
4081 case XpmFileInvalid
:
4082 image_error ("Invalid XPM file (%s)", img
->spec
, Qnil
);
4086 image_error ("Out of memory (%s)", img
->spec
, Qnil
);
4089 case XpmColorFailed
:
4090 image_error ("Color allocation error (%s)", img
->spec
, Qnil
);
4094 image_error ("Unknown error (%s)", img
->spec
, Qnil
);
4099 #ifdef ALLOC_XPM_COLORS
4100 xpm_free_color_cache ();
4102 return rc
== XpmSuccess
;
4105 #endif /* HAVE_XPM */
4109 /* XPM support functions for Mac OS where libxpm is not available.
4110 Only XPM version 3 (without any extensions) is supported. */
4112 static int xpm_scan
P_ ((const unsigned char **, const unsigned char *,
4113 const unsigned char **, int *));
4114 static Lisp_Object xpm_make_color_table_v
4115 P_ ((void (**) (Lisp_Object
, const unsigned char *, int, Lisp_Object
),
4116 Lisp_Object (**) (Lisp_Object
, const unsigned char *, int)));
4117 static void xpm_put_color_table_v
P_ ((Lisp_Object
, const unsigned char *,
4119 static Lisp_Object xpm_get_color_table_v
P_ ((Lisp_Object
,
4120 const unsigned char *, int));
4121 static Lisp_Object xpm_make_color_table_h
4122 P_ ((void (**) (Lisp_Object
, const unsigned char *, int, Lisp_Object
),
4123 Lisp_Object (**) (Lisp_Object
, const unsigned char *, int)));
4124 static void xpm_put_color_table_h
P_ ((Lisp_Object
, const unsigned char *,
4126 static Lisp_Object xpm_get_color_table_h
P_ ((Lisp_Object
,
4127 const unsigned char *, int));
4128 static int xpm_str_to_color_key
P_ ((const char *));
4129 static int xpm_load_image
P_ ((struct frame
*, struct image
*,
4130 const unsigned char *, const unsigned char *));
4132 /* Tokens returned from xpm_scan. */
4141 /* Scan an XPM data and return a character (< 256) or a token defined
4142 by enum xpm_token above. *S and END are the start (inclusive) and
4143 the end (exclusive) addresses of the data, respectively. Advance
4144 *S while scanning. If token is either XPM_TK_IDENT or
4145 XPM_TK_STRING, *BEG and *LEN are set to the start address and the
4146 length of the corresponding token, respectively. */
4149 xpm_scan (s
, end
, beg
, len
)
4150 const unsigned char **s
, *end
, **beg
;
4157 /* Skip white-space. */
4158 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
4161 /* gnus-pointer.xpm uses '-' in its identifier.
4162 sb-dir-plus.xpm uses '+' in its identifier. */
4163 if (isalpha (c
) || c
== '_' || c
== '-' || c
== '+')
4167 (c
= **s
, isalnum (c
) || c
== '_' || c
== '-' || c
== '+'))
4170 return XPM_TK_IDENT
;
4175 while (*s
< end
&& **s
!= '"')
4180 return XPM_TK_STRING
;
4184 if (*s
< end
&& **s
== '*')
4186 /* C-style comment. */
4190 while (*s
< end
&& *(*s
)++ != '*')
4193 while (*s
< end
&& **s
!= '/');
4207 /* Functions for color table lookup in XPM data. A Key is a string
4208 specifying the color of each pixel in XPM data. A value is either
4209 an integer that specifies a pixel color, Qt that specifies
4210 transparency, or Qnil for the unspecified color. If the length of
4211 the key string is one, a vector is used as a table. Otherwise, a
4212 hash table is used. */
4215 xpm_make_color_table_v (put_func
, get_func
)
4216 void (**put_func
) (Lisp_Object
, const unsigned char *, int, Lisp_Object
);
4217 Lisp_Object (**get_func
) (Lisp_Object
, const unsigned char *, int);
4219 *put_func
= xpm_put_color_table_v
;
4220 *get_func
= xpm_get_color_table_v
;
4221 return Fmake_vector (make_number (256), Qnil
);
4225 xpm_put_color_table_v (color_table
, chars_start
, chars_len
, color
)
4226 Lisp_Object color_table
;
4227 const unsigned char *chars_start
;
4231 XVECTOR (color_table
)->contents
[*chars_start
] = color
;
4235 xpm_get_color_table_v (color_table
, chars_start
, chars_len
)
4236 Lisp_Object color_table
;
4237 const unsigned char *chars_start
;
4240 return XVECTOR (color_table
)->contents
[*chars_start
];
4244 xpm_make_color_table_h (put_func
, get_func
)
4245 void (**put_func
) (Lisp_Object
, const unsigned char *, int, Lisp_Object
);
4246 Lisp_Object (**get_func
) (Lisp_Object
, const unsigned char *, int);
4248 *put_func
= xpm_put_color_table_h
;
4249 *get_func
= xpm_get_color_table_h
;
4250 return make_hash_table (Qequal
, make_number (DEFAULT_HASH_SIZE
),
4251 make_float (DEFAULT_REHASH_SIZE
),
4252 make_float (DEFAULT_REHASH_THRESHOLD
),
4257 xpm_put_color_table_h (color_table
, chars_start
, chars_len
, color
)
4258 Lisp_Object color_table
;
4259 const unsigned char *chars_start
;
4263 struct Lisp_Hash_Table
*table
= XHASH_TABLE (color_table
);
4265 Lisp_Object chars
= make_unibyte_string (chars_start
, chars_len
);
4267 hash_lookup (table
, chars
, &hash_code
);
4268 hash_put (table
, chars
, color
, hash_code
);
4272 xpm_get_color_table_h (color_table
, chars_start
, chars_len
)
4273 Lisp_Object color_table
;
4274 const unsigned char *chars_start
;
4277 struct Lisp_Hash_Table
*table
= XHASH_TABLE (color_table
);
4278 int i
= hash_lookup (table
, make_unibyte_string (chars_start
, chars_len
),
4281 return i
>= 0 ? HASH_VALUE (table
, i
) : Qnil
;
4284 enum xpm_color_key
{
4292 static const char xpm_color_key_strings
[][4] = {"s", "m", "g4", "g", "c"};
4295 xpm_str_to_color_key (s
)
4301 i
< sizeof xpm_color_key_strings
/ sizeof xpm_color_key_strings
[0];
4303 if (strcmp (xpm_color_key_strings
[i
], s
) == 0)
4309 xpm_load_image (f
, img
, contents
, end
)
4312 const unsigned char *contents
, *end
;
4314 const unsigned char *s
= contents
, *beg
, *str
;
4315 unsigned char buffer
[BUFSIZ
];
4316 int width
, height
, x
, y
;
4317 int num_colors
, chars_per_pixel
;
4319 void (*put_color_table
) (Lisp_Object
, const unsigned char *, int, Lisp_Object
);
4320 Lisp_Object (*get_color_table
) (Lisp_Object
, const unsigned char *, int);
4321 Lisp_Object frame
, color_symbols
, color_table
;
4322 int best_key
, have_mask
= 0;
4323 XImagePtr ximg
= NULL
, mask_img
= NULL
;
4326 LA1 = xpm_scan (&s, end, &beg, &len)
4328 #define expect(TOKEN) \
4329 if (LA1 != (TOKEN)) \
4334 #define expect_ident(IDENT) \
4335 if (LA1 == XPM_TK_IDENT \
4336 && strlen ((IDENT)) == len && memcmp ((IDENT), beg, len) == 0) \
4341 if (!(end
- s
>= 9 && memcmp (s
, "/* XPM */", 9) == 0))
4345 expect_ident ("static");
4346 expect_ident ("char");
4348 expect (XPM_TK_IDENT
);
4353 expect (XPM_TK_STRING
);
4356 memcpy (buffer
, beg
, len
);
4358 if (sscanf (buffer
, "%d %d %d %d", &width
, &height
,
4359 &num_colors
, &chars_per_pixel
) != 4
4360 || width
<= 0 || height
<= 0
4361 || num_colors
<= 0 || chars_per_pixel
<= 0)
4364 if (!check_image_size (f
, width
, height
))
4366 image_error ("Invalid image size", Qnil
, Qnil
);
4372 XSETFRAME (frame
, f
);
4373 if (!NILP (Fxw_display_color_p (frame
)))
4374 best_key
= XPM_COLOR_KEY_C
;
4375 else if (!NILP (Fx_display_grayscale_p (frame
)))
4376 best_key
= (XFASTINT (Fx_display_planes (frame
)) > 2
4377 ? XPM_COLOR_KEY_G
: XPM_COLOR_KEY_G4
);
4379 best_key
= XPM_COLOR_KEY_M
;
4381 color_symbols
= image_spec_value (img
->spec
, QCcolor_symbols
, NULL
);
4382 if (chars_per_pixel
== 1)
4383 color_table
= xpm_make_color_table_v (&put_color_table
,
4386 color_table
= xpm_make_color_table_h (&put_color_table
,
4389 while (num_colors
-- > 0)
4391 unsigned char *color
, *max_color
;
4392 int key
, next_key
, max_key
= 0;
4393 Lisp_Object symbol_color
= Qnil
, color_val
;
4396 expect (XPM_TK_STRING
);
4397 if (len
<= chars_per_pixel
|| len
>= BUFSIZ
+ chars_per_pixel
)
4399 memcpy (buffer
, beg
+ chars_per_pixel
, len
- chars_per_pixel
);
4400 buffer
[len
- chars_per_pixel
] = '\0';
4402 str
= strtok (buffer
, " \t");
4405 key
= xpm_str_to_color_key (str
);
4410 color
= strtok (NULL
, " \t");
4414 while ((str
= strtok (NULL
, " \t")) != NULL
)
4416 next_key
= xpm_str_to_color_key (str
);
4419 color
[strlen (color
)] = ' ';
4422 if (key
== XPM_COLOR_KEY_S
)
4424 if (NILP (symbol_color
))
4425 symbol_color
= build_string (color
);
4427 else if (max_key
< key
&& key
<= best_key
)
4437 if (!NILP (color_symbols
) && !NILP (symbol_color
))
4439 Lisp_Object specified_color
= Fassoc (symbol_color
, color_symbols
);
4441 if (CONSP (specified_color
) && STRINGP (XCDR (specified_color
)))
4443 if (xstricmp (SDATA (XCDR (specified_color
)), "None") == 0)
4445 else if (x_defined_color (f
, SDATA (XCDR (specified_color
)),
4447 color_val
= make_number (cdef
.pixel
);
4450 if (NILP (color_val
) && max_key
> 0)
4452 if (xstricmp (max_color
, "None") == 0)
4454 else if (x_defined_color (f
, max_color
, &cdef
, 0))
4455 color_val
= make_number (cdef
.pixel
);
4457 if (!NILP (color_val
))
4458 (*put_color_table
) (color_table
, beg
, chars_per_pixel
, color_val
);
4463 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0,
4464 &ximg
, &img
->pixmap
)
4465 || !x_create_x_image_and_pixmap (f
, width
, height
, 1,
4466 &mask_img
, &img
->mask
))
4468 image_error ("Out of memory (%s)", img
->spec
, Qnil
);
4472 for (y
= 0; y
< height
; y
++)
4474 expect (XPM_TK_STRING
);
4476 if (len
< width
* chars_per_pixel
)
4478 for (x
= 0; x
< width
; x
++, str
+= chars_per_pixel
)
4480 Lisp_Object color_val
=
4481 (*get_color_table
) (color_table
, str
, chars_per_pixel
);
4483 XPutPixel (ximg
, x
, y
,
4484 (INTEGERP (color_val
) ? XINT (color_val
)
4485 : FRAME_FOREGROUND_PIXEL (f
)));
4486 XPutPixel (mask_img
, x
, y
,
4487 (!EQ (color_val
, Qt
) ? PIX_MASK_DRAW
4488 : (have_mask
= 1, PIX_MASK_RETAIN
)));
4495 img
->height
= height
;
4497 /* Maybe fill in the background field while we have ximg handy. */
4498 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
4499 IMAGE_BACKGROUND (img
, f
, ximg
);
4501 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
4502 x_destroy_x_image (ximg
);
4505 /* Fill in the background_transparent field while we have the
4507 image_background_transparent (img
, f
, mask_img
);
4509 x_put_x_image (f
, mask_img
, img
->mask
, width
, height
);
4510 x_destroy_x_image (mask_img
);
4514 x_destroy_x_image (mask_img
);
4515 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
4516 img
->mask
= NO_PIXMAP
;
4522 image_error ("Invalid XPM file (%s)", img
->spec
, Qnil
);
4524 x_destroy_x_image (ximg
);
4525 x_destroy_x_image (mask_img
);
4526 x_clear_image (f
, img
);
4540 Lisp_Object file_name
;
4542 /* If IMG->spec specifies a file name, create a non-file spec from it. */
4543 file_name
= image_spec_value (img
->spec
, QCfile
, NULL
);
4544 if (STRINGP (file_name
))
4547 unsigned char *contents
;
4549 struct gcpro gcpro1
;
4551 file
= x_find_image_file (file_name
);
4553 if (!STRINGP (file
))
4555 image_error ("Cannot find image file `%s'", file_name
, Qnil
);
4560 contents
= slurp_file (SDATA (file
), &size
);
4561 if (contents
== NULL
)
4563 image_error ("Error loading XPM image `%s'", img
->spec
, Qnil
);
4568 success_p
= xpm_load_image (f
, img
, contents
, contents
+ size
);
4576 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
4577 success_p
= xpm_load_image (f
, img
, SDATA (data
),
4578 SDATA (data
) + SBYTES (data
));
4588 /***********************************************************************
4590 ***********************************************************************/
4592 #ifdef COLOR_TABLE_SUPPORT
4594 /* An entry in the color table mapping an RGB color to a pixel color. */
4599 unsigned long pixel
;
4601 /* Next in color table collision list. */
4602 struct ct_color
*next
;
4605 /* The bucket vector size to use. Must be prime. */
4609 /* Value is a hash of the RGB color given by R, G, and B. */
4611 #define CT_HASH_RGB(R, G, B) (((R) << 16) ^ ((G) << 8) ^ (B))
4613 /* The color hash table. */
4615 struct ct_color
**ct_table
;
4617 /* Number of entries in the color table. */
4619 int ct_colors_allocated
;
4621 /* Initialize the color table. */
4626 int size
= CT_SIZE
* sizeof (*ct_table
);
4627 ct_table
= (struct ct_color
**) xmalloc (size
);
4628 bzero (ct_table
, size
);
4629 ct_colors_allocated
= 0;
4633 /* Free memory associated with the color table. */
4639 struct ct_color
*p
, *next
;
4641 for (i
= 0; i
< CT_SIZE
; ++i
)
4642 for (p
= ct_table
[i
]; p
; p
= next
)
4653 /* Value is a pixel color for RGB color R, G, B on frame F. If an
4654 entry for that color already is in the color table, return the
4655 pixel color of that entry. Otherwise, allocate a new color for R,
4656 G, B, and make an entry in the color table. */
4658 static unsigned long
4659 lookup_rgb_color (f
, r
, g
, b
)
4663 unsigned hash
= CT_HASH_RGB (r
, g
, b
);
4664 int i
= hash
% CT_SIZE
;
4666 Display_Info
*dpyinfo
;
4668 /* Handle TrueColor visuals specially, which improves performance by
4669 two orders of magnitude. Freeing colors on TrueColor visuals is
4670 a nop, and pixel colors specify RGB values directly. See also
4671 the Xlib spec, chapter 3.1. */
4672 dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
4673 if (dpyinfo
->red_bits
> 0)
4675 unsigned long pr
, pg
, pb
;
4677 /* Apply gamma-correction like normal color allocation does. */
4681 color
.red
= r
, color
.green
= g
, color
.blue
= b
;
4682 gamma_correct (f
, &color
);
4683 r
= color
.red
, g
= color
.green
, b
= color
.blue
;
4686 /* Scale down RGB values to the visual's bits per RGB, and shift
4687 them to the right position in the pixel color. Note that the
4688 original RGB values are 16-bit values, as usual in X. */
4689 pr
= (r
>> (16 - dpyinfo
->red_bits
)) << dpyinfo
->red_offset
;
4690 pg
= (g
>> (16 - dpyinfo
->green_bits
)) << dpyinfo
->green_offset
;
4691 pb
= (b
>> (16 - dpyinfo
->blue_bits
)) << dpyinfo
->blue_offset
;
4693 /* Assemble the pixel color. */
4694 return pr
| pg
| pb
;
4697 for (p
= ct_table
[i
]; p
; p
= p
->next
)
4698 if (p
->r
== r
&& p
->g
== g
&& p
->b
== b
)
4704 #ifdef HAVE_X_WINDOWS
4713 cmap
= FRAME_X_COLORMAP (f
);
4714 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
4717 ++ct_colors_allocated
;
4718 p
= (struct ct_color
*) xmalloc (sizeof *p
);
4722 p
->pixel
= color
.pixel
;
4723 p
->next
= ct_table
[i
];
4727 return FRAME_FOREGROUND_PIXEL (f
);
4732 color
= PALETTERGB (r
, g
, b
);
4734 color
= RGB_TO_ULONG (r
, g
, b
);
4735 #endif /* HAVE_NTGUI */
4736 ++ct_colors_allocated
;
4737 p
= (struct ct_color
*) xmalloc (sizeof *p
);
4742 p
->next
= ct_table
[i
];
4744 #endif /* HAVE_X_WINDOWS */
4752 /* Look up pixel color PIXEL which is used on frame F in the color
4753 table. If not already present, allocate it. Value is PIXEL. */
4755 static unsigned long
4756 lookup_pixel_color (f
, pixel
)
4758 unsigned long pixel
;
4760 int i
= pixel
% CT_SIZE
;
4763 for (p
= ct_table
[i
]; p
; p
= p
->next
)
4764 if (p
->pixel
== pixel
)
4773 #ifdef HAVE_X_WINDOWS
4774 cmap
= FRAME_X_COLORMAP (f
);
4775 color
.pixel
= pixel
;
4776 x_query_color (f
, &color
);
4777 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
4780 cmap
= DefaultColormapOfScreen (FRAME_X_SCREEN (f
));
4781 color
.pixel
= pixel
;
4782 XQueryColor (NULL
, cmap
, &color
);
4783 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
4785 #endif /* HAVE_X_WINDOWS */
4789 ++ct_colors_allocated
;
4791 p
= (struct ct_color
*) xmalloc (sizeof *p
);
4796 p
->next
= ct_table
[i
];
4800 return FRAME_FOREGROUND_PIXEL (f
);
4806 /* Value is a vector of all pixel colors contained in the color table,
4807 allocated via xmalloc. Set *N to the number of colors. */
4809 static unsigned long *
4810 colors_in_color_table (n
)
4815 unsigned long *colors
;
4817 if (ct_colors_allocated
== 0)
4824 colors
= (unsigned long *) xmalloc (ct_colors_allocated
4826 *n
= ct_colors_allocated
;
4828 for (i
= j
= 0; i
< CT_SIZE
; ++i
)
4829 for (p
= ct_table
[i
]; p
; p
= p
->next
)
4830 colors
[j
++] = p
->pixel
;
4836 #else /* COLOR_TABLE_SUPPORT */
4838 static unsigned long
4839 lookup_rgb_color (f
, r
, g
, b
)
4843 unsigned long pixel
;
4846 pixel
= RGB_TO_ULONG (r
>> 8, g
>> 8, b
>> 8);
4847 gamma_correct (f
, &pixel
);
4851 pixel
= PALETTERGB (r
>> 8, g
>> 8, b
>> 8);
4852 #endif /* HAVE_NTGUI */
4861 #endif /* COLOR_TABLE_SUPPORT */
4864 /***********************************************************************
4866 ***********************************************************************/
4868 static XColor
*x_to_xcolors
P_ ((struct frame
*, struct image
*, int));
4869 static void x_from_xcolors
P_ ((struct frame
*, struct image
*, XColor
*));
4870 static void x_detect_edges
P_ ((struct frame
*, struct image
*, int[9], int));
4873 static void XPutPixel (XImagePtr
, int, int, COLORREF
);
4874 #endif /* HAVE_NTGUI */
4876 /* Non-zero means draw a cross on images having `:conversion
4879 int cross_disabled_images
;
4881 /* Edge detection matrices for different edge-detection
4884 static int emboss_matrix
[9] = {
4886 2, -1, 0, /* y - 1 */
4888 0, 1, -2 /* y + 1 */
4891 static int laplace_matrix
[9] = {
4893 1, 0, 0, /* y - 1 */
4895 0, 0, -1 /* y + 1 */
4898 /* Value is the intensity of the color whose red/green/blue values
4901 #define COLOR_INTENSITY(R, G, B) ((2 * (R) + 3 * (G) + (B)) / 6)
4904 /* On frame F, return an array of XColor structures describing image
4905 IMG->pixmap. Each XColor structure has its pixel color set. RGB_P
4906 non-zero means also fill the red/green/blue members of the XColor
4907 structures. Value is a pointer to the array of XColors structures,
4908 allocated with xmalloc; it must be freed by the caller. */
4911 x_to_xcolors (f
, img
, rgb_p
)
4918 XImagePtr_or_DC ximg
;
4922 #endif /* HAVE_NTGUI */
4924 colors
= (XColor
*) xmalloc (img
->width
* img
->height
* sizeof *colors
);
4927 /* Get the X image IMG->pixmap. */
4928 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
4929 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
4931 /* Load the image into a memory device context. */
4932 hdc
= get_frame_dc (f
);
4933 ximg
= CreateCompatibleDC (hdc
);
4934 release_frame_dc (f
, hdc
);
4935 prev
= SelectObject (ximg
, img
->pixmap
);
4936 #endif /* HAVE_NTGUI */
4938 /* Fill the `pixel' members of the XColor array. I wished there
4939 were an easy and portable way to circumvent XGetPixel. */
4941 for (y
= 0; y
< img
->height
; ++y
)
4945 #ifdef HAVE_X_WINDOWS
4946 for (x
= 0; x
< img
->width
; ++x
, ++p
)
4947 p
->pixel
= XGetPixel (ximg
, x
, y
);
4949 x_query_colors (f
, row
, img
->width
);
4953 for (x
= 0; x
< img
->width
; ++x
, ++p
)
4955 /* W32_TODO: palette support needed here? */
4956 p
->pixel
= GET_PIXEL (ximg
, x
, y
);
4960 p
->red
= RED16_FROM_ULONG (p
->pixel
);
4961 p
->green
= GREEN16_FROM_ULONG (p
->pixel
);
4962 p
->blue
= BLUE16_FROM_ULONG (p
->pixel
);
4965 p
->red
= 256 * GetRValue (p
->pixel
);
4966 p
->green
= 256 * GetGValue (p
->pixel
);
4967 p
->blue
= 256 * GetBValue (p
->pixel
);
4968 #endif /* HAVE_NTGUI */
4971 #endif /* HAVE_X_WINDOWS */
4974 Destroy_Image (ximg
, prev
);
4981 /* Put a pixel of COLOR at position X, Y in XIMG. XIMG must have been
4982 created with CreateDIBSection, with the pointer to the bit values
4983 stored in ximg->data. */
4985 static void XPutPixel (ximg
, x
, y
, color
)
4990 int width
= ximg
->info
.bmiHeader
.biWidth
;
4991 int height
= ximg
->info
.bmiHeader
.biHeight
;
4992 unsigned char * pixel
;
4994 /* True color images. */
4995 if (ximg
->info
.bmiHeader
.biBitCount
== 24)
4997 int rowbytes
= width
* 3;
4998 /* Ensure scanlines are aligned on 4 byte boundaries. */
5000 rowbytes
+= 4 - (rowbytes
% 4);
5002 pixel
= ximg
->data
+ y
* rowbytes
+ x
* 3;
5003 /* Windows bitmaps are in BGR order. */
5004 *pixel
= GetBValue (color
);
5005 *(pixel
+ 1) = GetGValue (color
);
5006 *(pixel
+ 2) = GetRValue (color
);
5008 /* Monochrome images. */
5009 else if (ximg
->info
.bmiHeader
.biBitCount
== 1)
5011 int rowbytes
= width
/ 8;
5012 /* Ensure scanlines are aligned on 4 byte boundaries. */
5014 rowbytes
+= 4 - (rowbytes
% 4);
5015 pixel
= ximg
->data
+ y
* rowbytes
+ x
/ 8;
5016 /* Filter out palette info. */
5017 if (color
& 0x00ffffff)
5018 *pixel
= *pixel
| (1 << x
% 8);
5020 *pixel
= *pixel
& ~(1 << x
% 8);
5023 image_error ("XPutPixel: palette image not supported", Qnil
, Qnil
);
5026 #endif /* HAVE_NTGUI */
5028 /* Create IMG->pixmap from an array COLORS of XColor structures, whose
5029 RGB members are set. F is the frame on which this all happens.
5030 COLORS will be freed; an existing IMG->pixmap will be freed, too. */
5033 x_from_xcolors (f
, img
, colors
)
5043 init_color_table ();
5045 x_create_x_image_and_pixmap (f
, img
->width
, img
->height
, 0,
5048 for (y
= 0; y
< img
->height
; ++y
)
5049 for (x
= 0; x
< img
->width
; ++x
, ++p
)
5051 unsigned long pixel
;
5052 pixel
= lookup_rgb_color (f
, p
->red
, p
->green
, p
->blue
);
5053 XPutPixel (oimg
, x
, y
, pixel
);
5057 x_clear_image_1 (f
, img
, 1, 0, 1);
5059 x_put_x_image (f
, oimg
, pixmap
, img
->width
, img
->height
);
5060 x_destroy_x_image (oimg
);
5061 img
->pixmap
= pixmap
;
5062 #ifdef COLOR_TABLE_SUPPORT
5063 img
->colors
= colors_in_color_table (&img
->ncolors
);
5064 free_color_table ();
5065 #endif /* COLOR_TABLE_SUPPORT */
5069 /* On frame F, perform edge-detection on image IMG.
5071 MATRIX is a nine-element array specifying the transformation
5072 matrix. See emboss_matrix for an example.
5074 COLOR_ADJUST is a color adjustment added to each pixel of the
5078 x_detect_edges (f
, img
, matrix
, color_adjust
)
5081 int matrix
[9], color_adjust
;
5083 XColor
*colors
= x_to_xcolors (f
, img
, 1);
5087 for (i
= sum
= 0; i
< 9; ++i
)
5088 sum
+= abs (matrix
[i
]);
5090 #define COLOR(A, X, Y) ((A) + (Y) * img->width + (X))
5092 new = (XColor
*) xmalloc (img
->width
* img
->height
* sizeof *new);
5094 for (y
= 0; y
< img
->height
; ++y
)
5096 p
= COLOR (new, 0, y
);
5097 p
->red
= p
->green
= p
->blue
= 0xffff/2;
5098 p
= COLOR (new, img
->width
- 1, y
);
5099 p
->red
= p
->green
= p
->blue
= 0xffff/2;
5102 for (x
= 1; x
< img
->width
- 1; ++x
)
5104 p
= COLOR (new, x
, 0);
5105 p
->red
= p
->green
= p
->blue
= 0xffff/2;
5106 p
= COLOR (new, x
, img
->height
- 1);
5107 p
->red
= p
->green
= p
->blue
= 0xffff/2;
5110 for (y
= 1; y
< img
->height
- 1; ++y
)
5112 p
= COLOR (new, 1, y
);
5114 for (x
= 1; x
< img
->width
- 1; ++x
, ++p
)
5116 int r
, g
, b
, y1
, x1
;
5119 for (y1
= y
- 1; y1
< y
+ 2; ++y1
)
5120 for (x1
= x
- 1; x1
< x
+ 2; ++x1
, ++i
)
5123 XColor
*t
= COLOR (colors
, x1
, y1
);
5124 r
+= matrix
[i
] * t
->red
;
5125 g
+= matrix
[i
] * t
->green
;
5126 b
+= matrix
[i
] * t
->blue
;
5129 r
= (r
/ sum
+ color_adjust
) & 0xffff;
5130 g
= (g
/ sum
+ color_adjust
) & 0xffff;
5131 b
= (b
/ sum
+ color_adjust
) & 0xffff;
5132 p
->red
= p
->green
= p
->blue
= COLOR_INTENSITY (r
, g
, b
);
5137 x_from_xcolors (f
, img
, new);
5143 /* Perform the pre-defined `emboss' edge-detection on image IMG
5151 x_detect_edges (f
, img
, emboss_matrix
, 0xffff / 2);
5155 /* Transform image IMG which is used on frame F with a Laplace
5156 edge-detection algorithm. The result is an image that can be used
5157 to draw disabled buttons, for example. */
5164 x_detect_edges (f
, img
, laplace_matrix
, 45000);
5168 /* Perform edge-detection on image IMG on frame F, with specified
5169 transformation matrix MATRIX and color-adjustment COLOR_ADJUST.
5171 MATRIX must be either
5173 - a list of at least 9 numbers in row-major form
5174 - a vector of at least 9 numbers
5176 COLOR_ADJUST nil means use a default; otherwise it must be a
5180 x_edge_detection (f
, img
, matrix
, color_adjust
)
5183 Lisp_Object matrix
, color_adjust
;
5191 i
< 9 && CONSP (matrix
) && NUMBERP (XCAR (matrix
));
5192 ++i
, matrix
= XCDR (matrix
))
5193 trans
[i
] = XFLOATINT (XCAR (matrix
));
5195 else if (VECTORP (matrix
) && ASIZE (matrix
) >= 9)
5197 for (i
= 0; i
< 9 && NUMBERP (AREF (matrix
, i
)); ++i
)
5198 trans
[i
] = XFLOATINT (AREF (matrix
, i
));
5201 if (NILP (color_adjust
))
5202 color_adjust
= make_number (0xffff / 2);
5204 if (i
== 9 && NUMBERP (color_adjust
))
5205 x_detect_edges (f
, img
, trans
, (int) XFLOATINT (color_adjust
));
5209 /* Transform image IMG on frame F so that it looks disabled. */
5212 x_disable_image (f
, img
)
5216 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
5218 int n_planes
= dpyinfo
->n_planes
* dpyinfo
->n_cbits
;
5220 int n_planes
= dpyinfo
->n_planes
;
5221 #endif /* HAVE_NTGUI */
5225 /* Color (or grayscale). Convert to gray, and equalize. Just
5226 drawing such images with a stipple can look very odd, so
5227 we're using this method instead. */
5228 XColor
*colors
= x_to_xcolors (f
, img
, 1);
5230 const int h
= 15000;
5231 const int l
= 30000;
5233 for (p
= colors
, end
= colors
+ img
->width
* img
->height
;
5237 int i
= COLOR_INTENSITY (p
->red
, p
->green
, p
->blue
);
5238 int i2
= (0xffff - h
- l
) * i
/ 0xffff + l
;
5239 p
->red
= p
->green
= p
->blue
= i2
;
5242 x_from_xcolors (f
, img
, colors
);
5245 /* Draw a cross over the disabled image, if we must or if we
5247 if (n_planes
< 2 || cross_disabled_images
)
5250 Display
*dpy
= FRAME_X_DISPLAY (f
);
5254 #define MaskForeground(f) PIX_MASK_DRAW
5256 #define MaskForeground(f) WHITE_PIX_DEFAULT (f)
5259 gc
= XCreateGC (dpy
, img
->pixmap
, 0, NULL
);
5260 XSetForeground (dpy
, gc
, BLACK_PIX_DEFAULT (f
));
5261 XDrawLine (dpy
, img
->pixmap
, gc
, 0, 0,
5262 img
->width
- 1, img
->height
- 1);
5263 XDrawLine (dpy
, img
->pixmap
, gc
, 0, img
->height
- 1,
5269 gc
= XCreateGC (dpy
, img
->mask
, 0, NULL
);
5270 XSetForeground (dpy
, gc
, MaskForeground (f
));
5271 XDrawLine (dpy
, img
->mask
, gc
, 0, 0,
5272 img
->width
- 1, img
->height
- 1);
5273 XDrawLine (dpy
, img
->mask
, gc
, 0, img
->height
- 1,
5281 hdc
= get_frame_dc (f
);
5282 bmpdc
= CreateCompatibleDC (hdc
);
5283 release_frame_dc (f
, hdc
);
5285 prev
= SelectObject (bmpdc
, img
->pixmap
);
5287 SetTextColor (bmpdc
, BLACK_PIX_DEFAULT (f
));
5288 MoveToEx (bmpdc
, 0, 0, NULL
);
5289 LineTo (bmpdc
, img
->width
- 1, img
->height
- 1);
5290 MoveToEx (bmpdc
, 0, img
->height
- 1, NULL
);
5291 LineTo (bmpdc
, img
->width
- 1, 0);
5295 SelectObject (bmpdc
, img
->mask
);
5296 SetTextColor (bmpdc
, WHITE_PIX_DEFAULT (f
));
5297 MoveToEx (bmpdc
, 0, 0, NULL
);
5298 LineTo (bmpdc
, img
->width
- 1, img
->height
- 1);
5299 MoveToEx (bmpdc
, 0, img
->height
- 1, NULL
);
5300 LineTo (bmpdc
, img
->width
- 1, 0);
5302 SelectObject (bmpdc
, prev
);
5304 #endif /* HAVE_NTGUI */
5309 /* Build a mask for image IMG which is used on frame F. FILE is the
5310 name of an image file, for error messages. HOW determines how to
5311 determine the background color of IMG. If it is a list '(R G B)',
5312 with R, G, and B being integers >= 0, take that as the color of the
5313 background. Otherwise, determine the background color of IMG
5314 heuristically. Value is non-zero if successful. */
5317 x_build_heuristic_mask (f
, img
, how
)
5322 XImagePtr_or_DC ximg
;
5330 #endif /* HAVE_NTGUI */
5331 int x
, y
, rc
, use_img_background
;
5332 unsigned long bg
= 0;
5336 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
5337 img
->mask
= NO_PIXMAP
;
5338 img
->background_transparent_valid
= 0;
5342 /* Create an image and pixmap serving as mask. */
5343 rc
= x_create_x_image_and_pixmap (f
, img
->width
, img
->height
, 1,
5344 &mask_img
, &img
->mask
);
5348 /* Get the X image of IMG->pixmap. */
5349 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
, 0, 0,
5350 img
->width
, img
->height
,
5353 /* Create the bit array serving as mask. */
5354 row_width
= (img
->width
+ 7) / 8;
5355 mask_img
= xmalloc (row_width
* img
->height
);
5356 bzero (mask_img
, row_width
* img
->height
);
5358 /* Create a memory device context for IMG->pixmap. */
5359 frame_dc
= get_frame_dc (f
);
5360 ximg
= CreateCompatibleDC (frame_dc
);
5361 release_frame_dc (f
, frame_dc
);
5362 prev
= SelectObject (ximg
, img
->pixmap
);
5363 #endif /* HAVE_NTGUI */
5365 /* Determine the background color of ximg. If HOW is `(R G B)'
5366 take that as color. Otherwise, use the image's background color. */
5367 use_img_background
= 1;
5373 for (i
= 0; i
< 3 && CONSP (how
) && NATNUMP (XCAR (how
)); ++i
)
5375 rgb
[i
] = XFASTINT (XCAR (how
)) & 0xffff;
5379 if (i
== 3 && NILP (how
))
5381 char color_name
[30];
5382 sprintf (color_name
, "#%04x%04x%04x", rgb
[0], rgb
[1], rgb
[2]);
5385 0x00ffffff & /* Filter out palette info. */
5386 #endif /* HAVE_NTGUI */
5387 x_alloc_image_color (f
, img
, build_string (color_name
), 0));
5388 use_img_background
= 0;
5392 if (use_img_background
)
5393 bg
= four_corners_best (ximg
, img
->corners
, img
->width
, img
->height
);
5395 /* Set all bits in mask_img to 1 whose color in ximg is different
5396 from the background color bg. */
5398 for (y
= 0; y
< img
->height
; ++y
)
5399 for (x
= 0; x
< img
->width
; ++x
)
5400 XPutPixel (mask_img
, x
, y
, (XGetPixel (ximg
, x
, y
) != bg
5401 ? PIX_MASK_DRAW
: PIX_MASK_RETAIN
));
5403 /* Fill in the background_transparent field while we have the mask handy. */
5404 image_background_transparent (img
, f
, mask_img
);
5406 /* Put mask_img into img->mask. */
5407 x_put_x_image (f
, mask_img
, img
->mask
, img
->width
, img
->height
);
5408 x_destroy_x_image (mask_img
);
5411 for (y
= 0; y
< img
->height
; ++y
)
5412 for (x
= 0; x
< img
->width
; ++x
)
5414 COLORREF p
= GetPixel (ximg
, x
, y
);
5416 mask_img
[y
* row_width
+ x
/ 8] |= 1 << (x
% 8);
5419 /* Create the mask image. */
5420 img
->mask
= w32_create_pixmap_from_bitmap_data (img
->width
, img
->height
,
5422 /* Fill in the background_transparent field while we have the mask handy. */
5423 SelectObject (ximg
, img
->mask
);
5424 image_background_transparent (img
, f
, ximg
);
5426 /* Was: x_destroy_x_image ((XImagePtr )mask_img); which seems bogus ++kfs */
5428 #endif /* HAVE_NTGUI */
5430 Destroy_Image (ximg
, prev
);
5436 /***********************************************************************
5437 PBM (mono, gray, color)
5438 ***********************************************************************/
5440 static int pbm_image_p
P_ ((Lisp_Object object
));
5441 static int pbm_load
P_ ((struct frame
*f
, struct image
*img
));
5442 static int pbm_scan_number
P_ ((unsigned char **, unsigned char *));
5444 /* The symbol `pbm' identifying images of this type. */
5448 /* Indices of image specification fields in gs_format, below. */
5450 enum pbm_keyword_index
5466 /* Vector of image_keyword structures describing the format
5467 of valid user-defined image specifications. */
5469 static struct image_keyword pbm_format
[PBM_LAST
] =
5471 {":type", IMAGE_SYMBOL_VALUE
, 1},
5472 {":file", IMAGE_STRING_VALUE
, 0},
5473 {":data", IMAGE_STRING_VALUE
, 0},
5474 {":ascent", IMAGE_ASCENT_VALUE
, 0},
5475 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
5476 {":relief", IMAGE_INTEGER_VALUE
, 0},
5477 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5478 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5479 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5480 {":foreground", IMAGE_STRING_OR_NIL_VALUE
, 0},
5481 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
5484 /* Structure describing the image type `pbm'. */
5486 static struct image_type pbm_type
=
5496 /* Return non-zero if OBJECT is a valid PBM image specification. */
5499 pbm_image_p (object
)
5502 struct image_keyword fmt
[PBM_LAST
];
5504 bcopy (pbm_format
, fmt
, sizeof fmt
);
5506 if (!parse_image_spec (object
, fmt
, PBM_LAST
, Qpbm
))
5509 /* Must specify either :data or :file. */
5510 return fmt
[PBM_DATA
].count
+ fmt
[PBM_FILE
].count
== 1;
5514 /* Scan a decimal number from *S and return it. Advance *S while
5515 reading the number. END is the end of the string. Value is -1 at
5519 pbm_scan_number (s
, end
)
5520 unsigned char **s
, *end
;
5522 int c
= 0, val
= -1;
5526 /* Skip white-space. */
5527 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
5532 /* Skip comment to end of line. */
5533 while (*s
< end
&& (c
= *(*s
)++, c
!= '\n'))
5536 else if (isdigit (c
))
5538 /* Read decimal number. */
5540 while (*s
< end
&& (c
= *(*s
)++, isdigit (c
)))
5541 val
= 10 * val
+ c
- '0';
5553 #if 0 /* Unused. ++kfs */
5555 /* Read FILE into memory. Value is a pointer to a buffer allocated
5556 with xmalloc holding FILE's contents. Value is null if an error
5557 occurred. *SIZE is set to the size of the file. */
5560 pbm_read_file (file
, size
)
5568 if (stat (SDATA (file
), &st
) == 0
5569 && (fp
= fopen (SDATA (file
), "rb")) != NULL
5570 && (buf
= (char *) xmalloc (st
.st_size
),
5571 fread (buf
, 1, st
.st_size
, fp
) == st
.st_size
))
5590 #endif /* HAVE_NTGUI */
5592 /* Load PBM image IMG for use on frame F. */
5600 int width
, height
, max_color_idx
= 0;
5602 Lisp_Object file
, specified_file
;
5603 enum {PBM_MONO
, PBM_GRAY
, PBM_COLOR
} type
;
5604 struct gcpro gcpro1
;
5605 unsigned char *contents
= NULL
;
5606 unsigned char *end
, *p
;
5609 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
5613 if (STRINGP (specified_file
))
5615 file
= x_find_image_file (specified_file
);
5616 if (!STRINGP (file
))
5618 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
5623 contents
= slurp_file (SDATA (file
), &size
);
5624 if (contents
== NULL
)
5626 image_error ("Error reading `%s'", file
, Qnil
);
5632 end
= contents
+ size
;
5637 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
5639 end
= p
+ SBYTES (data
);
5642 /* Check magic number. */
5643 if (end
- p
< 2 || *p
++ != 'P')
5645 image_error ("Not a PBM image: `%s'", img
->spec
, Qnil
);
5655 raw_p
= 0, type
= PBM_MONO
;
5659 raw_p
= 0, type
= PBM_GRAY
;
5663 raw_p
= 0, type
= PBM_COLOR
;
5667 raw_p
= 1, type
= PBM_MONO
;
5671 raw_p
= 1, type
= PBM_GRAY
;
5675 raw_p
= 1, type
= PBM_COLOR
;
5679 image_error ("Not a PBM image: `%s'", img
->spec
, Qnil
);
5683 /* Read width, height, maximum color-component. Characters
5684 starting with `#' up to the end of a line are ignored. */
5685 width
= pbm_scan_number (&p
, end
);
5686 height
= pbm_scan_number (&p
, end
);
5688 if (type
!= PBM_MONO
)
5690 max_color_idx
= pbm_scan_number (&p
, end
);
5691 if (raw_p
&& max_color_idx
> 255)
5692 max_color_idx
= 255;
5695 if (!check_image_size (f
, width
, height
)
5696 || (type
!= PBM_MONO
&& max_color_idx
< 0))
5699 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0,
5700 &ximg
, &img
->pixmap
))
5703 /* Initialize the color hash table. */
5704 init_color_table ();
5706 if (type
== PBM_MONO
)
5709 struct image_keyword fmt
[PBM_LAST
];
5710 unsigned long fg
= FRAME_FOREGROUND_PIXEL (f
);
5711 unsigned long bg
= FRAME_BACKGROUND_PIXEL (f
);
5713 /* Parse the image specification. */
5714 bcopy (pbm_format
, fmt
, sizeof fmt
);
5715 parse_image_spec (img
->spec
, fmt
, PBM_LAST
, Qpbm
);
5717 /* Get foreground and background colors, maybe allocate colors. */
5718 if (fmt
[PBM_FOREGROUND
].count
5719 && STRINGP (fmt
[PBM_FOREGROUND
].value
))
5720 fg
= x_alloc_image_color (f
, img
, fmt
[PBM_FOREGROUND
].value
, fg
);
5721 if (fmt
[PBM_BACKGROUND
].count
5722 && STRINGP (fmt
[PBM_BACKGROUND
].value
))
5724 bg
= x_alloc_image_color (f
, img
, fmt
[PBM_BACKGROUND
].value
, bg
);
5725 img
->background
= bg
;
5726 img
->background_valid
= 1;
5729 for (y
= 0; y
< height
; ++y
)
5730 for (x
= 0; x
< width
; ++x
)
5738 x_destroy_x_image (ximg
);
5739 x_clear_image (f
, img
);
5740 image_error ("Invalid image size in image `%s'",
5750 g
= pbm_scan_number (&p
, end
);
5752 XPutPixel (ximg
, x
, y
, g
? fg
: bg
);
5758 && ((type
== PBM_GRAY
)
5759 ? (p
+ height
* width
> end
)
5760 : (p
+ 3 * height
* width
> end
)))
5762 x_destroy_x_image (ximg
);
5763 x_clear_image (f
, img
);
5764 image_error ("Invalid image size in image `%s'",
5769 for (y
= 0; y
< height
; ++y
)
5770 for (x
= 0; x
< width
; ++x
)
5774 if (type
== PBM_GRAY
)
5775 r
= g
= b
= raw_p
? *p
++ : pbm_scan_number (&p
, end
);
5784 r
= pbm_scan_number (&p
, end
);
5785 g
= pbm_scan_number (&p
, end
);
5786 b
= pbm_scan_number (&p
, end
);
5789 if (r
< 0 || g
< 0 || b
< 0)
5791 x_destroy_x_image (ximg
);
5792 image_error ("Invalid pixel value in image `%s'",
5797 /* RGB values are now in the range 0..max_color_idx.
5798 Scale this to the range 0..0xffff supported by X. */
5799 r
= (double) r
* 65535 / max_color_idx
;
5800 g
= (double) g
* 65535 / max_color_idx
;
5801 b
= (double) b
* 65535 / max_color_idx
;
5802 XPutPixel (ximg
, x
, y
, lookup_rgb_color (f
, r
, g
, b
));
5806 #ifdef COLOR_TABLE_SUPPORT
5807 /* Store in IMG->colors the colors allocated for the image, and
5808 free the color table. */
5809 img
->colors
= colors_in_color_table (&img
->ncolors
);
5810 free_color_table ();
5811 #endif /* COLOR_TABLE_SUPPORT */
5814 img
->height
= height
;
5816 /* Maybe fill in the background field while we have ximg handy. */
5818 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
5819 /* Casting avoids a GCC warning. */
5820 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
5822 /* Put the image into a pixmap. */
5823 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
5824 x_destroy_x_image (ximg
);
5826 /* X and W32 versions did it here, MAC version above. ++kfs
5828 img->height = height; */
5836 /***********************************************************************
5838 ***********************************************************************/
5840 #if defined (HAVE_PNG) || defined (MAC_OS)
5842 /* Function prototypes. */
5844 static int png_image_p
P_ ((Lisp_Object object
));
5845 static int png_load
P_ ((struct frame
*f
, struct image
*img
));
5847 /* The symbol `png' identifying images of this type. */
5851 /* Indices of image specification fields in png_format, below. */
5853 enum png_keyword_index
5868 /* Vector of image_keyword structures describing the format
5869 of valid user-defined image specifications. */
5871 static struct image_keyword png_format
[PNG_LAST
] =
5873 {":type", IMAGE_SYMBOL_VALUE
, 1},
5874 {":data", IMAGE_STRING_VALUE
, 0},
5875 {":file", IMAGE_STRING_VALUE
, 0},
5876 {":ascent", IMAGE_ASCENT_VALUE
, 0},
5877 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
5878 {":relief", IMAGE_INTEGER_VALUE
, 0},
5879 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5880 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5881 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5882 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
5885 /* Structure describing the image type `png'. */
5887 static struct image_type png_type
=
5896 /* Return non-zero if OBJECT is a valid PNG image specification. */
5899 png_image_p (object
)
5902 struct image_keyword fmt
[PNG_LAST
];
5903 bcopy (png_format
, fmt
, sizeof fmt
);
5905 if (!parse_image_spec (object
, fmt
, PNG_LAST
, Qpng
))
5908 /* Must specify either the :data or :file keyword. */
5909 return fmt
[PNG_FILE
].count
+ fmt
[PNG_DATA
].count
== 1;
5912 #endif /* HAVE_PNG || MAC_OS */
5917 #if defined HAVE_LIBPNG_PNG_H
5918 # include <libpng/png.h>
5924 /* PNG library details. */
5926 DEF_IMGLIB_FN (png_get_io_ptr
);
5927 DEF_IMGLIB_FN (png_check_sig
);
5928 DEF_IMGLIB_FN (png_create_read_struct
);
5929 DEF_IMGLIB_FN (png_create_info_struct
);
5930 DEF_IMGLIB_FN (png_destroy_read_struct
);
5931 DEF_IMGLIB_FN (png_set_read_fn
);
5932 DEF_IMGLIB_FN (png_set_sig_bytes
);
5933 DEF_IMGLIB_FN (png_read_info
);
5934 DEF_IMGLIB_FN (png_get_IHDR
);
5935 DEF_IMGLIB_FN (png_get_valid
);
5936 DEF_IMGLIB_FN (png_set_strip_16
);
5937 DEF_IMGLIB_FN (png_set_expand
);
5938 DEF_IMGLIB_FN (png_set_gray_to_rgb
);
5939 DEF_IMGLIB_FN (png_set_background
);
5940 DEF_IMGLIB_FN (png_get_bKGD
);
5941 DEF_IMGLIB_FN (png_read_update_info
);
5942 DEF_IMGLIB_FN (png_get_channels
);
5943 DEF_IMGLIB_FN (png_get_rowbytes
);
5944 DEF_IMGLIB_FN (png_read_image
);
5945 DEF_IMGLIB_FN (png_read_end
);
5946 DEF_IMGLIB_FN (png_error
);
5949 init_png_functions (Lisp_Object libraries
)
5953 /* Try loading libpng under probable names. */
5954 if (!(library
= w32_delayed_load (libraries
, Qpng
)))
5957 LOAD_IMGLIB_FN (library
, png_get_io_ptr
);
5958 LOAD_IMGLIB_FN (library
, png_check_sig
);
5959 LOAD_IMGLIB_FN (library
, png_create_read_struct
);
5960 LOAD_IMGLIB_FN (library
, png_create_info_struct
);
5961 LOAD_IMGLIB_FN (library
, png_destroy_read_struct
);
5962 LOAD_IMGLIB_FN (library
, png_set_read_fn
);
5963 LOAD_IMGLIB_FN (library
, png_set_sig_bytes
);
5964 LOAD_IMGLIB_FN (library
, png_read_info
);
5965 LOAD_IMGLIB_FN (library
, png_get_IHDR
);
5966 LOAD_IMGLIB_FN (library
, png_get_valid
);
5967 LOAD_IMGLIB_FN (library
, png_set_strip_16
);
5968 LOAD_IMGLIB_FN (library
, png_set_expand
);
5969 LOAD_IMGLIB_FN (library
, png_set_gray_to_rgb
);
5970 LOAD_IMGLIB_FN (library
, png_set_background
);
5971 LOAD_IMGLIB_FN (library
, png_get_bKGD
);
5972 LOAD_IMGLIB_FN (library
, png_read_update_info
);
5973 LOAD_IMGLIB_FN (library
, png_get_channels
);
5974 LOAD_IMGLIB_FN (library
, png_get_rowbytes
);
5975 LOAD_IMGLIB_FN (library
, png_read_image
);
5976 LOAD_IMGLIB_FN (library
, png_read_end
);
5977 LOAD_IMGLIB_FN (library
, png_error
);
5982 #define fn_png_get_io_ptr png_get_io_ptr
5983 #define fn_png_check_sig png_check_sig
5984 #define fn_png_create_read_struct png_create_read_struct
5985 #define fn_png_create_info_struct png_create_info_struct
5986 #define fn_png_destroy_read_struct png_destroy_read_struct
5987 #define fn_png_set_read_fn png_set_read_fn
5988 #define fn_png_set_sig_bytes png_set_sig_bytes
5989 #define fn_png_read_info png_read_info
5990 #define fn_png_get_IHDR png_get_IHDR
5991 #define fn_png_get_valid png_get_valid
5992 #define fn_png_set_strip_16 png_set_strip_16
5993 #define fn_png_set_expand png_set_expand
5994 #define fn_png_set_gray_to_rgb png_set_gray_to_rgb
5995 #define fn_png_set_background png_set_background
5996 #define fn_png_get_bKGD png_get_bKGD
5997 #define fn_png_read_update_info png_read_update_info
5998 #define fn_png_get_channels png_get_channels
5999 #define fn_png_get_rowbytes png_get_rowbytes
6000 #define fn_png_read_image png_read_image
6001 #define fn_png_read_end png_read_end
6002 #define fn_png_error png_error
6004 #endif /* HAVE_NTGUI */
6006 /* Error and warning handlers installed when the PNG library
6010 my_png_error (png_ptr
, msg
)
6011 png_struct
*png_ptr
;
6014 xassert (png_ptr
!= NULL
);
6015 image_error ("PNG error: %s", build_string (msg
), Qnil
);
6016 longjmp (png_ptr
->jmpbuf
, 1);
6021 my_png_warning (png_ptr
, msg
)
6022 png_struct
*png_ptr
;
6025 xassert (png_ptr
!= NULL
);
6026 image_error ("PNG warning: %s", build_string (msg
), Qnil
);
6029 /* Memory source for PNG decoding. */
6031 struct png_memory_storage
6033 unsigned char *bytes
; /* The data */
6034 size_t len
; /* How big is it? */
6035 int index
; /* Where are we? */
6039 /* Function set as reader function when reading PNG image from memory.
6040 PNG_PTR is a pointer to the PNG control structure. Copy LENGTH
6041 bytes from the input to DATA. */
6044 png_read_from_memory (png_ptr
, data
, length
)
6045 png_structp png_ptr
;
6049 struct png_memory_storage
*tbr
6050 = (struct png_memory_storage
*) fn_png_get_io_ptr (png_ptr
);
6052 if (length
> tbr
->len
- tbr
->index
)
6053 fn_png_error (png_ptr
, "Read error");
6055 bcopy (tbr
->bytes
+ tbr
->index
, data
, length
);
6056 tbr
->index
= tbr
->index
+ length
;
6060 /* Function set as reader function when reading PNG image from a file.
6061 PNG_PTR is a pointer to the PNG control structure. Copy LENGTH
6062 bytes from the input to DATA. */
6065 png_read_from_file (png_ptr
, data
, length
)
6066 png_structp png_ptr
;
6070 FILE *fp
= (FILE *) fn_png_get_io_ptr (png_ptr
);
6072 if (fread (data
, 1, length
, fp
) < length
)
6073 fn_png_error (png_ptr
, "Read error");
6077 /* Load PNG image IMG for use on frame F. Value is non-zero if
6085 Lisp_Object file
, specified_file
;
6086 Lisp_Object specified_data
;
6088 XImagePtr ximg
, mask_img
= NULL
;
6089 struct gcpro gcpro1
;
6090 png_struct
*png_ptr
= NULL
;
6091 png_info
*info_ptr
= NULL
, *end_info
= NULL
;
6092 FILE *volatile fp
= NULL
;
6094 png_byte
* volatile pixels
= NULL
;
6095 png_byte
** volatile rows
= NULL
;
6096 png_uint_32 width
, height
;
6097 int bit_depth
, color_type
, interlace_type
;
6099 png_uint_32 row_bytes
;
6101 double screen_gamma
;
6102 struct png_memory_storage tbr
; /* Data to be read */
6104 /* Find out what file to load. */
6105 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
6106 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
6110 if (NILP (specified_data
))
6112 file
= x_find_image_file (specified_file
);
6113 if (!STRINGP (file
))
6115 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
6120 /* Open the image file. */
6121 fp
= fopen (SDATA (file
), "rb");
6124 image_error ("Cannot open image file `%s'", file
, Qnil
);
6129 /* Check PNG signature. */
6130 if (fread (sig
, 1, sizeof sig
, fp
) != sizeof sig
6131 || !fn_png_check_sig (sig
, sizeof sig
))
6133 image_error ("Not a PNG file: `%s'", file
, Qnil
);
6141 /* Read from memory. */
6142 tbr
.bytes
= SDATA (specified_data
);
6143 tbr
.len
= SBYTES (specified_data
);
6146 /* Check PNG signature. */
6147 if (tbr
.len
< sizeof sig
6148 || !fn_png_check_sig (tbr
.bytes
, sizeof sig
))
6150 image_error ("Not a PNG image: `%s'", img
->spec
, Qnil
);
6155 /* Need to skip past the signature. */
6156 tbr
.bytes
+= sizeof (sig
);
6159 /* Initialize read and info structs for PNG lib. Casting return
6160 value avoids a GCC warning on W32. */
6161 png_ptr
= (png_structp
)fn_png_create_read_struct (PNG_LIBPNG_VER_STRING
,
6166 if (fp
) fclose (fp
);
6171 /* Casting return value avoids a GCC warning on W32. */
6172 info_ptr
= (png_infop
)fn_png_create_info_struct (png_ptr
);
6175 fn_png_destroy_read_struct (&png_ptr
, NULL
, NULL
);
6176 if (fp
) fclose (fp
);
6181 /* Casting return value avoids a GCC warning on W32. */
6182 end_info
= (png_infop
)fn_png_create_info_struct (png_ptr
);
6185 fn_png_destroy_read_struct (&png_ptr
, &info_ptr
, NULL
);
6186 if (fp
) fclose (fp
);
6191 /* Set error jump-back. We come back here when the PNG library
6192 detects an error. */
6193 if (setjmp (png_ptr
->jmpbuf
))
6197 fn_png_destroy_read_struct (&png_ptr
, &info_ptr
, &end_info
);
6200 if (fp
) fclose (fp
);
6205 /* Read image info. */
6206 if (!NILP (specified_data
))
6207 fn_png_set_read_fn (png_ptr
, (void *) &tbr
, png_read_from_memory
);
6209 fn_png_set_read_fn (png_ptr
, (void *) fp
, png_read_from_file
);
6211 fn_png_set_sig_bytes (png_ptr
, sizeof sig
);
6212 fn_png_read_info (png_ptr
, info_ptr
);
6213 fn_png_get_IHDR (png_ptr
, info_ptr
, &width
, &height
, &bit_depth
, &color_type
,
6214 &interlace_type
, NULL
, NULL
);
6216 if (!check_image_size (f
, width
, height
))
6219 /* If image contains simply transparency data, we prefer to
6220 construct a clipping mask. */
6221 if (fn_png_get_valid (png_ptr
, info_ptr
, PNG_INFO_tRNS
))
6226 /* This function is easier to write if we only have to handle
6227 one data format: RGB or RGBA with 8 bits per channel. Let's
6228 transform other formats into that format. */
6230 /* Strip more than 8 bits per channel. */
6231 if (bit_depth
== 16)
6232 fn_png_set_strip_16 (png_ptr
);
6234 /* Expand data to 24 bit RGB, or 8 bit grayscale, with alpha channel
6236 fn_png_set_expand (png_ptr
);
6238 /* Convert grayscale images to RGB. */
6239 if (color_type
== PNG_COLOR_TYPE_GRAY
6240 || color_type
== PNG_COLOR_TYPE_GRAY_ALPHA
)
6241 fn_png_set_gray_to_rgb (png_ptr
);
6243 screen_gamma
= (f
->gamma
? 1 / f
->gamma
/ 0.45455 : 2.2);
6245 #if 0 /* Avoid double gamma correction for PNG images. */
6246 { /* Tell the PNG lib to handle gamma correction for us. */
6249 #if defined(PNG_READ_sRGB_SUPPORTED) || defined(PNG_WRITE_sRGB_SUPPORTED)
6250 if (png_get_sRGB (png_ptr
, info_ptr
, &intent
))
6251 /* The libpng documentation says this is right in this case. */
6252 png_set_gamma (png_ptr
, screen_gamma
, 0.45455);
6255 if (png_get_gAMA (png_ptr
, info_ptr
, &image_gamma
))
6256 /* Image contains gamma information. */
6257 png_set_gamma (png_ptr
, screen_gamma
, image_gamma
);
6259 /* Use the standard default for the image gamma. */
6260 png_set_gamma (png_ptr
, screen_gamma
, 0.45455);
6264 /* Handle alpha channel by combining the image with a background
6265 color. Do this only if a real alpha channel is supplied. For
6266 simple transparency, we prefer a clipping mask. */
6269 png_color_16
*image_bg
;
6270 Lisp_Object specified_bg
6271 = image_spec_value (img
->spec
, QCbackground
, NULL
);
6273 if (STRINGP (specified_bg
))
6274 /* The user specified `:background', use that. */
6276 /* W32 version incorrectly used COLORREF here!! ++kfs */
6278 if (x_defined_color (f
, SDATA (specified_bg
), &color
, 0))
6280 png_color_16 user_bg
;
6282 bzero (&user_bg
, sizeof user_bg
);
6283 user_bg
.red
= color
.red
>> 8;
6284 user_bg
.green
= color
.green
>> 8;
6285 user_bg
.blue
= color
.blue
>> 8;
6287 fn_png_set_background (png_ptr
, &user_bg
,
6288 PNG_BACKGROUND_GAMMA_SCREEN
, 0, 1.0);
6291 else if (fn_png_get_bKGD (png_ptr
, info_ptr
, &image_bg
))
6292 /* Image contains a background color with which to
6293 combine the image. */
6294 fn_png_set_background (png_ptr
, image_bg
,
6295 PNG_BACKGROUND_GAMMA_FILE
, 1, 1.0);
6298 /* Image does not contain a background color with which
6299 to combine the image data via an alpha channel. Use
6300 the frame's background instead. */
6301 #ifdef HAVE_X_WINDOWS
6303 png_color_16 frame_background
;
6305 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
6306 x_query_color (f
, &color
);
6308 bzero (&frame_background
, sizeof frame_background
);
6309 frame_background
.red
= color
.red
>> 8;
6310 frame_background
.green
= color
.green
>> 8;
6311 frame_background
.blue
= color
.blue
>> 8;
6312 #endif /* HAVE_X_WINDOWS */
6316 png_color_16 frame_background
;
6317 color
= FRAME_BACKGROUND_PIXEL (f
);
6318 #if 0 /* W32 TODO : Colormap support. */
6319 x_query_color (f
, &color
);
6321 bzero (&frame_background
, sizeof frame_background
);
6322 frame_background
.red
= GetRValue (color
);
6323 frame_background
.green
= GetGValue (color
);
6324 frame_background
.blue
= GetBValue (color
);
6325 #endif /* HAVE_NTGUI */
6328 unsigned long color
;
6329 png_color_16 frame_background
;
6330 color
= FRAME_BACKGROUND_PIXEL (f
);
6331 #if 0 /* MAC/W32 TODO : Colormap support. */
6332 x_query_color (f
, &color
);
6334 bzero (&frame_background
, sizeof frame_background
);
6335 frame_background
.red
= RED_FROM_ULONG (color
);
6336 frame_background
.green
= GREEN_FROM_ULONG (color
);
6337 frame_background
.blue
= BLUE_FROM_ULONG (color
);
6340 fn_png_set_background (png_ptr
, &frame_background
,
6341 PNG_BACKGROUND_GAMMA_SCREEN
, 0, 1.0);
6345 /* Update info structure. */
6346 fn_png_read_update_info (png_ptr
, info_ptr
);
6348 /* Get number of channels. Valid values are 1 for grayscale images
6349 and images with a palette, 2 for grayscale images with transparency
6350 information (alpha channel), 3 for RGB images, and 4 for RGB
6351 images with alpha channel, i.e. RGBA. If conversions above were
6352 sufficient we should only have 3 or 4 channels here. */
6353 channels
= fn_png_get_channels (png_ptr
, info_ptr
);
6354 xassert (channels
== 3 || channels
== 4);
6356 /* Number of bytes needed for one row of the image. */
6357 row_bytes
= fn_png_get_rowbytes (png_ptr
, info_ptr
);
6359 /* Allocate memory for the image. */
6360 pixels
= (png_byte
*) xmalloc (row_bytes
* height
* sizeof *pixels
);
6361 rows
= (png_byte
**) xmalloc (height
* sizeof *rows
);
6362 for (i
= 0; i
< height
; ++i
)
6363 rows
[i
] = pixels
+ i
* row_bytes
;
6365 /* Read the entire image. */
6366 fn_png_read_image (png_ptr
, rows
);
6367 fn_png_read_end (png_ptr
, info_ptr
);
6374 /* Create the X image and pixmap. */
6375 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
,
6379 /* Create an image and pixmap serving as mask if the PNG image
6380 contains an alpha channel. */
6383 && !x_create_x_image_and_pixmap (f
, width
, height
, 1,
6384 &mask_img
, &img
->mask
))
6386 x_destroy_x_image (ximg
);
6387 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->pixmap
);
6388 img
->pixmap
= NO_PIXMAP
;
6392 /* Fill the X image and mask from PNG data. */
6393 init_color_table ();
6395 for (y
= 0; y
< height
; ++y
)
6397 png_byte
*p
= rows
[y
];
6399 for (x
= 0; x
< width
; ++x
)
6406 XPutPixel (ximg
, x
, y
, lookup_rgb_color (f
, r
, g
, b
));
6407 /* An alpha channel, aka mask channel, associates variable
6408 transparency with an image. Where other image formats
6409 support binary transparency---fully transparent or fully
6410 opaque---PNG allows up to 254 levels of partial transparency.
6411 The PNG library implements partial transparency by combining
6412 the image with a specified background color.
6414 I'm not sure how to handle this here nicely: because the
6415 background on which the image is displayed may change, for
6416 real alpha channel support, it would be necessary to create
6417 a new image for each possible background.
6419 What I'm doing now is that a mask is created if we have
6420 boolean transparency information. Otherwise I'm using
6421 the frame's background color to combine the image with. */
6426 XPutPixel (mask_img
, x
, y
, *p
> 0 ? PIX_MASK_DRAW
: PIX_MASK_RETAIN
);
6432 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
6433 /* Set IMG's background color from the PNG image, unless the user
6437 if (fn_png_get_bKGD (png_ptr
, info_ptr
, &bg
))
6439 img
->background
= lookup_rgb_color (f
, bg
->red
, bg
->green
, bg
->blue
);
6440 img
->background_valid
= 1;
6444 #ifdef COLOR_TABLE_SUPPORT
6445 /* Remember colors allocated for this image. */
6446 img
->colors
= colors_in_color_table (&img
->ncolors
);
6447 free_color_table ();
6448 #endif /* COLOR_TABLE_SUPPORT */
6451 fn_png_destroy_read_struct (&png_ptr
, &info_ptr
, &end_info
);
6456 img
->height
= height
;
6458 /* Maybe fill in the background field while we have ximg handy.
6459 Casting avoids a GCC warning. */
6460 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
6462 /* Put the image into the pixmap, then free the X image and its buffer. */
6463 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
6464 x_destroy_x_image (ximg
);
6466 /* Same for the mask. */
6469 /* Fill in the background_transparent field while we have the
6470 mask handy. Casting avoids a GCC warning. */
6471 image_background_transparent (img
, f
, (XImagePtr_or_DC
)mask_img
);
6473 x_put_x_image (f
, mask_img
, img
->mask
, img
->width
, img
->height
);
6474 x_destroy_x_image (mask_img
);
6481 #else /* HAVE_PNG */
6490 if (MyCGImageCreateWithPNGDataProvider
)
6491 return image_load_quartz2d (f
, img
, 1);
6494 return image_load_quicktime (f
, img
, kQTFileTypePNG
);
6498 #endif /* !HAVE_PNG */
6502 /***********************************************************************
6504 ***********************************************************************/
6506 #if defined (HAVE_JPEG) || defined (MAC_OS)
6508 static int jpeg_image_p
P_ ((Lisp_Object object
));
6509 static int jpeg_load
P_ ((struct frame
*f
, struct image
*img
));
6511 /* The symbol `jpeg' identifying images of this type. */
6515 /* Indices of image specification fields in gs_format, below. */
6517 enum jpeg_keyword_index
6526 JPEG_HEURISTIC_MASK
,
6532 /* Vector of image_keyword structures describing the format
6533 of valid user-defined image specifications. */
6535 static struct image_keyword jpeg_format
[JPEG_LAST
] =
6537 {":type", IMAGE_SYMBOL_VALUE
, 1},
6538 {":data", IMAGE_STRING_VALUE
, 0},
6539 {":file", IMAGE_STRING_VALUE
, 0},
6540 {":ascent", IMAGE_ASCENT_VALUE
, 0},
6541 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
6542 {":relief", IMAGE_INTEGER_VALUE
, 0},
6543 {":conversions", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6544 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6545 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6546 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
6549 /* Structure describing the image type `jpeg'. */
6551 static struct image_type jpeg_type
=
6560 /* Return non-zero if OBJECT is a valid JPEG image specification. */
6563 jpeg_image_p (object
)
6566 struct image_keyword fmt
[JPEG_LAST
];
6568 bcopy (jpeg_format
, fmt
, sizeof fmt
);
6570 if (!parse_image_spec (object
, fmt
, JPEG_LAST
, Qjpeg
))
6573 /* Must specify either the :data or :file keyword. */
6574 return fmt
[JPEG_FILE
].count
+ fmt
[JPEG_DATA
].count
== 1;
6577 #endif /* HAVE_JPEG || MAC_OS */
6581 /* Work around a warning about HAVE_STDLIB_H being redefined in
6583 #ifdef HAVE_STDLIB_H
6584 #define HAVE_STDLIB_H_1
6585 #undef HAVE_STDLIB_H
6586 #endif /* HAVE_STLIB_H */
6588 #if defined (HAVE_NTGUI) && !defined (__WIN32__)
6589 /* In older releases of the jpeg library, jpeglib.h will define boolean
6590 differently depending on __WIN32__, so make sure it is defined. */
6594 #include <jpeglib.h>
6598 #ifdef HAVE_STLIB_H_1
6599 #define HAVE_STDLIB_H 1
6604 /* JPEG library details. */
6605 DEF_IMGLIB_FN (jpeg_CreateDecompress
);
6606 DEF_IMGLIB_FN (jpeg_start_decompress
);
6607 DEF_IMGLIB_FN (jpeg_finish_decompress
);
6608 DEF_IMGLIB_FN (jpeg_destroy_decompress
);
6609 DEF_IMGLIB_FN (jpeg_read_header
);
6610 DEF_IMGLIB_FN (jpeg_read_scanlines
);
6611 DEF_IMGLIB_FN (jpeg_std_error
);
6612 DEF_IMGLIB_FN (jpeg_resync_to_restart
);
6615 init_jpeg_functions (Lisp_Object libraries
)
6619 if (!(library
= w32_delayed_load (libraries
, Qjpeg
)))
6622 LOAD_IMGLIB_FN (library
, jpeg_finish_decompress
);
6623 LOAD_IMGLIB_FN (library
, jpeg_read_scanlines
);
6624 LOAD_IMGLIB_FN (library
, jpeg_start_decompress
);
6625 LOAD_IMGLIB_FN (library
, jpeg_read_header
);
6626 LOAD_IMGLIB_FN (library
, jpeg_CreateDecompress
);
6627 LOAD_IMGLIB_FN (library
, jpeg_destroy_decompress
);
6628 LOAD_IMGLIB_FN (library
, jpeg_std_error
);
6629 LOAD_IMGLIB_FN (library
, jpeg_resync_to_restart
);
6633 /* Wrapper since we can't directly assign the function pointer
6634 to another function pointer that was declared more completely easily. */
6636 jpeg_resync_to_restart_wrapper(cinfo
, desired
)
6637 j_decompress_ptr cinfo
;
6640 return fn_jpeg_resync_to_restart (cinfo
, desired
);
6645 #define fn_jpeg_CreateDecompress(a,b,c) jpeg_create_decompress(a)
6646 #define fn_jpeg_start_decompress jpeg_start_decompress
6647 #define fn_jpeg_finish_decompress jpeg_finish_decompress
6648 #define fn_jpeg_destroy_decompress jpeg_destroy_decompress
6649 #define fn_jpeg_read_header jpeg_read_header
6650 #define fn_jpeg_read_scanlines jpeg_read_scanlines
6651 #define fn_jpeg_std_error jpeg_std_error
6652 #define jpeg_resync_to_restart_wrapper jpeg_resync_to_restart
6654 #endif /* HAVE_NTGUI */
6656 struct my_jpeg_error_mgr
6658 struct jpeg_error_mgr pub
;
6659 jmp_buf setjmp_buffer
;
6664 my_error_exit (cinfo
)
6667 struct my_jpeg_error_mgr
*mgr
= (struct my_jpeg_error_mgr
*) cinfo
->err
;
6668 longjmp (mgr
->setjmp_buffer
, 1);
6672 /* Init source method for JPEG data source manager. Called by
6673 jpeg_read_header() before any data is actually read. See
6674 libjpeg.doc from the JPEG lib distribution. */
6677 our_common_init_source (cinfo
)
6678 j_decompress_ptr cinfo
;
6683 /* Method to terminate data source. Called by
6684 jpeg_finish_decompress() after all data has been processed. */
6687 our_common_term_source (cinfo
)
6688 j_decompress_ptr cinfo
;
6693 /* Fill input buffer method for JPEG data source manager. Called
6694 whenever more data is needed. We read the whole image in one step,
6695 so this only adds a fake end of input marker at the end. */
6698 our_memory_fill_input_buffer (cinfo
)
6699 j_decompress_ptr cinfo
;
6701 /* Insert a fake EOI marker. */
6702 struct jpeg_source_mgr
*src
= cinfo
->src
;
6703 static JOCTET buffer
[2];
6705 buffer
[0] = (JOCTET
) 0xFF;
6706 buffer
[1] = (JOCTET
) JPEG_EOI
;
6708 src
->next_input_byte
= buffer
;
6709 src
->bytes_in_buffer
= 2;
6714 /* Method to skip over NUM_BYTES bytes in the image data. CINFO->src
6715 is the JPEG data source manager. */
6718 our_memory_skip_input_data (cinfo
, num_bytes
)
6719 j_decompress_ptr cinfo
;
6722 struct jpeg_source_mgr
*src
= (struct jpeg_source_mgr
*) cinfo
->src
;
6726 if (num_bytes
> src
->bytes_in_buffer
)
6727 ERREXIT (cinfo
, JERR_INPUT_EOF
);
6729 src
->bytes_in_buffer
-= num_bytes
;
6730 src
->next_input_byte
+= num_bytes
;
6735 /* Set up the JPEG lib for reading an image from DATA which contains
6736 LEN bytes. CINFO is the decompression info structure created for
6737 reading the image. */
6740 jpeg_memory_src (cinfo
, data
, len
)
6741 j_decompress_ptr cinfo
;
6745 struct jpeg_source_mgr
*src
;
6747 if (cinfo
->src
== NULL
)
6749 /* First time for this JPEG object? */
6750 cinfo
->src
= (struct jpeg_source_mgr
*)
6751 (*cinfo
->mem
->alloc_small
) ((j_common_ptr
) cinfo
, JPOOL_PERMANENT
,
6752 sizeof (struct jpeg_source_mgr
));
6753 src
= (struct jpeg_source_mgr
*) cinfo
->src
;
6754 src
->next_input_byte
= data
;
6757 src
= (struct jpeg_source_mgr
*) cinfo
->src
;
6758 src
->init_source
= our_common_init_source
;
6759 src
->fill_input_buffer
= our_memory_fill_input_buffer
;
6760 src
->skip_input_data
= our_memory_skip_input_data
;
6761 src
->resync_to_restart
= jpeg_resync_to_restart_wrapper
; /* Use default method. */
6762 src
->term_source
= our_common_term_source
;
6763 src
->bytes_in_buffer
= len
;
6764 src
->next_input_byte
= data
;
6768 struct jpeg_stdio_mgr
6770 struct jpeg_source_mgr mgr
;
6777 /* Size of buffer to read JPEG from file.
6778 Not too big, as we want to use alloc_small. */
6779 #define JPEG_STDIO_BUFFER_SIZE 8192
6782 /* Fill input buffer method for JPEG data source manager. Called
6783 whenever more data is needed. The data is read from a FILE *. */
6786 our_stdio_fill_input_buffer (cinfo
)
6787 j_decompress_ptr cinfo
;
6789 struct jpeg_stdio_mgr
*src
;
6791 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6796 bytes
= fread (src
->buffer
, 1, JPEG_STDIO_BUFFER_SIZE
, src
->file
);
6798 src
->mgr
.bytes_in_buffer
= bytes
;
6801 WARNMS (cinfo
, JWRN_JPEG_EOF
);
6803 src
->buffer
[0] = (JOCTET
) 0xFF;
6804 src
->buffer
[1] = (JOCTET
) JPEG_EOI
;
6805 src
->mgr
.bytes_in_buffer
= 2;
6807 src
->mgr
.next_input_byte
= src
->buffer
;
6814 /* Method to skip over NUM_BYTES bytes in the image data. CINFO->src
6815 is the JPEG data source manager. */
6818 our_stdio_skip_input_data (cinfo
, num_bytes
)
6819 j_decompress_ptr cinfo
;
6822 struct jpeg_stdio_mgr
*src
;
6823 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6825 while (num_bytes
> 0 && !src
->finished
)
6827 if (num_bytes
<= src
->mgr
.bytes_in_buffer
)
6829 src
->mgr
.bytes_in_buffer
-= num_bytes
;
6830 src
->mgr
.next_input_byte
+= num_bytes
;
6835 num_bytes
-= src
->mgr
.bytes_in_buffer
;
6836 src
->mgr
.bytes_in_buffer
= 0;
6837 src
->mgr
.next_input_byte
= NULL
;
6839 our_stdio_fill_input_buffer (cinfo
);
6845 /* Set up the JPEG lib for reading an image from a FILE *.
6846 CINFO is the decompression info structure created for
6847 reading the image. */
6850 jpeg_file_src (cinfo
, fp
)
6851 j_decompress_ptr cinfo
;
6854 struct jpeg_stdio_mgr
*src
;
6856 if (cinfo
->src
!= NULL
)
6857 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6860 /* First time for this JPEG object? */
6861 cinfo
->src
= (struct jpeg_source_mgr
*)
6862 (*cinfo
->mem
->alloc_small
) ((j_common_ptr
) cinfo
, JPOOL_PERMANENT
,
6863 sizeof (struct jpeg_stdio_mgr
));
6864 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6865 src
->buffer
= (JOCTET
*)
6866 (*cinfo
->mem
->alloc_small
) ((j_common_ptr
) cinfo
, JPOOL_PERMANENT
,
6867 JPEG_STDIO_BUFFER_SIZE
);
6872 src
->mgr
.init_source
= our_common_init_source
;
6873 src
->mgr
.fill_input_buffer
= our_stdio_fill_input_buffer
;
6874 src
->mgr
.skip_input_data
= our_stdio_skip_input_data
;
6875 src
->mgr
.resync_to_restart
= jpeg_resync_to_restart_wrapper
; /* Use default method. */
6876 src
->mgr
.term_source
= our_common_term_source
;
6877 src
->mgr
.bytes_in_buffer
= 0;
6878 src
->mgr
.next_input_byte
= NULL
;
6882 /* Load image IMG for use on frame F. Patterned after example.c
6883 from the JPEG lib. */
6890 struct jpeg_decompress_struct cinfo
;
6891 struct my_jpeg_error_mgr mgr
;
6892 Lisp_Object file
, specified_file
;
6893 Lisp_Object specified_data
;
6894 FILE * volatile fp
= NULL
;
6896 int row_stride
, x
, y
;
6897 XImagePtr ximg
= NULL
;
6899 unsigned long *colors
;
6901 struct gcpro gcpro1
;
6903 /* Open the JPEG file. */
6904 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
6905 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
6909 if (NILP (specified_data
))
6911 file
= x_find_image_file (specified_file
);
6912 if (!STRINGP (file
))
6914 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
6919 fp
= fopen (SDATA (file
), "rb");
6922 image_error ("Cannot open `%s'", file
, Qnil
);
6928 /* Customize libjpeg's error handling to call my_error_exit when an
6929 error is detected. This function will perform a longjmp.
6930 Casting return value avoids a GCC warning on W32. */
6931 cinfo
.err
= (struct jpeg_error_mgr
*)fn_jpeg_std_error (&mgr
.pub
);
6932 mgr
.pub
.error_exit
= my_error_exit
;
6934 if ((rc
= setjmp (mgr
.setjmp_buffer
)) != 0)
6938 /* Called from my_error_exit. Display a JPEG error. */
6939 char buffer
[JMSG_LENGTH_MAX
];
6940 cinfo
.err
->format_message ((j_common_ptr
) &cinfo
, buffer
);
6941 image_error ("Error reading JPEG image `%s': %s", img
->spec
,
6942 build_string (buffer
));
6945 /* Close the input file and destroy the JPEG object. */
6947 fclose ((FILE *) fp
);
6948 fn_jpeg_destroy_decompress (&cinfo
);
6950 /* If we already have an XImage, free that. */
6951 x_destroy_x_image (ximg
);
6953 /* Free pixmap and colors. */
6954 x_clear_image (f
, img
);
6960 /* Create the JPEG decompression object. Let it read from fp.
6961 Read the JPEG image header. */
6962 fn_jpeg_CreateDecompress (&cinfo
, JPEG_LIB_VERSION
, sizeof (cinfo
));
6964 if (NILP (specified_data
))
6965 jpeg_file_src (&cinfo
, (FILE *) fp
);
6967 jpeg_memory_src (&cinfo
, SDATA (specified_data
),
6968 SBYTES (specified_data
));
6970 fn_jpeg_read_header (&cinfo
, 1);
6972 /* Customize decompression so that color quantization will be used.
6973 Start decompression. */
6974 cinfo
.quantize_colors
= 1;
6975 fn_jpeg_start_decompress (&cinfo
);
6976 width
= img
->width
= cinfo
.output_width
;
6977 height
= img
->height
= cinfo
.output_height
;
6979 if (!check_image_size (f
, width
, height
))
6981 image_error ("Invalid image size", Qnil
, Qnil
);
6982 longjmp (mgr
.setjmp_buffer
, 2);
6985 /* Create X image and pixmap. */
6986 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
6987 longjmp (mgr
.setjmp_buffer
, 2);
6989 /* Allocate colors. When color quantization is used,
6990 cinfo.actual_number_of_colors has been set with the number of
6991 colors generated, and cinfo.colormap is a two-dimensional array
6992 of color indices in the range 0..cinfo.actual_number_of_colors.
6993 No more than 255 colors will be generated. */
6997 if (cinfo
.out_color_components
> 2)
6998 ir
= 0, ig
= 1, ib
= 2;
6999 else if (cinfo
.out_color_components
> 1)
7000 ir
= 0, ig
= 1, ib
= 0;
7002 ir
= 0, ig
= 0, ib
= 0;
7004 /* Use the color table mechanism because it handles colors that
7005 cannot be allocated nicely. Such colors will be replaced with
7006 a default color, and we don't have to care about which colors
7007 can be freed safely, and which can't. */
7008 init_color_table ();
7009 colors
= (unsigned long *) alloca (cinfo
.actual_number_of_colors
7012 for (i
= 0; i
< cinfo
.actual_number_of_colors
; ++i
)
7014 /* Multiply RGB values with 255 because X expects RGB values
7015 in the range 0..0xffff. */
7016 int r
= cinfo
.colormap
[ir
][i
] << 8;
7017 int g
= cinfo
.colormap
[ig
][i
] << 8;
7018 int b
= cinfo
.colormap
[ib
][i
] << 8;
7019 colors
[i
] = lookup_rgb_color (f
, r
, g
, b
);
7022 #ifdef COLOR_TABLE_SUPPORT
7023 /* Remember those colors actually allocated. */
7024 img
->colors
= colors_in_color_table (&img
->ncolors
);
7025 free_color_table ();
7026 #endif /* COLOR_TABLE_SUPPORT */
7030 row_stride
= width
* cinfo
.output_components
;
7031 buffer
= cinfo
.mem
->alloc_sarray ((j_common_ptr
) &cinfo
, JPOOL_IMAGE
,
7033 for (y
= 0; y
< height
; ++y
)
7035 fn_jpeg_read_scanlines (&cinfo
, buffer
, 1);
7036 for (x
= 0; x
< cinfo
.output_width
; ++x
)
7037 XPutPixel (ximg
, x
, y
, colors
[buffer
[0][x
]]);
7041 fn_jpeg_finish_decompress (&cinfo
);
7042 fn_jpeg_destroy_decompress (&cinfo
);
7044 fclose ((FILE *) fp
);
7046 /* Maybe fill in the background field while we have ximg handy. */
7047 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
7048 /* Casting avoids a GCC warning. */
7049 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
7051 /* Put the image into the pixmap. */
7052 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
7053 x_destroy_x_image (ximg
);
7058 #else /* HAVE_JPEG */
7067 return image_load_quartz2d (f
, img
, 0);
7069 return image_load_quicktime (f
, img
, kQTFileTypeJPEG
);
7074 #endif /* !HAVE_JPEG */
7078 /***********************************************************************
7080 ***********************************************************************/
7082 #if defined (HAVE_TIFF) || defined (MAC_OS)
7084 static int tiff_image_p
P_ ((Lisp_Object object
));
7085 static int tiff_load
P_ ((struct frame
*f
, struct image
*img
));
7087 /* The symbol `tiff' identifying images of this type. */
7091 /* Indices of image specification fields in tiff_format, below. */
7093 enum tiff_keyword_index
7102 TIFF_HEURISTIC_MASK
,
7108 /* Vector of image_keyword structures describing the format
7109 of valid user-defined image specifications. */
7111 static struct image_keyword tiff_format
[TIFF_LAST
] =
7113 {":type", IMAGE_SYMBOL_VALUE
, 1},
7114 {":data", IMAGE_STRING_VALUE
, 0},
7115 {":file", IMAGE_STRING_VALUE
, 0},
7116 {":ascent", IMAGE_ASCENT_VALUE
, 0},
7117 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
7118 {":relief", IMAGE_INTEGER_VALUE
, 0},
7119 {":conversions", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7120 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7121 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7122 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
7125 /* Structure describing the image type `tiff'. */
7127 static struct image_type tiff_type
=
7136 /* Return non-zero if OBJECT is a valid TIFF image specification. */
7139 tiff_image_p (object
)
7142 struct image_keyword fmt
[TIFF_LAST
];
7143 bcopy (tiff_format
, fmt
, sizeof fmt
);
7145 if (!parse_image_spec (object
, fmt
, TIFF_LAST
, Qtiff
))
7148 /* Must specify either the :data or :file keyword. */
7149 return fmt
[TIFF_FILE
].count
+ fmt
[TIFF_DATA
].count
== 1;
7152 #endif /* HAVE_TIFF || MAC_OS */
7160 /* TIFF library details. */
7161 DEF_IMGLIB_FN (TIFFSetErrorHandler
);
7162 DEF_IMGLIB_FN (TIFFSetWarningHandler
);
7163 DEF_IMGLIB_FN (TIFFOpen
);
7164 DEF_IMGLIB_FN (TIFFClientOpen
);
7165 DEF_IMGLIB_FN (TIFFGetField
);
7166 DEF_IMGLIB_FN (TIFFReadRGBAImage
);
7167 DEF_IMGLIB_FN (TIFFClose
);
7170 init_tiff_functions (Lisp_Object libraries
)
7174 if (!(library
= w32_delayed_load (libraries
, Qtiff
)))
7177 LOAD_IMGLIB_FN (library
, TIFFSetErrorHandler
);
7178 LOAD_IMGLIB_FN (library
, TIFFSetWarningHandler
);
7179 LOAD_IMGLIB_FN (library
, TIFFOpen
);
7180 LOAD_IMGLIB_FN (library
, TIFFClientOpen
);
7181 LOAD_IMGLIB_FN (library
, TIFFGetField
);
7182 LOAD_IMGLIB_FN (library
, TIFFReadRGBAImage
);
7183 LOAD_IMGLIB_FN (library
, TIFFClose
);
7189 #define fn_TIFFSetErrorHandler TIFFSetErrorHandler
7190 #define fn_TIFFSetWarningHandler TIFFSetWarningHandler
7191 #define fn_TIFFOpen TIFFOpen
7192 #define fn_TIFFClientOpen TIFFClientOpen
7193 #define fn_TIFFGetField TIFFGetField
7194 #define fn_TIFFReadRGBAImage TIFFReadRGBAImage
7195 #define fn_TIFFClose TIFFClose
7197 #endif /* HAVE_NTGUI */
7200 /* Reading from a memory buffer for TIFF images Based on the PNG
7201 memory source, but we have to provide a lot of extra functions.
7204 We really only need to implement read and seek, but I am not
7205 convinced that the TIFF library is smart enough not to destroy
7206 itself if we only hand it the function pointers we need to
7211 unsigned char *bytes
;
7218 tiff_read_from_memory (data
, buf
, size
)
7223 tiff_memory_source
*src
= (tiff_memory_source
*) data
;
7225 if (size
> src
->len
- src
->index
)
7227 bcopy (src
->bytes
+ src
->index
, buf
, size
);
7233 tiff_write_from_memory (data
, buf
, size
)
7242 tiff_seek_in_memory (data
, off
, whence
)
7247 tiff_memory_source
*src
= (tiff_memory_source
*) data
;
7252 case SEEK_SET
: /* Go from beginning of source. */
7256 case SEEK_END
: /* Go from end of source. */
7257 idx
= src
->len
+ off
;
7260 case SEEK_CUR
: /* Go from current position. */
7261 idx
= src
->index
+ off
;
7264 default: /* Invalid `whence'. */
7268 if (idx
> src
->len
|| idx
< 0)
7276 tiff_close_memory (data
)
7284 tiff_mmap_memory (data
, pbase
, psize
)
7289 /* It is already _IN_ memory. */
7294 tiff_unmap_memory (data
, base
, size
)
7299 /* We don't need to do this. */
7303 tiff_size_of_memory (data
)
7306 return ((tiff_memory_source
*) data
)->len
;
7311 tiff_error_handler (title
, format
, ap
)
7312 const char *title
, *format
;
7318 len
= sprintf (buf
, "TIFF error: %s ", title
);
7319 vsprintf (buf
+ len
, format
, ap
);
7320 add_to_log (buf
, Qnil
, Qnil
);
7325 tiff_warning_handler (title
, format
, ap
)
7326 const char *title
, *format
;
7332 len
= sprintf (buf
, "TIFF warning: %s ", title
);
7333 vsprintf (buf
+ len
, format
, ap
);
7334 add_to_log (buf
, Qnil
, Qnil
);
7338 /* Load TIFF image IMG for use on frame F. Value is non-zero if
7346 Lisp_Object file
, specified_file
;
7347 Lisp_Object specified_data
;
7349 int width
, height
, x
, y
;
7353 struct gcpro gcpro1
;
7354 tiff_memory_source memsrc
;
7356 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
7357 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
7361 fn_TIFFSetErrorHandler (tiff_error_handler
);
7362 fn_TIFFSetWarningHandler (tiff_warning_handler
);
7364 if (NILP (specified_data
))
7366 /* Read from a file */
7367 file
= x_find_image_file (specified_file
);
7368 if (!STRINGP (file
))
7370 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
7375 /* Try to open the image file. Casting return value avoids a
7376 GCC warning on W32. */
7377 tiff
= (TIFF
*)fn_TIFFOpen (SDATA (file
), "r");
7380 image_error ("Cannot open `%s'", file
, Qnil
);
7387 /* Memory source! */
7388 memsrc
.bytes
= SDATA (specified_data
);
7389 memsrc
.len
= SBYTES (specified_data
);
7392 /* Casting return value avoids a GCC warning on W32. */
7393 tiff
= (TIFF
*)fn_TIFFClientOpen ("memory_source", "r", &memsrc
,
7394 (TIFFReadWriteProc
) tiff_read_from_memory
,
7395 (TIFFReadWriteProc
) tiff_write_from_memory
,
7396 tiff_seek_in_memory
,
7398 tiff_size_of_memory
,
7404 image_error ("Cannot open memory source for `%s'", img
->spec
, Qnil
);
7410 /* Get width and height of the image, and allocate a raster buffer
7411 of width x height 32-bit values. */
7412 fn_TIFFGetField (tiff
, TIFFTAG_IMAGEWIDTH
, &width
);
7413 fn_TIFFGetField (tiff
, TIFFTAG_IMAGELENGTH
, &height
);
7415 if (!check_image_size (f
, width
, height
))
7417 image_error ("Invalid image size", Qnil
, Qnil
);
7422 buf
= (uint32
*) xmalloc (width
* height
* sizeof *buf
);
7424 rc
= fn_TIFFReadRGBAImage (tiff
, width
, height
, buf
, 0);
7425 fn_TIFFClose (tiff
);
7428 image_error ("Error reading TIFF image `%s'", img
->spec
, Qnil
);
7434 /* Create the X image and pixmap. */
7435 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
7442 /* Initialize the color table. */
7443 init_color_table ();
7445 /* Process the pixel raster. Origin is in the lower-left corner. */
7446 for (y
= 0; y
< height
; ++y
)
7448 uint32
*row
= buf
+ y
* width
;
7450 for (x
= 0; x
< width
; ++x
)
7452 uint32 abgr
= row
[x
];
7453 int r
= TIFFGetR (abgr
) << 8;
7454 int g
= TIFFGetG (abgr
) << 8;
7455 int b
= TIFFGetB (abgr
) << 8;
7456 XPutPixel (ximg
, x
, height
- 1 - y
, lookup_rgb_color (f
, r
, g
, b
));
7460 #ifdef COLOR_TABLE_SUPPORT
7461 /* Remember the colors allocated for the image. Free the color table. */
7462 img
->colors
= colors_in_color_table (&img
->ncolors
);
7463 free_color_table ();
7464 #endif /* COLOR_TABLE_SUPPORT */
7467 img
->height
= height
;
7469 /* Maybe fill in the background field while we have ximg handy. */
7470 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
7471 /* Casting avoids a GCC warning on W32. */
7472 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
7474 /* Put the image into the pixmap, then free the X image and its buffer. */
7475 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
7476 x_destroy_x_image (ximg
);
7483 #else /* HAVE_TIFF */
7491 return image_load_quicktime (f
, img
, kQTFileTypeTIFF
);
7495 #endif /* !HAVE_TIFF */
7499 /***********************************************************************
7501 ***********************************************************************/
7503 #if defined (HAVE_GIF) || defined (MAC_OS)
7505 static int gif_image_p
P_ ((Lisp_Object object
));
7506 static int gif_load
P_ ((struct frame
*f
, struct image
*img
));
7507 static void gif_clear_image
P_ ((struct frame
*f
, struct image
*img
));
7509 /* The symbol `gif' identifying images of this type. */
7513 /* Indices of image specification fields in gif_format, below. */
7515 enum gif_keyword_index
7531 /* Vector of image_keyword structures describing the format
7532 of valid user-defined image specifications. */
7534 static struct image_keyword gif_format
[GIF_LAST
] =
7536 {":type", IMAGE_SYMBOL_VALUE
, 1},
7537 {":data", IMAGE_STRING_VALUE
, 0},
7538 {":file", IMAGE_STRING_VALUE
, 0},
7539 {":ascent", IMAGE_ASCENT_VALUE
, 0},
7540 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
7541 {":relief", IMAGE_INTEGER_VALUE
, 0},
7542 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7543 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7544 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7545 {":image", IMAGE_NON_NEGATIVE_INTEGER_VALUE
, 0},
7546 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
7549 /* Structure describing the image type `gif'. */
7551 static struct image_type gif_type
=
7560 /* Free X resources of GIF image IMG which is used on frame F. */
7563 gif_clear_image (f
, img
)
7567 /* IMG->data.ptr_val may contain extension data. */
7568 img
->data
.lisp_val
= Qnil
;
7569 x_clear_image (f
, img
);
7572 /* Return non-zero if OBJECT is a valid GIF image specification. */
7575 gif_image_p (object
)
7578 struct image_keyword fmt
[GIF_LAST
];
7579 bcopy (gif_format
, fmt
, sizeof fmt
);
7581 if (!parse_image_spec (object
, fmt
, GIF_LAST
, Qgif
))
7584 /* Must specify either the :data or :file keyword. */
7585 return fmt
[GIF_FILE
].count
+ fmt
[GIF_DATA
].count
== 1;
7588 #endif /* HAVE_GIF || MAC_OS */
7592 #if defined (HAVE_NTGUI) || defined (MAC_OS)
7593 /* winuser.h might define DrawText to DrawTextA or DrawTextW.
7594 Undefine before redefining to avoid a preprocessor warning. */
7598 /* avoid conflict with QuickdrawText.h */
7599 #define DrawText gif_DrawText
7600 #include <gif_lib.h>
7603 #else /* HAVE_NTGUI || MAC_OS */
7605 #include <gif_lib.h>
7607 #endif /* HAVE_NTGUI || MAC_OS */
7612 /* GIF library details. */
7613 DEF_IMGLIB_FN (DGifCloseFile
);
7614 DEF_IMGLIB_FN (DGifSlurp
);
7615 DEF_IMGLIB_FN (DGifOpen
);
7616 DEF_IMGLIB_FN (DGifOpenFileName
);
7619 init_gif_functions (Lisp_Object libraries
)
7623 if (!(library
= w32_delayed_load (libraries
, Qgif
)))
7626 LOAD_IMGLIB_FN (library
, DGifCloseFile
);
7627 LOAD_IMGLIB_FN (library
, DGifSlurp
);
7628 LOAD_IMGLIB_FN (library
, DGifOpen
);
7629 LOAD_IMGLIB_FN (library
, DGifOpenFileName
);
7635 #define fn_DGifCloseFile DGifCloseFile
7636 #define fn_DGifSlurp DGifSlurp
7637 #define fn_DGifOpen DGifOpen
7638 #define fn_DGifOpenFileName DGifOpenFileName
7640 #endif /* HAVE_NTGUI */
7642 /* Reading a GIF image from memory
7643 Based on the PNG memory stuff to a certain extent. */
7647 unsigned char *bytes
;
7653 /* Make the current memory source available to gif_read_from_memory.
7654 It's done this way because not all versions of libungif support
7655 a UserData field in the GifFileType structure. */
7656 static gif_memory_source
*current_gif_memory_src
;
7659 gif_read_from_memory (file
, buf
, len
)
7664 gif_memory_source
*src
= current_gif_memory_src
;
7666 if (len
> src
->len
- src
->index
)
7669 bcopy (src
->bytes
+ src
->index
, buf
, len
);
7675 /* Load GIF image IMG for use on frame F. Value is non-zero if
7683 Lisp_Object file
, specified_file
;
7684 Lisp_Object specified_data
;
7685 int rc
, width
, height
, x
, y
, i
;
7687 ColorMapObject
*gif_color_map
;
7688 unsigned long pixel_colors
[256];
7690 struct gcpro gcpro1
;
7692 int ino
, image_height
, image_width
;
7693 gif_memory_source memsrc
;
7694 unsigned char *raster
;
7696 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
7697 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
7701 if (NILP (specified_data
))
7703 file
= x_find_image_file (specified_file
);
7704 if (!STRINGP (file
))
7706 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
7711 /* Open the GIF file. Casting return value avoids a GCC warning
7713 gif
= (GifFileType
*)fn_DGifOpenFileName (SDATA (file
));
7716 image_error ("Cannot open `%s'", file
, Qnil
);
7723 /* Read from memory! */
7724 current_gif_memory_src
= &memsrc
;
7725 memsrc
.bytes
= SDATA (specified_data
);
7726 memsrc
.len
= SBYTES (specified_data
);
7729 /* Casting return value avoids a GCC warning on W32. */
7730 gif
= (GifFileType
*)fn_DGifOpen(&memsrc
, gif_read_from_memory
);
7733 image_error ("Cannot open memory source `%s'", img
->spec
, Qnil
);
7739 /* Before reading entire contents, check the declared image size. */
7740 if (!check_image_size (f
, gif
->SWidth
, gif
->SHeight
))
7742 image_error ("Invalid image size", Qnil
, Qnil
);
7743 fn_DGifCloseFile (gif
);
7748 /* Read entire contents. */
7749 rc
= fn_DGifSlurp (gif
);
7750 if (rc
== GIF_ERROR
)
7752 image_error ("Error reading `%s'", img
->spec
, Qnil
);
7753 fn_DGifCloseFile (gif
);
7758 image
= image_spec_value (img
->spec
, QCindex
, NULL
);
7759 ino
= INTEGERP (image
) ? XFASTINT (image
) : 0;
7760 if (ino
>= gif
->ImageCount
)
7762 image_error ("Invalid image number `%s' in image `%s'",
7764 fn_DGifCloseFile (gif
);
7769 img
->corners
[TOP_CORNER
] = gif
->SavedImages
[ino
].ImageDesc
.Top
;
7770 img
->corners
[LEFT_CORNER
] = gif
->SavedImages
[ino
].ImageDesc
.Left
;
7771 image_height
= gif
->SavedImages
[ino
].ImageDesc
.Height
;
7772 img
->corners
[BOT_CORNER
] = img
->corners
[TOP_CORNER
] + image_height
;
7773 image_width
= gif
->SavedImages
[ino
].ImageDesc
.Width
;
7774 img
->corners
[RIGHT_CORNER
] = img
->corners
[LEFT_CORNER
] + image_width
;
7776 width
= img
->width
= max (gif
->SWidth
,
7777 max (gif
->Image
.Left
+ gif
->Image
.Width
,
7778 img
->corners
[RIGHT_CORNER
]));
7779 height
= img
->height
= max (gif
->SHeight
,
7780 max (gif
->Image
.Top
+ gif
->Image
.Height
,
7781 img
->corners
[BOT_CORNER
]));
7783 if (!check_image_size (f
, width
, height
))
7785 image_error ("Invalid image size", Qnil
, Qnil
);
7786 fn_DGifCloseFile (gif
);
7791 /* Create the X image and pixmap. */
7792 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
7794 fn_DGifCloseFile (gif
);
7799 /* Allocate colors. */
7800 gif_color_map
= gif
->SavedImages
[ino
].ImageDesc
.ColorMap
;
7802 gif_color_map
= gif
->SColorMap
;
7803 init_color_table ();
7804 bzero (pixel_colors
, sizeof pixel_colors
);
7806 for (i
= 0; i
< gif_color_map
->ColorCount
; ++i
)
7808 int r
= gif_color_map
->Colors
[i
].Red
<< 8;
7809 int g
= gif_color_map
->Colors
[i
].Green
<< 8;
7810 int b
= gif_color_map
->Colors
[i
].Blue
<< 8;
7811 pixel_colors
[i
] = lookup_rgb_color (f
, r
, g
, b
);
7814 #ifdef COLOR_TABLE_SUPPORT
7815 img
->colors
= colors_in_color_table (&img
->ncolors
);
7816 free_color_table ();
7817 #endif /* COLOR_TABLE_SUPPORT */
7819 /* Clear the part of the screen image that are not covered by
7820 the image from the GIF file. Full animated GIF support
7821 requires more than can be done here (see the gif89 spec,
7822 disposal methods). Let's simply assume that the part
7823 not covered by a sub-image is in the frame's background color. */
7824 for (y
= 0; y
< img
->corners
[TOP_CORNER
]; ++y
)
7825 for (x
= 0; x
< width
; ++x
)
7826 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7828 for (y
= img
->corners
[BOT_CORNER
]; y
< height
; ++y
)
7829 for (x
= 0; x
< width
; ++x
)
7830 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7832 for (y
= img
->corners
[TOP_CORNER
]; y
< img
->corners
[BOT_CORNER
]; ++y
)
7834 for (x
= 0; x
< img
->corners
[LEFT_CORNER
]; ++x
)
7835 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7836 for (x
= img
->corners
[RIGHT_CORNER
]; x
< width
; ++x
)
7837 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7840 /* Read the GIF image into the X image. We use a local variable
7841 `raster' here because RasterBits below is a char *, and invites
7842 problems with bytes >= 0x80. */
7843 raster
= (unsigned char *) gif
->SavedImages
[ino
].RasterBits
;
7845 if (gif
->SavedImages
[ino
].ImageDesc
.Interlace
)
7847 static int interlace_start
[] = {0, 4, 2, 1};
7848 static int interlace_increment
[] = {8, 8, 4, 2};
7850 int row
= interlace_start
[0];
7854 for (y
= 0; y
< image_height
; y
++)
7856 if (row
>= image_height
)
7858 row
= interlace_start
[++pass
];
7859 while (row
>= image_height
)
7860 row
= interlace_start
[++pass
];
7863 for (x
= 0; x
< image_width
; x
++)
7865 int i
= raster
[(y
* image_width
) + x
];
7866 XPutPixel (ximg
, x
+ img
->corners
[LEFT_CORNER
],
7867 row
+ img
->corners
[TOP_CORNER
], pixel_colors
[i
]);
7870 row
+= interlace_increment
[pass
];
7875 for (y
= 0; y
< image_height
; ++y
)
7876 for (x
= 0; x
< image_width
; ++x
)
7878 int i
= raster
[y
* image_width
+ x
];
7879 XPutPixel (ximg
, x
+ img
->corners
[LEFT_CORNER
],
7880 y
+ img
->corners
[TOP_CORNER
], pixel_colors
[i
]);
7884 /* Save GIF image extension data for `image-extension-data'.
7885 Format is (count IMAGES FUNCTION "BYTES" ...). */
7886 img
->data
.lisp_val
= Qnil
;
7887 if (gif
->SavedImages
[ino
].ExtensionBlockCount
> 0)
7889 ExtensionBlock
*ext
= gif
->SavedImages
[ino
].ExtensionBlocks
;
7890 for (i
= 0; i
< gif
->SavedImages
[ino
].ExtensionBlockCount
; i
++, ext
++)
7891 /* Append (... FUNCTION "BYTES") */
7892 img
->data
.lisp_val
= Fcons (make_unibyte_string (ext
->Bytes
, ext
->ByteCount
),
7893 Fcons (make_number (ext
->Function
),
7894 img
->data
.lisp_val
));
7895 img
->data
.lisp_val
= Fnreverse (img
->data
.lisp_val
);
7897 if (gif
->ImageCount
> 1)
7898 img
->data
.lisp_val
= Fcons (Qcount
,
7899 Fcons (make_number (gif
->ImageCount
),
7900 img
->data
.lisp_val
));
7902 fn_DGifCloseFile (gif
);
7904 /* Maybe fill in the background field while we have ximg handy. */
7905 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
7906 /* Casting avoids a GCC warning. */
7907 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
7909 /* Put the image into the pixmap, then free the X image and its buffer. */
7910 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
7911 x_destroy_x_image (ximg
);
7917 #else /* !HAVE_GIF */
7925 Lisp_Object specified_file
, file
;
7926 Lisp_Object specified_data
;
7928 Boolean graphic_p
, movie_p
, prefer_graphic_p
;
7936 Lisp_Object specified_bg
;
7941 TimeScale time_scale
;
7942 TimeValue time
, duration
;
7947 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
7948 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
7950 /* Animated gifs use QuickTime Movie Toolbox. So initialize it here. */
7953 if (NILP (specified_data
))
7955 /* Read from a file */
7959 err
= find_image_fsspec (specified_file
, &file
, &fss
);
7963 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
7968 err
= CanQuickTimeOpenFile (&fss
, kQTFileTypeGIF
, 0,
7969 &graphic_p
, &movie_p
, &prefer_graphic_p
, 0);
7973 if (!graphic_p
&& !movie_p
)
7975 if (prefer_graphic_p
)
7976 return image_load_qt_1 (f
, img
, kQTFileTypeGIF
, &fss
, NULL
);
7977 err
= OpenMovieFile (&fss
, &refnum
, fsRdPerm
);
7980 err
= NewMovieFromFile (&movie
, refnum
, NULL
, NULL
, 0, NULL
);
7981 CloseMovieFile (refnum
);
7984 image_error ("Error reading `%s'", file
, Qnil
);
7990 /* Memory source! */
7992 long file_type_atom
[3];
7994 err
= PtrToHand (SDATA (specified_data
), &dh
, SBYTES (specified_data
));
7997 image_error ("Cannot allocate data handle for `%s'",
8002 file_type_atom
[0] = EndianU32_NtoB (sizeof (long) * 3);
8003 file_type_atom
[1] = EndianU32_NtoB (kDataRefExtensionMacOSFileType
);
8004 file_type_atom
[2] = EndianU32_NtoB (kQTFileTypeGIF
);
8005 err
= PtrToHand (&dh
, &dref
, sizeof (Handle
));
8008 err
= PtrAndHand ("\p", dref
, 1);
8010 err
= PtrAndHand (file_type_atom
, dref
, sizeof (long) * 3);
8013 image_error ("Cannot allocate handle data ref for `%s'", img
->spec
, Qnil
);
8016 err
= CanQuickTimeOpenDataRef (dref
, HandleDataHandlerSubType
, &graphic_p
,
8017 &movie_p
, &prefer_graphic_p
, 0);
8021 if (!graphic_p
&& !movie_p
)
8023 if (prefer_graphic_p
)
8027 DisposeHandle (dref
);
8028 success_p
= image_load_qt_1 (f
, img
, kQTFileTypeGIF
, NULL
, dh
);
8032 err
= NewMovieFromDataRef (&movie
, 0, NULL
, dref
,
8033 HandleDataHandlerSubType
);
8034 DisposeHandle (dref
);
8039 image
= image_spec_value (img
->spec
, QCindex
, NULL
);
8040 ino
= INTEGERP (image
) ? XFASTINT (image
) : 0;
8041 track
= GetMovieIndTrack (movie
, 1);
8042 media
= GetTrackMedia (track
);
8043 nsamples
= GetMediaSampleCount (media
);
8044 if (ino
>= nsamples
)
8046 image_error ("Invalid image number `%s' in image `%s'",
8050 time_scale
= GetMediaTimeScale (media
);
8052 specified_bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
8053 if (!STRINGP (specified_bg
) ||
8054 !mac_defined_color (f
, SDATA (specified_bg
), &color
, 0))
8056 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
8057 color
.red
= RED16_FROM_ULONG (color
.pixel
);
8058 color
.green
= GREEN16_FROM_ULONG (color
.pixel
);
8059 color
.blue
= BLUE16_FROM_ULONG (color
.pixel
);
8061 GetMovieBox (movie
, &rect
);
8062 width
= img
->width
= rect
.right
- rect
.left
;
8063 height
= img
->height
= rect
.bottom
- rect
.top
;
8064 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
8067 GetGWorld (&old_port
, &old_gdh
);
8068 SetGWorld (ximg
, NULL
);
8069 bg_color
.red
= color
.red
;
8070 bg_color
.green
= color
.green
;
8071 bg_color
.blue
= color
.blue
;
8072 RGBBackColor (&bg_color
);
8073 SetGWorld (old_port
, old_gdh
);
8074 SetMovieActive (movie
, 1);
8075 SetMovieGWorld (movie
, ximg
, NULL
);
8076 SampleNumToMediaTime (media
, ino
+ 1, &time
, &duration
);
8077 SetMovieTimeValue (movie
, time
);
8078 MoviesTask (movie
, 0L);
8079 DisposeTrackMedia (media
);
8080 DisposeMovieTrack (track
);
8081 DisposeMovie (movie
);
8085 /* Save GIF image extension data for `image-extension-data'.
8086 Format is (count IMAGES 0xf9 GRAPHIC_CONTROL_EXTENSION_BLOCK). */
8088 Lisp_Object gce
= make_uninit_string (4);
8089 int centisec
= ((float)duration
/ time_scale
) * 100.0f
+ 0.5f
;
8091 /* Fill the delay time field. */
8092 SSET (gce
, 1, centisec
& 0xff);
8093 SSET (gce
, 2, (centisec
>> 8) & 0xff);
8094 /* We don't know about other fields. */
8098 img
->data
.lisp_val
= list4 (Qcount
, make_number (nsamples
),
8099 make_number (0xf9), gce
);
8102 /* Maybe fill in the background field while we have ximg handy. */
8103 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
8104 IMAGE_BACKGROUND (img
, f
, ximg
);
8106 /* Put the image into the pixmap. */
8107 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
8108 x_destroy_x_image (ximg
);
8112 image_error ("Cannot open `%s'", file
, Qnil
);
8115 DisposeTrackMedia (media
);
8117 DisposeMovieTrack (track
);
8119 DisposeMovie (movie
);
8126 #endif /* HAVE_GIF */
8130 /***********************************************************************
8132 ***********************************************************************/
8134 #ifdef HAVE_X_WINDOWS
8135 #define HAVE_GHOSTSCRIPT 1
8136 #endif /* HAVE_X_WINDOWS */
8138 /* The symbol `postscript' identifying images of this type. */
8140 Lisp_Object Qpostscript
;
8142 #ifdef HAVE_GHOSTSCRIPT
8144 static int gs_image_p
P_ ((Lisp_Object object
));
8145 static int gs_load
P_ ((struct frame
*f
, struct image
*img
));
8146 static void gs_clear_image
P_ ((struct frame
*f
, struct image
*img
));
8148 /* Keyword symbols. */
8150 Lisp_Object QCloader
, QCbounding_box
, QCpt_width
, QCpt_height
;
8152 /* Indices of image specification fields in gs_format, below. */
8154 enum gs_keyword_index
8172 /* Vector of image_keyword structures describing the format
8173 of valid user-defined image specifications. */
8175 static struct image_keyword gs_format
[GS_LAST
] =
8177 {":type", IMAGE_SYMBOL_VALUE
, 1},
8178 {":pt-width", IMAGE_POSITIVE_INTEGER_VALUE
, 1},
8179 {":pt-height", IMAGE_POSITIVE_INTEGER_VALUE
, 1},
8180 {":file", IMAGE_STRING_VALUE
, 1},
8181 {":loader", IMAGE_FUNCTION_VALUE
, 0},
8182 {":bounding-box", IMAGE_DONT_CHECK_VALUE_TYPE
, 1},
8183 {":ascent", IMAGE_ASCENT_VALUE
, 0},
8184 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
8185 {":relief", IMAGE_INTEGER_VALUE
, 0},
8186 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8187 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8188 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8189 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
8192 /* Structure describing the image type `ghostscript'. */
8194 static struct image_type gs_type
=
8204 /* Free X resources of Ghostscript image IMG which is used on frame F. */
8207 gs_clear_image (f
, img
)
8211 /* IMG->data.ptr_val may contain a recorded colormap. */
8212 xfree (img
->data
.ptr_val
);
8213 x_clear_image (f
, img
);
8217 /* Return non-zero if OBJECT is a valid Ghostscript image
8224 struct image_keyword fmt
[GS_LAST
];
8228 bcopy (gs_format
, fmt
, sizeof fmt
);
8230 if (!parse_image_spec (object
, fmt
, GS_LAST
, Qpostscript
))
8233 /* Bounding box must be a list or vector containing 4 integers. */
8234 tem
= fmt
[GS_BOUNDING_BOX
].value
;
8237 for (i
= 0; i
< 4; ++i
, tem
= XCDR (tem
))
8238 if (!CONSP (tem
) || !INTEGERP (XCAR (tem
)))
8243 else if (VECTORP (tem
))
8245 if (XVECTOR (tem
)->size
!= 4)
8247 for (i
= 0; i
< 4; ++i
)
8248 if (!INTEGERP (XVECTOR (tem
)->contents
[i
]))
8258 /* Load Ghostscript image IMG for use on frame F. Value is non-zero
8267 Lisp_Object window_and_pixmap_id
= Qnil
, loader
, pt_height
, pt_width
;
8268 struct gcpro gcpro1
, gcpro2
;
8270 double in_width
, in_height
;
8271 Lisp_Object pixel_colors
= Qnil
;
8273 /* Compute pixel size of pixmap needed from the given size in the
8274 image specification. Sizes in the specification are in pt. 1 pt
8275 = 1/72 in, xdpi and ydpi are stored in the frame's X display
8277 pt_width
= image_spec_value (img
->spec
, QCpt_width
, NULL
);
8278 in_width
= XFASTINT (pt_width
) / 72.0;
8279 img
->width
= in_width
* FRAME_X_DISPLAY_INFO (f
)->resx
;
8280 pt_height
= image_spec_value (img
->spec
, QCpt_height
, NULL
);
8281 in_height
= XFASTINT (pt_height
) / 72.0;
8282 img
->height
= in_height
* FRAME_X_DISPLAY_INFO (f
)->resy
;
8284 if (!check_image_size (f
, img
->width
, img
->height
))
8286 image_error ("Invalid image size", Qnil
, Qnil
);
8290 /* Create the pixmap. */
8291 xassert (img
->pixmap
== NO_PIXMAP
);
8293 /* Only W32 version did BLOCK_INPUT here. ++kfs */
8295 img
->pixmap
= XCreatePixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
8296 img
->width
, img
->height
,
8297 DefaultDepthOfScreen (FRAME_X_SCREEN (f
)));
8302 image_error ("Unable to create pixmap for `%s'", img
->spec
, Qnil
);
8306 /* Call the loader to fill the pixmap. It returns a process object
8307 if successful. We do not record_unwind_protect here because
8308 other places in redisplay like calling window scroll functions
8309 don't either. Let the Lisp loader use `unwind-protect' instead. */
8310 GCPRO2 (window_and_pixmap_id
, pixel_colors
);
8312 sprintf (buffer
, "%lu %lu",
8313 (unsigned long) FRAME_X_WINDOW (f
),
8314 (unsigned long) img
->pixmap
);
8315 window_and_pixmap_id
= build_string (buffer
);
8317 sprintf (buffer
, "%lu %lu",
8318 FRAME_FOREGROUND_PIXEL (f
),
8319 FRAME_BACKGROUND_PIXEL (f
));
8320 pixel_colors
= build_string (buffer
);
8322 XSETFRAME (frame
, f
);
8323 loader
= image_spec_value (img
->spec
, QCloader
, NULL
);
8325 loader
= intern ("gs-load-image");
8327 img
->data
.lisp_val
= call6 (loader
, frame
, img
->spec
,
8328 make_number (img
->width
),
8329 make_number (img
->height
),
8330 window_and_pixmap_id
,
8333 return PROCESSP (img
->data
.lisp_val
);
8337 /* Kill the Ghostscript process that was started to fill PIXMAP on
8338 frame F. Called from XTread_socket when receiving an event
8339 telling Emacs that Ghostscript has finished drawing. */
8342 x_kill_gs_process (pixmap
, f
)
8346 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
8350 /* Find the image containing PIXMAP. */
8351 for (i
= 0; i
< c
->used
; ++i
)
8352 if (c
->images
[i
]->pixmap
== pixmap
)
8355 /* Should someone in between have cleared the image cache, for
8356 instance, give up. */
8360 /* Kill the GS process. We should have found PIXMAP in the image
8361 cache and its image should contain a process object. */
8363 xassert (PROCESSP (img
->data
.lisp_val
));
8364 Fkill_process (img
->data
.lisp_val
, Qnil
);
8365 img
->data
.lisp_val
= Qnil
;
8367 #if defined (HAVE_X_WINDOWS)
8369 /* On displays with a mutable colormap, figure out the colors
8370 allocated for the image by looking at the pixels of an XImage for
8372 class = FRAME_X_VISUAL (f
)->class;
8373 if (class != StaticColor
&& class != StaticGray
&& class != TrueColor
)
8379 /* Try to get an XImage for img->pixmep. */
8380 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
8381 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
8386 /* Initialize the color table. */
8387 init_color_table ();
8389 /* For each pixel of the image, look its color up in the
8390 color table. After having done so, the color table will
8391 contain an entry for each color used by the image. */
8392 for (y
= 0; y
< img
->height
; ++y
)
8393 for (x
= 0; x
< img
->width
; ++x
)
8395 unsigned long pixel
= XGetPixel (ximg
, x
, y
);
8396 lookup_pixel_color (f
, pixel
);
8399 /* Record colors in the image. Free color table and XImage. */
8400 #ifdef COLOR_TABLE_SUPPORT
8401 img
->colors
= colors_in_color_table (&img
->ncolors
);
8402 free_color_table ();
8404 XDestroyImage (ximg
);
8406 #if 0 /* This doesn't seem to be the case. If we free the colors
8407 here, we get a BadAccess later in x_clear_image when
8408 freeing the colors. */
8409 /* We have allocated colors once, but Ghostscript has also
8410 allocated colors on behalf of us. So, to get the
8411 reference counts right, free them once. */
8413 x_free_colors (f
, img
->colors
, img
->ncolors
);
8417 image_error ("Cannot get X image of `%s'; colors will not be freed",
8422 #endif /* HAVE_X_WINDOWS */
8424 /* Now that we have the pixmap, compute mask and transform the
8425 image if requested. */
8427 postprocess_image (f
, img
);
8431 #endif /* HAVE_GHOSTSCRIPT */
8434 /***********************************************************************
8436 ***********************************************************************/
8440 DEFUN ("imagep", Fimagep
, Simagep
, 1, 1, 0,
8441 doc
: /* Value is non-nil if SPEC is a valid image specification. */)
8445 return valid_image_p (spec
) ? Qt
: Qnil
;
8449 DEFUN ("lookup-image", Flookup_image
, Slookup_image
, 1, 1, 0, "")
8455 if (valid_image_p (spec
))
8456 id
= lookup_image (SELECTED_FRAME (), spec
);
8459 return make_number (id
);
8462 #endif /* GLYPH_DEBUG != 0 */
8465 /***********************************************************************
8467 ***********************************************************************/
8470 /* Image types that rely on external libraries are loaded dynamically
8471 if the library is available. */
8472 #define CHECK_LIB_AVAILABLE(image_type, init_lib_fn, libraries) \
8473 define_image_type (image_type, init_lib_fn (libraries))
8475 #define CHECK_LIB_AVAILABLE(image_type, init_lib_fn, libraries) \
8476 define_image_type (image_type, 1)
8477 #endif /* HAVE_NTGUI */
8479 DEFUN ("init-image-library", Finit_image_library
, Sinit_image_library
, 2, 2, 0,
8480 doc
: /* Initialize image library implementing image type TYPE.
8481 Return non-nil if TYPE is a supported image type.
8483 Image types pbm and xbm are prebuilt; other types are loaded here.
8484 Libraries to load are specified in alist LIBRARIES (usually, the value
8485 of `image-library-alist', which see). */)
8487 Lisp_Object type
, libraries
;
8491 /* Don't try to reload the library. */
8492 tested
= Fassq (type
, Vimage_type_cache
);
8494 return XCDR (tested
);
8496 #if defined (HAVE_XPM) || defined (MAC_OS)
8497 if (EQ (type
, Qxpm
))
8498 return CHECK_LIB_AVAILABLE (&xpm_type
, init_xpm_functions
, libraries
);
8501 #if defined (HAVE_JPEG) || defined (MAC_OS)
8502 if (EQ (type
, Qjpeg
))
8503 return CHECK_LIB_AVAILABLE (&jpeg_type
, init_jpeg_functions
, libraries
);
8506 #if defined (HAVE_TIFF) || defined (MAC_OS)
8507 if (EQ (type
, Qtiff
))
8508 return CHECK_LIB_AVAILABLE (&tiff_type
, init_tiff_functions
, libraries
);
8511 #if defined (HAVE_GIF) || defined (MAC_OS)
8512 if (EQ (type
, Qgif
))
8513 return CHECK_LIB_AVAILABLE (&gif_type
, init_gif_functions
, libraries
);
8516 #if defined (HAVE_PNG) || defined (MAC_OS)
8517 if (EQ (type
, Qpng
))
8518 return CHECK_LIB_AVAILABLE (&png_type
, init_png_functions
, libraries
);
8521 #ifdef HAVE_GHOSTSCRIPT
8522 if (EQ (type
, Qpostscript
))
8523 return CHECK_LIB_AVAILABLE (&gs_type
, init_gs_functions
, libraries
);
8526 /* If the type is not recognized, avoid testing it ever again. */
8527 CACHE_IMAGE_TYPE (type
, Qnil
);
8534 extern Lisp_Object Qrisky_local_variable
; /* Syms_of_xdisp has already run. */
8536 /* Initialize this only once, since that's what we do with Vimage_types
8537 and they are supposed to be in sync. Initializing here gives correct
8538 operation on GNU/Linux of calling dump-emacs after loading some images. */
8541 /* Must be defined now becase we're going to update it below, while
8542 defining the supported image types. */
8543 DEFVAR_LISP ("image-types", &Vimage_types
,
8544 doc
: /* List of potentially supported image types.
8545 Each element of the list is a symbol for a image type, like 'jpeg or 'png.
8546 To check whether it is really supported, use `image-type-available-p'. */);
8547 Vimage_types
= Qnil
;
8549 DEFVAR_LISP ("image-library-alist", &Vimage_library_alist
,
8550 doc
: /* Alist of image types vs external libraries needed to display them.
8552 Each element is a list (IMAGE-TYPE LIBRARY...), where the car is a symbol
8553 representing a supported image type, and the rest are strings giving
8554 alternate filenames for the corresponding external libraries.
8556 Emacs tries to load the libraries in the order they appear on the
8557 list; if none is loaded, the running session of Emacs won't
8558 support the image type. Types 'pbm and 'xbm don't need to be
8559 listed; they're always supported. */);
8560 Vimage_library_alist
= Qnil
;
8561 Fput (intern ("image-library-alist"), Qrisky_local_variable
, Qt
);
8563 DEFVAR_LISP ("max-image-size", &Vmax_image_size
,
8564 doc
: /* Maximum size of images.
8565 Emacs will not load an image into memory if its pixel width or
8566 pixel height exceeds this limit.
8568 If the value is an integer, it directly specifies the maximum
8569 image height and width, measured in pixels. If it is a floating
8570 point number, it specifies the maximum image height and width
8571 as a ratio to the frame height and width. If the value is
8572 non-numeric, there is no explicit limit on the size of images. */);
8573 Vmax_image_size
= make_float (MAX_IMAGE_SIZE
);
8575 Vimage_type_cache
= Qnil
;
8576 staticpro (&Vimage_type_cache
);
8578 Qpbm
= intern ("pbm");
8580 ADD_IMAGE_TYPE(Qpbm
);
8582 Qxbm
= intern ("xbm");
8584 ADD_IMAGE_TYPE(Qxbm
);
8586 define_image_type (&xbm_type
, 1);
8587 define_image_type (&pbm_type
, 1);
8589 QCascent
= intern (":ascent");
8590 staticpro (&QCascent
);
8591 QCmargin
= intern (":margin");
8592 staticpro (&QCmargin
);
8593 QCrelief
= intern (":relief");
8594 staticpro (&QCrelief
);
8595 QCconversion
= intern (":conversion");
8596 staticpro (&QCconversion
);
8597 QCcolor_symbols
= intern (":color-symbols");
8598 staticpro (&QCcolor_symbols
);
8599 QCheuristic_mask
= intern (":heuristic-mask");
8600 staticpro (&QCheuristic_mask
);
8601 QCindex
= intern (":index");
8602 staticpro (&QCindex
);
8603 QCmatrix
= intern (":matrix");
8604 staticpro (&QCmatrix
);
8605 QCcolor_adjustment
= intern (":color-adjustment");
8606 staticpro (&QCcolor_adjustment
);
8607 QCmask
= intern (":mask");
8608 staticpro (&QCmask
);
8610 Qlaplace
= intern ("laplace");
8611 staticpro (&Qlaplace
);
8612 Qemboss
= intern ("emboss");
8613 staticpro (&Qemboss
);
8614 Qedge_detection
= intern ("edge-detection");
8615 staticpro (&Qedge_detection
);
8616 Qheuristic
= intern ("heuristic");
8617 staticpro (&Qheuristic
);
8619 Qpostscript
= intern ("postscript");
8620 staticpro (&Qpostscript
);
8621 #ifdef HAVE_GHOSTSCRIPT
8622 ADD_IMAGE_TYPE(Qpostscript
);
8623 QCloader
= intern (":loader");
8624 staticpro (&QCloader
);
8625 QCbounding_box
= intern (":bounding-box");
8626 staticpro (&QCbounding_box
);
8627 QCpt_width
= intern (":pt-width");
8628 staticpro (&QCpt_width
);
8629 QCpt_height
= intern (":pt-height");
8630 staticpro (&QCpt_height
);
8631 #endif /* HAVE_GHOSTSCRIPT */
8633 #if defined (HAVE_XPM) || defined (MAC_OS)
8634 Qxpm
= intern ("xpm");
8636 ADD_IMAGE_TYPE(Qxpm
);
8639 #if defined (HAVE_JPEG) || defined (MAC_OS)
8640 Qjpeg
= intern ("jpeg");
8642 ADD_IMAGE_TYPE(Qjpeg
);
8645 #if defined (HAVE_TIFF) || defined (MAC_OS)
8646 Qtiff
= intern ("tiff");
8648 ADD_IMAGE_TYPE(Qtiff
);
8651 #if defined (HAVE_GIF) || defined (MAC_OS)
8652 Qgif
= intern ("gif");
8654 ADD_IMAGE_TYPE(Qgif
);
8657 #if defined (HAVE_PNG) || defined (MAC_OS)
8658 Qpng
= intern ("png");
8660 ADD_IMAGE_TYPE(Qpng
);
8663 defsubr (&Sinit_image_library
);
8664 defsubr (&Sclear_image_cache
);
8665 defsubr (&Simage_size
);
8666 defsubr (&Simage_mask_p
);
8667 defsubr (&Simage_extension_data
);
8671 defsubr (&Slookup_image
);
8674 DEFVAR_BOOL ("cross-disabled-images", &cross_disabled_images
,
8675 doc
: /* Non-nil means always draw a cross over disabled images.
8676 Disabled images are those having an `:conversion disabled' property.
8677 A cross is always drawn on black & white displays. */);
8678 cross_disabled_images
= 0;
8680 DEFVAR_LISP ("x-bitmap-file-path", &Vx_bitmap_file_path
,
8681 doc
: /* List of directories to search for window system bitmap files. */);
8682 Vx_bitmap_file_path
= decode_env_path ((char *) 0, PATH_BITMAPS
);
8684 DEFVAR_LISP ("image-cache-eviction-delay", &Vimage_cache_eviction_delay
,
8685 doc
: /* Time after which cached images are removed from the cache.
8686 When an image has not been displayed this many seconds, remove it
8687 from the image cache. Value must be an integer or nil with nil
8688 meaning don't clear the cache. */);
8689 Vimage_cache_eviction_delay
= make_number (30 * 60);
8695 #if defined (MAC_OSX) && TARGET_API_MAC_CARBON
8696 init_image_func_pointer ();
8700 /* arch-tag: 123c2a5e-14a8-4c53-ab95-af47d7db49b9
8701 (do not change this comment) */