PSION CD 2/PsionCDVol2.iso/Programs/720/PDF090B4-SorceCode/pdf/GfxState.h

C/C++ Source or Header | 2000-09-30 | 16.0 KB | 552 lines

//========================================================================
//
// GfxState.h
//
// Copyright 1996 Derek B. Noonburg
//
//========================================================================
//
//
// Ported to EPOC by Sander van der Wal
//
// $Id: GfxState.h 1.3 2000-09-21 14:44:54+02 svdwal Exp svdwal $
//
// Added some faster forms of tranforms, especcially when one value
// is known to be zero all call time
//

#ifndef GFXSTATE_H
#define GFXSTATE_H

#ifdef __GNUC__
#pragma interface
#endif

#ifdef __SYMBIAN32__
#undef FIXCOLOR
#define FIXCOLOR
#endif

#ifndef __E32BASE_H__
#include <e32base.h>
#endif

#include "gtypes.h"

class Object;
class Function;
class GfxFont;

//------------------------------------------------------------------------
// GfxColor
//------------------------------------------------------------------------

#if defined(FIXCOLOR)
class GfxColor {
public:

  GfxColor(): r(0), g(0), b(0) {}

  // Set color.
  void setGray(int gray);
  void setCMYK(int c, int m, int y, int k);
  void setRGB(int r1, int g1, int b1);

  // Accessors.
  int getR() { return r; }
  int getG() { return g; }
  int getB() { return b; }
  int getGray() { return (299 * r + 587 * g + 114 * b) / 1000; }

private:

  int r, g, b;
};
#else
class GfxColor {
public:

  GfxColor(): r(0), g(0), b(0) {}

  // Set color.
  void setGray(double gray);
  void setCMYK(double c, double m, double y, double k);
  void setRGB(double r1, double g1, double b1);

  // Accessors.
  double getR() { return r; }
  double getG() { return g; }
  double getB() { return b; }
  double getGray() { return 0.299 * r + 0.587 * g + 0.114 * b; }

private:

  double r, g, b;
};
#endif

//------------------------------------------------------------------------
// GfxColorSpace
//------------------------------------------------------------------------

enum GfxColorMode {
  colorGray, colorCMYK, colorRGB
};

class GfxColorSpace: public CBase {
public:

  // Construct a colorspace.
  GfxColorSpace() {}
  void ConstructL(Object *colorSpace);

  // Construct a simple colorspace: DeviceGray, DeviceCMYK, or
  // DeviceRGB.
  GfxColorSpace(GfxColorMode mode1);

  // Destructor.
  ~GfxColorSpace();

  // Copy.
  GfxColorSpace *copyL();

  // Is color space valid?
  GBool isOk() { return ok; }

  // Get the color mode.
  GfxColorMode getMode() { return mode; }

  // Get number of components in pixels of this colorspace.
  int getNumPixelComps() { return indexed ? 1 : numComps; }

  // Get number of components in colors of this colorspace.
  int getNumColorComps() { return numComps; }

  // Return true if colorspace is indexed.
  GBool isIndexed() { return indexed; }

  // Get lookup table (only for indexed colorspaces).
  int getIndexHigh() { return indexHigh; }
  Guchar *getLookupVal(int i) { return lookup[i]; }

  // Convert a pixel to a color.
#if defined(FIXCOLOR)
  void getColor(int x[4], GfxColor *color);
#else
  void getColor(double x[4], GfxColor *color);
#endif

private:

  Function *sepFunc;        // separation tint transform function
  GfxColorMode mode;        // color mode
  GBool indexed;        // set for indexed colorspaces
  int numComps;            // number of components in colors
  int indexHigh;        // max pixel for indexed colorspace
  Guchar (*lookup)[4];        // lookup table (only for indexed
                          //   colorspaces)
  GBool ok;            // is color space valid?

  void ConstructL(GfxColorSpace *colorSpace);

  void setMode(Object *colorSpace);
};

//------------------------------------------------------------------------
// Function
//------------------------------------------------------------------------

