image.c 236 KB
Newer Older
1
/* Functions for image support on window system.
2
   Copyright (C) 1989, 1992-2011 Free Software Foundation, Inc.
3

4
This file is part of GNU Emacs.
5

6 7 8 9
GNU Emacs is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
10

11 12 13 14
GNU Emacs is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.
15

16 17
You should have received a copy of the GNU General Public License
along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
18 19 20 21

#include <config.h>
#include <stdio.h>
#include <math.h>
Andreas Schwab's avatar
Andreas Schwab committed
22
#include <ctype.h>
23 24
#include <unistd.h>

25 26 27 28 29 30
#ifdef HAVE_PNG
#if defined HAVE_LIBPNG_PNG_H
# include <libpng/png.h>
#else
# include <png.h>
#endif
31
#endif
32

33 34
#include <setjmp.h>

35 36 37 38 39 40 41 42 43 44 45
/* This makes the fields of a Display accessible, in Xlib header files.  */

#define XLIB_ILLEGAL_ACCESS

#include "lisp.h"
#include "frame.h"
#include "window.h"
#include "dispextern.h"
#include "blockinput.h"
#include "systime.h"
#include <epaths.h>
46
#include "character.h"
47
#include "coding.h"
48
#include "termhooks.h"
49
#include "font.h"
50 51 52 53 54 55 56 57 58 59 60 61 62 63

#ifdef HAVE_X_WINDOWS
#include "xterm.h"
#include <sys/types.h>
#include <sys/stat.h>

#define COLOR_TABLE_SUPPORT 1

typedef struct x_bitmap_record Bitmap_Record;
#define GET_PIXEL(ximg, x, y) XGetPixel(ximg, x, y)
#define NO_PIXMAP None

#define RGB_PIXEL_COLOR unsigned long

64 65
#define PIX_MASK_RETAIN	0
#define PIX_MASK_DRAW	1
66 67 68 69 70 71 72 73 74 75 76 77 78 79 80
#endif /* HAVE_X_WINDOWS */


#ifdef HAVE_NTGUI
#include "w32term.h"

/* W32_TODO : Color tables on W32.  */
#undef COLOR_TABLE_SUPPORT

typedef struct w32_bitmap_record Bitmap_Record;
#define GET_PIXEL(ximg, x, y) GetPixel(ximg, x, y)
#define NO_PIXMAP 0

#define RGB_PIXEL_COLOR COLORREF

81 82
#define PIX_MASK_RETAIN	0
#define PIX_MASK_DRAW	1
83 84 85 86

#define FRAME_X_VISUAL(f) FRAME_X_DISPLAY_INFO (f)->visual
#define x_defined_color w32_defined_color
#define DefaultDepthOfScreen(screen) (one_w32_display_info.n_cbits)
87 88 89 90 91

/* Functions from w32term.c that depend on XColor (so can't go in w32term.h
   without modifying lots of files).  */
extern void x_query_colors (struct frame *f, XColor *colors, int ncolors);
extern void x_query_color (struct frame *f, XColor *color);
92 93 94 95 96

/* Version of libpng that we were compiled with, or -1 if no PNG
   support was compiled in.  This is tested by w32-win.el to correctly
   set up the alist used to search for PNG libraries.  */
Lisp_Object Qlibpng_version;
97 98
#endif /* HAVE_NTGUI */

99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117
#ifdef HAVE_NS
#include "nsterm.h"
#include <sys/types.h>
#include <sys/stat.h>

#undef COLOR_TABLE_SUPPORT

typedef struct ns_bitmap_record Bitmap_Record;

#define GET_PIXEL(ximg, x, y) XGetPixel(ximg, x, y)
#define NO_PIXMAP 0

#define RGB_PIXEL_COLOR unsigned long
#define ZPixmap 0

#define PIX_MASK_RETAIN	0
#define PIX_MASK_DRAW	1

#define FRAME_X_VISUAL FRAME_NS_DISPLAY_INFO(f)->visual
118
#define x_defined_color(f, name, color_def, alloc) \
119 120
  ns_defined_color (f, name, color_def, alloc, 0)
#define FRAME_X_SCREEN(f) 0
121
#define DefaultDepthOfScreen(screen) x_display_list->n_planes
122 123 124
#endif /* HAVE_NS */


125 126 127
/* The symbol `postscript' identifying images of this type.  */

Lisp_Object Qpostscript;
128

129 130 131
static void x_disable_image (struct frame *, struct image *);
static void x_edge_detection (struct frame *, struct image *, Lisp_Object,
                              Lisp_Object);
132

133 134
static void init_color_table (void);
static unsigned long lookup_rgb_color (struct frame *f, int r, int g, int b);
135
#ifdef COLOR_TABLE_SUPPORT
136 137 138
static void free_color_table (void);
static unsigned long *colors_in_color_table (int *n);
static unsigned long lookup_pixel_color (struct frame *f, unsigned long p);
139 140 141 142 143 144 145 146 147 148 149 150 151
#endif

/* Code to deal with bitmaps.  Bitmaps are referenced by their bitmap
   id, which is just an int that this section returns.  Bitmaps are
   reference counted so they can be shared among frames.

   Bitmap indices are guaranteed to be > 0, so a negative number can
   be used to indicate no bitmap.

   If you use x_create_bitmap_from_data, then you must keep track of
   the bitmaps yourself.  That is, creating a bitmap from the same
   data more than once will not be caught.  */

152 153 154 155 156 157
#ifdef HAVE_NS
XImagePtr
XGetImage (Display *display, Pixmap pixmap, int x, int y,
           unsigned int width, unsigned int height,
           unsigned long plane_mask, int format)
{
158
  /* TODO: not sure what this function is supposed to do.. */
159
  ns_retain_object (pixmap);
160 161 162 163 164 165 166
  return pixmap;
}

/* use with imgs created by ns_image_for_XPM */
unsigned long
XGetPixel (XImagePtr ximage, int x, int y)
{
167
  return ns_get_pixel (ximage, x, y);
168 169 170 171 172 173 174
}

/* use with imgs created by ns_image_for_XPM; alpha set to 1;
   pixel is assumed to be in form RGB */
void
XPutPixel (XImagePtr ximage, int x, int y, unsigned long pixel)
{
175
  ns_put_pixel (ximage, x, y, pixel);
176 177 178
}
#endif /* HAVE_NS */

179 180 181 182

/* Functions to access the contents of a bitmap, given an id.  */

int
183
x_bitmap_height (FRAME_PTR f, int id)
184 185 186 187 188
{
  return FRAME_X_DISPLAY_INFO (f)->bitmaps[id - 1].height;
}

int
189
x_bitmap_width (FRAME_PTR f, int id)
190 191 192 193 194 195
{
  return FRAME_X_DISPLAY_INFO (f)->bitmaps[id - 1].width;
}

