1 /* Functions for image support on window system.
2 Copyright (C) 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
20 Boston, MA 02110-1301, USA. */
31 /* This makes the fields of a Display accessible, in Xlib header files. */
33 #define XLIB_ILLEGAL_ACCESS
38 #include "dispextern.h"
39 #include "blockinput.h"
46 #include <sys/types.h>
49 #define COLOR_TABLE_SUPPORT 1
51 typedef struct x_bitmap_record Bitmap_Record
;
52 #define GET_PIXEL(ximg, x, y) XGetPixel(ximg, x, y)
53 #define NO_PIXMAP None
55 #define RGB_PIXEL_COLOR unsigned long
57 #define PIX_MASK_RETAIN 0
58 #define PIX_MASK_DRAW 1
59 #endif /* HAVE_X_WINDOWS */
65 /* W32_TODO : Color tables on W32. */
66 #undef COLOR_TABLE_SUPPORT
68 typedef struct w32_bitmap_record Bitmap_Record
;
69 #define GET_PIXEL(ximg, x, y) GetPixel(ximg, x, y)
72 #define RGB_PIXEL_COLOR COLORREF
74 #define PIX_MASK_RETAIN 0
75 #define PIX_MASK_DRAW 1
77 #define FRAME_X_VISUAL(f) FRAME_X_DISPLAY_INFO (f)->visual
78 #define x_defined_color w32_defined_color
79 #define DefaultDepthOfScreen(screen) (one_w32_display_info.n_cbits)
80 #endif /* HAVE_NTGUI */
88 #include <sys/param.h>
90 #if TARGET_API_MAC_CARBON
92 #include <QuickTime/QuickTime.h>
93 #else /* not MAC_OSX */
94 #include <QuickTime.h>
95 #endif /* not MAC_OSX */
96 #else /* not TARGET_API_MAC_CARBON */
99 #include <TextUtils.h>
100 #include <ImageCompression.h>
101 #include <QuickTimeComponents.h>
102 #endif /* not TARGET_API_MAC_CARBON */
104 /* MAC_TODO : Color tables on Mac. */
105 #undef COLOR_TABLE_SUPPORT
107 #define ZPixmap 0 /* arbitrary */
108 typedef struct mac_bitmap_record Bitmap_Record
;
110 #define GET_PIXEL(ximg, x, y) XGetPixel(ximg, x, y)
113 #define RGB_PIXEL_COLOR unsigned long
115 /* A black pixel in a mask bitmap/pixmap means ``draw a source
116 pixel''. A white pixel means ``retain the current pixel''. */
117 #define PIX_MASK_DRAW RGB_TO_ULONG(0,0,0)
118 #define PIX_MASK_RETAIN RGB_TO_ULONG(255,255,255)
120 #define FRAME_X_VISUAL(f) FRAME_X_DISPLAY_INFO (f)->visual
121 #define x_defined_color mac_defined_color
122 #define DefaultDepthOfScreen(screen) (one_mac_display_info.n_planes)
123 #define XDrawLine(display, w, gc, x1, y1, x2, y2) \
124 mac_draw_line_to_pixmap(display, w, gc, x1, y1, x2, y2)
129 /* Search path for bitmap files. */
131 Lisp_Object Vx_bitmap_file_path
;
134 static void x_disable_image
P_ ((struct frame
*, struct image
*));
135 static void x_edge_detection
P_ ((struct frame
*, struct image
*, Lisp_Object
,
138 static void init_color_table
P_ ((void));
139 static unsigned long lookup_rgb_color
P_ ((struct frame
*f
, int r
, int g
, int b
));
140 #ifdef COLOR_TABLE_SUPPORT
141 static void free_color_table
P_ ((void));
142 static unsigned long *colors_in_color_table
P_ ((int *n
));
143 static unsigned long lookup_pixel_color
P_ ((struct frame
*f
, unsigned long p
));
146 /* Code to deal with bitmaps. Bitmaps are referenced by their bitmap
147 id, which is just an int that this section returns. Bitmaps are
148 reference counted so they can be shared among frames.
150 Bitmap indices are guaranteed to be > 0, so a negative number can
151 be used to indicate no bitmap.
153 If you use x_create_bitmap_from_data, then you must keep track of
154 the bitmaps yourself. That is, creating a bitmap from the same
155 data more than once will not be caught. */
160 XGetImage (display
, pixmap
, x
, y
, width
, height
, plane_mask
, format
)
161 Display
*display
; /* not used */
163 int x
, y
; /* not used */
164 unsigned int width
, height
; /* not used */
165 unsigned long plane_mask
; /* not used */
166 int format
; /* not used */
169 xassert (x
== 0 && y
== 0);
172 SetRect (&ri
, 0, 0, width
, height
);
173 xassert (EqualRect (&ri
, GetPixBounds (GetGWorldPixMap (pixmap
), &rp
)));
175 xassert (! (pixelsLocked
& GetPixelsState (GetGWorldPixMap (pixmap
))));
178 LockPixels (GetGWorldPixMap (pixmap
));
184 XPutPixel (ximage
, x
, y
, pixel
)
189 PixMapHandle pixmap
= GetGWorldPixMap (ximage
);
190 short depth
= GetPixDepth (pixmap
);
194 char *base_addr
= GetPixBaseAddr (pixmap
);
195 short row_bytes
= GetPixRowBytes (pixmap
);
197 ((unsigned long *) (base_addr
+ y
* row_bytes
))[x
] = pixel
;
201 char *base_addr
= GetPixBaseAddr (pixmap
);
202 short row_bytes
= GetPixRowBytes (pixmap
);
204 if (pixel
== PIX_MASK_DRAW
)
205 base_addr
[y
* row_bytes
+ x
/ 8] |= (1 << 7) >> (x
& 7);
207 base_addr
[y
* row_bytes
+ x
/ 8] &= ~((1 << 7) >> (x
& 7));
215 GetGWorld (&old_port
, &old_gdh
);
216 SetGWorld (ximage
, NULL
);
218 color
.red
= RED16_FROM_ULONG (pixel
);
219 color
.green
= GREEN16_FROM_ULONG (pixel
);
220 color
.blue
= BLUE16_FROM_ULONG (pixel
);
222 SetCPixel (x
, y
, &color
);
224 SetGWorld (old_port
, old_gdh
);
229 XGetPixel (ximage
, x
, y
)
233 PixMapHandle pixmap
= GetGWorldPixMap (ximage
);
234 short depth
= GetPixDepth (pixmap
);
238 char *base_addr
= GetPixBaseAddr (pixmap
);
239 short row_bytes
= GetPixRowBytes (pixmap
);
241 return ((unsigned long *) (base_addr
+ y
* row_bytes
))[x
];
245 char *base_addr
= GetPixBaseAddr (pixmap
);
246 short row_bytes
= GetPixRowBytes (pixmap
);
248 if (base_addr
[y
* row_bytes
+ x
/ 8] & (1 << (~x
& 7)))
249 return PIX_MASK_DRAW
;
251 return PIX_MASK_RETAIN
;
259 GetGWorld (&old_port
, &old_gdh
);
260 SetGWorld (ximage
, NULL
);
262 GetCPixel (x
, y
, &color
);
264 SetGWorld (old_port
, old_gdh
);
265 return RGB_TO_ULONG (color
.red
>> 8, color
.green
>> 8, color
.blue
>> 8);
273 UnlockPixels (GetGWorldPixMap (ximg
));
278 /* Functions to access the contents of a bitmap, given an id. */
281 x_bitmap_height (f
, id
)
285 return FRAME_X_DISPLAY_INFO (f
)->bitmaps
[id
- 1].height
;
289 x_bitmap_width (f
, id
)
293 return FRAME_X_DISPLAY_INFO (f
)->bitmaps
[id
- 1].width
;
296 #if defined (HAVE_X_WINDOWS) || defined (HAVE_NTGUI)
298 x_bitmap_pixmap (f
, id
)
302 return (int) FRAME_X_DISPLAY_INFO (f
)->bitmaps
[id
- 1].pixmap
;
306 #ifdef HAVE_X_WINDOWS
308 x_bitmap_mask (f
, id
)
312 return FRAME_X_DISPLAY_INFO (f
)->bitmaps
[id
- 1].mask
;
316 /* Allocate a new bitmap record. Returns index of new record. */
319 x_allocate_bitmap_record (f
)
322 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
325 if (dpyinfo
->bitmaps
== NULL
)
327 dpyinfo
->bitmaps_size
= 10;
329 = (Bitmap_Record
*) xmalloc (dpyinfo
->bitmaps_size
* sizeof (Bitmap_Record
));
330 dpyinfo
->bitmaps_last
= 1;
334 if (dpyinfo
->bitmaps_last
< dpyinfo
->bitmaps_size
)
335 return ++dpyinfo
->bitmaps_last
;
337 for (i
= 0; i
< dpyinfo
->bitmaps_size
; ++i
)
338 if (dpyinfo
->bitmaps
[i
].refcount
== 0)
341 dpyinfo
->bitmaps_size
*= 2;
343 = (Bitmap_Record
*) xrealloc (dpyinfo
->bitmaps
,
344 dpyinfo
->bitmaps_size
* sizeof (Bitmap_Record
));
345 return ++dpyinfo
->bitmaps_last
;
348 /* Add one reference to the reference count of the bitmap with id ID. */
351 x_reference_bitmap (f
, id
)
355 ++FRAME_X_DISPLAY_INFO (f
)->bitmaps
[id
- 1].refcount
;
358 /* Create a bitmap for frame F from a HEIGHT x WIDTH array of bits at BITS. */
361 x_create_bitmap_from_data (f
, bits
, width
, height
)
364 unsigned int width
, height
;
366 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
369 #ifdef HAVE_X_WINDOWS
371 bitmap
= XCreateBitmapFromData (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
372 bits
, width
, height
);
375 #endif /* HAVE_X_WINDOWS */
379 bitmap
= CreateBitmap (width
, height
,
380 FRAME_X_DISPLAY_INFO (XFRAME (frame
))->n_planes
,
381 FRAME_X_DISPLAY_INFO (XFRAME (frame
))->n_cbits
,
385 #endif /* HAVE_NTGUI */
388 /* MAC_TODO: for now fail if width is not mod 16 (toolbox requires it) */
393 id
= x_allocate_bitmap_record (f
);
395 dpyinfo
->bitmaps
[id
- 1].bitmap_data
= (char *) xmalloc (height
* width
);
396 if (! dpyinfo
->bitmaps
[id
- 1].bitmap_data
)
398 bcopy (bits
, dpyinfo
->bitmaps
[id
- 1].bitmap_data
, height
* width
);
401 dpyinfo
->bitmaps
[id
- 1].file
= NULL
;
402 dpyinfo
->bitmaps
[id
- 1].height
= height
;
403 dpyinfo
->bitmaps
[id
- 1].width
= width
;
404 dpyinfo
->bitmaps
[id
- 1].refcount
= 1;
406 #ifdef HAVE_X_WINDOWS
407 dpyinfo
->bitmaps
[id
- 1].pixmap
= bitmap
;
408 dpyinfo
->bitmaps
[id
- 1].have_mask
= 0;
409 dpyinfo
->bitmaps
[id
- 1].depth
= 1;
410 #endif /* HAVE_X_WINDOWS */
413 dpyinfo
->bitmaps
[id
- 1].pixmap
= bitmap
;
414 dpyinfo
->bitmaps
[id
- 1].hinst
= NULL
;
415 dpyinfo
->bitmaps
[id
- 1].depth
= 1;
416 #endif /* HAVE_NTGUI */
421 /* Create bitmap from file FILE for frame F. */
424 x_create_bitmap_from_file (f
, file
)
429 return -1; /* MAC_TODO : bitmap support */
433 return -1; /* W32_TODO : bitmap support */
434 #endif /* HAVE_NTGUI */
436 #ifdef HAVE_X_WINDOWS
437 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
438 unsigned int width
, height
;
440 int xhot
, yhot
, result
, id
;
445 /* Look for an existing bitmap with the same name. */
446 for (id
= 0; id
< dpyinfo
->bitmaps_last
; ++id
)
448 if (dpyinfo
->bitmaps
[id
].refcount
449 && dpyinfo
->bitmaps
[id
].file
450 && !strcmp (dpyinfo
->bitmaps
[id
].file
, (char *) SDATA (file
)))
452 ++dpyinfo
->bitmaps
[id
].refcount
;
457 /* Search bitmap-file-path for the file, if appropriate. */
458 fd
= openp (Vx_bitmap_file_path
, file
, Qnil
, &found
, Qnil
);
463 filename
= (char *) SDATA (found
);
465 result
= XReadBitmapFile (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
466 filename
, &width
, &height
, &bitmap
, &xhot
, &yhot
);
467 if (result
!= BitmapSuccess
)
470 id
= x_allocate_bitmap_record (f
);
471 dpyinfo
->bitmaps
[id
- 1].pixmap
= bitmap
;
472 dpyinfo
->bitmaps
[id
- 1].have_mask
= 0;
473 dpyinfo
->bitmaps
[id
- 1].refcount
= 1;
474 dpyinfo
->bitmaps
[id
- 1].file
= (char *) xmalloc (SBYTES (file
) + 1);
475 dpyinfo
->bitmaps
[id
- 1].depth
= 1;
476 dpyinfo
->bitmaps
[id
- 1].height
= height
;
477 dpyinfo
->bitmaps
[id
- 1].width
= width
;
478 strcpy (dpyinfo
->bitmaps
[id
- 1].file
, SDATA (file
));
481 #endif /* HAVE_X_WINDOWS */
487 Free_Bitmap_Record (dpyinfo
, bm
)
488 Display_Info
*dpyinfo
;
491 #ifdef HAVE_X_WINDOWS
492 XFreePixmap (dpyinfo
->display
, bm
->pixmap
);
494 XFreePixmap (dpyinfo
->display
, bm
->mask
);
495 #endif /* HAVE_X_WINDOWS */
498 DeleteObject (bm
->pixmap
);
499 #endif /* HAVE_NTGUI */
502 xfree (bm
->bitmap_data
); /* Added ++kfs */
503 bm
->bitmap_data
= NULL
;
513 /* Remove reference to bitmap with id number ID. */
516 x_destroy_bitmap (f
, id
)
520 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
524 Bitmap_Record
*bm
= &dpyinfo
->bitmaps
[id
- 1];
526 if (--bm
->refcount
== 0)
529 Free_Bitmap_Record (dpyinfo
, bm
);
535 /* Free all the bitmaps for the display specified by DPYINFO. */
538 x_destroy_all_bitmaps (dpyinfo
)
539 Display_Info
*dpyinfo
;
542 Bitmap_Record
*bm
= dpyinfo
->bitmaps
;
544 for (i
= 0; i
< dpyinfo
->bitmaps_last
; i
++, bm
++)
545 if (bm
->refcount
> 0)
546 Free_Bitmap_Record (dpyinfo
, bm
);
548 dpyinfo
->bitmaps_last
= 0;
552 #ifdef HAVE_X_WINDOWS
554 /* Useful functions defined in the section
555 `Image type independent image structures' below. */
557 static unsigned long four_corners_best
P_ ((XImagePtr ximg
, unsigned long width
,
558 unsigned long height
));
560 static int x_create_x_image_and_pixmap
P_ ((struct frame
*f
, int width
, int height
,
561 int depth
, XImagePtr
*ximg
,
564 static void x_destroy_x_image
P_ ((XImagePtr ximg
));
567 /* Create a mask of a bitmap. Note is this not a perfect mask.
568 It's nicer with some borders in this context */
571 x_create_bitmap_mask (f
, id
)
576 XImagePtr ximg
, mask_img
;
577 unsigned long width
, height
;
580 unsigned long x
, y
, xp
, xm
, yp
, ym
;
583 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
588 pixmap
= x_bitmap_pixmap (f
, id
);
589 width
= x_bitmap_width (f
, id
);
590 height
= x_bitmap_height (f
, id
);
593 ximg
= XGetImage (FRAME_X_DISPLAY (f
), pixmap
, 0, 0, width
, height
,
602 result
= x_create_x_image_and_pixmap (f
, width
, height
, 1, &mask_img
, &mask
);
607 XDestroyImage (ximg
);
611 bg
= four_corners_best (ximg
, width
, height
);
613 for (y
= 0; y
< ximg
->height
; ++y
)
615 for (x
= 0; x
< ximg
->width
; ++x
)
617 xp
= x
!= ximg
->width
- 1 ? x
+ 1 : 0;
618 xm
= x
!= 0 ? x
- 1 : ximg
->width
- 1;
619 yp
= y
!= ximg
->height
- 1 ? y
+ 1 : 0;
620 ym
= y
!= 0 ? y
- 1 : ximg
->height
- 1;
621 if (XGetPixel (ximg
, x
, y
) == bg
622 && XGetPixel (ximg
, x
, yp
) == bg
623 && XGetPixel (ximg
, x
, ym
) == bg
624 && XGetPixel (ximg
, xp
, y
) == bg
625 && XGetPixel (ximg
, xp
, yp
) == bg
626 && XGetPixel (ximg
, xp
, ym
) == bg
627 && XGetPixel (ximg
, xm
, y
) == bg
628 && XGetPixel (ximg
, xm
, yp
) == bg
629 && XGetPixel (ximg
, xm
, ym
) == bg
)
630 XPutPixel (mask_img
, x
, y
, 0);
632 XPutPixel (mask_img
, x
, y
, 1);
636 xassert (interrupt_input_blocked
);
637 gc
= XCreateGC (FRAME_X_DISPLAY (f
), mask
, 0, NULL
);
638 XPutImage (FRAME_X_DISPLAY (f
), mask
, gc
, mask_img
, 0, 0, 0, 0,
640 XFreeGC (FRAME_X_DISPLAY (f
), gc
);
642 dpyinfo
->bitmaps
[id
- 1].have_mask
= 1;
643 dpyinfo
->bitmaps
[id
- 1].mask
= mask
;
645 XDestroyImage (ximg
);
646 x_destroy_x_image (mask_img
);
651 #endif /* HAVE_X_WINDOWS */
654 /***********************************************************************
656 ***********************************************************************/
658 /* Value is the number of elements of vector VECTOR. */
660 #define DIM(VECTOR) (sizeof (VECTOR) / sizeof *(VECTOR))
662 /* List of supported image types. Use define_image_type to add new
663 types. Use lookup_image_type to find a type for a given symbol. */
665 static struct image_type
*image_types
;
667 /* A list of symbols, one for each supported image type. */
669 Lisp_Object Vimage_types
;
671 /* An alist of image types and libraries that implement the type. */
673 Lisp_Object Vimage_library_alist
;
675 /* Cache for delayed-loading image types. */
677 static Lisp_Object Vimage_type_cache
;
679 /* The symbol `xbm' which is used as the type symbol for XBM images. */
685 extern Lisp_Object QCwidth
, QCheight
, QCforeground
, QCbackground
, QCfile
;
686 extern Lisp_Object QCdata
, QCtype
;
687 extern Lisp_Object Qcenter
;
688 Lisp_Object QCascent
, QCmargin
, QCrelief
;
689 Lisp_Object QCconversion
, QCcolor_symbols
, QCheuristic_mask
;
690 Lisp_Object QCindex
, QCmatrix
, QCcolor_adjustment
, QCmask
;
694 Lisp_Object Qlaplace
, Qemboss
, Qedge_detection
, Qheuristic
;
696 /* Time in seconds after which images should be removed from the cache
699 Lisp_Object Vimage_cache_eviction_delay
;
701 /* Function prototypes. */
703 static Lisp_Object define_image_type
P_ ((struct image_type
*type
, int loaded
));
704 static struct image_type
*lookup_image_type
P_ ((Lisp_Object symbol
));
705 static void image_error
P_ ((char *format
, Lisp_Object
, Lisp_Object
));
706 static void x_laplace
P_ ((struct frame
*, struct image
*));
707 static void x_emboss
P_ ((struct frame
*, struct image
*));
708 static int x_build_heuristic_mask
P_ ((struct frame
*, struct image
*,
711 #define CACHE_IMAGE_TYPE(type, status) \
712 do { Vimage_type_cache = Fcons (Fcons (type, status), Vimage_type_cache); } while (0)
714 #define ADD_IMAGE_TYPE(type) \
715 do { Vimage_types = Fcons (type, Vimage_types); } while (0)
717 /* Define a new image type from TYPE. This adds a copy of TYPE to
718 image_types and caches the loading status of TYPE. */
721 define_image_type (type
, loaded
)
722 struct image_type
*type
;
731 /* Make a copy of TYPE to avoid a bus error in a dumped Emacs.
732 The initialized data segment is read-only. */
733 struct image_type
*p
= (struct image_type
*) xmalloc (sizeof *p
);
734 bcopy (type
, p
, sizeof *p
);
735 p
->next
= image_types
;
740 CACHE_IMAGE_TYPE (*type
->type
, success
);
745 /* Look up image type SYMBOL, and return a pointer to its image_type
746 structure. Value is null if SYMBOL is not a known image type. */
748 static INLINE
struct image_type
*
749 lookup_image_type (symbol
)
752 struct image_type
*type
;
754 /* We must initialize the image-type if it hasn't been already. */
755 if (NILP (Finit_image_library (symbol
, Vimage_library_alist
)))
756 return 0; /* unimplemented */
758 for (type
= image_types
; type
; type
= type
->next
)
759 if (EQ (symbol
, *type
->type
))
766 /* Value is non-zero if OBJECT is a valid Lisp image specification. A
767 valid image specification is a list whose car is the symbol
768 `image', and whose rest is a property list. The property list must
769 contain a value for key `:type'. That value must be the name of a
770 supported image type. The rest of the property list depends on the
774 valid_image_p (object
)
783 for (tem
= XCDR (object
); CONSP (tem
); tem
= XCDR (tem
))
784 if (EQ (XCAR (tem
), QCtype
))
787 if (CONSP (tem
) && SYMBOLP (XCAR (tem
)))
789 struct image_type
*type
;
790 type
= lookup_image_type (XCAR (tem
));
792 valid_p
= type
->valid_p (object
);
803 /* Log error message with format string FORMAT and argument ARG.
804 Signaling an error, e.g. when an image cannot be loaded, is not a
805 good idea because this would interrupt redisplay, and the error
806 message display would lead to another redisplay. This function
807 therefore simply displays a message. */
810 image_error (format
, arg1
, arg2
)
812 Lisp_Object arg1
, arg2
;
814 add_to_log (format
, arg1
, arg2
);
819 /***********************************************************************
821 ***********************************************************************/
823 enum image_value_type
825 IMAGE_DONT_CHECK_VALUE_TYPE
,
827 IMAGE_STRING_OR_NIL_VALUE
,
829 IMAGE_POSITIVE_INTEGER_VALUE
,
830 IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
,
831 IMAGE_NON_NEGATIVE_INTEGER_VALUE
,
834 IMAGE_FUNCTION_VALUE
,
839 /* Structure used when parsing image specifications. */
843 /* Name of keyword. */
846 /* The type of value allowed. */
847 enum image_value_type type
;
849 /* Non-zero means key must be present. */
852 /* Used to recognize duplicate keywords in a property list. */
855 /* The value that was found. */
860 static int parse_image_spec
P_ ((Lisp_Object
, struct image_keyword
*,
862 static Lisp_Object image_spec_value
P_ ((Lisp_Object
, Lisp_Object
, int *));
865 /* Parse image spec SPEC according to KEYWORDS. A valid image spec
866 has the format (image KEYWORD VALUE ...). One of the keyword/
867 value pairs must be `:type TYPE'. KEYWORDS is a vector of
868 image_keywords structures of size NKEYWORDS describing other
869 allowed keyword/value pairs. Value is non-zero if SPEC is valid. */
872 parse_image_spec (spec
, keywords
, nkeywords
, type
)
874 struct image_keyword
*keywords
;
885 while (CONSP (plist
))
887 Lisp_Object key
, value
;
889 /* First element of a pair must be a symbol. */
891 plist
= XCDR (plist
);
895 /* There must follow a value. */
898 value
= XCAR (plist
);
899 plist
= XCDR (plist
);
901 /* Find key in KEYWORDS. Error if not found. */
902 for (i
= 0; i
< nkeywords
; ++i
)
903 if (strcmp (keywords
[i
].name
, SDATA (SYMBOL_NAME (key
))) == 0)
909 /* Record that we recognized the keyword. If a keywords
910 was found more than once, it's an error. */
911 keywords
[i
].value
= value
;
914 if (keywords
[i
].count
> 1)
917 /* Check type of value against allowed type. */
918 switch (keywords
[i
].type
)
920 case IMAGE_STRING_VALUE
:
921 if (!STRINGP (value
))
925 case IMAGE_STRING_OR_NIL_VALUE
:
926 if (!STRINGP (value
) && !NILP (value
))
930 case IMAGE_SYMBOL_VALUE
:
931 if (!SYMBOLP (value
))
935 case IMAGE_POSITIVE_INTEGER_VALUE
:
936 if (!INTEGERP (value
) || XINT (value
) <= 0)
940 case IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
:
941 if (INTEGERP (value
) && XINT (value
) >= 0)
944 && INTEGERP (XCAR (value
)) && INTEGERP (XCDR (value
))
945 && XINT (XCAR (value
)) >= 0 && XINT (XCDR (value
)) >= 0)
949 case IMAGE_ASCENT_VALUE
:
950 if (SYMBOLP (value
) && EQ (value
, Qcenter
))
952 else if (INTEGERP (value
)
954 && XINT (value
) <= 100)
958 case IMAGE_NON_NEGATIVE_INTEGER_VALUE
:
959 if (!INTEGERP (value
) || XINT (value
) < 0)
963 case IMAGE_DONT_CHECK_VALUE_TYPE
:
966 case IMAGE_FUNCTION_VALUE
:
967 value
= indirect_function (value
);
970 || (CONSP (value
) && EQ (XCAR (value
), Qlambda
)))
974 case IMAGE_NUMBER_VALUE
:
975 if (!INTEGERP (value
) && !FLOATP (value
))
979 case IMAGE_INTEGER_VALUE
:
980 if (!INTEGERP (value
))
984 case IMAGE_BOOL_VALUE
:
985 if (!NILP (value
) && !EQ (value
, Qt
))
994 if (EQ (key
, QCtype
) && !EQ (type
, value
))
998 /* Check that all mandatory fields are present. */
999 for (i
= 0; i
< nkeywords
; ++i
)
1000 if (keywords
[i
].mandatory_p
&& keywords
[i
].count
== 0)
1003 return NILP (plist
);
1007 /* Return the value of KEY in image specification SPEC. Value is nil
1008 if KEY is not present in SPEC. if FOUND is not null, set *FOUND
1009 to 1 if KEY was found in SPEC, set it to 0 otherwise. */
1012 image_spec_value (spec
, key
, found
)
1013 Lisp_Object spec
, key
;
1018 xassert (valid_image_p (spec
));
1020 for (tail
= XCDR (spec
);
1021 CONSP (tail
) && CONSP (XCDR (tail
));
1022 tail
= XCDR (XCDR (tail
)))
1024 if (EQ (XCAR (tail
), key
))
1028 return XCAR (XCDR (tail
));
1038 DEFUN ("image-size", Fimage_size
, Simage_size
, 1, 3, 0,
1039 doc
: /* Return the size of image SPEC as pair (WIDTH . HEIGHT).
1040 PIXELS non-nil means return the size in pixels, otherwise return the
1041 size in canonical character units.
1042 FRAME is the frame on which the image will be displayed. FRAME nil
1043 or omitted means use the selected frame. */)
1044 (spec
, pixels
, frame
)
1045 Lisp_Object spec
, pixels
, frame
;
1050 if (valid_image_p (spec
))
1052 struct frame
*f
= check_x_frame (frame
);
1053 int id
= lookup_image (f
, spec
);
1054 struct image
*img
= IMAGE_FROM_ID (f
, id
);
1055 int width
= img
->width
+ 2 * img
->hmargin
;
1056 int height
= img
->height
+ 2 * img
->vmargin
;
1059 size
= Fcons (make_float ((double) width
/ FRAME_COLUMN_WIDTH (f
)),
1060 make_float ((double) height
/ FRAME_LINE_HEIGHT (f
)));
1062 size
= Fcons (make_number (width
), make_number (height
));
1065 error ("Invalid image specification");
1071 DEFUN ("image-mask-p", Fimage_mask_p
, Simage_mask_p
, 1, 2, 0,
1072 doc
: /* Return t if image SPEC has a mask bitmap.
1073 FRAME is the frame on which the image will be displayed. FRAME nil
1074 or omitted means use the selected frame. */)
1076 Lisp_Object spec
, frame
;
1081 if (valid_image_p (spec
))
1083 struct frame
*f
= check_x_frame (frame
);
1084 int id
= lookup_image (f
, spec
);
1085 struct image
*img
= IMAGE_FROM_ID (f
, id
);
1090 error ("Invalid image specification");
1096 /***********************************************************************
1097 Image type independent image structures
1098 ***********************************************************************/
1100 static struct image
*make_image
P_ ((Lisp_Object spec
, unsigned hash
));
1101 static void free_image
P_ ((struct frame
*f
, struct image
*img
));
1102 static int check_image_size
P_ ((struct frame
*f
, int width
, int height
));
1104 #define MAX_IMAGE_SIZE 6.0
1105 Lisp_Object Vmax_image_size
;
1107 /* Allocate and return a new image structure for image specification
1108 SPEC. SPEC has a hash value of HASH. */
1110 static struct image
*
1111 make_image (spec
, hash
)
1115 struct image
*img
= (struct image
*) xmalloc (sizeof *img
);
1117 xassert (valid_image_p (spec
));
1118 bzero (img
, sizeof *img
);
1119 img
->type
= lookup_image_type (image_spec_value (spec
, QCtype
, NULL
));
1120 xassert (img
->type
!= NULL
);
1122 img
->data
.lisp_val
= Qnil
;
1123 img
->ascent
= DEFAULT_IMAGE_ASCENT
;
1129 /* Free image IMG which was used on frame F, including its resources. */
1138 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
1140 /* Remove IMG from the hash table of its cache. */
1142 img
->prev
->next
= img
->next
;
1144 c
->buckets
[img
->hash
% IMAGE_CACHE_BUCKETS_SIZE
] = img
->next
;
1147 img
->next
->prev
= img
->prev
;
1149 c
->images
[img
->id
] = NULL
;
1151 /* Free resources, then free IMG. */
1152 img
->type
->free (f
, img
);
1157 /* Return 1 if the given widths and heights are valid for display;
1158 otherwise, return 0. */
1161 check_image_size (f
, width
, height
)
1168 if (width
<= 0 || height
<= 0)
1171 if (INTEGERP (Vmax_image_size
))
1172 w
= h
= XINT (Vmax_image_size
);
1173 else if (FLOATP (Vmax_image_size
))
1177 w
= FRAME_PIXEL_WIDTH (f
);
1178 h
= FRAME_PIXEL_HEIGHT (f
);
1181 w
= h
= 1024; /* Arbitrary size for unknown frame. */
1182 w
= (int) (XFLOAT_DATA (Vmax_image_size
) * w
);
1183 h
= (int) (XFLOAT_DATA (Vmax_image_size
) * h
);
1188 return (width
<= w
&& height
<= h
);
1191 /* Prepare image IMG for display on frame F. Must be called before
1192 drawing an image. */
1195 prepare_image_for_display (f
, img
)
1201 /* We're about to display IMG, so set its timestamp to `now'. */
1203 img
->timestamp
= EMACS_SECS (t
);
1205 /* If IMG doesn't have a pixmap yet, load it now, using the image
1206 type dependent loader function. */
1207 if (img
->pixmap
== NO_PIXMAP
&& !img
->load_failed_p
)
1208 img
->load_failed_p
= img
->type
->load (f
, img
) == 0;
1212 /* Value is the number of pixels for the ascent of image IMG when
1213 drawn in face FACE. */
1216 image_ascent (img
, face
, slice
)
1219 struct glyph_slice
*slice
;
1224 if (slice
->height
== img
->height
)
1225 height
= img
->height
+ img
->vmargin
;
1226 else if (slice
->y
== 0)
1227 height
= slice
->height
+ img
->vmargin
;
1229 height
= slice
->height
;
1231 if (img
->ascent
== CENTERED_IMAGE_ASCENT
)
1236 /* W32 specific version. Why?. ++kfs */
1237 ascent
= height
/ 2 - (FONT_DESCENT(face
->font
)
1238 - FONT_BASE(face
->font
)) / 2;
1240 /* This expression is arranged so that if the image can't be
1241 exactly centered, it will be moved slightly up. This is
1242 because a typical font is `top-heavy' (due to the presence
1243 uppercase letters), so the image placement should err towards
1244 being top-heavy too. It also just generally looks better. */
1245 ascent
= (height
+ face
->font
->ascent
- face
->font
->descent
+ 1) / 2;
1246 #endif /* HAVE_NTGUI */
1249 ascent
= height
/ 2;
1252 ascent
= (int) (height
* img
->ascent
/ 100.0);
1258 /* Image background colors. */
1260 /* Find the "best" corner color of a bitmap.
1261 On W32, XIMG is assumed to a device context with the bitmap selected. */
1263 static RGB_PIXEL_COLOR
1264 four_corners_best (ximg
, width
, height
)
1265 XImagePtr_or_DC ximg
;
1266 unsigned long width
, height
;
1268 RGB_PIXEL_COLOR corners
[4], best
;
1271 /* Get the colors at the corners of ximg. */
1272 corners
[0] = GET_PIXEL (ximg
, 0, 0);
1273 corners
[1] = GET_PIXEL (ximg
, width
- 1, 0);
1274 corners
[2] = GET_PIXEL (ximg
, width
- 1, height
- 1);
1275 corners
[3] = GET_PIXEL (ximg
, 0, height
- 1);
1277 /* Choose the most frequently found color as background. */
1278 for (i
= best_count
= 0; i
< 4; ++i
)
1282 for (j
= n
= 0; j
< 4; ++j
)
1283 if (corners
[i
] == corners
[j
])
1287 best
= corners
[i
], best_count
= n
;
1293 /* Portability macros */
1297 #define Destroy_Image(img_dc, prev) \
1298 do { SelectObject (img_dc, prev); DeleteDC (img_dc); } while (0)
1300 #define Free_Pixmap(display, pixmap) \
1301 DeleteObject (pixmap)
1305 #define Destroy_Image(ximg, dummy) \
1306 XDestroyImage (ximg)
1308 #define Free_Pixmap(display, pixmap) \
1309 XFreePixmap (display, pixmap)
1311 #endif /* HAVE_NTGUI */
1314 /* Return the `background' field of IMG. If IMG doesn't have one yet,
1315 it is guessed heuristically. If non-zero, XIMG is an existing
1316 XImage object (or device context with the image selected on W32) to
1317 use for the heuristic. */
1320 image_background (img
, f
, ximg
)
1323 XImagePtr_or_DC ximg
;
1325 if (! img
->background_valid
)
1326 /* IMG doesn't have a background yet, try to guess a reasonable value. */
1328 int free_ximg
= !ximg
;
1331 #endif /* HAVE_NTGUI */
1336 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
1337 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
1339 HDC frame_dc
= get_frame_dc (f
);
1340 ximg
= CreateCompatibleDC (frame_dc
);
1341 release_frame_dc (f
, frame_dc
);
1342 prev
= SelectObject (ximg
, img
->pixmap
);
1343 #endif /* !HAVE_NTGUI */
1346 img
->background
= four_corners_best (ximg
, img
->width
, img
->height
);
1349 Destroy_Image (ximg
, prev
);
1351 img
->background_valid
= 1;
1354 return img
->background
;
1357 /* Return the `background_transparent' field of IMG. If IMG doesn't
1358 have one yet, it is guessed heuristically. If non-zero, MASK is an
1359 existing XImage object to use for the heuristic. */
1362 image_background_transparent (img
, f
, mask
)
1365 XImagePtr_or_DC mask
;
1367 if (! img
->background_transparent_valid
)
1368 /* IMG doesn't have a background yet, try to guess a reasonable value. */
1372 int free_mask
= !mask
;
1375 #endif /* HAVE_NTGUI */
1380 mask
= XGetImage (FRAME_X_DISPLAY (f
), img
->mask
,
1381 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
1383 HDC frame_dc
= get_frame_dc (f
);
1384 mask
= CreateCompatibleDC (frame_dc
);
1385 release_frame_dc (f
, frame_dc
);
1386 prev
= SelectObject (mask
, img
->mask
);
1387 #endif /* HAVE_NTGUI */
1390 img
->background_transparent
1391 = (four_corners_best (mask
, img
->width
, img
->height
) == PIX_MASK_RETAIN
);
1394 Destroy_Image (mask
, prev
);
1397 img
->background_transparent
= 0;
1399 img
->background_transparent_valid
= 1;
1402 return img
->background_transparent
;
1406 /***********************************************************************
1407 Helper functions for X image types
1408 ***********************************************************************/
1410 static void x_clear_image_1
P_ ((struct frame
*, struct image
*, int,
1412 static void x_clear_image
P_ ((struct frame
*f
, struct image
*img
));
1413 static unsigned long x_alloc_image_color
P_ ((struct frame
*f
,
1415 Lisp_Object color_name
,
1416 unsigned long dflt
));
1419 /* Clear X resources of image IMG on frame F. PIXMAP_P non-zero means
1420 free the pixmap if any. MASK_P non-zero means clear the mask
1421 pixmap if any. COLORS_P non-zero means free colors allocated for
1422 the image, if any. */
1425 x_clear_image_1 (f
, img
, pixmap_p
, mask_p
, colors_p
)
1428 int pixmap_p
, mask_p
, colors_p
;
1430 if (pixmap_p
&& img
->pixmap
)
1432 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->pixmap
);
1433 img
->pixmap
= NO_PIXMAP
;
1434 img
->background_valid
= 0;
1437 if (mask_p
&& img
->mask
)
1439 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
1440 img
->mask
= NO_PIXMAP
;
1441 img
->background_transparent_valid
= 0;
1444 if (colors_p
&& img
->ncolors
)
1446 /* MAC_TODO: color table support. */
1447 /* W32_TODO: color table support. */
1448 #ifdef HAVE_X_WINDOWS
1449 x_free_colors (f
, img
->colors
, img
->ncolors
);
1450 #endif /* HAVE_X_WINDOWS */
1451 xfree (img
->colors
);
1457 /* Free X resources of image IMG which is used on frame F. */
1460 x_clear_image (f
, img
)
1465 x_clear_image_1 (f
, img
, 1, 1, 1);
1470 /* Allocate color COLOR_NAME for image IMG on frame F. If color
1471 cannot be allocated, use DFLT. Add a newly allocated color to
1472 IMG->colors, so that it can be freed again. Value is the pixel
1475 static unsigned long
1476 x_alloc_image_color (f
, img
, color_name
, dflt
)
1479 Lisp_Object color_name
;
1483 unsigned long result
;
1485 xassert (STRINGP (color_name
));
1487 if (x_defined_color (f
, SDATA (color_name
), &color
, 1))
1489 /* This isn't called frequently so we get away with simply
1490 reallocating the color vector to the needed size, here. */
1493 (unsigned long *) xrealloc (img
->colors
,
1494 img
->ncolors
* sizeof *img
->colors
);
1495 img
->colors
[img
->ncolors
- 1] = color
.pixel
;
1496 result
= color
.pixel
;
1506 /***********************************************************************
1508 ***********************************************************************/
1510 static void cache_image
P_ ((struct frame
*f
, struct image
*img
));
1511 static void postprocess_image
P_ ((struct frame
*, struct image
*));
1513 /* Return a new, initialized image cache that is allocated from the
1514 heap. Call free_image_cache to free an image cache. */
1516 struct image_cache
*
1519 struct image_cache
*c
= (struct image_cache
*) xmalloc (sizeof *c
);
1522 bzero (c
, sizeof *c
);
1524 c
->images
= (struct image
**) xmalloc (c
->size
* sizeof *c
->images
);
1525 size
= IMAGE_CACHE_BUCKETS_SIZE
* sizeof *c
->buckets
;
1526 c
->buckets
= (struct image
**) xmalloc (size
);
1527 bzero (c
->buckets
, size
);
1532 /* Free image cache of frame F. Be aware that X frames share images
1536 free_image_cache (f
)
1539 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
1544 /* Cache should not be referenced by any frame when freed. */
1545 xassert (c
->refcount
== 0);
1547 for (i
= 0; i
< c
->used
; ++i
)
1548 free_image (f
, c
->images
[i
]);
1552 FRAME_X_IMAGE_CACHE (f
) = NULL
;
1557 /* Clear image cache of frame F. FORCE_P non-zero means free all
1558 images. FORCE_P zero means clear only images that haven't been
1559 displayed for some time. Should be called from time to time to
1560 reduce the number of loaded images. If image-eviction-seconds is
1561 non-nil, this frees images in the cache which weren't displayed for
1562 at least that many seconds. */
1565 clear_image_cache (f
, force_p
)
1569 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
1571 if (c
&& INTEGERP (Vimage_cache_eviction_delay
))
1578 old
= EMACS_SECS (t
) - XFASTINT (Vimage_cache_eviction_delay
);
1580 /* Block input so that we won't be interrupted by a SIGIO
1581 while being in an inconsistent state. */
1584 for (i
= nfreed
= 0; i
< c
->used
; ++i
)
1586 struct image
*img
= c
->images
[i
];
1588 && (force_p
|| img
->timestamp
< old
))
1590 free_image (f
, img
);
1595 /* We may be clearing the image cache because, for example,
1596 Emacs was iconified for a longer period of time. In that
1597 case, current matrices may still contain references to
1598 images freed above. So, clear these matrices. */
1601 Lisp_Object tail
, frame
;
1603 FOR_EACH_FRAME (tail
, frame
)
1605 struct frame
*f
= XFRAME (frame
);
1606 if (FRAME_WINDOW_P (f
)
1607 && FRAME_X_IMAGE_CACHE (f
) == c
)
1608 clear_current_matrices (f
);
1611 ++windows_or_buffers_changed
;
1619 DEFUN ("clear-image-cache", Fclear_image_cache
, Sclear_image_cache
,
1621 doc
: /* Clear the image cache of FRAME.
1622 FRAME nil or omitted means use the selected frame.
1623 FRAME t means clear the image caches of all frames. */)
1631 FOR_EACH_FRAME (tail
, frame
)
1632 if (FRAME_WINDOW_P (XFRAME (frame
)))
1633 clear_image_cache (XFRAME (frame
), 1);
1636 clear_image_cache (check_x_frame (frame
), 1);
1642 /* Compute masks and transform image IMG on frame F, as specified
1643 by the image's specification, */
1646 postprocess_image (f
, img
)
1650 /* Manipulation of the image's mask. */
1653 Lisp_Object conversion
, spec
;
1658 /* `:heuristic-mask t'
1660 means build a mask heuristically.
1661 `:heuristic-mask (R G B)'
1662 `:mask (heuristic (R G B))'
1663 means build a mask from color (R G B) in the
1666 means remove a mask, if any. */
1668 mask
= image_spec_value (spec
, QCheuristic_mask
, NULL
);
1670 x_build_heuristic_mask (f
, img
, mask
);
1675 mask
= image_spec_value (spec
, QCmask
, &found_p
);
1677 if (EQ (mask
, Qheuristic
))
1678 x_build_heuristic_mask (f
, img
, Qt
);
1679 else if (CONSP (mask
)
1680 && EQ (XCAR (mask
), Qheuristic
))
1682 if (CONSP (XCDR (mask
)))
1683 x_build_heuristic_mask (f
, img
, XCAR (XCDR (mask
)));
1685 x_build_heuristic_mask (f
, img
, XCDR (mask
));
1687 else if (NILP (mask
) && found_p
&& img
->mask
)
1689 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
1690 img
->mask
= NO_PIXMAP
;
1695 /* Should we apply an image transformation algorithm? */
1696 conversion
= image_spec_value (spec
, QCconversion
, NULL
);
1697 if (EQ (conversion
, Qdisabled
))
1698 x_disable_image (f
, img
);
1699 else if (EQ (conversion
, Qlaplace
))
1701 else if (EQ (conversion
, Qemboss
))
1703 else if (CONSP (conversion
)
1704 && EQ (XCAR (conversion
), Qedge_detection
))
1707 tem
= XCDR (conversion
);
1709 x_edge_detection (f
, img
,
1710 Fplist_get (tem
, QCmatrix
),
1711 Fplist_get (tem
, QCcolor_adjustment
));
1717 /* Return the id of image with Lisp specification SPEC on frame F.
1718 SPEC must be a valid Lisp image specification (see valid_image_p). */
1721 lookup_image (f
, spec
)
1725 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
1729 struct gcpro gcpro1
;
1732 /* F must be a window-system frame, and SPEC must be a valid image
1734 xassert (FRAME_WINDOW_P (f
));
1735 xassert (valid_image_p (spec
));
1739 /* Look up SPEC in the hash table of the image cache. */
1740 hash
= sxhash (spec
, 0);
1741 i
= hash
% IMAGE_CACHE_BUCKETS_SIZE
;
1743 for (img
= c
->buckets
[i
]; img
; img
= img
->next
)
1744 if (img
->hash
== hash
&& !NILP (Fequal (img
->spec
, spec
)))
1747 if (img
&& img
->load_failed_p
)
1749 free_image (f
, img
);
1753 /* If not found, create a new image and cache it. */
1756 extern Lisp_Object Qpostscript
;
1759 img
= make_image (spec
, hash
);
1760 cache_image (f
, img
);
1761 img
->load_failed_p
= img
->type
->load (f
, img
) == 0;
1763 /* If we can't load the image, and we don't have a width and
1764 height, use some arbitrary width and height so that we can
1765 draw a rectangle for it. */
1766 if (img
->load_failed_p
)
1770 value
= image_spec_value (spec
, QCwidth
, NULL
);
1771 img
->width
= (INTEGERP (value
)
1772 ? XFASTINT (value
) : DEFAULT_IMAGE_WIDTH
);
1773 value
= image_spec_value (spec
, QCheight
, NULL
);
1774 img
->height
= (INTEGERP (value
)
1775 ? XFASTINT (value
) : DEFAULT_IMAGE_HEIGHT
);
1779 /* Handle image type independent image attributes
1780 `:ascent ASCENT', `:margin MARGIN', `:relief RELIEF',
1781 `:background COLOR'. */
1782 Lisp_Object ascent
, margin
, relief
, bg
;
1784 ascent
= image_spec_value (spec
, QCascent
, NULL
);
1785 if (INTEGERP (ascent
))
1786 img
->ascent
= XFASTINT (ascent
);
1787 else if (EQ (ascent
, Qcenter
))
1788 img
->ascent
= CENTERED_IMAGE_ASCENT
;
1790 margin
= image_spec_value (spec
, QCmargin
, NULL
);
1791 if (INTEGERP (margin
) && XINT (margin
) >= 0)
1792 img
->vmargin
= img
->hmargin
= XFASTINT (margin
);
1793 else if (CONSP (margin
) && INTEGERP (XCAR (margin
))
1794 && INTEGERP (XCDR (margin
)))
1796 if (XINT (XCAR (margin
)) > 0)
1797 img
->hmargin
= XFASTINT (XCAR (margin
));
1798 if (XINT (XCDR (margin
)) > 0)
1799 img
->vmargin
= XFASTINT (XCDR (margin
));
1802 relief
= image_spec_value (spec
, QCrelief
, NULL
);
1803 if (INTEGERP (relief
))
1805 img
->relief
= XINT (relief
);
1806 img
->hmargin
+= abs (img
->relief
);
1807 img
->vmargin
+= abs (img
->relief
);
1810 if (! img
->background_valid
)
1812 bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
1816 = x_alloc_image_color (f
, img
, bg
,
1817 FRAME_BACKGROUND_PIXEL (f
));
1818 img
->background_valid
= 1;
1822 /* Do image transformations and compute masks, unless we
1823 don't have the image yet. */
1824 if (!EQ (*img
->type
->type
, Qpostscript
))
1825 postprocess_image (f
, img
);
1831 /* We're using IMG, so set its timestamp to `now'. */
1832 EMACS_GET_TIME (now
);
1833 img
->timestamp
= EMACS_SECS (now
);
1837 /* Value is the image id. */
1842 /* Cache image IMG in the image cache of frame F. */
1845 cache_image (f
, img
)
1849 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
1852 /* Find a free slot in c->images. */
1853 for (i
= 0; i
< c
->used
; ++i
)
1854 if (c
->images
[i
] == NULL
)
1857 /* If no free slot found, maybe enlarge c->images. */
1858 if (i
== c
->used
&& c
->used
== c
->size
)
1861 c
->images
= (struct image
**) xrealloc (c
->images
,
1862 c
->size
* sizeof *c
->images
);
1865 /* Add IMG to c->images, and assign IMG an id. */
1871 /* Add IMG to the cache's hash table. */
1872 i
= img
->hash
% IMAGE_CACHE_BUCKETS_SIZE
;
1873 img
->next
= c
->buckets
[i
];
1875 img
->next
->prev
= img
;
1877 c
->buckets
[i
] = img
;
1881 /* Call FN on every image in the image cache of frame F. Used to mark
1882 Lisp Objects in the image cache. */
1885 forall_images_in_image_cache (f
, fn
)
1887 void (*fn
) P_ ((struct image
*img
));
1889 if (FRAME_LIVE_P (f
) && FRAME_WINDOW_P (f
))
1891 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
1895 for (i
= 0; i
< c
->used
; ++i
)
1904 /***********************************************************************
1905 X / MAC / W32 support code
1906 ***********************************************************************/
1910 /* Macro for defining functions that will be loaded from image DLLs. */
1911 #define DEF_IMGLIB_FN(func) int (FAR CDECL *fn_##func)()
1913 /* Macro for loading those image functions from the library. */
1914 #define LOAD_IMGLIB_FN(lib,func) { \
1915 fn_##func = (void *) GetProcAddress (lib, #func); \
1916 if (!fn_##func) return 0; \
1919 /* Load a DLL implementing an image type.
1920 The `image-library-alist' variable associates a symbol,
1921 identifying an image type, to a list of possible filenames.
1922 The function returns NULL if no library could be loaded for
1923 the given image type, or if the library was previously loaded;
1924 else the handle of the DLL. */
1926 w32_delayed_load (Lisp_Object libraries
, Lisp_Object type
)
1928 HMODULE library
= NULL
;
1930 if (CONSP (libraries
) && NILP (Fassq (type
, Vimage_type_cache
)))
1932 Lisp_Object dlls
= Fassq (type
, libraries
);
1935 for (dlls
= XCDR (dlls
); CONSP (dlls
); dlls
= XCDR (dlls
))
1937 CHECK_STRING_CAR (dlls
);
1938 if (library
= LoadLibrary (SDATA (XCAR (dlls
))))
1946 #endif /* HAVE_NTGUI */
1948 static int x_create_x_image_and_pixmap
P_ ((struct frame
*, int, int, int,
1949 XImagePtr
*, Pixmap
*));
1950 static void x_destroy_x_image
P_ ((XImagePtr
));
1951 static void x_put_x_image
P_ ((struct frame
*, XImagePtr
, Pixmap
, int, int));
1954 /* Create an XImage and a pixmap of size WIDTH x HEIGHT for use on
1955 frame F. Set *XIMG and *PIXMAP to the XImage and Pixmap created.
1956 Set (*XIMG)->data to a raster of WIDTH x HEIGHT pixels allocated
1957 via xmalloc. Print error messages via image_error if an error
1958 occurs. Value is non-zero if successful.
1960 On W32, a DEPTH of zero signifies a 24 bit image, otherwise DEPTH
1961 should indicate the bit depth of the image. */
1964 x_create_x_image_and_pixmap (f
, width
, height
, depth
, ximg
, pixmap
)
1966 int width
, height
, depth
;
1970 #ifdef HAVE_X_WINDOWS
1971 Display
*display
= FRAME_X_DISPLAY (f
);
1972 Window window
= FRAME_X_WINDOW (f
);
1973 Screen
*screen
= FRAME_X_SCREEN (f
);
1975 xassert (interrupt_input_blocked
);
1978 depth
= DefaultDepthOfScreen (screen
);
1979 *ximg
= XCreateImage (display
, DefaultVisualOfScreen (screen
),
1980 depth
, ZPixmap
, 0, NULL
, width
, height
,
1981 depth
> 16 ? 32 : depth
> 8 ? 16 : 8, 0);
1984 image_error ("Unable to allocate X image", Qnil
, Qnil
);
1988 /* Allocate image raster. */
1989 (*ximg
)->data
= (char *) xmalloc ((*ximg
)->bytes_per_line
* height
);
1991 /* Allocate a pixmap of the same size. */
1992 *pixmap
= XCreatePixmap (display
, window
, width
, height
, depth
);
1993 if (*pixmap
== NO_PIXMAP
)
1995 x_destroy_x_image (*ximg
);
1997 image_error ("Unable to create X pixmap", Qnil
, Qnil
);
2002 #endif /* HAVE_X_WINDOWS */
2006 BITMAPINFOHEADER
*header
;
2008 int scanline_width_bits
;
2010 int palette_colors
= 0;
2015 if (depth
!= 1 && depth
!= 4 && depth
!= 8
2016 && depth
!= 16 && depth
!= 24 && depth
!= 32)
2018 image_error ("Invalid image bit depth specified", Qnil
, Qnil
);
2022 scanline_width_bits
= width
* depth
;
2023 remainder
= scanline_width_bits
% 32;
2026 scanline_width_bits
+= 32 - remainder
;
2028 /* Bitmaps with a depth less than 16 need a palette. */
2029 /* BITMAPINFO structure already contains the first RGBQUAD. */
2031 palette_colors
= 1 << depth
- 1;
2033 *ximg
= xmalloc (sizeof (XImage
) + palette_colors
* sizeof (RGBQUAD
));
2036 image_error ("Unable to allocate memory for XImage", Qnil
, Qnil
);
2040 header
= &((*ximg
)->info
.bmiHeader
);
2041 bzero (&((*ximg
)->info
), sizeof (BITMAPINFO
));
2042 header
->biSize
= sizeof (*header
);
2043 header
->biWidth
= width
;
2044 header
->biHeight
= -height
; /* negative indicates a top-down bitmap. */
2045 header
->biPlanes
= 1;
2046 header
->biBitCount
= depth
;
2047 header
->biCompression
= BI_RGB
;
2048 header
->biClrUsed
= palette_colors
;
2050 /* TODO: fill in palette. */
2053 (*ximg
)->info
.bmiColors
[0].rgbBlue
= 0;
2054 (*ximg
)->info
.bmiColors
[0].rgbGreen
= 0;
2055 (*ximg
)->info
.bmiColors
[0].rgbRed
= 0;
2056 (*ximg
)->info
.bmiColors
[0].rgbReserved
= 0;
2057 (*ximg
)->info
.bmiColors
[1].rgbBlue
= 255;
2058 (*ximg
)->info
.bmiColors
[1].rgbGreen
= 255;
2059 (*ximg
)->info
.bmiColors
[1].rgbRed
= 255;
2060 (*ximg
)->info
.bmiColors
[1].rgbReserved
= 0;
2063 hdc
= get_frame_dc (f
);
2065 /* Create a DIBSection and raster array for the bitmap,
2066 and store its handle in *pixmap. */
2067 *pixmap
= CreateDIBSection (hdc
, &((*ximg
)->info
),
2068 (depth
< 16) ? DIB_PAL_COLORS
: DIB_RGB_COLORS
,
2069 /* casting avoids a GCC warning */
2070 (void **)&((*ximg
)->data
), NULL
, 0);
2072 /* Realize display palette and garbage all frames. */
2073 release_frame_dc (f
, hdc
);
2075 if (*pixmap
== NULL
)
2077 DWORD err
= GetLastError();
2078 Lisp_Object errcode
;
2079 /* All system errors are < 10000, so the following is safe. */
2080 XSETINT (errcode
, (int) err
);
2081 image_error ("Unable to create bitmap, error code %d", errcode
, Qnil
);
2082 x_destroy_x_image (*ximg
);
2088 #endif /* HAVE_NTGUI */
2091 Display
*display
= FRAME_X_DISPLAY (f
);
2092 Window window
= FRAME_X_WINDOW (f
);
2094 xassert (interrupt_input_blocked
);
2096 /* Allocate a pixmap of the same size. */
2097 *pixmap
= XCreatePixmap (display
, window
, width
, height
, depth
);
2098 if (*pixmap
== NO_PIXMAP
)
2101 image_error ("Unable to create X pixmap", Qnil
, Qnil
);
2105 LockPixels (GetGWorldPixMap (*pixmap
));
2113 /* Destroy XImage XIMG. Free XIMG->data. */
2116 x_destroy_x_image (ximg
)
2119 xassert (interrupt_input_blocked
);
2122 #ifdef HAVE_X_WINDOWS
2125 XDestroyImage (ximg
);
2126 #endif /* HAVE_X_WINDOWS */
2128 /* Data will be freed by DestroyObject. */
2131 #endif /* HAVE_NTGUI */
2133 XDestroyImage (ximg
);
2139 /* Put XImage XIMG into pixmap PIXMAP on frame F. WIDTH and HEIGHT
2140 are width and height of both the image and pixmap. */
2143 x_put_x_image (f
, ximg
, pixmap
, width
, height
)
2149 #ifdef HAVE_X_WINDOWS
2152 xassert (interrupt_input_blocked
);
2153 gc
= XCreateGC (FRAME_X_DISPLAY (f
), pixmap
, 0, NULL
);
2154 XPutImage (FRAME_X_DISPLAY (f
), pixmap
, gc
, ximg
, 0, 0, 0, 0, width
, height
);
2155 XFreeGC (FRAME_X_DISPLAY (f
), gc
);
2156 #endif /* HAVE_X_WINDOWS */
2159 #if 0 /* I don't think this is necessary looking at where it is used. */
2160 HDC hdc
= get_frame_dc (f
);
2161 SetDIBits (hdc
, pixmap
, 0, height
, ximg
->data
, &(ximg
->info
), DIB_RGB_COLORS
);
2162 release_frame_dc (f
, hdc
);
2164 #endif /* HAVE_NTGUI */
2167 xassert (ximg
== pixmap
);
2172 /***********************************************************************
2174 ***********************************************************************/
2176 static unsigned char *slurp_file
P_ ((char *, int *));
2179 /* Find image file FILE. Look in data-directory, then
2180 x-bitmap-file-path. Value is the full name of the file found, or
2181 nil if not found. */
2184 x_find_image_file (file
)
2187 Lisp_Object file_found
, search_path
;
2188 struct gcpro gcpro1
, gcpro2
;
2192 search_path
= Fcons (Vdata_directory
, Vx_bitmap_file_path
);
2193 GCPRO2 (file_found
, search_path
);
2195 /* Try to find FILE in data-directory, then x-bitmap-file-path. */
2196 fd
= openp (search_path
, file
, Qnil
, &file_found
, Qnil
);
2208 /* Read FILE into memory. Value is a pointer to a buffer allocated
2209 with xmalloc holding FILE's contents. Value is null if an error
2210 occurred. *SIZE is set to the size of the file. */
2212 static unsigned char *
2213 slurp_file (file
, size
)
2218 unsigned char *buf
= NULL
;
2221 if (stat (file
, &st
) == 0
2222 && (fp
= fopen (file
, "rb")) != NULL
2223 && (buf
= (unsigned char *) xmalloc (st
.st_size
),
2224 fread (buf
, 1, st
.st_size
, fp
) == st
.st_size
))
2247 /***********************************************************************
2248 MAC Image Load Functions
2249 ***********************************************************************/
2251 static int image_load_quicktime
P_ ((struct frame
*, struct image
*img
,
2254 static int image_load_quartz2d
P_ ((struct frame
*, struct image
*img
, int));
2258 find_image_fsspec (specified_file
, file
, fss
)
2259 Lisp_Object specified_file
, *file
;
2267 *file
= x_find_image_file (specified_file
);
2268 if (!STRINGP (*file
))
2269 return fnfErr
; /* file or directory not found;
2270 incomplete pathname */
2271 /* Try to open the image file. */
2273 err
= FSPathMakeRef (SDATA (*file
), &fsr
, NULL
);
2275 err
= FSGetCatalogInfo (&fsr
, kFSCatInfoNone
, NULL
, NULL
, fss
, NULL
);
2277 err
= posix_pathname_to_fsspec (SDATA (*file
), fss
);
2283 image_load_qt_1 (f
, img
, type
, fss
, dh
)
2291 GraphicsImportComponent gi
;
2294 ImageDescriptionHandle desc_handle
;
2295 short draw_all_pixels
;
2296 Lisp_Object specified_bg
;
2301 err
= OpenADefaultComponent (GraphicsImporterComponentType
,
2305 image_error ("Cannot get importer component for `%s'", img
->spec
, Qnil
);
2310 /* read from file system spec */
2311 err
= GraphicsImportSetDataFile (gi
, fss
);
2314 image_error ("Cannot set fsspec to graphics importer for '%s'",
2321 /* read from data handle */
2322 err
= GraphicsImportSetDataHandle (gi
, dh
);
2325 image_error ("Cannot set data handle to graphics importer for `%s'",
2330 err
= GraphicsImportGetImageDescription (gi
, &desc_handle
);
2331 if (err
!= noErr
|| desc_handle
== NULL
)
2333 image_error ("Error reading `%s'", img
->spec
, Qnil
);
2336 width
= img
->width
= (*desc_handle
)->width
;
2337 height
= img
->height
= (*desc_handle
)->height
;
2338 DisposeHandle ((Handle
)desc_handle
);
2340 if (!check_image_size (f
, width
, height
))
2342 image_error ("Invalid image size", Qnil
, Qnil
);
2346 err
= GraphicsImportDoesDrawAllPixels (gi
, &draw_all_pixels
);
2348 /* Don't check the error code here. It may have an undocumented
2352 image_error ("Error reading `%s'", img
->spec
, Qnil
);
2356 if (draw_all_pixels
!= graphicsImporterDrawsAllPixels
)
2358 specified_bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
2359 if (!STRINGP (specified_bg
) ||
2360 !mac_defined_color (f
, SDATA (specified_bg
), &color
, 0))
2362 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
2363 color
.red
= RED16_FROM_ULONG (color
.pixel
);
2364 color
.green
= GREEN16_FROM_ULONG (color
.pixel
);
2365 color
.blue
= BLUE16_FROM_ULONG (color
.pixel
);
2369 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
2371 if (draw_all_pixels
!= graphicsImporterDrawsAllPixels
)
2376 GetGWorld (&old_port
, &old_gdh
);
2377 SetGWorld (ximg
, NULL
);
2378 bg_color
.red
= color
.red
;
2379 bg_color
.green
= color
.green
;
2380 bg_color
.blue
= color
.blue
;
2381 RGBBackColor (&bg_color
);
2382 #if TARGET_API_MAC_CARBON
2383 GetPortBounds (ximg
, &rect
);
2386 EraseRect (&(ximg
->portRect
));
2388 SetGWorld (old_port
, old_gdh
);
2390 GraphicsImportSetGWorld (gi
, ximg
, NULL
);
2391 GraphicsImportDraw (gi
);
2392 CloseComponent (gi
);
2394 /* Maybe fill in the background field while we have ximg handy. */
2395 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
2396 IMAGE_BACKGROUND (img
, f
, ximg
);
2398 /* Put the image into the pixmap. */
2399 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
2400 x_destroy_x_image (ximg
);
2404 CloseComponent (gi
);
2409 /* Load an image using the QuickTime Graphics Importer.
2410 Note: The alpha channel does not work for PNG images. */
2412 image_load_quicktime (f
, img
, type
)
2417 Lisp_Object specified_file
;
2418 Lisp_Object specified_data
;
2421 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
2422 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
2424 if (NILP (specified_data
))
2426 /* Read from a file */
2430 err
= find_image_fsspec (specified_file
, &file
, &fss
);
2434 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
2436 image_error ("Cannot open `%s'", file
, Qnil
);
2439 return image_load_qt_1 (f
, img
, type
, &fss
, NULL
);
2443 /* Memory source! */
2447 err
= PtrToHand (SDATA (specified_data
), &dh
, SBYTES (specified_data
));
2450 image_error ("Cannot allocate data handle for `%s'",
2454 success_p
= image_load_qt_1 (f
, img
, type
, NULL
, dh
);
2462 /* Load a PNG/JPEG image using Quartz 2D decoding routines.
2463 CGImageCreateWithPNGDataProvider is provided after Mac OS X 10.2.
2464 So don't use this function directly but determine at runtime
2465 whether it exists. */
2466 typedef CGImageRef (*CGImageCreateWithPNGDataProviderProcType
)
2467 (CGDataProviderRef
, const float [], bool, CGColorRenderingIntent
);
2468 static CGImageCreateWithPNGDataProviderProcType MyCGImageCreateWithPNGDataProvider
;
2472 init_image_func_pointer ()
2474 if (NSIsSymbolNameDefined ("_CGImageCreateWithPNGDataProvider"))
2476 MyCGImageCreateWithPNGDataProvider
2477 = (CGImageCreateWithPNGDataProviderProcType
)
2478 NSAddressOfSymbol (NSLookupAndBindSymbol
2479 ("_CGImageCreateWithPNGDataProvider"));
2482 MyCGImageCreateWithPNGDataProvider
= NULL
;
2487 image_load_quartz2d (f
, img
, png_p
)
2492 Lisp_Object file
, specified_file
;
2493 Lisp_Object specified_data
, specified_bg
;
2494 struct gcpro gcpro1
;
2495 CGDataProviderRef source
;
2499 XImagePtr ximg
= NULL
;
2500 CGContextRef context
;
2503 /* Open the file. */
2504 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
2505 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
2510 if (NILP (specified_data
))
2515 file
= x_find_image_file (specified_file
);
2516 if (!STRINGP (file
))
2518 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
2522 path
= cfstring_create_with_string (file
);
2523 url
= CFURLCreateWithFileSystemPath (NULL
, path
,
2524 kCFURLPOSIXPathStyle
, 0);
2526 source
= CGDataProviderCreateWithURL (url
);
2530 source
= CGDataProviderCreateWithData (NULL
, SDATA (specified_data
),
2531 SBYTES (specified_data
), NULL
);
2534 image
= (*MyCGImageCreateWithPNGDataProvider
) (source
, NULL
, FALSE
,
2535 kCGRenderingIntentDefault
);
2537 image
= CGImageCreateWithJPEGDataProvider (source
, NULL
, FALSE
,
2538 kCGRenderingIntentDefault
);
2540 CGDataProviderRelease (source
);
2544 image_error ("Error reading image `%s'", img
->spec
, Qnil
);
2547 width
= img
->width
= CGImageGetWidth (image
);
2548 height
= img
->height
= CGImageGetHeight (image
);
2550 if (!check_image_size (f
, width
, height
))
2552 CGImageRelease (image
);
2554 image_error ("Invalid image size", Qnil
, Qnil
);
2560 specified_bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
2561 if (!STRINGP (specified_bg
) ||
2562 !mac_defined_color (f
, SDATA (specified_bg
), &color
, 0))
2564 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
2565 color
.red
= RED16_FROM_ULONG (color
.pixel
);
2566 color
.green
= GREEN16_FROM_ULONG (color
.pixel
);
2567 color
.blue
= BLUE16_FROM_ULONG (color
.pixel
);
2571 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
2573 CGImageRelease (image
);
2577 rectangle
= CGRectMake (0, 0, width
, height
);
2578 QDBeginCGContext (ximg
, &context
);
2581 CGContextSetRGBFillColor (context
, color
.red
/ 65535.0,
2582 color
.green
/ 65535.0,
2583 color
.blue
/ 65535.0, 1.0);
2584 CGContextFillRect (context
, rectangle
);
2586 CGContextDrawImage (context
, rectangle
, image
);
2587 QDEndCGContext (ximg
, &context
);
2588 CGImageRelease (image
);
2590 /* Maybe fill in the background field while we have ximg handy. */
2591 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
2592 IMAGE_BACKGROUND (img
, f
, ximg
);
2594 /* Put the image into the pixmap. */
2595 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
2596 x_destroy_x_image (ximg
);
2605 /***********************************************************************
2607 ***********************************************************************/
2609 static int xbm_scan
P_ ((unsigned char **, unsigned char *, char *, int *));
2610 static int xbm_load
P_ ((struct frame
*f
, struct image
*img
));
2611 static int xbm_load_image
P_ ((struct frame
*f
, struct image
*img
,
2612 unsigned char *, unsigned char *));
2613 static int xbm_image_p
P_ ((Lisp_Object object
));
2614 static int xbm_read_bitmap_data
P_ ((struct frame
*f
,
2615 unsigned char *, unsigned char *,
2616 int *, int *, unsigned char **));
2617 static int xbm_file_p
P_ ((Lisp_Object
));
2620 /* Indices of image specification fields in xbm_format, below. */
2622 enum xbm_keyword_index
2640 /* Vector of image_keyword structures describing the format
2641 of valid XBM image specifications. */
2643 static struct image_keyword xbm_format
[XBM_LAST
] =
2645 {":type", IMAGE_SYMBOL_VALUE
, 1},
2646 {":file", IMAGE_STRING_VALUE
, 0},
2647 {":width", IMAGE_POSITIVE_INTEGER_VALUE
, 0},
2648 {":height", IMAGE_POSITIVE_INTEGER_VALUE
, 0},
2649 {":data", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
2650 {":foreground", IMAGE_STRING_OR_NIL_VALUE
, 0},
2651 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0},
2652 {":ascent", IMAGE_ASCENT_VALUE
, 0},
2653 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
2654 {":relief", IMAGE_INTEGER_VALUE
, 0},
2655 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
2656 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
2657 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0}
2660 /* Structure describing the image type XBM. */
2662 static struct image_type xbm_type
=
2671 /* Tokens returned from xbm_scan. */
2680 /* Return non-zero if OBJECT is a valid XBM-type image specification.
2681 A valid specification is a list starting with the symbol `image'
2682 The rest of the list is a property list which must contain an
2685 If the specification specifies a file to load, it must contain
2686 an entry `:file FILENAME' where FILENAME is a string.
2688 If the specification is for a bitmap loaded from memory it must
2689 contain `:width WIDTH', `:height HEIGHT', and `:data DATA', where
2690 WIDTH and HEIGHT are integers > 0. DATA may be:
2692 1. a string large enough to hold the bitmap data, i.e. it must
2693 have a size >= (WIDTH + 7) / 8 * HEIGHT
2695 2. a bool-vector of size >= WIDTH * HEIGHT
2697 3. a vector of strings or bool-vectors, one for each line of the
2700 4. A string containing an in-memory XBM file. WIDTH and HEIGHT
2701 may not be specified in this case because they are defined in the
2704 Both the file and data forms may contain the additional entries
2705 `:background COLOR' and `:foreground COLOR'. If not present,
2706 foreground and background of the frame on which the image is
2707 displayed is used. */
2710 xbm_image_p (object
)
2713 struct image_keyword kw
[XBM_LAST
];
2715 bcopy (xbm_format
, kw
, sizeof kw
);
2716 if (!parse_image_spec (object
, kw
, XBM_LAST
, Qxbm
))
2719 xassert (EQ (kw
[XBM_TYPE
].value
, Qxbm
));
2721 if (kw
[XBM_FILE
].count
)
2723 if (kw
[XBM_WIDTH
].count
|| kw
[XBM_HEIGHT
].count
|| kw
[XBM_DATA
].count
)
2726 else if (kw
[XBM_DATA
].count
&& xbm_file_p (kw
[XBM_DATA
].value
))
2728 /* In-memory XBM file. */
2729 if (kw
[XBM_WIDTH
].count
|| kw
[XBM_HEIGHT
].count
|| kw
[XBM_FILE
].count
)
2737 /* Entries for `:width', `:height' and `:data' must be present. */
2738 if (!kw
[XBM_WIDTH
].count
2739 || !kw
[XBM_HEIGHT
].count
2740 || !kw
[XBM_DATA
].count
)
2743 data
= kw
[XBM_DATA
].value
;
2744 width
= XFASTINT (kw
[XBM_WIDTH
].value
);
2745 height
= XFASTINT (kw
[XBM_HEIGHT
].value
);
2747 /* Check type of data, and width and height against contents of
2753 /* Number of elements of the vector must be >= height. */
2754 if (XVECTOR (data
)->size
< height
)
2757 /* Each string or bool-vector in data must be large enough
2758 for one line of the image. */
2759 for (i
= 0; i
< height
; ++i
)
2761 Lisp_Object elt
= XVECTOR (data
)->contents
[i
];
2766 < (width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
)
2769 else if (BOOL_VECTOR_P (elt
))
2771 if (XBOOL_VECTOR (elt
)->size
< width
)
2778 else if (STRINGP (data
))
2781 < (width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
* height
)
2784 else if (BOOL_VECTOR_P (data
))
2786 if (XBOOL_VECTOR (data
)->size
< width
* height
)
2797 /* Scan a bitmap file. FP is the stream to read from. Value is
2798 either an enumerator from enum xbm_token, or a character for a
2799 single-character token, or 0 at end of file. If scanning an
2800 identifier, store the lexeme of the identifier in SVAL. If
2801 scanning a number, store its value in *IVAL. */
2804 xbm_scan (s
, end
, sval
, ival
)
2805 unsigned char **s
, *end
;
2813 /* Skip white space. */
2814 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
2819 else if (isdigit (c
))
2821 int value
= 0, digit
;
2823 if (c
== '0' && *s
< end
)
2826 if (c
== 'x' || c
== 'X')
2833 else if (c
>= 'a' && c
<= 'f')
2834 digit
= c
- 'a' + 10;
2835 else if (c
>= 'A' && c
<= 'F')
2836 digit
= c
- 'A' + 10;
2839 value
= 16 * value
+ digit
;
2842 else if (isdigit (c
))
2846 && (c
= *(*s
)++, isdigit (c
)))
2847 value
= 8 * value
+ c
- '0';
2854 && (c
= *(*s
)++, isdigit (c
)))
2855 value
= 10 * value
+ c
- '0';
2863 else if (isalpha (c
) || c
== '_')
2867 && (c
= *(*s
)++, (isalnum (c
) || c
== '_')))
2874 else if (c
== '/' && **s
== '*')
2876 /* C-style comment. */
2878 while (**s
&& (**s
!= '*' || *(*s
+ 1) != '/'))
2892 /* Create a Windows bitmap from X bitmap data. */
2894 w32_create_pixmap_from_bitmap_data (int width
, int height
, char *data
)
2896 static unsigned char swap_nibble
[16]
2897 = { 0x0, 0x8, 0x4, 0xc, /* 0000 1000 0100 1100 */
2898 0x2, 0xa, 0x6, 0xe, /* 0010 1010 0110 1110 */
2899 0x1, 0x9, 0x5, 0xd, /* 0001 1001 0101 1101 */
2900 0x3, 0xb, 0x7, 0xf }; /* 0011 1011 0111 1111 */
2902 unsigned char *bits
, *p
;
2905 w1
= (width
+ 7) / 8; /* nb of 8bits elt in X bitmap */
2906 w2
= ((width
+ 15) / 16) * 2; /* nb of 16bits elt in W32 bitmap */
2907 bits
= (unsigned char *) alloca (height
* w2
);
2908 bzero (bits
, height
* w2
);
2909 for (i
= 0; i
< height
; i
++)
2912 for (j
= 0; j
< w1
; j
++)
2914 /* Bitswap XBM bytes to match how Windows does things. */
2915 unsigned char c
= *data
++;
2916 *p
++ = (unsigned char)((swap_nibble
[c
& 0xf] << 4)
2917 | (swap_nibble
[(c
>>4) & 0xf]));
2920 bmp
= CreateBitmap (width
, height
, 1, 1, (char *) bits
);
2925 static void convert_mono_to_color_image (f
, img
, foreground
, background
)
2928 COLORREF foreground
, background
;
2930 HDC hdc
, old_img_dc
, new_img_dc
;
2931 HGDIOBJ old_prev
, new_prev
;
2934 hdc
= get_frame_dc (f
);
2935 old_img_dc
= CreateCompatibleDC (hdc
);
2936 new_img_dc
= CreateCompatibleDC (hdc
);
2937 new_pixmap
= CreateCompatibleBitmap (hdc
, img
->width
, img
->height
);
2938 release_frame_dc (f
, hdc
);
2939 old_prev
= SelectObject (old_img_dc
, img
->pixmap
);
2940 new_prev
= SelectObject (new_img_dc
, new_pixmap
);
2941 SetTextColor (new_img_dc
, foreground
);
2942 SetBkColor (new_img_dc
, background
);
2944 BitBlt (new_img_dc
, 0, 0, img
->width
, img
->height
, old_img_dc
,
2947 SelectObject (old_img_dc
, old_prev
);
2948 SelectObject (new_img_dc
, new_prev
);
2949 DeleteDC (old_img_dc
);
2950 DeleteDC (new_img_dc
);
2951 DeleteObject (img
->pixmap
);
2952 if (new_pixmap
== 0)
2953 fprintf (stderr
, "Failed to convert image to color.\n");
2955 img
->pixmap
= new_pixmap
;
2958 #define XBM_BIT_SHUFFLE(b) (~(b))
2962 #define XBM_BIT_SHUFFLE(b) (b)
2964 #endif /* HAVE_NTGUI */
2968 Create_Pixmap_From_Bitmap_Data(f
, img
, data
, fg
, bg
, non_default_colors
)
2972 RGB_PIXEL_COLOR fg
, bg
;
2973 int non_default_colors
;
2977 = w32_create_pixmap_from_bitmap_data (img
->width
, img
->height
, data
);
2979 /* If colors were specified, transfer the bitmap to a color one. */
2980 if (non_default_colors
)
2981 convert_mono_to_color_image (f
, img
, fg
, bg
);
2984 = XCreatePixmapFromBitmapData (FRAME_X_DISPLAY (f
),
2987 img
->width
, img
->height
,
2989 DefaultDepthOfScreen (FRAME_X_SCREEN (f
)));
2990 #endif /* HAVE_NTGUI */
2995 /* Replacement for XReadBitmapFileData which isn't available under old
2996 X versions. CONTENTS is a pointer to a buffer to parse; END is the
2997 buffer's end. Set *WIDTH and *HEIGHT to the width and height of
2998 the image. Return in *DATA the bitmap data allocated with xmalloc.
2999 Value is non-zero if successful. DATA null means just test if
3000 CONTENTS looks like an in-memory XBM file. */
3003 xbm_read_bitmap_data (f
, contents
, end
, width
, height
, data
)
3005 unsigned char *contents
, *end
;
3006 int *width
, *height
;
3007 unsigned char **data
;
3009 unsigned char *s
= contents
;
3010 char buffer
[BUFSIZ
];
3013 int bytes_per_line
, i
, nbytes
;
3019 LA1 = xbm_scan (&s, end, buffer, &value)
3021 #define expect(TOKEN) \
3022 if (LA1 != (TOKEN)) \
3027 #define expect_ident(IDENT) \
3028 if (LA1 == XBM_TK_IDENT && strcmp (buffer, (IDENT)) == 0) \
3033 *width
= *height
= -1;
3036 LA1
= xbm_scan (&s
, end
, buffer
, &value
);
3038 /* Parse defines for width, height and hot-spots. */
3042 expect_ident ("define");
3043 expect (XBM_TK_IDENT
);
3045 if (LA1
== XBM_TK_NUMBER
);
3047 char *p
= strrchr (buffer
, '_');
3048 p
= p
? p
+ 1 : buffer
;
3049 if (strcmp (p
, "width") == 0)
3051 else if (strcmp (p
, "height") == 0)
3054 expect (XBM_TK_NUMBER
);
3057 if (!check_image_size (f
, *width
, *height
))
3059 else if (data
== NULL
)
3062 /* Parse bits. Must start with `static'. */
3063 expect_ident ("static");
3064 if (LA1
== XBM_TK_IDENT
)
3066 if (strcmp (buffer
, "unsigned") == 0)
3069 expect_ident ("char");
3071 else if (strcmp (buffer
, "short") == 0)
3075 if (*width
% 16 && *width
% 16 < 9)
3078 else if (strcmp (buffer
, "char") == 0)
3086 expect (XBM_TK_IDENT
);
3092 bytes_per_line
= (*width
+ 7) / 8 + padding_p
;
3093 nbytes
= bytes_per_line
* *height
;
3094 p
= *data
= (unsigned char *) xmalloc (nbytes
);
3098 for (i
= 0; i
< nbytes
; i
+= 2)
3101 expect (XBM_TK_NUMBER
);
3103 *p
++ = XBM_BIT_SHUFFLE (val
);
3104 if (!padding_p
|| ((i
+ 2) % bytes_per_line
))
3105 *p
++ = XBM_BIT_SHUFFLE (value
>> 8);
3107 if (LA1
== ',' || LA1
== '}')
3115 for (i
= 0; i
< nbytes
; ++i
)
3118 expect (XBM_TK_NUMBER
);
3120 *p
++ = XBM_BIT_SHUFFLE (val
);
3122 if (LA1
== ',' || LA1
== '}')
3147 /* Load XBM image IMG which will be displayed on frame F from buffer
3148 CONTENTS. END is the end of the buffer. Value is non-zero if
3152 xbm_load_image (f
, img
, contents
, end
)
3155 unsigned char *contents
, *end
;
3158 unsigned char *data
;
3161 rc
= xbm_read_bitmap_data (f
, contents
, end
, &img
->width
, &img
->height
, &data
);
3164 unsigned long foreground
= FRAME_FOREGROUND_PIXEL (f
);
3165 unsigned long background
= FRAME_BACKGROUND_PIXEL (f
);
3166 int non_default_colors
= 0;
3169 xassert (img
->width
> 0 && img
->height
> 0);
3171 /* Get foreground and background colors, maybe allocate colors. */
3172 value
= image_spec_value (img
->spec
, QCforeground
, NULL
);
3175 foreground
= x_alloc_image_color (f
, img
, value
, foreground
);
3176 non_default_colors
= 1;
3178 value
= image_spec_value (img
->spec
, QCbackground
, NULL
);
3181 background
= x_alloc_image_color (f
, img
, value
, background
);
3182 img
->background
= background
;
3183 img
->background_valid
= 1;
3184 non_default_colors
= 1;
3187 Create_Pixmap_From_Bitmap_Data (f
, img
, data
,
3188 foreground
, background
,
3189 non_default_colors
);
3192 if (img
->pixmap
== NO_PIXMAP
)
3194 x_clear_image (f
, img
);
3195 image_error ("Unable to create X pixmap for `%s'", img
->spec
, Qnil
);
3201 image_error ("Error loading XBM image `%s'", img
->spec
, Qnil
);
3207 /* Value is non-zero if DATA looks like an in-memory XBM file. */
3214 return (STRINGP (data
)
3215 && xbm_read_bitmap_data (NULL
, SDATA (data
),
3222 /* Fill image IMG which is used on frame F with pixmap data. Value is
3223 non-zero if successful. */
3231 Lisp_Object file_name
;
3233 xassert (xbm_image_p (img
->spec
));
3235 /* If IMG->spec specifies a file name, create a non-file spec from it. */
3236 file_name
= image_spec_value (img
->spec
, QCfile
, NULL
);
3237 if (STRINGP (file_name
))
3240 unsigned char *contents
;
3242 struct gcpro gcpro1
;
3244 file
= x_find_image_file (file_name
);
3246 if (!STRINGP (file
))
3248 image_error ("Cannot find image file `%s'", file_name
, Qnil
);
3253 contents
= slurp_file (SDATA (file
), &size
);
3254 if (contents
== NULL
)
3256 image_error ("Error loading XBM image `%s'", img
->spec
, Qnil
);
3261 success_p
= xbm_load_image (f
, img
, contents
, contents
+ size
);
3266 struct image_keyword fmt
[XBM_LAST
];
3268 unsigned long foreground
= FRAME_FOREGROUND_PIXEL (f
);
3269 unsigned long background
= FRAME_BACKGROUND_PIXEL (f
);
3270 int non_default_colors
= 0;
3273 int in_memory_file_p
= 0;
3275 /* See if data looks like an in-memory XBM file. */
3276 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
3277 in_memory_file_p
= xbm_file_p (data
);
3279 /* Parse the image specification. */
3280 bcopy (xbm_format
, fmt
, sizeof fmt
);
3281 parsed_p
= parse_image_spec (img
->spec
, fmt
, XBM_LAST
, Qxbm
);
3284 /* Get specified width, and height. */
3285 if (!in_memory_file_p
)
3287 img
->width
= XFASTINT (fmt
[XBM_WIDTH
].value
);
3288 img
->height
= XFASTINT (fmt
[XBM_HEIGHT
].value
);
3289 xassert (img
->width
> 0 && img
->height
> 0);
3292 /* Get foreground and background colors, maybe allocate colors. */
3293 if (fmt
[XBM_FOREGROUND
].count
3294 && STRINGP (fmt
[XBM_FOREGROUND
].value
))
3296 foreground
= x_alloc_image_color (f
, img
, fmt
[XBM_FOREGROUND
].value
,
3298 non_default_colors
= 1;
3301 if (fmt
[XBM_BACKGROUND
].count
3302 && STRINGP (fmt
[XBM_BACKGROUND
].value
))
3304 background
= x_alloc_image_color (f
, img
, fmt
[XBM_BACKGROUND
].value
,
3306 non_default_colors
= 1;
3309 if (in_memory_file_p
)
3310 success_p
= xbm_load_image (f
, img
, SDATA (data
),
3319 int nbytes
= (img
->width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
;
3321 p
= bits
= (char *) alloca (nbytes
* img
->height
);
3322 for (i
= 0; i
< img
->height
; ++i
, p
+= nbytes
)
3324 Lisp_Object line
= XVECTOR (data
)->contents
[i
];
3326 bcopy (SDATA (line
), p
, nbytes
);
3328 bcopy (XBOOL_VECTOR (line
)->data
, p
, nbytes
);
3331 else if (STRINGP (data
))
3332 bits
= SDATA (data
);
3334 bits
= XBOOL_VECTOR (data
)->data
;
3336 /* Create the pixmap. */
3338 Create_Pixmap_From_Bitmap_Data (f
, img
, bits
,
3339 foreground
, background
,
3340 non_default_colors
);
3345 image_error ("Unable to create pixmap for XBM image `%s'",
3347 x_clear_image (f
, img
);
3357 /***********************************************************************
3359 ***********************************************************************/
3361 #if defined (HAVE_XPM) || defined (MAC_OS)
3363 static int xpm_image_p
P_ ((Lisp_Object object
));
3364 static int xpm_load
P_ ((struct frame
*f
, struct image
*img
));
3365 static int xpm_valid_color_symbols_p
P_ ((Lisp_Object
));
3367 #endif /* HAVE_XPM || MAC_OS */
3371 /* Indicate to xpm.h that we don't have Xlib. */
3373 /* simx.h in xpm defines XColor and XImage differently than Emacs. */
3374 /* It also defines Display the same way as Emacs, but gcc 3.3 still barfs. */
3375 #define XColor xpm_XColor
3376 #define XImage xpm_XImage
3377 #define Display xpm_Display
3378 #define PIXEL_ALREADY_TYPEDEFED
3379 #include "X11/xpm.h"
3384 #undef PIXEL_ALREADY_TYPEDEFED
3386 #include "X11/xpm.h"
3387 #endif /* HAVE_NTGUI */
3388 #endif /* HAVE_XPM */
3390 #if defined (HAVE_XPM) || defined (MAC_OS)
3391 /* The symbol `xpm' identifying XPM-format images. */
3395 /* Indices of image specification fields in xpm_format, below. */
3397 enum xpm_keyword_index
3413 /* Vector of image_keyword structures describing the format
3414 of valid XPM image specifications. */
3416 static struct image_keyword xpm_format
[XPM_LAST
] =
3418 {":type", IMAGE_SYMBOL_VALUE
, 1},
3419 {":file", IMAGE_STRING_VALUE
, 0},
3420 {":data", IMAGE_STRING_VALUE
, 0},
3421 {":ascent", IMAGE_ASCENT_VALUE
, 0},
3422 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
3423 {":relief", IMAGE_INTEGER_VALUE
, 0},
3424 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3425 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3426 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3427 {":color-symbols", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3428 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
3431 /* Structure describing the image type XPM. */
3433 static struct image_type xpm_type
=
3442 #ifdef HAVE_X_WINDOWS
3444 /* Define ALLOC_XPM_COLORS if we can use Emacs' own color allocation
3445 functions for allocating image colors. Our own functions handle
3446 color allocation failures more gracefully than the ones on the XPM
3449 #if defined XpmAllocColor && defined XpmFreeColors && defined XpmColorClosure
3450 #define ALLOC_XPM_COLORS
3452 #endif /* HAVE_X_WINDOWS */
3454 #ifdef ALLOC_XPM_COLORS
3456 static void xpm_init_color_cache
P_ ((struct frame
*, XpmAttributes
*));
3457 static void xpm_free_color_cache
P_ ((void));
3458 static int xpm_lookup_color
P_ ((struct frame
*, char *, XColor
*));
3459 static int xpm_color_bucket
P_ ((char *));
3460 static struct xpm_cached_color
*xpm_cache_color
P_ ((struct frame
*, char *,
3463 /* An entry in a hash table used to cache color definitions of named
3464 colors. This cache is necessary to speed up XPM image loading in
3465 case we do color allocations ourselves. Without it, we would need
3466 a call to XParseColor per pixel in the image. */
3468 struct xpm_cached_color
3470 /* Next in collision chain. */
3471 struct xpm_cached_color
*next
;
3473 /* Color definition (RGB and pixel color). */
3480 /* The hash table used for the color cache, and its bucket vector
3483 #define XPM_COLOR_CACHE_BUCKETS 1001
3484 struct xpm_cached_color
**xpm_color_cache
;
3486 /* Initialize the color cache. */
3489 xpm_init_color_cache (f
, attrs
)
3491 XpmAttributes
*attrs
;
3493 size_t nbytes
= XPM_COLOR_CACHE_BUCKETS
* sizeof *xpm_color_cache
;
3494 xpm_color_cache
= (struct xpm_cached_color
**) xmalloc (nbytes
);
3495 memset (xpm_color_cache
, 0, nbytes
);
3496 init_color_table ();
3498 if (attrs
->valuemask
& XpmColorSymbols
)
3503 for (i
= 0; i
< attrs
->numsymbols
; ++i
)
3504 if (XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
3505 attrs
->colorsymbols
[i
].value
, &color
))
3507 color
.pixel
= lookup_rgb_color (f
, color
.red
, color
.green
,
3509 xpm_cache_color (f
, attrs
->colorsymbols
[i
].name
, &color
, -1);
3514 /* Free the color cache. */
3517 xpm_free_color_cache ()
3519 struct xpm_cached_color
*p
, *next
;
3522 for (i
= 0; i
< XPM_COLOR_CACHE_BUCKETS
; ++i
)
3523 for (p
= xpm_color_cache
[i
]; p
; p
= next
)
3529 xfree (xpm_color_cache
);
3530 xpm_color_cache
= NULL
;
3531 free_color_table ();
3534 /* Return the bucket index for color named COLOR_NAME in the color
3538 xpm_color_bucket (color_name
)
3544 for (s
= color_name
; *s
; ++s
)
3546 return h
%= XPM_COLOR_CACHE_BUCKETS
;
3550 /* On frame F, cache values COLOR for color with name COLOR_NAME.
3551 BUCKET, if >= 0, is a precomputed bucket index. Value is the cache
3554 static struct xpm_cached_color
*
3555 xpm_cache_color (f
, color_name
, color
, bucket
)
3562 struct xpm_cached_color
*p
;
3565 bucket
= xpm_color_bucket (color_name
);
3567 nbytes
= sizeof *p
+ strlen (color_name
);
3568 p
= (struct xpm_cached_color
*) xmalloc (nbytes
);
3569 strcpy (p
->name
, color_name
);
3571 p
->next
= xpm_color_cache
[bucket
];
3572 xpm_color_cache
[bucket
] = p
;
3576 /* Look up color COLOR_NAME for frame F in the color cache. If found,
3577 return the cached definition in *COLOR. Otherwise, make a new
3578 entry in the cache and allocate the color. Value is zero if color
3579 allocation failed. */
3582 xpm_lookup_color (f
, color_name
, color
)
3587 struct xpm_cached_color
*p
;
3588 int h
= xpm_color_bucket (color_name
);
3590 for (p
= xpm_color_cache
[h
]; p
; p
= p
->next
)
3591 if (strcmp (p
->name
, color_name
) == 0)
3596 else if (XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
3599 color
->pixel
= lookup_rgb_color (f
, color
->red
, color
->green
,
3601 p
= xpm_cache_color (f
, color_name
, color
, h
);
3603 /* You get `opaque' at least from ImageMagick converting pbm to xpm
3604 with transparency, and it's useful. */
3605 else if (strcmp ("opaque", color_name
) == 0)
3607 bzero (color
, sizeof (XColor
)); /* Is this necessary/correct? */
3608 color
->pixel
= FRAME_FOREGROUND_PIXEL (f
);
3609 p
= xpm_cache_color (f
, color_name
, color
, h
);
3616 /* Callback for allocating color COLOR_NAME. Called from the XPM lib.
3617 CLOSURE is a pointer to the frame on which we allocate the
3618 color. Return in *COLOR the allocated color. Value is non-zero
3622 xpm_alloc_color (dpy
, cmap
, color_name
, color
, closure
)
3629 return xpm_lookup_color ((struct frame
*) closure
, color_name
, color
);
3633 /* Callback for freeing NPIXELS colors contained in PIXELS. CLOSURE
3634 is a pointer to the frame on which we allocate the color. Value is
3635 non-zero if successful. */
3638 xpm_free_colors (dpy
, cmap
, pixels
, npixels
, closure
)
3648 #endif /* ALLOC_XPM_COLORS */
3653 /* XPM library details. */
3655 DEF_IMGLIB_FN (XpmFreeAttributes
);
3656 DEF_IMGLIB_FN (XpmCreateImageFromBuffer
);
3657 DEF_IMGLIB_FN (XpmReadFileToImage
);
3658 DEF_IMGLIB_FN (XImageFree
);
3661 init_xpm_functions (Lisp_Object libraries
)
3665 if (!(library
= w32_delayed_load (libraries
, Qxpm
)))
3668 LOAD_IMGLIB_FN (library
, XpmFreeAttributes
);
3669 LOAD_IMGLIB_FN (library
, XpmCreateImageFromBuffer
);
3670 LOAD_IMGLIB_FN (library
, XpmReadFileToImage
);
3671 LOAD_IMGLIB_FN (library
, XImageFree
);
3675 #endif /* HAVE_NTGUI */
3678 /* Value is non-zero if COLOR_SYMBOLS is a valid color symbols list
3679 for XPM images. Such a list must consist of conses whose car and
3683 xpm_valid_color_symbols_p (color_symbols
)
3684 Lisp_Object color_symbols
;
3686 while (CONSP (color_symbols
))
3688 Lisp_Object sym
= XCAR (color_symbols
);
3690 || !STRINGP (XCAR (sym
))
3691 || !STRINGP (XCDR (sym
)))
3693 color_symbols
= XCDR (color_symbols
);
3696 return NILP (color_symbols
);
3700 /* Value is non-zero if OBJECT is a valid XPM image specification. */
3703 xpm_image_p (object
)
3706 struct image_keyword fmt
[XPM_LAST
];
3707 bcopy (xpm_format
, fmt
, sizeof fmt
);
3708 return (parse_image_spec (object
, fmt
, XPM_LAST
, Qxpm
)
3709 /* Either `:file' or `:data' must be present. */
3710 && fmt
[XPM_FILE
].count
+ fmt
[XPM_DATA
].count
== 1
3711 /* Either no `:color-symbols' or it's a list of conses
3712 whose car and cdr are strings. */
3713 && (fmt
[XPM_COLOR_SYMBOLS
].count
== 0
3714 || xpm_valid_color_symbols_p (fmt
[XPM_COLOR_SYMBOLS
].value
)));
3717 #endif /* HAVE_XPM || MAC_OS */
3719 #if defined (HAVE_XPM) && defined (HAVE_X_WINDOWS)
3721 x_create_bitmap_from_xpm_data (f
, bits
)
3725 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
3727 XpmAttributes attrs
;
3728 Pixmap bitmap
, mask
;
3730 bzero (&attrs
, sizeof attrs
);
3732 rc
= XpmCreatePixmapFromData (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3733 bits
, &bitmap
, &mask
, &attrs
);
3734 if (rc
!= XpmSuccess
)
3737 id
= x_allocate_bitmap_record (f
);
3739 dpyinfo
->bitmaps
[id
- 1].pixmap
= bitmap
;
3740 dpyinfo
->bitmaps
[id
- 1].have_mask
= 1;
3741 dpyinfo
->bitmaps
[id
- 1].mask
= mask
;
3742 dpyinfo
->bitmaps
[id
- 1].file
= NULL
;
3743 dpyinfo
->bitmaps
[id
- 1].height
= attrs
.height
;
3744 dpyinfo
->bitmaps
[id
- 1].width
= attrs
.width
;
3745 dpyinfo
->bitmaps
[id
- 1].depth
= attrs
.depth
;
3746 dpyinfo
->bitmaps
[id
- 1].refcount
= 1;
3748 XpmFreeAttributes (&attrs
);
3751 #endif /* HAVE_X_WINDOWS */
3753 /* Load image IMG which will be displayed on frame F. Value is
3754 non-zero if successful. */
3764 XpmAttributes attrs
;
3765 Lisp_Object specified_file
, color_symbols
;
3768 xpm_XImage
* xpm_image
= NULL
, * xpm_mask
= NULL
;
3769 #endif /* HAVE_NTGUI */
3771 /* Configure the XPM lib. Use the visual of frame F. Allocate
3772 close colors. Return colors allocated. */
3773 bzero (&attrs
, sizeof attrs
);
3776 attrs
.visual
= FRAME_X_VISUAL (f
);
3777 attrs
.colormap
= FRAME_X_COLORMAP (f
);
3778 attrs
.valuemask
|= XpmVisual
;
3779 attrs
.valuemask
|= XpmColormap
;
3780 #endif /* HAVE_NTGUI */
3782 #ifdef ALLOC_XPM_COLORS
3783 /* Allocate colors with our own functions which handle
3784 failing color allocation more gracefully. */
3785 attrs
.color_closure
= f
;
3786 attrs
.alloc_color
= xpm_alloc_color
;
3787 attrs
.free_colors
= xpm_free_colors
;
3788 attrs
.valuemask
|= XpmAllocColor
| XpmFreeColors
| XpmColorClosure
;
3789 #else /* not ALLOC_XPM_COLORS */
3790 /* Let the XPM lib allocate colors. */
3791 attrs
.valuemask
|= XpmReturnAllocPixels
;
3792 #ifdef XpmAllocCloseColors
3793 attrs
.alloc_close_colors
= 1;
3794 attrs
.valuemask
|= XpmAllocCloseColors
;
3795 #else /* not XpmAllocCloseColors */
3796 attrs
.closeness
= 600;
3797 attrs
.valuemask
|= XpmCloseness
;
3798 #endif /* not XpmAllocCloseColors */
3799 #endif /* ALLOC_XPM_COLORS */
3801 /* If image specification contains symbolic color definitions, add
3802 these to `attrs'. */
3803 color_symbols
= image_spec_value (img
->spec
, QCcolor_symbols
, NULL
);
3804 if (CONSP (color_symbols
))
3807 XpmColorSymbol
*xpm_syms
;
3810 attrs
.valuemask
|= XpmColorSymbols
;
3812 /* Count number of symbols. */
3813 attrs
.numsymbols
= 0;
3814 for (tail
= color_symbols
; CONSP (tail
); tail
= XCDR (tail
))
3817 /* Allocate an XpmColorSymbol array. */
3818 size
= attrs
.numsymbols
* sizeof *xpm_syms
;
3819 xpm_syms
= (XpmColorSymbol
*) alloca (size
);
3820 bzero (xpm_syms
, size
);
3821 attrs
.colorsymbols
= xpm_syms
;
3823 /* Fill the color symbol array. */
3824 for (tail
= color_symbols
, i
= 0;
3826 ++i
, tail
= XCDR (tail
))
3828 Lisp_Object name
= XCAR (XCAR (tail
));
3829 Lisp_Object color
= XCDR (XCAR (tail
));
3830 xpm_syms
[i
].name
= (char *) alloca (SCHARS (name
) + 1);
3831 strcpy (xpm_syms
[i
].name
, SDATA (name
));
3832 xpm_syms
[i
].value
= (char *) alloca (SCHARS (color
) + 1);
3833 strcpy (xpm_syms
[i
].value
, SDATA (color
));
3837 /* Create a pixmap for the image, either from a file, or from a
3838 string buffer containing data in the same format as an XPM file. */
3839 #ifdef ALLOC_XPM_COLORS
3840 xpm_init_color_cache (f
, &attrs
);
3843 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
3847 HDC frame_dc
= get_frame_dc (f
);
3848 hdc
= CreateCompatibleDC (frame_dc
);
3849 release_frame_dc (f
, frame_dc
);
3851 #endif /* HAVE_NTGUI */
3853 if (STRINGP (specified_file
))
3855 Lisp_Object file
= x_find_image_file (specified_file
);
3856 if (!STRINGP (file
))
3858 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
3863 /* XpmReadFileToPixmap is not available in the Windows port of
3864 libxpm. But XpmReadFileToImage almost does what we want. */
3865 rc
= fn_XpmReadFileToImage (&hdc
, SDATA (file
),
3866 &xpm_image
, &xpm_mask
,
3869 rc
= XpmReadFileToPixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3870 SDATA (file
), &img
->pixmap
, &img
->mask
,
3872 #endif /* HAVE_NTGUI */
3876 Lisp_Object buffer
= image_spec_value (img
->spec
, QCdata
, NULL
);
3878 /* XpmCreatePixmapFromBuffer is not available in the Windows port
3879 of libxpm. But XpmCreateImageFromBuffer almost does what we want. */
3880 rc
= fn_XpmCreateImageFromBuffer (&hdc
, SDATA (buffer
),
3881 &xpm_image
, &xpm_mask
,
3884 rc
= XpmCreatePixmapFromBuffer (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3886 &img
->pixmap
, &img
->mask
,
3888 #endif /* HAVE_NTGUI */
3891 if (rc
== XpmSuccess
)
3893 #if defined (COLOR_TABLE_SUPPORT) && defined (ALLOC_XPM_COLORS)
3894 img
->colors
= colors_in_color_table (&img
->ncolors
);
3895 #else /* not ALLOC_XPM_COLORS */
3899 /* W32 XPM uses XImage to wrap what W32 Emacs calls a Pixmap,
3900 plus some duplicate attributes. */
3901 if (xpm_image
&& xpm_image
->bitmap
)
3903 img
->pixmap
= xpm_image
->bitmap
;
3904 /* XImageFree in libXpm frees XImage struct without destroying
3905 the bitmap, which is what we want. */
3906 fn_XImageFree (xpm_image
);
3908 if (xpm_mask
&& xpm_mask
->bitmap
)
3910 /* The mask appears to be inverted compared with what we expect.
3911 TODO: invert our expectations. See other places where we
3912 have to invert bits because our idea of masks is backwards. */
3914 old_obj
= SelectObject (hdc
, xpm_mask
->bitmap
);
3916 PatBlt (hdc
, 0, 0, xpm_mask
->width
, xpm_mask
->height
, DSTINVERT
);
3917 SelectObject (hdc
, old_obj
);
3919 img
->mask
= xpm_mask
->bitmap
;
3920 fn_XImageFree (xpm_mask
);
3925 #endif /* HAVE_NTGUI */
3927 /* Remember allocated colors. */
3928 img
->ncolors
= attrs
.nalloc_pixels
;
3929 img
->colors
= (unsigned long *) xmalloc (img
->ncolors
3930 * sizeof *img
->colors
);
3931 for (i
= 0; i
< attrs
.nalloc_pixels
; ++i
)
3933 img
->colors
[i
] = attrs
.alloc_pixels
[i
];
3934 #ifdef DEBUG_X_COLORS
3935 register_color (img
->colors
[i
]);
3938 #endif /* not ALLOC_XPM_COLORS */
3940 img
->width
= attrs
.width
;
3941 img
->height
= attrs
.height
;
3942 xassert (img
->width
> 0 && img
->height
> 0);
3944 /* The call to XpmFreeAttributes below frees attrs.alloc_pixels. */
3946 fn_XpmFreeAttributes (&attrs
);
3948 XpmFreeAttributes (&attrs
);
3949 #endif /* HAVE_NTGUI */
3955 #endif /* HAVE_NTGUI */
3960 image_error ("Error opening XPM file (%s)", img
->spec
, Qnil
);
3963 case XpmFileInvalid
:
3964 image_error ("Invalid XPM file (%s)", img
->spec
, Qnil
);
3968 image_error ("Out of memory (%s)", img
->spec
, Qnil
);
3971 case XpmColorFailed
:
3972 image_error ("Color allocation error (%s)", img
->spec
, Qnil
);
3976 image_error ("Unknown error (%s)", img
->spec
, Qnil
);
3981 #ifdef ALLOC_XPM_COLORS
3982 xpm_free_color_cache ();
3984 return rc
== XpmSuccess
;
3987 #endif /* HAVE_XPM */
3991 /* XPM support functions for Mac OS where libxpm is not available.
3992 Only XPM version 3 (without any extensions) is supported. */
3994 static int xpm_scan
P_ ((unsigned char **, unsigned char *,
3995 unsigned char **, int *));
3996 static Lisp_Object xpm_make_color_table_v
3997 P_ ((void (**) (Lisp_Object
, unsigned char *, int, Lisp_Object
),
3998 Lisp_Object (**) (Lisp_Object
, unsigned char *, int)));
3999 static void xpm_put_color_table_v
P_ ((Lisp_Object
, unsigned char *,
4001 static Lisp_Object xpm_get_color_table_v
P_ ((Lisp_Object
,
4002 unsigned char *, int));
4003 static Lisp_Object xpm_make_color_table_h
4004 P_ ((void (**) (Lisp_Object
, unsigned char *, int, Lisp_Object
),
4005 Lisp_Object (**) (Lisp_Object
, unsigned char *, int)));
4006 static void xpm_put_color_table_h
P_ ((Lisp_Object
, unsigned char *,
4008 static Lisp_Object xpm_get_color_table_h
P_ ((Lisp_Object
,
4009 unsigned char *, int));
4010 static int xpm_str_to_color_key
P_ ((char *));
4011 static int xpm_load_image
P_ ((struct frame
*, struct image
*,
4012 unsigned char *, unsigned char *));
4014 /* Tokens returned from xpm_scan. */
4023 /* Scan an XPM data and return a character (< 256) or a token defined
4024 by enum xpm_token above. *S and END are the start (inclusive) and
4025 the end (exclusive) addresses of the data, respectively. Advance
4026 *S while scanning. If token is either XPM_TK_IDENT or
4027 XPM_TK_STRING, *BEG and *LEN are set to the start address and the
4028 length of the corresponding token, respectively. */
4031 xpm_scan (s
, end
, beg
, len
)
4032 unsigned char **s
, *end
, **beg
;
4039 /* Skip white-space. */
4040 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
4043 /* gnus-pointer.xpm uses '-' in its identifier.
4044 sb-dir-plus.xpm uses '+' in its identifier. */
4045 if (isalpha (c
) || c
== '_' || c
== '-' || c
== '+')
4049 (c
= **s
, isalnum (c
) || c
== '_' || c
== '-' || c
== '+'))
4052 return XPM_TK_IDENT
;
4057 while (*s
< end
&& **s
!= '"')
4062 return XPM_TK_STRING
;
4066 if (*s
< end
&& **s
== '*')
4068 /* C-style comment. */
4072 while (*s
< end
&& *(*s
)++ != '*')
4075 while (*s
< end
&& **s
!= '/');
4089 /* Functions for color table lookup in XPM data. A Key is a string
4090 specifying the color of each pixel in XPM data. A value is either
4091 an integer that specifies a pixel color, Qt that specifies
4092 transparency, or Qnil for the unspecified color. If the length of
4093 the key string is one, a vector is used as a table. Otherwise, a
4094 hash table is used. */
4097 xpm_make_color_table_v (put_func
, get_func
)
4098 void (**put_func
) (Lisp_Object
, unsigned char *, int, Lisp_Object
);
4099 Lisp_Object (**get_func
) (Lisp_Object
, unsigned char *, int);
4101 *put_func
= xpm_put_color_table_v
;
4102 *get_func
= xpm_get_color_table_v
;
4103 return Fmake_vector (make_number (256), Qnil
);
4107 xpm_put_color_table_v (color_table
, chars_start
, chars_len
, color
)
4108 Lisp_Object color_table
;
4109 unsigned char *chars_start
;
4113 XVECTOR (color_table
)->contents
[*chars_start
] = color
;
4117 xpm_get_color_table_v (color_table
, chars_start
, chars_len
)
4118 Lisp_Object color_table
;
4119 unsigned char *chars_start
;
4122 return XVECTOR (color_table
)->contents
[*chars_start
];
4126 xpm_make_color_table_h (put_func
, get_func
)
4127 void (**put_func
) (Lisp_Object
, unsigned char *, int, Lisp_Object
);
4128 Lisp_Object (**get_func
) (Lisp_Object
, unsigned char *, int);
4130 *put_func
= xpm_put_color_table_h
;
4131 *get_func
= xpm_get_color_table_h
;
4132 return make_hash_table (Qequal
, make_number (DEFAULT_HASH_SIZE
),
4133 make_float (DEFAULT_REHASH_SIZE
),
4134 make_float (DEFAULT_REHASH_THRESHOLD
),
4139 xpm_put_color_table_h (color_table
, chars_start
, chars_len
, color
)
4140 Lisp_Object color_table
;
4141 unsigned char *chars_start
;
4145 struct Lisp_Hash_Table
*table
= XHASH_TABLE (color_table
);
4147 Lisp_Object chars
= make_unibyte_string (chars_start
, chars_len
);
4149 hash_lookup (table
, chars
, &hash_code
);
4150 hash_put (table
, chars
, color
, hash_code
);
4154 xpm_get_color_table_h (color_table
, chars_start
, chars_len
)
4155 Lisp_Object color_table
;
4156 unsigned char *chars_start
;
4159 struct Lisp_Hash_Table
*table
= XHASH_TABLE (color_table
);
4160 int i
= hash_lookup (table
, make_unibyte_string (chars_start
, chars_len
),
4163 return i
>= 0 ? HASH_VALUE (table
, i
) : Qnil
;
4166 enum xpm_color_key
{
4174 static char xpm_color_key_strings
[][4] = {"s", "m", "g4", "g", "c"};
4177 xpm_str_to_color_key (s
)
4183 i
< sizeof xpm_color_key_strings
/ sizeof xpm_color_key_strings
[0];
4185 if (strcmp (xpm_color_key_strings
[i
], s
) == 0)
4191 xpm_load_image (f
, img
, contents
, end
)
4194 unsigned char *contents
, *end
;
4196 unsigned char *s
= contents
, *beg
, *str
;
4197 unsigned char buffer
[BUFSIZ
];
4198 int width
, height
, x
, y
;
4199 int num_colors
, chars_per_pixel
;
4201 void (*put_color_table
) (Lisp_Object
, unsigned char *, int, Lisp_Object
);
4202 Lisp_Object (*get_color_table
) (Lisp_Object
, unsigned char *, int);
4203 Lisp_Object frame
, color_symbols
, color_table
;
4204 int best_key
, have_mask
= 0;
4205 XImagePtr ximg
= NULL
, mask_img
= NULL
;
4208 LA1 = xpm_scan (&s, end, &beg, &len)
4210 #define expect(TOKEN) \
4211 if (LA1 != (TOKEN)) \
4216 #define expect_ident(IDENT) \
4217 if (LA1 == XPM_TK_IDENT \
4218 && strlen ((IDENT)) == len && memcmp ((IDENT), beg, len) == 0) \
4223 if (!(end
- s
>= 9 && memcmp (s
, "/* XPM */", 9) == 0))
4227 expect_ident ("static");
4228 expect_ident ("char");
4230 expect (XPM_TK_IDENT
);
4235 expect (XPM_TK_STRING
);
4238 memcpy (buffer
, beg
, len
);
4240 if (sscanf (buffer
, "%d %d %d %d", &width
, &height
,
4241 &num_colors
, &chars_per_pixel
) != 4
4242 || width
<= 0 || height
<= 0
4243 || num_colors
<= 0 || chars_per_pixel
<= 0)
4246 if (!check_image_size (f
, width
, height
))
4248 image_error ("Invalid image size", Qnil
, Qnil
);
4254 XSETFRAME (frame
, f
);
4255 if (!NILP (Fxw_display_color_p (frame
)))
4256 best_key
= XPM_COLOR_KEY_C
;
4257 else if (!NILP (Fx_display_grayscale_p (frame
)))
4258 best_key
= (XFASTINT (Fx_display_planes (frame
)) > 2
4259 ? XPM_COLOR_KEY_G
: XPM_COLOR_KEY_G4
);
4261 best_key
= XPM_COLOR_KEY_M
;
4263 color_symbols
= image_spec_value (img
->spec
, QCcolor_symbols
, NULL
);
4264 if (chars_per_pixel
== 1)
4265 color_table
= xpm_make_color_table_v (&put_color_table
,
4268 color_table
= xpm_make_color_table_h (&put_color_table
,
4271 while (num_colors
-- > 0)
4273 unsigned char *color
, *max_color
;
4274 int key
, next_key
, max_key
= 0;
4275 Lisp_Object symbol_color
= Qnil
, color_val
;
4278 expect (XPM_TK_STRING
);
4279 if (len
<= chars_per_pixel
|| len
>= BUFSIZ
+ chars_per_pixel
)
4281 memcpy (buffer
, beg
+ chars_per_pixel
, len
- chars_per_pixel
);
4282 buffer
[len
- chars_per_pixel
] = '\0';
4284 str
= strtok (buffer
, " \t");
4287 key
= xpm_str_to_color_key (str
);
4292 color
= strtok (NULL
, " \t");
4296 while (str
= strtok (NULL
, " \t"))
4298 next_key
= xpm_str_to_color_key (str
);
4301 color
[strlen (color
)] = ' ';
4304 if (key
== XPM_COLOR_KEY_S
)
4306 if (NILP (symbol_color
))
4307 symbol_color
= build_string (color
);
4309 else if (max_key
< key
&& key
<= best_key
)
4319 if (!NILP (color_symbols
) && !NILP (symbol_color
))
4321 Lisp_Object specified_color
= Fassoc (symbol_color
, color_symbols
);
4323 if (CONSP (specified_color
) && STRINGP (XCDR (specified_color
)))
4324 if (xstricmp (SDATA (XCDR (specified_color
)), "None") == 0)
4326 else if (x_defined_color (f
, SDATA (XCDR (specified_color
)),
4328 color_val
= make_number (cdef
.pixel
);
4330 if (NILP (color_val
) && max_key
> 0)
4331 if (xstricmp (max_color
, "None") == 0)
4333 else if (x_defined_color (f
, max_color
, &cdef
, 0))
4334 color_val
= make_number (cdef
.pixel
);
4335 if (!NILP (color_val
))
4336 (*put_color_table
) (color_table
, beg
, chars_per_pixel
, color_val
);
4341 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0,
4342 &ximg
, &img
->pixmap
)
4343 || !x_create_x_image_and_pixmap (f
, width
, height
, 1,
4344 &mask_img
, &img
->mask
))
4346 image_error ("Out of memory (%s)", img
->spec
, Qnil
);
4350 for (y
= 0; y
< height
; y
++)
4352 expect (XPM_TK_STRING
);
4354 if (len
< width
* chars_per_pixel
)
4356 for (x
= 0; x
< width
; x
++, str
+= chars_per_pixel
)
4358 Lisp_Object color_val
=
4359 (*get_color_table
) (color_table
, str
, chars_per_pixel
);
4361 XPutPixel (ximg
, x
, y
,
4362 (INTEGERP (color_val
) ? XINT (color_val
)
4363 : FRAME_FOREGROUND_PIXEL (f
)));
4364 XPutPixel (mask_img
, x
, y
,
4365 (!EQ (color_val
, Qt
) ? PIX_MASK_DRAW
4366 : (have_mask
= 1, PIX_MASK_RETAIN
)));
4373 img
->height
= height
;
4375 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
4376 x_destroy_x_image (ximg
);
4379 /* Fill in the background_transparent field while we have the
4381 image_background_transparent (img
, f
, mask_img
);
4383 x_put_x_image (f
, mask_img
, img
->mask
, width
, height
);
4384 x_destroy_x_image (mask_img
);
4388 x_destroy_x_image (mask_img
);
4389 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
4390 img
->mask
= NO_PIXMAP
;
4396 image_error ("Invalid XPM file (%s)", img
->spec
, Qnil
);
4398 x_destroy_x_image (ximg
);
4399 x_destroy_x_image (mask_img
);
4400 x_clear_image (f
, img
);
4414 Lisp_Object file_name
;
4416 /* If IMG->spec specifies a file name, create a non-file spec from it. */
4417 file_name
= image_spec_value (img
->spec
, QCfile
, NULL
);
4418 if (STRINGP (file_name
))
4421 unsigned char *contents
;
4423 struct gcpro gcpro1
;
4425 file
= x_find_image_file (file_name
);
4427 if (!STRINGP (file
))
4429 image_error ("Cannot find image file `%s'", file_name
, Qnil
);
4434 contents
= slurp_file (SDATA (file
), &size
);
4435 if (contents
== NULL
)
4437 image_error ("Error loading XPM image `%s'", img
->spec
, Qnil
);
4442 success_p
= xpm_load_image (f
, img
, contents
, contents
+ size
);
4450 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
4451 success_p
= xpm_load_image (f
, img
, SDATA (data
),
4452 SDATA (data
) + SBYTES (data
));
4462 /***********************************************************************
4464 ***********************************************************************/
4466 #ifdef COLOR_TABLE_SUPPORT
4468 /* An entry in the color table mapping an RGB color to a pixel color. */
4473 unsigned long pixel
;
4475 /* Next in color table collision list. */
4476 struct ct_color
*next
;
4479 /* The bucket vector size to use. Must be prime. */
4483 /* Value is a hash of the RGB color given by R, G, and B. */
4485 #define CT_HASH_RGB(R, G, B) (((R) << 16) ^ ((G) << 8) ^ (B))
4487 /* The color hash table. */
4489 struct ct_color
**ct_table
;
4491 /* Number of entries in the color table. */
4493 int ct_colors_allocated
;
4495 /* Initialize the color table. */
4500 int size
= CT_SIZE
* sizeof (*ct_table
);
4501 ct_table
= (struct ct_color
**) xmalloc (size
);
4502 bzero (ct_table
, size
);
4503 ct_colors_allocated
= 0;
4507 /* Free memory associated with the color table. */
4513 struct ct_color
*p
, *next
;
4515 for (i
= 0; i
< CT_SIZE
; ++i
)
4516 for (p
= ct_table
[i
]; p
; p
= next
)
4527 /* Value is a pixel color for RGB color R, G, B on frame F. If an
4528 entry for that color already is in the color table, return the
4529 pixel color of that entry. Otherwise, allocate a new color for R,
4530 G, B, and make an entry in the color table. */
4532 static unsigned long
4533 lookup_rgb_color (f
, r
, g
, b
)
4537 unsigned hash
= CT_HASH_RGB (r
, g
, b
);
4538 int i
= hash
% CT_SIZE
;
4540 Display_Info
*dpyinfo
;
4542 /* Handle TrueColor visuals specially, which improves performance by
4543 two orders of magnitude. Freeing colors on TrueColor visuals is
4544 a nop, and pixel colors specify RGB values directly. See also
4545 the Xlib spec, chapter 3.1. */
4546 dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
4547 if (dpyinfo
->red_bits
> 0)
4549 unsigned long pr
, pg
, pb
;
4551 /* Apply gamma-correction like normal color allocation does. */
4555 color
.red
= r
, color
.green
= g
, color
.blue
= b
;
4556 gamma_correct (f
, &color
);
4557 r
= color
.red
, g
= color
.green
, b
= color
.blue
;
4560 /* Scale down RGB values to the visual's bits per RGB, and shift
4561 them to the right position in the pixel color. Note that the
4562 original RGB values are 16-bit values, as usual in X. */
4563 pr
= (r
>> (16 - dpyinfo
->red_bits
)) << dpyinfo
->red_offset
;
4564 pg
= (g
>> (16 - dpyinfo
->green_bits
)) << dpyinfo
->green_offset
;
4565 pb
= (b
>> (16 - dpyinfo
->blue_bits
)) << dpyinfo
->blue_offset
;
4567 /* Assemble the pixel color. */
4568 return pr
| pg
| pb
;
4571 for (p
= ct_table
[i
]; p
; p
= p
->next
)
4572 if (p
->r
== r
&& p
->g
== g
&& p
->b
== b
)
4578 #ifdef HAVE_X_WINDOWS
4587 cmap
= FRAME_X_COLORMAP (f
);
4588 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
4591 ++ct_colors_allocated
;
4592 p
= (struct ct_color
*) xmalloc (sizeof *p
);
4596 p
->pixel
= color
.pixel
;
4597 p
->next
= ct_table
[i
];
4601 return FRAME_FOREGROUND_PIXEL (f
);
4606 color
= PALETTERGB (r
, g
, b
);
4608 color
= RGB_TO_ULONG (r
, g
, b
);
4609 #endif /* HAVE_NTGUI */
4610 ++ct_colors_allocated
;
4611 p
= (struct ct_color
*) xmalloc (sizeof *p
);
4616 p
->next
= ct_table
[i
];
4618 #endif /* HAVE_X_WINDOWS */
4626 /* Look up pixel color PIXEL which is used on frame F in the color
4627 table. If not already present, allocate it. Value is PIXEL. */
4629 static unsigned long
4630 lookup_pixel_color (f
, pixel
)
4632 unsigned long pixel
;
4634 int i
= pixel
% CT_SIZE
;
4637 for (p
= ct_table
[i
]; p
; p
= p
->next
)
4638 if (p
->pixel
== pixel
)
4647 #ifdef HAVE_X_WINDOWS
4648 cmap
= FRAME_X_COLORMAP (f
);
4649 color
.pixel
= pixel
;
4650 x_query_color (f
, &color
);
4651 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
4654 cmap
= DefaultColormapOfScreen (FRAME_X_SCREEN (f
));
4655 color
.pixel
= pixel
;
4656 XQueryColor (NULL
, cmap
, &color
);
4657 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
4659 #endif /* HAVE_X_WINDOWS */
4663 ++ct_colors_allocated
;
4665 p
= (struct ct_color
*) xmalloc (sizeof *p
);
4670 p
->next
= ct_table
[i
];
4674 return FRAME_FOREGROUND_PIXEL (f
);
4680 /* Value is a vector of all pixel colors contained in the color table,
4681 allocated via xmalloc. Set *N to the number of colors. */
4683 static unsigned long *
4684 colors_in_color_table (n
)
4689 unsigned long *colors
;
4691 if (ct_colors_allocated
== 0)
4698 colors
= (unsigned long *) xmalloc (ct_colors_allocated
4700 *n
= ct_colors_allocated
;
4702 for (i
= j
= 0; i
< CT_SIZE
; ++i
)
4703 for (p
= ct_table
[i
]; p
; p
= p
->next
)
4704 colors
[j
++] = p
->pixel
;
4710 #else /* COLOR_TABLE_SUPPORT */
4712 static unsigned long
4713 lookup_rgb_color (f
, r
, g
, b
)
4717 unsigned long pixel
;
4720 pixel
= RGB_TO_ULONG (r
>> 8, g
>> 8, b
>> 8);
4721 gamma_correct (f
, &pixel
);
4725 pixel
= PALETTERGB (r
>> 8, g
>> 8, b
>> 8);
4726 #endif /* HAVE_NTGUI */
4735 #endif /* COLOR_TABLE_SUPPORT */
4738 /***********************************************************************
4740 ***********************************************************************/
4742 static XColor
*x_to_xcolors
P_ ((struct frame
*, struct image
*, int));
4743 static void x_from_xcolors
P_ ((struct frame
*, struct image
*, XColor
*));
4744 static void x_detect_edges
P_ ((struct frame
*, struct image
*, int[9], int));
4747 static void XPutPixel (XImagePtr
, int, int, COLORREF
);
4748 #endif /* HAVE_NTGUI */
4750 /* Non-zero means draw a cross on images having `:conversion
4753 int cross_disabled_images
;
4755 /* Edge detection matrices for different edge-detection
4758 static int emboss_matrix
[9] = {
4760 2, -1, 0, /* y - 1 */
4762 0, 1, -2 /* y + 1 */
4765 static int laplace_matrix
[9] = {
4767 1, 0, 0, /* y - 1 */
4769 0, 0, -1 /* y + 1 */
4772 /* Value is the intensity of the color whose red/green/blue values
4775 #define COLOR_INTENSITY(R, G, B) ((2 * (R) + 3 * (G) + (B)) / 6)
4778 /* On frame F, return an array of XColor structures describing image
4779 IMG->pixmap. Each XColor structure has its pixel color set. RGB_P
4780 non-zero means also fill the red/green/blue members of the XColor
4781 structures. Value is a pointer to the array of XColors structures,
4782 allocated with xmalloc; it must be freed by the caller. */
4785 x_to_xcolors (f
, img
, rgb_p
)
4792 XImagePtr_or_DC ximg
;
4796 #endif /* HAVE_NTGUI */
4798 colors
= (XColor
*) xmalloc (img
->width
* img
->height
* sizeof *colors
);
4801 /* Get the X image IMG->pixmap. */
4802 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
4803 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
4805 /* Load the image into a memory device context. */
4806 hdc
= get_frame_dc (f
);
4807 ximg
= CreateCompatibleDC (hdc
);
4808 release_frame_dc (f
, hdc
);
4809 prev
= SelectObject (ximg
, img
->pixmap
);
4810 #endif /* HAVE_NTGUI */
4812 /* Fill the `pixel' members of the XColor array. I wished there
4813 were an easy and portable way to circumvent XGetPixel. */
4815 for (y
= 0; y
< img
->height
; ++y
)
4819 #ifdef HAVE_X_WINDOWS
4820 for (x
= 0; x
< img
->width
; ++x
, ++p
)
4821 p
->pixel
= XGetPixel (ximg
, x
, y
);
4823 x_query_colors (f
, row
, img
->width
);
4827 for (x
= 0; x
< img
->width
; ++x
, ++p
)
4829 /* W32_TODO: palette support needed here? */
4830 p
->pixel
= GET_PIXEL (ximg
, x
, y
);
4834 p
->red
= RED16_FROM_ULONG (p
->pixel
);
4835 p
->green
= GREEN16_FROM_ULONG (p
->pixel
);
4836 p
->blue
= BLUE16_FROM_ULONG (p
->pixel
);
4839 p
->red
= 256 * GetRValue (p
->pixel
);
4840 p
->green
= 256 * GetGValue (p
->pixel
);
4841 p
->blue
= 256 * GetBValue (p
->pixel
);
4842 #endif /* HAVE_NTGUI */
4845 #endif /* HAVE_X_WINDOWS */
4848 Destroy_Image (ximg
, prev
);
4855 /* Put a pixel of COLOR at position X, Y in XIMG. XIMG must have been
4856 created with CreateDIBSection, with the pointer to the bit values
4857 stored in ximg->data. */
4859 static void XPutPixel (ximg
, x
, y
, color
)
4864 int width
= ximg
->info
.bmiHeader
.biWidth
;
4865 int height
= ximg
->info
.bmiHeader
.biHeight
;
4866 unsigned char * pixel
;
4868 /* True color images. */
4869 if (ximg
->info
.bmiHeader
.biBitCount
== 24)
4871 int rowbytes
= width
* 3;
4872 /* Ensure scanlines are aligned on 4 byte boundaries. */
4874 rowbytes
+= 4 - (rowbytes
% 4);
4876 pixel
= ximg
->data
+ y
* rowbytes
+ x
* 3;
4877 /* Windows bitmaps are in BGR order. */
4878 *pixel
= GetBValue (color
);
4879 *(pixel
+ 1) = GetGValue (color
);
4880 *(pixel
+ 2) = GetRValue (color
);
4882 /* Monochrome images. */
4883 else if (ximg
->info
.bmiHeader
.biBitCount
== 1)
4885 int rowbytes
= width
/ 8;
4886 /* Ensure scanlines are aligned on 4 byte boundaries. */
4888 rowbytes
+= 4 - (rowbytes
% 4);
4889 pixel
= ximg
->data
+ y
* rowbytes
+ x
/ 8;
4890 /* Filter out palette info. */
4891 if (color
& 0x00ffffff)
4892 *pixel
= *pixel
| (1 << x
% 8);
4894 *pixel
= *pixel
& ~(1 << x
% 8);
4897 image_error ("XPutPixel: palette image not supported", Qnil
, Qnil
);
4900 #endif /* HAVE_NTGUI */
4902 /* Create IMG->pixmap from an array COLORS of XColor structures, whose
4903 RGB members are set. F is the frame on which this all happens.
4904 COLORS will be freed; an existing IMG->pixmap will be freed, too. */
4907 x_from_xcolors (f
, img
, colors
)
4917 init_color_table ();
4919 x_create_x_image_and_pixmap (f
, img
->width
, img
->height
, 0,
4922 for (y
= 0; y
< img
->height
; ++y
)
4923 for (x
= 0; x
< img
->width
; ++x
, ++p
)
4925 unsigned long pixel
;
4926 pixel
= lookup_rgb_color (f
, p
->red
, p
->green
, p
->blue
);
4927 XPutPixel (oimg
, x
, y
, pixel
);
4931 x_clear_image_1 (f
, img
, 1, 0, 1);
4933 x_put_x_image (f
, oimg
, pixmap
, img
->width
, img
->height
);
4934 x_destroy_x_image (oimg
);
4935 img
->pixmap
= pixmap
;
4936 #ifdef COLOR_TABLE_SUPPORT
4937 img
->colors
= colors_in_color_table (&img
->ncolors
);
4938 free_color_table ();
4939 #endif /* COLOR_TABLE_SUPPORT */
4943 /* On frame F, perform edge-detection on image IMG.
4945 MATRIX is a nine-element array specifying the transformation
4946 matrix. See emboss_matrix for an example.
4948 COLOR_ADJUST is a color adjustment added to each pixel of the
4952 x_detect_edges (f
, img
, matrix
, color_adjust
)
4955 int matrix
[9], color_adjust
;
4957 XColor
*colors
= x_to_xcolors (f
, img
, 1);
4961 for (i
= sum
= 0; i
< 9; ++i
)
4962 sum
+= abs (matrix
[i
]);
4964 #define COLOR(A, X, Y) ((A) + (Y) * img->width + (X))
4966 new = (XColor
*) xmalloc (img
->width
* img
->height
* sizeof *new);
4968 for (y
= 0; y
< img
->height
; ++y
)
4970 p
= COLOR (new, 0, y
);
4971 p
->red
= p
->green
= p
->blue
= 0xffff/2;
4972 p
= COLOR (new, img
->width
- 1, y
);
4973 p
->red
= p
->green
= p
->blue
= 0xffff/2;
4976 for (x
= 1; x
< img
->width
- 1; ++x
)
4978 p
= COLOR (new, x
, 0);
4979 p
->red
= p
->green
= p
->blue
= 0xffff/2;
4980 p
= COLOR (new, x
, img
->height
- 1);
4981 p
->red
= p
->green
= p
->blue
= 0xffff/2;
4984 for (y
= 1; y
< img
->height
- 1; ++y
)
4986 p
= COLOR (new, 1, y
);
4988 for (x
= 1; x
< img
->width
- 1; ++x
, ++p
)
4990 int r
, g
, b
, y1
, x1
;
4993 for (y1
= y
- 1; y1
< y
+ 2; ++y1
)
4994 for (x1
= x
- 1; x1
< x
+ 2; ++x1
, ++i
)
4997 XColor
*t
= COLOR (colors
, x1
, y1
);
4998 r
+= matrix
[i
] * t
->red
;
4999 g
+= matrix
[i
] * t
->green
;
5000 b
+= matrix
[i
] * t
->blue
;
5003 r
= (r
/ sum
+ color_adjust
) & 0xffff;
5004 g
= (g
/ sum
+ color_adjust
) & 0xffff;
5005 b
= (b
/ sum
+ color_adjust
) & 0xffff;
5006 p
->red
= p
->green
= p
->blue
= COLOR_INTENSITY (r
, g
, b
);
5011 x_from_xcolors (f
, img
, new);
5017 /* Perform the pre-defined `emboss' edge-detection on image IMG
5025 x_detect_edges (f
, img
, emboss_matrix
, 0xffff / 2);
5029 /* Transform image IMG which is used on frame F with a Laplace
5030 edge-detection algorithm. The result is an image that can be used
5031 to draw disabled buttons, for example. */
5038 x_detect_edges (f
, img
, laplace_matrix
, 45000);
5042 /* Perform edge-detection on image IMG on frame F, with specified
5043 transformation matrix MATRIX and color-adjustment COLOR_ADJUST.
5045 MATRIX must be either
5047 - a list of at least 9 numbers in row-major form
5048 - a vector of at least 9 numbers
5050 COLOR_ADJUST nil means use a default; otherwise it must be a
5054 x_edge_detection (f
, img
, matrix
, color_adjust
)
5057 Lisp_Object matrix
, color_adjust
;
5065 i
< 9 && CONSP (matrix
) && NUMBERP (XCAR (matrix
));
5066 ++i
, matrix
= XCDR (matrix
))
5067 trans
[i
] = XFLOATINT (XCAR (matrix
));
5069 else if (VECTORP (matrix
) && ASIZE (matrix
) >= 9)
5071 for (i
= 0; i
< 9 && NUMBERP (AREF (matrix
, i
)); ++i
)
5072 trans
[i
] = XFLOATINT (AREF (matrix
, i
));
5075 if (NILP (color_adjust
))
5076 color_adjust
= make_number (0xffff / 2);
5078 if (i
== 9 && NUMBERP (color_adjust
))
5079 x_detect_edges (f
, img
, trans
, (int) XFLOATINT (color_adjust
));
5083 /* Transform image IMG on frame F so that it looks disabled. */
5086 x_disable_image (f
, img
)
5090 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
5092 int n_planes
= dpyinfo
->n_planes
* dpyinfo
->n_cbits
;
5094 int n_planes
= dpyinfo
->n_planes
;
5095 #endif /* HAVE_NTGUI */
5099 /* Color (or grayscale). Convert to gray, and equalize. Just
5100 drawing such images with a stipple can look very odd, so
5101 we're using this method instead. */
5102 XColor
*colors
= x_to_xcolors (f
, img
, 1);
5104 const int h
= 15000;
5105 const int l
= 30000;
5107 for (p
= colors
, end
= colors
+ img
->width
* img
->height
;
5111 int i
= COLOR_INTENSITY (p
->red
, p
->green
, p
->blue
);
5112 int i2
= (0xffff - h
- l
) * i
/ 0xffff + l
;
5113 p
->red
= p
->green
= p
->blue
= i2
;
5116 x_from_xcolors (f
, img
, colors
);
5119 /* Draw a cross over the disabled image, if we must or if we
5121 if (n_planes
< 2 || cross_disabled_images
)
5124 Display
*dpy
= FRAME_X_DISPLAY (f
);
5128 #define XCreateGC_pixmap(dpy, pixmap) XCreateGC (dpy, NULL, 0, NULL)
5129 #define MaskForeground(f) PIX_MASK_DRAW
5131 #define XCreateGC_pixmap(dpy, pixmap) XCreateGC (dpy, pixmap, 0, NULL)
5132 #define MaskForeground(f) WHITE_PIX_DEFAULT (f)
5135 gc
= XCreateGC_pixmap (dpy
, img
->pixmap
);
5136 XSetForeground (dpy
, gc
, BLACK_PIX_DEFAULT (f
));
5137 XDrawLine (dpy
, img
->pixmap
, gc
, 0, 0,
5138 img
->width
- 1, img
->height
- 1);
5139 XDrawLine (dpy
, img
->pixmap
, gc
, 0, img
->height
- 1,
5145 gc
= XCreateGC_pixmap (dpy
, img
->mask
);
5146 XSetForeground (dpy
, gc
, MaskForeground (f
));
5147 XDrawLine (dpy
, img
->mask
, gc
, 0, 0,
5148 img
->width
- 1, img
->height
- 1);
5149 XDrawLine (dpy
, img
->mask
, gc
, 0, img
->height
- 1,
5157 hdc
= get_frame_dc (f
);
5158 bmpdc
= CreateCompatibleDC (hdc
);
5159 release_frame_dc (f
, hdc
);
5161 prev
= SelectObject (bmpdc
, img
->pixmap
);
5163 SetTextColor (bmpdc
, BLACK_PIX_DEFAULT (f
));
5164 MoveToEx (bmpdc
, 0, 0, NULL
);
5165 LineTo (bmpdc
, img
->width
- 1, img
->height
- 1);
5166 MoveToEx (bmpdc
, 0, img
->height
- 1, NULL
);
5167 LineTo (bmpdc
, img
->width
- 1, 0);
5171 SelectObject (bmpdc
, img
->mask
);
5172 SetTextColor (bmpdc
, WHITE_PIX_DEFAULT (f
));
5173 MoveToEx (bmpdc
, 0, 0, NULL
);
5174 LineTo (bmpdc
, img
->width
- 1, img
->height
- 1);
5175 MoveToEx (bmpdc
, 0, img
->height
- 1, NULL
);
5176 LineTo (bmpdc
, img
->width
- 1, 0);
5178 SelectObject (bmpdc
, prev
);
5180 #endif /* HAVE_NTGUI */
5185 /* Build a mask for image IMG which is used on frame F. FILE is the
5186 name of an image file, for error messages. HOW determines how to
5187 determine the background color of IMG. If it is a list '(R G B)',
5188 with R, G, and B being integers >= 0, take that as the color of the
5189 background. Otherwise, determine the background color of IMG
5190 heuristically. Value is non-zero if successful. */
5193 x_build_heuristic_mask (f
, img
, how
)
5198 XImagePtr_or_DC ximg
;
5206 #endif /* HAVE_NTGUI */
5207 int x
, y
, rc
, use_img_background
;
5208 unsigned long bg
= 0;
5212 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
5213 img
->mask
= NO_PIXMAP
;
5214 img
->background_transparent_valid
= 0;
5218 /* Create an image and pixmap serving as mask. */
5219 rc
= x_create_x_image_and_pixmap (f
, img
->width
, img
->height
, 1,
5220 &mask_img
, &img
->mask
);
5224 /* Get the X image of IMG->pixmap. */
5225 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
, 0, 0,
5226 img
->width
, img
->height
,
5229 /* Create the bit array serving as mask. */
5230 row_width
= (img
->width
+ 7) / 8;
5231 mask_img
= xmalloc (row_width
* img
->height
);
5232 bzero (mask_img
, row_width
* img
->height
);
5234 /* Create a memory device context for IMG->pixmap. */
5235 frame_dc
= get_frame_dc (f
);
5236 ximg
= CreateCompatibleDC (frame_dc
);
5237 release_frame_dc (f
, frame_dc
);
5238 prev
= SelectObject (ximg
, img
->pixmap
);
5239 #endif /* HAVE_NTGUI */
5241 /* Determine the background color of ximg. If HOW is `(R G B)'
5242 take that as color. Otherwise, use the image's background color. */
5243 use_img_background
= 1;
5249 for (i
= 0; i
< 3 && CONSP (how
) && NATNUMP (XCAR (how
)); ++i
)
5251 rgb
[i
] = XFASTINT (XCAR (how
)) & 0xffff;
5255 if (i
== 3 && NILP (how
))
5257 char color_name
[30];
5258 sprintf (color_name
, "#%04x%04x%04x", rgb
[0], rgb
[1], rgb
[2]);
5261 0x00ffffff & /* Filter out palette info. */
5262 #endif /* HAVE_NTGUI */
5263 x_alloc_image_color (f
, img
, build_string (color_name
), 0));
5264 use_img_background
= 0;
5268 if (use_img_background
)
5269 bg
= four_corners_best (ximg
, img
->width
, img
->height
);
5271 /* Set all bits in mask_img to 1 whose color in ximg is different
5272 from the background color bg. */
5274 for (y
= 0; y
< img
->height
; ++y
)
5275 for (x
= 0; x
< img
->width
; ++x
)
5276 XPutPixel (mask_img
, x
, y
, (XGetPixel (ximg
, x
, y
) != bg
5277 ? PIX_MASK_DRAW
: PIX_MASK_RETAIN
));
5279 /* Fill in the background_transparent field while we have the mask handy. */
5280 image_background_transparent (img
, f
, mask_img
);
5282 /* Put mask_img into img->mask. */
5283 x_put_x_image (f
, mask_img
, img
->mask
, img
->width
, img
->height
);
5284 x_destroy_x_image (mask_img
);
5287 for (y
= 0; y
< img
->height
; ++y
)
5288 for (x
= 0; x
< img
->width
; ++x
)
5290 COLORREF p
= GetPixel (ximg
, x
, y
);
5292 mask_img
[y
* row_width
+ x
/ 8] |= 1 << (x
% 8);
5295 /* Create the mask image. */
5296 img
->mask
= w32_create_pixmap_from_bitmap_data (img
->width
, img
->height
,
5298 /* Fill in the background_transparent field while we have the mask handy. */
5299 SelectObject (ximg
, img
->mask
);
5300 image_background_transparent (img
, f
, ximg
);
5302 /* Was: x_destroy_x_image ((XImagePtr )mask_img); which seems bogus ++kfs */
5304 #endif /* HAVE_NTGUI */
5306 Destroy_Image (ximg
, prev
);
5312 /***********************************************************************
5313 PBM (mono, gray, color)
5314 ***********************************************************************/
5316 static int pbm_image_p
P_ ((Lisp_Object object
));
5317 static int pbm_load
P_ ((struct frame
*f
, struct image
*img
));
5318 static int pbm_scan_number
P_ ((unsigned char **, unsigned char *));
5320 /* The symbol `pbm' identifying images of this type. */
5324 /* Indices of image specification fields in gs_format, below. */
5326 enum pbm_keyword_index
5342 /* Vector of image_keyword structures describing the format
5343 of valid user-defined image specifications. */
5345 static struct image_keyword pbm_format
[PBM_LAST
] =
5347 {":type", IMAGE_SYMBOL_VALUE
, 1},
5348 {":file", IMAGE_STRING_VALUE
, 0},
5349 {":data", IMAGE_STRING_VALUE
, 0},
5350 {":ascent", IMAGE_ASCENT_VALUE
, 0},
5351 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
5352 {":relief", IMAGE_INTEGER_VALUE
, 0},
5353 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5354 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5355 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5356 {":foreground", IMAGE_STRING_OR_NIL_VALUE
, 0},
5357 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
5360 /* Structure describing the image type `pbm'. */
5362 static struct image_type pbm_type
=
5372 /* Return non-zero if OBJECT is a valid PBM image specification. */
5375 pbm_image_p (object
)
5378 struct image_keyword fmt
[PBM_LAST
];
5380 bcopy (pbm_format
, fmt
, sizeof fmt
);
5382 if (!parse_image_spec (object
, fmt
, PBM_LAST
, Qpbm
))
5385 /* Must specify either :data or :file. */
5386 return fmt
[PBM_DATA
].count
+ fmt
[PBM_FILE
].count
== 1;
5390 /* Scan a decimal number from *S and return it. Advance *S while
5391 reading the number. END is the end of the string. Value is -1 at
5395 pbm_scan_number (s
, end
)
5396 unsigned char **s
, *end
;
5398 int c
= 0, val
= -1;
5402 /* Skip white-space. */
5403 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
5408 /* Skip comment to end of line. */
5409 while (*s
< end
&& (c
= *(*s
)++, c
!= '\n'))
5412 else if (isdigit (c
))
5414 /* Read decimal number. */
5416 while (*s
< end
&& (c
= *(*s
)++, isdigit (c
)))
5417 val
= 10 * val
+ c
- '0';
5429 #if 0 /* Unused. ++kfs */
5431 /* Read FILE into memory. Value is a pointer to a buffer allocated
5432 with xmalloc holding FILE's contents. Value is null if an error
5433 occurred. *SIZE is set to the size of the file. */
5436 pbm_read_file (file
, size
)
5444 if (stat (SDATA (file
), &st
) == 0
5445 && (fp
= fopen (SDATA (file
), "rb")) != NULL
5446 && (buf
= (char *) xmalloc (st
.st_size
),
5447 fread (buf
, 1, st
.st_size
, fp
) == st
.st_size
))
5466 #endif /* HAVE_NTGUI */
5468 /* Load PBM image IMG for use on frame F. */
5476 int width
, height
, max_color_idx
= 0;
5478 Lisp_Object file
, specified_file
;
5479 enum {PBM_MONO
, PBM_GRAY
, PBM_COLOR
} type
;
5480 struct gcpro gcpro1
;
5481 unsigned char *contents
= NULL
;
5482 unsigned char *end
, *p
;
5485 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
5489 if (STRINGP (specified_file
))
5491 file
= x_find_image_file (specified_file
);
5492 if (!STRINGP (file
))
5494 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
5499 contents
= slurp_file (SDATA (file
), &size
);
5500 if (contents
== NULL
)
5502 image_error ("Error reading `%s'", file
, Qnil
);
5508 end
= contents
+ size
;
5513 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
5515 end
= p
+ SBYTES (data
);
5518 /* Check magic number. */
5519 if (end
- p
< 2 || *p
++ != 'P')
5521 image_error ("Not a PBM image: `%s'", img
->spec
, Qnil
);
5531 raw_p
= 0, type
= PBM_MONO
;
5535 raw_p
= 0, type
= PBM_GRAY
;
5539 raw_p
= 0, type
= PBM_COLOR
;
5543 raw_p
= 1, type
= PBM_MONO
;
5547 raw_p
= 1, type
= PBM_GRAY
;
5551 raw_p
= 1, type
= PBM_COLOR
;
5555 image_error ("Not a PBM image: `%s'", img
->spec
, Qnil
);
5559 /* Read width, height, maximum color-component. Characters
5560 starting with `#' up to the end of a line are ignored. */
5561 width
= pbm_scan_number (&p
, end
);
5562 height
= pbm_scan_number (&p
, end
);
5564 if (type
!= PBM_MONO
)
5566 max_color_idx
= pbm_scan_number (&p
, end
);
5567 if (raw_p
&& max_color_idx
> 255)
5568 max_color_idx
= 255;
5571 if (!check_image_size (f
, width
, height
)
5572 || (type
!= PBM_MONO
&& max_color_idx
< 0))
5575 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0,
5576 &ximg
, &img
->pixmap
))
5579 /* Initialize the color hash table. */
5580 init_color_table ();
5582 if (type
== PBM_MONO
)
5585 struct image_keyword fmt
[PBM_LAST
];
5586 unsigned long fg
= FRAME_FOREGROUND_PIXEL (f
);
5587 unsigned long bg
= FRAME_BACKGROUND_PIXEL (f
);
5589 /* Parse the image specification. */
5590 bcopy (pbm_format
, fmt
, sizeof fmt
);
5591 parse_image_spec (img
->spec
, fmt
, PBM_LAST
, Qpbm
);
5593 /* Get foreground and background colors, maybe allocate colors. */
5594 if (fmt
[PBM_FOREGROUND
].count
5595 && STRINGP (fmt
[PBM_FOREGROUND
].value
))
5596 fg
= x_alloc_image_color (f
, img
, fmt
[PBM_FOREGROUND
].value
, fg
);
5597 if (fmt
[PBM_BACKGROUND
].count
5598 && STRINGP (fmt
[PBM_BACKGROUND
].value
))
5600 bg
= x_alloc_image_color (f
, img
, fmt
[PBM_BACKGROUND
].value
, bg
);
5601 img
->background
= bg
;
5602 img
->background_valid
= 1;
5605 for (y
= 0; y
< height
; ++y
)
5606 for (x
= 0; x
< width
; ++x
)
5616 g
= pbm_scan_number (&p
, end
);
5618 XPutPixel (ximg
, x
, y
, g
? fg
: bg
);
5623 for (y
= 0; y
< height
; ++y
)
5624 for (x
= 0; x
< width
; ++x
)
5628 if (type
== PBM_GRAY
)
5629 r
= g
= b
= raw_p
? *p
++ : pbm_scan_number (&p
, end
);
5638 r
= pbm_scan_number (&p
, end
);
5639 g
= pbm_scan_number (&p
, end
);
5640 b
= pbm_scan_number (&p
, end
);
5643 if (r
< 0 || g
< 0 || b
< 0)
5645 x_destroy_x_image (ximg
);
5646 image_error ("Invalid pixel value in image `%s'",
5651 /* RGB values are now in the range 0..max_color_idx.
5652 Scale this to the range 0..0xffff supported by X. */
5653 r
= (double) r
* 65535 / max_color_idx
;
5654 g
= (double) g
* 65535 / max_color_idx
;
5655 b
= (double) b
* 65535 / max_color_idx
;
5656 XPutPixel (ximg
, x
, y
, lookup_rgb_color (f
, r
, g
, b
));
5660 #ifdef COLOR_TABLE_SUPPORT
5661 /* Store in IMG->colors the colors allocated for the image, and
5662 free the color table. */
5663 img
->colors
= colors_in_color_table (&img
->ncolors
);
5664 free_color_table ();
5665 #endif /* COLOR_TABLE_SUPPORT */
5668 img
->height
= height
;
5670 /* Maybe fill in the background field while we have ximg handy. */
5672 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
5673 /* Casting avoids a GCC warning. */
5674 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
5676 /* Put the image into a pixmap. */
5677 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
5678 x_destroy_x_image (ximg
);
5680 /* X and W32 versions did it here, MAC version above. ++kfs
5682 img->height = height; */
5690 /***********************************************************************
5692 ***********************************************************************/
5694 #if defined (HAVE_PNG) || defined (MAC_OS)
5696 /* Function prototypes. */
5698 static int png_image_p
P_ ((Lisp_Object object
));
5699 static int png_load
P_ ((struct frame
*f
, struct image
*img
));
5701 /* The symbol `png' identifying images of this type. */
5705 /* Indices of image specification fields in png_format, below. */
5707 enum png_keyword_index
5722 /* Vector of image_keyword structures describing the format
5723 of valid user-defined image specifications. */
5725 static struct image_keyword png_format
[PNG_LAST
] =
5727 {":type", IMAGE_SYMBOL_VALUE
, 1},
5728 {":data", IMAGE_STRING_VALUE
, 0},
5729 {":file", IMAGE_STRING_VALUE
, 0},
5730 {":ascent", IMAGE_ASCENT_VALUE
, 0},
5731 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
5732 {":relief", IMAGE_INTEGER_VALUE
, 0},
5733 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5734 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5735 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5736 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
5739 /* Structure describing the image type `png'. */
5741 static struct image_type png_type
=
5750 /* Return non-zero if OBJECT is a valid PNG image specification. */
5753 png_image_p (object
)
5756 struct image_keyword fmt
[PNG_LAST
];
5757 bcopy (png_format
, fmt
, sizeof fmt
);
5759 if (!parse_image_spec (object
, fmt
, PNG_LAST
, Qpng
))
5762 /* Must specify either the :data or :file keyword. */
5763 return fmt
[PNG_FILE
].count
+ fmt
[PNG_DATA
].count
== 1;
5766 #endif /* HAVE_PNG || MAC_OS */
5771 #if defined HAVE_LIBPNG_PNG_H
5772 # include <libpng/png.h>
5778 /* PNG library details. */
5780 DEF_IMGLIB_FN (png_get_io_ptr
);
5781 DEF_IMGLIB_FN (png_check_sig
);
5782 DEF_IMGLIB_FN (png_create_read_struct
);
5783 DEF_IMGLIB_FN (png_create_info_struct
);
5784 DEF_IMGLIB_FN (png_destroy_read_struct
);
5785 DEF_IMGLIB_FN (png_set_read_fn
);
5786 DEF_IMGLIB_FN (png_set_sig_bytes
);
5787 DEF_IMGLIB_FN (png_read_info
);
5788 DEF_IMGLIB_FN (png_get_IHDR
);
5789 DEF_IMGLIB_FN (png_get_valid
);
5790 DEF_IMGLIB_FN (png_set_strip_16
);
5791 DEF_IMGLIB_FN (png_set_expand
);
5792 DEF_IMGLIB_FN (png_set_gray_to_rgb
);
5793 DEF_IMGLIB_FN (png_set_background
);
5794 DEF_IMGLIB_FN (png_get_bKGD
);
5795 DEF_IMGLIB_FN (png_read_update_info
);
5796 DEF_IMGLIB_FN (png_get_channels
);
5797 DEF_IMGLIB_FN (png_get_rowbytes
);
5798 DEF_IMGLIB_FN (png_read_image
);
5799 DEF_IMGLIB_FN (png_read_end
);
5800 DEF_IMGLIB_FN (png_error
);
5803 init_png_functions (Lisp_Object libraries
)
5807 /* Try loading libpng under probable names. */
5808 if (!(library
= w32_delayed_load (libraries
, Qpng
)))
5811 LOAD_IMGLIB_FN (library
, png_get_io_ptr
);
5812 LOAD_IMGLIB_FN (library
, png_check_sig
);
5813 LOAD_IMGLIB_FN (library
, png_create_read_struct
);
5814 LOAD_IMGLIB_FN (library
, png_create_info_struct
);
5815 LOAD_IMGLIB_FN (library
, png_destroy_read_struct
);
5816 LOAD_IMGLIB_FN (library
, png_set_read_fn
);
5817 LOAD_IMGLIB_FN (library
, png_set_sig_bytes
);
5818 LOAD_IMGLIB_FN (library
, png_read_info
);
5819 LOAD_IMGLIB_FN (library
, png_get_IHDR
);
5820 LOAD_IMGLIB_FN (library
, png_get_valid
);
5821 LOAD_IMGLIB_FN (library
, png_set_strip_16
);
5822 LOAD_IMGLIB_FN (library
, png_set_expand
);
5823 LOAD_IMGLIB_FN (library
, png_set_gray_to_rgb
);
5824 LOAD_IMGLIB_FN (library
, png_set_background
);
5825 LOAD_IMGLIB_FN (library
, png_get_bKGD
);
5826 LOAD_IMGLIB_FN (library
, png_read_update_info
);
5827 LOAD_IMGLIB_FN (library
, png_get_channels
);
5828 LOAD_IMGLIB_FN (library
, png_get_rowbytes
);
5829 LOAD_IMGLIB_FN (library
, png_read_image
);
5830 LOAD_IMGLIB_FN (library
, png_read_end
);
5831 LOAD_IMGLIB_FN (library
, png_error
);
5836 #define fn_png_get_io_ptr png_get_io_ptr
5837 #define fn_png_check_sig png_check_sig
5838 #define fn_png_create_read_struct png_create_read_struct
5839 #define fn_png_create_info_struct png_create_info_struct
5840 #define fn_png_destroy_read_struct png_destroy_read_struct
5841 #define fn_png_set_read_fn png_set_read_fn
5842 #define fn_png_set_sig_bytes png_set_sig_bytes
5843 #define fn_png_read_info png_read_info
5844 #define fn_png_get_IHDR png_get_IHDR
5845 #define fn_png_get_valid png_get_valid
5846 #define fn_png_set_strip_16 png_set_strip_16
5847 #define fn_png_set_expand png_set_expand
5848 #define fn_png_set_gray_to_rgb png_set_gray_to_rgb
5849 #define fn_png_set_background png_set_background
5850 #define fn_png_get_bKGD png_get_bKGD
5851 #define fn_png_read_update_info png_read_update_info
5852 #define fn_png_get_channels png_get_channels
5853 #define fn_png_get_rowbytes png_get_rowbytes
5854 #define fn_png_read_image png_read_image
5855 #define fn_png_read_end png_read_end
5856 #define fn_png_error png_error
5858 #endif /* HAVE_NTGUI */
5860 /* Error and warning handlers installed when the PNG library
5864 my_png_error (png_ptr
, msg
)
5865 png_struct
*png_ptr
;
5868 xassert (png_ptr
!= NULL
);
5869 image_error ("PNG error: %s", build_string (msg
), Qnil
);
5870 longjmp (png_ptr
->jmpbuf
, 1);
5875 my_png_warning (png_ptr
, msg
)
5876 png_struct
*png_ptr
;
5879 xassert (png_ptr
!= NULL
);
5880 image_error ("PNG warning: %s", build_string (msg
), Qnil
);
5883 /* Memory source for PNG decoding. */
5885 struct png_memory_storage
5887 unsigned char *bytes
; /* The data */
5888 size_t len
; /* How big is it? */
5889 int index
; /* Where are we? */
5893 /* Function set as reader function when reading PNG image from memory.
5894 PNG_PTR is a pointer to the PNG control structure. Copy LENGTH
5895 bytes from the input to DATA. */
5898 png_read_from_memory (png_ptr
, data
, length
)
5899 png_structp png_ptr
;
5903 struct png_memory_storage
*tbr
5904 = (struct png_memory_storage
*) fn_png_get_io_ptr (png_ptr
);
5906 if (length
> tbr
->len
- tbr
->index
)
5907 fn_png_error (png_ptr
, "Read error");
5909 bcopy (tbr
->bytes
+ tbr
->index
, data
, length
);
5910 tbr
->index
= tbr
->index
+ length
;
5914 /* Function set as reader function when reading PNG image from a file.
5915 PNG_PTR is a pointer to the PNG control structure. Copy LENGTH
5916 bytes from the input to DATA. */
5919 png_read_from_file (png_ptr
, data
, length
)
5920 png_structp png_ptr
;
5924 FILE *fp
= (FILE *) fn_png_get_io_ptr (png_ptr
);
5926 if (fread (data
, 1, length
, fp
) < length
)
5927 fn_png_error (png_ptr
, "Read error");
5931 /* Load PNG image IMG for use on frame F. Value is non-zero if
5939 Lisp_Object file
, specified_file
;
5940 Lisp_Object specified_data
;
5942 XImagePtr ximg
, mask_img
= NULL
;
5943 struct gcpro gcpro1
;
5944 png_struct
*png_ptr
= NULL
;
5945 png_info
*info_ptr
= NULL
, *end_info
= NULL
;
5946 FILE *volatile fp
= NULL
;
5948 png_byte
* volatile pixels
= NULL
;
5949 png_byte
** volatile rows
= NULL
;
5950 png_uint_32 width
, height
;
5951 int bit_depth
, color_type
, interlace_type
;
5953 png_uint_32 row_bytes
;
5955 double screen_gamma
;
5956 struct png_memory_storage tbr
; /* Data to be read */
5958 /* Find out what file to load. */
5959 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
5960 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
5964 if (NILP (specified_data
))
5966 file
= x_find_image_file (specified_file
);
5967 if (!STRINGP (file
))
5969 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
5974 /* Open the image file. */
5975 fp
= fopen (SDATA (file
), "rb");
5978 image_error ("Cannot open image file `%s'", file
, Qnil
);
5984 /* Check PNG signature. */
5985 if (fread (sig
, 1, sizeof sig
, fp
) != sizeof sig
5986 || !fn_png_check_sig (sig
, sizeof sig
))
5988 image_error ("Not a PNG file: `%s'", file
, Qnil
);
5996 /* Read from memory. */
5997 tbr
.bytes
= SDATA (specified_data
);
5998 tbr
.len
= SBYTES (specified_data
);
6001 /* Check PNG signature. */
6002 if (tbr
.len
< sizeof sig
6003 || !fn_png_check_sig (tbr
.bytes
, sizeof sig
))
6005 image_error ("Not a PNG image: `%s'", img
->spec
, Qnil
);
6010 /* Need to skip past the signature. */
6011 tbr
.bytes
+= sizeof (sig
);
6014 /* Initialize read and info structs for PNG lib. Casting return
6015 value avoids a GCC warning on W32. */
6016 png_ptr
= (png_structp
)fn_png_create_read_struct (PNG_LIBPNG_VER_STRING
,
6021 if (fp
) fclose (fp
);
6026 /* Casting return value avoids a GCC warning on W32. */
6027 info_ptr
= (png_infop
)fn_png_create_info_struct (png_ptr
);
6030 fn_png_destroy_read_struct (&png_ptr
, NULL
, NULL
);
6031 if (fp
) fclose (fp
);
6036 /* Casting return value avoids a GCC warning on W32. */
6037 end_info
= (png_infop
)fn_png_create_info_struct (png_ptr
);
6040 fn_png_destroy_read_struct (&png_ptr
, &info_ptr
, NULL
);
6041 if (fp
) fclose (fp
);
6046 /* Set error jump-back. We come back here when the PNG library
6047 detects an error. */
6048 if (setjmp (png_ptr
->jmpbuf
))
6052 fn_png_destroy_read_struct (&png_ptr
, &info_ptr
, &end_info
);
6055 if (fp
) fclose (fp
);
6060 /* Read image info. */
6061 if (!NILP (specified_data
))
6062 fn_png_set_read_fn (png_ptr
, (void *) &tbr
, png_read_from_memory
);
6064 fn_png_set_read_fn (png_ptr
, (void *) fp
, png_read_from_file
);
6066 fn_png_set_sig_bytes (png_ptr
, sizeof sig
);
6067 fn_png_read_info (png_ptr
, info_ptr
);
6068 fn_png_get_IHDR (png_ptr
, info_ptr
, &width
, &height
, &bit_depth
, &color_type
,
6069 &interlace_type
, NULL
, NULL
);
6071 if (!check_image_size (f
, width
, height
))
6074 /* If image contains simply transparency data, we prefer to
6075 construct a clipping mask. */
6076 if (fn_png_get_valid (png_ptr
, info_ptr
, PNG_INFO_tRNS
))
6081 /* This function is easier to write if we only have to handle
6082 one data format: RGB or RGBA with 8 bits per channel. Let's
6083 transform other formats into that format. */
6085 /* Strip more than 8 bits per channel. */
6086 if (bit_depth
== 16)
6087 fn_png_set_strip_16 (png_ptr
);
6089 /* Expand data to 24 bit RGB, or 8 bit grayscale, with alpha channel
6091 fn_png_set_expand (png_ptr
);
6093 /* Convert grayscale images to RGB. */
6094 if (color_type
== PNG_COLOR_TYPE_GRAY
6095 || color_type
== PNG_COLOR_TYPE_GRAY_ALPHA
)
6096 fn_png_set_gray_to_rgb (png_ptr
);
6098 screen_gamma
= (f
->gamma
? 1 / f
->gamma
/ 0.45455 : 2.2);
6100 #if 0 /* Avoid double gamma correction for PNG images. */
6101 { /* Tell the PNG lib to handle gamma correction for us. */
6104 #if defined(PNG_READ_sRGB_SUPPORTED) || defined(PNG_WRITE_sRGB_SUPPORTED)
6105 if (png_get_sRGB (png_ptr
, info_ptr
, &intent
))
6106 /* The libpng documentation says this is right in this case. */
6107 png_set_gamma (png_ptr
, screen_gamma
, 0.45455);
6110 if (png_get_gAMA (png_ptr
, info_ptr
, &image_gamma
))
6111 /* Image contains gamma information. */
6112 png_set_gamma (png_ptr
, screen_gamma
, image_gamma
);
6114 /* Use the standard default for the image gamma. */
6115 png_set_gamma (png_ptr
, screen_gamma
, 0.45455);
6119 /* Handle alpha channel by combining the image with a background
6120 color. Do this only if a real alpha channel is supplied. For
6121 simple transparency, we prefer a clipping mask. */
6124 png_color_16
*image_bg
;
6125 Lisp_Object specified_bg
6126 = image_spec_value (img
->spec
, QCbackground
, NULL
);
6128 if (STRINGP (specified_bg
))
6129 /* The user specified `:background', use that. */
6131 /* W32 version incorrectly used COLORREF here!! ++kfs */
6133 if (x_defined_color (f
, SDATA (specified_bg
), &color
, 0))
6135 png_color_16 user_bg
;
6137 bzero (&user_bg
, sizeof user_bg
);
6138 user_bg
.red
= color
.red
>> 8;
6139 user_bg
.green
= color
.green
>> 8;
6140 user_bg
.blue
= color
.blue
>> 8;
6142 fn_png_set_background (png_ptr
, &user_bg
,
6143 PNG_BACKGROUND_GAMMA_SCREEN
, 0, 1.0);
6146 else if (fn_png_get_bKGD (png_ptr
, info_ptr
, &image_bg
))
6147 /* Image contains a background color with which to
6148 combine the image. */
6149 fn_png_set_background (png_ptr
, image_bg
,
6150 PNG_BACKGROUND_GAMMA_FILE
, 1, 1.0);
6153 /* Image does not contain a background color with which
6154 to combine the image data via an alpha channel. Use
6155 the frame's background instead. */
6156 #ifdef HAVE_X_WINDOWS
6158 png_color_16 frame_background
;
6160 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
6161 x_query_color (f
, &color
);
6163 bzero (&frame_background
, sizeof frame_background
);
6164 frame_background
.red
= color
.red
>> 8;
6165 frame_background
.green
= color
.green
>> 8;
6166 frame_background
.blue
= color
.blue
>> 8;
6167 #endif /* HAVE_X_WINDOWS */
6171 png_color_16 frame_background
;
6172 color
= FRAME_BACKGROUND_PIXEL (f
);
6173 #if 0 /* W32 TODO : Colormap support. */
6174 x_query_color (f
, &color
);
6176 bzero (&frame_background
, sizeof frame_background
);
6177 frame_background
.red
= GetRValue (color
);
6178 frame_background
.green
= GetGValue (color
);
6179 frame_background
.blue
= GetBValue (color
);
6180 #endif /* HAVE_NTGUI */
6183 unsigned long color
;
6184 png_color_16 frame_background
;
6185 color
= FRAME_BACKGROUND_PIXEL (f
);
6186 #if 0 /* MAC/W32 TODO : Colormap support. */
6187 x_query_color (f
, &color
);
6189 bzero (&frame_background
, sizeof frame_background
);
6190 frame_background
.red
= RED_FROM_ULONG (color
);
6191 frame_background
.green
= GREEN_FROM_ULONG (color
);
6192 frame_background
.blue
= BLUE_FROM_ULONG (color
);
6195 fn_png_set_background (png_ptr
, &frame_background
,
6196 PNG_BACKGROUND_GAMMA_SCREEN
, 0, 1.0);
6200 /* Update info structure. */
6201 fn_png_read_update_info (png_ptr
, info_ptr
);
6203 /* Get number of channels. Valid values are 1 for grayscale images
6204 and images with a palette, 2 for grayscale images with transparency
6205 information (alpha channel), 3 for RGB images, and 4 for RGB
6206 images with alpha channel, i.e. RGBA. If conversions above were
6207 sufficient we should only have 3 or 4 channels here. */
6208 channels
= fn_png_get_channels (png_ptr
, info_ptr
);
6209 xassert (channels
== 3 || channels
== 4);
6211 /* Number of bytes needed for one row of the image. */
6212 row_bytes
= fn_png_get_rowbytes (png_ptr
, info_ptr
);
6214 /* Allocate memory for the image. */
6215 pixels
= (png_byte
*) xmalloc (row_bytes
* height
* sizeof *pixels
);
6216 rows
= (png_byte
**) xmalloc (height
* sizeof *rows
);
6217 for (i
= 0; i
< height
; ++i
)
6218 rows
[i
] = pixels
+ i
* row_bytes
;
6220 /* Read the entire image. */
6221 fn_png_read_image (png_ptr
, rows
);
6222 fn_png_read_end (png_ptr
, info_ptr
);
6229 /* Create the X image and pixmap. */
6230 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
,
6234 /* Create an image and pixmap serving as mask if the PNG image
6235 contains an alpha channel. */
6238 && !x_create_x_image_and_pixmap (f
, width
, height
, 1,
6239 &mask_img
, &img
->mask
))
6241 x_destroy_x_image (ximg
);
6242 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->pixmap
);
6243 img
->pixmap
= NO_PIXMAP
;
6247 /* Fill the X image and mask from PNG data. */
6248 init_color_table ();
6250 for (y
= 0; y
< height
; ++y
)
6252 png_byte
*p
= rows
[y
];
6254 for (x
= 0; x
< width
; ++x
)
6261 XPutPixel (ximg
, x
, y
, lookup_rgb_color (f
, r
, g
, b
));
6262 /* An alpha channel, aka mask channel, associates variable
6263 transparency with an image. Where other image formats
6264 support binary transparency---fully transparent or fully
6265 opaque---PNG allows up to 254 levels of partial transparency.
6266 The PNG library implements partial transparency by combining
6267 the image with a specified background color.
6269 I'm not sure how to handle this here nicely: because the
6270 background on which the image is displayed may change, for
6271 real alpha channel support, it would be necessary to create
6272 a new image for each possible background.
6274 What I'm doing now is that a mask is created if we have
6275 boolean transparency information. Otherwise I'm using
6276 the frame's background color to combine the image with. */
6281 XPutPixel (mask_img
, x
, y
, *p
> 0 ? PIX_MASK_DRAW
: PIX_MASK_RETAIN
);
6287 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
6288 /* Set IMG's background color from the PNG image, unless the user
6292 if (fn_png_get_bKGD (png_ptr
, info_ptr
, &bg
))
6294 img
->background
= lookup_rgb_color (f
, bg
->red
, bg
->green
, bg
->blue
);
6295 img
->background_valid
= 1;
6299 #ifdef COLOR_TABLE_SUPPORT
6300 /* Remember colors allocated for this image. */
6301 img
->colors
= colors_in_color_table (&img
->ncolors
);
6302 free_color_table ();
6303 #endif /* COLOR_TABLE_SUPPORT */
6306 fn_png_destroy_read_struct (&png_ptr
, &info_ptr
, &end_info
);
6311 img
->height
= height
;
6313 /* Maybe fill in the background field while we have ximg handy.
6314 Casting avoids a GCC warning. */
6315 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
6317 /* Put the image into the pixmap, then free the X image and its buffer. */
6318 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
6319 x_destroy_x_image (ximg
);
6321 /* Same for the mask. */
6324 /* Fill in the background_transparent field while we have the
6325 mask handy. Casting avoids a GCC warning. */
6326 image_background_transparent (img
, f
, (XImagePtr_or_DC
)mask_img
);
6328 x_put_x_image (f
, mask_img
, img
->mask
, img
->width
, img
->height
);
6329 x_destroy_x_image (mask_img
);
6336 #else /* HAVE_PNG */
6345 if (MyCGImageCreateWithPNGDataProvider
)
6346 return image_load_quartz2d (f
, img
, 1);
6349 return image_load_quicktime (f
, img
, kQTFileTypePNG
);
6353 #endif /* !HAVE_PNG */
6357 /***********************************************************************
6359 ***********************************************************************/
6361 #if defined (HAVE_JPEG) || defined (MAC_OS)
6363 static int jpeg_image_p
P_ ((Lisp_Object object
));
6364 static int jpeg_load
P_ ((struct frame
*f
, struct image
*img
));
6366 /* The symbol `jpeg' identifying images of this type. */
6370 /* Indices of image specification fields in gs_format, below. */
6372 enum jpeg_keyword_index
6381 JPEG_HEURISTIC_MASK
,
6387 /* Vector of image_keyword structures describing the format
6388 of valid user-defined image specifications. */
6390 static struct image_keyword jpeg_format
[JPEG_LAST
] =
6392 {":type", IMAGE_SYMBOL_VALUE
, 1},
6393 {":data", IMAGE_STRING_VALUE
, 0},
6394 {":file", IMAGE_STRING_VALUE
, 0},
6395 {":ascent", IMAGE_ASCENT_VALUE
, 0},
6396 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
6397 {":relief", IMAGE_INTEGER_VALUE
, 0},
6398 {":conversions", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6399 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6400 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6401 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
6404 /* Structure describing the image type `jpeg'. */
6406 static struct image_type jpeg_type
=
6415 /* Return non-zero if OBJECT is a valid JPEG image specification. */
6418 jpeg_image_p (object
)
6421 struct image_keyword fmt
[JPEG_LAST
];
6423 bcopy (jpeg_format
, fmt
, sizeof fmt
);
6425 if (!parse_image_spec (object
, fmt
, JPEG_LAST
, Qjpeg
))
6428 /* Must specify either the :data or :file keyword. */
6429 return fmt
[JPEG_FILE
].count
+ fmt
[JPEG_DATA
].count
== 1;
6432 #endif /* HAVE_JPEG || MAC_OS */
6436 /* Work around a warning about HAVE_STDLIB_H being redefined in
6438 #ifdef HAVE_STDLIB_H
6439 #define HAVE_STDLIB_H_1
6440 #undef HAVE_STDLIB_H
6441 #endif /* HAVE_STLIB_H */
6443 #if defined (HAVE_NTGUI) && !defined (__WIN32__)
6444 /* In older releases of the jpeg library, jpeglib.h will define boolean
6445 differently depending on __WIN32__, so make sure it is defined. */
6449 #include <jpeglib.h>
6453 #ifdef HAVE_STLIB_H_1
6454 #define HAVE_STDLIB_H 1
6459 /* JPEG library details. */
6460 DEF_IMGLIB_FN (jpeg_CreateDecompress
);
6461 DEF_IMGLIB_FN (jpeg_start_decompress
);
6462 DEF_IMGLIB_FN (jpeg_finish_decompress
);
6463 DEF_IMGLIB_FN (jpeg_destroy_decompress
);
6464 DEF_IMGLIB_FN (jpeg_read_header
);
6465 DEF_IMGLIB_FN (jpeg_read_scanlines
);
6466 DEF_IMGLIB_FN (jpeg_std_error
);
6467 DEF_IMGLIB_FN (jpeg_resync_to_restart
);
6470 init_jpeg_functions (Lisp_Object libraries
)
6474 if (!(library
= w32_delayed_load (libraries
, Qjpeg
)))
6477 LOAD_IMGLIB_FN (library
, jpeg_finish_decompress
);
6478 LOAD_IMGLIB_FN (library
, jpeg_read_scanlines
);
6479 LOAD_IMGLIB_FN (library
, jpeg_start_decompress
);
6480 LOAD_IMGLIB_FN (library
, jpeg_read_header
);
6481 LOAD_IMGLIB_FN (library
, jpeg_CreateDecompress
);
6482 LOAD_IMGLIB_FN (library
, jpeg_destroy_decompress
);
6483 LOAD_IMGLIB_FN (library
, jpeg_std_error
);
6484 LOAD_IMGLIB_FN (library
, jpeg_resync_to_restart
);
6488 /* Wrapper since we can't directly assign the function pointer
6489 to another function pointer that was declared more completely easily. */
6491 jpeg_resync_to_restart_wrapper(cinfo
, desired
)
6492 j_decompress_ptr cinfo
;
6495 return fn_jpeg_resync_to_restart (cinfo
, desired
);
6500 #define fn_jpeg_CreateDecompress(a,b,c) jpeg_create_decompress(a)
6501 #define fn_jpeg_start_decompress jpeg_start_decompress
6502 #define fn_jpeg_finish_decompress jpeg_finish_decompress
6503 #define fn_jpeg_destroy_decompress jpeg_destroy_decompress
6504 #define fn_jpeg_read_header jpeg_read_header
6505 #define fn_jpeg_read_scanlines jpeg_read_scanlines
6506 #define fn_jpeg_std_error jpeg_std_error
6507 #define jpeg_resync_to_restart_wrapper jpeg_resync_to_restart
6509 #endif /* HAVE_NTGUI */
6511 struct my_jpeg_error_mgr
6513 struct jpeg_error_mgr pub
;
6514 jmp_buf setjmp_buffer
;
6519 my_error_exit (cinfo
)
6522 struct my_jpeg_error_mgr
*mgr
= (struct my_jpeg_error_mgr
*) cinfo
->err
;
6523 longjmp (mgr
->setjmp_buffer
, 1);
6527 /* Init source method for JPEG data source manager. Called by
6528 jpeg_read_header() before any data is actually read. See
6529 libjpeg.doc from the JPEG lib distribution. */
6532 our_common_init_source (cinfo
)
6533 j_decompress_ptr cinfo
;
6538 /* Method to terminate data source. Called by
6539 jpeg_finish_decompress() after all data has been processed. */
6542 our_common_term_source (cinfo
)
6543 j_decompress_ptr cinfo
;
6548 /* Fill input buffer method for JPEG data source manager. Called
6549 whenever more data is needed. We read the whole image in one step,
6550 so this only adds a fake end of input marker at the end. */
6553 our_memory_fill_input_buffer (cinfo
)
6554 j_decompress_ptr cinfo
;
6556 /* Insert a fake EOI marker. */
6557 struct jpeg_source_mgr
*src
= cinfo
->src
;
6558 static JOCTET buffer
[2];
6560 buffer
[0] = (JOCTET
) 0xFF;
6561 buffer
[1] = (JOCTET
) JPEG_EOI
;
6563 src
->next_input_byte
= buffer
;
6564 src
->bytes_in_buffer
= 2;
6569 /* Method to skip over NUM_BYTES bytes in the image data. CINFO->src
6570 is the JPEG data source manager. */
6573 our_memory_skip_input_data (cinfo
, num_bytes
)
6574 j_decompress_ptr cinfo
;
6577 struct jpeg_source_mgr
*src
= (struct jpeg_source_mgr
*) cinfo
->src
;
6581 if (num_bytes
> src
->bytes_in_buffer
)
6582 ERREXIT (cinfo
, JERR_INPUT_EOF
);
6584 src
->bytes_in_buffer
-= num_bytes
;
6585 src
->next_input_byte
+= num_bytes
;
6590 /* Set up the JPEG lib for reading an image from DATA which contains
6591 LEN bytes. CINFO is the decompression info structure created for
6592 reading the image. */
6595 jpeg_memory_src (cinfo
, data
, len
)
6596 j_decompress_ptr cinfo
;
6600 struct jpeg_source_mgr
*src
;
6602 if (cinfo
->src
== NULL
)
6604 /* First time for this JPEG object? */
6605 cinfo
->src
= (struct jpeg_source_mgr
*)
6606 (*cinfo
->mem
->alloc_small
) ((j_common_ptr
) cinfo
, JPOOL_PERMANENT
,
6607 sizeof (struct jpeg_source_mgr
));
6608 src
= (struct jpeg_source_mgr
*) cinfo
->src
;
6609 src
->next_input_byte
= data
;
6612 src
= (struct jpeg_source_mgr
*) cinfo
->src
;
6613 src
->init_source
= our_common_init_source
;
6614 src
->fill_input_buffer
= our_memory_fill_input_buffer
;
6615 src
->skip_input_data
= our_memory_skip_input_data
;
6616 src
->resync_to_restart
= jpeg_resync_to_restart_wrapper
; /* Use default method. */
6617 src
->term_source
= our_common_term_source
;
6618 src
->bytes_in_buffer
= len
;
6619 src
->next_input_byte
= data
;
6623 struct jpeg_stdio_mgr
6625 struct jpeg_source_mgr mgr
;
6632 /* Size of buffer to read JPEG from file.
6633 Not too big, as we want to use alloc_small. */
6634 #define JPEG_STDIO_BUFFER_SIZE 8192
6637 /* Fill input buffer method for JPEG data source manager. Called
6638 whenever more data is needed. The data is read from a FILE *. */
6641 our_stdio_fill_input_buffer (cinfo
)
6642 j_decompress_ptr cinfo
;
6644 struct jpeg_stdio_mgr
*src
;
6646 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6651 bytes
= fread (src
->buffer
, 1, JPEG_STDIO_BUFFER_SIZE
, src
->file
);
6653 src
->mgr
.bytes_in_buffer
= bytes
;
6656 WARNMS (cinfo
, JWRN_JPEG_EOF
);
6658 src
->buffer
[0] = (JOCTET
) 0xFF;
6659 src
->buffer
[1] = (JOCTET
) JPEG_EOI
;
6660 src
->mgr
.bytes_in_buffer
= 2;
6662 src
->mgr
.next_input_byte
= src
->buffer
;
6669 /* Method to skip over NUM_BYTES bytes in the image data. CINFO->src
6670 is the JPEG data source manager. */
6673 our_stdio_skip_input_data (cinfo
, num_bytes
)
6674 j_decompress_ptr cinfo
;
6677 struct jpeg_stdio_mgr
*src
;
6678 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6680 while (num_bytes
> 0 && !src
->finished
)
6682 if (num_bytes
<= src
->mgr
.bytes_in_buffer
)
6684 src
->mgr
.bytes_in_buffer
-= num_bytes
;
6685 src
->mgr
.next_input_byte
+= num_bytes
;
6690 num_bytes
-= src
->mgr
.bytes_in_buffer
;
6691 src
->mgr
.bytes_in_buffer
= 0;
6692 src
->mgr
.next_input_byte
= NULL
;
6694 our_stdio_fill_input_buffer (cinfo
);
6700 /* Set up the JPEG lib for reading an image from a FILE *.
6701 CINFO is the decompression info structure created for
6702 reading the image. */
6705 jpeg_file_src (cinfo
, fp
)
6706 j_decompress_ptr cinfo
;
6709 struct jpeg_stdio_mgr
*src
;
6711 if (cinfo
->src
!= NULL
)
6712 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6715 /* First time for this JPEG object? */
6716 cinfo
->src
= (struct jpeg_source_mgr
*)
6717 (*cinfo
->mem
->alloc_small
) ((j_common_ptr
) cinfo
, JPOOL_PERMANENT
,
6718 sizeof (struct jpeg_stdio_mgr
));
6719 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6720 src
->buffer
= (JOCTET
*)
6721 (*cinfo
->mem
->alloc_small
) ((j_common_ptr
) cinfo
, JPOOL_PERMANENT
,
6722 JPEG_STDIO_BUFFER_SIZE
);
6727 src
->mgr
.init_source
= our_common_init_source
;
6728 src
->mgr
.fill_input_buffer
= our_stdio_fill_input_buffer
;
6729 src
->mgr
.skip_input_data
= our_stdio_skip_input_data
;
6730 src
->mgr
.resync_to_restart
= jpeg_resync_to_restart_wrapper
; /* Use default method. */
6731 src
->mgr
.term_source
= our_common_term_source
;
6732 src
->mgr
.bytes_in_buffer
= 0;
6733 src
->mgr
.next_input_byte
= NULL
;
6737 /* Load image IMG for use on frame F. Patterned after example.c
6738 from the JPEG lib. */
6745 struct jpeg_decompress_struct cinfo
;
6746 struct my_jpeg_error_mgr mgr
;
6747 Lisp_Object file
, specified_file
;
6748 Lisp_Object specified_data
;
6749 FILE * volatile fp
= NULL
;
6751 int row_stride
, x
, y
;
6752 XImagePtr ximg
= NULL
;
6754 unsigned long *colors
;
6756 struct gcpro gcpro1
;
6758 /* Open the JPEG file. */
6759 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
6760 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
6764 if (NILP (specified_data
))
6766 file
= x_find_image_file (specified_file
);
6767 if (!STRINGP (file
))
6769 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
6774 fp
= fopen (SDATA (file
), "rb");
6777 image_error ("Cannot open `%s'", file
, Qnil
);
6783 /* Customize libjpeg's error handling to call my_error_exit when an
6784 error is detected. This function will perform a longjmp.
6785 Casting return value avoids a GCC warning on W32. */
6786 cinfo
.err
= (struct jpeg_error_mgr
*)fn_jpeg_std_error (&mgr
.pub
);
6787 mgr
.pub
.error_exit
= my_error_exit
;
6789 if ((rc
= setjmp (mgr
.setjmp_buffer
)) != 0)
6793 /* Called from my_error_exit. Display a JPEG error. */
6794 char buffer
[JMSG_LENGTH_MAX
];
6795 cinfo
.err
->format_message ((j_common_ptr
) &cinfo
, buffer
);
6796 image_error ("Error reading JPEG image `%s': %s", img
->spec
,
6797 build_string (buffer
));
6800 /* Close the input file and destroy the JPEG object. */
6802 fclose ((FILE *) fp
);
6803 fn_jpeg_destroy_decompress (&cinfo
);
6805 /* If we already have an XImage, free that. */
6806 x_destroy_x_image (ximg
);
6808 /* Free pixmap and colors. */
6809 x_clear_image (f
, img
);
6815 /* Create the JPEG decompression object. Let it read from fp.
6816 Read the JPEG image header. */
6817 fn_jpeg_CreateDecompress (&cinfo
, JPEG_LIB_VERSION
, sizeof (cinfo
));
6819 if (NILP (specified_data
))
6820 jpeg_file_src (&cinfo
, (FILE *) fp
);
6822 jpeg_memory_src (&cinfo
, SDATA (specified_data
),
6823 SBYTES (specified_data
));
6825 fn_jpeg_read_header (&cinfo
, 1);
6827 /* Customize decompression so that color quantization will be used.
6828 Start decompression. */
6829 cinfo
.quantize_colors
= 1;
6830 fn_jpeg_start_decompress (&cinfo
);
6831 width
= img
->width
= cinfo
.output_width
;
6832 height
= img
->height
= cinfo
.output_height
;
6834 if (!check_image_size (f
, width
, height
))
6836 image_error ("Invalid image size", Qnil
, Qnil
);
6837 longjmp (mgr
.setjmp_buffer
, 2);
6840 /* Create X image and pixmap. */
6841 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
6842 longjmp (mgr
.setjmp_buffer
, 2);
6844 /* Allocate colors. When color quantization is used,
6845 cinfo.actual_number_of_colors has been set with the number of
6846 colors generated, and cinfo.colormap is a two-dimensional array
6847 of color indices in the range 0..cinfo.actual_number_of_colors.
6848 No more than 255 colors will be generated. */
6852 if (cinfo
.out_color_components
> 2)
6853 ir
= 0, ig
= 1, ib
= 2;
6854 else if (cinfo
.out_color_components
> 1)
6855 ir
= 0, ig
= 1, ib
= 0;
6857 ir
= 0, ig
= 0, ib
= 0;
6859 /* Use the color table mechanism because it handles colors that
6860 cannot be allocated nicely. Such colors will be replaced with
6861 a default color, and we don't have to care about which colors
6862 can be freed safely, and which can't. */
6863 init_color_table ();
6864 colors
= (unsigned long *) alloca (cinfo
.actual_number_of_colors
6867 for (i
= 0; i
< cinfo
.actual_number_of_colors
; ++i
)
6869 /* Multiply RGB values with 255 because X expects RGB values
6870 in the range 0..0xffff. */
6871 int r
= cinfo
.colormap
[ir
][i
] << 8;
6872 int g
= cinfo
.colormap
[ig
][i
] << 8;
6873 int b
= cinfo
.colormap
[ib
][i
] << 8;
6874 colors
[i
] = lookup_rgb_color (f
, r
, g
, b
);
6877 #ifdef COLOR_TABLE_SUPPORT
6878 /* Remember those colors actually allocated. */
6879 img
->colors
= colors_in_color_table (&img
->ncolors
);
6880 free_color_table ();
6881 #endif /* COLOR_TABLE_SUPPORT */
6885 row_stride
= width
* cinfo
.output_components
;
6886 buffer
= cinfo
.mem
->alloc_sarray ((j_common_ptr
) &cinfo
, JPOOL_IMAGE
,
6888 for (y
= 0; y
< height
; ++y
)
6890 fn_jpeg_read_scanlines (&cinfo
, buffer
, 1);
6891 for (x
= 0; x
< cinfo
.output_width
; ++x
)
6892 XPutPixel (ximg
, x
, y
, colors
[buffer
[0][x
]]);
6896 fn_jpeg_finish_decompress (&cinfo
);
6897 fn_jpeg_destroy_decompress (&cinfo
);
6899 fclose ((FILE *) fp
);
6901 /* Maybe fill in the background field while we have ximg handy. */
6902 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
6903 /* Casting avoids a GCC warning. */
6904 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
6906 /* Put the image into the pixmap. */
6907 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
6908 x_destroy_x_image (ximg
);
6913 #else /* HAVE_JPEG */
6922 return image_load_quartz2d (f
, img
, 0);
6924 return image_load_quicktime (f
, img
, kQTFileTypeJPEG
);
6929 #endif /* !HAVE_JPEG */
6933 /***********************************************************************
6935 ***********************************************************************/
6937 #if defined (HAVE_TIFF) || defined (MAC_OS)
6939 static int tiff_image_p
P_ ((Lisp_Object object
));
6940 static int tiff_load
P_ ((struct frame
*f
, struct image
*img
));
6942 /* The symbol `tiff' identifying images of this type. */
6946 /* Indices of image specification fields in tiff_format, below. */
6948 enum tiff_keyword_index
6957 TIFF_HEURISTIC_MASK
,
6963 /* Vector of image_keyword structures describing the format
6964 of valid user-defined image specifications. */
6966 static struct image_keyword tiff_format
[TIFF_LAST
] =
6968 {":type", IMAGE_SYMBOL_VALUE
, 1},
6969 {":data", IMAGE_STRING_VALUE
, 0},
6970 {":file", IMAGE_STRING_VALUE
, 0},
6971 {":ascent", IMAGE_ASCENT_VALUE
, 0},
6972 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
6973 {":relief", IMAGE_INTEGER_VALUE
, 0},
6974 {":conversions", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6975 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6976 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6977 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
6980 /* Structure describing the image type `tiff'. */
6982 static struct image_type tiff_type
=
6991 /* Return non-zero if OBJECT is a valid TIFF image specification. */
6994 tiff_image_p (object
)
6997 struct image_keyword fmt
[TIFF_LAST
];
6998 bcopy (tiff_format
, fmt
, sizeof fmt
);
7000 if (!parse_image_spec (object
, fmt
, TIFF_LAST
, Qtiff
))
7003 /* Must specify either the :data or :file keyword. */
7004 return fmt
[TIFF_FILE
].count
+ fmt
[TIFF_DATA
].count
== 1;
7007 #endif /* HAVE_TIFF || MAC_OS */
7015 /* TIFF library details. */
7016 DEF_IMGLIB_FN (TIFFSetErrorHandler
);
7017 DEF_IMGLIB_FN (TIFFSetWarningHandler
);
7018 DEF_IMGLIB_FN (TIFFOpen
);
7019 DEF_IMGLIB_FN (TIFFClientOpen
);
7020 DEF_IMGLIB_FN (TIFFGetField
);
7021 DEF_IMGLIB_FN (TIFFReadRGBAImage
);
7022 DEF_IMGLIB_FN (TIFFClose
);
7025 init_tiff_functions (Lisp_Object libraries
)
7029 if (!(library
= w32_delayed_load (libraries
, Qtiff
)))
7032 LOAD_IMGLIB_FN (library
, TIFFSetErrorHandler
);
7033 LOAD_IMGLIB_FN (library
, TIFFSetWarningHandler
);
7034 LOAD_IMGLIB_FN (library
, TIFFOpen
);
7035 LOAD_IMGLIB_FN (library
, TIFFClientOpen
);
7036 LOAD_IMGLIB_FN (library
, TIFFGetField
);
7037 LOAD_IMGLIB_FN (library
, TIFFReadRGBAImage
);
7038 LOAD_IMGLIB_FN (library
, TIFFClose
);
7044 #define fn_TIFFSetErrorHandler TIFFSetErrorHandler
7045 #define fn_TIFFSetWarningHandler TIFFSetWarningHandler
7046 #define fn_TIFFOpen TIFFOpen
7047 #define fn_TIFFClientOpen TIFFClientOpen
7048 #define fn_TIFFGetField TIFFGetField
7049 #define fn_TIFFReadRGBAImage TIFFReadRGBAImage
7050 #define fn_TIFFClose TIFFClose
7052 #endif /* HAVE_NTGUI */
7055 /* Reading from a memory buffer for TIFF images Based on the PNG
7056 memory source, but we have to provide a lot of extra functions.
7059 We really only need to implement read and seek, but I am not
7060 convinced that the TIFF library is smart enough not to destroy
7061 itself if we only hand it the function pointers we need to
7066 unsigned char *bytes
;
7073 tiff_read_from_memory (data
, buf
, size
)
7078 tiff_memory_source
*src
= (tiff_memory_source
*) data
;
7080 if (size
> src
->len
- src
->index
)
7082 bcopy (src
->bytes
+ src
->index
, buf
, size
);
7088 tiff_write_from_memory (data
, buf
, size
)
7097 tiff_seek_in_memory (data
, off
, whence
)
7102 tiff_memory_source
*src
= (tiff_memory_source
*) data
;
7107 case SEEK_SET
: /* Go from beginning of source. */
7111 case SEEK_END
: /* Go from end of source. */
7112 idx
= src
->len
+ off
;
7115 case SEEK_CUR
: /* Go from current position. */
7116 idx
= src
->index
+ off
;
7119 default: /* Invalid `whence'. */
7123 if (idx
> src
->len
|| idx
< 0)
7131 tiff_close_memory (data
)
7139 tiff_mmap_memory (data
, pbase
, psize
)
7144 /* It is already _IN_ memory. */
7149 tiff_unmap_memory (data
, base
, size
)
7154 /* We don't need to do this. */
7158 tiff_size_of_memory (data
)
7161 return ((tiff_memory_source
*) data
)->len
;
7166 tiff_error_handler (title
, format
, ap
)
7167 const char *title
, *format
;
7173 len
= sprintf (buf
, "TIFF error: %s ", title
);
7174 vsprintf (buf
+ len
, format
, ap
);
7175 add_to_log (buf
, Qnil
, Qnil
);
7180 tiff_warning_handler (title
, format
, ap
)
7181 const char *title
, *format
;
7187 len
= sprintf (buf
, "TIFF warning: %s ", title
);
7188 vsprintf (buf
+ len
, format
, ap
);
7189 add_to_log (buf
, Qnil
, Qnil
);
7193 /* Load TIFF image IMG for use on frame F. Value is non-zero if
7201 Lisp_Object file
, specified_file
;
7202 Lisp_Object specified_data
;
7204 int width
, height
, x
, y
;
7208 struct gcpro gcpro1
;
7209 tiff_memory_source memsrc
;
7211 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
7212 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
7216 fn_TIFFSetErrorHandler (tiff_error_handler
);
7217 fn_TIFFSetWarningHandler (tiff_warning_handler
);
7219 if (NILP (specified_data
))
7221 /* Read from a file */
7222 file
= x_find_image_file (specified_file
);
7223 if (!STRINGP (file
))
7225 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
7230 /* Try to open the image file. Casting return value avoids a
7231 GCC warning on W32. */
7232 tiff
= (TIFF
*)fn_TIFFOpen (SDATA (file
), "r");
7235 image_error ("Cannot open `%s'", file
, Qnil
);
7242 /* Memory source! */
7243 memsrc
.bytes
= SDATA (specified_data
);
7244 memsrc
.len
= SBYTES (specified_data
);
7247 /* Casting return value avoids a GCC warning on W32. */
7248 tiff
= (TIFF
*)fn_TIFFClientOpen ("memory_source", "r", &memsrc
,
7249 (TIFFReadWriteProc
) tiff_read_from_memory
,
7250 (TIFFReadWriteProc
) tiff_write_from_memory
,
7251 tiff_seek_in_memory
,
7253 tiff_size_of_memory
,
7259 image_error ("Cannot open memory source for `%s'", img
->spec
, Qnil
);
7265 /* Get width and height of the image, and allocate a raster buffer
7266 of width x height 32-bit values. */
7267 fn_TIFFGetField (tiff
, TIFFTAG_IMAGEWIDTH
, &width
);
7268 fn_TIFFGetField (tiff
, TIFFTAG_IMAGELENGTH
, &height
);
7270 if (!check_image_size (f
, width
, height
))
7272 image_error ("Invalid image size", Qnil
, Qnil
);
7277 buf
= (uint32
*) xmalloc (width
* height
* sizeof *buf
);
7279 rc
= fn_TIFFReadRGBAImage (tiff
, width
, height
, buf
, 0);
7280 fn_TIFFClose (tiff
);
7283 image_error ("Error reading TIFF image `%s'", img
->spec
, Qnil
);
7289 /* Create the X image and pixmap. */
7290 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
7297 /* Initialize the color table. */
7298 init_color_table ();
7300 /* Process the pixel raster. Origin is in the lower-left corner. */
7301 for (y
= 0; y
< height
; ++y
)
7303 uint32
*row
= buf
+ y
* width
;
7305 for (x
= 0; x
< width
; ++x
)
7307 uint32 abgr
= row
[x
];
7308 int r
= TIFFGetR (abgr
) << 8;
7309 int g
= TIFFGetG (abgr
) << 8;
7310 int b
= TIFFGetB (abgr
) << 8;
7311 XPutPixel (ximg
, x
, height
- 1 - y
, lookup_rgb_color (f
, r
, g
, b
));
7315 #ifdef COLOR_TABLE_SUPPORT
7316 /* Remember the colors allocated for the image. Free the color table. */
7317 img
->colors
= colors_in_color_table (&img
->ncolors
);
7318 free_color_table ();
7319 #endif /* COLOR_TABLE_SUPPORT */
7322 img
->height
= height
;
7324 /* Maybe fill in the background field while we have ximg handy. */
7325 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
7326 /* Casting avoids a GCC warning on W32. */
7327 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
7329 /* Put the image into the pixmap, then free the X image and its buffer. */
7330 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
7331 x_destroy_x_image (ximg
);
7338 #else /* HAVE_TIFF */
7346 return image_load_quicktime (f
, img
, kQTFileTypeTIFF
);
7350 #endif /* !HAVE_TIFF */
7354 /***********************************************************************
7356 ***********************************************************************/
7358 #if defined (HAVE_GIF) || defined (MAC_OS)
7360 static int gif_image_p
P_ ((Lisp_Object object
));
7361 static int gif_load
P_ ((struct frame
*f
, struct image
*img
));
7363 /* The symbol `gif' identifying images of this type. */
7367 /* Indices of image specification fields in gif_format, below. */
7369 enum gif_keyword_index
7385 /* Vector of image_keyword structures describing the format
7386 of valid user-defined image specifications. */
7388 static struct image_keyword gif_format
[GIF_LAST
] =
7390 {":type", IMAGE_SYMBOL_VALUE
, 1},
7391 {":data", IMAGE_STRING_VALUE
, 0},
7392 {":file", IMAGE_STRING_VALUE
, 0},
7393 {":ascent", IMAGE_ASCENT_VALUE
, 0},
7394 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
7395 {":relief", IMAGE_INTEGER_VALUE
, 0},
7396 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7397 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7398 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7399 {":image", IMAGE_NON_NEGATIVE_INTEGER_VALUE
, 0},
7400 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
7403 /* Structure describing the image type `gif'. */
7405 static struct image_type gif_type
=
7414 /* Return non-zero if OBJECT is a valid GIF image specification. */
7417 gif_image_p (object
)
7420 struct image_keyword fmt
[GIF_LAST
];
7421 bcopy (gif_format
, fmt
, sizeof fmt
);
7423 if (!parse_image_spec (object
, fmt
, GIF_LAST
, Qgif
))
7426 /* Must specify either the :data or :file keyword. */
7427 return fmt
[GIF_FILE
].count
+ fmt
[GIF_DATA
].count
== 1;
7430 #endif /* HAVE_GIF || MAC_OS */
7434 #if defined (HAVE_NTGUI) || defined (MAC_OS)
7435 /* winuser.h might define DrawText to DrawTextA or DrawTextW.
7436 Undefine before redefining to avoid a preprocessor warning. */
7440 /* avoid conflict with QuickdrawText.h */
7441 #define DrawText gif_DrawText
7442 #include <gif_lib.h>
7445 #else /* HAVE_NTGUI || MAC_OS */
7447 #include <gif_lib.h>
7449 #endif /* HAVE_NTGUI || MAC_OS */
7454 /* GIF library details. */
7455 DEF_IMGLIB_FN (DGifCloseFile
);
7456 DEF_IMGLIB_FN (DGifSlurp
);
7457 DEF_IMGLIB_FN (DGifOpen
);
7458 DEF_IMGLIB_FN (DGifOpenFileName
);
7461 init_gif_functions (Lisp_Object libraries
)
7465 if (!(library
= w32_delayed_load (libraries
, Qgif
)))
7468 LOAD_IMGLIB_FN (library
, DGifCloseFile
);
7469 LOAD_IMGLIB_FN (library
, DGifSlurp
);
7470 LOAD_IMGLIB_FN (library
, DGifOpen
);
7471 LOAD_IMGLIB_FN (library
, DGifOpenFileName
);
7477 #define fn_DGifCloseFile DGifCloseFile
7478 #define fn_DGifSlurp DGifSlurp
7479 #define fn_DGifOpen DGifOpen
7480 #define fn_DGifOpenFileName DGifOpenFileName
7482 #endif /* HAVE_NTGUI */
7484 /* Reading a GIF image from memory
7485 Based on the PNG memory stuff to a certain extent. */
7489 unsigned char *bytes
;
7495 /* Make the current memory source available to gif_read_from_memory.
7496 It's done this way because not all versions of libungif support
7497 a UserData field in the GifFileType structure. */
7498 static gif_memory_source
*current_gif_memory_src
;
7501 gif_read_from_memory (file
, buf
, len
)
7506 gif_memory_source
*src
= current_gif_memory_src
;
7508 if (len
> src
->len
- src
->index
)
7511 bcopy (src
->bytes
+ src
->index
, buf
, len
);
7517 /* Load GIF image IMG for use on frame F. Value is non-zero if
7525 Lisp_Object file
, specified_file
;
7526 Lisp_Object specified_data
;
7527 int rc
, width
, height
, x
, y
, i
;
7529 ColorMapObject
*gif_color_map
;
7530 unsigned long pixel_colors
[256];
7532 struct gcpro gcpro1
;
7534 int ino
, image_left
, image_top
, image_width
, image_height
;
7535 gif_memory_source memsrc
;
7536 unsigned char *raster
;
7538 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
7539 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
7543 if (NILP (specified_data
))
7545 file
= x_find_image_file (specified_file
);
7546 if (!STRINGP (file
))
7548 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
7553 /* Open the GIF file. Casting return value avoids a GCC warning
7555 gif
= (GifFileType
*)fn_DGifOpenFileName (SDATA (file
));
7558 image_error ("Cannot open `%s'", file
, Qnil
);
7565 /* Read from memory! */
7566 current_gif_memory_src
= &memsrc
;
7567 memsrc
.bytes
= SDATA (specified_data
);
7568 memsrc
.len
= SBYTES (specified_data
);
7571 /* Casting return value avoids a GCC warning on W32. */
7572 gif
= (GifFileType
*)fn_DGifOpen(&memsrc
, gif_read_from_memory
);
7575 image_error ("Cannot open memory source `%s'", img
->spec
, Qnil
);
7581 /* Before reading entire contents, check the declared image size. */
7582 if (!check_image_size (f
, gif
->SWidth
, gif
->SHeight
))
7584 image_error ("Invalid image size", Qnil
, Qnil
);
7585 fn_DGifCloseFile (gif
);
7590 /* Read entire contents. */
7591 rc
= fn_DGifSlurp (gif
);
7592 if (rc
== GIF_ERROR
)
7594 image_error ("Error reading `%s'", img
->spec
, Qnil
);
7595 fn_DGifCloseFile (gif
);
7600 image
= image_spec_value (img
->spec
, QCindex
, NULL
);
7601 ino
= INTEGERP (image
) ? XFASTINT (image
) : 0;
7602 if (ino
>= gif
->ImageCount
)
7604 image_error ("Invalid image number `%s' in image `%s'",
7606 fn_DGifCloseFile (gif
);
7611 image_top
= gif
->SavedImages
[ino
].ImageDesc
.Top
;
7612 image_left
= gif
->SavedImages
[ino
].ImageDesc
.Left
;
7613 image_width
= gif
->SavedImages
[ino
].ImageDesc
.Width
;
7614 image_height
= gif
->SavedImages
[ino
].ImageDesc
.Height
;
7616 width
= img
->width
= max (gif
->SWidth
,
7617 max (gif
->Image
.Left
+ gif
->Image
.Width
,
7618 image_left
+ image_width
));
7619 height
= img
->height
= max (gif
->SHeight
,
7620 max (gif
->Image
.Top
+ gif
->Image
.Height
,
7621 image_top
+ image_height
));
7623 if (!check_image_size (f
, width
, height
))
7625 image_error ("Invalid image size", Qnil
, Qnil
);
7626 fn_DGifCloseFile (gif
);
7631 /* Create the X image and pixmap. */
7632 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
7634 fn_DGifCloseFile (gif
);
7639 /* Allocate colors. */
7640 gif_color_map
= gif
->SavedImages
[ino
].ImageDesc
.ColorMap
;
7642 gif_color_map
= gif
->SColorMap
;
7643 init_color_table ();
7644 bzero (pixel_colors
, sizeof pixel_colors
);
7646 for (i
= 0; i
< gif_color_map
->ColorCount
; ++i
)
7648 int r
= gif_color_map
->Colors
[i
].Red
<< 8;
7649 int g
= gif_color_map
->Colors
[i
].Green
<< 8;
7650 int b
= gif_color_map
->Colors
[i
].Blue
<< 8;
7651 pixel_colors
[i
] = lookup_rgb_color (f
, r
, g
, b
);
7654 #ifdef COLOR_TABLE_SUPPORT
7655 img
->colors
= colors_in_color_table (&img
->ncolors
);
7656 free_color_table ();
7657 #endif /* COLOR_TABLE_SUPPORT */
7659 /* Clear the part of the screen image that are not covered by
7660 the image from the GIF file. Full animated GIF support
7661 requires more than can be done here (see the gif89 spec,
7662 disposal methods). Let's simply assume that the part
7663 not covered by a sub-image is in the frame's background color. */
7664 for (y
= 0; y
< image_top
; ++y
)
7665 for (x
= 0; x
< width
; ++x
)
7666 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7668 for (y
= image_top
+ image_height
; y
< height
; ++y
)
7669 for (x
= 0; x
< width
; ++x
)
7670 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7672 for (y
= image_top
; y
< image_top
+ image_height
; ++y
)
7674 for (x
= 0; x
< image_left
; ++x
)
7675 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7676 for (x
= image_left
+ image_width
; x
< width
; ++x
)
7677 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7680 /* Read the GIF image into the X image. We use a local variable
7681 `raster' here because RasterBits below is a char *, and invites
7682 problems with bytes >= 0x80. */
7683 raster
= (unsigned char *) gif
->SavedImages
[ino
].RasterBits
;
7685 if (gif
->SavedImages
[ino
].ImageDesc
.Interlace
)
7687 static int interlace_start
[] = {0, 4, 2, 1};
7688 static int interlace_increment
[] = {8, 8, 4, 2};
7690 int row
= interlace_start
[0];
7694 for (y
= 0; y
< image_height
; y
++)
7696 if (row
>= image_height
)
7698 row
= interlace_start
[++pass
];
7699 while (row
>= image_height
)
7700 row
= interlace_start
[++pass
];
7703 for (x
= 0; x
< image_width
; x
++)
7705 int i
= raster
[(y
* image_width
) + x
];
7706 XPutPixel (ximg
, x
+ image_left
, row
+ image_top
,
7710 row
+= interlace_increment
[pass
];
7715 for (y
= 0; y
< image_height
; ++y
)
7716 for (x
= 0; x
< image_width
; ++x
)
7718 int i
= raster
[y
* image_width
+ x
];
7719 XPutPixel (ximg
, x
+ image_left
, y
+ image_top
, pixel_colors
[i
]);
7723 fn_DGifCloseFile (gif
);
7725 /* Maybe fill in the background field while we have ximg handy. */
7726 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
7727 /* Casting avoids a GCC warning. */
7728 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
7730 /* Put the image into the pixmap, then free the X image and its buffer. */
7731 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
7732 x_destroy_x_image (ximg
);
7738 #else /* !HAVE_GIF */
7746 Lisp_Object specified_file
, file
;
7747 Lisp_Object specified_data
;
7749 Boolean graphic_p
, movie_p
, prefer_graphic_p
;
7757 Lisp_Object specified_bg
;
7763 struct gcpro gcpro1
;
7768 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
7769 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
7771 if (NILP (specified_data
))
7773 /* Read from a file */
7777 err
= find_image_fsspec (specified_file
, &file
, &fss
);
7781 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
7786 err
= CanQuickTimeOpenFile (&fss
, kQTFileTypeGIF
, 0,
7787 &graphic_p
, &movie_p
, &prefer_graphic_p
, 0);
7791 if (!graphic_p
&& !movie_p
)
7793 if (prefer_graphic_p
)
7794 return image_load_qt_1 (f
, img
, kQTFileTypeGIF
, &fss
, NULL
);
7795 err
= OpenMovieFile (&fss
, &refnum
, fsRdPerm
);
7798 err
= NewMovieFromFile (&movie
, refnum
, NULL
, NULL
, 0, NULL
);
7799 CloseMovieFile (refnum
);
7802 image_error ("Error reading `%s'", file
, Qnil
);
7808 /* Memory source! */
7810 long file_type_atom
[3];
7812 err
= PtrToHand (SDATA (specified_data
), &dh
, SBYTES (specified_data
));
7815 image_error ("Cannot allocate data handle for `%s'",
7820 file_type_atom
[0] = EndianU32_NtoB (sizeof (long) * 3);
7821 file_type_atom
[1] = EndianU32_NtoB (kDataRefExtensionMacOSFileType
);
7822 file_type_atom
[2] = EndianU32_NtoB (kQTFileTypeGIF
);
7823 err
= PtrToHand (&dh
, &dref
, sizeof (Handle
));
7826 err
= PtrAndHand ("\p", dref
, 1);
7828 err
= PtrAndHand (file_type_atom
, dref
, sizeof (long) * 3);
7831 image_error ("Cannot allocate handle data ref for `%s'", img
->spec
, Qnil
);
7834 err
= CanQuickTimeOpenDataRef (dref
, HandleDataHandlerSubType
, &graphic_p
,
7835 &movie_p
, &prefer_graphic_p
, 0);
7839 if (!graphic_p
&& !movie_p
)
7841 if (prefer_graphic_p
)
7845 DisposeHandle (dref
);
7846 success_p
= image_load_qt_1 (f
, img
, kQTFileTypeGIF
, NULL
, dh
);
7850 err
= NewMovieFromDataRef (&movie
, 0, NULL
, dref
,
7851 HandleDataHandlerSubType
);
7852 DisposeHandle (dref
);
7857 image
= image_spec_value (img
->spec
, QCindex
, NULL
);
7858 ino
= INTEGERP (image
) ? XFASTINT (image
) : 0;
7859 track
= GetMovieIndTrack (movie
, 1);
7860 media
= GetTrackMedia (track
);
7861 nsamples
= GetMediaSampleCount (media
);
7862 if (ino
>= nsamples
)
7864 image_error ("Invalid image number `%s' in image `%s'",
7869 specified_bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
7870 if (!STRINGP (specified_bg
) ||
7871 !mac_defined_color (f
, SDATA (specified_bg
), &color
, 0))
7873 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
7874 color
.red
= RED16_FROM_ULONG (color
.pixel
);
7875 color
.green
= GREEN16_FROM_ULONG (color
.pixel
);
7876 color
.blue
= BLUE16_FROM_ULONG (color
.pixel
);
7878 GetMovieBox (movie
, &rect
);
7879 width
= img
->width
= rect
.right
- rect
.left
;
7880 height
= img
->height
= rect
.bottom
- rect
.top
;
7881 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
7884 GetGWorld (&old_port
, &old_gdh
);
7885 SetGWorld (ximg
, NULL
);
7886 bg_color
.red
= color
.red
;
7887 bg_color
.green
= color
.green
;
7888 bg_color
.blue
= color
.blue
;
7889 RGBBackColor (&bg_color
);
7890 SetGWorld (old_port
, old_gdh
);
7891 SetMovieActive (movie
, 1);
7892 SetMovieGWorld (movie
, ximg
, NULL
);
7893 SampleNumToMediaTime (media
, ino
+ 1, &time
, NULL
);
7894 SetMovieTimeValue (movie
, time
);
7895 MoviesTask (movie
, 0L);
7896 DisposeTrackMedia (media
);
7897 DisposeMovieTrack (track
);
7898 DisposeMovie (movie
);
7901 /* Maybe fill in the background field while we have ximg handy. */
7902 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
7903 IMAGE_BACKGROUND (img
, f
, ximg
);
7905 /* Put the image into the pixmap. */
7906 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
7907 x_destroy_x_image (ximg
);
7911 image_error ("Cannot open `%s'", file
, Qnil
);
7914 DisposeTrackMedia (media
);
7916 DisposeMovieTrack (track
);
7918 DisposeMovie (movie
);
7925 #endif /* HAVE_GIF */
7929 /***********************************************************************
7931 ***********************************************************************/
7933 #ifdef HAVE_X_WINDOWS
7934 #define HAVE_GHOSTSCRIPT 1
7935 #endif /* HAVE_X_WINDOWS */
7937 /* The symbol `postscript' identifying images of this type. */
7939 Lisp_Object Qpostscript
;
7941 #ifdef HAVE_GHOSTSCRIPT
7943 static int gs_image_p
P_ ((Lisp_Object object
));
7944 static int gs_load
P_ ((struct frame
*f
, struct image
*img
));
7945 static void gs_clear_image
P_ ((struct frame
*f
, struct image
*img
));
7947 /* Keyword symbols. */
7949 Lisp_Object QCloader
, QCbounding_box
, QCpt_width
, QCpt_height
;
7951 /* Indices of image specification fields in gs_format, below. */
7953 enum gs_keyword_index
7971 /* Vector of image_keyword structures describing the format
7972 of valid user-defined image specifications. */
7974 static struct image_keyword gs_format
[GS_LAST
] =
7976 {":type", IMAGE_SYMBOL_VALUE
, 1},
7977 {":pt-width", IMAGE_POSITIVE_INTEGER_VALUE
, 1},
7978 {":pt-height", IMAGE_POSITIVE_INTEGER_VALUE
, 1},
7979 {":file", IMAGE_STRING_VALUE
, 1},
7980 {":loader", IMAGE_FUNCTION_VALUE
, 0},
7981 {":bounding-box", IMAGE_DONT_CHECK_VALUE_TYPE
, 1},
7982 {":ascent", IMAGE_ASCENT_VALUE
, 0},
7983 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
7984 {":relief", IMAGE_INTEGER_VALUE
, 0},
7985 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7986 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7987 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7988 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
7991 /* Structure describing the image type `ghostscript'. */
7993 static struct image_type gs_type
=
8003 /* Free X resources of Ghostscript image IMG which is used on frame F. */
8006 gs_clear_image (f
, img
)
8010 /* IMG->data.ptr_val may contain a recorded colormap. */
8011 xfree (img
->data
.ptr_val
);
8012 x_clear_image (f
, img
);
8016 /* Return non-zero if OBJECT is a valid Ghostscript image
8023 struct image_keyword fmt
[GS_LAST
];
8027 bcopy (gs_format
, fmt
, sizeof fmt
);
8029 if (!parse_image_spec (object
, fmt
, GS_LAST
, Qpostscript
))
8032 /* Bounding box must be a list or vector containing 4 integers. */
8033 tem
= fmt
[GS_BOUNDING_BOX
].value
;
8036 for (i
= 0; i
< 4; ++i
, tem
= XCDR (tem
))
8037 if (!CONSP (tem
) || !INTEGERP (XCAR (tem
)))
8042 else if (VECTORP (tem
))
8044 if (XVECTOR (tem
)->size
!= 4)
8046 for (i
= 0; i
< 4; ++i
)
8047 if (!INTEGERP (XVECTOR (tem
)->contents
[i
]))
8057 /* Load Ghostscript image IMG for use on frame F. Value is non-zero
8066 Lisp_Object window_and_pixmap_id
= Qnil
, loader
, pt_height
, pt_width
;
8067 struct gcpro gcpro1
, gcpro2
;
8069 double in_width
, in_height
;
8070 Lisp_Object pixel_colors
= Qnil
;
8072 /* Compute pixel size of pixmap needed from the given size in the
8073 image specification. Sizes in the specification are in pt. 1 pt
8074 = 1/72 in, xdpi and ydpi are stored in the frame's X display
8076 pt_width
= image_spec_value (img
->spec
, QCpt_width
, NULL
);
8077 in_width
= XFASTINT (pt_width
) / 72.0;
8078 img
->width
= in_width
* FRAME_X_DISPLAY_INFO (f
)->resx
;
8079 pt_height
= image_spec_value (img
->spec
, QCpt_height
, NULL
);
8080 in_height
= XFASTINT (pt_height
) / 72.0;
8081 img
->height
= in_height
* FRAME_X_DISPLAY_INFO (f
)->resy
;
8083 if (!check_image_size (f
, img
->width
, img
->height
))
8085 image_error ("Invalid image size", Qnil
, Qnil
);
8089 /* Create the pixmap. */
8090 xassert (img
->pixmap
== NO_PIXMAP
);
8092 /* Only W32 version did BLOCK_INPUT here. ++kfs */
8094 img
->pixmap
= XCreatePixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
8095 img
->width
, img
->height
,
8096 DefaultDepthOfScreen (FRAME_X_SCREEN (f
)));
8101 image_error ("Unable to create pixmap for `%s'", img
->spec
, Qnil
);
8105 /* Call the loader to fill the pixmap. It returns a process object
8106 if successful. We do not record_unwind_protect here because
8107 other places in redisplay like calling window scroll functions
8108 don't either. Let the Lisp loader use `unwind-protect' instead. */
8109 GCPRO2 (window_and_pixmap_id
, pixel_colors
);
8111 sprintf (buffer
, "%lu %lu",
8112 (unsigned long) FRAME_X_WINDOW (f
),
8113 (unsigned long) img
->pixmap
);
8114 window_and_pixmap_id
= build_string (buffer
);
8116 sprintf (buffer
, "%lu %lu",
8117 FRAME_FOREGROUND_PIXEL (f
),
8118 FRAME_BACKGROUND_PIXEL (f
));
8119 pixel_colors
= build_string (buffer
);
8121 XSETFRAME (frame
, f
);
8122 loader
= image_spec_value (img
->spec
, QCloader
, NULL
);
8124 loader
= intern ("gs-load-image");
8126 img
->data
.lisp_val
= call6 (loader
, frame
, img
->spec
,
8127 make_number (img
->width
),
8128 make_number (img
->height
),
8129 window_and_pixmap_id
,
8132 return PROCESSP (img
->data
.lisp_val
);
8136 /* Kill the Ghostscript process that was started to fill PIXMAP on
8137 frame F. Called from XTread_socket when receiving an event
8138 telling Emacs that Ghostscript has finished drawing. */
8141 x_kill_gs_process (pixmap
, f
)
8145 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
8149 /* Find the image containing PIXMAP. */
8150 for (i
= 0; i
< c
->used
; ++i
)
8151 if (c
->images
[i
]->pixmap
== pixmap
)
8154 /* Should someone in between have cleared the image cache, for
8155 instance, give up. */
8159 /* Kill the GS process. We should have found PIXMAP in the image
8160 cache and its image should contain a process object. */
8162 xassert (PROCESSP (img
->data
.lisp_val
));
8163 Fkill_process (img
->data
.lisp_val
, Qnil
);
8164 img
->data
.lisp_val
= Qnil
;
8166 #if defined (HAVE_X_WINDOWS)
8168 /* On displays with a mutable colormap, figure out the colors
8169 allocated for the image by looking at the pixels of an XImage for
8171 class = FRAME_X_VISUAL (f
)->class;
8172 if (class != StaticColor
&& class != StaticGray
&& class != TrueColor
)
8178 /* Try to get an XImage for img->pixmep. */
8179 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
8180 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
8185 /* Initialize the color table. */
8186 init_color_table ();
8188 /* For each pixel of the image, look its color up in the
8189 color table. After having done so, the color table will
8190 contain an entry for each color used by the image. */
8191 for (y
= 0; y
< img
->height
; ++y
)
8192 for (x
= 0; x
< img
->width
; ++x
)
8194 unsigned long pixel
= XGetPixel (ximg
, x
, y
);
8195 lookup_pixel_color (f
, pixel
);
8198 /* Record colors in the image. Free color table and XImage. */
8199 #ifdef COLOR_TABLE_SUPPORT
8200 img
->colors
= colors_in_color_table (&img
->ncolors
);
8201 free_color_table ();
8203 XDestroyImage (ximg
);
8205 #if 0 /* This doesn't seem to be the case. If we free the colors
8206 here, we get a BadAccess later in x_clear_image when
8207 freeing the colors. */
8208 /* We have allocated colors once, but Ghostscript has also
8209 allocated colors on behalf of us. So, to get the
8210 reference counts right, free them once. */
8212 x_free_colors (f
, img
->colors
, img
->ncolors
);
8216 image_error ("Cannot get X image of `%s'; colors will not be freed",
8221 #endif /* HAVE_X_WINDOWS */
8223 /* Now that we have the pixmap, compute mask and transform the
8224 image if requested. */
8226 postprocess_image (f
, img
);
8230 #endif /* HAVE_GHOSTSCRIPT */
8233 /***********************************************************************
8235 ***********************************************************************/
8239 DEFUN ("imagep", Fimagep
, Simagep
, 1, 1, 0,
8240 doc
: /* Value is non-nil if SPEC is a valid image specification. */)
8244 return valid_image_p (spec
) ? Qt
: Qnil
;
8248 DEFUN ("lookup-image", Flookup_image
, Slookup_image
, 1, 1, 0, "")
8254 if (valid_image_p (spec
))
8255 id
= lookup_image (SELECTED_FRAME (), spec
);
8258 return make_number (id
);
8261 #endif /* GLYPH_DEBUG != 0 */
8264 /***********************************************************************
8266 ***********************************************************************/
8269 /* Image types that rely on external libraries are loaded dynamically
8270 if the library is available. */
8271 #define CHECK_LIB_AVAILABLE(image_type, init_lib_fn, libraries) \
8272 define_image_type (image_type, init_lib_fn (libraries))
8274 #define CHECK_LIB_AVAILABLE(image_type, init_lib_fn, libraries) \
8275 define_image_type (image_type, 1)
8276 #endif /* HAVE_NTGUI */
8278 DEFUN ("init-image-library", Finit_image_library
, Sinit_image_library
, 2, 2, 0,
8279 doc
: /* Initialize image library implementing image type TYPE.
8280 Return non-nil if TYPE is a supported image type.
8282 Image types pbm and xbm are prebuilt; other types are loaded here.
8283 Libraries to load are specified in alist LIBRARIES (usually, the value
8284 of `image-library-alist', which see). */)
8286 Lisp_Object type
, libraries
;
8290 /* Don't try to reload the library. */
8291 tested
= Fassq (type
, Vimage_type_cache
);
8293 return XCDR (tested
);
8295 #if defined (HAVE_XPM) || defined (MAC_OS)
8296 if (EQ (type
, Qxpm
))
8297 return CHECK_LIB_AVAILABLE (&xpm_type
, init_xpm_functions
, libraries
);
8300 #if defined (HAVE_JPEG) || defined (MAC_OS)
8301 if (EQ (type
, Qjpeg
))
8302 return CHECK_LIB_AVAILABLE (&jpeg_type
, init_jpeg_functions
, libraries
);
8305 #if defined (HAVE_TIFF) || defined (MAC_OS)
8306 if (EQ (type
, Qtiff
))
8307 return CHECK_LIB_AVAILABLE (&tiff_type
, init_tiff_functions
, libraries
);
8310 #if defined (HAVE_GIF) || defined (MAC_OS)
8311 if (EQ (type
, Qgif
))
8312 return CHECK_LIB_AVAILABLE (&gif_type
, init_gif_functions
, libraries
);
8315 #if defined (HAVE_PNG) || defined (MAC_OS)
8316 if (EQ (type
, Qpng
))
8317 return CHECK_LIB_AVAILABLE (&png_type
, init_png_functions
, libraries
);
8320 #ifdef HAVE_GHOSTSCRIPT
8321 if (EQ (type
, Qpostscript
))
8322 return CHECK_LIB_AVAILABLE (&gs_type
, init_gs_functions
, libraries
);
8325 /* If the type is not recognized, avoid testing it ever again. */
8326 CACHE_IMAGE_TYPE (type
, Qnil
);
8333 extern Lisp_Object Qrisky_local_variable
; /* Syms_of_xdisp has already run. */
8335 /* Initialize this only once, since that's what we do with Vimage_types
8336 and they are supposed to be in sync. Initializing here gives correct
8337 operation on GNU/Linux of calling dump-emacs after loading some images. */
8340 /* Must be defined now becase we're going to update it below, while
8341 defining the supported image types. */
8342 DEFVAR_LISP ("image-types", &Vimage_types
,
8343 doc
: /* List of potentially supported image types.
8344 Each element of the list is a symbol for a image type, like 'jpeg or 'png.
8345 To check whether it is really supported, use `image-type-available-p'. */);
8346 Vimage_types
= Qnil
;
8348 DEFVAR_LISP ("image-library-alist", &Vimage_library_alist
,
8349 doc
: /* Alist of image types vs external libraries needed to display them.
8351 Each element is a list (IMAGE-TYPE LIBRARY...), where the car is a symbol
8352 representing a supported image type, and the rest are strings giving
8353 alternate filenames for the corresponding external libraries.
8355 Emacs tries to load the libraries in the order they appear on the
8356 list; if none is loaded, the running session of Emacs won't
8357 support the image type. Types 'pbm and 'xbm don't need to be
8358 listed; they're always supported. */);
8359 Vimage_library_alist
= Qnil
;
8360 Fput (intern ("image-library-alist"), Qrisky_local_variable
, Qt
);
8362 DEFVAR_LISP ("max-image-size", &Vmax_image_size
,
8363 doc
: /* Maximum size of images.
8364 Emacs will not load an image into memory if its pixel width or
8365 pixel height exceeds this limit.
8367 If the value is an integer, it directly specifies the maximum
8368 image height and width, measured in pixels. If it is a floating
8369 point number, it specifies the maximum image height and width
8370 as a ratio to the frame height and width. If the value is
8371 non-numeric, there is no explicit limit on the size of images. */);
8372 Vmax_image_size
= make_float (MAX_IMAGE_SIZE
);
8374 Vimage_type_cache
= Qnil
;
8375 staticpro (&Vimage_type_cache
);
8377 Qpbm
= intern ("pbm");
8379 ADD_IMAGE_TYPE(Qpbm
);
8381 Qxbm
= intern ("xbm");
8383 ADD_IMAGE_TYPE(Qxbm
);
8385 define_image_type (&xbm_type
, 1);
8386 define_image_type (&pbm_type
, 1);
8388 QCascent
= intern (":ascent");
8389 staticpro (&QCascent
);
8390 QCmargin
= intern (":margin");
8391 staticpro (&QCmargin
);
8392 QCrelief
= intern (":relief");
8393 staticpro (&QCrelief
);
8394 QCconversion
= intern (":conversion");
8395 staticpro (&QCconversion
);
8396 QCcolor_symbols
= intern (":color-symbols");
8397 staticpro (&QCcolor_symbols
);
8398 QCheuristic_mask
= intern (":heuristic-mask");
8399 staticpro (&QCheuristic_mask
);
8400 QCindex
= intern (":index");
8401 staticpro (&QCindex
);
8402 QCmatrix
= intern (":matrix");
8403 staticpro (&QCmatrix
);
8404 QCcolor_adjustment
= intern (":color-adjustment");
8405 staticpro (&QCcolor_adjustment
);
8406 QCmask
= intern (":mask");
8407 staticpro (&QCmask
);
8409 Qlaplace
= intern ("laplace");
8410 staticpro (&Qlaplace
);
8411 Qemboss
= intern ("emboss");
8412 staticpro (&Qemboss
);
8413 Qedge_detection
= intern ("edge-detection");
8414 staticpro (&Qedge_detection
);
8415 Qheuristic
= intern ("heuristic");
8416 staticpro (&Qheuristic
);
8418 Qpostscript
= intern ("postscript");
8419 staticpro (&Qpostscript
);
8420 #ifdef HAVE_GHOSTSCRIPT
8421 ADD_IMAGE_TYPE(Qpostscript
);
8422 QCloader
= intern (":loader");
8423 staticpro (&QCloader
);
8424 QCbounding_box
= intern (":bounding-box");
8425 staticpro (&QCbounding_box
);
8426 QCpt_width
= intern (":pt-width");
8427 staticpro (&QCpt_width
);
8428 QCpt_height
= intern (":pt-height");
8429 staticpro (&QCpt_height
);
8430 #endif /* HAVE_GHOSTSCRIPT */
8432 #if defined (HAVE_XPM) || defined (MAC_OS)
8433 Qxpm
= intern ("xpm");
8435 ADD_IMAGE_TYPE(Qxpm
);
8438 #if defined (HAVE_JPEG) || defined (MAC_OS)
8439 Qjpeg
= intern ("jpeg");
8441 ADD_IMAGE_TYPE(Qjpeg
);
8444 #if defined (HAVE_TIFF) || defined (MAC_OS)
8445 Qtiff
= intern ("tiff");
8447 ADD_IMAGE_TYPE(Qtiff
);
8450 #if defined (HAVE_GIF) || defined (MAC_OS)
8451 Qgif
= intern ("gif");
8453 ADD_IMAGE_TYPE(Qgif
);
8456 #if defined (HAVE_PNG) || defined (MAC_OS)
8457 Qpng
= intern ("png");
8459 ADD_IMAGE_TYPE(Qpng
);
8462 defsubr (&Sinit_image_library
);
8463 defsubr (&Sclear_image_cache
);
8464 defsubr (&Simage_size
);
8465 defsubr (&Simage_mask_p
);
8469 defsubr (&Slookup_image
);
8472 DEFVAR_BOOL ("cross-disabled-images", &cross_disabled_images
,
8473 doc
: /* Non-nil means always draw a cross over disabled images.
8474 Disabled images are those having an `:conversion disabled' property.
8475 A cross is always drawn on black & white displays. */);
8476 cross_disabled_images
= 0;
8478 DEFVAR_LISP ("x-bitmap-file-path", &Vx_bitmap_file_path
,
8479 doc
: /* List of directories to search for window system bitmap files. */);
8480 Vx_bitmap_file_path
= decode_env_path ((char *) 0, PATH_BITMAPS
);
8482 DEFVAR_LISP ("image-cache-eviction-delay", &Vimage_cache_eviction_delay
,
8483 doc
: /* Time after which cached images are removed from the cache.
8484 When an image has not been displayed this many seconds, remove it
8485 from the image cache. Value must be an integer or nil with nil
8486 meaning don't clear the cache. */);
8487 Vimage_cache_eviction_delay
= make_number (30 * 60);
8494 /* Animated gifs use QuickTime Movie Toolbox. So initialize it here. */
8495 if (!inhibit_window_system
)
8498 init_image_func_pointer ();
8503 /* arch-tag: 123c2a5e-14a8-4c53-ab95-af47d7db49b9
8504 (do not change this comment) */