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

comparison src/glyphs-x.c @ 272:c5d627a313b1 r21-0b34

Import from CVS: tag r21-0b34

author	cvs
date	Mon, 13 Aug 2007 10:28:48 +0200
parents	b2472a1930f2
children	ca9a9ec9c1c1

comparison

equal deleted inserted replaced

-:c7b7086b0a39
+:c5d627a313b1
 /************************************************************************/
 /*                      image instance methods                          */
 /************************************************************************/
-DOESNT_RETURN
+static DOESNT_RETURN
-signal_image_error(CONST char *reason, Lisp_Object frob)
+signal_image_error (CONST char *reason, Lisp_Object frob)
 {
-signal_error (Qimage_conversion_error, list2 (build_translated_string (reason), frob));
+signal_error (Qimage_conversion_error,
-}
+		list2 (build_translated_string (reason), frob));
+}
-DOESNT_RETURN
-signal_image_error_2 (CONST char *reason,
+static DOESNT_RETURN
-Lisp_Object frob0, Lisp_Object frob1)
+signal_image_error_2 (CONST char *reason, Lisp_Object frob0, Lisp_Object frob1)
 {
-signal_error (Qimage_conversion_error, list3 (build_translated_string (reason), frob0,
+signal_error (Qimage_conversion_error,
-			       frob1));
+		list3 (build_translated_string (reason), frob0, frob1));
 }
 /************************************************************************/
 /* convert from a series of RGB triples to an XImage formated for the   */
 /* proper display 							*/
 /************************************************************************/
