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. */
32 /* This makes the fields of a Display accessible, in Xlib header files. */
34 #define XLIB_ILLEGAL_ACCESS
39 #include "dispextern.h"
40 #include "blockinput.h"
47 #include <sys/types.h>
50 #define COLOR_TABLE_SUPPORT 1
52 typedef struct x_bitmap_record Bitmap_Record
;
53 #define GET_PIXEL(ximg, x, y) XGetPixel(ximg, x, y)
54 #define NO_PIXMAP None
56 #define RGB_PIXEL_COLOR unsigned long
58 #define PIX_MASK_RETAIN(f) 0
59 #define PIX_MASK_DRAW(f) 1
60 #endif /* HAVE_X_WINDOWS */
66 /* W32_TODO : Color tables on W32. */
67 #undef COLOR_TABLE_SUPPORT
69 typedef struct w32_bitmap_record Bitmap_Record
;
70 #define GET_PIXEL(ximg, x, y) GetPixel(ximg, x, y)
73 #define RGB_PIXEL_COLOR COLORREF
75 #define PIX_MASK_RETAIN(f) 0
76 #define PIX_MASK_DRAW(f) 1
78 #define FRAME_X_VISUAL(f) FRAME_X_DISPLAY_INFO (f)->visual
79 #define x_defined_color w32_defined_color
80 #define DefaultDepthOfScreen(screen) (one_w32_display_info.n_cbits)
81 #endif /* HAVE_NTGUI */
89 #include <sys/param.h>
91 #if TARGET_API_MAC_CARBON
93 #include <QuickTime/QuickTime.h>
94 #else /* not MAC_OSX */
95 #include <QuickTime.h>
96 #endif /* not MAC_OSX */
97 #else /* not TARGET_API_MAC_CARBON */
100 #include <TextUtils.h>
101 #include <ImageCompression.h>
102 #include <QuickTimeComponents.h>
103 #endif /* not TARGET_API_MAC_CARBON */
105 /* MAC_TODO : Color tables on Mac. */
106 #undef COLOR_TABLE_SUPPORT
108 #define ZPixmap 0 /* arbitrary */
109 typedef struct mac_bitmap_record Bitmap_Record
;
111 #define GET_PIXEL(ximg, x, y) XGetPixel(ximg, x, y)
114 #define RGB_PIXEL_COLOR unsigned long
116 #define FRAME_X_VISUAL(f) FRAME_X_DISPLAY_INFO (f)->visual
117 #define x_defined_color mac_defined_color
118 #define DefaultDepthOfScreen(screen) (one_mac_display_info.n_planes)
119 #define XDrawLine(display, w, gc, x1, y1, x2, y2) \
120 mac_draw_line_to_pixmap(display, w, gc, x1, y1, x2, y2)
125 /* Search path for bitmap files. */
127 Lisp_Object Vx_bitmap_file_path
;
130 static void x_disable_image
P_ ((struct frame
*, struct image
*));
131 static void x_edge_detection
P_ ((struct frame
*, struct image
*, Lisp_Object
,
134 static void init_color_table
P_ ((void));
135 static unsigned long lookup_rgb_color
P_ ((struct frame
*f
, int r
, int g
, int b
));
136 #ifdef COLOR_TABLE_SUPPORT
137 static void free_color_table
P_ ((void));
138 static unsigned long *colors_in_color_table
P_ ((int *n
));
139 static unsigned long lookup_pixel_color
P_ ((struct frame
*f
, unsigned long p
));
142 /* Code to deal with bitmaps. Bitmaps are referenced by their bitmap
143 id, which is just an int that this section returns. Bitmaps are
144 reference counted so they can be shared among frames.
146 Bitmap indices are guaranteed to be > 0, so a negative number can
147 be used to indicate no bitmap.
149 If you use x_create_bitmap_from_data, then you must keep track of
150 the bitmaps yourself. That is, creating a bitmap from the same
151 data more than once will not be caught. */
156 XGetImage (display
, pixmap
, x
, y
, width
, height
, plane_mask
, format
)
157 Display
*display
; /* not used */
159 int x
, y
; /* not used */
160 unsigned int width
, height
; /* not used */
161 unsigned long plane_mask
; /* not used */
162 int format
; /* not used */
165 xassert (x
== 0 && y
== 0);
168 SetRect (&ri
, 0, 0, width
, height
);
169 xassert (EqualRect (&ri
, GetPixBounds (GetGWorldPixMap (pixmap
), &rp
)));
171 xassert (! (pixelsLocked
& GetPixelsState (GetGWorldPixMap (pixmap
))));
174 LockPixels (GetGWorldPixMap (pixmap
));
180 XPutPixel (ximage
, x
, y
, pixel
)
189 GetGWorld (&old_port
, &old_gdh
);
190 SetGWorld (ximage
, NULL
);
192 color
.red
= RED16_FROM_ULONG (pixel
);
193 color
.green
= GREEN16_FROM_ULONG (pixel
);
194 color
.blue
= BLUE16_FROM_ULONG (pixel
);
195 SetCPixel (x
, y
, &color
);
197 SetGWorld (old_port
, old_gdh
);
201 XGetPixel (ximage
, x
, y
)
209 GetGWorld (&old_port
, &old_gdh
);
210 SetGWorld (ximage
, NULL
);
212 GetCPixel (x
, y
, &color
);
214 SetGWorld (old_port
, old_gdh
);
215 return RGB_TO_ULONG (color
.red
>> 8, color
.green
>> 8, color
.blue
>> 8);
222 UnlockPixels (GetGWorldPixMap (ximg
));
227 /* Functions to access the contents of a bitmap, given an id. */
230 x_bitmap_height (f
, id
)
234 return FRAME_X_DISPLAY_INFO (f
)->bitmaps
[id
- 1].height
;
238 x_bitmap_width (f
, id
)
242 return FRAME_X_DISPLAY_INFO (f
)->bitmaps
[id
- 1].width
;
245 #if defined (HAVE_X_WINDOWS) || defined (HAVE_NTGUI)
247 x_bitmap_pixmap (f
, id
)
251 return (int) FRAME_X_DISPLAY_INFO (f
)->bitmaps
[id
- 1].pixmap
;
255 #ifdef HAVE_X_WINDOWS
257 x_bitmap_mask (f
, id
)
261 return FRAME_X_DISPLAY_INFO (f
)->bitmaps
[id
- 1].mask
;
265 /* Allocate a new bitmap record. Returns index of new record. */
268 x_allocate_bitmap_record (f
)
271 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
274 if (dpyinfo
->bitmaps
== NULL
)
276 dpyinfo
->bitmaps_size
= 10;
278 = (Bitmap_Record
*) xmalloc (dpyinfo
->bitmaps_size
* sizeof (Bitmap_Record
));
279 dpyinfo
->bitmaps_last
= 1;
283 if (dpyinfo
->bitmaps_last
< dpyinfo
->bitmaps_size
)
284 return ++dpyinfo
->bitmaps_last
;
286 for (i
= 0; i
< dpyinfo
->bitmaps_size
; ++i
)
287 if (dpyinfo
->bitmaps
[i
].refcount
== 0)
290 dpyinfo
->bitmaps_size
*= 2;
292 = (Bitmap_Record
*) xrealloc (dpyinfo
->bitmaps
,
293 dpyinfo
->bitmaps_size
* sizeof (Bitmap_Record
));
294 return ++dpyinfo
->bitmaps_last
;
297 /* Add one reference to the reference count of the bitmap with id ID. */
300 x_reference_bitmap (f
, id
)
304 ++FRAME_X_DISPLAY_INFO (f
)->bitmaps
[id
- 1].refcount
;
307 /* Create a bitmap for frame F from a HEIGHT x WIDTH array of bits at BITS. */
310 x_create_bitmap_from_data (f
, bits
, width
, height
)
313 unsigned int width
, height
;
315 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
318 #ifdef HAVE_X_WINDOWS
320 bitmap
= XCreateBitmapFromData (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
321 bits
, width
, height
);
324 #endif /* HAVE_X_WINDOWS */
328 bitmap
= CreateBitmap (width
, height
,
329 FRAME_X_DISPLAY_INFO (XFRAME (frame
))->n_planes
,
330 FRAME_X_DISPLAY_INFO (XFRAME (frame
))->n_cbits
,
334 #endif /* HAVE_NTGUI */
337 /* MAC_TODO: for now fail if width is not mod 16 (toolbox requires it) */
342 id
= x_allocate_bitmap_record (f
);
344 dpyinfo
->bitmaps
[id
- 1].bitmap_data
= (char *) xmalloc (height
* width
);
345 if (! dpyinfo
->bitmaps
[id
- 1].bitmap_data
)
347 bcopy (bits
, dpyinfo
->bitmaps
[id
- 1].bitmap_data
, height
* width
);
350 dpyinfo
->bitmaps
[id
- 1].file
= NULL
;
351 dpyinfo
->bitmaps
[id
- 1].height
= height
;
352 dpyinfo
->bitmaps
[id
- 1].width
= width
;
353 dpyinfo
->bitmaps
[id
- 1].refcount
= 1;
355 #ifdef HAVE_X_WINDOWS
356 dpyinfo
->bitmaps
[id
- 1].pixmap
= bitmap
;
357 dpyinfo
->bitmaps
[id
- 1].have_mask
= 0;
358 dpyinfo
->bitmaps
[id
- 1].depth
= 1;
359 #endif /* HAVE_X_WINDOWS */
362 dpyinfo
->bitmaps
[id
- 1].pixmap
= bitmap
;
363 dpyinfo
->bitmaps
[id
- 1].hinst
= NULL
;
364 dpyinfo
->bitmaps
[id
- 1].depth
= 1;
365 #endif /* HAVE_NTGUI */
370 /* Create bitmap from file FILE for frame F. */
373 x_create_bitmap_from_file (f
, file
)
378 return -1; /* MAC_TODO : bitmap support */
382 return -1; /* W32_TODO : bitmap support */
383 #endif /* HAVE_NTGUI */
385 #ifdef HAVE_X_WINDOWS
386 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
387 unsigned int width
, height
;
389 int xhot
, yhot
, result
, id
;
394 /* Look for an existing bitmap with the same name. */
395 for (id
= 0; id
< dpyinfo
->bitmaps_last
; ++id
)
397 if (dpyinfo
->bitmaps
[id
].refcount
398 && dpyinfo
->bitmaps
[id
].file
399 && !strcmp (dpyinfo
->bitmaps
[id
].file
, (char *) SDATA (file
)))
401 ++dpyinfo
->bitmaps
[id
].refcount
;
406 /* Search bitmap-file-path for the file, if appropriate. */
407 fd
= openp (Vx_bitmap_file_path
, file
, Qnil
, &found
, Qnil
);
412 filename
= (char *) SDATA (found
);
414 result
= XReadBitmapFile (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
415 filename
, &width
, &height
, &bitmap
, &xhot
, &yhot
);
416 if (result
!= BitmapSuccess
)
419 id
= x_allocate_bitmap_record (f
);
420 dpyinfo
->bitmaps
[id
- 1].pixmap
= bitmap
;
421 dpyinfo
->bitmaps
[id
- 1].have_mask
= 0;
422 dpyinfo
->bitmaps
[id
- 1].refcount
= 1;
423 dpyinfo
->bitmaps
[id
- 1].file
= (char *) xmalloc (SBYTES (file
) + 1);
424 dpyinfo
->bitmaps
[id
- 1].depth
= 1;
425 dpyinfo
->bitmaps
[id
- 1].height
= height
;
426 dpyinfo
->bitmaps
[id
- 1].width
= width
;
427 strcpy (dpyinfo
->bitmaps
[id
- 1].file
, SDATA (file
));
430 #endif /* HAVE_X_WINDOWS */
436 Free_Bitmap_Record (dpyinfo
, bm
)
437 Display_Info
*dpyinfo
;
440 #ifdef HAVE_X_WINDOWS
441 XFreePixmap (dpyinfo
->display
, bm
->pixmap
);
443 XFreePixmap (dpyinfo
->display
, bm
->mask
);
444 #endif /* HAVE_X_WINDOWS */
447 DeleteObject (bm
->pixmap
);
448 #endif /* HAVE_NTGUI */
451 xfree (bm
->bitmap_data
); /* Added ++kfs */
452 bm
->bitmap_data
= NULL
;
462 /* Remove reference to bitmap with id number ID. */
465 x_destroy_bitmap (f
, id
)
469 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
473 Bitmap_Record
*bm
= &dpyinfo
->bitmaps
[id
- 1];
475 if (--bm
->refcount
== 0)
478 Free_Bitmap_Record (dpyinfo
, bm
);
484 /* Free all the bitmaps for the display specified by DPYINFO. */
487 x_destroy_all_bitmaps (dpyinfo
)
488 Display_Info
*dpyinfo
;
491 Bitmap_Record
*bm
= dpyinfo
->bitmaps
;
493 for (i
= 0; i
< dpyinfo
->bitmaps_last
; i
++, bm
++)
494 if (bm
->refcount
> 0)
495 Free_Bitmap_Record (dpyinfo
, bm
);
497 dpyinfo
->bitmaps_last
= 0;
501 #ifdef HAVE_X_WINDOWS
503 /* Useful functions defined in the section
504 `Image type independent image structures' below. */
506 static unsigned long four_corners_best
P_ ((XImagePtr ximg
, unsigned long width
,
507 unsigned long height
));
509 static int x_create_x_image_and_pixmap
P_ ((struct frame
*f
, int width
, int height
,
510 int depth
, XImagePtr
*ximg
,
513 static void x_destroy_x_image
P_ ((XImagePtr ximg
));
516 /* Create a mask of a bitmap. Note is this not a perfect mask.
517 It's nicer with some borders in this context */
520 x_create_bitmap_mask (f
, id
)
525 XImagePtr ximg
, mask_img
;
526 unsigned long width
, height
;
529 unsigned long x
, y
, xp
, xm
, yp
, ym
;
532 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
537 pixmap
= x_bitmap_pixmap (f
, id
);
538 width
= x_bitmap_width (f
, id
);
539 height
= x_bitmap_height (f
, id
);
542 ximg
= XGetImage (FRAME_X_DISPLAY (f
), pixmap
, 0, 0, width
, height
,
551 result
= x_create_x_image_and_pixmap (f
, width
, height
, 1, &mask_img
, &mask
);
556 XDestroyImage (ximg
);
560 bg
= four_corners_best (ximg
, width
, height
);
562 for (y
= 0; y
< ximg
->height
; ++y
)
564 for (x
= 0; x
< ximg
->width
; ++x
)
566 xp
= x
!= ximg
->width
- 1 ? x
+ 1 : 0;
567 xm
= x
!= 0 ? x
- 1 : ximg
->width
- 1;
568 yp
= y
!= ximg
->height
- 1 ? y
+ 1 : 0;
569 ym
= y
!= 0 ? y
- 1 : ximg
->height
- 1;
570 if (XGetPixel (ximg
, x
, y
) == bg
571 && XGetPixel (ximg
, x
, yp
) == bg
572 && XGetPixel (ximg
, x
, ym
) == bg
573 && XGetPixel (ximg
, xp
, y
) == bg
574 && XGetPixel (ximg
, xp
, yp
) == bg
575 && XGetPixel (ximg
, xp
, ym
) == bg
576 && XGetPixel (ximg
, xm
, y
) == bg
577 && XGetPixel (ximg
, xm
, yp
) == bg
578 && XGetPixel (ximg
, xm
, ym
) == bg
)
579 XPutPixel (mask_img
, x
, y
, 0);
581 XPutPixel (mask_img
, x
, y
, 1);
585 xassert (interrupt_input_blocked
);
586 gc
= XCreateGC (FRAME_X_DISPLAY (f
), mask
, 0, NULL
);
587 XPutImage (FRAME_X_DISPLAY (f
), mask
, gc
, mask_img
, 0, 0, 0, 0,
589 XFreeGC (FRAME_X_DISPLAY (f
), gc
);
591 dpyinfo
->bitmaps
[id
- 1].have_mask
= 1;
592 dpyinfo
->bitmaps
[id
- 1].mask
= mask
;
594 XDestroyImage (ximg
);
595 x_destroy_x_image (mask_img
);
600 #endif /* HAVE_X_WINDOWS */
603 /***********************************************************************
605 ***********************************************************************/
607 /* Value is the number of elements of vector VECTOR. */
609 #define DIM(VECTOR) (sizeof (VECTOR) / sizeof *(VECTOR))
611 /* List of supported image types. Use define_image_type to add new
612 types. Use lookup_image_type to find a type for a given symbol. */
614 static struct image_type
*image_types
;
616 /* A list of symbols, one for each supported image type. */
618 Lisp_Object Vimage_types
;
620 /* Cache for delayed-loading image types. */
622 static Lisp_Object Vimage_type_cache
;
624 /* The symbol `xbm' which is used as the type symbol for XBM images. */
630 extern Lisp_Object QCwidth
, QCheight
, QCforeground
, QCbackground
, QCfile
;
631 extern Lisp_Object QCdata
, QCtype
;
632 extern Lisp_Object Qcenter
;
633 Lisp_Object QCascent
, QCmargin
, QCrelief
;
634 Lisp_Object QCconversion
, QCcolor_symbols
, QCheuristic_mask
;
635 Lisp_Object QCindex
, QCmatrix
, QCcolor_adjustment
, QCmask
;
639 Lisp_Object Qlaplace
, Qemboss
, Qedge_detection
, Qheuristic
;
641 /* Time in seconds after which images should be removed from the cache
644 Lisp_Object Vimage_cache_eviction_delay
;
646 /* Function prototypes. */
648 static Lisp_Object define_image_type
P_ ((struct image_type
*type
, int loaded
));
649 static struct image_type
*lookup_image_type
P_ ((Lisp_Object symbol
));
650 static void image_error
P_ ((char *format
, Lisp_Object
, Lisp_Object
));
651 static void x_laplace
P_ ((struct frame
*, struct image
*));
652 static void x_emboss
P_ ((struct frame
*, struct image
*));
653 static int x_build_heuristic_mask
P_ ((struct frame
*, struct image
*,
656 #define CACHE_IMAGE_TYPE(type, status) \
657 do { Vimage_type_cache = Fcons (Fcons (type, status), Vimage_type_cache); } while (0)
659 #define ADD_IMAGE_TYPE(type) \
660 do { Vimage_types = Fcons (type, Vimage_types); } while (0)
662 /* Define a new image type from TYPE. This adds a copy of TYPE to
663 image_types and caches the loading status of TYPE. */
666 define_image_type (type
, loaded
)
667 struct image_type
*type
;
676 /* Make a copy of TYPE to avoid a bus error in a dumped Emacs.
677 The initialized data segment is read-only. */
678 struct image_type
*p
= (struct image_type
*) xmalloc (sizeof *p
);
679 bcopy (type
, p
, sizeof *p
);
680 p
->next
= image_types
;
685 CACHE_IMAGE_TYPE (*type
->type
, success
);
690 /* Look up image type SYMBOL, and return a pointer to its image_type
691 structure. Value is null if SYMBOL is not a known image type. */
693 static INLINE
struct image_type
*
694 lookup_image_type (symbol
)
697 struct image_type
*type
;
699 /* We must initialize the image-type if it hasn't been already. */
700 if (NILP (Finit_image_library (symbol
, Qnil
)))
701 return 0; /* unimplemented */
703 for (type
= image_types
; type
; type
= type
->next
)
704 if (EQ (symbol
, *type
->type
))
711 /* Value is non-zero if OBJECT is a valid Lisp image specification. A
712 valid image specification is a list whose car is the symbol
713 `image', and whose rest is a property list. The property list must
714 contain a value for key `:type'. That value must be the name of a
715 supported image type. The rest of the property list depends on the
719 valid_image_p (object
)
728 for (tem
= XCDR (object
); CONSP (tem
); tem
= XCDR (tem
))
729 if (EQ (XCAR (tem
), QCtype
))
732 if (CONSP (tem
) && SYMBOLP (XCAR (tem
)))
734 struct image_type
*type
;
735 type
= lookup_image_type (XCAR (tem
));
737 valid_p
= type
->valid_p (object
);
748 /* Log error message with format string FORMAT and argument ARG.
749 Signaling an error, e.g. when an image cannot be loaded, is not a
750 good idea because this would interrupt redisplay, and the error
751 message display would lead to another redisplay. This function
752 therefore simply displays a message. */
755 image_error (format
, arg1
, arg2
)
757 Lisp_Object arg1
, arg2
;
759 add_to_log (format
, arg1
, arg2
);
764 /***********************************************************************
766 ***********************************************************************/
768 enum image_value_type
770 IMAGE_DONT_CHECK_VALUE_TYPE
,
772 IMAGE_STRING_OR_NIL_VALUE
,
774 IMAGE_POSITIVE_INTEGER_VALUE
,
775 IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
,
776 IMAGE_NON_NEGATIVE_INTEGER_VALUE
,
779 IMAGE_FUNCTION_VALUE
,
784 /* Structure used when parsing image specifications. */
788 /* Name of keyword. */
791 /* The type of value allowed. */
792 enum image_value_type type
;
794 /* Non-zero means key must be present. */
797 /* Used to recognize duplicate keywords in a property list. */
800 /* The value that was found. */
805 static int parse_image_spec
P_ ((Lisp_Object
, struct image_keyword
*,
807 static Lisp_Object image_spec_value
P_ ((Lisp_Object
, Lisp_Object
, int *));
810 /* Parse image spec SPEC according to KEYWORDS. A valid image spec
811 has the format (image KEYWORD VALUE ...). One of the keyword/
812 value pairs must be `:type TYPE'. KEYWORDS is a vector of
813 image_keywords structures of size NKEYWORDS describing other
814 allowed keyword/value pairs. Value is non-zero if SPEC is valid. */
817 parse_image_spec (spec
, keywords
, nkeywords
, type
)
819 struct image_keyword
*keywords
;
830 while (CONSP (plist
))
832 Lisp_Object key
, value
;
834 /* First element of a pair must be a symbol. */
836 plist
= XCDR (plist
);
840 /* There must follow a value. */
843 value
= XCAR (plist
);
844 plist
= XCDR (plist
);
846 /* Find key in KEYWORDS. Error if not found. */
847 for (i
= 0; i
< nkeywords
; ++i
)
848 if (strcmp (keywords
[i
].name
, SDATA (SYMBOL_NAME (key
))) == 0)
854 /* Record that we recognized the keyword. If a keywords
855 was found more than once, it's an error. */
856 keywords
[i
].value
= value
;
859 if (keywords
[i
].count
> 1)
862 /* Check type of value against allowed type. */
863 switch (keywords
[i
].type
)
865 case IMAGE_STRING_VALUE
:
866 if (!STRINGP (value
))
870 case IMAGE_STRING_OR_NIL_VALUE
:
871 if (!STRINGP (value
) && !NILP (value
))
875 case IMAGE_SYMBOL_VALUE
:
876 if (!SYMBOLP (value
))
880 case IMAGE_POSITIVE_INTEGER_VALUE
:
881 if (!INTEGERP (value
) || XINT (value
) <= 0)
885 case IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
:
886 if (INTEGERP (value
) && XINT (value
) >= 0)
889 && INTEGERP (XCAR (value
)) && INTEGERP (XCDR (value
))
890 && XINT (XCAR (value
)) >= 0 && XINT (XCDR (value
)) >= 0)
894 case IMAGE_ASCENT_VALUE
:
895 if (SYMBOLP (value
) && EQ (value
, Qcenter
))
897 else if (INTEGERP (value
)
899 && XINT (value
) <= 100)
903 case IMAGE_NON_NEGATIVE_INTEGER_VALUE
:
904 if (!INTEGERP (value
) || XINT (value
) < 0)
908 case IMAGE_DONT_CHECK_VALUE_TYPE
:
911 case IMAGE_FUNCTION_VALUE
:
912 value
= indirect_function (value
);
915 || (CONSP (value
) && EQ (XCAR (value
), Qlambda
)))
919 case IMAGE_NUMBER_VALUE
:
920 if (!INTEGERP (value
) && !FLOATP (value
))
924 case IMAGE_INTEGER_VALUE
:
925 if (!INTEGERP (value
))
929 case IMAGE_BOOL_VALUE
:
930 if (!NILP (value
) && !EQ (value
, Qt
))
939 if (EQ (key
, QCtype
) && !EQ (type
, value
))
943 /* Check that all mandatory fields are present. */
944 for (i
= 0; i
< nkeywords
; ++i
)
945 if (keywords
[i
].mandatory_p
&& keywords
[i
].count
== 0)
952 /* Return the value of KEY in image specification SPEC. Value is nil
953 if KEY is not present in SPEC. if FOUND is not null, set *FOUND
954 to 1 if KEY was found in SPEC, set it to 0 otherwise. */
957 image_spec_value (spec
, key
, found
)
958 Lisp_Object spec
, key
;
963 xassert (valid_image_p (spec
));
965 for (tail
= XCDR (spec
);
966 CONSP (tail
) && CONSP (XCDR (tail
));
967 tail
= XCDR (XCDR (tail
)))
969 if (EQ (XCAR (tail
), key
))
973 return XCAR (XCDR (tail
));
983 DEFUN ("image-size", Fimage_size
, Simage_size
, 1, 3, 0,
984 doc
: /* Return the size of image SPEC as pair (WIDTH . HEIGHT).
985 PIXELS non-nil means return the size in pixels, otherwise return the
986 size in canonical character units.
987 FRAME is the frame on which the image will be displayed. FRAME nil
988 or omitted means use the selected frame. */)
989 (spec
, pixels
, frame
)
990 Lisp_Object spec
, pixels
, frame
;
995 if (valid_image_p (spec
))
997 struct frame
*f
= check_x_frame (frame
);
998 int id
= lookup_image (f
, spec
);
999 struct image
*img
= IMAGE_FROM_ID (f
, id
);
1000 int width
= img
->width
+ 2 * img
->hmargin
;
1001 int height
= img
->height
+ 2 * img
->vmargin
;
1004 size
= Fcons (make_float ((double) width
/ FRAME_COLUMN_WIDTH (f
)),
1005 make_float ((double) height
/ FRAME_LINE_HEIGHT (f
)));
1007 size
= Fcons (make_number (width
), make_number (height
));
1010 error ("Invalid image specification");
1016 DEFUN ("image-mask-p", Fimage_mask_p
, Simage_mask_p
, 1, 2, 0,
1017 doc
: /* Return t if image SPEC has a mask bitmap.
1018 FRAME is the frame on which the image will be displayed. FRAME nil
1019 or omitted means use the selected frame. */)
1021 Lisp_Object spec
, frame
;
1026 if (valid_image_p (spec
))
1028 struct frame
*f
= check_x_frame (frame
);
1029 int id
= lookup_image (f
, spec
);
1030 struct image
*img
= IMAGE_FROM_ID (f
, id
);
1035 error ("Invalid image specification");
1041 /***********************************************************************
1042 Image type independent image structures
1043 ***********************************************************************/
1045 static struct image
*make_image
P_ ((Lisp_Object spec
, unsigned hash
));
1046 static void free_image
P_ ((struct frame
*f
, struct image
*img
));
1049 /* Allocate and return a new image structure for image specification
1050 SPEC. SPEC has a hash value of HASH. */
1052 static struct image
*
1053 make_image (spec
, hash
)
1057 struct image
*img
= (struct image
*) xmalloc (sizeof *img
);
1059 xassert (valid_image_p (spec
));
1060 bzero (img
, sizeof *img
);
1061 img
->type
= lookup_image_type (image_spec_value (spec
, QCtype
, NULL
));
1062 xassert (img
->type
!= NULL
);
1064 img
->data
.lisp_val
= Qnil
;
1065 img
->ascent
= DEFAULT_IMAGE_ASCENT
;
1071 /* Free image IMG which was used on frame F, including its resources. */
1080 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
1082 /* Remove IMG from the hash table of its cache. */
1084 img
->prev
->next
= img
->next
;
1086 c
->buckets
[img
->hash
% IMAGE_CACHE_BUCKETS_SIZE
] = img
->next
;
1089 img
->next
->prev
= img
->prev
;
1091 c
->images
[img
->id
] = NULL
;
1093 /* Free resources, then free IMG. */
1094 img
->type
->free (f
, img
);
1100 /* Prepare image IMG for display on frame F. Must be called before
1101 drawing an image. */
1104 prepare_image_for_display (f
, img
)
1110 /* We're about to display IMG, so set its timestamp to `now'. */
1112 img
->timestamp
= EMACS_SECS (t
);
1114 /* If IMG doesn't have a pixmap yet, load it now, using the image
1115 type dependent loader function. */
1116 if (img
->pixmap
== NO_PIXMAP
&& !img
->load_failed_p
)
1117 img
->load_failed_p
= img
->type
->load (f
, img
) == 0;
1121 /* Value is the number of pixels for the ascent of image IMG when
1122 drawn in face FACE. */
1125 image_ascent (img
, face
, slice
)
1128 struct glyph_slice
*slice
;
1133 if (slice
->height
== img
->height
)
1134 height
= img
->height
+ img
->vmargin
;
1135 else if (slice
->y
== 0)
1136 height
= slice
->height
+ img
->vmargin
;
1138 height
= slice
->height
;
1140 if (img
->ascent
== CENTERED_IMAGE_ASCENT
)
1145 /* W32 specific version. Why?. ++kfs */
1146 ascent
= height
/ 2 - (FONT_DESCENT(face
->font
)
1147 - FONT_BASE(face
->font
)) / 2;
1149 /* This expression is arranged so that if the image can't be
1150 exactly centered, it will be moved slightly up. This is
1151 because a typical font is `top-heavy' (due to the presence
1152 uppercase letters), so the image placement should err towards
1153 being top-heavy too. It also just generally looks better. */
1154 ascent
= (height
+ face
->font
->ascent
- face
->font
->descent
+ 1) / 2;
1155 #endif /* HAVE_NTGUI */
1158 ascent
= height
/ 2;
1161 ascent
= (int) (height
* img
->ascent
/ 100.0);
1167 /* Image background colors. */
1169 /* Find the "best" corner color of a bitmap.
1170 On W32, XIMG is assumed to a device context with the bitmap selected. */
1172 static RGB_PIXEL_COLOR
1173 four_corners_best (ximg
, width
, height
)
1174 XImagePtr_or_DC ximg
;
1175 unsigned long width
, height
;
1177 RGB_PIXEL_COLOR corners
[4], best
;
1180 /* Get the colors at the corners of ximg. */
1181 corners
[0] = GET_PIXEL (ximg
, 0, 0);
1182 corners
[1] = GET_PIXEL (ximg
, width
- 1, 0);
1183 corners
[2] = GET_PIXEL (ximg
, width
- 1, height
- 1);
1184 corners
[3] = GET_PIXEL (ximg
, 0, height
- 1);
1186 /* Choose the most frequently found color as background. */
1187 for (i
= best_count
= 0; i
< 4; ++i
)
1191 for (j
= n
= 0; j
< 4; ++j
)
1192 if (corners
[i
] == corners
[j
])
1196 best
= corners
[i
], best_count
= n
;
1202 /* Portability macros */
1206 #define Destroy_Image(img_dc, prev) \
1207 do { SelectObject (img_dc, prev); DeleteDC (img_dc); } while (0)
1209 #define Free_Pixmap(display, pixmap) \
1210 DeleteObject (pixmap)
1214 #define Destroy_Image(ximg, dummy) \
1215 XDestroyImage (ximg)
1217 #define Free_Pixmap(display, pixmap) \
1218 XFreePixmap (display, pixmap)
1220 #endif /* HAVE_NTGUI */
1223 /* Return the `background' field of IMG. If IMG doesn't have one yet,
1224 it is guessed heuristically. If non-zero, XIMG is an existing
1225 XImage object (or device context with the image selected on W32) to
1226 use for the heuristic. */
1229 image_background (img
, f
, ximg
)
1232 XImagePtr_or_DC ximg
;
1234 if (! img
->background_valid
)
1235 /* IMG doesn't have a background yet, try to guess a reasonable value. */
1237 int free_ximg
= !ximg
;
1240 #endif /* HAVE_NTGUI */
1245 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
1246 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
1248 HDC frame_dc
= get_frame_dc (f
);
1249 ximg
= CreateCompatibleDC (frame_dc
);
1250 release_frame_dc (f
, frame_dc
);
1251 prev
= SelectObject (ximg
, img
->pixmap
);
1252 #endif /* !HAVE_NTGUI */
1255 img
->background
= four_corners_best (ximg
, img
->width
, img
->height
);
1258 Destroy_Image (ximg
, prev
);
1260 img
->background_valid
= 1;
1263 return img
->background
;
1266 /* Return the `background_transparent' field of IMG. If IMG doesn't
1267 have one yet, it is guessed heuristically. If non-zero, MASK is an
1268 existing XImage object to use for the heuristic. */
1271 image_background_transparent (img
, f
, mask
)
1274 XImagePtr_or_DC mask
;
1276 if (! img
->background_transparent_valid
)
1277 /* IMG doesn't have a background yet, try to guess a reasonable value. */
1281 int free_mask
= !mask
;
1284 #endif /* HAVE_NTGUI */
1289 mask
= XGetImage (FRAME_X_DISPLAY (f
), img
->mask
,
1290 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
1292 HDC frame_dc
= get_frame_dc (f
);
1293 mask
= CreateCompatibleDC (frame_dc
);
1294 release_frame_dc (f
, frame_dc
);
1295 prev
= SelectObject (mask
, img
->mask
);
1296 #endif /* HAVE_NTGUI */
1299 img
->background_transparent
1300 = (four_corners_best (mask
, img
->width
, img
->height
) == PIX_MASK_RETAIN (f
));
1303 Destroy_Image (mask
, prev
);
1306 img
->background_transparent
= 0;
1308 img
->background_transparent_valid
= 1;
1311 return img
->background_transparent
;
1315 /***********************************************************************
1316 Helper functions for X image types
1317 ***********************************************************************/
1319 static void x_clear_image_1
P_ ((struct frame
*, struct image
*, int,
1321 static void x_clear_image
P_ ((struct frame
*f
, struct image
*img
));
1322 static unsigned long x_alloc_image_color
P_ ((struct frame
*f
,
1324 Lisp_Object color_name
,
1325 unsigned long dflt
));
1328 /* Clear X resources of image IMG on frame F. PIXMAP_P non-zero means
1329 free the pixmap if any. MASK_P non-zero means clear the mask
1330 pixmap if any. COLORS_P non-zero means free colors allocated for
1331 the image, if any. */
1334 x_clear_image_1 (f
, img
, pixmap_p
, mask_p
, colors_p
)
1337 int pixmap_p
, mask_p
, colors_p
;
1339 if (pixmap_p
&& img
->pixmap
)
1341 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->pixmap
);
1342 img
->pixmap
= NO_PIXMAP
;
1343 img
->background_valid
= 0;
1346 if (mask_p
&& img
->mask
)
1348 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
1349 img
->mask
= NO_PIXMAP
;
1350 img
->background_transparent_valid
= 0;
1353 if (colors_p
&& img
->ncolors
)
1355 /* MAC_TODO: color table support. */
1356 /* W32_TODO: color table support. */
1357 #ifdef HAVE_X_WINDOWS
1358 x_free_colors (f
, img
->colors
, img
->ncolors
);
1359 #endif /* HAVE_X_WINDOWS */
1360 xfree (img
->colors
);
1366 /* Free X resources of image IMG which is used on frame F. */
1369 x_clear_image (f
, img
)
1374 x_clear_image_1 (f
, img
, 1, 1, 1);
1379 /* Allocate color COLOR_NAME for image IMG on frame F. If color
1380 cannot be allocated, use DFLT. Add a newly allocated color to
1381 IMG->colors, so that it can be freed again. Value is the pixel
1384 static unsigned long
1385 x_alloc_image_color (f
, img
, color_name
, dflt
)
1388 Lisp_Object color_name
;
1392 unsigned long result
;
1394 xassert (STRINGP (color_name
));
1396 if (x_defined_color (f
, SDATA (color_name
), &color
, 1))
1398 /* This isn't called frequently so we get away with simply
1399 reallocating the color vector to the needed size, here. */
1402 (unsigned long *) xrealloc (img
->colors
,
1403 img
->ncolors
* sizeof *img
->colors
);
1404 img
->colors
[img
->ncolors
- 1] = color
.pixel
;
1405 result
= color
.pixel
;
1415 /***********************************************************************
1417 ***********************************************************************/
1419 static void cache_image
P_ ((struct frame
*f
, struct image
*img
));
1420 static void postprocess_image
P_ ((struct frame
*, struct image
*));
1422 /* Return a new, initialized image cache that is allocated from the
1423 heap. Call free_image_cache to free an image cache. */
1425 struct image_cache
*
1428 struct image_cache
*c
= (struct image_cache
*) xmalloc (sizeof *c
);
1431 bzero (c
, sizeof *c
);
1433 c
->images
= (struct image
**) xmalloc (c
->size
* sizeof *c
->images
);
1434 size
= IMAGE_CACHE_BUCKETS_SIZE
* sizeof *c
->buckets
;
1435 c
->buckets
= (struct image
**) xmalloc (size
);
1436 bzero (c
->buckets
, size
);
1441 /* Free image cache of frame F. Be aware that X frames share images
1445 free_image_cache (f
)
1448 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
1453 /* Cache should not be referenced by any frame when freed. */
1454 xassert (c
->refcount
== 0);
1456 for (i
= 0; i
< c
->used
; ++i
)
1457 free_image (f
, c
->images
[i
]);
1461 FRAME_X_IMAGE_CACHE (f
) = NULL
;
1466 /* Clear image cache of frame F. FORCE_P non-zero means free all
1467 images. FORCE_P zero means clear only images that haven't been
1468 displayed for some time. Should be called from time to time to
1469 reduce the number of loaded images. If image-eviction-seconds is
1470 non-nil, this frees images in the cache which weren't displayed for
1471 at least that many seconds. */
1474 clear_image_cache (f
, force_p
)
1478 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
1480 if (c
&& INTEGERP (Vimage_cache_eviction_delay
))
1487 old
= EMACS_SECS (t
) - XFASTINT (Vimage_cache_eviction_delay
);
1489 /* Block input so that we won't be interrupted by a SIGIO
1490 while being in an inconsistent state. */
1493 for (i
= nfreed
= 0; i
< c
->used
; ++i
)
1495 struct image
*img
= c
->images
[i
];
1497 && (force_p
|| img
->timestamp
< old
))
1499 free_image (f
, img
);
1504 /* We may be clearing the image cache because, for example,
1505 Emacs was iconified for a longer period of time. In that
1506 case, current matrices may still contain references to
1507 images freed above. So, clear these matrices. */
1510 Lisp_Object tail
, frame
;
1512 FOR_EACH_FRAME (tail
, frame
)
1514 struct frame
*f
= XFRAME (frame
);
1515 if (FRAME_WINDOW_P (f
)
1516 && FRAME_X_IMAGE_CACHE (f
) == c
)
1517 clear_current_matrices (f
);
1520 ++windows_or_buffers_changed
;
1528 DEFUN ("clear-image-cache", Fclear_image_cache
, Sclear_image_cache
,
1530 doc
: /* Clear the image cache of FRAME.
1531 FRAME nil or omitted means use the selected frame.
1532 FRAME t means clear the image caches of all frames. */)
1540 FOR_EACH_FRAME (tail
, frame
)
1541 if (FRAME_WINDOW_P (XFRAME (frame
)))
1542 clear_image_cache (XFRAME (frame
), 1);
1545 clear_image_cache (check_x_frame (frame
), 1);
1551 /* Compute masks and transform image IMG on frame F, as specified
1552 by the image's specification, */
1555 postprocess_image (f
, img
)
1559 /* Manipulation of the image's mask. */
1562 Lisp_Object conversion
, spec
;
1567 /* `:heuristic-mask t'
1569 means build a mask heuristically.
1570 `:heuristic-mask (R G B)'
1571 `:mask (heuristic (R G B))'
1572 means build a mask from color (R G B) in the
1575 means remove a mask, if any. */
1577 mask
= image_spec_value (spec
, QCheuristic_mask
, NULL
);
1579 x_build_heuristic_mask (f
, img
, mask
);
1584 mask
= image_spec_value (spec
, QCmask
, &found_p
);
1586 if (EQ (mask
, Qheuristic
))
1587 x_build_heuristic_mask (f
, img
, Qt
);
1588 else if (CONSP (mask
)
1589 && EQ (XCAR (mask
), Qheuristic
))
1591 if (CONSP (XCDR (mask
)))
1592 x_build_heuristic_mask (f
, img
, XCAR (XCDR (mask
)));
1594 x_build_heuristic_mask (f
, img
, XCDR (mask
));
1596 else if (NILP (mask
) && found_p
&& img
->mask
)
1598 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
1599 img
->mask
= NO_PIXMAP
;
1604 /* Should we apply an image transformation algorithm? */
1605 conversion
= image_spec_value (spec
, QCconversion
, NULL
);
1606 if (EQ (conversion
, Qdisabled
))
1607 x_disable_image (f
, img
);
1608 else if (EQ (conversion
, Qlaplace
))
1610 else if (EQ (conversion
, Qemboss
))
1612 else if (CONSP (conversion
)
1613 && EQ (XCAR (conversion
), Qedge_detection
))
1616 tem
= XCDR (conversion
);
1618 x_edge_detection (f
, img
,
1619 Fplist_get (tem
, QCmatrix
),
1620 Fplist_get (tem
, QCcolor_adjustment
));
1626 /* Return the id of image with Lisp specification SPEC on frame F.
1627 SPEC must be a valid Lisp image specification (see valid_image_p). */
1630 lookup_image (f
, spec
)
1634 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
1636 /* Work around a problem with MinGW builds of graphics libraries
1637 not honoring calling conventions. */
1643 struct gcpro gcpro1
;
1646 /* F must be a window-system frame, and SPEC must be a valid image
1648 xassert (FRAME_WINDOW_P (f
));
1649 xassert (valid_image_p (spec
));
1653 /* Look up SPEC in the hash table of the image cache. */
1654 hash
= sxhash (spec
, 0);
1655 i
= hash
% IMAGE_CACHE_BUCKETS_SIZE
;
1657 for (img
= c
->buckets
[i
]; img
; img
= img
->next
)
1658 if (img
->hash
== hash
&& !NILP (Fequal (img
->spec
, spec
)))
1661 /* If not found, create a new image and cache it. */
1664 extern Lisp_Object Qpostscript
;
1667 img
= make_image (spec
, hash
);
1668 cache_image (f
, img
);
1669 img
->load_failed_p
= img
->type
->load (f
, img
) == 0;
1671 /* If we can't load the image, and we don't have a width and
1672 height, use some arbitrary width and height so that we can
1673 draw a rectangle for it. */
1674 if (img
->load_failed_p
)
1678 value
= image_spec_value (spec
, QCwidth
, NULL
);
1679 img
->width
= (INTEGERP (value
)
1680 ? XFASTINT (value
) : DEFAULT_IMAGE_WIDTH
);
1681 value
= image_spec_value (spec
, QCheight
, NULL
);
1682 img
->height
= (INTEGERP (value
)
1683 ? XFASTINT (value
) : DEFAULT_IMAGE_HEIGHT
);
1687 /* Handle image type independent image attributes
1688 `:ascent ASCENT', `:margin MARGIN', `:relief RELIEF',
1689 `:background COLOR'. */
1690 Lisp_Object ascent
, margin
, relief
, bg
;
1692 ascent
= image_spec_value (spec
, QCascent
, NULL
);
1693 if (INTEGERP (ascent
))
1694 img
->ascent
= XFASTINT (ascent
);
1695 else if (EQ (ascent
, Qcenter
))
1696 img
->ascent
= CENTERED_IMAGE_ASCENT
;
1698 margin
= image_spec_value (spec
, QCmargin
, NULL
);
1699 if (INTEGERP (margin
) && XINT (margin
) >= 0)
1700 img
->vmargin
= img
->hmargin
= XFASTINT (margin
);
1701 else if (CONSP (margin
) && INTEGERP (XCAR (margin
))
1702 && INTEGERP (XCDR (margin
)))
1704 if (XINT (XCAR (margin
)) > 0)
1705 img
->hmargin
= XFASTINT (XCAR (margin
));
1706 if (XINT (XCDR (margin
)) > 0)
1707 img
->vmargin
= XFASTINT (XCDR (margin
));
1710 relief
= image_spec_value (spec
, QCrelief
, NULL
);
1711 if (INTEGERP (relief
))
1713 img
->relief
= XINT (relief
);
1714 img
->hmargin
+= abs (img
->relief
);
1715 img
->vmargin
+= abs (img
->relief
);
1718 if (! img
->background_valid
)
1720 bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
1724 = x_alloc_image_color (f
, img
, bg
,
1725 FRAME_BACKGROUND_PIXEL (f
));
1726 img
->background_valid
= 1;
1730 /* Do image transformations and compute masks, unless we
1731 don't have the image yet. */
1732 if (!EQ (*img
->type
->type
, Qpostscript
))
1733 postprocess_image (f
, img
);
1739 /* We're using IMG, so set its timestamp to `now'. */
1740 EMACS_GET_TIME (now
);
1741 img
->timestamp
= EMACS_SECS (now
);
1745 /* Value is the image id. */
1750 /* Cache image IMG in the image cache of frame F. */
1753 cache_image (f
, img
)
1757 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
1760 /* Find a free slot in c->images. */
1761 for (i
= 0; i
< c
->used
; ++i
)
1762 if (c
->images
[i
] == NULL
)
1765 /* If no free slot found, maybe enlarge c->images. */
1766 if (i
== c
->used
&& c
->used
== c
->size
)
1769 c
->images
= (struct image
**) xrealloc (c
->images
,
1770 c
->size
* sizeof *c
->images
);
1773 /* Add IMG to c->images, and assign IMG an id. */
1779 /* Add IMG to the cache's hash table. */
1780 i
= img
->hash
% IMAGE_CACHE_BUCKETS_SIZE
;
1781 img
->next
= c
->buckets
[i
];
1783 img
->next
->prev
= img
;
1785 c
->buckets
[i
] = img
;
1789 /* Call FN on every image in the image cache of frame F. Used to mark
1790 Lisp Objects in the image cache. */
1793 forall_images_in_image_cache (f
, fn
)
1795 void (*fn
) P_ ((struct image
*img
));
1797 if (FRAME_LIVE_P (f
) && FRAME_WINDOW_P (f
))
1799 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
1803 for (i
= 0; i
< c
->used
; ++i
)
1812 /***********************************************************************
1813 X / MAC / W32 support code
1814 ***********************************************************************/
1818 /* Macro for defining functions that will be loaded from image DLLs. */
1819 #define DEF_IMGLIB_FN(func) FARPROC fn_##func
1821 /* Macro for loading those image functions from the library. */
1822 #define LOAD_IMGLIB_FN(lib,func) { \
1823 fn_##func = (void *) GetProcAddress (lib, #func); \
1824 if (!fn_##func) return 0; \
1827 /* Load a DLL implementing an image type.
1828 The `image-library-alist' variable associates a symbol,
1829 identifying an image type, to a list of possible filenames.
1830 The function returns NULL if no library could be loaded for
1831 the given image type, or if the library was previously loaded;
1832 else the handle of the DLL. */
1834 w32_delayed_load (Lisp_Object libraries
, Lisp_Object type
)
1836 HMODULE library
= NULL
;
1838 if (CONSP (libraries
) && NILP (Fassq (type
, Vimage_type_cache
)))
1840 Lisp_Object dlls
= Fassq (type
, libraries
);
1843 for (dlls
= XCDR (dlls
); CONSP (dlls
); dlls
= XCDR (dlls
))
1845 CHECK_STRING_CAR (dlls
);
1846 if (library
= LoadLibrary (SDATA (XCAR (dlls
))))
1854 #endif /* HAVE_NTGUI */
1856 static int x_create_x_image_and_pixmap
P_ ((struct frame
*, int, int, int,
1857 XImagePtr
*, Pixmap
*));
1858 static void x_destroy_x_image
P_ ((XImagePtr
));
1859 static void x_put_x_image
P_ ((struct frame
*, XImagePtr
, Pixmap
, int, int));
1862 /* Create an XImage and a pixmap of size WIDTH x HEIGHT for use on
1863 frame F. Set *XIMG and *PIXMAP to the XImage and Pixmap created.
1864 Set (*XIMG)->data to a raster of WIDTH x HEIGHT pixels allocated
1865 via xmalloc. Print error messages via image_error if an error
1866 occurs. Value is non-zero if successful.
1868 On W32, a DEPTH of zero signifies a 24 bit image, otherwise DEPTH
1869 should indicate the bit depth of the image. */
1872 x_create_x_image_and_pixmap (f
, width
, height
, depth
, ximg
, pixmap
)
1874 int width
, height
, depth
;
1878 #ifdef HAVE_X_WINDOWS
1879 Display
*display
= FRAME_X_DISPLAY (f
);
1880 Window window
= FRAME_X_WINDOW (f
);
1881 Screen
*screen
= FRAME_X_SCREEN (f
);
1883 xassert (interrupt_input_blocked
);
1886 depth
= DefaultDepthOfScreen (screen
);
1887 *ximg
= XCreateImage (display
, DefaultVisualOfScreen (screen
),
1888 depth
, ZPixmap
, 0, NULL
, width
, height
,
1889 depth
> 16 ? 32 : depth
> 8 ? 16 : 8, 0);
1892 image_error ("Unable to allocate X image", Qnil
, Qnil
);
1896 /* Allocate image raster. */
1897 (*ximg
)->data
= (char *) xmalloc ((*ximg
)->bytes_per_line
* height
);
1899 /* Allocate a pixmap of the same size. */
1900 *pixmap
= XCreatePixmap (display
, window
, width
, height
, depth
);
1901 if (*pixmap
== NO_PIXMAP
)
1903 x_destroy_x_image (*ximg
);
1905 image_error ("Unable to create X pixmap", Qnil
, Qnil
);
1910 #endif /* HAVE_X_WINDOWS */
1914 BITMAPINFOHEADER
*header
;
1916 int scanline_width_bits
;
1918 int palette_colors
= 0;
1923 if (depth
!= 1 && depth
!= 4 && depth
!= 8
1924 && depth
!= 16 && depth
!= 24 && depth
!= 32)
1926 image_error ("Invalid image bit depth specified", Qnil
, Qnil
);
1930 scanline_width_bits
= width
* depth
;
1931 remainder
= scanline_width_bits
% 32;
1934 scanline_width_bits
+= 32 - remainder
;
1936 /* Bitmaps with a depth less than 16 need a palette. */
1937 /* BITMAPINFO structure already contains the first RGBQUAD. */
1939 palette_colors
= 1 << depth
- 1;
1941 *ximg
= xmalloc (sizeof (XImage
) + palette_colors
* sizeof (RGBQUAD
));
1944 image_error ("Unable to allocate memory for XImage", Qnil
, Qnil
);
1948 header
= &((*ximg
)->info
.bmiHeader
);
1949 bzero (&((*ximg
)->info
), sizeof (BITMAPINFO
));
1950 header
->biSize
= sizeof (*header
);
1951 header
->biWidth
= width
;
1952 header
->biHeight
= -height
; /* negative indicates a top-down bitmap. */
1953 header
->biPlanes
= 1;
1954 header
->biBitCount
= depth
;
1955 header
->biCompression
= BI_RGB
;
1956 header
->biClrUsed
= palette_colors
;
1958 /* TODO: fill in palette. */
1961 (*ximg
)->info
.bmiColors
[0].rgbBlue
= 0;
1962 (*ximg
)->info
.bmiColors
[0].rgbGreen
= 0;
1963 (*ximg
)->info
.bmiColors
[0].rgbRed
= 0;
1964 (*ximg
)->info
.bmiColors
[0].rgbReserved
= 0;
1965 (*ximg
)->info
.bmiColors
[1].rgbBlue
= 255;
1966 (*ximg
)->info
.bmiColors
[1].rgbGreen
= 255;
1967 (*ximg
)->info
.bmiColors
[1].rgbRed
= 255;
1968 (*ximg
)->info
.bmiColors
[1].rgbReserved
= 0;
1971 hdc
= get_frame_dc (f
);
1973 /* Create a DIBSection and raster array for the bitmap,
1974 and store its handle in *pixmap. */
1975 *pixmap
= CreateDIBSection (hdc
, &((*ximg
)->info
),
1976 (depth
< 16) ? DIB_PAL_COLORS
: DIB_RGB_COLORS
,
1977 &((*ximg
)->data
), NULL
, 0);
1979 /* Realize display palette and garbage all frames. */
1980 release_frame_dc (f
, hdc
);
1982 if (*pixmap
== NULL
)
1984 DWORD err
= GetLastError();
1985 Lisp_Object errcode
;
1986 /* All system errors are < 10000, so the following is safe. */
1987 XSETINT (errcode
, (int) err
);
1988 image_error ("Unable to create bitmap, error code %d", errcode
, Qnil
);
1989 x_destroy_x_image (*ximg
);
1995 #endif /* HAVE_NTGUI */
1998 Display
*display
= FRAME_X_DISPLAY (f
);
1999 Window window
= FRAME_X_WINDOW (f
);
2001 xassert (interrupt_input_blocked
);
2003 /* Allocate a pixmap of the same size. */
2004 *pixmap
= XCreatePixmap (display
, window
, width
, height
, depth
);
2005 if (*pixmap
== NO_PIXMAP
)
2007 x_destroy_x_image (*ximg
);
2009 image_error ("Unable to create X pixmap", Qnil
, Qnil
);
2013 LockPixels (GetGWorldPixMap (*pixmap
));
2021 /* Destroy XImage XIMG. Free XIMG->data. */
2024 x_destroy_x_image (ximg
)
2027 xassert (interrupt_input_blocked
);
2030 #ifdef HAVE_X_WINDOWS
2033 XDestroyImage (ximg
);
2034 #endif /* HAVE_X_WINDOWS */
2036 /* Data will be freed by DestroyObject. */
2039 #endif /* HAVE_NTGUI */
2041 XDestroyImage (ximg
);
2047 /* Put XImage XIMG into pixmap PIXMAP on frame F. WIDTH and HEIGHT
2048 are width and height of both the image and pixmap. */
2051 x_put_x_image (f
, ximg
, pixmap
, width
, height
)
2057 #ifdef HAVE_X_WINDOWS
2060 xassert (interrupt_input_blocked
);
2061 gc
= XCreateGC (FRAME_X_DISPLAY (f
), pixmap
, 0, NULL
);
2062 XPutImage (FRAME_X_DISPLAY (f
), pixmap
, gc
, ximg
, 0, 0, 0, 0, width
, height
);
2063 XFreeGC (FRAME_X_DISPLAY (f
), gc
);
2064 #endif /* HAVE_X_WINDOWS */
2067 #if 0 /* I don't think this is necessary looking at where it is used. */
2068 HDC hdc
= get_frame_dc (f
);
2069 SetDIBits (hdc
, pixmap
, 0, height
, ximg
->data
, &(ximg
->info
), DIB_RGB_COLORS
);
2070 release_frame_dc (f
, hdc
);
2072 #endif /* HAVE_NTGUI */
2075 xassert (ximg
== pixmap
);
2080 /***********************************************************************
2082 ***********************************************************************/
2084 static unsigned char *slurp_file
P_ ((char *, int *));
2087 /* Find image file FILE. Look in data-directory, then
2088 x-bitmap-file-path. Value is the full name of the file found, or
2089 nil if not found. */
2092 x_find_image_file (file
)
2095 Lisp_Object file_found
, search_path
;
2096 struct gcpro gcpro1
, gcpro2
;
2100 search_path
= Fcons (Vdata_directory
, Vx_bitmap_file_path
);
2101 GCPRO2 (file_found
, search_path
);
2103 /* Try to find FILE in data-directory, then x-bitmap-file-path. */
2104 fd
= openp (search_path
, file
, Qnil
, &file_found
, Qnil
);
2116 /* Read FILE into memory. Value is a pointer to a buffer allocated
2117 with xmalloc holding FILE's contents. Value is null if an error
2118 occurred. *SIZE is set to the size of the file. */
2120 static unsigned char *
2121 slurp_file (file
, size
)
2126 unsigned char *buf
= NULL
;
2129 if (stat (file
, &st
) == 0
2130 && (fp
= fopen (file
, "rb")) != NULL
2131 && (buf
= (char *) xmalloc (st
.st_size
),
2132 fread (buf
, 1, st
.st_size
, fp
) == st
.st_size
))
2155 /***********************************************************************
2156 MAC Image Load Functions
2157 ***********************************************************************/
2159 static int image_load_quicktime
P_ ((struct frame
*, struct image
*img
,
2162 static int image_load_quartz2d
P_ ((struct frame
*, struct image
*img
, int));
2166 find_image_fsspec (specified_file
, file
, fss
)
2167 Lisp_Object specified_file
, *file
;
2170 #if TARGET_API_MAC_CARBON
2173 Str255 mac_pathname
;
2177 *file
= x_find_image_file (specified_file
);
2178 if (!STRINGP (*file
))
2179 return fnfErr
; /* file or directory not found;
2180 incomplete pathname */
2181 /* Try to open the image file. */
2182 #if TARGET_API_MAC_CARBON
2183 err
= FSPathMakeRef (SDATA (*file
), &fsr
, NULL
);
2185 err
= FSGetCatalogInfo (&fsr
, kFSCatInfoNone
, NULL
, NULL
, fss
, NULL
);
2187 if (posix_to_mac_pathname (SDATA (*file
), mac_pathname
, MAXPATHLEN
+1) == 0)
2189 c2pstr (mac_pathname
);
2190 err
= FSMakeFSSpec (0, 0, mac_pathname
, fss
);
2196 image_load_qt_1 (f
, img
, type
, fss
, dh
)
2204 GraphicsImportComponent gi
;
2207 short draw_all_pixels
;
2208 Lisp_Object specified_bg
;
2213 err
= OpenADefaultComponent (GraphicsImporterComponentType
,
2217 image_error ("Cannot get importer component for `%s'", img
->spec
, Qnil
);
2222 /* read from file system spec */
2223 err
= GraphicsImportSetDataFile (gi
, fss
);
2226 image_error ("Cannot set fsspec to graphics importer for '%s'",
2233 /* read from data handle */
2234 err
= GraphicsImportSetDataHandle (gi
, dh
);
2237 image_error ("Cannot set data handle to graphics importer for `%s'",
2242 err
= GraphicsImportGetNaturalBounds (gi
, &rect
);
2245 image_error ("Error reading `%s'", img
->spec
, Qnil
);
2248 width
= img
->width
= rect
.right
- rect
.left
;
2249 height
= img
->height
= rect
.bottom
- rect
.top
;
2250 err
= GraphicsImportDoesDrawAllPixels (gi
, &draw_all_pixels
);
2252 /* Don't check the error code here. It may have an undocumented
2256 image_error ("Error reading `%s'", img
->spec
, Qnil
);
2260 if (draw_all_pixels
!= graphicsImporterDrawsAllPixels
)
2262 specified_bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
2263 if (!STRINGP (specified_bg
) ||
2264 !mac_defined_color (f
, SDATA (specified_bg
), &color
, 0))
2266 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
2267 color
.red
= RED16_FROM_ULONG (color
.pixel
);
2268 color
.green
= GREEN16_FROM_ULONG (color
.pixel
);
2269 color
.blue
= BLUE16_FROM_ULONG (color
.pixel
);
2273 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
2275 if (draw_all_pixels
!= graphicsImporterDrawsAllPixels
)
2280 GetGWorld (&old_port
, &old_gdh
);
2281 SetGWorld (ximg
, NULL
);
2282 bg_color
.red
= color
.red
;
2283 bg_color
.green
= color
.green
;
2284 bg_color
.blue
= color
.blue
;
2285 RGBBackColor (&bg_color
);
2286 #if TARGET_API_MAC_CARBON
2287 GetPortBounds (ximg
, &rect
);
2290 EraseRect (&(ximg
->portRect
));
2292 SetGWorld (old_port
, old_gdh
);
2294 GraphicsImportSetGWorld (gi
, ximg
, NULL
);
2295 GraphicsImportDraw (gi
);
2296 CloseComponent (gi
);
2298 /* Maybe fill in the background field while we have ximg handy. */
2299 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
2300 IMAGE_BACKGROUND (img
, f
, ximg
);
2302 /* Put the image into the pixmap. */
2303 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
2304 x_destroy_x_image (ximg
);
2308 CloseComponent (gi
);
2313 /* Load an image using the QuickTime Graphics Importer.
2314 Note: The alpha channel does not work for PNG images. */
2316 image_load_quicktime (f
, img
, type
)
2321 Lisp_Object specified_file
;
2322 Lisp_Object specified_data
;
2325 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
2326 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
2328 if (NILP (specified_data
))
2330 /* Read from a file */
2334 err
= find_image_fsspec (specified_file
, &file
, &fss
);
2338 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
2340 image_error ("Cannot open `%s'", file
, Qnil
);
2343 return image_load_qt_1 (f
, img
, type
, &fss
, NULL
);
2347 /* Memory source! */
2351 err
= PtrToHand (SDATA (specified_data
), &dh
, SBYTES (specified_data
));
2354 image_error ("Cannot allocate data handle for `%s'",
2358 success_p
= image_load_qt_1 (f
, img
, type
, NULL
, dh
);
2366 /* Load a PNG/JPEG image using Quartz 2D decoding routines.
2367 CGImageCreateWithPNGDataProvider is provided after Mac OS X 10.2.
2368 So don't use this function directly but determine at runtime
2369 whether it exists. */
2370 typedef CGImageRef (*CGImageCreateWithPNGDataProviderProcType
)
2371 (CGDataProviderRef
, const float [], bool, CGColorRenderingIntent
);
2372 static CGImageCreateWithPNGDataProviderProcType MyCGImageCreateWithPNGDataProvider
;
2376 init_image_func_pointer ()
2378 if (NSIsSymbolNameDefined ("_CGImageCreateWithPNGDataProvider"))
2380 MyCGImageCreateWithPNGDataProvider
2381 = (CGImageCreateWithPNGDataProviderProcType
)
2382 NSAddressOfSymbol (NSLookupAndBindSymbol
2383 ("_CGImageCreateWithPNGDataProvider"));
2386 MyCGImageCreateWithPNGDataProvider
= NULL
;
2391 image_load_quartz2d (f
, img
, png_p
)
2396 Lisp_Object file
, specified_file
;
2397 Lisp_Object specified_data
, specified_bg
;
2398 struct gcpro gcpro1
;
2399 CGDataProviderRef source
;
2403 XImagePtr ximg
= NULL
;
2404 CGContextRef context
;
2407 /* Open the file. */
2408 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
2409 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
2414 if (NILP (specified_data
))
2419 file
= x_find_image_file (specified_file
);
2420 if (!STRINGP (file
))
2422 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
2426 path
= cfstring_create_with_string (file
);
2427 url
= CFURLCreateWithFileSystemPath (NULL
, path
,
2428 kCFURLPOSIXPathStyle
, 0);
2430 source
= CGDataProviderCreateWithURL (url
);
2434 source
= CGDataProviderCreateWithData (NULL
, SDATA (specified_data
),
2435 SBYTES (specified_data
), NULL
);
2438 image
= (*MyCGImageCreateWithPNGDataProvider
) (source
, NULL
, FALSE
,
2439 kCGRenderingIntentDefault
);
2441 image
= CGImageCreateWithJPEGDataProvider (source
, NULL
, FALSE
,
2442 kCGRenderingIntentDefault
);
2444 CGDataProviderRelease (source
);
2448 image_error ("Error reading image `%s'", img
->spec
, Qnil
);
2454 specified_bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
2455 if (!STRINGP (specified_bg
) ||
2456 !mac_defined_color (f
, SDATA (specified_bg
), &color
, 0))
2458 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
2459 color
.red
= RED16_FROM_ULONG (color
.pixel
);
2460 color
.green
= GREEN16_FROM_ULONG (color
.pixel
);
2461 color
.blue
= BLUE16_FROM_ULONG (color
.pixel
);
2464 width
= img
->width
= CGImageGetWidth (image
);
2465 height
= img
->height
= CGImageGetHeight (image
);
2466 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
2468 CGImageRelease (image
);
2472 rectangle
= CGRectMake (0, 0, width
, height
);
2473 QDBeginCGContext (ximg
, &context
);
2476 CGContextSetRGBFillColor (context
, color
.red
/ 65535.0,
2477 color
.green
/ 65535.0,
2478 color
.blue
/ 65535.0, 1.0);
2479 CGContextFillRect (context
, rectangle
);
2481 CGContextDrawImage (context
, rectangle
, image
);
2482 QDEndCGContext (ximg
, &context
);
2483 CGImageRelease (image
);
2485 /* Maybe fill in the background field while we have ximg handy. */
2486 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
2487 IMAGE_BACKGROUND (img
, f
, ximg
);
2489 /* Put the image into the pixmap. */
2490 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
2491 x_destroy_x_image (ximg
);
2500 /***********************************************************************
2502 ***********************************************************************/
2504 static int xbm_scan
P_ ((unsigned char **, unsigned char *, char *, int *));
2505 static int xbm_load
P_ ((struct frame
*f
, struct image
*img
));
2506 static int xbm_load_image
P_ ((struct frame
*f
, struct image
*img
,
2507 unsigned char *, unsigned char *));
2508 static int xbm_image_p
P_ ((Lisp_Object object
));
2509 static int xbm_read_bitmap_data
P_ ((unsigned char *, unsigned char *,
2510 int *, int *, unsigned char **));
2511 static int xbm_file_p
P_ ((Lisp_Object
));
2514 /* Indices of image specification fields in xbm_format, below. */
2516 enum xbm_keyword_index
2534 /* Vector of image_keyword structures describing the format
2535 of valid XBM image specifications. */
2537 static struct image_keyword xbm_format
[XBM_LAST
] =
2539 {":type", IMAGE_SYMBOL_VALUE
, 1},
2540 {":file", IMAGE_STRING_VALUE
, 0},
2541 {":width", IMAGE_POSITIVE_INTEGER_VALUE
, 0},
2542 {":height", IMAGE_POSITIVE_INTEGER_VALUE
, 0},
2543 {":data", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
2544 {":foreground", IMAGE_STRING_OR_NIL_VALUE
, 0},
2545 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0},
2546 {":ascent", IMAGE_ASCENT_VALUE
, 0},
2547 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
2548 {":relief", IMAGE_INTEGER_VALUE
, 0},
2549 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
2550 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
2551 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0}
2554 /* Structure describing the image type XBM. */
2556 static struct image_type xbm_type
=
2565 /* Tokens returned from xbm_scan. */
2574 /* Return non-zero if OBJECT is a valid XBM-type image specification.
2575 A valid specification is a list starting with the symbol `image'
2576 The rest of the list is a property list which must contain an
2579 If the specification specifies a file to load, it must contain
2580 an entry `:file FILENAME' where FILENAME is a string.
2582 If the specification is for a bitmap loaded from memory it must
2583 contain `:width WIDTH', `:height HEIGHT', and `:data DATA', where
2584 WIDTH and HEIGHT are integers > 0. DATA may be:
2586 1. a string large enough to hold the bitmap data, i.e. it must
2587 have a size >= (WIDTH + 7) / 8 * HEIGHT
2589 2. a bool-vector of size >= WIDTH * HEIGHT
2591 3. a vector of strings or bool-vectors, one for each line of the
2594 4. A string containing an in-memory XBM file. WIDTH and HEIGHT
2595 may not be specified in this case because they are defined in the
2598 Both the file and data forms may contain the additional entries
2599 `:background COLOR' and `:foreground COLOR'. If not present,
2600 foreground and background of the frame on which the image is
2601 displayed is used. */
2604 xbm_image_p (object
)
2607 struct image_keyword kw
[XBM_LAST
];
2609 bcopy (xbm_format
, kw
, sizeof kw
);
2610 if (!parse_image_spec (object
, kw
, XBM_LAST
, Qxbm
))
2613 xassert (EQ (kw
[XBM_TYPE
].value
, Qxbm
));
2615 if (kw
[XBM_FILE
].count
)
2617 if (kw
[XBM_WIDTH
].count
|| kw
[XBM_HEIGHT
].count
|| kw
[XBM_DATA
].count
)
2620 else if (kw
[XBM_DATA
].count
&& xbm_file_p (kw
[XBM_DATA
].value
))
2622 /* In-memory XBM file. */
2623 if (kw
[XBM_WIDTH
].count
|| kw
[XBM_HEIGHT
].count
|| kw
[XBM_FILE
].count
)
2631 /* Entries for `:width', `:height' and `:data' must be present. */
2632 if (!kw
[XBM_WIDTH
].count
2633 || !kw
[XBM_HEIGHT
].count
2634 || !kw
[XBM_DATA
].count
)
2637 data
= kw
[XBM_DATA
].value
;
2638 width
= XFASTINT (kw
[XBM_WIDTH
].value
);
2639 height
= XFASTINT (kw
[XBM_HEIGHT
].value
);
2641 /* Check type of data, and width and height against contents of
2647 /* Number of elements of the vector must be >= height. */
2648 if (XVECTOR (data
)->size
< height
)
2651 /* Each string or bool-vector in data must be large enough
2652 for one line of the image. */
2653 for (i
= 0; i
< height
; ++i
)
2655 Lisp_Object elt
= XVECTOR (data
)->contents
[i
];
2660 < (width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
)
2663 else if (BOOL_VECTOR_P (elt
))
2665 if (XBOOL_VECTOR (elt
)->size
< width
)
2672 else if (STRINGP (data
))
2675 < (width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
* height
)
2678 else if (BOOL_VECTOR_P (data
))
2680 if (XBOOL_VECTOR (data
)->size
< width
* height
)
2691 /* Scan a bitmap file. FP is the stream to read from. Value is
2692 either an enumerator from enum xbm_token, or a character for a
2693 single-character token, or 0 at end of file. If scanning an
2694 identifier, store the lexeme of the identifier in SVAL. If
2695 scanning a number, store its value in *IVAL. */
2698 xbm_scan (s
, end
, sval
, ival
)
2699 unsigned char **s
, *end
;
2707 /* Skip white space. */
2708 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
2713 else if (isdigit (c
))
2715 int value
= 0, digit
;
2717 if (c
== '0' && *s
< end
)
2720 if (c
== 'x' || c
== 'X')
2727 else if (c
>= 'a' && c
<= 'f')
2728 digit
= c
- 'a' + 10;
2729 else if (c
>= 'A' && c
<= 'F')
2730 digit
= c
- 'A' + 10;
2733 value
= 16 * value
+ digit
;
2736 else if (isdigit (c
))
2740 && (c
= *(*s
)++, isdigit (c
)))
2741 value
= 8 * value
+ c
- '0';
2748 && (c
= *(*s
)++, isdigit (c
)))
2749 value
= 10 * value
+ c
- '0';
2757 else if (isalpha (c
) || c
== '_')
2761 && (c
= *(*s
)++, (isalnum (c
) || c
== '_')))
2768 else if (c
== '/' && **s
== '*')
2770 /* C-style comment. */
2772 while (**s
&& (**s
!= '*' || *(*s
+ 1) != '/'))
2786 /* Create a Windows bitmap from X bitmap data. */
2788 w32_create_pixmap_from_bitmap_data (int width
, int height
, char *data
)
2790 static unsigned char swap_nibble
[16]
2791 = { 0x0, 0x8, 0x4, 0xc, /* 0000 1000 0100 1100 */
2792 0x2, 0xa, 0x6, 0xe, /* 0010 1010 0110 1110 */
2793 0x1, 0x9, 0x5, 0xd, /* 0001 1001 0101 1101 */
2794 0x3, 0xb, 0x7, 0xf }; /* 0011 1011 0111 1111 */
2796 unsigned char *bits
, *p
;
2799 w1
= (width
+ 7) / 8; /* nb of 8bits elt in X bitmap */
2800 w2
= ((width
+ 15) / 16) * 2; /* nb of 16bits elt in W32 bitmap */
2801 bits
= (unsigned char *) alloca (height
* w2
);
2802 bzero (bits
, height
* w2
);
2803 for (i
= 0; i
< height
; i
++)
2806 for (j
= 0; j
< w1
; j
++)
2808 /* Bitswap XBM bytes to match how Windows does things. */
2809 unsigned char c
= *data
++;
2810 *p
++ = (unsigned char)((swap_nibble
[c
& 0xf] << 4)
2811 | (swap_nibble
[(c
>>4) & 0xf]));
2814 bmp
= CreateBitmap (width
, height
, 1, 1, (char *) bits
);
2819 static void convert_mono_to_color_image (f
, img
, foreground
, background
)
2822 COLORREF foreground
, background
;
2824 HDC hdc
, old_img_dc
, new_img_dc
;
2825 HGDIOBJ old_prev
, new_prev
;
2828 hdc
= get_frame_dc (f
);
2829 old_img_dc
= CreateCompatibleDC (hdc
);
2830 new_img_dc
= CreateCompatibleDC (hdc
);
2831 new_pixmap
= CreateCompatibleBitmap (hdc
, img
->width
, img
->height
);
2832 release_frame_dc (f
, hdc
);
2833 old_prev
= SelectObject (old_img_dc
, img
->pixmap
);
2834 new_prev
= SelectObject (new_img_dc
, new_pixmap
);
2835 SetTextColor (new_img_dc
, foreground
);
2836 SetBkColor (new_img_dc
, background
);
2838 BitBlt (new_img_dc
, 0, 0, img
->width
, img
->height
, old_img_dc
,
2841 SelectObject (old_img_dc
, old_prev
);
2842 SelectObject (new_img_dc
, new_prev
);
2843 DeleteDC (old_img_dc
);
2844 DeleteDC (new_img_dc
);
2845 DeleteObject (img
->pixmap
);
2846 if (new_pixmap
== 0)
2847 fprintf (stderr
, "Failed to convert image to color.\n");
2849 img
->pixmap
= new_pixmap
;
2852 #define XBM_BIT_SHUFFLE(b) (~(b))
2856 #define XBM_BIT_SHUFFLE(b) (b)
2858 #endif /* HAVE_NTGUI */
2862 Create_Pixmap_From_Bitmap_Data(f
, img
, data
, fg
, bg
, non_default_colors
)
2866 RGB_PIXEL_COLOR fg
, bg
;
2867 int non_default_colors
;
2871 = w32_create_pixmap_from_bitmap_data (img
->width
, img
->height
, data
);
2873 /* If colors were specified, transfer the bitmap to a color one. */
2874 if (non_default_colors
)
2875 convert_mono_to_color_image (f
, img
, fg
, bg
);
2878 = XCreatePixmapFromBitmapData (FRAME_X_DISPLAY (f
),
2881 img
->width
, img
->height
,
2883 DefaultDepthOfScreen (FRAME_X_SCREEN (f
)));
2884 #endif /* HAVE_NTGUI */
2889 /* Replacement for XReadBitmapFileData which isn't available under old
2890 X versions. CONTENTS is a pointer to a buffer to parse; END is the
2891 buffer's end. Set *WIDTH and *HEIGHT to the width and height of
2892 the image. Return in *DATA the bitmap data allocated with xmalloc.
2893 Value is non-zero if successful. DATA null means just test if
2894 CONTENTS looks like an in-memory XBM file. */
2897 xbm_read_bitmap_data (contents
, end
, width
, height
, data
)
2898 unsigned char *contents
, *end
;
2899 int *width
, *height
;
2900 unsigned char **data
;
2902 unsigned char *s
= contents
;
2903 char buffer
[BUFSIZ
];
2906 int bytes_per_line
, i
, nbytes
;
2912 LA1 = xbm_scan (&s, end, buffer, &value)
2914 #define expect(TOKEN) \
2915 if (LA1 != (TOKEN)) \
2920 #define expect_ident(IDENT) \
2921 if (LA1 == XBM_TK_IDENT && strcmp (buffer, (IDENT)) == 0) \
2926 *width
= *height
= -1;
2929 LA1
= xbm_scan (&s
, end
, buffer
, &value
);
2931 /* Parse defines for width, height and hot-spots. */
2935 expect_ident ("define");
2936 expect (XBM_TK_IDENT
);
2938 if (LA1
== XBM_TK_NUMBER
);
2940 char *p
= strrchr (buffer
, '_');
2941 p
= p
? p
+ 1 : buffer
;
2942 if (strcmp (p
, "width") == 0)
2944 else if (strcmp (p
, "height") == 0)
2947 expect (XBM_TK_NUMBER
);
2950 if (*width
< 0 || *height
< 0)
2952 else if (data
== NULL
)
2955 /* Parse bits. Must start with `static'. */
2956 expect_ident ("static");
2957 if (LA1
== XBM_TK_IDENT
)
2959 if (strcmp (buffer
, "unsigned") == 0)
2962 expect_ident ("char");
2964 else if (strcmp (buffer
, "short") == 0)
2968 if (*width
% 16 && *width
% 16 < 9)
2971 else if (strcmp (buffer
, "char") == 0)
2979 expect (XBM_TK_IDENT
);
2985 bytes_per_line
= (*width
+ 7) / 8 + padding_p
;
2986 nbytes
= bytes_per_line
* *height
;
2987 p
= *data
= (char *) xmalloc (nbytes
);
2991 for (i
= 0; i
< nbytes
; i
+= 2)
2994 expect (XBM_TK_NUMBER
);
2996 *p
++ = XBM_BIT_SHUFFLE (val
);
2997 if (!padding_p
|| ((i
+ 2) % bytes_per_line
))
2998 *p
++ = XBM_BIT_SHUFFLE (value
>> 8);
3000 if (LA1
== ',' || LA1
== '}')
3008 for (i
= 0; i
< nbytes
; ++i
)
3011 expect (XBM_TK_NUMBER
);
3013 *p
++ = XBM_BIT_SHUFFLE (val
);
3015 if (LA1
== ',' || LA1
== '}')
3040 /* Load XBM image IMG which will be displayed on frame F from buffer
3041 CONTENTS. END is the end of the buffer. Value is non-zero if
3045 xbm_load_image (f
, img
, contents
, end
)
3048 unsigned char *contents
, *end
;
3051 unsigned char *data
;
3054 rc
= xbm_read_bitmap_data (contents
, end
, &img
->width
, &img
->height
, &data
);
3057 unsigned long foreground
= FRAME_FOREGROUND_PIXEL (f
);
3058 unsigned long background
= FRAME_BACKGROUND_PIXEL (f
);
3059 int non_default_colors
= 0;
3062 xassert (img
->width
> 0 && img
->height
> 0);
3064 /* Get foreground and background colors, maybe allocate colors. */
3065 value
= image_spec_value (img
->spec
, QCforeground
, NULL
);
3068 foreground
= x_alloc_image_color (f
, img
, value
, foreground
);
3069 non_default_colors
= 1;
3071 value
= image_spec_value (img
->spec
, QCbackground
, NULL
);
3074 background
= x_alloc_image_color (f
, img
, value
, background
);
3075 img
->background
= background
;
3076 img
->background_valid
= 1;
3077 non_default_colors
= 1;
3080 Create_Pixmap_From_Bitmap_Data (f
, img
, data
,
3081 foreground
, background
,
3082 non_default_colors
);
3085 if (img
->pixmap
== NO_PIXMAP
)
3087 x_clear_image (f
, img
);
3088 image_error ("Unable to create X pixmap for `%s'", img
->spec
, Qnil
);
3094 image_error ("Error loading XBM image `%s'", img
->spec
, Qnil
);
3100 /* Value is non-zero if DATA looks like an in-memory XBM file. */
3107 return (STRINGP (data
)
3108 && xbm_read_bitmap_data (SDATA (data
),
3115 /* Fill image IMG which is used on frame F with pixmap data. Value is
3116 non-zero if successful. */
3124 Lisp_Object file_name
;
3126 xassert (xbm_image_p (img
->spec
));
3128 /* If IMG->spec specifies a file name, create a non-file spec from it. */
3129 file_name
= image_spec_value (img
->spec
, QCfile
, NULL
);
3130 if (STRINGP (file_name
))
3133 unsigned char *contents
;
3135 struct gcpro gcpro1
;
3137 file
= x_find_image_file (file_name
);
3139 if (!STRINGP (file
))
3141 image_error ("Cannot find image file `%s'", file_name
, Qnil
);
3146 contents
= slurp_file (SDATA (file
), &size
);
3147 if (contents
== NULL
)
3149 image_error ("Error loading XBM image `%s'", img
->spec
, Qnil
);
3154 success_p
= xbm_load_image (f
, img
, contents
, contents
+ size
);
3159 struct image_keyword fmt
[XBM_LAST
];
3161 unsigned long foreground
= FRAME_FOREGROUND_PIXEL (f
);
3162 unsigned long background
= FRAME_BACKGROUND_PIXEL (f
);
3163 int non_default_colors
= 0;
3166 int in_memory_file_p
= 0;
3168 /* See if data looks like an in-memory XBM file. */
3169 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
3170 in_memory_file_p
= xbm_file_p (data
);
3172 /* Parse the image specification. */
3173 bcopy (xbm_format
, fmt
, sizeof fmt
);
3174 parsed_p
= parse_image_spec (img
->spec
, fmt
, XBM_LAST
, Qxbm
);
3177 /* Get specified width, and height. */
3178 if (!in_memory_file_p
)
3180 img
->width
= XFASTINT (fmt
[XBM_WIDTH
].value
);
3181 img
->height
= XFASTINT (fmt
[XBM_HEIGHT
].value
);
3182 xassert (img
->width
> 0 && img
->height
> 0);
3185 /* Get foreground and background colors, maybe allocate colors. */
3186 if (fmt
[XBM_FOREGROUND
].count
3187 && STRINGP (fmt
[XBM_FOREGROUND
].value
))
3189 foreground
= x_alloc_image_color (f
, img
, fmt
[XBM_FOREGROUND
].value
,
3191 non_default_colors
= 1;
3194 if (fmt
[XBM_BACKGROUND
].count
3195 && STRINGP (fmt
[XBM_BACKGROUND
].value
))
3197 background
= x_alloc_image_color (f
, img
, fmt
[XBM_BACKGROUND
].value
,
3199 non_default_colors
= 1;
3202 if (in_memory_file_p
)
3203 success_p
= xbm_load_image (f
, img
, SDATA (data
),
3212 int nbytes
= (img
->width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
;
3214 p
= bits
= (char *) alloca (nbytes
* img
->height
);
3215 for (i
= 0; i
< img
->height
; ++i
, p
+= nbytes
)
3217 Lisp_Object line
= XVECTOR (data
)->contents
[i
];
3219 bcopy (SDATA (line
), p
, nbytes
);
3221 bcopy (XBOOL_VECTOR (line
)->data
, p
, nbytes
);
3224 else if (STRINGP (data
))
3225 bits
= SDATA (data
);
3227 bits
= XBOOL_VECTOR (data
)->data
;
3229 /* Create the pixmap. */
3231 Create_Pixmap_From_Bitmap_Data (f
, img
, bits
,
3232 foreground
, background
,
3233 non_default_colors
);
3238 image_error ("Unable to create pixmap for XBM image `%s'",
3240 x_clear_image (f
, img
);
3250 /***********************************************************************
3252 ***********************************************************************/
3254 #if defined (HAVE_XPM) || defined (MAC_OS)
3256 static int xpm_image_p
P_ ((Lisp_Object object
));
3257 static int xpm_load
P_ ((struct frame
*f
, struct image
*img
));
3258 static int xpm_valid_color_symbols_p
P_ ((Lisp_Object
));
3260 #endif /* HAVE_XPM || MAC_OS */
3264 /* Indicate to xpm.h that we don't have Xlib. */
3266 /* simx.h in xpm defines XColor and XImage differently than Emacs. */
3267 /* It also defines Display the same way as Emacs, but gcc 3.3 still barfs. */
3268 #define XColor xpm_XColor
3269 #define XImage xpm_XImage
3270 #define Display xpm_Display
3271 #define PIXEL_ALREADY_TYPEDEFED
3272 #include "X11/xpm.h"
3277 #undef PIXEL_ALREADY_TYPEDEFED
3279 #include "X11/xpm.h"
3280 #endif /* HAVE_NTGUI */
3281 #endif /* HAVE_XPM */
3283 #if defined (HAVE_XPM) || defined (MAC_OS)
3284 /* The symbol `xpm' identifying XPM-format images. */
3288 /* Indices of image specification fields in xpm_format, below. */
3290 enum xpm_keyword_index
3306 /* Vector of image_keyword structures describing the format
3307 of valid XPM image specifications. */
3309 static struct image_keyword xpm_format
[XPM_LAST
] =
3311 {":type", IMAGE_SYMBOL_VALUE
, 1},
3312 {":file", IMAGE_STRING_VALUE
, 0},
3313 {":data", IMAGE_STRING_VALUE
, 0},
3314 {":ascent", IMAGE_ASCENT_VALUE
, 0},
3315 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
3316 {":relief", IMAGE_INTEGER_VALUE
, 0},
3317 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3318 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3319 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3320 {":color-symbols", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3321 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
3324 /* Structure describing the image type XPM. */
3326 static struct image_type xpm_type
=
3335 #ifdef HAVE_X_WINDOWS
3337 /* Define ALLOC_XPM_COLORS if we can use Emacs' own color allocation
3338 functions for allocating image colors. Our own functions handle
3339 color allocation failures more gracefully than the ones on the XPM
3342 #if defined XpmAllocColor && defined XpmFreeColors && defined XpmColorClosure
3343 #define ALLOC_XPM_COLORS
3345 #endif /* HAVE_X_WINDOWS */
3347 #ifdef ALLOC_XPM_COLORS
3349 static void xpm_init_color_cache
P_ ((struct frame
*, XpmAttributes
*));
3350 static void xpm_free_color_cache
P_ ((void));
3351 static int xpm_lookup_color
P_ ((struct frame
*, char *, XColor
*));
3352 static int xpm_color_bucket
P_ ((char *));
3353 static struct xpm_cached_color
*xpm_cache_color
P_ ((struct frame
*, char *,
3356 /* An entry in a hash table used to cache color definitions of named
3357 colors. This cache is necessary to speed up XPM image loading in
3358 case we do color allocations ourselves. Without it, we would need
3359 a call to XParseColor per pixel in the image. */
3361 struct xpm_cached_color
3363 /* Next in collision chain. */
3364 struct xpm_cached_color
*next
;
3366 /* Color definition (RGB and pixel color). */
3373 /* The hash table used for the color cache, and its bucket vector
3376 #define XPM_COLOR_CACHE_BUCKETS 1001
3377 struct xpm_cached_color
**xpm_color_cache
;
3379 /* Initialize the color cache. */
3382 xpm_init_color_cache (f
, attrs
)
3384 XpmAttributes
*attrs
;
3386 size_t nbytes
= XPM_COLOR_CACHE_BUCKETS
* sizeof *xpm_color_cache
;
3387 xpm_color_cache
= (struct xpm_cached_color
**) xmalloc (nbytes
);
3388 memset (xpm_color_cache
, 0, nbytes
);
3389 init_color_table ();
3391 if (attrs
->valuemask
& XpmColorSymbols
)
3396 for (i
= 0; i
< attrs
->numsymbols
; ++i
)
3397 if (XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
3398 attrs
->colorsymbols
[i
].value
, &color
))
3400 color
.pixel
= lookup_rgb_color (f
, color
.red
, color
.green
,
3402 xpm_cache_color (f
, attrs
->colorsymbols
[i
].name
, &color
, -1);
3407 /* Free the color cache. */
3410 xpm_free_color_cache ()
3412 struct xpm_cached_color
*p
, *next
;
3415 for (i
= 0; i
< XPM_COLOR_CACHE_BUCKETS
; ++i
)
3416 for (p
= xpm_color_cache
[i
]; p
; p
= next
)
3422 xfree (xpm_color_cache
);
3423 xpm_color_cache
= NULL
;
3424 free_color_table ();
3427 /* Return the bucket index for color named COLOR_NAME in the color
3431 xpm_color_bucket (color_name
)
3437 for (s
= color_name
; *s
; ++s
)
3439 return h
%= XPM_COLOR_CACHE_BUCKETS
;
3443 /* On frame F, cache values COLOR for color with name COLOR_NAME.
3444 BUCKET, if >= 0, is a precomputed bucket index. Value is the cache
3447 static struct xpm_cached_color
*
3448 xpm_cache_color (f
, color_name
, color
, bucket
)
3455 struct xpm_cached_color
*p
;
3458 bucket
= xpm_color_bucket (color_name
);
3460 nbytes
= sizeof *p
+ strlen (color_name
);
3461 p
= (struct xpm_cached_color
*) xmalloc (nbytes
);
3462 strcpy (p
->name
, color_name
);
3464 p
->next
= xpm_color_cache
[bucket
];
3465 xpm_color_cache
[bucket
] = p
;
3469 /* Look up color COLOR_NAME for frame F in the color cache. If found,
3470 return the cached definition in *COLOR. Otherwise, make a new
3471 entry in the cache and allocate the color. Value is zero if color
3472 allocation failed. */
3475 xpm_lookup_color (f
, color_name
, color
)
3480 struct xpm_cached_color
*p
;
3481 int h
= xpm_color_bucket (color_name
);
3483 for (p
= xpm_color_cache
[h
]; p
; p
= p
->next
)
3484 if (strcmp (p
->name
, color_name
) == 0)
3489 else if (XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
3492 color
->pixel
= lookup_rgb_color (f
, color
->red
, color
->green
,
3494 p
= xpm_cache_color (f
, color_name
, color
, h
);
3496 /* You get `opaque' at least from ImageMagick converting pbm to xpm
3497 with transparency, and it's useful. */
3498 else if (strcmp ("opaque", color_name
) == 0)
3500 bzero (color
, sizeof (XColor
)); /* Is this necessary/correct? */
3501 color
->pixel
= FRAME_FOREGROUND_PIXEL (f
);
3502 p
= xpm_cache_color (f
, color_name
, color
, h
);
3509 /* Callback for allocating color COLOR_NAME. Called from the XPM lib.
3510 CLOSURE is a pointer to the frame on which we allocate the
3511 color. Return in *COLOR the allocated color. Value is non-zero
3515 xpm_alloc_color (dpy
, cmap
, color_name
, color
, closure
)
3522 return xpm_lookup_color ((struct frame
*) closure
, color_name
, color
);
3526 /* Callback for freeing NPIXELS colors contained in PIXELS. CLOSURE
3527 is a pointer to the frame on which we allocate the color. Value is
3528 non-zero if successful. */
3531 xpm_free_colors (dpy
, cmap
, pixels
, npixels
, closure
)
3541 #endif /* ALLOC_XPM_COLORS */
3546 /* XPM library details. */
3548 DEF_IMGLIB_FN (XpmFreeAttributes
);
3549 DEF_IMGLIB_FN (XpmCreateImageFromBuffer
);
3550 DEF_IMGLIB_FN (XpmReadFileToImage
);
3551 DEF_IMGLIB_FN (XImageFree
);
3554 init_xpm_functions (Lisp_Object libraries
)
3558 if (!(library
= w32_delayed_load (libraries
, Qxpm
)))
3561 LOAD_IMGLIB_FN (library
, XpmFreeAttributes
);
3562 LOAD_IMGLIB_FN (library
, XpmCreateImageFromBuffer
);
3563 LOAD_IMGLIB_FN (library
, XpmReadFileToImage
);
3564 LOAD_IMGLIB_FN (library
, XImageFree
);
3568 #endif /* HAVE_NTGUI */
3571 /* Value is non-zero if COLOR_SYMBOLS is a valid color symbols list
3572 for XPM images. Such a list must consist of conses whose car and
3576 xpm_valid_color_symbols_p (color_symbols
)
3577 Lisp_Object color_symbols
;
3579 while (CONSP (color_symbols
))
3581 Lisp_Object sym
= XCAR (color_symbols
);
3583 || !STRINGP (XCAR (sym
))
3584 || !STRINGP (XCDR (sym
)))
3586 color_symbols
= XCDR (color_symbols
);
3589 return NILP (color_symbols
);
3593 /* Value is non-zero if OBJECT is a valid XPM image specification. */
3596 xpm_image_p (object
)
3599 struct image_keyword fmt
[XPM_LAST
];
3600 bcopy (xpm_format
, fmt
, sizeof fmt
);
3601 return (parse_image_spec (object
, fmt
, XPM_LAST
, Qxpm
)
3602 /* Either `:file' or `:data' must be present. */
3603 && fmt
[XPM_FILE
].count
+ fmt
[XPM_DATA
].count
== 1
3604 /* Either no `:color-symbols' or it's a list of conses
3605 whose car and cdr are strings. */
3606 && (fmt
[XPM_COLOR_SYMBOLS
].count
== 0
3607 || xpm_valid_color_symbols_p (fmt
[XPM_COLOR_SYMBOLS
].value
)));
3610 #endif /* HAVE_XPM || MAC_OS */
3612 /* Load image IMG which will be displayed on frame F. Value is
3613 non-zero if successful. */
3623 XpmAttributes attrs
;
3624 Lisp_Object specified_file
, color_symbols
;
3627 xpm_XImage
* xpm_image
= NULL
, * xpm_mask
= NULL
;
3628 #endif /* HAVE_NTGUI */
3630 /* Configure the XPM lib. Use the visual of frame F. Allocate
3631 close colors. Return colors allocated. */
3632 bzero (&attrs
, sizeof attrs
);
3635 attrs
.visual
= FRAME_X_VISUAL (f
);
3636 attrs
.colormap
= FRAME_X_COLORMAP (f
);
3637 attrs
.valuemask
|= XpmVisual
;
3638 attrs
.valuemask
|= XpmColormap
;
3639 #endif /* HAVE_NTGUI */
3641 #ifdef ALLOC_XPM_COLORS
3642 /* Allocate colors with our own functions which handle
3643 failing color allocation more gracefully. */
3644 attrs
.color_closure
= f
;
3645 attrs
.alloc_color
= xpm_alloc_color
;
3646 attrs
.free_colors
= xpm_free_colors
;
3647 attrs
.valuemask
|= XpmAllocColor
| XpmFreeColors
| XpmColorClosure
;
3648 #else /* not ALLOC_XPM_COLORS */
3649 /* Let the XPM lib allocate colors. */
3650 attrs
.valuemask
|= XpmReturnAllocPixels
;
3651 #ifdef XpmAllocCloseColors
3652 attrs
.alloc_close_colors
= 1;
3653 attrs
.valuemask
|= XpmAllocCloseColors
;
3654 #else /* not XpmAllocCloseColors */
3655 attrs
.closeness
= 600;
3656 attrs
.valuemask
|= XpmCloseness
;
3657 #endif /* not XpmAllocCloseColors */
3658 #endif /* ALLOC_XPM_COLORS */
3660 /* If image specification contains symbolic color definitions, add
3661 these to `attrs'. */
3662 color_symbols
= image_spec_value (img
->spec
, QCcolor_symbols
, NULL
);
3663 if (CONSP (color_symbols
))
3666 XpmColorSymbol
*xpm_syms
;
3669 attrs
.valuemask
|= XpmColorSymbols
;
3671 /* Count number of symbols. */
3672 attrs
.numsymbols
= 0;
3673 for (tail
= color_symbols
; CONSP (tail
); tail
= XCDR (tail
))
3676 /* Allocate an XpmColorSymbol array. */
3677 size
= attrs
.numsymbols
* sizeof *xpm_syms
;
3678 xpm_syms
= (XpmColorSymbol
*) alloca (size
);
3679 bzero (xpm_syms
, size
);
3680 attrs
.colorsymbols
= xpm_syms
;
3682 /* Fill the color symbol array. */
3683 for (tail
= color_symbols
, i
= 0;
3685 ++i
, tail
= XCDR (tail
))
3687 Lisp_Object name
= XCAR (XCAR (tail
));
3688 Lisp_Object color
= XCDR (XCAR (tail
));
3689 xpm_syms
[i
].name
= (char *) alloca (SCHARS (name
) + 1);
3690 strcpy (xpm_syms
[i
].name
, SDATA (name
));
3691 xpm_syms
[i
].value
= (char *) alloca (SCHARS (color
) + 1);
3692 strcpy (xpm_syms
[i
].value
, SDATA (color
));
3696 /* Create a pixmap for the image, either from a file, or from a
3697 string buffer containing data in the same format as an XPM file. */
3698 #ifdef ALLOC_XPM_COLORS
3699 xpm_init_color_cache (f
, &attrs
);
3702 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
3706 HDC frame_dc
= get_frame_dc (f
);
3707 hdc
= CreateCompatibleDC (frame_dc
);
3708 release_frame_dc (f
, frame_dc
);
3710 #endif /* HAVE_NTGUI */
3712 if (STRINGP (specified_file
))
3714 Lisp_Object file
= x_find_image_file (specified_file
);
3715 if (!STRINGP (file
))
3717 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
3722 /* XpmReadFileToPixmap is not available in the Windows port of
3723 libxpm. But XpmReadFileToImage almost does what we want. */
3724 rc
= fn_XpmReadFileToImage (&hdc
, SDATA (file
),
3725 &xpm_image
, &xpm_mask
,
3728 rc
= XpmReadFileToPixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3729 SDATA (file
), &img
->pixmap
, &img
->mask
,
3731 #endif /* HAVE_NTGUI */
3735 Lisp_Object buffer
= image_spec_value (img
->spec
, QCdata
, NULL
);
3737 /* XpmCreatePixmapFromBuffer is not available in the Windows port
3738 of libxpm. But XpmCreateImageFromBuffer almost does what we want. */
3739 rc
= fn_XpmCreateImageFromBuffer (&hdc
, SDATA (buffer
),
3740 &xpm_image
, &xpm_mask
,
3743 rc
= XpmCreatePixmapFromBuffer (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3745 &img
->pixmap
, &img
->mask
,
3747 #endif /* HAVE_NTGUI */
3750 if (rc
== XpmSuccess
)
3752 #if defined (COLOR_TABLE_SUPPORT) && defined (ALLOC_XPM_COLORS)
3753 img
->colors
= colors_in_color_table (&img
->ncolors
);
3754 #else /* not ALLOC_XPM_COLORS */
3758 /* W32 XPM uses XImage to wrap what W32 Emacs calls a Pixmap,
3759 plus some duplicate attributes. */
3760 if (xpm_image
&& xpm_image
->bitmap
)
3762 img
->pixmap
= xpm_image
->bitmap
;
3763 /* XImageFree in libXpm frees XImage struct without destroying
3764 the bitmap, which is what we want. */
3765 fn_XImageFree (xpm_image
);
3767 if (xpm_mask
&& xpm_mask
->bitmap
)
3769 /* The mask appears to be inverted compared with what we expect.
3770 TODO: invert our expectations. See other places where we
3771 have to invert bits because our idea of masks is backwards. */
3773 old_obj
= SelectObject (hdc
, xpm_mask
->bitmap
);
3775 PatBlt (hdc
, 0, 0, xpm_mask
->width
, xpm_mask
->height
, DSTINVERT
);
3776 SelectObject (hdc
, old_obj
);
3778 img
->mask
= xpm_mask
->bitmap
;
3779 fn_XImageFree (xpm_mask
);
3784 #endif /* HAVE_NTGUI */
3786 /* Remember allocated colors. */
3787 img
->ncolors
= attrs
.nalloc_pixels
;
3788 img
->colors
= (unsigned long *) xmalloc (img
->ncolors
3789 * sizeof *img
->colors
);
3790 for (i
= 0; i
< attrs
.nalloc_pixels
; ++i
)
3792 img
->colors
[i
] = attrs
.alloc_pixels
[i
];
3793 #ifdef DEBUG_X_COLORS
3794 register_color (img
->colors
[i
]);
3797 #endif /* not ALLOC_XPM_COLORS */
3799 img
->width
= attrs
.width
;
3800 img
->height
= attrs
.height
;
3801 xassert (img
->width
> 0 && img
->height
> 0);
3803 /* The call to XpmFreeAttributes below frees attrs.alloc_pixels. */
3805 fn_XpmFreeAttributes (&attrs
);
3807 XpmFreeAttributes (&attrs
);
3808 #endif /* HAVE_NTGUI */
3814 #endif /* HAVE_NTGUI */
3819 image_error ("Error opening XPM file (%s)", img
->spec
, Qnil
);
3822 case XpmFileInvalid
:
3823 image_error ("Invalid XPM file (%s)", img
->spec
, Qnil
);
3827 image_error ("Out of memory (%s)", img
->spec
, Qnil
);
3830 case XpmColorFailed
:
3831 image_error ("Color allocation error (%s)", img
->spec
, Qnil
);
3835 image_error ("Unknown error (%s)", img
->spec
, Qnil
);
3840 #ifdef ALLOC_XPM_COLORS
3841 xpm_free_color_cache ();
3843 return rc
== XpmSuccess
;
3846 #endif /* HAVE_XPM */
3850 /* XPM support functions for Mac OS where libxpm is not available.
3851 Only XPM version 3 (without any extensions) is supported. */
3853 static int xpm_scan
P_ ((unsigned char **, unsigned char *,
3854 unsigned char **, int *));
3855 static Lisp_Object xpm_make_color_table_v
3856 P_ ((void (**) (Lisp_Object
, unsigned char *, int, Lisp_Object
),
3857 Lisp_Object (**) (Lisp_Object
, unsigned char *, int)));
3858 static void xpm_put_color_table_v
P_ ((Lisp_Object
, unsigned char *,
3860 static Lisp_Object xpm_get_color_table_v
P_ ((Lisp_Object
,
3861 unsigned char *, int));
3862 static Lisp_Object xpm_make_color_table_h
3863 P_ ((void (**) (Lisp_Object
, unsigned char *, int, Lisp_Object
),
3864 Lisp_Object (**) (Lisp_Object
, unsigned char *, int)));
3865 static void xpm_put_color_table_h
P_ ((Lisp_Object
, unsigned char *,
3867 static Lisp_Object xpm_get_color_table_h
P_ ((Lisp_Object
,
3868 unsigned char *, int));
3869 static int xpm_str_to_color_key
P_ ((char *));
3870 static int xpm_load_image
P_ ((struct frame
*, struct image
*,
3871 unsigned char *, unsigned char *));
3873 /* Tokens returned from xpm_scan. */
3882 /* Scan an XPM data and return a character (< 256) or a token defined
3883 by enum xpm_token above. *S and END are the start (inclusive) and
3884 the end (exclusive) addresses of the data, respectively. Advance
3885 *S while scanning. If token is either XPM_TK_IDENT or
3886 XPM_TK_STRING, *BEG and *LEN are set to the start address and the
3887 length of the corresponding token, respectively. */
3890 xpm_scan (s
, end
, beg
, len
)
3891 unsigned char **s
, *end
, **beg
;
3898 /* Skip white-space. */
3899 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
3902 /* gnus-pointer.xpm uses '-' in its identifier.
3903 sb-dir-plus.xpm uses '+' in its identifier. */
3904 if (isalpha (c
) || c
== '_' || c
== '-' || c
== '+')
3908 (c
= **s
, isalnum (c
) || c
== '_' || c
== '-' || c
== '+'))
3911 return XPM_TK_IDENT
;
3916 while (*s
< end
&& **s
!= '"')
3921 return XPM_TK_STRING
;
3925 if (*s
< end
&& **s
== '*')
3927 /* C-style comment. */
3931 while (*s
< end
&& *(*s
)++ != '*')
3934 while (*s
< end
&& **s
!= '/');
3948 /* Functions for color table lookup in XPM data. A Key is a string
3949 specifying the color of each pixel in XPM data. A value is either
3950 an integer that specifies a pixel color, Qt that specifies
3951 transparency, or Qnil for the unspecified color. If the length of
3952 the key string is one, a vector is used as a table. Otherwise, a
3953 hash table is used. */
3956 xpm_make_color_table_v (put_func
, get_func
)
3957 void (**put_func
) (Lisp_Object
, unsigned char *, int, Lisp_Object
);
3958 Lisp_Object (**get_func
) (Lisp_Object
, unsigned char *, int);
3960 *put_func
= xpm_put_color_table_v
;
3961 *get_func
= xpm_get_color_table_v
;
3962 return Fmake_vector (make_number (256), Qnil
);
3966 xpm_put_color_table_v (color_table
, chars_start
, chars_len
, color
)
3967 Lisp_Object color_table
;
3968 unsigned char *chars_start
;
3972 XVECTOR (color_table
)->contents
[*chars_start
] = color
;
3976 xpm_get_color_table_v (color_table
, chars_start
, chars_len
)
3977 Lisp_Object color_table
;
3978 unsigned char *chars_start
;
3981 return XVECTOR (color_table
)->contents
[*chars_start
];
3985 xpm_make_color_table_h (put_func
, get_func
)
3986 void (**put_func
) (Lisp_Object
, unsigned char *, int, Lisp_Object
);
3987 Lisp_Object (**get_func
) (Lisp_Object
, unsigned char *, int);
3989 *put_func
= xpm_put_color_table_h
;
3990 *get_func
= xpm_get_color_table_h
;
3991 return make_hash_table (Qequal
, make_number (DEFAULT_HASH_SIZE
),
3992 make_float (DEFAULT_REHASH_SIZE
),
3993 make_float (DEFAULT_REHASH_THRESHOLD
),
3998 xpm_put_color_table_h (color_table
, chars_start
, chars_len
, color
)
3999 Lisp_Object color_table
;
4000 unsigned char *chars_start
;
4004 struct Lisp_Hash_Table
*table
= XHASH_TABLE (color_table
);
4006 Lisp_Object chars
= make_unibyte_string (chars_start
, chars_len
);
4008 hash_lookup (table
, chars
, &hash_code
);
4009 hash_put (table
, chars
, color
, hash_code
);
4013 xpm_get_color_table_h (color_table
, chars_start
, chars_len
)
4014 Lisp_Object color_table
;
4015 unsigned char *chars_start
;
4018 struct Lisp_Hash_Table
*table
= XHASH_TABLE (color_table
);
4019 int i
= hash_lookup (table
, make_unibyte_string (chars_start
, chars_len
),
4022 return i
>= 0 ? HASH_VALUE (table
, i
) : Qnil
;
4025 enum xpm_color_key
{
4033 static char xpm_color_key_strings
[][4] = {"s", "m", "g4", "g", "c"};
4036 xpm_str_to_color_key (s
)
4042 i
< sizeof xpm_color_key_strings
/ sizeof xpm_color_key_strings
[0];
4044 if (strcmp (xpm_color_key_strings
[i
], s
) == 0)
4050 xpm_load_image (f
, img
, contents
, end
)
4053 unsigned char *contents
, *end
;
4055 unsigned char *s
= contents
, *beg
, *str
;
4056 unsigned char buffer
[BUFSIZ
];
4057 int width
, height
, x
, y
;
4058 int num_colors
, chars_per_pixel
;
4060 void (*put_color_table
) (Lisp_Object
, unsigned char *, int, Lisp_Object
);
4061 Lisp_Object (*get_color_table
) (Lisp_Object
, unsigned char *, int);
4062 Lisp_Object frame
, color_symbols
, color_table
;
4063 int best_key
, have_mask
= 0;
4064 XImagePtr ximg
= NULL
, mask_img
= NULL
;
4067 LA1 = xpm_scan (&s, end, &beg, &len)
4069 #define expect(TOKEN) \
4070 if (LA1 != (TOKEN)) \
4075 #define expect_ident(IDENT) \
4076 if (LA1 == XPM_TK_IDENT \
4077 && strlen ((IDENT)) == len && memcmp ((IDENT), beg, len) == 0) \
4082 if (!(end
- s
>= 9 && memcmp (s
, "/* XPM */", 9) == 0))
4086 expect_ident ("static");
4087 expect_ident ("char");
4089 expect (XPM_TK_IDENT
);
4094 expect (XPM_TK_STRING
);
4097 memcpy (buffer
, beg
, len
);
4099 if (sscanf (buffer
, "%d %d %d %d", &width
, &height
,
4100 &num_colors
, &chars_per_pixel
) != 4
4101 || width
<= 0 || height
<= 0
4102 || num_colors
<= 0 || chars_per_pixel
<= 0)
4106 XSETFRAME (frame
, f
);
4107 if (!NILP (Fxw_display_color_p (frame
)))
4108 best_key
= XPM_COLOR_KEY_C
;
4109 else if (!NILP (Fx_display_grayscale_p (frame
)))
4110 best_key
= (XFASTINT (Fx_display_planes (frame
)) > 2
4111 ? XPM_COLOR_KEY_G
: XPM_COLOR_KEY_G4
);
4113 best_key
= XPM_COLOR_KEY_M
;
4115 color_symbols
= image_spec_value (img
->spec
, QCcolor_symbols
, NULL
);
4116 if (chars_per_pixel
== 1)
4117 color_table
= xpm_make_color_table_v (&put_color_table
,
4120 color_table
= xpm_make_color_table_h (&put_color_table
,
4123 while (num_colors
-- > 0)
4125 unsigned char *color
, *max_color
;
4126 int key
, next_key
, max_key
= 0;
4127 Lisp_Object symbol_color
= Qnil
, color_val
;
4130 expect (XPM_TK_STRING
);
4131 if (len
<= chars_per_pixel
|| len
>= BUFSIZ
+ chars_per_pixel
)
4133 memcpy (buffer
, beg
+ chars_per_pixel
, len
- chars_per_pixel
);
4134 buffer
[len
- chars_per_pixel
] = '\0';
4136 str
= strtok (buffer
, " \t");
4139 key
= xpm_str_to_color_key (str
);
4144 color
= strtok (NULL
, " \t");
4148 while (str
= strtok (NULL
, " \t"))
4150 next_key
= xpm_str_to_color_key (str
);
4153 color
[strlen (color
)] = ' ';
4156 if (key
== XPM_COLOR_KEY_S
)
4158 if (NILP (symbol_color
))
4159 symbol_color
= build_string (color
);
4161 else if (max_key
< key
&& key
<= best_key
)
4171 if (!NILP (color_symbols
) && !NILP (symbol_color
))
4173 Lisp_Object specified_color
= Fassoc (symbol_color
, color_symbols
);
4175 if (CONSP (specified_color
) && STRINGP (XCDR (specified_color
)))
4176 if (xstricmp (SDATA (XCDR (specified_color
)), "None") == 0)
4178 else if (x_defined_color (f
, SDATA (XCDR (specified_color
)),
4180 color_val
= make_number (cdef
.pixel
);
4182 if (NILP (color_val
) && max_key
> 0)
4183 if (xstricmp (max_color
, "None") == 0)
4185 else if (x_defined_color (f
, max_color
, &cdef
, 0))
4186 color_val
= make_number (cdef
.pixel
);
4187 if (!NILP (color_val
))
4188 (*put_color_table
) (color_table
, beg
, chars_per_pixel
, color_val
);
4193 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0,
4194 &ximg
, &img
->pixmap
)
4195 || !x_create_x_image_and_pixmap (f
, width
, height
, 1,
4196 &mask_img
, &img
->mask
))
4198 image_error ("Out of memory (%s)", img
->spec
, Qnil
);
4202 for (y
= 0; y
< height
; y
++)
4204 expect (XPM_TK_STRING
);
4206 if (len
< width
* chars_per_pixel
)
4208 for (x
= 0; x
< width
; x
++, str
+= chars_per_pixel
)
4210 Lisp_Object color_val
=
4211 (*get_color_table
) (color_table
, str
, chars_per_pixel
);
4213 XPutPixel (ximg
, x
, y
,
4214 (INTEGERP (color_val
) ? XINT (color_val
)
4215 : FRAME_FOREGROUND_PIXEL (f
)));
4216 XPutPixel (mask_img
, x
, y
,
4217 (!EQ (color_val
, Qt
) ? PIX_MASK_DRAW (f
)
4218 : (have_mask
= 1, PIX_MASK_RETAIN (f
))));
4225 img
->height
= height
;
4227 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
4228 x_destroy_x_image (ximg
);
4231 x_put_x_image (f
, mask_img
, img
->mask
, width
, height
);
4232 x_destroy_x_image (mask_img
);
4236 x_destroy_x_image (mask_img
);
4237 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
4238 img
->mask
= NO_PIXMAP
;
4244 image_error ("Invalid XPM file (%s)", img
->spec
, Qnil
);
4246 x_destroy_x_image (ximg
);
4247 x_destroy_x_image (mask_img
);
4248 x_clear_image (f
, img
);
4262 Lisp_Object file_name
;
4264 /* If IMG->spec specifies a file name, create a non-file spec from it. */
4265 file_name
= image_spec_value (img
->spec
, QCfile
, NULL
);
4266 if (STRINGP (file_name
))
4269 unsigned char *contents
;
4271 struct gcpro gcpro1
;
4273 file
= x_find_image_file (file_name
);
4275 if (!STRINGP (file
))
4277 image_error ("Cannot find image file `%s'", file_name
, Qnil
);
4282 contents
= slurp_file (SDATA (file
), &size
);
4283 if (contents
== NULL
)
4285 image_error ("Error loading XPM image `%s'", img
->spec
, Qnil
);
4290 success_p
= xpm_load_image (f
, img
, contents
, contents
+ size
);
4298 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
4299 success_p
= xpm_load_image (f
, img
, SDATA (data
),
4300 SDATA (data
) + SBYTES (data
));
4310 /***********************************************************************
4312 ***********************************************************************/
4314 #ifdef COLOR_TABLE_SUPPORT
4316 /* An entry in the color table mapping an RGB color to a pixel color. */
4321 unsigned long pixel
;
4323 /* Next in color table collision list. */
4324 struct ct_color
*next
;
4327 /* The bucket vector size to use. Must be prime. */
4331 /* Value is a hash of the RGB color given by R, G, and B. */
4333 #define CT_HASH_RGB(R, G, B) (((R) << 16) ^ ((G) << 8) ^ (B))
4335 /* The color hash table. */
4337 struct ct_color
**ct_table
;
4339 /* Number of entries in the color table. */
4341 int ct_colors_allocated
;
4343 /* Initialize the color table. */
4348 int size
= CT_SIZE
* sizeof (*ct_table
);
4349 ct_table
= (struct ct_color
**) xmalloc (size
);
4350 bzero (ct_table
, size
);
4351 ct_colors_allocated
= 0;
4355 /* Free memory associated with the color table. */
4361 struct ct_color
*p
, *next
;
4363 for (i
= 0; i
< CT_SIZE
; ++i
)
4364 for (p
= ct_table
[i
]; p
; p
= next
)
4375 /* Value is a pixel color for RGB color R, G, B on frame F. If an
4376 entry for that color already is in the color table, return the
4377 pixel color of that entry. Otherwise, allocate a new color for R,
4378 G, B, and make an entry in the color table. */
4380 static unsigned long
4381 lookup_rgb_color (f
, r
, g
, b
)
4385 unsigned hash
= CT_HASH_RGB (r
, g
, b
);
4386 int i
= hash
% CT_SIZE
;
4388 Display_Info
*dpyinfo
;
4390 /* Handle TrueColor visuals specially, which improves performance by
4391 two orders of magnitude. Freeing colors on TrueColor visuals is
4392 a nop, and pixel colors specify RGB values directly. See also
4393 the Xlib spec, chapter 3.1. */
4394 dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
4395 if (dpyinfo
->red_bits
> 0)
4397 unsigned long pr
, pg
, pb
;
4399 /* Apply gamma-correction like normal color allocation does. */
4403 color
.red
= r
, color
.green
= g
, color
.blue
= b
;
4404 gamma_correct (f
, &color
);
4405 r
= color
.red
, g
= color
.green
, b
= color
.blue
;
4408 /* Scale down RGB values to the visual's bits per RGB, and shift
4409 them to the right position in the pixel color. Note that the
4410 original RGB values are 16-bit values, as usual in X. */
4411 pr
= (r
>> (16 - dpyinfo
->red_bits
)) << dpyinfo
->red_offset
;
4412 pg
= (g
>> (16 - dpyinfo
->green_bits
)) << dpyinfo
->green_offset
;
4413 pb
= (b
>> (16 - dpyinfo
->blue_bits
)) << dpyinfo
->blue_offset
;
4415 /* Assemble the pixel color. */
4416 return pr
| pg
| pb
;
4419 for (p
= ct_table
[i
]; p
; p
= p
->next
)
4420 if (p
->r
== r
&& p
->g
== g
&& p
->b
== b
)
4426 #ifdef HAVE_X_WINDOWS
4435 cmap
= FRAME_X_COLORMAP (f
);
4436 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
4439 ++ct_colors_allocated
;
4440 p
= (struct ct_color
*) xmalloc (sizeof *p
);
4444 p
->pixel
= color
.pixel
;
4445 p
->next
= ct_table
[i
];
4449 return FRAME_FOREGROUND_PIXEL (f
);
4454 color
= PALETTERGB (r
, g
, b
);
4456 color
= RGB_TO_ULONG (r
, g
, b
);
4457 #endif /* HAVE_NTGUI */
4458 ++ct_colors_allocated
;
4459 p
= (struct ct_color
*) xmalloc (sizeof *p
);
4464 p
->next
= ct_table
[i
];
4466 #endif /* HAVE_X_WINDOWS */
4474 /* Look up pixel color PIXEL which is used on frame F in the color
4475 table. If not already present, allocate it. Value is PIXEL. */
4477 static unsigned long
4478 lookup_pixel_color (f
, pixel
)
4480 unsigned long pixel
;
4482 int i
= pixel
% CT_SIZE
;
4485 for (p
= ct_table
[i
]; p
; p
= p
->next
)
4486 if (p
->pixel
== pixel
)
4495 #ifdef HAVE_X_WINDOWS
4496 cmap
= FRAME_X_COLORMAP (f
);
4497 color
.pixel
= pixel
;
4498 x_query_color (f
, &color
);
4499 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
4502 cmap
= DefaultColormapOfScreen (FRAME_X_SCREEN (f
));
4503 color
.pixel
= pixel
;
4504 XQueryColor (NULL
, cmap
, &color
);
4505 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
4507 #endif /* HAVE_X_WINDOWS */
4511 ++ct_colors_allocated
;
4513 p
= (struct ct_color
*) xmalloc (sizeof *p
);
4518 p
->next
= ct_table
[i
];
4522 return FRAME_FOREGROUND_PIXEL (f
);
4528 /* Value is a vector of all pixel colors contained in the color table,
4529 allocated via xmalloc. Set *N to the number of colors. */
4531 static unsigned long *
4532 colors_in_color_table (n
)
4537 unsigned long *colors
;
4539 if (ct_colors_allocated
== 0)
4546 colors
= (unsigned long *) xmalloc (ct_colors_allocated
4548 *n
= ct_colors_allocated
;
4550 for (i
= j
= 0; i
< CT_SIZE
; ++i
)
4551 for (p
= ct_table
[i
]; p
; p
= p
->next
)
4552 colors
[j
++] = p
->pixel
;
4558 #else /* COLOR_TABLE_SUPPORT */
4560 static unsigned long
4561 lookup_rgb_color (f
, r
, g
, b
)
4565 unsigned long pixel
;
4568 pixel
= RGB_TO_ULONG (r
>> 8, g
>> 8, b
>> 8);
4569 gamma_correct (f
, &pixel
);
4573 pixel
= PALETTERGB (r
>> 8, g
>> 8, b
>> 8);
4574 #endif /* HAVE_NTGUI */
4583 #endif /* COLOR_TABLE_SUPPORT */
4586 /***********************************************************************
4588 ***********************************************************************/
4590 static XColor
*x_to_xcolors
P_ ((struct frame
*, struct image
*, int));
4591 static void x_from_xcolors
P_ ((struct frame
*, struct image
*, XColor
*));
4592 static void x_detect_edges
P_ ((struct frame
*, struct image
*, int[9], int));
4595 static void XPutPixel (XImagePtr
, int, int, COLORREF
);
4596 #endif /* HAVE_NTGUI */
4598 /* Non-zero means draw a cross on images having `:conversion
4601 int cross_disabled_images
;
4603 /* Edge detection matrices for different edge-detection
4606 static int emboss_matrix
[9] = {
4608 2, -1, 0, /* y - 1 */
4610 0, 1, -2 /* y + 1 */
4613 static int laplace_matrix
[9] = {
4615 1, 0, 0, /* y - 1 */
4617 0, 0, -1 /* y + 1 */
4620 /* Value is the intensity of the color whose red/green/blue values
4623 #define COLOR_INTENSITY(R, G, B) ((2 * (R) + 3 * (G) + (B)) / 6)
4626 /* On frame F, return an array of XColor structures describing image
4627 IMG->pixmap. Each XColor structure has its pixel color set. RGB_P
4628 non-zero means also fill the red/green/blue members of the XColor
4629 structures. Value is a pointer to the array of XColors structures,
4630 allocated with xmalloc; it must be freed by the caller. */
4633 x_to_xcolors (f
, img
, rgb_p
)
4640 XImagePtr_or_DC ximg
;
4644 #endif /* HAVE_NTGUI */
4646 colors
= (XColor
*) xmalloc (img
->width
* img
->height
* sizeof *colors
);
4649 /* Get the X image IMG->pixmap. */
4650 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
4651 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
4653 /* Load the image into a memory device context. */
4654 hdc
= get_frame_dc (f
);
4655 ximg
= CreateCompatibleDC (hdc
);
4656 release_frame_dc (f
, hdc
);
4657 prev
= SelectObject (ximg
, img
->pixmap
);
4658 #endif /* HAVE_NTGUI */
4660 /* Fill the `pixel' members of the XColor array. I wished there
4661 were an easy and portable way to circumvent XGetPixel. */
4663 for (y
= 0; y
< img
->height
; ++y
)
4667 #ifdef HAVE_X_WINDOWS
4668 for (x
= 0; x
< img
->width
; ++x
, ++p
)
4669 p
->pixel
= XGetPixel (ximg
, x
, y
);
4671 x_query_colors (f
, row
, img
->width
);
4675 for (x
= 0; x
< img
->width
; ++x
, ++p
)
4677 /* W32_TODO: palette support needed here? */
4678 p
->pixel
= GET_PIXEL (ximg
, x
, y
);
4682 p
->red
= RED16_FROM_ULONG (p
->pixel
);
4683 p
->green
= GREEN16_FROM_ULONG (p
->pixel
);
4684 p
->blue
= BLUE16_FROM_ULONG (p
->pixel
);
4687 p
->red
= 256 * GetRValue (p
->pixel
);
4688 p
->green
= 256 * GetGValue (p
->pixel
);
4689 p
->blue
= 256 * GetBValue (p
->pixel
);
4690 #endif /* HAVE_NTGUI */
4693 #endif /* HAVE_X_WINDOWS */
4696 Destroy_Image (ximg
, prev
);
4703 /* Put a pixel of COLOR at position X, Y in XIMG. XIMG must have been
4704 created with CreateDIBSection, with the pointer to the bit values
4705 stored in ximg->data. */
4707 static void XPutPixel (ximg
, x
, y
, color
)
4712 int width
= ximg
->info
.bmiHeader
.biWidth
;
4713 int height
= ximg
->info
.bmiHeader
.biHeight
;
4714 unsigned char * pixel
;
4716 /* True color images. */
4717 if (ximg
->info
.bmiHeader
.biBitCount
== 24)
4719 int rowbytes
= width
* 3;
4720 /* Ensure scanlines are aligned on 4 byte boundaries. */
4722 rowbytes
+= 4 - (rowbytes
% 4);
4724 pixel
= ximg
->data
+ y
* rowbytes
+ x
* 3;
4725 /* Windows bitmaps are in BGR order. */
4726 *pixel
= GetBValue (color
);
4727 *(pixel
+ 1) = GetGValue (color
);
4728 *(pixel
+ 2) = GetRValue (color
);
4730 /* Monochrome images. */
4731 else if (ximg
->info
.bmiHeader
.biBitCount
== 1)
4733 int rowbytes
= width
/ 8;
4734 /* Ensure scanlines are aligned on 4 byte boundaries. */
4736 rowbytes
+= 4 - (rowbytes
% 4);
4737 pixel
= ximg
->data
+ y
* rowbytes
+ x
/ 8;
4738 /* Filter out palette info. */
4739 if (color
& 0x00ffffff)
4740 *pixel
= *pixel
| (1 << x
% 8);
4742 *pixel
= *pixel
& ~(1 << x
% 8);
4745 image_error ("XPutPixel: palette image not supported", Qnil
, Qnil
);
4748 #endif /* HAVE_NTGUI */
4750 /* Create IMG->pixmap from an array COLORS of XColor structures, whose
4751 RGB members are set. F is the frame on which this all happens.
4752 COLORS will be freed; an existing IMG->pixmap will be freed, too. */
4755 x_from_xcolors (f
, img
, colors
)
4765 init_color_table ();
4767 x_create_x_image_and_pixmap (f
, img
->width
, img
->height
, 0,
4770 for (y
= 0; y
< img
->height
; ++y
)
4771 for (x
= 0; x
< img
->width
; ++x
, ++p
)
4773 unsigned long pixel
;
4774 pixel
= lookup_rgb_color (f
, p
->red
, p
->green
, p
->blue
);
4775 XPutPixel (oimg
, x
, y
, pixel
);
4779 x_clear_image_1 (f
, img
, 1, 0, 1);
4781 x_put_x_image (f
, oimg
, pixmap
, img
->width
, img
->height
);
4782 x_destroy_x_image (oimg
);
4783 img
->pixmap
= pixmap
;
4784 #ifdef COLOR_TABLE_SUPPORT
4785 img
->colors
= colors_in_color_table (&img
->ncolors
);
4786 free_color_table ();
4787 #endif /* COLOR_TABLE_SUPPORT */
4791 /* On frame F, perform edge-detection on image IMG.
4793 MATRIX is a nine-element array specifying the transformation
4794 matrix. See emboss_matrix for an example.
4796 COLOR_ADJUST is a color adjustment added to each pixel of the
4800 x_detect_edges (f
, img
, matrix
, color_adjust
)
4803 int matrix
[9], color_adjust
;
4805 XColor
*colors
= x_to_xcolors (f
, img
, 1);
4809 for (i
= sum
= 0; i
< 9; ++i
)
4810 sum
+= abs (matrix
[i
]);
4812 #define COLOR(A, X, Y) ((A) + (Y) * img->width + (X))
4814 new = (XColor
*) xmalloc (img
->width
* img
->height
* sizeof *new);
4816 for (y
= 0; y
< img
->height
; ++y
)
4818 p
= COLOR (new, 0, y
);
4819 p
->red
= p
->green
= p
->blue
= 0xffff/2;
4820 p
= COLOR (new, img
->width
- 1, y
);
4821 p
->red
= p
->green
= p
->blue
= 0xffff/2;
4824 for (x
= 1; x
< img
->width
- 1; ++x
)
4826 p
= COLOR (new, x
, 0);
4827 p
->red
= p
->green
= p
->blue
= 0xffff/2;
4828 p
= COLOR (new, x
, img
->height
- 1);
4829 p
->red
= p
->green
= p
->blue
= 0xffff/2;
4832 for (y
= 1; y
< img
->height
- 1; ++y
)
4834 p
= COLOR (new, 1, y
);
4836 for (x
= 1; x
< img
->width
- 1; ++x
, ++p
)
4838 int r
, g
, b
, y1
, x1
;
4841 for (y1
= y
- 1; y1
< y
+ 2; ++y1
)
4842 for (x1
= x
- 1; x1
< x
+ 2; ++x1
, ++i
)
4845 XColor
*t
= COLOR (colors
, x1
, y1
);
4846 r
+= matrix
[i
] * t
->red
;
4847 g
+= matrix
[i
] * t
->green
;
4848 b
+= matrix
[i
] * t
->blue
;
4851 r
= (r
/ sum
+ color_adjust
) & 0xffff;
4852 g
= (g
/ sum
+ color_adjust
) & 0xffff;
4853 b
= (b
/ sum
+ color_adjust
) & 0xffff;
4854 p
->red
= p
->green
= p
->blue
= COLOR_INTENSITY (r
, g
, b
);
4859 x_from_xcolors (f
, img
, new);
4865 /* Perform the pre-defined `emboss' edge-detection on image IMG
4873 x_detect_edges (f
, img
, emboss_matrix
, 0xffff / 2);
4877 /* Transform image IMG which is used on frame F with a Laplace
4878 edge-detection algorithm. The result is an image that can be used
4879 to draw disabled buttons, for example. */
4886 x_detect_edges (f
, img
, laplace_matrix
, 45000);
4890 /* Perform edge-detection on image IMG on frame F, with specified
4891 transformation matrix MATRIX and color-adjustment COLOR_ADJUST.
4893 MATRIX must be either
4895 - a list of at least 9 numbers in row-major form
4896 - a vector of at least 9 numbers
4898 COLOR_ADJUST nil means use a default; otherwise it must be a
4902 x_edge_detection (f
, img
, matrix
, color_adjust
)
4905 Lisp_Object matrix
, color_adjust
;
4913 i
< 9 && CONSP (matrix
) && NUMBERP (XCAR (matrix
));
4914 ++i
, matrix
= XCDR (matrix
))
4915 trans
[i
] = XFLOATINT (XCAR (matrix
));
4917 else if (VECTORP (matrix
) && ASIZE (matrix
) >= 9)
4919 for (i
= 0; i
< 9 && NUMBERP (AREF (matrix
, i
)); ++i
)
4920 trans
[i
] = XFLOATINT (AREF (matrix
, i
));
4923 if (NILP (color_adjust
))
4924 color_adjust
= make_number (0xffff / 2);
4926 if (i
== 9 && NUMBERP (color_adjust
))
4927 x_detect_edges (f
, img
, trans
, (int) XFLOATINT (color_adjust
));
4931 /* Transform image IMG on frame F so that it looks disabled. */
4934 x_disable_image (f
, img
)
4938 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
4940 int n_planes
= dpyinfo
->n_planes
* dpyinfo
->n_cbits
;
4942 int n_planes
= dpyinfo
->n_planes
;
4943 #endif /* HAVE_NTGUI */
4947 /* Color (or grayscale). Convert to gray, and equalize. Just
4948 drawing such images with a stipple can look very odd, so
4949 we're using this method instead. */
4950 XColor
*colors
= x_to_xcolors (f
, img
, 1);
4952 const int h
= 15000;
4953 const int l
= 30000;
4955 for (p
= colors
, end
= colors
+ img
->width
* img
->height
;
4959 int i
= COLOR_INTENSITY (p
->red
, p
->green
, p
->blue
);
4960 int i2
= (0xffff - h
- l
) * i
/ 0xffff + l
;
4961 p
->red
= p
->green
= p
->blue
= i2
;
4964 x_from_xcolors (f
, img
, colors
);
4967 /* Draw a cross over the disabled image, if we must or if we
4969 if (n_planes
< 2 || cross_disabled_images
)
4972 Display
*dpy
= FRAME_X_DISPLAY (f
);
4976 #define XCreateGC_pixmap(dpy, pixmap) XCreateGC (dpy, NULL, 0, NULL)
4977 #define MaskForeground(f) PIX_MASK_DRAW (f)
4979 #define XCreateGC_pixmap(dpy, pixmap) XCreateGC (dpy, pixmap, 0, NULL)
4980 #define MaskForeground(f) WHITE_PIX_DEFAULT (f)
4983 gc
= XCreateGC_pixmap (dpy
, img
->pixmap
);
4984 XSetForeground (dpy
, gc
, BLACK_PIX_DEFAULT (f
));
4985 XDrawLine (dpy
, img
->pixmap
, gc
, 0, 0,
4986 img
->width
- 1, img
->height
- 1);
4987 XDrawLine (dpy
, img
->pixmap
, gc
, 0, img
->height
- 1,
4993 gc
= XCreateGC_pixmap (dpy
, img
->mask
);
4994 XSetForeground (dpy
, gc
, MaskForeground (f
));
4995 XDrawLine (dpy
, img
->mask
, gc
, 0, 0,
4996 img
->width
- 1, img
->height
- 1);
4997 XDrawLine (dpy
, img
->mask
, gc
, 0, img
->height
- 1,
5005 hdc
= get_frame_dc (f
);
5006 bmpdc
= CreateCompatibleDC (hdc
);
5007 release_frame_dc (f
, hdc
);
5009 prev
= SelectObject (bmpdc
, img
->pixmap
);
5011 SetTextColor (bmpdc
, BLACK_PIX_DEFAULT (f
));
5012 MoveToEx (bmpdc
, 0, 0, NULL
);
5013 LineTo (bmpdc
, img
->width
- 1, img
->height
- 1);
5014 MoveToEx (bmpdc
, 0, img
->height
- 1, NULL
);
5015 LineTo (bmpdc
, img
->width
- 1, 0);
5019 SelectObject (bmpdc
, img
->mask
);
5020 SetTextColor (bmpdc
, WHITE_PIX_DEFAULT (f
));
5021 MoveToEx (bmpdc
, 0, 0, NULL
);
5022 LineTo (bmpdc
, img
->width
- 1, img
->height
- 1);
5023 MoveToEx (bmpdc
, 0, img
->height
- 1, NULL
);
5024 LineTo (bmpdc
, img
->width
- 1, 0);
5026 SelectObject (bmpdc
, prev
);
5028 #endif /* HAVE_NTGUI */
5033 /* Build a mask for image IMG which is used on frame F. FILE is the
5034 name of an image file, for error messages. HOW determines how to
5035 determine the background color of IMG. If it is a list '(R G B)',
5036 with R, G, and B being integers >= 0, take that as the color of the
5037 background. Otherwise, determine the background color of IMG
5038 heuristically. Value is non-zero if successful. */
5041 x_build_heuristic_mask (f
, img
, how
)
5046 XImagePtr_or_DC ximg
;
5054 #endif /* HAVE_NTGUI */
5055 int x
, y
, rc
, use_img_background
;
5056 unsigned long bg
= 0;
5060 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
5061 img
->mask
= NO_PIXMAP
;
5062 img
->background_transparent_valid
= 0;
5066 /* Create an image and pixmap serving as mask. */
5067 rc
= x_create_x_image_and_pixmap (f
, img
->width
, img
->height
, 1,
5068 &mask_img
, &img
->mask
);
5072 /* Get the X image of IMG->pixmap. */
5073 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
, 0, 0,
5074 img
->width
, img
->height
,
5077 /* Create the bit array serving as mask. */
5078 row_width
= (img
->width
+ 7) / 8;
5079 mask_img
= xmalloc (row_width
* img
->height
);
5080 bzero (mask_img
, row_width
* img
->height
);
5082 /* Create a memory device context for IMG->pixmap. */
5083 frame_dc
= get_frame_dc (f
);
5084 ximg
= CreateCompatibleDC (frame_dc
);
5085 release_frame_dc (f
, frame_dc
);
5086 prev
= SelectObject (ximg
, img
->pixmap
);
5087 #endif /* HAVE_NTGUI */
5089 /* Determine the background color of ximg. If HOW is `(R G B)'
5090 take that as color. Otherwise, use the image's background color. */
5091 use_img_background
= 1;
5097 for (i
= 0; i
< 3 && CONSP (how
) && NATNUMP (XCAR (how
)); ++i
)
5099 rgb
[i
] = XFASTINT (XCAR (how
)) & 0xffff;
5103 if (i
== 3 && NILP (how
))
5105 char color_name
[30];
5106 sprintf (color_name
, "#%04x%04x%04x", rgb
[0], rgb
[1], rgb
[2]);
5109 0x00ffffff & /* Filter out palette info. */
5110 #endif /* HAVE_NTGUI */
5111 x_alloc_image_color (f
, img
, build_string (color_name
), 0));
5112 use_img_background
= 0;
5116 if (use_img_background
)
5117 bg
= four_corners_best (ximg
, img
->width
, img
->height
);
5119 /* Set all bits in mask_img to 1 whose color in ximg is different
5120 from the background color bg. */
5122 for (y
= 0; y
< img
->height
; ++y
)
5123 for (x
= 0; x
< img
->width
; ++x
)
5124 XPutPixel (mask_img
, x
, y
, (XGetPixel (ximg
, x
, y
) != bg
5125 ? PIX_MASK_DRAW (f
) : PIX_MASK_RETAIN (f
)));
5127 /* Fill in the background_transparent field while we have the mask handy. */
5128 image_background_transparent (img
, f
, mask_img
);
5130 /* Put mask_img into img->mask. */
5131 x_put_x_image (f
, mask_img
, img
->mask
, img
->width
, img
->height
);
5132 x_destroy_x_image (mask_img
);
5135 for (y
= 0; y
< img
->height
; ++y
)
5136 for (x
= 0; x
< img
->width
; ++x
)
5138 COLORREF p
= GetPixel (ximg
, x
, y
);
5140 mask_img
[y
* row_width
+ x
/ 8] |= 1 << (x
% 8);
5143 /* Create the mask image. */
5144 img
->mask
= w32_create_pixmap_from_bitmap_data (img
->width
, img
->height
,
5146 /* Fill in the background_transparent field while we have the mask handy. */
5147 SelectObject (ximg
, img
->mask
);
5148 image_background_transparent (img
, f
, ximg
);
5150 /* Was: x_destroy_x_image ((XImagePtr )mask_img); which seems bogus ++kfs */
5152 #endif /* HAVE_NTGUI */
5154 Destroy_Image (ximg
, prev
);
5160 /***********************************************************************
5161 PBM (mono, gray, color)
5162 ***********************************************************************/
5164 static int pbm_image_p
P_ ((Lisp_Object object
));
5165 static int pbm_load
P_ ((struct frame
*f
, struct image
*img
));
5166 static int pbm_scan_number
P_ ((unsigned char **, unsigned char *));
5168 /* The symbol `pbm' identifying images of this type. */
5172 /* Indices of image specification fields in gs_format, below. */
5174 enum pbm_keyword_index
5190 /* Vector of image_keyword structures describing the format
5191 of valid user-defined image specifications. */
5193 static struct image_keyword pbm_format
[PBM_LAST
] =
5195 {":type", IMAGE_SYMBOL_VALUE
, 1},
5196 {":file", IMAGE_STRING_VALUE
, 0},
5197 {":data", IMAGE_STRING_VALUE
, 0},
5198 {":ascent", IMAGE_ASCENT_VALUE
, 0},
5199 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
5200 {":relief", IMAGE_INTEGER_VALUE
, 0},
5201 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5202 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5203 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5204 {":foreground", IMAGE_STRING_OR_NIL_VALUE
, 0},
5205 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
5208 /* Structure describing the image type `pbm'. */
5210 static struct image_type pbm_type
=
5220 /* Return non-zero if OBJECT is a valid PBM image specification. */
5223 pbm_image_p (object
)
5226 struct image_keyword fmt
[PBM_LAST
];
5228 bcopy (pbm_format
, fmt
, sizeof fmt
);
5230 if (!parse_image_spec (object
, fmt
, PBM_LAST
, Qpbm
))
5233 /* Must specify either :data or :file. */
5234 return fmt
[PBM_DATA
].count
+ fmt
[PBM_FILE
].count
== 1;
5238 /* Scan a decimal number from *S and return it. Advance *S while
5239 reading the number. END is the end of the string. Value is -1 at
5243 pbm_scan_number (s
, end
)
5244 unsigned char **s
, *end
;
5246 int c
= 0, val
= -1;
5250 /* Skip white-space. */
5251 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
5256 /* Skip comment to end of line. */
5257 while (*s
< end
&& (c
= *(*s
)++, c
!= '\n'))
5260 else if (isdigit (c
))
5262 /* Read decimal number. */
5264 while (*s
< end
&& (c
= *(*s
)++, isdigit (c
)))
5265 val
= 10 * val
+ c
- '0';
5277 #if 0 /* Unused. ++kfs */
5279 /* Read FILE into memory. Value is a pointer to a buffer allocated
5280 with xmalloc holding FILE's contents. Value is null if an error
5281 occurred. *SIZE is set to the size of the file. */
5284 pbm_read_file (file
, size
)
5292 if (stat (SDATA (file
), &st
) == 0
5293 && (fp
= fopen (SDATA (file
), "rb")) != NULL
5294 && (buf
= (char *) xmalloc (st
.st_size
),
5295 fread (buf
, 1, st
.st_size
, fp
) == st
.st_size
))
5314 #endif /* HAVE_NTGUI */
5316 /* Load PBM image IMG for use on frame F. */
5324 int width
, height
, max_color_idx
= 0;
5326 Lisp_Object file
, specified_file
;
5327 enum {PBM_MONO
, PBM_GRAY
, PBM_COLOR
} type
;
5328 struct gcpro gcpro1
;
5329 unsigned char *contents
= NULL
;
5330 unsigned char *end
, *p
;
5333 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
5337 if (STRINGP (specified_file
))
5339 file
= x_find_image_file (specified_file
);
5340 if (!STRINGP (file
))
5342 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
5347 contents
= slurp_file (SDATA (file
), &size
);
5348 if (contents
== NULL
)
5350 image_error ("Error reading `%s'", file
, Qnil
);
5356 end
= contents
+ size
;
5361 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
5363 end
= p
+ SBYTES (data
);
5366 /* Check magic number. */
5367 if (end
- p
< 2 || *p
++ != 'P')
5369 image_error ("Not a PBM image: `%s'", img
->spec
, Qnil
);
5379 raw_p
= 0, type
= PBM_MONO
;
5383 raw_p
= 0, type
= PBM_GRAY
;
5387 raw_p
= 0, type
= PBM_COLOR
;
5391 raw_p
= 1, type
= PBM_MONO
;
5395 raw_p
= 1, type
= PBM_GRAY
;
5399 raw_p
= 1, type
= PBM_COLOR
;
5403 image_error ("Not a PBM image: `%s'", img
->spec
, Qnil
);
5407 /* Read width, height, maximum color-component. Characters
5408 starting with `#' up to the end of a line are ignored. */
5409 width
= pbm_scan_number (&p
, end
);
5410 height
= pbm_scan_number (&p
, end
);
5412 if (type
!= PBM_MONO
)
5414 max_color_idx
= pbm_scan_number (&p
, end
);
5415 if (raw_p
&& max_color_idx
> 255)
5416 max_color_idx
= 255;
5421 || (type
!= PBM_MONO
&& max_color_idx
< 0))
5424 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0,
5425 &ximg
, &img
->pixmap
))
5428 /* Initialize the color hash table. */
5429 init_color_table ();
5431 if (type
== PBM_MONO
)
5434 struct image_keyword fmt
[PBM_LAST
];
5435 unsigned long fg
= FRAME_FOREGROUND_PIXEL (f
);
5436 unsigned long bg
= FRAME_BACKGROUND_PIXEL (f
);
5438 /* Parse the image specification. */
5439 bcopy (pbm_format
, fmt
, sizeof fmt
);
5440 parse_image_spec (img
->spec
, fmt
, PBM_LAST
, Qpbm
);
5442 /* Get foreground and background colors, maybe allocate colors. */
5443 if (fmt
[PBM_FOREGROUND
].count
5444 && STRINGP (fmt
[PBM_FOREGROUND
].value
))
5445 fg
= x_alloc_image_color (f
, img
, fmt
[PBM_FOREGROUND
].value
, fg
);
5446 if (fmt
[PBM_BACKGROUND
].count
5447 && STRINGP (fmt
[PBM_BACKGROUND
].value
))
5449 bg
= x_alloc_image_color (f
, img
, fmt
[PBM_BACKGROUND
].value
, bg
);
5450 img
->background
= bg
;
5451 img
->background_valid
= 1;
5454 for (y
= 0; y
< height
; ++y
)
5455 for (x
= 0; x
< width
; ++x
)
5465 g
= pbm_scan_number (&p
, end
);
5467 XPutPixel (ximg
, x
, y
, g
? fg
: bg
);
5472 for (y
= 0; y
< height
; ++y
)
5473 for (x
= 0; x
< width
; ++x
)
5477 if (type
== PBM_GRAY
)
5478 r
= g
= b
= raw_p
? *p
++ : pbm_scan_number (&p
, end
);
5487 r
= pbm_scan_number (&p
, end
);
5488 g
= pbm_scan_number (&p
, end
);
5489 b
= pbm_scan_number (&p
, end
);
5492 if (r
< 0 || g
< 0 || b
< 0)
5494 x_destroy_x_image (ximg
);
5495 image_error ("Invalid pixel value in image `%s'",
5500 /* RGB values are now in the range 0..max_color_idx.
5501 Scale this to the range 0..0xffff supported by X. */
5502 r
= (double) r
* 65535 / max_color_idx
;
5503 g
= (double) g
* 65535 / max_color_idx
;
5504 b
= (double) b
* 65535 / max_color_idx
;
5505 XPutPixel (ximg
, x
, y
, lookup_rgb_color (f
, r
, g
, b
));
5509 #ifdef COLOR_TABLE_SUPPORT
5510 /* Store in IMG->colors the colors allocated for the image, and
5511 free the color table. */
5512 img
->colors
= colors_in_color_table (&img
->ncolors
);
5513 free_color_table ();
5514 #endif /* COLOR_TABLE_SUPPORT */
5517 img
->height
= height
;
5519 /* Maybe fill in the background field while we have ximg handy. */
5521 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
5522 IMAGE_BACKGROUND (img
, f
, 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 /* Work around a problem with MinGW builds of graphics libraries
5750 not honoring calling conventions. */
5751 #pragma optimize("g", off)
5755 png_read_from_memory (png_ptr
, data
, length
)
5756 png_structp png_ptr
;
5760 struct png_memory_storage
*tbr
5761 = (struct png_memory_storage
*) fn_png_get_io_ptr (png_ptr
);
5763 if (length
> tbr
->len
- tbr
->index
)
5764 fn_png_error (png_ptr
, "Read error");
5766 bcopy (tbr
->bytes
+ tbr
->index
, data
, length
);
5767 tbr
->index
= tbr
->index
+ length
;
5771 /* Restore normal optimization, as specified on the command line. */
5772 #pragma optimize("", on)
5775 /* Load PNG image IMG for use on frame F. Value is non-zero if
5783 Lisp_Object file
, specified_file
;
5784 Lisp_Object specified_data
;
5786 XImagePtr ximg
, mask_img
= NULL
;
5787 struct gcpro gcpro1
;
5788 png_struct
*png_ptr
= NULL
;
5789 png_info
*info_ptr
= NULL
, *end_info
= NULL
;
5790 FILE *volatile fp
= NULL
;
5792 png_byte
* volatile pixels
= NULL
;
5793 png_byte
** volatile rows
= NULL
;
5794 png_uint_32 width
, height
;
5795 int bit_depth
, color_type
, interlace_type
;
5797 png_uint_32 row_bytes
;
5799 double screen_gamma
;
5800 struct png_memory_storage tbr
; /* Data to be read */
5802 /* Find out what file to load. */
5803 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
5804 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
5808 if (NILP (specified_data
))
5810 file
= x_find_image_file (specified_file
);
5811 if (!STRINGP (file
))
5813 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
5818 /* Open the image file. */
5819 fp
= fopen (SDATA (file
), "rb");
5822 image_error ("Cannot open image file `%s'", file
, Qnil
);
5828 /* Check PNG signature. */
5829 if (fread (sig
, 1, sizeof sig
, fp
) != sizeof sig
5830 || !fn_png_check_sig (sig
, sizeof sig
))
5832 image_error ("Not a PNG file: `%s'", file
, Qnil
);
5840 /* Read from memory. */
5841 tbr
.bytes
= SDATA (specified_data
);
5842 tbr
.len
= SBYTES (specified_data
);
5845 /* Check PNG signature. */
5846 if (tbr
.len
< sizeof sig
5847 || !fn_png_check_sig (tbr
.bytes
, sizeof sig
))
5849 image_error ("Not a PNG image: `%s'", img
->spec
, Qnil
);
5854 /* Need to skip past the signature. */
5855 tbr
.bytes
+= sizeof (sig
);
5858 /* Initialize read and info structs for PNG lib. */
5859 png_ptr
= fn_png_create_read_struct (PNG_LIBPNG_VER_STRING
, NULL
,
5860 my_png_error
, my_png_warning
);
5863 if (fp
) fclose (fp
);
5868 info_ptr
= fn_png_create_info_struct (png_ptr
);
5871 fn_png_destroy_read_struct (&png_ptr
, NULL
, NULL
);
5872 if (fp
) fclose (fp
);
5877 end_info
= fn_png_create_info_struct (png_ptr
);
5880 fn_png_destroy_read_struct (&png_ptr
, &info_ptr
, NULL
);
5881 if (fp
) fclose (fp
);
5886 /* Set error jump-back. We come back here when the PNG library
5887 detects an error. */
5888 if (setjmp (png_ptr
->jmpbuf
))
5892 fn_png_destroy_read_struct (&png_ptr
, &info_ptr
, &end_info
);
5895 if (fp
) fclose (fp
);
5900 /* Read image info. */
5901 if (!NILP (specified_data
))
5902 fn_png_set_read_fn (png_ptr
, (void *) &tbr
, png_read_from_memory
);
5904 fn_png_init_io (png_ptr
, fp
);
5906 fn_png_set_sig_bytes (png_ptr
, sizeof sig
);
5907 fn_png_read_info (png_ptr
, info_ptr
);
5908 fn_png_get_IHDR (png_ptr
, info_ptr
, &width
, &height
, &bit_depth
, &color_type
,
5909 &interlace_type
, NULL
, NULL
);
5911 /* If image contains simply transparency data, we prefer to
5912 construct a clipping mask. */
5913 if (fn_png_get_valid (png_ptr
, info_ptr
, PNG_INFO_tRNS
))
5918 /* This function is easier to write if we only have to handle
5919 one data format: RGB or RGBA with 8 bits per channel. Let's
5920 transform other formats into that format. */
5922 /* Strip more than 8 bits per channel. */
5923 if (bit_depth
== 16)
5924 fn_png_set_strip_16 (png_ptr
);
5926 /* Expand data to 24 bit RGB, or 8 bit grayscale, with alpha channel
5928 fn_png_set_expand (png_ptr
);
5930 /* Convert grayscale images to RGB. */
5931 if (color_type
== PNG_COLOR_TYPE_GRAY
5932 || color_type
== PNG_COLOR_TYPE_GRAY_ALPHA
)
5933 fn_png_set_gray_to_rgb (png_ptr
);
5935 screen_gamma
= (f
->gamma
? 1 / f
->gamma
/ 0.45455 : 2.2);
5937 #if 0 /* Avoid double gamma correction for PNG images. */
5938 { /* Tell the PNG lib to handle gamma correction for us. */
5941 #if defined(PNG_READ_sRGB_SUPPORTED) || defined(PNG_WRITE_sRGB_SUPPORTED)
5942 if (png_get_sRGB (png_ptr
, info_ptr
, &intent
))
5943 /* The libpng documentation says this is right in this case. */
5944 png_set_gamma (png_ptr
, screen_gamma
, 0.45455);
5947 if (png_get_gAMA (png_ptr
, info_ptr
, &image_gamma
))
5948 /* Image contains gamma information. */
5949 png_set_gamma (png_ptr
, screen_gamma
, image_gamma
);
5951 /* Use the standard default for the image gamma. */
5952 png_set_gamma (png_ptr
, screen_gamma
, 0.45455);
5956 /* Handle alpha channel by combining the image with a background
5957 color. Do this only if a real alpha channel is supplied. For
5958 simple transparency, we prefer a clipping mask. */
5961 png_color_16
*image_bg
;
5962 Lisp_Object specified_bg
5963 = image_spec_value (img
->spec
, QCbackground
, NULL
);
5965 if (STRINGP (specified_bg
))
5966 /* The user specified `:background', use that. */
5968 /* W32 version incorrectly used COLORREF here!! ++kfs */
5970 if (x_defined_color (f
, SDATA (specified_bg
), &color
, 0))
5972 png_color_16 user_bg
;
5974 bzero (&user_bg
, sizeof user_bg
);
5975 user_bg
.red
= color
.red
>> 8;
5976 user_bg
.green
= color
.green
>> 8;
5977 user_bg
.blue
= color
.blue
>> 8;
5979 fn_png_set_background (png_ptr
, &user_bg
,
5980 PNG_BACKGROUND_GAMMA_SCREEN
, 0, 1.0);
5983 else if (fn_png_get_bKGD (png_ptr
, info_ptr
, &image_bg
))
5984 /* Image contains a background color with which to
5985 combine the image. */
5986 fn_png_set_background (png_ptr
, image_bg
,
5987 PNG_BACKGROUND_GAMMA_FILE
, 1, 1.0);
5990 /* Image does not contain a background color with which
5991 to combine the image data via an alpha channel. Use
5992 the frame's background instead. */
5993 #ifdef HAVE_X_WINDOWS
5995 png_color_16 frame_background
;
5997 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
5998 x_query_color (f
, &color
);
6000 bzero (&frame_background
, sizeof frame_background
);
6001 frame_background
.red
= color
.red
>> 8;
6002 frame_background
.green
= color
.green
>> 8;
6003 frame_background
.blue
= color
.blue
>> 8;
6004 #endif /* HAVE_X_WINDOWS */
6008 png_color_16 frame_background
;
6009 color
= FRAME_BACKGROUND_PIXEL (f
);
6010 #if 0 /* W32 TODO : Colormap support. */
6011 x_query_color (f
, &color
);
6013 bzero (&frame_background
, sizeof frame_background
);
6014 frame_background
.red
= GetRValue (color
);
6015 frame_background
.green
= GetGValue (color
);
6016 frame_background
.blue
= GetBValue (color
);
6017 #endif /* HAVE_NTGUI */
6020 unsigned long color
;
6021 png_color_16 frame_background
;
6022 color
= FRAME_BACKGROUND_PIXEL (f
);
6023 #if 0 /* MAC/W32 TODO : Colormap support. */
6024 x_query_color (f
, &color
);
6026 bzero (&frame_background
, sizeof frame_background
);
6027 frame_background
.red
= RED_FROM_ULONG (color
);
6028 frame_background
.green
= GREEN_FROM_ULONG (color
);
6029 frame_background
.blue
= BLUE_FROM_ULONG (color
);
6032 fn_png_set_background (png_ptr
, &frame_background
,
6033 PNG_BACKGROUND_GAMMA_SCREEN
, 0, 1.0);
6037 /* Update info structure. */
6038 fn_png_read_update_info (png_ptr
, info_ptr
);
6040 /* Get number of channels. Valid values are 1 for grayscale images
6041 and images with a palette, 2 for grayscale images with transparency
6042 information (alpha channel), 3 for RGB images, and 4 for RGB
6043 images with alpha channel, i.e. RGBA. If conversions above were
6044 sufficient we should only have 3 or 4 channels here. */
6045 channels
= fn_png_get_channels (png_ptr
, info_ptr
);
6046 xassert (channels
== 3 || channels
== 4);
6048 /* Number of bytes needed for one row of the image. */
6049 row_bytes
= fn_png_get_rowbytes (png_ptr
, info_ptr
);
6051 /* Allocate memory for the image. */
6052 pixels
= (png_byte
*) xmalloc (row_bytes
* height
* sizeof *pixels
);
6053 rows
= (png_byte
**) xmalloc (height
* sizeof *rows
);
6054 for (i
= 0; i
< height
; ++i
)
6055 rows
[i
] = pixels
+ i
* row_bytes
;
6057 /* Read the entire image. */
6058 fn_png_read_image (png_ptr
, rows
);
6059 fn_png_read_end (png_ptr
, info_ptr
);
6066 /* Create the X image and pixmap. */
6067 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
,
6071 /* Create an image and pixmap serving as mask if the PNG image
6072 contains an alpha channel. */
6075 && !x_create_x_image_and_pixmap (f
, width
, height
, 1,
6076 &mask_img
, &img
->mask
))
6078 x_destroy_x_image (ximg
);
6079 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->pixmap
);
6080 img
->pixmap
= NO_PIXMAP
;
6084 /* Fill the X image and mask from PNG data. */
6085 init_color_table ();
6087 for (y
= 0; y
< height
; ++y
)
6089 png_byte
*p
= rows
[y
];
6091 for (x
= 0; x
< width
; ++x
)
6098 XPutPixel (ximg
, x
, y
, lookup_rgb_color (f
, r
, g
, b
));
6099 /* An alpha channel, aka mask channel, associates variable
6100 transparency with an image. Where other image formats
6101 support binary transparency---fully transparent or fully
6102 opaque---PNG allows up to 254 levels of partial transparency.
6103 The PNG library implements partial transparency by combining
6104 the image with a specified background color.
6106 I'm not sure how to handle this here nicely: because the
6107 background on which the image is displayed may change, for
6108 real alpha channel support, it would be necessary to create
6109 a new image for each possible background.
6111 What I'm doing now is that a mask is created if we have
6112 boolean transparency information. Otherwise I'm using
6113 the frame's background color to combine the image with. */
6118 XPutPixel (mask_img
, x
, y
, *p
> 0 ? PIX_MASK_DRAW (f
) : PIX_MASK_RETAIN (f
));
6124 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
6125 /* Set IMG's background color from the PNG image, unless the user
6129 if (fn_png_get_bKGD (png_ptr
, info_ptr
, &bg
))
6131 img
->background
= lookup_rgb_color (f
, bg
->red
, bg
->green
, bg
->blue
);
6132 img
->background_valid
= 1;
6136 #ifdef COLOR_TABLE_SUPPORT
6137 /* Remember colors allocated for this image. */
6138 img
->colors
= colors_in_color_table (&img
->ncolors
);
6139 free_color_table ();
6140 #endif /* COLOR_TABLE_SUPPORT */
6143 fn_png_destroy_read_struct (&png_ptr
, &info_ptr
, &end_info
);
6148 img
->height
= height
;
6150 /* Maybe fill in the background field while we have ximg handy. */
6151 IMAGE_BACKGROUND (img
, f
, ximg
);
6153 /* Put the image into the pixmap, then free the X image and its buffer. */
6154 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
6155 x_destroy_x_image (ximg
);
6157 /* Same for the mask. */
6160 /* Fill in the background_transparent field while we have the mask
6162 image_background_transparent (img
, f
, mask_img
);
6164 x_put_x_image (f
, mask_img
, img
->mask
, img
->width
, img
->height
);
6165 x_destroy_x_image (mask_img
);
6172 #else /* HAVE_PNG */
6181 if (MyCGImageCreateWithPNGDataProvider
)
6182 return image_load_quartz2d (f
, img
, 1);
6185 return image_load_quicktime (f
, img
, kQTFileTypePNG
);
6189 #endif /* !HAVE_PNG */
6193 /***********************************************************************
6195 ***********************************************************************/
6197 #if defined (HAVE_JPEG) || defined (MAC_OS)
6199 static int jpeg_image_p
P_ ((Lisp_Object object
));
6200 static int jpeg_load
P_ ((struct frame
*f
, struct image
*img
));
6202 /* The symbol `jpeg' identifying images of this type. */
6206 /* Indices of image specification fields in gs_format, below. */
6208 enum jpeg_keyword_index
6217 JPEG_HEURISTIC_MASK
,
6223 /* Vector of image_keyword structures describing the format
6224 of valid user-defined image specifications. */
6226 static struct image_keyword jpeg_format
[JPEG_LAST
] =
6228 {":type", IMAGE_SYMBOL_VALUE
, 1},
6229 {":data", IMAGE_STRING_VALUE
, 0},
6230 {":file", IMAGE_STRING_VALUE
, 0},
6231 {":ascent", IMAGE_ASCENT_VALUE
, 0},
6232 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
6233 {":relief", IMAGE_INTEGER_VALUE
, 0},
6234 {":conversions", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6235 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6236 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6237 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
6240 /* Structure describing the image type `jpeg'. */
6242 static struct image_type jpeg_type
=
6251 /* Return non-zero if OBJECT is a valid JPEG image specification. */
6254 jpeg_image_p (object
)
6257 struct image_keyword fmt
[JPEG_LAST
];
6259 bcopy (jpeg_format
, fmt
, sizeof fmt
);
6261 if (!parse_image_spec (object
, fmt
, JPEG_LAST
, Qjpeg
))
6264 /* Must specify either the :data or :file keyword. */
6265 return fmt
[JPEG_FILE
].count
+ fmt
[JPEG_DATA
].count
== 1;
6268 #endif /* HAVE_JPEG || MAC_OS */
6272 /* Work around a warning about HAVE_STDLIB_H being redefined in
6274 #ifdef HAVE_STDLIB_H
6275 #define HAVE_STDLIB_H_1
6276 #undef HAVE_STDLIB_H
6277 #endif /* HAVE_STLIB_H */
6279 #if defined (HAVE_NTGUI) && !defined (__WIN32__)
6280 /* jpeglib.h will define boolean differently depending on __WIN32__,
6281 so make sure it is defined. */
6285 #include <jpeglib.h>
6289 #ifdef HAVE_STLIB_H_1
6290 #define HAVE_STDLIB_H 1
6295 /* JPEG library details. */
6296 DEF_IMGLIB_FN (jpeg_CreateDecompress
);
6297 DEF_IMGLIB_FN (jpeg_start_decompress
);
6298 DEF_IMGLIB_FN (jpeg_finish_decompress
);
6299 DEF_IMGLIB_FN (jpeg_destroy_decompress
);
6300 DEF_IMGLIB_FN (jpeg_read_header
);
6301 DEF_IMGLIB_FN (jpeg_read_scanlines
);
6302 DEF_IMGLIB_FN (jpeg_stdio_src
);
6303 DEF_IMGLIB_FN (jpeg_std_error
);
6304 DEF_IMGLIB_FN (jpeg_resync_to_restart
);
6307 init_jpeg_functions (Lisp_Object libraries
)
6311 if (!(library
= w32_delayed_load (libraries
, Qjpeg
)))
6314 LOAD_IMGLIB_FN (library
, jpeg_finish_decompress
);
6315 LOAD_IMGLIB_FN (library
, jpeg_read_scanlines
);
6316 LOAD_IMGLIB_FN (library
, jpeg_start_decompress
);
6317 LOAD_IMGLIB_FN (library
, jpeg_read_header
);
6318 LOAD_IMGLIB_FN (library
, jpeg_stdio_src
);
6319 LOAD_IMGLIB_FN (library
, jpeg_CreateDecompress
);
6320 LOAD_IMGLIB_FN (library
, jpeg_destroy_decompress
);
6321 LOAD_IMGLIB_FN (library
, jpeg_std_error
);
6322 LOAD_IMGLIB_FN (library
, jpeg_resync_to_restart
);
6326 /* Wrapper since we can't directly assign the function pointer
6327 to another function pointer that was declared more completely easily. */
6329 jpeg_resync_to_restart_wrapper(cinfo
, desired
)
6330 j_decompress_ptr cinfo
;
6333 return fn_jpeg_resync_to_restart (cinfo
, desired
);
6338 #define fn_jpeg_CreateDecompress(a,b,c) jpeg_create_decompress(a)
6339 #define fn_jpeg_start_decompress jpeg_start_decompress
6340 #define fn_jpeg_finish_decompress jpeg_finish_decompress
6341 #define fn_jpeg_destroy_decompress jpeg_destroy_decompress
6342 #define fn_jpeg_read_header jpeg_read_header
6343 #define fn_jpeg_read_scanlines jpeg_read_scanlines
6344 #define fn_jpeg_stdio_src jpeg_stdio_src
6345 #define fn_jpeg_std_error jpeg_std_error
6346 #define jpeg_resync_to_restart_wrapper jpeg_resync_to_restart
6348 #endif /* HAVE_NTGUI */
6350 struct my_jpeg_error_mgr
6352 struct jpeg_error_mgr pub
;
6353 jmp_buf setjmp_buffer
;
6358 my_error_exit (cinfo
)
6361 struct my_jpeg_error_mgr
*mgr
= (struct my_jpeg_error_mgr
*) cinfo
->err
;
6362 longjmp (mgr
->setjmp_buffer
, 1);
6366 /* Init source method for JPEG data source manager. Called by
6367 jpeg_read_header() before any data is actually read. See
6368 libjpeg.doc from the JPEG lib distribution. */
6371 our_init_source (cinfo
)
6372 j_decompress_ptr cinfo
;
6377 /* Fill input buffer method for JPEG data source manager. Called
6378 whenever more data is needed. We read the whole image in one step,
6379 so this only adds a fake end of input marker at the end. */
6382 our_fill_input_buffer (cinfo
)
6383 j_decompress_ptr cinfo
;
6385 /* Insert a fake EOI marker. */
6386 struct jpeg_source_mgr
*src
= cinfo
->src
;
6387 static JOCTET buffer
[2];
6389 buffer
[0] = (JOCTET
) 0xFF;
6390 buffer
[1] = (JOCTET
) JPEG_EOI
;
6392 src
->next_input_byte
= buffer
;
6393 src
->bytes_in_buffer
= 2;
6398 /* Method to skip over NUM_BYTES bytes in the image data. CINFO->src
6399 is the JPEG data source manager. */
6402 our_skip_input_data (cinfo
, num_bytes
)
6403 j_decompress_ptr cinfo
;
6406 struct jpeg_source_mgr
*src
= (struct jpeg_source_mgr
*) cinfo
->src
;
6410 if (num_bytes
> src
->bytes_in_buffer
)
6411 ERREXIT (cinfo
, JERR_INPUT_EOF
);
6413 src
->bytes_in_buffer
-= num_bytes
;
6414 src
->next_input_byte
+= num_bytes
;
6419 /* Method to terminate data source. Called by
6420 jpeg_finish_decompress() after all data has been processed. */
6423 our_term_source (cinfo
)
6424 j_decompress_ptr cinfo
;
6429 /* Set up the JPEG lib for reading an image from DATA which contains
6430 LEN bytes. CINFO is the decompression info structure created for
6431 reading the image. */
6434 jpeg_memory_src (cinfo
, data
, len
)
6435 j_decompress_ptr cinfo
;
6439 struct jpeg_source_mgr
*src
;
6441 if (cinfo
->src
== NULL
)
6443 /* First time for this JPEG object? */
6444 cinfo
->src
= (struct jpeg_source_mgr
*)
6445 (*cinfo
->mem
->alloc_small
) ((j_common_ptr
) cinfo
, JPOOL_PERMANENT
,
6446 sizeof (struct jpeg_source_mgr
));
6447 src
= (struct jpeg_source_mgr
*) cinfo
->src
;
6448 src
->next_input_byte
= data
;
6451 src
= (struct jpeg_source_mgr
*) cinfo
->src
;
6452 src
->init_source
= our_init_source
;
6453 src
->fill_input_buffer
= our_fill_input_buffer
;
6454 src
->skip_input_data
= our_skip_input_data
;
6455 src
->resync_to_restart
= jpeg_resync_to_restart_wrapper
; /* Use default method. */
6456 src
->term_source
= our_term_source
;
6457 src
->bytes_in_buffer
= len
;
6458 src
->next_input_byte
= data
;
6462 /* Load image IMG for use on frame F. Patterned after example.c
6463 from the JPEG lib. */
6470 struct jpeg_decompress_struct cinfo
;
6471 struct my_jpeg_error_mgr mgr
;
6472 Lisp_Object file
, specified_file
;
6473 Lisp_Object specified_data
;
6474 FILE * volatile fp
= NULL
;
6476 int row_stride
, x
, y
;
6477 XImagePtr ximg
= NULL
;
6479 unsigned long *colors
;
6481 struct gcpro gcpro1
;
6483 /* Open the JPEG file. */
6484 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
6485 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
6489 if (NILP (specified_data
))
6491 file
= x_find_image_file (specified_file
);
6492 if (!STRINGP (file
))
6494 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
6499 fp
= fopen (SDATA (file
), "rb");
6502 image_error ("Cannot open `%s'", file
, Qnil
);
6508 /* Customize libjpeg's error handling to call my_error_exit when an
6509 error is detected. This function will perform a longjmp. */
6510 cinfo
.err
= fn_jpeg_std_error (&mgr
.pub
);
6511 mgr
.pub
.error_exit
= my_error_exit
;
6513 if ((rc
= setjmp (mgr
.setjmp_buffer
)) != 0)
6517 /* Called from my_error_exit. Display a JPEG error. */
6518 char buffer
[JMSG_LENGTH_MAX
];
6519 cinfo
.err
->format_message ((j_common_ptr
) &cinfo
, buffer
);
6520 image_error ("Error reading JPEG image `%s': %s", img
->spec
,
6521 build_string (buffer
));
6524 /* Close the input file and destroy the JPEG object. */
6526 fclose ((FILE *) fp
);
6527 fn_jpeg_destroy_decompress (&cinfo
);
6529 /* If we already have an XImage, free that. */
6530 x_destroy_x_image (ximg
);
6532 /* Free pixmap and colors. */
6533 x_clear_image (f
, img
);
6539 /* Create the JPEG decompression object. Let it read from fp.
6540 Read the JPEG image header. */
6541 fn_jpeg_CreateDecompress (&cinfo
, JPEG_LIB_VERSION
, sizeof (cinfo
));
6543 if (NILP (specified_data
))
6544 fn_jpeg_stdio_src (&cinfo
, (FILE *) fp
);
6546 jpeg_memory_src (&cinfo
, SDATA (specified_data
),
6547 SBYTES (specified_data
));
6549 fn_jpeg_read_header (&cinfo
, 1);
6551 /* Customize decompression so that color quantization will be used.
6552 Start decompression. */
6553 cinfo
.quantize_colors
= 1;
6554 fn_jpeg_start_decompress (&cinfo
);
6555 width
= img
->width
= cinfo
.output_width
;
6556 height
= img
->height
= cinfo
.output_height
;
6558 /* Create X image and pixmap. */
6559 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
6560 longjmp (mgr
.setjmp_buffer
, 2);
6562 /* Allocate colors. When color quantization is used,
6563 cinfo.actual_number_of_colors has been set with the number of
6564 colors generated, and cinfo.colormap is a two-dimensional array
6565 of color indices in the range 0..cinfo.actual_number_of_colors.
6566 No more than 255 colors will be generated. */
6570 if (cinfo
.out_color_components
> 2)
6571 ir
= 0, ig
= 1, ib
= 2;
6572 else if (cinfo
.out_color_components
> 1)
6573 ir
= 0, ig
= 1, ib
= 0;
6575 ir
= 0, ig
= 0, ib
= 0;
6577 /* Use the color table mechanism because it handles colors that
6578 cannot be allocated nicely. Such colors will be replaced with
6579 a default color, and we don't have to care about which colors
6580 can be freed safely, and which can't. */
6581 init_color_table ();
6582 colors
= (unsigned long *) alloca (cinfo
.actual_number_of_colors
6585 for (i
= 0; i
< cinfo
.actual_number_of_colors
; ++i
)
6587 /* Multiply RGB values with 255 because X expects RGB values
6588 in the range 0..0xffff. */
6589 int r
= cinfo
.colormap
[ir
][i
] << 8;
6590 int g
= cinfo
.colormap
[ig
][i
] << 8;
6591 int b
= cinfo
.colormap
[ib
][i
] << 8;
6592 colors
[i
] = lookup_rgb_color (f
, r
, g
, b
);
6595 #ifdef COLOR_TABLE_SUPPORT
6596 /* Remember those colors actually allocated. */
6597 img
->colors
= colors_in_color_table (&img
->ncolors
);
6598 free_color_table ();
6599 #endif /* COLOR_TABLE_SUPPORT */
6603 row_stride
= width
* cinfo
.output_components
;
6604 buffer
= cinfo
.mem
->alloc_sarray ((j_common_ptr
) &cinfo
, JPOOL_IMAGE
,
6606 for (y
= 0; y
< height
; ++y
)
6608 fn_jpeg_read_scanlines (&cinfo
, buffer
, 1);
6609 for (x
= 0; x
< cinfo
.output_width
; ++x
)
6610 XPutPixel (ximg
, x
, y
, colors
[buffer
[0][x
]]);
6614 fn_jpeg_finish_decompress (&cinfo
);
6615 fn_jpeg_destroy_decompress (&cinfo
);
6617 fclose ((FILE *) fp
);
6619 /* Maybe fill in the background field while we have ximg handy. */
6620 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
6621 IMAGE_BACKGROUND (img
, f
, ximg
);
6623 /* Put the image into the pixmap. */
6624 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
6625 x_destroy_x_image (ximg
);
6630 #else /* HAVE_JPEG */
6639 return image_load_quartz2d (f
, img
, 0);
6641 return image_load_quicktime (f
, img
, kQTFileTypeJPEG
);
6646 #endif /* !HAVE_JPEG */
6650 /***********************************************************************
6652 ***********************************************************************/
6654 #if defined (HAVE_TIFF) || defined (MAC_OS)
6656 static int tiff_image_p
P_ ((Lisp_Object object
));
6657 static int tiff_load
P_ ((struct frame
*f
, struct image
*img
));
6659 /* The symbol `tiff' identifying images of this type. */
6663 /* Indices of image specification fields in tiff_format, below. */
6665 enum tiff_keyword_index
6674 TIFF_HEURISTIC_MASK
,
6680 /* Vector of image_keyword structures describing the format
6681 of valid user-defined image specifications. */
6683 static struct image_keyword tiff_format
[TIFF_LAST
] =
6685 {":type", IMAGE_SYMBOL_VALUE
, 1},
6686 {":data", IMAGE_STRING_VALUE
, 0},
6687 {":file", IMAGE_STRING_VALUE
, 0},
6688 {":ascent", IMAGE_ASCENT_VALUE
, 0},
6689 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
6690 {":relief", IMAGE_INTEGER_VALUE
, 0},
6691 {":conversions", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6692 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6693 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6694 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
6697 /* Structure describing the image type `tiff'. */
6699 static struct image_type tiff_type
=
6708 /* Return non-zero if OBJECT is a valid TIFF image specification. */
6711 tiff_image_p (object
)
6714 struct image_keyword fmt
[TIFF_LAST
];
6715 bcopy (tiff_format
, fmt
, sizeof fmt
);
6717 if (!parse_image_spec (object
, fmt
, TIFF_LAST
, Qtiff
))
6720 /* Must specify either the :data or :file keyword. */
6721 return fmt
[TIFF_FILE
].count
+ fmt
[TIFF_DATA
].count
== 1;
6724 #endif /* HAVE_TIFF || MAC_OS */
6732 /* TIFF library details. */
6733 DEF_IMGLIB_FN (TIFFSetErrorHandler
);
6734 DEF_IMGLIB_FN (TIFFSetWarningHandler
);
6735 DEF_IMGLIB_FN (TIFFOpen
);
6736 DEF_IMGLIB_FN (TIFFClientOpen
);
6737 DEF_IMGLIB_FN (TIFFGetField
);
6738 DEF_IMGLIB_FN (TIFFReadRGBAImage
);
6739 DEF_IMGLIB_FN (TIFFClose
);
6742 init_tiff_functions (Lisp_Object libraries
)
6746 if (!(library
= w32_delayed_load (libraries
, Qtiff
)))
6749 LOAD_IMGLIB_FN (library
, TIFFSetErrorHandler
);
6750 LOAD_IMGLIB_FN (library
, TIFFSetWarningHandler
);
6751 LOAD_IMGLIB_FN (library
, TIFFOpen
);
6752 LOAD_IMGLIB_FN (library
, TIFFClientOpen
);
6753 LOAD_IMGLIB_FN (library
, TIFFGetField
);
6754 LOAD_IMGLIB_FN (library
, TIFFReadRGBAImage
);
6755 LOAD_IMGLIB_FN (library
, TIFFClose
);
6761 #define fn_TIFFSetErrorHandler TIFFSetErrorHandler
6762 #define fn_TIFFSetWarningHandler TIFFSetWarningHandler
6763 #define fn_TIFFOpen TIFFOpen
6764 #define fn_TIFFClientOpen TIFFClientOpen
6765 #define fn_TIFFGetField TIFFGetField
6766 #define fn_TIFFReadRGBAImage TIFFReadRGBAImage
6767 #define fn_TIFFClose TIFFClose
6769 #endif /* HAVE_NTGUI */
6772 /* Reading from a memory buffer for TIFF images Based on the PNG
6773 memory source, but we have to provide a lot of extra functions.
6776 We really only need to implement read and seek, but I am not
6777 convinced that the TIFF library is smart enough not to destroy
6778 itself if we only hand it the function pointers we need to
6783 unsigned char *bytes
;
6790 tiff_read_from_memory (data
, buf
, size
)
6795 tiff_memory_source
*src
= (tiff_memory_source
*) data
;
6797 if (size
> src
->len
- src
->index
)
6799 bcopy (src
->bytes
+ src
->index
, buf
, size
);
6805 tiff_write_from_memory (data
, buf
, size
)
6814 tiff_seek_in_memory (data
, off
, whence
)
6819 tiff_memory_source
*src
= (tiff_memory_source
*) data
;
6824 case SEEK_SET
: /* Go from beginning of source. */
6828 case SEEK_END
: /* Go from end of source. */
6829 idx
= src
->len
+ off
;
6832 case SEEK_CUR
: /* Go from current position. */
6833 idx
= src
->index
+ off
;
6836 default: /* Invalid `whence'. */
6840 if (idx
> src
->len
|| idx
< 0)
6848 tiff_close_memory (data
)
6856 tiff_mmap_memory (data
, pbase
, psize
)
6861 /* It is already _IN_ memory. */
6866 tiff_unmap_memory (data
, base
, size
)
6871 /* We don't need to do this. */
6875 tiff_size_of_memory (data
)
6878 return ((tiff_memory_source
*) data
)->len
;
6883 tiff_error_handler (title
, format
, ap
)
6884 const char *title
, *format
;
6890 len
= sprintf (buf
, "TIFF error: %s ", title
);
6891 vsprintf (buf
+ len
, format
, ap
);
6892 add_to_log (buf
, Qnil
, Qnil
);
6897 tiff_warning_handler (title
, format
, ap
)
6898 const char *title
, *format
;
6904 len
= sprintf (buf
, "TIFF warning: %s ", title
);
6905 vsprintf (buf
+ len
, format
, ap
);
6906 add_to_log (buf
, Qnil
, Qnil
);
6910 /* Load TIFF image IMG for use on frame F. Value is non-zero if
6918 Lisp_Object file
, specified_file
;
6919 Lisp_Object specified_data
;
6921 int width
, height
, x
, y
;
6925 struct gcpro gcpro1
;
6926 tiff_memory_source memsrc
;
6928 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
6929 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
6933 fn_TIFFSetErrorHandler (tiff_error_handler
);
6934 fn_TIFFSetWarningHandler (tiff_warning_handler
);
6936 if (NILP (specified_data
))
6938 /* Read from a file */
6939 file
= x_find_image_file (specified_file
);
6940 if (!STRINGP (file
))
6942 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
6947 /* Try to open the image file. */
6948 tiff
= fn_TIFFOpen (SDATA (file
), "r");
6951 image_error ("Cannot open `%s'", file
, Qnil
);
6958 /* Memory source! */
6959 memsrc
.bytes
= SDATA (specified_data
);
6960 memsrc
.len
= SBYTES (specified_data
);
6963 tiff
= fn_TIFFClientOpen ("memory_source", "r", &memsrc
,
6964 (TIFFReadWriteProc
) tiff_read_from_memory
,
6965 (TIFFReadWriteProc
) tiff_write_from_memory
,
6966 tiff_seek_in_memory
,
6968 tiff_size_of_memory
,
6974 image_error ("Cannot open memory source for `%s'", img
->spec
, Qnil
);
6980 /* Get width and height of the image, and allocate a raster buffer
6981 of width x height 32-bit values. */
6982 fn_TIFFGetField (tiff
, TIFFTAG_IMAGEWIDTH
, &width
);
6983 fn_TIFFGetField (tiff
, TIFFTAG_IMAGELENGTH
, &height
);
6984 buf
= (uint32
*) xmalloc (width
* height
* sizeof *buf
);
6986 rc
= fn_TIFFReadRGBAImage (tiff
, width
, height
, buf
, 0);
6987 fn_TIFFClose (tiff
);
6990 image_error ("Error reading TIFF image `%s'", img
->spec
, Qnil
);
6996 /* Create the X image and pixmap. */
6997 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
7004 /* Initialize the color table. */
7005 init_color_table ();
7007 /* Process the pixel raster. Origin is in the lower-left corner. */
7008 for (y
= 0; y
< height
; ++y
)
7010 uint32
*row
= buf
+ y
* width
;
7012 for (x
= 0; x
< width
; ++x
)
7014 uint32 abgr
= row
[x
];
7015 int r
= TIFFGetR (abgr
) << 8;
7016 int g
= TIFFGetG (abgr
) << 8;
7017 int b
= TIFFGetB (abgr
) << 8;
7018 XPutPixel (ximg
, x
, height
- 1 - y
, lookup_rgb_color (f
, r
, g
, b
));
7022 #ifdef COLOR_TABLE_SUPPORT
7023 /* Remember the colors allocated for the image. Free the color table. */
7024 img
->colors
= colors_in_color_table (&img
->ncolors
);
7025 free_color_table ();
7026 #endif /* COLOR_TABLE_SUPPORT */
7029 img
->height
= height
;
7031 /* Maybe fill in the background field while we have ximg handy. */
7032 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
7033 IMAGE_BACKGROUND (img
, f
, 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 /* avoid conflict with QuickdrawText.h */
7142 #define DrawText gif_DrawText
7143 #include <gif_lib.h>
7146 #else /* HAVE_NTGUI || MAC_OS */
7148 #include <gif_lib.h>
7150 #endif /* HAVE_NTGUI || MAC_OS */
7155 /* GIF library details. */
7156 DEF_IMGLIB_FN (DGifCloseFile
);
7157 DEF_IMGLIB_FN (DGifSlurp
);
7158 DEF_IMGLIB_FN (DGifOpen
);
7159 DEF_IMGLIB_FN (DGifOpenFileName
);
7162 init_gif_functions (Lisp_Object libraries
)
7166 if (!(library
= w32_delayed_load (libraries
, Qgif
)))
7169 LOAD_IMGLIB_FN (library
, DGifCloseFile
);
7170 LOAD_IMGLIB_FN (library
, DGifSlurp
);
7171 LOAD_IMGLIB_FN (library
, DGifOpen
);
7172 LOAD_IMGLIB_FN (library
, DGifOpenFileName
);
7178 #define fn_DGifCloseFile DGifCloseFile
7179 #define fn_DGifSlurp DGifSlurp
7180 #define fn_DGifOpen DGifOpen
7181 #define fn_DGifOpenFileName DGifOpenFileName
7183 #endif /* HAVE_NTGUI */
7185 /* Reading a GIF image from memory
7186 Based on the PNG memory stuff to a certain extent. */
7190 unsigned char *bytes
;
7196 /* Make the current memory source available to gif_read_from_memory.
7197 It's done this way because not all versions of libungif support
7198 a UserData field in the GifFileType structure. */
7199 static gif_memory_source
*current_gif_memory_src
;
7202 gif_read_from_memory (file
, buf
, len
)
7207 gif_memory_source
*src
= current_gif_memory_src
;
7209 if (len
> src
->len
- src
->index
)
7212 bcopy (src
->bytes
+ src
->index
, buf
, len
);
7218 /* Load GIF image IMG for use on frame F. Value is non-zero if
7226 Lisp_Object file
, specified_file
;
7227 Lisp_Object specified_data
;
7228 int rc
, width
, height
, x
, y
, i
;
7230 ColorMapObject
*gif_color_map
;
7231 unsigned long pixel_colors
[256];
7233 struct gcpro gcpro1
;
7235 int ino
, image_left
, image_top
, image_width
, image_height
;
7236 gif_memory_source memsrc
;
7237 unsigned char *raster
;
7239 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
7240 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
7244 if (NILP (specified_data
))
7246 file
= x_find_image_file (specified_file
);
7247 if (!STRINGP (file
))
7249 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
7254 /* Open the GIF file. */
7255 gif
= fn_DGifOpenFileName (SDATA (file
));
7258 image_error ("Cannot open `%s'", file
, Qnil
);
7265 /* Read from memory! */
7266 current_gif_memory_src
= &memsrc
;
7267 memsrc
.bytes
= SDATA (specified_data
);
7268 memsrc
.len
= SBYTES (specified_data
);
7271 gif
= fn_DGifOpen(&memsrc
, gif_read_from_memory
);
7274 image_error ("Cannot open memory source `%s'", img
->spec
, Qnil
);
7280 /* Read entire contents. */
7281 rc
= fn_DGifSlurp (gif
);
7282 if (rc
== GIF_ERROR
)
7284 image_error ("Error reading `%s'", img
->spec
, Qnil
);
7285 fn_DGifCloseFile (gif
);
7290 image
= image_spec_value (img
->spec
, QCindex
, NULL
);
7291 ino
= INTEGERP (image
) ? XFASTINT (image
) : 0;
7292 if (ino
>= gif
->ImageCount
)
7294 image_error ("Invalid image number `%s' in image `%s'",
7296 fn_DGifCloseFile (gif
);
7301 width
= img
->width
= max (gif
->SWidth
, gif
->Image
.Left
+ gif
->Image
.Width
);
7302 height
= img
->height
= max (gif
->SHeight
, gif
->Image
.Top
+ gif
->Image
.Height
);
7304 /* Create the X image and pixmap. */
7305 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
7307 fn_DGifCloseFile (gif
);
7312 /* Allocate colors. */
7313 gif_color_map
= gif
->SavedImages
[ino
].ImageDesc
.ColorMap
;
7315 gif_color_map
= gif
->SColorMap
;
7316 init_color_table ();
7317 bzero (pixel_colors
, sizeof pixel_colors
);
7319 for (i
= 0; i
< gif_color_map
->ColorCount
; ++i
)
7321 int r
= gif_color_map
->Colors
[i
].Red
<< 8;
7322 int g
= gif_color_map
->Colors
[i
].Green
<< 8;
7323 int b
= gif_color_map
->Colors
[i
].Blue
<< 8;
7324 pixel_colors
[i
] = lookup_rgb_color (f
, r
, g
, b
);
7327 #ifdef COLOR_TABLE_SUPPORT
7328 img
->colors
= colors_in_color_table (&img
->ncolors
);
7329 free_color_table ();
7330 #endif /* COLOR_TABLE_SUPPORT */
7332 /* Clear the part of the screen image that are not covered by
7333 the image from the GIF file. Full animated GIF support
7334 requires more than can be done here (see the gif89 spec,
7335 disposal methods). Let's simply assume that the part
7336 not covered by a sub-image is in the frame's background color. */
7337 image_top
= gif
->SavedImages
[ino
].ImageDesc
.Top
;
7338 image_left
= gif
->SavedImages
[ino
].ImageDesc
.Left
;
7339 image_width
= gif
->SavedImages
[ino
].ImageDesc
.Width
;
7340 image_height
= gif
->SavedImages
[ino
].ImageDesc
.Height
;
7342 for (y
= 0; y
< image_top
; ++y
)
7343 for (x
= 0; x
< width
; ++x
)
7344 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7346 for (y
= image_top
+ image_height
; y
< height
; ++y
)
7347 for (x
= 0; x
< width
; ++x
)
7348 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7350 for (y
= image_top
; y
< image_top
+ image_height
; ++y
)
7352 for (x
= 0; x
< image_left
; ++x
)
7353 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7354 for (x
= image_left
+ image_width
; x
< width
; ++x
)
7355 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7358 /* Read the GIF image into the X image. We use a local variable
7359 `raster' here because RasterBits below is a char *, and invites
7360 problems with bytes >= 0x80. */
7361 raster
= (unsigned char *) gif
->SavedImages
[ino
].RasterBits
;
7363 if (gif
->SavedImages
[ino
].ImageDesc
.Interlace
)
7365 static int interlace_start
[] = {0, 4, 2, 1};
7366 static int interlace_increment
[] = {8, 8, 4, 2};
7368 int row
= interlace_start
[0];
7372 for (y
= 0; y
< image_height
; y
++)
7374 if (row
>= image_height
)
7376 row
= interlace_start
[++pass
];
7377 while (row
>= image_height
)
7378 row
= interlace_start
[++pass
];
7381 for (x
= 0; x
< image_width
; x
++)
7383 int i
= raster
[(y
* image_width
) + x
];
7384 XPutPixel (ximg
, x
+ image_left
, row
+ image_top
,
7388 row
+= interlace_increment
[pass
];
7393 for (y
= 0; y
< image_height
; ++y
)
7394 for (x
= 0; x
< image_width
; ++x
)
7396 int i
= raster
[y
* image_width
+ x
];
7397 XPutPixel (ximg
, x
+ image_left
, y
+ image_top
, pixel_colors
[i
]);
7401 fn_DGifCloseFile (gif
);
7403 /* Maybe fill in the background field while we have ximg handy. */
7404 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
7405 IMAGE_BACKGROUND (img
, f
, ximg
);
7407 /* Put the image into the pixmap, then free the X image and its buffer. */
7408 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
7409 x_destroy_x_image (ximg
);
7423 Lisp_Object specified_file
, file
;
7424 Lisp_Object specified_data
;
7426 Boolean graphic_p
, movie_p
, prefer_graphic_p
;
7434 Lisp_Object specified_bg
;
7440 struct gcpro gcpro1
;
7445 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
7446 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
7448 if (NILP (specified_data
))
7450 /* Read from a file */
7454 err
= find_image_fsspec (specified_file
, &file
, &fss
);
7458 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
7463 err
= CanQuickTimeOpenFile (&fss
, kQTFileTypeGIF
, 0,
7464 &graphic_p
, &movie_p
, &prefer_graphic_p
, 0);
7468 if (!graphic_p
&& !movie_p
)
7470 if (prefer_graphic_p
)
7471 return image_load_qt_1 (f
, img
, kQTFileTypeGIF
, &fss
, NULL
);
7472 err
= OpenMovieFile (&fss
, &refnum
, fsRdPerm
);
7475 err
= NewMovieFromFile (&movie
, refnum
, NULL
, NULL
, 0, NULL
);
7476 CloseMovieFile (refnum
);
7479 image_error ("Error reading `%s'", file
, Qnil
);
7485 /* Memory source! */
7487 long file_type_atom
[3];
7489 err
= PtrToHand (SDATA (specified_data
), &dh
, SBYTES (specified_data
));
7492 image_error ("Cannot allocate data handle for `%s'",
7497 file_type_atom
[0] = EndianU32_NtoB (sizeof (long) * 3);
7498 file_type_atom
[1] = EndianU32_NtoB (kDataRefExtensionMacOSFileType
);
7499 file_type_atom
[2] = EndianU32_NtoB (kQTFileTypeGIF
);
7500 err
= PtrToHand (&dh
, &dref
, sizeof (Handle
));
7503 err
= PtrAndHand ("\p", dref
, 1);
7505 err
= PtrAndHand (file_type_atom
, dref
, sizeof (long) * 3);
7508 image_error ("Cannot allocate handle data ref for `%s'", img
->spec
, Qnil
);
7511 err
= CanQuickTimeOpenDataRef (dref
, HandleDataHandlerSubType
, &graphic_p
,
7512 &movie_p
, &prefer_graphic_p
, 0);
7516 if (!graphic_p
&& !movie_p
)
7518 if (prefer_graphic_p
)
7522 DisposeHandle (dref
);
7523 success_p
= image_load_qt_1 (f
, img
, kQTFileTypeGIF
, NULL
, dh
);
7527 err
= NewMovieFromDataRef (&movie
, 0, NULL
, dref
,
7528 HandleDataHandlerSubType
);
7529 DisposeHandle (dref
);
7534 image
= image_spec_value (img
->spec
, QCindex
, NULL
);
7535 ino
= INTEGERP (image
) ? XFASTINT (image
) : 0;
7536 track
= GetMovieIndTrack (movie
, 1);
7537 media
= GetTrackMedia (track
);
7538 nsamples
= GetMediaSampleCount (media
);
7539 if (ino
>= nsamples
)
7541 image_error ("Invalid image number `%s' in image `%s'",
7546 specified_bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
7547 if (!STRINGP (specified_bg
) ||
7548 !mac_defined_color (f
, SDATA (specified_bg
), &color
, 0))
7550 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
7551 color
.red
= RED16_FROM_ULONG (color
.pixel
);
7552 color
.green
= GREEN16_FROM_ULONG (color
.pixel
);
7553 color
.blue
= BLUE16_FROM_ULONG (color
.pixel
);
7555 GetMovieBox (movie
, &rect
);
7556 width
= img
->width
= rect
.right
- rect
.left
;
7557 height
= img
->height
= rect
.bottom
- rect
.top
;
7558 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
7561 GetGWorld (&old_port
, &old_gdh
);
7562 SetGWorld (ximg
, NULL
);
7563 bg_color
.red
= color
.red
;
7564 bg_color
.green
= color
.green
;
7565 bg_color
.blue
= color
.blue
;
7566 RGBBackColor (&bg_color
);
7567 SetGWorld (old_port
, old_gdh
);
7568 SetMovieActive (movie
, 1);
7569 SetMovieGWorld (movie
, ximg
, NULL
);
7570 SampleNumToMediaTime (media
, ino
+ 1, &time
, NULL
);
7571 SetMovieTimeValue (movie
, time
);
7572 MoviesTask (movie
, 0L);
7573 DisposeTrackMedia (media
);
7574 DisposeMovieTrack (track
);
7575 DisposeMovie (movie
);
7578 /* Maybe fill in the background field while we have ximg handy. */
7579 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
7580 IMAGE_BACKGROUND (img
, f
, ximg
);
7582 /* Put the image into the pixmap. */
7583 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
7584 x_destroy_x_image (ximg
);
7588 image_error ("Cannot open `%s'", file
, Qnil
);
7591 DisposeTrackMedia (media
);
7593 DisposeMovieTrack (track
);
7595 DisposeMovie (movie
);
7602 #endif /* HAVE_GIF */
7606 /***********************************************************************
7608 ***********************************************************************/
7610 #ifdef HAVE_X_WINDOWS
7611 #define HAVE_GHOSTSCRIPT 1
7612 #endif /* HAVE_X_WINDOWS */
7614 /* The symbol `postscript' identifying images of this type. */
7616 Lisp_Object Qpostscript
;
7618 #ifdef HAVE_GHOSTSCRIPT
7620 static int gs_image_p
P_ ((Lisp_Object object
));
7621 static int gs_load
P_ ((struct frame
*f
, struct image
*img
));
7622 static void gs_clear_image
P_ ((struct frame
*f
, struct image
*img
));
7624 /* Keyword symbols. */
7626 Lisp_Object QCloader
, QCbounding_box
, QCpt_width
, QCpt_height
;
7628 /* Indices of image specification fields in gs_format, below. */
7630 enum gs_keyword_index
7648 /* Vector of image_keyword structures describing the format
7649 of valid user-defined image specifications. */
7651 static struct image_keyword gs_format
[GS_LAST
] =
7653 {":type", IMAGE_SYMBOL_VALUE
, 1},
7654 {":pt-width", IMAGE_POSITIVE_INTEGER_VALUE
, 1},
7655 {":pt-height", IMAGE_POSITIVE_INTEGER_VALUE
, 1},
7656 {":file", IMAGE_STRING_VALUE
, 1},
7657 {":loader", IMAGE_FUNCTION_VALUE
, 0},
7658 {":bounding-box", IMAGE_DONT_CHECK_VALUE_TYPE
, 1},
7659 {":ascent", IMAGE_ASCENT_VALUE
, 0},
7660 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
7661 {":relief", IMAGE_INTEGER_VALUE
, 0},
7662 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7663 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7664 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7665 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
7668 /* Structure describing the image type `ghostscript'. */
7670 static struct image_type gs_type
=
7680 /* Free X resources of Ghostscript image IMG which is used on frame F. */
7683 gs_clear_image (f
, img
)
7687 /* IMG->data.ptr_val may contain a recorded colormap. */
7688 xfree (img
->data
.ptr_val
);
7689 x_clear_image (f
, img
);
7693 /* Return non-zero if OBJECT is a valid Ghostscript image
7700 struct image_keyword fmt
[GS_LAST
];
7704 bcopy (gs_format
, fmt
, sizeof fmt
);
7706 if (!parse_image_spec (object
, fmt
, GS_LAST
, Qpostscript
))
7709 /* Bounding box must be a list or vector containing 4 integers. */
7710 tem
= fmt
[GS_BOUNDING_BOX
].value
;
7713 for (i
= 0; i
< 4; ++i
, tem
= XCDR (tem
))
7714 if (!CONSP (tem
) || !INTEGERP (XCAR (tem
)))
7719 else if (VECTORP (tem
))
7721 if (XVECTOR (tem
)->size
!= 4)
7723 for (i
= 0; i
< 4; ++i
)
7724 if (!INTEGERP (XVECTOR (tem
)->contents
[i
]))
7734 /* Load Ghostscript image IMG for use on frame F. Value is non-zero
7743 Lisp_Object window_and_pixmap_id
= Qnil
, loader
, pt_height
, pt_width
;
7744 struct gcpro gcpro1
, gcpro2
;
7746 double in_width
, in_height
;
7747 Lisp_Object pixel_colors
= Qnil
;
7749 /* Compute pixel size of pixmap needed from the given size in the
7750 image specification. Sizes in the specification are in pt. 1 pt
7751 = 1/72 in, xdpi and ydpi are stored in the frame's X display
7753 pt_width
= image_spec_value (img
->spec
, QCpt_width
, NULL
);
7754 in_width
= XFASTINT (pt_width
) / 72.0;
7755 img
->width
= in_width
* FRAME_X_DISPLAY_INFO (f
)->resx
;
7756 pt_height
= image_spec_value (img
->spec
, QCpt_height
, NULL
);
7757 in_height
= XFASTINT (pt_height
) / 72.0;
7758 img
->height
= in_height
* FRAME_X_DISPLAY_INFO (f
)->resy
;
7760 /* Create the pixmap. */
7761 xassert (img
->pixmap
== NO_PIXMAP
);
7763 /* Only W32 version did BLOCK_INPUT here. ++kfs */
7765 img
->pixmap
= XCreatePixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
7766 img
->width
, img
->height
,
7767 DefaultDepthOfScreen (FRAME_X_SCREEN (f
)));
7772 image_error ("Unable to create pixmap for `%s'", img
->spec
, Qnil
);
7776 /* Call the loader to fill the pixmap. It returns a process object
7777 if successful. We do not record_unwind_protect here because
7778 other places in redisplay like calling window scroll functions
7779 don't either. Let the Lisp loader use `unwind-protect' instead. */
7780 GCPRO2 (window_and_pixmap_id
, pixel_colors
);
7782 sprintf (buffer
, "%lu %lu",
7783 (unsigned long) FRAME_X_WINDOW (f
),
7784 (unsigned long) img
->pixmap
);
7785 window_and_pixmap_id
= build_string (buffer
);
7787 sprintf (buffer
, "%lu %lu",
7788 FRAME_FOREGROUND_PIXEL (f
),
7789 FRAME_BACKGROUND_PIXEL (f
));
7790 pixel_colors
= build_string (buffer
);
7792 XSETFRAME (frame
, f
);
7793 loader
= image_spec_value (img
->spec
, QCloader
, NULL
);
7795 loader
= intern ("gs-load-image");
7797 img
->data
.lisp_val
= call6 (loader
, frame
, img
->spec
,
7798 make_number (img
->width
),
7799 make_number (img
->height
),
7800 window_and_pixmap_id
,
7803 return PROCESSP (img
->data
.lisp_val
);
7807 /* Kill the Ghostscript process that was started to fill PIXMAP on
7808 frame F. Called from XTread_socket when receiving an event
7809 telling Emacs that Ghostscript has finished drawing. */
7812 x_kill_gs_process (pixmap
, f
)
7816 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
7820 /* Find the image containing PIXMAP. */
7821 for (i
= 0; i
< c
->used
; ++i
)
7822 if (c
->images
[i
]->pixmap
== pixmap
)
7825 /* Should someone in between have cleared the image cache, for
7826 instance, give up. */
7830 /* Kill the GS process. We should have found PIXMAP in the image
7831 cache and its image should contain a process object. */
7833 xassert (PROCESSP (img
->data
.lisp_val
));
7834 Fkill_process (img
->data
.lisp_val
, Qnil
);
7835 img
->data
.lisp_val
= Qnil
;
7837 #if defined (HAVE_X_WINDOWS)
7839 /* On displays with a mutable colormap, figure out the colors
7840 allocated for the image by looking at the pixels of an XImage for
7842 class = FRAME_X_VISUAL (f
)->class;
7843 if (class != StaticColor
&& class != StaticGray
&& class != TrueColor
)
7849 /* Try to get an XImage for img->pixmep. */
7850 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
7851 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
7856 /* Initialize the color table. */
7857 init_color_table ();
7859 /* For each pixel of the image, look its color up in the
7860 color table. After having done so, the color table will
7861 contain an entry for each color used by the image. */
7862 for (y
= 0; y
< img
->height
; ++y
)
7863 for (x
= 0; x
< img
->width
; ++x
)
7865 unsigned long pixel
= XGetPixel (ximg
, x
, y
);
7866 lookup_pixel_color (f
, pixel
);
7869 /* Record colors in the image. Free color table and XImage. */
7870 #ifdef COLOR_TABLE_SUPPORT
7871 img
->colors
= colors_in_color_table (&img
->ncolors
);
7872 free_color_table ();
7874 XDestroyImage (ximg
);
7876 #if 0 /* This doesn't seem to be the case. If we free the colors
7877 here, we get a BadAccess later in x_clear_image when
7878 freeing the colors. */
7879 /* We have allocated colors once, but Ghostscript has also
7880 allocated colors on behalf of us. So, to get the
7881 reference counts right, free them once. */
7883 x_free_colors (f
, img
->colors
, img
->ncolors
);
7887 image_error ("Cannot get X image of `%s'; colors will not be freed",
7892 #endif /* HAVE_X_WINDOWS */
7894 /* Now that we have the pixmap, compute mask and transform the
7895 image if requested. */
7897 postprocess_image (f
, img
);
7901 #endif /* HAVE_GHOSTSCRIPT */
7904 /***********************************************************************
7906 ***********************************************************************/
7910 DEFUN ("imagep", Fimagep
, Simagep
, 1, 1, 0,
7911 doc
: /* Value is non-nil if SPEC is a valid image specification. */)
7915 return valid_image_p (spec
) ? Qt
: Qnil
;
7919 DEFUN ("lookup-image", Flookup_image
, Slookup_image
, 1, 1, 0, "")
7925 if (valid_image_p (spec
))
7926 id
= lookup_image (SELECTED_FRAME (), spec
);
7929 return make_number (id
);
7932 #endif /* GLYPH_DEBUG != 0 */
7935 /***********************************************************************
7937 ***********************************************************************/
7940 /* Image types that rely on external libraries are loaded dynamically
7941 if the library is available. */
7942 #define CHECK_LIB_AVAILABLE(image_type, init_lib_fn, libraries) \
7943 define_image_type (image_type, init_lib_fn (libraries))
7945 #define CHECK_LIB_AVAILABLE(image_type, init_lib_fn, libraries) \
7946 define_image_type (image_type, 1)
7947 #endif /* HAVE_NTGUI */
7949 DEFUN ("init-image-library", Finit_image_library
, Sinit_image_library
, 2, 2, 0,
7950 doc
: /* Initialize image library implementing image type TYPE.
7951 Return non-nil if TYPE is a supported image type.
7953 Image types pbm and xbm are prebuilt; other types are loaded here.
7954 Libraries to load are specified in alist LIBRARIES (usually, the value
7955 of `image-library-alist', which see). */)
7957 Lisp_Object type
, libraries
;
7961 /* Don't try to reload the library. */
7962 tested
= Fassq (type
, Vimage_type_cache
);
7964 return XCDR (tested
);
7966 #if defined (HAVE_XPM) || defined (MAC_OS)
7967 if (EQ (type
, Qxpm
))
7968 return CHECK_LIB_AVAILABLE (&xpm_type
, init_xpm_functions
, libraries
);
7971 #if defined (HAVE_JPEG) || defined (MAC_OS)
7972 if (EQ (type
, Qjpeg
))
7973 return CHECK_LIB_AVAILABLE (&jpeg_type
, init_jpeg_functions
, libraries
);
7976 #if defined (HAVE_TIFF) || defined (MAC_OS)
7977 if (EQ (type
, Qtiff
))
7978 return CHECK_LIB_AVAILABLE (&tiff_type
, init_tiff_functions
, libraries
);
7981 #if defined (HAVE_GIF) || defined (MAC_OS)
7982 if (EQ (type
, Qgif
))
7983 return CHECK_LIB_AVAILABLE (&gif_type
, init_gif_functions
, libraries
);
7986 #if defined (HAVE_PNG) || defined (MAC_OS)
7987 if (EQ (type
, Qpng
))
7988 return CHECK_LIB_AVAILABLE (&png_type
, init_png_functions
, libraries
);
7991 #ifdef HAVE_GHOSTSCRIPT
7992 if (EQ (type
, Qpostscript
))
7993 return CHECK_LIB_AVAILABLE (&gs_type
, init_gs_functions
, libraries
);
7996 /* If the type is not recognized, avoid testing it ever again. */
7997 CACHE_IMAGE_TYPE (type
, Qnil
);
8004 /* Must be defined now becase we're going to update it below, while
8005 defining the supported image types. */
8006 DEFVAR_LISP ("image-types", &Vimage_types
,
8007 doc
: /* List of potentially supported image types.
8008 Each element of the list is a symbol for a image type, like 'jpeg or 'png.
8009 To check whether it is really supported, use `image-type-available-p'. */);
8010 Vimage_types
= Qnil
;
8012 Vimage_type_cache
= Qnil
;
8013 staticpro (&Vimage_type_cache
);
8015 QCascent
= intern (":ascent");
8016 staticpro (&QCascent
);
8017 QCmargin
= intern (":margin");
8018 staticpro (&QCmargin
);
8019 QCrelief
= intern (":relief");
8020 staticpro (&QCrelief
);
8021 QCconversion
= intern (":conversion");
8022 staticpro (&QCconversion
);
8023 QCcolor_symbols
= intern (":color-symbols");
8024 staticpro (&QCcolor_symbols
);
8025 QCheuristic_mask
= intern (":heuristic-mask");
8026 staticpro (&QCheuristic_mask
);
8027 QCindex
= intern (":index");
8028 staticpro (&QCindex
);
8029 QCmatrix
= intern (":matrix");
8030 staticpro (&QCmatrix
);
8031 QCcolor_adjustment
= intern (":color-adjustment");
8032 staticpro (&QCcolor_adjustment
);
8033 QCmask
= intern (":mask");
8034 staticpro (&QCmask
);
8036 Qlaplace
= intern ("laplace");
8037 staticpro (&Qlaplace
);
8038 Qemboss
= intern ("emboss");
8039 staticpro (&Qemboss
);
8040 Qedge_detection
= intern ("edge-detection");
8041 staticpro (&Qedge_detection
);
8042 Qheuristic
= intern ("heuristic");
8043 staticpro (&Qheuristic
);
8045 Qpostscript
= intern ("postscript");
8046 staticpro (&Qpostscript
);
8047 #ifdef HAVE_GHOSTSCRIPT
8048 ADD_IMAGE_TYPE(Qpostscript
);
8049 QCloader
= intern (":loader");
8050 staticpro (&QCloader
);
8051 QCbounding_box
= intern (":bounding-box");
8052 staticpro (&QCbounding_box
);
8053 QCpt_width
= intern (":pt-width");
8054 staticpro (&QCpt_width
);
8055 QCpt_height
= intern (":pt-height");
8056 staticpro (&QCpt_height
);
8057 #endif /* HAVE_GHOSTSCRIPT */
8059 Qpbm
= intern ("pbm");
8061 ADD_IMAGE_TYPE(Qpbm
);
8063 Qxbm
= intern ("xbm");
8065 ADD_IMAGE_TYPE(Qxbm
);
8067 #if defined (HAVE_XPM) || defined (MAC_OS)
8068 Qxpm
= intern ("xpm");
8070 ADD_IMAGE_TYPE(Qxpm
);
8073 #if defined (HAVE_JPEG) || defined (MAC_OS)
8074 Qjpeg
= intern ("jpeg");
8076 ADD_IMAGE_TYPE(Qjpeg
);
8079 #if defined (HAVE_TIFF) || defined (MAC_OS)
8080 Qtiff
= intern ("tiff");
8082 ADD_IMAGE_TYPE(Qtiff
);
8085 #if defined (HAVE_GIF) || defined (MAC_OS)
8086 Qgif
= intern ("gif");
8088 ADD_IMAGE_TYPE(Qgif
);
8091 #if defined (HAVE_PNG) || defined (MAC_OS)
8092 Qpng
= intern ("png");
8094 ADD_IMAGE_TYPE(Qpng
);
8097 defsubr (&Sinit_image_library
);
8098 defsubr (&Sclear_image_cache
);
8099 defsubr (&Simage_size
);
8100 defsubr (&Simage_mask_p
);
8104 defsubr (&Slookup_image
);
8107 DEFVAR_BOOL ("cross-disabled-images", &cross_disabled_images
,
8108 doc
: /* Non-nil means always draw a cross over disabled images.
8109 Disabled images are those having an `:conversion disabled' property.
8110 A cross is always drawn on black & white displays. */);
8111 cross_disabled_images
= 0;
8113 DEFVAR_LISP ("x-bitmap-file-path", &Vx_bitmap_file_path
,
8114 doc
: /* List of directories to search for window system bitmap files. */);
8115 Vx_bitmap_file_path
= decode_env_path ((char *) 0, PATH_BITMAPS
);
8117 DEFVAR_LISP ("image-cache-eviction-delay", &Vimage_cache_eviction_delay
,
8118 doc
: /* Time after which cached images are removed from the cache.
8119 When an image has not been displayed this many seconds, remove it
8120 from the image cache. Value must be an integer or nil with nil
8121 meaning don't clear the cache. */);
8122 Vimage_cache_eviction_delay
= make_number (30 * 60);
8130 define_image_type (&xbm_type
, 1);
8131 define_image_type (&pbm_type
, 1);
8134 /* Animated gifs use QuickTime Movie Toolbox. So initialize it here. */
8137 init_image_func_pointer ();
8142 /* arch-tag: 123c2a5e-14a8-4c53-ab95-af47d7db49b9
8143 (do not change this comment) */