X-Git-Url: http://git.asbjorn.biz/?a=blobdiff_plain;f=pdf2swf%2Fxpdf%2FGfxState.h;h=f747a831b12b90837cf3d737476cf3abeb606bc3;hb=5b709a634c4998b6d699f9a183c27747e93e92a7;hp=2056c4d1fb36f6f110a82fbb08d103f3e3e64e4e;hpb=fc554a43712b76d16b41ec77dd311b4a78b1ef6b;p=swftools.git diff --git a/pdf2swf/xpdf/GfxState.h b/pdf2swf/xpdf/GfxState.h index 2056c4d..f747a83 100644 --- a/pdf2swf/xpdf/GfxState.h +++ b/pdf2swf/xpdf/GfxState.h @@ -2,29 +2,33 @@ // // GfxState.h // -// Copyright 1996 Derek B. Noonburg +// Copyright 1996-2003 Glyph & Cog, LLC // //======================================================================== #ifndef GFXSTATE_H #define GFXSTATE_H -#ifdef __GNUC__ +#include + +#ifdef USE_GCC_PRAGMAS #pragma interface #endif #include "gtypes.h" #include "Object.h" +#include "Function.h" class Array; -class Function; class GfxFont; +class PDFRectangle; +class GfxShading; //------------------------------------------------------------------------ // GfxColor //------------------------------------------------------------------------ -#define gfxColorMaxComps 8 +#define gfxColorMaxComps funcMaxOutputs struct GfxColor { double c[gfxColorMaxComps]; @@ -50,6 +54,8 @@ struct GfxCMYK { // GfxColorSpace //------------------------------------------------------------------------ +// NB: The nGfxColorSpaceModes constant and the gfxColorSpaceModeNames +// array defined in GfxState.cc must match this enum. enum GfxColorSpaceMode { csDeviceGray, csCalGray, @@ -88,6 +94,12 @@ public: virtual void getDefaultRanges(double *decodeLow, double *decodeRange, int maxImgPixel); + // Return the number of color space modes + static int getNumColorSpaceModes(); + + // Return the name of the th color space mode. + static char *getColorSpaceModeName(int idx); + private: }; @@ -201,14 +213,14 @@ public: double getGammaR() { return gammaR; } double getGammaG() { return gammaG; } double getGammaB() { return gammaB; } - double *getMatrix() { return m; } + double *getMatrix() { return mat; } private: double whiteX, whiteY, whiteZ; // white point double blackX, blackY, blackZ; // black point double gammaR, gammaG, gammaB; // gamma values - double m[9]; // ABC -> XYZ transform matrix + double mat[9]; // ABC -> XYZ transform matrix }; //------------------------------------------------------------------------ @@ -283,8 +295,8 @@ private: class GfxICCBasedColorSpace: public GfxColorSpace { public: - GfxICCBasedColorSpace(int nComps, GfxColorSpace *alt, - Ref *iccProfileStream); + GfxICCBasedColorSpace(int nCompsA, GfxColorSpace *altA, + Ref *iccProfileStreamA); virtual ~GfxICCBasedColorSpace(); virtual GfxColorSpace *copy(); virtual GfxColorSpaceMode getMode() { return csICCBased; } @@ -320,7 +332,7 @@ private: class GfxIndexedColorSpace: public GfxColorSpace { public: - GfxIndexedColorSpace(GfxColorSpace *base, int indexHigh); + GfxIndexedColorSpace(GfxColorSpace *baseA, int indexHighA); virtual ~GfxIndexedColorSpace(); virtual GfxColorSpace *copy(); virtual GfxColorSpaceMode getMode() { return csIndexed; } @@ -341,6 +353,7 @@ public: GfxColorSpace *getBase() { return base; } int getIndexHigh() { return indexHigh; } Guchar *getLookup() { return lookup; } + GfxColor *mapColorToBase(GfxColor *color, GfxColor *baseColor); private: @@ -356,8 +369,8 @@ private: class GfxSeparationColorSpace: public GfxColorSpace { public: - GfxSeparationColorSpace(GString *name, GfxColorSpace *alt, - Function *func); + GfxSeparationColorSpace(GString *nameA, GfxColorSpace *altA, + Function *funcA); virtual ~GfxSeparationColorSpace(); virtual GfxColorSpace *copy(); virtual GfxColorSpaceMode getMode() { return csSeparation; } @@ -390,7 +403,7 @@ private: class GfxDeviceNColorSpace: public GfxColorSpace { public: - GfxDeviceNColorSpace(int nComps, GfxColorSpace *alt, Function *func); + GfxDeviceNColorSpace(int nCompsA, GfxColorSpace *alt, Function *func); virtual ~GfxDeviceNColorSpace(); virtual GfxColorSpace *copy(); virtual GfxColorSpaceMode getMode() { return csDeviceN; } @@ -405,7 +418,9 @@ public: virtual int getNComps() { return nComps; } // DeviceN-specific access. + GString *getColorantName(int i) { return names[i]; } GfxColorSpace *getAlt() { return alt; } + Function *getTintTransformFunc() { return func; } private: @@ -414,7 +429,6 @@ private: *names[gfxColorMaxComps]; GfxColorSpace *alt; // alternate color space Function *func; // tint transform (into alternate color space) - }; //------------------------------------------------------------------------ @@ -424,7 +438,7 @@ private: class GfxPatternColorSpace: public GfxColorSpace { public: - GfxPatternColorSpace(GfxColorSpace *under); + GfxPatternColorSpace(GfxColorSpace *underA); virtual ~GfxPatternColorSpace(); virtual GfxColorSpace *copy(); virtual GfxColorSpaceMode getMode() { return csPattern; } @@ -454,7 +468,7 @@ private: class GfxPattern { public: - GfxPattern(int type); + GfxPattern(int typeA); virtual ~GfxPattern(); static GfxPattern *parse(Object *obj); @@ -475,7 +489,7 @@ private: class GfxTilingPattern: public GfxPattern { public: - GfxTilingPattern(Dict *streamDict, Object *stream); + static GfxTilingPattern *parse(Object *patObj); virtual ~GfxTilingPattern(); virtual GfxPattern *copy(); @@ -492,7 +506,10 @@ public: private: - GfxTilingPattern(GfxTilingPattern *pat); + GfxTilingPattern(int paintTypeA, int tilingTypeA, + double *bboxA, double xStepA, double yStepA, + Object *resDictA, double *matrixA, + Object *contentStreamA); int paintType; int tilingType; @@ -504,94 +521,165 @@ private: }; //------------------------------------------------------------------------ -// Function +// GfxShadingPattern //------------------------------------------------------------------------ -#define funcMaxInputs 1 -#define funcMaxOutputs 8 - -class Function { +class GfxShadingPattern: public GfxPattern { public: - Function(); + static GfxShadingPattern *parse(Object *patObj); + virtual ~GfxShadingPattern(); - virtual ~Function(); + virtual GfxPattern *copy(); - // Construct a function. Returns NULL if unsuccessful. - static Function *parse(Object *funcObj); + GfxShading *getShading() { return shading; } + double *getMatrix() { return matrix; } - // Initialize the entries common to all function types. - GBool init(Dict *dict); +private: - virtual Function *copy() = 0; + GfxShadingPattern(GfxShading *shadingA, double *matrixA); - // Return size of input and output tuples. - int getInputSize() { return m; } - int getOutputSize() { return n; } + GfxShading *shading; + double matrix[6]; +}; - // Transform an input tuple into an output tuple. - virtual void transform(double *in, double *out) = 0; +//------------------------------------------------------------------------ +// GfxShading +//------------------------------------------------------------------------ + +class GfxShading { +public: - virtual GBool isOk() = 0; + GfxShading(int typeA); + GfxShading(GfxShading *shading); + virtual ~GfxShading(); + + static GfxShading *parse(Object *obj); + + virtual GfxShading *copy() = 0; + + int getType() { return type; } + GfxColorSpace *getColorSpace() { return colorSpace; } + GfxColor *getBackground() { return &background; } + GBool getHasBackground() { return hasBackground; } + void getBBox(double *xMinA, double *yMinA, double *xMaxA, double *yMaxA) + { *xMinA = xMin; *yMinA = yMin; *xMaxA = xMax; *yMaxA = yMax; } + GBool getHasBBox() { return hasBBox; } protected: - int m, n; // size of input and output tuples - double // min and max values for function domain - domain[funcMaxInputs][2]; - double // min and max values for function range - range[funcMaxOutputs][2]; - GBool hasRange; // set if range is defined + GBool init(Dict *dict); + + int type; + GfxColorSpace *colorSpace; + GfxColor background; + GBool hasBackground; + double xMin, yMin, xMax, yMax; + GBool hasBBox; }; //------------------------------------------------------------------------ -// SampledFunction +// GfxFunctionShading //------------------------------------------------------------------------ -class SampledFunction: public Function { +class GfxFunctionShading: public GfxShading { public: - SampledFunction(Object *funcObj, Dict *dict); - virtual ~SampledFunction(); - virtual Function *copy() { return new SampledFunction(this); } - virtual void transform(double *in, double *out); - virtual GBool isOk() { return ok; } + GfxFunctionShading(double x0A, double y0A, + double x1A, double y1A, + double *matrixA, + Function **funcsA, int nFuncsA); + GfxFunctionShading(GfxFunctionShading *shading); + virtual ~GfxFunctionShading(); -private: + static GfxFunctionShading *parse(Dict *dict); - SampledFunction(SampledFunction *func); + virtual GfxShading *copy(); - int // number of samples for each domain element - sampleSize[funcMaxInputs]; - double // min and max values for domain encoder - encode[funcMaxInputs][2]; - double // min and max values for range decoder - decode[funcMaxOutputs][2]; - double *samples; // the samples - GBool ok; + void getDomain(double *x0A, double *y0A, double *x1A, double *y1A) + { *x0A = x0; *y0A = y0; *x1A = x1; *y1A = y1; } + double *getMatrix() { return matrix; } + void getColor(double x, double y, GfxColor *color); + +private: + + double x0, y0, x1, y1; + double matrix[6]; + Function *funcs[gfxColorMaxComps]; + int nFuncs; }; //------------------------------------------------------------------------ -// ExponentialFunction +// GfxAxialShading //------------------------------------------------------------------------ -class ExponentialFunction: public Function { +class GfxAxialShading: public GfxShading { public: - ExponentialFunction(Object *funcObj, Dict *dict); - virtual ~ExponentialFunction(); - virtual Function *copy() { return new ExponentialFunction(this); } - virtual void transform(double *in, double *out); - virtual GBool isOk() { return ok; } + GfxAxialShading(double x0A, double y0A, + double x1A, double y1A, + double t0A, double t1A, + Function **funcsA, int nFuncsA, + GBool extend0A, GBool extend1A); + GfxAxialShading(GfxAxialShading *shading); + virtual ~GfxAxialShading(); + + static GfxAxialShading *parse(Dict *dict); + + virtual GfxShading *copy(); + + void getCoords(double *x0A, double *y0A, double *x1A, double *y1A) + { *x0A = x0; *y0A = y0; *x1A = x1; *y1A = y1; } + double getDomain0() { return t0; } + double getDomain1() { return t1; } + void getColor(double t, GfxColor *color); + GBool getExtend0() { return extend0; } + GBool getExtend1() { return extend1; } private: - ExponentialFunction(ExponentialFunction *func); + double x0, y0, x1, y1; + double t0, t1; + Function *funcs[gfxColorMaxComps]; + int nFuncs; + GBool extend0, extend1; +}; - double c0[funcMaxOutputs]; - double c1[funcMaxOutputs]; - double e; - GBool ok; +//------------------------------------------------------------------------ +// GfxRadialShading +//------------------------------------------------------------------------ + +class GfxRadialShading: public GfxShading { +public: + + GfxRadialShading(double x0A, double y0A, double r0A, + double x1A, double y1A, double r1A, + double t0A, double t1A, + Function **funcsA, int nFuncsA, + GBool extend0A, GBool extend1A); + GfxRadialShading(GfxRadialShading *shading); + virtual ~GfxRadialShading(); + + static GfxRadialShading *parse(Dict *dict); + + virtual GfxShading *copy(); + + void getCoords(double *x0A, double *y0A, double *r0A, + double *x1A, double *y1A, double *r1A) + { *x0A = x0; *y0A = y0; *r0A = r0; *x1A = x1; *y1A = y1; *r1A = r1; } + double getDomain0() { return t0; } + double getDomain1() { return t1; } + void getColor(double t, GfxColor *color); + GBool getExtend0() { return extend0; } + GBool getExtend1() { return extend1; } + +private: + + double x0, y0, r0, x1, y1, r1; + double t0, t1; + Function *funcs[gfxColorMaxComps]; + int nFuncs; + GBool extend0, extend1; }; //------------------------------------------------------------------------ @@ -602,11 +690,14 @@ class GfxImageColorMap { public: // Constructor. - GfxImageColorMap(int bits, Object *decode, GfxColorSpace *colorSpace); + GfxImageColorMap(int bitsA, Object *decode, GfxColorSpace *colorSpaceA); // Destructor. ~GfxImageColorMap(); + // Return a copy of this color map. + GfxImageColorMap *copy() { return new GfxImageColorMap(this); } + // Is color map valid? GBool isOk() { return ok; } @@ -625,9 +716,12 @@ public: void getGray(Guchar *x, double *gray); void getRGB(Guchar *x, GfxRGB *rgb); void getCMYK(Guchar *x, GfxCMYK *cmyk); + void getColor(Guchar *x, GfxColor *color); private: + GfxImageColorMap(GfxImageColorMap *colorMap); + GfxColorSpace *colorSpace; // the image color space int bits; // bits per component int nComps; // number of components in a pixel @@ -678,6 +772,9 @@ public: void close(); GBool isClosed() { return closed; } + // Add (, ) to each point in the subpath. + void offset(double dx, double dy); + private: double *x, *y; // points @@ -728,7 +825,13 @@ public: double x3, double y3); // Close the last subpath. - void close() { subpaths[n-1]->close(); } + void close(); + + // Append to . + void append(GfxPath *path); + + // Add (, ) to each point in the path. + void offset(double dx, double dy); private: @@ -749,11 +852,11 @@ private: class GfxState { public: - // Construct a default GfxState, for a device with resolution , - // page box (,)-(,), page rotation , and + // Construct a default GfxState, for a device with resolution + // x , page box , page rotation , and // coordinate system specified by . - GfxState(double dpi, double px1a, double py1a, - double px2a, double py2a, int rotate, GBool upsideDown); + GfxState(double hDPI, double vDPI, PDFRectangle *pageBox, + int rotate, GBool upsideDown); // Destructor. ~GfxState(); @@ -771,6 +874,10 @@ public: double getPageHeight() { return pageHeight; } GfxColor *getFillColor() { return &fillColor; } GfxColor *getStrokeColor() { return &strokeColor; } + void getFillGray(double *gray) + { fillColorSpace->getGray(&fillColor, gray); } + void getStrokeGray(double *gray) + { strokeColorSpace->getGray(&strokeColor, gray); } void getFillRGB(GfxRGB *rgb) { fillColorSpace->getRGB(&fillColor, rgb); } void getStrokeRGB(GfxRGB *rgb) @@ -802,8 +909,12 @@ public: double getRise() { return rise; } int getRender() { return render; } GfxPath *getPath() { return path; } + void setPath(GfxPath *pathA); double getCurX() { return curX; } double getCurY() { return curY; } + void getClipBBox(double *xMin, double *yMin, double *xMax, double *yMax) + { *xMin = clipXMin; *yMin = clipYMin; *xMax = clipXMax; *yMax = clipYMax; } + void getUserClipBBox(double *xMin, double *yMin, double *xMax, double *yMax); double getLineX() { return lineX; } double getLineY() { return lineY; } @@ -848,9 +959,9 @@ public: void setFlatness(int flatness1) { flatness = flatness1; } void setLineJoin(int lineJoin1) { lineJoin = lineJoin1; } void setLineCap(int lineCap1) { lineCap = lineCap1; } - void setMiterLimit(double miterLimit1) { miterLimit = miterLimit1; } - void setFont(GfxFont *font1, double fontSize1) - { font = font1; fontSize = fontSize1; } + void setMiterLimit(double limit) { miterLimit = limit; } + void setFont(GfxFont *fontA, double fontSizeA) + { font = fontA; fontSize = fontSizeA; } void setTextMat(double a, double b, double c, double d, double e, double f) { textMat[0] = a; textMat[1] = b; textMat[2] = c; @@ -861,12 +972,12 @@ public: { wordSpace = space; } void setHorizScaling(double scale) { horizScaling = 0.01 * scale; } - void setLeading(double leading1) - { leading = leading1; } - void setRise(double rise1) - { rise = rise1; } - void setRender(int render1) - { render = render1; } + void setLeading(double leadingA) + { leading = leadingA; } + void setRise(double riseA) + { rise = riseA; } + void setRender(int renderA) + { render = renderA; } // Add to path. void moveTo(double x, double y) @@ -880,11 +991,15 @@ public: { path->close(); curX = path->getLastX(); curY = path->getLastY(); } void clearPath(); + // Update clip region. + void clip(); + // Text position. + void textSetPos(double tx, double ty) { lineX = tx; lineY = ty; } void textMoveTo(double tx, double ty) { lineX = tx; lineY = ty; textTransform(tx, ty, &curX, &curY); } - void textShift(double tx); void textShift(double tx, double ty); + void shift(double dx, double dy); // Push/pop GfxState on/off stack. GfxState *save(); @@ -929,6 +1044,9 @@ private: double curX, curY; // current point (user coords) double lineX, lineY; // start of current text line (text coords) + double clipXMin, clipYMin, // bounding box for clip region + clipXMax, clipYMax; + GfxState *saved; // next GfxState on stack GfxState(GfxState *state);