emacs: src/xfns.c comparison

comparison src/xfns.c @ 40264:04766dd416bb

(image_background, image_background_transparent) (four_corners_best): New functions. (xpm_format, png_format, jpeg_format, tiff_format, gif_format) (gs_format): Add `:background' entry. (lookup_image): Set IMG's background color if specified. (pbm_load, xbm_load_image, png_load): Set IMG's background field when appropriate. (x_clear_image_1): Reset `background_valid' and `background_transparent_valid' fields. (x_build_heuristic_mask): Use IMAGE_BACKGROUND instead of calculating it here. Set IMG's background_transparent field. (enum xpm_keyword_index): Add XPM_BACKGROUND. (enum png_keyword_index): Add PNG_BACKGROUND. (enum jpeg_keyword_index): Add JPEG_BACKGROUND. (enum tiff_keyword_index): Add TIFF_BACKGROUND. (enum gif_keyword_index): Add GIF_BACKGROUND. (enum gs_keyword_index): Add GS_BACKGROUND. (pbm_load, png_load, jpeg_load, tiff_load, gif_load): Pre-calculate image background color where necessary.

author	Miles Bader <miles@gnu.org>
date	Wed, 24 Oct 2001 17:57:28 +0000
parents	2ee3c7f9fb40
children	1adbc1480e83

comparison

equal deleted inserted replaced

-:3657a6c97b2f
+:04766dd416bb
 ascent = height * img->ascent / 100.0;
 return ascent;
 }
