Fix bogus names such as PIXMAN_FORMAT_NAME_AR_GB32 that were left over from a broken search-and-replace. Normalize structure defintions, (eg. struct _pixman_region16_t -> struct pixman_region16). Normalize indentation.

Fix alphabetization.

11 files changed, 177 insertions, 160 deletions

diff --git a/pixman/AUTHORS b/pixman/AUTHORS
index cd599e41..c37067bc 100644
--- a/pixman/AUTHORS
+++ b/pixman/AUTHORS
@@ -1,7 +1,7 @@
-Jakub Bogusz <qboosh@pld-linux.org> Fixes for 64-bit machines.
 David R Bacon <dbacon@cis.ksu.edu> Fixes to compile on x86_64.
 Billy Biggs <vektor@dumbterm.net> Fix to use stdint datatypes.
 Dave Beckett <Dave.Beckett@bristol.ac.uk> Combined libpixregion, libic, and slim.
+Jakub Bogusz <qboosh@pld-linux.org> Fixes for 64-bit machines.
 Anders Carlsson <andersca@gnome.org> Build fixes. New accessor functions.
 Richard Henderson <rth@twiddle.net> "slim" macros for better shared libraries 
 Keith Packard <keithp@keithp.com> The original implementation of the compositing code.
diff --git a/pixman/ChangeLog b/pixman/ChangeLog
index d0c2c58d..a6283012 100644
--- a/pixman/ChangeLog
+++ b/pixman/ChangeLog
@@ -1,3 +1,19 @@
+2004-04-16  Carl Worth  <cworth@isi.edu>
+
+	* src/ictrap.c (IcCreateAlphaPicture): 
+	* src/icrect.c (pixman_color_rects): 
+	* src/pixregion.c (pixman_region16_print, pixman_region16_valid): 
+	* src/icint.h (IcBitsMask):
+	* src/icimage.h:
+	* src/icimage.c (pixman_image_change):
+	* src/icformat.c (pixman_format_create): 
+	* src/pixman.h: Fix bogus names such as PIXMAN_FORMAT_NAME_AR_GB32
+	that were left over from a broken search-and-replace. Normalize
+	structure defintions, (eg. struct _pixman_region16_t -> struct
+	pixman_region16). Normalize indentation.
+
+	* AUTHORS: Fix alphabetization.
+
 2004-02-24  Carl Worth  <cworth@isi.edu>
 
 	* AUTHORS: Added attribution for several authors after sifting
diff --git a/pixman/src/icformat.c b/pixman/src/icformat.c
index 9e15841a..870fc0fa 100644
--- a/pixman/src/icformat.c
+++ b/pixman/src/icformat.c
@@ -26,16 +26,16 @@
 #define Mask(n)	((n) == 32 ? 0xffffffff : ((1 << (n))-1))
 
 pixman_format_t *