#if defined (HAVE_X_WINDOWS) || defined (HAVE_NTGUI)
int
196
x_bitmap_pixmap (FRAME_PTR f, int id)
197 198 199 200 201 202 203
{
  return (int) FRAME_X_DISPLAY_INFO (f)->bitmaps[id - 1].pixmap;
}
#endif

#ifdef HAVE_X_WINDOWS
int
204
x_bitmap_mask (FRAME_PTR f, int id)
205 206 207 208 209 210 211 212
{
  return FRAME_X_DISPLAY_INFO (f)->bitmaps[id - 1].mask;
}
#endif

/* Allocate a new bitmap record.  Returns index of new record.  */

static int
213
x_allocate_bitmap_record (FRAME_PTR f)
214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243
{
  Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
  int i;

  if (dpyinfo->bitmaps == NULL)
    {
      dpyinfo->bitmaps_size = 10;
      dpyinfo->bitmaps
	= (Bitmap_Record *) xmalloc (dpyinfo->bitmaps_size * sizeof (Bitmap_Record));
      dpyinfo->bitmaps_last = 1;
      return 1;
    }

  if (dpyinfo->bitmaps_last < dpyinfo->bitmaps_size)
    return ++dpyinfo->bitmaps_last;

  for (i = 0; i < dpyinfo->bitmaps_size; ++i)
    if (dpyinfo->bitmaps[i].refcount == 0)
      return i + 1;

  dpyinfo->bitmaps_size *= 2;
  dpyinfo->bitmaps
    = (Bitmap_Record *) xrealloc (dpyinfo->bitmaps,
				  dpyinfo->bitmaps_size * sizeof (Bitmap_Record));
  return ++dpyinfo->bitmaps_last;
}

/* Add one reference to the reference count of the bitmap with id ID.  */

void
244
x_reference_bitmap (FRAME_PTR f, int id)
245 246 247 248 249 250 251
{
  ++FRAME_X_DISPLAY_INFO (f)->bitmaps[id - 1].refcount;
}

/* Create a bitmap for frame F from a HEIGHT x WIDTH array of bits at BITS.  */

int
252
x_create_bitmap_from_data (struct frame *f, char *bits, unsigned int width, unsigned int height)
253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274
{
  Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
  int id;

#ifdef HAVE_X_WINDOWS
  Pixmap bitmap;
  bitmap = XCreateBitmapFromData (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
				  bits, width, height);
  if (! bitmap)
    return -1;
#endif /* HAVE_X_WINDOWS */

#ifdef HAVE_NTGUI
  Pixmap bitmap;
  bitmap = CreateBitmap (width, height,
			 FRAME_X_DISPLAY_INFO (XFRAME (frame))->n_planes,
			 FRAME_X_DISPLAY_INFO (XFRAME (frame))->n_cbits,
			 bits);
  if (! bitmap)
    return -1;
#endif /* HAVE_NTGUI */

275
#ifdef HAVE_NS
276
  void *bitmap = ns_image_from_XBM (bits, width, height);
277
  if (!bitmap)
278
      return -1;
279 280
#endif

281 282
  id = x_allocate_bitmap_record (f);

283 284 285 286 287
#ifdef HAVE_NS
  dpyinfo->bitmaps[id - 1].img = bitmap;
  dpyinfo->bitmaps[id - 1].depth = 1;
#endif

288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310
  dpyinfo->bitmaps[id - 1].file = NULL;
  dpyinfo->bitmaps[id - 1].height = height;
  dpyinfo->bitmaps[id - 1].width = width;
  dpyinfo->bitmaps[id - 1].refcount = 1;

#ifdef HAVE_X_WINDOWS
  dpyinfo->bitmaps[id - 1].pixmap = bitmap;
  dpyinfo->bitmaps[id - 1].have_mask = 0;
  dpyinfo->bitmaps[id - 1].depth = 1;
#endif /* HAVE_X_WINDOWS */

#ifdef HAVE_NTGUI
  dpyinfo->bitmaps[id - 1].pixmap = bitmap;
  dpyinfo->bitmaps[id - 1].hinst = NULL;
  dpyinfo->bitmaps[id - 1].depth = 1;
#endif /* HAVE_NTGUI */

  return id;
}

/* Create bitmap from file FILE for frame F.  */

int
311
x_create_bitmap_from_file (struct frame *f, Lisp_Object file)
312
{
313 314
  Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);

315 316 317 318
#ifdef HAVE_NTGUI
  return -1;  /* W32_TODO : bitmap support */
#endif /* HAVE_NTGUI */

319 320
#ifdef HAVE_NS
  int id;
321
  void *bitmap = ns_image_from_file (file);
322 323

  if (!bitmap)
324
      return -1;
325 326 327 328 329 330 331


  id = x_allocate_bitmap_record (f);
  dpyinfo->bitmaps[id - 1].img = bitmap;
  dpyinfo->bitmaps[id - 1].refcount = 1;
  dpyinfo->bitmaps[id - 1].file = (char *) xmalloc (SBYTES (file) + 1);
  dpyinfo->bitmaps[id - 1].depth = 1;
332 333
  dpyinfo->bitmaps[id - 1].height = ns_image_width (bitmap);
  dpyinfo->bitmaps[id - 1].width = ns_image_height (bitmap);
334 335 336 337
  strcpy (dpyinfo->bitmaps[id - 1].file, SDATA (file));
  return id;
#endif

338 339 340 341 342 343 344 345 346 347 348 349 350
#ifdef HAVE_X_WINDOWS
  unsigned int width, height;
  Pixmap bitmap;
  int xhot, yhot, result, id;
  Lisp_Object found;
  int fd;
  char *filename;

  /* Look for an existing bitmap with the same name.  */
  for (id = 0; id < dpyinfo->bitmaps_last; ++id)
    {
      if (dpyinfo->bitmaps[id].refcount
	  && dpyinfo->bitmaps[id].file
351
	  && !strcmp (dpyinfo->bitmaps[id].file, SSDATA (file)))
352 353 354 355 356 357 358 359 360 361 362 363
	{
	  ++dpyinfo->bitmaps[id].refcount;
	  return id + 1;
	}
    }

  /* Search bitmap-file-path for the file, if appropriate.  */
  fd = openp (Vx_bitmap_file_path, file, Qnil, &found, Qnil);
  if (fd < 0)
    return -1;
  emacs_close (fd);

364
  filename = SSDATA (found);
365 366 367 368 369 370 371 372 373 374 375 376 377 378

  result = XReadBitmapFile (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
			    filename, &width, &height, &bitmap, &xhot, &yhot);
  if (result != BitmapSuccess)
    return -1;

  id = x_allocate_bitmap_record (f);
  dpyinfo->bitmaps[id - 1].pixmap = bitmap;
  dpyinfo->bitmaps[id - 1].have_mask = 0;
  dpyinfo->bitmaps[id - 1].refcount = 1;
  dpyinfo->bitmaps[id - 1].file = (char *) xmalloc (SBYTES (file) + 1);
  dpyinfo->bitmaps[id - 1].depth = 1;
  dpyinfo->bitmaps[id - 1].height = height;
  dpyinfo->bitmaps[id - 1].width = width;