class Function: public CBase {
public:

  // Create a PDF function object.
  Function() {}
  void ConstructL(Object* funcObj);

  ~Function();

  Function *copyL();

  GBool isOk() { return ok; }

  // Return size of input and output tuples.
  int getInputSize() { return m; }
  int getOutputSize() { return n; }

  // Transform an input tuple into an output tuple.
#ifdef FIXCOLOR
  void transform(int* in, int* out);
#else
  void transform(double *in, double *out);
#endif

private:

  void ConstructL(Function *func);

  int m, n;
  double domain[1][2];
  double range[4][2];
  int sampleSize[1];
  double encode[1][2];
  double decode[4][2];
  double *samples;
  GBool ok;
};

//------------------------------------------------------------------------
// GfxImageColorMap
//------------------------------------------------------------------------

class GfxImageColorMap: public CBase {
public:

  // Constructor.
  GfxImageColorMap(GfxColorSpace *aColorSpace);
  void ConstructL(int bits1, Object *decode);

  // Destructor.
  ~GfxImageColorMap();

  // Is color map valid?
  GBool isOk() { return ok; }

  // Get the color space.
  GfxColorSpace *getColorSpace() { return colorSpace; }

  // Get stream decoding info.
  int getNumPixelComps() { return numComps; }
  int getBits() { return bits; }

  // Get decode table.
  double getDecodeLow(int i) { return decodeLow[i]; }
  double getDecodeHigh(int i) { return decodeLow[i] + decodeRange[i]; }

  // Convert a pixel to a color.
  void getColor(Guchar x[4], GfxColor *color);

private:

  GfxColorSpace *colorSpace;    // the image colorspace
  int bits;            // bits per component
  int numComps;            // number of components in a pixel
  GBool indexed;        // set for indexed color space
  GfxColorMode mode;            // color mode
#if defined(FIXCOLOR)
  int (*lookup)[4];             // lookup table
  int decodeLow[4];        // minimum values for each component
  int decodeRange[4];            // max - min value for each component
#else
  double (*lookup)[4];        // lookup table
  double decodeLow[4];        // minimum values for each component
  double decodeRange[4];    // max - min value for each component
#endif
  GBool ok;
};

//------------------------------------------------------------------------
// GfxSubpath and GfxPath
//------------------------------------------------------------------------

class GfxSubpath: public CBase {
public:

  // Constructor.
  GfxSubpath() {};
  void ConstructL(double x1, double y1);

  // Destructor.
  ~GfxSubpath();

  // Copy.
  GfxSubpath *copyL();

  // Get points.
  int getNumPoints() { return n; }
  double getX(int i) { return x[i]; }
  double getY(int i) { return y[i]; }
  GBool getCurve(int i) { return curve[i]; }

  // Get last point.
  double getLastX() { return x[n-1]; }
  double getLastY() { return y[n-1]; }

  // Add a line segment.
  void lineTo(double x1, double y1);

  // Add a Bezier curve.
  void curveTo(double x1, double y1, double x2, double y2,
           double x3, double y3);

  // Close the subpath.
  void close();
  GBool isClosed() { return closed; }

private:

  double *x, *y;        // points
  GBool *curve;            // curve[i] => point i is a control point
                //   for a Bezier curve
  int n;            // number of points
  int size;            // size of x/y arrays
  GBool closed;            // set if path is closed

  void ConstructL(GfxSubpath *subpath);
};

class GfxPath: public CBase {
public:

  // Constructor.
  GfxPath() {}
  void ConstructL();

  // Destructor.
  ~GfxPath();

  // Copy.
  GfxPath *copyL();

  // Is there a current point?
  GBool isCurPt() { return n > 0 || justMoved; }

  // Is the path non-empty, i.e., is there at least one segment?
  GBool isPath() { return n > 0; }

  // Get subpaths.
  int getNumSubpaths() { return n; }
  GfxSubpath *getSubpath(int i) { return subpaths[i]; }

  // Get last point on last subpath.
  double getLastX() { return subpaths[n-1]->getLastX(); }
  double getLastY() { return subpaths[n-1]->getLastY(); }

