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 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"
46 #include <sys/types.h>
49 #define COLOR_TABLE_SUPPORT 1
51 typedef struct x_bitmap_record Bitmap_Record
;
52 #define GET_PIXEL(ximg, x, y) XGetPixel(ximg, x, y)
53 #define NO_PIXMAP None
55 #define RGB_PIXEL_COLOR unsigned long
57 #define PIX_MASK_RETAIN 0
58 #define PIX_MASK_DRAW 1
59 #endif /* HAVE_X_WINDOWS */
65 /* W32_TODO : Color tables on W32. */
66 #undef COLOR_TABLE_SUPPORT
68 typedef struct w32_bitmap_record Bitmap_Record
;
69 #define GET_PIXEL(ximg, x, y) GetPixel(ximg, x, y)
72 #define RGB_PIXEL_COLOR COLORREF
74 #define PIX_MASK_RETAIN 0
75 #define PIX_MASK_DRAW 1
77 #define FRAME_X_VISUAL(f) FRAME_X_DISPLAY_INFO (f)->visual
78 #define x_defined_color w32_defined_color
79 #define DefaultDepthOfScreen(screen) (one_w32_display_info.n_cbits)
80 #endif /* HAVE_NTGUI */
88 #include <sys/param.h>
90 #if TARGET_API_MAC_CARBON
92 #include <QuickTime/QuickTime.h>
93 #else /* not MAC_OSX */
94 #include <QuickTime.h>
95 #endif /* not MAC_OSX */
96 #else /* not TARGET_API_MAC_CARBON */
99 #include <TextUtils.h>
100 #include <ImageCompression.h>
101 #include <QuickTimeComponents.h>
102 #endif /* not TARGET_API_MAC_CARBON */
104 /* MAC_TODO : Color tables on Mac. */
105 #undef COLOR_TABLE_SUPPORT
107 #define ZPixmap 0 /* arbitrary */
108 typedef struct mac_bitmap_record Bitmap_Record
;
110 #define GET_PIXEL(ximg, x, y) XGetPixel(ximg, x, y)
113 #define RGB_PIXEL_COLOR unsigned long
115 /* A black pixel in a mask bitmap/pixmap means ``draw a source
116 pixel''. A white pixel means ``retain the current pixel''. */
117 #define PIX_MASK_DRAW RGB_TO_ULONG(0,0,0)
118 #define PIX_MASK_RETAIN RGB_TO_ULONG(255,255,255)
120 #define FRAME_X_VISUAL(f) FRAME_X_DISPLAY_INFO (f)->visual
121 #define x_defined_color mac_defined_color
122 #define DefaultDepthOfScreen(screen) (one_mac_display_info.n_planes)
123 #define XDrawLine(display, w, gc, x1, y1, x2, y2) \
124 mac_draw_line_to_pixmap(display, w, gc, x1, y1, x2, y2)
129 /* Search path for bitmap files. */
131 Lisp_Object Vx_bitmap_file_path
;
134 static void x_disable_image
P_ ((struct frame
*, struct image
*));
135 static void x_edge_detection
P_ ((struct frame
*, struct image
*, Lisp_Object
,
138 static void init_color_table
P_ ((void));
139 static unsigned long lookup_rgb_color
P_ ((struct frame
*f
, int r
, int g
, int b
));
140 #ifdef COLOR_TABLE_SUPPORT
141 static void free_color_table
P_ ((void));
142 static unsigned long *colors_in_color_table
P_ ((int *n
));
143 static unsigned long lookup_pixel_color
P_ ((struct frame
*f
, unsigned long p
));
146 /* Code to deal with bitmaps. Bitmaps are referenced by their bitmap
147 id, which is just an int that this section returns. Bitmaps are
148 reference counted so they can be shared among frames.
150 Bitmap indices are guaranteed to be > 0, so a negative number can
151 be used to indicate no bitmap.
153 If you use x_create_bitmap_from_data, then you must keep track of
154 the bitmaps yourself. That is, creating a bitmap from the same
155 data more than once will not be caught. */
160 XGetImage (display
, pixmap
, x
, y
, width
, height
, plane_mask
, format
)
161 Display
*display
; /* not used */
163 int x
, y
; /* not used */
164 unsigned int width
, height
; /* not used */
165 unsigned long plane_mask
; /* not used */
166 int format
; /* not used */
169 xassert (x
== 0 && y
== 0);
172 SetRect (&ri
, 0, 0, width
, height
);
173 xassert (EqualRect (&ri
, GetPixBounds (GetGWorldPixMap (pixmap
), &rp
)));
175 xassert (! (pixelsLocked
& GetPixelsState (GetGWorldPixMap (pixmap
))));
178 LockPixels (GetGWorldPixMap (pixmap
));
184 XPutPixel (ximage
, x
, y
, pixel
)
189 PixMapHandle pixmap
= GetGWorldPixMap (ximage
);
190 short depth
= GetPixDepth (pixmap
);
194 char *base_addr
= GetPixBaseAddr (pixmap
);
195 short row_bytes
= GetPixRowBytes (pixmap
);
197 ((unsigned long *) (base_addr
+ y
* row_bytes
))[x
] = pixel
;
201 char *base_addr
= GetPixBaseAddr (pixmap
);
202 short row_bytes
= GetPixRowBytes (pixmap
);
204 if (pixel
== PIX_MASK_DRAW
)
205 base_addr
[y
* row_bytes
+ x
/ 8] |= (1 << 7) >> (x
& 7);
207 base_addr
[y
* row_bytes
+ x
/ 8] &= ~((1 << 7) >> (x
& 7));
215 GetGWorld (&old_port
, &old_gdh
);
216 SetGWorld (ximage
, NULL
);
218 color
.red
= RED16_FROM_ULONG (pixel
);
219 color
.green
= GREEN16_FROM_ULONG (pixel
);
220 color
.blue
= BLUE16_FROM_ULONG (pixel
);
222 SetCPixel (x
, y
, &color
);
224 SetGWorld (old_port
, old_gdh
);
229 XGetPixel (ximage
, x
, y
)
233 PixMapHandle pixmap
= GetGWorldPixMap (ximage
);
234 short depth
= GetPixDepth (pixmap
);
238 char *base_addr
= GetPixBaseAddr (pixmap
);
239 short row_bytes
= GetPixRowBytes (pixmap
);
241 return ((unsigned long *) (base_addr
+ y
* row_bytes
))[x
];
245 char *base_addr
= GetPixBaseAddr (pixmap
);
246 short row_bytes
= GetPixRowBytes (pixmap
);
248 if (base_addr
[y
* row_bytes
+ x
/ 8] & (1 << (~x
& 7)))
249 return PIX_MASK_DRAW
;
251 return PIX_MASK_RETAIN
;
259 GetGWorld (&old_port
, &old_gdh
);
260 SetGWorld (ximage
, NULL
);
262 GetCPixel (x
, y
, &color
);
264 SetGWorld (old_port
, old_gdh
);
265 return RGB_TO_ULONG (color
.red
>> 8, color
.green
>> 8, color
.blue
>> 8);
273 UnlockPixels (GetGWorldPixMap (ximg
));
278 /* Functions to access the contents of a bitmap, given an id. */
281 x_bitmap_height (f
, id
)
285 return FRAME_X_DISPLAY_INFO (f
)->bitmaps
[id
- 1].height
;
289 x_bitmap_width (f
, id
)
293 return FRAME_X_DISPLAY_INFO (f
)->bitmaps
[id
- 1].width
;
296 #if defined (HAVE_X_WINDOWS) || defined (HAVE_NTGUI)
298 x_bitmap_pixmap (f
, id
)
302 return (int) FRAME_X_DISPLAY_INFO (f
)->bitmaps
[id
- 1].pixmap
;
306 #ifdef HAVE_X_WINDOWS
308 x_bitmap_mask (f
, id
)
312 return FRAME_X_DISPLAY_INFO (f
)->bitmaps
[id
- 1].mask
;
316 /* Allocate a new bitmap record. Returns index of new record. */
319 x_allocate_bitmap_record (f
)
322 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
325 if (dpyinfo
->bitmaps
== NULL
)
327 dpyinfo
->bitmaps_size
= 10;
329 = (Bitmap_Record
*) xmalloc (dpyinfo
->bitmaps_size
* sizeof (Bitmap_Record
));
330 dpyinfo
->bitmaps_last
= 1;
334 if (dpyinfo
->bitmaps_last
< dpyinfo
->bitmaps_size
)
335 return ++dpyinfo
->bitmaps_last
;
337 for (i
= 0; i
< dpyinfo
->bitmaps_size
; ++i
)
338 if (dpyinfo
->bitmaps
[i
].refcount
== 0)
341 dpyinfo
->bitmaps_size
*= 2;
343 = (Bitmap_Record
*) xrealloc (dpyinfo
->bitmaps
,
344 dpyinfo
->bitmaps_size
* sizeof (Bitmap_Record
));
345 return ++dpyinfo
->bitmaps_last
;
348 /* Add one reference to the reference count of the bitmap with id ID. */
351 x_reference_bitmap (f
, id
)
355 ++FRAME_X_DISPLAY_INFO (f
)->bitmaps
[id
- 1].refcount
;
358 /* Create a bitmap for frame F from a HEIGHT x WIDTH array of bits at BITS. */
361 x_create_bitmap_from_data (f
, bits
, width
, height
)
364 unsigned int width
, height
;
366 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
369 #ifdef HAVE_X_WINDOWS
371 bitmap
= XCreateBitmapFromData (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
372 bits
, width
, height
);
375 #endif /* HAVE_X_WINDOWS */
379 bitmap
= CreateBitmap (width
, height
,
380 FRAME_X_DISPLAY_INFO (XFRAME (frame
))->n_planes
,
381 FRAME_X_DISPLAY_INFO (XFRAME (frame
))->n_cbits
,
385 #endif /* HAVE_NTGUI */
388 /* MAC_TODO: for now fail if width is not mod 16 (toolbox requires it) */
393 id
= x_allocate_bitmap_record (f
);
395 dpyinfo
->bitmaps
[id
- 1].bitmap_data
= (char *) xmalloc (height
* width
);
396 if (! dpyinfo
->bitmaps
[id
- 1].bitmap_data
)
398 bcopy (bits
, dpyinfo
->bitmaps
[id
- 1].bitmap_data
, height
* width
);
401 dpyinfo
->bitmaps
[id
- 1].file
= NULL
;
402 dpyinfo
->bitmaps
[id
- 1].height
= height
;
403 dpyinfo
->bitmaps
[id
- 1].width
= width
;
404 dpyinfo
->bitmaps
[id
- 1].refcount
= 1;
406 #ifdef HAVE_X_WINDOWS
407 dpyinfo
->bitmaps
[id
- 1].pixmap
= bitmap
;
408 dpyinfo
->bitmaps
[id
- 1].have_mask
= 0;
409 dpyinfo
->bitmaps
[id
- 1].depth
= 1;
410 #endif /* HAVE_X_WINDOWS */
413 dpyinfo
->bitmaps
[id
- 1].pixmap
= bitmap
;
414 dpyinfo
->bitmaps
[id
- 1].hinst
= NULL
;
415 dpyinfo
->bitmaps
[id
- 1].depth
= 1;
416 #endif /* HAVE_NTGUI */
421 /* Create bitmap from file FILE for frame F. */
424 x_create_bitmap_from_file (f
, file
)
429 return -1; /* MAC_TODO : bitmap support */
433 return -1; /* W32_TODO : bitmap support */
434 #endif /* HAVE_NTGUI */
436 #ifdef HAVE_X_WINDOWS
437 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
438 unsigned int width
, height
;
440 int xhot
, yhot
, result
, id
;
445 /* Look for an existing bitmap with the same name. */
446 for (id
= 0; id
< dpyinfo
->bitmaps_last
; ++id
)
448 if (dpyinfo
->bitmaps
[id
].refcount
449 && dpyinfo
->bitmaps
[id
].file
450 && !strcmp (dpyinfo
->bitmaps
[id
].file
, (char *) SDATA (file
)))
452 ++dpyinfo
->bitmaps
[id
].refcount
;
457 /* Search bitmap-file-path for the file, if appropriate. */
458 fd
= openp (Vx_bitmap_file_path
, file
, Qnil
, &found
, Qnil
);
463 filename
= (char *) SDATA (found
);
465 result
= XReadBitmapFile (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
466 filename
, &width
, &height
, &bitmap
, &xhot
, &yhot
);
467 if (result
!= BitmapSuccess
)
470 id
= x_allocate_bitmap_record (f
);
471 dpyinfo
->bitmaps
[id
- 1].pixmap
= bitmap
;
472 dpyinfo
->bitmaps
[id
- 1].have_mask
= 0;
473 dpyinfo
->bitmaps
[id
- 1].refcount
= 1;
474 dpyinfo
->bitmaps
[id
- 1].file
= (char *) xmalloc (SBYTES (file
) + 1);
475 dpyinfo
->bitmaps
[id
- 1].depth
= 1;
476 dpyinfo
->bitmaps
[id
- 1].height
= height
;
477 dpyinfo
->bitmaps
[id
- 1].width
= width
;
478 strcpy (dpyinfo
->bitmaps
[id
- 1].file
, SDATA (file
));
481 #endif /* HAVE_X_WINDOWS */
487 Free_Bitmap_Record (dpyinfo
, bm
)
488 Display_Info
*dpyinfo
;
491 #ifdef HAVE_X_WINDOWS
492 XFreePixmap (dpyinfo
->display
, bm
->pixmap
);
494 XFreePixmap (dpyinfo
->display
, bm
->mask
);
495 #endif /* HAVE_X_WINDOWS */
498 DeleteObject (bm
->pixmap
);
499 #endif /* HAVE_NTGUI */
502 xfree (bm
->bitmap_data
); /* Added ++kfs */
503 bm
->bitmap_data
= NULL
;
513 /* Remove reference to bitmap with id number ID. */
516 x_destroy_bitmap (f
, id
)
520 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
524 Bitmap_Record
*bm
= &dpyinfo
->bitmaps
[id
- 1];
526 if (--bm
->refcount
== 0)
529 Free_Bitmap_Record (dpyinfo
, bm
);
535 /* Free all the bitmaps for the display specified by DPYINFO. */
538 x_destroy_all_bitmaps (dpyinfo
)
539 Display_Info
*dpyinfo
;
542 Bitmap_Record
*bm
= dpyinfo
->bitmaps
;
544 for (i
= 0; i
< dpyinfo
->bitmaps_last
; i
++, bm
++)
545 if (bm
->refcount
> 0)
546 Free_Bitmap_Record (dpyinfo
, bm
);
548 dpyinfo
->bitmaps_last
= 0;
552 #ifdef HAVE_X_WINDOWS
554 /* Useful functions defined in the section
555 `Image type independent image structures' below. */
557 static unsigned long four_corners_best
P_ ((XImagePtr ximg
, unsigned long width
,
558 unsigned long height
));
560 static int x_create_x_image_and_pixmap
P_ ((struct frame
*f
, int width
, int height
,
561 int depth
, XImagePtr
*ximg
,
564 static void x_destroy_x_image
P_ ((XImagePtr ximg
));
567 /* Create a mask of a bitmap. Note is this not a perfect mask.
568 It's nicer with some borders in this context */
571 x_create_bitmap_mask (f
, id
)
576 XImagePtr ximg
, mask_img
;
577 unsigned long width
, height
;
580 unsigned long x
, y
, xp
, xm
, yp
, ym
;
583 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
588 pixmap
= x_bitmap_pixmap (f
, id
);
589 width
= x_bitmap_width (f
, id
);
590 height
= x_bitmap_height (f
, id
);
593 ximg
= XGetImage (FRAME_X_DISPLAY (f
), pixmap
, 0, 0, width
, height
,
602 result
= x_create_x_image_and_pixmap (f
, width
, height
, 1, &mask_img
, &mask
);
607 XDestroyImage (ximg
);
611 bg
= four_corners_best (ximg
, width
, height
);
613 for (y
= 0; y
< ximg
->height
; ++y
)
615 for (x
= 0; x
< ximg
->width
; ++x
)
617 xp
= x
!= ximg
->width
- 1 ? x
+ 1 : 0;
618 xm
= x
!= 0 ? x
- 1 : ximg
->width
- 1;
619 yp
= y
!= ximg
->height
- 1 ? y
+ 1 : 0;
620 ym
= y
!= 0 ? y
- 1 : ximg
->height
- 1;
621 if (XGetPixel (ximg
, x
, y
) == bg
622 && XGetPixel (ximg
, x
, yp
) == bg
623 && XGetPixel (ximg
, x
, ym
) == bg
624 && XGetPixel (ximg
, xp
, y
) == bg
625 && XGetPixel (ximg
, xp
, yp
) == bg
626 && XGetPixel (ximg
, xp
, ym
) == bg
627 && XGetPixel (ximg
, xm
, y
) == bg
628 && XGetPixel (ximg
, xm
, yp
) == bg
629 && XGetPixel (ximg
, xm
, ym
) == bg
)
630 XPutPixel (mask_img
, x
, y
, 0);
632 XPutPixel (mask_img
, x
, y
, 1);
636 xassert (interrupt_input_blocked
);
637 gc
= XCreateGC (FRAME_X_DISPLAY (f
), mask
, 0, NULL
);
638 XPutImage (FRAME_X_DISPLAY (f
), mask
, gc
, mask_img
, 0, 0, 0, 0,
640 XFreeGC (FRAME_X_DISPLAY (f
), gc
);
642 dpyinfo
->bitmaps
[id
- 1].have_mask
= 1;
643 dpyinfo
->bitmaps
[id
- 1].mask
= mask
;
645 XDestroyImage (ximg
);
646 x_destroy_x_image (mask_img
);
651 #endif /* HAVE_X_WINDOWS */
654 /***********************************************************************
656 ***********************************************************************/
658 /* Value is the number of elements of vector VECTOR. */
660 #define DIM(VECTOR) (sizeof (VECTOR) / sizeof *(VECTOR))
662 /* List of supported image types. Use define_image_type to add new
663 types. Use lookup_image_type to find a type for a given symbol. */
665 static struct image_type
*image_types
;
667 /* A list of symbols, one for each supported image type. */
669 Lisp_Object Vimage_types
;
671 /* An alist of image types and libraries that implement the type. */
673 Lisp_Object Vimage_library_alist
;
675 /* Cache for delayed-loading image types. */
677 static Lisp_Object Vimage_type_cache
;
679 /* The symbol `xbm' which is used as the type symbol for XBM images. */
685 extern Lisp_Object QCwidth
, QCheight
, QCforeground
, QCbackground
, QCfile
;
686 extern Lisp_Object QCdata
, QCtype
;
687 extern Lisp_Object Qcenter
;
688 Lisp_Object QCascent
, QCmargin
, QCrelief
;
689 Lisp_Object QCconversion
, QCcolor_symbols
, QCheuristic_mask
;
690 Lisp_Object QCindex
, QCmatrix
, QCcolor_adjustment
, QCmask
;
694 Lisp_Object Qlaplace
, Qemboss
, Qedge_detection
, Qheuristic
;
696 /* Time in seconds after which images should be removed from the cache
699 Lisp_Object Vimage_cache_eviction_delay
;
701 /* Function prototypes. */
703 static Lisp_Object define_image_type
P_ ((struct image_type
*type
, int loaded
));
704 static struct image_type
*lookup_image_type
P_ ((Lisp_Object symbol
));
705 static void image_error
P_ ((char *format
, Lisp_Object
, Lisp_Object
));
706 static void x_laplace
P_ ((struct frame
*, struct image
*));
707 static void x_emboss
P_ ((struct frame
*, struct image
*));
708 static int x_build_heuristic_mask
P_ ((struct frame
*, struct image
*,
711 #define CACHE_IMAGE_TYPE(type, status) \
712 do { Vimage_type_cache = Fcons (Fcons (type, status), Vimage_type_cache); } while (0)
714 #define ADD_IMAGE_TYPE(type) \
715 do { Vimage_types = Fcons (type, Vimage_types); } while (0)
717 /* Define a new image type from TYPE. This adds a copy of TYPE to
718 image_types and caches the loading status of TYPE. */
721 define_image_type (type
, loaded
)
722 struct image_type
*type
;
731 /* Make a copy of TYPE to avoid a bus error in a dumped Emacs.
732 The initialized data segment is read-only. */
733 struct image_type
*p
= (struct image_type
*) xmalloc (sizeof *p
);
734 bcopy (type
, p
, sizeof *p
);
735 p
->next
= image_types
;
740 CACHE_IMAGE_TYPE (*type
->type
, success
);
745 /* Look up image type SYMBOL, and return a pointer to its image_type
746 structure. Value is null if SYMBOL is not a known image type. */
748 static INLINE
struct image_type
*
749 lookup_image_type (symbol
)
752 struct image_type
*type
;
754 /* We must initialize the image-type if it hasn't been already. */
755 if (NILP (Finit_image_library (symbol
, Vimage_library_alist
)))
756 return 0; /* unimplemented */
758 for (type
= image_types
; type
; type
= type
->next
)
759 if (EQ (symbol
, *type
->type
))
766 /* Value is non-zero if OBJECT is a valid Lisp image specification. A
767 valid image specification is a list whose car is the symbol
768 `image', and whose rest is a property list. The property list must
769 contain a value for key `:type'. That value must be the name of a
770 supported image type. The rest of the property list depends on the
774 valid_image_p (object
)
783 for (tem
= XCDR (object
); CONSP (tem
); tem
= XCDR (tem
))
784 if (EQ (XCAR (tem
), QCtype
))
787 if (CONSP (tem
) && SYMBOLP (XCAR (tem
)))
789 struct image_type
*type
;
790 type
= lookup_image_type (XCAR (tem
));
792 valid_p
= type
->valid_p (object
);
803 /* Log error message with format string FORMAT and argument ARG.
804 Signaling an error, e.g. when an image cannot be loaded, is not a
805 good idea because this would interrupt redisplay, and the error
806 message display would lead to another redisplay. This function
807 therefore simply displays a message. */
810 image_error (format
, arg1
, arg2
)
812 Lisp_Object arg1
, arg2
;
814 add_to_log (format
, arg1
, arg2
);
819 /***********************************************************************
821 ***********************************************************************/
823 enum image_value_type
825 IMAGE_DONT_CHECK_VALUE_TYPE
,
827 IMAGE_STRING_OR_NIL_VALUE
,
829 IMAGE_POSITIVE_INTEGER_VALUE
,
830 IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
,
831 IMAGE_NON_NEGATIVE_INTEGER_VALUE
,
834 IMAGE_FUNCTION_VALUE
,
839 /* Structure used when parsing image specifications. */
843 /* Name of keyword. */
846 /* The type of value allowed. */
847 enum image_value_type type
;
849 /* Non-zero means key must be present. */
852 /* Used to recognize duplicate keywords in a property list. */
855 /* The value that was found. */
860 static int parse_image_spec
P_ ((Lisp_Object
, struct image_keyword
*,
862 static Lisp_Object image_spec_value
P_ ((Lisp_Object
, Lisp_Object
, int *));
865 /* Parse image spec SPEC according to KEYWORDS. A valid image spec
866 has the format (image KEYWORD VALUE ...). One of the keyword/
867 value pairs must be `:type TYPE'. KEYWORDS is a vector of
868 image_keywords structures of size NKEYWORDS describing other
869 allowed keyword/value pairs. Value is non-zero if SPEC is valid. */
872 parse_image_spec (spec
, keywords
, nkeywords
, type
)
874 struct image_keyword
*keywords
;
885 while (CONSP (plist
))
887 Lisp_Object key
, value
;
889 /* First element of a pair must be a symbol. */
891 plist
= XCDR (plist
);
895 /* There must follow a value. */
898 value
= XCAR (plist
);
899 plist
= XCDR (plist
);
901 /* Find key in KEYWORDS. Error if not found. */
902 for (i
= 0; i
< nkeywords
; ++i
)
903 if (strcmp (keywords
[i
].name
, SDATA (SYMBOL_NAME (key
))) == 0)
909 /* Record that we recognized the keyword. If a keywords
910 was found more than once, it's an error. */
911 keywords
[i
].value
= value
;
914 if (keywords
[i
].count
> 1)
917 /* Check type of value against allowed type. */
918 switch (keywords
[i
].type
)
920 case IMAGE_STRING_VALUE
:
921 if (!STRINGP (value
))
925 case IMAGE_STRING_OR_NIL_VALUE
:
926 if (!STRINGP (value
) && !NILP (value
))
930 case IMAGE_SYMBOL_VALUE
:
931 if (!SYMBOLP (value
))
935 case IMAGE_POSITIVE_INTEGER_VALUE
:
936 if (!INTEGERP (value
) || XINT (value
) <= 0)
940 case IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
:
941 if (INTEGERP (value
) && XINT (value
) >= 0)
944 && INTEGERP (XCAR (value
)) && INTEGERP (XCDR (value
))
945 && XINT (XCAR (value
)) >= 0 && XINT (XCDR (value
)) >= 0)
949 case IMAGE_ASCENT_VALUE
:
950 if (SYMBOLP (value
) && EQ (value
, Qcenter
))
952 else if (INTEGERP (value
)
954 && XINT (value
) <= 100)
958 case IMAGE_NON_NEGATIVE_INTEGER_VALUE
:
959 if (!INTEGERP (value
) || XINT (value
) < 0)
963 case IMAGE_DONT_CHECK_VALUE_TYPE
:
966 case IMAGE_FUNCTION_VALUE
:
967 value
= indirect_function (value
);
970 || (CONSP (value
) && EQ (XCAR (value
), Qlambda
)))
974 case IMAGE_NUMBER_VALUE
:
975 if (!INTEGERP (value
) && !FLOATP (value
))
979 case IMAGE_INTEGER_VALUE
:
980 if (!INTEGERP (value
))
984 case IMAGE_BOOL_VALUE
:
985 if (!NILP (value
) && !EQ (value
, Qt
))
994 if (EQ (key
, QCtype
) && !EQ (type
, value
))
998 /* Check that all mandatory fields are present. */
999 for (i
= 0; i
< nkeywords
; ++i
)
1000 if (keywords
[i
].mandatory_p
&& keywords
[i
].count
== 0)
1003 return NILP (plist
);
1007 /* Return the value of KEY in image specification SPEC. Value is nil
1008 if KEY is not present in SPEC. if FOUND is not null, set *FOUND
1009 to 1 if KEY was found in SPEC, set it to 0 otherwise. */
1012 image_spec_value (spec
, key
, found
)
1013 Lisp_Object spec
, key
;
1018 xassert (valid_image_p (spec
));
1020 for (tail
= XCDR (spec
);
1021 CONSP (tail
) && CONSP (XCDR (tail
));
1022 tail
= XCDR (XCDR (tail
)))
1024 if (EQ (XCAR (tail
), key
))
1028 return XCAR (XCDR (tail
));
1038 DEFUN ("image-size", Fimage_size
, Simage_size
, 1, 3, 0,
1039 doc
: /* Return the size of image SPEC as pair (WIDTH . HEIGHT).
1040 PIXELS non-nil means return the size in pixels, otherwise return the
1041 size in canonical character units.
1042 FRAME is the frame on which the image will be displayed. FRAME nil
1043 or omitted means use the selected frame. */)
1044 (spec
, pixels
, frame
)
1045 Lisp_Object spec
, pixels
, frame
;
1050 if (valid_image_p (spec
))
1052 struct frame
*f
= check_x_frame (frame
);
1053 int id
= lookup_image (f
, spec
);
1054 struct image
*img
= IMAGE_FROM_ID (f
, id
);
1055 int width
= img
->width
+ 2 * img
->hmargin
;
1056 int height
= img
->height
+ 2 * img
->vmargin
;
1059 size
= Fcons (make_float ((double) width
/ FRAME_COLUMN_WIDTH (f
)),
1060 make_float ((double) height
/ FRAME_LINE_HEIGHT (f
)));
1062 size
= Fcons (make_number (width
), make_number (height
));
1065 error ("Invalid image specification");
1071 DEFUN ("image-mask-p", Fimage_mask_p
, Simage_mask_p
, 1, 2, 0,
1072 doc
: /* Return t if image SPEC has a mask bitmap.
1073 FRAME is the frame on which the image will be displayed. FRAME nil
1074 or omitted means use the selected frame. */)
1076 Lisp_Object spec
, frame
;
1081 if (valid_image_p (spec
))
1083 struct frame
*f
= check_x_frame (frame
);
1084 int id
= lookup_image (f
, spec
);
1085 struct image
*img
= IMAGE_FROM_ID (f
, id
);
1090 error ("Invalid image specification");
1096 /***********************************************************************
1097 Image type independent image structures
1098 ***********************************************************************/
1100 static struct image
*make_image
P_ ((Lisp_Object spec
, unsigned hash
));
1101 static void free_image
P_ ((struct frame
*f
, struct image
*img
));
1102 static int check_image_size
P_ ((struct frame
*f
, int width
, int height
));
1104 #define MAX_IMAGE_SIZE 6.0
1105 Lisp_Object Vmax_image_size
;
1107 /* Allocate and return a new image structure for image specification
1108 SPEC. SPEC has a hash value of HASH. */
1110 static struct image
*
1111 make_image (spec
, hash
)
1115 struct image
*img
= (struct image
*) xmalloc (sizeof *img
);
1117 xassert (valid_image_p (spec
));
1118 bzero (img
, sizeof *img
);
1119 img
->type
= lookup_image_type (image_spec_value (spec
, QCtype
, NULL
));
1120 xassert (img
->type
!= NULL
);
1122 img
->data
.lisp_val
= Qnil
;
1123 img
->ascent
= DEFAULT_IMAGE_ASCENT
;
1129 /* Free image IMG which was used on frame F, including its resources. */
1138 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
1140 /* Remove IMG from the hash table of its cache. */
1142 img
->prev
->next
= img
->next
;
1144 c
->buckets
[img
->hash
% IMAGE_CACHE_BUCKETS_SIZE
] = img
->next
;
1147 img
->next
->prev
= img
->prev
;
1149 c
->images
[img
->id
] = NULL
;
1151 /* Free resources, then free IMG. */
1152 img
->type
->free (f
, img
);
1157 /* Return 1 if the given widths and heights are valid for display;
1158 otherwise, return 0. */
1161 check_image_size (f
, width
, height
)
1168 if (width
<= 0 || height
<= 0)
1171 if (INTEGERP (Vmax_image_size
))
1172 w
= h
= XINT (Vmax_image_size
);
1173 else if (FLOATP (Vmax_image_size
))
1177 w
= FRAME_PIXEL_WIDTH (f
);
1178 h
= FRAME_PIXEL_HEIGHT (f
);
1181 w
= h
= 1024; /* Arbitrary size for unknown frame. */
1182 w
= (int) (XFLOAT_DATA (Vmax_image_size
) * w
);
1183 h
= (int) (XFLOAT_DATA (Vmax_image_size
) * h
);
1188 return (width
<= w
&& height
<= h
);
1191 /* Prepare image IMG for display on frame F. Must be called before
1192 drawing an image. */
1195 prepare_image_for_display (f
, img
)
1201 /* We're about to display IMG, so set its timestamp to `now'. */
1203 img
->timestamp
= EMACS_SECS (t
);
1205 /* If IMG doesn't have a pixmap yet, load it now, using the image
1206 type dependent loader function. */
1207 if (img
->pixmap
== NO_PIXMAP
&& !img
->load_failed_p
)
1208 img
->load_failed_p
= img
->type
->load (f
, img
) == 0;
1212 /* Value is the number of pixels for the ascent of image IMG when
1213 drawn in face FACE. */
1216 image_ascent (img
, face
, slice
)
1219 struct glyph_slice
*slice
;
1224 if (slice
->height
== img
->height
)
1225 height
= img
->height
+ img
->vmargin
;
1226 else if (slice
->y
== 0)
1227 height
= slice
->height
+ img
->vmargin
;
1229 height
= slice
->height
;
1231 if (img
->ascent
== CENTERED_IMAGE_ASCENT
)
1236 /* W32 specific version. Why?. ++kfs */
1237 ascent
= height
/ 2 - (FONT_DESCENT(face
->font
)
1238 - FONT_BASE(face
->font
)) / 2;
1240 /* This expression is arranged so that if the image can't be
1241 exactly centered, it will be moved slightly up. This is
1242 because a typical font is `top-heavy' (due to the presence
1243 uppercase letters), so the image placement should err towards
1244 being top-heavy too. It also just generally looks better. */
1245 ascent
= (height
+ face
->font
->ascent
- face
->font
->descent
+ 1) / 2;
1246 #endif /* HAVE_NTGUI */
1249 ascent
= height
/ 2;
1252 ascent
= (int) (height
* img
->ascent
/ 100.0);
1258 /* Image background colors. */
1260 /* Find the "best" corner color of a bitmap.
1261 On W32, XIMG is assumed to a device context with the bitmap selected. */
1263 static RGB_PIXEL_COLOR
1264 four_corners_best (ximg
, width
, height
)
1265 XImagePtr_or_DC ximg
;
1266 unsigned long width
, height
;
1268 RGB_PIXEL_COLOR corners
[4], best
;
1271 /* Get the colors at the corners of ximg. */
1272 corners
[0] = GET_PIXEL (ximg
, 0, 0);
1273 corners
[1] = GET_PIXEL (ximg
, width
- 1, 0);
1274 corners
[2] = GET_PIXEL (ximg
, width
- 1, height
- 1);
1275 corners
[3] = GET_PIXEL (ximg
, 0, height
- 1);
1277 /* Choose the most frequently found color as background. */
1278 for (i
= best_count
= 0; i
< 4; ++i
)
1282 for (j
= n
= 0; j
< 4; ++j
)
1283 if (corners
[i
] == corners
[j
])
1287 best
= corners
[i
], best_count
= n
;
1293 /* Portability macros */
1297 #define Destroy_Image(img_dc, prev) \
1298 do { SelectObject (img_dc, prev); DeleteDC (img_dc); } while (0)
1300 #define Free_Pixmap(display, pixmap) \
1301 DeleteObject (pixmap)
1305 #define Destroy_Image(ximg, dummy) \
1306 XDestroyImage (ximg)
1308 #define Free_Pixmap(display, pixmap) \
1309 XFreePixmap (display, pixmap)
1311 #endif /* HAVE_NTGUI */
1314 /* Return the `background' field of IMG. If IMG doesn't have one yet,
1315 it is guessed heuristically. If non-zero, XIMG is an existing
1316 XImage object (or device context with the image selected on W32) to
1317 use for the heuristic. */
1320 image_background (img
, f
, ximg
)
1323 XImagePtr_or_DC ximg
;
1325 if (! img
->background_valid
)
1326 /* IMG doesn't have a background yet, try to guess a reasonable value. */
1328 int free_ximg
= !ximg
;
1331 #endif /* HAVE_NTGUI */
1336 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
1337 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
1339 HDC frame_dc
= get_frame_dc (f
);
1340 ximg
= CreateCompatibleDC (frame_dc
);
1341 release_frame_dc (f
, frame_dc
);
1342 prev
= SelectObject (ximg
, img
->pixmap
);
1343 #endif /* !HAVE_NTGUI */
1346 img
->background
= four_corners_best (ximg
, img
->width
, img
->height
);
1349 Destroy_Image (ximg
, prev
);
1351 img
->background_valid
= 1;
1354 return img
->background
;
1357 /* Return the `background_transparent' field of IMG. If IMG doesn't
1358 have one yet, it is guessed heuristically. If non-zero, MASK is an
1359 existing XImage object to use for the heuristic. */
1362 image_background_transparent (img
, f
, mask
)
1365 XImagePtr_or_DC mask
;
1367 if (! img
->background_transparent_valid
)
1368 /* IMG doesn't have a background yet, try to guess a reasonable value. */
1372 int free_mask
= !mask
;
1375 #endif /* HAVE_NTGUI */
1380 mask
= XGetImage (FRAME_X_DISPLAY (f
), img
->mask
,
1381 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
1383 HDC frame_dc
= get_frame_dc (f
);
1384 mask
= CreateCompatibleDC (frame_dc
);
1385 release_frame_dc (f
, frame_dc
);
1386 prev
= SelectObject (mask
, img
->mask
);
1387 #endif /* HAVE_NTGUI */
1390 img
->background_transparent
1391 = (four_corners_best (mask
, img
->width
, img
->height
) == PIX_MASK_RETAIN
);
1394 Destroy_Image (mask
, prev
);
1397 img
->background_transparent
= 0;
1399 img
->background_transparent_valid
= 1;
1402 return img
->background_transparent
;
1406 /***********************************************************************
1407 Helper functions for X image types
1408 ***********************************************************************/
1410 static void x_clear_image_1
P_ ((struct frame
*, struct image
*, int,
1412 static void x_clear_image
P_ ((struct frame
*f
, struct image
*img
));
1413 static unsigned long x_alloc_image_color
P_ ((struct frame
*f
,
1415 Lisp_Object color_name
,
1416 unsigned long dflt
));
1419 /* Clear X resources of image IMG on frame F. PIXMAP_P non-zero means
1420 free the pixmap if any. MASK_P non-zero means clear the mask
1421 pixmap if any. COLORS_P non-zero means free colors allocated for
1422 the image, if any. */
1425 x_clear_image_1 (f
, img
, pixmap_p
, mask_p
, colors_p
)
1428 int pixmap_p
, mask_p
, colors_p
;
1430 if (pixmap_p
&& img
->pixmap
)
1432 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->pixmap
);
1433 img
->pixmap
= NO_PIXMAP
;
1434 img
->background_valid
= 0;
1437 if (mask_p
&& img
->mask
)
1439 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
1440 img
->mask
= NO_PIXMAP
;
1441 img
->background_transparent_valid
= 0;
1444 if (colors_p
&& img
->ncolors
)
1446 /* MAC_TODO: color table support. */
1447 /* W32_TODO: color table support. */
1448 #ifdef HAVE_X_WINDOWS
1449 x_free_colors (f
, img
->colors
, img
->ncolors
);
1450 #endif /* HAVE_X_WINDOWS */
1451 xfree (img
->colors
);
1457 /* Free X resources of image IMG which is used on frame F. */
1460 x_clear_image (f
, img
)
1465 x_clear_image_1 (f
, img
, 1, 1, 1);
1470 /* Allocate color COLOR_NAME for image IMG on frame F. If color
1471 cannot be allocated, use DFLT. Add a newly allocated color to
1472 IMG->colors, so that it can be freed again. Value is the pixel
1475 static unsigned long
1476 x_alloc_image_color (f
, img
, color_name
, dflt
)
1479 Lisp_Object color_name
;
1483 unsigned long result
;
1485 xassert (STRINGP (color_name
));
1487 if (x_defined_color (f
, SDATA (color_name
), &color
, 1))
1489 /* This isn't called frequently so we get away with simply
1490 reallocating the color vector to the needed size, here. */
1493 (unsigned long *) xrealloc (img
->colors
,
1494 img
->ncolors
* sizeof *img
->colors
);
1495 img
->colors
[img
->ncolors
- 1] = color
.pixel
;
1496 result
= color
.pixel
;
1506 /***********************************************************************
1508 ***********************************************************************/
1510 static void cache_image
P_ ((struct frame
*f
, struct image
*img
));
1511 static void postprocess_image
P_ ((struct frame
*, struct image
*));
1513 /* Return a new, initialized image cache that is allocated from the
1514 heap. Call free_image_cache to free an image cache. */
1516 struct image_cache
*
1519 struct image_cache
*c
= (struct image_cache
*) xmalloc (sizeof *c
);
1522 bzero (c
, sizeof *c
);
1524 c
->images
= (struct image
**) xmalloc (c
->size
* sizeof *c
->images
);
1525 size
= IMAGE_CACHE_BUCKETS_SIZE
* sizeof *c
->buckets
;
1526 c
->buckets
= (struct image
**) xmalloc (size
);
1527 bzero (c
->buckets
, size
);
1532 /* Free image cache of frame F. Be aware that X frames share images
1536 free_image_cache (f
)
1539 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
1544 /* Cache should not be referenced by any frame when freed. */
1545 xassert (c
->refcount
== 0);
1547 for (i
= 0; i
< c
->used
; ++i
)
1548 free_image (f
, c
->images
[i
]);
1552 FRAME_X_IMAGE_CACHE (f
) = NULL
;
1557 /* Clear image cache of frame F. FORCE_P non-zero means free all
1558 images. FORCE_P zero means clear only images that haven't been
1559 displayed for some time. Should be called from time to time to
1560 reduce the number of loaded images. If image-eviction-seconds is
1561 non-nil, this frees images in the cache which weren't displayed for
1562 at least that many seconds. */
1565 clear_image_cache (f
, force_p
)
1569 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
1571 if (c
&& INTEGERP (Vimage_cache_eviction_delay
))
1578 old
= EMACS_SECS (t
) - XFASTINT (Vimage_cache_eviction_delay
);
1580 /* Block input so that we won't be interrupted by a SIGIO
1581 while being in an inconsistent state. */
1584 for (i
= nfreed
= 0; i
< c
->used
; ++i
)
1586 struct image
*img
= c
->images
[i
];
1588 && (force_p
|| img
->timestamp
< old
))
1590 free_image (f
, img
);
1595 /* We may be clearing the image cache because, for example,
1596 Emacs was iconified for a longer period of time. In that
1597 case, current matrices may still contain references to
1598 images freed above. So, clear these matrices. */
1601 Lisp_Object tail
, frame
;
1603 FOR_EACH_FRAME (tail
, frame
)
1605 struct frame
*f
= XFRAME (frame
);
1606 if (FRAME_WINDOW_P (f
)
1607 && FRAME_X_IMAGE_CACHE (f
) == c
)
1608 clear_current_matrices (f
);
1611 ++windows_or_buffers_changed
;
1619 DEFUN ("clear-image-cache", Fclear_image_cache
, Sclear_image_cache
,
1621 doc
: /* Clear the image cache of FRAME.
1622 FRAME nil or omitted means use the selected frame.
1623 FRAME t means clear the image caches of all frames. */)
1631 FOR_EACH_FRAME (tail
, frame
)
1632 if (FRAME_WINDOW_P (XFRAME (frame
)))
1633 clear_image_cache (XFRAME (frame
), 1);
1636 clear_image_cache (check_x_frame (frame
), 1);
1642 /* Compute masks and transform image IMG on frame F, as specified
1643 by the image's specification, */
1646 postprocess_image (f
, img
)
1650 /* Manipulation of the image's mask. */
1653 Lisp_Object conversion
, spec
;
1658 /* `:heuristic-mask t'
1660 means build a mask heuristically.
1661 `:heuristic-mask (R G B)'
1662 `:mask (heuristic (R G B))'
1663 means build a mask from color (R G B) in the
1666 means remove a mask, if any. */
1668 mask
= image_spec_value (spec
, QCheuristic_mask
, NULL
);
1670 x_build_heuristic_mask (f
, img
, mask
);
1675 mask
= image_spec_value (spec
, QCmask
, &found_p
);
1677 if (EQ (mask
, Qheuristic
))
1678 x_build_heuristic_mask (f
, img
, Qt
);
1679 else if (CONSP (mask
)
1680 && EQ (XCAR (mask
), Qheuristic
))
1682 if (CONSP (XCDR (mask
)))
1683 x_build_heuristic_mask (f
, img
, XCAR (XCDR (mask
)));
1685 x_build_heuristic_mask (f
, img
, XCDR (mask
));
1687 else if (NILP (mask
) && found_p
&& img
->mask
)
1689 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
1690 img
->mask
= NO_PIXMAP
;
1695 /* Should we apply an image transformation algorithm? */
1696 conversion
= image_spec_value (spec
, QCconversion
, NULL
);
1697 if (EQ (conversion
, Qdisabled
))
1698 x_disable_image (f
, img
);
1699 else if (EQ (conversion
, Qlaplace
))
1701 else if (EQ (conversion
, Qemboss
))
1703 else if (CONSP (conversion
)
1704 && EQ (XCAR (conversion
), Qedge_detection
))
1707 tem
= XCDR (conversion
);
1709 x_edge_detection (f
, img
,
1710 Fplist_get (tem
, QCmatrix
),
1711 Fplist_get (tem
, QCcolor_adjustment
));
1717 /* Return the id of image with Lisp specification SPEC on frame F.
1718 SPEC must be a valid Lisp image specification (see valid_image_p). */
1721 lookup_image (f
, spec
)
1725 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
1729 struct gcpro gcpro1
;
1732 /* F must be a window-system frame, and SPEC must be a valid image
1734 xassert (FRAME_WINDOW_P (f
));
1735 xassert (valid_image_p (spec
));
1739 /* Look up SPEC in the hash table of the image cache. */
1740 hash
= sxhash (spec
, 0);
1741 i
= hash
% IMAGE_CACHE_BUCKETS_SIZE
;
1743 for (img
= c
->buckets
[i
]; img
; img
= img
->next
)
1744 if (img
->hash
== hash
&& !NILP (Fequal (img
->spec
, spec
)))
1747 if (img
&& img
->load_failed_p
)
1749 free_image (f
, img
);
1753 /* If not found, create a new image and cache it. */
1756 extern Lisp_Object Qpostscript
;
1759 img
= make_image (spec
, hash
);
1760 cache_image (f
, img
);
1761 img
->load_failed_p
= img
->type
->load (f
, img
) == 0;
1763 /* If we can't load the image, and we don't have a width and
1764 height, use some arbitrary width and height so that we can
1765 draw a rectangle for it. */
1766 if (img
->load_failed_p
)
1770 value
= image_spec_value (spec
, QCwidth
, NULL
);
1771 img
->width
= (INTEGERP (value
)
1772 ? XFASTINT (value
) : DEFAULT_IMAGE_WIDTH
);
1773 value
= image_spec_value (spec
, QCheight
, NULL
);
1774 img
->height
= (INTEGERP (value
)
1775 ? XFASTINT (value
) : DEFAULT_IMAGE_HEIGHT
);
1779 /* Handle image type independent image attributes
1780 `:ascent ASCENT', `:margin MARGIN', `:relief RELIEF',
1781 `:background COLOR'. */
1782 Lisp_Object ascent
, margin
, relief
, bg
;
1784 ascent
= image_spec_value (spec
, QCascent
, NULL
);
1785 if (INTEGERP (ascent
))
1786 img
->ascent
= XFASTINT (ascent
);
1787 else if (EQ (ascent
, Qcenter
))
1788 img
->ascent
= CENTERED_IMAGE_ASCENT
;
1790 margin
= image_spec_value (spec
, QCmargin
, NULL
);
1791 if (INTEGERP (margin
) && XINT (margin
) >= 0)
1792 img
->vmargin
= img
->hmargin
= XFASTINT (margin
);
1793 else if (CONSP (margin
) && INTEGERP (XCAR (margin
))
1794 && INTEGERP (XCDR (margin
)))
1796 if (XINT (XCAR (margin
)) > 0)
1797 img
->hmargin
= XFASTINT (XCAR (margin
));
1798 if (XINT (XCDR (margin
)) > 0)
1799 img
->vmargin
= XFASTINT (XCDR (margin
));
1802 relief
= image_spec_value (spec
, QCrelief
, NULL
);
1803 if (INTEGERP (relief
))
1805 img
->relief
= XINT (relief
);
1806 img
->hmargin
+= abs (img
->relief
);
1807 img
->vmargin
+= abs (img
->relief
);
1810 if (! img
->background_valid
)
1812 bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
1816 = x_alloc_image_color (f
, img
, bg
,
1817 FRAME_BACKGROUND_PIXEL (f
));
1818 img
->background_valid
= 1;
1822 /* Do image transformations and compute masks, unless we
1823 don't have the image yet. */
1824 if (!EQ (*img
->type
->type
, Qpostscript
))
1825 postprocess_image (f
, img
);
1831 /* We're using IMG, so set its timestamp to `now'. */
1832 EMACS_GET_TIME (now
);
1833 img
->timestamp
= EMACS_SECS (now
);
1837 /* Value is the image id. */
1842 /* Cache image IMG in the image cache of frame F. */
1845 cache_image (f
, img
)
1849 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
1852 /* Find a free slot in c->images. */
1853 for (i
= 0; i
< c
->used
; ++i
)
1854 if (c
->images
[i
] == NULL
)
1857 /* If no free slot found, maybe enlarge c->images. */
1858 if (i
== c
->used
&& c
->used
== c
->size
)
1861 c
->images
= (struct image
**) xrealloc (c
->images
,
1862 c
->size
* sizeof *c
->images
);
1865 /* Add IMG to c->images, and assign IMG an id. */
1871 /* Add IMG to the cache's hash table. */
1872 i
= img
->hash
% IMAGE_CACHE_BUCKETS_SIZE
;
1873 img
->next
= c
->buckets
[i
];
1875 img
->next
->prev
= img
;
1877 c
->buckets
[i
] = img
;
1881 /* Call FN on every image in the image cache of frame F. Used to mark
1882 Lisp Objects in the image cache. */
1885 forall_images_in_image_cache (f
, fn
)
1887 void (*fn
) P_ ((struct image
*img
));
1889 if (FRAME_LIVE_P (f
) && FRAME_WINDOW_P (f
))
1891 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
1895 for (i
= 0; i
< c
->used
; ++i
)
1904 /***********************************************************************
1905 X / MAC / W32 support code
1906 ***********************************************************************/
1910 /* Macro for defining functions that will be loaded from image DLLs. */
1911 #define DEF_IMGLIB_FN(func) int (FAR CDECL *fn_##func)()
1913 /* Macro for loading those image functions from the library. */
1914 #define LOAD_IMGLIB_FN(lib,func) { \
1915 fn_##func = (void *) GetProcAddress (lib, #func); \
1916 if (!fn_##func) return 0; \
1919 /* Load a DLL implementing an image type.
1920 The `image-library-alist' variable associates a symbol,
1921 identifying an image type, to a list of possible filenames.
1922 The function returns NULL if no library could be loaded for
1923 the given image type, or if the library was previously loaded;
1924 else the handle of the DLL. */
1926 w32_delayed_load (Lisp_Object libraries
, Lisp_Object type
)
1928 HMODULE library
= NULL
;
1930 if (CONSP (libraries
) && NILP (Fassq (type
, Vimage_type_cache
)))
1932 Lisp_Object dlls
= Fassq (type
, libraries
);
1935 for (dlls
= XCDR (dlls
); CONSP (dlls
); dlls
= XCDR (dlls
))
1937 CHECK_STRING_CAR (dlls
);
1938 if (library
= LoadLibrary (SDATA (XCAR (dlls
))))
1946 #endif /* HAVE_NTGUI */
1948 static int x_create_x_image_and_pixmap
P_ ((struct frame
*, int, int, int,
1949 XImagePtr
*, Pixmap
*));
1950 static void x_destroy_x_image
P_ ((XImagePtr
));
1951 static void x_put_x_image
P_ ((struct frame
*, XImagePtr
, Pixmap
, int, int));
1954 /* Create an XImage and a pixmap of size WIDTH x HEIGHT for use on
1955 frame F. Set *XIMG and *PIXMAP to the XImage and Pixmap created.
1956 Set (*XIMG)->data to a raster of WIDTH x HEIGHT pixels allocated
1957 via xmalloc. Print error messages via image_error if an error
1958 occurs. Value is non-zero if successful.
1960 On W32, a DEPTH of zero signifies a 24 bit image, otherwise DEPTH
1961 should indicate the bit depth of the image. */
1964 x_create_x_image_and_pixmap (f
, width
, height
, depth
, ximg
, pixmap
)
1966 int width
, height
, depth
;
1970 #ifdef HAVE_X_WINDOWS
1971 Display
*display
= FRAME_X_DISPLAY (f
);
1972 Window window
= FRAME_X_WINDOW (f
);
1973 Screen
*screen
= FRAME_X_SCREEN (f
);
1975 xassert (interrupt_input_blocked
);
1978 depth
= DefaultDepthOfScreen (screen
);
1979 *ximg
= XCreateImage (display
, DefaultVisualOfScreen (screen
),
1980 depth
, ZPixmap
, 0, NULL
, width
, height
,
1981 depth
> 16 ? 32 : depth
> 8 ? 16 : 8, 0);
1984 image_error ("Unable to allocate X image", Qnil
, Qnil
);
1988 /* Allocate image raster. */
1989 (*ximg
)->data
= (char *) xmalloc ((*ximg
)->bytes_per_line
* height
);
1991 /* Allocate a pixmap of the same size. */
1992 *pixmap
= XCreatePixmap (display
, window
, width
, height
, depth
);
1993 if (*pixmap
== NO_PIXMAP
)
1995 x_destroy_x_image (*ximg
);
1997 image_error ("Unable to create X pixmap", Qnil
, Qnil
);
2002 #endif /* HAVE_X_WINDOWS */
2006 BITMAPINFOHEADER
*header
;
2008 int scanline_width_bits
;
2010 int palette_colors
= 0;
2015 if (depth
!= 1 && depth
!= 4 && depth
!= 8
2016 && depth
!= 16 && depth
!= 24 && depth
!= 32)
2018 image_error ("Invalid image bit depth specified", Qnil
, Qnil
);
2022 scanline_width_bits
= width
* depth
;
2023 remainder
= scanline_width_bits
% 32;
2026 scanline_width_bits
+= 32 - remainder
;
2028 /* Bitmaps with a depth less than 16 need a palette. */
2029 /* BITMAPINFO structure already contains the first RGBQUAD. */
2031 palette_colors
= 1 << depth
- 1;
2033 *ximg
= xmalloc (sizeof (XImage
) + palette_colors
* sizeof (RGBQUAD
));
2036 image_error ("Unable to allocate memory for XImage", Qnil
, Qnil
);
2040 header
= &((*ximg
)->info
.bmiHeader
);
2041 bzero (&((*ximg
)->info
), sizeof (BITMAPINFO
));
2042 header
->biSize
= sizeof (*header
);
2043 header
->biWidth
= width
;
2044 header
->biHeight
= -height
; /* negative indicates a top-down bitmap. */
2045 header
->biPlanes
= 1;
2046 header
->biBitCount
= depth
;
2047 header
->biCompression
= BI_RGB
;
2048 header
->biClrUsed
= palette_colors
;
2050 /* TODO: fill in palette. */
2053 (*ximg
)->info
.bmiColors
[0].rgbBlue
= 0;
2054 (*ximg
)->info
.bmiColors
[0].rgbGreen
= 0;
2055 (*ximg
)->info
.bmiColors
[0].rgbRed
= 0;
2056 (*ximg
)->info
.bmiColors
[0].rgbReserved
= 0;
2057 (*ximg
)->info
.bmiColors
[1].rgbBlue
= 255;
2058 (*ximg
)->info
.bmiColors
[1].rgbGreen
= 255;
2059 (*ximg
)->info
.bmiColors
[1].rgbRed
= 255;
2060 (*ximg
)->info
.bmiColors
[1].rgbReserved
= 0;
2063 hdc
= get_frame_dc (f
);
2065 /* Create a DIBSection and raster array for the bitmap,
2066 and store its handle in *pixmap. */
2067 *pixmap
= CreateDIBSection (hdc
, &((*ximg
)->info
),
2068 (depth
< 16) ? DIB_PAL_COLORS
: DIB_RGB_COLORS
,
2069 /* casting avoids a GCC warning */
2070 (void **)&((*ximg
)->data
), NULL
, 0);
2072 /* Realize display palette and garbage all frames. */
2073 release_frame_dc (f
, hdc
);
2075 if (*pixmap
== NULL
)
2077 DWORD err
= GetLastError();
2078 Lisp_Object errcode
;
2079 /* All system errors are < 10000, so the following is safe. */
2080 XSETINT (errcode
, (int) err
);
2081 image_error ("Unable to create bitmap, error code %d", errcode
, Qnil
);
2082 x_destroy_x_image (*ximg
);
2088 #endif /* HAVE_NTGUI */
2091 Display
*display
= FRAME_X_DISPLAY (f
);
2092 Window window
= FRAME_X_WINDOW (f
);
2094 xassert (interrupt_input_blocked
);
2096 /* Allocate a pixmap of the same size. */
2097 *pixmap
= XCreatePixmap (display
, window
, width
, height
, depth
);
2098 if (*pixmap
== NO_PIXMAP
)
2101 image_error ("Unable to create X pixmap", Qnil
, Qnil
);
2105 LockPixels (GetGWorldPixMap (*pixmap
));
2113 /* Destroy XImage XIMG. Free XIMG->data. */
2116 x_destroy_x_image (ximg
)
2119 xassert (interrupt_input_blocked
);
2122 #ifdef HAVE_X_WINDOWS
2125 XDestroyImage (ximg
);
2126 #endif /* HAVE_X_WINDOWS */
2128 /* Data will be freed by DestroyObject. */
2131 #endif /* HAVE_NTGUI */
2133 XDestroyImage (ximg
);
2139 /* Put XImage XIMG into pixmap PIXMAP on frame F. WIDTH and HEIGHT
2140 are width and height of both the image and pixmap. */
2143 x_put_x_image (f
, ximg
, pixmap
, width
, height
)
2149 #ifdef HAVE_X_WINDOWS
2152 xassert (interrupt_input_blocked
);
2153 gc
= XCreateGC (FRAME_X_DISPLAY (f
), pixmap
, 0, NULL
);
2154 XPutImage (FRAME_X_DISPLAY (f
), pixmap
, gc
, ximg
, 0, 0, 0, 0, width
, height
);
2155 XFreeGC (FRAME_X_DISPLAY (f
), gc
);
2156 #endif /* HAVE_X_WINDOWS */
2159 #if 0 /* I don't think this is necessary looking at where it is used. */
2160 HDC hdc
= get_frame_dc (f
);
2161 SetDIBits (hdc
, pixmap
, 0, height
, ximg
->data
, &(ximg
->info
), DIB_RGB_COLORS
);
2162 release_frame_dc (f
, hdc
);
2164 #endif /* HAVE_NTGUI */
2167 xassert (ximg
== pixmap
);
2172 /***********************************************************************
2174 ***********************************************************************/
2176 static unsigned char *slurp_file
P_ ((char *, int *));
2179 /* Find image file FILE. Look in data-directory, then
2180 x-bitmap-file-path. Value is the full name of the file found, or
2181 nil if not found. */
2184 x_find_image_file (file
)
2187 Lisp_Object file_found
, search_path
;
2188 struct gcpro gcpro1
, gcpro2
;
2192 search_path
= Fcons (Vdata_directory
, Vx_bitmap_file_path
);
2193 GCPRO2 (file_found
, search_path
);
2195 /* Try to find FILE in data-directory, then x-bitmap-file-path. */
2196 fd
= openp (search_path
, file
, Qnil
, &file_found
, Qnil
);
2208 /* Read FILE into memory. Value is a pointer to a buffer allocated
2209 with xmalloc holding FILE's contents. Value is null if an error
2210 occurred. *SIZE is set to the size of the file. */
2212 static unsigned char *
2213 slurp_file (file
, size
)
2218 unsigned char *buf
= NULL
;
2221 if (stat (file
, &st
) == 0
2222 && (fp
= fopen (file
, "rb")) != NULL
2223 && (buf
= (unsigned char *) xmalloc (st
.st_size
),
2224 fread (buf
, 1, st
.st_size
, fp
) == st
.st_size
))
2247 /***********************************************************************
2248 MAC Image Load Functions
2249 ***********************************************************************/
2251 static int image_load_quicktime
P_ ((struct frame
*, struct image
*img
,
2254 static int image_load_quartz2d
P_ ((struct frame
*, struct image
*img
, int));
2258 find_image_fsspec (specified_file
, file
, fss
)
2259 Lisp_Object specified_file
, *file
;
2267 *file
= x_find_image_file (specified_file
);
2268 if (!STRINGP (*file
))
2269 return fnfErr
; /* file or directory not found;
2270 incomplete pathname */
2271 /* Try to open the image file. */
2273 err
= FSPathMakeRef (SDATA (*file
), &fsr
, NULL
);
2275 err
= FSGetCatalogInfo (&fsr
, kFSCatInfoNone
, NULL
, NULL
, fss
, NULL
);
2277 err
= posix_pathname_to_fsspec (SDATA (*file
), fss
);
2283 image_load_qt_1 (f
, img
, type
, fss
, dh
)
2291 GraphicsImportComponent gi
;
2294 ImageDescriptionHandle desc_handle
;
2295 short draw_all_pixels
;
2296 Lisp_Object specified_bg
;
2301 err
= OpenADefaultComponent (GraphicsImporterComponentType
,
2305 image_error ("Cannot get importer component for `%s'", img
->spec
, Qnil
);
2310 /* read from file system spec */
2311 err
= GraphicsImportSetDataFile (gi
, fss
);
2314 image_error ("Cannot set fsspec to graphics importer for '%s'",
2321 /* read from data handle */
2322 err
= GraphicsImportSetDataHandle (gi
, dh
);
2325 image_error ("Cannot set data handle to graphics importer for `%s'",
2330 err
= GraphicsImportGetImageDescription (gi
, &desc_handle
);
2331 if (err
!= noErr
|| desc_handle
== NULL
)
2333 image_error ("Error reading `%s'", img
->spec
, Qnil
);
2336 width
= img
->width
= (*desc_handle
)->width
;
2337 height
= img
->height
= (*desc_handle
)->height
;
2338 DisposeHandle ((Handle
)desc_handle
);
2340 if (!check_image_size (f
, width
, height
))
2342 image_error ("Invalid image size", Qnil
, Qnil
);
2346 err
= GraphicsImportDoesDrawAllPixels (gi
, &draw_all_pixels
);
2348 /* Don't check the error code here. It may have an undocumented
2352 image_error ("Error reading `%s'", img
->spec
, Qnil
);
2356 if (draw_all_pixels
!= graphicsImporterDrawsAllPixels
)
2358 specified_bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
2359 if (!STRINGP (specified_bg
) ||
2360 !mac_defined_color (f
, SDATA (specified_bg
), &color
, 0))
2362 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
2363 color
.red
= RED16_FROM_ULONG (color
.pixel
);
2364 color
.green
= GREEN16_FROM_ULONG (color
.pixel
);
2365 color
.blue
= BLUE16_FROM_ULONG (color
.pixel
);
2369 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
2371 if (draw_all_pixels
!= graphicsImporterDrawsAllPixels
)
2376 GetGWorld (&old_port
, &old_gdh
);
2377 SetGWorld (ximg
, NULL
);
2378 bg_color
.red
= color
.red
;
2379 bg_color
.green
= color
.green
;
2380 bg_color
.blue
= color
.blue
;
2381 RGBBackColor (&bg_color
);
2382 #if TARGET_API_MAC_CARBON
2383 GetPortBounds (ximg
, &rect
);
2386 EraseRect (&(ximg
->portRect
));
2388 SetGWorld (old_port
, old_gdh
);
2390 GraphicsImportSetGWorld (gi
, ximg
, NULL
);
2391 GraphicsImportDraw (gi
);
2392 CloseComponent (gi
);
2394 /* Maybe fill in the background field while we have ximg handy. */
2395 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
2396 IMAGE_BACKGROUND (img
, f
, ximg
);
2398 /* Put the image into the pixmap. */
2399 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
2400 x_destroy_x_image (ximg
);
2404 CloseComponent (gi
);
2409 /* Load an image using the QuickTime Graphics Importer.
2410 Note: The alpha channel does not work for PNG images. */
2412 image_load_quicktime (f
, img
, type
)
2417 Lisp_Object specified_file
;
2418 Lisp_Object specified_data
;
2421 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
2422 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
2424 if (NILP (specified_data
))
2426 /* Read from a file */
2430 err
= find_image_fsspec (specified_file
, &file
, &fss
);
2434 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
2436 image_error ("Cannot open `%s'", file
, Qnil
);
2439 return image_load_qt_1 (f
, img
, type
, &fss
, NULL
);
2443 /* Memory source! */
2447 err
= PtrToHand (SDATA (specified_data
), &dh
, SBYTES (specified_data
));
2450 image_error ("Cannot allocate data handle for `%s'",
2454 success_p
= image_load_qt_1 (f
, img
, type
, NULL
, dh
);
2462 /* Load a PNG/JPEG image using Quartz 2D decoding routines.
2463 CGImageCreateWithPNGDataProvider is provided after Mac OS X 10.2.
2464 So don't use this function directly but determine at runtime
2465 whether it exists. */
2466 typedef CGImageRef (*CGImageCreateWithPNGDataProviderProcType
)
2467 (CGDataProviderRef
, const float [], bool, CGColorRenderingIntent
);
2468 static CGImageCreateWithPNGDataProviderProcType MyCGImageCreateWithPNGDataProvider
;
2472 init_image_func_pointer ()
2474 if (NSIsSymbolNameDefined ("_CGImageCreateWithPNGDataProvider"))
2476 MyCGImageCreateWithPNGDataProvider
2477 = (CGImageCreateWithPNGDataProviderProcType
)
2478 NSAddressOfSymbol (NSLookupAndBindSymbol
2479 ("_CGImageCreateWithPNGDataProvider"));
2482 MyCGImageCreateWithPNGDataProvider
= NULL
;
2487 image_load_quartz2d (f
, img
, png_p
)
2492 Lisp_Object file
, specified_file
;
2493 Lisp_Object specified_data
, specified_bg
;
2494 struct gcpro gcpro1
;
2495 CGDataProviderRef source
;
2499 XImagePtr ximg
= NULL
;
2500 CGContextRef context
;
2503 /* Open the file. */
2504 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
2505 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
2510 if (NILP (specified_data
))
2515 file
= x_find_image_file (specified_file
);
2516 if (!STRINGP (file
))
2518 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
2522 path
= cfstring_create_with_string (file
);
2523 url
= CFURLCreateWithFileSystemPath (NULL
, path
,
2524 kCFURLPOSIXPathStyle
, 0);
2526 source
= CGDataProviderCreateWithURL (url
);
2530 source
= CGDataProviderCreateWithData (NULL
, SDATA (specified_data
),
2531 SBYTES (specified_data
), NULL
);
2534 image
= (*MyCGImageCreateWithPNGDataProvider
) (source
, NULL
, FALSE
,
2535 kCGRenderingIntentDefault
);
2537 image
= CGImageCreateWithJPEGDataProvider (source
, NULL
, FALSE
,
2538 kCGRenderingIntentDefault
);
2540 CGDataProviderRelease (source
);
2544 image_error ("Error reading image `%s'", img
->spec
, Qnil
);
2547 width
= img
->width
= CGImageGetWidth (image
);
2548 height
= img
->height
= CGImageGetHeight (image
);
2550 if (!check_image_size (f
, width
, height
))
2553 image_error ("Invalid image size", Qnil
, Qnil
);
2559 specified_bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
2560 if (!STRINGP (specified_bg
) ||
2561 !mac_defined_color (f
, SDATA (specified_bg
), &color
, 0))
2563 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
2564 color
.red
= RED16_FROM_ULONG (color
.pixel
);
2565 color
.green
= GREEN16_FROM_ULONG (color
.pixel
);
2566 color
.blue
= BLUE16_FROM_ULONG (color
.pixel
);
2570 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
2572 CGImageRelease (image
);
2576 rectangle
= CGRectMake (0, 0, width
, height
);
2577 QDBeginCGContext (ximg
, &context
);
2580 CGContextSetRGBFillColor (context
, color
.red
/ 65535.0,
2581 color
.green
/ 65535.0,
2582 color
.blue
/ 65535.0, 1.0);
2583 CGContextFillRect (context
, rectangle
);
2585 CGContextDrawImage (context
, rectangle
, image
);
2586 QDEndCGContext (ximg
, &context
);
2587 CGImageRelease (image
);
2589 /* Maybe fill in the background field while we have ximg handy. */
2590 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
2591 IMAGE_BACKGROUND (img
, f
, ximg
);
2593 /* Put the image into the pixmap. */
2594 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
2595 x_destroy_x_image (ximg
);
2604 /***********************************************************************
2606 ***********************************************************************/
2608 static int xbm_scan
P_ ((unsigned char **, unsigned char *, char *, int *));
2609 static int xbm_load
P_ ((struct frame
*f
, struct image
*img
));
2610 static int xbm_load_image
P_ ((struct frame
*f
, struct image
*img
,
2611 unsigned char *, unsigned char *));
2612 static int xbm_image_p
P_ ((Lisp_Object object
));
2613 static int xbm_read_bitmap_data
P_ ((struct frame
*f
,
2614 unsigned char *, unsigned char *,
2615 int *, int *, unsigned char **));
2616 static int xbm_file_p
P_ ((Lisp_Object
));
2619 /* Indices of image specification fields in xbm_format, below. */
2621 enum xbm_keyword_index
2639 /* Vector of image_keyword structures describing the format
2640 of valid XBM image specifications. */
2642 static struct image_keyword xbm_format
[XBM_LAST
] =
2644 {":type", IMAGE_SYMBOL_VALUE
, 1},
2645 {":file", IMAGE_STRING_VALUE
, 0},
2646 {":width", IMAGE_POSITIVE_INTEGER_VALUE
, 0},
2647 {":height", IMAGE_POSITIVE_INTEGER_VALUE
, 0},
2648 {":data", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
2649 {":foreground", IMAGE_STRING_OR_NIL_VALUE
, 0},
2650 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0},
2651 {":ascent", IMAGE_ASCENT_VALUE
, 0},
2652 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
2653 {":relief", IMAGE_INTEGER_VALUE
, 0},
2654 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
2655 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
2656 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0}
2659 /* Structure describing the image type XBM. */
2661 static struct image_type xbm_type
=
2670 /* Tokens returned from xbm_scan. */
2679 /* Return non-zero if OBJECT is a valid XBM-type image specification.
2680 A valid specification is a list starting with the symbol `image'
2681 The rest of the list is a property list which must contain an
2684 If the specification specifies a file to load, it must contain
2685 an entry `:file FILENAME' where FILENAME is a string.
2687 If the specification is for a bitmap loaded from memory it must
2688 contain `:width WIDTH', `:height HEIGHT', and `:data DATA', where
2689 WIDTH and HEIGHT are integers > 0. DATA may be:
2691 1. a string large enough to hold the bitmap data, i.e. it must
2692 have a size >= (WIDTH + 7) / 8 * HEIGHT
2694 2. a bool-vector of size >= WIDTH * HEIGHT
2696 3. a vector of strings or bool-vectors, one for each line of the
2699 4. A string containing an in-memory XBM file. WIDTH and HEIGHT
2700 may not be specified in this case because they are defined in the
2703 Both the file and data forms may contain the additional entries
2704 `:background COLOR' and `:foreground COLOR'. If not present,
2705 foreground and background of the frame on which the image is
2706 displayed is used. */
2709 xbm_image_p (object
)
2712 struct image_keyword kw
[XBM_LAST
];
2714 bcopy (xbm_format
, kw
, sizeof kw
);
2715 if (!parse_image_spec (object
, kw
, XBM_LAST
, Qxbm
))
2718 xassert (EQ (kw
[XBM_TYPE
].value
, Qxbm
));
2720 if (kw
[XBM_FILE
].count
)
2722 if (kw
[XBM_WIDTH
].count
|| kw
[XBM_HEIGHT
].count
|| kw
[XBM_DATA
].count
)
2725 else if (kw
[XBM_DATA
].count
&& xbm_file_p (kw
[XBM_DATA
].value
))
2727 /* In-memory XBM file. */
2728 if (kw
[XBM_WIDTH
].count
|| kw
[XBM_HEIGHT
].count
|| kw
[XBM_FILE
].count
)
2736 /* Entries for `:width', `:height' and `:data' must be present. */
2737 if (!kw
[XBM_WIDTH
].count
2738 || !kw
[XBM_HEIGHT
].count
2739 || !kw
[XBM_DATA
].count
)
2742 data
= kw
[XBM_DATA
].value
;
2743 width
= XFASTINT (kw
[XBM_WIDTH
].value
);
2744 height
= XFASTINT (kw
[XBM_HEIGHT
].value
);
2746 /* Check type of data, and width and height against contents of
2752 /* Number of elements of the vector must be >= height. */
2753 if (XVECTOR (data
)->size
< height
)
2756 /* Each string or bool-vector in data must be large enough
2757 for one line of the image. */
2758 for (i
= 0; i
< height
; ++i
)
2760 Lisp_Object elt
= XVECTOR (data
)->contents
[i
];
2765 < (width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
)
2768 else if (BOOL_VECTOR_P (elt
))
2770 if (XBOOL_VECTOR (elt
)->size
< width
)
2777 else if (STRINGP (data
))
2780 < (width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
* height
)
2783 else if (BOOL_VECTOR_P (data
))
2785 if (XBOOL_VECTOR (data
)->size
< width
* height
)
2796 /* Scan a bitmap file. FP is the stream to read from. Value is
2797 either an enumerator from enum xbm_token, or a character for a
2798 single-character token, or 0 at end of file. If scanning an
2799 identifier, store the lexeme of the identifier in SVAL. If
2800 scanning a number, store its value in *IVAL. */
2803 xbm_scan (s
, end
, sval
, ival
)
2804 unsigned char **s
, *end
;
2812 /* Skip white space. */
2813 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
2818 else if (isdigit (c
))
2820 int value
= 0, digit
;
2822 if (c
== '0' && *s
< end
)
2825 if (c
== 'x' || c
== 'X')
2832 else if (c
>= 'a' && c
<= 'f')
2833 digit
= c
- 'a' + 10;
2834 else if (c
>= 'A' && c
<= 'F')
2835 digit
= c
- 'A' + 10;
2838 value
= 16 * value
+ digit
;
2841 else if (isdigit (c
))
2845 && (c
= *(*s
)++, isdigit (c
)))
2846 value
= 8 * value
+ c
- '0';
2853 && (c
= *(*s
)++, isdigit (c
)))
2854 value
= 10 * value
+ c
- '0';
2862 else if (isalpha (c
) || c
== '_')
2866 && (c
= *(*s
)++, (isalnum (c
) || c
== '_')))
2873 else if (c
== '/' && **s
== '*')
2875 /* C-style comment. */
2877 while (**s
&& (**s
!= '*' || *(*s
+ 1) != '/'))
2891 /* Create a Windows bitmap from X bitmap data. */
2893 w32_create_pixmap_from_bitmap_data (int width
, int height
, char *data
)
2895 static unsigned char swap_nibble
[16]
2896 = { 0x0, 0x8, 0x4, 0xc, /* 0000 1000 0100 1100 */
2897 0x2, 0xa, 0x6, 0xe, /* 0010 1010 0110 1110 */
2898 0x1, 0x9, 0x5, 0xd, /* 0001 1001 0101 1101 */
2899 0x3, 0xb, 0x7, 0xf }; /* 0011 1011 0111 1111 */
2901 unsigned char *bits
, *p
;
2904 w1
= (width
+ 7) / 8; /* nb of 8bits elt in X bitmap */
2905 w2
= ((width
+ 15) / 16) * 2; /* nb of 16bits elt in W32 bitmap */
2906 bits
= (unsigned char *) alloca (height
* w2
);
2907 bzero (bits
, height
* w2
);
2908 for (i
= 0; i
< height
; i
++)
2911 for (j
= 0; j
< w1
; j
++)
2913 /* Bitswap XBM bytes to match how Windows does things. */
2914 unsigned char c
= *data
++;
2915 *p
++ = (unsigned char)((swap_nibble
[c
& 0xf] << 4)
2916 | (swap_nibble
[(c
>>4) & 0xf]));
2919 bmp
= CreateBitmap (width
, height
, 1, 1, (char *) bits
);
2924 static void convert_mono_to_color_image (f
, img
, foreground
, background
)
2927 COLORREF foreground
, background
;
2929 HDC hdc
, old_img_dc
, new_img_dc
;
2930 HGDIOBJ old_prev
, new_prev
;
2933 hdc
= get_frame_dc (f
);
2934 old_img_dc
= CreateCompatibleDC (hdc
);
2935 new_img_dc
= CreateCompatibleDC (hdc
);
2936 new_pixmap
= CreateCompatibleBitmap (hdc
, img
->width
, img
->height
);
2937 release_frame_dc (f
, hdc
);
2938 old_prev
= SelectObject (old_img_dc
, img
->pixmap
);
2939 new_prev
= SelectObject (new_img_dc
, new_pixmap
);
2940 SetTextColor (new_img_dc
, foreground
);
2941 SetBkColor (new_img_dc
, background
);
2943 BitBlt (new_img_dc
, 0, 0, img
->width
, img
->height
, old_img_dc
,
2946 SelectObject (old_img_dc
, old_prev
);
2947 SelectObject (new_img_dc
, new_prev
);
2948 DeleteDC (old_img_dc
);
2949 DeleteDC (new_img_dc
);
2950 DeleteObject (img
->pixmap
);
2951 if (new_pixmap
== 0)
2952 fprintf (stderr
, "Failed to convert image to color.\n");
2954 img
->pixmap
= new_pixmap
;
2957 #define XBM_BIT_SHUFFLE(b) (~(b))
2961 #define XBM_BIT_SHUFFLE(b) (b)
2963 #endif /* HAVE_NTGUI */
2967 Create_Pixmap_From_Bitmap_Data(f
, img
, data
, fg
, bg
, non_default_colors
)
2971 RGB_PIXEL_COLOR fg
, bg
;
2972 int non_default_colors
;
2976 = w32_create_pixmap_from_bitmap_data (img
->width
, img
->height
, data
);
2978 /* If colors were specified, transfer the bitmap to a color one. */
2979 if (non_default_colors
)
2980 convert_mono_to_color_image (f
, img
, fg
, bg
);
2983 = XCreatePixmapFromBitmapData (FRAME_X_DISPLAY (f
),
2986 img
->width
, img
->height
,
2988 DefaultDepthOfScreen (FRAME_X_SCREEN (f
)));
2989 #endif /* HAVE_NTGUI */
2994 /* Replacement for XReadBitmapFileData which isn't available under old
2995 X versions. CONTENTS is a pointer to a buffer to parse; END is the
2996 buffer's end. Set *WIDTH and *HEIGHT to the width and height of
2997 the image. Return in *DATA the bitmap data allocated with xmalloc.
2998 Value is non-zero if successful. DATA null means just test if
2999 CONTENTS looks like an in-memory XBM file. */
3002 xbm_read_bitmap_data (f
, contents
, end
, width
, height
, data
)
3004 unsigned char *contents
, *end
;
3005 int *width
, *height
;
3006 unsigned char **data
;
3008 unsigned char *s
= contents
;
3009 char buffer
[BUFSIZ
];
3012 int bytes_per_line
, i
, nbytes
;
3018 LA1 = xbm_scan (&s, end, buffer, &value)
3020 #define expect(TOKEN) \
3021 if (LA1 != (TOKEN)) \
3026 #define expect_ident(IDENT) \
3027 if (LA1 == XBM_TK_IDENT && strcmp (buffer, (IDENT)) == 0) \
3032 *width
= *height
= -1;
3035 LA1
= xbm_scan (&s
, end
, buffer
, &value
);
3037 /* Parse defines for width, height and hot-spots. */
3041 expect_ident ("define");
3042 expect (XBM_TK_IDENT
);
3044 if (LA1
== XBM_TK_NUMBER
);
3046 char *p
= strrchr (buffer
, '_');
3047 p
= p
? p
+ 1 : buffer
;
3048 if (strcmp (p
, "width") == 0)
3050 else if (strcmp (p
, "height") == 0)
3053 expect (XBM_TK_NUMBER
);
3056 if (!check_image_size (f
, *width
, *height
))
3058 else if (data
== NULL
)
3061 /* Parse bits. Must start with `static'. */
3062 expect_ident ("static");
3063 if (LA1
== XBM_TK_IDENT
)
3065 if (strcmp (buffer
, "unsigned") == 0)
3068 expect_ident ("char");
3070 else if (strcmp (buffer
, "short") == 0)
3074 if (*width
% 16 && *width
% 16 < 9)
3077 else if (strcmp (buffer
, "char") == 0)
3085 expect (XBM_TK_IDENT
);
3091 bytes_per_line
= (*width
+ 7) / 8 + padding_p
;
3092 nbytes
= bytes_per_line
* *height
;
3093 p
= *data
= (unsigned char *) xmalloc (nbytes
);
3097 for (i
= 0; i
< nbytes
; i
+= 2)
3100 expect (XBM_TK_NUMBER
);
3102 *p
++ = XBM_BIT_SHUFFLE (val
);
3103 if (!padding_p
|| ((i
+ 2) % bytes_per_line
))
3104 *p
++ = XBM_BIT_SHUFFLE (value
>> 8);
3106 if (LA1
== ',' || LA1
== '}')
3114 for (i
= 0; i
< nbytes
; ++i
)
3117 expect (XBM_TK_NUMBER
);
3119 *p
++ = XBM_BIT_SHUFFLE (val
);
3121 if (LA1
== ',' || LA1
== '}')
3146 /* Load XBM image IMG which will be displayed on frame F from buffer
3147 CONTENTS. END is the end of the buffer. Value is non-zero if
3151 xbm_load_image (f
, img
, contents
, end
)
3154 unsigned char *contents
, *end
;
3157 unsigned char *data
;
3160 rc
= xbm_read_bitmap_data (f
, contents
, end
, &img
->width
, &img
->height
, &data
);
3163 unsigned long foreground
= FRAME_FOREGROUND_PIXEL (f
);
3164 unsigned long background
= FRAME_BACKGROUND_PIXEL (f
);
3165 int non_default_colors
= 0;
3168 xassert (img
->width
> 0 && img
->height
> 0);
3170 /* Get foreground and background colors, maybe allocate colors. */
3171 value
= image_spec_value (img
->spec
, QCforeground
, NULL
);
3174 foreground
= x_alloc_image_color (f
, img
, value
, foreground
);
3175 non_default_colors
= 1;
3177 value
= image_spec_value (img
->spec
, QCbackground
, NULL
);
3180 background
= x_alloc_image_color (f
, img
, value
, background
);
3181 img
->background
= background
;
3182 img
->background_valid
= 1;
3183 non_default_colors
= 1;
3186 Create_Pixmap_From_Bitmap_Data (f
, img
, data
,
3187 foreground
, background
,
3188 non_default_colors
);
3191 if (img
->pixmap
== NO_PIXMAP
)
3193 x_clear_image (f
, img
);
3194 image_error ("Unable to create X pixmap for `%s'", img
->spec
, Qnil
);
3200 image_error ("Error loading XBM image `%s'", img
->spec
, Qnil
);
3206 /* Value is non-zero if DATA looks like an in-memory XBM file. */
3213 return (STRINGP (data
)
3214 && xbm_read_bitmap_data (NULL
, SDATA (data
),
3221 /* Fill image IMG which is used on frame F with pixmap data. Value is
3222 non-zero if successful. */
3230 Lisp_Object file_name
;
3232 xassert (xbm_image_p (img
->spec
));
3234 /* If IMG->spec specifies a file name, create a non-file spec from it. */
3235 file_name
= image_spec_value (img
->spec
, QCfile
, NULL
);
3236 if (STRINGP (file_name
))
3239 unsigned char *contents
;
3241 struct gcpro gcpro1
;
3243 file
= x_find_image_file (file_name
);
3245 if (!STRINGP (file
))
3247 image_error ("Cannot find image file `%s'", file_name
, Qnil
);
3252 contents
= slurp_file (SDATA (file
), &size
);
3253 if (contents
== NULL
)
3255 image_error ("Error loading XBM image `%s'", img
->spec
, Qnil
);
3260 success_p
= xbm_load_image (f
, img
, contents
, contents
+ size
);
3265 struct image_keyword fmt
[XBM_LAST
];
3267 unsigned long foreground
= FRAME_FOREGROUND_PIXEL (f
);
3268 unsigned long background
= FRAME_BACKGROUND_PIXEL (f
);
3269 int non_default_colors
= 0;
3272 int in_memory_file_p
= 0;
3274 /* See if data looks like an in-memory XBM file. */
3275 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
3276 in_memory_file_p
= xbm_file_p (data
);
3278 /* Parse the image specification. */
3279 bcopy (xbm_format
, fmt
, sizeof fmt
);
3280 parsed_p
= parse_image_spec (img
->spec
, fmt
, XBM_LAST
, Qxbm
);
3283 /* Get specified width, and height. */
3284 if (!in_memory_file_p
)
3286 img
->width
= XFASTINT (fmt
[XBM_WIDTH
].value
);
3287 img
->height
= XFASTINT (fmt
[XBM_HEIGHT
].value
);
3288 xassert (img
->width
> 0 && img
->height
> 0);
3291 /* Get foreground and background colors, maybe allocate colors. */
3292 if (fmt
[XBM_FOREGROUND
].count
3293 && STRINGP (fmt
[XBM_FOREGROUND
].value
))
3295 foreground
= x_alloc_image_color (f
, img
, fmt
[XBM_FOREGROUND
].value
,
3297 non_default_colors
= 1;
3300 if (fmt
[XBM_BACKGROUND
].count
3301 && STRINGP (fmt
[XBM_BACKGROUND
].value
))
3303 background
= x_alloc_image_color (f
, img
, fmt
[XBM_BACKGROUND
].value
,
3305 non_default_colors
= 1;
3308 if (in_memory_file_p
)
3309 success_p
= xbm_load_image (f
, img
, SDATA (data
),
3318 int nbytes
= (img
->width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
;
3320 p
= bits
= (char *) alloca (nbytes
* img
->height
);
3321 for (i
= 0; i
< img
->height
; ++i
, p
+= nbytes
)
3323 Lisp_Object line
= XVECTOR (data
)->contents
[i
];
3325 bcopy (SDATA (line
), p
, nbytes
);
3327 bcopy (XBOOL_VECTOR (line
)->data
, p
, nbytes
);
3330 else if (STRINGP (data
))
3331 bits
= SDATA (data
);
3333 bits
= XBOOL_VECTOR (data
)->data
;
3335 /* Create the pixmap. */
3337 Create_Pixmap_From_Bitmap_Data (f
, img
, bits
,
3338 foreground
, background
,
3339 non_default_colors
);
3344 image_error ("Unable to create pixmap for XBM image `%s'",
3346 x_clear_image (f
, img
);
3356 /***********************************************************************
3358 ***********************************************************************/
3360 #if defined (HAVE_XPM) || defined (MAC_OS)
3362 static int xpm_image_p
P_ ((Lisp_Object object
));
3363 static int xpm_load
P_ ((struct frame
*f
, struct image
*img
));
3364 static int xpm_valid_color_symbols_p
P_ ((Lisp_Object
));
3366 #endif /* HAVE_XPM || MAC_OS */
3370 /* Indicate to xpm.h that we don't have Xlib. */
3372 /* simx.h in xpm defines XColor and XImage differently than Emacs. */
3373 /* It also defines Display the same way as Emacs, but gcc 3.3 still barfs. */
3374 #define XColor xpm_XColor
3375 #define XImage xpm_XImage
3376 #define Display xpm_Display
3377 #define PIXEL_ALREADY_TYPEDEFED
3378 #include "X11/xpm.h"
3383 #undef PIXEL_ALREADY_TYPEDEFED
3385 #include "X11/xpm.h"
3386 #endif /* HAVE_NTGUI */
3387 #endif /* HAVE_XPM */
3389 #if defined (HAVE_XPM) || defined (MAC_OS)
3390 /* The symbol `xpm' identifying XPM-format images. */
3394 /* Indices of image specification fields in xpm_format, below. */
3396 enum xpm_keyword_index
3412 /* Vector of image_keyword structures describing the format
3413 of valid XPM image specifications. */
3415 static struct image_keyword xpm_format
[XPM_LAST
] =
3417 {":type", IMAGE_SYMBOL_VALUE
, 1},
3418 {":file", IMAGE_STRING_VALUE
, 0},
3419 {":data", IMAGE_STRING_VALUE
, 0},
3420 {":ascent", IMAGE_ASCENT_VALUE
, 0},
3421 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
3422 {":relief", IMAGE_INTEGER_VALUE
, 0},
3423 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3424 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3425 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3426 {":color-symbols", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3427 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
3430 /* Structure describing the image type XPM. */
3432 static struct image_type xpm_type
=
3441 #ifdef HAVE_X_WINDOWS
3443 /* Define ALLOC_XPM_COLORS if we can use Emacs' own color allocation
3444 functions for allocating image colors. Our own functions handle
3445 color allocation failures more gracefully than the ones on the XPM
3448 #if defined XpmAllocColor && defined XpmFreeColors && defined XpmColorClosure
3449 #define ALLOC_XPM_COLORS
3451 #endif /* HAVE_X_WINDOWS */
3453 #ifdef ALLOC_XPM_COLORS
3455 static void xpm_init_color_cache
P_ ((struct frame
*, XpmAttributes
*));
3456 static void xpm_free_color_cache
P_ ((void));
3457 static int xpm_lookup_color
P_ ((struct frame
*, char *, XColor
*));
3458 static int xpm_color_bucket
P_ ((char *));
3459 static struct xpm_cached_color
*xpm_cache_color
P_ ((struct frame
*, char *,
3462 /* An entry in a hash table used to cache color definitions of named
3463 colors. This cache is necessary to speed up XPM image loading in
3464 case we do color allocations ourselves. Without it, we would need
3465 a call to XParseColor per pixel in the image. */
3467 struct xpm_cached_color
3469 /* Next in collision chain. */
3470 struct xpm_cached_color
*next
;
3472 /* Color definition (RGB and pixel color). */
3479 /* The hash table used for the color cache, and its bucket vector
3482 #define XPM_COLOR_CACHE_BUCKETS 1001
3483 struct xpm_cached_color
**xpm_color_cache
;
3485 /* Initialize the color cache. */
3488 xpm_init_color_cache (f
, attrs
)
3490 XpmAttributes
*attrs
;
3492 size_t nbytes
= XPM_COLOR_CACHE_BUCKETS
* sizeof *xpm_color_cache
;
3493 xpm_color_cache
= (struct xpm_cached_color
**) xmalloc (nbytes
);
3494 memset (xpm_color_cache
, 0, nbytes
);
3495 init_color_table ();
3497 if (attrs
->valuemask
& XpmColorSymbols
)
3502 for (i
= 0; i
< attrs
->numsymbols
; ++i
)
3503 if (XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
3504 attrs
->colorsymbols
[i
].value
, &color
))
3506 color
.pixel
= lookup_rgb_color (f
, color
.red
, color
.green
,
3508 xpm_cache_color (f
, attrs
->colorsymbols
[i
].name
, &color
, -1);
3513 /* Free the color cache. */
3516 xpm_free_color_cache ()
3518 struct xpm_cached_color
*p
, *next
;
3521 for (i
= 0; i
< XPM_COLOR_CACHE_BUCKETS
; ++i
)
3522 for (p
= xpm_color_cache
[i
]; p
; p
= next
)
3528 xfree (xpm_color_cache
);
3529 xpm_color_cache
= NULL
;
3530 free_color_table ();
3533 /* Return the bucket index for color named COLOR_NAME in the color
3537 xpm_color_bucket (color_name
)
3543 for (s
= color_name
; *s
; ++s
)
3545 return h
%= XPM_COLOR_CACHE_BUCKETS
;
3549 /* On frame F, cache values COLOR for color with name COLOR_NAME.
3550 BUCKET, if >= 0, is a precomputed bucket index. Value is the cache
3553 static struct xpm_cached_color
*
3554 xpm_cache_color (f
, color_name
, color
, bucket
)
3561 struct xpm_cached_color
*p
;
3564 bucket
= xpm_color_bucket (color_name
);
3566 nbytes
= sizeof *p
+ strlen (color_name
);
3567 p
= (struct xpm_cached_color
*) xmalloc (nbytes
);
3568 strcpy (p
->name
, color_name
);
3570 p
->next
= xpm_color_cache
[bucket
];
3571 xpm_color_cache
[bucket
] = p
;
3575 /* Look up color COLOR_NAME for frame F in the color cache. If found,
3576 return the cached definition in *COLOR. Otherwise, make a new
3577 entry in the cache and allocate the color. Value is zero if color
3578 allocation failed. */
3581 xpm_lookup_color (f
, color_name
, color
)
3586 struct xpm_cached_color
*p
;
3587 int h
= xpm_color_bucket (color_name
);
3589 for (p
= xpm_color_cache
[h
]; p
; p
= p
->next
)
3590 if (strcmp (p
->name
, color_name
) == 0)
3595 else if (XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
3598 color
->pixel
= lookup_rgb_color (f
, color
->red
, color
->green
,
3600 p
= xpm_cache_color (f
, color_name
, color
, h
);
3602 /* You get `opaque' at least from ImageMagick converting pbm to xpm
3603 with transparency, and it's useful. */
3604 else if (strcmp ("opaque", color_name
) == 0)
3606 bzero (color
, sizeof (XColor
)); /* Is this necessary/correct? */
3607 color
->pixel
= FRAME_FOREGROUND_PIXEL (f
);
3608 p
= xpm_cache_color (f
, color_name
, color
, h
);
3615 /* Callback for allocating color COLOR_NAME. Called from the XPM lib.
3616 CLOSURE is a pointer to the frame on which we allocate the
3617 color. Return in *COLOR the allocated color. Value is non-zero
3621 xpm_alloc_color (dpy
, cmap
, color_name
, color
, closure
)
3628 return xpm_lookup_color ((struct frame
*) closure
, color_name
, color
);
3632 /* Callback for freeing NPIXELS colors contained in PIXELS. CLOSURE
3633 is a pointer to the frame on which we allocate the color. Value is
3634 non-zero if successful. */
3637 xpm_free_colors (dpy
, cmap
, pixels
, npixels
, closure
)
3647 #endif /* ALLOC_XPM_COLORS */
3652 /* XPM library details. */
3654 DEF_IMGLIB_FN (XpmFreeAttributes
);
3655 DEF_IMGLIB_FN (XpmCreateImageFromBuffer
);
3656 DEF_IMGLIB_FN (XpmReadFileToImage
);
3657 DEF_IMGLIB_FN (XImageFree
);
3660 init_xpm_functions (Lisp_Object libraries
)
3664 if (!(library
= w32_delayed_load (libraries
, Qxpm
)))
3667 LOAD_IMGLIB_FN (library
, XpmFreeAttributes
);
3668 LOAD_IMGLIB_FN (library
, XpmCreateImageFromBuffer
);
3669 LOAD_IMGLIB_FN (library
, XpmReadFileToImage
);
3670 LOAD_IMGLIB_FN (library
, XImageFree
);
3674 #endif /* HAVE_NTGUI */
3677 /* Value is non-zero if COLOR_SYMBOLS is a valid color symbols list
3678 for XPM images. Such a list must consist of conses whose car and
3682 xpm_valid_color_symbols_p (color_symbols
)
3683 Lisp_Object color_symbols
;
3685 while (CONSP (color_symbols
))
3687 Lisp_Object sym
= XCAR (color_symbols
);
3689 || !STRINGP (XCAR (sym
))
3690 || !STRINGP (XCDR (sym
)))
3692 color_symbols
= XCDR (color_symbols
);
3695 return NILP (color_symbols
);
3699 /* Value is non-zero if OBJECT is a valid XPM image specification. */
3702 xpm_image_p (object
)
3705 struct image_keyword fmt
[XPM_LAST
];
3706 bcopy (xpm_format
, fmt
, sizeof fmt
);
3707 return (parse_image_spec (object
, fmt
, XPM_LAST
, Qxpm
)
3708 /* Either `:file' or `:data' must be present. */
3709 && fmt
[XPM_FILE
].count
+ fmt
[XPM_DATA
].count
== 1
3710 /* Either no `:color-symbols' or it's a list of conses
3711 whose car and cdr are strings. */
3712 && (fmt
[XPM_COLOR_SYMBOLS
].count
== 0
3713 || xpm_valid_color_symbols_p (fmt
[XPM_COLOR_SYMBOLS
].value
)));
3716 #endif /* HAVE_XPM || MAC_OS */
3718 /* Load image IMG which will be displayed on frame F. Value is
3719 non-zero if successful. */
3729 XpmAttributes attrs
;
3730 Lisp_Object specified_file
, color_symbols
;
3733 xpm_XImage
* xpm_image
= NULL
, * xpm_mask
= NULL
;
3734 #endif /* HAVE_NTGUI */
3736 /* Configure the XPM lib. Use the visual of frame F. Allocate
3737 close colors. Return colors allocated. */
3738 bzero (&attrs
, sizeof attrs
);
3741 attrs
.visual
= FRAME_X_VISUAL (f
);
3742 attrs
.colormap
= FRAME_X_COLORMAP (f
);
3743 attrs
.valuemask
|= XpmVisual
;
3744 attrs
.valuemask
|= XpmColormap
;
3745 #endif /* HAVE_NTGUI */
3747 #ifdef ALLOC_XPM_COLORS
3748 /* Allocate colors with our own functions which handle
3749 failing color allocation more gracefully. */
3750 attrs
.color_closure
= f
;
3751 attrs
.alloc_color
= xpm_alloc_color
;
3752 attrs
.free_colors
= xpm_free_colors
;
3753 attrs
.valuemask
|= XpmAllocColor
| XpmFreeColors
| XpmColorClosure
;
3754 #else /* not ALLOC_XPM_COLORS */
3755 /* Let the XPM lib allocate colors. */
3756 attrs
.valuemask
|= XpmReturnAllocPixels
;
3757 #ifdef XpmAllocCloseColors
3758 attrs
.alloc_close_colors
= 1;
3759 attrs
.valuemask
|= XpmAllocCloseColors
;
3760 #else /* not XpmAllocCloseColors */
3761 attrs
.closeness
= 600;
3762 attrs
.valuemask
|= XpmCloseness
;
3763 #endif /* not XpmAllocCloseColors */
3764 #endif /* ALLOC_XPM_COLORS */
3766 /* If image specification contains symbolic color definitions, add
3767 these to `attrs'. */
3768 color_symbols
= image_spec_value (img
->spec
, QCcolor_symbols
, NULL
);
3769 if (CONSP (color_symbols
))
3772 XpmColorSymbol
*xpm_syms
;
3775 attrs
.valuemask
|= XpmColorSymbols
;
3777 /* Count number of symbols. */
3778 attrs
.numsymbols
= 0;
3779 for (tail
= color_symbols
; CONSP (tail
); tail
= XCDR (tail
))
3782 /* Allocate an XpmColorSymbol array. */
3783 size
= attrs
.numsymbols
* sizeof *xpm_syms
;
3784 xpm_syms
= (XpmColorSymbol
*) alloca (size
);
3785 bzero (xpm_syms
, size
);
3786 attrs
.colorsymbols
= xpm_syms
;
3788 /* Fill the color symbol array. */
3789 for (tail
= color_symbols
, i
= 0;
3791 ++i
, tail
= XCDR (tail
))
3793 Lisp_Object name
= XCAR (XCAR (tail
));
3794 Lisp_Object color
= XCDR (XCAR (tail
));
3795 xpm_syms
[i
].name
= (char *) alloca (SCHARS (name
) + 1);
3796 strcpy (xpm_syms
[i
].name
, SDATA (name
));
3797 xpm_syms
[i
].value
= (char *) alloca (SCHARS (color
) + 1);
3798 strcpy (xpm_syms
[i
].value
, SDATA (color
));
3802 /* Create a pixmap for the image, either from a file, or from a
3803 string buffer containing data in the same format as an XPM file. */
3804 #ifdef ALLOC_XPM_COLORS
3805 xpm_init_color_cache (f
, &attrs
);
3808 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
3812 HDC frame_dc
= get_frame_dc (f
);
3813 hdc
= CreateCompatibleDC (frame_dc
);
3814 release_frame_dc (f
, frame_dc
);
3816 #endif /* HAVE_NTGUI */
3818 if (STRINGP (specified_file
))
3820 Lisp_Object file
= x_find_image_file (specified_file
);
3821 if (!STRINGP (file
))
3823 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
3828 /* XpmReadFileToPixmap is not available in the Windows port of
3829 libxpm. But XpmReadFileToImage almost does what we want. */
3830 rc
= fn_XpmReadFileToImage (&hdc
, SDATA (file
),
3831 &xpm_image
, &xpm_mask
,
3834 rc
= XpmReadFileToPixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3835 SDATA (file
), &img
->pixmap
, &img
->mask
,
3837 #endif /* HAVE_NTGUI */
3841 Lisp_Object buffer
= image_spec_value (img
->spec
, QCdata
, NULL
);
3843 /* XpmCreatePixmapFromBuffer is not available in the Windows port
3844 of libxpm. But XpmCreateImageFromBuffer almost does what we want. */
3845 rc
= fn_XpmCreateImageFromBuffer (&hdc
, SDATA (buffer
),
3846 &xpm_image
, &xpm_mask
,
3849 rc
= XpmCreatePixmapFromBuffer (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3851 &img
->pixmap
, &img
->mask
,
3853 #endif /* HAVE_NTGUI */
3856 if (rc
== XpmSuccess
)
3858 #if defined (COLOR_TABLE_SUPPORT) && defined (ALLOC_XPM_COLORS)
3859 img
->colors
= colors_in_color_table (&img
->ncolors
);
3860 #else /* not ALLOC_XPM_COLORS */
3864 /* W32 XPM uses XImage to wrap what W32 Emacs calls a Pixmap,
3865 plus some duplicate attributes. */
3866 if (xpm_image
&& xpm_image
->bitmap
)
3868 img
->pixmap
= xpm_image
->bitmap
;
3869 /* XImageFree in libXpm frees XImage struct without destroying
3870 the bitmap, which is what we want. */
3871 fn_XImageFree (xpm_image
);
3873 if (xpm_mask
&& xpm_mask
->bitmap
)
3875 /* The mask appears to be inverted compared with what we expect.
3876 TODO: invert our expectations. See other places where we
3877 have to invert bits because our idea of masks is backwards. */
3879 old_obj
= SelectObject (hdc
, xpm_mask
->bitmap
);
3881 PatBlt (hdc
, 0, 0, xpm_mask
->width
, xpm_mask
->height
, DSTINVERT
);
3882 SelectObject (hdc
, old_obj
);
3884 img
->mask
= xpm_mask
->bitmap
;
3885 fn_XImageFree (xpm_mask
);
3890 #endif /* HAVE_NTGUI */
3892 /* Remember allocated colors. */
3893 img
->ncolors
= attrs
.nalloc_pixels
;
3894 img
->colors
= (unsigned long *) xmalloc (img
->ncolors
3895 * sizeof *img
->colors
);
3896 for (i
= 0; i
< attrs
.nalloc_pixels
; ++i
)
3898 img
->colors
[i
] = attrs
.alloc_pixels
[i
];
3899 #ifdef DEBUG_X_COLORS
3900 register_color (img
->colors
[i
]);
3903 #endif /* not ALLOC_XPM_COLORS */
3905 img
->width
= attrs
.width
;
3906 img
->height
= attrs
.height
;
3907 xassert (img
->width
> 0 && img
->height
> 0);
3909 /* The call to XpmFreeAttributes below frees attrs.alloc_pixels. */
3911 fn_XpmFreeAttributes (&attrs
);
3913 XpmFreeAttributes (&attrs
);
3914 #endif /* HAVE_NTGUI */
3920 #endif /* HAVE_NTGUI */
3925 image_error ("Error opening XPM file (%s)", img
->spec
, Qnil
);
3928 case XpmFileInvalid
:
3929 image_error ("Invalid XPM file (%s)", img
->spec
, Qnil
);
3933 image_error ("Out of memory (%s)", img
->spec
, Qnil
);
3936 case XpmColorFailed
:
3937 image_error ("Color allocation error (%s)", img
->spec
, Qnil
);
3941 image_error ("Unknown error (%s)", img
->spec
, Qnil
);
3946 #ifdef ALLOC_XPM_COLORS
3947 xpm_free_color_cache ();
3949 return rc
== XpmSuccess
;
3952 #endif /* HAVE_XPM */
3956 /* XPM support functions for Mac OS where libxpm is not available.
3957 Only XPM version 3 (without any extensions) is supported. */
3959 static int xpm_scan
P_ ((unsigned char **, unsigned char *,
3960 unsigned char **, int *));
3961 static Lisp_Object xpm_make_color_table_v
3962 P_ ((void (**) (Lisp_Object
, unsigned char *, int, Lisp_Object
),
3963 Lisp_Object (**) (Lisp_Object
, unsigned char *, int)));
3964 static void xpm_put_color_table_v
P_ ((Lisp_Object
, unsigned char *,
3966 static Lisp_Object xpm_get_color_table_v
P_ ((Lisp_Object
,
3967 unsigned char *, int));
3968 static Lisp_Object xpm_make_color_table_h
3969 P_ ((void (**) (Lisp_Object
, unsigned char *, int, Lisp_Object
),
3970 Lisp_Object (**) (Lisp_Object
, unsigned char *, int)));
3971 static void xpm_put_color_table_h
P_ ((Lisp_Object
, unsigned char *,
3973 static Lisp_Object xpm_get_color_table_h
P_ ((Lisp_Object
,
3974 unsigned char *, int));
3975 static int xpm_str_to_color_key
P_ ((char *));
3976 static int xpm_load_image
P_ ((struct frame
*, struct image
*,
3977 unsigned char *, unsigned char *));
3979 /* Tokens returned from xpm_scan. */
3988 /* Scan an XPM data and return a character (< 256) or a token defined
3989 by enum xpm_token above. *S and END are the start (inclusive) and
3990 the end (exclusive) addresses of the data, respectively. Advance
3991 *S while scanning. If token is either XPM_TK_IDENT or
3992 XPM_TK_STRING, *BEG and *LEN are set to the start address and the
3993 length of the corresponding token, respectively. */
3996 xpm_scan (s
, end
, beg
, len
)
3997 unsigned char **s
, *end
, **beg
;
4004 /* Skip white-space. */
4005 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
4008 /* gnus-pointer.xpm uses '-' in its identifier.
4009 sb-dir-plus.xpm uses '+' in its identifier. */
4010 if (isalpha (c
) || c
== '_' || c
== '-' || c
== '+')
4014 (c
= **s
, isalnum (c
) || c
== '_' || c
== '-' || c
== '+'))
4017 return XPM_TK_IDENT
;
4022 while (*s
< end
&& **s
!= '"')
4027 return XPM_TK_STRING
;
4031 if (*s
< end
&& **s
== '*')
4033 /* C-style comment. */
4037 while (*s
< end
&& *(*s
)++ != '*')
4040 while (*s
< end
&& **s
!= '/');
4054 /* Functions for color table lookup in XPM data. A Key is a string
4055 specifying the color of each pixel in XPM data. A value is either
4056 an integer that specifies a pixel color, Qt that specifies
4057 transparency, or Qnil for the unspecified color. If the length of
4058 the key string is one, a vector is used as a table. Otherwise, a
4059 hash table is used. */
4062 xpm_make_color_table_v (put_func
, get_func
)
4063 void (**put_func
) (Lisp_Object
, unsigned char *, int, Lisp_Object
);
4064 Lisp_Object (**get_func
) (Lisp_Object
, unsigned char *, int);
4066 *put_func
= xpm_put_color_table_v
;
4067 *get_func
= xpm_get_color_table_v
;
4068 return Fmake_vector (make_number (256), Qnil
);
4072 xpm_put_color_table_v (color_table
, chars_start
, chars_len
, color
)
4073 Lisp_Object color_table
;
4074 unsigned char *chars_start
;
4078 XVECTOR (color_table
)->contents
[*chars_start
] = color
;
4082 xpm_get_color_table_v (color_table
, chars_start
, chars_len
)
4083 Lisp_Object color_table
;
4084 unsigned char *chars_start
;
4087 return XVECTOR (color_table
)->contents
[*chars_start
];
4091 xpm_make_color_table_h (put_func
, get_func
)
4092 void (**put_func
) (Lisp_Object
, unsigned char *, int, Lisp_Object
);
4093 Lisp_Object (**get_func
) (Lisp_Object
, unsigned char *, int);
4095 *put_func
= xpm_put_color_table_h
;
4096 *get_func
= xpm_get_color_table_h
;
4097 return make_hash_table (Qequal
, make_number (DEFAULT_HASH_SIZE
),
4098 make_float (DEFAULT_REHASH_SIZE
),
4099 make_float (DEFAULT_REHASH_THRESHOLD
),
4104 xpm_put_color_table_h (color_table
, chars_start
, chars_len
, color
)
4105 Lisp_Object color_table
;
4106 unsigned char *chars_start
;
4110 struct Lisp_Hash_Table
*table
= XHASH_TABLE (color_table
);
4112 Lisp_Object chars
= make_unibyte_string (chars_start
, chars_len
);
4114 hash_lookup (table
, chars
, &hash_code
);
4115 hash_put (table
, chars
, color
, hash_code
);
4119 xpm_get_color_table_h (color_table
, chars_start
, chars_len
)
4120 Lisp_Object color_table
;
4121 unsigned char *chars_start
;
4124 struct Lisp_Hash_Table
*table
= XHASH_TABLE (color_table
);
4125 int i
= hash_lookup (table
, make_unibyte_string (chars_start
, chars_len
),
4128 return i
>= 0 ? HASH_VALUE (table
, i
) : Qnil
;
4131 enum xpm_color_key
{
4139 static char xpm_color_key_strings
[][4] = {"s", "m", "g4", "g", "c"};
4142 xpm_str_to_color_key (s
)
4148 i
< sizeof xpm_color_key_strings
/ sizeof xpm_color_key_strings
[0];
4150 if (strcmp (xpm_color_key_strings
[i
], s
) == 0)
4156 xpm_load_image (f
, img
, contents
, end
)
4159 unsigned char *contents
, *end
;
4161 unsigned char *s
= contents
, *beg
, *str
;
4162 unsigned char buffer
[BUFSIZ
];
4163 int width
, height
, x
, y
;
4164 int num_colors
, chars_per_pixel
;
4166 void (*put_color_table
) (Lisp_Object
, unsigned char *, int, Lisp_Object
);
4167 Lisp_Object (*get_color_table
) (Lisp_Object
, unsigned char *, int);
4168 Lisp_Object frame
, color_symbols
, color_table
;
4169 int best_key
, have_mask
= 0;
4170 XImagePtr ximg
= NULL
, mask_img
= NULL
;
4173 LA1 = xpm_scan (&s, end, &beg, &len)
4175 #define expect(TOKEN) \
4176 if (LA1 != (TOKEN)) \
4181 #define expect_ident(IDENT) \
4182 if (LA1 == XPM_TK_IDENT \
4183 && strlen ((IDENT)) == len && memcmp ((IDENT), beg, len) == 0) \
4188 if (!(end
- s
>= 9 && memcmp (s
, "/* XPM */", 9) == 0))
4192 expect_ident ("static");
4193 expect_ident ("char");
4195 expect (XPM_TK_IDENT
);
4200 expect (XPM_TK_STRING
);
4203 memcpy (buffer
, beg
, len
);
4205 if (sscanf (buffer
, "%d %d %d %d", &width
, &height
,
4206 &num_colors
, &chars_per_pixel
) != 4
4207 || width
<= 0 || height
<= 0
4208 || num_colors
<= 0 || chars_per_pixel
<= 0)
4211 if (!check_image_size (f
, width
, height
))
4213 image_error ("Invalid image size", Qnil
, Qnil
);
4219 XSETFRAME (frame
, f
);
4220 if (!NILP (Fxw_display_color_p (frame
)))
4221 best_key
= XPM_COLOR_KEY_C
;
4222 else if (!NILP (Fx_display_grayscale_p (frame
)))
4223 best_key
= (XFASTINT (Fx_display_planes (frame
)) > 2
4224 ? XPM_COLOR_KEY_G
: XPM_COLOR_KEY_G4
);
4226 best_key
= XPM_COLOR_KEY_M
;
4228 color_symbols
= image_spec_value (img
->spec
, QCcolor_symbols
, NULL
);
4229 if (chars_per_pixel
== 1)
4230 color_table
= xpm_make_color_table_v (&put_color_table
,
4233 color_table
= xpm_make_color_table_h (&put_color_table
,
4236 while (num_colors
-- > 0)
4238 unsigned char *color
, *max_color
;
4239 int key
, next_key
, max_key
= 0;
4240 Lisp_Object symbol_color
= Qnil
, color_val
;
4243 expect (XPM_TK_STRING
);
4244 if (len
<= chars_per_pixel
|| len
>= BUFSIZ
+ chars_per_pixel
)
4246 memcpy (buffer
, beg
+ chars_per_pixel
, len
- chars_per_pixel
);
4247 buffer
[len
- chars_per_pixel
] = '\0';
4249 str
= strtok (buffer
, " \t");
4252 key
= xpm_str_to_color_key (str
);
4257 color
= strtok (NULL
, " \t");
4261 while (str
= strtok (NULL
, " \t"))
4263 next_key
= xpm_str_to_color_key (str
);
4266 color
[strlen (color
)] = ' ';
4269 if (key
== XPM_COLOR_KEY_S
)
4271 if (NILP (symbol_color
))
4272 symbol_color
= build_string (color
);
4274 else if (max_key
< key
&& key
<= best_key
)
4284 if (!NILP (color_symbols
) && !NILP (symbol_color
))
4286 Lisp_Object specified_color
= Fassoc (symbol_color
, color_symbols
);
4288 if (CONSP (specified_color
) && STRINGP (XCDR (specified_color
)))
4289 if (xstricmp (SDATA (XCDR (specified_color
)), "None") == 0)
4291 else if (x_defined_color (f
, SDATA (XCDR (specified_color
)),
4293 color_val
= make_number (cdef
.pixel
);
4295 if (NILP (color_val
) && max_key
> 0)
4296 if (xstricmp (max_color
, "None") == 0)
4298 else if (x_defined_color (f
, max_color
, &cdef
, 0))
4299 color_val
= make_number (cdef
.pixel
);
4300 if (!NILP (color_val
))
4301 (*put_color_table
) (color_table
, beg
, chars_per_pixel
, color_val
);
4306 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0,
4307 &ximg
, &img
->pixmap
)
4308 || !x_create_x_image_and_pixmap (f
, width
, height
, 1,
4309 &mask_img
, &img
->mask
))
4311 image_error ("Out of memory (%s)", img
->spec
, Qnil
);
4315 for (y
= 0; y
< height
; y
++)
4317 expect (XPM_TK_STRING
);
4319 if (len
< width
* chars_per_pixel
)
4321 for (x
= 0; x
< width
; x
++, str
+= chars_per_pixel
)
4323 Lisp_Object color_val
=
4324 (*get_color_table
) (color_table
, str
, chars_per_pixel
);
4326 XPutPixel (ximg
, x
, y
,
4327 (INTEGERP (color_val
) ? XINT (color_val
)
4328 : FRAME_FOREGROUND_PIXEL (f
)));
4329 XPutPixel (mask_img
, x
, y
,
4330 (!EQ (color_val
, Qt
) ? PIX_MASK_DRAW
4331 : (have_mask
= 1, PIX_MASK_RETAIN
)));
4338 img
->height
= height
;
4340 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
4341 x_destroy_x_image (ximg
);
4344 /* Fill in the background_transparent field while we have the
4346 image_background_transparent (img
, f
, mask_img
);
4348 x_put_x_image (f
, mask_img
, img
->mask
, width
, height
);
4349 x_destroy_x_image (mask_img
);
4353 x_destroy_x_image (mask_img
);
4354 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
4355 img
->mask
= NO_PIXMAP
;
4361 image_error ("Invalid XPM file (%s)", img
->spec
, Qnil
);
4363 x_destroy_x_image (ximg
);
4364 x_destroy_x_image (mask_img
);
4365 x_clear_image (f
, img
);
4379 Lisp_Object file_name
;
4381 /* If IMG->spec specifies a file name, create a non-file spec from it. */
4382 file_name
= image_spec_value (img
->spec
, QCfile
, NULL
);
4383 if (STRINGP (file_name
))
4386 unsigned char *contents
;
4388 struct gcpro gcpro1
;
4390 file
= x_find_image_file (file_name
);
4392 if (!STRINGP (file
))
4394 image_error ("Cannot find image file `%s'", file_name
, Qnil
);
4399 contents
= slurp_file (SDATA (file
), &size
);
4400 if (contents
== NULL
)
4402 image_error ("Error loading XPM image `%s'", img
->spec
, Qnil
);
4407 success_p
= xpm_load_image (f
, img
, contents
, contents
+ size
);
4415 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
4416 success_p
= xpm_load_image (f
, img
, SDATA (data
),
4417 SDATA (data
) + SBYTES (data
));
4427 /***********************************************************************
4429 ***********************************************************************/
4431 #ifdef COLOR_TABLE_SUPPORT
4433 /* An entry in the color table mapping an RGB color to a pixel color. */
4438 unsigned long pixel
;
4440 /* Next in color table collision list. */
4441 struct ct_color
*next
;
4444 /* The bucket vector size to use. Must be prime. */
4448 /* Value is a hash of the RGB color given by R, G, and B. */
4450 #define CT_HASH_RGB(R, G, B) (((R) << 16) ^ ((G) << 8) ^ (B))
4452 /* The color hash table. */
4454 struct ct_color
**ct_table
;
4456 /* Number of entries in the color table. */
4458 int ct_colors_allocated
;
4460 /* Initialize the color table. */
4465 int size
= CT_SIZE
* sizeof (*ct_table
);
4466 ct_table
= (struct ct_color
**) xmalloc (size
);
4467 bzero (ct_table
, size
);
4468 ct_colors_allocated
= 0;
4472 /* Free memory associated with the color table. */
4478 struct ct_color
*p
, *next
;
4480 for (i
= 0; i
< CT_SIZE
; ++i
)
4481 for (p
= ct_table
[i
]; p
; p
= next
)
4492 /* Value is a pixel color for RGB color R, G, B on frame F. If an
4493 entry for that color already is in the color table, return the
4494 pixel color of that entry. Otherwise, allocate a new color for R,
4495 G, B, and make an entry in the color table. */
4497 static unsigned long
4498 lookup_rgb_color (f
, r
, g
, b
)
4502 unsigned hash
= CT_HASH_RGB (r
, g
, b
);
4503 int i
= hash
% CT_SIZE
;
4505 Display_Info
*dpyinfo
;
4507 /* Handle TrueColor visuals specially, which improves performance by
4508 two orders of magnitude. Freeing colors on TrueColor visuals is
4509 a nop, and pixel colors specify RGB values directly. See also
4510 the Xlib spec, chapter 3.1. */
4511 dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
4512 if (dpyinfo
->red_bits
> 0)
4514 unsigned long pr
, pg
, pb
;
4516 /* Apply gamma-correction like normal color allocation does. */
4520 color
.red
= r
, color
.green
= g
, color
.blue
= b
;
4521 gamma_correct (f
, &color
);
4522 r
= color
.red
, g
= color
.green
, b
= color
.blue
;
4525 /* Scale down RGB values to the visual's bits per RGB, and shift
4526 them to the right position in the pixel color. Note that the
4527 original RGB values are 16-bit values, as usual in X. */
4528 pr
= (r
>> (16 - dpyinfo
->red_bits
)) << dpyinfo
->red_offset
;
4529 pg
= (g
>> (16 - dpyinfo
->green_bits
)) << dpyinfo
->green_offset
;
4530 pb
= (b
>> (16 - dpyinfo
->blue_bits
)) << dpyinfo
->blue_offset
;
4532 /* Assemble the pixel color. */
4533 return pr
| pg
| pb
;
4536 for (p
= ct_table
[i
]; p
; p
= p
->next
)
4537 if (p
->r
== r
&& p
->g
== g
&& p
->b
== b
)
4543 #ifdef HAVE_X_WINDOWS
4552 cmap
= FRAME_X_COLORMAP (f
);
4553 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
4556 ++ct_colors_allocated
;
4557 p
= (struct ct_color
*) xmalloc (sizeof *p
);
4561 p
->pixel
= color
.pixel
;
4562 p
->next
= ct_table
[i
];
4566 return FRAME_FOREGROUND_PIXEL (f
);
4571 color
= PALETTERGB (r
, g
, b
);
4573 color
= RGB_TO_ULONG (r
, g
, b
);
4574 #endif /* HAVE_NTGUI */
4575 ++ct_colors_allocated
;
4576 p
= (struct ct_color
*) xmalloc (sizeof *p
);
4581 p
->next
= ct_table
[i
];
4583 #endif /* HAVE_X_WINDOWS */
4591 /* Look up pixel color PIXEL which is used on frame F in the color
4592 table. If not already present, allocate it. Value is PIXEL. */
4594 static unsigned long
4595 lookup_pixel_color (f
, pixel
)
4597 unsigned long pixel
;
4599 int i
= pixel
% CT_SIZE
;
4602 for (p
= ct_table
[i
]; p
; p
= p
->next
)
4603 if (p
->pixel
== pixel
)
4612 #ifdef HAVE_X_WINDOWS
4613 cmap
= FRAME_X_COLORMAP (f
);
4614 color
.pixel
= pixel
;
4615 x_query_color (f
, &color
);
4616 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
4619 cmap
= DefaultColormapOfScreen (FRAME_X_SCREEN (f
));
4620 color
.pixel
= pixel
;
4621 XQueryColor (NULL
, cmap
, &color
);
4622 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
4624 #endif /* HAVE_X_WINDOWS */
4628 ++ct_colors_allocated
;
4630 p
= (struct ct_color
*) xmalloc (sizeof *p
);
4635 p
->next
= ct_table
[i
];
4639 return FRAME_FOREGROUND_PIXEL (f
);
4645 /* Value is a vector of all pixel colors contained in the color table,
4646 allocated via xmalloc. Set *N to the number of colors. */
4648 static unsigned long *
4649 colors_in_color_table (n
)
4654 unsigned long *colors
;
4656 if (ct_colors_allocated
== 0)
4663 colors
= (unsigned long *) xmalloc (ct_colors_allocated
4665 *n
= ct_colors_allocated
;
4667 for (i
= j
= 0; i
< CT_SIZE
; ++i
)
4668 for (p
= ct_table
[i
]; p
; p
= p
->next
)
4669 colors
[j
++] = p
->pixel
;
4675 #else /* COLOR_TABLE_SUPPORT */
4677 static unsigned long
4678 lookup_rgb_color (f
, r
, g
, b
)
4682 unsigned long pixel
;
4685 pixel
= RGB_TO_ULONG (r
>> 8, g
>> 8, b
>> 8);
4686 gamma_correct (f
, &pixel
);
4690 pixel
= PALETTERGB (r
>> 8, g
>> 8, b
>> 8);
4691 #endif /* HAVE_NTGUI */
4700 #endif /* COLOR_TABLE_SUPPORT */
4703 /***********************************************************************
4705 ***********************************************************************/
4707 static XColor
*x_to_xcolors
P_ ((struct frame
*, struct image
*, int));
4708 static void x_from_xcolors
P_ ((struct frame
*, struct image
*, XColor
*));
4709 static void x_detect_edges
P_ ((struct frame
*, struct image
*, int[9], int));
4712 static void XPutPixel (XImagePtr
, int, int, COLORREF
);
4713 #endif /* HAVE_NTGUI */
4715 /* Non-zero means draw a cross on images having `:conversion
4718 int cross_disabled_images
;
4720 /* Edge detection matrices for different edge-detection
4723 static int emboss_matrix
[9] = {
4725 2, -1, 0, /* y - 1 */
4727 0, 1, -2 /* y + 1 */
4730 static int laplace_matrix
[9] = {
4732 1, 0, 0, /* y - 1 */
4734 0, 0, -1 /* y + 1 */
4737 /* Value is the intensity of the color whose red/green/blue values
4740 #define COLOR_INTENSITY(R, G, B) ((2 * (R) + 3 * (G) + (B)) / 6)
4743 /* On frame F, return an array of XColor structures describing image
4744 IMG->pixmap. Each XColor structure has its pixel color set. RGB_P
4745 non-zero means also fill the red/green/blue members of the XColor
4746 structures. Value is a pointer to the array of XColors structures,
4747 allocated with xmalloc; it must be freed by the caller. */
4750 x_to_xcolors (f
, img
, rgb_p
)
4757 XImagePtr_or_DC ximg
;
4761 #endif /* HAVE_NTGUI */
4763 colors
= (XColor
*) xmalloc (img
->width
* img
->height
* sizeof *colors
);
4766 /* Get the X image IMG->pixmap. */
4767 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
4768 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
4770 /* Load the image into a memory device context. */
4771 hdc
= get_frame_dc (f
);
4772 ximg
= CreateCompatibleDC (hdc
);
4773 release_frame_dc (f
, hdc
);
4774 prev
= SelectObject (ximg
, img
->pixmap
);
4775 #endif /* HAVE_NTGUI */
4777 /* Fill the `pixel' members of the XColor array. I wished there
4778 were an easy and portable way to circumvent XGetPixel. */
4780 for (y
= 0; y
< img
->height
; ++y
)
4784 #ifdef HAVE_X_WINDOWS
4785 for (x
= 0; x
< img
->width
; ++x
, ++p
)
4786 p
->pixel
= XGetPixel (ximg
, x
, y
);
4788 x_query_colors (f
, row
, img
->width
);
4792 for (x
= 0; x
< img
->width
; ++x
, ++p
)
4794 /* W32_TODO: palette support needed here? */
4795 p
->pixel
= GET_PIXEL (ximg
, x
, y
);
4799 p
->red
= RED16_FROM_ULONG (p
->pixel
);
4800 p
->green
= GREEN16_FROM_ULONG (p
->pixel
);
4801 p
->blue
= BLUE16_FROM_ULONG (p
->pixel
);
4804 p
->red
= 256 * GetRValue (p
->pixel
);
4805 p
->green
= 256 * GetGValue (p
->pixel
);
4806 p
->blue
= 256 * GetBValue (p
->pixel
);
4807 #endif /* HAVE_NTGUI */
4810 #endif /* HAVE_X_WINDOWS */
4813 Destroy_Image (ximg
, prev
);
4820 /* Put a pixel of COLOR at position X, Y in XIMG. XIMG must have been
4821 created with CreateDIBSection, with the pointer to the bit values
4822 stored in ximg->data. */
4824 static void XPutPixel (ximg
, x
, y
, color
)
4829 int width
= ximg
->info
.bmiHeader
.biWidth
;
4830 int height
= ximg
->info
.bmiHeader
.biHeight
;
4831 unsigned char * pixel
;
4833 /* True color images. */
4834 if (ximg
->info
.bmiHeader
.biBitCount
== 24)
4836 int rowbytes
= width
* 3;
4837 /* Ensure scanlines are aligned on 4 byte boundaries. */
4839 rowbytes
+= 4 - (rowbytes
% 4);
4841 pixel
= ximg
->data
+ y
* rowbytes
+ x
* 3;
4842 /* Windows bitmaps are in BGR order. */
4843 *pixel
= GetBValue (color
);
4844 *(pixel
+ 1) = GetGValue (color
);
4845 *(pixel
+ 2) = GetRValue (color
);
4847 /* Monochrome images. */
4848 else if (ximg
->info
.bmiHeader
.biBitCount
== 1)
4850 int rowbytes
= width
/ 8;
4851 /* Ensure scanlines are aligned on 4 byte boundaries. */
4853 rowbytes
+= 4 - (rowbytes
% 4);
4854 pixel
= ximg
->data
+ y
* rowbytes
+ x
/ 8;
4855 /* Filter out palette info. */
4856 if (color
& 0x00ffffff)
4857 *pixel
= *pixel
| (1 << x
% 8);
4859 *pixel
= *pixel
& ~(1 << x
% 8);
4862 image_error ("XPutPixel: palette image not supported", Qnil
, Qnil
);
4865 #endif /* HAVE_NTGUI */
4867 /* Create IMG->pixmap from an array COLORS of XColor structures, whose
4868 RGB members are set. F is the frame on which this all happens.
4869 COLORS will be freed; an existing IMG->pixmap will be freed, too. */
4872 x_from_xcolors (f
, img
, colors
)
4882 init_color_table ();
4884 x_create_x_image_and_pixmap (f
, img
->width
, img
->height
, 0,
4887 for (y
= 0; y
< img
->height
; ++y
)
4888 for (x
= 0; x
< img
->width
; ++x
, ++p
)
4890 unsigned long pixel
;
4891 pixel
= lookup_rgb_color (f
, p
->red
, p
->green
, p
->blue
);
4892 XPutPixel (oimg
, x
, y
, pixel
);
4896 x_clear_image_1 (f
, img
, 1, 0, 1);
4898 x_put_x_image (f
, oimg
, pixmap
, img
->width
, img
->height
);
4899 x_destroy_x_image (oimg
);
4900 img
->pixmap
= pixmap
;
4901 #ifdef COLOR_TABLE_SUPPORT
4902 img
->colors
= colors_in_color_table (&img
->ncolors
);
4903 free_color_table ();
4904 #endif /* COLOR_TABLE_SUPPORT */
4908 /* On frame F, perform edge-detection on image IMG.
4910 MATRIX is a nine-element array specifying the transformation
4911 matrix. See emboss_matrix for an example.
4913 COLOR_ADJUST is a color adjustment added to each pixel of the
4917 x_detect_edges (f
, img
, matrix
, color_adjust
)
4920 int matrix
[9], color_adjust
;
4922 XColor
*colors
= x_to_xcolors (f
, img
, 1);
4926 for (i
= sum
= 0; i
< 9; ++i
)
4927 sum
+= abs (matrix
[i
]);
4929 #define COLOR(A, X, Y) ((A) + (Y) * img->width + (X))
4931 new = (XColor
*) xmalloc (img
->width
* img
->height
* sizeof *new);
4933 for (y
= 0; y
< img
->height
; ++y
)
4935 p
= COLOR (new, 0, y
);
4936 p
->red
= p
->green
= p
->blue
= 0xffff/2;
4937 p
= COLOR (new, img
->width
- 1, y
);
4938 p
->red
= p
->green
= p
->blue
= 0xffff/2;
4941 for (x
= 1; x
< img
->width
- 1; ++x
)
4943 p
= COLOR (new, x
, 0);
4944 p
->red
= p
->green
= p
->blue
= 0xffff/2;
4945 p
= COLOR (new, x
, img
->height
- 1);
4946 p
->red
= p
->green
= p
->blue
= 0xffff/2;
4949 for (y
= 1; y
< img
->height
- 1; ++y
)
4951 p
= COLOR (new, 1, y
);
4953 for (x
= 1; x
< img
->width
- 1; ++x
, ++p
)
4955 int r
, g
, b
, y1
, x1
;
4958 for (y1
= y
- 1; y1
< y
+ 2; ++y1
)
4959 for (x1
= x
- 1; x1
< x
+ 2; ++x1
, ++i
)
4962 XColor
*t
= COLOR (colors
, x1
, y1
);
4963 r
+= matrix
[i
] * t
->red
;
4964 g
+= matrix
[i
] * t
->green
;
4965 b
+= matrix
[i
] * t
->blue
;
4968 r
= (r
/ sum
+ color_adjust
) & 0xffff;
4969 g
= (g
/ sum
+ color_adjust
) & 0xffff;
4970 b
= (b
/ sum
+ color_adjust
) & 0xffff;
4971 p
->red
= p
->green
= p
->blue
= COLOR_INTENSITY (r
, g
, b
);
4976 x_from_xcolors (f
, img
, new);
4982 /* Perform the pre-defined `emboss' edge-detection on image IMG
4990 x_detect_edges (f
, img
, emboss_matrix
, 0xffff / 2);
4994 /* Transform image IMG which is used on frame F with a Laplace
4995 edge-detection algorithm. The result is an image that can be used
4996 to draw disabled buttons, for example. */
5003 x_detect_edges (f
, img
, laplace_matrix
, 45000);
5007 /* Perform edge-detection on image IMG on frame F, with specified
5008 transformation matrix MATRIX and color-adjustment COLOR_ADJUST.
5010 MATRIX must be either
5012 - a list of at least 9 numbers in row-major form
5013 - a vector of at least 9 numbers
5015 COLOR_ADJUST nil means use a default; otherwise it must be a
5019 x_edge_detection (f
, img
, matrix
, color_adjust
)
5022 Lisp_Object matrix
, color_adjust
;
5030 i
< 9 && CONSP (matrix
) && NUMBERP (XCAR (matrix
));
5031 ++i
, matrix
= XCDR (matrix
))
5032 trans
[i
] = XFLOATINT (XCAR (matrix
));
5034 else if (VECTORP (matrix
) && ASIZE (matrix
) >= 9)
5036 for (i
= 0; i
< 9 && NUMBERP (AREF (matrix
, i
)); ++i
)
5037 trans
[i
] = XFLOATINT (AREF (matrix
, i
));
5040 if (NILP (color_adjust
))
5041 color_adjust
= make_number (0xffff / 2);
5043 if (i
== 9 && NUMBERP (color_adjust
))
5044 x_detect_edges (f
, img
, trans
, (int) XFLOATINT (color_adjust
));
5048 /* Transform image IMG on frame F so that it looks disabled. */
5051 x_disable_image (f
, img
)
5055 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
5057 int n_planes
= dpyinfo
->n_planes
* dpyinfo
->n_cbits
;
5059 int n_planes
= dpyinfo
->n_planes
;
5060 #endif /* HAVE_NTGUI */
5064 /* Color (or grayscale). Convert to gray, and equalize. Just
5065 drawing such images with a stipple can look very odd, so
5066 we're using this method instead. */
5067 XColor
*colors
= x_to_xcolors (f
, img
, 1);
5069 const int h
= 15000;
5070 const int l
= 30000;
5072 for (p
= colors
, end
= colors
+ img
->width
* img
->height
;
5076 int i
= COLOR_INTENSITY (p
->red
, p
->green
, p
->blue
);
5077 int i2
= (0xffff - h
- l
) * i
/ 0xffff + l
;
5078 p
->red
= p
->green
= p
->blue
= i2
;
5081 x_from_xcolors (f
, img
, colors
);
5084 /* Draw a cross over the disabled image, if we must or if we
5086 if (n_planes
< 2 || cross_disabled_images
)
5089 Display
*dpy
= FRAME_X_DISPLAY (f
);
5093 #define XCreateGC_pixmap(dpy, pixmap) XCreateGC (dpy, NULL, 0, NULL)
5094 #define MaskForeground(f) PIX_MASK_DRAW
5096 #define XCreateGC_pixmap(dpy, pixmap) XCreateGC (dpy, pixmap, 0, NULL)
5097 #define MaskForeground(f) WHITE_PIX_DEFAULT (f)
5100 gc
= XCreateGC_pixmap (dpy
, img
->pixmap
);
5101 XSetForeground (dpy
, gc
, BLACK_PIX_DEFAULT (f
));
5102 XDrawLine (dpy
, img
->pixmap
, gc
, 0, 0,
5103 img
->width
- 1, img
->height
- 1);
5104 XDrawLine (dpy
, img
->pixmap
, gc
, 0, img
->height
- 1,
5110 gc
= XCreateGC_pixmap (dpy
, img
->mask
);
5111 XSetForeground (dpy
, gc
, MaskForeground (f
));
5112 XDrawLine (dpy
, img
->mask
, gc
, 0, 0,
5113 img
->width
- 1, img
->height
- 1);
5114 XDrawLine (dpy
, img
->mask
, gc
, 0, img
->height
- 1,
5122 hdc
= get_frame_dc (f
);
5123 bmpdc
= CreateCompatibleDC (hdc
);
5124 release_frame_dc (f
, hdc
);
5126 prev
= SelectObject (bmpdc
, img
->pixmap
);
5128 SetTextColor (bmpdc
, BLACK_PIX_DEFAULT (f
));
5129 MoveToEx (bmpdc
, 0, 0, NULL
);
5130 LineTo (bmpdc
, img
->width
- 1, img
->height
- 1);
5131 MoveToEx (bmpdc
, 0, img
->height
- 1, NULL
);
5132 LineTo (bmpdc
, img
->width
- 1, 0);
5136 SelectObject (bmpdc
, img
->mask
);
5137 SetTextColor (bmpdc
, WHITE_PIX_DEFAULT (f
));
5138 MoveToEx (bmpdc
, 0, 0, NULL
);
5139 LineTo (bmpdc
, img
->width
- 1, img
->height
- 1);
5140 MoveToEx (bmpdc
, 0, img
->height
- 1, NULL
);
5141 LineTo (bmpdc
, img
->width
- 1, 0);
5143 SelectObject (bmpdc
, prev
);
5145 #endif /* HAVE_NTGUI */
5150 /* Build a mask for image IMG which is used on frame F. FILE is the
5151 name of an image file, for error messages. HOW determines how to
5152 determine the background color of IMG. If it is a list '(R G B)',
5153 with R, G, and B being integers >= 0, take that as the color of the
5154 background. Otherwise, determine the background color of IMG
5155 heuristically. Value is non-zero if successful. */
5158 x_build_heuristic_mask (f
, img
, how
)
5163 XImagePtr_or_DC ximg
;
5171 #endif /* HAVE_NTGUI */
5172 int x
, y
, rc
, use_img_background
;
5173 unsigned long bg
= 0;
5177 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
5178 img
->mask
= NO_PIXMAP
;
5179 img
->background_transparent_valid
= 0;
5183 /* Create an image and pixmap serving as mask. */
5184 rc
= x_create_x_image_and_pixmap (f
, img
->width
, img
->height
, 1,
5185 &mask_img
, &img
->mask
);
5189 /* Get the X image of IMG->pixmap. */
5190 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
, 0, 0,
5191 img
->width
, img
->height
,
5194 /* Create the bit array serving as mask. */
5195 row_width
= (img
->width
+ 7) / 8;
5196 mask_img
= xmalloc (row_width
* img
->height
);
5197 bzero (mask_img
, row_width
* img
->height
);
5199 /* Create a memory device context for IMG->pixmap. */
5200 frame_dc
= get_frame_dc (f
);
5201 ximg
= CreateCompatibleDC (frame_dc
);
5202 release_frame_dc (f
, frame_dc
);
5203 prev
= SelectObject (ximg
, img
->pixmap
);
5204 #endif /* HAVE_NTGUI */
5206 /* Determine the background color of ximg. If HOW is `(R G B)'
5207 take that as color. Otherwise, use the image's background color. */
5208 use_img_background
= 1;
5214 for (i
= 0; i
< 3 && CONSP (how
) && NATNUMP (XCAR (how
)); ++i
)
5216 rgb
[i
] = XFASTINT (XCAR (how
)) & 0xffff;
5220 if (i
== 3 && NILP (how
))
5222 char color_name
[30];
5223 sprintf (color_name
, "#%04x%04x%04x", rgb
[0], rgb
[1], rgb
[2]);
5226 0x00ffffff & /* Filter out palette info. */
5227 #endif /* HAVE_NTGUI */
5228 x_alloc_image_color (f
, img
, build_string (color_name
), 0));
5229 use_img_background
= 0;
5233 if (use_img_background
)
5234 bg
= four_corners_best (ximg
, img
->width
, img
->height
);
5236 /* Set all bits in mask_img to 1 whose color in ximg is different
5237 from the background color bg. */
5239 for (y
= 0; y
< img
->height
; ++y
)
5240 for (x
= 0; x
< img
->width
; ++x
)
5241 XPutPixel (mask_img
, x
, y
, (XGetPixel (ximg
, x
, y
) != bg
5242 ? PIX_MASK_DRAW
: PIX_MASK_RETAIN
));
5244 /* Fill in the background_transparent field while we have the mask handy. */
5245 image_background_transparent (img
, f
, mask_img
);
5247 /* Put mask_img into img->mask. */
5248 x_put_x_image (f
, mask_img
, img
->mask
, img
->width
, img
->height
);
5249 x_destroy_x_image (mask_img
);
5252 for (y
= 0; y
< img
->height
; ++y
)
5253 for (x
= 0; x
< img
->width
; ++x
)
5255 COLORREF p
= GetPixel (ximg
, x
, y
);
5257 mask_img
[y
* row_width
+ x
/ 8] |= 1 << (x
% 8);
5260 /* Create the mask image. */
5261 img
->mask
= w32_create_pixmap_from_bitmap_data (img
->width
, img
->height
,
5263 /* Fill in the background_transparent field while we have the mask handy. */
5264 SelectObject (ximg
, img
->mask
);
5265 image_background_transparent (img
, f
, ximg
);
5267 /* Was: x_destroy_x_image ((XImagePtr )mask_img); which seems bogus ++kfs */
5269 #endif /* HAVE_NTGUI */
5271 Destroy_Image (ximg
, prev
);
5277 /***********************************************************************
5278 PBM (mono, gray, color)
5279 ***********************************************************************/
5281 static int pbm_image_p
P_ ((Lisp_Object object
));
5282 static int pbm_load
P_ ((struct frame
*f
, struct image
*img
));
5283 static int pbm_scan_number
P_ ((unsigned char **, unsigned char *));
5285 /* The symbol `pbm' identifying images of this type. */
5289 /* Indices of image specification fields in gs_format, below. */
5291 enum pbm_keyword_index
5307 /* Vector of image_keyword structures describing the format
5308 of valid user-defined image specifications. */
5310 static struct image_keyword pbm_format
[PBM_LAST
] =
5312 {":type", IMAGE_SYMBOL_VALUE
, 1},
5313 {":file", IMAGE_STRING_VALUE
, 0},
5314 {":data", IMAGE_STRING_VALUE
, 0},
5315 {":ascent", IMAGE_ASCENT_VALUE
, 0},
5316 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
5317 {":relief", IMAGE_INTEGER_VALUE
, 0},
5318 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5319 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5320 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5321 {":foreground", IMAGE_STRING_OR_NIL_VALUE
, 0},
5322 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
5325 /* Structure describing the image type `pbm'. */
5327 static struct image_type pbm_type
=
5337 /* Return non-zero if OBJECT is a valid PBM image specification. */
5340 pbm_image_p (object
)
5343 struct image_keyword fmt
[PBM_LAST
];
5345 bcopy (pbm_format
, fmt
, sizeof fmt
);
5347 if (!parse_image_spec (object
, fmt
, PBM_LAST
, Qpbm
))
5350 /* Must specify either :data or :file. */
5351 return fmt
[PBM_DATA
].count
+ fmt
[PBM_FILE
].count
== 1;
5355 /* Scan a decimal number from *S and return it. Advance *S while
5356 reading the number. END is the end of the string. Value is -1 at
5360 pbm_scan_number (s
, end
)
5361 unsigned char **s
, *end
;
5363 int c
= 0, val
= -1;
5367 /* Skip white-space. */
5368 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
5373 /* Skip comment to end of line. */
5374 while (*s
< end
&& (c
= *(*s
)++, c
!= '\n'))
5377 else if (isdigit (c
))
5379 /* Read decimal number. */
5381 while (*s
< end
&& (c
= *(*s
)++, isdigit (c
)))
5382 val
= 10 * val
+ c
- '0';
5394 #if 0 /* Unused. ++kfs */
5396 /* Read FILE into memory. Value is a pointer to a buffer allocated
5397 with xmalloc holding FILE's contents. Value is null if an error
5398 occurred. *SIZE is set to the size of the file. */
5401 pbm_read_file (file
, size
)
5409 if (stat (SDATA (file
), &st
) == 0
5410 && (fp
= fopen (SDATA (file
), "rb")) != NULL
5411 && (buf
= (char *) xmalloc (st
.st_size
),
5412 fread (buf
, 1, st
.st_size
, fp
) == st
.st_size
))
5431 #endif /* HAVE_NTGUI */
5433 /* Load PBM image IMG for use on frame F. */
5441 int width
, height
, max_color_idx
= 0;
5443 Lisp_Object file
, specified_file
;
5444 enum {PBM_MONO
, PBM_GRAY
, PBM_COLOR
} type
;
5445 struct gcpro gcpro1
;
5446 unsigned char *contents
= NULL
;
5447 unsigned char *end
, *p
;
5450 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
5454 if (STRINGP (specified_file
))
5456 file
= x_find_image_file (specified_file
);
5457 if (!STRINGP (file
))
5459 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
5464 contents
= slurp_file (SDATA (file
), &size
);
5465 if (contents
== NULL
)
5467 image_error ("Error reading `%s'", file
, Qnil
);
5473 end
= contents
+ size
;
5478 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
5480 end
= p
+ SBYTES (data
);
5483 /* Check magic number. */
5484 if (end
- p
< 2 || *p
++ != 'P')
5486 image_error ("Not a PBM image: `%s'", img
->spec
, Qnil
);
5496 raw_p
= 0, type
= PBM_MONO
;
5500 raw_p
= 0, type
= PBM_GRAY
;
5504 raw_p
= 0, type
= PBM_COLOR
;
5508 raw_p
= 1, type
= PBM_MONO
;
5512 raw_p
= 1, type
= PBM_GRAY
;
5516 raw_p
= 1, type
= PBM_COLOR
;
5520 image_error ("Not a PBM image: `%s'", img
->spec
, Qnil
);
5524 /* Read width, height, maximum color-component. Characters
5525 starting with `#' up to the end of a line are ignored. */
5526 width
= pbm_scan_number (&p
, end
);
5527 height
= pbm_scan_number (&p
, end
);
5529 if (type
!= PBM_MONO
)
5531 max_color_idx
= pbm_scan_number (&p
, end
);
5532 if (raw_p
&& max_color_idx
> 255)
5533 max_color_idx
= 255;
5536 if (!check_image_size (f
, width
, height
)
5537 || (type
!= PBM_MONO
&& max_color_idx
< 0))
5540 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0,
5541 &ximg
, &img
->pixmap
))
5544 /* Initialize the color hash table. */
5545 init_color_table ();
5547 if (type
== PBM_MONO
)
5550 struct image_keyword fmt
[PBM_LAST
];
5551 unsigned long fg
= FRAME_FOREGROUND_PIXEL (f
);
5552 unsigned long bg
= FRAME_BACKGROUND_PIXEL (f
);
5554 /* Parse the image specification. */
5555 bcopy (pbm_format
, fmt
, sizeof fmt
);
5556 parse_image_spec (img
->spec
, fmt
, PBM_LAST
, Qpbm
);
5558 /* Get foreground and background colors, maybe allocate colors. */
5559 if (fmt
[PBM_FOREGROUND
].count
5560 && STRINGP (fmt
[PBM_FOREGROUND
].value
))
5561 fg
= x_alloc_image_color (f
, img
, fmt
[PBM_FOREGROUND
].value
, fg
);
5562 if (fmt
[PBM_BACKGROUND
].count
5563 && STRINGP (fmt
[PBM_BACKGROUND
].value
))
5565 bg
= x_alloc_image_color (f
, img
, fmt
[PBM_BACKGROUND
].value
, bg
);
5566 img
->background
= bg
;
5567 img
->background_valid
= 1;
5570 for (y
= 0; y
< height
; ++y
)
5571 for (x
= 0; x
< width
; ++x
)
5581 g
= pbm_scan_number (&p
, end
);
5583 XPutPixel (ximg
, x
, y
, g
? fg
: bg
);
5588 for (y
= 0; y
< height
; ++y
)
5589 for (x
= 0; x
< width
; ++x
)
5593 if (type
== PBM_GRAY
)
5594 r
= g
= b
= raw_p
? *p
++ : pbm_scan_number (&p
, end
);
5603 r
= pbm_scan_number (&p
, end
);
5604 g
= pbm_scan_number (&p
, end
);
5605 b
= pbm_scan_number (&p
, end
);
5608 if (r
< 0 || g
< 0 || b
< 0)
5610 x_destroy_x_image (ximg
);
5611 image_error ("Invalid pixel value in image `%s'",
5616 /* RGB values are now in the range 0..max_color_idx.
5617 Scale this to the range 0..0xffff supported by X. */
5618 r
= (double) r
* 65535 / max_color_idx
;
5619 g
= (double) g
* 65535 / max_color_idx
;
5620 b
= (double) b
* 65535 / max_color_idx
;
5621 XPutPixel (ximg
, x
, y
, lookup_rgb_color (f
, r
, g
, b
));
5625 #ifdef COLOR_TABLE_SUPPORT
5626 /* Store in IMG->colors the colors allocated for the image, and
5627 free the color table. */
5628 img
->colors
= colors_in_color_table (&img
->ncolors
);
5629 free_color_table ();
5630 #endif /* COLOR_TABLE_SUPPORT */
5633 img
->height
= height
;
5635 /* Maybe fill in the background field while we have ximg handy. */
5637 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
5638 /* Casting avoids a GCC warning. */
5639 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
5641 /* Put the image into a pixmap. */
5642 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
5643 x_destroy_x_image (ximg
);
5645 /* X and W32 versions did it here, MAC version above. ++kfs
5647 img->height = height; */
5655 /***********************************************************************
5657 ***********************************************************************/
5659 #if defined (HAVE_PNG) || defined (MAC_OS)
5661 /* Function prototypes. */
5663 static int png_image_p
P_ ((Lisp_Object object
));
5664 static int png_load
P_ ((struct frame
*f
, struct image
*img
));
5666 /* The symbol `png' identifying images of this type. */
5670 /* Indices of image specification fields in png_format, below. */
5672 enum png_keyword_index
5687 /* Vector of image_keyword structures describing the format
5688 of valid user-defined image specifications. */
5690 static struct image_keyword png_format
[PNG_LAST
] =
5692 {":type", IMAGE_SYMBOL_VALUE
, 1},
5693 {":data", IMAGE_STRING_VALUE
, 0},
5694 {":file", IMAGE_STRING_VALUE
, 0},
5695 {":ascent", IMAGE_ASCENT_VALUE
, 0},
5696 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
5697 {":relief", IMAGE_INTEGER_VALUE
, 0},
5698 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5699 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5700 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5701 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
5704 /* Structure describing the image type `png'. */
5706 static struct image_type png_type
=
5715 /* Return non-zero if OBJECT is a valid PNG image specification. */
5718 png_image_p (object
)
5721 struct image_keyword fmt
[PNG_LAST
];
5722 bcopy (png_format
, fmt
, sizeof fmt
);
5724 if (!parse_image_spec (object
, fmt
, PNG_LAST
, Qpng
))
5727 /* Must specify either the :data or :file keyword. */
5728 return fmt
[PNG_FILE
].count
+ fmt
[PNG_DATA
].count
== 1;
5731 #endif /* HAVE_PNG || MAC_OS */
5736 #if defined HAVE_LIBPNG_PNG_H
5737 # include <libpng/png.h>
5743 /* PNG library details. */
5745 DEF_IMGLIB_FN (png_get_io_ptr
);
5746 DEF_IMGLIB_FN (png_check_sig
);
5747 DEF_IMGLIB_FN (png_create_read_struct
);
5748 DEF_IMGLIB_FN (png_create_info_struct
);
5749 DEF_IMGLIB_FN (png_destroy_read_struct
);
5750 DEF_IMGLIB_FN (png_set_read_fn
);
5751 DEF_IMGLIB_FN (png_set_sig_bytes
);
5752 DEF_IMGLIB_FN (png_read_info
);
5753 DEF_IMGLIB_FN (png_get_IHDR
);
5754 DEF_IMGLIB_FN (png_get_valid
);
5755 DEF_IMGLIB_FN (png_set_strip_16
);
5756 DEF_IMGLIB_FN (png_set_expand
);
5757 DEF_IMGLIB_FN (png_set_gray_to_rgb
);
5758 DEF_IMGLIB_FN (png_set_background
);
5759 DEF_IMGLIB_FN (png_get_bKGD
);
5760 DEF_IMGLIB_FN (png_read_update_info
);
5761 DEF_IMGLIB_FN (png_get_channels
);
5762 DEF_IMGLIB_FN (png_get_rowbytes
);
5763 DEF_IMGLIB_FN (png_read_image
);
5764 DEF_IMGLIB_FN (png_read_end
);
5765 DEF_IMGLIB_FN (png_error
);
5768 init_png_functions (Lisp_Object libraries
)
5772 /* Try loading libpng under probable names. */
5773 if (!(library
= w32_delayed_load (libraries
, Qpng
)))
5776 LOAD_IMGLIB_FN (library
, png_get_io_ptr
);
5777 LOAD_IMGLIB_FN (library
, png_check_sig
);
5778 LOAD_IMGLIB_FN (library
, png_create_read_struct
);
5779 LOAD_IMGLIB_FN (library
, png_create_info_struct
);
5780 LOAD_IMGLIB_FN (library
, png_destroy_read_struct
);
5781 LOAD_IMGLIB_FN (library
, png_set_read_fn
);
5782 LOAD_IMGLIB_FN (library
, png_set_sig_bytes
);
5783 LOAD_IMGLIB_FN (library
, png_read_info
);
5784 LOAD_IMGLIB_FN (library
, png_get_IHDR
);
5785 LOAD_IMGLIB_FN (library
, png_get_valid
);
5786 LOAD_IMGLIB_FN (library
, png_set_strip_16
);
5787 LOAD_IMGLIB_FN (library
, png_set_expand
);
5788 LOAD_IMGLIB_FN (library
, png_set_gray_to_rgb
);
5789 LOAD_IMGLIB_FN (library
, png_set_background
);
5790 LOAD_IMGLIB_FN (library
, png_get_bKGD
);
5791 LOAD_IMGLIB_FN (library
, png_read_update_info
);
5792 LOAD_IMGLIB_FN (library
, png_get_channels
);
5793 LOAD_IMGLIB_FN (library
, png_get_rowbytes
);
5794 LOAD_IMGLIB_FN (library
, png_read_image
);
5795 LOAD_IMGLIB_FN (library
, png_read_end
);
5796 LOAD_IMGLIB_FN (library
, png_error
);
5801 #define fn_png_get_io_ptr png_get_io_ptr
5802 #define fn_png_check_sig png_check_sig
5803 #define fn_png_create_read_struct png_create_read_struct
5804 #define fn_png_create_info_struct png_create_info_struct
5805 #define fn_png_destroy_read_struct png_destroy_read_struct
5806 #define fn_png_set_read_fn png_set_read_fn
5807 #define fn_png_set_sig_bytes png_set_sig_bytes
5808 #define fn_png_read_info png_read_info
5809 #define fn_png_get_IHDR png_get_IHDR
5810 #define fn_png_get_valid png_get_valid
5811 #define fn_png_set_strip_16 png_set_strip_16
5812 #define fn_png_set_expand png_set_expand
5813 #define fn_png_set_gray_to_rgb png_set_gray_to_rgb
5814 #define fn_png_set_background png_set_background
5815 #define fn_png_get_bKGD png_get_bKGD
5816 #define fn_png_read_update_info png_read_update_info
5817 #define fn_png_get_channels png_get_channels
5818 #define fn_png_get_rowbytes png_get_rowbytes
5819 #define fn_png_read_image png_read_image
5820 #define fn_png_read_end png_read_end
5821 #define fn_png_error png_error
5823 #endif /* HAVE_NTGUI */
5825 /* Error and warning handlers installed when the PNG library
5829 my_png_error (png_ptr
, msg
)
5830 png_struct
*png_ptr
;
5833 xassert (png_ptr
!= NULL
);
5834 image_error ("PNG error: %s", build_string (msg
), Qnil
);
5835 longjmp (png_ptr
->jmpbuf
, 1);
5840 my_png_warning (png_ptr
, msg
)
5841 png_struct
*png_ptr
;
5844 xassert (png_ptr
!= NULL
);
5845 image_error ("PNG warning: %s", build_string (msg
), Qnil
);
5848 /* Memory source for PNG decoding. */
5850 struct png_memory_storage
5852 unsigned char *bytes
; /* The data */
5853 size_t len
; /* How big is it? */
5854 int index
; /* Where are we? */
5858 /* Function set as reader function when reading PNG image from memory.
5859 PNG_PTR is a pointer to the PNG control structure. Copy LENGTH
5860 bytes from the input to DATA. */
5863 png_read_from_memory (png_ptr
, data
, length
)
5864 png_structp png_ptr
;
5868 struct png_memory_storage
*tbr
5869 = (struct png_memory_storage
*) fn_png_get_io_ptr (png_ptr
);
5871 if (length
> tbr
->len
- tbr
->index
)
5872 fn_png_error (png_ptr
, "Read error");
5874 bcopy (tbr
->bytes
+ tbr
->index
, data
, length
);
5875 tbr
->index
= tbr
->index
+ length
;
5879 /* Function set as reader function when reading PNG image from a file.
5880 PNG_PTR is a pointer to the PNG control structure. Copy LENGTH
5881 bytes from the input to DATA. */
5884 png_read_from_file (png_ptr
, data
, length
)
5885 png_structp png_ptr
;
5889 FILE *fp
= (FILE *) fn_png_get_io_ptr (png_ptr
);
5891 if (fread (data
, 1, length
, fp
) < length
)
5892 fn_png_error (png_ptr
, "Read error");
5896 /* Load PNG image IMG for use on frame F. Value is non-zero if
5904 Lisp_Object file
, specified_file
;
5905 Lisp_Object specified_data
;
5907 XImagePtr ximg
, mask_img
= NULL
;
5908 struct gcpro gcpro1
;
5909 png_struct
*png_ptr
= NULL
;
5910 png_info
*info_ptr
= NULL
, *end_info
= NULL
;
5911 FILE *volatile fp
= NULL
;
5913 png_byte
* volatile pixels
= NULL
;
5914 png_byte
** volatile rows
= NULL
;
5915 png_uint_32 width
, height
;
5916 int bit_depth
, color_type
, interlace_type
;
5918 png_uint_32 row_bytes
;
5920 double screen_gamma
;
5921 struct png_memory_storage tbr
; /* Data to be read */
5923 /* Find out what file to load. */
5924 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
5925 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
5929 if (NILP (specified_data
))
5931 file
= x_find_image_file (specified_file
);
5932 if (!STRINGP (file
))
5934 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
5939 /* Open the image file. */
5940 fp
= fopen (SDATA (file
), "rb");
5943 image_error ("Cannot open image file `%s'", file
, Qnil
);
5949 /* Check PNG signature. */
5950 if (fread (sig
, 1, sizeof sig
, fp
) != sizeof sig
5951 || !fn_png_check_sig (sig
, sizeof sig
))
5953 image_error ("Not a PNG file: `%s'", file
, Qnil
);
5961 /* Read from memory. */
5962 tbr
.bytes
= SDATA (specified_data
);
5963 tbr
.len
= SBYTES (specified_data
);
5966 /* Check PNG signature. */
5967 if (tbr
.len
< sizeof sig
5968 || !fn_png_check_sig (tbr
.bytes
, sizeof sig
))
5970 image_error ("Not a PNG image: `%s'", img
->spec
, Qnil
);
5975 /* Need to skip past the signature. */
5976 tbr
.bytes
+= sizeof (sig
);
5979 /* Initialize read and info structs for PNG lib. Casting return
5980 value avoids a GCC warning on W32. */
5981 png_ptr
= (png_structp
)fn_png_create_read_struct (PNG_LIBPNG_VER_STRING
,
5986 if (fp
) fclose (fp
);
5991 /* Casting return value avoids a GCC warning on W32. */
5992 info_ptr
= (png_infop
)fn_png_create_info_struct (png_ptr
);
5995 fn_png_destroy_read_struct (&png_ptr
, NULL
, NULL
);
5996 if (fp
) fclose (fp
);
6001 /* Casting return value avoids a GCC warning on W32. */
6002 end_info
= (png_infop
)fn_png_create_info_struct (png_ptr
);
6005 fn_png_destroy_read_struct (&png_ptr
, &info_ptr
, NULL
);
6006 if (fp
) fclose (fp
);
6011 /* Set error jump-back. We come back here when the PNG library
6012 detects an error. */
6013 if (setjmp (png_ptr
->jmpbuf
))
6017 fn_png_destroy_read_struct (&png_ptr
, &info_ptr
, &end_info
);
6020 if (fp
) fclose (fp
);
6025 /* Read image info. */
6026 if (!NILP (specified_data
))
6027 fn_png_set_read_fn (png_ptr
, (void *) &tbr
, png_read_from_memory
);
6029 fn_png_set_read_fn (png_ptr
, (void *) fp
, png_read_from_file
);
6031 fn_png_set_sig_bytes (png_ptr
, sizeof sig
);
6032 fn_png_read_info (png_ptr
, info_ptr
);
6033 fn_png_get_IHDR (png_ptr
, info_ptr
, &width
, &height
, &bit_depth
, &color_type
,
6034 &interlace_type
, NULL
, NULL
);
6036 if (!check_image_size (f
, width
, height
))
6039 /* If image contains simply transparency data, we prefer to
6040 construct a clipping mask. */
6041 if (fn_png_get_valid (png_ptr
, info_ptr
, PNG_INFO_tRNS
))
6046 /* This function is easier to write if we only have to handle
6047 one data format: RGB or RGBA with 8 bits per channel. Let's
6048 transform other formats into that format. */
6050 /* Strip more than 8 bits per channel. */
6051 if (bit_depth
== 16)
6052 fn_png_set_strip_16 (png_ptr
);
6054 /* Expand data to 24 bit RGB, or 8 bit grayscale, with alpha channel
6056 fn_png_set_expand (png_ptr
);
6058 /* Convert grayscale images to RGB. */
6059 if (color_type
== PNG_COLOR_TYPE_GRAY
6060 || color_type
== PNG_COLOR_TYPE_GRAY_ALPHA
)
6061 fn_png_set_gray_to_rgb (png_ptr
);
6063 screen_gamma
= (f
->gamma
? 1 / f
->gamma
/ 0.45455 : 2.2);
6065 #if 0 /* Avoid double gamma correction for PNG images. */
6066 { /* Tell the PNG lib to handle gamma correction for us. */
6069 #if defined(PNG_READ_sRGB_SUPPORTED) || defined(PNG_WRITE_sRGB_SUPPORTED)
6070 if (png_get_sRGB (png_ptr
, info_ptr
, &intent
))
6071 /* The libpng documentation says this is right in this case. */
6072 png_set_gamma (png_ptr
, screen_gamma
, 0.45455);
6075 if (png_get_gAMA (png_ptr
, info_ptr
, &image_gamma
))
6076 /* Image contains gamma information. */
6077 png_set_gamma (png_ptr
, screen_gamma
, image_gamma
);
6079 /* Use the standard default for the image gamma. */
6080 png_set_gamma (png_ptr
, screen_gamma
, 0.45455);
6084 /* Handle alpha channel by combining the image with a background
6085 color. Do this only if a real alpha channel is supplied. For
6086 simple transparency, we prefer a clipping mask. */
6089 png_color_16
*image_bg
;
6090 Lisp_Object specified_bg
6091 = image_spec_value (img
->spec
, QCbackground
, NULL
);
6093 if (STRINGP (specified_bg
))
6094 /* The user specified `:background', use that. */
6096 /* W32 version incorrectly used COLORREF here!! ++kfs */
6098 if (x_defined_color (f
, SDATA (specified_bg
), &color
, 0))
6100 png_color_16 user_bg
;
6102 bzero (&user_bg
, sizeof user_bg
);
6103 user_bg
.red
= color
.red
>> 8;
6104 user_bg
.green
= color
.green
>> 8;
6105 user_bg
.blue
= color
.blue
>> 8;
6107 fn_png_set_background (png_ptr
, &user_bg
,
6108 PNG_BACKGROUND_GAMMA_SCREEN
, 0, 1.0);
6111 else if (fn_png_get_bKGD (png_ptr
, info_ptr
, &image_bg
))
6112 /* Image contains a background color with which to
6113 combine the image. */
6114 fn_png_set_background (png_ptr
, image_bg
,
6115 PNG_BACKGROUND_GAMMA_FILE
, 1, 1.0);
6118 /* Image does not contain a background color with which
6119 to combine the image data via an alpha channel. Use
6120 the frame's background instead. */
6121 #ifdef HAVE_X_WINDOWS
6123 png_color_16 frame_background
;
6125 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
6126 x_query_color (f
, &color
);
6128 bzero (&frame_background
, sizeof frame_background
);
6129 frame_background
.red
= color
.red
>> 8;
6130 frame_background
.green
= color
.green
>> 8;
6131 frame_background
.blue
= color
.blue
>> 8;
6132 #endif /* HAVE_X_WINDOWS */
6136 png_color_16 frame_background
;
6137 color
= FRAME_BACKGROUND_PIXEL (f
);
6138 #if 0 /* W32 TODO : Colormap support. */
6139 x_query_color (f
, &color
);
6141 bzero (&frame_background
, sizeof frame_background
);
6142 frame_background
.red
= GetRValue (color
);
6143 frame_background
.green
= GetGValue (color
);
6144 frame_background
.blue
= GetBValue (color
);
6145 #endif /* HAVE_NTGUI */
6148 unsigned long color
;
6149 png_color_16 frame_background
;
6150 color
= FRAME_BACKGROUND_PIXEL (f
);
6151 #if 0 /* MAC/W32 TODO : Colormap support. */
6152 x_query_color (f
, &color
);
6154 bzero (&frame_background
, sizeof frame_background
);
6155 frame_background
.red
= RED_FROM_ULONG (color
);
6156 frame_background
.green
= GREEN_FROM_ULONG (color
);
6157 frame_background
.blue
= BLUE_FROM_ULONG (color
);
6160 fn_png_set_background (png_ptr
, &frame_background
,
6161 PNG_BACKGROUND_GAMMA_SCREEN
, 0, 1.0);
6165 /* Update info structure. */
6166 fn_png_read_update_info (png_ptr
, info_ptr
);
6168 /* Get number of channels. Valid values are 1 for grayscale images
6169 and images with a palette, 2 for grayscale images with transparency
6170 information (alpha channel), 3 for RGB images, and 4 for RGB
6171 images with alpha channel, i.e. RGBA. If conversions above were
6172 sufficient we should only have 3 or 4 channels here. */
6173 channels
= fn_png_get_channels (png_ptr
, info_ptr
);
6174 xassert (channels
== 3 || channels
== 4);
6176 /* Number of bytes needed for one row of the image. */
6177 row_bytes
= fn_png_get_rowbytes (png_ptr
, info_ptr
);
6179 /* Allocate memory for the image. */
6180 pixels
= (png_byte
*) xmalloc (row_bytes
* height
* sizeof *pixels
);
6181 rows
= (png_byte
**) xmalloc (height
* sizeof *rows
);
6182 for (i
= 0; i
< height
; ++i
)
6183 rows
[i
] = pixels
+ i
* row_bytes
;
6185 /* Read the entire image. */
6186 fn_png_read_image (png_ptr
, rows
);
6187 fn_png_read_end (png_ptr
, info_ptr
);
6194 /* Create the X image and pixmap. */
6195 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
,
6199 /* Create an image and pixmap serving as mask if the PNG image
6200 contains an alpha channel. */
6203 && !x_create_x_image_and_pixmap (f
, width
, height
, 1,
6204 &mask_img
, &img
->mask
))
6206 x_destroy_x_image (ximg
);
6207 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->pixmap
);
6208 img
->pixmap
= NO_PIXMAP
;
6212 /* Fill the X image and mask from PNG data. */
6213 init_color_table ();
6215 for (y
= 0; y
< height
; ++y
)
6217 png_byte
*p
= rows
[y
];
6219 for (x
= 0; x
< width
; ++x
)
6226 XPutPixel (ximg
, x
, y
, lookup_rgb_color (f
, r
, g
, b
));
6227 /* An alpha channel, aka mask channel, associates variable
6228 transparency with an image. Where other image formats
6229 support binary transparency---fully transparent or fully
6230 opaque---PNG allows up to 254 levels of partial transparency.
6231 The PNG library implements partial transparency by combining
6232 the image with a specified background color.
6234 I'm not sure how to handle this here nicely: because the
6235 background on which the image is displayed may change, for
6236 real alpha channel support, it would be necessary to create
6237 a new image for each possible background.
6239 What I'm doing now is that a mask is created if we have
6240 boolean transparency information. Otherwise I'm using
6241 the frame's background color to combine the image with. */
6246 XPutPixel (mask_img
, x
, y
, *p
> 0 ? PIX_MASK_DRAW
: PIX_MASK_RETAIN
);
6252 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
6253 /* Set IMG's background color from the PNG image, unless the user
6257 if (fn_png_get_bKGD (png_ptr
, info_ptr
, &bg
))
6259 img
->background
= lookup_rgb_color (f
, bg
->red
, bg
->green
, bg
->blue
);
6260 img
->background_valid
= 1;
6264 #ifdef COLOR_TABLE_SUPPORT
6265 /* Remember colors allocated for this image. */
6266 img
->colors
= colors_in_color_table (&img
->ncolors
);
6267 free_color_table ();
6268 #endif /* COLOR_TABLE_SUPPORT */
6271 fn_png_destroy_read_struct (&png_ptr
, &info_ptr
, &end_info
);
6276 img
->height
= height
;
6278 /* Maybe fill in the background field while we have ximg handy.
6279 Casting avoids a GCC warning. */
6280 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
6282 /* Put the image into the pixmap, then free the X image and its buffer. */
6283 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
6284 x_destroy_x_image (ximg
);
6286 /* Same for the mask. */
6289 /* Fill in the background_transparent field while we have the
6290 mask handy. Casting avoids a GCC warning. */
6291 image_background_transparent (img
, f
, (XImagePtr_or_DC
)mask_img
);
6293 x_put_x_image (f
, mask_img
, img
->mask
, img
->width
, img
->height
);
6294 x_destroy_x_image (mask_img
);
6301 #else /* HAVE_PNG */
6310 if (MyCGImageCreateWithPNGDataProvider
)
6311 return image_load_quartz2d (f
, img
, 1);
6314 return image_load_quicktime (f
, img
, kQTFileTypePNG
);
6318 #endif /* !HAVE_PNG */
6322 /***********************************************************************
6324 ***********************************************************************/
6326 #if defined (HAVE_JPEG) || defined (MAC_OS)
6328 static int jpeg_image_p
P_ ((Lisp_Object object
));
6329 static int jpeg_load
P_ ((struct frame
*f
, struct image
*img
));
6331 /* The symbol `jpeg' identifying images of this type. */
6335 /* Indices of image specification fields in gs_format, below. */
6337 enum jpeg_keyword_index
6346 JPEG_HEURISTIC_MASK
,
6352 /* Vector of image_keyword structures describing the format
6353 of valid user-defined image specifications. */
6355 static struct image_keyword jpeg_format
[JPEG_LAST
] =
6357 {":type", IMAGE_SYMBOL_VALUE
, 1},
6358 {":data", IMAGE_STRING_VALUE
, 0},
6359 {":file", IMAGE_STRING_VALUE
, 0},
6360 {":ascent", IMAGE_ASCENT_VALUE
, 0},
6361 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
6362 {":relief", IMAGE_INTEGER_VALUE
, 0},
6363 {":conversions", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6364 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6365 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6366 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
6369 /* Structure describing the image type `jpeg'. */
6371 static struct image_type jpeg_type
=
6380 /* Return non-zero if OBJECT is a valid JPEG image specification. */
6383 jpeg_image_p (object
)
6386 struct image_keyword fmt
[JPEG_LAST
];
6388 bcopy (jpeg_format
, fmt
, sizeof fmt
);
6390 if (!parse_image_spec (object
, fmt
, JPEG_LAST
, Qjpeg
))
6393 /* Must specify either the :data or :file keyword. */
6394 return fmt
[JPEG_FILE
].count
+ fmt
[JPEG_DATA
].count
== 1;
6397 #endif /* HAVE_JPEG || MAC_OS */
6401 /* Work around a warning about HAVE_STDLIB_H being redefined in
6403 #ifdef HAVE_STDLIB_H
6404 #define HAVE_STDLIB_H_1
6405 #undef HAVE_STDLIB_H
6406 #endif /* HAVE_STLIB_H */
6408 #if defined (HAVE_NTGUI) && !defined (__WIN32__)
6409 /* In older releases of the jpeg library, jpeglib.h will define boolean
6410 differently depending on __WIN32__, so make sure it is defined. */
6414 #include <jpeglib.h>
6418 #ifdef HAVE_STLIB_H_1
6419 #define HAVE_STDLIB_H 1
6424 /* JPEG library details. */
6425 DEF_IMGLIB_FN (jpeg_CreateDecompress
);
6426 DEF_IMGLIB_FN (jpeg_start_decompress
);
6427 DEF_IMGLIB_FN (jpeg_finish_decompress
);
6428 DEF_IMGLIB_FN (jpeg_destroy_decompress
);
6429 DEF_IMGLIB_FN (jpeg_read_header
);
6430 DEF_IMGLIB_FN (jpeg_read_scanlines
);
6431 DEF_IMGLIB_FN (jpeg_std_error
);
6432 DEF_IMGLIB_FN (jpeg_resync_to_restart
);
6435 init_jpeg_functions (Lisp_Object libraries
)
6439 if (!(library
= w32_delayed_load (libraries
, Qjpeg
)))
6442 LOAD_IMGLIB_FN (library
, jpeg_finish_decompress
);
6443 LOAD_IMGLIB_FN (library
, jpeg_read_scanlines
);
6444 LOAD_IMGLIB_FN (library
, jpeg_start_decompress
);
6445 LOAD_IMGLIB_FN (library
, jpeg_read_header
);
6446 LOAD_IMGLIB_FN (library
, jpeg_CreateDecompress
);
6447 LOAD_IMGLIB_FN (library
, jpeg_destroy_decompress
);
6448 LOAD_IMGLIB_FN (library
, jpeg_std_error
);
6449 LOAD_IMGLIB_FN (library
, jpeg_resync_to_restart
);
6453 /* Wrapper since we can't directly assign the function pointer
6454 to another function pointer that was declared more completely easily. */
6456 jpeg_resync_to_restart_wrapper(cinfo
, desired
)
6457 j_decompress_ptr cinfo
;
6460 return fn_jpeg_resync_to_restart (cinfo
, desired
);
6465 #define fn_jpeg_CreateDecompress(a,b,c) jpeg_create_decompress(a)
6466 #define fn_jpeg_start_decompress jpeg_start_decompress
6467 #define fn_jpeg_finish_decompress jpeg_finish_decompress
6468 #define fn_jpeg_destroy_decompress jpeg_destroy_decompress
6469 #define fn_jpeg_read_header jpeg_read_header
6470 #define fn_jpeg_read_scanlines jpeg_read_scanlines
6471 #define fn_jpeg_std_error jpeg_std_error
6472 #define jpeg_resync_to_restart_wrapper jpeg_resync_to_restart
6474 #endif /* HAVE_NTGUI */
6476 struct my_jpeg_error_mgr
6478 struct jpeg_error_mgr pub
;
6479 jmp_buf setjmp_buffer
;
6484 my_error_exit (cinfo
)
6487 struct my_jpeg_error_mgr
*mgr
= (struct my_jpeg_error_mgr
*) cinfo
->err
;
6488 longjmp (mgr
->setjmp_buffer
, 1);
6492 /* Init source method for JPEG data source manager. Called by
6493 jpeg_read_header() before any data is actually read. See
6494 libjpeg.doc from the JPEG lib distribution. */
6497 our_common_init_source (cinfo
)
6498 j_decompress_ptr cinfo
;
6503 /* Method to terminate data source. Called by
6504 jpeg_finish_decompress() after all data has been processed. */
6507 our_common_term_source (cinfo
)
6508 j_decompress_ptr cinfo
;
6513 /* Fill input buffer method for JPEG data source manager. Called
6514 whenever more data is needed. We read the whole image in one step,
6515 so this only adds a fake end of input marker at the end. */
6518 our_memory_fill_input_buffer (cinfo
)
6519 j_decompress_ptr cinfo
;
6521 /* Insert a fake EOI marker. */
6522 struct jpeg_source_mgr
*src
= cinfo
->src
;
6523 static JOCTET buffer
[2];
6525 buffer
[0] = (JOCTET
) 0xFF;
6526 buffer
[1] = (JOCTET
) JPEG_EOI
;
6528 src
->next_input_byte
= buffer
;
6529 src
->bytes_in_buffer
= 2;
6534 /* Method to skip over NUM_BYTES bytes in the image data. CINFO->src
6535 is the JPEG data source manager. */
6538 our_memory_skip_input_data (cinfo
, num_bytes
)
6539 j_decompress_ptr cinfo
;
6542 struct jpeg_source_mgr
*src
= (struct jpeg_source_mgr
*) cinfo
->src
;
6546 if (num_bytes
> src
->bytes_in_buffer
)
6547 ERREXIT (cinfo
, JERR_INPUT_EOF
);
6549 src
->bytes_in_buffer
-= num_bytes
;
6550 src
->next_input_byte
+= num_bytes
;
6555 /* Set up the JPEG lib for reading an image from DATA which contains
6556 LEN bytes. CINFO is the decompression info structure created for
6557 reading the image. */
6560 jpeg_memory_src (cinfo
, data
, len
)
6561 j_decompress_ptr cinfo
;
6565 struct jpeg_source_mgr
*src
;
6567 if (cinfo
->src
== NULL
)
6569 /* First time for this JPEG object? */
6570 cinfo
->src
= (struct jpeg_source_mgr
*)
6571 (*cinfo
->mem
->alloc_small
) ((j_common_ptr
) cinfo
, JPOOL_PERMANENT
,
6572 sizeof (struct jpeg_source_mgr
));
6573 src
= (struct jpeg_source_mgr
*) cinfo
->src
;
6574 src
->next_input_byte
= data
;
6577 src
= (struct jpeg_source_mgr
*) cinfo
->src
;
6578 src
->init_source
= our_common_init_source
;
6579 src
->fill_input_buffer
= our_memory_fill_input_buffer
;
6580 src
->skip_input_data
= our_memory_skip_input_data
;
6581 src
->resync_to_restart
= jpeg_resync_to_restart_wrapper
; /* Use default method. */
6582 src
->term_source
= our_common_term_source
;
6583 src
->bytes_in_buffer
= len
;
6584 src
->next_input_byte
= data
;
6588 struct jpeg_stdio_mgr
6590 struct jpeg_source_mgr mgr
;
6597 /* Size of buffer to read JPEG from file.
6598 Not too big, as we want to use alloc_small. */
6599 #define JPEG_STDIO_BUFFER_SIZE 8192
6602 /* Fill input buffer method for JPEG data source manager. Called
6603 whenever more data is needed. The data is read from a FILE *. */
6606 our_stdio_fill_input_buffer (cinfo
)
6607 j_decompress_ptr cinfo
;
6609 struct jpeg_stdio_mgr
*src
;
6611 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6616 bytes
= fread (src
->buffer
, 1, JPEG_STDIO_BUFFER_SIZE
, src
->file
);
6618 src
->mgr
.bytes_in_buffer
= bytes
;
6621 WARNMS (cinfo
, JWRN_JPEG_EOF
);
6623 src
->buffer
[0] = (JOCTET
) 0xFF;
6624 src
->buffer
[1] = (JOCTET
) JPEG_EOI
;
6625 src
->mgr
.bytes_in_buffer
= 2;
6627 src
->mgr
.next_input_byte
= src
->buffer
;
6634 /* Method to skip over NUM_BYTES bytes in the image data. CINFO->src
6635 is the JPEG data source manager. */
6638 our_stdio_skip_input_data (cinfo
, num_bytes
)
6639 j_decompress_ptr cinfo
;
6642 struct jpeg_stdio_mgr
*src
;
6643 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6645 while (num_bytes
> 0 && !src
->finished
)
6647 if (num_bytes
<= src
->mgr
.bytes_in_buffer
)
6649 src
->mgr
.bytes_in_buffer
-= num_bytes
;
6650 src
->mgr
.next_input_byte
+= num_bytes
;
6655 num_bytes
-= src
->mgr
.bytes_in_buffer
;
6656 src
->mgr
.bytes_in_buffer
= 0;
6657 src
->mgr
.next_input_byte
= NULL
;
6659 our_stdio_fill_input_buffer (cinfo
);
6665 /* Set up the JPEG lib for reading an image from a FILE *.
6666 CINFO is the decompression info structure created for
6667 reading the image. */
6670 jpeg_file_src (cinfo
, fp
)
6671 j_decompress_ptr cinfo
;
6674 struct jpeg_stdio_mgr
*src
;
6676 if (cinfo
->src
!= NULL
)
6677 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6680 /* First time for this JPEG object? */
6681 cinfo
->src
= (struct jpeg_source_mgr
*)
6682 (*cinfo
->mem
->alloc_small
) ((j_common_ptr
) cinfo
, JPOOL_PERMANENT
,
6683 sizeof (struct jpeg_stdio_mgr
));
6684 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6685 src
->buffer
= (JOCTET
*)
6686 (*cinfo
->mem
->alloc_small
) ((j_common_ptr
) cinfo
, JPOOL_PERMANENT
,
6687 JPEG_STDIO_BUFFER_SIZE
);
6692 src
->mgr
.init_source
= our_common_init_source
;
6693 src
->mgr
.fill_input_buffer
= our_stdio_fill_input_buffer
;
6694 src
->mgr
.skip_input_data
= our_stdio_skip_input_data
;
6695 src
->mgr
.resync_to_restart
= jpeg_resync_to_restart_wrapper
; /* Use default method. */
6696 src
->mgr
.term_source
= our_common_term_source
;
6697 src
->mgr
.bytes_in_buffer
= 0;
6698 src
->mgr
.next_input_byte
= NULL
;
6702 /* Load image IMG for use on frame F. Patterned after example.c
6703 from the JPEG lib. */
6710 struct jpeg_decompress_struct cinfo
;
6711 struct my_jpeg_error_mgr mgr
;
6712 Lisp_Object file
, specified_file
;
6713 Lisp_Object specified_data
;
6714 FILE * volatile fp
= NULL
;
6716 int row_stride
, x
, y
;
6717 XImagePtr ximg
= NULL
;
6719 unsigned long *colors
;
6721 struct gcpro gcpro1
;
6723 /* Open the JPEG file. */
6724 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
6725 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
6729 if (NILP (specified_data
))
6731 file
= x_find_image_file (specified_file
);
6732 if (!STRINGP (file
))
6734 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
6739 fp
= fopen (SDATA (file
), "rb");
6742 image_error ("Cannot open `%s'", file
, Qnil
);
6748 /* Customize libjpeg's error handling to call my_error_exit when an
6749 error is detected. This function will perform a longjmp.
6750 Casting return value avoids a GCC warning on W32. */
6751 cinfo
.err
= (struct jpeg_error_mgr
*)fn_jpeg_std_error (&mgr
.pub
);
6752 mgr
.pub
.error_exit
= my_error_exit
;
6754 if ((rc
= setjmp (mgr
.setjmp_buffer
)) != 0)
6758 /* Called from my_error_exit. Display a JPEG error. */
6759 char buffer
[JMSG_LENGTH_MAX
];
6760 cinfo
.err
->format_message ((j_common_ptr
) &cinfo
, buffer
);
6761 image_error ("Error reading JPEG image `%s': %s", img
->spec
,
6762 build_string (buffer
));
6765 /* Close the input file and destroy the JPEG object. */
6767 fclose ((FILE *) fp
);
6768 fn_jpeg_destroy_decompress (&cinfo
);
6770 /* If we already have an XImage, free that. */
6771 x_destroy_x_image (ximg
);
6773 /* Free pixmap and colors. */
6774 x_clear_image (f
, img
);
6780 /* Create the JPEG decompression object. Let it read from fp.
6781 Read the JPEG image header. */
6782 fn_jpeg_CreateDecompress (&cinfo
, JPEG_LIB_VERSION
, sizeof (cinfo
));
6784 if (NILP (specified_data
))
6785 jpeg_file_src (&cinfo
, (FILE *) fp
);
6787 jpeg_memory_src (&cinfo
, SDATA (specified_data
),
6788 SBYTES (specified_data
));
6790 fn_jpeg_read_header (&cinfo
, 1);
6792 /* Customize decompression so that color quantization will be used.
6793 Start decompression. */
6794 cinfo
.quantize_colors
= 1;
6795 fn_jpeg_start_decompress (&cinfo
);
6796 width
= img
->width
= cinfo
.output_width
;
6797 height
= img
->height
= cinfo
.output_height
;
6799 if (!check_image_size (f
, width
, height
))
6801 image_error ("Invalid image size", Qnil
, Qnil
);
6802 longjmp (mgr
.setjmp_buffer
, 2);
6805 /* Create X image and pixmap. */
6806 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
6807 longjmp (mgr
.setjmp_buffer
, 2);
6809 /* Allocate colors. When color quantization is used,
6810 cinfo.actual_number_of_colors has been set with the number of
6811 colors generated, and cinfo.colormap is a two-dimensional array
6812 of color indices in the range 0..cinfo.actual_number_of_colors.
6813 No more than 255 colors will be generated. */
6817 if (cinfo
.out_color_components
> 2)
6818 ir
= 0, ig
= 1, ib
= 2;
6819 else if (cinfo
.out_color_components
> 1)
6820 ir
= 0, ig
= 1, ib
= 0;
6822 ir
= 0, ig
= 0, ib
= 0;
6824 /* Use the color table mechanism because it handles colors that
6825 cannot be allocated nicely. Such colors will be replaced with
6826 a default color, and we don't have to care about which colors
6827 can be freed safely, and which can't. */
6828 init_color_table ();
6829 colors
= (unsigned long *) alloca (cinfo
.actual_number_of_colors
6832 for (i
= 0; i
< cinfo
.actual_number_of_colors
; ++i
)
6834 /* Multiply RGB values with 255 because X expects RGB values
6835 in the range 0..0xffff. */
6836 int r
= cinfo
.colormap
[ir
][i
] << 8;
6837 int g
= cinfo
.colormap
[ig
][i
] << 8;
6838 int b
= cinfo
.colormap
[ib
][i
] << 8;
6839 colors
[i
] = lookup_rgb_color (f
, r
, g
, b
);
6842 #ifdef COLOR_TABLE_SUPPORT
6843 /* Remember those colors actually allocated. */
6844 img
->colors
= colors_in_color_table (&img
->ncolors
);
6845 free_color_table ();
6846 #endif /* COLOR_TABLE_SUPPORT */
6850 row_stride
= width
* cinfo
.output_components
;
6851 buffer
= cinfo
.mem
->alloc_sarray ((j_common_ptr
) &cinfo
, JPOOL_IMAGE
,
6853 for (y
= 0; y
< height
; ++y
)
6855 fn_jpeg_read_scanlines (&cinfo
, buffer
, 1);
6856 for (x
= 0; x
< cinfo
.output_width
; ++x
)
6857 XPutPixel (ximg
, x
, y
, colors
[buffer
[0][x
]]);
6861 fn_jpeg_finish_decompress (&cinfo
);
6862 fn_jpeg_destroy_decompress (&cinfo
);
6864 fclose ((FILE *) fp
);
6866 /* Maybe fill in the background field while we have ximg handy. */
6867 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
6868 /* Casting avoids a GCC warning. */
6869 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
6871 /* Put the image into the pixmap. */
6872 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
6873 x_destroy_x_image (ximg
);
6878 #else /* HAVE_JPEG */
6887 return image_load_quartz2d (f
, img
, 0);
6889 return image_load_quicktime (f
, img
, kQTFileTypeJPEG
);
6894 #endif /* !HAVE_JPEG */
6898 /***********************************************************************
6900 ***********************************************************************/
6902 #if defined (HAVE_TIFF) || defined (MAC_OS)
6904 static int tiff_image_p
P_ ((Lisp_Object object
));
6905 static int tiff_load
P_ ((struct frame
*f
, struct image
*img
));
6907 /* The symbol `tiff' identifying images of this type. */
6911 /* Indices of image specification fields in tiff_format, below. */
6913 enum tiff_keyword_index
6922 TIFF_HEURISTIC_MASK
,
6928 /* Vector of image_keyword structures describing the format
6929 of valid user-defined image specifications. */
6931 static struct image_keyword tiff_format
[TIFF_LAST
] =
6933 {":type", IMAGE_SYMBOL_VALUE
, 1},
6934 {":data", IMAGE_STRING_VALUE
, 0},
6935 {":file", IMAGE_STRING_VALUE
, 0},
6936 {":ascent", IMAGE_ASCENT_VALUE
, 0},
6937 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
6938 {":relief", IMAGE_INTEGER_VALUE
, 0},
6939 {":conversions", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6940 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6941 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6942 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
6945 /* Structure describing the image type `tiff'. */
6947 static struct image_type tiff_type
=
6956 /* Return non-zero if OBJECT is a valid TIFF image specification. */
6959 tiff_image_p (object
)
6962 struct image_keyword fmt
[TIFF_LAST
];
6963 bcopy (tiff_format
, fmt
, sizeof fmt
);
6965 if (!parse_image_spec (object
, fmt
, TIFF_LAST
, Qtiff
))
6968 /* Must specify either the :data or :file keyword. */
6969 return fmt
[TIFF_FILE
].count
+ fmt
[TIFF_DATA
].count
== 1;
6972 #endif /* HAVE_TIFF || MAC_OS */
6980 /* TIFF library details. */
6981 DEF_IMGLIB_FN (TIFFSetErrorHandler
);
6982 DEF_IMGLIB_FN (TIFFSetWarningHandler
);
6983 DEF_IMGLIB_FN (TIFFOpen
);
6984 DEF_IMGLIB_FN (TIFFClientOpen
);
6985 DEF_IMGLIB_FN (TIFFGetField
);
6986 DEF_IMGLIB_FN (TIFFReadRGBAImage
);
6987 DEF_IMGLIB_FN (TIFFClose
);
6990 init_tiff_functions (Lisp_Object libraries
)
6994 if (!(library
= w32_delayed_load (libraries
, Qtiff
)))
6997 LOAD_IMGLIB_FN (library
, TIFFSetErrorHandler
);
6998 LOAD_IMGLIB_FN (library
, TIFFSetWarningHandler
);
6999 LOAD_IMGLIB_FN (library
, TIFFOpen
);
7000 LOAD_IMGLIB_FN (library
, TIFFClientOpen
);
7001 LOAD_IMGLIB_FN (library
, TIFFGetField
);
7002 LOAD_IMGLIB_FN (library
, TIFFReadRGBAImage
);
7003 LOAD_IMGLIB_FN (library
, TIFFClose
);
7009 #define fn_TIFFSetErrorHandler TIFFSetErrorHandler
7010 #define fn_TIFFSetWarningHandler TIFFSetWarningHandler
7011 #define fn_TIFFOpen TIFFOpen
7012 #define fn_TIFFClientOpen TIFFClientOpen
7013 #define fn_TIFFGetField TIFFGetField
7014 #define fn_TIFFReadRGBAImage TIFFReadRGBAImage
7015 #define fn_TIFFClose TIFFClose
7017 #endif /* HAVE_NTGUI */
7020 /* Reading from a memory buffer for TIFF images Based on the PNG
7021 memory source, but we have to provide a lot of extra functions.
7024 We really only need to implement read and seek, but I am not
7025 convinced that the TIFF library is smart enough not to destroy
7026 itself if we only hand it the function pointers we need to
7031 unsigned char *bytes
;
7038 tiff_read_from_memory (data
, buf
, size
)
7043 tiff_memory_source
*src
= (tiff_memory_source
*) data
;
7045 if (size
> src
->len
- src
->index
)
7047 bcopy (src
->bytes
+ src
->index
, buf
, size
);
7053 tiff_write_from_memory (data
, buf
, size
)
7062 tiff_seek_in_memory (data
, off
, whence
)
7067 tiff_memory_source
*src
= (tiff_memory_source
*) data
;
7072 case SEEK_SET
: /* Go from beginning of source. */
7076 case SEEK_END
: /* Go from end of source. */
7077 idx
= src
->len
+ off
;
7080 case SEEK_CUR
: /* Go from current position. */
7081 idx
= src
->index
+ off
;
7084 default: /* Invalid `whence'. */
7088 if (idx
> src
->len
|| idx
< 0)
7096 tiff_close_memory (data
)
7104 tiff_mmap_memory (data
, pbase
, psize
)
7109 /* It is already _IN_ memory. */
7114 tiff_unmap_memory (data
, base
, size
)
7119 /* We don't need to do this. */
7123 tiff_size_of_memory (data
)
7126 return ((tiff_memory_source
*) data
)->len
;
7131 tiff_error_handler (title
, format
, ap
)
7132 const char *title
, *format
;
7138 len
= sprintf (buf
, "TIFF error: %s ", title
);
7139 vsprintf (buf
+ len
, format
, ap
);
7140 add_to_log (buf
, Qnil
, Qnil
);
7145 tiff_warning_handler (title
, format
, ap
)
7146 const char *title
, *format
;
7152 len
= sprintf (buf
, "TIFF warning: %s ", title
);
7153 vsprintf (buf
+ len
, format
, ap
);
7154 add_to_log (buf
, Qnil
, Qnil
);
7158 /* Load TIFF image IMG for use on frame F. Value is non-zero if
7166 Lisp_Object file
, specified_file
;
7167 Lisp_Object specified_data
;
7169 int width
, height
, x
, y
;
7173 struct gcpro gcpro1
;
7174 tiff_memory_source memsrc
;
7176 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
7177 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
7181 fn_TIFFSetErrorHandler (tiff_error_handler
);
7182 fn_TIFFSetWarningHandler (tiff_warning_handler
);
7184 if (NILP (specified_data
))
7186 /* Read from a file */
7187 file
= x_find_image_file (specified_file
);
7188 if (!STRINGP (file
))
7190 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
7195 /* Try to open the image file. Casting return value avoids a
7196 GCC warning on W32. */
7197 tiff
= (TIFF
*)fn_TIFFOpen (SDATA (file
), "r");
7200 image_error ("Cannot open `%s'", file
, Qnil
);
7207 /* Memory source! */
7208 memsrc
.bytes
= SDATA (specified_data
);
7209 memsrc
.len
= SBYTES (specified_data
);
7212 /* Casting return value avoids a GCC warning on W32. */
7213 tiff
= (TIFF
*)fn_TIFFClientOpen ("memory_source", "r", &memsrc
,
7214 (TIFFReadWriteProc
) tiff_read_from_memory
,
7215 (TIFFReadWriteProc
) tiff_write_from_memory
,
7216 tiff_seek_in_memory
,
7218 tiff_size_of_memory
,
7224 image_error ("Cannot open memory source for `%s'", img
->spec
, Qnil
);
7230 /* Get width and height of the image, and allocate a raster buffer
7231 of width x height 32-bit values. */
7232 fn_TIFFGetField (tiff
, TIFFTAG_IMAGEWIDTH
, &width
);
7233 fn_TIFFGetField (tiff
, TIFFTAG_IMAGELENGTH
, &height
);
7235 if (!check_image_size (f
, width
, height
))
7237 image_error ("Invalid image size", Qnil
, Qnil
);
7242 buf
= (uint32
*) xmalloc (width
* height
* sizeof *buf
);
7244 rc
= fn_TIFFReadRGBAImage (tiff
, width
, height
, buf
, 0);
7245 fn_TIFFClose (tiff
);
7248 image_error ("Error reading TIFF image `%s'", img
->spec
, Qnil
);
7254 /* Create the X image and pixmap. */
7255 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
7262 /* Initialize the color table. */
7263 init_color_table ();
7265 /* Process the pixel raster. Origin is in the lower-left corner. */
7266 for (y
= 0; y
< height
; ++y
)
7268 uint32
*row
= buf
+ y
* width
;
7270 for (x
= 0; x
< width
; ++x
)
7272 uint32 abgr
= row
[x
];
7273 int r
= TIFFGetR (abgr
) << 8;
7274 int g
= TIFFGetG (abgr
) << 8;
7275 int b
= TIFFGetB (abgr
) << 8;
7276 XPutPixel (ximg
, x
, height
- 1 - y
, lookup_rgb_color (f
, r
, g
, b
));
7280 #ifdef COLOR_TABLE_SUPPORT
7281 /* Remember the colors allocated for the image. Free the color table. */
7282 img
->colors
= colors_in_color_table (&img
->ncolors
);
7283 free_color_table ();
7284 #endif /* COLOR_TABLE_SUPPORT */
7287 img
->height
= height
;
7289 /* Maybe fill in the background field while we have ximg handy. */
7290 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
7291 /* Casting avoids a GCC warning on W32. */
7292 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
7294 /* Put the image into the pixmap, then free the X image and its buffer. */
7295 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
7296 x_destroy_x_image (ximg
);
7303 #else /* HAVE_TIFF */
7311 return image_load_quicktime (f
, img
, kQTFileTypeTIFF
);
7315 #endif /* !HAVE_TIFF */
7319 /***********************************************************************
7321 ***********************************************************************/
7323 #if defined (HAVE_GIF) || defined (MAC_OS)
7325 static int gif_image_p
P_ ((Lisp_Object object
));
7326 static int gif_load
P_ ((struct frame
*f
, struct image
*img
));
7328 /* The symbol `gif' identifying images of this type. */
7332 /* Indices of image specification fields in gif_format, below. */
7334 enum gif_keyword_index
7350 /* Vector of image_keyword structures describing the format
7351 of valid user-defined image specifications. */
7353 static struct image_keyword gif_format
[GIF_LAST
] =
7355 {":type", IMAGE_SYMBOL_VALUE
, 1},
7356 {":data", IMAGE_STRING_VALUE
, 0},
7357 {":file", IMAGE_STRING_VALUE
, 0},
7358 {":ascent", IMAGE_ASCENT_VALUE
, 0},
7359 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
7360 {":relief", IMAGE_INTEGER_VALUE
, 0},
7361 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7362 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7363 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7364 {":image", IMAGE_NON_NEGATIVE_INTEGER_VALUE
, 0},
7365 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
7368 /* Structure describing the image type `gif'. */
7370 static struct image_type gif_type
=
7379 /* Return non-zero if OBJECT is a valid GIF image specification. */
7382 gif_image_p (object
)
7385 struct image_keyword fmt
[GIF_LAST
];
7386 bcopy (gif_format
, fmt
, sizeof fmt
);
7388 if (!parse_image_spec (object
, fmt
, GIF_LAST
, Qgif
))
7391 /* Must specify either the :data or :file keyword. */
7392 return fmt
[GIF_FILE
].count
+ fmt
[GIF_DATA
].count
== 1;
7395 #endif /* HAVE_GIF || MAC_OS */
7399 #if defined (HAVE_NTGUI) || defined (MAC_OS)
7400 /* winuser.h might define DrawText to DrawTextA or DrawTextW.
7401 Undefine before redefining to avoid a preprocessor warning. */
7405 /* avoid conflict with QuickdrawText.h */
7406 #define DrawText gif_DrawText
7407 #include <gif_lib.h>
7410 #else /* HAVE_NTGUI || MAC_OS */
7412 #include <gif_lib.h>
7414 #endif /* HAVE_NTGUI || MAC_OS */
7419 /* GIF library details. */
7420 DEF_IMGLIB_FN (DGifCloseFile
);
7421 DEF_IMGLIB_FN (DGifSlurp
);
7422 DEF_IMGLIB_FN (DGifOpen
);
7423 DEF_IMGLIB_FN (DGifOpenFileName
);
7426 init_gif_functions (Lisp_Object libraries
)
7430 if (!(library
= w32_delayed_load (libraries
, Qgif
)))
7433 LOAD_IMGLIB_FN (library
, DGifCloseFile
);
7434 LOAD_IMGLIB_FN (library
, DGifSlurp
);
7435 LOAD_IMGLIB_FN (library
, DGifOpen
);
7436 LOAD_IMGLIB_FN (library
, DGifOpenFileName
);
7442 #define fn_DGifCloseFile DGifCloseFile
7443 #define fn_DGifSlurp DGifSlurp
7444 #define fn_DGifOpen DGifOpen
7445 #define fn_DGifOpenFileName DGifOpenFileName
7447 #endif /* HAVE_NTGUI */
7449 /* Reading a GIF image from memory
7450 Based on the PNG memory stuff to a certain extent. */
7454 unsigned char *bytes
;
7460 /* Make the current memory source available to gif_read_from_memory.
7461 It's done this way because not all versions of libungif support
7462 a UserData field in the GifFileType structure. */
7463 static gif_memory_source
*current_gif_memory_src
;
7466 gif_read_from_memory (file
, buf
, len
)
7471 gif_memory_source
*src
= current_gif_memory_src
;
7473 if (len
> src
->len
- src
->index
)
7476 bcopy (src
->bytes
+ src
->index
, buf
, len
);
7482 /* Load GIF image IMG for use on frame F. Value is non-zero if
7490 Lisp_Object file
, specified_file
;
7491 Lisp_Object specified_data
;
7492 int rc
, width
, height
, x
, y
, i
;
7494 ColorMapObject
*gif_color_map
;
7495 unsigned long pixel_colors
[256];
7497 struct gcpro gcpro1
;
7499 int ino
, image_left
, image_top
, image_width
, image_height
;
7500 gif_memory_source memsrc
;
7501 unsigned char *raster
;
7503 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
7504 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
7508 if (NILP (specified_data
))
7510 file
= x_find_image_file (specified_file
);
7511 if (!STRINGP (file
))
7513 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
7518 /* Open the GIF file. Casting return value avoids a GCC warning
7520 gif
= (GifFileType
*)fn_DGifOpenFileName (SDATA (file
));
7523 image_error ("Cannot open `%s'", file
, Qnil
);
7530 /* Read from memory! */
7531 current_gif_memory_src
= &memsrc
;
7532 memsrc
.bytes
= SDATA (specified_data
);
7533 memsrc
.len
= SBYTES (specified_data
);
7536 /* Casting return value avoids a GCC warning on W32. */
7537 gif
= (GifFileType
*)fn_DGifOpen(&memsrc
, gif_read_from_memory
);
7540 image_error ("Cannot open memory source `%s'", img
->spec
, Qnil
);
7546 /* Before reading entire contents, check the declared image size. */
7547 if (!check_image_size (f
, gif
->SWidth
, gif
->SHeight
))
7549 image_error ("Invalid image size", Qnil
, Qnil
);
7550 fn_DGifCloseFile (gif
);
7555 /* Read entire contents. */
7556 rc
= fn_DGifSlurp (gif
);
7557 if (rc
== GIF_ERROR
)
7559 image_error ("Error reading `%s'", img
->spec
, Qnil
);
7560 fn_DGifCloseFile (gif
);
7565 image
= image_spec_value (img
->spec
, QCindex
, NULL
);
7566 ino
= INTEGERP (image
) ? XFASTINT (image
) : 0;
7567 if (ino
>= gif
->ImageCount
)
7569 image_error ("Invalid image number `%s' in image `%s'",
7571 fn_DGifCloseFile (gif
);
7576 image_top
= gif
->SavedImages
[ino
].ImageDesc
.Top
;
7577 image_left
= gif
->SavedImages
[ino
].ImageDesc
.Left
;
7578 image_width
= gif
->SavedImages
[ino
].ImageDesc
.Width
;
7579 image_height
= gif
->SavedImages
[ino
].ImageDesc
.Height
;
7581 width
= img
->width
= max (gif
->SWidth
,
7582 max (gif
->Image
.Left
+ gif
->Image
.Width
,
7583 image_left
+ image_width
));
7584 height
= img
->height
= max (gif
->SHeight
,
7585 max (gif
->Image
.Top
+ gif
->Image
.Height
,
7586 image_top
+ image_height
));
7588 if (!check_image_size (f
, width
, height
))
7590 image_error ("Invalid image size", Qnil
, Qnil
);
7591 fn_DGifCloseFile (gif
);
7596 /* Create the X image and pixmap. */
7597 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
7599 fn_DGifCloseFile (gif
);
7604 /* Allocate colors. */
7605 gif_color_map
= gif
->SavedImages
[ino
].ImageDesc
.ColorMap
;
7607 gif_color_map
= gif
->SColorMap
;
7608 init_color_table ();
7609 bzero (pixel_colors
, sizeof pixel_colors
);
7611 for (i
= 0; i
< gif_color_map
->ColorCount
; ++i
)
7613 int r
= gif_color_map
->Colors
[i
].Red
<< 8;
7614 int g
= gif_color_map
->Colors
[i
].Green
<< 8;
7615 int b
= gif_color_map
->Colors
[i
].Blue
<< 8;
7616 pixel_colors
[i
] = lookup_rgb_color (f
, r
, g
, b
);
7619 #ifdef COLOR_TABLE_SUPPORT
7620 img
->colors
= colors_in_color_table (&img
->ncolors
);
7621 free_color_table ();
7622 #endif /* COLOR_TABLE_SUPPORT */
7624 /* Clear the part of the screen image that are not covered by
7625 the image from the GIF file. Full animated GIF support
7626 requires more than can be done here (see the gif89 spec,
7627 disposal methods). Let's simply assume that the part
7628 not covered by a sub-image is in the frame's background color. */
7629 for (y
= 0; y
< image_top
; ++y
)
7630 for (x
= 0; x
< width
; ++x
)
7631 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7633 for (y
= image_top
+ image_height
; y
< height
; ++y
)
7634 for (x
= 0; x
< width
; ++x
)
7635 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7637 for (y
= image_top
; y
< image_top
+ image_height
; ++y
)
7639 for (x
= 0; x
< image_left
; ++x
)
7640 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7641 for (x
= image_left
+ image_width
; x
< width
; ++x
)
7642 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7645 /* Read the GIF image into the X image. We use a local variable
7646 `raster' here because RasterBits below is a char *, and invites
7647 problems with bytes >= 0x80. */
7648 raster
= (unsigned char *) gif
->SavedImages
[ino
].RasterBits
;
7650 if (gif
->SavedImages
[ino
].ImageDesc
.Interlace
)
7652 static int interlace_start
[] = {0, 4, 2, 1};
7653 static int interlace_increment
[] = {8, 8, 4, 2};
7655 int row
= interlace_start
[0];
7659 for (y
= 0; y
< image_height
; y
++)
7661 if (row
>= image_height
)
7663 row
= interlace_start
[++pass
];
7664 while (row
>= image_height
)
7665 row
= interlace_start
[++pass
];
7668 for (x
= 0; x
< image_width
; x
++)
7670 int i
= raster
[(y
* image_width
) + x
];
7671 XPutPixel (ximg
, x
+ image_left
, row
+ image_top
,
7675 row
+= interlace_increment
[pass
];
7680 for (y
= 0; y
< image_height
; ++y
)
7681 for (x
= 0; x
< image_width
; ++x
)
7683 int i
= raster
[y
* image_width
+ x
];
7684 XPutPixel (ximg
, x
+ image_left
, y
+ image_top
, pixel_colors
[i
]);
7688 fn_DGifCloseFile (gif
);
7690 /* Maybe fill in the background field while we have ximg handy. */
7691 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
7692 /* Casting avoids a GCC warning. */
7693 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
7695 /* Put the image into the pixmap, then free the X image and its buffer. */
7696 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
7697 x_destroy_x_image (ximg
);
7703 #else /* !HAVE_GIF */
7711 Lisp_Object specified_file
, file
;
7712 Lisp_Object specified_data
;
7714 Boolean graphic_p
, movie_p
, prefer_graphic_p
;
7722 Lisp_Object specified_bg
;
7728 struct gcpro gcpro1
;
7733 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
7734 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
7736 if (NILP (specified_data
))
7738 /* Read from a file */
7742 err
= find_image_fsspec (specified_file
, &file
, &fss
);
7746 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
7751 err
= CanQuickTimeOpenFile (&fss
, kQTFileTypeGIF
, 0,
7752 &graphic_p
, &movie_p
, &prefer_graphic_p
, 0);
7756 if (!graphic_p
&& !movie_p
)
7758 if (prefer_graphic_p
)
7759 return image_load_qt_1 (f
, img
, kQTFileTypeGIF
, &fss
, NULL
);
7760 err
= OpenMovieFile (&fss
, &refnum
, fsRdPerm
);
7763 err
= NewMovieFromFile (&movie
, refnum
, NULL
, NULL
, 0, NULL
);
7764 CloseMovieFile (refnum
);
7767 image_error ("Error reading `%s'", file
, Qnil
);
7773 /* Memory source! */
7775 long file_type_atom
[3];
7777 err
= PtrToHand (SDATA (specified_data
), &dh
, SBYTES (specified_data
));
7780 image_error ("Cannot allocate data handle for `%s'",
7785 file_type_atom
[0] = EndianU32_NtoB (sizeof (long) * 3);
7786 file_type_atom
[1] = EndianU32_NtoB (kDataRefExtensionMacOSFileType
);
7787 file_type_atom
[2] = EndianU32_NtoB (kQTFileTypeGIF
);
7788 err
= PtrToHand (&dh
, &dref
, sizeof (Handle
));
7791 err
= PtrAndHand ("\p", dref
, 1);
7793 err
= PtrAndHand (file_type_atom
, dref
, sizeof (long) * 3);
7796 image_error ("Cannot allocate handle data ref for `%s'", img
->spec
, Qnil
);
7799 err
= CanQuickTimeOpenDataRef (dref
, HandleDataHandlerSubType
, &graphic_p
,
7800 &movie_p
, &prefer_graphic_p
, 0);
7804 if (!graphic_p
&& !movie_p
)
7806 if (prefer_graphic_p
)
7810 DisposeHandle (dref
);
7811 success_p
= image_load_qt_1 (f
, img
, kQTFileTypeGIF
, NULL
, dh
);
7815 err
= NewMovieFromDataRef (&movie
, 0, NULL
, dref
,
7816 HandleDataHandlerSubType
);
7817 DisposeHandle (dref
);
7822 image
= image_spec_value (img
->spec
, QCindex
, NULL
);
7823 ino
= INTEGERP (image
) ? XFASTINT (image
) : 0;
7824 track
= GetMovieIndTrack (movie
, 1);
7825 media
= GetTrackMedia (track
);
7826 nsamples
= GetMediaSampleCount (media
);
7827 if (ino
>= nsamples
)
7829 image_error ("Invalid image number `%s' in image `%s'",
7834 specified_bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
7835 if (!STRINGP (specified_bg
) ||
7836 !mac_defined_color (f
, SDATA (specified_bg
), &color
, 0))
7838 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
7839 color
.red
= RED16_FROM_ULONG (color
.pixel
);
7840 color
.green
= GREEN16_FROM_ULONG (color
.pixel
);
7841 color
.blue
= BLUE16_FROM_ULONG (color
.pixel
);
7843 GetMovieBox (movie
, &rect
);
7844 width
= img
->width
= rect
.right
- rect
.left
;
7845 height
= img
->height
= rect
.bottom
- rect
.top
;
7846 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
7849 GetGWorld (&old_port
, &old_gdh
);
7850 SetGWorld (ximg
, NULL
);
7851 bg_color
.red
= color
.red
;
7852 bg_color
.green
= color
.green
;
7853 bg_color
.blue
= color
.blue
;
7854 RGBBackColor (&bg_color
);
7855 SetGWorld (old_port
, old_gdh
);
7856 SetMovieActive (movie
, 1);
7857 SetMovieGWorld (movie
, ximg
, NULL
);
7858 SampleNumToMediaTime (media
, ino
+ 1, &time
, NULL
);
7859 SetMovieTimeValue (movie
, time
);
7860 MoviesTask (movie
, 0L);
7861 DisposeTrackMedia (media
);
7862 DisposeMovieTrack (track
);
7863 DisposeMovie (movie
);
7866 /* Maybe fill in the background field while we have ximg handy. */
7867 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
7868 IMAGE_BACKGROUND (img
, f
, ximg
);
7870 /* Put the image into the pixmap. */
7871 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
7872 x_destroy_x_image (ximg
);
7876 image_error ("Cannot open `%s'", file
, Qnil
);
7879 DisposeTrackMedia (media
);
7881 DisposeMovieTrack (track
);
7883 DisposeMovie (movie
);
7890 #endif /* HAVE_GIF */
7894 /***********************************************************************
7896 ***********************************************************************/
7898 #ifdef HAVE_X_WINDOWS
7899 #define HAVE_GHOSTSCRIPT 1
7900 #endif /* HAVE_X_WINDOWS */
7902 /* The symbol `postscript' identifying images of this type. */
7904 Lisp_Object Qpostscript
;
7906 #ifdef HAVE_GHOSTSCRIPT
7908 static int gs_image_p
P_ ((Lisp_Object object
));
7909 static int gs_load
P_ ((struct frame
*f
, struct image
*img
));
7910 static void gs_clear_image
P_ ((struct frame
*f
, struct image
*img
));
7912 /* Keyword symbols. */
7914 Lisp_Object QCloader
, QCbounding_box
, QCpt_width
, QCpt_height
;
7916 /* Indices of image specification fields in gs_format, below. */
7918 enum gs_keyword_index
7936 /* Vector of image_keyword structures describing the format
7937 of valid user-defined image specifications. */
7939 static struct image_keyword gs_format
[GS_LAST
] =
7941 {":type", IMAGE_SYMBOL_VALUE
, 1},
7942 {":pt-width", IMAGE_POSITIVE_INTEGER_VALUE
, 1},
7943 {":pt-height", IMAGE_POSITIVE_INTEGER_VALUE
, 1},
7944 {":file", IMAGE_STRING_VALUE
, 1},
7945 {":loader", IMAGE_FUNCTION_VALUE
, 0},
7946 {":bounding-box", IMAGE_DONT_CHECK_VALUE_TYPE
, 1},
7947 {":ascent", IMAGE_ASCENT_VALUE
, 0},
7948 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
7949 {":relief", IMAGE_INTEGER_VALUE
, 0},
7950 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7951 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7952 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7953 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
7956 /* Structure describing the image type `ghostscript'. */
7958 static struct image_type gs_type
=
7968 /* Free X resources of Ghostscript image IMG which is used on frame F. */
7971 gs_clear_image (f
, img
)
7975 /* IMG->data.ptr_val may contain a recorded colormap. */
7976 xfree (img
->data
.ptr_val
);
7977 x_clear_image (f
, img
);
7981 /* Return non-zero if OBJECT is a valid Ghostscript image
7988 struct image_keyword fmt
[GS_LAST
];
7992 bcopy (gs_format
, fmt
, sizeof fmt
);
7994 if (!parse_image_spec (object
, fmt
, GS_LAST
, Qpostscript
))
7997 /* Bounding box must be a list or vector containing 4 integers. */
7998 tem
= fmt
[GS_BOUNDING_BOX
].value
;
8001 for (i
= 0; i
< 4; ++i
, tem
= XCDR (tem
))
8002 if (!CONSP (tem
) || !INTEGERP (XCAR (tem
)))
8007 else if (VECTORP (tem
))
8009 if (XVECTOR (tem
)->size
!= 4)
8011 for (i
= 0; i
< 4; ++i
)
8012 if (!INTEGERP (XVECTOR (tem
)->contents
[i
]))
8022 /* Load Ghostscript image IMG for use on frame F. Value is non-zero
8031 Lisp_Object window_and_pixmap_id
= Qnil
, loader
, pt_height
, pt_width
;
8032 struct gcpro gcpro1
, gcpro2
;
8034 double in_width
, in_height
;
8035 Lisp_Object pixel_colors
= Qnil
;
8037 /* Compute pixel size of pixmap needed from the given size in the
8038 image specification. Sizes in the specification are in pt. 1 pt
8039 = 1/72 in, xdpi and ydpi are stored in the frame's X display
8041 pt_width
= image_spec_value (img
->spec
, QCpt_width
, NULL
);
8042 in_width
= XFASTINT (pt_width
) / 72.0;
8043 img
->width
= in_width
* FRAME_X_DISPLAY_INFO (f
)->resx
;
8044 pt_height
= image_spec_value (img
->spec
, QCpt_height
, NULL
);
8045 in_height
= XFASTINT (pt_height
) / 72.0;
8046 img
->height
= in_height
* FRAME_X_DISPLAY_INFO (f
)->resy
;
8048 if (!check_image_size (f
, img
->width
, img
->height
))
8050 image_error ("Invalid image size", Qnil
, Qnil
);
8054 /* Create the pixmap. */
8055 xassert (img
->pixmap
== NO_PIXMAP
);
8057 /* Only W32 version did BLOCK_INPUT here. ++kfs */
8059 img
->pixmap
= XCreatePixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
8060 img
->width
, img
->height
,
8061 DefaultDepthOfScreen (FRAME_X_SCREEN (f
)));
8066 image_error ("Unable to create pixmap for `%s'", img
->spec
, Qnil
);
8070 /* Call the loader to fill the pixmap. It returns a process object
8071 if successful. We do not record_unwind_protect here because
8072 other places in redisplay like calling window scroll functions
8073 don't either. Let the Lisp loader use `unwind-protect' instead. */
8074 GCPRO2 (window_and_pixmap_id
, pixel_colors
);
8076 sprintf (buffer
, "%lu %lu",
8077 (unsigned long) FRAME_X_WINDOW (f
),
8078 (unsigned long) img
->pixmap
);
8079 window_and_pixmap_id
= build_string (buffer
);
8081 sprintf (buffer
, "%lu %lu",
8082 FRAME_FOREGROUND_PIXEL (f
),
8083 FRAME_BACKGROUND_PIXEL (f
));
8084 pixel_colors
= build_string (buffer
);
8086 XSETFRAME (frame
, f
);
8087 loader
= image_spec_value (img
->spec
, QCloader
, NULL
);
8089 loader
= intern ("gs-load-image");
8091 img
->data
.lisp_val
= call6 (loader
, frame
, img
->spec
,
8092 make_number (img
->width
),
8093 make_number (img
->height
),
8094 window_and_pixmap_id
,
8097 return PROCESSP (img
->data
.lisp_val
);
8101 /* Kill the Ghostscript process that was started to fill PIXMAP on
8102 frame F. Called from XTread_socket when receiving an event
8103 telling Emacs that Ghostscript has finished drawing. */
8106 x_kill_gs_process (pixmap
, f
)
8110 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
8114 /* Find the image containing PIXMAP. */
8115 for (i
= 0; i
< c
->used
; ++i
)
8116 if (c
->images
[i
]->pixmap
== pixmap
)
8119 /* Should someone in between have cleared the image cache, for
8120 instance, give up. */
8124 /* Kill the GS process. We should have found PIXMAP in the image
8125 cache and its image should contain a process object. */
8127 xassert (PROCESSP (img
->data
.lisp_val
));
8128 Fkill_process (img
->data
.lisp_val
, Qnil
);
8129 img
->data
.lisp_val
= Qnil
;
8131 #if defined (HAVE_X_WINDOWS)
8133 /* On displays with a mutable colormap, figure out the colors
8134 allocated for the image by looking at the pixels of an XImage for
8136 class = FRAME_X_VISUAL (f
)->class;
8137 if (class != StaticColor
&& class != StaticGray
&& class != TrueColor
)
8143 /* Try to get an XImage for img->pixmep. */
8144 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
8145 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
8150 /* Initialize the color table. */
8151 init_color_table ();
8153 /* For each pixel of the image, look its color up in the
8154 color table. After having done so, the color table will
8155 contain an entry for each color used by the image. */
8156 for (y
= 0; y
< img
->height
; ++y
)
8157 for (x
= 0; x
< img
->width
; ++x
)
8159 unsigned long pixel
= XGetPixel (ximg
, x
, y
);
8160 lookup_pixel_color (f
, pixel
);
8163 /* Record colors in the image. Free color table and XImage. */
8164 #ifdef COLOR_TABLE_SUPPORT
8165 img
->colors
= colors_in_color_table (&img
->ncolors
);
8166 free_color_table ();
8168 XDestroyImage (ximg
);
8170 #if 0 /* This doesn't seem to be the case. If we free the colors
8171 here, we get a BadAccess later in x_clear_image when
8172 freeing the colors. */
8173 /* We have allocated colors once, but Ghostscript has also
8174 allocated colors on behalf of us. So, to get the
8175 reference counts right, free them once. */
8177 x_free_colors (f
, img
->colors
, img
->ncolors
);
8181 image_error ("Cannot get X image of `%s'; colors will not be freed",
8186 #endif /* HAVE_X_WINDOWS */
8188 /* Now that we have the pixmap, compute mask and transform the
8189 image if requested. */
8191 postprocess_image (f
, img
);
8195 #endif /* HAVE_GHOSTSCRIPT */
8198 /***********************************************************************
8200 ***********************************************************************/
8204 DEFUN ("imagep", Fimagep
, Simagep
, 1, 1, 0,
8205 doc
: /* Value is non-nil if SPEC is a valid image specification. */)
8209 return valid_image_p (spec
) ? Qt
: Qnil
;
8213 DEFUN ("lookup-image", Flookup_image
, Slookup_image
, 1, 1, 0, "")
8219 if (valid_image_p (spec
))
8220 id
= lookup_image (SELECTED_FRAME (), spec
);
8223 return make_number (id
);
8226 #endif /* GLYPH_DEBUG != 0 */
8229 /***********************************************************************
8231 ***********************************************************************/
8234 /* Image types that rely on external libraries are loaded dynamically
8235 if the library is available. */
8236 #define CHECK_LIB_AVAILABLE(image_type, init_lib_fn, libraries) \
8237 define_image_type (image_type, init_lib_fn (libraries))
8239 #define CHECK_LIB_AVAILABLE(image_type, init_lib_fn, libraries) \
8240 define_image_type (image_type, 1)
8241 #endif /* HAVE_NTGUI */
8243 DEFUN ("init-image-library", Finit_image_library
, Sinit_image_library
, 2, 2, 0,
8244 doc
: /* Initialize image library implementing image type TYPE.
8245 Return non-nil if TYPE is a supported image type.
8247 Image types pbm and xbm are prebuilt; other types are loaded here.
8248 Libraries to load are specified in alist LIBRARIES (usually, the value
8249 of `image-library-alist', which see). */)
8251 Lisp_Object type
, libraries
;
8255 /* Don't try to reload the library. */
8256 tested
= Fassq (type
, Vimage_type_cache
);
8258 return XCDR (tested
);
8260 #if defined (HAVE_XPM) || defined (MAC_OS)
8261 if (EQ (type
, Qxpm
))
8262 return CHECK_LIB_AVAILABLE (&xpm_type
, init_xpm_functions
, libraries
);
8265 #if defined (HAVE_JPEG) || defined (MAC_OS)
8266 if (EQ (type
, Qjpeg
))
8267 return CHECK_LIB_AVAILABLE (&jpeg_type
, init_jpeg_functions
, libraries
);
8270 #if defined (HAVE_TIFF) || defined (MAC_OS)
8271 if (EQ (type
, Qtiff
))
8272 return CHECK_LIB_AVAILABLE (&tiff_type
, init_tiff_functions
, libraries
);
8275 #if defined (HAVE_GIF) || defined (MAC_OS)
8276 if (EQ (type
, Qgif
))
8277 return CHECK_LIB_AVAILABLE (&gif_type
, init_gif_functions
, libraries
);
8280 #if defined (HAVE_PNG) || defined (MAC_OS)
8281 if (EQ (type
, Qpng
))
8282 return CHECK_LIB_AVAILABLE (&png_type
, init_png_functions
, libraries
);
8285 #ifdef HAVE_GHOSTSCRIPT
8286 if (EQ (type
, Qpostscript
))
8287 return CHECK_LIB_AVAILABLE (&gs_type
, init_gs_functions
, libraries
);
8290 /* If the type is not recognized, avoid testing it ever again. */
8291 CACHE_IMAGE_TYPE (type
, Qnil
);
8298 extern Lisp_Object Qrisky_local_variable
; /* Syms_of_xdisp has already run. */
8300 /* Initialize this only once, since that's what we do with Vimage_types
8301 and they are supposed to be in sync. Initializing here gives correct
8302 operation on GNU/Linux of calling dump-emacs after loading some images. */
8305 /* Must be defined now becase we're going to update it below, while
8306 defining the supported image types. */
8307 DEFVAR_LISP ("image-types", &Vimage_types
,
8308 doc
: /* List of potentially supported image types.
8309 Each element of the list is a symbol for a image type, like 'jpeg or 'png.
8310 To check whether it is really supported, use `image-type-available-p'. */);
8311 Vimage_types
= Qnil
;
8313 DEFVAR_LISP ("image-library-alist", &Vimage_library_alist
,
8314 doc
: /* Alist of image types vs external libraries needed to display them.
8316 Each element is a list (IMAGE-TYPE LIBRARY...), where the car is a symbol
8317 representing a supported image type, and the rest are strings giving
8318 alternate filenames for the corresponding external libraries.
8320 Emacs tries to load the libraries in the order they appear on the
8321 list; if none is loaded, the running session of Emacs won't
8322 support the image type. Types 'pbm and 'xbm don't need to be
8323 listed; they're always supported. */);
8324 Vimage_library_alist
= Qnil
;
8325 Fput (intern ("image-library-alist"), Qrisky_local_variable
, Qt
);
8327 DEFVAR_LISP ("max-image-size", &Vmax_image_size
,
8328 doc
: /* Maximum size of images.
8329 Emacs will not load an image into memory if its pixel width or
8330 pixel height exceeds this limit.
8332 If the value is an integer, it directly specifies the maximum
8333 image height and width, measured in pixels. If it is a floating
8334 point number, it specifies the maximum image height and width
8335 as a ratio to the frame height and width. If the value is
8336 non-numeric, there is no explicit limit on the size of images. */);
8337 Vmax_image_size
= make_float (MAX_IMAGE_SIZE
);
8339 Vimage_type_cache
= Qnil
;
8340 staticpro (&Vimage_type_cache
);
8342 Qpbm
= intern ("pbm");
8344 ADD_IMAGE_TYPE(Qpbm
);
8346 Qxbm
= intern ("xbm");
8348 ADD_IMAGE_TYPE(Qxbm
);
8350 define_image_type (&xbm_type
, 1);
8351 define_image_type (&pbm_type
, 1);
8353 QCascent
= intern (":ascent");
8354 staticpro (&QCascent
);
8355 QCmargin
= intern (":margin");
8356 staticpro (&QCmargin
);
8357 QCrelief
= intern (":relief");
8358 staticpro (&QCrelief
);
8359 QCconversion
= intern (":conversion");
8360 staticpro (&QCconversion
);
8361 QCcolor_symbols
= intern (":color-symbols");
8362 staticpro (&QCcolor_symbols
);
8363 QCheuristic_mask
= intern (":heuristic-mask");
8364 staticpro (&QCheuristic_mask
);
8365 QCindex
= intern (":index");
8366 staticpro (&QCindex
);
8367 QCmatrix
= intern (":matrix");
8368 staticpro (&QCmatrix
);
8369 QCcolor_adjustment
= intern (":color-adjustment");
8370 staticpro (&QCcolor_adjustment
);
8371 QCmask
= intern (":mask");
8372 staticpro (&QCmask
);
8374 Qlaplace
= intern ("laplace");
8375 staticpro (&Qlaplace
);
8376 Qemboss
= intern ("emboss");
8377 staticpro (&Qemboss
);
8378 Qedge_detection
= intern ("edge-detection");
8379 staticpro (&Qedge_detection
);
8380 Qheuristic
= intern ("heuristic");
8381 staticpro (&Qheuristic
);
8383 Qpostscript
= intern ("postscript");
8384 staticpro (&Qpostscript
);
8385 #ifdef HAVE_GHOSTSCRIPT
8386 ADD_IMAGE_TYPE(Qpostscript
);
8387 QCloader
= intern (":loader");
8388 staticpro (&QCloader
);
8389 QCbounding_box
= intern (":bounding-box");
8390 staticpro (&QCbounding_box
);
8391 QCpt_width
= intern (":pt-width");
8392 staticpro (&QCpt_width
);
8393 QCpt_height
= intern (":pt-height");
8394 staticpro (&QCpt_height
);
8395 #endif /* HAVE_GHOSTSCRIPT */
8397 #if defined (HAVE_XPM) || defined (MAC_OS)
8398 Qxpm
= intern ("xpm");
8400 ADD_IMAGE_TYPE(Qxpm
);
8403 #if defined (HAVE_JPEG) || defined (MAC_OS)
8404 Qjpeg
= intern ("jpeg");
8406 ADD_IMAGE_TYPE(Qjpeg
);
8409 #if defined (HAVE_TIFF) || defined (MAC_OS)
8410 Qtiff
= intern ("tiff");
8412 ADD_IMAGE_TYPE(Qtiff
);
8415 #if defined (HAVE_GIF) || defined (MAC_OS)
8416 Qgif
= intern ("gif");
8418 ADD_IMAGE_TYPE(Qgif
);
8421 #if defined (HAVE_PNG) || defined (MAC_OS)
8422 Qpng
= intern ("png");
8424 ADD_IMAGE_TYPE(Qpng
);
8427 defsubr (&Sinit_image_library
);
8428 defsubr (&Sclear_image_cache
);
8429 defsubr (&Simage_size
);
8430 defsubr (&Simage_mask_p
);
8434 defsubr (&Slookup_image
);
8437 DEFVAR_BOOL ("cross-disabled-images", &cross_disabled_images
,
8438 doc
: /* Non-nil means always draw a cross over disabled images.
8439 Disabled images are those having an `:conversion disabled' property.
8440 A cross is always drawn on black & white displays. */);
8441 cross_disabled_images
= 0;
8443 DEFVAR_LISP ("x-bitmap-file-path", &Vx_bitmap_file_path
,
8444 doc
: /* List of directories to search for window system bitmap files. */);
8445 Vx_bitmap_file_path
= decode_env_path ((char *) 0, PATH_BITMAPS
);
8447 DEFVAR_LISP ("image-cache-eviction-delay", &Vimage_cache_eviction_delay
,
8448 doc
: /* Time after which cached images are removed from the cache.
8449 When an image has not been displayed this many seconds, remove it
8450 from the image cache. Value must be an integer or nil with nil
8451 meaning don't clear the cache. */);
8452 Vimage_cache_eviction_delay
= make_number (30 * 60);
8459 /* Animated gifs use QuickTime Movie Toolbox. So initialize it here. */
8462 init_image_func_pointer ();
8467 /* arch-tag: 123c2a5e-14a8-4c53-ab95-af47d7db49b9
8468 (do not change this comment) */