379
  strcpy (dpyinfo->bitmaps[id - 1].file, SSDATA (file));
380 381 382 383 384 385 386 387

  return id;
#endif /* HAVE_X_WINDOWS */
}

/* Free bitmap B.  */

static void
388
free_bitmap_record (Display_Info *dpyinfo, Bitmap_Record *bm)
389 390 391 392 393 394 395 396 397 398 399
{
#ifdef HAVE_X_WINDOWS
  XFreePixmap (dpyinfo->display, bm->pixmap);
  if (bm->have_mask)
    XFreePixmap (dpyinfo->display, bm->mask);
#endif /* HAVE_X_WINDOWS */

#ifdef HAVE_NTGUI
  DeleteObject (bm->pixmap);
#endif /* HAVE_NTGUI */

400
#ifdef HAVE_NS
401
  ns_release_object (bm->img);
402 403
#endif

404 405 406 407 408 409 410 411 412 413
  if (bm->file)
    {
      xfree (bm->file);
      bm->file = NULL;
    }
}

/* Remove reference to bitmap with id number ID.  */

void
414
x_destroy_bitmap (FRAME_PTR f, int id)
415 416 417 418 419 420 421 422 423 424
{
  Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);

  if (id > 0)
    {
      Bitmap_Record *bm = &dpyinfo->bitmaps[id - 1];

      if (--bm->refcount == 0)
	{
	  BLOCK_INPUT;
425
	  free_bitmap_record (dpyinfo, bm);
426 427 428 429 430 431 432 433
	  UNBLOCK_INPUT;
	}
    }
}

/* Free all the bitmaps for the display specified by DPYINFO.  */

void
434
x_destroy_all_bitmaps (Display_Info *dpyinfo)
435 436 437 438 439 440
{
  int i;
  Bitmap_Record *bm = dpyinfo->bitmaps;

  for (i = 0; i < dpyinfo->bitmaps_last; i++, bm++)
    if (bm->refcount > 0)
441
      free_bitmap_record (dpyinfo, bm);
442 443 444 445 446 447 448 449 450 451

  dpyinfo->bitmaps_last = 0;
}


#ifdef HAVE_X_WINDOWS

/* Useful functions defined in the section
   `Image type independent image structures' below. */

452 453 454 455
static unsigned long four_corners_best (XImagePtr ximg,
                                        int *corners,
                                        unsigned long width,
                                        unsigned long height);
456

457 458 459
static int x_create_x_image_and_pixmap (struct frame *f, int width, int height,
                                        int depth, XImagePtr *ximg,
                                        Pixmap *pixmap);
460

461
static void x_destroy_x_image (XImagePtr ximg);
462 463 464 465 466 467


/* Create a mask of a bitmap. Note is this not a perfect mask.
   It's nicer with some borders in this context */

int
468
x_create_bitmap_mask (struct frame *f, int id)
469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505
{
  Pixmap pixmap, mask;
  XImagePtr ximg, mask_img;
  unsigned long width, height;
  int result;
  unsigned long bg;
  unsigned long x, y, xp, xm, yp, ym;
  GC gc;

  Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);

  if (!(id > 0))
    return -1;

  pixmap = x_bitmap_pixmap (f, id);
  width = x_bitmap_width (f, id);
  height = x_bitmap_height (f, id);

  BLOCK_INPUT;
  ximg = XGetImage (FRAME_X_DISPLAY (f), pixmap, 0, 0, width, height,
		    ~0, ZPixmap);

  if (!ximg)
    {
      UNBLOCK_INPUT;
      return -1;
    }

  result = x_create_x_image_and_pixmap (f, width, height, 1, &mask_img, &mask);

  UNBLOCK_INPUT;
  if (!result)
    {
      XDestroyImage (ximg);
      return -1;
    }

506
  bg = four_corners_best (ximg, NULL, width, height);
507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550

  for (y = 0; y < ximg->height; ++y)
    {
      for (x = 0; x < ximg->width; ++x)
	{
	  xp = x != ximg->width - 1 ? x + 1 : 0;
	  xm = x != 0 ? x - 1 : ximg->width - 1;
	  yp = y != ximg->height - 1 ? y + 1 : 0;
	  ym = y != 0 ? y - 1 : ximg->height - 1;
	  if (XGetPixel (ximg, x, y) == bg
	      && XGetPixel (ximg, x, yp) == bg
	      && XGetPixel (ximg, x, ym) == bg
	      && XGetPixel (ximg, xp, y) == bg
	      && XGetPixel (ximg, xp, yp) == bg
	      && XGetPixel (ximg, xp, ym) == bg
	      && XGetPixel (ximg, xm, y) == bg
	      && XGetPixel (ximg, xm, yp) == bg
	      && XGetPixel (ximg, xm, ym) == bg)
	    XPutPixel (mask_img, x, y, 0);
	  else
	    XPutPixel (mask_img, x, y, 1);
	}
    }

  xassert (interrupt_input_blocked);
  gc = XCreateGC (FRAME_X_DISPLAY (f), mask, 0, NULL);
  XPutImage (FRAME_X_DISPLAY (f), mask, gc, mask_img, 0, 0, 0, 0,
	     width, height);
  XFreeGC (FRAME_X_DISPLAY (f), gc);

  dpyinfo->bitmaps[id - 1].have_mask = 1;
  dpyinfo->bitmaps[id - 1].mask = mask;

  XDestroyImage (ximg);
  x_destroy_x_image (mask_img);

  return 0;
}

#endif /* HAVE_X_WINDOWS */


/***********************************************************************
			    Image types
551
 ***********************************************************************/
552 553 554 555 556 557

/* List of supported image types.  Use define_image_type to add new
   types.  Use lookup_image_type to find a type for a given symbol.  */

static struct image_type *image_types;

558 559 560 561
/* Cache for delayed-loading image types.  */

static Lisp_Object Vimage_type_cache;

562 563 564 565 566 567
/* The symbol `xbm' which is used as the type symbol for XBM images.  */

Lisp_Object Qxbm;

/* Keywords.  */

568
Lisp_Object QCascent, QCmargin, QCrelief, Qcount, Qextension_data;
569
Lisp_Object QCconversion, QCcolor_symbols, QCheuristic_mask;
570
Lisp_Object QCindex, QCmatrix, QCcolor_adjustment, QCmask, QCgeometry, QCcrop, QCrotation;
571 572 573 574 575 576 577

/* Other symbols.  */

Lisp_Object Qlaplace, Qemboss, Qedge_detection, Qheuristic;

/* Function prototypes.  */

