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 */
91 #include <QuickTime/QuickTime.h>
92 #else /* not MAC_OSX */
95 #include <TextUtils.h>
96 #endif /* not MAC_OSX */
98 /* MAC_TODO : Color tables on Mac. */
99 #undef COLOR_TABLE_SUPPORT
101 #define ZPixmap 0 /* arbitrary */
102 typedef struct mac_bitmap_record Bitmap_Record
;
104 #define GET_PIXEL(ximg, x, y) XGetPixel(ximg, x, y)
107 #define RGB_PIXEL_COLOR unsigned long
109 #define FRAME_X_VISUAL(f) FRAME_X_DISPLAY_INFO (f)->visual
110 #define x_defined_color mac_defined_color
111 #define DefaultDepthOfScreen(screen) (one_mac_display_info.n_planes)
112 #define XDrawLine(display, w, gc, x1, y1, x2, y2) \
113 mac_draw_line_to_pixmap(display, w, gc, x1, y1, x2, y2)
118 /* Search path for bitmap files. */
120 Lisp_Object Vx_bitmap_file_path
;
123 static void x_disable_image
P_ ((struct frame
*, struct image
*));
124 static void x_edge_detection
P_ ((struct frame
*, struct image
*, Lisp_Object
,
127 static void init_color_table
P_ ((void));
128 static unsigned long lookup_rgb_color
P_ ((struct frame
*f
, int r
, int g
, int b
));
129 #ifdef COLOR_TABLE_SUPPORT
130 static void free_color_table
P_ ((void));
131 static unsigned long *colors_in_color_table
P_ ((int *n
));
132 static unsigned long lookup_pixel_color
P_ ((struct frame
*f
, unsigned long p
));
135 /* Code to deal with bitmaps. Bitmaps are referenced by their bitmap
136 id, which is just an int that this section returns. Bitmaps are
137 reference counted so they can be shared among frames.
139 Bitmap indices are guaranteed to be > 0, so a negative number can
140 be used to indicate no bitmap.
142 If you use x_create_bitmap_from_data, then you must keep track of
143 the bitmaps yourself. That is, creating a bitmap from the same
144 data more than once will not be caught. */
149 XGetImage (display
, pixmap
, x
, y
, width
, height
, plane_mask
, format
)
150 Display
*display
; /* not used */
152 int x
, y
; /* not used */
153 unsigned int width
, height
; /* not used */
154 unsigned long plane_mask
; /* not used */
155 int format
; /* not used */
158 xassert (x
== 0 && y
== 0);
161 SetRect (&ri
, 0, 0, width
, height
);
162 xassert (EqualRect (&ri
, GetPixBounds (GetGWorldPixMap (pixmap
), &rp
)));
164 xassert (! (pixelsLocked
& GetPixelsState (GetGWorldPixMap (pixmap
))));
167 LockPixels (GetGWorldPixMap (pixmap
));
173 XPutPixel (ximage
, x
, y
, pixel
)
182 GetGWorld (&old_port
, &old_gdh
);
183 SetGWorld (ximage
, NULL
);
185 color
.red
= RED16_FROM_ULONG (pixel
);
186 color
.green
= GREEN16_FROM_ULONG (pixel
);
187 color
.blue
= BLUE16_FROM_ULONG (pixel
);
188 SetCPixel (x
, y
, &color
);
190 SetGWorld (old_port
, old_gdh
);
194 XGetPixel (ximage
, x
, y
)
202 GetGWorld (&old_port
, &old_gdh
);
203 SetGWorld (ximage
, NULL
);
205 GetCPixel (x
, y
, &color
);
207 SetGWorld (old_port
, old_gdh
);
208 return RGB_TO_ULONG (color
.red
>> 8, color
.green
>> 8, color
.blue
>> 8);
215 UnlockPixels (GetGWorldPixMap (ximg
));
220 /* Functions to access the contents of a bitmap, given an id. */
223 x_bitmap_height (f
, id
)
227 return FRAME_X_DISPLAY_INFO (f
)->bitmaps
[id
- 1].height
;
231 x_bitmap_width (f
, id
)
235 return FRAME_X_DISPLAY_INFO (f
)->bitmaps
[id
- 1].width
;
238 #if defined (HAVE_X_WINDOWS) || defined (HAVE_NTGUI)
240 x_bitmap_pixmap (f
, id
)
244 return (int) FRAME_X_DISPLAY_INFO (f
)->bitmaps
[id
- 1].pixmap
;
248 #ifdef HAVE_X_WINDOWS
250 x_bitmap_mask (f
, id
)
254 return FRAME_X_DISPLAY_INFO (f
)->bitmaps
[id
- 1].mask
;
258 /* Allocate a new bitmap record. Returns index of new record. */
261 x_allocate_bitmap_record (f
)
264 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
267 if (dpyinfo
->bitmaps
== NULL
)
269 dpyinfo
->bitmaps_size
= 10;
271 = (Bitmap_Record
*) xmalloc (dpyinfo
->bitmaps_size
* sizeof (Bitmap_Record
));
272 dpyinfo
->bitmaps_last
= 1;
276 if (dpyinfo
->bitmaps_last
< dpyinfo
->bitmaps_size
)
277 return ++dpyinfo
->bitmaps_last
;
279 for (i
= 0; i
< dpyinfo
->bitmaps_size
; ++i
)
280 if (dpyinfo
->bitmaps
[i
].refcount
== 0)
283 dpyinfo
->bitmaps_size
*= 2;
285 = (Bitmap_Record
*) xrealloc (dpyinfo
->bitmaps
,
286 dpyinfo
->bitmaps_size
* sizeof (Bitmap_Record
));
287 return ++dpyinfo
->bitmaps_last
;
290 /* Add one reference to the reference count of the bitmap with id ID. */
293 x_reference_bitmap (f
, id
)
297 ++FRAME_X_DISPLAY_INFO (f
)->bitmaps
[id
- 1].refcount
;
300 /* Create a bitmap for frame F from a HEIGHT x WIDTH array of bits at BITS. */
303 x_create_bitmap_from_data (f
, bits
, width
, height
)
306 unsigned int width
, height
;
308 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
311 #ifdef HAVE_X_WINDOWS
313 bitmap
= XCreateBitmapFromData (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
314 bits
, width
, height
);
317 #endif /* HAVE_X_WINDOWS */
321 bitmap
= CreateBitmap (width
, height
,
322 FRAME_X_DISPLAY_INFO (XFRAME (frame
))->n_planes
,
323 FRAME_X_DISPLAY_INFO (XFRAME (frame
))->n_cbits
,
327 #endif /* HAVE_NTGUI */
330 /* MAC_TODO: for now fail if width is not mod 16 (toolbox requires it) */
335 id
= x_allocate_bitmap_record (f
);
337 dpyinfo
->bitmaps
[id
- 1].bitmap_data
= (char *) xmalloc (height
* width
);
338 if (! dpyinfo
->bitmaps
[id
- 1].bitmap_data
)
340 bcopy (bits
, dpyinfo
->bitmaps
[id
- 1].bitmap_data
, height
* width
);
343 dpyinfo
->bitmaps
[id
- 1].file
= NULL
;
344 dpyinfo
->bitmaps
[id
- 1].height
= height
;
345 dpyinfo
->bitmaps
[id
- 1].width
= width
;
346 dpyinfo
->bitmaps
[id
- 1].refcount
= 1;
348 #ifdef HAVE_X_WINDOWS
349 dpyinfo
->bitmaps
[id
- 1].pixmap
= bitmap
;
350 dpyinfo
->bitmaps
[id
- 1].have_mask
= 0;
351 dpyinfo
->bitmaps
[id
- 1].depth
= 1;
352 #endif /* HAVE_X_WINDOWS */
355 dpyinfo
->bitmaps
[id
- 1].pixmap
= bitmap
;
356 dpyinfo
->bitmaps
[id
- 1].hinst
= NULL
;
357 dpyinfo
->bitmaps
[id
- 1].depth
= 1;
358 #endif /* HAVE_NTGUI */
363 /* Create bitmap from file FILE for frame F. */
366 x_create_bitmap_from_file (f
, file
)
371 return -1; /* MAC_TODO : bitmap support */
375 return -1; /* W32_TODO : bitmap support */
376 #endif /* HAVE_NTGUI */
378 #ifdef HAVE_X_WINDOWS
379 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
380 unsigned int width
, height
;
382 int xhot
, yhot
, result
, id
;
387 /* Look for an existing bitmap with the same name. */
388 for (id
= 0; id
< dpyinfo
->bitmaps_last
; ++id
)
390 if (dpyinfo
->bitmaps
[id
].refcount
391 && dpyinfo
->bitmaps
[id
].file
392 && !strcmp (dpyinfo
->bitmaps
[id
].file
, (char *) SDATA (file
)))
394 ++dpyinfo
->bitmaps
[id
].refcount
;
399 /* Search bitmap-file-path for the file, if appropriate. */
400 fd
= openp (Vx_bitmap_file_path
, file
, Qnil
, &found
, Qnil
);
405 filename
= (char *) SDATA (found
);
407 result
= XReadBitmapFile (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
408 filename
, &width
, &height
, &bitmap
, &xhot
, &yhot
);
409 if (result
!= BitmapSuccess
)
412 id
= x_allocate_bitmap_record (f
);
413 dpyinfo
->bitmaps
[id
- 1].pixmap
= bitmap
;
414 dpyinfo
->bitmaps
[id
- 1].have_mask
= 0;
415 dpyinfo
->bitmaps
[id
- 1].refcount
= 1;
416 dpyinfo
->bitmaps
[id
- 1].file
= (char *) xmalloc (SBYTES (file
) + 1);
417 dpyinfo
->bitmaps
[id
- 1].depth
= 1;
418 dpyinfo
->bitmaps
[id
- 1].height
= height
;
419 dpyinfo
->bitmaps
[id
- 1].width
= width
;
420 strcpy (dpyinfo
->bitmaps
[id
- 1].file
, SDATA (file
));
423 #endif /* HAVE_X_WINDOWS */
429 Free_Bitmap_Record (dpyinfo
, bm
)
430 Display_Info
*dpyinfo
;
433 #ifdef HAVE_X_WINDOWS
434 XFreePixmap (dpyinfo
->display
, bm
->pixmap
);
436 XFreePixmap (dpyinfo
->display
, bm
->mask
);
437 #endif /* HAVE_X_WINDOWS */
440 DeleteObject (bm
->pixmap
);
441 #endif /* HAVE_NTGUI */
444 xfree (bm
->bitmap_data
); /* Added ++kfs */
445 bm
->bitmap_data
= NULL
;
455 /* Remove reference to bitmap with id number ID. */
458 x_destroy_bitmap (f
, id
)
462 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
466 Bitmap_Record
*bm
= &dpyinfo
->bitmaps
[id
- 1];
468 if (--bm
->refcount
== 0)
471 Free_Bitmap_Record (dpyinfo
, bm
);
477 /* Free all the bitmaps for the display specified by DPYINFO. */
480 x_destroy_all_bitmaps (dpyinfo
)
481 Display_Info
*dpyinfo
;
484 Bitmap_Record
*bm
= dpyinfo
->bitmaps
;
486 for (i
= 0; i
< dpyinfo
->bitmaps_last
; i
++, bm
++)
487 if (bm
->refcount
> 0)
488 Free_Bitmap_Record (dpyinfo
, bm
);
490 dpyinfo
->bitmaps_last
= 0;
494 #ifdef HAVE_X_WINDOWS
496 /* Useful functions defined in the section
497 `Image type independent image structures' below. */
499 static unsigned long four_corners_best
P_ ((XImagePtr ximg
, unsigned long width
,
500 unsigned long height
));
502 static int x_create_x_image_and_pixmap
P_ ((struct frame
*f
, int width
, int height
,
503 int depth
, XImagePtr
*ximg
,
506 static void x_destroy_x_image
P_ ((XImagePtr ximg
));
509 /* Create a mask of a bitmap. Note is this not a perfect mask.
510 It's nicer with some borders in this context */
513 x_create_bitmap_mask (f
, id
)
518 XImagePtr ximg
, mask_img
;
519 unsigned long width
, height
;
522 unsigned long x
, y
, xp
, xm
, yp
, ym
;
525 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
530 pixmap
= x_bitmap_pixmap (f
, id
);
531 width
= x_bitmap_width (f
, id
);
532 height
= x_bitmap_height (f
, id
);
535 ximg
= XGetImage (FRAME_X_DISPLAY (f
), pixmap
, 0, 0, width
, height
,
544 result
= x_create_x_image_and_pixmap (f
, width
, height
, 1, &mask_img
, &mask
);
549 XDestroyImage (ximg
);
553 bg
= four_corners_best (ximg
, width
, height
);
555 for (y
= 0; y
< ximg
->height
; ++y
)
557 for (x
= 0; x
< ximg
->width
; ++x
)
559 xp
= x
!= ximg
->width
- 1 ? x
+ 1 : 0;
560 xm
= x
!= 0 ? x
- 1 : ximg
->width
- 1;
561 yp
= y
!= ximg
->height
- 1 ? y
+ 1 : 0;
562 ym
= y
!= 0 ? y
- 1 : ximg
->height
- 1;
563 if (XGetPixel (ximg
, x
, y
) == bg
564 && XGetPixel (ximg
, x
, yp
) == bg
565 && XGetPixel (ximg
, x
, ym
) == bg
566 && XGetPixel (ximg
, xp
, y
) == bg
567 && XGetPixel (ximg
, xp
, yp
) == bg
568 && XGetPixel (ximg
, xp
, ym
) == bg
569 && XGetPixel (ximg
, xm
, y
) == bg
570 && XGetPixel (ximg
, xm
, yp
) == bg
571 && XGetPixel (ximg
, xm
, ym
) == bg
)
572 XPutPixel (mask_img
, x
, y
, 0);
574 XPutPixel (mask_img
, x
, y
, 1);
578 xassert (interrupt_input_blocked
);
579 gc
= XCreateGC (FRAME_X_DISPLAY (f
), mask
, 0, NULL
);
580 XPutImage (FRAME_X_DISPLAY (f
), mask
, gc
, mask_img
, 0, 0, 0, 0,
582 XFreeGC (FRAME_X_DISPLAY (f
), gc
);
584 dpyinfo
->bitmaps
[id
- 1].have_mask
= 1;
585 dpyinfo
->bitmaps
[id
- 1].mask
= mask
;
587 XDestroyImage (ximg
);
588 x_destroy_x_image (mask_img
);
593 #endif /* HAVE_X_WINDOWS */
596 /***********************************************************************
598 ***********************************************************************/
600 /* Value is the number of elements of vector VECTOR. */
602 #define DIM(VECTOR) (sizeof (VECTOR) / sizeof *(VECTOR))
604 /* List of supported image types. Use define_image_type to add new
605 types. Use lookup_image_type to find a type for a given symbol. */
607 static struct image_type
*image_types
;
609 /* A list of symbols, one for each supported image type. */
611 Lisp_Object Vimage_types
;
613 /* Cache for delayed-loading image types. */
615 static Lisp_Object Vimage_type_cache
;
617 /* The symbol `xbm' which is used as the type symbol for XBM images. */
623 extern Lisp_Object QCwidth
, QCheight
, QCforeground
, QCbackground
, QCfile
;
624 extern Lisp_Object QCdata
, QCtype
;
625 extern Lisp_Object Qcenter
;
626 Lisp_Object QCascent
, QCmargin
, QCrelief
;
627 Lisp_Object QCconversion
, QCcolor_symbols
, QCheuristic_mask
;
628 Lisp_Object QCindex
, QCmatrix
, QCcolor_adjustment
, QCmask
;
632 Lisp_Object Qlaplace
, Qemboss
, Qedge_detection
, Qheuristic
;
634 /* Time in seconds after which images should be removed from the cache
637 Lisp_Object Vimage_cache_eviction_delay
;
639 /* Function prototypes. */
641 static Lisp_Object define_image_type
P_ ((struct image_type
*type
, int loaded
));
642 static struct image_type
*lookup_image_type
P_ ((Lisp_Object symbol
));
643 static void image_error
P_ ((char *format
, Lisp_Object
, Lisp_Object
));
644 static void x_laplace
P_ ((struct frame
*, struct image
*));
645 static void x_emboss
P_ ((struct frame
*, struct image
*));
646 static int x_build_heuristic_mask
P_ ((struct frame
*, struct image
*,
649 #define CACHE_IMAGE_TYPE(type, status) \
650 do { Vimage_type_cache = Fcons (Fcons (type, status), Vimage_type_cache); } while (0)
652 #define ADD_IMAGE_TYPE(type) \
653 do { Vimage_types = Fcons (type, Vimage_types); } while (0)
655 /* Define a new image type from TYPE. This adds a copy of TYPE to
656 image_types and caches the loading status of TYPE. */
659 define_image_type (type
, loaded
)
660 struct image_type
*type
;
669 /* Make a copy of TYPE to avoid a bus error in a dumped Emacs.
670 The initialized data segment is read-only. */
671 struct image_type
*p
= (struct image_type
*) xmalloc (sizeof *p
);
672 bcopy (type
, p
, sizeof *p
);
673 p
->next
= image_types
;
678 CACHE_IMAGE_TYPE (*type
->type
, success
);
683 /* Look up image type SYMBOL, and return a pointer to its image_type
684 structure. Value is null if SYMBOL is not a known image type. */
686 static INLINE
struct image_type
*
687 lookup_image_type (symbol
)
690 struct image_type
*type
;
692 /* We must initialize the image-type if it hasn't been already. */
693 if (NILP (Finit_image_library (symbol
, Qnil
)))
694 return 0; /* unimplemented */
696 for (type
= image_types
; type
; type
= type
->next
)
697 if (EQ (symbol
, *type
->type
))
704 /* Value is non-zero if OBJECT is a valid Lisp image specification. A
705 valid image specification is a list whose car is the symbol
706 `image', and whose rest is a property list. The property list must
707 contain a value for key `:type'. That value must be the name of a
708 supported image type. The rest of the property list depends on the
712 valid_image_p (object
)
721 for (tem
= XCDR (object
); CONSP (tem
); tem
= XCDR (tem
))
722 if (EQ (XCAR (tem
), QCtype
))
725 if (CONSP (tem
) && SYMBOLP (XCAR (tem
)))
727 struct image_type
*type
;
728 type
= lookup_image_type (XCAR (tem
));
730 valid_p
= type
->valid_p (object
);
741 /* Log error message with format string FORMAT and argument ARG.
742 Signaling an error, e.g. when an image cannot be loaded, is not a
743 good idea because this would interrupt redisplay, and the error
744 message display would lead to another redisplay. This function
745 therefore simply displays a message. */
748 image_error (format
, arg1
, arg2
)
750 Lisp_Object arg1
, arg2
;
752 add_to_log (format
, arg1
, arg2
);
757 /***********************************************************************
759 ***********************************************************************/
761 enum image_value_type
763 IMAGE_DONT_CHECK_VALUE_TYPE
,
765 IMAGE_STRING_OR_NIL_VALUE
,
767 IMAGE_POSITIVE_INTEGER_VALUE
,
768 IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
,
769 IMAGE_NON_NEGATIVE_INTEGER_VALUE
,
772 IMAGE_FUNCTION_VALUE
,
777 /* Structure used when parsing image specifications. */
781 /* Name of keyword. */
784 /* The type of value allowed. */
785 enum image_value_type type
;
787 /* Non-zero means key must be present. */
790 /* Used to recognize duplicate keywords in a property list. */
793 /* The value that was found. */
798 static int parse_image_spec
P_ ((Lisp_Object
, struct image_keyword
*,
800 static Lisp_Object image_spec_value
P_ ((Lisp_Object
, Lisp_Object
, int *));
803 /* Parse image spec SPEC according to KEYWORDS. A valid image spec
804 has the format (image KEYWORD VALUE ...). One of the keyword/
805 value pairs must be `:type TYPE'. KEYWORDS is a vector of
806 image_keywords structures of size NKEYWORDS describing other
807 allowed keyword/value pairs. Value is non-zero if SPEC is valid. */
810 parse_image_spec (spec
, keywords
, nkeywords
, type
)
812 struct image_keyword
*keywords
;
823 while (CONSP (plist
))
825 Lisp_Object key
, value
;
827 /* First element of a pair must be a symbol. */
829 plist
= XCDR (plist
);
833 /* There must follow a value. */
836 value
= XCAR (plist
);
837 plist
= XCDR (plist
);
839 /* Find key in KEYWORDS. Error if not found. */
840 for (i
= 0; i
< nkeywords
; ++i
)
841 if (strcmp (keywords
[i
].name
, SDATA (SYMBOL_NAME (key
))) == 0)
847 /* Record that we recognized the keyword. If a keywords
848 was found more than once, it's an error. */
849 keywords
[i
].value
= value
;
852 if (keywords
[i
].count
> 1)
855 /* Check type of value against allowed type. */
856 switch (keywords
[i
].type
)
858 case IMAGE_STRING_VALUE
:
859 if (!STRINGP (value
))
863 case IMAGE_STRING_OR_NIL_VALUE
:
864 if (!STRINGP (value
) && !NILP (value
))
868 case IMAGE_SYMBOL_VALUE
:
869 if (!SYMBOLP (value
))
873 case IMAGE_POSITIVE_INTEGER_VALUE
:
874 if (!INTEGERP (value
) || XINT (value
) <= 0)
878 case IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
:
879 if (INTEGERP (value
) && XINT (value
) >= 0)
882 && INTEGERP (XCAR (value
)) && INTEGERP (XCDR (value
))
883 && XINT (XCAR (value
)) >= 0 && XINT (XCDR (value
)) >= 0)
887 case IMAGE_ASCENT_VALUE
:
888 if (SYMBOLP (value
) && EQ (value
, Qcenter
))
890 else if (INTEGERP (value
)
892 && XINT (value
) <= 100)
896 case IMAGE_NON_NEGATIVE_INTEGER_VALUE
:
897 if (!INTEGERP (value
) || XINT (value
) < 0)
901 case IMAGE_DONT_CHECK_VALUE_TYPE
:
904 case IMAGE_FUNCTION_VALUE
:
905 value
= indirect_function (value
);
908 || (CONSP (value
) && EQ (XCAR (value
), Qlambda
)))
912 case IMAGE_NUMBER_VALUE
:
913 if (!INTEGERP (value
) && !FLOATP (value
))
917 case IMAGE_INTEGER_VALUE
:
918 if (!INTEGERP (value
))
922 case IMAGE_BOOL_VALUE
:
923 if (!NILP (value
) && !EQ (value
, Qt
))
932 if (EQ (key
, QCtype
) && !EQ (type
, value
))
936 /* Check that all mandatory fields are present. */
937 for (i
= 0; i
< nkeywords
; ++i
)
938 if (keywords
[i
].mandatory_p
&& keywords
[i
].count
== 0)
945 /* Return the value of KEY in image specification SPEC. Value is nil
946 if KEY is not present in SPEC. if FOUND is not null, set *FOUND
947 to 1 if KEY was found in SPEC, set it to 0 otherwise. */
950 image_spec_value (spec
, key
, found
)
951 Lisp_Object spec
, key
;
956 xassert (valid_image_p (spec
));
958 for (tail
= XCDR (spec
);
959 CONSP (tail
) && CONSP (XCDR (tail
));
960 tail
= XCDR (XCDR (tail
)))
962 if (EQ (XCAR (tail
), key
))
966 return XCAR (XCDR (tail
));
976 DEFUN ("image-size", Fimage_size
, Simage_size
, 1, 3, 0,
977 doc
: /* Return the size of image SPEC as pair (WIDTH . HEIGHT).
978 PIXELS non-nil means return the size in pixels, otherwise return the
979 size in canonical character units.
980 FRAME is the frame on which the image will be displayed. FRAME nil
981 or omitted means use the selected frame. */)
982 (spec
, pixels
, frame
)
983 Lisp_Object spec
, pixels
, frame
;
988 if (valid_image_p (spec
))
990 struct frame
*f
= check_x_frame (frame
);
991 int id
= lookup_image (f
, spec
);
992 struct image
*img
= IMAGE_FROM_ID (f
, id
);
993 int width
= img
->width
+ 2 * img
->hmargin
;
994 int height
= img
->height
+ 2 * img
->vmargin
;
997 size
= Fcons (make_float ((double) width
/ FRAME_COLUMN_WIDTH (f
)),
998 make_float ((double) height
/ FRAME_LINE_HEIGHT (f
)));
1000 size
= Fcons (make_number (width
), make_number (height
));
1003 error ("Invalid image specification");
1009 DEFUN ("image-mask-p", Fimage_mask_p
, Simage_mask_p
, 1, 2, 0,
1010 doc
: /* Return t if image SPEC has a mask bitmap.
1011 FRAME is the frame on which the image will be displayed. FRAME nil
1012 or omitted means use the selected frame. */)
1014 Lisp_Object spec
, frame
;
1019 if (valid_image_p (spec
))
1021 struct frame
*f
= check_x_frame (frame
);
1022 int id
= lookup_image (f
, spec
);
1023 struct image
*img
= IMAGE_FROM_ID (f
, id
);
1028 error ("Invalid image specification");
1034 /***********************************************************************
1035 Image type independent image structures
1036 ***********************************************************************/
1038 static struct image
*make_image
P_ ((Lisp_Object spec
, unsigned hash
));
1039 static void free_image
P_ ((struct frame
*f
, struct image
*img
));
1042 /* Allocate and return a new image structure for image specification
1043 SPEC. SPEC has a hash value of HASH. */
1045 static struct image
*
1046 make_image (spec
, hash
)
1050 struct image
*img
= (struct image
*) xmalloc (sizeof *img
);
1052 xassert (valid_image_p (spec
));
1053 bzero (img
, sizeof *img
);
1054 img
->type
= lookup_image_type (image_spec_value (spec
, QCtype
, NULL
));
1055 xassert (img
->type
!= NULL
);
1057 img
->data
.lisp_val
= Qnil
;
1058 img
->ascent
= DEFAULT_IMAGE_ASCENT
;
1064 /* Free image IMG which was used on frame F, including its resources. */
1073 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
1075 /* Remove IMG from the hash table of its cache. */
1077 img
->prev
->next
= img
->next
;
1079 c
->buckets
[img
->hash
% IMAGE_CACHE_BUCKETS_SIZE
] = img
->next
;
1082 img
->next
->prev
= img
->prev
;
1084 c
->images
[img
->id
] = NULL
;
1086 /* Free resources, then free IMG. */
1087 img
->type
->free (f
, img
);
1093 /* Prepare image IMG for display on frame F. Must be called before
1094 drawing an image. */
1097 prepare_image_for_display (f
, img
)
1103 /* We're about to display IMG, so set its timestamp to `now'. */
1105 img
->timestamp
= EMACS_SECS (t
);
1107 /* If IMG doesn't have a pixmap yet, load it now, using the image
1108 type dependent loader function. */
1109 if (img
->pixmap
== NO_PIXMAP
&& !img
->load_failed_p
)
1110 img
->load_failed_p
= img
->type
->load (f
, img
) == 0;
1114 /* Value is the number of pixels for the ascent of image IMG when
1115 drawn in face FACE. */
1118 image_ascent (img
, face
, slice
)
1121 struct glyph_slice
*slice
;
1126 if (slice
->height
== img
->height
)
1127 height
= img
->height
+ img
->vmargin
;
1128 else if (slice
->y
== 0)
1129 height
= slice
->height
+ img
->vmargin
;
1131 height
= slice
->height
;
1133 if (img
->ascent
== CENTERED_IMAGE_ASCENT
)
1138 /* W32 specific version. Why?. ++kfs */
1139 ascent
= height
/ 2 - (FONT_DESCENT(face
->font
)
1140 - FONT_BASE(face
->font
)) / 2;
1142 /* This expression is arranged so that if the image can't be
1143 exactly centered, it will be moved slightly up. This is
1144 because a typical font is `top-heavy' (due to the presence
1145 uppercase letters), so the image placement should err towards
1146 being top-heavy too. It also just generally looks better. */
1147 ascent
= (height
+ face
->font
->ascent
- face
->font
->descent
+ 1) / 2;
1148 #endif /* HAVE_NTGUI */
1151 ascent
= height
/ 2;
1154 ascent
= (int) (height
* img
->ascent
/ 100.0);
1160 /* Image background colors. */
1162 /* Find the "best" corner color of a bitmap.
1163 On W32, XIMG is assumed to a device context with the bitmap selected. */
1165 static RGB_PIXEL_COLOR
1166 four_corners_best (ximg
, width
, height
)
1167 XImagePtr_or_DC ximg
;
1168 unsigned long width
, height
;
1170 RGB_PIXEL_COLOR corners
[4], best
;
1173 /* Get the colors at the corners of ximg. */
1174 corners
[0] = GET_PIXEL (ximg
, 0, 0);
1175 corners
[1] = GET_PIXEL (ximg
, width
- 1, 0);
1176 corners
[2] = GET_PIXEL (ximg
, width
- 1, height
- 1);
1177 corners
[3] = GET_PIXEL (ximg
, 0, height
- 1);
1179 /* Choose the most frequently found color as background. */
1180 for (i
= best_count
= 0; i
< 4; ++i
)
1184 for (j
= n
= 0; j
< 4; ++j
)
1185 if (corners
[i
] == corners
[j
])
1189 best
= corners
[i
], best_count
= n
;
1195 /* Portability macros */
1199 #define Destroy_Image(img_dc, prev) \
1200 do { SelectObject (img_dc, prev); DeleteDC (img_dc); } while (0)
1202 #define Free_Pixmap(display, pixmap) \
1203 DeleteObject (pixmap)
1207 #define Destroy_Image(ximg, dummy) \
1208 XDestroyImage (ximg)
1210 #define Free_Pixmap(display, pixmap) \
1211 XFreePixmap (display, pixmap)
1213 #endif /* HAVE_NTGUI */
1216 /* Return the `background' field of IMG. If IMG doesn't have one yet,
1217 it is guessed heuristically. If non-zero, XIMG is an existing
1218 XImage object (or device context with the image selected on W32) to
1219 use for the heuristic. */
1222 image_background (img
, f
, ximg
)
1225 XImagePtr_or_DC ximg
;
1227 if (! img
->background_valid
)
1228 /* IMG doesn't have a background yet, try to guess a reasonable value. */
1230 int free_ximg
= !ximg
;
1233 #endif /* HAVE_NTGUI */
1238 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
1239 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
1241 HDC frame_dc
= get_frame_dc (f
);
1242 ximg
= CreateCompatibleDC (frame_dc
);
1243 release_frame_dc (f
, frame_dc
);
1244 prev
= SelectObject (ximg
, img
->pixmap
);
1245 #endif /* !HAVE_NTGUI */
1248 img
->background
= four_corners_best (ximg
, img
->width
, img
->height
);
1251 Destroy_Image (ximg
, prev
);
1253 img
->background_valid
= 1;
1256 return img
->background
;
1259 /* Return the `background_transparent' field of IMG. If IMG doesn't
1260 have one yet, it is guessed heuristically. If non-zero, MASK is an
1261 existing XImage object to use for the heuristic. */
1264 image_background_transparent (img
, f
, mask
)
1267 XImagePtr_or_DC mask
;
1269 if (! img
->background_transparent_valid
)
1270 /* IMG doesn't have a background yet, try to guess a reasonable value. */
1274 int free_mask
= !mask
;
1277 #endif /* HAVE_NTGUI */
1282 mask
= XGetImage (FRAME_X_DISPLAY (f
), img
->mask
,
1283 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
1285 HDC frame_dc
= get_frame_dc (f
);
1286 mask
= CreateCompatibleDC (frame_dc
);
1287 release_frame_dc (f
, frame_dc
);
1288 prev
= SelectObject (mask
, img
->mask
);
1289 #endif /* HAVE_NTGUI */
1292 img
->background_transparent
1293 = (four_corners_best (mask
, img
->width
, img
->height
) == PIX_MASK_RETAIN (f
));
1296 Destroy_Image (mask
, prev
);
1299 img
->background_transparent
= 0;
1301 img
->background_transparent_valid
= 1;
1304 return img
->background_transparent
;
1308 /***********************************************************************
1309 Helper functions for X image types
1310 ***********************************************************************/
1312 static void x_clear_image_1
P_ ((struct frame
*, struct image
*, int,
1314 static void x_clear_image
P_ ((struct frame
*f
, struct image
*img
));
1315 static unsigned long x_alloc_image_color
P_ ((struct frame
*f
,
1317 Lisp_Object color_name
,
1318 unsigned long dflt
));
1321 /* Clear X resources of image IMG on frame F. PIXMAP_P non-zero means
1322 free the pixmap if any. MASK_P non-zero means clear the mask
1323 pixmap if any. COLORS_P non-zero means free colors allocated for
1324 the image, if any. */
1327 x_clear_image_1 (f
, img
, pixmap_p
, mask_p
, colors_p
)
1330 int pixmap_p
, mask_p
, colors_p
;
1332 if (pixmap_p
&& img
->pixmap
)
1334 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->pixmap
);
1335 img
->pixmap
= NO_PIXMAP
;
1336 img
->background_valid
= 0;
1339 if (mask_p
&& img
->mask
)
1341 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
1342 img
->mask
= NO_PIXMAP
;
1343 img
->background_transparent_valid
= 0;
1346 if (colors_p
&& img
->ncolors
)
1348 /* MAC_TODO: color table support. */
1349 /* W32_TODO: color table support. */
1350 #ifdef HAVE_X_WINDOWS
1351 x_free_colors (f
, img
->colors
, img
->ncolors
);
1352 #endif /* HAVE_X_WINDOWS */
1353 xfree (img
->colors
);
1359 /* Free X resources of image IMG which is used on frame F. */
1362 x_clear_image (f
, img
)
1367 x_clear_image_1 (f
, img
, 1, 1, 1);
1372 /* Allocate color COLOR_NAME for image IMG on frame F. If color
1373 cannot be allocated, use DFLT. Add a newly allocated color to
1374 IMG->colors, so that it can be freed again. Value is the pixel
1377 static unsigned long
1378 x_alloc_image_color (f
, img
, color_name
, dflt
)
1381 Lisp_Object color_name
;
1385 unsigned long result
;
1387 xassert (STRINGP (color_name
));
1389 if (x_defined_color (f
, SDATA (color_name
), &color
, 1))
1391 /* This isn't called frequently so we get away with simply
1392 reallocating the color vector to the needed size, here. */
1395 (unsigned long *) xrealloc (img
->colors
,
1396 img
->ncolors
* sizeof *img
->colors
);
1397 img
->colors
[img
->ncolors
- 1] = color
.pixel
;
1398 result
= color
.pixel
;
1408 /***********************************************************************
1410 ***********************************************************************/
1412 static void cache_image
P_ ((struct frame
*f
, struct image
*img
));
1413 static void postprocess_image
P_ ((struct frame
*, struct image
*));
1415 /* Return a new, initialized image cache that is allocated from the
1416 heap. Call free_image_cache to free an image cache. */
1418 struct image_cache
*
1421 struct image_cache
*c
= (struct image_cache
*) xmalloc (sizeof *c
);
1424 bzero (c
, sizeof *c
);
1426 c
->images
= (struct image
**) xmalloc (c
->size
* sizeof *c
->images
);
1427 size
= IMAGE_CACHE_BUCKETS_SIZE
* sizeof *c
->buckets
;
1428 c
->buckets
= (struct image
**) xmalloc (size
);
1429 bzero (c
->buckets
, size
);
1434 /* Free image cache of frame F. Be aware that X frames share images
1438 free_image_cache (f
)
1441 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
1446 /* Cache should not be referenced by any frame when freed. */
1447 xassert (c
->refcount
== 0);
1449 for (i
= 0; i
< c
->used
; ++i
)
1450 free_image (f
, c
->images
[i
]);
1454 FRAME_X_IMAGE_CACHE (f
) = NULL
;
1459 /* Clear image cache of frame F. FORCE_P non-zero means free all
1460 images. FORCE_P zero means clear only images that haven't been
1461 displayed for some time. Should be called from time to time to
1462 reduce the number of loaded images. If image-eviction-seconds is
1463 non-nil, this frees images in the cache which weren't displayed for
1464 at least that many seconds. */
1467 clear_image_cache (f
, force_p
)
1471 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
1473 if (c
&& INTEGERP (Vimage_cache_eviction_delay
))
1480 old
= EMACS_SECS (t
) - XFASTINT (Vimage_cache_eviction_delay
);
1482 /* Block input so that we won't be interrupted by a SIGIO
1483 while being in an inconsistent state. */
1486 for (i
= nfreed
= 0; i
< c
->used
; ++i
)
1488 struct image
*img
= c
->images
[i
];
1490 && (force_p
|| img
->timestamp
< old
))
1492 free_image (f
, img
);
1497 /* We may be clearing the image cache because, for example,
1498 Emacs was iconified for a longer period of time. In that
1499 case, current matrices may still contain references to
1500 images freed above. So, clear these matrices. */
1503 Lisp_Object tail
, frame
;
1505 FOR_EACH_FRAME (tail
, frame
)
1507 struct frame
*f
= XFRAME (frame
);
1508 if (FRAME_WINDOW_P (f
)
1509 && FRAME_X_IMAGE_CACHE (f
) == c
)
1510 clear_current_matrices (f
);
1513 ++windows_or_buffers_changed
;
1521 DEFUN ("clear-image-cache", Fclear_image_cache
, Sclear_image_cache
,
1523 doc
: /* Clear the image cache of FRAME.
1524 FRAME nil or omitted means use the selected frame.
1525 FRAME t means clear the image caches of all frames. */)
1533 FOR_EACH_FRAME (tail
, frame
)
1534 if (FRAME_WINDOW_P (XFRAME (frame
)))
1535 clear_image_cache (XFRAME (frame
), 1);
1538 clear_image_cache (check_x_frame (frame
), 1);
1544 /* Compute masks and transform image IMG on frame F, as specified
1545 by the image's specification, */
1548 postprocess_image (f
, img
)
1552 /* Manipulation of the image's mask. */
1555 Lisp_Object conversion
, spec
;
1560 /* `:heuristic-mask t'
1562 means build a mask heuristically.
1563 `:heuristic-mask (R G B)'
1564 `:mask (heuristic (R G B))'
1565 means build a mask from color (R G B) in the
1568 means remove a mask, if any. */
1570 mask
= image_spec_value (spec
, QCheuristic_mask
, NULL
);
1572 x_build_heuristic_mask (f
, img
, mask
);
1577 mask
= image_spec_value (spec
, QCmask
, &found_p
);
1579 if (EQ (mask
, Qheuristic
))
1580 x_build_heuristic_mask (f
, img
, Qt
);
1581 else if (CONSP (mask
)
1582 && EQ (XCAR (mask
), Qheuristic
))
1584 if (CONSP (XCDR (mask
)))
1585 x_build_heuristic_mask (f
, img
, XCAR (XCDR (mask
)));
1587 x_build_heuristic_mask (f
, img
, XCDR (mask
));
1589 else if (NILP (mask
) && found_p
&& img
->mask
)
1591 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
1592 img
->mask
= NO_PIXMAP
;
1597 /* Should we apply an image transformation algorithm? */
1598 conversion
= image_spec_value (spec
, QCconversion
, NULL
);
1599 if (EQ (conversion
, Qdisabled
))
1600 x_disable_image (f
, img
);
1601 else if (EQ (conversion
, Qlaplace
))
1603 else if (EQ (conversion
, Qemboss
))
1605 else if (CONSP (conversion
)
1606 && EQ (XCAR (conversion
), Qedge_detection
))
1609 tem
= XCDR (conversion
);
1611 x_edge_detection (f
, img
,
1612 Fplist_get (tem
, QCmatrix
),
1613 Fplist_get (tem
, QCcolor_adjustment
));
1619 /* Return the id of image with Lisp specification SPEC on frame F.
1620 SPEC must be a valid Lisp image specification (see valid_image_p). */
1623 lookup_image (f
, spec
)
1627 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
1629 /* Work around a problem with MinGW builds of graphics libraries
1630 not honoring calling conventions. */
1636 struct gcpro gcpro1
;
1639 /* F must be a window-system frame, and SPEC must be a valid image
1641 xassert (FRAME_WINDOW_P (f
));
1642 xassert (valid_image_p (spec
));
1646 /* Look up SPEC in the hash table of the image cache. */
1647 hash
= sxhash (spec
, 0);
1648 i
= hash
% IMAGE_CACHE_BUCKETS_SIZE
;
1650 for (img
= c
->buckets
[i
]; img
; img
= img
->next
)
1651 if (img
->hash
== hash
&& !NILP (Fequal (img
->spec
, spec
)))
1654 /* If not found, create a new image and cache it. */
1657 extern Lisp_Object Qpostscript
;
1660 img
= make_image (spec
, hash
);
1661 cache_image (f
, img
);
1662 img
->load_failed_p
= img
->type
->load (f
, img
) == 0;
1664 /* If we can't load the image, and we don't have a width and
1665 height, use some arbitrary width and height so that we can
1666 draw a rectangle for it. */
1667 if (img
->load_failed_p
)
1671 value
= image_spec_value (spec
, QCwidth
, NULL
);
1672 img
->width
= (INTEGERP (value
)
1673 ? XFASTINT (value
) : DEFAULT_IMAGE_WIDTH
);
1674 value
= image_spec_value (spec
, QCheight
, NULL
);
1675 img
->height
= (INTEGERP (value
)
1676 ? XFASTINT (value
) : DEFAULT_IMAGE_HEIGHT
);
1680 /* Handle image type independent image attributes
1681 `:ascent ASCENT', `:margin MARGIN', `:relief RELIEF',
1682 `:background COLOR'. */
1683 Lisp_Object ascent
, margin
, relief
, bg
;
1685 ascent
= image_spec_value (spec
, QCascent
, NULL
);
1686 if (INTEGERP (ascent
))
1687 img
->ascent
= XFASTINT (ascent
);
1688 else if (EQ (ascent
, Qcenter
))
1689 img
->ascent
= CENTERED_IMAGE_ASCENT
;
1691 margin
= image_spec_value (spec
, QCmargin
, NULL
);
1692 if (INTEGERP (margin
) && XINT (margin
) >= 0)
1693 img
->vmargin
= img
->hmargin
= XFASTINT (margin
);
1694 else if (CONSP (margin
) && INTEGERP (XCAR (margin
))
1695 && INTEGERP (XCDR (margin
)))
1697 if (XINT (XCAR (margin
)) > 0)
1698 img
->hmargin
= XFASTINT (XCAR (margin
));
1699 if (XINT (XCDR (margin
)) > 0)
1700 img
->vmargin
= XFASTINT (XCDR (margin
));
1703 relief
= image_spec_value (spec
, QCrelief
, NULL
);
1704 if (INTEGERP (relief
))
1706 img
->relief
= XINT (relief
);
1707 img
->hmargin
+= abs (img
->relief
);
1708 img
->vmargin
+= abs (img
->relief
);
1711 if (! img
->background_valid
)
1713 bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
1717 = x_alloc_image_color (f
, img
, bg
,
1718 FRAME_BACKGROUND_PIXEL (f
));
1719 img
->background_valid
= 1;
1723 /* Do image transformations and compute masks, unless we
1724 don't have the image yet. */
1725 if (!EQ (*img
->type
->type
, Qpostscript
))
1726 postprocess_image (f
, img
);
1732 /* We're using IMG, so set its timestamp to `now'. */
1733 EMACS_GET_TIME (now
);
1734 img
->timestamp
= EMACS_SECS (now
);
1738 /* Value is the image id. */
1743 /* Cache image IMG in the image cache of frame F. */
1746 cache_image (f
, img
)
1750 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
1753 /* Find a free slot in c->images. */
1754 for (i
= 0; i
< c
->used
; ++i
)
1755 if (c
->images
[i
] == NULL
)
1758 /* If no free slot found, maybe enlarge c->images. */
1759 if (i
== c
->used
&& c
->used
== c
->size
)
1762 c
->images
= (struct image
**) xrealloc (c
->images
,
1763 c
->size
* sizeof *c
->images
);
1766 /* Add IMG to c->images, and assign IMG an id. */
1772 /* Add IMG to the cache's hash table. */
1773 i
= img
->hash
% IMAGE_CACHE_BUCKETS_SIZE
;
1774 img
->next
= c
->buckets
[i
];
1776 img
->next
->prev
= img
;
1778 c
->buckets
[i
] = img
;
1782 /* Call FN on every image in the image cache of frame F. Used to mark
1783 Lisp Objects in the image cache. */
1786 forall_images_in_image_cache (f
, fn
)
1788 void (*fn
) P_ ((struct image
*img
));
1790 if (FRAME_LIVE_P (f
) && FRAME_WINDOW_P (f
))
1792 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
1796 for (i
= 0; i
< c
->used
; ++i
)
1805 /***********************************************************************
1806 X / MAC / W32 support code
1807 ***********************************************************************/
1811 /* Macro for defining functions that will be loaded from image DLLs. */
1812 #define DEF_IMGLIB_FN(func) FARPROC fn_##func
1814 /* Macro for loading those image functions from the library. */
1815 #define LOAD_IMGLIB_FN(lib,func) { \
1816 fn_##func = (void *) GetProcAddress (lib, #func); \
1817 if (!fn_##func) return 0; \
1820 /* Load a DLL implementing an image type.
1821 The `image-library-alist' variable associates a symbol,
1822 identifying an image type, to a list of possible filenames.
1823 The function returns NULL if no library could be loaded for
1824 the given image type, or if the library was previously loaded;
1825 else the handle of the DLL. */
1827 w32_delayed_load (Lisp_Object libraries
, Lisp_Object type
)
1829 HMODULE library
= NULL
;
1831 if (CONSP (libraries
) && NILP (Fassq (type
, Vimage_type_cache
)))
1833 Lisp_Object dlls
= Fassq (type
, libraries
);
1836 for (dlls
= XCDR (dlls
); CONSP (dlls
); dlls
= XCDR (dlls
))
1838 CHECK_STRING_CAR (dlls
);
1839 if (library
= LoadLibrary (SDATA (XCAR (dlls
))))
1847 #endif /* HAVE_NTGUI */
1849 static int x_create_x_image_and_pixmap
P_ ((struct frame
*, int, int, int,
1850 XImagePtr
*, Pixmap
*));
1851 static void x_destroy_x_image
P_ ((XImagePtr
));
1852 static void x_put_x_image
P_ ((struct frame
*, XImagePtr
, Pixmap
, int, int));
1855 /* Create an XImage and a pixmap of size WIDTH x HEIGHT for use on
1856 frame F. Set *XIMG and *PIXMAP to the XImage and Pixmap created.
1857 Set (*XIMG)->data to a raster of WIDTH x HEIGHT pixels allocated
1858 via xmalloc. Print error messages via image_error if an error
1859 occurs. Value is non-zero if successful.
1861 On W32, a DEPTH of zero signifies a 24 bit image, otherwise DEPTH
1862 should indicate the bit depth of the image. */
1865 x_create_x_image_and_pixmap (f
, width
, height
, depth
, ximg
, pixmap
)
1867 int width
, height
, depth
;
1871 #ifdef HAVE_X_WINDOWS
1872 Display
*display
= FRAME_X_DISPLAY (f
);
1873 Window window
= FRAME_X_WINDOW (f
);
1874 Screen
*screen
= FRAME_X_SCREEN (f
);
1876 xassert (interrupt_input_blocked
);
1879 depth
= DefaultDepthOfScreen (screen
);
1880 *ximg
= XCreateImage (display
, DefaultVisualOfScreen (screen
),
1881 depth
, ZPixmap
, 0, NULL
, width
, height
,
1882 depth
> 16 ? 32 : depth
> 8 ? 16 : 8, 0);
1885 image_error ("Unable to allocate X image", Qnil
, Qnil
);
1889 /* Allocate image raster. */
1890 (*ximg
)->data
= (char *) xmalloc ((*ximg
)->bytes_per_line
* height
);
1892 /* Allocate a pixmap of the same size. */
1893 *pixmap
= XCreatePixmap (display
, window
, width
, height
, depth
);
1894 if (*pixmap
== NO_PIXMAP
)
1896 x_destroy_x_image (*ximg
);
1898 image_error ("Unable to create X pixmap", Qnil
, Qnil
);
1903 #endif /* HAVE_X_WINDOWS */
1907 BITMAPINFOHEADER
*header
;
1909 int scanline_width_bits
;
1911 int palette_colors
= 0;
1916 if (depth
!= 1 && depth
!= 4 && depth
!= 8
1917 && depth
!= 16 && depth
!= 24 && depth
!= 32)
1919 image_error ("Invalid image bit depth specified", Qnil
, Qnil
);
1923 scanline_width_bits
= width
* depth
;
1924 remainder
= scanline_width_bits
% 32;
1927 scanline_width_bits
+= 32 - remainder
;
1929 /* Bitmaps with a depth less than 16 need a palette. */
1930 /* BITMAPINFO structure already contains the first RGBQUAD. */
1932 palette_colors
= 1 << depth
- 1;
1934 *ximg
= xmalloc (sizeof (XImage
) + palette_colors
* sizeof (RGBQUAD
));
1937 image_error ("Unable to allocate memory for XImage", Qnil
, Qnil
);
1941 header
= &((*ximg
)->info
.bmiHeader
);
1942 bzero (&((*ximg
)->info
), sizeof (BITMAPINFO
));
1943 header
->biSize
= sizeof (*header
);
1944 header
->biWidth
= width
;
1945 header
->biHeight
= -height
; /* negative indicates a top-down bitmap. */
1946 header
->biPlanes
= 1;
1947 header
->biBitCount
= depth
;
1948 header
->biCompression
= BI_RGB
;
1949 header
->biClrUsed
= palette_colors
;
1951 /* TODO: fill in palette. */
1954 (*ximg
)->info
.bmiColors
[0].rgbBlue
= 0;
1955 (*ximg
)->info
.bmiColors
[0].rgbGreen
= 0;
1956 (*ximg
)->info
.bmiColors
[0].rgbRed
= 0;
1957 (*ximg
)->info
.bmiColors
[0].rgbReserved
= 0;
1958 (*ximg
)->info
.bmiColors
[1].rgbBlue
= 255;
1959 (*ximg
)->info
.bmiColors
[1].rgbGreen
= 255;
1960 (*ximg
)->info
.bmiColors
[1].rgbRed
= 255;
1961 (*ximg
)->info
.bmiColors
[1].rgbReserved
= 0;
1964 hdc
= get_frame_dc (f
);
1966 /* Create a DIBSection and raster array for the bitmap,
1967 and store its handle in *pixmap. */
1968 *pixmap
= CreateDIBSection (hdc
, &((*ximg
)->info
),
1969 (depth
< 16) ? DIB_PAL_COLORS
: DIB_RGB_COLORS
,
1970 &((*ximg
)->data
), NULL
, 0);
1972 /* Realize display palette and garbage all frames. */
1973 release_frame_dc (f
, hdc
);
1975 if (*pixmap
== NULL
)
1977 DWORD err
= GetLastError();
1978 Lisp_Object errcode
;
1979 /* All system errors are < 10000, so the following is safe. */
1980 XSETINT (errcode
, (int) err
);
1981 image_error ("Unable to create bitmap, error code %d", errcode
, Qnil
);
1982 x_destroy_x_image (*ximg
);
1988 #endif /* HAVE_NTGUI */
1991 Display
*display
= FRAME_X_DISPLAY (f
);
1992 Window window
= FRAME_X_WINDOW (f
);
1994 xassert (interrupt_input_blocked
);
1996 /* Allocate a pixmap of the same size. */
1997 *pixmap
= XCreatePixmap (display
, window
, width
, height
, depth
);
1998 if (*pixmap
== NO_PIXMAP
)
2000 x_destroy_x_image (*ximg
);
2002 image_error ("Unable to create X pixmap", Qnil
, Qnil
);
2006 LockPixels (GetGWorldPixMap (*pixmap
));
2014 /* Destroy XImage XIMG. Free XIMG->data. */
2017 x_destroy_x_image (ximg
)
2020 xassert (interrupt_input_blocked
);
2023 #ifdef HAVE_X_WINDOWS
2026 XDestroyImage (ximg
);
2027 #endif /* HAVE_X_WINDOWS */
2029 /* Data will be freed by DestroyObject. */
2032 #endif /* HAVE_NTGUI */
2034 XDestroyImage (ximg
);
2040 /* Put XImage XIMG into pixmap PIXMAP on frame F. WIDTH and HEIGHT
2041 are width and height of both the image and pixmap. */
2044 x_put_x_image (f
, ximg
, pixmap
, width
, height
)
2050 #ifdef HAVE_X_WINDOWS
2053 xassert (interrupt_input_blocked
);
2054 gc
= XCreateGC (FRAME_X_DISPLAY (f
), pixmap
, 0, NULL
);
2055 XPutImage (FRAME_X_DISPLAY (f
), pixmap
, gc
, ximg
, 0, 0, 0, 0, width
, height
);
2056 XFreeGC (FRAME_X_DISPLAY (f
), gc
);
2057 #endif /* HAVE_X_WINDOWS */
2060 #if 0 /* I don't think this is necessary looking at where it is used. */
2061 HDC hdc
= get_frame_dc (f
);
2062 SetDIBits (hdc
, pixmap
, 0, height
, ximg
->data
, &(ximg
->info
), DIB_RGB_COLORS
);
2063 release_frame_dc (f
, hdc
);
2065 #endif /* HAVE_NTGUI */
2068 xassert (ximg
== pixmap
);
2073 /***********************************************************************
2075 ***********************************************************************/
2077 static unsigned char *slurp_file
P_ ((char *, int *));
2080 /* Find image file FILE. Look in data-directory, then
2081 x-bitmap-file-path. Value is the full name of the file found, or
2082 nil if not found. */
2085 x_find_image_file (file
)
2088 Lisp_Object file_found
, search_path
;
2089 struct gcpro gcpro1
, gcpro2
;
2093 search_path
= Fcons (Vdata_directory
, Vx_bitmap_file_path
);
2094 GCPRO2 (file_found
, search_path
);
2096 /* Try to find FILE in data-directory, then x-bitmap-file-path. */
2097 fd
= openp (search_path
, file
, Qnil
, &file_found
, Qnil
);
2109 /* Read FILE into memory. Value is a pointer to a buffer allocated
2110 with xmalloc holding FILE's contents. Value is null if an error
2111 occurred. *SIZE is set to the size of the file. */
2113 static unsigned char *
2114 slurp_file (file
, size
)
2119 unsigned char *buf
= NULL
;
2122 if (stat (file
, &st
) == 0
2123 && (fp
= fopen (file
, "rb")) != NULL
2124 && (buf
= (char *) xmalloc (st
.st_size
),
2125 fread (buf
, 1, st
.st_size
, fp
) == st
.st_size
))
2148 /***********************************************************************
2149 MAC Image Load Functions
2150 ***********************************************************************/
2152 static int image_load_quicktime
P_ ((struct frame
*, struct image
*img
,
2155 static int image_load_quartz2d
P_ ((struct frame
*, struct image
*img
, int));
2159 find_image_fsspec (specified_file
, file
, fss
)
2160 Lisp_Object specified_file
, *file
;
2163 #if TARGET_API_MAC_CARBON
2166 Str255 mac_pathname
;
2170 *file
= x_find_image_file (specified_file
);
2171 if (!STRINGP (*file
))
2172 return fnfErr
; /* file or directory not found;
2173 incomplete pathname */
2174 /* Try to open the image file. */
2175 #if TARGET_API_MAC_CARBON
2176 err
= FSPathMakeRef (SDATA (*file
), &fsr
, NULL
);
2178 err
= FSGetCatalogInfo (&fsr
, kFSCatInfoNone
, NULL
, NULL
, fss
, NULL
);
2180 if (posix_to_mac_pathname (SDATA (*file
), mac_pathname
, MAXPATHLEN
+1) == 0)
2182 c2pstr (mac_pathname
);
2183 err
= FSMakeFSSpec (0, 0, mac_pathname
, fss
);
2189 image_load_qt_1 (f
, img
, type
, fss
, dh
)
2197 GraphicsImportComponent gi
;
2200 short draw_all_pixels
;
2201 Lisp_Object specified_bg
;
2206 err
= OpenADefaultComponent (GraphicsImporterComponentType
,
2210 image_error ("Cannot get importer component for `%s'", img
->spec
, Qnil
);
2215 /* read from file system spec */
2216 err
= GraphicsImportSetDataFile (gi
, fss
);
2219 image_error ("Cannot set fsspec to graphics importer for '%s'",
2226 /* read from data handle */
2227 err
= GraphicsImportSetDataHandle (gi
, dh
);
2230 image_error ("Cannot set data handle to graphics importer for `%s'",
2235 err
= GraphicsImportGetNaturalBounds (gi
, &rect
);
2238 image_error ("Error reading `%s'", img
->spec
, Qnil
);
2241 width
= img
->width
= rect
.right
- rect
.left
;
2242 height
= img
->height
= rect
.bottom
- rect
.top
;
2243 err
= GraphicsImportDoesDrawAllPixels (gi
, &draw_all_pixels
);
2245 /* Don't check the error code here. It may have an undocumented
2249 image_error ("Error reading `%s'", img
->spec
, Qnil
);
2253 if (draw_all_pixels
!= graphicsImporterDrawsAllPixels
)
2255 specified_bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
2256 if (!STRINGP (specified_bg
) ||
2257 !mac_defined_color (f
, SDATA (specified_bg
), &color
, 0))
2259 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
2260 color
.red
= RED16_FROM_ULONG (color
.pixel
);
2261 color
.green
= GREEN16_FROM_ULONG (color
.pixel
);
2262 color
.blue
= BLUE16_FROM_ULONG (color
.pixel
);
2266 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
2268 if (draw_all_pixels
!= graphicsImporterDrawsAllPixels
)
2273 GetGWorld (&old_port
, &old_gdh
);
2274 SetGWorld (ximg
, NULL
);
2275 bg_color
.red
= color
.red
;
2276 bg_color
.green
= color
.green
;
2277 bg_color
.blue
= color
.blue
;
2278 RGBBackColor (&bg_color
);
2279 #if TARGET_API_MAC_CARBON
2280 GetPortBounds (ximg
, &rect
);
2283 EraseRect (&(ximg
->portRect
));
2285 SetGWorld (old_port
, old_gdh
);
2287 GraphicsImportSetGWorld (gi
, ximg
, NULL
);
2288 GraphicsImportDraw (gi
);
2289 CloseComponent (gi
);
2291 /* Maybe fill in the background field while we have ximg handy. */
2292 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
2293 IMAGE_BACKGROUND (img
, f
, ximg
);
2295 /* Put the image into the pixmap. */
2296 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
2297 x_destroy_x_image (ximg
);
2301 CloseComponent (gi
);
2306 /* Load an image using the QuickTime Graphics Importer.
2307 Note: The alpha channel does not work for PNG images. */
2309 image_load_quicktime (f
, img
, type
)
2314 Lisp_Object specified_file
;
2315 Lisp_Object specified_data
;
2318 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
2319 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
2321 if (NILP (specified_data
))
2323 /* Read from a file */
2327 err
= find_image_fsspec (specified_file
, &file
, &fss
);
2331 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
2333 image_error ("Cannot open `%s'", file
, Qnil
);
2336 return image_load_qt_1 (f
, img
, type
, &fss
, NULL
);
2340 /* Memory source! */
2344 err
= PtrToHand (SDATA (specified_data
), &dh
, SBYTES (specified_data
));
2347 image_error ("Cannot allocate data handle for `%s'",
2351 success_p
= image_load_qt_1 (f
, img
, type
, NULL
, dh
);
2359 /* Load a PNG/JPEG image using Quartz 2D decoding routines.
2360 CGImageCreateWithPNGDataProvider is provided after Mac OS X 10.2.
2361 So don't use this function directly but determine at runtime
2362 whether it exists. */
2363 typedef CGImageRef (*CGImageCreateWithPNGDataProviderProcType
)
2364 (CGDataProviderRef
, const float [], bool, CGColorRenderingIntent
);
2365 static CGImageCreateWithPNGDataProviderProcType MyCGImageCreateWithPNGDataProvider
;
2369 init_image_func_pointer ()
2371 if (NSIsSymbolNameDefined ("_CGImageCreateWithPNGDataProvider"))
2373 MyCGImageCreateWithPNGDataProvider
2374 = (CGImageCreateWithPNGDataProviderProcType
)
2375 NSAddressOfSymbol (NSLookupAndBindSymbol
2376 ("_CGImageCreateWithPNGDataProvider"));
2379 MyCGImageCreateWithPNGDataProvider
= NULL
;
2384 image_load_quartz2d (f
, img
, png_p
)
2389 Lisp_Object file
, specified_file
;
2390 Lisp_Object specified_data
, specified_bg
;
2391 struct gcpro gcpro1
;
2392 CGDataProviderRef source
;
2396 XImagePtr ximg
= NULL
;
2397 CGContextRef context
;
2400 /* Open the file. */
2401 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
2402 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
2407 if (NILP (specified_data
))
2412 file
= x_find_image_file (specified_file
);
2413 if (!STRINGP (file
))
2415 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
2419 path
= cfstring_create_with_utf8_cstring (SDATA (file
));
2420 url
= CFURLCreateWithFileSystemPath (NULL
, path
,
2421 kCFURLPOSIXPathStyle
, 0);
2423 source
= CGDataProviderCreateWithURL (url
);
2427 source
= CGDataProviderCreateWithData (NULL
, SDATA (specified_data
),
2428 SBYTES (specified_data
), NULL
);
2431 image
= (*MyCGImageCreateWithPNGDataProvider
) (source
, NULL
, FALSE
,
2432 kCGRenderingIntentDefault
);
2434 image
= CGImageCreateWithJPEGDataProvider (source
, NULL
, FALSE
,
2435 kCGRenderingIntentDefault
);
2437 CGDataProviderRelease (source
);
2441 image_error ("Error reading image `%s'", img
->spec
, Qnil
);
2447 specified_bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
2448 if (!STRINGP (specified_bg
) ||
2449 !mac_defined_color (f
, SDATA (specified_bg
), &color
, 0))
2451 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
2452 color
.red
= RED16_FROM_ULONG (color
.pixel
);
2453 color
.green
= GREEN16_FROM_ULONG (color
.pixel
);
2454 color
.blue
= BLUE16_FROM_ULONG (color
.pixel
);
2457 width
= img
->width
= CGImageGetWidth (image
);
2458 height
= img
->height
= CGImageGetHeight (image
);
2459 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
2461 CGImageRelease (image
);
2465 rectangle
= CGRectMake (0, 0, width
, height
);
2466 QDBeginCGContext (ximg
, &context
);
2469 CGContextSetRGBFillColor (context
, color
.red
/ 65535.0,
2470 color
.green
/ 65535.0,
2471 color
.blue
/ 65535.0, 1.0);
2472 CGContextFillRect (context
, rectangle
);
2474 CGContextDrawImage (context
, rectangle
, image
);
2475 QDEndCGContext (ximg
, &context
);
2476 CGImageRelease (image
);
2478 /* Maybe fill in the background field while we have ximg handy. */
2479 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
2480 IMAGE_BACKGROUND (img
, f
, ximg
);
2482 /* Put the image into the pixmap. */
2483 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
2484 x_destroy_x_image (ximg
);
2493 /***********************************************************************
2495 ***********************************************************************/
2497 static int xbm_scan
P_ ((unsigned char **, unsigned char *, char *, int *));
2498 static int xbm_load
P_ ((struct frame
*f
, struct image
*img
));
2499 static int xbm_load_image
P_ ((struct frame
*f
, struct image
*img
,
2500 unsigned char *, unsigned char *));
2501 static int xbm_image_p
P_ ((Lisp_Object object
));
2502 static int xbm_read_bitmap_data
P_ ((unsigned char *, unsigned char *,
2503 int *, int *, unsigned char **));
2504 static int xbm_file_p
P_ ((Lisp_Object
));
2507 /* Indices of image specification fields in xbm_format, below. */
2509 enum xbm_keyword_index
2527 /* Vector of image_keyword structures describing the format
2528 of valid XBM image specifications. */
2530 static struct image_keyword xbm_format
[XBM_LAST
] =
2532 {":type", IMAGE_SYMBOL_VALUE
, 1},
2533 {":file", IMAGE_STRING_VALUE
, 0},
2534 {":width", IMAGE_POSITIVE_INTEGER_VALUE
, 0},
2535 {":height", IMAGE_POSITIVE_INTEGER_VALUE
, 0},
2536 {":data", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
2537 {":foreground", IMAGE_STRING_OR_NIL_VALUE
, 0},
2538 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0},
2539 {":ascent", IMAGE_ASCENT_VALUE
, 0},
2540 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
2541 {":relief", IMAGE_INTEGER_VALUE
, 0},
2542 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
2543 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
2544 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0}
2547 /* Structure describing the image type XBM. */
2549 static struct image_type xbm_type
=
2558 /* Tokens returned from xbm_scan. */
2567 /* Return non-zero if OBJECT is a valid XBM-type image specification.
2568 A valid specification is a list starting with the symbol `image'
2569 The rest of the list is a property list which must contain an
2572 If the specification specifies a file to load, it must contain
2573 an entry `:file FILENAME' where FILENAME is a string.
2575 If the specification is for a bitmap loaded from memory it must
2576 contain `:width WIDTH', `:height HEIGHT', and `:data DATA', where
2577 WIDTH and HEIGHT are integers > 0. DATA may be:
2579 1. a string large enough to hold the bitmap data, i.e. it must
2580 have a size >= (WIDTH + 7) / 8 * HEIGHT
2582 2. a bool-vector of size >= WIDTH * HEIGHT
2584 3. a vector of strings or bool-vectors, one for each line of the
2587 4. A string containing an in-memory XBM file. WIDTH and HEIGHT
2588 may not be specified in this case because they are defined in the
2591 Both the file and data forms may contain the additional entries
2592 `:background COLOR' and `:foreground COLOR'. If not present,
2593 foreground and background of the frame on which the image is
2594 displayed is used. */
2597 xbm_image_p (object
)
2600 struct image_keyword kw
[XBM_LAST
];
2602 bcopy (xbm_format
, kw
, sizeof kw
);
2603 if (!parse_image_spec (object
, kw
, XBM_LAST
, Qxbm
))
2606 xassert (EQ (kw
[XBM_TYPE
].value
, Qxbm
));
2608 if (kw
[XBM_FILE
].count
)
2610 if (kw
[XBM_WIDTH
].count
|| kw
[XBM_HEIGHT
].count
|| kw
[XBM_DATA
].count
)
2613 else if (kw
[XBM_DATA
].count
&& xbm_file_p (kw
[XBM_DATA
].value
))
2615 /* In-memory XBM file. */
2616 if (kw
[XBM_WIDTH
].count
|| kw
[XBM_HEIGHT
].count
|| kw
[XBM_FILE
].count
)
2624 /* Entries for `:width', `:height' and `:data' must be present. */
2625 if (!kw
[XBM_WIDTH
].count
2626 || !kw
[XBM_HEIGHT
].count
2627 || !kw
[XBM_DATA
].count
)
2630 data
= kw
[XBM_DATA
].value
;
2631 width
= XFASTINT (kw
[XBM_WIDTH
].value
);
2632 height
= XFASTINT (kw
[XBM_HEIGHT
].value
);
2634 /* Check type of data, and width and height against contents of
2640 /* Number of elements of the vector must be >= height. */
2641 if (XVECTOR (data
)->size
< height
)
2644 /* Each string or bool-vector in data must be large enough
2645 for one line of the image. */
2646 for (i
= 0; i
< height
; ++i
)
2648 Lisp_Object elt
= XVECTOR (data
)->contents
[i
];
2653 < (width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
)
2656 else if (BOOL_VECTOR_P (elt
))
2658 if (XBOOL_VECTOR (elt
)->size
< width
)
2665 else if (STRINGP (data
))
2668 < (width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
* height
)
2671 else if (BOOL_VECTOR_P (data
))
2673 if (XBOOL_VECTOR (data
)->size
< width
* height
)
2684 /* Scan a bitmap file. FP is the stream to read from. Value is
2685 either an enumerator from enum xbm_token, or a character for a
2686 single-character token, or 0 at end of file. If scanning an
2687 identifier, store the lexeme of the identifier in SVAL. If
2688 scanning a number, store its value in *IVAL. */
2691 xbm_scan (s
, end
, sval
, ival
)
2692 unsigned char **s
, *end
;
2700 /* Skip white space. */
2701 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
2706 else if (isdigit (c
))
2708 int value
= 0, digit
;
2710 if (c
== '0' && *s
< end
)
2713 if (c
== 'x' || c
== 'X')
2720 else if (c
>= 'a' && c
<= 'f')
2721 digit
= c
- 'a' + 10;
2722 else if (c
>= 'A' && c
<= 'F')
2723 digit
= c
- 'A' + 10;
2726 value
= 16 * value
+ digit
;
2729 else if (isdigit (c
))
2733 && (c
= *(*s
)++, isdigit (c
)))
2734 value
= 8 * value
+ c
- '0';
2741 && (c
= *(*s
)++, isdigit (c
)))
2742 value
= 10 * value
+ c
- '0';
2750 else if (isalpha (c
) || c
== '_')
2754 && (c
= *(*s
)++, (isalnum (c
) || c
== '_')))
2761 else if (c
== '/' && **s
== '*')
2763 /* C-style comment. */
2765 while (**s
&& (**s
!= '*' || *(*s
+ 1) != '/'))
2779 /* Create a Windows bitmap from X bitmap data. */
2781 w32_create_pixmap_from_bitmap_data (int width
, int height
, char *data
)
2783 static unsigned char swap_nibble
[16]
2784 = { 0x0, 0x8, 0x4, 0xc, /* 0000 1000 0100 1100 */
2785 0x2, 0xa, 0x6, 0xe, /* 0010 1010 0110 1110 */
2786 0x1, 0x9, 0x5, 0xd, /* 0001 1001 0101 1101 */
2787 0x3, 0xb, 0x7, 0xf }; /* 0011 1011 0111 1111 */
2789 unsigned char *bits
, *p
;
2792 w1
= (width
+ 7) / 8; /* nb of 8bits elt in X bitmap */
2793 w2
= ((width
+ 15) / 16) * 2; /* nb of 16bits elt in W32 bitmap */
2794 bits
= (unsigned char *) alloca (height
* w2
);
2795 bzero (bits
, height
* w2
);
2796 for (i
= 0; i
< height
; i
++)
2799 for (j
= 0; j
< w1
; j
++)
2801 /* Bitswap XBM bytes to match how Windows does things. */
2802 unsigned char c
= *data
++;
2803 *p
++ = (unsigned char)((swap_nibble
[c
& 0xf] << 4)
2804 | (swap_nibble
[(c
>>4) & 0xf]));
2807 bmp
= CreateBitmap (width
, height
, 1, 1, (char *) bits
);
2812 static void convert_mono_to_color_image (f
, img
, foreground
, background
)
2815 COLORREF foreground
, background
;
2817 HDC hdc
, old_img_dc
, new_img_dc
;
2818 HGDIOBJ old_prev
, new_prev
;
2821 hdc
= get_frame_dc (f
);
2822 old_img_dc
= CreateCompatibleDC (hdc
);
2823 new_img_dc
= CreateCompatibleDC (hdc
);
2824 new_pixmap
= CreateCompatibleBitmap (hdc
, img
->width
, img
->height
);
2825 release_frame_dc (f
, hdc
);
2826 old_prev
= SelectObject (old_img_dc
, img
->pixmap
);
2827 new_prev
= SelectObject (new_img_dc
, new_pixmap
);
2828 SetTextColor (new_img_dc
, foreground
);
2829 SetBkColor (new_img_dc
, background
);
2831 BitBlt (new_img_dc
, 0, 0, img
->width
, img
->height
, old_img_dc
,
2834 SelectObject (old_img_dc
, old_prev
);
2835 SelectObject (new_img_dc
, new_prev
);
2836 DeleteDC (old_img_dc
);
2837 DeleteDC (new_img_dc
);
2838 DeleteObject (img
->pixmap
);
2839 if (new_pixmap
== 0)
2840 fprintf (stderr
, "Failed to convert image to color.\n");
2842 img
->pixmap
= new_pixmap
;
2845 #define XBM_BIT_SHUFFLE(b) (~(b))
2849 #define XBM_BIT_SHUFFLE(b) (b)
2851 #endif /* HAVE_NTGUI */
2855 Create_Pixmap_From_Bitmap_Data(f
, img
, data
, fg
, bg
, non_default_colors
)
2859 RGB_PIXEL_COLOR fg
, bg
;
2860 int non_default_colors
;
2864 = w32_create_pixmap_from_bitmap_data (img
->width
, img
->height
, data
);
2866 /* If colors were specified, transfer the bitmap to a color one. */
2867 if (non_default_colors
)
2868 convert_mono_to_color_image (f
, img
, fg
, bg
);
2871 = XCreatePixmapFromBitmapData (FRAME_X_DISPLAY (f
),
2874 img
->width
, img
->height
,
2876 DefaultDepthOfScreen (FRAME_X_SCREEN (f
)));
2877 #endif /* HAVE_NTGUI */
2882 /* Replacement for XReadBitmapFileData which isn't available under old
2883 X versions. CONTENTS is a pointer to a buffer to parse; END is the
2884 buffer's end. Set *WIDTH and *HEIGHT to the width and height of
2885 the image. Return in *DATA the bitmap data allocated with xmalloc.
2886 Value is non-zero if successful. DATA null means just test if
2887 CONTENTS looks like an in-memory XBM file. */
2890 xbm_read_bitmap_data (contents
, end
, width
, height
, data
)
2891 unsigned char *contents
, *end
;
2892 int *width
, *height
;
2893 unsigned char **data
;
2895 unsigned char *s
= contents
;
2896 char buffer
[BUFSIZ
];
2899 int bytes_per_line
, i
, nbytes
;
2905 LA1 = xbm_scan (&s, end, buffer, &value)
2907 #define expect(TOKEN) \
2908 if (LA1 != (TOKEN)) \
2913 #define expect_ident(IDENT) \
2914 if (LA1 == XBM_TK_IDENT && strcmp (buffer, (IDENT)) == 0) \
2919 *width
= *height
= -1;
2922 LA1
= xbm_scan (&s
, end
, buffer
, &value
);
2924 /* Parse defines for width, height and hot-spots. */
2928 expect_ident ("define");
2929 expect (XBM_TK_IDENT
);
2931 if (LA1
== XBM_TK_NUMBER
);
2933 char *p
= strrchr (buffer
, '_');
2934 p
= p
? p
+ 1 : buffer
;
2935 if (strcmp (p
, "width") == 0)
2937 else if (strcmp (p
, "height") == 0)
2940 expect (XBM_TK_NUMBER
);
2943 if (*width
< 0 || *height
< 0)
2945 else if (data
== NULL
)
2948 /* Parse bits. Must start with `static'. */
2949 expect_ident ("static");
2950 if (LA1
== XBM_TK_IDENT
)
2952 if (strcmp (buffer
, "unsigned") == 0)
2955 expect_ident ("char");
2957 else if (strcmp (buffer
, "short") == 0)
2961 if (*width
% 16 && *width
% 16 < 9)
2964 else if (strcmp (buffer
, "char") == 0)
2972 expect (XBM_TK_IDENT
);
2978 bytes_per_line
= (*width
+ 7) / 8 + padding_p
;
2979 nbytes
= bytes_per_line
* *height
;
2980 p
= *data
= (char *) xmalloc (nbytes
);
2984 for (i
= 0; i
< nbytes
; i
+= 2)
2987 expect (XBM_TK_NUMBER
);
2989 *p
++ = XBM_BIT_SHUFFLE (val
);
2990 if (!padding_p
|| ((i
+ 2) % bytes_per_line
))
2991 *p
++ = XBM_BIT_SHUFFLE (value
>> 8);
2993 if (LA1
== ',' || LA1
== '}')
3001 for (i
= 0; i
< nbytes
; ++i
)
3004 expect (XBM_TK_NUMBER
);
3006 *p
++ = XBM_BIT_SHUFFLE (val
);
3008 if (LA1
== ',' || LA1
== '}')
3033 /* Load XBM image IMG which will be displayed on frame F from buffer
3034 CONTENTS. END is the end of the buffer. Value is non-zero if
3038 xbm_load_image (f
, img
, contents
, end
)
3041 unsigned char *contents
, *end
;
3044 unsigned char *data
;
3047 rc
= xbm_read_bitmap_data (contents
, end
, &img
->width
, &img
->height
, &data
);
3050 unsigned long foreground
= FRAME_FOREGROUND_PIXEL (f
);
3051 unsigned long background
= FRAME_BACKGROUND_PIXEL (f
);
3052 int non_default_colors
= 0;
3055 xassert (img
->width
> 0 && img
->height
> 0);
3057 /* Get foreground and background colors, maybe allocate colors. */
3058 value
= image_spec_value (img
->spec
, QCforeground
, NULL
);
3061 foreground
= x_alloc_image_color (f
, img
, value
, foreground
);
3062 non_default_colors
= 1;
3064 value
= image_spec_value (img
->spec
, QCbackground
, NULL
);
3067 background
= x_alloc_image_color (f
, img
, value
, background
);
3068 img
->background
= background
;
3069 img
->background_valid
= 1;
3070 non_default_colors
= 1;
3073 Create_Pixmap_From_Bitmap_Data (f
, img
, data
,
3074 foreground
, background
,
3075 non_default_colors
);
3078 if (img
->pixmap
== NO_PIXMAP
)
3080 x_clear_image (f
, img
);
3081 image_error ("Unable to create X pixmap for `%s'", img
->spec
, Qnil
);
3087 image_error ("Error loading XBM image `%s'", img
->spec
, Qnil
);
3093 /* Value is non-zero if DATA looks like an in-memory XBM file. */
3100 return (STRINGP (data
)
3101 && xbm_read_bitmap_data (SDATA (data
),
3108 /* Fill image IMG which is used on frame F with pixmap data. Value is
3109 non-zero if successful. */
3117 Lisp_Object file_name
;
3119 xassert (xbm_image_p (img
->spec
));
3121 /* If IMG->spec specifies a file name, create a non-file spec from it. */
3122 file_name
= image_spec_value (img
->spec
, QCfile
, NULL
);
3123 if (STRINGP (file_name
))
3126 unsigned char *contents
;
3128 struct gcpro gcpro1
;
3130 file
= x_find_image_file (file_name
);
3132 if (!STRINGP (file
))
3134 image_error ("Cannot find image file `%s'", file_name
, Qnil
);
3139 contents
= slurp_file (SDATA (file
), &size
);
3140 if (contents
== NULL
)
3142 image_error ("Error loading XBM image `%s'", img
->spec
, Qnil
);
3147 success_p
= xbm_load_image (f
, img
, contents
, contents
+ size
);
3152 struct image_keyword fmt
[XBM_LAST
];
3154 unsigned long foreground
= FRAME_FOREGROUND_PIXEL (f
);
3155 unsigned long background
= FRAME_BACKGROUND_PIXEL (f
);
3156 int non_default_colors
= 0;
3159 int in_memory_file_p
= 0;
3161 /* See if data looks like an in-memory XBM file. */
3162 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
3163 in_memory_file_p
= xbm_file_p (data
);
3165 /* Parse the image specification. */
3166 bcopy (xbm_format
, fmt
, sizeof fmt
);
3167 parsed_p
= parse_image_spec (img
->spec
, fmt
, XBM_LAST
, Qxbm
);
3170 /* Get specified width, and height. */
3171 if (!in_memory_file_p
)
3173 img
->width
= XFASTINT (fmt
[XBM_WIDTH
].value
);
3174 img
->height
= XFASTINT (fmt
[XBM_HEIGHT
].value
);
3175 xassert (img
->width
> 0 && img
->height
> 0);
3178 /* Get foreground and background colors, maybe allocate colors. */
3179 if (fmt
[XBM_FOREGROUND
].count
3180 && STRINGP (fmt
[XBM_FOREGROUND
].value
))
3182 foreground
= x_alloc_image_color (f
, img
, fmt
[XBM_FOREGROUND
].value
,
3184 non_default_colors
= 1;
3187 if (fmt
[XBM_BACKGROUND
].count
3188 && STRINGP (fmt
[XBM_BACKGROUND
].value
))
3190 background
= x_alloc_image_color (f
, img
, fmt
[XBM_BACKGROUND
].value
,
3192 non_default_colors
= 1;
3195 if (in_memory_file_p
)
3196 success_p
= xbm_load_image (f
, img
, SDATA (data
),
3205 int nbytes
= (img
->width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
;
3207 p
= bits
= (char *) alloca (nbytes
* img
->height
);
3208 for (i
= 0; i
< img
->height
; ++i
, p
+= nbytes
)
3210 Lisp_Object line
= XVECTOR (data
)->contents
[i
];
3212 bcopy (SDATA (line
), p
, nbytes
);
3214 bcopy (XBOOL_VECTOR (line
)->data
, p
, nbytes
);
3217 else if (STRINGP (data
))
3218 bits
= SDATA (data
);
3220 bits
= XBOOL_VECTOR (data
)->data
;
3222 /* Create the pixmap. */
3224 Create_Pixmap_From_Bitmap_Data (f
, img
, bits
,
3225 foreground
, background
,
3226 non_default_colors
);
3231 image_error ("Unable to create pixmap for XBM image `%s'",
3233 x_clear_image (f
, img
);
3243 /***********************************************************************
3245 ***********************************************************************/
3247 #if defined (HAVE_XPM) || defined (MAC_OS)
3249 static int xpm_image_p
P_ ((Lisp_Object object
));
3250 static int xpm_load
P_ ((struct frame
*f
, struct image
*img
));
3251 static int xpm_valid_color_symbols_p
P_ ((Lisp_Object
));
3253 #endif /* HAVE_XPM || MAC_OS */
3257 /* Indicate to xpm.h that we don't have Xlib. */
3259 /* simx.h in xpm defines XColor and XImage differently than Emacs. */
3260 /* It also defines Display the same way as Emacs, but gcc 3.3 still barfs. */
3261 #define XColor xpm_XColor
3262 #define XImage xpm_XImage
3263 #define Display xpm_Display
3264 #define PIXEL_ALREADY_TYPEDEFED
3265 #include "X11/xpm.h"
3270 #undef PIXEL_ALREADY_TYPEDEFED
3272 #include "X11/xpm.h"
3273 #endif /* HAVE_NTGUI */
3274 #endif /* HAVE_XPM */
3276 #if defined (HAVE_XPM) || defined (MAC_OS)
3277 /* The symbol `xpm' identifying XPM-format images. */
3281 /* Indices of image specification fields in xpm_format, below. */
3283 enum xpm_keyword_index
3299 /* Vector of image_keyword structures describing the format
3300 of valid XPM image specifications. */
3302 static struct image_keyword xpm_format
[XPM_LAST
] =
3304 {":type", IMAGE_SYMBOL_VALUE
, 1},
3305 {":file", IMAGE_STRING_VALUE
, 0},
3306 {":data", IMAGE_STRING_VALUE
, 0},
3307 {":ascent", IMAGE_ASCENT_VALUE
, 0},
3308 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
3309 {":relief", IMAGE_INTEGER_VALUE
, 0},
3310 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3311 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3312 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3313 {":color-symbols", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3314 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
3317 /* Structure describing the image type XPM. */
3319 static struct image_type xpm_type
=
3328 #ifdef HAVE_X_WINDOWS
3330 /* Define ALLOC_XPM_COLORS if we can use Emacs' own color allocation
3331 functions for allocating image colors. Our own functions handle
3332 color allocation failures more gracefully than the ones on the XPM
3335 #if defined XpmAllocColor && defined XpmFreeColors && defined XpmColorClosure
3336 #define ALLOC_XPM_COLORS
3338 #endif /* HAVE_X_WINDOWS */
3340 #ifdef ALLOC_XPM_COLORS
3342 static void xpm_init_color_cache
P_ ((struct frame
*, XpmAttributes
*));
3343 static void xpm_free_color_cache
P_ ((void));
3344 static int xpm_lookup_color
P_ ((struct frame
*, char *, XColor
*));
3345 static int xpm_color_bucket
P_ ((char *));
3346 static struct xpm_cached_color
*xpm_cache_color
P_ ((struct frame
*, char *,
3349 /* An entry in a hash table used to cache color definitions of named
3350 colors. This cache is necessary to speed up XPM image loading in
3351 case we do color allocations ourselves. Without it, we would need
3352 a call to XParseColor per pixel in the image. */
3354 struct xpm_cached_color
3356 /* Next in collision chain. */
3357 struct xpm_cached_color
*next
;
3359 /* Color definition (RGB and pixel color). */
3366 /* The hash table used for the color cache, and its bucket vector
3369 #define XPM_COLOR_CACHE_BUCKETS 1001
3370 struct xpm_cached_color
**xpm_color_cache
;
3372 /* Initialize the color cache. */
3375 xpm_init_color_cache (f
, attrs
)
3377 XpmAttributes
*attrs
;
3379 size_t nbytes
= XPM_COLOR_CACHE_BUCKETS
* sizeof *xpm_color_cache
;
3380 xpm_color_cache
= (struct xpm_cached_color
**) xmalloc (nbytes
);
3381 memset (xpm_color_cache
, 0, nbytes
);
3382 init_color_table ();
3384 if (attrs
->valuemask
& XpmColorSymbols
)
3389 for (i
= 0; i
< attrs
->numsymbols
; ++i
)
3390 if (XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
3391 attrs
->colorsymbols
[i
].value
, &color
))
3393 color
.pixel
= lookup_rgb_color (f
, color
.red
, color
.green
,
3395 xpm_cache_color (f
, attrs
->colorsymbols
[i
].name
, &color
, -1);
3400 /* Free the color cache. */
3403 xpm_free_color_cache ()
3405 struct xpm_cached_color
*p
, *next
;
3408 for (i
= 0; i
< XPM_COLOR_CACHE_BUCKETS
; ++i
)
3409 for (p
= xpm_color_cache
[i
]; p
; p
= next
)
3415 xfree (xpm_color_cache
);
3416 xpm_color_cache
= NULL
;
3417 free_color_table ();
3420 /* Return the bucket index for color named COLOR_NAME in the color
3424 xpm_color_bucket (color_name
)
3430 for (s
= color_name
; *s
; ++s
)
3432 return h
%= XPM_COLOR_CACHE_BUCKETS
;
3436 /* On frame F, cache values COLOR for color with name COLOR_NAME.
3437 BUCKET, if >= 0, is a precomputed bucket index. Value is the cache
3440 static struct xpm_cached_color
*
3441 xpm_cache_color (f
, color_name
, color
, bucket
)
3448 struct xpm_cached_color
*p
;
3451 bucket
= xpm_color_bucket (color_name
);
3453 nbytes
= sizeof *p
+ strlen (color_name
);
3454 p
= (struct xpm_cached_color
*) xmalloc (nbytes
);
3455 strcpy (p
->name
, color_name
);
3457 p
->next
= xpm_color_cache
[bucket
];
3458 xpm_color_cache
[bucket
] = p
;
3462 /* Look up color COLOR_NAME for frame F in the color cache. If found,
3463 return the cached definition in *COLOR. Otherwise, make a new
3464 entry in the cache and allocate the color. Value is zero if color
3465 allocation failed. */
3468 xpm_lookup_color (f
, color_name
, color
)
3473 struct xpm_cached_color
*p
;
3474 int h
= xpm_color_bucket (color_name
);
3476 for (p
= xpm_color_cache
[h
]; p
; p
= p
->next
)
3477 if (strcmp (p
->name
, color_name
) == 0)
3482 else if (XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
3485 color
->pixel
= lookup_rgb_color (f
, color
->red
, color
->green
,
3487 p
= xpm_cache_color (f
, color_name
, color
, h
);
3489 /* You get `opaque' at least from ImageMagick converting pbm to xpm
3490 with transparency, and it's useful. */
3491 else if (strcmp ("opaque", color_name
) == 0)
3493 bzero (color
, sizeof (XColor
)); /* Is this necessary/correct? */
3494 color
->pixel
= FRAME_FOREGROUND_PIXEL (f
);
3495 p
= xpm_cache_color (f
, color_name
, color
, h
);
3502 /* Callback for allocating color COLOR_NAME. Called from the XPM lib.
3503 CLOSURE is a pointer to the frame on which we allocate the
3504 color. Return in *COLOR the allocated color. Value is non-zero
3508 xpm_alloc_color (dpy
, cmap
, color_name
, color
, closure
)
3515 return xpm_lookup_color ((struct frame
*) closure
, color_name
, color
);
3519 /* Callback for freeing NPIXELS colors contained in PIXELS. CLOSURE
3520 is a pointer to the frame on which we allocate the color. Value is
3521 non-zero if successful. */
3524 xpm_free_colors (dpy
, cmap
, pixels
, npixels
, closure
)
3534 #endif /* ALLOC_XPM_COLORS */
3539 /* XPM library details. */
3541 DEF_IMGLIB_FN (XpmFreeAttributes
);
3542 DEF_IMGLIB_FN (XpmCreateImageFromBuffer
);
3543 DEF_IMGLIB_FN (XpmReadFileToImage
);
3544 DEF_IMGLIB_FN (XImageFree
);
3547 init_xpm_functions (Lisp_Object libraries
)
3551 if (!(library
= w32_delayed_load (libraries
, Qxpm
)))
3554 LOAD_IMGLIB_FN (library
, XpmFreeAttributes
);
3555 LOAD_IMGLIB_FN (library
, XpmCreateImageFromBuffer
);
3556 LOAD_IMGLIB_FN (library
, XpmReadFileToImage
);
3557 LOAD_IMGLIB_FN (library
, XImageFree
);
3561 #endif /* HAVE_NTGUI */
3564 /* Value is non-zero if COLOR_SYMBOLS is a valid color symbols list
3565 for XPM images. Such a list must consist of conses whose car and
3569 xpm_valid_color_symbols_p (color_symbols
)
3570 Lisp_Object color_symbols
;
3572 while (CONSP (color_symbols
))
3574 Lisp_Object sym
= XCAR (color_symbols
);
3576 || !STRINGP (XCAR (sym
))
3577 || !STRINGP (XCDR (sym
)))
3579 color_symbols
= XCDR (color_symbols
);
3582 return NILP (color_symbols
);
3586 /* Value is non-zero if OBJECT is a valid XPM image specification. */
3589 xpm_image_p (object
)
3592 struct image_keyword fmt
[XPM_LAST
];
3593 bcopy (xpm_format
, fmt
, sizeof fmt
);
3594 return (parse_image_spec (object
, fmt
, XPM_LAST
, Qxpm
)
3595 /* Either `:file' or `:data' must be present. */
3596 && fmt
[XPM_FILE
].count
+ fmt
[XPM_DATA
].count
== 1
3597 /* Either no `:color-symbols' or it's a list of conses
3598 whose car and cdr are strings. */
3599 && (fmt
[XPM_COLOR_SYMBOLS
].count
== 0
3600 || xpm_valid_color_symbols_p (fmt
[XPM_COLOR_SYMBOLS
].value
)));
3603 #endif /* HAVE_XPM || MAC_OS */
3605 /* Load image IMG which will be displayed on frame F. Value is
3606 non-zero if successful. */
3616 XpmAttributes attrs
;
3617 Lisp_Object specified_file
, color_symbols
;
3620 xpm_XImage
* xpm_image
= NULL
, * xpm_mask
= NULL
;
3621 #endif /* HAVE_NTGUI */
3623 /* Configure the XPM lib. Use the visual of frame F. Allocate
3624 close colors. Return colors allocated. */
3625 bzero (&attrs
, sizeof attrs
);
3628 attrs
.visual
= FRAME_X_VISUAL (f
);
3629 attrs
.colormap
= FRAME_X_COLORMAP (f
);
3630 attrs
.valuemask
|= XpmVisual
;
3631 attrs
.valuemask
|= XpmColormap
;
3632 #endif /* HAVE_NTGUI */
3634 #ifdef ALLOC_XPM_COLORS
3635 /* Allocate colors with our own functions which handle
3636 failing color allocation more gracefully. */
3637 attrs
.color_closure
= f
;
3638 attrs
.alloc_color
= xpm_alloc_color
;
3639 attrs
.free_colors
= xpm_free_colors
;
3640 attrs
.valuemask
|= XpmAllocColor
| XpmFreeColors
| XpmColorClosure
;
3641 #else /* not ALLOC_XPM_COLORS */
3642 /* Let the XPM lib allocate colors. */
3643 attrs
.valuemask
|= XpmReturnAllocPixels
;
3644 #ifdef XpmAllocCloseColors
3645 attrs
.alloc_close_colors
= 1;
3646 attrs
.valuemask
|= XpmAllocCloseColors
;
3647 #else /* not XpmAllocCloseColors */
3648 attrs
.closeness
= 600;
3649 attrs
.valuemask
|= XpmCloseness
;
3650 #endif /* not XpmAllocCloseColors */
3651 #endif /* ALLOC_XPM_COLORS */
3653 /* If image specification contains symbolic color definitions, add
3654 these to `attrs'. */
3655 color_symbols
= image_spec_value (img
->spec
, QCcolor_symbols
, NULL
);
3656 if (CONSP (color_symbols
))
3659 XpmColorSymbol
*xpm_syms
;
3662 attrs
.valuemask
|= XpmColorSymbols
;
3664 /* Count number of symbols. */
3665 attrs
.numsymbols
= 0;
3666 for (tail
= color_symbols
; CONSP (tail
); tail
= XCDR (tail
))
3669 /* Allocate an XpmColorSymbol array. */
3670 size
= attrs
.numsymbols
* sizeof *xpm_syms
;
3671 xpm_syms
= (XpmColorSymbol
*) alloca (size
);
3672 bzero (xpm_syms
, size
);
3673 attrs
.colorsymbols
= xpm_syms
;
3675 /* Fill the color symbol array. */
3676 for (tail
= color_symbols
, i
= 0;
3678 ++i
, tail
= XCDR (tail
))
3680 Lisp_Object name
= XCAR (XCAR (tail
));
3681 Lisp_Object color
= XCDR (XCAR (tail
));
3682 xpm_syms
[i
].name
= (char *) alloca (SCHARS (name
) + 1);
3683 strcpy (xpm_syms
[i
].name
, SDATA (name
));
3684 xpm_syms
[i
].value
= (char *) alloca (SCHARS (color
) + 1);
3685 strcpy (xpm_syms
[i
].value
, SDATA (color
));
3689 /* Create a pixmap for the image, either from a file, or from a
3690 string buffer containing data in the same format as an XPM file. */
3691 #ifdef ALLOC_XPM_COLORS
3692 xpm_init_color_cache (f
, &attrs
);
3695 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
3699 HDC frame_dc
= get_frame_dc (f
);
3700 hdc
= CreateCompatibleDC (frame_dc
);
3701 release_frame_dc (f
, frame_dc
);
3703 #endif /* HAVE_NTGUI */
3705 if (STRINGP (specified_file
))
3707 Lisp_Object file
= x_find_image_file (specified_file
);
3708 if (!STRINGP (file
))
3710 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
3715 /* XpmReadFileToPixmap is not available in the Windows port of
3716 libxpm. But XpmReadFileToImage almost does what we want. */
3717 rc
= fn_XpmReadFileToImage (&hdc
, SDATA (file
),
3718 &xpm_image
, &xpm_mask
,
3721 rc
= XpmReadFileToPixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3722 SDATA (file
), &img
->pixmap
, &img
->mask
,
3724 #endif /* HAVE_NTGUI */
3728 Lisp_Object buffer
= image_spec_value (img
->spec
, QCdata
, NULL
);
3730 /* XpmCreatePixmapFromBuffer is not available in the Windows port
3731 of libxpm. But XpmCreateImageFromBuffer almost does what we want. */
3732 rc
= fn_XpmCreateImageFromBuffer (&hdc
, SDATA (buffer
),
3733 &xpm_image
, &xpm_mask
,
3736 rc
= XpmCreatePixmapFromBuffer (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3738 &img
->pixmap
, &img
->mask
,
3740 #endif /* HAVE_NTGUI */
3743 if (rc
== XpmSuccess
)
3745 #if defined (COLOR_TABLE_SUPPORT) && defined (ALLOC_XPM_COLORS)
3746 img
->colors
= colors_in_color_table (&img
->ncolors
);
3747 #else /* not ALLOC_XPM_COLORS */
3751 /* W32 XPM uses XImage to wrap what W32 Emacs calls a Pixmap,
3752 plus some duplicate attributes. */
3753 if (xpm_image
&& xpm_image
->bitmap
)
3755 img
->pixmap
= xpm_image
->bitmap
;
3756 /* XImageFree in libXpm frees XImage struct without destroying
3757 the bitmap, which is what we want. */
3758 fn_XImageFree (xpm_image
);
3760 if (xpm_mask
&& xpm_mask
->bitmap
)
3762 /* The mask appears to be inverted compared with what we expect.
3763 TODO: invert our expectations. See other places where we
3764 have to invert bits because our idea of masks is backwards. */
3766 old_obj
= SelectObject (hdc
, xpm_mask
->bitmap
);
3768 PatBlt (hdc
, 0, 0, xpm_mask
->width
, xpm_mask
->height
, DSTINVERT
);
3769 SelectObject (hdc
, old_obj
);
3771 img
->mask
= xpm_mask
->bitmap
;
3772 fn_XImageFree (xpm_mask
);
3777 #endif /* HAVE_NTGUI */
3779 /* Remember allocated colors. */
3780 img
->ncolors
= attrs
.nalloc_pixels
;
3781 img
->colors
= (unsigned long *) xmalloc (img
->ncolors
3782 * sizeof *img
->colors
);
3783 for (i
= 0; i
< attrs
.nalloc_pixels
; ++i
)
3785 img
->colors
[i
] = attrs
.alloc_pixels
[i
];
3786 #ifdef DEBUG_X_COLORS
3787 register_color (img
->colors
[i
]);
3790 #endif /* not ALLOC_XPM_COLORS */
3792 img
->width
= attrs
.width
;
3793 img
->height
= attrs
.height
;
3794 xassert (img
->width
> 0 && img
->height
> 0);
3796 /* The call to XpmFreeAttributes below frees attrs.alloc_pixels. */
3798 fn_XpmFreeAttributes (&attrs
);
3800 XpmFreeAttributes (&attrs
);
3801 #endif /* HAVE_NTGUI */
3807 #endif /* HAVE_NTGUI */
3812 image_error ("Error opening XPM file (%s)", img
->spec
, Qnil
);
3815 case XpmFileInvalid
:
3816 image_error ("Invalid XPM file (%s)", img
->spec
, Qnil
);
3820 image_error ("Out of memory (%s)", img
->spec
, Qnil
);
3823 case XpmColorFailed
:
3824 image_error ("Color allocation error (%s)", img
->spec
, Qnil
);
3828 image_error ("Unknown error (%s)", img
->spec
, Qnil
);
3833 #ifdef ALLOC_XPM_COLORS
3834 xpm_free_color_cache ();
3836 return rc
== XpmSuccess
;
3839 #endif /* HAVE_XPM */
3843 /* XPM support functions for Mac OS where libxpm is not available.
3844 Only XPM version 3 (without any extensions) is supported. */
3846 static int xpm_scan
P_ ((unsigned char **, unsigned char *,
3847 unsigned char **, int *));
3848 static Lisp_Object xpm_make_color_table_v
3849 P_ ((void (**) (Lisp_Object
, unsigned char *, int, Lisp_Object
),
3850 Lisp_Object (**) (Lisp_Object
, unsigned char *, int)));
3851 static void xpm_put_color_table_v
P_ ((Lisp_Object
, unsigned char *,
3853 static Lisp_Object xpm_get_color_table_v
P_ ((Lisp_Object
,
3854 unsigned char *, int));
3855 static Lisp_Object xpm_make_color_table_h
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_h
P_ ((Lisp_Object
, unsigned char *,
3860 static Lisp_Object xpm_get_color_table_h
P_ ((Lisp_Object
,
3861 unsigned char *, int));
3862 static int xpm_str_to_color_key
P_ ((char *));
3863 static int xpm_load_image
P_ ((struct frame
*, struct image
*,
3864 unsigned char *, unsigned char *));
3866 /* Tokens returned from xpm_scan. */
3875 /* Scan an XPM data and return a character (< 256) or a token defined
3876 by enum xpm_token above. *S and END are the start (inclusive) and
3877 the end (exclusive) addresses of the data, respectively. Advance
3878 *S while scanning. If token is either XPM_TK_IDENT or
3879 XPM_TK_STRING, *BEG and *LEN are set to the start address and the
3880 length of the corresponding token, respectively. */
3883 xpm_scan (s
, end
, beg
, len
)
3884 unsigned char **s
, *end
, **beg
;
3891 /* Skip white-space. */
3892 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
3895 /* gnus-pointer.xpm uses '-' in its identifier.
3896 sb-dir-plus.xpm uses '+' in its identifier. */
3897 if (isalpha (c
) || c
== '_' || c
== '-' || c
== '+')
3901 (c
= **s
, isalnum (c
) || c
== '_' || c
== '-' || c
== '+'))
3904 return XPM_TK_IDENT
;
3909 while (*s
< end
&& **s
!= '"')
3914 return XPM_TK_STRING
;
3918 if (*s
< end
&& **s
== '*')
3920 /* C-style comment. */
3924 while (*s
< end
&& *(*s
)++ != '*')
3927 while (*s
< end
&& **s
!= '/');
3941 /* Functions for color table lookup in XPM data. A Key is a string
3942 specifying the color of each pixel in XPM data. A value is either
3943 an integer that specifies a pixel color, Qt that specifies
3944 transparency, or Qnil for the unspecified color. If the length of
3945 the key string is one, a vector is used as a table. Otherwise, a
3946 hash table is used. */
3949 xpm_make_color_table_v (put_func
, get_func
)
3950 void (**put_func
) (Lisp_Object
, unsigned char *, int, Lisp_Object
);
3951 Lisp_Object (**get_func
) (Lisp_Object
, unsigned char *, int);
3953 *put_func
= xpm_put_color_table_v
;
3954 *get_func
= xpm_get_color_table_v
;
3955 return Fmake_vector (make_number (256), Qnil
);
3959 xpm_put_color_table_v (color_table
, chars_start
, chars_len
, color
)
3960 Lisp_Object color_table
;
3961 unsigned char *chars_start
;
3965 XVECTOR (color_table
)->contents
[*chars_start
] = color
;
3969 xpm_get_color_table_v (color_table
, chars_start
, chars_len
)
3970 Lisp_Object color_table
;
3971 unsigned char *chars_start
;
3974 return XVECTOR (color_table
)->contents
[*chars_start
];
3978 xpm_make_color_table_h (put_func
, get_func
)
3979 void (**put_func
) (Lisp_Object
, unsigned char *, int, Lisp_Object
);
3980 Lisp_Object (**get_func
) (Lisp_Object
, unsigned char *, int);
3982 *put_func
= xpm_put_color_table_h
;
3983 *get_func
= xpm_get_color_table_h
;
3984 return make_hash_table (Qequal
, make_number (DEFAULT_HASH_SIZE
),
3985 make_float (DEFAULT_REHASH_SIZE
),
3986 make_float (DEFAULT_REHASH_THRESHOLD
),
3991 xpm_put_color_table_h (color_table
, chars_start
, chars_len
, color
)
3992 Lisp_Object color_table
;
3993 unsigned char *chars_start
;
3997 struct Lisp_Hash_Table
*table
= XHASH_TABLE (color_table
);
3999 Lisp_Object chars
= make_unibyte_string (chars_start
, chars_len
);
4001 hash_lookup (table
, chars
, &hash_code
);
4002 hash_put (table
, chars
, color
, hash_code
);
4006 xpm_get_color_table_h (color_table
, chars_start
, chars_len
)
4007 Lisp_Object color_table
;
4008 unsigned char *chars_start
;
4011 struct Lisp_Hash_Table
*table
= XHASH_TABLE (color_table
);
4012 int i
= hash_lookup (table
, make_unibyte_string (chars_start
, chars_len
),
4015 return i
>= 0 ? HASH_VALUE (table
, i
) : Qnil
;
4018 enum xpm_color_key
{
4026 static char xpm_color_key_strings
[][4] = {"s", "m", "g4", "g", "c"};
4029 xpm_str_to_color_key (s
)
4035 i
< sizeof xpm_color_key_strings
/ sizeof xpm_color_key_strings
[0];
4037 if (strcmp (xpm_color_key_strings
[i
], s
) == 0)
4043 xpm_load_image (f
, img
, contents
, end
)
4046 unsigned char *contents
, *end
;
4048 unsigned char *s
= contents
, *beg
, *str
;
4049 unsigned char buffer
[BUFSIZ
];
4050 int width
, height
, x
, y
;
4051 int num_colors
, chars_per_pixel
;
4053 void (*put_color_table
) (Lisp_Object
, unsigned char *, int, Lisp_Object
);
4054 Lisp_Object (*get_color_table
) (Lisp_Object
, unsigned char *, int);
4055 Lisp_Object frame
, color_symbols
, color_table
;
4056 int best_key
, have_mask
= 0;
4057 XImagePtr ximg
= NULL
, mask_img
= NULL
;
4060 LA1 = xpm_scan (&s, end, &beg, &len)
4062 #define expect(TOKEN) \
4063 if (LA1 != (TOKEN)) \
4068 #define expect_ident(IDENT) \
4069 if (LA1 == XPM_TK_IDENT \
4070 && strlen ((IDENT)) == len && memcmp ((IDENT), beg, len) == 0) \
4075 if (!(end
- s
>= 9 && memcmp (s
, "/* XPM */", 9) == 0))
4079 expect_ident ("static");
4080 expect_ident ("char");
4082 expect (XPM_TK_IDENT
);
4087 expect (XPM_TK_STRING
);
4090 memcpy (buffer
, beg
, len
);
4092 if (sscanf (buffer
, "%d %d %d %d", &width
, &height
,
4093 &num_colors
, &chars_per_pixel
) != 4
4094 || width
<= 0 || height
<= 0
4095 || num_colors
<= 0 || chars_per_pixel
<= 0)
4099 XSETFRAME (frame
, f
);
4100 if (!NILP (Fxw_display_color_p (frame
)))
4101 best_key
= XPM_COLOR_KEY_C
;
4102 else if (!NILP (Fx_display_grayscale_p (frame
)))
4103 best_key
= (XFASTINT (Fx_display_planes (frame
)) > 2
4104 ? XPM_COLOR_KEY_G
: XPM_COLOR_KEY_G4
);
4106 best_key
= XPM_COLOR_KEY_M
;
4108 color_symbols
= image_spec_value (img
->spec
, QCcolor_symbols
, NULL
);
4109 if (chars_per_pixel
== 1)
4110 color_table
= xpm_make_color_table_v (&put_color_table
,
4113 color_table
= xpm_make_color_table_h (&put_color_table
,
4116 while (num_colors
-- > 0)
4118 unsigned char *color
, *max_color
;
4119 int key
, next_key
, max_key
= 0;
4120 Lisp_Object symbol_color
= Qnil
, color_val
;
4123 expect (XPM_TK_STRING
);
4124 if (len
<= chars_per_pixel
|| len
>= BUFSIZ
+ chars_per_pixel
)
4126 memcpy (buffer
, beg
+ chars_per_pixel
, len
- chars_per_pixel
);
4127 buffer
[len
- chars_per_pixel
] = '\0';
4129 str
= strtok (buffer
, " \t");
4132 key
= xpm_str_to_color_key (str
);
4137 color
= strtok (NULL
, " \t");
4141 while (str
= strtok (NULL
, " \t"))
4143 next_key
= xpm_str_to_color_key (str
);
4146 color
[strlen (color
)] = ' ';
4149 if (key
== XPM_COLOR_KEY_S
)
4151 if (NILP (symbol_color
))
4152 symbol_color
= build_string (color
);
4154 else if (max_key
< key
&& key
<= best_key
)
4164 if (!NILP (color_symbols
) && !NILP (symbol_color
))
4166 Lisp_Object specified_color
= Fassoc (symbol_color
, color_symbols
);
4168 if (CONSP (specified_color
) && STRINGP (XCDR (specified_color
)))
4169 if (xstricmp (SDATA (XCDR (specified_color
)), "None") == 0)
4171 else if (x_defined_color (f
, SDATA (XCDR (specified_color
)),
4173 color_val
= make_number (cdef
.pixel
);
4175 if (NILP (color_val
) && max_key
> 0)
4176 if (xstricmp (max_color
, "None") == 0)
4178 else if (x_defined_color (f
, max_color
, &cdef
, 0))
4179 color_val
= make_number (cdef
.pixel
);
4180 if (!NILP (color_val
))
4181 (*put_color_table
) (color_table
, beg
, chars_per_pixel
, color_val
);
4186 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0,
4187 &ximg
, &img
->pixmap
)
4188 || !x_create_x_image_and_pixmap (f
, width
, height
, 1,
4189 &mask_img
, &img
->mask
))
4191 image_error ("Out of memory (%s)", img
->spec
, Qnil
);
4195 for (y
= 0; y
< height
; y
++)
4197 expect (XPM_TK_STRING
);
4199 if (len
< width
* chars_per_pixel
)
4201 for (x
= 0; x
< width
; x
++, str
+= chars_per_pixel
)
4203 Lisp_Object color_val
=
4204 (*get_color_table
) (color_table
, str
, chars_per_pixel
);
4206 XPutPixel (ximg
, x
, y
,
4207 (INTEGERP (color_val
) ? XINT (color_val
)
4208 : FRAME_FOREGROUND_PIXEL (f
)));
4209 XPutPixel (mask_img
, x
, y
,
4210 (!EQ (color_val
, Qt
) ? PIX_MASK_DRAW (f
)
4211 : (have_mask
= 1, PIX_MASK_RETAIN (f
))));
4218 img
->height
= height
;
4220 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
4221 x_destroy_x_image (ximg
);
4224 x_put_x_image (f
, mask_img
, img
->mask
, width
, height
);
4225 x_destroy_x_image (mask_img
);
4229 x_destroy_x_image (mask_img
);
4230 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
4231 img
->mask
= NO_PIXMAP
;
4237 image_error ("Invalid XPM file (%s)", img
->spec
, Qnil
);
4239 x_destroy_x_image (ximg
);
4240 x_destroy_x_image (mask_img
);
4241 x_clear_image (f
, img
);
4255 Lisp_Object file_name
;
4257 /* If IMG->spec specifies a file name, create a non-file spec from it. */
4258 file_name
= image_spec_value (img
->spec
, QCfile
, NULL
);
4259 if (STRINGP (file_name
))
4262 unsigned char *contents
;
4264 struct gcpro gcpro1
;
4266 file
= x_find_image_file (file_name
);
4268 if (!STRINGP (file
))
4270 image_error ("Cannot find image file `%s'", file_name
, Qnil
);
4275 contents
= slurp_file (SDATA (file
), &size
);
4276 if (contents
== NULL
)
4278 image_error ("Error loading XPM image `%s'", img
->spec
, Qnil
);
4283 success_p
= xpm_load_image (f
, img
, contents
, contents
+ size
);
4291 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
4292 success_p
= xpm_load_image (f
, img
, SDATA (data
),
4293 SDATA (data
) + SBYTES (data
));
4303 /***********************************************************************
4305 ***********************************************************************/
4307 #ifdef COLOR_TABLE_SUPPORT
4309 /* An entry in the color table mapping an RGB color to a pixel color. */
4314 unsigned long pixel
;
4316 /* Next in color table collision list. */
4317 struct ct_color
*next
;
4320 /* The bucket vector size to use. Must be prime. */
4324 /* Value is a hash of the RGB color given by R, G, and B. */
4326 #define CT_HASH_RGB(R, G, B) (((R) << 16) ^ ((G) << 8) ^ (B))
4328 /* The color hash table. */
4330 struct ct_color
**ct_table
;
4332 /* Number of entries in the color table. */
4334 int ct_colors_allocated
;
4336 /* Initialize the color table. */
4341 int size
= CT_SIZE
* sizeof (*ct_table
);
4342 ct_table
= (struct ct_color
**) xmalloc (size
);
4343 bzero (ct_table
, size
);
4344 ct_colors_allocated
= 0;
4348 /* Free memory associated with the color table. */
4354 struct ct_color
*p
, *next
;
4356 for (i
= 0; i
< CT_SIZE
; ++i
)
4357 for (p
= ct_table
[i
]; p
; p
= next
)
4368 /* Value is a pixel color for RGB color R, G, B on frame F. If an
4369 entry for that color already is in the color table, return the
4370 pixel color of that entry. Otherwise, allocate a new color for R,
4371 G, B, and make an entry in the color table. */
4373 static unsigned long
4374 lookup_rgb_color (f
, r
, g
, b
)
4378 unsigned hash
= CT_HASH_RGB (r
, g
, b
);
4379 int i
= hash
% CT_SIZE
;
4381 Display_Info
*dpyinfo
;
4383 /* Handle TrueColor visuals specially, which improves performance by
4384 two orders of magnitude. Freeing colors on TrueColor visuals is
4385 a nop, and pixel colors specify RGB values directly. See also
4386 the Xlib spec, chapter 3.1. */
4387 dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
4388 if (dpyinfo
->red_bits
> 0)
4390 unsigned long pr
, pg
, pb
;
4392 /* Apply gamma-correction like normal color allocation does. */
4396 color
.red
= r
, color
.green
= g
, color
.blue
= b
;
4397 gamma_correct (f
, &color
);
4398 r
= color
.red
, g
= color
.green
, b
= color
.blue
;
4401 /* Scale down RGB values to the visual's bits per RGB, and shift
4402 them to the right position in the pixel color. Note that the
4403 original RGB values are 16-bit values, as usual in X. */
4404 pr
= (r
>> (16 - dpyinfo
->red_bits
)) << dpyinfo
->red_offset
;
4405 pg
= (g
>> (16 - dpyinfo
->green_bits
)) << dpyinfo
->green_offset
;
4406 pb
= (b
>> (16 - dpyinfo
->blue_bits
)) << dpyinfo
->blue_offset
;
4408 /* Assemble the pixel color. */
4409 return pr
| pg
| pb
;
4412 for (p
= ct_table
[i
]; p
; p
= p
->next
)
4413 if (p
->r
== r
&& p
->g
== g
&& p
->b
== b
)
4419 #ifdef HAVE_X_WINDOWS
4428 cmap
= FRAME_X_COLORMAP (f
);
4429 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
4432 ++ct_colors_allocated
;
4433 p
= (struct ct_color
*) xmalloc (sizeof *p
);
4437 p
->pixel
= color
.pixel
;
4438 p
->next
= ct_table
[i
];
4442 return FRAME_FOREGROUND_PIXEL (f
);
4447 color
= PALETTERGB (r
, g
, b
);
4449 color
= RGB_TO_ULONG (r
, g
, b
);
4450 #endif /* HAVE_NTGUI */
4451 ++ct_colors_allocated
;
4452 p
= (struct ct_color
*) xmalloc (sizeof *p
);
4457 p
->next
= ct_table
[i
];
4459 #endif /* HAVE_X_WINDOWS */
4467 /* Look up pixel color PIXEL which is used on frame F in the color
4468 table. If not already present, allocate it. Value is PIXEL. */
4470 static unsigned long
4471 lookup_pixel_color (f
, pixel
)
4473 unsigned long pixel
;
4475 int i
= pixel
% CT_SIZE
;
4478 for (p
= ct_table
[i
]; p
; p
= p
->next
)
4479 if (p
->pixel
== pixel
)
4488 #ifdef HAVE_X_WINDOWS
4489 cmap
= FRAME_X_COLORMAP (f
);
4490 color
.pixel
= pixel
;
4491 x_query_color (f
, &color
);
4492 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
4495 cmap
= DefaultColormapOfScreen (FRAME_X_SCREEN (f
));
4496 color
.pixel
= pixel
;
4497 XQueryColor (NULL
, cmap
, &color
);
4498 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
4500 #endif /* HAVE_X_WINDOWS */
4504 ++ct_colors_allocated
;
4506 p
= (struct ct_color
*) xmalloc (sizeof *p
);
4511 p
->next
= ct_table
[i
];
4515 return FRAME_FOREGROUND_PIXEL (f
);
4521 /* Value is a vector of all pixel colors contained in the color table,
4522 allocated via xmalloc. Set *N to the number of colors. */
4524 static unsigned long *
4525 colors_in_color_table (n
)
4530 unsigned long *colors
;
4532 if (ct_colors_allocated
== 0)
4539 colors
= (unsigned long *) xmalloc (ct_colors_allocated
4541 *n
= ct_colors_allocated
;
4543 for (i
= j
= 0; i
< CT_SIZE
; ++i
)
4544 for (p
= ct_table
[i
]; p
; p
= p
->next
)
4545 colors
[j
++] = p
->pixel
;
4551 #else /* COLOR_TABLE_SUPPORT */
4553 static unsigned long
4554 lookup_rgb_color (f
, r
, g
, b
)
4558 unsigned long pixel
;
4561 pixel
= RGB_TO_ULONG (r
>> 8, g
>> 8, b
>> 8);
4562 gamma_correct (f
, &pixel
);
4566 pixel
= PALETTERGB (r
>> 8, g
>> 8, b
>> 8);
4567 #endif /* HAVE_NTGUI */
4576 #endif /* COLOR_TABLE_SUPPORT */
4579 /***********************************************************************
4581 ***********************************************************************/
4583 static XColor
*x_to_xcolors
P_ ((struct frame
*, struct image
*, int));
4584 static void x_from_xcolors
P_ ((struct frame
*, struct image
*, XColor
*));
4585 static void x_detect_edges
P_ ((struct frame
*, struct image
*, int[9], int));
4588 static void XPutPixel (XImagePtr
, int, int, COLORREF
);
4589 #endif /* HAVE_NTGUI */
4591 /* Non-zero means draw a cross on images having `:conversion
4594 int cross_disabled_images
;
4596 /* Edge detection matrices for different edge-detection
4599 static int emboss_matrix
[9] = {
4601 2, -1, 0, /* y - 1 */
4603 0, 1, -2 /* y + 1 */
4606 static int laplace_matrix
[9] = {
4608 1, 0, 0, /* y - 1 */
4610 0, 0, -1 /* y + 1 */
4613 /* Value is the intensity of the color whose red/green/blue values
4616 #define COLOR_INTENSITY(R, G, B) ((2 * (R) + 3 * (G) + (B)) / 6)
4619 /* On frame F, return an array of XColor structures describing image
4620 IMG->pixmap. Each XColor structure has its pixel color set. RGB_P
4621 non-zero means also fill the red/green/blue members of the XColor
4622 structures. Value is a pointer to the array of XColors structures,
4623 allocated with xmalloc; it must be freed by the caller. */
4626 x_to_xcolors (f
, img
, rgb_p
)
4633 XImagePtr_or_DC ximg
;
4637 #endif /* HAVE_NTGUI */
4639 colors
= (XColor
*) xmalloc (img
->width
* img
->height
* sizeof *colors
);
4642 /* Get the X image IMG->pixmap. */
4643 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
4644 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
4646 /* Load the image into a memory device context. */
4647 hdc
= get_frame_dc (f
);
4648 ximg
= CreateCompatibleDC (hdc
);
4649 release_frame_dc (f
, hdc
);
4650 prev
= SelectObject (ximg
, img
->pixmap
);
4651 #endif /* HAVE_NTGUI */
4653 /* Fill the `pixel' members of the XColor array. I wished there
4654 were an easy and portable way to circumvent XGetPixel. */
4656 for (y
= 0; y
< img
->height
; ++y
)
4660 #ifdef HAVE_X_WINDOWS
4661 for (x
= 0; x
< img
->width
; ++x
, ++p
)
4662 p
->pixel
= XGetPixel (ximg
, x
, y
);
4664 x_query_colors (f
, row
, img
->width
);
4668 for (x
= 0; x
< img
->width
; ++x
, ++p
)
4670 /* W32_TODO: palette support needed here? */
4671 p
->pixel
= GET_PIXEL (ximg
, x
, y
);
4675 p
->red
= RED16_FROM_ULONG (p
->pixel
);
4676 p
->green
= GREEN16_FROM_ULONG (p
->pixel
);
4677 p
->blue
= BLUE16_FROM_ULONG (p
->pixel
);
4680 p
->red
= 256 * GetRValue (p
->pixel
);
4681 p
->green
= 256 * GetGValue (p
->pixel
);
4682 p
->blue
= 256 * GetBValue (p
->pixel
);
4683 #endif /* HAVE_NTGUI */
4686 #endif /* HAVE_X_WINDOWS */
4689 Destroy_Image (ximg
, prev
);
4696 /* Put a pixel of COLOR at position X, Y in XIMG. XIMG must have been
4697 created with CreateDIBSection, with the pointer to the bit values
4698 stored in ximg->data. */
4700 static void XPutPixel (ximg
, x
, y
, color
)
4705 int width
= ximg
->info
.bmiHeader
.biWidth
;
4706 int height
= ximg
->info
.bmiHeader
.biHeight
;
4707 unsigned char * pixel
;
4709 /* True color images. */
4710 if (ximg
->info
.bmiHeader
.biBitCount
== 24)
4712 int rowbytes
= width
* 3;
4713 /* Ensure scanlines are aligned on 4 byte boundaries. */
4715 rowbytes
+= 4 - (rowbytes
% 4);
4717 pixel
= ximg
->data
+ y
* rowbytes
+ x
* 3;
4718 /* Windows bitmaps are in BGR order. */
4719 *pixel
= GetBValue (color
);
4720 *(pixel
+ 1) = GetGValue (color
);
4721 *(pixel
+ 2) = GetRValue (color
);
4723 /* Monochrome images. */
4724 else if (ximg
->info
.bmiHeader
.biBitCount
== 1)
4726 int rowbytes
= width
/ 8;
4727 /* Ensure scanlines are aligned on 4 byte boundaries. */
4729 rowbytes
+= 4 - (rowbytes
% 4);
4730 pixel
= ximg
->data
+ y
* rowbytes
+ x
/ 8;
4731 /* Filter out palette info. */
4732 if (color
& 0x00ffffff)
4733 *pixel
= *pixel
| (1 << x
% 8);
4735 *pixel
= *pixel
& ~(1 << x
% 8);
4738 image_error ("XPutPixel: palette image not supported", Qnil
, Qnil
);
4741 #endif /* HAVE_NTGUI */
4743 /* Create IMG->pixmap from an array COLORS of XColor structures, whose
4744 RGB members are set. F is the frame on which this all happens.
4745 COLORS will be freed; an existing IMG->pixmap will be freed, too. */
4748 x_from_xcolors (f
, img
, colors
)
4758 init_color_table ();
4760 x_create_x_image_and_pixmap (f
, img
->width
, img
->height
, 0,
4763 for (y
= 0; y
< img
->height
; ++y
)
4764 for (x
= 0; x
< img
->width
; ++x
, ++p
)
4766 unsigned long pixel
;
4767 pixel
= lookup_rgb_color (f
, p
->red
, p
->green
, p
->blue
);
4768 XPutPixel (oimg
, x
, y
, pixel
);
4772 x_clear_image_1 (f
, img
, 1, 0, 1);
4774 x_put_x_image (f
, oimg
, pixmap
, img
->width
, img
->height
);
4775 x_destroy_x_image (oimg
);
4776 img
->pixmap
= pixmap
;
4777 #ifdef COLOR_TABLE_SUPPORT
4778 img
->colors
= colors_in_color_table (&img
->ncolors
);
4779 free_color_table ();
4780 #endif /* COLOR_TABLE_SUPPORT */
4784 /* On frame F, perform edge-detection on image IMG.
4786 MATRIX is a nine-element array specifying the transformation
4787 matrix. See emboss_matrix for an example.
4789 COLOR_ADJUST is a color adjustment added to each pixel of the
4793 x_detect_edges (f
, img
, matrix
, color_adjust
)
4796 int matrix
[9], color_adjust
;
4798 XColor
*colors
= x_to_xcolors (f
, img
, 1);
4802 for (i
= sum
= 0; i
< 9; ++i
)
4803 sum
+= abs (matrix
[i
]);
4805 #define COLOR(A, X, Y) ((A) + (Y) * img->width + (X))
4807 new = (XColor
*) xmalloc (img
->width
* img
->height
* sizeof *new);
4809 for (y
= 0; y
< img
->height
; ++y
)
4811 p
= COLOR (new, 0, y
);
4812 p
->red
= p
->green
= p
->blue
= 0xffff/2;
4813 p
= COLOR (new, img
->width
- 1, y
);
4814 p
->red
= p
->green
= p
->blue
= 0xffff/2;
4817 for (x
= 1; x
< img
->width
- 1; ++x
)
4819 p
= COLOR (new, x
, 0);
4820 p
->red
= p
->green
= p
->blue
= 0xffff/2;
4821 p
= COLOR (new, x
, img
->height
- 1);
4822 p
->red
= p
->green
= p
->blue
= 0xffff/2;
4825 for (y
= 1; y
< img
->height
- 1; ++y
)
4827 p
= COLOR (new, 1, y
);
4829 for (x
= 1; x
< img
->width
- 1; ++x
, ++p
)
4831 int r
, g
, b
, y1
, x1
;
4834 for (y1
= y
- 1; y1
< y
+ 2; ++y1
)
4835 for (x1
= x
- 1; x1
< x
+ 2; ++x1
, ++i
)
4838 XColor
*t
= COLOR (colors
, x1
, y1
);
4839 r
+= matrix
[i
] * t
->red
;
4840 g
+= matrix
[i
] * t
->green
;
4841 b
+= matrix
[i
] * t
->blue
;
4844 r
= (r
/ sum
+ color_adjust
) & 0xffff;
4845 g
= (g
/ sum
+ color_adjust
) & 0xffff;
4846 b
= (b
/ sum
+ color_adjust
) & 0xffff;
4847 p
->red
= p
->green
= p
->blue
= COLOR_INTENSITY (r
, g
, b
);
4852 x_from_xcolors (f
, img
, new);
4858 /* Perform the pre-defined `emboss' edge-detection on image IMG
4866 x_detect_edges (f
, img
, emboss_matrix
, 0xffff / 2);
4870 /* Transform image IMG which is used on frame F with a Laplace
4871 edge-detection algorithm. The result is an image that can be used
4872 to draw disabled buttons, for example. */
4879 x_detect_edges (f
, img
, laplace_matrix
, 45000);
4883 /* Perform edge-detection on image IMG on frame F, with specified
4884 transformation matrix MATRIX and color-adjustment COLOR_ADJUST.
4886 MATRIX must be either
4888 - a list of at least 9 numbers in row-major form
4889 - a vector of at least 9 numbers
4891 COLOR_ADJUST nil means use a default; otherwise it must be a
4895 x_edge_detection (f
, img
, matrix
, color_adjust
)
4898 Lisp_Object matrix
, color_adjust
;
4906 i
< 9 && CONSP (matrix
) && NUMBERP (XCAR (matrix
));
4907 ++i
, matrix
= XCDR (matrix
))
4908 trans
[i
] = XFLOATINT (XCAR (matrix
));
4910 else if (VECTORP (matrix
) && ASIZE (matrix
) >= 9)
4912 for (i
= 0; i
< 9 && NUMBERP (AREF (matrix
, i
)); ++i
)
4913 trans
[i
] = XFLOATINT (AREF (matrix
, i
));
4916 if (NILP (color_adjust
))
4917 color_adjust
= make_number (0xffff / 2);
4919 if (i
== 9 && NUMBERP (color_adjust
))
4920 x_detect_edges (f
, img
, trans
, (int) XFLOATINT (color_adjust
));
4924 /* Transform image IMG on frame F so that it looks disabled. */
4927 x_disable_image (f
, img
)
4931 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
4933 int n_planes
= dpyinfo
->n_planes
* dpyinfo
->n_cbits
;
4935 int n_planes
= dpyinfo
->n_planes
;
4936 #endif /* HAVE_NTGUI */
4940 /* Color (or grayscale). Convert to gray, and equalize. Just
4941 drawing such images with a stipple can look very odd, so
4942 we're using this method instead. */
4943 XColor
*colors
= x_to_xcolors (f
, img
, 1);
4945 const int h
= 15000;
4946 const int l
= 30000;
4948 for (p
= colors
, end
= colors
+ img
->width
* img
->height
;
4952 int i
= COLOR_INTENSITY (p
->red
, p
->green
, p
->blue
);
4953 int i2
= (0xffff - h
- l
) * i
/ 0xffff + l
;
4954 p
->red
= p
->green
= p
->blue
= i2
;
4957 x_from_xcolors (f
, img
, colors
);
4960 /* Draw a cross over the disabled image, if we must or if we
4962 if (n_planes
< 2 || cross_disabled_images
)
4965 Display
*dpy
= FRAME_X_DISPLAY (f
);
4969 #define XCreateGC_pixmap(dpy, pixmap) XCreateGC (dpy, NULL, 0, NULL)
4970 #define MaskForeground(f) PIX_MASK_DRAW (f)
4972 #define XCreateGC_pixmap(dpy, pixmap) XCreateGC (dpy, pixmap, 0, NULL)
4973 #define MaskForeground(f) WHITE_PIX_DEFAULT (f)
4976 gc
= XCreateGC_pixmap (dpy
, img
->pixmap
);
4977 XSetForeground (dpy
, gc
, BLACK_PIX_DEFAULT (f
));
4978 XDrawLine (dpy
, img
->pixmap
, gc
, 0, 0,
4979 img
->width
- 1, img
->height
- 1);
4980 XDrawLine (dpy
, img
->pixmap
, gc
, 0, img
->height
- 1,
4986 gc
= XCreateGC_pixmap (dpy
, img
->mask
);
4987 XSetForeground (dpy
, gc
, MaskForeground (f
));
4988 XDrawLine (dpy
, img
->mask
, gc
, 0, 0,
4989 img
->width
- 1, img
->height
- 1);
4990 XDrawLine (dpy
, img
->mask
, gc
, 0, img
->height
- 1,
4998 hdc
= get_frame_dc (f
);
4999 bmpdc
= CreateCompatibleDC (hdc
);
5000 release_frame_dc (f
, hdc
);
5002 prev
= SelectObject (bmpdc
, img
->pixmap
);
5004 SetTextColor (bmpdc
, BLACK_PIX_DEFAULT (f
));
5005 MoveToEx (bmpdc
, 0, 0, NULL
);
5006 LineTo (bmpdc
, img
->width
- 1, img
->height
- 1);
5007 MoveToEx (bmpdc
, 0, img
->height
- 1, NULL
);
5008 LineTo (bmpdc
, img
->width
- 1, 0);
5012 SelectObject (bmpdc
, img
->mask
);
5013 SetTextColor (bmpdc
, WHITE_PIX_DEFAULT (f
));
5014 MoveToEx (bmpdc
, 0, 0, NULL
);
5015 LineTo (bmpdc
, img
->width
- 1, img
->height
- 1);
5016 MoveToEx (bmpdc
, 0, img
->height
- 1, NULL
);
5017 LineTo (bmpdc
, img
->width
- 1, 0);
5019 SelectObject (bmpdc
, prev
);
5021 #endif /* HAVE_NTGUI */
5026 /* Build a mask for image IMG which is used on frame F. FILE is the
5027 name of an image file, for error messages. HOW determines how to
5028 determine the background color of IMG. If it is a list '(R G B)',
5029 with R, G, and B being integers >= 0, take that as the color of the
5030 background. Otherwise, determine the background color of IMG
5031 heuristically. Value is non-zero if successful. */
5034 x_build_heuristic_mask (f
, img
, how
)
5039 XImagePtr_or_DC ximg
;
5047 #endif /* HAVE_NTGUI */
5048 int x
, y
, rc
, use_img_background
;
5049 unsigned long bg
= 0;
5053 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
5054 img
->mask
= NO_PIXMAP
;
5055 img
->background_transparent_valid
= 0;
5059 /* Create an image and pixmap serving as mask. */
5060 rc
= x_create_x_image_and_pixmap (f
, img
->width
, img
->height
, 1,
5061 &mask_img
, &img
->mask
);
5065 /* Get the X image of IMG->pixmap. */
5066 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
, 0, 0,
5067 img
->width
, img
->height
,
5070 /* Create the bit array serving as mask. */
5071 row_width
= (img
->width
+ 7) / 8;
5072 mask_img
= xmalloc (row_width
* img
->height
);
5073 bzero (mask_img
, row_width
* img
->height
);
5075 /* Create a memory device context for IMG->pixmap. */
5076 frame_dc
= get_frame_dc (f
);
5077 ximg
= CreateCompatibleDC (frame_dc
);
5078 release_frame_dc (f
, frame_dc
);
5079 prev
= SelectObject (ximg
, img
->pixmap
);
5080 #endif /* HAVE_NTGUI */
5082 /* Determine the background color of ximg. If HOW is `(R G B)'
5083 take that as color. Otherwise, use the image's background color. */
5084 use_img_background
= 1;
5090 for (i
= 0; i
< 3 && CONSP (how
) && NATNUMP (XCAR (how
)); ++i
)
5092 rgb
[i
] = XFASTINT (XCAR (how
)) & 0xffff;
5096 if (i
== 3 && NILP (how
))
5098 char color_name
[30];
5099 sprintf (color_name
, "#%04x%04x%04x", rgb
[0], rgb
[1], rgb
[2]);
5102 0x00ffffff & /* Filter out palette info. */
5103 #endif /* HAVE_NTGUI */
5104 x_alloc_image_color (f
, img
, build_string (color_name
), 0));
5105 use_img_background
= 0;
5109 if (use_img_background
)
5110 bg
= four_corners_best (ximg
, img
->width
, img
->height
);
5112 /* Set all bits in mask_img to 1 whose color in ximg is different
5113 from the background color bg. */
5115 for (y
= 0; y
< img
->height
; ++y
)
5116 for (x
= 0; x
< img
->width
; ++x
)
5117 XPutPixel (mask_img
, x
, y
, (XGetPixel (ximg
, x
, y
) != bg
5118 ? PIX_MASK_DRAW (f
) : PIX_MASK_RETAIN (f
)));
5120 /* Fill in the background_transparent field while we have the mask handy. */
5121 image_background_transparent (img
, f
, mask_img
);
5123 /* Put mask_img into img->mask. */
5124 x_put_x_image (f
, mask_img
, img
->mask
, img
->width
, img
->height
);
5125 x_destroy_x_image (mask_img
);
5128 for (y
= 0; y
< img
->height
; ++y
)
5129 for (x
= 0; x
< img
->width
; ++x
)
5131 COLORREF p
= GetPixel (ximg
, x
, y
);
5133 mask_img
[y
* row_width
+ x
/ 8] |= 1 << (x
% 8);
5136 /* Create the mask image. */
5137 img
->mask
= w32_create_pixmap_from_bitmap_data (img
->width
, img
->height
,
5139 /* Fill in the background_transparent field while we have the mask handy. */
5140 SelectObject (ximg
, img
->mask
);
5141 image_background_transparent (img
, f
, ximg
);
5143 /* Was: x_destroy_x_image ((XImagePtr )mask_img); which seems bogus ++kfs */
5145 #endif /* HAVE_NTGUI */
5147 Destroy_Image (ximg
, prev
);
5153 /***********************************************************************
5154 PBM (mono, gray, color)
5155 ***********************************************************************/
5157 static int pbm_image_p
P_ ((Lisp_Object object
));
5158 static int pbm_load
P_ ((struct frame
*f
, struct image
*img
));
5159 static int pbm_scan_number
P_ ((unsigned char **, unsigned char *));
5161 /* The symbol `pbm' identifying images of this type. */
5165 /* Indices of image specification fields in gs_format, below. */
5167 enum pbm_keyword_index
5183 /* Vector of image_keyword structures describing the format
5184 of valid user-defined image specifications. */
5186 static struct image_keyword pbm_format
[PBM_LAST
] =
5188 {":type", IMAGE_SYMBOL_VALUE
, 1},
5189 {":file", IMAGE_STRING_VALUE
, 0},
5190 {":data", IMAGE_STRING_VALUE
, 0},
5191 {":ascent", IMAGE_ASCENT_VALUE
, 0},
5192 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
5193 {":relief", IMAGE_INTEGER_VALUE
, 0},
5194 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5195 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5196 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5197 {":foreground", IMAGE_STRING_OR_NIL_VALUE
, 0},
5198 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
5201 /* Structure describing the image type `pbm'. */
5203 static struct image_type pbm_type
=
5213 /* Return non-zero if OBJECT is a valid PBM image specification. */
5216 pbm_image_p (object
)
5219 struct image_keyword fmt
[PBM_LAST
];
5221 bcopy (pbm_format
, fmt
, sizeof fmt
);
5223 if (!parse_image_spec (object
, fmt
, PBM_LAST
, Qpbm
))
5226 /* Must specify either :data or :file. */
5227 return fmt
[PBM_DATA
].count
+ fmt
[PBM_FILE
].count
== 1;
5231 /* Scan a decimal number from *S and return it. Advance *S while
5232 reading the number. END is the end of the string. Value is -1 at
5236 pbm_scan_number (s
, end
)
5237 unsigned char **s
, *end
;
5239 int c
= 0, val
= -1;
5243 /* Skip white-space. */
5244 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
5249 /* Skip comment to end of line. */
5250 while (*s
< end
&& (c
= *(*s
)++, c
!= '\n'))
5253 else if (isdigit (c
))
5255 /* Read decimal number. */
5257 while (*s
< end
&& (c
= *(*s
)++, isdigit (c
)))
5258 val
= 10 * val
+ c
- '0';
5270 #if 0 /* Unused. ++kfs */
5272 /* Read FILE into memory. Value is a pointer to a buffer allocated
5273 with xmalloc holding FILE's contents. Value is null if an error
5274 occurred. *SIZE is set to the size of the file. */
5277 pbm_read_file (file
, size
)
5285 if (stat (SDATA (file
), &st
) == 0
5286 && (fp
= fopen (SDATA (file
), "rb")) != NULL
5287 && (buf
= (char *) xmalloc (st
.st_size
),
5288 fread (buf
, 1, st
.st_size
, fp
) == st
.st_size
))
5307 #endif /* HAVE_NTGUI */
5309 /* Load PBM image IMG for use on frame F. */
5317 int width
, height
, max_color_idx
= 0;
5319 Lisp_Object file
, specified_file
;
5320 enum {PBM_MONO
, PBM_GRAY
, PBM_COLOR
} type
;
5321 struct gcpro gcpro1
;
5322 unsigned char *contents
= NULL
;
5323 unsigned char *end
, *p
;
5326 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
5330 if (STRINGP (specified_file
))
5332 file
= x_find_image_file (specified_file
);
5333 if (!STRINGP (file
))
5335 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
5340 contents
= slurp_file (SDATA (file
), &size
);
5341 if (contents
== NULL
)
5343 image_error ("Error reading `%s'", file
, Qnil
);
5349 end
= contents
+ size
;
5354 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
5356 end
= p
+ SBYTES (data
);
5359 /* Check magic number. */
5360 if (end
- p
< 2 || *p
++ != 'P')
5362 image_error ("Not a PBM image: `%s'", img
->spec
, Qnil
);
5372 raw_p
= 0, type
= PBM_MONO
;
5376 raw_p
= 0, type
= PBM_GRAY
;
5380 raw_p
= 0, type
= PBM_COLOR
;
5384 raw_p
= 1, type
= PBM_MONO
;
5388 raw_p
= 1, type
= PBM_GRAY
;
5392 raw_p
= 1, type
= PBM_COLOR
;
5396 image_error ("Not a PBM image: `%s'", img
->spec
, Qnil
);
5400 /* Read width, height, maximum color-component. Characters
5401 starting with `#' up to the end of a line are ignored. */
5402 width
= pbm_scan_number (&p
, end
);
5403 height
= pbm_scan_number (&p
, end
);
5405 if (type
!= PBM_MONO
)
5407 max_color_idx
= pbm_scan_number (&p
, end
);
5408 if (raw_p
&& max_color_idx
> 255)
5409 max_color_idx
= 255;
5414 || (type
!= PBM_MONO
&& max_color_idx
< 0))
5417 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0,
5418 &ximg
, &img
->pixmap
))
5421 /* Initialize the color hash table. */
5422 init_color_table ();
5424 if (type
== PBM_MONO
)
5427 struct image_keyword fmt
[PBM_LAST
];
5428 unsigned long fg
= FRAME_FOREGROUND_PIXEL (f
);
5429 unsigned long bg
= FRAME_BACKGROUND_PIXEL (f
);
5431 /* Parse the image specification. */
5432 bcopy (pbm_format
, fmt
, sizeof fmt
);
5433 parse_image_spec (img
->spec
, fmt
, PBM_LAST
, Qpbm
);
5435 /* Get foreground and background colors, maybe allocate colors. */
5436 if (fmt
[PBM_FOREGROUND
].count
5437 && STRINGP (fmt
[PBM_FOREGROUND
].value
))
5438 fg
= x_alloc_image_color (f
, img
, fmt
[PBM_FOREGROUND
].value
, fg
);
5439 if (fmt
[PBM_BACKGROUND
].count
5440 && STRINGP (fmt
[PBM_BACKGROUND
].value
))
5442 bg
= x_alloc_image_color (f
, img
, fmt
[PBM_BACKGROUND
].value
, bg
);
5443 img
->background
= bg
;
5444 img
->background_valid
= 1;
5447 for (y
= 0; y
< height
; ++y
)
5448 for (x
= 0; x
< width
; ++x
)
5458 g
= pbm_scan_number (&p
, end
);
5460 XPutPixel (ximg
, x
, y
, g
? fg
: bg
);
5465 for (y
= 0; y
< height
; ++y
)
5466 for (x
= 0; x
< width
; ++x
)
5470 if (type
== PBM_GRAY
)
5471 r
= g
= b
= raw_p
? *p
++ : pbm_scan_number (&p
, end
);
5480 r
= pbm_scan_number (&p
, end
);
5481 g
= pbm_scan_number (&p
, end
);
5482 b
= pbm_scan_number (&p
, end
);
5485 if (r
< 0 || g
< 0 || b
< 0)
5487 x_destroy_x_image (ximg
);
5488 image_error ("Invalid pixel value in image `%s'",
5493 /* RGB values are now in the range 0..max_color_idx.
5494 Scale this to the range 0..0xffff supported by X. */
5495 r
= (double) r
* 65535 / max_color_idx
;
5496 g
= (double) g
* 65535 / max_color_idx
;
5497 b
= (double) b
* 65535 / max_color_idx
;
5498 XPutPixel (ximg
, x
, y
, lookup_rgb_color (f
, r
, g
, b
));
5502 #ifdef COLOR_TABLE_SUPPORT
5503 /* Store in IMG->colors the colors allocated for the image, and
5504 free the color table. */
5505 img
->colors
= colors_in_color_table (&img
->ncolors
);
5506 free_color_table ();
5507 #endif /* COLOR_TABLE_SUPPORT */
5510 img
->height
= height
;
5512 /* Maybe fill in the background field while we have ximg handy. */
5514 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
5515 IMAGE_BACKGROUND (img
, f
, ximg
);
5517 /* Put the image into a pixmap. */
5518 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
5519 x_destroy_x_image (ximg
);
5521 /* X and W32 versions did it here, MAC version above. ++kfs
5523 img->height = height; */
5531 /***********************************************************************
5533 ***********************************************************************/
5535 #if defined (HAVE_PNG) || defined (MAC_OS)
5537 /* Function prototypes. */
5539 static int png_image_p
P_ ((Lisp_Object object
));
5540 static int png_load
P_ ((struct frame
*f
, struct image
*img
));
5542 /* The symbol `png' identifying images of this type. */
5546 /* Indices of image specification fields in png_format, below. */
5548 enum png_keyword_index
5563 /* Vector of image_keyword structures describing the format
5564 of valid user-defined image specifications. */
5566 static struct image_keyword png_format
[PNG_LAST
] =
5568 {":type", IMAGE_SYMBOL_VALUE
, 1},
5569 {":data", IMAGE_STRING_VALUE
, 0},
5570 {":file", IMAGE_STRING_VALUE
, 0},
5571 {":ascent", IMAGE_ASCENT_VALUE
, 0},
5572 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
5573 {":relief", IMAGE_INTEGER_VALUE
, 0},
5574 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5575 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5576 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5577 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
5580 /* Structure describing the image type `png'. */
5582 static struct image_type png_type
=
5591 /* Return non-zero if OBJECT is a valid PNG image specification. */
5594 png_image_p (object
)
5597 struct image_keyword fmt
[PNG_LAST
];
5598 bcopy (png_format
, fmt
, sizeof fmt
);
5600 if (!parse_image_spec (object
, fmt
, PNG_LAST
, Qpng
))
5603 /* Must specify either the :data or :file keyword. */
5604 return fmt
[PNG_FILE
].count
+ fmt
[PNG_DATA
].count
== 1;
5607 #endif /* HAVE_PNG || MAC_OS */
5612 #if defined HAVE_LIBPNG_PNG_H
5613 # include <libpng/png.h>
5619 /* PNG library details. */
5621 DEF_IMGLIB_FN (png_get_io_ptr
);
5622 DEF_IMGLIB_FN (png_check_sig
);
5623 DEF_IMGLIB_FN (png_create_read_struct
);
5624 DEF_IMGLIB_FN (png_create_info_struct
);
5625 DEF_IMGLIB_FN (png_destroy_read_struct
);
5626 DEF_IMGLIB_FN (png_set_read_fn
);
5627 DEF_IMGLIB_FN (png_init_io
);
5628 DEF_IMGLIB_FN (png_set_sig_bytes
);
5629 DEF_IMGLIB_FN (png_read_info
);
5630 DEF_IMGLIB_FN (png_get_IHDR
);
5631 DEF_IMGLIB_FN (png_get_valid
);
5632 DEF_IMGLIB_FN (png_set_strip_16
);
5633 DEF_IMGLIB_FN (png_set_expand
);
5634 DEF_IMGLIB_FN (png_set_gray_to_rgb
);
5635 DEF_IMGLIB_FN (png_set_background
);
5636 DEF_IMGLIB_FN (png_get_bKGD
);
5637 DEF_IMGLIB_FN (png_read_update_info
);
5638 DEF_IMGLIB_FN (png_get_channels
);
5639 DEF_IMGLIB_FN (png_get_rowbytes
);
5640 DEF_IMGLIB_FN (png_read_image
);
5641 DEF_IMGLIB_FN (png_read_end
);
5642 DEF_IMGLIB_FN (png_error
);
5645 init_png_functions (Lisp_Object libraries
)
5649 /* Try loading libpng under probable names. */
5650 if (!(library
= w32_delayed_load (libraries
, Qpng
)))
5653 LOAD_IMGLIB_FN (library
, png_get_io_ptr
);
5654 LOAD_IMGLIB_FN (library
, png_check_sig
);
5655 LOAD_IMGLIB_FN (library
, png_create_read_struct
);
5656 LOAD_IMGLIB_FN (library
, png_create_info_struct
);
5657 LOAD_IMGLIB_FN (library
, png_destroy_read_struct
);
5658 LOAD_IMGLIB_FN (library
, png_set_read_fn
);
5659 LOAD_IMGLIB_FN (library
, png_init_io
);
5660 LOAD_IMGLIB_FN (library
, png_set_sig_bytes
);
5661 LOAD_IMGLIB_FN (library
, png_read_info
);
5662 LOAD_IMGLIB_FN (library
, png_get_IHDR
);
5663 LOAD_IMGLIB_FN (library
, png_get_valid
);
5664 LOAD_IMGLIB_FN (library
, png_set_strip_16
);
5665 LOAD_IMGLIB_FN (library
, png_set_expand
);
5666 LOAD_IMGLIB_FN (library
, png_set_gray_to_rgb
);
5667 LOAD_IMGLIB_FN (library
, png_set_background
);
5668 LOAD_IMGLIB_FN (library
, png_get_bKGD
);
5669 LOAD_IMGLIB_FN (library
, png_read_update_info
);
5670 LOAD_IMGLIB_FN (library
, png_get_channels
);
5671 LOAD_IMGLIB_FN (library
, png_get_rowbytes
);
5672 LOAD_IMGLIB_FN (library
, png_read_image
);
5673 LOAD_IMGLIB_FN (library
, png_read_end
);
5674 LOAD_IMGLIB_FN (library
, png_error
);
5679 #define fn_png_get_io_ptr png_get_io_ptr
5680 #define fn_png_check_sig png_check_sig
5681 #define fn_png_create_read_struct png_create_read_struct
5682 #define fn_png_create_info_struct png_create_info_struct
5683 #define fn_png_destroy_read_struct png_destroy_read_struct
5684 #define fn_png_set_read_fn png_set_read_fn
5685 #define fn_png_init_io png_init_io
5686 #define fn_png_set_sig_bytes png_set_sig_bytes
5687 #define fn_png_read_info png_read_info
5688 #define fn_png_get_IHDR png_get_IHDR
5689 #define fn_png_get_valid png_get_valid
5690 #define fn_png_set_strip_16 png_set_strip_16
5691 #define fn_png_set_expand png_set_expand
5692 #define fn_png_set_gray_to_rgb png_set_gray_to_rgb
5693 #define fn_png_set_background png_set_background
5694 #define fn_png_get_bKGD png_get_bKGD
5695 #define fn_png_read_update_info png_read_update_info
5696 #define fn_png_get_channels png_get_channels
5697 #define fn_png_get_rowbytes png_get_rowbytes
5698 #define fn_png_read_image png_read_image
5699 #define fn_png_read_end png_read_end
5700 #define fn_png_error png_error
5702 #endif /* HAVE_NTGUI */
5704 /* Error and warning handlers installed when the PNG library
5708 my_png_error (png_ptr
, msg
)
5709 png_struct
*png_ptr
;
5712 xassert (png_ptr
!= NULL
);
5713 image_error ("PNG error: %s", build_string (msg
), Qnil
);
5714 longjmp (png_ptr
->jmpbuf
, 1);
5719 my_png_warning (png_ptr
, msg
)
5720 png_struct
*png_ptr
;
5723 xassert (png_ptr
!= NULL
);
5724 image_error ("PNG warning: %s", build_string (msg
), Qnil
);
5727 /* Memory source for PNG decoding. */
5729 struct png_memory_storage
5731 unsigned char *bytes
; /* The data */
5732 size_t len
; /* How big is it? */
5733 int index
; /* Where are we? */
5737 /* Function set as reader function when reading PNG image from memory.
5738 PNG_PTR is a pointer to the PNG control structure. Copy LENGTH
5739 bytes from the input to DATA. */
5742 /* Work around a problem with MinGW builds of graphics libraries
5743 not honoring calling conventions. */
5744 #pragma optimize("g", off)
5748 png_read_from_memory (png_ptr
, data
, length
)
5749 png_structp png_ptr
;
5753 struct png_memory_storage
*tbr
5754 = (struct png_memory_storage
*) fn_png_get_io_ptr (png_ptr
);
5756 if (length
> tbr
->len
- tbr
->index
)
5757 fn_png_error (png_ptr
, "Read error");
5759 bcopy (tbr
->bytes
+ tbr
->index
, data
, length
);
5760 tbr
->index
= tbr
->index
+ length
;
5764 /* Restore normal optimization, as specified on the command line. */
5765 #pragma optimize("", on)
5768 /* Load PNG image IMG for use on frame F. Value is non-zero if
5776 Lisp_Object file
, specified_file
;
5777 Lisp_Object specified_data
;
5779 XImagePtr ximg
, mask_img
= NULL
;
5780 struct gcpro gcpro1
;
5781 png_struct
*png_ptr
= NULL
;
5782 png_info
*info_ptr
= NULL
, *end_info
= NULL
;
5783 FILE *volatile fp
= NULL
;
5785 png_byte
* volatile pixels
= NULL
;
5786 png_byte
** volatile rows
= NULL
;
5787 png_uint_32 width
, height
;
5788 int bit_depth
, color_type
, interlace_type
;
5790 png_uint_32 row_bytes
;
5792 double screen_gamma
;
5793 struct png_memory_storage tbr
; /* Data to be read */
5795 /* Find out what file to load. */
5796 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
5797 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
5801 if (NILP (specified_data
))
5803 file
= x_find_image_file (specified_file
);
5804 if (!STRINGP (file
))
5806 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
5811 /* Open the image file. */
5812 fp
= fopen (SDATA (file
), "rb");
5815 image_error ("Cannot open image file `%s'", file
, Qnil
);
5821 /* Check PNG signature. */
5822 if (fread (sig
, 1, sizeof sig
, fp
) != sizeof sig
5823 || !fn_png_check_sig (sig
, sizeof sig
))
5825 image_error ("Not a PNG file: `%s'", file
, Qnil
);
5833 /* Read from memory. */
5834 tbr
.bytes
= SDATA (specified_data
);
5835 tbr
.len
= SBYTES (specified_data
);
5838 /* Check PNG signature. */
5839 if (tbr
.len
< sizeof sig
5840 || !fn_png_check_sig (tbr
.bytes
, sizeof sig
))
5842 image_error ("Not a PNG image: `%s'", img
->spec
, Qnil
);
5847 /* Need to skip past the signature. */
5848 tbr
.bytes
+= sizeof (sig
);
5851 /* Initialize read and info structs for PNG lib. */
5852 png_ptr
= fn_png_create_read_struct (PNG_LIBPNG_VER_STRING
, NULL
,
5853 my_png_error
, my_png_warning
);
5856 if (fp
) fclose (fp
);
5861 info_ptr
= fn_png_create_info_struct (png_ptr
);
5864 fn_png_destroy_read_struct (&png_ptr
, NULL
, NULL
);
5865 if (fp
) fclose (fp
);
5870 end_info
= fn_png_create_info_struct (png_ptr
);
5873 fn_png_destroy_read_struct (&png_ptr
, &info_ptr
, NULL
);
5874 if (fp
) fclose (fp
);
5879 /* Set error jump-back. We come back here when the PNG library
5880 detects an error. */
5881 if (setjmp (png_ptr
->jmpbuf
))
5885 fn_png_destroy_read_struct (&png_ptr
, &info_ptr
, &end_info
);
5888 if (fp
) fclose (fp
);
5893 /* Read image info. */
5894 if (!NILP (specified_data
))
5895 fn_png_set_read_fn (png_ptr
, (void *) &tbr
, png_read_from_memory
);
5897 fn_png_init_io (png_ptr
, fp
);
5899 fn_png_set_sig_bytes (png_ptr
, sizeof sig
);
5900 fn_png_read_info (png_ptr
, info_ptr
);
5901 fn_png_get_IHDR (png_ptr
, info_ptr
, &width
, &height
, &bit_depth
, &color_type
,
5902 &interlace_type
, NULL
, NULL
);
5904 /* If image contains simply transparency data, we prefer to
5905 construct a clipping mask. */
5906 if (fn_png_get_valid (png_ptr
, info_ptr
, PNG_INFO_tRNS
))
5911 /* This function is easier to write if we only have to handle
5912 one data format: RGB or RGBA with 8 bits per channel. Let's
5913 transform other formats into that format. */
5915 /* Strip more than 8 bits per channel. */
5916 if (bit_depth
== 16)
5917 fn_png_set_strip_16 (png_ptr
);
5919 /* Expand data to 24 bit RGB, or 8 bit grayscale, with alpha channel
5921 fn_png_set_expand (png_ptr
);
5923 /* Convert grayscale images to RGB. */
5924 if (color_type
== PNG_COLOR_TYPE_GRAY
5925 || color_type
== PNG_COLOR_TYPE_GRAY_ALPHA
)
5926 fn_png_set_gray_to_rgb (png_ptr
);
5928 screen_gamma
= (f
->gamma
? 1 / f
->gamma
/ 0.45455 : 2.2);
5930 #if 0 /* Avoid double gamma correction for PNG images. */
5931 { /* Tell the PNG lib to handle gamma correction for us. */
5934 #if defined(PNG_READ_sRGB_SUPPORTED) || defined(PNG_WRITE_sRGB_SUPPORTED)
5935 if (png_get_sRGB (png_ptr
, info_ptr
, &intent
))
5936 /* The libpng documentation says this is right in this case. */
5937 png_set_gamma (png_ptr
, screen_gamma
, 0.45455);
5940 if (png_get_gAMA (png_ptr
, info_ptr
, &image_gamma
))
5941 /* Image contains gamma information. */
5942 png_set_gamma (png_ptr
, screen_gamma
, image_gamma
);
5944 /* Use the standard default for the image gamma. */
5945 png_set_gamma (png_ptr
, screen_gamma
, 0.45455);
5949 /* Handle alpha channel by combining the image with a background
5950 color. Do this only if a real alpha channel is supplied. For
5951 simple transparency, we prefer a clipping mask. */
5954 png_color_16
*image_bg
;
5955 Lisp_Object specified_bg
5956 = image_spec_value (img
->spec
, QCbackground
, NULL
);
5958 if (STRINGP (specified_bg
))
5959 /* The user specified `:background', use that. */
5961 /* W32 version incorrectly used COLORREF here!! ++kfs */
5963 if (x_defined_color (f
, SDATA (specified_bg
), &color
, 0))
5965 png_color_16 user_bg
;
5967 bzero (&user_bg
, sizeof user_bg
);
5968 user_bg
.red
= color
.red
>> 8;
5969 user_bg
.green
= color
.green
>> 8;
5970 user_bg
.blue
= color
.blue
>> 8;
5972 fn_png_set_background (png_ptr
, &user_bg
,
5973 PNG_BACKGROUND_GAMMA_SCREEN
, 0, 1.0);
5976 else if (fn_png_get_bKGD (png_ptr
, info_ptr
, &image_bg
))
5977 /* Image contains a background color with which to
5978 combine the image. */
5979 fn_png_set_background (png_ptr
, image_bg
,
5980 PNG_BACKGROUND_GAMMA_FILE
, 1, 1.0);
5983 /* Image does not contain a background color with which
5984 to combine the image data via an alpha channel. Use
5985 the frame's background instead. */
5986 #ifdef HAVE_X_WINDOWS
5988 png_color_16 frame_background
;
5990 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
5991 x_query_color (f
, &color
);
5993 bzero (&frame_background
, sizeof frame_background
);
5994 frame_background
.red
= color
.red
>> 8;
5995 frame_background
.green
= color
.green
>> 8;
5996 frame_background
.blue
= color
.blue
>> 8;
5997 #endif /* HAVE_X_WINDOWS */
6001 png_color_16 frame_background
;
6002 color
= FRAME_BACKGROUND_PIXEL (f
);
6003 #if 0 /* W32 TODO : Colormap support. */
6004 x_query_color (f
, &color
);
6006 bzero (&frame_background
, sizeof frame_background
);
6007 frame_background
.red
= GetRValue (color
);
6008 frame_background
.green
= GetGValue (color
);
6009 frame_background
.blue
= GetBValue (color
);
6010 #endif /* HAVE_NTGUI */
6013 unsigned long color
;
6014 png_color_16 frame_background
;
6015 color
= FRAME_BACKGROUND_PIXEL (f
);
6016 #if 0 /* MAC/W32 TODO : Colormap support. */
6017 x_query_color (f
, &color
);
6019 bzero (&frame_background
, sizeof frame_background
);
6020 frame_background
.red
= RED_FROM_ULONG (color
);
6021 frame_background
.green
= GREEN_FROM_ULONG (color
);
6022 frame_background
.blue
= BLUE_FROM_ULONG (color
);
6025 fn_png_set_background (png_ptr
, &frame_background
,
6026 PNG_BACKGROUND_GAMMA_SCREEN
, 0, 1.0);
6030 /* Update info structure. */
6031 fn_png_read_update_info (png_ptr
, info_ptr
);
6033 /* Get number of channels. Valid values are 1 for grayscale images
6034 and images with a palette, 2 for grayscale images with transparency
6035 information (alpha channel), 3 for RGB images, and 4 for RGB
6036 images with alpha channel, i.e. RGBA. If conversions above were
6037 sufficient we should only have 3 or 4 channels here. */
6038 channels
= fn_png_get_channels (png_ptr
, info_ptr
);
6039 xassert (channels
== 3 || channels
== 4);
6041 /* Number of bytes needed for one row of the image. */
6042 row_bytes
= fn_png_get_rowbytes (png_ptr
, info_ptr
);
6044 /* Allocate memory for the image. */
6045 pixels
= (png_byte
*) xmalloc (row_bytes
* height
* sizeof *pixels
);
6046 rows
= (png_byte
**) xmalloc (height
* sizeof *rows
);
6047 for (i
= 0; i
< height
; ++i
)
6048 rows
[i
] = pixels
+ i
* row_bytes
;
6050 /* Read the entire image. */
6051 fn_png_read_image (png_ptr
, rows
);
6052 fn_png_read_end (png_ptr
, info_ptr
);
6059 /* Create the X image and pixmap. */
6060 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
,
6064 /* Create an image and pixmap serving as mask if the PNG image
6065 contains an alpha channel. */
6068 && !x_create_x_image_and_pixmap (f
, width
, height
, 1,
6069 &mask_img
, &img
->mask
))
6071 x_destroy_x_image (ximg
);
6072 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->pixmap
);
6073 img
->pixmap
= NO_PIXMAP
;
6077 /* Fill the X image and mask from PNG data. */
6078 init_color_table ();
6080 for (y
= 0; y
< height
; ++y
)
6082 png_byte
*p
= rows
[y
];
6084 for (x
= 0; x
< width
; ++x
)
6091 XPutPixel (ximg
, x
, y
, lookup_rgb_color (f
, r
, g
, b
));
6092 /* An alpha channel, aka mask channel, associates variable
6093 transparency with an image. Where other image formats
6094 support binary transparency---fully transparent or fully
6095 opaque---PNG allows up to 254 levels of partial transparency.
6096 The PNG library implements partial transparency by combining
6097 the image with a specified background color.
6099 I'm not sure how to handle this here nicely: because the
6100 background on which the image is displayed may change, for
6101 real alpha channel support, it would be necessary to create
6102 a new image for each possible background.
6104 What I'm doing now is that a mask is created if we have
6105 boolean transparency information. Otherwise I'm using
6106 the frame's background color to combine the image with. */
6111 XPutPixel (mask_img
, x
, y
, *p
> 0 ? PIX_MASK_DRAW (f
) : PIX_MASK_RETAIN (f
));
6117 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
6118 /* Set IMG's background color from the PNG image, unless the user
6122 if (fn_png_get_bKGD (png_ptr
, info_ptr
, &bg
))
6124 img
->background
= lookup_rgb_color (f
, bg
->red
, bg
->green
, bg
->blue
);
6125 img
->background_valid
= 1;
6129 #ifdef COLOR_TABLE_SUPPORT
6130 /* Remember colors allocated for this image. */
6131 img
->colors
= colors_in_color_table (&img
->ncolors
);
6132 free_color_table ();
6133 #endif /* COLOR_TABLE_SUPPORT */
6136 fn_png_destroy_read_struct (&png_ptr
, &info_ptr
, &end_info
);
6141 img
->height
= height
;
6143 /* Maybe fill in the background field while we have ximg handy. */
6144 IMAGE_BACKGROUND (img
, f
, ximg
);
6146 /* Put the image into the pixmap, then free the X image and its buffer. */
6147 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
6148 x_destroy_x_image (ximg
);
6150 /* Same for the mask. */
6153 /* Fill in the background_transparent field while we have the mask
6155 image_background_transparent (img
, f
, mask_img
);
6157 x_put_x_image (f
, mask_img
, img
->mask
, img
->width
, img
->height
);
6158 x_destroy_x_image (mask_img
);
6165 #else /* HAVE_PNG */
6174 if (MyCGImageCreateWithPNGDataProvider
)
6175 return image_load_quartz2d (f
, img
, 1);
6178 return image_load_quicktime (f
, img
, kQTFileTypePNG
);
6182 #endif /* !HAVE_PNG */
6186 /***********************************************************************
6188 ***********************************************************************/
6190 #if defined (HAVE_JPEG) || defined (MAC_OS)
6192 static int jpeg_image_p
P_ ((Lisp_Object object
));
6193 static int jpeg_load
P_ ((struct frame
*f
, struct image
*img
));
6195 /* The symbol `jpeg' identifying images of this type. */
6199 /* Indices of image specification fields in gs_format, below. */
6201 enum jpeg_keyword_index
6210 JPEG_HEURISTIC_MASK
,
6216 /* Vector of image_keyword structures describing the format
6217 of valid user-defined image specifications. */
6219 static struct image_keyword jpeg_format
[JPEG_LAST
] =
6221 {":type", IMAGE_SYMBOL_VALUE
, 1},
6222 {":data", IMAGE_STRING_VALUE
, 0},
6223 {":file", IMAGE_STRING_VALUE
, 0},
6224 {":ascent", IMAGE_ASCENT_VALUE
, 0},
6225 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
6226 {":relief", IMAGE_INTEGER_VALUE
, 0},
6227 {":conversions", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6228 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6229 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6230 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
6233 /* Structure describing the image type `jpeg'. */
6235 static struct image_type jpeg_type
=
6244 /* Return non-zero if OBJECT is a valid JPEG image specification. */
6247 jpeg_image_p (object
)
6250 struct image_keyword fmt
[JPEG_LAST
];
6252 bcopy (jpeg_format
, fmt
, sizeof fmt
);
6254 if (!parse_image_spec (object
, fmt
, JPEG_LAST
, Qjpeg
))
6257 /* Must specify either the :data or :file keyword. */
6258 return fmt
[JPEG_FILE
].count
+ fmt
[JPEG_DATA
].count
== 1;
6261 #endif /* HAVE_JPEG || MAC_OS */
6265 /* Work around a warning about HAVE_STDLIB_H being redefined in
6267 #ifdef HAVE_STDLIB_H
6268 #define HAVE_STDLIB_H_1
6269 #undef HAVE_STDLIB_H
6270 #endif /* HAVE_STLIB_H */
6272 #include <jpeglib.h>
6276 #ifdef HAVE_STLIB_H_1
6277 #define HAVE_STDLIB_H 1
6282 /* JPEG library details. */
6283 DEF_IMGLIB_FN (jpeg_CreateDecompress
);
6284 DEF_IMGLIB_FN (jpeg_start_decompress
);
6285 DEF_IMGLIB_FN (jpeg_finish_decompress
);
6286 DEF_IMGLIB_FN (jpeg_destroy_decompress
);
6287 DEF_IMGLIB_FN (jpeg_read_header
);
6288 DEF_IMGLIB_FN (jpeg_read_scanlines
);
6289 DEF_IMGLIB_FN (jpeg_stdio_src
);
6290 DEF_IMGLIB_FN (jpeg_std_error
);
6291 DEF_IMGLIB_FN (jpeg_resync_to_restart
);
6294 init_jpeg_functions (Lisp_Object libraries
)
6298 if (!(library
= w32_delayed_load (libraries
, Qjpeg
)))
6301 LOAD_IMGLIB_FN (library
, jpeg_finish_decompress
);
6302 LOAD_IMGLIB_FN (library
, jpeg_read_scanlines
);
6303 LOAD_IMGLIB_FN (library
, jpeg_start_decompress
);
6304 LOAD_IMGLIB_FN (library
, jpeg_read_header
);
6305 LOAD_IMGLIB_FN (library
, jpeg_stdio_src
);
6306 LOAD_IMGLIB_FN (library
, jpeg_CreateDecompress
);
6307 LOAD_IMGLIB_FN (library
, jpeg_destroy_decompress
);
6308 LOAD_IMGLIB_FN (library
, jpeg_std_error
);
6309 LOAD_IMGLIB_FN (library
, jpeg_resync_to_restart
);
6313 /* Wrapper since we can't directly assign the function pointer
6314 to another function pointer that was declared more completely easily. */
6316 jpeg_resync_to_restart_wrapper(cinfo
, desired
)
6317 j_decompress_ptr cinfo
;
6320 return fn_jpeg_resync_to_restart (cinfo
, desired
);
6325 #define fn_jpeg_CreateDecompress(a,b,c) jpeg_create_decompress(a)
6326 #define fn_jpeg_start_decompress jpeg_start_decompress
6327 #define fn_jpeg_finish_decompress jpeg_finish_decompress
6328 #define fn_jpeg_destroy_decompress jpeg_destroy_decompress
6329 #define fn_jpeg_read_header jpeg_read_header
6330 #define fn_jpeg_read_scanlines jpeg_read_scanlines
6331 #define fn_jpeg_stdio_src jpeg_stdio_src
6332 #define fn_jpeg_std_error jpeg_std_error
6333 #define jpeg_resync_to_restart_wrapper jpeg_resync_to_restart
6335 #endif /* HAVE_NTGUI */
6337 struct my_jpeg_error_mgr
6339 struct jpeg_error_mgr pub
;
6340 jmp_buf setjmp_buffer
;
6345 my_error_exit (cinfo
)
6348 struct my_jpeg_error_mgr
*mgr
= (struct my_jpeg_error_mgr
*) cinfo
->err
;
6349 longjmp (mgr
->setjmp_buffer
, 1);
6353 /* Init source method for JPEG data source manager. Called by
6354 jpeg_read_header() before any data is actually read. See
6355 libjpeg.doc from the JPEG lib distribution. */
6358 our_init_source (cinfo
)
6359 j_decompress_ptr cinfo
;
6364 /* Fill input buffer method for JPEG data source manager. Called
6365 whenever more data is needed. We read the whole image in one step,
6366 so this only adds a fake end of input marker at the end. */
6369 our_fill_input_buffer (cinfo
)
6370 j_decompress_ptr cinfo
;
6372 /* Insert a fake EOI marker. */
6373 struct jpeg_source_mgr
*src
= cinfo
->src
;
6374 static JOCTET buffer
[2];
6376 buffer
[0] = (JOCTET
) 0xFF;
6377 buffer
[1] = (JOCTET
) JPEG_EOI
;
6379 src
->next_input_byte
= buffer
;
6380 src
->bytes_in_buffer
= 2;
6385 /* Method to skip over NUM_BYTES bytes in the image data. CINFO->src
6386 is the JPEG data source manager. */
6389 our_skip_input_data (cinfo
, num_bytes
)
6390 j_decompress_ptr cinfo
;
6393 struct jpeg_source_mgr
*src
= (struct jpeg_source_mgr
*) cinfo
->src
;
6397 if (num_bytes
> src
->bytes_in_buffer
)
6398 ERREXIT (cinfo
, JERR_INPUT_EOF
);
6400 src
->bytes_in_buffer
-= num_bytes
;
6401 src
->next_input_byte
+= num_bytes
;
6406 /* Method to terminate data source. Called by
6407 jpeg_finish_decompress() after all data has been processed. */
6410 our_term_source (cinfo
)
6411 j_decompress_ptr cinfo
;
6416 /* Set up the JPEG lib for reading an image from DATA which contains
6417 LEN bytes. CINFO is the decompression info structure created for
6418 reading the image. */
6421 jpeg_memory_src (cinfo
, data
, len
)
6422 j_decompress_ptr cinfo
;
6426 struct jpeg_source_mgr
*src
;
6428 if (cinfo
->src
== NULL
)
6430 /* First time for this JPEG object? */
6431 cinfo
->src
= (struct jpeg_source_mgr
*)
6432 (*cinfo
->mem
->alloc_small
) ((j_common_ptr
) cinfo
, JPOOL_PERMANENT
,
6433 sizeof (struct jpeg_source_mgr
));
6434 src
= (struct jpeg_source_mgr
*) cinfo
->src
;
6435 src
->next_input_byte
= data
;
6438 src
= (struct jpeg_source_mgr
*) cinfo
->src
;
6439 src
->init_source
= our_init_source
;
6440 src
->fill_input_buffer
= our_fill_input_buffer
;
6441 src
->skip_input_data
= our_skip_input_data
;
6442 src
->resync_to_restart
= jpeg_resync_to_restart_wrapper
; /* Use default method. */
6443 src
->term_source
= our_term_source
;
6444 src
->bytes_in_buffer
= len
;
6445 src
->next_input_byte
= data
;
6449 /* Load image IMG for use on frame F. Patterned after example.c
6450 from the JPEG lib. */
6457 struct jpeg_decompress_struct cinfo
;
6458 struct my_jpeg_error_mgr mgr
;
6459 Lisp_Object file
, specified_file
;
6460 Lisp_Object specified_data
;
6461 FILE * volatile fp
= NULL
;
6463 int row_stride
, x
, y
;
6464 XImagePtr ximg
= NULL
;
6466 unsigned long *colors
;
6468 struct gcpro gcpro1
;
6470 /* Open the JPEG file. */
6471 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
6472 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
6476 if (NILP (specified_data
))
6478 file
= x_find_image_file (specified_file
);
6479 if (!STRINGP (file
))
6481 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
6486 fp
= fopen (SDATA (file
), "rb");
6489 image_error ("Cannot open `%s'", file
, Qnil
);
6495 /* Customize libjpeg's error handling to call my_error_exit when an
6496 error is detected. This function will perform a longjmp. */
6497 cinfo
.err
= fn_jpeg_std_error (&mgr
.pub
);
6498 mgr
.pub
.error_exit
= my_error_exit
;
6500 if ((rc
= setjmp (mgr
.setjmp_buffer
)) != 0)
6504 /* Called from my_error_exit. Display a JPEG error. */
6505 char buffer
[JMSG_LENGTH_MAX
];
6506 cinfo
.err
->format_message ((j_common_ptr
) &cinfo
, buffer
);
6507 image_error ("Error reading JPEG image `%s': %s", img
->spec
,
6508 build_string (buffer
));
6511 /* Close the input file and destroy the JPEG object. */
6513 fclose ((FILE *) fp
);
6514 fn_jpeg_destroy_decompress (&cinfo
);
6516 /* If we already have an XImage, free that. */
6517 x_destroy_x_image (ximg
);
6519 /* Free pixmap and colors. */
6520 x_clear_image (f
, img
);
6526 /* Create the JPEG decompression object. Let it read from fp.
6527 Read the JPEG image header. */
6528 fn_jpeg_CreateDecompress (&cinfo
, JPEG_LIB_VERSION
, sizeof (cinfo
));
6530 if (NILP (specified_data
))
6531 fn_jpeg_stdio_src (&cinfo
, (FILE *) fp
);
6533 jpeg_memory_src (&cinfo
, SDATA (specified_data
),
6534 SBYTES (specified_data
));
6536 fn_jpeg_read_header (&cinfo
, 1);
6538 /* Customize decompression so that color quantization will be used.
6539 Start decompression. */
6540 cinfo
.quantize_colors
= 1;
6541 fn_jpeg_start_decompress (&cinfo
);
6542 width
= img
->width
= cinfo
.output_width
;
6543 height
= img
->height
= cinfo
.output_height
;
6545 /* Create X image and pixmap. */
6546 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
6547 longjmp (mgr
.setjmp_buffer
, 2);
6549 /* Allocate colors. When color quantization is used,
6550 cinfo.actual_number_of_colors has been set with the number of
6551 colors generated, and cinfo.colormap is a two-dimensional array
6552 of color indices in the range 0..cinfo.actual_number_of_colors.
6553 No more than 255 colors will be generated. */
6557 if (cinfo
.out_color_components
> 2)
6558 ir
= 0, ig
= 1, ib
= 2;
6559 else if (cinfo
.out_color_components
> 1)
6560 ir
= 0, ig
= 1, ib
= 0;
6562 ir
= 0, ig
= 0, ib
= 0;
6564 /* Use the color table mechanism because it handles colors that
6565 cannot be allocated nicely. Such colors will be replaced with
6566 a default color, and we don't have to care about which colors
6567 can be freed safely, and which can't. */
6568 init_color_table ();
6569 colors
= (unsigned long *) alloca (cinfo
.actual_number_of_colors
6572 for (i
= 0; i
< cinfo
.actual_number_of_colors
; ++i
)
6574 /* Multiply RGB values with 255 because X expects RGB values
6575 in the range 0..0xffff. */
6576 int r
= cinfo
.colormap
[ir
][i
] << 8;
6577 int g
= cinfo
.colormap
[ig
][i
] << 8;
6578 int b
= cinfo
.colormap
[ib
][i
] << 8;
6579 colors
[i
] = lookup_rgb_color (f
, r
, g
, b
);
6582 #ifdef COLOR_TABLE_SUPPORT
6583 /* Remember those colors actually allocated. */
6584 img
->colors
= colors_in_color_table (&img
->ncolors
);
6585 free_color_table ();
6586 #endif /* COLOR_TABLE_SUPPORT */
6590 row_stride
= width
* cinfo
.output_components
;
6591 buffer
= cinfo
.mem
->alloc_sarray ((j_common_ptr
) &cinfo
, JPOOL_IMAGE
,
6593 for (y
= 0; y
< height
; ++y
)
6595 fn_jpeg_read_scanlines (&cinfo
, buffer
, 1);
6596 for (x
= 0; x
< cinfo
.output_width
; ++x
)
6597 XPutPixel (ximg
, x
, y
, colors
[buffer
[0][x
]]);
6601 fn_jpeg_finish_decompress (&cinfo
);
6602 fn_jpeg_destroy_decompress (&cinfo
);
6604 fclose ((FILE *) fp
);
6606 /* Maybe fill in the background field while we have ximg handy. */
6607 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
6608 IMAGE_BACKGROUND (img
, f
, ximg
);
6610 /* Put the image into the pixmap. */
6611 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
6612 x_destroy_x_image (ximg
);
6617 #else /* HAVE_JPEG */
6626 return image_load_quartz2d (f
, img
, 0);
6628 return image_load_quicktime (f
, img
, kQTFileTypeJPEG
);
6633 #endif /* !HAVE_JPEG */
6637 /***********************************************************************
6639 ***********************************************************************/
6641 #if defined (HAVE_TIFF) || defined (MAC_OS)
6643 static int tiff_image_p
P_ ((Lisp_Object object
));
6644 static int tiff_load
P_ ((struct frame
*f
, struct image
*img
));
6646 /* The symbol `tiff' identifying images of this type. */
6650 /* Indices of image specification fields in tiff_format, below. */
6652 enum tiff_keyword_index
6661 TIFF_HEURISTIC_MASK
,
6667 /* Vector of image_keyword structures describing the format
6668 of valid user-defined image specifications. */
6670 static struct image_keyword tiff_format
[TIFF_LAST
] =
6672 {":type", IMAGE_SYMBOL_VALUE
, 1},
6673 {":data", IMAGE_STRING_VALUE
, 0},
6674 {":file", IMAGE_STRING_VALUE
, 0},
6675 {":ascent", IMAGE_ASCENT_VALUE
, 0},
6676 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
6677 {":relief", IMAGE_INTEGER_VALUE
, 0},
6678 {":conversions", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6679 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6680 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6681 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
6684 /* Structure describing the image type `tiff'. */
6686 static struct image_type tiff_type
=
6695 /* Return non-zero if OBJECT is a valid TIFF image specification. */
6698 tiff_image_p (object
)
6701 struct image_keyword fmt
[TIFF_LAST
];
6702 bcopy (tiff_format
, fmt
, sizeof fmt
);
6704 if (!parse_image_spec (object
, fmt
, TIFF_LAST
, Qtiff
))
6707 /* Must specify either the :data or :file keyword. */
6708 return fmt
[TIFF_FILE
].count
+ fmt
[TIFF_DATA
].count
== 1;
6711 #endif /* HAVE_TIFF || MAC_OS */
6719 /* TIFF library details. */
6720 DEF_IMGLIB_FN (TIFFSetErrorHandler
);
6721 DEF_IMGLIB_FN (TIFFSetWarningHandler
);
6722 DEF_IMGLIB_FN (TIFFOpen
);
6723 DEF_IMGLIB_FN (TIFFClientOpen
);
6724 DEF_IMGLIB_FN (TIFFGetField
);
6725 DEF_IMGLIB_FN (TIFFReadRGBAImage
);
6726 DEF_IMGLIB_FN (TIFFClose
);
6729 init_tiff_functions (Lisp_Object libraries
)
6733 if (!(library
= w32_delayed_load (libraries
, Qtiff
)))
6736 LOAD_IMGLIB_FN (library
, TIFFSetErrorHandler
);
6737 LOAD_IMGLIB_FN (library
, TIFFSetWarningHandler
);
6738 LOAD_IMGLIB_FN (library
, TIFFOpen
);
6739 LOAD_IMGLIB_FN (library
, TIFFClientOpen
);
6740 LOAD_IMGLIB_FN (library
, TIFFGetField
);
6741 LOAD_IMGLIB_FN (library
, TIFFReadRGBAImage
);
6742 LOAD_IMGLIB_FN (library
, TIFFClose
);
6748 #define fn_TIFFSetErrorHandler TIFFSetErrorHandler
6749 #define fn_TIFFSetWarningHandler TIFFSetWarningHandler
6750 #define fn_TIFFOpen TIFFOpen
6751 #define fn_TIFFClientOpen TIFFClientOpen
6752 #define fn_TIFFGetField TIFFGetField
6753 #define fn_TIFFReadRGBAImage TIFFReadRGBAImage
6754 #define fn_TIFFClose TIFFClose
6756 #endif /* HAVE_NTGUI */
6759 /* Reading from a memory buffer for TIFF images Based on the PNG
6760 memory source, but we have to provide a lot of extra functions.
6763 We really only need to implement read and seek, but I am not
6764 convinced that the TIFF library is smart enough not to destroy
6765 itself if we only hand it the function pointers we need to
6770 unsigned char *bytes
;
6777 tiff_read_from_memory (data
, buf
, size
)
6782 tiff_memory_source
*src
= (tiff_memory_source
*) data
;
6784 if (size
> src
->len
- src
->index
)
6786 bcopy (src
->bytes
+ src
->index
, buf
, size
);
6792 tiff_write_from_memory (data
, buf
, size
)
6801 tiff_seek_in_memory (data
, off
, whence
)
6806 tiff_memory_source
*src
= (tiff_memory_source
*) data
;
6811 case SEEK_SET
: /* Go from beginning of source. */
6815 case SEEK_END
: /* Go from end of source. */
6816 idx
= src
->len
+ off
;
6819 case SEEK_CUR
: /* Go from current position. */
6820 idx
= src
->index
+ off
;
6823 default: /* Invalid `whence'. */
6827 if (idx
> src
->len
|| idx
< 0)
6835 tiff_close_memory (data
)
6843 tiff_mmap_memory (data
, pbase
, psize
)
6848 /* It is already _IN_ memory. */
6853 tiff_unmap_memory (data
, base
, size
)
6858 /* We don't need to do this. */
6862 tiff_size_of_memory (data
)
6865 return ((tiff_memory_source
*) data
)->len
;
6870 tiff_error_handler (title
, format
, ap
)
6871 const char *title
, *format
;
6877 len
= sprintf (buf
, "TIFF error: %s ", title
);
6878 vsprintf (buf
+ len
, format
, ap
);
6879 add_to_log (buf
, Qnil
, Qnil
);
6884 tiff_warning_handler (title
, format
, ap
)
6885 const char *title
, *format
;
6891 len
= sprintf (buf
, "TIFF warning: %s ", title
);
6892 vsprintf (buf
+ len
, format
, ap
);
6893 add_to_log (buf
, Qnil
, Qnil
);
6897 /* Load TIFF image IMG for use on frame F. Value is non-zero if
6905 Lisp_Object file
, specified_file
;
6906 Lisp_Object specified_data
;
6908 int width
, height
, x
, y
;
6912 struct gcpro gcpro1
;
6913 tiff_memory_source memsrc
;
6915 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
6916 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
6920 fn_TIFFSetErrorHandler (tiff_error_handler
);
6921 fn_TIFFSetWarningHandler (tiff_warning_handler
);
6923 if (NILP (specified_data
))
6925 /* Read from a file */
6926 file
= x_find_image_file (specified_file
);
6927 if (!STRINGP (file
))
6929 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
6934 /* Try to open the image file. */
6935 tiff
= fn_TIFFOpen (SDATA (file
), "r");
6938 image_error ("Cannot open `%s'", file
, Qnil
);
6945 /* Memory source! */
6946 memsrc
.bytes
= SDATA (specified_data
);
6947 memsrc
.len
= SBYTES (specified_data
);
6950 tiff
= fn_TIFFClientOpen ("memory_source", "r", &memsrc
,
6951 (TIFFReadWriteProc
) tiff_read_from_memory
,
6952 (TIFFReadWriteProc
) tiff_write_from_memory
,
6953 tiff_seek_in_memory
,
6955 tiff_size_of_memory
,
6961 image_error ("Cannot open memory source for `%s'", img
->spec
, Qnil
);
6967 /* Get width and height of the image, and allocate a raster buffer
6968 of width x height 32-bit values. */
6969 fn_TIFFGetField (tiff
, TIFFTAG_IMAGEWIDTH
, &width
);
6970 fn_TIFFGetField (tiff
, TIFFTAG_IMAGELENGTH
, &height
);
6971 buf
= (uint32
*) xmalloc (width
* height
* sizeof *buf
);
6973 rc
= fn_TIFFReadRGBAImage (tiff
, width
, height
, buf
, 0);
6974 fn_TIFFClose (tiff
);
6977 image_error ("Error reading TIFF image `%s'", img
->spec
, Qnil
);
6983 /* Create the X image and pixmap. */
6984 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
6991 /* Initialize the color table. */
6992 init_color_table ();
6994 /* Process the pixel raster. Origin is in the lower-left corner. */
6995 for (y
= 0; y
< height
; ++y
)
6997 uint32
*row
= buf
+ y
* width
;
6999 for (x
= 0; x
< width
; ++x
)
7001 uint32 abgr
= row
[x
];
7002 int r
= TIFFGetR (abgr
) << 8;
7003 int g
= TIFFGetG (abgr
) << 8;
7004 int b
= TIFFGetB (abgr
) << 8;
7005 XPutPixel (ximg
, x
, height
- 1 - y
, lookup_rgb_color (f
, r
, g
, b
));
7009 #ifdef COLOR_TABLE_SUPPORT
7010 /* Remember the colors allocated for the image. Free the color table. */
7011 img
->colors
= colors_in_color_table (&img
->ncolors
);
7012 free_color_table ();
7013 #endif /* COLOR_TABLE_SUPPORT */
7016 img
->height
= height
;
7018 /* Maybe fill in the background field while we have ximg handy. */
7019 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
7020 IMAGE_BACKGROUND (img
, f
, ximg
);
7022 /* Put the image into the pixmap, then free the X image and its buffer. */
7023 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
7024 x_destroy_x_image (ximg
);
7031 #else /* HAVE_TIFF */
7039 return image_load_quicktime (f
, img
, kQTFileTypeTIFF
);
7043 #endif /* !HAVE_TIFF */
7047 /***********************************************************************
7049 ***********************************************************************/
7051 #if defined (HAVE_GIF) || defined (MAC_OS)
7053 static int gif_image_p
P_ ((Lisp_Object object
));
7054 static int gif_load
P_ ((struct frame
*f
, struct image
*img
));
7056 /* The symbol `gif' identifying images of this type. */
7060 /* Indices of image specification fields in gif_format, below. */
7062 enum gif_keyword_index
7078 /* Vector of image_keyword structures describing the format
7079 of valid user-defined image specifications. */
7081 static struct image_keyword gif_format
[GIF_LAST
] =
7083 {":type", IMAGE_SYMBOL_VALUE
, 1},
7084 {":data", IMAGE_STRING_VALUE
, 0},
7085 {":file", IMAGE_STRING_VALUE
, 0},
7086 {":ascent", IMAGE_ASCENT_VALUE
, 0},
7087 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
7088 {":relief", IMAGE_INTEGER_VALUE
, 0},
7089 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7090 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7091 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7092 {":image", IMAGE_NON_NEGATIVE_INTEGER_VALUE
, 0},
7093 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
7096 /* Structure describing the image type `gif'. */
7098 static struct image_type gif_type
=
7107 /* Return non-zero if OBJECT is a valid GIF image specification. */
7110 gif_image_p (object
)
7113 struct image_keyword fmt
[GIF_LAST
];
7114 bcopy (gif_format
, fmt
, sizeof fmt
);
7116 if (!parse_image_spec (object
, fmt
, GIF_LAST
, Qgif
))
7119 /* Must specify either the :data or :file keyword. */
7120 return fmt
[GIF_FILE
].count
+ fmt
[GIF_DATA
].count
== 1;
7123 #endif /* HAVE_GIF || MAC_OS */
7127 #if defined (HAVE_NTGUI) || defined (MAC_OS)
7128 /* avoid conflict with QuickdrawText.h */
7129 #define DrawText gif_DrawText
7130 #include <gif_lib.h>
7133 #else /* HAVE_NTGUI || MAC_OS */
7135 #include <gif_lib.h>
7137 #endif /* HAVE_NTGUI || MAC_OS */
7142 /* GIF library details. */
7143 DEF_IMGLIB_FN (DGifCloseFile
);
7144 DEF_IMGLIB_FN (DGifSlurp
);
7145 DEF_IMGLIB_FN (DGifOpen
);
7146 DEF_IMGLIB_FN (DGifOpenFileName
);
7149 init_gif_functions (Lisp_Object libraries
)
7153 if (!(library
= w32_delayed_load (libraries
, Qgif
)))
7156 LOAD_IMGLIB_FN (library
, DGifCloseFile
);
7157 LOAD_IMGLIB_FN (library
, DGifSlurp
);
7158 LOAD_IMGLIB_FN (library
, DGifOpen
);
7159 LOAD_IMGLIB_FN (library
, DGifOpenFileName
);
7165 #define fn_DGifCloseFile DGifCloseFile
7166 #define fn_DGifSlurp DGifSlurp
7167 #define fn_DGifOpen DGifOpen
7168 #define fn_DGifOpenFileName DGifOpenFileName
7170 #endif /* HAVE_NTGUI */
7172 /* Reading a GIF image from memory
7173 Based on the PNG memory stuff to a certain extent. */
7177 unsigned char *bytes
;
7183 /* Make the current memory source available to gif_read_from_memory.
7184 It's done this way because not all versions of libungif support
7185 a UserData field in the GifFileType structure. */
7186 static gif_memory_source
*current_gif_memory_src
;
7189 gif_read_from_memory (file
, buf
, len
)
7194 gif_memory_source
*src
= current_gif_memory_src
;
7196 if (len
> src
->len
- src
->index
)
7199 bcopy (src
->bytes
+ src
->index
, buf
, len
);
7205 /* Load GIF image IMG for use on frame F. Value is non-zero if
7213 Lisp_Object file
, specified_file
;
7214 Lisp_Object specified_data
;
7215 int rc
, width
, height
, x
, y
, i
;
7217 ColorMapObject
*gif_color_map
;
7218 unsigned long pixel_colors
[256];
7220 struct gcpro gcpro1
;
7222 int ino
, image_left
, image_top
, image_width
, image_height
;
7223 gif_memory_source memsrc
;
7224 unsigned char *raster
;
7226 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
7227 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
7231 if (NILP (specified_data
))
7233 file
= x_find_image_file (specified_file
);
7234 if (!STRINGP (file
))
7236 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
7241 /* Open the GIF file. */
7242 gif
= fn_DGifOpenFileName (SDATA (file
));
7245 image_error ("Cannot open `%s'", file
, Qnil
);
7252 /* Read from memory! */
7253 current_gif_memory_src
= &memsrc
;
7254 memsrc
.bytes
= SDATA (specified_data
);
7255 memsrc
.len
= SBYTES (specified_data
);
7258 gif
= fn_DGifOpen(&memsrc
, gif_read_from_memory
);
7261 image_error ("Cannot open memory source `%s'", img
->spec
, Qnil
);
7267 /* Read entire contents. */
7268 rc
= fn_DGifSlurp (gif
);
7269 if (rc
== GIF_ERROR
)
7271 image_error ("Error reading `%s'", img
->spec
, Qnil
);
7272 fn_DGifCloseFile (gif
);
7277 image
= image_spec_value (img
->spec
, QCindex
, NULL
);
7278 ino
= INTEGERP (image
) ? XFASTINT (image
) : 0;
7279 if (ino
>= gif
->ImageCount
)
7281 image_error ("Invalid image number `%s' in image `%s'",
7283 fn_DGifCloseFile (gif
);
7288 width
= img
->width
= max (gif
->SWidth
, gif
->Image
.Left
+ gif
->Image
.Width
);
7289 height
= img
->height
= max (gif
->SHeight
, gif
->Image
.Top
+ gif
->Image
.Height
);
7291 /* Create the X image and pixmap. */
7292 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
7294 fn_DGifCloseFile (gif
);
7299 /* Allocate colors. */
7300 gif_color_map
= gif
->SavedImages
[ino
].ImageDesc
.ColorMap
;
7302 gif_color_map
= gif
->SColorMap
;
7303 init_color_table ();
7304 bzero (pixel_colors
, sizeof pixel_colors
);
7306 for (i
= 0; i
< gif_color_map
->ColorCount
; ++i
)
7308 int r
= gif_color_map
->Colors
[i
].Red
<< 8;
7309 int g
= gif_color_map
->Colors
[i
].Green
<< 8;
7310 int b
= gif_color_map
->Colors
[i
].Blue
<< 8;
7311 pixel_colors
[i
] = lookup_rgb_color (f
, r
, g
, b
);
7314 #ifdef COLOR_TABLE_SUPPORT
7315 img
->colors
= colors_in_color_table (&img
->ncolors
);
7316 free_color_table ();
7317 #endif /* COLOR_TABLE_SUPPORT */
7319 /* Clear the part of the screen image that are not covered by
7320 the image from the GIF file. Full animated GIF support
7321 requires more than can be done here (see the gif89 spec,
7322 disposal methods). Let's simply assume that the part
7323 not covered by a sub-image is in the frame's background color. */
7324 image_top
= gif
->SavedImages
[ino
].ImageDesc
.Top
;
7325 image_left
= gif
->SavedImages
[ino
].ImageDesc
.Left
;
7326 image_width
= gif
->SavedImages
[ino
].ImageDesc
.Width
;
7327 image_height
= gif
->SavedImages
[ino
].ImageDesc
.Height
;
7329 for (y
= 0; y
< image_top
; ++y
)
7330 for (x
= 0; x
< width
; ++x
)
7331 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7333 for (y
= image_top
+ image_height
; y
< height
; ++y
)
7334 for (x
= 0; x
< width
; ++x
)
7335 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7337 for (y
= image_top
; y
< image_top
+ image_height
; ++y
)
7339 for (x
= 0; x
< image_left
; ++x
)
7340 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7341 for (x
= image_left
+ image_width
; x
< width
; ++x
)
7342 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7345 /* Read the GIF image into the X image. We use a local variable
7346 `raster' here because RasterBits below is a char *, and invites
7347 problems with bytes >= 0x80. */
7348 raster
= (unsigned char *) gif
->SavedImages
[ino
].RasterBits
;
7350 if (gif
->SavedImages
[ino
].ImageDesc
.Interlace
)
7352 static int interlace_start
[] = {0, 4, 2, 1};
7353 static int interlace_increment
[] = {8, 8, 4, 2};
7355 int row
= interlace_start
[0];
7359 for (y
= 0; y
< image_height
; y
++)
7361 if (row
>= image_height
)
7363 row
= interlace_start
[++pass
];
7364 while (row
>= image_height
)
7365 row
= interlace_start
[++pass
];
7368 for (x
= 0; x
< image_width
; x
++)
7370 int i
= raster
[(y
* image_width
) + x
];
7371 XPutPixel (ximg
, x
+ image_left
, row
+ image_top
,
7375 row
+= interlace_increment
[pass
];
7380 for (y
= 0; y
< image_height
; ++y
)
7381 for (x
= 0; x
< image_width
; ++x
)
7383 int i
= raster
[y
* image_width
+ x
];
7384 XPutPixel (ximg
, x
+ image_left
, y
+ image_top
, pixel_colors
[i
]);
7388 fn_DGifCloseFile (gif
);
7390 /* Maybe fill in the background field while we have ximg handy. */
7391 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
7392 IMAGE_BACKGROUND (img
, f
, ximg
);
7394 /* Put the image into the pixmap, then free the X image and its buffer. */
7395 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
7396 x_destroy_x_image (ximg
);
7410 Lisp_Object specified_file
, file
;
7411 Lisp_Object specified_data
;
7413 Boolean graphic_p
, movie_p
, prefer_graphic_p
;
7421 Lisp_Object specified_bg
;
7427 struct gcpro gcpro1
;
7432 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
7433 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
7435 if (NILP (specified_data
))
7437 /* Read from a file */
7441 err
= find_image_fsspec (specified_file
, &file
, &fss
);
7445 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
7450 err
= CanQuickTimeOpenFile (&fss
, kQTFileTypeGIF
, 0,
7451 &graphic_p
, &movie_p
, &prefer_graphic_p
, 0);
7455 if (!graphic_p
&& !movie_p
)
7457 if (prefer_graphic_p
)
7458 return image_load_qt_1 (f
, img
, kQTFileTypeGIF
, &fss
, NULL
);
7459 err
= OpenMovieFile (&fss
, &refnum
, fsRdPerm
);
7462 err
= NewMovieFromFile (&movie
, refnum
, NULL
, NULL
, 0, NULL
);
7463 CloseMovieFile (refnum
);
7466 image_error ("Error reading `%s'", file
, Qnil
);
7472 /* Memory source! */
7474 long file_type_atom
[3];
7476 err
= PtrToHand (SDATA (specified_data
), &dh
, SBYTES (specified_data
));
7479 image_error ("Cannot allocate data handle for `%s'",
7484 file_type_atom
[0] = EndianU32_NtoB (sizeof (long) * 3);
7485 file_type_atom
[1] = EndianU32_NtoB (kDataRefExtensionMacOSFileType
);
7486 file_type_atom
[2] = EndianU32_NtoB (kQTFileTypeGIF
);
7487 err
= PtrToHand (&dh
, &dref
, sizeof (Handle
));
7490 err
= PtrAndHand ("\p", dref
, 1);
7492 err
= PtrAndHand (file_type_atom
, dref
, sizeof (long) * 3);
7495 image_error ("Cannot allocate handle data ref for `%s'", img
->spec
, Qnil
);
7498 err
= CanQuickTimeOpenDataRef (dref
, HandleDataHandlerSubType
, &graphic_p
,
7499 &movie_p
, &prefer_graphic_p
, 0);
7503 if (!graphic_p
&& !movie_p
)
7505 if (prefer_graphic_p
)
7509 DisposeHandle (dref
);
7510 success_p
= image_load_qt_1 (f
, img
, kQTFileTypeGIF
, NULL
, dh
);
7514 err
= NewMovieFromDataRef (&movie
, 0, NULL
, dref
,
7515 HandleDataHandlerSubType
);
7516 DisposeHandle (dref
);
7521 image
= image_spec_value (img
->spec
, QCindex
, NULL
);
7522 ino
= INTEGERP (image
) ? XFASTINT (image
) : 0;
7523 track
= GetMovieIndTrack (movie
, 1);
7524 media
= GetTrackMedia (track
);
7525 nsamples
= GetMediaSampleCount (media
);
7526 if (ino
>= nsamples
)
7528 image_error ("Invalid image number `%s' in image `%s'",
7533 specified_bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
7534 if (!STRINGP (specified_bg
) ||
7535 !mac_defined_color (f
, SDATA (specified_bg
), &color
, 0))
7537 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
7538 color
.red
= RED16_FROM_ULONG (color
.pixel
);
7539 color
.green
= GREEN16_FROM_ULONG (color
.pixel
);
7540 color
.blue
= BLUE16_FROM_ULONG (color
.pixel
);
7542 GetMovieBox (movie
, &rect
);
7543 width
= img
->width
= rect
.right
- rect
.left
;
7544 height
= img
->height
= rect
.bottom
- rect
.top
;
7545 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
7548 GetGWorld (&old_port
, &old_gdh
);
7549 SetGWorld (ximg
, NULL
);
7550 bg_color
.red
= color
.red
;
7551 bg_color
.green
= color
.green
;
7552 bg_color
.blue
= color
.blue
;
7553 RGBBackColor (&bg_color
);
7554 SetGWorld (old_port
, old_gdh
);
7555 SetMovieActive (movie
, 1);
7556 SetMovieGWorld (movie
, ximg
, NULL
);
7557 SampleNumToMediaTime (media
, ino
+ 1, &time
, NULL
);
7558 SetMovieTimeValue (movie
, time
);
7559 MoviesTask (movie
, 0L);
7560 DisposeTrackMedia (media
);
7561 DisposeMovieTrack (track
);
7562 DisposeMovie (movie
);
7565 /* Maybe fill in the background field while we have ximg handy. */
7566 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
7567 IMAGE_BACKGROUND (img
, f
, ximg
);
7569 /* Put the image into the pixmap. */
7570 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
7571 x_destroy_x_image (ximg
);
7575 image_error ("Cannot open `%s'", file
, Qnil
);
7578 DisposeTrackMedia (media
);
7580 DisposeMovieTrack (track
);
7582 DisposeMovie (movie
);
7589 #endif /* HAVE_GIF */
7593 /***********************************************************************
7595 ***********************************************************************/
7597 #ifdef HAVE_X_WINDOWS
7598 #define HAVE_GHOSTSCRIPT 1
7599 #endif /* HAVE_X_WINDOWS */
7601 /* The symbol `postscript' identifying images of this type. */
7603 Lisp_Object Qpostscript
;
7605 #ifdef HAVE_GHOSTSCRIPT
7607 static int gs_image_p
P_ ((Lisp_Object object
));
7608 static int gs_load
P_ ((struct frame
*f
, struct image
*img
));
7609 static void gs_clear_image
P_ ((struct frame
*f
, struct image
*img
));
7611 /* Keyword symbols. */
7613 Lisp_Object QCloader
, QCbounding_box
, QCpt_width
, QCpt_height
;
7615 /* Indices of image specification fields in gs_format, below. */
7617 enum gs_keyword_index
7635 /* Vector of image_keyword structures describing the format
7636 of valid user-defined image specifications. */
7638 static struct image_keyword gs_format
[GS_LAST
] =
7640 {":type", IMAGE_SYMBOL_VALUE
, 1},
7641 {":pt-width", IMAGE_POSITIVE_INTEGER_VALUE
, 1},
7642 {":pt-height", IMAGE_POSITIVE_INTEGER_VALUE
, 1},
7643 {":file", IMAGE_STRING_VALUE
, 1},
7644 {":loader", IMAGE_FUNCTION_VALUE
, 0},
7645 {":bounding-box", IMAGE_DONT_CHECK_VALUE_TYPE
, 1},
7646 {":ascent", IMAGE_ASCENT_VALUE
, 0},
7647 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
7648 {":relief", IMAGE_INTEGER_VALUE
, 0},
7649 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7650 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7651 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7652 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
7655 /* Structure describing the image type `ghostscript'. */
7657 static struct image_type gs_type
=
7667 /* Free X resources of Ghostscript image IMG which is used on frame F. */
7670 gs_clear_image (f
, img
)
7674 /* IMG->data.ptr_val may contain a recorded colormap. */
7675 xfree (img
->data
.ptr_val
);
7676 x_clear_image (f
, img
);
7680 /* Return non-zero if OBJECT is a valid Ghostscript image
7687 struct image_keyword fmt
[GS_LAST
];
7691 bcopy (gs_format
, fmt
, sizeof fmt
);
7693 if (!parse_image_spec (object
, fmt
, GS_LAST
, Qpostscript
))
7696 /* Bounding box must be a list or vector containing 4 integers. */
7697 tem
= fmt
[GS_BOUNDING_BOX
].value
;
7700 for (i
= 0; i
< 4; ++i
, tem
= XCDR (tem
))
7701 if (!CONSP (tem
) || !INTEGERP (XCAR (tem
)))
7706 else if (VECTORP (tem
))
7708 if (XVECTOR (tem
)->size
!= 4)
7710 for (i
= 0; i
< 4; ++i
)
7711 if (!INTEGERP (XVECTOR (tem
)->contents
[i
]))
7721 /* Load Ghostscript image IMG for use on frame F. Value is non-zero
7730 Lisp_Object window_and_pixmap_id
= Qnil
, loader
, pt_height
, pt_width
;
7731 struct gcpro gcpro1
, gcpro2
;
7733 double in_width
, in_height
;
7734 Lisp_Object pixel_colors
= Qnil
;
7736 /* Compute pixel size of pixmap needed from the given size in the
7737 image specification. Sizes in the specification are in pt. 1 pt
7738 = 1/72 in, xdpi and ydpi are stored in the frame's X display
7740 pt_width
= image_spec_value (img
->spec
, QCpt_width
, NULL
);
7741 in_width
= XFASTINT (pt_width
) / 72.0;
7742 img
->width
= in_width
* FRAME_X_DISPLAY_INFO (f
)->resx
;
7743 pt_height
= image_spec_value (img
->spec
, QCpt_height
, NULL
);
7744 in_height
= XFASTINT (pt_height
) / 72.0;
7745 img
->height
= in_height
* FRAME_X_DISPLAY_INFO (f
)->resy
;
7747 /* Create the pixmap. */
7748 xassert (img
->pixmap
== NO_PIXMAP
);
7750 /* Only W32 version did BLOCK_INPUT here. ++kfs */
7752 img
->pixmap
= XCreatePixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
7753 img
->width
, img
->height
,
7754 DefaultDepthOfScreen (FRAME_X_SCREEN (f
)));
7759 image_error ("Unable to create pixmap for `%s'", img
->spec
, Qnil
);
7763 /* Call the loader to fill the pixmap. It returns a process object
7764 if successful. We do not record_unwind_protect here because
7765 other places in redisplay like calling window scroll functions
7766 don't either. Let the Lisp loader use `unwind-protect' instead. */
7767 GCPRO2 (window_and_pixmap_id
, pixel_colors
);
7769 sprintf (buffer
, "%lu %lu",
7770 (unsigned long) FRAME_X_WINDOW (f
),
7771 (unsigned long) img
->pixmap
);
7772 window_and_pixmap_id
= build_string (buffer
);
7774 sprintf (buffer
, "%lu %lu",
7775 FRAME_FOREGROUND_PIXEL (f
),
7776 FRAME_BACKGROUND_PIXEL (f
));
7777 pixel_colors
= build_string (buffer
);
7779 XSETFRAME (frame
, f
);
7780 loader
= image_spec_value (img
->spec
, QCloader
, NULL
);
7782 loader
= intern ("gs-load-image");
7784 img
->data
.lisp_val
= call6 (loader
, frame
, img
->spec
,
7785 make_number (img
->width
),
7786 make_number (img
->height
),
7787 window_and_pixmap_id
,
7790 return PROCESSP (img
->data
.lisp_val
);
7794 /* Kill the Ghostscript process that was started to fill PIXMAP on
7795 frame F. Called from XTread_socket when receiving an event
7796 telling Emacs that Ghostscript has finished drawing. */
7799 x_kill_gs_process (pixmap
, f
)
7803 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
7807 /* Find the image containing PIXMAP. */
7808 for (i
= 0; i
< c
->used
; ++i
)
7809 if (c
->images
[i
]->pixmap
== pixmap
)
7812 /* Should someone in between have cleared the image cache, for
7813 instance, give up. */
7817 /* Kill the GS process. We should have found PIXMAP in the image
7818 cache and its image should contain a process object. */
7820 xassert (PROCESSP (img
->data
.lisp_val
));
7821 Fkill_process (img
->data
.lisp_val
, Qnil
);
7822 img
->data
.lisp_val
= Qnil
;
7824 #if defined (HAVE_X_WINDOWS)
7826 /* On displays with a mutable colormap, figure out the colors
7827 allocated for the image by looking at the pixels of an XImage for
7829 class = FRAME_X_VISUAL (f
)->class;
7830 if (class != StaticColor
&& class != StaticGray
&& class != TrueColor
)
7836 /* Try to get an XImage for img->pixmep. */
7837 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
7838 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
7843 /* Initialize the color table. */
7844 init_color_table ();
7846 /* For each pixel of the image, look its color up in the
7847 color table. After having done so, the color table will
7848 contain an entry for each color used by the image. */
7849 for (y
= 0; y
< img
->height
; ++y
)
7850 for (x
= 0; x
< img
->width
; ++x
)
7852 unsigned long pixel
= XGetPixel (ximg
, x
, y
);
7853 lookup_pixel_color (f
, pixel
);
7856 /* Record colors in the image. Free color table and XImage. */
7857 #ifdef COLOR_TABLE_SUPPORT
7858 img
->colors
= colors_in_color_table (&img
->ncolors
);
7859 free_color_table ();
7861 XDestroyImage (ximg
);
7863 #if 0 /* This doesn't seem to be the case. If we free the colors
7864 here, we get a BadAccess later in x_clear_image when
7865 freeing the colors. */
7866 /* We have allocated colors once, but Ghostscript has also
7867 allocated colors on behalf of us. So, to get the
7868 reference counts right, free them once. */
7870 x_free_colors (f
, img
->colors
, img
->ncolors
);
7874 image_error ("Cannot get X image of `%s'; colors will not be freed",
7879 #endif /* HAVE_X_WINDOWS */
7881 /* Now that we have the pixmap, compute mask and transform the
7882 image if requested. */
7884 postprocess_image (f
, img
);
7888 #endif /* HAVE_GHOSTSCRIPT */
7891 /***********************************************************************
7893 ***********************************************************************/
7897 DEFUN ("imagep", Fimagep
, Simagep
, 1, 1, 0,
7898 doc
: /* Value is non-nil if SPEC is a valid image specification. */)
7902 return valid_image_p (spec
) ? Qt
: Qnil
;
7906 DEFUN ("lookup-image", Flookup_image
, Slookup_image
, 1, 1, 0, "")
7912 if (valid_image_p (spec
))
7913 id
= lookup_image (SELECTED_FRAME (), spec
);
7916 return make_number (id
);
7919 #endif /* GLYPH_DEBUG != 0 */
7922 /***********************************************************************
7924 ***********************************************************************/
7927 /* Image types that rely on external libraries are loaded dynamically
7928 if the library is available. */
7929 #define CHECK_LIB_AVAILABLE(image_type, init_lib_fn, libraries) \
7930 define_image_type (image_type, init_lib_fn (libraries))
7932 #define CHECK_LIB_AVAILABLE(image_type, init_lib_fn, libraries) \
7933 define_image_type (image_type, 1)
7934 #endif /* HAVE_NTGUI */
7936 DEFUN ("init-image-library", Finit_image_library
, Sinit_image_library
, 2, 2, 0,
7937 doc
: /* Initialize image library implementing image type TYPE.
7938 Return non-nil if TYPE is a supported image type.
7940 Image types pbm and xbm are prebuilt; other types are loaded here.
7941 Libraries to load are specified in alist LIBRARIES (usually, the value
7942 of `image-library-alist', which see). */)
7944 Lisp_Object type
, libraries
;
7948 /* Don't try to reload the library. */
7949 tested
= Fassq (type
, Vimage_type_cache
);
7951 return XCDR (tested
);
7953 #if defined (HAVE_XPM) || defined (MAC_OS)
7954 if (EQ (type
, Qxpm
))
7955 return CHECK_LIB_AVAILABLE (&xpm_type
, init_xpm_functions
, libraries
);
7958 #if defined (HAVE_JPEG) || defined (MAC_OS)
7959 if (EQ (type
, Qjpeg
))
7960 return CHECK_LIB_AVAILABLE (&jpeg_type
, init_jpeg_functions
, libraries
);
7963 #if defined (HAVE_TIFF) || defined (MAC_OS)
7964 if (EQ (type
, Qtiff
))
7965 return CHECK_LIB_AVAILABLE (&tiff_type
, init_tiff_functions
, libraries
);
7968 #if defined (HAVE_GIF) || defined (MAC_OS)
7969 if (EQ (type
, Qgif
))
7970 return CHECK_LIB_AVAILABLE (&gif_type
, init_gif_functions
, libraries
);
7973 #if defined (HAVE_PNG) || defined (MAC_OS)
7974 if (EQ (type
, Qpng
))
7975 return CHECK_LIB_AVAILABLE (&png_type
, init_png_functions
, libraries
);
7978 #ifdef HAVE_GHOSTSCRIPT
7979 if (EQ (type
, Qpostscript
))
7980 return CHECK_LIB_AVAILABLE (&gs_type
, init_gs_functions
, libraries
);
7983 /* If the type is not recognized, avoid testing it ever again. */
7984 CACHE_IMAGE_TYPE (type
, Qnil
);
7991 /* Must be defined now becase we're going to update it below, while
7992 defining the supported image types. */
7993 DEFVAR_LISP ("image-types", &Vimage_types
,
7994 doc
: /* List of potentially supported image types.
7995 Each element of the list is a symbol for a image type, like 'jpeg or 'png.
7996 To check whether it is really supported, use `image-type-available-p'. */);
7997 Vimage_types
= Qnil
;
7999 Vimage_type_cache
= Qnil
;
8000 staticpro (&Vimage_type_cache
);
8002 QCascent
= intern (":ascent");
8003 staticpro (&QCascent
);
8004 QCmargin
= intern (":margin");
8005 staticpro (&QCmargin
);
8006 QCrelief
= intern (":relief");
8007 staticpro (&QCrelief
);
8008 QCconversion
= intern (":conversion");
8009 staticpro (&QCconversion
);
8010 QCcolor_symbols
= intern (":color-symbols");
8011 staticpro (&QCcolor_symbols
);
8012 QCheuristic_mask
= intern (":heuristic-mask");
8013 staticpro (&QCheuristic_mask
);
8014 QCindex
= intern (":index");
8015 staticpro (&QCindex
);
8016 QCmatrix
= intern (":matrix");
8017 staticpro (&QCmatrix
);
8018 QCcolor_adjustment
= intern (":color-adjustment");
8019 staticpro (&QCcolor_adjustment
);
8020 QCmask
= intern (":mask");
8021 staticpro (&QCmask
);
8023 Qlaplace
= intern ("laplace");
8024 staticpro (&Qlaplace
);
8025 Qemboss
= intern ("emboss");
8026 staticpro (&Qemboss
);
8027 Qedge_detection
= intern ("edge-detection");
8028 staticpro (&Qedge_detection
);
8029 Qheuristic
= intern ("heuristic");
8030 staticpro (&Qheuristic
);
8032 Qpostscript
= intern ("postscript");
8033 staticpro (&Qpostscript
);
8034 #ifdef HAVE_GHOSTSCRIPT
8035 ADD_IMAGE_TYPE(Qpostscript
);
8036 QCloader
= intern (":loader");
8037 staticpro (&QCloader
);
8038 QCbounding_box
= intern (":bounding-box");
8039 staticpro (&QCbounding_box
);
8040 QCpt_width
= intern (":pt-width");
8041 staticpro (&QCpt_width
);
8042 QCpt_height
= intern (":pt-height");
8043 staticpro (&QCpt_height
);
8044 #endif /* HAVE_GHOSTSCRIPT */
8046 Qpbm
= intern ("pbm");
8048 ADD_IMAGE_TYPE(Qpbm
);
8050 Qxbm
= intern ("xbm");
8052 ADD_IMAGE_TYPE(Qxbm
);
8054 #if defined (HAVE_XPM) || defined (MAC_OS)
8055 Qxpm
= intern ("xpm");
8057 ADD_IMAGE_TYPE(Qxpm
);
8060 #if defined (HAVE_JPEG) || defined (MAC_OS)
8061 Qjpeg
= intern ("jpeg");
8063 ADD_IMAGE_TYPE(Qjpeg
);
8066 #if defined (HAVE_TIFF) || defined (MAC_OS)
8067 Qtiff
= intern ("tiff");
8069 ADD_IMAGE_TYPE(Qtiff
);
8072 #if defined (HAVE_GIF) || defined (MAC_OS)
8073 Qgif
= intern ("gif");
8075 ADD_IMAGE_TYPE(Qgif
);
8078 #if defined (HAVE_PNG) || defined (MAC_OS)
8079 Qpng
= intern ("png");
8081 ADD_IMAGE_TYPE(Qpng
);
8084 defsubr (&Sinit_image_library
);
8085 defsubr (&Sclear_image_cache
);
8086 defsubr (&Simage_size
);
8087 defsubr (&Simage_mask_p
);
8091 defsubr (&Slookup_image
);
8094 DEFVAR_BOOL ("cross-disabled-images", &cross_disabled_images
,
8095 doc
: /* Non-nil means always draw a cross over disabled images.
8096 Disabled images are those having an `:conversion disabled' property.
8097 A cross is always drawn on black & white displays. */);
8098 cross_disabled_images
= 0;
8100 DEFVAR_LISP ("x-bitmap-file-path", &Vx_bitmap_file_path
,
8101 doc
: /* List of directories to search for window system bitmap files. */);
8102 Vx_bitmap_file_path
= decode_env_path ((char *) 0, PATH_BITMAPS
);
8104 DEFVAR_LISP ("image-cache-eviction-delay", &Vimage_cache_eviction_delay
,
8105 doc
: /* Time after which cached images are removed from the cache.
8106 When an image has not been displayed this many seconds, remove it
8107 from the image cache. Value must be an integer or nil with nil
8108 meaning don't clear the cache. */);
8109 Vimage_cache_eviction_delay
= make_number (30 * 60);
8117 define_image_type (&xbm_type
, 1);
8118 define_image_type (&pbm_type
, 1);
8121 /* Animated gifs use QuickTime Movie Toolbox. So initialize it here. */
8124 init_image_func_pointer ();
8129 /* arch-tag: 123c2a5e-14a8-4c53-ab95-af47d7db49b9
8130 (do not change this comment) */