-pixman_format_create (pixman_format_tName name)
+pixman_format_create (pixman_format_name_t name)
 {
     switch (name) {
-    case PIXMAN_FORMAT_NAME_AR_GB32:
+    case PIXMAN_FORMAT_NAME_ARGB32:
 	return pixman_format_create_masks (32,
 				    0xff000000,
 				    0x00ff0000,
 				    0x0000ff00,
 				    0x000000ff);
-    case PIXMAN_FORMAT_NAME_RG_B24:
+    case PIXMAN_FORMAT_NAME_RGB24:
 	return pixman_format_create_masks (32,
 				    0x0,
 				    0xff0000,
diff --git a/pixman/src/icimage.c b/pixman/src/icimage.c
index be099e85..8a17d514 100644
--- a/pixman/src/icimage.c
+++ b/pixman/src/icimage.c
@@ -346,7 +346,7 @@ IcClipImageSrc (pixman_region16_t	*region,
 #define NEXT_PTR(_type) ((_type) ulist++->ptr)
 
 int
-pixman_image_tChange (pixman_image_t		*image,
+pixman_image_change (pixman_image_t		*image,
 	       Mask		vmask,
 	       unsigned int	*vlist,
 	       DevUnion		*ulist,
@@ -413,7 +413,7 @@ pixman_image_tChange (pixman_image_t		*image,
 		} else {
 		    clipType = CT_NONE;
 		}
-		error = pixman_image_tChangeClip (image, clipType,
+		error = pixman_image_change_clip (image, clipType,
 					   (void *)mask, 0);
 		break;
 	    }
diff --git a/pixman/src/icimage.h b/pixman/src/icimage.h
index ece6951a..0c37666e 100644
--- a/pixman/src/icimage.h
+++ b/pixman/src/icimage.h
@@ -76,17 +76,17 @@ typedef struct _IndexFormat {
 */
 
 /*
-typedef struct _pixman_format_t {
+typedef struct pixman_format {
     uint32_t	    id;
     uint32_t	    format;
     unsigned char   type;
     unsigned char   depth;
     DirectFormatRec direct;
     IndexFormatRec  index;
-} pixman_format_tRec;
+} pixman_format_t;
 */
 
-struct _pixman_image_t {
+struct pixman_image {
     IcPixels	    *pixels;
     pixman_format_t	    image_format;
     int		    format_code;
@@ -103,7 +103,7 @@ struct _pixman_image_t {
     unsigned int    componentAlpha : 1;
     unsigned int    unused : 23;
 
-    struct _pixman_image_t *alphaMap;
+    struct pixman_image *alphaMap;
     IcPoint	    alphaOrigin;
 
     IcPoint 	    clipOrigin;
@@ -314,16 +314,16 @@ IcBuildCompositeOperand (pixman_image_t	    *image,
 
 extern void __internal_linkage
 pixman_compositeGeneral (pixman_operator_t	op,
-		    pixman_image_t	*iSrc,
-		    pixman_image_t	*iMask,
-		    pixman_image_t	*iDst,
-		    int16_t	xSrc,
-		    int16_t	ySrc,
-		    int16_t	xMask,
-		    int16_t	yMask,
-		    int16_t	xDst,
-		    int16_t	yDst,
-		    uint16_t	width,
-		    uint16_t	height);
+			 pixman_image_t	*iSrc,
+			 pixman_image_t	*iMask,
+			 pixman_image_t	*iDst,
+			 int16_t	xSrc,
+			 int16_t	ySrc,
+			 int16_t	xMask,
+			 int16_t	yMask,
+			 int16_t	xDst,
+			 int16_t	yDst,
+			 uint16_t	width,
+			 uint16_t	height);
 
 #endif /* _IC_MIPICT_H_ */
diff --git a/pixman/src/icint.h b/pixman/src/icint.h
index be9d7410..1f8a4162 100644
--- a/pixman/src/icint.h
+++ b/pixman/src/icint.h
@@ -109,7 +109,7 @@ typedef unsigned int	Mask;
 #define IC_STIP_ODDPTR(p)	((((long) (p)) & (IC_MASK >> 3)) != 0)
     
 #define IcStipStrideToBitsStride(s) (((s) >> (IC_SHIFT - IC_STIP_SHIFT)))
-#define pixman_bits_tStrideToStipStride(s) (((s) << (IC_SHIFT - IC_STIP_SHIFT)))
+#define IcBitsStrideToStipStride(s) (((s) << (IC_SHIFT - IC_STIP_SHIFT)))
     
 #define IcFullMask(n)   ((n) == IC_UNIT ? IC_ALLONES : ((((pixman_bits_t) 1) << n) - 1))
 
@@ -164,7 +164,7 @@ extern void IcSetBits (IcStip *bits, int stride, IcStip data);
 #define IcRightStipMask(x)  ( ((IC_STIP_UNIT - (x)) & IC_STIP_MASK) ? \
 			     IcScrLeft(IC_STIP_ALLONES,(IC_STIP_UNIT - (x)) & IC_STIP_MASK) : 0)
 
-#define pixman_bits_tMask(x,w)	(IcScrRight(IC_ALLONES,(x) & IC_MASK) & \
+#define IcBitsMask(x,w)	(IcScrRight(IC_ALLONES,(x) & IC_MASK) & \
 			 IcScrLeft(IC_ALLONES,(IC_UNIT - ((x) + (w))) & IC_MASK))
 
 #define IcStipMask(x,w)	(IcStipRight(IC_STIP_ALLONES,(x) & IC_STIP_MASK) & \
@@ -705,7 +705,7 @@ IcStipple (pixman_bits_t   *dst,
 	   int	    yRot);
 
 /* XXX: Is depth redundant here? */
-struct _pixman_format_t {
+struct pixman_format {
     int		format_code;
     int		depth;
     int		red, redMask;
diff --git a/pixman/src/icrect.c b/pixman/src/icrect.c
index 24125326..a62862cb 100644
--- a/pixman/src/icrect.c
+++ b/pixman/src/icrect.c
@@ -24,7 +24,7 @@
 
 /* XXX: I haven't ported this yet
 static void
-pixman_color_tRects (pixman_image_t	 *dst,
+pixman_color_rects (pixman_image_t	 *dst,
 	      pixman_image_t	 *clipPict,
 	      pixman_color_t	 *color,
 	      int	 nRect,
@@ -108,11 +108,11 @@ pixman_fill_rectangles (pixman_operator_t		op,
 	color_s.red = color_s.green = color_s.blue = color_s.alpha = 0;
 
 /* XXX: Really need this to optimize solid rectangles
-    if (op == pixman_operator_tSource || op == PIXMAN_OPERATOR_CLEAR)
+    if (op == PIXMAN_OPERATOR_SOURCE || op == PIXMAN_OPERATOR_CLEAR)
     {
-	pixman_color_tRects (dst, dst, &color_s, nRects, rects, 0, 0);
+	pixman_color_rects (dst, dst, &color_s, nRects, rects, 0, 0);
 	if (dst->alphaMap)
-	    pixman_color_tRects (dst->alphaMap, dst,
+	    pixman_color_rects (dst->alphaMap, dst,
 			  &color_s, nRects, rects,
 			  dst->alphaOrigin.x,
 			  dst->alphaOrigin.y);
diff --git a/pixman/src/ictrap.c b/pixman/src/ictrap.c
index 6f9db62a..607fa6d9 100644
--- a/pixman/src/ictrap.c
+++ b/pixman/src/ictrap.c
@@ -58,7 +58,7 @@ IcCreateAlphaPicture (pixman_image_t	*dst,
 	pixman_format_destroy (format);
 
     /* XXX: Is this a reasonable way to clear the image? Would
-       probably be preferable to use pixman_image_tFillRectangle once such a
+       probably be preferable to use pixman_image_fill_rectangle once such a
        beast exists. */
     memset (image->pixels->data, 0, height * image->pixels->stride);
 
diff --git a/pixman/src/pixman.h b/pixman/src/pixman.h
index 358af9a6..46a9a775 100644
--- a/pixman/src/pixman.h
+++ b/pixman/src/pixman.h
@@ -54,7 +54,7 @@ ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
 SOFTWARE.
 
 ******************************************************************/
-/* $Id: pixman.h,v 1.12 2004-01-23 05:05:08 rworth Exp $ */
+/* $Id: pixman.h,v 1.13 2004-04-16 15:32:53 cworth Exp $ */
 
 /* libic.h */
 
@@ -98,9 +98,9 @@ extern "C" {
 
 /* pixregion.h */
 
-typedef struct _pixman_region16_t pixman_region16_t;
+typedef struct pixman_region16 pixman_region16_t;
 
-typedef struct _pixman_box16_t {
+typedef struct pixman_box16 {
     short x1, y1, x2, y2;
 } pixman_box16_t;
 
@@ -136,7 +136,7 @@ pixman_region_union (pixman_region16_t *newReg, pixman_region16_t *reg1, pixman_
 
 pixman_region_status_t
 pixman_region_union_rect(pixman_region16_t *dest, pixman_region16_t *source,
-		   int x, int y, unsigned int width, unsigned int height);
+			 int x, int y, unsigned int width, unsigned int height);
 
 pixman_region_status_t
 pixman_region_subtract (pixman_region16_t *regD, pixman_region16_t *regM, pixman_region16_t *regS);
@@ -151,7 +151,7 @@ RectsTopixman_region16_t (int nrects, xRectanglePtr prect, int ctype);
 
 /* querying */
 
-/* XXX: These should proably be combined: pixman_region16_tGetRects? */
+/* XXX: These should proably be combined: pixman_region_get_rects? */
 int
 pixman_region_num_rects (pixman_region16_t *region);
 
@@ -200,7 +200,7 @@ pixman_region_empty (pixman_region16_t *region);
 
 
 /* icformat.c */
-typedef enum _pixman_operator_t {
+typedef enum pixman_operator {
     PIXMAN_OPERATOR_CLEAR,
     PIXMAN_OPERATOR_SRC,
     PIXMAN_OPERATOR_DST,
@@ -217,37 +217,36 @@ typedef enum _pixman_operator_t {
     PIXMAN_OPERATOR_SATURATE
 } pixman_operator_t;
 
-
-typedef enum _pixman_format_tName {
-    PIXMAN_FORMAT_NAME_AR_GB32,
-    PIXMAN_FORMAT_NAME_RG_B24,
+typedef enum pixman_format_name {
+    PIXMAN_FORMAT_NAME_ARGB32,
+    PIXMAN_FORMAT_NAME_RGB24,
     PIXMAN_FORMAT_NAME_A8,
     PIXMAN_FORMAT_NAME_A1
-} pixman_format_tName;
+} pixman_format_name_t;
 
-typedef struct _pixman_format_t pixman_format_t;
+typedef struct pixman_format pixman_format_t;
 
 pixman_format_t *
-pixman_format_create (pixman_format_tName name);
+pixman_format_create (pixman_format_name_t name);
 
 pixman_format_t *
 pixman_format_create_masks (int bpp,
-		     int alpha_mask,
-		     int red_mask,
-		     int green_mask,
-		     int blue_mask);
+			    int alpha_mask,
+			    int red_mask,
+			    int green_mask,
+			    int blue_mask);
 
 void
 pixman_format_destroy (pixman_format_t *format);
 
 /* icimage.c */
 
-typedef struct _pixman_image_t	pixman_image_t;
+typedef struct pixman_image pixman_image_t;
 
 pixman_image_t *
 pixman_image_create (pixman_format_t	*format,
-	       int	width,
-	       int	height);
+		     int	width,
+		     int	height);
 
 /*
  * This single define controls the basic size of data manipulated
@@ -269,47 +268,50 @@ typedef uint32_t pixman_bits_t;
 #endif
 
 pixman_image_t *
-pixman_image_create_for_data (pixman_bits_t *data, pixman_format_t *format, int width, int height, int bpp, int stride);
+pixman_image_create_for_data (pixman_bits_t *data,
+			      pixman_format_t *format,
+			      int width, int height,
+			      int bpp, int stride);
 
 void
 pixman_image_destroy (pixman_image_t *image);
 
 int
 pixman_image_set_clip_region (pixman_image_t	*image,
-		      pixman_region16_t	*region);
+			      pixman_region16_t	*region);
 
 typedef int pixman_fixed16_16_t;
 
-typedef struct _pixman_point_fixed_t {
+typedef struct pixman_point_fixed {
     pixman_fixed16_16_t  x, y;
 } pixman_point_fixed_t;
 
-typedef struct _pixman_line_fixed_t {
+typedef struct pixman_line_fixed {
     pixman_point_fixed_t	p1, p2;
 } pixman_line_fixed_t;
 
 /* XXX: It's goofy that pixman_rectangle_t has integers while all the other
    datatypes have fixed-point values. (Though by design,
    pixman_fill_rectangles is designed to fill only whole pixels) */
-typedef struct _pixman_rectangle_t {
+typedef struct pixman_rectangle {
     short x, y;
     unsigned short width, height;
 } pixman_rectangle_t;
 
-typedef struct _pixman_triangle_t {
+typedef struct pixman_triangle {
     pixman_point_fixed_t	p1, p2, p3;
 } pixman_triangle_t;
 
-typedef struct _pixman_trapezoid_t {
+typedef struct pixman_trapezoid {
     pixman_fixed16_16_t  top, bottom;
     pixman_line_fixed_t	left, right;
 } pixman_trapezoid_t;
 
-typedef struct _pixman_vector_t {
+typedef struct pixman_vector {
     pixman_fixed16_16_t    vector[3];
 } pixman_vector_t;
 
-typedef struct _pixman_transform_t {
+typedef struct pixman_transform {
     pixman_fixed16_16_t  matrix[3][3];
 } pixman_transform_t;
 
@@ -322,16 +324,16 @@ typedef enum {
 } pixman_filter_t;
 
 int
-pixman_image_set_transform (pixman_image_t		*image,
-		     pixman_transform_t	*transform);
+pixman_image_set_transform (pixman_image_t	*image,
+			    pixman_transform_t	*transform);
 
 void
 pixman_image_set_repeat (pixman_image_t	*image,
-		  int		repeat);
+			 int		repeat);
 
 void
-pixman_image_set_filter (pixman_image_t	*image,
-		  pixman_filter_t	filter);
+pixman_image_set_filter (pixman_image_t		*image,
+			 pixman_filter_t	filter);
 
 int
 pixman_image_get_width (pixman_image_t	*image);
@@ -353,8 +355,8 @@ pixman_image_get_data (pixman_image_t	*image);
 
 /* iccolor.c */
 
-/* XXX: Do we really need a struct here? Only pixman_rectangle_ts uses this. */
-typedef struct {
+/* XXX: Do we really need a struct here? Only pixman_rectangle_t uses this. */
+typedef struct pixman_color {
     unsigned short   red;
     unsigned short   green;
     unsigned short   blue;
@@ -363,89 +365,88 @@ typedef struct {
 
 void
 pixman_color_to_pixel (const pixman_format_t	*format,
-		const pixman_color_t	*color,
-		pixman_bits_t		*pixel);
+		       const pixman_color_t	*color,
+		       pixman_bits_t		*pixel);
 
 void
 pixman_pixel_to_color (const pixman_format_t	*format,
-		pixman_bits_t		pixel,
-		pixman_color_t		*color);
+		       pixman_bits_t		pixel,
+		       pixman_color_t		*color);
 
 /* icrect.c */
 
 void
 pixman_fill_rectangle (pixman_operator_t	op,
-		 pixman_image_t	*dst,
-		 const pixman_color_t	*color,
-		 int		x,
-		 int		y,
-		 unsigned int	width,
-		 unsigned int	height);
+		       pixman_image_t		*dst,
+		       const pixman_color_t	*color,
+		       int			x,
+		       int			y,
+		       unsigned int		width,
+		       unsigned int		height);
 
 void
 pixman_fill_rectangles (pixman_operator_t		op,
-		  pixman_image_t		*dst,
-		  const pixman_color_t		*color,
-		  const pixman_rectangle_t	*rects,
-		  int			nRects);
+			pixman_image_t			*dst,
+			const pixman_color_t		*color,
+			const pixman_rectangle_t	*rects,
+			int				nRects);
 
 /* ictrap.c */
 
-/* XXX: Switch to enum for op */
 void
-pixman_composite_trapezoids (pixman_operator_t	op,
-		       pixman_image_t		*src,
-		       pixman_image_t		*dst,
-		       int		xSrc,
-		       int		ySrc,
-		       const pixman_trapezoid_t *traps,
-		       int		ntrap);
+pixman_composite_trapezoids (pixman_operator_t		op,
+			     pixman_image_t		*src,
+			     pixman_image_t		*dst,
+			     int			xSrc,
+			     int			ySrc,
+			     const pixman_trapezoid_t *traps,
+			     int			ntrap);
 
 /* ictri.c */
 
 void
-pixman_composite_triangles (pixman_operator_t	op,
-		      pixman_image_t		*src,
-		      pixman_image_t		*dst,
-		      int		xSrc,
-		      int		ySrc,
-		      const pixman_triangle_t	*tris,
-		      int		ntris);
+pixman_composite_triangles (pixman_operator_t		op,
+			    pixman_image_t		*src,
+			    pixman_image_t		*dst,
+			    int				xSrc,
+			    int				ySrc,
+			    const pixman_triangle_t	*tris,
+			    int				ntris);
 
 void
 pixman_composite_tri_strip (pixman_operator_t		op,
-		     pixman_image_t		*src,
-		     pixman_image_t		*dst,
-		     int		xSrc,
-		     int		ySrc,
-		     const pixman_point_fixed_t	*points,
-		     int		npoints);
+			    pixman_image_t		*src,
+			    pixman_image_t		*dst,
+			    int				xSrc,
+			    int				ySrc,
+			    const pixman_point_fixed_t	*points,
+			    int				npoints);
 
 
 void
 pixman_composite_tri_fan (pixman_operator_t		op,
-		   pixman_image_t		*src,
-		   pixman_image_t		*dst,
-		   int			xSrc,
-		   int			ySrc,
-		   const pixman_point_fixed_t	*points,
-		   int			npoints);
+			  pixman_image_t		*src,
+			  pixman_image_t		*dst,
+			  int				xSrc,
+			  int				ySrc,
+			  const pixman_point_fixed_t	*points,
+			  int				npoints);
 
 /* ic.c */
 
 void
 pixman_composite (pixman_operator_t	op,
-	     pixman_image_t	*iSrc,
-	     pixman_image_t    *iMask,
-	     pixman_image_t    *iDst,
-	     int      	xSrc,
-	     int      	ySrc,
-	     int      	xMask,
-	     int      	yMask,
-	     int      	xDst,
-	     int      	yDst,
-	     int	width,
-	     int	height);
+		  pixman_image_t	*iSrc,
+		  pixman_image_t	*iMask,
+		  pixman_image_t	*iDst,
+		  int      		xSrc,
+		  int      		ySrc,
+		  int      		xMask,
+		  int      		yMask,
+		  int      		xDst,
+		  int      		yDst,
+		  int			width,
+		  int			height);
 
 
 
diff --git a/pixman/src/pixregion.c b/pixman/src/pixregion.c
index 62124437..2a03d2ea 100644
--- a/pixman/src/pixregion.c
+++ b/pixman/src/pixregion.c
@@ -68,15 +68,15 @@ SOFTWARE.
 #define assert(expr)
 #endif
 
-#define good(reg) assert(pixman_region16_tValidRegion(reg))
+#define good(reg) assert(pixman_region16_valid(reg))
 
 #define MIN(a,b) ((a) < (b) ? (a) : (b))
 #define MAX(a,b) ((a) > (b) ? (a) : (b))
 
 static pixman_box16_t pixman_region_emptyBox = {0, 0, 0, 0};
-static pixman_region16_tData pixman_region_emptyData = {0, 0};
+static pixman_region16_data_t pixman_region_emptyData = {0, 0};
 
-static pixman_region16_tData  pixman_brokendata = {0, 0};
+static pixman_region16_data_t  pixman_brokendata = {0, 0};
 static pixman_region16_t   pixman_brokenregion = { { 0, 0, 0, 0 }, &pixman_brokendata };
 
 static pixman_region_status_t
@@ -198,8 +198,8 @@ if (!(pReg)->data || (((pReg)->data->numRects + (n)) > (pReg)->data->size)) \
 #define DOWNSIZE(reg,numRects)						 \
 if (((numRects) < ((reg)->data->size >> 1)) && ((reg)->data->size > 50)) \
 {									 \
-    pixman_region16_tData * NewData;							 \
-    NewData = (pixman_region16_tData *)realloc((reg)->data, PIXREGION_SZOF(numRects));	 \
+    pixman_region16_data_t * NewData;							 \
+    NewData = (pixman_region16_data_t *)realloc((reg)->data, PIXREGION_SZOF(numRects));	 \
     if (NewData)							 \
     {									 \
 	NewData->size = (numRects);					 \
@@ -210,7 +210,7 @@ if (((numRects) < ((reg)->data->size >> 1)) && ((reg)->data->size > 50)) \
 
 #ifdef DEBUG
 int
-pixman_region16_tPrintRegion(rgn)
+pixman_region16_print(rgn)
     pixman_region16_t * rgn;
 {
     int num, size;
@@ -257,7 +257,7 @@ pixman_region16_tsEqual(reg1, reg2)
 }
 
 pixman_region_status_t
-pixman_region16_tValidRegion(reg)
+pixman_region16_valid(reg)
     pixman_region16_t * reg;
 {
     int i, numRects;
@@ -392,7 +392,7 @@ pixman_break (pixman_region16_t *region)
 static pixman_region_status_t
 pixman_rect_alloc(pixman_region16_t * region, int n)
 {
-    pixman_region16_tData *data;
+    pixman_region16_data_t *data;
     
     if (!region->data)
     {
@@ -419,7 +419,7 @@ pixman_rect_alloc(pixman_region16_t * region, int n)
 		n = 250;
 	}
 	n += region->data->numRects;
-	data = (pixman_region16_tData *)realloc(region->data, PIXREGION_SZOF(n));
+	data = (pixman_region16_data_t *)realloc(region->data, PIXREGION_SZOF(n));
 	if (!data)
 	    return pixman_break (region);
 	region->data = data;
@@ -671,7 +671,7 @@ pixman_op(
     pixman_box16_t *	    r2End;		    /* End of 2d region		     */
     short	    ybot;		    /* Bottom of intersection	     */
     short	    ytop;		    /* Top of intersection	     */
-    pixman_region16_tData *	    oldData;		    /* Old data for newReg	     */
+    pixman_region16_data_t *	    oldData;		    /* Old data for newReg	     */
     int		    prevBand;		    /* Index of start of
 					     * previous band in newReg       */
     int		    curBand;		    /* Index of start of current
@@ -708,7 +708,7 @@ pixman_op(
     assert(r1 != r1End);
     assert(r2 != r2End);
 
-    oldData = (pixman_region16_tData *)NULL;
+    oldData = (pixman_region16_data_t *)NULL;
     if (((newReg == reg1) && (newSize > 1)) ||
 	((newReg == reg2) && (numRects > 1)))
     {
@@ -862,7 +862,7 @@ pixman_op(
     {
 	newReg->extents = *PIXREGION_BOXPTR(newReg);
 	freeData(newReg);
-	newReg->data = (pixman_region16_tData *)NULL;
+	newReg->data = (pixman_region16_data_t *)NULL;
     }
     else
     {
@@ -1026,7 +1026,7 @@ pixman_region_intersect(newReg, reg1, reg2)
 	newReg->extents.x2 = MIN(reg1->extents.x2, reg2->extents.x2);
 	newReg->extents.y2 = MIN(reg1->extents.y2, reg2->extents.y2);
 	freeData(newReg);
-	newReg->data = (pixman_region16_tData *)NULL;
+	newReg->data = (pixman_region16_data_t *)NULL;
     }
     else if (!reg2->data && SUBSUMES(&reg2->extents, &reg1->extents))
     {
@@ -1278,7 +1278,7 @@ pixman_region_append(dstrgn, rgn)
     if (!rgn->data && (dstrgn->data == &pixman_region_emptyData))
     {
 	dstrgn->extents = rgn->extents;
-	dstrgn->data = (pixman_region16_tData *)NULL;
+	dstrgn->data = (pixman_region16_data_t *)NULL;
 	return PIXMAN_REGION_STATUS_SUCCESS;
     }
 
@@ -1493,7 +1493,7 @@ pixman_region_validate(badreg, pOverlap)
 	if ((numRects) == 1)
 	{
 	    freeData(badreg);
-	    badreg->data = (pixman_region16_tData *) NULL;
+	    badreg->data = (pixman_region16_data_t *) NULL;
 	}
 	else
 	{
@@ -1584,7 +1584,7 @@ pixman_region_validate(badreg, pOverlap)
 	rit->prevBand = 0;
 	rit->curBand = 0;
 	rit->reg.extents = *box;
-	rit->reg.data = (pixman_region16_tData *)NULL;
+	rit->reg.data = (pixman_region16_data_t *)NULL;
 	if (!pixman_rect_alloc(&rit->reg, (i+numRI) / numRI)) /* MUST force allocation */
 	    goto bail;
 NextRect: ;
@@ -1603,7 +1603,7 @@ NextRect: ;
 	if (reg->data->numRects == 1) /* keep unions happy below */
 	{
 	    freeData(reg);
-	    reg->data = (pixman_region16_tData *)NULL;
+	    reg->data = (pixman_region16_data_t *)NULL;
 	}
     }
 
@@ -1648,7 +1648,7 @@ pixman_region_rectsToRegion(nrects, prect, ctype)
     int			ctype;
 {
     pixman_region16_t *	region;
-    pixman_region16_tData *	pData;
+    pixman_region16_data_t *	pData;
     pixman_box16_t *	box;
     int        i;
     int			x1, y1, x2, y2;
@@ -1672,7 +1672,7 @@ pixman_region_rectsToRegion(nrects, prect, ctype)
 	    region->extents.y1 = y1;
 	    region->extents.x2 = x2;
 	    region->extents.y2 = y2;
-	    region->data = (pixman_region16_tData *)NULL;
+	    region->data = (pixman_region16_data_t *)NULL;
 	}
 	return region;
     }
@@ -1951,7 +1951,7 @@ pixman_region_inverse(newReg, reg1, invRect)
 	    return pixman_break (newReg);
 	newReg->extents = *invRect;
 	freeData(newReg);
-	newReg->data = (pixman_region16_tData *)NULL;
+	newReg->data = (pixman_region16_data_t *)NULL;
         return PIXMAN_REGION_STATUS_SUCCESS;
     }
 
@@ -1959,7 +1959,7 @@ pixman_region_inverse(newReg, reg1, invRect)
        do yucky substraction for overlaps, and
        just throw away rectangles in region 2 that aren't in region 1 */
     invReg.extents = *invRect;
-    invReg.data = (pixman_region16_tData *)NULL;
+    invReg.data = (pixman_region16_data_t *)NULL;
     if (!pixman_op(newReg, &invReg, reg1, pixman_region_subtractO, PIXMAN_REGION_STATUS_SUCCESS, PIXMAN_REGION_STATUS_FAILURE, &overlap))
 	return PIXMAN_REGION_STATUS_FAILURE;
 
@@ -2162,7 +2162,7 @@ pixman_region_translate (pixman_region16_t * region, int x, int y)
 	    {
 		region->extents = *PIXREGION_BOXPTR(region);
 		freeData(region);
-		region->data = (pixman_region16_tData *)NULL;
+		region->data = (pixman_region16_data_t *)NULL;
 	    }
 	    else
 		pixman_set_extents(region);
@@ -2172,7 +2172,7 @@ pixman_region_translate (pixman_region16_t * region, int x, int y)
 
 /* XXX: Do we need this?
 static pixman_region_status_t
-pixman_region16_tDataCopy(pixman_region16_t * dst, pixman_region16_t * src)
+pixman_region16_data_copy(pixman_region16_t * dst, pixman_region16_t * src)
 {
     good(dst);
     good(src);
@@ -2183,7 +2183,7 @@ pixman_region16_tDataCopy(pixman_region16_t * dst, pixman_region16_t * src)
     if (!src->data || !src->data->size)
     {
 	freeData(dst);
-	dst->data = (pixman_region16_tData *)NULL;
+	dst->data = (pixman_region16_data_t *)NULL;
 	return PIXMAN_REGION_STATUS_SUCCESS;
     }
     if (!dst->data || (dst->data->size < src->data->numRects))
@@ -2207,7 +2207,7 @@ pixman_region_reset(pixman_region16_t *region, pixman_box16_t *box)
     assert(box->y1<=box->y2);
     region->extents = *box;
     freeData(region);
-    region->data = (pixman_region16_tData *)NULL;
+    region->data = (pixman_region16_data_t *)NULL;
 }
 
 int
@@ -2254,7 +2254,7 @@ pixman_region_not_empty(region)
 
 /* XXX: Do we need this?
 static int
-pixman_region16_tBroken(pixman_region16_t * region)
+pixman_region16_broken(pixman_region16_t * region)
 {
     good(region);
     return (PIXREGION_NAR(region));
@@ -2282,7 +2282,7 @@ pixman_region_extents(region)
 
 #define ExchangeSpans(a, b)				    \
 {							    \
-    pixman_region16_tPoint tpt;					    \
+    pixman_region16_point_t tpt;					    \
     int    tw;						    \
 							    \
     tpt = spans[a]; spans[a] = spans[b]; spans[b] = tpt;    \
@@ -2295,13 +2295,13 @@ pixman_region_extents(region)
 */
 
 static void QuickSortSpans(
-    pixman_region16_tPoint spans[],
+    pixman_region16_point_t spans[],
     int	    widths[],
     int	    numSpans)
 {
     int	    y;
     int	    i, j, m;
-    pixman_region16_tPoint *r;
+    pixman_region16_point_t *r;
 
     /* Always called with numSpans > 1 */
     /* Sorts only by y, doesn't bother to sort by x */
@@ -2321,7 +2321,7 @@ static void QuickSortSpans(
 		if (yprev > y)
 		{
 		    /* spans[i] is out of order.  Move into proper location. */
-		    pixman_region16_tPoint tpt;
+		    pixman_region16_point_t tpt;
 		    int	    tw, k;
 
 		    for (j = 0; y >= spans[j].y; j++) {}
@@ -2400,16 +2400,16 @@ static void QuickSortSpans(
 
 #ifdef XXX_DO_WE_NEED_THIS
 static int
-pixman_region16_tClipSpans(
+pixman_region16_clip_spans(
     pixman_region16_t 		*prgnDst,
-    pixman_region16_tPoint 	*ppt,
+    pixman_region16_point_t 	*ppt,
     int	    		*pwidth,
     int			nspans,
-    pixman_region16_tPoint 	*pptNew,
+    pixman_region16_point_t 	*pptNew,
     int			*pwidthNew,
     int			fSorted)
 {
-    pixman_region16_tPoint 	*pptLast;
+    pixman_region16_point_t 	*pptLast;
     int			*pwidthNewStart;	/* the vengeance of Xerox! */
     int	y, x1, x2;
     int	numRects;
@@ -2517,7 +2517,7 @@ pixman_region16_tClipSpans(
 
 /* find the band in a region with the most rectangles */
 static int
-pixman_region16_tFindMaxBand(pixman_region16_t * prgn)
+pixman_region16_find_max_band(pixman_region16_t * prgn)
 {
     int nbox;
     pixman_box16_t * pbox;
diff --git a/pixman/src/pixregionint.h b/pixman/src/pixregionint.h
index 1c218afc..86ff8e65 100644
--- a/pixman/src/pixregionint.h
+++ b/pixman/src/pixregionint.h
@@ -44,28 +44,28 @@ ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
 SOFTWARE.
 
 ******************************************************************/
-/* $Id: pixregionint.h,v 1.6 2003-12-10 23:24:33 dajobe Exp $ */
+/* $Id: pixregionint.h,v 1.7 2004-04-16 15:32:53 cworth Exp $ */
 
 #ifndef _PIXREGIONINT_H_
 #define _PIXREGIONINT_H_
 
 #include "pixman.h"
 
-typedef struct _pixman_region16_tData {
+typedef struct pixman_region16_data {
     long		size;
     long		numRects;
     /* XXX: And why, exactly, do we have this bogus struct definition? */
 /*  pixman_box16_t	rects[size];   in memory but not explicitly declared */
-} pixman_region16_tData;
+} pixman_region16_data_t;
 
-struct _pixman_region16_t {
+struct pixman_region16 {
     pixman_box16_t	extents;
-    pixman_region16_tData	*data;
+    pixman_region16_data_t	*data;
 };
 
-typedef struct _pixman_region16_tPoint {
+typedef struct pixman_region16_point {
     int x, y;
-} pixman_region16_tPoint;
+} pixman_region16_point_t;
 
 #define PIXREGION_NIL(reg) ((reg)->data && !(reg)->data->numRects)
 /* not a region */
@@ -78,6 +78,6 @@ typedef struct _pixman_region16_tPoint {
 #define PIXREGION_BOX(reg,i) (&PIXREGION_BOXPTR(reg)[i])
 #define PIXREGION_TOP(reg) PIXREGION_BOX(reg, (reg)->data->numRects)
 #define PIXREGION_END(reg) PIXREGION_BOX(reg, (reg)->data->numRects - 1)
-#define PIXREGION_SZOF(n) (sizeof(pixman_region16_tData) + ((n) * sizeof(pixman_box16_t)))
+#define PIXREGION_SZOF(n) (sizeof(pixman_region16_data_t) + ((n) * sizeof(pixman_box16_t)))
 
 #endif /* _PIXREGIONINT_H_ */