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
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
;
737 extern Lisp_Object Qcenter
;
738 Lisp_Object QCascent
, QCmargin
, QCrelief
, Qcount
;
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
)
1908 struct image_cache
*c
;
1911 struct gcpro gcpro1
;
1914 /* F must be a window-system frame, and SPEC must be a valid image
1916 xassert (FRAME_WINDOW_P (f
));
1917 xassert (valid_image_p (spec
));
1919 c
= FRAME_X_IMAGE_CACHE (f
);
1923 /* Look up SPEC in the hash table of the image cache. */
1924 hash
= sxhash (spec
, 0);
1925 img
= search_image_cache (f
, spec
, hash
);
1926 if (img
&& img
->load_failed_p
)
1928 free_image (f
, img
);
1932 /* If not found, create a new image and cache it. */
1935 extern Lisp_Object Qpostscript
;
1938 img
= make_image (spec
, hash
);
1939 cache_image (f
, img
);
1940 img
->load_failed_p
= img
->type
->load (f
, img
) == 0;
1941 img
->frame_foreground
= FRAME_FOREGROUND_PIXEL (f
);
1942 img
->frame_background
= FRAME_BACKGROUND_PIXEL (f
);
1944 /* If we can't load the image, and we don't have a width and
1945 height, use some arbitrary width and height so that we can
1946 draw a rectangle for it. */
1947 if (img
->load_failed_p
)
1951 value
= image_spec_value (spec
, QCwidth
, NULL
);
1952 img
->width
= (INTEGERP (value
)
1953 ? XFASTINT (value
) : DEFAULT_IMAGE_WIDTH
);
1954 value
= image_spec_value (spec
, QCheight
, NULL
);
1955 img
->height
= (INTEGERP (value
)
1956 ? XFASTINT (value
) : DEFAULT_IMAGE_HEIGHT
);
1960 /* Handle image type independent image attributes
1961 `:ascent ASCENT', `:margin MARGIN', `:relief RELIEF',
1962 `:background COLOR'. */
1963 Lisp_Object ascent
, margin
, relief
, bg
;
1965 ascent
= image_spec_value (spec
, QCascent
, NULL
);
1966 if (INTEGERP (ascent
))
1967 img
->ascent
= XFASTINT (ascent
);
1968 else if (EQ (ascent
, Qcenter
))
1969 img
->ascent
= CENTERED_IMAGE_ASCENT
;
1971 margin
= image_spec_value (spec
, QCmargin
, NULL
);
1972 if (INTEGERP (margin
) && XINT (margin
) >= 0)
1973 img
->vmargin
= img
->hmargin
= XFASTINT (margin
);
1974 else if (CONSP (margin
) && INTEGERP (XCAR (margin
))
1975 && INTEGERP (XCDR (margin
)))
1977 if (XINT (XCAR (margin
)) > 0)
1978 img
->hmargin
= XFASTINT (XCAR (margin
));
1979 if (XINT (XCDR (margin
)) > 0)
1980 img
->vmargin
= XFASTINT (XCDR (margin
));
1983 relief
= image_spec_value (spec
, QCrelief
, NULL
);
1984 if (INTEGERP (relief
))
1986 img
->relief
= XINT (relief
);
1987 img
->hmargin
+= eabs (img
->relief
);
1988 img
->vmargin
+= eabs (img
->relief
);
1991 if (! img
->background_valid
)
1993 bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
1997 = x_alloc_image_color (f
, img
, bg
,
1998 FRAME_BACKGROUND_PIXEL (f
));
1999 img
->background_valid
= 1;
2003 /* Do image transformations and compute masks, unless we
2004 don't have the image yet. */
2005 if (!EQ (*img
->type
->type
, Qpostscript
))
2006 postprocess_image (f
, img
);
2012 /* We're using IMG, so set its timestamp to `now'. */
2013 EMACS_GET_TIME (now
);
2014 img
->timestamp
= EMACS_SECS (now
);
2018 /* Value is the image id. */
2023 /* Cache image IMG in the image cache of frame F. */
2026 cache_image (f
, img
)
2030 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
2033 /* Find a free slot in c->images. */
2034 for (i
= 0; i
< c
->used
; ++i
)
2035 if (c
->images
[i
] == NULL
)
2038 /* If no free slot found, maybe enlarge c->images. */
2039 if (i
== c
->used
&& c
->used
== c
->size
)
2042 c
->images
= (struct image
**) xrealloc (c
->images
,
2043 c
->size
* sizeof *c
->images
);
2046 /* Add IMG to c->images, and assign IMG an id. */
2052 /* Add IMG to the cache's hash table. */
2053 i
= img
->hash
% IMAGE_CACHE_BUCKETS_SIZE
;
2054 img
->next
= c
->buckets
[i
];
2056 img
->next
->prev
= img
;
2058 c
->buckets
[i
] = img
;
2062 /* Call FN on every image in the image cache of frame F. Used to mark
2063 Lisp Objects in the image cache. */
2066 forall_images_in_image_cache (f
, fn
)
2068 void (*fn
) P_ ((struct image
*img
));
2070 if (FRAME_LIVE_P (f
) && FRAME_WINDOW_P (f
))
2072 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
2076 for (i
= 0; i
< c
->used
; ++i
)
2085 /***********************************************************************
2086 X / MAC / W32 support code
2087 ***********************************************************************/
2091 /* Macro for defining functions that will be loaded from image DLLs. */
2092 #define DEF_IMGLIB_FN(func) int (FAR CDECL *fn_##func)()
2094 /* Macro for loading those image functions from the library. */
2095 #define LOAD_IMGLIB_FN(lib,func) { \
2096 fn_##func = (void *) GetProcAddress (lib, #func); \
2097 if (!fn_##func) return 0; \
2100 /* Load a DLL implementing an image type.
2101 The `image-library-alist' variable associates a symbol,
2102 identifying an image type, to a list of possible filenames.
2103 The function returns NULL if no library could be loaded for
2104 the given image type, or if the library was previously loaded;
2105 else the handle of the DLL. */
2107 w32_delayed_load (Lisp_Object libraries
, Lisp_Object type
)
2109 HMODULE library
= NULL
;
2111 if (CONSP (libraries
) && NILP (Fassq (type
, Vimage_type_cache
)))
2113 Lisp_Object dlls
= Fassq (type
, libraries
);
2116 for (dlls
= XCDR (dlls
); CONSP (dlls
); dlls
= XCDR (dlls
))
2118 CHECK_STRING_CAR (dlls
);
2119 if (library
= LoadLibrary (SDATA (XCAR (dlls
))))
2127 #endif /* HAVE_NTGUI */
2129 static int x_create_x_image_and_pixmap
P_ ((struct frame
*, int, int, int,
2130 XImagePtr
*, Pixmap
*));
2131 static void x_destroy_x_image
P_ ((XImagePtr
));
2132 static void x_put_x_image
P_ ((struct frame
*, XImagePtr
, Pixmap
, int, int));
2135 /* Create an XImage and a pixmap of size WIDTH x HEIGHT for use on
2136 frame F. Set *XIMG and *PIXMAP to the XImage and Pixmap created.
2137 Set (*XIMG)->data to a raster of WIDTH x HEIGHT pixels allocated
2138 via xmalloc. Print error messages via image_error if an error
2139 occurs. Value is non-zero if successful.
2141 On W32, a DEPTH of zero signifies a 24 bit image, otherwise DEPTH
2142 should indicate the bit depth of the image. */
2145 x_create_x_image_and_pixmap (f
, width
, height
, depth
, ximg
, pixmap
)
2147 int width
, height
, depth
;
2151 #ifdef HAVE_X_WINDOWS
2152 Display
*display
= FRAME_X_DISPLAY (f
);
2153 Window window
= FRAME_X_WINDOW (f
);
2154 Screen
*screen
= FRAME_X_SCREEN (f
);
2156 xassert (interrupt_input_blocked
);
2159 depth
= DefaultDepthOfScreen (screen
);
2160 *ximg
= XCreateImage (display
, DefaultVisualOfScreen (screen
),
2161 depth
, ZPixmap
, 0, NULL
, width
, height
,
2162 depth
> 16 ? 32 : depth
> 8 ? 16 : 8, 0);
2165 image_error ("Unable to allocate X image", Qnil
, Qnil
);
2169 /* Allocate image raster. */
2170 (*ximg
)->data
= (char *) xmalloc ((*ximg
)->bytes_per_line
* height
);
2172 /* Allocate a pixmap of the same size. */
2173 *pixmap
= XCreatePixmap (display
, window
, width
, height
, depth
);
2174 if (*pixmap
== NO_PIXMAP
)
2176 x_destroy_x_image (*ximg
);
2178 image_error ("Unable to create X pixmap", Qnil
, Qnil
);
2183 #endif /* HAVE_X_WINDOWS */
2187 BITMAPINFOHEADER
*header
;
2189 int scanline_width_bits
;
2191 int palette_colors
= 0;
2196 if (depth
!= 1 && depth
!= 4 && depth
!= 8
2197 && depth
!= 16 && depth
!= 24 && depth
!= 32)
2199 image_error ("Invalid image bit depth specified", Qnil
, Qnil
);
2203 scanline_width_bits
= width
* depth
;
2204 remainder
= scanline_width_bits
% 32;
2207 scanline_width_bits
+= 32 - remainder
;
2209 /* Bitmaps with a depth less than 16 need a palette. */
2210 /* BITMAPINFO structure already contains the first RGBQUAD. */
2212 palette_colors
= 1 << depth
- 1;
2214 *ximg
= xmalloc (sizeof (XImage
) + palette_colors
* sizeof (RGBQUAD
));
2217 image_error ("Unable to allocate memory for XImage", Qnil
, Qnil
);
2221 header
= &((*ximg
)->info
.bmiHeader
);
2222 bzero (&((*ximg
)->info
), sizeof (BITMAPINFO
));
2223 header
->biSize
= sizeof (*header
);
2224 header
->biWidth
= width
;
2225 header
->biHeight
= -height
; /* negative indicates a top-down bitmap. */
2226 header
->biPlanes
= 1;
2227 header
->biBitCount
= depth
;
2228 header
->biCompression
= BI_RGB
;
2229 header
->biClrUsed
= palette_colors
;
2231 /* TODO: fill in palette. */
2234 (*ximg
)->info
.bmiColors
[0].rgbBlue
= 0;
2235 (*ximg
)->info
.bmiColors
[0].rgbGreen
= 0;
2236 (*ximg
)->info
.bmiColors
[0].rgbRed
= 0;
2237 (*ximg
)->info
.bmiColors
[0].rgbReserved
= 0;
2238 (*ximg
)->info
.bmiColors
[1].rgbBlue
= 255;
2239 (*ximg
)->info
.bmiColors
[1].rgbGreen
= 255;
2240 (*ximg
)->info
.bmiColors
[1].rgbRed
= 255;
2241 (*ximg
)->info
.bmiColors
[1].rgbReserved
= 0;
2244 hdc
= get_frame_dc (f
);
2246 /* Create a DIBSection and raster array for the bitmap,
2247 and store its handle in *pixmap. */
2248 *pixmap
= CreateDIBSection (hdc
, &((*ximg
)->info
),
2249 (depth
< 16) ? DIB_PAL_COLORS
: DIB_RGB_COLORS
,
2250 /* casting avoids a GCC warning */
2251 (void **)&((*ximg
)->data
), NULL
, 0);
2253 /* Realize display palette and garbage all frames. */
2254 release_frame_dc (f
, hdc
);
2256 if (*pixmap
== NULL
)
2258 DWORD err
= GetLastError ();
2259 Lisp_Object errcode
;
2260 /* All system errors are < 10000, so the following is safe. */
2261 XSETINT (errcode
, (int) err
);
2262 image_error ("Unable to create bitmap, error code %d", errcode
, Qnil
);
2263 x_destroy_x_image (*ximg
);
2269 #endif /* HAVE_NTGUI */
2272 Display
*display
= FRAME_X_DISPLAY (f
);
2273 Window window
= FRAME_X_WINDOW (f
);
2275 xassert (interrupt_input_blocked
);
2277 /* Allocate a pixmap of the same size. */
2278 *pixmap
= XCreatePixmap (display
, window
, width
, height
, depth
);
2279 if (*pixmap
== NO_PIXMAP
)
2282 image_error ("Unable to create X pixmap", Qnil
, Qnil
);
2286 LockPixels (GetGWorldPixMap (*pixmap
));
2294 /* Destroy XImage XIMG. Free XIMG->data. */
2297 x_destroy_x_image (ximg
)
2300 xassert (interrupt_input_blocked
);
2303 #ifdef HAVE_X_WINDOWS
2306 XDestroyImage (ximg
);
2307 #endif /* HAVE_X_WINDOWS */
2309 /* Data will be freed by DestroyObject. */
2312 #endif /* HAVE_NTGUI */
2314 XDestroyImage (ximg
);
2320 /* Put XImage XIMG into pixmap PIXMAP on frame F. WIDTH and HEIGHT
2321 are width and height of both the image and pixmap. */
2324 x_put_x_image (f
, ximg
, pixmap
, width
, height
)
2330 #ifdef HAVE_X_WINDOWS
2333 xassert (interrupt_input_blocked
);
2334 gc
= XCreateGC (FRAME_X_DISPLAY (f
), pixmap
, 0, NULL
);
2335 XPutImage (FRAME_X_DISPLAY (f
), pixmap
, gc
, ximg
, 0, 0, 0, 0, width
, height
);
2336 XFreeGC (FRAME_X_DISPLAY (f
), gc
);
2337 #endif /* HAVE_X_WINDOWS */
2340 #if 0 /* I don't think this is necessary looking at where it is used. */
2341 HDC hdc
= get_frame_dc (f
);
2342 SetDIBits (hdc
, pixmap
, 0, height
, ximg
->data
, &(ximg
->info
), DIB_RGB_COLORS
);
2343 release_frame_dc (f
, hdc
);
2345 #endif /* HAVE_NTGUI */
2348 xassert (ximg
== pixmap
);
2353 /***********************************************************************
2355 ***********************************************************************/
2357 static unsigned char *slurp_file
P_ ((char *, int *));
2360 /* Find image file FILE. Look in data-directory/images, then
2361 x-bitmap-file-path. Value is the encoded full name of the file
2362 found, or nil if not found. */
2365 x_find_image_file (file
)
2368 Lisp_Object file_found
, search_path
;
2369 struct gcpro gcpro1
, gcpro2
;
2373 /* TODO I think this should use something like image-load-path
2374 instead. Unfortunately, that can contain non-string elements. */
2375 search_path
= Fcons (Fexpand_file_name (build_string ("images"),
2377 Vx_bitmap_file_path
);
2378 GCPRO2 (file_found
, search_path
);
2380 /* Try to find FILE in data-directory/images, then x-bitmap-file-path. */
2381 fd
= openp (search_path
, file
, Qnil
, &file_found
, Qnil
);
2387 file_found
= ENCODE_FILE (file_found
);
2396 /* Read FILE into memory. Value is a pointer to a buffer allocated
2397 with xmalloc holding FILE's contents. Value is null if an error
2398 occurred. *SIZE is set to the size of the file. */
2400 static unsigned char *
2401 slurp_file (file
, size
)
2406 unsigned char *buf
= NULL
;
2409 if (stat (file
, &st
) == 0
2410 && (fp
= fopen (file
, "rb")) != NULL
2411 && (buf
= (unsigned char *) xmalloc (st
.st_size
),
2412 fread (buf
, 1, st
.st_size
, fp
) == st
.st_size
))
2435 /***********************************************************************
2436 MAC Image Load Functions
2437 ***********************************************************************/
2439 static int image_load_quicktime
P_ ((struct frame
*, struct image
*img
,
2442 static int image_load_quartz2d
P_ ((struct frame
*, struct image
*img
, int));
2446 find_image_fsspec (specified_file
, file
, fss
)
2447 Lisp_Object specified_file
, *file
;
2453 *file
= x_find_image_file (specified_file
);
2454 if (!STRINGP (*file
))
2455 return fnfErr
; /* file or directory not found;
2456 incomplete pathname */
2457 /* Try to open the image file. */
2458 err
= AECoercePtr (TYPE_FILE_NAME
, SDATA (*file
),
2459 SBYTES (*file
), typeFSS
, &desc
);
2462 #if TARGET_API_MAC_CARBON
2463 err
= AEGetDescData (&desc
, fss
, sizeof (FSSpec
));
2465 *fss
= *(FSSpec
*)(*(desc
.dataHandle
));
2467 AEDisposeDesc (&desc
);
2473 image_load_qt_1 (f
, img
, type
, fss
, dh
)
2480 ComponentResult err
;
2481 GraphicsImportComponent gi
;
2484 ImageDescriptionHandle desc_handle
;
2485 short draw_all_pixels
;
2486 Lisp_Object specified_bg
;
2491 err
= OpenADefaultComponent (GraphicsImporterComponentType
, type
, &gi
);
2494 image_error ("Cannot get importer component for `%s'", img
->spec
, Qnil
);
2499 /* read from file system spec */
2500 err
= GraphicsImportSetDataFile (gi
, fss
);
2503 image_error ("Cannot set fsspec to graphics importer for '%s'",
2510 /* read from data handle */
2511 err
= GraphicsImportSetDataHandle (gi
, dh
);
2514 image_error ("Cannot set data handle to graphics importer for `%s'",
2519 err
= GraphicsImportGetImageDescription (gi
, &desc_handle
);
2520 if (err
!= noErr
|| desc_handle
== NULL
)
2522 image_error ("Error reading `%s'", img
->spec
, Qnil
);
2525 width
= img
->width
= (*desc_handle
)->width
;
2526 height
= img
->height
= (*desc_handle
)->height
;
2527 DisposeHandle ((Handle
)desc_handle
);
2529 if (!check_image_size (f
, width
, height
))
2531 image_error ("Invalid image size", Qnil
, Qnil
);
2535 err
= GraphicsImportDoesDrawAllPixels (gi
, &draw_all_pixels
);
2537 /* Don't check the error code here. It may have an undocumented
2541 image_error ("Error reading `%s'", img
->spec
, Qnil
);
2545 if (draw_all_pixels
!= graphicsImporterDrawsAllPixels
)
2547 specified_bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
2548 if (!STRINGP (specified_bg
) ||
2549 !mac_defined_color (f
, SDATA (specified_bg
), &color
, 0))
2551 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
2552 color
.red
= RED16_FROM_ULONG (color
.pixel
);
2553 color
.green
= GREEN16_FROM_ULONG (color
.pixel
);
2554 color
.blue
= BLUE16_FROM_ULONG (color
.pixel
);
2558 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
2560 if (draw_all_pixels
!= graphicsImporterDrawsAllPixels
)
2565 GetGWorld (&old_port
, &old_gdh
);
2566 SetGWorld (ximg
, NULL
);
2567 bg_color
.red
= color
.red
;
2568 bg_color
.green
= color
.green
;
2569 bg_color
.blue
= color
.blue
;
2570 RGBBackColor (&bg_color
);
2571 #if TARGET_API_MAC_CARBON
2572 GetPortBounds (ximg
, &rect
);
2575 EraseRect (&(ximg
->portRect
));
2577 SetGWorld (old_port
, old_gdh
);
2579 GraphicsImportSetGWorld (gi
, ximg
, NULL
);
2580 GraphicsImportDraw (gi
);
2581 CloseComponent (gi
);
2583 /* Maybe fill in the background field while we have ximg handy. */
2584 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
2585 IMAGE_BACKGROUND (img
, f
, ximg
);
2587 /* Put the image into the pixmap. */
2588 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
2589 x_destroy_x_image (ximg
);
2593 CloseComponent (gi
);
2598 /* Load an image using the QuickTime Graphics Importer.
2599 Note: The alpha channel does not work for PNG images. */
2601 image_load_quicktime (f
, img
, type
)
2606 Lisp_Object specified_file
;
2607 Lisp_Object specified_data
;
2610 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
2611 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
2613 if (NILP (specified_data
))
2615 /* Read from a file */
2619 err
= find_image_fsspec (specified_file
, &file
, &fss
);
2623 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
2625 image_error ("Cannot open `%s'", file
, Qnil
);
2628 return image_load_qt_1 (f
, img
, type
, &fss
, NULL
);
2632 /* Memory source! */
2636 err
= PtrToHand (SDATA (specified_data
), &dh
, SBYTES (specified_data
));
2639 image_error ("Cannot allocate data handle for `%s'",
2643 success_p
= image_load_qt_1 (f
, img
, type
, NULL
, dh
);
2651 /* Load a PNG/JPEG image using Quartz 2D decoding routines.
2652 CGImageCreateWithPNGDataProvider is provided after Mac OS X 10.2.
2653 So don't use this function directly but determine at runtime
2654 whether it exists. */
2655 typedef CGImageRef (*CGImageCreateWithPNGDataProviderProcType
)
2656 (CGDataProviderRef
, const float [], bool, CGColorRenderingIntent
);
2657 static CGImageCreateWithPNGDataProviderProcType MyCGImageCreateWithPNGDataProvider
;
2661 init_image_func_pointer ()
2663 if (NSIsSymbolNameDefined ("_CGImageCreateWithPNGDataProvider"))
2665 MyCGImageCreateWithPNGDataProvider
2666 = (CGImageCreateWithPNGDataProviderProcType
)
2667 NSAddressOfSymbol (NSLookupAndBindSymbol
2668 ("_CGImageCreateWithPNGDataProvider"));
2671 MyCGImageCreateWithPNGDataProvider
= NULL
;
2676 image_load_quartz2d (f
, img
, png_p
)
2681 Lisp_Object file
, specified_file
;
2682 Lisp_Object specified_data
, specified_bg
;
2683 struct gcpro gcpro1
;
2684 CGDataProviderRef source
;
2688 XImagePtr ximg
= NULL
;
2689 CGContextRef context
;
2692 /* Open the file. */
2693 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
2694 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
2699 if (NILP (specified_data
))
2704 file
= x_find_image_file (specified_file
);
2705 if (!STRINGP (file
))
2707 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
2711 path
= cfstring_create_with_utf8_cstring (SDATA (file
));
2712 url
= CFURLCreateWithFileSystemPath (NULL
, path
,
2713 kCFURLPOSIXPathStyle
, 0);
2715 source
= CGDataProviderCreateWithURL (url
);
2719 source
= CGDataProviderCreateWithData (NULL
, SDATA (specified_data
),
2720 SBYTES (specified_data
), NULL
);
2723 image
= (*MyCGImageCreateWithPNGDataProvider
) (source
, NULL
, FALSE
,
2724 kCGRenderingIntentDefault
);
2726 image
= CGImageCreateWithJPEGDataProvider (source
, NULL
, FALSE
,
2727 kCGRenderingIntentDefault
);
2729 CGDataProviderRelease (source
);
2733 image_error ("Error reading image `%s'", img
->spec
, Qnil
);
2736 width
= img
->width
= CGImageGetWidth (image
);
2737 height
= img
->height
= CGImageGetHeight (image
);
2739 if (!check_image_size (f
, width
, height
))
2741 CGImageRelease (image
);
2743 image_error ("Invalid image size", Qnil
, Qnil
);
2749 specified_bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
2750 if (!STRINGP (specified_bg
) ||
2751 !mac_defined_color (f
, SDATA (specified_bg
), &color
, 0))
2753 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
2754 color
.red
= RED16_FROM_ULONG (color
.pixel
);
2755 color
.green
= GREEN16_FROM_ULONG (color
.pixel
);
2756 color
.blue
= BLUE16_FROM_ULONG (color
.pixel
);
2760 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
2762 CGImageRelease (image
);
2766 rectangle
= CGRectMake (0, 0, width
, height
);
2767 QDBeginCGContext (ximg
, &context
);
2770 CGContextSetRGBFillColor (context
, color
.red
/ 65535.0,
2771 color
.green
/ 65535.0,
2772 color
.blue
/ 65535.0, 1.0);
2773 CGContextFillRect (context
, rectangle
);
2775 CGContextDrawImage (context
, rectangle
, image
);
2776 QDEndCGContext (ximg
, &context
);
2777 CGImageRelease (image
);
2779 /* Maybe fill in the background field while we have ximg handy. */
2780 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
2781 IMAGE_BACKGROUND (img
, f
, ximg
);
2783 /* Put the image into the pixmap. */
2784 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
2785 x_destroy_x_image (ximg
);
2794 /***********************************************************************
2796 ***********************************************************************/
2798 static int xbm_scan
P_ ((unsigned char **, unsigned char *, char *, int *));
2799 static int xbm_load
P_ ((struct frame
*f
, struct image
*img
));
2800 static int xbm_load_image
P_ ((struct frame
*f
, struct image
*img
,
2801 unsigned char *, unsigned char *));
2802 static int xbm_image_p
P_ ((Lisp_Object object
));
2803 static int xbm_read_bitmap_data
P_ ((struct frame
*f
,
2804 unsigned char *, unsigned char *,
2805 int *, int *, unsigned char **));
2806 static int xbm_file_p
P_ ((Lisp_Object
));
2809 /* Indices of image specification fields in xbm_format, below. */
2811 enum xbm_keyword_index
2829 /* Vector of image_keyword structures describing the format
2830 of valid XBM image specifications. */
2832 static struct image_keyword xbm_format
[XBM_LAST
] =
2834 {":type", IMAGE_SYMBOL_VALUE
, 1},
2835 {":file", IMAGE_STRING_VALUE
, 0},
2836 {":width", IMAGE_POSITIVE_INTEGER_VALUE
, 0},
2837 {":height", IMAGE_POSITIVE_INTEGER_VALUE
, 0},
2838 {":data", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
2839 {":foreground", IMAGE_STRING_OR_NIL_VALUE
, 0},
2840 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0},
2841 {":ascent", IMAGE_ASCENT_VALUE
, 0},
2842 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
2843 {":relief", IMAGE_INTEGER_VALUE
, 0},
2844 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
2845 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
2846 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0}
2849 /* Structure describing the image type XBM. */
2851 static struct image_type xbm_type
=
2860 /* Tokens returned from xbm_scan. */
2869 /* Return non-zero if OBJECT is a valid XBM-type image specification.
2870 A valid specification is a list starting with the symbol `image'
2871 The rest of the list is a property list which must contain an
2874 If the specification specifies a file to load, it must contain
2875 an entry `:file FILENAME' where FILENAME is a string.
2877 If the specification is for a bitmap loaded from memory it must
2878 contain `:width WIDTH', `:height HEIGHT', and `:data DATA', where
2879 WIDTH and HEIGHT are integers > 0. DATA may be:
2881 1. a string large enough to hold the bitmap data, i.e. it must
2882 have a size >= (WIDTH + 7) / 8 * HEIGHT
2884 2. a bool-vector of size >= WIDTH * HEIGHT
2886 3. a vector of strings or bool-vectors, one for each line of the
2889 4. a string containing an in-memory XBM file. WIDTH and HEIGHT
2890 may not be specified in this case because they are defined in the
2893 Both the file and data forms may contain the additional entries
2894 `:background COLOR' and `:foreground COLOR'. If not present,
2895 foreground and background of the frame on which the image is
2896 displayed is used. */
2899 xbm_image_p (object
)
2902 struct image_keyword kw
[XBM_LAST
];
2904 bcopy (xbm_format
, kw
, sizeof kw
);
2905 if (!parse_image_spec (object
, kw
, XBM_LAST
, Qxbm
))
2908 xassert (EQ (kw
[XBM_TYPE
].value
, Qxbm
));
2910 if (kw
[XBM_FILE
].count
)
2912 if (kw
[XBM_WIDTH
].count
|| kw
[XBM_HEIGHT
].count
|| kw
[XBM_DATA
].count
)
2915 else if (kw
[XBM_DATA
].count
&& xbm_file_p (kw
[XBM_DATA
].value
))
2917 /* In-memory XBM file. */
2918 if (kw
[XBM_WIDTH
].count
|| kw
[XBM_HEIGHT
].count
|| kw
[XBM_FILE
].count
)
2926 /* Entries for `:width', `:height' and `:data' must be present. */
2927 if (!kw
[XBM_WIDTH
].count
2928 || !kw
[XBM_HEIGHT
].count
2929 || !kw
[XBM_DATA
].count
)
2932 data
= kw
[XBM_DATA
].value
;
2933 width
= XFASTINT (kw
[XBM_WIDTH
].value
);
2934 height
= XFASTINT (kw
[XBM_HEIGHT
].value
);
2936 /* Check type of data, and width and height against contents of
2942 /* Number of elements of the vector must be >= height. */
2943 if (XVECTOR (data
)->size
< height
)
2946 /* Each string or bool-vector in data must be large enough
2947 for one line of the image. */
2948 for (i
= 0; i
< height
; ++i
)
2950 Lisp_Object elt
= XVECTOR (data
)->contents
[i
];
2955 < (width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
)
2958 else if (BOOL_VECTOR_P (elt
))
2960 if (XBOOL_VECTOR (elt
)->size
< width
)
2967 else if (STRINGP (data
))
2970 < (width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
* height
)
2973 else if (BOOL_VECTOR_P (data
))
2975 if (XBOOL_VECTOR (data
)->size
< width
* height
)
2986 /* Scan a bitmap file. FP is the stream to read from. Value is
2987 either an enumerator from enum xbm_token, or a character for a
2988 single-character token, or 0 at end of file. If scanning an
2989 identifier, store the lexeme of the identifier in SVAL. If
2990 scanning a number, store its value in *IVAL. */
2993 xbm_scan (s
, end
, sval
, ival
)
2994 unsigned char **s
, *end
;
3002 /* Skip white space. */
3003 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
3008 else if (isdigit (c
))
3010 int value
= 0, digit
;
3012 if (c
== '0' && *s
< end
)
3015 if (c
== 'x' || c
== 'X')
3022 else if (c
>= 'a' && c
<= 'f')
3023 digit
= c
- 'a' + 10;
3024 else if (c
>= 'A' && c
<= 'F')
3025 digit
= c
- 'A' + 10;
3028 value
= 16 * value
+ digit
;
3031 else if (isdigit (c
))
3035 && (c
= *(*s
)++, isdigit (c
)))
3036 value
= 8 * value
+ c
- '0';
3043 && (c
= *(*s
)++, isdigit (c
)))
3044 value
= 10 * value
+ c
- '0';
3052 else if (isalpha (c
) || c
== '_')
3056 && (c
= *(*s
)++, (isalnum (c
) || c
== '_')))
3063 else if (c
== '/' && **s
== '*')
3065 /* C-style comment. */
3067 while (**s
&& (**s
!= '*' || *(*s
+ 1) != '/'))
3081 /* Create a Windows bitmap from X bitmap data. */
3083 w32_create_pixmap_from_bitmap_data (int width
, int height
, char *data
)
3085 static unsigned char swap_nibble
[16]
3086 = { 0x0, 0x8, 0x4, 0xc, /* 0000 1000 0100 1100 */
3087 0x2, 0xa, 0x6, 0xe, /* 0010 1010 0110 1110 */
3088 0x1, 0x9, 0x5, 0xd, /* 0001 1001 0101 1101 */
3089 0x3, 0xb, 0x7, 0xf }; /* 0011 1011 0111 1111 */
3091 unsigned char *bits
, *p
;
3094 w1
= (width
+ 7) / 8; /* nb of 8bits elt in X bitmap */
3095 w2
= ((width
+ 15) / 16) * 2; /* nb of 16bits elt in W32 bitmap */
3096 bits
= (unsigned char *) alloca (height
* w2
);
3097 bzero (bits
, height
* w2
);
3098 for (i
= 0; i
< height
; i
++)
3101 for (j
= 0; j
< w1
; j
++)
3103 /* Bitswap XBM bytes to match how Windows does things. */
3104 unsigned char c
= *data
++;
3105 *p
++ = (unsigned char)((swap_nibble
[c
& 0xf] << 4)
3106 | (swap_nibble
[(c
>>4) & 0xf]));
3109 bmp
= CreateBitmap (width
, height
, 1, 1, (char *) bits
);
3115 convert_mono_to_color_image (f
, img
, foreground
, background
)
3118 COLORREF foreground
, background
;
3120 HDC hdc
, old_img_dc
, new_img_dc
;
3121 HGDIOBJ old_prev
, new_prev
;
3124 hdc
= get_frame_dc (f
);
3125 old_img_dc
= CreateCompatibleDC (hdc
);
3126 new_img_dc
= CreateCompatibleDC (hdc
);
3127 new_pixmap
= CreateCompatibleBitmap (hdc
, img
->width
, img
->height
);
3128 release_frame_dc (f
, hdc
);
3129 old_prev
= SelectObject (old_img_dc
, img
->pixmap
);
3130 new_prev
= SelectObject (new_img_dc
, new_pixmap
);
3131 /* Windows convention for mono bitmaps is black = background,
3132 white = foreground. */
3133 SetTextColor (new_img_dc
, background
);
3134 SetBkColor (new_img_dc
, foreground
);
3136 BitBlt (new_img_dc
, 0, 0, img
->width
, img
->height
, old_img_dc
,
3139 SelectObject (old_img_dc
, old_prev
);
3140 SelectObject (new_img_dc
, new_prev
);
3141 DeleteDC (old_img_dc
);
3142 DeleteDC (new_img_dc
);
3143 DeleteObject (img
->pixmap
);
3144 if (new_pixmap
== 0)
3145 fprintf (stderr
, "Failed to convert image to color.\n");
3147 img
->pixmap
= new_pixmap
;
3150 #define XBM_BIT_SHUFFLE(b) (~(b))
3154 #define XBM_BIT_SHUFFLE(b) (b)
3156 #endif /* HAVE_NTGUI */
3160 Create_Pixmap_From_Bitmap_Data (f
, img
, data
, fg
, bg
, non_default_colors
)
3164 RGB_PIXEL_COLOR fg
, bg
;
3165 int non_default_colors
;
3169 = w32_create_pixmap_from_bitmap_data (img
->width
, img
->height
, data
);
3171 /* If colors were specified, transfer the bitmap to a color one. */
3172 if (non_default_colors
)
3173 convert_mono_to_color_image (f
, img
, fg
, bg
);
3176 = XCreatePixmapFromBitmapData (FRAME_X_DISPLAY (f
),
3179 img
->width
, img
->height
,
3181 DefaultDepthOfScreen (FRAME_X_SCREEN (f
)));
3182 #endif /* HAVE_NTGUI */
3187 /* Replacement for XReadBitmapFileData which isn't available under old
3188 X versions. CONTENTS is a pointer to a buffer to parse; END is the
3189 buffer's end. Set *WIDTH and *HEIGHT to the width and height of
3190 the image. Return in *DATA the bitmap data allocated with xmalloc.
3191 Value is non-zero if successful. DATA null means just test if
3192 CONTENTS looks like an in-memory XBM file. */
3195 xbm_read_bitmap_data (f
, contents
, end
, width
, height
, data
)
3197 unsigned char *contents
, *end
;
3198 int *width
, *height
;
3199 unsigned char **data
;
3201 unsigned char *s
= contents
;
3202 char buffer
[BUFSIZ
];
3205 int bytes_per_line
, i
, nbytes
;
3211 LA1 = xbm_scan (&s, end, buffer, &value)
3213 #define expect(TOKEN) \
3214 if (LA1 != (TOKEN)) \
3219 #define expect_ident(IDENT) \
3220 if (LA1 == XBM_TK_IDENT && strcmp (buffer, (IDENT)) == 0) \
3225 *width
= *height
= -1;
3228 LA1
= xbm_scan (&s
, end
, buffer
, &value
);
3230 /* Parse defines for width, height and hot-spots. */
3234 expect_ident ("define");
3235 expect (XBM_TK_IDENT
);
3237 if (LA1
== XBM_TK_NUMBER
)
3239 char *p
= strrchr (buffer
, '_');
3240 p
= p
? p
+ 1 : buffer
;
3241 if (strcmp (p
, "width") == 0)
3243 else if (strcmp (p
, "height") == 0)
3246 expect (XBM_TK_NUMBER
);
3249 if (!check_image_size (f
, *width
, *height
))
3251 else if (data
== NULL
)
3254 /* Parse bits. Must start with `static'. */
3255 expect_ident ("static");
3256 if (LA1
== XBM_TK_IDENT
)
3258 if (strcmp (buffer
, "unsigned") == 0)
3261 expect_ident ("char");
3263 else if (strcmp (buffer
, "short") == 0)
3267 if (*width
% 16 && *width
% 16 < 9)
3270 else if (strcmp (buffer
, "char") == 0)
3278 expect (XBM_TK_IDENT
);
3284 bytes_per_line
= (*width
+ 7) / 8 + padding_p
;
3285 nbytes
= bytes_per_line
* *height
;
3286 p
= *data
= (unsigned char *) xmalloc (nbytes
);
3290 for (i
= 0; i
< nbytes
; i
+= 2)
3293 expect (XBM_TK_NUMBER
);
3295 *p
++ = XBM_BIT_SHUFFLE (val
);
3296 if (!padding_p
|| ((i
+ 2) % bytes_per_line
))
3297 *p
++ = XBM_BIT_SHUFFLE (value
>> 8);
3299 if (LA1
== ',' || LA1
== '}')
3307 for (i
= 0; i
< nbytes
; ++i
)
3310 expect (XBM_TK_NUMBER
);
3312 *p
++ = XBM_BIT_SHUFFLE (val
);
3314 if (LA1
== ',' || LA1
== '}')
3339 /* Load XBM image IMG which will be displayed on frame F from buffer
3340 CONTENTS. END is the end of the buffer. Value is non-zero if
3344 xbm_load_image (f
, img
, contents
, end
)
3347 unsigned char *contents
, *end
;
3350 unsigned char *data
;
3353 rc
= xbm_read_bitmap_data (f
, contents
, end
, &img
->width
, &img
->height
, &data
);
3356 unsigned long foreground
= FRAME_FOREGROUND_PIXEL (f
);
3357 unsigned long background
= FRAME_BACKGROUND_PIXEL (f
);
3358 int non_default_colors
= 0;
3361 xassert (img
->width
> 0 && img
->height
> 0);
3363 /* Get foreground and background colors, maybe allocate colors. */
3364 value
= image_spec_value (img
->spec
, QCforeground
, NULL
);
3367 foreground
= x_alloc_image_color (f
, img
, value
, foreground
);
3368 non_default_colors
= 1;
3370 value
= image_spec_value (img
->spec
, QCbackground
, NULL
);
3373 background
= x_alloc_image_color (f
, img
, value
, background
);
3374 img
->background
= background
;
3375 img
->background_valid
= 1;
3376 non_default_colors
= 1;
3379 Create_Pixmap_From_Bitmap_Data (f
, img
, data
,
3380 foreground
, background
,
3381 non_default_colors
);
3384 if (img
->pixmap
== NO_PIXMAP
)
3386 x_clear_image (f
, img
);
3387 image_error ("Unable to create X pixmap for `%s'", img
->spec
, Qnil
);
3393 image_error ("Error loading XBM image `%s'", img
->spec
, Qnil
);
3399 /* Value is non-zero if DATA looks like an in-memory XBM file. */
3406 return (STRINGP (data
)
3407 && xbm_read_bitmap_data (NULL
, SDATA (data
),
3414 /* Fill image IMG which is used on frame F with pixmap data. Value is
3415 non-zero if successful. */
3423 Lisp_Object file_name
;
3425 xassert (xbm_image_p (img
->spec
));
3427 /* If IMG->spec specifies a file name, create a non-file spec from it. */
3428 file_name
= image_spec_value (img
->spec
, QCfile
, NULL
);
3429 if (STRINGP (file_name
))
3432 unsigned char *contents
;
3434 struct gcpro gcpro1
;
3436 file
= x_find_image_file (file_name
);
3438 if (!STRINGP (file
))
3440 image_error ("Cannot find image file `%s'", file_name
, Qnil
);
3445 contents
= slurp_file (SDATA (file
), &size
);
3446 if (contents
== NULL
)
3448 image_error ("Error loading XBM image `%s'", img
->spec
, Qnil
);
3453 success_p
= xbm_load_image (f
, img
, contents
, contents
+ size
);
3458 struct image_keyword fmt
[XBM_LAST
];
3460 unsigned long foreground
= FRAME_FOREGROUND_PIXEL (f
);
3461 unsigned long background
= FRAME_BACKGROUND_PIXEL (f
);
3462 int non_default_colors
= 0;
3465 int in_memory_file_p
= 0;
3467 /* See if data looks like an in-memory XBM file. */
3468 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
3469 in_memory_file_p
= xbm_file_p (data
);
3471 /* Parse the image specification. */
3472 bcopy (xbm_format
, fmt
, sizeof fmt
);
3473 parsed_p
= parse_image_spec (img
->spec
, fmt
, XBM_LAST
, Qxbm
);
3476 /* Get specified width, and height. */
3477 if (!in_memory_file_p
)
3479 img
->width
= XFASTINT (fmt
[XBM_WIDTH
].value
);
3480 img
->height
= XFASTINT (fmt
[XBM_HEIGHT
].value
);
3481 xassert (img
->width
> 0 && img
->height
> 0);
3484 /* Get foreground and background colors, maybe allocate colors. */
3485 if (fmt
[XBM_FOREGROUND
].count
3486 && STRINGP (fmt
[XBM_FOREGROUND
].value
))
3488 foreground
= x_alloc_image_color (f
, img
, fmt
[XBM_FOREGROUND
].value
,
3490 non_default_colors
= 1;
3493 if (fmt
[XBM_BACKGROUND
].count
3494 && STRINGP (fmt
[XBM_BACKGROUND
].value
))
3496 background
= x_alloc_image_color (f
, img
, fmt
[XBM_BACKGROUND
].value
,
3498 non_default_colors
= 1;
3501 if (in_memory_file_p
)
3502 success_p
= xbm_load_image (f
, img
, SDATA (data
),
3511 int nbytes
= (img
->width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
;
3513 p
= bits
= (char *) alloca (nbytes
* img
->height
);
3514 for (i
= 0; i
< img
->height
; ++i
, p
+= nbytes
)
3516 Lisp_Object line
= XVECTOR (data
)->contents
[i
];
3518 bcopy (SDATA (line
), p
, nbytes
);
3520 bcopy (XBOOL_VECTOR (line
)->data
, p
, nbytes
);
3523 else if (STRINGP (data
))
3524 bits
= SDATA (data
);
3526 bits
= XBOOL_VECTOR (data
)->data
;
3532 /* Windows mono bitmaps are reversed compared with X. */
3533 invertedBits
= bits
;
3534 nbytes
= (img
->width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
3536 bits
= (char *) alloca(nbytes
);
3537 for (i
= 0; i
< nbytes
; i
++)
3538 bits
[i
] = XBM_BIT_SHUFFLE (invertedBits
[i
]);
3541 /* Create the pixmap. */
3543 Create_Pixmap_From_Bitmap_Data (f
, img
, bits
,
3544 foreground
, background
,
3545 non_default_colors
);
3550 image_error ("Unable to create pixmap for XBM image `%s'",
3552 x_clear_image (f
, img
);
3562 /***********************************************************************
3564 ***********************************************************************/
3566 #if defined (HAVE_XPM) || defined (MAC_OS)
3568 static int xpm_image_p
P_ ((Lisp_Object object
));
3569 static int xpm_load
P_ ((struct frame
*f
, struct image
*img
));
3570 static int xpm_valid_color_symbols_p
P_ ((Lisp_Object
));
3572 #endif /* HAVE_XPM || MAC_OS */
3576 /* Indicate to xpm.h that we don't have Xlib. */
3578 /* simx.h in xpm defines XColor and XImage differently than Emacs. */
3579 /* It also defines Display the same way as Emacs, but gcc 3.3 still barfs. */
3580 #define XColor xpm_XColor
3581 #define XImage xpm_XImage
3582 #define Display xpm_Display
3583 #define PIXEL_ALREADY_TYPEDEFED
3584 #include "X11/xpm.h"
3589 #undef PIXEL_ALREADY_TYPEDEFED
3591 #include "X11/xpm.h"
3592 #endif /* HAVE_NTGUI */
3593 #endif /* HAVE_XPM */
3595 #if defined (HAVE_XPM) || defined (MAC_OS)
3596 /* The symbol `xpm' identifying XPM-format images. */
3600 /* Indices of image specification fields in xpm_format, below. */
3602 enum xpm_keyword_index
3618 /* Vector of image_keyword structures describing the format
3619 of valid XPM image specifications. */
3621 static struct image_keyword xpm_format
[XPM_LAST
] =
3623 {":type", IMAGE_SYMBOL_VALUE
, 1},
3624 {":file", IMAGE_STRING_VALUE
, 0},
3625 {":data", IMAGE_STRING_VALUE
, 0},
3626 {":ascent", IMAGE_ASCENT_VALUE
, 0},
3627 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
3628 {":relief", IMAGE_INTEGER_VALUE
, 0},
3629 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3630 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3631 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3632 {":color-symbols", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3633 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
3636 /* Structure describing the image type XPM. */
3638 static struct image_type xpm_type
=
3647 #ifdef HAVE_X_WINDOWS
3649 /* Define ALLOC_XPM_COLORS if we can use Emacs' own color allocation
3650 functions for allocating image colors. Our own functions handle
3651 color allocation failures more gracefully than the ones on the XPM
3654 #if defined XpmAllocColor && defined XpmFreeColors && defined XpmColorClosure
3655 #define ALLOC_XPM_COLORS
3657 #endif /* HAVE_X_WINDOWS */
3659 #ifdef ALLOC_XPM_COLORS
3661 static void xpm_init_color_cache
P_ ((struct frame
*, XpmAttributes
*));
3662 static void xpm_free_color_cache
P_ ((void));
3663 static int xpm_lookup_color
P_ ((struct frame
*, char *, XColor
*));
3664 static int xpm_color_bucket
P_ ((char *));
3665 static struct xpm_cached_color
*xpm_cache_color
P_ ((struct frame
*, char *,
3668 /* An entry in a hash table used to cache color definitions of named
3669 colors. This cache is necessary to speed up XPM image loading in
3670 case we do color allocations ourselves. Without it, we would need
3671 a call to XParseColor per pixel in the image. */
3673 struct xpm_cached_color
3675 /* Next in collision chain. */
3676 struct xpm_cached_color
*next
;
3678 /* Color definition (RGB and pixel color). */
3685 /* The hash table used for the color cache, and its bucket vector
3688 #define XPM_COLOR_CACHE_BUCKETS 1001
3689 struct xpm_cached_color
**xpm_color_cache
;
3691 /* Initialize the color cache. */
3694 xpm_init_color_cache (f
, attrs
)
3696 XpmAttributes
*attrs
;
3698 size_t nbytes
= XPM_COLOR_CACHE_BUCKETS
* sizeof *xpm_color_cache
;
3699 xpm_color_cache
= (struct xpm_cached_color
**) xmalloc (nbytes
);
3700 memset (xpm_color_cache
, 0, nbytes
);
3701 init_color_table ();
3703 if (attrs
->valuemask
& XpmColorSymbols
)
3708 for (i
= 0; i
< attrs
->numsymbols
; ++i
)
3709 if (XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
3710 attrs
->colorsymbols
[i
].value
, &color
))
3712 color
.pixel
= lookup_rgb_color (f
, color
.red
, color
.green
,
3714 xpm_cache_color (f
, attrs
->colorsymbols
[i
].name
, &color
, -1);
3719 /* Free the color cache. */
3722 xpm_free_color_cache ()
3724 struct xpm_cached_color
*p
, *next
;
3727 for (i
= 0; i
< XPM_COLOR_CACHE_BUCKETS
; ++i
)
3728 for (p
= xpm_color_cache
[i
]; p
; p
= next
)
3734 xfree (xpm_color_cache
);
3735 xpm_color_cache
= NULL
;
3736 free_color_table ();
3739 /* Return the bucket index for color named COLOR_NAME in the color
3743 xpm_color_bucket (color_name
)
3749 for (s
= color_name
; *s
; ++s
)
3751 return h
%= XPM_COLOR_CACHE_BUCKETS
;
3755 /* On frame F, cache values COLOR for color with name COLOR_NAME.
3756 BUCKET, if >= 0, is a precomputed bucket index. Value is the cache
3759 static struct xpm_cached_color
*
3760 xpm_cache_color (f
, color_name
, color
, bucket
)
3767 struct xpm_cached_color
*p
;
3770 bucket
= xpm_color_bucket (color_name
);
3772 nbytes
= sizeof *p
+ strlen (color_name
);
3773 p
= (struct xpm_cached_color
*) xmalloc (nbytes
);
3774 strcpy (p
->name
, color_name
);
3776 p
->next
= xpm_color_cache
[bucket
];
3777 xpm_color_cache
[bucket
] = p
;
3781 /* Look up color COLOR_NAME for frame F in the color cache. If found,
3782 return the cached definition in *COLOR. Otherwise, make a new
3783 entry in the cache and allocate the color. Value is zero if color
3784 allocation failed. */
3787 xpm_lookup_color (f
, color_name
, color
)
3792 struct xpm_cached_color
*p
;
3793 int h
= xpm_color_bucket (color_name
);
3795 for (p
= xpm_color_cache
[h
]; p
; p
= p
->next
)
3796 if (strcmp (p
->name
, color_name
) == 0)
3801 else if (XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
3804 color
->pixel
= lookup_rgb_color (f
, color
->red
, color
->green
,
3806 p
= xpm_cache_color (f
, color_name
, color
, h
);
3808 /* You get `opaque' at least from ImageMagick converting pbm to xpm
3809 with transparency, and it's useful. */
3810 else if (strcmp ("opaque", color_name
) == 0)
3812 bzero (color
, sizeof (XColor
)); /* Is this necessary/correct? */
3813 color
->pixel
= FRAME_FOREGROUND_PIXEL (f
);
3814 p
= xpm_cache_color (f
, color_name
, color
, h
);
3821 /* Callback for allocating color COLOR_NAME. Called from the XPM lib.
3822 CLOSURE is a pointer to the frame on which we allocate the
3823 color. Return in *COLOR the allocated color. Value is non-zero
3827 xpm_alloc_color (dpy
, cmap
, color_name
, color
, closure
)
3834 return xpm_lookup_color ((struct frame
*) closure
, color_name
, color
);
3838 /* Callback for freeing NPIXELS colors contained in PIXELS. CLOSURE
3839 is a pointer to the frame on which we allocate the color. Value is
3840 non-zero if successful. */
3843 xpm_free_colors (dpy
, cmap
, pixels
, npixels
, closure
)
3853 #endif /* ALLOC_XPM_COLORS */
3858 /* XPM library details. */
3860 DEF_IMGLIB_FN (XpmFreeAttributes
);
3861 DEF_IMGLIB_FN (XpmCreateImageFromBuffer
);
3862 DEF_IMGLIB_FN (XpmReadFileToImage
);
3863 DEF_IMGLIB_FN (XImageFree
);
3866 init_xpm_functions (Lisp_Object libraries
)
3870 if (!(library
= w32_delayed_load (libraries
, Qxpm
)))
3873 LOAD_IMGLIB_FN (library
, XpmFreeAttributes
);
3874 LOAD_IMGLIB_FN (library
, XpmCreateImageFromBuffer
);
3875 LOAD_IMGLIB_FN (library
, XpmReadFileToImage
);
3876 LOAD_IMGLIB_FN (library
, XImageFree
);
3880 #endif /* HAVE_NTGUI */
3883 /* Value is non-zero if COLOR_SYMBOLS is a valid color symbols list
3884 for XPM images. Such a list must consist of conses whose car and
3888 xpm_valid_color_symbols_p (color_symbols
)
3889 Lisp_Object color_symbols
;
3891 while (CONSP (color_symbols
))
3893 Lisp_Object sym
= XCAR (color_symbols
);
3895 || !STRINGP (XCAR (sym
))
3896 || !STRINGP (XCDR (sym
)))
3898 color_symbols
= XCDR (color_symbols
);
3901 return NILP (color_symbols
);
3905 /* Value is non-zero if OBJECT is a valid XPM image specification. */
3908 xpm_image_p (object
)
3911 struct image_keyword fmt
[XPM_LAST
];
3912 bcopy (xpm_format
, fmt
, sizeof fmt
);
3913 return (parse_image_spec (object
, fmt
, XPM_LAST
, Qxpm
)
3914 /* Either `:file' or `:data' must be present. */
3915 && fmt
[XPM_FILE
].count
+ fmt
[XPM_DATA
].count
== 1
3916 /* Either no `:color-symbols' or it's a list of conses
3917 whose car and cdr are strings. */
3918 && (fmt
[XPM_COLOR_SYMBOLS
].count
== 0
3919 || xpm_valid_color_symbols_p (fmt
[XPM_COLOR_SYMBOLS
].value
)));
3922 #endif /* HAVE_XPM || MAC_OS */
3924 #if defined (HAVE_XPM) && defined (HAVE_X_WINDOWS)
3926 x_create_bitmap_from_xpm_data (f
, bits
)
3930 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
3932 XpmAttributes attrs
;
3933 Pixmap bitmap
, mask
;
3935 bzero (&attrs
, sizeof attrs
);
3937 attrs
.visual
= FRAME_X_VISUAL (f
);
3938 attrs
.colormap
= FRAME_X_COLORMAP (f
);
3939 attrs
.valuemask
|= XpmVisual
;
3940 attrs
.valuemask
|= XpmColormap
;
3942 rc
= XpmCreatePixmapFromData (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3943 bits
, &bitmap
, &mask
, &attrs
);
3944 if (rc
!= XpmSuccess
)
3946 XpmFreeAttributes (&attrs
);
3950 id
= x_allocate_bitmap_record (f
);
3951 dpyinfo
->bitmaps
[id
- 1].pixmap
= bitmap
;
3952 dpyinfo
->bitmaps
[id
- 1].have_mask
= 1;
3953 dpyinfo
->bitmaps
[id
- 1].mask
= mask
;
3954 dpyinfo
->bitmaps
[id
- 1].file
= NULL
;
3955 dpyinfo
->bitmaps
[id
- 1].height
= attrs
.height
;
3956 dpyinfo
->bitmaps
[id
- 1].width
= attrs
.width
;
3957 dpyinfo
->bitmaps
[id
- 1].depth
= attrs
.depth
;
3958 dpyinfo
->bitmaps
[id
- 1].refcount
= 1;
3960 XpmFreeAttributes (&attrs
);
3963 #endif /* defined (HAVE_XPM) && defined (HAVE_X_WINDOWS) */
3965 /* Load image IMG which will be displayed on frame F. Value is
3966 non-zero if successful. */
3976 XpmAttributes attrs
;
3977 Lisp_Object specified_file
, color_symbols
;
3980 xpm_XImage
* xpm_image
= NULL
, * xpm_mask
= NULL
;
3981 #endif /* HAVE_NTGUI */
3983 /* Configure the XPM lib. Use the visual of frame F. Allocate
3984 close colors. Return colors allocated. */
3985 bzero (&attrs
, sizeof attrs
);
3988 attrs
.visual
= FRAME_X_VISUAL (f
);
3989 attrs
.colormap
= FRAME_X_COLORMAP (f
);
3990 attrs
.valuemask
|= XpmVisual
;
3991 attrs
.valuemask
|= XpmColormap
;
3992 #endif /* HAVE_NTGUI */
3994 #ifdef ALLOC_XPM_COLORS
3995 /* Allocate colors with our own functions which handle
3996 failing color allocation more gracefully. */
3997 attrs
.color_closure
= f
;
3998 attrs
.alloc_color
= xpm_alloc_color
;
3999 attrs
.free_colors
= xpm_free_colors
;
4000 attrs
.valuemask
|= XpmAllocColor
| XpmFreeColors
| XpmColorClosure
;
4001 #else /* not ALLOC_XPM_COLORS */
4002 /* Let the XPM lib allocate colors. */
4003 attrs
.valuemask
|= XpmReturnAllocPixels
;
4004 #ifdef XpmAllocCloseColors
4005 attrs
.alloc_close_colors
= 1;
4006 attrs
.valuemask
|= XpmAllocCloseColors
;
4007 #else /* not XpmAllocCloseColors */
4008 attrs
.closeness
= 600;
4009 attrs
.valuemask
|= XpmCloseness
;
4010 #endif /* not XpmAllocCloseColors */
4011 #endif /* ALLOC_XPM_COLORS */
4013 /* If image specification contains symbolic color definitions, add
4014 these to `attrs'. */
4015 color_symbols
= image_spec_value (img
->spec
, QCcolor_symbols
, NULL
);
4016 if (CONSP (color_symbols
))
4019 XpmColorSymbol
*xpm_syms
;
4022 attrs
.valuemask
|= XpmColorSymbols
;
4024 /* Count number of symbols. */
4025 attrs
.numsymbols
= 0;
4026 for (tail
= color_symbols
; CONSP (tail
); tail
= XCDR (tail
))
4029 /* Allocate an XpmColorSymbol array. */
4030 size
= attrs
.numsymbols
* sizeof *xpm_syms
;
4031 xpm_syms
= (XpmColorSymbol
*) alloca (size
);
4032 bzero (xpm_syms
, size
);
4033 attrs
.colorsymbols
= xpm_syms
;
4035 /* Fill the color symbol array. */
4036 for (tail
= color_symbols
, i
= 0;
4038 ++i
, tail
= XCDR (tail
))
4040 Lisp_Object name
= XCAR (XCAR (tail
));
4041 Lisp_Object color
= XCDR (XCAR (tail
));
4042 xpm_syms
[i
].name
= (char *) alloca (SCHARS (name
) + 1);
4043 strcpy (xpm_syms
[i
].name
, SDATA (name
));
4044 xpm_syms
[i
].value
= (char *) alloca (SCHARS (color
) + 1);
4045 strcpy (xpm_syms
[i
].value
, SDATA (color
));
4049 /* Create a pixmap for the image, either from a file, or from a
4050 string buffer containing data in the same format as an XPM file. */
4051 #ifdef ALLOC_XPM_COLORS
4052 xpm_init_color_cache (f
, &attrs
);
4055 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
4059 HDC frame_dc
= get_frame_dc (f
);
4060 hdc
= CreateCompatibleDC (frame_dc
);
4061 release_frame_dc (f
, frame_dc
);
4063 #endif /* HAVE_NTGUI */
4065 if (STRINGP (specified_file
))
4067 Lisp_Object file
= x_find_image_file (specified_file
);
4068 if (!STRINGP (file
))
4070 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
4075 /* XpmReadFileToPixmap is not available in the Windows port of
4076 libxpm. But XpmReadFileToImage almost does what we want. */
4077 rc
= fn_XpmReadFileToImage (&hdc
, SDATA (file
),
4078 &xpm_image
, &xpm_mask
,
4081 rc
= XpmReadFileToPixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
4082 SDATA (file
), &img
->pixmap
, &img
->mask
,
4084 #endif /* HAVE_NTGUI */
4088 Lisp_Object buffer
= image_spec_value (img
->spec
, QCdata
, NULL
);
4090 /* XpmCreatePixmapFromBuffer is not available in the Windows port
4091 of libxpm. But XpmCreateImageFromBuffer almost does what we want. */
4092 rc
= fn_XpmCreateImageFromBuffer (&hdc
, SDATA (buffer
),
4093 &xpm_image
, &xpm_mask
,
4096 rc
= XpmCreatePixmapFromBuffer (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
4098 &img
->pixmap
, &img
->mask
,
4100 #endif /* HAVE_NTGUI */
4103 if (rc
== XpmSuccess
)
4105 #if defined (COLOR_TABLE_SUPPORT) && defined (ALLOC_XPM_COLORS)
4106 img
->colors
= colors_in_color_table (&img
->ncolors
);
4107 #else /* not ALLOC_XPM_COLORS */
4111 /* W32 XPM uses XImage to wrap what W32 Emacs calls a Pixmap,
4112 plus some duplicate attributes. */
4113 if (xpm_image
&& xpm_image
->bitmap
)
4115 img
->pixmap
= xpm_image
->bitmap
;
4116 /* XImageFree in libXpm frees XImage struct without destroying
4117 the bitmap, which is what we want. */
4118 fn_XImageFree (xpm_image
);
4120 if (xpm_mask
&& xpm_mask
->bitmap
)
4122 /* The mask appears to be inverted compared with what we expect.
4123 TODO: invert our expectations. See other places where we
4124 have to invert bits because our idea of masks is backwards. */
4126 old_obj
= SelectObject (hdc
, xpm_mask
->bitmap
);
4128 PatBlt (hdc
, 0, 0, xpm_mask
->width
, xpm_mask
->height
, DSTINVERT
);
4129 SelectObject (hdc
, old_obj
);
4131 img
->mask
= xpm_mask
->bitmap
;
4132 fn_XImageFree (xpm_mask
);
4137 #endif /* HAVE_NTGUI */
4139 /* Remember allocated colors. */
4140 img
->ncolors
= attrs
.nalloc_pixels
;
4141 img
->colors
= (unsigned long *) xmalloc (img
->ncolors
4142 * sizeof *img
->colors
);
4143 for (i
= 0; i
< attrs
.nalloc_pixels
; ++i
)
4145 img
->colors
[i
] = attrs
.alloc_pixels
[i
];
4146 #ifdef DEBUG_X_COLORS
4147 register_color (img
->colors
[i
]);
4150 #endif /* not ALLOC_XPM_COLORS */
4152 img
->width
= attrs
.width
;
4153 img
->height
= attrs
.height
;
4154 xassert (img
->width
> 0 && img
->height
> 0);
4156 /* The call to XpmFreeAttributes below frees attrs.alloc_pixels. */
4158 fn_XpmFreeAttributes (&attrs
);
4160 XpmFreeAttributes (&attrs
);
4161 #endif /* HAVE_NTGUI */
4167 #endif /* HAVE_NTGUI */
4172 image_error ("Error opening XPM file (%s)", img
->spec
, Qnil
);
4175 case XpmFileInvalid
:
4176 image_error ("Invalid XPM file (%s)", img
->spec
, Qnil
);
4180 image_error ("Out of memory (%s)", img
->spec
, Qnil
);
4183 case XpmColorFailed
:
4184 image_error ("Color allocation error (%s)", img
->spec
, Qnil
);
4188 image_error ("Unknown error (%s)", img
->spec
, Qnil
);
4193 #ifdef ALLOC_XPM_COLORS
4194 xpm_free_color_cache ();
4196 return rc
== XpmSuccess
;
4199 #endif /* HAVE_XPM */
4203 /* XPM support functions for Mac OS where libxpm is not available.
4204 Only XPM version 3 (without any extensions) is supported. */
4206 static int xpm_scan
P_ ((const unsigned char **, const unsigned char *,
4207 const unsigned char **, int *));
4208 static Lisp_Object xpm_make_color_table_v
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_v
P_ ((Lisp_Object
, const unsigned char *,
4213 static Lisp_Object xpm_get_color_table_v
P_ ((Lisp_Object
,
4214 const unsigned char *, int));
4215 static Lisp_Object xpm_make_color_table_h
4216 P_ ((void (**) (Lisp_Object
, const unsigned char *, int, Lisp_Object
),
4217 Lisp_Object (**) (Lisp_Object
, const unsigned char *, int)));
4218 static void xpm_put_color_table_h
P_ ((Lisp_Object
, const unsigned char *,
4220 static Lisp_Object xpm_get_color_table_h
P_ ((Lisp_Object
,
4221 const unsigned char *, int));
4222 static int xpm_str_to_color_key
P_ ((const char *));
4223 static int xpm_load_image
P_ ((struct frame
*, struct image
*,
4224 const unsigned char *, const unsigned char *));
4226 /* Tokens returned from xpm_scan. */
4235 /* Scan an XPM data and return a character (< 256) or a token defined
4236 by enum xpm_token above. *S and END are the start (inclusive) and
4237 the end (exclusive) addresses of the data, respectively. Advance
4238 *S while scanning. If token is either XPM_TK_IDENT or
4239 XPM_TK_STRING, *BEG and *LEN are set to the start address and the
4240 length of the corresponding token, respectively. */
4243 xpm_scan (s
, end
, beg
, len
)
4244 const unsigned char **s
, *end
, **beg
;
4251 /* Skip white-space. */
4252 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
4255 /* gnus-pointer.xpm uses '-' in its identifier.
4256 sb-dir-plus.xpm uses '+' in its identifier. */
4257 if (isalpha (c
) || c
== '_' || c
== '-' || c
== '+')
4261 (c
= **s
, isalnum (c
) || c
== '_' || c
== '-' || c
== '+'))
4264 return XPM_TK_IDENT
;
4269 while (*s
< end
&& **s
!= '"')
4274 return XPM_TK_STRING
;
4278 if (*s
< end
&& **s
== '*')
4280 /* C-style comment. */
4284 while (*s
< end
&& *(*s
)++ != '*')
4287 while (*s
< end
&& **s
!= '/');
4301 /* Functions for color table lookup in XPM data. A key is a string
4302 specifying the color of each pixel in XPM data. A value is either
4303 an integer that specifies a pixel color, Qt that specifies
4304 transparency, or Qnil for the unspecified color. If the length of
4305 the key string is one, a vector is used as a table. Otherwise, a
4306 hash table is used. */
4309 xpm_make_color_table_v (put_func
, get_func
)
4310 void (**put_func
) (Lisp_Object
, const unsigned char *, int, Lisp_Object
);
4311 Lisp_Object (**get_func
) (Lisp_Object
, const unsigned char *, int);
4313 *put_func
= xpm_put_color_table_v
;
4314 *get_func
= xpm_get_color_table_v
;
4315 return Fmake_vector (make_number (256), Qnil
);
4319 xpm_put_color_table_v (color_table
, chars_start
, chars_len
, color
)
4320 Lisp_Object color_table
;
4321 const unsigned char *chars_start
;
4325 XVECTOR (color_table
)->contents
[*chars_start
] = color
;
4329 xpm_get_color_table_v (color_table
, chars_start
, chars_len
)
4330 Lisp_Object color_table
;
4331 const unsigned char *chars_start
;
4334 return XVECTOR (color_table
)->contents
[*chars_start
];
4338 xpm_make_color_table_h (put_func
, get_func
)
4339 void (**put_func
) (Lisp_Object
, const unsigned char *, int, Lisp_Object
);
4340 Lisp_Object (**get_func
) (Lisp_Object
, const unsigned char *, int);
4342 *put_func
= xpm_put_color_table_h
;
4343 *get_func
= xpm_get_color_table_h
;
4344 return make_hash_table (Qequal
, make_number (DEFAULT_HASH_SIZE
),
4345 make_float (DEFAULT_REHASH_SIZE
),
4346 make_float (DEFAULT_REHASH_THRESHOLD
),
4351 xpm_put_color_table_h (color_table
, chars_start
, chars_len
, color
)
4352 Lisp_Object color_table
;
4353 const unsigned char *chars_start
;
4357 struct Lisp_Hash_Table
*table
= XHASH_TABLE (color_table
);
4359 Lisp_Object chars
= make_unibyte_string (chars_start
, chars_len
);
4361 hash_lookup (table
, chars
, &hash_code
);
4362 hash_put (table
, chars
, color
, hash_code
);
4366 xpm_get_color_table_h (color_table
, chars_start
, chars_len
)
4367 Lisp_Object color_table
;
4368 const unsigned char *chars_start
;
4371 struct Lisp_Hash_Table
*table
= XHASH_TABLE (color_table
);
4372 int i
= hash_lookup (table
, make_unibyte_string (chars_start
, chars_len
),
4375 return i
>= 0 ? HASH_VALUE (table
, i
) : Qnil
;
4378 enum xpm_color_key
{
4386 static const char xpm_color_key_strings
[][4] = {"s", "m", "g4", "g", "c"};
4389 xpm_str_to_color_key (s
)
4395 i
< sizeof xpm_color_key_strings
/ sizeof xpm_color_key_strings
[0];
4397 if (strcmp (xpm_color_key_strings
[i
], s
) == 0)
4403 xpm_load_image (f
, img
, contents
, end
)
4406 const unsigned char *contents
, *end
;
4408 const unsigned char *s
= contents
, *beg
, *str
;
4409 unsigned char buffer
[BUFSIZ
];
4410 int width
, height
, x
, y
;
4411 int num_colors
, chars_per_pixel
;
4413 void (*put_color_table
) (Lisp_Object
, const unsigned char *, int, Lisp_Object
);
4414 Lisp_Object (*get_color_table
) (Lisp_Object
, const unsigned char *, int);
4415 Lisp_Object frame
, color_symbols
, color_table
;
4416 int best_key
, have_mask
= 0;
4417 XImagePtr ximg
= NULL
, mask_img
= NULL
;
4420 LA1 = xpm_scan (&s, end, &beg, &len)
4422 #define expect(TOKEN) \
4423 if (LA1 != (TOKEN)) \
4428 #define expect_ident(IDENT) \
4429 if (LA1 == XPM_TK_IDENT \
4430 && strlen ((IDENT)) == len && memcmp ((IDENT), beg, len) == 0) \
4435 if (!(end
- s
>= 9 && memcmp (s
, "/* XPM */", 9) == 0))
4439 expect_ident ("static");
4440 expect_ident ("char");
4442 expect (XPM_TK_IDENT
);
4447 expect (XPM_TK_STRING
);
4450 memcpy (buffer
, beg
, len
);
4452 if (sscanf (buffer
, "%d %d %d %d", &width
, &height
,
4453 &num_colors
, &chars_per_pixel
) != 4
4454 || width
<= 0 || height
<= 0
4455 || num_colors
<= 0 || chars_per_pixel
<= 0)
4458 if (!check_image_size (f
, width
, height
))
4460 image_error ("Invalid image size", Qnil
, Qnil
);
4466 XSETFRAME (frame
, f
);
4467 if (!NILP (Fxw_display_color_p (frame
)))
4468 best_key
= XPM_COLOR_KEY_C
;
4469 else if (!NILP (Fx_display_grayscale_p (frame
)))
4470 best_key
= (XFASTINT (Fx_display_planes (frame
)) > 2
4471 ? XPM_COLOR_KEY_G
: XPM_COLOR_KEY_G4
);
4473 best_key
= XPM_COLOR_KEY_M
;
4475 color_symbols
= image_spec_value (img
->spec
, QCcolor_symbols
, NULL
);
4476 if (chars_per_pixel
== 1)
4477 color_table
= xpm_make_color_table_v (&put_color_table
,
4480 color_table
= xpm_make_color_table_h (&put_color_table
,
4483 while (num_colors
-- > 0)
4485 unsigned char *color
, *max_color
;
4486 int key
, next_key
, max_key
= 0;
4487 Lisp_Object symbol_color
= Qnil
, color_val
;
4490 expect (XPM_TK_STRING
);
4491 if (len
<= chars_per_pixel
|| len
>= BUFSIZ
+ chars_per_pixel
)
4493 memcpy (buffer
, beg
+ chars_per_pixel
, len
- chars_per_pixel
);
4494 buffer
[len
- chars_per_pixel
] = '\0';
4496 str
= strtok (buffer
, " \t");
4499 key
= xpm_str_to_color_key (str
);
4504 color
= strtok (NULL
, " \t");
4508 while ((str
= strtok (NULL
, " \t")) != NULL
)
4510 next_key
= xpm_str_to_color_key (str
);
4513 color
[strlen (color
)] = ' ';
4516 if (key
== XPM_COLOR_KEY_S
)
4518 if (NILP (symbol_color
))
4519 symbol_color
= build_string (color
);
4521 else if (max_key
< key
&& key
<= best_key
)
4531 if (!NILP (color_symbols
) && !NILP (symbol_color
))
4533 Lisp_Object specified_color
= Fassoc (symbol_color
, color_symbols
);
4535 if (CONSP (specified_color
) && STRINGP (XCDR (specified_color
)))
4537 if (xstricmp (SDATA (XCDR (specified_color
)), "None") == 0)
4539 else if (x_defined_color (f
, SDATA (XCDR (specified_color
)),
4541 color_val
= make_number (cdef
.pixel
);
4544 if (NILP (color_val
) && max_key
> 0)
4546 if (xstricmp (max_color
, "None") == 0)
4548 else if (x_defined_color (f
, max_color
, &cdef
, 0))
4549 color_val
= make_number (cdef
.pixel
);
4551 if (!NILP (color_val
))
4552 (*put_color_table
) (color_table
, beg
, chars_per_pixel
, color_val
);
4557 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0,
4558 &ximg
, &img
->pixmap
)
4559 || !x_create_x_image_and_pixmap (f
, width
, height
, 1,
4560 &mask_img
, &img
->mask
))
4562 image_error ("Out of memory (%s)", img
->spec
, Qnil
);
4566 for (y
= 0; y
< height
; y
++)
4568 expect (XPM_TK_STRING
);
4570 if (len
< width
* chars_per_pixel
)
4572 for (x
= 0; x
< width
; x
++, str
+= chars_per_pixel
)
4574 Lisp_Object color_val
=
4575 (*get_color_table
) (color_table
, str
, chars_per_pixel
);
4577 XPutPixel (ximg
, x
, y
,
4578 (INTEGERP (color_val
) ? XINT (color_val
)
4579 : FRAME_FOREGROUND_PIXEL (f
)));
4580 XPutPixel (mask_img
, x
, y
,
4581 (!EQ (color_val
, Qt
) ? PIX_MASK_DRAW
4582 : (have_mask
= 1, PIX_MASK_RETAIN
)));
4589 img
->height
= height
;
4591 /* Maybe fill in the background field while we have ximg handy. */
4592 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
4593 IMAGE_BACKGROUND (img
, f
, ximg
);
4595 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
4596 x_destroy_x_image (ximg
);
4599 /* Fill in the background_transparent field while we have the
4601 image_background_transparent (img
, f
, mask_img
);
4603 x_put_x_image (f
, mask_img
, img
->mask
, width
, height
);
4604 x_destroy_x_image (mask_img
);
4608 x_destroy_x_image (mask_img
);
4609 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
4610 img
->mask
= NO_PIXMAP
;
4616 image_error ("Invalid XPM file (%s)", img
->spec
, Qnil
);
4618 x_destroy_x_image (ximg
);
4619 x_destroy_x_image (mask_img
);
4620 x_clear_image (f
, img
);
4634 Lisp_Object file_name
;
4636 /* If IMG->spec specifies a file name, create a non-file spec from it. */
4637 file_name
= image_spec_value (img
->spec
, QCfile
, NULL
);
4638 if (STRINGP (file_name
))
4641 unsigned char *contents
;
4643 struct gcpro gcpro1
;
4645 file
= x_find_image_file (file_name
);
4647 if (!STRINGP (file
))
4649 image_error ("Cannot find image file `%s'", file_name
, Qnil
);
4654 contents
= slurp_file (SDATA (file
), &size
);
4655 if (contents
== NULL
)
4657 image_error ("Error loading XPM image `%s'", img
->spec
, Qnil
);
4662 success_p
= xpm_load_image (f
, img
, contents
, contents
+ size
);
4670 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
4671 success_p
= xpm_load_image (f
, img
, SDATA (data
),
4672 SDATA (data
) + SBYTES (data
));
4682 /***********************************************************************
4684 ***********************************************************************/
4686 #ifdef COLOR_TABLE_SUPPORT
4688 /* An entry in the color table mapping an RGB color to a pixel color. */
4693 unsigned long pixel
;
4695 /* Next in color table collision list. */
4696 struct ct_color
*next
;
4699 /* The bucket vector size to use. Must be prime. */
4703 /* Value is a hash of the RGB color given by R, G, and B. */
4705 #define CT_HASH_RGB(R, G, B) (((R) << 16) ^ ((G) << 8) ^ (B))
4707 /* The color hash table. */
4709 struct ct_color
**ct_table
;
4711 /* Number of entries in the color table. */
4713 int ct_colors_allocated
;
4715 /* Initialize the color table. */
4720 int size
= CT_SIZE
* sizeof (*ct_table
);
4721 ct_table
= (struct ct_color
**) xmalloc (size
);
4722 bzero (ct_table
, size
);
4723 ct_colors_allocated
= 0;
4727 /* Free memory associated with the color table. */
4733 struct ct_color
*p
, *next
;
4735 for (i
= 0; i
< CT_SIZE
; ++i
)
4736 for (p
= ct_table
[i
]; p
; p
= next
)
4747 /* Value is a pixel color for RGB color R, G, B on frame F. If an
4748 entry for that color already is in the color table, return the
4749 pixel color of that entry. Otherwise, allocate a new color for R,
4750 G, B, and make an entry in the color table. */
4752 static unsigned long
4753 lookup_rgb_color (f
, r
, g
, b
)
4757 unsigned hash
= CT_HASH_RGB (r
, g
, b
);
4758 int i
= hash
% CT_SIZE
;
4760 Display_Info
*dpyinfo
;
4762 /* Handle TrueColor visuals specially, which improves performance by
4763 two orders of magnitude. Freeing colors on TrueColor visuals is
4764 a nop, and pixel colors specify RGB values directly. See also
4765 the Xlib spec, chapter 3.1. */
4766 dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
4767 if (dpyinfo
->red_bits
> 0)
4769 unsigned long pr
, pg
, pb
;
4771 /* Apply gamma-correction like normal color allocation does. */
4775 color
.red
= r
, color
.green
= g
, color
.blue
= b
;
4776 gamma_correct (f
, &color
);
4777 r
= color
.red
, g
= color
.green
, b
= color
.blue
;
4780 /* Scale down RGB values to the visual's bits per RGB, and shift
4781 them to the right position in the pixel color. Note that the
4782 original RGB values are 16-bit values, as usual in X. */
4783 pr
= (r
>> (16 - dpyinfo
->red_bits
)) << dpyinfo
->red_offset
;
4784 pg
= (g
>> (16 - dpyinfo
->green_bits
)) << dpyinfo
->green_offset
;
4785 pb
= (b
>> (16 - dpyinfo
->blue_bits
)) << dpyinfo
->blue_offset
;
4787 /* Assemble the pixel color. */
4788 return pr
| pg
| pb
;
4791 for (p
= ct_table
[i
]; p
; p
= p
->next
)
4792 if (p
->r
== r
&& p
->g
== g
&& p
->b
== b
)
4798 #ifdef HAVE_X_WINDOWS
4807 cmap
= FRAME_X_COLORMAP (f
);
4808 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
4811 ++ct_colors_allocated
;
4812 p
= (struct ct_color
*) xmalloc (sizeof *p
);
4816 p
->pixel
= color
.pixel
;
4817 p
->next
= ct_table
[i
];
4821 return FRAME_FOREGROUND_PIXEL (f
);
4826 color
= PALETTERGB (r
, g
, b
);
4828 color
= RGB_TO_ULONG (r
, g
, b
);
4829 #endif /* HAVE_NTGUI */
4830 ++ct_colors_allocated
;
4831 p
= (struct ct_color
*) xmalloc (sizeof *p
);
4836 p
->next
= ct_table
[i
];
4838 #endif /* HAVE_X_WINDOWS */
4846 /* Look up pixel color PIXEL which is used on frame F in the color
4847 table. If not already present, allocate it. Value is PIXEL. */
4849 static unsigned long
4850 lookup_pixel_color (f
, pixel
)
4852 unsigned long pixel
;
4854 int i
= pixel
% CT_SIZE
;
4857 for (p
= ct_table
[i
]; p
; p
= p
->next
)
4858 if (p
->pixel
== pixel
)
4867 #ifdef HAVE_X_WINDOWS
4868 cmap
= FRAME_X_COLORMAP (f
);
4869 color
.pixel
= pixel
;
4870 x_query_color (f
, &color
);
4871 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
4874 cmap
= DefaultColormapOfScreen (FRAME_X_SCREEN (f
));
4875 color
.pixel
= pixel
;
4876 XQueryColor (NULL
, cmap
, &color
);
4877 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
4879 #endif /* HAVE_X_WINDOWS */
4883 ++ct_colors_allocated
;
4885 p
= (struct ct_color
*) xmalloc (sizeof *p
);
4890 p
->next
= ct_table
[i
];
4894 return FRAME_FOREGROUND_PIXEL (f
);
4900 /* Value is a vector of all pixel colors contained in the color table,
4901 allocated via xmalloc. Set *N to the number of colors. */
4903 static unsigned long *
4904 colors_in_color_table (n
)
4909 unsigned long *colors
;
4911 if (ct_colors_allocated
== 0)
4918 colors
= (unsigned long *) xmalloc (ct_colors_allocated
4920 *n
= ct_colors_allocated
;
4922 for (i
= j
= 0; i
< CT_SIZE
; ++i
)
4923 for (p
= ct_table
[i
]; p
; p
= p
->next
)
4924 colors
[j
++] = p
->pixel
;
4930 #else /* COLOR_TABLE_SUPPORT */
4932 static unsigned long
4933 lookup_rgb_color (f
, r
, g
, b
)
4937 unsigned long pixel
;
4940 pixel
= RGB_TO_ULONG (r
>> 8, g
>> 8, b
>> 8);
4941 gamma_correct (f
, &pixel
);
4945 pixel
= PALETTERGB (r
>> 8, g
>> 8, b
>> 8);
4946 #endif /* HAVE_NTGUI */
4955 #endif /* COLOR_TABLE_SUPPORT */
4958 /***********************************************************************
4960 ***********************************************************************/
4962 static XColor
*x_to_xcolors
P_ ((struct frame
*, struct image
*, int));
4963 static void x_from_xcolors
P_ ((struct frame
*, struct image
*, XColor
*));
4964 static void x_detect_edges
P_ ((struct frame
*, struct image
*, int[9], int));
4967 static void XPutPixel (XImagePtr
, int, int, COLORREF
);
4968 #endif /* HAVE_NTGUI */
4970 /* Non-zero means draw a cross on images having `:conversion
4973 int cross_disabled_images
;
4975 /* Edge detection matrices for different edge-detection
4978 static int emboss_matrix
[9] = {
4980 2, -1, 0, /* y - 1 */
4982 0, 1, -2 /* y + 1 */
4985 static int laplace_matrix
[9] = {
4987 1, 0, 0, /* y - 1 */
4989 0, 0, -1 /* y + 1 */
4992 /* Value is the intensity of the color whose red/green/blue values
4995 #define COLOR_INTENSITY(R, G, B) ((2 * (R) + 3 * (G) + (B)) / 6)
4998 /* On frame F, return an array of XColor structures describing image
4999 IMG->pixmap. Each XColor structure has its pixel color set. RGB_P
5000 non-zero means also fill the red/green/blue members of the XColor
5001 structures. Value is a pointer to the array of XColors structures,
5002 allocated with xmalloc; it must be freed by the caller. */
5005 x_to_xcolors (f
, img
, rgb_p
)
5012 XImagePtr_or_DC ximg
;
5016 #endif /* HAVE_NTGUI */
5018 colors
= (XColor
*) xmalloc (img
->width
* img
->height
* sizeof *colors
);
5021 /* Get the X image IMG->pixmap. */
5022 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
5023 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
5025 /* Load the image into a memory device context. */
5026 hdc
= get_frame_dc (f
);
5027 ximg
= CreateCompatibleDC (hdc
);
5028 release_frame_dc (f
, hdc
);
5029 prev
= SelectObject (ximg
, img
->pixmap
);
5030 #endif /* HAVE_NTGUI */
5032 /* Fill the `pixel' members of the XColor array. I wished there
5033 were an easy and portable way to circumvent XGetPixel. */
5035 for (y
= 0; y
< img
->height
; ++y
)
5039 #ifdef HAVE_X_WINDOWS
5040 for (x
= 0; x
< img
->width
; ++x
, ++p
)
5041 p
->pixel
= XGetPixel (ximg
, x
, y
);
5043 x_query_colors (f
, row
, img
->width
);
5047 for (x
= 0; x
< img
->width
; ++x
, ++p
)
5049 /* W32_TODO: palette support needed here? */
5050 p
->pixel
= GET_PIXEL (ximg
, x
, y
);
5054 p
->red
= RED16_FROM_ULONG (p
->pixel
);
5055 p
->green
= GREEN16_FROM_ULONG (p
->pixel
);
5056 p
->blue
= BLUE16_FROM_ULONG (p
->pixel
);
5059 p
->red
= 256 * GetRValue (p
->pixel
);
5060 p
->green
= 256 * GetGValue (p
->pixel
);
5061 p
->blue
= 256 * GetBValue (p
->pixel
);
5062 #endif /* HAVE_NTGUI */
5065 #endif /* HAVE_X_WINDOWS */
5068 Destroy_Image (ximg
, prev
);
5075 /* Put a pixel of COLOR at position X, Y in XIMG. XIMG must have been
5076 created with CreateDIBSection, with the pointer to the bit values
5077 stored in ximg->data. */
5080 XPutPixel (ximg
, x
, y
, color
)
5085 int width
= ximg
->info
.bmiHeader
.biWidth
;
5086 int height
= ximg
->info
.bmiHeader
.biHeight
;
5087 unsigned char * pixel
;
5089 /* True color images. */
5090 if (ximg
->info
.bmiHeader
.biBitCount
== 24)
5092 int rowbytes
= width
* 3;
5093 /* Ensure scanlines are aligned on 4 byte boundaries. */
5095 rowbytes
+= 4 - (rowbytes
% 4);
5097 pixel
= ximg
->data
+ y
* rowbytes
+ x
* 3;
5098 /* Windows bitmaps are in BGR order. */
5099 *pixel
= GetBValue (color
);
5100 *(pixel
+ 1) = GetGValue (color
);
5101 *(pixel
+ 2) = GetRValue (color
);
5103 /* Monochrome images. */
5104 else if (ximg
->info
.bmiHeader
.biBitCount
== 1)
5106 int rowbytes
= width
/ 8;
5107 /* Ensure scanlines are aligned on 4 byte boundaries. */
5109 rowbytes
+= 4 - (rowbytes
% 4);
5110 pixel
= ximg
->data
+ y
* rowbytes
+ x
/ 8;
5111 /* Filter out palette info. */
5112 if (color
& 0x00ffffff)
5113 *pixel
= *pixel
| (1 << x
% 8);
5115 *pixel
= *pixel
& ~(1 << x
% 8);
5118 image_error ("XPutPixel: palette image not supported", Qnil
, Qnil
);
5121 #endif /* HAVE_NTGUI */
5123 /* Create IMG->pixmap from an array COLORS of XColor structures, whose
5124 RGB members are set. F is the frame on which this all happens.
5125 COLORS will be freed; an existing IMG->pixmap will be freed, too. */
5128 x_from_xcolors (f
, img
, colors
)
5138 init_color_table ();
5140 x_create_x_image_and_pixmap (f
, img
->width
, img
->height
, 0,
5143 for (y
= 0; y
< img
->height
; ++y
)
5144 for (x
= 0; x
< img
->width
; ++x
, ++p
)
5146 unsigned long pixel
;
5147 pixel
= lookup_rgb_color (f
, p
->red
, p
->green
, p
->blue
);
5148 XPutPixel (oimg
, x
, y
, pixel
);
5152 x_clear_image_1 (f
, img
, 1, 0, 1);
5154 x_put_x_image (f
, oimg
, pixmap
, img
->width
, img
->height
);
5155 x_destroy_x_image (oimg
);
5156 img
->pixmap
= pixmap
;
5157 #ifdef COLOR_TABLE_SUPPORT
5158 img
->colors
= colors_in_color_table (&img
->ncolors
);
5159 free_color_table ();
5160 #endif /* COLOR_TABLE_SUPPORT */
5164 /* On frame F, perform edge-detection on image IMG.
5166 MATRIX is a nine-element array specifying the transformation
5167 matrix. See emboss_matrix for an example.
5169 COLOR_ADJUST is a color adjustment added to each pixel of the
5173 x_detect_edges (f
, img
, matrix
, color_adjust
)
5176 int matrix
[9], color_adjust
;
5178 XColor
*colors
= x_to_xcolors (f
, img
, 1);
5182 for (i
= sum
= 0; i
< 9; ++i
)
5183 sum
+= eabs (matrix
[i
]);
5185 #define COLOR(A, X, Y) ((A) + (Y) * img->width + (X))
5187 new = (XColor
*) xmalloc (img
->width
* img
->height
* sizeof *new);
5189 for (y
= 0; y
< img
->height
; ++y
)
5191 p
= COLOR (new, 0, y
);
5192 p
->red
= p
->green
= p
->blue
= 0xffff/2;
5193 p
= COLOR (new, img
->width
- 1, y
);
5194 p
->red
= p
->green
= p
->blue
= 0xffff/2;
5197 for (x
= 1; x
< img
->width
- 1; ++x
)
5199 p
= COLOR (new, x
, 0);
5200 p
->red
= p
->green
= p
->blue
= 0xffff/2;
5201 p
= COLOR (new, x
, img
->height
- 1);
5202 p
->red
= p
->green
= p
->blue
= 0xffff/2;
5205 for (y
= 1; y
< img
->height
- 1; ++y
)
5207 p
= COLOR (new, 1, y
);
5209 for (x
= 1; x
< img
->width
- 1; ++x
, ++p
)
5211 int r
, g
, b
, y1
, x1
;
5214 for (y1
= y
- 1; y1
< y
+ 2; ++y1
)
5215 for (x1
= x
- 1; x1
< x
+ 2; ++x1
, ++i
)
5218 XColor
*t
= COLOR (colors
, x1
, y1
);
5219 r
+= matrix
[i
] * t
->red
;
5220 g
+= matrix
[i
] * t
->green
;
5221 b
+= matrix
[i
] * t
->blue
;
5224 r
= (r
/ sum
+ color_adjust
) & 0xffff;
5225 g
= (g
/ sum
+ color_adjust
) & 0xffff;
5226 b
= (b
/ sum
+ color_adjust
) & 0xffff;
5227 p
->red
= p
->green
= p
->blue
= COLOR_INTENSITY (r
, g
, b
);
5232 x_from_xcolors (f
, img
, new);
5238 /* Perform the pre-defined `emboss' edge-detection on image IMG
5246 x_detect_edges (f
, img
, emboss_matrix
, 0xffff / 2);
5250 /* Transform image IMG which is used on frame F with a Laplace
5251 edge-detection algorithm. The result is an image that can be used
5252 to draw disabled buttons, for example. */
5259 x_detect_edges (f
, img
, laplace_matrix
, 45000);
5263 /* Perform edge-detection on image IMG on frame F, with specified
5264 transformation matrix MATRIX and color-adjustment COLOR_ADJUST.
5266 MATRIX must be either
5268 - a list of at least 9 numbers in row-major form
5269 - a vector of at least 9 numbers
5271 COLOR_ADJUST nil means use a default; otherwise it must be a
5275 x_edge_detection (f
, img
, matrix
, color_adjust
)
5278 Lisp_Object matrix
, color_adjust
;
5286 i
< 9 && CONSP (matrix
) && NUMBERP (XCAR (matrix
));
5287 ++i
, matrix
= XCDR (matrix
))
5288 trans
[i
] = XFLOATINT (XCAR (matrix
));
5290 else if (VECTORP (matrix
) && ASIZE (matrix
) >= 9)
5292 for (i
= 0; i
< 9 && NUMBERP (AREF (matrix
, i
)); ++i
)
5293 trans
[i
] = XFLOATINT (AREF (matrix
, i
));
5296 if (NILP (color_adjust
))
5297 color_adjust
= make_number (0xffff / 2);
5299 if (i
== 9 && NUMBERP (color_adjust
))
5300 x_detect_edges (f
, img
, trans
, (int) XFLOATINT (color_adjust
));
5304 /* Transform image IMG on frame F so that it looks disabled. */
5307 x_disable_image (f
, img
)
5311 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
5313 int n_planes
= dpyinfo
->n_planes
* dpyinfo
->n_cbits
;
5315 int n_planes
= dpyinfo
->n_planes
;
5316 #endif /* HAVE_NTGUI */
5320 /* Color (or grayscale). Convert to gray, and equalize. Just
5321 drawing such images with a stipple can look very odd, so
5322 we're using this method instead. */
5323 XColor
*colors
= x_to_xcolors (f
, img
, 1);
5325 const int h
= 15000;
5326 const int l
= 30000;
5328 for (p
= colors
, end
= colors
+ img
->width
* img
->height
;
5332 int i
= COLOR_INTENSITY (p
->red
, p
->green
, p
->blue
);
5333 int i2
= (0xffff - h
- l
) * i
/ 0xffff + l
;
5334 p
->red
= p
->green
= p
->blue
= i2
;
5337 x_from_xcolors (f
, img
, colors
);
5340 /* Draw a cross over the disabled image, if we must or if we
5342 if (n_planes
< 2 || cross_disabled_images
)
5345 Display
*dpy
= FRAME_X_DISPLAY (f
);
5349 #define MaskForeground(f) PIX_MASK_DRAW
5351 #define MaskForeground(f) WHITE_PIX_DEFAULT (f)
5354 gc
= XCreateGC (dpy
, img
->pixmap
, 0, NULL
);
5355 XSetForeground (dpy
, gc
, BLACK_PIX_DEFAULT (f
));
5356 XDrawLine (dpy
, img
->pixmap
, gc
, 0, 0,
5357 img
->width
- 1, img
->height
- 1);
5358 XDrawLine (dpy
, img
->pixmap
, gc
, 0, img
->height
- 1,
5364 gc
= XCreateGC (dpy
, img
->mask
, 0, NULL
);
5365 XSetForeground (dpy
, gc
, MaskForeground (f
));
5366 XDrawLine (dpy
, img
->mask
, gc
, 0, 0,
5367 img
->width
- 1, img
->height
- 1);
5368 XDrawLine (dpy
, img
->mask
, gc
, 0, img
->height
- 1,
5376 hdc
= get_frame_dc (f
);
5377 bmpdc
= CreateCompatibleDC (hdc
);
5378 release_frame_dc (f
, hdc
);
5380 prev
= SelectObject (bmpdc
, img
->pixmap
);
5382 SetTextColor (bmpdc
, BLACK_PIX_DEFAULT (f
));
5383 MoveToEx (bmpdc
, 0, 0, NULL
);
5384 LineTo (bmpdc
, img
->width
- 1, img
->height
- 1);
5385 MoveToEx (bmpdc
, 0, img
->height
- 1, NULL
);
5386 LineTo (bmpdc
, img
->width
- 1, 0);
5390 SelectObject (bmpdc
, img
->mask
);
5391 SetTextColor (bmpdc
, WHITE_PIX_DEFAULT (f
));
5392 MoveToEx (bmpdc
, 0, 0, NULL
);
5393 LineTo (bmpdc
, img
->width
- 1, img
->height
- 1);
5394 MoveToEx (bmpdc
, 0, img
->height
- 1, NULL
);
5395 LineTo (bmpdc
, img
->width
- 1, 0);
5397 SelectObject (bmpdc
, prev
);
5399 #endif /* HAVE_NTGUI */
5404 /* Build a mask for image IMG which is used on frame F. FILE is the
5405 name of an image file, for error messages. HOW determines how to
5406 determine the background color of IMG. If it is a list '(R G B)',
5407 with R, G, and B being integers >= 0, take that as the color of the
5408 background. Otherwise, determine the background color of IMG
5409 heuristically. Value is non-zero if successful. */
5412 x_build_heuristic_mask (f
, img
, how
)
5417 XImagePtr_or_DC ximg
;
5425 #endif /* HAVE_NTGUI */
5426 int x
, y
, rc
, use_img_background
;
5427 unsigned long bg
= 0;
5431 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
5432 img
->mask
= NO_PIXMAP
;
5433 img
->background_transparent_valid
= 0;
5437 /* Create an image and pixmap serving as mask. */
5438 rc
= x_create_x_image_and_pixmap (f
, img
->width
, img
->height
, 1,
5439 &mask_img
, &img
->mask
);
5443 /* Get the X image of IMG->pixmap. */
5444 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
, 0, 0,
5445 img
->width
, img
->height
,
5448 /* Create the bit array serving as mask. */
5449 row_width
= (img
->width
+ 7) / 8;
5450 mask_img
= xmalloc (row_width
* img
->height
);
5451 bzero (mask_img
, row_width
* img
->height
);
5453 /* Create a memory device context for IMG->pixmap. */
5454 frame_dc
= get_frame_dc (f
);
5455 ximg
= CreateCompatibleDC (frame_dc
);
5456 release_frame_dc (f
, frame_dc
);
5457 prev
= SelectObject (ximg
, img
->pixmap
);
5458 #endif /* HAVE_NTGUI */
5460 /* Determine the background color of ximg. If HOW is `(R G B)'
5461 take that as color. Otherwise, use the image's background color. */
5462 use_img_background
= 1;
5468 for (i
= 0; i
< 3 && CONSP (how
) && NATNUMP (XCAR (how
)); ++i
)
5470 rgb
[i
] = XFASTINT (XCAR (how
)) & 0xffff;
5474 if (i
== 3 && NILP (how
))
5476 char color_name
[30];
5477 sprintf (color_name
, "#%04x%04x%04x", rgb
[0], rgb
[1], rgb
[2]);
5480 0x00ffffff & /* Filter out palette info. */
5481 #endif /* HAVE_NTGUI */
5482 x_alloc_image_color (f
, img
, build_string (color_name
), 0));
5483 use_img_background
= 0;
5487 if (use_img_background
)
5488 bg
= four_corners_best (ximg
, img
->corners
, img
->width
, img
->height
);
5490 /* Set all bits in mask_img to 1 whose color in ximg is different
5491 from the background color bg. */
5493 for (y
= 0; y
< img
->height
; ++y
)
5494 for (x
= 0; x
< img
->width
; ++x
)
5495 XPutPixel (mask_img
, x
, y
, (XGetPixel (ximg
, x
, y
) != bg
5496 ? PIX_MASK_DRAW
: PIX_MASK_RETAIN
));
5498 /* Fill in the background_transparent field while we have the mask handy. */
5499 image_background_transparent (img
, f
, mask_img
);
5501 /* Put mask_img into img->mask. */
5502 x_put_x_image (f
, mask_img
, img
->mask
, img
->width
, img
->height
);
5503 x_destroy_x_image (mask_img
);
5506 for (y
= 0; y
< img
->height
; ++y
)
5507 for (x
= 0; x
< img
->width
; ++x
)
5509 COLORREF p
= GetPixel (ximg
, x
, y
);
5511 mask_img
[y
* row_width
+ x
/ 8] |= 1 << (x
% 8);
5514 /* Create the mask image. */
5515 img
->mask
= w32_create_pixmap_from_bitmap_data (img
->width
, img
->height
,
5517 /* Fill in the background_transparent field while we have the mask handy. */
5518 SelectObject (ximg
, img
->mask
);
5519 image_background_transparent (img
, f
, ximg
);
5521 /* Was: x_destroy_x_image ((XImagePtr )mask_img); which seems bogus ++kfs */
5523 #endif /* HAVE_NTGUI */
5525 Destroy_Image (ximg
, prev
);
5531 /***********************************************************************
5532 PBM (mono, gray, color)
5533 ***********************************************************************/
5535 static int pbm_image_p
P_ ((Lisp_Object object
));
5536 static int pbm_load
P_ ((struct frame
*f
, struct image
*img
));
5537 static int pbm_scan_number
P_ ((unsigned char **, unsigned char *));
5539 /* The symbol `pbm' identifying images of this type. */
5543 /* Indices of image specification fields in gs_format, below. */
5545 enum pbm_keyword_index
5561 /* Vector of image_keyword structures describing the format
5562 of valid user-defined image specifications. */
5564 static struct image_keyword pbm_format
[PBM_LAST
] =
5566 {":type", IMAGE_SYMBOL_VALUE
, 1},
5567 {":file", IMAGE_STRING_VALUE
, 0},
5568 {":data", IMAGE_STRING_VALUE
, 0},
5569 {":ascent", IMAGE_ASCENT_VALUE
, 0},
5570 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
5571 {":relief", IMAGE_INTEGER_VALUE
, 0},
5572 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5573 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5574 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5575 {":foreground", IMAGE_STRING_OR_NIL_VALUE
, 0},
5576 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
5579 /* Structure describing the image type `pbm'. */
5581 static struct image_type pbm_type
=
5591 /* Return non-zero if OBJECT is a valid PBM image specification. */
5594 pbm_image_p (object
)
5597 struct image_keyword fmt
[PBM_LAST
];
5599 bcopy (pbm_format
, fmt
, sizeof fmt
);
5601 if (!parse_image_spec (object
, fmt
, PBM_LAST
, Qpbm
))
5604 /* Must specify either :data or :file. */
5605 return fmt
[PBM_DATA
].count
+ fmt
[PBM_FILE
].count
== 1;
5609 /* Scan a decimal number from *S and return it. Advance *S while
5610 reading the number. END is the end of the string. Value is -1 at
5614 pbm_scan_number (s
, end
)
5615 unsigned char **s
, *end
;
5617 int c
= 0, val
= -1;
5621 /* Skip white-space. */
5622 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
5627 /* Skip comment to end of line. */
5628 while (*s
< end
&& (c
= *(*s
)++, c
!= '\n'))
5631 else if (isdigit (c
))
5633 /* Read decimal number. */
5635 while (*s
< end
&& (c
= *(*s
)++, isdigit (c
)))
5636 val
= 10 * val
+ c
- '0';
5648 #if 0 /* Unused. ++kfs */
5650 /* Read FILE into memory. Value is a pointer to a buffer allocated
5651 with xmalloc holding FILE's contents. Value is null if an error
5652 occurred. *SIZE is set to the size of the file. */
5655 pbm_read_file (file
, size
)
5663 if (stat (SDATA (file
), &st
) == 0
5664 && (fp
= fopen (SDATA (file
), "rb")) != NULL
5665 && (buf
= (char *) xmalloc (st
.st_size
),
5666 fread (buf
, 1, st
.st_size
, fp
) == st
.st_size
))
5685 #endif /* HAVE_NTGUI */
5687 /* Load PBM image IMG for use on frame F. */
5695 int width
, height
, max_color_idx
= 0;
5697 Lisp_Object file
, specified_file
;
5698 enum {PBM_MONO
, PBM_GRAY
, PBM_COLOR
} type
;
5699 struct gcpro gcpro1
;
5700 unsigned char *contents
= NULL
;
5701 unsigned char *end
, *p
;
5704 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
5708 if (STRINGP (specified_file
))
5710 file
= x_find_image_file (specified_file
);
5711 if (!STRINGP (file
))
5713 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
5718 contents
= slurp_file (SDATA (file
), &size
);
5719 if (contents
== NULL
)
5721 image_error ("Error reading `%s'", file
, Qnil
);
5727 end
= contents
+ size
;
5732 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
5734 end
= p
+ SBYTES (data
);
5737 /* Check magic number. */
5738 if (end
- p
< 2 || *p
++ != 'P')
5740 image_error ("Not a PBM image: `%s'", img
->spec
, Qnil
);
5750 raw_p
= 0, type
= PBM_MONO
;
5754 raw_p
= 0, type
= PBM_GRAY
;
5758 raw_p
= 0, type
= PBM_COLOR
;
5762 raw_p
= 1, type
= PBM_MONO
;
5766 raw_p
= 1, type
= PBM_GRAY
;
5770 raw_p
= 1, type
= PBM_COLOR
;
5774 image_error ("Not a PBM image: `%s'", img
->spec
, Qnil
);
5778 /* Read width, height, maximum color-component. Characters
5779 starting with `#' up to the end of a line are ignored. */
5780 width
= pbm_scan_number (&p
, end
);
5781 height
= pbm_scan_number (&p
, end
);
5783 if (type
!= PBM_MONO
)
5785 max_color_idx
= pbm_scan_number (&p
, end
);
5786 if (raw_p
&& max_color_idx
> 255)
5787 max_color_idx
= 255;
5790 if (!check_image_size (f
, width
, height
)
5791 || (type
!= PBM_MONO
&& max_color_idx
< 0))
5794 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0,
5795 &ximg
, &img
->pixmap
))
5798 /* Initialize the color hash table. */
5799 init_color_table ();
5801 if (type
== PBM_MONO
)
5804 struct image_keyword fmt
[PBM_LAST
];
5805 unsigned long fg
= FRAME_FOREGROUND_PIXEL (f
);
5806 unsigned long bg
= FRAME_BACKGROUND_PIXEL (f
);
5808 /* Parse the image specification. */
5809 bcopy (pbm_format
, fmt
, sizeof fmt
);
5810 parse_image_spec (img
->spec
, fmt
, PBM_LAST
, Qpbm
);
5812 /* Get foreground and background colors, maybe allocate colors. */
5813 if (fmt
[PBM_FOREGROUND
].count
5814 && STRINGP (fmt
[PBM_FOREGROUND
].value
))
5815 fg
= x_alloc_image_color (f
, img
, fmt
[PBM_FOREGROUND
].value
, fg
);
5816 if (fmt
[PBM_BACKGROUND
].count
5817 && STRINGP (fmt
[PBM_BACKGROUND
].value
))
5819 bg
= x_alloc_image_color (f
, img
, fmt
[PBM_BACKGROUND
].value
, bg
);
5820 img
->background
= bg
;
5821 img
->background_valid
= 1;
5824 for (y
= 0; y
< height
; ++y
)
5825 for (x
= 0; x
< width
; ++x
)
5833 x_destroy_x_image (ximg
);
5834 x_clear_image (f
, img
);
5835 image_error ("Invalid image size in image `%s'",
5845 g
= pbm_scan_number (&p
, end
);
5847 XPutPixel (ximg
, x
, y
, g
? fg
: bg
);
5853 && ((type
== PBM_GRAY
)
5854 ? (p
+ height
* width
> end
)
5855 : (p
+ 3 * height
* width
> end
)))
5857 x_destroy_x_image (ximg
);
5858 x_clear_image (f
, img
);
5859 image_error ("Invalid image size in image `%s'",
5864 for (y
= 0; y
< height
; ++y
)
5865 for (x
= 0; x
< width
; ++x
)
5869 if (type
== PBM_GRAY
)
5870 r
= g
= b
= raw_p
? *p
++ : pbm_scan_number (&p
, end
);
5879 r
= pbm_scan_number (&p
, end
);
5880 g
= pbm_scan_number (&p
, end
);
5881 b
= pbm_scan_number (&p
, end
);
5884 if (r
< 0 || g
< 0 || b
< 0)
5886 x_destroy_x_image (ximg
);
5887 image_error ("Invalid pixel value in image `%s'",
5892 /* RGB values are now in the range 0..max_color_idx.
5893 Scale this to the range 0..0xffff supported by X. */
5894 r
= (double) r
* 65535 / max_color_idx
;
5895 g
= (double) g
* 65535 / max_color_idx
;
5896 b
= (double) b
* 65535 / max_color_idx
;
5897 XPutPixel (ximg
, x
, y
, lookup_rgb_color (f
, r
, g
, b
));
5901 #ifdef COLOR_TABLE_SUPPORT
5902 /* Store in IMG->colors the colors allocated for the image, and
5903 free the color table. */
5904 img
->colors
= colors_in_color_table (&img
->ncolors
);
5905 free_color_table ();
5906 #endif /* COLOR_TABLE_SUPPORT */
5909 img
->height
= height
;
5911 /* Maybe fill in the background field while we have ximg handy. */
5913 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
5914 /* Casting avoids a GCC warning. */
5915 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
5917 /* Put the image into a pixmap. */
5918 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
5919 x_destroy_x_image (ximg
);
5921 /* X and W32 versions did it here, MAC version above. ++kfs
5923 img->height = height; */
5931 /***********************************************************************
5933 ***********************************************************************/
5935 #if defined (HAVE_PNG) || defined (MAC_OS)
5937 /* Function prototypes. */
5939 static int png_image_p
P_ ((Lisp_Object object
));
5940 static int png_load
P_ ((struct frame
*f
, struct image
*img
));
5942 /* The symbol `png' identifying images of this type. */
5946 /* Indices of image specification fields in png_format, below. */
5948 enum png_keyword_index
5963 /* Vector of image_keyword structures describing the format
5964 of valid user-defined image specifications. */
5966 static struct image_keyword png_format
[PNG_LAST
] =
5968 {":type", IMAGE_SYMBOL_VALUE
, 1},
5969 {":data", IMAGE_STRING_VALUE
, 0},
5970 {":file", IMAGE_STRING_VALUE
, 0},
5971 {":ascent", IMAGE_ASCENT_VALUE
, 0},
5972 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
5973 {":relief", IMAGE_INTEGER_VALUE
, 0},
5974 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5975 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5976 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5977 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
5980 /* Structure describing the image type `png'. */
5982 static struct image_type png_type
=
5991 /* Return non-zero if OBJECT is a valid PNG image specification. */
5994 png_image_p (object
)
5997 struct image_keyword fmt
[PNG_LAST
];
5998 bcopy (png_format
, fmt
, sizeof fmt
);
6000 if (!parse_image_spec (object
, fmt
, PNG_LAST
, Qpng
))
6003 /* Must specify either the :data or :file keyword. */
6004 return fmt
[PNG_FILE
].count
+ fmt
[PNG_DATA
].count
== 1;
6007 #endif /* HAVE_PNG || MAC_OS */
6012 #if defined HAVE_LIBPNG_PNG_H
6013 # include <libpng/png.h>
6019 /* PNG library details. */
6021 DEF_IMGLIB_FN (png_get_io_ptr
);
6022 DEF_IMGLIB_FN (png_check_sig
);
6023 DEF_IMGLIB_FN (png_create_read_struct
);
6024 DEF_IMGLIB_FN (png_create_info_struct
);
6025 DEF_IMGLIB_FN (png_destroy_read_struct
);
6026 DEF_IMGLIB_FN (png_set_read_fn
);
6027 DEF_IMGLIB_FN (png_set_sig_bytes
);
6028 DEF_IMGLIB_FN (png_read_info
);
6029 DEF_IMGLIB_FN (png_get_IHDR
);
6030 DEF_IMGLIB_FN (png_get_valid
);
6031 DEF_IMGLIB_FN (png_set_strip_16
);
6032 DEF_IMGLIB_FN (png_set_expand
);
6033 DEF_IMGLIB_FN (png_set_gray_to_rgb
);
6034 DEF_IMGLIB_FN (png_set_background
);
6035 DEF_IMGLIB_FN (png_get_bKGD
);
6036 DEF_IMGLIB_FN (png_read_update_info
);
6037 DEF_IMGLIB_FN (png_get_channels
);
6038 DEF_IMGLIB_FN (png_get_rowbytes
);
6039 DEF_IMGLIB_FN (png_read_image
);
6040 DEF_IMGLIB_FN (png_read_end
);
6041 DEF_IMGLIB_FN (png_error
);
6044 init_png_functions (Lisp_Object libraries
)
6048 /* Try loading libpng under probable names. */
6049 if (!(library
= w32_delayed_load (libraries
, Qpng
)))
6052 LOAD_IMGLIB_FN (library
, png_get_io_ptr
);
6053 LOAD_IMGLIB_FN (library
, png_check_sig
);
6054 LOAD_IMGLIB_FN (library
, png_create_read_struct
);
6055 LOAD_IMGLIB_FN (library
, png_create_info_struct
);
6056 LOAD_IMGLIB_FN (library
, png_destroy_read_struct
);
6057 LOAD_IMGLIB_FN (library
, png_set_read_fn
);
6058 LOAD_IMGLIB_FN (library
, png_set_sig_bytes
);
6059 LOAD_IMGLIB_FN (library
, png_read_info
);
6060 LOAD_IMGLIB_FN (library
, png_get_IHDR
);
6061 LOAD_IMGLIB_FN (library
, png_get_valid
);
6062 LOAD_IMGLIB_FN (library
, png_set_strip_16
);
6063 LOAD_IMGLIB_FN (library
, png_set_expand
);
6064 LOAD_IMGLIB_FN (library
, png_set_gray_to_rgb
);
6065 LOAD_IMGLIB_FN (library
, png_set_background
);
6066 LOAD_IMGLIB_FN (library
, png_get_bKGD
);
6067 LOAD_IMGLIB_FN (library
, png_read_update_info
);
6068 LOAD_IMGLIB_FN (library
, png_get_channels
);
6069 LOAD_IMGLIB_FN (library
, png_get_rowbytes
);
6070 LOAD_IMGLIB_FN (library
, png_read_image
);
6071 LOAD_IMGLIB_FN (library
, png_read_end
);
6072 LOAD_IMGLIB_FN (library
, png_error
);
6077 #define fn_png_get_io_ptr png_get_io_ptr
6078 #define fn_png_check_sig png_check_sig
6079 #define fn_png_create_read_struct png_create_read_struct
6080 #define fn_png_create_info_struct png_create_info_struct
6081 #define fn_png_destroy_read_struct png_destroy_read_struct
6082 #define fn_png_set_read_fn png_set_read_fn
6083 #define fn_png_set_sig_bytes png_set_sig_bytes
6084 #define fn_png_read_info png_read_info
6085 #define fn_png_get_IHDR png_get_IHDR
6086 #define fn_png_get_valid png_get_valid
6087 #define fn_png_set_strip_16 png_set_strip_16
6088 #define fn_png_set_expand png_set_expand
6089 #define fn_png_set_gray_to_rgb png_set_gray_to_rgb
6090 #define fn_png_set_background png_set_background
6091 #define fn_png_get_bKGD png_get_bKGD
6092 #define fn_png_read_update_info png_read_update_info
6093 #define fn_png_get_channels png_get_channels
6094 #define fn_png_get_rowbytes png_get_rowbytes
6095 #define fn_png_read_image png_read_image
6096 #define fn_png_read_end png_read_end
6097 #define fn_png_error png_error
6099 #endif /* HAVE_NTGUI */
6101 /* Error and warning handlers installed when the PNG library
6105 my_png_error (png_ptr
, msg
)
6106 png_struct
*png_ptr
;
6109 xassert (png_ptr
!= NULL
);
6110 image_error ("PNG error: %s", build_string (msg
), Qnil
);
6111 longjmp (png_ptr
->jmpbuf
, 1);
6116 my_png_warning (png_ptr
, msg
)
6117 png_struct
*png_ptr
;
6120 xassert (png_ptr
!= NULL
);
6121 image_error ("PNG warning: %s", build_string (msg
), Qnil
);
6124 /* Memory source for PNG decoding. */
6126 struct png_memory_storage
6128 unsigned char *bytes
; /* The data */
6129 size_t len
; /* How big is it? */
6130 int index
; /* Where are we? */
6134 /* Function set as reader function when reading PNG image from memory.
6135 PNG_PTR is a pointer to the PNG control structure. Copy LENGTH
6136 bytes from the input to DATA. */
6139 png_read_from_memory (png_ptr
, data
, length
)
6140 png_structp png_ptr
;
6144 struct png_memory_storage
*tbr
6145 = (struct png_memory_storage
*) fn_png_get_io_ptr (png_ptr
);
6147 if (length
> tbr
->len
- tbr
->index
)
6148 fn_png_error (png_ptr
, "Read error");
6150 bcopy (tbr
->bytes
+ tbr
->index
, data
, length
);
6151 tbr
->index
= tbr
->index
+ length
;
6155 /* Function set as reader function when reading PNG image from a file.
6156 PNG_PTR is a pointer to the PNG control structure. Copy LENGTH
6157 bytes from the input to DATA. */
6160 png_read_from_file (png_ptr
, data
, length
)
6161 png_structp png_ptr
;
6165 FILE *fp
= (FILE *) fn_png_get_io_ptr (png_ptr
);
6167 if (fread (data
, 1, length
, fp
) < length
)
6168 fn_png_error (png_ptr
, "Read error");
6172 /* Load PNG image IMG for use on frame F. Value is non-zero if
6180 Lisp_Object file
, specified_file
;
6181 Lisp_Object specified_data
;
6183 XImagePtr ximg
, mask_img
= NULL
;
6184 struct gcpro gcpro1
;
6185 png_struct
*png_ptr
= NULL
;
6186 png_info
*info_ptr
= NULL
, *end_info
= NULL
;
6187 FILE *volatile fp
= NULL
;
6189 png_byte
* volatile pixels
= NULL
;
6190 png_byte
** volatile rows
= NULL
;
6191 png_uint_32 width
, height
;
6192 int bit_depth
, color_type
, interlace_type
;
6194 png_uint_32 row_bytes
;
6196 double screen_gamma
;
6197 struct png_memory_storage tbr
; /* Data to be read */
6199 /* Find out what file to load. */
6200 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
6201 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
6205 if (NILP (specified_data
))
6207 file
= x_find_image_file (specified_file
);
6208 if (!STRINGP (file
))
6210 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
6215 /* Open the image file. */
6216 fp
= fopen (SDATA (file
), "rb");
6219 image_error ("Cannot open image file `%s'", file
, Qnil
);
6224 /* Check PNG signature. */
6225 if (fread (sig
, 1, sizeof sig
, fp
) != sizeof sig
6226 || !fn_png_check_sig (sig
, sizeof sig
))
6228 image_error ("Not a PNG file: `%s'", file
, Qnil
);
6236 /* Read from memory. */
6237 tbr
.bytes
= SDATA (specified_data
);
6238 tbr
.len
= SBYTES (specified_data
);
6241 /* Check PNG signature. */
6242 if (tbr
.len
< sizeof sig
6243 || !fn_png_check_sig (tbr
.bytes
, sizeof sig
))
6245 image_error ("Not a PNG image: `%s'", img
->spec
, Qnil
);
6250 /* Need to skip past the signature. */
6251 tbr
.bytes
+= sizeof (sig
);
6254 /* Initialize read and info structs for PNG lib. Casting return
6255 value avoids a GCC warning on W32. */
6256 png_ptr
= (png_structp
)fn_png_create_read_struct (PNG_LIBPNG_VER_STRING
,
6261 if (fp
) fclose (fp
);
6266 /* Casting return value avoids a GCC warning on W32. */
6267 info_ptr
= (png_infop
)fn_png_create_info_struct (png_ptr
);
6270 fn_png_destroy_read_struct (&png_ptr
, NULL
, NULL
);
6271 if (fp
) fclose (fp
);
6276 /* Casting return value avoids a GCC warning on W32. */
6277 end_info
= (png_infop
)fn_png_create_info_struct (png_ptr
);
6280 fn_png_destroy_read_struct (&png_ptr
, &info_ptr
, NULL
);
6281 if (fp
) fclose (fp
);
6286 /* Set error jump-back. We come back here when the PNG library
6287 detects an error. */
6288 if (setjmp (png_ptr
->jmpbuf
))
6292 fn_png_destroy_read_struct (&png_ptr
, &info_ptr
, &end_info
);
6295 if (fp
) fclose (fp
);
6300 /* Read image info. */
6301 if (!NILP (specified_data
))
6302 fn_png_set_read_fn (png_ptr
, (void *) &tbr
, png_read_from_memory
);
6304 fn_png_set_read_fn (png_ptr
, (void *) fp
, png_read_from_file
);
6306 fn_png_set_sig_bytes (png_ptr
, sizeof sig
);
6307 fn_png_read_info (png_ptr
, info_ptr
);
6308 fn_png_get_IHDR (png_ptr
, info_ptr
, &width
, &height
, &bit_depth
, &color_type
,
6309 &interlace_type
, NULL
, NULL
);
6311 if (!check_image_size (f
, width
, height
))
6314 /* If image contains simply transparency data, we prefer to
6315 construct a clipping mask. */
6316 if (fn_png_get_valid (png_ptr
, info_ptr
, PNG_INFO_tRNS
))
6321 /* This function is easier to write if we only have to handle
6322 one data format: RGB or RGBA with 8 bits per channel. Let's
6323 transform other formats into that format. */
6325 /* Strip more than 8 bits per channel. */
6326 if (bit_depth
== 16)
6327 fn_png_set_strip_16 (png_ptr
);
6329 /* Expand data to 24 bit RGB, or 8 bit grayscale, with alpha channel
6331 fn_png_set_expand (png_ptr
);
6333 /* Convert grayscale images to RGB. */
6334 if (color_type
== PNG_COLOR_TYPE_GRAY
6335 || color_type
== PNG_COLOR_TYPE_GRAY_ALPHA
)
6336 fn_png_set_gray_to_rgb (png_ptr
);
6338 screen_gamma
= (f
->gamma
? 1 / f
->gamma
/ 0.45455 : 2.2);
6340 #if 0 /* Avoid double gamma correction for PNG images. */
6341 { /* Tell the PNG lib to handle gamma correction for us. */
6344 #if defined(PNG_READ_sRGB_SUPPORTED) || defined(PNG_WRITE_sRGB_SUPPORTED)
6345 if (png_get_sRGB (png_ptr
, info_ptr
, &intent
))
6346 /* The libpng documentation says this is right in this case. */
6347 png_set_gamma (png_ptr
, screen_gamma
, 0.45455);
6350 if (png_get_gAMA (png_ptr
, info_ptr
, &image_gamma
))
6351 /* Image contains gamma information. */
6352 png_set_gamma (png_ptr
, screen_gamma
, image_gamma
);
6354 /* Use the standard default for the image gamma. */
6355 png_set_gamma (png_ptr
, screen_gamma
, 0.45455);
6359 /* Handle alpha channel by combining the image with a background
6360 color. Do this only if a real alpha channel is supplied. For
6361 simple transparency, we prefer a clipping mask. */
6364 /* png_color_16 *image_bg; */
6365 Lisp_Object specified_bg
6366 = image_spec_value (img
->spec
, QCbackground
, NULL
);
6368 if (STRINGP (specified_bg
))
6369 /* The user specified `:background', use that. */
6371 /* W32 version incorrectly used COLORREF here!! ++kfs */
6373 if (x_defined_color (f
, SDATA (specified_bg
), &color
, 0))
6375 png_color_16 user_bg
;
6377 bzero (&user_bg
, sizeof user_bg
);
6378 user_bg
.red
= color
.red
>> 8;
6379 user_bg
.green
= color
.green
>> 8;
6380 user_bg
.blue
= color
.blue
>> 8;
6382 fn_png_set_background (png_ptr
, &user_bg
,
6383 PNG_BACKGROUND_GAMMA_SCREEN
, 0, 1.0);
6386 /* The commented-out code checked if the png specifies a default
6387 background color, and uses that. Since we use the current
6388 frame background, it is OK for us to ignore this.
6390 else if (fn_png_get_bKGD (png_ptr, info_ptr, &image_bg))
6391 fn_png_set_background (png_ptr, image_bg,
6392 PNG_BACKGROUND_GAMMA_FILE, 1, 1.0);
6396 /* Image does not contain a background color with which
6397 to combine the image data via an alpha channel. Use
6398 the frame's background instead. */
6399 #ifdef HAVE_X_WINDOWS
6401 png_color_16 frame_background
;
6403 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
6404 x_query_color (f
, &color
);
6406 bzero (&frame_background
, sizeof frame_background
);
6407 frame_background
.red
= color
.red
>> 8;
6408 frame_background
.green
= color
.green
>> 8;
6409 frame_background
.blue
= color
.blue
>> 8;
6410 #endif /* HAVE_X_WINDOWS */
6414 png_color_16 frame_background
;
6415 color
= FRAME_BACKGROUND_PIXEL (f
);
6416 #if 0 /* W32 TODO : Colormap support. */
6417 x_query_color (f
, &color
);
6419 bzero (&frame_background
, sizeof frame_background
);
6420 frame_background
.red
= GetRValue (color
);
6421 frame_background
.green
= GetGValue (color
);
6422 frame_background
.blue
= GetBValue (color
);
6423 #endif /* HAVE_NTGUI */
6426 unsigned long color
;
6427 png_color_16 frame_background
;
6428 color
= FRAME_BACKGROUND_PIXEL (f
);
6429 #if 0 /* MAC/W32 TODO : Colormap support. */
6430 x_query_color (f
, &color
);
6432 bzero (&frame_background
, sizeof frame_background
);
6433 frame_background
.red
= RED_FROM_ULONG (color
);
6434 frame_background
.green
= GREEN_FROM_ULONG (color
);
6435 frame_background
.blue
= BLUE_FROM_ULONG (color
);
6438 fn_png_set_background (png_ptr
, &frame_background
,
6439 PNG_BACKGROUND_GAMMA_SCREEN
, 0, 1.0);
6443 /* Update info structure. */
6444 fn_png_read_update_info (png_ptr
, info_ptr
);
6446 /* Get number of channels. Valid values are 1 for grayscale images
6447 and images with a palette, 2 for grayscale images with transparency
6448 information (alpha channel), 3 for RGB images, and 4 for RGB
6449 images with alpha channel, i.e. RGBA. If conversions above were
6450 sufficient we should only have 3 or 4 channels here. */
6451 channels
= fn_png_get_channels (png_ptr
, info_ptr
);
6452 xassert (channels
== 3 || channels
== 4);
6454 /* Number of bytes needed for one row of the image. */
6455 row_bytes
= fn_png_get_rowbytes (png_ptr
, info_ptr
);
6457 /* Allocate memory for the image. */
6458 pixels
= (png_byte
*) xmalloc (row_bytes
* height
* sizeof *pixels
);
6459 rows
= (png_byte
**) xmalloc (height
* sizeof *rows
);
6460 for (i
= 0; i
< height
; ++i
)
6461 rows
[i
] = pixels
+ i
* row_bytes
;
6463 /* Read the entire image. */
6464 fn_png_read_image (png_ptr
, rows
);
6465 fn_png_read_end (png_ptr
, info_ptr
);
6472 /* Create the X image and pixmap. */
6473 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
,
6477 /* Create an image and pixmap serving as mask if the PNG image
6478 contains an alpha channel. */
6481 && !x_create_x_image_and_pixmap (f
, width
, height
, 1,
6482 &mask_img
, &img
->mask
))
6484 x_destroy_x_image (ximg
);
6485 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->pixmap
);
6486 img
->pixmap
= NO_PIXMAP
;
6490 /* Fill the X image and mask from PNG data. */
6491 init_color_table ();
6493 for (y
= 0; y
< height
; ++y
)
6495 png_byte
*p
= rows
[y
];
6497 for (x
= 0; x
< width
; ++x
)
6504 XPutPixel (ximg
, x
, y
, lookup_rgb_color (f
, r
, g
, b
));
6505 /* An alpha channel, aka mask channel, associates variable
6506 transparency with an image. Where other image formats
6507 support binary transparency---fully transparent or fully
6508 opaque---PNG allows up to 254 levels of partial transparency.
6509 The PNG library implements partial transparency by combining
6510 the image with a specified background color.
6512 I'm not sure how to handle this here nicely: because the
6513 background on which the image is displayed may change, for
6514 real alpha channel support, it would be necessary to create
6515 a new image for each possible background.
6517 What I'm doing now is that a mask is created if we have
6518 boolean transparency information. Otherwise I'm using
6519 the frame's background color to combine the image with. */
6524 XPutPixel (mask_img
, x
, y
, *p
> 0 ? PIX_MASK_DRAW
: PIX_MASK_RETAIN
);
6530 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
6531 /* Set IMG's background color from the PNG image, unless the user
6535 if (fn_png_get_bKGD (png_ptr
, info_ptr
, &bg
))
6537 img
->background
= lookup_rgb_color (f
, bg
->red
, bg
->green
, bg
->blue
);
6538 img
->background_valid
= 1;
6542 #ifdef COLOR_TABLE_SUPPORT
6543 /* Remember colors allocated for this image. */
6544 img
->colors
= colors_in_color_table (&img
->ncolors
);
6545 free_color_table ();
6546 #endif /* COLOR_TABLE_SUPPORT */
6549 fn_png_destroy_read_struct (&png_ptr
, &info_ptr
, &end_info
);
6554 img
->height
= height
;
6556 /* Maybe fill in the background field while we have ximg handy.
6557 Casting avoids a GCC warning. */
6558 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
6560 /* Put the image into the pixmap, then free the X image and its buffer. */
6561 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
6562 x_destroy_x_image (ximg
);
6564 /* Same for the mask. */
6567 /* Fill in the background_transparent field while we have the
6568 mask handy. Casting avoids a GCC warning. */
6569 image_background_transparent (img
, f
, (XImagePtr_or_DC
)mask_img
);
6571 x_put_x_image (f
, mask_img
, img
->mask
, img
->width
, img
->height
);
6572 x_destroy_x_image (mask_img
);
6579 #else /* HAVE_PNG */
6588 if (MyCGImageCreateWithPNGDataProvider
)
6589 return image_load_quartz2d (f
, img
, 1);
6592 return image_load_quicktime (f
, img
, kQTFileTypePNG
);
6596 #endif /* !HAVE_PNG */
6600 /***********************************************************************
6602 ***********************************************************************/
6604 #if defined (HAVE_JPEG) || defined (MAC_OS)
6606 static int jpeg_image_p
P_ ((Lisp_Object object
));
6607 static int jpeg_load
P_ ((struct frame
*f
, struct image
*img
));
6609 /* The symbol `jpeg' identifying images of this type. */
6613 /* Indices of image specification fields in gs_format, below. */
6615 enum jpeg_keyword_index
6624 JPEG_HEURISTIC_MASK
,
6630 /* Vector of image_keyword structures describing the format
6631 of valid user-defined image specifications. */
6633 static struct image_keyword jpeg_format
[JPEG_LAST
] =
6635 {":type", IMAGE_SYMBOL_VALUE
, 1},
6636 {":data", IMAGE_STRING_VALUE
, 0},
6637 {":file", IMAGE_STRING_VALUE
, 0},
6638 {":ascent", IMAGE_ASCENT_VALUE
, 0},
6639 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
6640 {":relief", IMAGE_INTEGER_VALUE
, 0},
6641 {":conversions", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6642 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6643 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6644 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
6647 /* Structure describing the image type `jpeg'. */
6649 static struct image_type jpeg_type
=
6658 /* Return non-zero if OBJECT is a valid JPEG image specification. */
6661 jpeg_image_p (object
)
6664 struct image_keyword fmt
[JPEG_LAST
];
6666 bcopy (jpeg_format
, fmt
, sizeof fmt
);
6668 if (!parse_image_spec (object
, fmt
, JPEG_LAST
, Qjpeg
))
6671 /* Must specify either the :data or :file keyword. */
6672 return fmt
[JPEG_FILE
].count
+ fmt
[JPEG_DATA
].count
== 1;
6675 #endif /* HAVE_JPEG || MAC_OS */
6679 /* Work around a warning about HAVE_STDLIB_H being redefined in
6681 #ifdef HAVE_STDLIB_H
6682 #define HAVE_STDLIB_H_1
6683 #undef HAVE_STDLIB_H
6684 #endif /* HAVE_STLIB_H */
6686 #if defined (HAVE_NTGUI) && !defined (__WIN32__)
6687 /* In older releases of the jpeg library, jpeglib.h will define boolean
6688 differently depending on __WIN32__, so make sure it is defined. */
6692 #include <jpeglib.h>
6696 #ifdef HAVE_STLIB_H_1
6697 #define HAVE_STDLIB_H 1
6702 /* JPEG library details. */
6703 DEF_IMGLIB_FN (jpeg_CreateDecompress
);
6704 DEF_IMGLIB_FN (jpeg_start_decompress
);
6705 DEF_IMGLIB_FN (jpeg_finish_decompress
);
6706 DEF_IMGLIB_FN (jpeg_destroy_decompress
);
6707 DEF_IMGLIB_FN (jpeg_read_header
);
6708 DEF_IMGLIB_FN (jpeg_read_scanlines
);
6709 DEF_IMGLIB_FN (jpeg_std_error
);
6710 DEF_IMGLIB_FN (jpeg_resync_to_restart
);
6713 init_jpeg_functions (Lisp_Object libraries
)
6717 if (!(library
= w32_delayed_load (libraries
, Qjpeg
)))
6720 LOAD_IMGLIB_FN (library
, jpeg_finish_decompress
);
6721 LOAD_IMGLIB_FN (library
, jpeg_read_scanlines
);
6722 LOAD_IMGLIB_FN (library
, jpeg_start_decompress
);
6723 LOAD_IMGLIB_FN (library
, jpeg_read_header
);
6724 LOAD_IMGLIB_FN (library
, jpeg_CreateDecompress
);
6725 LOAD_IMGLIB_FN (library
, jpeg_destroy_decompress
);
6726 LOAD_IMGLIB_FN (library
, jpeg_std_error
);
6727 LOAD_IMGLIB_FN (library
, jpeg_resync_to_restart
);
6731 /* Wrapper since we can't directly assign the function pointer
6732 to another function pointer that was declared more completely easily. */
6734 jpeg_resync_to_restart_wrapper (cinfo
, desired
)
6735 j_decompress_ptr cinfo
;
6738 return fn_jpeg_resync_to_restart (cinfo
, desired
);
6743 #define fn_jpeg_CreateDecompress(a,b,c) jpeg_create_decompress(a)
6744 #define fn_jpeg_start_decompress jpeg_start_decompress
6745 #define fn_jpeg_finish_decompress jpeg_finish_decompress
6746 #define fn_jpeg_destroy_decompress jpeg_destroy_decompress
6747 #define fn_jpeg_read_header jpeg_read_header
6748 #define fn_jpeg_read_scanlines jpeg_read_scanlines
6749 #define fn_jpeg_std_error jpeg_std_error
6750 #define jpeg_resync_to_restart_wrapper jpeg_resync_to_restart
6752 #endif /* HAVE_NTGUI */
6754 struct my_jpeg_error_mgr
6756 struct jpeg_error_mgr pub
;
6757 jmp_buf setjmp_buffer
;
6762 my_error_exit (cinfo
)
6765 struct my_jpeg_error_mgr
*mgr
= (struct my_jpeg_error_mgr
*) cinfo
->err
;
6766 longjmp (mgr
->setjmp_buffer
, 1);
6770 /* Init source method for JPEG data source manager. Called by
6771 jpeg_read_header() before any data is actually read. See
6772 libjpeg.doc from the JPEG lib distribution. */
6775 our_common_init_source (cinfo
)
6776 j_decompress_ptr cinfo
;
6781 /* Method to terminate data source. Called by
6782 jpeg_finish_decompress() after all data has been processed. */
6785 our_common_term_source (cinfo
)
6786 j_decompress_ptr cinfo
;
6791 /* Fill input buffer method for JPEG data source manager. Called
6792 whenever more data is needed. We read the whole image in one step,
6793 so this only adds a fake end of input marker at the end. */
6795 static JOCTET our_memory_buffer
[2];
6798 our_memory_fill_input_buffer (cinfo
)
6799 j_decompress_ptr cinfo
;
6801 /* Insert a fake EOI marker. */
6802 struct jpeg_source_mgr
*src
= cinfo
->src
;
6804 our_memory_buffer
[0] = (JOCTET
) 0xFF;
6805 our_memory_buffer
[1] = (JOCTET
) JPEG_EOI
;
6807 src
->next_input_byte
= our_memory_buffer
;
6808 src
->bytes_in_buffer
= 2;
6813 /* Method to skip over NUM_BYTES bytes in the image data. CINFO->src
6814 is the JPEG data source manager. */
6817 our_memory_skip_input_data (cinfo
, num_bytes
)
6818 j_decompress_ptr cinfo
;
6821 struct jpeg_source_mgr
*src
= (struct jpeg_source_mgr
*) cinfo
->src
;
6825 if (num_bytes
> src
->bytes_in_buffer
)
6826 ERREXIT (cinfo
, JERR_INPUT_EOF
);
6828 src
->bytes_in_buffer
-= num_bytes
;
6829 src
->next_input_byte
+= num_bytes
;
6834 /* Set up the JPEG lib for reading an image from DATA which contains
6835 LEN bytes. CINFO is the decompression info structure created for
6836 reading the image. */
6839 jpeg_memory_src (cinfo
, data
, len
)
6840 j_decompress_ptr cinfo
;
6844 struct jpeg_source_mgr
*src
;
6846 if (cinfo
->src
== NULL
)
6848 /* First time for this JPEG object? */
6849 cinfo
->src
= (struct jpeg_source_mgr
*)
6850 (*cinfo
->mem
->alloc_small
) ((j_common_ptr
) cinfo
, JPOOL_PERMANENT
,
6851 sizeof (struct jpeg_source_mgr
));
6852 src
= (struct jpeg_source_mgr
*) cinfo
->src
;
6853 src
->next_input_byte
= data
;
6856 src
= (struct jpeg_source_mgr
*) cinfo
->src
;
6857 src
->init_source
= our_common_init_source
;
6858 src
->fill_input_buffer
= our_memory_fill_input_buffer
;
6859 src
->skip_input_data
= our_memory_skip_input_data
;
6860 src
->resync_to_restart
= jpeg_resync_to_restart_wrapper
; /* Use default method. */
6861 src
->term_source
= our_common_term_source
;
6862 src
->bytes_in_buffer
= len
;
6863 src
->next_input_byte
= data
;
6867 struct jpeg_stdio_mgr
6869 struct jpeg_source_mgr mgr
;
6876 /* Size of buffer to read JPEG from file.
6877 Not too big, as we want to use alloc_small. */
6878 #define JPEG_STDIO_BUFFER_SIZE 8192
6881 /* Fill input buffer method for JPEG data source manager. Called
6882 whenever more data is needed. The data is read from a FILE *. */
6885 our_stdio_fill_input_buffer (cinfo
)
6886 j_decompress_ptr cinfo
;
6888 struct jpeg_stdio_mgr
*src
;
6890 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6895 bytes
= fread (src
->buffer
, 1, JPEG_STDIO_BUFFER_SIZE
, src
->file
);
6897 src
->mgr
.bytes_in_buffer
= bytes
;
6900 WARNMS (cinfo
, JWRN_JPEG_EOF
);
6902 src
->buffer
[0] = (JOCTET
) 0xFF;
6903 src
->buffer
[1] = (JOCTET
) JPEG_EOI
;
6904 src
->mgr
.bytes_in_buffer
= 2;
6906 src
->mgr
.next_input_byte
= src
->buffer
;
6913 /* Method to skip over NUM_BYTES bytes in the image data. CINFO->src
6914 is the JPEG data source manager. */
6917 our_stdio_skip_input_data (cinfo
, num_bytes
)
6918 j_decompress_ptr cinfo
;
6921 struct jpeg_stdio_mgr
*src
;
6922 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6924 while (num_bytes
> 0 && !src
->finished
)
6926 if (num_bytes
<= src
->mgr
.bytes_in_buffer
)
6928 src
->mgr
.bytes_in_buffer
-= num_bytes
;
6929 src
->mgr
.next_input_byte
+= num_bytes
;
6934 num_bytes
-= src
->mgr
.bytes_in_buffer
;
6935 src
->mgr
.bytes_in_buffer
= 0;
6936 src
->mgr
.next_input_byte
= NULL
;
6938 our_stdio_fill_input_buffer (cinfo
);
6944 /* Set up the JPEG lib for reading an image from a FILE *.
6945 CINFO is the decompression info structure created for
6946 reading the image. */
6949 jpeg_file_src (cinfo
, fp
)
6950 j_decompress_ptr cinfo
;
6953 struct jpeg_stdio_mgr
*src
;
6955 if (cinfo
->src
!= NULL
)
6956 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6959 /* First time for this JPEG object? */
6960 cinfo
->src
= (struct jpeg_source_mgr
*)
6961 (*cinfo
->mem
->alloc_small
) ((j_common_ptr
) cinfo
, JPOOL_PERMANENT
,
6962 sizeof (struct jpeg_stdio_mgr
));
6963 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6964 src
->buffer
= (JOCTET
*)
6965 (*cinfo
->mem
->alloc_small
) ((j_common_ptr
) cinfo
, JPOOL_PERMANENT
,
6966 JPEG_STDIO_BUFFER_SIZE
);
6971 src
->mgr
.init_source
= our_common_init_source
;
6972 src
->mgr
.fill_input_buffer
= our_stdio_fill_input_buffer
;
6973 src
->mgr
.skip_input_data
= our_stdio_skip_input_data
;
6974 src
->mgr
.resync_to_restart
= jpeg_resync_to_restart_wrapper
; /* Use default method. */
6975 src
->mgr
.term_source
= our_common_term_source
;
6976 src
->mgr
.bytes_in_buffer
= 0;
6977 src
->mgr
.next_input_byte
= NULL
;
6981 /* Load image IMG for use on frame F. Patterned after example.c
6982 from the JPEG lib. */
6989 struct jpeg_decompress_struct cinfo
;
6990 struct my_jpeg_error_mgr mgr
;
6991 Lisp_Object file
, specified_file
;
6992 Lisp_Object specified_data
;
6993 FILE * volatile fp
= NULL
;
6995 int row_stride
, x
, y
;
6996 XImagePtr ximg
= NULL
;
6998 unsigned long *colors
;
7000 struct gcpro gcpro1
;
7002 /* Open the JPEG file. */
7003 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
7004 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
7008 if (NILP (specified_data
))
7010 file
= x_find_image_file (specified_file
);
7011 if (!STRINGP (file
))
7013 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
7018 fp
= fopen (SDATA (file
), "rb");
7021 image_error ("Cannot open `%s'", file
, Qnil
);
7027 /* Customize libjpeg's error handling to call my_error_exit when an
7028 error is detected. This function will perform a longjmp.
7029 Casting return value avoids a GCC warning on W32. */
7030 cinfo
.err
= (struct jpeg_error_mgr
*)fn_jpeg_std_error (&mgr
.pub
);
7031 mgr
.pub
.error_exit
= my_error_exit
;
7033 if ((rc
= setjmp (mgr
.setjmp_buffer
)) != 0)
7037 /* Called from my_error_exit. Display a JPEG error. */
7038 char buffer
[JMSG_LENGTH_MAX
];
7039 cinfo
.err
->format_message ((j_common_ptr
) &cinfo
, buffer
);
7040 image_error ("Error reading JPEG image `%s': %s", img
->spec
,
7041 build_string (buffer
));
7044 /* Close the input file and destroy the JPEG object. */
7046 fclose ((FILE *) fp
);
7047 fn_jpeg_destroy_decompress (&cinfo
);
7049 /* If we already have an XImage, free that. */
7050 x_destroy_x_image (ximg
);
7052 /* Free pixmap and colors. */
7053 x_clear_image (f
, img
);
7059 /* Create the JPEG decompression object. Let it read from fp.
7060 Read the JPEG image header. */
7061 fn_jpeg_CreateDecompress (&cinfo
, JPEG_LIB_VERSION
, sizeof (cinfo
));
7063 if (NILP (specified_data
))
7064 jpeg_file_src (&cinfo
, (FILE *) fp
);
7066 jpeg_memory_src (&cinfo
, SDATA (specified_data
),
7067 SBYTES (specified_data
));
7069 fn_jpeg_read_header (&cinfo
, 1);
7071 /* Customize decompression so that color quantization will be used.
7072 Start decompression. */
7073 cinfo
.quantize_colors
= 1;
7074 fn_jpeg_start_decompress (&cinfo
);
7075 width
= img
->width
= cinfo
.output_width
;
7076 height
= img
->height
= cinfo
.output_height
;
7078 if (!check_image_size (f
, width
, height
))
7080 image_error ("Invalid image size", Qnil
, Qnil
);
7081 longjmp (mgr
.setjmp_buffer
, 2);
7084 /* Create X image and pixmap. */
7085 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
7086 longjmp (mgr
.setjmp_buffer
, 2);
7088 /* Allocate colors. When color quantization is used,
7089 cinfo.actual_number_of_colors has been set with the number of
7090 colors generated, and cinfo.colormap is a two-dimensional array
7091 of color indices in the range 0..cinfo.actual_number_of_colors.
7092 No more than 255 colors will be generated. */
7096 if (cinfo
.out_color_components
> 2)
7097 ir
= 0, ig
= 1, ib
= 2;
7098 else if (cinfo
.out_color_components
> 1)
7099 ir
= 0, ig
= 1, ib
= 0;
7101 ir
= 0, ig
= 0, ib
= 0;
7103 /* Use the color table mechanism because it handles colors that
7104 cannot be allocated nicely. Such colors will be replaced with
7105 a default color, and we don't have to care about which colors
7106 can be freed safely, and which can't. */
7107 init_color_table ();
7108 colors
= (unsigned long *) alloca (cinfo
.actual_number_of_colors
7111 for (i
= 0; i
< cinfo
.actual_number_of_colors
; ++i
)
7113 /* Multiply RGB values with 255 because X expects RGB values
7114 in the range 0..0xffff. */
7115 int r
= cinfo
.colormap
[ir
][i
] << 8;
7116 int g
= cinfo
.colormap
[ig
][i
] << 8;
7117 int b
= cinfo
.colormap
[ib
][i
] << 8;
7118 colors
[i
] = lookup_rgb_color (f
, r
, g
, b
);
7121 #ifdef COLOR_TABLE_SUPPORT
7122 /* Remember those colors actually allocated. */
7123 img
->colors
= colors_in_color_table (&img
->ncolors
);
7124 free_color_table ();
7125 #endif /* COLOR_TABLE_SUPPORT */
7129 row_stride
= width
* cinfo
.output_components
;
7130 buffer
= cinfo
.mem
->alloc_sarray ((j_common_ptr
) &cinfo
, JPOOL_IMAGE
,
7132 for (y
= 0; y
< height
; ++y
)
7134 fn_jpeg_read_scanlines (&cinfo
, buffer
, 1);
7135 for (x
= 0; x
< cinfo
.output_width
; ++x
)
7136 XPutPixel (ximg
, x
, y
, colors
[buffer
[0][x
]]);
7140 fn_jpeg_finish_decompress (&cinfo
);
7141 fn_jpeg_destroy_decompress (&cinfo
);
7143 fclose ((FILE *) fp
);
7145 /* Maybe fill in the background field while we have ximg handy. */
7146 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
7147 /* Casting avoids a GCC warning. */
7148 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
7150 /* Put the image into the pixmap. */
7151 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
7152 x_destroy_x_image (ximg
);
7157 #else /* HAVE_JPEG */
7166 return image_load_quartz2d (f
, img
, 0);
7168 return image_load_quicktime (f
, img
, kQTFileTypeJPEG
);
7173 #endif /* !HAVE_JPEG */
7177 /***********************************************************************
7179 ***********************************************************************/
7181 #if defined (HAVE_TIFF) || defined (MAC_OS)
7183 static int tiff_image_p
P_ ((Lisp_Object object
));
7184 static int tiff_load
P_ ((struct frame
*f
, struct image
*img
));
7186 /* The symbol `tiff' identifying images of this type. */
7190 /* Indices of image specification fields in tiff_format, below. */
7192 enum tiff_keyword_index
7201 TIFF_HEURISTIC_MASK
,
7207 /* Vector of image_keyword structures describing the format
7208 of valid user-defined image specifications. */
7210 static struct image_keyword tiff_format
[TIFF_LAST
] =
7212 {":type", IMAGE_SYMBOL_VALUE
, 1},
7213 {":data", IMAGE_STRING_VALUE
, 0},
7214 {":file", IMAGE_STRING_VALUE
, 0},
7215 {":ascent", IMAGE_ASCENT_VALUE
, 0},
7216 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
7217 {":relief", IMAGE_INTEGER_VALUE
, 0},
7218 {":conversions", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7219 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7220 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7221 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
7224 /* Structure describing the image type `tiff'. */
7226 static struct image_type tiff_type
=
7235 /* Return non-zero if OBJECT is a valid TIFF image specification. */
7238 tiff_image_p (object
)
7241 struct image_keyword fmt
[TIFF_LAST
];
7242 bcopy (tiff_format
, fmt
, sizeof fmt
);
7244 if (!parse_image_spec (object
, fmt
, TIFF_LAST
, Qtiff
))
7247 /* Must specify either the :data or :file keyword. */
7248 return fmt
[TIFF_FILE
].count
+ fmt
[TIFF_DATA
].count
== 1;
7251 #endif /* HAVE_TIFF || MAC_OS */
7259 /* TIFF library details. */
7260 DEF_IMGLIB_FN (TIFFSetErrorHandler
);
7261 DEF_IMGLIB_FN (TIFFSetWarningHandler
);
7262 DEF_IMGLIB_FN (TIFFOpen
);
7263 DEF_IMGLIB_FN (TIFFClientOpen
);
7264 DEF_IMGLIB_FN (TIFFGetField
);
7265 DEF_IMGLIB_FN (TIFFReadRGBAImage
);
7266 DEF_IMGLIB_FN (TIFFClose
);
7269 init_tiff_functions (Lisp_Object libraries
)
7273 if (!(library
= w32_delayed_load (libraries
, Qtiff
)))
7276 LOAD_IMGLIB_FN (library
, TIFFSetErrorHandler
);
7277 LOAD_IMGLIB_FN (library
, TIFFSetWarningHandler
);
7278 LOAD_IMGLIB_FN (library
, TIFFOpen
);
7279 LOAD_IMGLIB_FN (library
, TIFFClientOpen
);
7280 LOAD_IMGLIB_FN (library
, TIFFGetField
);
7281 LOAD_IMGLIB_FN (library
, TIFFReadRGBAImage
);
7282 LOAD_IMGLIB_FN (library
, TIFFClose
);
7288 #define fn_TIFFSetErrorHandler TIFFSetErrorHandler
7289 #define fn_TIFFSetWarningHandler TIFFSetWarningHandler
7290 #define fn_TIFFOpen TIFFOpen
7291 #define fn_TIFFClientOpen TIFFClientOpen
7292 #define fn_TIFFGetField TIFFGetField
7293 #define fn_TIFFReadRGBAImage TIFFReadRGBAImage
7294 #define fn_TIFFClose TIFFClose
7296 #endif /* HAVE_NTGUI */
7299 /* Reading from a memory buffer for TIFF images Based on the PNG
7300 memory source, but we have to provide a lot of extra functions.
7303 We really only need to implement read and seek, but I am not
7304 convinced that the TIFF library is smart enough not to destroy
7305 itself if we only hand it the function pointers we need to
7310 unsigned char *bytes
;
7317 tiff_read_from_memory (data
, buf
, size
)
7322 tiff_memory_source
*src
= (tiff_memory_source
*) data
;
7324 if (size
> src
->len
- src
->index
)
7326 bcopy (src
->bytes
+ src
->index
, buf
, size
);
7332 tiff_write_from_memory (data
, buf
, size
)
7341 tiff_seek_in_memory (data
, off
, whence
)
7346 tiff_memory_source
*src
= (tiff_memory_source
*) data
;
7351 case SEEK_SET
: /* Go from beginning of source. */
7355 case SEEK_END
: /* Go from end of source. */
7356 idx
= src
->len
+ off
;
7359 case SEEK_CUR
: /* Go from current position. */
7360 idx
= src
->index
+ off
;
7363 default: /* Invalid `whence'. */
7367 if (idx
> src
->len
|| idx
< 0)
7375 tiff_close_memory (data
)
7383 tiff_mmap_memory (data
, pbase
, psize
)
7388 /* It is already _IN_ memory. */
7393 tiff_unmap_memory (data
, base
, size
)
7398 /* We don't need to do this. */
7402 tiff_size_of_memory (data
)
7405 return ((tiff_memory_source
*) data
)->len
;
7410 tiff_error_handler (title
, format
, ap
)
7411 const char *title
, *format
;
7417 len
= sprintf (buf
, "TIFF error: %s ", title
);
7418 vsprintf (buf
+ len
, format
, ap
);
7419 add_to_log (buf
, Qnil
, Qnil
);
7424 tiff_warning_handler (title
, format
, ap
)
7425 const char *title
, *format
;
7431 len
= sprintf (buf
, "TIFF warning: %s ", title
);
7432 vsprintf (buf
+ len
, format
, ap
);
7433 add_to_log (buf
, Qnil
, Qnil
);
7437 /* Load TIFF image IMG for use on frame F. Value is non-zero if
7445 Lisp_Object file
, specified_file
;
7446 Lisp_Object specified_data
;
7448 int width
, height
, x
, y
;
7452 struct gcpro gcpro1
;
7453 tiff_memory_source memsrc
;
7455 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
7456 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
7460 fn_TIFFSetErrorHandler (tiff_error_handler
);
7461 fn_TIFFSetWarningHandler (tiff_warning_handler
);
7463 if (NILP (specified_data
))
7465 /* Read from a file */
7466 file
= x_find_image_file (specified_file
);
7467 if (!STRINGP (file
))
7469 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
7474 /* Try to open the image file. Casting return value avoids a
7475 GCC warning on W32. */
7476 tiff
= (TIFF
*)fn_TIFFOpen (SDATA (file
), "r");
7479 image_error ("Cannot open `%s'", file
, Qnil
);
7486 /* Memory source! */
7487 memsrc
.bytes
= SDATA (specified_data
);
7488 memsrc
.len
= SBYTES (specified_data
);
7491 /* Casting return value avoids a GCC warning on W32. */
7492 tiff
= (TIFF
*)fn_TIFFClientOpen ("memory_source", "r", &memsrc
,
7493 (TIFFReadWriteProc
) tiff_read_from_memory
,
7494 (TIFFReadWriteProc
) tiff_write_from_memory
,
7495 tiff_seek_in_memory
,
7497 tiff_size_of_memory
,
7503 image_error ("Cannot open memory source for `%s'", img
->spec
, Qnil
);
7509 /* Get width and height of the image, and allocate a raster buffer
7510 of width x height 32-bit values. */
7511 fn_TIFFGetField (tiff
, TIFFTAG_IMAGEWIDTH
, &width
);
7512 fn_TIFFGetField (tiff
, TIFFTAG_IMAGELENGTH
, &height
);
7514 if (!check_image_size (f
, width
, height
))
7516 image_error ("Invalid image size", Qnil
, Qnil
);
7521 buf
= (uint32
*) xmalloc (width
* height
* sizeof *buf
);
7523 rc
= fn_TIFFReadRGBAImage (tiff
, width
, height
, buf
, 0);
7524 fn_TIFFClose (tiff
);
7527 image_error ("Error reading TIFF image `%s'", img
->spec
, Qnil
);
7533 /* Create the X image and pixmap. */
7534 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
7541 /* Initialize the color table. */
7542 init_color_table ();
7544 /* Process the pixel raster. Origin is in the lower-left corner. */
7545 for (y
= 0; y
< height
; ++y
)
7547 uint32
*row
= buf
+ y
* width
;
7549 for (x
= 0; x
< width
; ++x
)
7551 uint32 abgr
= row
[x
];
7552 int r
= TIFFGetR (abgr
) << 8;
7553 int g
= TIFFGetG (abgr
) << 8;
7554 int b
= TIFFGetB (abgr
) << 8;
7555 XPutPixel (ximg
, x
, height
- 1 - y
, lookup_rgb_color (f
, r
, g
, b
));
7559 #ifdef COLOR_TABLE_SUPPORT
7560 /* Remember the colors allocated for the image. Free the color table. */
7561 img
->colors
= colors_in_color_table (&img
->ncolors
);
7562 free_color_table ();
7563 #endif /* COLOR_TABLE_SUPPORT */
7566 img
->height
= height
;
7568 /* Maybe fill in the background field while we have ximg handy. */
7569 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
7570 /* Casting avoids a GCC warning on W32. */
7571 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
7573 /* Put the image into the pixmap, then free the X image and its buffer. */
7574 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
7575 x_destroy_x_image (ximg
);
7582 #else /* HAVE_TIFF */
7590 return image_load_quicktime (f
, img
, kQTFileTypeTIFF
);
7594 #endif /* !HAVE_TIFF */
7598 /***********************************************************************
7600 ***********************************************************************/
7602 #if defined (HAVE_GIF) || defined (MAC_OS)
7604 static int gif_image_p
P_ ((Lisp_Object object
));
7605 static int gif_load
P_ ((struct frame
*f
, struct image
*img
));
7606 static void gif_clear_image
P_ ((struct frame
*f
, struct image
*img
));
7608 /* The symbol `gif' identifying images of this type. */
7612 /* Indices of image specification fields in gif_format, below. */
7614 enum gif_keyword_index
7630 /* Vector of image_keyword structures describing the format
7631 of valid user-defined image specifications. */
7633 static struct image_keyword gif_format
[GIF_LAST
] =
7635 {":type", IMAGE_SYMBOL_VALUE
, 1},
7636 {":data", IMAGE_STRING_VALUE
, 0},
7637 {":file", IMAGE_STRING_VALUE
, 0},
7638 {":ascent", IMAGE_ASCENT_VALUE
, 0},
7639 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
7640 {":relief", IMAGE_INTEGER_VALUE
, 0},
7641 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7642 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7643 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7644 {":image", IMAGE_NON_NEGATIVE_INTEGER_VALUE
, 0},
7645 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
7648 /* Structure describing the image type `gif'. */
7650 static struct image_type gif_type
=
7659 /* Free X resources of GIF image IMG which is used on frame F. */
7662 gif_clear_image (f
, img
)
7666 /* IMG->data.ptr_val may contain extension data. */
7667 img
->data
.lisp_val
= Qnil
;
7668 x_clear_image (f
, img
);
7671 /* Return non-zero if OBJECT is a valid GIF image specification. */
7674 gif_image_p (object
)
7677 struct image_keyword fmt
[GIF_LAST
];
7678 bcopy (gif_format
, fmt
, sizeof fmt
);
7680 if (!parse_image_spec (object
, fmt
, GIF_LAST
, Qgif
))
7683 /* Must specify either the :data or :file keyword. */
7684 return fmt
[GIF_FILE
].count
+ fmt
[GIF_DATA
].count
== 1;
7687 #endif /* HAVE_GIF || MAC_OS */
7691 #if defined (HAVE_NTGUI) || defined (MAC_OS)
7692 /* winuser.h might define DrawText to DrawTextA or DrawTextW.
7693 Undefine before redefining to avoid a preprocessor warning. */
7697 /* avoid conflict with QuickdrawText.h */
7698 #define DrawText gif_DrawText
7699 #include <gif_lib.h>
7702 #else /* HAVE_NTGUI || MAC_OS */
7704 #include <gif_lib.h>
7706 #endif /* HAVE_NTGUI || MAC_OS */
7711 /* GIF library details. */
7712 DEF_IMGLIB_FN (DGifCloseFile
);
7713 DEF_IMGLIB_FN (DGifSlurp
);
7714 DEF_IMGLIB_FN (DGifOpen
);
7715 DEF_IMGLIB_FN (DGifOpenFileName
);
7718 init_gif_functions (Lisp_Object libraries
)
7722 if (!(library
= w32_delayed_load (libraries
, Qgif
)))
7725 LOAD_IMGLIB_FN (library
, DGifCloseFile
);
7726 LOAD_IMGLIB_FN (library
, DGifSlurp
);
7727 LOAD_IMGLIB_FN (library
, DGifOpen
);
7728 LOAD_IMGLIB_FN (library
, DGifOpenFileName
);
7734 #define fn_DGifCloseFile DGifCloseFile
7735 #define fn_DGifSlurp DGifSlurp
7736 #define fn_DGifOpen DGifOpen
7737 #define fn_DGifOpenFileName DGifOpenFileName
7739 #endif /* HAVE_NTGUI */
7741 /* Reading a GIF image from memory
7742 Based on the PNG memory stuff to a certain extent. */
7746 unsigned char *bytes
;
7752 /* Make the current memory source available to gif_read_from_memory.
7753 It's done this way because not all versions of libungif support
7754 a UserData field in the GifFileType structure. */
7755 static gif_memory_source
*current_gif_memory_src
;
7758 gif_read_from_memory (file
, buf
, len
)
7763 gif_memory_source
*src
= current_gif_memory_src
;
7765 if (len
> src
->len
- src
->index
)
7768 bcopy (src
->bytes
+ src
->index
, buf
, len
);
7774 /* Load GIF image IMG for use on frame F. Value is non-zero if
7777 static int interlace_start
[] = {0, 4, 2, 1};
7778 static int interlace_increment
[] = {8, 8, 4, 2};
7785 Lisp_Object file
, specified_file
;
7786 Lisp_Object specified_data
;
7787 int rc
, width
, height
, x
, y
, i
;
7789 ColorMapObject
*gif_color_map
;
7790 unsigned long pixel_colors
[256];
7792 struct gcpro gcpro1
;
7794 int ino
, image_height
, image_width
;
7795 gif_memory_source memsrc
;
7796 unsigned char *raster
;
7798 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
7799 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
7803 if (NILP (specified_data
))
7805 file
= x_find_image_file (specified_file
);
7806 if (!STRINGP (file
))
7808 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
7813 /* Open the GIF file. Casting return value avoids a GCC warning
7815 gif
= (GifFileType
*)fn_DGifOpenFileName (SDATA (file
));
7818 image_error ("Cannot open `%s'", file
, Qnil
);
7825 /* Read from memory! */
7826 current_gif_memory_src
= &memsrc
;
7827 memsrc
.bytes
= SDATA (specified_data
);
7828 memsrc
.len
= SBYTES (specified_data
);
7831 /* Casting return value avoids a GCC warning on W32. */
7832 gif
= (GifFileType
*) fn_DGifOpen (&memsrc
, gif_read_from_memory
);
7835 image_error ("Cannot open memory source `%s'", img
->spec
, Qnil
);
7841 /* Before reading entire contents, check the declared image size. */
7842 if (!check_image_size (f
, gif
->SWidth
, gif
->SHeight
))
7844 image_error ("Invalid image size", Qnil
, Qnil
);
7845 fn_DGifCloseFile (gif
);
7850 /* Read entire contents. */
7851 rc
= fn_DGifSlurp (gif
);
7852 if (rc
== GIF_ERROR
)
7854 image_error ("Error reading `%s'", img
->spec
, Qnil
);
7855 fn_DGifCloseFile (gif
);
7860 image
= image_spec_value (img
->spec
, QCindex
, NULL
);
7861 ino
= INTEGERP (image
) ? XFASTINT (image
) : 0;
7862 if (ino
>= gif
->ImageCount
)
7864 image_error ("Invalid image number `%s' in image `%s'",
7866 fn_DGifCloseFile (gif
);
7871 img
->corners
[TOP_CORNER
] = gif
->SavedImages
[ino
].ImageDesc
.Top
;
7872 img
->corners
[LEFT_CORNER
] = gif
->SavedImages
[ino
].ImageDesc
.Left
;
7873 image_height
= gif
->SavedImages
[ino
].ImageDesc
.Height
;
7874 img
->corners
[BOT_CORNER
] = img
->corners
[TOP_CORNER
] + image_height
;
7875 image_width
= gif
->SavedImages
[ino
].ImageDesc
.Width
;
7876 img
->corners
[RIGHT_CORNER
] = img
->corners
[LEFT_CORNER
] + image_width
;
7878 width
= img
->width
= max (gif
->SWidth
,
7879 max (gif
->Image
.Left
+ gif
->Image
.Width
,
7880 img
->corners
[RIGHT_CORNER
]));
7881 height
= img
->height
= max (gif
->SHeight
,
7882 max (gif
->Image
.Top
+ gif
->Image
.Height
,
7883 img
->corners
[BOT_CORNER
]));
7885 if (!check_image_size (f
, width
, height
))
7887 image_error ("Invalid image size", Qnil
, Qnil
);
7888 fn_DGifCloseFile (gif
);
7893 /* Create the X image and pixmap. */
7894 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
7896 fn_DGifCloseFile (gif
);
7901 /* Allocate colors. */
7902 gif_color_map
= gif
->SavedImages
[ino
].ImageDesc
.ColorMap
;
7904 gif_color_map
= gif
->SColorMap
;
7905 init_color_table ();
7906 bzero (pixel_colors
, sizeof pixel_colors
);
7909 for (i
= 0; i
< gif_color_map
->ColorCount
; ++i
)
7911 int r
= gif_color_map
->Colors
[i
].Red
<< 8;
7912 int g
= gif_color_map
->Colors
[i
].Green
<< 8;
7913 int b
= gif_color_map
->Colors
[i
].Blue
<< 8;
7914 pixel_colors
[i
] = lookup_rgb_color (f
, r
, g
, b
);
7917 #ifdef COLOR_TABLE_SUPPORT
7918 img
->colors
= colors_in_color_table (&img
->ncolors
);
7919 free_color_table ();
7920 #endif /* COLOR_TABLE_SUPPORT */
7922 /* Clear the part of the screen image that are not covered by
7923 the image from the GIF file. Full animated GIF support
7924 requires more than can be done here (see the gif89 spec,
7925 disposal methods). Let's simply assume that the part
7926 not covered by a sub-image is in the frame's background color. */
7927 for (y
= 0; y
< img
->corners
[TOP_CORNER
]; ++y
)
7928 for (x
= 0; x
< width
; ++x
)
7929 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7931 for (y
= img
->corners
[BOT_CORNER
]; y
< height
; ++y
)
7932 for (x
= 0; x
< width
; ++x
)
7933 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7935 for (y
= img
->corners
[TOP_CORNER
]; y
< img
->corners
[BOT_CORNER
]; ++y
)
7937 for (x
= 0; x
< img
->corners
[LEFT_CORNER
]; ++x
)
7938 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7939 for (x
= img
->corners
[RIGHT_CORNER
]; x
< width
; ++x
)
7940 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7943 /* Read the GIF image into the X image. We use a local variable
7944 `raster' here because RasterBits below is a char *, and invites
7945 problems with bytes >= 0x80. */
7946 raster
= (unsigned char *) gif
->SavedImages
[ino
].RasterBits
;
7948 if (gif
->SavedImages
[ino
].ImageDesc
.Interlace
)
7951 int row
= interlace_start
[0];
7955 for (y
= 0; y
< image_height
; y
++)
7957 if (row
>= image_height
)
7959 row
= interlace_start
[++pass
];
7960 while (row
>= image_height
)
7961 row
= interlace_start
[++pass
];
7964 for (x
= 0; x
< image_width
; x
++)
7966 int i
= raster
[(y
* image_width
) + x
];
7967 XPutPixel (ximg
, x
+ img
->corners
[LEFT_CORNER
],
7968 row
+ img
->corners
[TOP_CORNER
], pixel_colors
[i
]);
7971 row
+= interlace_increment
[pass
];
7976 for (y
= 0; y
< image_height
; ++y
)
7977 for (x
= 0; x
< image_width
; ++x
)
7979 int i
= raster
[y
* image_width
+ x
];
7980 XPutPixel (ximg
, x
+ img
->corners
[LEFT_CORNER
],
7981 y
+ img
->corners
[TOP_CORNER
], pixel_colors
[i
]);
7985 /* Save GIF image extension data for `image-extension-data'.
7986 Format is (count IMAGES FUNCTION "BYTES" ...). */
7987 img
->data
.lisp_val
= Qnil
;
7988 if (gif
->SavedImages
[ino
].ExtensionBlockCount
> 0)
7990 ExtensionBlock
*ext
= gif
->SavedImages
[ino
].ExtensionBlocks
;
7991 for (i
= 0; i
< gif
->SavedImages
[ino
].ExtensionBlockCount
; i
++, ext
++)
7992 /* Append (... FUNCTION "BYTES") */
7993 img
->data
.lisp_val
= Fcons (make_unibyte_string (ext
->Bytes
, ext
->ByteCount
),
7994 Fcons (make_number (ext
->Function
),
7995 img
->data
.lisp_val
));
7996 img
->data
.lisp_val
= Fnreverse (img
->data
.lisp_val
);
7998 if (gif
->ImageCount
> 1)
7999 img
->data
.lisp_val
= Fcons (Qcount
,
8000 Fcons (make_number (gif
->ImageCount
),
8001 img
->data
.lisp_val
));
8003 fn_DGifCloseFile (gif
);
8005 /* Maybe fill in the background field while we have ximg handy. */
8006 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
8007 /* Casting avoids a GCC warning. */
8008 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
8010 /* Put the image into the pixmap, then free the X image and its buffer. */
8011 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
8012 x_destroy_x_image (ximg
);
8018 #else /* !HAVE_GIF */
8026 Lisp_Object specified_file
, file
;
8027 Lisp_Object specified_data
;
8029 Boolean graphic_p
, movie_p
, prefer_graphic_p
;
8037 Lisp_Object specified_bg
;
8042 TimeScale time_scale
;
8043 TimeValue time
, duration
;
8048 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
8049 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
8051 /* Animated gifs use QuickTime Movie Toolbox. So initialize it here. */
8054 if (NILP (specified_data
))
8056 /* Read from a file */
8060 err
= find_image_fsspec (specified_file
, &file
, &fss
);
8064 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
8069 err
= CanQuickTimeOpenFile (&fss
, kQTFileTypeGIF
, 0,
8070 &graphic_p
, &movie_p
, &prefer_graphic_p
, 0);
8074 if (!graphic_p
&& !movie_p
)
8076 if (prefer_graphic_p
)
8077 return image_load_qt_1 (f
, img
, kQTFileTypeGIF
, &fss
, NULL
);
8078 err
= OpenMovieFile (&fss
, &refnum
, fsRdPerm
);
8081 err
= NewMovieFromFile (&movie
, refnum
, NULL
, NULL
, 0, NULL
);
8082 CloseMovieFile (refnum
);
8085 image_error ("Error reading `%s'", file
, Qnil
);
8091 /* Memory source! */
8093 long file_type_atom
[3];
8095 err
= PtrToHand (SDATA (specified_data
), &dh
, SBYTES (specified_data
));
8098 image_error ("Cannot allocate data handle for `%s'",
8103 file_type_atom
[0] = EndianU32_NtoB (sizeof (long) * 3);
8104 file_type_atom
[1] = EndianU32_NtoB (kDataRefExtensionMacOSFileType
);
8105 file_type_atom
[2] = EndianU32_NtoB (kQTFileTypeGIF
);
8106 err
= PtrToHand (&dh
, &dref
, sizeof (Handle
));
8109 err
= PtrAndHand ("\p", dref
, 1);
8111 err
= PtrAndHand (file_type_atom
, dref
, sizeof (long) * 3);
8114 image_error ("Cannot allocate handle data ref for `%s'", img
->spec
, Qnil
);
8117 err
= CanQuickTimeOpenDataRef (dref
, HandleDataHandlerSubType
, &graphic_p
,
8118 &movie_p
, &prefer_graphic_p
, 0);
8122 if (!graphic_p
&& !movie_p
)
8124 if (prefer_graphic_p
)
8128 DisposeHandle (dref
);
8129 success_p
= image_load_qt_1 (f
, img
, kQTFileTypeGIF
, NULL
, dh
);
8133 err
= NewMovieFromDataRef (&movie
, 0, NULL
, dref
,
8134 HandleDataHandlerSubType
);
8135 DisposeHandle (dref
);
8140 image
= image_spec_value (img
->spec
, QCindex
, NULL
);
8141 ino
= INTEGERP (image
) ? XFASTINT (image
) : 0;
8142 track
= GetMovieIndTrack (movie
, 1);
8143 media
= GetTrackMedia (track
);
8144 nsamples
= GetMediaSampleCount (media
);
8145 if (ino
>= nsamples
)
8147 image_error ("Invalid image number `%s' in image `%s'",
8151 time_scale
= GetMediaTimeScale (media
);
8153 specified_bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
8154 if (!STRINGP (specified_bg
) ||
8155 !mac_defined_color (f
, SDATA (specified_bg
), &color
, 0))
8157 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
8158 color
.red
= RED16_FROM_ULONG (color
.pixel
);
8159 color
.green
= GREEN16_FROM_ULONG (color
.pixel
);
8160 color
.blue
= BLUE16_FROM_ULONG (color
.pixel
);
8162 GetMovieBox (movie
, &rect
);
8163 width
= img
->width
= rect
.right
- rect
.left
;
8164 height
= img
->height
= rect
.bottom
- rect
.top
;
8165 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
8168 GetGWorld (&old_port
, &old_gdh
);
8169 SetGWorld (ximg
, NULL
);
8170 bg_color
.red
= color
.red
;
8171 bg_color
.green
= color
.green
;
8172 bg_color
.blue
= color
.blue
;
8173 RGBBackColor (&bg_color
);
8174 SetGWorld (old_port
, old_gdh
);
8175 SetMovieActive (movie
, 1);
8176 SetMovieGWorld (movie
, ximg
, NULL
);
8177 SampleNumToMediaTime (media
, ino
+ 1, &time
, &duration
);
8178 SetMovieTimeValue (movie
, time
);
8179 MoviesTask (movie
, 0L);
8180 DisposeTrackMedia (media
);
8181 DisposeMovieTrack (track
);
8182 DisposeMovie (movie
);
8186 /* Save GIF image extension data for `image-extension-data'.
8187 Format is (count IMAGES 0xf9 GRAPHIC_CONTROL_EXTENSION_BLOCK). */
8189 Lisp_Object gce
= make_uninit_string (4);
8190 int centisec
= ((float)duration
/ time_scale
) * 100.0f
+ 0.5f
;
8192 /* Fill the delay time field. */
8193 SSET (gce
, 1, centisec
& 0xff);
8194 SSET (gce
, 2, (centisec
>> 8) & 0xff);
8195 /* We don't know about other fields. */
8199 img
->data
.lisp_val
= list4 (Qcount
, make_number (nsamples
),
8200 make_number (0xf9), gce
);
8203 /* Maybe fill in the background field while we have ximg handy. */
8204 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
8205 IMAGE_BACKGROUND (img
, f
, ximg
);
8207 /* Put the image into the pixmap. */
8208 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
8209 x_destroy_x_image (ximg
);
8213 image_error ("Cannot open `%s'", file
, Qnil
);
8216 DisposeTrackMedia (media
);
8218 DisposeMovieTrack (track
);
8220 DisposeMovie (movie
);
8227 #endif /* HAVE_GIF */
8231 /***********************************************************************
8233 ***********************************************************************/
8235 #if defined (HAVE_RSVG)
8237 /* Function prototypes. */
8239 static int svg_image_p
P_ ((Lisp_Object object
));
8240 static int svg_load
P_ ((struct frame
*f
, struct image
*img
));
8242 static int svg_load_image
P_ ((struct frame
*, struct image
*,
8243 unsigned char *, unsigned int));
8245 /* The symbol `svg' identifying images of this type. */
8249 /* Indices of image specification fields in svg_format, below. */
8251 enum svg_keyword_index
8266 /* Vector of image_keyword structures describing the format
8267 of valid user-defined image specifications. */
8269 static struct image_keyword svg_format
[SVG_LAST
] =
8271 {":type", IMAGE_SYMBOL_VALUE
, 1},
8272 {":data", IMAGE_STRING_VALUE
, 0},
8273 {":file", IMAGE_STRING_VALUE
, 0},
8274 {":ascent", IMAGE_ASCENT_VALUE
, 0},
8275 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
8276 {":relief", IMAGE_INTEGER_VALUE
, 0},
8277 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8278 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8279 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8280 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
8283 /* Structure describing the image type `svg'. Its the same type of
8284 structure defined for all image formats, handled by emacs image
8285 functions. See struct image_type in dispextern.h. */
8287 static struct image_type svg_type
=
8289 /* An identifier showing that this is an image structure for the SVG format. */
8291 /* Handle to a function that can be used to identify a SVG file. */
8293 /* Handle to function used to load a SVG file. */
8295 /* Handle to function to free sresources for SVG. */
8297 /* An internal field to link to the next image type in a list of
8298 image types, will be filled in when registering the format. */
8303 /* Return non-zero if OBJECT is a valid SVG image specification. Do
8304 this by calling parse_image_spec and supplying the keywords that
8305 identify the SVG format. */
8308 svg_image_p (object
)
8311 struct image_keyword fmt
[SVG_LAST
];
8312 bcopy (svg_format
, fmt
, sizeof fmt
);
8314 if (!parse_image_spec (object
, fmt
, SVG_LAST
, Qsvg
))
8317 /* Must specify either the :data or :file keyword. */
8318 return fmt
[SVG_FILE
].count
+ fmt
[SVG_DATA
].count
== 1;
8321 #include <librsvg/rsvg.h>
8325 /* SVG library functions. */
8326 DEF_IMGLIB_FN (rsvg_handle_new
);
8327 DEF_IMGLIB_FN (rsvg_handle_set_size_callback
);
8328 DEF_IMGLIB_FN (rsvg_handle_write
);
8329 DEF_IMGLIB_FN (rsvg_handle_close
);
8330 DEF_IMGLIB_FN (rsvg_handle_get_pixbuf
);
8331 DEF_IMGLIB_FN (rsvg_handle_free
);
8333 DEF_IMGLIB_FN (gdk_pixbuf_get_width
);
8334 DEF_IMGLIB_FN (gdk_pixbuf_get_height
);
8335 DEF_IMGLIB_FN (gdk_pixbuf_get_pixels
);
8336 DEF_IMGLIB_FN (gdk_pixbuf_get_rowstride
);
8337 DEF_IMGLIB_FN (gdk_pixbuf_get_colorspace
);
8338 DEF_IMGLIB_FN (gdk_pixbuf_get_n_channels
);
8339 DEF_IMGLIB_FN (gdk_pixbuf_get_has_alpha
);
8340 DEF_IMGLIB_FN (gdk_pixbuf_get_bits_per_sample
);
8342 DEF_IMGLIB_FN (g_type_init
);
8343 DEF_IMGLIB_FN (g_object_unref
);
8344 DEF_IMGLIB_FN (g_error_free
);
8346 Lisp_Object Qgdk_pixbuf
, Qglib
;
8349 init_svg_functions (Lisp_Object libraries
)
8351 HMODULE library
, gdklib
, glib
;
8353 if (!(glib
= w32_delayed_load (libraries
, Qglib
))
8354 || !(gdklib
= w32_delayed_load (libraries
, Qgdk_pixbuf
))
8355 || !(library
= w32_delayed_load (libraries
, Qsvg
)))
8358 LOAD_IMGLIB_FN (library
, rsvg_handle_new
);
8359 LOAD_IMGLIB_FN (library
, rsvg_handle_set_size_callback
);
8360 LOAD_IMGLIB_FN (library
, rsvg_handle_write
);
8361 LOAD_IMGLIB_FN (library
, rsvg_handle_close
);
8362 LOAD_IMGLIB_FN (library
, rsvg_handle_get_pixbuf
);
8363 LOAD_IMGLIB_FN (library
, rsvg_handle_free
);
8365 LOAD_IMGLIB_FN (gdklib
, gdk_pixbuf_get_width
);
8366 LOAD_IMGLIB_FN (gdklib
, gdk_pixbuf_get_height
);
8367 LOAD_IMGLIB_FN (gdklib
, gdk_pixbuf_get_pixels
);
8368 LOAD_IMGLIB_FN (gdklib
, gdk_pixbuf_get_rowstride
);
8369 LOAD_IMGLIB_FN (gdklib
, gdk_pixbuf_get_colorspace
);
8370 LOAD_IMGLIB_FN (gdklib
, gdk_pixbuf_get_n_channels
);
8371 LOAD_IMGLIB_FN (gdklib
, gdk_pixbuf_get_has_alpha
);
8372 LOAD_IMGLIB_FN (gdklib
, gdk_pixbuf_get_bits_per_sample
);
8374 LOAD_IMGLIB_FN (glib
, g_type_init
);
8375 LOAD_IMGLIB_FN (glib
, g_object_unref
);
8376 LOAD_IMGLIB_FN (glib
, g_error_free
);
8381 /* The following aliases for library functions allow dynamic loading
8382 to be used on some platforms. */
8383 #define fn_rsvg_handle_new rsvg_handle_new
8384 #define fn_rsvg_handle_set_size_callback rsvg_handle_set_size_callback
8385 #define fn_rsvg_handle_write rsvg_handle_write
8386 #define fn_rsvg_handle_close rsvg_handle_close
8387 #define fn_rsvg_handle_get_pixbuf rsvg_handle_get_pixbuf
8388 #define fn_rsvg_handle_free rsvg_handle_free
8390 #define fn_gdk_pixbuf_get_width gdk_pixbuf_get_width
8391 #define fn_gdk_pixbuf_get_height gdk_pixbuf_get_height
8392 #define fn_gdk_pixbuf_get_pixels gdk_pixbuf_get_pixels
8393 #define fn_gdk_pixbuf_get_rowstride gdk_pixbuf_get_rowstride
8394 #define fn_gdk_pixbuf_get_colorspace gdk_pixbuf_get_colorspace
8395 #define fn_gdk_pixbuf_get_n_channels gdk_pixbuf_get_n_channels
8396 #define fn_gdk_pixbuf_get_has_alpha gdk_pixbuf_get_has_alpha
8397 #define fn_gdk_pixbuf_get_bits_per_sample gdk_pixbuf_get_bits_per_sample
8399 #define fn_g_type_init g_type_init
8400 #define fn_g_object_unref g_object_unref
8401 #define fn_g_error_free g_error_free
8402 #endif /* !HAVE_NTGUI */
8404 /* Load SVG image IMG for use on frame F. Value is non-zero if
8405 successful. this function will go into the svg_type structure, and
8406 the prototype thus needs to be compatible with that structure. */
8414 Lisp_Object file_name
;
8416 /* If IMG->spec specifies a file name, create a non-file spec from it. */
8417 file_name
= image_spec_value (img
->spec
, QCfile
, NULL
);
8418 if (STRINGP (file_name
))
8421 unsigned char *contents
;
8423 struct gcpro gcpro1
;
8425 file
= x_find_image_file (file_name
);
8427 if (!STRINGP (file
))
8429 image_error ("Cannot find image file `%s'", file_name
, Qnil
);
8434 /* Read the entire file into memory. */
8435 contents
= slurp_file (SDATA (file
), &size
);
8436 if (contents
== NULL
)
8438 image_error ("Error loading SVG image `%s'", img
->spec
, Qnil
);
8442 /* If the file was slurped into memory properly, parse it. */
8443 success_p
= svg_load_image (f
, img
, contents
, size
);
8447 /* Else its not a file, its a lisp object. Load the image from a
8448 lisp object rather than a file. */
8453 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
8454 success_p
= svg_load_image (f
, img
, SDATA (data
), SBYTES (data
));
8460 /* svg_load_image is a helper function for svg_load, which does the
8461 actual loading given contents and size, apart from frame and image
8462 structures, passed from svg_load.
8464 Uses librsvg to do most of the image processing.
8466 Returns non-zero when successful. */
8468 svg_load_image (f
, img
, contents
, size
)
8469 /* Pointer to emacs frame structure. */
8471 /* Pointer to emacs image structure. */
8473 /* String containing the SVG XML data to be parsed. */
8474 unsigned char *contents
;
8475 /* Size of data in bytes. */
8478 RsvgHandle
*rsvg_handle
;
8479 GError
*error
= NULL
;
8483 const guint8
*pixels
;
8486 Lisp_Object specified_bg
;
8491 /* g_type_init is a glib function that must be called prior to using
8492 gnome type library functions. */
8494 /* Make a handle to a new rsvg object. */
8495 rsvg_handle
= fn_rsvg_handle_new ();
8497 /* Parse the contents argument and fill in the rsvg_handle. */
8498 fn_rsvg_handle_write (rsvg_handle
, contents
, size
, &error
);
8502 /* The parsing is complete, rsvg_handle is ready to used, close it
8503 for further writes. */
8504 fn_rsvg_handle_close (rsvg_handle
, &error
);
8507 /* We can now get a valid pixel buffer from the svg file, if all
8509 pixbuf
= fn_rsvg_handle_get_pixbuf (rsvg_handle
);
8512 /* Extract some meta data from the svg handle. */
8513 width
= fn_gdk_pixbuf_get_width (pixbuf
);
8514 height
= fn_gdk_pixbuf_get_height (pixbuf
);
8515 pixels
= fn_gdk_pixbuf_get_pixels (pixbuf
);
8516 rowstride
= fn_gdk_pixbuf_get_rowstride (pixbuf
);
8518 /* Validate the svg meta data. */
8519 eassert (fn_gdk_pixbuf_get_colorspace (pixbuf
) == GDK_COLORSPACE_RGB
);
8520 eassert (fn_gdk_pixbuf_get_n_channels (pixbuf
) == 4);
8521 eassert (fn_gdk_pixbuf_get_has_alpha (pixbuf
));
8522 eassert (fn_gdk_pixbuf_get_bits_per_sample (pixbuf
) == 8);
8524 /* Try to create a x pixmap to hold the svg pixmap. */
8525 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
8527 fn_g_object_unref (pixbuf
);
8531 init_color_table ();
8533 /* Handle alpha channel by combining the image with a background
8535 specified_bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
8536 if (STRINGP (specified_bg
)
8537 && x_defined_color (f
, SDATA (specified_bg
), &background
, 0))
8539 background
.red
>>= 8;
8540 background
.green
>>= 8;
8541 background
.blue
>>= 8;
8545 #ifdef HAVE_X_WINDOWS
8546 background
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
8547 x_query_color (f
, &background
);
8549 /* SVG pixmaps specify transparency in the last byte, so right
8550 shift 8 bits to get rid of it, since emacs doesn't support
8552 background
.red
>>= 8;
8553 background
.green
>>= 8;
8554 background
.blue
>>= 8;
8555 #elif defined (MAC_OS)
8556 background
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
8557 background
.red
= RED_FROM_ULONG (background
.pixel
);
8558 background
.green
= GREEN_FROM_ULONG (background
.pixel
);
8559 background
.blue
= BLUE_FROM_ULONG (background
.pixel
);
8560 #elif defined (HAVE_NTGUI)
8561 background
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
8562 #if 0 /* W32 TODO : Colormap support. */
8563 x_query_color (f
, &background
);
8566 /* SVG pixmaps specify transparency in the last byte, so right
8567 shift 8 bits to get rid of it, since emacs doesn't support
8569 background
.red
>>= 8;
8570 background
.green
>>= 8;
8571 background
.blue
>>= 8;
8572 #else /* not HAVE_X_WINDOWS && not MAC_OS*/
8577 /* This loop handles opacity values, since Emacs assumes
8578 non-transparent images. Each pixel must be "flattened" by
8579 calculating the resulting color, given the transparency of the
8580 pixel, and the image background color. */
8581 for (y
= 0; y
< height
; ++y
)
8583 for (x
= 0; x
< width
; ++x
)
8593 opacity
= *pixels
++;
8595 red
= ((red
* opacity
)
8596 + (background
.red
* ((1 << 8) - opacity
)));
8597 green
= ((green
* opacity
)
8598 + (background
.green
* ((1 << 8) - opacity
)));
8599 blue
= ((blue
* opacity
)
8600 + (background
.blue
* ((1 << 8) - opacity
)));
8602 XPutPixel (ximg
, x
, y
, lookup_rgb_color (f
, red
, green
, blue
));
8605 pixels
+= rowstride
- 4 * width
;
8608 #ifdef COLOR_TABLE_SUPPORT
8609 /* Remember colors allocated for this image. */
8610 img
->colors
= colors_in_color_table (&img
->ncolors
);
8611 free_color_table ();
8612 #endif /* COLOR_TABLE_SUPPORT */
8614 fn_g_object_unref (pixbuf
);
8617 img
->height
= height
;
8619 /* Maybe fill in the background field while we have ximg handy.
8620 Casting avoids a GCC warning. */
8621 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
8623 /* Put the image into the pixmap, then free the X image and its
8625 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
8626 x_destroy_x_image (ximg
);
8631 /* FIXME: Use error->message so the user knows what is the actual
8632 problem with the image. */
8633 image_error ("Error parsing SVG image `%s'", img
->spec
, Qnil
);
8634 fn_g_error_free (error
);
8638 #endif /* defined (HAVE_RSVG) */
8643 /***********************************************************************
8645 ***********************************************************************/
8647 #ifdef HAVE_X_WINDOWS
8648 #define HAVE_GHOSTSCRIPT 1
8649 #endif /* HAVE_X_WINDOWS */
8651 /* The symbol `postscript' identifying images of this type. */
8653 Lisp_Object Qpostscript
;
8655 #ifdef HAVE_GHOSTSCRIPT
8657 static int gs_image_p
P_ ((Lisp_Object object
));
8658 static int gs_load
P_ ((struct frame
*f
, struct image
*img
));
8659 static void gs_clear_image
P_ ((struct frame
*f
, struct image
*img
));
8661 /* Keyword symbols. */
8663 Lisp_Object QCloader
, QCbounding_box
, QCpt_width
, QCpt_height
;
8665 /* Indices of image specification fields in gs_format, below. */
8667 enum gs_keyword_index
8685 /* Vector of image_keyword structures describing the format
8686 of valid user-defined image specifications. */
8688 static struct image_keyword gs_format
[GS_LAST
] =
8690 {":type", IMAGE_SYMBOL_VALUE
, 1},
8691 {":pt-width", IMAGE_POSITIVE_INTEGER_VALUE
, 1},
8692 {":pt-height", IMAGE_POSITIVE_INTEGER_VALUE
, 1},
8693 {":file", IMAGE_STRING_VALUE
, 1},
8694 {":loader", IMAGE_FUNCTION_VALUE
, 0},
8695 {":bounding-box", IMAGE_DONT_CHECK_VALUE_TYPE
, 1},
8696 {":ascent", IMAGE_ASCENT_VALUE
, 0},
8697 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
8698 {":relief", IMAGE_INTEGER_VALUE
, 0},
8699 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8700 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8701 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8702 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
8705 /* Structure describing the image type `ghostscript'. */
8707 static struct image_type gs_type
=
8717 /* Free X resources of Ghostscript image IMG which is used on frame F. */
8720 gs_clear_image (f
, img
)
8724 /* IMG->data.ptr_val may contain a recorded colormap. */
8725 xfree (img
->data
.ptr_val
);
8726 x_clear_image (f
, img
);
8730 /* Return non-zero if OBJECT is a valid Ghostscript image
8737 struct image_keyword fmt
[GS_LAST
];
8741 bcopy (gs_format
, fmt
, sizeof fmt
);
8743 if (!parse_image_spec (object
, fmt
, GS_LAST
, Qpostscript
))
8746 /* Bounding box must be a list or vector containing 4 integers. */
8747 tem
= fmt
[GS_BOUNDING_BOX
].value
;
8750 for (i
= 0; i
< 4; ++i
, tem
= XCDR (tem
))
8751 if (!CONSP (tem
) || !INTEGERP (XCAR (tem
)))
8756 else if (VECTORP (tem
))
8758 if (XVECTOR (tem
)->size
!= 4)
8760 for (i
= 0; i
< 4; ++i
)
8761 if (!INTEGERP (XVECTOR (tem
)->contents
[i
]))
8771 /* Load Ghostscript image IMG for use on frame F. Value is non-zero
8780 Lisp_Object window_and_pixmap_id
= Qnil
, loader
, pt_height
, pt_width
;
8781 struct gcpro gcpro1
, gcpro2
;
8783 double in_width
, in_height
;
8784 Lisp_Object pixel_colors
= Qnil
;
8786 /* Compute pixel size of pixmap needed from the given size in the
8787 image specification. Sizes in the specification are in pt. 1 pt
8788 = 1/72 in, xdpi and ydpi are stored in the frame's X display
8790 pt_width
= image_spec_value (img
->spec
, QCpt_width
, NULL
);
8791 in_width
= XFASTINT (pt_width
) / 72.0;
8792 img
->width
= in_width
* FRAME_X_DISPLAY_INFO (f
)->resx
;
8793 pt_height
= image_spec_value (img
->spec
, QCpt_height
, NULL
);
8794 in_height
= XFASTINT (pt_height
) / 72.0;
8795 img
->height
= in_height
* FRAME_X_DISPLAY_INFO (f
)->resy
;
8797 if (!check_image_size (f
, img
->width
, img
->height
))
8799 image_error ("Invalid image size", Qnil
, Qnil
);
8803 /* Create the pixmap. */
8804 xassert (img
->pixmap
== NO_PIXMAP
);
8806 /* Only W32 version did BLOCK_INPUT here. ++kfs */
8808 img
->pixmap
= XCreatePixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
8809 img
->width
, img
->height
,
8810 DefaultDepthOfScreen (FRAME_X_SCREEN (f
)));
8815 image_error ("Unable to create pixmap for `%s'", img
->spec
, Qnil
);
8819 /* Call the loader to fill the pixmap. It returns a process object
8820 if successful. We do not record_unwind_protect here because
8821 other places in redisplay like calling window scroll functions
8822 don't either. Let the Lisp loader use `unwind-protect' instead. */
8823 GCPRO2 (window_and_pixmap_id
, pixel_colors
);
8825 sprintf (buffer
, "%lu %lu",
8826 (unsigned long) FRAME_X_WINDOW (f
),
8827 (unsigned long) img
->pixmap
);
8828 window_and_pixmap_id
= build_string (buffer
);
8830 sprintf (buffer
, "%lu %lu",
8831 FRAME_FOREGROUND_PIXEL (f
),
8832 FRAME_BACKGROUND_PIXEL (f
));
8833 pixel_colors
= build_string (buffer
);
8835 XSETFRAME (frame
, f
);
8836 loader
= image_spec_value (img
->spec
, QCloader
, NULL
);
8838 loader
= intern ("gs-load-image");
8840 img
->data
.lisp_val
= call6 (loader
, frame
, img
->spec
,
8841 make_number (img
->width
),
8842 make_number (img
->height
),
8843 window_and_pixmap_id
,
8846 return PROCESSP (img
->data
.lisp_val
);
8850 /* Kill the Ghostscript process that was started to fill PIXMAP on
8851 frame F. Called from XTread_socket when receiving an event
8852 telling Emacs that Ghostscript has finished drawing. */
8855 x_kill_gs_process (pixmap
, f
)
8859 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
8863 /* Find the image containing PIXMAP. */
8864 for (i
= 0; i
< c
->used
; ++i
)
8865 if (c
->images
[i
]->pixmap
== pixmap
)
8868 /* Should someone in between have cleared the image cache, for
8869 instance, give up. */
8873 /* Kill the GS process. We should have found PIXMAP in the image
8874 cache and its image should contain a process object. */
8876 xassert (PROCESSP (img
->data
.lisp_val
));
8877 Fkill_process (img
->data
.lisp_val
, Qnil
);
8878 img
->data
.lisp_val
= Qnil
;
8880 #if defined (HAVE_X_WINDOWS)
8882 /* On displays with a mutable colormap, figure out the colors
8883 allocated for the image by looking at the pixels of an XImage for
8885 class = FRAME_X_VISUAL (f
)->class;
8886 if (class != StaticColor
&& class != StaticGray
&& class != TrueColor
)
8892 /* Try to get an XImage for img->pixmep. */
8893 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
8894 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
8899 /* Initialize the color table. */
8900 init_color_table ();
8902 /* For each pixel of the image, look its color up in the
8903 color table. After having done so, the color table will
8904 contain an entry for each color used by the image. */
8905 for (y
= 0; y
< img
->height
; ++y
)
8906 for (x
= 0; x
< img
->width
; ++x
)
8908 unsigned long pixel
= XGetPixel (ximg
, x
, y
);
8909 lookup_pixel_color (f
, pixel
);
8912 /* Record colors in the image. Free color table and XImage. */
8913 #ifdef COLOR_TABLE_SUPPORT
8914 img
->colors
= colors_in_color_table (&img
->ncolors
);
8915 free_color_table ();
8917 XDestroyImage (ximg
);
8919 #if 0 /* This doesn't seem to be the case. If we free the colors
8920 here, we get a BadAccess later in x_clear_image when
8921 freeing the colors. */
8922 /* We have allocated colors once, but Ghostscript has also
8923 allocated colors on behalf of us. So, to get the
8924 reference counts right, free them once. */
8926 x_free_colors (f
, img
->colors
, img
->ncolors
);
8930 image_error ("Cannot get X image of `%s'; colors will not be freed",
8935 #endif /* HAVE_X_WINDOWS */
8937 /* Now that we have the pixmap, compute mask and transform the
8938 image if requested. */
8940 postprocess_image (f
, img
);
8944 #endif /* HAVE_GHOSTSCRIPT */
8947 /***********************************************************************
8949 ***********************************************************************/
8953 DEFUN ("imagep", Fimagep
, Simagep
, 1, 1, 0,
8954 doc
: /* Value is non-nil if SPEC is a valid image specification. */)
8958 return valid_image_p (spec
) ? Qt
: Qnil
;
8962 DEFUN ("lookup-image", Flookup_image
, Slookup_image
, 1, 1, 0, "")
8968 if (valid_image_p (spec
))
8969 id
= lookup_image (SELECTED_FRAME (), spec
);
8972 return make_number (id
);
8975 #endif /* GLYPH_DEBUG != 0 */
8978 /***********************************************************************
8980 ***********************************************************************/
8983 /* Image types that rely on external libraries are loaded dynamically
8984 if the library is available. */
8985 #define CHECK_LIB_AVAILABLE(image_type, init_lib_fn, libraries) \
8986 define_image_type (image_type, init_lib_fn (libraries))
8988 #define CHECK_LIB_AVAILABLE(image_type, init_lib_fn, libraries) \
8989 define_image_type (image_type, 1)
8990 #endif /* HAVE_NTGUI */
8992 DEFUN ("init-image-library", Finit_image_library
, Sinit_image_library
, 2, 2, 0,
8993 doc
: /* Initialize image library implementing image type TYPE.
8994 Return non-nil if TYPE is a supported image type.
8996 Image types pbm and xbm are prebuilt; other types are loaded here.
8997 Libraries to load are specified in alist LIBRARIES (usually, the value
8998 of `image-library-alist', which see). */)
9000 Lisp_Object type
, libraries
;
9004 /* Don't try to reload the library. */
9005 tested
= Fassq (type
, Vimage_type_cache
);
9007 return XCDR (tested
);
9009 #if defined (HAVE_XPM) || defined (MAC_OS)
9010 if (EQ (type
, Qxpm
))
9011 return CHECK_LIB_AVAILABLE (&xpm_type
, init_xpm_functions
, libraries
);
9014 #if defined (HAVE_JPEG) || defined (MAC_OS)
9015 if (EQ (type
, Qjpeg
))
9016 return CHECK_LIB_AVAILABLE (&jpeg_type
, init_jpeg_functions
, libraries
);
9019 #if defined (HAVE_TIFF) || defined (MAC_OS)
9020 if (EQ (type
, Qtiff
))
9021 return CHECK_LIB_AVAILABLE (&tiff_type
, init_tiff_functions
, libraries
);
9024 #if defined (HAVE_GIF) || defined (MAC_OS)
9025 if (EQ (type
, Qgif
))
9026 return CHECK_LIB_AVAILABLE (&gif_type
, init_gif_functions
, libraries
);
9029 #if defined (HAVE_PNG) || defined (MAC_OS)
9030 if (EQ (type
, Qpng
))
9031 return CHECK_LIB_AVAILABLE (&png_type
, init_png_functions
, libraries
);
9034 #if defined (HAVE_RSVG)
9035 if (EQ (type
, Qsvg
))
9036 return CHECK_LIB_AVAILABLE (&svg_type
, init_svg_functions
, libraries
);
9039 #ifdef HAVE_GHOSTSCRIPT
9040 if (EQ (type
, Qpostscript
))
9041 return CHECK_LIB_AVAILABLE (&gs_type
, init_gs_functions
, libraries
);
9044 /* If the type is not recognized, avoid testing it ever again. */
9045 CACHE_IMAGE_TYPE (type
, Qnil
);
9052 extern Lisp_Object Qrisky_local_variable
; /* Syms_of_xdisp has already run. */
9054 /* Initialize this only once, since that's what we do with Vimage_types
9055 and they are supposed to be in sync. Initializing here gives correct
9056 operation on GNU/Linux of calling dump-emacs after loading some images. */
9059 /* Must be defined now becase we're going to update it below, while
9060 defining the supported image types. */
9061 DEFVAR_LISP ("image-types", &Vimage_types
,
9062 doc
: /* List of potentially supported image types.
9063 Each element of the list is a symbol for an image type, like 'jpeg or 'png.
9064 To check whether it is really supported, use `image-type-available-p'. */);
9065 Vimage_types
= Qnil
;
9067 DEFVAR_LISP ("image-library-alist", &Vimage_library_alist
,
9068 doc
: /* Alist of image types vs external libraries needed to display them.
9070 Each element is a list (IMAGE-TYPE LIBRARY...), where the car is a symbol
9071 representing a supported image type, and the rest are strings giving
9072 alternate filenames for the corresponding external libraries.
9074 Emacs tries to load the libraries in the order they appear on the
9075 list; if none is loaded, the running session of Emacs won't
9076 support the image type. Types 'pbm and 'xbm don't need to be
9077 listed; they are always supported. */);
9078 Vimage_library_alist
= Qnil
;
9079 Fput (intern ("image-library-alist"), Qrisky_local_variable
, Qt
);
9081 DEFVAR_LISP ("max-image-size", &Vmax_image_size
,
9082 doc
: /* Maximum size of images.
9083 Emacs will not load an image into memory if its pixel width or
9084 pixel height exceeds this limit.
9086 If the value is an integer, it directly specifies the maximum
9087 image height and width, measured in pixels. If it is a floating
9088 point number, it specifies the maximum image height and width
9089 as a ratio to the frame height and width. If the value is
9090 non-numeric, there is no explicit limit on the size of images. */);
9091 Vmax_image_size
= make_float (MAX_IMAGE_SIZE
);
9093 Vimage_type_cache
= Qnil
;
9094 staticpro (&Vimage_type_cache
);
9096 Qpbm
= intern ("pbm");
9098 ADD_IMAGE_TYPE (Qpbm
);
9100 Qxbm
= intern ("xbm");
9102 ADD_IMAGE_TYPE (Qxbm
);
9104 define_image_type (&xbm_type
, 1);
9105 define_image_type (&pbm_type
, 1);
9107 Qcount
= intern ("count");
9108 staticpro (&Qcount
);
9110 QCascent
= intern (":ascent");
9111 staticpro (&QCascent
);
9112 QCmargin
= intern (":margin");
9113 staticpro (&QCmargin
);
9114 QCrelief
= intern (":relief");
9115 staticpro (&QCrelief
);
9116 QCconversion
= intern (":conversion");
9117 staticpro (&QCconversion
);
9118 QCcolor_symbols
= intern (":color-symbols");
9119 staticpro (&QCcolor_symbols
);
9120 QCheuristic_mask
= intern (":heuristic-mask");
9121 staticpro (&QCheuristic_mask
);
9122 QCindex
= intern (":index");
9123 staticpro (&QCindex
);
9124 QCmatrix
= intern (":matrix");
9125 staticpro (&QCmatrix
);
9126 QCcolor_adjustment
= intern (":color-adjustment");
9127 staticpro (&QCcolor_adjustment
);
9128 QCmask
= intern (":mask");
9129 staticpro (&QCmask
);
9131 Qlaplace
= intern ("laplace");
9132 staticpro (&Qlaplace
);
9133 Qemboss
= intern ("emboss");
9134 staticpro (&Qemboss
);
9135 Qedge_detection
= intern ("edge-detection");
9136 staticpro (&Qedge_detection
);
9137 Qheuristic
= intern ("heuristic");
9138 staticpro (&Qheuristic
);
9140 Qpostscript
= intern ("postscript");
9141 staticpro (&Qpostscript
);
9142 #ifdef HAVE_GHOSTSCRIPT
9143 ADD_IMAGE_TYPE (Qpostscript
);
9144 QCloader
= intern (":loader");
9145 staticpro (&QCloader
);
9146 QCbounding_box
= intern (":bounding-box");
9147 staticpro (&QCbounding_box
);
9148 QCpt_width
= intern (":pt-width");
9149 staticpro (&QCpt_width
);
9150 QCpt_height
= intern (":pt-height");
9151 staticpro (&QCpt_height
);
9152 #endif /* HAVE_GHOSTSCRIPT */
9154 #if defined (HAVE_XPM) || defined (MAC_OS)
9155 Qxpm
= intern ("xpm");
9157 ADD_IMAGE_TYPE (Qxpm
);
9160 #if defined (HAVE_JPEG) || defined (MAC_OS)
9161 Qjpeg
= intern ("jpeg");
9163 ADD_IMAGE_TYPE (Qjpeg
);
9166 #if defined (HAVE_TIFF) || defined (MAC_OS)
9167 Qtiff
= intern ("tiff");
9169 ADD_IMAGE_TYPE (Qtiff
);
9172 #if defined (HAVE_GIF) || defined (MAC_OS)
9173 Qgif
= intern ("gif");
9175 ADD_IMAGE_TYPE (Qgif
);
9178 #if defined (HAVE_PNG) || defined (MAC_OS)
9179 Qpng
= intern ("png");
9181 ADD_IMAGE_TYPE (Qpng
);
9184 #if defined (HAVE_RSVG)
9185 Qsvg
= intern ("svg");
9187 ADD_IMAGE_TYPE (Qsvg
);
9189 Qgdk_pixbuf
= intern ("gdk-pixbuf");
9190 staticpro (&Qgdk_pixbuf
);
9191 Qglib
= intern ("glib");
9193 #endif /* HAVE_NTGUI */
9194 #endif /* HAVE_RSVG */
9196 defsubr (&Sinit_image_library
);
9197 defsubr (&Sclear_image_cache
);
9198 defsubr (&Simage_refresh
);
9199 defsubr (&Simage_size
);
9200 defsubr (&Simage_mask_p
);
9201 defsubr (&Simage_extension_data
);
9205 defsubr (&Slookup_image
);
9208 DEFVAR_BOOL ("cross-disabled-images", &cross_disabled_images
,
9209 doc
: /* Non-nil means always draw a cross over disabled images.
9210 Disabled images are those having a `:conversion disabled' property.
9211 A cross is always drawn on black & white displays. */);
9212 cross_disabled_images
= 0;
9214 DEFVAR_LISP ("x-bitmap-file-path", &Vx_bitmap_file_path
,
9215 doc
: /* List of directories to search for window system bitmap files. */);
9216 Vx_bitmap_file_path
= decode_env_path ((char *) 0, PATH_BITMAPS
);
9218 DEFVAR_LISP ("image-cache-eviction-delay", &Vimage_cache_eviction_delay
,
9219 doc
: /* Time after which cached images are removed from the cache.
9220 When an image has not been displayed this many seconds, remove it
9221 from the image cache. Value must be an integer or nil with nil
9222 meaning don't clear the cache. */);
9223 Vimage_cache_eviction_delay
= make_number (30 * 60);
9229 #if defined (MAC_OSX) && TARGET_API_MAC_CARBON
9230 init_image_func_pointer ();
9234 /* arch-tag: 123c2a5e-14a8-4c53-ab95-af47d7db49b9
9235 (do not change this comment) */