X-Git-Url: https://www.fi.muni.cz/~kas/git//home/kas/public_html/git/?a=blobdiff_plain;f=pdf%2Fxpdf%2FGfxState.h;h=a0b1d14aee56440b9e05a0851e4d7e27739150ef;hb=884f739665dc56e66f51e104350f2affd33f2dd8;hp=2056c4d1fb36f6f110a82fbb08d103f3e3e64e4e;hpb=7aac8dc8533347e21311b15186e0af82f1b22fd6;p=evince.git diff --git a/pdf/xpdf/GfxState.h b/pdf/xpdf/GfxState.h index 2056c4d1..a0b1d14a 100644 --- a/pdf/xpdf/GfxState.h +++ b/pdf/xpdf/GfxState.h @@ -2,29 +2,32 @@ // // 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; //------------------------------------------------------------------------ // GfxColor //------------------------------------------------------------------------ -#define gfxColorMaxComps 8 +#define gfxColorMaxComps funcMaxOutputs struct GfxColor { double c[gfxColorMaxComps]; @@ -50,6 +53,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 +93,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 +212,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 +294,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 +331,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 +352,7 @@ public: GfxColorSpace *getBase() { return base; } int getIndexHigh() { return indexHigh; } Guchar *getLookup() { return lookup; } + GfxColor *mapColorToBase(GfxColor *color, GfxColor *baseColor); private: @@ -356,8 +368,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; } @@ -405,7 +417,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: @@ -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); @@ -504,94 +518,100 @@ private: }; //------------------------------------------------------------------------ -// Function +// GfxShading //------------------------------------------------------------------------ -#define funcMaxInputs 1 -#define funcMaxOutputs 8 - -class Function { +class GfxShading { public: - Function(); - - virtual ~Function(); - - // Construct a function. Returns NULL if unsuccessful. - static Function *parse(Object *funcObj); + GfxShading(); + virtual ~GfxShading(); - // Initialize the entries common to all function types. - GBool init(Dict *dict); + static GfxShading *parse(Object *obj); - virtual Function *copy() = 0; - - // Return size of input and output tuples. - int getInputSize() { return m; } - int getOutputSize() { return n; } - - // Transform an input tuple into an output tuple. - virtual void transform(double *in, double *out) = 0; - - virtual GBool isOk() = 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: +private: - 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 + int type; + GfxColorSpace *colorSpace; + GfxColor background; + GBool hasBackground; + double xMin, yMin, xMax, yMax; + GBool hasBBox; }; //------------------------------------------------------------------------ -// SampledFunction +// GfxAxialShading //------------------------------------------------------------------------ -class SampledFunction: public Function { +class GfxAxialShading: 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; } + GfxAxialShading(double x0A, double y0A, + double x1A, double y1A, + double t0A, double t1A, + Function **funcsA, int nFuncsA, + GBool extend0A, GBool extend1A); + virtual ~GfxAxialShading(); -private: + static GfxAxialShading *parse(Dict *dict); - SampledFunction(SampledFunction *func); + 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; } - 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; +private: + + double x0, y0, x1, y1; + double t0, t1; + Function *funcs[gfxColorMaxComps]; + int nFuncs; + GBool extend0, extend1; }; //------------------------------------------------------------------------ -// ExponentialFunction +// GfxRadialShading //------------------------------------------------------------------------ -class ExponentialFunction: public Function { +class GfxRadialShading: 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; } + 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); + virtual ~GfxRadialShading(); -private: + static GfxRadialShading *parse(Dict *dict); - ExponentialFunction(ExponentialFunction *func); + 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; } - double c0[funcMaxOutputs]; - double c1[funcMaxOutputs]; - double e; - GBool ok; +private: + + double x0, y0, r0, x1, y1, r1; + double t0, t1; + Function *funcs[gfxColorMaxComps]; + int nFuncs; + GBool extend0, extend1; }; //------------------------------------------------------------------------ @@ -602,7 +622,7 @@ class GfxImageColorMap { public: // Constructor. - GfxImageColorMap(int bits, Object *decode, GfxColorSpace *colorSpace); + GfxImageColorMap(int bitsA, Object *decode, GfxColorSpace *colorSpaceA); // Destructor. ~GfxImageColorMap(); @@ -625,6 +645,7 @@ 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: @@ -728,7 +749,7 @@ public: double x3, double y3); // Close the last subpath. - void close() { subpaths[n-1]->close(); } + void close(); private: @@ -750,10 +771,10 @@ class GfxState { public: // Construct a default GfxState, for a device with resolution , - // page box (,)-(,), page rotation , and - // coordinate system specified by . - GfxState(double dpi, double px1a, double py1a, - double px2a, double py2a, int rotate, GBool upsideDown); + // page box , page rotation , and coordinate system + // specified by . + GfxState(double dpi, PDFRectangle *pageBox, int rotate, + GBool upsideDown); // Destructor. ~GfxState(); @@ -771,6 +792,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(&fillColor, gray); } void getFillRGB(GfxRGB *rgb) { fillColorSpace->getRGB(&fillColor, rgb); } void getStrokeRGB(GfxRGB *rgb) @@ -804,6 +829,9 @@ public: GfxPath *getPath() { return path; } 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 +876,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 +889,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 +908,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 +961,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);