xps: use fitz runtime and remove ghostscript specific code so it compiles.

1 files changed, 89 insertions, 351 deletions

diff --git a/xps/xpsgradient.c b/xps/xpsgradient.c
index 0c6bcf60..3bb95824 100644
--- a/xps/xpsgradient.c
+++ b/xps/xpsgradient.c
@@ -1,19 +1,5 @@
-/* Copyright (C) 2006-2010 Artifex Software, Inc.
-   All Rights Reserved.
-
-   This software is provided AS-IS with no warranty, either express or
-   implied.
-
-   This software is distributed under license and may not be copied, modified
-   or distributed except as expressly authorized under the terms of that
-   license.  Refer to licensing information at http://www.artifex.com/
-   or contact Artifex Software, Inc.,  7 Mt. Lassen  Drive - Suite A-134,
-   San Rafael, CA  94903, U.S.A., +1(415)492-9861, for further information.
-*/
-
-/* XPS interpreter - gradient support */
-
-#include "ghostxps.h"
+#include "fitz.h"
+#include "muxps.h"
 
 #define MAX_STOPS 256
 
@@ -52,11 +38,9 @@ static int
 xps_parse_gradient_stops(xps_context_t *ctx, char *base_uri, xps_item_t *node,
 	struct stop *stops, int maxcount)
 {
-	unsigned short sample_in[8], sample_out[8]; /* XPS allows up to 8 bands */
-	gsicc_rendering_param_t rendering_params;
-	gsicc_link_t *icclink;
-	gs_color_space *colorspace;
+	fz_colorspace *colorspace;
 	float sample[8];
+	float rgb[3];
 	int before, after;
 	int count;
 	int i, k;
@@ -77,53 +61,22 @@ xps_parse_gradient_stops(xps_context_t *ctx, char *base_uri, xps_item_t *node,
 
 				xps_parse_color(ctx, base_uri, color, &colorspace, sample);
 
-				/* Set the rendering parameters */
-				rendering_params.black_point_comp = BP_ON;
-				rendering_params.object_type = GS_PATH_TAG;
-				rendering_params.rendering_intent = gsPERCEPTUAL;
-
-				/* Get link to map from source to sRGB */
-				icclink = gsicc_get_link((gs_imager_state*) ctx->pgs,
-										 NULL, colorspace, ctx->srgb,
-										 &rendering_params, ctx->memory, false);
-
-				if (icclink != NULL && !icclink->is_identity)
-				{
-					/* Transform the color */
-					int num_colors = gsicc_getsrc_channel_count(colorspace->cmm_icc_profile_data);
-					for (i = 0; i < num_colors; i++)
-					{
-						sample_in[i] = sample[i+1]*65535;
-					}
-					gscms_transform_color(icclink, sample_in, sample_out, 2, NULL);
-
-					stops[count].color[0] = sample[0]; /* Alpha */
-					stops[count].color[1] = (float) sample_out[0] / 65535.0; /* sRGB */
-					stops[count].color[2] = (float) sample_out[1] / 65535.0;
-					stops[count].color[3] = (float) sample_out[2] / 65535.0;
-				}
-				else
-				{
-					stops[count].color[0] = sample[0];
-					stops[count].color[1] = sample[1];
-					stops[count].color[2] = sample[2];
-					stops[count].color[3] = sample[3];
-				}
+				fz_convertcolor(colorspace, sample + 1, fz_devicergb, rgb);
+
+				stops[count].color[0] = sample[0];
+				stops[count].color[1] = rgb[0];
+				stops[count].color[2] = rgb[1];
+				stops[count].color[3] = rgb[2];
 
 				count ++;
 			}
 		}
-
-		if (icclink != NULL)
-			gsicc_release_link(icclink);
-		icclink = NULL;
 		node = xps_next(node);