+/* Image background colors.  */
+static unsigned long
+four_corners_best (ximg, width, height)
+XImage *ximg;
+unsigned long width, height;
+{
+unsigned long corners[4], best;
+int i, best_count;
+/* Get the colors at the corners of ximg.  */
+corners[0] = XGetPixel (ximg, 0, 0);
+corners[1] = XGetPixel (ximg, width - 1, 0);
+corners[2] = XGetPixel (ximg, width - 1, height - 1);
+corners[3] = XGetPixel (ximg, 0, height - 1);
+/* 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)
+	    if (corners[i] == corners[j])
+	      ++n;
+	  if (n > best_count)
+	    best = corners[i], best_count = n;
+	}
+return best;
+}
+/* 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 to use for the heuristic.  */
+unsigned long
+image_background (img, f, ximg)
+struct image *img;
+struct frame *f;
+XImage *ximg;
+{
+if (! img->background_valid)
+/* IMG doesn't have a background yet, try to guess a reasonable value.  */
+{
+int free_ximg = !ximg;
+if (! ximg)
+	ximg = XGetImage (FRAME_X_DISPLAY (f), img->pixmap,
+			  0, 0, img->width, img->height, ~0, ZPixmap);
+img->background = four_corners_best (ximg, img->width, img->height);
+if (free_ximg)
+	XDestroyImage (ximg);
+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
+image_background_transparent (img, f, mask)
+struct image *img;
+struct frame *f;
+XImage *mask;
+{
+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;
+	  if (! mask)
+	    mask = XGetImage (FRAME_X_DISPLAY (f), img->mask,
+			      0, 0, img->width, img->height, ~0, ZPixmap);
+	  img->background_transparent
+	    = !four_corners_best (mask, img->width, img->height);
+	  if (free_mask)
+	    XDestroyImage (mask);
+	}
+else
+	img->background_transparent = 0;
+img->background_transparent_valid = 1;
+}
+return img->background_transparent;
+}
 /***********************************************************************
 		  Helper functions for X image types
 ***********************************************************************/
 {
 if (pixmap_p && img->pixmap)
 {
 XFreePixmap (FRAME_X_DISPLAY (f), img->pixmap);
 img->pixmap = None;
+img->background_valid = 0;
 }
 if (mask_p && img->mask)
 {
 XFreePixmap (FRAME_X_DISPLAY (f), img->mask);
 img->mask = None;
+img->background_transparent_valid = 0;
 }
 if (colors_p && img->ncolors)
 {
 x_free_colors (f, img->colors, img->ncolors);
 			 ? XFASTINT (value) : DEFAULT_IMAGE_HEIGHT);
 	}
 else
 	{
 	  /* Handle image type independent image attributes
-	     `:ascent ASCENT', `:margin MARGIN', `:relief RELIEF'.  */
+	     `:ascent ASCENT', `:margin MARGIN', `:relief RELIEF',
-	  Lisp_Object ascent, margin, relief;
+	     `:background COLOR'.  */
+	  Lisp_Object ascent, margin, relief, bg;
 	  ascent = image_spec_value (spec, QCascent, NULL);
 	  if (INTEGERP (ascent))
 	    img->ascent = XFASTINT (ascent);
 	  else if (EQ (ascent, Qcenter))
 	  if (INTEGERP (relief))
 	    {
 	      img->relief = XINT (relief);
 	      img->hmargin += abs (img->relief);
 	      img->vmargin += abs (img->relief);
+	    }
+	  if (! img->background_valid)
+	    {
+	      bg = image_spec_value (img->spec, QCbackground, NULL);
+	      if (!NILP (bg))
+		{
+		  img->background
+		    = x_alloc_image_color (f, img, bg,
+					   FRAME_BACKGROUND_PIXEL (f));
+		  img->background_valid = 1;
+		}
 	    }
 	  /* Do image transformations and compute masks, unless we
 	     don't have the image yet.  */
 	  if (!EQ (*img->type->type, Qpostscript))
 /* Get foreground and background colors, maybe allocate colors.  */
 value = image_spec_value (img->spec, QCforeground, NULL);
 if (!NILP (value))
 	foreground = x_alloc_image_color (f, img, value, foreground);
 value = image_spec_value (img->spec, QCbackground, NULL);
 if (!NILP (value))
-	background = x_alloc_image_color (f, img, value, background);
+	{
+	  background = x_alloc_image_color (f, img, value, background);
+	  img->background = background;
+	  img->background_valid = 1;
+	}
 img->pixmap
 	= XCreatePixmapFromBitmapData (FRAME_X_DISPLAY (f),
 				       FRAME_X_WINDOW (f),
 				       data,
 XPM_RELIEF,
 XPM_ALGORITHM,
 XPM_HEURISTIC_MASK,
 XPM_MASK,
 XPM_COLOR_SYMBOLS,
+XPM_BACKGROUND,
 XPM_LAST
 };
 /* Vector of image_keyword structures describing the format
 of valid XPM image specifications.  */
 {":margin",		IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR,	0},
 {":relief",		IMAGE_INTEGER_VALUE,			0},
 {":conversion",	IMAGE_DONT_CHECK_VALUE_TYPE,		0},
 {":heuristic-mask",	IMAGE_DONT_CHECK_VALUE_TYPE,		0},
 {":mask",		IMAGE_DONT_CHECK_VALUE_TYPE,		0},
-{":color-symbols",	IMAGE_DONT_CHECK_VALUE_TYPE,		0}
+{":color-symbols",	IMAGE_DONT_CHECK_VALUE_TYPE,		0},
+{":background",	IMAGE_STRING_OR_NIL_VALUE,		0}
 };
 /* Structure describing the image type XBM.  */
 static struct image_type xpm_type =
 struct image *img;
 Lisp_Object how;
 {
 Display *dpy = FRAME_X_DISPLAY (f);
 XImage *ximg, *mask_img;
-int x, y, rc, look_at_corners_p;
+int x, y, rc, use_img_background;
 unsigned long bg = 0;
 if (img->mask)
 {
 XFreePixmap (FRAME_X_DISPLAY (f), img->mask);
 img->mask = None;
+img->background_transparent_valid = 0;
 }
 /* Create an image and pixmap serving as mask.  */
 rc = x_create_x_image_and_pixmap (f, img->width, img->height, 1,
 				    &mask_img, &img->mask);
 /* Get the X image of IMG->pixmap.  */
 ximg = XGetImage (dpy, img->pixmap, 0, 0, img->width, img->height,
 		    ~0, ZPixmap);
 /* Determine the background color of ximg.  If HOW is `(R G B)'
-take that as color.  Otherwise, try to determine the color
+take that as color.  Otherwise, use the image's background color. */
-heuristically. */
+use_img_background = 1;
-look_at_corners_p = 1;
 if (CONSP (how))
 {
 int rgb[3], i = 0;
 	  cmap = FRAME_X_COLORMAP (f);
 	  if (XLookupColor (dpy, cmap, color_name, &exact, &color))
 	    {
 	      bg = color.pixel;
-	      look_at_corners_p = 0;
+	      use_img_background = 0;
 	    }
 	}
 }
-if (look_at_corners_p)
+if (use_img_background)
-{
+bg = IMAGE_BACKGROUND (img, f, ximg);
-unsigned long corners[4];
-int i, best_count;
-/* Get the colors at the corners of ximg.  */
-corners[0] = XGetPixel (ximg, 0, 0);
-corners[1] = XGetPixel (ximg, img->width - 1, 0);
-corners[2] = XGetPixel (ximg, img->width - 1, img->height - 1);
-corners[3] = XGetPixel (ximg, 0, img->height - 1);
-/* 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)
-	    if (corners[i] == corners[j])
-	      ++n;
-	  if (n > best_count)
-	    bg = corners[i], best_count = n;
-	}
-}
 /* Set all bits in mask_img to 1 whose color in ximg is different
 from the background color bg.  */
 for (y = 0; y < img->height; ++y)
 for (x = 0; x < img->width; ++x)
 XPutPixel (mask_img, x, y, XGetPixel (ximg, x, y) != bg);
+/* Fill in the background_transparent field while we have the mask handy. */
+image_background_transparent (img, f, mask_img);
 /* Put mask_img into img->mask.  */
 x_put_x_image (f, mask_img, img->mask, img->width, img->height);
 x_destroy_x_image (mask_img);
 XDestroyImage (ximg);
 if (fmt[PBM_FOREGROUND].count
 	  && STRINGP (fmt[PBM_FOREGROUND].value))
 	fg = x_alloc_image_color (f, img, fmt[PBM_FOREGROUND].value, fg);
 if (fmt[PBM_BACKGROUND].count
 	  && STRINGP (fmt[PBM_BACKGROUND].value))
-	bg = x_alloc_image_color (f, img, fmt[PBM_BACKGROUND].value, bg);
+	{
+	  bg = x_alloc_image_color (f, img, fmt[PBM_BACKGROUND].value, bg);
+	  img->background = bg;
+	  img->background_valid = 1;
+	}
 for (y = 0; y < height; ++y)
 	for (x = 0; x < width; ++x)
 	  {
 	    if (raw_p)
 /* Store in IMG->colors the colors allocated for the image, and
 free the color table.  */
 img->colors = colors_in_color_table (&img->ncolors);
 free_color_table ();
+/* Maybe fill in the background field while we have ximg handy. */
+if (NILP (image_spec_value (img->spec, QCbackground, NULL)))
+IMAGE_BACKGROUND (img, f, ximg);
 /* Put the image into a pixmap.  */
 x_put_x_image (f, ximg, img->pixmap, width, height);
 x_destroy_x_image (ximg);
 PNG_MARGIN,
 PNG_RELIEF,
 PNG_ALGORITHM,
 PNG_HEURISTIC_MASK,
 PNG_MASK,
+PNG_BACKGROUND,
 PNG_LAST
 };
 /* Vector of image_keyword structures describing the format
 of valid user-defined image specifications.  */
 {":margin",		IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR,	0},
 {":relief",		IMAGE_INTEGER_VALUE,			0},
 {":conversion",	IMAGE_DONT_CHECK_VALUE_TYPE,		0},
 {":heuristic-mask",	IMAGE_DONT_CHECK_VALUE_TYPE,		0},
 {":mask",		IMAGE_DONT_CHECK_VALUE_TYPE,		0}
+{":background",	IMAGE_STRING_OR_NIL_VALUE,		0}
 };
 /* Structure describing the image type `png'.  */
 static struct image_type png_type =
 /* Handle alpha channel by combining the image with a background
 color.  Do this only if a real alpha channel is supplied.  For
 simple transparency, we prefer a clipping mask.  */
 if (!transparent_p)
 {
-png_color_16 *image_background;
+png_color_16 *image_bg;
+Lisp_Object specified_bg
-if (png_get_bKGD (png_ptr, info_ptr, &image_background))
+	= image_spec_value (img->spec, QCbackground, NULL);
+if (! NILP (specified_bg))
+	/* The user specified `:background', use that.  */
+	{
+	  XColor color;
+	  if (x_defined_color (f, specified_bg, &color, 0))
+	    {
+	      png_color_16 user_bg;
+	      bzero (&user_bg, sizeof user_bg);
+	      user_bg.red = color.red;
+	      user_bg.green = color.green;
+	      user_bg.blue = color.blue;
+	      png_set_background (png_ptr, &user_bg,
+				  PNG_BACKGROUND_GAMMA_SCREEN, 0, 1.0);
+	    }
+	}
+else if (png_get_bKGD (png_ptr, info_ptr, &image_bg))
 	/* Image contains a background color with which to
 	   combine the image.  */
-	png_set_background (png_ptr, image_background,
+	png_set_background (png_ptr, image_bg,
 			    PNG_BACKGROUND_GAMMA_FILE, 1, 1.0);
 else
 	{
 	  /* Image does not contain a background color with which
 	     to combine the image data via an alpha channel.  Use
 	      ++p;
 	    }
 	}
 }
+if (NILP (image_spec_value (img->spec, QCbackground, NULL)))
+/* Set IMG's background color from the PNG image, unless the user
+overrode it.  */
+{
+png_color_16 *bg;
+if (png_get_bKGD (png_ptr, info_ptr, &bg))
+	{
+	  img->background = lookup_rgb_color (f, bg.red, bg.green, bg.blue);
+	  img->background_valid = 1;
+	}
+}
 /* Remember colors allocated for this image.  */
 img->colors = colors_in_color_table (&img->ncolors);
 free_color_table ();
 /* Clean up.  */
 xfree (pixels);
 img->width = width;
 img->height = height;
+/* Maybe fill in the background field while we have ximg handy. */
+IMAGE_BACKGROUND (img, f, ximg);
 /* Put the image into the pixmap, then free the X image and its buffer.  */
 x_put_x_image (f, ximg, img->pixmap, width, height);
 x_destroy_x_image (ximg);
 /* Same for the mask.  */
 if (mask_img)
 {
+/* Fill in the background_transparent field while we have the mask
+	 handy. */
+image_background_transparent (img, f, mask_img);
 x_put_x_image (f, mask_img, img->mask, img->width, img->height);
 x_destroy_x_image (mask_img);
 }
 UNGCPRO;
 JPEG_MARGIN,
 JPEG_RELIEF,
 JPEG_ALGORITHM,
 JPEG_HEURISTIC_MASK,
 JPEG_MASK,
+JPEG_BACKGROUND,
 JPEG_LAST
 };
 /* Vector of image_keyword structures describing the format
 of valid user-defined image specifications.  */
 {":ascent",		IMAGE_ASCENT_VALUE,			0},
 {":margin",		IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR,	0},
 {":relief",		IMAGE_INTEGER_VALUE,			0},
 {":conversions",	IMAGE_DONT_CHECK_VALUE_TYPE,		0},
 {":heuristic-mask",	IMAGE_DONT_CHECK_VALUE_TYPE,		0},
-{":mask",		IMAGE_DONT_CHECK_VALUE_TYPE,		0}
+{":mask",		IMAGE_DONT_CHECK_VALUE_TYPE,		0},
+{":background",	IMAGE_STRING_OR_NIL_VALUE,		0}
 };
 /* Structure describing the image type `jpeg'.  */
 static struct image_type jpeg_type =
 /* Clean up.  */
 jpeg_finish_decompress (&cinfo);
 jpeg_destroy_decompress (&cinfo);
 if (fp)
 fclose ((FILE *) fp);
+/* Maybe fill in the background field while we have ximg handy. */
+if (NILP (image_spec_value (img->spec, QCbackground, NULL)))
+IMAGE_BACKGROUND (img, f, ximg);
 /* Put the image into the pixmap.  */
 x_put_x_image (f, ximg, img->pixmap, width, height);
 x_destroy_x_image (ximg);
 UNGCPRO;
 TIFF_MARGIN,
 TIFF_RELIEF,
 TIFF_ALGORITHM,
 TIFF_HEURISTIC_MASK,
 TIFF_MASK,
+TIFF_BACKGROUND,
 TIFF_LAST
 };
 /* Vector of image_keyword structures describing the format
 of valid user-defined image specifications.  */
 {":ascent",		IMAGE_ASCENT_VALUE,			0},
 {":margin",		IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR,	0},
 {":relief",		IMAGE_INTEGER_VALUE,			0},
 {":conversions",	IMAGE_DONT_CHECK_VALUE_TYPE,		0},
 {":heuristic-mask",	IMAGE_DONT_CHECK_VALUE_TYPE,		0},
-{":mask",		IMAGE_DONT_CHECK_VALUE_TYPE,		0}
+{":mask",		IMAGE_DONT_CHECK_VALUE_TYPE,		0},
+{":background",	IMAGE_STRING_OR_NIL_VALUE,		0}
 };
 /* Structure describing the image type `tiff'.  */
 static struct image_type tiff_type =
 }
 /* Remember the colors allocated for the image.  Free the color table.  */
 img->colors = colors_in_color_table (&img->ncolors);
 free_color_table ();
