pdf2swf/xpdf/GfxState.h

   1 //========================================================================
   2 //
   3 // GfxState.h
   4 //
   5 // Copyright 1996-2002 Glyph & Cog, LLC
   6 //
   7 //========================================================================
   8
   9 #ifndef GFXSTATE_H
  10 #define GFXSTATE_H
  11
  12 #ifdef __GNUC__
  13 #pragma interface
  14 #endif
  15
  16 #include "gtypes.h"
  17 #include "Object.h"
  18 #include "Function.h"
  19
  20 class Array;
  21 class GfxFont;
  22 struct PDFRectangle;
  23
  24 //------------------------------------------------------------------------
  25 // GfxColor
  26 //------------------------------------------------------------------------
  27
  28 #define gfxColorMaxComps funcMaxOutputs
  29
  30 struct GfxColor {
  31   double c[gfxColorMaxComps];
  32 };
  33
  34 //------------------------------------------------------------------------
  35 // GfxRGB
  36 //------------------------------------------------------------------------
  37
  38 struct GfxRGB {
  39   double r, g, b;
  40 };
  41
  42 //------------------------------------------------------------------------
  43 // GfxCMYK
  44 //------------------------------------------------------------------------
  45
  46 struct GfxCMYK {
  47   double c, m, y, k;
  48 };
  49
  50 //------------------------------------------------------------------------
  51 // GfxColorSpace
  52 //------------------------------------------------------------------------
  53
  54 enum GfxColorSpaceMode {
  55   csDeviceGray,
  56   csCalGray,
  57   csDeviceRGB,
  58   csCalRGB,
  59   csDeviceCMYK,
  60   csLab,
  61   csICCBased,
  62   csIndexed,
  63   csSeparation,
  64   csDeviceN,
  65   csPattern
  66 };
  67
  68 class GfxColorSpace {
  69 public:
  70
  71   GfxColorSpace();
  72   virtual ~GfxColorSpace();
  73   virtual GfxColorSpace *copy() = 0;
  74   virtual GfxColorSpaceMode getMode() = 0;
  75
  76   // Construct a color space.  Returns NULL if unsuccessful.
  77   static GfxColorSpace *parse(Object *csObj);
  78
  79   // Convert to gray, RGB, or CMYK.
  80   virtual void getGray(GfxColor *color, double *gray) = 0;
  81   virtual void getRGB(GfxColor *color, GfxRGB *rgb) = 0;
  82   virtual void getCMYK(GfxColor *color, GfxCMYK *cmyk) = 0;
  83
  84   // Return the number of color components.
  85   virtual int getNComps() = 0;
  86
  87   // Return the default ranges for each component, assuming an image
  88   // with a max pixel value of <maxImgPixel>.
  89   virtual void getDefaultRanges(double *decodeLow, double *decodeRange,
  90                                 int maxImgPixel);
  91
  92 private:
  93 };
  94
  95 //------------------------------------------------------------------------
  96 // GfxDeviceGrayColorSpace
  97 //------------------------------------------------------------------------
  98
  99 class GfxDeviceGrayColorSpace: public GfxColorSpace {
 100 public:
 101
 102   GfxDeviceGrayColorSpace();
 103   virtual ~GfxDeviceGrayColorSpace();
 104   virtual GfxColorSpace *copy();
 105   virtual GfxColorSpaceMode getMode() { return csDeviceGray; }
 106
 107   virtual void getGray(GfxColor *color, double *gray);
 108   virtual void getRGB(GfxColor *color, GfxRGB *rgb);
 109   virtual void getCMYK(GfxColor *color, GfxCMYK *cmyk);
 110
 111   virtual int getNComps() { return 1; }
 112
 113 private:
 114 };
 115
 116 //------------------------------------------------------------------------
 117 // GfxCalGrayColorSpace
 118 //------------------------------------------------------------------------
 119
 120 class GfxCalGrayColorSpace: public GfxColorSpace {
 121 public:
 122
 123   GfxCalGrayColorSpace();
 124   virtual ~GfxCalGrayColorSpace();
 125   virtual GfxColorSpace *copy();
 126   virtual GfxColorSpaceMode getMode() { return csCalGray; }
 127
 128   // Construct a CalGray color space.  Returns NULL if unsuccessful.
 129   static GfxColorSpace *parse(Array *arr);
 130
 131   virtual void getGray(GfxColor *color, double *gray);
 132   virtual void getRGB(GfxColor *color, GfxRGB *rgb);
 133   virtual void getCMYK(GfxColor *color, GfxCMYK *cmyk);
 134
 135   virtual int getNComps() { return 1; }
 136
 137   // CalGray-specific access.
 138   double getWhiteX() { return whiteX; }
 139   double getWhiteY() { return whiteY; }
 140   double getWhiteZ() { return whiteZ; }
 141   double getBlackX() { return blackX; }
 142   double getBlackY() { return blackY; }
 143   double getBlackZ() { return blackZ; }
 144   double getGamma() { return gamma; }
 145
 146 private:
 147
 148   double whiteX, whiteY, whiteZ;    // white point
 149   double blackX, blackY, blackZ;    // black point
 150   double gamma;                     // gamma value
 151 };
 152
 153 //------------------------------------------------------------------------
 154 // GfxDeviceRGBColorSpace
 155 //------------------------------------------------------------------------
 156
 157 class GfxDeviceRGBColorSpace: public GfxColorSpace {
 158 public:
 159
 160   GfxDeviceRGBColorSpace();
 161   virtual ~GfxDeviceRGBColorSpace();
 162   virtual GfxColorSpace *copy();
 163   virtual GfxColorSpaceMode getMode() { return csDeviceRGB; }
 164
 165   virtual void getGray(GfxColor *color, double *gray);
 166   virtual void getRGB(GfxColor *color, GfxRGB *rgb);
 167   virtual void getCMYK(GfxColor *color, GfxCMYK *cmyk);
 168
 169   virtual int getNComps() { return 3; }
 170
 171 private:
 172 };
 173
 174 //------------------------------------------------------------------------
 175 // GfxCalRGBColorSpace
 176 //------------------------------------------------------------------------
 177
 178 class GfxCalRGBColorSpace: public GfxColorSpace {
 179 public:
 180
 181   GfxCalRGBColorSpace();
 182   virtual ~GfxCalRGBColorSpace();
 183   virtual GfxColorSpace *copy();
 184   virtual GfxColorSpaceMode getMode() { return csCalRGB; }
 185
 186   // Construct a CalRGB color space.  Returns NULL if unsuccessful.
 187   static GfxColorSpace *parse(Array *arr);
 188
 189   virtual void getGray(GfxColor *color, double *gray);
 190   virtual void getRGB(GfxColor *color, GfxRGB *rgb);
 191   virtual void getCMYK(GfxColor *color, GfxCMYK *cmyk);
 192
 193   virtual int getNComps() { return 3; }
 194
 195   // CalRGB-specific access.
 196   double getWhiteX() { return whiteX; }
 197   double getWhiteY() { return whiteY; }
 198   double getWhiteZ() { return whiteZ; }
 199   double getBlackX() { return blackX; }
 200   double getBlackY() { return blackY; }
 201   double getBlackZ() { return blackZ; }
 202   double getGammaR() { return gammaR; }
 203   double getGammaG() { return gammaG; }
 204   double getGammaB() { return gammaB; }
 205   double *getMatrix() { return mat; }
 206
 207 private:
 208
 209   double whiteX, whiteY, whiteZ;    // white point
 210   double blackX, blackY, blackZ;    // black point
 211   double gammaR, gammaG, gammaB;    // gamma values
 212   double mat[9];                // ABC -> XYZ transform matrix
 213 };
 214
 215 //------------------------------------------------------------------------
 216 // GfxDeviceCMYKColorSpace
 217 //------------------------------------------------------------------------
 218
 219 class GfxDeviceCMYKColorSpace: public GfxColorSpace {
 220 public:
 221
 222   GfxDeviceCMYKColorSpace();
 223   virtual ~GfxDeviceCMYKColorSpace();
 224   virtual GfxColorSpace *copy();
 225   virtual GfxColorSpaceMode getMode() { return csDeviceCMYK; }
 226
 227   virtual void getGray(GfxColor *color, double *gray);
 228   virtual void getRGB(GfxColor *color, GfxRGB *rgb);
 229   virtual void getCMYK(GfxColor *color, GfxCMYK *cmyk);
 230
 231   virtual int getNComps() { return 4; }
 232
 233 private:
 234 };
 235
 236 //------------------------------------------------------------------------
 237 // GfxLabColorSpace
 238 //------------------------------------------------------------------------
 239
 240 class GfxLabColorSpace: public GfxColorSpace {
 241 public:
 242
 243   GfxLabColorSpace();
 244   virtual ~GfxLabColorSpace();
 245   virtual GfxColorSpace *copy();
 246   virtual GfxColorSpaceMode getMode() { return csLab; }
 247
 248   // Construct a Lab color space.  Returns NULL if unsuccessful.
 249   static GfxColorSpace *parse(Array *arr);
 250
 251   virtual void getGray(GfxColor *color, double *gray);
 252   virtual void getRGB(GfxColor *color, GfxRGB *rgb);
 253   virtual void getCMYK(GfxColor *color, GfxCMYK *cmyk);
 254
 255   virtual int getNComps() { return 3; }
 256
 257   virtual void getDefaultRanges(double *decodeLow, double *decodeRange,
 258                                 int maxImgPixel);
 259
 260   // Lab-specific access.
 261   double getWhiteX() { return whiteX; }
 262   double getWhiteY() { return whiteY; }
 263   double getWhiteZ() { return whiteZ; }
 264   double getBlackX() { return blackX; }
 265   double getBlackY() { return blackY; }
 266   double getBlackZ() { return blackZ; }
 267   double getAMin() { return aMin; }
 268   double getAMax() { return aMax; }
 269   double getBMin() { return bMin; }
 270   double getBMax() { return bMax; }
 271
 272 private:
 273
 274   double whiteX, whiteY, whiteZ;    // white point
 275   double blackX, blackY, blackZ;    // black point
 276   double aMin, aMax, bMin, bMax;    // range for the a and b components
 277   double kr, kg, kb;                // gamut mapping mulitpliers
 278 };
 279
 280 //------------------------------------------------------------------------
 281 // GfxICCBasedColorSpace
 282 //------------------------------------------------------------------------
 283
 284 class GfxICCBasedColorSpace: public GfxColorSpace {
 285 public:
 286
 287   GfxICCBasedColorSpace(int nCompsA, GfxColorSpace *altA,
 288                         Ref *iccProfileStreamA);
 289   virtual ~GfxICCBasedColorSpace();
 290   virtual GfxColorSpace *copy();
 291   virtual GfxColorSpaceMode getMode() { return csICCBased; }
 292
 293   // Construct an ICCBased color space.  Returns NULL if unsuccessful.
 294   static GfxColorSpace *parse(Array *arr);
 295
 296   virtual void getGray(GfxColor *color, double *gray);
 297   virtual void getRGB(GfxColor *color, GfxRGB *rgb);
 298   virtual void getCMYK(GfxColor *color, GfxCMYK *cmyk);
 299
 300   virtual int getNComps() { return nComps; }
 301
 302   virtual void getDefaultRanges(double *decodeLow, double *decodeRange,
 303                                 int maxImgPixel);
 304
 305   // ICCBased-specific access.
 306   GfxColorSpace *getAlt() { return alt; }
 307
 308 private:
 309
 310   int nComps;                   // number of color components (1, 3, or 4)
 311   GfxColorSpace *alt;           // alternate color space
 312   double rangeMin[4];           // min values for each component
 313   double rangeMax[4];           // max values for each component
 314   Ref iccProfileStream;         // the ICC profile
 315 };
 316
 317 //------------------------------------------------------------------------
 318 // GfxIndexedColorSpace
 319 //------------------------------------------------------------------------
 320
 321 class GfxIndexedColorSpace: public GfxColorSpace {
 322 public:
 323
 324   GfxIndexedColorSpace(GfxColorSpace *baseA, int indexHighA);
 325   virtual ~GfxIndexedColorSpace();
 326   virtual GfxColorSpace *copy();
 327   virtual GfxColorSpaceMode getMode() { return csIndexed; }
 328
 329   // Construct a Lab color space.  Returns NULL if unsuccessful.
 330   static GfxColorSpace *parse(Array *arr);
 331
 332   virtual void getGray(GfxColor *color, double *gray);
 333   virtual void getRGB(GfxColor *color, GfxRGB *rgb);
 334   virtual void getCMYK(GfxColor *color, GfxCMYK *cmyk);
 335
 336   virtual int getNComps() { return 1; }
 337
 338   virtual void getDefaultRanges(double *decodeLow, double *decodeRange,
 339                                 int maxImgPixel);
 340
 341   // Indexed-specific access.
 342   GfxColorSpace *getBase() { return base; }
 343   int getIndexHigh() { return indexHigh; }
 344   Guchar *getLookup() { return lookup; }
 345
 346 private:
 347
 348   GfxColorSpace *base;          // base color space
 349   int indexHigh;                // max pixel value
 350   Guchar *lookup;               // lookup table
 351 };
 352
 353 //------------------------------------------------------------------------
 354 // GfxSeparationColorSpace
 355 //------------------------------------------------------------------------
 356
 357 class GfxSeparationColorSpace: public GfxColorSpace {
 358 public:
 359
 360   GfxSeparationColorSpace(GString *nameA, GfxColorSpace *altA,
 361                           Function *funcA);
 362   virtual ~GfxSeparationColorSpace();
 363   virtual GfxColorSpace *copy();
 364   virtual GfxColorSpaceMode getMode() { return csSeparation; }
 365
 366   // Construct a Separation color space.  Returns NULL if unsuccessful.
 367   static GfxColorSpace *parse(Array *arr);
 368
 369   virtual void getGray(GfxColor *color, double *gray);
 370   virtual void getRGB(GfxColor *color, GfxRGB *rgb);
 371   virtual void getCMYK(GfxColor *color, GfxCMYK *cmyk);
 372
 373   virtual int getNComps() { return 1; }
 374
 375   // Separation-specific access.
 376   GString *getName() { return name; }
 377   GfxColorSpace *getAlt() { return alt; }
 378   Function *getFunc() { return func; }
 379
 380 private:
 381
 382   GString *name;                // colorant name
 383   GfxColorSpace *alt;           // alternate color space
 384   Function *func;               // tint transform (into alternate color space)
 385 };
 386
 387 //------------------------------------------------------------------------
 388 // GfxDeviceNColorSpace
 389 //------------------------------------------------------------------------
 390
 391 class GfxDeviceNColorSpace: public GfxColorSpace {
 392 public:
 393
 394   GfxDeviceNColorSpace(int nComps, GfxColorSpace *alt, Function *func);
 395   virtual ~GfxDeviceNColorSpace();
 396   virtual GfxColorSpace *copy();
 397   virtual GfxColorSpaceMode getMode() { return csDeviceN; }
 398
 399   // Construct a DeviceN color space.  Returns NULL if unsuccessful.
 400   static GfxColorSpace *parse(Array *arr);
 401
 402   virtual void getGray(GfxColor *color, double *gray);
 403   virtual void getRGB(GfxColor *color, GfxRGB *rgb);
 404   virtual void getCMYK(GfxColor *color, GfxCMYK *cmyk);
 405
 406   virtual int getNComps() { return nComps; }
 407
 408   // DeviceN-specific access.
 409   GfxColorSpace *getAlt() { return alt; }
 410
 411 private:
 412
 413   int nComps;                   // number of components
 414   GString                       // colorant names
 415     *names[gfxColorMaxComps];
 416   GfxColorSpace *alt;           // alternate color space
 417   Function *func;               // tint transform (into alternate color space)
 418
 419 };
 420
 421 //------------------------------------------------------------------------
 422 // GfxPatternColorSpace
 423 //------------------------------------------------------------------------
 424
 425 class GfxPatternColorSpace: public GfxColorSpace {
 426 public:
 427
 428   GfxPatternColorSpace(GfxColorSpace *underA);
 429   virtual ~GfxPatternColorSpace();
 430   virtual GfxColorSpace *copy();
 431   virtual GfxColorSpaceMode getMode() { return csPattern; }
 432
 433   // Construct a Pattern color space.  Returns NULL if unsuccessful.
 434   static GfxColorSpace *parse(Array *arr);
 435
 436   virtual void getGray(GfxColor *color, double *gray);
 437   virtual void getRGB(GfxColor *color, GfxRGB *rgb);
 438   virtual void getCMYK(GfxColor *color, GfxCMYK *cmyk);
 439
 440   virtual int getNComps() { return 0; }
 441
 442   // Pattern-specific access.
 443   GfxColorSpace *getUnder() { return under; }
 444
 445 private:
 446
 447   GfxColorSpace *under;         // underlying color space (for uncolored
 448                                 //   patterns)
 449 };
 450
 451 //------------------------------------------------------------------------
 452 // GfxPattern
 453 //------------------------------------------------------------------------
 454
 455 class GfxPattern {
 456 public:
 457
 458   GfxPattern(int typeA);
 459   virtual ~GfxPattern();
 460
 461   static GfxPattern *parse(Object *obj);
 462
 463   virtual GfxPattern *copy() = 0;
 464
 465   int getType() { return type; }
 466
 467 private:
 468
 469   int type;
 470 };
 471
 472 //------------------------------------------------------------------------
 473 // GfxTilingPattern
 474 //------------------------------------------------------------------------
 475
 476 class GfxTilingPattern: public GfxPattern {
 477 public:
 478
 479   GfxTilingPattern(Dict *streamDict, Object *stream);
 480   virtual ~GfxTilingPattern();
 481
 482   virtual GfxPattern *copy();
 483
 484   int getPaintType() { return paintType; }
 485   int getTilingType() { return tilingType; }
 486   double *getBBox() { return bbox; }
 487   double getXStep() { return xStep; }
 488   double getYStep() { return yStep; }
 489   Dict *getResDict()
 490     { return resDict.isDict() ? resDict.getDict() : (Dict *)NULL; }
 491   double *getMatrix() { return matrix; }
 492   Object *getContentStream() { return &contentStream; }
 493
 494 private:
 495
 496   GfxTilingPattern(GfxTilingPattern *pat);
 497
 498   int paintType;
 499   int tilingType;
 500   double bbox[4];
 501   double xStep, yStep;
 502   Object resDict;
 503   double matrix[6];
 504   Object contentStream;
 505 };
 506
 507 //------------------------------------------------------------------------
 508 // GfxShading
 509 //------------------------------------------------------------------------
 510
 511 class GfxShading {
 512 public:
 513
 514   GfxShading();
 515   virtual ~GfxShading();
 516
 517   static GfxShading *parse(Object *obj);
 518
 519   int getType() { return type; }
 520   GfxColorSpace *getColorSpace() { return colorSpace; }
 521   GfxColor *getBackground() { return &background; }
 522   GBool getHasBackground() { return hasBackground; }
 523   void getBBox(double *xMinA, double *yMinA, double *xMaxA, double *yMaxA)
 524     { *xMinA = xMin; *yMinA = yMin; *xMaxA = xMax; *yMaxA = yMax; }
 525   GBool getHasBBox() { return hasBBox; }
 526
 527 private:
 528
 529   int type;
 530   GfxColorSpace *colorSpace;
 531   GfxColor background;
 532   GBool hasBackground;
 533   double xMin, yMin, xMax, yMax;
 534   GBool hasBBox;
 535 };
 536
 537 //------------------------------------------------------------------------
 538 // GfxAxialShading
 539 //------------------------------------------------------------------------
 540
 541 class GfxAxialShading: public GfxShading {
 542 public:
 543
 544   GfxAxialShading(double x0A, double y0A,
 545                   double x1A, double y1A,
 546                   double t0A, double t1A,
 547                   Function **funcsA, int nFuncsA,
 548                   GBool extend0A, GBool extend1A);
 549   virtual ~GfxAxialShading();
 550
 551   static GfxAxialShading *parse(Dict *dict);
 552
 553   void getCoords(double *x0A, double *y0A, double *x1A, double *y1A)
 554     { *x0A = x0; *y0A = y0; *x1A = x1; *y1A = y1; }
 555   double getDomain0() { return t0; }
 556   double getDomain1() { return t1; }
 557   void getColor(double t, GfxColor *color);
 558   GBool getExtend0() { return extend0; }
 559   GBool getExtend1() { return extend1; }
 560
 561 private:
 562
 563   double x0, y0, x1, y1;
 564   double t0, t1;
 565   Function *funcs[gfxColorMaxComps];
 566   int nFuncs;
 567   GBool extend0, extend1;
 568 };
 569
 570 //------------------------------------------------------------------------
 571 // GfxRadialShading
 572 //------------------------------------------------------------------------
 573
 574 class GfxRadialShading: public GfxShading {
 575 public:
 576
 577   GfxRadialShading(double x0A, double y0A, double r0A,
 578                    double x1A, double y1A, double r1A,
 579                    double t0A, double t1A,
 580                    Function **funcsA, int nFuncsA,
 581                    GBool extend0A, GBool extend1A);
 582   virtual ~GfxRadialShading();
 583
 584   static GfxRadialShading *parse(Dict *dict);
 585
 586   void getCoords(double *x0A, double *y0A, double *r0A,
 587                  double *x1A, double *y1A, double *r1A)
 588     { *x0A = x0; *y0A = y0; *r0A = r0; *x1A = x1; *y1A = y1; *r1A = r1; }
 589   double getDomain0() { return t0; }
 590   double getDomain1() { return t1; }
 591   void getColor(double t, GfxColor *color);
 592   GBool getExtend0() { return extend0; }
 593   GBool getExtend1() { return extend1; }
 594
 595 private:
 596
 597   double x0, y0, r0, x1, y1, r1;
 598   double t0, t1;
 599   Function *funcs[gfxColorMaxComps];
 600   int nFuncs;
 601   GBool extend0, extend1;
 602 };
 603
 604 //------------------------------------------------------------------------
 605 // GfxImageColorMap
 606 //------------------------------------------------------------------------
 607
 608 class GfxImageColorMap {
 609 public:
 610
 611   // Constructor.
 612   GfxImageColorMap(int bitsA, Object *decode, GfxColorSpace *colorSpaceA);
 613
 614   // Destructor.
 615   ~GfxImageColorMap();
 616
 617   // Is color map valid?
 618   GBool isOk() { return ok; }
 619
 620   // Get the color space.
 621   GfxColorSpace *getColorSpace() { return colorSpace; }
 622
 623   // Get stream decoding info.
 624   int getNumPixelComps() { return nComps; }
 625   int getBits() { return bits; }
 626
 627   // Get decode table.
 628   double getDecodeLow(int i) { return decodeLow[i]; }
 629   double getDecodeHigh(int i) { return decodeLow[i] + decodeRange[i]; }
 630
 631   // Convert an image pixel to a color.
 632   void getGray(Guchar *x, double *gray);
 633   void getRGB(Guchar *x, GfxRGB *rgb);
 634   void getCMYK(Guchar *x, GfxCMYK *cmyk);
 635
 636 private:
 637
 638   GfxColorSpace *colorSpace;    // the image color space
 639   int bits;                     // bits per component
 640   int nComps;                   // number of components in a pixel
 641   GfxColorSpace *colorSpace2;   // secondary color space
 642   int nComps2;                  // number of components in colorSpace2
 643   double *lookup;               // lookup table
 644   double                        // minimum values for each component
 645     decodeLow[gfxColorMaxComps];
 646   double                        // max - min value for each component
 647     decodeRange[gfxColorMaxComps];
 648   GBool ok;
 649 };
 650
 651 //------------------------------------------------------------------------
 652 // GfxSubpath and GfxPath
 653 //------------------------------------------------------------------------
 654
 655 class GfxSubpath {
 656 public:
 657
 658   // Constructor.
 659   GfxSubpath(double x1, double y1);
 660
 661   // Destructor.
 662   ~GfxSubpath();
 663
 664   // Copy.
 665   GfxSubpath *copy() { return new GfxSubpath(this); }
 666
 667   // Get points.
 668   int getNumPoints() { return n; }
 669   double getX(int i) { return x[i]; }
 670   double getY(int i) { return y[i]; }
 671   GBool getCurve(int i) { return curve[i]; }
 672
 673   // Get last point.
 674   double getLastX() { return x[n-1]; }
 675   double getLastY() { return y[n-1]; }
 676
 677   // Add a line segment.
 678   void lineTo(double x1, double y1);
 679
 680   // Add a Bezier curve.
 681   void curveTo(double x1, double y1, double x2, double y2,
 682                double x3, double y3);
 683
 684   // Close the subpath.
 685   void close();
 686   GBool isClosed() { return closed; }
 687
 688 private:
 689
 690   double *x, *y;                // points
 691   GBool *curve;                 // curve[i] => point i is a control point
 692                                 //   for a Bezier curve
 693   int n;                        // number of points
 694   int size;                     // size of x/y arrays
 695   GBool closed;                 // set if path is closed
 696
 697   GfxSubpath(GfxSubpath *subpath);
 698 };
 699
 700 class GfxPath {
 701 public:
 702
 703   // Constructor.
 704   GfxPath();
 705
 706   // Destructor.
 707   ~GfxPath();
 708
 709   // Copy.
 710   GfxPath *copy()
 711     { return new GfxPath(justMoved, firstX, firstY, subpaths, n, size); }
 712
 713   // Is there a current point?
 714   GBool isCurPt() { return n > 0 || justMoved; }
 715
 716   // Is the path non-empty, i.e., is there at least one segment?
 717   GBool isPath() { return n > 0; }
 718
 719   // Get subpaths.
 720   int getNumSubpaths() { return n; }
 721   GfxSubpath *getSubpath(int i) { return subpaths[i]; }
 722
 723   // Get last point on last subpath.
 724   double getLastX() { return subpaths[n-1]->getLastX(); }
 725   double getLastY() { return subpaths[n-1]->getLastY(); }
 726
 727   // Move the current point.
 728   void moveTo(double x, double y);
 729
 730   // Add a segment to the last subpath.
 731   void lineTo(double x, double y);
 732
 733   // Add a Bezier curve to the last subpath
 734   void curveTo(double x1, double y1, double x2, double y2,
 735                double x3, double y3);
 736
 737   // Close the last subpath.
 738   void close();
 739
 740 private:
 741
 742   GBool justMoved;              // set if a new subpath was just started
 743   double firstX, firstY;        // first point in new subpath
 744   GfxSubpath **subpaths;        // subpaths
 745   int n;                        // number of subpaths
 746   int size;                     // size of subpaths array
 747
 748   GfxPath(GBool justMoved1, double firstX1, double firstY1,
 749           GfxSubpath **subpaths1, int n1, int size1);
 750 };
 751
 752 //------------------------------------------------------------------------
 753 // GfxState
 754 //------------------------------------------------------------------------
 755
 756 class GfxState {
 757 public:
 758
 759   // Construct a default GfxState, for a device with resolution <dpi>,
 760   // page box <pageBox>, page rotation <rotate>, and coordinate system
 761   // specified by <upsideDown>.
 762   GfxState(double dpi, PDFRectangle *pageBox, int rotate,
 763            GBool upsideDown);
 764
 765   // Destructor.
 766   ~GfxState();
 767
 768   // Copy.
 769   GfxState *copy() { return new GfxState(this); }
 770
 771   // Accessors.
 772   double *getCTM() { return ctm; }
 773   double getX1() { return px1; }
 774   double getY1() { return py1; }
 775   double getX2() { return px2; }
 776   double getY2() { return py2; }
 777   double getPageWidth() { return pageWidth; }
 778   double getPageHeight() { return pageHeight; }
 779   GfxColor *getFillColor() { return &fillColor; }
 780   GfxColor *getStrokeColor() { return &strokeColor; }
 781   void getFillGray(double *gray)
 782     { fillColorSpace->getGray(&fillColor, gray); }
 783   void getStrokeGray(double *gray)
 784     { strokeColorSpace->getGray(&fillColor, gray); }
 785   void getFillRGB(GfxRGB *rgb)
 786     { fillColorSpace->getRGB(&fillColor, rgb); }
 787   void getStrokeRGB(GfxRGB *rgb)
 788     { strokeColorSpace->getRGB(&strokeColor, rgb); }
 789   void getFillCMYK(GfxCMYK *cmyk)
 790     { fillColorSpace->getCMYK(&fillColor, cmyk); }
 791   void getStrokeCMYK(GfxCMYK *cmyk)
 792     { strokeColorSpace->getCMYK(&strokeColor, cmyk); }
 793   GfxColorSpace *getFillColorSpace() { return fillColorSpace; }
 794   GfxColorSpace *getStrokeColorSpace() { return strokeColorSpace; }
 795   GfxPattern *getFillPattern() { return fillPattern; }
 796   GfxPattern *getStrokePattern() { return strokePattern; }
 797   double getFillOpacity() { return fillOpacity; }
 798   double getStrokeOpacity() { return strokeOpacity; }
 799   double getLineWidth() { return lineWidth; }
 800   void getLineDash(double **dash, int *length, double *start)
 801     { *dash = lineDash; *length = lineDashLength; *start = lineDashStart; }
 802   int getFlatness() { return flatness; }
 803   int getLineJoin() { return lineJoin; }
 804   int getLineCap() { return lineCap; }
 805   double getMiterLimit() { return miterLimit; }
 806   GfxFont *getFont() { return font; }
 807   double getFontSize() { return fontSize; }
 808   double *getTextMat() { return textMat; }
 809   double getCharSpace() { return charSpace; }
 810   double getWordSpace() { return wordSpace; }
 811   double getHorizScaling() { return horizScaling; }
 812   double getLeading() { return leading; }
 813   double getRise() { return rise; }
 814   int getRender() { return render; }
 815   GfxPath *getPath() { return path; }
 816   double getCurX() { return curX; }
 817   double getCurY() { return curY; }
 818   void getClipBBox(double *xMin, double *yMin, double *xMax, double *yMax)
 819     { *xMin = clipXMin; *yMin = clipYMin; *xMax = clipXMax; *yMax = clipYMax; }
 820   void getUserClipBBox(double *xMin, double *yMin, double *xMax, double *yMax);
 821   double getLineX() { return lineX; }
 822   double getLineY() { return lineY; }
 823
 824   // Is there a current point/path?
 825   GBool isCurPt() { return path->isCurPt(); }
 826   GBool isPath() { return path->isPath(); }
 827
 828   // Transforms.
 829   void transform(double x1, double y1, double *x2, double *y2)
 830     { *x2 = ctm[0] * x1 + ctm[2] * y1 + ctm[4];
 831       *y2 = ctm[1] * x1 + ctm[3] * y1 + ctm[5]; }
 832   void transformDelta(double x1, double y1, double *x2, double *y2)
 833     { *x2 = ctm[0] * x1 + ctm[2] * y1;
 834       *y2 = ctm[1] * x1 + ctm[3] * y1; }
 835   void textTransform(double x1, double y1, double *x2, double *y2)
 836     { *x2 = textMat[0] * x1 + textMat[2] * y1 + textMat[4];
 837       *y2 = textMat[1] * x1 + textMat[3] * y1 + textMat[5]; }
 838   void textTransformDelta(double x1, double y1, double *x2, double *y2)
 839     { *x2 = textMat[0] * x1 + textMat[2] * y1;
 840       *y2 = textMat[1] * x1 + textMat[3] * y1; }
 841   double transformWidth(double w);
 842   double getTransformedLineWidth()
 843     { return transformWidth(lineWidth); }
 844   double getTransformedFontSize();
 845   void getFontTransMat(double *m11, double *m12, double *m21, double *m22);
 846
 847   // Change state parameters.
 848   void setCTM(double a, double b, double c,
 849               double d, double e, double f);
 850   void concatCTM(double a, double b, double c,
 851                  double d, double e, double f);
 852   void setFillColorSpace(GfxColorSpace *colorSpace);
 853   void setStrokeColorSpace(GfxColorSpace *colorSpace);
 854   void setFillColor(GfxColor *color) { fillColor = *color; }
 855   void setStrokeColor(GfxColor *color) { strokeColor = *color; }
 856   void setFillPattern(GfxPattern *pattern);
 857   void setStrokePattern(GfxPattern *pattern);
 858   void setFillOpacity(double opac) { fillOpacity = opac; }
 859   void setStrokeOpacity(double opac) { strokeOpacity = opac; }
 860   void setLineWidth(double width) { lineWidth = width; }
 861   void setLineDash(double *dash, int length, double start);
 862   void setFlatness(int flatness1) { flatness = flatness1; }
 863   void setLineJoin(int lineJoin1) { lineJoin = lineJoin1; }
 864   void setLineCap(int lineCap1) { lineCap = lineCap1; }
 865   void setMiterLimit(double limit) { miterLimit = limit; }
 866   void setFont(GfxFont *fontA, double fontSizeA)
 867     { font = fontA; fontSize = fontSizeA; }
 868   void setTextMat(double a, double b, double c,
 869                   double d, double e, double f)
 870     { textMat[0] = a; textMat[1] = b; textMat[2] = c;
 871       textMat[3] = d; textMat[4] = e; textMat[5] = f; }
 872   void setCharSpace(double space)
 873     { charSpace = space; }
 874   void setWordSpace(double space)
 875     { wordSpace = space; }
 876   void setHorizScaling(double scale)
 877     { horizScaling = 0.01 * scale; }
 878   void setLeading(double leadingA)
 879     { leading = leadingA; }
 880   void setRise(double riseA)
 881     { rise = riseA; }
 882   void setRender(int renderA)
 883     { render = renderA; }
 884
 885   // Add to path.
 886   void moveTo(double x, double y)
 887     { path->moveTo(curX = x, curY = y); }
 888   void lineTo(double x, double y)
 889     { path->lineTo(curX = x, curY = y); }
 890   void curveTo(double x1, double y1, double x2, double y2,
 891                double x3, double y3)
 892     { path->curveTo(x1, y1, x2, y2, curX = x3, curY = y3); }
 893   void closePath()
 894     { path->close(); curX = path->getLastX(); curY = path->getLastY(); }
 895   void clearPath();
 896
 897   // Update clip region.
 898   void clip();
 899
 900   // Text position.
 901   void textMoveTo(double tx, double ty)
 902     { lineX = tx; lineY = ty; textTransform(tx, ty, &curX, &curY); }
 903   void textShift(double tx, double ty);
 904   void shift(double dx, double dy);
 905
 906   // Push/pop GfxState on/off stack.
 907   GfxState *save();
 908   GfxState *restore();
 909   GBool hasSaves() { return saved != NULL; }
 910
 911 private:
 912
 913   double ctm[6];                // coord transform matrix
 914   double px1, py1, px2, py2;    // page corners (user coords)
 915   double pageWidth, pageHeight; // page size (pixels)
 916
 917   GfxColorSpace *fillColorSpace;   // fill color space
 918   GfxColorSpace *strokeColorSpace; // stroke color space
 919   GfxColor fillColor;           // fill color
 920   GfxColor strokeColor;         // stroke color
 921   GfxPattern *fillPattern;      // fill pattern
 922   GfxPattern *strokePattern;    // stroke pattern
 923   double fillOpacity;           // fill opacity
 924   double strokeOpacity;         // stroke opacity
 925
 926   double lineWidth;             // line width
 927   double *lineDash;             // line dash
 928   int lineDashLength;
 929   double lineDashStart;
 930   int flatness;                 // curve flatness
 931   int lineJoin;                 // line join style
 932   int lineCap;                  // line cap style
 933   double miterLimit;            // line miter limit
 934
 935   GfxFont *font;                // font
 936   double fontSize;              // font size
 937   double textMat[6];            // text matrix
 938   double charSpace;             // character spacing
 939   double wordSpace;             // word spacing
 940   double horizScaling;          // horizontal scaling
 941   double leading;               // text leading
 942   double rise;                  // text rise
 943   int render;                   // text rendering mode
 944
 945   GfxPath *path;                // array of path elements
 946   double curX, curY;            // current point (user coords)
 947   double lineX, lineY;          // start of current text line (text coords)
 948
 949   double clipXMin, clipYMin,    // bounding box for clip region
 950          clipXMax, clipYMax;
 951
 952   GfxState *saved;              // next GfxState on stack
 953
 954   GfxState(GfxState *state);
 955 };
 956
 957 #endif