578 579
static Lisp_Object define_image_type (struct image_type *type, int loaded);
static struct image_type *lookup_image_type (Lisp_Object symbol);
580
static void image_error (const char *format, Lisp_Object, Lisp_Object);
581 582 583 584
static void x_laplace (struct frame *, struct image *);
static void x_emboss (struct frame *, struct image *);
static int x_build_heuristic_mask (struct frame *, struct image *,
                                   Lisp_Object);
585

586
#define CACHE_IMAGE_TYPE(type, status) \
587 588
  do { Vimage_type_cache = Fcons (Fcons (type, status), Vimage_type_cache); } while (0)

589
#define ADD_IMAGE_TYPE(type) \
590
  do { Vimage_types = Fcons (type, Vimage_types); } while (0)
591 592

/* Define a new image type from TYPE.  This adds a copy of TYPE to
593
   image_types and caches the loading status of TYPE.  */
594

595
static Lisp_Object
596
define_image_type (struct image_type *type, int loaded)
597
{
598 599 600 601 602 603 604 605 606
  Lisp_Object success;

  if (!loaded)
    success = Qnil;
  else
    {
      /* Make a copy of TYPE to avoid a bus error in a dumped Emacs.
         The initialized data segment is read-only.  */
      struct image_type *p = (struct image_type *) xmalloc (sizeof *p);
607
      memcpy (p, type, sizeof *p);
608 609 610 611 612
      p->next = image_types;
      image_types = p;
      success = Qt;
    }

613
  CACHE_IMAGE_TYPE (*type->type, success);
614
  return success;
615 616 617 618 619 620 621
}


/* Look up image type SYMBOL, and return a pointer to its image_type
   structure.  Value is null if SYMBOL is not a known image type.  */

static INLINE struct image_type *
622
lookup_image_type (Lisp_Object symbol)
623 624 625
{
  struct image_type *type;

626
  /* We must initialize the image-type if it hasn't been already.  */
627
  if (NILP (Finit_image_library (symbol, Vdynamic_library_alist)))
628 629
    return 0;			/* unimplemented */

630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645
  for (type = image_types; type; type = type->next)
    if (EQ (symbol, *type->type))
      break;

  return type;
}


/* Value is non-zero if OBJECT is a valid Lisp image specification.  A
   valid image specification is a list whose car is the symbol
   `image', and whose rest is a property list.  The property list must
   contain a value for key `:type'.  That value must be the name of a
   supported image type.  The rest of the property list depends on the
   image type.  */

int
646
valid_image_p (Lisp_Object object)
647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680
{
  int valid_p = 0;

  if (IMAGEP (object))
    {
      Lisp_Object tem;

      for (tem = XCDR (object); CONSP (tem); tem = XCDR (tem))
	if (EQ (XCAR (tem), QCtype))
	  {
	    tem = XCDR (tem);
	    if (CONSP (tem) && SYMBOLP (XCAR (tem)))
	      {
		struct image_type *type;
		type = lookup_image_type (XCAR (tem));
		if (type)
		  valid_p = type->valid_p (object);
	      }

	    break;
	  }
    }

  return valid_p;
}


/* Log error message with format string FORMAT and argument ARG.
   Signaling an error, e.g. when an image cannot be loaded, is not a
   good idea because this would interrupt redisplay, and the error
   message display would lead to another redisplay.  This function
   therefore simply displays a message.  */

static void
681
image_error (const char *format, Lisp_Object arg1, Lisp_Object arg2)
682 683 684 685 686 687 688 689
{
  add_to_log (format, arg1, arg2);
}



/***********************************************************************
			 Image specifications
690
 ***********************************************************************/
691 692

enum image_value_type
693 694 695 696 697 698 699 700 701 702 703 704 705 706
{
  IMAGE_DONT_CHECK_VALUE_TYPE,
  IMAGE_STRING_VALUE,
  IMAGE_STRING_OR_NIL_VALUE,
  IMAGE_SYMBOL_VALUE,
  IMAGE_POSITIVE_INTEGER_VALUE,
  IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR,
  IMAGE_NON_NEGATIVE_INTEGER_VALUE,
  IMAGE_ASCENT_VALUE,
  IMAGE_INTEGER_VALUE,
  IMAGE_FUNCTION_VALUE,
  IMAGE_NUMBER_VALUE,
  IMAGE_BOOL_VALUE
};
707 708 709 710 711 712

/* Structure used when parsing image specifications.  */

struct image_keyword
{
  /* Name of keyword.  */
713
  const char *name;
714 715 716 717 718 719 720 721 722 723 724 725 726 727 728

  /* The type of value allowed.  */
  enum image_value_type type;

  /* Non-zero means key must be present.  */
  int mandatory_p;

  /* Used to recognize duplicate keywords in a property list.  */
  int count;

  /* The value that was found.  */
  Lisp_Object value;
};


729 730 731
static int parse_image_spec (Lisp_Object, struct image_keyword *,
                             int, Lisp_Object);
static Lisp_Object image_spec_value (Lisp_Object, Lisp_Object, int *);
732 733 734 735 736 737 738 739 740


/* Parse image spec SPEC according to KEYWORDS.  A valid image spec
   has the format (image KEYWORD VALUE ...).  One of the keyword/
   value pairs must be `:type TYPE'.  KEYWORDS is a vector of
   image_keywords structures of size NKEYWORDS describing other
   allowed keyword/value pairs.  Value is non-zero if SPEC is valid.  */

static int
741 742
parse_image_spec (Lisp_Object spec, struct image_keyword *keywords,
		  int nkeywords, Lisp_Object type)
