Attachment 39130 Details for Bug 30436 – Axial shading extend false

[patch] Axial shading extend false

30436.patch (text/plain), 10.24 KB, created by Thomas Freitag on 2010-10-03 01:38:45 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Thomas Freitag

Created: 2010-10-03 01:38:45 UTC

Size: 10.24 KB

patch

obsolete

>diff --git a/poppler/SplashOutputDev.cc b/poppler/SplashOutputDev.cc
>index 0ae5bc5..11e052e 100644
>--- a/poppler/SplashOutputDev.cc
>+++ b/poppler/SplashOutputDev.cc
>@@ -80,6 +80,85 @@ extern "C" int unlink(char *filename);
> #endif
> 
> //------------------------------------------------------------------------
>+// SplashSolidColor
>+//------------------------------------------------------------------------
>+
>+SplashAxialPattern::SplashAxialPattern(SplashColorMode colorModeA, GfxState *stateA, GfxAxialShading *shadingA) {
>+	Matrix ctm;
>+	
>+	shading = shadingA;
>+	state = stateA;
>+	colorMode = colorModeA;
>+	state->getCTM (&ctm);
>+	ctm.invertTo (&ictm);
>+
>+	shading->getCoords(&x0, &y0, &x1, &y1);
>+	dx = x1 - x0;
>+	dy = y1 - y0;
>+    mul = 1 / (dx * dx + dy * dy);
>+	
>+	// get the function domain
>+	t0 = shading->getDomain0();
>+	t1 = shading->getDomain1();
>+}
>+
>+SplashAxialPattern::~SplashAxialPattern() {
>+}
>+
>+GBool SplashAxialPattern::getColor(int x, int y, SplashColorPtr c) {
>+	SplashColor color;
>+	GfxColor gfxColor;
>+	GfxGray gray;
>+	GfxRGB rgb;
>+#if SPLASH_CMYK
>+	GfxCMYK cmyk;
>+#endif
>+	double tt;
>+
>+	double xc, yc, xaxis;
>+	ictm.transform(x, y, &xc, &yc);
>+	xaxis = ((xc - x0) * dx + (yc - y0) * dy) * mul;
>+	if (xaxis < 0 && shading->getExtend0()) {
>+		tt = t0;
>+	} else if (xaxis > 1 && !shading->getExtend1()) {
>+		tt = t1;
>+    } else if (xaxis >= 0 && xaxis <= 1) {
>+		tt = t0 + (t1 -t0) * xaxis;
>+	} else
>+		return gFalse;
>+	shading->getColor(tt, &gfxColor);
>+    state->setFillColor(&gfxColor);
>+  switch (colorMode) {
>+  case splashModeMono1:
>+  case splashModeMono8:
>+	state->getFillGray(&gray);
>+    color[0] = colToByte(gray);
>+    break;
>+  case splashModeXBGR8:
>+    color[3] = 255;
>+  case splashModeRGB8:
>+  case splashModeBGR8:
>+	state->getFillRGB(&rgb);
>+    color[0] = colToByte(rgb.r);
>+    color[1] = colToByte(rgb.g);
>+    color[2] = colToByte(rgb.b);
>+    break;
>+#if SPLASH_CMYK
>+  case splashModeCMYK8:
>+	state->getFillCMYK(&cmyk);
>+    color[0] = colToByte(cmyk.c);
>+    color[1] = colToByte(cmyk.m);
>+    color[2] = colToByte(cmyk.y);
>+    color[3] = colToByte(cmyk.k);
>+    break;
>+#endif
>+  }
>+
>+	splashColorCopy(c, color);
>+	return gTrue;
>+}
>+
>+//------------------------------------------------------------------------
> 
> // Divide a 16-bit value (in [0, 255*255]) by 255, returning an 8-bit result.
> static inline Guchar div255(int x) {
>@@ -3186,3 +3265,41 @@ void SplashOutputDev::setFreeTypeHinting(GBool enable)
> {
>   enableFreeTypeHinting = enable;
> }
>+
>+/* implement shading routines */
>+GBool SplashOutputDev::axialShadedFill(GfxState *state, GfxAxialShading *shading, double tMin, double tMax) {
>+  double xMin, yMin, xMax, yMax;
>+  SplashPath *path;
>+
>+  // restore vector antialias because we support it here
>+  setVectorAntialias(gTrue);
>+  // get the clip region bbox
>+  state->getUserClipBBox(&xMin, &yMin, &xMax, &yMax);
>+  
>+  // fill the region
>+  state->moveTo(xMin, yMin);
>+  state->lineTo(xMax, yMin);
>+  state->lineTo(xMax, yMax);
>+  state->lineTo(xMin, yMax);
>+  state->closePath();
>+  path = convertPath(state, state->getPath());
>+	  
>+  SplashPattern *pattern = new SplashAxialPattern(colorMode, state, shading);
>+  splash->shadedFill(path, gFalse, pattern);
>+  state->clearPath();
>+  delete path;
>+
>+  return gTrue;
>+}
>+
>+GBool SplashOutputDev::functionShadedFill(GfxState *state,
>+				     GfxFunctionShading *shading) {
>+  // not implemented, therefore:
>+  return gFalse;
>+}
>+
>+GBool SplashOutputDev::radialShadedFill(GfxState *state, 
>+										GfxRadialShading *shading, double /*sMin*/, double /*sMax*/) {
>+  // not implemented, therefore:
>+  return gFalse;
>+}
>diff --git a/poppler/SplashOutputDev.h b/poppler/SplashOutputDev.h
>index adbd196..4cf74bf 100644
>--- a/poppler/SplashOutputDev.h
>+++ b/poppler/SplashOutputDev.h
>@@ -31,6 +31,7 @@
> 
> #include "goo/gtypes.h"
> #include "splash/SplashTypes.h"
>+#include "splash/SplashPattern.h"
> #include "poppler-config.h"
> #include "OutputDev.h"
> #include "GfxState.h"
>@@ -39,7 +40,6 @@ class Gfx8BitFont;
> class SplashBitmap;
> class Splash;
> class SplashPath;
>-class SplashPattern;
> class SplashFontEngine;
> class SplashFont;
> class T3FontCache;
>@@ -48,6 +48,35 @@ struct T3GlyphStack;
> struct SplashTransparencyGroup;
> 
> //------------------------------------------------------------------------
>+// Splash dynamic pattern
>+//------------------------------------------------------------------------
>+
>+class SplashAxialPattern: public SplashPattern {
>+public:
>+
>+  SplashAxialPattern(SplashColorMode colorMode, GfxState *state, GfxAxialShading *shading);
>+
>+  virtual SplashPattern *copy() { return new SplashAxialPattern(colorMode, state, shading); }
>+
>+  virtual ~SplashAxialPattern();
>+
>+  virtual GBool getColor(int x, int y, SplashColorPtr c);
>+
>+  virtual GBool isStatic() { return gFalse; }
>+
>+private:
>+
>+  Matrix ictm;
>+  double x0, y0, x1, y1;
>+  double dx, dy, mul;
>+  double t0, t1;
>+  GfxAxialShading *shading;
>+  GfxState *state;
>+  SplashColorMode colorMode;
>+  double *bbox;
>+};
>+
>+//------------------------------------------------------------------------
> 
> // number of Type 3 fonts to cache
> #define splashOutT3FontCacheSize 8
>@@ -70,6 +99,11 @@ public:
> 
>   //----- get info about output device
> 
>+  // Does this device use functionShadedFill(), axialShadedFill(), and
>+  // radialShadedFill()?  If this returns false, these shaded fills
>+  // will be reduced to a series of other drawing operations.
>+  virtual GBool useShadedFills() { return gTrue; }
>+
>   // Does this device use upside-down coordinates?
>   // (Upside-down means (0,0) is the top left corner of the page.)
>   virtual GBool upsideDown() { return gTrue; }
>@@ -121,6 +155,10 @@ public:
>   virtual void stroke(GfxState *state);
>   virtual void fill(GfxState *state);
>   virtual void eoFill(GfxState *state);
>+  virtual GBool axialShadedFill(GfxState *state, GfxAxialShading *shading, double tMin, double tMax);
>+  virtual GBool functionShadedFill(GfxState *state,
>+				   GfxFunctionShading *shading);
>+  virtual GBool radialShadedFill(GfxState *state, GfxRadialShading *shading, double /*sMin*/, double /*sMax*/);
> 
>   //----- path clipping
>   virtual void clip(GfxState *state);
>diff --git a/splash/Splash.cc b/splash/Splash.cc
>index 5e27d42..f005792 100644
>--- a/splash/Splash.cc
>+++ b/splash/Splash.cc
>@@ -245,7 +245,32 @@ inline void Splash::pipeRun(SplashPipe *pipe) {
> 
>   // dynamic pattern
>   if (pipe->pattern) {
>-    pipe->pattern->getColor(pipe->x, pipe->y, pipe->cSrcVal);
>+	  if (!pipe->pattern->getColor(pipe->x, pipe->y, pipe->cSrcVal)) {
>+		  switch (bitmap->mode) {
>+		case splashModeMono1:
>+			if (!(pipe->destColorMask >>= 1)) 
>+				++pipe->destColorPtr;
>+			break;
>+		case splashModeMono8:
>+			++pipe->destColorPtr;
>+			break;
>+		case splashModeBGR8:
>+		case splashModeRGB8:
>+			pipe->destColorPtr += 3;
>+			break;
>+		case splashModeXBGR8:
>+#if SPLASH_CMYK
>+		case splashModeCMYK8:
>+#endif
>+			pipe->destColorPtr += 4;
>+			break;
>+		  }
>+		  if (pipe->destAlphaPtr) {
>+			  ++pipe->destAlphaPtr;
>+		  }
>+		  ++pipe->x;
>+		  return;
>+	  }
>   }
> 
>   if (pipe->noTransparency && !state->blendFunc) {
>@@ -3592,3 +3617,52 @@ void Splash::dumpXPath(SplashXPath *path) {
> 	   (path->segs[i].flags	& splashXPathFlip) ? "P" : " ");
>   }
> }
>+
>+SplashError Splash::shadedFill(SplashPath *path, GBool eo,
>+									SplashPattern *pattern) {
>+  SplashPipe pipe;
>+  SplashXPath *xPath;
>+  SplashXPathScanner *scanner;
>+  int xMinI, yMinI, xMaxI, yMaxI, x0, x1, y;
>+  SplashClipResult clipRes;
>+
>+  if (path->length == 0) {
>+    return splashErrEmptyPath;
>+  }
>+  xPath = new SplashXPath(path, state->matrix, state->flatness, gTrue);
>+  xPath->aaScale();
>+  xPath->sort();
>+  scanner = new SplashXPathScanner(xPath, eo);
>+
>+  // get the min and max x and y values
>+  scanner->getBBoxAA(&xMinI, &yMinI, &xMaxI, &yMaxI);
>+
>+  // check clipping
>+  if ((clipRes = state->clip->testRect(xMinI, yMinI, xMaxI, yMaxI))
>+      != splashClipAllOutside) {
>+
>+    // limit the y range
>+    if (yMinI < state->clip->getYMinI()) {
>+      yMinI = state->clip->getYMinI();
>+    }
>+    if (yMaxI > state->clip->getYMaxI()) {
>+      yMaxI = state->clip->getYMaxI();
>+    }
>+
>+	pipeInit(&pipe, 0, yMinI, pattern, NULL, state->fillAlpha, vectorAntialias, gFalse);
>+
>+    // draw the spans
>+	for (y = yMinI; y <= yMaxI; ++y) {
>+		scanner->renderAALine(aaBuf, &x0, &x1, y);
>+		if (clipRes != splashClipAllInside) {
>+			state->clip->clipAALine(aaBuf, &x0, &x1, y);
>+		}
>+		drawAALine(&pipe, x0, x1, y);
>+	}
>+  }
>+  opClipRes = clipRes;
>+
>+  delete scanner;
>+  delete xPath;
>+  return splashOk;
>+}
>diff --git a/splash/Splash.h b/splash/Splash.h
>index c9d57cc..23b3bf4 100644
>--- a/splash/Splash.h
>+++ b/splash/Splash.h
>@@ -248,6 +248,8 @@ public:
>   GBool getVectorAntialias() { return vectorAntialias; }
>   void setVectorAntialias(GBool vaa) { vectorAntialias = vaa; }
> #endif
>+  SplashError shadedFill(SplashPath *path, GBool eo,
>+				    SplashPattern *pattern);
> 
> private:
> 
>diff --git a/splash/SplashPattern.cc b/splash/SplashPattern.cc
>index ce49078..19fb31f 100644
>--- a/splash/SplashPattern.cc
>+++ b/splash/SplashPattern.cc
>@@ -35,6 +35,7 @@ SplashSolidColor::SplashSolidColor(SplashColorPtr colorA) {
> SplashSolidColor::~SplashSolidColor() {
> }
> 
>-void SplashSolidColor::getColor(int x, int y, SplashColorPtr c) {
>+GBool SplashSolidColor::getColor(int x, int y, SplashColorPtr c) {
>   splashColorCopy(c, color);
>+  return gTrue;
> }
>diff --git a/splash/SplashPattern.h b/splash/SplashPattern.h
>index 4e3d9ab..3c0d178 100644
>--- a/splash/SplashPattern.h
>+++ b/splash/SplashPattern.h
>@@ -29,7 +29,7 @@ public:
>   virtual ~SplashPattern();
> 
>   // Return the color value for a specific pixel.
>-  virtual void getColor(int x, int y, SplashColorPtr c) = 0;
>+  virtual GBool getColor(int x, int y, SplashColorPtr c) = 0;
> 
>   // Returns true if this pattern object will return the same color
>   // value for all pixels.
>@@ -51,7 +51,7 @@ public:
> 
>   virtual ~SplashSolidColor();
> 
>-  virtual void getColor(int x, int y, SplashColorPtr c);
>+  virtual GBool getColor(int x, int y, SplashColorPtr c);
> 
>   virtual GBool isStatic() { return gTrue; }
>

Actions: View | Splinter Review

Attachments on bug 30436: 39119 | 39129 | 39130 | 39304 | 39305 | 39480 | 39515 | 39664 | 39974

Use of freedesktop.org services, including Bugzilla, is subject to our Code of Conduct. How we collect and use information is described in our Privacy Policy.