-XImage *
+static XImage *
-convert_EImage_to_XImage(Lisp_Object device, int width, int height, unsigned char *pic,
+convert_EImage_to_XImage (Lisp_Object device, int width, int height,
-	      unsigned long **pixtbl, int *pixcount, int *npixels)
+			  unsigned char *pic, unsigned long **pixtbl,
+			  int *pixcount, int *npixels)
 {
 Display *dpy;
 Colormap cmap;
 Visual *vis;
 XImage *outimg;
 if (!outimg) return NULL;
 data = (unsigned char *) xmalloc (outimg->bytes_per_line * height);
 if (!data)
 {
-XDestroyImage(outimg);
+XDestroyImage (outimg);
 return NULL;
 }
-outimg->data = data;
+outimg->data = (char *) data;
 if (vis->class == PseudoColor)
 {
 unsigned long pixarray[256];
 int n;
 Lstream_close (istr);
 #ifdef FILE_CODING
 Lstream_close (costr);
 #endif
 Lstream_close (ostr);
 UNGCPRO;
 Lstream_delete (istr);
 Lstream_delete (ostr);
 #ifdef FILE_CODING
 Lstream_delete (costr);
 if (fubar)
 report_file_error ("Writing temp file",
 		       list1 (build_string (filename_out)));
 }
-#endif
+#endif /* 0 */
 /************************************************************************/
 /*                           cursor functions                           */
 /************************************************************************/
 static void
 check_valid_xbm_inline (Lisp_Object data)
 {
 Lisp_Object width, height, bits;
-CHECK_CONS (data);
+if (!CONSP (data) ||
-if (!CONSP (XCDR (data)) || !CONSP (XCDR (XCDR (data))) ||
+!CONSP (XCDR (data)) ||
+!CONSP (XCDR (XCDR (data))) ||
 !NILP (XCDR (XCDR (XCDR (data)))))
 signal_simple_error ("Must be list of 3 elements", data);
-width = XCAR (data);
+width  = XCAR (data);
 height = XCAR (XCDR (data));
-bits = XCAR (XCDR (XCDR (data)));
+bits   = XCAR (XCDR (XCDR (data)));
-if (!INTP (width) || !INTP (height) || !STRINGP (bits))
+CHECK_STRING (bits);
-signal_simple_error ("Must be (width height bits)",
-			 vector3 (width, height, bits));
+if (!NATNUMP (width))
+signal_simple_error ("Width must be a natural number", width);
-if (XINT (width) <= 0)
-signal_simple_error ("Width must be > 0", width);
+if (!NATNUMP (height))
+signal_simple_error ("Height must be a natural number", height);
-if (XINT (height) <= 0)
-signal_simple_error ("Height must be > 0", height);
+if (((XINT (width) * XINT (height)) / 8) > XSTRING_CHAR_LENGTH (bits))
+signal_simple_error ("data is too short for width and height",
-if (((unsigned) (XINT (width) * XINT (height)) / 8)
-> string_char_length (XSTRING (bits)))
-signal_simple_error ("data is too short for W and H",
 			 vector3 (width, height, bits));
 }
 /* Validate method for XBM's. */
 assert (!NILP (data));
 retry:
-memset (&xpmattrs, 0, sizeof (xpmattrs)); /* want XpmInitAttributes() */
+xzero (xpmattrs); /* want XpmInitAttributes() */
 xpmattrs.valuemask = XpmReturnPixels;
 if (force_mono)
 {
 /* Without this, we get a 1-bit version of the color image, which
 	 isn't quite right.  With this, we get the mono image, which might
 METHODDEF boolean
 #endif
 our_fill_input_buffer (j_decompress_ptr cinfo)
 {
 /* Insert a fake EOI marker */
-struct jpeg_source_mgr *src = (struct jpeg_source_mgr *) cinfo->src;
+struct jpeg_source_mgr *src = cinfo->src;
 static JOCTET buffer[2];
 buffer[0] = (JOCTET) 0xFF;
 buffer[1] = (JOCTET) JPEG_EOI;
 #endif
 our_term_source (j_decompress_ptr cinfo)
 {
 }
-typedef struct {
+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;
+struct jpeg_source_mgr *src;
 if (cinfo->src == NULL)
 {	/* first time for this JPEG object? */
 cinfo->src = (struct jpeg_source_mgr *)
 	(*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
 vis = DEVICE_X_VISUAL (XDEVICE(device));
 /* Step -1: First record our unwind-protect, which will clean up after
 any exit, normal or not */
-memset (&unwind, 0, sizeof (unwind));
+xzero (unwind);
 unwind.dpy = dpy;
 unwind.cmap = cmap;
 record_unwind_protect (jpeg_instantiate_unwind, make_opaque_ptr (&unwind));
 #ifdef USE_TEMP_FILES_FOR_JPEG_IMAGES
 /* #### This is a definite problem under Mule due to the amount of
 stack data it might allocate.  Need to be able to convert and
 write out to a file. */
 GET_STRING_BINARY_DATA_ALLOCA (data, bytes, len);
-jpeg_memory_src (&cinfo, bytes, len);
+jpeg_memory_src (&cinfo, (JOCTET *) bytes, len);
 }
 #endif
 /* Step 3: read file parameters with jpeg_read_header() */
 	/* jpeg_read_scanlines expects an array of pointers to scanlines.
 	 * 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);
+	jpeg_read_scanlines (&cinfo, row_buffer, 1);
-	for (i = 0; i < cinfo.output_width; i++)
+	for (i = 0; i < (int) cinfo.output_width; i++)
 	  XPutPixel (unwind.ximage, i, scanline,
 		     /* Let's make sure we avoid getting bit like
 			what happened for GIF's.  It's probably the
 			case that JSAMPLE's are unsigned chars as
 			opposed to chars, but you never know.
 dpy = DEVICE_X_DISPLAY (XDEVICE (device));
 cmap = DEVICE_X_COLORMAP (XDEVICE(device));
 vis = DEVICE_X_VISUAL (XDEVICE(device));
-memset (&unwind, 0, sizeof (unwind));
+xzero (unwind);
 unwind.dpy = dpy;
 unwind.cmap = cmap;
 record_unwind_protect (gif_instantiate_unwind, make_opaque_ptr (&unwind));
 /* 1. Now decode the data. */
 for (i = 0; i < cmo->ColorCount; i++)
 {
 	int res;
 	XColor color;
-	color.red = cmo->Colors[i].Red << 8;
+	color.red   = cmo->Colors[i].Red   << 8;
 	color.green = cmo->Colors[i].Green << 8;
-	color.blue = cmo->Colors[i].Blue << 8;
+	color.blue  = cmo->Colors[i].Blue  << 8;
 	color.flags = DoRed | DoGreen | DoBlue;
 	res = allocate_nearest_color (dpy, cmap, vis, &color);
 	if (res > 0 && res < 3)
 	  {
 }
 #ifndef USE_TEMP_FILES_FOR_PNG_IMAGES
 struct png_memory_storage
 {
-Extbyte *bytes;		/* The data       */
+CONST Extbyte *bytes;		/* The data       */
 Extcount len;			/* How big is it? */
 int index;			/* Where are we?  */
 };
 static void
 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)
+png_error_func (png_structp png_ptr, png_const_charp msg)
 {
-png_err_stct.err_str = message;
+png_err_stct.err_str = msg;
 longjmp (png_err_stct.setjmp_buffer, 1);
 }
 static void
-png_warning_func(png_structp png_ptr, png_const_charp message)
+png_warning_func (png_structp png_ptr, png_const_charp msg)
 {
-warn_when_safe (Qpng, Qinfo, "%s", message);
+warn_when_safe (Qpng, Qinfo, "%s", msg);
 }
 struct png_unwind_data
 {
 Display *dpy;
 {
 png_destroy_read_struct (&png_ptr, (png_infopp)NULL, (png_infopp)NULL);
 signal_image_error ("Error obtaining memory for png_read", instantiator);
 }
-memset (&unwind, 0, sizeof (unwind));
+xzero (unwind);
 unwind.png_ptr = png_ptr;
 unwind.info_ptr = info_ptr;
 unwind.dpy = dpy;
 unwind.cmap = cmap;
 }
 /* Initialize the IO layer and read in header information */
 {
 Lisp_Object data = find_keyword_in_vector (instantiator, Q_data);
-Extbyte *bytes;
+CONST Extbyte *bytes;
 Extcount len;
 struct png_memory_storage tbr; /* Data to be read */
 assert (!NILP (data));
 {
 	if (!(info_ptr->valid & PNG_INFO_PLTE))
 	  {
 	    for (y = 0; y < 216; y++)
 	      {
-		static_color_cube[y].red = (y % 6) * 255.0 / 5;
+		static_color_cube[y].red   = (png_byte) ((y % 6) * 255.0 / 5);
-		static_color_cube[y].green = ((y / 6) % 6) * 255.0 / 5;
+		static_color_cube[y].green = (png_byte) (((y / 6) % 6) * 255.0 / 5);
-		static_color_cube[y].blue = (y / 36) * 255.0 / 5;
+		static_color_cube[y].blue  = (png_byte) ((y / 36) * 255.0 / 5);
 	      }
 	    png_set_dither (png_ptr, static_color_cube, 216, 216, NULL, 1);
 	  }
 	else
 	  {
 {
 	unwind.npixels = 0;
 	for (y = 0; y < info_ptr->num_palette; y++)
 	  {
 	    int res;
-	    color.red = info_ptr->palette[y].red << 8;
+	    color.red   = info_ptr->palette[y].red   << 8;
 	    color.green = info_ptr->palette[y].green << 8;
-	    color.blue = info_ptr->palette[y].blue << 8;
+	    color.blue  = info_ptr->palette[y].blue  << 8;
 	    color.flags = DoRed | DoGreen | DoBlue;
 	    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.npixels = 0;
 	for (y = 0; y < 216; y++)
 	  {
 	    int res;
-	    color.red = static_color_cube[y].red << 8;
+	    color.red   = static_color_cube[y].red   << 8;
 	    color.green = static_color_cube[y].green << 8;
-	    color.blue = static_color_cube[y].blue << 8;
+	    color.blue  = static_color_cube[y].blue  << 8;
 	    color.flags = DoRed|DoGreen|DoBlue;
 	    res = allocate_nearest_color (dpy, cmap, vis, &color);
 	    if (res > 0 && res < 3)
 	      {
 		unwind.pixels[unwind.npixels] = color.pixel;
 /* if the png specifies a background chunk, go ahead and
 	 use it */
 png_color_16 my_background, *image_background;
 /* ### how do I get the background of the current frame? */
-my_background.red = 0x7fff;
+my_background.red   = 0x7fff;
 my_background.green = 0x7fff;
-my_background.blue = 0x7fff;
+my_background.blue  = 0x7fff;
 if (png_get_bKGD (png_ptr, info_ptr, &image_background))
 	png_set_background (png_ptr, image_background,
 			    PNG_BACKGROUND_GAMMA_FILE, 1, 1.0);
 else
 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;
+return (size_t) -1;
 memcpy(buf, mem->bytes + mem->index, size);
 mem->index = mem->index + size;
 return size;
 }
 signal_simple_error ("Not an X device", device);
 dpy = DEVICE_X_DISPLAY (XDEVICE (device));
 cmap = DEVICE_X_COLORMAP (XDEVICE(device));
-memset (&unwind, 0, sizeof (unwind));
+xzero (unwind);
 unwind.dpy = dpy;
 unwind.cmap = cmap;
 record_unwind_protect (tiff_instantiate_unwind, make_opaque_ptr (&unwind));
 /* set up error facilities */
 if (!unwind.tiff)
 signal_image_error ("Insufficent memory to instantiate TIFF image", instantiator);
 TIFFGetField (unwind.tiff, TIFFTAG_IMAGEWIDTH, &width);
 TIFFGetField (unwind.tiff, TIFFTAG_IMAGELENGTH, &height);
-unwind.eimage = xmalloc (width * height * 3);
+unwind.eimage = (unsigned char *) 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));
 /************************************************************************/
 /*                               subwindows                             */
 /************************************************************************/
 Lisp_Object Qsubwindowp;
-static Lisp_Object mark_subwindow (Lisp_Object, void (*) (Lisp_Object));
-static void print_subwindow (Lisp_Object, Lisp_Object, int);
-static void finalize_subwindow (void *, int);
-static int subwindow_equal (Lisp_Object o1, Lisp_Object o2, int depth);
-static unsigned long subwindow_hash (Lisp_Object obj, int depth);
-DEFINE_LRECORD_IMPLEMENTATION ("subwindow", subwindow,
-			       mark_subwindow, print_subwindow,
-			       finalize_subwindow, subwindow_equal,
-			       subwindow_hash, struct Lisp_Subwindow);
 static Lisp_Object
 mark_subwindow (Lisp_Object obj, void (*markobj) (Lisp_Object))
 {
 struct Lisp_Subwindow *sw = XSUBWINDOW (obj);
 subwindow_hash (Lisp_Object obj, int depth)
 {
 return XSUBWINDOW (obj)->subwindow;
 }
+DEFINE_LRECORD_IMPLEMENTATION ("subwindow", subwindow,
+			       mark_subwindow, print_subwindow,
+			       finalize_subwindow, subwindow_equal,
+			       subwindow_hash, struct Lisp_Subwindow);
 /* #### PROBLEM: The display routines assume that the glyph is only
 being displayed in one buffer.  If it is in two different buffers
 which are both being displayed simultaneously you will lose big time.
 This can be dealt with in the new redisplay. */
 XChangeProperty (dpy, sw->subwindow, property_atom, XA_STRING, 8,
 		   PropModeReplace,
 		   XSTRING_DATA   (data),
 		   XSTRING_LENGTH (data));
-return (property);
+return property;
 }
 DEFUN ("subwindowp", Fsubwindowp, 1, 1, 0, /*
 Return non-nil if OBJECT is a subwindow.
 Subwindows are not currently implemented.
 */
 (object))
 {
-return (SUBWINDOWP (object) ? Qt : Qnil);
+return SUBWINDOWP (object) ? Qt : Qnil;
 }
 DEFUN ("subwindow-width", Fsubwindow_width, 1, 1, 0, /*
 Width of SUBWINDOW.
 Subwindows are not currently implemented.
 */
 (subwindow))
 {
 CHECK_SUBWINDOW (subwindow);
-return (make_int (XSUBWINDOW (subwindow)->width));
+return make_int (XSUBWINDOW (subwindow)->width);
 }
 DEFUN ("subwindow-height", Fsubwindow_height, 1, 1, 0, /*
 Height of SUBWINDOW.
 Subwindows are not currently implemented.
 */
 (subwindow))
 {
 CHECK_SUBWINDOW (subwindow);
-return (make_int (XSUBWINDOW (subwindow)->height));
+return make_int (XSUBWINDOW (subwindow)->height);
 }
 DEFUN ("subwindow-xid", Fsubwindow_xid, 1, 1, 0, /*
 Return the xid of SUBWINDOW as a number.
 Subwindows are not currently implemented.
 */
 (subwindow))
 {
 CHECK_SUBWINDOW (subwindow);
-return (make_int (XSUBWINDOW (subwindow)->subwindow));
+return make_int (XSUBWINDOW (subwindow)->subwindow);
 }
 DEFUN ("resize-subwindow", Fresize_subwindow, 1, 3, 0, /*
 Resize SUBWINDOW to WIDTH x HEIGHT.
 If a value is nil that parameter is not changed.

Mercurial > hg > xemacs-beta

comparison src/glyphs-x.c @ 272:c5d627a313b1 r21-0b34