743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768
{
  int i;
  Lisp_Object plist;

  if (!IMAGEP (spec))
    return 0;

  plist = XCDR (spec);
  while (CONSP (plist))
    {
      Lisp_Object key, value;

      /* First element of a pair must be a symbol.  */
      key = XCAR (plist);
      plist = XCDR (plist);
      if (!SYMBOLP (key))
	return 0;

      /* There must follow a value.  */
      if (!CONSP (plist))
	return 0;
      value = XCAR (plist);
      plist = XCDR (plist);

      /* Find key in KEYWORDS.  Error if not found.  */
      for (i = 0; i < nkeywords; ++i)
769
	if (strcmp (keywords[i].name, SSDATA (SYMBOL_NAME (key))) == 0)
770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877
	  break;

      if (i == nkeywords)
	continue;

      /* Record that we recognized the keyword.  If a keywords
	 was found more than once, it's an error.  */
      keywords[i].value = value;
      ++keywords[i].count;

      if (keywords[i].count > 1)
	return 0;

      /* Check type of value against allowed type.  */
      switch (keywords[i].type)
	{
	case IMAGE_STRING_VALUE:
	  if (!STRINGP (value))
	    return 0;
	  break;

	case IMAGE_STRING_OR_NIL_VALUE:
	  if (!STRINGP (value) && !NILP (value))
	    return 0;
	  break;

	case IMAGE_SYMBOL_VALUE:
	  if (!SYMBOLP (value))
	    return 0;
	  break;

	case IMAGE_POSITIVE_INTEGER_VALUE:
	  if (!INTEGERP (value) || XINT (value) <= 0)
	    return 0;
	  break;

	case IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR:
	  if (INTEGERP (value) && XINT (value) >= 0)
	    break;
	  if (CONSP (value)
	      && INTEGERP (XCAR (value)) && INTEGERP (XCDR (value))
	      && XINT (XCAR (value)) >= 0 && XINT (XCDR (value)) >= 0)
	    break;
	  return 0;

	case IMAGE_ASCENT_VALUE:
	  if (SYMBOLP (value) && EQ (value, Qcenter))
	    break;
	  else if (INTEGERP (value)
		   && XINT (value) >= 0
		   && XINT (value) <= 100)
	    break;
	  return 0;

	case IMAGE_NON_NEGATIVE_INTEGER_VALUE:
	  if (!INTEGERP (value) || XINT (value) < 0)
	    return 0;
	  break;

	case IMAGE_DONT_CHECK_VALUE_TYPE:
	  break;

	case IMAGE_FUNCTION_VALUE:
	  value = indirect_function (value);
	  if (SUBRP (value)
	      || COMPILEDP (value)
	      || (CONSP (value) && EQ (XCAR (value), Qlambda)))
	    break;
	  return 0;

	case IMAGE_NUMBER_VALUE:
	  if (!INTEGERP (value) && !FLOATP (value))
	    return 0;
	  break;

	case IMAGE_INTEGER_VALUE:
	  if (!INTEGERP (value))
	    return 0;
	  break;

	case IMAGE_BOOL_VALUE:
	  if (!NILP (value) && !EQ (value, Qt))
	    return 0;
	  break;

	default:
	  abort ();
	  break;
	}

      if (EQ (key, QCtype) && !EQ (type, value))
	return 0;
    }

  /* Check that all mandatory fields are present.  */
  for (i = 0; i < nkeywords; ++i)
    if (keywords[i].mandatory_p && keywords[i].count == 0)
      return 0;

  return NILP (plist);
}


/* Return the value of KEY in image specification SPEC.  Value is nil
   if KEY is not present in SPEC.  if FOUND is not null, set *FOUND
   to 1 if KEY was found in SPEC, set it to 0 otherwise.  */

static Lisp_Object
878
image_spec_value (Lisp_Object spec, Lisp_Object key, int *found)
879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907
{
  Lisp_Object tail;

  xassert (valid_image_p (spec));

  for (tail = XCDR (spec);
       CONSP (tail) && CONSP (XCDR (tail));
       tail = XCDR (XCDR (tail)))
    {
      if (EQ (XCAR (tail), key))
	{
	  if (found)
	    *found = 1;
	  return XCAR (XCDR (tail));
	}
    }

  if (found)
    *found = 0;
  return Qnil;
}


DEFUN ("image-size", Fimage_size, Simage_size, 1, 3, 0,
       doc: /* Return the size of image SPEC as pair (WIDTH . HEIGHT).
PIXELS non-nil means return the size in pixels, otherwise return the
size in canonical character units.
FRAME is the frame on which the image will be displayed.  FRAME nil
or omitted means use the selected frame.  */)
Dan Nicolaescu's avatar
Dan Nicolaescu committed
908
  (Lisp_Object spec, Lisp_Object pixels, Lisp_Object frame)
909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937
{
  Lisp_Object size;

  size = Qnil;
  if (valid_image_p (spec))
    {
      struct frame *f = check_x_frame (frame);
      int id = lookup_image (f, spec);
      struct image *img = IMAGE_FROM_ID (f, id);
      int width = img->width + 2 * img->hmargin;
      int height = img->height + 2 * img->vmargin;

      if (NILP (pixels))
	size = Fcons (make_float ((double) width / FRAME_COLUMN_WIDTH (f)),
		      make_float ((double) height / FRAME_LINE_HEIGHT (f)));
      else
	size = Fcons (make_number (width), make_number (height));
    }
  else
    error ("Invalid image specification");

  return size;
}


DEFUN ("image-mask-p", Fimage_mask_p, Simage_mask_p, 1, 2, 0,
       doc: /* Return t if image SPEC has a mask bitmap.
FRAME is the frame on which the image will be displayed.  FRAME nil
or omitted means use the selected frame.  */)
Dan Nicolaescu's avatar
Dan Nicolaescu committed
938
  (Lisp_Object spec, Lisp_Object frame)
939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956
{
  Lisp_Object mask;

  mask = Qnil;
  if (valid_image_p (spec))
    {
      struct frame *f = check_x_frame (frame);
      int id = lookup_image (f, spec);
      struct image *img = IMAGE_FROM_ID (f, id);
      if (img->mask)
	mask = Qt;
    }
  else
    error ("Invalid image specification");

  return mask;
}

957 958
DEFUN ("image-metadata", Fimage_metadata, Simage_metadata, 1, 2, 0,
       doc: /* Return metadata for image SPEC.
959 960
FRAME is the frame on which the image will be displayed.  FRAME nil
or omitted means use the selected frame.  */)
Dan Nicolaescu's avatar
Dan Nicolaescu committed
961
  (Lisp_Object spec, Lisp_Object frame)
962 963 964 965 966 967 968 969 970 971 972 973 974 975 976
{
  Lisp_Object ext;

  ext = Qnil;
  if (valid_image_p (spec))
    {
      struct frame *f = check_x_frame (frame);
      int id = lookup_image (f, spec);
      struct image *img = IMAGE_FROM_ID (f, id);
      ext = img->data.lisp_val;
    }

  return ext;
}

977 978 979

/***********************************************************************
		 Image type independent image structures
980
 ***********************************************************************/
981

982 983 984
static struct image *make_image (Lisp_Object spec, unsigned hash);
static void free_image (struct frame *f, struct image *img);
static int check_image_size (struct frame *f, int width, int height);
985

986
#define MAX_IMAGE_SIZE 6.0
987 988 989 990
/* Allocate and return a new image structure for image specification
   SPEC.  SPEC has a hash value of HASH.  */

static struct image *
991
make_image (Lisp_Object spec, unsigned int hash)
992 993
{
  struct image *img = (struct image *) xmalloc (sizeof *img);
994
  Lisp_Object file = image_spec_value (spec, QCfile, NULL);
995 996

  xassert (valid_image_p (spec));
997
  memset (img, 0, sizeof *img);
998
  img->dependencies = NILP (file) ? Qnil : list1 (file);
999 1000 1001 1002 1003 1004
  img->type = lookup_image_type (image_spec_value (spec, QCtype, NULL));
  xassert (img->type != NULL);
  img->spec = spec;
  img->data.lisp_val = Qnil;
  img->ascent = DEFAULT_IMAGE_ASCENT;
  img->hash = hash;
1005
  img->corners[BOT_CORNER] = -1;  /* Full image */
1006 1007 1008 1009 1010 1011 1012
  return img;
}


