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 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
20 Boston, MA 02110-1301, USA. */
31 /* This makes the fields of a Display accessible, in Xlib header files. */
33 #define XLIB_ILLEGAL_ACCESS
38 #include "dispextern.h"
39 #include "blockinput.h"
48 #include <sys/types.h>
51 #define COLOR_TABLE_SUPPORT 1
53 typedef struct x_bitmap_record Bitmap_Record
;
54 #define GET_PIXEL(ximg, x, y) XGetPixel(ximg, x, y)
55 #define NO_PIXMAP None
57 #define RGB_PIXEL_COLOR unsigned long
59 #define PIX_MASK_RETAIN 0
60 #define PIX_MASK_DRAW 1
61 #endif /* HAVE_X_WINDOWS */
67 /* W32_TODO : Color tables on W32. */
68 #undef COLOR_TABLE_SUPPORT
70 typedef struct w32_bitmap_record Bitmap_Record
;
71 #define GET_PIXEL(ximg, x, y) GetPixel(ximg, x, y)
74 #define RGB_PIXEL_COLOR COLORREF
76 #define PIX_MASK_RETAIN 0
77 #define PIX_MASK_DRAW 1
79 #define FRAME_X_VISUAL(f) FRAME_X_DISPLAY_INFO (f)->visual
80 #define x_defined_color w32_defined_color
81 #define DefaultDepthOfScreen(screen) (one_w32_display_info.n_cbits)
82 #endif /* HAVE_NTGUI */
90 #include <sys/param.h>
92 #if TARGET_API_MAC_CARBON
94 #include <QuickTime/QuickTime.h>
95 #else /* not MAC_OSX */
96 #include <QuickTime.h>
97 #endif /* not MAC_OSX */
98 #else /* not TARGET_API_MAC_CARBON */
101 #include <TextUtils.h>
102 #include <ImageCompression.h>
103 #include <QuickTimeComponents.h>
104 #endif /* not TARGET_API_MAC_CARBON */
106 /* MAC_TODO : Color tables on Mac. */
107 #undef COLOR_TABLE_SUPPORT
109 #define ZPixmap 0 /* arbitrary */
110 typedef struct mac_bitmap_record Bitmap_Record
;
112 #define GET_PIXEL(ximg, x, y) XGetPixel(ximg, x, y)
115 #define RGB_PIXEL_COLOR unsigned long
117 /* A black pixel in a mask bitmap/pixmap means ``draw a source
118 pixel''. A white pixel means ``retain the current pixel''. */
119 #define PIX_MASK_DRAW RGB_TO_ULONG(0,0,0)
120 #define PIX_MASK_RETAIN RGB_TO_ULONG(255,255,255)
122 #define FRAME_X_VISUAL(f) FRAME_X_DISPLAY_INFO (f)->visual
123 #define x_defined_color mac_defined_color
124 #define DefaultDepthOfScreen(screen) (one_mac_display_info.n_planes)
125 #define XDrawLine(display, w, gc, x1, y1, x2, y2) \
126 mac_draw_line_to_pixmap(display, w, gc, x1, y1, x2, y2)
131 /* Search path for bitmap files. */
133 Lisp_Object Vx_bitmap_file_path
;
136 static void x_disable_image
P_ ((struct frame
*, struct image
*));
137 static void x_edge_detection
P_ ((struct frame
*, struct image
*, Lisp_Object
,
140 static void init_color_table
P_ ((void));
141 static unsigned long lookup_rgb_color
P_ ((struct frame
*f
, int r
, int g
, int b
));
142 #ifdef COLOR_TABLE_SUPPORT
143 static void free_color_table
P_ ((void));
144 static unsigned long *colors_in_color_table
P_ ((int *n
));
145 static unsigned long lookup_pixel_color
P_ ((struct frame
*f
, unsigned long p
));
148 /* Code to deal with bitmaps. Bitmaps are referenced by their bitmap
149 id, which is just an int that this section returns. Bitmaps are
150 reference counted so they can be shared among frames.
152 Bitmap indices are guaranteed to be > 0, so a negative number can
153 be used to indicate no bitmap.
155 If you use x_create_bitmap_from_data, then you must keep track of
156 the bitmaps yourself. That is, creating a bitmap from the same
157 data more than once will not be caught. */
162 XGetImage (display
, pixmap
, x
, y
, width
, height
, plane_mask
, format
)
163 Display
*display
; /* not used */
165 int x
, y
; /* not used */
166 unsigned int width
, height
; /* not used */
167 unsigned long plane_mask
; /* not used */
168 int format
; /* not used */
171 xassert (x
== 0 && y
== 0);
174 SetRect (&ri
, 0, 0, width
, height
);
175 xassert (EqualRect (&ri
, GetPixBounds (GetGWorldPixMap (pixmap
), &rp
)));
177 xassert (! (pixelsLocked
& GetPixelsState (GetGWorldPixMap (pixmap
))));
180 LockPixels (GetGWorldPixMap (pixmap
));
186 XPutPixel (ximage
, x
, y
, pixel
)
191 PixMapHandle pixmap
= GetGWorldPixMap (ximage
);
192 short depth
= GetPixDepth (pixmap
);
194 #if defined (WORDS_BIG_ENDIAN) || !USE_CG_DRAWING
197 char *base_addr
= GetPixBaseAddr (pixmap
);
198 short row_bytes
= GetPixRowBytes (pixmap
);
200 ((unsigned long *) (base_addr
+ y
* row_bytes
))[x
] = 0xff000000 | pixel
;
206 char *base_addr
= GetPixBaseAddr (pixmap
);
207 short row_bytes
= GetPixRowBytes (pixmap
);
209 if (pixel
== PIX_MASK_DRAW
)
210 base_addr
[y
* row_bytes
+ x
/ 8] |= (1 << 7) >> (x
& 7);
212 base_addr
[y
* row_bytes
+ x
/ 8] &= ~((1 << 7) >> (x
& 7));
220 GetGWorld (&old_port
, &old_gdh
);
221 SetGWorld (ximage
, NULL
);
223 color
.red
= RED16_FROM_ULONG (pixel
);
224 color
.green
= GREEN16_FROM_ULONG (pixel
);
225 color
.blue
= BLUE16_FROM_ULONG (pixel
);
227 SetCPixel (x
, y
, &color
);
229 SetGWorld (old_port
, old_gdh
);
234 XGetPixel (ximage
, x
, y
)
238 PixMapHandle pixmap
= GetGWorldPixMap (ximage
);
239 short depth
= GetPixDepth (pixmap
);
241 #if defined (WORDS_BIG_ENDIAN) || !USE_CG_DRAWING
244 char *base_addr
= GetPixBaseAddr (pixmap
);
245 short row_bytes
= GetPixRowBytes (pixmap
);
247 return ((unsigned long *) (base_addr
+ y
* row_bytes
))[x
] & 0x00ffffff;
253 char *base_addr
= GetPixBaseAddr (pixmap
);
254 short row_bytes
= GetPixRowBytes (pixmap
);
256 if (base_addr
[y
* row_bytes
+ x
/ 8] & (1 << (~x
& 7)))
257 return PIX_MASK_DRAW
;
259 return PIX_MASK_RETAIN
;
267 GetGWorld (&old_port
, &old_gdh
);
268 SetGWorld (ximage
, NULL
);
270 GetCPixel (x
, y
, &color
);
272 SetGWorld (old_port
, old_gdh
);
273 return RGB_TO_ULONG (color
.red
>> 8, color
.green
>> 8, color
.blue
>> 8);
281 UnlockPixels (GetGWorldPixMap (ximg
));
286 mac_create_cg_image_from_image (f
, img
)
291 CGImageRef result
= NULL
;
298 mask
= XCreatePixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
299 img
->width
, img
->height
, 1);
306 GetGWorld (&old_port
, &old_gdh
);
307 SetGWorld (mask
, NULL
);
308 BackColor (blackColor
); /* Don't mask. */
309 SetRect (&r
, 0, 0, img
->width
, img
->height
);
311 SetGWorld (old_port
, old_gdh
);
316 CreateCGImageFromPixMaps (GetGWorldPixMap (img
->pixmap
),
317 GetGWorldPixMap (mask
), &result
);
318 if (mask
!= img
->mask
)
319 XFreePixmap (FRAME_X_DISPLAY (f
), mask
);
325 #endif /* USE_CG_DRAWING */
329 /* Functions to access the contents of a bitmap, given an id. */
332 x_bitmap_height (f
, id
)
336 return FRAME_X_DISPLAY_INFO (f
)->bitmaps
[id
- 1].height
;
340 x_bitmap_width (f
, id
)
344 return FRAME_X_DISPLAY_INFO (f
)->bitmaps
[id
- 1].width
;
347 #if defined (HAVE_X_WINDOWS) || defined (HAVE_NTGUI)
349 x_bitmap_pixmap (f
, id
)
353 return (int) FRAME_X_DISPLAY_INFO (f
)->bitmaps
[id
- 1].pixmap
;
357 #ifdef HAVE_X_WINDOWS
359 x_bitmap_mask (f
, id
)
363 return FRAME_X_DISPLAY_INFO (f
)->bitmaps
[id
- 1].mask
;
367 /* Allocate a new bitmap record. Returns index of new record. */
370 x_allocate_bitmap_record (f
)
373 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
376 if (dpyinfo
->bitmaps
== NULL
)
378 dpyinfo
->bitmaps_size
= 10;
380 = (Bitmap_Record
*) xmalloc (dpyinfo
->bitmaps_size
* sizeof (Bitmap_Record
));
381 dpyinfo
->bitmaps_last
= 1;
385 if (dpyinfo
->bitmaps_last
< dpyinfo
->bitmaps_size
)
386 return ++dpyinfo
->bitmaps_last
;
388 for (i
= 0; i
< dpyinfo
->bitmaps_size
; ++i
)
389 if (dpyinfo
->bitmaps
[i
].refcount
== 0)
392 dpyinfo
->bitmaps_size
*= 2;
394 = (Bitmap_Record
*) xrealloc (dpyinfo
->bitmaps
,
395 dpyinfo
->bitmaps_size
* sizeof (Bitmap_Record
));
396 return ++dpyinfo
->bitmaps_last
;
399 /* Add one reference to the reference count of the bitmap with id ID. */
402 x_reference_bitmap (f
, id
)
406 ++FRAME_X_DISPLAY_INFO (f
)->bitmaps
[id
- 1].refcount
;
409 /* Create a bitmap for frame F from a HEIGHT x WIDTH array of bits at BITS. */
412 x_create_bitmap_from_data (f
, bits
, width
, height
)
415 unsigned int width
, height
;
417 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
420 #ifdef HAVE_X_WINDOWS
422 bitmap
= XCreateBitmapFromData (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
423 bits
, width
, height
);
426 #endif /* HAVE_X_WINDOWS */
430 bitmap
= CreateBitmap (width
, height
,
431 FRAME_X_DISPLAY_INFO (XFRAME (frame
))->n_planes
,
432 FRAME_X_DISPLAY_INFO (XFRAME (frame
))->n_cbits
,
436 #endif /* HAVE_NTGUI */
439 /* MAC_TODO: for now fail if width is not mod 16 (toolbox requires it) */
444 id
= x_allocate_bitmap_record (f
);
446 dpyinfo
->bitmaps
[id
- 1].bitmap_data
= (char *) xmalloc (height
* width
);
447 bcopy (bits
, dpyinfo
->bitmaps
[id
- 1].bitmap_data
, height
* width
);
450 dpyinfo
->bitmaps
[id
- 1].file
= NULL
;
451 dpyinfo
->bitmaps
[id
- 1].height
= height
;
452 dpyinfo
->bitmaps
[id
- 1].width
= width
;
453 dpyinfo
->bitmaps
[id
- 1].refcount
= 1;
455 #ifdef HAVE_X_WINDOWS
456 dpyinfo
->bitmaps
[id
- 1].pixmap
= bitmap
;
457 dpyinfo
->bitmaps
[id
- 1].have_mask
= 0;
458 dpyinfo
->bitmaps
[id
- 1].depth
= 1;
459 #endif /* HAVE_X_WINDOWS */
462 dpyinfo
->bitmaps
[id
- 1].pixmap
= bitmap
;
463 dpyinfo
->bitmaps
[id
- 1].hinst
= NULL
;
464 dpyinfo
->bitmaps
[id
- 1].depth
= 1;
465 #endif /* HAVE_NTGUI */
470 /* Create bitmap from file FILE for frame F. */
473 x_create_bitmap_from_file (f
, file
)
478 return -1; /* MAC_TODO : bitmap support */
482 return -1; /* W32_TODO : bitmap support */
483 #endif /* HAVE_NTGUI */
485 #ifdef HAVE_X_WINDOWS
486 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
487 unsigned int width
, height
;
489 int xhot
, yhot
, result
, id
;
494 /* Look for an existing bitmap with the same name. */
495 for (id
= 0; id
< dpyinfo
->bitmaps_last
; ++id
)
497 if (dpyinfo
->bitmaps
[id
].refcount
498 && dpyinfo
->bitmaps
[id
].file
499 && !strcmp (dpyinfo
->bitmaps
[id
].file
, (char *) SDATA (file
)))
501 ++dpyinfo
->bitmaps
[id
].refcount
;
506 /* Search bitmap-file-path for the file, if appropriate. */
507 fd
= openp (Vx_bitmap_file_path
, file
, Qnil
, &found
, Qnil
);
512 filename
= (char *) SDATA (found
);
514 result
= XReadBitmapFile (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
515 filename
, &width
, &height
, &bitmap
, &xhot
, &yhot
);
516 if (result
!= BitmapSuccess
)
519 id
= x_allocate_bitmap_record (f
);
520 dpyinfo
->bitmaps
[id
- 1].pixmap
= bitmap
;
521 dpyinfo
->bitmaps
[id
- 1].have_mask
= 0;
522 dpyinfo
->bitmaps
[id
- 1].refcount
= 1;
523 dpyinfo
->bitmaps
[id
- 1].file
= (char *) xmalloc (SBYTES (file
) + 1);
524 dpyinfo
->bitmaps
[id
- 1].depth
= 1;
525 dpyinfo
->bitmaps
[id
- 1].height
= height
;
526 dpyinfo
->bitmaps
[id
- 1].width
= width
;
527 strcpy (dpyinfo
->bitmaps
[id
- 1].file
, SDATA (file
));
530 #endif /* HAVE_X_WINDOWS */
536 Free_Bitmap_Record (dpyinfo
, bm
)
537 Display_Info
*dpyinfo
;
540 #ifdef HAVE_X_WINDOWS
541 XFreePixmap (dpyinfo
->display
, bm
->pixmap
);
543 XFreePixmap (dpyinfo
->display
, bm
->mask
);
544 #endif /* HAVE_X_WINDOWS */
547 DeleteObject (bm
->pixmap
);
548 #endif /* HAVE_NTGUI */
551 xfree (bm
->bitmap_data
); /* Added ++kfs */
552 bm
->bitmap_data
= NULL
;
562 /* Remove reference to bitmap with id number ID. */
565 x_destroy_bitmap (f
, id
)
569 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
573 Bitmap_Record
*bm
= &dpyinfo
->bitmaps
[id
- 1];
575 if (--bm
->refcount
== 0)
578 Free_Bitmap_Record (dpyinfo
, bm
);
584 /* Free all the bitmaps for the display specified by DPYINFO. */
587 x_destroy_all_bitmaps (dpyinfo
)
588 Display_Info
*dpyinfo
;
591 Bitmap_Record
*bm
= dpyinfo
->bitmaps
;
593 for (i
= 0; i
< dpyinfo
->bitmaps_last
; i
++, bm
++)
594 if (bm
->refcount
> 0)
595 Free_Bitmap_Record (dpyinfo
, bm
);
597 dpyinfo
->bitmaps_last
= 0;
601 #ifdef HAVE_X_WINDOWS
603 /* Useful functions defined in the section
604 `Image type independent image structures' below. */
606 static unsigned long four_corners_best
P_ ((XImagePtr ximg
, unsigned long width
,
607 unsigned long height
));
609 static int x_create_x_image_and_pixmap
P_ ((struct frame
*f
, int width
, int height
,
610 int depth
, XImagePtr
*ximg
,
613 static void x_destroy_x_image
P_ ((XImagePtr ximg
));
616 /* Create a mask of a bitmap. Note is this not a perfect mask.
617 It's nicer with some borders in this context */
620 x_create_bitmap_mask (f
, id
)
625 XImagePtr ximg
, mask_img
;
626 unsigned long width
, height
;
629 unsigned long x
, y
, xp
, xm
, yp
, ym
;
632 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
637 pixmap
= x_bitmap_pixmap (f
, id
);
638 width
= x_bitmap_width (f
, id
);
639 height
= x_bitmap_height (f
, id
);
642 ximg
= XGetImage (FRAME_X_DISPLAY (f
), pixmap
, 0, 0, width
, height
,
651 result
= x_create_x_image_and_pixmap (f
, width
, height
, 1, &mask_img
, &mask
);
656 XDestroyImage (ximg
);
660 bg
= four_corners_best (ximg
, width
, height
);
662 for (y
= 0; y
< ximg
->height
; ++y
)
664 for (x
= 0; x
< ximg
->width
; ++x
)
666 xp
= x
!= ximg
->width
- 1 ? x
+ 1 : 0;
667 xm
= x
!= 0 ? x
- 1 : ximg
->width
- 1;
668 yp
= y
!= ximg
->height
- 1 ? y
+ 1 : 0;
669 ym
= y
!= 0 ? y
- 1 : ximg
->height
- 1;
670 if (XGetPixel (ximg
, x
, y
) == bg
671 && XGetPixel (ximg
, x
, yp
) == bg
672 && XGetPixel (ximg
, x
, ym
) == bg
673 && XGetPixel (ximg
, xp
, y
) == bg
674 && XGetPixel (ximg
, xp
, yp
) == bg
675 && XGetPixel (ximg
, xp
, ym
) == bg
676 && XGetPixel (ximg
, xm
, y
) == bg
677 && XGetPixel (ximg
, xm
, yp
) == bg
678 && XGetPixel (ximg
, xm
, ym
) == bg
)
679 XPutPixel (mask_img
, x
, y
, 0);
681 XPutPixel (mask_img
, x
, y
, 1);
685 xassert (interrupt_input_blocked
);
686 gc
= XCreateGC (FRAME_X_DISPLAY (f
), mask
, 0, NULL
);
687 XPutImage (FRAME_X_DISPLAY (f
), mask
, gc
, mask_img
, 0, 0, 0, 0,
689 XFreeGC (FRAME_X_DISPLAY (f
), gc
);
691 dpyinfo
->bitmaps
[id
- 1].have_mask
= 1;
692 dpyinfo
->bitmaps
[id
- 1].mask
= mask
;
694 XDestroyImage (ximg
);
695 x_destroy_x_image (mask_img
);
700 #endif /* HAVE_X_WINDOWS */
703 /***********************************************************************
705 ***********************************************************************/
707 /* Value is the number of elements of vector VECTOR. */
709 #define DIM(VECTOR) (sizeof (VECTOR) / sizeof *(VECTOR))
711 /* List of supported image types. Use define_image_type to add new
712 types. Use lookup_image_type to find a type for a given symbol. */
714 static struct image_type
*image_types
;
716 /* A list of symbols, one for each supported image type. */
718 Lisp_Object Vimage_types
;
720 /* An alist of image types and libraries that implement the type. */
722 Lisp_Object Vimage_library_alist
;
724 /* Cache for delayed-loading image types. */
726 static Lisp_Object Vimage_type_cache
;
728 /* The symbol `xbm' which is used as the type symbol for XBM images. */
734 extern Lisp_Object QCwidth
, QCheight
, QCforeground
, QCbackground
, QCfile
;
735 extern Lisp_Object QCdata
, QCtype
;
736 extern Lisp_Object Qcenter
;
737 Lisp_Object QCascent
, QCmargin
, QCrelief
;
738 Lisp_Object QCconversion
, QCcolor_symbols
, QCheuristic_mask
;
739 Lisp_Object QCindex
, QCmatrix
, QCcolor_adjustment
, QCmask
;
743 Lisp_Object Qlaplace
, Qemboss
, Qedge_detection
, Qheuristic
;
745 /* Time in seconds after which images should be removed from the cache
748 Lisp_Object Vimage_cache_eviction_delay
;
750 /* Function prototypes. */
752 static Lisp_Object define_image_type
P_ ((struct image_type
*type
, int loaded
));
753 static struct image_type
*lookup_image_type
P_ ((Lisp_Object symbol
));
754 static void image_error
P_ ((char *format
, Lisp_Object
, Lisp_Object
));
755 static void x_laplace
P_ ((struct frame
*, struct image
*));
756 static void x_emboss
P_ ((struct frame
*, struct image
*));
757 static int x_build_heuristic_mask
P_ ((struct frame
*, struct image
*,
760 #define CACHE_IMAGE_TYPE(type, status) \
761 do { Vimage_type_cache = Fcons (Fcons (type, status), Vimage_type_cache); } while (0)
763 #define ADD_IMAGE_TYPE(type) \
764 do { Vimage_types = Fcons (type, Vimage_types); } while (0)
766 /* Define a new image type from TYPE. This adds a copy of TYPE to
767 image_types and caches the loading status of TYPE. */
770 define_image_type (type
, loaded
)
771 struct image_type
*type
;
780 /* Make a copy of TYPE to avoid a bus error in a dumped Emacs.
781 The initialized data segment is read-only. */
782 struct image_type
*p
= (struct image_type
*) xmalloc (sizeof *p
);
783 bcopy (type
, p
, sizeof *p
);
784 p
->next
= image_types
;
789 CACHE_IMAGE_TYPE (*type
->type
, success
);
794 /* Look up image type SYMBOL, and return a pointer to its image_type
795 structure. Value is null if SYMBOL is not a known image type. */
797 static INLINE
struct image_type
*
798 lookup_image_type (symbol
)
801 struct image_type
*type
;
803 /* We must initialize the image-type if it hasn't been already. */
804 if (NILP (Finit_image_library (symbol
, Vimage_library_alist
)))
805 return 0; /* unimplemented */
807 for (type
= image_types
; type
; type
= type
->next
)
808 if (EQ (symbol
, *type
->type
))
815 /* Value is non-zero if OBJECT is a valid Lisp image specification. A
816 valid image specification is a list whose car is the symbol
817 `image', and whose rest is a property list. The property list must
818 contain a value for key `:type'. That value must be the name of a
819 supported image type. The rest of the property list depends on the
823 valid_image_p (object
)
832 for (tem
= XCDR (object
); CONSP (tem
); tem
= XCDR (tem
))
833 if (EQ (XCAR (tem
), QCtype
))
836 if (CONSP (tem
) && SYMBOLP (XCAR (tem
)))
838 struct image_type
*type
;
839 type
= lookup_image_type (XCAR (tem
));
841 valid_p
= type
->valid_p (object
);
852 /* Log error message with format string FORMAT and argument ARG.
853 Signaling an error, e.g. when an image cannot be loaded, is not a
854 good idea because this would interrupt redisplay, and the error
855 message display would lead to another redisplay. This function
856 therefore simply displays a message. */
859 image_error (format
, arg1
, arg2
)
861 Lisp_Object arg1
, arg2
;
863 add_to_log (format
, arg1
, arg2
);
868 /***********************************************************************
870 ***********************************************************************/
872 enum image_value_type
874 IMAGE_DONT_CHECK_VALUE_TYPE
,
876 IMAGE_STRING_OR_NIL_VALUE
,
878 IMAGE_POSITIVE_INTEGER_VALUE
,
879 IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
,
880 IMAGE_NON_NEGATIVE_INTEGER_VALUE
,
883 IMAGE_FUNCTION_VALUE
,
888 /* Structure used when parsing image specifications. */
892 /* Name of keyword. */
895 /* The type of value allowed. */
896 enum image_value_type type
;
898 /* Non-zero means key must be present. */
901 /* Used to recognize duplicate keywords in a property list. */
904 /* The value that was found. */
909 static int parse_image_spec
P_ ((Lisp_Object
, struct image_keyword
*,
911 static Lisp_Object image_spec_value
P_ ((Lisp_Object
, Lisp_Object
, int *));
914 /* Parse image spec SPEC according to KEYWORDS. A valid image spec
915 has the format (image KEYWORD VALUE ...). One of the keyword/
916 value pairs must be `:type TYPE'. KEYWORDS is a vector of
917 image_keywords structures of size NKEYWORDS describing other
918 allowed keyword/value pairs. Value is non-zero if SPEC is valid. */
921 parse_image_spec (spec
, keywords
, nkeywords
, type
)
923 struct image_keyword
*keywords
;
934 while (CONSP (plist
))
936 Lisp_Object key
, value
;
938 /* First element of a pair must be a symbol. */
940 plist
= XCDR (plist
);
944 /* There must follow a value. */
947 value
= XCAR (plist
);
948 plist
= XCDR (plist
);
950 /* Find key in KEYWORDS. Error if not found. */
951 for (i
= 0; i
< nkeywords
; ++i
)
952 if (strcmp (keywords
[i
].name
, SDATA (SYMBOL_NAME (key
))) == 0)
958 /* Record that we recognized the keyword. If a keywords
959 was found more than once, it's an error. */
960 keywords
[i
].value
= value
;
963 if (keywords
[i
].count
> 1)
966 /* Check type of value against allowed type. */
967 switch (keywords
[i
].type
)
969 case IMAGE_STRING_VALUE
:
970 if (!STRINGP (value
))
974 case IMAGE_STRING_OR_NIL_VALUE
:
975 if (!STRINGP (value
) && !NILP (value
))
979 case IMAGE_SYMBOL_VALUE
:
980 if (!SYMBOLP (value
))
984 case IMAGE_POSITIVE_INTEGER_VALUE
:
985 if (!INTEGERP (value
) || XINT (value
) <= 0)
989 case IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
:
990 if (INTEGERP (value
) && XINT (value
) >= 0)
993 && INTEGERP (XCAR (value
)) && INTEGERP (XCDR (value
))
994 && XINT (XCAR (value
)) >= 0 && XINT (XCDR (value
)) >= 0)
998 case IMAGE_ASCENT_VALUE
:
999 if (SYMBOLP (value
) && EQ (value
, Qcenter
))
1001 else if (INTEGERP (value
)
1002 && XINT (value
) >= 0
1003 && XINT (value
) <= 100)
1007 case IMAGE_NON_NEGATIVE_INTEGER_VALUE
:
1008 if (!INTEGERP (value
) || XINT (value
) < 0)
1012 case IMAGE_DONT_CHECK_VALUE_TYPE
:
1015 case IMAGE_FUNCTION_VALUE
:
1016 value
= indirect_function (value
);
1018 || COMPILEDP (value
)
1019 || (CONSP (value
) && EQ (XCAR (value
), Qlambda
)))
1023 case IMAGE_NUMBER_VALUE
:
1024 if (!INTEGERP (value
) && !FLOATP (value
))
1028 case IMAGE_INTEGER_VALUE
:
1029 if (!INTEGERP (value
))
1033 case IMAGE_BOOL_VALUE
:
1034 if (!NILP (value
) && !EQ (value
, Qt
))
1043 if (EQ (key
, QCtype
) && !EQ (type
, value
))
1047 /* Check that all mandatory fields are present. */
1048 for (i
= 0; i
< nkeywords
; ++i
)
1049 if (keywords
[i
].mandatory_p
&& keywords
[i
].count
== 0)
1052 return NILP (plist
);
1056 /* Return the value of KEY in image specification SPEC. Value is nil
1057 if KEY is not present in SPEC. if FOUND is not null, set *FOUND
1058 to 1 if KEY was found in SPEC, set it to 0 otherwise. */
1061 image_spec_value (spec
, key
, found
)
1062 Lisp_Object spec
, key
;
1067 xassert (valid_image_p (spec
));
1069 for (tail
= XCDR (spec
);
1070 CONSP (tail
) && CONSP (XCDR (tail
));
1071 tail
= XCDR (XCDR (tail
)))
1073 if (EQ (XCAR (tail
), key
))
1077 return XCAR (XCDR (tail
));
1087 DEFUN ("image-size", Fimage_size
, Simage_size
, 1, 3, 0,
1088 doc
: /* Return the size of image SPEC as pair (WIDTH . HEIGHT).
1089 PIXELS non-nil means return the size in pixels, otherwise return the
1090 size in canonical character units.
1091 FRAME is the frame on which the image will be displayed. FRAME nil
1092 or omitted means use the selected frame. */)
1093 (spec
, pixels
, frame
)
1094 Lisp_Object spec
, pixels
, frame
;
1099 if (valid_image_p (spec
))
1101 struct frame
*f
= check_x_frame (frame
);
1102 int id
= lookup_image (f
, spec
);
1103 struct image
*img
= IMAGE_FROM_ID (f
, id
);
1104 int width
= img
->width
+ 2 * img
->hmargin
;
1105 int height
= img
->height
+ 2 * img
->vmargin
;
1108 size
= Fcons (make_float ((double) width
/ FRAME_COLUMN_WIDTH (f
)),
1109 make_float ((double) height
/ FRAME_LINE_HEIGHT (f
)));
1111 size
= Fcons (make_number (width
), make_number (height
));
1114 error ("Invalid image specification");
1120 DEFUN ("image-mask-p", Fimage_mask_p
, Simage_mask_p
, 1, 2, 0,
1121 doc
: /* Return t if image SPEC has a mask bitmap.
1122 FRAME is the frame on which the image will be displayed. FRAME nil
1123 or omitted means use the selected frame. */)
1125 Lisp_Object spec
, frame
;
1130 if (valid_image_p (spec
))
1132 struct frame
*f
= check_x_frame (frame
);
1133 int id
= lookup_image (f
, spec
);
1134 struct image
*img
= IMAGE_FROM_ID (f
, id
);
1139 error ("Invalid image specification");
1145 /***********************************************************************
1146 Image type independent image structures
1147 ***********************************************************************/
1149 static struct image
*make_image
P_ ((Lisp_Object spec
, unsigned hash
));
1150 static void free_image
P_ ((struct frame
*f
, struct image
*img
));
1151 static int check_image_size
P_ ((struct frame
*f
, int width
, int height
));
1153 #define MAX_IMAGE_SIZE 6.0
1154 Lisp_Object Vmax_image_size
;
1156 /* Allocate and return a new image structure for image specification
1157 SPEC. SPEC has a hash value of HASH. */
1159 static struct image
*
1160 make_image (spec
, hash
)
1164 struct image
*img
= (struct image
*) xmalloc (sizeof *img
);
1166 xassert (valid_image_p (spec
));
1167 bzero (img
, sizeof *img
);
1168 img
->type
= lookup_image_type (image_spec_value (spec
, QCtype
, NULL
));
1169 xassert (img
->type
!= NULL
);
1171 img
->data
.lisp_val
= Qnil
;
1172 img
->ascent
= DEFAULT_IMAGE_ASCENT
;
1178 /* Free image IMG which was used on frame F, including its resources. */
1187 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
1189 /* Remove IMG from the hash table of its cache. */
1191 img
->prev
->next
= img
->next
;
1193 c
->buckets
[img
->hash
% IMAGE_CACHE_BUCKETS_SIZE
] = img
->next
;
1196 img
->next
->prev
= img
->prev
;
1198 c
->images
[img
->id
] = NULL
;
1200 /* Free resources, then free IMG. */
1201 img
->type
->free (f
, img
);
1206 /* Return 1 if the given widths and heights are valid for display;
1207 otherwise, return 0. */
1210 check_image_size (f
, width
, height
)
1217 if (width
<= 0 || height
<= 0)
1220 if (INTEGERP (Vmax_image_size
))
1221 w
= h
= XINT (Vmax_image_size
);
1222 else if (FLOATP (Vmax_image_size
))
1226 w
= FRAME_PIXEL_WIDTH (f
);
1227 h
= FRAME_PIXEL_HEIGHT (f
);
1230 w
= h
= 1024; /* Arbitrary size for unknown frame. */
1231 w
= (int) (XFLOAT_DATA (Vmax_image_size
) * w
);
1232 h
= (int) (XFLOAT_DATA (Vmax_image_size
) * h
);
1237 return (width
<= w
&& height
<= h
);
1240 /* Prepare image IMG for display on frame F. Must be called before
1241 drawing an image. */
1244 prepare_image_for_display (f
, img
)
1250 /* We're about to display IMG, so set its timestamp to `now'. */
1252 img
->timestamp
= EMACS_SECS (t
);
1254 /* If IMG doesn't have a pixmap yet, load it now, using the image
1255 type dependent loader function. */
1256 if (img
->pixmap
== NO_PIXMAP
&& !img
->load_failed_p
)
1257 img
->load_failed_p
= img
->type
->load (f
, img
) == 0;
1259 #if defined (MAC_OS) && USE_CG_DRAWING
1260 if (!img
->load_failed_p
&& img
->data
.ptr_val
== NULL
)
1262 img
->data
.ptr_val
= mac_create_cg_image_from_image (f
, img
);
1263 if (img
->data
.ptr_val
== NULL
)
1265 img
->load_failed_p
= 1;
1266 img
->type
->free (f
, img
);
1273 /* Value is the number of pixels for the ascent of image IMG when
1274 drawn in face FACE. */
1277 image_ascent (img
, face
, slice
)
1280 struct glyph_slice
*slice
;
1285 if (slice
->height
== img
->height
)
1286 height
= img
->height
+ img
->vmargin
;
1287 else if (slice
->y
== 0)
1288 height
= slice
->height
+ img
->vmargin
;
1290 height
= slice
->height
;
1292 if (img
->ascent
== CENTERED_IMAGE_ASCENT
)
1297 /* W32 specific version. Why?. ++kfs */
1298 ascent
= height
/ 2 - (FONT_DESCENT(face
->font
)
1299 - FONT_BASE(face
->font
)) / 2;
1301 /* This expression is arranged so that if the image can't be
1302 exactly centered, it will be moved slightly up. This is
1303 because a typical font is `top-heavy' (due to the presence
1304 uppercase letters), so the image placement should err towards
1305 being top-heavy too. It also just generally looks better. */
1306 ascent
= (height
+ face
->font
->ascent
- face
->font
->descent
+ 1) / 2;
1307 #endif /* HAVE_NTGUI */
1310 ascent
= height
/ 2;
1313 ascent
= (int) (height
* img
->ascent
/ 100.0);
1319 /* Image background colors. */
1321 /* Find the "best" corner color of a bitmap.
1322 On W32, XIMG is assumed to a device context with the bitmap selected. */
1324 static RGB_PIXEL_COLOR
1325 four_corners_best (ximg
, width
, height
)
1326 XImagePtr_or_DC ximg
;
1327 unsigned long width
, height
;
1329 RGB_PIXEL_COLOR corners
[4], best
;
1332 /* Get the colors at the corners of ximg. */
1333 corners
[0] = GET_PIXEL (ximg
, 0, 0);
1334 corners
[1] = GET_PIXEL (ximg
, width
- 1, 0);
1335 corners
[2] = GET_PIXEL (ximg
, width
- 1, height
- 1);
1336 corners
[3] = GET_PIXEL (ximg
, 0, height
- 1);
1338 /* Choose the most frequently found color as background. */
1339 for (i
= best_count
= 0; i
< 4; ++i
)
1343 for (j
= n
= 0; j
< 4; ++j
)
1344 if (corners
[i
] == corners
[j
])
1348 best
= corners
[i
], best_count
= n
;
1354 /* Portability macros */
1358 #define Destroy_Image(img_dc, prev) \
1359 do { SelectObject (img_dc, prev); DeleteDC (img_dc); } while (0)
1361 #define Free_Pixmap(display, pixmap) \
1362 DeleteObject (pixmap)
1366 #define Destroy_Image(ximg, dummy) \
1367 XDestroyImage (ximg)
1369 #define Free_Pixmap(display, pixmap) \
1370 XFreePixmap (display, pixmap)
1372 #endif /* HAVE_NTGUI */
1375 /* Return the `background' field of IMG. If IMG doesn't have one yet,
1376 it is guessed heuristically. If non-zero, XIMG is an existing
1377 XImage object (or device context with the image selected on W32) to
1378 use for the heuristic. */
1381 image_background (img
, f
, ximg
)
1384 XImagePtr_or_DC ximg
;
1386 if (! img
->background_valid
)
1387 /* IMG doesn't have a background yet, try to guess a reasonable value. */
1389 int free_ximg
= !ximg
;
1392 #endif /* HAVE_NTGUI */
1397 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
1398 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
1400 HDC frame_dc
= get_frame_dc (f
);
1401 ximg
= CreateCompatibleDC (frame_dc
);
1402 release_frame_dc (f
, frame_dc
);
1403 prev
= SelectObject (ximg
, img
->pixmap
);
1404 #endif /* !HAVE_NTGUI */
1407 img
->background
= four_corners_best (ximg
, img
->width
, img
->height
);
1410 Destroy_Image (ximg
, prev
);
1412 img
->background_valid
= 1;
1415 return img
->background
;
1418 /* Return the `background_transparent' field of IMG. If IMG doesn't
1419 have one yet, it is guessed heuristically. If non-zero, MASK is an
1420 existing XImage object to use for the heuristic. */
1423 image_background_transparent (img
, f
, mask
)
1426 XImagePtr_or_DC mask
;
1428 if (! img
->background_transparent_valid
)
1429 /* IMG doesn't have a background yet, try to guess a reasonable value. */
1433 int free_mask
= !mask
;
1436 #endif /* HAVE_NTGUI */
1441 mask
= XGetImage (FRAME_X_DISPLAY (f
), img
->mask
,
1442 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
1444 HDC frame_dc
= get_frame_dc (f
);
1445 mask
= CreateCompatibleDC (frame_dc
);
1446 release_frame_dc (f
, frame_dc
);
1447 prev
= SelectObject (mask
, img
->mask
);
1448 #endif /* HAVE_NTGUI */
1451 img
->background_transparent
1452 = (four_corners_best (mask
, img
->width
, img
->height
) == PIX_MASK_RETAIN
);
1455 Destroy_Image (mask
, prev
);
1458 img
->background_transparent
= 0;
1460 img
->background_transparent_valid
= 1;
1463 return img
->background_transparent
;
1467 /***********************************************************************
1468 Helper functions for X image types
1469 ***********************************************************************/
1471 static void x_clear_image_1
P_ ((struct frame
*, struct image
*, int,
1473 static void x_clear_image
P_ ((struct frame
*f
, struct image
*img
));
1474 static unsigned long x_alloc_image_color
P_ ((struct frame
*f
,
1476 Lisp_Object color_name
,
1477 unsigned long dflt
));
1480 /* Clear X resources of image IMG on frame F. PIXMAP_P non-zero means
1481 free the pixmap if any. MASK_P non-zero means clear the mask
1482 pixmap if any. COLORS_P non-zero means free colors allocated for
1483 the image, if any. */
1486 x_clear_image_1 (f
, img
, pixmap_p
, mask_p
, colors_p
)
1489 int pixmap_p
, mask_p
, colors_p
;
1491 if (pixmap_p
&& img
->pixmap
)
1493 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->pixmap
);
1494 img
->pixmap
= NO_PIXMAP
;
1495 img
->background_valid
= 0;
1498 if (mask_p
&& img
->mask
)
1500 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
1501 img
->mask
= NO_PIXMAP
;
1502 img
->background_transparent_valid
= 0;
1505 if (colors_p
&& img
->ncolors
)
1507 /* MAC_TODO: color table support. */
1508 /* W32_TODO: color table support. */
1509 #ifdef HAVE_X_WINDOWS
1510 x_free_colors (f
, img
->colors
, img
->ncolors
);
1511 #endif /* HAVE_X_WINDOWS */
1512 xfree (img
->colors
);
1517 #if defined (MAC_OS) && USE_CG_DRAWING
1518 if (img
->data
.ptr_val
)
1520 CGImageRelease (img
->data
.ptr_val
);
1521 img
->data
.ptr_val
= NULL
;
1526 /* Free X resources of image IMG which is used on frame F. */
1529 x_clear_image (f
, img
)
1534 x_clear_image_1 (f
, img
, 1, 1, 1);
1539 /* Allocate color COLOR_NAME for image IMG on frame F. If color
1540 cannot be allocated, use DFLT. Add a newly allocated color to
1541 IMG->colors, so that it can be freed again. Value is the pixel
1544 static unsigned long
1545 x_alloc_image_color (f
, img
, color_name
, dflt
)
1548 Lisp_Object color_name
;
1552 unsigned long result
;
1554 xassert (STRINGP (color_name
));
1556 if (x_defined_color (f
, SDATA (color_name
), &color
, 1))
1558 /* This isn't called frequently so we get away with simply
1559 reallocating the color vector to the needed size, here. */
1562 (unsigned long *) xrealloc (img
->colors
,
1563 img
->ncolors
* sizeof *img
->colors
);
1564 img
->colors
[img
->ncolors
- 1] = color
.pixel
;
1565 result
= color
.pixel
;
1575 /***********************************************************************
1577 ***********************************************************************/
1579 static void cache_image
P_ ((struct frame
*f
, struct image
*img
));
1580 static void postprocess_image
P_ ((struct frame
*, struct image
*));
1582 /* Return a new, initialized image cache that is allocated from the
1583 heap. Call free_image_cache to free an image cache. */
1585 struct image_cache
*
1588 struct image_cache
*c
= (struct image_cache
*) xmalloc (sizeof *c
);
1591 bzero (c
, sizeof *c
);
1593 c
->images
= (struct image
**) xmalloc (c
->size
* sizeof *c
->images
);
1594 size
= IMAGE_CACHE_BUCKETS_SIZE
* sizeof *c
->buckets
;
1595 c
->buckets
= (struct image
**) xmalloc (size
);
1596 bzero (c
->buckets
, size
);
1601 /* Free image cache of frame F. Be aware that X frames share images
1605 free_image_cache (f
)
1608 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
1613 /* Cache should not be referenced by any frame when freed. */
1614 xassert (c
->refcount
== 0);
1616 for (i
= 0; i
< c
->used
; ++i
)
1617 free_image (f
, c
->images
[i
]);
1621 FRAME_X_IMAGE_CACHE (f
) = NULL
;
1626 /* Clear image cache of frame F. FORCE_P non-zero means free all
1627 images. FORCE_P zero means clear only images that haven't been
1628 displayed for some time. Should be called from time to time to
1629 reduce the number of loaded images. If image-eviction-seconds is
1630 non-nil, this frees images in the cache which weren't displayed for
1631 at least that many seconds. */
1634 clear_image_cache (f
, force_p
)
1638 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
1640 if (c
&& INTEGERP (Vimage_cache_eviction_delay
))
1647 old
= EMACS_SECS (t
) - XFASTINT (Vimage_cache_eviction_delay
);
1649 /* Block input so that we won't be interrupted by a SIGIO
1650 while being in an inconsistent state. */
1653 for (i
= nfreed
= 0; i
< c
->used
; ++i
)
1655 struct image
*img
= c
->images
[i
];
1657 && (force_p
|| img
->timestamp
< old
))
1659 free_image (f
, img
);
1664 /* We may be clearing the image cache because, for example,
1665 Emacs was iconified for a longer period of time. In that
1666 case, current matrices may still contain references to
1667 images freed above. So, clear these matrices. */
1670 Lisp_Object tail
, frame
;
1672 FOR_EACH_FRAME (tail
, frame
)
1674 struct frame
*f
= XFRAME (frame
);
1675 if (FRAME_WINDOW_P (f
)
1676 && FRAME_X_IMAGE_CACHE (f
) == c
)
1677 clear_current_matrices (f
);
1680 ++windows_or_buffers_changed
;
1688 DEFUN ("clear-image-cache", Fclear_image_cache
, Sclear_image_cache
,
1690 doc
: /* Clear the image cache of FRAME.
1691 FRAME nil or omitted means use the selected frame.
1692 FRAME t means clear the image caches of all frames. */)
1700 FOR_EACH_FRAME (tail
, frame
)
1701 if (FRAME_WINDOW_P (XFRAME (frame
)))
1702 clear_image_cache (XFRAME (frame
), 1);
1705 clear_image_cache (check_x_frame (frame
), 1);
1711 /* Compute masks and transform image IMG on frame F, as specified
1712 by the image's specification, */
1715 postprocess_image (f
, img
)
1719 /* Manipulation of the image's mask. */
1722 Lisp_Object conversion
, spec
;
1727 /* `:heuristic-mask t'
1729 means build a mask heuristically.
1730 `:heuristic-mask (R G B)'
1731 `:mask (heuristic (R G B))'
1732 means build a mask from color (R G B) in the
1735 means remove a mask, if any. */
1737 mask
= image_spec_value (spec
, QCheuristic_mask
, NULL
);
1739 x_build_heuristic_mask (f
, img
, mask
);
1744 mask
= image_spec_value (spec
, QCmask
, &found_p
);
1746 if (EQ (mask
, Qheuristic
))
1747 x_build_heuristic_mask (f
, img
, Qt
);
1748 else if (CONSP (mask
)
1749 && EQ (XCAR (mask
), Qheuristic
))
1751 if (CONSP (XCDR (mask
)))
1752 x_build_heuristic_mask (f
, img
, XCAR (XCDR (mask
)));
1754 x_build_heuristic_mask (f
, img
, XCDR (mask
));
1756 else if (NILP (mask
) && found_p
&& img
->mask
)
1758 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
1759 img
->mask
= NO_PIXMAP
;
1764 /* Should we apply an image transformation algorithm? */
1765 conversion
= image_spec_value (spec
, QCconversion
, NULL
);
1766 if (EQ (conversion
, Qdisabled
))
1767 x_disable_image (f
, img
);
1768 else if (EQ (conversion
, Qlaplace
))
1770 else if (EQ (conversion
, Qemboss
))
1772 else if (CONSP (conversion
)
1773 && EQ (XCAR (conversion
), Qedge_detection
))
1776 tem
= XCDR (conversion
);
1778 x_edge_detection (f
, img
,
1779 Fplist_get (tem
, QCmatrix
),
1780 Fplist_get (tem
, QCcolor_adjustment
));
1786 /* Return the id of image with Lisp specification SPEC on frame F.
1787 SPEC must be a valid Lisp image specification (see valid_image_p). */
1790 lookup_image (f
, spec
)
1794 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
1798 struct gcpro gcpro1
;
1801 /* F must be a window-system frame, and SPEC must be a valid image
1803 xassert (FRAME_WINDOW_P (f
));
1804 xassert (valid_image_p (spec
));
1808 /* Look up SPEC in the hash table of the image cache. */
1809 hash
= sxhash (spec
, 0);
1810 i
= hash
% IMAGE_CACHE_BUCKETS_SIZE
;
1812 for (img
= c
->buckets
[i
]; img
; img
= img
->next
)
1813 if (img
->hash
== hash
&& !NILP (Fequal (img
->spec
, spec
)))
1816 if (img
&& img
->load_failed_p
)
1818 free_image (f
, img
);
1822 /* If not found, create a new image and cache it. */
1825 extern Lisp_Object Qpostscript
;
1828 img
= make_image (spec
, hash
);
1829 cache_image (f
, img
);
1830 img
->load_failed_p
= img
->type
->load (f
, img
) == 0;
1832 /* If we can't load the image, and we don't have a width and
1833 height, use some arbitrary width and height so that we can
1834 draw a rectangle for it. */
1835 if (img
->load_failed_p
)
1839 value
= image_spec_value (spec
, QCwidth
, NULL
);
1840 img
->width
= (INTEGERP (value
)
1841 ? XFASTINT (value
) : DEFAULT_IMAGE_WIDTH
);
1842 value
= image_spec_value (spec
, QCheight
, NULL
);
1843 img
->height
= (INTEGERP (value
)
1844 ? XFASTINT (value
) : DEFAULT_IMAGE_HEIGHT
);
1848 /* Handle image type independent image attributes
1849 `:ascent ASCENT', `:margin MARGIN', `:relief RELIEF',
1850 `:background COLOR'. */
1851 Lisp_Object ascent
, margin
, relief
, bg
;
1853 ascent
= image_spec_value (spec
, QCascent
, NULL
);
1854 if (INTEGERP (ascent
))
1855 img
->ascent
= XFASTINT (ascent
);
1856 else if (EQ (ascent
, Qcenter
))
1857 img
->ascent
= CENTERED_IMAGE_ASCENT
;
1859 margin
= image_spec_value (spec
, QCmargin
, NULL
);
1860 if (INTEGERP (margin
) && XINT (margin
) >= 0)
1861 img
->vmargin
= img
->hmargin
= XFASTINT (margin
);
1862 else if (CONSP (margin
) && INTEGERP (XCAR (margin
))
1863 && INTEGERP (XCDR (margin
)))
1865 if (XINT (XCAR (margin
)) > 0)
1866 img
->hmargin
= XFASTINT (XCAR (margin
));
1867 if (XINT (XCDR (margin
)) > 0)
1868 img
->vmargin
= XFASTINT (XCDR (margin
));
1871 relief
= image_spec_value (spec
, QCrelief
, NULL
);
1872 if (INTEGERP (relief
))
1874 img
->relief
= XINT (relief
);
1875 img
->hmargin
+= abs (img
->relief
);
1876 img
->vmargin
+= abs (img
->relief
);
1879 if (! img
->background_valid
)
1881 bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
1885 = x_alloc_image_color (f
, img
, bg
,
1886 FRAME_BACKGROUND_PIXEL (f
));
1887 img
->background_valid
= 1;
1891 /* Do image transformations and compute masks, unless we
1892 don't have the image yet. */
1893 if (!EQ (*img
->type
->type
, Qpostscript
))
1894 postprocess_image (f
, img
);
1900 /* We're using IMG, so set its timestamp to `now'. */
1901 EMACS_GET_TIME (now
);
1902 img
->timestamp
= EMACS_SECS (now
);
1906 /* Value is the image id. */
1911 /* Cache image IMG in the image cache of frame F. */
1914 cache_image (f
, img
)
1918 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
1921 /* Find a free slot in c->images. */
1922 for (i
= 0; i
< c
->used
; ++i
)
1923 if (c
->images
[i
] == NULL
)
1926 /* If no free slot found, maybe enlarge c->images. */
1927 if (i
== c
->used
&& c
->used
== c
->size
)
1930 c
->images
= (struct image
**) xrealloc (c
->images
,
1931 c
->size
* sizeof *c
->images
);
1934 /* Add IMG to c->images, and assign IMG an id. */
1940 /* Add IMG to the cache's hash table. */
1941 i
= img
->hash
% IMAGE_CACHE_BUCKETS_SIZE
;
1942 img
->next
= c
->buckets
[i
];
1944 img
->next
->prev
= img
;
1946 c
->buckets
[i
] = img
;
1950 /* Call FN on every image in the image cache of frame F. Used to mark
1951 Lisp Objects in the image cache. */
1954 forall_images_in_image_cache (f
, fn
)
1956 void (*fn
) P_ ((struct image
*img
));
1958 if (FRAME_LIVE_P (f
) && FRAME_WINDOW_P (f
))
1960 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
1964 for (i
= 0; i
< c
->used
; ++i
)
1973 /***********************************************************************
1974 X / MAC / W32 support code
1975 ***********************************************************************/
1979 /* Macro for defining functions that will be loaded from image DLLs. */
1980 #define DEF_IMGLIB_FN(func) int (FAR CDECL *fn_##func)()
1982 /* Macro for loading those image functions from the library. */
1983 #define LOAD_IMGLIB_FN(lib,func) { \
1984 fn_##func = (void *) GetProcAddress (lib, #func); \
1985 if (!fn_##func) return 0; \
1988 /* Load a DLL implementing an image type.
1989 The `image-library-alist' variable associates a symbol,
1990 identifying an image type, to a list of possible filenames.
1991 The function returns NULL if no library could be loaded for
1992 the given image type, or if the library was previously loaded;
1993 else the handle of the DLL. */
1995 w32_delayed_load (Lisp_Object libraries
, Lisp_Object type
)
1997 HMODULE library
= NULL
;
1999 if (CONSP (libraries
) && NILP (Fassq (type
, Vimage_type_cache
)))
2001 Lisp_Object dlls
= Fassq (type
, libraries
);
2004 for (dlls
= XCDR (dlls
); CONSP (dlls
); dlls
= XCDR (dlls
))
2006 CHECK_STRING_CAR (dlls
);
2007 if (library
= LoadLibrary (SDATA (XCAR (dlls
))))
2015 #endif /* HAVE_NTGUI */
2017 static int x_create_x_image_and_pixmap
P_ ((struct frame
*, int, int, int,
2018 XImagePtr
*, Pixmap
*));
2019 static void x_destroy_x_image
P_ ((XImagePtr
));
2020 static void x_put_x_image
P_ ((struct frame
*, XImagePtr
, Pixmap
, int, int));
2023 /* Create an XImage and a pixmap of size WIDTH x HEIGHT for use on
2024 frame F. Set *XIMG and *PIXMAP to the XImage and Pixmap created.
2025 Set (*XIMG)->data to a raster of WIDTH x HEIGHT pixels allocated
2026 via xmalloc. Print error messages via image_error if an error
2027 occurs. Value is non-zero if successful.
2029 On W32, a DEPTH of zero signifies a 24 bit image, otherwise DEPTH
2030 should indicate the bit depth of the image. */
2033 x_create_x_image_and_pixmap (f
, width
, height
, depth
, ximg
, pixmap
)
2035 int width
, height
, depth
;
2039 #ifdef HAVE_X_WINDOWS
2040 Display
*display
= FRAME_X_DISPLAY (f
);
2041 Window window
= FRAME_X_WINDOW (f
);
2042 Screen
*screen
= FRAME_X_SCREEN (f
);
2044 xassert (interrupt_input_blocked
);
2047 depth
= DefaultDepthOfScreen (screen
);
2048 *ximg
= XCreateImage (display
, DefaultVisualOfScreen (screen
),
2049 depth
, ZPixmap
, 0, NULL
, width
, height
,
2050 depth
> 16 ? 32 : depth
> 8 ? 16 : 8, 0);
2053 image_error ("Unable to allocate X image", Qnil
, Qnil
);
2057 /* Allocate image raster. */
2058 (*ximg
)->data
= (char *) xmalloc ((*ximg
)->bytes_per_line
* height
);
2060 /* Allocate a pixmap of the same size. */
2061 *pixmap
= XCreatePixmap (display
, window
, width
, height
, depth
);
2062 if (*pixmap
== NO_PIXMAP
)
2064 x_destroy_x_image (*ximg
);
2066 image_error ("Unable to create X pixmap", Qnil
, Qnil
);
2071 #endif /* HAVE_X_WINDOWS */
2075 BITMAPINFOHEADER
*header
;
2077 int scanline_width_bits
;
2079 int palette_colors
= 0;
2084 if (depth
!= 1 && depth
!= 4 && depth
!= 8
2085 && depth
!= 16 && depth
!= 24 && depth
!= 32)
2087 image_error ("Invalid image bit depth specified", Qnil
, Qnil
);
2091 scanline_width_bits
= width
* depth
;
2092 remainder
= scanline_width_bits
% 32;
2095 scanline_width_bits
+= 32 - remainder
;
2097 /* Bitmaps with a depth less than 16 need a palette. */
2098 /* BITMAPINFO structure already contains the first RGBQUAD. */
2100 palette_colors
= 1 << depth
- 1;
2102 *ximg
= xmalloc (sizeof (XImage
) + palette_colors
* sizeof (RGBQUAD
));
2105 image_error ("Unable to allocate memory for XImage", Qnil
, Qnil
);
2109 header
= &((*ximg
)->info
.bmiHeader
);
2110 bzero (&((*ximg
)->info
), sizeof (BITMAPINFO
));
2111 header
->biSize
= sizeof (*header
);
2112 header
->biWidth
= width
;
2113 header
->biHeight
= -height
; /* negative indicates a top-down bitmap. */
2114 header
->biPlanes
= 1;
2115 header
->biBitCount
= depth
;
2116 header
->biCompression
= BI_RGB
;
2117 header
->biClrUsed
= palette_colors
;
2119 /* TODO: fill in palette. */
2122 (*ximg
)->info
.bmiColors
[0].rgbBlue
= 0;
2123 (*ximg
)->info
.bmiColors
[0].rgbGreen
= 0;
2124 (*ximg
)->info
.bmiColors
[0].rgbRed
= 0;
2125 (*ximg
)->info
.bmiColors
[0].rgbReserved
= 0;
2126 (*ximg
)->info
.bmiColors
[1].rgbBlue
= 255;
2127 (*ximg
)->info
.bmiColors
[1].rgbGreen
= 255;
2128 (*ximg
)->info
.bmiColors
[1].rgbRed
= 255;
2129 (*ximg
)->info
.bmiColors
[1].rgbReserved
= 0;
2132 hdc
= get_frame_dc (f
);
2134 /* Create a DIBSection and raster array for the bitmap,
2135 and store its handle in *pixmap. */
2136 *pixmap
= CreateDIBSection (hdc
, &((*ximg
)->info
),
2137 (depth
< 16) ? DIB_PAL_COLORS
: DIB_RGB_COLORS
,
2138 /* casting avoids a GCC warning */
2139 (void **)&((*ximg
)->data
), NULL
, 0);
2141 /* Realize display palette and garbage all frames. */
2142 release_frame_dc (f
, hdc
);
2144 if (*pixmap
== NULL
)
2146 DWORD err
= GetLastError();
2147 Lisp_Object errcode
;
2148 /* All system errors are < 10000, so the following is safe. */
2149 XSETINT (errcode
, (int) err
);
2150 image_error ("Unable to create bitmap, error code %d", errcode
, Qnil
);
2151 x_destroy_x_image (*ximg
);
2157 #endif /* HAVE_NTGUI */
2160 Display
*display
= FRAME_X_DISPLAY (f
);
2161 Window window
= FRAME_X_WINDOW (f
);
2163 xassert (interrupt_input_blocked
);
2165 /* Allocate a pixmap of the same size. */
2166 *pixmap
= XCreatePixmap (display
, window
, width
, height
, depth
);
2167 if (*pixmap
== NO_PIXMAP
)
2170 image_error ("Unable to create X pixmap", Qnil
, Qnil
);
2174 LockPixels (GetGWorldPixMap (*pixmap
));
2182 /* Destroy XImage XIMG. Free XIMG->data. */
2185 x_destroy_x_image (ximg
)
2188 xassert (interrupt_input_blocked
);
2191 #ifdef HAVE_X_WINDOWS
2194 XDestroyImage (ximg
);
2195 #endif /* HAVE_X_WINDOWS */
2197 /* Data will be freed by DestroyObject. */
2200 #endif /* HAVE_NTGUI */
2202 XDestroyImage (ximg
);
2208 /* Put XImage XIMG into pixmap PIXMAP on frame F. WIDTH and HEIGHT
2209 are width and height of both the image and pixmap. */
2212 x_put_x_image (f
, ximg
, pixmap
, width
, height
)
2218 #ifdef HAVE_X_WINDOWS
2221 xassert (interrupt_input_blocked
);
2222 gc
= XCreateGC (FRAME_X_DISPLAY (f
), pixmap
, 0, NULL
);
2223 XPutImage (FRAME_X_DISPLAY (f
), pixmap
, gc
, ximg
, 0, 0, 0, 0, width
, height
);
2224 XFreeGC (FRAME_X_DISPLAY (f
), gc
);
2225 #endif /* HAVE_X_WINDOWS */
2228 #if 0 /* I don't think this is necessary looking at where it is used. */
2229 HDC hdc
= get_frame_dc (f
);
2230 SetDIBits (hdc
, pixmap
, 0, height
, ximg
->data
, &(ximg
->info
), DIB_RGB_COLORS
);
2231 release_frame_dc (f
, hdc
);
2233 #endif /* HAVE_NTGUI */
2236 xassert (ximg
== pixmap
);
2241 /***********************************************************************
2243 ***********************************************************************/
2245 static unsigned char *slurp_file
P_ ((char *, int *));
2248 /* Find image file FILE. Look in data-directory, then
2249 x-bitmap-file-path. Value is the encoded full name of the file
2250 found, or nil if not found. */
2253 x_find_image_file (file
)
2256 Lisp_Object file_found
, search_path
;
2257 struct gcpro gcpro1
, gcpro2
;
2261 search_path
= Fcons (Vdata_directory
, Vx_bitmap_file_path
);
2262 GCPRO2 (file_found
, search_path
);
2264 /* Try to find FILE in data-directory, then x-bitmap-file-path. */
2265 fd
= openp (search_path
, file
, Qnil
, &file_found
, Qnil
);
2271 file_found
= ENCODE_FILE (file_found
);
2280 /* Read FILE into memory. Value is a pointer to a buffer allocated
2281 with xmalloc holding FILE's contents. Value is null if an error
2282 occurred. *SIZE is set to the size of the file. */
2284 static unsigned char *
2285 slurp_file (file
, size
)
2290 unsigned char *buf
= NULL
;
2293 if (stat (file
, &st
) == 0
2294 && (fp
= fopen (file
, "rb")) != NULL
2295 && (buf
= (unsigned char *) xmalloc (st
.st_size
),
2296 fread (buf
, 1, st
.st_size
, fp
) == st
.st_size
))
2319 /***********************************************************************
2320 MAC Image Load Functions
2321 ***********************************************************************/
2323 static int image_load_quicktime
P_ ((struct frame
*, struct image
*img
,
2326 static int image_load_quartz2d
P_ ((struct frame
*, struct image
*img
, int));
2330 find_image_fsspec (specified_file
, file
, fss
)
2331 Lisp_Object specified_file
, *file
;
2337 *file
= x_find_image_file (specified_file
);
2338 if (!STRINGP (*file
))
2339 return fnfErr
; /* file or directory not found;
2340 incomplete pathname */
2341 /* Try to open the image file. */
2342 err
= AECoercePtr (TYPE_FILE_NAME
, SDATA (*file
),
2343 SBYTES (*file
), typeFSS
, &desc
);
2346 #if TARGET_API_MAC_CARBON
2347 err
= AEGetDescData (&desc
, fss
, sizeof (FSSpec
));
2349 *fss
= *(FSSpec
*)(*(desc
.dataHandle
));
2351 AEDisposeDesc (&desc
);
2357 image_load_qt_1 (f
, img
, type
, fss
, dh
)
2365 GraphicsImportComponent gi
;
2368 ImageDescriptionHandle desc_handle
;
2369 short draw_all_pixels
;
2370 Lisp_Object specified_bg
;
2375 err
= OpenADefaultComponent (GraphicsImporterComponentType
,
2379 image_error ("Cannot get importer component for `%s'", img
->spec
, Qnil
);
2384 /* read from file system spec */
2385 err
= GraphicsImportSetDataFile (gi
, fss
);
2388 image_error ("Cannot set fsspec to graphics importer for '%s'",
2395 /* read from data handle */
2396 err
= GraphicsImportSetDataHandle (gi
, dh
);
2399 image_error ("Cannot set data handle to graphics importer for `%s'",
2404 err
= GraphicsImportGetImageDescription (gi
, &desc_handle
);
2405 if (err
!= noErr
|| desc_handle
== NULL
)
2407 image_error ("Error reading `%s'", img
->spec
, Qnil
);
2410 width
= img
->width
= (*desc_handle
)->width
;
2411 height
= img
->height
= (*desc_handle
)->height
;
2412 DisposeHandle ((Handle
)desc_handle
);
2414 if (!check_image_size (f
, width
, height
))
2416 image_error ("Invalid image size", Qnil
, Qnil
);
2420 err
= GraphicsImportDoesDrawAllPixels (gi
, &draw_all_pixels
);
2422 /* Don't check the error code here. It may have an undocumented
2426 image_error ("Error reading `%s'", img
->spec
, Qnil
);
2430 if (draw_all_pixels
!= graphicsImporterDrawsAllPixels
)
2432 specified_bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
2433 if (!STRINGP (specified_bg
) ||
2434 !mac_defined_color (f
, SDATA (specified_bg
), &color
, 0))
2436 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
2437 color
.red
= RED16_FROM_ULONG (color
.pixel
);
2438 color
.green
= GREEN16_FROM_ULONG (color
.pixel
);
2439 color
.blue
= BLUE16_FROM_ULONG (color
.pixel
);
2443 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
2445 if (draw_all_pixels
!= graphicsImporterDrawsAllPixels
)
2450 GetGWorld (&old_port
, &old_gdh
);
2451 SetGWorld (ximg
, NULL
);
2452 bg_color
.red
= color
.red
;
2453 bg_color
.green
= color
.green
;
2454 bg_color
.blue
= color
.blue
;
2455 RGBBackColor (&bg_color
);
2456 #if TARGET_API_MAC_CARBON
2457 GetPortBounds (ximg
, &rect
);
2460 EraseRect (&(ximg
->portRect
));
2462 SetGWorld (old_port
, old_gdh
);
2464 GraphicsImportSetGWorld (gi
, ximg
, NULL
);
2465 GraphicsImportDraw (gi
);
2466 CloseComponent (gi
);
2468 /* Maybe fill in the background field while we have ximg handy. */
2469 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
2470 IMAGE_BACKGROUND (img
, f
, ximg
);
2472 /* Put the image into the pixmap. */
2473 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
2474 x_destroy_x_image (ximg
);
2478 CloseComponent (gi
);
2483 /* Load an image using the QuickTime Graphics Importer.
2484 Note: The alpha channel does not work for PNG images. */
2486 image_load_quicktime (f
, img
, type
)
2491 Lisp_Object specified_file
;
2492 Lisp_Object specified_data
;
2495 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
2496 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
2498 if (NILP (specified_data
))
2500 /* Read from a file */
2504 err
= find_image_fsspec (specified_file
, &file
, &fss
);
2508 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
2510 image_error ("Cannot open `%s'", file
, Qnil
);
2513 return image_load_qt_1 (f
, img
, type
, &fss
, NULL
);
2517 /* Memory source! */
2521 err
= PtrToHand (SDATA (specified_data
), &dh
, SBYTES (specified_data
));
2524 image_error ("Cannot allocate data handle for `%s'",
2528 success_p
= image_load_qt_1 (f
, img
, type
, NULL
, dh
);
2536 /* Load a PNG/JPEG image using Quartz 2D decoding routines.
2537 CGImageCreateWithPNGDataProvider is provided after Mac OS X 10.2.
2538 So don't use this function directly but determine at runtime
2539 whether it exists. */
2540 typedef CGImageRef (*CGImageCreateWithPNGDataProviderProcType
)
2541 (CGDataProviderRef
, const float [], bool, CGColorRenderingIntent
);
2542 static CGImageCreateWithPNGDataProviderProcType MyCGImageCreateWithPNGDataProvider
;
2546 init_image_func_pointer ()
2548 if (NSIsSymbolNameDefined ("_CGImageCreateWithPNGDataProvider"))
2550 MyCGImageCreateWithPNGDataProvider
2551 = (CGImageCreateWithPNGDataProviderProcType
)
2552 NSAddressOfSymbol (NSLookupAndBindSymbol
2553 ("_CGImageCreateWithPNGDataProvider"));
2556 MyCGImageCreateWithPNGDataProvider
= NULL
;
2561 image_load_quartz2d (f
, img
, png_p
)
2566 Lisp_Object file
, specified_file
;
2567 Lisp_Object specified_data
, specified_bg
;
2568 struct gcpro gcpro1
;
2569 CGDataProviderRef source
;
2573 XImagePtr ximg
= NULL
;
2574 CGContextRef context
;
2577 /* Open the file. */
2578 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
2579 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
2584 if (NILP (specified_data
))
2589 file
= x_find_image_file (specified_file
);
2590 if (!STRINGP (file
))
2592 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
2596 path
= cfstring_create_with_string (file
);
2597 url
= CFURLCreateWithFileSystemPath (NULL
, path
,
2598 kCFURLPOSIXPathStyle
, 0);
2600 source
= CGDataProviderCreateWithURL (url
);
2604 source
= CGDataProviderCreateWithData (NULL
, SDATA (specified_data
),
2605 SBYTES (specified_data
), NULL
);
2608 image
= (*MyCGImageCreateWithPNGDataProvider
) (source
, NULL
, FALSE
,
2609 kCGRenderingIntentDefault
);
2611 image
= CGImageCreateWithJPEGDataProvider (source
, NULL
, FALSE
,
2612 kCGRenderingIntentDefault
);
2614 CGDataProviderRelease (source
);
2618 image_error ("Error reading image `%s'", img
->spec
, Qnil
);
2621 width
= img
->width
= CGImageGetWidth (image
);
2622 height
= img
->height
= CGImageGetHeight (image
);
2624 if (!check_image_size (f
, width
, height
))
2626 CGImageRelease (image
);
2628 image_error ("Invalid image size", Qnil
, Qnil
);
2634 specified_bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
2635 if (!STRINGP (specified_bg
) ||
2636 !mac_defined_color (f
, SDATA (specified_bg
), &color
, 0))
2638 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
2639 color
.red
= RED16_FROM_ULONG (color
.pixel
);
2640 color
.green
= GREEN16_FROM_ULONG (color
.pixel
);
2641 color
.blue
= BLUE16_FROM_ULONG (color
.pixel
);
2645 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
2647 CGImageRelease (image
);
2651 rectangle
= CGRectMake (0, 0, width
, height
);
2652 QDBeginCGContext (ximg
, &context
);
2655 CGContextSetRGBFillColor (context
, color
.red
/ 65535.0,
2656 color
.green
/ 65535.0,
2657 color
.blue
/ 65535.0, 1.0);
2658 CGContextFillRect (context
, rectangle
);
2660 CGContextDrawImage (context
, rectangle
, image
);
2661 QDEndCGContext (ximg
, &context
);
2662 CGImageRelease (image
);
2664 /* Maybe fill in the background field while we have ximg handy. */
2665 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
2666 IMAGE_BACKGROUND (img
, f
, ximg
);
2668 /* Put the image into the pixmap. */
2669 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
2670 x_destroy_x_image (ximg
);
2679 /***********************************************************************
2681 ***********************************************************************/
2683 static int xbm_scan
P_ ((unsigned char **, unsigned char *, char *, int *));
2684 static int xbm_load
P_ ((struct frame
*f
, struct image
*img
));
2685 static int xbm_load_image
P_ ((struct frame
*f
, struct image
*img
,
2686 unsigned char *, unsigned char *));
2687 static int xbm_image_p
P_ ((Lisp_Object object
));
2688 static int xbm_read_bitmap_data
P_ ((struct frame
*f
,
2689 unsigned char *, unsigned char *,
2690 int *, int *, unsigned char **));
2691 static int xbm_file_p
P_ ((Lisp_Object
));
2694 /* Indices of image specification fields in xbm_format, below. */
2696 enum xbm_keyword_index
2714 /* Vector of image_keyword structures describing the format
2715 of valid XBM image specifications. */
2717 static struct image_keyword xbm_format
[XBM_LAST
] =
2719 {":type", IMAGE_SYMBOL_VALUE
, 1},
2720 {":file", IMAGE_STRING_VALUE
, 0},
2721 {":width", IMAGE_POSITIVE_INTEGER_VALUE
, 0},
2722 {":height", IMAGE_POSITIVE_INTEGER_VALUE
, 0},
2723 {":data", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
2724 {":foreground", IMAGE_STRING_OR_NIL_VALUE
, 0},
2725 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0},
2726 {":ascent", IMAGE_ASCENT_VALUE
, 0},
2727 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
2728 {":relief", IMAGE_INTEGER_VALUE
, 0},
2729 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
2730 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
2731 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0}
2734 /* Structure describing the image type XBM. */
2736 static struct image_type xbm_type
=
2745 /* Tokens returned from xbm_scan. */
2754 /* Return non-zero if OBJECT is a valid XBM-type image specification.
2755 A valid specification is a list starting with the symbol `image'
2756 The rest of the list is a property list which must contain an
2759 If the specification specifies a file to load, it must contain
2760 an entry `:file FILENAME' where FILENAME is a string.
2762 If the specification is for a bitmap loaded from memory it must
2763 contain `:width WIDTH', `:height HEIGHT', and `:data DATA', where
2764 WIDTH and HEIGHT are integers > 0. DATA may be:
2766 1. a string large enough to hold the bitmap data, i.e. it must
2767 have a size >= (WIDTH + 7) / 8 * HEIGHT
2769 2. a bool-vector of size >= WIDTH * HEIGHT
2771 3. a vector of strings or bool-vectors, one for each line of the
2774 4. A string containing an in-memory XBM file. WIDTH and HEIGHT
2775 may not be specified in this case because they are defined in the
2778 Both the file and data forms may contain the additional entries
2779 `:background COLOR' and `:foreground COLOR'. If not present,
2780 foreground and background of the frame on which the image is
2781 displayed is used. */
2784 xbm_image_p (object
)
2787 struct image_keyword kw
[XBM_LAST
];
2789 bcopy (xbm_format
, kw
, sizeof kw
);
2790 if (!parse_image_spec (object
, kw
, XBM_LAST
, Qxbm
))
2793 xassert (EQ (kw
[XBM_TYPE
].value
, Qxbm
));
2795 if (kw
[XBM_FILE
].count
)
2797 if (kw
[XBM_WIDTH
].count
|| kw
[XBM_HEIGHT
].count
|| kw
[XBM_DATA
].count
)
2800 else if (kw
[XBM_DATA
].count
&& xbm_file_p (kw
[XBM_DATA
].value
))
2802 /* In-memory XBM file. */
2803 if (kw
[XBM_WIDTH
].count
|| kw
[XBM_HEIGHT
].count
|| kw
[XBM_FILE
].count
)
2811 /* Entries for `:width', `:height' and `:data' must be present. */
2812 if (!kw
[XBM_WIDTH
].count
2813 || !kw
[XBM_HEIGHT
].count
2814 || !kw
[XBM_DATA
].count
)
2817 data
= kw
[XBM_DATA
].value
;
2818 width
= XFASTINT (kw
[XBM_WIDTH
].value
);
2819 height
= XFASTINT (kw
[XBM_HEIGHT
].value
);
2821 /* Check type of data, and width and height against contents of
2827 /* Number of elements of the vector must be >= height. */
2828 if (XVECTOR (data
)->size
< height
)
2831 /* Each string or bool-vector in data must be large enough
2832 for one line of the image. */
2833 for (i
= 0; i
< height
; ++i
)
2835 Lisp_Object elt
= XVECTOR (data
)->contents
[i
];
2840 < (width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
)
2843 else if (BOOL_VECTOR_P (elt
))
2845 if (XBOOL_VECTOR (elt
)->size
< width
)
2852 else if (STRINGP (data
))
2855 < (width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
* height
)
2858 else if (BOOL_VECTOR_P (data
))
2860 if (XBOOL_VECTOR (data
)->size
< width
* height
)
2871 /* Scan a bitmap file. FP is the stream to read from. Value is
2872 either an enumerator from enum xbm_token, or a character for a
2873 single-character token, or 0 at end of file. If scanning an
2874 identifier, store the lexeme of the identifier in SVAL. If
2875 scanning a number, store its value in *IVAL. */
2878 xbm_scan (s
, end
, sval
, ival
)
2879 unsigned char **s
, *end
;
2887 /* Skip white space. */
2888 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
2893 else if (isdigit (c
))
2895 int value
= 0, digit
;
2897 if (c
== '0' && *s
< end
)
2900 if (c
== 'x' || c
== 'X')
2907 else if (c
>= 'a' && c
<= 'f')
2908 digit
= c
- 'a' + 10;
2909 else if (c
>= 'A' && c
<= 'F')
2910 digit
= c
- 'A' + 10;
2913 value
= 16 * value
+ digit
;
2916 else if (isdigit (c
))
2920 && (c
= *(*s
)++, isdigit (c
)))
2921 value
= 8 * value
+ c
- '0';
2928 && (c
= *(*s
)++, isdigit (c
)))
2929 value
= 10 * value
+ c
- '0';
2937 else if (isalpha (c
) || c
== '_')
2941 && (c
= *(*s
)++, (isalnum (c
) || c
== '_')))
2948 else if (c
== '/' && **s
== '*')
2950 /* C-style comment. */
2952 while (**s
&& (**s
!= '*' || *(*s
+ 1) != '/'))
2966 /* Create a Windows bitmap from X bitmap data. */
2968 w32_create_pixmap_from_bitmap_data (int width
, int height
, char *data
)
2970 static unsigned char swap_nibble
[16]
2971 = { 0x0, 0x8, 0x4, 0xc, /* 0000 1000 0100 1100 */
2972 0x2, 0xa, 0x6, 0xe, /* 0010 1010 0110 1110 */
2973 0x1, 0x9, 0x5, 0xd, /* 0001 1001 0101 1101 */
2974 0x3, 0xb, 0x7, 0xf }; /* 0011 1011 0111 1111 */
2976 unsigned char *bits
, *p
;
2979 w1
= (width
+ 7) / 8; /* nb of 8bits elt in X bitmap */
2980 w2
= ((width
+ 15) / 16) * 2; /* nb of 16bits elt in W32 bitmap */
2981 bits
= (unsigned char *) alloca (height
* w2
);
2982 bzero (bits
, height
* w2
);
2983 for (i
= 0; i
< height
; i
++)
2986 for (j
= 0; j
< w1
; j
++)
2988 /* Bitswap XBM bytes to match how Windows does things. */
2989 unsigned char c
= *data
++;
2990 *p
++ = (unsigned char)((swap_nibble
[c
& 0xf] << 4)
2991 | (swap_nibble
[(c
>>4) & 0xf]));
2994 bmp
= CreateBitmap (width
, height
, 1, 1, (char *) bits
);
2999 static void convert_mono_to_color_image (f
, img
, foreground
, background
)
3002 COLORREF foreground
, background
;
3004 HDC hdc
, old_img_dc
, new_img_dc
;
3005 HGDIOBJ old_prev
, new_prev
;
3008 hdc
= get_frame_dc (f
);
3009 old_img_dc
= CreateCompatibleDC (hdc
);
3010 new_img_dc
= CreateCompatibleDC (hdc
);
3011 new_pixmap
= CreateCompatibleBitmap (hdc
, img
->width
, img
->height
);
3012 release_frame_dc (f
, hdc
);
3013 old_prev
= SelectObject (old_img_dc
, img
->pixmap
);
3014 new_prev
= SelectObject (new_img_dc
, new_pixmap
);
3015 SetTextColor (new_img_dc
, foreground
);
3016 SetBkColor (new_img_dc
, background
);
3018 BitBlt (new_img_dc
, 0, 0, img
->width
, img
->height
, old_img_dc
,
3021 SelectObject (old_img_dc
, old_prev
);
3022 SelectObject (new_img_dc
, new_prev
);
3023 DeleteDC (old_img_dc
);
3024 DeleteDC (new_img_dc
);
3025 DeleteObject (img
->pixmap
);
3026 if (new_pixmap
== 0)
3027 fprintf (stderr
, "Failed to convert image to color.\n");
3029 img
->pixmap
= new_pixmap
;
3032 #define XBM_BIT_SHUFFLE(b) (~(b))
3036 #define XBM_BIT_SHUFFLE(b) (b)
3038 #endif /* HAVE_NTGUI */
3042 Create_Pixmap_From_Bitmap_Data(f
, img
, data
, fg
, bg
, non_default_colors
)
3046 RGB_PIXEL_COLOR fg
, bg
;
3047 int non_default_colors
;
3051 = w32_create_pixmap_from_bitmap_data (img
->width
, img
->height
, data
);
3053 /* If colors were specified, transfer the bitmap to a color one. */
3054 if (non_default_colors
)
3055 convert_mono_to_color_image (f
, img
, fg
, bg
);
3058 = XCreatePixmapFromBitmapData (FRAME_X_DISPLAY (f
),
3061 img
->width
, img
->height
,
3063 DefaultDepthOfScreen (FRAME_X_SCREEN (f
)));
3064 #endif /* HAVE_NTGUI */
3069 /* Replacement for XReadBitmapFileData which isn't available under old
3070 X versions. CONTENTS is a pointer to a buffer to parse; END is the
3071 buffer's end. Set *WIDTH and *HEIGHT to the width and height of
3072 the image. Return in *DATA the bitmap data allocated with xmalloc.
3073 Value is non-zero if successful. DATA null means just test if
3074 CONTENTS looks like an in-memory XBM file. */
3077 xbm_read_bitmap_data (f
, contents
, end
, width
, height
, data
)
3079 unsigned char *contents
, *end
;
3080 int *width
, *height
;
3081 unsigned char **data
;
3083 unsigned char *s
= contents
;
3084 char buffer
[BUFSIZ
];
3087 int bytes_per_line
, i
, nbytes
;
3093 LA1 = xbm_scan (&s, end, buffer, &value)
3095 #define expect(TOKEN) \
3096 if (LA1 != (TOKEN)) \
3101 #define expect_ident(IDENT) \
3102 if (LA1 == XBM_TK_IDENT && strcmp (buffer, (IDENT)) == 0) \
3107 *width
= *height
= -1;
3110 LA1
= xbm_scan (&s
, end
, buffer
, &value
);
3112 /* Parse defines for width, height and hot-spots. */
3116 expect_ident ("define");
3117 expect (XBM_TK_IDENT
);
3119 if (LA1
== XBM_TK_NUMBER
);
3121 char *p
= strrchr (buffer
, '_');
3122 p
= p
? p
+ 1 : buffer
;
3123 if (strcmp (p
, "width") == 0)
3125 else if (strcmp (p
, "height") == 0)
3128 expect (XBM_TK_NUMBER
);
3131 if (!check_image_size (f
, *width
, *height
))
3133 else if (data
== NULL
)
3136 /* Parse bits. Must start with `static'. */
3137 expect_ident ("static");
3138 if (LA1
== XBM_TK_IDENT
)
3140 if (strcmp (buffer
, "unsigned") == 0)
3143 expect_ident ("char");
3145 else if (strcmp (buffer
, "short") == 0)
3149 if (*width
% 16 && *width
% 16 < 9)
3152 else if (strcmp (buffer
, "char") == 0)
3160 expect (XBM_TK_IDENT
);
3166 bytes_per_line
= (*width
+ 7) / 8 + padding_p
;
3167 nbytes
= bytes_per_line
* *height
;
3168 p
= *data
= (unsigned char *) xmalloc (nbytes
);
3172 for (i
= 0; i
< nbytes
; i
+= 2)
3175 expect (XBM_TK_NUMBER
);
3177 *p
++ = XBM_BIT_SHUFFLE (val
);
3178 if (!padding_p
|| ((i
+ 2) % bytes_per_line
))
3179 *p
++ = XBM_BIT_SHUFFLE (value
>> 8);
3181 if (LA1
== ',' || LA1
== '}')
3189 for (i
= 0; i
< nbytes
; ++i
)
3192 expect (XBM_TK_NUMBER
);
3194 *p
++ = XBM_BIT_SHUFFLE (val
);
3196 if (LA1
== ',' || LA1
== '}')
3221 /* Load XBM image IMG which will be displayed on frame F from buffer
3222 CONTENTS. END is the end of the buffer. Value is non-zero if
3226 xbm_load_image (f
, img
, contents
, end
)
3229 unsigned char *contents
, *end
;
3232 unsigned char *data
;
3235 rc
= xbm_read_bitmap_data (f
, contents
, end
, &img
->width
, &img
->height
, &data
);
3238 unsigned long foreground
= FRAME_FOREGROUND_PIXEL (f
);
3239 unsigned long background
= FRAME_BACKGROUND_PIXEL (f
);
3240 int non_default_colors
= 0;
3243 xassert (img
->width
> 0 && img
->height
> 0);
3245 /* Get foreground and background colors, maybe allocate colors. */
3246 value
= image_spec_value (img
->spec
, QCforeground
, NULL
);
3249 foreground
= x_alloc_image_color (f
, img
, value
, foreground
);
3250 non_default_colors
= 1;
3252 value
= image_spec_value (img
->spec
, QCbackground
, NULL
);
3255 background
= x_alloc_image_color (f
, img
, value
, background
);
3256 img
->background
= background
;
3257 img
->background_valid
= 1;
3258 non_default_colors
= 1;
3261 Create_Pixmap_From_Bitmap_Data (f
, img
, data
,
3262 foreground
, background
,
3263 non_default_colors
);
3266 if (img
->pixmap
== NO_PIXMAP
)
3268 x_clear_image (f
, img
);
3269 image_error ("Unable to create X pixmap for `%s'", img
->spec
, Qnil
);
3275 image_error ("Error loading XBM image `%s'", img
->spec
, Qnil
);
3281 /* Value is non-zero if DATA looks like an in-memory XBM file. */
3288 return (STRINGP (data
)
3289 && xbm_read_bitmap_data (NULL
, SDATA (data
),
3296 /* Fill image IMG which is used on frame F with pixmap data. Value is
3297 non-zero if successful. */
3305 Lisp_Object file_name
;
3307 xassert (xbm_image_p (img
->spec
));
3309 /* If IMG->spec specifies a file name, create a non-file spec from it. */
3310 file_name
= image_spec_value (img
->spec
, QCfile
, NULL
);
3311 if (STRINGP (file_name
))
3314 unsigned char *contents
;
3316 struct gcpro gcpro1
;
3318 file
= x_find_image_file (file_name
);
3320 if (!STRINGP (file
))
3322 image_error ("Cannot find image file `%s'", file_name
, Qnil
);
3327 contents
= slurp_file (SDATA (file
), &size
);
3328 if (contents
== NULL
)
3330 image_error ("Error loading XBM image `%s'", img
->spec
, Qnil
);
3335 success_p
= xbm_load_image (f
, img
, contents
, contents
+ size
);
3340 struct image_keyword fmt
[XBM_LAST
];
3342 unsigned long foreground
= FRAME_FOREGROUND_PIXEL (f
);
3343 unsigned long background
= FRAME_BACKGROUND_PIXEL (f
);
3344 int non_default_colors
= 0;
3347 int in_memory_file_p
= 0;
3349 /* See if data looks like an in-memory XBM file. */
3350 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
3351 in_memory_file_p
= xbm_file_p (data
);
3353 /* Parse the image specification. */
3354 bcopy (xbm_format
, fmt
, sizeof fmt
);
3355 parsed_p
= parse_image_spec (img
->spec
, fmt
, XBM_LAST
, Qxbm
);
3358 /* Get specified width, and height. */
3359 if (!in_memory_file_p
)
3361 img
->width
= XFASTINT (fmt
[XBM_WIDTH
].value
);
3362 img
->height
= XFASTINT (fmt
[XBM_HEIGHT
].value
);
3363 xassert (img
->width
> 0 && img
->height
> 0);
3366 /* Get foreground and background colors, maybe allocate colors. */
3367 if (fmt
[XBM_FOREGROUND
].count
3368 && STRINGP (fmt
[XBM_FOREGROUND
].value
))
3370 foreground
= x_alloc_image_color (f
, img
, fmt
[XBM_FOREGROUND
].value
,
3372 non_default_colors
= 1;
3375 if (fmt
[XBM_BACKGROUND
].count
3376 && STRINGP (fmt
[XBM_BACKGROUND
].value
))
3378 background
= x_alloc_image_color (f
, img
, fmt
[XBM_BACKGROUND
].value
,
3380 non_default_colors
= 1;
3383 if (in_memory_file_p
)
3384 success_p
= xbm_load_image (f
, img
, SDATA (data
),
3393 int nbytes
= (img
->width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
;
3395 p
= bits
= (char *) alloca (nbytes
* img
->height
);
3396 for (i
= 0; i
< img
->height
; ++i
, p
+= nbytes
)
3398 Lisp_Object line
= XVECTOR (data
)->contents
[i
];
3400 bcopy (SDATA (line
), p
, nbytes
);
3402 bcopy (XBOOL_VECTOR (line
)->data
, p
, nbytes
);
3405 else if (STRINGP (data
))
3406 bits
= SDATA (data
);
3408 bits
= XBOOL_VECTOR (data
)->data
;
3410 /* Create the pixmap. */
3412 Create_Pixmap_From_Bitmap_Data (f
, img
, bits
,
3413 foreground
, background
,
3414 non_default_colors
);
3419 image_error ("Unable to create pixmap for XBM image `%s'",
3421 x_clear_image (f
, img
);
3431 /***********************************************************************
3433 ***********************************************************************/
3435 #if defined (HAVE_XPM) || defined (MAC_OS)
3437 static int xpm_image_p
P_ ((Lisp_Object object
));
3438 static int xpm_load
P_ ((struct frame
*f
, struct image
*img
));
3439 static int xpm_valid_color_symbols_p
P_ ((Lisp_Object
));
3441 #endif /* HAVE_XPM || MAC_OS */
3445 /* Indicate to xpm.h that we don't have Xlib. */
3447 /* simx.h in xpm defines XColor and XImage differently than Emacs. */
3448 /* It also defines Display the same way as Emacs, but gcc 3.3 still barfs. */
3449 #define XColor xpm_XColor
3450 #define XImage xpm_XImage
3451 #define Display xpm_Display
3452 #define PIXEL_ALREADY_TYPEDEFED
3453 #include "X11/xpm.h"
3458 #undef PIXEL_ALREADY_TYPEDEFED
3460 #include "X11/xpm.h"
3461 #endif /* HAVE_NTGUI */
3462 #endif /* HAVE_XPM */
3464 #if defined (HAVE_XPM) || defined (MAC_OS)
3465 /* The symbol `xpm' identifying XPM-format images. */
3469 /* Indices of image specification fields in xpm_format, below. */
3471 enum xpm_keyword_index
3487 /* Vector of image_keyword structures describing the format
3488 of valid XPM image specifications. */
3490 static struct image_keyword xpm_format
[XPM_LAST
] =
3492 {":type", IMAGE_SYMBOL_VALUE
, 1},
3493 {":file", IMAGE_STRING_VALUE
, 0},
3494 {":data", IMAGE_STRING_VALUE
, 0},
3495 {":ascent", IMAGE_ASCENT_VALUE
, 0},
3496 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
3497 {":relief", IMAGE_INTEGER_VALUE
, 0},
3498 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3499 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3500 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3501 {":color-symbols", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3502 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
3505 /* Structure describing the image type XPM. */
3507 static struct image_type xpm_type
=
3516 #ifdef HAVE_X_WINDOWS
3518 /* Define ALLOC_XPM_COLORS if we can use Emacs' own color allocation
3519 functions for allocating image colors. Our own functions handle
3520 color allocation failures more gracefully than the ones on the XPM
3523 #if defined XpmAllocColor && defined XpmFreeColors && defined XpmColorClosure
3524 #define ALLOC_XPM_COLORS
3526 #endif /* HAVE_X_WINDOWS */
3528 #ifdef ALLOC_XPM_COLORS
3530 static void xpm_init_color_cache
P_ ((struct frame
*, XpmAttributes
*));
3531 static void xpm_free_color_cache
P_ ((void));
3532 static int xpm_lookup_color
P_ ((struct frame
*, char *, XColor
*));
3533 static int xpm_color_bucket
P_ ((char *));
3534 static struct xpm_cached_color
*xpm_cache_color
P_ ((struct frame
*, char *,
3537 /* An entry in a hash table used to cache color definitions of named
3538 colors. This cache is necessary to speed up XPM image loading in
3539 case we do color allocations ourselves. Without it, we would need
3540 a call to XParseColor per pixel in the image. */
3542 struct xpm_cached_color
3544 /* Next in collision chain. */
3545 struct xpm_cached_color
*next
;
3547 /* Color definition (RGB and pixel color). */
3554 /* The hash table used for the color cache, and its bucket vector
3557 #define XPM_COLOR_CACHE_BUCKETS 1001
3558 struct xpm_cached_color
**xpm_color_cache
;
3560 /* Initialize the color cache. */
3563 xpm_init_color_cache (f
, attrs
)
3565 XpmAttributes
*attrs
;
3567 size_t nbytes
= XPM_COLOR_CACHE_BUCKETS
* sizeof *xpm_color_cache
;
3568 xpm_color_cache
= (struct xpm_cached_color
**) xmalloc (nbytes
);
3569 memset (xpm_color_cache
, 0, nbytes
);
3570 init_color_table ();
3572 if (attrs
->valuemask
& XpmColorSymbols
)
3577 for (i
= 0; i
< attrs
->numsymbols
; ++i
)
3578 if (XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
3579 attrs
->colorsymbols
[i
].value
, &color
))
3581 color
.pixel
= lookup_rgb_color (f
, color
.red
, color
.green
,
3583 xpm_cache_color (f
, attrs
->colorsymbols
[i
].name
, &color
, -1);
3588 /* Free the color cache. */
3591 xpm_free_color_cache ()
3593 struct xpm_cached_color
*p
, *next
;
3596 for (i
= 0; i
< XPM_COLOR_CACHE_BUCKETS
; ++i
)
3597 for (p
= xpm_color_cache
[i
]; p
; p
= next
)
3603 xfree (xpm_color_cache
);
3604 xpm_color_cache
= NULL
;
3605 free_color_table ();
3608 /* Return the bucket index for color named COLOR_NAME in the color
3612 xpm_color_bucket (color_name
)
3618 for (s
= color_name
; *s
; ++s
)
3620 return h
%= XPM_COLOR_CACHE_BUCKETS
;
3624 /* On frame F, cache values COLOR for color with name COLOR_NAME.
3625 BUCKET, if >= 0, is a precomputed bucket index. Value is the cache
3628 static struct xpm_cached_color
*
3629 xpm_cache_color (f
, color_name
, color
, bucket
)
3636 struct xpm_cached_color
*p
;
3639 bucket
= xpm_color_bucket (color_name
);
3641 nbytes
= sizeof *p
+ strlen (color_name
);
3642 p
= (struct xpm_cached_color
*) xmalloc (nbytes
);
3643 strcpy (p
->name
, color_name
);
3645 p
->next
= xpm_color_cache
[bucket
];
3646 xpm_color_cache
[bucket
] = p
;
3650 /* Look up color COLOR_NAME for frame F in the color cache. If found,
3651 return the cached definition in *COLOR. Otherwise, make a new
3652 entry in the cache and allocate the color. Value is zero if color
3653 allocation failed. */
3656 xpm_lookup_color (f
, color_name
, color
)
3661 struct xpm_cached_color
*p
;
3662 int h
= xpm_color_bucket (color_name
);
3664 for (p
= xpm_color_cache
[h
]; p
; p
= p
->next
)
3665 if (strcmp (p
->name
, color_name
) == 0)
3670 else if (XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
3673 color
->pixel
= lookup_rgb_color (f
, color
->red
, color
->green
,
3675 p
= xpm_cache_color (f
, color_name
, color
, h
);
3677 /* You get `opaque' at least from ImageMagick converting pbm to xpm
3678 with transparency, and it's useful. */
3679 else if (strcmp ("opaque", color_name
) == 0)
3681 bzero (color
, sizeof (XColor
)); /* Is this necessary/correct? */
3682 color
->pixel
= FRAME_FOREGROUND_PIXEL (f
);
3683 p
= xpm_cache_color (f
, color_name
, color
, h
);
3690 /* Callback for allocating color COLOR_NAME. Called from the XPM lib.
3691 CLOSURE is a pointer to the frame on which we allocate the
3692 color. Return in *COLOR the allocated color. Value is non-zero
3696 xpm_alloc_color (dpy
, cmap
, color_name
, color
, closure
)
3703 return xpm_lookup_color ((struct frame
*) closure
, color_name
, color
);
3707 /* Callback for freeing NPIXELS colors contained in PIXELS. CLOSURE
3708 is a pointer to the frame on which we allocate the color. Value is
3709 non-zero if successful. */
3712 xpm_free_colors (dpy
, cmap
, pixels
, npixels
, closure
)
3722 #endif /* ALLOC_XPM_COLORS */
3727 /* XPM library details. */
3729 DEF_IMGLIB_FN (XpmFreeAttributes
);
3730 DEF_IMGLIB_FN (XpmCreateImageFromBuffer
);
3731 DEF_IMGLIB_FN (XpmReadFileToImage
);
3732 DEF_IMGLIB_FN (XImageFree
);
3735 init_xpm_functions (Lisp_Object libraries
)
3739 if (!(library
= w32_delayed_load (libraries
, Qxpm
)))
3742 LOAD_IMGLIB_FN (library
, XpmFreeAttributes
);
3743 LOAD_IMGLIB_FN (library
, XpmCreateImageFromBuffer
);
3744 LOAD_IMGLIB_FN (library
, XpmReadFileToImage
);
3745 LOAD_IMGLIB_FN (library
, XImageFree
);
3749 #endif /* HAVE_NTGUI */
3752 /* Value is non-zero if COLOR_SYMBOLS is a valid color symbols list
3753 for XPM images. Such a list must consist of conses whose car and
3757 xpm_valid_color_symbols_p (color_symbols
)
3758 Lisp_Object color_symbols
;
3760 while (CONSP (color_symbols
))
3762 Lisp_Object sym
= XCAR (color_symbols
);
3764 || !STRINGP (XCAR (sym
))
3765 || !STRINGP (XCDR (sym
)))
3767 color_symbols
= XCDR (color_symbols
);
3770 return NILP (color_symbols
);
3774 /* Value is non-zero if OBJECT is a valid XPM image specification. */
3777 xpm_image_p (object
)
3780 struct image_keyword fmt
[XPM_LAST
];
3781 bcopy (xpm_format
, fmt
, sizeof fmt
);
3782 return (parse_image_spec (object
, fmt
, XPM_LAST
, Qxpm
)
3783 /* Either `:file' or `:data' must be present. */
3784 && fmt
[XPM_FILE
].count
+ fmt
[XPM_DATA
].count
== 1
3785 /* Either no `:color-symbols' or it's a list of conses
3786 whose car and cdr are strings. */
3787 && (fmt
[XPM_COLOR_SYMBOLS
].count
== 0
3788 || xpm_valid_color_symbols_p (fmt
[XPM_COLOR_SYMBOLS
].value
)));
3791 #endif /* HAVE_XPM || MAC_OS */
3793 #if defined (HAVE_XPM) && defined (HAVE_X_WINDOWS)
3795 x_create_bitmap_from_xpm_data (f
, bits
)
3799 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
3801 XpmAttributes attrs
;
3802 Pixmap bitmap
, mask
;
3804 bzero (&attrs
, sizeof attrs
);
3806 attrs
.visual
= FRAME_X_VISUAL (f
);
3807 attrs
.colormap
= FRAME_X_COLORMAP (f
);
3808 attrs
.valuemask
|= XpmVisual
;
3809 attrs
.valuemask
|= XpmColormap
;
3811 rc
= XpmCreatePixmapFromData (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3812 bits
, &bitmap
, &mask
, &attrs
);
3813 if (rc
!= XpmSuccess
)
3815 XpmFreeAttributes (&attrs
);
3819 id
= x_allocate_bitmap_record (f
);
3820 dpyinfo
->bitmaps
[id
- 1].pixmap
= bitmap
;
3821 dpyinfo
->bitmaps
[id
- 1].have_mask
= 1;
3822 dpyinfo
->bitmaps
[id
- 1].mask
= mask
;
3823 dpyinfo
->bitmaps
[id
- 1].file
= NULL
;
3824 dpyinfo
->bitmaps
[id
- 1].height
= attrs
.height
;
3825 dpyinfo
->bitmaps
[id
- 1].width
= attrs
.width
;
3826 dpyinfo
->bitmaps
[id
- 1].depth
= attrs
.depth
;
3827 dpyinfo
->bitmaps
[id
- 1].refcount
= 1;
3829 XpmFreeAttributes (&attrs
);
3832 #endif /* defined (HAVE_XPM) && defined (HAVE_X_WINDOWS) */
3834 /* Load image IMG which will be displayed on frame F. Value is
3835 non-zero if successful. */
3845 XpmAttributes attrs
;
3846 Lisp_Object specified_file
, color_symbols
;
3849 xpm_XImage
* xpm_image
= NULL
, * xpm_mask
= NULL
;
3850 #endif /* HAVE_NTGUI */
3852 /* Configure the XPM lib. Use the visual of frame F. Allocate
3853 close colors. Return colors allocated. */
3854 bzero (&attrs
, sizeof attrs
);
3857 attrs
.visual
= FRAME_X_VISUAL (f
);
3858 attrs
.colormap
= FRAME_X_COLORMAP (f
);
3859 attrs
.valuemask
|= XpmVisual
;
3860 attrs
.valuemask
|= XpmColormap
;
3861 #endif /* HAVE_NTGUI */
3863 #ifdef ALLOC_XPM_COLORS
3864 /* Allocate colors with our own functions which handle
3865 failing color allocation more gracefully. */
3866 attrs
.color_closure
= f
;
3867 attrs
.alloc_color
= xpm_alloc_color
;
3868 attrs
.free_colors
= xpm_free_colors
;
3869 attrs
.valuemask
|= XpmAllocColor
| XpmFreeColors
| XpmColorClosure
;
3870 #else /* not ALLOC_XPM_COLORS */
3871 /* Let the XPM lib allocate colors. */
3872 attrs
.valuemask
|= XpmReturnAllocPixels
;
3873 #ifdef XpmAllocCloseColors
3874 attrs
.alloc_close_colors
= 1;
3875 attrs
.valuemask
|= XpmAllocCloseColors
;
3876 #else /* not XpmAllocCloseColors */
3877 attrs
.closeness
= 600;
3878 attrs
.valuemask
|= XpmCloseness
;
3879 #endif /* not XpmAllocCloseColors */
3880 #endif /* ALLOC_XPM_COLORS */
3881 #ifdef ALLOC_XPM_COLORS
3882 xpm_init_color_cache (f
, &attrs
);
3885 /* If image specification contains symbolic color definitions, add
3886 these to `attrs'. */
3887 color_symbols
= image_spec_value (img
->spec
, QCcolor_symbols
, NULL
);
3888 if (CONSP (color_symbols
))
3891 XpmColorSymbol
*xpm_syms
;
3894 attrs
.valuemask
|= XpmColorSymbols
;
3896 /* Count number of symbols. */
3897 attrs
.numsymbols
= 0;
3898 for (tail
= color_symbols
; CONSP (tail
); tail
= XCDR (tail
))
3901 /* Allocate an XpmColorSymbol array. */
3902 size
= attrs
.numsymbols
* sizeof *xpm_syms
;
3903 xpm_syms
= (XpmColorSymbol
*) alloca (size
);
3904 bzero (xpm_syms
, size
);
3905 attrs
.colorsymbols
= xpm_syms
;
3907 /* Fill the color symbol array. */
3908 for (tail
= color_symbols
, i
= 0;
3910 ++i
, tail
= XCDR (tail
))
3912 Lisp_Object name
= XCAR (XCAR (tail
));
3913 Lisp_Object color
= XCDR (XCAR (tail
));
3914 xpm_syms
[i
].name
= (char *) alloca (SCHARS (name
) + 1);
3915 strcpy (xpm_syms
[i
].name
, SDATA (name
));
3916 xpm_syms
[i
].value
= (char *) alloca (SCHARS (color
) + 1);
3917 strcpy (xpm_syms
[i
].value
, SDATA (color
));
3921 /* Create a pixmap for the image, either from a file, or from a
3922 string buffer containing data in the same format as an XPM file. */
3923 #ifdef ALLOC_XPM_COLORS
3924 xpm_init_color_cache (f
, &attrs
);
3927 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
3931 HDC frame_dc
= get_frame_dc (f
);
3932 hdc
= CreateCompatibleDC (frame_dc
);
3933 release_frame_dc (f
, frame_dc
);
3935 #endif /* HAVE_NTGUI */
3937 if (STRINGP (specified_file
))
3939 Lisp_Object file
= x_find_image_file (specified_file
);
3940 if (!STRINGP (file
))
3942 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
3947 /* XpmReadFileToPixmap is not available in the Windows port of
3948 libxpm. But XpmReadFileToImage almost does what we want. */
3949 rc
= fn_XpmReadFileToImage (&hdc
, SDATA (file
),
3950 &xpm_image
, &xpm_mask
,
3953 rc
= XpmReadFileToPixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3954 SDATA (file
), &img
->pixmap
, &img
->mask
,
3956 #endif /* HAVE_NTGUI */
3960 Lisp_Object buffer
= image_spec_value (img
->spec
, QCdata
, NULL
);
3962 /* XpmCreatePixmapFromBuffer is not available in the Windows port
3963 of libxpm. But XpmCreateImageFromBuffer almost does what we want. */
3964 rc
= fn_XpmCreateImageFromBuffer (&hdc
, SDATA (buffer
),
3965 &xpm_image
, &xpm_mask
,
3968 rc
= XpmCreatePixmapFromBuffer (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3970 &img
->pixmap
, &img
->mask
,
3972 #endif /* HAVE_NTGUI */
3975 if (rc
== XpmSuccess
)
3977 #if defined (COLOR_TABLE_SUPPORT) && defined (ALLOC_XPM_COLORS)
3978 img
->colors
= colors_in_color_table (&img
->ncolors
);
3979 #else /* not ALLOC_XPM_COLORS */
3983 /* W32 XPM uses XImage to wrap what W32 Emacs calls a Pixmap,
3984 plus some duplicate attributes. */
3985 if (xpm_image
&& xpm_image
->bitmap
)
3987 img
->pixmap
= xpm_image
->bitmap
;
3988 /* XImageFree in libXpm frees XImage struct without destroying
3989 the bitmap, which is what we want. */
3990 fn_XImageFree (xpm_image
);
3992 if (xpm_mask
&& xpm_mask
->bitmap
)
3994 /* The mask appears to be inverted compared with what we expect.
3995 TODO: invert our expectations. See other places where we
3996 have to invert bits because our idea of masks is backwards. */
3998 old_obj
= SelectObject (hdc
, xpm_mask
->bitmap
);
4000 PatBlt (hdc
, 0, 0, xpm_mask
->width
, xpm_mask
->height
, DSTINVERT
);
4001 SelectObject (hdc
, old_obj
);
4003 img
->mask
= xpm_mask
->bitmap
;
4004 fn_XImageFree (xpm_mask
);
4009 #endif /* HAVE_NTGUI */
4011 /* Remember allocated colors. */
4012 img
->ncolors
= attrs
.nalloc_pixels
;
4013 img
->colors
= (unsigned long *) xmalloc (img
->ncolors
4014 * sizeof *img
->colors
);
4015 for (i
= 0; i
< attrs
.nalloc_pixels
; ++i
)
4017 img
->colors
[i
] = attrs
.alloc_pixels
[i
];
4018 #ifdef DEBUG_X_COLORS
4019 register_color (img
->colors
[i
]);
4022 #endif /* not ALLOC_XPM_COLORS */
4024 img
->width
= attrs
.width
;
4025 img
->height
= attrs
.height
;
4026 xassert (img
->width
> 0 && img
->height
> 0);
4028 /* The call to XpmFreeAttributes below frees attrs.alloc_pixels. */
4030 fn_XpmFreeAttributes (&attrs
);
4032 XpmFreeAttributes (&attrs
);
4033 #endif /* HAVE_NTGUI */
4039 #endif /* HAVE_NTGUI */
4044 image_error ("Error opening XPM file (%s)", img
->spec
, Qnil
);
4047 case XpmFileInvalid
:
4048 image_error ("Invalid XPM file (%s)", img
->spec
, Qnil
);
4052 image_error ("Out of memory (%s)", img
->spec
, Qnil
);
4055 case XpmColorFailed
:
4056 image_error ("Color allocation error (%s)", img
->spec
, Qnil
);
4060 image_error ("Unknown error (%s)", img
->spec
, Qnil
);
4065 #ifdef ALLOC_XPM_COLORS
4066 xpm_free_color_cache ();
4068 return rc
== XpmSuccess
;
4071 #endif /* HAVE_XPM */
4075 /* XPM support functions for Mac OS where libxpm is not available.
4076 Only XPM version 3 (without any extensions) is supported. */
4078 static int xpm_scan
P_ ((unsigned char **, unsigned char *,
4079 unsigned char **, int *));
4080 static Lisp_Object xpm_make_color_table_v
4081 P_ ((void (**) (Lisp_Object
, unsigned char *, int, Lisp_Object
),
4082 Lisp_Object (**) (Lisp_Object
, unsigned char *, int)));
4083 static void xpm_put_color_table_v
P_ ((Lisp_Object
, unsigned char *,
4085 static Lisp_Object xpm_get_color_table_v
P_ ((Lisp_Object
,
4086 unsigned char *, int));
4087 static Lisp_Object xpm_make_color_table_h
4088 P_ ((void (**) (Lisp_Object
, unsigned char *, int, Lisp_Object
),
4089 Lisp_Object (**) (Lisp_Object
, unsigned char *, int)));
4090 static void xpm_put_color_table_h
P_ ((Lisp_Object
, unsigned char *,
4092 static Lisp_Object xpm_get_color_table_h
P_ ((Lisp_Object
,
4093 unsigned char *, int));
4094 static int xpm_str_to_color_key
P_ ((char *));
4095 static int xpm_load_image
P_ ((struct frame
*, struct image
*,
4096 unsigned char *, unsigned char *));
4098 /* Tokens returned from xpm_scan. */
4107 /* Scan an XPM data and return a character (< 256) or a token defined
4108 by enum xpm_token above. *S and END are the start (inclusive) and
4109 the end (exclusive) addresses of the data, respectively. Advance
4110 *S while scanning. If token is either XPM_TK_IDENT or
4111 XPM_TK_STRING, *BEG and *LEN are set to the start address and the
4112 length of the corresponding token, respectively. */
4115 xpm_scan (s
, end
, beg
, len
)
4116 unsigned char **s
, *end
, **beg
;
4123 /* Skip white-space. */
4124 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
4127 /* gnus-pointer.xpm uses '-' in its identifier.
4128 sb-dir-plus.xpm uses '+' in its identifier. */
4129 if (isalpha (c
) || c
== '_' || c
== '-' || c
== '+')
4133 (c
= **s
, isalnum (c
) || c
== '_' || c
== '-' || c
== '+'))
4136 return XPM_TK_IDENT
;
4141 while (*s
< end
&& **s
!= '"')
4146 return XPM_TK_STRING
;
4150 if (*s
< end
&& **s
== '*')
4152 /* C-style comment. */
4156 while (*s
< end
&& *(*s
)++ != '*')
4159 while (*s
< end
&& **s
!= '/');
4173 /* Functions for color table lookup in XPM data. A Key is a string
4174 specifying the color of each pixel in XPM data. A value is either
4175 an integer that specifies a pixel color, Qt that specifies
4176 transparency, or Qnil for the unspecified color. If the length of
4177 the key string is one, a vector is used as a table. Otherwise, a
4178 hash table is used. */
4181 xpm_make_color_table_v (put_func
, get_func
)
4182 void (**put_func
) (Lisp_Object
, unsigned char *, int, Lisp_Object
);
4183 Lisp_Object (**get_func
) (Lisp_Object
, unsigned char *, int);
4185 *put_func
= xpm_put_color_table_v
;
4186 *get_func
= xpm_get_color_table_v
;
4187 return Fmake_vector (make_number (256), Qnil
);
4191 xpm_put_color_table_v (color_table
, chars_start
, chars_len
, color
)
4192 Lisp_Object color_table
;
4193 unsigned char *chars_start
;
4197 XVECTOR (color_table
)->contents
[*chars_start
] = color
;
4201 xpm_get_color_table_v (color_table
, chars_start
, chars_len
)
4202 Lisp_Object color_table
;
4203 unsigned char *chars_start
;
4206 return XVECTOR (color_table
)->contents
[*chars_start
];
4210 xpm_make_color_table_h (put_func
, get_func
)
4211 void (**put_func
) (Lisp_Object
, unsigned char *, int, Lisp_Object
);
4212 Lisp_Object (**get_func
) (Lisp_Object
, unsigned char *, int);
4214 *put_func
= xpm_put_color_table_h
;
4215 *get_func
= xpm_get_color_table_h
;
4216 return make_hash_table (Qequal
, make_number (DEFAULT_HASH_SIZE
),
4217 make_float (DEFAULT_REHASH_SIZE
),
4218 make_float (DEFAULT_REHASH_THRESHOLD
),
4223 xpm_put_color_table_h (color_table
, chars_start
, chars_len
, color
)
4224 Lisp_Object color_table
;
4225 unsigned char *chars_start
;
4229 struct Lisp_Hash_Table
*table
= XHASH_TABLE (color_table
);
4231 Lisp_Object chars
= make_unibyte_string (chars_start
, chars_len
);
4233 hash_lookup (table
, chars
, &hash_code
);
4234 hash_put (table
, chars
, color
, hash_code
);
4238 xpm_get_color_table_h (color_table
, chars_start
, chars_len
)
4239 Lisp_Object color_table
;
4240 unsigned char *chars_start
;
4243 struct Lisp_Hash_Table
*table
= XHASH_TABLE (color_table
);
4244 int i
= hash_lookup (table
, make_unibyte_string (chars_start
, chars_len
),
4247 return i
>= 0 ? HASH_VALUE (table
, i
) : Qnil
;
4250 enum xpm_color_key
{
4258 static char xpm_color_key_strings
[][4] = {"s", "m", "g4", "g", "c"};
4261 xpm_str_to_color_key (s
)
4267 i
< sizeof xpm_color_key_strings
/ sizeof xpm_color_key_strings
[0];
4269 if (strcmp (xpm_color_key_strings
[i
], s
) == 0)
4275 xpm_load_image (f
, img
, contents
, end
)
4278 unsigned char *contents
, *end
;
4280 unsigned char *s
= contents
, *beg
, *str
;
4281 unsigned char buffer
[BUFSIZ
];
4282 int width
, height
, x
, y
;
4283 int num_colors
, chars_per_pixel
;
4285 void (*put_color_table
) (Lisp_Object
, unsigned char *, int, Lisp_Object
);
4286 Lisp_Object (*get_color_table
) (Lisp_Object
, unsigned char *, int);
4287 Lisp_Object frame
, color_symbols
, color_table
;
4288 int best_key
, have_mask
= 0;
4289 XImagePtr ximg
= NULL
, mask_img
= NULL
;
4292 LA1 = xpm_scan (&s, end, &beg, &len)
4294 #define expect(TOKEN) \
4295 if (LA1 != (TOKEN)) \
4300 #define expect_ident(IDENT) \
4301 if (LA1 == XPM_TK_IDENT \
4302 && strlen ((IDENT)) == len && memcmp ((IDENT), beg, len) == 0) \
4307 if (!(end
- s
>= 9 && memcmp (s
, "/* XPM */", 9) == 0))
4311 expect_ident ("static");
4312 expect_ident ("char");
4314 expect (XPM_TK_IDENT
);
4319 expect (XPM_TK_STRING
);
4322 memcpy (buffer
, beg
, len
);
4324 if (sscanf (buffer
, "%d %d %d %d", &width
, &height
,
4325 &num_colors
, &chars_per_pixel
) != 4
4326 || width
<= 0 || height
<= 0
4327 || num_colors
<= 0 || chars_per_pixel
<= 0)
4330 if (!check_image_size (f
, width
, height
))
4332 image_error ("Invalid image size", Qnil
, Qnil
);
4338 XSETFRAME (frame
, f
);
4339 if (!NILP (Fxw_display_color_p (frame
)))
4340 best_key
= XPM_COLOR_KEY_C
;
4341 else if (!NILP (Fx_display_grayscale_p (frame
)))
4342 best_key
= (XFASTINT (Fx_display_planes (frame
)) > 2
4343 ? XPM_COLOR_KEY_G
: XPM_COLOR_KEY_G4
);
4345 best_key
= XPM_COLOR_KEY_M
;
4347 color_symbols
= image_spec_value (img
->spec
, QCcolor_symbols
, NULL
);
4348 if (chars_per_pixel
== 1)
4349 color_table
= xpm_make_color_table_v (&put_color_table
,
4352 color_table
= xpm_make_color_table_h (&put_color_table
,
4355 while (num_colors
-- > 0)
4357 unsigned char *color
, *max_color
;
4358 int key
, next_key
, max_key
= 0;
4359 Lisp_Object symbol_color
= Qnil
, color_val
;
4362 expect (XPM_TK_STRING
);
4363 if (len
<= chars_per_pixel
|| len
>= BUFSIZ
+ chars_per_pixel
)
4365 memcpy (buffer
, beg
+ chars_per_pixel
, len
- chars_per_pixel
);
4366 buffer
[len
- chars_per_pixel
] = '\0';
4368 str
= strtok (buffer
, " \t");
4371 key
= xpm_str_to_color_key (str
);
4376 color
= strtok (NULL
, " \t");
4380 while ((str
= strtok (NULL
, " \t")) != NULL
)
4382 next_key
= xpm_str_to_color_key (str
);
4385 color
[strlen (color
)] = ' ';
4388 if (key
== XPM_COLOR_KEY_S
)
4390 if (NILP (symbol_color
))
4391 symbol_color
= build_string (color
);
4393 else if (max_key
< key
&& key
<= best_key
)
4403 if (!NILP (color_symbols
) && !NILP (symbol_color
))
4405 Lisp_Object specified_color
= Fassoc (symbol_color
, color_symbols
);
4407 if (CONSP (specified_color
) && STRINGP (XCDR (specified_color
)))
4409 if (xstricmp (SDATA (XCDR (specified_color
)), "None") == 0)
4411 else if (x_defined_color (f
, SDATA (XCDR (specified_color
)),
4413 color_val
= make_number (cdef
.pixel
);
4416 if (NILP (color_val
) && max_key
> 0)
4418 if (xstricmp (max_color
, "None") == 0)
4420 else if (x_defined_color (f
, max_color
, &cdef
, 0))
4421 color_val
= make_number (cdef
.pixel
);
4423 if (!NILP (color_val
))
4424 (*put_color_table
) (color_table
, beg
, chars_per_pixel
, color_val
);
4429 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0,
4430 &ximg
, &img
->pixmap
)
4431 || !x_create_x_image_and_pixmap (f
, width
, height
, 1,
4432 &mask_img
, &img
->mask
))
4434 image_error ("Out of memory (%s)", img
->spec
, Qnil
);
4438 for (y
= 0; y
< height
; y
++)
4440 expect (XPM_TK_STRING
);
4442 if (len
< width
* chars_per_pixel
)
4444 for (x
= 0; x
< width
; x
++, str
+= chars_per_pixel
)
4446 Lisp_Object color_val
=
4447 (*get_color_table
) (color_table
, str
, chars_per_pixel
);
4449 XPutPixel (ximg
, x
, y
,
4450 (INTEGERP (color_val
) ? XINT (color_val
)
4451 : FRAME_FOREGROUND_PIXEL (f
)));
4452 XPutPixel (mask_img
, x
, y
,
4453 (!EQ (color_val
, Qt
) ? PIX_MASK_DRAW
4454 : (have_mask
= 1, PIX_MASK_RETAIN
)));
4461 img
->height
= height
;
4463 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
4464 x_destroy_x_image (ximg
);
4467 /* Fill in the background_transparent field while we have the
4469 image_background_transparent (img
, f
, mask_img
);
4471 x_put_x_image (f
, mask_img
, img
->mask
, width
, height
);
4472 x_destroy_x_image (mask_img
);
4476 x_destroy_x_image (mask_img
);
4477 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
4478 img
->mask
= NO_PIXMAP
;
4484 image_error ("Invalid XPM file (%s)", img
->spec
, Qnil
);
4486 x_destroy_x_image (ximg
);
4487 x_destroy_x_image (mask_img
);
4488 x_clear_image (f
, img
);
4502 Lisp_Object file_name
;
4504 /* If IMG->spec specifies a file name, create a non-file spec from it. */
4505 file_name
= image_spec_value (img
->spec
, QCfile
, NULL
);
4506 if (STRINGP (file_name
))
4509 unsigned char *contents
;
4511 struct gcpro gcpro1
;
4513 file
= x_find_image_file (file_name
);
4515 if (!STRINGP (file
))
4517 image_error ("Cannot find image file `%s'", file_name
, Qnil
);
4522 contents
= slurp_file (SDATA (file
), &size
);
4523 if (contents
== NULL
)
4525 image_error ("Error loading XPM image `%s'", img
->spec
, Qnil
);
4530 success_p
= xpm_load_image (f
, img
, contents
, contents
+ size
);
4538 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
4539 success_p
= xpm_load_image (f
, img
, SDATA (data
),
4540 SDATA (data
) + SBYTES (data
));
4550 /***********************************************************************
4552 ***********************************************************************/
4554 #ifdef COLOR_TABLE_SUPPORT
4556 /* An entry in the color table mapping an RGB color to a pixel color. */
4561 unsigned long pixel
;
4563 /* Next in color table collision list. */
4564 struct ct_color
*next
;
4567 /* The bucket vector size to use. Must be prime. */
4571 /* Value is a hash of the RGB color given by R, G, and B. */
4573 #define CT_HASH_RGB(R, G, B) (((R) << 16) ^ ((G) << 8) ^ (B))
4575 /* The color hash table. */
4577 struct ct_color
**ct_table
;
4579 /* Number of entries in the color table. */
4581 int ct_colors_allocated
;
4583 /* Initialize the color table. */
4588 int size
= CT_SIZE
* sizeof (*ct_table
);
4589 ct_table
= (struct ct_color
**) xmalloc (size
);
4590 bzero (ct_table
, size
);
4591 ct_colors_allocated
= 0;
4595 /* Free memory associated with the color table. */
4601 struct ct_color
*p
, *next
;
4603 for (i
= 0; i
< CT_SIZE
; ++i
)
4604 for (p
= ct_table
[i
]; p
; p
= next
)
4615 /* Value is a pixel color for RGB color R, G, B on frame F. If an
4616 entry for that color already is in the color table, return the
4617 pixel color of that entry. Otherwise, allocate a new color for R,
4618 G, B, and make an entry in the color table. */
4620 static unsigned long
4621 lookup_rgb_color (f
, r
, g
, b
)
4625 unsigned hash
= CT_HASH_RGB (r
, g
, b
);
4626 int i
= hash
% CT_SIZE
;
4628 Display_Info
*dpyinfo
;
4630 /* Handle TrueColor visuals specially, which improves performance by
4631 two orders of magnitude. Freeing colors on TrueColor visuals is
4632 a nop, and pixel colors specify RGB values directly. See also
4633 the Xlib spec, chapter 3.1. */
4634 dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
4635 if (dpyinfo
->red_bits
> 0)
4637 unsigned long pr
, pg
, pb
;
4639 /* Apply gamma-correction like normal color allocation does. */
4643 color
.red
= r
, color
.green
= g
, color
.blue
= b
;
4644 gamma_correct (f
, &color
);
4645 r
= color
.red
, g
= color
.green
, b
= color
.blue
;
4648 /* Scale down RGB values to the visual's bits per RGB, and shift
4649 them to the right position in the pixel color. Note that the
4650 original RGB values are 16-bit values, as usual in X. */
4651 pr
= (r
>> (16 - dpyinfo
->red_bits
)) << dpyinfo
->red_offset
;
4652 pg
= (g
>> (16 - dpyinfo
->green_bits
)) << dpyinfo
->green_offset
;
4653 pb
= (b
>> (16 - dpyinfo
->blue_bits
)) << dpyinfo
->blue_offset
;
4655 /* Assemble the pixel color. */
4656 return pr
| pg
| pb
;
4659 for (p
= ct_table
[i
]; p
; p
= p
->next
)
4660 if (p
->r
== r
&& p
->g
== g
&& p
->b
== b
)
4666 #ifdef HAVE_X_WINDOWS
4675 cmap
= FRAME_X_COLORMAP (f
);
4676 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
4679 ++ct_colors_allocated
;
4680 p
= (struct ct_color
*) xmalloc (sizeof *p
);
4684 p
->pixel
= color
.pixel
;
4685 p
->next
= ct_table
[i
];
4689 return FRAME_FOREGROUND_PIXEL (f
);
4694 color
= PALETTERGB (r
, g
, b
);
4696 color
= RGB_TO_ULONG (r
, g
, b
);
4697 #endif /* HAVE_NTGUI */
4698 ++ct_colors_allocated
;
4699 p
= (struct ct_color
*) xmalloc (sizeof *p
);
4704 p
->next
= ct_table
[i
];
4706 #endif /* HAVE_X_WINDOWS */
4714 /* Look up pixel color PIXEL which is used on frame F in the color
4715 table. If not already present, allocate it. Value is PIXEL. */
4717 static unsigned long
4718 lookup_pixel_color (f
, pixel
)
4720 unsigned long pixel
;
4722 int i
= pixel
% CT_SIZE
;
4725 for (p
= ct_table
[i
]; p
; p
= p
->next
)
4726 if (p
->pixel
== pixel
)
4735 #ifdef HAVE_X_WINDOWS
4736 cmap
= FRAME_X_COLORMAP (f
);
4737 color
.pixel
= pixel
;
4738 x_query_color (f
, &color
);
4739 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
4742 cmap
= DefaultColormapOfScreen (FRAME_X_SCREEN (f
));
4743 color
.pixel
= pixel
;
4744 XQueryColor (NULL
, cmap
, &color
);
4745 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
4747 #endif /* HAVE_X_WINDOWS */
4751 ++ct_colors_allocated
;
4753 p
= (struct ct_color
*) xmalloc (sizeof *p
);
4758 p
->next
= ct_table
[i
];
4762 return FRAME_FOREGROUND_PIXEL (f
);
4768 /* Value is a vector of all pixel colors contained in the color table,
4769 allocated via xmalloc. Set *N to the number of colors. */
4771 static unsigned long *
4772 colors_in_color_table (n
)
4777 unsigned long *colors
;
4779 if (ct_colors_allocated
== 0)
4786 colors
= (unsigned long *) xmalloc (ct_colors_allocated
4788 *n
= ct_colors_allocated
;
4790 for (i
= j
= 0; i
< CT_SIZE
; ++i
)
4791 for (p
= ct_table
[i
]; p
; p
= p
->next
)
4792 colors
[j
++] = p
->pixel
;
4798 #else /* COLOR_TABLE_SUPPORT */
4800 static unsigned long
4801 lookup_rgb_color (f
, r
, g
, b
)
4805 unsigned long pixel
;
4808 pixel
= RGB_TO_ULONG (r
>> 8, g
>> 8, b
>> 8);
4809 gamma_correct (f
, &pixel
);
4813 pixel
= PALETTERGB (r
>> 8, g
>> 8, b
>> 8);
4814 #endif /* HAVE_NTGUI */
4823 #endif /* COLOR_TABLE_SUPPORT */
4826 /***********************************************************************
4828 ***********************************************************************/
4830 static XColor
*x_to_xcolors
P_ ((struct frame
*, struct image
*, int));
4831 static void x_from_xcolors
P_ ((struct frame
*, struct image
*, XColor
*));
4832 static void x_detect_edges
P_ ((struct frame
*, struct image
*, int[9], int));
4835 static void XPutPixel (XImagePtr
, int, int, COLORREF
);
4836 #endif /* HAVE_NTGUI */
4838 /* Non-zero means draw a cross on images having `:conversion
4841 int cross_disabled_images
;
4843 /* Edge detection matrices for different edge-detection
4846 static int emboss_matrix
[9] = {
4848 2, -1, 0, /* y - 1 */
4850 0, 1, -2 /* y + 1 */
4853 static int laplace_matrix
[9] = {
4855 1, 0, 0, /* y - 1 */
4857 0, 0, -1 /* y + 1 */
4860 /* Value is the intensity of the color whose red/green/blue values
4863 #define COLOR_INTENSITY(R, G, B) ((2 * (R) + 3 * (G) + (B)) / 6)
4866 /* On frame F, return an array of XColor structures describing image
4867 IMG->pixmap. Each XColor structure has its pixel color set. RGB_P
4868 non-zero means also fill the red/green/blue members of the XColor
4869 structures. Value is a pointer to the array of XColors structures,
4870 allocated with xmalloc; it must be freed by the caller. */
4873 x_to_xcolors (f
, img
, rgb_p
)
4880 XImagePtr_or_DC ximg
;
4884 #endif /* HAVE_NTGUI */
4886 colors
= (XColor
*) xmalloc (img
->width
* img
->height
* sizeof *colors
);
4889 /* Get the X image IMG->pixmap. */
4890 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
4891 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
4893 /* Load the image into a memory device context. */
4894 hdc
= get_frame_dc (f
);
4895 ximg
= CreateCompatibleDC (hdc
);
4896 release_frame_dc (f
, hdc
);
4897 prev
= SelectObject (ximg
, img
->pixmap
);
4898 #endif /* HAVE_NTGUI */
4900 /* Fill the `pixel' members of the XColor array. I wished there
4901 were an easy and portable way to circumvent XGetPixel. */
4903 for (y
= 0; y
< img
->height
; ++y
)
4907 #ifdef HAVE_X_WINDOWS
4908 for (x
= 0; x
< img
->width
; ++x
, ++p
)
4909 p
->pixel
= XGetPixel (ximg
, x
, y
);
4911 x_query_colors (f
, row
, img
->width
);
4915 for (x
= 0; x
< img
->width
; ++x
, ++p
)
4917 /* W32_TODO: palette support needed here? */
4918 p
->pixel
= GET_PIXEL (ximg
, x
, y
);
4922 p
->red
= RED16_FROM_ULONG (p
->pixel
);
4923 p
->green
= GREEN16_FROM_ULONG (p
->pixel
);
4924 p
->blue
= BLUE16_FROM_ULONG (p
->pixel
);
4927 p
->red
= 256 * GetRValue (p
->pixel
);
4928 p
->green
= 256 * GetGValue (p
->pixel
);
4929 p
->blue
= 256 * GetBValue (p
->pixel
);
4930 #endif /* HAVE_NTGUI */
4933 #endif /* HAVE_X_WINDOWS */
4936 Destroy_Image (ximg
, prev
);
4943 /* Put a pixel of COLOR at position X, Y in XIMG. XIMG must have been
4944 created with CreateDIBSection, with the pointer to the bit values
4945 stored in ximg->data. */
4947 static void XPutPixel (ximg
, x
, y
, color
)
4952 int width
= ximg
->info
.bmiHeader
.biWidth
;
4953 int height
= ximg
->info
.bmiHeader
.biHeight
;
4954 unsigned char * pixel
;
4956 /* True color images. */
4957 if (ximg
->info
.bmiHeader
.biBitCount
== 24)
4959 int rowbytes
= width
* 3;
4960 /* Ensure scanlines are aligned on 4 byte boundaries. */
4962 rowbytes
+= 4 - (rowbytes
% 4);
4964 pixel
= ximg
->data
+ y
* rowbytes
+ x
* 3;
4965 /* Windows bitmaps are in BGR order. */
4966 *pixel
= GetBValue (color
);
4967 *(pixel
+ 1) = GetGValue (color
);
4968 *(pixel
+ 2) = GetRValue (color
);
4970 /* Monochrome images. */
4971 else if (ximg
->info
.bmiHeader
.biBitCount
== 1)
4973 int rowbytes
= width
/ 8;
4974 /* Ensure scanlines are aligned on 4 byte boundaries. */
4976 rowbytes
+= 4 - (rowbytes
% 4);
4977 pixel
= ximg
->data
+ y
* rowbytes
+ x
/ 8;
4978 /* Filter out palette info. */
4979 if (color
& 0x00ffffff)
4980 *pixel
= *pixel
| (1 << x
% 8);
4982 *pixel
= *pixel
& ~(1 << x
% 8);
4985 image_error ("XPutPixel: palette image not supported", Qnil
, Qnil
);
4988 #endif /* HAVE_NTGUI */
4990 /* Create IMG->pixmap from an array COLORS of XColor structures, whose
4991 RGB members are set. F is the frame on which this all happens.
4992 COLORS will be freed; an existing IMG->pixmap will be freed, too. */
4995 x_from_xcolors (f
, img
, colors
)
5005 init_color_table ();
5007 x_create_x_image_and_pixmap (f
, img
->width
, img
->height
, 0,
5010 for (y
= 0; y
< img
->height
; ++y
)
5011 for (x
= 0; x
< img
->width
; ++x
, ++p
)
5013 unsigned long pixel
;
5014 pixel
= lookup_rgb_color (f
, p
->red
, p
->green
, p
->blue
);
5015 XPutPixel (oimg
, x
, y
, pixel
);
5019 x_clear_image_1 (f
, img
, 1, 0, 1);
5021 x_put_x_image (f
, oimg
, pixmap
, img
->width
, img
->height
);
5022 x_destroy_x_image (oimg
);
5023 img
->pixmap
= pixmap
;
5024 #ifdef COLOR_TABLE_SUPPORT
5025 img
->colors
= colors_in_color_table (&img
->ncolors
);
5026 free_color_table ();
5027 #endif /* COLOR_TABLE_SUPPORT */
5031 /* On frame F, perform edge-detection on image IMG.
5033 MATRIX is a nine-element array specifying the transformation
5034 matrix. See emboss_matrix for an example.
5036 COLOR_ADJUST is a color adjustment added to each pixel of the
5040 x_detect_edges (f
, img
, matrix
, color_adjust
)
5043 int matrix
[9], color_adjust
;
5045 XColor
*colors
= x_to_xcolors (f
, img
, 1);
5049 for (i
= sum
= 0; i
< 9; ++i
)
5050 sum
+= abs (matrix
[i
]);
5052 #define COLOR(A, X, Y) ((A) + (Y) * img->width + (X))
5054 new = (XColor
*) xmalloc (img
->width
* img
->height
* sizeof *new);
5056 for (y
= 0; y
< img
->height
; ++y
)
5058 p
= COLOR (new, 0, y
);
5059 p
->red
= p
->green
= p
->blue
= 0xffff/2;
5060 p
= COLOR (new, img
->width
- 1, y
);
5061 p
->red
= p
->green
= p
->blue
= 0xffff/2;
5064 for (x
= 1; x
< img
->width
- 1; ++x
)
5066 p
= COLOR (new, x
, 0);
5067 p
->red
= p
->green
= p
->blue
= 0xffff/2;
5068 p
= COLOR (new, x
, img
->height
- 1);
5069 p
->red
= p
->green
= p
->blue
= 0xffff/2;
5072 for (y
= 1; y
< img
->height
- 1; ++y
)
5074 p
= COLOR (new, 1, y
);
5076 for (x
= 1; x
< img
->width
- 1; ++x
, ++p
)
5078 int r
, g
, b
, y1
, x1
;
5081 for (y1
= y
- 1; y1
< y
+ 2; ++y1
)
5082 for (x1
= x
- 1; x1
< x
+ 2; ++x1
, ++i
)
5085 XColor
*t
= COLOR (colors
, x1
, y1
);
5086 r
+= matrix
[i
] * t
->red
;
5087 g
+= matrix
[i
] * t
->green
;
5088 b
+= matrix
[i
] * t
->blue
;
5091 r
= (r
/ sum
+ color_adjust
) & 0xffff;
5092 g
= (g
/ sum
+ color_adjust
) & 0xffff;
5093 b
= (b
/ sum
+ color_adjust
) & 0xffff;
5094 p
->red
= p
->green
= p
->blue
= COLOR_INTENSITY (r
, g
, b
);
5099 x_from_xcolors (f
, img
, new);
5105 /* Perform the pre-defined `emboss' edge-detection on image IMG
5113 x_detect_edges (f
, img
, emboss_matrix
, 0xffff / 2);
5117 /* Transform image IMG which is used on frame F with a Laplace
5118 edge-detection algorithm. The result is an image that can be used
5119 to draw disabled buttons, for example. */
5126 x_detect_edges (f
, img
, laplace_matrix
, 45000);
5130 /* Perform edge-detection on image IMG on frame F, with specified
5131 transformation matrix MATRIX and color-adjustment COLOR_ADJUST.
5133 MATRIX must be either
5135 - a list of at least 9 numbers in row-major form
5136 - a vector of at least 9 numbers
5138 COLOR_ADJUST nil means use a default; otherwise it must be a
5142 x_edge_detection (f
, img
, matrix
, color_adjust
)
5145 Lisp_Object matrix
, color_adjust
;
5153 i
< 9 && CONSP (matrix
) && NUMBERP (XCAR (matrix
));
5154 ++i
, matrix
= XCDR (matrix
))
5155 trans
[i
] = XFLOATINT (XCAR (matrix
));
5157 else if (VECTORP (matrix
) && ASIZE (matrix
) >= 9)
5159 for (i
= 0; i
< 9 && NUMBERP (AREF (matrix
, i
)); ++i
)
5160 trans
[i
] = XFLOATINT (AREF (matrix
, i
));
5163 if (NILP (color_adjust
))
5164 color_adjust
= make_number (0xffff / 2);
5166 if (i
== 9 && NUMBERP (color_adjust
))
5167 x_detect_edges (f
, img
, trans
, (int) XFLOATINT (color_adjust
));
5171 /* Transform image IMG on frame F so that it looks disabled. */
5174 x_disable_image (f
, img
)
5178 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
5180 int n_planes
= dpyinfo
->n_planes
* dpyinfo
->n_cbits
;
5182 int n_planes
= dpyinfo
->n_planes
;
5183 #endif /* HAVE_NTGUI */
5187 /* Color (or grayscale). Convert to gray, and equalize. Just
5188 drawing such images with a stipple can look very odd, so
5189 we're using this method instead. */
5190 XColor
*colors
= x_to_xcolors (f
, img
, 1);
5192 const int h
= 15000;
5193 const int l
= 30000;
5195 for (p
= colors
, end
= colors
+ img
->width
* img
->height
;
5199 int i
= COLOR_INTENSITY (p
->red
, p
->green
, p
->blue
);
5200 int i2
= (0xffff - h
- l
) * i
/ 0xffff + l
;
5201 p
->red
= p
->green
= p
->blue
= i2
;
5204 x_from_xcolors (f
, img
, colors
);
5207 /* Draw a cross over the disabled image, if we must or if we
5209 if (n_planes
< 2 || cross_disabled_images
)
5212 Display
*dpy
= FRAME_X_DISPLAY (f
);
5216 #define XCreateGC_pixmap(dpy, pixmap) XCreateGC (dpy, NULL, 0, NULL)
5217 #define MaskForeground(f) PIX_MASK_DRAW
5219 #define XCreateGC_pixmap(dpy, pixmap) XCreateGC (dpy, pixmap, 0, NULL)
5220 #define MaskForeground(f) WHITE_PIX_DEFAULT (f)
5223 gc
= XCreateGC_pixmap (dpy
, img
->pixmap
);
5224 XSetForeground (dpy
, gc
, BLACK_PIX_DEFAULT (f
));
5225 XDrawLine (dpy
, img
->pixmap
, gc
, 0, 0,
5226 img
->width
- 1, img
->height
- 1);
5227 XDrawLine (dpy
, img
->pixmap
, gc
, 0, img
->height
- 1,
5233 gc
= XCreateGC_pixmap (dpy
, img
->mask
);
5234 XSetForeground (dpy
, gc
, MaskForeground (f
));
5235 XDrawLine (dpy
, img
->mask
, gc
, 0, 0,
5236 img
->width
- 1, img
->height
- 1);
5237 XDrawLine (dpy
, img
->mask
, gc
, 0, img
->height
- 1,
5245 hdc
= get_frame_dc (f
);
5246 bmpdc
= CreateCompatibleDC (hdc
);
5247 release_frame_dc (f
, hdc
);
5249 prev
= SelectObject (bmpdc
, img
->pixmap
);
5251 SetTextColor (bmpdc
, BLACK_PIX_DEFAULT (f
));
5252 MoveToEx (bmpdc
, 0, 0, NULL
);
5253 LineTo (bmpdc
, img
->width
- 1, img
->height
- 1);
5254 MoveToEx (bmpdc
, 0, img
->height
- 1, NULL
);
5255 LineTo (bmpdc
, img
->width
- 1, 0);
5259 SelectObject (bmpdc
, img
->mask
);
5260 SetTextColor (bmpdc
, WHITE_PIX_DEFAULT (f
));
5261 MoveToEx (bmpdc
, 0, 0, NULL
);
5262 LineTo (bmpdc
, img
->width
- 1, img
->height
- 1);
5263 MoveToEx (bmpdc
, 0, img
->height
- 1, NULL
);
5264 LineTo (bmpdc
, img
->width
- 1, 0);
5266 SelectObject (bmpdc
, prev
);
5268 #endif /* HAVE_NTGUI */
5273 /* Build a mask for image IMG which is used on frame F. FILE is the
5274 name of an image file, for error messages. HOW determines how to
5275 determine the background color of IMG. If it is a list '(R G B)',
5276 with R, G, and B being integers >= 0, take that as the color of the
5277 background. Otherwise, determine the background color of IMG
5278 heuristically. Value is non-zero if successful. */
5281 x_build_heuristic_mask (f
, img
, how
)
5286 XImagePtr_or_DC ximg
;
5294 #endif /* HAVE_NTGUI */
5295 int x
, y
, rc
, use_img_background
;
5296 unsigned long bg
= 0;
5300 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
5301 img
->mask
= NO_PIXMAP
;
5302 img
->background_transparent_valid
= 0;
5306 /* Create an image and pixmap serving as mask. */
5307 rc
= x_create_x_image_and_pixmap (f
, img
->width
, img
->height
, 1,
5308 &mask_img
, &img
->mask
);
5312 /* Get the X image of IMG->pixmap. */
5313 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
, 0, 0,
5314 img
->width
, img
->height
,
5317 /* Create the bit array serving as mask. */
5318 row_width
= (img
->width
+ 7) / 8;
5319 mask_img
= xmalloc (row_width
* img
->height
);
5320 bzero (mask_img
, row_width
* img
->height
);
5322 /* Create a memory device context for IMG->pixmap. */
5323 frame_dc
= get_frame_dc (f
);
5324 ximg
= CreateCompatibleDC (frame_dc
);
5325 release_frame_dc (f
, frame_dc
);
5326 prev
= SelectObject (ximg
, img
->pixmap
);
5327 #endif /* HAVE_NTGUI */
5329 /* Determine the background color of ximg. If HOW is `(R G B)'
5330 take that as color. Otherwise, use the image's background color. */
5331 use_img_background
= 1;
5337 for (i
= 0; i
< 3 && CONSP (how
) && NATNUMP (XCAR (how
)); ++i
)
5339 rgb
[i
] = XFASTINT (XCAR (how
)) & 0xffff;
5343 if (i
== 3 && NILP (how
))
5345 char color_name
[30];
5346 sprintf (color_name
, "#%04x%04x%04x", rgb
[0], rgb
[1], rgb
[2]);
5349 0x00ffffff & /* Filter out palette info. */
5350 #endif /* HAVE_NTGUI */
5351 x_alloc_image_color (f
, img
, build_string (color_name
), 0));
5352 use_img_background
= 0;
5356 if (use_img_background
)
5357 bg
= four_corners_best (ximg
, img
->width
, img
->height
);
5359 /* Set all bits in mask_img to 1 whose color in ximg is different
5360 from the background color bg. */
5362 for (y
= 0; y
< img
->height
; ++y
)
5363 for (x
= 0; x
< img
->width
; ++x
)
5364 XPutPixel (mask_img
, x
, y
, (XGetPixel (ximg
, x
, y
) != bg
5365 ? PIX_MASK_DRAW
: PIX_MASK_RETAIN
));
5367 /* Fill in the background_transparent field while we have the mask handy. */
5368 image_background_transparent (img
, f
, mask_img
);
5370 /* Put mask_img into img->mask. */
5371 x_put_x_image (f
, mask_img
, img
->mask
, img
->width
, img
->height
);
5372 x_destroy_x_image (mask_img
);
5375 for (y
= 0; y
< img
->height
; ++y
)
5376 for (x
= 0; x
< img
->width
; ++x
)
5378 COLORREF p
= GetPixel (ximg
, x
, y
);
5380 mask_img
[y
* row_width
+ x
/ 8] |= 1 << (x
% 8);
5383 /* Create the mask image. */
5384 img
->mask
= w32_create_pixmap_from_bitmap_data (img
->width
, img
->height
,
5386 /* Fill in the background_transparent field while we have the mask handy. */
5387 SelectObject (ximg
, img
->mask
);
5388 image_background_transparent (img
, f
, ximg
);
5390 /* Was: x_destroy_x_image ((XImagePtr )mask_img); which seems bogus ++kfs */
5392 #endif /* HAVE_NTGUI */
5394 Destroy_Image (ximg
, prev
);
5400 /***********************************************************************
5401 PBM (mono, gray, color)
5402 ***********************************************************************/
5404 static int pbm_image_p
P_ ((Lisp_Object object
));
5405 static int pbm_load
P_ ((struct frame
*f
, struct image
*img
));
5406 static int pbm_scan_number
P_ ((unsigned char **, unsigned char *));
5408 /* The symbol `pbm' identifying images of this type. */
5412 /* Indices of image specification fields in gs_format, below. */
5414 enum pbm_keyword_index
5430 /* Vector of image_keyword structures describing the format
5431 of valid user-defined image specifications. */
5433 static struct image_keyword pbm_format
[PBM_LAST
] =
5435 {":type", IMAGE_SYMBOL_VALUE
, 1},
5436 {":file", IMAGE_STRING_VALUE
, 0},
5437 {":data", IMAGE_STRING_VALUE
, 0},
5438 {":ascent", IMAGE_ASCENT_VALUE
, 0},
5439 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
5440 {":relief", IMAGE_INTEGER_VALUE
, 0},
5441 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5442 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5443 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5444 {":foreground", IMAGE_STRING_OR_NIL_VALUE
, 0},
5445 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
5448 /* Structure describing the image type `pbm'. */
5450 static struct image_type pbm_type
=
5460 /* Return non-zero if OBJECT is a valid PBM image specification. */
5463 pbm_image_p (object
)
5466 struct image_keyword fmt
[PBM_LAST
];
5468 bcopy (pbm_format
, fmt
, sizeof fmt
);
5470 if (!parse_image_spec (object
, fmt
, PBM_LAST
, Qpbm
))
5473 /* Must specify either :data or :file. */
5474 return fmt
[PBM_DATA
].count
+ fmt
[PBM_FILE
].count
== 1;
5478 /* Scan a decimal number from *S and return it. Advance *S while
5479 reading the number. END is the end of the string. Value is -1 at
5483 pbm_scan_number (s
, end
)
5484 unsigned char **s
, *end
;
5486 int c
= 0, val
= -1;
5490 /* Skip white-space. */
5491 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
5496 /* Skip comment to end of line. */
5497 while (*s
< end
&& (c
= *(*s
)++, c
!= '\n'))
5500 else if (isdigit (c
))
5502 /* Read decimal number. */
5504 while (*s
< end
&& (c
= *(*s
)++, isdigit (c
)))
5505 val
= 10 * val
+ c
- '0';
5517 #if 0 /* Unused. ++kfs */
5519 /* Read FILE into memory. Value is a pointer to a buffer allocated
5520 with xmalloc holding FILE's contents. Value is null if an error
5521 occurred. *SIZE is set to the size of the file. */
5524 pbm_read_file (file
, size
)
5532 if (stat (SDATA (file
), &st
) == 0
5533 && (fp
= fopen (SDATA (file
), "rb")) != NULL
5534 && (buf
= (char *) xmalloc (st
.st_size
),
5535 fread (buf
, 1, st
.st_size
, fp
) == st
.st_size
))
5554 #endif /* HAVE_NTGUI */
5556 /* Load PBM image IMG for use on frame F. */
5564 int width
, height
, max_color_idx
= 0;
5566 Lisp_Object file
, specified_file
;
5567 enum {PBM_MONO
, PBM_GRAY
, PBM_COLOR
} type
;
5568 struct gcpro gcpro1
;
5569 unsigned char *contents
= NULL
;
5570 unsigned char *end
, *p
;
5573 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
5577 if (STRINGP (specified_file
))
5579 file
= x_find_image_file (specified_file
);
5580 if (!STRINGP (file
))
5582 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
5587 contents
= slurp_file (SDATA (file
), &size
);
5588 if (contents
== NULL
)
5590 image_error ("Error reading `%s'", file
, Qnil
);
5596 end
= contents
+ size
;
5601 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
5603 end
= p
+ SBYTES (data
);
5606 /* Check magic number. */
5607 if (end
- p
< 2 || *p
++ != 'P')
5609 image_error ("Not a PBM image: `%s'", img
->spec
, Qnil
);
5619 raw_p
= 0, type
= PBM_MONO
;
5623 raw_p
= 0, type
= PBM_GRAY
;
5627 raw_p
= 0, type
= PBM_COLOR
;
5631 raw_p
= 1, type
= PBM_MONO
;
5635 raw_p
= 1, type
= PBM_GRAY
;
5639 raw_p
= 1, type
= PBM_COLOR
;
5643 image_error ("Not a PBM image: `%s'", img
->spec
, Qnil
);
5647 /* Read width, height, maximum color-component. Characters
5648 starting with `#' up to the end of a line are ignored. */
5649 width
= pbm_scan_number (&p
, end
);
5650 height
= pbm_scan_number (&p
, end
);
5652 if (type
!= PBM_MONO
)
5654 max_color_idx
= pbm_scan_number (&p
, end
);
5655 if (raw_p
&& max_color_idx
> 255)
5656 max_color_idx
= 255;
5659 if (!check_image_size (f
, width
, height
)
5660 || (type
!= PBM_MONO
&& max_color_idx
< 0))
5663 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0,
5664 &ximg
, &img
->pixmap
))
5667 /* Initialize the color hash table. */
5668 init_color_table ();
5670 if (type
== PBM_MONO
)
5673 struct image_keyword fmt
[PBM_LAST
];
5674 unsigned long fg
= FRAME_FOREGROUND_PIXEL (f
);
5675 unsigned long bg
= FRAME_BACKGROUND_PIXEL (f
);
5677 /* Parse the image specification. */
5678 bcopy (pbm_format
, fmt
, sizeof fmt
);
5679 parse_image_spec (img
->spec
, fmt
, PBM_LAST
, Qpbm
);
5681 /* Get foreground and background colors, maybe allocate colors. */
5682 if (fmt
[PBM_FOREGROUND
].count
5683 && STRINGP (fmt
[PBM_FOREGROUND
].value
))
5684 fg
= x_alloc_image_color (f
, img
, fmt
[PBM_FOREGROUND
].value
, fg
);
5685 if (fmt
[PBM_BACKGROUND
].count
5686 && STRINGP (fmt
[PBM_BACKGROUND
].value
))
5688 bg
= x_alloc_image_color (f
, img
, fmt
[PBM_BACKGROUND
].value
, bg
);
5689 img
->background
= bg
;
5690 img
->background_valid
= 1;
5693 for (y
= 0; y
< height
; ++y
)
5694 for (x
= 0; x
< width
; ++x
)
5704 g
= pbm_scan_number (&p
, end
);
5706 XPutPixel (ximg
, x
, y
, g
? fg
: bg
);
5711 for (y
= 0; y
< height
; ++y
)
5712 for (x
= 0; x
< width
; ++x
)
5716 if (type
== PBM_GRAY
)
5717 r
= g
= b
= raw_p
? *p
++ : pbm_scan_number (&p
, end
);
5726 r
= pbm_scan_number (&p
, end
);
5727 g
= pbm_scan_number (&p
, end
);
5728 b
= pbm_scan_number (&p
, end
);
5731 if (r
< 0 || g
< 0 || b
< 0)
5733 x_destroy_x_image (ximg
);
5734 image_error ("Invalid pixel value in image `%s'",
5739 /* RGB values are now in the range 0..max_color_idx.
5740 Scale this to the range 0..0xffff supported by X. */
5741 r
= (double) r
* 65535 / max_color_idx
;
5742 g
= (double) g
* 65535 / max_color_idx
;
5743 b
= (double) b
* 65535 / max_color_idx
;
5744 XPutPixel (ximg
, x
, y
, lookup_rgb_color (f
, r
, g
, b
));
5748 #ifdef COLOR_TABLE_SUPPORT
5749 /* Store in IMG->colors the colors allocated for the image, and
5750 free the color table. */
5751 img
->colors
= colors_in_color_table (&img
->ncolors
);
5752 free_color_table ();
5753 #endif /* COLOR_TABLE_SUPPORT */
5756 img
->height
= height
;
5758 /* Maybe fill in the background field while we have ximg handy. */
5760 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
5761 /* Casting avoids a GCC warning. */
5762 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
5764 /* Put the image into a pixmap. */
5765 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
5766 x_destroy_x_image (ximg
);
5768 /* X and W32 versions did it here, MAC version above. ++kfs
5770 img->height = height; */
5778 /***********************************************************************
5780 ***********************************************************************/
5782 #if defined (HAVE_PNG) || defined (MAC_OS)
5784 /* Function prototypes. */
5786 static int png_image_p
P_ ((Lisp_Object object
));
5787 static int png_load
P_ ((struct frame
*f
, struct image
*img
));
5789 /* The symbol `png' identifying images of this type. */
5793 /* Indices of image specification fields in png_format, below. */
5795 enum png_keyword_index
5810 /* Vector of image_keyword structures describing the format
5811 of valid user-defined image specifications. */
5813 static struct image_keyword png_format
[PNG_LAST
] =
5815 {":type", IMAGE_SYMBOL_VALUE
, 1},
5816 {":data", IMAGE_STRING_VALUE
, 0},
5817 {":file", IMAGE_STRING_VALUE
, 0},
5818 {":ascent", IMAGE_ASCENT_VALUE
, 0},
5819 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
5820 {":relief", IMAGE_INTEGER_VALUE
, 0},
5821 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5822 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5823 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5824 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
5827 /* Structure describing the image type `png'. */
5829 static struct image_type png_type
=
5838 /* Return non-zero if OBJECT is a valid PNG image specification. */
5841 png_image_p (object
)
5844 struct image_keyword fmt
[PNG_LAST
];
5845 bcopy (png_format
, fmt
, sizeof fmt
);
5847 if (!parse_image_spec (object
, fmt
, PNG_LAST
, Qpng
))
5850 /* Must specify either the :data or :file keyword. */
5851 return fmt
[PNG_FILE
].count
+ fmt
[PNG_DATA
].count
== 1;
5854 #endif /* HAVE_PNG || MAC_OS */
5859 #if defined HAVE_LIBPNG_PNG_H
5860 # include <libpng/png.h>
5866 /* PNG library details. */
5868 DEF_IMGLIB_FN (png_get_io_ptr
);
5869 DEF_IMGLIB_FN (png_check_sig
);
5870 DEF_IMGLIB_FN (png_create_read_struct
);
5871 DEF_IMGLIB_FN (png_create_info_struct
);
5872 DEF_IMGLIB_FN (png_destroy_read_struct
);
5873 DEF_IMGLIB_FN (png_set_read_fn
);
5874 DEF_IMGLIB_FN (png_set_sig_bytes
);
5875 DEF_IMGLIB_FN (png_read_info
);
5876 DEF_IMGLIB_FN (png_get_IHDR
);
5877 DEF_IMGLIB_FN (png_get_valid
);
5878 DEF_IMGLIB_FN (png_set_strip_16
);
5879 DEF_IMGLIB_FN (png_set_expand
);
5880 DEF_IMGLIB_FN (png_set_gray_to_rgb
);
5881 DEF_IMGLIB_FN (png_set_background
);
5882 DEF_IMGLIB_FN (png_get_bKGD
);
5883 DEF_IMGLIB_FN (png_read_update_info
);
5884 DEF_IMGLIB_FN (png_get_channels
);
5885 DEF_IMGLIB_FN (png_get_rowbytes
);
5886 DEF_IMGLIB_FN (png_read_image
);
5887 DEF_IMGLIB_FN (png_read_end
);
5888 DEF_IMGLIB_FN (png_error
);
5891 init_png_functions (Lisp_Object libraries
)
5895 /* Try loading libpng under probable names. */
5896 if (!(library
= w32_delayed_load (libraries
, Qpng
)))
5899 LOAD_IMGLIB_FN (library
, png_get_io_ptr
);
5900 LOAD_IMGLIB_FN (library
, png_check_sig
);
5901 LOAD_IMGLIB_FN (library
, png_create_read_struct
);
5902 LOAD_IMGLIB_FN (library
, png_create_info_struct
);
5903 LOAD_IMGLIB_FN (library
, png_destroy_read_struct
);
5904 LOAD_IMGLIB_FN (library
, png_set_read_fn
);
5905 LOAD_IMGLIB_FN (library
, png_set_sig_bytes
);
5906 LOAD_IMGLIB_FN (library
, png_read_info
);
5907 LOAD_IMGLIB_FN (library
, png_get_IHDR
);
5908 LOAD_IMGLIB_FN (library
, png_get_valid
);
5909 LOAD_IMGLIB_FN (library
, png_set_strip_16
);
5910 LOAD_IMGLIB_FN (library
, png_set_expand
);
5911 LOAD_IMGLIB_FN (library
, png_set_gray_to_rgb
);
5912 LOAD_IMGLIB_FN (library
, png_set_background
);
5913 LOAD_IMGLIB_FN (library
, png_get_bKGD
);
5914 LOAD_IMGLIB_FN (library
, png_read_update_info
);
5915 LOAD_IMGLIB_FN (library
, png_get_channels
);
5916 LOAD_IMGLIB_FN (library
, png_get_rowbytes
);
5917 LOAD_IMGLIB_FN (library
, png_read_image
);
5918 LOAD_IMGLIB_FN (library
, png_read_end
);
5919 LOAD_IMGLIB_FN (library
, png_error
);
5924 #define fn_png_get_io_ptr png_get_io_ptr
5925 #define fn_png_check_sig png_check_sig
5926 #define fn_png_create_read_struct png_create_read_struct
5927 #define fn_png_create_info_struct png_create_info_struct
5928 #define fn_png_destroy_read_struct png_destroy_read_struct
5929 #define fn_png_set_read_fn png_set_read_fn
5930 #define fn_png_set_sig_bytes png_set_sig_bytes
5931 #define fn_png_read_info png_read_info
5932 #define fn_png_get_IHDR png_get_IHDR
5933 #define fn_png_get_valid png_get_valid
5934 #define fn_png_set_strip_16 png_set_strip_16
5935 #define fn_png_set_expand png_set_expand
5936 #define fn_png_set_gray_to_rgb png_set_gray_to_rgb
5937 #define fn_png_set_background png_set_background
5938 #define fn_png_get_bKGD png_get_bKGD
5939 #define fn_png_read_update_info png_read_update_info
5940 #define fn_png_get_channels png_get_channels
5941 #define fn_png_get_rowbytes png_get_rowbytes
5942 #define fn_png_read_image png_read_image
5943 #define fn_png_read_end png_read_end
5944 #define fn_png_error png_error
5946 #endif /* HAVE_NTGUI */
5948 /* Error and warning handlers installed when the PNG library
5952 my_png_error (png_ptr
, msg
)
5953 png_struct
*png_ptr
;
5956 xassert (png_ptr
!= NULL
);
5957 image_error ("PNG error: %s", build_string (msg
), Qnil
);
5958 longjmp (png_ptr
->jmpbuf
, 1);
5963 my_png_warning (png_ptr
, msg
)
5964 png_struct
*png_ptr
;
5967 xassert (png_ptr
!= NULL
);
5968 image_error ("PNG warning: %s", build_string (msg
), Qnil
);
5971 /* Memory source for PNG decoding. */
5973 struct png_memory_storage
5975 unsigned char *bytes
; /* The data */
5976 size_t len
; /* How big is it? */
5977 int index
; /* Where are we? */
5981 /* Function set as reader function when reading PNG image from memory.
5982 PNG_PTR is a pointer to the PNG control structure. Copy LENGTH
5983 bytes from the input to DATA. */
5986 png_read_from_memory (png_ptr
, data
, length
)
5987 png_structp png_ptr
;
5991 struct png_memory_storage
*tbr
5992 = (struct png_memory_storage
*) fn_png_get_io_ptr (png_ptr
);
5994 if (length
> tbr
->len
- tbr
->index
)
5995 fn_png_error (png_ptr
, "Read error");
5997 bcopy (tbr
->bytes
+ tbr
->index
, data
, length
);
5998 tbr
->index
= tbr
->index
+ length
;
6002 /* Function set as reader function when reading PNG image from a file.
6003 PNG_PTR is a pointer to the PNG control structure. Copy LENGTH
6004 bytes from the input to DATA. */
6007 png_read_from_file (png_ptr
, data
, length
)
6008 png_structp png_ptr
;
6012 FILE *fp
= (FILE *) fn_png_get_io_ptr (png_ptr
);
6014 if (fread (data
, 1, length
, fp
) < length
)
6015 fn_png_error (png_ptr
, "Read error");
6019 /* Load PNG image IMG for use on frame F. Value is non-zero if
6027 Lisp_Object file
, specified_file
;
6028 Lisp_Object specified_data
;
6030 XImagePtr ximg
, mask_img
= NULL
;
6031 struct gcpro gcpro1
;
6032 png_struct
*png_ptr
= NULL
;
6033 png_info
*info_ptr
= NULL
, *end_info
= NULL
;
6034 FILE *volatile fp
= NULL
;
6036 png_byte
* volatile pixels
= NULL
;
6037 png_byte
** volatile rows
= NULL
;
6038 png_uint_32 width
, height
;
6039 int bit_depth
, color_type
, interlace_type
;
6041 png_uint_32 row_bytes
;
6043 double screen_gamma
;
6044 struct png_memory_storage tbr
; /* Data to be read */
6046 /* Find out what file to load. */
6047 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
6048 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
6052 if (NILP (specified_data
))
6054 file
= x_find_image_file (specified_file
);
6055 if (!STRINGP (file
))
6057 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
6062 /* Open the image file. */
6063 fp
= fopen (SDATA (file
), "rb");
6066 image_error ("Cannot open image file `%s'", file
, Qnil
);
6072 /* Check PNG signature. */
6073 if (fread (sig
, 1, sizeof sig
, fp
) != sizeof sig
6074 || !fn_png_check_sig (sig
, sizeof sig
))
6076 image_error ("Not a PNG file: `%s'", file
, Qnil
);
6084 /* Read from memory. */
6085 tbr
.bytes
= SDATA (specified_data
);
6086 tbr
.len
= SBYTES (specified_data
);
6089 /* Check PNG signature. */
6090 if (tbr
.len
< sizeof sig
6091 || !fn_png_check_sig (tbr
.bytes
, sizeof sig
))
6093 image_error ("Not a PNG image: `%s'", img
->spec
, Qnil
);
6098 /* Need to skip past the signature. */
6099 tbr
.bytes
+= sizeof (sig
);
6102 /* Initialize read and info structs for PNG lib. Casting return
6103 value avoids a GCC warning on W32. */
6104 png_ptr
= (png_structp
)fn_png_create_read_struct (PNG_LIBPNG_VER_STRING
,
6109 if (fp
) fclose (fp
);
6114 /* Casting return value avoids a GCC warning on W32. */
6115 info_ptr
= (png_infop
)fn_png_create_info_struct (png_ptr
);
6118 fn_png_destroy_read_struct (&png_ptr
, NULL
, NULL
);
6119 if (fp
) fclose (fp
);
6124 /* Casting return value avoids a GCC warning on W32. */
6125 end_info
= (png_infop
)fn_png_create_info_struct (png_ptr
);
6128 fn_png_destroy_read_struct (&png_ptr
, &info_ptr
, NULL
);
6129 if (fp
) fclose (fp
);
6134 /* Set error jump-back. We come back here when the PNG library
6135 detects an error. */
6136 if (setjmp (png_ptr
->jmpbuf
))
6140 fn_png_destroy_read_struct (&png_ptr
, &info_ptr
, &end_info
);
6143 if (fp
) fclose (fp
);
6148 /* Read image info. */
6149 if (!NILP (specified_data
))
6150 fn_png_set_read_fn (png_ptr
, (void *) &tbr
, png_read_from_memory
);
6152 fn_png_set_read_fn (png_ptr
, (void *) fp
, png_read_from_file
);
6154 fn_png_set_sig_bytes (png_ptr
, sizeof sig
);
6155 fn_png_read_info (png_ptr
, info_ptr
);
6156 fn_png_get_IHDR (png_ptr
, info_ptr
, &width
, &height
, &bit_depth
, &color_type
,
6157 &interlace_type
, NULL
, NULL
);
6159 if (!check_image_size (f
, width
, height
))
6162 /* If image contains simply transparency data, we prefer to
6163 construct a clipping mask. */
6164 if (fn_png_get_valid (png_ptr
, info_ptr
, PNG_INFO_tRNS
))
6169 /* This function is easier to write if we only have to handle
6170 one data format: RGB or RGBA with 8 bits per channel. Let's
6171 transform other formats into that format. */
6173 /* Strip more than 8 bits per channel. */
6174 if (bit_depth
== 16)
6175 fn_png_set_strip_16 (png_ptr
);
6177 /* Expand data to 24 bit RGB, or 8 bit grayscale, with alpha channel
6179 fn_png_set_expand (png_ptr
);
6181 /* Convert grayscale images to RGB. */
6182 if (color_type
== PNG_COLOR_TYPE_GRAY
6183 || color_type
== PNG_COLOR_TYPE_GRAY_ALPHA
)
6184 fn_png_set_gray_to_rgb (png_ptr
);
6186 screen_gamma
= (f
->gamma
? 1 / f
->gamma
/ 0.45455 : 2.2);
6188 #if 0 /* Avoid double gamma correction for PNG images. */
6189 { /* Tell the PNG lib to handle gamma correction for us. */
6192 #if defined(PNG_READ_sRGB_SUPPORTED) || defined(PNG_WRITE_sRGB_SUPPORTED)
6193 if (png_get_sRGB (png_ptr
, info_ptr
, &intent
))
6194 /* The libpng documentation says this is right in this case. */
6195 png_set_gamma (png_ptr
, screen_gamma
, 0.45455);
6198 if (png_get_gAMA (png_ptr
, info_ptr
, &image_gamma
))
6199 /* Image contains gamma information. */
6200 png_set_gamma (png_ptr
, screen_gamma
, image_gamma
);
6202 /* Use the standard default for the image gamma. */
6203 png_set_gamma (png_ptr
, screen_gamma
, 0.45455);
6207 /* Handle alpha channel by combining the image with a background
6208 color. Do this only if a real alpha channel is supplied. For
6209 simple transparency, we prefer a clipping mask. */
6212 png_color_16
*image_bg
;
6213 Lisp_Object specified_bg
6214 = image_spec_value (img
->spec
, QCbackground
, NULL
);
6216 if (STRINGP (specified_bg
))
6217 /* The user specified `:background', use that. */
6219 /* W32 version incorrectly used COLORREF here!! ++kfs */
6221 if (x_defined_color (f
, SDATA (specified_bg
), &color
, 0))
6223 png_color_16 user_bg
;
6225 bzero (&user_bg
, sizeof user_bg
);
6226 user_bg
.red
= color
.red
>> 8;
6227 user_bg
.green
= color
.green
>> 8;
6228 user_bg
.blue
= color
.blue
>> 8;
6230 fn_png_set_background (png_ptr
, &user_bg
,
6231 PNG_BACKGROUND_GAMMA_SCREEN
, 0, 1.0);
6234 else if (fn_png_get_bKGD (png_ptr
, info_ptr
, &image_bg
))
6235 /* Image contains a background color with which to
6236 combine the image. */
6237 fn_png_set_background (png_ptr
, image_bg
,
6238 PNG_BACKGROUND_GAMMA_FILE
, 1, 1.0);
6241 /* Image does not contain a background color with which
6242 to combine the image data via an alpha channel. Use
6243 the frame's background instead. */
6244 #ifdef HAVE_X_WINDOWS
6246 png_color_16 frame_background
;
6248 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
6249 x_query_color (f
, &color
);
6251 bzero (&frame_background
, sizeof frame_background
);
6252 frame_background
.red
= color
.red
>> 8;
6253 frame_background
.green
= color
.green
>> 8;
6254 frame_background
.blue
= color
.blue
>> 8;
6255 #endif /* HAVE_X_WINDOWS */
6259 png_color_16 frame_background
;
6260 color
= FRAME_BACKGROUND_PIXEL (f
);
6261 #if 0 /* W32 TODO : Colormap support. */
6262 x_query_color (f
, &color
);
6264 bzero (&frame_background
, sizeof frame_background
);
6265 frame_background
.red
= GetRValue (color
);
6266 frame_background
.green
= GetGValue (color
);
6267 frame_background
.blue
= GetBValue (color
);
6268 #endif /* HAVE_NTGUI */
6271 unsigned long color
;
6272 png_color_16 frame_background
;
6273 color
= FRAME_BACKGROUND_PIXEL (f
);
6274 #if 0 /* MAC/W32 TODO : Colormap support. */
6275 x_query_color (f
, &color
);
6277 bzero (&frame_background
, sizeof frame_background
);
6278 frame_background
.red
= RED_FROM_ULONG (color
);
6279 frame_background
.green
= GREEN_FROM_ULONG (color
);
6280 frame_background
.blue
= BLUE_FROM_ULONG (color
);
6283 fn_png_set_background (png_ptr
, &frame_background
,
6284 PNG_BACKGROUND_GAMMA_SCREEN
, 0, 1.0);
6288 /* Update info structure. */
6289 fn_png_read_update_info (png_ptr
, info_ptr
);
6291 /* Get number of channels. Valid values are 1 for grayscale images
6292 and images with a palette, 2 for grayscale images with transparency
6293 information (alpha channel), 3 for RGB images, and 4 for RGB
6294 images with alpha channel, i.e. RGBA. If conversions above were
6295 sufficient we should only have 3 or 4 channels here. */
6296 channels
= fn_png_get_channels (png_ptr
, info_ptr
);
6297 xassert (channels
== 3 || channels
== 4);
6299 /* Number of bytes needed for one row of the image. */
6300 row_bytes
= fn_png_get_rowbytes (png_ptr
, info_ptr
);
6302 /* Allocate memory for the image. */
6303 pixels
= (png_byte
*) xmalloc (row_bytes
* height
* sizeof *pixels
);
6304 rows
= (png_byte
**) xmalloc (height
* sizeof *rows
);
6305 for (i
= 0; i
< height
; ++i
)
6306 rows
[i
] = pixels
+ i
* row_bytes
;
6308 /* Read the entire image. */
6309 fn_png_read_image (png_ptr
, rows
);
6310 fn_png_read_end (png_ptr
, info_ptr
);
6317 /* Create the X image and pixmap. */
6318 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
,
6322 /* Create an image and pixmap serving as mask if the PNG image
6323 contains an alpha channel. */
6326 && !x_create_x_image_and_pixmap (f
, width
, height
, 1,
6327 &mask_img
, &img
->mask
))
6329 x_destroy_x_image (ximg
);
6330 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->pixmap
);
6331 img
->pixmap
= NO_PIXMAP
;
6335 /* Fill the X image and mask from PNG data. */
6336 init_color_table ();
6338 for (y
= 0; y
< height
; ++y
)
6340 png_byte
*p
= rows
[y
];
6342 for (x
= 0; x
< width
; ++x
)
6349 XPutPixel (ximg
, x
, y
, lookup_rgb_color (f
, r
, g
, b
));
6350 /* An alpha channel, aka mask channel, associates variable
6351 transparency with an image. Where other image formats
6352 support binary transparency---fully transparent or fully
6353 opaque---PNG allows up to 254 levels of partial transparency.
6354 The PNG library implements partial transparency by combining
6355 the image with a specified background color.
6357 I'm not sure how to handle this here nicely: because the
6358 background on which the image is displayed may change, for
6359 real alpha channel support, it would be necessary to create
6360 a new image for each possible background.
6362 What I'm doing now is that a mask is created if we have
6363 boolean transparency information. Otherwise I'm using
6364 the frame's background color to combine the image with. */
6369 XPutPixel (mask_img
, x
, y
, *p
> 0 ? PIX_MASK_DRAW
: PIX_MASK_RETAIN
);
6375 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
6376 /* Set IMG's background color from the PNG image, unless the user
6380 if (fn_png_get_bKGD (png_ptr
, info_ptr
, &bg
))
6382 img
->background
= lookup_rgb_color (f
, bg
->red
, bg
->green
, bg
->blue
);
6383 img
->background_valid
= 1;
6387 #ifdef COLOR_TABLE_SUPPORT
6388 /* Remember colors allocated for this image. */
6389 img
->colors
= colors_in_color_table (&img
->ncolors
);
6390 free_color_table ();
6391 #endif /* COLOR_TABLE_SUPPORT */
6394 fn_png_destroy_read_struct (&png_ptr
, &info_ptr
, &end_info
);
6399 img
->height
= height
;
6401 /* Maybe fill in the background field while we have ximg handy.
6402 Casting avoids a GCC warning. */
6403 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
6405 /* Put the image into the pixmap, then free the X image and its buffer. */
6406 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
6407 x_destroy_x_image (ximg
);
6409 /* Same for the mask. */
6412 /* Fill in the background_transparent field while we have the
6413 mask handy. Casting avoids a GCC warning. */
6414 image_background_transparent (img
, f
, (XImagePtr_or_DC
)mask_img
);
6416 x_put_x_image (f
, mask_img
, img
->mask
, img
->width
, img
->height
);
6417 x_destroy_x_image (mask_img
);
6424 #else /* HAVE_PNG */
6433 if (MyCGImageCreateWithPNGDataProvider
)
6434 return image_load_quartz2d (f
, img
, 1);
6437 return image_load_quicktime (f
, img
, kQTFileTypePNG
);
6441 #endif /* !HAVE_PNG */
6445 /***********************************************************************
6447 ***********************************************************************/
6449 #if defined (HAVE_JPEG) || defined (MAC_OS)
6451 static int jpeg_image_p
P_ ((Lisp_Object object
));
6452 static int jpeg_load
P_ ((struct frame
*f
, struct image
*img
));
6454 /* The symbol `jpeg' identifying images of this type. */
6458 /* Indices of image specification fields in gs_format, below. */
6460 enum jpeg_keyword_index
6469 JPEG_HEURISTIC_MASK
,
6475 /* Vector of image_keyword structures describing the format
6476 of valid user-defined image specifications. */
6478 static struct image_keyword jpeg_format
[JPEG_LAST
] =
6480 {":type", IMAGE_SYMBOL_VALUE
, 1},
6481 {":data", IMAGE_STRING_VALUE
, 0},
6482 {":file", IMAGE_STRING_VALUE
, 0},
6483 {":ascent", IMAGE_ASCENT_VALUE
, 0},
6484 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
6485 {":relief", IMAGE_INTEGER_VALUE
, 0},
6486 {":conversions", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6487 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6488 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6489 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
6492 /* Structure describing the image type `jpeg'. */
6494 static struct image_type jpeg_type
=
6503 /* Return non-zero if OBJECT is a valid JPEG image specification. */
6506 jpeg_image_p (object
)
6509 struct image_keyword fmt
[JPEG_LAST
];
6511 bcopy (jpeg_format
, fmt
, sizeof fmt
);
6513 if (!parse_image_spec (object
, fmt
, JPEG_LAST
, Qjpeg
))
6516 /* Must specify either the :data or :file keyword. */
6517 return fmt
[JPEG_FILE
].count
+ fmt
[JPEG_DATA
].count
== 1;
6520 #endif /* HAVE_JPEG || MAC_OS */
6524 /* Work around a warning about HAVE_STDLIB_H being redefined in
6526 #ifdef HAVE_STDLIB_H
6527 #define HAVE_STDLIB_H_1
6528 #undef HAVE_STDLIB_H
6529 #endif /* HAVE_STLIB_H */
6531 #if defined (HAVE_NTGUI) && !defined (__WIN32__)
6532 /* In older releases of the jpeg library, jpeglib.h will define boolean
6533 differently depending on __WIN32__, so make sure it is defined. */
6537 #include <jpeglib.h>
6541 #ifdef HAVE_STLIB_H_1
6542 #define HAVE_STDLIB_H 1
6547 /* JPEG library details. */
6548 DEF_IMGLIB_FN (jpeg_CreateDecompress
);
6549 DEF_IMGLIB_FN (jpeg_start_decompress
);
6550 DEF_IMGLIB_FN (jpeg_finish_decompress
);
6551 DEF_IMGLIB_FN (jpeg_destroy_decompress
);
6552 DEF_IMGLIB_FN (jpeg_read_header
);
6553 DEF_IMGLIB_FN (jpeg_read_scanlines
);
6554 DEF_IMGLIB_FN (jpeg_std_error
);
6555 DEF_IMGLIB_FN (jpeg_resync_to_restart
);
6558 init_jpeg_functions (Lisp_Object libraries
)
6562 if (!(library
= w32_delayed_load (libraries
, Qjpeg
)))
6565 LOAD_IMGLIB_FN (library
, jpeg_finish_decompress
);
6566 LOAD_IMGLIB_FN (library
, jpeg_read_scanlines
);
6567 LOAD_IMGLIB_FN (library
, jpeg_start_decompress
);
6568 LOAD_IMGLIB_FN (library
, jpeg_read_header
);
6569 LOAD_IMGLIB_FN (library
, jpeg_CreateDecompress
);
6570 LOAD_IMGLIB_FN (library
, jpeg_destroy_decompress
);
6571 LOAD_IMGLIB_FN (library
, jpeg_std_error
);
6572 LOAD_IMGLIB_FN (library
, jpeg_resync_to_restart
);
6576 /* Wrapper since we can't directly assign the function pointer
6577 to another function pointer that was declared more completely easily. */
6579 jpeg_resync_to_restart_wrapper(cinfo
, desired
)
6580 j_decompress_ptr cinfo
;
6583 return fn_jpeg_resync_to_restart (cinfo
, desired
);
6588 #define fn_jpeg_CreateDecompress(a,b,c) jpeg_create_decompress(a)
6589 #define fn_jpeg_start_decompress jpeg_start_decompress
6590 #define fn_jpeg_finish_decompress jpeg_finish_decompress
6591 #define fn_jpeg_destroy_decompress jpeg_destroy_decompress
6592 #define fn_jpeg_read_header jpeg_read_header
6593 #define fn_jpeg_read_scanlines jpeg_read_scanlines
6594 #define fn_jpeg_std_error jpeg_std_error
6595 #define jpeg_resync_to_restart_wrapper jpeg_resync_to_restart
6597 #endif /* HAVE_NTGUI */
6599 struct my_jpeg_error_mgr
6601 struct jpeg_error_mgr pub
;
6602 jmp_buf setjmp_buffer
;
6607 my_error_exit (cinfo
)
6610 struct my_jpeg_error_mgr
*mgr
= (struct my_jpeg_error_mgr
*) cinfo
->err
;
6611 longjmp (mgr
->setjmp_buffer
, 1);
6615 /* Init source method for JPEG data source manager. Called by
6616 jpeg_read_header() before any data is actually read. See
6617 libjpeg.doc from the JPEG lib distribution. */
6620 our_common_init_source (cinfo
)
6621 j_decompress_ptr cinfo
;
6626 /* Method to terminate data source. Called by
6627 jpeg_finish_decompress() after all data has been processed. */
6630 our_common_term_source (cinfo
)
6631 j_decompress_ptr cinfo
;
6636 /* Fill input buffer method for JPEG data source manager. Called
6637 whenever more data is needed. We read the whole image in one step,
6638 so this only adds a fake end of input marker at the end. */
6641 our_memory_fill_input_buffer (cinfo
)
6642 j_decompress_ptr cinfo
;
6644 /* Insert a fake EOI marker. */
6645 struct jpeg_source_mgr
*src
= cinfo
->src
;
6646 static JOCTET buffer
[2];
6648 buffer
[0] = (JOCTET
) 0xFF;
6649 buffer
[1] = (JOCTET
) JPEG_EOI
;
6651 src
->next_input_byte
= buffer
;
6652 src
->bytes_in_buffer
= 2;
6657 /* Method to skip over NUM_BYTES bytes in the image data. CINFO->src
6658 is the JPEG data source manager. */
6661 our_memory_skip_input_data (cinfo
, num_bytes
)
6662 j_decompress_ptr cinfo
;
6665 struct jpeg_source_mgr
*src
= (struct jpeg_source_mgr
*) cinfo
->src
;
6669 if (num_bytes
> src
->bytes_in_buffer
)
6670 ERREXIT (cinfo
, JERR_INPUT_EOF
);
6672 src
->bytes_in_buffer
-= num_bytes
;
6673 src
->next_input_byte
+= num_bytes
;
6678 /* Set up the JPEG lib for reading an image from DATA which contains
6679 LEN bytes. CINFO is the decompression info structure created for
6680 reading the image. */
6683 jpeg_memory_src (cinfo
, data
, len
)
6684 j_decompress_ptr cinfo
;
6688 struct jpeg_source_mgr
*src
;
6690 if (cinfo
->src
== NULL
)
6692 /* First time for this JPEG object? */
6693 cinfo
->src
= (struct jpeg_source_mgr
*)
6694 (*cinfo
->mem
->alloc_small
) ((j_common_ptr
) cinfo
, JPOOL_PERMANENT
,
6695 sizeof (struct jpeg_source_mgr
));
6696 src
= (struct jpeg_source_mgr
*) cinfo
->src
;
6697 src
->next_input_byte
= data
;
6700 src
= (struct jpeg_source_mgr
*) cinfo
->src
;
6701 src
->init_source
= our_common_init_source
;
6702 src
->fill_input_buffer
= our_memory_fill_input_buffer
;
6703 src
->skip_input_data
= our_memory_skip_input_data
;
6704 src
->resync_to_restart
= jpeg_resync_to_restart_wrapper
; /* Use default method. */
6705 src
->term_source
= our_common_term_source
;
6706 src
->bytes_in_buffer
= len
;
6707 src
->next_input_byte
= data
;
6711 struct jpeg_stdio_mgr
6713 struct jpeg_source_mgr mgr
;
6720 /* Size of buffer to read JPEG from file.
6721 Not too big, as we want to use alloc_small. */
6722 #define JPEG_STDIO_BUFFER_SIZE 8192
6725 /* Fill input buffer method for JPEG data source manager. Called
6726 whenever more data is needed. The data is read from a FILE *. */
6729 our_stdio_fill_input_buffer (cinfo
)
6730 j_decompress_ptr cinfo
;
6732 struct jpeg_stdio_mgr
*src
;
6734 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6739 bytes
= fread (src
->buffer
, 1, JPEG_STDIO_BUFFER_SIZE
, src
->file
);
6741 src
->mgr
.bytes_in_buffer
= bytes
;
6744 WARNMS (cinfo
, JWRN_JPEG_EOF
);
6746 src
->buffer
[0] = (JOCTET
) 0xFF;
6747 src
->buffer
[1] = (JOCTET
) JPEG_EOI
;
6748 src
->mgr
.bytes_in_buffer
= 2;
6750 src
->mgr
.next_input_byte
= src
->buffer
;
6757 /* Method to skip over NUM_BYTES bytes in the image data. CINFO->src
6758 is the JPEG data source manager. */
6761 our_stdio_skip_input_data (cinfo
, num_bytes
)
6762 j_decompress_ptr cinfo
;
6765 struct jpeg_stdio_mgr
*src
;
6766 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6768 while (num_bytes
> 0 && !src
->finished
)
6770 if (num_bytes
<= src
->mgr
.bytes_in_buffer
)
6772 src
->mgr
.bytes_in_buffer
-= num_bytes
;
6773 src
->mgr
.next_input_byte
+= num_bytes
;
6778 num_bytes
-= src
->mgr
.bytes_in_buffer
;
6779 src
->mgr
.bytes_in_buffer
= 0;
6780 src
->mgr
.next_input_byte
= NULL
;
6782 our_stdio_fill_input_buffer (cinfo
);
6788 /* Set up the JPEG lib for reading an image from a FILE *.
6789 CINFO is the decompression info structure created for
6790 reading the image. */
6793 jpeg_file_src (cinfo
, fp
)
6794 j_decompress_ptr cinfo
;
6797 struct jpeg_stdio_mgr
*src
;
6799 if (cinfo
->src
!= NULL
)
6800 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6803 /* First time for this JPEG object? */
6804 cinfo
->src
= (struct jpeg_source_mgr
*)
6805 (*cinfo
->mem
->alloc_small
) ((j_common_ptr
) cinfo
, JPOOL_PERMANENT
,
6806 sizeof (struct jpeg_stdio_mgr
));
6807 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6808 src
->buffer
= (JOCTET
*)
6809 (*cinfo
->mem
->alloc_small
) ((j_common_ptr
) cinfo
, JPOOL_PERMANENT
,
6810 JPEG_STDIO_BUFFER_SIZE
);
6815 src
->mgr
.init_source
= our_common_init_source
;
6816 src
->mgr
.fill_input_buffer
= our_stdio_fill_input_buffer
;
6817 src
->mgr
.skip_input_data
= our_stdio_skip_input_data
;
6818 src
->mgr
.resync_to_restart
= jpeg_resync_to_restart_wrapper
; /* Use default method. */
6819 src
->mgr
.term_source
= our_common_term_source
;
6820 src
->mgr
.bytes_in_buffer
= 0;
6821 src
->mgr
.next_input_byte
= NULL
;
6825 /* Load image IMG for use on frame F. Patterned after example.c
6826 from the JPEG lib. */
6833 struct jpeg_decompress_struct cinfo
;
6834 struct my_jpeg_error_mgr mgr
;
6835 Lisp_Object file
, specified_file
;
6836 Lisp_Object specified_data
;
6837 FILE * volatile fp
= NULL
;
6839 int row_stride
, x
, y
;
6840 XImagePtr ximg
= NULL
;
6842 unsigned long *colors
;
6844 struct gcpro gcpro1
;
6846 /* Open the JPEG file. */
6847 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
6848 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
6852 if (NILP (specified_data
))
6854 file
= x_find_image_file (specified_file
);
6855 if (!STRINGP (file
))
6857 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
6862 fp
= fopen (SDATA (file
), "rb");
6865 image_error ("Cannot open `%s'", file
, Qnil
);
6871 /* Customize libjpeg's error handling to call my_error_exit when an
6872 error is detected. This function will perform a longjmp.
6873 Casting return value avoids a GCC warning on W32. */
6874 cinfo
.err
= (struct jpeg_error_mgr
*)fn_jpeg_std_error (&mgr
.pub
);
6875 mgr
.pub
.error_exit
= my_error_exit
;
6877 if ((rc
= setjmp (mgr
.setjmp_buffer
)) != 0)
6881 /* Called from my_error_exit. Display a JPEG error. */
6882 char buffer
[JMSG_LENGTH_MAX
];
6883 cinfo
.err
->format_message ((j_common_ptr
) &cinfo
, buffer
);
6884 image_error ("Error reading JPEG image `%s': %s", img
->spec
,
6885 build_string (buffer
));
6888 /* Close the input file and destroy the JPEG object. */
6890 fclose ((FILE *) fp
);
6891 fn_jpeg_destroy_decompress (&cinfo
);
6893 /* If we already have an XImage, free that. */
6894 x_destroy_x_image (ximg
);
6896 /* Free pixmap and colors. */
6897 x_clear_image (f
, img
);
6903 /* Create the JPEG decompression object. Let it read from fp.
6904 Read the JPEG image header. */
6905 fn_jpeg_CreateDecompress (&cinfo
, JPEG_LIB_VERSION
, sizeof (cinfo
));
6907 if (NILP (specified_data
))
6908 jpeg_file_src (&cinfo
, (FILE *) fp
);
6910 jpeg_memory_src (&cinfo
, SDATA (specified_data
),
6911 SBYTES (specified_data
));
6913 fn_jpeg_read_header (&cinfo
, 1);
6915 /* Customize decompression so that color quantization will be used.
6916 Start decompression. */
6917 cinfo
.quantize_colors
= 1;
6918 fn_jpeg_start_decompress (&cinfo
);
6919 width
= img
->width
= cinfo
.output_width
;
6920 height
= img
->height
= cinfo
.output_height
;
6922 if (!check_image_size (f
, width
, height
))
6924 image_error ("Invalid image size", Qnil
, Qnil
);
6925 longjmp (mgr
.setjmp_buffer
, 2);
6928 /* Create X image and pixmap. */
6929 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
6930 longjmp (mgr
.setjmp_buffer
, 2);
6932 /* Allocate colors. When color quantization is used,
6933 cinfo.actual_number_of_colors has been set with the number of
6934 colors generated, and cinfo.colormap is a two-dimensional array
6935 of color indices in the range 0..cinfo.actual_number_of_colors.
6936 No more than 255 colors will be generated. */
6940 if (cinfo
.out_color_components
> 2)
6941 ir
= 0, ig
= 1, ib
= 2;
6942 else if (cinfo
.out_color_components
> 1)
6943 ir
= 0, ig
= 1, ib
= 0;
6945 ir
= 0, ig
= 0, ib
= 0;
6947 /* Use the color table mechanism because it handles colors that
6948 cannot be allocated nicely. Such colors will be replaced with
6949 a default color, and we don't have to care about which colors
6950 can be freed safely, and which can't. */
6951 init_color_table ();
6952 colors
= (unsigned long *) alloca (cinfo
.actual_number_of_colors
6955 for (i
= 0; i
< cinfo
.actual_number_of_colors
; ++i
)
6957 /* Multiply RGB values with 255 because X expects RGB values
6958 in the range 0..0xffff. */
6959 int r
= cinfo
.colormap
[ir
][i
] << 8;
6960 int g
= cinfo
.colormap
[ig
][i
] << 8;
6961 int b
= cinfo
.colormap
[ib
][i
] << 8;
6962 colors
[i
] = lookup_rgb_color (f
, r
, g
, b
);
6965 #ifdef COLOR_TABLE_SUPPORT
6966 /* Remember those colors actually allocated. */
6967 img
->colors
= colors_in_color_table (&img
->ncolors
);
6968 free_color_table ();
6969 #endif /* COLOR_TABLE_SUPPORT */
6973 row_stride
= width
* cinfo
.output_components
;
6974 buffer
= cinfo
.mem
->alloc_sarray ((j_common_ptr
) &cinfo
, JPOOL_IMAGE
,
6976 for (y
= 0; y
< height
; ++y
)
6978 fn_jpeg_read_scanlines (&cinfo
, buffer
, 1);
6979 for (x
= 0; x
< cinfo
.output_width
; ++x
)
6980 XPutPixel (ximg
, x
, y
, colors
[buffer
[0][x
]]);
6984 fn_jpeg_finish_decompress (&cinfo
);
6985 fn_jpeg_destroy_decompress (&cinfo
);
6987 fclose ((FILE *) fp
);
6989 /* Maybe fill in the background field while we have ximg handy. */
6990 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
6991 /* Casting avoids a GCC warning. */
6992 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
6994 /* Put the image into the pixmap. */
6995 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
6996 x_destroy_x_image (ximg
);
7001 #else /* HAVE_JPEG */
7010 return image_load_quartz2d (f
, img
, 0);
7012 return image_load_quicktime (f
, img
, kQTFileTypeJPEG
);
7017 #endif /* !HAVE_JPEG */
7021 /***********************************************************************
7023 ***********************************************************************/
7025 #if defined (HAVE_TIFF) || defined (MAC_OS)
7027 static int tiff_image_p
P_ ((Lisp_Object object
));
7028 static int tiff_load
P_ ((struct frame
*f
, struct image
*img
));
7030 /* The symbol `tiff' identifying images of this type. */
7034 /* Indices of image specification fields in tiff_format, below. */
7036 enum tiff_keyword_index
7045 TIFF_HEURISTIC_MASK
,
7051 /* Vector of image_keyword structures describing the format
7052 of valid user-defined image specifications. */
7054 static struct image_keyword tiff_format
[TIFF_LAST
] =
7056 {":type", IMAGE_SYMBOL_VALUE
, 1},
7057 {":data", IMAGE_STRING_VALUE
, 0},
7058 {":file", IMAGE_STRING_VALUE
, 0},
7059 {":ascent", IMAGE_ASCENT_VALUE
, 0},
7060 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
7061 {":relief", IMAGE_INTEGER_VALUE
, 0},
7062 {":conversions", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7063 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7064 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7065 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
7068 /* Structure describing the image type `tiff'. */
7070 static struct image_type tiff_type
=
7079 /* Return non-zero if OBJECT is a valid TIFF image specification. */
7082 tiff_image_p (object
)
7085 struct image_keyword fmt
[TIFF_LAST
];
7086 bcopy (tiff_format
, fmt
, sizeof fmt
);
7088 if (!parse_image_spec (object
, fmt
, TIFF_LAST
, Qtiff
))
7091 /* Must specify either the :data or :file keyword. */
7092 return fmt
[TIFF_FILE
].count
+ fmt
[TIFF_DATA
].count
== 1;
7095 #endif /* HAVE_TIFF || MAC_OS */
7103 /* TIFF library details. */
7104 DEF_IMGLIB_FN (TIFFSetErrorHandler
);
7105 DEF_IMGLIB_FN (TIFFSetWarningHandler
);
7106 DEF_IMGLIB_FN (TIFFOpen
);
7107 DEF_IMGLIB_FN (TIFFClientOpen
);
7108 DEF_IMGLIB_FN (TIFFGetField
);
7109 DEF_IMGLIB_FN (TIFFReadRGBAImage
);
7110 DEF_IMGLIB_FN (TIFFClose
);
7113 init_tiff_functions (Lisp_Object libraries
)
7117 if (!(library
= w32_delayed_load (libraries
, Qtiff
)))
7120 LOAD_IMGLIB_FN (library
, TIFFSetErrorHandler
);
7121 LOAD_IMGLIB_FN (library
, TIFFSetWarningHandler
);
7122 LOAD_IMGLIB_FN (library
, TIFFOpen
);
7123 LOAD_IMGLIB_FN (library
, TIFFClientOpen
);
7124 LOAD_IMGLIB_FN (library
, TIFFGetField
);
7125 LOAD_IMGLIB_FN (library
, TIFFReadRGBAImage
);
7126 LOAD_IMGLIB_FN (library
, TIFFClose
);
7132 #define fn_TIFFSetErrorHandler TIFFSetErrorHandler
7133 #define fn_TIFFSetWarningHandler TIFFSetWarningHandler
7134 #define fn_TIFFOpen TIFFOpen
7135 #define fn_TIFFClientOpen TIFFClientOpen
7136 #define fn_TIFFGetField TIFFGetField
7137 #define fn_TIFFReadRGBAImage TIFFReadRGBAImage
7138 #define fn_TIFFClose TIFFClose
7140 #endif /* HAVE_NTGUI */
7143 /* Reading from a memory buffer for TIFF images Based on the PNG
7144 memory source, but we have to provide a lot of extra functions.
7147 We really only need to implement read and seek, but I am not
7148 convinced that the TIFF library is smart enough not to destroy
7149 itself if we only hand it the function pointers we need to
7154 unsigned char *bytes
;
7161 tiff_read_from_memory (data
, buf
, size
)
7166 tiff_memory_source
*src
= (tiff_memory_source
*) data
;
7168 if (size
> src
->len
- src
->index
)
7170 bcopy (src
->bytes
+ src
->index
, buf
, size
);
7176 tiff_write_from_memory (data
, buf
, size
)
7185 tiff_seek_in_memory (data
, off
, whence
)
7190 tiff_memory_source
*src
= (tiff_memory_source
*) data
;
7195 case SEEK_SET
: /* Go from beginning of source. */
7199 case SEEK_END
: /* Go from end of source. */
7200 idx
= src
->len
+ off
;
7203 case SEEK_CUR
: /* Go from current position. */
7204 idx
= src
->index
+ off
;
7207 default: /* Invalid `whence'. */
7211 if (idx
> src
->len
|| idx
< 0)
7219 tiff_close_memory (data
)
7227 tiff_mmap_memory (data
, pbase
, psize
)
7232 /* It is already _IN_ memory. */
7237 tiff_unmap_memory (data
, base
, size
)
7242 /* We don't need to do this. */
7246 tiff_size_of_memory (data
)
7249 return ((tiff_memory_source
*) data
)->len
;
7254 tiff_error_handler (title
, format
, ap
)
7255 const char *title
, *format
;
7261 len
= sprintf (buf
, "TIFF error: %s ", title
);
7262 vsprintf (buf
+ len
, format
, ap
);
7263 add_to_log (buf
, Qnil
, Qnil
);
7268 tiff_warning_handler (title
, format
, ap
)
7269 const char *title
, *format
;
7275 len
= sprintf (buf
, "TIFF warning: %s ", title
);
7276 vsprintf (buf
+ len
, format
, ap
);
7277 add_to_log (buf
, Qnil
, Qnil
);
7281 /* Load TIFF image IMG for use on frame F. Value is non-zero if
7289 Lisp_Object file
, specified_file
;
7290 Lisp_Object specified_data
;
7292 int width
, height
, x
, y
;
7296 struct gcpro gcpro1
;
7297 tiff_memory_source memsrc
;
7299 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
7300 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
7304 fn_TIFFSetErrorHandler (tiff_error_handler
);
7305 fn_TIFFSetWarningHandler (tiff_warning_handler
);
7307 if (NILP (specified_data
))
7309 /* Read from a file */
7310 file
= x_find_image_file (specified_file
);
7311 if (!STRINGP (file
))
7313 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
7318 /* Try to open the image file. Casting return value avoids a
7319 GCC warning on W32. */
7320 tiff
= (TIFF
*)fn_TIFFOpen (SDATA (file
), "r");
7323 image_error ("Cannot open `%s'", file
, Qnil
);
7330 /* Memory source! */
7331 memsrc
.bytes
= SDATA (specified_data
);
7332 memsrc
.len
= SBYTES (specified_data
);
7335 /* Casting return value avoids a GCC warning on W32. */
7336 tiff
= (TIFF
*)fn_TIFFClientOpen ("memory_source", "r", &memsrc
,
7337 (TIFFReadWriteProc
) tiff_read_from_memory
,
7338 (TIFFReadWriteProc
) tiff_write_from_memory
,
7339 tiff_seek_in_memory
,
7341 tiff_size_of_memory
,
7347 image_error ("Cannot open memory source for `%s'", img
->spec
, Qnil
);
7353 /* Get width and height of the image, and allocate a raster buffer
7354 of width x height 32-bit values. */
7355 fn_TIFFGetField (tiff
, TIFFTAG_IMAGEWIDTH
, &width
);
7356 fn_TIFFGetField (tiff
, TIFFTAG_IMAGELENGTH
, &height
);
7358 if (!check_image_size (f
, width
, height
))
7360 image_error ("Invalid image size", Qnil
, Qnil
);
7365 buf
= (uint32
*) xmalloc (width
* height
* sizeof *buf
);
7367 rc
= fn_TIFFReadRGBAImage (tiff
, width
, height
, buf
, 0);
7368 fn_TIFFClose (tiff
);
7371 image_error ("Error reading TIFF image `%s'", img
->spec
, Qnil
);
7377 /* Create the X image and pixmap. */
7378 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
7385 /* Initialize the color table. */
7386 init_color_table ();
7388 /* Process the pixel raster. Origin is in the lower-left corner. */
7389 for (y
= 0; y
< height
; ++y
)
7391 uint32
*row
= buf
+ y
* width
;
7393 for (x
= 0; x
< width
; ++x
)
7395 uint32 abgr
= row
[x
];
7396 int r
= TIFFGetR (abgr
) << 8;
7397 int g
= TIFFGetG (abgr
) << 8;
7398 int b
= TIFFGetB (abgr
) << 8;
7399 XPutPixel (ximg
, x
, height
- 1 - y
, lookup_rgb_color (f
, r
, g
, b
));
7403 #ifdef COLOR_TABLE_SUPPORT
7404 /* Remember the colors allocated for the image. Free the color table. */
7405 img
->colors
= colors_in_color_table (&img
->ncolors
);
7406 free_color_table ();
7407 #endif /* COLOR_TABLE_SUPPORT */
7410 img
->height
= height
;
7412 /* Maybe fill in the background field while we have ximg handy. */
7413 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
7414 /* Casting avoids a GCC warning on W32. */
7415 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
7417 /* Put the image into the pixmap, then free the X image and its buffer. */
7418 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
7419 x_destroy_x_image (ximg
);
7426 #else /* HAVE_TIFF */
7434 return image_load_quicktime (f
, img
, kQTFileTypeTIFF
);
7438 #endif /* !HAVE_TIFF */
7442 /***********************************************************************
7444 ***********************************************************************/
7446 #if defined (HAVE_GIF) || defined (MAC_OS)
7448 static int gif_image_p
P_ ((Lisp_Object object
));
7449 static int gif_load
P_ ((struct frame
*f
, struct image
*img
));
7451 /* The symbol `gif' identifying images of this type. */
7455 /* Indices of image specification fields in gif_format, below. */
7457 enum gif_keyword_index
7473 /* Vector of image_keyword structures describing the format
7474 of valid user-defined image specifications. */
7476 static struct image_keyword gif_format
[GIF_LAST
] =
7478 {":type", IMAGE_SYMBOL_VALUE
, 1},
7479 {":data", IMAGE_STRING_VALUE
, 0},
7480 {":file", IMAGE_STRING_VALUE
, 0},
7481 {":ascent", IMAGE_ASCENT_VALUE
, 0},
7482 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
7483 {":relief", IMAGE_INTEGER_VALUE
, 0},
7484 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7485 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7486 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7487 {":image", IMAGE_NON_NEGATIVE_INTEGER_VALUE
, 0},
7488 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
7491 /* Structure describing the image type `gif'. */
7493 static struct image_type gif_type
=
7502 /* Return non-zero if OBJECT is a valid GIF image specification. */
7505 gif_image_p (object
)
7508 struct image_keyword fmt
[GIF_LAST
];
7509 bcopy (gif_format
, fmt
, sizeof fmt
);
7511 if (!parse_image_spec (object
, fmt
, GIF_LAST
, Qgif
))
7514 /* Must specify either the :data or :file keyword. */
7515 return fmt
[GIF_FILE
].count
+ fmt
[GIF_DATA
].count
== 1;
7518 #endif /* HAVE_GIF || MAC_OS */
7522 #if defined (HAVE_NTGUI) || defined (MAC_OS)
7523 /* winuser.h might define DrawText to DrawTextA or DrawTextW.
7524 Undefine before redefining to avoid a preprocessor warning. */
7528 /* avoid conflict with QuickdrawText.h */
7529 #define DrawText gif_DrawText
7530 #include <gif_lib.h>
7533 #else /* HAVE_NTGUI || MAC_OS */
7535 #include <gif_lib.h>
7537 #endif /* HAVE_NTGUI || MAC_OS */
7542 /* GIF library details. */
7543 DEF_IMGLIB_FN (DGifCloseFile
);
7544 DEF_IMGLIB_FN (DGifSlurp
);
7545 DEF_IMGLIB_FN (DGifOpen
);
7546 DEF_IMGLIB_FN (DGifOpenFileName
);
7549 init_gif_functions (Lisp_Object libraries
)
7553 if (!(library
= w32_delayed_load (libraries
, Qgif
)))
7556 LOAD_IMGLIB_FN (library
, DGifCloseFile
);
7557 LOAD_IMGLIB_FN (library
, DGifSlurp
);
7558 LOAD_IMGLIB_FN (library
, DGifOpen
);
7559 LOAD_IMGLIB_FN (library
, DGifOpenFileName
);
7565 #define fn_DGifCloseFile DGifCloseFile
7566 #define fn_DGifSlurp DGifSlurp
7567 #define fn_DGifOpen DGifOpen
7568 #define fn_DGifOpenFileName DGifOpenFileName
7570 #endif /* HAVE_NTGUI */
7572 /* Reading a GIF image from memory
7573 Based on the PNG memory stuff to a certain extent. */
7577 unsigned char *bytes
;
7583 /* Make the current memory source available to gif_read_from_memory.
7584 It's done this way because not all versions of libungif support
7585 a UserData field in the GifFileType structure. */
7586 static gif_memory_source
*current_gif_memory_src
;
7589 gif_read_from_memory (file
, buf
, len
)
7594 gif_memory_source
*src
= current_gif_memory_src
;
7596 if (len
> src
->len
- src
->index
)
7599 bcopy (src
->bytes
+ src
->index
, buf
, len
);
7605 /* Load GIF image IMG for use on frame F. Value is non-zero if
7613 Lisp_Object file
, specified_file
;
7614 Lisp_Object specified_data
;
7615 int rc
, width
, height
, x
, y
, i
;
7617 ColorMapObject
*gif_color_map
;
7618 unsigned long pixel_colors
[256];
7620 struct gcpro gcpro1
;
7622 int ino
, image_left
, image_top
, image_width
, image_height
;
7623 gif_memory_source memsrc
;
7624 unsigned char *raster
;
7626 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
7627 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
7631 if (NILP (specified_data
))
7633 file
= x_find_image_file (specified_file
);
7634 if (!STRINGP (file
))
7636 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
7641 /* Open the GIF file. Casting return value avoids a GCC warning
7643 gif
= (GifFileType
*)fn_DGifOpenFileName (SDATA (file
));
7646 image_error ("Cannot open `%s'", file
, Qnil
);
7653 /* Read from memory! */
7654 current_gif_memory_src
= &memsrc
;
7655 memsrc
.bytes
= SDATA (specified_data
);
7656 memsrc
.len
= SBYTES (specified_data
);
7659 /* Casting return value avoids a GCC warning on W32. */
7660 gif
= (GifFileType
*)fn_DGifOpen(&memsrc
, gif_read_from_memory
);
7663 image_error ("Cannot open memory source `%s'", img
->spec
, Qnil
);
7669 /* Before reading entire contents, check the declared image size. */
7670 if (!check_image_size (f
, gif
->SWidth
, gif
->SHeight
))
7672 image_error ("Invalid image size", Qnil
, Qnil
);
7673 fn_DGifCloseFile (gif
);
7678 /* Read entire contents. */
7679 rc
= fn_DGifSlurp (gif
);
7680 if (rc
== GIF_ERROR
)
7682 image_error ("Error reading `%s'", img
->spec
, Qnil
);
7683 fn_DGifCloseFile (gif
);
7688 image
= image_spec_value (img
->spec
, QCindex
, NULL
);
7689 ino
= INTEGERP (image
) ? XFASTINT (image
) : 0;
7690 if (ino
>= gif
->ImageCount
)
7692 image_error ("Invalid image number `%s' in image `%s'",
7694 fn_DGifCloseFile (gif
);
7699 image_top
= gif
->SavedImages
[ino
].ImageDesc
.Top
;
7700 image_left
= gif
->SavedImages
[ino
].ImageDesc
.Left
;
7701 image_width
= gif
->SavedImages
[ino
].ImageDesc
.Width
;
7702 image_height
= gif
->SavedImages
[ino
].ImageDesc
.Height
;
7704 width
= img
->width
= max (gif
->SWidth
,
7705 max (gif
->Image
.Left
+ gif
->Image
.Width
,
7706 image_left
+ image_width
));
7707 height
= img
->height
= max (gif
->SHeight
,
7708 max (gif
->Image
.Top
+ gif
->Image
.Height
,
7709 image_top
+ image_height
));
7711 if (!check_image_size (f
, width
, height
))
7713 image_error ("Invalid image size", Qnil
, Qnil
);
7714 fn_DGifCloseFile (gif
);
7719 /* Create the X image and pixmap. */
7720 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
7722 fn_DGifCloseFile (gif
);
7727 /* Allocate colors. */
7728 gif_color_map
= gif
->SavedImages
[ino
].ImageDesc
.ColorMap
;
7730 gif_color_map
= gif
->SColorMap
;
7731 init_color_table ();
7732 bzero (pixel_colors
, sizeof pixel_colors
);
7734 for (i
= 0; i
< gif_color_map
->ColorCount
; ++i
)
7736 int r
= gif_color_map
->Colors
[i
].Red
<< 8;
7737 int g
= gif_color_map
->Colors
[i
].Green
<< 8;
7738 int b
= gif_color_map
->Colors
[i
].Blue
<< 8;
7739 pixel_colors
[i
] = lookup_rgb_color (f
, r
, g
, b
);
7742 #ifdef COLOR_TABLE_SUPPORT
7743 img
->colors
= colors_in_color_table (&img
->ncolors
);
7744 free_color_table ();
7745 #endif /* COLOR_TABLE_SUPPORT */
7747 /* Clear the part of the screen image that are not covered by
7748 the image from the GIF file. Full animated GIF support
7749 requires more than can be done here (see the gif89 spec,
7750 disposal methods). Let's simply assume that the part
7751 not covered by a sub-image is in the frame's background color. */
7752 for (y
= 0; y
< image_top
; ++y
)
7753 for (x
= 0; x
< width
; ++x
)
7754 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7756 for (y
= image_top
+ image_height
; y
< height
; ++y
)
7757 for (x
= 0; x
< width
; ++x
)
7758 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7760 for (y
= image_top
; y
< image_top
+ image_height
; ++y
)
7762 for (x
= 0; x
< image_left
; ++x
)
7763 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7764 for (x
= image_left
+ image_width
; x
< width
; ++x
)
7765 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7768 /* Read the GIF image into the X image. We use a local variable
7769 `raster' here because RasterBits below is a char *, and invites
7770 problems with bytes >= 0x80. */
7771 raster
= (unsigned char *) gif
->SavedImages
[ino
].RasterBits
;
7773 if (gif
->SavedImages
[ino
].ImageDesc
.Interlace
)
7775 static int interlace_start
[] = {0, 4, 2, 1};
7776 static int interlace_increment
[] = {8, 8, 4, 2};
7778 int row
= interlace_start
[0];
7782 for (y
= 0; y
< image_height
; y
++)
7784 if (row
>= image_height
)
7786 row
= interlace_start
[++pass
];
7787 while (row
>= image_height
)
7788 row
= interlace_start
[++pass
];
7791 for (x
= 0; x
< image_width
; x
++)
7793 int i
= raster
[(y
* image_width
) + x
];
7794 XPutPixel (ximg
, x
+ image_left
, row
+ image_top
,
7798 row
+= interlace_increment
[pass
];
7803 for (y
= 0; y
< image_height
; ++y
)
7804 for (x
= 0; x
< image_width
; ++x
)
7806 int i
= raster
[y
* image_width
+ x
];
7807 XPutPixel (ximg
, x
+ image_left
, y
+ image_top
, pixel_colors
[i
]);
7811 fn_DGifCloseFile (gif
);
7813 /* Maybe fill in the background field while we have ximg handy. */
7814 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
7815 /* Casting avoids a GCC warning. */
7816 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
7818 /* Put the image into the pixmap, then free the X image and its buffer. */
7819 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
7820 x_destroy_x_image (ximg
);
7826 #else /* !HAVE_GIF */
7834 Lisp_Object specified_file
, file
;
7835 Lisp_Object specified_data
;
7837 Boolean graphic_p
, movie_p
, prefer_graphic_p
;
7845 Lisp_Object specified_bg
;
7855 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
7856 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
7858 /* Animated gifs use QuickTime Movie Toolbox. So initialize it here. */
7861 if (NILP (specified_data
))
7863 /* Read from a file */
7867 err
= find_image_fsspec (specified_file
, &file
, &fss
);
7871 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
7876 err
= CanQuickTimeOpenFile (&fss
, kQTFileTypeGIF
, 0,
7877 &graphic_p
, &movie_p
, &prefer_graphic_p
, 0);
7881 if (!graphic_p
&& !movie_p
)
7883 if (prefer_graphic_p
)
7884 return image_load_qt_1 (f
, img
, kQTFileTypeGIF
, &fss
, NULL
);
7885 err
= OpenMovieFile (&fss
, &refnum
, fsRdPerm
);
7888 err
= NewMovieFromFile (&movie
, refnum
, NULL
, NULL
, 0, NULL
);
7889 CloseMovieFile (refnum
);
7892 image_error ("Error reading `%s'", file
, Qnil
);
7898 /* Memory source! */
7900 long file_type_atom
[3];
7902 err
= PtrToHand (SDATA (specified_data
), &dh
, SBYTES (specified_data
));
7905 image_error ("Cannot allocate data handle for `%s'",
7910 file_type_atom
[0] = EndianU32_NtoB (sizeof (long) * 3);
7911 file_type_atom
[1] = EndianU32_NtoB (kDataRefExtensionMacOSFileType
);
7912 file_type_atom
[2] = EndianU32_NtoB (kQTFileTypeGIF
);
7913 err
= PtrToHand (&dh
, &dref
, sizeof (Handle
));
7916 err
= PtrAndHand ("\p", dref
, 1);
7918 err
= PtrAndHand (file_type_atom
, dref
, sizeof (long) * 3);
7921 image_error ("Cannot allocate handle data ref for `%s'", img
->spec
, Qnil
);
7924 err
= CanQuickTimeOpenDataRef (dref
, HandleDataHandlerSubType
, &graphic_p
,
7925 &movie_p
, &prefer_graphic_p
, 0);
7929 if (!graphic_p
&& !movie_p
)
7931 if (prefer_graphic_p
)
7935 DisposeHandle (dref
);
7936 success_p
= image_load_qt_1 (f
, img
, kQTFileTypeGIF
, NULL
, dh
);
7940 err
= NewMovieFromDataRef (&movie
, 0, NULL
, dref
,
7941 HandleDataHandlerSubType
);
7942 DisposeHandle (dref
);
7947 image
= image_spec_value (img
->spec
, QCindex
, NULL
);
7948 ino
= INTEGERP (image
) ? XFASTINT (image
) : 0;
7949 track
= GetMovieIndTrack (movie
, 1);
7950 media
= GetTrackMedia (track
);
7951 nsamples
= GetMediaSampleCount (media
);
7952 if (ino
>= nsamples
)
7954 image_error ("Invalid image number `%s' in image `%s'",
7959 specified_bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
7960 if (!STRINGP (specified_bg
) ||
7961 !mac_defined_color (f
, SDATA (specified_bg
), &color
, 0))
7963 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
7964 color
.red
= RED16_FROM_ULONG (color
.pixel
);
7965 color
.green
= GREEN16_FROM_ULONG (color
.pixel
);
7966 color
.blue
= BLUE16_FROM_ULONG (color
.pixel
);
7968 GetMovieBox (movie
, &rect
);
7969 width
= img
->width
= rect
.right
- rect
.left
;
7970 height
= img
->height
= rect
.bottom
- rect
.top
;
7971 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
7974 GetGWorld (&old_port
, &old_gdh
);
7975 SetGWorld (ximg
, NULL
);
7976 bg_color
.red
= color
.red
;
7977 bg_color
.green
= color
.green
;
7978 bg_color
.blue
= color
.blue
;
7979 RGBBackColor (&bg_color
);
7980 SetGWorld (old_port
, old_gdh
);
7981 SetMovieActive (movie
, 1);
7982 SetMovieGWorld (movie
, ximg
, NULL
);
7983 SampleNumToMediaTime (media
, ino
+ 1, &time
, NULL
);
7984 SetMovieTimeValue (movie
, time
);
7985 MoviesTask (movie
, 0L);
7986 DisposeTrackMedia (media
);
7987 DisposeMovieTrack (track
);
7988 DisposeMovie (movie
);
7991 /* Maybe fill in the background field while we have ximg handy. */
7992 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
7993 IMAGE_BACKGROUND (img
, f
, ximg
);
7995 /* Put the image into the pixmap. */
7996 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
7997 x_destroy_x_image (ximg
);
8001 image_error ("Cannot open `%s'", file
, Qnil
);
8004 DisposeTrackMedia (media
);
8006 DisposeMovieTrack (track
);
8008 DisposeMovie (movie
);
8015 #endif /* HAVE_GIF */
8019 /***********************************************************************
8021 ***********************************************************************/
8023 #ifdef HAVE_X_WINDOWS
8024 #define HAVE_GHOSTSCRIPT 1
8025 #endif /* HAVE_X_WINDOWS */
8027 /* The symbol `postscript' identifying images of this type. */
8029 Lisp_Object Qpostscript
;
8031 #ifdef HAVE_GHOSTSCRIPT
8033 static int gs_image_p
P_ ((Lisp_Object object
));
8034 static int gs_load
P_ ((struct frame
*f
, struct image
*img
));
8035 static void gs_clear_image
P_ ((struct frame
*f
, struct image
*img
));
8037 /* Keyword symbols. */
8039 Lisp_Object QCloader
, QCbounding_box
, QCpt_width
, QCpt_height
;
8041 /* Indices of image specification fields in gs_format, below. */
8043 enum gs_keyword_index
8061 /* Vector of image_keyword structures describing the format
8062 of valid user-defined image specifications. */
8064 static struct image_keyword gs_format
[GS_LAST
] =
8066 {":type", IMAGE_SYMBOL_VALUE
, 1},
8067 {":pt-width", IMAGE_POSITIVE_INTEGER_VALUE
, 1},
8068 {":pt-height", IMAGE_POSITIVE_INTEGER_VALUE
, 1},
8069 {":file", IMAGE_STRING_VALUE
, 1},
8070 {":loader", IMAGE_FUNCTION_VALUE
, 0},
8071 {":bounding-box", IMAGE_DONT_CHECK_VALUE_TYPE
, 1},
8072 {":ascent", IMAGE_ASCENT_VALUE
, 0},
8073 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
8074 {":relief", IMAGE_INTEGER_VALUE
, 0},
8075 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8076 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8077 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8078 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
8081 /* Structure describing the image type `ghostscript'. */
8083 static struct image_type gs_type
=
8093 /* Free X resources of Ghostscript image IMG which is used on frame F. */
8096 gs_clear_image (f
, img
)
8100 /* IMG->data.ptr_val may contain a recorded colormap. */
8101 xfree (img
->data
.ptr_val
);
8102 x_clear_image (f
, img
);
8106 /* Return non-zero if OBJECT is a valid Ghostscript image
8113 struct image_keyword fmt
[GS_LAST
];
8117 bcopy (gs_format
, fmt
, sizeof fmt
);
8119 if (!parse_image_spec (object
, fmt
, GS_LAST
, Qpostscript
))
8122 /* Bounding box must be a list or vector containing 4 integers. */
8123 tem
= fmt
[GS_BOUNDING_BOX
].value
;
8126 for (i
= 0; i
< 4; ++i
, tem
= XCDR (tem
))
8127 if (!CONSP (tem
) || !INTEGERP (XCAR (tem
)))
8132 else if (VECTORP (tem
))
8134 if (XVECTOR (tem
)->size
!= 4)
8136 for (i
= 0; i
< 4; ++i
)
8137 if (!INTEGERP (XVECTOR (tem
)->contents
[i
]))
8147 /* Load Ghostscript image IMG for use on frame F. Value is non-zero
8156 Lisp_Object window_and_pixmap_id
= Qnil
, loader
, pt_height
, pt_width
;
8157 struct gcpro gcpro1
, gcpro2
;
8159 double in_width
, in_height
;
8160 Lisp_Object pixel_colors
= Qnil
;
8162 /* Compute pixel size of pixmap needed from the given size in the
8163 image specification. Sizes in the specification are in pt. 1 pt
8164 = 1/72 in, xdpi and ydpi are stored in the frame's X display
8166 pt_width
= image_spec_value (img
->spec
, QCpt_width
, NULL
);
8167 in_width
= XFASTINT (pt_width
) / 72.0;
8168 img
->width
= in_width
* FRAME_X_DISPLAY_INFO (f
)->resx
;
8169 pt_height
= image_spec_value (img
->spec
, QCpt_height
, NULL
);
8170 in_height
= XFASTINT (pt_height
) / 72.0;
8171 img
->height
= in_height
* FRAME_X_DISPLAY_INFO (f
)->resy
;
8173 if (!check_image_size (f
, img
->width
, img
->height
))
8175 image_error ("Invalid image size", Qnil
, Qnil
);
8179 /* Create the pixmap. */
8180 xassert (img
->pixmap
== NO_PIXMAP
);
8182 /* Only W32 version did BLOCK_INPUT here. ++kfs */
8184 img
->pixmap
= XCreatePixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
8185 img
->width
, img
->height
,
8186 DefaultDepthOfScreen (FRAME_X_SCREEN (f
)));
8191 image_error ("Unable to create pixmap for `%s'", img
->spec
, Qnil
);
8195 /* Call the loader to fill the pixmap. It returns a process object
8196 if successful. We do not record_unwind_protect here because
8197 other places in redisplay like calling window scroll functions
8198 don't either. Let the Lisp loader use `unwind-protect' instead. */
8199 GCPRO2 (window_and_pixmap_id
, pixel_colors
);
8201 sprintf (buffer
, "%lu %lu",
8202 (unsigned long) FRAME_X_WINDOW (f
),
8203 (unsigned long) img
->pixmap
);
8204 window_and_pixmap_id
= build_string (buffer
);
8206 sprintf (buffer
, "%lu %lu",
8207 FRAME_FOREGROUND_PIXEL (f
),
8208 FRAME_BACKGROUND_PIXEL (f
));
8209 pixel_colors
= build_string (buffer
);
8211 XSETFRAME (frame
, f
);
8212 loader
= image_spec_value (img
->spec
, QCloader
, NULL
);
8214 loader
= intern ("gs-load-image");
8216 img
->data
.lisp_val
= call6 (loader
, frame
, img
->spec
,
8217 make_number (img
->width
),
8218 make_number (img
->height
),
8219 window_and_pixmap_id
,
8222 return PROCESSP (img
->data
.lisp_val
);
8226 /* Kill the Ghostscript process that was started to fill PIXMAP on
8227 frame F. Called from XTread_socket when receiving an event
8228 telling Emacs that Ghostscript has finished drawing. */
8231 x_kill_gs_process (pixmap
, f
)
8235 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
8239 /* Find the image containing PIXMAP. */
8240 for (i
= 0; i
< c
->used
; ++i
)
8241 if (c
->images
[i
]->pixmap
== pixmap
)
8244 /* Should someone in between have cleared the image cache, for
8245 instance, give up. */
8249 /* Kill the GS process. We should have found PIXMAP in the image
8250 cache and its image should contain a process object. */
8252 xassert (PROCESSP (img
->data
.lisp_val
));
8253 Fkill_process (img
->data
.lisp_val
, Qnil
);
8254 img
->data
.lisp_val
= Qnil
;
8256 #if defined (HAVE_X_WINDOWS)
8258 /* On displays with a mutable colormap, figure out the colors
8259 allocated for the image by looking at the pixels of an XImage for
8261 class = FRAME_X_VISUAL (f
)->class;
8262 if (class != StaticColor
&& class != StaticGray
&& class != TrueColor
)
8268 /* Try to get an XImage for img->pixmep. */
8269 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
8270 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
8275 /* Initialize the color table. */
8276 init_color_table ();
8278 /* For each pixel of the image, look its color up in the
8279 color table. After having done so, the color table will
8280 contain an entry for each color used by the image. */
8281 for (y
= 0; y
< img
->height
; ++y
)
8282 for (x
= 0; x
< img
->width
; ++x
)
8284 unsigned long pixel
= XGetPixel (ximg
, x
, y
);
8285 lookup_pixel_color (f
, pixel
);
8288 /* Record colors in the image. Free color table and XImage. */
8289 #ifdef COLOR_TABLE_SUPPORT
8290 img
->colors
= colors_in_color_table (&img
->ncolors
);
8291 free_color_table ();
8293 XDestroyImage (ximg
);
8295 #if 0 /* This doesn't seem to be the case. If we free the colors
8296 here, we get a BadAccess later in x_clear_image when
8297 freeing the colors. */
8298 /* We have allocated colors once, but Ghostscript has also
8299 allocated colors on behalf of us. So, to get the
8300 reference counts right, free them once. */
8302 x_free_colors (f
, img
->colors
, img
->ncolors
);
8306 image_error ("Cannot get X image of `%s'; colors will not be freed",
8311 #endif /* HAVE_X_WINDOWS */
8313 /* Now that we have the pixmap, compute mask and transform the
8314 image if requested. */
8316 postprocess_image (f
, img
);
8320 #endif /* HAVE_GHOSTSCRIPT */
8323 /***********************************************************************
8325 ***********************************************************************/
8329 DEFUN ("imagep", Fimagep
, Simagep
, 1, 1, 0,
8330 doc
: /* Value is non-nil if SPEC is a valid image specification. */)
8334 return valid_image_p (spec
) ? Qt
: Qnil
;
8338 DEFUN ("lookup-image", Flookup_image
, Slookup_image
, 1, 1, 0, "")
8344 if (valid_image_p (spec
))
8345 id
= lookup_image (SELECTED_FRAME (), spec
);
8348 return make_number (id
);
8351 #endif /* GLYPH_DEBUG != 0 */
8354 /***********************************************************************
8356 ***********************************************************************/
8359 /* Image types that rely on external libraries are loaded dynamically
8360 if the library is available. */
8361 #define CHECK_LIB_AVAILABLE(image_type, init_lib_fn, libraries) \
8362 define_image_type (image_type, init_lib_fn (libraries))
8364 #define CHECK_LIB_AVAILABLE(image_type, init_lib_fn, libraries) \
8365 define_image_type (image_type, 1)
8366 #endif /* HAVE_NTGUI */
8368 DEFUN ("init-image-library", Finit_image_library
, Sinit_image_library
, 2, 2, 0,
8369 doc
: /* Initialize image library implementing image type TYPE.
8370 Return non-nil if TYPE is a supported image type.
8372 Image types pbm and xbm are prebuilt; other types are loaded here.
8373 Libraries to load are specified in alist LIBRARIES (usually, the value
8374 of `image-library-alist', which see). */)
8376 Lisp_Object type
, libraries
;
8380 /* Don't try to reload the library. */
8381 tested
= Fassq (type
, Vimage_type_cache
);
8383 return XCDR (tested
);
8385 #if defined (HAVE_XPM) || defined (MAC_OS)
8386 if (EQ (type
, Qxpm
))
8387 return CHECK_LIB_AVAILABLE (&xpm_type
, init_xpm_functions
, libraries
);
8390 #if defined (HAVE_JPEG) || defined (MAC_OS)
8391 if (EQ (type
, Qjpeg
))
8392 return CHECK_LIB_AVAILABLE (&jpeg_type
, init_jpeg_functions
, libraries
);
8395 #if defined (HAVE_TIFF) || defined (MAC_OS)
8396 if (EQ (type
, Qtiff
))
8397 return CHECK_LIB_AVAILABLE (&tiff_type
, init_tiff_functions
, libraries
);
8400 #if defined (HAVE_GIF) || defined (MAC_OS)
8401 if (EQ (type
, Qgif
))
8402 return CHECK_LIB_AVAILABLE (&gif_type
, init_gif_functions
, libraries
);
8405 #if defined (HAVE_PNG) || defined (MAC_OS)
8406 if (EQ (type
, Qpng
))
8407 return CHECK_LIB_AVAILABLE (&png_type
, init_png_functions
, libraries
);
8410 #ifdef HAVE_GHOSTSCRIPT
8411 if (EQ (type
, Qpostscript
))
8412 return CHECK_LIB_AVAILABLE (&gs_type
, init_gs_functions
, libraries
);
8415 /* If the type is not recognized, avoid testing it ever again. */
8416 CACHE_IMAGE_TYPE (type
, Qnil
);
8423 extern Lisp_Object Qrisky_local_variable
; /* Syms_of_xdisp has already run. */
8425 /* Initialize this only once, since that's what we do with Vimage_types
8426 and they are supposed to be in sync. Initializing here gives correct
8427 operation on GNU/Linux of calling dump-emacs after loading some images. */
8430 /* Must be defined now becase we're going to update it below, while
8431 defining the supported image types. */
8432 DEFVAR_LISP ("image-types", &Vimage_types
,
8433 doc
: /* List of potentially supported image types.
8434 Each element of the list is a symbol for a image type, like 'jpeg or 'png.
8435 To check whether it is really supported, use `image-type-available-p'. */);
8436 Vimage_types
= Qnil
;
8438 DEFVAR_LISP ("image-library-alist", &Vimage_library_alist
,
8439 doc
: /* Alist of image types vs external libraries needed to display them.
8441 Each element is a list (IMAGE-TYPE LIBRARY...), where the car is a symbol
8442 representing a supported image type, and the rest are strings giving
8443 alternate filenames for the corresponding external libraries.
8445 Emacs tries to load the libraries in the order they appear on the
8446 list; if none is loaded, the running session of Emacs won't
8447 support the image type. Types 'pbm and 'xbm don't need to be
8448 listed; they're always supported. */);
8449 Vimage_library_alist
= Qnil
;
8450 Fput (intern ("image-library-alist"), Qrisky_local_variable
, Qt
);
8452 DEFVAR_LISP ("max-image-size", &Vmax_image_size
,
8453 doc
: /* Maximum size of images.
8454 Emacs will not load an image into memory if its pixel width or
8455 pixel height exceeds this limit.
8457 If the value is an integer, it directly specifies the maximum
8458 image height and width, measured in pixels. If it is a floating
8459 point number, it specifies the maximum image height and width
8460 as a ratio to the frame height and width. If the value is
8461 non-numeric, there is no explicit limit on the size of images. */);
8462 Vmax_image_size
= make_float (MAX_IMAGE_SIZE
);
8464 Vimage_type_cache
= Qnil
;
8465 staticpro (&Vimage_type_cache
);
8467 Qpbm
= intern ("pbm");
8469 ADD_IMAGE_TYPE(Qpbm
);
8471 Qxbm
= intern ("xbm");
8473 ADD_IMAGE_TYPE(Qxbm
);
8475 define_image_type (&xbm_type
, 1);
8476 define_image_type (&pbm_type
, 1);
8478 QCascent
= intern (":ascent");
8479 staticpro (&QCascent
);
8480 QCmargin
= intern (":margin");
8481 staticpro (&QCmargin
);
8482 QCrelief
= intern (":relief");
8483 staticpro (&QCrelief
);
8484 QCconversion
= intern (":conversion");
8485 staticpro (&QCconversion
);
8486 QCcolor_symbols
= intern (":color-symbols");
8487 staticpro (&QCcolor_symbols
);
8488 QCheuristic_mask
= intern (":heuristic-mask");
8489 staticpro (&QCheuristic_mask
);
8490 QCindex
= intern (":index");
8491 staticpro (&QCindex
);
8492 QCmatrix
= intern (":matrix");
8493 staticpro (&QCmatrix
);
8494 QCcolor_adjustment
= intern (":color-adjustment");
8495 staticpro (&QCcolor_adjustment
);
8496 QCmask
= intern (":mask");
8497 staticpro (&QCmask
);
8499 Qlaplace
= intern ("laplace");
8500 staticpro (&Qlaplace
);
8501 Qemboss
= intern ("emboss");
8502 staticpro (&Qemboss
);
8503 Qedge_detection
= intern ("edge-detection");
8504 staticpro (&Qedge_detection
);
8505 Qheuristic
= intern ("heuristic");
8506 staticpro (&Qheuristic
);
8508 Qpostscript
= intern ("postscript");
8509 staticpro (&Qpostscript
);
8510 #ifdef HAVE_GHOSTSCRIPT
8511 ADD_IMAGE_TYPE(Qpostscript
);
8512 QCloader
= intern (":loader");
8513 staticpro (&QCloader
);
8514 QCbounding_box
= intern (":bounding-box");
8515 staticpro (&QCbounding_box
);
8516 QCpt_width
= intern (":pt-width");
8517 staticpro (&QCpt_width
);
8518 QCpt_height
= intern (":pt-height");
8519 staticpro (&QCpt_height
);
8520 #endif /* HAVE_GHOSTSCRIPT */
8522 #if defined (HAVE_XPM) || defined (MAC_OS)
8523 Qxpm
= intern ("xpm");
8525 ADD_IMAGE_TYPE(Qxpm
);
8528 #if defined (HAVE_JPEG) || defined (MAC_OS)
8529 Qjpeg
= intern ("jpeg");
8531 ADD_IMAGE_TYPE(Qjpeg
);
8534 #if defined (HAVE_TIFF) || defined (MAC_OS)
8535 Qtiff
= intern ("tiff");
8537 ADD_IMAGE_TYPE(Qtiff
);
8540 #if defined (HAVE_GIF) || defined (MAC_OS)
8541 Qgif
= intern ("gif");
8543 ADD_IMAGE_TYPE(Qgif
);
8546 #if defined (HAVE_PNG) || defined (MAC_OS)
8547 Qpng
= intern ("png");
8549 ADD_IMAGE_TYPE(Qpng
);
8552 defsubr (&Sinit_image_library
);
8553 defsubr (&Sclear_image_cache
);
8554 defsubr (&Simage_size
);
8555 defsubr (&Simage_mask_p
);
8559 defsubr (&Slookup_image
);
8562 DEFVAR_BOOL ("cross-disabled-images", &cross_disabled_images
,
8563 doc
: /* Non-nil means always draw a cross over disabled images.
8564 Disabled images are those having an `:conversion disabled' property.
8565 A cross is always drawn on black & white displays. */);
8566 cross_disabled_images
= 0;
8568 DEFVAR_LISP ("x-bitmap-file-path", &Vx_bitmap_file_path
,
8569 doc
: /* List of directories to search for window system bitmap files. */);
8570 Vx_bitmap_file_path
= decode_env_path ((char *) 0, PATH_BITMAPS
);
8572 DEFVAR_LISP ("image-cache-eviction-delay", &Vimage_cache_eviction_delay
,
8573 doc
: /* Time after which cached images are removed from the cache.
8574 When an image has not been displayed this many seconds, remove it
8575 from the image cache. Value must be an integer or nil with nil
8576 meaning don't clear the cache. */);
8577 Vimage_cache_eviction_delay
= make_number (30 * 60);
8583 #if defined (MAC_OSX) && TARGET_API_MAC_CARBON
8584 init_image_func_pointer ();
8588 /* arch-tag: 123c2a5e-14a8-4c53-ab95-af47d7db49b9
8589 (do not change this comment) */