  // Move the current point.
  void moveTo(double x, double y);

  // Add a segment to the last subpath.
  void lineTo(double x, double y);

  // Add a Bezier curve to the last subpath
  void curveTo(double x1, double y1, double x2, double y2,
           double x3, double y3);

  // Close the last subpath.
  void close() { subpaths[n-1]->close(); }

private:

  GBool justMoved;        // set if a new subpath was just started
  double firstX, firstY;    // first point in new subpath
  GfxSubpath **subpaths;    // subpaths
  int n;            // number of subpaths
  int size;            // size of subpaths array

  void ConstructL(GBool justMoved1, double firstX1, double firstY1,
      GfxSubpath **subpaths1, int n1, int size1);
};

//------------------------------------------------------------------------
// GfxState
//------------------------------------------------------------------------

class GfxState: public CBase {
public:

  // Construct a default GfxState, for a device with resolution <dpi>,
  // page box (<x1>,<y1>)-(<x2>,<y2>), page rotation <rotate>, and
  // coordinate system specified by <upsideDown>.
  GfxState() {}
  void ConstructL(int dpi, double px1a, double py1a, double px2a, double py2a,
       int rotate, GBool upsideDown);

  // Destructor.
  ~GfxState();

  // Copy.
  GfxState *copyL();

  // Accessors.
  double *getCTM() { return ctm; }
  double getX1() { return px1; }
  double getY1() { return py1; }
  double getX2() { return px2; }
  double getY2() { return py2; }
  double getPageWidth() { return pageWidth; }
  double getPageHeight() { return pageHeight; }
  GfxColor *getFillColor() { return &fillColor; }
  GfxColor *getStrokeColor() { return &strokeColor; }
  double getLineWidth() { return lineWidth; }
  void getLineDash(double **dash, int *length, double *start)
    { *dash = lineDash; *length = lineDashLength; *start = lineDashStart; }
  int getFlatness() { return flatness; }
  int getLineJoin() { return lineJoin; }
  int getLineCap() { return lineCap; }
  double getMiterLimit() { return miterLimit; }
  GfxFont *getFont() { return font; }
  double getFontSize() { return fontSize; }
  double *getTextMat() { return textMat; }
  double getCharSpace() { return charSpace; }
  double getWordSpace() { return wordSpace; }
  double getHorizScaling() { return horizScaling; }
  double getLeading() { return leading; }
  double getRise() { return rise; }
  int getRender() { return render; }
  GfxPath *getPath() { return path; }
  double getCurX() { return curX; }
  double getCurY() { return curY; }
  double getLineX() { return lineX; }
  double getLineY() { return lineY; }

  // Is there a current point/path?
  GBool isCurPt() { return path->isCurPt(); }
  GBool isPath() { return path->isPath(); }

  // Transforms.
  void transform(double x1, double y1, double *x2, double *y2);
  void transformDelta(double x1, double y1, double *x2, double *y2);
  void textTransform(double x1, double y1, double *x2, double *y2);
  void textTransformDelta(double x1, double y1, double *x2, double *y2);
  // special when y1 == 0
  void textTransformDelta(double x1, double *x2, double *y2);
  double transformWidth(double w);
  double getTransformedLineWidth()
    { return transformWidth(lineWidth); }
  double getTransformedFontSize();
  void getFontTransMat(double *m11, double *m12, double *m21, double *m22);