/* Free image IMG which was used on frame F, including its resources.  */

static void
1013
free_image (struct frame *f, struct image *img)
1014 1015 1016
{
  if (img)
    {
1017
      struct image_cache *c = FRAME_IMAGE_CACHE (f);
1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035

      /* Remove IMG from the hash table of its cache.  */
      if (img->prev)
	img->prev->next = img->next;
      else
	c->buckets[img->hash % IMAGE_CACHE_BUCKETS_SIZE] = img->next;

      if (img->next)
	img->next->prev = img->prev;

      c->images[img->id] = NULL;

      /* Free resources, then free IMG.  */
      img->type->free (f, img);
      xfree (img);
    }
}

1036 1037 1038 1039
/* Return 1 if the given widths and heights are valid for display;
   otherwise, return 0. */

int
1040
check_image_size (struct frame *f, int width, int height)
1041
{
1042
  int w, h;
1043

1044
  if (width <= 0 || height <= 0)
1045 1046
    return 0;

1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064
  if (INTEGERP (Vmax_image_size))
    w = h = XINT (Vmax_image_size);
  else if (FLOATP (Vmax_image_size))
    {
      if (f != NULL)
	{
	  w = FRAME_PIXEL_WIDTH (f);
	  h = FRAME_PIXEL_HEIGHT (f);
	}
      else
	w = h = 1024;  /* Arbitrary size for unknown frame. */
      w = (int) (XFLOAT_DATA (Vmax_image_size) * w);
      h = (int) (XFLOAT_DATA (Vmax_image_size) * h);
    }
  else
    return 1;

  return (width <= w && height <= h);
1065
}
1066 1067 1068 1069 1070

/* Prepare image IMG for display on frame F.  Must be called before
   drawing an image.  */

void
1071
prepare_image_for_display (struct frame *f, struct image *img)
1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082
{
  EMACS_TIME t;

  /* We're about to display IMG, so set its timestamp to `now'.  */
  EMACS_GET_TIME (t);
  img->timestamp = EMACS_SECS (t);

  /* If IMG doesn't have a pixmap yet, load it now, using the image
     type dependent loader function.  */
  if (img->pixmap == NO_PIXMAP && !img->load_failed_p)
    img->load_failed_p = img->type->load (f, img) == 0;
1083

1084 1085 1086 1087 1088 1089 1090
}


/* Value is the number of pixels for the ascent of image IMG when
   drawn in face FACE.  */

int
1091
image_ascent (struct image *img, struct face *face, struct glyph_slice *slice)
1092
{
1093
  int height;
1094 1095
  int ascent;

1096 1097 1098 1099 1100 1101 1102
  if (slice->height == img->height)
    height = img->height + img->vmargin;
  else if (slice->y == 0)
    height = slice->height + img->vmargin;
  else
    height = slice->height;

1103 1104 1105 1106 1107 1108
  if (img->ascent == CENTERED_IMAGE_ASCENT)
    {
      if (face->font)
	{
#ifdef HAVE_NTGUI
	  /* W32 specific version.  Why?. ++kfs  */
1109 1110
	  ascent = height / 2 - (FONT_DESCENT (face->font)
				 - FONT_BASE (face->font)) / 2;
1111 1112 1113 1114 1115 1116
#else
	  /* This expression is arranged so that if the image can't be
	     exactly centered, it will be moved slightly up.  This is
	     because a typical font is `top-heavy' (due to the presence
	     uppercase letters), so the image placement should err towards
	     being top-heavy too.  It also just generally looks better.  */
1117 1118
	  ascent = (height + FONT_BASE(face->font)
                    - FONT_DESCENT(face->font) + 1) / 2;
1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136
#endif /* HAVE_NTGUI */
	}
      else
	ascent = height / 2;
    }
  else
    ascent = (int) (height * img->ascent / 100.0);

  return ascent;
}


/* Image background colors.  */

/* Find the "best" corner color of a bitmap.
   On W32, XIMG is assumed to a device context with the bitmap selected.  */

static RGB_PIXEL_COLOR
1137 1138
four_corners_best (XImagePtr_or_DC ximg, int *corners,
		   unsigned long width, unsigned long height)
1139
{
1140
  RGB_PIXEL_COLOR corner_pixels[4], best IF_LINT (= 0);
1141 1142
  int i, best_count;

1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158
  if (corners && corners[BOT_CORNER] >= 0)
    {
      /* Get the colors at the corner_pixels of ximg.  */
      corner_pixels[0] = GET_PIXEL (ximg, corners[LEFT_CORNER], corners[TOP_CORNER]);
      corner_pixels[1] = GET_PIXEL (ximg, corners[RIGHT_CORNER] - 1, corners[TOP_CORNER]);
      corner_pixels[2] = GET_PIXEL (ximg, corners[RIGHT_CORNER] - 1, corners[BOT_CORNER] - 1);
      corner_pixels[3] = GET_PIXEL (ximg, corners[LEFT_CORNER], corners[BOT_CORNER] - 1);
    }
  else
    {
      /* Get the colors at the corner_pixels of ximg.  */
      corner_pixels[0] = GET_PIXEL (ximg, 0, 0);
      corner_pixels[1] = GET_PIXEL (ximg, width - 1, 0);
      corner_pixels[2] = GET_PIXEL (ximg, width - 1, height - 1);
      corner_pixels[3] = GET_PIXEL (ximg, 0, height - 1);
    }
1159 1160 1161 1162 1163 1164
  /* Choose the most frequently found color as background.  */
  for (i = best_count = 0; i < 4; ++i)
    {
      int j, n;

      for (j = n = 0; j < 4; ++j)
1165
	if (corner_pixels[i] == corner_pixels[j])
1166 1167 1168
	  ++n;

      if (n > best_count)
1169
	best = corner_pixels[i], best_count = n;
1170 1171 1172 1173 1174 1175 1176 1177 1178
    }

  return best;
}

/* Portability macros */

#ifdef HAVE_NTGUI

1179
#define Destroy_Image(img_dc, prev) \
1180 1181
  do { SelectObject (img_dc, prev); DeleteDC (img_dc); } while (0)

1182
#define Free_Pixmap(display, pixmap) \
1183 1184
  DeleteObject (pixmap)

1185 1186 1187
#elif defined (HAVE_NS)

#define Destroy_Image(ximg, dummy) \
1188
  ns_release_object (ximg)
1189 1190

#define Free_Pixmap(display, pixmap) \
1191
  ns_release_object (pixmap)
1192

1193 1194
#else

1195
#define Destroy_Image(ximg, dummy) \
1196 1197
  XDestroyImage (ximg)

