#include <epaths.h>
#include "charset.h"
#include "coding.h"
-
+#include "termhooks.h"
#ifdef HAVE_X_WINDOWS
#include "xterm.h"
unsigned hash;
{
struct image *img = (struct image *) xmalloc (sizeof *img);
+ Lisp_Object file = image_spec_value (spec, QCfile, NULL);
xassert (valid_image_p (spec));
bzero (img, sizeof *img);
+ img->dependencies = NILP (file) ? Qnil : list1 (file);
img->type = lookup_image_type (image_spec_value (spec, QCtype, NULL));
xassert (img->type != NULL);
img->spec = spec;
{
if (img)
{
- struct image_cache *c = FRAME_X_IMAGE_CACHE (f);
+ struct image_cache *c = FRAME_IMAGE_CACHE (f);
/* Remove IMG from the hash table of its cache. */
if (img->prev)
unsigned hash;
{
struct image *img;
- struct image_cache *c = FRAME_X_IMAGE_CACHE (f);
+ struct image_cache *c = FRAME_IMAGE_CACHE (f);
int i = hash % IMAGE_CACHE_BUCKETS_SIZE;
if (!c) return NULL;
free_image_cache (f)
struct frame *f;
{
- struct image_cache *c = FRAME_X_IMAGE_CACHE (f);
+ struct image_cache *c = FRAME_IMAGE_CACHE (f);
if (c)
{
int i;
xfree (c->images);
xfree (c->buckets);
xfree (c);
- FRAME_X_IMAGE_CACHE (f) = NULL;
+ FRAME_IMAGE_CACHE (f) = NULL;
}
}
-/* 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-cache-eviction-delay
- is non-nil, this frees images in the cache which weren't displayed
- for at least that many seconds. */
+/* Clear image cache of frame F. FILTER=t means free all images.
+ FILTER=nil means clear only images that haven't been
+ displayed for some time.
+ Else, only free the images which have FILTER in their `dependencies'.
+ Should be called from time to time to 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;
- int force_p;
+clear_image_cache (struct frame *f, Lisp_Object filter)
{
- struct image_cache *c = FRAME_X_IMAGE_CACHE (f);
+ struct image_cache *c = FRAME_IMAGE_CACHE (f);
- if (c && INTEGERP (Vimage_cache_eviction_delay))
+ if (c && (!NILP (filter) || INTEGERP (Vimage_cache_eviction_delay)))
{
EMACS_TIME t;
unsigned long old;
{
struct image *img = c->images[i];
if (img != NULL
- && (force_p || img->timestamp < old))
+ && (NILP (filter) ? img->timestamp < old
+ : (EQ (Qt, filter)
+ || !NILP (Fmember (filter, img->dependencies)))))
{
free_image (f, img);
++nfreed;
FOR_EACH_FRAME (tail, frame)
{
struct frame *f = XFRAME (frame);
- if (FRAME_WINDOW_P (f)
- && FRAME_X_IMAGE_CACHE (f) == c)
+ if (FRAME_IMAGE_CACHE (f) == c)
clear_current_matrices (f);
}
}
}
+void
+clear_image_caches (Lisp_Object filter)
+{
+ /* FIXME: We want to do
+ * struct terminal *t;
+ * for (t = terminal_list; t; t = t->next_terminal)
+ * clear_image_cache (t, filter); */
+ Lisp_Object tail, frame;
+ FOR_EACH_FRAME (tail, frame)
+ if (FRAME_WINDOW_P (XFRAME (frame)))
+ clear_image_cache (XFRAME (frame), filter);
+}
DEFUN ("clear-image-cache", Fclear_image_cache, Sclear_image_cache,
0, 1, 0,
- doc: /* Clear the image cache of FRAME.
-FRAME nil or omitted means use the selected frame.
-FRAME t means clear the image caches of all frames. */)
- (frame)
- Lisp_Object frame;
-{
- if (EQ (frame, Qt))
- {
- Lisp_Object tail;
-
- FOR_EACH_FRAME (tail, frame)
- if (FRAME_WINDOW_P (XFRAME (frame)))
- clear_image_cache (XFRAME (frame), 1);
- }
+ doc: /* Clear the image cache.
+FILTER nil or a frame means clear all images in the selected frame.
+FILTER t means clear the image caches of all frames.
+Anything else, means only clear those images which refer to FILTER,
+which is then usually a filename. */)
+ (filter)
+ Lisp_Object filter;
+{
+ if (!(EQ (filter, Qnil) || FRAMEP (filter)))
+ clear_image_caches (filter);
else
- clear_image_cache (check_x_frame (frame), 1);
+ clear_image_cache (check_x_frame (filter), Qt);
return Qnil;
}
xassert (FRAME_WINDOW_P (f));
xassert (valid_image_p (spec));
- c = FRAME_X_IMAGE_CACHE (f);
+ c = FRAME_IMAGE_CACHE (f);
GCPRO1 (spec);
struct frame *f;
struct image *img;
{
- struct image_cache *c = FRAME_X_IMAGE_CACHE (f);
+ struct image_cache *c = FRAME_IMAGE_CACHE (f);
int i;
/* Find a free slot in c->images. */
/* Call FN on every image in the image cache of frame F. Used to mark
Lisp Objects in the image cache. */
+/* Mark Lisp objects in image IMG. */
+
+static void
+mark_image (img)
+ struct image *img;
+{
+ mark_object (img->spec);
+ mark_object (img->dependencies);
+
+ if (!NILP (img->data.lisp_val))
+ mark_object (img->data.lisp_val);
+}
+
+
void
-forall_images_in_image_cache (f, fn)
- struct frame *f;
- void (*fn) P_ ((struct image *img));
+mark_image_cache (struct image_cache *c)
{
- if (FRAME_LIVE_P (f) && FRAME_WINDOW_P (f))
+ if (c)
{
- struct image_cache *c = FRAME_X_IMAGE_CACHE (f);
- if (c)
- {
- int i;
- for (i = 0; i < c->used; ++i)
- if (c->images[i])
- fn (c->images[i]);
- }
+ int i;
+ for (i = 0; i < c->used; ++i)
+ if (c->images[i])
+ mark_image (c->images[i]);
}
}
Pixmap pixmap;
struct frame *f;
{
- struct image_cache *c = FRAME_X_IMAGE_CACHE (f);
+ struct image_cache *c = FRAME_IMAGE_CACHE (f);
int class, i;
struct image *img;