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
)
1166 if (width
<= 0 || height
<=0)
1169 if (FLOATP (Vmax_image_size
) && f
1170 && ((width
> (int)(XFLOAT_DATA (Vmax_image_size
)
1171 * FRAME_PIXEL_WIDTH (f
)))
1172 || (height
> (int)(XFLOAT_DATA (Vmax_image_size
)
1173 * FRAME_PIXEL_HEIGHT (f
)))))
1179 /* Prepare image IMG for display on frame F. Must be called before
1180 drawing an image. */
1183 prepare_image_for_display (f
, img
)
1189 /* We're about to display IMG, so set its timestamp to `now'. */
1191 img
->timestamp
= EMACS_SECS (t
);
1193 /* If IMG doesn't have a pixmap yet, load it now, using the image
1194 type dependent loader function. */
1195 if (img
->pixmap
== NO_PIXMAP
&& !img
->load_failed_p
)
1196 img
->load_failed_p
= img
->type
->load (f
, img
) == 0;
1200 /* Value is the number of pixels for the ascent of image IMG when
1201 drawn in face FACE. */
1204 image_ascent (img
, face
, slice
)
1207 struct glyph_slice
*slice
;
1212 if (slice
->height
== img
->height
)
1213 height
= img
->height
+ img
->vmargin
;
1214 else if (slice
->y
== 0)
1215 height
= slice
->height
+ img
->vmargin
;
1217 height
= slice
->height
;
1219 if (img
->ascent
== CENTERED_IMAGE_ASCENT
)
1224 /* W32 specific version. Why?. ++kfs */
1225 ascent
= height
/ 2 - (FONT_DESCENT(face
->font
)
1226 - FONT_BASE(face
->font
)) / 2;
1228 /* This expression is arranged so that if the image can't be
1229 exactly centered, it will be moved slightly up. This is
1230 because a typical font is `top-heavy' (due to the presence
1231 uppercase letters), so the image placement should err towards
1232 being top-heavy too. It also just generally looks better. */
1233 ascent
= (height
+ face
->font
->ascent
- face
->font
->descent
+ 1) / 2;
1234 #endif /* HAVE_NTGUI */
1237 ascent
= height
/ 2;
1240 ascent
= (int) (height
* img
->ascent
/ 100.0);
1246 /* Image background colors. */
1248 /* Find the "best" corner color of a bitmap.
1249 On W32, XIMG is assumed to a device context with the bitmap selected. */
1251 static RGB_PIXEL_COLOR
1252 four_corners_best (ximg
, width
, height
)
1253 XImagePtr_or_DC ximg
;
1254 unsigned long width
, height
;
1256 RGB_PIXEL_COLOR corners
[4], best
;
1259 /* Get the colors at the corners of ximg. */
1260 corners
[0] = GET_PIXEL (ximg
, 0, 0);
1261 corners
[1] = GET_PIXEL (ximg
, width
- 1, 0);
1262 corners
[2] = GET_PIXEL (ximg
, width
- 1, height
- 1);
1263 corners
[3] = GET_PIXEL (ximg
, 0, height
- 1);
1265 /* Choose the most frequently found color as background. */
1266 for (i
= best_count
= 0; i
< 4; ++i
)
1270 for (j
= n
= 0; j
< 4; ++j
)
1271 if (corners
[i
] == corners
[j
])
1275 best
= corners
[i
], best_count
= n
;
1281 /* Portability macros */
1285 #define Destroy_Image(img_dc, prev) \
1286 do { SelectObject (img_dc, prev); DeleteDC (img_dc); } while (0)
1288 #define Free_Pixmap(display, pixmap) \
1289 DeleteObject (pixmap)
1293 #define Destroy_Image(ximg, dummy) \
1294 XDestroyImage (ximg)
1296 #define Free_Pixmap(display, pixmap) \
1297 XFreePixmap (display, pixmap)
1299 #endif /* HAVE_NTGUI */
1302 /* Return the `background' field of IMG. If IMG doesn't have one yet,
1303 it is guessed heuristically. If non-zero, XIMG is an existing
1304 XImage object (or device context with the image selected on W32) to
1305 use for the heuristic. */
1308 image_background (img
, f
, ximg
)
1311 XImagePtr_or_DC ximg
;
1313 if (! img
->background_valid
)
1314 /* IMG doesn't have a background yet, try to guess a reasonable value. */
1316 int free_ximg
= !ximg
;
1319 #endif /* HAVE_NTGUI */
1324 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
1325 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
1327 HDC frame_dc
= get_frame_dc (f
);
1328 ximg
= CreateCompatibleDC (frame_dc
);
1329 release_frame_dc (f
, frame_dc
);
1330 prev
= SelectObject (ximg
, img
->pixmap
);
1331 #endif /* !HAVE_NTGUI */
1334 img
->background
= four_corners_best (ximg
, img
->width
, img
->height
);
1337 Destroy_Image (ximg
, prev
);
1339 img
->background_valid
= 1;
1342 return img
->background
;
1345 /* Return the `background_transparent' field of IMG. If IMG doesn't
1346 have one yet, it is guessed heuristically. If non-zero, MASK is an
1347 existing XImage object to use for the heuristic. */
1350 image_background_transparent (img
, f
, mask
)
1353 XImagePtr_or_DC mask
;
1355 if (! img
->background_transparent_valid
)
1356 /* IMG doesn't have a background yet, try to guess a reasonable value. */
1360 int free_mask
= !mask
;
1363 #endif /* HAVE_NTGUI */
1368 mask
= XGetImage (FRAME_X_DISPLAY (f
), img
->mask
,
1369 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
1371 HDC frame_dc
= get_frame_dc (f
);
1372 mask
= CreateCompatibleDC (frame_dc
);
1373 release_frame_dc (f
, frame_dc
);
1374 prev
= SelectObject (mask
, img
->mask
);
1375 #endif /* HAVE_NTGUI */
1378 img
->background_transparent
1379 = (four_corners_best (mask
, img
->width
, img
->height
) == PIX_MASK_RETAIN
);
1382 Destroy_Image (mask
, prev
);
1385 img
->background_transparent
= 0;
1387 img
->background_transparent_valid
= 1;
1390 return img
->background_transparent
;
1394 /***********************************************************************
1395 Helper functions for X image types
1396 ***********************************************************************/
1398 static void x_clear_image_1
P_ ((struct frame
*, struct image
*, int,
1400 static void x_clear_image
P_ ((struct frame
*f
, struct image
*img
));
1401 static unsigned long x_alloc_image_color
P_ ((struct frame
*f
,
1403 Lisp_Object color_name
,
1404 unsigned long dflt
));
1407 /* Clear X resources of image IMG on frame F. PIXMAP_P non-zero means
1408 free the pixmap if any. MASK_P non-zero means clear the mask
1409 pixmap if any. COLORS_P non-zero means free colors allocated for
1410 the image, if any. */
1413 x_clear_image_1 (f
, img
, pixmap_p
, mask_p
, colors_p
)
1416 int pixmap_p
, mask_p
, colors_p
;
1418 if (pixmap_p
&& img
->pixmap
)
1420 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->pixmap
);
1421 img
->pixmap
= NO_PIXMAP
;
1422 img
->background_valid
= 0;
1425 if (mask_p
&& img
->mask
)
1427 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
1428 img
->mask
= NO_PIXMAP
;
1429 img
->background_transparent_valid
= 0;
1432 if (colors_p
&& img
->ncolors
)
1434 /* MAC_TODO: color table support. */
1435 /* W32_TODO: color table support. */
1436 #ifdef HAVE_X_WINDOWS
1437 x_free_colors (f
, img
->colors
, img
->ncolors
);
1438 #endif /* HAVE_X_WINDOWS */
1439 xfree (img
->colors
);
1445 /* Free X resources of image IMG which is used on frame F. */
1448 x_clear_image (f
, img
)
1453 x_clear_image_1 (f
, img
, 1, 1, 1);
1458 /* Allocate color COLOR_NAME for image IMG on frame F. If color
1459 cannot be allocated, use DFLT. Add a newly allocated color to
1460 IMG->colors, so that it can be freed again. Value is the pixel
1463 static unsigned long
1464 x_alloc_image_color (f
, img
, color_name
, dflt
)
1467 Lisp_Object color_name
;
1471 unsigned long result
;
1473 xassert (STRINGP (color_name
));
1475 if (x_defined_color (f
, SDATA (color_name
), &color
, 1))
1477 /* This isn't called frequently so we get away with simply
1478 reallocating the color vector to the needed size, here. */
1481 (unsigned long *) xrealloc (img
->colors
,
1482 img
->ncolors
* sizeof *img
->colors
);
1483 img
->colors
[img
->ncolors
- 1] = color
.pixel
;
1484 result
= color
.pixel
;
1494 /***********************************************************************
1496 ***********************************************************************/
1498 static void cache_image
P_ ((struct frame
*f
, struct image
*img
));
1499 static void postprocess_image
P_ ((struct frame
*, struct image
*));
1501 /* Return a new, initialized image cache that is allocated from the
1502 heap. Call free_image_cache to free an image cache. */
1504 struct image_cache
*
1507 struct image_cache
*c
= (struct image_cache
*) xmalloc (sizeof *c
);
1510 bzero (c
, sizeof *c
);
1512 c
->images
= (struct image
**) xmalloc (c
->size
* sizeof *c
->images
);
1513 size
= IMAGE_CACHE_BUCKETS_SIZE
* sizeof *c
->buckets
;
1514 c
->buckets
= (struct image
**) xmalloc (size
);
1515 bzero (c
->buckets
, size
);
1520 /* Free image cache of frame F. Be aware that X frames share images
1524 free_image_cache (f
)
1527 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
1532 /* Cache should not be referenced by any frame when freed. */
1533 xassert (c
->refcount
== 0);
1535 for (i
= 0; i
< c
->used
; ++i
)
1536 free_image (f
, c
->images
[i
]);
1540 FRAME_X_IMAGE_CACHE (f
) = NULL
;
1545 /* Clear image cache of frame F. FORCE_P non-zero means free all
1546 images. FORCE_P zero means clear only images that haven't been
1547 displayed for some time. Should be called from time to time to
1548 reduce the number of loaded images. If image-eviction-seconds is
1549 non-nil, this frees images in the cache which weren't displayed for
1550 at least that many seconds. */
1553 clear_image_cache (f
, force_p
)
1557 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
1559 if (c
&& INTEGERP (Vimage_cache_eviction_delay
))
1566 old
= EMACS_SECS (t
) - XFASTINT (Vimage_cache_eviction_delay
);
1568 /* Block input so that we won't be interrupted by a SIGIO
1569 while being in an inconsistent state. */
1572 for (i
= nfreed
= 0; i
< c
->used
; ++i
)
1574 struct image
*img
= c
->images
[i
];
1576 && (force_p
|| img
->timestamp
< old
))
1578 free_image (f
, img
);
1583 /* We may be clearing the image cache because, for example,
1584 Emacs was iconified for a longer period of time. In that
1585 case, current matrices may still contain references to
1586 images freed above. So, clear these matrices. */
1589 Lisp_Object tail
, frame
;
1591 FOR_EACH_FRAME (tail
, frame
)
1593 struct frame
*f
= XFRAME (frame
);
1594 if (FRAME_WINDOW_P (f
)
1595 && FRAME_X_IMAGE_CACHE (f
) == c
)
1596 clear_current_matrices (f
);
1599 ++windows_or_buffers_changed
;
1607 DEFUN ("clear-image-cache", Fclear_image_cache
, Sclear_image_cache
,
1609 doc
: /* Clear the image cache of FRAME.
1610 FRAME nil or omitted means use the selected frame.
1611 FRAME t means clear the image caches of all frames. */)
1619 FOR_EACH_FRAME (tail
, frame
)
1620 if (FRAME_WINDOW_P (XFRAME (frame
)))
1621 clear_image_cache (XFRAME (frame
), 1);
1624 clear_image_cache (check_x_frame (frame
), 1);
1630 /* Compute masks and transform image IMG on frame F, as specified
1631 by the image's specification, */
1634 postprocess_image (f
, img
)
1638 /* Manipulation of the image's mask. */
1641 Lisp_Object conversion
, spec
;
1646 /* `:heuristic-mask t'
1648 means build a mask heuristically.
1649 `:heuristic-mask (R G B)'
1650 `:mask (heuristic (R G B))'
1651 means build a mask from color (R G B) in the
1654 means remove a mask, if any. */
1656 mask
= image_spec_value (spec
, QCheuristic_mask
, NULL
);
1658 x_build_heuristic_mask (f
, img
, mask
);
1663 mask
= image_spec_value (spec
, QCmask
, &found_p
);
1665 if (EQ (mask
, Qheuristic
))
1666 x_build_heuristic_mask (f
, img
, Qt
);
1667 else if (CONSP (mask
)
1668 && EQ (XCAR (mask
), Qheuristic
))
1670 if (CONSP (XCDR (mask
)))
1671 x_build_heuristic_mask (f
, img
, XCAR (XCDR (mask
)));
1673 x_build_heuristic_mask (f
, img
, XCDR (mask
));
1675 else if (NILP (mask
) && found_p
&& img
->mask
)
1677 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
1678 img
->mask
= NO_PIXMAP
;
1683 /* Should we apply an image transformation algorithm? */
1684 conversion
= image_spec_value (spec
, QCconversion
, NULL
);
1685 if (EQ (conversion
, Qdisabled
))
1686 x_disable_image (f
, img
);
1687 else if (EQ (conversion
, Qlaplace
))
1689 else if (EQ (conversion
, Qemboss
))
1691 else if (CONSP (conversion
)
1692 && EQ (XCAR (conversion
), Qedge_detection
))
1695 tem
= XCDR (conversion
);
1697 x_edge_detection (f
, img
,
1698 Fplist_get (tem
, QCmatrix
),
1699 Fplist_get (tem
, QCcolor_adjustment
));
1705 /* Return the id of image with Lisp specification SPEC on frame F.
1706 SPEC must be a valid Lisp image specification (see valid_image_p). */
1709 lookup_image (f
, spec
)
1713 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
1717 struct gcpro gcpro1
;
1720 /* F must be a window-system frame, and SPEC must be a valid image
1722 xassert (FRAME_WINDOW_P (f
));
1723 xassert (valid_image_p (spec
));
1727 /* Look up SPEC in the hash table of the image cache. */
1728 hash
= sxhash (spec
, 0);
1729 i
= hash
% IMAGE_CACHE_BUCKETS_SIZE
;
1731 for (img
= c
->buckets
[i
]; img
; img
= img
->next
)
1732 if (img
->hash
== hash
&& !NILP (Fequal (img
->spec
, spec
)))
1735 if (img
&& img
->load_failed_p
)
1737 free_image (f
, img
);
1741 /* If not found, create a new image and cache it. */
1744 extern Lisp_Object Qpostscript
;
1747 img
= make_image (spec
, hash
);
1748 cache_image (f
, img
);
1749 img
->load_failed_p
= img
->type
->load (f
, img
) == 0;
1751 /* If we can't load the image, and we don't have a width and
1752 height, use some arbitrary width and height so that we can
1753 draw a rectangle for it. */
1754 if (img
->load_failed_p
)
1758 value
= image_spec_value (spec
, QCwidth
, NULL
);
1759 img
->width
= (INTEGERP (value
)
1760 ? XFASTINT (value
) : DEFAULT_IMAGE_WIDTH
);
1761 value
= image_spec_value (spec
, QCheight
, NULL
);
1762 img
->height
= (INTEGERP (value
)
1763 ? XFASTINT (value
) : DEFAULT_IMAGE_HEIGHT
);
1767 /* Handle image type independent image attributes
1768 `:ascent ASCENT', `:margin MARGIN', `:relief RELIEF',
1769 `:background COLOR'. */
1770 Lisp_Object ascent
, margin
, relief
, bg
;
1772 ascent
= image_spec_value (spec
, QCascent
, NULL
);
1773 if (INTEGERP (ascent
))
1774 img
->ascent
= XFASTINT (ascent
);
1775 else if (EQ (ascent
, Qcenter
))
1776 img
->ascent
= CENTERED_IMAGE_ASCENT
;
1778 margin
= image_spec_value (spec
, QCmargin
, NULL
);
1779 if (INTEGERP (margin
) && XINT (margin
) >= 0)
1780 img
->vmargin
= img
->hmargin
= XFASTINT (margin
);
1781 else if (CONSP (margin
) && INTEGERP (XCAR (margin
))
1782 && INTEGERP (XCDR (margin
)))
1784 if (XINT (XCAR (margin
)) > 0)
1785 img
->hmargin
= XFASTINT (XCAR (margin
));
1786 if (XINT (XCDR (margin
)) > 0)
1787 img
->vmargin
= XFASTINT (XCDR (margin
));
1790 relief
= image_spec_value (spec
, QCrelief
, NULL
);
1791 if (INTEGERP (relief
))
1793 img
->relief
= XINT (relief
);
1794 img
->hmargin
+= abs (img
->relief
);
1795 img
->vmargin
+= abs (img
->relief
);
1798 if (! img
->background_valid
)
1800 bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
1804 = x_alloc_image_color (f
, img
, bg
,
1805 FRAME_BACKGROUND_PIXEL (f
));
1806 img
->background_valid
= 1;
1810 /* Do image transformations and compute masks, unless we
1811 don't have the image yet. */
1812 if (!EQ (*img
->type
->type
, Qpostscript
))
1813 postprocess_image (f
, img
);
1819 /* We're using IMG, so set its timestamp to `now'. */
1820 EMACS_GET_TIME (now
);
1821 img
->timestamp
= EMACS_SECS (now
);
1825 /* Value is the image id. */
1830 /* Cache image IMG in the image cache of frame F. */
1833 cache_image (f
, img
)
1837 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
1840 /* Find a free slot in c->images. */
1841 for (i
= 0; i
< c
->used
; ++i
)
1842 if (c
->images
[i
] == NULL
)
1845 /* If no free slot found, maybe enlarge c->images. */
1846 if (i
== c
->used
&& c
->used
== c
->size
)
1849 c
->images
= (struct image
**) xrealloc (c
->images
,
1850 c
->size
* sizeof *c
->images
);
1853 /* Add IMG to c->images, and assign IMG an id. */
1859 /* Add IMG to the cache's hash table. */
1860 i
= img
->hash
% IMAGE_CACHE_BUCKETS_SIZE
;
1861 img
->next
= c
->buckets
[i
];
1863 img
->next
->prev
= img
;
1865 c
->buckets
[i
] = img
;
1869 /* Call FN on every image in the image cache of frame F. Used to mark
1870 Lisp Objects in the image cache. */
1873 forall_images_in_image_cache (f
, fn
)
1875 void (*fn
) P_ ((struct image
*img
));
1877 if (FRAME_LIVE_P (f
) && FRAME_WINDOW_P (f
))
1879 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
1883 for (i
= 0; i
< c
->used
; ++i
)
1892 /***********************************************************************
1893 X / MAC / W32 support code
1894 ***********************************************************************/
1898 /* Macro for defining functions that will be loaded from image DLLs. */
1899 #define DEF_IMGLIB_FN(func) int (FAR CDECL *fn_##func)()
1901 /* Macro for loading those image functions from the library. */
1902 #define LOAD_IMGLIB_FN(lib,func) { \
1903 fn_##func = (void *) GetProcAddress (lib, #func); \
1904 if (!fn_##func) return 0; \
1907 /* Load a DLL implementing an image type.
1908 The `image-library-alist' variable associates a symbol,
1909 identifying an image type, to a list of possible filenames.
1910 The function returns NULL if no library could be loaded for
1911 the given image type, or if the library was previously loaded;
1912 else the handle of the DLL. */
1914 w32_delayed_load (Lisp_Object libraries
, Lisp_Object type
)
1916 HMODULE library
= NULL
;
1918 if (CONSP (libraries
) && NILP (Fassq (type
, Vimage_type_cache
)))
1920 Lisp_Object dlls
= Fassq (type
, libraries
);
1923 for (dlls
= XCDR (dlls
); CONSP (dlls
); dlls
= XCDR (dlls
))
1925 CHECK_STRING_CAR (dlls
);
1926 if (library
= LoadLibrary (SDATA (XCAR (dlls
))))
1934 #endif /* HAVE_NTGUI */
1936 static int x_create_x_image_and_pixmap
P_ ((struct frame
*, int, int, int,
1937 XImagePtr
*, Pixmap
*));
1938 static void x_destroy_x_image
P_ ((XImagePtr
));
1939 static void x_put_x_image
P_ ((struct frame
*, XImagePtr
, Pixmap
, int, int));
1942 /* Create an XImage and a pixmap of size WIDTH x HEIGHT for use on
1943 frame F. Set *XIMG and *PIXMAP to the XImage and Pixmap created.
1944 Set (*XIMG)->data to a raster of WIDTH x HEIGHT pixels allocated
1945 via xmalloc. Print error messages via image_error if an error
1946 occurs. Value is non-zero if successful.
1948 On W32, a DEPTH of zero signifies a 24 bit image, otherwise DEPTH
1949 should indicate the bit depth of the image. */
1952 x_create_x_image_and_pixmap (f
, width
, height
, depth
, ximg
, pixmap
)
1954 int width
, height
, depth
;
1958 #ifdef HAVE_X_WINDOWS
1959 Display
*display
= FRAME_X_DISPLAY (f
);
1960 Window window
= FRAME_X_WINDOW (f
);
1961 Screen
*screen
= FRAME_X_SCREEN (f
);
1963 xassert (interrupt_input_blocked
);
1966 depth
= DefaultDepthOfScreen (screen
);
1967 *ximg
= XCreateImage (display
, DefaultVisualOfScreen (screen
),
1968 depth
, ZPixmap
, 0, NULL
, width
, height
,
1969 depth
> 16 ? 32 : depth
> 8 ? 16 : 8, 0);
1972 image_error ("Unable to allocate X image", Qnil
, Qnil
);
1976 /* Allocate image raster. */
1977 (*ximg
)->data
= (char *) xmalloc ((*ximg
)->bytes_per_line
* height
);
1979 /* Allocate a pixmap of the same size. */
1980 *pixmap
= XCreatePixmap (display
, window
, width
, height
, depth
);
1981 if (*pixmap
== NO_PIXMAP
)
1983 x_destroy_x_image (*ximg
);
1985 image_error ("Unable to create X pixmap", Qnil
, Qnil
);
1990 #endif /* HAVE_X_WINDOWS */
1994 BITMAPINFOHEADER
*header
;
1996 int scanline_width_bits
;
1998 int palette_colors
= 0;
2003 if (depth
!= 1 && depth
!= 4 && depth
!= 8
2004 && depth
!= 16 && depth
!= 24 && depth
!= 32)
2006 image_error ("Invalid image bit depth specified", Qnil
, Qnil
);
2010 scanline_width_bits
= width
* depth
;
2011 remainder
= scanline_width_bits
% 32;
2014 scanline_width_bits
+= 32 - remainder
;
2016 /* Bitmaps with a depth less than 16 need a palette. */
2017 /* BITMAPINFO structure already contains the first RGBQUAD. */
2019 palette_colors
= 1 << depth
- 1;
2021 *ximg
= xmalloc (sizeof (XImage
) + palette_colors
* sizeof (RGBQUAD
));
2024 image_error ("Unable to allocate memory for XImage", Qnil
, Qnil
);
2028 header
= &((*ximg
)->info
.bmiHeader
);
2029 bzero (&((*ximg
)->info
), sizeof (BITMAPINFO
));
2030 header
->biSize
= sizeof (*header
);
2031 header
->biWidth
= width
;
2032 header
->biHeight
= -height
; /* negative indicates a top-down bitmap. */
2033 header
->biPlanes
= 1;
2034 header
->biBitCount
= depth
;
2035 header
->biCompression
= BI_RGB
;
2036 header
->biClrUsed
= palette_colors
;
2038 /* TODO: fill in palette. */
2041 (*ximg
)->info
.bmiColors
[0].rgbBlue
= 0;
2042 (*ximg
)->info
.bmiColors
[0].rgbGreen
= 0;
2043 (*ximg
)->info
.bmiColors
[0].rgbRed
= 0;
2044 (*ximg
)->info
.bmiColors
[0].rgbReserved
= 0;
2045 (*ximg
)->info
.bmiColors
[1].rgbBlue
= 255;
2046 (*ximg
)->info
.bmiColors
[1].rgbGreen
= 255;
2047 (*ximg
)->info
.bmiColors
[1].rgbRed
= 255;
2048 (*ximg
)->info
.bmiColors
[1].rgbReserved
= 0;
2051 hdc
= get_frame_dc (f
);
2053 /* Create a DIBSection and raster array for the bitmap,
2054 and store its handle in *pixmap. */
2055 *pixmap
= CreateDIBSection (hdc
, &((*ximg
)->info
),
2056 (depth
< 16) ? DIB_PAL_COLORS
: DIB_RGB_COLORS
,
2057 /* casting avoids a GCC warning */
2058 (void **)&((*ximg
)->data
), NULL
, 0);
2060 /* Realize display palette and garbage all frames. */
2061 release_frame_dc (f
, hdc
);
2063 if (*pixmap
== NULL
)
2065 DWORD err
= GetLastError();
2066 Lisp_Object errcode
;
2067 /* All system errors are < 10000, so the following is safe. */
2068 XSETINT (errcode
, (int) err
);
2069 image_error ("Unable to create bitmap, error code %d", errcode
, Qnil
);
2070 x_destroy_x_image (*ximg
);
2076 #endif /* HAVE_NTGUI */
2079 Display
*display
= FRAME_X_DISPLAY (f
);
2080 Window window
= FRAME_X_WINDOW (f
);
2082 xassert (interrupt_input_blocked
);
2084 /* Allocate a pixmap of the same size. */
2085 *pixmap
= XCreatePixmap (display
, window
, width
, height
, depth
);
2086 if (*pixmap
== NO_PIXMAP
)
2089 image_error ("Unable to create X pixmap", Qnil
, Qnil
);
2093 LockPixels (GetGWorldPixMap (*pixmap
));
2101 /* Destroy XImage XIMG. Free XIMG->data. */
2104 x_destroy_x_image (ximg
)
2107 xassert (interrupt_input_blocked
);
2110 #ifdef HAVE_X_WINDOWS
2113 XDestroyImage (ximg
);
2114 #endif /* HAVE_X_WINDOWS */
2116 /* Data will be freed by DestroyObject. */
2119 #endif /* HAVE_NTGUI */
2121 XDestroyImage (ximg
);
2127 /* Put XImage XIMG into pixmap PIXMAP on frame F. WIDTH and HEIGHT
2128 are width and height of both the image and pixmap. */
2131 x_put_x_image (f
, ximg
, pixmap
, width
, height
)
2137 #ifdef HAVE_X_WINDOWS
2140 xassert (interrupt_input_blocked
);
2141 gc
= XCreateGC (FRAME_X_DISPLAY (f
), pixmap
, 0, NULL
);
2142 XPutImage (FRAME_X_DISPLAY (f
), pixmap
, gc
, ximg
, 0, 0, 0, 0, width
, height
);
2143 XFreeGC (FRAME_X_DISPLAY (f
), gc
);
2144 #endif /* HAVE_X_WINDOWS */
2147 #if 0 /* I don't think this is necessary looking at where it is used. */
2148 HDC hdc
= get_frame_dc (f
);
2149 SetDIBits (hdc
, pixmap
, 0, height
, ximg
->data
, &(ximg
->info
), DIB_RGB_COLORS
);
2150 release_frame_dc (f
, hdc
);
2152 #endif /* HAVE_NTGUI */
2155 xassert (ximg
== pixmap
);
2160 /***********************************************************************
2162 ***********************************************************************/
2164 static unsigned char *slurp_file
P_ ((char *, int *));
2167 /* Find image file FILE. Look in data-directory, then
2168 x-bitmap-file-path. Value is the full name of the file found, or
2169 nil if not found. */
2172 x_find_image_file (file
)
2175 Lisp_Object file_found
, search_path
;
2176 struct gcpro gcpro1
, gcpro2
;
2180 search_path
= Fcons (Vdata_directory
, Vx_bitmap_file_path
);
2181 GCPRO2 (file_found
, search_path
);
2183 /* Try to find FILE in data-directory, then x-bitmap-file-path. */
2184 fd
= openp (search_path
, file
, Qnil
, &file_found
, Qnil
);
2196 /* Read FILE into memory. Value is a pointer to a buffer allocated
2197 with xmalloc holding FILE's contents. Value is null if an error
2198 occurred. *SIZE is set to the size of the file. */
2200 static unsigned char *
2201 slurp_file (file
, size
)
2206 unsigned char *buf
= NULL
;
2209 if (stat (file
, &st
) == 0
2210 && (fp
= fopen (file
, "rb")) != NULL
2211 && (buf
= (unsigned char *) xmalloc (st
.st_size
),
2212 fread (buf
, 1, st
.st_size
, fp
) == st
.st_size
))
2235 /***********************************************************************
2236 MAC Image Load Functions
2237 ***********************************************************************/
2239 static int image_load_quicktime
P_ ((struct frame
*, struct image
*img
,
2242 static int image_load_quartz2d
P_ ((struct frame
*, struct image
*img
, int));
2246 find_image_fsspec (specified_file
, file
, fss
)
2247 Lisp_Object specified_file
, *file
;
2255 *file
= x_find_image_file (specified_file
);
2256 if (!STRINGP (*file
))
2257 return fnfErr
; /* file or directory not found;
2258 incomplete pathname */
2259 /* Try to open the image file. */
2261 err
= FSPathMakeRef (SDATA (*file
), &fsr
, NULL
);
2263 err
= FSGetCatalogInfo (&fsr
, kFSCatInfoNone
, NULL
, NULL
, fss
, NULL
);
2265 err
= posix_pathname_to_fsspec (SDATA (*file
), fss
);
2271 image_load_qt_1 (f
, img
, type
, fss
, dh
)
2279 GraphicsImportComponent gi
;
2282 short draw_all_pixels
;
2283 Lisp_Object specified_bg
;
2288 err
= OpenADefaultComponent (GraphicsImporterComponentType
,
2292 image_error ("Cannot get importer component for `%s'", img
->spec
, Qnil
);
2297 /* read from file system spec */
2298 err
= GraphicsImportSetDataFile (gi
, fss
);
2301 image_error ("Cannot set fsspec to graphics importer for '%s'",
2308 /* read from data handle */
2309 err
= GraphicsImportSetDataHandle (gi
, dh
);
2312 image_error ("Cannot set data handle to graphics importer for `%s'",
2317 err
= GraphicsImportGetNaturalBounds (gi
, &rect
);
2320 image_error ("Error reading `%s'", img
->spec
, Qnil
);
2323 width
= img
->width
= rect
.right
- rect
.left
;
2324 height
= img
->height
= rect
.bottom
- rect
.top
;
2325 err
= GraphicsImportDoesDrawAllPixels (gi
, &draw_all_pixels
);
2327 /* Don't check the error code here. It may have an undocumented
2331 image_error ("Error reading `%s'", img
->spec
, Qnil
);
2335 if (draw_all_pixels
!= graphicsImporterDrawsAllPixels
)
2337 specified_bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
2338 if (!STRINGP (specified_bg
) ||
2339 !mac_defined_color (f
, SDATA (specified_bg
), &color
, 0))
2341 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
2342 color
.red
= RED16_FROM_ULONG (color
.pixel
);
2343 color
.green
= GREEN16_FROM_ULONG (color
.pixel
);
2344 color
.blue
= BLUE16_FROM_ULONG (color
.pixel
);
2348 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
2350 if (draw_all_pixels
!= graphicsImporterDrawsAllPixels
)
2355 GetGWorld (&old_port
, &old_gdh
);
2356 SetGWorld (ximg
, NULL
);
2357 bg_color
.red
= color
.red
;
2358 bg_color
.green
= color
.green
;
2359 bg_color
.blue
= color
.blue
;
2360 RGBBackColor (&bg_color
);
2361 #if TARGET_API_MAC_CARBON
2362 GetPortBounds (ximg
, &rect
);
2365 EraseRect (&(ximg
->portRect
));
2367 SetGWorld (old_port
, old_gdh
);
2369 GraphicsImportSetGWorld (gi
, ximg
, NULL
);
2370 GraphicsImportDraw (gi
);
2371 CloseComponent (gi
);
2373 /* Maybe fill in the background field while we have ximg handy. */
2374 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
2375 IMAGE_BACKGROUND (img
, f
, ximg
);
2377 /* Put the image into the pixmap. */
2378 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
2379 x_destroy_x_image (ximg
);
2383 CloseComponent (gi
);
2388 /* Load an image using the QuickTime Graphics Importer.
2389 Note: The alpha channel does not work for PNG images. */
2391 image_load_quicktime (f
, img
, type
)
2396 Lisp_Object specified_file
;
2397 Lisp_Object specified_data
;
2400 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
2401 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
2403 if (NILP (specified_data
))
2405 /* Read from a file */
2409 err
= find_image_fsspec (specified_file
, &file
, &fss
);
2413 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
2415 image_error ("Cannot open `%s'", file
, Qnil
);
2418 return image_load_qt_1 (f
, img
, type
, &fss
, NULL
);
2422 /* Memory source! */
2426 err
= PtrToHand (SDATA (specified_data
), &dh
, SBYTES (specified_data
));
2429 image_error ("Cannot allocate data handle for `%s'",
2433 success_p
= image_load_qt_1 (f
, img
, type
, NULL
, dh
);
2441 /* Load a PNG/JPEG image using Quartz 2D decoding routines.
2442 CGImageCreateWithPNGDataProvider is provided after Mac OS X 10.2.
2443 So don't use this function directly but determine at runtime
2444 whether it exists. */
2445 typedef CGImageRef (*CGImageCreateWithPNGDataProviderProcType
)
2446 (CGDataProviderRef
, const float [], bool, CGColorRenderingIntent
);
2447 static CGImageCreateWithPNGDataProviderProcType MyCGImageCreateWithPNGDataProvider
;
2451 init_image_func_pointer ()
2453 if (NSIsSymbolNameDefined ("_CGImageCreateWithPNGDataProvider"))
2455 MyCGImageCreateWithPNGDataProvider
2456 = (CGImageCreateWithPNGDataProviderProcType
)
2457 NSAddressOfSymbol (NSLookupAndBindSymbol
2458 ("_CGImageCreateWithPNGDataProvider"));
2461 MyCGImageCreateWithPNGDataProvider
= NULL
;
2466 image_load_quartz2d (f
, img
, png_p
)
2471 Lisp_Object file
, specified_file
;
2472 Lisp_Object specified_data
, specified_bg
;
2473 struct gcpro gcpro1
;
2474 CGDataProviderRef source
;
2478 XImagePtr ximg
= NULL
;
2479 CGContextRef context
;
2482 /* Open the file. */
2483 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
2484 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
2489 if (NILP (specified_data
))
2494 file
= x_find_image_file (specified_file
);
2495 if (!STRINGP (file
))
2497 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
2501 path
= cfstring_create_with_string (file
);
2502 url
= CFURLCreateWithFileSystemPath (NULL
, path
,
2503 kCFURLPOSIXPathStyle
, 0);
2505 source
= CGDataProviderCreateWithURL (url
);
2509 source
= CGDataProviderCreateWithData (NULL
, SDATA (specified_data
),
2510 SBYTES (specified_data
), NULL
);
2513 image
= (*MyCGImageCreateWithPNGDataProvider
) (source
, NULL
, FALSE
,
2514 kCGRenderingIntentDefault
);
2516 image
= CGImageCreateWithJPEGDataProvider (source
, NULL
, FALSE
,
2517 kCGRenderingIntentDefault
);
2519 CGDataProviderRelease (source
);
2523 image_error ("Error reading image `%s'", img
->spec
, Qnil
);
2529 specified_bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
2530 if (!STRINGP (specified_bg
) ||
2531 !mac_defined_color (f
, SDATA (specified_bg
), &color
, 0))
2533 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
2534 color
.red
= RED16_FROM_ULONG (color
.pixel
);
2535 color
.green
= GREEN16_FROM_ULONG (color
.pixel
);
2536 color
.blue
= BLUE16_FROM_ULONG (color
.pixel
);
2539 width
= img
->width
= CGImageGetWidth (image
);
2540 height
= img
->height
= CGImageGetHeight (image
);
2541 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
2543 CGImageRelease (image
);
2547 rectangle
= CGRectMake (0, 0, width
, height
);
2548 QDBeginCGContext (ximg
, &context
);
2551 CGContextSetRGBFillColor (context
, color
.red
/ 65535.0,
2552 color
.green
/ 65535.0,
2553 color
.blue
/ 65535.0, 1.0);
2554 CGContextFillRect (context
, rectangle
);
2556 CGContextDrawImage (context
, rectangle
, image
);
2557 QDEndCGContext (ximg
, &context
);
2558 CGImageRelease (image
);
2560 /* Maybe fill in the background field while we have ximg handy. */
2561 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
2562 IMAGE_BACKGROUND (img
, f
, ximg
);
2564 /* Put the image into the pixmap. */
2565 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
2566 x_destroy_x_image (ximg
);
2575 /***********************************************************************
2577 ***********************************************************************/
2579 static int xbm_scan
P_ ((unsigned char **, unsigned char *, char *, int *));
2580 static int xbm_load
P_ ((struct frame
*f
, struct image
*img
));
2581 static int xbm_load_image
P_ ((struct frame
*f
, struct image
*img
,
2582 unsigned char *, unsigned char *));
2583 static int xbm_image_p
P_ ((Lisp_Object object
));
2584 static int xbm_read_bitmap_data
P_ ((struct frame
*f
,
2585 unsigned char *, unsigned char *,
2586 int *, int *, unsigned char **));
2587 static int xbm_file_p
P_ ((Lisp_Object
));
2590 /* Indices of image specification fields in xbm_format, below. */
2592 enum xbm_keyword_index
2610 /* Vector of image_keyword structures describing the format
2611 of valid XBM image specifications. */
2613 static struct image_keyword xbm_format
[XBM_LAST
] =
2615 {":type", IMAGE_SYMBOL_VALUE
, 1},
2616 {":file", IMAGE_STRING_VALUE
, 0},
2617 {":width", IMAGE_POSITIVE_INTEGER_VALUE
, 0},
2618 {":height", IMAGE_POSITIVE_INTEGER_VALUE
, 0},
2619 {":data", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
2620 {":foreground", IMAGE_STRING_OR_NIL_VALUE
, 0},
2621 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0},
2622 {":ascent", IMAGE_ASCENT_VALUE
, 0},
2623 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
2624 {":relief", IMAGE_INTEGER_VALUE
, 0},
2625 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
2626 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
2627 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0}
2630 /* Structure describing the image type XBM. */
2632 static struct image_type xbm_type
=
2641 /* Tokens returned from xbm_scan. */
2650 /* Return non-zero if OBJECT is a valid XBM-type image specification.
2651 A valid specification is a list starting with the symbol `image'
2652 The rest of the list is a property list which must contain an
2655 If the specification specifies a file to load, it must contain
2656 an entry `:file FILENAME' where FILENAME is a string.
2658 If the specification is for a bitmap loaded from memory it must
2659 contain `:width WIDTH', `:height HEIGHT', and `:data DATA', where
2660 WIDTH and HEIGHT are integers > 0. DATA may be:
2662 1. a string large enough to hold the bitmap data, i.e. it must
2663 have a size >= (WIDTH + 7) / 8 * HEIGHT
2665 2. a bool-vector of size >= WIDTH * HEIGHT
2667 3. a vector of strings or bool-vectors, one for each line of the
2670 4. A string containing an in-memory XBM file. WIDTH and HEIGHT
2671 may not be specified in this case because they are defined in the
2674 Both the file and data forms may contain the additional entries
2675 `:background COLOR' and `:foreground COLOR'. If not present,
2676 foreground and background of the frame on which the image is
2677 displayed is used. */
2680 xbm_image_p (object
)
2683 struct image_keyword kw
[XBM_LAST
];
2685 bcopy (xbm_format
, kw
, sizeof kw
);
2686 if (!parse_image_spec (object
, kw
, XBM_LAST
, Qxbm
))
2689 xassert (EQ (kw
[XBM_TYPE
].value
, Qxbm
));
2691 if (kw
[XBM_FILE
].count
)
2693 if (kw
[XBM_WIDTH
].count
|| kw
[XBM_HEIGHT
].count
|| kw
[XBM_DATA
].count
)
2696 else if (kw
[XBM_DATA
].count
&& xbm_file_p (kw
[XBM_DATA
].value
))
2698 /* In-memory XBM file. */
2699 if (kw
[XBM_WIDTH
].count
|| kw
[XBM_HEIGHT
].count
|| kw
[XBM_FILE
].count
)
2707 /* Entries for `:width', `:height' and `:data' must be present. */
2708 if (!kw
[XBM_WIDTH
].count
2709 || !kw
[XBM_HEIGHT
].count
2710 || !kw
[XBM_DATA
].count
)
2713 data
= kw
[XBM_DATA
].value
;
2714 width
= XFASTINT (kw
[XBM_WIDTH
].value
);
2715 height
= XFASTINT (kw
[XBM_HEIGHT
].value
);
2717 /* Check type of data, and width and height against contents of
2723 /* Number of elements of the vector must be >= height. */
2724 if (XVECTOR (data
)->size
< height
)
2727 /* Each string or bool-vector in data must be large enough
2728 for one line of the image. */
2729 for (i
= 0; i
< height
; ++i
)
2731 Lisp_Object elt
= XVECTOR (data
)->contents
[i
];
2736 < (width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
)
2739 else if (BOOL_VECTOR_P (elt
))
2741 if (XBOOL_VECTOR (elt
)->size
< width
)
2748 else if (STRINGP (data
))
2751 < (width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
* height
)
2754 else if (BOOL_VECTOR_P (data
))
2756 if (XBOOL_VECTOR (data
)->size
< width
* height
)
2767 /* Scan a bitmap file. FP is the stream to read from. Value is
2768 either an enumerator from enum xbm_token, or a character for a
2769 single-character token, or 0 at end of file. If scanning an
2770 identifier, store the lexeme of the identifier in SVAL. If
2771 scanning a number, store its value in *IVAL. */
2774 xbm_scan (s
, end
, sval
, ival
)
2775 unsigned char **s
, *end
;
2783 /* Skip white space. */
2784 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
2789 else if (isdigit (c
))
2791 int value
= 0, digit
;
2793 if (c
== '0' && *s
< end
)
2796 if (c
== 'x' || c
== 'X')
2803 else if (c
>= 'a' && c
<= 'f')
2804 digit
= c
- 'a' + 10;
2805 else if (c
>= 'A' && c
<= 'F')
2806 digit
= c
- 'A' + 10;
2809 value
= 16 * value
+ digit
;
2812 else if (isdigit (c
))
2816 && (c
= *(*s
)++, isdigit (c
)))
2817 value
= 8 * value
+ c
- '0';
2824 && (c
= *(*s
)++, isdigit (c
)))
2825 value
= 10 * value
+ c
- '0';
2833 else if (isalpha (c
) || c
== '_')
2837 && (c
= *(*s
)++, (isalnum (c
) || c
== '_')))
2844 else if (c
== '/' && **s
== '*')
2846 /* C-style comment. */
2848 while (**s
&& (**s
!= '*' || *(*s
+ 1) != '/'))
2862 /* Create a Windows bitmap from X bitmap data. */
2864 w32_create_pixmap_from_bitmap_data (int width
, int height
, char *data
)
2866 static unsigned char swap_nibble
[16]
2867 = { 0x0, 0x8, 0x4, 0xc, /* 0000 1000 0100 1100 */
2868 0x2, 0xa, 0x6, 0xe, /* 0010 1010 0110 1110 */
2869 0x1, 0x9, 0x5, 0xd, /* 0001 1001 0101 1101 */
2870 0x3, 0xb, 0x7, 0xf }; /* 0011 1011 0111 1111 */
2872 unsigned char *bits
, *p
;
2875 w1
= (width
+ 7) / 8; /* nb of 8bits elt in X bitmap */
2876 w2
= ((width
+ 15) / 16) * 2; /* nb of 16bits elt in W32 bitmap */
2877 bits
= (unsigned char *) alloca (height
* w2
);
2878 bzero (bits
, height
* w2
);
2879 for (i
= 0; i
< height
; i
++)
2882 for (j
= 0; j
< w1
; j
++)
2884 /* Bitswap XBM bytes to match how Windows does things. */
2885 unsigned char c
= *data
++;
2886 *p
++ = (unsigned char)((swap_nibble
[c
& 0xf] << 4)
2887 | (swap_nibble
[(c
>>4) & 0xf]));
2890 bmp
= CreateBitmap (width
, height
, 1, 1, (char *) bits
);
2895 static void convert_mono_to_color_image (f
, img
, foreground
, background
)
2898 COLORREF foreground
, background
;
2900 HDC hdc
, old_img_dc
, new_img_dc
;
2901 HGDIOBJ old_prev
, new_prev
;
2904 hdc
= get_frame_dc (f
);
2905 old_img_dc
= CreateCompatibleDC (hdc
);
2906 new_img_dc
= CreateCompatibleDC (hdc
);
2907 new_pixmap
= CreateCompatibleBitmap (hdc
, img
->width
, img
->height
);
2908 release_frame_dc (f
, hdc
);
2909 old_prev
= SelectObject (old_img_dc
, img
->pixmap
);
2910 new_prev
= SelectObject (new_img_dc
, new_pixmap
);
2911 SetTextColor (new_img_dc
, foreground
);
2912 SetBkColor (new_img_dc
, background
);
2914 BitBlt (new_img_dc
, 0, 0, img
->width
, img
->height
, old_img_dc
,
2917 SelectObject (old_img_dc
, old_prev
);
2918 SelectObject (new_img_dc
, new_prev
);
2919 DeleteDC (old_img_dc
);
2920 DeleteDC (new_img_dc
);
2921 DeleteObject (img
->pixmap
);
2922 if (new_pixmap
== 0)
2923 fprintf (stderr
, "Failed to convert image to color.\n");
2925 img
->pixmap
= new_pixmap
;
2928 #define XBM_BIT_SHUFFLE(b) (~(b))
2932 #define XBM_BIT_SHUFFLE(b) (b)
2934 #endif /* HAVE_NTGUI */
2938 Create_Pixmap_From_Bitmap_Data(f
, img
, data
, fg
, bg
, non_default_colors
)
2942 RGB_PIXEL_COLOR fg
, bg
;
2943 int non_default_colors
;
2947 = w32_create_pixmap_from_bitmap_data (img
->width
, img
->height
, data
);
2949 /* If colors were specified, transfer the bitmap to a color one. */
2950 if (non_default_colors
)
2951 convert_mono_to_color_image (f
, img
, fg
, bg
);
2954 = XCreatePixmapFromBitmapData (FRAME_X_DISPLAY (f
),
2957 img
->width
, img
->height
,
2959 DefaultDepthOfScreen (FRAME_X_SCREEN (f
)));
2960 #endif /* HAVE_NTGUI */
2965 /* Replacement for XReadBitmapFileData which isn't available under old
2966 X versions. CONTENTS is a pointer to a buffer to parse; END is the
2967 buffer's end. Set *WIDTH and *HEIGHT to the width and height of
2968 the image. Return in *DATA the bitmap data allocated with xmalloc.
2969 Value is non-zero if successful. DATA null means just test if
2970 CONTENTS looks like an in-memory XBM file. */
2973 xbm_read_bitmap_data (f
, contents
, end
, width
, height
, data
)
2975 unsigned char *contents
, *end
;
2976 int *width
, *height
;
2977 unsigned char **data
;
2979 unsigned char *s
= contents
;
2980 char buffer
[BUFSIZ
];
2983 int bytes_per_line
, i
, nbytes
;
2989 LA1 = xbm_scan (&s, end, buffer, &value)
2991 #define expect(TOKEN) \
2992 if (LA1 != (TOKEN)) \
2997 #define expect_ident(IDENT) \
2998 if (LA1 == XBM_TK_IDENT && strcmp (buffer, (IDENT)) == 0) \
3003 *width
= *height
= -1;
3006 LA1
= xbm_scan (&s
, end
, buffer
, &value
);
3008 /* Parse defines for width, height and hot-spots. */
3012 expect_ident ("define");
3013 expect (XBM_TK_IDENT
);
3015 if (LA1
== XBM_TK_NUMBER
);
3017 char *p
= strrchr (buffer
, '_');
3018 p
= p
? p
+ 1 : buffer
;
3019 if (strcmp (p
, "width") == 0)
3021 else if (strcmp (p
, "height") == 0)
3024 expect (XBM_TK_NUMBER
);
3027 if (!check_image_size (f
, *width
, *height
))
3029 else if (data
== NULL
)
3032 /* Parse bits. Must start with `static'. */
3033 expect_ident ("static");
3034 if (LA1
== XBM_TK_IDENT
)
3036 if (strcmp (buffer
, "unsigned") == 0)
3039 expect_ident ("char");
3041 else if (strcmp (buffer
, "short") == 0)
3045 if (*width
% 16 && *width
% 16 < 9)
3048 else if (strcmp (buffer
, "char") == 0)
3056 expect (XBM_TK_IDENT
);
3062 bytes_per_line
= (*width
+ 7) / 8 + padding_p
;
3063 nbytes
= bytes_per_line
* *height
;
3064 p
= *data
= (unsigned char *) xmalloc (nbytes
);
3068 for (i
= 0; i
< nbytes
; i
+= 2)
3071 expect (XBM_TK_NUMBER
);
3073 *p
++ = XBM_BIT_SHUFFLE (val
);
3074 if (!padding_p
|| ((i
+ 2) % bytes_per_line
))
3075 *p
++ = XBM_BIT_SHUFFLE (value
>> 8);
3077 if (LA1
== ',' || LA1
== '}')
3085 for (i
= 0; i
< nbytes
; ++i
)
3088 expect (XBM_TK_NUMBER
);
3090 *p
++ = XBM_BIT_SHUFFLE (val
);
3092 if (LA1
== ',' || LA1
== '}')
3117 /* Load XBM image IMG which will be displayed on frame F from buffer
3118 CONTENTS. END is the end of the buffer. Value is non-zero if
3122 xbm_load_image (f
, img
, contents
, end
)
3125 unsigned char *contents
, *end
;
3128 unsigned char *data
;
3131 rc
= xbm_read_bitmap_data (f
, contents
, end
, &img
->width
, &img
->height
, &data
);
3134 unsigned long foreground
= FRAME_FOREGROUND_PIXEL (f
);
3135 unsigned long background
= FRAME_BACKGROUND_PIXEL (f
);
3136 int non_default_colors
= 0;
3139 xassert (img
->width
> 0 && img
->height
> 0);
3141 /* Get foreground and background colors, maybe allocate colors. */
3142 value
= image_spec_value (img
->spec
, QCforeground
, NULL
);
3145 foreground
= x_alloc_image_color (f
, img
, value
, foreground
);
3146 non_default_colors
= 1;
3148 value
= image_spec_value (img
->spec
, QCbackground
, NULL
);
3151 background
= x_alloc_image_color (f
, img
, value
, background
);
3152 img
->background
= background
;
3153 img
->background_valid
= 1;
3154 non_default_colors
= 1;
3157 Create_Pixmap_From_Bitmap_Data (f
, img
, data
,
3158 foreground
, background
,
3159 non_default_colors
);
3162 if (img
->pixmap
== NO_PIXMAP
)
3164 x_clear_image (f
, img
);
3165 image_error ("Unable to create X pixmap for `%s'", img
->spec
, Qnil
);
3171 image_error ("Error loading XBM image `%s'", img
->spec
, Qnil
);
3177 /* Value is non-zero if DATA looks like an in-memory XBM file. */
3184 return (STRINGP (data
)
3185 && xbm_read_bitmap_data (NULL
, SDATA (data
),
3192 /* Fill image IMG which is used on frame F with pixmap data. Value is
3193 non-zero if successful. */
3201 Lisp_Object file_name
;
3203 xassert (xbm_image_p (img
->spec
));
3205 /* If IMG->spec specifies a file name, create a non-file spec from it. */
3206 file_name
= image_spec_value (img
->spec
, QCfile
, NULL
);
3207 if (STRINGP (file_name
))
3210 unsigned char *contents
;
3212 struct gcpro gcpro1
;
3214 file
= x_find_image_file (file_name
);
3216 if (!STRINGP (file
))
3218 image_error ("Cannot find image file `%s'", file_name
, Qnil
);
3223 contents
= slurp_file (SDATA (file
), &size
);
3224 if (contents
== NULL
)
3226 image_error ("Error loading XBM image `%s'", img
->spec
, Qnil
);
3231 success_p
= xbm_load_image (f
, img
, contents
, contents
+ size
);
3236 struct image_keyword fmt
[XBM_LAST
];
3238 unsigned long foreground
= FRAME_FOREGROUND_PIXEL (f
);
3239 unsigned long background
= FRAME_BACKGROUND_PIXEL (f
);
3240 int non_default_colors
= 0;
3243 int in_memory_file_p
= 0;
3245 /* See if data looks like an in-memory XBM file. */
3246 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
3247 in_memory_file_p
= xbm_file_p (data
);
3249 /* Parse the image specification. */
3250 bcopy (xbm_format
, fmt
, sizeof fmt
);
3251 parsed_p
= parse_image_spec (img
->spec
, fmt
, XBM_LAST
, Qxbm
);
3254 /* Get specified width, and height. */
3255 if (!in_memory_file_p
)
3257 img
->width
= XFASTINT (fmt
[XBM_WIDTH
].value
);
3258 img
->height
= XFASTINT (fmt
[XBM_HEIGHT
].value
);
3259 xassert (img
->width
> 0 && img
->height
> 0);
3262 /* Get foreground and background colors, maybe allocate colors. */
3263 if (fmt
[XBM_FOREGROUND
].count
3264 && STRINGP (fmt
[XBM_FOREGROUND
].value
))
3266 foreground
= x_alloc_image_color (f
, img
, fmt
[XBM_FOREGROUND
].value
,
3268 non_default_colors
= 1;
3271 if (fmt
[XBM_BACKGROUND
].count
3272 && STRINGP (fmt
[XBM_BACKGROUND
].value
))
3274 background
= x_alloc_image_color (f
, img
, fmt
[XBM_BACKGROUND
].value
,
3276 non_default_colors
= 1;
3279 if (in_memory_file_p
)
3280 success_p
= xbm_load_image (f
, img
, SDATA (data
),
3289 int nbytes
= (img
->width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
;
3291 p
= bits
= (char *) alloca (nbytes
* img
->height
);
3292 for (i
= 0; i
< img
->height
; ++i
, p
+= nbytes
)
3294 Lisp_Object line
= XVECTOR (data
)->contents
[i
];
3296 bcopy (SDATA (line
), p
, nbytes
);
3298 bcopy (XBOOL_VECTOR (line
)->data
, p
, nbytes
);
3301 else if (STRINGP (data
))
3302 bits
= SDATA (data
);
3304 bits
= XBOOL_VECTOR (data
)->data
;
3306 /* Create the pixmap. */
3308 Create_Pixmap_From_Bitmap_Data (f
, img
, bits
,
3309 foreground
, background
,
3310 non_default_colors
);
3315 image_error ("Unable to create pixmap for XBM image `%s'",
3317 x_clear_image (f
, img
);
3327 /***********************************************************************
3329 ***********************************************************************/
3331 #if defined (HAVE_XPM) || defined (MAC_OS)
3333 static int xpm_image_p
P_ ((Lisp_Object object
));
3334 static int xpm_load
P_ ((struct frame
*f
, struct image
*img
));
3335 static int xpm_valid_color_symbols_p
P_ ((Lisp_Object
));
3337 #endif /* HAVE_XPM || MAC_OS */
3341 /* Indicate to xpm.h that we don't have Xlib. */
3343 /* simx.h in xpm defines XColor and XImage differently than Emacs. */
3344 /* It also defines Display the same way as Emacs, but gcc 3.3 still barfs. */
3345 #define XColor xpm_XColor
3346 #define XImage xpm_XImage
3347 #define Display xpm_Display
3348 #define PIXEL_ALREADY_TYPEDEFED
3349 #include "X11/xpm.h"
3354 #undef PIXEL_ALREADY_TYPEDEFED
3356 #include "X11/xpm.h"
3357 #endif /* HAVE_NTGUI */
3358 #endif /* HAVE_XPM */
3360 #if defined (HAVE_XPM) || defined (MAC_OS)
3361 /* The symbol `xpm' identifying XPM-format images. */
3365 /* Indices of image specification fields in xpm_format, below. */
3367 enum xpm_keyword_index
3383 /* Vector of image_keyword structures describing the format
3384 of valid XPM image specifications. */
3386 static struct image_keyword xpm_format
[XPM_LAST
] =
3388 {":type", IMAGE_SYMBOL_VALUE
, 1},
3389 {":file", IMAGE_STRING_VALUE
, 0},
3390 {":data", IMAGE_STRING_VALUE
, 0},
3391 {":ascent", IMAGE_ASCENT_VALUE
, 0},
3392 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
3393 {":relief", IMAGE_INTEGER_VALUE
, 0},
3394 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3395 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3396 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3397 {":color-symbols", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3398 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
3401 /* Structure describing the image type XPM. */
3403 static struct image_type xpm_type
=
3412 #ifdef HAVE_X_WINDOWS
3414 /* Define ALLOC_XPM_COLORS if we can use Emacs' own color allocation
3415 functions for allocating image colors. Our own functions handle
3416 color allocation failures more gracefully than the ones on the XPM
3419 #if defined XpmAllocColor && defined XpmFreeColors && defined XpmColorClosure
3420 #define ALLOC_XPM_COLORS
3422 #endif /* HAVE_X_WINDOWS */
3424 #ifdef ALLOC_XPM_COLORS
3426 static void xpm_init_color_cache
P_ ((struct frame
*, XpmAttributes
*));
3427 static void xpm_free_color_cache
P_ ((void));
3428 static int xpm_lookup_color
P_ ((struct frame
*, char *, XColor
*));
3429 static int xpm_color_bucket
P_ ((char *));
3430 static struct xpm_cached_color
*xpm_cache_color
P_ ((struct frame
*, char *,
3433 /* An entry in a hash table used to cache color definitions of named
3434 colors. This cache is necessary to speed up XPM image loading in
3435 case we do color allocations ourselves. Without it, we would need
3436 a call to XParseColor per pixel in the image. */
3438 struct xpm_cached_color
3440 /* Next in collision chain. */
3441 struct xpm_cached_color
*next
;
3443 /* Color definition (RGB and pixel color). */
3450 /* The hash table used for the color cache, and its bucket vector
3453 #define XPM_COLOR_CACHE_BUCKETS 1001
3454 struct xpm_cached_color
**xpm_color_cache
;
3456 /* Initialize the color cache. */
3459 xpm_init_color_cache (f
, attrs
)
3461 XpmAttributes
*attrs
;
3463 size_t nbytes
= XPM_COLOR_CACHE_BUCKETS
* sizeof *xpm_color_cache
;
3464 xpm_color_cache
= (struct xpm_cached_color
**) xmalloc (nbytes
);
3465 memset (xpm_color_cache
, 0, nbytes
);
3466 init_color_table ();
3468 if (attrs
->valuemask
& XpmColorSymbols
)
3473 for (i
= 0; i
< attrs
->numsymbols
; ++i
)
3474 if (XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
3475 attrs
->colorsymbols
[i
].value
, &color
))
3477 color
.pixel
= lookup_rgb_color (f
, color
.red
, color
.green
,
3479 xpm_cache_color (f
, attrs
->colorsymbols
[i
].name
, &color
, -1);
3484 /* Free the color cache. */
3487 xpm_free_color_cache ()
3489 struct xpm_cached_color
*p
, *next
;
3492 for (i
= 0; i
< XPM_COLOR_CACHE_BUCKETS
; ++i
)
3493 for (p
= xpm_color_cache
[i
]; p
; p
= next
)
3499 xfree (xpm_color_cache
);
3500 xpm_color_cache
= NULL
;
3501 free_color_table ();
3504 /* Return the bucket index for color named COLOR_NAME in the color
3508 xpm_color_bucket (color_name
)
3514 for (s
= color_name
; *s
; ++s
)
3516 return h
%= XPM_COLOR_CACHE_BUCKETS
;
3520 /* On frame F, cache values COLOR for color with name COLOR_NAME.
3521 BUCKET, if >= 0, is a precomputed bucket index. Value is the cache
3524 static struct xpm_cached_color
*
3525 xpm_cache_color (f
, color_name
, color
, bucket
)
3532 struct xpm_cached_color
*p
;
3535 bucket
= xpm_color_bucket (color_name
);
3537 nbytes
= sizeof *p
+ strlen (color_name
);
3538 p
= (struct xpm_cached_color
*) xmalloc (nbytes
);
3539 strcpy (p
->name
, color_name
);
3541 p
->next
= xpm_color_cache
[bucket
];
3542 xpm_color_cache
[bucket
] = p
;
3546 /* Look up color COLOR_NAME for frame F in the color cache. If found,
3547 return the cached definition in *COLOR. Otherwise, make a new
3548 entry in the cache and allocate the color. Value is zero if color
3549 allocation failed. */
3552 xpm_lookup_color (f
, color_name
, color
)
3557 struct xpm_cached_color
*p
;
3558 int h
= xpm_color_bucket (color_name
);
3560 for (p
= xpm_color_cache
[h
]; p
; p
= p
->next
)
3561 if (strcmp (p
->name
, color_name
) == 0)
3566 else if (XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
3569 color
->pixel
= lookup_rgb_color (f
, color
->red
, color
->green
,
3571 p
= xpm_cache_color (f
, color_name
, color
, h
);
3573 /* You get `opaque' at least from ImageMagick converting pbm to xpm
3574 with transparency, and it's useful. */
3575 else if (strcmp ("opaque", color_name
) == 0)
3577 bzero (color
, sizeof (XColor
)); /* Is this necessary/correct? */
3578 color
->pixel
= FRAME_FOREGROUND_PIXEL (f
);
3579 p
= xpm_cache_color (f
, color_name
, color
, h
);
3586 /* Callback for allocating color COLOR_NAME. Called from the XPM lib.
3587 CLOSURE is a pointer to the frame on which we allocate the
3588 color. Return in *COLOR the allocated color. Value is non-zero
3592 xpm_alloc_color (dpy
, cmap
, color_name
, color
, closure
)
3599 return xpm_lookup_color ((struct frame
*) closure
, color_name
, color
);
3603 /* Callback for freeing NPIXELS colors contained in PIXELS. CLOSURE
3604 is a pointer to the frame on which we allocate the color. Value is
3605 non-zero if successful. */
3608 xpm_free_colors (dpy
, cmap
, pixels
, npixels
, closure
)
3618 #endif /* ALLOC_XPM_COLORS */
3623 /* XPM library details. */
3625 DEF_IMGLIB_FN (XpmFreeAttributes
);
3626 DEF_IMGLIB_FN (XpmCreateImageFromBuffer
);
3627 DEF_IMGLIB_FN (XpmReadFileToImage
);
3628 DEF_IMGLIB_FN (XImageFree
);
3631 init_xpm_functions (Lisp_Object libraries
)
3635 if (!(library
= w32_delayed_load (libraries
, Qxpm
)))
3638 LOAD_IMGLIB_FN (library
, XpmFreeAttributes
);
3639 LOAD_IMGLIB_FN (library
, XpmCreateImageFromBuffer
);
3640 LOAD_IMGLIB_FN (library
, XpmReadFileToImage
);
3641 LOAD_IMGLIB_FN (library
, XImageFree
);
3645 #endif /* HAVE_NTGUI */
3648 /* Value is non-zero if COLOR_SYMBOLS is a valid color symbols list
3649 for XPM images. Such a list must consist of conses whose car and
3653 xpm_valid_color_symbols_p (color_symbols
)
3654 Lisp_Object color_symbols
;
3656 while (CONSP (color_symbols
))
3658 Lisp_Object sym
= XCAR (color_symbols
);
3660 || !STRINGP (XCAR (sym
))
3661 || !STRINGP (XCDR (sym
)))
3663 color_symbols
= XCDR (color_symbols
);
3666 return NILP (color_symbols
);
3670 /* Value is non-zero if OBJECT is a valid XPM image specification. */
3673 xpm_image_p (object
)
3676 struct image_keyword fmt
[XPM_LAST
];
3677 bcopy (xpm_format
, fmt
, sizeof fmt
);
3678 return (parse_image_spec (object
, fmt
, XPM_LAST
, Qxpm
)
3679 /* Either `:file' or `:data' must be present. */
3680 && fmt
[XPM_FILE
].count
+ fmt
[XPM_DATA
].count
== 1
3681 /* Either no `:color-symbols' or it's a list of conses
3682 whose car and cdr are strings. */
3683 && (fmt
[XPM_COLOR_SYMBOLS
].count
== 0
3684 || xpm_valid_color_symbols_p (fmt
[XPM_COLOR_SYMBOLS
].value
)));
3687 #endif /* HAVE_XPM || MAC_OS */
3689 /* Load image IMG which will be displayed on frame F. Value is
3690 non-zero if successful. */
3700 XpmAttributes attrs
;
3701 Lisp_Object specified_file
, color_symbols
;
3704 xpm_XImage
* xpm_image
= NULL
, * xpm_mask
= NULL
;
3705 #endif /* HAVE_NTGUI */
3707 /* Configure the XPM lib. Use the visual of frame F. Allocate
3708 close colors. Return colors allocated. */
3709 bzero (&attrs
, sizeof attrs
);
3712 attrs
.visual
= FRAME_X_VISUAL (f
);
3713 attrs
.colormap
= FRAME_X_COLORMAP (f
);
3714 attrs
.valuemask
|= XpmVisual
;
3715 attrs
.valuemask
|= XpmColormap
;
3716 #endif /* HAVE_NTGUI */
3718 #ifdef ALLOC_XPM_COLORS
3719 /* Allocate colors with our own functions which handle
3720 failing color allocation more gracefully. */
3721 attrs
.color_closure
= f
;
3722 attrs
.alloc_color
= xpm_alloc_color
;
3723 attrs
.free_colors
= xpm_free_colors
;
3724 attrs
.valuemask
|= XpmAllocColor
| XpmFreeColors
| XpmColorClosure
;
3725 #else /* not ALLOC_XPM_COLORS */
3726 /* Let the XPM lib allocate colors. */
3727 attrs
.valuemask
|= XpmReturnAllocPixels
;
3728 #ifdef XpmAllocCloseColors
3729 attrs
.alloc_close_colors
= 1;
3730 attrs
.valuemask
|= XpmAllocCloseColors
;
3731 #else /* not XpmAllocCloseColors */
3732 attrs
.closeness
= 600;
3733 attrs
.valuemask
|= XpmCloseness
;
3734 #endif /* not XpmAllocCloseColors */
3735 #endif /* ALLOC_XPM_COLORS */
3737 /* If image specification contains symbolic color definitions, add
3738 these to `attrs'. */
3739 color_symbols
= image_spec_value (img
->spec
, QCcolor_symbols
, NULL
);
3740 if (CONSP (color_symbols
))
3743 XpmColorSymbol
*xpm_syms
;
3746 attrs
.valuemask
|= XpmColorSymbols
;
3748 /* Count number of symbols. */
3749 attrs
.numsymbols
= 0;
3750 for (tail
= color_symbols
; CONSP (tail
); tail
= XCDR (tail
))
3753 /* Allocate an XpmColorSymbol array. */
3754 size
= attrs
.numsymbols
* sizeof *xpm_syms
;
3755 xpm_syms
= (XpmColorSymbol
*) alloca (size
);
3756 bzero (xpm_syms
, size
);
3757 attrs
.colorsymbols
= xpm_syms
;
3759 /* Fill the color symbol array. */
3760 for (tail
= color_symbols
, i
= 0;
3762 ++i
, tail
= XCDR (tail
))
3764 Lisp_Object name
= XCAR (XCAR (tail
));
3765 Lisp_Object color
= XCDR (XCAR (tail
));
3766 xpm_syms
[i
].name
= (char *) alloca (SCHARS (name
) + 1);
3767 strcpy (xpm_syms
[i
].name
, SDATA (name
));
3768 xpm_syms
[i
].value
= (char *) alloca (SCHARS (color
) + 1);
3769 strcpy (xpm_syms
[i
].value
, SDATA (color
));
3773 /* Create a pixmap for the image, either from a file, or from a
3774 string buffer containing data in the same format as an XPM file. */
3775 #ifdef ALLOC_XPM_COLORS
3776 xpm_init_color_cache (f
, &attrs
);
3779 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
3783 HDC frame_dc
= get_frame_dc (f
);
3784 hdc
= CreateCompatibleDC (frame_dc
);
3785 release_frame_dc (f
, frame_dc
);
3787 #endif /* HAVE_NTGUI */
3789 if (STRINGP (specified_file
))
3791 Lisp_Object file
= x_find_image_file (specified_file
);
3792 if (!STRINGP (file
))
3794 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
3799 /* XpmReadFileToPixmap is not available in the Windows port of
3800 libxpm. But XpmReadFileToImage almost does what we want. */
3801 rc
= fn_XpmReadFileToImage (&hdc
, SDATA (file
),
3802 &xpm_image
, &xpm_mask
,
3805 rc
= XpmReadFileToPixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3806 SDATA (file
), &img
->pixmap
, &img
->mask
,
3808 #endif /* HAVE_NTGUI */
3812 Lisp_Object buffer
= image_spec_value (img
->spec
, QCdata
, NULL
);
3814 /* XpmCreatePixmapFromBuffer is not available in the Windows port
3815 of libxpm. But XpmCreateImageFromBuffer almost does what we want. */
3816 rc
= fn_XpmCreateImageFromBuffer (&hdc
, SDATA (buffer
),
3817 &xpm_image
, &xpm_mask
,
3820 rc
= XpmCreatePixmapFromBuffer (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3822 &img
->pixmap
, &img
->mask
,
3824 #endif /* HAVE_NTGUI */
3827 if (rc
== XpmSuccess
)
3829 #if defined (COLOR_TABLE_SUPPORT) && defined (ALLOC_XPM_COLORS)
3830 img
->colors
= colors_in_color_table (&img
->ncolors
);
3831 #else /* not ALLOC_XPM_COLORS */
3835 /* W32 XPM uses XImage to wrap what W32 Emacs calls a Pixmap,
3836 plus some duplicate attributes. */
3837 if (xpm_image
&& xpm_image
->bitmap
)
3839 img
->pixmap
= xpm_image
->bitmap
;
3840 /* XImageFree in libXpm frees XImage struct without destroying
3841 the bitmap, which is what we want. */
3842 fn_XImageFree (xpm_image
);
3844 if (xpm_mask
&& xpm_mask
->bitmap
)
3846 /* The mask appears to be inverted compared with what we expect.
3847 TODO: invert our expectations. See other places where we
3848 have to invert bits because our idea of masks is backwards. */
3850 old_obj
= SelectObject (hdc
, xpm_mask
->bitmap
);
3852 PatBlt (hdc
, 0, 0, xpm_mask
->width
, xpm_mask
->height
, DSTINVERT
);
3853 SelectObject (hdc
, old_obj
);
3855 img
->mask
= xpm_mask
->bitmap
;
3856 fn_XImageFree (xpm_mask
);
3861 #endif /* HAVE_NTGUI */
3863 /* Remember allocated colors. */
3864 img
->ncolors
= attrs
.nalloc_pixels
;
3865 img
->colors
= (unsigned long *) xmalloc (img
->ncolors
3866 * sizeof *img
->colors
);
3867 for (i
= 0; i
< attrs
.nalloc_pixels
; ++i
)
3869 img
->colors
[i
] = attrs
.alloc_pixels
[i
];
3870 #ifdef DEBUG_X_COLORS
3871 register_color (img
->colors
[i
]);
3874 #endif /* not ALLOC_XPM_COLORS */
3876 img
->width
= attrs
.width
;
3877 img
->height
= attrs
.height
;
3878 xassert (img
->width
> 0 && img
->height
> 0);
3880 /* The call to XpmFreeAttributes below frees attrs.alloc_pixels. */
3882 fn_XpmFreeAttributes (&attrs
);
3884 XpmFreeAttributes (&attrs
);
3885 #endif /* HAVE_NTGUI */
3891 #endif /* HAVE_NTGUI */
3896 image_error ("Error opening XPM file (%s)", img
->spec
, Qnil
);
3899 case XpmFileInvalid
:
3900 image_error ("Invalid XPM file (%s)", img
->spec
, Qnil
);
3904 image_error ("Out of memory (%s)", img
->spec
, Qnil
);
3907 case XpmColorFailed
:
3908 image_error ("Color allocation error (%s)", img
->spec
, Qnil
);
3912 image_error ("Unknown error (%s)", img
->spec
, Qnil
);
3917 #ifdef ALLOC_XPM_COLORS
3918 xpm_free_color_cache ();
3920 return rc
== XpmSuccess
;
3923 #endif /* HAVE_XPM */
3927 /* XPM support functions for Mac OS where libxpm is not available.
3928 Only XPM version 3 (without any extensions) is supported. */
3930 static int xpm_scan
P_ ((unsigned char **, unsigned char *,
3931 unsigned char **, int *));
3932 static Lisp_Object xpm_make_color_table_v
3933 P_ ((void (**) (Lisp_Object
, unsigned char *, int, Lisp_Object
),
3934 Lisp_Object (**) (Lisp_Object
, unsigned char *, int)));
3935 static void xpm_put_color_table_v
P_ ((Lisp_Object
, unsigned char *,
3937 static Lisp_Object xpm_get_color_table_v
P_ ((Lisp_Object
,
3938 unsigned char *, int));
3939 static Lisp_Object xpm_make_color_table_h
3940 P_ ((void (**) (Lisp_Object
, unsigned char *, int, Lisp_Object
),
3941 Lisp_Object (**) (Lisp_Object
, unsigned char *, int)));
3942 static void xpm_put_color_table_h
P_ ((Lisp_Object
, unsigned char *,
3944 static Lisp_Object xpm_get_color_table_h
P_ ((Lisp_Object
,
3945 unsigned char *, int));
3946 static int xpm_str_to_color_key
P_ ((char *));
3947 static int xpm_load_image
P_ ((struct frame
*, struct image
*,
3948 unsigned char *, unsigned char *));
3950 /* Tokens returned from xpm_scan. */
3959 /* Scan an XPM data and return a character (< 256) or a token defined
3960 by enum xpm_token above. *S and END are the start (inclusive) and
3961 the end (exclusive) addresses of the data, respectively. Advance
3962 *S while scanning. If token is either XPM_TK_IDENT or
3963 XPM_TK_STRING, *BEG and *LEN are set to the start address and the
3964 length of the corresponding token, respectively. */
3967 xpm_scan (s
, end
, beg
, len
)
3968 unsigned char **s
, *end
, **beg
;
3975 /* Skip white-space. */
3976 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
3979 /* gnus-pointer.xpm uses '-' in its identifier.
3980 sb-dir-plus.xpm uses '+' in its identifier. */
3981 if (isalpha (c
) || c
== '_' || c
== '-' || c
== '+')
3985 (c
= **s
, isalnum (c
) || c
== '_' || c
== '-' || c
== '+'))
3988 return XPM_TK_IDENT
;
3993 while (*s
< end
&& **s
!= '"')
3998 return XPM_TK_STRING
;
4002 if (*s
< end
&& **s
== '*')
4004 /* C-style comment. */
4008 while (*s
< end
&& *(*s
)++ != '*')
4011 while (*s
< end
&& **s
!= '/');
4025 /* Functions for color table lookup in XPM data. A Key is a string
4026 specifying the color of each pixel in XPM data. A value is either
4027 an integer that specifies a pixel color, Qt that specifies
4028 transparency, or Qnil for the unspecified color. If the length of
4029 the key string is one, a vector is used as a table. Otherwise, a
4030 hash table is used. */
4033 xpm_make_color_table_v (put_func
, get_func
)
4034 void (**put_func
) (Lisp_Object
, unsigned char *, int, Lisp_Object
);
4035 Lisp_Object (**get_func
) (Lisp_Object
, unsigned char *, int);
4037 *put_func
= xpm_put_color_table_v
;
4038 *get_func
= xpm_get_color_table_v
;
4039 return Fmake_vector (make_number (256), Qnil
);
4043 xpm_put_color_table_v (color_table
, chars_start
, chars_len
, color
)
4044 Lisp_Object color_table
;
4045 unsigned char *chars_start
;
4049 XVECTOR (color_table
)->contents
[*chars_start
] = color
;
4053 xpm_get_color_table_v (color_table
, chars_start
, chars_len
)
4054 Lisp_Object color_table
;
4055 unsigned char *chars_start
;
4058 return XVECTOR (color_table
)->contents
[*chars_start
];
4062 xpm_make_color_table_h (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_h
;
4067 *get_func
= xpm_get_color_table_h
;
4068 return make_hash_table (Qequal
, make_number (DEFAULT_HASH_SIZE
),
4069 make_float (DEFAULT_REHASH_SIZE
),
4070 make_float (DEFAULT_REHASH_THRESHOLD
),
4075 xpm_put_color_table_h (color_table
, chars_start
, chars_len
, color
)
4076 Lisp_Object color_table
;
4077 unsigned char *chars_start
;
4081 struct Lisp_Hash_Table
*table
= XHASH_TABLE (color_table
);
4083 Lisp_Object chars
= make_unibyte_string (chars_start
, chars_len
);
4085 hash_lookup (table
, chars
, &hash_code
);
4086 hash_put (table
, chars
, color
, hash_code
);
4090 xpm_get_color_table_h (color_table
, chars_start
, chars_len
)
4091 Lisp_Object color_table
;
4092 unsigned char *chars_start
;
4095 struct Lisp_Hash_Table
*table
= XHASH_TABLE (color_table
);
4096 int i
= hash_lookup (table
, make_unibyte_string (chars_start
, chars_len
),
4099 return i
>= 0 ? HASH_VALUE (table
, i
) : Qnil
;
4102 enum xpm_color_key
{
4110 static char xpm_color_key_strings
[][4] = {"s", "m", "g4", "g", "c"};
4113 xpm_str_to_color_key (s
)
4119 i
< sizeof xpm_color_key_strings
/ sizeof xpm_color_key_strings
[0];
4121 if (strcmp (xpm_color_key_strings
[i
], s
) == 0)
4127 xpm_load_image (f
, img
, contents
, end
)
4130 unsigned char *contents
, *end
;
4132 unsigned char *s
= contents
, *beg
, *str
;
4133 unsigned char buffer
[BUFSIZ
];
4134 int width
, height
, x
, y
;
4135 int num_colors
, chars_per_pixel
;
4137 void (*put_color_table
) (Lisp_Object
, unsigned char *, int, Lisp_Object
);
4138 Lisp_Object (*get_color_table
) (Lisp_Object
, unsigned char *, int);
4139 Lisp_Object frame
, color_symbols
, color_table
;
4140 int best_key
, have_mask
= 0;
4141 XImagePtr ximg
= NULL
, mask_img
= NULL
;
4144 LA1 = xpm_scan (&s, end, &beg, &len)
4146 #define expect(TOKEN) \
4147 if (LA1 != (TOKEN)) \
4152 #define expect_ident(IDENT) \
4153 if (LA1 == XPM_TK_IDENT \
4154 && strlen ((IDENT)) == len && memcmp ((IDENT), beg, len) == 0) \
4159 if (!(end
- s
>= 9 && memcmp (s
, "/* XPM */", 9) == 0))
4163 expect_ident ("static");
4164 expect_ident ("char");
4166 expect (XPM_TK_IDENT
);
4171 expect (XPM_TK_STRING
);
4174 memcpy (buffer
, beg
, len
);
4176 if (sscanf (buffer
, "%d %d %d %d", &width
, &height
,
4177 &num_colors
, &chars_per_pixel
) != 4
4178 || width
<= 0 || height
<= 0
4179 || num_colors
<= 0 || chars_per_pixel
<= 0)
4183 XSETFRAME (frame
, f
);
4184 if (!NILP (Fxw_display_color_p (frame
)))
4185 best_key
= XPM_COLOR_KEY_C
;
4186 else if (!NILP (Fx_display_grayscale_p (frame
)))
4187 best_key
= (XFASTINT (Fx_display_planes (frame
)) > 2
4188 ? XPM_COLOR_KEY_G
: XPM_COLOR_KEY_G4
);
4190 best_key
= XPM_COLOR_KEY_M
;
4192 color_symbols
= image_spec_value (img
->spec
, QCcolor_symbols
, NULL
);
4193 if (chars_per_pixel
== 1)
4194 color_table
= xpm_make_color_table_v (&put_color_table
,
4197 color_table
= xpm_make_color_table_h (&put_color_table
,
4200 while (num_colors
-- > 0)
4202 unsigned char *color
, *max_color
;
4203 int key
, next_key
, max_key
= 0;
4204 Lisp_Object symbol_color
= Qnil
, color_val
;
4207 expect (XPM_TK_STRING
);
4208 if (len
<= chars_per_pixel
|| len
>= BUFSIZ
+ chars_per_pixel
)
4210 memcpy (buffer
, beg
+ chars_per_pixel
, len
- chars_per_pixel
);
4211 buffer
[len
- chars_per_pixel
] = '\0';
4213 str
= strtok (buffer
, " \t");
4216 key
= xpm_str_to_color_key (str
);
4221 color
= strtok (NULL
, " \t");
4225 while (str
= strtok (NULL
, " \t"))
4227 next_key
= xpm_str_to_color_key (str
);
4230 color
[strlen (color
)] = ' ';
4233 if (key
== XPM_COLOR_KEY_S
)
4235 if (NILP (symbol_color
))
4236 symbol_color
= build_string (color
);
4238 else if (max_key
< key
&& key
<= best_key
)
4248 if (!NILP (color_symbols
) && !NILP (symbol_color
))
4250 Lisp_Object specified_color
= Fassoc (symbol_color
, color_symbols
);
4252 if (CONSP (specified_color
) && STRINGP (XCDR (specified_color
)))
4253 if (xstricmp (SDATA (XCDR (specified_color
)), "None") == 0)
4255 else if (x_defined_color (f
, SDATA (XCDR (specified_color
)),
4257 color_val
= make_number (cdef
.pixel
);
4259 if (NILP (color_val
) && max_key
> 0)
4260 if (xstricmp (max_color
, "None") == 0)
4262 else if (x_defined_color (f
, max_color
, &cdef
, 0))
4263 color_val
= make_number (cdef
.pixel
);
4264 if (!NILP (color_val
))
4265 (*put_color_table
) (color_table
, beg
, chars_per_pixel
, color_val
);
4270 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0,
4271 &ximg
, &img
->pixmap
)
4272 || !x_create_x_image_and_pixmap (f
, width
, height
, 1,
4273 &mask_img
, &img
->mask
))
4275 image_error ("Out of memory (%s)", img
->spec
, Qnil
);
4279 for (y
= 0; y
< height
; y
++)
4281 expect (XPM_TK_STRING
);
4283 if (len
< width
* chars_per_pixel
)
4285 for (x
= 0; x
< width
; x
++, str
+= chars_per_pixel
)
4287 Lisp_Object color_val
=
4288 (*get_color_table
) (color_table
, str
, chars_per_pixel
);
4290 XPutPixel (ximg
, x
, y
,
4291 (INTEGERP (color_val
) ? XINT (color_val
)
4292 : FRAME_FOREGROUND_PIXEL (f
)));
4293 XPutPixel (mask_img
, x
, y
,
4294 (!EQ (color_val
, Qt
) ? PIX_MASK_DRAW
4295 : (have_mask
= 1, PIX_MASK_RETAIN
)));
4302 img
->height
= height
;
4304 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
4305 x_destroy_x_image (ximg
);
4308 /* Fill in the background_transparent field while we have the
4310 image_background_transparent (img
, f
, mask_img
);
4312 x_put_x_image (f
, mask_img
, img
->mask
, width
, height
);
4313 x_destroy_x_image (mask_img
);
4317 x_destroy_x_image (mask_img
);
4318 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
4319 img
->mask
= NO_PIXMAP
;
4325 image_error ("Invalid XPM file (%s)", img
->spec
, Qnil
);
4327 x_destroy_x_image (ximg
);
4328 x_destroy_x_image (mask_img
);
4329 x_clear_image (f
, img
);
4343 Lisp_Object file_name
;
4345 /* If IMG->spec specifies a file name, create a non-file spec from it. */
4346 file_name
= image_spec_value (img
->spec
, QCfile
, NULL
);
4347 if (STRINGP (file_name
))
4350 unsigned char *contents
;
4352 struct gcpro gcpro1
;
4354 file
= x_find_image_file (file_name
);
4356 if (!STRINGP (file
))
4358 image_error ("Cannot find image file `%s'", file_name
, Qnil
);
4363 contents
= slurp_file (SDATA (file
), &size
);
4364 if (contents
== NULL
)
4366 image_error ("Error loading XPM image `%s'", img
->spec
, Qnil
);
4371 success_p
= xpm_load_image (f
, img
, contents
, contents
+ size
);
4379 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
4380 success_p
= xpm_load_image (f
, img
, SDATA (data
),
4381 SDATA (data
) + SBYTES (data
));
4391 /***********************************************************************
4393 ***********************************************************************/
4395 #ifdef COLOR_TABLE_SUPPORT
4397 /* An entry in the color table mapping an RGB color to a pixel color. */
4402 unsigned long pixel
;
4404 /* Next in color table collision list. */
4405 struct ct_color
*next
;
4408 /* The bucket vector size to use. Must be prime. */
4412 /* Value is a hash of the RGB color given by R, G, and B. */
4414 #define CT_HASH_RGB(R, G, B) (((R) << 16) ^ ((G) << 8) ^ (B))
4416 /* The color hash table. */
4418 struct ct_color
**ct_table
;
4420 /* Number of entries in the color table. */
4422 int ct_colors_allocated
;
4424 /* Initialize the color table. */
4429 int size
= CT_SIZE
* sizeof (*ct_table
);
4430 ct_table
= (struct ct_color
**) xmalloc (size
);
4431 bzero (ct_table
, size
);
4432 ct_colors_allocated
= 0;
4436 /* Free memory associated with the color table. */
4442 struct ct_color
*p
, *next
;
4444 for (i
= 0; i
< CT_SIZE
; ++i
)
4445 for (p
= ct_table
[i
]; p
; p
= next
)
4456 /* Value is a pixel color for RGB color R, G, B on frame F. If an
4457 entry for that color already is in the color table, return the
4458 pixel color of that entry. Otherwise, allocate a new color for R,
4459 G, B, and make an entry in the color table. */
4461 static unsigned long
4462 lookup_rgb_color (f
, r
, g
, b
)
4466 unsigned hash
= CT_HASH_RGB (r
, g
, b
);
4467 int i
= hash
% CT_SIZE
;
4469 Display_Info
*dpyinfo
;
4471 /* Handle TrueColor visuals specially, which improves performance by
4472 two orders of magnitude. Freeing colors on TrueColor visuals is
4473 a nop, and pixel colors specify RGB values directly. See also
4474 the Xlib spec, chapter 3.1. */
4475 dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
4476 if (dpyinfo
->red_bits
> 0)
4478 unsigned long pr
, pg
, pb
;
4480 /* Apply gamma-correction like normal color allocation does. */
4484 color
.red
= r
, color
.green
= g
, color
.blue
= b
;
4485 gamma_correct (f
, &color
);
4486 r
= color
.red
, g
= color
.green
, b
= color
.blue
;
4489 /* Scale down RGB values to the visual's bits per RGB, and shift
4490 them to the right position in the pixel color. Note that the
4491 original RGB values are 16-bit values, as usual in X. */
4492 pr
= (r
>> (16 - dpyinfo
->red_bits
)) << dpyinfo
->red_offset
;
4493 pg
= (g
>> (16 - dpyinfo
->green_bits
)) << dpyinfo
->green_offset
;
4494 pb
= (b
>> (16 - dpyinfo
->blue_bits
)) << dpyinfo
->blue_offset
;
4496 /* Assemble the pixel color. */
4497 return pr
| pg
| pb
;
4500 for (p
= ct_table
[i
]; p
; p
= p
->next
)
4501 if (p
->r
== r
&& p
->g
== g
&& p
->b
== b
)
4507 #ifdef HAVE_X_WINDOWS
4516 cmap
= FRAME_X_COLORMAP (f
);
4517 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
4520 ++ct_colors_allocated
;
4521 p
= (struct ct_color
*) xmalloc (sizeof *p
);
4525 p
->pixel
= color
.pixel
;
4526 p
->next
= ct_table
[i
];
4530 return FRAME_FOREGROUND_PIXEL (f
);
4535 color
= PALETTERGB (r
, g
, b
);
4537 color
= RGB_TO_ULONG (r
, g
, b
);
4538 #endif /* HAVE_NTGUI */
4539 ++ct_colors_allocated
;
4540 p
= (struct ct_color
*) xmalloc (sizeof *p
);
4545 p
->next
= ct_table
[i
];
4547 #endif /* HAVE_X_WINDOWS */
4555 /* Look up pixel color PIXEL which is used on frame F in the color
4556 table. If not already present, allocate it. Value is PIXEL. */
4558 static unsigned long
4559 lookup_pixel_color (f
, pixel
)
4561 unsigned long pixel
;
4563 int i
= pixel
% CT_SIZE
;
4566 for (p
= ct_table
[i
]; p
; p
= p
->next
)
4567 if (p
->pixel
== pixel
)
4576 #ifdef HAVE_X_WINDOWS
4577 cmap
= FRAME_X_COLORMAP (f
);
4578 color
.pixel
= pixel
;
4579 x_query_color (f
, &color
);
4580 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
4583 cmap
= DefaultColormapOfScreen (FRAME_X_SCREEN (f
));
4584 color
.pixel
= pixel
;
4585 XQueryColor (NULL
, cmap
, &color
);
4586 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
4588 #endif /* HAVE_X_WINDOWS */
4592 ++ct_colors_allocated
;
4594 p
= (struct ct_color
*) xmalloc (sizeof *p
);
4599 p
->next
= ct_table
[i
];
4603 return FRAME_FOREGROUND_PIXEL (f
);
4609 /* Value is a vector of all pixel colors contained in the color table,
4610 allocated via xmalloc. Set *N to the number of colors. */
4612 static unsigned long *
4613 colors_in_color_table (n
)
4618 unsigned long *colors
;
4620 if (ct_colors_allocated
== 0)
4627 colors
= (unsigned long *) xmalloc (ct_colors_allocated
4629 *n
= ct_colors_allocated
;
4631 for (i
= j
= 0; i
< CT_SIZE
; ++i
)
4632 for (p
= ct_table
[i
]; p
; p
= p
->next
)
4633 colors
[j
++] = p
->pixel
;
4639 #else /* COLOR_TABLE_SUPPORT */
4641 static unsigned long
4642 lookup_rgb_color (f
, r
, g
, b
)
4646 unsigned long pixel
;
4649 pixel
= RGB_TO_ULONG (r
>> 8, g
>> 8, b
>> 8);
4650 gamma_correct (f
, &pixel
);
4654 pixel
= PALETTERGB (r
>> 8, g
>> 8, b
>> 8);
4655 #endif /* HAVE_NTGUI */
4664 #endif /* COLOR_TABLE_SUPPORT */
4667 /***********************************************************************
4669 ***********************************************************************/
4671 static XColor
*x_to_xcolors
P_ ((struct frame
*, struct image
*, int));
4672 static void x_from_xcolors
P_ ((struct frame
*, struct image
*, XColor
*));
4673 static void x_detect_edges
P_ ((struct frame
*, struct image
*, int[9], int));
4676 static void XPutPixel (XImagePtr
, int, int, COLORREF
);
4677 #endif /* HAVE_NTGUI */
4679 /* Non-zero means draw a cross on images having `:conversion
4682 int cross_disabled_images
;
4684 /* Edge detection matrices for different edge-detection
4687 static int emboss_matrix
[9] = {
4689 2, -1, 0, /* y - 1 */
4691 0, 1, -2 /* y + 1 */
4694 static int laplace_matrix
[9] = {
4696 1, 0, 0, /* y - 1 */
4698 0, 0, -1 /* y + 1 */
4701 /* Value is the intensity of the color whose red/green/blue values
4704 #define COLOR_INTENSITY(R, G, B) ((2 * (R) + 3 * (G) + (B)) / 6)
4707 /* On frame F, return an array of XColor structures describing image
4708 IMG->pixmap. Each XColor structure has its pixel color set. RGB_P
4709 non-zero means also fill the red/green/blue members of the XColor
4710 structures. Value is a pointer to the array of XColors structures,
4711 allocated with xmalloc; it must be freed by the caller. */
4714 x_to_xcolors (f
, img
, rgb_p
)
4721 XImagePtr_or_DC ximg
;
4725 #endif /* HAVE_NTGUI */
4727 colors
= (XColor
*) xmalloc (img
->width
* img
->height
* sizeof *colors
);
4730 /* Get the X image IMG->pixmap. */
4731 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
4732 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
4734 /* Load the image into a memory device context. */
4735 hdc
= get_frame_dc (f
);
4736 ximg
= CreateCompatibleDC (hdc
);
4737 release_frame_dc (f
, hdc
);
4738 prev
= SelectObject (ximg
, img
->pixmap
);
4739 #endif /* HAVE_NTGUI */
4741 /* Fill the `pixel' members of the XColor array. I wished there
4742 were an easy and portable way to circumvent XGetPixel. */
4744 for (y
= 0; y
< img
->height
; ++y
)
4748 #ifdef HAVE_X_WINDOWS
4749 for (x
= 0; x
< img
->width
; ++x
, ++p
)
4750 p
->pixel
= XGetPixel (ximg
, x
, y
);
4752 x_query_colors (f
, row
, img
->width
);
4756 for (x
= 0; x
< img
->width
; ++x
, ++p
)
4758 /* W32_TODO: palette support needed here? */
4759 p
->pixel
= GET_PIXEL (ximg
, x
, y
);
4763 p
->red
= RED16_FROM_ULONG (p
->pixel
);
4764 p
->green
= GREEN16_FROM_ULONG (p
->pixel
);
4765 p
->blue
= BLUE16_FROM_ULONG (p
->pixel
);
4768 p
->red
= 256 * GetRValue (p
->pixel
);
4769 p
->green
= 256 * GetGValue (p
->pixel
);
4770 p
->blue
= 256 * GetBValue (p
->pixel
);
4771 #endif /* HAVE_NTGUI */
4774 #endif /* HAVE_X_WINDOWS */
4777 Destroy_Image (ximg
, prev
);
4784 /* Put a pixel of COLOR at position X, Y in XIMG. XIMG must have been
4785 created with CreateDIBSection, with the pointer to the bit values
4786 stored in ximg->data. */
4788 static void XPutPixel (ximg
, x
, y
, color
)
4793 int width
= ximg
->info
.bmiHeader
.biWidth
;
4794 int height
= ximg
->info
.bmiHeader
.biHeight
;
4795 unsigned char * pixel
;
4797 /* True color images. */
4798 if (ximg
->info
.bmiHeader
.biBitCount
== 24)
4800 int rowbytes
= width
* 3;
4801 /* Ensure scanlines are aligned on 4 byte boundaries. */
4803 rowbytes
+= 4 - (rowbytes
% 4);
4805 pixel
= ximg
->data
+ y
* rowbytes
+ x
* 3;
4806 /* Windows bitmaps are in BGR order. */
4807 *pixel
= GetBValue (color
);
4808 *(pixel
+ 1) = GetGValue (color
);
4809 *(pixel
+ 2) = GetRValue (color
);
4811 /* Monochrome images. */
4812 else if (ximg
->info
.bmiHeader
.biBitCount
== 1)
4814 int rowbytes
= width
/ 8;
4815 /* Ensure scanlines are aligned on 4 byte boundaries. */
4817 rowbytes
+= 4 - (rowbytes
% 4);
4818 pixel
= ximg
->data
+ y
* rowbytes
+ x
/ 8;
4819 /* Filter out palette info. */
4820 if (color
& 0x00ffffff)
4821 *pixel
= *pixel
| (1 << x
% 8);
4823 *pixel
= *pixel
& ~(1 << x
% 8);
4826 image_error ("XPutPixel: palette image not supported", Qnil
, Qnil
);
4829 #endif /* HAVE_NTGUI */
4831 /* Create IMG->pixmap from an array COLORS of XColor structures, whose
4832 RGB members are set. F is the frame on which this all happens.
4833 COLORS will be freed; an existing IMG->pixmap will be freed, too. */
4836 x_from_xcolors (f
, img
, colors
)
4846 init_color_table ();
4848 x_create_x_image_and_pixmap (f
, img
->width
, img
->height
, 0,
4851 for (y
= 0; y
< img
->height
; ++y
)
4852 for (x
= 0; x
< img
->width
; ++x
, ++p
)
4854 unsigned long pixel
;
4855 pixel
= lookup_rgb_color (f
, p
->red
, p
->green
, p
->blue
);
4856 XPutPixel (oimg
, x
, y
, pixel
);
4860 x_clear_image_1 (f
, img
, 1, 0, 1);
4862 x_put_x_image (f
, oimg
, pixmap
, img
->width
, img
->height
);
4863 x_destroy_x_image (oimg
);
4864 img
->pixmap
= pixmap
;
4865 #ifdef COLOR_TABLE_SUPPORT
4866 img
->colors
= colors_in_color_table (&img
->ncolors
);
4867 free_color_table ();
4868 #endif /* COLOR_TABLE_SUPPORT */
4872 /* On frame F, perform edge-detection on image IMG.
4874 MATRIX is a nine-element array specifying the transformation
4875 matrix. See emboss_matrix for an example.
4877 COLOR_ADJUST is a color adjustment added to each pixel of the
4881 x_detect_edges (f
, img
, matrix
, color_adjust
)
4884 int matrix
[9], color_adjust
;
4886 XColor
*colors
= x_to_xcolors (f
, img
, 1);
4890 for (i
= sum
= 0; i
< 9; ++i
)
4891 sum
+= abs (matrix
[i
]);
4893 #define COLOR(A, X, Y) ((A) + (Y) * img->width + (X))
4895 new = (XColor
*) xmalloc (img
->width
* img
->height
* sizeof *new);
4897 for (y
= 0; y
< img
->height
; ++y
)
4899 p
= COLOR (new, 0, y
);
4900 p
->red
= p
->green
= p
->blue
= 0xffff/2;
4901 p
= COLOR (new, img
->width
- 1, y
);
4902 p
->red
= p
->green
= p
->blue
= 0xffff/2;
4905 for (x
= 1; x
< img
->width
- 1; ++x
)
4907 p
= COLOR (new, x
, 0);
4908 p
->red
= p
->green
= p
->blue
= 0xffff/2;
4909 p
= COLOR (new, x
, img
->height
- 1);
4910 p
->red
= p
->green
= p
->blue
= 0xffff/2;
4913 for (y
= 1; y
< img
->height
- 1; ++y
)
4915 p
= COLOR (new, 1, y
);
4917 for (x
= 1; x
< img
->width
- 1; ++x
, ++p
)
4919 int r
, g
, b
, y1
, x1
;
4922 for (y1
= y
- 1; y1
< y
+ 2; ++y1
)
4923 for (x1
= x
- 1; x1
< x
+ 2; ++x1
, ++i
)
4926 XColor
*t
= COLOR (colors
, x1
, y1
);
4927 r
+= matrix
[i
] * t
->red
;
4928 g
+= matrix
[i
] * t
->green
;
4929 b
+= matrix
[i
] * t
->blue
;
4932 r
= (r
/ sum
+ color_adjust
) & 0xffff;
4933 g
= (g
/ sum
+ color_adjust
) & 0xffff;
4934 b
= (b
/ sum
+ color_adjust
) & 0xffff;
4935 p
->red
= p
->green
= p
->blue
= COLOR_INTENSITY (r
, g
, b
);
4940 x_from_xcolors (f
, img
, new);
4946 /* Perform the pre-defined `emboss' edge-detection on image IMG
4954 x_detect_edges (f
, img
, emboss_matrix
, 0xffff / 2);
4958 /* Transform image IMG which is used on frame F with a Laplace
4959 edge-detection algorithm. The result is an image that can be used
4960 to draw disabled buttons, for example. */
4967 x_detect_edges (f
, img
, laplace_matrix
, 45000);
4971 /* Perform edge-detection on image IMG on frame F, with specified
4972 transformation matrix MATRIX and color-adjustment COLOR_ADJUST.
4974 MATRIX must be either
4976 - a list of at least 9 numbers in row-major form
4977 - a vector of at least 9 numbers
4979 COLOR_ADJUST nil means use a default; otherwise it must be a
4983 x_edge_detection (f
, img
, matrix
, color_adjust
)
4986 Lisp_Object matrix
, color_adjust
;
4994 i
< 9 && CONSP (matrix
) && NUMBERP (XCAR (matrix
));
4995 ++i
, matrix
= XCDR (matrix
))
4996 trans
[i
] = XFLOATINT (XCAR (matrix
));
4998 else if (VECTORP (matrix
) && ASIZE (matrix
) >= 9)
5000 for (i
= 0; i
< 9 && NUMBERP (AREF (matrix
, i
)); ++i
)
5001 trans
[i
] = XFLOATINT (AREF (matrix
, i
));
5004 if (NILP (color_adjust
))
5005 color_adjust
= make_number (0xffff / 2);
5007 if (i
== 9 && NUMBERP (color_adjust
))
5008 x_detect_edges (f
, img
, trans
, (int) XFLOATINT (color_adjust
));
5012 /* Transform image IMG on frame F so that it looks disabled. */
5015 x_disable_image (f
, img
)
5019 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
5021 int n_planes
= dpyinfo
->n_planes
* dpyinfo
->n_cbits
;
5023 int n_planes
= dpyinfo
->n_planes
;
5024 #endif /* HAVE_NTGUI */
5028 /* Color (or grayscale). Convert to gray, and equalize. Just
5029 drawing such images with a stipple can look very odd, so
5030 we're using this method instead. */
5031 XColor
*colors
= x_to_xcolors (f
, img
, 1);
5033 const int h
= 15000;
5034 const int l
= 30000;
5036 for (p
= colors
, end
= colors
+ img
->width
* img
->height
;
5040 int i
= COLOR_INTENSITY (p
->red
, p
->green
, p
->blue
);
5041 int i2
= (0xffff - h
- l
) * i
/ 0xffff + l
;
5042 p
->red
= p
->green
= p
->blue
= i2
;
5045 x_from_xcolors (f
, img
, colors
);
5048 /* Draw a cross over the disabled image, if we must or if we
5050 if (n_planes
< 2 || cross_disabled_images
)
5053 Display
*dpy
= FRAME_X_DISPLAY (f
);
5057 #define XCreateGC_pixmap(dpy, pixmap) XCreateGC (dpy, NULL, 0, NULL)
5058 #define MaskForeground(f) PIX_MASK_DRAW
5060 #define XCreateGC_pixmap(dpy, pixmap) XCreateGC (dpy, pixmap, 0, NULL)
5061 #define MaskForeground(f) WHITE_PIX_DEFAULT (f)
5064 gc
= XCreateGC_pixmap (dpy
, img
->pixmap
);
5065 XSetForeground (dpy
, gc
, BLACK_PIX_DEFAULT (f
));
5066 XDrawLine (dpy
, img
->pixmap
, gc
, 0, 0,
5067 img
->width
- 1, img
->height
- 1);
5068 XDrawLine (dpy
, img
->pixmap
, gc
, 0, img
->height
- 1,
5074 gc
= XCreateGC_pixmap (dpy
, img
->mask
);
5075 XSetForeground (dpy
, gc
, MaskForeground (f
));
5076 XDrawLine (dpy
, img
->mask
, gc
, 0, 0,
5077 img
->width
- 1, img
->height
- 1);
5078 XDrawLine (dpy
, img
->mask
, gc
, 0, img
->height
- 1,
5086 hdc
= get_frame_dc (f
);
5087 bmpdc
= CreateCompatibleDC (hdc
);
5088 release_frame_dc (f
, hdc
);
5090 prev
= SelectObject (bmpdc
, img
->pixmap
);
5092 SetTextColor (bmpdc
, BLACK_PIX_DEFAULT (f
));
5093 MoveToEx (bmpdc
, 0, 0, NULL
);
5094 LineTo (bmpdc
, img
->width
- 1, img
->height
- 1);
5095 MoveToEx (bmpdc
, 0, img
->height
- 1, NULL
);
5096 LineTo (bmpdc
, img
->width
- 1, 0);
5100 SelectObject (bmpdc
, img
->mask
);
5101 SetTextColor (bmpdc
, WHITE_PIX_DEFAULT (f
));
5102 MoveToEx (bmpdc
, 0, 0, NULL
);
5103 LineTo (bmpdc
, img
->width
- 1, img
->height
- 1);
5104 MoveToEx (bmpdc
, 0, img
->height
- 1, NULL
);
5105 LineTo (bmpdc
, img
->width
- 1, 0);
5107 SelectObject (bmpdc
, prev
);
5109 #endif /* HAVE_NTGUI */
5114 /* Build a mask for image IMG which is used on frame F. FILE is the
5115 name of an image file, for error messages. HOW determines how to
5116 determine the background color of IMG. If it is a list '(R G B)',
5117 with R, G, and B being integers >= 0, take that as the color of the
5118 background. Otherwise, determine the background color of IMG
5119 heuristically. Value is non-zero if successful. */
5122 x_build_heuristic_mask (f
, img
, how
)
5127 XImagePtr_or_DC ximg
;
5135 #endif /* HAVE_NTGUI */
5136 int x
, y
, rc
, use_img_background
;
5137 unsigned long bg
= 0;
5141 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
5142 img
->mask
= NO_PIXMAP
;
5143 img
->background_transparent_valid
= 0;
5147 /* Create an image and pixmap serving as mask. */
5148 rc
= x_create_x_image_and_pixmap (f
, img
->width
, img
->height
, 1,
5149 &mask_img
, &img
->mask
);
5153 /* Get the X image of IMG->pixmap. */
5154 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
, 0, 0,
5155 img
->width
, img
->height
,
5158 /* Create the bit array serving as mask. */
5159 row_width
= (img
->width
+ 7) / 8;
5160 mask_img
= xmalloc (row_width
* img
->height
);
5161 bzero (mask_img
, row_width
* img
->height
);
5163 /* Create a memory device context for IMG->pixmap. */
5164 frame_dc
= get_frame_dc (f
);
5165 ximg
= CreateCompatibleDC (frame_dc
);
5166 release_frame_dc (f
, frame_dc
);
5167 prev
= SelectObject (ximg
, img
->pixmap
);
5168 #endif /* HAVE_NTGUI */
5170 /* Determine the background color of ximg. If HOW is `(R G B)'
5171 take that as color. Otherwise, use the image's background color. */
5172 use_img_background
= 1;
5178 for (i
= 0; i
< 3 && CONSP (how
) && NATNUMP (XCAR (how
)); ++i
)
5180 rgb
[i
] = XFASTINT (XCAR (how
)) & 0xffff;
5184 if (i
== 3 && NILP (how
))
5186 char color_name
[30];
5187 sprintf (color_name
, "#%04x%04x%04x", rgb
[0], rgb
[1], rgb
[2]);
5190 0x00ffffff & /* Filter out palette info. */
5191 #endif /* HAVE_NTGUI */
5192 x_alloc_image_color (f
, img
, build_string (color_name
), 0));
5193 use_img_background
= 0;
5197 if (use_img_background
)
5198 bg
= four_corners_best (ximg
, img
->width
, img
->height
);
5200 /* Set all bits in mask_img to 1 whose color in ximg is different
5201 from the background color bg. */
5203 for (y
= 0; y
< img
->height
; ++y
)
5204 for (x
= 0; x
< img
->width
; ++x
)
5205 XPutPixel (mask_img
, x
, y
, (XGetPixel (ximg
, x
, y
) != bg
5206 ? PIX_MASK_DRAW
: PIX_MASK_RETAIN
));
5208 /* Fill in the background_transparent field while we have the mask handy. */
5209 image_background_transparent (img
, f
, mask_img
);
5211 /* Put mask_img into img->mask. */
5212 x_put_x_image (f
, mask_img
, img
->mask
, img
->width
, img
->height
);
5213 x_destroy_x_image (mask_img
);
5216 for (y
= 0; y
< img
->height
; ++y
)
5217 for (x
= 0; x
< img
->width
; ++x
)
5219 COLORREF p
= GetPixel (ximg
, x
, y
);
5221 mask_img
[y
* row_width
+ x
/ 8] |= 1 << (x
% 8);
5224 /* Create the mask image. */
5225 img
->mask
= w32_create_pixmap_from_bitmap_data (img
->width
, img
->height
,
5227 /* Fill in the background_transparent field while we have the mask handy. */
5228 SelectObject (ximg
, img
->mask
);
5229 image_background_transparent (img
, f
, ximg
);
5231 /* Was: x_destroy_x_image ((XImagePtr )mask_img); which seems bogus ++kfs */
5233 #endif /* HAVE_NTGUI */
5235 Destroy_Image (ximg
, prev
);
5241 /***********************************************************************
5242 PBM (mono, gray, color)
5243 ***********************************************************************/
5245 static int pbm_image_p
P_ ((Lisp_Object object
));
5246 static int pbm_load
P_ ((struct frame
*f
, struct image
*img
));
5247 static int pbm_scan_number
P_ ((unsigned char **, unsigned char *));
5249 /* The symbol `pbm' identifying images of this type. */
5253 /* Indices of image specification fields in gs_format, below. */
5255 enum pbm_keyword_index
5271 /* Vector of image_keyword structures describing the format
5272 of valid user-defined image specifications. */
5274 static struct image_keyword pbm_format
[PBM_LAST
] =
5276 {":type", IMAGE_SYMBOL_VALUE
, 1},
5277 {":file", IMAGE_STRING_VALUE
, 0},
5278 {":data", IMAGE_STRING_VALUE
, 0},
5279 {":ascent", IMAGE_ASCENT_VALUE
, 0},
5280 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
5281 {":relief", IMAGE_INTEGER_VALUE
, 0},
5282 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5283 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5284 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5285 {":foreground", IMAGE_STRING_OR_NIL_VALUE
, 0},
5286 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
5289 /* Structure describing the image type `pbm'. */
5291 static struct image_type pbm_type
=
5301 /* Return non-zero if OBJECT is a valid PBM image specification. */
5304 pbm_image_p (object
)
5307 struct image_keyword fmt
[PBM_LAST
];
5309 bcopy (pbm_format
, fmt
, sizeof fmt
);
5311 if (!parse_image_spec (object
, fmt
, PBM_LAST
, Qpbm
))
5314 /* Must specify either :data or :file. */
5315 return fmt
[PBM_DATA
].count
+ fmt
[PBM_FILE
].count
== 1;
5319 /* Scan a decimal number from *S and return it. Advance *S while
5320 reading the number. END is the end of the string. Value is -1 at
5324 pbm_scan_number (s
, end
)
5325 unsigned char **s
, *end
;
5327 int c
= 0, val
= -1;
5331 /* Skip white-space. */
5332 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
5337 /* Skip comment to end of line. */
5338 while (*s
< end
&& (c
= *(*s
)++, c
!= '\n'))
5341 else if (isdigit (c
))
5343 /* Read decimal number. */
5345 while (*s
< end
&& (c
= *(*s
)++, isdigit (c
)))
5346 val
= 10 * val
+ c
- '0';
5358 #if 0 /* Unused. ++kfs */
5360 /* Read FILE into memory. Value is a pointer to a buffer allocated
5361 with xmalloc holding FILE's contents. Value is null if an error
5362 occurred. *SIZE is set to the size of the file. */
5365 pbm_read_file (file
, size
)
5373 if (stat (SDATA (file
), &st
) == 0
5374 && (fp
= fopen (SDATA (file
), "rb")) != NULL
5375 && (buf
= (char *) xmalloc (st
.st_size
),
5376 fread (buf
, 1, st
.st_size
, fp
) == st
.st_size
))
5395 #endif /* HAVE_NTGUI */
5397 /* Load PBM image IMG for use on frame F. */
5405 int width
, height
, max_color_idx
= 0;
5407 Lisp_Object file
, specified_file
;
5408 enum {PBM_MONO
, PBM_GRAY
, PBM_COLOR
} type
;
5409 struct gcpro gcpro1
;
5410 unsigned char *contents
= NULL
;
5411 unsigned char *end
, *p
;
5414 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
5418 if (STRINGP (specified_file
))
5420 file
= x_find_image_file (specified_file
);
5421 if (!STRINGP (file
))
5423 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
5428 contents
= slurp_file (SDATA (file
), &size
);
5429 if (contents
== NULL
)
5431 image_error ("Error reading `%s'", file
, Qnil
);
5437 end
= contents
+ size
;
5442 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
5444 end
= p
+ SBYTES (data
);
5447 /* Check magic number. */
5448 if (end
- p
< 2 || *p
++ != 'P')
5450 image_error ("Not a PBM image: `%s'", img
->spec
, Qnil
);
5460 raw_p
= 0, type
= PBM_MONO
;
5464 raw_p
= 0, type
= PBM_GRAY
;
5468 raw_p
= 0, type
= PBM_COLOR
;
5472 raw_p
= 1, type
= PBM_MONO
;
5476 raw_p
= 1, type
= PBM_GRAY
;
5480 raw_p
= 1, type
= PBM_COLOR
;
5484 image_error ("Not a PBM image: `%s'", img
->spec
, Qnil
);
5488 /* Read width, height, maximum color-component. Characters
5489 starting with `#' up to the end of a line are ignored. */
5490 width
= pbm_scan_number (&p
, end
);
5491 height
= pbm_scan_number (&p
, end
);
5493 if (type
!= PBM_MONO
)
5495 max_color_idx
= pbm_scan_number (&p
, end
);
5496 if (raw_p
&& max_color_idx
> 255)
5497 max_color_idx
= 255;
5500 if (!check_image_size (f
, width
, height
)
5501 || (type
!= PBM_MONO
&& max_color_idx
< 0))
5504 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0,
5505 &ximg
, &img
->pixmap
))
5508 /* Initialize the color hash table. */
5509 init_color_table ();
5511 if (type
== PBM_MONO
)
5514 struct image_keyword fmt
[PBM_LAST
];
5515 unsigned long fg
= FRAME_FOREGROUND_PIXEL (f
);
5516 unsigned long bg
= FRAME_BACKGROUND_PIXEL (f
);
5518 /* Parse the image specification. */
5519 bcopy (pbm_format
, fmt
, sizeof fmt
);
5520 parse_image_spec (img
->spec
, fmt
, PBM_LAST
, Qpbm
);
5522 /* Get foreground and background colors, maybe allocate colors. */
5523 if (fmt
[PBM_FOREGROUND
].count
5524 && STRINGP (fmt
[PBM_FOREGROUND
].value
))
5525 fg
= x_alloc_image_color (f
, img
, fmt
[PBM_FOREGROUND
].value
, fg
);
5526 if (fmt
[PBM_BACKGROUND
].count
5527 && STRINGP (fmt
[PBM_BACKGROUND
].value
))
5529 bg
= x_alloc_image_color (f
, img
, fmt
[PBM_BACKGROUND
].value
, bg
);
5530 img
->background
= bg
;
5531 img
->background_valid
= 1;
5534 for (y
= 0; y
< height
; ++y
)
5535 for (x
= 0; x
< width
; ++x
)
5545 g
= pbm_scan_number (&p
, end
);
5547 XPutPixel (ximg
, x
, y
, g
? fg
: bg
);
5552 for (y
= 0; y
< height
; ++y
)
5553 for (x
= 0; x
< width
; ++x
)
5557 if (type
== PBM_GRAY
)
5558 r
= g
= b
= raw_p
? *p
++ : pbm_scan_number (&p
, end
);
5567 r
= pbm_scan_number (&p
, end
);
5568 g
= pbm_scan_number (&p
, end
);
5569 b
= pbm_scan_number (&p
, end
);
5572 if (r
< 0 || g
< 0 || b
< 0)
5574 x_destroy_x_image (ximg
);
5575 image_error ("Invalid pixel value in image `%s'",
5580 /* RGB values are now in the range 0..max_color_idx.
5581 Scale this to the range 0..0xffff supported by X. */
5582 r
= (double) r
* 65535 / max_color_idx
;
5583 g
= (double) g
* 65535 / max_color_idx
;
5584 b
= (double) b
* 65535 / max_color_idx
;
5585 XPutPixel (ximg
, x
, y
, lookup_rgb_color (f
, r
, g
, b
));
5589 #ifdef COLOR_TABLE_SUPPORT
5590 /* Store in IMG->colors the colors allocated for the image, and
5591 free the color table. */
5592 img
->colors
= colors_in_color_table (&img
->ncolors
);
5593 free_color_table ();
5594 #endif /* COLOR_TABLE_SUPPORT */
5597 img
->height
= height
;
5599 /* Maybe fill in the background field while we have ximg handy. */
5601 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
5602 /* Casting avoids a GCC warning. */
5603 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
5605 /* Put the image into a pixmap. */
5606 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
5607 x_destroy_x_image (ximg
);
5609 /* X and W32 versions did it here, MAC version above. ++kfs
5611 img->height = height; */
5619 /***********************************************************************
5621 ***********************************************************************/
5623 #if defined (HAVE_PNG) || defined (MAC_OS)
5625 /* Function prototypes. */
5627 static int png_image_p
P_ ((Lisp_Object object
));
5628 static int png_load
P_ ((struct frame
*f
, struct image
*img
));
5630 /* The symbol `png' identifying images of this type. */
5634 /* Indices of image specification fields in png_format, below. */
5636 enum png_keyword_index
5651 /* Vector of image_keyword structures describing the format
5652 of valid user-defined image specifications. */
5654 static struct image_keyword png_format
[PNG_LAST
] =
5656 {":type", IMAGE_SYMBOL_VALUE
, 1},
5657 {":data", IMAGE_STRING_VALUE
, 0},
5658 {":file", IMAGE_STRING_VALUE
, 0},
5659 {":ascent", IMAGE_ASCENT_VALUE
, 0},
5660 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
5661 {":relief", IMAGE_INTEGER_VALUE
, 0},
5662 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5663 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5664 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5665 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
5668 /* Structure describing the image type `png'. */
5670 static struct image_type png_type
=
5679 /* Return non-zero if OBJECT is a valid PNG image specification. */
5682 png_image_p (object
)
5685 struct image_keyword fmt
[PNG_LAST
];
5686 bcopy (png_format
, fmt
, sizeof fmt
);
5688 if (!parse_image_spec (object
, fmt
, PNG_LAST
, Qpng
))
5691 /* Must specify either the :data or :file keyword. */
5692 return fmt
[PNG_FILE
].count
+ fmt
[PNG_DATA
].count
== 1;
5695 #endif /* HAVE_PNG || MAC_OS */
5700 #if defined HAVE_LIBPNG_PNG_H
5701 # include <libpng/png.h>
5707 /* PNG library details. */
5709 DEF_IMGLIB_FN (png_get_io_ptr
);
5710 DEF_IMGLIB_FN (png_check_sig
);
5711 DEF_IMGLIB_FN (png_create_read_struct
);
5712 DEF_IMGLIB_FN (png_create_info_struct
);
5713 DEF_IMGLIB_FN (png_destroy_read_struct
);
5714 DEF_IMGLIB_FN (png_set_read_fn
);
5715 DEF_IMGLIB_FN (png_set_sig_bytes
);
5716 DEF_IMGLIB_FN (png_read_info
);
5717 DEF_IMGLIB_FN (png_get_IHDR
);
5718 DEF_IMGLIB_FN (png_get_valid
);
5719 DEF_IMGLIB_FN (png_set_strip_16
);
5720 DEF_IMGLIB_FN (png_set_expand
);
5721 DEF_IMGLIB_FN (png_set_gray_to_rgb
);
5722 DEF_IMGLIB_FN (png_set_background
);
5723 DEF_IMGLIB_FN (png_get_bKGD
);
5724 DEF_IMGLIB_FN (png_read_update_info
);
5725 DEF_IMGLIB_FN (png_get_channels
);
5726 DEF_IMGLIB_FN (png_get_rowbytes
);
5727 DEF_IMGLIB_FN (png_read_image
);
5728 DEF_IMGLIB_FN (png_read_end
);
5729 DEF_IMGLIB_FN (png_error
);
5732 init_png_functions (Lisp_Object libraries
)
5736 /* Try loading libpng under probable names. */
5737 if (!(library
= w32_delayed_load (libraries
, Qpng
)))
5740 LOAD_IMGLIB_FN (library
, png_get_io_ptr
);
5741 LOAD_IMGLIB_FN (library
, png_check_sig
);
5742 LOAD_IMGLIB_FN (library
, png_create_read_struct
);
5743 LOAD_IMGLIB_FN (library
, png_create_info_struct
);
5744 LOAD_IMGLIB_FN (library
, png_destroy_read_struct
);
5745 LOAD_IMGLIB_FN (library
, png_set_read_fn
);
5746 LOAD_IMGLIB_FN (library
, png_set_sig_bytes
);
5747 LOAD_IMGLIB_FN (library
, png_read_info
);
5748 LOAD_IMGLIB_FN (library
, png_get_IHDR
);
5749 LOAD_IMGLIB_FN (library
, png_get_valid
);
5750 LOAD_IMGLIB_FN (library
, png_set_strip_16
);
5751 LOAD_IMGLIB_FN (library
, png_set_expand
);
5752 LOAD_IMGLIB_FN (library
, png_set_gray_to_rgb
);
5753 LOAD_IMGLIB_FN (library
, png_set_background
);
5754 LOAD_IMGLIB_FN (library
, png_get_bKGD
);
5755 LOAD_IMGLIB_FN (library
, png_read_update_info
);
5756 LOAD_IMGLIB_FN (library
, png_get_channels
);
5757 LOAD_IMGLIB_FN (library
, png_get_rowbytes
);
5758 LOAD_IMGLIB_FN (library
, png_read_image
);
5759 LOAD_IMGLIB_FN (library
, png_read_end
);
5760 LOAD_IMGLIB_FN (library
, png_error
);
5765 #define fn_png_get_io_ptr png_get_io_ptr
5766 #define fn_png_check_sig png_check_sig
5767 #define fn_png_create_read_struct png_create_read_struct
5768 #define fn_png_create_info_struct png_create_info_struct
5769 #define fn_png_destroy_read_struct png_destroy_read_struct
5770 #define fn_png_set_read_fn png_set_read_fn
5771 #define fn_png_set_sig_bytes png_set_sig_bytes
5772 #define fn_png_read_info png_read_info
5773 #define fn_png_get_IHDR png_get_IHDR
5774 #define fn_png_get_valid png_get_valid
5775 #define fn_png_set_strip_16 png_set_strip_16
5776 #define fn_png_set_expand png_set_expand
5777 #define fn_png_set_gray_to_rgb png_set_gray_to_rgb
5778 #define fn_png_set_background png_set_background
5779 #define fn_png_get_bKGD png_get_bKGD
5780 #define fn_png_read_update_info png_read_update_info
5781 #define fn_png_get_channels png_get_channels
5782 #define fn_png_get_rowbytes png_get_rowbytes
5783 #define fn_png_read_image png_read_image
5784 #define fn_png_read_end png_read_end
5785 #define fn_png_error png_error
5787 #endif /* HAVE_NTGUI */
5789 /* Error and warning handlers installed when the PNG library
5793 my_png_error (png_ptr
, msg
)
5794 png_struct
*png_ptr
;
5797 xassert (png_ptr
!= NULL
);
5798 image_error ("PNG error: %s", build_string (msg
), Qnil
);
5799 longjmp (png_ptr
->jmpbuf
, 1);
5804 my_png_warning (png_ptr
, msg
)
5805 png_struct
*png_ptr
;
5808 xassert (png_ptr
!= NULL
);
5809 image_error ("PNG warning: %s", build_string (msg
), Qnil
);
5812 /* Memory source for PNG decoding. */
5814 struct png_memory_storage
5816 unsigned char *bytes
; /* The data */
5817 size_t len
; /* How big is it? */
5818 int index
; /* Where are we? */
5822 /* Function set as reader function when reading PNG image from memory.
5823 PNG_PTR is a pointer to the PNG control structure. Copy LENGTH
5824 bytes from the input to DATA. */
5827 png_read_from_memory (png_ptr
, data
, length
)
5828 png_structp png_ptr
;
5832 struct png_memory_storage
*tbr
5833 = (struct png_memory_storage
*) fn_png_get_io_ptr (png_ptr
);
5835 if (length
> tbr
->len
- tbr
->index
)
5836 fn_png_error (png_ptr
, "Read error");
5838 bcopy (tbr
->bytes
+ tbr
->index
, data
, length
);
5839 tbr
->index
= tbr
->index
+ length
;
5843 /* Function set as reader function when reading PNG image from a file.
5844 PNG_PTR is a pointer to the PNG control structure. Copy LENGTH
5845 bytes from the input to DATA. */
5848 png_read_from_file (png_ptr
, data
, length
)
5849 png_structp png_ptr
;
5853 FILE *fp
= (FILE *) fn_png_get_io_ptr (png_ptr
);
5855 if (fread (data
, 1, length
, fp
) < length
)
5856 fn_png_error (png_ptr
, "Read error");
5860 /* Load PNG image IMG for use on frame F. Value is non-zero if
5868 Lisp_Object file
, specified_file
;
5869 Lisp_Object specified_data
;
5871 XImagePtr ximg
, mask_img
= NULL
;
5872 struct gcpro gcpro1
;
5873 png_struct
*png_ptr
= NULL
;
5874 png_info
*info_ptr
= NULL
, *end_info
= NULL
;
5875 FILE *volatile fp
= NULL
;
5877 png_byte
* volatile pixels
= NULL
;
5878 png_byte
** volatile rows
= NULL
;
5879 png_uint_32 width
, height
;
5880 int bit_depth
, color_type
, interlace_type
;
5882 png_uint_32 row_bytes
;
5884 double screen_gamma
;
5885 struct png_memory_storage tbr
; /* Data to be read */
5887 /* Find out what file to load. */
5888 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
5889 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
5893 if (NILP (specified_data
))
5895 file
= x_find_image_file (specified_file
);
5896 if (!STRINGP (file
))
5898 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
5903 /* Open the image file. */
5904 fp
= fopen (SDATA (file
), "rb");
5907 image_error ("Cannot open image file `%s'", file
, Qnil
);
5913 /* Check PNG signature. */
5914 if (fread (sig
, 1, sizeof sig
, fp
) != sizeof sig
5915 || !fn_png_check_sig (sig
, sizeof sig
))
5917 image_error ("Not a PNG file: `%s'", file
, Qnil
);
5925 /* Read from memory. */
5926 tbr
.bytes
= SDATA (specified_data
);
5927 tbr
.len
= SBYTES (specified_data
);
5930 /* Check PNG signature. */
5931 if (tbr
.len
< sizeof sig
5932 || !fn_png_check_sig (tbr
.bytes
, sizeof sig
))
5934 image_error ("Not a PNG image: `%s'", img
->spec
, Qnil
);
5939 /* Need to skip past the signature. */
5940 tbr
.bytes
+= sizeof (sig
);
5943 /* Initialize read and info structs for PNG lib. Casting return
5944 value avoids a GCC warning on W32. */
5945 png_ptr
= (png_structp
)fn_png_create_read_struct (PNG_LIBPNG_VER_STRING
,
5950 if (fp
) fclose (fp
);
5955 /* Casting return value avoids a GCC warning on W32. */
5956 info_ptr
= (png_infop
)fn_png_create_info_struct (png_ptr
);
5959 fn_png_destroy_read_struct (&png_ptr
, NULL
, NULL
);
5960 if (fp
) fclose (fp
);
5965 /* Casting return value avoids a GCC warning on W32. */
5966 end_info
= (png_infop
)fn_png_create_info_struct (png_ptr
);
5969 fn_png_destroy_read_struct (&png_ptr
, &info_ptr
, NULL
);
5970 if (fp
) fclose (fp
);
5975 /* Set error jump-back. We come back here when the PNG library
5976 detects an error. */
5977 if (setjmp (png_ptr
->jmpbuf
))
5981 fn_png_destroy_read_struct (&png_ptr
, &info_ptr
, &end_info
);
5984 if (fp
) fclose (fp
);
5989 /* Read image info. */
5990 if (!NILP (specified_data
))
5991 fn_png_set_read_fn (png_ptr
, (void *) &tbr
, png_read_from_memory
);
5993 fn_png_set_read_fn (png_ptr
, (void *) fp
, png_read_from_file
);
5995 fn_png_set_sig_bytes (png_ptr
, sizeof sig
);
5996 fn_png_read_info (png_ptr
, info_ptr
);
5997 fn_png_get_IHDR (png_ptr
, info_ptr
, &width
, &height
, &bit_depth
, &color_type
,
5998 &interlace_type
, NULL
, NULL
);
6000 if (!check_image_size (f
, width
, height
))
6003 /* If image contains simply transparency data, we prefer to
6004 construct a clipping mask. */
6005 if (fn_png_get_valid (png_ptr
, info_ptr
, PNG_INFO_tRNS
))
6010 /* This function is easier to write if we only have to handle
6011 one data format: RGB or RGBA with 8 bits per channel. Let's
6012 transform other formats into that format. */
6014 /* Strip more than 8 bits per channel. */
6015 if (bit_depth
== 16)
6016 fn_png_set_strip_16 (png_ptr
);
6018 /* Expand data to 24 bit RGB, or 8 bit grayscale, with alpha channel
6020 fn_png_set_expand (png_ptr
);
6022 /* Convert grayscale images to RGB. */
6023 if (color_type
== PNG_COLOR_TYPE_GRAY
6024 || color_type
== PNG_COLOR_TYPE_GRAY_ALPHA
)
6025 fn_png_set_gray_to_rgb (png_ptr
);
6027 screen_gamma
= (f
->gamma
? 1 / f
->gamma
/ 0.45455 : 2.2);
6029 #if 0 /* Avoid double gamma correction for PNG images. */
6030 { /* Tell the PNG lib to handle gamma correction for us. */
6033 #if defined(PNG_READ_sRGB_SUPPORTED) || defined(PNG_WRITE_sRGB_SUPPORTED)
6034 if (png_get_sRGB (png_ptr
, info_ptr
, &intent
))
6035 /* The libpng documentation says this is right in this case. */
6036 png_set_gamma (png_ptr
, screen_gamma
, 0.45455);
6039 if (png_get_gAMA (png_ptr
, info_ptr
, &image_gamma
))
6040 /* Image contains gamma information. */
6041 png_set_gamma (png_ptr
, screen_gamma
, image_gamma
);
6043 /* Use the standard default for the image gamma. */
6044 png_set_gamma (png_ptr
, screen_gamma
, 0.45455);
6048 /* Handle alpha channel by combining the image with a background
6049 color. Do this only if a real alpha channel is supplied. For
6050 simple transparency, we prefer a clipping mask. */
6053 png_color_16
*image_bg
;
6054 Lisp_Object specified_bg
6055 = image_spec_value (img
->spec
, QCbackground
, NULL
);
6057 if (STRINGP (specified_bg
))
6058 /* The user specified `:background', use that. */
6060 /* W32 version incorrectly used COLORREF here!! ++kfs */
6062 if (x_defined_color (f
, SDATA (specified_bg
), &color
, 0))
6064 png_color_16 user_bg
;
6066 bzero (&user_bg
, sizeof user_bg
);
6067 user_bg
.red
= color
.red
>> 8;
6068 user_bg
.green
= color
.green
>> 8;
6069 user_bg
.blue
= color
.blue
>> 8;
6071 fn_png_set_background (png_ptr
, &user_bg
,
6072 PNG_BACKGROUND_GAMMA_SCREEN
, 0, 1.0);
6075 else if (fn_png_get_bKGD (png_ptr
, info_ptr
, &image_bg
))
6076 /* Image contains a background color with which to
6077 combine the image. */
6078 fn_png_set_background (png_ptr
, image_bg
,
6079 PNG_BACKGROUND_GAMMA_FILE
, 1, 1.0);
6082 /* Image does not contain a background color with which
6083 to combine the image data via an alpha channel. Use
6084 the frame's background instead. */
6085 #ifdef HAVE_X_WINDOWS
6087 png_color_16 frame_background
;
6089 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
6090 x_query_color (f
, &color
);
6092 bzero (&frame_background
, sizeof frame_background
);
6093 frame_background
.red
= color
.red
>> 8;
6094 frame_background
.green
= color
.green
>> 8;
6095 frame_background
.blue
= color
.blue
>> 8;
6096 #endif /* HAVE_X_WINDOWS */
6100 png_color_16 frame_background
;
6101 color
= FRAME_BACKGROUND_PIXEL (f
);
6102 #if 0 /* W32 TODO : Colormap support. */
6103 x_query_color (f
, &color
);
6105 bzero (&frame_background
, sizeof frame_background
);
6106 frame_background
.red
= GetRValue (color
);
6107 frame_background
.green
= GetGValue (color
);
6108 frame_background
.blue
= GetBValue (color
);
6109 #endif /* HAVE_NTGUI */
6112 unsigned long color
;
6113 png_color_16 frame_background
;
6114 color
= FRAME_BACKGROUND_PIXEL (f
);
6115 #if 0 /* MAC/W32 TODO : Colormap support. */
6116 x_query_color (f
, &color
);
6118 bzero (&frame_background
, sizeof frame_background
);
6119 frame_background
.red
= RED_FROM_ULONG (color
);
6120 frame_background
.green
= GREEN_FROM_ULONG (color
);
6121 frame_background
.blue
= BLUE_FROM_ULONG (color
);
6124 fn_png_set_background (png_ptr
, &frame_background
,
6125 PNG_BACKGROUND_GAMMA_SCREEN
, 0, 1.0);
6129 /* Update info structure. */
6130 fn_png_read_update_info (png_ptr
, info_ptr
);
6132 /* Get number of channels. Valid values are 1 for grayscale images
6133 and images with a palette, 2 for grayscale images with transparency
6134 information (alpha channel), 3 for RGB images, and 4 for RGB
6135 images with alpha channel, i.e. RGBA. If conversions above were
6136 sufficient we should only have 3 or 4 channels here. */
6137 channels
= fn_png_get_channels (png_ptr
, info_ptr
);
6138 xassert (channels
== 3 || channels
== 4);
6140 /* Number of bytes needed for one row of the image. */
6141 row_bytes
= fn_png_get_rowbytes (png_ptr
, info_ptr
);
6143 /* Allocate memory for the image. */
6144 pixels
= (png_byte
*) xmalloc (row_bytes
* height
* sizeof *pixels
);
6145 rows
= (png_byte
**) xmalloc (height
* sizeof *rows
);
6146 for (i
= 0; i
< height
; ++i
)
6147 rows
[i
] = pixels
+ i
* row_bytes
;
6149 /* Read the entire image. */
6150 fn_png_read_image (png_ptr
, rows
);
6151 fn_png_read_end (png_ptr
, info_ptr
);
6158 /* Create the X image and pixmap. */
6159 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
,
6163 /* Create an image and pixmap serving as mask if the PNG image
6164 contains an alpha channel. */
6167 && !x_create_x_image_and_pixmap (f
, width
, height
, 1,
6168 &mask_img
, &img
->mask
))
6170 x_destroy_x_image (ximg
);
6171 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->pixmap
);
6172 img
->pixmap
= NO_PIXMAP
;
6176 /* Fill the X image and mask from PNG data. */
6177 init_color_table ();
6179 for (y
= 0; y
< height
; ++y
)
6181 png_byte
*p
= rows
[y
];
6183 for (x
= 0; x
< width
; ++x
)
6190 XPutPixel (ximg
, x
, y
, lookup_rgb_color (f
, r
, g
, b
));
6191 /* An alpha channel, aka mask channel, associates variable
6192 transparency with an image. Where other image formats
6193 support binary transparency---fully transparent or fully
6194 opaque---PNG allows up to 254 levels of partial transparency.
6195 The PNG library implements partial transparency by combining
6196 the image with a specified background color.
6198 I'm not sure how to handle this here nicely: because the
6199 background on which the image is displayed may change, for
6200 real alpha channel support, it would be necessary to create
6201 a new image for each possible background.
6203 What I'm doing now is that a mask is created if we have
6204 boolean transparency information. Otherwise I'm using
6205 the frame's background color to combine the image with. */
6210 XPutPixel (mask_img
, x
, y
, *p
> 0 ? PIX_MASK_DRAW
: PIX_MASK_RETAIN
);
6216 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
6217 /* Set IMG's background color from the PNG image, unless the user
6221 if (fn_png_get_bKGD (png_ptr
, info_ptr
, &bg
))
6223 img
->background
= lookup_rgb_color (f
, bg
->red
, bg
->green
, bg
->blue
);
6224 img
->background_valid
= 1;
6228 #ifdef COLOR_TABLE_SUPPORT
6229 /* Remember colors allocated for this image. */
6230 img
->colors
= colors_in_color_table (&img
->ncolors
);
6231 free_color_table ();
6232 #endif /* COLOR_TABLE_SUPPORT */
6235 fn_png_destroy_read_struct (&png_ptr
, &info_ptr
, &end_info
);
6240 img
->height
= height
;
6242 /* Maybe fill in the background field while we have ximg handy.
6243 Casting avoids a GCC warning. */
6244 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
6246 /* Put the image into the pixmap, then free the X image and its buffer. */
6247 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
6248 x_destroy_x_image (ximg
);
6250 /* Same for the mask. */
6253 /* Fill in the background_transparent field while we have the
6254 mask handy. Casting avoids a GCC warning. */
6255 image_background_transparent (img
, f
, (XImagePtr_or_DC
)mask_img
);
6257 x_put_x_image (f
, mask_img
, img
->mask
, img
->width
, img
->height
);
6258 x_destroy_x_image (mask_img
);
6265 #else /* HAVE_PNG */
6274 if (MyCGImageCreateWithPNGDataProvider
)
6275 return image_load_quartz2d (f
, img
, 1);
6278 return image_load_quicktime (f
, img
, kQTFileTypePNG
);
6282 #endif /* !HAVE_PNG */
6286 /***********************************************************************
6288 ***********************************************************************/
6290 #if defined (HAVE_JPEG) || defined (MAC_OS)
6292 static int jpeg_image_p
P_ ((Lisp_Object object
));
6293 static int jpeg_load
P_ ((struct frame
*f
, struct image
*img
));
6295 /* The symbol `jpeg' identifying images of this type. */
6299 /* Indices of image specification fields in gs_format, below. */
6301 enum jpeg_keyword_index
6310 JPEG_HEURISTIC_MASK
,
6316 /* Vector of image_keyword structures describing the format
6317 of valid user-defined image specifications. */
6319 static struct image_keyword jpeg_format
[JPEG_LAST
] =
6321 {":type", IMAGE_SYMBOL_VALUE
, 1},
6322 {":data", IMAGE_STRING_VALUE
, 0},
6323 {":file", IMAGE_STRING_VALUE
, 0},
6324 {":ascent", IMAGE_ASCENT_VALUE
, 0},
6325 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
6326 {":relief", IMAGE_INTEGER_VALUE
, 0},
6327 {":conversions", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6328 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6329 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6330 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
6333 /* Structure describing the image type `jpeg'. */
6335 static struct image_type jpeg_type
=
6344 /* Return non-zero if OBJECT is a valid JPEG image specification. */
6347 jpeg_image_p (object
)
6350 struct image_keyword fmt
[JPEG_LAST
];
6352 bcopy (jpeg_format
, fmt
, sizeof fmt
);
6354 if (!parse_image_spec (object
, fmt
, JPEG_LAST
, Qjpeg
))
6357 /* Must specify either the :data or :file keyword. */
6358 return fmt
[JPEG_FILE
].count
+ fmt
[JPEG_DATA
].count
== 1;
6361 #endif /* HAVE_JPEG || MAC_OS */
6365 /* Work around a warning about HAVE_STDLIB_H being redefined in
6367 #ifdef HAVE_STDLIB_H
6368 #define HAVE_STDLIB_H_1
6369 #undef HAVE_STDLIB_H
6370 #endif /* HAVE_STLIB_H */
6372 #if defined (HAVE_NTGUI) && !defined (__WIN32__)
6373 /* In older releases of the jpeg library, jpeglib.h will define boolean
6374 differently depending on __WIN32__, so make sure it is defined. */
6378 #include <jpeglib.h>
6382 #ifdef HAVE_STLIB_H_1
6383 #define HAVE_STDLIB_H 1
6388 /* JPEG library details. */
6389 DEF_IMGLIB_FN (jpeg_CreateDecompress
);
6390 DEF_IMGLIB_FN (jpeg_start_decompress
);
6391 DEF_IMGLIB_FN (jpeg_finish_decompress
);
6392 DEF_IMGLIB_FN (jpeg_destroy_decompress
);
6393 DEF_IMGLIB_FN (jpeg_read_header
);
6394 DEF_IMGLIB_FN (jpeg_read_scanlines
);
6395 DEF_IMGLIB_FN (jpeg_std_error
);
6396 DEF_IMGLIB_FN (jpeg_resync_to_restart
);
6399 init_jpeg_functions (Lisp_Object libraries
)
6403 if (!(library
= w32_delayed_load (libraries
, Qjpeg
)))
6406 LOAD_IMGLIB_FN (library
, jpeg_finish_decompress
);
6407 LOAD_IMGLIB_FN (library
, jpeg_read_scanlines
);
6408 LOAD_IMGLIB_FN (library
, jpeg_start_decompress
);
6409 LOAD_IMGLIB_FN (library
, jpeg_read_header
);
6410 LOAD_IMGLIB_FN (library
, jpeg_CreateDecompress
);
6411 LOAD_IMGLIB_FN (library
, jpeg_destroy_decompress
);
6412 LOAD_IMGLIB_FN (library
, jpeg_std_error
);
6413 LOAD_IMGLIB_FN (library
, jpeg_resync_to_restart
);
6417 /* Wrapper since we can't directly assign the function pointer
6418 to another function pointer that was declared more completely easily. */
6420 jpeg_resync_to_restart_wrapper(cinfo
, desired
)
6421 j_decompress_ptr cinfo
;
6424 return fn_jpeg_resync_to_restart (cinfo
, desired
);
6429 #define fn_jpeg_CreateDecompress(a,b,c) jpeg_create_decompress(a)
6430 #define fn_jpeg_start_decompress jpeg_start_decompress
6431 #define fn_jpeg_finish_decompress jpeg_finish_decompress
6432 #define fn_jpeg_destroy_decompress jpeg_destroy_decompress
6433 #define fn_jpeg_read_header jpeg_read_header
6434 #define fn_jpeg_read_scanlines jpeg_read_scanlines
6435 #define fn_jpeg_std_error jpeg_std_error
6436 #define jpeg_resync_to_restart_wrapper jpeg_resync_to_restart
6438 #endif /* HAVE_NTGUI */
6440 struct my_jpeg_error_mgr
6442 struct jpeg_error_mgr pub
;
6443 jmp_buf setjmp_buffer
;
6448 my_error_exit (cinfo
)
6451 struct my_jpeg_error_mgr
*mgr
= (struct my_jpeg_error_mgr
*) cinfo
->err
;
6452 longjmp (mgr
->setjmp_buffer
, 1);
6456 /* Init source method for JPEG data source manager. Called by
6457 jpeg_read_header() before any data is actually read. See
6458 libjpeg.doc from the JPEG lib distribution. */
6461 our_common_init_source (cinfo
)
6462 j_decompress_ptr cinfo
;
6467 /* Method to terminate data source. Called by
6468 jpeg_finish_decompress() after all data has been processed. */
6471 our_common_term_source (cinfo
)
6472 j_decompress_ptr cinfo
;
6477 /* Fill input buffer method for JPEG data source manager. Called
6478 whenever more data is needed. We read the whole image in one step,
6479 so this only adds a fake end of input marker at the end. */
6482 our_memory_fill_input_buffer (cinfo
)
6483 j_decompress_ptr cinfo
;
6485 /* Insert a fake EOI marker. */
6486 struct jpeg_source_mgr
*src
= cinfo
->src
;
6487 static JOCTET buffer
[2];
6489 buffer
[0] = (JOCTET
) 0xFF;
6490 buffer
[1] = (JOCTET
) JPEG_EOI
;
6492 src
->next_input_byte
= buffer
;
6493 src
->bytes_in_buffer
= 2;
6498 /* Method to skip over NUM_BYTES bytes in the image data. CINFO->src
6499 is the JPEG data source manager. */
6502 our_memory_skip_input_data (cinfo
, num_bytes
)
6503 j_decompress_ptr cinfo
;
6506 struct jpeg_source_mgr
*src
= (struct jpeg_source_mgr
*) cinfo
->src
;
6510 if (num_bytes
> src
->bytes_in_buffer
)
6511 ERREXIT (cinfo
, JERR_INPUT_EOF
);
6513 src
->bytes_in_buffer
-= num_bytes
;
6514 src
->next_input_byte
+= num_bytes
;
6519 /* Set up the JPEG lib for reading an image from DATA which contains
6520 LEN bytes. CINFO is the decompression info structure created for
6521 reading the image. */
6524 jpeg_memory_src (cinfo
, data
, len
)
6525 j_decompress_ptr cinfo
;
6529 struct jpeg_source_mgr
*src
;
6531 if (cinfo
->src
== NULL
)
6533 /* First time for this JPEG object? */
6534 cinfo
->src
= (struct jpeg_source_mgr
*)
6535 (*cinfo
->mem
->alloc_small
) ((j_common_ptr
) cinfo
, JPOOL_PERMANENT
,
6536 sizeof (struct jpeg_source_mgr
));
6537 src
= (struct jpeg_source_mgr
*) cinfo
->src
;
6538 src
->next_input_byte
= data
;
6541 src
= (struct jpeg_source_mgr
*) cinfo
->src
;
6542 src
->init_source
= our_common_init_source
;
6543 src
->fill_input_buffer
= our_memory_fill_input_buffer
;
6544 src
->skip_input_data
= our_memory_skip_input_data
;
6545 src
->resync_to_restart
= jpeg_resync_to_restart_wrapper
; /* Use default method. */
6546 src
->term_source
= our_common_term_source
;
6547 src
->bytes_in_buffer
= len
;
6548 src
->next_input_byte
= data
;
6552 struct jpeg_stdio_mgr
6554 struct jpeg_source_mgr mgr
;
6561 /* Size of buffer to read JPEG from file.
6562 Not too big, as we want to use alloc_small. */
6563 #define JPEG_STDIO_BUFFER_SIZE 8192
6566 /* Fill input buffer method for JPEG data source manager. Called
6567 whenever more data is needed. The data is read from a FILE *. */
6570 our_stdio_fill_input_buffer (cinfo
)
6571 j_decompress_ptr cinfo
;
6573 struct jpeg_stdio_mgr
*src
;
6575 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6580 bytes
= fread (src
->buffer
, 1, JPEG_STDIO_BUFFER_SIZE
, src
->file
);
6582 src
->mgr
.bytes_in_buffer
= bytes
;
6585 WARNMS (cinfo
, JWRN_JPEG_EOF
);
6587 src
->buffer
[0] = (JOCTET
) 0xFF;
6588 src
->buffer
[1] = (JOCTET
) JPEG_EOI
;
6589 src
->mgr
.bytes_in_buffer
= 2;
6591 src
->mgr
.next_input_byte
= src
->buffer
;
6598 /* Method to skip over NUM_BYTES bytes in the image data. CINFO->src
6599 is the JPEG data source manager. */
6602 our_stdio_skip_input_data (cinfo
, num_bytes
)
6603 j_decompress_ptr cinfo
;
6606 struct jpeg_stdio_mgr
*src
;
6607 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6609 while (num_bytes
> 0 && !src
->finished
)
6611 if (num_bytes
<= src
->mgr
.bytes_in_buffer
)
6613 src
->mgr
.bytes_in_buffer
-= num_bytes
;
6614 src
->mgr
.next_input_byte
+= num_bytes
;
6619 num_bytes
-= src
->mgr
.bytes_in_buffer
;
6620 src
->mgr
.bytes_in_buffer
= 0;
6621 src
->mgr
.next_input_byte
= NULL
;
6623 our_stdio_fill_input_buffer (cinfo
);
6629 /* Set up the JPEG lib for reading an image from a FILE *.
6630 CINFO is the decompression info structure created for
6631 reading the image. */
6634 jpeg_file_src (cinfo
, fp
)
6635 j_decompress_ptr cinfo
;
6638 struct jpeg_stdio_mgr
*src
;
6640 if (cinfo
->src
!= NULL
)
6641 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6644 /* First time for this JPEG object? */
6645 cinfo
->src
= (struct jpeg_source_mgr
*)
6646 (*cinfo
->mem
->alloc_small
) ((j_common_ptr
) cinfo
, JPOOL_PERMANENT
,
6647 sizeof (struct jpeg_stdio_mgr
));
6648 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6649 src
->buffer
= (JOCTET
*)
6650 (*cinfo
->mem
->alloc_small
) ((j_common_ptr
) cinfo
, JPOOL_PERMANENT
,
6651 JPEG_STDIO_BUFFER_SIZE
);
6656 src
->mgr
.init_source
= our_common_init_source
;
6657 src
->mgr
.fill_input_buffer
= our_stdio_fill_input_buffer
;
6658 src
->mgr
.skip_input_data
= our_stdio_skip_input_data
;
6659 src
->mgr
.resync_to_restart
= jpeg_resync_to_restart_wrapper
; /* Use default method. */
6660 src
->mgr
.term_source
= our_common_term_source
;
6661 src
->mgr
.bytes_in_buffer
= 0;
6662 src
->mgr
.next_input_byte
= NULL
;
6666 /* Load image IMG for use on frame F. Patterned after example.c
6667 from the JPEG lib. */
6674 struct jpeg_decompress_struct cinfo
;
6675 struct my_jpeg_error_mgr mgr
;
6676 Lisp_Object file
, specified_file
;
6677 Lisp_Object specified_data
;
6678 FILE * volatile fp
= NULL
;
6680 int row_stride
, x
, y
;
6681 XImagePtr ximg
= NULL
;
6683 unsigned long *colors
;
6685 struct gcpro gcpro1
;
6687 /* Open the JPEG file. */
6688 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
6689 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
6693 if (NILP (specified_data
))
6695 file
= x_find_image_file (specified_file
);
6696 if (!STRINGP (file
))
6698 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
6703 fp
= fopen (SDATA (file
), "rb");
6706 image_error ("Cannot open `%s'", file
, Qnil
);
6712 /* Customize libjpeg's error handling to call my_error_exit when an
6713 error is detected. This function will perform a longjmp.
6714 Casting return value avoids a GCC warning on W32. */
6715 cinfo
.err
= (struct jpeg_error_mgr
*)fn_jpeg_std_error (&mgr
.pub
);
6716 mgr
.pub
.error_exit
= my_error_exit
;
6718 if ((rc
= setjmp (mgr
.setjmp_buffer
)) != 0)
6722 /* Called from my_error_exit. Display a JPEG error. */
6723 char buffer
[JMSG_LENGTH_MAX
];
6724 cinfo
.err
->format_message ((j_common_ptr
) &cinfo
, buffer
);
6725 image_error ("Error reading JPEG image `%s': %s", img
->spec
,
6726 build_string (buffer
));
6729 /* Close the input file and destroy the JPEG object. */
6731 fclose ((FILE *) fp
);
6732 fn_jpeg_destroy_decompress (&cinfo
);
6734 /* If we already have an XImage, free that. */
6735 x_destroy_x_image (ximg
);
6737 /* Free pixmap and colors. */
6738 x_clear_image (f
, img
);
6744 /* Create the JPEG decompression object. Let it read from fp.
6745 Read the JPEG image header. */
6746 fn_jpeg_CreateDecompress (&cinfo
, JPEG_LIB_VERSION
, sizeof (cinfo
));
6748 if (NILP (specified_data
))
6749 jpeg_file_src (&cinfo
, (FILE *) fp
);
6751 jpeg_memory_src (&cinfo
, SDATA (specified_data
),
6752 SBYTES (specified_data
));
6754 fn_jpeg_read_header (&cinfo
, 1);
6756 /* Customize decompression so that color quantization will be used.
6757 Start decompression. */
6758 cinfo
.quantize_colors
= 1;
6759 fn_jpeg_start_decompress (&cinfo
);
6760 width
= img
->width
= cinfo
.output_width
;
6761 height
= img
->height
= cinfo
.output_height
;
6763 if (!check_image_size (f
, width
, height
))
6765 image_error ("Invalid image size", Qnil
, Qnil
);
6766 longjmp (mgr
.setjmp_buffer
, 2);
6769 /* Create X image and pixmap. */
6770 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
6771 longjmp (mgr
.setjmp_buffer
, 2);
6773 /* Allocate colors. When color quantization is used,
6774 cinfo.actual_number_of_colors has been set with the number of
6775 colors generated, and cinfo.colormap is a two-dimensional array
6776 of color indices in the range 0..cinfo.actual_number_of_colors.
6777 No more than 255 colors will be generated. */
6781 if (cinfo
.out_color_components
> 2)
6782 ir
= 0, ig
= 1, ib
= 2;
6783 else if (cinfo
.out_color_components
> 1)
6784 ir
= 0, ig
= 1, ib
= 0;
6786 ir
= 0, ig
= 0, ib
= 0;
6788 /* Use the color table mechanism because it handles colors that
6789 cannot be allocated nicely. Such colors will be replaced with
6790 a default color, and we don't have to care about which colors
6791 can be freed safely, and which can't. */
6792 init_color_table ();
6793 colors
= (unsigned long *) alloca (cinfo
.actual_number_of_colors
6796 for (i
= 0; i
< cinfo
.actual_number_of_colors
; ++i
)
6798 /* Multiply RGB values with 255 because X expects RGB values
6799 in the range 0..0xffff. */
6800 int r
= cinfo
.colormap
[ir
][i
] << 8;
6801 int g
= cinfo
.colormap
[ig
][i
] << 8;
6802 int b
= cinfo
.colormap
[ib
][i
] << 8;
6803 colors
[i
] = lookup_rgb_color (f
, r
, g
, b
);
6806 #ifdef COLOR_TABLE_SUPPORT
6807 /* Remember those colors actually allocated. */
6808 img
->colors
= colors_in_color_table (&img
->ncolors
);
6809 free_color_table ();
6810 #endif /* COLOR_TABLE_SUPPORT */
6814 row_stride
= width
* cinfo
.output_components
;
6815 buffer
= cinfo
.mem
->alloc_sarray ((j_common_ptr
) &cinfo
, JPOOL_IMAGE
,
6817 for (y
= 0; y
< height
; ++y
)
6819 fn_jpeg_read_scanlines (&cinfo
, buffer
, 1);
6820 for (x
= 0; x
< cinfo
.output_width
; ++x
)
6821 XPutPixel (ximg
, x
, y
, colors
[buffer
[0][x
]]);
6825 fn_jpeg_finish_decompress (&cinfo
);
6826 fn_jpeg_destroy_decompress (&cinfo
);
6828 fclose ((FILE *) fp
);
6830 /* Maybe fill in the background field while we have ximg handy. */
6831 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
6832 /* Casting avoids a GCC warning. */
6833 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
6835 /* Put the image into the pixmap. */
6836 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
6837 x_destroy_x_image (ximg
);
6842 #else /* HAVE_JPEG */
6851 return image_load_quartz2d (f
, img
, 0);
6853 return image_load_quicktime (f
, img
, kQTFileTypeJPEG
);
6858 #endif /* !HAVE_JPEG */
6862 /***********************************************************************
6864 ***********************************************************************/
6866 #if defined (HAVE_TIFF) || defined (MAC_OS)
6868 static int tiff_image_p
P_ ((Lisp_Object object
));
6869 static int tiff_load
P_ ((struct frame
*f
, struct image
*img
));
6871 /* The symbol `tiff' identifying images of this type. */
6875 /* Indices of image specification fields in tiff_format, below. */
6877 enum tiff_keyword_index
6886 TIFF_HEURISTIC_MASK
,
6892 /* Vector of image_keyword structures describing the format
6893 of valid user-defined image specifications. */
6895 static struct image_keyword tiff_format
[TIFF_LAST
] =
6897 {":type", IMAGE_SYMBOL_VALUE
, 1},
6898 {":data", IMAGE_STRING_VALUE
, 0},
6899 {":file", IMAGE_STRING_VALUE
, 0},
6900 {":ascent", IMAGE_ASCENT_VALUE
, 0},
6901 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
6902 {":relief", IMAGE_INTEGER_VALUE
, 0},
6903 {":conversions", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6904 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6905 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6906 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
6909 /* Structure describing the image type `tiff'. */
6911 static struct image_type tiff_type
=
6920 /* Return non-zero if OBJECT is a valid TIFF image specification. */
6923 tiff_image_p (object
)
6926 struct image_keyword fmt
[TIFF_LAST
];
6927 bcopy (tiff_format
, fmt
, sizeof fmt
);
6929 if (!parse_image_spec (object
, fmt
, TIFF_LAST
, Qtiff
))
6932 /* Must specify either the :data or :file keyword. */
6933 return fmt
[TIFF_FILE
].count
+ fmt
[TIFF_DATA
].count
== 1;
6936 #endif /* HAVE_TIFF || MAC_OS */
6944 /* TIFF library details. */
6945 DEF_IMGLIB_FN (TIFFSetErrorHandler
);
6946 DEF_IMGLIB_FN (TIFFSetWarningHandler
);
6947 DEF_IMGLIB_FN (TIFFOpen
);
6948 DEF_IMGLIB_FN (TIFFClientOpen
);
6949 DEF_IMGLIB_FN (TIFFGetField
);
6950 DEF_IMGLIB_FN (TIFFReadRGBAImage
);
6951 DEF_IMGLIB_FN (TIFFClose
);
6954 init_tiff_functions (Lisp_Object libraries
)
6958 if (!(library
= w32_delayed_load (libraries
, Qtiff
)))
6961 LOAD_IMGLIB_FN (library
, TIFFSetErrorHandler
);
6962 LOAD_IMGLIB_FN (library
, TIFFSetWarningHandler
);
6963 LOAD_IMGLIB_FN (library
, TIFFOpen
);
6964 LOAD_IMGLIB_FN (library
, TIFFClientOpen
);
6965 LOAD_IMGLIB_FN (library
, TIFFGetField
);
6966 LOAD_IMGLIB_FN (library
, TIFFReadRGBAImage
);
6967 LOAD_IMGLIB_FN (library
, TIFFClose
);
6973 #define fn_TIFFSetErrorHandler TIFFSetErrorHandler
6974 #define fn_TIFFSetWarningHandler TIFFSetWarningHandler
6975 #define fn_TIFFOpen TIFFOpen
6976 #define fn_TIFFClientOpen TIFFClientOpen
6977 #define fn_TIFFGetField TIFFGetField
6978 #define fn_TIFFReadRGBAImage TIFFReadRGBAImage
6979 #define fn_TIFFClose TIFFClose
6981 #endif /* HAVE_NTGUI */
6984 /* Reading from a memory buffer for TIFF images Based on the PNG
6985 memory source, but we have to provide a lot of extra functions.
6988 We really only need to implement read and seek, but I am not
6989 convinced that the TIFF library is smart enough not to destroy
6990 itself if we only hand it the function pointers we need to
6995 unsigned char *bytes
;
7002 tiff_read_from_memory (data
, buf
, size
)
7007 tiff_memory_source
*src
= (tiff_memory_source
*) data
;
7009 if (size
> src
->len
- src
->index
)
7011 bcopy (src
->bytes
+ src
->index
, buf
, size
);
7017 tiff_write_from_memory (data
, buf
, size
)
7026 tiff_seek_in_memory (data
, off
, whence
)
7031 tiff_memory_source
*src
= (tiff_memory_source
*) data
;
7036 case SEEK_SET
: /* Go from beginning of source. */
7040 case SEEK_END
: /* Go from end of source. */
7041 idx
= src
->len
+ off
;
7044 case SEEK_CUR
: /* Go from current position. */
7045 idx
= src
->index
+ off
;
7048 default: /* Invalid `whence'. */
7052 if (idx
> src
->len
|| idx
< 0)
7060 tiff_close_memory (data
)
7068 tiff_mmap_memory (data
, pbase
, psize
)
7073 /* It is already _IN_ memory. */
7078 tiff_unmap_memory (data
, base
, size
)
7083 /* We don't need to do this. */
7087 tiff_size_of_memory (data
)
7090 return ((tiff_memory_source
*) data
)->len
;
7095 tiff_error_handler (title
, format
, ap
)
7096 const char *title
, *format
;
7102 len
= sprintf (buf
, "TIFF error: %s ", title
);
7103 vsprintf (buf
+ len
, format
, ap
);
7104 add_to_log (buf
, Qnil
, Qnil
);
7109 tiff_warning_handler (title
, format
, ap
)
7110 const char *title
, *format
;
7116 len
= sprintf (buf
, "TIFF warning: %s ", title
);
7117 vsprintf (buf
+ len
, format
, ap
);
7118 add_to_log (buf
, Qnil
, Qnil
);
7122 /* Load TIFF image IMG for use on frame F. Value is non-zero if
7130 Lisp_Object file
, specified_file
;
7131 Lisp_Object specified_data
;
7133 int width
, height
, x
, y
;
7137 struct gcpro gcpro1
;
7138 tiff_memory_source memsrc
;
7140 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
7141 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
7145 fn_TIFFSetErrorHandler (tiff_error_handler
);
7146 fn_TIFFSetWarningHandler (tiff_warning_handler
);
7148 if (NILP (specified_data
))
7150 /* Read from a file */
7151 file
= x_find_image_file (specified_file
);
7152 if (!STRINGP (file
))
7154 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
7159 /* Try to open the image file. Casting return value avoids a
7160 GCC warning on W32. */
7161 tiff
= (TIFF
*)fn_TIFFOpen (SDATA (file
), "r");
7164 image_error ("Cannot open `%s'", file
, Qnil
);
7171 /* Memory source! */
7172 memsrc
.bytes
= SDATA (specified_data
);
7173 memsrc
.len
= SBYTES (specified_data
);
7176 /* Casting return value avoids a GCC warning on W32. */
7177 tiff
= (TIFF
*)fn_TIFFClientOpen ("memory_source", "r", &memsrc
,
7178 (TIFFReadWriteProc
) tiff_read_from_memory
,
7179 (TIFFReadWriteProc
) tiff_write_from_memory
,
7180 tiff_seek_in_memory
,
7182 tiff_size_of_memory
,
7188 image_error ("Cannot open memory source for `%s'", img
->spec
, Qnil
);
7194 /* Get width and height of the image, and allocate a raster buffer
7195 of width x height 32-bit values. */
7196 fn_TIFFGetField (tiff
, TIFFTAG_IMAGEWIDTH
, &width
);
7197 fn_TIFFGetField (tiff
, TIFFTAG_IMAGELENGTH
, &height
);
7199 if (!check_image_size (f
, width
, height
))
7201 image_error ("Invalid image size", Qnil
, Qnil
);
7206 buf
= (uint32
*) xmalloc (width
* height
* sizeof *buf
);
7208 rc
= fn_TIFFReadRGBAImage (tiff
, width
, height
, buf
, 0);
7209 fn_TIFFClose (tiff
);
7212 image_error ("Error reading TIFF image `%s'", img
->spec
, Qnil
);
7218 /* Create the X image and pixmap. */
7219 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
7226 /* Initialize the color table. */
7227 init_color_table ();
7229 /* Process the pixel raster. Origin is in the lower-left corner. */
7230 for (y
= 0; y
< height
; ++y
)
7232 uint32
*row
= buf
+ y
* width
;
7234 for (x
= 0; x
< width
; ++x
)
7236 uint32 abgr
= row
[x
];
7237 int r
= TIFFGetR (abgr
) << 8;
7238 int g
= TIFFGetG (abgr
) << 8;
7239 int b
= TIFFGetB (abgr
) << 8;
7240 XPutPixel (ximg
, x
, height
- 1 - y
, lookup_rgb_color (f
, r
, g
, b
));
7244 #ifdef COLOR_TABLE_SUPPORT
7245 /* Remember the colors allocated for the image. Free the color table. */
7246 img
->colors
= colors_in_color_table (&img
->ncolors
);
7247 free_color_table ();
7248 #endif /* COLOR_TABLE_SUPPORT */
7251 img
->height
= height
;
7253 /* Maybe fill in the background field while we have ximg handy. */
7254 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
7255 /* Casting avoids a GCC warning on W32. */
7256 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
7258 /* Put the image into the pixmap, then free the X image and its buffer. */
7259 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
7260 x_destroy_x_image (ximg
);
7267 #else /* HAVE_TIFF */
7275 return image_load_quicktime (f
, img
, kQTFileTypeTIFF
);
7279 #endif /* !HAVE_TIFF */
7283 /***********************************************************************
7285 ***********************************************************************/
7287 #if defined (HAVE_GIF) || defined (MAC_OS)
7289 static int gif_image_p
P_ ((Lisp_Object object
));
7290 static int gif_load
P_ ((struct frame
*f
, struct image
*img
));
7292 /* The symbol `gif' identifying images of this type. */
7296 /* Indices of image specification fields in gif_format, below. */
7298 enum gif_keyword_index
7314 /* Vector of image_keyword structures describing the format
7315 of valid user-defined image specifications. */
7317 static struct image_keyword gif_format
[GIF_LAST
] =
7319 {":type", IMAGE_SYMBOL_VALUE
, 1},
7320 {":data", IMAGE_STRING_VALUE
, 0},
7321 {":file", IMAGE_STRING_VALUE
, 0},
7322 {":ascent", IMAGE_ASCENT_VALUE
, 0},
7323 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
7324 {":relief", IMAGE_INTEGER_VALUE
, 0},
7325 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7326 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7327 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7328 {":image", IMAGE_NON_NEGATIVE_INTEGER_VALUE
, 0},
7329 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
7332 /* Structure describing the image type `gif'. */
7334 static struct image_type gif_type
=
7343 /* Return non-zero if OBJECT is a valid GIF image specification. */
7346 gif_image_p (object
)
7349 struct image_keyword fmt
[GIF_LAST
];
7350 bcopy (gif_format
, fmt
, sizeof fmt
);
7352 if (!parse_image_spec (object
, fmt
, GIF_LAST
, Qgif
))
7355 /* Must specify either the :data or :file keyword. */
7356 return fmt
[GIF_FILE
].count
+ fmt
[GIF_DATA
].count
== 1;
7359 #endif /* HAVE_GIF || MAC_OS */
7363 #if defined (HAVE_NTGUI) || defined (MAC_OS)
7364 /* winuser.h might define DrawText to DrawTextA or DrawTextW.
7365 Undefine before redefining to avoid a preprocessor warning. */
7369 /* avoid conflict with QuickdrawText.h */
7370 #define DrawText gif_DrawText
7371 #include <gif_lib.h>
7374 #else /* HAVE_NTGUI || MAC_OS */
7376 #include <gif_lib.h>
7378 #endif /* HAVE_NTGUI || MAC_OS */
7383 /* GIF library details. */
7384 DEF_IMGLIB_FN (DGifCloseFile
);
7385 DEF_IMGLIB_FN (DGifSlurp
);
7386 DEF_IMGLIB_FN (DGifOpen
);
7387 DEF_IMGLIB_FN (DGifOpenFileName
);
7390 init_gif_functions (Lisp_Object libraries
)
7394 if (!(library
= w32_delayed_load (libraries
, Qgif
)))
7397 LOAD_IMGLIB_FN (library
, DGifCloseFile
);
7398 LOAD_IMGLIB_FN (library
, DGifSlurp
);
7399 LOAD_IMGLIB_FN (library
, DGifOpen
);
7400 LOAD_IMGLIB_FN (library
, DGifOpenFileName
);
7406 #define fn_DGifCloseFile DGifCloseFile
7407 #define fn_DGifSlurp DGifSlurp
7408 #define fn_DGifOpen DGifOpen
7409 #define fn_DGifOpenFileName DGifOpenFileName
7411 #endif /* HAVE_NTGUI */
7413 /* Reading a GIF image from memory
7414 Based on the PNG memory stuff to a certain extent. */
7418 unsigned char *bytes
;
7424 /* Make the current memory source available to gif_read_from_memory.
7425 It's done this way because not all versions of libungif support
7426 a UserData field in the GifFileType structure. */
7427 static gif_memory_source
*current_gif_memory_src
;
7430 gif_read_from_memory (file
, buf
, len
)
7435 gif_memory_source
*src
= current_gif_memory_src
;
7437 if (len
> src
->len
- src
->index
)
7440 bcopy (src
->bytes
+ src
->index
, buf
, len
);
7446 /* Load GIF image IMG for use on frame F. Value is non-zero if
7454 Lisp_Object file
, specified_file
;
7455 Lisp_Object specified_data
;
7456 int rc
, width
, height
, x
, y
, i
;
7458 ColorMapObject
*gif_color_map
;
7459 unsigned long pixel_colors
[256];
7461 struct gcpro gcpro1
;
7463 int ino
, image_left
, image_top
, image_width
, image_height
;
7464 gif_memory_source memsrc
;
7465 unsigned char *raster
;
7467 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
7468 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
7472 if (NILP (specified_data
))
7474 file
= x_find_image_file (specified_file
);
7475 if (!STRINGP (file
))
7477 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
7482 /* Open the GIF file. Casting return value avoids a GCC warning
7484 gif
= (GifFileType
*)fn_DGifOpenFileName (SDATA (file
));
7487 image_error ("Cannot open `%s'", file
, Qnil
);
7494 /* Read from memory! */
7495 current_gif_memory_src
= &memsrc
;
7496 memsrc
.bytes
= SDATA (specified_data
);
7497 memsrc
.len
= SBYTES (specified_data
);
7500 /* Casting return value avoids a GCC warning on W32. */
7501 gif
= (GifFileType
*)fn_DGifOpen(&memsrc
, gif_read_from_memory
);
7504 image_error ("Cannot open memory source `%s'", img
->spec
, Qnil
);
7510 /* Before reading entire contents, check the declared image size. */
7511 if (!check_image_size (f
, gif
->SWidth
, gif
->SHeight
))
7513 image_error ("Invalid image size", Qnil
, Qnil
);
7514 fn_DGifCloseFile (gif
);
7519 /* Read entire contents. */
7520 rc
= fn_DGifSlurp (gif
);
7521 if (rc
== GIF_ERROR
)
7523 image_error ("Error reading `%s'", img
->spec
, Qnil
);
7524 fn_DGifCloseFile (gif
);
7529 image
= image_spec_value (img
->spec
, QCindex
, NULL
);
7530 ino
= INTEGERP (image
) ? XFASTINT (image
) : 0;
7531 if (ino
>= gif
->ImageCount
)
7533 image_error ("Invalid image number `%s' in image `%s'",
7535 fn_DGifCloseFile (gif
);
7540 image_top
= gif
->SavedImages
[ino
].ImageDesc
.Top
;
7541 image_left
= gif
->SavedImages
[ino
].ImageDesc
.Left
;
7542 image_width
= gif
->SavedImages
[ino
].ImageDesc
.Width
;
7543 image_height
= gif
->SavedImages
[ino
].ImageDesc
.Height
;
7545 width
= img
->width
= max (gif
->SWidth
,
7546 max (gif
->Image
.Left
+ gif
->Image
.Width
,
7547 image_left
+ image_width
));
7548 height
= img
->height
= max (gif
->SHeight
,
7549 max (gif
->Image
.Top
+ gif
->Image
.Height
,
7550 image_top
+ image_height
));
7552 if (!check_image_size (f
, width
, height
))
7554 image_error ("Invalid image size", Qnil
, Qnil
);
7555 fn_DGifCloseFile (gif
);
7560 /* Create the X image and pixmap. */
7561 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
7563 fn_DGifCloseFile (gif
);
7568 /* Allocate colors. */
7569 gif_color_map
= gif
->SavedImages
[ino
].ImageDesc
.ColorMap
;
7571 gif_color_map
= gif
->SColorMap
;
7572 init_color_table ();
7573 bzero (pixel_colors
, sizeof pixel_colors
);
7575 for (i
= 0; i
< gif_color_map
->ColorCount
; ++i
)
7577 int r
= gif_color_map
->Colors
[i
].Red
<< 8;
7578 int g
= gif_color_map
->Colors
[i
].Green
<< 8;
7579 int b
= gif_color_map
->Colors
[i
].Blue
<< 8;
7580 pixel_colors
[i
] = lookup_rgb_color (f
, r
, g
, b
);
7583 #ifdef COLOR_TABLE_SUPPORT
7584 img
->colors
= colors_in_color_table (&img
->ncolors
);
7585 free_color_table ();
7586 #endif /* COLOR_TABLE_SUPPORT */
7588 /* Clear the part of the screen image that are not covered by
7589 the image from the GIF file. Full animated GIF support
7590 requires more than can be done here (see the gif89 spec,
7591 disposal methods). Let's simply assume that the part
7592 not covered by a sub-image is in the frame's background color. */
7593 for (y
= 0; y
< image_top
; ++y
)
7594 for (x
= 0; x
< width
; ++x
)
7595 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7597 for (y
= image_top
+ image_height
; y
< height
; ++y
)
7598 for (x
= 0; x
< width
; ++x
)
7599 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7601 for (y
= image_top
; y
< image_top
+ image_height
; ++y
)
7603 for (x
= 0; x
< image_left
; ++x
)
7604 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7605 for (x
= image_left
+ image_width
; x
< width
; ++x
)
7606 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7609 /* Read the GIF image into the X image. We use a local variable
7610 `raster' here because RasterBits below is a char *, and invites
7611 problems with bytes >= 0x80. */
7612 raster
= (unsigned char *) gif
->SavedImages
[ino
].RasterBits
;
7614 if (gif
->SavedImages
[ino
].ImageDesc
.Interlace
)
7616 static int interlace_start
[] = {0, 4, 2, 1};
7617 static int interlace_increment
[] = {8, 8, 4, 2};
7619 int row
= interlace_start
[0];
7623 for (y
= 0; y
< image_height
; y
++)
7625 if (row
>= image_height
)
7627 row
= interlace_start
[++pass
];
7628 while (row
>= image_height
)
7629 row
= interlace_start
[++pass
];
7632 for (x
= 0; x
< image_width
; x
++)
7634 int i
= raster
[(y
* image_width
) + x
];
7635 XPutPixel (ximg
, x
+ image_left
, row
+ image_top
,
7639 row
+= interlace_increment
[pass
];
7644 for (y
= 0; y
< image_height
; ++y
)
7645 for (x
= 0; x
< image_width
; ++x
)
7647 int i
= raster
[y
* image_width
+ x
];
7648 XPutPixel (ximg
, x
+ image_left
, y
+ image_top
, pixel_colors
[i
]);
7652 fn_DGifCloseFile (gif
);
7654 /* Maybe fill in the background field while we have ximg handy. */
7655 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
7656 /* Casting avoids a GCC warning. */
7657 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
7659 /* Put the image into the pixmap, then free the X image and its buffer. */
7660 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
7661 x_destroy_x_image (ximg
);
7667 #else /* !HAVE_GIF */
7675 Lisp_Object specified_file
, file
;
7676 Lisp_Object specified_data
;
7678 Boolean graphic_p
, movie_p
, prefer_graphic_p
;
7686 Lisp_Object specified_bg
;
7692 struct gcpro gcpro1
;
7697 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
7698 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
7700 if (NILP (specified_data
))
7702 /* Read from a file */
7706 err
= find_image_fsspec (specified_file
, &file
, &fss
);
7710 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
7715 err
= CanQuickTimeOpenFile (&fss
, kQTFileTypeGIF
, 0,
7716 &graphic_p
, &movie_p
, &prefer_graphic_p
, 0);
7720 if (!graphic_p
&& !movie_p
)
7722 if (prefer_graphic_p
)
7723 return image_load_qt_1 (f
, img
, kQTFileTypeGIF
, &fss
, NULL
);
7724 err
= OpenMovieFile (&fss
, &refnum
, fsRdPerm
);
7727 err
= NewMovieFromFile (&movie
, refnum
, NULL
, NULL
, 0, NULL
);
7728 CloseMovieFile (refnum
);
7731 image_error ("Error reading `%s'", file
, Qnil
);
7737 /* Memory source! */
7739 long file_type_atom
[3];
7741 err
= PtrToHand (SDATA (specified_data
), &dh
, SBYTES (specified_data
));
7744 image_error ("Cannot allocate data handle for `%s'",
7749 file_type_atom
[0] = EndianU32_NtoB (sizeof (long) * 3);
7750 file_type_atom
[1] = EndianU32_NtoB (kDataRefExtensionMacOSFileType
);
7751 file_type_atom
[2] = EndianU32_NtoB (kQTFileTypeGIF
);
7752 err
= PtrToHand (&dh
, &dref
, sizeof (Handle
));
7755 err
= PtrAndHand ("\p", dref
, 1);
7757 err
= PtrAndHand (file_type_atom
, dref
, sizeof (long) * 3);
7760 image_error ("Cannot allocate handle data ref for `%s'", img
->spec
, Qnil
);
7763 err
= CanQuickTimeOpenDataRef (dref
, HandleDataHandlerSubType
, &graphic_p
,
7764 &movie_p
, &prefer_graphic_p
, 0);
7768 if (!graphic_p
&& !movie_p
)
7770 if (prefer_graphic_p
)
7774 DisposeHandle (dref
);
7775 success_p
= image_load_qt_1 (f
, img
, kQTFileTypeGIF
, NULL
, dh
);
7779 err
= NewMovieFromDataRef (&movie
, 0, NULL
, dref
,
7780 HandleDataHandlerSubType
);
7781 DisposeHandle (dref
);
7786 image
= image_spec_value (img
->spec
, QCindex
, NULL
);
7787 ino
= INTEGERP (image
) ? XFASTINT (image
) : 0;
7788 track
= GetMovieIndTrack (movie
, 1);
7789 media
= GetTrackMedia (track
);
7790 nsamples
= GetMediaSampleCount (media
);
7791 if (ino
>= nsamples
)
7793 image_error ("Invalid image number `%s' in image `%s'",
7798 specified_bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
7799 if (!STRINGP (specified_bg
) ||
7800 !mac_defined_color (f
, SDATA (specified_bg
), &color
, 0))
7802 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
7803 color
.red
= RED16_FROM_ULONG (color
.pixel
);
7804 color
.green
= GREEN16_FROM_ULONG (color
.pixel
);
7805 color
.blue
= BLUE16_FROM_ULONG (color
.pixel
);
7807 GetMovieBox (movie
, &rect
);
7808 width
= img
->width
= rect
.right
- rect
.left
;
7809 height
= img
->height
= rect
.bottom
- rect
.top
;
7810 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
7813 GetGWorld (&old_port
, &old_gdh
);
7814 SetGWorld (ximg
, NULL
);
7815 bg_color
.red
= color
.red
;
7816 bg_color
.green
= color
.green
;
7817 bg_color
.blue
= color
.blue
;
7818 RGBBackColor (&bg_color
);
7819 SetGWorld (old_port
, old_gdh
);
7820 SetMovieActive (movie
, 1);
7821 SetMovieGWorld (movie
, ximg
, NULL
);
7822 SampleNumToMediaTime (media
, ino
+ 1, &time
, NULL
);
7823 SetMovieTimeValue (movie
, time
);
7824 MoviesTask (movie
, 0L);
7825 DisposeTrackMedia (media
);
7826 DisposeMovieTrack (track
);
7827 DisposeMovie (movie
);
7830 /* Maybe fill in the background field while we have ximg handy. */
7831 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
7832 IMAGE_BACKGROUND (img
, f
, ximg
);
7834 /* Put the image into the pixmap. */
7835 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
7836 x_destroy_x_image (ximg
);
7840 image_error ("Cannot open `%s'", file
, Qnil
);
7843 DisposeTrackMedia (media
);
7845 DisposeMovieTrack (track
);
7847 DisposeMovie (movie
);
7854 #endif /* HAVE_GIF */
7858 /***********************************************************************
7860 ***********************************************************************/
7862 #ifdef HAVE_X_WINDOWS
7863 #define HAVE_GHOSTSCRIPT 1
7864 #endif /* HAVE_X_WINDOWS */
7866 /* The symbol `postscript' identifying images of this type. */
7868 Lisp_Object Qpostscript
;
7870 #ifdef HAVE_GHOSTSCRIPT
7872 static int gs_image_p
P_ ((Lisp_Object object
));
7873 static int gs_load
P_ ((struct frame
*f
, struct image
*img
));
7874 static void gs_clear_image
P_ ((struct frame
*f
, struct image
*img
));
7876 /* Keyword symbols. */
7878 Lisp_Object QCloader
, QCbounding_box
, QCpt_width
, QCpt_height
;
7880 /* Indices of image specification fields in gs_format, below. */
7882 enum gs_keyword_index
7900 /* Vector of image_keyword structures describing the format
7901 of valid user-defined image specifications. */
7903 static struct image_keyword gs_format
[GS_LAST
] =
7905 {":type", IMAGE_SYMBOL_VALUE
, 1},
7906 {":pt-width", IMAGE_POSITIVE_INTEGER_VALUE
, 1},
7907 {":pt-height", IMAGE_POSITIVE_INTEGER_VALUE
, 1},
7908 {":file", IMAGE_STRING_VALUE
, 1},
7909 {":loader", IMAGE_FUNCTION_VALUE
, 0},
7910 {":bounding-box", IMAGE_DONT_CHECK_VALUE_TYPE
, 1},
7911 {":ascent", IMAGE_ASCENT_VALUE
, 0},
7912 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
7913 {":relief", IMAGE_INTEGER_VALUE
, 0},
7914 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7915 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7916 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7917 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
7920 /* Structure describing the image type `ghostscript'. */
7922 static struct image_type gs_type
=
7932 /* Free X resources of Ghostscript image IMG which is used on frame F. */
7935 gs_clear_image (f
, img
)
7939 /* IMG->data.ptr_val may contain a recorded colormap. */
7940 xfree (img
->data
.ptr_val
);
7941 x_clear_image (f
, img
);
7945 /* Return non-zero if OBJECT is a valid Ghostscript image
7952 struct image_keyword fmt
[GS_LAST
];
7956 bcopy (gs_format
, fmt
, sizeof fmt
);
7958 if (!parse_image_spec (object
, fmt
, GS_LAST
, Qpostscript
))
7961 /* Bounding box must be a list or vector containing 4 integers. */
7962 tem
= fmt
[GS_BOUNDING_BOX
].value
;
7965 for (i
= 0; i
< 4; ++i
, tem
= XCDR (tem
))
7966 if (!CONSP (tem
) || !INTEGERP (XCAR (tem
)))
7971 else if (VECTORP (tem
))
7973 if (XVECTOR (tem
)->size
!= 4)
7975 for (i
= 0; i
< 4; ++i
)
7976 if (!INTEGERP (XVECTOR (tem
)->contents
[i
]))
7986 /* Load Ghostscript image IMG for use on frame F. Value is non-zero
7995 Lisp_Object window_and_pixmap_id
= Qnil
, loader
, pt_height
, pt_width
;
7996 struct gcpro gcpro1
, gcpro2
;
7998 double in_width
, in_height
;
7999 Lisp_Object pixel_colors
= Qnil
;
8001 /* Compute pixel size of pixmap needed from the given size in the
8002 image specification. Sizes in the specification are in pt. 1 pt
8003 = 1/72 in, xdpi and ydpi are stored in the frame's X display
8005 pt_width
= image_spec_value (img
->spec
, QCpt_width
, NULL
);
8006 in_width
= XFASTINT (pt_width
) / 72.0;
8007 img
->width
= in_width
* FRAME_X_DISPLAY_INFO (f
)->resx
;
8008 pt_height
= image_spec_value (img
->spec
, QCpt_height
, NULL
);
8009 in_height
= XFASTINT (pt_height
) / 72.0;
8010 img
->height
= in_height
* FRAME_X_DISPLAY_INFO (f
)->resy
;
8012 if (!check_image_size (f
, img
->width
, img
->height
))
8014 image_error ("Invalid image size", Qnil
, Qnil
);
8018 /* Create the pixmap. */
8019 xassert (img
->pixmap
== NO_PIXMAP
);
8021 /* Only W32 version did BLOCK_INPUT here. ++kfs */
8023 img
->pixmap
= XCreatePixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
8024 img
->width
, img
->height
,
8025 DefaultDepthOfScreen (FRAME_X_SCREEN (f
)));
8030 image_error ("Unable to create pixmap for `%s'", img
->spec
, Qnil
);
8034 /* Call the loader to fill the pixmap. It returns a process object
8035 if successful. We do not record_unwind_protect here because
8036 other places in redisplay like calling window scroll functions
8037 don't either. Let the Lisp loader use `unwind-protect' instead. */
8038 GCPRO2 (window_and_pixmap_id
, pixel_colors
);
8040 sprintf (buffer
, "%lu %lu",
8041 (unsigned long) FRAME_X_WINDOW (f
),
8042 (unsigned long) img
->pixmap
);
8043 window_and_pixmap_id
= build_string (buffer
);
8045 sprintf (buffer
, "%lu %lu",
8046 FRAME_FOREGROUND_PIXEL (f
),
8047 FRAME_BACKGROUND_PIXEL (f
));
8048 pixel_colors
= build_string (buffer
);
8050 XSETFRAME (frame
, f
);
8051 loader
= image_spec_value (img
->spec
, QCloader
, NULL
);
8053 loader
= intern ("gs-load-image");
8055 img
->data
.lisp_val
= call6 (loader
, frame
, img
->spec
,
8056 make_number (img
->width
),
8057 make_number (img
->height
),
8058 window_and_pixmap_id
,
8061 return PROCESSP (img
->data
.lisp_val
);
8065 /* Kill the Ghostscript process that was started to fill PIXMAP on
8066 frame F. Called from XTread_socket when receiving an event
8067 telling Emacs that Ghostscript has finished drawing. */
8070 x_kill_gs_process (pixmap
, f
)
8074 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
8078 /* Find the image containing PIXMAP. */
8079 for (i
= 0; i
< c
->used
; ++i
)
8080 if (c
->images
[i
]->pixmap
== pixmap
)
8083 /* Should someone in between have cleared the image cache, for
8084 instance, give up. */
8088 /* Kill the GS process. We should have found PIXMAP in the image
8089 cache and its image should contain a process object. */
8091 xassert (PROCESSP (img
->data
.lisp_val
));
8092 Fkill_process (img
->data
.lisp_val
, Qnil
);
8093 img
->data
.lisp_val
= Qnil
;
8095 #if defined (HAVE_X_WINDOWS)
8097 /* On displays with a mutable colormap, figure out the colors
8098 allocated for the image by looking at the pixels of an XImage for
8100 class = FRAME_X_VISUAL (f
)->class;
8101 if (class != StaticColor
&& class != StaticGray
&& class != TrueColor
)
8107 /* Try to get an XImage for img->pixmep. */
8108 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
8109 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
8114 /* Initialize the color table. */
8115 init_color_table ();
8117 /* For each pixel of the image, look its color up in the
8118 color table. After having done so, the color table will
8119 contain an entry for each color used by the image. */
8120 for (y
= 0; y
< img
->height
; ++y
)
8121 for (x
= 0; x
< img
->width
; ++x
)
8123 unsigned long pixel
= XGetPixel (ximg
, x
, y
);
8124 lookup_pixel_color (f
, pixel
);
8127 /* Record colors in the image. Free color table and XImage. */
8128 #ifdef COLOR_TABLE_SUPPORT
8129 img
->colors
= colors_in_color_table (&img
->ncolors
);
8130 free_color_table ();
8132 XDestroyImage (ximg
);
8134 #if 0 /* This doesn't seem to be the case. If we free the colors
8135 here, we get a BadAccess later in x_clear_image when
8136 freeing the colors. */
8137 /* We have allocated colors once, but Ghostscript has also
8138 allocated colors on behalf of us. So, to get the
8139 reference counts right, free them once. */
8141 x_free_colors (f
, img
->colors
, img
->ncolors
);
8145 image_error ("Cannot get X image of `%s'; colors will not be freed",
8150 #endif /* HAVE_X_WINDOWS */
8152 /* Now that we have the pixmap, compute mask and transform the
8153 image if requested. */
8155 postprocess_image (f
, img
);
8159 #endif /* HAVE_GHOSTSCRIPT */
8162 /***********************************************************************
8164 ***********************************************************************/
8168 DEFUN ("imagep", Fimagep
, Simagep
, 1, 1, 0,
8169 doc
: /* Value is non-nil if SPEC is a valid image specification. */)
8173 return valid_image_p (spec
) ? Qt
: Qnil
;
8177 DEFUN ("lookup-image", Flookup_image
, Slookup_image
, 1, 1, 0, "")
8183 if (valid_image_p (spec
))
8184 id
= lookup_image (SELECTED_FRAME (), spec
);
8187 return make_number (id
);
8190 #endif /* GLYPH_DEBUG != 0 */
8193 /***********************************************************************
8195 ***********************************************************************/
8198 /* Image types that rely on external libraries are loaded dynamically
8199 if the library is available. */
8200 #define CHECK_LIB_AVAILABLE(image_type, init_lib_fn, libraries) \
8201 define_image_type (image_type, init_lib_fn (libraries))
8203 #define CHECK_LIB_AVAILABLE(image_type, init_lib_fn, libraries) \
8204 define_image_type (image_type, 1)
8205 #endif /* HAVE_NTGUI */
8207 DEFUN ("init-image-library", Finit_image_library
, Sinit_image_library
, 2, 2, 0,
8208 doc
: /* Initialize image library implementing image type TYPE.
8209 Return non-nil if TYPE is a supported image type.
8211 Image types pbm and xbm are prebuilt; other types are loaded here.
8212 Libraries to load are specified in alist LIBRARIES (usually, the value
8213 of `image-library-alist', which see). */)
8215 Lisp_Object type
, libraries
;
8219 /* Don't try to reload the library. */
8220 tested
= Fassq (type
, Vimage_type_cache
);
8222 return XCDR (tested
);
8224 #if defined (HAVE_XPM) || defined (MAC_OS)
8225 if (EQ (type
, Qxpm
))
8226 return CHECK_LIB_AVAILABLE (&xpm_type
, init_xpm_functions
, libraries
);
8229 #if defined (HAVE_JPEG) || defined (MAC_OS)
8230 if (EQ (type
, Qjpeg
))
8231 return CHECK_LIB_AVAILABLE (&jpeg_type
, init_jpeg_functions
, libraries
);
8234 #if defined (HAVE_TIFF) || defined (MAC_OS)
8235 if (EQ (type
, Qtiff
))
8236 return CHECK_LIB_AVAILABLE (&tiff_type
, init_tiff_functions
, libraries
);
8239 #if defined (HAVE_GIF) || defined (MAC_OS)
8240 if (EQ (type
, Qgif
))
8241 return CHECK_LIB_AVAILABLE (&gif_type
, init_gif_functions
, libraries
);
8244 #if defined (HAVE_PNG) || defined (MAC_OS)
8245 if (EQ (type
, Qpng
))
8246 return CHECK_LIB_AVAILABLE (&png_type
, init_png_functions
, libraries
);
8249 #ifdef HAVE_GHOSTSCRIPT
8250 if (EQ (type
, Qpostscript
))
8251 return CHECK_LIB_AVAILABLE (&gs_type
, init_gs_functions
, libraries
);
8254 /* If the type is not recognized, avoid testing it ever again. */
8255 CACHE_IMAGE_TYPE (type
, Qnil
);
8262 extern Lisp_Object Qrisky_local_variable
; /* Syms_of_xdisp has already run. */
8264 /* Initialize this only once, since that's what we do with Vimage_types
8265 and they are supposed to be in sync. Initializing here gives correct
8266 operation on GNU/Linux of calling dump-emacs after loading some images. */
8269 /* Must be defined now becase we're going to update it below, while
8270 defining the supported image types. */
8271 DEFVAR_LISP ("image-types", &Vimage_types
,
8272 doc
: /* List of potentially supported image types.
8273 Each element of the list is a symbol for a image type, like 'jpeg or 'png.
8274 To check whether it is really supported, use `image-type-available-p'. */);
8275 Vimage_types
= Qnil
;
8277 DEFVAR_LISP ("image-library-alist", &Vimage_library_alist
,
8278 doc
: /* Alist of image types vs external libraries needed to display them.
8280 Each element is a list (IMAGE-TYPE LIBRARY...), where the car is a symbol
8281 representing a supported image type, and the rest are strings giving
8282 alternate filenames for the corresponding external libraries.
8284 Emacs tries to load the libraries in the order they appear on the
8285 list; if none is loaded, the running session of Emacs won't
8286 support the image type. Types 'pbm and 'xbm don't need to be
8287 listed; they're always supported. */);
8288 Vimage_library_alist
= Qnil
;
8289 Fput (intern ("image-library-alist"), Qrisky_local_variable
, Qt
);
8291 DEFVAR_LISP ("max-image-size", &Vmax_image_size
,
8292 doc
: /* Maximum size of an image, relative to the selected frame.
8294 This is a floating point number that is multiplied by the width and
8295 height of the selected frame, to give the maximum width and height for
8296 images. Emacs will not load an image into memory if its width or
8297 height exceeds this limit. */);
8298 Vmax_image_size
= make_float (MAX_IMAGE_SIZE
);
8300 Vimage_type_cache
= Qnil
;
8301 staticpro (&Vimage_type_cache
);
8303 Qpbm
= intern ("pbm");
8305 ADD_IMAGE_TYPE(Qpbm
);
8307 Qxbm
= intern ("xbm");
8309 ADD_IMAGE_TYPE(Qxbm
);
8311 define_image_type (&xbm_type
, 1);
8312 define_image_type (&pbm_type
, 1);
8314 QCascent
= intern (":ascent");
8315 staticpro (&QCascent
);
8316 QCmargin
= intern (":margin");
8317 staticpro (&QCmargin
);
8318 QCrelief
= intern (":relief");
8319 staticpro (&QCrelief
);
8320 QCconversion
= intern (":conversion");
8321 staticpro (&QCconversion
);
8322 QCcolor_symbols
= intern (":color-symbols");
8323 staticpro (&QCcolor_symbols
);
8324 QCheuristic_mask
= intern (":heuristic-mask");
8325 staticpro (&QCheuristic_mask
);
8326 QCindex
= intern (":index");
8327 staticpro (&QCindex
);
8328 QCmatrix
= intern (":matrix");
8329 staticpro (&QCmatrix
);
8330 QCcolor_adjustment
= intern (":color-adjustment");
8331 staticpro (&QCcolor_adjustment
);
8332 QCmask
= intern (":mask");
8333 staticpro (&QCmask
);
8335 Qlaplace
= intern ("laplace");
8336 staticpro (&Qlaplace
);
8337 Qemboss
= intern ("emboss");
8338 staticpro (&Qemboss
);
8339 Qedge_detection
= intern ("edge-detection");
8340 staticpro (&Qedge_detection
);
8341 Qheuristic
= intern ("heuristic");
8342 staticpro (&Qheuristic
);
8344 Qpostscript
= intern ("postscript");
8345 staticpro (&Qpostscript
);
8346 #ifdef HAVE_GHOSTSCRIPT
8347 ADD_IMAGE_TYPE(Qpostscript
);
8348 QCloader
= intern (":loader");
8349 staticpro (&QCloader
);
8350 QCbounding_box
= intern (":bounding-box");
8351 staticpro (&QCbounding_box
);
8352 QCpt_width
= intern (":pt-width");
8353 staticpro (&QCpt_width
);
8354 QCpt_height
= intern (":pt-height");
8355 staticpro (&QCpt_height
);
8356 #endif /* HAVE_GHOSTSCRIPT */
8358 #if defined (HAVE_XPM) || defined (MAC_OS)
8359 Qxpm
= intern ("xpm");
8361 ADD_IMAGE_TYPE(Qxpm
);
8364 #if defined (HAVE_JPEG) || defined (MAC_OS)
8365 Qjpeg
= intern ("jpeg");
8367 ADD_IMAGE_TYPE(Qjpeg
);
8370 #if defined (HAVE_TIFF) || defined (MAC_OS)
8371 Qtiff
= intern ("tiff");
8373 ADD_IMAGE_TYPE(Qtiff
);
8376 #if defined (HAVE_GIF) || defined (MAC_OS)
8377 Qgif
= intern ("gif");
8379 ADD_IMAGE_TYPE(Qgif
);
8382 #if defined (HAVE_PNG) || defined (MAC_OS)
8383 Qpng
= intern ("png");
8385 ADD_IMAGE_TYPE(Qpng
);
8388 defsubr (&Sinit_image_library
);
8389 defsubr (&Sclear_image_cache
);
8390 defsubr (&Simage_size
);
8391 defsubr (&Simage_mask_p
);
8395 defsubr (&Slookup_image
);
8398 DEFVAR_BOOL ("cross-disabled-images", &cross_disabled_images
,
8399 doc
: /* Non-nil means always draw a cross over disabled images.
8400 Disabled images are those having an `:conversion disabled' property.
8401 A cross is always drawn on black & white displays. */);
8402 cross_disabled_images
= 0;
8404 DEFVAR_LISP ("x-bitmap-file-path", &Vx_bitmap_file_path
,
8405 doc
: /* List of directories to search for window system bitmap files. */);
8406 Vx_bitmap_file_path
= decode_env_path ((char *) 0, PATH_BITMAPS
);
8408 DEFVAR_LISP ("image-cache-eviction-delay", &Vimage_cache_eviction_delay
,
8409 doc
: /* Time after which cached images are removed from the cache.
8410 When an image has not been displayed this many seconds, remove it
8411 from the image cache. Value must be an integer or nil with nil
8412 meaning don't clear the cache. */);
8413 Vimage_cache_eviction_delay
= make_number (30 * 60);
8420 /* Animated gifs use QuickTime Movie Toolbox. So initialize it here. */
8423 init_image_func_pointer ();
8428 /* arch-tag: 123c2a5e-14a8-4c53-ab95-af47d7db49b9
8429 (do not change this comment) */