/* Free bitmap B. */
static void
-Free_Bitmap_Record (dpyinfo, bm)
+free_bitmap_record (dpyinfo, bm)
Display_Info *dpyinfo;
Bitmap_Record *bm;
{
if (--bm->refcount == 0)
{
BLOCK_INPUT;
- Free_Bitmap_Record (dpyinfo, bm);
+ free_bitmap_record (dpyinfo, bm);
UNBLOCK_INPUT;
}
}
for (i = 0; i < dpyinfo->bitmaps_last; i++, bm++)
if (bm->refcount > 0)
- Free_Bitmap_Record (dpyinfo, bm);
+ free_bitmap_record (dpyinfo, bm);
dpyinfo->bitmaps_last = 0;
}
{
#ifdef HAVE_NTGUI
/* W32 specific version. Why?. ++kfs */
- ascent = height / 2 - (FONT_DESCENT(face->font)
- - FONT_BASE(face->font)) / 2;
+ ascent = height / 2 - (FONT_DESCENT (face->font)
+ - FONT_BASE (face->font)) / 2;
#else
/* This expression is arranged so that if the image can't be
exactly centered, it will be moved slightly up. This is
/* Clear image cache of frame F. FORCE_P non-zero means free all
images. FORCE_P zero means clear only images that haven't been
displayed for some time. Should be called from time to time to
- reduce the number of loaded images. If image-eviction-seconds is
- non-nil, this frees images in the cache which weren't displayed for
- at least that many seconds. */
+ reduce the number of loaded images. If image-cache-eviction-delay
+ is non-nil, this frees images in the cache which weren't displayed
+ for at least that many seconds. */
void
clear_image_cache (f, force_p)
struct frame *f;
Lisp_Object spec;
{
+ struct image_cache *c;
struct image *img;
unsigned hash;
struct gcpro gcpro1;
xassert (FRAME_WINDOW_P (f));
xassert (valid_image_p (spec));
+ c = FRAME_X_IMAGE_CACHE (f);
+
GCPRO1 (spec);
/* Look up SPEC in the hash table of the image cache. */
/* Load a DLL implementing an image type.
The `image-library-alist' variable associates a symbol,
- identifying an image type, to a list of possible filenames.
+ identifying an image type, to a list of possible filenames.
The function returns NULL if no library could be loaded for
the given image type, or if the library was previously loaded;
else the handle of the DLL. */
if (*pixmap == NULL)
{
- DWORD err = GetLastError();
+ DWORD err = GetLastError ();
Lisp_Object errcode;
/* All system errors are < 10000, so the following is safe. */
XSETINT (errcode, (int) err);
Vx_bitmap_file_path);
GCPRO2 (file_found, search_path);
- /* Try to find FILE in data-directory, then x-bitmap-file-path. */
+ /* Try to find FILE in data-directory/images, then x-bitmap-file-path. */
fd = openp (search_path, file, Qnil, &file_found, Qnil);
if (fd == -1)
3. a vector of strings or bool-vectors, one for each line of the
bitmap.
- 4. A string containing an in-memory XBM file. WIDTH and HEIGHT
+ 4. a string containing an in-memory XBM file. WIDTH and HEIGHT
may not be specified in this case because they are defined in the
XBM file.
return bmp;
}
-static void convert_mono_to_color_image (f, img, foreground, background)
+static void
+convert_mono_to_color_image (f, img, foreground, background)
struct frame *f;
struct image *img;
COLORREF foreground, background;
static void
-Create_Pixmap_From_Bitmap_Data(f, img, data, fg, bg, non_default_colors)
+Create_Pixmap_From_Bitmap_Data (f, img, data, fg, bg, non_default_colors)
struct frame *f;
struct image *img;
char *data;
return XPM_TK_EOF;
}
-/* Functions for color table lookup in XPM data. A Key is a string
+/* Functions for color table lookup in XPM data. A key is a string
specifying the color of each pixel in XPM data. A value is either
an integer that specifies a pixel color, Qt that specifies
transparency, or Qnil for the unspecified color. If the length of
created with CreateDIBSection, with the pointer to the bit values
stored in ximg->data. */
-static void XPutPixel (ximg, x, y, color)
+static void
+XPutPixel (ximg, x, y, color)
XImagePtr ximg;
int x, y;
COLORREF color;
simple transparency, we prefer a clipping mask. */
if (!transparent_p)
{
- png_color_16 *image_bg;
+ /* png_color_16 *image_bg; */
Lisp_Object specified_bg
= image_spec_value (img->spec, QCbackground, NULL);
/* Wrapper since we can't directly assign the function pointer
to another function pointer that was declared more completely easily. */
static boolean
-jpeg_resync_to_restart_wrapper(cinfo, desired)
+jpeg_resync_to_restart_wrapper (cinfo, desired)
j_decompress_ptr cinfo;
int desired;
{
whenever more data is needed. We read the whole image in one step,
so this only adds a fake end of input marker at the end. */
+static JOCTET omfib_buffer[2];
+
static boolean
our_memory_fill_input_buffer (cinfo)
j_decompress_ptr cinfo;
{
/* Insert a fake EOI marker. */
struct jpeg_source_mgr *src = cinfo->src;
- static JOCTET buffer[2];
- buffer[0] = (JOCTET) 0xFF;
- buffer[1] = (JOCTET) JPEG_EOI;
+ omfib_buffer[0] = (JOCTET) 0xFF;
+ omfib_buffer[1] = (JOCTET) JPEG_EOI;
- src->next_input_byte = buffer;
+ src->next_input_byte = omfib_buffer;
src->bytes_in_buffer = 2;
return 1;
}
/* Load GIF image IMG for use on frame F. Value is non-zero if
successful. */
+static int interlace_start[] = {0, 4, 2, 1};
+static int interlace_increment[] = {8, 8, 4, 2};
+
static int
gif_load (f, img)
struct frame *f;
memsrc.index = 0;
/* Casting return value avoids a GCC warning on W32. */
- gif = (GifFileType *)fn_DGifOpen(&memsrc, gif_read_from_memory);
+ gif = (GifFileType *) fn_DGifOpen (&memsrc, gif_read_from_memory);
if (!gif)
{
image_error ("Cannot open memory source `%s'", img->spec, Qnil);
init_color_table ();
bzero (pixel_colors, sizeof pixel_colors);
- for (i = 0; i < gif_color_map->ColorCount; ++i)
- {
- int r = gif_color_map->Colors[i].Red << 8;
- int g = gif_color_map->Colors[i].Green << 8;
- int b = gif_color_map->Colors[i].Blue << 8;
- pixel_colors[i] = lookup_rgb_color (f, r, g, b);
- }
+ if (gif_color_map)
+ for (i = 0; i < gif_color_map->ColorCount; ++i)
+ {
+ int r = gif_color_map->Colors[i].Red << 8;
+ int g = gif_color_map->Colors[i].Green << 8;
+ int b = gif_color_map->Colors[i].Blue << 8;
+ pixel_colors[i] = lookup_rgb_color (f, r, g, b);
+ }
#ifdef COLOR_TABLE_SUPPORT
img->colors = colors_in_color_table (&img->ncolors);
if (gif->SavedImages[ino].ImageDesc.Interlace)
{
- static int interlace_start[] = {0, 4, 2, 1};
- static int interlace_increment[] = {8, 8, 4, 2};
int pass;
int row = interlace_start[0];
#include <librsvg/rsvg.h>
-/* TO DO: define DEF_IMGLIB_FN here. This macro is used to handle
-loading of dynamic link library functions for various OS:es.
-Currently only librsvg2 is supported, which is only available for X,
-so its not strictly necessary yet. The current code is thought to be
-compatible with this scheme because of the defines below, should
-librsvg2 become available on more plattforms. */
+#ifdef HAVE_NTGUI
+
+/* SVG library functions. */
+DEF_IMGLIB_FN (rsvg_handle_new);
+DEF_IMGLIB_FN (rsvg_handle_set_size_callback);
+DEF_IMGLIB_FN (rsvg_handle_write);
+DEF_IMGLIB_FN (rsvg_handle_close);
+DEF_IMGLIB_FN (rsvg_handle_get_pixbuf);
+DEF_IMGLIB_FN (rsvg_handle_free);
+
+DEF_IMGLIB_FN (gdk_pixbuf_get_width);
+DEF_IMGLIB_FN (gdk_pixbuf_get_height);
+DEF_IMGLIB_FN (gdk_pixbuf_get_pixels);
+DEF_IMGLIB_FN (gdk_pixbuf_get_rowstride);
+DEF_IMGLIB_FN (gdk_pixbuf_get_colorspace);
+DEF_IMGLIB_FN (gdk_pixbuf_get_n_channels);
+DEF_IMGLIB_FN (gdk_pixbuf_get_has_alpha);
+DEF_IMGLIB_FN (gdk_pixbuf_get_bits_per_sample);
+
+DEF_IMGLIB_FN (g_type_init);
+DEF_IMGLIB_FN (g_object_unref);
+DEF_IMGLIB_FN (g_error_free);
+
+Lisp_Object Qgdk_pixbuf, Qglib;
+
+static int
+init_svg_functions (Lisp_Object libraries)
+{
+ HMODULE library, gdklib, glib;
+
+ if (!(glib = w32_delayed_load (libraries, Qglib))
+ || !(gdklib = w32_delayed_load (libraries, Qgdk_pixbuf))
+ || !(library = w32_delayed_load (libraries, Qsvg)))
+ return 0;
+
+ LOAD_IMGLIB_FN (library, rsvg_handle_new);
+ LOAD_IMGLIB_FN (library, rsvg_handle_set_size_callback);
+ LOAD_IMGLIB_FN (library, rsvg_handle_write);
+ LOAD_IMGLIB_FN (library, rsvg_handle_close);
+ LOAD_IMGLIB_FN (library, rsvg_handle_get_pixbuf);
+ LOAD_IMGLIB_FN (library, rsvg_handle_free);
+
+ LOAD_IMGLIB_FN (gdklib, gdk_pixbuf_get_width);
+ LOAD_IMGLIB_FN (gdklib, gdk_pixbuf_get_height);
+ LOAD_IMGLIB_FN (gdklib, gdk_pixbuf_get_pixels);
+ LOAD_IMGLIB_FN (gdklib, gdk_pixbuf_get_rowstride);
+ LOAD_IMGLIB_FN (gdklib, gdk_pixbuf_get_colorspace);
+ LOAD_IMGLIB_FN (gdklib, gdk_pixbuf_get_n_channels);
+ LOAD_IMGLIB_FN (gdklib, gdk_pixbuf_get_has_alpha);
+ LOAD_IMGLIB_FN (gdklib, gdk_pixbuf_get_bits_per_sample);
+
+ LOAD_IMGLIB_FN (glib, g_type_init);
+ LOAD_IMGLIB_FN (glib, g_object_unref);
+ LOAD_IMGLIB_FN (glib, g_error_free);
+ return 1;
+}
+#else
+/* The following aliases for library functions allow dynamic loading
+ to be used on some platforms. */
#define fn_rsvg_handle_new rsvg_handle_new
#define fn_rsvg_handle_set_size_callback rsvg_handle_set_size_callback
#define fn_rsvg_handle_write rsvg_handle_write
#define fn_rsvg_handle_get_pixbuf rsvg_handle_get_pixbuf
#define fn_rsvg_handle_free rsvg_handle_free
-#define fn_gdk_pixbuf_get_width gdk_pixbuf_get_width
-#define fn_gdk_pixbuf_get_height gdk_pixbuf_get_height
-#define fn_gdk_pixbuf_get_pixels gdk_pixbuf_get_pixels
-#define fn_gdk_pixbuf_get_rowstride gdk_pixbuf_get_rowstride
-#define fn_gdk_pixbuf_get_colorspace gdk_pixbuf_get_colorspace
-#define fn_gdk_pixbuf_get_n_channels gdk_pixbuf_get_n_channels
-#define fn_gdk_pixbuf_get_has_alpha gdk_pixbuf_get_has_alpha
+#define fn_gdk_pixbuf_get_width gdk_pixbuf_get_width
+#define fn_gdk_pixbuf_get_height gdk_pixbuf_get_height
+#define fn_gdk_pixbuf_get_pixels gdk_pixbuf_get_pixels
+#define fn_gdk_pixbuf_get_rowstride gdk_pixbuf_get_rowstride
+#define fn_gdk_pixbuf_get_colorspace gdk_pixbuf_get_colorspace
+#define fn_gdk_pixbuf_get_n_channels gdk_pixbuf_get_n_channels
+#define fn_gdk_pixbuf_get_has_alpha gdk_pixbuf_get_has_alpha
#define fn_gdk_pixbuf_get_bits_per_sample gdk_pixbuf_get_bits_per_sample
+#define fn_g_type_init g_type_init
+#define fn_g_object_unref g_object_unref
+#define fn_g_error_free g_error_free
+#endif /* !HAVE_NTGUI */
/* Load SVG image IMG for use on frame F. Value is non-zero if
successful. this function will go into the svg_type structure, and
return success_p;
}
-/* svg_load_image is a helper function for svg_load, which does the actual
- loading given contents and size, apart from frame and image
- structures, passed from svg_load.
+/* svg_load_image is a helper function for svg_load, which does the
+ actual loading given contents and size, apart from frame and image
+ structures, passed from svg_load.
- Uses librsvg to do most of the image processing.
+ Uses librsvg to do most of the image processing.
- Returns non-zero when sucessful. */
+ Returns non-zero when successful. */
static int
svg_load_image (f, img, contents, size)
- /* Pointer to emacs frame sturcture. */
+ /* Pointer to emacs frame structure. */
struct frame *f;
/* Pointer to emacs image structure. */
struct image *img;
/* g_type_init is a glib function that must be called prior to using
gnome type library functions. */
- g_type_init ();
+ fn_g_type_init ();
/* Make a handle to a new rsvg object. */
rsvg_handle = fn_rsvg_handle_new ();
/* Try to create a x pixmap to hold the svg pixmap. */
if (!x_create_x_image_and_pixmap (f, width, height, 0, &ximg, &img->pixmap))
{
- g_object_unref (pixbuf);
+ fn_g_object_unref (pixbuf);
return 0;
}
x_query_color (f, &background);
/* SVG pixmaps specify transparency in the last byte, so right
- shift 8 bits to get rid of it, since emacs doesnt support
+ shift 8 bits to get rid of it, since emacs doesn't support
transparency. */
background.red >>= 8;
background.green >>= 8;
background.red = RED_FROM_ULONG (background.pixel);
background.green = GREEN_FROM_ULONG (background.pixel);
background.blue = BLUE_FROM_ULONG (background.pixel);
+#elif defined (HAVE_NTGUI)
+ background.pixel = FRAME_BACKGROUND_PIXEL (f);
+#if 0 /* W32 TODO : Colormap support. */
+ x_query_color (f, &background);
+#endif
+
+ /* SVG pixmaps specify transparency in the last byte, so right
+ shift 8 bits to get rid of it, since emacs doesn't support
+ transparency. */
+ background.red >>= 8;
+ background.green >>= 8;
+ background.blue >>= 8;
#else /* not HAVE_X_WINDOWS && not MAC_OS*/
#error FIXME
#endif
/* This loop handles opacity values, since Emacs assumes
non-transparent images. Each pixel must be "flattened" by
- calculating he resulting color, given the transparency of the
- pixel, and the image background color. */
+ calculating the resulting color, given the transparency of the
+ pixel, and the image background color. */
for (y = 0; y < height; ++y)
{
for (x = 0; x < width; ++x)
free_color_table ();
#endif /* COLOR_TABLE_SUPPORT */
- g_object_unref (pixbuf);
+ fn_g_object_unref (pixbuf);
img->width = width;
img->height = height;
/* FIXME: Use error->message so the user knows what is the actual
problem with the image. */
image_error ("Error parsing SVG image `%s'", img->spec, Qnil);
- g_error_free (error);
+ fn_g_error_free (error);
return 0;
}
defining the supported image types. */
DEFVAR_LISP ("image-types", &Vimage_types,
doc: /* List of potentially supported image types.
-Each element of the list is a symbol for a image type, like 'jpeg or 'png.
+Each element of the list is a symbol for an image type, like 'jpeg or 'png.
To check whether it is really supported, use `image-type-available-p'. */);
Vimage_types = Qnil;
Emacs tries to load the libraries in the order they appear on the
list; if none is loaded, the running session of Emacs won't
support the image type. Types 'pbm and 'xbm don't need to be
-listed; they're always supported. */);
+listed; they are always supported. */);
Vimage_library_alist = Qnil;
Fput (intern ("image-library-alist"), Qrisky_local_variable, Qt);
Qpbm = intern ("pbm");
staticpro (&Qpbm);
- ADD_IMAGE_TYPE(Qpbm);
+ ADD_IMAGE_TYPE (Qpbm);
Qxbm = intern ("xbm");
staticpro (&Qxbm);
- ADD_IMAGE_TYPE(Qxbm);
+ ADD_IMAGE_TYPE (Qxbm);
define_image_type (&xbm_type, 1);
define_image_type (&pbm_type, 1);
Qpostscript = intern ("postscript");
staticpro (&Qpostscript);
#ifdef HAVE_GHOSTSCRIPT
- ADD_IMAGE_TYPE(Qpostscript);
+ ADD_IMAGE_TYPE (Qpostscript);
QCloader = intern (":loader");
staticpro (&QCloader);
QCbounding_box = intern (":bounding-box");
#if defined (HAVE_XPM) || defined (MAC_OS)
Qxpm = intern ("xpm");
staticpro (&Qxpm);
- ADD_IMAGE_TYPE(Qxpm);
+ ADD_IMAGE_TYPE (Qxpm);
#endif
#if defined (HAVE_JPEG) || defined (MAC_OS)
Qjpeg = intern ("jpeg");
staticpro (&Qjpeg);
- ADD_IMAGE_TYPE(Qjpeg);
+ ADD_IMAGE_TYPE (Qjpeg);
#endif
#if defined (HAVE_TIFF) || defined (MAC_OS)
Qtiff = intern ("tiff");
staticpro (&Qtiff);
- ADD_IMAGE_TYPE(Qtiff);
+ ADD_IMAGE_TYPE (Qtiff);
#endif
#if defined (HAVE_GIF) || defined (MAC_OS)
Qgif = intern ("gif");
staticpro (&Qgif);
- ADD_IMAGE_TYPE(Qgif);
+ ADD_IMAGE_TYPE (Qgif);
#endif
#if defined (HAVE_PNG) || defined (MAC_OS)
Qpng = intern ("png");
staticpro (&Qpng);
- ADD_IMAGE_TYPE(Qpng);
+ ADD_IMAGE_TYPE (Qpng);
#endif
#if defined (HAVE_RSVG)
Qsvg = intern ("svg");
staticpro (&Qsvg);
- ADD_IMAGE_TYPE(Qsvg);
-#endif
+ ADD_IMAGE_TYPE (Qsvg);
+#ifdef HAVE_NTGUI
+ Qgdk_pixbuf = intern ("gdk-pixbuf");
+ staticpro (&Qgdk_pixbuf);
+ Qglib = intern ("glib");
+ staticpro (&Qglib);
+#endif /* HAVE_NTGUI */
+#endif /* HAVE_RSVG */
defsubr (&Sinit_image_library);
defsubr (&Sclear_image_cache);
DEFVAR_BOOL ("cross-disabled-images", &cross_disabled_images,
doc: /* Non-nil means always draw a cross over disabled images.
-Disabled images are those having an `:conversion disabled' property.
+Disabled images are those having a `:conversion disabled' property.
A cross is always drawn on black & white displays. */);
cross_disabled_images = 0;
HCoop / bpt / emacs.git / blobdiff