xemacs-beta: src/glyphs-x.c comparison

comparison src/glyphs-x.c @ 269:b2472a1930f2 r20-5b33

Import from CVS: tag r20-5b33

author	cvs
date	Mon, 13 Aug 2007 10:27:19 +0200
parents	966663fcf606
children	c5d627a313b1

comparison

equal deleted inserted replaced

-:6ced69ccd85f
+:b2472a1930f2
 /************************************************************************/
 /*                      image instance methods                          */
 /************************************************************************/
+DOESNT_RETURN
+signal_image_error(CONST char *reason, Lisp_Object frob)
+{
+signal_error (Qimage_conversion_error, list2 (build_translated_string (reason), frob));
+}
+DOESNT_RETURN
+signal_image_error_2 (CONST char *reason,
+Lisp_Object frob0, Lisp_Object frob1)
+{
+signal_error (Qimage_conversion_error, list3 (build_translated_string (reason), frob0,
+			       frob1));
+}
 /************************************************************************/
 /* convert from a series of RGB triples to an XImage formated for the   */
 /* proper display 							*/
 /************************************************************************/
-XImage *EImage2XImage(Lisp_Object device, int width, int height, unsigned char *pic,
+XImage *
-		      unsigned long **pixtbl, int *pixcount, int *npixels)
+convert_EImage_to_XImage(Lisp_Object device, int width, int height, unsigned char *pic,
+	      unsigned long **pixtbl, int *pixcount, int *npixels)
 {
 Display *dpy;
 Colormap cmap;
 Visual *vis;
 XImage *outimg;
 dpy = DEVICE_X_DISPLAY (XDEVICE (device));
 cmap = DEVICE_X_COLORMAP (XDEVICE(device));
 vis = DEVICE_X_VISUAL (XDEVICE(device));
 depth = DEVICE_X_DEPTH(XDEVICE(device));
-if (vis->class == PseudoColor) {
+if (vis->class == PseudoColor)
-/* Quantize the image and get a histogram while we're at it.
+{
-Do this first to save memory */
+/* Quantize the image and get a histogram while we're at it.
-qtable = EImage_build_quantable(pic, width, height, 256);
+	 Do this first to save memory */
-if (qtable == NULL) return NULL;
+qtable = build_EImage_quantable(pic, width, height, 256);
-}
+if (qtable == NULL) return NULL;
+}
 bitmap_pad = ((depth > 16) ? 32 :
 		(depth >  8) ? 16 :
 		8);
 byte_cnt = bitmap_pad >> 3;
 			 depth, ZPixmap, 0, 0, width, height,
 			 bitmap_pad, 0);
 if (!outimg) return NULL;
 data = (unsigned char *) xmalloc (outimg->bytes_per_line * height);
-if (!data) {
+if (!data)
-XDestroyImage(outimg);
+{
-return NULL;
+XDestroyImage(outimg);
-}
+return NULL;
+}
 outimg->data = data;