  // Change state parameters.
  void setCTM(double a, double b, double c,
          double d, double e, double f);
  void concatCTM(double a, double b, double c,
         double d, double e, double f);
#if defined(FIXCOLOR)
  void setFillGray(double gray)
    { fillColor.setGray(int(gray * 255.0)); }
  void setFillCMYK(double c, double m, double y, double k)
    { fillColor.setCMYK(int(c*255.0), int(m*255.0), int(y*255.0), int(k*255.0)); }
  void setFillRGB(double r, double g, double b)
    { fillColor.setRGB(int(r*255.0), int(g*255.0), int(b*255.0)); }
  void setStrokeGray(double gray)
    { strokeColor.setGray(int(gray*255.0)); }
  void setStrokeCMYK(double c, double m, double y, double k)
    { strokeColor.setCMYK(int(c*255.0), int(m*255.0), int(y*255.0), int(k*255.0)); }
  void setStrokeRGB(double r, double g, double b)
    { strokeColor.setRGB(int(r*255.0), int(g*255.0), int(b*255.0)); }
#else
  void setFillGray(double gray)
    { fillColor.setGray(gray); }
  void setFillCMYK(double c, double m, double y, double k)
    { fillColor.setCMYK(c, m, y, k); }
  void setFillRGB(double r, double g, double b)
    { fillColor.setRGB(r, g, b); }
  void setStrokeGray(double gray)
    { strokeColor.setGray(gray); }
  void setStrokeCMYK(double c, double m, double y, double k)
    { strokeColor.setCMYK(c, m, y, k); }
  void setStrokeRGB(double r, double g, double b)
    { strokeColor.setRGB(r, g, b); }
#endif
  void setFillColorSpace(GfxColorSpace *colorSpace);
  void setStrokeColorSpace(GfxColorSpace *colorSpace);
#if defined(FIXCOLOR)
  void setFillColor(int x[4])
    { fillColorSpace->getColor(x, &fillColor); }
  void setStrokeColor(int x[4])
    { strokeColorSpace->getColor(x, &strokeColor); }
#else
  void setFillColor(double x[4])
    { fillColorSpace->getColor(x, &fillColor); }
  void setStrokeColor(double x[4])
    { strokeColorSpace->getColor(x, &strokeColor); }
#endif
  void setLineWidth(double width)
    { lineWidth = width; }
  void setLineDash(double *dash, int length, double start);
  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 setTextMat(double a, double b, double c,
          double d, double e, double f);
  void setCharSpace(double space)
    { charSpace = space; }
  void setWordSpace(double space)
    { 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; }

  // Add to path.
  void moveTo(double x, double y)
    { path->moveTo(curX = x, curY = y); }
  void lineTo(double x, double y)
    { path->lineTo(curX = x, curY = y); }
  void curveTo(double x1, double y1, double x2, double y2,
           double x3, double y3)
    { path->curveTo(x1, y1, x2, y2, curX = x3, curY = y3); }
  void closePath()
    { path->close(); curX = path->getLastX(); curY = path->getLastY(); }
  void clearPath();

  // Text position.
  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);
  // Fast textshift when textTransformDelta already has been done
  void textShiftFast(double dx, double dy) { curX += dx; curY += dy;};

  // Push/pop GfxState on/off stack.
  GfxState *save();
  GfxState *restore();
  GBool hasSaves() { return saved != NULL; }

private:

  double ctm[6];        // coord transform matrix
  double px1, py1, px2, py2;    // page corners (user coords)
  double pageWidth, pageHeight;    // page size (pixels)

  GfxColorSpace *fillColorSpace;   // fill color space
  GfxColorSpace *strokeColorSpace; // stroke color space
  GfxColor fillColor;        // fill color
  GfxColor strokeColor;        // stroke color

  double lineWidth;        // line width
  double *lineDash;        // line dash
  int lineDashLength;
  double lineDashStart;
  int flatness;            // curve flatness
  int lineJoin;            // line join style
  int lineCap;            // line cap style
  double miterLimit;        // line miter limit

  GfxFont *font;        // font
  double fontSize;        // font size
  double textMat[6];        // text matrix
  double charSpace;        // character spacing
  double wordSpace;        // word spacing
  double horizScaling;        // horizontal scaling
  double leading;        // text leading
  double rise;            // text rise
  int render;            // text rendering mode

  GfxPath *path;        // array of path elements
  double curX, curY;        // current point (user coords)
  double lineX, lineY;        // start of current text line (text coords)

  GfxState *saved;        // next GfxState on stack

  void ConstructL(GfxState *state);
};

#endif