1198
#define Free_Pixmap(display, pixmap) \
1199 1200
  XFreePixmap (display, pixmap)

1201
#endif /* !HAVE_NTGUI && !HAVE_NS */
1202 1203 1204 1205 1206


/* Return the `background' field of IMG.  If IMG doesn't have one yet,
   it is guessed heuristically.  If non-zero, XIMG is an existing
   XImage object (or device context with the image selected on W32) to
Kim F. Storm's avatar
Kim F. Storm committed
1207
   use for the heuristic.  */
1208 1209

RGB_PIXEL_COLOR
1210
image_background (struct image *img, struct frame *f, XImagePtr_or_DC ximg)
1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232
{
  if (! img->background_valid)
    /* IMG doesn't have a background yet, try to guess a reasonable value.  */
    {
      int free_ximg = !ximg;
#ifdef HAVE_NTGUI
      HGDIOBJ prev;
#endif /* HAVE_NTGUI */

      if (free_ximg)
	{
#ifndef HAVE_NTGUI
	  ximg = XGetImage (FRAME_X_DISPLAY (f), img->pixmap,
			    0, 0, img->width, img->height, ~0, ZPixmap);
#else
	  HDC frame_dc = get_frame_dc (f);
	  ximg = CreateCompatibleDC (frame_dc);
	  release_frame_dc (f, frame_dc);
	  prev = SelectObject (ximg, img->pixmap);
#endif /* !HAVE_NTGUI */
	}

1233
      img->background = four_corners_best (ximg, img->corners, img->width, img->height);
1234 1235 1236

      if (free_ximg)
	Destroy_Image (ximg, prev);
Kim F. Storm's avatar
Kim F. Storm committed
1237

1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248
      img->background_valid = 1;
    }

  return img->background;
}

/* Return the `background_transparent' field of IMG.  If IMG doesn't
   have one yet, it is guessed heuristically.  If non-zero, MASK is an
   existing XImage object to use for the heuristic.  */

int
1249
image_background_transparent (struct image *img, struct frame *f, XImagePtr_or_DC mask)
1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274
{
  if (! img->background_transparent_valid)
    /* IMG doesn't have a background yet, try to guess a reasonable value.  */
    {
      if (img->mask)
	{
	  int free_mask = !mask;
#ifdef HAVE_NTGUI
	  HGDIOBJ prev;
#endif /* HAVE_NTGUI */

	  if (free_mask)
	    {
#ifndef HAVE_NTGUI
	      mask = XGetImage (FRAME_X_DISPLAY (f), img->mask,
				0, 0, img->width, img->height, ~0, ZPixmap);
#else
	      HDC frame_dc = get_frame_dc (f);
	      mask = CreateCompatibleDC (frame_dc);
	      release_frame_dc (f, frame_dc);
	      prev = SelectObject (mask, img->mask);
#endif /* HAVE_NTGUI */
	    }

	  img->background_transparent
1275
	    = (four_corners_best (mask, img->corners, img->width, img->height) == PIX_MASK_RETAIN);
1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291

	  if (free_mask)
	    Destroy_Image (mask, prev);
	}
      else
	img->background_transparent = 0;

      img->background_transparent_valid = 1;
    }

  return img->background_transparent;
}


/***********************************************************************
		  Helper functions for X image types
1292
 ***********************************************************************/
1293

1294 1295 1296 1297 1298 1299 1300
static void x_clear_image_1 (struct frame *, struct image *, int,
                             int, int);
static void x_clear_image (struct frame *f, struct image *img);
static unsigned long x_alloc_image_color (struct frame *f,
                                          struct image *img,
                                          Lisp_Object color_name,
                                          unsigned long dflt);
1301 1302 1303 1304 1305 1306 1307 1308


/* Clear X resources of image IMG on frame F.  PIXMAP_P non-zero means
   free the pixmap if any.  MASK_P non-zero means clear the mask
   pixmap if any.  COLORS_P non-zero means free colors allocated for
   the image, if any.  */

static void
1309 1310
x_clear_image_1 (struct frame *f, struct image *img, int pixmap_p, int mask_p,
		 int colors_p)
1311 1312 1313 1314 1315
{
  if (pixmap_p && img->pixmap)
    {
      Free_Pixmap (FRAME_X_DISPLAY (f), img->pixmap);
      img->pixmap = NO_PIXMAP;
1316
      /* NOTE (HAVE_NS): background color is NOT an indexed color! */
1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336
      img->background_valid = 0;
    }

  if (mask_p && img->mask)
    {
      Free_Pixmap (FRAME_X_DISPLAY (f), img->mask);
      img->mask = NO_PIXMAP;
      img->background_transparent_valid = 0;
    }

  if (colors_p && img->ncolors)
    {
      /* W32_TODO: color table support.  */
#ifdef HAVE_X_WINDOWS
      x_free_colors (f, img->colors, img->ncolors);
#endif /* HAVE_X_WINDOWS */
      xfree (img->colors);
      img->colors = NULL;
      img->ncolors = 0;
    }
1337

1338 1339 1340 1341 1342
}

/* Free X resources of image IMG which is used on frame F.  */

static void
1343
x_clear_image (struct frame *f, struct image *img)
1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356
{
  BLOCK_INPUT;
  x_clear_image_1 (f, img, 1, 1, 1);
  UNBLOCK_INPUT;
}


/* Allocate color COLOR_NAME for image IMG on frame F.  If color
   cannot be allocated, use DFLT.  Add a newly allocated color to
   IMG->colors, so that it can be freed again.  Value is the pixel
   color.  */

static unsigned long
1357 1358
x_alloc_image_color (struct frame *f, struct image *img, Lisp_Object color_name,
		     unsigned long dflt)
1359 1360 1361 1362 1363 1364
{
  XColor color;
  unsigned long result;

  xassert (STRINGP (color_name));

1365
  if (x_defined_color (f, SSDATA (color_name), &color, 1))
1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385
    {
      /* This isn't called frequently so we get away with simply
	 reallocating the color vector to the needed size, here.  */
      ++img->ncolors;
      img->colors =
	(unsigned long *) xrealloc (img->colors,
				    img->ncolors * sizeof *img->colors);
      img->colors[img->ncolors - 1] = color.pixel;
      result = color.pixel;
    }
  else
    result = dflt;

  return result;
}



/***********************************************************************
			     Image Cache
1386
 ***********************************************************************/
1387

1388 1389 1390
static struct image *search_image_cache (struct frame *, Lisp_Object, unsigned);
static void cache_image (struct frame *f, struct image *img);
static void postprocess_image (struct frame *, struct image *);
1391 1392 1393 1394 1395

/* Return a new, initialized image cache that is allocated from the
   heap.  Call free_image_cache to free an image cache.  */