-
 	}
 
 	if (count == 0)
 	{
-		gs_warn("gradient brush has no gradient stops");
+		fz_warn("gradient brush has no gradient stops");
 		stops[0].offset = 0;
 		stops[0].color[0] = 1;
 		stops[0].color[1] = 0;
@@ -138,7 +91,7 @@ xps_parse_gradient_stops(xps_context_t *ctx, char *base_uri, xps_item_t *node,
 	}
 
 	if (count == maxcount)
-		gs_warn("gradient brush exceeded maximum number of gradient stops");
+		fz_warn("gradient brush exceeded maximum number of gradient stops");
 
 	/* Postprocess to make sure the range of offsets is 0.0 to 1.0 */
 
@@ -227,219 +180,6 @@ xps_gradient_has_transparent_colors(struct stop *stops, int count)
 }
 
 /*
- * Create a Function object to map [0..1] to RGB colors
- * based on the gradient stop arrays.
- *
- * We do this by creating a stitching function that joins
- * a series of linear functions (one linear function
- * for each gradient stop-pair).
- */
-
-static gs_function_t *
-xps_create_gradient_stop_function(xps_context_t *ctx, struct stop *stops, int count, int opacity_only)
-{
-	gs_function_1ItSg_params_t sparams;
-	gs_function_ElIn_params_t lparams;
-	gs_function_t *sfunc;
-	gs_function_t *lfunc;
-
-	float *domain, *range, *c0, *c1, *bounds, *encode;
-	const gs_function_t **functions;
-
-	int code;
-	int k;
-	int i;
-
-	k = count - 1; /* number of intervals / functions */
-
-	domain = xps_alloc(ctx, 2 * sizeof(float));
-	domain[0] = 0.0;
-	domain[1] = 1.0;
-	sparams.m = 1;
-	sparams.Domain = domain;
-
-	range = xps_alloc(ctx, 6 * sizeof(float));
-	range[0] = 0.0;
-	range[1] = 1.0;
-	range[2] = 0.0;
-	range[3] = 1.0;
-	range[4] = 0.0;
-	range[5] = 1.0;
-	sparams.n = 3;
-	sparams.Range = range;
-
-	functions = xps_alloc(ctx, k * sizeof(void*));
-	bounds = xps_alloc(ctx, (k - 1) * sizeof(float));
-	encode = xps_alloc(ctx, (k * 2) * sizeof(float));
-
-	sparams.k = k;
-	sparams.Functions = functions;
-	sparams.Bounds = bounds;
-	sparams.Encode = encode;
-
-	for (i = 0; i < k; i++)
-	{
-		domain = xps_alloc(ctx, 2 * sizeof(float));
-		domain[0] = 0.0;
-		domain[1] = 1.0;
-		lparams.m = 1;
-		lparams.Domain = domain;
-
-		range = xps_alloc(ctx, 6 * sizeof(float));
-		range[0] = 0.0;
-		range[1] = 1.0;
-		range[2] = 0.0;
-		range[3] = 1.0;
-		range[4] = 0.0;
-		range[5] = 1.0;
-		lparams.n = 3;
-		lparams.Range = range;
-
-		c0 = xps_alloc(ctx, 3 * sizeof(float));
-		lparams.C0 = c0;
-
-		c1 = xps_alloc(ctx, 3 * sizeof(float));
-		lparams.C1 = c1;
-
-		if (opacity_only)
-		{
-			c0[0] = stops[i].color[0];
-			c0[1] = stops[i].color[0];
-			c0[2] = stops[i].color[0];
-
-			c1[0] = stops[i+1].color[0];
-			c1[1] = stops[i+1].color[0];
-			c1[2] = stops[i+1].color[0];
-		}
-		else
-		{
-			c0[0] = stops[i].color[1];
-			c0[1] = stops[i].color[2];
-			c0[2] = stops[i].color[3];
-
-			c1[0] = stops[i+1].color[1];
-			c1[1] = stops[i+1].color[2];
-			c1[2] = stops[i+1].color[3];
-		}
-
-		lparams.N = 1;
-
-		code = gs_function_ElIn_init(&lfunc, &lparams, ctx->memory);
-		if (code < 0)
-		{
-			gs_rethrow(code, "gs_function_ElIn_init failed");
-			return NULL;
-		}
-
-		functions[i] = lfunc;
-
-		if (i > 0)
-			bounds[i - 1] = stops[i].offset;
-
-		encode[i * 2 + 0] = 0.0;
-		encode[i * 2 + 1] = 1.0;
-	}
-
-	code = gs_function_1ItSg_init(&sfunc, &sparams, ctx->memory);
-	if (code < 0)
-	{
-		gs_rethrow(code, "gs_function_1ItSg_init failed");
-		return NULL;
-	}
-
-	return sfunc;
-}
-
-/*
- * Shadings and functions are ghostscript type objects,
- * and as such rely on the garbage collector for cleanup.
- * We can't have none of that here, so we have to
- * write our own destructors.
- */
-
-static void
-xps_free_gradient_stop_function(xps_context_t *ctx, gs_function_t *func)
-{
-	gs_function_t *lfunc;
-	gs_function_1ItSg_params_t *sparams;
-	gs_function_ElIn_params_t *lparams;
-	int i;
-
-	sparams = (gs_function_1ItSg_params_t*) &func->params;
-	xps_free(ctx, (void*)sparams->Domain);
-	xps_free(ctx, (void*)sparams->Range);
-
-	for (i = 0; i < sparams->k; i++)
-	{
-		lfunc = (gs_function_t*) sparams->Functions[i]; /* discard const */
-		lparams = (gs_function_ElIn_params_t*) &lfunc->params;
-		xps_free(ctx, (void*)lparams->Domain);
-		xps_free(ctx, (void*)lparams->Range);
-		xps_free(ctx, (void*)lparams->C0);
-		xps_free(ctx, (void*)lparams->C1);
-		xps_free(ctx, lfunc);
-	}
-
-	xps_free(ctx, (void*)sparams->Bounds);
-	xps_free(ctx, (void*)sparams->Encode);
-	xps_free(ctx, (void*)sparams->Functions);
-	xps_free(ctx, func);
-}
-
-/*
- * For radial gradients that have a cone drawing we have to
- * reverse the direction of the gradient because we draw
- * the shading in the opposite direction with the
- * big circle first.
- */
-static gs_function_t *
-xps_reverse_function(xps_context_t *ctx, gs_function_t *func, float *fary, void *vary)
-{
-	gs_function_1ItSg_params_t sparams;
-	gs_function_t *sfunc;
-	int code;
-
-	/* take from stack allocated arrays that the caller provides */
-	float *domain = fary + 0;
-	float *range = fary + 2;
-	float *encode = fary + 2 + 6;
-	const gs_function_t **functions = vary;
-
-	domain[0] = 0.0;
-	domain[1] = 1.0;
-
-	range[0] = 0.0;
-	range[1] = 1.0;
-	range[2] = 0.0;
-	range[3] = 1.0;
-	range[4] = 0.0;
-	range[5] = 1.0;
-
-	functions[0] = func;
-
-	encode[0] = 1.0;
-	encode[1] = 0.0;
-
-	sparams.m = 1;
-	sparams.Domain = domain;
-	sparams.n = 3;
-	sparams.Range = range;
-	sparams.k = 1;
-	sparams.Functions = functions;
-	sparams.Bounds = NULL;
-	sparams.Encode = encode;
-
-	code = gs_function_1ItSg_init(&sfunc, &sparams, ctx->memory);
-	if (code < 0)
-	{
-		gs_rethrow(code, "gs_function_1ItSg_init failed");
-		return NULL;
-	}
-
-	return sfunc;
-}
-
-/*
  * Radial gradients map more or less to Radial shadings.
  * The inner circle is always a point.
  * The outer circle is actually an ellipse,
@@ -448,10 +188,11 @@ xps_reverse_function(xps_context_t *ctx, gs_function_t *func, float *fary, void
 
 static int
 xps_draw_one_radial_gradient(xps_context_t *ctx,
-		gs_function_t *func, int extend,
+		int extend,
 		float x0, float y0, float r0,
 		float x1, float y1, float r1)
 {
+#if 0
 	gs_memory_t *mem = ctx->memory;
 	gs_shading_t *shading;
 	gs_shading_R_params_t params;
@@ -476,7 +217,7 @@ xps_draw_one_radial_gradient(xps_context_t *ctx,
 
 	code = gs_shading_R_init(&shading, &params, mem);
 	if (code < 0)
-		return gs_rethrow(code, "gs_shading_R_init failed");
+		return fz_rethrow(code, "gs_shading_R_init failed");
 
 	gs_setsmoothness(ctx->pgs, 0.02);
 
@@ -484,11 +225,11 @@ xps_draw_one_radial_gradient(xps_context_t *ctx,
 	if (code < 0)
 	{
 		gs_free_object(mem, shading, "gs_shading_R");
-		return gs_rethrow(code, "gs_shfill failed");
+		return fz_rethrow(code, "gs_shfill failed");
 	}
 
 	gs_free_object(mem, shading, "gs_shading_R");
-
+#endif
 	return 0;
 }
 
@@ -498,9 +239,10 @@ xps_draw_one_radial_gradient(xps_context_t *ctx,
 
 static int
 xps_draw_one_linear_gradient(xps_context_t *ctx,
-		gs_function_t *func, int extend,
+		int extend,
 		float x0, float y0, float x1, float y1)
 {
+#if 0
 	gs_memory_t *mem = ctx->memory;
 	gs_shading_t *shading;
 	gs_shading_A_params_t params;
@@ -523,7 +265,7 @@ xps_draw_one_linear_gradient(xps_context_t *ctx,
 
 	code = gs_shading_A_init(&shading, &params, mem);
 	if (code < 0)
-		return gs_rethrow(code, "gs_shading_A_init failed");
+		return fz_rethrow(code, "gs_shading_A_init failed");
 
 	gs_setsmoothness(ctx->pgs, 0.02);
 
@@ -531,11 +273,11 @@ xps_draw_one_linear_gradient(xps_context_t *ctx,
 	if (code < 0)
 	{
 		gs_free_object(mem, shading, "gs_shading_A");
-		return gs_rethrow(code, "gs_shfill failed");
+		return fz_rethrow(code, "gs_shfill failed");
 	}
 
 	gs_free_object(mem, shading, "gs_shading_A");
-
+#endif
 	return 0;
 }
 
@@ -555,9 +297,9 @@ static inline float point_inside_circle(float px, float py, float x, float y, fl
 }
 
 static int
-xps_draw_radial_gradient(xps_context_t *ctx, xps_item_t *root, int spread, gs_function_t *func)
+xps_draw_radial_gradient(xps_context_t *ctx, xps_item_t *root, int spread)
 {
-	gs_rect bbox;
+	fz_rect bbox;
 	float x0, y0, r0;
 	float x1, y1, r1;
 	float xrad = 1;
@@ -583,8 +325,8 @@ xps_draw_radial_gradient(xps_context_t *ctx, xps_item_t *root, int spread, gs_fu
 		yrad = atof(radius_y_att);
 
 	/* scale the ctm to make ellipses */