+img->width = width;
+img->height = height;
+/* Maybe fill in the background field while we have ximg handy. */
+if (NILP (image_spec_value (img->spec, QCbackground, NULL)))
+IMAGE_BACKGROUND (img, f, ximg);
 /* Put the image into the pixmap, then free the X image and its buffer.  */
 x_put_x_image (f, ximg, img->pixmap, width, height);
 x_destroy_x_image (ximg);
 xfree (buf);
-img->width = width;
-img->height = height;
 UNGCPRO;
 return 1;
 }
 GIF_RELIEF,
 GIF_ALGORITHM,
 GIF_HEURISTIC_MASK,
 GIF_MASK,
 GIF_IMAGE,
+GIF_BACKGROUND,
 GIF_LAST
 };
 /* Vector of image_keyword structures describing the format
 of valid user-defined image specifications.  */
 {":relief",		IMAGE_INTEGER_VALUE,			0},
 {":conversion",	IMAGE_DONT_CHECK_VALUE_TYPE,		0},
 {":heuristic-mask",	IMAGE_DONT_CHECK_VALUE_TYPE,		0},
 {":mask",		IMAGE_DONT_CHECK_VALUE_TYPE,		0},
 {":image",		IMAGE_NON_NEGATIVE_INTEGER_VALUE,	0}