struct image_cache *
1396
make_image_cache (void)
1397 1398 1399 1400
{
  struct image_cache *c = (struct image_cache *) xmalloc (sizeof *c);
  int size;

1401
  memset (c, 0, sizeof *c);
1402 1403 1404 1405
  c->size = 50;
  c->images = (struct image **) xmalloc (c->size * sizeof *c->images);
  size = IMAGE_CACHE_BUCKETS_SIZE * sizeof *c->buckets;
  c->buckets = (struct image **) xmalloc (size);
1406
  memset (c->buckets, 0, size);
1407 1408 1409 1410
  return c;
}


1411 1412 1413
/* Find an image matching SPEC in the cache, and return it.  If no
   image is found, return NULL.  */
static struct image *
1414
search_image_cache (struct frame *f, Lisp_Object spec, unsigned int hash)
Chong Yidong's avatar
Chong Yidong committed
1415
{
Chong Yidong's avatar
Chong Yidong committed
1416
  struct image *img;
1417
  struct image_cache *c = FRAME_IMAGE_CACHE (f);
Chong Yidong's avatar
Chong Yidong committed
1418 1419
  int i = hash % IMAGE_CACHE_BUCKETS_SIZE;

Chong Yidong's avatar
Chong Yidong committed
1420 1421
  if (!c) return NULL;

1422 1423
  /* If the image spec does not specify a background color, the cached
     image must have the same background color as the current frame.
1424 1425 1426 1427 1428 1429 1430 1431 1432
     The foreground color must also match, for the sake of monochrome
     images.

     In fact, we could ignore the foreground color matching condition
     for color images, or if the image spec specifies :foreground;
     similarly we could ignore the background color matching condition
     for formats that don't use transparency (such as jpeg), or if the
     image spec specifies :background.  However, the extra memory
     usage is probably negligible in practice, so we don't bother.  */
1433

Chong Yidong's avatar
Chong Yidong committed
1434
  for (img = c->buckets[i]; img; img = img->next)
1435 1436
    if (img->hash == hash
	&& !NILP (Fequal (img->spec, spec))
1437 1438
	&& img->frame_foreground == FRAME_FOREGROUND_PIXEL (f)
	&& img->frame_background == FRAME_BACKGROUND_PIXEL (f))
1439 1440 1441 1442 1443 1444 1445 1446
      break;
  return img;
}


/* Search frame F for an image with spec SPEC, and free it.  */

static void
1447
uncache_image (struct frame *f, Lisp_Object spec)
1448 1449 1450
{
  struct image *img = search_image_cache (f, spec, sxhash (spec, 0));
  if (img)
1451 1452 1453 1454 1455 1456
    {
      free_image (f, img);
      /* As display glyphs may still be referring to the image ID, we
	 must garbage the frame (Bug#6426).  */
      SET_FRAME_GARBAGED (f);
    }
Chong Yidong's avatar
Chong Yidong committed
1457 1458 1459
}


1460 1461 1462 1463
/* Free image cache of frame F.  Be aware that X frames share images
   caches.  */

void
1464
free_image_cache (struct frame *f)
1465
{
1466
  struct image_cache *c = FRAME_IMAGE_CACHE (f);
1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478
  if (c)
    {
      int i;

      /* Cache should not be referenced by any frame when freed.  */
      xassert (c->refcount == 0);

      for (i = 0; i < c->used; ++i)
	free_image (f, c->images[i]);
      xfree (c->images);
      xfree (c->buckets);
      xfree (c);
1479
      FRAME_IMAGE_CACHE (f) = NULL;
1480 1481 1482 1483
    }
}


1484 1485 1486 1487 1488 1489 1490
/* 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.  */
1491

1492
static void
1493
clear_image_cache (struct frame *f, Lisp_Object filter)
1494
{
1495
  struct image_cache *c = FRAME_IMAGE_CACHE (f);
1496

1497
  if (c)
1498
    {
1499
      int i, nfreed = 0;
1500 1501 1502 1503 1504

      /* Block input so that we won't be interrupted by a SIGIO
	 while being in an inconsistent state.  */
      BLOCK_INPUT;

1505
      if (!NILP (filter))
1506
	{
1507 1508
	  /* Filter image cache.  */
	  for (i = 0; i < c->used; ++i)
1509
	    {
1510 1511 1512 1513 1514 1515 1516 1517 1518 1519
	      struct image *img = c->images[i];
	      if (img && (EQ (Qt, filter)
			  || !NILP (Fmember (filter, img->dependencies))))
		{
		  free_image (f, img);
		  ++nfreed;
		}
	    }
	}
      else if (INTEGERP (Vimage_cache_eviction_delay))
1520
	{
1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539
	  /* Free cache based on timestamp.  */
	  EMACS_TIME t;
	  unsigned long old;
	  int delay, nimages = 0;

	  for (i = 0; i < c->used; ++i)
	    if (c->images[i])
	      nimages++;

	  /* If the number of cached images has grown unusually large,
	     decrease the cache eviction delay (Bug#6230).  */
	  delay = XFASTINT (Vimage_cache_eviction_delay);
	  if (nimages > 40)
	    delay = max (1, 1600 * delay / (nimages*nimages));

	  EMACS_GET_TIME (t);
	  old = EMACS_SECS (t) - delay;

	  for (i = 0; i < c->used; ++i)
1540
	    {
1541 1542 1543 1544 1545 1546
	      struct image *img = c->images[i];
	      if (img && img->timestamp < old)
		{
		  free_image (f, img);
		  ++nfreed;
		}
1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559
	    }
	}

      /* We may be clearing the image cache because, for example,
	 Emacs was iconified for a longer period of time.  In that
	 case, current matrices may still contain references to
	 images freed above.  So, clear these matrices.  */
      if (nfreed)
	{
	  Lisp_Object tail, frame;

	  FOR_EACH_FRAME (tail, frame)
	    {
1560 1561 1562
	      struct frame *fr = XFRAME (frame);
	      if (FRAME_IMAGE_CACHE (fr) == c)
		clear_current_matrices (fr);
1563 1564 1565 1566 1567 1568 1569 1570 1571
	    }

	  ++windows_or_buffers_changed;
	}

      UNBLOCK_INPUT;
    }
}

1572
void
1573
clear_image_caches (Lisp_Object filter)
1574 1575 1576 1577 1578 1579 1580 1581
{
  /* 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)))
1582
      clear_image_cache (XFRAME (frame), filter);
1583
}
1584 1585 1586

DEFUN ("clear-image-cache", Fclear_image_cache, Sclear_image_cache,
       0, 1, 0,
1587 1588 1589 1590 1591
       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.  */)
Dan Nicolaescu's avatar
Dan Nicolaescu committed
1592
  (Lisp_Object filter)
1593
{
1594 1595
  if (!(EQ (filter, Qnil) || FRAMEP (filter)))
    clear_image_caches (filter);
1596
  else
1597
    clear_image_cache (check_x_frame (filter), Qt);
1598 1599 1600 1601 1602

  return Qnil;
}