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, 2008
4 Free Software Foundation, Inc.
6 This file is part of GNU Emacs.
8 GNU Emacs is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 GNU Emacs is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU Emacs; see the file COPYING. If not, write to
20 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
21 Boston, MA 02110-1301, USA. */
32 /* This makes the fields of a Display accessible, in Xlib header files. */
34 #define XLIB_ILLEGAL_ACCESS
39 #include "dispextern.h"
40 #include "blockinput.h"
49 #include <sys/types.h>
52 #define COLOR_TABLE_SUPPORT 1
54 typedef struct x_bitmap_record Bitmap_Record
;
55 #define GET_PIXEL(ximg, x, y) XGetPixel(ximg, x, y)
56 #define NO_PIXMAP None
58 #define RGB_PIXEL_COLOR unsigned long
60 #define PIX_MASK_RETAIN 0
61 #define PIX_MASK_DRAW 1
62 #endif /* HAVE_X_WINDOWS */
68 /* W32_TODO : Color tables on W32. */
69 #undef COLOR_TABLE_SUPPORT
71 typedef struct w32_bitmap_record Bitmap_Record
;
72 #define GET_PIXEL(ximg, x, y) GetPixel(ximg, x, y)
75 #define RGB_PIXEL_COLOR COLORREF
77 #define PIX_MASK_RETAIN 0
78 #define PIX_MASK_DRAW 1
80 #define FRAME_X_VISUAL(f) FRAME_X_DISPLAY_INFO (f)->visual
81 #define x_defined_color w32_defined_color
82 #define DefaultDepthOfScreen(screen) (one_w32_display_info.n_cbits)
83 #endif /* HAVE_NTGUI */
91 #include <sys/param.h>
93 #if TARGET_API_MAC_CARBON
95 #include <QuickTime/QuickTime.h>
96 #else /* not MAC_OSX */
97 #include <QuickTime.h>
98 #endif /* not MAC_OSX */
99 #else /* not TARGET_API_MAC_CARBON */
102 #include <TextUtils.h>
103 #include <ImageCompression.h>
104 #include <QuickTimeComponents.h>
105 #endif /* not TARGET_API_MAC_CARBON */
107 /* MAC_TODO : Color tables on Mac. */
108 #undef COLOR_TABLE_SUPPORT
110 #define ZPixmap 0 /* arbitrary */
111 typedef struct mac_bitmap_record Bitmap_Record
;
113 #define GET_PIXEL(ximg, x, y) XGetPixel(ximg, x, y)
116 #define RGB_PIXEL_COLOR unsigned long
118 /* A black pixel in a mask bitmap/pixmap means ``draw a source
119 pixel''. A white pixel means ``retain the current pixel''. */
120 #define PIX_MASK_DRAW RGB_TO_ULONG(0,0,0)
121 #define PIX_MASK_RETAIN RGB_TO_ULONG(255,255,255)
123 #define FRAME_X_VISUAL(f) FRAME_X_DISPLAY_INFO (f)->visual
124 #define x_defined_color mac_defined_color
125 #define DefaultDepthOfScreen(screen) (one_mac_display_info.n_planes)
130 /* Search path for bitmap files. */
132 Lisp_Object Vx_bitmap_file_path
;
135 static void x_disable_image
P_ ((struct frame
*, struct image
*));
136 static void x_edge_detection
P_ ((struct frame
*, struct image
*, Lisp_Object
,
139 static void init_color_table
P_ ((void));
140 static unsigned long lookup_rgb_color
P_ ((struct frame
*f
, int r
, int g
, int b
));
141 #ifdef COLOR_TABLE_SUPPORT
142 static void free_color_table
P_ ((void));
143 static unsigned long *colors_in_color_table
P_ ((int *n
));
144 static unsigned long lookup_pixel_color
P_ ((struct frame
*f
, unsigned long p
));
147 /* Code to deal with bitmaps. Bitmaps are referenced by their bitmap
148 id, which is just an int that this section returns. Bitmaps are
149 reference counted so they can be shared among frames.
151 Bitmap indices are guaranteed to be > 0, so a negative number can
152 be used to indicate no bitmap.
154 If you use x_create_bitmap_from_data, then you must keep track of
155 the bitmaps yourself. That is, creating a bitmap from the same
156 data more than once will not be caught. */
161 XGetImage (display
, pixmap
, x
, y
, width
, height
, plane_mask
, format
)
162 Display
*display
; /* not used */
164 int x
, y
; /* not used */
165 unsigned int width
, height
; /* not used */
166 unsigned long plane_mask
; /* not used */
167 int format
; /* not used */
170 xassert (x
== 0 && y
== 0);
173 SetRect (&ri
, 0, 0, width
, height
);
174 xassert (EqualRect (&ri
, GetPixBounds (GetGWorldPixMap (pixmap
), &rp
)));
176 xassert (! (pixelsLocked
& GetPixelsState (GetGWorldPixMap (pixmap
))));
179 LockPixels (GetGWorldPixMap (pixmap
));
185 XPutPixel (ximage
, x
, y
, pixel
)
190 PixMapHandle pixmap
= GetGWorldPixMap (ximage
);
191 short depth
= GetPixDepth (pixmap
);
193 #if defined (WORDS_BIG_ENDIAN) || !USE_CG_DRAWING
196 char *base_addr
= GetPixBaseAddr (pixmap
);
197 short row_bytes
= GetPixRowBytes (pixmap
);
199 ((unsigned long *) (base_addr
+ y
* row_bytes
))[x
] = 0xff000000 | pixel
;
205 char *base_addr
= GetPixBaseAddr (pixmap
);
206 short row_bytes
= GetPixRowBytes (pixmap
);
208 if (pixel
== PIX_MASK_DRAW
)
209 base_addr
[y
* row_bytes
+ x
/ 8] |= (1 << 7) >> (x
& 7);
211 base_addr
[y
* row_bytes
+ x
/ 8] &= ~((1 << 7) >> (x
& 7));
219 GetGWorld (&old_port
, &old_gdh
);
220 SetGWorld (ximage
, NULL
);
222 color
.red
= RED16_FROM_ULONG (pixel
);
223 color
.green
= GREEN16_FROM_ULONG (pixel
);
224 color
.blue
= BLUE16_FROM_ULONG (pixel
);
226 SetCPixel (x
, y
, &color
);
228 SetGWorld (old_port
, old_gdh
);
233 XGetPixel (ximage
, x
, y
)
237 PixMapHandle pixmap
= GetGWorldPixMap (ximage
);
238 short depth
= GetPixDepth (pixmap
);
240 #if defined (WORDS_BIG_ENDIAN) || !USE_CG_DRAWING
243 char *base_addr
= GetPixBaseAddr (pixmap
);
244 short row_bytes
= GetPixRowBytes (pixmap
);
246 return ((unsigned long *) (base_addr
+ y
* row_bytes
))[x
] & 0x00ffffff;
252 char *base_addr
= GetPixBaseAddr (pixmap
);
253 short row_bytes
= GetPixRowBytes (pixmap
);
255 if (base_addr
[y
* row_bytes
+ x
/ 8] & (1 << (~x
& 7)))
256 return PIX_MASK_DRAW
;
258 return PIX_MASK_RETAIN
;
266 GetGWorld (&old_port
, &old_gdh
);
267 SetGWorld (ximage
, NULL
);
269 GetCPixel (x
, y
, &color
);
271 SetGWorld (old_port
, old_gdh
);
272 return RGB_TO_ULONG (color
.red
>> 8, color
.green
>> 8, color
.blue
>> 8);
280 UnlockPixels (GetGWorldPixMap (ximg
));
285 mac_create_cg_image_from_image (f
, img
)
290 CGImageRef result
= NULL
;
297 mask
= XCreatePixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
298 img
->width
, img
->height
, 1);
305 GetGWorld (&old_port
, &old_gdh
);
306 SetGWorld (mask
, NULL
);
307 BackColor (blackColor
); /* Don't mask. */
308 SetRect (&r
, 0, 0, img
->width
, img
->height
);
310 SetGWorld (old_port
, old_gdh
);
315 CreateCGImageFromPixMaps (GetGWorldPixMap (img
->pixmap
),
316 GetGWorldPixMap (mask
), &result
);
317 if (mask
!= img
->mask
)
318 XFreePixmap (FRAME_X_DISPLAY (f
), mask
);
324 #endif /* USE_CG_DRAWING */
328 /* Functions to access the contents of a bitmap, given an id. */
331 x_bitmap_height (f
, id
)
335 return FRAME_X_DISPLAY_INFO (f
)->bitmaps
[id
- 1].height
;
339 x_bitmap_width (f
, id
)
343 return FRAME_X_DISPLAY_INFO (f
)->bitmaps
[id
- 1].width
;
346 #if defined (HAVE_X_WINDOWS) || defined (HAVE_NTGUI)
348 x_bitmap_pixmap (f
, id
)
352 return (int) FRAME_X_DISPLAY_INFO (f
)->bitmaps
[id
- 1].pixmap
;
356 #ifdef HAVE_X_WINDOWS
358 x_bitmap_mask (f
, id
)
362 return FRAME_X_DISPLAY_INFO (f
)->bitmaps
[id
- 1].mask
;
366 /* Allocate a new bitmap record. Returns index of new record. */
369 x_allocate_bitmap_record (f
)
372 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
375 if (dpyinfo
->bitmaps
== NULL
)
377 dpyinfo
->bitmaps_size
= 10;
379 = (Bitmap_Record
*) xmalloc (dpyinfo
->bitmaps_size
* sizeof (Bitmap_Record
));
380 dpyinfo
->bitmaps_last
= 1;
384 if (dpyinfo
->bitmaps_last
< dpyinfo
->bitmaps_size
)
385 return ++dpyinfo
->bitmaps_last
;
387 for (i
= 0; i
< dpyinfo
->bitmaps_size
; ++i
)
388 if (dpyinfo
->bitmaps
[i
].refcount
== 0)
391 dpyinfo
->bitmaps_size
*= 2;
393 = (Bitmap_Record
*) xrealloc (dpyinfo
->bitmaps
,
394 dpyinfo
->bitmaps_size
* sizeof (Bitmap_Record
));
395 return ++dpyinfo
->bitmaps_last
;
398 /* Add one reference to the reference count of the bitmap with id ID. */
401 x_reference_bitmap (f
, id
)
405 ++FRAME_X_DISPLAY_INFO (f
)->bitmaps
[id
- 1].refcount
;
408 /* Create a bitmap for frame F from a HEIGHT x WIDTH array of bits at BITS. */
411 x_create_bitmap_from_data (f
, bits
, width
, height
)
414 unsigned int width
, height
;
416 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
419 #ifdef HAVE_X_WINDOWS
421 bitmap
= XCreateBitmapFromData (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
422 bits
, width
, height
);
425 #endif /* HAVE_X_WINDOWS */
429 bitmap
= CreateBitmap (width
, height
,
430 FRAME_X_DISPLAY_INFO (XFRAME (frame
))->n_planes
,
431 FRAME_X_DISPLAY_INFO (XFRAME (frame
))->n_cbits
,
435 #endif /* HAVE_NTGUI */
438 /* MAC_TODO: for now fail if width is not mod 16 (toolbox requires it) */
443 id
= x_allocate_bitmap_record (f
);
445 dpyinfo
->bitmaps
[id
- 1].bitmap_data
= (char *) xmalloc (height
* width
);
446 bcopy (bits
, dpyinfo
->bitmaps
[id
- 1].bitmap_data
, height
* width
);
449 dpyinfo
->bitmaps
[id
- 1].file
= NULL
;
450 dpyinfo
->bitmaps
[id
- 1].height
= height
;
451 dpyinfo
->bitmaps
[id
- 1].width
= width
;
452 dpyinfo
->bitmaps
[id
- 1].refcount
= 1;
454 #ifdef HAVE_X_WINDOWS
455 dpyinfo
->bitmaps
[id
- 1].pixmap
= bitmap
;
456 dpyinfo
->bitmaps
[id
- 1].have_mask
= 0;
457 dpyinfo
->bitmaps
[id
- 1].depth
= 1;
458 #endif /* HAVE_X_WINDOWS */
461 dpyinfo
->bitmaps
[id
- 1].pixmap
= bitmap
;
462 dpyinfo
->bitmaps
[id
- 1].hinst
= NULL
;
463 dpyinfo
->bitmaps
[id
- 1].depth
= 1;
464 #endif /* HAVE_NTGUI */
469 /* Create bitmap from file FILE for frame F. */
472 x_create_bitmap_from_file (f
, file
)
477 return -1; /* MAC_TODO : bitmap support */
481 return -1; /* W32_TODO : bitmap support */
482 #endif /* HAVE_NTGUI */
484 #ifdef HAVE_X_WINDOWS
485 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
486 unsigned int width
, height
;
488 int xhot
, yhot
, result
, id
;
493 /* Look for an existing bitmap with the same name. */
494 for (id
= 0; id
< dpyinfo
->bitmaps_last
; ++id
)
496 if (dpyinfo
->bitmaps
[id
].refcount
497 && dpyinfo
->bitmaps
[id
].file
498 && !strcmp (dpyinfo
->bitmaps
[id
].file
, (char *) SDATA (file
)))
500 ++dpyinfo
->bitmaps
[id
].refcount
;
505 /* Search bitmap-file-path for the file, if appropriate. */
506 fd
= openp (Vx_bitmap_file_path
, file
, Qnil
, &found
, Qnil
);
511 filename
= (char *) SDATA (found
);
513 result
= XReadBitmapFile (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
514 filename
, &width
, &height
, &bitmap
, &xhot
, &yhot
);
515 if (result
!= BitmapSuccess
)
518 id
= x_allocate_bitmap_record (f
);
519 dpyinfo
->bitmaps
[id
- 1].pixmap
= bitmap
;
520 dpyinfo
->bitmaps
[id
- 1].have_mask
= 0;
521 dpyinfo
->bitmaps
[id
- 1].refcount
= 1;
522 dpyinfo
->bitmaps
[id
- 1].file
= (char *) xmalloc (SBYTES (file
) + 1);
523 dpyinfo
->bitmaps
[id
- 1].depth
= 1;
524 dpyinfo
->bitmaps
[id
- 1].height
= height
;
525 dpyinfo
->bitmaps
[id
- 1].width
= width
;
526 strcpy (dpyinfo
->bitmaps
[id
- 1].file
, SDATA (file
));
529 #endif /* HAVE_X_WINDOWS */
535 Free_Bitmap_Record (dpyinfo
, bm
)
536 Display_Info
*dpyinfo
;
539 #ifdef HAVE_X_WINDOWS
540 XFreePixmap (dpyinfo
->display
, bm
->pixmap
);
542 XFreePixmap (dpyinfo
->display
, bm
->mask
);
543 #endif /* HAVE_X_WINDOWS */
546 DeleteObject (bm
->pixmap
);
547 #endif /* HAVE_NTGUI */
550 xfree (bm
->bitmap_data
); /* Added ++kfs */
551 bm
->bitmap_data
= NULL
;
561 /* Remove reference to bitmap with id number ID. */
564 x_destroy_bitmap (f
, id
)
568 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
572 Bitmap_Record
*bm
= &dpyinfo
->bitmaps
[id
- 1];
574 if (--bm
->refcount
== 0)
577 Free_Bitmap_Record (dpyinfo
, bm
);
583 /* Free all the bitmaps for the display specified by DPYINFO. */
586 x_destroy_all_bitmaps (dpyinfo
)
587 Display_Info
*dpyinfo
;
590 Bitmap_Record
*bm
= dpyinfo
->bitmaps
;
592 for (i
= 0; i
< dpyinfo
->bitmaps_last
; i
++, bm
++)
593 if (bm
->refcount
> 0)
594 Free_Bitmap_Record (dpyinfo
, bm
);
596 dpyinfo
->bitmaps_last
= 0;
600 #ifdef HAVE_X_WINDOWS
602 /* Useful functions defined in the section
603 `Image type independent image structures' below. */
605 static unsigned long four_corners_best
P_ ((XImagePtr ximg
,
608 unsigned long height
));
610 static int x_create_x_image_and_pixmap
P_ ((struct frame
*f
, int width
, int height
,
611 int depth
, XImagePtr
*ximg
,
614 static void x_destroy_x_image
P_ ((XImagePtr ximg
));
617 /* Create a mask of a bitmap. Note is this not a perfect mask.
618 It's nicer with some borders in this context */
621 x_create_bitmap_mask (f
, id
)
626 XImagePtr ximg
, mask_img
;
627 unsigned long width
, height
;
630 unsigned long x
, y
, xp
, xm
, yp
, ym
;
633 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
638 pixmap
= x_bitmap_pixmap (f
, id
);
639 width
= x_bitmap_width (f
, id
);
640 height
= x_bitmap_height (f
, id
);
643 ximg
= XGetImage (FRAME_X_DISPLAY (f
), pixmap
, 0, 0, width
, height
,
652 result
= x_create_x_image_and_pixmap (f
, width
, height
, 1, &mask_img
, &mask
);
657 XDestroyImage (ximg
);
661 bg
= four_corners_best (ximg
, NULL
, width
, height
);
663 for (y
= 0; y
< ximg
->height
; ++y
)
665 for (x
= 0; x
< ximg
->width
; ++x
)
667 xp
= x
!= ximg
->width
- 1 ? x
+ 1 : 0;
668 xm
= x
!= 0 ? x
- 1 : ximg
->width
- 1;
669 yp
= y
!= ximg
->height
- 1 ? y
+ 1 : 0;
670 ym
= y
!= 0 ? y
- 1 : ximg
->height
- 1;
671 if (XGetPixel (ximg
, x
, y
) == bg
672 && XGetPixel (ximg
, x
, yp
) == bg
673 && XGetPixel (ximg
, x
, ym
) == bg
674 && XGetPixel (ximg
, xp
, y
) == bg
675 && XGetPixel (ximg
, xp
, yp
) == bg
676 && XGetPixel (ximg
, xp
, ym
) == bg
677 && XGetPixel (ximg
, xm
, y
) == bg
678 && XGetPixel (ximg
, xm
, yp
) == bg
679 && XGetPixel (ximg
, xm
, ym
) == bg
)
680 XPutPixel (mask_img
, x
, y
, 0);
682 XPutPixel (mask_img
, x
, y
, 1);
686 xassert (interrupt_input_blocked
);
687 gc
= XCreateGC (FRAME_X_DISPLAY (f
), mask
, 0, NULL
);
688 XPutImage (FRAME_X_DISPLAY (f
), mask
, gc
, mask_img
, 0, 0, 0, 0,
690 XFreeGC (FRAME_X_DISPLAY (f
), gc
);
692 dpyinfo
->bitmaps
[id
- 1].have_mask
= 1;
693 dpyinfo
->bitmaps
[id
- 1].mask
= mask
;
695 XDestroyImage (ximg
);
696 x_destroy_x_image (mask_img
);
701 #endif /* HAVE_X_WINDOWS */
704 /***********************************************************************
706 ***********************************************************************/
708 /* Value is the number of elements of vector VECTOR. */
710 #define DIM(VECTOR) (sizeof (VECTOR) / sizeof *(VECTOR))
712 /* List of supported image types. Use define_image_type to add new
713 types. Use lookup_image_type to find a type for a given symbol. */
715 static struct image_type
*image_types
;
717 /* A list of symbols, one for each supported image type. */
719 Lisp_Object Vimage_types
;
721 /* An alist of image types and libraries that implement the type. */
723 Lisp_Object Vimage_library_alist
;
725 /* Cache for delayed-loading image types. */
727 static Lisp_Object Vimage_type_cache
;
729 /* The symbol `xbm' which is used as the type symbol for XBM images. */
735 extern Lisp_Object QCwidth
, QCheight
, QCforeground
, QCbackground
, QCfile
;
736 extern Lisp_Object QCdata
, QCtype
, Qcount
;
737 extern Lisp_Object Qcenter
;
738 Lisp_Object QCascent
, QCmargin
, QCrelief
;
739 Lisp_Object QCconversion
, QCcolor_symbols
, QCheuristic_mask
;
740 Lisp_Object QCindex
, QCmatrix
, QCcolor_adjustment
, QCmask
;
744 Lisp_Object Qlaplace
, Qemboss
, Qedge_detection
, Qheuristic
;
746 /* Time in seconds after which images should be removed from the cache
749 Lisp_Object Vimage_cache_eviction_delay
;
751 /* Function prototypes. */
753 static Lisp_Object define_image_type
P_ ((struct image_type
*type
, int loaded
));
754 static struct image_type
*lookup_image_type
P_ ((Lisp_Object symbol
));
755 static void image_error
P_ ((char *format
, Lisp_Object
, Lisp_Object
));
756 static void x_laplace
P_ ((struct frame
*, struct image
*));
757 static void x_emboss
P_ ((struct frame
*, struct image
*));
758 static int x_build_heuristic_mask
P_ ((struct frame
*, struct image
*,
761 #define CACHE_IMAGE_TYPE(type, status) \
762 do { Vimage_type_cache = Fcons (Fcons (type, status), Vimage_type_cache); } while (0)
764 #define ADD_IMAGE_TYPE(type) \
765 do { Vimage_types = Fcons (type, Vimage_types); } while (0)
767 /* Define a new image type from TYPE. This adds a copy of TYPE to
768 image_types and caches the loading status of TYPE. */
771 define_image_type (type
, loaded
)
772 struct image_type
*type
;
781 /* Make a copy of TYPE to avoid a bus error in a dumped Emacs.
782 The initialized data segment is read-only. */
783 struct image_type
*p
= (struct image_type
*) xmalloc (sizeof *p
);
784 bcopy (type
, p
, sizeof *p
);
785 p
->next
= image_types
;
790 CACHE_IMAGE_TYPE (*type
->type
, success
);
795 /* Look up image type SYMBOL, and return a pointer to its image_type
796 structure. Value is null if SYMBOL is not a known image type. */
798 static INLINE
struct image_type
*
799 lookup_image_type (symbol
)
802 struct image_type
*type
;
804 /* We must initialize the image-type if it hasn't been already. */
805 if (NILP (Finit_image_library (symbol
, Vimage_library_alist
)))
806 return 0; /* unimplemented */
808 for (type
= image_types
; type
; type
= type
->next
)
809 if (EQ (symbol
, *type
->type
))
816 /* Value is non-zero if OBJECT is a valid Lisp image specification. A
817 valid image specification is a list whose car is the symbol
818 `image', and whose rest is a property list. The property list must
819 contain a value for key `:type'. That value must be the name of a
820 supported image type. The rest of the property list depends on the
824 valid_image_p (object
)
833 for (tem
= XCDR (object
); CONSP (tem
); tem
= XCDR (tem
))
834 if (EQ (XCAR (tem
), QCtype
))
837 if (CONSP (tem
) && SYMBOLP (XCAR (tem
)))
839 struct image_type
*type
;
840 type
= lookup_image_type (XCAR (tem
));
842 valid_p
= type
->valid_p (object
);
853 /* Log error message with format string FORMAT and argument ARG.
854 Signaling an error, e.g. when an image cannot be loaded, is not a
855 good idea because this would interrupt redisplay, and the error
856 message display would lead to another redisplay. This function
857 therefore simply displays a message. */
860 image_error (format
, arg1
, arg2
)
862 Lisp_Object arg1
, arg2
;
864 add_to_log (format
, arg1
, arg2
);
869 /***********************************************************************
871 ***********************************************************************/
873 enum image_value_type
875 IMAGE_DONT_CHECK_VALUE_TYPE
,
877 IMAGE_STRING_OR_NIL_VALUE
,
879 IMAGE_POSITIVE_INTEGER_VALUE
,
880 IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
,
881 IMAGE_NON_NEGATIVE_INTEGER_VALUE
,
884 IMAGE_FUNCTION_VALUE
,
889 /* Structure used when parsing image specifications. */
893 /* Name of keyword. */
896 /* The type of value allowed. */
897 enum image_value_type type
;
899 /* Non-zero means key must be present. */
902 /* Used to recognize duplicate keywords in a property list. */
905 /* The value that was found. */
910 static int parse_image_spec
P_ ((Lisp_Object
, struct image_keyword
*,
912 static Lisp_Object image_spec_value
P_ ((Lisp_Object
, Lisp_Object
, int *));
915 /* Parse image spec SPEC according to KEYWORDS. A valid image spec
916 has the format (image KEYWORD VALUE ...). One of the keyword/
917 value pairs must be `:type TYPE'. KEYWORDS is a vector of
918 image_keywords structures of size NKEYWORDS describing other
919 allowed keyword/value pairs. Value is non-zero if SPEC is valid. */
922 parse_image_spec (spec
, keywords
, nkeywords
, type
)
924 struct image_keyword
*keywords
;
935 while (CONSP (plist
))
937 Lisp_Object key
, value
;
939 /* First element of a pair must be a symbol. */
941 plist
= XCDR (plist
);
945 /* There must follow a value. */
948 value
= XCAR (plist
);
949 plist
= XCDR (plist
);
951 /* Find key in KEYWORDS. Error if not found. */
952 for (i
= 0; i
< nkeywords
; ++i
)
953 if (strcmp (keywords
[i
].name
, SDATA (SYMBOL_NAME (key
))) == 0)
959 /* Record that we recognized the keyword. If a keywords
960 was found more than once, it's an error. */
961 keywords
[i
].value
= value
;
964 if (keywords
[i
].count
> 1)
967 /* Check type of value against allowed type. */
968 switch (keywords
[i
].type
)
970 case IMAGE_STRING_VALUE
:
971 if (!STRINGP (value
))
975 case IMAGE_STRING_OR_NIL_VALUE
:
976 if (!STRINGP (value
) && !NILP (value
))
980 case IMAGE_SYMBOL_VALUE
:
981 if (!SYMBOLP (value
))
985 case IMAGE_POSITIVE_INTEGER_VALUE
:
986 if (!INTEGERP (value
) || XINT (value
) <= 0)
990 case IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
:
991 if (INTEGERP (value
) && XINT (value
) >= 0)
994 && INTEGERP (XCAR (value
)) && INTEGERP (XCDR (value
))
995 && XINT (XCAR (value
)) >= 0 && XINT (XCDR (value
)) >= 0)
999 case IMAGE_ASCENT_VALUE
:
1000 if (SYMBOLP (value
) && EQ (value
, Qcenter
))
1002 else if (INTEGERP (value
)
1003 && XINT (value
) >= 0
1004 && XINT (value
) <= 100)
1008 case IMAGE_NON_NEGATIVE_INTEGER_VALUE
:
1009 if (!INTEGERP (value
) || XINT (value
) < 0)
1013 case IMAGE_DONT_CHECK_VALUE_TYPE
:
1016 case IMAGE_FUNCTION_VALUE
:
1017 value
= indirect_function (value
);
1019 || COMPILEDP (value
)
1020 || (CONSP (value
) && EQ (XCAR (value
), Qlambda
)))
1024 case IMAGE_NUMBER_VALUE
:
1025 if (!INTEGERP (value
) && !FLOATP (value
))
1029 case IMAGE_INTEGER_VALUE
:
1030 if (!INTEGERP (value
))
1034 case IMAGE_BOOL_VALUE
:
1035 if (!NILP (value
) && !EQ (value
, Qt
))
1044 if (EQ (key
, QCtype
) && !EQ (type
, value
))
1048 /* Check that all mandatory fields are present. */
1049 for (i
= 0; i
< nkeywords
; ++i
)
1050 if (keywords
[i
].mandatory_p
&& keywords
[i
].count
== 0)
1053 return NILP (plist
);
1057 /* Return the value of KEY in image specification SPEC. Value is nil
1058 if KEY is not present in SPEC. if FOUND is not null, set *FOUND
1059 to 1 if KEY was found in SPEC, set it to 0 otherwise. */
1062 image_spec_value (spec
, key
, found
)
1063 Lisp_Object spec
, key
;
1068 xassert (valid_image_p (spec
));
1070 for (tail
= XCDR (spec
);
1071 CONSP (tail
) && CONSP (XCDR (tail
));
1072 tail
= XCDR (XCDR (tail
)))
1074 if (EQ (XCAR (tail
), key
))
1078 return XCAR (XCDR (tail
));
1088 DEFUN ("image-size", Fimage_size
, Simage_size
, 1, 3, 0,
1089 doc
: /* Return the size of image SPEC as pair (WIDTH . HEIGHT).
1090 PIXELS non-nil means return the size in pixels, otherwise return the
1091 size in canonical character units.
1092 FRAME is the frame on which the image will be displayed. FRAME nil
1093 or omitted means use the selected frame. */)
1094 (spec
, pixels
, frame
)
1095 Lisp_Object spec
, pixels
, frame
;
1100 if (valid_image_p (spec
))
1102 struct frame
*f
= check_x_frame (frame
);
1103 int id
= lookup_image (f
, spec
);
1104 struct image
*img
= IMAGE_FROM_ID (f
, id
);
1105 int width
= img
->width
+ 2 * img
->hmargin
;
1106 int height
= img
->height
+ 2 * img
->vmargin
;
1109 size
= Fcons (make_float ((double) width
/ FRAME_COLUMN_WIDTH (f
)),
1110 make_float ((double) height
/ FRAME_LINE_HEIGHT (f
)));
1112 size
= Fcons (make_number (width
), make_number (height
));
1115 error ("Invalid image specification");
1121 DEFUN ("image-mask-p", Fimage_mask_p
, Simage_mask_p
, 1, 2, 0,
1122 doc
: /* Return t if image SPEC has a mask bitmap.
1123 FRAME is the frame on which the image will be displayed. FRAME nil
1124 or omitted means use the selected frame. */)
1126 Lisp_Object spec
, frame
;
1131 if (valid_image_p (spec
))
1133 struct frame
*f
= check_x_frame (frame
);
1134 int id
= lookup_image (f
, spec
);
1135 struct image
*img
= IMAGE_FROM_ID (f
, id
);
1140 error ("Invalid image specification");
1145 DEFUN ("image-extension-data", Fimage_extension_data
, Simage_extension_data
, 1, 2, 0,
1146 doc
: /* Return extension data for image SPEC.
1147 FRAME is the frame on which the image will be displayed. FRAME nil
1148 or omitted means use the selected frame. */)
1150 Lisp_Object spec
, frame
;
1155 if (valid_image_p (spec
))
1157 struct frame
*f
= check_x_frame (frame
);
1158 int id
= lookup_image (f
, spec
);
1159 struct image
*img
= IMAGE_FROM_ID (f
, id
);
1160 ext
= img
->data
.lisp_val
;
1167 /***********************************************************************
1168 Image type independent image structures
1169 ***********************************************************************/
1171 static struct image
*make_image
P_ ((Lisp_Object spec
, unsigned hash
));
1172 static void free_image
P_ ((struct frame
*f
, struct image
*img
));
1173 static int check_image_size
P_ ((struct frame
*f
, int width
, int height
));
1175 #define MAX_IMAGE_SIZE 6.0
1176 Lisp_Object Vmax_image_size
;
1178 /* Allocate and return a new image structure for image specification
1179 SPEC. SPEC has a hash value of HASH. */
1181 static struct image
*
1182 make_image (spec
, hash
)
1186 struct image
*img
= (struct image
*) xmalloc (sizeof *img
);
1188 xassert (valid_image_p (spec
));
1189 bzero (img
, sizeof *img
);
1190 img
->type
= lookup_image_type (image_spec_value (spec
, QCtype
, NULL
));
1191 xassert (img
->type
!= NULL
);
1193 img
->data
.lisp_val
= Qnil
;
1194 img
->ascent
= DEFAULT_IMAGE_ASCENT
;
1196 img
->corners
[BOT_CORNER
] = -1; /* Full image */
1201 /* Free image IMG which was used on frame F, including its resources. */
1210 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
1212 /* Remove IMG from the hash table of its cache. */
1214 img
->prev
->next
= img
->next
;
1216 c
->buckets
[img
->hash
% IMAGE_CACHE_BUCKETS_SIZE
] = img
->next
;
1219 img
->next
->prev
= img
->prev
;
1221 c
->images
[img
->id
] = NULL
;
1223 /* Free resources, then free IMG. */
1224 img
->type
->free (f
, img
);
1229 /* Return 1 if the given widths and heights are valid for display;
1230 otherwise, return 0. */
1233 check_image_size (f
, width
, height
)
1240 if (width
<= 0 || height
<= 0)
1243 if (INTEGERP (Vmax_image_size
))
1244 w
= h
= XINT (Vmax_image_size
);
1245 else if (FLOATP (Vmax_image_size
))
1249 w
= FRAME_PIXEL_WIDTH (f
);
1250 h
= FRAME_PIXEL_HEIGHT (f
);
1253 w
= h
= 1024; /* Arbitrary size for unknown frame. */
1254 w
= (int) (XFLOAT_DATA (Vmax_image_size
) * w
);
1255 h
= (int) (XFLOAT_DATA (Vmax_image_size
) * h
);
1260 return (width
<= w
&& height
<= h
);
1263 /* Prepare image IMG for display on frame F. Must be called before
1264 drawing an image. */
1267 prepare_image_for_display (f
, img
)
1273 /* We're about to display IMG, so set its timestamp to `now'. */
1275 img
->timestamp
= EMACS_SECS (t
);
1277 /* If IMG doesn't have a pixmap yet, load it now, using the image
1278 type dependent loader function. */
1279 if (img
->pixmap
== NO_PIXMAP
&& !img
->load_failed_p
)
1280 img
->load_failed_p
= img
->type
->load (f
, img
) == 0;
1282 #if defined (MAC_OS) && USE_CG_DRAWING
1283 if (!img
->load_failed_p
&& img
->data
.ptr_val
== NULL
)
1285 img
->data
.ptr_val
= mac_create_cg_image_from_image (f
, img
);
1286 if (img
->data
.ptr_val
== NULL
)
1288 img
->load_failed_p
= 1;
1289 img
->type
->free (f
, img
);
1296 /* Value is the number of pixels for the ascent of image IMG when
1297 drawn in face FACE. */
1300 image_ascent (img
, face
, slice
)
1303 struct glyph_slice
*slice
;
1308 if (slice
->height
== img
->height
)
1309 height
= img
->height
+ img
->vmargin
;
1310 else if (slice
->y
== 0)
1311 height
= slice
->height
+ img
->vmargin
;
1313 height
= slice
->height
;
1315 if (img
->ascent
== CENTERED_IMAGE_ASCENT
)
1320 /* W32 specific version. Why?. ++kfs */
1321 ascent
= height
/ 2 - (FONT_DESCENT(face
->font
)
1322 - FONT_BASE(face
->font
)) / 2;
1324 /* This expression is arranged so that if the image can't be
1325 exactly centered, it will be moved slightly up. This is
1326 because a typical font is `top-heavy' (due to the presence
1327 uppercase letters), so the image placement should err towards
1328 being top-heavy too. It also just generally looks better. */
1329 ascent
= (height
+ face
->font
->ascent
- face
->font
->descent
+ 1) / 2;
1330 #endif /* HAVE_NTGUI */
1333 ascent
= height
/ 2;
1336 ascent
= (int) (height
* img
->ascent
/ 100.0);
1342 /* Image background colors. */
1344 /* Find the "best" corner color of a bitmap.
1345 On W32, XIMG is assumed to a device context with the bitmap selected. */
1347 static RGB_PIXEL_COLOR
1348 four_corners_best (ximg
, corners
, width
, height
)
1349 XImagePtr_or_DC ximg
;
1351 unsigned long width
, height
;
1353 RGB_PIXEL_COLOR corner_pixels
[4], best
;
1356 if (corners
&& corners
[BOT_CORNER
] >= 0)
1358 /* Get the colors at the corner_pixels of ximg. */
1359 corner_pixels
[0] = GET_PIXEL (ximg
, corners
[LEFT_CORNER
], corners
[TOP_CORNER
]);
1360 corner_pixels
[1] = GET_PIXEL (ximg
, corners
[RIGHT_CORNER
] - 1, corners
[TOP_CORNER
]);
1361 corner_pixels
[2] = GET_PIXEL (ximg
, corners
[RIGHT_CORNER
] - 1, corners
[BOT_CORNER
] - 1);
1362 corner_pixels
[3] = GET_PIXEL (ximg
, corners
[LEFT_CORNER
], corners
[BOT_CORNER
] - 1);
1366 /* Get the colors at the corner_pixels of ximg. */
1367 corner_pixels
[0] = GET_PIXEL (ximg
, 0, 0);
1368 corner_pixels
[1] = GET_PIXEL (ximg
, width
- 1, 0);
1369 corner_pixels
[2] = GET_PIXEL (ximg
, width
- 1, height
- 1);
1370 corner_pixels
[3] = GET_PIXEL (ximg
, 0, height
- 1);
1372 /* Choose the most frequently found color as background. */
1373 for (i
= best_count
= 0; i
< 4; ++i
)
1377 for (j
= n
= 0; j
< 4; ++j
)
1378 if (corner_pixels
[i
] == corner_pixels
[j
])
1382 best
= corner_pixels
[i
], best_count
= n
;
1388 /* Portability macros */
1392 #define Destroy_Image(img_dc, prev) \
1393 do { SelectObject (img_dc, prev); DeleteDC (img_dc); } while (0)
1395 #define Free_Pixmap(display, pixmap) \
1396 DeleteObject (pixmap)
1400 #define Destroy_Image(ximg, dummy) \
1401 XDestroyImage (ximg)
1403 #define Free_Pixmap(display, pixmap) \
1404 XFreePixmap (display, pixmap)
1406 #endif /* HAVE_NTGUI */
1409 /* Return the `background' field of IMG. If IMG doesn't have one yet,
1410 it is guessed heuristically. If non-zero, XIMG is an existing
1411 XImage object (or device context with the image selected on W32) to
1412 use for the heuristic. */
1415 image_background (img
, f
, ximg
)
1418 XImagePtr_or_DC ximg
;
1420 if (! img
->background_valid
)
1421 /* IMG doesn't have a background yet, try to guess a reasonable value. */
1423 int free_ximg
= !ximg
;
1426 #endif /* HAVE_NTGUI */
1431 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
1432 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
1434 HDC frame_dc
= get_frame_dc (f
);
1435 ximg
= CreateCompatibleDC (frame_dc
);
1436 release_frame_dc (f
, frame_dc
);
1437 prev
= SelectObject (ximg
, img
->pixmap
);
1438 #endif /* !HAVE_NTGUI */
1441 img
->background
= four_corners_best (ximg
, img
->corners
, img
->width
, img
->height
);
1444 Destroy_Image (ximg
, prev
);
1446 img
->background_valid
= 1;
1449 return img
->background
;
1452 /* Return the `background_transparent' field of IMG. If IMG doesn't
1453 have one yet, it is guessed heuristically. If non-zero, MASK is an
1454 existing XImage object to use for the heuristic. */
1457 image_background_transparent (img
, f
, mask
)
1460 XImagePtr_or_DC mask
;
1462 if (! img
->background_transparent_valid
)
1463 /* IMG doesn't have a background yet, try to guess a reasonable value. */
1467 int free_mask
= !mask
;
1470 #endif /* HAVE_NTGUI */
1475 mask
= XGetImage (FRAME_X_DISPLAY (f
), img
->mask
,
1476 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
1478 HDC frame_dc
= get_frame_dc (f
);
1479 mask
= CreateCompatibleDC (frame_dc
);
1480 release_frame_dc (f
, frame_dc
);
1481 prev
= SelectObject (mask
, img
->mask
);
1482 #endif /* HAVE_NTGUI */
1485 img
->background_transparent
1486 = (four_corners_best (mask
, img
->corners
, img
->width
, img
->height
) == PIX_MASK_RETAIN
);
1489 Destroy_Image (mask
, prev
);
1492 img
->background_transparent
= 0;
1494 img
->background_transparent_valid
= 1;
1497 return img
->background_transparent
;
1501 /***********************************************************************
1502 Helper functions for X image types
1503 ***********************************************************************/
1505 static void x_clear_image_1
P_ ((struct frame
*, struct image
*, int,
1507 static void x_clear_image
P_ ((struct frame
*f
, struct image
*img
));
1508 static unsigned long x_alloc_image_color
P_ ((struct frame
*f
,
1510 Lisp_Object color_name
,
1511 unsigned long dflt
));
1514 /* Clear X resources of image IMG on frame F. PIXMAP_P non-zero means
1515 free the pixmap if any. MASK_P non-zero means clear the mask
1516 pixmap if any. COLORS_P non-zero means free colors allocated for
1517 the image, if any. */
1520 x_clear_image_1 (f
, img
, pixmap_p
, mask_p
, colors_p
)
1523 int pixmap_p
, mask_p
, colors_p
;
1525 if (pixmap_p
&& img
->pixmap
)
1527 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->pixmap
);
1528 img
->pixmap
= NO_PIXMAP
;
1529 img
->background_valid
= 0;
1532 if (mask_p
&& img
->mask
)
1534 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
1535 img
->mask
= NO_PIXMAP
;
1536 img
->background_transparent_valid
= 0;
1539 if (colors_p
&& img
->ncolors
)
1541 /* MAC_TODO: color table support. */
1542 /* W32_TODO: color table support. */
1543 #ifdef HAVE_X_WINDOWS
1544 x_free_colors (f
, img
->colors
, img
->ncolors
);
1545 #endif /* HAVE_X_WINDOWS */
1546 xfree (img
->colors
);
1551 #if defined (MAC_OS) && USE_CG_DRAWING
1552 if (img
->data
.ptr_val
)
1554 CGImageRelease (img
->data
.ptr_val
);
1555 img
->data
.ptr_val
= NULL
;
1560 /* Free X resources of image IMG which is used on frame F. */
1563 x_clear_image (f
, img
)
1568 x_clear_image_1 (f
, img
, 1, 1, 1);
1573 /* Allocate color COLOR_NAME for image IMG on frame F. If color
1574 cannot be allocated, use DFLT. Add a newly allocated color to
1575 IMG->colors, so that it can be freed again. Value is the pixel
1578 static unsigned long
1579 x_alloc_image_color (f
, img
, color_name
, dflt
)
1582 Lisp_Object color_name
;
1586 unsigned long result
;
1588 xassert (STRINGP (color_name
));
1590 if (x_defined_color (f
, SDATA (color_name
), &color
, 1))
1592 /* This isn't called frequently so we get away with simply
1593 reallocating the color vector to the needed size, here. */
1596 (unsigned long *) xrealloc (img
->colors
,
1597 img
->ncolors
* sizeof *img
->colors
);
1598 img
->colors
[img
->ncolors
- 1] = color
.pixel
;
1599 result
= color
.pixel
;
1609 /***********************************************************************
1611 ***********************************************************************/
1613 static struct image
*search_image_cache
P_ ((struct frame
*, Lisp_Object
, unsigned));
1614 static void cache_image
P_ ((struct frame
*f
, struct image
*img
));
1615 static void postprocess_image
P_ ((struct frame
*, struct image
*));
1617 /* Return a new, initialized image cache that is allocated from the
1618 heap. Call free_image_cache to free an image cache. */
1620 struct image_cache
*
1623 struct image_cache
*c
= (struct image_cache
*) xmalloc (sizeof *c
);
1626 bzero (c
, sizeof *c
);
1628 c
->images
= (struct image
**) xmalloc (c
->size
* sizeof *c
->images
);
1629 size
= IMAGE_CACHE_BUCKETS_SIZE
* sizeof *c
->buckets
;
1630 c
->buckets
= (struct image
**) xmalloc (size
);
1631 bzero (c
->buckets
, size
);
1636 /* Find an image matching SPEC in the cache, and return it. If no
1637 image is found, return NULL. */
1638 static struct image
*
1639 search_image_cache (f
, spec
, hash
)
1645 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
1646 int i
= hash
% IMAGE_CACHE_BUCKETS_SIZE
;
1648 if (!c
) return NULL
;
1650 /* If the image spec does not specify a background color, the cached
1651 image must have the same background color as the current frame.
1652 The foreground color must also match, for the sake of monochrome
1655 In fact, we could ignore the foreground color matching condition
1656 for color images, or if the image spec specifies :foreground;
1657 similarly we could ignore the background color matching condition
1658 for formats that don't use transparency (such as jpeg), or if the
1659 image spec specifies :background. However, the extra memory
1660 usage is probably negligible in practice, so we don't bother. */
1662 for (img
= c
->buckets
[i
]; img
; img
= img
->next
)
1663 if (img
->hash
== hash
1664 && !NILP (Fequal (img
->spec
, spec
))
1665 && img
->frame_foreground
== FRAME_FOREGROUND_PIXEL (f
)
1666 && img
->frame_background
== FRAME_BACKGROUND_PIXEL (f
))
1672 /* Search frame F for an image with spec SPEC, and free it. */
1675 uncache_image (f
, spec
)
1679 struct image
*img
= search_image_cache (f
, spec
, sxhash (spec
, 0));
1681 free_image (f
, img
);
1685 /* Free image cache of frame F. Be aware that X frames share images
1689 free_image_cache (f
)
1692 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
1697 /* Cache should not be referenced by any frame when freed. */
1698 xassert (c
->refcount
== 0);
1700 for (i
= 0; i
< c
->used
; ++i
)
1701 free_image (f
, c
->images
[i
]);
1705 FRAME_X_IMAGE_CACHE (f
) = NULL
;
1710 /* Clear image cache of frame F. FORCE_P non-zero means free all
1711 images. FORCE_P zero means clear only images that haven't been
1712 displayed for some time. Should be called from time to time to
1713 reduce the number of loaded images. If image-cache-eviction-delay
1714 is non-nil, this frees images in the cache which weren't displayed
1715 for at least that many seconds. */
1718 clear_image_cache (f
, force_p
)
1722 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
1724 if (c
&& INTEGERP (Vimage_cache_eviction_delay
))
1731 old
= EMACS_SECS (t
) - XFASTINT (Vimage_cache_eviction_delay
);
1733 /* Block input so that we won't be interrupted by a SIGIO
1734 while being in an inconsistent state. */
1737 for (i
= nfreed
= 0; i
< c
->used
; ++i
)
1739 struct image
*img
= c
->images
[i
];
1741 && (force_p
|| img
->timestamp
< old
))
1743 free_image (f
, img
);
1748 /* We may be clearing the image cache because, for example,
1749 Emacs was iconified for a longer period of time. In that
1750 case, current matrices may still contain references to
1751 images freed above. So, clear these matrices. */
1754 Lisp_Object tail
, frame
;
1756 FOR_EACH_FRAME (tail
, frame
)
1758 struct frame
*f
= XFRAME (frame
);
1759 if (FRAME_WINDOW_P (f
)
1760 && FRAME_X_IMAGE_CACHE (f
) == c
)
1761 clear_current_matrices (f
);
1764 ++windows_or_buffers_changed
;
1772 DEFUN ("clear-image-cache", Fclear_image_cache
, Sclear_image_cache
,
1774 doc
: /* Clear the image cache of FRAME.
1775 FRAME nil or omitted means use the selected frame.
1776 FRAME t means clear the image caches of all frames. */)
1784 FOR_EACH_FRAME (tail
, frame
)
1785 if (FRAME_WINDOW_P (XFRAME (frame
)))
1786 clear_image_cache (XFRAME (frame
), 1);
1789 clear_image_cache (check_x_frame (frame
), 1);
1795 DEFUN ("image-refresh", Fimage_refresh
, Simage_refresh
,
1797 doc
: /* Refresh the image with specification SPEC on frame FRAME.
1798 If SPEC specifies an image file, the displayed image is updated with
1799 the current contents of that file.
1800 FRAME nil or omitted means use the selected frame.
1801 FRAME t means refresh the image on all frames. */)
1803 Lisp_Object spec
, frame
;
1805 if (!valid_image_p (spec
))
1806 error ("Invalid image specification");
1811 FOR_EACH_FRAME (tail
, frame
)
1813 struct frame
*f
= XFRAME (frame
);
1814 if (FRAME_WINDOW_P (f
))
1815 uncache_image (f
, spec
);
1819 uncache_image (check_x_frame (frame
), spec
);
1825 /* Compute masks and transform image IMG on frame F, as specified
1826 by the image's specification, */
1829 postprocess_image (f
, img
)
1833 /* Manipulation of the image's mask. */
1836 Lisp_Object conversion
, spec
;
1841 /* `:heuristic-mask t'
1843 means build a mask heuristically.
1844 `:heuristic-mask (R G B)'
1845 `:mask (heuristic (R G B))'
1846 means build a mask from color (R G B) in the
1849 means remove a mask, if any. */
1851 mask
= image_spec_value (spec
, QCheuristic_mask
, NULL
);
1853 x_build_heuristic_mask (f
, img
, mask
);
1858 mask
= image_spec_value (spec
, QCmask
, &found_p
);
1860 if (EQ (mask
, Qheuristic
))
1861 x_build_heuristic_mask (f
, img
, Qt
);
1862 else if (CONSP (mask
)
1863 && EQ (XCAR (mask
), Qheuristic
))
1865 if (CONSP (XCDR (mask
)))
1866 x_build_heuristic_mask (f
, img
, XCAR (XCDR (mask
)));
1868 x_build_heuristic_mask (f
, img
, XCDR (mask
));
1870 else if (NILP (mask
) && found_p
&& img
->mask
)
1872 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
1873 img
->mask
= NO_PIXMAP
;
1878 /* Should we apply an image transformation algorithm? */
1879 conversion
= image_spec_value (spec
, QCconversion
, NULL
);
1880 if (EQ (conversion
, Qdisabled
))
1881 x_disable_image (f
, img
);
1882 else if (EQ (conversion
, Qlaplace
))
1884 else if (EQ (conversion
, Qemboss
))
1886 else if (CONSP (conversion
)
1887 && EQ (XCAR (conversion
), Qedge_detection
))
1890 tem
= XCDR (conversion
);
1892 x_edge_detection (f
, img
,
1893 Fplist_get (tem
, QCmatrix
),
1894 Fplist_get (tem
, QCcolor_adjustment
));
1900 /* Return the id of image with Lisp specification SPEC on frame F.
1901 SPEC must be a valid Lisp image specification (see valid_image_p). */
1904 lookup_image (f
, spec
)
1910 struct gcpro gcpro1
;
1913 /* F must be a window-system frame, and SPEC must be a valid image
1915 xassert (FRAME_WINDOW_P (f
));
1916 xassert (valid_image_p (spec
));
1920 /* Look up SPEC in the hash table of the image cache. */
1921 hash
= sxhash (spec
, 0);
1922 img
= search_image_cache (f
, spec
, hash
);
1923 if (img
&& img
->load_failed_p
)
1925 free_image (f
, img
);
1929 /* If not found, create a new image and cache it. */
1932 extern Lisp_Object Qpostscript
;
1935 img
= make_image (spec
, hash
);
1936 cache_image (f
, img
);
1937 img
->load_failed_p
= img
->type
->load (f
, img
) == 0;
1938 img
->frame_foreground
= FRAME_FOREGROUND_PIXEL (f
);
1939 img
->frame_background
= FRAME_BACKGROUND_PIXEL (f
);
1941 /* If we can't load the image, and we don't have a width and
1942 height, use some arbitrary width and height so that we can
1943 draw a rectangle for it. */
1944 if (img
->load_failed_p
)
1948 value
= image_spec_value (spec
, QCwidth
, NULL
);
1949 img
->width
= (INTEGERP (value
)
1950 ? XFASTINT (value
) : DEFAULT_IMAGE_WIDTH
);
1951 value
= image_spec_value (spec
, QCheight
, NULL
);
1952 img
->height
= (INTEGERP (value
)
1953 ? XFASTINT (value
) : DEFAULT_IMAGE_HEIGHT
);
1957 /* Handle image type independent image attributes
1958 `:ascent ASCENT', `:margin MARGIN', `:relief RELIEF',
1959 `:background COLOR'. */
1960 Lisp_Object ascent
, margin
, relief
, bg
;
1962 ascent
= image_spec_value (spec
, QCascent
, NULL
);
1963 if (INTEGERP (ascent
))
1964 img
->ascent
= XFASTINT (ascent
);
1965 else if (EQ (ascent
, Qcenter
))
1966 img
->ascent
= CENTERED_IMAGE_ASCENT
;
1968 margin
= image_spec_value (spec
, QCmargin
, NULL
);
1969 if (INTEGERP (margin
) && XINT (margin
) >= 0)
1970 img
->vmargin
= img
->hmargin
= XFASTINT (margin
);
1971 else if (CONSP (margin
) && INTEGERP (XCAR (margin
))
1972 && INTEGERP (XCDR (margin
)))
1974 if (XINT (XCAR (margin
)) > 0)
1975 img
->hmargin
= XFASTINT (XCAR (margin
));
1976 if (XINT (XCDR (margin
)) > 0)
1977 img
->vmargin
= XFASTINT (XCDR (margin
));
1980 relief
= image_spec_value (spec
, QCrelief
, NULL
);
1981 if (INTEGERP (relief
))
1983 img
->relief
= XINT (relief
);
1984 img
->hmargin
+= abs (img
->relief
);
1985 img
->vmargin
+= abs (img
->relief
);
1988 if (! img
->background_valid
)
1990 bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
1994 = x_alloc_image_color (f
, img
, bg
,
1995 FRAME_BACKGROUND_PIXEL (f
));
1996 img
->background_valid
= 1;
2000 /* Do image transformations and compute masks, unless we
2001 don't have the image yet. */
2002 if (!EQ (*img
->type
->type
, Qpostscript
))
2003 postprocess_image (f
, img
);
2009 /* We're using IMG, so set its timestamp to `now'. */
2010 EMACS_GET_TIME (now
);
2011 img
->timestamp
= EMACS_SECS (now
);
2015 /* Value is the image id. */
2020 /* Cache image IMG in the image cache of frame F. */
2023 cache_image (f
, img
)
2027 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
2030 /* Find a free slot in c->images. */
2031 for (i
= 0; i
< c
->used
; ++i
)
2032 if (c
->images
[i
] == NULL
)
2035 /* If no free slot found, maybe enlarge c->images. */
2036 if (i
== c
->used
&& c
->used
== c
->size
)
2039 c
->images
= (struct image
**) xrealloc (c
->images
,
2040 c
->size
* sizeof *c
->images
);
2043 /* Add IMG to c->images, and assign IMG an id. */
2049 /* Add IMG to the cache's hash table. */
2050 i
= img
->hash
% IMAGE_CACHE_BUCKETS_SIZE
;
2051 img
->next
= c
->buckets
[i
];
2053 img
->next
->prev
= img
;
2055 c
->buckets
[i
] = img
;
2059 /* Call FN on every image in the image cache of frame F. Used to mark
2060 Lisp Objects in the image cache. */
2063 forall_images_in_image_cache (f
, fn
)
2065 void (*fn
) P_ ((struct image
*img
));
2067 if (FRAME_LIVE_P (f
) && FRAME_WINDOW_P (f
))
2069 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
2073 for (i
= 0; i
< c
->used
; ++i
)
2082 /***********************************************************************
2083 X / MAC / W32 support code
2084 ***********************************************************************/
2088 /* Macro for defining functions that will be loaded from image DLLs. */
2089 #define DEF_IMGLIB_FN(func) int (FAR CDECL *fn_##func)()
2091 /* Macro for loading those image functions from the library. */
2092 #define LOAD_IMGLIB_FN(lib,func) { \
2093 fn_##func = (void *) GetProcAddress (lib, #func); \
2094 if (!fn_##func) return 0; \
2097 /* Load a DLL implementing an image type.
2098 The `image-library-alist' variable associates a symbol,
2099 identifying an image type, to a list of possible filenames.
2100 The function returns NULL if no library could be loaded for
2101 the given image type, or if the library was previously loaded;
2102 else the handle of the DLL. */
2104 w32_delayed_load (Lisp_Object libraries
, Lisp_Object type
)
2106 HMODULE library
= NULL
;
2108 if (CONSP (libraries
) && NILP (Fassq (type
, Vimage_type_cache
)))
2110 Lisp_Object dlls
= Fassq (type
, libraries
);
2113 for (dlls
= XCDR (dlls
); CONSP (dlls
); dlls
= XCDR (dlls
))
2115 CHECK_STRING_CAR (dlls
);
2116 if (library
= LoadLibrary (SDATA (XCAR (dlls
))))
2124 #endif /* HAVE_NTGUI */
2126 static int x_create_x_image_and_pixmap
P_ ((struct frame
*, int, int, int,
2127 XImagePtr
*, Pixmap
*));
2128 static void x_destroy_x_image
P_ ((XImagePtr
));
2129 static void x_put_x_image
P_ ((struct frame
*, XImagePtr
, Pixmap
, int, int));
2132 /* Create an XImage and a pixmap of size WIDTH x HEIGHT for use on
2133 frame F. Set *XIMG and *PIXMAP to the XImage and Pixmap created.
2134 Set (*XIMG)->data to a raster of WIDTH x HEIGHT pixels allocated
2135 via xmalloc. Print error messages via image_error if an error
2136 occurs. Value is non-zero if successful.
2138 On W32, a DEPTH of zero signifies a 24 bit image, otherwise DEPTH
2139 should indicate the bit depth of the image. */
2142 x_create_x_image_and_pixmap (f
, width
, height
, depth
, ximg
, pixmap
)
2144 int width
, height
, depth
;
2148 #ifdef HAVE_X_WINDOWS
2149 Display
*display
= FRAME_X_DISPLAY (f
);
2150 Window window
= FRAME_X_WINDOW (f
);
2151 Screen
*screen
= FRAME_X_SCREEN (f
);
2153 xassert (interrupt_input_blocked
);
2156 depth
= DefaultDepthOfScreen (screen
);
2157 *ximg
= XCreateImage (display
, DefaultVisualOfScreen (screen
),
2158 depth
, ZPixmap
, 0, NULL
, width
, height
,
2159 depth
> 16 ? 32 : depth
> 8 ? 16 : 8, 0);
2162 image_error ("Unable to allocate X image", Qnil
, Qnil
);
2166 /* Allocate image raster. */
2167 (*ximg
)->data
= (char *) xmalloc ((*ximg
)->bytes_per_line
* height
);
2169 /* Allocate a pixmap of the same size. */
2170 *pixmap
= XCreatePixmap (display
, window
, width
, height
, depth
);
2171 if (*pixmap
== NO_PIXMAP
)
2173 x_destroy_x_image (*ximg
);
2175 image_error ("Unable to create X pixmap", Qnil
, Qnil
);
2180 #endif /* HAVE_X_WINDOWS */
2184 BITMAPINFOHEADER
*header
;
2186 int scanline_width_bits
;
2188 int palette_colors
= 0;
2193 if (depth
!= 1 && depth
!= 4 && depth
!= 8
2194 && depth
!= 16 && depth
!= 24 && depth
!= 32)
2196 image_error ("Invalid image bit depth specified", Qnil
, Qnil
);
2200 scanline_width_bits
= width
* depth
;
2201 remainder
= scanline_width_bits
% 32;
2204 scanline_width_bits
+= 32 - remainder
;
2206 /* Bitmaps with a depth less than 16 need a palette. */
2207 /* BITMAPINFO structure already contains the first RGBQUAD. */
2209 palette_colors
= 1 << depth
- 1;
2211 *ximg
= xmalloc (sizeof (XImage
) + palette_colors
* sizeof (RGBQUAD
));
2214 image_error ("Unable to allocate memory for XImage", Qnil
, Qnil
);
2218 header
= &((*ximg
)->info
.bmiHeader
);
2219 bzero (&((*ximg
)->info
), sizeof (BITMAPINFO
));
2220 header
->biSize
= sizeof (*header
);
2221 header
->biWidth
= width
;
2222 header
->biHeight
= -height
; /* negative indicates a top-down bitmap. */
2223 header
->biPlanes
= 1;
2224 header
->biBitCount
= depth
;
2225 header
->biCompression
= BI_RGB
;
2226 header
->biClrUsed
= palette_colors
;
2228 /* TODO: fill in palette. */
2231 (*ximg
)->info
.bmiColors
[0].rgbBlue
= 0;
2232 (*ximg
)->info
.bmiColors
[0].rgbGreen
= 0;
2233 (*ximg
)->info
.bmiColors
[0].rgbRed
= 0;
2234 (*ximg
)->info
.bmiColors
[0].rgbReserved
= 0;
2235 (*ximg
)->info
.bmiColors
[1].rgbBlue
= 255;
2236 (*ximg
)->info
.bmiColors
[1].rgbGreen
= 255;
2237 (*ximg
)->info
.bmiColors
[1].rgbRed
= 255;
2238 (*ximg
)->info
.bmiColors
[1].rgbReserved
= 0;
2241 hdc
= get_frame_dc (f
);
2243 /* Create a DIBSection and raster array for the bitmap,
2244 and store its handle in *pixmap. */
2245 *pixmap
= CreateDIBSection (hdc
, &((*ximg
)->info
),
2246 (depth
< 16) ? DIB_PAL_COLORS
: DIB_RGB_COLORS
,
2247 /* casting avoids a GCC warning */
2248 (void **)&((*ximg
)->data
), NULL
, 0);
2250 /* Realize display palette and garbage all frames. */
2251 release_frame_dc (f
, hdc
);
2253 if (*pixmap
== NULL
)
2255 DWORD err
= GetLastError();
2256 Lisp_Object errcode
;
2257 /* All system errors are < 10000, so the following is safe. */
2258 XSETINT (errcode
, (int) err
);
2259 image_error ("Unable to create bitmap, error code %d", errcode
, Qnil
);
2260 x_destroy_x_image (*ximg
);
2266 #endif /* HAVE_NTGUI */
2269 Display
*display
= FRAME_X_DISPLAY (f
);
2270 Window window
= FRAME_X_WINDOW (f
);
2272 xassert (interrupt_input_blocked
);
2274 /* Allocate a pixmap of the same size. */
2275 *pixmap
= XCreatePixmap (display
, window
, width
, height
, depth
);
2276 if (*pixmap
== NO_PIXMAP
)
2279 image_error ("Unable to create X pixmap", Qnil
, Qnil
);
2283 LockPixels (GetGWorldPixMap (*pixmap
));
2291 /* Destroy XImage XIMG. Free XIMG->data. */
2294 x_destroy_x_image (ximg
)
2297 xassert (interrupt_input_blocked
);
2300 #ifdef HAVE_X_WINDOWS
2303 XDestroyImage (ximg
);
2304 #endif /* HAVE_X_WINDOWS */
2306 /* Data will be freed by DestroyObject. */
2309 #endif /* HAVE_NTGUI */
2311 XDestroyImage (ximg
);
2317 /* Put XImage XIMG into pixmap PIXMAP on frame F. WIDTH and HEIGHT
2318 are width and height of both the image and pixmap. */
2321 x_put_x_image (f
, ximg
, pixmap
, width
, height
)
2327 #ifdef HAVE_X_WINDOWS
2330 xassert (interrupt_input_blocked
);
2331 gc
= XCreateGC (FRAME_X_DISPLAY (f
), pixmap
, 0, NULL
);
2332 XPutImage (FRAME_X_DISPLAY (f
), pixmap
, gc
, ximg
, 0, 0, 0, 0, width
, height
);
2333 XFreeGC (FRAME_X_DISPLAY (f
), gc
);
2334 #endif /* HAVE_X_WINDOWS */
2337 #if 0 /* I don't think this is necessary looking at where it is used. */
2338 HDC hdc
= get_frame_dc (f
);
2339 SetDIBits (hdc
, pixmap
, 0, height
, ximg
->data
, &(ximg
->info
), DIB_RGB_COLORS
);
2340 release_frame_dc (f
, hdc
);
2342 #endif /* HAVE_NTGUI */
2345 xassert (ximg
== pixmap
);
2350 /***********************************************************************
2352 ***********************************************************************/
2354 static unsigned char *slurp_file
P_ ((char *, int *));
2357 /* Find image file FILE. Look in data-directory, then
2358 x-bitmap-file-path. Value is the encoded full name of the file
2359 found, or nil if not found. */
2362 x_find_image_file (file
)
2365 Lisp_Object file_found
, search_path
;
2366 struct gcpro gcpro1
, gcpro2
;
2370 search_path
= Fcons (Vdata_directory
, Vx_bitmap_file_path
);
2371 GCPRO2 (file_found
, search_path
);
2373 /* Try to find FILE in data-directory, then x-bitmap-file-path. */
2374 fd
= openp (search_path
, file
, Qnil
, &file_found
, Qnil
);
2380 file_found
= ENCODE_FILE (file_found
);
2389 /* Read FILE into memory. Value is a pointer to a buffer allocated
2390 with xmalloc holding FILE's contents. Value is null if an error
2391 occurred. *SIZE is set to the size of the file. */
2393 static unsigned char *
2394 slurp_file (file
, size
)
2399 unsigned char *buf
= NULL
;
2402 if (stat (file
, &st
) == 0
2403 && (fp
= fopen (file
, "rb")) != NULL
2404 && (buf
= (unsigned char *) xmalloc (st
.st_size
),
2405 fread (buf
, 1, st
.st_size
, fp
) == st
.st_size
))
2428 /***********************************************************************
2429 MAC Image Load Functions
2430 ***********************************************************************/
2432 static int image_load_quicktime
P_ ((struct frame
*, struct image
*img
,
2435 static int image_load_quartz2d
P_ ((struct frame
*, struct image
*img
, int));
2439 find_image_fsspec (specified_file
, file
, fss
)
2440 Lisp_Object specified_file
, *file
;
2446 *file
= x_find_image_file (specified_file
);
2447 if (!STRINGP (*file
))
2448 return fnfErr
; /* file or directory not found;
2449 incomplete pathname */
2450 /* Try to open the image file. */
2451 err
= AECoercePtr (TYPE_FILE_NAME
, SDATA (*file
),
2452 SBYTES (*file
), typeFSS
, &desc
);
2455 #if TARGET_API_MAC_CARBON
2456 err
= AEGetDescData (&desc
, fss
, sizeof (FSSpec
));
2458 *fss
= *(FSSpec
*)(*(desc
.dataHandle
));
2460 AEDisposeDesc (&desc
);
2466 image_load_qt_1 (f
, img
, type
, fss
, dh
)
2473 ComponentResult err
;
2474 GraphicsImportComponent gi
;
2477 ImageDescriptionHandle desc_handle
;
2478 short draw_all_pixels
;
2479 Lisp_Object specified_bg
;
2484 err
= OpenADefaultComponent (GraphicsImporterComponentType
, type
, &gi
);
2487 image_error ("Cannot get importer component for `%s'", img
->spec
, Qnil
);
2492 /* read from file system spec */
2493 err
= GraphicsImportSetDataFile (gi
, fss
);
2496 image_error ("Cannot set fsspec to graphics importer for '%s'",
2503 /* read from data handle */
2504 err
= GraphicsImportSetDataHandle (gi
, dh
);
2507 image_error ("Cannot set data handle to graphics importer for `%s'",
2512 err
= GraphicsImportGetImageDescription (gi
, &desc_handle
);
2513 if (err
!= noErr
|| desc_handle
== NULL
)
2515 image_error ("Error reading `%s'", img
->spec
, Qnil
);
2518 width
= img
->width
= (*desc_handle
)->width
;
2519 height
= img
->height
= (*desc_handle
)->height
;
2520 DisposeHandle ((Handle
)desc_handle
);
2522 if (!check_image_size (f
, width
, height
))
2524 image_error ("Invalid image size", Qnil
, Qnil
);
2528 err
= GraphicsImportDoesDrawAllPixels (gi
, &draw_all_pixels
);
2530 /* Don't check the error code here. It may have an undocumented
2534 image_error ("Error reading `%s'", img
->spec
, Qnil
);
2538 if (draw_all_pixels
!= graphicsImporterDrawsAllPixels
)
2540 specified_bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
2541 if (!STRINGP (specified_bg
) ||
2542 !mac_defined_color (f
, SDATA (specified_bg
), &color
, 0))
2544 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
2545 color
.red
= RED16_FROM_ULONG (color
.pixel
);
2546 color
.green
= GREEN16_FROM_ULONG (color
.pixel
);
2547 color
.blue
= BLUE16_FROM_ULONG (color
.pixel
);
2551 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
2553 if (draw_all_pixels
!= graphicsImporterDrawsAllPixels
)
2558 GetGWorld (&old_port
, &old_gdh
);
2559 SetGWorld (ximg
, NULL
);
2560 bg_color
.red
= color
.red
;
2561 bg_color
.green
= color
.green
;
2562 bg_color
.blue
= color
.blue
;
2563 RGBBackColor (&bg_color
);
2564 #if TARGET_API_MAC_CARBON
2565 GetPortBounds (ximg
, &rect
);
2568 EraseRect (&(ximg
->portRect
));
2570 SetGWorld (old_port
, old_gdh
);
2572 GraphicsImportSetGWorld (gi
, ximg
, NULL
);
2573 GraphicsImportDraw (gi
);
2574 CloseComponent (gi
);
2576 /* Maybe fill in the background field while we have ximg handy. */
2577 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
2578 IMAGE_BACKGROUND (img
, f
, ximg
);
2580 /* Put the image into the pixmap. */
2581 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
2582 x_destroy_x_image (ximg
);
2586 CloseComponent (gi
);
2591 /* Load an image using the QuickTime Graphics Importer.
2592 Note: The alpha channel does not work for PNG images. */
2594 image_load_quicktime (f
, img
, type
)
2599 Lisp_Object specified_file
;
2600 Lisp_Object specified_data
;
2603 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
2604 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
2606 if (NILP (specified_data
))
2608 /* Read from a file */
2612 err
= find_image_fsspec (specified_file
, &file
, &fss
);
2616 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
2618 image_error ("Cannot open `%s'", file
, Qnil
);
2621 return image_load_qt_1 (f
, img
, type
, &fss
, NULL
);
2625 /* Memory source! */
2629 err
= PtrToHand (SDATA (specified_data
), &dh
, SBYTES (specified_data
));
2632 image_error ("Cannot allocate data handle for `%s'",
2636 success_p
= image_load_qt_1 (f
, img
, type
, NULL
, dh
);
2644 /* Load a PNG/JPEG image using Quartz 2D decoding routines.
2645 CGImageCreateWithPNGDataProvider is provided after Mac OS X 10.2.
2646 So don't use this function directly but determine at runtime
2647 whether it exists. */
2648 typedef CGImageRef (*CGImageCreateWithPNGDataProviderProcType
)
2649 (CGDataProviderRef
, const float [], bool, CGColorRenderingIntent
);
2650 static CGImageCreateWithPNGDataProviderProcType MyCGImageCreateWithPNGDataProvider
;
2654 init_image_func_pointer ()
2656 if (NSIsSymbolNameDefined ("_CGImageCreateWithPNGDataProvider"))
2658 MyCGImageCreateWithPNGDataProvider
2659 = (CGImageCreateWithPNGDataProviderProcType
)
2660 NSAddressOfSymbol (NSLookupAndBindSymbol
2661 ("_CGImageCreateWithPNGDataProvider"));
2664 MyCGImageCreateWithPNGDataProvider
= NULL
;
2669 image_load_quartz2d (f
, img
, png_p
)
2674 Lisp_Object file
, specified_file
;
2675 Lisp_Object specified_data
, specified_bg
;
2676 struct gcpro gcpro1
;
2677 CGDataProviderRef source
;
2681 XImagePtr ximg
= NULL
;
2682 CGContextRef context
;
2685 /* Open the file. */
2686 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
2687 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
2692 if (NILP (specified_data
))
2697 file
= x_find_image_file (specified_file
);
2698 if (!STRINGP (file
))
2700 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
2704 path
= cfstring_create_with_utf8_cstring (SDATA (file
));
2705 url
= CFURLCreateWithFileSystemPath (NULL
, path
,
2706 kCFURLPOSIXPathStyle
, 0);
2708 source
= CGDataProviderCreateWithURL (url
);
2712 source
= CGDataProviderCreateWithData (NULL
, SDATA (specified_data
),
2713 SBYTES (specified_data
), NULL
);
2716 image
= (*MyCGImageCreateWithPNGDataProvider
) (source
, NULL
, FALSE
,
2717 kCGRenderingIntentDefault
);
2719 image
= CGImageCreateWithJPEGDataProvider (source
, NULL
, FALSE
,
2720 kCGRenderingIntentDefault
);
2722 CGDataProviderRelease (source
);
2726 image_error ("Error reading image `%s'", img
->spec
, Qnil
);
2729 width
= img
->width
= CGImageGetWidth (image
);
2730 height
= img
->height
= CGImageGetHeight (image
);
2732 if (!check_image_size (f
, width
, height
))
2734 CGImageRelease (image
);
2736 image_error ("Invalid image size", Qnil
, Qnil
);
2742 specified_bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
2743 if (!STRINGP (specified_bg
) ||
2744 !mac_defined_color (f
, SDATA (specified_bg
), &color
, 0))
2746 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
2747 color
.red
= RED16_FROM_ULONG (color
.pixel
);
2748 color
.green
= GREEN16_FROM_ULONG (color
.pixel
);
2749 color
.blue
= BLUE16_FROM_ULONG (color
.pixel
);
2753 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
2755 CGImageRelease (image
);
2759 rectangle
= CGRectMake (0, 0, width
, height
);
2760 QDBeginCGContext (ximg
, &context
);
2763 CGContextSetRGBFillColor (context
, color
.red
/ 65535.0,
2764 color
.green
/ 65535.0,
2765 color
.blue
/ 65535.0, 1.0);
2766 CGContextFillRect (context
, rectangle
);
2768 CGContextDrawImage (context
, rectangle
, image
);
2769 QDEndCGContext (ximg
, &context
);
2770 CGImageRelease (image
);
2772 /* Maybe fill in the background field while we have ximg handy. */
2773 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
2774 IMAGE_BACKGROUND (img
, f
, ximg
);
2776 /* Put the image into the pixmap. */
2777 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
2778 x_destroy_x_image (ximg
);
2787 /***********************************************************************
2789 ***********************************************************************/
2791 static int xbm_scan
P_ ((unsigned char **, unsigned char *, char *, int *));
2792 static int xbm_load
P_ ((struct frame
*f
, struct image
*img
));
2793 static int xbm_load_image
P_ ((struct frame
*f
, struct image
*img
,
2794 unsigned char *, unsigned char *));
2795 static int xbm_image_p
P_ ((Lisp_Object object
));
2796 static int xbm_read_bitmap_data
P_ ((struct frame
*f
,
2797 unsigned char *, unsigned char *,
2798 int *, int *, unsigned char **));
2799 static int xbm_file_p
P_ ((Lisp_Object
));
2802 /* Indices of image specification fields in xbm_format, below. */
2804 enum xbm_keyword_index
2822 /* Vector of image_keyword structures describing the format
2823 of valid XBM image specifications. */
2825 static struct image_keyword xbm_format
[XBM_LAST
] =
2827 {":type", IMAGE_SYMBOL_VALUE
, 1},
2828 {":file", IMAGE_STRING_VALUE
, 0},
2829 {":width", IMAGE_POSITIVE_INTEGER_VALUE
, 0},
2830 {":height", IMAGE_POSITIVE_INTEGER_VALUE
, 0},
2831 {":data", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
2832 {":foreground", IMAGE_STRING_OR_NIL_VALUE
, 0},
2833 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0},
2834 {":ascent", IMAGE_ASCENT_VALUE
, 0},
2835 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
2836 {":relief", IMAGE_INTEGER_VALUE
, 0},
2837 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
2838 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
2839 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0}
2842 /* Structure describing the image type XBM. */
2844 static struct image_type xbm_type
=
2853 /* Tokens returned from xbm_scan. */
2862 /* Return non-zero if OBJECT is a valid XBM-type image specification.
2863 A valid specification is a list starting with the symbol `image'
2864 The rest of the list is a property list which must contain an
2867 If the specification specifies a file to load, it must contain
2868 an entry `:file FILENAME' where FILENAME is a string.
2870 If the specification is for a bitmap loaded from memory it must
2871 contain `:width WIDTH', `:height HEIGHT', and `:data DATA', where
2872 WIDTH and HEIGHT are integers > 0. DATA may be:
2874 1. a string large enough to hold the bitmap data, i.e. it must
2875 have a size >= (WIDTH + 7) / 8 * HEIGHT
2877 2. a bool-vector of size >= WIDTH * HEIGHT
2879 3. a vector of strings or bool-vectors, one for each line of the
2882 4. a string containing an in-memory XBM file. WIDTH and HEIGHT
2883 may not be specified in this case because they are defined in the
2886 Both the file and data forms may contain the additional entries
2887 `:background COLOR' and `:foreground COLOR'. If not present,
2888 foreground and background of the frame on which the image is
2889 displayed is used. */
2892 xbm_image_p (object
)
2895 struct image_keyword kw
[XBM_LAST
];
2897 bcopy (xbm_format
, kw
, sizeof kw
);
2898 if (!parse_image_spec (object
, kw
, XBM_LAST
, Qxbm
))
2901 xassert (EQ (kw
[XBM_TYPE
].value
, Qxbm
));
2903 if (kw
[XBM_FILE
].count
)
2905 if (kw
[XBM_WIDTH
].count
|| kw
[XBM_HEIGHT
].count
|| kw
[XBM_DATA
].count
)
2908 else if (kw
[XBM_DATA
].count
&& xbm_file_p (kw
[XBM_DATA
].value
))
2910 /* In-memory XBM file. */
2911 if (kw
[XBM_WIDTH
].count
|| kw
[XBM_HEIGHT
].count
|| kw
[XBM_FILE
].count
)
2919 /* Entries for `:width', `:height' and `:data' must be present. */
2920 if (!kw
[XBM_WIDTH
].count
2921 || !kw
[XBM_HEIGHT
].count
2922 || !kw
[XBM_DATA
].count
)
2925 data
= kw
[XBM_DATA
].value
;
2926 width
= XFASTINT (kw
[XBM_WIDTH
].value
);
2927 height
= XFASTINT (kw
[XBM_HEIGHT
].value
);
2929 /* Check type of data, and width and height against contents of
2935 /* Number of elements of the vector must be >= height. */
2936 if (XVECTOR (data
)->size
< height
)
2939 /* Each string or bool-vector in data must be large enough
2940 for one line of the image. */
2941 for (i
= 0; i
< height
; ++i
)
2943 Lisp_Object elt
= XVECTOR (data
)->contents
[i
];
2948 < (width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
)
2951 else if (BOOL_VECTOR_P (elt
))
2953 if (XBOOL_VECTOR (elt
)->size
< width
)
2960 else if (STRINGP (data
))
2963 < (width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
* height
)
2966 else if (BOOL_VECTOR_P (data
))
2968 if (XBOOL_VECTOR (data
)->size
< width
* height
)
2979 /* Scan a bitmap file. FP is the stream to read from. Value is
2980 either an enumerator from enum xbm_token, or a character for a
2981 single-character token, or 0 at end of file. If scanning an
2982 identifier, store the lexeme of the identifier in SVAL. If
2983 scanning a number, store its value in *IVAL. */
2986 xbm_scan (s
, end
, sval
, ival
)
2987 unsigned char **s
, *end
;
2995 /* Skip white space. */
2996 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
3001 else if (isdigit (c
))
3003 int value
= 0, digit
;
3005 if (c
== '0' && *s
< end
)
3008 if (c
== 'x' || c
== 'X')
3015 else if (c
>= 'a' && c
<= 'f')
3016 digit
= c
- 'a' + 10;
3017 else if (c
>= 'A' && c
<= 'F')
3018 digit
= c
- 'A' + 10;
3021 value
= 16 * value
+ digit
;
3024 else if (isdigit (c
))
3028 && (c
= *(*s
)++, isdigit (c
)))
3029 value
= 8 * value
+ c
- '0';
3036 && (c
= *(*s
)++, isdigit (c
)))
3037 value
= 10 * value
+ c
- '0';
3045 else if (isalpha (c
) || c
== '_')
3049 && (c
= *(*s
)++, (isalnum (c
) || c
== '_')))
3056 else if (c
== '/' && **s
== '*')
3058 /* C-style comment. */
3060 while (**s
&& (**s
!= '*' || *(*s
+ 1) != '/'))
3074 /* Create a Windows bitmap from X bitmap data. */
3076 w32_create_pixmap_from_bitmap_data (int width
, int height
, char *data
)
3078 static unsigned char swap_nibble
[16]
3079 = { 0x0, 0x8, 0x4, 0xc, /* 0000 1000 0100 1100 */
3080 0x2, 0xa, 0x6, 0xe, /* 0010 1010 0110 1110 */
3081 0x1, 0x9, 0x5, 0xd, /* 0001 1001 0101 1101 */
3082 0x3, 0xb, 0x7, 0xf }; /* 0011 1011 0111 1111 */
3084 unsigned char *bits
, *p
;
3087 w1
= (width
+ 7) / 8; /* nb of 8bits elt in X bitmap */
3088 w2
= ((width
+ 15) / 16) * 2; /* nb of 16bits elt in W32 bitmap */
3089 bits
= (unsigned char *) alloca (height
* w2
);
3090 bzero (bits
, height
* w2
);
3091 for (i
= 0; i
< height
; i
++)
3094 for (j
= 0; j
< w1
; j
++)
3096 /* Bitswap XBM bytes to match how Windows does things. */
3097 unsigned char c
= *data
++;
3098 *p
++ = (unsigned char)((swap_nibble
[c
& 0xf] << 4)
3099 | (swap_nibble
[(c
>>4) & 0xf]));
3102 bmp
= CreateBitmap (width
, height
, 1, 1, (char *) bits
);
3108 convert_mono_to_color_image (f
, img
, foreground
, background
)
3111 COLORREF foreground
, background
;
3113 HDC hdc
, old_img_dc
, new_img_dc
;
3114 HGDIOBJ old_prev
, new_prev
;
3117 hdc
= get_frame_dc (f
);
3118 old_img_dc
= CreateCompatibleDC (hdc
);
3119 new_img_dc
= CreateCompatibleDC (hdc
);
3120 new_pixmap
= CreateCompatibleBitmap (hdc
, img
->width
, img
->height
);
3121 release_frame_dc (f
, hdc
);
3122 old_prev
= SelectObject (old_img_dc
, img
->pixmap
);
3123 new_prev
= SelectObject (new_img_dc
, new_pixmap
);
3124 /* Windows convention for mono bitmaps is black = background,
3125 white = foreground. */
3126 SetTextColor (new_img_dc
, background
);
3127 SetBkColor (new_img_dc
, foreground
);
3129 BitBlt (new_img_dc
, 0, 0, img
->width
, img
->height
, old_img_dc
,
3132 SelectObject (old_img_dc
, old_prev
);
3133 SelectObject (new_img_dc
, new_prev
);
3134 DeleteDC (old_img_dc
);
3135 DeleteDC (new_img_dc
);
3136 DeleteObject (img
->pixmap
);
3137 if (new_pixmap
== 0)
3138 fprintf (stderr
, "Failed to convert image to color.\n");
3140 img
->pixmap
= new_pixmap
;
3143 #define XBM_BIT_SHUFFLE(b) (~(b))
3147 #define XBM_BIT_SHUFFLE(b) (b)
3149 #endif /* HAVE_NTGUI */
3153 Create_Pixmap_From_Bitmap_Data(f
, img
, data
, fg
, bg
, non_default_colors
)
3157 RGB_PIXEL_COLOR fg
, bg
;
3158 int non_default_colors
;
3162 = w32_create_pixmap_from_bitmap_data (img
->width
, img
->height
, data
);
3164 /* If colors were specified, transfer the bitmap to a color one. */
3165 if (non_default_colors
)
3166 convert_mono_to_color_image (f
, img
, fg
, bg
);
3169 = XCreatePixmapFromBitmapData (FRAME_X_DISPLAY (f
),
3172 img
->width
, img
->height
,
3174 DefaultDepthOfScreen (FRAME_X_SCREEN (f
)));
3175 #endif /* HAVE_NTGUI */
3180 /* Replacement for XReadBitmapFileData which isn't available under old
3181 X versions. CONTENTS is a pointer to a buffer to parse; END is the
3182 buffer's end. Set *WIDTH and *HEIGHT to the width and height of
3183 the image. Return in *DATA the bitmap data allocated with xmalloc.
3184 Value is non-zero if successful. DATA null means just test if
3185 CONTENTS looks like an in-memory XBM file. */
3188 xbm_read_bitmap_data (f
, contents
, end
, width
, height
, data
)
3190 unsigned char *contents
, *end
;
3191 int *width
, *height
;
3192 unsigned char **data
;
3194 unsigned char *s
= contents
;
3195 char buffer
[BUFSIZ
];
3198 int bytes_per_line
, i
, nbytes
;
3204 LA1 = xbm_scan (&s, end, buffer, &value)
3206 #define expect(TOKEN) \
3207 if (LA1 != (TOKEN)) \
3212 #define expect_ident(IDENT) \
3213 if (LA1 == XBM_TK_IDENT && strcmp (buffer, (IDENT)) == 0) \
3218 *width
= *height
= -1;
3221 LA1
= xbm_scan (&s
, end
, buffer
, &value
);
3223 /* Parse defines for width, height and hot-spots. */
3227 expect_ident ("define");
3228 expect (XBM_TK_IDENT
);
3230 if (LA1
== XBM_TK_NUMBER
)
3232 char *p
= strrchr (buffer
, '_');
3233 p
= p
? p
+ 1 : buffer
;
3234 if (strcmp (p
, "width") == 0)
3236 else if (strcmp (p
, "height") == 0)
3239 expect (XBM_TK_NUMBER
);
3242 if (!check_image_size (f
, *width
, *height
))
3244 else if (data
== NULL
)
3247 /* Parse bits. Must start with `static'. */
3248 expect_ident ("static");
3249 if (LA1
== XBM_TK_IDENT
)
3251 if (strcmp (buffer
, "unsigned") == 0)
3254 expect_ident ("char");
3256 else if (strcmp (buffer
, "short") == 0)
3260 if (*width
% 16 && *width
% 16 < 9)
3263 else if (strcmp (buffer
, "char") == 0)
3271 expect (XBM_TK_IDENT
);
3277 bytes_per_line
= (*width
+ 7) / 8 + padding_p
;
3278 nbytes
= bytes_per_line
* *height
;
3279 p
= *data
= (unsigned char *) xmalloc (nbytes
);
3283 for (i
= 0; i
< nbytes
; i
+= 2)
3286 expect (XBM_TK_NUMBER
);
3288 *p
++ = XBM_BIT_SHUFFLE (val
);
3289 if (!padding_p
|| ((i
+ 2) % bytes_per_line
))
3290 *p
++ = XBM_BIT_SHUFFLE (value
>> 8);
3292 if (LA1
== ',' || LA1
== '}')
3300 for (i
= 0; i
< nbytes
; ++i
)
3303 expect (XBM_TK_NUMBER
);
3305 *p
++ = XBM_BIT_SHUFFLE (val
);
3307 if (LA1
== ',' || LA1
== '}')
3332 /* Load XBM image IMG which will be displayed on frame F from buffer
3333 CONTENTS. END is the end of the buffer. Value is non-zero if
3337 xbm_load_image (f
, img
, contents
, end
)
3340 unsigned char *contents
, *end
;
3343 unsigned char *data
;
3346 rc
= xbm_read_bitmap_data (f
, contents
, end
, &img
->width
, &img
->height
, &data
);
3349 unsigned long foreground
= FRAME_FOREGROUND_PIXEL (f
);
3350 unsigned long background
= FRAME_BACKGROUND_PIXEL (f
);
3351 int non_default_colors
= 0;
3354 xassert (img
->width
> 0 && img
->height
> 0);
3356 /* Get foreground and background colors, maybe allocate colors. */
3357 value
= image_spec_value (img
->spec
, QCforeground
, NULL
);
3360 foreground
= x_alloc_image_color (f
, img
, value
, foreground
);
3361 non_default_colors
= 1;
3363 value
= image_spec_value (img
->spec
, QCbackground
, NULL
);
3366 background
= x_alloc_image_color (f
, img
, value
, background
);
3367 img
->background
= background
;
3368 img
->background_valid
= 1;
3369 non_default_colors
= 1;
3372 Create_Pixmap_From_Bitmap_Data (f
, img
, data
,
3373 foreground
, background
,
3374 non_default_colors
);
3377 if (img
->pixmap
== NO_PIXMAP
)
3379 x_clear_image (f
, img
);
3380 image_error ("Unable to create X pixmap for `%s'", img
->spec
, Qnil
);
3386 image_error ("Error loading XBM image `%s'", img
->spec
, Qnil
);
3392 /* Value is non-zero if DATA looks like an in-memory XBM file. */
3399 return (STRINGP (data
)
3400 && xbm_read_bitmap_data (NULL
, SDATA (data
),
3407 /* Fill image IMG which is used on frame F with pixmap data. Value is
3408 non-zero if successful. */
3416 Lisp_Object file_name
;
3418 xassert (xbm_image_p (img
->spec
));
3420 /* If IMG->spec specifies a file name, create a non-file spec from it. */
3421 file_name
= image_spec_value (img
->spec
, QCfile
, NULL
);
3422 if (STRINGP (file_name
))
3425 unsigned char *contents
;
3427 struct gcpro gcpro1
;
3429 file
= x_find_image_file (file_name
);
3431 if (!STRINGP (file
))
3433 image_error ("Cannot find image file `%s'", file_name
, Qnil
);
3438 contents
= slurp_file (SDATA (file
), &size
);
3439 if (contents
== NULL
)
3441 image_error ("Error loading XBM image `%s'", img
->spec
, Qnil
);
3446 success_p
= xbm_load_image (f
, img
, contents
, contents
+ size
);
3451 struct image_keyword fmt
[XBM_LAST
];
3453 unsigned long foreground
= FRAME_FOREGROUND_PIXEL (f
);
3454 unsigned long background
= FRAME_BACKGROUND_PIXEL (f
);
3455 int non_default_colors
= 0;
3458 int in_memory_file_p
= 0;
3460 /* See if data looks like an in-memory XBM file. */
3461 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
3462 in_memory_file_p
= xbm_file_p (data
);
3464 /* Parse the image specification. */
3465 bcopy (xbm_format
, fmt
, sizeof fmt
);
3466 parsed_p
= parse_image_spec (img
->spec
, fmt
, XBM_LAST
, Qxbm
);
3469 /* Get specified width, and height. */
3470 if (!in_memory_file_p
)
3472 img
->width
= XFASTINT (fmt
[XBM_WIDTH
].value
);
3473 img
->height
= XFASTINT (fmt
[XBM_HEIGHT
].value
);
3474 xassert (img
->width
> 0 && img
->height
> 0);
3477 /* Get foreground and background colors, maybe allocate colors. */
3478 if (fmt
[XBM_FOREGROUND
].count
3479 && STRINGP (fmt
[XBM_FOREGROUND
].value
))
3481 foreground
= x_alloc_image_color (f
, img
, fmt
[XBM_FOREGROUND
].value
,
3483 non_default_colors
= 1;
3486 if (fmt
[XBM_BACKGROUND
].count
3487 && STRINGP (fmt
[XBM_BACKGROUND
].value
))
3489 background
= x_alloc_image_color (f
, img
, fmt
[XBM_BACKGROUND
].value
,
3491 non_default_colors
= 1;
3494 if (in_memory_file_p
)
3495 success_p
= xbm_load_image (f
, img
, SDATA (data
),
3504 int nbytes
= (img
->width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
;
3506 p
= bits
= (char *) alloca (nbytes
* img
->height
);
3507 for (i
= 0; i
< img
->height
; ++i
, p
+= nbytes
)
3509 Lisp_Object line
= XVECTOR (data
)->contents
[i
];
3511 bcopy (SDATA (line
), p
, nbytes
);
3513 bcopy (XBOOL_VECTOR (line
)->data
, p
, nbytes
);
3516 else if (STRINGP (data
))
3517 bits
= SDATA (data
);
3519 bits
= XBOOL_VECTOR (data
)->data
;
3525 /* Windows mono bitmaps are reversed compared with X. */
3526 invertedBits
= bits
;
3527 nbytes
= (img
->width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
3529 bits
= (char *) alloca(nbytes
);
3530 for (i
= 0; i
< nbytes
; i
++)
3531 bits
[i
] = XBM_BIT_SHUFFLE (invertedBits
[i
]);
3534 /* Create the pixmap. */
3536 Create_Pixmap_From_Bitmap_Data (f
, img
, bits
,
3537 foreground
, background
,
3538 non_default_colors
);
3543 image_error ("Unable to create pixmap for XBM image `%s'",
3545 x_clear_image (f
, img
);
3555 /***********************************************************************
3557 ***********************************************************************/
3559 #if defined (HAVE_XPM) || defined (MAC_OS)
3561 static int xpm_image_p
P_ ((Lisp_Object object
));
3562 static int xpm_load
P_ ((struct frame
*f
, struct image
*img
));
3563 static int xpm_valid_color_symbols_p
P_ ((Lisp_Object
));
3565 #endif /* HAVE_XPM || MAC_OS */
3569 /* Indicate to xpm.h that we don't have Xlib. */
3571 /* simx.h in xpm defines XColor and XImage differently than Emacs. */
3572 /* It also defines Display the same way as Emacs, but gcc 3.3 still barfs. */
3573 #define XColor xpm_XColor
3574 #define XImage xpm_XImage
3575 #define Display xpm_Display
3576 #define PIXEL_ALREADY_TYPEDEFED
3577 #include "X11/xpm.h"
3582 #undef PIXEL_ALREADY_TYPEDEFED
3584 #include "X11/xpm.h"
3585 #endif /* HAVE_NTGUI */
3586 #endif /* HAVE_XPM */
3588 #if defined (HAVE_XPM) || defined (MAC_OS)
3589 /* The symbol `xpm' identifying XPM-format images. */
3593 /* Indices of image specification fields in xpm_format, below. */
3595 enum xpm_keyword_index
3611 /* Vector of image_keyword structures describing the format
3612 of valid XPM image specifications. */
3614 static struct image_keyword xpm_format
[XPM_LAST
] =
3616 {":type", IMAGE_SYMBOL_VALUE
, 1},
3617 {":file", IMAGE_STRING_VALUE
, 0},
3618 {":data", IMAGE_STRING_VALUE
, 0},
3619 {":ascent", IMAGE_ASCENT_VALUE
, 0},
3620 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
3621 {":relief", IMAGE_INTEGER_VALUE
, 0},
3622 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3623 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3624 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3625 {":color-symbols", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3626 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
3629 /* Structure describing the image type XPM. */
3631 static struct image_type xpm_type
=
3640 #ifdef HAVE_X_WINDOWS
3642 /* Define ALLOC_XPM_COLORS if we can use Emacs' own color allocation
3643 functions for allocating image colors. Our own functions handle
3644 color allocation failures more gracefully than the ones on the XPM
3647 #if defined XpmAllocColor && defined XpmFreeColors && defined XpmColorClosure
3648 #define ALLOC_XPM_COLORS
3650 #endif /* HAVE_X_WINDOWS */
3652 #ifdef ALLOC_XPM_COLORS
3654 static void xpm_init_color_cache
P_ ((struct frame
*, XpmAttributes
*));
3655 static void xpm_free_color_cache
P_ ((void));
3656 static int xpm_lookup_color
P_ ((struct frame
*, char *, XColor
*));
3657 static int xpm_color_bucket
P_ ((char *));
3658 static struct xpm_cached_color
*xpm_cache_color
P_ ((struct frame
*, char *,
3661 /* An entry in a hash table used to cache color definitions of named
3662 colors. This cache is necessary to speed up XPM image loading in
3663 case we do color allocations ourselves. Without it, we would need
3664 a call to XParseColor per pixel in the image. */
3666 struct xpm_cached_color
3668 /* Next in collision chain. */
3669 struct xpm_cached_color
*next
;
3671 /* Color definition (RGB and pixel color). */
3678 /* The hash table used for the color cache, and its bucket vector
3681 #define XPM_COLOR_CACHE_BUCKETS 1001
3682 struct xpm_cached_color
**xpm_color_cache
;
3684 /* Initialize the color cache. */
3687 xpm_init_color_cache (f
, attrs
)
3689 XpmAttributes
*attrs
;
3691 size_t nbytes
= XPM_COLOR_CACHE_BUCKETS
* sizeof *xpm_color_cache
;
3692 xpm_color_cache
= (struct xpm_cached_color
**) xmalloc (nbytes
);
3693 memset (xpm_color_cache
, 0, nbytes
);
3694 init_color_table ();
3696 if (attrs
->valuemask
& XpmColorSymbols
)
3701 for (i
= 0; i
< attrs
->numsymbols
; ++i
)
3702 if (XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
3703 attrs
->colorsymbols
[i
].value
, &color
))
3705 color
.pixel
= lookup_rgb_color (f
, color
.red
, color
.green
,
3707 xpm_cache_color (f
, attrs
->colorsymbols
[i
].name
, &color
, -1);
3712 /* Free the color cache. */
3715 xpm_free_color_cache ()
3717 struct xpm_cached_color
*p
, *next
;
3720 for (i
= 0; i
< XPM_COLOR_CACHE_BUCKETS
; ++i
)
3721 for (p
= xpm_color_cache
[i
]; p
; p
= next
)
3727 xfree (xpm_color_cache
);
3728 xpm_color_cache
= NULL
;
3729 free_color_table ();
3732 /* Return the bucket index for color named COLOR_NAME in the color
3736 xpm_color_bucket (color_name
)
3742 for (s
= color_name
; *s
; ++s
)
3744 return h
%= XPM_COLOR_CACHE_BUCKETS
;
3748 /* On frame F, cache values COLOR for color with name COLOR_NAME.
3749 BUCKET, if >= 0, is a precomputed bucket index. Value is the cache
3752 static struct xpm_cached_color
*
3753 xpm_cache_color (f
, color_name
, color
, bucket
)
3760 struct xpm_cached_color
*p
;
3763 bucket
= xpm_color_bucket (color_name
);
3765 nbytes
= sizeof *p
+ strlen (color_name
);
3766 p
= (struct xpm_cached_color
*) xmalloc (nbytes
);
3767 strcpy (p
->name
, color_name
);
3769 p
->next
= xpm_color_cache
[bucket
];
3770 xpm_color_cache
[bucket
] = p
;
3774 /* Look up color COLOR_NAME for frame F in the color cache. If found,
3775 return the cached definition in *COLOR. Otherwise, make a new
3776 entry in the cache and allocate the color. Value is zero if color
3777 allocation failed. */
3780 xpm_lookup_color (f
, color_name
, color
)
3785 struct xpm_cached_color
*p
;
3786 int h
= xpm_color_bucket (color_name
);
3788 for (p
= xpm_color_cache
[h
]; p
; p
= p
->next
)
3789 if (strcmp (p
->name
, color_name
) == 0)
3794 else if (XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
3797 color
->pixel
= lookup_rgb_color (f
, color
->red
, color
->green
,
3799 p
= xpm_cache_color (f
, color_name
, color
, h
);
3801 /* You get `opaque' at least from ImageMagick converting pbm to xpm
3802 with transparency, and it's useful. */
3803 else if (strcmp ("opaque", color_name
) == 0)
3805 bzero (color
, sizeof (XColor
)); /* Is this necessary/correct? */
3806 color
->pixel
= FRAME_FOREGROUND_PIXEL (f
);
3807 p
= xpm_cache_color (f
, color_name
, color
, h
);
3814 /* Callback for allocating color COLOR_NAME. Called from the XPM lib.
3815 CLOSURE is a pointer to the frame on which we allocate the
3816 color. Return in *COLOR the allocated color. Value is non-zero
3820 xpm_alloc_color (dpy
, cmap
, color_name
, color
, closure
)
3827 return xpm_lookup_color ((struct frame
*) closure
, color_name
, color
);
3831 /* Callback for freeing NPIXELS colors contained in PIXELS. CLOSURE
3832 is a pointer to the frame on which we allocate the color. Value is
3833 non-zero if successful. */
3836 xpm_free_colors (dpy
, cmap
, pixels
, npixels
, closure
)
3846 #endif /* ALLOC_XPM_COLORS */
3851 /* XPM library details. */
3853 DEF_IMGLIB_FN (XpmFreeAttributes
);
3854 DEF_IMGLIB_FN (XpmCreateImageFromBuffer
);
3855 DEF_IMGLIB_FN (XpmReadFileToImage
);
3856 DEF_IMGLIB_FN (XImageFree
);
3859 init_xpm_functions (Lisp_Object libraries
)
3863 if (!(library
= w32_delayed_load (libraries
, Qxpm
)))
3866 LOAD_IMGLIB_FN (library
, XpmFreeAttributes
);
3867 LOAD_IMGLIB_FN (library
, XpmCreateImageFromBuffer
);
3868 LOAD_IMGLIB_FN (library
, XpmReadFileToImage
);
3869 LOAD_IMGLIB_FN (library
, XImageFree
);
3873 #endif /* HAVE_NTGUI */
3876 /* Value is non-zero if COLOR_SYMBOLS is a valid color symbols list
3877 for XPM images. Such a list must consist of conses whose car and
3881 xpm_valid_color_symbols_p (color_symbols
)
3882 Lisp_Object color_symbols
;
3884 while (CONSP (color_symbols
))
3886 Lisp_Object sym
= XCAR (color_symbols
);
3888 || !STRINGP (XCAR (sym
))
3889 || !STRINGP (XCDR (sym
)))
3891 color_symbols
= XCDR (color_symbols
);
3894 return NILP (color_symbols
);
3898 /* Value is non-zero if OBJECT is a valid XPM image specification. */
3901 xpm_image_p (object
)
3904 struct image_keyword fmt
[XPM_LAST
];
3905 bcopy (xpm_format
, fmt
, sizeof fmt
);
3906 return (parse_image_spec (object
, fmt
, XPM_LAST
, Qxpm
)
3907 /* Either `:file' or `:data' must be present. */
3908 && fmt
[XPM_FILE
].count
+ fmt
[XPM_DATA
].count
== 1
3909 /* Either no `:color-symbols' or it's a list of conses
3910 whose car and cdr are strings. */
3911 && (fmt
[XPM_COLOR_SYMBOLS
].count
== 0
3912 || xpm_valid_color_symbols_p (fmt
[XPM_COLOR_SYMBOLS
].value
)));
3915 #endif /* HAVE_XPM || MAC_OS */
3917 #if defined (HAVE_XPM) && defined (HAVE_X_WINDOWS)
3919 x_create_bitmap_from_xpm_data (f
, bits
)
3923 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
3925 XpmAttributes attrs
;
3926 Pixmap bitmap
, mask
;
3928 bzero (&attrs
, sizeof attrs
);
3930 attrs
.visual
= FRAME_X_VISUAL (f
);
3931 attrs
.colormap
= FRAME_X_COLORMAP (f
);
3932 attrs
.valuemask
|= XpmVisual
;
3933 attrs
.valuemask
|= XpmColormap
;
3935 rc
= XpmCreatePixmapFromData (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3936 bits
, &bitmap
, &mask
, &attrs
);
3937 if (rc
!= XpmSuccess
)
3939 XpmFreeAttributes (&attrs
);
3943 id
= x_allocate_bitmap_record (f
);
3944 dpyinfo
->bitmaps
[id
- 1].pixmap
= bitmap
;
3945 dpyinfo
->bitmaps
[id
- 1].have_mask
= 1;
3946 dpyinfo
->bitmaps
[id
- 1].mask
= mask
;
3947 dpyinfo
->bitmaps
[id
- 1].file
= NULL
;
3948 dpyinfo
->bitmaps
[id
- 1].height
= attrs
.height
;
3949 dpyinfo
->bitmaps
[id
- 1].width
= attrs
.width
;
3950 dpyinfo
->bitmaps
[id
- 1].depth
= attrs
.depth
;
3951 dpyinfo
->bitmaps
[id
- 1].refcount
= 1;
3953 XpmFreeAttributes (&attrs
);
3956 #endif /* defined (HAVE_XPM) && defined (HAVE_X_WINDOWS) */
3958 /* Load image IMG which will be displayed on frame F. Value is
3959 non-zero if successful. */
3969 XpmAttributes attrs
;
3970 Lisp_Object specified_file
, color_symbols
;
3973 xpm_XImage
* xpm_image
= NULL
, * xpm_mask
= NULL
;
3974 #endif /* HAVE_NTGUI */
3976 /* Configure the XPM lib. Use the visual of frame F. Allocate
3977 close colors. Return colors allocated. */
3978 bzero (&attrs
, sizeof attrs
);
3981 attrs
.visual
= FRAME_X_VISUAL (f
);
3982 attrs
.colormap
= FRAME_X_COLORMAP (f
);
3983 attrs
.valuemask
|= XpmVisual
;
3984 attrs
.valuemask
|= XpmColormap
;
3985 #endif /* HAVE_NTGUI */
3987 #ifdef ALLOC_XPM_COLORS
3988 /* Allocate colors with our own functions which handle
3989 failing color allocation more gracefully. */
3990 attrs
.color_closure
= f
;
3991 attrs
.alloc_color
= xpm_alloc_color
;
3992 attrs
.free_colors
= xpm_free_colors
;
3993 attrs
.valuemask
|= XpmAllocColor
| XpmFreeColors
| XpmColorClosure
;
3994 #else /* not ALLOC_XPM_COLORS */
3995 /* Let the XPM lib allocate colors. */
3996 attrs
.valuemask
|= XpmReturnAllocPixels
;
3997 #ifdef XpmAllocCloseColors
3998 attrs
.alloc_close_colors
= 1;
3999 attrs
.valuemask
|= XpmAllocCloseColors
;
4000 #else /* not XpmAllocCloseColors */
4001 attrs
.closeness
= 600;
4002 attrs
.valuemask
|= XpmCloseness
;
4003 #endif /* not XpmAllocCloseColors */
4004 #endif /* ALLOC_XPM_COLORS */
4006 /* If image specification contains symbolic color definitions, add
4007 these to `attrs'. */
4008 color_symbols
= image_spec_value (img
->spec
, QCcolor_symbols
, NULL
);
4009 if (CONSP (color_symbols
))
4012 XpmColorSymbol
*xpm_syms
;
4015 attrs
.valuemask
|= XpmColorSymbols
;
4017 /* Count number of symbols. */
4018 attrs
.numsymbols
= 0;
4019 for (tail
= color_symbols
; CONSP (tail
); tail
= XCDR (tail
))
4022 /* Allocate an XpmColorSymbol array. */
4023 size
= attrs
.numsymbols
* sizeof *xpm_syms
;
4024 xpm_syms
= (XpmColorSymbol
*) alloca (size
);
4025 bzero (xpm_syms
, size
);
4026 attrs
.colorsymbols
= xpm_syms
;
4028 /* Fill the color symbol array. */
4029 for (tail
= color_symbols
, i
= 0;
4031 ++i
, tail
= XCDR (tail
))
4033 Lisp_Object name
= XCAR (XCAR (tail
));
4034 Lisp_Object color
= XCDR (XCAR (tail
));
4035 xpm_syms
[i
].name
= (char *) alloca (SCHARS (name
) + 1);
4036 strcpy (xpm_syms
[i
].name
, SDATA (name
));
4037 xpm_syms
[i
].value
= (char *) alloca (SCHARS (color
) + 1);
4038 strcpy (xpm_syms
[i
].value
, SDATA (color
));
4042 /* Create a pixmap for the image, either from a file, or from a
4043 string buffer containing data in the same format as an XPM file. */
4044 #ifdef ALLOC_XPM_COLORS
4045 xpm_init_color_cache (f
, &attrs
);
4048 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
4052 HDC frame_dc
= get_frame_dc (f
);
4053 hdc
= CreateCompatibleDC (frame_dc
);
4054 release_frame_dc (f
, frame_dc
);
4056 #endif /* HAVE_NTGUI */
4058 if (STRINGP (specified_file
))
4060 Lisp_Object file
= x_find_image_file (specified_file
);
4061 if (!STRINGP (file
))
4063 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
4068 /* XpmReadFileToPixmap is not available in the Windows port of
4069 libxpm. But XpmReadFileToImage almost does what we want. */
4070 rc
= fn_XpmReadFileToImage (&hdc
, SDATA (file
),
4071 &xpm_image
, &xpm_mask
,
4074 rc
= XpmReadFileToPixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
4075 SDATA (file
), &img
->pixmap
, &img
->mask
,
4077 #endif /* HAVE_NTGUI */
4081 Lisp_Object buffer
= image_spec_value (img
->spec
, QCdata
, NULL
);
4083 /* XpmCreatePixmapFromBuffer is not available in the Windows port
4084 of libxpm. But XpmCreateImageFromBuffer almost does what we want. */
4085 rc
= fn_XpmCreateImageFromBuffer (&hdc
, SDATA (buffer
),
4086 &xpm_image
, &xpm_mask
,
4089 rc
= XpmCreatePixmapFromBuffer (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
4091 &img
->pixmap
, &img
->mask
,
4093 #endif /* HAVE_NTGUI */
4096 if (rc
== XpmSuccess
)
4098 #if defined (COLOR_TABLE_SUPPORT) && defined (ALLOC_XPM_COLORS)
4099 img
->colors
= colors_in_color_table (&img
->ncolors
);
4100 #else /* not ALLOC_XPM_COLORS */
4104 /* W32 XPM uses XImage to wrap what W32 Emacs calls a Pixmap,
4105 plus some duplicate attributes. */
4106 if (xpm_image
&& xpm_image
->bitmap
)
4108 img
->pixmap
= xpm_image
->bitmap
;
4109 /* XImageFree in libXpm frees XImage struct without destroying
4110 the bitmap, which is what we want. */
4111 fn_XImageFree (xpm_image
);
4113 if (xpm_mask
&& xpm_mask
->bitmap
)
4115 /* The mask appears to be inverted compared with what we expect.
4116 TODO: invert our expectations. See other places where we
4117 have to invert bits because our idea of masks is backwards. */
4119 old_obj
= SelectObject (hdc
, xpm_mask
->bitmap
);
4121 PatBlt (hdc
, 0, 0, xpm_mask
->width
, xpm_mask
->height
, DSTINVERT
);
4122 SelectObject (hdc
, old_obj
);
4124 img
->mask
= xpm_mask
->bitmap
;
4125 fn_XImageFree (xpm_mask
);
4130 #endif /* HAVE_NTGUI */
4132 /* Remember allocated colors. */
4133 img
->ncolors
= attrs
.nalloc_pixels
;
4134 img
->colors
= (unsigned long *) xmalloc (img
->ncolors
4135 * sizeof *img
->colors
);
4136 for (i
= 0; i
< attrs
.nalloc_pixels
; ++i
)
4138 img
->colors
[i
] = attrs
.alloc_pixels
[i
];
4139 #ifdef DEBUG_X_COLORS
4140 register_color (img
->colors
[i
]);
4143 #endif /* not ALLOC_XPM_COLORS */
4145 img
->width
= attrs
.width
;
4146 img
->height
= attrs
.height
;
4147 xassert (img
->width
> 0 && img
->height
> 0);
4149 /* The call to XpmFreeAttributes below frees attrs.alloc_pixels. */
4151 fn_XpmFreeAttributes (&attrs
);
4153 XpmFreeAttributes (&attrs
);
4154 #endif /* HAVE_NTGUI */
4160 #endif /* HAVE_NTGUI */
4165 image_error ("Error opening XPM file (%s)", img
->spec
, Qnil
);
4168 case XpmFileInvalid
:
4169 image_error ("Invalid XPM file (%s)", img
->spec
, Qnil
);
4173 image_error ("Out of memory (%s)", img
->spec
, Qnil
);
4176 case XpmColorFailed
:
4177 image_error ("Color allocation error (%s)", img
->spec
, Qnil
);
4181 image_error ("Unknown error (%s)", img
->spec
, Qnil
);
4186 #ifdef ALLOC_XPM_COLORS
4187 xpm_free_color_cache ();
4189 return rc
== XpmSuccess
;
4192 #endif /* HAVE_XPM */
4196 /* XPM support functions for Mac OS where libxpm is not available.
4197 Only XPM version 3 (without any extensions) is supported. */
4199 static int xpm_scan
P_ ((const unsigned char **, const unsigned char *,
4200 const unsigned char **, int *));
4201 static Lisp_Object xpm_make_color_table_v
4202 P_ ((void (**) (Lisp_Object
, const unsigned char *, int, Lisp_Object
),
4203 Lisp_Object (**) (Lisp_Object
, const unsigned char *, int)));
4204 static void xpm_put_color_table_v
P_ ((Lisp_Object
, const unsigned char *,
4206 static Lisp_Object xpm_get_color_table_v
P_ ((Lisp_Object
,
4207 const unsigned char *, int));
4208 static Lisp_Object xpm_make_color_table_h
4209 P_ ((void (**) (Lisp_Object
, const unsigned char *, int, Lisp_Object
),
4210 Lisp_Object (**) (Lisp_Object
, const unsigned char *, int)));
4211 static void xpm_put_color_table_h
P_ ((Lisp_Object
, const unsigned char *,
4213 static Lisp_Object xpm_get_color_table_h
P_ ((Lisp_Object
,
4214 const unsigned char *, int));
4215 static int xpm_str_to_color_key
P_ ((const char *));
4216 static int xpm_load_image
P_ ((struct frame
*, struct image
*,
4217 const unsigned char *, const unsigned char *));
4219 /* Tokens returned from xpm_scan. */
4228 /* Scan an XPM data and return a character (< 256) or a token defined
4229 by enum xpm_token above. *S and END are the start (inclusive) and
4230 the end (exclusive) addresses of the data, respectively. Advance
4231 *S while scanning. If token is either XPM_TK_IDENT or
4232 XPM_TK_STRING, *BEG and *LEN are set to the start address and the
4233 length of the corresponding token, respectively. */
4236 xpm_scan (s
, end
, beg
, len
)
4237 const unsigned char **s
, *end
, **beg
;
4244 /* Skip white-space. */
4245 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
4248 /* gnus-pointer.xpm uses '-' in its identifier.
4249 sb-dir-plus.xpm uses '+' in its identifier. */
4250 if (isalpha (c
) || c
== '_' || c
== '-' || c
== '+')
4254 (c
= **s
, isalnum (c
) || c
== '_' || c
== '-' || c
== '+'))
4257 return XPM_TK_IDENT
;
4262 while (*s
< end
&& **s
!= '"')
4267 return XPM_TK_STRING
;
4271 if (*s
< end
&& **s
== '*')
4273 /* C-style comment. */
4277 while (*s
< end
&& *(*s
)++ != '*')
4280 while (*s
< end
&& **s
!= '/');
4294 /* Functions for color table lookup in XPM data. A key is a string
4295 specifying the color of each pixel in XPM data. A value is either
4296 an integer that specifies a pixel color, Qt that specifies
4297 transparency, or Qnil for the unspecified color. If the length of
4298 the key string is one, a vector is used as a table. Otherwise, a
4299 hash table is used. */
4302 xpm_make_color_table_v (put_func
, get_func
)
4303 void (**put_func
) (Lisp_Object
, const unsigned char *, int, Lisp_Object
);
4304 Lisp_Object (**get_func
) (Lisp_Object
, const unsigned char *, int);
4306 *put_func
= xpm_put_color_table_v
;
4307 *get_func
= xpm_get_color_table_v
;
4308 return Fmake_vector (make_number (256), Qnil
);
4312 xpm_put_color_table_v (color_table
, chars_start
, chars_len
, color
)
4313 Lisp_Object color_table
;
4314 const unsigned char *chars_start
;
4318 XVECTOR (color_table
)->contents
[*chars_start
] = color
;
4322 xpm_get_color_table_v (color_table
, chars_start
, chars_len
)
4323 Lisp_Object color_table
;
4324 const unsigned char *chars_start
;
4327 return XVECTOR (color_table
)->contents
[*chars_start
];
4331 xpm_make_color_table_h (put_func
, get_func
)
4332 void (**put_func
) (Lisp_Object
, const unsigned char *, int, Lisp_Object
);
4333 Lisp_Object (**get_func
) (Lisp_Object
, const unsigned char *, int);
4335 *put_func
= xpm_put_color_table_h
;
4336 *get_func
= xpm_get_color_table_h
;
4337 return make_hash_table (Qequal
, make_number (DEFAULT_HASH_SIZE
),
4338 make_float (DEFAULT_REHASH_SIZE
),
4339 make_float (DEFAULT_REHASH_THRESHOLD
),
4344 xpm_put_color_table_h (color_table
, chars_start
, chars_len
, color
)
4345 Lisp_Object color_table
;
4346 const unsigned char *chars_start
;
4350 struct Lisp_Hash_Table
*table
= XHASH_TABLE (color_table
);
4352 Lisp_Object chars
= make_unibyte_string (chars_start
, chars_len
);
4354 hash_lookup (table
, chars
, &hash_code
);
4355 hash_put (table
, chars
, color
, hash_code
);
4359 xpm_get_color_table_h (color_table
, chars_start
, chars_len
)
4360 Lisp_Object color_table
;
4361 const unsigned char *chars_start
;
4364 struct Lisp_Hash_Table
*table
= XHASH_TABLE (color_table
);
4365 int i
= hash_lookup (table
, make_unibyte_string (chars_start
, chars_len
),
4368 return i
>= 0 ? HASH_VALUE (table
, i
) : Qnil
;
4371 enum xpm_color_key
{
4379 static const char xpm_color_key_strings
[][4] = {"s", "m", "g4", "g", "c"};
4382 xpm_str_to_color_key (s
)
4388 i
< sizeof xpm_color_key_strings
/ sizeof xpm_color_key_strings
[0];
4390 if (strcmp (xpm_color_key_strings
[i
], s
) == 0)
4396 xpm_load_image (f
, img
, contents
, end
)
4399 const unsigned char *contents
, *end
;
4401 const unsigned char *s
= contents
, *beg
, *str
;
4402 unsigned char buffer
[BUFSIZ
];
4403 int width
, height
, x
, y
;
4404 int num_colors
, chars_per_pixel
;
4406 void (*put_color_table
) (Lisp_Object
, const unsigned char *, int, Lisp_Object
);
4407 Lisp_Object (*get_color_table
) (Lisp_Object
, const unsigned char *, int);
4408 Lisp_Object frame
, color_symbols
, color_table
;
4409 int best_key
, have_mask
= 0;
4410 XImagePtr ximg
= NULL
, mask_img
= NULL
;
4413 LA1 = xpm_scan (&s, end, &beg, &len)
4415 #define expect(TOKEN) \
4416 if (LA1 != (TOKEN)) \
4421 #define expect_ident(IDENT) \
4422 if (LA1 == XPM_TK_IDENT \
4423 && strlen ((IDENT)) == len && memcmp ((IDENT), beg, len) == 0) \
4428 if (!(end
- s
>= 9 && memcmp (s
, "/* XPM */", 9) == 0))
4432 expect_ident ("static");
4433 expect_ident ("char");
4435 expect (XPM_TK_IDENT
);
4440 expect (XPM_TK_STRING
);
4443 memcpy (buffer
, beg
, len
);
4445 if (sscanf (buffer
, "%d %d %d %d", &width
, &height
,
4446 &num_colors
, &chars_per_pixel
) != 4
4447 || width
<= 0 || height
<= 0
4448 || num_colors
<= 0 || chars_per_pixel
<= 0)
4451 if (!check_image_size (f
, width
, height
))
4453 image_error ("Invalid image size", Qnil
, Qnil
);
4459 XSETFRAME (frame
, f
);
4460 if (!NILP (Fxw_display_color_p (frame
)))
4461 best_key
= XPM_COLOR_KEY_C
;
4462 else if (!NILP (Fx_display_grayscale_p (frame
)))
4463 best_key
= (XFASTINT (Fx_display_planes (frame
)) > 2
4464 ? XPM_COLOR_KEY_G
: XPM_COLOR_KEY_G4
);
4466 best_key
= XPM_COLOR_KEY_M
;
4468 color_symbols
= image_spec_value (img
->spec
, QCcolor_symbols
, NULL
);
4469 if (chars_per_pixel
== 1)
4470 color_table
= xpm_make_color_table_v (&put_color_table
,
4473 color_table
= xpm_make_color_table_h (&put_color_table
,
4476 while (num_colors
-- > 0)
4478 unsigned char *color
, *max_color
;
4479 int key
, next_key
, max_key
= 0;
4480 Lisp_Object symbol_color
= Qnil
, color_val
;
4483 expect (XPM_TK_STRING
);
4484 if (len
<= chars_per_pixel
|| len
>= BUFSIZ
+ chars_per_pixel
)
4486 memcpy (buffer
, beg
+ chars_per_pixel
, len
- chars_per_pixel
);
4487 buffer
[len
- chars_per_pixel
] = '\0';
4489 str
= strtok (buffer
, " \t");
4492 key
= xpm_str_to_color_key (str
);
4497 color
= strtok (NULL
, " \t");
4501 while ((str
= strtok (NULL
, " \t")) != NULL
)
4503 next_key
= xpm_str_to_color_key (str
);
4506 color
[strlen (color
)] = ' ';
4509 if (key
== XPM_COLOR_KEY_S
)
4511 if (NILP (symbol_color
))
4512 symbol_color
= build_string (color
);
4514 else if (max_key
< key
&& key
<= best_key
)
4524 if (!NILP (color_symbols
) && !NILP (symbol_color
))
4526 Lisp_Object specified_color
= Fassoc (symbol_color
, color_symbols
);
4528 if (CONSP (specified_color
) && STRINGP (XCDR (specified_color
)))
4530 if (xstricmp (SDATA (XCDR (specified_color
)), "None") == 0)
4532 else if (x_defined_color (f
, SDATA (XCDR (specified_color
)),
4534 color_val
= make_number (cdef
.pixel
);
4537 if (NILP (color_val
) && max_key
> 0)
4539 if (xstricmp (max_color
, "None") == 0)
4541 else if (x_defined_color (f
, max_color
, &cdef
, 0))
4542 color_val
= make_number (cdef
.pixel
);
4544 if (!NILP (color_val
))
4545 (*put_color_table
) (color_table
, beg
, chars_per_pixel
, color_val
);
4550 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0,
4551 &ximg
, &img
->pixmap
)
4552 || !x_create_x_image_and_pixmap (f
, width
, height
, 1,
4553 &mask_img
, &img
->mask
))
4555 image_error ("Out of memory (%s)", img
->spec
, Qnil
);
4559 for (y
= 0; y
< height
; y
++)
4561 expect (XPM_TK_STRING
);
4563 if (len
< width
* chars_per_pixel
)
4565 for (x
= 0; x
< width
; x
++, str
+= chars_per_pixel
)
4567 Lisp_Object color_val
=
4568 (*get_color_table
) (color_table
, str
, chars_per_pixel
);
4570 XPutPixel (ximg
, x
, y
,
4571 (INTEGERP (color_val
) ? XINT (color_val
)
4572 : FRAME_FOREGROUND_PIXEL (f
)));
4573 XPutPixel (mask_img
, x
, y
,
4574 (!EQ (color_val
, Qt
) ? PIX_MASK_DRAW
4575 : (have_mask
= 1, PIX_MASK_RETAIN
)));
4582 img
->height
= height
;
4584 /* Maybe fill in the background field while we have ximg handy. */
4585 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
4586 IMAGE_BACKGROUND (img
, f
, ximg
);
4588 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
4589 x_destroy_x_image (ximg
);
4592 /* Fill in the background_transparent field while we have the
4594 image_background_transparent (img
, f
, mask_img
);
4596 x_put_x_image (f
, mask_img
, img
->mask
, width
, height
);
4597 x_destroy_x_image (mask_img
);
4601 x_destroy_x_image (mask_img
);
4602 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
4603 img
->mask
= NO_PIXMAP
;
4609 image_error ("Invalid XPM file (%s)", img
->spec
, Qnil
);
4611 x_destroy_x_image (ximg
);
4612 x_destroy_x_image (mask_img
);
4613 x_clear_image (f
, img
);
4627 Lisp_Object file_name
;
4629 /* If IMG->spec specifies a file name, create a non-file spec from it. */
4630 file_name
= image_spec_value (img
->spec
, QCfile
, NULL
);
4631 if (STRINGP (file_name
))
4634 unsigned char *contents
;
4636 struct gcpro gcpro1
;
4638 file
= x_find_image_file (file_name
);
4640 if (!STRINGP (file
))
4642 image_error ("Cannot find image file `%s'", file_name
, Qnil
);
4647 contents
= slurp_file (SDATA (file
), &size
);
4648 if (contents
== NULL
)
4650 image_error ("Error loading XPM image `%s'", img
->spec
, Qnil
);
4655 success_p
= xpm_load_image (f
, img
, contents
, contents
+ size
);
4663 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
4664 success_p
= xpm_load_image (f
, img
, SDATA (data
),
4665 SDATA (data
) + SBYTES (data
));
4675 /***********************************************************************
4677 ***********************************************************************/
4679 #ifdef COLOR_TABLE_SUPPORT
4681 /* An entry in the color table mapping an RGB color to a pixel color. */
4686 unsigned long pixel
;
4688 /* Next in color table collision list. */
4689 struct ct_color
*next
;
4692 /* The bucket vector size to use. Must be prime. */
4696 /* Value is a hash of the RGB color given by R, G, and B. */
4698 #define CT_HASH_RGB(R, G, B) (((R) << 16) ^ ((G) << 8) ^ (B))
4700 /* The color hash table. */
4702 struct ct_color
**ct_table
;
4704 /* Number of entries in the color table. */
4706 int ct_colors_allocated
;
4708 /* Initialize the color table. */
4713 int size
= CT_SIZE
* sizeof (*ct_table
);
4714 ct_table
= (struct ct_color
**) xmalloc (size
);
4715 bzero (ct_table
, size
);
4716 ct_colors_allocated
= 0;
4720 /* Free memory associated with the color table. */
4726 struct ct_color
*p
, *next
;
4728 for (i
= 0; i
< CT_SIZE
; ++i
)
4729 for (p
= ct_table
[i
]; p
; p
= next
)
4740 /* Value is a pixel color for RGB color R, G, B on frame F. If an
4741 entry for that color already is in the color table, return the
4742 pixel color of that entry. Otherwise, allocate a new color for R,
4743 G, B, and make an entry in the color table. */
4745 static unsigned long
4746 lookup_rgb_color (f
, r
, g
, b
)
4750 unsigned hash
= CT_HASH_RGB (r
, g
, b
);
4751 int i
= hash
% CT_SIZE
;
4753 Display_Info
*dpyinfo
;
4755 /* Handle TrueColor visuals specially, which improves performance by
4756 two orders of magnitude. Freeing colors on TrueColor visuals is
4757 a nop, and pixel colors specify RGB values directly. See also
4758 the Xlib spec, chapter 3.1. */
4759 dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
4760 if (dpyinfo
->red_bits
> 0)
4762 unsigned long pr
, pg
, pb
;
4764 /* Apply gamma-correction like normal color allocation does. */
4768 color
.red
= r
, color
.green
= g
, color
.blue
= b
;
4769 gamma_correct (f
, &color
);
4770 r
= color
.red
, g
= color
.green
, b
= color
.blue
;
4773 /* Scale down RGB values to the visual's bits per RGB, and shift
4774 them to the right position in the pixel color. Note that the
4775 original RGB values are 16-bit values, as usual in X. */
4776 pr
= (r
>> (16 - dpyinfo
->red_bits
)) << dpyinfo
->red_offset
;
4777 pg
= (g
>> (16 - dpyinfo
->green_bits
)) << dpyinfo
->green_offset
;
4778 pb
= (b
>> (16 - dpyinfo
->blue_bits
)) << dpyinfo
->blue_offset
;
4780 /* Assemble the pixel color. */
4781 return pr
| pg
| pb
;
4784 for (p
= ct_table
[i
]; p
; p
= p
->next
)
4785 if (p
->r
== r
&& p
->g
== g
&& p
->b
== b
)
4791 #ifdef HAVE_X_WINDOWS
4800 cmap
= FRAME_X_COLORMAP (f
);
4801 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
4804 ++ct_colors_allocated
;
4805 p
= (struct ct_color
*) xmalloc (sizeof *p
);
4809 p
->pixel
= color
.pixel
;
4810 p
->next
= ct_table
[i
];
4814 return FRAME_FOREGROUND_PIXEL (f
);
4819 color
= PALETTERGB (r
, g
, b
);
4821 color
= RGB_TO_ULONG (r
, g
, b
);
4822 #endif /* HAVE_NTGUI */
4823 ++ct_colors_allocated
;
4824 p
= (struct ct_color
*) xmalloc (sizeof *p
);
4829 p
->next
= ct_table
[i
];
4831 #endif /* HAVE_X_WINDOWS */
4839 /* Look up pixel color PIXEL which is used on frame F in the color
4840 table. If not already present, allocate it. Value is PIXEL. */
4842 static unsigned long
4843 lookup_pixel_color (f
, pixel
)
4845 unsigned long pixel
;
4847 int i
= pixel
% CT_SIZE
;
4850 for (p
= ct_table
[i
]; p
; p
= p
->next
)
4851 if (p
->pixel
== pixel
)
4860 #ifdef HAVE_X_WINDOWS
4861 cmap
= FRAME_X_COLORMAP (f
);
4862 color
.pixel
= pixel
;
4863 x_query_color (f
, &color
);
4864 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
4867 cmap
= DefaultColormapOfScreen (FRAME_X_SCREEN (f
));
4868 color
.pixel
= pixel
;
4869 XQueryColor (NULL
, cmap
, &color
);
4870 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
4872 #endif /* HAVE_X_WINDOWS */
4876 ++ct_colors_allocated
;
4878 p
= (struct ct_color
*) xmalloc (sizeof *p
);
4883 p
->next
= ct_table
[i
];
4887 return FRAME_FOREGROUND_PIXEL (f
);
4893 /* Value is a vector of all pixel colors contained in the color table,
4894 allocated via xmalloc. Set *N to the number of colors. */
4896 static unsigned long *
4897 colors_in_color_table (n
)
4902 unsigned long *colors
;
4904 if (ct_colors_allocated
== 0)
4911 colors
= (unsigned long *) xmalloc (ct_colors_allocated
4913 *n
= ct_colors_allocated
;
4915 for (i
= j
= 0; i
< CT_SIZE
; ++i
)
4916 for (p
= ct_table
[i
]; p
; p
= p
->next
)
4917 colors
[j
++] = p
->pixel
;
4923 #else /* COLOR_TABLE_SUPPORT */
4925 static unsigned long
4926 lookup_rgb_color (f
, r
, g
, b
)
4930 unsigned long pixel
;
4933 pixel
= RGB_TO_ULONG (r
>> 8, g
>> 8, b
>> 8);
4934 gamma_correct (f
, &pixel
);
4938 pixel
= PALETTERGB (r
>> 8, g
>> 8, b
>> 8);
4939 #endif /* HAVE_NTGUI */
4948 #endif /* COLOR_TABLE_SUPPORT */
4951 /***********************************************************************
4953 ***********************************************************************/
4955 static XColor
*x_to_xcolors
P_ ((struct frame
*, struct image
*, int));
4956 static void x_from_xcolors
P_ ((struct frame
*, struct image
*, XColor
*));
4957 static void x_detect_edges
P_ ((struct frame
*, struct image
*, int[9], int));
4960 static void XPutPixel (XImagePtr
, int, int, COLORREF
);
4961 #endif /* HAVE_NTGUI */
4963 /* Non-zero means draw a cross on images having `:conversion
4966 int cross_disabled_images
;
4968 /* Edge detection matrices for different edge-detection
4971 static int emboss_matrix
[9] = {
4973 2, -1, 0, /* y - 1 */
4975 0, 1, -2 /* y + 1 */
4978 static int laplace_matrix
[9] = {
4980 1, 0, 0, /* y - 1 */
4982 0, 0, -1 /* y + 1 */
4985 /* Value is the intensity of the color whose red/green/blue values
4988 #define COLOR_INTENSITY(R, G, B) ((2 * (R) + 3 * (G) + (B)) / 6)
4991 /* On frame F, return an array of XColor structures describing image
4992 IMG->pixmap. Each XColor structure has its pixel color set. RGB_P
4993 non-zero means also fill the red/green/blue members of the XColor
4994 structures. Value is a pointer to the array of XColors structures,
4995 allocated with xmalloc; it must be freed by the caller. */
4998 x_to_xcolors (f
, img
, rgb_p
)
5005 XImagePtr_or_DC ximg
;
5009 #endif /* HAVE_NTGUI */
5011 colors
= (XColor
*) xmalloc (img
->width
* img
->height
* sizeof *colors
);
5014 /* Get the X image IMG->pixmap. */
5015 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
5016 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
5018 /* Load the image into a memory device context. */
5019 hdc
= get_frame_dc (f
);
5020 ximg
= CreateCompatibleDC (hdc
);
5021 release_frame_dc (f
, hdc
);
5022 prev
= SelectObject (ximg
, img
->pixmap
);
5023 #endif /* HAVE_NTGUI */
5025 /* Fill the `pixel' members of the XColor array. I wished there
5026 were an easy and portable way to circumvent XGetPixel. */
5028 for (y
= 0; y
< img
->height
; ++y
)
5032 #ifdef HAVE_X_WINDOWS
5033 for (x
= 0; x
< img
->width
; ++x
, ++p
)
5034 p
->pixel
= XGetPixel (ximg
, x
, y
);
5036 x_query_colors (f
, row
, img
->width
);
5040 for (x
= 0; x
< img
->width
; ++x
, ++p
)
5042 /* W32_TODO: palette support needed here? */
5043 p
->pixel
= GET_PIXEL (ximg
, x
, y
);
5047 p
->red
= RED16_FROM_ULONG (p
->pixel
);
5048 p
->green
= GREEN16_FROM_ULONG (p
->pixel
);
5049 p
->blue
= BLUE16_FROM_ULONG (p
->pixel
);
5052 p
->red
= 256 * GetRValue (p
->pixel
);
5053 p
->green
= 256 * GetGValue (p
->pixel
);
5054 p
->blue
= 256 * GetBValue (p
->pixel
);
5055 #endif /* HAVE_NTGUI */
5058 #endif /* HAVE_X_WINDOWS */
5061 Destroy_Image (ximg
, prev
);
5068 /* Put a pixel of COLOR at position X, Y in XIMG. XIMG must have been
5069 created with CreateDIBSection, with the pointer to the bit values
5070 stored in ximg->data. */
5073 XPutPixel (ximg
, x
, y
, color
)
5078 int width
= ximg
->info
.bmiHeader
.biWidth
;
5079 int height
= ximg
->info
.bmiHeader
.biHeight
;
5080 unsigned char * pixel
;
5082 /* True color images. */
5083 if (ximg
->info
.bmiHeader
.biBitCount
== 24)
5085 int rowbytes
= width
* 3;
5086 /* Ensure scanlines are aligned on 4 byte boundaries. */
5088 rowbytes
+= 4 - (rowbytes
% 4);
5090 pixel
= ximg
->data
+ y
* rowbytes
+ x
* 3;
5091 /* Windows bitmaps are in BGR order. */
5092 *pixel
= GetBValue (color
);
5093 *(pixel
+ 1) = GetGValue (color
);
5094 *(pixel
+ 2) = GetRValue (color
);
5096 /* Monochrome images. */
5097 else if (ximg
->info
.bmiHeader
.biBitCount
== 1)
5099 int rowbytes
= width
/ 8;
5100 /* Ensure scanlines are aligned on 4 byte boundaries. */
5102 rowbytes
+= 4 - (rowbytes
% 4);
5103 pixel
= ximg
->data
+ y
* rowbytes
+ x
/ 8;
5104 /* Filter out palette info. */
5105 if (color
& 0x00ffffff)
5106 *pixel
= *pixel
| (1 << x
% 8);
5108 *pixel
= *pixel
& ~(1 << x
% 8);
5111 image_error ("XPutPixel: palette image not supported", Qnil
, Qnil
);
5114 #endif /* HAVE_NTGUI */
5116 /* Create IMG->pixmap from an array COLORS of XColor structures, whose
5117 RGB members are set. F is the frame on which this all happens.
5118 COLORS will be freed; an existing IMG->pixmap will be freed, too. */
5121 x_from_xcolors (f
, img
, colors
)
5131 init_color_table ();
5133 x_create_x_image_and_pixmap (f
, img
->width
, img
->height
, 0,
5136 for (y
= 0; y
< img
->height
; ++y
)
5137 for (x
= 0; x
< img
->width
; ++x
, ++p
)
5139 unsigned long pixel
;
5140 pixel
= lookup_rgb_color (f
, p
->red
, p
->green
, p
->blue
);
5141 XPutPixel (oimg
, x
, y
, pixel
);
5145 x_clear_image_1 (f
, img
, 1, 0, 1);
5147 x_put_x_image (f
, oimg
, pixmap
, img
->width
, img
->height
);
5148 x_destroy_x_image (oimg
);
5149 img
->pixmap
= pixmap
;
5150 #ifdef COLOR_TABLE_SUPPORT
5151 img
->colors
= colors_in_color_table (&img
->ncolors
);
5152 free_color_table ();
5153 #endif /* COLOR_TABLE_SUPPORT */
5157 /* On frame F, perform edge-detection on image IMG.
5159 MATRIX is a nine-element array specifying the transformation
5160 matrix. See emboss_matrix for an example.
5162 COLOR_ADJUST is a color adjustment added to each pixel of the
5166 x_detect_edges (f
, img
, matrix
, color_adjust
)
5169 int matrix
[9], color_adjust
;
5171 XColor
*colors
= x_to_xcolors (f
, img
, 1);
5175 for (i
= sum
= 0; i
< 9; ++i
)
5176 sum
+= abs (matrix
[i
]);
5178 #define COLOR(A, X, Y) ((A) + (Y) * img->width + (X))
5180 new = (XColor
*) xmalloc (img
->width
* img
->height
* sizeof *new);
5182 for (y
= 0; y
< img
->height
; ++y
)
5184 p
= COLOR (new, 0, y
);
5185 p
->red
= p
->green
= p
->blue
= 0xffff/2;
5186 p
= COLOR (new, img
->width
- 1, y
);
5187 p
->red
= p
->green
= p
->blue
= 0xffff/2;
5190 for (x
= 1; x
< img
->width
- 1; ++x
)
5192 p
= COLOR (new, x
, 0);
5193 p
->red
= p
->green
= p
->blue
= 0xffff/2;
5194 p
= COLOR (new, x
, img
->height
- 1);
5195 p
->red
= p
->green
= p
->blue
= 0xffff/2;
5198 for (y
= 1; y
< img
->height
- 1; ++y
)
5200 p
= COLOR (new, 1, y
);
5202 for (x
= 1; x
< img
->width
- 1; ++x
, ++p
)
5204 int r
, g
, b
, y1
, x1
;
5207 for (y1
= y
- 1; y1
< y
+ 2; ++y1
)
5208 for (x1
= x
- 1; x1
< x
+ 2; ++x1
, ++i
)
5211 XColor
*t
= COLOR (colors
, x1
, y1
);
5212 r
+= matrix
[i
] * t
->red
;
5213 g
+= matrix
[i
] * t
->green
;
5214 b
+= matrix
[i
] * t
->blue
;
5217 r
= (r
/ sum
+ color_adjust
) & 0xffff;
5218 g
= (g
/ sum
+ color_adjust
) & 0xffff;
5219 b
= (b
/ sum
+ color_adjust
) & 0xffff;
5220 p
->red
= p
->green
= p
->blue
= COLOR_INTENSITY (r
, g
, b
);
5225 x_from_xcolors (f
, img
, new);
5231 /* Perform the pre-defined `emboss' edge-detection on image IMG
5239 x_detect_edges (f
, img
, emboss_matrix
, 0xffff / 2);
5243 /* Transform image IMG which is used on frame F with a Laplace
5244 edge-detection algorithm. The result is an image that can be used
5245 to draw disabled buttons, for example. */
5252 x_detect_edges (f
, img
, laplace_matrix
, 45000);
5256 /* Perform edge-detection on image IMG on frame F, with specified
5257 transformation matrix MATRIX and color-adjustment COLOR_ADJUST.
5259 MATRIX must be either
5261 - a list of at least 9 numbers in row-major form
5262 - a vector of at least 9 numbers
5264 COLOR_ADJUST nil means use a default; otherwise it must be a
5268 x_edge_detection (f
, img
, matrix
, color_adjust
)
5271 Lisp_Object matrix
, color_adjust
;
5279 i
< 9 && CONSP (matrix
) && NUMBERP (XCAR (matrix
));
5280 ++i
, matrix
= XCDR (matrix
))
5281 trans
[i
] = XFLOATINT (XCAR (matrix
));
5283 else if (VECTORP (matrix
) && ASIZE (matrix
) >= 9)
5285 for (i
= 0; i
< 9 && NUMBERP (AREF (matrix
, i
)); ++i
)
5286 trans
[i
] = XFLOATINT (AREF (matrix
, i
));
5289 if (NILP (color_adjust
))
5290 color_adjust
= make_number (0xffff / 2);
5292 if (i
== 9 && NUMBERP (color_adjust
))
5293 x_detect_edges (f
, img
, trans
, (int) XFLOATINT (color_adjust
));
5297 /* Transform image IMG on frame F so that it looks disabled. */
5300 x_disable_image (f
, img
)
5304 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
5306 int n_planes
= dpyinfo
->n_planes
* dpyinfo
->n_cbits
;
5308 int n_planes
= dpyinfo
->n_planes
;
5309 #endif /* HAVE_NTGUI */
5313 /* Color (or grayscale). Convert to gray, and equalize. Just
5314 drawing such images with a stipple can look very odd, so
5315 we're using this method instead. */
5316 XColor
*colors
= x_to_xcolors (f
, img
, 1);
5318 const int h
= 15000;
5319 const int l
= 30000;
5321 for (p
= colors
, end
= colors
+ img
->width
* img
->height
;
5325 int i
= COLOR_INTENSITY (p
->red
, p
->green
, p
->blue
);
5326 int i2
= (0xffff - h
- l
) * i
/ 0xffff + l
;
5327 p
->red
= p
->green
= p
->blue
= i2
;
5330 x_from_xcolors (f
, img
, colors
);
5333 /* Draw a cross over the disabled image, if we must or if we
5335 if (n_planes
< 2 || cross_disabled_images
)
5338 Display
*dpy
= FRAME_X_DISPLAY (f
);
5342 #define MaskForeground(f) PIX_MASK_DRAW
5344 #define MaskForeground(f) WHITE_PIX_DEFAULT (f)
5347 gc
= XCreateGC (dpy
, img
->pixmap
, 0, NULL
);
5348 XSetForeground (dpy
, gc
, BLACK_PIX_DEFAULT (f
));
5349 XDrawLine (dpy
, img
->pixmap
, gc
, 0, 0,
5350 img
->width
- 1, img
->height
- 1);
5351 XDrawLine (dpy
, img
->pixmap
, gc
, 0, img
->height
- 1,
5357 gc
= XCreateGC (dpy
, img
->mask
, 0, NULL
);
5358 XSetForeground (dpy
, gc
, MaskForeground (f
));
5359 XDrawLine (dpy
, img
->mask
, gc
, 0, 0,
5360 img
->width
- 1, img
->height
- 1);
5361 XDrawLine (dpy
, img
->mask
, gc
, 0, img
->height
- 1,
5369 hdc
= get_frame_dc (f
);
5370 bmpdc
= CreateCompatibleDC (hdc
);
5371 release_frame_dc (f
, hdc
);
5373 prev
= SelectObject (bmpdc
, img
->pixmap
);
5375 SetTextColor (bmpdc
, BLACK_PIX_DEFAULT (f
));
5376 MoveToEx (bmpdc
, 0, 0, NULL
);
5377 LineTo (bmpdc
, img
->width
- 1, img
->height
- 1);
5378 MoveToEx (bmpdc
, 0, img
->height
- 1, NULL
);
5379 LineTo (bmpdc
, img
->width
- 1, 0);
5383 SelectObject (bmpdc
, img
->mask
);
5384 SetTextColor (bmpdc
, WHITE_PIX_DEFAULT (f
));
5385 MoveToEx (bmpdc
, 0, 0, NULL
);
5386 LineTo (bmpdc
, img
->width
- 1, img
->height
- 1);
5387 MoveToEx (bmpdc
, 0, img
->height
- 1, NULL
);
5388 LineTo (bmpdc
, img
->width
- 1, 0);
5390 SelectObject (bmpdc
, prev
);
5392 #endif /* HAVE_NTGUI */
5397 /* Build a mask for image IMG which is used on frame F. FILE is the
5398 name of an image file, for error messages. HOW determines how to
5399 determine the background color of IMG. If it is a list '(R G B)',
5400 with R, G, and B being integers >= 0, take that as the color of the
5401 background. Otherwise, determine the background color of IMG
5402 heuristically. Value is non-zero if successful. */
5405 x_build_heuristic_mask (f
, img
, how
)
5410 XImagePtr_or_DC ximg
;
5418 #endif /* HAVE_NTGUI */
5419 int x
, y
, rc
, use_img_background
;
5420 unsigned long bg
= 0;
5424 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
5425 img
->mask
= NO_PIXMAP
;
5426 img
->background_transparent_valid
= 0;
5430 /* Create an image and pixmap serving as mask. */
5431 rc
= x_create_x_image_and_pixmap (f
, img
->width
, img
->height
, 1,
5432 &mask_img
, &img
->mask
);
5436 /* Get the X image of IMG->pixmap. */
5437 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
, 0, 0,
5438 img
->width
, img
->height
,
5441 /* Create the bit array serving as mask. */
5442 row_width
= (img
->width
+ 7) / 8;
5443 mask_img
= xmalloc (row_width
* img
->height
);
5444 bzero (mask_img
, row_width
* img
->height
);
5446 /* Create a memory device context for IMG->pixmap. */
5447 frame_dc
= get_frame_dc (f
);
5448 ximg
= CreateCompatibleDC (frame_dc
);
5449 release_frame_dc (f
, frame_dc
);
5450 prev
= SelectObject (ximg
, img
->pixmap
);
5451 #endif /* HAVE_NTGUI */
5453 /* Determine the background color of ximg. If HOW is `(R G B)'
5454 take that as color. Otherwise, use the image's background color. */
5455 use_img_background
= 1;
5461 for (i
= 0; i
< 3 && CONSP (how
) && NATNUMP (XCAR (how
)); ++i
)
5463 rgb
[i
] = XFASTINT (XCAR (how
)) & 0xffff;
5467 if (i
== 3 && NILP (how
))
5469 char color_name
[30];
5470 sprintf (color_name
, "#%04x%04x%04x", rgb
[0], rgb
[1], rgb
[2]);
5473 0x00ffffff & /* Filter out palette info. */
5474 #endif /* HAVE_NTGUI */
5475 x_alloc_image_color (f
, img
, build_string (color_name
), 0));
5476 use_img_background
= 0;
5480 if (use_img_background
)
5481 bg
= four_corners_best (ximg
, img
->corners
, img
->width
, img
->height
);
5483 /* Set all bits in mask_img to 1 whose color in ximg is different
5484 from the background color bg. */
5486 for (y
= 0; y
< img
->height
; ++y
)
5487 for (x
= 0; x
< img
->width
; ++x
)
5488 XPutPixel (mask_img
, x
, y
, (XGetPixel (ximg
, x
, y
) != bg
5489 ? PIX_MASK_DRAW
: PIX_MASK_RETAIN
));
5491 /* Fill in the background_transparent field while we have the mask handy. */
5492 image_background_transparent (img
, f
, mask_img
);
5494 /* Put mask_img into img->mask. */
5495 x_put_x_image (f
, mask_img
, img
->mask
, img
->width
, img
->height
);
5496 x_destroy_x_image (mask_img
);
5499 for (y
= 0; y
< img
->height
; ++y
)
5500 for (x
= 0; x
< img
->width
; ++x
)
5502 COLORREF p
= GetPixel (ximg
, x
, y
);
5504 mask_img
[y
* row_width
+ x
/ 8] |= 1 << (x
% 8);
5507 /* Create the mask image. */
5508 img
->mask
= w32_create_pixmap_from_bitmap_data (img
->width
, img
->height
,
5510 /* Fill in the background_transparent field while we have the mask handy. */
5511 SelectObject (ximg
, img
->mask
);
5512 image_background_transparent (img
, f
, ximg
);
5514 /* Was: x_destroy_x_image ((XImagePtr )mask_img); which seems bogus ++kfs */
5516 #endif /* HAVE_NTGUI */
5518 Destroy_Image (ximg
, prev
);
5524 /***********************************************************************
5525 PBM (mono, gray, color)
5526 ***********************************************************************/
5528 static int pbm_image_p
P_ ((Lisp_Object object
));
5529 static int pbm_load
P_ ((struct frame
*f
, struct image
*img
));
5530 static int pbm_scan_number
P_ ((unsigned char **, unsigned char *));
5532 /* The symbol `pbm' identifying images of this type. */
5536 /* Indices of image specification fields in gs_format, below. */
5538 enum pbm_keyword_index
5554 /* Vector of image_keyword structures describing the format
5555 of valid user-defined image specifications. */
5557 static struct image_keyword pbm_format
[PBM_LAST
] =
5559 {":type", IMAGE_SYMBOL_VALUE
, 1},
5560 {":file", IMAGE_STRING_VALUE
, 0},
5561 {":data", IMAGE_STRING_VALUE
, 0},
5562 {":ascent", IMAGE_ASCENT_VALUE
, 0},
5563 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
5564 {":relief", IMAGE_INTEGER_VALUE
, 0},
5565 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5566 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5567 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5568 {":foreground", IMAGE_STRING_OR_NIL_VALUE
, 0},
5569 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
5572 /* Structure describing the image type `pbm'. */
5574 static struct image_type pbm_type
=
5584 /* Return non-zero if OBJECT is a valid PBM image specification. */
5587 pbm_image_p (object
)
5590 struct image_keyword fmt
[PBM_LAST
];
5592 bcopy (pbm_format
, fmt
, sizeof fmt
);
5594 if (!parse_image_spec (object
, fmt
, PBM_LAST
, Qpbm
))
5597 /* Must specify either :data or :file. */
5598 return fmt
[PBM_DATA
].count
+ fmt
[PBM_FILE
].count
== 1;
5602 /* Scan a decimal number from *S and return it. Advance *S while
5603 reading the number. END is the end of the string. Value is -1 at
5607 pbm_scan_number (s
, end
)
5608 unsigned char **s
, *end
;
5610 int c
= 0, val
= -1;
5614 /* Skip white-space. */
5615 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
5620 /* Skip comment to end of line. */
5621 while (*s
< end
&& (c
= *(*s
)++, c
!= '\n'))
5624 else if (isdigit (c
))
5626 /* Read decimal number. */
5628 while (*s
< end
&& (c
= *(*s
)++, isdigit (c
)))
5629 val
= 10 * val
+ c
- '0';
5641 #if 0 /* Unused. ++kfs */
5643 /* Read FILE into memory. Value is a pointer to a buffer allocated
5644 with xmalloc holding FILE's contents. Value is null if an error
5645 occurred. *SIZE is set to the size of the file. */
5648 pbm_read_file (file
, size
)
5656 if (stat (SDATA (file
), &st
) == 0
5657 && (fp
= fopen (SDATA (file
), "rb")) != NULL
5658 && (buf
= (char *) xmalloc (st
.st_size
),
5659 fread (buf
, 1, st
.st_size
, fp
) == st
.st_size
))
5678 #endif /* HAVE_NTGUI */
5680 /* Load PBM image IMG for use on frame F. */
5688 int width
, height
, max_color_idx
= 0;
5690 Lisp_Object file
, specified_file
;
5691 enum {PBM_MONO
, PBM_GRAY
, PBM_COLOR
} type
;
5692 struct gcpro gcpro1
;
5693 unsigned char *contents
= NULL
;
5694 unsigned char *end
, *p
;
5697 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
5701 if (STRINGP (specified_file
))
5703 file
= x_find_image_file (specified_file
);
5704 if (!STRINGP (file
))
5706 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
5711 contents
= slurp_file (SDATA (file
), &size
);
5712 if (contents
== NULL
)
5714 image_error ("Error reading `%s'", file
, Qnil
);
5720 end
= contents
+ size
;
5725 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
5727 end
= p
+ SBYTES (data
);
5730 /* Check magic number. */
5731 if (end
- p
< 2 || *p
++ != 'P')
5733 image_error ("Not a PBM image: `%s'", img
->spec
, Qnil
);
5743 raw_p
= 0, type
= PBM_MONO
;
5747 raw_p
= 0, type
= PBM_GRAY
;
5751 raw_p
= 0, type
= PBM_COLOR
;
5755 raw_p
= 1, type
= PBM_MONO
;
5759 raw_p
= 1, type
= PBM_GRAY
;
5763 raw_p
= 1, type
= PBM_COLOR
;
5767 image_error ("Not a PBM image: `%s'", img
->spec
, Qnil
);
5771 /* Read width, height, maximum color-component. Characters
5772 starting with `#' up to the end of a line are ignored. */
5773 width
= pbm_scan_number (&p
, end
);
5774 height
= pbm_scan_number (&p
, end
);
5776 if (type
!= PBM_MONO
)
5778 max_color_idx
= pbm_scan_number (&p
, end
);
5779 if (raw_p
&& max_color_idx
> 255)
5780 max_color_idx
= 255;
5783 if (!check_image_size (f
, width
, height
)
5784 || (type
!= PBM_MONO
&& max_color_idx
< 0))
5787 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0,
5788 &ximg
, &img
->pixmap
))
5791 /* Initialize the color hash table. */
5792 init_color_table ();
5794 if (type
== PBM_MONO
)
5797 struct image_keyword fmt
[PBM_LAST
];
5798 unsigned long fg
= FRAME_FOREGROUND_PIXEL (f
);
5799 unsigned long bg
= FRAME_BACKGROUND_PIXEL (f
);
5801 /* Parse the image specification. */
5802 bcopy (pbm_format
, fmt
, sizeof fmt
);
5803 parse_image_spec (img
->spec
, fmt
, PBM_LAST
, Qpbm
);
5805 /* Get foreground and background colors, maybe allocate colors. */
5806 if (fmt
[PBM_FOREGROUND
].count
5807 && STRINGP (fmt
[PBM_FOREGROUND
].value
))
5808 fg
= x_alloc_image_color (f
, img
, fmt
[PBM_FOREGROUND
].value
, fg
);
5809 if (fmt
[PBM_BACKGROUND
].count
5810 && STRINGP (fmt
[PBM_BACKGROUND
].value
))
5812 bg
= x_alloc_image_color (f
, img
, fmt
[PBM_BACKGROUND
].value
, bg
);
5813 img
->background
= bg
;
5814 img
->background_valid
= 1;
5817 for (y
= 0; y
< height
; ++y
)
5818 for (x
= 0; x
< width
; ++x
)
5826 x_destroy_x_image (ximg
);
5827 x_clear_image (f
, img
);
5828 image_error ("Invalid image size in image `%s'",
5838 g
= pbm_scan_number (&p
, end
);
5840 XPutPixel (ximg
, x
, y
, g
? fg
: bg
);
5846 && ((type
== PBM_GRAY
)
5847 ? (p
+ height
* width
> end
)
5848 : (p
+ 3 * height
* width
> end
)))
5850 x_destroy_x_image (ximg
);
5851 x_clear_image (f
, img
);
5852 image_error ("Invalid image size in image `%s'",
5857 for (y
= 0; y
< height
; ++y
)
5858 for (x
= 0; x
< width
; ++x
)
5862 if (type
== PBM_GRAY
)
5863 r
= g
= b
= raw_p
? *p
++ : pbm_scan_number (&p
, end
);
5872 r
= pbm_scan_number (&p
, end
);
5873 g
= pbm_scan_number (&p
, end
);
5874 b
= pbm_scan_number (&p
, end
);
5877 if (r
< 0 || g
< 0 || b
< 0)
5879 x_destroy_x_image (ximg
);
5880 image_error ("Invalid pixel value in image `%s'",
5885 /* RGB values are now in the range 0..max_color_idx.
5886 Scale this to the range 0..0xffff supported by X. */
5887 r
= (double) r
* 65535 / max_color_idx
;
5888 g
= (double) g
* 65535 / max_color_idx
;
5889 b
= (double) b
* 65535 / max_color_idx
;
5890 XPutPixel (ximg
, x
, y
, lookup_rgb_color (f
, r
, g
, b
));
5894 #ifdef COLOR_TABLE_SUPPORT
5895 /* Store in IMG->colors the colors allocated for the image, and
5896 free the color table. */
5897 img
->colors
= colors_in_color_table (&img
->ncolors
);
5898 free_color_table ();
5899 #endif /* COLOR_TABLE_SUPPORT */
5902 img
->height
= height
;
5904 /* Maybe fill in the background field while we have ximg handy. */
5906 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
5907 /* Casting avoids a GCC warning. */
5908 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
5910 /* Put the image into a pixmap. */
5911 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
5912 x_destroy_x_image (ximg
);
5914 /* X and W32 versions did it here, MAC version above. ++kfs
5916 img->height = height; */
5924 /***********************************************************************
5926 ***********************************************************************/
5928 #if defined (HAVE_PNG) || defined (MAC_OS)
5930 /* Function prototypes. */
5932 static int png_image_p
P_ ((Lisp_Object object
));
5933 static int png_load
P_ ((struct frame
*f
, struct image
*img
));
5935 /* The symbol `png' identifying images of this type. */
5939 /* Indices of image specification fields in png_format, below. */
5941 enum png_keyword_index
5956 /* Vector of image_keyword structures describing the format
5957 of valid user-defined image specifications. */
5959 static struct image_keyword png_format
[PNG_LAST
] =
5961 {":type", IMAGE_SYMBOL_VALUE
, 1},
5962 {":data", IMAGE_STRING_VALUE
, 0},
5963 {":file", IMAGE_STRING_VALUE
, 0},
5964 {":ascent", IMAGE_ASCENT_VALUE
, 0},
5965 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
5966 {":relief", IMAGE_INTEGER_VALUE
, 0},
5967 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5968 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5969 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5970 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
5973 /* Structure describing the image type `png'. */
5975 static struct image_type png_type
=
5984 /* Return non-zero if OBJECT is a valid PNG image specification. */
5987 png_image_p (object
)
5990 struct image_keyword fmt
[PNG_LAST
];
5991 bcopy (png_format
, fmt
, sizeof fmt
);
5993 if (!parse_image_spec (object
, fmt
, PNG_LAST
, Qpng
))
5996 /* Must specify either the :data or :file keyword. */
5997 return fmt
[PNG_FILE
].count
+ fmt
[PNG_DATA
].count
== 1;
6000 #endif /* HAVE_PNG || MAC_OS */
6005 #if defined HAVE_LIBPNG_PNG_H
6006 # include <libpng/png.h>
6012 /* PNG library details. */
6014 DEF_IMGLIB_FN (png_get_io_ptr
);
6015 DEF_IMGLIB_FN (png_check_sig
);
6016 DEF_IMGLIB_FN (png_create_read_struct
);
6017 DEF_IMGLIB_FN (png_create_info_struct
);
6018 DEF_IMGLIB_FN (png_destroy_read_struct
);
6019 DEF_IMGLIB_FN (png_set_read_fn
);
6020 DEF_IMGLIB_FN (png_set_sig_bytes
);
6021 DEF_IMGLIB_FN (png_read_info
);
6022 DEF_IMGLIB_FN (png_get_IHDR
);
6023 DEF_IMGLIB_FN (png_get_valid
);
6024 DEF_IMGLIB_FN (png_set_strip_16
);
6025 DEF_IMGLIB_FN (png_set_expand
);
6026 DEF_IMGLIB_FN (png_set_gray_to_rgb
);
6027 DEF_IMGLIB_FN (png_set_background
);
6028 DEF_IMGLIB_FN (png_get_bKGD
);
6029 DEF_IMGLIB_FN (png_read_update_info
);
6030 DEF_IMGLIB_FN (png_get_channels
);
6031 DEF_IMGLIB_FN (png_get_rowbytes
);
6032 DEF_IMGLIB_FN (png_read_image
);
6033 DEF_IMGLIB_FN (png_read_end
);
6034 DEF_IMGLIB_FN (png_error
);
6037 init_png_functions (Lisp_Object libraries
)
6041 /* Try loading libpng under probable names. */
6042 if (!(library
= w32_delayed_load (libraries
, Qpng
)))
6045 LOAD_IMGLIB_FN (library
, png_get_io_ptr
);
6046 LOAD_IMGLIB_FN (library
, png_check_sig
);
6047 LOAD_IMGLIB_FN (library
, png_create_read_struct
);
6048 LOAD_IMGLIB_FN (library
, png_create_info_struct
);
6049 LOAD_IMGLIB_FN (library
, png_destroy_read_struct
);
6050 LOAD_IMGLIB_FN (library
, png_set_read_fn
);
6051 LOAD_IMGLIB_FN (library
, png_set_sig_bytes
);
6052 LOAD_IMGLIB_FN (library
, png_read_info
);
6053 LOAD_IMGLIB_FN (library
, png_get_IHDR
);
6054 LOAD_IMGLIB_FN (library
, png_get_valid
);
6055 LOAD_IMGLIB_FN (library
, png_set_strip_16
);
6056 LOAD_IMGLIB_FN (library
, png_set_expand
);
6057 LOAD_IMGLIB_FN (library
, png_set_gray_to_rgb
);
6058 LOAD_IMGLIB_FN (library
, png_set_background
);
6059 LOAD_IMGLIB_FN (library
, png_get_bKGD
);
6060 LOAD_IMGLIB_FN (library
, png_read_update_info
);
6061 LOAD_IMGLIB_FN (library
, png_get_channels
);
6062 LOAD_IMGLIB_FN (library
, png_get_rowbytes
);
6063 LOAD_IMGLIB_FN (library
, png_read_image
);
6064 LOAD_IMGLIB_FN (library
, png_read_end
);
6065 LOAD_IMGLIB_FN (library
, png_error
);
6070 #define fn_png_get_io_ptr png_get_io_ptr
6071 #define fn_png_check_sig png_check_sig
6072 #define fn_png_create_read_struct png_create_read_struct
6073 #define fn_png_create_info_struct png_create_info_struct
6074 #define fn_png_destroy_read_struct png_destroy_read_struct
6075 #define fn_png_set_read_fn png_set_read_fn
6076 #define fn_png_set_sig_bytes png_set_sig_bytes
6077 #define fn_png_read_info png_read_info
6078 #define fn_png_get_IHDR png_get_IHDR
6079 #define fn_png_get_valid png_get_valid
6080 #define fn_png_set_strip_16 png_set_strip_16
6081 #define fn_png_set_expand png_set_expand
6082 #define fn_png_set_gray_to_rgb png_set_gray_to_rgb
6083 #define fn_png_set_background png_set_background
6084 #define fn_png_get_bKGD png_get_bKGD
6085 #define fn_png_read_update_info png_read_update_info
6086 #define fn_png_get_channels png_get_channels
6087 #define fn_png_get_rowbytes png_get_rowbytes
6088 #define fn_png_read_image png_read_image
6089 #define fn_png_read_end png_read_end
6090 #define fn_png_error png_error
6092 #endif /* HAVE_NTGUI */
6094 /* Error and warning handlers installed when the PNG library
6098 my_png_error (png_ptr
, msg
)
6099 png_struct
*png_ptr
;
6102 xassert (png_ptr
!= NULL
);
6103 image_error ("PNG error: %s", build_string (msg
), Qnil
);
6104 longjmp (png_ptr
->jmpbuf
, 1);
6109 my_png_warning (png_ptr
, msg
)
6110 png_struct
*png_ptr
;
6113 xassert (png_ptr
!= NULL
);
6114 image_error ("PNG warning: %s", build_string (msg
), Qnil
);
6117 /* Memory source for PNG decoding. */
6119 struct png_memory_storage
6121 unsigned char *bytes
; /* The data */
6122 size_t len
; /* How big is it? */
6123 int index
; /* Where are we? */
6127 /* Function set as reader function when reading PNG image from memory.
6128 PNG_PTR is a pointer to the PNG control structure. Copy LENGTH
6129 bytes from the input to DATA. */
6132 png_read_from_memory (png_ptr
, data
, length
)
6133 png_structp png_ptr
;
6137 struct png_memory_storage
*tbr
6138 = (struct png_memory_storage
*) fn_png_get_io_ptr (png_ptr
);
6140 if (length
> tbr
->len
- tbr
->index
)
6141 fn_png_error (png_ptr
, "Read error");
6143 bcopy (tbr
->bytes
+ tbr
->index
, data
, length
);
6144 tbr
->index
= tbr
->index
+ length
;
6148 /* Function set as reader function when reading PNG image from a file.
6149 PNG_PTR is a pointer to the PNG control structure. Copy LENGTH
6150 bytes from the input to DATA. */
6153 png_read_from_file (png_ptr
, data
, length
)
6154 png_structp png_ptr
;
6158 FILE *fp
= (FILE *) fn_png_get_io_ptr (png_ptr
);
6160 if (fread (data
, 1, length
, fp
) < length
)
6161 fn_png_error (png_ptr
, "Read error");
6165 /* Load PNG image IMG for use on frame F. Value is non-zero if
6173 Lisp_Object file
, specified_file
;
6174 Lisp_Object specified_data
;
6176 XImagePtr ximg
, mask_img
= NULL
;
6177 struct gcpro gcpro1
;
6178 png_struct
*png_ptr
= NULL
;
6179 png_info
*info_ptr
= NULL
, *end_info
= NULL
;
6180 FILE *volatile fp
= NULL
;
6182 png_byte
* volatile pixels
= NULL
;
6183 png_byte
** volatile rows
= NULL
;
6184 png_uint_32 width
, height
;
6185 int bit_depth
, color_type
, interlace_type
;
6187 png_uint_32 row_bytes
;
6189 double screen_gamma
;
6190 struct png_memory_storage tbr
; /* Data to be read */
6192 /* Find out what file to load. */
6193 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
6194 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
6198 if (NILP (specified_data
))
6200 file
= x_find_image_file (specified_file
);
6201 if (!STRINGP (file
))
6203 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
6208 /* Open the image file. */
6209 fp
= fopen (SDATA (file
), "rb");
6212 image_error ("Cannot open image file `%s'", file
, Qnil
);
6217 /* Check PNG signature. */
6218 if (fread (sig
, 1, sizeof sig
, fp
) != sizeof sig
6219 || !fn_png_check_sig (sig
, sizeof sig
))
6221 image_error ("Not a PNG file: `%s'", file
, Qnil
);
6229 /* Read from memory. */
6230 tbr
.bytes
= SDATA (specified_data
);
6231 tbr
.len
= SBYTES (specified_data
);
6234 /* Check PNG signature. */
6235 if (tbr
.len
< sizeof sig
6236 || !fn_png_check_sig (tbr
.bytes
, sizeof sig
))
6238 image_error ("Not a PNG image: `%s'", img
->spec
, Qnil
);
6243 /* Need to skip past the signature. */
6244 tbr
.bytes
+= sizeof (sig
);
6247 /* Initialize read and info structs for PNG lib. Casting return
6248 value avoids a GCC warning on W32. */
6249 png_ptr
= (png_structp
)fn_png_create_read_struct (PNG_LIBPNG_VER_STRING
,
6254 if (fp
) fclose (fp
);
6259 /* Casting return value avoids a GCC warning on W32. */
6260 info_ptr
= (png_infop
)fn_png_create_info_struct (png_ptr
);
6263 fn_png_destroy_read_struct (&png_ptr
, NULL
, NULL
);
6264 if (fp
) fclose (fp
);
6269 /* Casting return value avoids a GCC warning on W32. */
6270 end_info
= (png_infop
)fn_png_create_info_struct (png_ptr
);
6273 fn_png_destroy_read_struct (&png_ptr
, &info_ptr
, NULL
);
6274 if (fp
) fclose (fp
);
6279 /* Set error jump-back. We come back here when the PNG library
6280 detects an error. */
6281 if (setjmp (png_ptr
->jmpbuf
))
6285 fn_png_destroy_read_struct (&png_ptr
, &info_ptr
, &end_info
);
6288 if (fp
) fclose (fp
);
6293 /* Read image info. */
6294 if (!NILP (specified_data
))
6295 fn_png_set_read_fn (png_ptr
, (void *) &tbr
, png_read_from_memory
);
6297 fn_png_set_read_fn (png_ptr
, (void *) fp
, png_read_from_file
);
6299 fn_png_set_sig_bytes (png_ptr
, sizeof sig
);
6300 fn_png_read_info (png_ptr
, info_ptr
);
6301 fn_png_get_IHDR (png_ptr
, info_ptr
, &width
, &height
, &bit_depth
, &color_type
,
6302 &interlace_type
, NULL
, NULL
);
6304 if (!check_image_size (f
, width
, height
))
6307 /* If image contains simply transparency data, we prefer to
6308 construct a clipping mask. */
6309 if (fn_png_get_valid (png_ptr
, info_ptr
, PNG_INFO_tRNS
))
6314 /* This function is easier to write if we only have to handle
6315 one data format: RGB or RGBA with 8 bits per channel. Let's
6316 transform other formats into that format. */
6318 /* Strip more than 8 bits per channel. */
6319 if (bit_depth
== 16)
6320 fn_png_set_strip_16 (png_ptr
);
6322 /* Expand data to 24 bit RGB, or 8 bit grayscale, with alpha channel
6324 fn_png_set_expand (png_ptr
);
6326 /* Convert grayscale images to RGB. */
6327 if (color_type
== PNG_COLOR_TYPE_GRAY
6328 || color_type
== PNG_COLOR_TYPE_GRAY_ALPHA
)
6329 fn_png_set_gray_to_rgb (png_ptr
);
6331 screen_gamma
= (f
->gamma
? 1 / f
->gamma
/ 0.45455 : 2.2);
6333 #if 0 /* Avoid double gamma correction for PNG images. */
6334 { /* Tell the PNG lib to handle gamma correction for us. */
6337 #if defined(PNG_READ_sRGB_SUPPORTED) || defined(PNG_WRITE_sRGB_SUPPORTED)
6338 if (png_get_sRGB (png_ptr
, info_ptr
, &intent
))
6339 /* The libpng documentation says this is right in this case. */
6340 png_set_gamma (png_ptr
, screen_gamma
, 0.45455);
6343 if (png_get_gAMA (png_ptr
, info_ptr
, &image_gamma
))
6344 /* Image contains gamma information. */
6345 png_set_gamma (png_ptr
, screen_gamma
, image_gamma
);
6347 /* Use the standard default for the image gamma. */
6348 png_set_gamma (png_ptr
, screen_gamma
, 0.45455);
6352 /* Handle alpha channel by combining the image with a background
6353 color. Do this only if a real alpha channel is supplied. For
6354 simple transparency, we prefer a clipping mask. */
6357 png_color_16
*image_bg
;
6358 Lisp_Object specified_bg
6359 = image_spec_value (img
->spec
, QCbackground
, NULL
);
6361 if (STRINGP (specified_bg
))
6362 /* The user specified `:background', use that. */
6364 /* W32 version incorrectly used COLORREF here!! ++kfs */
6366 if (x_defined_color (f
, SDATA (specified_bg
), &color
, 0))
6368 png_color_16 user_bg
;
6370 bzero (&user_bg
, sizeof user_bg
);
6371 user_bg
.red
= color
.red
>> 8;
6372 user_bg
.green
= color
.green
>> 8;
6373 user_bg
.blue
= color
.blue
>> 8;
6375 fn_png_set_background (png_ptr
, &user_bg
,
6376 PNG_BACKGROUND_GAMMA_SCREEN
, 0, 1.0);
6379 /* The commented-out code checked if the png specifies a default
6380 background color, and uses that. Since we use the current
6381 frame background, it is OK for us to ignore this.
6383 else if (fn_png_get_bKGD (png_ptr, info_ptr, &image_bg))
6384 fn_png_set_background (png_ptr, image_bg,
6385 PNG_BACKGROUND_GAMMA_FILE, 1, 1.0);
6389 /* Image does not contain a background color with which
6390 to combine the image data via an alpha channel. Use
6391 the frame's background instead. */
6392 #ifdef HAVE_X_WINDOWS
6394 png_color_16 frame_background
;
6396 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
6397 x_query_color (f
, &color
);
6399 bzero (&frame_background
, sizeof frame_background
);
6400 frame_background
.red
= color
.red
>> 8;
6401 frame_background
.green
= color
.green
>> 8;
6402 frame_background
.blue
= color
.blue
>> 8;
6403 #endif /* HAVE_X_WINDOWS */
6407 png_color_16 frame_background
;
6408 color
= FRAME_BACKGROUND_PIXEL (f
);
6409 #if 0 /* W32 TODO : Colormap support. */
6410 x_query_color (f
, &color
);
6412 bzero (&frame_background
, sizeof frame_background
);
6413 frame_background
.red
= GetRValue (color
);
6414 frame_background
.green
= GetGValue (color
);
6415 frame_background
.blue
= GetBValue (color
);
6416 #endif /* HAVE_NTGUI */
6419 unsigned long color
;
6420 png_color_16 frame_background
;
6421 color
= FRAME_BACKGROUND_PIXEL (f
);
6422 #if 0 /* MAC/W32 TODO : Colormap support. */
6423 x_query_color (f
, &color
);
6425 bzero (&frame_background
, sizeof frame_background
);
6426 frame_background
.red
= RED_FROM_ULONG (color
);
6427 frame_background
.green
= GREEN_FROM_ULONG (color
);
6428 frame_background
.blue
= BLUE_FROM_ULONG (color
);
6431 fn_png_set_background (png_ptr
, &frame_background
,
6432 PNG_BACKGROUND_GAMMA_SCREEN
, 0, 1.0);
6436 /* Update info structure. */
6437 fn_png_read_update_info (png_ptr
, info_ptr
);
6439 /* Get number of channels. Valid values are 1 for grayscale images
6440 and images with a palette, 2 for grayscale images with transparency
6441 information (alpha channel), 3 for RGB images, and 4 for RGB
6442 images with alpha channel, i.e. RGBA. If conversions above were
6443 sufficient we should only have 3 or 4 channels here. */
6444 channels
= fn_png_get_channels (png_ptr
, info_ptr
);
6445 xassert (channels
== 3 || channels
== 4);
6447 /* Number of bytes needed for one row of the image. */
6448 row_bytes
= fn_png_get_rowbytes (png_ptr
, info_ptr
);
6450 /* Allocate memory for the image. */
6451 pixels
= (png_byte
*) xmalloc (row_bytes
* height
* sizeof *pixels
);
6452 rows
= (png_byte
**) xmalloc (height
* sizeof *rows
);
6453 for (i
= 0; i
< height
; ++i
)
6454 rows
[i
] = pixels
+ i
* row_bytes
;
6456 /* Read the entire image. */
6457 fn_png_read_image (png_ptr
, rows
);
6458 fn_png_read_end (png_ptr
, info_ptr
);
6465 /* Create the X image and pixmap. */
6466 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
,
6470 /* Create an image and pixmap serving as mask if the PNG image
6471 contains an alpha channel. */
6474 && !x_create_x_image_and_pixmap (f
, width
, height
, 1,
6475 &mask_img
, &img
->mask
))
6477 x_destroy_x_image (ximg
);
6478 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->pixmap
);
6479 img
->pixmap
= NO_PIXMAP
;
6483 /* Fill the X image and mask from PNG data. */
6484 init_color_table ();
6486 for (y
= 0; y
< height
; ++y
)
6488 png_byte
*p
= rows
[y
];
6490 for (x
= 0; x
< width
; ++x
)
6497 XPutPixel (ximg
, x
, y
, lookup_rgb_color (f
, r
, g
, b
));
6498 /* An alpha channel, aka mask channel, associates variable
6499 transparency with an image. Where other image formats
6500 support binary transparency---fully transparent or fully
6501 opaque---PNG allows up to 254 levels of partial transparency.
6502 The PNG library implements partial transparency by combining
6503 the image with a specified background color.
6505 I'm not sure how to handle this here nicely: because the
6506 background on which the image is displayed may change, for
6507 real alpha channel support, it would be necessary to create
6508 a new image for each possible background.
6510 What I'm doing now is that a mask is created if we have
6511 boolean transparency information. Otherwise I'm using
6512 the frame's background color to combine the image with. */
6517 XPutPixel (mask_img
, x
, y
, *p
> 0 ? PIX_MASK_DRAW
: PIX_MASK_RETAIN
);
6523 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
6524 /* Set IMG's background color from the PNG image, unless the user
6528 if (fn_png_get_bKGD (png_ptr
, info_ptr
, &bg
))
6530 img
->background
= lookup_rgb_color (f
, bg
->red
, bg
->green
, bg
->blue
);
6531 img
->background_valid
= 1;
6535 #ifdef COLOR_TABLE_SUPPORT
6536 /* Remember colors allocated for this image. */
6537 img
->colors
= colors_in_color_table (&img
->ncolors
);
6538 free_color_table ();
6539 #endif /* COLOR_TABLE_SUPPORT */
6542 fn_png_destroy_read_struct (&png_ptr
, &info_ptr
, &end_info
);
6547 img
->height
= height
;
6549 /* Maybe fill in the background field while we have ximg handy.
6550 Casting avoids a GCC warning. */
6551 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
6553 /* Put the image into the pixmap, then free the X image and its buffer. */
6554 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
6555 x_destroy_x_image (ximg
);
6557 /* Same for the mask. */
6560 /* Fill in the background_transparent field while we have the
6561 mask handy. Casting avoids a GCC warning. */
6562 image_background_transparent (img
, f
, (XImagePtr_or_DC
)mask_img
);
6564 x_put_x_image (f
, mask_img
, img
->mask
, img
->width
, img
->height
);
6565 x_destroy_x_image (mask_img
);
6572 #else /* HAVE_PNG */
6581 if (MyCGImageCreateWithPNGDataProvider
)
6582 return image_load_quartz2d (f
, img
, 1);
6585 return image_load_quicktime (f
, img
, kQTFileTypePNG
);
6589 #endif /* !HAVE_PNG */
6593 /***********************************************************************
6595 ***********************************************************************/
6597 #if defined (HAVE_JPEG) || defined (MAC_OS)
6599 static int jpeg_image_p
P_ ((Lisp_Object object
));
6600 static int jpeg_load
P_ ((struct frame
*f
, struct image
*img
));
6602 /* The symbol `jpeg' identifying images of this type. */
6606 /* Indices of image specification fields in gs_format, below. */
6608 enum jpeg_keyword_index
6617 JPEG_HEURISTIC_MASK
,
6623 /* Vector of image_keyword structures describing the format
6624 of valid user-defined image specifications. */
6626 static struct image_keyword jpeg_format
[JPEG_LAST
] =
6628 {":type", IMAGE_SYMBOL_VALUE
, 1},
6629 {":data", IMAGE_STRING_VALUE
, 0},
6630 {":file", IMAGE_STRING_VALUE
, 0},
6631 {":ascent", IMAGE_ASCENT_VALUE
, 0},
6632 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
6633 {":relief", IMAGE_INTEGER_VALUE
, 0},
6634 {":conversions", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6635 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6636 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6637 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
6640 /* Structure describing the image type `jpeg'. */
6642 static struct image_type jpeg_type
=
6651 /* Return non-zero if OBJECT is a valid JPEG image specification. */
6654 jpeg_image_p (object
)
6657 struct image_keyword fmt
[JPEG_LAST
];
6659 bcopy (jpeg_format
, fmt
, sizeof fmt
);
6661 if (!parse_image_spec (object
, fmt
, JPEG_LAST
, Qjpeg
))
6664 /* Must specify either the :data or :file keyword. */
6665 return fmt
[JPEG_FILE
].count
+ fmt
[JPEG_DATA
].count
== 1;
6668 #endif /* HAVE_JPEG || MAC_OS */
6672 /* Work around a warning about HAVE_STDLIB_H being redefined in
6674 #ifdef HAVE_STDLIB_H
6675 #define HAVE_STDLIB_H_1
6676 #undef HAVE_STDLIB_H
6677 #endif /* HAVE_STLIB_H */
6679 #if defined (HAVE_NTGUI) && !defined (__WIN32__)
6680 /* In older releases of the jpeg library, jpeglib.h will define boolean
6681 differently depending on __WIN32__, so make sure it is defined. */
6685 #include <jpeglib.h>
6689 #ifdef HAVE_STLIB_H_1
6690 #define HAVE_STDLIB_H 1
6695 /* JPEG library details. */
6696 DEF_IMGLIB_FN (jpeg_CreateDecompress
);
6697 DEF_IMGLIB_FN (jpeg_start_decompress
);
6698 DEF_IMGLIB_FN (jpeg_finish_decompress
);
6699 DEF_IMGLIB_FN (jpeg_destroy_decompress
);
6700 DEF_IMGLIB_FN (jpeg_read_header
);
6701 DEF_IMGLIB_FN (jpeg_read_scanlines
);
6702 DEF_IMGLIB_FN (jpeg_std_error
);
6703 DEF_IMGLIB_FN (jpeg_resync_to_restart
);
6706 init_jpeg_functions (Lisp_Object libraries
)
6710 if (!(library
= w32_delayed_load (libraries
, Qjpeg
)))
6713 LOAD_IMGLIB_FN (library
, jpeg_finish_decompress
);
6714 LOAD_IMGLIB_FN (library
, jpeg_read_scanlines
);
6715 LOAD_IMGLIB_FN (library
, jpeg_start_decompress
);
6716 LOAD_IMGLIB_FN (library
, jpeg_read_header
);
6717 LOAD_IMGLIB_FN (library
, jpeg_CreateDecompress
);
6718 LOAD_IMGLIB_FN (library
, jpeg_destroy_decompress
);
6719 LOAD_IMGLIB_FN (library
, jpeg_std_error
);
6720 LOAD_IMGLIB_FN (library
, jpeg_resync_to_restart
);
6724 /* Wrapper since we can't directly assign the function pointer
6725 to another function pointer that was declared more completely easily. */
6727 jpeg_resync_to_restart_wrapper(cinfo
, desired
)
6728 j_decompress_ptr cinfo
;
6731 return fn_jpeg_resync_to_restart (cinfo
, desired
);
6736 #define fn_jpeg_CreateDecompress(a,b,c) jpeg_create_decompress(a)
6737 #define fn_jpeg_start_decompress jpeg_start_decompress
6738 #define fn_jpeg_finish_decompress jpeg_finish_decompress
6739 #define fn_jpeg_destroy_decompress jpeg_destroy_decompress
6740 #define fn_jpeg_read_header jpeg_read_header
6741 #define fn_jpeg_read_scanlines jpeg_read_scanlines
6742 #define fn_jpeg_std_error jpeg_std_error
6743 #define jpeg_resync_to_restart_wrapper jpeg_resync_to_restart
6745 #endif /* HAVE_NTGUI */
6747 struct my_jpeg_error_mgr
6749 struct jpeg_error_mgr pub
;
6750 jmp_buf setjmp_buffer
;
6755 my_error_exit (cinfo
)
6758 struct my_jpeg_error_mgr
*mgr
= (struct my_jpeg_error_mgr
*) cinfo
->err
;
6759 longjmp (mgr
->setjmp_buffer
, 1);
6763 /* Init source method for JPEG data source manager. Called by
6764 jpeg_read_header() before any data is actually read. See
6765 libjpeg.doc from the JPEG lib distribution. */
6768 our_common_init_source (cinfo
)
6769 j_decompress_ptr cinfo
;
6774 /* Method to terminate data source. Called by
6775 jpeg_finish_decompress() after all data has been processed. */
6778 our_common_term_source (cinfo
)
6779 j_decompress_ptr cinfo
;
6784 /* Fill input buffer method for JPEG data source manager. Called
6785 whenever more data is needed. We read the whole image in one step,
6786 so this only adds a fake end of input marker at the end. */
6788 static JOCTET our_memory_buffer
[2];
6791 our_memory_fill_input_buffer (cinfo
)
6792 j_decompress_ptr cinfo
;
6794 /* Insert a fake EOI marker. */
6795 struct jpeg_source_mgr
*src
= cinfo
->src
;
6797 our_memory_buffer
[0] = (JOCTET
) 0xFF;
6798 our_memory_buffer
[1] = (JOCTET
) JPEG_EOI
;
6800 src
->next_input_byte
= our_memory_buffer
;
6801 src
->bytes_in_buffer
= 2;
6806 /* Method to skip over NUM_BYTES bytes in the image data. CINFO->src
6807 is the JPEG data source manager. */
6810 our_memory_skip_input_data (cinfo
, num_bytes
)
6811 j_decompress_ptr cinfo
;
6814 struct jpeg_source_mgr
*src
= (struct jpeg_source_mgr
*) cinfo
->src
;
6818 if (num_bytes
> src
->bytes_in_buffer
)
6819 ERREXIT (cinfo
, JERR_INPUT_EOF
);
6821 src
->bytes_in_buffer
-= num_bytes
;
6822 src
->next_input_byte
+= num_bytes
;
6827 /* Set up the JPEG lib for reading an image from DATA which contains
6828 LEN bytes. CINFO is the decompression info structure created for
6829 reading the image. */
6832 jpeg_memory_src (cinfo
, data
, len
)
6833 j_decompress_ptr cinfo
;
6837 struct jpeg_source_mgr
*src
;
6839 if (cinfo
->src
== NULL
)
6841 /* First time for this JPEG object? */
6842 cinfo
->src
= (struct jpeg_source_mgr
*)
6843 (*cinfo
->mem
->alloc_small
) ((j_common_ptr
) cinfo
, JPOOL_PERMANENT
,
6844 sizeof (struct jpeg_source_mgr
));
6845 src
= (struct jpeg_source_mgr
*) cinfo
->src
;
6846 src
->next_input_byte
= data
;
6849 src
= (struct jpeg_source_mgr
*) cinfo
->src
;
6850 src
->init_source
= our_common_init_source
;
6851 src
->fill_input_buffer
= our_memory_fill_input_buffer
;
6852 src
->skip_input_data
= our_memory_skip_input_data
;
6853 src
->resync_to_restart
= jpeg_resync_to_restart_wrapper
; /* Use default method. */
6854 src
->term_source
= our_common_term_source
;
6855 src
->bytes_in_buffer
= len
;
6856 src
->next_input_byte
= data
;
6860 struct jpeg_stdio_mgr
6862 struct jpeg_source_mgr mgr
;
6869 /* Size of buffer to read JPEG from file.
6870 Not too big, as we want to use alloc_small. */
6871 #define JPEG_STDIO_BUFFER_SIZE 8192
6874 /* Fill input buffer method for JPEG data source manager. Called
6875 whenever more data is needed. The data is read from a FILE *. */
6878 our_stdio_fill_input_buffer (cinfo
)
6879 j_decompress_ptr cinfo
;
6881 struct jpeg_stdio_mgr
*src
;
6883 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6888 bytes
= fread (src
->buffer
, 1, JPEG_STDIO_BUFFER_SIZE
, src
->file
);
6890 src
->mgr
.bytes_in_buffer
= bytes
;
6893 WARNMS (cinfo
, JWRN_JPEG_EOF
);
6895 src
->buffer
[0] = (JOCTET
) 0xFF;
6896 src
->buffer
[1] = (JOCTET
) JPEG_EOI
;
6897 src
->mgr
.bytes_in_buffer
= 2;
6899 src
->mgr
.next_input_byte
= src
->buffer
;
6906 /* Method to skip over NUM_BYTES bytes in the image data. CINFO->src
6907 is the JPEG data source manager. */
6910 our_stdio_skip_input_data (cinfo
, num_bytes
)
6911 j_decompress_ptr cinfo
;
6914 struct jpeg_stdio_mgr
*src
;
6915 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6917 while (num_bytes
> 0 && !src
->finished
)
6919 if (num_bytes
<= src
->mgr
.bytes_in_buffer
)
6921 src
->mgr
.bytes_in_buffer
-= num_bytes
;
6922 src
->mgr
.next_input_byte
+= num_bytes
;
6927 num_bytes
-= src
->mgr
.bytes_in_buffer
;
6928 src
->mgr
.bytes_in_buffer
= 0;
6929 src
->mgr
.next_input_byte
= NULL
;
6931 our_stdio_fill_input_buffer (cinfo
);
6937 /* Set up the JPEG lib for reading an image from a FILE *.
6938 CINFO is the decompression info structure created for
6939 reading the image. */
6942 jpeg_file_src (cinfo
, fp
)
6943 j_decompress_ptr cinfo
;
6946 struct jpeg_stdio_mgr
*src
;
6948 if (cinfo
->src
!= NULL
)
6949 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6952 /* First time for this JPEG object? */
6953 cinfo
->src
= (struct jpeg_source_mgr
*)
6954 (*cinfo
->mem
->alloc_small
) ((j_common_ptr
) cinfo
, JPOOL_PERMANENT
,
6955 sizeof (struct jpeg_stdio_mgr
));
6956 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6957 src
->buffer
= (JOCTET
*)
6958 (*cinfo
->mem
->alloc_small
) ((j_common_ptr
) cinfo
, JPOOL_PERMANENT
,
6959 JPEG_STDIO_BUFFER_SIZE
);
6964 src
->mgr
.init_source
= our_common_init_source
;
6965 src
->mgr
.fill_input_buffer
= our_stdio_fill_input_buffer
;
6966 src
->mgr
.skip_input_data
= our_stdio_skip_input_data
;
6967 src
->mgr
.resync_to_restart
= jpeg_resync_to_restart_wrapper
; /* Use default method. */
6968 src
->mgr
.term_source
= our_common_term_source
;
6969 src
->mgr
.bytes_in_buffer
= 0;
6970 src
->mgr
.next_input_byte
= NULL
;
6974 /* Load image IMG for use on frame F. Patterned after example.c
6975 from the JPEG lib. */
6982 struct jpeg_decompress_struct cinfo
;
6983 struct my_jpeg_error_mgr mgr
;
6984 Lisp_Object file
, specified_file
;
6985 Lisp_Object specified_data
;
6986 FILE * volatile fp
= NULL
;
6988 int row_stride
, x
, y
;
6989 XImagePtr ximg
= NULL
;
6991 unsigned long *colors
;
6993 struct gcpro gcpro1
;
6995 /* Open the JPEG file. */
6996 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
6997 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
7001 if (NILP (specified_data
))
7003 file
= x_find_image_file (specified_file
);
7004 if (!STRINGP (file
))
7006 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
7011 fp
= fopen (SDATA (file
), "rb");
7014 image_error ("Cannot open `%s'", file
, Qnil
);
7020 /* Customize libjpeg's error handling to call my_error_exit when an
7021 error is detected. This function will perform a longjmp.
7022 Casting return value avoids a GCC warning on W32. */
7023 cinfo
.err
= (struct jpeg_error_mgr
*)fn_jpeg_std_error (&mgr
.pub
);
7024 mgr
.pub
.error_exit
= my_error_exit
;
7026 if ((rc
= setjmp (mgr
.setjmp_buffer
)) != 0)
7030 /* Called from my_error_exit. Display a JPEG error. */
7031 char buffer
[JMSG_LENGTH_MAX
];
7032 cinfo
.err
->format_message ((j_common_ptr
) &cinfo
, buffer
);
7033 image_error ("Error reading JPEG image `%s': %s", img
->spec
,
7034 build_string (buffer
));
7037 /* Close the input file and destroy the JPEG object. */
7039 fclose ((FILE *) fp
);
7040 fn_jpeg_destroy_decompress (&cinfo
);
7042 /* If we already have an XImage, free that. */
7043 x_destroy_x_image (ximg
);
7045 /* Free pixmap and colors. */
7046 x_clear_image (f
, img
);
7052 /* Create the JPEG decompression object. Let it read from fp.
7053 Read the JPEG image header. */
7054 fn_jpeg_CreateDecompress (&cinfo
, JPEG_LIB_VERSION
, sizeof (cinfo
));
7056 if (NILP (specified_data
))
7057 jpeg_file_src (&cinfo
, (FILE *) fp
);
7059 jpeg_memory_src (&cinfo
, SDATA (specified_data
),
7060 SBYTES (specified_data
));
7062 fn_jpeg_read_header (&cinfo
, 1);
7064 /* Customize decompression so that color quantization will be used.
7065 Start decompression. */
7066 cinfo
.quantize_colors
= 1;
7067 fn_jpeg_start_decompress (&cinfo
);
7068 width
= img
->width
= cinfo
.output_width
;
7069 height
= img
->height
= cinfo
.output_height
;
7071 if (!check_image_size (f
, width
, height
))
7073 image_error ("Invalid image size", Qnil
, Qnil
);
7074 longjmp (mgr
.setjmp_buffer
, 2);
7077 /* Create X image and pixmap. */
7078 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
7079 longjmp (mgr
.setjmp_buffer
, 2);
7081 /* Allocate colors. When color quantization is used,
7082 cinfo.actual_number_of_colors has been set with the number of
7083 colors generated, and cinfo.colormap is a two-dimensional array
7084 of color indices in the range 0..cinfo.actual_number_of_colors.
7085 No more than 255 colors will be generated. */
7089 if (cinfo
.out_color_components
> 2)
7090 ir
= 0, ig
= 1, ib
= 2;
7091 else if (cinfo
.out_color_components
> 1)
7092 ir
= 0, ig
= 1, ib
= 0;
7094 ir
= 0, ig
= 0, ib
= 0;
7096 /* Use the color table mechanism because it handles colors that
7097 cannot be allocated nicely. Such colors will be replaced with
7098 a default color, and we don't have to care about which colors
7099 can be freed safely, and which can't. */
7100 init_color_table ();
7101 colors
= (unsigned long *) alloca (cinfo
.actual_number_of_colors
7104 for (i
= 0; i
< cinfo
.actual_number_of_colors
; ++i
)
7106 /* Multiply RGB values with 255 because X expects RGB values
7107 in the range 0..0xffff. */
7108 int r
= cinfo
.colormap
[ir
][i
] << 8;
7109 int g
= cinfo
.colormap
[ig
][i
] << 8;
7110 int b
= cinfo
.colormap
[ib
][i
] << 8;
7111 colors
[i
] = lookup_rgb_color (f
, r
, g
, b
);
7114 #ifdef COLOR_TABLE_SUPPORT
7115 /* Remember those colors actually allocated. */
7116 img
->colors
= colors_in_color_table (&img
->ncolors
);
7117 free_color_table ();
7118 #endif /* COLOR_TABLE_SUPPORT */
7122 row_stride
= width
* cinfo
.output_components
;
7123 buffer
= cinfo
.mem
->alloc_sarray ((j_common_ptr
) &cinfo
, JPOOL_IMAGE
,
7125 for (y
= 0; y
< height
; ++y
)
7127 fn_jpeg_read_scanlines (&cinfo
, buffer
, 1);
7128 for (x
= 0; x
< cinfo
.output_width
; ++x
)
7129 XPutPixel (ximg
, x
, y
, colors
[buffer
[0][x
]]);
7133 fn_jpeg_finish_decompress (&cinfo
);
7134 fn_jpeg_destroy_decompress (&cinfo
);
7136 fclose ((FILE *) fp
);
7138 /* Maybe fill in the background field while we have ximg handy. */
7139 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
7140 /* Casting avoids a GCC warning. */
7141 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
7143 /* Put the image into the pixmap. */
7144 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
7145 x_destroy_x_image (ximg
);
7150 #else /* HAVE_JPEG */
7159 return image_load_quartz2d (f
, img
, 0);
7161 return image_load_quicktime (f
, img
, kQTFileTypeJPEG
);
7166 #endif /* !HAVE_JPEG */
7170 /***********************************************************************
7172 ***********************************************************************/
7174 #if defined (HAVE_TIFF) || defined (MAC_OS)
7176 static int tiff_image_p
P_ ((Lisp_Object object
));
7177 static int tiff_load
P_ ((struct frame
*f
, struct image
*img
));
7179 /* The symbol `tiff' identifying images of this type. */
7183 /* Indices of image specification fields in tiff_format, below. */
7185 enum tiff_keyword_index
7194 TIFF_HEURISTIC_MASK
,
7200 /* Vector of image_keyword structures describing the format
7201 of valid user-defined image specifications. */
7203 static struct image_keyword tiff_format
[TIFF_LAST
] =
7205 {":type", IMAGE_SYMBOL_VALUE
, 1},
7206 {":data", IMAGE_STRING_VALUE
, 0},
7207 {":file", IMAGE_STRING_VALUE
, 0},
7208 {":ascent", IMAGE_ASCENT_VALUE
, 0},
7209 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
7210 {":relief", IMAGE_INTEGER_VALUE
, 0},
7211 {":conversions", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7212 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7213 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7214 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
7217 /* Structure describing the image type `tiff'. */
7219 static struct image_type tiff_type
=
7228 /* Return non-zero if OBJECT is a valid TIFF image specification. */
7231 tiff_image_p (object
)
7234 struct image_keyword fmt
[TIFF_LAST
];
7235 bcopy (tiff_format
, fmt
, sizeof fmt
);
7237 if (!parse_image_spec (object
, fmt
, TIFF_LAST
, Qtiff
))
7240 /* Must specify either the :data or :file keyword. */
7241 return fmt
[TIFF_FILE
].count
+ fmt
[TIFF_DATA
].count
== 1;
7244 #endif /* HAVE_TIFF || MAC_OS */
7252 /* TIFF library details. */
7253 DEF_IMGLIB_FN (TIFFSetErrorHandler
);
7254 DEF_IMGLIB_FN (TIFFSetWarningHandler
);
7255 DEF_IMGLIB_FN (TIFFOpen
);
7256 DEF_IMGLIB_FN (TIFFClientOpen
);
7257 DEF_IMGLIB_FN (TIFFGetField
);
7258 DEF_IMGLIB_FN (TIFFReadRGBAImage
);
7259 DEF_IMGLIB_FN (TIFFClose
);
7262 init_tiff_functions (Lisp_Object libraries
)
7266 if (!(library
= w32_delayed_load (libraries
, Qtiff
)))
7269 LOAD_IMGLIB_FN (library
, TIFFSetErrorHandler
);
7270 LOAD_IMGLIB_FN (library
, TIFFSetWarningHandler
);
7271 LOAD_IMGLIB_FN (library
, TIFFOpen
);
7272 LOAD_IMGLIB_FN (library
, TIFFClientOpen
);
7273 LOAD_IMGLIB_FN (library
, TIFFGetField
);
7274 LOAD_IMGLIB_FN (library
, TIFFReadRGBAImage
);
7275 LOAD_IMGLIB_FN (library
, TIFFClose
);
7281 #define fn_TIFFSetErrorHandler TIFFSetErrorHandler
7282 #define fn_TIFFSetWarningHandler TIFFSetWarningHandler
7283 #define fn_TIFFOpen TIFFOpen
7284 #define fn_TIFFClientOpen TIFFClientOpen
7285 #define fn_TIFFGetField TIFFGetField
7286 #define fn_TIFFReadRGBAImage TIFFReadRGBAImage
7287 #define fn_TIFFClose TIFFClose
7289 #endif /* HAVE_NTGUI */
7292 /* Reading from a memory buffer for TIFF images Based on the PNG
7293 memory source, but we have to provide a lot of extra functions.
7296 We really only need to implement read and seek, but I am not
7297 convinced that the TIFF library is smart enough not to destroy
7298 itself if we only hand it the function pointers we need to
7303 unsigned char *bytes
;
7310 tiff_read_from_memory (data
, buf
, size
)
7315 tiff_memory_source
*src
= (tiff_memory_source
*) data
;
7317 if (size
> src
->len
- src
->index
)
7319 bcopy (src
->bytes
+ src
->index
, buf
, size
);
7325 tiff_write_from_memory (data
, buf
, size
)
7334 tiff_seek_in_memory (data
, off
, whence
)
7339 tiff_memory_source
*src
= (tiff_memory_source
*) data
;
7344 case SEEK_SET
: /* Go from beginning of source. */
7348 case SEEK_END
: /* Go from end of source. */
7349 idx
= src
->len
+ off
;
7352 case SEEK_CUR
: /* Go from current position. */
7353 idx
= src
->index
+ off
;
7356 default: /* Invalid `whence'. */
7360 if (idx
> src
->len
|| idx
< 0)
7368 tiff_close_memory (data
)
7376 tiff_mmap_memory (data
, pbase
, psize
)
7381 /* It is already _IN_ memory. */
7386 tiff_unmap_memory (data
, base
, size
)
7391 /* We don't need to do this. */
7395 tiff_size_of_memory (data
)
7398 return ((tiff_memory_source
*) data
)->len
;
7403 tiff_error_handler (title
, format
, ap
)
7404 const char *title
, *format
;
7410 len
= sprintf (buf
, "TIFF error: %s ", title
);
7411 vsprintf (buf
+ len
, format
, ap
);
7412 add_to_log (buf
, Qnil
, Qnil
);
7417 tiff_warning_handler (title
, format
, ap
)
7418 const char *title
, *format
;
7424 len
= sprintf (buf
, "TIFF warning: %s ", title
);
7425 vsprintf (buf
+ len
, format
, ap
);
7426 add_to_log (buf
, Qnil
, Qnil
);
7430 /* Load TIFF image IMG for use on frame F. Value is non-zero if
7438 Lisp_Object file
, specified_file
;
7439 Lisp_Object specified_data
;
7441 int width
, height
, x
, y
;
7445 struct gcpro gcpro1
;
7446 tiff_memory_source memsrc
;
7448 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
7449 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
7453 fn_TIFFSetErrorHandler (tiff_error_handler
);
7454 fn_TIFFSetWarningHandler (tiff_warning_handler
);
7456 if (NILP (specified_data
))
7458 /* Read from a file */
7459 file
= x_find_image_file (specified_file
);
7460 if (!STRINGP (file
))
7462 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
7467 /* Try to open the image file. Casting return value avoids a
7468 GCC warning on W32. */
7469 tiff
= (TIFF
*)fn_TIFFOpen (SDATA (file
), "r");
7472 image_error ("Cannot open `%s'", file
, Qnil
);
7479 /* Memory source! */
7480 memsrc
.bytes
= SDATA (specified_data
);
7481 memsrc
.len
= SBYTES (specified_data
);
7484 /* Casting return value avoids a GCC warning on W32. */
7485 tiff
= (TIFF
*)fn_TIFFClientOpen ("memory_source", "r", &memsrc
,
7486 (TIFFReadWriteProc
) tiff_read_from_memory
,
7487 (TIFFReadWriteProc
) tiff_write_from_memory
,
7488 tiff_seek_in_memory
,
7490 tiff_size_of_memory
,
7496 image_error ("Cannot open memory source for `%s'", img
->spec
, Qnil
);
7502 /* Get width and height of the image, and allocate a raster buffer
7503 of width x height 32-bit values. */
7504 fn_TIFFGetField (tiff
, TIFFTAG_IMAGEWIDTH
, &width
);
7505 fn_TIFFGetField (tiff
, TIFFTAG_IMAGELENGTH
, &height
);
7507 if (!check_image_size (f
, width
, height
))
7509 image_error ("Invalid image size", Qnil
, Qnil
);
7514 buf
= (uint32
*) xmalloc (width
* height
* sizeof *buf
);
7516 rc
= fn_TIFFReadRGBAImage (tiff
, width
, height
, buf
, 0);
7517 fn_TIFFClose (tiff
);
7520 image_error ("Error reading TIFF image `%s'", img
->spec
, Qnil
);
7526 /* Create the X image and pixmap. */
7527 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
7534 /* Initialize the color table. */
7535 init_color_table ();
7537 /* Process the pixel raster. Origin is in the lower-left corner. */
7538 for (y
= 0; y
< height
; ++y
)
7540 uint32
*row
= buf
+ y
* width
;
7542 for (x
= 0; x
< width
; ++x
)
7544 uint32 abgr
= row
[x
];
7545 int r
= TIFFGetR (abgr
) << 8;
7546 int g
= TIFFGetG (abgr
) << 8;
7547 int b
= TIFFGetB (abgr
) << 8;
7548 XPutPixel (ximg
, x
, height
- 1 - y
, lookup_rgb_color (f
, r
, g
, b
));
7552 #ifdef COLOR_TABLE_SUPPORT
7553 /* Remember the colors allocated for the image. Free the color table. */
7554 img
->colors
= colors_in_color_table (&img
->ncolors
);
7555 free_color_table ();
7556 #endif /* COLOR_TABLE_SUPPORT */
7559 img
->height
= height
;
7561 /* Maybe fill in the background field while we have ximg handy. */
7562 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
7563 /* Casting avoids a GCC warning on W32. */
7564 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
7566 /* Put the image into the pixmap, then free the X image and its buffer. */
7567 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
7568 x_destroy_x_image (ximg
);
7575 #else /* HAVE_TIFF */
7583 return image_load_quicktime (f
, img
, kQTFileTypeTIFF
);
7587 #endif /* !HAVE_TIFF */
7591 /***********************************************************************
7593 ***********************************************************************/
7595 #if defined (HAVE_GIF) || defined (MAC_OS)
7597 static int gif_image_p
P_ ((Lisp_Object object
));
7598 static int gif_load
P_ ((struct frame
*f
, struct image
*img
));
7599 static void gif_clear_image
P_ ((struct frame
*f
, struct image
*img
));
7601 /* The symbol `gif' identifying images of this type. */
7605 /* Indices of image specification fields in gif_format, below. */
7607 enum gif_keyword_index
7623 /* Vector of image_keyword structures describing the format
7624 of valid user-defined image specifications. */
7626 static struct image_keyword gif_format
[GIF_LAST
] =
7628 {":type", IMAGE_SYMBOL_VALUE
, 1},
7629 {":data", IMAGE_STRING_VALUE
, 0},
7630 {":file", IMAGE_STRING_VALUE
, 0},
7631 {":ascent", IMAGE_ASCENT_VALUE
, 0},
7632 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
7633 {":relief", IMAGE_INTEGER_VALUE
, 0},
7634 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7635 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7636 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7637 {":image", IMAGE_NON_NEGATIVE_INTEGER_VALUE
, 0},
7638 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
7641 /* Structure describing the image type `gif'. */
7643 static struct image_type gif_type
=
7652 /* Free X resources of GIF image IMG which is used on frame F. */
7655 gif_clear_image (f
, img
)
7659 /* IMG->data.ptr_val may contain extension data. */
7660 img
->data
.lisp_val
= Qnil
;
7661 x_clear_image (f
, img
);
7664 /* Return non-zero if OBJECT is a valid GIF image specification. */
7667 gif_image_p (object
)
7670 struct image_keyword fmt
[GIF_LAST
];
7671 bcopy (gif_format
, fmt
, sizeof fmt
);
7673 if (!parse_image_spec (object
, fmt
, GIF_LAST
, Qgif
))
7676 /* Must specify either the :data or :file keyword. */
7677 return fmt
[GIF_FILE
].count
+ fmt
[GIF_DATA
].count
== 1;
7680 #endif /* HAVE_GIF || MAC_OS */
7684 #if defined (HAVE_NTGUI) || defined (MAC_OS)
7685 /* winuser.h might define DrawText to DrawTextA or DrawTextW.
7686 Undefine before redefining to avoid a preprocessor warning. */
7690 /* avoid conflict with QuickdrawText.h */
7691 #define DrawText gif_DrawText
7692 #include <gif_lib.h>
7695 #else /* HAVE_NTGUI || MAC_OS */
7697 #include <gif_lib.h>
7699 #endif /* HAVE_NTGUI || MAC_OS */
7704 /* GIF library details. */
7705 DEF_IMGLIB_FN (DGifCloseFile
);
7706 DEF_IMGLIB_FN (DGifSlurp
);
7707 DEF_IMGLIB_FN (DGifOpen
);
7708 DEF_IMGLIB_FN (DGifOpenFileName
);
7711 init_gif_functions (Lisp_Object libraries
)
7715 if (!(library
= w32_delayed_load (libraries
, Qgif
)))
7718 LOAD_IMGLIB_FN (library
, DGifCloseFile
);
7719 LOAD_IMGLIB_FN (library
, DGifSlurp
);
7720 LOAD_IMGLIB_FN (library
, DGifOpen
);
7721 LOAD_IMGLIB_FN (library
, DGifOpenFileName
);
7727 #define fn_DGifCloseFile DGifCloseFile
7728 #define fn_DGifSlurp DGifSlurp
7729 #define fn_DGifOpen DGifOpen
7730 #define fn_DGifOpenFileName DGifOpenFileName
7732 #endif /* HAVE_NTGUI */
7734 /* Reading a GIF image from memory
7735 Based on the PNG memory stuff to a certain extent. */
7739 unsigned char *bytes
;
7745 /* Make the current memory source available to gif_read_from_memory.
7746 It's done this way because not all versions of libungif support
7747 a UserData field in the GifFileType structure. */
7748 static gif_memory_source
*current_gif_memory_src
;
7751 gif_read_from_memory (file
, buf
, len
)
7756 gif_memory_source
*src
= current_gif_memory_src
;
7758 if (len
> src
->len
- src
->index
)
7761 bcopy (src
->bytes
+ src
->index
, buf
, len
);
7767 /* Load GIF image IMG for use on frame F. Value is non-zero if
7770 static int interlace_start
[] = {0, 4, 2, 1};
7771 static int interlace_increment
[] = {8, 8, 4, 2};
7778 Lisp_Object file
, specified_file
;
7779 Lisp_Object specified_data
;
7780 int rc
, width
, height
, x
, y
, i
;
7782 ColorMapObject
*gif_color_map
;
7783 unsigned long pixel_colors
[256];
7785 struct gcpro gcpro1
;
7787 int ino
, image_height
, image_width
;
7788 gif_memory_source memsrc
;
7789 unsigned char *raster
;
7791 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
7792 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
7796 if (NILP (specified_data
))
7798 file
= x_find_image_file (specified_file
);
7799 if (!STRINGP (file
))
7801 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
7806 /* Open the GIF file. Casting return value avoids a GCC warning
7808 gif
= (GifFileType
*)fn_DGifOpenFileName (SDATA (file
));
7811 image_error ("Cannot open `%s'", file
, Qnil
);
7818 /* Read from memory! */
7819 current_gif_memory_src
= &memsrc
;
7820 memsrc
.bytes
= SDATA (specified_data
);
7821 memsrc
.len
= SBYTES (specified_data
);
7824 /* Casting return value avoids a GCC warning on W32. */
7825 gif
= (GifFileType
*)fn_DGifOpen(&memsrc
, gif_read_from_memory
);
7828 image_error ("Cannot open memory source `%s'", img
->spec
, Qnil
);
7834 /* Before reading entire contents, check the declared image size. */
7835 if (!check_image_size (f
, gif
->SWidth
, gif
->SHeight
))
7837 image_error ("Invalid image size", Qnil
, Qnil
);
7838 fn_DGifCloseFile (gif
);
7843 /* Read entire contents. */
7844 rc
= fn_DGifSlurp (gif
);
7845 if (rc
== GIF_ERROR
)
7847 image_error ("Error reading `%s'", img
->spec
, Qnil
);
7848 fn_DGifCloseFile (gif
);
7853 image
= image_spec_value (img
->spec
, QCindex
, NULL
);
7854 ino
= INTEGERP (image
) ? XFASTINT (image
) : 0;
7855 if (ino
>= gif
->ImageCount
)
7857 image_error ("Invalid image number `%s' in image `%s'",
7859 fn_DGifCloseFile (gif
);
7864 img
->corners
[TOP_CORNER
] = gif
->SavedImages
[ino
].ImageDesc
.Top
;
7865 img
->corners
[LEFT_CORNER
] = gif
->SavedImages
[ino
].ImageDesc
.Left
;
7866 image_height
= gif
->SavedImages
[ino
].ImageDesc
.Height
;
7867 img
->corners
[BOT_CORNER
] = img
->corners
[TOP_CORNER
] + image_height
;
7868 image_width
= gif
->SavedImages
[ino
].ImageDesc
.Width
;
7869 img
->corners
[RIGHT_CORNER
] = img
->corners
[LEFT_CORNER
] + image_width
;
7871 width
= img
->width
= max (gif
->SWidth
,
7872 max (gif
->Image
.Left
+ gif
->Image
.Width
,
7873 img
->corners
[RIGHT_CORNER
]));
7874 height
= img
->height
= max (gif
->SHeight
,
7875 max (gif
->Image
.Top
+ gif
->Image
.Height
,
7876 img
->corners
[BOT_CORNER
]));
7878 if (!check_image_size (f
, width
, height
))
7880 image_error ("Invalid image size", Qnil
, Qnil
);
7881 fn_DGifCloseFile (gif
);
7886 /* Create the X image and pixmap. */
7887 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
7889 fn_DGifCloseFile (gif
);
7894 /* Allocate colors. */
7895 gif_color_map
= gif
->SavedImages
[ino
].ImageDesc
.ColorMap
;
7897 gif_color_map
= gif
->SColorMap
;
7898 init_color_table ();
7899 bzero (pixel_colors
, sizeof pixel_colors
);
7902 for (i
= 0; i
< gif_color_map
->ColorCount
; ++i
)
7904 int r
= gif_color_map
->Colors
[i
].Red
<< 8;
7905 int g
= gif_color_map
->Colors
[i
].Green
<< 8;
7906 int b
= gif_color_map
->Colors
[i
].Blue
<< 8;
7907 pixel_colors
[i
] = lookup_rgb_color (f
, r
, g
, b
);
7910 #ifdef COLOR_TABLE_SUPPORT
7911 img
->colors
= colors_in_color_table (&img
->ncolors
);
7912 free_color_table ();
7913 #endif /* COLOR_TABLE_SUPPORT */
7915 /* Clear the part of the screen image that are not covered by
7916 the image from the GIF file. Full animated GIF support
7917 requires more than can be done here (see the gif89 spec,
7918 disposal methods). Let's simply assume that the part
7919 not covered by a sub-image is in the frame's background color. */
7920 for (y
= 0; y
< img
->corners
[TOP_CORNER
]; ++y
)
7921 for (x
= 0; x
< width
; ++x
)
7922 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7924 for (y
= img
->corners
[BOT_CORNER
]; y
< height
; ++y
)
7925 for (x
= 0; x
< width
; ++x
)
7926 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7928 for (y
= img
->corners
[TOP_CORNER
]; y
< img
->corners
[BOT_CORNER
]; ++y
)
7930 for (x
= 0; x
< img
->corners
[LEFT_CORNER
]; ++x
)
7931 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7932 for (x
= img
->corners
[RIGHT_CORNER
]; x
< width
; ++x
)
7933 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7936 /* Read the GIF image into the X image. We use a local variable
7937 `raster' here because RasterBits below is a char *, and invites
7938 problems with bytes >= 0x80. */
7939 raster
= (unsigned char *) gif
->SavedImages
[ino
].RasterBits
;
7941 if (gif
->SavedImages
[ino
].ImageDesc
.Interlace
)
7944 int row
= interlace_start
[0];
7948 for (y
= 0; y
< image_height
; y
++)
7950 if (row
>= image_height
)
7952 row
= interlace_start
[++pass
];
7953 while (row
>= image_height
)
7954 row
= interlace_start
[++pass
];
7957 for (x
= 0; x
< image_width
; x
++)
7959 int i
= raster
[(y
* image_width
) + x
];
7960 XPutPixel (ximg
, x
+ img
->corners
[LEFT_CORNER
],
7961 row
+ img
->corners
[TOP_CORNER
], pixel_colors
[i
]);
7964 row
+= interlace_increment
[pass
];
7969 for (y
= 0; y
< image_height
; ++y
)
7970 for (x
= 0; x
< image_width
; ++x
)
7972 int i
= raster
[y
* image_width
+ x
];
7973 XPutPixel (ximg
, x
+ img
->corners
[LEFT_CORNER
],
7974 y
+ img
->corners
[TOP_CORNER
], pixel_colors
[i
]);
7978 /* Save GIF image extension data for `image-extension-data'.
7979 Format is (count IMAGES FUNCTION "BYTES" ...). */
7980 img
->data
.lisp_val
= Qnil
;
7981 if (gif
->SavedImages
[ino
].ExtensionBlockCount
> 0)
7983 ExtensionBlock
*ext
= gif
->SavedImages
[ino
].ExtensionBlocks
;
7984 for (i
= 0; i
< gif
->SavedImages
[ino
].ExtensionBlockCount
; i
++, ext
++)
7985 /* Append (... FUNCTION "BYTES") */
7986 img
->data
.lisp_val
= Fcons (make_unibyte_string (ext
->Bytes
, ext
->ByteCount
),
7987 Fcons (make_number (ext
->Function
),
7988 img
->data
.lisp_val
));
7989 img
->data
.lisp_val
= Fnreverse (img
->data
.lisp_val
);
7991 if (gif
->ImageCount
> 1)
7992 img
->data
.lisp_val
= Fcons (Qcount
,
7993 Fcons (make_number (gif
->ImageCount
),
7994 img
->data
.lisp_val
));
7996 fn_DGifCloseFile (gif
);
7998 /* Maybe fill in the background field while we have ximg handy. */
7999 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
8000 /* Casting avoids a GCC warning. */
8001 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
8003 /* Put the image into the pixmap, then free the X image and its buffer. */
8004 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
8005 x_destroy_x_image (ximg
);
8011 #else /* !HAVE_GIF */
8019 Lisp_Object specified_file
, file
;
8020 Lisp_Object specified_data
;
8022 Boolean graphic_p
, movie_p
, prefer_graphic_p
;
8030 Lisp_Object specified_bg
;
8035 TimeScale time_scale
;
8036 TimeValue time
, duration
;
8041 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
8042 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
8044 /* Animated gifs use QuickTime Movie Toolbox. So initialize it here. */
8047 if (NILP (specified_data
))
8049 /* Read from a file */
8053 err
= find_image_fsspec (specified_file
, &file
, &fss
);
8057 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
8062 err
= CanQuickTimeOpenFile (&fss
, kQTFileTypeGIF
, 0,
8063 &graphic_p
, &movie_p
, &prefer_graphic_p
, 0);
8067 if (!graphic_p
&& !movie_p
)
8069 if (prefer_graphic_p
)
8070 return image_load_qt_1 (f
, img
, kQTFileTypeGIF
, &fss
, NULL
);
8071 err
= OpenMovieFile (&fss
, &refnum
, fsRdPerm
);
8074 err
= NewMovieFromFile (&movie
, refnum
, NULL
, NULL
, 0, NULL
);
8075 CloseMovieFile (refnum
);
8078 image_error ("Error reading `%s'", file
, Qnil
);
8084 /* Memory source! */
8086 long file_type_atom
[3];
8088 err
= PtrToHand (SDATA (specified_data
), &dh
, SBYTES (specified_data
));
8091 image_error ("Cannot allocate data handle for `%s'",
8096 file_type_atom
[0] = EndianU32_NtoB (sizeof (long) * 3);
8097 file_type_atom
[1] = EndianU32_NtoB (kDataRefExtensionMacOSFileType
);
8098 file_type_atom
[2] = EndianU32_NtoB (kQTFileTypeGIF
);
8099 err
= PtrToHand (&dh
, &dref
, sizeof (Handle
));
8102 err
= PtrAndHand ("\p", dref
, 1);
8104 err
= PtrAndHand (file_type_atom
, dref
, sizeof (long) * 3);
8107 image_error ("Cannot allocate handle data ref for `%s'", img
->spec
, Qnil
);
8110 err
= CanQuickTimeOpenDataRef (dref
, HandleDataHandlerSubType
, &graphic_p
,
8111 &movie_p
, &prefer_graphic_p
, 0);
8115 if (!graphic_p
&& !movie_p
)
8117 if (prefer_graphic_p
)
8121 DisposeHandle (dref
);
8122 success_p
= image_load_qt_1 (f
, img
, kQTFileTypeGIF
, NULL
, dh
);
8126 err
= NewMovieFromDataRef (&movie
, 0, NULL
, dref
,
8127 HandleDataHandlerSubType
);
8128 DisposeHandle (dref
);
8133 image
= image_spec_value (img
->spec
, QCindex
, NULL
);
8134 ino
= INTEGERP (image
) ? XFASTINT (image
) : 0;
8135 track
= GetMovieIndTrack (movie
, 1);
8136 media
= GetTrackMedia (track
);
8137 nsamples
= GetMediaSampleCount (media
);
8138 if (ino
>= nsamples
)
8140 image_error ("Invalid image number `%s' in image `%s'",
8144 time_scale
= GetMediaTimeScale (media
);
8146 specified_bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
8147 if (!STRINGP (specified_bg
) ||
8148 !mac_defined_color (f
, SDATA (specified_bg
), &color
, 0))
8150 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
8151 color
.red
= RED16_FROM_ULONG (color
.pixel
);
8152 color
.green
= GREEN16_FROM_ULONG (color
.pixel
);
8153 color
.blue
= BLUE16_FROM_ULONG (color
.pixel
);
8155 GetMovieBox (movie
, &rect
);
8156 width
= img
->width
= rect
.right
- rect
.left
;
8157 height
= img
->height
= rect
.bottom
- rect
.top
;
8158 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
8161 GetGWorld (&old_port
, &old_gdh
);
8162 SetGWorld (ximg
, NULL
);
8163 bg_color
.red
= color
.red
;
8164 bg_color
.green
= color
.green
;
8165 bg_color
.blue
= color
.blue
;
8166 RGBBackColor (&bg_color
);
8167 SetGWorld (old_port
, old_gdh
);
8168 SetMovieActive (movie
, 1);
8169 SetMovieGWorld (movie
, ximg
, NULL
);
8170 SampleNumToMediaTime (media
, ino
+ 1, &time
, &duration
);
8171 SetMovieTimeValue (movie
, time
);
8172 MoviesTask (movie
, 0L);
8173 DisposeTrackMedia (media
);
8174 DisposeMovieTrack (track
);
8175 DisposeMovie (movie
);
8179 /* Save GIF image extension data for `image-extension-data'.
8180 Format is (count IMAGES 0xf9 GRAPHIC_CONTROL_EXTENSION_BLOCK). */
8182 Lisp_Object gce
= make_uninit_string (4);
8183 int centisec
= ((float)duration
/ time_scale
) * 100.0f
+ 0.5f
;
8185 /* Fill the delay time field. */
8186 SSET (gce
, 1, centisec
& 0xff);
8187 SSET (gce
, 2, (centisec
>> 8) & 0xff);
8188 /* We don't know about other fields. */
8192 img
->data
.lisp_val
= list4 (Qcount
, make_number (nsamples
),
8193 make_number (0xf9), gce
);
8196 /* Maybe fill in the background field while we have ximg handy. */
8197 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
8198 IMAGE_BACKGROUND (img
, f
, ximg
);
8200 /* Put the image into the pixmap. */
8201 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
8202 x_destroy_x_image (ximg
);
8206 image_error ("Cannot open `%s'", file
, Qnil
);
8209 DisposeTrackMedia (media
);
8211 DisposeMovieTrack (track
);
8213 DisposeMovie (movie
);
8220 #endif /* HAVE_GIF */
8224 /***********************************************************************
8226 ***********************************************************************/
8228 #ifdef HAVE_X_WINDOWS
8229 #define HAVE_GHOSTSCRIPT 1
8230 #endif /* HAVE_X_WINDOWS */
8232 /* The symbol `postscript' identifying images of this type. */
8234 Lisp_Object Qpostscript
;
8236 #ifdef HAVE_GHOSTSCRIPT
8238 static int gs_image_p
P_ ((Lisp_Object object
));
8239 static int gs_load
P_ ((struct frame
*f
, struct image
*img
));
8240 static void gs_clear_image
P_ ((struct frame
*f
, struct image
*img
));
8242 /* Keyword symbols. */
8244 Lisp_Object QCloader
, QCbounding_box
, QCpt_width
, QCpt_height
;
8246 /* Indices of image specification fields in gs_format, below. */
8248 enum gs_keyword_index
8266 /* Vector of image_keyword structures describing the format
8267 of valid user-defined image specifications. */
8269 static struct image_keyword gs_format
[GS_LAST
] =
8271 {":type", IMAGE_SYMBOL_VALUE
, 1},
8272 {":pt-width", IMAGE_POSITIVE_INTEGER_VALUE
, 1},
8273 {":pt-height", IMAGE_POSITIVE_INTEGER_VALUE
, 1},
8274 {":file", IMAGE_STRING_VALUE
, 1},
8275 {":loader", IMAGE_FUNCTION_VALUE
, 0},
8276 {":bounding-box", IMAGE_DONT_CHECK_VALUE_TYPE
, 1},
8277 {":ascent", IMAGE_ASCENT_VALUE
, 0},
8278 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
8279 {":relief", IMAGE_INTEGER_VALUE
, 0},
8280 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8281 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8282 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8283 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
8286 /* Structure describing the image type `ghostscript'. */
8288 static struct image_type gs_type
=
8298 /* Free X resources of Ghostscript image IMG which is used on frame F. */
8301 gs_clear_image (f
, img
)
8305 /* IMG->data.ptr_val may contain a recorded colormap. */
8306 xfree (img
->data
.ptr_val
);
8307 x_clear_image (f
, img
);
8311 /* Return non-zero if OBJECT is a valid Ghostscript image
8318 struct image_keyword fmt
[GS_LAST
];
8322 bcopy (gs_format
, fmt
, sizeof fmt
);
8324 if (!parse_image_spec (object
, fmt
, GS_LAST
, Qpostscript
))
8327 /* Bounding box must be a list or vector containing 4 integers. */
8328 tem
= fmt
[GS_BOUNDING_BOX
].value
;
8331 for (i
= 0; i
< 4; ++i
, tem
= XCDR (tem
))
8332 if (!CONSP (tem
) || !INTEGERP (XCAR (tem
)))
8337 else if (VECTORP (tem
))
8339 if (XVECTOR (tem
)->size
!= 4)
8341 for (i
= 0; i
< 4; ++i
)
8342 if (!INTEGERP (XVECTOR (tem
)->contents
[i
]))
8352 /* Load Ghostscript image IMG for use on frame F. Value is non-zero
8361 Lisp_Object window_and_pixmap_id
= Qnil
, loader
, pt_height
, pt_width
;
8362 struct gcpro gcpro1
, gcpro2
;
8364 double in_width
, in_height
;
8365 Lisp_Object pixel_colors
= Qnil
;
8367 /* Compute pixel size of pixmap needed from the given size in the
8368 image specification. Sizes in the specification are in pt. 1 pt
8369 = 1/72 in, xdpi and ydpi are stored in the frame's X display
8371 pt_width
= image_spec_value (img
->spec
, QCpt_width
, NULL
);
8372 in_width
= XFASTINT (pt_width
) / 72.0;
8373 img
->width
= in_width
* FRAME_X_DISPLAY_INFO (f
)->resx
;
8374 pt_height
= image_spec_value (img
->spec
, QCpt_height
, NULL
);
8375 in_height
= XFASTINT (pt_height
) / 72.0;
8376 img
->height
= in_height
* FRAME_X_DISPLAY_INFO (f
)->resy
;
8378 if (!check_image_size (f
, img
->width
, img
->height
))
8380 image_error ("Invalid image size", Qnil
, Qnil
);
8384 /* Create the pixmap. */
8385 xassert (img
->pixmap
== NO_PIXMAP
);
8387 /* Only W32 version did BLOCK_INPUT here. ++kfs */
8389 img
->pixmap
= XCreatePixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
8390 img
->width
, img
->height
,
8391 DefaultDepthOfScreen (FRAME_X_SCREEN (f
)));
8396 image_error ("Unable to create pixmap for `%s'", img
->spec
, Qnil
);
8400 /* Call the loader to fill the pixmap. It returns a process object
8401 if successful. We do not record_unwind_protect here because
8402 other places in redisplay like calling window scroll functions
8403 don't either. Let the Lisp loader use `unwind-protect' instead. */
8404 GCPRO2 (window_and_pixmap_id
, pixel_colors
);
8406 sprintf (buffer
, "%lu %lu",
8407 (unsigned long) FRAME_X_WINDOW (f
),
8408 (unsigned long) img
->pixmap
);
8409 window_and_pixmap_id
= build_string (buffer
);
8411 sprintf (buffer
, "%lu %lu",
8412 FRAME_FOREGROUND_PIXEL (f
),
8413 FRAME_BACKGROUND_PIXEL (f
));
8414 pixel_colors
= build_string (buffer
);
8416 XSETFRAME (frame
, f
);
8417 loader
= image_spec_value (img
->spec
, QCloader
, NULL
);
8419 loader
= intern ("gs-load-image");
8421 img
->data
.lisp_val
= call6 (loader
, frame
, img
->spec
,
8422 make_number (img
->width
),
8423 make_number (img
->height
),
8424 window_and_pixmap_id
,
8427 return PROCESSP (img
->data
.lisp_val
);
8431 /* Kill the Ghostscript process that was started to fill PIXMAP on
8432 frame F. Called from XTread_socket when receiving an event
8433 telling Emacs that Ghostscript has finished drawing. */
8436 x_kill_gs_process (pixmap
, f
)
8440 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
8444 /* Find the image containing PIXMAP. */
8445 for (i
= 0; i
< c
->used
; ++i
)
8446 if (c
->images
[i
]->pixmap
== pixmap
)
8449 /* Should someone in between have cleared the image cache, for
8450 instance, give up. */
8454 /* Kill the GS process. We should have found PIXMAP in the image
8455 cache and its image should contain a process object. */
8457 xassert (PROCESSP (img
->data
.lisp_val
));
8458 Fkill_process (img
->data
.lisp_val
, Qnil
);
8459 img
->data
.lisp_val
= Qnil
;
8461 #if defined (HAVE_X_WINDOWS)
8463 /* On displays with a mutable colormap, figure out the colors
8464 allocated for the image by looking at the pixels of an XImage for
8466 class = FRAME_X_VISUAL (f
)->class;
8467 if (class != StaticColor
&& class != StaticGray
&& class != TrueColor
)
8473 /* Try to get an XImage for img->pixmep. */
8474 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
8475 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
8480 /* Initialize the color table. */
8481 init_color_table ();
8483 /* For each pixel of the image, look its color up in the
8484 color table. After having done so, the color table will
8485 contain an entry for each color used by the image. */
8486 for (y
= 0; y
< img
->height
; ++y
)
8487 for (x
= 0; x
< img
->width
; ++x
)
8489 unsigned long pixel
= XGetPixel (ximg
, x
, y
);
8490 lookup_pixel_color (f
, pixel
);
8493 /* Record colors in the image. Free color table and XImage. */
8494 #ifdef COLOR_TABLE_SUPPORT
8495 img
->colors
= colors_in_color_table (&img
->ncolors
);
8496 free_color_table ();
8498 XDestroyImage (ximg
);
8500 #if 0 /* This doesn't seem to be the case. If we free the colors
8501 here, we get a BadAccess later in x_clear_image when
8502 freeing the colors. */
8503 /* We have allocated colors once, but Ghostscript has also
8504 allocated colors on behalf of us. So, to get the
8505 reference counts right, free them once. */
8507 x_free_colors (f
, img
->colors
, img
->ncolors
);
8511 image_error ("Cannot get X image of `%s'; colors will not be freed",
8516 #endif /* HAVE_X_WINDOWS */
8518 /* Now that we have the pixmap, compute mask and transform the
8519 image if requested. */
8521 postprocess_image (f
, img
);
8525 #endif /* HAVE_GHOSTSCRIPT */
8528 /***********************************************************************
8530 ***********************************************************************/
8534 DEFUN ("imagep", Fimagep
, Simagep
, 1, 1, 0,
8535 doc
: /* Value is non-nil if SPEC is a valid image specification. */)
8539 return valid_image_p (spec
) ? Qt
: Qnil
;
8543 DEFUN ("lookup-image", Flookup_image
, Slookup_image
, 1, 1, 0, "")
8549 if (valid_image_p (spec
))
8550 id
= lookup_image (SELECTED_FRAME (), spec
);
8553 return make_number (id
);
8556 #endif /* GLYPH_DEBUG != 0 */
8559 /***********************************************************************
8561 ***********************************************************************/
8564 /* Image types that rely on external libraries are loaded dynamically
8565 if the library is available. */
8566 #define CHECK_LIB_AVAILABLE(image_type, init_lib_fn, libraries) \
8567 define_image_type (image_type, init_lib_fn (libraries))
8569 #define CHECK_LIB_AVAILABLE(image_type, init_lib_fn, libraries) \
8570 define_image_type (image_type, 1)
8571 #endif /* HAVE_NTGUI */
8573 DEFUN ("init-image-library", Finit_image_library
, Sinit_image_library
, 2, 2, 0,
8574 doc
: /* Initialize image library implementing image type TYPE.
8575 Return non-nil if TYPE is a supported image type.
8577 Image types pbm and xbm are prebuilt; other types are loaded here.
8578 Libraries to load are specified in alist LIBRARIES (usually, the value
8579 of `image-library-alist', which see). */)
8581 Lisp_Object type
, libraries
;
8585 /* Don't try to reload the library. */
8586 tested
= Fassq (type
, Vimage_type_cache
);
8588 return XCDR (tested
);
8590 #if defined (HAVE_XPM) || defined (MAC_OS)
8591 if (EQ (type
, Qxpm
))
8592 return CHECK_LIB_AVAILABLE (&xpm_type
, init_xpm_functions
, libraries
);
8595 #if defined (HAVE_JPEG) || defined (MAC_OS)
8596 if (EQ (type
, Qjpeg
))
8597 return CHECK_LIB_AVAILABLE (&jpeg_type
, init_jpeg_functions
, libraries
);
8600 #if defined (HAVE_TIFF) || defined (MAC_OS)
8601 if (EQ (type
, Qtiff
))
8602 return CHECK_LIB_AVAILABLE (&tiff_type
, init_tiff_functions
, libraries
);
8605 #if defined (HAVE_GIF) || defined (MAC_OS)
8606 if (EQ (type
, Qgif
))
8607 return CHECK_LIB_AVAILABLE (&gif_type
, init_gif_functions
, libraries
);
8610 #if defined (HAVE_PNG) || defined (MAC_OS)
8611 if (EQ (type
, Qpng
))
8612 return CHECK_LIB_AVAILABLE (&png_type
, init_png_functions
, libraries
);
8615 #ifdef HAVE_GHOSTSCRIPT
8616 if (EQ (type
, Qpostscript
))
8617 return CHECK_LIB_AVAILABLE (&gs_type
, init_gs_functions
, libraries
);
8620 /* If the type is not recognized, avoid testing it ever again. */
8621 CACHE_IMAGE_TYPE (type
, Qnil
);
8628 extern Lisp_Object Qrisky_local_variable
; /* Syms_of_xdisp has already run. */
8630 /* Initialize this only once, since that's what we do with Vimage_types
8631 and they are supposed to be in sync. Initializing here gives correct
8632 operation on GNU/Linux of calling dump-emacs after loading some images. */
8635 /* Must be defined now becase we're going to update it below, while
8636 defining the supported image types. */
8637 DEFVAR_LISP ("image-types", &Vimage_types
,
8638 doc
: /* List of potentially supported image types.
8639 Each element of the list is a symbol for an image type, like 'jpeg or 'png.
8640 To check whether it is really supported, use `image-type-available-p'. */);
8641 Vimage_types
= Qnil
;
8643 DEFVAR_LISP ("image-library-alist", &Vimage_library_alist
,
8644 doc
: /* Alist of image types vs external libraries needed to display them.
8646 Each element is a list (IMAGE-TYPE LIBRARY...), where the car is a symbol
8647 representing a supported image type, and the rest are strings giving
8648 alternate filenames for the corresponding external libraries.
8650 Emacs tries to load the libraries in the order they appear on the
8651 list; if none is loaded, the running session of Emacs won't
8652 support the image type. Types 'pbm and 'xbm don't need to be
8653 listed; they are always supported. */);
8654 Vimage_library_alist
= Qnil
;
8655 Fput (intern ("image-library-alist"), Qrisky_local_variable
, Qt
);
8657 DEFVAR_LISP ("max-image-size", &Vmax_image_size
,
8658 doc
: /* Maximum size of images.
8659 Emacs will not load an image into memory if its pixel width or
8660 pixel height exceeds this limit.
8662 If the value is an integer, it directly specifies the maximum
8663 image height and width, measured in pixels. If it is a floating
8664 point number, it specifies the maximum image height and width
8665 as a ratio to the frame height and width. If the value is
8666 non-numeric, there is no explicit limit on the size of images. */);
8667 Vmax_image_size
= make_float (MAX_IMAGE_SIZE
);
8669 Vimage_type_cache
= Qnil
;
8670 staticpro (&Vimage_type_cache
);
8672 Qpbm
= intern ("pbm");
8674 ADD_IMAGE_TYPE(Qpbm
);
8676 Qxbm
= intern ("xbm");
8678 ADD_IMAGE_TYPE(Qxbm
);
8680 define_image_type (&xbm_type
, 1);
8681 define_image_type (&pbm_type
, 1);
8683 QCascent
= intern (":ascent");
8684 staticpro (&QCascent
);
8685 QCmargin
= intern (":margin");
8686 staticpro (&QCmargin
);
8687 QCrelief
= intern (":relief");
8688 staticpro (&QCrelief
);
8689 QCconversion
= intern (":conversion");
8690 staticpro (&QCconversion
);
8691 QCcolor_symbols
= intern (":color-symbols");
8692 staticpro (&QCcolor_symbols
);
8693 QCheuristic_mask
= intern (":heuristic-mask");
8694 staticpro (&QCheuristic_mask
);
8695 QCindex
= intern (":index");
8696 staticpro (&QCindex
);
8697 QCmatrix
= intern (":matrix");
8698 staticpro (&QCmatrix
);
8699 QCcolor_adjustment
= intern (":color-adjustment");
8700 staticpro (&QCcolor_adjustment
);
8701 QCmask
= intern (":mask");
8702 staticpro (&QCmask
);
8704 Qlaplace
= intern ("laplace");
8705 staticpro (&Qlaplace
);
8706 Qemboss
= intern ("emboss");
8707 staticpro (&Qemboss
);
8708 Qedge_detection
= intern ("edge-detection");
8709 staticpro (&Qedge_detection
);
8710 Qheuristic
= intern ("heuristic");
8711 staticpro (&Qheuristic
);
8713 Qpostscript
= intern ("postscript");
8714 staticpro (&Qpostscript
);
8715 #ifdef HAVE_GHOSTSCRIPT
8716 ADD_IMAGE_TYPE(Qpostscript
);
8717 QCloader
= intern (":loader");
8718 staticpro (&QCloader
);
8719 QCbounding_box
= intern (":bounding-box");
8720 staticpro (&QCbounding_box
);
8721 QCpt_width
= intern (":pt-width");
8722 staticpro (&QCpt_width
);
8723 QCpt_height
= intern (":pt-height");
8724 staticpro (&QCpt_height
);
8725 #endif /* HAVE_GHOSTSCRIPT */
8727 #if defined (HAVE_XPM) || defined (MAC_OS)
8728 Qxpm
= intern ("xpm");
8730 ADD_IMAGE_TYPE(Qxpm
);
8733 #if defined (HAVE_JPEG) || defined (MAC_OS)
8734 Qjpeg
= intern ("jpeg");
8736 ADD_IMAGE_TYPE(Qjpeg
);
8739 #if defined (HAVE_TIFF) || defined (MAC_OS)
8740 Qtiff
= intern ("tiff");
8742 ADD_IMAGE_TYPE(Qtiff
);
8745 #if defined (HAVE_GIF) || defined (MAC_OS)
8746 Qgif
= intern ("gif");
8748 ADD_IMAGE_TYPE(Qgif
);
8751 #if defined (HAVE_PNG) || defined (MAC_OS)
8752 Qpng
= intern ("png");
8754 ADD_IMAGE_TYPE(Qpng
);
8757 defsubr (&Sinit_image_library
);
8758 defsubr (&Sclear_image_cache
);
8759 defsubr (&Simage_refresh
);
8760 defsubr (&Simage_size
);
8761 defsubr (&Simage_mask_p
);
8762 defsubr (&Simage_extension_data
);
8766 defsubr (&Slookup_image
);
8769 DEFVAR_BOOL ("cross-disabled-images", &cross_disabled_images
,
8770 doc
: /* Non-nil means always draw a cross over disabled images.
8771 Disabled images are those having a `:conversion disabled' property.
8772 A cross is always drawn on black & white displays. */);
8773 cross_disabled_images
= 0;
8775 DEFVAR_LISP ("x-bitmap-file-path", &Vx_bitmap_file_path
,
8776 doc
: /* List of directories to search for window system bitmap files. */);
8777 Vx_bitmap_file_path
= decode_env_path ((char *) 0, PATH_BITMAPS
);
8779 DEFVAR_LISP ("image-cache-eviction-delay", &Vimage_cache_eviction_delay
,
8780 doc
: /* Time after which cached images are removed from the cache.
8781 When an image has not been displayed this many seconds, remove it
8782 from the image cache. Value must be an integer or nil with nil
8783 meaning don't clear the cache. */);
8784 Vimage_cache_eviction_delay
= make_number (30 * 60);
8790 #if defined (MAC_OSX) && TARGET_API_MAC_CARBON
8791 init_image_func_pointer ();
8795 /* arch-tag: 123c2a5e-14a8-4c53-ab95-af47d7db49b9
8796 (do not change this comment) */