1 /* Functions for image support on window system.
2 Copyright (C) 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
4 Free Software Foundation, Inc.
6 This file is part of GNU Emacs.
8 GNU Emacs is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 GNU Emacs is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU Emacs; see the file COPYING. If not, write to
20 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
21 Boston, MA 02110-1301, USA. */
32 /* This makes the fields of a Display accessible, in Xlib header files. */
34 #define XLIB_ILLEGAL_ACCESS
39 #include "dispextern.h"
40 #include "blockinput.h"
45 #include "termhooks.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
);
1187 Lisp_Object file
= image_spec_value (spec
, QCfile
, NULL
);
1189 xassert (valid_image_p (spec
));
1190 bzero (img
, sizeof *img
);
1191 img
->dependencies
= NILP (file
) ? Qnil
: list1 (file
);
1192 img
->type
= lookup_image_type (image_spec_value (spec
, QCtype
, NULL
));
1193 xassert (img
->type
!= NULL
);
1195 img
->data
.lisp_val
= Qnil
;
1196 img
->ascent
= DEFAULT_IMAGE_ASCENT
;
1198 img
->corners
[BOT_CORNER
] = -1; /* Full image */
1203 /* Free image IMG which was used on frame F, including its resources. */
1212 struct image_cache
*c
= FRAME_IMAGE_CACHE (f
);
1214 /* Remove IMG from the hash table of its cache. */
1216 img
->prev
->next
= img
->next
;
1218 c
->buckets
[img
->hash
% IMAGE_CACHE_BUCKETS_SIZE
] = img
->next
;
1221 img
->next
->prev
= img
->prev
;
1223 c
->images
[img
->id
] = NULL
;
1225 /* Free resources, then free IMG. */
1226 img
->type
->free (f
, img
);
1231 /* Return 1 if the given widths and heights are valid for display;
1232 otherwise, return 0. */
1235 check_image_size (f
, width
, height
)
1242 if (width
<= 0 || height
<= 0)
1245 if (INTEGERP (Vmax_image_size
))
1246 w
= h
= XINT (Vmax_image_size
);
1247 else if (FLOATP (Vmax_image_size
))
1251 w
= FRAME_PIXEL_WIDTH (f
);
1252 h
= FRAME_PIXEL_HEIGHT (f
);
1255 w
= h
= 1024; /* Arbitrary size for unknown frame. */
1256 w
= (int) (XFLOAT_DATA (Vmax_image_size
) * w
);
1257 h
= (int) (XFLOAT_DATA (Vmax_image_size
) * h
);
1262 return (width
<= w
&& height
<= h
);
1265 /* Prepare image IMG for display on frame F. Must be called before
1266 drawing an image. */
1269 prepare_image_for_display (f
, img
)
1275 /* We're about to display IMG, so set its timestamp to `now'. */
1277 img
->timestamp
= EMACS_SECS (t
);
1279 /* If IMG doesn't have a pixmap yet, load it now, using the image
1280 type dependent loader function. */
1281 if (img
->pixmap
== NO_PIXMAP
&& !img
->load_failed_p
)
1282 img
->load_failed_p
= img
->type
->load (f
, img
) == 0;
1284 #if defined (MAC_OS) && USE_CG_DRAWING
1285 if (!img
->load_failed_p
&& img
->data
.ptr_val
== NULL
)
1287 img
->data
.ptr_val
= mac_create_cg_image_from_image (f
, img
);
1288 if (img
->data
.ptr_val
== NULL
)
1290 img
->load_failed_p
= 1;
1291 img
->type
->free (f
, img
);
1298 /* Value is the number of pixels for the ascent of image IMG when
1299 drawn in face FACE. */
1302 image_ascent (img
, face
, slice
)
1305 struct glyph_slice
*slice
;
1310 if (slice
->height
== img
->height
)
1311 height
= img
->height
+ img
->vmargin
;
1312 else if (slice
->y
== 0)
1313 height
= slice
->height
+ img
->vmargin
;
1315 height
= slice
->height
;
1317 if (img
->ascent
== CENTERED_IMAGE_ASCENT
)
1322 /* W32 specific version. Why?. ++kfs */
1323 ascent
= height
/ 2 - (FONT_DESCENT (face
->font
)
1324 - FONT_BASE (face
->font
)) / 2;
1326 /* This expression is arranged so that if the image can't be
1327 exactly centered, it will be moved slightly up. This is
1328 because a typical font is `top-heavy' (due to the presence
1329 uppercase letters), so the image placement should err towards
1330 being top-heavy too. It also just generally looks better. */
1331 ascent
= (height
+ face
->font
->ascent
- face
->font
->descent
+ 1) / 2;
1332 #endif /* HAVE_NTGUI */
1335 ascent
= height
/ 2;
1338 ascent
= (int) (height
* img
->ascent
/ 100.0);
1344 /* Image background colors. */
1346 /* Find the "best" corner color of a bitmap.
1347 On W32, XIMG is assumed to a device context with the bitmap selected. */
1349 static RGB_PIXEL_COLOR
1350 four_corners_best (ximg
, corners
, width
, height
)
1351 XImagePtr_or_DC ximg
;
1353 unsigned long width
, height
;
1355 RGB_PIXEL_COLOR corner_pixels
[4], best
;
1358 if (corners
&& corners
[BOT_CORNER
] >= 0)
1360 /* Get the colors at the corner_pixels of ximg. */
1361 corner_pixels
[0] = GET_PIXEL (ximg
, corners
[LEFT_CORNER
], corners
[TOP_CORNER
]);
1362 corner_pixels
[1] = GET_PIXEL (ximg
, corners
[RIGHT_CORNER
] - 1, corners
[TOP_CORNER
]);
1363 corner_pixels
[2] = GET_PIXEL (ximg
, corners
[RIGHT_CORNER
] - 1, corners
[BOT_CORNER
] - 1);
1364 corner_pixels
[3] = GET_PIXEL (ximg
, corners
[LEFT_CORNER
], corners
[BOT_CORNER
] - 1);
1368 /* Get the colors at the corner_pixels of ximg. */
1369 corner_pixels
[0] = GET_PIXEL (ximg
, 0, 0);
1370 corner_pixels
[1] = GET_PIXEL (ximg
, width
- 1, 0);
1371 corner_pixels
[2] = GET_PIXEL (ximg
, width
- 1, height
- 1);
1372 corner_pixels
[3] = GET_PIXEL (ximg
, 0, height
- 1);
1374 /* Choose the most frequently found color as background. */
1375 for (i
= best_count
= 0; i
< 4; ++i
)
1379 for (j
= n
= 0; j
< 4; ++j
)
1380 if (corner_pixels
[i
] == corner_pixels
[j
])
1384 best
= corner_pixels
[i
], best_count
= n
;
1390 /* Portability macros */
1394 #define Destroy_Image(img_dc, prev) \
1395 do { SelectObject (img_dc, prev); DeleteDC (img_dc); } while (0)
1397 #define Free_Pixmap(display, pixmap) \
1398 DeleteObject (pixmap)
1402 #define Destroy_Image(ximg, dummy) \
1403 XDestroyImage (ximg)
1405 #define Free_Pixmap(display, pixmap) \
1406 XFreePixmap (display, pixmap)
1408 #endif /* HAVE_NTGUI */
1411 /* Return the `background' field of IMG. If IMG doesn't have one yet,
1412 it is guessed heuristically. If non-zero, XIMG is an existing
1413 XImage object (or device context with the image selected on W32) to
1414 use for the heuristic. */
1417 image_background (img
, f
, ximg
)
1420 XImagePtr_or_DC ximg
;
1422 if (! img
->background_valid
)
1423 /* IMG doesn't have a background yet, try to guess a reasonable value. */
1425 int free_ximg
= !ximg
;
1428 #endif /* HAVE_NTGUI */
1433 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
1434 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
1436 HDC frame_dc
= get_frame_dc (f
);
1437 ximg
= CreateCompatibleDC (frame_dc
);
1438 release_frame_dc (f
, frame_dc
);
1439 prev
= SelectObject (ximg
, img
->pixmap
);
1440 #endif /* !HAVE_NTGUI */
1443 img
->background
= four_corners_best (ximg
, img
->corners
, img
->width
, img
->height
);
1446 Destroy_Image (ximg
, prev
);
1448 img
->background_valid
= 1;
1451 return img
->background
;
1454 /* Return the `background_transparent' field of IMG. If IMG doesn't
1455 have one yet, it is guessed heuristically. If non-zero, MASK is an
1456 existing XImage object to use for the heuristic. */
1459 image_background_transparent (img
, f
, mask
)
1462 XImagePtr_or_DC mask
;
1464 if (! img
->background_transparent_valid
)
1465 /* IMG doesn't have a background yet, try to guess a reasonable value. */
1469 int free_mask
= !mask
;
1472 #endif /* HAVE_NTGUI */
1477 mask
= XGetImage (FRAME_X_DISPLAY (f
), img
->mask
,
1478 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
1480 HDC frame_dc
= get_frame_dc (f
);
1481 mask
= CreateCompatibleDC (frame_dc
);
1482 release_frame_dc (f
, frame_dc
);
1483 prev
= SelectObject (mask
, img
->mask
);
1484 #endif /* HAVE_NTGUI */
1487 img
->background_transparent
1488 = (four_corners_best (mask
, img
->corners
, img
->width
, img
->height
) == PIX_MASK_RETAIN
);
1491 Destroy_Image (mask
, prev
);
1494 img
->background_transparent
= 0;
1496 img
->background_transparent_valid
= 1;
1499 return img
->background_transparent
;
1503 /***********************************************************************
1504 Helper functions for X image types
1505 ***********************************************************************/
1507 static void x_clear_image_1
P_ ((struct frame
*, struct image
*, int,
1509 static void x_clear_image
P_ ((struct frame
*f
, struct image
*img
));
1510 static unsigned long x_alloc_image_color
P_ ((struct frame
*f
,
1512 Lisp_Object color_name
,
1513 unsigned long dflt
));
1516 /* Clear X resources of image IMG on frame F. PIXMAP_P non-zero means
1517 free the pixmap if any. MASK_P non-zero means clear the mask
1518 pixmap if any. COLORS_P non-zero means free colors allocated for
1519 the image, if any. */
1522 x_clear_image_1 (f
, img
, pixmap_p
, mask_p
, colors_p
)
1525 int pixmap_p
, mask_p
, colors_p
;
1527 if (pixmap_p
&& img
->pixmap
)
1529 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->pixmap
);
1530 img
->pixmap
= NO_PIXMAP
;
1531 img
->background_valid
= 0;
1534 if (mask_p
&& img
->mask
)
1536 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
1537 img
->mask
= NO_PIXMAP
;
1538 img
->background_transparent_valid
= 0;
1541 if (colors_p
&& img
->ncolors
)
1543 /* MAC_TODO: color table support. */
1544 /* W32_TODO: color table support. */
1545 #ifdef HAVE_X_WINDOWS
1546 x_free_colors (f
, img
->colors
, img
->ncolors
);
1547 #endif /* HAVE_X_WINDOWS */
1548 xfree (img
->colors
);
1553 #if defined (MAC_OS) && USE_CG_DRAWING
1554 if (img
->data
.ptr_val
)
1556 CGImageRelease (img
->data
.ptr_val
);
1557 img
->data
.ptr_val
= NULL
;
1562 /* Free X resources of image IMG which is used on frame F. */
1565 x_clear_image (f
, img
)
1570 x_clear_image_1 (f
, img
, 1, 1, 1);
1575 /* Allocate color COLOR_NAME for image IMG on frame F. If color
1576 cannot be allocated, use DFLT. Add a newly allocated color to
1577 IMG->colors, so that it can be freed again. Value is the pixel
1580 static unsigned long
1581 x_alloc_image_color (f
, img
, color_name
, dflt
)
1584 Lisp_Object color_name
;
1588 unsigned long result
;
1590 xassert (STRINGP (color_name
));
1592 if (x_defined_color (f
, SDATA (color_name
), &color
, 1))
1594 /* This isn't called frequently so we get away with simply
1595 reallocating the color vector to the needed size, here. */
1598 (unsigned long *) xrealloc (img
->colors
,
1599 img
->ncolors
* sizeof *img
->colors
);
1600 img
->colors
[img
->ncolors
- 1] = color
.pixel
;
1601 result
= color
.pixel
;
1611 /***********************************************************************
1613 ***********************************************************************/
1615 static struct image
*search_image_cache
P_ ((struct frame
*, Lisp_Object
, unsigned));
1616 static void cache_image
P_ ((struct frame
*f
, struct image
*img
));
1617 static void postprocess_image
P_ ((struct frame
*, struct image
*));
1619 /* Return a new, initialized image cache that is allocated from the
1620 heap. Call free_image_cache to free an image cache. */
1622 struct image_cache
*
1625 struct image_cache
*c
= (struct image_cache
*) xmalloc (sizeof *c
);
1628 bzero (c
, sizeof *c
);
1630 c
->images
= (struct image
**) xmalloc (c
->size
* sizeof *c
->images
);
1631 size
= IMAGE_CACHE_BUCKETS_SIZE
* sizeof *c
->buckets
;
1632 c
->buckets
= (struct image
**) xmalloc (size
);
1633 bzero (c
->buckets
, size
);
1638 /* Find an image matching SPEC in the cache, and return it. If no
1639 image is found, return NULL. */
1640 static struct image
*
1641 search_image_cache (f
, spec
, hash
)
1647 struct image_cache
*c
= FRAME_IMAGE_CACHE (f
);
1648 int i
= hash
% IMAGE_CACHE_BUCKETS_SIZE
;
1650 if (!c
) return NULL
;
1652 /* If the image spec does not specify a background color, the cached
1653 image must have the same background color as the current frame.
1654 The foreground color must also match, for the sake of monochrome
1657 In fact, we could ignore the foreground color matching condition
1658 for color images, or if the image spec specifies :foreground;
1659 similarly we could ignore the background color matching condition
1660 for formats that don't use transparency (such as jpeg), or if the
1661 image spec specifies :background. However, the extra memory
1662 usage is probably negligible in practice, so we don't bother. */
1664 for (img
= c
->buckets
[i
]; img
; img
= img
->next
)
1665 if (img
->hash
== hash
1666 && !NILP (Fequal (img
->spec
, spec
))
1667 && img
->frame_foreground
== FRAME_FOREGROUND_PIXEL (f
)
1668 && img
->frame_background
== FRAME_BACKGROUND_PIXEL (f
))
1674 /* Search frame F for an image with spec SPEC, and free it. */
1677 uncache_image (f
, spec
)
1681 struct image
*img
= search_image_cache (f
, spec
, sxhash (spec
, 0));
1683 free_image (f
, img
);
1687 /* Free image cache of frame F. Be aware that X frames share images
1691 free_image_cache (f
)
1694 struct image_cache
*c
= FRAME_IMAGE_CACHE (f
);
1699 /* Cache should not be referenced by any frame when freed. */
1700 xassert (c
->refcount
== 0);
1702 for (i
= 0; i
< c
->used
; ++i
)
1703 free_image (f
, c
->images
[i
]);
1707 FRAME_IMAGE_CACHE (f
) = NULL
;
1712 /* Clear image cache of frame F. FILTER=t means free all images.
1713 FILTER=nil means clear only images that haven't been
1714 displayed for some time.
1715 Else, only free the images which have FILTER in their `dependencies'.
1716 Should be called from time to time to reduce the number of loaded images.
1717 If image-cache-eviction-delay is non-nil, this frees images in the cache
1718 which weren't displayed for at least that many seconds. */
1721 clear_image_cache (struct frame
*f
, Lisp_Object filter
)
1723 struct image_cache
*c
= FRAME_IMAGE_CACHE (f
);
1725 if (c
&& (!NILP (filter
) || INTEGERP (Vimage_cache_eviction_delay
)))
1732 old
= EMACS_SECS (t
) - XFASTINT (Vimage_cache_eviction_delay
);
1734 /* Block input so that we won't be interrupted by a SIGIO
1735 while being in an inconsistent state. */
1738 for (i
= nfreed
= 0; i
< c
->used
; ++i
)
1740 struct image
*img
= c
->images
[i
];
1742 && (NILP (filter
) ? img
->timestamp
< old
1744 || !NILP (Fmember (filter
, img
->dependencies
)))))
1746 free_image (f
, img
);
1751 /* We may be clearing the image cache because, for example,
1752 Emacs was iconified for a longer period of time. In that
1753 case, current matrices may still contain references to
1754 images freed above. So, clear these matrices. */
1757 Lisp_Object tail
, frame
;
1759 FOR_EACH_FRAME (tail
, frame
)
1761 struct frame
*f
= XFRAME (frame
);
1762 if (FRAME_IMAGE_CACHE (f
) == c
)
1763 clear_current_matrices (f
);
1766 ++windows_or_buffers_changed
;
1774 clear_image_caches (Lisp_Object filter
)
1776 /* FIXME: We want to do
1777 * struct terminal *t;
1778 * for (t = terminal_list; t; t = t->next_terminal)
1779 * clear_image_cache (t, filter); */
1780 Lisp_Object tail
, frame
;
1781 FOR_EACH_FRAME (tail
, frame
)
1782 if (FRAME_WINDOW_P (XFRAME (frame
)))
1783 clear_image_cache (XFRAME (frame
), filter
);
1786 DEFUN ("clear-image-cache", Fclear_image_cache
, Sclear_image_cache
,
1788 doc
: /* Clear the image cache.
1789 FILTER nil or a frame means clear all images in the selected frame.
1790 FILTER t means clear the image caches of all frames.
1791 Anything else, means only clear those images which refer to FILTER,
1792 which is then usually a filename. */)
1796 if (!(EQ (filter
, Qnil
) || FRAMEP (filter
)))
1797 clear_image_caches (filter
);
1799 clear_image_cache (check_x_frame (filter
), Qt
);
1805 DEFUN ("image-refresh", Fimage_refresh
, Simage_refresh
,
1807 doc
: /* Refresh the image with specification SPEC on frame FRAME.
1808 If SPEC specifies an image file, the displayed image is updated with
1809 the current contents of that file.
1810 FRAME nil or omitted means use the selected frame.
1811 FRAME t means refresh the image on all frames. */)
1813 Lisp_Object spec
, frame
;
1815 if (!valid_image_p (spec
))
1816 error ("Invalid image specification");
1821 FOR_EACH_FRAME (tail
, frame
)
1823 struct frame
*f
= XFRAME (frame
);
1824 if (FRAME_WINDOW_P (f
))
1825 uncache_image (f
, spec
);
1829 uncache_image (check_x_frame (frame
), spec
);
1835 /* Compute masks and transform image IMG on frame F, as specified
1836 by the image's specification, */
1839 postprocess_image (f
, img
)
1843 /* Manipulation of the image's mask. */
1846 Lisp_Object conversion
, spec
;
1851 /* `:heuristic-mask t'
1853 means build a mask heuristically.
1854 `:heuristic-mask (R G B)'
1855 `:mask (heuristic (R G B))'
1856 means build a mask from color (R G B) in the
1859 means remove a mask, if any. */
1861 mask
= image_spec_value (spec
, QCheuristic_mask
, NULL
);
1863 x_build_heuristic_mask (f
, img
, mask
);
1868 mask
= image_spec_value (spec
, QCmask
, &found_p
);
1870 if (EQ (mask
, Qheuristic
))
1871 x_build_heuristic_mask (f
, img
, Qt
);
1872 else if (CONSP (mask
)
1873 && EQ (XCAR (mask
), Qheuristic
))
1875 if (CONSP (XCDR (mask
)))
1876 x_build_heuristic_mask (f
, img
, XCAR (XCDR (mask
)));
1878 x_build_heuristic_mask (f
, img
, XCDR (mask
));
1880 else if (NILP (mask
) && found_p
&& img
->mask
)
1882 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
1883 img
->mask
= NO_PIXMAP
;
1888 /* Should we apply an image transformation algorithm? */
1889 conversion
= image_spec_value (spec
, QCconversion
, NULL
);
1890 if (EQ (conversion
, Qdisabled
))
1891 x_disable_image (f
, img
);
1892 else if (EQ (conversion
, Qlaplace
))
1894 else if (EQ (conversion
, Qemboss
))
1896 else if (CONSP (conversion
)
1897 && EQ (XCAR (conversion
), Qedge_detection
))
1900 tem
= XCDR (conversion
);
1902 x_edge_detection (f
, img
,
1903 Fplist_get (tem
, QCmatrix
),
1904 Fplist_get (tem
, QCcolor_adjustment
));
1910 /* Return the id of image with Lisp specification SPEC on frame F.
1911 SPEC must be a valid Lisp image specification (see valid_image_p). */
1914 lookup_image (f
, spec
)
1918 struct image_cache
*c
;
1921 struct gcpro gcpro1
;
1924 /* F must be a window-system frame, and SPEC must be a valid image
1926 xassert (FRAME_WINDOW_P (f
));
1927 xassert (valid_image_p (spec
));
1929 c
= FRAME_IMAGE_CACHE (f
);
1933 /* Look up SPEC in the hash table of the image cache. */
1934 hash
= sxhash (spec
, 0);
1935 img
= search_image_cache (f
, spec
, hash
);
1936 if (img
&& img
->load_failed_p
)
1938 free_image (f
, img
);
1942 /* If not found, create a new image and cache it. */
1945 extern Lisp_Object Qpostscript
;
1948 img
= make_image (spec
, hash
);
1949 cache_image (f
, img
);
1950 img
->load_failed_p
= img
->type
->load (f
, img
) == 0;
1951 img
->frame_foreground
= FRAME_FOREGROUND_PIXEL (f
);
1952 img
->frame_background
= FRAME_BACKGROUND_PIXEL (f
);
1954 /* If we can't load the image, and we don't have a width and
1955 height, use some arbitrary width and height so that we can
1956 draw a rectangle for it. */
1957 if (img
->load_failed_p
)
1961 value
= image_spec_value (spec
, QCwidth
, NULL
);
1962 img
->width
= (INTEGERP (value
)
1963 ? XFASTINT (value
) : DEFAULT_IMAGE_WIDTH
);
1964 value
= image_spec_value (spec
, QCheight
, NULL
);
1965 img
->height
= (INTEGERP (value
)
1966 ? XFASTINT (value
) : DEFAULT_IMAGE_HEIGHT
);
1970 /* Handle image type independent image attributes
1971 `:ascent ASCENT', `:margin MARGIN', `:relief RELIEF',
1972 `:background COLOR'. */
1973 Lisp_Object ascent
, margin
, relief
, bg
;
1975 ascent
= image_spec_value (spec
, QCascent
, NULL
);
1976 if (INTEGERP (ascent
))
1977 img
->ascent
= XFASTINT (ascent
);
1978 else if (EQ (ascent
, Qcenter
))
1979 img
->ascent
= CENTERED_IMAGE_ASCENT
;
1981 margin
= image_spec_value (spec
, QCmargin
, NULL
);
1982 if (INTEGERP (margin
) && XINT (margin
) >= 0)
1983 img
->vmargin
= img
->hmargin
= XFASTINT (margin
);
1984 else if (CONSP (margin
) && INTEGERP (XCAR (margin
))
1985 && INTEGERP (XCDR (margin
)))
1987 if (XINT (XCAR (margin
)) > 0)
1988 img
->hmargin
= XFASTINT (XCAR (margin
));
1989 if (XINT (XCDR (margin
)) > 0)
1990 img
->vmargin
= XFASTINT (XCDR (margin
));
1993 relief
= image_spec_value (spec
, QCrelief
, NULL
);
1994 if (INTEGERP (relief
))
1996 img
->relief
= XINT (relief
);
1997 img
->hmargin
+= eabs (img
->relief
);
1998 img
->vmargin
+= eabs (img
->relief
);
2001 if (! img
->background_valid
)
2003 bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
2007 = x_alloc_image_color (f
, img
, bg
,
2008 FRAME_BACKGROUND_PIXEL (f
));
2009 img
->background_valid
= 1;
2013 /* Do image transformations and compute masks, unless we
2014 don't have the image yet. */
2015 if (!EQ (*img
->type
->type
, Qpostscript
))
2016 postprocess_image (f
, img
);
2022 /* We're using IMG, so set its timestamp to `now'. */
2023 EMACS_GET_TIME (now
);
2024 img
->timestamp
= EMACS_SECS (now
);
2028 /* Value is the image id. */
2033 /* Cache image IMG in the image cache of frame F. */
2036 cache_image (f
, img
)
2040 struct image_cache
*c
= FRAME_IMAGE_CACHE (f
);
2043 /* Find a free slot in c->images. */
2044 for (i
= 0; i
< c
->used
; ++i
)
2045 if (c
->images
[i
] == NULL
)
2048 /* If no free slot found, maybe enlarge c->images. */
2049 if (i
== c
->used
&& c
->used
== c
->size
)
2052 c
->images
= (struct image
**) xrealloc (c
->images
,
2053 c
->size
* sizeof *c
->images
);
2056 /* Add IMG to c->images, and assign IMG an id. */
2062 /* Add IMG to the cache's hash table. */
2063 i
= img
->hash
% IMAGE_CACHE_BUCKETS_SIZE
;
2064 img
->next
= c
->buckets
[i
];
2066 img
->next
->prev
= img
;
2068 c
->buckets
[i
] = img
;
2072 /* Call FN on every image in the image cache of frame F. Used to mark
2073 Lisp Objects in the image cache. */
2075 /* Mark Lisp objects in image IMG. */
2081 mark_object (img
->spec
);
2082 mark_object (img
->dependencies
);
2084 if (!NILP (img
->data
.lisp_val
))
2085 mark_object (img
->data
.lisp_val
);
2090 mark_image_cache (struct image_cache
*c
)
2095 for (i
= 0; i
< c
->used
; ++i
)
2097 mark_image (c
->images
[i
]);
2103 /***********************************************************************
2104 X / MAC / W32 support code
2105 ***********************************************************************/
2109 /* Macro for defining functions that will be loaded from image DLLs. */
2110 #define DEF_IMGLIB_FN(func) int (FAR CDECL *fn_##func)()
2112 /* Macro for loading those image functions from the library. */
2113 #define LOAD_IMGLIB_FN(lib,func) { \
2114 fn_##func = (void *) GetProcAddress (lib, #func); \
2115 if (!fn_##func) return 0; \
2118 /* Load a DLL implementing an image type.
2119 The `image-library-alist' variable associates a symbol,
2120 identifying an image type, to a list of possible filenames.
2121 The function returns NULL if no library could be loaded for
2122 the given image type, or if the library was previously loaded;
2123 else the handle of the DLL. */
2125 w32_delayed_load (Lisp_Object libraries
, Lisp_Object type
)
2127 HMODULE library
= NULL
;
2129 if (CONSP (libraries
) && NILP (Fassq (type
, Vimage_type_cache
)))
2131 Lisp_Object dlls
= Fassq (type
, libraries
);
2134 for (dlls
= XCDR (dlls
); CONSP (dlls
); dlls
= XCDR (dlls
))
2136 CHECK_STRING_CAR (dlls
);
2137 if (library
= LoadLibrary (SDATA (XCAR (dlls
))))
2145 #endif /* HAVE_NTGUI */
2147 static int x_create_x_image_and_pixmap
P_ ((struct frame
*, int, int, int,
2148 XImagePtr
*, Pixmap
*));
2149 static void x_destroy_x_image
P_ ((XImagePtr
));
2150 static void x_put_x_image
P_ ((struct frame
*, XImagePtr
, Pixmap
, int, int));
2153 /* Create an XImage and a pixmap of size WIDTH x HEIGHT for use on
2154 frame F. Set *XIMG and *PIXMAP to the XImage and Pixmap created.
2155 Set (*XIMG)->data to a raster of WIDTH x HEIGHT pixels allocated
2156 via xmalloc. Print error messages via image_error if an error
2157 occurs. Value is non-zero if successful.
2159 On W32, a DEPTH of zero signifies a 24 bit image, otherwise DEPTH
2160 should indicate the bit depth of the image. */
2163 x_create_x_image_and_pixmap (f
, width
, height
, depth
, ximg
, pixmap
)
2165 int width
, height
, depth
;
2169 #ifdef HAVE_X_WINDOWS
2170 Display
*display
= FRAME_X_DISPLAY (f
);
2171 Window window
= FRAME_X_WINDOW (f
);
2172 Screen
*screen
= FRAME_X_SCREEN (f
);
2174 xassert (interrupt_input_blocked
);
2177 depth
= DefaultDepthOfScreen (screen
);
2178 *ximg
= XCreateImage (display
, DefaultVisualOfScreen (screen
),
2179 depth
, ZPixmap
, 0, NULL
, width
, height
,
2180 depth
> 16 ? 32 : depth
> 8 ? 16 : 8, 0);
2183 image_error ("Unable to allocate X image", Qnil
, Qnil
);
2187 /* Allocate image raster. */
2188 (*ximg
)->data
= (char *) xmalloc ((*ximg
)->bytes_per_line
* height
);
2190 /* Allocate a pixmap of the same size. */
2191 *pixmap
= XCreatePixmap (display
, window
, width
, height
, depth
);
2192 if (*pixmap
== NO_PIXMAP
)
2194 x_destroy_x_image (*ximg
);
2196 image_error ("Unable to create X pixmap", Qnil
, Qnil
);
2201 #endif /* HAVE_X_WINDOWS */
2205 BITMAPINFOHEADER
*header
;
2207 int scanline_width_bits
;
2209 int palette_colors
= 0;
2214 if (depth
!= 1 && depth
!= 4 && depth
!= 8
2215 && depth
!= 16 && depth
!= 24 && depth
!= 32)
2217 image_error ("Invalid image bit depth specified", Qnil
, Qnil
);
2221 scanline_width_bits
= width
* depth
;
2222 remainder
= scanline_width_bits
% 32;
2225 scanline_width_bits
+= 32 - remainder
;
2227 /* Bitmaps with a depth less than 16 need a palette. */
2228 /* BITMAPINFO structure already contains the first RGBQUAD. */
2230 palette_colors
= 1 << depth
- 1;
2232 *ximg
= xmalloc (sizeof (XImage
) + palette_colors
* sizeof (RGBQUAD
));
2235 image_error ("Unable to allocate memory for XImage", Qnil
, Qnil
);
2239 header
= &((*ximg
)->info
.bmiHeader
);
2240 bzero (&((*ximg
)->info
), sizeof (BITMAPINFO
));
2241 header
->biSize
= sizeof (*header
);
2242 header
->biWidth
= width
;
2243 header
->biHeight
= -height
; /* negative indicates a top-down bitmap. */
2244 header
->biPlanes
= 1;
2245 header
->biBitCount
= depth
;
2246 header
->biCompression
= BI_RGB
;
2247 header
->biClrUsed
= palette_colors
;
2249 /* TODO: fill in palette. */
2252 (*ximg
)->info
.bmiColors
[0].rgbBlue
= 0;
2253 (*ximg
)->info
.bmiColors
[0].rgbGreen
= 0;
2254 (*ximg
)->info
.bmiColors
[0].rgbRed
= 0;
2255 (*ximg
)->info
.bmiColors
[0].rgbReserved
= 0;
2256 (*ximg
)->info
.bmiColors
[1].rgbBlue
= 255;
2257 (*ximg
)->info
.bmiColors
[1].rgbGreen
= 255;
2258 (*ximg
)->info
.bmiColors
[1].rgbRed
= 255;
2259 (*ximg
)->info
.bmiColors
[1].rgbReserved
= 0;
2262 hdc
= get_frame_dc (f
);
2264 /* Create a DIBSection and raster array for the bitmap,
2265 and store its handle in *pixmap. */
2266 *pixmap
= CreateDIBSection (hdc
, &((*ximg
)->info
),
2267 (depth
< 16) ? DIB_PAL_COLORS
: DIB_RGB_COLORS
,
2268 /* casting avoids a GCC warning */
2269 (void **)&((*ximg
)->data
), NULL
, 0);
2271 /* Realize display palette and garbage all frames. */
2272 release_frame_dc (f
, hdc
);
2274 if (*pixmap
== NULL
)
2276 DWORD err
= GetLastError ();
2277 Lisp_Object errcode
;
2278 /* All system errors are < 10000, so the following is safe. */
2279 XSETINT (errcode
, (int) err
);
2280 image_error ("Unable to create bitmap, error code %d", errcode
, Qnil
);
2281 x_destroy_x_image (*ximg
);
2287 #endif /* HAVE_NTGUI */
2290 Display
*display
= FRAME_X_DISPLAY (f
);
2291 Window window
= FRAME_X_WINDOW (f
);
2293 xassert (interrupt_input_blocked
);
2295 /* Allocate a pixmap of the same size. */
2296 *pixmap
= XCreatePixmap (display
, window
, width
, height
, depth
);
2297 if (*pixmap
== NO_PIXMAP
)
2300 image_error ("Unable to create X pixmap", Qnil
, Qnil
);
2304 LockPixels (GetGWorldPixMap (*pixmap
));
2312 /* Destroy XImage XIMG. Free XIMG->data. */
2315 x_destroy_x_image (ximg
)
2318 xassert (interrupt_input_blocked
);
2321 #ifdef HAVE_X_WINDOWS
2324 XDestroyImage (ximg
);
2325 #endif /* HAVE_X_WINDOWS */
2327 /* Data will be freed by DestroyObject. */
2330 #endif /* HAVE_NTGUI */
2332 XDestroyImage (ximg
);
2338 /* Put XImage XIMG into pixmap PIXMAP on frame F. WIDTH and HEIGHT
2339 are width and height of both the image and pixmap. */
2342 x_put_x_image (f
, ximg
, pixmap
, width
, height
)
2348 #ifdef HAVE_X_WINDOWS
2351 xassert (interrupt_input_blocked
);
2352 gc
= XCreateGC (FRAME_X_DISPLAY (f
), pixmap
, 0, NULL
);
2353 XPutImage (FRAME_X_DISPLAY (f
), pixmap
, gc
, ximg
, 0, 0, 0, 0, width
, height
);
2354 XFreeGC (FRAME_X_DISPLAY (f
), gc
);
2355 #endif /* HAVE_X_WINDOWS */
2358 #if 0 /* I don't think this is necessary looking at where it is used. */
2359 HDC hdc
= get_frame_dc (f
);
2360 SetDIBits (hdc
, pixmap
, 0, height
, ximg
->data
, &(ximg
->info
), DIB_RGB_COLORS
);
2361 release_frame_dc (f
, hdc
);
2363 #endif /* HAVE_NTGUI */
2366 xassert (ximg
== pixmap
);
2371 /***********************************************************************
2373 ***********************************************************************/
2375 static unsigned char *slurp_file
P_ ((char *, int *));
2378 /* Find image file FILE. Look in data-directory/images, then
2379 x-bitmap-file-path. Value is the encoded full name of the file
2380 found, or nil if not found. */
2383 x_find_image_file (file
)
2386 Lisp_Object file_found
, search_path
;
2387 struct gcpro gcpro1
, gcpro2
;
2391 /* TODO I think this should use something like image-load-path
2392 instead. Unfortunately, that can contain non-string elements. */
2393 search_path
= Fcons (Fexpand_file_name (build_string ("images"),
2395 Vx_bitmap_file_path
);
2396 GCPRO2 (file_found
, search_path
);
2398 /* Try to find FILE in data-directory/images, then x-bitmap-file-path. */
2399 fd
= openp (search_path
, file
, Qnil
, &file_found
, Qnil
);
2405 file_found
= ENCODE_FILE (file_found
);
2414 /* Read FILE into memory. Value is a pointer to a buffer allocated
2415 with xmalloc holding FILE's contents. Value is null if an error
2416 occurred. *SIZE is set to the size of the file. */
2418 static unsigned char *
2419 slurp_file (file
, size
)
2424 unsigned char *buf
= NULL
;
2427 if (stat (file
, &st
) == 0
2428 && (fp
= fopen (file
, "rb")) != NULL
2429 && (buf
= (unsigned char *) xmalloc (st
.st_size
),
2430 fread (buf
, 1, st
.st_size
, fp
) == st
.st_size
))
2453 /***********************************************************************
2454 MAC Image Load Functions
2455 ***********************************************************************/
2457 static int image_load_quicktime
P_ ((struct frame
*, struct image
*img
,
2460 static int image_load_quartz2d
P_ ((struct frame
*, struct image
*img
, int));
2464 find_image_fsspec (specified_file
, file
, fss
)
2465 Lisp_Object specified_file
, *file
;
2471 *file
= x_find_image_file (specified_file
);
2472 if (!STRINGP (*file
))
2473 return fnfErr
; /* file or directory not found;
2474 incomplete pathname */
2475 /* Try to open the image file. */
2476 err
= AECoercePtr (TYPE_FILE_NAME
, SDATA (*file
),
2477 SBYTES (*file
), typeFSS
, &desc
);
2480 #if TARGET_API_MAC_CARBON
2481 err
= AEGetDescData (&desc
, fss
, sizeof (FSSpec
));
2483 *fss
= *(FSSpec
*)(*(desc
.dataHandle
));
2485 AEDisposeDesc (&desc
);
2491 image_load_qt_1 (f
, img
, type
, fss
, dh
)
2498 ComponentResult err
;
2499 GraphicsImportComponent gi
;
2502 ImageDescriptionHandle desc_handle
;
2503 short draw_all_pixels
;
2504 Lisp_Object specified_bg
;
2509 err
= OpenADefaultComponent (GraphicsImporterComponentType
, type
, &gi
);
2512 image_error ("Cannot get importer component for `%s'", img
->spec
, Qnil
);
2517 /* read from file system spec */
2518 err
= GraphicsImportSetDataFile (gi
, fss
);
2521 image_error ("Cannot set fsspec to graphics importer for '%s'",
2528 /* read from data handle */
2529 err
= GraphicsImportSetDataHandle (gi
, dh
);
2532 image_error ("Cannot set data handle to graphics importer for `%s'",
2537 err
= GraphicsImportGetImageDescription (gi
, &desc_handle
);
2538 if (err
!= noErr
|| desc_handle
== NULL
)
2540 image_error ("Error reading `%s'", img
->spec
, Qnil
);
2543 width
= img
->width
= (*desc_handle
)->width
;
2544 height
= img
->height
= (*desc_handle
)->height
;
2545 DisposeHandle ((Handle
)desc_handle
);
2547 if (!check_image_size (f
, width
, height
))
2549 image_error ("Invalid image size", Qnil
, Qnil
);
2553 err
= GraphicsImportDoesDrawAllPixels (gi
, &draw_all_pixels
);
2555 /* Don't check the error code here. It may have an undocumented
2559 image_error ("Error reading `%s'", img
->spec
, Qnil
);
2563 if (draw_all_pixels
!= graphicsImporterDrawsAllPixels
)
2565 specified_bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
2566 if (!STRINGP (specified_bg
) ||
2567 !mac_defined_color (f
, SDATA (specified_bg
), &color
, 0))
2569 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
2570 color
.red
= RED16_FROM_ULONG (color
.pixel
);
2571 color
.green
= GREEN16_FROM_ULONG (color
.pixel
);
2572 color
.blue
= BLUE16_FROM_ULONG (color
.pixel
);
2576 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
2578 if (draw_all_pixels
!= graphicsImporterDrawsAllPixels
)
2583 GetGWorld (&old_port
, &old_gdh
);
2584 SetGWorld (ximg
, NULL
);
2585 bg_color
.red
= color
.red
;
2586 bg_color
.green
= color
.green
;
2587 bg_color
.blue
= color
.blue
;
2588 RGBBackColor (&bg_color
);
2589 #if TARGET_API_MAC_CARBON
2590 GetPortBounds (ximg
, &rect
);
2593 EraseRect (&(ximg
->portRect
));
2595 SetGWorld (old_port
, old_gdh
);
2597 GraphicsImportSetGWorld (gi
, ximg
, NULL
);
2598 GraphicsImportDraw (gi
);
2599 CloseComponent (gi
);
2601 /* Maybe fill in the background field while we have ximg handy. */
2602 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
2603 IMAGE_BACKGROUND (img
, f
, ximg
);
2605 /* Put the image into the pixmap. */
2606 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
2607 x_destroy_x_image (ximg
);
2611 CloseComponent (gi
);
2616 /* Load an image using the QuickTime Graphics Importer.
2617 Note: The alpha channel does not work for PNG images. */
2619 image_load_quicktime (f
, img
, type
)
2624 Lisp_Object specified_file
;
2625 Lisp_Object specified_data
;
2628 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
2629 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
2631 if (NILP (specified_data
))
2633 /* Read from a file */
2637 err
= find_image_fsspec (specified_file
, &file
, &fss
);
2641 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
2643 image_error ("Cannot open `%s'", file
, Qnil
);
2646 return image_load_qt_1 (f
, img
, type
, &fss
, NULL
);
2650 /* Memory source! */
2654 err
= PtrToHand (SDATA (specified_data
), &dh
, SBYTES (specified_data
));
2657 image_error ("Cannot allocate data handle for `%s'",
2661 success_p
= image_load_qt_1 (f
, img
, type
, NULL
, dh
);
2669 /* Load a PNG/JPEG image using Quartz 2D decoding routines.
2670 CGImageCreateWithPNGDataProvider is provided after Mac OS X 10.2.
2671 So don't use this function directly but determine at runtime
2672 whether it exists. */
2673 typedef CGImageRef (*CGImageCreateWithPNGDataProviderProcType
)
2674 (CGDataProviderRef
, const float [], bool, CGColorRenderingIntent
);
2675 static CGImageCreateWithPNGDataProviderProcType MyCGImageCreateWithPNGDataProvider
;
2679 init_image_func_pointer ()
2681 if (NSIsSymbolNameDefined ("_CGImageCreateWithPNGDataProvider"))
2683 MyCGImageCreateWithPNGDataProvider
2684 = (CGImageCreateWithPNGDataProviderProcType
)
2685 NSAddressOfSymbol (NSLookupAndBindSymbol
2686 ("_CGImageCreateWithPNGDataProvider"));
2689 MyCGImageCreateWithPNGDataProvider
= NULL
;
2694 image_load_quartz2d (f
, img
, png_p
)
2699 Lisp_Object file
, specified_file
;
2700 Lisp_Object specified_data
, specified_bg
;
2701 struct gcpro gcpro1
;
2702 CGDataProviderRef source
;
2706 XImagePtr ximg
= NULL
;
2707 CGContextRef context
;
2710 /* Open the file. */
2711 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
2712 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
2717 if (NILP (specified_data
))
2722 file
= x_find_image_file (specified_file
);
2723 if (!STRINGP (file
))
2725 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
2729 path
= cfstring_create_with_utf8_cstring (SDATA (file
));
2730 url
= CFURLCreateWithFileSystemPath (NULL
, path
,
2731 kCFURLPOSIXPathStyle
, 0);
2733 source
= CGDataProviderCreateWithURL (url
);
2737 source
= CGDataProviderCreateWithData (NULL
, SDATA (specified_data
),
2738 SBYTES (specified_data
), NULL
);
2741 image
= (*MyCGImageCreateWithPNGDataProvider
) (source
, NULL
, FALSE
,
2742 kCGRenderingIntentDefault
);
2744 image
= CGImageCreateWithJPEGDataProvider (source
, NULL
, FALSE
,
2745 kCGRenderingIntentDefault
);
2747 CGDataProviderRelease (source
);
2751 image_error ("Error reading image `%s'", img
->spec
, Qnil
);
2754 width
= img
->width
= CGImageGetWidth (image
);
2755 height
= img
->height
= CGImageGetHeight (image
);
2757 if (!check_image_size (f
, width
, height
))
2759 CGImageRelease (image
);
2761 image_error ("Invalid image size", Qnil
, Qnil
);
2767 specified_bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
2768 if (!STRINGP (specified_bg
) ||
2769 !mac_defined_color (f
, SDATA (specified_bg
), &color
, 0))
2771 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
2772 color
.red
= RED16_FROM_ULONG (color
.pixel
);
2773 color
.green
= GREEN16_FROM_ULONG (color
.pixel
);
2774 color
.blue
= BLUE16_FROM_ULONG (color
.pixel
);
2778 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
2780 CGImageRelease (image
);
2784 rectangle
= CGRectMake (0, 0, width
, height
);
2785 QDBeginCGContext (ximg
, &context
);
2788 CGContextSetRGBFillColor (context
, color
.red
/ 65535.0,
2789 color
.green
/ 65535.0,
2790 color
.blue
/ 65535.0, 1.0);
2791 CGContextFillRect (context
, rectangle
);
2793 CGContextDrawImage (context
, rectangle
, image
);
2794 QDEndCGContext (ximg
, &context
);
2795 CGImageRelease (image
);
2797 /* Maybe fill in the background field while we have ximg handy. */
2798 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
2799 IMAGE_BACKGROUND (img
, f
, ximg
);
2801 /* Put the image into the pixmap. */
2802 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
2803 x_destroy_x_image (ximg
);
2812 /***********************************************************************
2814 ***********************************************************************/
2816 static int xbm_scan
P_ ((unsigned char **, unsigned char *, char *, int *));
2817 static int xbm_load
P_ ((struct frame
*f
, struct image
*img
));
2818 static int xbm_load_image
P_ ((struct frame
*f
, struct image
*img
,
2819 unsigned char *, unsigned char *));
2820 static int xbm_image_p
P_ ((Lisp_Object object
));
2821 static int xbm_read_bitmap_data
P_ ((struct frame
*f
,
2822 unsigned char *, unsigned char *,
2823 int *, int *, unsigned char **));
2824 static int xbm_file_p
P_ ((Lisp_Object
));
2827 /* Indices of image specification fields in xbm_format, below. */
2829 enum xbm_keyword_index
2847 /* Vector of image_keyword structures describing the format
2848 of valid XBM image specifications. */
2850 static struct image_keyword xbm_format
[XBM_LAST
] =
2852 {":type", IMAGE_SYMBOL_VALUE
, 1},
2853 {":file", IMAGE_STRING_VALUE
, 0},
2854 {":width", IMAGE_POSITIVE_INTEGER_VALUE
, 0},
2855 {":height", IMAGE_POSITIVE_INTEGER_VALUE
, 0},
2856 {":data", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
2857 {":foreground", IMAGE_STRING_OR_NIL_VALUE
, 0},
2858 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0},
2859 {":ascent", IMAGE_ASCENT_VALUE
, 0},
2860 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
2861 {":relief", IMAGE_INTEGER_VALUE
, 0},
2862 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
2863 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
2864 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0}
2867 /* Structure describing the image type XBM. */
2869 static struct image_type xbm_type
=
2878 /* Tokens returned from xbm_scan. */
2887 /* Return non-zero if OBJECT is a valid XBM-type image specification.
2888 A valid specification is a list starting with the symbol `image'
2889 The rest of the list is a property list which must contain an
2892 If the specification specifies a file to load, it must contain
2893 an entry `:file FILENAME' where FILENAME is a string.
2895 If the specification is for a bitmap loaded from memory it must
2896 contain `:width WIDTH', `:height HEIGHT', and `:data DATA', where
2897 WIDTH and HEIGHT are integers > 0. DATA may be:
2899 1. a string large enough to hold the bitmap data, i.e. it must
2900 have a size >= (WIDTH + 7) / 8 * HEIGHT
2902 2. a bool-vector of size >= WIDTH * HEIGHT
2904 3. a vector of strings or bool-vectors, one for each line of the
2907 4. a string containing an in-memory XBM file. WIDTH and HEIGHT
2908 may not be specified in this case because they are defined in the
2911 Both the file and data forms may contain the additional entries
2912 `:background COLOR' and `:foreground COLOR'. If not present,
2913 foreground and background of the frame on which the image is
2914 displayed is used. */
2917 xbm_image_p (object
)
2920 struct image_keyword kw
[XBM_LAST
];
2922 bcopy (xbm_format
, kw
, sizeof kw
);
2923 if (!parse_image_spec (object
, kw
, XBM_LAST
, Qxbm
))
2926 xassert (EQ (kw
[XBM_TYPE
].value
, Qxbm
));
2928 if (kw
[XBM_FILE
].count
)
2930 if (kw
[XBM_WIDTH
].count
|| kw
[XBM_HEIGHT
].count
|| kw
[XBM_DATA
].count
)
2933 else if (kw
[XBM_DATA
].count
&& xbm_file_p (kw
[XBM_DATA
].value
))
2935 /* In-memory XBM file. */
2936 if (kw
[XBM_WIDTH
].count
|| kw
[XBM_HEIGHT
].count
|| kw
[XBM_FILE
].count
)
2944 /* Entries for `:width', `:height' and `:data' must be present. */
2945 if (!kw
[XBM_WIDTH
].count
2946 || !kw
[XBM_HEIGHT
].count
2947 || !kw
[XBM_DATA
].count
)
2950 data
= kw
[XBM_DATA
].value
;
2951 width
= XFASTINT (kw
[XBM_WIDTH
].value
);
2952 height
= XFASTINT (kw
[XBM_HEIGHT
].value
);
2954 /* Check type of data, and width and height against contents of
2960 /* Number of elements of the vector must be >= height. */
2961 if (XVECTOR (data
)->size
< height
)
2964 /* Each string or bool-vector in data must be large enough
2965 for one line of the image. */
2966 for (i
= 0; i
< height
; ++i
)
2968 Lisp_Object elt
= XVECTOR (data
)->contents
[i
];
2973 < (width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
)
2976 else if (BOOL_VECTOR_P (elt
))
2978 if (XBOOL_VECTOR (elt
)->size
< width
)
2985 else if (STRINGP (data
))
2988 < (width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
* height
)
2991 else if (BOOL_VECTOR_P (data
))
2993 if (XBOOL_VECTOR (data
)->size
< width
* height
)
3004 /* Scan a bitmap file. FP is the stream to read from. Value is
3005 either an enumerator from enum xbm_token, or a character for a
3006 single-character token, or 0 at end of file. If scanning an
3007 identifier, store the lexeme of the identifier in SVAL. If
3008 scanning a number, store its value in *IVAL. */
3011 xbm_scan (s
, end
, sval
, ival
)
3012 unsigned char **s
, *end
;
3020 /* Skip white space. */
3021 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
3026 else if (isdigit (c
))
3028 int value
= 0, digit
;
3030 if (c
== '0' && *s
< end
)
3033 if (c
== 'x' || c
== 'X')
3040 else if (c
>= 'a' && c
<= 'f')
3041 digit
= c
- 'a' + 10;
3042 else if (c
>= 'A' && c
<= 'F')
3043 digit
= c
- 'A' + 10;
3046 value
= 16 * value
+ digit
;
3049 else if (isdigit (c
))
3053 && (c
= *(*s
)++, isdigit (c
)))
3054 value
= 8 * value
+ c
- '0';
3061 && (c
= *(*s
)++, isdigit (c
)))
3062 value
= 10 * value
+ c
- '0';
3070 else if (isalpha (c
) || c
== '_')
3074 && (c
= *(*s
)++, (isalnum (c
) || c
== '_')))
3081 else if (c
== '/' && **s
== '*')
3083 /* C-style comment. */
3085 while (**s
&& (**s
!= '*' || *(*s
+ 1) != '/'))
3099 /* Create a Windows bitmap from X bitmap data. */
3101 w32_create_pixmap_from_bitmap_data (int width
, int height
, char *data
)
3103 static unsigned char swap_nibble
[16]
3104 = { 0x0, 0x8, 0x4, 0xc, /* 0000 1000 0100 1100 */
3105 0x2, 0xa, 0x6, 0xe, /* 0010 1010 0110 1110 */
3106 0x1, 0x9, 0x5, 0xd, /* 0001 1001 0101 1101 */
3107 0x3, 0xb, 0x7, 0xf }; /* 0011 1011 0111 1111 */
3109 unsigned char *bits
, *p
;
3112 w1
= (width
+ 7) / 8; /* nb of 8bits elt in X bitmap */
3113 w2
= ((width
+ 15) / 16) * 2; /* nb of 16bits elt in W32 bitmap */
3114 bits
= (unsigned char *) alloca (height
* w2
);
3115 bzero (bits
, height
* w2
);
3116 for (i
= 0; i
< height
; i
++)
3119 for (j
= 0; j
< w1
; j
++)
3121 /* Bitswap XBM bytes to match how Windows does things. */
3122 unsigned char c
= *data
++;
3123 *p
++ = (unsigned char)((swap_nibble
[c
& 0xf] << 4)
3124 | (swap_nibble
[(c
>>4) & 0xf]));
3127 bmp
= CreateBitmap (width
, height
, 1, 1, (char *) bits
);
3133 convert_mono_to_color_image (f
, img
, foreground
, background
)
3136 COLORREF foreground
, background
;
3138 HDC hdc
, old_img_dc
, new_img_dc
;
3139 HGDIOBJ old_prev
, new_prev
;
3142 hdc
= get_frame_dc (f
);
3143 old_img_dc
= CreateCompatibleDC (hdc
);
3144 new_img_dc
= CreateCompatibleDC (hdc
);
3145 new_pixmap
= CreateCompatibleBitmap (hdc
, img
->width
, img
->height
);
3146 release_frame_dc (f
, hdc
);
3147 old_prev
= SelectObject (old_img_dc
, img
->pixmap
);
3148 new_prev
= SelectObject (new_img_dc
, new_pixmap
);
3149 /* Windows convention for mono bitmaps is black = background,
3150 white = foreground. */
3151 SetTextColor (new_img_dc
, background
);
3152 SetBkColor (new_img_dc
, foreground
);
3154 BitBlt (new_img_dc
, 0, 0, img
->width
, img
->height
, old_img_dc
,
3157 SelectObject (old_img_dc
, old_prev
);
3158 SelectObject (new_img_dc
, new_prev
);
3159 DeleteDC (old_img_dc
);
3160 DeleteDC (new_img_dc
);
3161 DeleteObject (img
->pixmap
);
3162 if (new_pixmap
== 0)
3163 fprintf (stderr
, "Failed to convert image to color.\n");
3165 img
->pixmap
= new_pixmap
;
3168 #define XBM_BIT_SHUFFLE(b) (~(b))
3172 #define XBM_BIT_SHUFFLE(b) (b)
3174 #endif /* HAVE_NTGUI */
3178 Create_Pixmap_From_Bitmap_Data (f
, img
, data
, fg
, bg
, non_default_colors
)
3182 RGB_PIXEL_COLOR fg
, bg
;
3183 int non_default_colors
;
3187 = w32_create_pixmap_from_bitmap_data (img
->width
, img
->height
, data
);
3189 /* If colors were specified, transfer the bitmap to a color one. */
3190 if (non_default_colors
)
3191 convert_mono_to_color_image (f
, img
, fg
, bg
);
3194 = XCreatePixmapFromBitmapData (FRAME_X_DISPLAY (f
),
3197 img
->width
, img
->height
,
3199 DefaultDepthOfScreen (FRAME_X_SCREEN (f
)));
3200 #endif /* HAVE_NTGUI */
3205 /* Replacement for XReadBitmapFileData which isn't available under old
3206 X versions. CONTENTS is a pointer to a buffer to parse; END is the
3207 buffer's end. Set *WIDTH and *HEIGHT to the width and height of
3208 the image. Return in *DATA the bitmap data allocated with xmalloc.
3209 Value is non-zero if successful. DATA null means just test if
3210 CONTENTS looks like an in-memory XBM file. */
3213 xbm_read_bitmap_data (f
, contents
, end
, width
, height
, data
)
3215 unsigned char *contents
, *end
;
3216 int *width
, *height
;
3217 unsigned char **data
;
3219 unsigned char *s
= contents
;
3220 char buffer
[BUFSIZ
];
3223 int bytes_per_line
, i
, nbytes
;
3229 LA1 = xbm_scan (&s, end, buffer, &value)
3231 #define expect(TOKEN) \
3232 if (LA1 != (TOKEN)) \
3237 #define expect_ident(IDENT) \
3238 if (LA1 == XBM_TK_IDENT && strcmp (buffer, (IDENT)) == 0) \
3243 *width
= *height
= -1;
3246 LA1
= xbm_scan (&s
, end
, buffer
, &value
);
3248 /* Parse defines for width, height and hot-spots. */
3252 expect_ident ("define");
3253 expect (XBM_TK_IDENT
);
3255 if (LA1
== XBM_TK_NUMBER
)
3257 char *p
= strrchr (buffer
, '_');
3258 p
= p
? p
+ 1 : buffer
;
3259 if (strcmp (p
, "width") == 0)
3261 else if (strcmp (p
, "height") == 0)
3264 expect (XBM_TK_NUMBER
);
3267 if (!check_image_size (f
, *width
, *height
))
3269 else if (data
== NULL
)
3272 /* Parse bits. Must start with `static'. */
3273 expect_ident ("static");
3274 if (LA1
== XBM_TK_IDENT
)
3276 if (strcmp (buffer
, "unsigned") == 0)
3279 expect_ident ("char");
3281 else if (strcmp (buffer
, "short") == 0)
3285 if (*width
% 16 && *width
% 16 < 9)
3288 else if (strcmp (buffer
, "char") == 0)
3296 expect (XBM_TK_IDENT
);
3302 bytes_per_line
= (*width
+ 7) / 8 + padding_p
;
3303 nbytes
= bytes_per_line
* *height
;
3304 p
= *data
= (unsigned char *) xmalloc (nbytes
);
3308 for (i
= 0; i
< nbytes
; i
+= 2)
3311 expect (XBM_TK_NUMBER
);
3313 *p
++ = XBM_BIT_SHUFFLE (val
);
3314 if (!padding_p
|| ((i
+ 2) % bytes_per_line
))
3315 *p
++ = XBM_BIT_SHUFFLE (value
>> 8);
3317 if (LA1
== ',' || LA1
== '}')
3325 for (i
= 0; i
< nbytes
; ++i
)
3328 expect (XBM_TK_NUMBER
);
3330 *p
++ = XBM_BIT_SHUFFLE (val
);
3332 if (LA1
== ',' || LA1
== '}')
3357 /* Load XBM image IMG which will be displayed on frame F from buffer
3358 CONTENTS. END is the end of the buffer. Value is non-zero if
3362 xbm_load_image (f
, img
, contents
, end
)
3365 unsigned char *contents
, *end
;
3368 unsigned char *data
;
3371 rc
= xbm_read_bitmap_data (f
, contents
, end
, &img
->width
, &img
->height
, &data
);
3374 unsigned long foreground
= FRAME_FOREGROUND_PIXEL (f
);
3375 unsigned long background
= FRAME_BACKGROUND_PIXEL (f
);
3376 int non_default_colors
= 0;
3379 xassert (img
->width
> 0 && img
->height
> 0);
3381 /* Get foreground and background colors, maybe allocate colors. */
3382 value
= image_spec_value (img
->spec
, QCforeground
, NULL
);
3385 foreground
= x_alloc_image_color (f
, img
, value
, foreground
);
3386 non_default_colors
= 1;
3388 value
= image_spec_value (img
->spec
, QCbackground
, NULL
);
3391 background
= x_alloc_image_color (f
, img
, value
, background
);
3392 img
->background
= background
;
3393 img
->background_valid
= 1;
3394 non_default_colors
= 1;
3397 Create_Pixmap_From_Bitmap_Data (f
, img
, data
,
3398 foreground
, background
,
3399 non_default_colors
);
3402 if (img
->pixmap
== NO_PIXMAP
)
3404 x_clear_image (f
, img
);
3405 image_error ("Unable to create X pixmap for `%s'", img
->spec
, Qnil
);
3411 image_error ("Error loading XBM image `%s'", img
->spec
, Qnil
);
3417 /* Value is non-zero if DATA looks like an in-memory XBM file. */
3424 return (STRINGP (data
)
3425 && xbm_read_bitmap_data (NULL
, SDATA (data
),
3432 /* Fill image IMG which is used on frame F with pixmap data. Value is
3433 non-zero if successful. */
3441 Lisp_Object file_name
;
3443 xassert (xbm_image_p (img
->spec
));
3445 /* If IMG->spec specifies a file name, create a non-file spec from it. */
3446 file_name
= image_spec_value (img
->spec
, QCfile
, NULL
);
3447 if (STRINGP (file_name
))
3450 unsigned char *contents
;
3452 struct gcpro gcpro1
;
3454 file
= x_find_image_file (file_name
);
3456 if (!STRINGP (file
))
3458 image_error ("Cannot find image file `%s'", file_name
, Qnil
);
3463 contents
= slurp_file (SDATA (file
), &size
);
3464 if (contents
== NULL
)
3466 image_error ("Error loading XBM image `%s'", img
->spec
, Qnil
);
3471 success_p
= xbm_load_image (f
, img
, contents
, contents
+ size
);
3476 struct image_keyword fmt
[XBM_LAST
];
3478 unsigned long foreground
= FRAME_FOREGROUND_PIXEL (f
);
3479 unsigned long background
= FRAME_BACKGROUND_PIXEL (f
);
3480 int non_default_colors
= 0;
3483 int in_memory_file_p
= 0;
3485 /* See if data looks like an in-memory XBM file. */
3486 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
3487 in_memory_file_p
= xbm_file_p (data
);
3489 /* Parse the image specification. */
3490 bcopy (xbm_format
, fmt
, sizeof fmt
);
3491 parsed_p
= parse_image_spec (img
->spec
, fmt
, XBM_LAST
, Qxbm
);
3494 /* Get specified width, and height. */
3495 if (!in_memory_file_p
)
3497 img
->width
= XFASTINT (fmt
[XBM_WIDTH
].value
);
3498 img
->height
= XFASTINT (fmt
[XBM_HEIGHT
].value
);
3499 xassert (img
->width
> 0 && img
->height
> 0);
3502 /* Get foreground and background colors, maybe allocate colors. */
3503 if (fmt
[XBM_FOREGROUND
].count
3504 && STRINGP (fmt
[XBM_FOREGROUND
].value
))
3506 foreground
= x_alloc_image_color (f
, img
, fmt
[XBM_FOREGROUND
].value
,
3508 non_default_colors
= 1;
3511 if (fmt
[XBM_BACKGROUND
].count
3512 && STRINGP (fmt
[XBM_BACKGROUND
].value
))
3514 background
= x_alloc_image_color (f
, img
, fmt
[XBM_BACKGROUND
].value
,
3516 non_default_colors
= 1;
3519 if (in_memory_file_p
)
3520 success_p
= xbm_load_image (f
, img
, SDATA (data
),
3529 int nbytes
= (img
->width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
;
3531 p
= bits
= (char *) alloca (nbytes
* img
->height
);
3532 for (i
= 0; i
< img
->height
; ++i
, p
+= nbytes
)
3534 Lisp_Object line
= XVECTOR (data
)->contents
[i
];
3536 bcopy (SDATA (line
), p
, nbytes
);
3538 bcopy (XBOOL_VECTOR (line
)->data
, p
, nbytes
);
3541 else if (STRINGP (data
))
3542 bits
= SDATA (data
);
3544 bits
= XBOOL_VECTOR (data
)->data
;
3550 /* Windows mono bitmaps are reversed compared with X. */
3551 invertedBits
= bits
;
3552 nbytes
= (img
->width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
3554 bits
= (char *) alloca(nbytes
);
3555 for (i
= 0; i
< nbytes
; i
++)
3556 bits
[i
] = XBM_BIT_SHUFFLE (invertedBits
[i
]);
3559 /* Create the pixmap. */
3561 Create_Pixmap_From_Bitmap_Data (f
, img
, bits
,
3562 foreground
, background
,
3563 non_default_colors
);
3568 image_error ("Unable to create pixmap for XBM image `%s'",
3570 x_clear_image (f
, img
);
3580 /***********************************************************************
3582 ***********************************************************************/
3584 #if defined (HAVE_XPM) || defined (MAC_OS)
3586 static int xpm_image_p
P_ ((Lisp_Object object
));
3587 static int xpm_load
P_ ((struct frame
*f
, struct image
*img
));
3588 static int xpm_valid_color_symbols_p
P_ ((Lisp_Object
));
3590 #endif /* HAVE_XPM || MAC_OS */
3594 /* Indicate to xpm.h that we don't have Xlib. */
3596 /* simx.h in xpm defines XColor and XImage differently than Emacs. */
3597 /* It also defines Display the same way as Emacs, but gcc 3.3 still barfs. */
3598 #define XColor xpm_XColor
3599 #define XImage xpm_XImage
3600 #define Display xpm_Display
3601 #define PIXEL_ALREADY_TYPEDEFED
3602 #include "X11/xpm.h"
3607 #undef PIXEL_ALREADY_TYPEDEFED
3609 #include "X11/xpm.h"
3610 #endif /* HAVE_NTGUI */
3611 #endif /* HAVE_XPM */
3613 #if defined (HAVE_XPM) || defined (MAC_OS)
3614 /* The symbol `xpm' identifying XPM-format images. */
3618 /* Indices of image specification fields in xpm_format, below. */
3620 enum xpm_keyword_index
3636 /* Vector of image_keyword structures describing the format
3637 of valid XPM image specifications. */
3639 static struct image_keyword xpm_format
[XPM_LAST
] =
3641 {":type", IMAGE_SYMBOL_VALUE
, 1},
3642 {":file", IMAGE_STRING_VALUE
, 0},
3643 {":data", IMAGE_STRING_VALUE
, 0},
3644 {":ascent", IMAGE_ASCENT_VALUE
, 0},
3645 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
3646 {":relief", IMAGE_INTEGER_VALUE
, 0},
3647 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3648 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3649 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3650 {":color-symbols", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3651 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
3654 /* Structure describing the image type XPM. */
3656 static struct image_type xpm_type
=
3665 #ifdef HAVE_X_WINDOWS
3667 /* Define ALLOC_XPM_COLORS if we can use Emacs' own color allocation
3668 functions for allocating image colors. Our own functions handle
3669 color allocation failures more gracefully than the ones on the XPM
3672 #if defined XpmAllocColor && defined XpmFreeColors && defined XpmColorClosure
3673 #define ALLOC_XPM_COLORS
3675 #endif /* HAVE_X_WINDOWS */
3677 #ifdef ALLOC_XPM_COLORS
3679 static void xpm_init_color_cache
P_ ((struct frame
*, XpmAttributes
*));
3680 static void xpm_free_color_cache
P_ ((void));
3681 static int xpm_lookup_color
P_ ((struct frame
*, char *, XColor
*));
3682 static int xpm_color_bucket
P_ ((char *));
3683 static struct xpm_cached_color
*xpm_cache_color
P_ ((struct frame
*, char *,
3686 /* An entry in a hash table used to cache color definitions of named
3687 colors. This cache is necessary to speed up XPM image loading in
3688 case we do color allocations ourselves. Without it, we would need
3689 a call to XParseColor per pixel in the image. */
3691 struct xpm_cached_color
3693 /* Next in collision chain. */
3694 struct xpm_cached_color
*next
;
3696 /* Color definition (RGB and pixel color). */
3703 /* The hash table used for the color cache, and its bucket vector
3706 #define XPM_COLOR_CACHE_BUCKETS 1001
3707 struct xpm_cached_color
**xpm_color_cache
;
3709 /* Initialize the color cache. */
3712 xpm_init_color_cache (f
, attrs
)
3714 XpmAttributes
*attrs
;
3716 size_t nbytes
= XPM_COLOR_CACHE_BUCKETS
* sizeof *xpm_color_cache
;
3717 xpm_color_cache
= (struct xpm_cached_color
**) xmalloc (nbytes
);
3718 memset (xpm_color_cache
, 0, nbytes
);
3719 init_color_table ();
3721 if (attrs
->valuemask
& XpmColorSymbols
)
3726 for (i
= 0; i
< attrs
->numsymbols
; ++i
)
3727 if (XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
3728 attrs
->colorsymbols
[i
].value
, &color
))
3730 color
.pixel
= lookup_rgb_color (f
, color
.red
, color
.green
,
3732 xpm_cache_color (f
, attrs
->colorsymbols
[i
].name
, &color
, -1);
3737 /* Free the color cache. */
3740 xpm_free_color_cache ()
3742 struct xpm_cached_color
*p
, *next
;
3745 for (i
= 0; i
< XPM_COLOR_CACHE_BUCKETS
; ++i
)
3746 for (p
= xpm_color_cache
[i
]; p
; p
= next
)
3752 xfree (xpm_color_cache
);
3753 xpm_color_cache
= NULL
;
3754 free_color_table ();
3757 /* Return the bucket index for color named COLOR_NAME in the color
3761 xpm_color_bucket (color_name
)
3767 for (s
= color_name
; *s
; ++s
)
3769 return h
%= XPM_COLOR_CACHE_BUCKETS
;
3773 /* On frame F, cache values COLOR for color with name COLOR_NAME.
3774 BUCKET, if >= 0, is a precomputed bucket index. Value is the cache
3777 static struct xpm_cached_color
*
3778 xpm_cache_color (f
, color_name
, color
, bucket
)
3785 struct xpm_cached_color
*p
;
3788 bucket
= xpm_color_bucket (color_name
);
3790 nbytes
= sizeof *p
+ strlen (color_name
);
3791 p
= (struct xpm_cached_color
*) xmalloc (nbytes
);
3792 strcpy (p
->name
, color_name
);
3794 p
->next
= xpm_color_cache
[bucket
];
3795 xpm_color_cache
[bucket
] = p
;
3799 /* Look up color COLOR_NAME for frame F in the color cache. If found,
3800 return the cached definition in *COLOR. Otherwise, make a new
3801 entry in the cache and allocate the color. Value is zero if color
3802 allocation failed. */
3805 xpm_lookup_color (f
, color_name
, color
)
3810 struct xpm_cached_color
*p
;
3811 int h
= xpm_color_bucket (color_name
);
3813 for (p
= xpm_color_cache
[h
]; p
; p
= p
->next
)
3814 if (strcmp (p
->name
, color_name
) == 0)
3819 else if (XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
3822 color
->pixel
= lookup_rgb_color (f
, color
->red
, color
->green
,
3824 p
= xpm_cache_color (f
, color_name
, color
, h
);
3826 /* You get `opaque' at least from ImageMagick converting pbm to xpm
3827 with transparency, and it's useful. */
3828 else if (strcmp ("opaque", color_name
) == 0)
3830 bzero (color
, sizeof (XColor
)); /* Is this necessary/correct? */
3831 color
->pixel
= FRAME_FOREGROUND_PIXEL (f
);
3832 p
= xpm_cache_color (f
, color_name
, color
, h
);
3839 /* Callback for allocating color COLOR_NAME. Called from the XPM lib.
3840 CLOSURE is a pointer to the frame on which we allocate the
3841 color. Return in *COLOR the allocated color. Value is non-zero
3845 xpm_alloc_color (dpy
, cmap
, color_name
, color
, closure
)
3852 return xpm_lookup_color ((struct frame
*) closure
, color_name
, color
);
3856 /* Callback for freeing NPIXELS colors contained in PIXELS. CLOSURE
3857 is a pointer to the frame on which we allocate the color. Value is
3858 non-zero if successful. */
3861 xpm_free_colors (dpy
, cmap
, pixels
, npixels
, closure
)
3871 #endif /* ALLOC_XPM_COLORS */
3876 /* XPM library details. */
3878 DEF_IMGLIB_FN (XpmFreeAttributes
);
3879 DEF_IMGLIB_FN (XpmCreateImageFromBuffer
);
3880 DEF_IMGLIB_FN (XpmReadFileToImage
);
3881 DEF_IMGLIB_FN (XImageFree
);
3884 init_xpm_functions (Lisp_Object libraries
)
3888 if (!(library
= w32_delayed_load (libraries
, Qxpm
)))
3891 LOAD_IMGLIB_FN (library
, XpmFreeAttributes
);
3892 LOAD_IMGLIB_FN (library
, XpmCreateImageFromBuffer
);
3893 LOAD_IMGLIB_FN (library
, XpmReadFileToImage
);
3894 LOAD_IMGLIB_FN (library
, XImageFree
);
3898 #endif /* HAVE_NTGUI */
3901 /* Value is non-zero if COLOR_SYMBOLS is a valid color symbols list
3902 for XPM images. Such a list must consist of conses whose car and
3906 xpm_valid_color_symbols_p (color_symbols
)
3907 Lisp_Object color_symbols
;
3909 while (CONSP (color_symbols
))
3911 Lisp_Object sym
= XCAR (color_symbols
);
3913 || !STRINGP (XCAR (sym
))
3914 || !STRINGP (XCDR (sym
)))
3916 color_symbols
= XCDR (color_symbols
);
3919 return NILP (color_symbols
);
3923 /* Value is non-zero if OBJECT is a valid XPM image specification. */
3926 xpm_image_p (object
)
3929 struct image_keyword fmt
[XPM_LAST
];
3930 bcopy (xpm_format
, fmt
, sizeof fmt
);
3931 return (parse_image_spec (object
, fmt
, XPM_LAST
, Qxpm
)
3932 /* Either `:file' or `:data' must be present. */
3933 && fmt
[XPM_FILE
].count
+ fmt
[XPM_DATA
].count
== 1
3934 /* Either no `:color-symbols' or it's a list of conses
3935 whose car and cdr are strings. */
3936 && (fmt
[XPM_COLOR_SYMBOLS
].count
== 0
3937 || xpm_valid_color_symbols_p (fmt
[XPM_COLOR_SYMBOLS
].value
)));
3940 #endif /* HAVE_XPM || MAC_OS */
3942 #if defined (HAVE_XPM) && defined (HAVE_X_WINDOWS)
3944 x_create_bitmap_from_xpm_data (f
, bits
)
3948 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
3950 XpmAttributes attrs
;
3951 Pixmap bitmap
, mask
;
3953 bzero (&attrs
, sizeof attrs
);
3955 attrs
.visual
= FRAME_X_VISUAL (f
);
3956 attrs
.colormap
= FRAME_X_COLORMAP (f
);
3957 attrs
.valuemask
|= XpmVisual
;
3958 attrs
.valuemask
|= XpmColormap
;
3960 rc
= XpmCreatePixmapFromData (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3961 bits
, &bitmap
, &mask
, &attrs
);
3962 if (rc
!= XpmSuccess
)
3964 XpmFreeAttributes (&attrs
);
3968 id
= x_allocate_bitmap_record (f
);
3969 dpyinfo
->bitmaps
[id
- 1].pixmap
= bitmap
;
3970 dpyinfo
->bitmaps
[id
- 1].have_mask
= 1;
3971 dpyinfo
->bitmaps
[id
- 1].mask
= mask
;
3972 dpyinfo
->bitmaps
[id
- 1].file
= NULL
;
3973 dpyinfo
->bitmaps
[id
- 1].height
= attrs
.height
;
3974 dpyinfo
->bitmaps
[id
- 1].width
= attrs
.width
;
3975 dpyinfo
->bitmaps
[id
- 1].depth
= attrs
.depth
;
3976 dpyinfo
->bitmaps
[id
- 1].refcount
= 1;
3978 XpmFreeAttributes (&attrs
);
3981 #endif /* defined (HAVE_XPM) && defined (HAVE_X_WINDOWS) */
3983 /* Load image IMG which will be displayed on frame F. Value is
3984 non-zero if successful. */
3994 XpmAttributes attrs
;
3995 Lisp_Object specified_file
, color_symbols
;
3998 xpm_XImage
* xpm_image
= NULL
, * xpm_mask
= NULL
;
3999 #endif /* HAVE_NTGUI */
4001 /* Configure the XPM lib. Use the visual of frame F. Allocate
4002 close colors. Return colors allocated. */
4003 bzero (&attrs
, sizeof attrs
);
4006 attrs
.visual
= FRAME_X_VISUAL (f
);
4007 attrs
.colormap
= FRAME_X_COLORMAP (f
);
4008 attrs
.valuemask
|= XpmVisual
;
4009 attrs
.valuemask
|= XpmColormap
;
4010 #endif /* HAVE_NTGUI */
4012 #ifdef ALLOC_XPM_COLORS
4013 /* Allocate colors with our own functions which handle
4014 failing color allocation more gracefully. */
4015 attrs
.color_closure
= f
;
4016 attrs
.alloc_color
= xpm_alloc_color
;
4017 attrs
.free_colors
= xpm_free_colors
;
4018 attrs
.valuemask
|= XpmAllocColor
| XpmFreeColors
| XpmColorClosure
;
4019 #else /* not ALLOC_XPM_COLORS */
4020 /* Let the XPM lib allocate colors. */
4021 attrs
.valuemask
|= XpmReturnAllocPixels
;
4022 #ifdef XpmAllocCloseColors
4023 attrs
.alloc_close_colors
= 1;
4024 attrs
.valuemask
|= XpmAllocCloseColors
;
4025 #else /* not XpmAllocCloseColors */
4026 attrs
.closeness
= 600;
4027 attrs
.valuemask
|= XpmCloseness
;
4028 #endif /* not XpmAllocCloseColors */
4029 #endif /* ALLOC_XPM_COLORS */
4031 /* If image specification contains symbolic color definitions, add
4032 these to `attrs'. */
4033 color_symbols
= image_spec_value (img
->spec
, QCcolor_symbols
, NULL
);
4034 if (CONSP (color_symbols
))
4037 XpmColorSymbol
*xpm_syms
;
4040 attrs
.valuemask
|= XpmColorSymbols
;
4042 /* Count number of symbols. */
4043 attrs
.numsymbols
= 0;
4044 for (tail
= color_symbols
; CONSP (tail
); tail
= XCDR (tail
))
4047 /* Allocate an XpmColorSymbol array. */
4048 size
= attrs
.numsymbols
* sizeof *xpm_syms
;
4049 xpm_syms
= (XpmColorSymbol
*) alloca (size
);
4050 bzero (xpm_syms
, size
);
4051 attrs
.colorsymbols
= xpm_syms
;
4053 /* Fill the color symbol array. */
4054 for (tail
= color_symbols
, i
= 0;
4056 ++i
, tail
= XCDR (tail
))
4058 Lisp_Object name
= XCAR (XCAR (tail
));
4059 Lisp_Object color
= XCDR (XCAR (tail
));
4060 xpm_syms
[i
].name
= (char *) alloca (SCHARS (name
) + 1);
4061 strcpy (xpm_syms
[i
].name
, SDATA (name
));
4062 xpm_syms
[i
].value
= (char *) alloca (SCHARS (color
) + 1);
4063 strcpy (xpm_syms
[i
].value
, SDATA (color
));
4067 /* Create a pixmap for the image, either from a file, or from a
4068 string buffer containing data in the same format as an XPM file. */
4069 #ifdef ALLOC_XPM_COLORS
4070 xpm_init_color_cache (f
, &attrs
);
4073 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
4077 HDC frame_dc
= get_frame_dc (f
);
4078 hdc
= CreateCompatibleDC (frame_dc
);
4079 release_frame_dc (f
, frame_dc
);
4081 #endif /* HAVE_NTGUI */
4083 if (STRINGP (specified_file
))
4085 Lisp_Object file
= x_find_image_file (specified_file
);
4086 if (!STRINGP (file
))
4088 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
4093 /* XpmReadFileToPixmap is not available in the Windows port of
4094 libxpm. But XpmReadFileToImage almost does what we want. */
4095 rc
= fn_XpmReadFileToImage (&hdc
, SDATA (file
),
4096 &xpm_image
, &xpm_mask
,
4099 rc
= XpmReadFileToPixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
4100 SDATA (file
), &img
->pixmap
, &img
->mask
,
4102 #endif /* HAVE_NTGUI */
4106 Lisp_Object buffer
= image_spec_value (img
->spec
, QCdata
, NULL
);
4108 /* XpmCreatePixmapFromBuffer is not available in the Windows port
4109 of libxpm. But XpmCreateImageFromBuffer almost does what we want. */
4110 rc
= fn_XpmCreateImageFromBuffer (&hdc
, SDATA (buffer
),
4111 &xpm_image
, &xpm_mask
,
4114 rc
= XpmCreatePixmapFromBuffer (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
4116 &img
->pixmap
, &img
->mask
,
4118 #endif /* HAVE_NTGUI */
4121 if (rc
== XpmSuccess
)
4123 #if defined (COLOR_TABLE_SUPPORT) && defined (ALLOC_XPM_COLORS)
4124 img
->colors
= colors_in_color_table (&img
->ncolors
);
4125 #else /* not ALLOC_XPM_COLORS */
4129 /* W32 XPM uses XImage to wrap what W32 Emacs calls a Pixmap,
4130 plus some duplicate attributes. */
4131 if (xpm_image
&& xpm_image
->bitmap
)
4133 img
->pixmap
= xpm_image
->bitmap
;
4134 /* XImageFree in libXpm frees XImage struct without destroying
4135 the bitmap, which is what we want. */
4136 fn_XImageFree (xpm_image
);
4138 if (xpm_mask
&& xpm_mask
->bitmap
)
4140 /* The mask appears to be inverted compared with what we expect.
4141 TODO: invert our expectations. See other places where we
4142 have to invert bits because our idea of masks is backwards. */
4144 old_obj
= SelectObject (hdc
, xpm_mask
->bitmap
);
4146 PatBlt (hdc
, 0, 0, xpm_mask
->width
, xpm_mask
->height
, DSTINVERT
);
4147 SelectObject (hdc
, old_obj
);
4149 img
->mask
= xpm_mask
->bitmap
;
4150 fn_XImageFree (xpm_mask
);
4155 #endif /* HAVE_NTGUI */
4157 /* Remember allocated colors. */
4158 img
->ncolors
= attrs
.nalloc_pixels
;
4159 img
->colors
= (unsigned long *) xmalloc (img
->ncolors
4160 * sizeof *img
->colors
);
4161 for (i
= 0; i
< attrs
.nalloc_pixels
; ++i
)
4163 img
->colors
[i
] = attrs
.alloc_pixels
[i
];
4164 #ifdef DEBUG_X_COLORS
4165 register_color (img
->colors
[i
]);
4168 #endif /* not ALLOC_XPM_COLORS */
4170 img
->width
= attrs
.width
;
4171 img
->height
= attrs
.height
;
4172 xassert (img
->width
> 0 && img
->height
> 0);
4174 /* The call to XpmFreeAttributes below frees attrs.alloc_pixels. */
4176 fn_XpmFreeAttributes (&attrs
);
4178 XpmFreeAttributes (&attrs
);
4179 #endif /* HAVE_NTGUI */
4185 #endif /* HAVE_NTGUI */
4190 image_error ("Error opening XPM file (%s)", img
->spec
, Qnil
);
4193 case XpmFileInvalid
:
4194 image_error ("Invalid XPM file (%s)", img
->spec
, Qnil
);
4198 image_error ("Out of memory (%s)", img
->spec
, Qnil
);
4201 case XpmColorFailed
:
4202 image_error ("Color allocation error (%s)", img
->spec
, Qnil
);
4206 image_error ("Unknown error (%s)", img
->spec
, Qnil
);
4211 #ifdef ALLOC_XPM_COLORS
4212 xpm_free_color_cache ();
4214 return rc
== XpmSuccess
;
4217 #endif /* HAVE_XPM */
4221 /* XPM support functions for Mac OS where libxpm is not available.
4222 Only XPM version 3 (without any extensions) is supported. */
4224 static int xpm_scan
P_ ((const unsigned char **, const unsigned char *,
4225 const unsigned char **, int *));
4226 static Lisp_Object xpm_make_color_table_v
4227 P_ ((void (**) (Lisp_Object
, const unsigned char *, int, Lisp_Object
),
4228 Lisp_Object (**) (Lisp_Object
, const unsigned char *, int)));
4229 static void xpm_put_color_table_v
P_ ((Lisp_Object
, const unsigned char *,
4231 static Lisp_Object xpm_get_color_table_v
P_ ((Lisp_Object
,
4232 const unsigned char *, int));
4233 static Lisp_Object xpm_make_color_table_h
4234 P_ ((void (**) (Lisp_Object
, const unsigned char *, int, Lisp_Object
),
4235 Lisp_Object (**) (Lisp_Object
, const unsigned char *, int)));
4236 static void xpm_put_color_table_h
P_ ((Lisp_Object
, const unsigned char *,
4238 static Lisp_Object xpm_get_color_table_h
P_ ((Lisp_Object
,
4239 const unsigned char *, int));
4240 static int xpm_str_to_color_key
P_ ((const char *));
4241 static int xpm_load_image
P_ ((struct frame
*, struct image
*,
4242 const unsigned char *, const unsigned char *));
4244 /* Tokens returned from xpm_scan. */
4253 /* Scan an XPM data and return a character (< 256) or a token defined
4254 by enum xpm_token above. *S and END are the start (inclusive) and
4255 the end (exclusive) addresses of the data, respectively. Advance
4256 *S while scanning. If token is either XPM_TK_IDENT or
4257 XPM_TK_STRING, *BEG and *LEN are set to the start address and the
4258 length of the corresponding token, respectively. */
4261 xpm_scan (s
, end
, beg
, len
)
4262 const unsigned char **s
, *end
, **beg
;
4269 /* Skip white-space. */
4270 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
4273 /* gnus-pointer.xpm uses '-' in its identifier.
4274 sb-dir-plus.xpm uses '+' in its identifier. */
4275 if (isalpha (c
) || c
== '_' || c
== '-' || c
== '+')
4279 (c
= **s
, isalnum (c
) || c
== '_' || c
== '-' || c
== '+'))
4282 return XPM_TK_IDENT
;
4287 while (*s
< end
&& **s
!= '"')
4292 return XPM_TK_STRING
;
4296 if (*s
< end
&& **s
== '*')
4298 /* C-style comment. */
4302 while (*s
< end
&& *(*s
)++ != '*')
4305 while (*s
< end
&& **s
!= '/');
4319 /* Functions for color table lookup in XPM data. A key is a string
4320 specifying the color of each pixel in XPM data. A value is either
4321 an integer that specifies a pixel color, Qt that specifies
4322 transparency, or Qnil for the unspecified color. If the length of
4323 the key string is one, a vector is used as a table. Otherwise, a
4324 hash table is used. */
4327 xpm_make_color_table_v (put_func
, get_func
)
4328 void (**put_func
) (Lisp_Object
, const unsigned char *, int, Lisp_Object
);
4329 Lisp_Object (**get_func
) (Lisp_Object
, const unsigned char *, int);
4331 *put_func
= xpm_put_color_table_v
;
4332 *get_func
= xpm_get_color_table_v
;
4333 return Fmake_vector (make_number (256), Qnil
);
4337 xpm_put_color_table_v (color_table
, chars_start
, chars_len
, color
)
4338 Lisp_Object color_table
;
4339 const unsigned char *chars_start
;
4343 XVECTOR (color_table
)->contents
[*chars_start
] = color
;
4347 xpm_get_color_table_v (color_table
, chars_start
, chars_len
)
4348 Lisp_Object color_table
;
4349 const unsigned char *chars_start
;
4352 return XVECTOR (color_table
)->contents
[*chars_start
];
4356 xpm_make_color_table_h (put_func
, get_func
)
4357 void (**put_func
) (Lisp_Object
, const unsigned char *, int, Lisp_Object
);
4358 Lisp_Object (**get_func
) (Lisp_Object
, const unsigned char *, int);
4360 *put_func
= xpm_put_color_table_h
;
4361 *get_func
= xpm_get_color_table_h
;
4362 return make_hash_table (Qequal
, make_number (DEFAULT_HASH_SIZE
),
4363 make_float (DEFAULT_REHASH_SIZE
),
4364 make_float (DEFAULT_REHASH_THRESHOLD
),
4369 xpm_put_color_table_h (color_table
, chars_start
, chars_len
, color
)
4370 Lisp_Object color_table
;
4371 const unsigned char *chars_start
;
4375 struct Lisp_Hash_Table
*table
= XHASH_TABLE (color_table
);
4377 Lisp_Object chars
= make_unibyte_string (chars_start
, chars_len
);
4379 hash_lookup (table
, chars
, &hash_code
);
4380 hash_put (table
, chars
, color
, hash_code
);
4384 xpm_get_color_table_h (color_table
, chars_start
, chars_len
)
4385 Lisp_Object color_table
;
4386 const unsigned char *chars_start
;
4389 struct Lisp_Hash_Table
*table
= XHASH_TABLE (color_table
);
4390 int i
= hash_lookup (table
, make_unibyte_string (chars_start
, chars_len
),
4393 return i
>= 0 ? HASH_VALUE (table
, i
) : Qnil
;
4396 enum xpm_color_key
{
4404 static const char xpm_color_key_strings
[][4] = {"s", "m", "g4", "g", "c"};
4407 xpm_str_to_color_key (s
)
4413 i
< sizeof xpm_color_key_strings
/ sizeof xpm_color_key_strings
[0];
4415 if (strcmp (xpm_color_key_strings
[i
], s
) == 0)
4421 xpm_load_image (f
, img
, contents
, end
)
4424 const unsigned char *contents
, *end
;
4426 const unsigned char *s
= contents
, *beg
, *str
;
4427 unsigned char buffer
[BUFSIZ
];
4428 int width
, height
, x
, y
;
4429 int num_colors
, chars_per_pixel
;
4431 void (*put_color_table
) (Lisp_Object
, const unsigned char *, int, Lisp_Object
);
4432 Lisp_Object (*get_color_table
) (Lisp_Object
, const unsigned char *, int);
4433 Lisp_Object frame
, color_symbols
, color_table
;
4434 int best_key
, have_mask
= 0;
4435 XImagePtr ximg
= NULL
, mask_img
= NULL
;
4438 LA1 = xpm_scan (&s, end, &beg, &len)
4440 #define expect(TOKEN) \
4441 if (LA1 != (TOKEN)) \
4446 #define expect_ident(IDENT) \
4447 if (LA1 == XPM_TK_IDENT \
4448 && strlen ((IDENT)) == len && memcmp ((IDENT), beg, len) == 0) \
4453 if (!(end
- s
>= 9 && memcmp (s
, "/* XPM */", 9) == 0))
4457 expect_ident ("static");
4458 expect_ident ("char");
4460 expect (XPM_TK_IDENT
);
4465 expect (XPM_TK_STRING
);
4468 memcpy (buffer
, beg
, len
);
4470 if (sscanf (buffer
, "%d %d %d %d", &width
, &height
,
4471 &num_colors
, &chars_per_pixel
) != 4
4472 || width
<= 0 || height
<= 0
4473 || num_colors
<= 0 || chars_per_pixel
<= 0)
4476 if (!check_image_size (f
, width
, height
))
4478 image_error ("Invalid image size", Qnil
, Qnil
);
4484 XSETFRAME (frame
, f
);
4485 if (!NILP (Fxw_display_color_p (frame
)))
4486 best_key
= XPM_COLOR_KEY_C
;
4487 else if (!NILP (Fx_display_grayscale_p (frame
)))
4488 best_key
= (XFASTINT (Fx_display_planes (frame
)) > 2
4489 ? XPM_COLOR_KEY_G
: XPM_COLOR_KEY_G4
);
4491 best_key
= XPM_COLOR_KEY_M
;
4493 color_symbols
= image_spec_value (img
->spec
, QCcolor_symbols
, NULL
);
4494 if (chars_per_pixel
== 1)
4495 color_table
= xpm_make_color_table_v (&put_color_table
,
4498 color_table
= xpm_make_color_table_h (&put_color_table
,
4501 while (num_colors
-- > 0)
4503 unsigned char *color
, *max_color
;
4504 int key
, next_key
, max_key
= 0;
4505 Lisp_Object symbol_color
= Qnil
, color_val
;
4508 expect (XPM_TK_STRING
);
4509 if (len
<= chars_per_pixel
|| len
>= BUFSIZ
+ chars_per_pixel
)
4511 memcpy (buffer
, beg
+ chars_per_pixel
, len
- chars_per_pixel
);
4512 buffer
[len
- chars_per_pixel
] = '\0';
4514 str
= strtok (buffer
, " \t");
4517 key
= xpm_str_to_color_key (str
);
4522 color
= strtok (NULL
, " \t");
4526 while ((str
= strtok (NULL
, " \t")) != NULL
)
4528 next_key
= xpm_str_to_color_key (str
);
4531 color
[strlen (color
)] = ' ';
4534 if (key
== XPM_COLOR_KEY_S
)
4536 if (NILP (symbol_color
))
4537 symbol_color
= build_string (color
);
4539 else if (max_key
< key
&& key
<= best_key
)
4549 if (!NILP (color_symbols
) && !NILP (symbol_color
))
4551 Lisp_Object specified_color
= Fassoc (symbol_color
, color_symbols
);
4553 if (CONSP (specified_color
) && STRINGP (XCDR (specified_color
)))
4555 if (xstricmp (SDATA (XCDR (specified_color
)), "None") == 0)
4557 else if (x_defined_color (f
, SDATA (XCDR (specified_color
)),
4559 color_val
= make_number (cdef
.pixel
);
4562 if (NILP (color_val
) && max_key
> 0)
4564 if (xstricmp (max_color
, "None") == 0)
4566 else if (x_defined_color (f
, max_color
, &cdef
, 0))
4567 color_val
= make_number (cdef
.pixel
);
4569 if (!NILP (color_val
))
4570 (*put_color_table
) (color_table
, beg
, chars_per_pixel
, color_val
);
4575 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0,
4576 &ximg
, &img
->pixmap
)
4577 || !x_create_x_image_and_pixmap (f
, width
, height
, 1,
4578 &mask_img
, &img
->mask
))
4580 image_error ("Out of memory (%s)", img
->spec
, Qnil
);
4584 for (y
= 0; y
< height
; y
++)
4586 expect (XPM_TK_STRING
);
4588 if (len
< width
* chars_per_pixel
)
4590 for (x
= 0; x
< width
; x
++, str
+= chars_per_pixel
)
4592 Lisp_Object color_val
=
4593 (*get_color_table
) (color_table
, str
, chars_per_pixel
);
4595 XPutPixel (ximg
, x
, y
,
4596 (INTEGERP (color_val
) ? XINT (color_val
)
4597 : FRAME_FOREGROUND_PIXEL (f
)));
4598 XPutPixel (mask_img
, x
, y
,
4599 (!EQ (color_val
, Qt
) ? PIX_MASK_DRAW
4600 : (have_mask
= 1, PIX_MASK_RETAIN
)));
4607 img
->height
= height
;
4609 /* Maybe fill in the background field while we have ximg handy. */
4610 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
4611 IMAGE_BACKGROUND (img
, f
, ximg
);
4613 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
4614 x_destroy_x_image (ximg
);
4617 /* Fill in the background_transparent field while we have the
4619 image_background_transparent (img
, f
, mask_img
);
4621 x_put_x_image (f
, mask_img
, img
->mask
, width
, height
);
4622 x_destroy_x_image (mask_img
);
4626 x_destroy_x_image (mask_img
);
4627 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
4628 img
->mask
= NO_PIXMAP
;
4634 image_error ("Invalid XPM file (%s)", img
->spec
, Qnil
);
4636 x_destroy_x_image (ximg
);
4637 x_destroy_x_image (mask_img
);
4638 x_clear_image (f
, img
);
4652 Lisp_Object file_name
;
4654 /* If IMG->spec specifies a file name, create a non-file spec from it. */
4655 file_name
= image_spec_value (img
->spec
, QCfile
, NULL
);
4656 if (STRINGP (file_name
))
4659 unsigned char *contents
;
4661 struct gcpro gcpro1
;
4663 file
= x_find_image_file (file_name
);
4665 if (!STRINGP (file
))
4667 image_error ("Cannot find image file `%s'", file_name
, Qnil
);
4672 contents
= slurp_file (SDATA (file
), &size
);
4673 if (contents
== NULL
)
4675 image_error ("Error loading XPM image `%s'", img
->spec
, Qnil
);
4680 success_p
= xpm_load_image (f
, img
, contents
, contents
+ size
);
4688 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
4689 success_p
= xpm_load_image (f
, img
, SDATA (data
),
4690 SDATA (data
) + SBYTES (data
));
4700 /***********************************************************************
4702 ***********************************************************************/
4704 #ifdef COLOR_TABLE_SUPPORT
4706 /* An entry in the color table mapping an RGB color to a pixel color. */
4711 unsigned long pixel
;
4713 /* Next in color table collision list. */
4714 struct ct_color
*next
;
4717 /* The bucket vector size to use. Must be prime. */
4721 /* Value is a hash of the RGB color given by R, G, and B. */
4723 #define CT_HASH_RGB(R, G, B) (((R) << 16) ^ ((G) << 8) ^ (B))
4725 /* The color hash table. */
4727 struct ct_color
**ct_table
;
4729 /* Number of entries in the color table. */
4731 int ct_colors_allocated
;
4733 /* Initialize the color table. */
4738 int size
= CT_SIZE
* sizeof (*ct_table
);
4739 ct_table
= (struct ct_color
**) xmalloc (size
);
4740 bzero (ct_table
, size
);
4741 ct_colors_allocated
= 0;
4745 /* Free memory associated with the color table. */
4751 struct ct_color
*p
, *next
;
4753 for (i
= 0; i
< CT_SIZE
; ++i
)
4754 for (p
= ct_table
[i
]; p
; p
= next
)
4765 /* Value is a pixel color for RGB color R, G, B on frame F. If an
4766 entry for that color already is in the color table, return the
4767 pixel color of that entry. Otherwise, allocate a new color for R,
4768 G, B, and make an entry in the color table. */
4770 static unsigned long
4771 lookup_rgb_color (f
, r
, g
, b
)
4775 unsigned hash
= CT_HASH_RGB (r
, g
, b
);
4776 int i
= hash
% CT_SIZE
;
4778 Display_Info
*dpyinfo
;
4780 /* Handle TrueColor visuals specially, which improves performance by
4781 two orders of magnitude. Freeing colors on TrueColor visuals is
4782 a nop, and pixel colors specify RGB values directly. See also
4783 the Xlib spec, chapter 3.1. */
4784 dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
4785 if (dpyinfo
->red_bits
> 0)
4787 unsigned long pr
, pg
, pb
;
4789 /* Apply gamma-correction like normal color allocation does. */
4793 color
.red
= r
, color
.green
= g
, color
.blue
= b
;
4794 gamma_correct (f
, &color
);
4795 r
= color
.red
, g
= color
.green
, b
= color
.blue
;
4798 /* Scale down RGB values to the visual's bits per RGB, and shift
4799 them to the right position in the pixel color. Note that the
4800 original RGB values are 16-bit values, as usual in X. */
4801 pr
= (r
>> (16 - dpyinfo
->red_bits
)) << dpyinfo
->red_offset
;
4802 pg
= (g
>> (16 - dpyinfo
->green_bits
)) << dpyinfo
->green_offset
;
4803 pb
= (b
>> (16 - dpyinfo
->blue_bits
)) << dpyinfo
->blue_offset
;
4805 /* Assemble the pixel color. */
4806 return pr
| pg
| pb
;
4809 for (p
= ct_table
[i
]; p
; p
= p
->next
)
4810 if (p
->r
== r
&& p
->g
== g
&& p
->b
== b
)
4816 #ifdef HAVE_X_WINDOWS
4825 cmap
= FRAME_X_COLORMAP (f
);
4826 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
4829 ++ct_colors_allocated
;
4830 p
= (struct ct_color
*) xmalloc (sizeof *p
);
4834 p
->pixel
= color
.pixel
;
4835 p
->next
= ct_table
[i
];
4839 return FRAME_FOREGROUND_PIXEL (f
);
4844 color
= PALETTERGB (r
, g
, b
);
4846 color
= RGB_TO_ULONG (r
, g
, b
);
4847 #endif /* HAVE_NTGUI */
4848 ++ct_colors_allocated
;
4849 p
= (struct ct_color
*) xmalloc (sizeof *p
);
4854 p
->next
= ct_table
[i
];
4856 #endif /* HAVE_X_WINDOWS */
4864 /* Look up pixel color PIXEL which is used on frame F in the color
4865 table. If not already present, allocate it. Value is PIXEL. */
4867 static unsigned long
4868 lookup_pixel_color (f
, pixel
)
4870 unsigned long pixel
;
4872 int i
= pixel
% CT_SIZE
;
4875 for (p
= ct_table
[i
]; p
; p
= p
->next
)
4876 if (p
->pixel
== pixel
)
4885 #ifdef HAVE_X_WINDOWS
4886 cmap
= FRAME_X_COLORMAP (f
);
4887 color
.pixel
= pixel
;
4888 x_query_color (f
, &color
);
4889 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
4892 cmap
= DefaultColormapOfScreen (FRAME_X_SCREEN (f
));
4893 color
.pixel
= pixel
;
4894 XQueryColor (NULL
, cmap
, &color
);
4895 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
4897 #endif /* HAVE_X_WINDOWS */
4901 ++ct_colors_allocated
;
4903 p
= (struct ct_color
*) xmalloc (sizeof *p
);
4908 p
->next
= ct_table
[i
];
4912 return FRAME_FOREGROUND_PIXEL (f
);
4918 /* Value is a vector of all pixel colors contained in the color table,
4919 allocated via xmalloc. Set *N to the number of colors. */
4921 static unsigned long *
4922 colors_in_color_table (n
)
4927 unsigned long *colors
;
4929 if (ct_colors_allocated
== 0)
4936 colors
= (unsigned long *) xmalloc (ct_colors_allocated
4938 *n
= ct_colors_allocated
;
4940 for (i
= j
= 0; i
< CT_SIZE
; ++i
)
4941 for (p
= ct_table
[i
]; p
; p
= p
->next
)
4942 colors
[j
++] = p
->pixel
;
4948 #else /* COLOR_TABLE_SUPPORT */
4950 static unsigned long
4951 lookup_rgb_color (f
, r
, g
, b
)
4955 unsigned long pixel
;
4958 pixel
= RGB_TO_ULONG (r
>> 8, g
>> 8, b
>> 8);
4959 gamma_correct (f
, &pixel
);
4963 pixel
= PALETTERGB (r
>> 8, g
>> 8, b
>> 8);
4964 #endif /* HAVE_NTGUI */
4973 #endif /* COLOR_TABLE_SUPPORT */
4976 /***********************************************************************
4978 ***********************************************************************/
4980 static XColor
*x_to_xcolors
P_ ((struct frame
*, struct image
*, int));
4981 static void x_from_xcolors
P_ ((struct frame
*, struct image
*, XColor
*));
4982 static void x_detect_edges
P_ ((struct frame
*, struct image
*, int[9], int));
4985 static void XPutPixel (XImagePtr
, int, int, COLORREF
);
4986 #endif /* HAVE_NTGUI */
4988 /* Non-zero means draw a cross on images having `:conversion
4991 int cross_disabled_images
;
4993 /* Edge detection matrices for different edge-detection
4996 static int emboss_matrix
[9] = {
4998 2, -1, 0, /* y - 1 */
5000 0, 1, -2 /* y + 1 */
5003 static int laplace_matrix
[9] = {
5005 1, 0, 0, /* y - 1 */
5007 0, 0, -1 /* y + 1 */
5010 /* Value is the intensity of the color whose red/green/blue values
5013 #define COLOR_INTENSITY(R, G, B) ((2 * (R) + 3 * (G) + (B)) / 6)
5016 /* On frame F, return an array of XColor structures describing image
5017 IMG->pixmap. Each XColor structure has its pixel color set. RGB_P
5018 non-zero means also fill the red/green/blue members of the XColor
5019 structures. Value is a pointer to the array of XColors structures,
5020 allocated with xmalloc; it must be freed by the caller. */
5023 x_to_xcolors (f
, img
, rgb_p
)
5030 XImagePtr_or_DC ximg
;
5034 #endif /* HAVE_NTGUI */
5036 colors
= (XColor
*) xmalloc (img
->width
* img
->height
* sizeof *colors
);
5039 /* Get the X image IMG->pixmap. */
5040 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
5041 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
5043 /* Load the image into a memory device context. */
5044 hdc
= get_frame_dc (f
);
5045 ximg
= CreateCompatibleDC (hdc
);
5046 release_frame_dc (f
, hdc
);
5047 prev
= SelectObject (ximg
, img
->pixmap
);
5048 #endif /* HAVE_NTGUI */
5050 /* Fill the `pixel' members of the XColor array. I wished there
5051 were an easy and portable way to circumvent XGetPixel. */
5053 for (y
= 0; y
< img
->height
; ++y
)
5057 #ifdef HAVE_X_WINDOWS
5058 for (x
= 0; x
< img
->width
; ++x
, ++p
)
5059 p
->pixel
= XGetPixel (ximg
, x
, y
);
5061 x_query_colors (f
, row
, img
->width
);
5065 for (x
= 0; x
< img
->width
; ++x
, ++p
)
5067 /* W32_TODO: palette support needed here? */
5068 p
->pixel
= GET_PIXEL (ximg
, x
, y
);
5072 p
->red
= RED16_FROM_ULONG (p
->pixel
);
5073 p
->green
= GREEN16_FROM_ULONG (p
->pixel
);
5074 p
->blue
= BLUE16_FROM_ULONG (p
->pixel
);
5077 p
->red
= 256 * GetRValue (p
->pixel
);
5078 p
->green
= 256 * GetGValue (p
->pixel
);
5079 p
->blue
= 256 * GetBValue (p
->pixel
);
5080 #endif /* HAVE_NTGUI */
5083 #endif /* HAVE_X_WINDOWS */
5086 Destroy_Image (ximg
, prev
);
5093 /* Put a pixel of COLOR at position X, Y in XIMG. XIMG must have been
5094 created with CreateDIBSection, with the pointer to the bit values
5095 stored in ximg->data. */
5098 XPutPixel (ximg
, x
, y
, color
)
5103 int width
= ximg
->info
.bmiHeader
.biWidth
;
5104 int height
= ximg
->info
.bmiHeader
.biHeight
;
5105 unsigned char * pixel
;
5107 /* True color images. */
5108 if (ximg
->info
.bmiHeader
.biBitCount
== 24)
5110 int rowbytes
= width
* 3;
5111 /* Ensure scanlines are aligned on 4 byte boundaries. */
5113 rowbytes
+= 4 - (rowbytes
% 4);
5115 pixel
= ximg
->data
+ y
* rowbytes
+ x
* 3;
5116 /* Windows bitmaps are in BGR order. */
5117 *pixel
= GetBValue (color
);
5118 *(pixel
+ 1) = GetGValue (color
);
5119 *(pixel
+ 2) = GetRValue (color
);
5121 /* Monochrome images. */
5122 else if (ximg
->info
.bmiHeader
.biBitCount
== 1)
5124 int rowbytes
= width
/ 8;
5125 /* Ensure scanlines are aligned on 4 byte boundaries. */
5127 rowbytes
+= 4 - (rowbytes
% 4);
5128 pixel
= ximg
->data
+ y
* rowbytes
+ x
/ 8;
5129 /* Filter out palette info. */
5130 if (color
& 0x00ffffff)
5131 *pixel
= *pixel
| (1 << x
% 8);
5133 *pixel
= *pixel
& ~(1 << x
% 8);
5136 image_error ("XPutPixel: palette image not supported", Qnil
, Qnil
);
5139 #endif /* HAVE_NTGUI */
5141 /* Create IMG->pixmap from an array COLORS of XColor structures, whose
5142 RGB members are set. F is the frame on which this all happens.
5143 COLORS will be freed; an existing IMG->pixmap will be freed, too. */
5146 x_from_xcolors (f
, img
, colors
)
5156 init_color_table ();
5158 x_create_x_image_and_pixmap (f
, img
->width
, img
->height
, 0,
5161 for (y
= 0; y
< img
->height
; ++y
)
5162 for (x
= 0; x
< img
->width
; ++x
, ++p
)
5164 unsigned long pixel
;
5165 pixel
= lookup_rgb_color (f
, p
->red
, p
->green
, p
->blue
);
5166 XPutPixel (oimg
, x
, y
, pixel
);
5170 x_clear_image_1 (f
, img
, 1, 0, 1);
5172 x_put_x_image (f
, oimg
, pixmap
, img
->width
, img
->height
);
5173 x_destroy_x_image (oimg
);
5174 img
->pixmap
= pixmap
;
5175 #ifdef COLOR_TABLE_SUPPORT
5176 img
->colors
= colors_in_color_table (&img
->ncolors
);
5177 free_color_table ();
5178 #endif /* COLOR_TABLE_SUPPORT */
5182 /* On frame F, perform edge-detection on image IMG.
5184 MATRIX is a nine-element array specifying the transformation
5185 matrix. See emboss_matrix for an example.
5187 COLOR_ADJUST is a color adjustment added to each pixel of the
5191 x_detect_edges (f
, img
, matrix
, color_adjust
)
5194 int matrix
[9], color_adjust
;
5196 XColor
*colors
= x_to_xcolors (f
, img
, 1);
5200 for (i
= sum
= 0; i
< 9; ++i
)
5201 sum
+= eabs (matrix
[i
]);
5203 #define COLOR(A, X, Y) ((A) + (Y) * img->width + (X))
5205 new = (XColor
*) xmalloc (img
->width
* img
->height
* sizeof *new);
5207 for (y
= 0; y
< img
->height
; ++y
)
5209 p
= COLOR (new, 0, y
);
5210 p
->red
= p
->green
= p
->blue
= 0xffff/2;
5211 p
= COLOR (new, img
->width
- 1, y
);
5212 p
->red
= p
->green
= p
->blue
= 0xffff/2;
5215 for (x
= 1; x
< img
->width
- 1; ++x
)
5217 p
= COLOR (new, x
, 0);
5218 p
->red
= p
->green
= p
->blue
= 0xffff/2;
5219 p
= COLOR (new, x
, img
->height
- 1);
5220 p
->red
= p
->green
= p
->blue
= 0xffff/2;
5223 for (y
= 1; y
< img
->height
- 1; ++y
)
5225 p
= COLOR (new, 1, y
);
5227 for (x
= 1; x
< img
->width
- 1; ++x
, ++p
)
5229 int r
, g
, b
, y1
, x1
;
5232 for (y1
= y
- 1; y1
< y
+ 2; ++y1
)
5233 for (x1
= x
- 1; x1
< x
+ 2; ++x1
, ++i
)
5236 XColor
*t
= COLOR (colors
, x1
, y1
);
5237 r
+= matrix
[i
] * t
->red
;
5238 g
+= matrix
[i
] * t
->green
;
5239 b
+= matrix
[i
] * t
->blue
;
5242 r
= (r
/ sum
+ color_adjust
) & 0xffff;
5243 g
= (g
/ sum
+ color_adjust
) & 0xffff;
5244 b
= (b
/ sum
+ color_adjust
) & 0xffff;
5245 p
->red
= p
->green
= p
->blue
= COLOR_INTENSITY (r
, g
, b
);
5250 x_from_xcolors (f
, img
, new);
5256 /* Perform the pre-defined `emboss' edge-detection on image IMG
5264 x_detect_edges (f
, img
, emboss_matrix
, 0xffff / 2);
5268 /* Transform image IMG which is used on frame F with a Laplace
5269 edge-detection algorithm. The result is an image that can be used
5270 to draw disabled buttons, for example. */
5277 x_detect_edges (f
, img
, laplace_matrix
, 45000);
5281 /* Perform edge-detection on image IMG on frame F, with specified
5282 transformation matrix MATRIX and color-adjustment COLOR_ADJUST.
5284 MATRIX must be either
5286 - a list of at least 9 numbers in row-major form
5287 - a vector of at least 9 numbers
5289 COLOR_ADJUST nil means use a default; otherwise it must be a
5293 x_edge_detection (f
, img
, matrix
, color_adjust
)
5296 Lisp_Object matrix
, color_adjust
;
5304 i
< 9 && CONSP (matrix
) && NUMBERP (XCAR (matrix
));
5305 ++i
, matrix
= XCDR (matrix
))
5306 trans
[i
] = XFLOATINT (XCAR (matrix
));
5308 else if (VECTORP (matrix
) && ASIZE (matrix
) >= 9)
5310 for (i
= 0; i
< 9 && NUMBERP (AREF (matrix
, i
)); ++i
)
5311 trans
[i
] = XFLOATINT (AREF (matrix
, i
));
5314 if (NILP (color_adjust
))
5315 color_adjust
= make_number (0xffff / 2);
5317 if (i
== 9 && NUMBERP (color_adjust
))
5318 x_detect_edges (f
, img
, trans
, (int) XFLOATINT (color_adjust
));
5322 /* Transform image IMG on frame F so that it looks disabled. */
5325 x_disable_image (f
, img
)
5329 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
5331 int n_planes
= dpyinfo
->n_planes
* dpyinfo
->n_cbits
;
5333 int n_planes
= dpyinfo
->n_planes
;
5334 #endif /* HAVE_NTGUI */
5338 /* Color (or grayscale). Convert to gray, and equalize. Just
5339 drawing such images with a stipple can look very odd, so
5340 we're using this method instead. */
5341 XColor
*colors
= x_to_xcolors (f
, img
, 1);
5343 const int h
= 15000;
5344 const int l
= 30000;
5346 for (p
= colors
, end
= colors
+ img
->width
* img
->height
;
5350 int i
= COLOR_INTENSITY (p
->red
, p
->green
, p
->blue
);
5351 int i2
= (0xffff - h
- l
) * i
/ 0xffff + l
;
5352 p
->red
= p
->green
= p
->blue
= i2
;
5355 x_from_xcolors (f
, img
, colors
);
5358 /* Draw a cross over the disabled image, if we must or if we
5360 if (n_planes
< 2 || cross_disabled_images
)
5363 Display
*dpy
= FRAME_X_DISPLAY (f
);
5367 #define MaskForeground(f) PIX_MASK_DRAW
5369 #define MaskForeground(f) WHITE_PIX_DEFAULT (f)
5372 gc
= XCreateGC (dpy
, img
->pixmap
, 0, NULL
);
5373 XSetForeground (dpy
, gc
, BLACK_PIX_DEFAULT (f
));
5374 XDrawLine (dpy
, img
->pixmap
, gc
, 0, 0,
5375 img
->width
- 1, img
->height
- 1);
5376 XDrawLine (dpy
, img
->pixmap
, gc
, 0, img
->height
- 1,
5382 gc
= XCreateGC (dpy
, img
->mask
, 0, NULL
);
5383 XSetForeground (dpy
, gc
, MaskForeground (f
));
5384 XDrawLine (dpy
, img
->mask
, gc
, 0, 0,
5385 img
->width
- 1, img
->height
- 1);
5386 XDrawLine (dpy
, img
->mask
, gc
, 0, img
->height
- 1,
5394 hdc
= get_frame_dc (f
);
5395 bmpdc
= CreateCompatibleDC (hdc
);
5396 release_frame_dc (f
, hdc
);
5398 prev
= SelectObject (bmpdc
, img
->pixmap
);
5400 SetTextColor (bmpdc
, BLACK_PIX_DEFAULT (f
));
5401 MoveToEx (bmpdc
, 0, 0, NULL
);
5402 LineTo (bmpdc
, img
->width
- 1, img
->height
- 1);
5403 MoveToEx (bmpdc
, 0, img
->height
- 1, NULL
);
5404 LineTo (bmpdc
, img
->width
- 1, 0);
5408 SelectObject (bmpdc
, img
->mask
);
5409 SetTextColor (bmpdc
, WHITE_PIX_DEFAULT (f
));
5410 MoveToEx (bmpdc
, 0, 0, NULL
);
5411 LineTo (bmpdc
, img
->width
- 1, img
->height
- 1);
5412 MoveToEx (bmpdc
, 0, img
->height
- 1, NULL
);
5413 LineTo (bmpdc
, img
->width
- 1, 0);
5415 SelectObject (bmpdc
, prev
);
5417 #endif /* HAVE_NTGUI */
5422 /* Build a mask for image IMG which is used on frame F. FILE is the
5423 name of an image file, for error messages. HOW determines how to
5424 determine the background color of IMG. If it is a list '(R G B)',
5425 with R, G, and B being integers >= 0, take that as the color of the
5426 background. Otherwise, determine the background color of IMG
5427 heuristically. Value is non-zero if successful. */
5430 x_build_heuristic_mask (f
, img
, how
)
5435 XImagePtr_or_DC ximg
;
5443 #endif /* HAVE_NTGUI */
5444 int x
, y
, rc
, use_img_background
;
5445 unsigned long bg
= 0;
5449 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
5450 img
->mask
= NO_PIXMAP
;
5451 img
->background_transparent_valid
= 0;
5455 /* Create an image and pixmap serving as mask. */
5456 rc
= x_create_x_image_and_pixmap (f
, img
->width
, img
->height
, 1,
5457 &mask_img
, &img
->mask
);
5461 /* Get the X image of IMG->pixmap. */
5462 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
, 0, 0,
5463 img
->width
, img
->height
,
5466 /* Create the bit array serving as mask. */
5467 row_width
= (img
->width
+ 7) / 8;
5468 mask_img
= xmalloc (row_width
* img
->height
);
5469 bzero (mask_img
, row_width
* img
->height
);
5471 /* Create a memory device context for IMG->pixmap. */
5472 frame_dc
= get_frame_dc (f
);
5473 ximg
= CreateCompatibleDC (frame_dc
);
5474 release_frame_dc (f
, frame_dc
);
5475 prev
= SelectObject (ximg
, img
->pixmap
);
5476 #endif /* HAVE_NTGUI */
5478 /* Determine the background color of ximg. If HOW is `(R G B)'
5479 take that as color. Otherwise, use the image's background color. */
5480 use_img_background
= 1;
5486 for (i
= 0; i
< 3 && CONSP (how
) && NATNUMP (XCAR (how
)); ++i
)
5488 rgb
[i
] = XFASTINT (XCAR (how
)) & 0xffff;
5492 if (i
== 3 && NILP (how
))
5494 char color_name
[30];
5495 sprintf (color_name
, "#%04x%04x%04x", rgb
[0], rgb
[1], rgb
[2]);
5498 0x00ffffff & /* Filter out palette info. */
5499 #endif /* HAVE_NTGUI */
5500 x_alloc_image_color (f
, img
, build_string (color_name
), 0));
5501 use_img_background
= 0;
5505 if (use_img_background
)
5506 bg
= four_corners_best (ximg
, img
->corners
, img
->width
, img
->height
);
5508 /* Set all bits in mask_img to 1 whose color in ximg is different
5509 from the background color bg. */
5511 for (y
= 0; y
< img
->height
; ++y
)
5512 for (x
= 0; x
< img
->width
; ++x
)
5513 XPutPixel (mask_img
, x
, y
, (XGetPixel (ximg
, x
, y
) != bg
5514 ? PIX_MASK_DRAW
: PIX_MASK_RETAIN
));
5516 /* Fill in the background_transparent field while we have the mask handy. */
5517 image_background_transparent (img
, f
, mask_img
);
5519 /* Put mask_img into img->mask. */
5520 x_put_x_image (f
, mask_img
, img
->mask
, img
->width
, img
->height
);
5521 x_destroy_x_image (mask_img
);
5524 for (y
= 0; y
< img
->height
; ++y
)
5525 for (x
= 0; x
< img
->width
; ++x
)
5527 COLORREF p
= GetPixel (ximg
, x
, y
);
5529 mask_img
[y
* row_width
+ x
/ 8] |= 1 << (x
% 8);
5532 /* Create the mask image. */
5533 img
->mask
= w32_create_pixmap_from_bitmap_data (img
->width
, img
->height
,
5535 /* Fill in the background_transparent field while we have the mask handy. */
5536 SelectObject (ximg
, img
->mask
);
5537 image_background_transparent (img
, f
, ximg
);
5539 /* Was: x_destroy_x_image ((XImagePtr )mask_img); which seems bogus ++kfs */
5541 #endif /* HAVE_NTGUI */
5543 Destroy_Image (ximg
, prev
);
5549 /***********************************************************************
5550 PBM (mono, gray, color)
5551 ***********************************************************************/
5553 static int pbm_image_p
P_ ((Lisp_Object object
));
5554 static int pbm_load
P_ ((struct frame
*f
, struct image
*img
));
5555 static int pbm_scan_number
P_ ((unsigned char **, unsigned char *));
5557 /* The symbol `pbm' identifying images of this type. */
5561 /* Indices of image specification fields in gs_format, below. */
5563 enum pbm_keyword_index
5579 /* Vector of image_keyword structures describing the format
5580 of valid user-defined image specifications. */
5582 static struct image_keyword pbm_format
[PBM_LAST
] =
5584 {":type", IMAGE_SYMBOL_VALUE
, 1},
5585 {":file", IMAGE_STRING_VALUE
, 0},
5586 {":data", IMAGE_STRING_VALUE
, 0},
5587 {":ascent", IMAGE_ASCENT_VALUE
, 0},
5588 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
5589 {":relief", IMAGE_INTEGER_VALUE
, 0},
5590 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5591 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5592 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5593 {":foreground", IMAGE_STRING_OR_NIL_VALUE
, 0},
5594 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
5597 /* Structure describing the image type `pbm'. */
5599 static struct image_type pbm_type
=
5609 /* Return non-zero if OBJECT is a valid PBM image specification. */
5612 pbm_image_p (object
)
5615 struct image_keyword fmt
[PBM_LAST
];
5617 bcopy (pbm_format
, fmt
, sizeof fmt
);
5619 if (!parse_image_spec (object
, fmt
, PBM_LAST
, Qpbm
))
5622 /* Must specify either :data or :file. */
5623 return fmt
[PBM_DATA
].count
+ fmt
[PBM_FILE
].count
== 1;
5627 /* Scan a decimal number from *S and return it. Advance *S while
5628 reading the number. END is the end of the string. Value is -1 at
5632 pbm_scan_number (s
, end
)
5633 unsigned char **s
, *end
;
5635 int c
= 0, val
= -1;
5639 /* Skip white-space. */
5640 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
5645 /* Skip comment to end of line. */
5646 while (*s
< end
&& (c
= *(*s
)++, c
!= '\n'))
5649 else if (isdigit (c
))
5651 /* Read decimal number. */
5653 while (*s
< end
&& (c
= *(*s
)++, isdigit (c
)))
5654 val
= 10 * val
+ c
- '0';
5666 #if 0 /* Unused. ++kfs */
5668 /* Read FILE into memory. Value is a pointer to a buffer allocated
5669 with xmalloc holding FILE's contents. Value is null if an error
5670 occurred. *SIZE is set to the size of the file. */
5673 pbm_read_file (file
, size
)
5681 if (stat (SDATA (file
), &st
) == 0
5682 && (fp
= fopen (SDATA (file
), "rb")) != NULL
5683 && (buf
= (char *) xmalloc (st
.st_size
),
5684 fread (buf
, 1, st
.st_size
, fp
) == st
.st_size
))
5703 #endif /* HAVE_NTGUI */
5705 /* Load PBM image IMG for use on frame F. */
5713 int width
, height
, max_color_idx
= 0;
5715 Lisp_Object file
, specified_file
;
5716 enum {PBM_MONO
, PBM_GRAY
, PBM_COLOR
} type
;
5717 struct gcpro gcpro1
;
5718 unsigned char *contents
= NULL
;
5719 unsigned char *end
, *p
;
5722 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
5726 if (STRINGP (specified_file
))
5728 file
= x_find_image_file (specified_file
);
5729 if (!STRINGP (file
))
5731 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
5736 contents
= slurp_file (SDATA (file
), &size
);
5737 if (contents
== NULL
)
5739 image_error ("Error reading `%s'", file
, Qnil
);
5745 end
= contents
+ size
;
5750 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
5752 end
= p
+ SBYTES (data
);
5755 /* Check magic number. */
5756 if (end
- p
< 2 || *p
++ != 'P')
5758 image_error ("Not a PBM image: `%s'", img
->spec
, Qnil
);
5768 raw_p
= 0, type
= PBM_MONO
;
5772 raw_p
= 0, type
= PBM_GRAY
;
5776 raw_p
= 0, type
= PBM_COLOR
;
5780 raw_p
= 1, type
= PBM_MONO
;
5784 raw_p
= 1, type
= PBM_GRAY
;
5788 raw_p
= 1, type
= PBM_COLOR
;
5792 image_error ("Not a PBM image: `%s'", img
->spec
, Qnil
);
5796 /* Read width, height, maximum color-component. Characters
5797 starting with `#' up to the end of a line are ignored. */
5798 width
= pbm_scan_number (&p
, end
);
5799 height
= pbm_scan_number (&p
, end
);
5801 if (type
!= PBM_MONO
)
5803 max_color_idx
= pbm_scan_number (&p
, end
);
5804 if (max_color_idx
> 65535 || max_color_idx
< 0)
5806 image_error ("Unsupported maximum PBM color value", Qnil
, Qnil
);
5811 if (!check_image_size (f
, width
, height
))
5813 image_error ("Invalid image size", Qnil
, Qnil
);
5817 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0,
5818 &ximg
, &img
->pixmap
))
5821 /* Initialize the color hash table. */
5822 init_color_table ();
5824 if (type
== PBM_MONO
)
5827 struct image_keyword fmt
[PBM_LAST
];
5828 unsigned long fg
= FRAME_FOREGROUND_PIXEL (f
);
5829 unsigned long bg
= FRAME_BACKGROUND_PIXEL (f
);
5831 /* Parse the image specification. */
5832 bcopy (pbm_format
, fmt
, sizeof fmt
);
5833 parse_image_spec (img
->spec
, fmt
, PBM_LAST
, Qpbm
);
5835 /* Get foreground and background colors, maybe allocate colors. */
5836 if (fmt
[PBM_FOREGROUND
].count
5837 && STRINGP (fmt
[PBM_FOREGROUND
].value
))
5838 fg
= x_alloc_image_color (f
, img
, fmt
[PBM_FOREGROUND
].value
, fg
);
5839 if (fmt
[PBM_BACKGROUND
].count
5840 && STRINGP (fmt
[PBM_BACKGROUND
].value
))
5842 bg
= x_alloc_image_color (f
, img
, fmt
[PBM_BACKGROUND
].value
, bg
);
5843 img
->background
= bg
;
5844 img
->background_valid
= 1;
5847 for (y
= 0; y
< height
; ++y
)
5848 for (x
= 0; x
< width
; ++x
)
5856 x_destroy_x_image (ximg
);
5857 x_clear_image (f
, img
);
5858 image_error ("Invalid image size in image `%s'",
5868 g
= pbm_scan_number (&p
, end
);
5870 XPutPixel (ximg
, x
, y
, g
? fg
: bg
);
5875 int expected_size
= height
* width
;
5876 if (max_color_idx
> 255)
5878 if (type
== PBM_COLOR
)
5881 if (raw_p
&& p
+ expected_size
> end
)
5883 x_destroy_x_image (ximg
);
5884 x_clear_image (f
, img
);
5885 image_error ("Invalid image size in image `%s'",
5890 for (y
= 0; y
< height
; ++y
)
5891 for (x
= 0; x
< width
; ++x
)
5895 if (type
== PBM_GRAY
&& raw_p
)
5898 if (max_color_idx
> 255)
5899 r
= g
= b
= r
* 256 + *p
++;
5901 else if (type
== PBM_GRAY
)
5902 r
= g
= b
= pbm_scan_number (&p
, end
);
5906 if (max_color_idx
> 255)
5909 if (max_color_idx
> 255)
5912 if (max_color_idx
> 255)
5917 r
= pbm_scan_number (&p
, end
);
5918 g
= pbm_scan_number (&p
, end
);
5919 b
= pbm_scan_number (&p
, end
);
5922 if (r
< 0 || g
< 0 || b
< 0)
5924 x_destroy_x_image (ximg
);
5925 image_error ("Invalid pixel value in image `%s'",
5930 /* RGB values are now in the range 0..max_color_idx.
5931 Scale this to the range 0..0xffff supported by X. */
5932 r
= (double) r
* 65535 / max_color_idx
;
5933 g
= (double) g
* 65535 / max_color_idx
;
5934 b
= (double) b
* 65535 / max_color_idx
;
5935 XPutPixel (ximg
, x
, y
, lookup_rgb_color (f
, r
, g
, b
));
5939 #ifdef COLOR_TABLE_SUPPORT
5940 /* Store in IMG->colors the colors allocated for the image, and
5941 free the color table. */
5942 img
->colors
= colors_in_color_table (&img
->ncolors
);
5943 free_color_table ();
5944 #endif /* COLOR_TABLE_SUPPORT */
5947 img
->height
= height
;
5949 /* Maybe fill in the background field while we have ximg handy. */
5951 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
5952 /* Casting avoids a GCC warning. */
5953 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
5955 /* Put the image into a pixmap. */
5956 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
5957 x_destroy_x_image (ximg
);
5959 /* X and W32 versions did it here, MAC version above. ++kfs
5961 img->height = height; */
5969 /***********************************************************************
5971 ***********************************************************************/
5973 #if defined (HAVE_PNG) || defined (MAC_OS)
5975 /* Function prototypes. */
5977 static int png_image_p
P_ ((Lisp_Object object
));
5978 static int png_load
P_ ((struct frame
*f
, struct image
*img
));
5980 /* The symbol `png' identifying images of this type. */
5984 /* Indices of image specification fields in png_format, below. */
5986 enum png_keyword_index
6001 /* Vector of image_keyword structures describing the format
6002 of valid user-defined image specifications. */
6004 static struct image_keyword png_format
[PNG_LAST
] =
6006 {":type", IMAGE_SYMBOL_VALUE
, 1},
6007 {":data", IMAGE_STRING_VALUE
, 0},
6008 {":file", IMAGE_STRING_VALUE
, 0},
6009 {":ascent", IMAGE_ASCENT_VALUE
, 0},
6010 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
6011 {":relief", IMAGE_INTEGER_VALUE
, 0},
6012 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6013 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6014 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6015 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
6018 /* Structure describing the image type `png'. */
6020 static struct image_type png_type
=
6029 /* Return non-zero if OBJECT is a valid PNG image specification. */
6032 png_image_p (object
)
6035 struct image_keyword fmt
[PNG_LAST
];
6036 bcopy (png_format
, fmt
, sizeof fmt
);
6038 if (!parse_image_spec (object
, fmt
, PNG_LAST
, Qpng
))
6041 /* Must specify either the :data or :file keyword. */
6042 return fmt
[PNG_FILE
].count
+ fmt
[PNG_DATA
].count
== 1;
6045 #endif /* HAVE_PNG || MAC_OS */
6050 #if defined HAVE_LIBPNG_PNG_H
6051 # include <libpng/png.h>
6057 /* PNG library details. */
6059 DEF_IMGLIB_FN (png_get_io_ptr
);
6060 DEF_IMGLIB_FN (png_check_sig
);
6061 DEF_IMGLIB_FN (png_create_read_struct
);
6062 DEF_IMGLIB_FN (png_create_info_struct
);
6063 DEF_IMGLIB_FN (png_destroy_read_struct
);
6064 DEF_IMGLIB_FN (png_set_read_fn
);
6065 DEF_IMGLIB_FN (png_set_sig_bytes
);
6066 DEF_IMGLIB_FN (png_read_info
);
6067 DEF_IMGLIB_FN (png_get_IHDR
);
6068 DEF_IMGLIB_FN (png_get_valid
);
6069 DEF_IMGLIB_FN (png_set_strip_16
);
6070 DEF_IMGLIB_FN (png_set_expand
);
6071 DEF_IMGLIB_FN (png_set_gray_to_rgb
);
6072 DEF_IMGLIB_FN (png_set_background
);
6073 DEF_IMGLIB_FN (png_get_bKGD
);
6074 DEF_IMGLIB_FN (png_read_update_info
);
6075 DEF_IMGLIB_FN (png_get_channels
);
6076 DEF_IMGLIB_FN (png_get_rowbytes
);
6077 DEF_IMGLIB_FN (png_read_image
);
6078 DEF_IMGLIB_FN (png_read_end
);
6079 DEF_IMGLIB_FN (png_error
);
6082 init_png_functions (Lisp_Object libraries
)
6086 /* Try loading libpng under probable names. */
6087 if (!(library
= w32_delayed_load (libraries
, Qpng
)))
6090 LOAD_IMGLIB_FN (library
, png_get_io_ptr
);
6091 LOAD_IMGLIB_FN (library
, png_check_sig
);
6092 LOAD_IMGLIB_FN (library
, png_create_read_struct
);
6093 LOAD_IMGLIB_FN (library
, png_create_info_struct
);
6094 LOAD_IMGLIB_FN (library
, png_destroy_read_struct
);
6095 LOAD_IMGLIB_FN (library
, png_set_read_fn
);
6096 LOAD_IMGLIB_FN (library
, png_set_sig_bytes
);
6097 LOAD_IMGLIB_FN (library
, png_read_info
);
6098 LOAD_IMGLIB_FN (library
, png_get_IHDR
);
6099 LOAD_IMGLIB_FN (library
, png_get_valid
);
6100 LOAD_IMGLIB_FN (library
, png_set_strip_16
);
6101 LOAD_IMGLIB_FN (library
, png_set_expand
);
6102 LOAD_IMGLIB_FN (library
, png_set_gray_to_rgb
);
6103 LOAD_IMGLIB_FN (library
, png_set_background
);
6104 LOAD_IMGLIB_FN (library
, png_get_bKGD
);
6105 LOAD_IMGLIB_FN (library
, png_read_update_info
);
6106 LOAD_IMGLIB_FN (library
, png_get_channels
);
6107 LOAD_IMGLIB_FN (library
, png_get_rowbytes
);
6108 LOAD_IMGLIB_FN (library
, png_read_image
);
6109 LOAD_IMGLIB_FN (library
, png_read_end
);
6110 LOAD_IMGLIB_FN (library
, png_error
);
6115 #define fn_png_get_io_ptr png_get_io_ptr
6116 #define fn_png_check_sig png_check_sig
6117 #define fn_png_create_read_struct png_create_read_struct
6118 #define fn_png_create_info_struct png_create_info_struct
6119 #define fn_png_destroy_read_struct png_destroy_read_struct
6120 #define fn_png_set_read_fn png_set_read_fn
6121 #define fn_png_set_sig_bytes png_set_sig_bytes
6122 #define fn_png_read_info png_read_info
6123 #define fn_png_get_IHDR png_get_IHDR
6124 #define fn_png_get_valid png_get_valid
6125 #define fn_png_set_strip_16 png_set_strip_16
6126 #define fn_png_set_expand png_set_expand
6127 #define fn_png_set_gray_to_rgb png_set_gray_to_rgb
6128 #define fn_png_set_background png_set_background
6129 #define fn_png_get_bKGD png_get_bKGD
6130 #define fn_png_read_update_info png_read_update_info
6131 #define fn_png_get_channels png_get_channels
6132 #define fn_png_get_rowbytes png_get_rowbytes
6133 #define fn_png_read_image png_read_image
6134 #define fn_png_read_end png_read_end
6135 #define fn_png_error png_error
6137 #endif /* HAVE_NTGUI */
6139 /* Error and warning handlers installed when the PNG library
6143 my_png_error (png_ptr
, msg
)
6144 png_struct
*png_ptr
;
6147 xassert (png_ptr
!= NULL
);
6148 image_error ("PNG error: %s", build_string (msg
), Qnil
);
6149 longjmp (png_ptr
->jmpbuf
, 1);
6154 my_png_warning (png_ptr
, msg
)
6155 png_struct
*png_ptr
;
6158 xassert (png_ptr
!= NULL
);
6159 image_error ("PNG warning: %s", build_string (msg
), Qnil
);
6162 /* Memory source for PNG decoding. */
6164 struct png_memory_storage
6166 unsigned char *bytes
; /* The data */
6167 size_t len
; /* How big is it? */
6168 int index
; /* Where are we? */
6172 /* Function set as reader function when reading PNG image from memory.
6173 PNG_PTR is a pointer to the PNG control structure. Copy LENGTH
6174 bytes from the input to DATA. */
6177 png_read_from_memory (png_ptr
, data
, length
)
6178 png_structp png_ptr
;
6182 struct png_memory_storage
*tbr
6183 = (struct png_memory_storage
*) fn_png_get_io_ptr (png_ptr
);
6185 if (length
> tbr
->len
- tbr
->index
)
6186 fn_png_error (png_ptr
, "Read error");
6188 bcopy (tbr
->bytes
+ tbr
->index
, data
, length
);
6189 tbr
->index
= tbr
->index
+ length
;
6193 /* Function set as reader function when reading PNG image from a file.
6194 PNG_PTR is a pointer to the PNG control structure. Copy LENGTH
6195 bytes from the input to DATA. */
6198 png_read_from_file (png_ptr
, data
, length
)
6199 png_structp png_ptr
;
6203 FILE *fp
= (FILE *) fn_png_get_io_ptr (png_ptr
);
6205 if (fread (data
, 1, length
, fp
) < length
)
6206 fn_png_error (png_ptr
, "Read error");
6210 /* Load PNG image IMG for use on frame F. Value is non-zero if
6218 Lisp_Object file
, specified_file
;
6219 Lisp_Object specified_data
;
6221 XImagePtr ximg
, mask_img
= NULL
;
6222 struct gcpro gcpro1
;
6223 png_struct
*png_ptr
= NULL
;
6224 png_info
*info_ptr
= NULL
, *end_info
= NULL
;
6225 FILE *volatile fp
= NULL
;
6227 png_byte
* volatile pixels
= NULL
;
6228 png_byte
** volatile rows
= NULL
;
6229 png_uint_32 width
, height
;
6230 int bit_depth
, color_type
, interlace_type
;
6232 png_uint_32 row_bytes
;
6234 double screen_gamma
;
6235 struct png_memory_storage tbr
; /* Data to be read */
6237 /* Find out what file to load. */
6238 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
6239 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
6243 if (NILP (specified_data
))
6245 file
= x_find_image_file (specified_file
);
6246 if (!STRINGP (file
))
6248 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
6253 /* Open the image file. */
6254 fp
= fopen (SDATA (file
), "rb");
6257 image_error ("Cannot open image file `%s'", file
, Qnil
);
6262 /* Check PNG signature. */
6263 if (fread (sig
, 1, sizeof sig
, fp
) != sizeof sig
6264 || !fn_png_check_sig (sig
, sizeof sig
))
6266 image_error ("Not a PNG file: `%s'", file
, Qnil
);
6274 /* Read from memory. */
6275 tbr
.bytes
= SDATA (specified_data
);
6276 tbr
.len
= SBYTES (specified_data
);
6279 /* Check PNG signature. */
6280 if (tbr
.len
< sizeof sig
6281 || !fn_png_check_sig (tbr
.bytes
, sizeof sig
))
6283 image_error ("Not a PNG image: `%s'", img
->spec
, Qnil
);
6288 /* Need to skip past the signature. */
6289 tbr
.bytes
+= sizeof (sig
);
6292 /* Initialize read and info structs for PNG lib. Casting return
6293 value avoids a GCC warning on W32. */
6294 png_ptr
= (png_structp
)fn_png_create_read_struct (PNG_LIBPNG_VER_STRING
,
6299 if (fp
) fclose (fp
);
6304 /* Casting return value avoids a GCC warning on W32. */
6305 info_ptr
= (png_infop
)fn_png_create_info_struct (png_ptr
);
6308 fn_png_destroy_read_struct (&png_ptr
, NULL
, NULL
);
6309 if (fp
) fclose (fp
);
6314 /* Casting return value avoids a GCC warning on W32. */
6315 end_info
= (png_infop
)fn_png_create_info_struct (png_ptr
);
6318 fn_png_destroy_read_struct (&png_ptr
, &info_ptr
, NULL
);
6319 if (fp
) fclose (fp
);
6324 /* Set error jump-back. We come back here when the PNG library
6325 detects an error. */
6326 if (setjmp (png_ptr
->jmpbuf
))
6330 fn_png_destroy_read_struct (&png_ptr
, &info_ptr
, &end_info
);
6333 if (fp
) fclose (fp
);
6338 /* Read image info. */
6339 if (!NILP (specified_data
))
6340 fn_png_set_read_fn (png_ptr
, (void *) &tbr
, png_read_from_memory
);
6342 fn_png_set_read_fn (png_ptr
, (void *) fp
, png_read_from_file
);
6344 fn_png_set_sig_bytes (png_ptr
, sizeof sig
);
6345 fn_png_read_info (png_ptr
, info_ptr
);
6346 fn_png_get_IHDR (png_ptr
, info_ptr
, &width
, &height
, &bit_depth
, &color_type
,
6347 &interlace_type
, NULL
, NULL
);
6349 if (!check_image_size (f
, width
, height
))
6352 /* If image contains simply transparency data, we prefer to
6353 construct a clipping mask. */
6354 if (fn_png_get_valid (png_ptr
, info_ptr
, PNG_INFO_tRNS
))
6359 /* This function is easier to write if we only have to handle
6360 one data format: RGB or RGBA with 8 bits per channel. Let's
6361 transform other formats into that format. */
6363 /* Strip more than 8 bits per channel. */
6364 if (bit_depth
== 16)
6365 fn_png_set_strip_16 (png_ptr
);
6367 /* Expand data to 24 bit RGB, or 8 bit grayscale, with alpha channel
6369 fn_png_set_expand (png_ptr
);
6371 /* Convert grayscale images to RGB. */
6372 if (color_type
== PNG_COLOR_TYPE_GRAY
6373 || color_type
== PNG_COLOR_TYPE_GRAY_ALPHA
)
6374 fn_png_set_gray_to_rgb (png_ptr
);
6376 screen_gamma
= (f
->gamma
? 1 / f
->gamma
/ 0.45455 : 2.2);
6378 #if 0 /* Avoid double gamma correction for PNG images. */
6379 { /* Tell the PNG lib to handle gamma correction for us. */
6382 #if defined(PNG_READ_sRGB_SUPPORTED) || defined(PNG_WRITE_sRGB_SUPPORTED)
6383 if (png_get_sRGB (png_ptr
, info_ptr
, &intent
))
6384 /* The libpng documentation says this is right in this case. */
6385 png_set_gamma (png_ptr
, screen_gamma
, 0.45455);
6388 if (png_get_gAMA (png_ptr
, info_ptr
, &image_gamma
))
6389 /* Image contains gamma information. */
6390 png_set_gamma (png_ptr
, screen_gamma
, image_gamma
);
6392 /* Use the standard default for the image gamma. */
6393 png_set_gamma (png_ptr
, screen_gamma
, 0.45455);
6397 /* Handle alpha channel by combining the image with a background
6398 color. Do this only if a real alpha channel is supplied. For
6399 simple transparency, we prefer a clipping mask. */
6402 /* png_color_16 *image_bg; */
6403 Lisp_Object specified_bg
6404 = image_spec_value (img
->spec
, QCbackground
, NULL
);
6406 if (STRINGP (specified_bg
))
6407 /* The user specified `:background', use that. */
6409 /* W32 version incorrectly used COLORREF here!! ++kfs */
6411 if (x_defined_color (f
, SDATA (specified_bg
), &color
, 0))
6413 png_color_16 user_bg
;
6415 bzero (&user_bg
, sizeof user_bg
);
6416 user_bg
.red
= color
.red
>> 8;
6417 user_bg
.green
= color
.green
>> 8;
6418 user_bg
.blue
= color
.blue
>> 8;
6420 fn_png_set_background (png_ptr
, &user_bg
,
6421 PNG_BACKGROUND_GAMMA_SCREEN
, 0, 1.0);
6424 /* The commented-out code checked if the png specifies a default
6425 background color, and uses that. Since we use the current
6426 frame background, it is OK for us to ignore this.
6428 else if (fn_png_get_bKGD (png_ptr, info_ptr, &image_bg))
6429 fn_png_set_background (png_ptr, image_bg,
6430 PNG_BACKGROUND_GAMMA_FILE, 1, 1.0);
6434 /* Image does not contain a background color with which
6435 to combine the image data via an alpha channel. Use
6436 the frame's background instead. */
6437 #ifdef HAVE_X_WINDOWS
6439 png_color_16 frame_background
;
6441 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
6442 x_query_color (f
, &color
);
6444 bzero (&frame_background
, sizeof frame_background
);
6445 frame_background
.red
= color
.red
>> 8;
6446 frame_background
.green
= color
.green
>> 8;
6447 frame_background
.blue
= color
.blue
>> 8;
6448 #endif /* HAVE_X_WINDOWS */
6452 png_color_16 frame_background
;
6453 color
= FRAME_BACKGROUND_PIXEL (f
);
6454 #if 0 /* W32 TODO : Colormap support. */
6455 x_query_color (f
, &color
);
6457 bzero (&frame_background
, sizeof frame_background
);
6458 frame_background
.red
= GetRValue (color
);
6459 frame_background
.green
= GetGValue (color
);
6460 frame_background
.blue
= GetBValue (color
);
6461 #endif /* HAVE_NTGUI */
6464 unsigned long color
;
6465 png_color_16 frame_background
;
6466 color
= FRAME_BACKGROUND_PIXEL (f
);
6467 #if 0 /* MAC/W32 TODO : Colormap support. */
6468 x_query_color (f
, &color
);
6470 bzero (&frame_background
, sizeof frame_background
);
6471 frame_background
.red
= RED_FROM_ULONG (color
);
6472 frame_background
.green
= GREEN_FROM_ULONG (color
);
6473 frame_background
.blue
= BLUE_FROM_ULONG (color
);
6476 fn_png_set_background (png_ptr
, &frame_background
,
6477 PNG_BACKGROUND_GAMMA_SCREEN
, 0, 1.0);
6481 /* Update info structure. */
6482 fn_png_read_update_info (png_ptr
, info_ptr
);
6484 /* Get number of channels. Valid values are 1 for grayscale images
6485 and images with a palette, 2 for grayscale images with transparency
6486 information (alpha channel), 3 for RGB images, and 4 for RGB
6487 images with alpha channel, i.e. RGBA. If conversions above were
6488 sufficient we should only have 3 or 4 channels here. */
6489 channels
= fn_png_get_channels (png_ptr
, info_ptr
);
6490 xassert (channels
== 3 || channels
== 4);
6492 /* Number of bytes needed for one row of the image. */
6493 row_bytes
= fn_png_get_rowbytes (png_ptr
, info_ptr
);
6495 /* Allocate memory for the image. */
6496 pixels
= (png_byte
*) xmalloc (row_bytes
* height
* sizeof *pixels
);
6497 rows
= (png_byte
**) xmalloc (height
* sizeof *rows
);
6498 for (i
= 0; i
< height
; ++i
)
6499 rows
[i
] = pixels
+ i
* row_bytes
;
6501 /* Read the entire image. */
6502 fn_png_read_image (png_ptr
, rows
);
6503 fn_png_read_end (png_ptr
, info_ptr
);
6510 /* Create the X image and pixmap. */
6511 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
,
6515 /* Create an image and pixmap serving as mask if the PNG image
6516 contains an alpha channel. */
6519 && !x_create_x_image_and_pixmap (f
, width
, height
, 1,
6520 &mask_img
, &img
->mask
))
6522 x_destroy_x_image (ximg
);
6523 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->pixmap
);
6524 img
->pixmap
= NO_PIXMAP
;
6528 /* Fill the X image and mask from PNG data. */
6529 init_color_table ();
6531 for (y
= 0; y
< height
; ++y
)
6533 png_byte
*p
= rows
[y
];
6535 for (x
= 0; x
< width
; ++x
)
6542 XPutPixel (ximg
, x
, y
, lookup_rgb_color (f
, r
, g
, b
));
6543 /* An alpha channel, aka mask channel, associates variable
6544 transparency with an image. Where other image formats
6545 support binary transparency---fully transparent or fully
6546 opaque---PNG allows up to 254 levels of partial transparency.
6547 The PNG library implements partial transparency by combining
6548 the image with a specified background color.
6550 I'm not sure how to handle this here nicely: because the
6551 background on which the image is displayed may change, for
6552 real alpha channel support, it would be necessary to create
6553 a new image for each possible background.
6555 What I'm doing now is that a mask is created if we have
6556 boolean transparency information. Otherwise I'm using
6557 the frame's background color to combine the image with. */
6562 XPutPixel (mask_img
, x
, y
, *p
> 0 ? PIX_MASK_DRAW
: PIX_MASK_RETAIN
);
6568 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
6569 /* Set IMG's background color from the PNG image, unless the user
6573 if (fn_png_get_bKGD (png_ptr
, info_ptr
, &bg
))
6575 img
->background
= lookup_rgb_color (f
, bg
->red
, bg
->green
, bg
->blue
);
6576 img
->background_valid
= 1;
6580 #ifdef COLOR_TABLE_SUPPORT
6581 /* Remember colors allocated for this image. */
6582 img
->colors
= colors_in_color_table (&img
->ncolors
);
6583 free_color_table ();
6584 #endif /* COLOR_TABLE_SUPPORT */
6587 fn_png_destroy_read_struct (&png_ptr
, &info_ptr
, &end_info
);
6592 img
->height
= height
;
6594 /* Maybe fill in the background field while we have ximg handy.
6595 Casting avoids a GCC warning. */
6596 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
6598 /* Put the image into the pixmap, then free the X image and its buffer. */
6599 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
6600 x_destroy_x_image (ximg
);
6602 /* Same for the mask. */
6605 /* Fill in the background_transparent field while we have the
6606 mask handy. Casting avoids a GCC warning. */
6607 image_background_transparent (img
, f
, (XImagePtr_or_DC
)mask_img
);
6609 x_put_x_image (f
, mask_img
, img
->mask
, img
->width
, img
->height
);
6610 x_destroy_x_image (mask_img
);
6617 #else /* HAVE_PNG */
6626 if (MyCGImageCreateWithPNGDataProvider
)
6627 return image_load_quartz2d (f
, img
, 1);
6630 return image_load_quicktime (f
, img
, kQTFileTypePNG
);
6634 #endif /* !HAVE_PNG */
6638 /***********************************************************************
6640 ***********************************************************************/
6642 #if defined (HAVE_JPEG) || defined (MAC_OS)
6644 static int jpeg_image_p
P_ ((Lisp_Object object
));
6645 static int jpeg_load
P_ ((struct frame
*f
, struct image
*img
));
6647 /* The symbol `jpeg' identifying images of this type. */
6651 /* Indices of image specification fields in gs_format, below. */
6653 enum jpeg_keyword_index
6662 JPEG_HEURISTIC_MASK
,
6668 /* Vector of image_keyword structures describing the format
6669 of valid user-defined image specifications. */
6671 static struct image_keyword jpeg_format
[JPEG_LAST
] =
6673 {":type", IMAGE_SYMBOL_VALUE
, 1},
6674 {":data", IMAGE_STRING_VALUE
, 0},
6675 {":file", IMAGE_STRING_VALUE
, 0},
6676 {":ascent", IMAGE_ASCENT_VALUE
, 0},
6677 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
6678 {":relief", IMAGE_INTEGER_VALUE
, 0},
6679 {":conversions", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6680 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6681 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6682 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
6685 /* Structure describing the image type `jpeg'. */
6687 static struct image_type jpeg_type
=
6696 /* Return non-zero if OBJECT is a valid JPEG image specification. */
6699 jpeg_image_p (object
)
6702 struct image_keyword fmt
[JPEG_LAST
];
6704 bcopy (jpeg_format
, fmt
, sizeof fmt
);
6706 if (!parse_image_spec (object
, fmt
, JPEG_LAST
, Qjpeg
))
6709 /* Must specify either the :data or :file keyword. */
6710 return fmt
[JPEG_FILE
].count
+ fmt
[JPEG_DATA
].count
== 1;
6713 #endif /* HAVE_JPEG || MAC_OS */
6717 /* Work around a warning about HAVE_STDLIB_H being redefined in
6719 #ifdef HAVE_STDLIB_H
6720 #define HAVE_STDLIB_H_1
6721 #undef HAVE_STDLIB_H
6722 #endif /* HAVE_STLIB_H */
6724 #if defined (HAVE_NTGUI) && !defined (__WIN32__)
6725 /* In older releases of the jpeg library, jpeglib.h will define boolean
6726 differently depending on __WIN32__, so make sure it is defined. */
6730 #include <jpeglib.h>
6734 #ifdef HAVE_STLIB_H_1
6735 #define HAVE_STDLIB_H 1
6740 /* JPEG library details. */
6741 DEF_IMGLIB_FN (jpeg_CreateDecompress
);
6742 DEF_IMGLIB_FN (jpeg_start_decompress
);
6743 DEF_IMGLIB_FN (jpeg_finish_decompress
);
6744 DEF_IMGLIB_FN (jpeg_destroy_decompress
);
6745 DEF_IMGLIB_FN (jpeg_read_header
);
6746 DEF_IMGLIB_FN (jpeg_read_scanlines
);
6747 DEF_IMGLIB_FN (jpeg_std_error
);
6748 DEF_IMGLIB_FN (jpeg_resync_to_restart
);
6751 init_jpeg_functions (Lisp_Object libraries
)
6755 if (!(library
= w32_delayed_load (libraries
, Qjpeg
)))
6758 LOAD_IMGLIB_FN (library
, jpeg_finish_decompress
);
6759 LOAD_IMGLIB_FN (library
, jpeg_read_scanlines
);
6760 LOAD_IMGLIB_FN (library
, jpeg_start_decompress
);
6761 LOAD_IMGLIB_FN (library
, jpeg_read_header
);
6762 LOAD_IMGLIB_FN (library
, jpeg_CreateDecompress
);
6763 LOAD_IMGLIB_FN (library
, jpeg_destroy_decompress
);
6764 LOAD_IMGLIB_FN (library
, jpeg_std_error
);
6765 LOAD_IMGLIB_FN (library
, jpeg_resync_to_restart
);
6769 /* Wrapper since we can't directly assign the function pointer
6770 to another function pointer that was declared more completely easily. */
6772 jpeg_resync_to_restart_wrapper (cinfo
, desired
)
6773 j_decompress_ptr cinfo
;
6776 return fn_jpeg_resync_to_restart (cinfo
, desired
);
6781 #define fn_jpeg_CreateDecompress(a,b,c) jpeg_create_decompress(a)
6782 #define fn_jpeg_start_decompress jpeg_start_decompress
6783 #define fn_jpeg_finish_decompress jpeg_finish_decompress
6784 #define fn_jpeg_destroy_decompress jpeg_destroy_decompress
6785 #define fn_jpeg_read_header jpeg_read_header
6786 #define fn_jpeg_read_scanlines jpeg_read_scanlines
6787 #define fn_jpeg_std_error jpeg_std_error
6788 #define jpeg_resync_to_restart_wrapper jpeg_resync_to_restart
6790 #endif /* HAVE_NTGUI */
6792 struct my_jpeg_error_mgr
6794 struct jpeg_error_mgr pub
;
6795 jmp_buf setjmp_buffer
;
6800 my_error_exit (cinfo
)
6803 struct my_jpeg_error_mgr
*mgr
= (struct my_jpeg_error_mgr
*) cinfo
->err
;
6804 longjmp (mgr
->setjmp_buffer
, 1);
6808 /* Init source method for JPEG data source manager. Called by
6809 jpeg_read_header() before any data is actually read. See
6810 libjpeg.doc from the JPEG lib distribution. */
6813 our_common_init_source (cinfo
)
6814 j_decompress_ptr cinfo
;
6819 /* Method to terminate data source. Called by
6820 jpeg_finish_decompress() after all data has been processed. */
6823 our_common_term_source (cinfo
)
6824 j_decompress_ptr cinfo
;
6829 /* Fill input buffer method for JPEG data source manager. Called
6830 whenever more data is needed. We read the whole image in one step,
6831 so this only adds a fake end of input marker at the end. */
6833 static JOCTET our_memory_buffer
[2];
6836 our_memory_fill_input_buffer (cinfo
)
6837 j_decompress_ptr cinfo
;
6839 /* Insert a fake EOI marker. */
6840 struct jpeg_source_mgr
*src
= cinfo
->src
;
6842 our_memory_buffer
[0] = (JOCTET
) 0xFF;
6843 our_memory_buffer
[1] = (JOCTET
) JPEG_EOI
;
6845 src
->next_input_byte
= our_memory_buffer
;
6846 src
->bytes_in_buffer
= 2;
6851 /* Method to skip over NUM_BYTES bytes in the image data. CINFO->src
6852 is the JPEG data source manager. */
6855 our_memory_skip_input_data (cinfo
, num_bytes
)
6856 j_decompress_ptr cinfo
;
6859 struct jpeg_source_mgr
*src
= (struct jpeg_source_mgr
*) cinfo
->src
;
6863 if (num_bytes
> src
->bytes_in_buffer
)
6864 ERREXIT (cinfo
, JERR_INPUT_EOF
);
6866 src
->bytes_in_buffer
-= num_bytes
;
6867 src
->next_input_byte
+= num_bytes
;
6872 /* Set up the JPEG lib for reading an image from DATA which contains
6873 LEN bytes. CINFO is the decompression info structure created for
6874 reading the image. */
6877 jpeg_memory_src (cinfo
, data
, len
)
6878 j_decompress_ptr cinfo
;
6882 struct jpeg_source_mgr
*src
;
6884 if (cinfo
->src
== NULL
)
6886 /* First time for this JPEG object? */
6887 cinfo
->src
= (struct jpeg_source_mgr
*)
6888 (*cinfo
->mem
->alloc_small
) ((j_common_ptr
) cinfo
, JPOOL_PERMANENT
,
6889 sizeof (struct jpeg_source_mgr
));
6890 src
= (struct jpeg_source_mgr
*) cinfo
->src
;
6891 src
->next_input_byte
= data
;
6894 src
= (struct jpeg_source_mgr
*) cinfo
->src
;
6895 src
->init_source
= our_common_init_source
;
6896 src
->fill_input_buffer
= our_memory_fill_input_buffer
;
6897 src
->skip_input_data
= our_memory_skip_input_data
;
6898 src
->resync_to_restart
= jpeg_resync_to_restart_wrapper
; /* Use default method. */
6899 src
->term_source
= our_common_term_source
;
6900 src
->bytes_in_buffer
= len
;
6901 src
->next_input_byte
= data
;
6905 struct jpeg_stdio_mgr
6907 struct jpeg_source_mgr mgr
;
6914 /* Size of buffer to read JPEG from file.
6915 Not too big, as we want to use alloc_small. */
6916 #define JPEG_STDIO_BUFFER_SIZE 8192
6919 /* Fill input buffer method for JPEG data source manager. Called
6920 whenever more data is needed. The data is read from a FILE *. */
6923 our_stdio_fill_input_buffer (cinfo
)
6924 j_decompress_ptr cinfo
;
6926 struct jpeg_stdio_mgr
*src
;
6928 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6933 bytes
= fread (src
->buffer
, 1, JPEG_STDIO_BUFFER_SIZE
, src
->file
);
6935 src
->mgr
.bytes_in_buffer
= bytes
;
6938 WARNMS (cinfo
, JWRN_JPEG_EOF
);
6940 src
->buffer
[0] = (JOCTET
) 0xFF;
6941 src
->buffer
[1] = (JOCTET
) JPEG_EOI
;
6942 src
->mgr
.bytes_in_buffer
= 2;
6944 src
->mgr
.next_input_byte
= src
->buffer
;
6951 /* Method to skip over NUM_BYTES bytes in the image data. CINFO->src
6952 is the JPEG data source manager. */
6955 our_stdio_skip_input_data (cinfo
, num_bytes
)
6956 j_decompress_ptr cinfo
;
6959 struct jpeg_stdio_mgr
*src
;
6960 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6962 while (num_bytes
> 0 && !src
->finished
)
6964 if (num_bytes
<= src
->mgr
.bytes_in_buffer
)
6966 src
->mgr
.bytes_in_buffer
-= num_bytes
;
6967 src
->mgr
.next_input_byte
+= num_bytes
;
6972 num_bytes
-= src
->mgr
.bytes_in_buffer
;
6973 src
->mgr
.bytes_in_buffer
= 0;
6974 src
->mgr
.next_input_byte
= NULL
;
6976 our_stdio_fill_input_buffer (cinfo
);
6982 /* Set up the JPEG lib for reading an image from a FILE *.
6983 CINFO is the decompression info structure created for
6984 reading the image. */
6987 jpeg_file_src (cinfo
, fp
)
6988 j_decompress_ptr cinfo
;
6991 struct jpeg_stdio_mgr
*src
;
6993 if (cinfo
->src
!= NULL
)
6994 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6997 /* First time for this JPEG object? */
6998 cinfo
->src
= (struct jpeg_source_mgr
*)
6999 (*cinfo
->mem
->alloc_small
) ((j_common_ptr
) cinfo
, JPOOL_PERMANENT
,
7000 sizeof (struct jpeg_stdio_mgr
));
7001 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
7002 src
->buffer
= (JOCTET
*)
7003 (*cinfo
->mem
->alloc_small
) ((j_common_ptr
) cinfo
, JPOOL_PERMANENT
,
7004 JPEG_STDIO_BUFFER_SIZE
);
7009 src
->mgr
.init_source
= our_common_init_source
;
7010 src
->mgr
.fill_input_buffer
= our_stdio_fill_input_buffer
;
7011 src
->mgr
.skip_input_data
= our_stdio_skip_input_data
;
7012 src
->mgr
.resync_to_restart
= jpeg_resync_to_restart_wrapper
; /* Use default method. */
7013 src
->mgr
.term_source
= our_common_term_source
;
7014 src
->mgr
.bytes_in_buffer
= 0;
7015 src
->mgr
.next_input_byte
= NULL
;
7019 /* Load image IMG for use on frame F. Patterned after example.c
7020 from the JPEG lib. */
7027 struct jpeg_decompress_struct cinfo
;
7028 struct my_jpeg_error_mgr mgr
;
7029 Lisp_Object file
, specified_file
;
7030 Lisp_Object specified_data
;
7031 FILE * volatile fp
= NULL
;
7033 int row_stride
, x
, y
;
7034 XImagePtr ximg
= NULL
;
7036 unsigned long *colors
;
7038 struct gcpro gcpro1
;
7040 /* Open the JPEG file. */
7041 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
7042 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
7046 if (NILP (specified_data
))
7048 file
= x_find_image_file (specified_file
);
7049 if (!STRINGP (file
))
7051 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
7056 fp
= fopen (SDATA (file
), "rb");
7059 image_error ("Cannot open `%s'", file
, Qnil
);
7065 /* Customize libjpeg's error handling to call my_error_exit when an
7066 error is detected. This function will perform a longjmp.
7067 Casting return value avoids a GCC warning on W32. */
7068 cinfo
.err
= (struct jpeg_error_mgr
*)fn_jpeg_std_error (&mgr
.pub
);
7069 mgr
.pub
.error_exit
= my_error_exit
;
7071 if ((rc
= setjmp (mgr
.setjmp_buffer
)) != 0)
7075 /* Called from my_error_exit. Display a JPEG error. */
7076 char buffer
[JMSG_LENGTH_MAX
];
7077 cinfo
.err
->format_message ((j_common_ptr
) &cinfo
, buffer
);
7078 image_error ("Error reading JPEG image `%s': %s", img
->spec
,
7079 build_string (buffer
));
7082 /* Close the input file and destroy the JPEG object. */
7084 fclose ((FILE *) fp
);
7085 fn_jpeg_destroy_decompress (&cinfo
);
7087 /* If we already have an XImage, free that. */
7088 x_destroy_x_image (ximg
);
7090 /* Free pixmap and colors. */
7091 x_clear_image (f
, img
);
7097 /* Create the JPEG decompression object. Let it read from fp.
7098 Read the JPEG image header. */
7099 fn_jpeg_CreateDecompress (&cinfo
, JPEG_LIB_VERSION
, sizeof (cinfo
));
7101 if (NILP (specified_data
))
7102 jpeg_file_src (&cinfo
, (FILE *) fp
);
7104 jpeg_memory_src (&cinfo
, SDATA (specified_data
),
7105 SBYTES (specified_data
));
7107 fn_jpeg_read_header (&cinfo
, 1);
7109 /* Customize decompression so that color quantization will be used.
7110 Start decompression. */
7111 cinfo
.quantize_colors
= 1;
7112 fn_jpeg_start_decompress (&cinfo
);
7113 width
= img
->width
= cinfo
.output_width
;
7114 height
= img
->height
= cinfo
.output_height
;
7116 if (!check_image_size (f
, width
, height
))
7118 image_error ("Invalid image size", Qnil
, Qnil
);
7119 longjmp (mgr
.setjmp_buffer
, 2);
7122 /* Create X image and pixmap. */
7123 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
7124 longjmp (mgr
.setjmp_buffer
, 2);
7126 /* Allocate colors. When color quantization is used,
7127 cinfo.actual_number_of_colors has been set with the number of
7128 colors generated, and cinfo.colormap is a two-dimensional array
7129 of color indices in the range 0..cinfo.actual_number_of_colors.
7130 No more than 255 colors will be generated. */
7134 if (cinfo
.out_color_components
> 2)
7135 ir
= 0, ig
= 1, ib
= 2;
7136 else if (cinfo
.out_color_components
> 1)
7137 ir
= 0, ig
= 1, ib
= 0;
7139 ir
= 0, ig
= 0, ib
= 0;
7141 /* Use the color table mechanism because it handles colors that
7142 cannot be allocated nicely. Such colors will be replaced with
7143 a default color, and we don't have to care about which colors
7144 can be freed safely, and which can't. */
7145 init_color_table ();
7146 colors
= (unsigned long *) alloca (cinfo
.actual_number_of_colors
7149 for (i
= 0; i
< cinfo
.actual_number_of_colors
; ++i
)
7151 /* Multiply RGB values with 255 because X expects RGB values
7152 in the range 0..0xffff. */
7153 int r
= cinfo
.colormap
[ir
][i
] << 8;
7154 int g
= cinfo
.colormap
[ig
][i
] << 8;
7155 int b
= cinfo
.colormap
[ib
][i
] << 8;
7156 colors
[i
] = lookup_rgb_color (f
, r
, g
, b
);
7159 #ifdef COLOR_TABLE_SUPPORT
7160 /* Remember those colors actually allocated. */
7161 img
->colors
= colors_in_color_table (&img
->ncolors
);
7162 free_color_table ();
7163 #endif /* COLOR_TABLE_SUPPORT */
7167 row_stride
= width
* cinfo
.output_components
;
7168 buffer
= cinfo
.mem
->alloc_sarray ((j_common_ptr
) &cinfo
, JPOOL_IMAGE
,
7170 for (y
= 0; y
< height
; ++y
)
7172 fn_jpeg_read_scanlines (&cinfo
, buffer
, 1);
7173 for (x
= 0; x
< cinfo
.output_width
; ++x
)
7174 XPutPixel (ximg
, x
, y
, colors
[buffer
[0][x
]]);
7178 fn_jpeg_finish_decompress (&cinfo
);
7179 fn_jpeg_destroy_decompress (&cinfo
);
7181 fclose ((FILE *) fp
);
7183 /* Maybe fill in the background field while we have ximg handy. */
7184 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
7185 /* Casting avoids a GCC warning. */
7186 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
7188 /* Put the image into the pixmap. */
7189 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
7190 x_destroy_x_image (ximg
);
7195 #else /* HAVE_JPEG */
7204 return image_load_quartz2d (f
, img
, 0);
7206 return image_load_quicktime (f
, img
, kQTFileTypeJPEG
);
7211 #endif /* !HAVE_JPEG */
7215 /***********************************************************************
7217 ***********************************************************************/
7219 #if defined (HAVE_TIFF) || defined (MAC_OS)
7221 static int tiff_image_p
P_ ((Lisp_Object object
));
7222 static int tiff_load
P_ ((struct frame
*f
, struct image
*img
));
7224 /* The symbol `tiff' identifying images of this type. */
7228 /* Indices of image specification fields in tiff_format, below. */
7230 enum tiff_keyword_index
7239 TIFF_HEURISTIC_MASK
,
7245 /* Vector of image_keyword structures describing the format
7246 of valid user-defined image specifications. */
7248 static struct image_keyword tiff_format
[TIFF_LAST
] =
7250 {":type", IMAGE_SYMBOL_VALUE
, 1},
7251 {":data", IMAGE_STRING_VALUE
, 0},
7252 {":file", IMAGE_STRING_VALUE
, 0},
7253 {":ascent", IMAGE_ASCENT_VALUE
, 0},
7254 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
7255 {":relief", IMAGE_INTEGER_VALUE
, 0},
7256 {":conversions", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7257 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7258 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7259 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
7262 /* Structure describing the image type `tiff'. */
7264 static struct image_type tiff_type
=
7273 /* Return non-zero if OBJECT is a valid TIFF image specification. */
7276 tiff_image_p (object
)
7279 struct image_keyword fmt
[TIFF_LAST
];
7280 bcopy (tiff_format
, fmt
, sizeof fmt
);
7282 if (!parse_image_spec (object
, fmt
, TIFF_LAST
, Qtiff
))
7285 /* Must specify either the :data or :file keyword. */
7286 return fmt
[TIFF_FILE
].count
+ fmt
[TIFF_DATA
].count
== 1;
7289 #endif /* HAVE_TIFF || MAC_OS */
7297 /* TIFF library details. */
7298 DEF_IMGLIB_FN (TIFFSetErrorHandler
);
7299 DEF_IMGLIB_FN (TIFFSetWarningHandler
);
7300 DEF_IMGLIB_FN (TIFFOpen
);
7301 DEF_IMGLIB_FN (TIFFClientOpen
);
7302 DEF_IMGLIB_FN (TIFFGetField
);
7303 DEF_IMGLIB_FN (TIFFReadRGBAImage
);
7304 DEF_IMGLIB_FN (TIFFClose
);
7307 init_tiff_functions (Lisp_Object libraries
)
7311 if (!(library
= w32_delayed_load (libraries
, Qtiff
)))
7314 LOAD_IMGLIB_FN (library
, TIFFSetErrorHandler
);
7315 LOAD_IMGLIB_FN (library
, TIFFSetWarningHandler
);
7316 LOAD_IMGLIB_FN (library
, TIFFOpen
);
7317 LOAD_IMGLIB_FN (library
, TIFFClientOpen
);
7318 LOAD_IMGLIB_FN (library
, TIFFGetField
);
7319 LOAD_IMGLIB_FN (library
, TIFFReadRGBAImage
);
7320 LOAD_IMGLIB_FN (library
, TIFFClose
);
7326 #define fn_TIFFSetErrorHandler TIFFSetErrorHandler
7327 #define fn_TIFFSetWarningHandler TIFFSetWarningHandler
7328 #define fn_TIFFOpen TIFFOpen
7329 #define fn_TIFFClientOpen TIFFClientOpen
7330 #define fn_TIFFGetField TIFFGetField
7331 #define fn_TIFFReadRGBAImage TIFFReadRGBAImage
7332 #define fn_TIFFClose TIFFClose
7334 #endif /* HAVE_NTGUI */
7337 /* Reading from a memory buffer for TIFF images Based on the PNG
7338 memory source, but we have to provide a lot of extra functions.
7341 We really only need to implement read and seek, but I am not
7342 convinced that the TIFF library is smart enough not to destroy
7343 itself if we only hand it the function pointers we need to
7348 unsigned char *bytes
;
7355 tiff_read_from_memory (data
, buf
, size
)
7360 tiff_memory_source
*src
= (tiff_memory_source
*) data
;
7362 if (size
> src
->len
- src
->index
)
7364 bcopy (src
->bytes
+ src
->index
, buf
, size
);
7370 tiff_write_from_memory (data
, buf
, size
)
7379 tiff_seek_in_memory (data
, off
, whence
)
7384 tiff_memory_source
*src
= (tiff_memory_source
*) data
;
7389 case SEEK_SET
: /* Go from beginning of source. */
7393 case SEEK_END
: /* Go from end of source. */
7394 idx
= src
->len
+ off
;
7397 case SEEK_CUR
: /* Go from current position. */
7398 idx
= src
->index
+ off
;
7401 default: /* Invalid `whence'. */
7405 if (idx
> src
->len
|| idx
< 0)
7413 tiff_close_memory (data
)
7421 tiff_mmap_memory (data
, pbase
, psize
)
7426 /* It is already _IN_ memory. */
7431 tiff_unmap_memory (data
, base
, size
)
7436 /* We don't need to do this. */
7440 tiff_size_of_memory (data
)
7443 return ((tiff_memory_source
*) data
)->len
;
7448 tiff_error_handler (title
, format
, ap
)
7449 const char *title
, *format
;
7455 len
= sprintf (buf
, "TIFF error: %s ", title
);
7456 vsprintf (buf
+ len
, format
, ap
);
7457 add_to_log (buf
, Qnil
, Qnil
);
7462 tiff_warning_handler (title
, format
, ap
)
7463 const char *title
, *format
;
7469 len
= sprintf (buf
, "TIFF warning: %s ", title
);
7470 vsprintf (buf
+ len
, format
, ap
);
7471 add_to_log (buf
, Qnil
, Qnil
);
7475 /* Load TIFF image IMG for use on frame F. Value is non-zero if
7483 Lisp_Object file
, specified_file
;
7484 Lisp_Object specified_data
;
7486 int width
, height
, x
, y
;
7490 struct gcpro gcpro1
;
7491 tiff_memory_source memsrc
;
7493 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
7494 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
7498 fn_TIFFSetErrorHandler (tiff_error_handler
);
7499 fn_TIFFSetWarningHandler (tiff_warning_handler
);
7501 if (NILP (specified_data
))
7503 /* Read from a file */
7504 file
= x_find_image_file (specified_file
);
7505 if (!STRINGP (file
))
7507 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
7512 /* Try to open the image file. Casting return value avoids a
7513 GCC warning on W32. */
7514 tiff
= (TIFF
*)fn_TIFFOpen (SDATA (file
), "r");
7517 image_error ("Cannot open `%s'", file
, Qnil
);
7524 /* Memory source! */
7525 memsrc
.bytes
= SDATA (specified_data
);
7526 memsrc
.len
= SBYTES (specified_data
);
7529 /* Casting return value avoids a GCC warning on W32. */
7530 tiff
= (TIFF
*)fn_TIFFClientOpen ("memory_source", "r", &memsrc
,
7531 (TIFFReadWriteProc
) tiff_read_from_memory
,
7532 (TIFFReadWriteProc
) tiff_write_from_memory
,
7533 tiff_seek_in_memory
,
7535 tiff_size_of_memory
,
7541 image_error ("Cannot open memory source for `%s'", img
->spec
, Qnil
);
7547 /* Get width and height of the image, and allocate a raster buffer
7548 of width x height 32-bit values. */
7549 fn_TIFFGetField (tiff
, TIFFTAG_IMAGEWIDTH
, &width
);
7550 fn_TIFFGetField (tiff
, TIFFTAG_IMAGELENGTH
, &height
);
7552 if (!check_image_size (f
, width
, height
))
7554 image_error ("Invalid image size", Qnil
, Qnil
);
7559 buf
= (uint32
*) xmalloc (width
* height
* sizeof *buf
);
7561 rc
= fn_TIFFReadRGBAImage (tiff
, width
, height
, buf
, 0);
7562 fn_TIFFClose (tiff
);
7565 image_error ("Error reading TIFF image `%s'", img
->spec
, Qnil
);
7571 /* Create the X image and pixmap. */
7572 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
7579 /* Initialize the color table. */
7580 init_color_table ();
7582 /* Process the pixel raster. Origin is in the lower-left corner. */
7583 for (y
= 0; y
< height
; ++y
)
7585 uint32
*row
= buf
+ y
* width
;
7587 for (x
= 0; x
< width
; ++x
)
7589 uint32 abgr
= row
[x
];
7590 int r
= TIFFGetR (abgr
) << 8;
7591 int g
= TIFFGetG (abgr
) << 8;
7592 int b
= TIFFGetB (abgr
) << 8;
7593 XPutPixel (ximg
, x
, height
- 1 - y
, lookup_rgb_color (f
, r
, g
, b
));
7597 #ifdef COLOR_TABLE_SUPPORT
7598 /* Remember the colors allocated for the image. Free the color table. */
7599 img
->colors
= colors_in_color_table (&img
->ncolors
);
7600 free_color_table ();
7601 #endif /* COLOR_TABLE_SUPPORT */
7604 img
->height
= height
;
7606 /* Maybe fill in the background field while we have ximg handy. */
7607 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
7608 /* Casting avoids a GCC warning on W32. */
7609 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
7611 /* Put the image into the pixmap, then free the X image and its buffer. */
7612 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
7613 x_destroy_x_image (ximg
);
7620 #else /* HAVE_TIFF */
7628 return image_load_quicktime (f
, img
, kQTFileTypeTIFF
);
7632 #endif /* !HAVE_TIFF */
7636 /***********************************************************************
7638 ***********************************************************************/
7640 #if defined (HAVE_GIF) || defined (MAC_OS)
7642 static int gif_image_p
P_ ((Lisp_Object object
));
7643 static int gif_load
P_ ((struct frame
*f
, struct image
*img
));
7644 static void gif_clear_image
P_ ((struct frame
*f
, struct image
*img
));
7646 /* The symbol `gif' identifying images of this type. */
7650 /* Indices of image specification fields in gif_format, below. */
7652 enum gif_keyword_index
7668 /* Vector of image_keyword structures describing the format
7669 of valid user-defined image specifications. */
7671 static struct image_keyword gif_format
[GIF_LAST
] =
7673 {":type", IMAGE_SYMBOL_VALUE
, 1},
7674 {":data", IMAGE_STRING_VALUE
, 0},
7675 {":file", IMAGE_STRING_VALUE
, 0},
7676 {":ascent", IMAGE_ASCENT_VALUE
, 0},
7677 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
7678 {":relief", IMAGE_INTEGER_VALUE
, 0},
7679 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7680 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7681 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7682 {":image", IMAGE_NON_NEGATIVE_INTEGER_VALUE
, 0},
7683 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
7686 /* Structure describing the image type `gif'. */
7688 static struct image_type gif_type
=
7697 /* Free X resources of GIF image IMG which is used on frame F. */
7700 gif_clear_image (f
, img
)
7704 /* IMG->data.ptr_val may contain extension data. */
7705 img
->data
.lisp_val
= Qnil
;
7706 x_clear_image (f
, img
);
7709 /* Return non-zero if OBJECT is a valid GIF image specification. */
7712 gif_image_p (object
)
7715 struct image_keyword fmt
[GIF_LAST
];
7716 bcopy (gif_format
, fmt
, sizeof fmt
);
7718 if (!parse_image_spec (object
, fmt
, GIF_LAST
, Qgif
))
7721 /* Must specify either the :data or :file keyword. */
7722 return fmt
[GIF_FILE
].count
+ fmt
[GIF_DATA
].count
== 1;
7725 #endif /* HAVE_GIF || MAC_OS */
7729 #if defined (HAVE_NTGUI) || defined (MAC_OS)
7730 /* winuser.h might define DrawText to DrawTextA or DrawTextW.
7731 Undefine before redefining to avoid a preprocessor warning. */
7735 /* avoid conflict with QuickdrawText.h */
7736 #define DrawText gif_DrawText
7737 #include <gif_lib.h>
7740 #else /* HAVE_NTGUI || MAC_OS */
7742 #include <gif_lib.h>
7744 #endif /* HAVE_NTGUI || MAC_OS */
7749 /* GIF library details. */
7750 DEF_IMGLIB_FN (DGifCloseFile
);
7751 DEF_IMGLIB_FN (DGifSlurp
);
7752 DEF_IMGLIB_FN (DGifOpen
);
7753 DEF_IMGLIB_FN (DGifOpenFileName
);
7756 init_gif_functions (Lisp_Object libraries
)
7760 if (!(library
= w32_delayed_load (libraries
, Qgif
)))
7763 LOAD_IMGLIB_FN (library
, DGifCloseFile
);
7764 LOAD_IMGLIB_FN (library
, DGifSlurp
);
7765 LOAD_IMGLIB_FN (library
, DGifOpen
);
7766 LOAD_IMGLIB_FN (library
, DGifOpenFileName
);
7772 #define fn_DGifCloseFile DGifCloseFile
7773 #define fn_DGifSlurp DGifSlurp
7774 #define fn_DGifOpen DGifOpen
7775 #define fn_DGifOpenFileName DGifOpenFileName
7777 #endif /* HAVE_NTGUI */
7779 /* Reading a GIF image from memory
7780 Based on the PNG memory stuff to a certain extent. */
7784 unsigned char *bytes
;
7790 /* Make the current memory source available to gif_read_from_memory.
7791 It's done this way because not all versions of libungif support
7792 a UserData field in the GifFileType structure. */
7793 static gif_memory_source
*current_gif_memory_src
;
7796 gif_read_from_memory (file
, buf
, len
)
7801 gif_memory_source
*src
= current_gif_memory_src
;
7803 if (len
> src
->len
- src
->index
)
7806 bcopy (src
->bytes
+ src
->index
, buf
, len
);
7812 /* Load GIF image IMG for use on frame F. Value is non-zero if
7815 static int interlace_start
[] = {0, 4, 2, 1};
7816 static int interlace_increment
[] = {8, 8, 4, 2};
7823 Lisp_Object file
, specified_file
;
7824 Lisp_Object specified_data
;
7825 int rc
, width
, height
, x
, y
, i
;
7827 ColorMapObject
*gif_color_map
;
7828 unsigned long pixel_colors
[256];
7830 struct gcpro gcpro1
;
7832 int ino
, image_height
, image_width
;
7833 gif_memory_source memsrc
;
7834 unsigned char *raster
;
7836 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
7837 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
7841 if (NILP (specified_data
))
7843 file
= x_find_image_file (specified_file
);
7844 if (!STRINGP (file
))
7846 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
7851 /* Open the GIF file. Casting return value avoids a GCC warning
7853 gif
= (GifFileType
*)fn_DGifOpenFileName (SDATA (file
));
7856 image_error ("Cannot open `%s'", file
, Qnil
);
7863 /* Read from memory! */
7864 current_gif_memory_src
= &memsrc
;
7865 memsrc
.bytes
= SDATA (specified_data
);
7866 memsrc
.len
= SBYTES (specified_data
);
7869 /* Casting return value avoids a GCC warning on W32. */
7870 gif
= (GifFileType
*) fn_DGifOpen (&memsrc
, gif_read_from_memory
);
7873 image_error ("Cannot open memory source `%s'", img
->spec
, Qnil
);
7879 /* Before reading entire contents, check the declared image size. */
7880 if (!check_image_size (f
, gif
->SWidth
, gif
->SHeight
))
7882 image_error ("Invalid image size", Qnil
, Qnil
);
7883 fn_DGifCloseFile (gif
);
7888 /* Read entire contents. */
7889 rc
= fn_DGifSlurp (gif
);
7890 if (rc
== GIF_ERROR
)
7892 image_error ("Error reading `%s'", img
->spec
, Qnil
);
7893 fn_DGifCloseFile (gif
);
7898 image
= image_spec_value (img
->spec
, QCindex
, NULL
);
7899 ino
= INTEGERP (image
) ? XFASTINT (image
) : 0;
7900 if (ino
>= gif
->ImageCount
)
7902 image_error ("Invalid image number `%s' in image `%s'",
7904 fn_DGifCloseFile (gif
);
7909 img
->corners
[TOP_CORNER
] = gif
->SavedImages
[ino
].ImageDesc
.Top
;
7910 img
->corners
[LEFT_CORNER
] = gif
->SavedImages
[ino
].ImageDesc
.Left
;
7911 image_height
= gif
->SavedImages
[ino
].ImageDesc
.Height
;
7912 img
->corners
[BOT_CORNER
] = img
->corners
[TOP_CORNER
] + image_height
;
7913 image_width
= gif
->SavedImages
[ino
].ImageDesc
.Width
;
7914 img
->corners
[RIGHT_CORNER
] = img
->corners
[LEFT_CORNER
] + image_width
;
7916 width
= img
->width
= max (gif
->SWidth
,
7917 max (gif
->Image
.Left
+ gif
->Image
.Width
,
7918 img
->corners
[RIGHT_CORNER
]));
7919 height
= img
->height
= max (gif
->SHeight
,
7920 max (gif
->Image
.Top
+ gif
->Image
.Height
,
7921 img
->corners
[BOT_CORNER
]));
7923 if (!check_image_size (f
, width
, height
))
7925 image_error ("Invalid image size", Qnil
, Qnil
);
7926 fn_DGifCloseFile (gif
);
7931 /* Create the X image and pixmap. */
7932 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
7934 fn_DGifCloseFile (gif
);
7939 /* Allocate colors. */
7940 gif_color_map
= gif
->SavedImages
[ino
].ImageDesc
.ColorMap
;
7942 gif_color_map
= gif
->SColorMap
;
7943 init_color_table ();
7944 bzero (pixel_colors
, sizeof pixel_colors
);
7947 for (i
= 0; i
< gif_color_map
->ColorCount
; ++i
)
7949 int r
= gif_color_map
->Colors
[i
].Red
<< 8;
7950 int g
= gif_color_map
->Colors
[i
].Green
<< 8;
7951 int b
= gif_color_map
->Colors
[i
].Blue
<< 8;
7952 pixel_colors
[i
] = lookup_rgb_color (f
, r
, g
, b
);
7955 #ifdef COLOR_TABLE_SUPPORT
7956 img
->colors
= colors_in_color_table (&img
->ncolors
);
7957 free_color_table ();
7958 #endif /* COLOR_TABLE_SUPPORT */
7960 /* Clear the part of the screen image that are not covered by
7961 the image from the GIF file. Full animated GIF support
7962 requires more than can be done here (see the gif89 spec,
7963 disposal methods). Let's simply assume that the part
7964 not covered by a sub-image is in the frame's background color. */
7965 for (y
= 0; y
< img
->corners
[TOP_CORNER
]; ++y
)
7966 for (x
= 0; x
< width
; ++x
)
7967 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7969 for (y
= img
->corners
[BOT_CORNER
]; y
< height
; ++y
)
7970 for (x
= 0; x
< width
; ++x
)
7971 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7973 for (y
= img
->corners
[TOP_CORNER
]; y
< img
->corners
[BOT_CORNER
]; ++y
)
7975 for (x
= 0; x
< img
->corners
[LEFT_CORNER
]; ++x
)
7976 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7977 for (x
= img
->corners
[RIGHT_CORNER
]; x
< width
; ++x
)
7978 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7981 /* Read the GIF image into the X image. We use a local variable
7982 `raster' here because RasterBits below is a char *, and invites
7983 problems with bytes >= 0x80. */
7984 raster
= (unsigned char *) gif
->SavedImages
[ino
].RasterBits
;
7986 if (gif
->SavedImages
[ino
].ImageDesc
.Interlace
)
7989 int row
= interlace_start
[0];
7993 for (y
= 0; y
< image_height
; y
++)
7995 if (row
>= image_height
)
7997 row
= interlace_start
[++pass
];
7998 while (row
>= image_height
)
7999 row
= interlace_start
[++pass
];
8002 for (x
= 0; x
< image_width
; x
++)
8004 int i
= raster
[(y
* image_width
) + x
];
8005 XPutPixel (ximg
, x
+ img
->corners
[LEFT_CORNER
],
8006 row
+ img
->corners
[TOP_CORNER
], pixel_colors
[i
]);
8009 row
+= interlace_increment
[pass
];
8014 for (y
= 0; y
< image_height
; ++y
)
8015 for (x
= 0; x
< image_width
; ++x
)
8017 int i
= raster
[y
* image_width
+ x
];
8018 XPutPixel (ximg
, x
+ img
->corners
[LEFT_CORNER
],
8019 y
+ img
->corners
[TOP_CORNER
], pixel_colors
[i
]);
8023 /* Save GIF image extension data for `image-extension-data'.
8024 Format is (count IMAGES FUNCTION "BYTES" ...). */
8025 img
->data
.lisp_val
= Qnil
;
8026 if (gif
->SavedImages
[ino
].ExtensionBlockCount
> 0)
8028 ExtensionBlock
*ext
= gif
->SavedImages
[ino
].ExtensionBlocks
;
8029 for (i
= 0; i
< gif
->SavedImages
[ino
].ExtensionBlockCount
; i
++, ext
++)
8030 /* Append (... FUNCTION "BYTES") */
8031 img
->data
.lisp_val
= Fcons (make_unibyte_string (ext
->Bytes
, ext
->ByteCount
),
8032 Fcons (make_number (ext
->Function
),
8033 img
->data
.lisp_val
));
8034 img
->data
.lisp_val
= Fnreverse (img
->data
.lisp_val
);
8036 if (gif
->ImageCount
> 1)
8037 img
->data
.lisp_val
= Fcons (Qcount
,
8038 Fcons (make_number (gif
->ImageCount
),
8039 img
->data
.lisp_val
));
8041 fn_DGifCloseFile (gif
);
8043 /* Maybe fill in the background field while we have ximg handy. */
8044 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
8045 /* Casting avoids a GCC warning. */
8046 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
8048 /* Put the image into the pixmap, then free the X image and its buffer. */
8049 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
8050 x_destroy_x_image (ximg
);
8056 #else /* !HAVE_GIF */
8064 Lisp_Object specified_file
, file
;
8065 Lisp_Object specified_data
;
8067 Boolean graphic_p
, movie_p
, prefer_graphic_p
;
8075 Lisp_Object specified_bg
;
8080 TimeScale time_scale
;
8081 TimeValue time
, duration
;
8086 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
8087 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
8089 /* Animated gifs use QuickTime Movie Toolbox. So initialize it here. */
8092 if (NILP (specified_data
))
8094 /* Read from a file */
8098 err
= find_image_fsspec (specified_file
, &file
, &fss
);
8102 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
8107 err
= CanQuickTimeOpenFile (&fss
, kQTFileTypeGIF
, 0,
8108 &graphic_p
, &movie_p
, &prefer_graphic_p
, 0);
8112 if (!graphic_p
&& !movie_p
)
8114 if (prefer_graphic_p
)
8115 return image_load_qt_1 (f
, img
, kQTFileTypeGIF
, &fss
, NULL
);
8116 err
= OpenMovieFile (&fss
, &refnum
, fsRdPerm
);
8119 err
= NewMovieFromFile (&movie
, refnum
, NULL
, NULL
, 0, NULL
);
8120 CloseMovieFile (refnum
);
8123 image_error ("Error reading `%s'", file
, Qnil
);
8129 /* Memory source! */
8131 long file_type_atom
[3];
8133 err
= PtrToHand (SDATA (specified_data
), &dh
, SBYTES (specified_data
));
8136 image_error ("Cannot allocate data handle for `%s'",
8141 file_type_atom
[0] = EndianU32_NtoB (sizeof (long) * 3);
8142 file_type_atom
[1] = EndianU32_NtoB (kDataRefExtensionMacOSFileType
);
8143 file_type_atom
[2] = EndianU32_NtoB (kQTFileTypeGIF
);
8144 err
= PtrToHand (&dh
, &dref
, sizeof (Handle
));
8147 err
= PtrAndHand ("\p", dref
, 1);
8149 err
= PtrAndHand (file_type_atom
, dref
, sizeof (long) * 3);
8152 image_error ("Cannot allocate handle data ref for `%s'", img
->spec
, Qnil
);
8155 err
= CanQuickTimeOpenDataRef (dref
, HandleDataHandlerSubType
, &graphic_p
,
8156 &movie_p
, &prefer_graphic_p
, 0);
8160 if (!graphic_p
&& !movie_p
)
8162 if (prefer_graphic_p
)
8166 DisposeHandle (dref
);
8167 success_p
= image_load_qt_1 (f
, img
, kQTFileTypeGIF
, NULL
, dh
);
8171 err
= NewMovieFromDataRef (&movie
, 0, NULL
, dref
,
8172 HandleDataHandlerSubType
);
8173 DisposeHandle (dref
);
8178 image
= image_spec_value (img
->spec
, QCindex
, NULL
);
8179 ino
= INTEGERP (image
) ? XFASTINT (image
) : 0;
8180 track
= GetMovieIndTrack (movie
, 1);
8181 media
= GetTrackMedia (track
);
8182 nsamples
= GetMediaSampleCount (media
);
8183 if (ino
>= nsamples
)
8185 image_error ("Invalid image number `%s' in image `%s'",
8189 time_scale
= GetMediaTimeScale (media
);
8191 specified_bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
8192 if (!STRINGP (specified_bg
) ||
8193 !mac_defined_color (f
, SDATA (specified_bg
), &color
, 0))
8195 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
8196 color
.red
= RED16_FROM_ULONG (color
.pixel
);
8197 color
.green
= GREEN16_FROM_ULONG (color
.pixel
);
8198 color
.blue
= BLUE16_FROM_ULONG (color
.pixel
);
8200 GetMovieBox (movie
, &rect
);
8201 width
= img
->width
= rect
.right
- rect
.left
;
8202 height
= img
->height
= rect
.bottom
- rect
.top
;
8203 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
8206 GetGWorld (&old_port
, &old_gdh
);
8207 SetGWorld (ximg
, NULL
);
8208 bg_color
.red
= color
.red
;
8209 bg_color
.green
= color
.green
;
8210 bg_color
.blue
= color
.blue
;
8211 RGBBackColor (&bg_color
);
8212 SetGWorld (old_port
, old_gdh
);
8213 SetMovieActive (movie
, 1);
8214 SetMovieGWorld (movie
, ximg
, NULL
);
8215 SampleNumToMediaTime (media
, ino
+ 1, &time
, &duration
);
8216 SetMovieTimeValue (movie
, time
);
8217 MoviesTask (movie
, 0L);
8218 DisposeTrackMedia (media
);
8219 DisposeMovieTrack (track
);
8220 DisposeMovie (movie
);
8224 /* Save GIF image extension data for `image-extension-data'.
8225 Format is (count IMAGES 0xf9 GRAPHIC_CONTROL_EXTENSION_BLOCK). */
8227 Lisp_Object gce
= make_uninit_string (4);
8228 int centisec
= ((float)duration
/ time_scale
) * 100.0f
+ 0.5f
;
8230 /* Fill the delay time field. */
8231 SSET (gce
, 1, centisec
& 0xff);
8232 SSET (gce
, 2, (centisec
>> 8) & 0xff);
8233 /* We don't know about other fields. */
8237 img
->data
.lisp_val
= list4 (Qcount
, make_number (nsamples
),
8238 make_number (0xf9), gce
);
8241 /* Maybe fill in the background field while we have ximg handy. */
8242 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
8243 IMAGE_BACKGROUND (img
, f
, ximg
);
8245 /* Put the image into the pixmap. */
8246 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
8247 x_destroy_x_image (ximg
);
8251 image_error ("Cannot open `%s'", file
, Qnil
);
8254 DisposeTrackMedia (media
);
8256 DisposeMovieTrack (track
);
8258 DisposeMovie (movie
);
8265 #endif /* HAVE_GIF */
8269 /***********************************************************************
8271 ***********************************************************************/
8273 #if defined (HAVE_RSVG)
8275 /* Function prototypes. */
8277 static int svg_image_p
P_ ((Lisp_Object object
));
8278 static int svg_load
P_ ((struct frame
*f
, struct image
*img
));
8280 static int svg_load_image
P_ ((struct frame
*, struct image
*,
8281 unsigned char *, unsigned int));
8283 /* The symbol `svg' identifying images of this type. */
8287 /* Indices of image specification fields in svg_format, below. */
8289 enum svg_keyword_index
8304 /* Vector of image_keyword structures describing the format
8305 of valid user-defined image specifications. */
8307 static struct image_keyword svg_format
[SVG_LAST
] =
8309 {":type", IMAGE_SYMBOL_VALUE
, 1},
8310 {":data", IMAGE_STRING_VALUE
, 0},
8311 {":file", IMAGE_STRING_VALUE
, 0},
8312 {":ascent", IMAGE_ASCENT_VALUE
, 0},
8313 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
8314 {":relief", IMAGE_INTEGER_VALUE
, 0},
8315 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8316 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8317 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8318 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
8321 /* Structure describing the image type `svg'. Its the same type of
8322 structure defined for all image formats, handled by emacs image
8323 functions. See struct image_type in dispextern.h. */
8325 static struct image_type svg_type
=
8327 /* An identifier showing that this is an image structure for the SVG format. */
8329 /* Handle to a function that can be used to identify a SVG file. */
8331 /* Handle to function used to load a SVG file. */
8333 /* Handle to function to free sresources for SVG. */
8335 /* An internal field to link to the next image type in a list of
8336 image types, will be filled in when registering the format. */
8341 /* Return non-zero if OBJECT is a valid SVG image specification. Do
8342 this by calling parse_image_spec and supplying the keywords that
8343 identify the SVG format. */
8346 svg_image_p (object
)
8349 struct image_keyword fmt
[SVG_LAST
];
8350 bcopy (svg_format
, fmt
, sizeof fmt
);
8352 if (!parse_image_spec (object
, fmt
, SVG_LAST
, Qsvg
))
8355 /* Must specify either the :data or :file keyword. */
8356 return fmt
[SVG_FILE
].count
+ fmt
[SVG_DATA
].count
== 1;
8359 #include <librsvg/rsvg.h>
8363 /* SVG library functions. */
8364 DEF_IMGLIB_FN (rsvg_handle_new
);
8365 DEF_IMGLIB_FN (rsvg_handle_set_size_callback
);
8366 DEF_IMGLIB_FN (rsvg_handle_write
);
8367 DEF_IMGLIB_FN (rsvg_handle_close
);
8368 DEF_IMGLIB_FN (rsvg_handle_get_pixbuf
);
8369 DEF_IMGLIB_FN (rsvg_handle_free
);
8371 DEF_IMGLIB_FN (gdk_pixbuf_get_width
);
8372 DEF_IMGLIB_FN (gdk_pixbuf_get_height
);
8373 DEF_IMGLIB_FN (gdk_pixbuf_get_pixels
);
8374 DEF_IMGLIB_FN (gdk_pixbuf_get_rowstride
);
8375 DEF_IMGLIB_FN (gdk_pixbuf_get_colorspace
);
8376 DEF_IMGLIB_FN (gdk_pixbuf_get_n_channels
);
8377 DEF_IMGLIB_FN (gdk_pixbuf_get_has_alpha
);
8378 DEF_IMGLIB_FN (gdk_pixbuf_get_bits_per_sample
);
8380 DEF_IMGLIB_FN (g_type_init
);
8381 DEF_IMGLIB_FN (g_object_unref
);
8382 DEF_IMGLIB_FN (g_error_free
);
8384 Lisp_Object Qgdk_pixbuf
, Qglib
;
8387 init_svg_functions (Lisp_Object libraries
)
8389 HMODULE library
, gdklib
, glib
;
8391 if (!(glib
= w32_delayed_load (libraries
, Qglib
))
8392 || !(gdklib
= w32_delayed_load (libraries
, Qgdk_pixbuf
))
8393 || !(library
= w32_delayed_load (libraries
, Qsvg
)))
8396 LOAD_IMGLIB_FN (library
, rsvg_handle_new
);
8397 LOAD_IMGLIB_FN (library
, rsvg_handle_set_size_callback
);
8398 LOAD_IMGLIB_FN (library
, rsvg_handle_write
);
8399 LOAD_IMGLIB_FN (library
, rsvg_handle_close
);
8400 LOAD_IMGLIB_FN (library
, rsvg_handle_get_pixbuf
);
8401 LOAD_IMGLIB_FN (library
, rsvg_handle_free
);
8403 LOAD_IMGLIB_FN (gdklib
, gdk_pixbuf_get_width
);
8404 LOAD_IMGLIB_FN (gdklib
, gdk_pixbuf_get_height
);
8405 LOAD_IMGLIB_FN (gdklib
, gdk_pixbuf_get_pixels
);
8406 LOAD_IMGLIB_FN (gdklib
, gdk_pixbuf_get_rowstride
);
8407 LOAD_IMGLIB_FN (gdklib
, gdk_pixbuf_get_colorspace
);
8408 LOAD_IMGLIB_FN (gdklib
, gdk_pixbuf_get_n_channels
);
8409 LOAD_IMGLIB_FN (gdklib
, gdk_pixbuf_get_has_alpha
);
8410 LOAD_IMGLIB_FN (gdklib
, gdk_pixbuf_get_bits_per_sample
);
8412 LOAD_IMGLIB_FN (glib
, g_type_init
);
8413 LOAD_IMGLIB_FN (glib
, g_object_unref
);
8414 LOAD_IMGLIB_FN (glib
, g_error_free
);
8419 /* The following aliases for library functions allow dynamic loading
8420 to be used on some platforms. */
8421 #define fn_rsvg_handle_new rsvg_handle_new
8422 #define fn_rsvg_handle_set_size_callback rsvg_handle_set_size_callback
8423 #define fn_rsvg_handle_write rsvg_handle_write
8424 #define fn_rsvg_handle_close rsvg_handle_close
8425 #define fn_rsvg_handle_get_pixbuf rsvg_handle_get_pixbuf
8426 #define fn_rsvg_handle_free rsvg_handle_free
8428 #define fn_gdk_pixbuf_get_width gdk_pixbuf_get_width
8429 #define fn_gdk_pixbuf_get_height gdk_pixbuf_get_height
8430 #define fn_gdk_pixbuf_get_pixels gdk_pixbuf_get_pixels
8431 #define fn_gdk_pixbuf_get_rowstride gdk_pixbuf_get_rowstride
8432 #define fn_gdk_pixbuf_get_colorspace gdk_pixbuf_get_colorspace
8433 #define fn_gdk_pixbuf_get_n_channels gdk_pixbuf_get_n_channels
8434 #define fn_gdk_pixbuf_get_has_alpha gdk_pixbuf_get_has_alpha
8435 #define fn_gdk_pixbuf_get_bits_per_sample gdk_pixbuf_get_bits_per_sample
8437 #define fn_g_type_init g_type_init
8438 #define fn_g_object_unref g_object_unref
8439 #define fn_g_error_free g_error_free
8440 #endif /* !HAVE_NTGUI */
8442 /* Load SVG image IMG for use on frame F. Value is non-zero if
8443 successful. this function will go into the svg_type structure, and
8444 the prototype thus needs to be compatible with that structure. */
8452 Lisp_Object file_name
;
8454 /* If IMG->spec specifies a file name, create a non-file spec from it. */
8455 file_name
= image_spec_value (img
->spec
, QCfile
, NULL
);
8456 if (STRINGP (file_name
))
8459 unsigned char *contents
;
8461 struct gcpro gcpro1
;
8463 file
= x_find_image_file (file_name
);
8465 if (!STRINGP (file
))
8467 image_error ("Cannot find image file `%s'", file_name
, Qnil
);
8472 /* Read the entire file into memory. */
8473 contents
= slurp_file (SDATA (file
), &size
);
8474 if (contents
== NULL
)
8476 image_error ("Error loading SVG image `%s'", img
->spec
, Qnil
);
8480 /* If the file was slurped into memory properly, parse it. */
8481 success_p
= svg_load_image (f
, img
, contents
, size
);
8485 /* Else its not a file, its a lisp object. Load the image from a
8486 lisp object rather than a file. */
8491 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
8492 success_p
= svg_load_image (f
, img
, SDATA (data
), SBYTES (data
));
8498 /* svg_load_image is a helper function for svg_load, which does the
8499 actual loading given contents and size, apart from frame and image
8500 structures, passed from svg_load.
8502 Uses librsvg to do most of the image processing.
8504 Returns non-zero when successful. */
8506 svg_load_image (f
, img
, contents
, size
)
8507 /* Pointer to emacs frame structure. */
8509 /* Pointer to emacs image structure. */
8511 /* String containing the SVG XML data to be parsed. */
8512 unsigned char *contents
;
8513 /* Size of data in bytes. */
8516 RsvgHandle
*rsvg_handle
;
8517 GError
*error
= NULL
;
8521 const guint8
*pixels
;
8524 Lisp_Object specified_bg
;
8529 /* g_type_init is a glib function that must be called prior to using
8530 gnome type library functions. */
8532 /* Make a handle to a new rsvg object. */
8533 rsvg_handle
= fn_rsvg_handle_new ();
8535 /* Parse the contents argument and fill in the rsvg_handle. */
8536 fn_rsvg_handle_write (rsvg_handle
, contents
, size
, &error
);
8540 /* The parsing is complete, rsvg_handle is ready to used, close it
8541 for further writes. */
8542 fn_rsvg_handle_close (rsvg_handle
, &error
);
8545 /* We can now get a valid pixel buffer from the svg file, if all
8547 pixbuf
= fn_rsvg_handle_get_pixbuf (rsvg_handle
);
8550 /* Extract some meta data from the svg handle. */
8551 width
= fn_gdk_pixbuf_get_width (pixbuf
);
8552 height
= fn_gdk_pixbuf_get_height (pixbuf
);
8553 pixels
= fn_gdk_pixbuf_get_pixels (pixbuf
);
8554 rowstride
= fn_gdk_pixbuf_get_rowstride (pixbuf
);
8556 /* Validate the svg meta data. */
8557 eassert (fn_gdk_pixbuf_get_colorspace (pixbuf
) == GDK_COLORSPACE_RGB
);
8558 eassert (fn_gdk_pixbuf_get_n_channels (pixbuf
) == 4);
8559 eassert (fn_gdk_pixbuf_get_has_alpha (pixbuf
));
8560 eassert (fn_gdk_pixbuf_get_bits_per_sample (pixbuf
) == 8);
8562 /* Try to create a x pixmap to hold the svg pixmap. */
8563 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
8565 fn_g_object_unref (pixbuf
);
8569 init_color_table ();
8571 /* Handle alpha channel by combining the image with a background
8573 specified_bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
8574 if (STRINGP (specified_bg
)
8575 && x_defined_color (f
, SDATA (specified_bg
), &background
, 0))
8577 background
.red
>>= 8;
8578 background
.green
>>= 8;
8579 background
.blue
>>= 8;
8583 #ifdef HAVE_X_WINDOWS
8584 background
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
8585 x_query_color (f
, &background
);
8587 /* SVG pixmaps specify transparency in the last byte, so right
8588 shift 8 bits to get rid of it, since emacs doesn't support
8590 background
.red
>>= 8;
8591 background
.green
>>= 8;
8592 background
.blue
>>= 8;
8593 #elif defined (MAC_OS)
8594 background
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
8595 background
.red
= RED_FROM_ULONG (background
.pixel
);
8596 background
.green
= GREEN_FROM_ULONG (background
.pixel
);
8597 background
.blue
= BLUE_FROM_ULONG (background
.pixel
);
8598 #elif defined (HAVE_NTGUI)
8599 background
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
8600 #if 0 /* W32 TODO : Colormap support. */
8601 x_query_color (f
, &background
);
8604 /* SVG pixmaps specify transparency in the last byte, so right
8605 shift 8 bits to get rid of it, since emacs doesn't support
8607 background
.red
>>= 8;
8608 background
.green
>>= 8;
8609 background
.blue
>>= 8;
8610 #else /* not HAVE_X_WINDOWS && not MAC_OS*/
8615 /* This loop handles opacity values, since Emacs assumes
8616 non-transparent images. Each pixel must be "flattened" by
8617 calculating the resulting color, given the transparency of the
8618 pixel, and the image background color. */
8619 for (y
= 0; y
< height
; ++y
)
8621 for (x
= 0; x
< width
; ++x
)
8631 opacity
= *pixels
++;
8633 red
= ((red
* opacity
)
8634 + (background
.red
* ((1 << 8) - opacity
)));
8635 green
= ((green
* opacity
)
8636 + (background
.green
* ((1 << 8) - opacity
)));
8637 blue
= ((blue
* opacity
)
8638 + (background
.blue
* ((1 << 8) - opacity
)));
8640 XPutPixel (ximg
, x
, y
, lookup_rgb_color (f
, red
, green
, blue
));
8643 pixels
+= rowstride
- 4 * width
;
8646 #ifdef COLOR_TABLE_SUPPORT
8647 /* Remember colors allocated for this image. */
8648 img
->colors
= colors_in_color_table (&img
->ncolors
);
8649 free_color_table ();
8650 #endif /* COLOR_TABLE_SUPPORT */
8652 fn_g_object_unref (pixbuf
);
8655 img
->height
= height
;
8657 /* Maybe fill in the background field while we have ximg handy.
8658 Casting avoids a GCC warning. */
8659 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
8661 /* Put the image into the pixmap, then free the X image and its
8663 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
8664 x_destroy_x_image (ximg
);
8669 /* FIXME: Use error->message so the user knows what is the actual
8670 problem with the image. */
8671 image_error ("Error parsing SVG image `%s'", img
->spec
, Qnil
);
8672 fn_g_error_free (error
);
8676 #endif /* defined (HAVE_RSVG) */
8681 /***********************************************************************
8683 ***********************************************************************/
8685 #ifdef HAVE_X_WINDOWS
8686 #define HAVE_GHOSTSCRIPT 1
8687 #endif /* HAVE_X_WINDOWS */
8689 /* The symbol `postscript' identifying images of this type. */
8691 Lisp_Object Qpostscript
;
8693 #ifdef HAVE_GHOSTSCRIPT
8695 static int gs_image_p
P_ ((Lisp_Object object
));
8696 static int gs_load
P_ ((struct frame
*f
, struct image
*img
));
8697 static void gs_clear_image
P_ ((struct frame
*f
, struct image
*img
));
8699 /* Keyword symbols. */
8701 Lisp_Object QCloader
, QCbounding_box
, QCpt_width
, QCpt_height
;
8703 /* Indices of image specification fields in gs_format, below. */
8705 enum gs_keyword_index
8723 /* Vector of image_keyword structures describing the format
8724 of valid user-defined image specifications. */
8726 static struct image_keyword gs_format
[GS_LAST
] =
8728 {":type", IMAGE_SYMBOL_VALUE
, 1},
8729 {":pt-width", IMAGE_POSITIVE_INTEGER_VALUE
, 1},
8730 {":pt-height", IMAGE_POSITIVE_INTEGER_VALUE
, 1},
8731 {":file", IMAGE_STRING_VALUE
, 1},
8732 {":loader", IMAGE_FUNCTION_VALUE
, 0},
8733 {":bounding-box", IMAGE_DONT_CHECK_VALUE_TYPE
, 1},
8734 {":ascent", IMAGE_ASCENT_VALUE
, 0},
8735 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
8736 {":relief", IMAGE_INTEGER_VALUE
, 0},
8737 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8738 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8739 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8740 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
8743 /* Structure describing the image type `ghostscript'. */
8745 static struct image_type gs_type
=
8755 /* Free X resources of Ghostscript image IMG which is used on frame F. */
8758 gs_clear_image (f
, img
)
8762 /* IMG->data.ptr_val may contain a recorded colormap. */
8763 xfree (img
->data
.ptr_val
);
8764 x_clear_image (f
, img
);
8768 /* Return non-zero if OBJECT is a valid Ghostscript image
8775 struct image_keyword fmt
[GS_LAST
];
8779 bcopy (gs_format
, fmt
, sizeof fmt
);
8781 if (!parse_image_spec (object
, fmt
, GS_LAST
, Qpostscript
))
8784 /* Bounding box must be a list or vector containing 4 integers. */
8785 tem
= fmt
[GS_BOUNDING_BOX
].value
;
8788 for (i
= 0; i
< 4; ++i
, tem
= XCDR (tem
))
8789 if (!CONSP (tem
) || !INTEGERP (XCAR (tem
)))
8794 else if (VECTORP (tem
))
8796 if (XVECTOR (tem
)->size
!= 4)
8798 for (i
= 0; i
< 4; ++i
)
8799 if (!INTEGERP (XVECTOR (tem
)->contents
[i
]))
8809 /* Load Ghostscript image IMG for use on frame F. Value is non-zero
8818 Lisp_Object window_and_pixmap_id
= Qnil
, loader
, pt_height
, pt_width
;
8819 struct gcpro gcpro1
, gcpro2
;
8821 double in_width
, in_height
;
8822 Lisp_Object pixel_colors
= Qnil
;
8824 /* Compute pixel size of pixmap needed from the given size in the
8825 image specification. Sizes in the specification are in pt. 1 pt
8826 = 1/72 in, xdpi and ydpi are stored in the frame's X display
8828 pt_width
= image_spec_value (img
->spec
, QCpt_width
, NULL
);
8829 in_width
= XFASTINT (pt_width
) / 72.0;
8830 img
->width
= in_width
* FRAME_X_DISPLAY_INFO (f
)->resx
;
8831 pt_height
= image_spec_value (img
->spec
, QCpt_height
, NULL
);
8832 in_height
= XFASTINT (pt_height
) / 72.0;
8833 img
->height
= in_height
* FRAME_X_DISPLAY_INFO (f
)->resy
;
8835 if (!check_image_size (f
, img
->width
, img
->height
))
8837 image_error ("Invalid image size", Qnil
, Qnil
);
8841 /* Create the pixmap. */
8842 xassert (img
->pixmap
== NO_PIXMAP
);
8844 /* Only W32 version did BLOCK_INPUT here. ++kfs */
8846 img
->pixmap
= XCreatePixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
8847 img
->width
, img
->height
,
8848 DefaultDepthOfScreen (FRAME_X_SCREEN (f
)));
8853 image_error ("Unable to create pixmap for `%s'", img
->spec
, Qnil
);
8857 /* Call the loader to fill the pixmap. It returns a process object
8858 if successful. We do not record_unwind_protect here because
8859 other places in redisplay like calling window scroll functions
8860 don't either. Let the Lisp loader use `unwind-protect' instead. */
8861 GCPRO2 (window_and_pixmap_id
, pixel_colors
);
8863 sprintf (buffer
, "%lu %lu",
8864 (unsigned long) FRAME_X_WINDOW (f
),
8865 (unsigned long) img
->pixmap
);
8866 window_and_pixmap_id
= build_string (buffer
);
8868 sprintf (buffer
, "%lu %lu",
8869 FRAME_FOREGROUND_PIXEL (f
),
8870 FRAME_BACKGROUND_PIXEL (f
));
8871 pixel_colors
= build_string (buffer
);
8873 XSETFRAME (frame
, f
);
8874 loader
= image_spec_value (img
->spec
, QCloader
, NULL
);
8876 loader
= intern ("gs-load-image");
8878 img
->data
.lisp_val
= call6 (loader
, frame
, img
->spec
,
8879 make_number (img
->width
),
8880 make_number (img
->height
),
8881 window_and_pixmap_id
,
8884 return PROCESSP (img
->data
.lisp_val
);
8888 /* Kill the Ghostscript process that was started to fill PIXMAP on
8889 frame F. Called from XTread_socket when receiving an event
8890 telling Emacs that Ghostscript has finished drawing. */
8893 x_kill_gs_process (pixmap
, f
)
8897 struct image_cache
*c
= FRAME_IMAGE_CACHE (f
);
8901 /* Find the image containing PIXMAP. */
8902 for (i
= 0; i
< c
->used
; ++i
)
8903 if (c
->images
[i
]->pixmap
== pixmap
)
8906 /* Should someone in between have cleared the image cache, for
8907 instance, give up. */
8911 /* Kill the GS process. We should have found PIXMAP in the image
8912 cache and its image should contain a process object. */
8914 xassert (PROCESSP (img
->data
.lisp_val
));
8915 Fkill_process (img
->data
.lisp_val
, Qnil
);
8916 img
->data
.lisp_val
= Qnil
;
8918 #if defined (HAVE_X_WINDOWS)
8920 /* On displays with a mutable colormap, figure out the colors
8921 allocated for the image by looking at the pixels of an XImage for
8923 class = FRAME_X_VISUAL (f
)->class;
8924 if (class != StaticColor
&& class != StaticGray
&& class != TrueColor
)
8930 /* Try to get an XImage for img->pixmep. */
8931 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
8932 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
8937 /* Initialize the color table. */
8938 init_color_table ();
8940 /* For each pixel of the image, look its color up in the
8941 color table. After having done so, the color table will
8942 contain an entry for each color used by the image. */
8943 for (y
= 0; y
< img
->height
; ++y
)
8944 for (x
= 0; x
< img
->width
; ++x
)
8946 unsigned long pixel
= XGetPixel (ximg
, x
, y
);
8947 lookup_pixel_color (f
, pixel
);
8950 /* Record colors in the image. Free color table and XImage. */
8951 #ifdef COLOR_TABLE_SUPPORT
8952 img
->colors
= colors_in_color_table (&img
->ncolors
);
8953 free_color_table ();
8955 XDestroyImage (ximg
);
8957 #if 0 /* This doesn't seem to be the case. If we free the colors
8958 here, we get a BadAccess later in x_clear_image when
8959 freeing the colors. */
8960 /* We have allocated colors once, but Ghostscript has also
8961 allocated colors on behalf of us. So, to get the
8962 reference counts right, free them once. */
8964 x_free_colors (f
, img
->colors
, img
->ncolors
);
8968 image_error ("Cannot get X image of `%s'; colors will not be freed",
8973 #endif /* HAVE_X_WINDOWS */
8975 /* Now that we have the pixmap, compute mask and transform the
8976 image if requested. */
8978 postprocess_image (f
, img
);
8982 #endif /* HAVE_GHOSTSCRIPT */
8985 /***********************************************************************
8987 ***********************************************************************/
8991 DEFUN ("imagep", Fimagep
, Simagep
, 1, 1, 0,
8992 doc
: /* Value is non-nil if SPEC is a valid image specification. */)
8996 return valid_image_p (spec
) ? Qt
: Qnil
;
9000 DEFUN ("lookup-image", Flookup_image
, Slookup_image
, 1, 1, 0, "")
9006 if (valid_image_p (spec
))
9007 id
= lookup_image (SELECTED_FRAME (), spec
);
9010 return make_number (id
);
9013 #endif /* GLYPH_DEBUG != 0 */
9016 /***********************************************************************
9018 ***********************************************************************/
9021 /* Image types that rely on external libraries are loaded dynamically
9022 if the library is available. */
9023 #define CHECK_LIB_AVAILABLE(image_type, init_lib_fn, libraries) \
9024 define_image_type (image_type, init_lib_fn (libraries))
9026 #define CHECK_LIB_AVAILABLE(image_type, init_lib_fn, libraries) \
9027 define_image_type (image_type, 1)
9028 #endif /* HAVE_NTGUI */
9030 DEFUN ("init-image-library", Finit_image_library
, Sinit_image_library
, 2, 2, 0,
9031 doc
: /* Initialize image library implementing image type TYPE.
9032 Return non-nil if TYPE is a supported image type.
9034 Image types pbm and xbm are prebuilt; other types are loaded here.
9035 Libraries to load are specified in alist LIBRARIES (usually, the value
9036 of `image-library-alist', which see). */)
9038 Lisp_Object type
, libraries
;
9042 /* Don't try to reload the library. */
9043 tested
= Fassq (type
, Vimage_type_cache
);
9045 return XCDR (tested
);
9047 #if defined (HAVE_XPM) || defined (MAC_OS)
9048 if (EQ (type
, Qxpm
))
9049 return CHECK_LIB_AVAILABLE (&xpm_type
, init_xpm_functions
, libraries
);
9052 #if defined (HAVE_JPEG) || defined (MAC_OS)
9053 if (EQ (type
, Qjpeg
))
9054 return CHECK_LIB_AVAILABLE (&jpeg_type
, init_jpeg_functions
, libraries
);
9057 #if defined (HAVE_TIFF) || defined (MAC_OS)
9058 if (EQ (type
, Qtiff
))
9059 return CHECK_LIB_AVAILABLE (&tiff_type
, init_tiff_functions
, libraries
);
9062 #if defined (HAVE_GIF) || defined (MAC_OS)
9063 if (EQ (type
, Qgif
))
9064 return CHECK_LIB_AVAILABLE (&gif_type
, init_gif_functions
, libraries
);
9067 #if defined (HAVE_PNG) || defined (MAC_OS)
9068 if (EQ (type
, Qpng
))
9069 return CHECK_LIB_AVAILABLE (&png_type
, init_png_functions
, libraries
);
9072 #if defined (HAVE_RSVG)
9073 if (EQ (type
, Qsvg
))
9074 return CHECK_LIB_AVAILABLE (&svg_type
, init_svg_functions
, libraries
);
9077 #ifdef HAVE_GHOSTSCRIPT
9078 if (EQ (type
, Qpostscript
))
9079 return CHECK_LIB_AVAILABLE (&gs_type
, init_gs_functions
, libraries
);
9082 /* If the type is not recognized, avoid testing it ever again. */
9083 CACHE_IMAGE_TYPE (type
, Qnil
);
9090 extern Lisp_Object Qrisky_local_variable
; /* Syms_of_xdisp has already run. */
9092 /* Initialize this only once, since that's what we do with Vimage_types
9093 and they are supposed to be in sync. Initializing here gives correct
9094 operation on GNU/Linux of calling dump-emacs after loading some images. */
9097 /* Must be defined now becase we're going to update it below, while
9098 defining the supported image types. */
9099 DEFVAR_LISP ("image-types", &Vimage_types
,
9100 doc
: /* List of potentially supported image types.
9101 Each element of the list is a symbol for an image type, like 'jpeg or 'png.
9102 To check whether it is really supported, use `image-type-available-p'. */);
9103 Vimage_types
= Qnil
;
9105 DEFVAR_LISP ("image-library-alist", &Vimage_library_alist
,
9106 doc
: /* Alist of image types vs external libraries needed to display them.
9108 Each element is a list (IMAGE-TYPE LIBRARY...), where the car is a symbol
9109 representing a supported image type, and the rest are strings giving
9110 alternate filenames for the corresponding external libraries.
9112 Emacs tries to load the libraries in the order they appear on the
9113 list; if none is loaded, the running session of Emacs won't
9114 support the image type. Types 'pbm and 'xbm don't need to be
9115 listed; they are always supported. */);
9116 Vimage_library_alist
= Qnil
;
9117 Fput (intern ("image-library-alist"), Qrisky_local_variable
, Qt
);
9119 DEFVAR_LISP ("max-image-size", &Vmax_image_size
,
9120 doc
: /* Maximum size of images.
9121 Emacs will not load an image into memory if its pixel width or
9122 pixel height exceeds this limit.
9124 If the value is an integer, it directly specifies the maximum
9125 image height and width, measured in pixels. If it is a floating
9126 point number, it specifies the maximum image height and width
9127 as a ratio to the frame height and width. If the value is
9128 non-numeric, there is no explicit limit on the size of images. */);
9129 Vmax_image_size
= make_float (MAX_IMAGE_SIZE
);
9131 Vimage_type_cache
= Qnil
;
9132 staticpro (&Vimage_type_cache
);
9134 Qpbm
= intern ("pbm");
9136 ADD_IMAGE_TYPE (Qpbm
);
9138 Qxbm
= intern ("xbm");
9140 ADD_IMAGE_TYPE (Qxbm
);
9142 define_image_type (&xbm_type
, 1);
9143 define_image_type (&pbm_type
, 1);
9145 Qcount
= intern ("count");
9146 staticpro (&Qcount
);
9148 QCascent
= intern (":ascent");
9149 staticpro (&QCascent
);
9150 QCmargin
= intern (":margin");
9151 staticpro (&QCmargin
);
9152 QCrelief
= intern (":relief");
9153 staticpro (&QCrelief
);
9154 QCconversion
= intern (":conversion");
9155 staticpro (&QCconversion
);
9156 QCcolor_symbols
= intern (":color-symbols");
9157 staticpro (&QCcolor_symbols
);
9158 QCheuristic_mask
= intern (":heuristic-mask");
9159 staticpro (&QCheuristic_mask
);
9160 QCindex
= intern (":index");
9161 staticpro (&QCindex
);
9162 QCmatrix
= intern (":matrix");
9163 staticpro (&QCmatrix
);
9164 QCcolor_adjustment
= intern (":color-adjustment");
9165 staticpro (&QCcolor_adjustment
);
9166 QCmask
= intern (":mask");
9167 staticpro (&QCmask
);
9169 Qlaplace
= intern ("laplace");
9170 staticpro (&Qlaplace
);
9171 Qemboss
= intern ("emboss");
9172 staticpro (&Qemboss
);
9173 Qedge_detection
= intern ("edge-detection");
9174 staticpro (&Qedge_detection
);
9175 Qheuristic
= intern ("heuristic");
9176 staticpro (&Qheuristic
);
9178 Qpostscript
= intern ("postscript");
9179 staticpro (&Qpostscript
);
9180 #ifdef HAVE_GHOSTSCRIPT
9181 ADD_IMAGE_TYPE (Qpostscript
);
9182 QCloader
= intern (":loader");
9183 staticpro (&QCloader
);
9184 QCbounding_box
= intern (":bounding-box");
9185 staticpro (&QCbounding_box
);
9186 QCpt_width
= intern (":pt-width");
9187 staticpro (&QCpt_width
);
9188 QCpt_height
= intern (":pt-height");
9189 staticpro (&QCpt_height
);
9190 #endif /* HAVE_GHOSTSCRIPT */
9192 #if defined (HAVE_XPM) || defined (MAC_OS)
9193 Qxpm
= intern ("xpm");
9195 ADD_IMAGE_TYPE (Qxpm
);
9198 #if defined (HAVE_JPEG) || defined (MAC_OS)
9199 Qjpeg
= intern ("jpeg");
9201 ADD_IMAGE_TYPE (Qjpeg
);
9204 #if defined (HAVE_TIFF) || defined (MAC_OS)
9205 Qtiff
= intern ("tiff");
9207 ADD_IMAGE_TYPE (Qtiff
);
9210 #if defined (HAVE_GIF) || defined (MAC_OS)
9211 Qgif
= intern ("gif");
9213 ADD_IMAGE_TYPE (Qgif
);
9216 #if defined (HAVE_PNG) || defined (MAC_OS)
9217 Qpng
= intern ("png");
9219 ADD_IMAGE_TYPE (Qpng
);
9222 #if defined (HAVE_RSVG)
9223 Qsvg
= intern ("svg");
9225 ADD_IMAGE_TYPE (Qsvg
);
9227 Qgdk_pixbuf
= intern ("gdk-pixbuf");
9228 staticpro (&Qgdk_pixbuf
);
9229 Qglib
= intern ("glib");
9231 #endif /* HAVE_NTGUI */
9232 #endif /* HAVE_RSVG */
9234 defsubr (&Sinit_image_library
);
9235 defsubr (&Sclear_image_cache
);
9236 defsubr (&Simage_refresh
);
9237 defsubr (&Simage_size
);
9238 defsubr (&Simage_mask_p
);
9239 defsubr (&Simage_extension_data
);
9243 defsubr (&Slookup_image
);
9246 DEFVAR_BOOL ("cross-disabled-images", &cross_disabled_images
,
9247 doc
: /* Non-nil means always draw a cross over disabled images.
9248 Disabled images are those having a `:conversion disabled' property.
9249 A cross is always drawn on black & white displays. */);
9250 cross_disabled_images
= 0;
9252 DEFVAR_LISP ("x-bitmap-file-path", &Vx_bitmap_file_path
,
9253 doc
: /* List of directories to search for window system bitmap files. */);
9254 Vx_bitmap_file_path
= decode_env_path ((char *) 0, PATH_BITMAPS
);
9256 DEFVAR_LISP ("image-cache-eviction-delay", &Vimage_cache_eviction_delay
,
9257 doc
: /* Time after which cached images are removed from the cache.
9258 When an image has not been displayed this many seconds, remove it
9259 from the image cache. Value must be an integer or nil with nil
9260 meaning don't clear the cache. */);
9261 Vimage_cache_eviction_delay
= make_number (30 * 60);
9267 #if defined (MAC_OSX) && TARGET_API_MAC_CARBON
9268 init_image_func_pointer ();
9272 /* arch-tag: 123c2a5e-14a8-4c53-ab95-af47d7db49b9
9273 (do not change this comment) */