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 /* An alist of image types and libraries that implement the type. */
621 Lisp_Object Vimage_library_alist
;
623 /* Cache for delayed-loading image types. */
625 static Lisp_Object Vimage_type_cache
;
627 /* The symbol `xbm' which is used as the type symbol for XBM images. */
633 extern Lisp_Object QCwidth
, QCheight
, QCforeground
, QCbackground
, QCfile
;
634 extern Lisp_Object QCdata
, QCtype
;
635 extern Lisp_Object Qcenter
;
636 Lisp_Object QCascent
, QCmargin
, QCrelief
;
637 Lisp_Object QCconversion
, QCcolor_symbols
, QCheuristic_mask
;
638 Lisp_Object QCindex
, QCmatrix
, QCcolor_adjustment
, QCmask
;
642 Lisp_Object Qlaplace
, Qemboss
, Qedge_detection
, Qheuristic
;
644 /* Time in seconds after which images should be removed from the cache
647 Lisp_Object Vimage_cache_eviction_delay
;
649 /* Function prototypes. */
651 static Lisp_Object define_image_type
P_ ((struct image_type
*type
, int loaded
));
652 static struct image_type
*lookup_image_type
P_ ((Lisp_Object symbol
));
653 static void image_error
P_ ((char *format
, Lisp_Object
, Lisp_Object
));
654 static void x_laplace
P_ ((struct frame
*, struct image
*));
655 static void x_emboss
P_ ((struct frame
*, struct image
*));
656 static int x_build_heuristic_mask
P_ ((struct frame
*, struct image
*,
659 #define CACHE_IMAGE_TYPE(type, status) \
660 do { Vimage_type_cache = Fcons (Fcons (type, status), Vimage_type_cache); } while (0)
662 #define ADD_IMAGE_TYPE(type) \
663 do { Vimage_types = Fcons (type, Vimage_types); } while (0)
665 /* Define a new image type from TYPE. This adds a copy of TYPE to
666 image_types and caches the loading status of TYPE. */
669 define_image_type (type
, loaded
)
670 struct image_type
*type
;
679 /* Make a copy of TYPE to avoid a bus error in a dumped Emacs.
680 The initialized data segment is read-only. */
681 struct image_type
*p
= (struct image_type
*) xmalloc (sizeof *p
);
682 bcopy (type
, p
, sizeof *p
);
683 p
->next
= image_types
;
688 CACHE_IMAGE_TYPE (*type
->type
, success
);
693 /* Look up image type SYMBOL, and return a pointer to its image_type
694 structure. Value is null if SYMBOL is not a known image type. */
696 static INLINE
struct image_type
*
697 lookup_image_type (symbol
)
700 struct image_type
*type
;
702 /* We must initialize the image-type if it hasn't been already. */
703 if (NILP (Finit_image_library (symbol
, Vimage_library_alist
)))
704 return 0; /* unimplemented */
706 for (type
= image_types
; type
; type
= type
->next
)
707 if (EQ (symbol
, *type
->type
))
714 /* Value is non-zero if OBJECT is a valid Lisp image specification. A
715 valid image specification is a list whose car is the symbol
716 `image', and whose rest is a property list. The property list must
717 contain a value for key `:type'. That value must be the name of a
718 supported image type. The rest of the property list depends on the
722 valid_image_p (object
)
731 for (tem
= XCDR (object
); CONSP (tem
); tem
= XCDR (tem
))
732 if (EQ (XCAR (tem
), QCtype
))
735 if (CONSP (tem
) && SYMBOLP (XCAR (tem
)))
737 struct image_type
*type
;
738 type
= lookup_image_type (XCAR (tem
));
740 valid_p
= type
->valid_p (object
);
751 /* Log error message with format string FORMAT and argument ARG.
752 Signaling an error, e.g. when an image cannot be loaded, is not a
753 good idea because this would interrupt redisplay, and the error
754 message display would lead to another redisplay. This function
755 therefore simply displays a message. */
758 image_error (format
, arg1
, arg2
)
760 Lisp_Object arg1
, arg2
;
762 add_to_log (format
, arg1
, arg2
);
767 /***********************************************************************
769 ***********************************************************************/
771 enum image_value_type
773 IMAGE_DONT_CHECK_VALUE_TYPE
,
775 IMAGE_STRING_OR_NIL_VALUE
,
777 IMAGE_POSITIVE_INTEGER_VALUE
,
778 IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
,
779 IMAGE_NON_NEGATIVE_INTEGER_VALUE
,
782 IMAGE_FUNCTION_VALUE
,
787 /* Structure used when parsing image specifications. */
791 /* Name of keyword. */
794 /* The type of value allowed. */
795 enum image_value_type type
;
797 /* Non-zero means key must be present. */
800 /* Used to recognize duplicate keywords in a property list. */
803 /* The value that was found. */
808 static int parse_image_spec
P_ ((Lisp_Object
, struct image_keyword
*,
810 static Lisp_Object image_spec_value
P_ ((Lisp_Object
, Lisp_Object
, int *));
813 /* Parse image spec SPEC according to KEYWORDS. A valid image spec
814 has the format (image KEYWORD VALUE ...). One of the keyword/
815 value pairs must be `:type TYPE'. KEYWORDS is a vector of
816 image_keywords structures of size NKEYWORDS describing other
817 allowed keyword/value pairs. Value is non-zero if SPEC is valid. */
820 parse_image_spec (spec
, keywords
, nkeywords
, type
)
822 struct image_keyword
*keywords
;
833 while (CONSP (plist
))
835 Lisp_Object key
, value
;
837 /* First element of a pair must be a symbol. */
839 plist
= XCDR (plist
);
843 /* There must follow a value. */
846 value
= XCAR (plist
);
847 plist
= XCDR (plist
);
849 /* Find key in KEYWORDS. Error if not found. */
850 for (i
= 0; i
< nkeywords
; ++i
)
851 if (strcmp (keywords
[i
].name
, SDATA (SYMBOL_NAME (key
))) == 0)
857 /* Record that we recognized the keyword. If a keywords
858 was found more than once, it's an error. */
859 keywords
[i
].value
= value
;
862 if (keywords
[i
].count
> 1)
865 /* Check type of value against allowed type. */
866 switch (keywords
[i
].type
)
868 case IMAGE_STRING_VALUE
:
869 if (!STRINGP (value
))
873 case IMAGE_STRING_OR_NIL_VALUE
:
874 if (!STRINGP (value
) && !NILP (value
))
878 case IMAGE_SYMBOL_VALUE
:
879 if (!SYMBOLP (value
))
883 case IMAGE_POSITIVE_INTEGER_VALUE
:
884 if (!INTEGERP (value
) || XINT (value
) <= 0)
888 case IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
:
889 if (INTEGERP (value
) && XINT (value
) >= 0)
892 && INTEGERP (XCAR (value
)) && INTEGERP (XCDR (value
))
893 && XINT (XCAR (value
)) >= 0 && XINT (XCDR (value
)) >= 0)
897 case IMAGE_ASCENT_VALUE
:
898 if (SYMBOLP (value
) && EQ (value
, Qcenter
))
900 else if (INTEGERP (value
)
902 && XINT (value
) <= 100)
906 case IMAGE_NON_NEGATIVE_INTEGER_VALUE
:
907 if (!INTEGERP (value
) || XINT (value
) < 0)
911 case IMAGE_DONT_CHECK_VALUE_TYPE
:
914 case IMAGE_FUNCTION_VALUE
:
915 value
= indirect_function (value
);
918 || (CONSP (value
) && EQ (XCAR (value
), Qlambda
)))
922 case IMAGE_NUMBER_VALUE
:
923 if (!INTEGERP (value
) && !FLOATP (value
))
927 case IMAGE_INTEGER_VALUE
:
928 if (!INTEGERP (value
))
932 case IMAGE_BOOL_VALUE
:
933 if (!NILP (value
) && !EQ (value
, Qt
))
942 if (EQ (key
, QCtype
) && !EQ (type
, value
))
946 /* Check that all mandatory fields are present. */
947 for (i
= 0; i
< nkeywords
; ++i
)
948 if (keywords
[i
].mandatory_p
&& keywords
[i
].count
== 0)
955 /* Return the value of KEY in image specification SPEC. Value is nil
956 if KEY is not present in SPEC. if FOUND is not null, set *FOUND
957 to 1 if KEY was found in SPEC, set it to 0 otherwise. */
960 image_spec_value (spec
, key
, found
)
961 Lisp_Object spec
, key
;
966 xassert (valid_image_p (spec
));
968 for (tail
= XCDR (spec
);
969 CONSP (tail
) && CONSP (XCDR (tail
));
970 tail
= XCDR (XCDR (tail
)))
972 if (EQ (XCAR (tail
), key
))
976 return XCAR (XCDR (tail
));
986 DEFUN ("image-size", Fimage_size
, Simage_size
, 1, 3, 0,
987 doc
: /* Return the size of image SPEC as pair (WIDTH . HEIGHT).
988 PIXELS non-nil means return the size in pixels, otherwise return the
989 size in canonical character units.
990 FRAME is the frame on which the image will be displayed. FRAME nil
991 or omitted means use the selected frame. */)
992 (spec
, pixels
, frame
)
993 Lisp_Object spec
, pixels
, frame
;
998 if (valid_image_p (spec
))
1000 struct frame
*f
= check_x_frame (frame
);
1001 int id
= lookup_image (f
, spec
);
1002 struct image
*img
= IMAGE_FROM_ID (f
, id
);
1003 int width
= img
->width
+ 2 * img
->hmargin
;
1004 int height
= img
->height
+ 2 * img
->vmargin
;
1007 size
= Fcons (make_float ((double) width
/ FRAME_COLUMN_WIDTH (f
)),
1008 make_float ((double) height
/ FRAME_LINE_HEIGHT (f
)));
1010 size
= Fcons (make_number (width
), make_number (height
));
1013 error ("Invalid image specification");
1019 DEFUN ("image-mask-p", Fimage_mask_p
, Simage_mask_p
, 1, 2, 0,
1020 doc
: /* Return t if image SPEC has a mask bitmap.
1021 FRAME is the frame on which the image will be displayed. FRAME nil
1022 or omitted means use the selected frame. */)
1024 Lisp_Object spec
, frame
;
1029 if (valid_image_p (spec
))
1031 struct frame
*f
= check_x_frame (frame
);
1032 int id
= lookup_image (f
, spec
);
1033 struct image
*img
= IMAGE_FROM_ID (f
, id
);
1038 error ("Invalid image specification");
1044 /***********************************************************************
1045 Image type independent image structures
1046 ***********************************************************************/
1048 static struct image
*make_image
P_ ((Lisp_Object spec
, unsigned hash
));
1049 static void free_image
P_ ((struct frame
*f
, struct image
*img
));
1052 /* Allocate and return a new image structure for image specification
1053 SPEC. SPEC has a hash value of HASH. */
1055 static struct image
*
1056 make_image (spec
, hash
)
1060 struct image
*img
= (struct image
*) xmalloc (sizeof *img
);
1062 xassert (valid_image_p (spec
));
1063 bzero (img
, sizeof *img
);
1064 img
->type
= lookup_image_type (image_spec_value (spec
, QCtype
, NULL
));
1065 xassert (img
->type
!= NULL
);
1067 img
->data
.lisp_val
= Qnil
;
1068 img
->ascent
= DEFAULT_IMAGE_ASCENT
;
1074 /* Free image IMG which was used on frame F, including its resources. */
1083 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
1085 /* Remove IMG from the hash table of its cache. */
1087 img
->prev
->next
= img
->next
;
1089 c
->buckets
[img
->hash
% IMAGE_CACHE_BUCKETS_SIZE
] = img
->next
;
1092 img
->next
->prev
= img
->prev
;
1094 c
->images
[img
->id
] = NULL
;
1096 /* Free resources, then free IMG. */
1097 img
->type
->free (f
, img
);
1103 /* Prepare image IMG for display on frame F. Must be called before
1104 drawing an image. */
1107 prepare_image_for_display (f
, img
)
1113 /* We're about to display IMG, so set its timestamp to `now'. */
1115 img
->timestamp
= EMACS_SECS (t
);
1117 /* If IMG doesn't have a pixmap yet, load it now, using the image
1118 type dependent loader function. */
1119 if (img
->pixmap
== NO_PIXMAP
&& !img
->load_failed_p
)
1120 img
->load_failed_p
= img
->type
->load (f
, img
) == 0;
1124 /* Value is the number of pixels for the ascent of image IMG when
1125 drawn in face FACE. */
1128 image_ascent (img
, face
, slice
)
1131 struct glyph_slice
*slice
;
1136 if (slice
->height
== img
->height
)
1137 height
= img
->height
+ img
->vmargin
;
1138 else if (slice
->y
== 0)
1139 height
= slice
->height
+ img
->vmargin
;
1141 height
= slice
->height
;
1143 if (img
->ascent
== CENTERED_IMAGE_ASCENT
)
1148 /* W32 specific version. Why?. ++kfs */
1149 ascent
= height
/ 2 - (FONT_DESCENT(face
->font
)
1150 - FONT_BASE(face
->font
)) / 2;
1152 /* This expression is arranged so that if the image can't be
1153 exactly centered, it will be moved slightly up. This is
1154 because a typical font is `top-heavy' (due to the presence
1155 uppercase letters), so the image placement should err towards
1156 being top-heavy too. It also just generally looks better. */
1157 ascent
= (height
+ face
->font
->ascent
- face
->font
->descent
+ 1) / 2;
1158 #endif /* HAVE_NTGUI */
1161 ascent
= height
/ 2;
1164 ascent
= (int) (height
* img
->ascent
/ 100.0);
1170 /* Image background colors. */
1172 /* Find the "best" corner color of a bitmap.
1173 On W32, XIMG is assumed to a device context with the bitmap selected. */
1175 static RGB_PIXEL_COLOR
1176 four_corners_best (ximg
, width
, height
)
1177 XImagePtr_or_DC ximg
;
1178 unsigned long width
, height
;
1180 RGB_PIXEL_COLOR corners
[4], best
;
1183 /* Get the colors at the corners of ximg. */
1184 corners
[0] = GET_PIXEL (ximg
, 0, 0);
1185 corners
[1] = GET_PIXEL (ximg
, width
- 1, 0);
1186 corners
[2] = GET_PIXEL (ximg
, width
- 1, height
- 1);
1187 corners
[3] = GET_PIXEL (ximg
, 0, height
- 1);
1189 /* Choose the most frequently found color as background. */
1190 for (i
= best_count
= 0; i
< 4; ++i
)
1194 for (j
= n
= 0; j
< 4; ++j
)
1195 if (corners
[i
] == corners
[j
])
1199 best
= corners
[i
], best_count
= n
;
1205 /* Portability macros */
1209 #define Destroy_Image(img_dc, prev) \
1210 do { SelectObject (img_dc, prev); DeleteDC (img_dc); } while (0)
1212 #define Free_Pixmap(display, pixmap) \
1213 DeleteObject (pixmap)
1217 #define Destroy_Image(ximg, dummy) \
1218 XDestroyImage (ximg)
1220 #define Free_Pixmap(display, pixmap) \
1221 XFreePixmap (display, pixmap)
1223 #endif /* HAVE_NTGUI */
1226 /* Return the `background' field of IMG. If IMG doesn't have one yet,
1227 it is guessed heuristically. If non-zero, XIMG is an existing
1228 XImage object (or device context with the image selected on W32) to
1229 use for the heuristic. */
1232 image_background (img
, f
, ximg
)
1235 XImagePtr_or_DC ximg
;
1237 if (! img
->background_valid
)
1238 /* IMG doesn't have a background yet, try to guess a reasonable value. */
1240 int free_ximg
= !ximg
;
1243 #endif /* HAVE_NTGUI */
1248 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
1249 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
1251 HDC frame_dc
= get_frame_dc (f
);
1252 ximg
= CreateCompatibleDC (frame_dc
);
1253 release_frame_dc (f
, frame_dc
);
1254 prev
= SelectObject (ximg
, img
->pixmap
);
1255 #endif /* !HAVE_NTGUI */
1258 img
->background
= four_corners_best (ximg
, img
->width
, img
->height
);
1261 Destroy_Image (ximg
, prev
);
1263 img
->background_valid
= 1;
1266 return img
->background
;
1269 /* Return the `background_transparent' field of IMG. If IMG doesn't
1270 have one yet, it is guessed heuristically. If non-zero, MASK is an
1271 existing XImage object to use for the heuristic. */
1274 image_background_transparent (img
, f
, mask
)
1277 XImagePtr_or_DC mask
;
1279 if (! img
->background_transparent_valid
)
1280 /* IMG doesn't have a background yet, try to guess a reasonable value. */
1284 int free_mask
= !mask
;
1287 #endif /* HAVE_NTGUI */
1292 mask
= XGetImage (FRAME_X_DISPLAY (f
), img
->mask
,
1293 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
1295 HDC frame_dc
= get_frame_dc (f
);
1296 mask
= CreateCompatibleDC (frame_dc
);
1297 release_frame_dc (f
, frame_dc
);
1298 prev
= SelectObject (mask
, img
->mask
);
1299 #endif /* HAVE_NTGUI */
1302 img
->background_transparent
1303 = (four_corners_best (mask
, img
->width
, img
->height
) == PIX_MASK_RETAIN (f
));
1306 Destroy_Image (mask
, prev
);
1309 img
->background_transparent
= 0;
1311 img
->background_transparent_valid
= 1;
1314 return img
->background_transparent
;
1318 /***********************************************************************
1319 Helper functions for X image types
1320 ***********************************************************************/
1322 static void x_clear_image_1
P_ ((struct frame
*, struct image
*, int,
1324 static void x_clear_image
P_ ((struct frame
*f
, struct image
*img
));
1325 static unsigned long x_alloc_image_color
P_ ((struct frame
*f
,
1327 Lisp_Object color_name
,
1328 unsigned long dflt
));
1331 /* Clear X resources of image IMG on frame F. PIXMAP_P non-zero means
1332 free the pixmap if any. MASK_P non-zero means clear the mask
1333 pixmap if any. COLORS_P non-zero means free colors allocated for
1334 the image, if any. */
1337 x_clear_image_1 (f
, img
, pixmap_p
, mask_p
, colors_p
)
1340 int pixmap_p
, mask_p
, colors_p
;
1342 if (pixmap_p
&& img
->pixmap
)
1344 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->pixmap
);
1345 img
->pixmap
= NO_PIXMAP
;
1346 img
->background_valid
= 0;
1349 if (mask_p
&& img
->mask
)
1351 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
1352 img
->mask
= NO_PIXMAP
;
1353 img
->background_transparent_valid
= 0;
1356 if (colors_p
&& img
->ncolors
)
1358 /* MAC_TODO: color table support. */
1359 /* W32_TODO: color table support. */
1360 #ifdef HAVE_X_WINDOWS
1361 x_free_colors (f
, img
->colors
, img
->ncolors
);
1362 #endif /* HAVE_X_WINDOWS */
1363 xfree (img
->colors
);
1369 /* Free X resources of image IMG which is used on frame F. */
1372 x_clear_image (f
, img
)
1377 x_clear_image_1 (f
, img
, 1, 1, 1);
1382 /* Allocate color COLOR_NAME for image IMG on frame F. If color
1383 cannot be allocated, use DFLT. Add a newly allocated color to
1384 IMG->colors, so that it can be freed again. Value is the pixel
1387 static unsigned long
1388 x_alloc_image_color (f
, img
, color_name
, dflt
)
1391 Lisp_Object color_name
;
1395 unsigned long result
;
1397 xassert (STRINGP (color_name
));
1399 if (x_defined_color (f
, SDATA (color_name
), &color
, 1))
1401 /* This isn't called frequently so we get away with simply
1402 reallocating the color vector to the needed size, here. */
1405 (unsigned long *) xrealloc (img
->colors
,
1406 img
->ncolors
* sizeof *img
->colors
);
1407 img
->colors
[img
->ncolors
- 1] = color
.pixel
;
1408 result
= color
.pixel
;
1418 /***********************************************************************
1420 ***********************************************************************/
1422 static void cache_image
P_ ((struct frame
*f
, struct image
*img
));
1423 static void postprocess_image
P_ ((struct frame
*, struct image
*));
1425 /* Return a new, initialized image cache that is allocated from the
1426 heap. Call free_image_cache to free an image cache. */
1428 struct image_cache
*
1431 struct image_cache
*c
= (struct image_cache
*) xmalloc (sizeof *c
);
1434 bzero (c
, sizeof *c
);
1436 c
->images
= (struct image
**) xmalloc (c
->size
* sizeof *c
->images
);
1437 size
= IMAGE_CACHE_BUCKETS_SIZE
* sizeof *c
->buckets
;
1438 c
->buckets
= (struct image
**) xmalloc (size
);
1439 bzero (c
->buckets
, size
);
1444 /* Free image cache of frame F. Be aware that X frames share images
1448 free_image_cache (f
)
1451 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
1456 /* Cache should not be referenced by any frame when freed. */
1457 xassert (c
->refcount
== 0);
1459 for (i
= 0; i
< c
->used
; ++i
)
1460 free_image (f
, c
->images
[i
]);
1464 FRAME_X_IMAGE_CACHE (f
) = NULL
;
1469 /* Clear image cache of frame F. FORCE_P non-zero means free all
1470 images. FORCE_P zero means clear only images that haven't been
1471 displayed for some time. Should be called from time to time to
1472 reduce the number of loaded images. If image-eviction-seconds is
1473 non-nil, this frees images in the cache which weren't displayed for
1474 at least that many seconds. */
1477 clear_image_cache (f
, force_p
)
1481 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
1483 if (c
&& INTEGERP (Vimage_cache_eviction_delay
))
1490 old
= EMACS_SECS (t
) - XFASTINT (Vimage_cache_eviction_delay
);
1492 /* Block input so that we won't be interrupted by a SIGIO
1493 while being in an inconsistent state. */
1496 for (i
= nfreed
= 0; i
< c
->used
; ++i
)
1498 struct image
*img
= c
->images
[i
];
1500 && (force_p
|| img
->timestamp
< old
))
1502 free_image (f
, img
);
1507 /* We may be clearing the image cache because, for example,
1508 Emacs was iconified for a longer period of time. In that
1509 case, current matrices may still contain references to
1510 images freed above. So, clear these matrices. */
1513 Lisp_Object tail
, frame
;
1515 FOR_EACH_FRAME (tail
, frame
)
1517 struct frame
*f
= XFRAME (frame
);
1518 if (FRAME_WINDOW_P (f
)
1519 && FRAME_X_IMAGE_CACHE (f
) == c
)
1520 clear_current_matrices (f
);
1523 ++windows_or_buffers_changed
;
1531 DEFUN ("clear-image-cache", Fclear_image_cache
, Sclear_image_cache
,
1533 doc
: /* Clear the image cache of FRAME.
1534 FRAME nil or omitted means use the selected frame.
1535 FRAME t means clear the image caches of all frames. */)
1543 FOR_EACH_FRAME (tail
, frame
)
1544 if (FRAME_WINDOW_P (XFRAME (frame
)))
1545 clear_image_cache (XFRAME (frame
), 1);
1548 clear_image_cache (check_x_frame (frame
), 1);
1554 /* Compute masks and transform image IMG on frame F, as specified
1555 by the image's specification, */
1558 postprocess_image (f
, img
)
1562 /* Manipulation of the image's mask. */
1565 Lisp_Object conversion
, spec
;
1570 /* `:heuristic-mask t'
1572 means build a mask heuristically.
1573 `:heuristic-mask (R G B)'
1574 `:mask (heuristic (R G B))'
1575 means build a mask from color (R G B) in the
1578 means remove a mask, if any. */
1580 mask
= image_spec_value (spec
, QCheuristic_mask
, NULL
);
1582 x_build_heuristic_mask (f
, img
, mask
);
1587 mask
= image_spec_value (spec
, QCmask
, &found_p
);
1589 if (EQ (mask
, Qheuristic
))
1590 x_build_heuristic_mask (f
, img
, Qt
);
1591 else if (CONSP (mask
)
1592 && EQ (XCAR (mask
), Qheuristic
))
1594 if (CONSP (XCDR (mask
)))
1595 x_build_heuristic_mask (f
, img
, XCAR (XCDR (mask
)));
1597 x_build_heuristic_mask (f
, img
, XCDR (mask
));
1599 else if (NILP (mask
) && found_p
&& img
->mask
)
1601 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
1602 img
->mask
= NO_PIXMAP
;
1607 /* Should we apply an image transformation algorithm? */
1608 conversion
= image_spec_value (spec
, QCconversion
, NULL
);
1609 if (EQ (conversion
, Qdisabled
))
1610 x_disable_image (f
, img
);
1611 else if (EQ (conversion
, Qlaplace
))
1613 else if (EQ (conversion
, Qemboss
))
1615 else if (CONSP (conversion
)
1616 && EQ (XCAR (conversion
), Qedge_detection
))
1619 tem
= XCDR (conversion
);
1621 x_edge_detection (f
, img
,
1622 Fplist_get (tem
, QCmatrix
),
1623 Fplist_get (tem
, QCcolor_adjustment
));
1629 /* Return the id of image with Lisp specification SPEC on frame F.
1630 SPEC must be a valid Lisp image specification (see valid_image_p). */
1633 lookup_image (f
, spec
)
1637 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
1641 struct gcpro gcpro1
;
1644 /* F must be a window-system frame, and SPEC must be a valid image
1646 xassert (FRAME_WINDOW_P (f
));
1647 xassert (valid_image_p (spec
));
1651 /* Look up SPEC in the hash table of the image cache. */
1652 hash
= sxhash (spec
, 0);
1653 i
= hash
% IMAGE_CACHE_BUCKETS_SIZE
;
1655 for (img
= c
->buckets
[i
]; img
; img
= img
->next
)
1656 if (img
->hash
== hash
&& !NILP (Fequal (img
->spec
, spec
)))
1659 /* If not found, create a new image and cache it. */
1662 extern Lisp_Object Qpostscript
;
1665 img
= make_image (spec
, hash
);
1666 cache_image (f
, img
);
1667 img
->load_failed_p
= img
->type
->load (f
, img
) == 0;
1669 /* If we can't load the image, and we don't have a width and
1670 height, use some arbitrary width and height so that we can
1671 draw a rectangle for it. */
1672 if (img
->load_failed_p
)
1676 value
= image_spec_value (spec
, QCwidth
, NULL
);
1677 img
->width
= (INTEGERP (value
)
1678 ? XFASTINT (value
) : DEFAULT_IMAGE_WIDTH
);
1679 value
= image_spec_value (spec
, QCheight
, NULL
);
1680 img
->height
= (INTEGERP (value
)
1681 ? XFASTINT (value
) : DEFAULT_IMAGE_HEIGHT
);
1685 /* Handle image type independent image attributes
1686 `:ascent ASCENT', `:margin MARGIN', `:relief RELIEF',
1687 `:background COLOR'. */
1688 Lisp_Object ascent
, margin
, relief
, bg
;
1690 ascent
= image_spec_value (spec
, QCascent
, NULL
);
1691 if (INTEGERP (ascent
))
1692 img
->ascent
= XFASTINT (ascent
);
1693 else if (EQ (ascent
, Qcenter
))
1694 img
->ascent
= CENTERED_IMAGE_ASCENT
;
1696 margin
= image_spec_value (spec
, QCmargin
, NULL
);
1697 if (INTEGERP (margin
) && XINT (margin
) >= 0)
1698 img
->vmargin
= img
->hmargin
= XFASTINT (margin
);
1699 else if (CONSP (margin
) && INTEGERP (XCAR (margin
))
1700 && INTEGERP (XCDR (margin
)))
1702 if (XINT (XCAR (margin
)) > 0)
1703 img
->hmargin
= XFASTINT (XCAR (margin
));
1704 if (XINT (XCDR (margin
)) > 0)
1705 img
->vmargin
= XFASTINT (XCDR (margin
));
1708 relief
= image_spec_value (spec
, QCrelief
, NULL
);
1709 if (INTEGERP (relief
))
1711 img
->relief
= XINT (relief
);
1712 img
->hmargin
+= abs (img
->relief
);
1713 img
->vmargin
+= abs (img
->relief
);
1716 if (! img
->background_valid
)
1718 bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
1722 = x_alloc_image_color (f
, img
, bg
,
1723 FRAME_BACKGROUND_PIXEL (f
));
1724 img
->background_valid
= 1;
1728 /* Do image transformations and compute masks, unless we
1729 don't have the image yet. */
1730 if (!EQ (*img
->type
->type
, Qpostscript
))
1731 postprocess_image (f
, img
);
1737 /* We're using IMG, so set its timestamp to `now'. */
1738 EMACS_GET_TIME (now
);
1739 img
->timestamp
= EMACS_SECS (now
);
1743 /* Value is the image id. */
1748 /* Cache image IMG in the image cache of frame F. */
1751 cache_image (f
, img
)
1755 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
1758 /* Find a free slot in c->images. */
1759 for (i
= 0; i
< c
->used
; ++i
)
1760 if (c
->images
[i
] == NULL
)
1763 /* If no free slot found, maybe enlarge c->images. */
1764 if (i
== c
->used
&& c
->used
== c
->size
)
1767 c
->images
= (struct image
**) xrealloc (c
->images
,
1768 c
->size
* sizeof *c
->images
);
1771 /* Add IMG to c->images, and assign IMG an id. */
1777 /* Add IMG to the cache's hash table. */
1778 i
= img
->hash
% IMAGE_CACHE_BUCKETS_SIZE
;
1779 img
->next
= c
->buckets
[i
];
1781 img
->next
->prev
= img
;
1783 c
->buckets
[i
] = img
;
1787 /* Call FN on every image in the image cache of frame F. Used to mark
1788 Lisp Objects in the image cache. */
1791 forall_images_in_image_cache (f
, fn
)
1793 void (*fn
) P_ ((struct image
*img
));
1795 if (FRAME_LIVE_P (f
) && FRAME_WINDOW_P (f
))
1797 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
1801 for (i
= 0; i
< c
->used
; ++i
)
1810 /***********************************************************************
1811 X / MAC / W32 support code
1812 ***********************************************************************/
1816 /* Macro for defining functions that will be loaded from image DLLs. */
1817 #define DEF_IMGLIB_FN(func) int (FAR CDECL *fn_##func)()
1819 /* Macro for loading those image functions from the library. */
1820 #define LOAD_IMGLIB_FN(lib,func) { \
1821 fn_##func = (void *) GetProcAddress (lib, #func); \
1822 if (!fn_##func) return 0; \
1825 /* Load a DLL implementing an image type.
1826 The `image-library-alist' variable associates a symbol,
1827 identifying an image type, to a list of possible filenames.
1828 The function returns NULL if no library could be loaded for
1829 the given image type, or if the library was previously loaded;
1830 else the handle of the DLL. */
1832 w32_delayed_load (Lisp_Object libraries
, Lisp_Object type
)
1834 HMODULE library
= NULL
;
1836 if (CONSP (libraries
) && NILP (Fassq (type
, Vimage_type_cache
)))
1838 Lisp_Object dlls
= Fassq (type
, libraries
);
1841 for (dlls
= XCDR (dlls
); CONSP (dlls
); dlls
= XCDR (dlls
))
1843 CHECK_STRING_CAR (dlls
);
1844 if (library
= LoadLibrary (SDATA (XCAR (dlls
))))
1852 #endif /* HAVE_NTGUI */
1854 static int x_create_x_image_and_pixmap
P_ ((struct frame
*, int, int, int,
1855 XImagePtr
*, Pixmap
*));
1856 static void x_destroy_x_image
P_ ((XImagePtr
));
1857 static void x_put_x_image
P_ ((struct frame
*, XImagePtr
, Pixmap
, int, int));
1860 /* Create an XImage and a pixmap of size WIDTH x HEIGHT for use on
1861 frame F. Set *XIMG and *PIXMAP to the XImage and Pixmap created.
1862 Set (*XIMG)->data to a raster of WIDTH x HEIGHT pixels allocated
1863 via xmalloc. Print error messages via image_error if an error
1864 occurs. Value is non-zero if successful.
1866 On W32, a DEPTH of zero signifies a 24 bit image, otherwise DEPTH
1867 should indicate the bit depth of the image. */
1870 x_create_x_image_and_pixmap (f
, width
, height
, depth
, ximg
, pixmap
)
1872 int width
, height
, depth
;
1876 #ifdef HAVE_X_WINDOWS
1877 Display
*display
= FRAME_X_DISPLAY (f
);
1878 Window window
= FRAME_X_WINDOW (f
);
1879 Screen
*screen
= FRAME_X_SCREEN (f
);
1881 xassert (interrupt_input_blocked
);
1884 depth
= DefaultDepthOfScreen (screen
);
1885 *ximg
= XCreateImage (display
, DefaultVisualOfScreen (screen
),
1886 depth
, ZPixmap
, 0, NULL
, width
, height
,
1887 depth
> 16 ? 32 : depth
> 8 ? 16 : 8, 0);
1890 image_error ("Unable to allocate X image", Qnil
, Qnil
);
1894 /* Allocate image raster. */
1895 (*ximg
)->data
= (char *) xmalloc ((*ximg
)->bytes_per_line
* height
);
1897 /* Allocate a pixmap of the same size. */
1898 *pixmap
= XCreatePixmap (display
, window
, width
, height
, depth
);
1899 if (*pixmap
== NO_PIXMAP
)
1901 x_destroy_x_image (*ximg
);
1903 image_error ("Unable to create X pixmap", Qnil
, Qnil
);
1908 #endif /* HAVE_X_WINDOWS */
1912 BITMAPINFOHEADER
*header
;
1914 int scanline_width_bits
;
1916 int palette_colors
= 0;
1921 if (depth
!= 1 && depth
!= 4 && depth
!= 8
1922 && depth
!= 16 && depth
!= 24 && depth
!= 32)
1924 image_error ("Invalid image bit depth specified", Qnil
, Qnil
);
1928 scanline_width_bits
= width
* depth
;
1929 remainder
= scanline_width_bits
% 32;
1932 scanline_width_bits
+= 32 - remainder
;
1934 /* Bitmaps with a depth less than 16 need a palette. */
1935 /* BITMAPINFO structure already contains the first RGBQUAD. */
1937 palette_colors
= 1 << depth
- 1;
1939 *ximg
= xmalloc (sizeof (XImage
) + palette_colors
* sizeof (RGBQUAD
));
1942 image_error ("Unable to allocate memory for XImage", Qnil
, Qnil
);
1946 header
= &((*ximg
)->info
.bmiHeader
);
1947 bzero (&((*ximg
)->info
), sizeof (BITMAPINFO
));
1948 header
->biSize
= sizeof (*header
);
1949 header
->biWidth
= width
;
1950 header
->biHeight
= -height
; /* negative indicates a top-down bitmap. */
1951 header
->biPlanes
= 1;
1952 header
->biBitCount
= depth
;
1953 header
->biCompression
= BI_RGB
;
1954 header
->biClrUsed
= palette_colors
;
1956 /* TODO: fill in palette. */
1959 (*ximg
)->info
.bmiColors
[0].rgbBlue
= 0;
1960 (*ximg
)->info
.bmiColors
[0].rgbGreen
= 0;
1961 (*ximg
)->info
.bmiColors
[0].rgbRed
= 0;
1962 (*ximg
)->info
.bmiColors
[0].rgbReserved
= 0;
1963 (*ximg
)->info
.bmiColors
[1].rgbBlue
= 255;
1964 (*ximg
)->info
.bmiColors
[1].rgbGreen
= 255;
1965 (*ximg
)->info
.bmiColors
[1].rgbRed
= 255;
1966 (*ximg
)->info
.bmiColors
[1].rgbReserved
= 0;
1969 hdc
= get_frame_dc (f
);
1971 /* Create a DIBSection and raster array for the bitmap,
1972 and store its handle in *pixmap. */
1973 *pixmap
= CreateDIBSection (hdc
, &((*ximg
)->info
),
1974 (depth
< 16) ? DIB_PAL_COLORS
: DIB_RGB_COLORS
,
1975 /* casting avoids a GCC warning */
1976 (void **)&((*ximg
)->data
), NULL
, 0);
1978 /* Realize display palette and garbage all frames. */
1979 release_frame_dc (f
, hdc
);
1981 if (*pixmap
== NULL
)
1983 DWORD err
= GetLastError();
1984 Lisp_Object errcode
;
1985 /* All system errors are < 10000, so the following is safe. */
1986 XSETINT (errcode
, (int) err
);
1987 image_error ("Unable to create bitmap, error code %d", errcode
, Qnil
);
1988 x_destroy_x_image (*ximg
);
1994 #endif /* HAVE_NTGUI */
1997 Display
*display
= FRAME_X_DISPLAY (f
);
1998 Window window
= FRAME_X_WINDOW (f
);
2000 xassert (interrupt_input_blocked
);
2002 /* Allocate a pixmap of the same size. */
2003 *pixmap
= XCreatePixmap (display
, window
, width
, height
, depth
);
2004 if (*pixmap
== NO_PIXMAP
)
2006 x_destroy_x_image (*ximg
);
2008 image_error ("Unable to create X pixmap", Qnil
, Qnil
);
2012 LockPixels (GetGWorldPixMap (*pixmap
));
2020 /* Destroy XImage XIMG. Free XIMG->data. */
2023 x_destroy_x_image (ximg
)
2026 xassert (interrupt_input_blocked
);
2029 #ifdef HAVE_X_WINDOWS
2032 XDestroyImage (ximg
);
2033 #endif /* HAVE_X_WINDOWS */
2035 /* Data will be freed by DestroyObject. */
2038 #endif /* HAVE_NTGUI */
2040 XDestroyImage (ximg
);
2046 /* Put XImage XIMG into pixmap PIXMAP on frame F. WIDTH and HEIGHT
2047 are width and height of both the image and pixmap. */
2050 x_put_x_image (f
, ximg
, pixmap
, width
, height
)
2056 #ifdef HAVE_X_WINDOWS
2059 xassert (interrupt_input_blocked
);
2060 gc
= XCreateGC (FRAME_X_DISPLAY (f
), pixmap
, 0, NULL
);
2061 XPutImage (FRAME_X_DISPLAY (f
), pixmap
, gc
, ximg
, 0, 0, 0, 0, width
, height
);
2062 XFreeGC (FRAME_X_DISPLAY (f
), gc
);
2063 #endif /* HAVE_X_WINDOWS */
2066 #if 0 /* I don't think this is necessary looking at where it is used. */
2067 HDC hdc
= get_frame_dc (f
);
2068 SetDIBits (hdc
, pixmap
, 0, height
, ximg
->data
, &(ximg
->info
), DIB_RGB_COLORS
);
2069 release_frame_dc (f
, hdc
);
2071 #endif /* HAVE_NTGUI */
2074 xassert (ximg
== pixmap
);
2079 /***********************************************************************
2081 ***********************************************************************/
2083 static unsigned char *slurp_file
P_ ((char *, int *));
2086 /* Find image file FILE. Look in data-directory, then
2087 x-bitmap-file-path. Value is the full name of the file found, or
2088 nil if not found. */
2091 x_find_image_file (file
)
2094 Lisp_Object file_found
, search_path
;
2095 struct gcpro gcpro1
, gcpro2
;
2099 search_path
= Fcons (Vdata_directory
, Vx_bitmap_file_path
);
2100 GCPRO2 (file_found
, search_path
);
2102 /* Try to find FILE in data-directory, then x-bitmap-file-path. */
2103 fd
= openp (search_path
, file
, Qnil
, &file_found
, Qnil
);
2115 /* Read FILE into memory. Value is a pointer to a buffer allocated
2116 with xmalloc holding FILE's contents. Value is null if an error
2117 occurred. *SIZE is set to the size of the file. */
2119 static unsigned char *
2120 slurp_file (file
, size
)
2125 unsigned char *buf
= NULL
;
2128 if (stat (file
, &st
) == 0
2129 && (fp
= fopen (file
, "rb")) != NULL
2130 && (buf
= (char *) xmalloc (st
.st_size
),
2131 fread (buf
, 1, st
.st_size
, fp
) == st
.st_size
))
2154 /***********************************************************************
2155 MAC Image Load Functions
2156 ***********************************************************************/
2158 static int image_load_quicktime
P_ ((struct frame
*, struct image
*img
,
2161 static int image_load_quartz2d
P_ ((struct frame
*, struct image
*img
, int));
2165 find_image_fsspec (specified_file
, file
, fss
)
2166 Lisp_Object specified_file
, *file
;
2169 #if TARGET_API_MAC_CARBON
2172 Str255 mac_pathname
;
2176 *file
= x_find_image_file (specified_file
);
2177 if (!STRINGP (*file
))
2178 return fnfErr
; /* file or directory not found;
2179 incomplete pathname */
2180 /* Try to open the image file. */
2181 #if TARGET_API_MAC_CARBON
2182 err
= FSPathMakeRef (SDATA (*file
), &fsr
, NULL
);
2184 err
= FSGetCatalogInfo (&fsr
, kFSCatInfoNone
, NULL
, NULL
, fss
, NULL
);
2186 if (posix_to_mac_pathname (SDATA (*file
), mac_pathname
, MAXPATHLEN
+1) == 0)
2188 c2pstr (mac_pathname
);
2189 err
= FSMakeFSSpec (0, 0, mac_pathname
, fss
);
2195 image_load_qt_1 (f
, img
, type
, fss
, dh
)
2203 GraphicsImportComponent gi
;
2206 short draw_all_pixels
;
2207 Lisp_Object specified_bg
;
2212 err
= OpenADefaultComponent (GraphicsImporterComponentType
,
2216 image_error ("Cannot get importer component for `%s'", img
->spec
, Qnil
);
2221 /* read from file system spec */
2222 err
= GraphicsImportSetDataFile (gi
, fss
);
2225 image_error ("Cannot set fsspec to graphics importer for '%s'",
2232 /* read from data handle */
2233 err
= GraphicsImportSetDataHandle (gi
, dh
);
2236 image_error ("Cannot set data handle to graphics importer for `%s'",
2241 err
= GraphicsImportGetNaturalBounds (gi
, &rect
);
2244 image_error ("Error reading `%s'", img
->spec
, Qnil
);
2247 width
= img
->width
= rect
.right
- rect
.left
;
2248 height
= img
->height
= rect
.bottom
- rect
.top
;
2249 err
= GraphicsImportDoesDrawAllPixels (gi
, &draw_all_pixels
);
2251 /* Don't check the error code here. It may have an undocumented
2255 image_error ("Error reading `%s'", img
->spec
, Qnil
);
2259 if (draw_all_pixels
!= graphicsImporterDrawsAllPixels
)
2261 specified_bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
2262 if (!STRINGP (specified_bg
) ||
2263 !mac_defined_color (f
, SDATA (specified_bg
), &color
, 0))
2265 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
2266 color
.red
= RED16_FROM_ULONG (color
.pixel
);
2267 color
.green
= GREEN16_FROM_ULONG (color
.pixel
);
2268 color
.blue
= BLUE16_FROM_ULONG (color
.pixel
);
2272 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
2274 if (draw_all_pixels
!= graphicsImporterDrawsAllPixels
)
2279 GetGWorld (&old_port
, &old_gdh
);
2280 SetGWorld (ximg
, NULL
);
2281 bg_color
.red
= color
.red
;
2282 bg_color
.green
= color
.green
;
2283 bg_color
.blue
= color
.blue
;
2284 RGBBackColor (&bg_color
);
2285 #if TARGET_API_MAC_CARBON
2286 GetPortBounds (ximg
, &rect
);
2289 EraseRect (&(ximg
->portRect
));
2291 SetGWorld (old_port
, old_gdh
);
2293 GraphicsImportSetGWorld (gi
, ximg
, NULL
);
2294 GraphicsImportDraw (gi
);
2295 CloseComponent (gi
);
2297 /* Maybe fill in the background field while we have ximg handy. */
2298 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
2299 IMAGE_BACKGROUND (img
, f
, ximg
);
2301 /* Put the image into the pixmap. */
2302 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
2303 x_destroy_x_image (ximg
);
2307 CloseComponent (gi
);
2312 /* Load an image using the QuickTime Graphics Importer.
2313 Note: The alpha channel does not work for PNG images. */
2315 image_load_quicktime (f
, img
, type
)
2320 Lisp_Object specified_file
;
2321 Lisp_Object specified_data
;
2324 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
2325 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
2327 if (NILP (specified_data
))
2329 /* Read from a file */
2333 err
= find_image_fsspec (specified_file
, &file
, &fss
);
2337 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
2339 image_error ("Cannot open `%s'", file
, Qnil
);
2342 return image_load_qt_1 (f
, img
, type
, &fss
, NULL
);
2346 /* Memory source! */
2350 err
= PtrToHand (SDATA (specified_data
), &dh
, SBYTES (specified_data
));
2353 image_error ("Cannot allocate data handle for `%s'",
2357 success_p
= image_load_qt_1 (f
, img
, type
, NULL
, dh
);
2365 /* Load a PNG/JPEG image using Quartz 2D decoding routines.
2366 CGImageCreateWithPNGDataProvider is provided after Mac OS X 10.2.
2367 So don't use this function directly but determine at runtime
2368 whether it exists. */
2369 typedef CGImageRef (*CGImageCreateWithPNGDataProviderProcType
)
2370 (CGDataProviderRef
, const float [], bool, CGColorRenderingIntent
);
2371 static CGImageCreateWithPNGDataProviderProcType MyCGImageCreateWithPNGDataProvider
;
2375 init_image_func_pointer ()
2377 if (NSIsSymbolNameDefined ("_CGImageCreateWithPNGDataProvider"))
2379 MyCGImageCreateWithPNGDataProvider
2380 = (CGImageCreateWithPNGDataProviderProcType
)
2381 NSAddressOfSymbol (NSLookupAndBindSymbol
2382 ("_CGImageCreateWithPNGDataProvider"));
2385 MyCGImageCreateWithPNGDataProvider
= NULL
;
2390 image_load_quartz2d (f
, img
, png_p
)
2395 Lisp_Object file
, specified_file
;
2396 Lisp_Object specified_data
, specified_bg
;
2397 struct gcpro gcpro1
;
2398 CGDataProviderRef source
;
2402 XImagePtr ximg
= NULL
;
2403 CGContextRef context
;
2406 /* Open the file. */
2407 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
2408 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
2413 if (NILP (specified_data
))
2418 file
= x_find_image_file (specified_file
);
2419 if (!STRINGP (file
))
2421 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
2425 path
= cfstring_create_with_string (file
);
2426 url
= CFURLCreateWithFileSystemPath (NULL
, path
,
2427 kCFURLPOSIXPathStyle
, 0);
2429 source
= CGDataProviderCreateWithURL (url
);
2433 source
= CGDataProviderCreateWithData (NULL
, SDATA (specified_data
),
2434 SBYTES (specified_data
), NULL
);
2437 image
= (*MyCGImageCreateWithPNGDataProvider
) (source
, NULL
, FALSE
,
2438 kCGRenderingIntentDefault
);
2440 image
= CGImageCreateWithJPEGDataProvider (source
, NULL
, FALSE
,
2441 kCGRenderingIntentDefault
);
2443 CGDataProviderRelease (source
);
2447 image_error ("Error reading image `%s'", img
->spec
, Qnil
);
2453 specified_bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
2454 if (!STRINGP (specified_bg
) ||
2455 !mac_defined_color (f
, SDATA (specified_bg
), &color
, 0))
2457 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
2458 color
.red
= RED16_FROM_ULONG (color
.pixel
);
2459 color
.green
= GREEN16_FROM_ULONG (color
.pixel
);
2460 color
.blue
= BLUE16_FROM_ULONG (color
.pixel
);
2463 width
= img
->width
= CGImageGetWidth (image
);
2464 height
= img
->height
= CGImageGetHeight (image
);
2465 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
2467 CGImageRelease (image
);
2471 rectangle
= CGRectMake (0, 0, width
, height
);
2472 QDBeginCGContext (ximg
, &context
);
2475 CGContextSetRGBFillColor (context
, color
.red
/ 65535.0,
2476 color
.green
/ 65535.0,
2477 color
.blue
/ 65535.0, 1.0);
2478 CGContextFillRect (context
, rectangle
);
2480 CGContextDrawImage (context
, rectangle
, image
);
2481 QDEndCGContext (ximg
, &context
);
2482 CGImageRelease (image
);
2484 /* Maybe fill in the background field while we have ximg handy. */
2485 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
2486 IMAGE_BACKGROUND (img
, f
, ximg
);
2488 /* Put the image into the pixmap. */
2489 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
2490 x_destroy_x_image (ximg
);
2499 /***********************************************************************
2501 ***********************************************************************/
2503 static int xbm_scan
P_ ((unsigned char **, unsigned char *, char *, int *));
2504 static int xbm_load
P_ ((struct frame
*f
, struct image
*img
));
2505 static int xbm_load_image
P_ ((struct frame
*f
, struct image
*img
,
2506 unsigned char *, unsigned char *));
2507 static int xbm_image_p
P_ ((Lisp_Object object
));
2508 static int xbm_read_bitmap_data
P_ ((unsigned char *, unsigned char *,
2509 int *, int *, unsigned char **));
2510 static int xbm_file_p
P_ ((Lisp_Object
));
2513 /* Indices of image specification fields in xbm_format, below. */
2515 enum xbm_keyword_index
2533 /* Vector of image_keyword structures describing the format
2534 of valid XBM image specifications. */
2536 static struct image_keyword xbm_format
[XBM_LAST
] =
2538 {":type", IMAGE_SYMBOL_VALUE
, 1},
2539 {":file", IMAGE_STRING_VALUE
, 0},
2540 {":width", IMAGE_POSITIVE_INTEGER_VALUE
, 0},
2541 {":height", IMAGE_POSITIVE_INTEGER_VALUE
, 0},
2542 {":data", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
2543 {":foreground", IMAGE_STRING_OR_NIL_VALUE
, 0},
2544 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0},
2545 {":ascent", IMAGE_ASCENT_VALUE
, 0},
2546 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
2547 {":relief", IMAGE_INTEGER_VALUE
, 0},
2548 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
2549 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
2550 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0}
2553 /* Structure describing the image type XBM. */
2555 static struct image_type xbm_type
=
2564 /* Tokens returned from xbm_scan. */
2573 /* Return non-zero if OBJECT is a valid XBM-type image specification.
2574 A valid specification is a list starting with the symbol `image'
2575 The rest of the list is a property list which must contain an
2578 If the specification specifies a file to load, it must contain
2579 an entry `:file FILENAME' where FILENAME is a string.
2581 If the specification is for a bitmap loaded from memory it must
2582 contain `:width WIDTH', `:height HEIGHT', and `:data DATA', where
2583 WIDTH and HEIGHT are integers > 0. DATA may be:
2585 1. a string large enough to hold the bitmap data, i.e. it must
2586 have a size >= (WIDTH + 7) / 8 * HEIGHT
2588 2. a bool-vector of size >= WIDTH * HEIGHT
2590 3. a vector of strings or bool-vectors, one for each line of the
2593 4. A string containing an in-memory XBM file. WIDTH and HEIGHT
2594 may not be specified in this case because they are defined in the
2597 Both the file and data forms may contain the additional entries
2598 `:background COLOR' and `:foreground COLOR'. If not present,
2599 foreground and background of the frame on which the image is
2600 displayed is used. */
2603 xbm_image_p (object
)
2606 struct image_keyword kw
[XBM_LAST
];
2608 bcopy (xbm_format
, kw
, sizeof kw
);
2609 if (!parse_image_spec (object
, kw
, XBM_LAST
, Qxbm
))
2612 xassert (EQ (kw
[XBM_TYPE
].value
, Qxbm
));
2614 if (kw
[XBM_FILE
].count
)
2616 if (kw
[XBM_WIDTH
].count
|| kw
[XBM_HEIGHT
].count
|| kw
[XBM_DATA
].count
)
2619 else if (kw
[XBM_DATA
].count
&& xbm_file_p (kw
[XBM_DATA
].value
))
2621 /* In-memory XBM file. */
2622 if (kw
[XBM_WIDTH
].count
|| kw
[XBM_HEIGHT
].count
|| kw
[XBM_FILE
].count
)
2630 /* Entries for `:width', `:height' and `:data' must be present. */
2631 if (!kw
[XBM_WIDTH
].count
2632 || !kw
[XBM_HEIGHT
].count
2633 || !kw
[XBM_DATA
].count
)
2636 data
= kw
[XBM_DATA
].value
;
2637 width
= XFASTINT (kw
[XBM_WIDTH
].value
);
2638 height
= XFASTINT (kw
[XBM_HEIGHT
].value
);
2640 /* Check type of data, and width and height against contents of
2646 /* Number of elements of the vector must be >= height. */
2647 if (XVECTOR (data
)->size
< height
)
2650 /* Each string or bool-vector in data must be large enough
2651 for one line of the image. */
2652 for (i
= 0; i
< height
; ++i
)
2654 Lisp_Object elt
= XVECTOR (data
)->contents
[i
];
2659 < (width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
)
2662 else if (BOOL_VECTOR_P (elt
))
2664 if (XBOOL_VECTOR (elt
)->size
< width
)
2671 else if (STRINGP (data
))
2674 < (width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
* height
)
2677 else if (BOOL_VECTOR_P (data
))
2679 if (XBOOL_VECTOR (data
)->size
< width
* height
)
2690 /* Scan a bitmap file. FP is the stream to read from. Value is
2691 either an enumerator from enum xbm_token, or a character for a
2692 single-character token, or 0 at end of file. If scanning an
2693 identifier, store the lexeme of the identifier in SVAL. If
2694 scanning a number, store its value in *IVAL. */
2697 xbm_scan (s
, end
, sval
, ival
)
2698 unsigned char **s
, *end
;
2706 /* Skip white space. */
2707 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
2712 else if (isdigit (c
))
2714 int value
= 0, digit
;
2716 if (c
== '0' && *s
< end
)
2719 if (c
== 'x' || c
== 'X')
2726 else if (c
>= 'a' && c
<= 'f')
2727 digit
= c
- 'a' + 10;
2728 else if (c
>= 'A' && c
<= 'F')
2729 digit
= c
- 'A' + 10;
2732 value
= 16 * value
+ digit
;
2735 else if (isdigit (c
))
2739 && (c
= *(*s
)++, isdigit (c
)))
2740 value
= 8 * value
+ c
- '0';
2747 && (c
= *(*s
)++, isdigit (c
)))
2748 value
= 10 * value
+ c
- '0';
2756 else if (isalpha (c
) || c
== '_')
2760 && (c
= *(*s
)++, (isalnum (c
) || c
== '_')))
2767 else if (c
== '/' && **s
== '*')
2769 /* C-style comment. */
2771 while (**s
&& (**s
!= '*' || *(*s
+ 1) != '/'))
2785 /* Create a Windows bitmap from X bitmap data. */
2787 w32_create_pixmap_from_bitmap_data (int width
, int height
, char *data
)
2789 static unsigned char swap_nibble
[16]
2790 = { 0x0, 0x8, 0x4, 0xc, /* 0000 1000 0100 1100 */
2791 0x2, 0xa, 0x6, 0xe, /* 0010 1010 0110 1110 */
2792 0x1, 0x9, 0x5, 0xd, /* 0001 1001 0101 1101 */
2793 0x3, 0xb, 0x7, 0xf }; /* 0011 1011 0111 1111 */
2795 unsigned char *bits
, *p
;
2798 w1
= (width
+ 7) / 8; /* nb of 8bits elt in X bitmap */
2799 w2
= ((width
+ 15) / 16) * 2; /* nb of 16bits elt in W32 bitmap */
2800 bits
= (unsigned char *) alloca (height
* w2
);
2801 bzero (bits
, height
* w2
);
2802 for (i
= 0; i
< height
; i
++)
2805 for (j
= 0; j
< w1
; j
++)
2807 /* Bitswap XBM bytes to match how Windows does things. */
2808 unsigned char c
= *data
++;
2809 *p
++ = (unsigned char)((swap_nibble
[c
& 0xf] << 4)
2810 | (swap_nibble
[(c
>>4) & 0xf]));
2813 bmp
= CreateBitmap (width
, height
, 1, 1, (char *) bits
);
2818 static void convert_mono_to_color_image (f
, img
, foreground
, background
)
2821 COLORREF foreground
, background
;
2823 HDC hdc
, old_img_dc
, new_img_dc
;
2824 HGDIOBJ old_prev
, new_prev
;
2827 hdc
= get_frame_dc (f
);
2828 old_img_dc
= CreateCompatibleDC (hdc
);
2829 new_img_dc
= CreateCompatibleDC (hdc
);
2830 new_pixmap
= CreateCompatibleBitmap (hdc
, img
->width
, img
->height
);
2831 release_frame_dc (f
, hdc
);
2832 old_prev
= SelectObject (old_img_dc
, img
->pixmap
);
2833 new_prev
= SelectObject (new_img_dc
, new_pixmap
);
2834 SetTextColor (new_img_dc
, foreground
);
2835 SetBkColor (new_img_dc
, background
);
2837 BitBlt (new_img_dc
, 0, 0, img
->width
, img
->height
, old_img_dc
,
2840 SelectObject (old_img_dc
, old_prev
);
2841 SelectObject (new_img_dc
, new_prev
);
2842 DeleteDC (old_img_dc
);
2843 DeleteDC (new_img_dc
);
2844 DeleteObject (img
->pixmap
);
2845 if (new_pixmap
== 0)
2846 fprintf (stderr
, "Failed to convert image to color.\n");
2848 img
->pixmap
= new_pixmap
;
2851 #define XBM_BIT_SHUFFLE(b) (~(b))
2855 #define XBM_BIT_SHUFFLE(b) (b)
2857 #endif /* HAVE_NTGUI */
2861 Create_Pixmap_From_Bitmap_Data(f
, img
, data
, fg
, bg
, non_default_colors
)
2865 RGB_PIXEL_COLOR fg
, bg
;
2866 int non_default_colors
;
2870 = w32_create_pixmap_from_bitmap_data (img
->width
, img
->height
, data
);
2872 /* If colors were specified, transfer the bitmap to a color one. */
2873 if (non_default_colors
)
2874 convert_mono_to_color_image (f
, img
, fg
, bg
);
2877 = XCreatePixmapFromBitmapData (FRAME_X_DISPLAY (f
),
2880 img
->width
, img
->height
,
2882 DefaultDepthOfScreen (FRAME_X_SCREEN (f
)));
2883 #endif /* HAVE_NTGUI */
2888 /* Replacement for XReadBitmapFileData which isn't available under old
2889 X versions. CONTENTS is a pointer to a buffer to parse; END is the
2890 buffer's end. Set *WIDTH and *HEIGHT to the width and height of
2891 the image. Return in *DATA the bitmap data allocated with xmalloc.
2892 Value is non-zero if successful. DATA null means just test if
2893 CONTENTS looks like an in-memory XBM file. */
2896 xbm_read_bitmap_data (contents
, end
, width
, height
, data
)
2897 unsigned char *contents
, *end
;
2898 int *width
, *height
;
2899 unsigned char **data
;
2901 unsigned char *s
= contents
;
2902 char buffer
[BUFSIZ
];
2905 int bytes_per_line
, i
, nbytes
;
2911 LA1 = xbm_scan (&s, end, buffer, &value)
2913 #define expect(TOKEN) \
2914 if (LA1 != (TOKEN)) \
2919 #define expect_ident(IDENT) \
2920 if (LA1 == XBM_TK_IDENT && strcmp (buffer, (IDENT)) == 0) \
2925 *width
= *height
= -1;
2928 LA1
= xbm_scan (&s
, end
, buffer
, &value
);
2930 /* Parse defines for width, height and hot-spots. */
2934 expect_ident ("define");
2935 expect (XBM_TK_IDENT
);
2937 if (LA1
== XBM_TK_NUMBER
);
2939 char *p
= strrchr (buffer
, '_');
2940 p
= p
? p
+ 1 : buffer
;
2941 if (strcmp (p
, "width") == 0)
2943 else if (strcmp (p
, "height") == 0)
2946 expect (XBM_TK_NUMBER
);
2949 if (*width
< 0 || *height
< 0)
2951 else if (data
== NULL
)
2954 /* Parse bits. Must start with `static'. */
2955 expect_ident ("static");
2956 if (LA1
== XBM_TK_IDENT
)
2958 if (strcmp (buffer
, "unsigned") == 0)
2961 expect_ident ("char");
2963 else if (strcmp (buffer
, "short") == 0)
2967 if (*width
% 16 && *width
% 16 < 9)
2970 else if (strcmp (buffer
, "char") == 0)
2978 expect (XBM_TK_IDENT
);
2984 bytes_per_line
= (*width
+ 7) / 8 + padding_p
;
2985 nbytes
= bytes_per_line
* *height
;
2986 p
= *data
= (char *) xmalloc (nbytes
);
2990 for (i
= 0; i
< nbytes
; i
+= 2)
2993 expect (XBM_TK_NUMBER
);
2995 *p
++ = XBM_BIT_SHUFFLE (val
);
2996 if (!padding_p
|| ((i
+ 2) % bytes_per_line
))
2997 *p
++ = XBM_BIT_SHUFFLE (value
>> 8);
2999 if (LA1
== ',' || LA1
== '}')
3007 for (i
= 0; i
< nbytes
; ++i
)
3010 expect (XBM_TK_NUMBER
);
3012 *p
++ = XBM_BIT_SHUFFLE (val
);
3014 if (LA1
== ',' || LA1
== '}')
3039 /* Load XBM image IMG which will be displayed on frame F from buffer
3040 CONTENTS. END is the end of the buffer. Value is non-zero if
3044 xbm_load_image (f
, img
, contents
, end
)
3047 unsigned char *contents
, *end
;
3050 unsigned char *data
;
3053 rc
= xbm_read_bitmap_data (contents
, end
, &img
->width
, &img
->height
, &data
);
3056 unsigned long foreground
= FRAME_FOREGROUND_PIXEL (f
);
3057 unsigned long background
= FRAME_BACKGROUND_PIXEL (f
);
3058 int non_default_colors
= 0;
3061 xassert (img
->width
> 0 && img
->height
> 0);
3063 /* Get foreground and background colors, maybe allocate colors. */
3064 value
= image_spec_value (img
->spec
, QCforeground
, NULL
);
3067 foreground
= x_alloc_image_color (f
, img
, value
, foreground
);
3068 non_default_colors
= 1;
3070 value
= image_spec_value (img
->spec
, QCbackground
, NULL
);
3073 background
= x_alloc_image_color (f
, img
, value
, background
);
3074 img
->background
= background
;
3075 img
->background_valid
= 1;
3076 non_default_colors
= 1;
3079 Create_Pixmap_From_Bitmap_Data (f
, img
, data
,
3080 foreground
, background
,
3081 non_default_colors
);
3084 if (img
->pixmap
== NO_PIXMAP
)
3086 x_clear_image (f
, img
);
3087 image_error ("Unable to create X pixmap for `%s'", img
->spec
, Qnil
);
3093 image_error ("Error loading XBM image `%s'", img
->spec
, Qnil
);
3099 /* Value is non-zero if DATA looks like an in-memory XBM file. */
3106 return (STRINGP (data
)
3107 && xbm_read_bitmap_data (SDATA (data
),
3114 /* Fill image IMG which is used on frame F with pixmap data. Value is
3115 non-zero if successful. */
3123 Lisp_Object file_name
;
3125 xassert (xbm_image_p (img
->spec
));
3127 /* If IMG->spec specifies a file name, create a non-file spec from it. */
3128 file_name
= image_spec_value (img
->spec
, QCfile
, NULL
);
3129 if (STRINGP (file_name
))
3132 unsigned char *contents
;
3134 struct gcpro gcpro1
;
3136 file
= x_find_image_file (file_name
);
3138 if (!STRINGP (file
))
3140 image_error ("Cannot find image file `%s'", file_name
, Qnil
);
3145 contents
= slurp_file (SDATA (file
), &size
);
3146 if (contents
== NULL
)
3148 image_error ("Error loading XBM image `%s'", img
->spec
, Qnil
);
3153 success_p
= xbm_load_image (f
, img
, contents
, contents
+ size
);
3158 struct image_keyword fmt
[XBM_LAST
];
3160 unsigned long foreground
= FRAME_FOREGROUND_PIXEL (f
);
3161 unsigned long background
= FRAME_BACKGROUND_PIXEL (f
);
3162 int non_default_colors
= 0;
3165 int in_memory_file_p
= 0;
3167 /* See if data looks like an in-memory XBM file. */
3168 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
3169 in_memory_file_p
= xbm_file_p (data
);
3171 /* Parse the image specification. */
3172 bcopy (xbm_format
, fmt
, sizeof fmt
);
3173 parsed_p
= parse_image_spec (img
->spec
, fmt
, XBM_LAST
, Qxbm
);
3176 /* Get specified width, and height. */
3177 if (!in_memory_file_p
)
3179 img
->width
= XFASTINT (fmt
[XBM_WIDTH
].value
);
3180 img
->height
= XFASTINT (fmt
[XBM_HEIGHT
].value
);
3181 xassert (img
->width
> 0 && img
->height
> 0);
3184 /* Get foreground and background colors, maybe allocate colors. */
3185 if (fmt
[XBM_FOREGROUND
].count
3186 && STRINGP (fmt
[XBM_FOREGROUND
].value
))
3188 foreground
= x_alloc_image_color (f
, img
, fmt
[XBM_FOREGROUND
].value
,
3190 non_default_colors
= 1;
3193 if (fmt
[XBM_BACKGROUND
].count
3194 && STRINGP (fmt
[XBM_BACKGROUND
].value
))
3196 background
= x_alloc_image_color (f
, img
, fmt
[XBM_BACKGROUND
].value
,
3198 non_default_colors
= 1;
3201 if (in_memory_file_p
)
3202 success_p
= xbm_load_image (f
, img
, SDATA (data
),
3211 int nbytes
= (img
->width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
;
3213 p
= bits
= (char *) alloca (nbytes
* img
->height
);
3214 for (i
= 0; i
< img
->height
; ++i
, p
+= nbytes
)
3216 Lisp_Object line
= XVECTOR (data
)->contents
[i
];
3218 bcopy (SDATA (line
), p
, nbytes
);
3220 bcopy (XBOOL_VECTOR (line
)->data
, p
, nbytes
);
3223 else if (STRINGP (data
))
3224 bits
= SDATA (data
);
3226 bits
= XBOOL_VECTOR (data
)->data
;
3228 /* Create the pixmap. */
3230 Create_Pixmap_From_Bitmap_Data (f
, img
, bits
,
3231 foreground
, background
,
3232 non_default_colors
);
3237 image_error ("Unable to create pixmap for XBM image `%s'",
3239 x_clear_image (f
, img
);
3249 /***********************************************************************
3251 ***********************************************************************/
3253 #if defined (HAVE_XPM) || defined (MAC_OS)
3255 static int xpm_image_p
P_ ((Lisp_Object object
));
3256 static int xpm_load
P_ ((struct frame
*f
, struct image
*img
));
3257 static int xpm_valid_color_symbols_p
P_ ((Lisp_Object
));
3259 #endif /* HAVE_XPM || MAC_OS */
3263 /* Indicate to xpm.h that we don't have Xlib. */
3265 /* simx.h in xpm defines XColor and XImage differently than Emacs. */
3266 /* It also defines Display the same way as Emacs, but gcc 3.3 still barfs. */
3267 #define XColor xpm_XColor
3268 #define XImage xpm_XImage
3269 #define Display xpm_Display
3270 #define PIXEL_ALREADY_TYPEDEFED
3271 #include "X11/xpm.h"
3276 #undef PIXEL_ALREADY_TYPEDEFED
3278 #include "X11/xpm.h"
3279 #endif /* HAVE_NTGUI */
3280 #endif /* HAVE_XPM */
3282 #if defined (HAVE_XPM) || defined (MAC_OS)
3283 /* The symbol `xpm' identifying XPM-format images. */
3287 /* Indices of image specification fields in xpm_format, below. */
3289 enum xpm_keyword_index
3305 /* Vector of image_keyword structures describing the format
3306 of valid XPM image specifications. */
3308 static struct image_keyword xpm_format
[XPM_LAST
] =
3310 {":type", IMAGE_SYMBOL_VALUE
, 1},
3311 {":file", IMAGE_STRING_VALUE
, 0},
3312 {":data", IMAGE_STRING_VALUE
, 0},
3313 {":ascent", IMAGE_ASCENT_VALUE
, 0},
3314 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
3315 {":relief", IMAGE_INTEGER_VALUE
, 0},
3316 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3317 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3318 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3319 {":color-symbols", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3320 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
3323 /* Structure describing the image type XPM. */
3325 static struct image_type xpm_type
=
3334 #ifdef HAVE_X_WINDOWS
3336 /* Define ALLOC_XPM_COLORS if we can use Emacs' own color allocation
3337 functions for allocating image colors. Our own functions handle
3338 color allocation failures more gracefully than the ones on the XPM
3341 #if defined XpmAllocColor && defined XpmFreeColors && defined XpmColorClosure
3342 #define ALLOC_XPM_COLORS
3344 #endif /* HAVE_X_WINDOWS */
3346 #ifdef ALLOC_XPM_COLORS
3348 static void xpm_init_color_cache
P_ ((struct frame
*, XpmAttributes
*));
3349 static void xpm_free_color_cache
P_ ((void));
3350 static int xpm_lookup_color
P_ ((struct frame
*, char *, XColor
*));
3351 static int xpm_color_bucket
P_ ((char *));
3352 static struct xpm_cached_color
*xpm_cache_color
P_ ((struct frame
*, char *,
3355 /* An entry in a hash table used to cache color definitions of named
3356 colors. This cache is necessary to speed up XPM image loading in
3357 case we do color allocations ourselves. Without it, we would need
3358 a call to XParseColor per pixel in the image. */
3360 struct xpm_cached_color
3362 /* Next in collision chain. */
3363 struct xpm_cached_color
*next
;
3365 /* Color definition (RGB and pixel color). */
3372 /* The hash table used for the color cache, and its bucket vector
3375 #define XPM_COLOR_CACHE_BUCKETS 1001
3376 struct xpm_cached_color
**xpm_color_cache
;
3378 /* Initialize the color cache. */
3381 xpm_init_color_cache (f
, attrs
)
3383 XpmAttributes
*attrs
;
3385 size_t nbytes
= XPM_COLOR_CACHE_BUCKETS
* sizeof *xpm_color_cache
;
3386 xpm_color_cache
= (struct xpm_cached_color
**) xmalloc (nbytes
);
3387 memset (xpm_color_cache
, 0, nbytes
);
3388 init_color_table ();
3390 if (attrs
->valuemask
& XpmColorSymbols
)
3395 for (i
= 0; i
< attrs
->numsymbols
; ++i
)
3396 if (XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
3397 attrs
->colorsymbols
[i
].value
, &color
))
3399 color
.pixel
= lookup_rgb_color (f
, color
.red
, color
.green
,
3401 xpm_cache_color (f
, attrs
->colorsymbols
[i
].name
, &color
, -1);
3406 /* Free the color cache. */
3409 xpm_free_color_cache ()
3411 struct xpm_cached_color
*p
, *next
;
3414 for (i
= 0; i
< XPM_COLOR_CACHE_BUCKETS
; ++i
)
3415 for (p
= xpm_color_cache
[i
]; p
; p
= next
)
3421 xfree (xpm_color_cache
);
3422 xpm_color_cache
= NULL
;
3423 free_color_table ();
3426 /* Return the bucket index for color named COLOR_NAME in the color
3430 xpm_color_bucket (color_name
)
3436 for (s
= color_name
; *s
; ++s
)
3438 return h
%= XPM_COLOR_CACHE_BUCKETS
;
3442 /* On frame F, cache values COLOR for color with name COLOR_NAME.
3443 BUCKET, if >= 0, is a precomputed bucket index. Value is the cache
3446 static struct xpm_cached_color
*
3447 xpm_cache_color (f
, color_name
, color
, bucket
)
3454 struct xpm_cached_color
*p
;
3457 bucket
= xpm_color_bucket (color_name
);
3459 nbytes
= sizeof *p
+ strlen (color_name
);
3460 p
= (struct xpm_cached_color
*) xmalloc (nbytes
);
3461 strcpy (p
->name
, color_name
);
3463 p
->next
= xpm_color_cache
[bucket
];
3464 xpm_color_cache
[bucket
] = p
;
3468 /* Look up color COLOR_NAME for frame F in the color cache. If found,
3469 return the cached definition in *COLOR. Otherwise, make a new
3470 entry in the cache and allocate the color. Value is zero if color
3471 allocation failed. */
3474 xpm_lookup_color (f
, color_name
, color
)
3479 struct xpm_cached_color
*p
;
3480 int h
= xpm_color_bucket (color_name
);
3482 for (p
= xpm_color_cache
[h
]; p
; p
= p
->next
)
3483 if (strcmp (p
->name
, color_name
) == 0)
3488 else if (XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
3491 color
->pixel
= lookup_rgb_color (f
, color
->red
, color
->green
,
3493 p
= xpm_cache_color (f
, color_name
, color
, h
);
3495 /* You get `opaque' at least from ImageMagick converting pbm to xpm
3496 with transparency, and it's useful. */
3497 else if (strcmp ("opaque", color_name
) == 0)
3499 bzero (color
, sizeof (XColor
)); /* Is this necessary/correct? */
3500 color
->pixel
= FRAME_FOREGROUND_PIXEL (f
);
3501 p
= xpm_cache_color (f
, color_name
, color
, h
);
3508 /* Callback for allocating color COLOR_NAME. Called from the XPM lib.
3509 CLOSURE is a pointer to the frame on which we allocate the
3510 color. Return in *COLOR the allocated color. Value is non-zero
3514 xpm_alloc_color (dpy
, cmap
, color_name
, color
, closure
)
3521 return xpm_lookup_color ((struct frame
*) closure
, color_name
, color
);
3525 /* Callback for freeing NPIXELS colors contained in PIXELS. CLOSURE
3526 is a pointer to the frame on which we allocate the color. Value is
3527 non-zero if successful. */
3530 xpm_free_colors (dpy
, cmap
, pixels
, npixels
, closure
)
3540 #endif /* ALLOC_XPM_COLORS */
3545 /* XPM library details. */
3547 DEF_IMGLIB_FN (XpmFreeAttributes
);
3548 DEF_IMGLIB_FN (XpmCreateImageFromBuffer
);
3549 DEF_IMGLIB_FN (XpmReadFileToImage
);
3550 DEF_IMGLIB_FN (XImageFree
);
3553 init_xpm_functions (Lisp_Object libraries
)
3557 if (!(library
= w32_delayed_load (libraries
, Qxpm
)))
3560 LOAD_IMGLIB_FN (library
, XpmFreeAttributes
);
3561 LOAD_IMGLIB_FN (library
, XpmCreateImageFromBuffer
);
3562 LOAD_IMGLIB_FN (library
, XpmReadFileToImage
);
3563 LOAD_IMGLIB_FN (library
, XImageFree
);
3567 #endif /* HAVE_NTGUI */
3570 /* Value is non-zero if COLOR_SYMBOLS is a valid color symbols list
3571 for XPM images. Such a list must consist of conses whose car and
3575 xpm_valid_color_symbols_p (color_symbols
)
3576 Lisp_Object color_symbols
;
3578 while (CONSP (color_symbols
))
3580 Lisp_Object sym
= XCAR (color_symbols
);
3582 || !STRINGP (XCAR (sym
))
3583 || !STRINGP (XCDR (sym
)))
3585 color_symbols
= XCDR (color_symbols
);
3588 return NILP (color_symbols
);
3592 /* Value is non-zero if OBJECT is a valid XPM image specification. */
3595 xpm_image_p (object
)
3598 struct image_keyword fmt
[XPM_LAST
];
3599 bcopy (xpm_format
, fmt
, sizeof fmt
);
3600 return (parse_image_spec (object
, fmt
, XPM_LAST
, Qxpm
)
3601 /* Either `:file' or `:data' must be present. */
3602 && fmt
[XPM_FILE
].count
+ fmt
[XPM_DATA
].count
== 1
3603 /* Either no `:color-symbols' or it's a list of conses
3604 whose car and cdr are strings. */
3605 && (fmt
[XPM_COLOR_SYMBOLS
].count
== 0
3606 || xpm_valid_color_symbols_p (fmt
[XPM_COLOR_SYMBOLS
].value
)));
3609 #endif /* HAVE_XPM || MAC_OS */
3611 /* Load image IMG which will be displayed on frame F. Value is
3612 non-zero if successful. */
3622 XpmAttributes attrs
;
3623 Lisp_Object specified_file
, color_symbols
;
3626 xpm_XImage
* xpm_image
= NULL
, * xpm_mask
= NULL
;
3627 #endif /* HAVE_NTGUI */
3629 /* Configure the XPM lib. Use the visual of frame F. Allocate
3630 close colors. Return colors allocated. */
3631 bzero (&attrs
, sizeof attrs
);
3634 attrs
.visual
= FRAME_X_VISUAL (f
);
3635 attrs
.colormap
= FRAME_X_COLORMAP (f
);
3636 attrs
.valuemask
|= XpmVisual
;
3637 attrs
.valuemask
|= XpmColormap
;
3638 #endif /* HAVE_NTGUI */
3640 #ifdef ALLOC_XPM_COLORS
3641 /* Allocate colors with our own functions which handle
3642 failing color allocation more gracefully. */
3643 attrs
.color_closure
= f
;
3644 attrs
.alloc_color
= xpm_alloc_color
;
3645 attrs
.free_colors
= xpm_free_colors
;
3646 attrs
.valuemask
|= XpmAllocColor
| XpmFreeColors
| XpmColorClosure
;
3647 #else /* not ALLOC_XPM_COLORS */
3648 /* Let the XPM lib allocate colors. */
3649 attrs
.valuemask
|= XpmReturnAllocPixels
;
3650 #ifdef XpmAllocCloseColors
3651 attrs
.alloc_close_colors
= 1;
3652 attrs
.valuemask
|= XpmAllocCloseColors
;
3653 #else /* not XpmAllocCloseColors */
3654 attrs
.closeness
= 600;
3655 attrs
.valuemask
|= XpmCloseness
;
3656 #endif /* not XpmAllocCloseColors */
3657 #endif /* ALLOC_XPM_COLORS */
3659 /* If image specification contains symbolic color definitions, add
3660 these to `attrs'. */
3661 color_symbols
= image_spec_value (img
->spec
, QCcolor_symbols
, NULL
);
3662 if (CONSP (color_symbols
))
3665 XpmColorSymbol
*xpm_syms
;
3668 attrs
.valuemask
|= XpmColorSymbols
;
3670 /* Count number of symbols. */
3671 attrs
.numsymbols
= 0;
3672 for (tail
= color_symbols
; CONSP (tail
); tail
= XCDR (tail
))
3675 /* Allocate an XpmColorSymbol array. */
3676 size
= attrs
.numsymbols
* sizeof *xpm_syms
;
3677 xpm_syms
= (XpmColorSymbol
*) alloca (size
);
3678 bzero (xpm_syms
, size
);
3679 attrs
.colorsymbols
= xpm_syms
;
3681 /* Fill the color symbol array. */
3682 for (tail
= color_symbols
, i
= 0;
3684 ++i
, tail
= XCDR (tail
))
3686 Lisp_Object name
= XCAR (XCAR (tail
));
3687 Lisp_Object color
= XCDR (XCAR (tail
));
3688 xpm_syms
[i
].name
= (char *) alloca (SCHARS (name
) + 1);
3689 strcpy (xpm_syms
[i
].name
, SDATA (name
));
3690 xpm_syms
[i
].value
= (char *) alloca (SCHARS (color
) + 1);
3691 strcpy (xpm_syms
[i
].value
, SDATA (color
));
3695 /* Create a pixmap for the image, either from a file, or from a
3696 string buffer containing data in the same format as an XPM file. */
3697 #ifdef ALLOC_XPM_COLORS
3698 xpm_init_color_cache (f
, &attrs
);
3701 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
3705 HDC frame_dc
= get_frame_dc (f
);
3706 hdc
= CreateCompatibleDC (frame_dc
);
3707 release_frame_dc (f
, frame_dc
);
3709 #endif /* HAVE_NTGUI */
3711 if (STRINGP (specified_file
))
3713 Lisp_Object file
= x_find_image_file (specified_file
);
3714 if (!STRINGP (file
))
3716 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
3721 /* XpmReadFileToPixmap is not available in the Windows port of
3722 libxpm. But XpmReadFileToImage almost does what we want. */
3723 rc
= fn_XpmReadFileToImage (&hdc
, SDATA (file
),
3724 &xpm_image
, &xpm_mask
,
3727 rc
= XpmReadFileToPixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3728 SDATA (file
), &img
->pixmap
, &img
->mask
,
3730 #endif /* HAVE_NTGUI */
3734 Lisp_Object buffer
= image_spec_value (img
->spec
, QCdata
, NULL
);
3736 /* XpmCreatePixmapFromBuffer is not available in the Windows port
3737 of libxpm. But XpmCreateImageFromBuffer almost does what we want. */
3738 rc
= fn_XpmCreateImageFromBuffer (&hdc
, SDATA (buffer
),
3739 &xpm_image
, &xpm_mask
,
3742 rc
= XpmCreatePixmapFromBuffer (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3744 &img
->pixmap
, &img
->mask
,
3746 #endif /* HAVE_NTGUI */
3749 if (rc
== XpmSuccess
)
3751 #if defined (COLOR_TABLE_SUPPORT) && defined (ALLOC_XPM_COLORS)
3752 img
->colors
= colors_in_color_table (&img
->ncolors
);
3753 #else /* not ALLOC_XPM_COLORS */
3757 /* W32 XPM uses XImage to wrap what W32 Emacs calls a Pixmap,
3758 plus some duplicate attributes. */
3759 if (xpm_image
&& xpm_image
->bitmap
)
3761 img
->pixmap
= xpm_image
->bitmap
;
3762 /* XImageFree in libXpm frees XImage struct without destroying
3763 the bitmap, which is what we want. */
3764 fn_XImageFree (xpm_image
);
3766 if (xpm_mask
&& xpm_mask
->bitmap
)
3768 /* The mask appears to be inverted compared with what we expect.
3769 TODO: invert our expectations. See other places where we
3770 have to invert bits because our idea of masks is backwards. */
3772 old_obj
= SelectObject (hdc
, xpm_mask
->bitmap
);
3774 PatBlt (hdc
, 0, 0, xpm_mask
->width
, xpm_mask
->height
, DSTINVERT
);
3775 SelectObject (hdc
, old_obj
);
3777 img
->mask
= xpm_mask
->bitmap
;
3778 fn_XImageFree (xpm_mask
);
3783 #endif /* HAVE_NTGUI */
3785 /* Remember allocated colors. */
3786 img
->ncolors
= attrs
.nalloc_pixels
;
3787 img
->colors
= (unsigned long *) xmalloc (img
->ncolors
3788 * sizeof *img
->colors
);
3789 for (i
= 0; i
< attrs
.nalloc_pixels
; ++i
)
3791 img
->colors
[i
] = attrs
.alloc_pixels
[i
];
3792 #ifdef DEBUG_X_COLORS
3793 register_color (img
->colors
[i
]);
3796 #endif /* not ALLOC_XPM_COLORS */
3798 img
->width
= attrs
.width
;
3799 img
->height
= attrs
.height
;
3800 xassert (img
->width
> 0 && img
->height
> 0);
3802 /* The call to XpmFreeAttributes below frees attrs.alloc_pixels. */
3804 fn_XpmFreeAttributes (&attrs
);
3806 XpmFreeAttributes (&attrs
);
3807 #endif /* HAVE_NTGUI */
3813 #endif /* HAVE_NTGUI */
3818 image_error ("Error opening XPM file (%s)", img
->spec
, Qnil
);
3821 case XpmFileInvalid
:
3822 image_error ("Invalid XPM file (%s)", img
->spec
, Qnil
);
3826 image_error ("Out of memory (%s)", img
->spec
, Qnil
);
3829 case XpmColorFailed
:
3830 image_error ("Color allocation error (%s)", img
->spec
, Qnil
);
3834 image_error ("Unknown error (%s)", img
->spec
, Qnil
);
3839 #ifdef ALLOC_XPM_COLORS
3840 xpm_free_color_cache ();
3842 return rc
== XpmSuccess
;
3845 #endif /* HAVE_XPM */
3849 /* XPM support functions for Mac OS where libxpm is not available.
3850 Only XPM version 3 (without any extensions) is supported. */
3852 static int xpm_scan
P_ ((unsigned char **, unsigned char *,
3853 unsigned char **, int *));
3854 static Lisp_Object xpm_make_color_table_v
3855 P_ ((void (**) (Lisp_Object
, unsigned char *, int, Lisp_Object
),
3856 Lisp_Object (**) (Lisp_Object
, unsigned char *, int)));
3857 static void xpm_put_color_table_v
P_ ((Lisp_Object
, unsigned char *,
3859 static Lisp_Object xpm_get_color_table_v
P_ ((Lisp_Object
,
3860 unsigned char *, int));
3861 static Lisp_Object xpm_make_color_table_h
3862 P_ ((void (**) (Lisp_Object
, unsigned char *, int, Lisp_Object
),
3863 Lisp_Object (**) (Lisp_Object
, unsigned char *, int)));
3864 static void xpm_put_color_table_h
P_ ((Lisp_Object
, unsigned char *,
3866 static Lisp_Object xpm_get_color_table_h
P_ ((Lisp_Object
,
3867 unsigned char *, int));
3868 static int xpm_str_to_color_key
P_ ((char *));
3869 static int xpm_load_image
P_ ((struct frame
*, struct image
*,
3870 unsigned char *, unsigned char *));
3872 /* Tokens returned from xpm_scan. */
3881 /* Scan an XPM data and return a character (< 256) or a token defined
3882 by enum xpm_token above. *S and END are the start (inclusive) and
3883 the end (exclusive) addresses of the data, respectively. Advance
3884 *S while scanning. If token is either XPM_TK_IDENT or
3885 XPM_TK_STRING, *BEG and *LEN are set to the start address and the
3886 length of the corresponding token, respectively. */
3889 xpm_scan (s
, end
, beg
, len
)
3890 unsigned char **s
, *end
, **beg
;
3897 /* Skip white-space. */
3898 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
3901 /* gnus-pointer.xpm uses '-' in its identifier.
3902 sb-dir-plus.xpm uses '+' in its identifier. */
3903 if (isalpha (c
) || c
== '_' || c
== '-' || c
== '+')
3907 (c
= **s
, isalnum (c
) || c
== '_' || c
== '-' || c
== '+'))
3910 return XPM_TK_IDENT
;
3915 while (*s
< end
&& **s
!= '"')
3920 return XPM_TK_STRING
;
3924 if (*s
< end
&& **s
== '*')
3926 /* C-style comment. */
3930 while (*s
< end
&& *(*s
)++ != '*')
3933 while (*s
< end
&& **s
!= '/');
3947 /* Functions for color table lookup in XPM data. A Key is a string
3948 specifying the color of each pixel in XPM data. A value is either
3949 an integer that specifies a pixel color, Qt that specifies
3950 transparency, or Qnil for the unspecified color. If the length of
3951 the key string is one, a vector is used as a table. Otherwise, a
3952 hash table is used. */
3955 xpm_make_color_table_v (put_func
, get_func
)
3956 void (**put_func
) (Lisp_Object
, unsigned char *, int, Lisp_Object
);
3957 Lisp_Object (**get_func
) (Lisp_Object
, unsigned char *, int);
3959 *put_func
= xpm_put_color_table_v
;
3960 *get_func
= xpm_get_color_table_v
;
3961 return Fmake_vector (make_number (256), Qnil
);
3965 xpm_put_color_table_v (color_table
, chars_start
, chars_len
, color
)
3966 Lisp_Object color_table
;
3967 unsigned char *chars_start
;
3971 XVECTOR (color_table
)->contents
[*chars_start
] = color
;
3975 xpm_get_color_table_v (color_table
, chars_start
, chars_len
)
3976 Lisp_Object color_table
;
3977 unsigned char *chars_start
;
3980 return XVECTOR (color_table
)->contents
[*chars_start
];
3984 xpm_make_color_table_h (put_func
, get_func
)
3985 void (**put_func
) (Lisp_Object
, unsigned char *, int, Lisp_Object
);
3986 Lisp_Object (**get_func
) (Lisp_Object
, unsigned char *, int);
3988 *put_func
= xpm_put_color_table_h
;
3989 *get_func
= xpm_get_color_table_h
;
3990 return make_hash_table (Qequal
, make_number (DEFAULT_HASH_SIZE
),
3991 make_float (DEFAULT_REHASH_SIZE
),
3992 make_float (DEFAULT_REHASH_THRESHOLD
),
3997 xpm_put_color_table_h (color_table
, chars_start
, chars_len
, color
)
3998 Lisp_Object color_table
;
3999 unsigned char *chars_start
;
4003 struct Lisp_Hash_Table
*table
= XHASH_TABLE (color_table
);
4005 Lisp_Object chars
= make_unibyte_string (chars_start
, chars_len
);
4007 hash_lookup (table
, chars
, &hash_code
);
4008 hash_put (table
, chars
, color
, hash_code
);
4012 xpm_get_color_table_h (color_table
, chars_start
, chars_len
)
4013 Lisp_Object color_table
;
4014 unsigned char *chars_start
;
4017 struct Lisp_Hash_Table
*table
= XHASH_TABLE (color_table
);
4018 int i
= hash_lookup (table
, make_unibyte_string (chars_start
, chars_len
),
4021 return i
>= 0 ? HASH_VALUE (table
, i
) : Qnil
;
4024 enum xpm_color_key
{
4032 static char xpm_color_key_strings
[][4] = {"s", "m", "g4", "g", "c"};
4035 xpm_str_to_color_key (s
)
4041 i
< sizeof xpm_color_key_strings
/ sizeof xpm_color_key_strings
[0];
4043 if (strcmp (xpm_color_key_strings
[i
], s
) == 0)
4049 xpm_load_image (f
, img
, contents
, end
)
4052 unsigned char *contents
, *end
;
4054 unsigned char *s
= contents
, *beg
, *str
;
4055 unsigned char buffer
[BUFSIZ
];
4056 int width
, height
, x
, y
;
4057 int num_colors
, chars_per_pixel
;
4059 void (*put_color_table
) (Lisp_Object
, unsigned char *, int, Lisp_Object
);
4060 Lisp_Object (*get_color_table
) (Lisp_Object
, unsigned char *, int);
4061 Lisp_Object frame
, color_symbols
, color_table
;
4062 int best_key
, have_mask
= 0;
4063 XImagePtr ximg
= NULL
, mask_img
= NULL
;
4066 LA1 = xpm_scan (&s, end, &beg, &len)
4068 #define expect(TOKEN) \
4069 if (LA1 != (TOKEN)) \
4074 #define expect_ident(IDENT) \
4075 if (LA1 == XPM_TK_IDENT \
4076 && strlen ((IDENT)) == len && memcmp ((IDENT), beg, len) == 0) \
4081 if (!(end
- s
>= 9 && memcmp (s
, "/* XPM */", 9) == 0))
4085 expect_ident ("static");
4086 expect_ident ("char");
4088 expect (XPM_TK_IDENT
);
4093 expect (XPM_TK_STRING
);
4096 memcpy (buffer
, beg
, len
);
4098 if (sscanf (buffer
, "%d %d %d %d", &width
, &height
,
4099 &num_colors
, &chars_per_pixel
) != 4
4100 || width
<= 0 || height
<= 0
4101 || num_colors
<= 0 || chars_per_pixel
<= 0)
4105 XSETFRAME (frame
, f
);
4106 if (!NILP (Fxw_display_color_p (frame
)))
4107 best_key
= XPM_COLOR_KEY_C
;
4108 else if (!NILP (Fx_display_grayscale_p (frame
)))
4109 best_key
= (XFASTINT (Fx_display_planes (frame
)) > 2
4110 ? XPM_COLOR_KEY_G
: XPM_COLOR_KEY_G4
);
4112 best_key
= XPM_COLOR_KEY_M
;
4114 color_symbols
= image_spec_value (img
->spec
, QCcolor_symbols
, NULL
);
4115 if (chars_per_pixel
== 1)
4116 color_table
= xpm_make_color_table_v (&put_color_table
,
4119 color_table
= xpm_make_color_table_h (&put_color_table
,
4122 while (num_colors
-- > 0)
4124 unsigned char *color
, *max_color
;
4125 int key
, next_key
, max_key
= 0;
4126 Lisp_Object symbol_color
= Qnil
, color_val
;
4129 expect (XPM_TK_STRING
);
4130 if (len
<= chars_per_pixel
|| len
>= BUFSIZ
+ chars_per_pixel
)
4132 memcpy (buffer
, beg
+ chars_per_pixel
, len
- chars_per_pixel
);
4133 buffer
[len
- chars_per_pixel
] = '\0';
4135 str
= strtok (buffer
, " \t");
4138 key
= xpm_str_to_color_key (str
);
4143 color
= strtok (NULL
, " \t");
4147 while (str
= strtok (NULL
, " \t"))
4149 next_key
= xpm_str_to_color_key (str
);
4152 color
[strlen (color
)] = ' ';
4155 if (key
== XPM_COLOR_KEY_S
)
4157 if (NILP (symbol_color
))
4158 symbol_color
= build_string (color
);
4160 else if (max_key
< key
&& key
<= best_key
)
4170 if (!NILP (color_symbols
) && !NILP (symbol_color
))
4172 Lisp_Object specified_color
= Fassoc (symbol_color
, color_symbols
);
4174 if (CONSP (specified_color
) && STRINGP (XCDR (specified_color
)))
4175 if (xstricmp (SDATA (XCDR (specified_color
)), "None") == 0)
4177 else if (x_defined_color (f
, SDATA (XCDR (specified_color
)),
4179 color_val
= make_number (cdef
.pixel
);
4181 if (NILP (color_val
) && max_key
> 0)
4182 if (xstricmp (max_color
, "None") == 0)
4184 else if (x_defined_color (f
, max_color
, &cdef
, 0))
4185 color_val
= make_number (cdef
.pixel
);
4186 if (!NILP (color_val
))
4187 (*put_color_table
) (color_table
, beg
, chars_per_pixel
, color_val
);
4192 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0,
4193 &ximg
, &img
->pixmap
)
4194 || !x_create_x_image_and_pixmap (f
, width
, height
, 1,
4195 &mask_img
, &img
->mask
))
4197 image_error ("Out of memory (%s)", img
->spec
, Qnil
);
4201 for (y
= 0; y
< height
; y
++)
4203 expect (XPM_TK_STRING
);
4205 if (len
< width
* chars_per_pixel
)
4207 for (x
= 0; x
< width
; x
++, str
+= chars_per_pixel
)
4209 Lisp_Object color_val
=
4210 (*get_color_table
) (color_table
, str
, chars_per_pixel
);
4212 XPutPixel (ximg
, x
, y
,
4213 (INTEGERP (color_val
) ? XINT (color_val
)
4214 : FRAME_FOREGROUND_PIXEL (f
)));
4215 XPutPixel (mask_img
, x
, y
,
4216 (!EQ (color_val
, Qt
) ? PIX_MASK_DRAW (f
)
4217 : (have_mask
= 1, PIX_MASK_RETAIN (f
))));
4224 img
->height
= height
;
4226 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
4227 x_destroy_x_image (ximg
);
4230 x_put_x_image (f
, mask_img
, img
->mask
, width
, height
);
4231 x_destroy_x_image (mask_img
);
4235 x_destroy_x_image (mask_img
);
4236 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
4237 img
->mask
= NO_PIXMAP
;
4243 image_error ("Invalid XPM file (%s)", img
->spec
, Qnil
);
4245 x_destroy_x_image (ximg
);
4246 x_destroy_x_image (mask_img
);
4247 x_clear_image (f
, img
);
4261 Lisp_Object file_name
;
4263 /* If IMG->spec specifies a file name, create a non-file spec from it. */
4264 file_name
= image_spec_value (img
->spec
, QCfile
, NULL
);
4265 if (STRINGP (file_name
))
4268 unsigned char *contents
;
4270 struct gcpro gcpro1
;
4272 file
= x_find_image_file (file_name
);
4274 if (!STRINGP (file
))
4276 image_error ("Cannot find image file `%s'", file_name
, Qnil
);
4281 contents
= slurp_file (SDATA (file
), &size
);
4282 if (contents
== NULL
)
4284 image_error ("Error loading XPM image `%s'", img
->spec
, Qnil
);
4289 success_p
= xpm_load_image (f
, img
, contents
, contents
+ size
);
4297 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
4298 success_p
= xpm_load_image (f
, img
, SDATA (data
),
4299 SDATA (data
) + SBYTES (data
));
4309 /***********************************************************************
4311 ***********************************************************************/
4313 #ifdef COLOR_TABLE_SUPPORT
4315 /* An entry in the color table mapping an RGB color to a pixel color. */
4320 unsigned long pixel
;
4322 /* Next in color table collision list. */
4323 struct ct_color
*next
;
4326 /* The bucket vector size to use. Must be prime. */
4330 /* Value is a hash of the RGB color given by R, G, and B. */
4332 #define CT_HASH_RGB(R, G, B) (((R) << 16) ^ ((G) << 8) ^ (B))
4334 /* The color hash table. */
4336 struct ct_color
**ct_table
;
4338 /* Number of entries in the color table. */
4340 int ct_colors_allocated
;
4342 /* Initialize the color table. */
4347 int size
= CT_SIZE
* sizeof (*ct_table
);
4348 ct_table
= (struct ct_color
**) xmalloc (size
);
4349 bzero (ct_table
, size
);
4350 ct_colors_allocated
= 0;
4354 /* Free memory associated with the color table. */
4360 struct ct_color
*p
, *next
;
4362 for (i
= 0; i
< CT_SIZE
; ++i
)
4363 for (p
= ct_table
[i
]; p
; p
= next
)
4374 /* Value is a pixel color for RGB color R, G, B on frame F. If an
4375 entry for that color already is in the color table, return the
4376 pixel color of that entry. Otherwise, allocate a new color for R,
4377 G, B, and make an entry in the color table. */
4379 static unsigned long
4380 lookup_rgb_color (f
, r
, g
, b
)
4384 unsigned hash
= CT_HASH_RGB (r
, g
, b
);
4385 int i
= hash
% CT_SIZE
;
4387 Display_Info
*dpyinfo
;
4389 /* Handle TrueColor visuals specially, which improves performance by
4390 two orders of magnitude. Freeing colors on TrueColor visuals is
4391 a nop, and pixel colors specify RGB values directly. See also
4392 the Xlib spec, chapter 3.1. */
4393 dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
4394 if (dpyinfo
->red_bits
> 0)
4396 unsigned long pr
, pg
, pb
;
4398 /* Apply gamma-correction like normal color allocation does. */
4402 color
.red
= r
, color
.green
= g
, color
.blue
= b
;
4403 gamma_correct (f
, &color
);
4404 r
= color
.red
, g
= color
.green
, b
= color
.blue
;
4407 /* Scale down RGB values to the visual's bits per RGB, and shift
4408 them to the right position in the pixel color. Note that the
4409 original RGB values are 16-bit values, as usual in X. */
4410 pr
= (r
>> (16 - dpyinfo
->red_bits
)) << dpyinfo
->red_offset
;
4411 pg
= (g
>> (16 - dpyinfo
->green_bits
)) << dpyinfo
->green_offset
;
4412 pb
= (b
>> (16 - dpyinfo
->blue_bits
)) << dpyinfo
->blue_offset
;
4414 /* Assemble the pixel color. */
4415 return pr
| pg
| pb
;
4418 for (p
= ct_table
[i
]; p
; p
= p
->next
)
4419 if (p
->r
== r
&& p
->g
== g
&& p
->b
== b
)
4425 #ifdef HAVE_X_WINDOWS
4434 cmap
= FRAME_X_COLORMAP (f
);
4435 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
4438 ++ct_colors_allocated
;
4439 p
= (struct ct_color
*) xmalloc (sizeof *p
);
4443 p
->pixel
= color
.pixel
;
4444 p
->next
= ct_table
[i
];
4448 return FRAME_FOREGROUND_PIXEL (f
);
4453 color
= PALETTERGB (r
, g
, b
);
4455 color
= RGB_TO_ULONG (r
, g
, b
);
4456 #endif /* HAVE_NTGUI */
4457 ++ct_colors_allocated
;
4458 p
= (struct ct_color
*) xmalloc (sizeof *p
);
4463 p
->next
= ct_table
[i
];
4465 #endif /* HAVE_X_WINDOWS */
4473 /* Look up pixel color PIXEL which is used on frame F in the color
4474 table. If not already present, allocate it. Value is PIXEL. */
4476 static unsigned long
4477 lookup_pixel_color (f
, pixel
)
4479 unsigned long pixel
;
4481 int i
= pixel
% CT_SIZE
;
4484 for (p
= ct_table
[i
]; p
; p
= p
->next
)
4485 if (p
->pixel
== pixel
)
4494 #ifdef HAVE_X_WINDOWS
4495 cmap
= FRAME_X_COLORMAP (f
);
4496 color
.pixel
= pixel
;
4497 x_query_color (f
, &color
);
4498 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
4501 cmap
= DefaultColormapOfScreen (FRAME_X_SCREEN (f
));
4502 color
.pixel
= pixel
;
4503 XQueryColor (NULL
, cmap
, &color
);
4504 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
4506 #endif /* HAVE_X_WINDOWS */
4510 ++ct_colors_allocated
;
4512 p
= (struct ct_color
*) xmalloc (sizeof *p
);
4517 p
->next
= ct_table
[i
];
4521 return FRAME_FOREGROUND_PIXEL (f
);
4527 /* Value is a vector of all pixel colors contained in the color table,
4528 allocated via xmalloc. Set *N to the number of colors. */
4530 static unsigned long *
4531 colors_in_color_table (n
)
4536 unsigned long *colors
;
4538 if (ct_colors_allocated
== 0)
4545 colors
= (unsigned long *) xmalloc (ct_colors_allocated
4547 *n
= ct_colors_allocated
;
4549 for (i
= j
= 0; i
< CT_SIZE
; ++i
)
4550 for (p
= ct_table
[i
]; p
; p
= p
->next
)
4551 colors
[j
++] = p
->pixel
;
4557 #else /* COLOR_TABLE_SUPPORT */
4559 static unsigned long
4560 lookup_rgb_color (f
, r
, g
, b
)
4564 unsigned long pixel
;
4567 pixel
= RGB_TO_ULONG (r
>> 8, g
>> 8, b
>> 8);
4568 gamma_correct (f
, &pixel
);
4572 pixel
= PALETTERGB (r
>> 8, g
>> 8, b
>> 8);
4573 #endif /* HAVE_NTGUI */
4582 #endif /* COLOR_TABLE_SUPPORT */
4585 /***********************************************************************
4587 ***********************************************************************/
4589 static XColor
*x_to_xcolors
P_ ((struct frame
*, struct image
*, int));
4590 static void x_from_xcolors
P_ ((struct frame
*, struct image
*, XColor
*));
4591 static void x_detect_edges
P_ ((struct frame
*, struct image
*, int[9], int));
4594 static void XPutPixel (XImagePtr
, int, int, COLORREF
);
4595 #endif /* HAVE_NTGUI */
4597 /* Non-zero means draw a cross on images having `:conversion
4600 int cross_disabled_images
;
4602 /* Edge detection matrices for different edge-detection
4605 static int emboss_matrix
[9] = {
4607 2, -1, 0, /* y - 1 */
4609 0, 1, -2 /* y + 1 */
4612 static int laplace_matrix
[9] = {
4614 1, 0, 0, /* y - 1 */
4616 0, 0, -1 /* y + 1 */
4619 /* Value is the intensity of the color whose red/green/blue values
4622 #define COLOR_INTENSITY(R, G, B) ((2 * (R) + 3 * (G) + (B)) / 6)
4625 /* On frame F, return an array of XColor structures describing image
4626 IMG->pixmap. Each XColor structure has its pixel color set. RGB_P
4627 non-zero means also fill the red/green/blue members of the XColor
4628 structures. Value is a pointer to the array of XColors structures,
4629 allocated with xmalloc; it must be freed by the caller. */
4632 x_to_xcolors (f
, img
, rgb_p
)
4639 XImagePtr_or_DC ximg
;
4643 #endif /* HAVE_NTGUI */
4645 colors
= (XColor
*) xmalloc (img
->width
* img
->height
* sizeof *colors
);
4648 /* Get the X image IMG->pixmap. */
4649 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
4650 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
4652 /* Load the image into a memory device context. */
4653 hdc
= get_frame_dc (f
);
4654 ximg
= CreateCompatibleDC (hdc
);
4655 release_frame_dc (f
, hdc
);
4656 prev
= SelectObject (ximg
, img
->pixmap
);
4657 #endif /* HAVE_NTGUI */
4659 /* Fill the `pixel' members of the XColor array. I wished there
4660 were an easy and portable way to circumvent XGetPixel. */
4662 for (y
= 0; y
< img
->height
; ++y
)
4666 #ifdef HAVE_X_WINDOWS
4667 for (x
= 0; x
< img
->width
; ++x
, ++p
)
4668 p
->pixel
= XGetPixel (ximg
, x
, y
);
4670 x_query_colors (f
, row
, img
->width
);
4674 for (x
= 0; x
< img
->width
; ++x
, ++p
)
4676 /* W32_TODO: palette support needed here? */
4677 p
->pixel
= GET_PIXEL (ximg
, x
, y
);
4681 p
->red
= RED16_FROM_ULONG (p
->pixel
);
4682 p
->green
= GREEN16_FROM_ULONG (p
->pixel
);
4683 p
->blue
= BLUE16_FROM_ULONG (p
->pixel
);
4686 p
->red
= 256 * GetRValue (p
->pixel
);
4687 p
->green
= 256 * GetGValue (p
->pixel
);
4688 p
->blue
= 256 * GetBValue (p
->pixel
);
4689 #endif /* HAVE_NTGUI */
4692 #endif /* HAVE_X_WINDOWS */
4695 Destroy_Image (ximg
, prev
);
4702 /* Put a pixel of COLOR at position X, Y in XIMG. XIMG must have been
4703 created with CreateDIBSection, with the pointer to the bit values
4704 stored in ximg->data. */
4706 static void XPutPixel (ximg
, x
, y
, color
)
4711 int width
= ximg
->info
.bmiHeader
.biWidth
;
4712 int height
= ximg
->info
.bmiHeader
.biHeight
;
4713 unsigned char * pixel
;
4715 /* True color images. */
4716 if (ximg
->info
.bmiHeader
.biBitCount
== 24)
4718 int rowbytes
= width
* 3;
4719 /* Ensure scanlines are aligned on 4 byte boundaries. */
4721 rowbytes
+= 4 - (rowbytes
% 4);
4723 pixel
= ximg
->data
+ y
* rowbytes
+ x
* 3;
4724 /* Windows bitmaps are in BGR order. */
4725 *pixel
= GetBValue (color
);
4726 *(pixel
+ 1) = GetGValue (color
);
4727 *(pixel
+ 2) = GetRValue (color
);
4729 /* Monochrome images. */
4730 else if (ximg
->info
.bmiHeader
.biBitCount
== 1)
4732 int rowbytes
= width
/ 8;
4733 /* Ensure scanlines are aligned on 4 byte boundaries. */
4735 rowbytes
+= 4 - (rowbytes
% 4);
4736 pixel
= ximg
->data
+ y
* rowbytes
+ x
/ 8;
4737 /* Filter out palette info. */
4738 if (color
& 0x00ffffff)
4739 *pixel
= *pixel
| (1 << x
% 8);
4741 *pixel
= *pixel
& ~(1 << x
% 8);
4744 image_error ("XPutPixel: palette image not supported", Qnil
, Qnil
);
4747 #endif /* HAVE_NTGUI */
4749 /* Create IMG->pixmap from an array COLORS of XColor structures, whose
4750 RGB members are set. F is the frame on which this all happens.
4751 COLORS will be freed; an existing IMG->pixmap will be freed, too. */
4754 x_from_xcolors (f
, img
, colors
)
4764 init_color_table ();
4766 x_create_x_image_and_pixmap (f
, img
->width
, img
->height
, 0,
4769 for (y
= 0; y
< img
->height
; ++y
)
4770 for (x
= 0; x
< img
->width
; ++x
, ++p
)
4772 unsigned long pixel
;
4773 pixel
= lookup_rgb_color (f
, p
->red
, p
->green
, p
->blue
);
4774 XPutPixel (oimg
, x
, y
, pixel
);
4778 x_clear_image_1 (f
, img
, 1, 0, 1);
4780 x_put_x_image (f
, oimg
, pixmap
, img
->width
, img
->height
);
4781 x_destroy_x_image (oimg
);
4782 img
->pixmap
= pixmap
;
4783 #ifdef COLOR_TABLE_SUPPORT
4784 img
->colors
= colors_in_color_table (&img
->ncolors
);
4785 free_color_table ();
4786 #endif /* COLOR_TABLE_SUPPORT */
4790 /* On frame F, perform edge-detection on image IMG.
4792 MATRIX is a nine-element array specifying the transformation
4793 matrix. See emboss_matrix for an example.
4795 COLOR_ADJUST is a color adjustment added to each pixel of the
4799 x_detect_edges (f
, img
, matrix
, color_adjust
)
4802 int matrix
[9], color_adjust
;
4804 XColor
*colors
= x_to_xcolors (f
, img
, 1);
4808 for (i
= sum
= 0; i
< 9; ++i
)
4809 sum
+= abs (matrix
[i
]);
4811 #define COLOR(A, X, Y) ((A) + (Y) * img->width + (X))
4813 new = (XColor
*) xmalloc (img
->width
* img
->height
* sizeof *new);
4815 for (y
= 0; y
< img
->height
; ++y
)
4817 p
= COLOR (new, 0, y
);
4818 p
->red
= p
->green
= p
->blue
= 0xffff/2;
4819 p
= COLOR (new, img
->width
- 1, y
);
4820 p
->red
= p
->green
= p
->blue
= 0xffff/2;
4823 for (x
= 1; x
< img
->width
- 1; ++x
)
4825 p
= COLOR (new, x
, 0);
4826 p
->red
= p
->green
= p
->blue
= 0xffff/2;
4827 p
= COLOR (new, x
, img
->height
- 1);
4828 p
->red
= p
->green
= p
->blue
= 0xffff/2;
4831 for (y
= 1; y
< img
->height
- 1; ++y
)
4833 p
= COLOR (new, 1, y
);
4835 for (x
= 1; x
< img
->width
- 1; ++x
, ++p
)
4837 int r
, g
, b
, y1
, x1
;
4840 for (y1
= y
- 1; y1
< y
+ 2; ++y1
)
4841 for (x1
= x
- 1; x1
< x
+ 2; ++x1
, ++i
)
4844 XColor
*t
= COLOR (colors
, x1
, y1
);
4845 r
+= matrix
[i
] * t
->red
;
4846 g
+= matrix
[i
] * t
->green
;
4847 b
+= matrix
[i
] * t
->blue
;
4850 r
= (r
/ sum
+ color_adjust
) & 0xffff;
4851 g
= (g
/ sum
+ color_adjust
) & 0xffff;
4852 b
= (b
/ sum
+ color_adjust
) & 0xffff;
4853 p
->red
= p
->green
= p
->blue
= COLOR_INTENSITY (r
, g
, b
);
4858 x_from_xcolors (f
, img
, new);
4864 /* Perform the pre-defined `emboss' edge-detection on image IMG
4872 x_detect_edges (f
, img
, emboss_matrix
, 0xffff / 2);
4876 /* Transform image IMG which is used on frame F with a Laplace
4877 edge-detection algorithm. The result is an image that can be used
4878 to draw disabled buttons, for example. */
4885 x_detect_edges (f
, img
, laplace_matrix
, 45000);
4889 /* Perform edge-detection on image IMG on frame F, with specified
4890 transformation matrix MATRIX and color-adjustment COLOR_ADJUST.
4892 MATRIX must be either
4894 - a list of at least 9 numbers in row-major form
4895 - a vector of at least 9 numbers
4897 COLOR_ADJUST nil means use a default; otherwise it must be a
4901 x_edge_detection (f
, img
, matrix
, color_adjust
)
4904 Lisp_Object matrix
, color_adjust
;
4912 i
< 9 && CONSP (matrix
) && NUMBERP (XCAR (matrix
));
4913 ++i
, matrix
= XCDR (matrix
))
4914 trans
[i
] = XFLOATINT (XCAR (matrix
));
4916 else if (VECTORP (matrix
) && ASIZE (matrix
) >= 9)
4918 for (i
= 0; i
< 9 && NUMBERP (AREF (matrix
, i
)); ++i
)
4919 trans
[i
] = XFLOATINT (AREF (matrix
, i
));
4922 if (NILP (color_adjust
))
4923 color_adjust
= make_number (0xffff / 2);
4925 if (i
== 9 && NUMBERP (color_adjust
))
4926 x_detect_edges (f
, img
, trans
, (int) XFLOATINT (color_adjust
));
4930 /* Transform image IMG on frame F so that it looks disabled. */
4933 x_disable_image (f
, img
)
4937 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
4939 int n_planes
= dpyinfo
->n_planes
* dpyinfo
->n_cbits
;
4941 int n_planes
= dpyinfo
->n_planes
;
4942 #endif /* HAVE_NTGUI */
4946 /* Color (or grayscale). Convert to gray, and equalize. Just
4947 drawing such images with a stipple can look very odd, so
4948 we're using this method instead. */
4949 XColor
*colors
= x_to_xcolors (f
, img
, 1);
4951 const int h
= 15000;
4952 const int l
= 30000;
4954 for (p
= colors
, end
= colors
+ img
->width
* img
->height
;
4958 int i
= COLOR_INTENSITY (p
->red
, p
->green
, p
->blue
);
4959 int i2
= (0xffff - h
- l
) * i
/ 0xffff + l
;
4960 p
->red
= p
->green
= p
->blue
= i2
;
4963 x_from_xcolors (f
, img
, colors
);
4966 /* Draw a cross over the disabled image, if we must or if we
4968 if (n_planes
< 2 || cross_disabled_images
)
4971 Display
*dpy
= FRAME_X_DISPLAY (f
);
4975 #define XCreateGC_pixmap(dpy, pixmap) XCreateGC (dpy, NULL, 0, NULL)
4976 #define MaskForeground(f) PIX_MASK_DRAW (f)
4978 #define XCreateGC_pixmap(dpy, pixmap) XCreateGC (dpy, pixmap, 0, NULL)
4979 #define MaskForeground(f) WHITE_PIX_DEFAULT (f)
4982 gc
= XCreateGC_pixmap (dpy
, img
->pixmap
);
4983 XSetForeground (dpy
, gc
, BLACK_PIX_DEFAULT (f
));
4984 XDrawLine (dpy
, img
->pixmap
, gc
, 0, 0,
4985 img
->width
- 1, img
->height
- 1);
4986 XDrawLine (dpy
, img
->pixmap
, gc
, 0, img
->height
- 1,
4992 gc
= XCreateGC_pixmap (dpy
, img
->mask
);
4993 XSetForeground (dpy
, gc
, MaskForeground (f
));
4994 XDrawLine (dpy
, img
->mask
, gc
, 0, 0,
4995 img
->width
- 1, img
->height
- 1);
4996 XDrawLine (dpy
, img
->mask
, gc
, 0, img
->height
- 1,
5004 hdc
= get_frame_dc (f
);
5005 bmpdc
= CreateCompatibleDC (hdc
);
5006 release_frame_dc (f
, hdc
);
5008 prev
= SelectObject (bmpdc
, img
->pixmap
);
5010 SetTextColor (bmpdc
, BLACK_PIX_DEFAULT (f
));
5011 MoveToEx (bmpdc
, 0, 0, NULL
);
5012 LineTo (bmpdc
, img
->width
- 1, img
->height
- 1);
5013 MoveToEx (bmpdc
, 0, img
->height
- 1, NULL
);
5014 LineTo (bmpdc
, img
->width
- 1, 0);
5018 SelectObject (bmpdc
, img
->mask
);
5019 SetTextColor (bmpdc
, WHITE_PIX_DEFAULT (f
));
5020 MoveToEx (bmpdc
, 0, 0, NULL
);
5021 LineTo (bmpdc
, img
->width
- 1, img
->height
- 1);
5022 MoveToEx (bmpdc
, 0, img
->height
- 1, NULL
);
5023 LineTo (bmpdc
, img
->width
- 1, 0);
5025 SelectObject (bmpdc
, prev
);
5027 #endif /* HAVE_NTGUI */
5032 /* Build a mask for image IMG which is used on frame F. FILE is the
5033 name of an image file, for error messages. HOW determines how to
5034 determine the background color of IMG. If it is a list '(R G B)',
5035 with R, G, and B being integers >= 0, take that as the color of the
5036 background. Otherwise, determine the background color of IMG
5037 heuristically. Value is non-zero if successful. */
5040 x_build_heuristic_mask (f
, img
, how
)
5045 XImagePtr_or_DC ximg
;
5053 #endif /* HAVE_NTGUI */
5054 int x
, y
, rc
, use_img_background
;
5055 unsigned long bg
= 0;
5059 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
5060 img
->mask
= NO_PIXMAP
;
5061 img
->background_transparent_valid
= 0;
5065 /* Create an image and pixmap serving as mask. */
5066 rc
= x_create_x_image_and_pixmap (f
, img
->width
, img
->height
, 1,
5067 &mask_img
, &img
->mask
);
5071 /* Get the X image of IMG->pixmap. */
5072 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
, 0, 0,
5073 img
->width
, img
->height
,
5076 /* Create the bit array serving as mask. */
5077 row_width
= (img
->width
+ 7) / 8;
5078 mask_img
= xmalloc (row_width
* img
->height
);
5079 bzero (mask_img
, row_width
* img
->height
);
5081 /* Create a memory device context for IMG->pixmap. */
5082 frame_dc
= get_frame_dc (f
);
5083 ximg
= CreateCompatibleDC (frame_dc
);
5084 release_frame_dc (f
, frame_dc
);
5085 prev
= SelectObject (ximg
, img
->pixmap
);
5086 #endif /* HAVE_NTGUI */
5088 /* Determine the background color of ximg. If HOW is `(R G B)'
5089 take that as color. Otherwise, use the image's background color. */
5090 use_img_background
= 1;
5096 for (i
= 0; i
< 3 && CONSP (how
) && NATNUMP (XCAR (how
)); ++i
)
5098 rgb
[i
] = XFASTINT (XCAR (how
)) & 0xffff;
5102 if (i
== 3 && NILP (how
))
5104 char color_name
[30];
5105 sprintf (color_name
, "#%04x%04x%04x", rgb
[0], rgb
[1], rgb
[2]);
5108 0x00ffffff & /* Filter out palette info. */
5109 #endif /* HAVE_NTGUI */
5110 x_alloc_image_color (f
, img
, build_string (color_name
), 0));
5111 use_img_background
= 0;
5115 if (use_img_background
)
5116 bg
= four_corners_best (ximg
, img
->width
, img
->height
);
5118 /* Set all bits in mask_img to 1 whose color in ximg is different
5119 from the background color bg. */
5121 for (y
= 0; y
< img
->height
; ++y
)
5122 for (x
= 0; x
< img
->width
; ++x
)
5123 XPutPixel (mask_img
, x
, y
, (XGetPixel (ximg
, x
, y
) != bg
5124 ? PIX_MASK_DRAW (f
) : PIX_MASK_RETAIN (f
)));
5126 /* Fill in the background_transparent field while we have the mask handy. */
5127 image_background_transparent (img
, f
, mask_img
);
5129 /* Put mask_img into img->mask. */
5130 x_put_x_image (f
, mask_img
, img
->mask
, img
->width
, img
->height
);
5131 x_destroy_x_image (mask_img
);
5134 for (y
= 0; y
< img
->height
; ++y
)
5135 for (x
= 0; x
< img
->width
; ++x
)
5137 COLORREF p
= GetPixel (ximg
, x
, y
);
5139 mask_img
[y
* row_width
+ x
/ 8] |= 1 << (x
% 8);
5142 /* Create the mask image. */
5143 img
->mask
= w32_create_pixmap_from_bitmap_data (img
->width
, img
->height
,
5145 /* Fill in the background_transparent field while we have the mask handy. */
5146 SelectObject (ximg
, img
->mask
);
5147 image_background_transparent (img
, f
, ximg
);
5149 /* Was: x_destroy_x_image ((XImagePtr )mask_img); which seems bogus ++kfs */
5151 #endif /* HAVE_NTGUI */
5153 Destroy_Image (ximg
, prev
);
5159 /***********************************************************************
5160 PBM (mono, gray, color)
5161 ***********************************************************************/
5163 static int pbm_image_p
P_ ((Lisp_Object object
));
5164 static int pbm_load
P_ ((struct frame
*f
, struct image
*img
));
5165 static int pbm_scan_number
P_ ((unsigned char **, unsigned char *));
5167 /* The symbol `pbm' identifying images of this type. */
5171 /* Indices of image specification fields in gs_format, below. */
5173 enum pbm_keyword_index
5189 /* Vector of image_keyword structures describing the format
5190 of valid user-defined image specifications. */
5192 static struct image_keyword pbm_format
[PBM_LAST
] =
5194 {":type", IMAGE_SYMBOL_VALUE
, 1},
5195 {":file", IMAGE_STRING_VALUE
, 0},
5196 {":data", IMAGE_STRING_VALUE
, 0},
5197 {":ascent", IMAGE_ASCENT_VALUE
, 0},
5198 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
5199 {":relief", IMAGE_INTEGER_VALUE
, 0},
5200 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5201 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5202 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5203 {":foreground", IMAGE_STRING_OR_NIL_VALUE
, 0},
5204 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
5207 /* Structure describing the image type `pbm'. */
5209 static struct image_type pbm_type
=
5219 /* Return non-zero if OBJECT is a valid PBM image specification. */
5222 pbm_image_p (object
)
5225 struct image_keyword fmt
[PBM_LAST
];
5227 bcopy (pbm_format
, fmt
, sizeof fmt
);
5229 if (!parse_image_spec (object
, fmt
, PBM_LAST
, Qpbm
))
5232 /* Must specify either :data or :file. */
5233 return fmt
[PBM_DATA
].count
+ fmt
[PBM_FILE
].count
== 1;
5237 /* Scan a decimal number from *S and return it. Advance *S while
5238 reading the number. END is the end of the string. Value is -1 at
5242 pbm_scan_number (s
, end
)
5243 unsigned char **s
, *end
;
5245 int c
= 0, val
= -1;
5249 /* Skip white-space. */
5250 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
5255 /* Skip comment to end of line. */
5256 while (*s
< end
&& (c
= *(*s
)++, c
!= '\n'))
5259 else if (isdigit (c
))
5261 /* Read decimal number. */
5263 while (*s
< end
&& (c
= *(*s
)++, isdigit (c
)))
5264 val
= 10 * val
+ c
- '0';
5276 #if 0 /* Unused. ++kfs */
5278 /* Read FILE into memory. Value is a pointer to a buffer allocated
5279 with xmalloc holding FILE's contents. Value is null if an error
5280 occurred. *SIZE is set to the size of the file. */
5283 pbm_read_file (file
, size
)
5291 if (stat (SDATA (file
), &st
) == 0
5292 && (fp
= fopen (SDATA (file
), "rb")) != NULL
5293 && (buf
= (char *) xmalloc (st
.st_size
),
5294 fread (buf
, 1, st
.st_size
, fp
) == st
.st_size
))
5313 #endif /* HAVE_NTGUI */
5315 /* Load PBM image IMG for use on frame F. */
5323 int width
, height
, max_color_idx
= 0;
5325 Lisp_Object file
, specified_file
;
5326 enum {PBM_MONO
, PBM_GRAY
, PBM_COLOR
} type
;
5327 struct gcpro gcpro1
;
5328 unsigned char *contents
= NULL
;
5329 unsigned char *end
, *p
;
5332 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
5336 if (STRINGP (specified_file
))
5338 file
= x_find_image_file (specified_file
);
5339 if (!STRINGP (file
))
5341 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
5346 contents
= slurp_file (SDATA (file
), &size
);
5347 if (contents
== NULL
)
5349 image_error ("Error reading `%s'", file
, Qnil
);
5355 end
= contents
+ size
;
5360 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
5362 end
= p
+ SBYTES (data
);
5365 /* Check magic number. */
5366 if (end
- p
< 2 || *p
++ != 'P')
5368 image_error ("Not a PBM image: `%s'", img
->spec
, Qnil
);
5378 raw_p
= 0, type
= PBM_MONO
;
5382 raw_p
= 0, type
= PBM_GRAY
;
5386 raw_p
= 0, type
= PBM_COLOR
;
5390 raw_p
= 1, type
= PBM_MONO
;
5394 raw_p
= 1, type
= PBM_GRAY
;
5398 raw_p
= 1, type
= PBM_COLOR
;
5402 image_error ("Not a PBM image: `%s'", img
->spec
, Qnil
);
5406 /* Read width, height, maximum color-component. Characters
5407 starting with `#' up to the end of a line are ignored. */
5408 width
= pbm_scan_number (&p
, end
);
5409 height
= pbm_scan_number (&p
, end
);
5411 if (type
!= PBM_MONO
)
5413 max_color_idx
= pbm_scan_number (&p
, end
);
5414 if (raw_p
&& max_color_idx
> 255)
5415 max_color_idx
= 255;
5420 || (type
!= PBM_MONO
&& max_color_idx
< 0))
5423 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0,
5424 &ximg
, &img
->pixmap
))
5427 /* Initialize the color hash table. */
5428 init_color_table ();
5430 if (type
== PBM_MONO
)
5433 struct image_keyword fmt
[PBM_LAST
];
5434 unsigned long fg
= FRAME_FOREGROUND_PIXEL (f
);
5435 unsigned long bg
= FRAME_BACKGROUND_PIXEL (f
);
5437 /* Parse the image specification. */
5438 bcopy (pbm_format
, fmt
, sizeof fmt
);
5439 parse_image_spec (img
->spec
, fmt
, PBM_LAST
, Qpbm
);
5441 /* Get foreground and background colors, maybe allocate colors. */
5442 if (fmt
[PBM_FOREGROUND
].count
5443 && STRINGP (fmt
[PBM_FOREGROUND
].value
))
5444 fg
= x_alloc_image_color (f
, img
, fmt
[PBM_FOREGROUND
].value
, fg
);
5445 if (fmt
[PBM_BACKGROUND
].count
5446 && STRINGP (fmt
[PBM_BACKGROUND
].value
))
5448 bg
= x_alloc_image_color (f
, img
, fmt
[PBM_BACKGROUND
].value
, bg
);
5449 img
->background
= bg
;
5450 img
->background_valid
= 1;
5453 for (y
= 0; y
< height
; ++y
)
5454 for (x
= 0; x
< width
; ++x
)
5464 g
= pbm_scan_number (&p
, end
);
5466 XPutPixel (ximg
, x
, y
, g
? fg
: bg
);
5471 for (y
= 0; y
< height
; ++y
)
5472 for (x
= 0; x
< width
; ++x
)
5476 if (type
== PBM_GRAY
)
5477 r
= g
= b
= raw_p
? *p
++ : pbm_scan_number (&p
, end
);
5486 r
= pbm_scan_number (&p
, end
);
5487 g
= pbm_scan_number (&p
, end
);
5488 b
= pbm_scan_number (&p
, end
);
5491 if (r
< 0 || g
< 0 || b
< 0)
5493 x_destroy_x_image (ximg
);
5494 image_error ("Invalid pixel value in image `%s'",
5499 /* RGB values are now in the range 0..max_color_idx.
5500 Scale this to the range 0..0xffff supported by X. */
5501 r
= (double) r
* 65535 / max_color_idx
;
5502 g
= (double) g
* 65535 / max_color_idx
;
5503 b
= (double) b
* 65535 / max_color_idx
;
5504 XPutPixel (ximg
, x
, y
, lookup_rgb_color (f
, r
, g
, b
));
5508 #ifdef COLOR_TABLE_SUPPORT
5509 /* Store in IMG->colors the colors allocated for the image, and
5510 free the color table. */
5511 img
->colors
= colors_in_color_table (&img
->ncolors
);
5512 free_color_table ();
5513 #endif /* COLOR_TABLE_SUPPORT */
5516 img
->height
= height
;
5518 /* Maybe fill in the background field while we have ximg handy. */
5520 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
5521 /* Casting avoids a GCC warning. */
5522 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
5524 /* Put the image into a pixmap. */
5525 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
5526 x_destroy_x_image (ximg
);
5528 /* X and W32 versions did it here, MAC version above. ++kfs
5530 img->height = height; */
5538 /***********************************************************************
5540 ***********************************************************************/
5542 #if defined (HAVE_PNG) || defined (MAC_OS)
5544 /* Function prototypes. */
5546 static int png_image_p
P_ ((Lisp_Object object
));
5547 static int png_load
P_ ((struct frame
*f
, struct image
*img
));
5549 /* The symbol `png' identifying images of this type. */
5553 /* Indices of image specification fields in png_format, below. */
5555 enum png_keyword_index
5570 /* Vector of image_keyword structures describing the format
5571 of valid user-defined image specifications. */
5573 static struct image_keyword png_format
[PNG_LAST
] =
5575 {":type", IMAGE_SYMBOL_VALUE
, 1},
5576 {":data", IMAGE_STRING_VALUE
, 0},
5577 {":file", IMAGE_STRING_VALUE
, 0},
5578 {":ascent", IMAGE_ASCENT_VALUE
, 0},
5579 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
5580 {":relief", IMAGE_INTEGER_VALUE
, 0},
5581 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5582 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5583 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5584 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
5587 /* Structure describing the image type `png'. */
5589 static struct image_type png_type
=
5598 /* Return non-zero if OBJECT is a valid PNG image specification. */
5601 png_image_p (object
)
5604 struct image_keyword fmt
[PNG_LAST
];
5605 bcopy (png_format
, fmt
, sizeof fmt
);
5607 if (!parse_image_spec (object
, fmt
, PNG_LAST
, Qpng
))
5610 /* Must specify either the :data or :file keyword. */
5611 return fmt
[PNG_FILE
].count
+ fmt
[PNG_DATA
].count
== 1;
5614 #endif /* HAVE_PNG || MAC_OS */
5619 #if defined HAVE_LIBPNG_PNG_H
5620 # include <libpng/png.h>
5626 /* PNG library details. */
5628 DEF_IMGLIB_FN (png_get_io_ptr
);
5629 DEF_IMGLIB_FN (png_check_sig
);
5630 DEF_IMGLIB_FN (png_create_read_struct
);
5631 DEF_IMGLIB_FN (png_create_info_struct
);
5632 DEF_IMGLIB_FN (png_destroy_read_struct
);
5633 DEF_IMGLIB_FN (png_set_read_fn
);
5634 DEF_IMGLIB_FN (png_init_io
);
5635 DEF_IMGLIB_FN (png_set_sig_bytes
);
5636 DEF_IMGLIB_FN (png_read_info
);
5637 DEF_IMGLIB_FN (png_get_IHDR
);
5638 DEF_IMGLIB_FN (png_get_valid
);
5639 DEF_IMGLIB_FN (png_set_strip_16
);
5640 DEF_IMGLIB_FN (png_set_expand
);
5641 DEF_IMGLIB_FN (png_set_gray_to_rgb
);
5642 DEF_IMGLIB_FN (png_set_background
);
5643 DEF_IMGLIB_FN (png_get_bKGD
);
5644 DEF_IMGLIB_FN (png_read_update_info
);
5645 DEF_IMGLIB_FN (png_get_channels
);
5646 DEF_IMGLIB_FN (png_get_rowbytes
);
5647 DEF_IMGLIB_FN (png_read_image
);
5648 DEF_IMGLIB_FN (png_read_end
);
5649 DEF_IMGLIB_FN (png_error
);
5652 init_png_functions (Lisp_Object libraries
)
5656 /* Try loading libpng under probable names. */
5657 if (!(library
= w32_delayed_load (libraries
, Qpng
)))
5660 LOAD_IMGLIB_FN (library
, png_get_io_ptr
);
5661 LOAD_IMGLIB_FN (library
, png_check_sig
);
5662 LOAD_IMGLIB_FN (library
, png_create_read_struct
);
5663 LOAD_IMGLIB_FN (library
, png_create_info_struct
);
5664 LOAD_IMGLIB_FN (library
, png_destroy_read_struct
);
5665 LOAD_IMGLIB_FN (library
, png_set_read_fn
);
5666 LOAD_IMGLIB_FN (library
, png_init_io
);
5667 LOAD_IMGLIB_FN (library
, png_set_sig_bytes
);
5668 LOAD_IMGLIB_FN (library
, png_read_info
);
5669 LOAD_IMGLIB_FN (library
, png_get_IHDR
);
5670 LOAD_IMGLIB_FN (library
, png_get_valid
);
5671 LOAD_IMGLIB_FN (library
, png_set_strip_16
);
5672 LOAD_IMGLIB_FN (library
, png_set_expand
);
5673 LOAD_IMGLIB_FN (library
, png_set_gray_to_rgb
);
5674 LOAD_IMGLIB_FN (library
, png_set_background
);
5675 LOAD_IMGLIB_FN (library
, png_get_bKGD
);
5676 LOAD_IMGLIB_FN (library
, png_read_update_info
);
5677 LOAD_IMGLIB_FN (library
, png_get_channels
);
5678 LOAD_IMGLIB_FN (library
, png_get_rowbytes
);
5679 LOAD_IMGLIB_FN (library
, png_read_image
);
5680 LOAD_IMGLIB_FN (library
, png_read_end
);
5681 LOAD_IMGLIB_FN (library
, png_error
);
5686 #define fn_png_get_io_ptr png_get_io_ptr
5687 #define fn_png_check_sig png_check_sig
5688 #define fn_png_create_read_struct png_create_read_struct
5689 #define fn_png_create_info_struct png_create_info_struct
5690 #define fn_png_destroy_read_struct png_destroy_read_struct
5691 #define fn_png_set_read_fn png_set_read_fn
5692 #define fn_png_init_io png_init_io
5693 #define fn_png_set_sig_bytes png_set_sig_bytes
5694 #define fn_png_read_info png_read_info
5695 #define fn_png_get_IHDR png_get_IHDR
5696 #define fn_png_get_valid png_get_valid
5697 #define fn_png_set_strip_16 png_set_strip_16
5698 #define fn_png_set_expand png_set_expand
5699 #define fn_png_set_gray_to_rgb png_set_gray_to_rgb
5700 #define fn_png_set_background png_set_background
5701 #define fn_png_get_bKGD png_get_bKGD
5702 #define fn_png_read_update_info png_read_update_info
5703 #define fn_png_get_channels png_get_channels
5704 #define fn_png_get_rowbytes png_get_rowbytes
5705 #define fn_png_read_image png_read_image
5706 #define fn_png_read_end png_read_end
5707 #define fn_png_error png_error
5709 #endif /* HAVE_NTGUI */
5711 /* Error and warning handlers installed when the PNG library
5715 my_png_error (png_ptr
, msg
)
5716 png_struct
*png_ptr
;
5719 xassert (png_ptr
!= NULL
);
5720 image_error ("PNG error: %s", build_string (msg
), Qnil
);
5721 longjmp (png_ptr
->jmpbuf
, 1);
5726 my_png_warning (png_ptr
, msg
)
5727 png_struct
*png_ptr
;
5730 xassert (png_ptr
!= NULL
);
5731 image_error ("PNG warning: %s", build_string (msg
), Qnil
);
5734 /* Memory source for PNG decoding. */
5736 struct png_memory_storage
5738 unsigned char *bytes
; /* The data */
5739 size_t len
; /* How big is it? */
5740 int index
; /* Where are we? */
5744 /* Function set as reader function when reading PNG image from memory.
5745 PNG_PTR is a pointer to the PNG control structure. Copy LENGTH
5746 bytes from the input to DATA. */
5749 png_read_from_memory (png_ptr
, data
, length
)
5750 png_structp png_ptr
;
5754 struct png_memory_storage
*tbr
5755 = (struct png_memory_storage
*) fn_png_get_io_ptr (png_ptr
);
5757 if (length
> tbr
->len
- tbr
->index
)
5758 fn_png_error (png_ptr
, "Read error");
5760 bcopy (tbr
->bytes
+ tbr
->index
, data
, length
);
5761 tbr
->index
= tbr
->index
+ length
;
5765 /* Load PNG image IMG for use on frame F. Value is non-zero if
5773 Lisp_Object file
, specified_file
;
5774 Lisp_Object specified_data
;
5776 XImagePtr ximg
, mask_img
= NULL
;
5777 struct gcpro gcpro1
;
5778 png_struct
*png_ptr
= NULL
;
5779 png_info
*info_ptr
= NULL
, *end_info
= NULL
;
5780 FILE *volatile fp
= NULL
;
5782 png_byte
* volatile pixels
= NULL
;
5783 png_byte
** volatile rows
= NULL
;
5784 png_uint_32 width
, height
;
5785 int bit_depth
, color_type
, interlace_type
;
5787 png_uint_32 row_bytes
;
5789 double screen_gamma
;
5790 struct png_memory_storage tbr
; /* Data to be read */
5792 /* Find out what file to load. */
5793 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
5794 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
5798 if (NILP (specified_data
))
5800 file
= x_find_image_file (specified_file
);
5801 if (!STRINGP (file
))
5803 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
5808 /* Open the image file. */
5809 fp
= fopen (SDATA (file
), "rb");
5812 image_error ("Cannot open image file `%s'", file
, Qnil
);
5818 /* Check PNG signature. */
5819 if (fread (sig
, 1, sizeof sig
, fp
) != sizeof sig
5820 || !fn_png_check_sig (sig
, sizeof sig
))
5822 image_error ("Not a PNG file: `%s'", file
, Qnil
);
5830 /* Read from memory. */
5831 tbr
.bytes
= SDATA (specified_data
);
5832 tbr
.len
= SBYTES (specified_data
);
5835 /* Check PNG signature. */
5836 if (tbr
.len
< sizeof sig
5837 || !fn_png_check_sig (tbr
.bytes
, sizeof sig
))
5839 image_error ("Not a PNG image: `%s'", img
->spec
, Qnil
);
5844 /* Need to skip past the signature. */
5845 tbr
.bytes
+= sizeof (sig
);
5848 /* Initialize read and info structs for PNG lib. Casting return
5849 value avoids a GCC warning on W32. */
5850 png_ptr
= (png_structp
)fn_png_create_read_struct (PNG_LIBPNG_VER_STRING
,
5855 if (fp
) fclose (fp
);
5860 /* Casting return value avoids a GCC warning on W32. */
5861 info_ptr
= (png_infop
)fn_png_create_info_struct (png_ptr
);
5864 fn_png_destroy_read_struct (&png_ptr
, NULL
, NULL
);
5865 if (fp
) fclose (fp
);
5870 /* Casting return value avoids a GCC warning on W32. */
5871 end_info
= (png_infop
)fn_png_create_info_struct (png_ptr
);
5874 fn_png_destroy_read_struct (&png_ptr
, &info_ptr
, NULL
);
5875 if (fp
) fclose (fp
);
5880 /* Set error jump-back. We come back here when the PNG library
5881 detects an error. */
5882 if (setjmp (png_ptr
->jmpbuf
))
5886 fn_png_destroy_read_struct (&png_ptr
, &info_ptr
, &end_info
);
5889 if (fp
) fclose (fp
);
5894 /* Read image info. */
5895 if (!NILP (specified_data
))
5896 fn_png_set_read_fn (png_ptr
, (void *) &tbr
, png_read_from_memory
);
5898 fn_png_init_io (png_ptr
, fp
);
5900 fn_png_set_sig_bytes (png_ptr
, sizeof sig
);
5901 fn_png_read_info (png_ptr
, info_ptr
);
5902 fn_png_get_IHDR (png_ptr
, info_ptr
, &width
, &height
, &bit_depth
, &color_type
,
5903 &interlace_type
, NULL
, NULL
);
5905 /* If image contains simply transparency data, we prefer to
5906 construct a clipping mask. */
5907 if (fn_png_get_valid (png_ptr
, info_ptr
, PNG_INFO_tRNS
))
5912 /* This function is easier to write if we only have to handle
5913 one data format: RGB or RGBA with 8 bits per channel. Let's
5914 transform other formats into that format. */
5916 /* Strip more than 8 bits per channel. */
5917 if (bit_depth
== 16)
5918 fn_png_set_strip_16 (png_ptr
);
5920 /* Expand data to 24 bit RGB, or 8 bit grayscale, with alpha channel
5922 fn_png_set_expand (png_ptr
);
5924 /* Convert grayscale images to RGB. */
5925 if (color_type
== PNG_COLOR_TYPE_GRAY
5926 || color_type
== PNG_COLOR_TYPE_GRAY_ALPHA
)
5927 fn_png_set_gray_to_rgb (png_ptr
);
5929 screen_gamma
= (f
->gamma
? 1 / f
->gamma
/ 0.45455 : 2.2);
5931 #if 0 /* Avoid double gamma correction for PNG images. */
5932 { /* Tell the PNG lib to handle gamma correction for us. */
5935 #if defined(PNG_READ_sRGB_SUPPORTED) || defined(PNG_WRITE_sRGB_SUPPORTED)
5936 if (png_get_sRGB (png_ptr
, info_ptr
, &intent
))
5937 /* The libpng documentation says this is right in this case. */
5938 png_set_gamma (png_ptr
, screen_gamma
, 0.45455);
5941 if (png_get_gAMA (png_ptr
, info_ptr
, &image_gamma
))
5942 /* Image contains gamma information. */
5943 png_set_gamma (png_ptr
, screen_gamma
, image_gamma
);
5945 /* Use the standard default for the image gamma. */
5946 png_set_gamma (png_ptr
, screen_gamma
, 0.45455);
5950 /* Handle alpha channel by combining the image with a background
5951 color. Do this only if a real alpha channel is supplied. For
5952 simple transparency, we prefer a clipping mask. */
5955 png_color_16
*image_bg
;
5956 Lisp_Object specified_bg
5957 = image_spec_value (img
->spec
, QCbackground
, NULL
);
5959 if (STRINGP (specified_bg
))
5960 /* The user specified `:background', use that. */
5962 /* W32 version incorrectly used COLORREF here!! ++kfs */
5964 if (x_defined_color (f
, SDATA (specified_bg
), &color
, 0))
5966 png_color_16 user_bg
;
5968 bzero (&user_bg
, sizeof user_bg
);
5969 user_bg
.red
= color
.red
>> 8;
5970 user_bg
.green
= color
.green
>> 8;
5971 user_bg
.blue
= color
.blue
>> 8;
5973 fn_png_set_background (png_ptr
, &user_bg
,
5974 PNG_BACKGROUND_GAMMA_SCREEN
, 0, 1.0);
5977 else if (fn_png_get_bKGD (png_ptr
, info_ptr
, &image_bg
))
5978 /* Image contains a background color with which to
5979 combine the image. */
5980 fn_png_set_background (png_ptr
, image_bg
,
5981 PNG_BACKGROUND_GAMMA_FILE
, 1, 1.0);
5984 /* Image does not contain a background color with which
5985 to combine the image data via an alpha channel. Use
5986 the frame's background instead. */
5987 #ifdef HAVE_X_WINDOWS
5989 png_color_16 frame_background
;
5991 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
5992 x_query_color (f
, &color
);
5994 bzero (&frame_background
, sizeof frame_background
);
5995 frame_background
.red
= color
.red
>> 8;
5996 frame_background
.green
= color
.green
>> 8;
5997 frame_background
.blue
= color
.blue
>> 8;
5998 #endif /* HAVE_X_WINDOWS */
6002 png_color_16 frame_background
;
6003 color
= FRAME_BACKGROUND_PIXEL (f
);
6004 #if 0 /* W32 TODO : Colormap support. */
6005 x_query_color (f
, &color
);
6007 bzero (&frame_background
, sizeof frame_background
);
6008 frame_background
.red
= GetRValue (color
);
6009 frame_background
.green
= GetGValue (color
);
6010 frame_background
.blue
= GetBValue (color
);
6011 #endif /* HAVE_NTGUI */
6014 unsigned long color
;
6015 png_color_16 frame_background
;
6016 color
= FRAME_BACKGROUND_PIXEL (f
);
6017 #if 0 /* MAC/W32 TODO : Colormap support. */
6018 x_query_color (f
, &color
);
6020 bzero (&frame_background
, sizeof frame_background
);
6021 frame_background
.red
= RED_FROM_ULONG (color
);
6022 frame_background
.green
= GREEN_FROM_ULONG (color
);
6023 frame_background
.blue
= BLUE_FROM_ULONG (color
);
6026 fn_png_set_background (png_ptr
, &frame_background
,
6027 PNG_BACKGROUND_GAMMA_SCREEN
, 0, 1.0);
6031 /* Update info structure. */
6032 fn_png_read_update_info (png_ptr
, info_ptr
);
6034 /* Get number of channels. Valid values are 1 for grayscale images
6035 and images with a palette, 2 for grayscale images with transparency
6036 information (alpha channel), 3 for RGB images, and 4 for RGB
6037 images with alpha channel, i.e. RGBA. If conversions above were
6038 sufficient we should only have 3 or 4 channels here. */
6039 channels
= fn_png_get_channels (png_ptr
, info_ptr
);
6040 xassert (channels
== 3 || channels
== 4);
6042 /* Number of bytes needed for one row of the image. */
6043 row_bytes
= fn_png_get_rowbytes (png_ptr
, info_ptr
);
6045 /* Allocate memory for the image. */
6046 pixels
= (png_byte
*) xmalloc (row_bytes
* height
* sizeof *pixels
);
6047 rows
= (png_byte
**) xmalloc (height
* sizeof *rows
);
6048 for (i
= 0; i
< height
; ++i
)
6049 rows
[i
] = pixels
+ i
* row_bytes
;
6051 /* Read the entire image. */
6052 fn_png_read_image (png_ptr
, rows
);
6053 fn_png_read_end (png_ptr
, info_ptr
);
6060 /* Create the X image and pixmap. */
6061 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
,
6065 /* Create an image and pixmap serving as mask if the PNG image
6066 contains an alpha channel. */
6069 && !x_create_x_image_and_pixmap (f
, width
, height
, 1,
6070 &mask_img
, &img
->mask
))
6072 x_destroy_x_image (ximg
);
6073 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->pixmap
);
6074 img
->pixmap
= NO_PIXMAP
;
6078 /* Fill the X image and mask from PNG data. */
6079 init_color_table ();
6081 for (y
= 0; y
< height
; ++y
)
6083 png_byte
*p
= rows
[y
];
6085 for (x
= 0; x
< width
; ++x
)
6092 XPutPixel (ximg
, x
, y
, lookup_rgb_color (f
, r
, g
, b
));
6093 /* An alpha channel, aka mask channel, associates variable
6094 transparency with an image. Where other image formats
6095 support binary transparency---fully transparent or fully
6096 opaque---PNG allows up to 254 levels of partial transparency.
6097 The PNG library implements partial transparency by combining
6098 the image with a specified background color.
6100 I'm not sure how to handle this here nicely: because the
6101 background on which the image is displayed may change, for
6102 real alpha channel support, it would be necessary to create
6103 a new image for each possible background.
6105 What I'm doing now is that a mask is created if we have
6106 boolean transparency information. Otherwise I'm using
6107 the frame's background color to combine the image with. */
6112 XPutPixel (mask_img
, x
, y
, *p
> 0 ? PIX_MASK_DRAW (f
) : PIX_MASK_RETAIN (f
));
6118 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
6119 /* Set IMG's background color from the PNG image, unless the user
6123 if (fn_png_get_bKGD (png_ptr
, info_ptr
, &bg
))
6125 img
->background
= lookup_rgb_color (f
, bg
->red
, bg
->green
, bg
->blue
);
6126 img
->background_valid
= 1;
6130 #ifdef COLOR_TABLE_SUPPORT
6131 /* Remember colors allocated for this image. */
6132 img
->colors
= colors_in_color_table (&img
->ncolors
);
6133 free_color_table ();
6134 #endif /* COLOR_TABLE_SUPPORT */
6137 fn_png_destroy_read_struct (&png_ptr
, &info_ptr
, &end_info
);
6142 img
->height
= height
;
6144 /* Maybe fill in the background field while we have ximg handy.
6145 Casting avoids a GCC warning. */
6146 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
6148 /* Put the image into the pixmap, then free the X image and its buffer. */
6149 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
6150 x_destroy_x_image (ximg
);
6152 /* Same for the mask. */
6155 /* Fill in the background_transparent field while we have the
6156 mask handy. Casting avoids a GCC warning. */
6157 image_background_transparent (img
, f
, (XImagePtr_or_DC
)mask_img
);
6159 x_put_x_image (f
, mask_img
, img
->mask
, img
->width
, img
->height
);
6160 x_destroy_x_image (mask_img
);
6167 #else /* HAVE_PNG */
6176 if (MyCGImageCreateWithPNGDataProvider
)
6177 return image_load_quartz2d (f
, img
, 1);
6180 return image_load_quicktime (f
, img
, kQTFileTypePNG
);
6184 #endif /* !HAVE_PNG */
6188 /***********************************************************************
6190 ***********************************************************************/
6192 #if defined (HAVE_JPEG) || defined (MAC_OS)
6194 static int jpeg_image_p
P_ ((Lisp_Object object
));
6195 static int jpeg_load
P_ ((struct frame
*f
, struct image
*img
));
6197 /* The symbol `jpeg' identifying images of this type. */
6201 /* Indices of image specification fields in gs_format, below. */
6203 enum jpeg_keyword_index
6212 JPEG_HEURISTIC_MASK
,
6218 /* Vector of image_keyword structures describing the format
6219 of valid user-defined image specifications. */
6221 static struct image_keyword jpeg_format
[JPEG_LAST
] =
6223 {":type", IMAGE_SYMBOL_VALUE
, 1},
6224 {":data", IMAGE_STRING_VALUE
, 0},
6225 {":file", IMAGE_STRING_VALUE
, 0},
6226 {":ascent", IMAGE_ASCENT_VALUE
, 0},
6227 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
6228 {":relief", IMAGE_INTEGER_VALUE
, 0},
6229 {":conversions", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6230 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6231 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6232 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
6235 /* Structure describing the image type `jpeg'. */
6237 static struct image_type jpeg_type
=
6246 /* Return non-zero if OBJECT is a valid JPEG image specification. */
6249 jpeg_image_p (object
)
6252 struct image_keyword fmt
[JPEG_LAST
];
6254 bcopy (jpeg_format
, fmt
, sizeof fmt
);
6256 if (!parse_image_spec (object
, fmt
, JPEG_LAST
, Qjpeg
))
6259 /* Must specify either the :data or :file keyword. */
6260 return fmt
[JPEG_FILE
].count
+ fmt
[JPEG_DATA
].count
== 1;
6263 #endif /* HAVE_JPEG || MAC_OS */
6267 /* Work around a warning about HAVE_STDLIB_H being redefined in
6269 #ifdef HAVE_STDLIB_H
6270 #define HAVE_STDLIB_H_1
6271 #undef HAVE_STDLIB_H
6272 #endif /* HAVE_STLIB_H */
6274 #if defined (HAVE_NTGUI) && !defined (__WIN32__)
6275 /* In older releases of the jpeg library, jpeglib.h will define boolean
6276 differently depending on __WIN32__, so make sure it is defined. */
6280 #include <jpeglib.h>
6284 #ifdef HAVE_STLIB_H_1
6285 #define HAVE_STDLIB_H 1
6290 /* JPEG library details. */
6291 DEF_IMGLIB_FN (jpeg_CreateDecompress
);
6292 DEF_IMGLIB_FN (jpeg_start_decompress
);
6293 DEF_IMGLIB_FN (jpeg_finish_decompress
);
6294 DEF_IMGLIB_FN (jpeg_destroy_decompress
);
6295 DEF_IMGLIB_FN (jpeg_read_header
);
6296 DEF_IMGLIB_FN (jpeg_read_scanlines
);
6297 DEF_IMGLIB_FN (jpeg_stdio_src
);
6298 DEF_IMGLIB_FN (jpeg_std_error
);
6299 DEF_IMGLIB_FN (jpeg_resync_to_restart
);
6302 init_jpeg_functions (Lisp_Object libraries
)
6306 if (!(library
= w32_delayed_load (libraries
, Qjpeg
)))
6309 LOAD_IMGLIB_FN (library
, jpeg_finish_decompress
);
6310 LOAD_IMGLIB_FN (library
, jpeg_read_scanlines
);
6311 LOAD_IMGLIB_FN (library
, jpeg_start_decompress
);
6312 LOAD_IMGLIB_FN (library
, jpeg_read_header
);
6313 LOAD_IMGLIB_FN (library
, jpeg_stdio_src
);
6314 LOAD_IMGLIB_FN (library
, jpeg_CreateDecompress
);
6315 LOAD_IMGLIB_FN (library
, jpeg_destroy_decompress
);
6316 LOAD_IMGLIB_FN (library
, jpeg_std_error
);
6317 LOAD_IMGLIB_FN (library
, jpeg_resync_to_restart
);
6321 /* Wrapper since we can't directly assign the function pointer
6322 to another function pointer that was declared more completely easily. */
6324 jpeg_resync_to_restart_wrapper(cinfo
, desired
)
6325 j_decompress_ptr cinfo
;
6328 return fn_jpeg_resync_to_restart (cinfo
, desired
);
6333 #define fn_jpeg_CreateDecompress(a,b,c) jpeg_create_decompress(a)
6334 #define fn_jpeg_start_decompress jpeg_start_decompress
6335 #define fn_jpeg_finish_decompress jpeg_finish_decompress
6336 #define fn_jpeg_destroy_decompress jpeg_destroy_decompress
6337 #define fn_jpeg_read_header jpeg_read_header
6338 #define fn_jpeg_read_scanlines jpeg_read_scanlines
6339 #define fn_jpeg_stdio_src jpeg_stdio_src
6340 #define fn_jpeg_std_error jpeg_std_error
6341 #define jpeg_resync_to_restart_wrapper jpeg_resync_to_restart
6343 #endif /* HAVE_NTGUI */
6345 struct my_jpeg_error_mgr
6347 struct jpeg_error_mgr pub
;
6348 jmp_buf setjmp_buffer
;
6353 my_error_exit (cinfo
)
6356 struct my_jpeg_error_mgr
*mgr
= (struct my_jpeg_error_mgr
*) cinfo
->err
;
6357 longjmp (mgr
->setjmp_buffer
, 1);
6361 /* Init source method for JPEG data source manager. Called by
6362 jpeg_read_header() before any data is actually read. See
6363 libjpeg.doc from the JPEG lib distribution. */
6366 our_init_source (cinfo
)
6367 j_decompress_ptr cinfo
;
6372 /* Fill input buffer method for JPEG data source manager. Called
6373 whenever more data is needed. We read the whole image in one step,
6374 so this only adds a fake end of input marker at the end. */
6377 our_fill_input_buffer (cinfo
)
6378 j_decompress_ptr cinfo
;
6380 /* Insert a fake EOI marker. */
6381 struct jpeg_source_mgr
*src
= cinfo
->src
;
6382 static JOCTET buffer
[2];
6384 buffer
[0] = (JOCTET
) 0xFF;
6385 buffer
[1] = (JOCTET
) JPEG_EOI
;
6387 src
->next_input_byte
= buffer
;
6388 src
->bytes_in_buffer
= 2;
6393 /* Method to skip over NUM_BYTES bytes in the image data. CINFO->src
6394 is the JPEG data source manager. */
6397 our_skip_input_data (cinfo
, num_bytes
)
6398 j_decompress_ptr cinfo
;
6401 struct jpeg_source_mgr
*src
= (struct jpeg_source_mgr
*) cinfo
->src
;
6405 if (num_bytes
> src
->bytes_in_buffer
)
6406 ERREXIT (cinfo
, JERR_INPUT_EOF
);
6408 src
->bytes_in_buffer
-= num_bytes
;
6409 src
->next_input_byte
+= num_bytes
;
6414 /* Method to terminate data source. Called by
6415 jpeg_finish_decompress() after all data has been processed. */
6418 our_term_source (cinfo
)
6419 j_decompress_ptr cinfo
;
6424 /* Set up the JPEG lib for reading an image from DATA which contains
6425 LEN bytes. CINFO is the decompression info structure created for
6426 reading the image. */
6429 jpeg_memory_src (cinfo
, data
, len
)
6430 j_decompress_ptr cinfo
;
6434 struct jpeg_source_mgr
*src
;
6436 if (cinfo
->src
== NULL
)
6438 /* First time for this JPEG object? */
6439 cinfo
->src
= (struct jpeg_source_mgr
*)
6440 (*cinfo
->mem
->alloc_small
) ((j_common_ptr
) cinfo
, JPOOL_PERMANENT
,
6441 sizeof (struct jpeg_source_mgr
));
6442 src
= (struct jpeg_source_mgr
*) cinfo
->src
;
6443 src
->next_input_byte
= data
;
6446 src
= (struct jpeg_source_mgr
*) cinfo
->src
;
6447 src
->init_source
= our_init_source
;
6448 src
->fill_input_buffer
= our_fill_input_buffer
;
6449 src
->skip_input_data
= our_skip_input_data
;
6450 src
->resync_to_restart
= jpeg_resync_to_restart_wrapper
; /* Use default method. */
6451 src
->term_source
= our_term_source
;
6452 src
->bytes_in_buffer
= len
;
6453 src
->next_input_byte
= data
;
6457 /* Load image IMG for use on frame F. Patterned after example.c
6458 from the JPEG lib. */
6465 struct jpeg_decompress_struct cinfo
;
6466 struct my_jpeg_error_mgr mgr
;
6467 Lisp_Object file
, specified_file
;
6468 Lisp_Object specified_data
;
6469 FILE * volatile fp
= NULL
;
6471 int row_stride
, x
, y
;
6472 XImagePtr ximg
= NULL
;
6474 unsigned long *colors
;
6476 struct gcpro gcpro1
;
6478 /* Open the JPEG file. */
6479 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
6480 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
6484 if (NILP (specified_data
))
6486 file
= x_find_image_file (specified_file
);
6487 if (!STRINGP (file
))
6489 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
6494 fp
= fopen (SDATA (file
), "rb");
6497 image_error ("Cannot open `%s'", file
, Qnil
);
6503 /* Customize libjpeg's error handling to call my_error_exit when an
6504 error is detected. This function will perform a longjmp.
6505 Casting return value avoids a GCC warning on W32. */
6506 cinfo
.err
= (struct jpeg_error_mgr
*)fn_jpeg_std_error (&mgr
.pub
);
6507 mgr
.pub
.error_exit
= my_error_exit
;
6509 if ((rc
= setjmp (mgr
.setjmp_buffer
)) != 0)
6513 /* Called from my_error_exit. Display a JPEG error. */
6514 char buffer
[JMSG_LENGTH_MAX
];
6515 cinfo
.err
->format_message ((j_common_ptr
) &cinfo
, buffer
);
6516 image_error ("Error reading JPEG image `%s': %s", img
->spec
,
6517 build_string (buffer
));
6520 /* Close the input file and destroy the JPEG object. */
6522 fclose ((FILE *) fp
);
6523 fn_jpeg_destroy_decompress (&cinfo
);
6525 /* If we already have an XImage, free that. */
6526 x_destroy_x_image (ximg
);
6528 /* Free pixmap and colors. */
6529 x_clear_image (f
, img
);
6535 /* Create the JPEG decompression object. Let it read from fp.
6536 Read the JPEG image header. */
6537 fn_jpeg_CreateDecompress (&cinfo
, JPEG_LIB_VERSION
, sizeof (cinfo
));
6539 if (NILP (specified_data
))
6540 fn_jpeg_stdio_src (&cinfo
, (FILE *) fp
);
6542 jpeg_memory_src (&cinfo
, SDATA (specified_data
),
6543 SBYTES (specified_data
));
6545 fn_jpeg_read_header (&cinfo
, 1);
6547 /* Customize decompression so that color quantization will be used.
6548 Start decompression. */
6549 cinfo
.quantize_colors
= 1;
6550 fn_jpeg_start_decompress (&cinfo
);
6551 width
= img
->width
= cinfo
.output_width
;
6552 height
= img
->height
= cinfo
.output_height
;
6554 /* Create X image and pixmap. */
6555 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
6556 longjmp (mgr
.setjmp_buffer
, 2);
6558 /* Allocate colors. When color quantization is used,
6559 cinfo.actual_number_of_colors has been set with the number of
6560 colors generated, and cinfo.colormap is a two-dimensional array
6561 of color indices in the range 0..cinfo.actual_number_of_colors.
6562 No more than 255 colors will be generated. */
6566 if (cinfo
.out_color_components
> 2)
6567 ir
= 0, ig
= 1, ib
= 2;
6568 else if (cinfo
.out_color_components
> 1)
6569 ir
= 0, ig
= 1, ib
= 0;
6571 ir
= 0, ig
= 0, ib
= 0;
6573 /* Use the color table mechanism because it handles colors that
6574 cannot be allocated nicely. Such colors will be replaced with
6575 a default color, and we don't have to care about which colors
6576 can be freed safely, and which can't. */
6577 init_color_table ();
6578 colors
= (unsigned long *) alloca (cinfo
.actual_number_of_colors
6581 for (i
= 0; i
< cinfo
.actual_number_of_colors
; ++i
)
6583 /* Multiply RGB values with 255 because X expects RGB values
6584 in the range 0..0xffff. */
6585 int r
= cinfo
.colormap
[ir
][i
] << 8;
6586 int g
= cinfo
.colormap
[ig
][i
] << 8;
6587 int b
= cinfo
.colormap
[ib
][i
] << 8;
6588 colors
[i
] = lookup_rgb_color (f
, r
, g
, b
);
6591 #ifdef COLOR_TABLE_SUPPORT
6592 /* Remember those colors actually allocated. */
6593 img
->colors
= colors_in_color_table (&img
->ncolors
);
6594 free_color_table ();
6595 #endif /* COLOR_TABLE_SUPPORT */
6599 row_stride
= width
* cinfo
.output_components
;
6600 buffer
= cinfo
.mem
->alloc_sarray ((j_common_ptr
) &cinfo
, JPOOL_IMAGE
,
6602 for (y
= 0; y
< height
; ++y
)
6604 fn_jpeg_read_scanlines (&cinfo
, buffer
, 1);
6605 for (x
= 0; x
< cinfo
.output_width
; ++x
)
6606 XPutPixel (ximg
, x
, y
, colors
[buffer
[0][x
]]);
6610 fn_jpeg_finish_decompress (&cinfo
);
6611 fn_jpeg_destroy_decompress (&cinfo
);
6613 fclose ((FILE *) fp
);
6615 /* Maybe fill in the background field while we have ximg handy. */
6616 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
6617 /* Casting avoids a GCC warning. */
6618 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
6620 /* Put the image into the pixmap. */
6621 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
6622 x_destroy_x_image (ximg
);
6627 #else /* HAVE_JPEG */
6636 return image_load_quartz2d (f
, img
, 0);
6638 return image_load_quicktime (f
, img
, kQTFileTypeJPEG
);
6643 #endif /* !HAVE_JPEG */
6647 /***********************************************************************
6649 ***********************************************************************/
6651 #if defined (HAVE_TIFF) || defined (MAC_OS)
6653 static int tiff_image_p
P_ ((Lisp_Object object
));
6654 static int tiff_load
P_ ((struct frame
*f
, struct image
*img
));
6656 /* The symbol `tiff' identifying images of this type. */
6660 /* Indices of image specification fields in tiff_format, below. */
6662 enum tiff_keyword_index
6671 TIFF_HEURISTIC_MASK
,
6677 /* Vector of image_keyword structures describing the format
6678 of valid user-defined image specifications. */
6680 static struct image_keyword tiff_format
[TIFF_LAST
] =
6682 {":type", IMAGE_SYMBOL_VALUE
, 1},
6683 {":data", IMAGE_STRING_VALUE
, 0},
6684 {":file", IMAGE_STRING_VALUE
, 0},
6685 {":ascent", IMAGE_ASCENT_VALUE
, 0},
6686 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
6687 {":relief", IMAGE_INTEGER_VALUE
, 0},
6688 {":conversions", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6689 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6690 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6691 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
6694 /* Structure describing the image type `tiff'. */
6696 static struct image_type tiff_type
=
6705 /* Return non-zero if OBJECT is a valid TIFF image specification. */
6708 tiff_image_p (object
)
6711 struct image_keyword fmt
[TIFF_LAST
];
6712 bcopy (tiff_format
, fmt
, sizeof fmt
);
6714 if (!parse_image_spec (object
, fmt
, TIFF_LAST
, Qtiff
))
6717 /* Must specify either the :data or :file keyword. */
6718 return fmt
[TIFF_FILE
].count
+ fmt
[TIFF_DATA
].count
== 1;
6721 #endif /* HAVE_TIFF || MAC_OS */
6729 /* TIFF library details. */
6730 DEF_IMGLIB_FN (TIFFSetErrorHandler
);
6731 DEF_IMGLIB_FN (TIFFSetWarningHandler
);
6732 DEF_IMGLIB_FN (TIFFOpen
);
6733 DEF_IMGLIB_FN (TIFFClientOpen
);
6734 DEF_IMGLIB_FN (TIFFGetField
);
6735 DEF_IMGLIB_FN (TIFFReadRGBAImage
);
6736 DEF_IMGLIB_FN (TIFFClose
);
6739 init_tiff_functions (Lisp_Object libraries
)
6743 if (!(library
= w32_delayed_load (libraries
, Qtiff
)))
6746 LOAD_IMGLIB_FN (library
, TIFFSetErrorHandler
);
6747 LOAD_IMGLIB_FN (library
, TIFFSetWarningHandler
);
6748 LOAD_IMGLIB_FN (library
, TIFFOpen
);
6749 LOAD_IMGLIB_FN (library
, TIFFClientOpen
);
6750 LOAD_IMGLIB_FN (library
, TIFFGetField
);
6751 LOAD_IMGLIB_FN (library
, TIFFReadRGBAImage
);
6752 LOAD_IMGLIB_FN (library
, TIFFClose
);
6758 #define fn_TIFFSetErrorHandler TIFFSetErrorHandler
6759 #define fn_TIFFSetWarningHandler TIFFSetWarningHandler
6760 #define fn_TIFFOpen TIFFOpen
6761 #define fn_TIFFClientOpen TIFFClientOpen
6762 #define fn_TIFFGetField TIFFGetField
6763 #define fn_TIFFReadRGBAImage TIFFReadRGBAImage
6764 #define fn_TIFFClose TIFFClose
6766 #endif /* HAVE_NTGUI */
6769 /* Reading from a memory buffer for TIFF images Based on the PNG
6770 memory source, but we have to provide a lot of extra functions.
6773 We really only need to implement read and seek, but I am not
6774 convinced that the TIFF library is smart enough not to destroy
6775 itself if we only hand it the function pointers we need to
6780 unsigned char *bytes
;
6787 tiff_read_from_memory (data
, buf
, size
)
6792 tiff_memory_source
*src
= (tiff_memory_source
*) data
;
6794 if (size
> src
->len
- src
->index
)
6796 bcopy (src
->bytes
+ src
->index
, buf
, size
);
6802 tiff_write_from_memory (data
, buf
, size
)
6811 tiff_seek_in_memory (data
, off
, whence
)
6816 tiff_memory_source
*src
= (tiff_memory_source
*) data
;
6821 case SEEK_SET
: /* Go from beginning of source. */
6825 case SEEK_END
: /* Go from end of source. */
6826 idx
= src
->len
+ off
;
6829 case SEEK_CUR
: /* Go from current position. */
6830 idx
= src
->index
+ off
;
6833 default: /* Invalid `whence'. */
6837 if (idx
> src
->len
|| idx
< 0)
6845 tiff_close_memory (data
)
6853 tiff_mmap_memory (data
, pbase
, psize
)
6858 /* It is already _IN_ memory. */
6863 tiff_unmap_memory (data
, base
, size
)
6868 /* We don't need to do this. */
6872 tiff_size_of_memory (data
)
6875 return ((tiff_memory_source
*) data
)->len
;
6880 tiff_error_handler (title
, format
, ap
)
6881 const char *title
, *format
;
6887 len
= sprintf (buf
, "TIFF error: %s ", title
);
6888 vsprintf (buf
+ len
, format
, ap
);
6889 add_to_log (buf
, Qnil
, Qnil
);
6894 tiff_warning_handler (title
, format
, ap
)
6895 const char *title
, *format
;
6901 len
= sprintf (buf
, "TIFF warning: %s ", title
);
6902 vsprintf (buf
+ len
, format
, ap
);
6903 add_to_log (buf
, Qnil
, Qnil
);
6907 /* Load TIFF image IMG for use on frame F. Value is non-zero if
6915 Lisp_Object file
, specified_file
;
6916 Lisp_Object specified_data
;
6918 int width
, height
, x
, y
;
6922 struct gcpro gcpro1
;
6923 tiff_memory_source memsrc
;
6925 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
6926 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
6930 fn_TIFFSetErrorHandler (tiff_error_handler
);
6931 fn_TIFFSetWarningHandler (tiff_warning_handler
);
6933 if (NILP (specified_data
))
6935 /* Read from a file */
6936 file
= x_find_image_file (specified_file
);
6937 if (!STRINGP (file
))
6939 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
6944 /* Try to open the image file. Casting return value avoids a
6945 GCC warning on W32. */
6946 tiff
= (TIFF
*)fn_TIFFOpen (SDATA (file
), "r");
6949 image_error ("Cannot open `%s'", file
, Qnil
);
6956 /* Memory source! */
6957 memsrc
.bytes
= SDATA (specified_data
);
6958 memsrc
.len
= SBYTES (specified_data
);
6961 /* Casting return value avoids a GCC warning on W32. */
6962 tiff
= (TIFF
*)fn_TIFFClientOpen ("memory_source", "r", &memsrc
,
6963 (TIFFReadWriteProc
) tiff_read_from_memory
,
6964 (TIFFReadWriteProc
) tiff_write_from_memory
,
6965 tiff_seek_in_memory
,
6967 tiff_size_of_memory
,
6973 image_error ("Cannot open memory source for `%s'", img
->spec
, Qnil
);
6979 /* Get width and height of the image, and allocate a raster buffer
6980 of width x height 32-bit values. */
6981 fn_TIFFGetField (tiff
, TIFFTAG_IMAGEWIDTH
, &width
);
6982 fn_TIFFGetField (tiff
, TIFFTAG_IMAGELENGTH
, &height
);
6983 buf
= (uint32
*) xmalloc (width
* height
* sizeof *buf
);
6985 rc
= fn_TIFFReadRGBAImage (tiff
, width
, height
, buf
, 0);
6986 fn_TIFFClose (tiff
);
6989 image_error ("Error reading TIFF image `%s'", img
->spec
, Qnil
);
6995 /* Create the X image and pixmap. */
6996 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
7003 /* Initialize the color table. */
7004 init_color_table ();
7006 /* Process the pixel raster. Origin is in the lower-left corner. */
7007 for (y
= 0; y
< height
; ++y
)
7009 uint32
*row
= buf
+ y
* width
;
7011 for (x
= 0; x
< width
; ++x
)
7013 uint32 abgr
= row
[x
];
7014 int r
= TIFFGetR (abgr
) << 8;
7015 int g
= TIFFGetG (abgr
) << 8;
7016 int b
= TIFFGetB (abgr
) << 8;
7017 XPutPixel (ximg
, x
, height
- 1 - y
, lookup_rgb_color (f
, r
, g
, b
));
7021 #ifdef COLOR_TABLE_SUPPORT
7022 /* Remember the colors allocated for the image. Free the color table. */
7023 img
->colors
= colors_in_color_table (&img
->ncolors
);
7024 free_color_table ();
7025 #endif /* COLOR_TABLE_SUPPORT */
7028 img
->height
= height
;
7030 /* Maybe fill in the background field while we have ximg handy. */
7031 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
7032 /* Casting avoids a GCC warning on W32. */
7033 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
7035 /* Put the image into the pixmap, then free the X image and its buffer. */
7036 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
7037 x_destroy_x_image (ximg
);
7044 #else /* HAVE_TIFF */
7052 return image_load_quicktime (f
, img
, kQTFileTypeTIFF
);
7056 #endif /* !HAVE_TIFF */
7060 /***********************************************************************
7062 ***********************************************************************/
7064 #if defined (HAVE_GIF) || defined (MAC_OS)
7066 static int gif_image_p
P_ ((Lisp_Object object
));
7067 static int gif_load
P_ ((struct frame
*f
, struct image
*img
));
7069 /* The symbol `gif' identifying images of this type. */
7073 /* Indices of image specification fields in gif_format, below. */
7075 enum gif_keyword_index
7091 /* Vector of image_keyword structures describing the format
7092 of valid user-defined image specifications. */
7094 static struct image_keyword gif_format
[GIF_LAST
] =
7096 {":type", IMAGE_SYMBOL_VALUE
, 1},
7097 {":data", IMAGE_STRING_VALUE
, 0},
7098 {":file", IMAGE_STRING_VALUE
, 0},
7099 {":ascent", IMAGE_ASCENT_VALUE
, 0},
7100 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
7101 {":relief", IMAGE_INTEGER_VALUE
, 0},
7102 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7103 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7104 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7105 {":image", IMAGE_NON_NEGATIVE_INTEGER_VALUE
, 0},
7106 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
7109 /* Structure describing the image type `gif'. */
7111 static struct image_type gif_type
=
7120 /* Return non-zero if OBJECT is a valid GIF image specification. */
7123 gif_image_p (object
)
7126 struct image_keyword fmt
[GIF_LAST
];
7127 bcopy (gif_format
, fmt
, sizeof fmt
);
7129 if (!parse_image_spec (object
, fmt
, GIF_LAST
, Qgif
))
7132 /* Must specify either the :data or :file keyword. */
7133 return fmt
[GIF_FILE
].count
+ fmt
[GIF_DATA
].count
== 1;
7136 #endif /* HAVE_GIF || MAC_OS */
7140 #if defined (HAVE_NTGUI) || defined (MAC_OS)
7141 /* winuser.h might define DrawText to DrawTextA or DrawTextW.
7142 Undefine before redefining to avoid a preprocessor warning. */
7146 /* avoid conflict with QuickdrawText.h */
7147 #define DrawText gif_DrawText
7148 #include <gif_lib.h>
7151 #else /* HAVE_NTGUI || MAC_OS */
7153 #include <gif_lib.h>
7155 #endif /* HAVE_NTGUI || MAC_OS */
7160 /* GIF library details. */
7161 DEF_IMGLIB_FN (DGifCloseFile
);
7162 DEF_IMGLIB_FN (DGifSlurp
);
7163 DEF_IMGLIB_FN (DGifOpen
);
7164 DEF_IMGLIB_FN (DGifOpenFileName
);
7167 init_gif_functions (Lisp_Object libraries
)
7171 if (!(library
= w32_delayed_load (libraries
, Qgif
)))
7174 LOAD_IMGLIB_FN (library
, DGifCloseFile
);
7175 LOAD_IMGLIB_FN (library
, DGifSlurp
);
7176 LOAD_IMGLIB_FN (library
, DGifOpen
);
7177 LOAD_IMGLIB_FN (library
, DGifOpenFileName
);
7183 #define fn_DGifCloseFile DGifCloseFile
7184 #define fn_DGifSlurp DGifSlurp
7185 #define fn_DGifOpen DGifOpen
7186 #define fn_DGifOpenFileName DGifOpenFileName
7188 #endif /* HAVE_NTGUI */
7190 /* Reading a GIF image from memory
7191 Based on the PNG memory stuff to a certain extent. */
7195 unsigned char *bytes
;
7201 /* Make the current memory source available to gif_read_from_memory.
7202 It's done this way because not all versions of libungif support
7203 a UserData field in the GifFileType structure. */
7204 static gif_memory_source
*current_gif_memory_src
;
7207 gif_read_from_memory (file
, buf
, len
)
7212 gif_memory_source
*src
= current_gif_memory_src
;
7214 if (len
> src
->len
- src
->index
)
7217 bcopy (src
->bytes
+ src
->index
, buf
, len
);
7223 /* Load GIF image IMG for use on frame F. Value is non-zero if
7231 Lisp_Object file
, specified_file
;
7232 Lisp_Object specified_data
;
7233 int rc
, width
, height
, x
, y
, i
;
7235 ColorMapObject
*gif_color_map
;
7236 unsigned long pixel_colors
[256];
7238 struct gcpro gcpro1
;
7240 int ino
, image_left
, image_top
, image_width
, image_height
;
7241 gif_memory_source memsrc
;
7242 unsigned char *raster
;
7244 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
7245 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
7249 if (NILP (specified_data
))
7251 file
= x_find_image_file (specified_file
);
7252 if (!STRINGP (file
))
7254 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
7259 /* Open the GIF file. Casting return value avoids a GCC warning
7261 gif
= (GifFileType
*)fn_DGifOpenFileName (SDATA (file
));
7264 image_error ("Cannot open `%s'", file
, Qnil
);
7271 /* Read from memory! */
7272 current_gif_memory_src
= &memsrc
;
7273 memsrc
.bytes
= SDATA (specified_data
);
7274 memsrc
.len
= SBYTES (specified_data
);
7277 /* Casting return value avoids a GCC warning on W32. */
7278 gif
= (GifFileType
*)fn_DGifOpen(&memsrc
, gif_read_from_memory
);
7281 image_error ("Cannot open memory source `%s'", img
->spec
, Qnil
);
7287 /* Read entire contents. */
7288 rc
= fn_DGifSlurp (gif
);
7289 if (rc
== GIF_ERROR
)
7291 image_error ("Error reading `%s'", img
->spec
, Qnil
);
7292 fn_DGifCloseFile (gif
);
7297 image
= image_spec_value (img
->spec
, QCindex
, NULL
);
7298 ino
= INTEGERP (image
) ? XFASTINT (image
) : 0;
7299 if (ino
>= gif
->ImageCount
)
7301 image_error ("Invalid image number `%s' in image `%s'",
7303 fn_DGifCloseFile (gif
);
7308 width
= img
->width
= max (gif
->SWidth
, gif
->Image
.Left
+ gif
->Image
.Width
);
7309 height
= img
->height
= max (gif
->SHeight
, gif
->Image
.Top
+ gif
->Image
.Height
);
7311 /* Create the X image and pixmap. */
7312 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
7314 fn_DGifCloseFile (gif
);
7319 /* Allocate colors. */
7320 gif_color_map
= gif
->SavedImages
[ino
].ImageDesc
.ColorMap
;
7322 gif_color_map
= gif
->SColorMap
;
7323 init_color_table ();
7324 bzero (pixel_colors
, sizeof pixel_colors
);
7326 for (i
= 0; i
< gif_color_map
->ColorCount
; ++i
)
7328 int r
= gif_color_map
->Colors
[i
].Red
<< 8;
7329 int g
= gif_color_map
->Colors
[i
].Green
<< 8;
7330 int b
= gif_color_map
->Colors
[i
].Blue
<< 8;
7331 pixel_colors
[i
] = lookup_rgb_color (f
, r
, g
, b
);
7334 #ifdef COLOR_TABLE_SUPPORT
7335 img
->colors
= colors_in_color_table (&img
->ncolors
);
7336 free_color_table ();
7337 #endif /* COLOR_TABLE_SUPPORT */
7339 /* Clear the part of the screen image that are not covered by
7340 the image from the GIF file. Full animated GIF support
7341 requires more than can be done here (see the gif89 spec,
7342 disposal methods). Let's simply assume that the part
7343 not covered by a sub-image is in the frame's background color. */
7344 image_top
= gif
->SavedImages
[ino
].ImageDesc
.Top
;
7345 image_left
= gif
->SavedImages
[ino
].ImageDesc
.Left
;
7346 image_width
= gif
->SavedImages
[ino
].ImageDesc
.Width
;
7347 image_height
= gif
->SavedImages
[ino
].ImageDesc
.Height
;
7349 for (y
= 0; y
< image_top
; ++y
)
7350 for (x
= 0; x
< width
; ++x
)
7351 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7353 for (y
= image_top
+ image_height
; y
< height
; ++y
)
7354 for (x
= 0; x
< width
; ++x
)
7355 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7357 for (y
= image_top
; y
< image_top
+ image_height
; ++y
)
7359 for (x
= 0; x
< image_left
; ++x
)
7360 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7361 for (x
= image_left
+ image_width
; x
< width
; ++x
)
7362 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7365 /* Read the GIF image into the X image. We use a local variable
7366 `raster' here because RasterBits below is a char *, and invites
7367 problems with bytes >= 0x80. */
7368 raster
= (unsigned char *) gif
->SavedImages
[ino
].RasterBits
;
7370 if (gif
->SavedImages
[ino
].ImageDesc
.Interlace
)
7372 static int interlace_start
[] = {0, 4, 2, 1};
7373 static int interlace_increment
[] = {8, 8, 4, 2};
7375 int row
= interlace_start
[0];
7379 for (y
= 0; y
< image_height
; y
++)
7381 if (row
>= image_height
)
7383 row
= interlace_start
[++pass
];
7384 while (row
>= image_height
)
7385 row
= interlace_start
[++pass
];
7388 for (x
= 0; x
< image_width
; x
++)
7390 int i
= raster
[(y
* image_width
) + x
];
7391 XPutPixel (ximg
, x
+ image_left
, row
+ image_top
,
7395 row
+= interlace_increment
[pass
];
7400 for (y
= 0; y
< image_height
; ++y
)
7401 for (x
= 0; x
< image_width
; ++x
)
7403 int i
= raster
[y
* image_width
+ x
];
7404 XPutPixel (ximg
, x
+ image_left
, y
+ image_top
, pixel_colors
[i
]);
7408 fn_DGifCloseFile (gif
);
7410 /* Maybe fill in the background field while we have ximg handy. */
7411 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
7412 /* Casting avoids a GCC warning. */
7413 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
7415 /* Put the image into the pixmap, then free the X image and its buffer. */
7416 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
7417 x_destroy_x_image (ximg
);
7423 #else /* !HAVE_GIF */
7431 Lisp_Object specified_file
, file
;
7432 Lisp_Object specified_data
;
7434 Boolean graphic_p
, movie_p
, prefer_graphic_p
;
7442 Lisp_Object specified_bg
;
7448 struct gcpro gcpro1
;
7453 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
7454 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
7456 if (NILP (specified_data
))
7458 /* Read from a file */
7462 err
= find_image_fsspec (specified_file
, &file
, &fss
);
7466 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
7471 err
= CanQuickTimeOpenFile (&fss
, kQTFileTypeGIF
, 0,
7472 &graphic_p
, &movie_p
, &prefer_graphic_p
, 0);
7476 if (!graphic_p
&& !movie_p
)
7478 if (prefer_graphic_p
)
7479 return image_load_qt_1 (f
, img
, kQTFileTypeGIF
, &fss
, NULL
);
7480 err
= OpenMovieFile (&fss
, &refnum
, fsRdPerm
);
7483 err
= NewMovieFromFile (&movie
, refnum
, NULL
, NULL
, 0, NULL
);
7484 CloseMovieFile (refnum
);
7487 image_error ("Error reading `%s'", file
, Qnil
);
7493 /* Memory source! */
7495 long file_type_atom
[3];
7497 err
= PtrToHand (SDATA (specified_data
), &dh
, SBYTES (specified_data
));
7500 image_error ("Cannot allocate data handle for `%s'",
7505 file_type_atom
[0] = EndianU32_NtoB (sizeof (long) * 3);
7506 file_type_atom
[1] = EndianU32_NtoB (kDataRefExtensionMacOSFileType
);
7507 file_type_atom
[2] = EndianU32_NtoB (kQTFileTypeGIF
);
7508 err
= PtrToHand (&dh
, &dref
, sizeof (Handle
));
7511 err
= PtrAndHand ("\p", dref
, 1);
7513 err
= PtrAndHand (file_type_atom
, dref
, sizeof (long) * 3);
7516 image_error ("Cannot allocate handle data ref for `%s'", img
->spec
, Qnil
);
7519 err
= CanQuickTimeOpenDataRef (dref
, HandleDataHandlerSubType
, &graphic_p
,
7520 &movie_p
, &prefer_graphic_p
, 0);
7524 if (!graphic_p
&& !movie_p
)
7526 if (prefer_graphic_p
)
7530 DisposeHandle (dref
);
7531 success_p
= image_load_qt_1 (f
, img
, kQTFileTypeGIF
, NULL
, dh
);
7535 err
= NewMovieFromDataRef (&movie
, 0, NULL
, dref
,
7536 HandleDataHandlerSubType
);
7537 DisposeHandle (dref
);
7542 image
= image_spec_value (img
->spec
, QCindex
, NULL
);
7543 ino
= INTEGERP (image
) ? XFASTINT (image
) : 0;
7544 track
= GetMovieIndTrack (movie
, 1);
7545 media
= GetTrackMedia (track
);
7546 nsamples
= GetMediaSampleCount (media
);
7547 if (ino
>= nsamples
)
7549 image_error ("Invalid image number `%s' in image `%s'",
7554 specified_bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
7555 if (!STRINGP (specified_bg
) ||
7556 !mac_defined_color (f
, SDATA (specified_bg
), &color
, 0))
7558 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
7559 color
.red
= RED16_FROM_ULONG (color
.pixel
);
7560 color
.green
= GREEN16_FROM_ULONG (color
.pixel
);
7561 color
.blue
= BLUE16_FROM_ULONG (color
.pixel
);
7563 GetMovieBox (movie
, &rect
);
7564 width
= img
->width
= rect
.right
- rect
.left
;
7565 height
= img
->height
= rect
.bottom
- rect
.top
;
7566 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
7569 GetGWorld (&old_port
, &old_gdh
);
7570 SetGWorld (ximg
, NULL
);
7571 bg_color
.red
= color
.red
;
7572 bg_color
.green
= color
.green
;
7573 bg_color
.blue
= color
.blue
;
7574 RGBBackColor (&bg_color
);
7575 SetGWorld (old_port
, old_gdh
);
7576 SetMovieActive (movie
, 1);
7577 SetMovieGWorld (movie
, ximg
, NULL
);
7578 SampleNumToMediaTime (media
, ino
+ 1, &time
, NULL
);
7579 SetMovieTimeValue (movie
, time
);
7580 MoviesTask (movie
, 0L);
7581 DisposeTrackMedia (media
);
7582 DisposeMovieTrack (track
);
7583 DisposeMovie (movie
);
7586 /* Maybe fill in the background field while we have ximg handy. */
7587 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
7588 IMAGE_BACKGROUND (img
, f
, ximg
);
7590 /* Put the image into the pixmap. */
7591 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
7592 x_destroy_x_image (ximg
);
7596 image_error ("Cannot open `%s'", file
, Qnil
);
7599 DisposeTrackMedia (media
);
7601 DisposeMovieTrack (track
);
7603 DisposeMovie (movie
);
7610 #endif /* HAVE_GIF */
7614 /***********************************************************************
7616 ***********************************************************************/
7618 #ifdef HAVE_X_WINDOWS
7619 #define HAVE_GHOSTSCRIPT 1
7620 #endif /* HAVE_X_WINDOWS */
7622 /* The symbol `postscript' identifying images of this type. */
7624 Lisp_Object Qpostscript
;
7626 #ifdef HAVE_GHOSTSCRIPT
7628 static int gs_image_p
P_ ((Lisp_Object object
));
7629 static int gs_load
P_ ((struct frame
*f
, struct image
*img
));
7630 static void gs_clear_image
P_ ((struct frame
*f
, struct image
*img
));
7632 /* Keyword symbols. */
7634 Lisp_Object QCloader
, QCbounding_box
, QCpt_width
, QCpt_height
;
7636 /* Indices of image specification fields in gs_format, below. */
7638 enum gs_keyword_index
7656 /* Vector of image_keyword structures describing the format
7657 of valid user-defined image specifications. */
7659 static struct image_keyword gs_format
[GS_LAST
] =
7661 {":type", IMAGE_SYMBOL_VALUE
, 1},
7662 {":pt-width", IMAGE_POSITIVE_INTEGER_VALUE
, 1},
7663 {":pt-height", IMAGE_POSITIVE_INTEGER_VALUE
, 1},
7664 {":file", IMAGE_STRING_VALUE
, 1},
7665 {":loader", IMAGE_FUNCTION_VALUE
, 0},
7666 {":bounding-box", IMAGE_DONT_CHECK_VALUE_TYPE
, 1},
7667 {":ascent", IMAGE_ASCENT_VALUE
, 0},
7668 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
7669 {":relief", IMAGE_INTEGER_VALUE
, 0},
7670 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7671 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7672 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7673 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
7676 /* Structure describing the image type `ghostscript'. */
7678 static struct image_type gs_type
=
7688 /* Free X resources of Ghostscript image IMG which is used on frame F. */
7691 gs_clear_image (f
, img
)
7695 /* IMG->data.ptr_val may contain a recorded colormap. */
7696 xfree (img
->data
.ptr_val
);
7697 x_clear_image (f
, img
);
7701 /* Return non-zero if OBJECT is a valid Ghostscript image
7708 struct image_keyword fmt
[GS_LAST
];
7712 bcopy (gs_format
, fmt
, sizeof fmt
);
7714 if (!parse_image_spec (object
, fmt
, GS_LAST
, Qpostscript
))
7717 /* Bounding box must be a list or vector containing 4 integers. */
7718 tem
= fmt
[GS_BOUNDING_BOX
].value
;
7721 for (i
= 0; i
< 4; ++i
, tem
= XCDR (tem
))
7722 if (!CONSP (tem
) || !INTEGERP (XCAR (tem
)))
7727 else if (VECTORP (tem
))
7729 if (XVECTOR (tem
)->size
!= 4)
7731 for (i
= 0; i
< 4; ++i
)
7732 if (!INTEGERP (XVECTOR (tem
)->contents
[i
]))
7742 /* Load Ghostscript image IMG for use on frame F. Value is non-zero
7751 Lisp_Object window_and_pixmap_id
= Qnil
, loader
, pt_height
, pt_width
;
7752 struct gcpro gcpro1
, gcpro2
;
7754 double in_width
, in_height
;
7755 Lisp_Object pixel_colors
= Qnil
;
7757 /* Compute pixel size of pixmap needed from the given size in the
7758 image specification. Sizes in the specification are in pt. 1 pt
7759 = 1/72 in, xdpi and ydpi are stored in the frame's X display
7761 pt_width
= image_spec_value (img
->spec
, QCpt_width
, NULL
);
7762 in_width
= XFASTINT (pt_width
) / 72.0;
7763 img
->width
= in_width
* FRAME_X_DISPLAY_INFO (f
)->resx
;
7764 pt_height
= image_spec_value (img
->spec
, QCpt_height
, NULL
);
7765 in_height
= XFASTINT (pt_height
) / 72.0;
7766 img
->height
= in_height
* FRAME_X_DISPLAY_INFO (f
)->resy
;
7768 /* Create the pixmap. */
7769 xassert (img
->pixmap
== NO_PIXMAP
);
7771 /* Only W32 version did BLOCK_INPUT here. ++kfs */
7773 img
->pixmap
= XCreatePixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
7774 img
->width
, img
->height
,
7775 DefaultDepthOfScreen (FRAME_X_SCREEN (f
)));
7780 image_error ("Unable to create pixmap for `%s'", img
->spec
, Qnil
);
7784 /* Call the loader to fill the pixmap. It returns a process object
7785 if successful. We do not record_unwind_protect here because
7786 other places in redisplay like calling window scroll functions
7787 don't either. Let the Lisp loader use `unwind-protect' instead. */
7788 GCPRO2 (window_and_pixmap_id
, pixel_colors
);
7790 sprintf (buffer
, "%lu %lu",
7791 (unsigned long) FRAME_X_WINDOW (f
),
7792 (unsigned long) img
->pixmap
);
7793 window_and_pixmap_id
= build_string (buffer
);
7795 sprintf (buffer
, "%lu %lu",
7796 FRAME_FOREGROUND_PIXEL (f
),
7797 FRAME_BACKGROUND_PIXEL (f
));
7798 pixel_colors
= build_string (buffer
);
7800 XSETFRAME (frame
, f
);
7801 loader
= image_spec_value (img
->spec
, QCloader
, NULL
);
7803 loader
= intern ("gs-load-image");
7805 img
->data
.lisp_val
= call6 (loader
, frame
, img
->spec
,
7806 make_number (img
->width
),
7807 make_number (img
->height
),
7808 window_and_pixmap_id
,
7811 return PROCESSP (img
->data
.lisp_val
);
7815 /* Kill the Ghostscript process that was started to fill PIXMAP on
7816 frame F. Called from XTread_socket when receiving an event
7817 telling Emacs that Ghostscript has finished drawing. */
7820 x_kill_gs_process (pixmap
, f
)
7824 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
7828 /* Find the image containing PIXMAP. */
7829 for (i
= 0; i
< c
->used
; ++i
)
7830 if (c
->images
[i
]->pixmap
== pixmap
)
7833 /* Should someone in between have cleared the image cache, for
7834 instance, give up. */
7838 /* Kill the GS process. We should have found PIXMAP in the image
7839 cache and its image should contain a process object. */
7841 xassert (PROCESSP (img
->data
.lisp_val
));
7842 Fkill_process (img
->data
.lisp_val
, Qnil
);
7843 img
->data
.lisp_val
= Qnil
;
7845 #if defined (HAVE_X_WINDOWS)
7847 /* On displays with a mutable colormap, figure out the colors
7848 allocated for the image by looking at the pixels of an XImage for
7850 class = FRAME_X_VISUAL (f
)->class;
7851 if (class != StaticColor
&& class != StaticGray
&& class != TrueColor
)
7857 /* Try to get an XImage for img->pixmep. */
7858 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
7859 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
7864 /* Initialize the color table. */
7865 init_color_table ();
7867 /* For each pixel of the image, look its color up in the
7868 color table. After having done so, the color table will
7869 contain an entry for each color used by the image. */
7870 for (y
= 0; y
< img
->height
; ++y
)
7871 for (x
= 0; x
< img
->width
; ++x
)
7873 unsigned long pixel
= XGetPixel (ximg
, x
, y
);
7874 lookup_pixel_color (f
, pixel
);
7877 /* Record colors in the image. Free color table and XImage. */
7878 #ifdef COLOR_TABLE_SUPPORT
7879 img
->colors
= colors_in_color_table (&img
->ncolors
);
7880 free_color_table ();
7882 XDestroyImage (ximg
);
7884 #if 0 /* This doesn't seem to be the case. If we free the colors
7885 here, we get a BadAccess later in x_clear_image when
7886 freeing the colors. */
7887 /* We have allocated colors once, but Ghostscript has also
7888 allocated colors on behalf of us. So, to get the
7889 reference counts right, free them once. */
7891 x_free_colors (f
, img
->colors
, img
->ncolors
);
7895 image_error ("Cannot get X image of `%s'; colors will not be freed",
7900 #endif /* HAVE_X_WINDOWS */
7902 /* Now that we have the pixmap, compute mask and transform the
7903 image if requested. */
7905 postprocess_image (f
, img
);
7909 #endif /* HAVE_GHOSTSCRIPT */
7912 /***********************************************************************
7914 ***********************************************************************/
7918 DEFUN ("imagep", Fimagep
, Simagep
, 1, 1, 0,
7919 doc
: /* Value is non-nil if SPEC is a valid image specification. */)
7923 return valid_image_p (spec
) ? Qt
: Qnil
;
7927 DEFUN ("lookup-image", Flookup_image
, Slookup_image
, 1, 1, 0, "")
7933 if (valid_image_p (spec
))
7934 id
= lookup_image (SELECTED_FRAME (), spec
);
7937 return make_number (id
);
7940 #endif /* GLYPH_DEBUG != 0 */
7943 /***********************************************************************
7945 ***********************************************************************/
7948 /* Image types that rely on external libraries are loaded dynamically
7949 if the library is available. */
7950 #define CHECK_LIB_AVAILABLE(image_type, init_lib_fn, libraries) \
7951 define_image_type (image_type, init_lib_fn (libraries))
7953 #define CHECK_LIB_AVAILABLE(image_type, init_lib_fn, libraries) \
7954 define_image_type (image_type, 1)
7955 #endif /* HAVE_NTGUI */
7957 DEFUN ("init-image-library", Finit_image_library
, Sinit_image_library
, 2, 2, 0,
7958 doc
: /* Initialize image library implementing image type TYPE.
7959 Return non-nil if TYPE is a supported image type.
7961 Image types pbm and xbm are prebuilt; other types are loaded here.
7962 Libraries to load are specified in alist LIBRARIES (usually, the value
7963 of `image-library-alist', which see). */)
7965 Lisp_Object type
, libraries
;
7969 /* Don't try to reload the library. */
7970 tested
= Fassq (type
, Vimage_type_cache
);
7972 return XCDR (tested
);
7974 #if defined (HAVE_XPM) || defined (MAC_OS)
7975 if (EQ (type
, Qxpm
))
7976 return CHECK_LIB_AVAILABLE (&xpm_type
, init_xpm_functions
, libraries
);
7979 #if defined (HAVE_JPEG) || defined (MAC_OS)
7980 if (EQ (type
, Qjpeg
))
7981 return CHECK_LIB_AVAILABLE (&jpeg_type
, init_jpeg_functions
, libraries
);
7984 #if defined (HAVE_TIFF) || defined (MAC_OS)
7985 if (EQ (type
, Qtiff
))
7986 return CHECK_LIB_AVAILABLE (&tiff_type
, init_tiff_functions
, libraries
);
7989 #if defined (HAVE_GIF) || defined (MAC_OS)
7990 if (EQ (type
, Qgif
))
7991 return CHECK_LIB_AVAILABLE (&gif_type
, init_gif_functions
, libraries
);
7994 #if defined (HAVE_PNG) || defined (MAC_OS)
7995 if (EQ (type
, Qpng
))
7996 return CHECK_LIB_AVAILABLE (&png_type
, init_png_functions
, libraries
);
7999 #ifdef HAVE_GHOSTSCRIPT
8000 if (EQ (type
, Qpostscript
))
8001 return CHECK_LIB_AVAILABLE (&gs_type
, init_gs_functions
, libraries
);
8004 /* If the type is not recognized, avoid testing it ever again. */
8005 CACHE_IMAGE_TYPE (type
, Qnil
);
8012 extern Lisp_Object Qrisky_local_variable
; /* Syms_of_xdisp has already run. */
8014 /* Must be defined now becase we're going to update it below, while
8015 defining the supported image types. */
8016 DEFVAR_LISP ("image-types", &Vimage_types
,
8017 doc
: /* List of potentially supported image types.
8018 Each element of the list is a symbol for a image type, like 'jpeg or 'png.
8019 To check whether it is really supported, use `image-type-available-p'. */);
8020 Vimage_types
= Qnil
;
8022 DEFVAR_LISP ("image-library-alist", &Vimage_library_alist
,
8023 doc
: /* Alist of image types vs external libraries needed to display them.
8025 Each element is a list (IMAGE-TYPE LIBRARY...), where the car is a symbol
8026 representing a supported image type, and the rest are strings giving
8027 alternate filenames for the corresponding external libraries.
8029 Emacs tries to load the libraries in the order they appear on the
8030 list; if none is loaded, the running session of Emacs won't
8031 support the image type. Types 'pbm and 'xbm don't need to be
8032 listed; they're always supported. */);
8033 Vimage_library_alist
= Qnil
;
8034 Fput (intern ("image-library-alist"), Qrisky_local_variable
, Qt
);
8036 Vimage_type_cache
= Qnil
;
8037 staticpro (&Vimage_type_cache
);
8039 QCascent
= intern (":ascent");
8040 staticpro (&QCascent
);
8041 QCmargin
= intern (":margin");
8042 staticpro (&QCmargin
);
8043 QCrelief
= intern (":relief");
8044 staticpro (&QCrelief
);
8045 QCconversion
= intern (":conversion");
8046 staticpro (&QCconversion
);
8047 QCcolor_symbols
= intern (":color-symbols");
8048 staticpro (&QCcolor_symbols
);
8049 QCheuristic_mask
= intern (":heuristic-mask");
8050 staticpro (&QCheuristic_mask
);
8051 QCindex
= intern (":index");
8052 staticpro (&QCindex
);
8053 QCmatrix
= intern (":matrix");
8054 staticpro (&QCmatrix
);
8055 QCcolor_adjustment
= intern (":color-adjustment");
8056 staticpro (&QCcolor_adjustment
);
8057 QCmask
= intern (":mask");
8058 staticpro (&QCmask
);
8060 Qlaplace
= intern ("laplace");
8061 staticpro (&Qlaplace
);
8062 Qemboss
= intern ("emboss");
8063 staticpro (&Qemboss
);
8064 Qedge_detection
= intern ("edge-detection");
8065 staticpro (&Qedge_detection
);
8066 Qheuristic
= intern ("heuristic");
8067 staticpro (&Qheuristic
);
8069 Qpostscript
= intern ("postscript");
8070 staticpro (&Qpostscript
);
8071 #ifdef HAVE_GHOSTSCRIPT
8072 ADD_IMAGE_TYPE(Qpostscript
);
8073 QCloader
= intern (":loader");
8074 staticpro (&QCloader
);
8075 QCbounding_box
= intern (":bounding-box");
8076 staticpro (&QCbounding_box
);
8077 QCpt_width
= intern (":pt-width");
8078 staticpro (&QCpt_width
);
8079 QCpt_height
= intern (":pt-height");
8080 staticpro (&QCpt_height
);
8081 #endif /* HAVE_GHOSTSCRIPT */
8083 Qpbm
= intern ("pbm");
8085 ADD_IMAGE_TYPE(Qpbm
);
8087 Qxbm
= intern ("xbm");
8089 ADD_IMAGE_TYPE(Qxbm
);
8091 #if defined (HAVE_XPM) || defined (MAC_OS)
8092 Qxpm
= intern ("xpm");
8094 ADD_IMAGE_TYPE(Qxpm
);
8097 #if defined (HAVE_JPEG) || defined (MAC_OS)
8098 Qjpeg
= intern ("jpeg");
8100 ADD_IMAGE_TYPE(Qjpeg
);
8103 #if defined (HAVE_TIFF) || defined (MAC_OS)
8104 Qtiff
= intern ("tiff");
8106 ADD_IMAGE_TYPE(Qtiff
);
8109 #if defined (HAVE_GIF) || defined (MAC_OS)
8110 Qgif
= intern ("gif");
8112 ADD_IMAGE_TYPE(Qgif
);
8115 #if defined (HAVE_PNG) || defined (MAC_OS)
8116 Qpng
= intern ("png");
8118 ADD_IMAGE_TYPE(Qpng
);
8121 defsubr (&Sinit_image_library
);
8122 defsubr (&Sclear_image_cache
);
8123 defsubr (&Simage_size
);
8124 defsubr (&Simage_mask_p
);
8128 defsubr (&Slookup_image
);
8131 DEFVAR_BOOL ("cross-disabled-images", &cross_disabled_images
,
8132 doc
: /* Non-nil means always draw a cross over disabled images.
8133 Disabled images are those having an `:conversion disabled' property.
8134 A cross is always drawn on black & white displays. */);
8135 cross_disabled_images
= 0;
8137 DEFVAR_LISP ("x-bitmap-file-path", &Vx_bitmap_file_path
,
8138 doc
: /* List of directories to search for window system bitmap files. */);
8139 Vx_bitmap_file_path
= decode_env_path ((char *) 0, PATH_BITMAPS
);
8141 DEFVAR_LISP ("image-cache-eviction-delay", &Vimage_cache_eviction_delay
,
8142 doc
: /* Time after which cached images are removed from the cache.
8143 When an image has not been displayed this many seconds, remove it
8144 from the image cache. Value must be an integer or nil with nil
8145 meaning don't clear the cache. */);
8146 Vimage_cache_eviction_delay
= make_number (30 * 60);
8154 define_image_type (&xbm_type
, 1);
8155 define_image_type (&pbm_type
, 1);
8158 /* Animated gifs use QuickTime Movie Toolbox. So initialize it here. */
8161 init_image_func_pointer ();
8166 /* arch-tag: 123c2a5e-14a8-4c53-ab95-af47d7db49b9
8167 (do not change this comment) */