+{":background",	IMAGE_STRING_OR_NIL_VALUE,		0}
 };
 /* Structure describing the image type `gif'.  */
 static struct image_type gif_type =
 	    XPutPixel (ximg, x + image_left, y + image_top, pixel_colors[i]);
 	  }
 }
 DGifCloseFile (gif);
+/* Maybe fill in the background field while we have ximg handy. */
+if (NILP (image_spec_value (img->spec, QCbackground, NULL)))
+IMAGE_BACKGROUND (img, f, ximg);
 /* Put the image into the pixmap, then free the X image and its buffer.  */
 x_put_x_image (f, ximg, img->pixmap, width, height);
 x_destroy_x_image (ximg);
 GS_MARGIN,
 GS_RELIEF,
 GS_ALGORITHM,
 GS_HEURISTIC_MASK,
 GS_MASK,
+GS_BACKGROUND,
 GS_LAST
 };
 /* Vector of image_keyword structures describing the format
 of valid user-defined image specifications.  */
 {":ascent",		IMAGE_ASCENT_VALUE,			0},
 {":margin",		IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR,	0},
 {":relief",		IMAGE_INTEGER_VALUE,			0},
 {":conversion",	IMAGE_DONT_CHECK_VALUE_TYPE,		0},
 {":heuristic-mask",	IMAGE_DONT_CHECK_VALUE_TYPE,		0},
-{":mask",		IMAGE_DONT_CHECK_VALUE_TYPE,		0}
+{":mask",		IMAGE_DONT_CHECK_VALUE_TYPE,		0},
+{":background",	IMAGE_STRING_OR_NIL_VALUE,		0}
 };
 /* Structure describing the image type `ghostscript'.  */
 static struct image_type gs_type =

Mercurial > emacs

comparison src/xfns.c @ 40264:04766dd416bb