1 /* Functions for image support on window system.
2 Copyright (C) 1989, 92, 93, 94, 95, 96, 97, 98, 99, 2000,01,02,03,04
3 Free Software Foundation.
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., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, 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(f) 0
58 #define PIX_MASK_DRAW(f) 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(f) 0
75 #define PIX_MASK_DRAW(f) 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 #define FRAME_X_VISUAL(f) FRAME_X_DISPLAY_INFO (f)->visual
116 #define x_defined_color mac_defined_color
117 #define DefaultDepthOfScreen(screen) (one_mac_display_info.n_planes)
118 #define XDrawLine(display, w, gc, x1, y1, x2, y2) \
119 mac_draw_line_to_pixmap(display, w, gc, x1, y1, x2, y2)
124 /* Search path for bitmap files. */
126 Lisp_Object Vx_bitmap_file_path
;
129 static void x_disable_image
P_ ((struct frame
*, struct image
*));
130 static void x_edge_detection
P_ ((struct frame
*, struct image
*, Lisp_Object
,
133 static void init_color_table
P_ ((void));
134 static unsigned long lookup_rgb_color
P_ ((struct frame
*f
, int r
, int g
, int b
));
135 #ifdef COLOR_TABLE_SUPPORT
136 static void free_color_table
P_ ((void));
137 static unsigned long *colors_in_color_table
P_ ((int *n
));
138 static unsigned long lookup_pixel_color
P_ ((struct frame
*f
, unsigned long p
));
141 /* Code to deal with bitmaps. Bitmaps are referenced by their bitmap
142 id, which is just an int that this section returns. Bitmaps are
143 reference counted so they can be shared among frames.
145 Bitmap indices are guaranteed to be > 0, so a negative number can
146 be used to indicate no bitmap.
148 If you use x_create_bitmap_from_data, then you must keep track of
149 the bitmaps yourself. That is, creating a bitmap from the same
150 data more than once will not be caught. */
155 XGetImage (display
, pixmap
, x
, y
, width
, height
, plane_mask
, format
)
156 Display
*display
; /* not used */
158 int x
, y
; /* not used */
159 unsigned int width
, height
; /* not used */
160 unsigned long plane_mask
; /* not used */
161 int format
; /* not used */
164 xassert (x
== 0 && y
== 0);
167 SetRect (&ri
, 0, 0, width
, height
);
168 xassert (EqualRect (&ri
, GetPixBounds (GetGWorldPixMap (pixmap
), &rp
)));
170 xassert (! (pixelsLocked
& GetPixelsState (GetGWorldPixMap (pixmap
))));
173 LockPixels (GetGWorldPixMap (pixmap
));
179 XPutPixel (ximage
, x
, y
, pixel
)
188 GetGWorld (&old_port
, &old_gdh
);
189 SetGWorld (ximage
, NULL
);
191 color
.red
= RED16_FROM_ULONG (pixel
);
192 color
.green
= GREEN16_FROM_ULONG (pixel
);
193 color
.blue
= BLUE16_FROM_ULONG (pixel
);
194 SetCPixel (x
, y
, &color
);
196 SetGWorld (old_port
, old_gdh
);
200 XGetPixel (ximage
, x
, y
)
208 GetGWorld (&old_port
, &old_gdh
);
209 SetGWorld (ximage
, NULL
);
211 GetCPixel (x
, y
, &color
);
213 SetGWorld (old_port
, old_gdh
);
214 return RGB_TO_ULONG (color
.red
>> 8, color
.green
>> 8, color
.blue
>> 8);
221 UnlockPixels (GetGWorldPixMap (ximg
));
226 /* Functions to access the contents of a bitmap, given an id. */
229 x_bitmap_height (f
, id
)
233 return FRAME_X_DISPLAY_INFO (f
)->bitmaps
[id
- 1].height
;
237 x_bitmap_width (f
, id
)
241 return FRAME_X_DISPLAY_INFO (f
)->bitmaps
[id
- 1].width
;
244 #if defined (HAVE_X_WINDOWS) || defined (HAVE_NTGUI)
246 x_bitmap_pixmap (f
, id
)
250 return (int) FRAME_X_DISPLAY_INFO (f
)->bitmaps
[id
- 1].pixmap
;
254 #ifdef HAVE_X_WINDOWS
256 x_bitmap_mask (f
, id
)
260 return FRAME_X_DISPLAY_INFO (f
)->bitmaps
[id
- 1].mask
;
264 /* Allocate a new bitmap record. Returns index of new record. */
267 x_allocate_bitmap_record (f
)
270 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
273 if (dpyinfo
->bitmaps
== NULL
)
275 dpyinfo
->bitmaps_size
= 10;
277 = (Bitmap_Record
*) xmalloc (dpyinfo
->bitmaps_size
* sizeof (Bitmap_Record
));
278 dpyinfo
->bitmaps_last
= 1;
282 if (dpyinfo
->bitmaps_last
< dpyinfo
->bitmaps_size
)
283 return ++dpyinfo
->bitmaps_last
;
285 for (i
= 0; i
< dpyinfo
->bitmaps_size
; ++i
)
286 if (dpyinfo
->bitmaps
[i
].refcount
== 0)
289 dpyinfo
->bitmaps_size
*= 2;
291 = (Bitmap_Record
*) xrealloc (dpyinfo
->bitmaps
,
292 dpyinfo
->bitmaps_size
* sizeof (Bitmap_Record
));
293 return ++dpyinfo
->bitmaps_last
;
296 /* Add one reference to the reference count of the bitmap with id ID. */
299 x_reference_bitmap (f
, id
)
303 ++FRAME_X_DISPLAY_INFO (f
)->bitmaps
[id
- 1].refcount
;
306 /* Create a bitmap for frame F from a HEIGHT x WIDTH array of bits at BITS. */
309 x_create_bitmap_from_data (f
, bits
, width
, height
)
312 unsigned int width
, height
;
314 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
317 #ifdef HAVE_X_WINDOWS
319 bitmap
= XCreateBitmapFromData (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
320 bits
, width
, height
);
323 #endif /* HAVE_X_WINDOWS */
327 bitmap
= CreateBitmap (width
, height
,
328 FRAME_X_DISPLAY_INFO (XFRAME (frame
))->n_planes
,
329 FRAME_X_DISPLAY_INFO (XFRAME (frame
))->n_cbits
,
333 #endif /* HAVE_NTGUI */
336 /* MAC_TODO: for now fail if width is not mod 16 (toolbox requires it) */
341 id
= x_allocate_bitmap_record (f
);
343 dpyinfo
->bitmaps
[id
- 1].bitmap_data
= (char *) xmalloc (height
* width
);
344 if (! dpyinfo
->bitmaps
[id
- 1].bitmap_data
)
346 bcopy (bits
, dpyinfo
->bitmaps
[id
- 1].bitmap_data
, height
* width
);
349 dpyinfo
->bitmaps
[id
- 1].file
= NULL
;
350 dpyinfo
->bitmaps
[id
- 1].height
= height
;
351 dpyinfo
->bitmaps
[id
- 1].width
= width
;
352 dpyinfo
->bitmaps
[id
- 1].refcount
= 1;
354 #ifdef HAVE_X_WINDOWS
355 dpyinfo
->bitmaps
[id
- 1].pixmap
= bitmap
;
356 dpyinfo
->bitmaps
[id
- 1].have_mask
= 0;
357 dpyinfo
->bitmaps
[id
- 1].depth
= 1;
358 #endif /* HAVE_X_WINDOWS */
361 dpyinfo
->bitmaps
[id
- 1].pixmap
= bitmap
;
362 dpyinfo
->bitmaps
[id
- 1].hinst
= NULL
;
363 dpyinfo
->bitmaps
[id
- 1].depth
= 1;
364 #endif /* HAVE_NTGUI */
369 /* Create bitmap from file FILE for frame F. */
372 x_create_bitmap_from_file (f
, file
)
377 return -1; /* MAC_TODO : bitmap support */
381 return -1; /* W32_TODO : bitmap support */
382 #endif /* HAVE_NTGUI */
384 #ifdef HAVE_X_WINDOWS
385 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
386 unsigned int width
, height
;
388 int xhot
, yhot
, result
, id
;
393 /* Look for an existing bitmap with the same name. */
394 for (id
= 0; id
< dpyinfo
->bitmaps_last
; ++id
)
396 if (dpyinfo
->bitmaps
[id
].refcount
397 && dpyinfo
->bitmaps
[id
].file
398 && !strcmp (dpyinfo
->bitmaps
[id
].file
, (char *) SDATA (file
)))
400 ++dpyinfo
->bitmaps
[id
].refcount
;
405 /* Search bitmap-file-path for the file, if appropriate. */
406 fd
= openp (Vx_bitmap_file_path
, file
, Qnil
, &found
, Qnil
);
411 filename
= (char *) SDATA (found
);
413 result
= XReadBitmapFile (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
414 filename
, &width
, &height
, &bitmap
, &xhot
, &yhot
);
415 if (result
!= BitmapSuccess
)
418 id
= x_allocate_bitmap_record (f
);
419 dpyinfo
->bitmaps
[id
- 1].pixmap
= bitmap
;
420 dpyinfo
->bitmaps
[id
- 1].have_mask
= 0;
421 dpyinfo
->bitmaps
[id
- 1].refcount
= 1;
422 dpyinfo
->bitmaps
[id
- 1].file
= (char *) xmalloc (SBYTES (file
) + 1);
423 dpyinfo
->bitmaps
[id
- 1].depth
= 1;
424 dpyinfo
->bitmaps
[id
- 1].height
= height
;
425 dpyinfo
->bitmaps
[id
- 1].width
= width
;
426 strcpy (dpyinfo
->bitmaps
[id
- 1].file
, SDATA (file
));
429 #endif /* HAVE_X_WINDOWS */
435 Free_Bitmap_Record (dpyinfo
, bm
)
436 Display_Info
*dpyinfo
;
439 #ifdef HAVE_X_WINDOWS
440 XFreePixmap (dpyinfo
->display
, bm
->pixmap
);
442 XFreePixmap (dpyinfo
->display
, bm
->mask
);
443 #endif /* HAVE_X_WINDOWS */
446 DeleteObject (bm
->pixmap
);
447 #endif /* HAVE_NTGUI */
450 xfree (bm
->bitmap_data
); /* Added ++kfs */
451 bm
->bitmap_data
= NULL
;
461 /* Remove reference to bitmap with id number ID. */
464 x_destroy_bitmap (f
, id
)
468 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
472 Bitmap_Record
*bm
= &dpyinfo
->bitmaps
[id
- 1];
474 if (--bm
->refcount
== 0)
477 Free_Bitmap_Record (dpyinfo
, bm
);
483 /* Free all the bitmaps for the display specified by DPYINFO. */
486 x_destroy_all_bitmaps (dpyinfo
)
487 Display_Info
*dpyinfo
;
490 Bitmap_Record
*bm
= dpyinfo
->bitmaps
;
492 for (i
= 0; i
< dpyinfo
->bitmaps_last
; i
++, bm
++)
493 if (bm
->refcount
> 0)
494 Free_Bitmap_Record (dpyinfo
, bm
);
496 dpyinfo
->bitmaps_last
= 0;
500 #ifdef HAVE_X_WINDOWS
502 /* Useful functions defined in the section
503 `Image type independent image structures' below. */
505 static unsigned long four_corners_best
P_ ((XImagePtr ximg
, unsigned long width
,
506 unsigned long height
));
508 static int x_create_x_image_and_pixmap
P_ ((struct frame
*f
, int width
, int height
,
509 int depth
, XImagePtr
*ximg
,
512 static void x_destroy_x_image
P_ ((XImagePtr ximg
));
515 /* Create a mask of a bitmap. Note is this not a perfect mask.
516 It's nicer with some borders in this context */
519 x_create_bitmap_mask (f
, id
)
524 XImagePtr ximg
, mask_img
;
525 unsigned long width
, height
;
528 unsigned long x
, y
, xp
, xm
, yp
, ym
;
531 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
536 pixmap
= x_bitmap_pixmap (f
, id
);
537 width
= x_bitmap_width (f
, id
);
538 height
= x_bitmap_height (f
, id
);
541 ximg
= XGetImage (FRAME_X_DISPLAY (f
), pixmap
, 0, 0, width
, height
,
550 result
= x_create_x_image_and_pixmap (f
, width
, height
, 1, &mask_img
, &mask
);
555 XDestroyImage (ximg
);
559 bg
= four_corners_best (ximg
, width
, height
);
561 for (y
= 0; y
< ximg
->height
; ++y
)
563 for (x
= 0; x
< ximg
->width
; ++x
)
565 xp
= x
!= ximg
->width
- 1 ? x
+ 1 : 0;
566 xm
= x
!= 0 ? x
- 1 : ximg
->width
- 1;
567 yp
= y
!= ximg
->height
- 1 ? y
+ 1 : 0;
568 ym
= y
!= 0 ? y
- 1 : ximg
->height
- 1;
569 if (XGetPixel (ximg
, x
, y
) == bg
570 && XGetPixel (ximg
, x
, yp
) == bg
571 && XGetPixel (ximg
, x
, ym
) == bg
572 && XGetPixel (ximg
, xp
, y
) == bg
573 && XGetPixel (ximg
, xp
, yp
) == bg
574 && XGetPixel (ximg
, xp
, ym
) == bg
575 && XGetPixel (ximg
, xm
, y
) == bg
576 && XGetPixel (ximg
, xm
, yp
) == bg
577 && XGetPixel (ximg
, xm
, ym
) == bg
)
578 XPutPixel (mask_img
, x
, y
, 0);
580 XPutPixel (mask_img
, x
, y
, 1);
584 xassert (interrupt_input_blocked
);
585 gc
= XCreateGC (FRAME_X_DISPLAY (f
), mask
, 0, NULL
);
586 XPutImage (FRAME_X_DISPLAY (f
), mask
, gc
, mask_img
, 0, 0, 0, 0,
588 XFreeGC (FRAME_X_DISPLAY (f
), gc
);
590 dpyinfo
->bitmaps
[id
- 1].have_mask
= 1;
591 dpyinfo
->bitmaps
[id
- 1].mask
= mask
;
593 XDestroyImage (ximg
);
594 x_destroy_x_image (mask_img
);
599 #endif /* HAVE_X_WINDOWS */
602 /***********************************************************************
604 ***********************************************************************/
606 /* Value is the number of elements of vector VECTOR. */
608 #define DIM(VECTOR) (sizeof (VECTOR) / sizeof *(VECTOR))
610 /* List of supported image types. Use define_image_type to add new
611 types. Use lookup_image_type to find a type for a given symbol. */
613 static struct image_type
*image_types
;
615 /* A list of symbols, one for each supported image type. */
617 Lisp_Object Vimage_types
;
619 /* Cache for delayed-loading image types. */
621 static Lisp_Object Vimage_type_cache
;
623 /* The symbol `xbm' which is used as the type symbol for XBM images. */
629 extern Lisp_Object QCwidth
, QCheight
, QCforeground
, QCbackground
, QCfile
;
630 extern Lisp_Object QCdata
, QCtype
;
631 extern Lisp_Object Qcenter
;
632 Lisp_Object QCascent
, QCmargin
, QCrelief
;
633 Lisp_Object QCconversion
, QCcolor_symbols
, QCheuristic_mask
;
634 Lisp_Object QCindex
, QCmatrix
, QCcolor_adjustment
, QCmask
;
638 Lisp_Object Qlaplace
, Qemboss
, Qedge_detection
, Qheuristic
;
640 /* Time in seconds after which images should be removed from the cache
643 Lisp_Object Vimage_cache_eviction_delay
;
645 /* Function prototypes. */
647 static Lisp_Object define_image_type
P_ ((struct image_type
*type
, int loaded
));
648 static struct image_type
*lookup_image_type
P_ ((Lisp_Object symbol
));
649 static void image_error
P_ ((char *format
, Lisp_Object
, Lisp_Object
));
650 static void x_laplace
P_ ((struct frame
*, struct image
*));
651 static void x_emboss
P_ ((struct frame
*, struct image
*));
652 static int x_build_heuristic_mask
P_ ((struct frame
*, struct image
*,
655 #define CACHE_IMAGE_TYPE(type, status) \
656 do { Vimage_type_cache = Fcons (Fcons (type, status), Vimage_type_cache); } while (0)
658 #define ADD_IMAGE_TYPE(type) \
659 do { Vimage_types = Fcons (type, Vimage_types); } while (0)
661 /* Define a new image type from TYPE. This adds a copy of TYPE to
662 image_types and caches the loading status of TYPE. */
665 define_image_type (type
, loaded
)
666 struct image_type
*type
;
675 /* Make a copy of TYPE to avoid a bus error in a dumped Emacs.
676 The initialized data segment is read-only. */
677 struct image_type
*p
= (struct image_type
*) xmalloc (sizeof *p
);
678 bcopy (type
, p
, sizeof *p
);
679 p
->next
= image_types
;
684 CACHE_IMAGE_TYPE (*type
->type
, success
);
689 /* Look up image type SYMBOL, and return a pointer to its image_type
690 structure. Value is null if SYMBOL is not a known image type. */
692 static INLINE
struct image_type
*
693 lookup_image_type (symbol
)
696 struct image_type
*type
;
698 /* We must initialize the image-type if it hasn't been already. */
699 if (NILP (Finit_image_library (symbol
, Qnil
)))
700 return 0; /* unimplemented */
702 for (type
= image_types
; type
; type
= type
->next
)
703 if (EQ (symbol
, *type
->type
))
710 /* Value is non-zero if OBJECT is a valid Lisp image specification. A
711 valid image specification is a list whose car is the symbol
712 `image', and whose rest is a property list. The property list must
713 contain a value for key `:type'. That value must be the name of a
714 supported image type. The rest of the property list depends on the
718 valid_image_p (object
)
727 for (tem
= XCDR (object
); CONSP (tem
); tem
= XCDR (tem
))
728 if (EQ (XCAR (tem
), QCtype
))
731 if (CONSP (tem
) && SYMBOLP (XCAR (tem
)))
733 struct image_type
*type
;
734 type
= lookup_image_type (XCAR (tem
));
736 valid_p
= type
->valid_p (object
);
747 /* Log error message with format string FORMAT and argument ARG.
748 Signaling an error, e.g. when an image cannot be loaded, is not a
749 good idea because this would interrupt redisplay, and the error
750 message display would lead to another redisplay. This function
751 therefore simply displays a message. */
754 image_error (format
, arg1
, arg2
)
756 Lisp_Object arg1
, arg2
;
758 add_to_log (format
, arg1
, arg2
);
763 /***********************************************************************
765 ***********************************************************************/
767 enum image_value_type
769 IMAGE_DONT_CHECK_VALUE_TYPE
,
771 IMAGE_STRING_OR_NIL_VALUE
,
773 IMAGE_POSITIVE_INTEGER_VALUE
,
774 IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
,
775 IMAGE_NON_NEGATIVE_INTEGER_VALUE
,
778 IMAGE_FUNCTION_VALUE
,
783 /* Structure used when parsing image specifications. */
787 /* Name of keyword. */
790 /* The type of value allowed. */
791 enum image_value_type type
;
793 /* Non-zero means key must be present. */
796 /* Used to recognize duplicate keywords in a property list. */
799 /* The value that was found. */
804 static int parse_image_spec
P_ ((Lisp_Object
, struct image_keyword
*,
806 static Lisp_Object image_spec_value
P_ ((Lisp_Object
, Lisp_Object
, int *));
809 /* Parse image spec SPEC according to KEYWORDS. A valid image spec
810 has the format (image KEYWORD VALUE ...). One of the keyword/
811 value pairs must be `:type TYPE'. KEYWORDS is a vector of
812 image_keywords structures of size NKEYWORDS describing other
813 allowed keyword/value pairs. Value is non-zero if SPEC is valid. */
816 parse_image_spec (spec
, keywords
, nkeywords
, type
)
818 struct image_keyword
*keywords
;
829 while (CONSP (plist
))
831 Lisp_Object key
, value
;
833 /* First element of a pair must be a symbol. */
835 plist
= XCDR (plist
);
839 /* There must follow a value. */
842 value
= XCAR (plist
);
843 plist
= XCDR (plist
);
845 /* Find key in KEYWORDS. Error if not found. */
846 for (i
= 0; i
< nkeywords
; ++i
)
847 if (strcmp (keywords
[i
].name
, SDATA (SYMBOL_NAME (key
))) == 0)
853 /* Record that we recognized the keyword. If a keywords
854 was found more than once, it's an error. */
855 keywords
[i
].value
= value
;
858 if (keywords
[i
].count
> 1)
861 /* Check type of value against allowed type. */
862 switch (keywords
[i
].type
)
864 case IMAGE_STRING_VALUE
:
865 if (!STRINGP (value
))
869 case IMAGE_STRING_OR_NIL_VALUE
:
870 if (!STRINGP (value
) && !NILP (value
))
874 case IMAGE_SYMBOL_VALUE
:
875 if (!SYMBOLP (value
))
879 case IMAGE_POSITIVE_INTEGER_VALUE
:
880 if (!INTEGERP (value
) || XINT (value
) <= 0)
884 case IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
:
885 if (INTEGERP (value
) && XINT (value
) >= 0)
888 && INTEGERP (XCAR (value
)) && INTEGERP (XCDR (value
))
889 && XINT (XCAR (value
)) >= 0 && XINT (XCDR (value
)) >= 0)
893 case IMAGE_ASCENT_VALUE
:
894 if (SYMBOLP (value
) && EQ (value
, Qcenter
))
896 else if (INTEGERP (value
)
898 && XINT (value
) <= 100)
902 case IMAGE_NON_NEGATIVE_INTEGER_VALUE
:
903 if (!INTEGERP (value
) || XINT (value
) < 0)
907 case IMAGE_DONT_CHECK_VALUE_TYPE
:
910 case IMAGE_FUNCTION_VALUE
:
911 value
= indirect_function (value
);
914 || (CONSP (value
) && EQ (XCAR (value
), Qlambda
)))
918 case IMAGE_NUMBER_VALUE
:
919 if (!INTEGERP (value
) && !FLOATP (value
))
923 case IMAGE_INTEGER_VALUE
:
924 if (!INTEGERP (value
))
928 case IMAGE_BOOL_VALUE
:
929 if (!NILP (value
) && !EQ (value
, Qt
))
938 if (EQ (key
, QCtype
) && !EQ (type
, value
))
942 /* Check that all mandatory fields are present. */
943 for (i
= 0; i
< nkeywords
; ++i
)
944 if (keywords
[i
].mandatory_p
&& keywords
[i
].count
== 0)
951 /* Return the value of KEY in image specification SPEC. Value is nil
952 if KEY is not present in SPEC. if FOUND is not null, set *FOUND
953 to 1 if KEY was found in SPEC, set it to 0 otherwise. */
956 image_spec_value (spec
, key
, found
)
957 Lisp_Object spec
, key
;
962 xassert (valid_image_p (spec
));
964 for (tail
= XCDR (spec
);
965 CONSP (tail
) && CONSP (XCDR (tail
));
966 tail
= XCDR (XCDR (tail
)))
968 if (EQ (XCAR (tail
), key
))
972 return XCAR (XCDR (tail
));
982 DEFUN ("image-size", Fimage_size
, Simage_size
, 1, 3, 0,
983 doc
: /* Return the size of image SPEC as pair (WIDTH . HEIGHT).
984 PIXELS non-nil means return the size in pixels, otherwise return the
985 size in canonical character units.
986 FRAME is the frame on which the image will be displayed. FRAME nil
987 or omitted means use the selected frame. */)
988 (spec
, pixels
, frame
)
989 Lisp_Object spec
, pixels
, frame
;
994 if (valid_image_p (spec
))
996 struct frame
*f
= check_x_frame (frame
);
997 int id
= lookup_image (f
, spec
);
998 struct image
*img
= IMAGE_FROM_ID (f
, id
);
999 int width
= img
->width
+ 2 * img
->hmargin
;
1000 int height
= img
->height
+ 2 * img
->vmargin
;
1003 size
= Fcons (make_float ((double) width
/ FRAME_COLUMN_WIDTH (f
)),
1004 make_float ((double) height
/ FRAME_LINE_HEIGHT (f
)));
1006 size
= Fcons (make_number (width
), make_number (height
));
1009 error ("Invalid image specification");
1015 DEFUN ("image-mask-p", Fimage_mask_p
, Simage_mask_p
, 1, 2, 0,
1016 doc
: /* Return t if image SPEC has a mask bitmap.
1017 FRAME is the frame on which the image will be displayed. FRAME nil
1018 or omitted means use the selected frame. */)
1020 Lisp_Object spec
, frame
;
1025 if (valid_image_p (spec
))
1027 struct frame
*f
= check_x_frame (frame
);
1028 int id
= lookup_image (f
, spec
);
1029 struct image
*img
= IMAGE_FROM_ID (f
, id
);
1034 error ("Invalid image specification");
1040 /***********************************************************************
1041 Image type independent image structures
1042 ***********************************************************************/
1044 static struct image
*make_image
P_ ((Lisp_Object spec
, unsigned hash
));
1045 static void free_image
P_ ((struct frame
*f
, struct image
*img
));
1048 /* Allocate and return a new image structure for image specification
1049 SPEC. SPEC has a hash value of HASH. */
1051 static struct image
*
1052 make_image (spec
, hash
)
1056 struct image
*img
= (struct image
*) xmalloc (sizeof *img
);
1058 xassert (valid_image_p (spec
));
1059 bzero (img
, sizeof *img
);
1060 img
->type
= lookup_image_type (image_spec_value (spec
, QCtype
, NULL
));
1061 xassert (img
->type
!= NULL
);
1063 img
->data
.lisp_val
= Qnil
;
1064 img
->ascent
= DEFAULT_IMAGE_ASCENT
;
1070 /* Free image IMG which was used on frame F, including its resources. */
1079 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
1081 /* Remove IMG from the hash table of its cache. */
1083 img
->prev
->next
= img
->next
;
1085 c
->buckets
[img
->hash
% IMAGE_CACHE_BUCKETS_SIZE
] = img
->next
;
1088 img
->next
->prev
= img
->prev
;
1090 c
->images
[img
->id
] = NULL
;
1092 /* Free resources, then free IMG. */
1093 img
->type
->free (f
, img
);
1099 /* Prepare image IMG for display on frame F. Must be called before
1100 drawing an image. */
1103 prepare_image_for_display (f
, img
)
1109 /* We're about to display IMG, so set its timestamp to `now'. */
1111 img
->timestamp
= EMACS_SECS (t
);
1113 /* If IMG doesn't have a pixmap yet, load it now, using the image
1114 type dependent loader function. */
1115 if (img
->pixmap
== NO_PIXMAP
&& !img
->load_failed_p
)
1116 img
->load_failed_p
= img
->type
->load (f
, img
) == 0;
1120 /* Value is the number of pixels for the ascent of image IMG when
1121 drawn in face FACE. */
1124 image_ascent (img
, face
, slice
)
1127 struct glyph_slice
*slice
;
1132 if (slice
->height
== img
->height
)
1133 height
= img
->height
+ img
->vmargin
;
1134 else if (slice
->y
== 0)
1135 height
= slice
->height
+ img
->vmargin
;
1137 height
= slice
->height
;
1139 if (img
->ascent
== CENTERED_IMAGE_ASCENT
)
1144 /* W32 specific version. Why?. ++kfs */
1145 ascent
= height
/ 2 - (FONT_DESCENT(face
->font
)
1146 - FONT_BASE(face
->font
)) / 2;
1148 /* This expression is arranged so that if the image can't be
1149 exactly centered, it will be moved slightly up. This is
1150 because a typical font is `top-heavy' (due to the presence
1151 uppercase letters), so the image placement should err towards
1152 being top-heavy too. It also just generally looks better. */
1153 ascent
= (height
+ face
->font
->ascent
- face
->font
->descent
+ 1) / 2;
1154 #endif /* HAVE_NTGUI */
1157 ascent
= height
/ 2;
1160 ascent
= (int) (height
* img
->ascent
/ 100.0);
1166 /* Image background colors. */
1168 /* Find the "best" corner color of a bitmap.
1169 On W32, XIMG is assumed to a device context with the bitmap selected. */
1171 static RGB_PIXEL_COLOR
1172 four_corners_best (ximg
, width
, height
)
1173 XImagePtr_or_DC ximg
;
1174 unsigned long width
, height
;
1176 RGB_PIXEL_COLOR corners
[4], best
;
1179 /* Get the colors at the corners of ximg. */
1180 corners
[0] = GET_PIXEL (ximg
, 0, 0);
1181 corners
[1] = GET_PIXEL (ximg
, width
- 1, 0);
1182 corners
[2] = GET_PIXEL (ximg
, width
- 1, height
- 1);
1183 corners
[3] = GET_PIXEL (ximg
, 0, height
- 1);
1185 /* Choose the most frequently found color as background. */
1186 for (i
= best_count
= 0; i
< 4; ++i
)
1190 for (j
= n
= 0; j
< 4; ++j
)
1191 if (corners
[i
] == corners
[j
])
1195 best
= corners
[i
], best_count
= n
;
1201 /* Portability macros */
1205 #define Destroy_Image(img_dc, prev) \
1206 do { SelectObject (img_dc, prev); DeleteDC (img_dc); } while (0)
1208 #define Free_Pixmap(display, pixmap) \
1209 DeleteObject (pixmap)
1213 #define Destroy_Image(ximg, dummy) \
1214 XDestroyImage (ximg)
1216 #define Free_Pixmap(display, pixmap) \
1217 XFreePixmap (display, pixmap)
1219 #endif /* HAVE_NTGUI */
1222 /* Return the `background' field of IMG. If IMG doesn't have one yet,
1223 it is guessed heuristically. If non-zero, XIMG is an existing
1224 XImage object (or device context with the image selected on W32) to
1225 use for the heuristic. */
1228 image_background (img
, f
, ximg
)
1231 XImagePtr_or_DC ximg
;
1233 if (! img
->background_valid
)
1234 /* IMG doesn't have a background yet, try to guess a reasonable value. */
1236 int free_ximg
= !ximg
;
1239 #endif /* HAVE_NTGUI */
1244 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
1245 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
1247 HDC frame_dc
= get_frame_dc (f
);
1248 ximg
= CreateCompatibleDC (frame_dc
);
1249 release_frame_dc (f
, frame_dc
);
1250 prev
= SelectObject (ximg
, img
->pixmap
);
1251 #endif /* !HAVE_NTGUI */
1254 img
->background
= four_corners_best (ximg
, img
->width
, img
->height
);
1257 Destroy_Image (ximg
, prev
);
1259 img
->background_valid
= 1;
1262 return img
->background
;
1265 /* Return the `background_transparent' field of IMG. If IMG doesn't
1266 have one yet, it is guessed heuristically. If non-zero, MASK is an
1267 existing XImage object to use for the heuristic. */
1270 image_background_transparent (img
, f
, mask
)
1273 XImagePtr_or_DC mask
;
1275 if (! img
->background_transparent_valid
)
1276 /* IMG doesn't have a background yet, try to guess a reasonable value. */
1280 int free_mask
= !mask
;
1283 #endif /* HAVE_NTGUI */
1288 mask
= XGetImage (FRAME_X_DISPLAY (f
), img
->mask
,
1289 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
1291 HDC frame_dc
= get_frame_dc (f
);
1292 mask
= CreateCompatibleDC (frame_dc
);
1293 release_frame_dc (f
, frame_dc
);
1294 prev
= SelectObject (mask
, img
->mask
);
1295 #endif /* HAVE_NTGUI */
1298 img
->background_transparent
1299 = (four_corners_best (mask
, img
->width
, img
->height
) == PIX_MASK_RETAIN (f
));
1302 Destroy_Image (mask
, prev
);
1305 img
->background_transparent
= 0;
1307 img
->background_transparent_valid
= 1;
1310 return img
->background_transparent
;
1314 /***********************************************************************
1315 Helper functions for X image types
1316 ***********************************************************************/
1318 static void x_clear_image_1
P_ ((struct frame
*, struct image
*, int,
1320 static void x_clear_image
P_ ((struct frame
*f
, struct image
*img
));
1321 static unsigned long x_alloc_image_color
P_ ((struct frame
*f
,
1323 Lisp_Object color_name
,
1324 unsigned long dflt
));
1327 /* Clear X resources of image IMG on frame F. PIXMAP_P non-zero means
1328 free the pixmap if any. MASK_P non-zero means clear the mask
1329 pixmap if any. COLORS_P non-zero means free colors allocated for
1330 the image, if any. */
1333 x_clear_image_1 (f
, img
, pixmap_p
, mask_p
, colors_p
)
1336 int pixmap_p
, mask_p
, colors_p
;
1338 if (pixmap_p
&& img
->pixmap
)
1340 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->pixmap
);
1341 img
->pixmap
= NO_PIXMAP
;
1342 img
->background_valid
= 0;
1345 if (mask_p
&& img
->mask
)
1347 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
1348 img
->mask
= NO_PIXMAP
;
1349 img
->background_transparent_valid
= 0;
1352 if (colors_p
&& img
->ncolors
)
1354 /* MAC_TODO: color table support. */
1355 /* W32_TODO: color table support. */
1356 #ifdef HAVE_X_WINDOWS
1357 x_free_colors (f
, img
->colors
, img
->ncolors
);
1358 #endif /* HAVE_X_WINDOWS */
1359 xfree (img
->colors
);
1365 /* Free X resources of image IMG which is used on frame F. */
1368 x_clear_image (f
, img
)
1373 x_clear_image_1 (f
, img
, 1, 1, 1);
1378 /* Allocate color COLOR_NAME for image IMG on frame F. If color
1379 cannot be allocated, use DFLT. Add a newly allocated color to
1380 IMG->colors, so that it can be freed again. Value is the pixel
1383 static unsigned long
1384 x_alloc_image_color (f
, img
, color_name
, dflt
)
1387 Lisp_Object color_name
;
1391 unsigned long result
;
1393 xassert (STRINGP (color_name
));
1395 if (x_defined_color (f
, SDATA (color_name
), &color
, 1))
1397 /* This isn't called frequently so we get away with simply
1398 reallocating the color vector to the needed size, here. */
1401 (unsigned long *) xrealloc (img
->colors
,
1402 img
->ncolors
* sizeof *img
->colors
);
1403 img
->colors
[img
->ncolors
- 1] = color
.pixel
;
1404 result
= color
.pixel
;
1414 /***********************************************************************
1416 ***********************************************************************/
1418 static void cache_image
P_ ((struct frame
*f
, struct image
*img
));
1419 static void postprocess_image
P_ ((struct frame
*, struct image
*));
1421 /* Return a new, initialized image cache that is allocated from the
1422 heap. Call free_image_cache to free an image cache. */
1424 struct image_cache
*
1427 struct image_cache
*c
= (struct image_cache
*) xmalloc (sizeof *c
);
1430 bzero (c
, sizeof *c
);
1432 c
->images
= (struct image
**) xmalloc (c
->size
* sizeof *c
->images
);
1433 size
= IMAGE_CACHE_BUCKETS_SIZE
* sizeof *c
->buckets
;
1434 c
->buckets
= (struct image
**) xmalloc (size
);
1435 bzero (c
->buckets
, size
);
1440 /* Free image cache of frame F. Be aware that X frames share images
1444 free_image_cache (f
)
1447 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
1452 /* Cache should not be referenced by any frame when freed. */
1453 xassert (c
->refcount
== 0);
1455 for (i
= 0; i
< c
->used
; ++i
)
1456 free_image (f
, c
->images
[i
]);
1460 FRAME_X_IMAGE_CACHE (f
) = NULL
;
1465 /* Clear image cache of frame F. FORCE_P non-zero means free all
1466 images. FORCE_P zero means clear only images that haven't been
1467 displayed for some time. Should be called from time to time to
1468 reduce the number of loaded images. If image-eviction-seconds is
1469 non-nil, this frees images in the cache which weren't displayed for
1470 at least that many seconds. */
1473 clear_image_cache (f
, force_p
)
1477 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
1479 if (c
&& INTEGERP (Vimage_cache_eviction_delay
))
1486 old
= EMACS_SECS (t
) - XFASTINT (Vimage_cache_eviction_delay
);
1488 /* Block input so that we won't be interrupted by a SIGIO
1489 while being in an inconsistent state. */
1492 for (i
= nfreed
= 0; i
< c
->used
; ++i
)
1494 struct image
*img
= c
->images
[i
];
1496 && (force_p
|| img
->timestamp
< old
))
1498 free_image (f
, img
);
1503 /* We may be clearing the image cache because, for example,
1504 Emacs was iconified for a longer period of time. In that
1505 case, current matrices may still contain references to
1506 images freed above. So, clear these matrices. */
1509 Lisp_Object tail
, frame
;
1511 FOR_EACH_FRAME (tail
, frame
)
1513 struct frame
*f
= XFRAME (frame
);
1514 if (FRAME_WINDOW_P (f
)
1515 && FRAME_X_IMAGE_CACHE (f
) == c
)
1516 clear_current_matrices (f
);
1519 ++windows_or_buffers_changed
;
1527 DEFUN ("clear-image-cache", Fclear_image_cache
, Sclear_image_cache
,
1529 doc
: /* Clear the image cache of FRAME.
1530 FRAME nil or omitted means use the selected frame.
1531 FRAME t means clear the image caches of all frames. */)
1539 FOR_EACH_FRAME (tail
, frame
)
1540 if (FRAME_WINDOW_P (XFRAME (frame
)))
1541 clear_image_cache (XFRAME (frame
), 1);
1544 clear_image_cache (check_x_frame (frame
), 1);
1550 /* Compute masks and transform image IMG on frame F, as specified
1551 by the image's specification, */
1554 postprocess_image (f
, img
)
1558 /* Manipulation of the image's mask. */
1561 Lisp_Object conversion
, spec
;
1566 /* `:heuristic-mask t'
1568 means build a mask heuristically.
1569 `:heuristic-mask (R G B)'
1570 `:mask (heuristic (R G B))'
1571 means build a mask from color (R G B) in the
1574 means remove a mask, if any. */
1576 mask
= image_spec_value (spec
, QCheuristic_mask
, NULL
);
1578 x_build_heuristic_mask (f
, img
, mask
);
1583 mask
= image_spec_value (spec
, QCmask
, &found_p
);
1585 if (EQ (mask
, Qheuristic
))
1586 x_build_heuristic_mask (f
, img
, Qt
);
1587 else if (CONSP (mask
)
1588 && EQ (XCAR (mask
), Qheuristic
))
1590 if (CONSP (XCDR (mask
)))
1591 x_build_heuristic_mask (f
, img
, XCAR (XCDR (mask
)));
1593 x_build_heuristic_mask (f
, img
, XCDR (mask
));
1595 else if (NILP (mask
) && found_p
&& img
->mask
)
1597 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
1598 img
->mask
= NO_PIXMAP
;
1603 /* Should we apply an image transformation algorithm? */
1604 conversion
= image_spec_value (spec
, QCconversion
, NULL
);
1605 if (EQ (conversion
, Qdisabled
))
1606 x_disable_image (f
, img
);
1607 else if (EQ (conversion
, Qlaplace
))
1609 else if (EQ (conversion
, Qemboss
))
1611 else if (CONSP (conversion
)
1612 && EQ (XCAR (conversion
), Qedge_detection
))
1615 tem
= XCDR (conversion
);
1617 x_edge_detection (f
, img
,
1618 Fplist_get (tem
, QCmatrix
),
1619 Fplist_get (tem
, QCcolor_adjustment
));
1625 /* Return the id of image with Lisp specification SPEC on frame F.
1626 SPEC must be a valid Lisp image specification (see valid_image_p). */
1629 lookup_image (f
, spec
)
1633 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
1637 struct gcpro gcpro1
;
1640 /* F must be a window-system frame, and SPEC must be a valid image
1642 xassert (FRAME_WINDOW_P (f
));
1643 xassert (valid_image_p (spec
));
1647 /* Look up SPEC in the hash table of the image cache. */
1648 hash
= sxhash (spec
, 0);
1649 i
= hash
% IMAGE_CACHE_BUCKETS_SIZE
;
1651 for (img
= c
->buckets
[i
]; img
; img
= img
->next
)
1652 if (img
->hash
== hash
&& !NILP (Fequal (img
->spec
, spec
)))
1655 /* If not found, create a new image and cache it. */
1658 extern Lisp_Object Qpostscript
;
1661 img
= make_image (spec
, hash
);
1662 cache_image (f
, img
);
1663 img
->load_failed_p
= img
->type
->load (f
, img
) == 0;
1665 /* If we can't load the image, and we don't have a width and
1666 height, use some arbitrary width and height so that we can
1667 draw a rectangle for it. */
1668 if (img
->load_failed_p
)
1672 value
= image_spec_value (spec
, QCwidth
, NULL
);
1673 img
->width
= (INTEGERP (value
)
1674 ? XFASTINT (value
) : DEFAULT_IMAGE_WIDTH
);
1675 value
= image_spec_value (spec
, QCheight
, NULL
);
1676 img
->height
= (INTEGERP (value
)
1677 ? XFASTINT (value
) : DEFAULT_IMAGE_HEIGHT
);
1681 /* Handle image type independent image attributes
1682 `:ascent ASCENT', `:margin MARGIN', `:relief RELIEF',
1683 `:background COLOR'. */
1684 Lisp_Object ascent
, margin
, relief
, bg
;
1686 ascent
= image_spec_value (spec
, QCascent
, NULL
);
1687 if (INTEGERP (ascent
))
1688 img
->ascent
= XFASTINT (ascent
);
1689 else if (EQ (ascent
, Qcenter
))
1690 img
->ascent
= CENTERED_IMAGE_ASCENT
;
1692 margin
= image_spec_value (spec
, QCmargin
, NULL
);
1693 if (INTEGERP (margin
) && XINT (margin
) >= 0)
1694 img
->vmargin
= img
->hmargin
= XFASTINT (margin
);
1695 else if (CONSP (margin
) && INTEGERP (XCAR (margin
))
1696 && INTEGERP (XCDR (margin
)))
1698 if (XINT (XCAR (margin
)) > 0)
1699 img
->hmargin
= XFASTINT (XCAR (margin
));
1700 if (XINT (XCDR (margin
)) > 0)
1701 img
->vmargin
= XFASTINT (XCDR (margin
));
1704 relief
= image_spec_value (spec
, QCrelief
, NULL
);
1705 if (INTEGERP (relief
))
1707 img
->relief
= XINT (relief
);
1708 img
->hmargin
+= abs (img
->relief
);
1709 img
->vmargin
+= abs (img
->relief
);
1712 if (! img
->background_valid
)
1714 bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
1718 = x_alloc_image_color (f
, img
, bg
,
1719 FRAME_BACKGROUND_PIXEL (f
));
1720 img
->background_valid
= 1;
1724 /* Do image transformations and compute masks, unless we
1725 don't have the image yet. */
1726 if (!EQ (*img
->type
->type
, Qpostscript
))
1727 postprocess_image (f
, img
);
1733 /* We're using IMG, so set its timestamp to `now'. */
1734 EMACS_GET_TIME (now
);
1735 img
->timestamp
= EMACS_SECS (now
);
1739 /* Value is the image id. */
1744 /* Cache image IMG in the image cache of frame F. */
1747 cache_image (f
, img
)
1751 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
1754 /* Find a free slot in c->images. */
1755 for (i
= 0; i
< c
->used
; ++i
)
1756 if (c
->images
[i
] == NULL
)
1759 /* If no free slot found, maybe enlarge c->images. */
1760 if (i
== c
->used
&& c
->used
== c
->size
)
1763 c
->images
= (struct image
**) xrealloc (c
->images
,
1764 c
->size
* sizeof *c
->images
);
1767 /* Add IMG to c->images, and assign IMG an id. */
1773 /* Add IMG to the cache's hash table. */
1774 i
= img
->hash
% IMAGE_CACHE_BUCKETS_SIZE
;
1775 img
->next
= c
->buckets
[i
];
1777 img
->next
->prev
= img
;
1779 c
->buckets
[i
] = img
;
1783 /* Call FN on every image in the image cache of frame F. Used to mark
1784 Lisp Objects in the image cache. */
1787 forall_images_in_image_cache (f
, fn
)
1789 void (*fn
) P_ ((struct image
*img
));
1791 if (FRAME_LIVE_P (f
) && FRAME_WINDOW_P (f
))
1793 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
1797 for (i
= 0; i
< c
->used
; ++i
)
1806 /***********************************************************************
1807 X / MAC / W32 support code
1808 ***********************************************************************/
1812 /* Macro for defining functions that will be loaded from image DLLs. */
1813 #define DEF_IMGLIB_FN(func) int (FAR CDECL *fn_##func)()
1815 /* Macro for loading those image functions from the library. */
1816 #define LOAD_IMGLIB_FN(lib,func) { \
1817 fn_##func = (void *) GetProcAddress (lib, #func); \
1818 if (!fn_##func) return 0; \
1821 /* Load a DLL implementing an image type.
1822 The `image-library-alist' variable associates a symbol,
1823 identifying an image type, to a list of possible filenames.
1824 The function returns NULL if no library could be loaded for
1825 the given image type, or if the library was previously loaded;
1826 else the handle of the DLL. */
1828 w32_delayed_load (Lisp_Object libraries
, Lisp_Object type
)
1830 HMODULE library
= NULL
;
1832 if (CONSP (libraries
) && NILP (Fassq (type
, Vimage_type_cache
)))
1834 Lisp_Object dlls
= Fassq (type
, libraries
);
1837 for (dlls
= XCDR (dlls
); CONSP (dlls
); dlls
= XCDR (dlls
))
1839 CHECK_STRING_CAR (dlls
);
1840 if (library
= LoadLibrary (SDATA (XCAR (dlls
))))
1848 #endif /* HAVE_NTGUI */
1850 static int x_create_x_image_and_pixmap
P_ ((struct frame
*, int, int, int,
1851 XImagePtr
*, Pixmap
*));
1852 static void x_destroy_x_image
P_ ((XImagePtr
));
1853 static void x_put_x_image
P_ ((struct frame
*, XImagePtr
, Pixmap
, int, int));
1856 /* Create an XImage and a pixmap of size WIDTH x HEIGHT for use on
1857 frame F. Set *XIMG and *PIXMAP to the XImage and Pixmap created.
1858 Set (*XIMG)->data to a raster of WIDTH x HEIGHT pixels allocated
1859 via xmalloc. Print error messages via image_error if an error
1860 occurs. Value is non-zero if successful.
1862 On W32, a DEPTH of zero signifies a 24 bit image, otherwise DEPTH
1863 should indicate the bit depth of the image. */
1866 x_create_x_image_and_pixmap (f
, width
, height
, depth
, ximg
, pixmap
)
1868 int width
, height
, depth
;
1872 #ifdef HAVE_X_WINDOWS
1873 Display
*display
= FRAME_X_DISPLAY (f
);
1874 Window window
= FRAME_X_WINDOW (f
);
1875 Screen
*screen
= FRAME_X_SCREEN (f
);
1877 xassert (interrupt_input_blocked
);
1880 depth
= DefaultDepthOfScreen (screen
);
1881 *ximg
= XCreateImage (display
, DefaultVisualOfScreen (screen
),
1882 depth
, ZPixmap
, 0, NULL
, width
, height
,
1883 depth
> 16 ? 32 : depth
> 8 ? 16 : 8, 0);
1886 image_error ("Unable to allocate X image", Qnil
, Qnil
);
1890 /* Allocate image raster. */
1891 (*ximg
)->data
= (char *) xmalloc ((*ximg
)->bytes_per_line
* height
);
1893 /* Allocate a pixmap of the same size. */
1894 *pixmap
= XCreatePixmap (display
, window
, width
, height
, depth
);
1895 if (*pixmap
== NO_PIXMAP
)
1897 x_destroy_x_image (*ximg
);
1899 image_error ("Unable to create X pixmap", Qnil
, Qnil
);
1904 #endif /* HAVE_X_WINDOWS */
1908 BITMAPINFOHEADER
*header
;
1910 int scanline_width_bits
;
1912 int palette_colors
= 0;
1917 if (depth
!= 1 && depth
!= 4 && depth
!= 8
1918 && depth
!= 16 && depth
!= 24 && depth
!= 32)
1920 image_error ("Invalid image bit depth specified", Qnil
, Qnil
);
1924 scanline_width_bits
= width
* depth
;
1925 remainder
= scanline_width_bits
% 32;
1928 scanline_width_bits
+= 32 - remainder
;
1930 /* Bitmaps with a depth less than 16 need a palette. */
1931 /* BITMAPINFO structure already contains the first RGBQUAD. */
1933 palette_colors
= 1 << depth
- 1;
1935 *ximg
= xmalloc (sizeof (XImage
) + palette_colors
* sizeof (RGBQUAD
));
1938 image_error ("Unable to allocate memory for XImage", Qnil
, Qnil
);
1942 header
= &((*ximg
)->info
.bmiHeader
);
1943 bzero (&((*ximg
)->info
), sizeof (BITMAPINFO
));
1944 header
->biSize
= sizeof (*header
);
1945 header
->biWidth
= width
;
1946 header
->biHeight
= -height
; /* negative indicates a top-down bitmap. */
1947 header
->biPlanes
= 1;
1948 header
->biBitCount
= depth
;
1949 header
->biCompression
= BI_RGB
;
1950 header
->biClrUsed
= palette_colors
;
1952 /* TODO: fill in palette. */
1955 (*ximg
)->info
.bmiColors
[0].rgbBlue
= 0;
1956 (*ximg
)->info
.bmiColors
[0].rgbGreen
= 0;
1957 (*ximg
)->info
.bmiColors
[0].rgbRed
= 0;
1958 (*ximg
)->info
.bmiColors
[0].rgbReserved
= 0;
1959 (*ximg
)->info
.bmiColors
[1].rgbBlue
= 255;
1960 (*ximg
)->info
.bmiColors
[1].rgbGreen
= 255;
1961 (*ximg
)->info
.bmiColors
[1].rgbRed
= 255;
1962 (*ximg
)->info
.bmiColors
[1].rgbReserved
= 0;
1965 hdc
= get_frame_dc (f
);
1967 /* Create a DIBSection and raster array for the bitmap,
1968 and store its handle in *pixmap. */
1969 *pixmap
= CreateDIBSection (hdc
, &((*ximg
)->info
),
1970 (depth
< 16) ? DIB_PAL_COLORS
: DIB_RGB_COLORS
,
1971 &((*ximg
)->data
), NULL
, 0);
1973 /* Realize display palette and garbage all frames. */
1974 release_frame_dc (f
, hdc
);
1976 if (*pixmap
== NULL
)
1978 DWORD err
= GetLastError();
1979 Lisp_Object errcode
;
1980 /* All system errors are < 10000, so the following is safe. */
1981 XSETINT (errcode
, (int) err
);
1982 image_error ("Unable to create bitmap, error code %d", errcode
, Qnil
);
1983 x_destroy_x_image (*ximg
);
1989 #endif /* HAVE_NTGUI */
1992 Display
*display
= FRAME_X_DISPLAY (f
);
1993 Window window
= FRAME_X_WINDOW (f
);
1995 xassert (interrupt_input_blocked
);
1997 /* Allocate a pixmap of the same size. */
1998 *pixmap
= XCreatePixmap (display
, window
, width
, height
, depth
);
1999 if (*pixmap
== NO_PIXMAP
)
2001 x_destroy_x_image (*ximg
);
2003 image_error ("Unable to create X pixmap", Qnil
, Qnil
);
2007 LockPixels (GetGWorldPixMap (*pixmap
));
2015 /* Destroy XImage XIMG. Free XIMG->data. */
2018 x_destroy_x_image (ximg
)
2021 xassert (interrupt_input_blocked
);
2024 #ifdef HAVE_X_WINDOWS
2027 XDestroyImage (ximg
);
2028 #endif /* HAVE_X_WINDOWS */
2030 /* Data will be freed by DestroyObject. */
2033 #endif /* HAVE_NTGUI */
2035 XDestroyImage (ximg
);
2041 /* Put XImage XIMG into pixmap PIXMAP on frame F. WIDTH and HEIGHT
2042 are width and height of both the image and pixmap. */
2045 x_put_x_image (f
, ximg
, pixmap
, width
, height
)
2051 #ifdef HAVE_X_WINDOWS
2054 xassert (interrupt_input_blocked
);
2055 gc
= XCreateGC (FRAME_X_DISPLAY (f
), pixmap
, 0, NULL
);
2056 XPutImage (FRAME_X_DISPLAY (f
), pixmap
, gc
, ximg
, 0, 0, 0, 0, width
, height
);
2057 XFreeGC (FRAME_X_DISPLAY (f
), gc
);
2058 #endif /* HAVE_X_WINDOWS */
2061 #if 0 /* I don't think this is necessary looking at where it is used. */
2062 HDC hdc
= get_frame_dc (f
);
2063 SetDIBits (hdc
, pixmap
, 0, height
, ximg
->data
, &(ximg
->info
), DIB_RGB_COLORS
);
2064 release_frame_dc (f
, hdc
);
2066 #endif /* HAVE_NTGUI */
2069 xassert (ximg
== pixmap
);
2074 /***********************************************************************
2076 ***********************************************************************/
2078 static unsigned char *slurp_file
P_ ((char *, int *));
2081 /* Find image file FILE. Look in data-directory, then
2082 x-bitmap-file-path. Value is the full name of the file found, or
2083 nil if not found. */
2086 x_find_image_file (file
)
2089 Lisp_Object file_found
, search_path
;
2090 struct gcpro gcpro1
, gcpro2
;
2094 search_path
= Fcons (Vdata_directory
, Vx_bitmap_file_path
);
2095 GCPRO2 (file_found
, search_path
);
2097 /* Try to find FILE in data-directory, then x-bitmap-file-path. */
2098 fd
= openp (search_path
, file
, Qnil
, &file_found
, Qnil
);
2110 /* Read FILE into memory. Value is a pointer to a buffer allocated
2111 with xmalloc holding FILE's contents. Value is null if an error
2112 occurred. *SIZE is set to the size of the file. */
2114 static unsigned char *
2115 slurp_file (file
, size
)
2120 unsigned char *buf
= NULL
;
2123 if (stat (file
, &st
) == 0
2124 && (fp
= fopen (file
, "rb")) != NULL
2125 && (buf
= (char *) xmalloc (st
.st_size
),
2126 fread (buf
, 1, st
.st_size
, fp
) == st
.st_size
))
2149 /***********************************************************************
2150 MAC Image Load Functions
2151 ***********************************************************************/
2153 static int image_load_quicktime
P_ ((struct frame
*, struct image
*img
,
2156 static int image_load_quartz2d
P_ ((struct frame
*, struct image
*img
, int));
2160 find_image_fsspec (specified_file
, file
, fss
)
2161 Lisp_Object specified_file
, *file
;
2164 #if TARGET_API_MAC_CARBON
2167 Str255 mac_pathname
;
2171 *file
= x_find_image_file (specified_file
);
2172 if (!STRINGP (*file
))
2173 return fnfErr
; /* file or directory not found;
2174 incomplete pathname */
2175 /* Try to open the image file. */
2176 #if TARGET_API_MAC_CARBON
2177 err
= FSPathMakeRef (SDATA (*file
), &fsr
, NULL
);
2179 err
= FSGetCatalogInfo (&fsr
, kFSCatInfoNone
, NULL
, NULL
, fss
, NULL
);
2181 if (posix_to_mac_pathname (SDATA (*file
), mac_pathname
, MAXPATHLEN
+1) == 0)
2183 c2pstr (mac_pathname
);
2184 err
= FSMakeFSSpec (0, 0, mac_pathname
, fss
);
2190 image_load_qt_1 (f
, img
, type
, fss
, dh
)
2198 GraphicsImportComponent gi
;
2201 short draw_all_pixels
;
2202 Lisp_Object specified_bg
;
2207 err
= OpenADefaultComponent (GraphicsImporterComponentType
,
2211 image_error ("Cannot get importer component for `%s'", img
->spec
, Qnil
);
2216 /* read from file system spec */
2217 err
= GraphicsImportSetDataFile (gi
, fss
);
2220 image_error ("Cannot set fsspec to graphics importer for '%s'",
2227 /* read from data handle */
2228 err
= GraphicsImportSetDataHandle (gi
, dh
);
2231 image_error ("Cannot set data handle to graphics importer for `%s'",
2236 err
= GraphicsImportGetNaturalBounds (gi
, &rect
);
2239 image_error ("Error reading `%s'", img
->spec
, Qnil
);
2242 width
= img
->width
= rect
.right
- rect
.left
;
2243 height
= img
->height
= rect
.bottom
- rect
.top
;
2244 err
= GraphicsImportDoesDrawAllPixels (gi
, &draw_all_pixels
);
2246 /* Don't check the error code here. It may have an undocumented
2250 image_error ("Error reading `%s'", img
->spec
, Qnil
);
2254 if (draw_all_pixels
!= graphicsImporterDrawsAllPixels
)
2256 specified_bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
2257 if (!STRINGP (specified_bg
) ||
2258 !mac_defined_color (f
, SDATA (specified_bg
), &color
, 0))
2260 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
2261 color
.red
= RED16_FROM_ULONG (color
.pixel
);
2262 color
.green
= GREEN16_FROM_ULONG (color
.pixel
);
2263 color
.blue
= BLUE16_FROM_ULONG (color
.pixel
);
2267 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
2269 if (draw_all_pixels
!= graphicsImporterDrawsAllPixels
)
2274 GetGWorld (&old_port
, &old_gdh
);
2275 SetGWorld (ximg
, NULL
);
2276 bg_color
.red
= color
.red
;
2277 bg_color
.green
= color
.green
;
2278 bg_color
.blue
= color
.blue
;
2279 RGBBackColor (&bg_color
);
2280 #if TARGET_API_MAC_CARBON
2281 GetPortBounds (ximg
, &rect
);
2284 EraseRect (&(ximg
->portRect
));
2286 SetGWorld (old_port
, old_gdh
);
2288 GraphicsImportSetGWorld (gi
, ximg
, NULL
);
2289 GraphicsImportDraw (gi
);
2290 CloseComponent (gi
);
2292 /* Maybe fill in the background field while we have ximg handy. */
2293 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
2294 IMAGE_BACKGROUND (img
, f
, ximg
);
2296 /* Put the image into the pixmap. */
2297 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
2298 x_destroy_x_image (ximg
);
2302 CloseComponent (gi
);
2307 /* Load an image using the QuickTime Graphics Importer.
2308 Note: The alpha channel does not work for PNG images. */
2310 image_load_quicktime (f
, img
, type
)
2315 Lisp_Object specified_file
;
2316 Lisp_Object specified_data
;
2319 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
2320 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
2322 if (NILP (specified_data
))
2324 /* Read from a file */
2328 err
= find_image_fsspec (specified_file
, &file
, &fss
);
2332 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
2334 image_error ("Cannot open `%s'", file
, Qnil
);
2337 return image_load_qt_1 (f
, img
, type
, &fss
, NULL
);
2341 /* Memory source! */
2345 err
= PtrToHand (SDATA (specified_data
), &dh
, SBYTES (specified_data
));
2348 image_error ("Cannot allocate data handle for `%s'",
2352 success_p
= image_load_qt_1 (f
, img
, type
, NULL
, dh
);
2360 /* Load a PNG/JPEG image using Quartz 2D decoding routines.
2361 CGImageCreateWithPNGDataProvider is provided after Mac OS X 10.2.
2362 So don't use this function directly but determine at runtime
2363 whether it exists. */
2364 typedef CGImageRef (*CGImageCreateWithPNGDataProviderProcType
)
2365 (CGDataProviderRef
, const float [], bool, CGColorRenderingIntent
);
2366 static CGImageCreateWithPNGDataProviderProcType MyCGImageCreateWithPNGDataProvider
;
2370 init_image_func_pointer ()
2372 if (NSIsSymbolNameDefined ("_CGImageCreateWithPNGDataProvider"))
2374 MyCGImageCreateWithPNGDataProvider
2375 = (CGImageCreateWithPNGDataProviderProcType
)
2376 NSAddressOfSymbol (NSLookupAndBindSymbol
2377 ("_CGImageCreateWithPNGDataProvider"));
2380 MyCGImageCreateWithPNGDataProvider
= NULL
;
2385 image_load_quartz2d (f
, img
, png_p
)
2390 Lisp_Object file
, specified_file
;
2391 Lisp_Object specified_data
, specified_bg
;
2392 struct gcpro gcpro1
;
2393 CGDataProviderRef source
;
2397 XImagePtr ximg
= NULL
;
2398 CGContextRef context
;
2401 /* Open the file. */
2402 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
2403 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
2408 if (NILP (specified_data
))
2413 file
= x_find_image_file (specified_file
);
2414 if (!STRINGP (file
))
2416 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
2420 path
= cfstring_create_with_string (file
);
2421 url
= CFURLCreateWithFileSystemPath (NULL
, path
,
2422 kCFURLPOSIXPathStyle
, 0);
2424 source
= CGDataProviderCreateWithURL (url
);
2428 source
= CGDataProviderCreateWithData (NULL
, SDATA (specified_data
),
2429 SBYTES (specified_data
), NULL
);
2432 image
= (*MyCGImageCreateWithPNGDataProvider
) (source
, NULL
, FALSE
,
2433 kCGRenderingIntentDefault
);
2435 image
= CGImageCreateWithJPEGDataProvider (source
, NULL
, FALSE
,
2436 kCGRenderingIntentDefault
);
2438 CGDataProviderRelease (source
);
2442 image_error ("Error reading image `%s'", img
->spec
, Qnil
);
2448 specified_bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
2449 if (!STRINGP (specified_bg
) ||
2450 !mac_defined_color (f
, SDATA (specified_bg
), &color
, 0))
2452 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
2453 color
.red
= RED16_FROM_ULONG (color
.pixel
);
2454 color
.green
= GREEN16_FROM_ULONG (color
.pixel
);
2455 color
.blue
= BLUE16_FROM_ULONG (color
.pixel
);
2458 width
= img
->width
= CGImageGetWidth (image
);
2459 height
= img
->height
= CGImageGetHeight (image
);
2460 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
2462 CGImageRelease (image
);
2466 rectangle
= CGRectMake (0, 0, width
, height
);
2467 QDBeginCGContext (ximg
, &context
);
2470 CGContextSetRGBFillColor (context
, color
.red
/ 65535.0,
2471 color
.green
/ 65535.0,
2472 color
.blue
/ 65535.0, 1.0);
2473 CGContextFillRect (context
, rectangle
);
2475 CGContextDrawImage (context
, rectangle
, image
);
2476 QDEndCGContext (ximg
, &context
);
2477 CGImageRelease (image
);
2479 /* Maybe fill in the background field while we have ximg handy. */
2480 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
2481 IMAGE_BACKGROUND (img
, f
, ximg
);
2483 /* Put the image into the pixmap. */
2484 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
2485 x_destroy_x_image (ximg
);
2494 /***********************************************************************
2496 ***********************************************************************/
2498 static int xbm_scan
P_ ((unsigned char **, unsigned char *, char *, int *));
2499 static int xbm_load
P_ ((struct frame
*f
, struct image
*img
));
2500 static int xbm_load_image
P_ ((struct frame
*f
, struct image
*img
,
2501 unsigned char *, unsigned char *));
2502 static int xbm_image_p
P_ ((Lisp_Object object
));
2503 static int xbm_read_bitmap_data
P_ ((unsigned char *, unsigned char *,
2504 int *, int *, unsigned char **));
2505 static int xbm_file_p
P_ ((Lisp_Object
));
2508 /* Indices of image specification fields in xbm_format, below. */
2510 enum xbm_keyword_index
2528 /* Vector of image_keyword structures describing the format
2529 of valid XBM image specifications. */
2531 static struct image_keyword xbm_format
[XBM_LAST
] =
2533 {":type", IMAGE_SYMBOL_VALUE
, 1},
2534 {":file", IMAGE_STRING_VALUE
, 0},
2535 {":width", IMAGE_POSITIVE_INTEGER_VALUE
, 0},
2536 {":height", IMAGE_POSITIVE_INTEGER_VALUE
, 0},
2537 {":data", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
2538 {":foreground", IMAGE_STRING_OR_NIL_VALUE
, 0},
2539 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0},
2540 {":ascent", IMAGE_ASCENT_VALUE
, 0},
2541 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
2542 {":relief", IMAGE_INTEGER_VALUE
, 0},
2543 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
2544 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
2545 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0}
2548 /* Structure describing the image type XBM. */
2550 static struct image_type xbm_type
=
2559 /* Tokens returned from xbm_scan. */
2568 /* Return non-zero if OBJECT is a valid XBM-type image specification.
2569 A valid specification is a list starting with the symbol `image'
2570 The rest of the list is a property list which must contain an
2573 If the specification specifies a file to load, it must contain
2574 an entry `:file FILENAME' where FILENAME is a string.
2576 If the specification is for a bitmap loaded from memory it must
2577 contain `:width WIDTH', `:height HEIGHT', and `:data DATA', where
2578 WIDTH and HEIGHT are integers > 0. DATA may be:
2580 1. a string large enough to hold the bitmap data, i.e. it must
2581 have a size >= (WIDTH + 7) / 8 * HEIGHT
2583 2. a bool-vector of size >= WIDTH * HEIGHT
2585 3. a vector of strings or bool-vectors, one for each line of the
2588 4. A string containing an in-memory XBM file. WIDTH and HEIGHT
2589 may not be specified in this case because they are defined in the
2592 Both the file and data forms may contain the additional entries
2593 `:background COLOR' and `:foreground COLOR'. If not present,
2594 foreground and background of the frame on which the image is
2595 displayed is used. */
2598 xbm_image_p (object
)
2601 struct image_keyword kw
[XBM_LAST
];
2603 bcopy (xbm_format
, kw
, sizeof kw
);
2604 if (!parse_image_spec (object
, kw
, XBM_LAST
, Qxbm
))
2607 xassert (EQ (kw
[XBM_TYPE
].value
, Qxbm
));
2609 if (kw
[XBM_FILE
].count
)
2611 if (kw
[XBM_WIDTH
].count
|| kw
[XBM_HEIGHT
].count
|| kw
[XBM_DATA
].count
)
2614 else if (kw
[XBM_DATA
].count
&& xbm_file_p (kw
[XBM_DATA
].value
))
2616 /* In-memory XBM file. */
2617 if (kw
[XBM_WIDTH
].count
|| kw
[XBM_HEIGHT
].count
|| kw
[XBM_FILE
].count
)
2625 /* Entries for `:width', `:height' and `:data' must be present. */
2626 if (!kw
[XBM_WIDTH
].count
2627 || !kw
[XBM_HEIGHT
].count
2628 || !kw
[XBM_DATA
].count
)
2631 data
= kw
[XBM_DATA
].value
;
2632 width
= XFASTINT (kw
[XBM_WIDTH
].value
);
2633 height
= XFASTINT (kw
[XBM_HEIGHT
].value
);
2635 /* Check type of data, and width and height against contents of
2641 /* Number of elements of the vector must be >= height. */
2642 if (XVECTOR (data
)->size
< height
)
2645 /* Each string or bool-vector in data must be large enough
2646 for one line of the image. */
2647 for (i
= 0; i
< height
; ++i
)
2649 Lisp_Object elt
= XVECTOR (data
)->contents
[i
];
2654 < (width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
)
2657 else if (BOOL_VECTOR_P (elt
))
2659 if (XBOOL_VECTOR (elt
)->size
< width
)
2666 else if (STRINGP (data
))
2669 < (width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
* height
)
2672 else if (BOOL_VECTOR_P (data
))
2674 if (XBOOL_VECTOR (data
)->size
< width
* height
)
2685 /* Scan a bitmap file. FP is the stream to read from. Value is
2686 either an enumerator from enum xbm_token, or a character for a
2687 single-character token, or 0 at end of file. If scanning an
2688 identifier, store the lexeme of the identifier in SVAL. If
2689 scanning a number, store its value in *IVAL. */
2692 xbm_scan (s
, end
, sval
, ival
)
2693 unsigned char **s
, *end
;
2701 /* Skip white space. */
2702 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
2707 else if (isdigit (c
))
2709 int value
= 0, digit
;
2711 if (c
== '0' && *s
< end
)
2714 if (c
== 'x' || c
== 'X')
2721 else if (c
>= 'a' && c
<= 'f')
2722 digit
= c
- 'a' + 10;
2723 else if (c
>= 'A' && c
<= 'F')
2724 digit
= c
- 'A' + 10;
2727 value
= 16 * value
+ digit
;
2730 else if (isdigit (c
))
2734 && (c
= *(*s
)++, isdigit (c
)))
2735 value
= 8 * value
+ c
- '0';
2742 && (c
= *(*s
)++, isdigit (c
)))
2743 value
= 10 * value
+ c
- '0';
2751 else if (isalpha (c
) || c
== '_')
2755 && (c
= *(*s
)++, (isalnum (c
) || c
== '_')))
2762 else if (c
== '/' && **s
== '*')
2764 /* C-style comment. */
2766 while (**s
&& (**s
!= '*' || *(*s
+ 1) != '/'))
2780 /* Create a Windows bitmap from X bitmap data. */
2782 w32_create_pixmap_from_bitmap_data (int width
, int height
, char *data
)
2784 static unsigned char swap_nibble
[16]
2785 = { 0x0, 0x8, 0x4, 0xc, /* 0000 1000 0100 1100 */
2786 0x2, 0xa, 0x6, 0xe, /* 0010 1010 0110 1110 */
2787 0x1, 0x9, 0x5, 0xd, /* 0001 1001 0101 1101 */
2788 0x3, 0xb, 0x7, 0xf }; /* 0011 1011 0111 1111 */
2790 unsigned char *bits
, *p
;
2793 w1
= (width
+ 7) / 8; /* nb of 8bits elt in X bitmap */
2794 w2
= ((width
+ 15) / 16) * 2; /* nb of 16bits elt in W32 bitmap */
2795 bits
= (unsigned char *) alloca (height
* w2
);
2796 bzero (bits
, height
* w2
);
2797 for (i
= 0; i
< height
; i
++)
2800 for (j
= 0; j
< w1
; j
++)
2802 /* Bitswap XBM bytes to match how Windows does things. */
2803 unsigned char c
= *data
++;
2804 *p
++ = (unsigned char)((swap_nibble
[c
& 0xf] << 4)
2805 | (swap_nibble
[(c
>>4) & 0xf]));
2808 bmp
= CreateBitmap (width
, height
, 1, 1, (char *) bits
);
2813 static void convert_mono_to_color_image (f
, img
, foreground
, background
)
2816 COLORREF foreground
, background
;
2818 HDC hdc
, old_img_dc
, new_img_dc
;
2819 HGDIOBJ old_prev
, new_prev
;
2822 hdc
= get_frame_dc (f
);
2823 old_img_dc
= CreateCompatibleDC (hdc
);
2824 new_img_dc
= CreateCompatibleDC (hdc
);
2825 new_pixmap
= CreateCompatibleBitmap (hdc
, img
->width
, img
->height
);
2826 release_frame_dc (f
, hdc
);
2827 old_prev
= SelectObject (old_img_dc
, img
->pixmap
);
2828 new_prev
= SelectObject (new_img_dc
, new_pixmap
);
2829 SetTextColor (new_img_dc
, foreground
);
2830 SetBkColor (new_img_dc
, background
);
2832 BitBlt (new_img_dc
, 0, 0, img
->width
, img
->height
, old_img_dc
,
2835 SelectObject (old_img_dc
, old_prev
);
2836 SelectObject (new_img_dc
, new_prev
);
2837 DeleteDC (old_img_dc
);
2838 DeleteDC (new_img_dc
);
2839 DeleteObject (img
->pixmap
);
2840 if (new_pixmap
== 0)
2841 fprintf (stderr
, "Failed to convert image to color.\n");
2843 img
->pixmap
= new_pixmap
;
2846 #define XBM_BIT_SHUFFLE(b) (~(b))
2850 #define XBM_BIT_SHUFFLE(b) (b)
2852 #endif /* HAVE_NTGUI */
2856 Create_Pixmap_From_Bitmap_Data(f
, img
, data
, fg
, bg
, non_default_colors
)
2860 RGB_PIXEL_COLOR fg
, bg
;
2861 int non_default_colors
;
2865 = w32_create_pixmap_from_bitmap_data (img
->width
, img
->height
, data
);
2867 /* If colors were specified, transfer the bitmap to a color one. */
2868 if (non_default_colors
)
2869 convert_mono_to_color_image (f
, img
, fg
, bg
);
2872 = XCreatePixmapFromBitmapData (FRAME_X_DISPLAY (f
),
2875 img
->width
, img
->height
,
2877 DefaultDepthOfScreen (FRAME_X_SCREEN (f
)));
2878 #endif /* HAVE_NTGUI */
2883 /* Replacement for XReadBitmapFileData which isn't available under old
2884 X versions. CONTENTS is a pointer to a buffer to parse; END is the
2885 buffer's end. Set *WIDTH and *HEIGHT to the width and height of
2886 the image. Return in *DATA the bitmap data allocated with xmalloc.
2887 Value is non-zero if successful. DATA null means just test if
2888 CONTENTS looks like an in-memory XBM file. */
2891 xbm_read_bitmap_data (contents
, end
, width
, height
, data
)
2892 unsigned char *contents
, *end
;
2893 int *width
, *height
;
2894 unsigned char **data
;
2896 unsigned char *s
= contents
;
2897 char buffer
[BUFSIZ
];
2900 int bytes_per_line
, i
, nbytes
;
2906 LA1 = xbm_scan (&s, end, buffer, &value)
2908 #define expect(TOKEN) \
2909 if (LA1 != (TOKEN)) \
2914 #define expect_ident(IDENT) \
2915 if (LA1 == XBM_TK_IDENT && strcmp (buffer, (IDENT)) == 0) \
2920 *width
= *height
= -1;
2923 LA1
= xbm_scan (&s
, end
, buffer
, &value
);
2925 /* Parse defines for width, height and hot-spots. */
2929 expect_ident ("define");
2930 expect (XBM_TK_IDENT
);
2932 if (LA1
== XBM_TK_NUMBER
);
2934 char *p
= strrchr (buffer
, '_');
2935 p
= p
? p
+ 1 : buffer
;
2936 if (strcmp (p
, "width") == 0)
2938 else if (strcmp (p
, "height") == 0)
2941 expect (XBM_TK_NUMBER
);
2944 if (*width
< 0 || *height
< 0)
2946 else if (data
== NULL
)
2949 /* Parse bits. Must start with `static'. */
2950 expect_ident ("static");
2951 if (LA1
== XBM_TK_IDENT
)
2953 if (strcmp (buffer
, "unsigned") == 0)
2956 expect_ident ("char");
2958 else if (strcmp (buffer
, "short") == 0)
2962 if (*width
% 16 && *width
% 16 < 9)
2965 else if (strcmp (buffer
, "char") == 0)
2973 expect (XBM_TK_IDENT
);
2979 bytes_per_line
= (*width
+ 7) / 8 + padding_p
;
2980 nbytes
= bytes_per_line
* *height
;
2981 p
= *data
= (char *) xmalloc (nbytes
);
2985 for (i
= 0; i
< nbytes
; i
+= 2)
2988 expect (XBM_TK_NUMBER
);
2990 *p
++ = XBM_BIT_SHUFFLE (val
);
2991 if (!padding_p
|| ((i
+ 2) % bytes_per_line
))
2992 *p
++ = XBM_BIT_SHUFFLE (value
>> 8);
2994 if (LA1
== ',' || LA1
== '}')
3002 for (i
= 0; i
< nbytes
; ++i
)
3005 expect (XBM_TK_NUMBER
);
3007 *p
++ = XBM_BIT_SHUFFLE (val
);
3009 if (LA1
== ',' || LA1
== '}')
3034 /* Load XBM image IMG which will be displayed on frame F from buffer
3035 CONTENTS. END is the end of the buffer. Value is non-zero if
3039 xbm_load_image (f
, img
, contents
, end
)
3042 unsigned char *contents
, *end
;
3045 unsigned char *data
;
3048 rc
= xbm_read_bitmap_data (contents
, end
, &img
->width
, &img
->height
, &data
);
3051 unsigned long foreground
= FRAME_FOREGROUND_PIXEL (f
);
3052 unsigned long background
= FRAME_BACKGROUND_PIXEL (f
);
3053 int non_default_colors
= 0;
3056 xassert (img
->width
> 0 && img
->height
> 0);
3058 /* Get foreground and background colors, maybe allocate colors. */
3059 value
= image_spec_value (img
->spec
, QCforeground
, NULL
);
3062 foreground
= x_alloc_image_color (f
, img
, value
, foreground
);
3063 non_default_colors
= 1;
3065 value
= image_spec_value (img
->spec
, QCbackground
, NULL
);
3068 background
= x_alloc_image_color (f
, img
, value
, background
);
3069 img
->background
= background
;
3070 img
->background_valid
= 1;
3071 non_default_colors
= 1;
3074 Create_Pixmap_From_Bitmap_Data (f
, img
, data
,
3075 foreground
, background
,
3076 non_default_colors
);
3079 if (img
->pixmap
== NO_PIXMAP
)
3081 x_clear_image (f
, img
);
3082 image_error ("Unable to create X pixmap for `%s'", img
->spec
, Qnil
);
3088 image_error ("Error loading XBM image `%s'", img
->spec
, Qnil
);
3094 /* Value is non-zero if DATA looks like an in-memory XBM file. */
3101 return (STRINGP (data
)
3102 && xbm_read_bitmap_data (SDATA (data
),
3109 /* Fill image IMG which is used on frame F with pixmap data. Value is
3110 non-zero if successful. */
3118 Lisp_Object file_name
;
3120 xassert (xbm_image_p (img
->spec
));
3122 /* If IMG->spec specifies a file name, create a non-file spec from it. */
3123 file_name
= image_spec_value (img
->spec
, QCfile
, NULL
);
3124 if (STRINGP (file_name
))
3127 unsigned char *contents
;
3129 struct gcpro gcpro1
;
3131 file
= x_find_image_file (file_name
);
3133 if (!STRINGP (file
))
3135 image_error ("Cannot find image file `%s'", file_name
, Qnil
);
3140 contents
= slurp_file (SDATA (file
), &size
);
3141 if (contents
== NULL
)
3143 image_error ("Error loading XBM image `%s'", img
->spec
, Qnil
);
3148 success_p
= xbm_load_image (f
, img
, contents
, contents
+ size
);
3153 struct image_keyword fmt
[XBM_LAST
];
3155 unsigned long foreground
= FRAME_FOREGROUND_PIXEL (f
);
3156 unsigned long background
= FRAME_BACKGROUND_PIXEL (f
);
3157 int non_default_colors
= 0;
3160 int in_memory_file_p
= 0;
3162 /* See if data looks like an in-memory XBM file. */
3163 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
3164 in_memory_file_p
= xbm_file_p (data
);
3166 /* Parse the image specification. */
3167 bcopy (xbm_format
, fmt
, sizeof fmt
);
3168 parsed_p
= parse_image_spec (img
->spec
, fmt
, XBM_LAST
, Qxbm
);
3171 /* Get specified width, and height. */
3172 if (!in_memory_file_p
)
3174 img
->width
= XFASTINT (fmt
[XBM_WIDTH
].value
);
3175 img
->height
= XFASTINT (fmt
[XBM_HEIGHT
].value
);
3176 xassert (img
->width
> 0 && img
->height
> 0);
3179 /* Get foreground and background colors, maybe allocate colors. */
3180 if (fmt
[XBM_FOREGROUND
].count
3181 && STRINGP (fmt
[XBM_FOREGROUND
].value
))
3183 foreground
= x_alloc_image_color (f
, img
, fmt
[XBM_FOREGROUND
].value
,
3185 non_default_colors
= 1;
3188 if (fmt
[XBM_BACKGROUND
].count
3189 && STRINGP (fmt
[XBM_BACKGROUND
].value
))
3191 background
= x_alloc_image_color (f
, img
, fmt
[XBM_BACKGROUND
].value
,
3193 non_default_colors
= 1;
3196 if (in_memory_file_p
)
3197 success_p
= xbm_load_image (f
, img
, SDATA (data
),
3206 int nbytes
= (img
->width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
;
3208 p
= bits
= (char *) alloca (nbytes
* img
->height
);
3209 for (i
= 0; i
< img
->height
; ++i
, p
+= nbytes
)
3211 Lisp_Object line
= XVECTOR (data
)->contents
[i
];
3213 bcopy (SDATA (line
), p
, nbytes
);
3215 bcopy (XBOOL_VECTOR (line
)->data
, p
, nbytes
);
3218 else if (STRINGP (data
))
3219 bits
= SDATA (data
);
3221 bits
= XBOOL_VECTOR (data
)->data
;
3223 /* Create the pixmap. */
3225 Create_Pixmap_From_Bitmap_Data (f
, img
, bits
,
3226 foreground
, background
,
3227 non_default_colors
);
3232 image_error ("Unable to create pixmap for XBM image `%s'",
3234 x_clear_image (f
, img
);
3244 /***********************************************************************
3246 ***********************************************************************/
3248 #if defined (HAVE_XPM) || defined (MAC_OS)
3250 static int xpm_image_p
P_ ((Lisp_Object object
));
3251 static int xpm_load
P_ ((struct frame
*f
, struct image
*img
));
3252 static int xpm_valid_color_symbols_p
P_ ((Lisp_Object
));
3254 #endif /* HAVE_XPM || MAC_OS */
3258 /* Indicate to xpm.h that we don't have Xlib. */
3260 /* simx.h in xpm defines XColor and XImage differently than Emacs. */
3261 /* It also defines Display the same way as Emacs, but gcc 3.3 still barfs. */
3262 #define XColor xpm_XColor
3263 #define XImage xpm_XImage
3264 #define Display xpm_Display
3265 #define PIXEL_ALREADY_TYPEDEFED
3266 #include "X11/xpm.h"
3271 #undef PIXEL_ALREADY_TYPEDEFED
3273 #include "X11/xpm.h"
3274 #endif /* HAVE_NTGUI */
3275 #endif /* HAVE_XPM */
3277 #if defined (HAVE_XPM) || defined (MAC_OS)
3278 /* The symbol `xpm' identifying XPM-format images. */
3282 /* Indices of image specification fields in xpm_format, below. */
3284 enum xpm_keyword_index
3300 /* Vector of image_keyword structures describing the format
3301 of valid XPM image specifications. */
3303 static struct image_keyword xpm_format
[XPM_LAST
] =
3305 {":type", IMAGE_SYMBOL_VALUE
, 1},
3306 {":file", IMAGE_STRING_VALUE
, 0},
3307 {":data", IMAGE_STRING_VALUE
, 0},
3308 {":ascent", IMAGE_ASCENT_VALUE
, 0},
3309 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
3310 {":relief", IMAGE_INTEGER_VALUE
, 0},
3311 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3312 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3313 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3314 {":color-symbols", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3315 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
3318 /* Structure describing the image type XPM. */
3320 static struct image_type xpm_type
=
3329 #ifdef HAVE_X_WINDOWS
3331 /* Define ALLOC_XPM_COLORS if we can use Emacs' own color allocation
3332 functions for allocating image colors. Our own functions handle
3333 color allocation failures more gracefully than the ones on the XPM
3336 #if defined XpmAllocColor && defined XpmFreeColors && defined XpmColorClosure
3337 #define ALLOC_XPM_COLORS
3339 #endif /* HAVE_X_WINDOWS */
3341 #ifdef ALLOC_XPM_COLORS
3343 static void xpm_init_color_cache
P_ ((struct frame
*, XpmAttributes
*));
3344 static void xpm_free_color_cache
P_ ((void));
3345 static int xpm_lookup_color
P_ ((struct frame
*, char *, XColor
*));
3346 static int xpm_color_bucket
P_ ((char *));
3347 static struct xpm_cached_color
*xpm_cache_color
P_ ((struct frame
*, char *,
3350 /* An entry in a hash table used to cache color definitions of named
3351 colors. This cache is necessary to speed up XPM image loading in
3352 case we do color allocations ourselves. Without it, we would need
3353 a call to XParseColor per pixel in the image. */
3355 struct xpm_cached_color
3357 /* Next in collision chain. */
3358 struct xpm_cached_color
*next
;
3360 /* Color definition (RGB and pixel color). */
3367 /* The hash table used for the color cache, and its bucket vector
3370 #define XPM_COLOR_CACHE_BUCKETS 1001
3371 struct xpm_cached_color
**xpm_color_cache
;
3373 /* Initialize the color cache. */
3376 xpm_init_color_cache (f
, attrs
)
3378 XpmAttributes
*attrs
;
3380 size_t nbytes
= XPM_COLOR_CACHE_BUCKETS
* sizeof *xpm_color_cache
;
3381 xpm_color_cache
= (struct xpm_cached_color
**) xmalloc (nbytes
);
3382 memset (xpm_color_cache
, 0, nbytes
);
3383 init_color_table ();
3385 if (attrs
->valuemask
& XpmColorSymbols
)
3390 for (i
= 0; i
< attrs
->numsymbols
; ++i
)
3391 if (XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
3392 attrs
->colorsymbols
[i
].value
, &color
))
3394 color
.pixel
= lookup_rgb_color (f
, color
.red
, color
.green
,
3396 xpm_cache_color (f
, attrs
->colorsymbols
[i
].name
, &color
, -1);
3401 /* Free the color cache. */
3404 xpm_free_color_cache ()
3406 struct xpm_cached_color
*p
, *next
;
3409 for (i
= 0; i
< XPM_COLOR_CACHE_BUCKETS
; ++i
)
3410 for (p
= xpm_color_cache
[i
]; p
; p
= next
)
3416 xfree (xpm_color_cache
);
3417 xpm_color_cache
= NULL
;
3418 free_color_table ();
3421 /* Return the bucket index for color named COLOR_NAME in the color
3425 xpm_color_bucket (color_name
)
3431 for (s
= color_name
; *s
; ++s
)
3433 return h
%= XPM_COLOR_CACHE_BUCKETS
;
3437 /* On frame F, cache values COLOR for color with name COLOR_NAME.
3438 BUCKET, if >= 0, is a precomputed bucket index. Value is the cache
3441 static struct xpm_cached_color
*
3442 xpm_cache_color (f
, color_name
, color
, bucket
)
3449 struct xpm_cached_color
*p
;
3452 bucket
= xpm_color_bucket (color_name
);
3454 nbytes
= sizeof *p
+ strlen (color_name
);
3455 p
= (struct xpm_cached_color
*) xmalloc (nbytes
);
3456 strcpy (p
->name
, color_name
);
3458 p
->next
= xpm_color_cache
[bucket
];
3459 xpm_color_cache
[bucket
] = p
;
3463 /* Look up color COLOR_NAME for frame F in the color cache. If found,
3464 return the cached definition in *COLOR. Otherwise, make a new
3465 entry in the cache and allocate the color. Value is zero if color
3466 allocation failed. */
3469 xpm_lookup_color (f
, color_name
, color
)
3474 struct xpm_cached_color
*p
;
3475 int h
= xpm_color_bucket (color_name
);
3477 for (p
= xpm_color_cache
[h
]; p
; p
= p
->next
)
3478 if (strcmp (p
->name
, color_name
) == 0)
3483 else if (XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
3486 color
->pixel
= lookup_rgb_color (f
, color
->red
, color
->green
,
3488 p
= xpm_cache_color (f
, color_name
, color
, h
);
3490 /* You get `opaque' at least from ImageMagick converting pbm to xpm
3491 with transparency, and it's useful. */
3492 else if (strcmp ("opaque", color_name
) == 0)
3494 bzero (color
, sizeof (XColor
)); /* Is this necessary/correct? */
3495 color
->pixel
= FRAME_FOREGROUND_PIXEL (f
);
3496 p
= xpm_cache_color (f
, color_name
, color
, h
);
3503 /* Callback for allocating color COLOR_NAME. Called from the XPM lib.
3504 CLOSURE is a pointer to the frame on which we allocate the
3505 color. Return in *COLOR the allocated color. Value is non-zero
3509 xpm_alloc_color (dpy
, cmap
, color_name
, color
, closure
)
3516 return xpm_lookup_color ((struct frame
*) closure
, color_name
, color
);
3520 /* Callback for freeing NPIXELS colors contained in PIXELS. CLOSURE
3521 is a pointer to the frame on which we allocate the color. Value is
3522 non-zero if successful. */
3525 xpm_free_colors (dpy
, cmap
, pixels
, npixels
, closure
)
3535 #endif /* ALLOC_XPM_COLORS */
3540 /* XPM library details. */
3542 DEF_IMGLIB_FN (XpmFreeAttributes
);
3543 DEF_IMGLIB_FN (XpmCreateImageFromBuffer
);
3544 DEF_IMGLIB_FN (XpmReadFileToImage
);
3545 DEF_IMGLIB_FN (XImageFree
);
3548 init_xpm_functions (Lisp_Object libraries
)
3552 if (!(library
= w32_delayed_load (libraries
, Qxpm
)))
3555 LOAD_IMGLIB_FN (library
, XpmFreeAttributes
);
3556 LOAD_IMGLIB_FN (library
, XpmCreateImageFromBuffer
);
3557 LOAD_IMGLIB_FN (library
, XpmReadFileToImage
);
3558 LOAD_IMGLIB_FN (library
, XImageFree
);
3562 #endif /* HAVE_NTGUI */
3565 /* Value is non-zero if COLOR_SYMBOLS is a valid color symbols list
3566 for XPM images. Such a list must consist of conses whose car and
3570 xpm_valid_color_symbols_p (color_symbols
)
3571 Lisp_Object color_symbols
;
3573 while (CONSP (color_symbols
))
3575 Lisp_Object sym
= XCAR (color_symbols
);
3577 || !STRINGP (XCAR (sym
))
3578 || !STRINGP (XCDR (sym
)))
3580 color_symbols
= XCDR (color_symbols
);
3583 return NILP (color_symbols
);
3587 /* Value is non-zero if OBJECT is a valid XPM image specification. */
3590 xpm_image_p (object
)
3593 struct image_keyword fmt
[XPM_LAST
];
3594 bcopy (xpm_format
, fmt
, sizeof fmt
);
3595 return (parse_image_spec (object
, fmt
, XPM_LAST
, Qxpm
)
3596 /* Either `:file' or `:data' must be present. */
3597 && fmt
[XPM_FILE
].count
+ fmt
[XPM_DATA
].count
== 1
3598 /* Either no `:color-symbols' or it's a list of conses
3599 whose car and cdr are strings. */
3600 && (fmt
[XPM_COLOR_SYMBOLS
].count
== 0
3601 || xpm_valid_color_symbols_p (fmt
[XPM_COLOR_SYMBOLS
].value
)));
3604 #endif /* HAVE_XPM || MAC_OS */
3606 /* Load image IMG which will be displayed on frame F. Value is
3607 non-zero if successful. */
3617 XpmAttributes attrs
;
3618 Lisp_Object specified_file
, color_symbols
;
3621 xpm_XImage
* xpm_image
= NULL
, * xpm_mask
= NULL
;
3622 #endif /* HAVE_NTGUI */
3624 /* Configure the XPM lib. Use the visual of frame F. Allocate
3625 close colors. Return colors allocated. */
3626 bzero (&attrs
, sizeof attrs
);
3629 attrs
.visual
= FRAME_X_VISUAL (f
);
3630 attrs
.colormap
= FRAME_X_COLORMAP (f
);
3631 attrs
.valuemask
|= XpmVisual
;
3632 attrs
.valuemask
|= XpmColormap
;
3633 #endif /* HAVE_NTGUI */
3635 #ifdef ALLOC_XPM_COLORS
3636 /* Allocate colors with our own functions which handle
3637 failing color allocation more gracefully. */
3638 attrs
.color_closure
= f
;
3639 attrs
.alloc_color
= xpm_alloc_color
;
3640 attrs
.free_colors
= xpm_free_colors
;
3641 attrs
.valuemask
|= XpmAllocColor
| XpmFreeColors
| XpmColorClosure
;
3642 #else /* not ALLOC_XPM_COLORS */
3643 /* Let the XPM lib allocate colors. */
3644 attrs
.valuemask
|= XpmReturnAllocPixels
;
3645 #ifdef XpmAllocCloseColors
3646 attrs
.alloc_close_colors
= 1;
3647 attrs
.valuemask
|= XpmAllocCloseColors
;
3648 #else /* not XpmAllocCloseColors */
3649 attrs
.closeness
= 600;
3650 attrs
.valuemask
|= XpmCloseness
;
3651 #endif /* not XpmAllocCloseColors */
3652 #endif /* ALLOC_XPM_COLORS */
3654 /* If image specification contains symbolic color definitions, add
3655 these to `attrs'. */
3656 color_symbols
= image_spec_value (img
->spec
, QCcolor_symbols
, NULL
);
3657 if (CONSP (color_symbols
))
3660 XpmColorSymbol
*xpm_syms
;
3663 attrs
.valuemask
|= XpmColorSymbols
;
3665 /* Count number of symbols. */
3666 attrs
.numsymbols
= 0;
3667 for (tail
= color_symbols
; CONSP (tail
); tail
= XCDR (tail
))
3670 /* Allocate an XpmColorSymbol array. */
3671 size
= attrs
.numsymbols
* sizeof *xpm_syms
;
3672 xpm_syms
= (XpmColorSymbol
*) alloca (size
);
3673 bzero (xpm_syms
, size
);
3674 attrs
.colorsymbols
= xpm_syms
;
3676 /* Fill the color symbol array. */
3677 for (tail
= color_symbols
, i
= 0;
3679 ++i
, tail
= XCDR (tail
))
3681 Lisp_Object name
= XCAR (XCAR (tail
));
3682 Lisp_Object color
= XCDR (XCAR (tail
));
3683 xpm_syms
[i
].name
= (char *) alloca (SCHARS (name
) + 1);
3684 strcpy (xpm_syms
[i
].name
, SDATA (name
));
3685 xpm_syms
[i
].value
= (char *) alloca (SCHARS (color
) + 1);
3686 strcpy (xpm_syms
[i
].value
, SDATA (color
));
3690 /* Create a pixmap for the image, either from a file, or from a
3691 string buffer containing data in the same format as an XPM file. */
3692 #ifdef ALLOC_XPM_COLORS
3693 xpm_init_color_cache (f
, &attrs
);
3696 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
3700 HDC frame_dc
= get_frame_dc (f
);
3701 hdc
= CreateCompatibleDC (frame_dc
);
3702 release_frame_dc (f
, frame_dc
);
3704 #endif /* HAVE_NTGUI */
3706 if (STRINGP (specified_file
))
3708 Lisp_Object file
= x_find_image_file (specified_file
);
3709 if (!STRINGP (file
))
3711 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
3716 /* XpmReadFileToPixmap is not available in the Windows port of
3717 libxpm. But XpmReadFileToImage almost does what we want. */
3718 rc
= fn_XpmReadFileToImage (&hdc
, SDATA (file
),
3719 &xpm_image
, &xpm_mask
,
3722 rc
= XpmReadFileToPixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3723 SDATA (file
), &img
->pixmap
, &img
->mask
,
3725 #endif /* HAVE_NTGUI */
3729 Lisp_Object buffer
= image_spec_value (img
->spec
, QCdata
, NULL
);
3731 /* XpmCreatePixmapFromBuffer is not available in the Windows port
3732 of libxpm. But XpmCreateImageFromBuffer almost does what we want. */
3733 rc
= fn_XpmCreateImageFromBuffer (&hdc
, SDATA (buffer
),
3734 &xpm_image
, &xpm_mask
,
3737 rc
= XpmCreatePixmapFromBuffer (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3739 &img
->pixmap
, &img
->mask
,
3741 #endif /* HAVE_NTGUI */
3744 if (rc
== XpmSuccess
)
3746 #if defined (COLOR_TABLE_SUPPORT) && defined (ALLOC_XPM_COLORS)
3747 img
->colors
= colors_in_color_table (&img
->ncolors
);
3748 #else /* not ALLOC_XPM_COLORS */
3752 /* W32 XPM uses XImage to wrap what W32 Emacs calls a Pixmap,
3753 plus some duplicate attributes. */
3754 if (xpm_image
&& xpm_image
->bitmap
)
3756 img
->pixmap
= xpm_image
->bitmap
;
3757 /* XImageFree in libXpm frees XImage struct without destroying
3758 the bitmap, which is what we want. */
3759 fn_XImageFree (xpm_image
);
3761 if (xpm_mask
&& xpm_mask
->bitmap
)
3763 /* The mask appears to be inverted compared with what we expect.
3764 TODO: invert our expectations. See other places where we
3765 have to invert bits because our idea of masks is backwards. */
3767 old_obj
= SelectObject (hdc
, xpm_mask
->bitmap
);
3769 PatBlt (hdc
, 0, 0, xpm_mask
->width
, xpm_mask
->height
, DSTINVERT
);
3770 SelectObject (hdc
, old_obj
);
3772 img
->mask
= xpm_mask
->bitmap
;
3773 fn_XImageFree (xpm_mask
);
3778 #endif /* HAVE_NTGUI */
3780 /* Remember allocated colors. */
3781 img
->ncolors
= attrs
.nalloc_pixels
;
3782 img
->colors
= (unsigned long *) xmalloc (img
->ncolors
3783 * sizeof *img
->colors
);
3784 for (i
= 0; i
< attrs
.nalloc_pixels
; ++i
)
3786 img
->colors
[i
] = attrs
.alloc_pixels
[i
];
3787 #ifdef DEBUG_X_COLORS
3788 register_color (img
->colors
[i
]);
3791 #endif /* not ALLOC_XPM_COLORS */
3793 img
->width
= attrs
.width
;
3794 img
->height
= attrs
.height
;
3795 xassert (img
->width
> 0 && img
->height
> 0);
3797 /* The call to XpmFreeAttributes below frees attrs.alloc_pixels. */
3799 fn_XpmFreeAttributes (&attrs
);
3801 XpmFreeAttributes (&attrs
);
3802 #endif /* HAVE_NTGUI */
3808 #endif /* HAVE_NTGUI */
3813 image_error ("Error opening XPM file (%s)", img
->spec
, Qnil
);
3816 case XpmFileInvalid
:
3817 image_error ("Invalid XPM file (%s)", img
->spec
, Qnil
);
3821 image_error ("Out of memory (%s)", img
->spec
, Qnil
);
3824 case XpmColorFailed
:
3825 image_error ("Color allocation error (%s)", img
->spec
, Qnil
);
3829 image_error ("Unknown error (%s)", img
->spec
, Qnil
);
3834 #ifdef ALLOC_XPM_COLORS
3835 xpm_free_color_cache ();
3837 return rc
== XpmSuccess
;
3840 #endif /* HAVE_XPM */
3844 /* XPM support functions for Mac OS where libxpm is not available.
3845 Only XPM version 3 (without any extensions) is supported. */
3847 static int xpm_scan
P_ ((unsigned char **, unsigned char *,
3848 unsigned char **, int *));
3849 static Lisp_Object xpm_make_color_table_v
3850 P_ ((void (**) (Lisp_Object
, unsigned char *, int, Lisp_Object
),
3851 Lisp_Object (**) (Lisp_Object
, unsigned char *, int)));
3852 static void xpm_put_color_table_v
P_ ((Lisp_Object
, unsigned char *,
3854 static Lisp_Object xpm_get_color_table_v
P_ ((Lisp_Object
,
3855 unsigned char *, int));
3856 static Lisp_Object xpm_make_color_table_h
3857 P_ ((void (**) (Lisp_Object
, unsigned char *, int, Lisp_Object
),
3858 Lisp_Object (**) (Lisp_Object
, unsigned char *, int)));
3859 static void xpm_put_color_table_h
P_ ((Lisp_Object
, unsigned char *,
3861 static Lisp_Object xpm_get_color_table_h
P_ ((Lisp_Object
,
3862 unsigned char *, int));
3863 static int xpm_str_to_color_key
P_ ((char *));
3864 static int xpm_load_image
P_ ((struct frame
*, struct image
*,
3865 unsigned char *, unsigned char *));
3867 /* Tokens returned from xpm_scan. */
3876 /* Scan an XPM data and return a character (< 256) or a token defined
3877 by enum xpm_token above. *S and END are the start (inclusive) and
3878 the end (exclusive) addresses of the data, respectively. Advance
3879 *S while scanning. If token is either XPM_TK_IDENT or
3880 XPM_TK_STRING, *BEG and *LEN are set to the start address and the
3881 length of the corresponding token, respectively. */
3884 xpm_scan (s
, end
, beg
, len
)
3885 unsigned char **s
, *end
, **beg
;
3892 /* Skip white-space. */
3893 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
3896 /* gnus-pointer.xpm uses '-' in its identifier.
3897 sb-dir-plus.xpm uses '+' in its identifier. */
3898 if (isalpha (c
) || c
== '_' || c
== '-' || c
== '+')
3902 (c
= **s
, isalnum (c
) || c
== '_' || c
== '-' || c
== '+'))
3905 return XPM_TK_IDENT
;
3910 while (*s
< end
&& **s
!= '"')
3915 return XPM_TK_STRING
;
3919 if (*s
< end
&& **s
== '*')
3921 /* C-style comment. */
3925 while (*s
< end
&& *(*s
)++ != '*')
3928 while (*s
< end
&& **s
!= '/');
3942 /* Functions for color table lookup in XPM data. A Key is a string
3943 specifying the color of each pixel in XPM data. A value is either
3944 an integer that specifies a pixel color, Qt that specifies
3945 transparency, or Qnil for the unspecified color. If the length of
3946 the key string is one, a vector is used as a table. Otherwise, a
3947 hash table is used. */
3950 xpm_make_color_table_v (put_func
, get_func
)
3951 void (**put_func
) (Lisp_Object
, unsigned char *, int, Lisp_Object
);
3952 Lisp_Object (**get_func
) (Lisp_Object
, unsigned char *, int);
3954 *put_func
= xpm_put_color_table_v
;
3955 *get_func
= xpm_get_color_table_v
;
3956 return Fmake_vector (make_number (256), Qnil
);
3960 xpm_put_color_table_v (color_table
, chars_start
, chars_len
, color
)
3961 Lisp_Object color_table
;
3962 unsigned char *chars_start
;
3966 XVECTOR (color_table
)->contents
[*chars_start
] = color
;
3970 xpm_get_color_table_v (color_table
, chars_start
, chars_len
)
3971 Lisp_Object color_table
;
3972 unsigned char *chars_start
;
3975 return XVECTOR (color_table
)->contents
[*chars_start
];
3979 xpm_make_color_table_h (put_func
, get_func
)
3980 void (**put_func
) (Lisp_Object
, unsigned char *, int, Lisp_Object
);
3981 Lisp_Object (**get_func
) (Lisp_Object
, unsigned char *, int);
3983 *put_func
= xpm_put_color_table_h
;
3984 *get_func
= xpm_get_color_table_h
;
3985 return make_hash_table (Qequal
, make_number (DEFAULT_HASH_SIZE
),
3986 make_float (DEFAULT_REHASH_SIZE
),
3987 make_float (DEFAULT_REHASH_THRESHOLD
),
3992 xpm_put_color_table_h (color_table
, chars_start
, chars_len
, color
)
3993 Lisp_Object color_table
;
3994 unsigned char *chars_start
;
3998 struct Lisp_Hash_Table
*table
= XHASH_TABLE (color_table
);
4000 Lisp_Object chars
= make_unibyte_string (chars_start
, chars_len
);
4002 hash_lookup (table
, chars
, &hash_code
);
4003 hash_put (table
, chars
, color
, hash_code
);
4007 xpm_get_color_table_h (color_table
, chars_start
, chars_len
)
4008 Lisp_Object color_table
;
4009 unsigned char *chars_start
;
4012 struct Lisp_Hash_Table
*table
= XHASH_TABLE (color_table
);
4013 int i
= hash_lookup (table
, make_unibyte_string (chars_start
, chars_len
),
4016 return i
>= 0 ? HASH_VALUE (table
, i
) : Qnil
;
4019 enum xpm_color_key
{
4027 static char xpm_color_key_strings
[][4] = {"s", "m", "g4", "g", "c"};
4030 xpm_str_to_color_key (s
)
4036 i
< sizeof xpm_color_key_strings
/ sizeof xpm_color_key_strings
[0];
4038 if (strcmp (xpm_color_key_strings
[i
], s
) == 0)
4044 xpm_load_image (f
, img
, contents
, end
)
4047 unsigned char *contents
, *end
;
4049 unsigned char *s
= contents
, *beg
, *str
;
4050 unsigned char buffer
[BUFSIZ
];
4051 int width
, height
, x
, y
;
4052 int num_colors
, chars_per_pixel
;
4054 void (*put_color_table
) (Lisp_Object
, unsigned char *, int, Lisp_Object
);
4055 Lisp_Object (*get_color_table
) (Lisp_Object
, unsigned char *, int);
4056 Lisp_Object frame
, color_symbols
, color_table
;
4057 int best_key
, have_mask
= 0;
4058 XImagePtr ximg
= NULL
, mask_img
= NULL
;
4061 LA1 = xpm_scan (&s, end, &beg, &len)
4063 #define expect(TOKEN) \
4064 if (LA1 != (TOKEN)) \
4069 #define expect_ident(IDENT) \
4070 if (LA1 == XPM_TK_IDENT \
4071 && strlen ((IDENT)) == len && memcmp ((IDENT), beg, len) == 0) \
4076 if (!(end
- s
>= 9 && memcmp (s
, "/* XPM */", 9) == 0))
4080 expect_ident ("static");
4081 expect_ident ("char");
4083 expect (XPM_TK_IDENT
);
4088 expect (XPM_TK_STRING
);
4091 memcpy (buffer
, beg
, len
);
4093 if (sscanf (buffer
, "%d %d %d %d", &width
, &height
,
4094 &num_colors
, &chars_per_pixel
) != 4
4095 || width
<= 0 || height
<= 0
4096 || num_colors
<= 0 || chars_per_pixel
<= 0)
4100 XSETFRAME (frame
, f
);
4101 if (!NILP (Fxw_display_color_p (frame
)))
4102 best_key
= XPM_COLOR_KEY_C
;
4103 else if (!NILP (Fx_display_grayscale_p (frame
)))
4104 best_key
= (XFASTINT (Fx_display_planes (frame
)) > 2
4105 ? XPM_COLOR_KEY_G
: XPM_COLOR_KEY_G4
);
4107 best_key
= XPM_COLOR_KEY_M
;
4109 color_symbols
= image_spec_value (img
->spec
, QCcolor_symbols
, NULL
);
4110 if (chars_per_pixel
== 1)
4111 color_table
= xpm_make_color_table_v (&put_color_table
,
4114 color_table
= xpm_make_color_table_h (&put_color_table
,
4117 while (num_colors
-- > 0)
4119 unsigned char *color
, *max_color
;
4120 int key
, next_key
, max_key
= 0;
4121 Lisp_Object symbol_color
= Qnil
, color_val
;
4124 expect (XPM_TK_STRING
);
4125 if (len
<= chars_per_pixel
|| len
>= BUFSIZ
+ chars_per_pixel
)
4127 memcpy (buffer
, beg
+ chars_per_pixel
, len
- chars_per_pixel
);
4128 buffer
[len
- chars_per_pixel
] = '\0';
4130 str
= strtok (buffer
, " \t");
4133 key
= xpm_str_to_color_key (str
);
4138 color
= strtok (NULL
, " \t");
4142 while (str
= strtok (NULL
, " \t"))
4144 next_key
= xpm_str_to_color_key (str
);
4147 color
[strlen (color
)] = ' ';
4150 if (key
== XPM_COLOR_KEY_S
)
4152 if (NILP (symbol_color
))
4153 symbol_color
= build_string (color
);
4155 else if (max_key
< key
&& key
<= best_key
)
4165 if (!NILP (color_symbols
) && !NILP (symbol_color
))
4167 Lisp_Object specified_color
= Fassoc (symbol_color
, color_symbols
);
4169 if (CONSP (specified_color
) && STRINGP (XCDR (specified_color
)))
4170 if (xstricmp (SDATA (XCDR (specified_color
)), "None") == 0)
4172 else if (x_defined_color (f
, SDATA (XCDR (specified_color
)),
4174 color_val
= make_number (cdef
.pixel
);
4176 if (NILP (color_val
) && max_key
> 0)
4177 if (xstricmp (max_color
, "None") == 0)
4179 else if (x_defined_color (f
, max_color
, &cdef
, 0))
4180 color_val
= make_number (cdef
.pixel
);
4181 if (!NILP (color_val
))
4182 (*put_color_table
) (color_table
, beg
, chars_per_pixel
, color_val
);
4187 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0,
4188 &ximg
, &img
->pixmap
)
4189 || !x_create_x_image_and_pixmap (f
, width
, height
, 1,
4190 &mask_img
, &img
->mask
))
4192 image_error ("Out of memory (%s)", img
->spec
, Qnil
);
4196 for (y
= 0; y
< height
; y
++)
4198 expect (XPM_TK_STRING
);
4200 if (len
< width
* chars_per_pixel
)
4202 for (x
= 0; x
< width
; x
++, str
+= chars_per_pixel
)
4204 Lisp_Object color_val
=
4205 (*get_color_table
) (color_table
, str
, chars_per_pixel
);
4207 XPutPixel (ximg
, x
, y
,
4208 (INTEGERP (color_val
) ? XINT (color_val
)
4209 : FRAME_FOREGROUND_PIXEL (f
)));
4210 XPutPixel (mask_img
, x
, y
,
4211 (!EQ (color_val
, Qt
) ? PIX_MASK_DRAW (f
)
4212 : (have_mask
= 1, PIX_MASK_RETAIN (f
))));
4219 img
->height
= height
;
4221 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
4222 x_destroy_x_image (ximg
);
4225 x_put_x_image (f
, mask_img
, img
->mask
, width
, height
);
4226 x_destroy_x_image (mask_img
);
4230 x_destroy_x_image (mask_img
);
4231 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
4232 img
->mask
= NO_PIXMAP
;
4238 image_error ("Invalid XPM file (%s)", img
->spec
, Qnil
);
4240 x_destroy_x_image (ximg
);
4241 x_destroy_x_image (mask_img
);
4242 x_clear_image (f
, img
);
4256 Lisp_Object file_name
;
4258 /* If IMG->spec specifies a file name, create a non-file spec from it. */
4259 file_name
= image_spec_value (img
->spec
, QCfile
, NULL
);
4260 if (STRINGP (file_name
))
4263 unsigned char *contents
;
4265 struct gcpro gcpro1
;
4267 file
= x_find_image_file (file_name
);
4269 if (!STRINGP (file
))
4271 image_error ("Cannot find image file `%s'", file_name
, Qnil
);
4276 contents
= slurp_file (SDATA (file
), &size
);
4277 if (contents
== NULL
)
4279 image_error ("Error loading XPM image `%s'", img
->spec
, Qnil
);
4284 success_p
= xpm_load_image (f
, img
, contents
, contents
+ size
);
4292 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
4293 success_p
= xpm_load_image (f
, img
, SDATA (data
),
4294 SDATA (data
) + SBYTES (data
));
4304 /***********************************************************************
4306 ***********************************************************************/
4308 #ifdef COLOR_TABLE_SUPPORT
4310 /* An entry in the color table mapping an RGB color to a pixel color. */
4315 unsigned long pixel
;
4317 /* Next in color table collision list. */
4318 struct ct_color
*next
;
4321 /* The bucket vector size to use. Must be prime. */
4325 /* Value is a hash of the RGB color given by R, G, and B. */
4327 #define CT_HASH_RGB(R, G, B) (((R) << 16) ^ ((G) << 8) ^ (B))
4329 /* The color hash table. */
4331 struct ct_color
**ct_table
;
4333 /* Number of entries in the color table. */
4335 int ct_colors_allocated
;
4337 /* Initialize the color table. */
4342 int size
= CT_SIZE
* sizeof (*ct_table
);
4343 ct_table
= (struct ct_color
**) xmalloc (size
);
4344 bzero (ct_table
, size
);
4345 ct_colors_allocated
= 0;
4349 /* Free memory associated with the color table. */
4355 struct ct_color
*p
, *next
;
4357 for (i
= 0; i
< CT_SIZE
; ++i
)
4358 for (p
= ct_table
[i
]; p
; p
= next
)
4369 /* Value is a pixel color for RGB color R, G, B on frame F. If an
4370 entry for that color already is in the color table, return the
4371 pixel color of that entry. Otherwise, allocate a new color for R,
4372 G, B, and make an entry in the color table. */
4374 static unsigned long
4375 lookup_rgb_color (f
, r
, g
, b
)
4379 unsigned hash
= CT_HASH_RGB (r
, g
, b
);
4380 int i
= hash
% CT_SIZE
;
4382 Display_Info
*dpyinfo
;
4384 /* Handle TrueColor visuals specially, which improves performance by
4385 two orders of magnitude. Freeing colors on TrueColor visuals is
4386 a nop, and pixel colors specify RGB values directly. See also
4387 the Xlib spec, chapter 3.1. */
4388 dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
4389 if (dpyinfo
->red_bits
> 0)
4391 unsigned long pr
, pg
, pb
;
4393 /* Apply gamma-correction like normal color allocation does. */
4397 color
.red
= r
, color
.green
= g
, color
.blue
= b
;
4398 gamma_correct (f
, &color
);
4399 r
= color
.red
, g
= color
.green
, b
= color
.blue
;
4402 /* Scale down RGB values to the visual's bits per RGB, and shift
4403 them to the right position in the pixel color. Note that the
4404 original RGB values are 16-bit values, as usual in X. */
4405 pr
= (r
>> (16 - dpyinfo
->red_bits
)) << dpyinfo
->red_offset
;
4406 pg
= (g
>> (16 - dpyinfo
->green_bits
)) << dpyinfo
->green_offset
;
4407 pb
= (b
>> (16 - dpyinfo
->blue_bits
)) << dpyinfo
->blue_offset
;
4409 /* Assemble the pixel color. */
4410 return pr
| pg
| pb
;
4413 for (p
= ct_table
[i
]; p
; p
= p
->next
)
4414 if (p
->r
== r
&& p
->g
== g
&& p
->b
== b
)
4420 #ifdef HAVE_X_WINDOWS
4429 cmap
= FRAME_X_COLORMAP (f
);
4430 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
4433 ++ct_colors_allocated
;
4434 p
= (struct ct_color
*) xmalloc (sizeof *p
);
4438 p
->pixel
= color
.pixel
;
4439 p
->next
= ct_table
[i
];
4443 return FRAME_FOREGROUND_PIXEL (f
);
4448 color
= PALETTERGB (r
, g
, b
);
4450 color
= RGB_TO_ULONG (r
, g
, b
);
4451 #endif /* HAVE_NTGUI */
4452 ++ct_colors_allocated
;
4453 p
= (struct ct_color
*) xmalloc (sizeof *p
);
4458 p
->next
= ct_table
[i
];
4460 #endif /* HAVE_X_WINDOWS */
4468 /* Look up pixel color PIXEL which is used on frame F in the color
4469 table. If not already present, allocate it. Value is PIXEL. */
4471 static unsigned long
4472 lookup_pixel_color (f
, pixel
)
4474 unsigned long pixel
;
4476 int i
= pixel
% CT_SIZE
;
4479 for (p
= ct_table
[i
]; p
; p
= p
->next
)
4480 if (p
->pixel
== pixel
)
4489 #ifdef HAVE_X_WINDOWS
4490 cmap
= FRAME_X_COLORMAP (f
);
4491 color
.pixel
= pixel
;
4492 x_query_color (f
, &color
);
4493 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
4496 cmap
= DefaultColormapOfScreen (FRAME_X_SCREEN (f
));
4497 color
.pixel
= pixel
;
4498 XQueryColor (NULL
, cmap
, &color
);
4499 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
4501 #endif /* HAVE_X_WINDOWS */
4505 ++ct_colors_allocated
;
4507 p
= (struct ct_color
*) xmalloc (sizeof *p
);
4512 p
->next
= ct_table
[i
];
4516 return FRAME_FOREGROUND_PIXEL (f
);
4522 /* Value is a vector of all pixel colors contained in the color table,
4523 allocated via xmalloc. Set *N to the number of colors. */
4525 static unsigned long *
4526 colors_in_color_table (n
)
4531 unsigned long *colors
;
4533 if (ct_colors_allocated
== 0)
4540 colors
= (unsigned long *) xmalloc (ct_colors_allocated
4542 *n
= ct_colors_allocated
;
4544 for (i
= j
= 0; i
< CT_SIZE
; ++i
)
4545 for (p
= ct_table
[i
]; p
; p
= p
->next
)
4546 colors
[j
++] = p
->pixel
;
4552 #else /* COLOR_TABLE_SUPPORT */
4554 static unsigned long
4555 lookup_rgb_color (f
, r
, g
, b
)
4559 unsigned long pixel
;
4562 pixel
= RGB_TO_ULONG (r
>> 8, g
>> 8, b
>> 8);
4563 gamma_correct (f
, &pixel
);
4567 pixel
= PALETTERGB (r
>> 8, g
>> 8, b
>> 8);
4568 #endif /* HAVE_NTGUI */
4577 #endif /* COLOR_TABLE_SUPPORT */
4580 /***********************************************************************
4582 ***********************************************************************/
4584 static XColor
*x_to_xcolors
P_ ((struct frame
*, struct image
*, int));
4585 static void x_from_xcolors
P_ ((struct frame
*, struct image
*, XColor
*));
4586 static void x_detect_edges
P_ ((struct frame
*, struct image
*, int[9], int));
4589 static void XPutPixel (XImagePtr
, int, int, COLORREF
);
4590 #endif /* HAVE_NTGUI */
4592 /* Non-zero means draw a cross on images having `:conversion
4595 int cross_disabled_images
;
4597 /* Edge detection matrices for different edge-detection
4600 static int emboss_matrix
[9] = {
4602 2, -1, 0, /* y - 1 */
4604 0, 1, -2 /* y + 1 */
4607 static int laplace_matrix
[9] = {
4609 1, 0, 0, /* y - 1 */
4611 0, 0, -1 /* y + 1 */
4614 /* Value is the intensity of the color whose red/green/blue values
4617 #define COLOR_INTENSITY(R, G, B) ((2 * (R) + 3 * (G) + (B)) / 6)
4620 /* On frame F, return an array of XColor structures describing image
4621 IMG->pixmap. Each XColor structure has its pixel color set. RGB_P
4622 non-zero means also fill the red/green/blue members of the XColor
4623 structures. Value is a pointer to the array of XColors structures,
4624 allocated with xmalloc; it must be freed by the caller. */
4627 x_to_xcolors (f
, img
, rgb_p
)
4634 XImagePtr_or_DC ximg
;
4638 #endif /* HAVE_NTGUI */
4640 colors
= (XColor
*) xmalloc (img
->width
* img
->height
* sizeof *colors
);
4643 /* Get the X image IMG->pixmap. */
4644 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
4645 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
4647 /* Load the image into a memory device context. */
4648 hdc
= get_frame_dc (f
);
4649 ximg
= CreateCompatibleDC (hdc
);
4650 release_frame_dc (f
, hdc
);
4651 prev
= SelectObject (ximg
, img
->pixmap
);
4652 #endif /* HAVE_NTGUI */
4654 /* Fill the `pixel' members of the XColor array. I wished there
4655 were an easy and portable way to circumvent XGetPixel. */
4657 for (y
= 0; y
< img
->height
; ++y
)
4661 #ifdef HAVE_X_WINDOWS
4662 for (x
= 0; x
< img
->width
; ++x
, ++p
)
4663 p
->pixel
= XGetPixel (ximg
, x
, y
);
4665 x_query_colors (f
, row
, img
->width
);
4669 for (x
= 0; x
< img
->width
; ++x
, ++p
)
4671 /* W32_TODO: palette support needed here? */
4672 p
->pixel
= GET_PIXEL (ximg
, x
, y
);
4676 p
->red
= RED16_FROM_ULONG (p
->pixel
);
4677 p
->green
= GREEN16_FROM_ULONG (p
->pixel
);
4678 p
->blue
= BLUE16_FROM_ULONG (p
->pixel
);
4681 p
->red
= 256 * GetRValue (p
->pixel
);
4682 p
->green
= 256 * GetGValue (p
->pixel
);
4683 p
->blue
= 256 * GetBValue (p
->pixel
);
4684 #endif /* HAVE_NTGUI */
4687 #endif /* HAVE_X_WINDOWS */
4690 Destroy_Image (ximg
, prev
);
4697 /* Put a pixel of COLOR at position X, Y in XIMG. XIMG must have been
4698 created with CreateDIBSection, with the pointer to the bit values
4699 stored in ximg->data. */
4701 static void XPutPixel (ximg
, x
, y
, color
)
4706 int width
= ximg
->info
.bmiHeader
.biWidth
;
4707 int height
= ximg
->info
.bmiHeader
.biHeight
;
4708 unsigned char * pixel
;
4710 /* True color images. */
4711 if (ximg
->info
.bmiHeader
.biBitCount
== 24)
4713 int rowbytes
= width
* 3;
4714 /* Ensure scanlines are aligned on 4 byte boundaries. */
4716 rowbytes
+= 4 - (rowbytes
% 4);
4718 pixel
= ximg
->data
+ y
* rowbytes
+ x
* 3;
4719 /* Windows bitmaps are in BGR order. */
4720 *pixel
= GetBValue (color
);
4721 *(pixel
+ 1) = GetGValue (color
);
4722 *(pixel
+ 2) = GetRValue (color
);
4724 /* Monochrome images. */
4725 else if (ximg
->info
.bmiHeader
.biBitCount
== 1)
4727 int rowbytes
= width
/ 8;
4728 /* Ensure scanlines are aligned on 4 byte boundaries. */
4730 rowbytes
+= 4 - (rowbytes
% 4);
4731 pixel
= ximg
->data
+ y
* rowbytes
+ x
/ 8;
4732 /* Filter out palette info. */
4733 if (color
& 0x00ffffff)
4734 *pixel
= *pixel
| (1 << x
% 8);
4736 *pixel
= *pixel
& ~(1 << x
% 8);
4739 image_error ("XPutPixel: palette image not supported", Qnil
, Qnil
);
4742 #endif /* HAVE_NTGUI */
4744 /* Create IMG->pixmap from an array COLORS of XColor structures, whose
4745 RGB members are set. F is the frame on which this all happens.
4746 COLORS will be freed; an existing IMG->pixmap will be freed, too. */
4749 x_from_xcolors (f
, img
, colors
)
4759 init_color_table ();
4761 x_create_x_image_and_pixmap (f
, img
->width
, img
->height
, 0,
4764 for (y
= 0; y
< img
->height
; ++y
)
4765 for (x
= 0; x
< img
->width
; ++x
, ++p
)
4767 unsigned long pixel
;
4768 pixel
= lookup_rgb_color (f
, p
->red
, p
->green
, p
->blue
);
4769 XPutPixel (oimg
, x
, y
, pixel
);
4773 x_clear_image_1 (f
, img
, 1, 0, 1);
4775 x_put_x_image (f
, oimg
, pixmap
, img
->width
, img
->height
);
4776 x_destroy_x_image (oimg
);
4777 img
->pixmap
= pixmap
;
4778 #ifdef COLOR_TABLE_SUPPORT
4779 img
->colors
= colors_in_color_table (&img
->ncolors
);
4780 free_color_table ();
4781 #endif /* COLOR_TABLE_SUPPORT */
4785 /* On frame F, perform edge-detection on image IMG.
4787 MATRIX is a nine-element array specifying the transformation
4788 matrix. See emboss_matrix for an example.
4790 COLOR_ADJUST is a color adjustment added to each pixel of the
4794 x_detect_edges (f
, img
, matrix
, color_adjust
)
4797 int matrix
[9], color_adjust
;
4799 XColor
*colors
= x_to_xcolors (f
, img
, 1);
4803 for (i
= sum
= 0; i
< 9; ++i
)
4804 sum
+= abs (matrix
[i
]);
4806 #define COLOR(A, X, Y) ((A) + (Y) * img->width + (X))
4808 new = (XColor
*) xmalloc (img
->width
* img
->height
* sizeof *new);
4810 for (y
= 0; y
< img
->height
; ++y
)
4812 p
= COLOR (new, 0, y
);
4813 p
->red
= p
->green
= p
->blue
= 0xffff/2;
4814 p
= COLOR (new, img
->width
- 1, y
);
4815 p
->red
= p
->green
= p
->blue
= 0xffff/2;
4818 for (x
= 1; x
< img
->width
- 1; ++x
)
4820 p
= COLOR (new, x
, 0);
4821 p
->red
= p
->green
= p
->blue
= 0xffff/2;
4822 p
= COLOR (new, x
, img
->height
- 1);
4823 p
->red
= p
->green
= p
->blue
= 0xffff/2;
4826 for (y
= 1; y
< img
->height
- 1; ++y
)
4828 p
= COLOR (new, 1, y
);
4830 for (x
= 1; x
< img
->width
- 1; ++x
, ++p
)
4832 int r
, g
, b
, y1
, x1
;
4835 for (y1
= y
- 1; y1
< y
+ 2; ++y1
)
4836 for (x1
= x
- 1; x1
< x
+ 2; ++x1
, ++i
)
4839 XColor
*t
= COLOR (colors
, x1
, y1
);
4840 r
+= matrix
[i
] * t
->red
;
4841 g
+= matrix
[i
] * t
->green
;
4842 b
+= matrix
[i
] * t
->blue
;
4845 r
= (r
/ sum
+ color_adjust
) & 0xffff;
4846 g
= (g
/ sum
+ color_adjust
) & 0xffff;
4847 b
= (b
/ sum
+ color_adjust
) & 0xffff;
4848 p
->red
= p
->green
= p
->blue
= COLOR_INTENSITY (r
, g
, b
);
4853 x_from_xcolors (f
, img
, new);
4859 /* Perform the pre-defined `emboss' edge-detection on image IMG
4867 x_detect_edges (f
, img
, emboss_matrix
, 0xffff / 2);
4871 /* Transform image IMG which is used on frame F with a Laplace
4872 edge-detection algorithm. The result is an image that can be used
4873 to draw disabled buttons, for example. */
4880 x_detect_edges (f
, img
, laplace_matrix
, 45000);
4884 /* Perform edge-detection on image IMG on frame F, with specified
4885 transformation matrix MATRIX and color-adjustment COLOR_ADJUST.
4887 MATRIX must be either
4889 - a list of at least 9 numbers in row-major form
4890 - a vector of at least 9 numbers
4892 COLOR_ADJUST nil means use a default; otherwise it must be a
4896 x_edge_detection (f
, img
, matrix
, color_adjust
)
4899 Lisp_Object matrix
, color_adjust
;
4907 i
< 9 && CONSP (matrix
) && NUMBERP (XCAR (matrix
));
4908 ++i
, matrix
= XCDR (matrix
))
4909 trans
[i
] = XFLOATINT (XCAR (matrix
));
4911 else if (VECTORP (matrix
) && ASIZE (matrix
) >= 9)
4913 for (i
= 0; i
< 9 && NUMBERP (AREF (matrix
, i
)); ++i
)
4914 trans
[i
] = XFLOATINT (AREF (matrix
, i
));
4917 if (NILP (color_adjust
))
4918 color_adjust
= make_number (0xffff / 2);
4920 if (i
== 9 && NUMBERP (color_adjust
))
4921 x_detect_edges (f
, img
, trans
, (int) XFLOATINT (color_adjust
));
4925 /* Transform image IMG on frame F so that it looks disabled. */
4928 x_disable_image (f
, img
)
4932 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
4934 int n_planes
= dpyinfo
->n_planes
* dpyinfo
->n_cbits
;
4936 int n_planes
= dpyinfo
->n_planes
;
4937 #endif /* HAVE_NTGUI */
4941 /* Color (or grayscale). Convert to gray, and equalize. Just
4942 drawing such images with a stipple can look very odd, so
4943 we're using this method instead. */
4944 XColor
*colors
= x_to_xcolors (f
, img
, 1);
4946 const int h
= 15000;
4947 const int l
= 30000;
4949 for (p
= colors
, end
= colors
+ img
->width
* img
->height
;
4953 int i
= COLOR_INTENSITY (p
->red
, p
->green
, p
->blue
);
4954 int i2
= (0xffff - h
- l
) * i
/ 0xffff + l
;
4955 p
->red
= p
->green
= p
->blue
= i2
;
4958 x_from_xcolors (f
, img
, colors
);
4961 /* Draw a cross over the disabled image, if we must or if we
4963 if (n_planes
< 2 || cross_disabled_images
)
4966 Display
*dpy
= FRAME_X_DISPLAY (f
);
4970 #define XCreateGC_pixmap(dpy, pixmap) XCreateGC (dpy, NULL, 0, NULL)
4971 #define MaskForeground(f) PIX_MASK_DRAW (f)
4973 #define XCreateGC_pixmap(dpy, pixmap) XCreateGC (dpy, pixmap, 0, NULL)
4974 #define MaskForeground(f) WHITE_PIX_DEFAULT (f)
4977 gc
= XCreateGC_pixmap (dpy
, img
->pixmap
);
4978 XSetForeground (dpy
, gc
, BLACK_PIX_DEFAULT (f
));
4979 XDrawLine (dpy
, img
->pixmap
, gc
, 0, 0,
4980 img
->width
- 1, img
->height
- 1);
4981 XDrawLine (dpy
, img
->pixmap
, gc
, 0, img
->height
- 1,
4987 gc
= XCreateGC_pixmap (dpy
, img
->mask
);
4988 XSetForeground (dpy
, gc
, MaskForeground (f
));
4989 XDrawLine (dpy
, img
->mask
, gc
, 0, 0,
4990 img
->width
- 1, img
->height
- 1);
4991 XDrawLine (dpy
, img
->mask
, gc
, 0, img
->height
- 1,
4999 hdc
= get_frame_dc (f
);
5000 bmpdc
= CreateCompatibleDC (hdc
);
5001 release_frame_dc (f
, hdc
);
5003 prev
= SelectObject (bmpdc
, img
->pixmap
);
5005 SetTextColor (bmpdc
, BLACK_PIX_DEFAULT (f
));
5006 MoveToEx (bmpdc
, 0, 0, NULL
);
5007 LineTo (bmpdc
, img
->width
- 1, img
->height
- 1);
5008 MoveToEx (bmpdc
, 0, img
->height
- 1, NULL
);
5009 LineTo (bmpdc
, img
->width
- 1, 0);
5013 SelectObject (bmpdc
, img
->mask
);
5014 SetTextColor (bmpdc
, WHITE_PIX_DEFAULT (f
));
5015 MoveToEx (bmpdc
, 0, 0, NULL
);
5016 LineTo (bmpdc
, img
->width
- 1, img
->height
- 1);
5017 MoveToEx (bmpdc
, 0, img
->height
- 1, NULL
);
5018 LineTo (bmpdc
, img
->width
- 1, 0);
5020 SelectObject (bmpdc
, prev
);
5022 #endif /* HAVE_NTGUI */
5027 /* Build a mask for image IMG which is used on frame F. FILE is the
5028 name of an image file, for error messages. HOW determines how to
5029 determine the background color of IMG. If it is a list '(R G B)',
5030 with R, G, and B being integers >= 0, take that as the color of the
5031 background. Otherwise, determine the background color of IMG
5032 heuristically. Value is non-zero if successful. */
5035 x_build_heuristic_mask (f
, img
, how
)
5040 XImagePtr_or_DC ximg
;
5048 #endif /* HAVE_NTGUI */
5049 int x
, y
, rc
, use_img_background
;
5050 unsigned long bg
= 0;
5054 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
5055 img
->mask
= NO_PIXMAP
;
5056 img
->background_transparent_valid
= 0;
5060 /* Create an image and pixmap serving as mask. */
5061 rc
= x_create_x_image_and_pixmap (f
, img
->width
, img
->height
, 1,
5062 &mask_img
, &img
->mask
);
5066 /* Get the X image of IMG->pixmap. */
5067 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
, 0, 0,
5068 img
->width
, img
->height
,
5071 /* Create the bit array serving as mask. */
5072 row_width
= (img
->width
+ 7) / 8;
5073 mask_img
= xmalloc (row_width
* img
->height
);
5074 bzero (mask_img
, row_width
* img
->height
);
5076 /* Create a memory device context for IMG->pixmap. */
5077 frame_dc
= get_frame_dc (f
);
5078 ximg
= CreateCompatibleDC (frame_dc
);
5079 release_frame_dc (f
, frame_dc
);
5080 prev
= SelectObject (ximg
, img
->pixmap
);
5081 #endif /* HAVE_NTGUI */
5083 /* Determine the background color of ximg. If HOW is `(R G B)'
5084 take that as color. Otherwise, use the image's background color. */
5085 use_img_background
= 1;
5091 for (i
= 0; i
< 3 && CONSP (how
) && NATNUMP (XCAR (how
)); ++i
)
5093 rgb
[i
] = XFASTINT (XCAR (how
)) & 0xffff;
5097 if (i
== 3 && NILP (how
))
5099 char color_name
[30];
5100 sprintf (color_name
, "#%04x%04x%04x", rgb
[0], rgb
[1], rgb
[2]);
5103 0x00ffffff & /* Filter out palette info. */
5104 #endif /* HAVE_NTGUI */
5105 x_alloc_image_color (f
, img
, build_string (color_name
), 0));
5106 use_img_background
= 0;
5110 if (use_img_background
)
5111 bg
= four_corners_best (ximg
, img
->width
, img
->height
);
5113 /* Set all bits in mask_img to 1 whose color in ximg is different
5114 from the background color bg. */
5116 for (y
= 0; y
< img
->height
; ++y
)
5117 for (x
= 0; x
< img
->width
; ++x
)
5118 XPutPixel (mask_img
, x
, y
, (XGetPixel (ximg
, x
, y
) != bg
5119 ? PIX_MASK_DRAW (f
) : PIX_MASK_RETAIN (f
)));
5121 /* Fill in the background_transparent field while we have the mask handy. */
5122 image_background_transparent (img
, f
, mask_img
);
5124 /* Put mask_img into img->mask. */
5125 x_put_x_image (f
, mask_img
, img
->mask
, img
->width
, img
->height
);
5126 x_destroy_x_image (mask_img
);
5129 for (y
= 0; y
< img
->height
; ++y
)
5130 for (x
= 0; x
< img
->width
; ++x
)
5132 COLORREF p
= GetPixel (ximg
, x
, y
);
5134 mask_img
[y
* row_width
+ x
/ 8] |= 1 << (x
% 8);
5137 /* Create the mask image. */
5138 img
->mask
= w32_create_pixmap_from_bitmap_data (img
->width
, img
->height
,
5140 /* Fill in the background_transparent field while we have the mask handy. */
5141 SelectObject (ximg
, img
->mask
);
5142 image_background_transparent (img
, f
, ximg
);
5144 /* Was: x_destroy_x_image ((XImagePtr )mask_img); which seems bogus ++kfs */
5146 #endif /* HAVE_NTGUI */
5148 Destroy_Image (ximg
, prev
);
5154 /***********************************************************************
5155 PBM (mono, gray, color)
5156 ***********************************************************************/
5158 static int pbm_image_p
P_ ((Lisp_Object object
));
5159 static int pbm_load
P_ ((struct frame
*f
, struct image
*img
));
5160 static int pbm_scan_number
P_ ((unsigned char **, unsigned char *));
5162 /* The symbol `pbm' identifying images of this type. */
5166 /* Indices of image specification fields in gs_format, below. */
5168 enum pbm_keyword_index
5184 /* Vector of image_keyword structures describing the format
5185 of valid user-defined image specifications. */
5187 static struct image_keyword pbm_format
[PBM_LAST
] =
5189 {":type", IMAGE_SYMBOL_VALUE
, 1},
5190 {":file", IMAGE_STRING_VALUE
, 0},
5191 {":data", IMAGE_STRING_VALUE
, 0},
5192 {":ascent", IMAGE_ASCENT_VALUE
, 0},
5193 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
5194 {":relief", IMAGE_INTEGER_VALUE
, 0},
5195 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5196 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5197 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5198 {":foreground", IMAGE_STRING_OR_NIL_VALUE
, 0},
5199 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
5202 /* Structure describing the image type `pbm'. */
5204 static struct image_type pbm_type
=
5214 /* Return non-zero if OBJECT is a valid PBM image specification. */
5217 pbm_image_p (object
)
5220 struct image_keyword fmt
[PBM_LAST
];
5222 bcopy (pbm_format
, fmt
, sizeof fmt
);
5224 if (!parse_image_spec (object
, fmt
, PBM_LAST
, Qpbm
))
5227 /* Must specify either :data or :file. */
5228 return fmt
[PBM_DATA
].count
+ fmt
[PBM_FILE
].count
== 1;
5232 /* Scan a decimal number from *S and return it. Advance *S while
5233 reading the number. END is the end of the string. Value is -1 at
5237 pbm_scan_number (s
, end
)
5238 unsigned char **s
, *end
;
5240 int c
= 0, val
= -1;
5244 /* Skip white-space. */
5245 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
5250 /* Skip comment to end of line. */
5251 while (*s
< end
&& (c
= *(*s
)++, c
!= '\n'))
5254 else if (isdigit (c
))
5256 /* Read decimal number. */
5258 while (*s
< end
&& (c
= *(*s
)++, isdigit (c
)))
5259 val
= 10 * val
+ c
- '0';
5271 #if 0 /* Unused. ++kfs */
5273 /* Read FILE into memory. Value is a pointer to a buffer allocated
5274 with xmalloc holding FILE's contents. Value is null if an error
5275 occurred. *SIZE is set to the size of the file. */
5278 pbm_read_file (file
, size
)
5286 if (stat (SDATA (file
), &st
) == 0
5287 && (fp
= fopen (SDATA (file
), "rb")) != NULL
5288 && (buf
= (char *) xmalloc (st
.st_size
),
5289 fread (buf
, 1, st
.st_size
, fp
) == st
.st_size
))
5308 #endif /* HAVE_NTGUI */
5310 /* Load PBM image IMG for use on frame F. */
5318 int width
, height
, max_color_idx
= 0;
5320 Lisp_Object file
, specified_file
;
5321 enum {PBM_MONO
, PBM_GRAY
, PBM_COLOR
} type
;
5322 struct gcpro gcpro1
;
5323 unsigned char *contents
= NULL
;
5324 unsigned char *end
, *p
;
5327 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
5331 if (STRINGP (specified_file
))
5333 file
= x_find_image_file (specified_file
);
5334 if (!STRINGP (file
))
5336 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
5341 contents
= slurp_file (SDATA (file
), &size
);
5342 if (contents
== NULL
)
5344 image_error ("Error reading `%s'", file
, Qnil
);
5350 end
= contents
+ size
;
5355 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
5357 end
= p
+ SBYTES (data
);
5360 /* Check magic number. */
5361 if (end
- p
< 2 || *p
++ != 'P')
5363 image_error ("Not a PBM image: `%s'", img
->spec
, Qnil
);
5373 raw_p
= 0, type
= PBM_MONO
;
5377 raw_p
= 0, type
= PBM_GRAY
;
5381 raw_p
= 0, type
= PBM_COLOR
;
5385 raw_p
= 1, type
= PBM_MONO
;
5389 raw_p
= 1, type
= PBM_GRAY
;
5393 raw_p
= 1, type
= PBM_COLOR
;
5397 image_error ("Not a PBM image: `%s'", img
->spec
, Qnil
);
5401 /* Read width, height, maximum color-component. Characters
5402 starting with `#' up to the end of a line are ignored. */
5403 width
= pbm_scan_number (&p
, end
);
5404 height
= pbm_scan_number (&p
, end
);
5406 if (type
!= PBM_MONO
)
5408 max_color_idx
= pbm_scan_number (&p
, end
);
5409 if (raw_p
&& max_color_idx
> 255)
5410 max_color_idx
= 255;
5415 || (type
!= PBM_MONO
&& max_color_idx
< 0))
5418 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0,
5419 &ximg
, &img
->pixmap
))
5422 /* Initialize the color hash table. */
5423 init_color_table ();
5425 if (type
== PBM_MONO
)
5428 struct image_keyword fmt
[PBM_LAST
];
5429 unsigned long fg
= FRAME_FOREGROUND_PIXEL (f
);
5430 unsigned long bg
= FRAME_BACKGROUND_PIXEL (f
);
5432 /* Parse the image specification. */
5433 bcopy (pbm_format
, fmt
, sizeof fmt
);
5434 parse_image_spec (img
->spec
, fmt
, PBM_LAST
, Qpbm
);
5436 /* Get foreground and background colors, maybe allocate colors. */
5437 if (fmt
[PBM_FOREGROUND
].count
5438 && STRINGP (fmt
[PBM_FOREGROUND
].value
))
5439 fg
= x_alloc_image_color (f
, img
, fmt
[PBM_FOREGROUND
].value
, fg
);
5440 if (fmt
[PBM_BACKGROUND
].count
5441 && STRINGP (fmt
[PBM_BACKGROUND
].value
))
5443 bg
= x_alloc_image_color (f
, img
, fmt
[PBM_BACKGROUND
].value
, bg
);
5444 img
->background
= bg
;
5445 img
->background_valid
= 1;
5448 for (y
= 0; y
< height
; ++y
)
5449 for (x
= 0; x
< width
; ++x
)
5459 g
= pbm_scan_number (&p
, end
);
5461 XPutPixel (ximg
, x
, y
, g
? fg
: bg
);
5466 for (y
= 0; y
< height
; ++y
)
5467 for (x
= 0; x
< width
; ++x
)
5471 if (type
== PBM_GRAY
)
5472 r
= g
= b
= raw_p
? *p
++ : pbm_scan_number (&p
, end
);
5481 r
= pbm_scan_number (&p
, end
);
5482 g
= pbm_scan_number (&p
, end
);
5483 b
= pbm_scan_number (&p
, end
);
5486 if (r
< 0 || g
< 0 || b
< 0)
5488 x_destroy_x_image (ximg
);
5489 image_error ("Invalid pixel value in image `%s'",
5494 /* RGB values are now in the range 0..max_color_idx.
5495 Scale this to the range 0..0xffff supported by X. */
5496 r
= (double) r
* 65535 / max_color_idx
;
5497 g
= (double) g
* 65535 / max_color_idx
;
5498 b
= (double) b
* 65535 / max_color_idx
;
5499 XPutPixel (ximg
, x
, y
, lookup_rgb_color (f
, r
, g
, b
));
5503 #ifdef COLOR_TABLE_SUPPORT
5504 /* Store in IMG->colors the colors allocated for the image, and
5505 free the color table. */
5506 img
->colors
= colors_in_color_table (&img
->ncolors
);
5507 free_color_table ();
5508 #endif /* COLOR_TABLE_SUPPORT */
5511 img
->height
= height
;
5513 /* Maybe fill in the background field while we have ximg handy. */
5515 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
5516 IMAGE_BACKGROUND (img
, f
, ximg
);
5518 /* Put the image into a pixmap. */
5519 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
5520 x_destroy_x_image (ximg
);
5522 /* X and W32 versions did it here, MAC version above. ++kfs
5524 img->height = height; */
5532 /***********************************************************************
5534 ***********************************************************************/
5536 #if defined (HAVE_PNG) || defined (MAC_OS)
5538 /* Function prototypes. */
5540 static int png_image_p
P_ ((Lisp_Object object
));
5541 static int png_load
P_ ((struct frame
*f
, struct image
*img
));
5543 /* The symbol `png' identifying images of this type. */
5547 /* Indices of image specification fields in png_format, below. */
5549 enum png_keyword_index
5564 /* Vector of image_keyword structures describing the format
5565 of valid user-defined image specifications. */
5567 static struct image_keyword png_format
[PNG_LAST
] =
5569 {":type", IMAGE_SYMBOL_VALUE
, 1},
5570 {":data", IMAGE_STRING_VALUE
, 0},
5571 {":file", IMAGE_STRING_VALUE
, 0},
5572 {":ascent", IMAGE_ASCENT_VALUE
, 0},
5573 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
5574 {":relief", IMAGE_INTEGER_VALUE
, 0},
5575 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5576 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5577 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5578 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
5581 /* Structure describing the image type `png'. */
5583 static struct image_type png_type
=
5592 /* Return non-zero if OBJECT is a valid PNG image specification. */
5595 png_image_p (object
)
5598 struct image_keyword fmt
[PNG_LAST
];
5599 bcopy (png_format
, fmt
, sizeof fmt
);
5601 if (!parse_image_spec (object
, fmt
, PNG_LAST
, Qpng
))
5604 /* Must specify either the :data or :file keyword. */
5605 return fmt
[PNG_FILE
].count
+ fmt
[PNG_DATA
].count
== 1;
5608 #endif /* HAVE_PNG || MAC_OS */
5613 #if defined HAVE_LIBPNG_PNG_H
5614 # include <libpng/png.h>
5620 /* PNG library details. */
5622 DEF_IMGLIB_FN (png_get_io_ptr
);
5623 DEF_IMGLIB_FN (png_check_sig
);
5624 DEF_IMGLIB_FN (png_create_read_struct
);
5625 DEF_IMGLIB_FN (png_create_info_struct
);
5626 DEF_IMGLIB_FN (png_destroy_read_struct
);
5627 DEF_IMGLIB_FN (png_set_read_fn
);
5628 DEF_IMGLIB_FN (png_init_io
);
5629 DEF_IMGLIB_FN (png_set_sig_bytes
);
5630 DEF_IMGLIB_FN (png_read_info
);
5631 DEF_IMGLIB_FN (png_get_IHDR
);
5632 DEF_IMGLIB_FN (png_get_valid
);
5633 DEF_IMGLIB_FN (png_set_strip_16
);
5634 DEF_IMGLIB_FN (png_set_expand
);
5635 DEF_IMGLIB_FN (png_set_gray_to_rgb
);
5636 DEF_IMGLIB_FN (png_set_background
);
5637 DEF_IMGLIB_FN (png_get_bKGD
);
5638 DEF_IMGLIB_FN (png_read_update_info
);
5639 DEF_IMGLIB_FN (png_get_channels
);
5640 DEF_IMGLIB_FN (png_get_rowbytes
);
5641 DEF_IMGLIB_FN (png_read_image
);
5642 DEF_IMGLIB_FN (png_read_end
);
5643 DEF_IMGLIB_FN (png_error
);
5646 init_png_functions (Lisp_Object libraries
)
5650 /* Try loading libpng under probable names. */
5651 if (!(library
= w32_delayed_load (libraries
, Qpng
)))
5654 LOAD_IMGLIB_FN (library
, png_get_io_ptr
);
5655 LOAD_IMGLIB_FN (library
, png_check_sig
);
5656 LOAD_IMGLIB_FN (library
, png_create_read_struct
);
5657 LOAD_IMGLIB_FN (library
, png_create_info_struct
);
5658 LOAD_IMGLIB_FN (library
, png_destroy_read_struct
);
5659 LOAD_IMGLIB_FN (library
, png_set_read_fn
);
5660 LOAD_IMGLIB_FN (library
, png_init_io
);
5661 LOAD_IMGLIB_FN (library
, png_set_sig_bytes
);
5662 LOAD_IMGLIB_FN (library
, png_read_info
);
5663 LOAD_IMGLIB_FN (library
, png_get_IHDR
);
5664 LOAD_IMGLIB_FN (library
, png_get_valid
);
5665 LOAD_IMGLIB_FN (library
, png_set_strip_16
);
5666 LOAD_IMGLIB_FN (library
, png_set_expand
);
5667 LOAD_IMGLIB_FN (library
, png_set_gray_to_rgb
);
5668 LOAD_IMGLIB_FN (library
, png_set_background
);
5669 LOAD_IMGLIB_FN (library
, png_get_bKGD
);
5670 LOAD_IMGLIB_FN (library
, png_read_update_info
);
5671 LOAD_IMGLIB_FN (library
, png_get_channels
);
5672 LOAD_IMGLIB_FN (library
, png_get_rowbytes
);
5673 LOAD_IMGLIB_FN (library
, png_read_image
);
5674 LOAD_IMGLIB_FN (library
, png_read_end
);
5675 LOAD_IMGLIB_FN (library
, png_error
);
5680 #define fn_png_get_io_ptr png_get_io_ptr
5681 #define fn_png_check_sig png_check_sig
5682 #define fn_png_create_read_struct png_create_read_struct
5683 #define fn_png_create_info_struct png_create_info_struct
5684 #define fn_png_destroy_read_struct png_destroy_read_struct
5685 #define fn_png_set_read_fn png_set_read_fn
5686 #define fn_png_init_io png_init_io
5687 #define fn_png_set_sig_bytes png_set_sig_bytes
5688 #define fn_png_read_info png_read_info
5689 #define fn_png_get_IHDR png_get_IHDR
5690 #define fn_png_get_valid png_get_valid
5691 #define fn_png_set_strip_16 png_set_strip_16
5692 #define fn_png_set_expand png_set_expand
5693 #define fn_png_set_gray_to_rgb png_set_gray_to_rgb
5694 #define fn_png_set_background png_set_background
5695 #define fn_png_get_bKGD png_get_bKGD
5696 #define fn_png_read_update_info png_read_update_info
5697 #define fn_png_get_channels png_get_channels
5698 #define fn_png_get_rowbytes png_get_rowbytes
5699 #define fn_png_read_image png_read_image
5700 #define fn_png_read_end png_read_end
5701 #define fn_png_error png_error
5703 #endif /* HAVE_NTGUI */
5705 /* Error and warning handlers installed when the PNG library
5709 my_png_error (png_ptr
, msg
)
5710 png_struct
*png_ptr
;
5713 xassert (png_ptr
!= NULL
);
5714 image_error ("PNG error: %s", build_string (msg
), Qnil
);
5715 longjmp (png_ptr
->jmpbuf
, 1);
5720 my_png_warning (png_ptr
, msg
)
5721 png_struct
*png_ptr
;
5724 xassert (png_ptr
!= NULL
);
5725 image_error ("PNG warning: %s", build_string (msg
), Qnil
);
5728 /* Memory source for PNG decoding. */
5730 struct png_memory_storage
5732 unsigned char *bytes
; /* The data */
5733 size_t len
; /* How big is it? */
5734 int index
; /* Where are we? */
5738 /* Function set as reader function when reading PNG image from memory.
5739 PNG_PTR is a pointer to the PNG control structure. Copy LENGTH
5740 bytes from the input to DATA. */
5743 png_read_from_memory (png_ptr
, data
, length
)
5744 png_structp png_ptr
;
5748 struct png_memory_storage
*tbr
5749 = (struct png_memory_storage
*) fn_png_get_io_ptr (png_ptr
);
5751 if (length
> tbr
->len
- tbr
->index
)
5752 fn_png_error (png_ptr
, "Read error");
5754 bcopy (tbr
->bytes
+ tbr
->index
, data
, length
);
5755 tbr
->index
= tbr
->index
+ length
;
5759 /* Load PNG image IMG for use on frame F. Value is non-zero if
5767 Lisp_Object file
, specified_file
;
5768 Lisp_Object specified_data
;
5770 XImagePtr ximg
, mask_img
= NULL
;
5771 struct gcpro gcpro1
;
5772 png_struct
*png_ptr
= NULL
;
5773 png_info
*info_ptr
= NULL
, *end_info
= NULL
;
5774 FILE *volatile fp
= NULL
;
5776 png_byte
* volatile pixels
= NULL
;
5777 png_byte
** volatile rows
= NULL
;
5778 png_uint_32 width
, height
;
5779 int bit_depth
, color_type
, interlace_type
;
5781 png_uint_32 row_bytes
;
5783 double screen_gamma
;
5784 struct png_memory_storage tbr
; /* Data to be read */
5786 /* Find out what file to load. */
5787 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
5788 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
5792 if (NILP (specified_data
))
5794 file
= x_find_image_file (specified_file
);
5795 if (!STRINGP (file
))
5797 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
5802 /* Open the image file. */
5803 fp
= fopen (SDATA (file
), "rb");
5806 image_error ("Cannot open image file `%s'", file
, Qnil
);
5812 /* Check PNG signature. */
5813 if (fread (sig
, 1, sizeof sig
, fp
) != sizeof sig
5814 || !fn_png_check_sig (sig
, sizeof sig
))
5816 image_error ("Not a PNG file: `%s'", file
, Qnil
);
5824 /* Read from memory. */
5825 tbr
.bytes
= SDATA (specified_data
);
5826 tbr
.len
= SBYTES (specified_data
);
5829 /* Check PNG signature. */
5830 if (tbr
.len
< sizeof sig
5831 || !fn_png_check_sig (tbr
.bytes
, sizeof sig
))
5833 image_error ("Not a PNG image: `%s'", img
->spec
, Qnil
);
5838 /* Need to skip past the signature. */
5839 tbr
.bytes
+= sizeof (sig
);
5842 /* Initialize read and info structs for PNG lib. */
5843 png_ptr
= fn_png_create_read_struct (PNG_LIBPNG_VER_STRING
, NULL
,
5844 my_png_error
, my_png_warning
);
5847 if (fp
) fclose (fp
);
5852 info_ptr
= fn_png_create_info_struct (png_ptr
);
5855 fn_png_destroy_read_struct (&png_ptr
, NULL
, NULL
);
5856 if (fp
) fclose (fp
);
5861 end_info
= fn_png_create_info_struct (png_ptr
);
5864 fn_png_destroy_read_struct (&png_ptr
, &info_ptr
, NULL
);
5865 if (fp
) fclose (fp
);
5870 /* Set error jump-back. We come back here when the PNG library
5871 detects an error. */
5872 if (setjmp (png_ptr
->jmpbuf
))
5876 fn_png_destroy_read_struct (&png_ptr
, &info_ptr
, &end_info
);
5879 if (fp
) fclose (fp
);
5884 /* Read image info. */
5885 if (!NILP (specified_data
))
5886 fn_png_set_read_fn (png_ptr
, (void *) &tbr
, png_read_from_memory
);
5888 fn_png_init_io (png_ptr
, fp
);
5890 fn_png_set_sig_bytes (png_ptr
, sizeof sig
);
5891 fn_png_read_info (png_ptr
, info_ptr
);
5892 fn_png_get_IHDR (png_ptr
, info_ptr
, &width
, &height
, &bit_depth
, &color_type
,
5893 &interlace_type
, NULL
, NULL
);
5895 /* If image contains simply transparency data, we prefer to
5896 construct a clipping mask. */
5897 if (fn_png_get_valid (png_ptr
, info_ptr
, PNG_INFO_tRNS
))
5902 /* This function is easier to write if we only have to handle
5903 one data format: RGB or RGBA with 8 bits per channel. Let's
5904 transform other formats into that format. */
5906 /* Strip more than 8 bits per channel. */
5907 if (bit_depth
== 16)
5908 fn_png_set_strip_16 (png_ptr
);
5910 /* Expand data to 24 bit RGB, or 8 bit grayscale, with alpha channel
5912 fn_png_set_expand (png_ptr
);
5914 /* Convert grayscale images to RGB. */
5915 if (color_type
== PNG_COLOR_TYPE_GRAY
5916 || color_type
== PNG_COLOR_TYPE_GRAY_ALPHA
)
5917 fn_png_set_gray_to_rgb (png_ptr
);
5919 screen_gamma
= (f
->gamma
? 1 / f
->gamma
/ 0.45455 : 2.2);
5921 #if 0 /* Avoid double gamma correction for PNG images. */
5922 { /* Tell the PNG lib to handle gamma correction for us. */
5925 #if defined(PNG_READ_sRGB_SUPPORTED) || defined(PNG_WRITE_sRGB_SUPPORTED)
5926 if (png_get_sRGB (png_ptr
, info_ptr
, &intent
))
5927 /* The libpng documentation says this is right in this case. */
5928 png_set_gamma (png_ptr
, screen_gamma
, 0.45455);
5931 if (png_get_gAMA (png_ptr
, info_ptr
, &image_gamma
))
5932 /* Image contains gamma information. */
5933 png_set_gamma (png_ptr
, screen_gamma
, image_gamma
);
5935 /* Use the standard default for the image gamma. */
5936 png_set_gamma (png_ptr
, screen_gamma
, 0.45455);
5940 /* Handle alpha channel by combining the image with a background
5941 color. Do this only if a real alpha channel is supplied. For
5942 simple transparency, we prefer a clipping mask. */
5945 png_color_16
*image_bg
;
5946 Lisp_Object specified_bg
5947 = image_spec_value (img
->spec
, QCbackground
, NULL
);
5949 if (STRINGP (specified_bg
))
5950 /* The user specified `:background', use that. */
5952 /* W32 version incorrectly used COLORREF here!! ++kfs */
5954 if (x_defined_color (f
, SDATA (specified_bg
), &color
, 0))
5956 png_color_16 user_bg
;
5958 bzero (&user_bg
, sizeof user_bg
);
5959 user_bg
.red
= color
.red
>> 8;
5960 user_bg
.green
= color
.green
>> 8;
5961 user_bg
.blue
= color
.blue
>> 8;
5963 fn_png_set_background (png_ptr
, &user_bg
,
5964 PNG_BACKGROUND_GAMMA_SCREEN
, 0, 1.0);
5967 else if (fn_png_get_bKGD (png_ptr
, info_ptr
, &image_bg
))
5968 /* Image contains a background color with which to
5969 combine the image. */
5970 fn_png_set_background (png_ptr
, image_bg
,
5971 PNG_BACKGROUND_GAMMA_FILE
, 1, 1.0);
5974 /* Image does not contain a background color with which
5975 to combine the image data via an alpha channel. Use
5976 the frame's background instead. */
5977 #ifdef HAVE_X_WINDOWS
5979 png_color_16 frame_background
;
5981 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
5982 x_query_color (f
, &color
);
5984 bzero (&frame_background
, sizeof frame_background
);
5985 frame_background
.red
= color
.red
>> 8;
5986 frame_background
.green
= color
.green
>> 8;
5987 frame_background
.blue
= color
.blue
>> 8;
5988 #endif /* HAVE_X_WINDOWS */
5992 png_color_16 frame_background
;
5993 color
= FRAME_BACKGROUND_PIXEL (f
);
5994 #if 0 /* W32 TODO : Colormap support. */
5995 x_query_color (f
, &color
);
5997 bzero (&frame_background
, sizeof frame_background
);
5998 frame_background
.red
= GetRValue (color
);
5999 frame_background
.green
= GetGValue (color
);
6000 frame_background
.blue
= GetBValue (color
);
6001 #endif /* HAVE_NTGUI */
6004 unsigned long color
;
6005 png_color_16 frame_background
;
6006 color
= FRAME_BACKGROUND_PIXEL (f
);
6007 #if 0 /* MAC/W32 TODO : Colormap support. */
6008 x_query_color (f
, &color
);
6010 bzero (&frame_background
, sizeof frame_background
);
6011 frame_background
.red
= RED_FROM_ULONG (color
);
6012 frame_background
.green
= GREEN_FROM_ULONG (color
);
6013 frame_background
.blue
= BLUE_FROM_ULONG (color
);
6016 fn_png_set_background (png_ptr
, &frame_background
,
6017 PNG_BACKGROUND_GAMMA_SCREEN
, 0, 1.0);
6021 /* Update info structure. */
6022 fn_png_read_update_info (png_ptr
, info_ptr
);
6024 /* Get number of channels. Valid values are 1 for grayscale images
6025 and images with a palette, 2 for grayscale images with transparency
6026 information (alpha channel), 3 for RGB images, and 4 for RGB
6027 images with alpha channel, i.e. RGBA. If conversions above were
6028 sufficient we should only have 3 or 4 channels here. */
6029 channels
= fn_png_get_channels (png_ptr
, info_ptr
);
6030 xassert (channels
== 3 || channels
== 4);
6032 /* Number of bytes needed for one row of the image. */
6033 row_bytes
= fn_png_get_rowbytes (png_ptr
, info_ptr
);
6035 /* Allocate memory for the image. */
6036 pixels
= (png_byte
*) xmalloc (row_bytes
* height
* sizeof *pixels
);
6037 rows
= (png_byte
**) xmalloc (height
* sizeof *rows
);
6038 for (i
= 0; i
< height
; ++i
)
6039 rows
[i
] = pixels
+ i
* row_bytes
;
6041 /* Read the entire image. */
6042 fn_png_read_image (png_ptr
, rows
);
6043 fn_png_read_end (png_ptr
, info_ptr
);
6050 /* Create the X image and pixmap. */
6051 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
,
6055 /* Create an image and pixmap serving as mask if the PNG image
6056 contains an alpha channel. */
6059 && !x_create_x_image_and_pixmap (f
, width
, height
, 1,
6060 &mask_img
, &img
->mask
))
6062 x_destroy_x_image (ximg
);
6063 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->pixmap
);
6064 img
->pixmap
= NO_PIXMAP
;
6068 /* Fill the X image and mask from PNG data. */
6069 init_color_table ();
6071 for (y
= 0; y
< height
; ++y
)
6073 png_byte
*p
= rows
[y
];
6075 for (x
= 0; x
< width
; ++x
)
6082 XPutPixel (ximg
, x
, y
, lookup_rgb_color (f
, r
, g
, b
));
6083 /* An alpha channel, aka mask channel, associates variable
6084 transparency with an image. Where other image formats
6085 support binary transparency---fully transparent or fully
6086 opaque---PNG allows up to 254 levels of partial transparency.
6087 The PNG library implements partial transparency by combining
6088 the image with a specified background color.
6090 I'm not sure how to handle this here nicely: because the
6091 background on which the image is displayed may change, for
6092 real alpha channel support, it would be necessary to create
6093 a new image for each possible background.
6095 What I'm doing now is that a mask is created if we have
6096 boolean transparency information. Otherwise I'm using
6097 the frame's background color to combine the image with. */
6102 XPutPixel (mask_img
, x
, y
, *p
> 0 ? PIX_MASK_DRAW (f
) : PIX_MASK_RETAIN (f
));
6108 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
6109 /* Set IMG's background color from the PNG image, unless the user
6113 if (fn_png_get_bKGD (png_ptr
, info_ptr
, &bg
))
6115 img
->background
= lookup_rgb_color (f
, bg
->red
, bg
->green
, bg
->blue
);
6116 img
->background_valid
= 1;
6120 #ifdef COLOR_TABLE_SUPPORT
6121 /* Remember colors allocated for this image. */
6122 img
->colors
= colors_in_color_table (&img
->ncolors
);
6123 free_color_table ();
6124 #endif /* COLOR_TABLE_SUPPORT */
6127 fn_png_destroy_read_struct (&png_ptr
, &info_ptr
, &end_info
);
6132 img
->height
= height
;
6134 /* Maybe fill in the background field while we have ximg handy. */
6135 IMAGE_BACKGROUND (img
, f
, ximg
);
6137 /* Put the image into the pixmap, then free the X image and its buffer. */
6138 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
6139 x_destroy_x_image (ximg
);
6141 /* Same for the mask. */
6144 /* Fill in the background_transparent field while we have the mask
6146 image_background_transparent (img
, f
, mask_img
);
6148 x_put_x_image (f
, mask_img
, img
->mask
, img
->width
, img
->height
);
6149 x_destroy_x_image (mask_img
);
6156 #else /* HAVE_PNG */
6165 if (MyCGImageCreateWithPNGDataProvider
)
6166 return image_load_quartz2d (f
, img
, 1);
6169 return image_load_quicktime (f
, img
, kQTFileTypePNG
);
6173 #endif /* !HAVE_PNG */
6177 /***********************************************************************
6179 ***********************************************************************/
6181 #if defined (HAVE_JPEG) || defined (MAC_OS)
6183 static int jpeg_image_p
P_ ((Lisp_Object object
));
6184 static int jpeg_load
P_ ((struct frame
*f
, struct image
*img
));
6186 /* The symbol `jpeg' identifying images of this type. */
6190 /* Indices of image specification fields in gs_format, below. */
6192 enum jpeg_keyword_index
6201 JPEG_HEURISTIC_MASK
,
6207 /* Vector of image_keyword structures describing the format
6208 of valid user-defined image specifications. */
6210 static struct image_keyword jpeg_format
[JPEG_LAST
] =
6212 {":type", IMAGE_SYMBOL_VALUE
, 1},
6213 {":data", IMAGE_STRING_VALUE
, 0},
6214 {":file", IMAGE_STRING_VALUE
, 0},
6215 {":ascent", IMAGE_ASCENT_VALUE
, 0},
6216 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
6217 {":relief", IMAGE_INTEGER_VALUE
, 0},
6218 {":conversions", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6219 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6220 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6221 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
6224 /* Structure describing the image type `jpeg'. */
6226 static struct image_type jpeg_type
=
6235 /* Return non-zero if OBJECT is a valid JPEG image specification. */
6238 jpeg_image_p (object
)
6241 struct image_keyword fmt
[JPEG_LAST
];
6243 bcopy (jpeg_format
, fmt
, sizeof fmt
);
6245 if (!parse_image_spec (object
, fmt
, JPEG_LAST
, Qjpeg
))
6248 /* Must specify either the :data or :file keyword. */
6249 return fmt
[JPEG_FILE
].count
+ fmt
[JPEG_DATA
].count
== 1;
6252 #endif /* HAVE_JPEG || MAC_OS */
6256 /* Work around a warning about HAVE_STDLIB_H being redefined in
6258 #ifdef HAVE_STDLIB_H
6259 #define HAVE_STDLIB_H_1
6260 #undef HAVE_STDLIB_H
6261 #endif /* HAVE_STLIB_H */
6263 #if defined (HAVE_NTGUI) && !defined (__WIN32__)
6264 /* jpeglib.h will define boolean differently depending on __WIN32__,
6265 so make sure it is defined. */
6269 #include <jpeglib.h>
6273 #ifdef HAVE_STLIB_H_1
6274 #define HAVE_STDLIB_H 1
6279 /* JPEG library details. */
6280 DEF_IMGLIB_FN (jpeg_CreateDecompress
);
6281 DEF_IMGLIB_FN (jpeg_start_decompress
);
6282 DEF_IMGLIB_FN (jpeg_finish_decompress
);
6283 DEF_IMGLIB_FN (jpeg_destroy_decompress
);
6284 DEF_IMGLIB_FN (jpeg_read_header
);
6285 DEF_IMGLIB_FN (jpeg_read_scanlines
);
6286 DEF_IMGLIB_FN (jpeg_stdio_src
);
6287 DEF_IMGLIB_FN (jpeg_std_error
);
6288 DEF_IMGLIB_FN (jpeg_resync_to_restart
);
6291 init_jpeg_functions (Lisp_Object libraries
)
6295 if (!(library
= w32_delayed_load (libraries
, Qjpeg
)))
6298 LOAD_IMGLIB_FN (library
, jpeg_finish_decompress
);
6299 LOAD_IMGLIB_FN (library
, jpeg_read_scanlines
);
6300 LOAD_IMGLIB_FN (library
, jpeg_start_decompress
);
6301 LOAD_IMGLIB_FN (library
, jpeg_read_header
);
6302 LOAD_IMGLIB_FN (library
, jpeg_stdio_src
);
6303 LOAD_IMGLIB_FN (library
, jpeg_CreateDecompress
);
6304 LOAD_IMGLIB_FN (library
, jpeg_destroy_decompress
);
6305 LOAD_IMGLIB_FN (library
, jpeg_std_error
);
6306 LOAD_IMGLIB_FN (library
, jpeg_resync_to_restart
);
6310 /* Wrapper since we can't directly assign the function pointer
6311 to another function pointer that was declared more completely easily. */
6313 jpeg_resync_to_restart_wrapper(cinfo
, desired
)
6314 j_decompress_ptr cinfo
;
6317 return fn_jpeg_resync_to_restart (cinfo
, desired
);
6322 #define fn_jpeg_CreateDecompress(a,b,c) jpeg_create_decompress(a)
6323 #define fn_jpeg_start_decompress jpeg_start_decompress
6324 #define fn_jpeg_finish_decompress jpeg_finish_decompress
6325 #define fn_jpeg_destroy_decompress jpeg_destroy_decompress
6326 #define fn_jpeg_read_header jpeg_read_header
6327 #define fn_jpeg_read_scanlines jpeg_read_scanlines
6328 #define fn_jpeg_stdio_src jpeg_stdio_src
6329 #define fn_jpeg_std_error jpeg_std_error
6330 #define jpeg_resync_to_restart_wrapper jpeg_resync_to_restart
6332 #endif /* HAVE_NTGUI */
6334 struct my_jpeg_error_mgr
6336 struct jpeg_error_mgr pub
;
6337 jmp_buf setjmp_buffer
;
6342 my_error_exit (cinfo
)
6345 struct my_jpeg_error_mgr
*mgr
= (struct my_jpeg_error_mgr
*) cinfo
->err
;
6346 longjmp (mgr
->setjmp_buffer
, 1);
6350 /* Init source method for JPEG data source manager. Called by
6351 jpeg_read_header() before any data is actually read. See
6352 libjpeg.doc from the JPEG lib distribution. */
6355 our_init_source (cinfo
)
6356 j_decompress_ptr cinfo
;
6361 /* Fill input buffer method for JPEG data source manager. Called
6362 whenever more data is needed. We read the whole image in one step,
6363 so this only adds a fake end of input marker at the end. */
6366 our_fill_input_buffer (cinfo
)
6367 j_decompress_ptr cinfo
;
6369 /* Insert a fake EOI marker. */
6370 struct jpeg_source_mgr
*src
= cinfo
->src
;
6371 static JOCTET buffer
[2];
6373 buffer
[0] = (JOCTET
) 0xFF;
6374 buffer
[1] = (JOCTET
) JPEG_EOI
;
6376 src
->next_input_byte
= buffer
;
6377 src
->bytes_in_buffer
= 2;
6382 /* Method to skip over NUM_BYTES bytes in the image data. CINFO->src
6383 is the JPEG data source manager. */
6386 our_skip_input_data (cinfo
, num_bytes
)
6387 j_decompress_ptr cinfo
;
6390 struct jpeg_source_mgr
*src
= (struct jpeg_source_mgr
*) cinfo
->src
;
6394 if (num_bytes
> src
->bytes_in_buffer
)
6395 ERREXIT (cinfo
, JERR_INPUT_EOF
);
6397 src
->bytes_in_buffer
-= num_bytes
;
6398 src
->next_input_byte
+= num_bytes
;
6403 /* Method to terminate data source. Called by
6404 jpeg_finish_decompress() after all data has been processed. */
6407 our_term_source (cinfo
)
6408 j_decompress_ptr cinfo
;
6413 /* Set up the JPEG lib for reading an image from DATA which contains
6414 LEN bytes. CINFO is the decompression info structure created for
6415 reading the image. */
6418 jpeg_memory_src (cinfo
, data
, len
)
6419 j_decompress_ptr cinfo
;
6423 struct jpeg_source_mgr
*src
;
6425 if (cinfo
->src
== NULL
)
6427 /* First time for this JPEG object? */
6428 cinfo
->src
= (struct jpeg_source_mgr
*)
6429 (*cinfo
->mem
->alloc_small
) ((j_common_ptr
) cinfo
, JPOOL_PERMANENT
,
6430 sizeof (struct jpeg_source_mgr
));
6431 src
= (struct jpeg_source_mgr
*) cinfo
->src
;
6432 src
->next_input_byte
= data
;
6435 src
= (struct jpeg_source_mgr
*) cinfo
->src
;
6436 src
->init_source
= our_init_source
;
6437 src
->fill_input_buffer
= our_fill_input_buffer
;
6438 src
->skip_input_data
= our_skip_input_data
;
6439 src
->resync_to_restart
= jpeg_resync_to_restart_wrapper
; /* Use default method. */
6440 src
->term_source
= our_term_source
;
6441 src
->bytes_in_buffer
= len
;
6442 src
->next_input_byte
= data
;
6446 /* Load image IMG for use on frame F. Patterned after example.c
6447 from the JPEG lib. */
6454 struct jpeg_decompress_struct cinfo
;
6455 struct my_jpeg_error_mgr mgr
;
6456 Lisp_Object file
, specified_file
;
6457 Lisp_Object specified_data
;
6458 FILE * volatile fp
= NULL
;
6460 int row_stride
, x
, y
;
6461 XImagePtr ximg
= NULL
;
6463 unsigned long *colors
;
6465 struct gcpro gcpro1
;
6467 /* Open the JPEG file. */
6468 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
6469 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
6473 if (NILP (specified_data
))
6475 file
= x_find_image_file (specified_file
);
6476 if (!STRINGP (file
))
6478 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
6483 fp
= fopen (SDATA (file
), "rb");
6486 image_error ("Cannot open `%s'", file
, Qnil
);
6492 /* Customize libjpeg's error handling to call my_error_exit when an
6493 error is detected. This function will perform a longjmp. */
6494 cinfo
.err
= fn_jpeg_std_error (&mgr
.pub
);
6495 mgr
.pub
.error_exit
= my_error_exit
;
6497 if ((rc
= setjmp (mgr
.setjmp_buffer
)) != 0)
6501 /* Called from my_error_exit. Display a JPEG error. */
6502 char buffer
[JMSG_LENGTH_MAX
];
6503 cinfo
.err
->format_message ((j_common_ptr
) &cinfo
, buffer
);
6504 image_error ("Error reading JPEG image `%s': %s", img
->spec
,
6505 build_string (buffer
));
6508 /* Close the input file and destroy the JPEG object. */
6510 fclose ((FILE *) fp
);
6511 fn_jpeg_destroy_decompress (&cinfo
);
6513 /* If we already have an XImage, free that. */
6514 x_destroy_x_image (ximg
);
6516 /* Free pixmap and colors. */
6517 x_clear_image (f
, img
);
6523 /* Create the JPEG decompression object. Let it read from fp.
6524 Read the JPEG image header. */
6525 fn_jpeg_CreateDecompress (&cinfo
, JPEG_LIB_VERSION
, sizeof (cinfo
));
6527 if (NILP (specified_data
))
6528 fn_jpeg_stdio_src (&cinfo
, (FILE *) fp
);
6530 jpeg_memory_src (&cinfo
, SDATA (specified_data
),
6531 SBYTES (specified_data
));
6533 fn_jpeg_read_header (&cinfo
, 1);
6535 /* Customize decompression so that color quantization will be used.
6536 Start decompression. */
6537 cinfo
.quantize_colors
= 1;
6538 fn_jpeg_start_decompress (&cinfo
);
6539 width
= img
->width
= cinfo
.output_width
;
6540 height
= img
->height
= cinfo
.output_height
;
6542 /* Create X image and pixmap. */
6543 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
6544 longjmp (mgr
.setjmp_buffer
, 2);
6546 /* Allocate colors. When color quantization is used,
6547 cinfo.actual_number_of_colors has been set with the number of
6548 colors generated, and cinfo.colormap is a two-dimensional array
6549 of color indices in the range 0..cinfo.actual_number_of_colors.
6550 No more than 255 colors will be generated. */
6554 if (cinfo
.out_color_components
> 2)
6555 ir
= 0, ig
= 1, ib
= 2;
6556 else if (cinfo
.out_color_components
> 1)
6557 ir
= 0, ig
= 1, ib
= 0;
6559 ir
= 0, ig
= 0, ib
= 0;
6561 /* Use the color table mechanism because it handles colors that
6562 cannot be allocated nicely. Such colors will be replaced with
6563 a default color, and we don't have to care about which colors
6564 can be freed safely, and which can't. */
6565 init_color_table ();
6566 colors
= (unsigned long *) alloca (cinfo
.actual_number_of_colors
6569 for (i
= 0; i
< cinfo
.actual_number_of_colors
; ++i
)
6571 /* Multiply RGB values with 255 because X expects RGB values
6572 in the range 0..0xffff. */
6573 int r
= cinfo
.colormap
[ir
][i
] << 8;
6574 int g
= cinfo
.colormap
[ig
][i
] << 8;
6575 int b
= cinfo
.colormap
[ib
][i
] << 8;
6576 colors
[i
] = lookup_rgb_color (f
, r
, g
, b
);
6579 #ifdef COLOR_TABLE_SUPPORT
6580 /* Remember those colors actually allocated. */
6581 img
->colors
= colors_in_color_table (&img
->ncolors
);
6582 free_color_table ();
6583 #endif /* COLOR_TABLE_SUPPORT */
6587 row_stride
= width
* cinfo
.output_components
;
6588 buffer
= cinfo
.mem
->alloc_sarray ((j_common_ptr
) &cinfo
, JPOOL_IMAGE
,
6590 for (y
= 0; y
< height
; ++y
)
6592 fn_jpeg_read_scanlines (&cinfo
, buffer
, 1);
6593 for (x
= 0; x
< cinfo
.output_width
; ++x
)
6594 XPutPixel (ximg
, x
, y
, colors
[buffer
[0][x
]]);
6598 fn_jpeg_finish_decompress (&cinfo
);
6599 fn_jpeg_destroy_decompress (&cinfo
);
6601 fclose ((FILE *) fp
);
6603 /* Maybe fill in the background field while we have ximg handy. */
6604 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
6605 IMAGE_BACKGROUND (img
, f
, ximg
);
6607 /* Put the image into the pixmap. */
6608 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
6609 x_destroy_x_image (ximg
);
6614 #else /* HAVE_JPEG */
6623 return image_load_quartz2d (f
, img
, 0);
6625 return image_load_quicktime (f
, img
, kQTFileTypeJPEG
);
6630 #endif /* !HAVE_JPEG */
6634 /***********************************************************************
6636 ***********************************************************************/
6638 #if defined (HAVE_TIFF) || defined (MAC_OS)
6640 static int tiff_image_p
P_ ((Lisp_Object object
));
6641 static int tiff_load
P_ ((struct frame
*f
, struct image
*img
));
6643 /* The symbol `tiff' identifying images of this type. */
6647 /* Indices of image specification fields in tiff_format, below. */
6649 enum tiff_keyword_index
6658 TIFF_HEURISTIC_MASK
,
6664 /* Vector of image_keyword structures describing the format
6665 of valid user-defined image specifications. */
6667 static struct image_keyword tiff_format
[TIFF_LAST
] =
6669 {":type", IMAGE_SYMBOL_VALUE
, 1},
6670 {":data", IMAGE_STRING_VALUE
, 0},
6671 {":file", IMAGE_STRING_VALUE
, 0},
6672 {":ascent", IMAGE_ASCENT_VALUE
, 0},
6673 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
6674 {":relief", IMAGE_INTEGER_VALUE
, 0},
6675 {":conversions", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6676 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6677 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6678 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
6681 /* Structure describing the image type `tiff'. */
6683 static struct image_type tiff_type
=
6692 /* Return non-zero if OBJECT is a valid TIFF image specification. */
6695 tiff_image_p (object
)
6698 struct image_keyword fmt
[TIFF_LAST
];
6699 bcopy (tiff_format
, fmt
, sizeof fmt
);
6701 if (!parse_image_spec (object
, fmt
, TIFF_LAST
, Qtiff
))
6704 /* Must specify either the :data or :file keyword. */
6705 return fmt
[TIFF_FILE
].count
+ fmt
[TIFF_DATA
].count
== 1;
6708 #endif /* HAVE_TIFF || MAC_OS */
6716 /* TIFF library details. */
6717 DEF_IMGLIB_FN (TIFFSetErrorHandler
);
6718 DEF_IMGLIB_FN (TIFFSetWarningHandler
);
6719 DEF_IMGLIB_FN (TIFFOpen
);
6720 DEF_IMGLIB_FN (TIFFClientOpen
);
6721 DEF_IMGLIB_FN (TIFFGetField
);
6722 DEF_IMGLIB_FN (TIFFReadRGBAImage
);
6723 DEF_IMGLIB_FN (TIFFClose
);
6726 init_tiff_functions (Lisp_Object libraries
)
6730 if (!(library
= w32_delayed_load (libraries
, Qtiff
)))
6733 LOAD_IMGLIB_FN (library
, TIFFSetErrorHandler
);
6734 LOAD_IMGLIB_FN (library
, TIFFSetWarningHandler
);
6735 LOAD_IMGLIB_FN (library
, TIFFOpen
);
6736 LOAD_IMGLIB_FN (library
, TIFFClientOpen
);
6737 LOAD_IMGLIB_FN (library
, TIFFGetField
);
6738 LOAD_IMGLIB_FN (library
, TIFFReadRGBAImage
);
6739 LOAD_IMGLIB_FN (library
, TIFFClose
);
6745 #define fn_TIFFSetErrorHandler TIFFSetErrorHandler
6746 #define fn_TIFFSetWarningHandler TIFFSetWarningHandler
6747 #define fn_TIFFOpen TIFFOpen
6748 #define fn_TIFFClientOpen TIFFClientOpen
6749 #define fn_TIFFGetField TIFFGetField
6750 #define fn_TIFFReadRGBAImage TIFFReadRGBAImage
6751 #define fn_TIFFClose TIFFClose
6753 #endif /* HAVE_NTGUI */
6756 /* Reading from a memory buffer for TIFF images Based on the PNG
6757 memory source, but we have to provide a lot of extra functions.
6760 We really only need to implement read and seek, but I am not
6761 convinced that the TIFF library is smart enough not to destroy
6762 itself if we only hand it the function pointers we need to
6767 unsigned char *bytes
;
6774 tiff_read_from_memory (data
, buf
, size
)
6779 tiff_memory_source
*src
= (tiff_memory_source
*) data
;
6781 if (size
> src
->len
- src
->index
)
6783 bcopy (src
->bytes
+ src
->index
, buf
, size
);
6789 tiff_write_from_memory (data
, buf
, size
)
6798 tiff_seek_in_memory (data
, off
, whence
)
6803 tiff_memory_source
*src
= (tiff_memory_source
*) data
;
6808 case SEEK_SET
: /* Go from beginning of source. */
6812 case SEEK_END
: /* Go from end of source. */
6813 idx
= src
->len
+ off
;
6816 case SEEK_CUR
: /* Go from current position. */
6817 idx
= src
->index
+ off
;
6820 default: /* Invalid `whence'. */
6824 if (idx
> src
->len
|| idx
< 0)
6832 tiff_close_memory (data
)
6840 tiff_mmap_memory (data
, pbase
, psize
)
6845 /* It is already _IN_ memory. */
6850 tiff_unmap_memory (data
, base
, size
)
6855 /* We don't need to do this. */
6859 tiff_size_of_memory (data
)
6862 return ((tiff_memory_source
*) data
)->len
;
6867 tiff_error_handler (title
, format
, ap
)
6868 const char *title
, *format
;
6874 len
= sprintf (buf
, "TIFF error: %s ", title
);
6875 vsprintf (buf
+ len
, format
, ap
);
6876 add_to_log (buf
, Qnil
, Qnil
);
6881 tiff_warning_handler (title
, format
, ap
)
6882 const char *title
, *format
;
6888 len
= sprintf (buf
, "TIFF warning: %s ", title
);
6889 vsprintf (buf
+ len
, format
, ap
);
6890 add_to_log (buf
, Qnil
, Qnil
);
6894 /* Load TIFF image IMG for use on frame F. Value is non-zero if
6902 Lisp_Object file
, specified_file
;
6903 Lisp_Object specified_data
;
6905 int width
, height
, x
, y
;
6909 struct gcpro gcpro1
;
6910 tiff_memory_source memsrc
;
6912 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
6913 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
6917 fn_TIFFSetErrorHandler (tiff_error_handler
);
6918 fn_TIFFSetWarningHandler (tiff_warning_handler
);
6920 if (NILP (specified_data
))
6922 /* Read from a file */
6923 file
= x_find_image_file (specified_file
);
6924 if (!STRINGP (file
))
6926 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
6931 /* Try to open the image file. */
6932 tiff
= fn_TIFFOpen (SDATA (file
), "r");
6935 image_error ("Cannot open `%s'", file
, Qnil
);
6942 /* Memory source! */
6943 memsrc
.bytes
= SDATA (specified_data
);
6944 memsrc
.len
= SBYTES (specified_data
);
6947 tiff
= fn_TIFFClientOpen ("memory_source", "r", &memsrc
,
6948 (TIFFReadWriteProc
) tiff_read_from_memory
,
6949 (TIFFReadWriteProc
) tiff_write_from_memory
,
6950 tiff_seek_in_memory
,
6952 tiff_size_of_memory
,
6958 image_error ("Cannot open memory source for `%s'", img
->spec
, Qnil
);
6964 /* Get width and height of the image, and allocate a raster buffer
6965 of width x height 32-bit values. */
6966 fn_TIFFGetField (tiff
, TIFFTAG_IMAGEWIDTH
, &width
);
6967 fn_TIFFGetField (tiff
, TIFFTAG_IMAGELENGTH
, &height
);
6968 buf
= (uint32
*) xmalloc (width
* height
* sizeof *buf
);
6970 rc
= fn_TIFFReadRGBAImage (tiff
, width
, height
, buf
, 0);
6971 fn_TIFFClose (tiff
);
6974 image_error ("Error reading TIFF image `%s'", img
->spec
, Qnil
);
6980 /* Create the X image and pixmap. */
6981 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
6988 /* Initialize the color table. */
6989 init_color_table ();
6991 /* Process the pixel raster. Origin is in the lower-left corner. */
6992 for (y
= 0; y
< height
; ++y
)
6994 uint32
*row
= buf
+ y
* width
;
6996 for (x
= 0; x
< width
; ++x
)
6998 uint32 abgr
= row
[x
];
6999 int r
= TIFFGetR (abgr
) << 8;
7000 int g
= TIFFGetG (abgr
) << 8;
7001 int b
= TIFFGetB (abgr
) << 8;
7002 XPutPixel (ximg
, x
, height
- 1 - y
, lookup_rgb_color (f
, r
, g
, b
));
7006 #ifdef COLOR_TABLE_SUPPORT
7007 /* Remember the colors allocated for the image. Free the color table. */
7008 img
->colors
= colors_in_color_table (&img
->ncolors
);
7009 free_color_table ();
7010 #endif /* COLOR_TABLE_SUPPORT */
7013 img
->height
= height
;
7015 /* Maybe fill in the background field while we have ximg handy. */
7016 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
7017 IMAGE_BACKGROUND (img
, f
, ximg
);
7019 /* Put the image into the pixmap, then free the X image and its buffer. */
7020 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
7021 x_destroy_x_image (ximg
);
7028 #else /* HAVE_TIFF */
7036 return image_load_quicktime (f
, img
, kQTFileTypeTIFF
);
7040 #endif /* !HAVE_TIFF */
7044 /***********************************************************************
7046 ***********************************************************************/
7048 #if defined (HAVE_GIF) || defined (MAC_OS)
7050 static int gif_image_p
P_ ((Lisp_Object object
));
7051 static int gif_load
P_ ((struct frame
*f
, struct image
*img
));
7053 /* The symbol `gif' identifying images of this type. */
7057 /* Indices of image specification fields in gif_format, below. */
7059 enum gif_keyword_index
7075 /* Vector of image_keyword structures describing the format
7076 of valid user-defined image specifications. */
7078 static struct image_keyword gif_format
[GIF_LAST
] =
7080 {":type", IMAGE_SYMBOL_VALUE
, 1},
7081 {":data", IMAGE_STRING_VALUE
, 0},
7082 {":file", IMAGE_STRING_VALUE
, 0},
7083 {":ascent", IMAGE_ASCENT_VALUE
, 0},
7084 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
7085 {":relief", IMAGE_INTEGER_VALUE
, 0},
7086 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7087 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7088 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7089 {":image", IMAGE_NON_NEGATIVE_INTEGER_VALUE
, 0},
7090 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
7093 /* Structure describing the image type `gif'. */
7095 static struct image_type gif_type
=
7104 /* Return non-zero if OBJECT is a valid GIF image specification. */
7107 gif_image_p (object
)
7110 struct image_keyword fmt
[GIF_LAST
];
7111 bcopy (gif_format
, fmt
, sizeof fmt
);
7113 if (!parse_image_spec (object
, fmt
, GIF_LAST
, Qgif
))
7116 /* Must specify either the :data or :file keyword. */
7117 return fmt
[GIF_FILE
].count
+ fmt
[GIF_DATA
].count
== 1;
7120 #endif /* HAVE_GIF || MAC_OS */
7124 #if defined (HAVE_NTGUI) || defined (MAC_OS)
7125 /* avoid conflict with QuickdrawText.h */
7126 #define DrawText gif_DrawText
7127 #include <gif_lib.h>
7130 #else /* HAVE_NTGUI || MAC_OS */
7132 #include <gif_lib.h>
7134 #endif /* HAVE_NTGUI || MAC_OS */
7139 /* GIF library details. */
7140 DEF_IMGLIB_FN (DGifCloseFile
);
7141 DEF_IMGLIB_FN (DGifSlurp
);
7142 DEF_IMGLIB_FN (DGifOpen
);
7143 DEF_IMGLIB_FN (DGifOpenFileName
);
7146 init_gif_functions (Lisp_Object libraries
)
7150 if (!(library
= w32_delayed_load (libraries
, Qgif
)))
7153 LOAD_IMGLIB_FN (library
, DGifCloseFile
);
7154 LOAD_IMGLIB_FN (library
, DGifSlurp
);
7155 LOAD_IMGLIB_FN (library
, DGifOpen
);
7156 LOAD_IMGLIB_FN (library
, DGifOpenFileName
);
7162 #define fn_DGifCloseFile DGifCloseFile
7163 #define fn_DGifSlurp DGifSlurp
7164 #define fn_DGifOpen DGifOpen
7165 #define fn_DGifOpenFileName DGifOpenFileName
7167 #endif /* HAVE_NTGUI */
7169 /* Reading a GIF image from memory
7170 Based on the PNG memory stuff to a certain extent. */
7174 unsigned char *bytes
;
7180 /* Make the current memory source available to gif_read_from_memory.
7181 It's done this way because not all versions of libungif support
7182 a UserData field in the GifFileType structure. */
7183 static gif_memory_source
*current_gif_memory_src
;
7186 gif_read_from_memory (file
, buf
, len
)
7191 gif_memory_source
*src
= current_gif_memory_src
;
7193 if (len
> src
->len
- src
->index
)
7196 bcopy (src
->bytes
+ src
->index
, buf
, len
);
7202 /* Load GIF image IMG for use on frame F. Value is non-zero if
7210 Lisp_Object file
, specified_file
;
7211 Lisp_Object specified_data
;
7212 int rc
, width
, height
, x
, y
, i
;
7214 ColorMapObject
*gif_color_map
;
7215 unsigned long pixel_colors
[256];
7217 struct gcpro gcpro1
;
7219 int ino
, image_left
, image_top
, image_width
, image_height
;
7220 gif_memory_source memsrc
;
7221 unsigned char *raster
;
7223 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
7224 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
7228 if (NILP (specified_data
))
7230 file
= x_find_image_file (specified_file
);
7231 if (!STRINGP (file
))
7233 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
7238 /* Open the GIF file. */
7239 gif
= fn_DGifOpenFileName (SDATA (file
));
7242 image_error ("Cannot open `%s'", file
, Qnil
);
7249 /* Read from memory! */
7250 current_gif_memory_src
= &memsrc
;
7251 memsrc
.bytes
= SDATA (specified_data
);
7252 memsrc
.len
= SBYTES (specified_data
);
7255 gif
= fn_DGifOpen(&memsrc
, gif_read_from_memory
);
7258 image_error ("Cannot open memory source `%s'", img
->spec
, Qnil
);
7264 /* Read entire contents. */
7265 rc
= fn_DGifSlurp (gif
);
7266 if (rc
== GIF_ERROR
)
7268 image_error ("Error reading `%s'", img
->spec
, Qnil
);
7269 fn_DGifCloseFile (gif
);
7274 image
= image_spec_value (img
->spec
, QCindex
, NULL
);
7275 ino
= INTEGERP (image
) ? XFASTINT (image
) : 0;
7276 if (ino
>= gif
->ImageCount
)
7278 image_error ("Invalid image number `%s' in image `%s'",
7280 fn_DGifCloseFile (gif
);
7285 width
= img
->width
= max (gif
->SWidth
, gif
->Image
.Left
+ gif
->Image
.Width
);
7286 height
= img
->height
= max (gif
->SHeight
, gif
->Image
.Top
+ gif
->Image
.Height
);
7288 /* Create the X image and pixmap. */
7289 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
7291 fn_DGifCloseFile (gif
);
7296 /* Allocate colors. */
7297 gif_color_map
= gif
->SavedImages
[ino
].ImageDesc
.ColorMap
;
7299 gif_color_map
= gif
->SColorMap
;
7300 init_color_table ();
7301 bzero (pixel_colors
, sizeof pixel_colors
);
7303 for (i
= 0; i
< gif_color_map
->ColorCount
; ++i
)
7305 int r
= gif_color_map
->Colors
[i
].Red
<< 8;
7306 int g
= gif_color_map
->Colors
[i
].Green
<< 8;
7307 int b
= gif_color_map
->Colors
[i
].Blue
<< 8;
7308 pixel_colors
[i
] = lookup_rgb_color (f
, r
, g
, b
);
7311 #ifdef COLOR_TABLE_SUPPORT
7312 img
->colors
= colors_in_color_table (&img
->ncolors
);
7313 free_color_table ();
7314 #endif /* COLOR_TABLE_SUPPORT */
7316 /* Clear the part of the screen image that are not covered by
7317 the image from the GIF file. Full animated GIF support
7318 requires more than can be done here (see the gif89 spec,
7319 disposal methods). Let's simply assume that the part
7320 not covered by a sub-image is in the frame's background color. */
7321 image_top
= gif
->SavedImages
[ino
].ImageDesc
.Top
;
7322 image_left
= gif
->SavedImages
[ino
].ImageDesc
.Left
;
7323 image_width
= gif
->SavedImages
[ino
].ImageDesc
.Width
;
7324 image_height
= gif
->SavedImages
[ino
].ImageDesc
.Height
;
7326 for (y
= 0; y
< image_top
; ++y
)
7327 for (x
= 0; x
< width
; ++x
)
7328 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7330 for (y
= image_top
+ image_height
; y
< height
; ++y
)
7331 for (x
= 0; x
< width
; ++x
)
7332 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7334 for (y
= image_top
; y
< image_top
+ image_height
; ++y
)
7336 for (x
= 0; x
< image_left
; ++x
)
7337 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7338 for (x
= image_left
+ image_width
; x
< width
; ++x
)
7339 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7342 /* Read the GIF image into the X image. We use a local variable
7343 `raster' here because RasterBits below is a char *, and invites
7344 problems with bytes >= 0x80. */
7345 raster
= (unsigned char *) gif
->SavedImages
[ino
].RasterBits
;
7347 if (gif
->SavedImages
[ino
].ImageDesc
.Interlace
)
7349 static int interlace_start
[] = {0, 4, 2, 1};
7350 static int interlace_increment
[] = {8, 8, 4, 2};
7352 int row
= interlace_start
[0];
7356 for (y
= 0; y
< image_height
; y
++)
7358 if (row
>= image_height
)
7360 row
= interlace_start
[++pass
];
7361 while (row
>= image_height
)
7362 row
= interlace_start
[++pass
];
7365 for (x
= 0; x
< image_width
; x
++)
7367 int i
= raster
[(y
* image_width
) + x
];
7368 XPutPixel (ximg
, x
+ image_left
, row
+ image_top
,
7372 row
+= interlace_increment
[pass
];
7377 for (y
= 0; y
< image_height
; ++y
)
7378 for (x
= 0; x
< image_width
; ++x
)
7380 int i
= raster
[y
* image_width
+ x
];
7381 XPutPixel (ximg
, x
+ image_left
, y
+ image_top
, pixel_colors
[i
]);
7385 fn_DGifCloseFile (gif
);
7387 /* Maybe fill in the background field while we have ximg handy. */
7388 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
7389 IMAGE_BACKGROUND (img
, f
, ximg
);
7391 /* Put the image into the pixmap, then free the X image and its buffer. */
7392 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
7393 x_destroy_x_image (ximg
);
7407 Lisp_Object specified_file
, file
;
7408 Lisp_Object specified_data
;
7410 Boolean graphic_p
, movie_p
, prefer_graphic_p
;
7418 Lisp_Object specified_bg
;
7424 struct gcpro gcpro1
;
7429 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
7430 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
7432 if (NILP (specified_data
))
7434 /* Read from a file */
7438 err
= find_image_fsspec (specified_file
, &file
, &fss
);
7442 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
7447 err
= CanQuickTimeOpenFile (&fss
, kQTFileTypeGIF
, 0,
7448 &graphic_p
, &movie_p
, &prefer_graphic_p
, 0);
7452 if (!graphic_p
&& !movie_p
)
7454 if (prefer_graphic_p
)
7455 return image_load_qt_1 (f
, img
, kQTFileTypeGIF
, &fss
, NULL
);
7456 err
= OpenMovieFile (&fss
, &refnum
, fsRdPerm
);
7459 err
= NewMovieFromFile (&movie
, refnum
, NULL
, NULL
, 0, NULL
);
7460 CloseMovieFile (refnum
);
7463 image_error ("Error reading `%s'", file
, Qnil
);
7469 /* Memory source! */
7471 long file_type_atom
[3];
7473 err
= PtrToHand (SDATA (specified_data
), &dh
, SBYTES (specified_data
));
7476 image_error ("Cannot allocate data handle for `%s'",
7481 file_type_atom
[0] = EndianU32_NtoB (sizeof (long) * 3);
7482 file_type_atom
[1] = EndianU32_NtoB (kDataRefExtensionMacOSFileType
);
7483 file_type_atom
[2] = EndianU32_NtoB (kQTFileTypeGIF
);
7484 err
= PtrToHand (&dh
, &dref
, sizeof (Handle
));
7487 err
= PtrAndHand ("\p", dref
, 1);
7489 err
= PtrAndHand (file_type_atom
, dref
, sizeof (long) * 3);
7492 image_error ("Cannot allocate handle data ref for `%s'", img
->spec
, Qnil
);
7495 err
= CanQuickTimeOpenDataRef (dref
, HandleDataHandlerSubType
, &graphic_p
,
7496 &movie_p
, &prefer_graphic_p
, 0);
7500 if (!graphic_p
&& !movie_p
)
7502 if (prefer_graphic_p
)
7506 DisposeHandle (dref
);
7507 success_p
= image_load_qt_1 (f
, img
, kQTFileTypeGIF
, NULL
, dh
);
7511 err
= NewMovieFromDataRef (&movie
, 0, NULL
, dref
,
7512 HandleDataHandlerSubType
);
7513 DisposeHandle (dref
);
7518 image
= image_spec_value (img
->spec
, QCindex
, NULL
);
7519 ino
= INTEGERP (image
) ? XFASTINT (image
) : 0;
7520 track
= GetMovieIndTrack (movie
, 1);
7521 media
= GetTrackMedia (track
);
7522 nsamples
= GetMediaSampleCount (media
);
7523 if (ino
>= nsamples
)
7525 image_error ("Invalid image number `%s' in image `%s'",
7530 specified_bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
7531 if (!STRINGP (specified_bg
) ||
7532 !mac_defined_color (f
, SDATA (specified_bg
), &color
, 0))
7534 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
7535 color
.red
= RED16_FROM_ULONG (color
.pixel
);
7536 color
.green
= GREEN16_FROM_ULONG (color
.pixel
);
7537 color
.blue
= BLUE16_FROM_ULONG (color
.pixel
);
7539 GetMovieBox (movie
, &rect
);
7540 width
= img
->width
= rect
.right
- rect
.left
;
7541 height
= img
->height
= rect
.bottom
- rect
.top
;
7542 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
7545 GetGWorld (&old_port
, &old_gdh
);
7546 SetGWorld (ximg
, NULL
);
7547 bg_color
.red
= color
.red
;
7548 bg_color
.green
= color
.green
;
7549 bg_color
.blue
= color
.blue
;
7550 RGBBackColor (&bg_color
);
7551 SetGWorld (old_port
, old_gdh
);
7552 SetMovieActive (movie
, 1);
7553 SetMovieGWorld (movie
, ximg
, NULL
);
7554 SampleNumToMediaTime (media
, ino
+ 1, &time
, NULL
);
7555 SetMovieTimeValue (movie
, time
);
7556 MoviesTask (movie
, 0L);
7557 DisposeTrackMedia (media
);
7558 DisposeMovieTrack (track
);
7559 DisposeMovie (movie
);
7562 /* Maybe fill in the background field while we have ximg handy. */
7563 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
7564 IMAGE_BACKGROUND (img
, f
, ximg
);
7566 /* Put the image into the pixmap. */
7567 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
7568 x_destroy_x_image (ximg
);
7572 image_error ("Cannot open `%s'", file
, Qnil
);
7575 DisposeTrackMedia (media
);
7577 DisposeMovieTrack (track
);
7579 DisposeMovie (movie
);
7586 #endif /* HAVE_GIF */
7590 /***********************************************************************
7592 ***********************************************************************/
7594 #ifdef HAVE_X_WINDOWS
7595 #define HAVE_GHOSTSCRIPT 1
7596 #endif /* HAVE_X_WINDOWS */
7598 /* The symbol `postscript' identifying images of this type. */
7600 Lisp_Object Qpostscript
;
7602 #ifdef HAVE_GHOSTSCRIPT
7604 static int gs_image_p
P_ ((Lisp_Object object
));
7605 static int gs_load
P_ ((struct frame
*f
, struct image
*img
));
7606 static void gs_clear_image
P_ ((struct frame
*f
, struct image
*img
));
7608 /* Keyword symbols. */
7610 Lisp_Object QCloader
, QCbounding_box
, QCpt_width
, QCpt_height
;
7612 /* Indices of image specification fields in gs_format, below. */
7614 enum gs_keyword_index
7632 /* Vector of image_keyword structures describing the format
7633 of valid user-defined image specifications. */
7635 static struct image_keyword gs_format
[GS_LAST
] =
7637 {":type", IMAGE_SYMBOL_VALUE
, 1},
7638 {":pt-width", IMAGE_POSITIVE_INTEGER_VALUE
, 1},
7639 {":pt-height", IMAGE_POSITIVE_INTEGER_VALUE
, 1},
7640 {":file", IMAGE_STRING_VALUE
, 1},
7641 {":loader", IMAGE_FUNCTION_VALUE
, 0},
7642 {":bounding-box", IMAGE_DONT_CHECK_VALUE_TYPE
, 1},
7643 {":ascent", IMAGE_ASCENT_VALUE
, 0},
7644 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
7645 {":relief", IMAGE_INTEGER_VALUE
, 0},
7646 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7647 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7648 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7649 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
7652 /* Structure describing the image type `ghostscript'. */
7654 static struct image_type gs_type
=
7664 /* Free X resources of Ghostscript image IMG which is used on frame F. */
7667 gs_clear_image (f
, img
)
7671 /* IMG->data.ptr_val may contain a recorded colormap. */
7672 xfree (img
->data
.ptr_val
);
7673 x_clear_image (f
, img
);
7677 /* Return non-zero if OBJECT is a valid Ghostscript image
7684 struct image_keyword fmt
[GS_LAST
];
7688 bcopy (gs_format
, fmt
, sizeof fmt
);
7690 if (!parse_image_spec (object
, fmt
, GS_LAST
, Qpostscript
))
7693 /* Bounding box must be a list or vector containing 4 integers. */
7694 tem
= fmt
[GS_BOUNDING_BOX
].value
;
7697 for (i
= 0; i
< 4; ++i
, tem
= XCDR (tem
))
7698 if (!CONSP (tem
) || !INTEGERP (XCAR (tem
)))
7703 else if (VECTORP (tem
))
7705 if (XVECTOR (tem
)->size
!= 4)
7707 for (i
= 0; i
< 4; ++i
)
7708 if (!INTEGERP (XVECTOR (tem
)->contents
[i
]))
7718 /* Load Ghostscript image IMG for use on frame F. Value is non-zero
7727 Lisp_Object window_and_pixmap_id
= Qnil
, loader
, pt_height
, pt_width
;
7728 struct gcpro gcpro1
, gcpro2
;
7730 double in_width
, in_height
;
7731 Lisp_Object pixel_colors
= Qnil
;
7733 /* Compute pixel size of pixmap needed from the given size in the
7734 image specification. Sizes in the specification are in pt. 1 pt
7735 = 1/72 in, xdpi and ydpi are stored in the frame's X display
7737 pt_width
= image_spec_value (img
->spec
, QCpt_width
, NULL
);
7738 in_width
= XFASTINT (pt_width
) / 72.0;
7739 img
->width
= in_width
* FRAME_X_DISPLAY_INFO (f
)->resx
;
7740 pt_height
= image_spec_value (img
->spec
, QCpt_height
, NULL
);
7741 in_height
= XFASTINT (pt_height
) / 72.0;
7742 img
->height
= in_height
* FRAME_X_DISPLAY_INFO (f
)->resy
;
7744 /* Create the pixmap. */
7745 xassert (img
->pixmap
== NO_PIXMAP
);
7747 /* Only W32 version did BLOCK_INPUT here. ++kfs */
7749 img
->pixmap
= XCreatePixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
7750 img
->width
, img
->height
,
7751 DefaultDepthOfScreen (FRAME_X_SCREEN (f
)));
7756 image_error ("Unable to create pixmap for `%s'", img
->spec
, Qnil
);
7760 /* Call the loader to fill the pixmap. It returns a process object
7761 if successful. We do not record_unwind_protect here because
7762 other places in redisplay like calling window scroll functions
7763 don't either. Let the Lisp loader use `unwind-protect' instead. */
7764 GCPRO2 (window_and_pixmap_id
, pixel_colors
);
7766 sprintf (buffer
, "%lu %lu",
7767 (unsigned long) FRAME_X_WINDOW (f
),
7768 (unsigned long) img
->pixmap
);
7769 window_and_pixmap_id
= build_string (buffer
);
7771 sprintf (buffer
, "%lu %lu",
7772 FRAME_FOREGROUND_PIXEL (f
),
7773 FRAME_BACKGROUND_PIXEL (f
));
7774 pixel_colors
= build_string (buffer
);
7776 XSETFRAME (frame
, f
);
7777 loader
= image_spec_value (img
->spec
, QCloader
, NULL
);
7779 loader
= intern ("gs-load-image");
7781 img
->data
.lisp_val
= call6 (loader
, frame
, img
->spec
,
7782 make_number (img
->width
),
7783 make_number (img
->height
),
7784 window_and_pixmap_id
,
7787 return PROCESSP (img
->data
.lisp_val
);
7791 /* Kill the Ghostscript process that was started to fill PIXMAP on
7792 frame F. Called from XTread_socket when receiving an event
7793 telling Emacs that Ghostscript has finished drawing. */
7796 x_kill_gs_process (pixmap
, f
)
7800 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
7804 /* Find the image containing PIXMAP. */
7805 for (i
= 0; i
< c
->used
; ++i
)
7806 if (c
->images
[i
]->pixmap
== pixmap
)
7809 /* Should someone in between have cleared the image cache, for
7810 instance, give up. */
7814 /* Kill the GS process. We should have found PIXMAP in the image
7815 cache and its image should contain a process object. */
7817 xassert (PROCESSP (img
->data
.lisp_val
));
7818 Fkill_process (img
->data
.lisp_val
, Qnil
);
7819 img
->data
.lisp_val
= Qnil
;
7821 #if defined (HAVE_X_WINDOWS)
7823 /* On displays with a mutable colormap, figure out the colors
7824 allocated for the image by looking at the pixels of an XImage for
7826 class = FRAME_X_VISUAL (f
)->class;
7827 if (class != StaticColor
&& class != StaticGray
&& class != TrueColor
)
7833 /* Try to get an XImage for img->pixmep. */
7834 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
7835 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
7840 /* Initialize the color table. */
7841 init_color_table ();
7843 /* For each pixel of the image, look its color up in the
7844 color table. After having done so, the color table will
7845 contain an entry for each color used by the image. */
7846 for (y
= 0; y
< img
->height
; ++y
)
7847 for (x
= 0; x
< img
->width
; ++x
)
7849 unsigned long pixel
= XGetPixel (ximg
, x
, y
);
7850 lookup_pixel_color (f
, pixel
);
7853 /* Record colors in the image. Free color table and XImage. */
7854 #ifdef COLOR_TABLE_SUPPORT
7855 img
->colors
= colors_in_color_table (&img
->ncolors
);
7856 free_color_table ();
7858 XDestroyImage (ximg
);
7860 #if 0 /* This doesn't seem to be the case. If we free the colors
7861 here, we get a BadAccess later in x_clear_image when
7862 freeing the colors. */
7863 /* We have allocated colors once, but Ghostscript has also
7864 allocated colors on behalf of us. So, to get the
7865 reference counts right, free them once. */
7867 x_free_colors (f
, img
->colors
, img
->ncolors
);
7871 image_error ("Cannot get X image of `%s'; colors will not be freed",
7876 #endif /* HAVE_X_WINDOWS */
7878 /* Now that we have the pixmap, compute mask and transform the
7879 image if requested. */
7881 postprocess_image (f
, img
);
7885 #endif /* HAVE_GHOSTSCRIPT */
7888 /***********************************************************************
7890 ***********************************************************************/
7894 DEFUN ("imagep", Fimagep
, Simagep
, 1, 1, 0,
7895 doc
: /* Value is non-nil if SPEC is a valid image specification. */)
7899 return valid_image_p (spec
) ? Qt
: Qnil
;
7903 DEFUN ("lookup-image", Flookup_image
, Slookup_image
, 1, 1, 0, "")
7909 if (valid_image_p (spec
))
7910 id
= lookup_image (SELECTED_FRAME (), spec
);
7913 return make_number (id
);
7916 #endif /* GLYPH_DEBUG != 0 */
7919 /***********************************************************************
7921 ***********************************************************************/
7924 /* Image types that rely on external libraries are loaded dynamically
7925 if the library is available. */
7926 #define CHECK_LIB_AVAILABLE(image_type, init_lib_fn, libraries) \
7927 define_image_type (image_type, init_lib_fn (libraries))
7929 #define CHECK_LIB_AVAILABLE(image_type, init_lib_fn, libraries) \
7930 define_image_type (image_type, 1)
7931 #endif /* HAVE_NTGUI */
7933 DEFUN ("init-image-library", Finit_image_library
, Sinit_image_library
, 2, 2, 0,
7934 doc
: /* Initialize image library implementing image type TYPE.
7935 Return non-nil if TYPE is a supported image type.
7937 Image types pbm and xbm are prebuilt; other types are loaded here.
7938 Libraries to load are specified in alist LIBRARIES (usually, the value
7939 of `image-library-alist', which see). */)
7941 Lisp_Object type
, libraries
;
7945 /* Don't try to reload the library. */
7946 tested
= Fassq (type
, Vimage_type_cache
);
7948 return XCDR (tested
);
7950 #if defined (HAVE_XPM) || defined (MAC_OS)
7951 if (EQ (type
, Qxpm
))
7952 return CHECK_LIB_AVAILABLE (&xpm_type
, init_xpm_functions
, libraries
);
7955 #if defined (HAVE_JPEG) || defined (MAC_OS)
7956 if (EQ (type
, Qjpeg
))
7957 return CHECK_LIB_AVAILABLE (&jpeg_type
, init_jpeg_functions
, libraries
);
7960 #if defined (HAVE_TIFF) || defined (MAC_OS)
7961 if (EQ (type
, Qtiff
))
7962 return CHECK_LIB_AVAILABLE (&tiff_type
, init_tiff_functions
, libraries
);
7965 #if defined (HAVE_GIF) || defined (MAC_OS)
7966 if (EQ (type
, Qgif
))
7967 return CHECK_LIB_AVAILABLE (&gif_type
, init_gif_functions
, libraries
);
7970 #if defined (HAVE_PNG) || defined (MAC_OS)
7971 if (EQ (type
, Qpng
))
7972 return CHECK_LIB_AVAILABLE (&png_type
, init_png_functions
, libraries
);
7975 #ifdef HAVE_GHOSTSCRIPT
7976 if (EQ (type
, Qpostscript
))
7977 return CHECK_LIB_AVAILABLE (&gs_type
, init_gs_functions
, libraries
);
7980 /* If the type is not recognized, avoid testing it ever again. */
7981 CACHE_IMAGE_TYPE (type
, Qnil
);
7988 /* Must be defined now becase we're going to update it below, while
7989 defining the supported image types. */
7990 DEFVAR_LISP ("image-types", &Vimage_types
,
7991 doc
: /* List of potentially supported image types.
7992 Each element of the list is a symbol for a image type, like 'jpeg or 'png.
7993 To check whether it is really supported, use `image-type-available-p'. */);
7994 Vimage_types
= Qnil
;
7996 Vimage_type_cache
= Qnil
;
7997 staticpro (&Vimage_type_cache
);
7999 QCascent
= intern (":ascent");
8000 staticpro (&QCascent
);
8001 QCmargin
= intern (":margin");
8002 staticpro (&QCmargin
);
8003 QCrelief
= intern (":relief");
8004 staticpro (&QCrelief
);
8005 QCconversion
= intern (":conversion");
8006 staticpro (&QCconversion
);
8007 QCcolor_symbols
= intern (":color-symbols");
8008 staticpro (&QCcolor_symbols
);
8009 QCheuristic_mask
= intern (":heuristic-mask");
8010 staticpro (&QCheuristic_mask
);
8011 QCindex
= intern (":index");
8012 staticpro (&QCindex
);
8013 QCmatrix
= intern (":matrix");
8014 staticpro (&QCmatrix
);
8015 QCcolor_adjustment
= intern (":color-adjustment");
8016 staticpro (&QCcolor_adjustment
);
8017 QCmask
= intern (":mask");
8018 staticpro (&QCmask
);
8020 Qlaplace
= intern ("laplace");
8021 staticpro (&Qlaplace
);
8022 Qemboss
= intern ("emboss");
8023 staticpro (&Qemboss
);
8024 Qedge_detection
= intern ("edge-detection");
8025 staticpro (&Qedge_detection
);
8026 Qheuristic
= intern ("heuristic");
8027 staticpro (&Qheuristic
);
8029 Qpostscript
= intern ("postscript");
8030 staticpro (&Qpostscript
);
8031 #ifdef HAVE_GHOSTSCRIPT
8032 ADD_IMAGE_TYPE(Qpostscript
);
8033 QCloader
= intern (":loader");
8034 staticpro (&QCloader
);
8035 QCbounding_box
= intern (":bounding-box");
8036 staticpro (&QCbounding_box
);
8037 QCpt_width
= intern (":pt-width");
8038 staticpro (&QCpt_width
);
8039 QCpt_height
= intern (":pt-height");
8040 staticpro (&QCpt_height
);
8041 #endif /* HAVE_GHOSTSCRIPT */
8043 Qpbm
= intern ("pbm");
8045 ADD_IMAGE_TYPE(Qpbm
);
8047 Qxbm
= intern ("xbm");
8049 ADD_IMAGE_TYPE(Qxbm
);
8051 #if defined (HAVE_XPM) || defined (MAC_OS)
8052 Qxpm
= intern ("xpm");
8054 ADD_IMAGE_TYPE(Qxpm
);
8057 #if defined (HAVE_JPEG) || defined (MAC_OS)
8058 Qjpeg
= intern ("jpeg");
8060 ADD_IMAGE_TYPE(Qjpeg
);
8063 #if defined (HAVE_TIFF) || defined (MAC_OS)
8064 Qtiff
= intern ("tiff");
8066 ADD_IMAGE_TYPE(Qtiff
);
8069 #if defined (HAVE_GIF) || defined (MAC_OS)
8070 Qgif
= intern ("gif");
8072 ADD_IMAGE_TYPE(Qgif
);
8075 #if defined (HAVE_PNG) || defined (MAC_OS)
8076 Qpng
= intern ("png");
8078 ADD_IMAGE_TYPE(Qpng
);
8081 defsubr (&Sinit_image_library
);
8082 defsubr (&Sclear_image_cache
);
8083 defsubr (&Simage_size
);
8084 defsubr (&Simage_mask_p
);
8088 defsubr (&Slookup_image
);
8091 DEFVAR_BOOL ("cross-disabled-images", &cross_disabled_images
,
8092 doc
: /* Non-nil means always draw a cross over disabled images.
8093 Disabled images are those having an `:conversion disabled' property.
8094 A cross is always drawn on black & white displays. */);
8095 cross_disabled_images
= 0;
8097 DEFVAR_LISP ("x-bitmap-file-path", &Vx_bitmap_file_path
,
8098 doc
: /* List of directories to search for window system bitmap files. */);
8099 Vx_bitmap_file_path
= decode_env_path ((char *) 0, PATH_BITMAPS
);
8101 DEFVAR_LISP ("image-cache-eviction-delay", &Vimage_cache_eviction_delay
,
8102 doc
: /* Time after which cached images are removed from the cache.
8103 When an image has not been displayed this many seconds, remove it
8104 from the image cache. Value must be an integer or nil with nil
8105 meaning don't clear the cache. */);
8106 Vimage_cache_eviction_delay
= make_number (30 * 60);
8114 define_image_type (&xbm_type
, 1);
8115 define_image_type (&pbm_type
, 1);
8118 /* Animated gifs use QuickTime Movie Toolbox. So initialize it here. */
8121 init_image_func_pointer ();
8126 /* arch-tag: 123c2a5e-14a8-4c53-ab95-af47d7db49b9
8127 (do not change this comment) */