-	gs_gsave(ctx->pgs);
-	gs_scale(ctx->pgs, 1.0, yrad / xrad);
+//	gs_gsave(ctx->pgs);
+//	gs_scale(ctx->pgs, 1.0, yrad / xrad);
 
 	invscale = xrad / yrad;
 	y0 = y0 * invscale;
@@ -602,7 +344,7 @@ xps_draw_radial_gradient(xps_context_t *ctx, xps_item_t *root, int spread, gs_fu
 	{
 		if (!point_inside_circle(x0, y0, x1, y1, r1))
 		{
-			gs_function_t *reverse;
+#if 0
 			float in[1];
 			float out[4];
 			float fary[10];
@@ -612,7 +354,6 @@ xps_draw_radial_gradient(xps_context_t *ctx, xps_item_t *root, int spread, gs_fu
 			 * gradients when the radial shading is a cone. In this case
 			 * we fill the background ourselves.
 			 */
-
 			in[0] = 1.0;
 			out[0] = 1.0;
 			out[1] = 0.0;
@@ -637,30 +378,25 @@ xps_draw_radial_gradient(xps_context_t *ctx, xps_item_t *root, int spread, gs_fu
 			 * have to reverse the direction of the function to compensate.
 			 */
 
-			reverse = xps_reverse_function(ctx, func, fary, vary);
-			if (!reverse)
-			{
-				gs_grestore(ctx->pgs);
-				return gs_rethrow(-1, "could not create the reversed function");
-			}
+//			reverse = xps_reverse_function(ctx, func, fary, vary);
 
 			code = xps_draw_one_radial_gradient(ctx, reverse, 1, x1, y1, r1, x0, y0, r0);
 			if (code < 0)
 			{
 				xps_free(ctx, reverse);
 				gs_grestore(ctx->pgs);
-				return gs_rethrow(code, "could not draw radial gradient");
+				return fz_rethrow(code, "could not draw radial gradient");
 			}
 
-			xps_free(ctx, reverse);
+#endif
 		}
 		else
 		{
-			code = xps_draw_one_radial_gradient(ctx, func, 1, x0, y0, r0, x1, y1, r1);
+			code = xps_draw_one_radial_gradient(ctx, 1, x0, y0, r0, x1, y1, r1);
 			if (code < 0)
 			{
-				gs_grestore(ctx->pgs);
-				return gs_rethrow(code, "could not draw radial gradient");
+//				gs_grestore(ctx->pgs);
+				return fz_rethrow(code, "could not draw radial gradient");
 			}
 		}
 	}
@@ -671,25 +407,25 @@ xps_draw_radial_gradient(xps_context_t *ctx, xps_item_t *root, int spread, gs_fu
 			/* Draw current circle */
 
 			if (!point_inside_circle(x0, y0, x1, y1, r1))
-				dputs("xps: we should reverse gradient here too\n");
+				printf("xps: we should reverse gradient here too\n");
 
 			if (spread == SPREAD_REFLECT && (i & 1))
-				code = xps_draw_one_radial_gradient(ctx, func, 0, x1, y1, r1, x0, y0, r0);
+				code = xps_draw_one_radial_gradient(ctx, 0, x1, y1, r1, x0, y0, r0);
 			else
-				code = xps_draw_one_radial_gradient(ctx, func, 0, x0, y0, r0, x1, y1, r1);
+				code = xps_draw_one_radial_gradient(ctx, 0, x0, y0, r0, x1, y1, r1);
 			if (code < 0)
 			{
-				gs_grestore(ctx->pgs);
-				return gs_rethrow(code, "could not draw axial gradient");
+//				gs_grestore(ctx->pgs);
+				return fz_rethrow(code, "could not draw axial gradient");
 			}
 
 			/* Check if circle encompassed the entire bounding box (break loop if we do) */
 
 			done = 1;
-			if (!point_inside_circle(bbox.p.x, bbox.p.y, x1, y1, r1)) done = 0;
-			if (!point_inside_circle(bbox.p.x, bbox.q.y, x1, y1, r1)) done = 0;
-			if (!point_inside_circle(bbox.q.x, bbox.q.y, x1, y1, r1)) done = 0;
-			if (!point_inside_circle(bbox.q.x, bbox.p.y, x1, y1, r1)) done = 0;
+			if (!point_inside_circle(bbox.x0, bbox.y0, x1, y1, r1)) done = 0;
+			if (!point_inside_circle(bbox.x0, bbox.y1, x1, y1, r1)) done = 0;
+			if (!point_inside_circle(bbox.x1, bbox.y1, x1, y1, r1)) done = 0;
+			if (!point_inside_circle(bbox.x1, bbox.y0, x1, y1, r1)) done = 0;
 			if (done)
 				break;
 
@@ -705,7 +441,7 @@ xps_draw_radial_gradient(xps_context_t *ctx, xps_item_t *root, int spread, gs_fu
 		}
 	}
 
-	gs_grestore(ctx->pgs);
+//	gs_grestore(ctx->pgs);
 
 	return 0;
 }
@@ -716,9 +452,9 @@ xps_draw_radial_gradient(xps_context_t *ctx, xps_item_t *root, int spread, gs_fu
  */
 
 static int
-xps_draw_linear_gradient(xps_context_t *ctx, xps_item_t *root, int spread, gs_function_t *func)
+xps_draw_linear_gradient(xps_context_t *ctx, xps_item_t *root, int spread)
 {
-	gs_rect bbox;
+	fz_rect bbox;
 	float x0, y0, x1, y1;
 	float dx, dy;
 	int code;
@@ -744,9 +480,9 @@ xps_draw_linear_gradient(xps_context_t *ctx, xps_item_t *root, int spread, gs_fu
 
 	if (spread == SPREAD_PAD)
 	{
-		code = xps_draw_one_linear_gradient(ctx, func, 1, x0, y0, x1, y1);
+		code = xps_draw_one_linear_gradient(ctx, 1, x0, y0, x1, y1);
 		if (code < 0)
-			return gs_rethrow(code, "could not draw axial gradient");
+			return fz_rethrow(code, "could not draw axial gradient");
 	}
 	else
 	{
@@ -760,10 +496,10 @@ xps_draw_linear_gradient(xps_context_t *ctx, xps_item_t *root, int spread, gs_fu
 		a = dx / len;
 		b = dy / len;
 
-		dist[0] = a * (bbox.p.x - x0) + b * (bbox.p.y - y0);
-		dist[1] = a * (bbox.p.x - x0) + b * (bbox.q.y - y0);
-		dist[2] = a * (bbox.q.x - x0) + b * (bbox.q.y - y0);
-		dist[3] = a * (bbox.q.x - x0) + b * (bbox.p.y - y0);
+		dist[0] = a * (bbox.x0 - x0) + b * (bbox.y0 - y0);
+		dist[1] = a * (bbox.x0 - x0) + b * (bbox.y1 - y0);
+		dist[2] = a * (bbox.x1 - x0) + b * (bbox.y1 - y0);
+		dist[3] = a * (bbox.x1 - x0) + b * (bbox.y0 - y0);
 
 		d0 = dist[0];
 		d1 = dist[0];
@@ -780,18 +516,18 @@ xps_draw_linear_gradient(xps_context_t *ctx, xps_item_t *root, int spread, gs_fu
 		{
 			if (spread == SPREAD_REFLECT && (i & 1))
 			{
-				code = xps_draw_one_linear_gradient(ctx, func, 0,
+				code = xps_draw_one_linear_gradient(ctx, 0,
 						x1 + dx * i, y1 + dy * i,
 						x0 + dx * i, y0 + dy * i);
 			}
 			else
 			{
-				code = xps_draw_one_linear_gradient(ctx, func, 0,
+				code = xps_draw_one_linear_gradient(ctx, 0,
 						x0 + dx * i, y0 + dy * i,
 						x1 + dx * i, y1 + dy * i);
 			}
 			if (code < 0)
-				return gs_rethrow(code, "could not draw axial gradient");
+				return fz_rethrow(code, "could not draw axial gradient");
 		}
 	}
 
@@ -804,8 +540,9 @@ xps_draw_linear_gradient(xps_context_t *ctx, xps_item_t *root, int spread, gs_fu
  */
 
 static int
-xps_parse_gradient_brush(xps_context_t *ctx, char *base_uri, xps_resource_t *dict, xps_item_t *root,
-		int (*draw)(xps_context_t *, xps_item_t *, int, gs_function_t *))
+xps_parse_gradient_brush(xps_context_t *ctx, fz_matrix ctm,
+	char *base_uri, xps_resource_t *dict, xps_item_t *root,
+	int (*draw)(xps_context_t *, xps_item_t *, int))
 {
 	xps_item_t *node;
 
@@ -820,14 +557,11 @@ xps_parse_gradient_brush(xps_context_t *ctx, char *base_uri, xps_resource_t *dic
 
 	struct stop stop_list[MAX_STOPS];
 	int stop_count;
-	gs_matrix transform;
+	fz_matrix transform;
 	int spread_method;
-	int code;
 
-	gs_rect bbox;
+	fz_rect bbox;
 
-	gs_function_t *color_func;
-	gs_function_t *opacity_func;
 	int has_opacity = 0;
 
 	opacity_att = xps_att(root, "Opacity");
@@ -861,41 +595,42 @@ xps_parse_gradient_brush(xps_context_t *ctx, char *base_uri, xps_resource_t *dic
 			spread_method = SPREAD_REPEAT;
 	}
 
-	gs_make_identity(&transform);
+	xps_clip(ctx, ctm);
+
+	transform = fz_identity;
 	if (transform_att)
 		xps_parse_render_transform(ctx, transform_att, &transform);
 	if (transform_tag)
 		xps_parse_matrix_transform(ctx, transform_tag, &transform);
+	ctm = fz_concat(ctm, transform);
 
 	if (!stop_tag)
-		return gs_throw(-1, "missing gradient stops tag");
+		return fz_throw("missing gradient stops tag");
 
 	stop_count = xps_parse_gradient_stops(ctx, base_uri, stop_tag, stop_list, MAX_STOPS);
 	if (stop_count == 0)
-		return gs_throw(-1, "no gradient stops found");
+		return fz_throw("no gradient stops found");
 
+/*
 	color_func = xps_create_gradient_stop_function(ctx, stop_list, stop_count, 0);
 	if (!color_func)
-		return gs_rethrow(-1, "could not create color gradient function");
+		return fz_rethrow(-1, "could not create color gradient function");
 
 	opacity_func = xps_create_gradient_stop_function(ctx, stop_list, stop_count, 1);
 	if (!opacity_func)
-		return gs_rethrow(-1, "could not create opacity gradient function");
+		return fz_rethrow(-1, "could not create opacity gradient function");
+*/
 
 	has_opacity = xps_gradient_has_transparent_colors(stop_list, stop_count);
 
-	xps_clip(ctx);
-
-	gs_gsave(ctx->pgs);
-	gs_concat(ctx->pgs, &transform);
-
 	xps_bounds_in_user_space(ctx, &bbox);
 
+#if 0
 	code = xps_begin_opacity(ctx, base_uri, dict, opacity_att, NULL);
 	if (code)
 	{
 		gs_grestore(ctx->pgs);
-		return gs_rethrow(code, "cannot create transparency group");
+		return fz_rethrow(code, "cannot create transparency group");
 	}
 
 	if (ctx->opacity_only)
@@ -904,7 +639,7 @@ xps_parse_gradient_brush(xps_context_t *ctx, char *base_uri, xps_resource_t *dic
 		if (code)
 		{
 			gs_grestore(ctx->pgs);
-			return gs_rethrow(code, "cannot draw gradient opacity");
+			return fz_rethrow(code, "cannot draw gradient opacity");
 		}
 	}
 	else
@@ -921,7 +656,7 @@ xps_parse_gradient_brush(xps_context_t *ctx, char *base_uri, xps_resource_t *dic
 			{
 				gs_end_transparency_mask(ctx->pgs, TRANSPARENCY_CHANNEL_Opacity);
 				gs_grestore(ctx->pgs);
-				return gs_rethrow(code, "cannot draw gradient opacity");
+				return fz_rethrow(code, "cannot draw gradient opacity");
 			}
 			gs_end_transparency_mask(ctx->pgs, TRANSPARENCY_CHANNEL_Opacity);
 
@@ -932,7 +667,7 @@ xps_parse_gradient_brush(xps_context_t *ctx, char *base_uri, xps_resource_t *dic
 			{
 				gs_end_transparency_group(ctx->pgs);
 				gs_grestore(ctx->pgs);
-				return gs_rethrow(code, "cannot draw gradient color");
+				return fz_rethrow(code, "cannot draw gradient color");
 			}
 			gs_end_transparency_group(ctx->pgs);
 		}
@@ -942,37 +677,40 @@ xps_parse_gradient_brush(xps_context_t *ctx, char *base_uri, xps_resource_t *dic
 			if (code)
 			{
 				gs_grestore(ctx->pgs);
-				return gs_rethrow(code, "cannot draw gradient color");
+				return fz_rethrow(code, "cannot draw gradient color");
 			}
 		}
 	}
+#endif
 
 	xps_end_opacity(ctx, base_uri, dict, opacity_att, NULL);
 
-	gs_grestore(ctx->pgs);
+//	gs_grestore(ctx->pgs);
 
-	xps_free_gradient_stop_function(ctx, opacity_func);
-	xps_free_gradient_stop_function(ctx, color_func);
+//	xps_free_gradient_stop_function(ctx, opacity_func);
+//	xps_free_gradient_stop_function(ctx, color_func);
 
 	return 0;
 }
 
 int
-xps_parse_linear_gradient_brush(xps_context_t *ctx, char *base_uri, xps_resource_t *dict, xps_item_t *root)
+xps_parse_linear_gradient_brush(xps_context_t *ctx, fz_matrix ctm,
+	char *base_uri, xps_resource_t *dict, xps_item_t *root)
 {
 	int code;
-	code = xps_parse_gradient_brush(ctx, base_uri, dict, root, xps_draw_linear_gradient);
+	code = xps_parse_gradient_brush(ctx, ctm, base_uri, dict, root, xps_draw_linear_gradient);
 	if (code < 0)
-		return gs_rethrow(code, "cannot parse linear gradient brush");
-	return gs_okay;
+		return fz_rethrow(code, "cannot parse linear gradient brush");
+	return fz_okay;
 }
 
 int
-xps_parse_radial_gradient_brush(xps_context_t *ctx, char *base_uri, xps_resource_t *dict, xps_item_t *root)
+xps_parse_radial_gradient_brush(xps_context_t *ctx, fz_matrix ctm,
+	char *base_uri, xps_resource_t *dict, xps_item_t *root)
 {
 	int code;
-	code = xps_parse_gradient_brush(ctx, base_uri, dict, root, xps_draw_radial_gradient);
+	code = xps_parse_gradient_brush(ctx, ctm, base_uri, dict, root, xps_draw_radial_gradient);
 	if (code < 0)
-		return gs_rethrow(code, "cannot parse radial gradient brush");
-	return gs_okay;
+		return fz_rethrow(code, "cannot parse radial gradient brush");
+	return fz_okay;
 }