-if (vis->class == PseudoColor) {
+if (vis->class == PseudoColor)
-unsigned long pixarray[256];
+{
-int n;
+unsigned long pixarray[256];
-/* use our quantize table to allocate the colors */
+int n;
-*pixcount = 32;
+/* use our quantize table to allocate the colors */
-*pixtbl = xnew_array (unsigned long, *pixcount);
+*pixcount = 32;
-*npixels = 0;
+*pixtbl = xnew_array (unsigned long, *pixcount);
+*npixels = 0;
-/* ### should implement a sort by popularity to assure proper allocation */
-n = *npixels;
+/* ### should implement a sort by popularity to assure proper allocation */
-for (i = 0; i < qtable->num_active_colors; i++) {
+n = *npixels;
-	XColor color;
+for (i = 0; i < qtable->num_active_colors; i++)
-	int res;
+	{
+	  XColor color;
+	  int res;
-	color.red = qtable->rm[i] ? qtable->rm[i] << 8 : 0;
+	  color.red = qtable->rm[i] ? qtable->rm[i] << 8 : 0;
-	color.green = qtable->gm[i] ? qtable->gm[i] << 8 : 0;
+	  color.green = qtable->gm[i] ? qtable->gm[i] << 8 : 0;
-	color.blue = qtable->bm[i] ? qtable->bm[i] << 8 : 0;
+	  color.blue = qtable->bm[i] ? qtable->bm[i] << 8 : 0;
-	color.flags = DoRed | DoGreen | DoBlue;
+	  color.flags = DoRed | DoGreen | DoBlue;
-	res = allocate_nearest_color (dpy, cmap, vis, &color);
+	  res = allocate_nearest_color (dpy, cmap, vis, &color);
-	if (res > 0 && res < 3)
+	  if (res > 0 && res < 3)
-	  {
+	    {
-	    DO_REALLOC(*pixtbl, *pixcount, n+1, unsigned long);
+	      DO_REALLOC(*pixtbl, *pixcount, n+1, unsigned long);
-	    (*pixtbl)[n] = color.pixel;
+	      (*pixtbl)[n] = color.pixel;
-	    n++;
+	      n++;
-	  }
+	    }
-	pixarray[i] = color.pixel;
+	  pixarray[i] = color.pixel;
-}
+	}
 *npixels = n;
 ip = pic;
-for (i = 0; i < height; i++) {
+for (i = 0; i < height; i++)
-dp = data + (i * outimg->bytes_per_line);
+	{
-for (j = 0; j < width; j++) {
+	  dp = data + (i * outimg->bytes_per_line);
-	rd = *ip++;
+	  for (j = 0; j < width; j++)
-	gr = *ip++;
+	    {
-	bl = *ip++;
+	      rd = *ip++;
-	conv.val = pixarray[QUANT_GET_COLOR(qtable,rd,gr,bl)];
+	      gr = *ip++;
+	      bl = *ip++;
+	      conv.val = pixarray[QUANT_GET_COLOR(qtable,rd,gr,bl)];
 #ifdef WORDS_BIGENDIAN
-	for (q = 4-byte_cnt; q < 4; q++) *dp++ = conv.cp[q];
+	      for (q = 4-byte_cnt; q < 4; q++) *dp++ = conv.cp[q];
 #else
-	for (q = 0; q < byte_cnt; q++) *dp++ = conv.cp[q];
+	      for (q = 0; q < byte_cnt; q++) *dp++ = conv.cp[q];
 #endif
-}
+	    }
-}
+	}
 xfree(qtable);
 } else {
 unsigned long rshift,gshift,bshift,rbits,gbits,bbits,junk;
 junk = vis->red_mask;
 rshift = 0;
-while ((junk & 0x1) == 0) {
+while ((junk & 0x1) == 0)
-junk = junk >> 1;
+	{
-rshift ++;
+	  junk = junk >> 1;
-}
+	  rshift ++;
-rbits = 0;
+	}
-while (junk != 0) {
+rbits = 0;
-junk = junk >> 1;
+while (junk != 0)
-rbits++;
+	{
-}
+	  junk = junk >> 1;
-junk = vis->green_mask;
+	  rbits++;
-gshift = 0;
+	}
-while ((junk & 0x1) == 0) {
+junk = vis->green_mask;
-junk = junk >> 1;
+gshift = 0;
-gshift ++;
+while ((junk & 0x1) == 0)
-}
+	{
-gbits = 0;
+	  junk = junk >> 1;
-while (junk != 0) {
+	  gshift ++;
-junk = junk >> 1;
+	}
-gbits++;
+gbits = 0;
-}
+while (junk != 0)
-junk = vis->blue_mask;
+	{
-bshift = 0;
+	  junk = junk >> 1;
-while ((junk & 0x1) == 0) {
+	  gbits++;
-junk = junk >> 1;
+	}
-bshift ++;
+junk = vis->blue_mask;
-}
+bshift = 0;
-bbits = 0;
+while ((junk & 0x1) == 0)
-while (junk != 0) {
+	{
-junk = junk >> 1;
+	  junk = junk >> 1;
-bbits++;
+	  bshift ++;
-}
+	}
-ip = pic;
+bbits = 0;
-for (i = 0; i < height; i++) {
+while (junk != 0)
-dp = data + (i * outimg->bytes_per_line);
+	{
-for (j = 0; j < width; j++) {
+	  junk = junk >> 1;
-	if (rbits > 8)
+	  bbits++;
-	  rd = *ip++ << (rbits - 8);
+	}
-	else
+ip = pic;
-	  rd = *ip++ >> (8 - rbits);
+for (i = 0; i < height; i++)
-	if (gbits > 8)
+	{
-	  gr = *ip++ << (gbits - 8);
+	  dp = data + (i * outimg->bytes_per_line);
-	else
+	  for (j = 0; j < width; j++)
-	  gr = *ip++ >> (8 - gbits);
+	    {
-	if (bbits > 8)
+	      if (rbits > 8)
-	  bl = *ip++ << (bbits - 8);
+		rd = *ip++ << (rbits - 8);
-	else
+	      else
-	  bl = *ip++ >> (8 - bbits);
+		rd = *ip++ >> (8 - rbits);
+	      if (gbits > 8)
-	conv.val = (rd << rshift) | (gr << gshift) | (bl << bshift);
+		gr = *ip++ << (gbits - 8);
+	      else
+		gr = *ip++ >> (8 - gbits);
+	      if (bbits > 8)
+		bl = *ip++ << (bbits - 8);
+	      else
+		bl = *ip++ >> (8 - bbits);
+	      conv.val = (rd << rshift) | (gr << gshift) | (bl << bshift);
 #ifdef WORDS_BIGENDIAN
-	for (q = 4-byte_cnt; q < 4; q++) *dp++ = conv.cp[q];
+	      for (q = 4-byte_cnt; q < 4; q++) *dp++ = conv.cp[q];
 #else
-	for (q = 0; q < byte_cnt; q++) *dp++ = conv.cp[q];
+	      for (q = 0; q < byte_cnt; q++) *dp++ = conv.cp[q];
 #endif
-}
+	    }
-}
+	}
 }
 return outimg;
 }
 	}
 if (IMAGE_INSTANCE_X_NPIXELS (p) != 0)
 	{
 	  XFreeColors (dpy,
-		       DEVICE_X_COLORMAP (XDEVICE(p->device)),
+		       IMAGE_INSTANCE_X_COLORMAP (p),
 		       IMAGE_INSTANCE_X_PIXELS (p),
 		       IMAGE_INSTANCE_X_NPIXELS (p), 0);
 	  IMAGE_INSTANCE_X_NPIXELS (p) = 0;
 	}
 }
 switch (IMAGE_INSTANCE_TYPE (p1))
 {
 case IMAGE_MONO_PIXMAP:
 case IMAGE_COLOR_PIXMAP:
 case IMAGE_POINTER:
-if (IMAGE_INSTANCE_X_NPIXELS (p1) != IMAGE_INSTANCE_X_NPIXELS (p2))
+if (IMAGE_INSTANCE_X_COLORMAP (p1) != IMAGE_INSTANCE_X_COLORMAP (p2) ||
+	  IMAGE_INSTANCE_X_NPIXELS (p1) != IMAGE_INSTANCE_X_NPIXELS (p2))
 	return 0;
 #if HAVE_SUBWINDOWS
 case IMAGE_SUBWINDOW:
 /* #### implement me */
 #endif
 #else
 GCPRO2 (instream, outstream);
 #endif
 /* Get the data while doing the conversion */
-while (1) {
+while (1)
-int size_in_bytes = Lstream_read (istr, tempbuf, sizeof (tempbuf));
+{
-if (!size_in_bytes)
+int size_in_bytes = Lstream_read (istr, tempbuf, sizeof (tempbuf));
-break;
+if (!size_in_bytes)
-/* It does seem the flushes are necessary... */
+	break;
+/* It does seem the flushes are necessary... */
 #ifdef FILE_CODING
 Lstream_write (costr, tempbuf, size_in_bytes);
 Lstream_flush (costr);
 #else
 Lstream_write (ostr, tempbuf, size_in_bytes);
 #endif
 Lstream_flush (ostr);
 if (fwrite ((unsigned char *)Dynarr_atp(conversion_out_dynarr, 0),
-		Dynarr_length(conversion_out_dynarr), 1, tmpfil) != 1)
+		  Dynarr_length(conversion_out_dynarr), 1, tmpfil) != 1)
-{
+	{
-	fubar = 1;
+	  fubar = 1;
-	break;
+	  break;
-}
+	}
 /* reset the dynarr */
 Lstream_rewind(ostr);
 }
 if (fclose (tmpfil) != 0)
 fubar = 1;
 Lstream_close (istr);
 #ifdef FILE_CODING
 static void
 init_image_instance_from_x_image (struct Lisp_Image_Instance *ii,
 				  XImage *ximage,
 				  int dest_mask,
+				  Colormap cmap,
 				  unsigned long *pixels,
 				  int npixels,
 				  Lisp_Object instantiator)
 {
 Lisp_Object device = IMAGE_INSTANCE_DEVICE (ii);
 IMAGE_INSTANCE_X_PIXMAP (ii) = pixmap;
 IMAGE_INSTANCE_X_MASK (ii) = 0;
 IMAGE_INSTANCE_PIXMAP_WIDTH (ii) = ximage->width;
 IMAGE_INSTANCE_PIXMAP_HEIGHT (ii) = ximage->height;
 IMAGE_INSTANCE_PIXMAP_DEPTH (ii) = ximage->depth;
+IMAGE_INSTANCE_X_COLORMAP (ii) = cmap;
 IMAGE_INSTANCE_X_PIXELS (ii) = pixels;
 IMAGE_INSTANCE_X_NPIXELS (ii) = npixels;
 }
 struct Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
 Pixmap mask = 0;
 CONST char *gcc_may_you_rot_in_hell;
 if (!NILP (mask_data))
 {
 GET_C_STRING_BINARY_DATA_ALLOCA (XCAR (XCDR (XCDR (mask_data))),
 				       gcc_may_you_rot_in_hell);
 mask =
 	pixmap_from_xbm_inline (IMAGE_INSTANCE_DEVICE (ii),
 				XINT (XCAR (mask_data)),
 {
 case XpmFileInvalid:
 {
 	if (ok_if_data_invalid)
 	  return Qt;
-	signal_simple_error ("invalid XPM data in file", name);
+	signal_image_error ("invalid XPM data in file", name);
 }
 case XpmNoMemory:
 {
 	signal_double_file_error ("Reading pixmap file",
 				  "out of memory", name);
 incompatible_image_types (instantiator, dest_mask,
 			      IMAGE_MONO_PIXMAP_MASK | IMAGE_COLOR_PIXMAP_MASK
 			      | IMAGE_POINTER_MASK);
 force_mono = (type != IMAGE_COLOR_PIXMAP);
-#if 0
+#if 1
 /* Although I haven't found it documented yet, it appears that pointers are
 always colored via the default window colormap... Sigh.  However, with
 the current color structure, this will blow the doors off as things aren't set up
 to differenciate between two colormaps per console.  AARGH! */
 if (type == IMAGE_POINTER)
 case XpmSuccess:
 break;
 case XpmFileInvalid:
 {
 	xpm_free (&xpmattrs);
-	signal_simple_error ("invalid XPM data", data);
+	signal_image_error ("invalid XPM data", data);
 }
 case XpmColorFailed:
 case XpmColorError:
 {
 	xpm_free (&xpmattrs);
 else
 pixels = NULL;
 IMAGE_INSTANCE_X_PIXMAP (ii) = pixmap;
 IMAGE_INSTANCE_X_MASK (ii) = mask;
+IMAGE_INSTANCE_X_COLORMAP (ii) = cmap;
 IMAGE_INSTANCE_X_PIXELS (ii) = pixels;
 IMAGE_INSTANCE_X_NPIXELS (ii) = npixels;
 IMAGE_INSTANCE_PIXMAP_WIDTH (ii) = w;
 IMAGE_INSTANCE_PIXMAP_HEIGHT (ii) = h;
 IMAGE_INSTANCE_PIXMAP_FILENAME (ii) =
 #if defined(JPEG_LIB_VERSION) && (JPEG_LIB_VERSION >= 61)
 METHODDEF(void)
 #else
 METHODDEF void
 #endif
-our_init_source (j_decompress_ptr cinfo) {
+our_init_source (j_decompress_ptr cinfo)
+{
 }
 #if defined(JPEG_LIB_VERSION) && (JPEG_LIB_VERSION >= 61)
 METHODDEF(boolean)
 #else
 METHODDEF boolean
 #endif
-our_fill_input_buffer (j_decompress_ptr cinfo) {
+our_fill_input_buffer (j_decompress_ptr cinfo)
+{
 /* Insert a fake EOI marker */
 struct jpeg_source_mgr *src = (struct jpeg_source_mgr *) cinfo->src;
 static JOCTET buffer[2];
 buffer[0] = (JOCTET) 0xFF;
 #if defined(JPEG_LIB_VERSION) && (JPEG_LIB_VERSION >= 61)
 METHODDEF(void)
 #else
 METHODDEF void
 #endif
-our_skip_input_data (j_decompress_ptr cinfo, long num_bytes) {
+our_skip_input_data (j_decompress_ptr cinfo, long num_bytes)
+{
 struct jpeg_source_mgr *src = NULL;
 src = (struct jpeg_source_mgr *) cinfo->src;
-if (!src) {
+if (!src)
-return;
+{
-} else if (num_bytes > src->bytes_in_buffer) {
+return;
-ERREXIT(cinfo, JERR_INPUT_EOF);
+} else if (num_bytes > src->bytes_in_buffer)
-/*NOTREACHED*/
+{
-}
+	ERREXIT(cinfo, JERR_INPUT_EOF);
+	/*NOTREACHED*/
+}
 src->bytes_in_buffer -= num_bytes;
 src->next_input_byte += num_bytes;
 }
 #if defined(JPEG_LIB_VERSION) && (JPEG_LIB_VERSION >= 61)
 METHODDEF(void)
 #else
 METHODDEF void
 #endif
-our_term_source (j_decompress_ptr cinfo) {
+our_term_source (j_decompress_ptr cinfo)
+{
 }
 typedef struct {
 struct jpeg_source_mgr pub;
 } our_jpeg_source_mgr;
 static void
 jpeg_memory_src (j_decompress_ptr cinfo, JOCTET *data, unsigned int len)
 {
 struct jpeg_source_mgr *src = NULL;
-if (cinfo->src == NULL) {	/* first time for this JPEG object? */
+if (cinfo->src == NULL)
-cinfo->src = (struct jpeg_source_mgr *)
+{	/* first time for this JPEG object? */
-(*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
+cinfo->src = (struct jpeg_source_mgr *)
-				  sizeof(our_jpeg_source_mgr));
+	(*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
-src = (struct jpeg_source_mgr *) cinfo->src;
+				    sizeof(our_jpeg_source_mgr));
-src->next_input_byte = data;
+src = (struct jpeg_source_mgr *) cinfo->src;
-}
+src->next_input_byte = data;
+}
 src = (struct jpeg_source_mgr *) cinfo->src;
 src->init_source = our_init_source;
 src->fill_input_buffer = our_fill_input_buffer;
 src->skip_input_data = our_skip_input_data;
 src->resync_to_restart = jpeg_resync_to_restart; /* use default method */
 	/* Create the message */
 	(*cinfo.err->format_message) ((j_common_ptr) &cinfo, buffer);
 	errstring = build_string (buffer);
-	signal_simple_error_2 ("JPEG decoding error",
+	signal_image_error_2 ("JPEG decoding error",
-			       errstring, instantiator);
+			      errstring, instantiator);
 }
 }
 /* Now we can initialize the JPEG decompression object. */
 jpeg_create_decompress (&cinfo);
 */
 /* At this point we know the size of the image and the colormap. */
 /* Step 5.33: Allocate the colors */
-if (vis->class == PseudoColor) {
+if (vis->class == PseudoColor)
-int i;
+{
-unwind.pixcount = 32;
+int i;
-unwind.pixels = xnew_array (unsigned long, unwind.pixcount);
+unwind.pixcount = 32;
-unwind.npixels = 0;
+unwind.pixels = xnew_array (unsigned long, unwind.pixcount);
+unwind.npixels = 0;
-/* Allocate pixels for the various colors. */
-for (i = 0; i < cinfo.actual_number_of_colors; i++)
+/* Allocate pixels for the various colors. */
-{
+for (i = 0; i < cinfo.actual_number_of_colors; i++)
-	XColor color;
+	{
-	int ri, gi, bi, res;
+	  XColor color;
+	  int ri, gi, bi, res;
-	ri = 0;
-	gi = cinfo.out_color_components > 1 ? 1 : 0;
+	  ri = 0;
-	bi = cinfo.out_color_components > 2 ? 2 : 0;
+	  gi = cinfo.out_color_components > 1 ? 1 : 0;
+	  bi = cinfo.out_color_components > 2 ? 2 : 0;
-	/* Ok... apparently, an entry of cinfo.colormap can be NULL if
-	   there are no bits of that color in the image.  How incredibly
+	  /* Ok... apparently, an entry of cinfo.colormap can be NULL if
-	   gross.  Wouldn't it be nice to have exceptions!? */
+	     there are no bits of that color in the image.  How incredibly
-	color.red = cinfo.colormap[ri] ? cinfo.colormap[ri][i] << 8 : 0;
+	     gross.  Wouldn't it be nice to have exceptions!? */
-	color.green = cinfo.colormap[gi] ? cinfo.colormap[gi][i] << 8 : 0;
+	  color.red = cinfo.colormap[ri] ? cinfo.colormap[ri][i] << 8 : 0;
-	color.blue = cinfo.colormap[bi] ? cinfo.colormap[bi][i] << 8 : 0;
+	  color.green = cinfo.colormap[gi] ? cinfo.colormap[gi][i] << 8 : 0;
-	color.flags = DoRed | DoGreen | DoBlue;
+	  color.blue = cinfo.colormap[bi] ? cinfo.colormap[bi][i] << 8 : 0;
+	  color.flags = DoRed | DoGreen | DoBlue;
-	res = allocate_nearest_color (dpy, cmap, vis, &color);
-	if (res > 0 && res < 3)
+	  res = allocate_nearest_color (dpy, cmap, vis, &color);
-	  {
+	  if (res > 0 && res < 3)
-	    DO_REALLOC(unwind.pixels, unwind.pixcount, unwind.npixels+1, unsigned long);
+	    {
-	    unwind.pixels[unwind.npixels] = color.pixel;
+	      DO_REALLOC(unwind.pixels, unwind.pixcount, unwind.npixels+1, unsigned long);
-	    unwind.npixels++;
+	      unwind.pixels[unwind.npixels] = color.pixel;
-	  }
+	      unwind.npixels++;
-}
+	    }
-}
+	}
+}
 /* Step 5.66: Create the image */
 {
 int height = cinfo.output_height;
 int width = cinfo.output_width;
 unwind.ximage = XCreateImage (dpy, vis, depth, ZPixmap, 0, 0, width, height,
 				  bitmap_pad, 0);
 if (!unwind.ximage)
-signal_simple_error ("Unable to create X image struct", instantiator);
+signal_image_error ("Unable to create X image struct", instantiator);
 /* now that bytes_per_line must have been set properly alloc data */
 unwind.ximage->data =
 (char *) xmalloc (unwind.ximage->bytes_per_line * height);
 }
 /* Step 6: Read in the data and put into EImage format (8bit RGB triples)*/
 unwind.eimage = (unsigned char*) xmalloc (cinfo.output_width * cinfo.output_height * 3);
 if (!unwind.eimage)
-signal_simple_error("Unable to allocate enough memory for image", instantiator);
+signal_image_error("Unable to allocate enough memory for image", instantiator);
 {
 JSAMPARRAY row_buffer;	/* Output row buffer */
 JSAMPLE *jp;
 int row_stride;		/* physical row width in output buffer */
 	   * Here the array is only one element long, but you could ask for
 	   * more than one scanline at a time if that's more convenient.
 	   */
 	  (void) jpeg_read_scanlines (&cinfo, row_buffer, 1);
 	  jp = row_buffer[0];
-	  for (i = 0; i < cinfo.output_width; i++) {
+	  for (i = 0; i < cinfo.output_width; i++)
-	    int clr;
+	    {
+	      int clr;
 #if (BITS_IN_JSAMPLE == 8)
-	    for (clr = 0; clr < 3; clr++)
+	      for (clr = 0; clr < 3; clr++)
-	      *op++ = (unsigned char)*jp++;
+		*op++ = (unsigned char)*jp++;
 #else /* other option is 12 */
-	    for (clr = 0; clr < 3; clr++)
+	      for (clr = 0; clr < 3; clr++)
-	      *op++ = (unsigned char)(*jp++ >> 4);
+		*op++ = (unsigned char)(*jp++ >> 4);
 #endif
-	  }
+	    }
 	}
-unwind.ximage = EImage2XImage (device, cinfo.output_width, cinfo.output_height, unwind.eimage,
+unwind.ximage = convert_EImage_to_XImage (device, cinfo.output_width, cinfo.output_height, unwind.eimage,
 				     &unwind.pixels, &unwind.pixcount, &unwind.npixels);
 if (!unwind.ximage)
-	signal_simple_error("JPEG conversion failed", instantiator);
+	signal_image_error("JPEG conversion failed", instantiator);
 }
 }
 #endif
 /* Step 6.5: Create the pixmap and set up the image instance */
 init_image_instance_from_x_image (ii, unwind.ximage, dest_mask,
-				    unwind.pixels, unwind.npixels,
+				    cmap, unwind.pixels, unwind.npixels,
 				    instantiator);
 /* Step 7: Finish decompression */
 jpeg_finish_decompress (&cinfo);
 Extbyte *bytes;		/* The data       */
 Extcount len;			/* How big is it? */
 int index;			/* Where are we?  */
 } gif_memory_storage;
-static size_t gif_read_from_memory(GifByteType *buf, size_t size, VoidPtr data)
+static size_t
+gif_read_from_memory(GifByteType *buf, size_t size, VoidPtr data)
 {
 gif_memory_storage *mem = (gif_memory_storage*)data;
 if (size > (mem->len - mem->index))
 return -1;
 memcpy(buf, mem->bytes + mem->index, size);
 mem->index = mem->index + size;
 return size;
 }
-static int gif_memory_close(VoidPtr data)
+static int
+gif_memory_close(VoidPtr data)
 {
 return 0;
 }
 #endif
 {
 char *err_str;		/* return the error string */
 jmp_buf setjmp_buffer;	/* for return to caller */
 };
-static void gif_error_func(CONST char *err_str, VoidPtr error_ptr)
+static void
+gif_error_func(CONST char *err_str, VoidPtr error_ptr)
 {
 struct gif_error_struct *error_data = (struct gif_error_struct*)error_ptr;
 /* return to setjmp point */
 error_data->err_str = err_str;
 Lisp_Object data = find_keyword_in_vector (instantiator, Q_data);
 assert (!NILP (data));
 if (!(unwind.giffile = GifSetup()))
-signal_simple_error ("Insufficent memory to instantiate GIF image", instantiator);
+signal_image_error ("Insufficent memory to instantiate GIF image", instantiator);
 /* set up error facilities */
-if (setjmp(gif_err.setjmp_buffer)) {
+if (setjmp(gif_err.setjmp_buffer))
-/* An error was signaled. No clean up is needed, as unwind handles that
+{
-	 for us.  Just pass the error along. */
+	/* An error was signaled. No clean up is needed, as unwind handles that
-Lisp_Object errstring;
+	   for us.  Just pass the error along. */
-errstring = build_string (gif_err.err_str);
+	Lisp_Object errstring;
-signal_simple_error_2 ("GIF decoding error", errstring, instantiator);
+	errstring = build_string (gif_err.err_str);
-}
+	signal_image_error_2 ("GIF decoding error", errstring, instantiator);
+}
 GifSetErrorFunc(unwind.giffile, (Gif_error_func)gif_error_func, (VoidPtr)&gif_err);
 #ifdef USE_TEMP_FILES_FOR_GIF_IMAGES
 write_lisp_string_to_temp_file (data, unwind.tempfile);
 unwind.tempfile_needs_to_be_removed = 1;
 unwind.ximage = XCreateImage (dpy, vis,
 				  depth, ZPixmap, 0, 0, width, height,
 				  bitmap_pad, 0);
 if (!unwind.ximage)
-signal_simple_error ("Unable to create X image struct", instantiator);
+signal_image_error ("Unable to create X image struct", instantiator);
 /* now that bytes_per_line must have been set properly alloc data */
 unwind.ximage->data =
 (char *) xmalloc (unwind.ximage->bytes_per_line * height);
 -dkindred@cs.cmu.edu  */
 if (unwind.giffile->SavedImages[0].ImageDesc.Height != height
 	|| unwind.giffile->SavedImages[0].ImageDesc.Width != width
 	|| unwind.giffile->SavedImages[0].ImageDesc.Left != 0
 	|| unwind.giffile->SavedImages[0].ImageDesc.Top != 0)
-signal_simple_error ("First image in GIF file is not full size",
+signal_image_error ("First image in GIF file is not full size",
 			   instantiator);
 interlace = unwind.giffile->SavedImages[0].ImageDesc.Interlace;
 pass = 0;
 row = interlace ? InterlacedOffset[pass] : 0;
 static int InterlacedOffset[] = { 0, 4, 2, 1 };
 static int InterlacedJumps[] = { 8, 8, 4, 2 };
 unwind.eimage = (unsigned char*) xmalloc (width * height * 3);
 if (!unwind.eimage)
-signal_simple_error("Unable to allocate enough memory for image", instantiator);
+signal_image_error("Unable to allocate enough memory for image", instantiator);
 /* write the data in EImage format (8bit RGB triples) */
 /* Note: We just use the first image in the file and ignore the rest.
 We check here that that image covers the full "screen" size.
 -dkindred@cs.cmu.edu  */
 if (unwind.giffile->SavedImages[0].ImageDesc.Height != height
 	|| unwind.giffile->SavedImages[0].ImageDesc.Width != width
 	|| unwind.giffile->SavedImages[0].ImageDesc.Left != 0
 	|| unwind.giffile->SavedImages[0].ImageDesc.Top != 0)
-signal_simple_error ("First image in GIF file is not full size",
+signal_image_error ("First image in GIF file is not full size",
 			   instantiator);
 interlace = unwind.giffile->SavedImages[0].ImageDesc.Interlace;
 pass = 0;
 row = interlace ? InterlacedOffset[pass] : 0;
 for (i = 0; i < height; i++)
 {
 	if (interlace && row >= height)
 	  row = InterlacedOffset[++pass];
 	eip = unwind.eimage + (row * width * 3);
-	for (j = 0; j < width; j++) {
+	for (j = 0; j < width; j++)
-	  unsigned char pixel = unwind.giffile->SavedImages[0].RasterBits[(i * width) + j];
+	  {
-	  *eip++ = cmo->Colors[pixel].Red;
+	    unsigned char pixel = unwind.giffile->SavedImages[0].RasterBits[(i * width) + j];
-	  *eip++ = cmo->Colors[pixel].Green;
+	    *eip++ = cmo->Colors[pixel].Red;
-	  *eip++ = cmo->Colors[pixel].Blue;
+	    *eip++ = cmo->Colors[pixel].Green;
-	}
+	    *eip++ = cmo->Colors[pixel].Blue;
+	  }
 	row += interlace ? InterlacedJumps[pass] : 1;
 }
-unwind.ximage = EImage2XImage (device, width, height, unwind.eimage,
+unwind.ximage = convert_EImage_to_XImage (device, width, height, unwind.eimage,
 				   &unwind.pixels, &unwind.pixcount, &unwind.npixels);
 if (!unwind.ximage)
-signal_simple_error("GIF conversion failed", instantiator);
+signal_image_error("GIF conversion failed", instantiator);
 }
 #endif
 /* 4. Now create the pixmap and set up the image instance */
 init_image_instance_from_x_image (ii, unwind.ximage, dest_mask,
-				    unwind.pixels, unwind.npixels,
+				    cmap, unwind.pixels, unwind.npixels,
 				    instantiator);
 /* Now that we've succeeded, we don't want the pixels
 freed right now.  They're kept around in the image instance
 structure until it's destroyed. */
 unwind.npixels = 0;
 Extbyte *bytes;		/* The data       */
 Extcount len;			/* How big is it? */
 int index;			/* Where are we?  */
 };
-static void png_read_from_memory(png_structp png_ptr, png_bytep data,
+static void
-				 png_size_t length)
+png_read_from_memory(png_structp png_ptr, png_bytep data,
+		     png_size_t length)
 {
 struct png_memory_storage *tbr =
 (struct png_memory_storage *) png_get_io_ptr (png_ptr);
 if (length > (tbr->len - tbr->index))
 png_error (png_ptr, (png_const_charp) "Read Error");
-memcpy(data,tbr->bytes + tbr->index,length);
+memcpy (data,tbr->bytes + tbr->index,length);
 tbr->index = tbr->index + length;
 }
 #endif /* !USE_TEMP_FILES_FOR_PNG_IMAGES */
 struct png_error_struct
 around this, use our own error functions, and don't rely on things
 passed in the png_ptr to them.  This is an ugly hack and must
 go away when the lisp engine is threaded! */
 static struct png_error_struct png_err_stct;
-static void png_error_func(png_structp png_ptr, png_const_charp message)
+static void
+png_error_func(png_structp png_ptr, png_const_charp message)
 {
 png_err_stct.err_str = message;
 longjmp (png_err_stct.setjmp_buffer, 1);
 }
-static void png_warning_func(png_structp png_ptr, png_const_charp message)
+static void
+png_warning_func(png_structp png_ptr, png_const_charp message)
 {
 warn_when_safe (Qpng, Qinfo, "%s", message);
 }
 struct png_unwind_data
 dpy = DEVICE_X_DISPLAY (XDEVICE (device));
 cmap = DEVICE_X_COLORMAP (XDEVICE(device));
 vis = DEVICE_X_VISUAL (XDEVICE(device));
 /* Initialize all PNG structures */
-png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, (void*)&png_err_stct,
+png_ptr = png_create_read_struct (PNG_LIBPNG_VER_STRING, (void*)&png_err_stct,
-				   png_error_func, png_warning_func);
+				    png_error_func, png_warning_func);
 if (!png_ptr)
-signal_simple_error("Error obtaining memory for png_read", instantiator);
+signal_image_error ("Error obtaining memory for png_read", instantiator);
-info_ptr = png_create_info_struct(png_ptr);
+info_ptr = png_create_info_struct (png_ptr);
 if (!info_ptr)
 {
-png_destroy_read_struct(&png_ptr, (png_infopp)NULL, (png_infopp)NULL);
+png_destroy_read_struct (&png_ptr, (png_infopp)NULL, (png_infopp)NULL);
-signal_simple_error("Error obtaining memory for png_read", instantiator);
+signal_image_error ("Error obtaining memory for png_read", instantiator);
 }
 memset (&unwind, 0, sizeof (unwind));
 unwind.png_ptr = png_ptr;
 unwind.info_ptr = info_ptr;
 /* Set the jmp_buf reurn context for png_error ... if this returns !0, then
 we ran into a problem somewhere, and need to clean up after ourselves. */
 if (setjmp (png_err_stct.setjmp_buffer))
 {
 /* Something blew up: just display the error (cleanup happens in the unwind) */
-signal_simple_error_2 ("Error decoding PNG",
+signal_image_error_2 ("Error decoding PNG",
 			     build_string(png_err_stct.err_str),
 			     instantiator);
 }
 /* Initialize the IO layer and read in header information */
 stack data it might allocate.  Need to think about using Lstreams */
 GET_STRING_BINARY_DATA_ALLOCA (data, bytes, len);
 tbr.bytes = bytes;
 tbr.len = len;
 tbr.index = 0;
-png_set_read_fn(png_ptr,(void *) &tbr, png_read_from_memory);
+png_set_read_fn (png_ptr,(void *) &tbr, png_read_from_memory);
 }
 png_read_info (png_ptr, info_ptr);
 #if 0
 unwind.ximage = XCreateImage (dpy, vis,
 				  depth, ZPixmap, 0, 0, width, height,
 				  bitmap_pad, 0);
 if (!unwind.ximage)
-signal_simple_error ("Unable to create X image struct",
+signal_image_error ("Unable to create X image struct",
 			   instantiator);
 /* now that bytes_per_line must have been set properly alloc data */
 unwind.ximage->data = (char *) xmalloc (unwind.ximage->bytes_per_line *
 					    height);
 /* Now that we're using EImage, ask for 8bit RGB triples for any type
 of image*/
 /* convert palatte images to full RGB */
 if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
-png_set_expand(png_ptr);
+png_set_expand (png_ptr);
 /* send grayscale images to RGB too */
 if (info_ptr->color_type == PNG_COLOR_TYPE_GRAY ||
 info_ptr->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
-png_set_gray_to_rgb(png_ptr);
+png_set_gray_to_rgb (png_ptr);
 /* we can't handle alpha values */
 if (info_ptr->color_type & PNG_COLOR_MASK_ALPHA)
-png_set_strip_alpha(png_ptr);
+png_set_strip_alpha (png_ptr);
 /* rip out any transparancy layers/colors */
-if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) {
+if (png_get_valid (png_ptr, info_ptr, PNG_INFO_tRNS))
-png_set_expand(png_ptr);
+{
-	png_set_strip_alpha(png_ptr);
+png_set_expand (png_ptr);
-}
+	png_set_strip_alpha (png_ptr);
+}
 /* tell libpng to strip 16 bit depth files down to 8 bits */
 if (info_ptr->bit_depth == 16)
 png_set_strip_16 (png_ptr);
 /* if the image is < 8 bits, pad it out */
-if (info_ptr->bit_depth < 8) {
+if (info_ptr->bit_depth < 8)
-if (info_ptr->color_type == PNG_COLOR_TYPE_GRAY)
+{
-	png_set_expand(png_ptr);
+	if (info_ptr->color_type == PNG_COLOR_TYPE_GRAY)
-else
+	  png_set_expand (png_ptr);
-	png_set_packing (png_ptr);
+	else
-}
+	  png_set_packing (png_ptr);
+}
 #if 1 /* tests? or permanent? */
 {
 /* if the png specifies a background chunk, go ahead and
 	 use it */
 /* ### how do I get the background of the current frame? */
 my_background.red = 0x7fff;
 my_background.green = 0x7fff;
 my_background.blue = 0x7fff;
-if (png_get_bKGD(png_ptr, info_ptr, &image_background))
+if (png_get_bKGD (png_ptr, info_ptr, &image_background))
-	png_set_background(png_ptr, image_background,
+	png_set_background (png_ptr, image_background,
-			   PNG_BACKGROUND_GAMMA_FILE, 1, 1.0);
+			    PNG_BACKGROUND_GAMMA_FILE, 1, 1.0);
 else
-	png_set_background(png_ptr, &my_background,
+	png_set_background (png_ptr, &my_background,
-			   PNG_BACKGROUND_GAMMA_SCREEN, 0, 1.0);
+			    PNG_BACKGROUND_GAMMA_SCREEN, 0, 1.0);
 }
 #endif
 png_read_image (png_ptr, row_pointers);
 png_read_end (png_ptr, info_ptr);
 	}
 }
 #endif
 xfree (row_pointers);
-unwind.ximage = EImage2XImage (device, width, height, unwind.eimage,
+unwind.ximage = convert_EImage_to_XImage (device, width, height, unwind.eimage,
 				   &unwind.pixels, &unwind.pixcount, &unwind.npixels);
 if (!unwind.ximage)
-signal_simple_error("PNG conversion failed", instantiator);
+signal_image_error ("PNG conversion failed", instantiator);
 }
 #endif
 init_image_instance_from_x_image (ii, unwind.ximage, dest_mask,
-				    unwind.pixels, unwind.npixels,
+				    cmap, unwind.pixels, unwind.npixels,
 				    instantiator);
 /* This will clean up everything else. */
 unwind.npixels = 0;
 unwind.pixcount = 0;
 if (data->tiff)
 {
 TIFFClose(data->tiff);
 }
 if (data->eimage)
-xfree(data->eimage);
+xfree (data->eimage);
 if (data->npixels > 0)
 XFreeColors (data->dpy, data->cmap, data->pixels, data->npixels, 0L);
 if (data->pixcount)
 xfree (data->pixels);
 if (data->ximage)
 Extbyte *bytes;		/* The data       */
 Extcount len;			/* How big is it? */
 int index;			/* Where are we?  */
 } tiff_memory_storage;
-static size_t tiff_memory_read(thandle_t data, tdata_t buf, tsize_t size)
+static size_t
+tiff_memory_read(thandle_t data, tdata_t buf, tsize_t size)
 {
 tiff_memory_storage *mem = (tiff_memory_storage*)data;
 if (size > (mem->len - mem->index))
 return -1;
 mem->index = newidx;
 return newidx;
 }
-static int tiff_memory_close(thandle_t data)
+static int
+tiff_memory_close(thandle_t data)
 {
 return 0;
 }
-static int tiff_map_noop(thandle_t data, tdata_t* pbase, toff_t* psize)
+static int
+tiff_map_noop(thandle_t data, tdata_t* pbase, toff_t* psize)
 {
 return 0;
 }
-static void tiff_unmap_noop(thandle_t data, tdata_t pbase, toff_t psize)
+static void
+tiff_unmap_noop(thandle_t data, tdata_t pbase, toff_t psize)
 {
 return;
 }
-static toff_t tiff_memory_size(thandle_t data)
+static toff_t
+tiff_memory_size(thandle_t data)
 {
 tiff_memory_storage *mem = (tiff_memory_storage*)data;
 return mem->len;
 }
 is an ugly hack caused by the fact that libtiff (as of v3.4) doesn't
 have any place to store error func data.  This should be rectified
 before XEmacs gets threads! */
 static struct tiff_error_struct tiff_err_data;
-static void tiff_error_func(CONST char *module, CONST char *fmt, ...)
+static void
+tiff_error_func(CONST char *module, CONST char *fmt, ...)
 {
 va_list vargs;
 va_start (vargs, fmt);
 #if HAVE_VSNPRINTF
-vsnprintf(tiff_err_data.err_str, 255, fmt, vargs);
+vsnprintf (tiff_err_data.err_str, 255, fmt, vargs);
 #else
 /* pray this doesn't overflow... */
-vsprintf(tiff_err_data.err_str, fmt, vargs);
+vsprintf (tiff_err_data.err_str, fmt, vargs);
 #endif
-va_end(vargs);
+va_end (vargs);
 /* return to setjmp point */
 longjmp (tiff_err_data.setjmp_buffer, 1);
 }
-static void tiff_warning_func(CONST char *module, CONST char *fmt, ...)
+static void
+tiff_warning_func(CONST char *module, CONST char *fmt, ...)
 {
 va_list vargs;
 #if HAVE_VSNPRINTF
 char warn_str[256];
 #else
 char warn_str[1024];
 #endif
 va_start (vargs, fmt);
 #if HAVE_VSNPRINTF
-vsnprintf(warn_str, 255, fmt, vargs);
+vsnprintf (warn_str, 255, fmt, vargs);
 #else
-vsprintf(warn_str, fmt, vargs);
+vsprintf (warn_str, fmt, vargs);
 #endif
-va_end(vargs);
+va_end (vargs);
 warn_when_safe (Qtiff, Qinfo, "%s - %s",
 		  module, warn_str);
 }
 static void
 unwind.dpy = dpy;
 unwind.cmap = cmap;
 record_unwind_protect (tiff_instantiate_unwind, make_opaque_ptr (&unwind));
 /* set up error facilities */
-if (setjmp(tiff_err_data.setjmp_buffer)) {
+if (setjmp (tiff_err_data.setjmp_buffer))
-/* An error was signaled. No clean up is needed, as unwind handles that
+{
-for us.  Just pass the error along. */
+/* An error was signaled. No clean up is needed, as unwind handles that
-signal_simple_error_2 ("TIFF decoding error",
+	 for us.  Just pass the error along. */
-			   build_string(tiff_err_data.err_str),
+signal_image_error_2 ("TIFF decoding error",
-			   instantiator);
+			    build_string(tiff_err_data.err_str),
-}
+			    instantiator);
-TIFFSetErrorHandler((TIFFErrorHandler)tiff_error_func);
+}
-TIFFSetWarningHandler((TIFFErrorHandler)tiff_warning_func);
+TIFFSetErrorHandler ((TIFFErrorHandler)tiff_error_func);
+TIFFSetWarningHandler ((TIFFErrorHandler)tiff_warning_func);
 {
 Lisp_Object data = find_keyword_in_vector (instantiator, Q_data);
 Extbyte *bytes;
 Extcount len;
 GET_STRING_BINARY_DATA_ALLOCA (data, bytes, len);
 mem_struct.bytes = bytes;
 mem_struct.len = len;
 mem_struct.index = 0;
-unwind.tiff = TIFFClientOpen("memfile", "r", &mem_struct,
+unwind.tiff = TIFFClientOpen ("memfile", "r", &mem_struct,
-				 (TIFFReadWriteProc)tiff_memory_read,
+				  (TIFFReadWriteProc)tiff_memory_read,
-				 (TIFFReadWriteProc)tiff_memory_write,
+				  (TIFFReadWriteProc)tiff_memory_write,
-				 tiff_memory_seek, tiff_memory_close, tiff_memory_size,
+				  tiff_memory_seek, tiff_memory_close, tiff_memory_size,
-				 tiff_map_noop, tiff_unmap_noop);
+				  tiff_map_noop, tiff_unmap_noop);
 if (!unwind.tiff)
-signal_simple_error ("Insufficent memory to instantiate TIFF image", instantiator);
+signal_image_error ("Insufficent memory to instantiate TIFF image", instantiator);
-TIFFGetField(unwind.tiff, TIFFTAG_IMAGEWIDTH, &width);
+TIFFGetField (unwind.tiff, TIFFTAG_IMAGEWIDTH, &width);
-TIFFGetField(unwind.tiff, TIFFTAG_IMAGELENGTH, &height);
+TIFFGetField (unwind.tiff, TIFFTAG_IMAGELENGTH, &height);
-unwind.eimage = xmalloc(width * height * 3);
+unwind.eimage = xmalloc (width * height * 3);
 /* ### This is little more than proof-of-concept/function testing.
 It needs to be reimplimented via scanline reads for both memory
 compactness. */
-raster = (uint32*) _TIFFmalloc(width * height * sizeof (uint32));
+raster = (uint32*) _TIFFmalloc (width * height * sizeof (uint32));
-if (raster != NULL) {
+if (raster != NULL)
-int i,j;
+{
-uint32 *rp;
+	int i,j;
-ep = unwind.eimage;
+	uint32 *rp;
-rp = raster;
+	ep = unwind.eimage;
-if (TIFFReadRGBAImage(unwind.tiff, width, height, raster, 0)) {
+	rp = raster;
-	for (i = height - 1;  i >= 0; i--) {
+	if (TIFFReadRGBAImage (unwind.tiff, width, height, raster, 0))
-	  /* This is to get around weirdness in the libtiff library where properly
+	  {
-	     made TIFFs will come out upside down.  libtiff bug or jhod-brainlock? */
+	    for (i = height - 1;  i >= 0; i--)
-	  rp = raster + (i * width);
+	      {
-	  for (j = 0; j < width; j++) {
+		/* This is to get around weirdness in the libtiff library where properly
-	    *ep++ = (unsigned char)TIFFGetR(*rp);
+		   made TIFFs will come out upside down.  libtiff bug or jhod-brainlock? */
-	    *ep++ = (unsigned char)TIFFGetG(*rp);
+		rp = raster + (i * width);
-	    *ep++ = (unsigned char)TIFFGetB(*rp);
+		for (j = 0; j < width; j++)
-	    rp++;
+		  {
+		    *ep++ = (unsigned char)TIFFGetR(*rp);
+		    *ep++ = (unsigned char)TIFFGetG(*rp);
+		    *ep++ = (unsigned char)TIFFGetB(*rp);
+		    rp++;
+		  }
+	      }
 	  }
-	}
+	_TIFFfree (raster);
-}
+} else
-_TIFFfree(raster);
+	signal_image_error ("Unable to allocate memory for TIFFReadRGBA", instantiator);
-} else
-signal_simple_error ("Unable to allocate memory for TIFFReadRGBA", instantiator);
+unwind.ximage = convert_EImage_to_XImage (device, width, height, unwind.eimage,
-unwind.ximage = EImage2XImage (device, width, height, unwind.eimage,
 				   &unwind.pixels, &unwind.pixcount, &unwind.npixels);
 if (!unwind.ximage)
-signal_simple_error("TIFF conversion failed", instantiator);
+signal_image_error ("TIFF conversion failed", instantiator);
 }
 /* Now create the pixmap and set up the image instance */
 init_image_instance_from_x_image (ii, unwind.ximage, dest_mask,
-				    unwind.pixels, unwind.npixels,
+				    cmap, unwind.pixels, unwind.npixels,
 				    instantiator);
 /* Now that we've succeeded, we don't want the pixels
 freed right now.  They're kept around in the image instance
 structure until it's destroyed. */
 unwind.npixels = 0;

Mercurial > hg > xemacs-beta

comparison src/glyphs-x.c @ 269:b2472a1930f2 r20-5b33