source: trunk/poppler/mypoppler/poppler/GfxState.h @ 461

Last change on this file since 461 was 461, checked in by Silvan Scherrer, 11 years ago

poppler update to 0.14.2

File size: 41.0 KB
Line 
1//========================================================================
2//
3// GfxState.h
4//
5// Copyright 1996-2003 Glyph & Cog, LLC
6//
7//========================================================================
8
9//========================================================================
10//
11// Modified under the Poppler project - http://poppler.freedesktop.org
12//
13// All changes made under the Poppler project to this file are licensed
14// under GPL version 2 or later
15//
16// Copyright (C) 2005 Kristian HÞgsberg <krh@redhat.com>
17// Copyright (C) 2006, 2007 Jeff Muizelaar <jeff@infidigm.net>
18// Copyright (C) 2006 Carlos Garcia Campos <carlosgc@gnome.org>
19// Copyright (C) 2009 Koji Otani <sho@bbr.jp>
20// Copyright (C) 2009 Albert Astals Cid <aacid@kde.org>
21//
22// To see a description of the changes please see the Changelog file that
23// came with your tarball or type make ChangeLog if you are building from git
24//
25//========================================================================
26
27#ifndef GFXSTATE_H
28#define GFXSTATE_H
29
30#ifdef USE_GCC_PRAGMAS
31#pragma interface
32#endif
33
34#include "goo/gtypes.h"
35#include "Object.h"
36#include "Function.h"
37
38class Array;
39class Gfx;
40class GfxFont;
41class PDFRectangle;
42class GfxShading;
43class PopplerCache;
44
45class Matrix {
46public:
47  double m[6];
48
49  GBool invertTo(Matrix *other);
50  void transform(double x, double y, double *tx, double *ty);
51};
52
53//------------------------------------------------------------------------
54// GfxBlendMode
55//------------------------------------------------------------------------
56 
57enum GfxBlendMode {
58  gfxBlendNormal,
59  gfxBlendMultiply,
60  gfxBlendScreen,
61  gfxBlendOverlay,
62  gfxBlendDarken,
63  gfxBlendLighten,
64  gfxBlendColorDodge,
65  gfxBlendColorBurn,
66  gfxBlendHardLight,
67  gfxBlendSoftLight,
68  gfxBlendDifference,
69  gfxBlendExclusion,
70  gfxBlendHue,
71  gfxBlendSaturation,
72  gfxBlendColor,
73  gfxBlendLuminosity
74};
75
76//------------------------------------------------------------------------
77// GfxColorComp
78//------------------------------------------------------------------------
79
80// 16.16 fixed point color component
81typedef int GfxColorComp;
82
83#define gfxColorComp1 0x10000
84
85static inline GfxColorComp dblToCol(double x) {
86  return (GfxColorComp)(x * gfxColorComp1);
87}
88
89static inline double colToDbl(GfxColorComp x) {
90  return (double)x / (double)gfxColorComp1;
91}
92
93static inline GfxColorComp byteToCol(Guchar x) {
94  // (x / 255) << 16  =  (0.0000000100000001... * x) << 16
95  //                  =  ((x << 8) + (x) + (x >> 8) + ...) << 16
96  //                  =  (x << 8) + (x) + (x >> 7)
97  //                                      [for rounding]
98  return (GfxColorComp)((x << 8) + x + (x >> 7));
99}
100
101static inline Guchar colToByte(GfxColorComp x) {
102  // 255 * x + 0.5  =  256 * x - x + 0x8000
103  return (Guchar)(((x << 8) - x + 0x8000) >> 16);
104}
105
106//------------------------------------------------------------------------
107// GfxColor
108//------------------------------------------------------------------------
109
110#define gfxColorMaxComps funcMaxOutputs
111
112struct GfxColor {
113  GfxColorComp c[gfxColorMaxComps];
114};
115
116//------------------------------------------------------------------------
117// GfxGray
118//------------------------------------------------------------------------
119
120typedef GfxColorComp GfxGray;
121
122//------------------------------------------------------------------------
123// GfxRGB
124//------------------------------------------------------------------------
125
126struct GfxRGB {
127  GfxColorComp r, g, b;
128};
129
130//------------------------------------------------------------------------
131// GfxCMYK
132//------------------------------------------------------------------------
133
134struct GfxCMYK {
135  GfxColorComp c, m, y, k;
136};
137
138//------------------------------------------------------------------------
139// GfxColorSpace
140//------------------------------------------------------------------------
141
142// NB: The nGfxColorSpaceModes constant and the gfxColorSpaceModeNames
143// array defined in GfxState.cc must match this enum.
144enum GfxColorSpaceMode {
145  csDeviceGray,
146  csCalGray,
147  csDeviceRGB,
148  csCalRGB,
149  csDeviceCMYK,
150  csLab,
151  csICCBased,
152  csIndexed,
153  csSeparation,
154  csDeviceN,
155  csPattern
156};
157
158// wrapper of cmsHTRANSFORM to copy
159class GfxColorTransform {
160public:
161  void doTransform(void *in, void *out, unsigned int size);
162  // transformA should be a cmsHTRANSFORM
163  GfxColorTransform(void *transformA);
164  ~GfxColorTransform();
165  void ref();
166  unsigned int unref();
167private:
168  GfxColorTransform() {}
169  void *transform;
170  unsigned int refCount;
171};
172
173class GfxColorSpace {
174public:
175
176  GfxColorSpace();
177  virtual ~GfxColorSpace();
178  virtual GfxColorSpace *copy() = 0;
179  virtual GfxColorSpaceMode getMode() = 0;
180
181  // Construct a color space.  Returns NULL if unsuccessful.
182  static GfxColorSpace *parse(Object *csObj, Gfx *gfx);
183
184  // Convert to gray, RGB, or CMYK.
185  virtual void getGray(GfxColor *color, GfxGray *gray) = 0;
186  virtual void getRGB(GfxColor *color, GfxRGB *rgb) = 0;
187  virtual void getCMYK(GfxColor *color, GfxCMYK *cmyk) = 0;
188  virtual void getGrayLine(Guchar * /*in*/, Guchar * /*out*/, int /*length*/) {}
189  virtual void getRGBLine(Guchar * /*in*/, unsigned int * /*out*/, int /*length*/) {}
190
191  // Does this ColorSpace use getRGBLine?
192  virtual GBool useGetRGBLine() { return gFalse; }
193  // Does this ColorSpace use getGrayLine?
194  virtual GBool useGetGrayLine() { return gFalse; }
195
196  // Return the number of color components.
197  virtual int getNComps() = 0;
198
199  // Get this color space's default color.
200  virtual void getDefaultColor(GfxColor *color) = 0;
201
202  // Return the default ranges for each component, assuming an image
203  // with a max pixel value of <maxImgPixel>.
204  virtual void getDefaultRanges(double *decodeLow, double *decodeRange,
205                                int maxImgPixel);
206
207  // Returns true if painting operations in this color space never
208  // mark the page (e.g., the "None" colorant).
209  virtual GBool isNonMarking() { return gFalse; }
210
211  // Return the number of color space modes
212  static int getNumColorSpaceModes();
213
214  // Return the name of the <idx>th color space mode.
215  static char *getColorSpaceModeName(int idx);
216
217#ifdef USE_CMS
218  static int setupColorProfiles();
219  // displayProfileA should be a cmsHPROFILE
220  static void setDisplayProfile(void *displayProfileA);
221  static void setDisplayProfileName(GooString *name);
222  // result will be a cmsHPROFILE
223  static void *getRGBProfile();
224  // result will be a cmsHPROFILE
225  static void *getDisplayProfile();
226#endif
227};
228
229//------------------------------------------------------------------------
230// GfxDeviceGrayColorSpace
231//------------------------------------------------------------------------
232
233class GfxDeviceGrayColorSpace: public GfxColorSpace {
234public:
235
236  GfxDeviceGrayColorSpace();
237  virtual ~GfxDeviceGrayColorSpace();
238  virtual GfxColorSpace *copy();
239  virtual GfxColorSpaceMode getMode() { return csDeviceGray; }
240
241  virtual void getGray(GfxColor *color, GfxGray *gray);
242  virtual void getRGB(GfxColor *color, GfxRGB *rgb);
243  virtual void getCMYK(GfxColor *color, GfxCMYK *cmyk);
244  virtual void getGrayLine(Guchar *in, Guchar *out, int length);
245  virtual void getRGBLine(Guchar *in, unsigned int *out, int length);
246
247  virtual GBool useGetRGBLine() { return gTrue; }
248  virtual GBool useGetGrayLine() { return gTrue; }
249
250  virtual int getNComps() { return 1; }
251  virtual void getDefaultColor(GfxColor *color);
252
253private:
254};
255
256//------------------------------------------------------------------------
257// GfxCalGrayColorSpace
258//------------------------------------------------------------------------
259
260class GfxCalGrayColorSpace: public GfxColorSpace {
261public:
262
263  GfxCalGrayColorSpace();
264  virtual ~GfxCalGrayColorSpace();
265  virtual GfxColorSpace *copy();
266  virtual GfxColorSpaceMode getMode() { return csCalGray; }
267
268  // Construct a CalGray color space.  Returns NULL if unsuccessful.
269  static GfxColorSpace *parse(Array *arr);
270
271  virtual void getGray(GfxColor *color, GfxGray *gray);
272  virtual void getRGB(GfxColor *color, GfxRGB *rgb);
273  virtual void getCMYK(GfxColor *color, GfxCMYK *cmyk);
274
275  virtual int getNComps() { return 1; }
276  virtual void getDefaultColor(GfxColor *color);
277
278  // CalGray-specific access.
279  double getWhiteX() { return whiteX; }
280  double getWhiteY() { return whiteY; }
281  double getWhiteZ() { return whiteZ; }
282  double getBlackX() { return blackX; }
283  double getBlackY() { return blackY; }
284  double getBlackZ() { return blackZ; }
285  double getGamma() { return gamma; }
286
287private:
288
289  double whiteX, whiteY, whiteZ;    // white point
290  double blackX, blackY, blackZ;    // black point
291  double gamma;                     // gamma value
292  double kr, kg, kb;                // gamut mapping mulitpliers
293  void getXYZ(GfxColor *color, double *pX, double *pY, double *pZ);
294};
295
296//------------------------------------------------------------------------
297// GfxDeviceRGBColorSpace
298//------------------------------------------------------------------------
299
300class GfxDeviceRGBColorSpace: public GfxColorSpace {
301public:
302
303  GfxDeviceRGBColorSpace();
304  virtual ~GfxDeviceRGBColorSpace();
305  virtual GfxColorSpace *copy();
306  virtual GfxColorSpaceMode getMode() { return csDeviceRGB; }
307
308  virtual void getGray(GfxColor *color, GfxGray *gray);
309  virtual void getRGB(GfxColor *color, GfxRGB *rgb);
310  virtual void getCMYK(GfxColor *color, GfxCMYK *cmyk);
311  virtual void getGrayLine(Guchar *in, Guchar *out, int length);
312  virtual void getRGBLine(Guchar *in, unsigned int *out, int length);
313
314  virtual GBool useGetRGBLine() { return gTrue; }
315  virtual GBool useGetGrayLine() { return gTrue; }
316
317  virtual int getNComps() { return 3; }
318  virtual void getDefaultColor(GfxColor *color);
319
320private:
321};
322
323//------------------------------------------------------------------------
324// GfxCalRGBColorSpace
325//------------------------------------------------------------------------
326
327class GfxCalRGBColorSpace: public GfxColorSpace {
328public:
329
330  GfxCalRGBColorSpace();
331  virtual ~GfxCalRGBColorSpace();
332  virtual GfxColorSpace *copy();
333  virtual GfxColorSpaceMode getMode() { return csCalRGB; }
334
335  // Construct a CalRGB color space.  Returns NULL if unsuccessful.
336  static GfxColorSpace *parse(Array *arr);
337
338  virtual void getGray(GfxColor *color, GfxGray *gray);
339  virtual void getRGB(GfxColor *color, GfxRGB *rgb);
340  virtual void getCMYK(GfxColor *color, GfxCMYK *cmyk);
341
342  virtual int getNComps() { return 3; }
343  virtual void getDefaultColor(GfxColor *color);
344
345  // CalRGB-specific access.
346  double getWhiteX() { return whiteX; }
347  double getWhiteY() { return whiteY; }
348  double getWhiteZ() { return whiteZ; }
349  double getBlackX() { return blackX; }
350  double getBlackY() { return blackY; }
351  double getBlackZ() { return blackZ; }
352  double getGammaR() { return gammaR; }
353  double getGammaG() { return gammaG; }
354  double getGammaB() { return gammaB; }
355  double *getMatrix() { return mat; }
356
357private:
358
359  double whiteX, whiteY, whiteZ;    // white point
360  double blackX, blackY, blackZ;    // black point
361  double gammaR, gammaG, gammaB;    // gamma values
362  double mat[9];                    // ABC -> XYZ transform matrix
363  double kr, kg, kb;                // gamut mapping mulitpliers
364  void getXYZ(GfxColor *color, double *pX, double *pY, double *pZ);
365};
366
367//------------------------------------------------------------------------
368// GfxDeviceCMYKColorSpace
369//------------------------------------------------------------------------
370
371class GfxDeviceCMYKColorSpace: public GfxColorSpace {
372public:
373
374  GfxDeviceCMYKColorSpace();
375  virtual ~GfxDeviceCMYKColorSpace();
376  virtual GfxColorSpace *copy();
377  virtual GfxColorSpaceMode getMode() { return csDeviceCMYK; }
378
379  virtual void getGray(GfxColor *color, GfxGray *gray);
380  virtual void getRGB(GfxColor *color, GfxRGB *rgb);
381  virtual void getCMYK(GfxColor *color, GfxCMYK *cmyk);
382
383  virtual int getNComps() { return 4; }
384  virtual void getDefaultColor(GfxColor *color);
385
386private:
387};
388
389//------------------------------------------------------------------------
390// GfxLabColorSpace
391//------------------------------------------------------------------------
392
393class GfxLabColorSpace: public GfxColorSpace {
394public:
395
396  GfxLabColorSpace();
397  virtual ~GfxLabColorSpace();
398  virtual GfxColorSpace *copy();
399  virtual GfxColorSpaceMode getMode() { return csLab; }
400
401  // Construct a Lab color space.  Returns NULL if unsuccessful.
402  static GfxColorSpace *parse(Array *arr);
403
404  virtual void getGray(GfxColor *color, GfxGray *gray);
405  virtual void getRGB(GfxColor *color, GfxRGB *rgb);
406  virtual void getCMYK(GfxColor *color, GfxCMYK *cmyk);
407
408  virtual int getNComps() { return 3; }
409  virtual void getDefaultColor(GfxColor *color);
410
411  virtual void getDefaultRanges(double *decodeLow, double *decodeRange,
412                                int maxImgPixel);
413
414  // Lab-specific access.
415  double getWhiteX() { return whiteX; }
416  double getWhiteY() { return whiteY; }
417  double getWhiteZ() { return whiteZ; }
418  double getBlackX() { return blackX; }
419  double getBlackY() { return blackY; }
420  double getBlackZ() { return blackZ; }
421  double getAMin() { return aMin; }
422  double getAMax() { return aMax; }
423  double getBMin() { return bMin; }
424  double getBMax() { return bMax; }
425
426private:
427
428  double whiteX, whiteY, whiteZ;    // white point
429  double blackX, blackY, blackZ;    // black point
430  double aMin, aMax, bMin, bMax;    // range for the a and b components
431  double kr, kg, kb;                // gamut mapping mulitpliers
432  void getXYZ(GfxColor *color, double *pX, double *pY, double *pZ);
433};
434
435//------------------------------------------------------------------------
436// GfxICCBasedColorSpace
437//------------------------------------------------------------------------
438
439class GfxICCBasedColorSpace: public GfxColorSpace {
440public:
441
442  GfxICCBasedColorSpace(int nCompsA, GfxColorSpace *altA,
443                        Ref *iccProfileStreamA);
444  virtual ~GfxICCBasedColorSpace();
445  virtual GfxColorSpace *copy();
446  virtual GfxColorSpaceMode getMode() { return csICCBased; }
447
448  // Construct an ICCBased color space.  Returns NULL if unsuccessful.
449  static GfxColorSpace *parse(Array *arr, Gfx *gfx);
450
451  virtual void getGray(GfxColor *color, GfxGray *gray);
452  virtual void getRGB(GfxColor *color, GfxRGB *rgb);
453  virtual void getCMYK(GfxColor *color, GfxCMYK *cmyk);
454  virtual void getRGBLine(Guchar *in, unsigned int *out, int length);
455
456  virtual GBool useGetRGBLine();
457
458  virtual int getNComps() { return nComps; }
459  virtual void getDefaultColor(GfxColor *color);
460
461  virtual void getDefaultRanges(double *decodeLow, double *decodeRange,
462                                int maxImgPixel);
463
464  // ICCBased-specific access.
465  GfxColorSpace *getAlt() { return alt; }
466
467private:
468
469  int nComps;                   // number of color components (1, 3, or 4)
470  GfxColorSpace *alt;           // alternate color space
471  double rangeMin[4];           // min values for each component
472  double rangeMax[4];           // max values for each component
473  Ref iccProfileStream;         // the ICC profile
474#ifdef USE_CMS
475  GfxColorTransform *transform;
476  GfxColorTransform *lineTransform; // color transform for line
477#endif
478};
479//------------------------------------------------------------------------
480// GfxIndexedColorSpace
481//------------------------------------------------------------------------
482
483class GfxIndexedColorSpace: public GfxColorSpace {
484public:
485
486  GfxIndexedColorSpace(GfxColorSpace *baseA, int indexHighA);
487  virtual ~GfxIndexedColorSpace();
488  virtual GfxColorSpace *copy();
489  virtual GfxColorSpaceMode getMode() { return csIndexed; }
490
491  // Construct a Lab color space.  Returns NULL if unsuccessful.
492  static GfxColorSpace *parse(Array *arr, Gfx *gfx);
493
494  virtual void getGray(GfxColor *color, GfxGray *gray);
495  virtual void getRGB(GfxColor *color, GfxRGB *rgb);
496  virtual void getCMYK(GfxColor *color, GfxCMYK *cmyk);
497  virtual void getRGBLine(Guchar *in, unsigned int *out, int length);
498
499  virtual GBool useGetRGBLine() { return gTrue; }
500
501  virtual int getNComps() { return 1; }
502  virtual void getDefaultColor(GfxColor *color);
503
504  virtual void getDefaultRanges(double *decodeLow, double *decodeRange,
505                                int maxImgPixel);
506
507  // Indexed-specific access.
508  GfxColorSpace *getBase() { return base; }
509  int getIndexHigh() { return indexHigh; }
510  Guchar *getLookup() { return lookup; }
511  GfxColor *mapColorToBase(GfxColor *color, GfxColor *baseColor);
512
513private:
514
515  GfxColorSpace *base;          // base color space
516  int indexHigh;                // max pixel value
517  Guchar *lookup;               // lookup table
518};
519
520//------------------------------------------------------------------------
521// GfxSeparationColorSpace
522//------------------------------------------------------------------------
523
524class GfxSeparationColorSpace: public GfxColorSpace {
525public:
526
527  GfxSeparationColorSpace(GooString *nameA, GfxColorSpace *altA,
528                          Function *funcA);
529  virtual ~GfxSeparationColorSpace();
530  virtual GfxColorSpace *copy();
531  virtual GfxColorSpaceMode getMode() { return csSeparation; }
532
533  // Construct a Separation color space.  Returns NULL if unsuccessful.
534  static GfxColorSpace *parse(Array *arr, Gfx *gfx);
535
536  virtual void getGray(GfxColor *color, GfxGray *gray);
537  virtual void getRGB(GfxColor *color, GfxRGB *rgb);
538  virtual void getCMYK(GfxColor *color, GfxCMYK *cmyk);
539
540  virtual int getNComps() { return 1; }
541  virtual void getDefaultColor(GfxColor *color);
542
543  virtual GBool isNonMarking() { return nonMarking; }
544
545  // Separation-specific access.
546  GooString *getName() { return name; }
547  GfxColorSpace *getAlt() { return alt; }
548  Function *getFunc() { return func; }
549
550private:
551
552  GooString *name;              // colorant name
553  GfxColorSpace *alt;           // alternate color space
554  Function *func;               // tint transform (into alternate color space)
555  GBool nonMarking;
556};
557
558//------------------------------------------------------------------------
559// GfxDeviceNColorSpace
560//------------------------------------------------------------------------
561
562class GfxDeviceNColorSpace: public GfxColorSpace {
563public:
564
565  GfxDeviceNColorSpace(int nCompsA, GfxColorSpace *alt, Function *func);
566  virtual ~GfxDeviceNColorSpace();
567  virtual GfxColorSpace *copy();
568  virtual GfxColorSpaceMode getMode() { return csDeviceN; }
569
570  // Construct a DeviceN color space.  Returns NULL if unsuccessful.
571  static GfxColorSpace *parse(Array *arr, Gfx *gfx);
572
573  virtual void getGray(GfxColor *color, GfxGray *gray);
574  virtual void getRGB(GfxColor *color, GfxRGB *rgb);
575  virtual void getCMYK(GfxColor *color, GfxCMYK *cmyk);
576
577  virtual int getNComps() { return nComps; }
578  virtual void getDefaultColor(GfxColor *color);
579
580  virtual GBool isNonMarking() { return nonMarking; }
581
582  // DeviceN-specific access.
583  GooString *getColorantName(int i) { return names[i]; }
584  GfxColorSpace *getAlt() { return alt; }
585  Function *getTintTransformFunc() { return func; }
586
587private:
588
589  int nComps;                   // number of components
590  GooString                     // colorant names
591    *names[gfxColorMaxComps];
592  GfxColorSpace *alt;           // alternate color space
593  Function *func;               // tint transform (into alternate color space)
594  GBool nonMarking;
595};
596
597//------------------------------------------------------------------------
598// GfxPatternColorSpace
599//------------------------------------------------------------------------
600
601class GfxPatternColorSpace: public GfxColorSpace {
602public:
603
604  GfxPatternColorSpace(GfxColorSpace *underA);
605  virtual ~GfxPatternColorSpace();
606  virtual GfxColorSpace *copy();
607  virtual GfxColorSpaceMode getMode() { return csPattern; }
608
609  // Construct a Pattern color space.  Returns NULL if unsuccessful.
610  static GfxColorSpace *parse(Array *arr, Gfx *gfx);
611
612  virtual void getGray(GfxColor *color, GfxGray *gray);
613  virtual void getRGB(GfxColor *color, GfxRGB *rgb);
614  virtual void getCMYK(GfxColor *color, GfxCMYK *cmyk);
615
616  virtual int getNComps() { return 0; }
617  virtual void getDefaultColor(GfxColor *color);
618
619  // Pattern-specific access.
620  GfxColorSpace *getUnder() { return under; }
621
622private:
623
624  GfxColorSpace *under;         // underlying color space (for uncolored
625                                //   patterns)
626};
627
628//------------------------------------------------------------------------
629// GfxPattern
630//------------------------------------------------------------------------
631
632class GfxPattern {
633public:
634
635  GfxPattern(int typeA);
636  virtual ~GfxPattern();
637
638  static GfxPattern *parse(Object *obj, Gfx *gfx);
639
640  virtual GfxPattern *copy() = 0;
641
642  int getType() { return type; }
643
644private:
645
646  int type;
647};
648
649//------------------------------------------------------------------------
650// GfxTilingPattern
651//------------------------------------------------------------------------
652
653class GfxTilingPattern: public GfxPattern {
654public:
655
656  static GfxTilingPattern *parse(Object *patObj);
657  virtual ~GfxTilingPattern();
658
659  virtual GfxPattern *copy();
660
661  int getPaintType() { return paintType; }
662  int getTilingType() { return tilingType; }
663  double *getBBox() { return bbox; }
664  double getXStep() { return xStep; }
665  double getYStep() { return yStep; }
666  Dict *getResDict()
667    { return resDict.isDict() ? resDict.getDict() : (Dict *)NULL; }
668  double *getMatrix() { return matrix; }
669  Object *getContentStream() { return &contentStream; }
670
671private:
672
673  GfxTilingPattern(int paintTypeA, int tilingTypeA,
674                   double *bboxA, double xStepA, double yStepA,
675                   Object *resDictA, double *matrixA,
676                   Object *contentStreamA);
677
678  int paintType;
679  int tilingType;
680  double bbox[4];
681  double xStep, yStep;
682  Object resDict;
683  double matrix[6];
684  Object contentStream;
685};
686
687//------------------------------------------------------------------------
688// GfxShadingPattern
689//------------------------------------------------------------------------
690
691class GfxShadingPattern: public GfxPattern {
692public:
693
694  static GfxShadingPattern *parse(Object *patObj, Gfx *gfx);
695  virtual ~GfxShadingPattern();
696
697  virtual GfxPattern *copy();
698
699  GfxShading *getShading() { return shading; }
700  double *getMatrix() { return matrix; }
701
702private:
703
704  GfxShadingPattern(GfxShading *shadingA, double *matrixA);
705
706  GfxShading *shading;
707  double matrix[6];
708};
709
710//------------------------------------------------------------------------
711// GfxShading
712//------------------------------------------------------------------------
713
714class GfxShading {
715public:
716
717  GfxShading(int typeA);
718  GfxShading(GfxShading *shading);
719  virtual ~GfxShading();
720
721  static GfxShading *parse(Object *obj, Gfx *gfx);
722
723  virtual GfxShading *copy() = 0;
724
725  int getType() { return type; }
726  GfxColorSpace *getColorSpace() { return colorSpace; }
727  GfxColor *getBackground() { return &background; }
728  GBool getHasBackground() { return hasBackground; }
729  void getBBox(double *xMinA, double *yMinA, double *xMaxA, double *yMaxA)
730    { *xMinA = xMin; *yMinA = yMin; *xMaxA = xMax; *yMaxA = yMax; }
731  GBool getHasBBox() { return hasBBox; }
732
733protected:
734
735  GBool init(Dict *dict, Gfx *gfx);
736
737  int type;
738  GfxColorSpace *colorSpace;
739  GfxColor background;
740  GBool hasBackground;
741  double xMin, yMin, xMax, yMax;
742  GBool hasBBox;
743};
744
745//------------------------------------------------------------------------
746// GfxFunctionShading
747//------------------------------------------------------------------------
748
749class GfxFunctionShading: public GfxShading {
750public:
751
752  GfxFunctionShading(double x0A, double y0A,
753                     double x1A, double y1A,
754                     double *matrixA,
755                     Function **funcsA, int nFuncsA);
756  GfxFunctionShading(GfxFunctionShading *shading);
757  virtual ~GfxFunctionShading();
758
759  static GfxFunctionShading *parse(Dict *dict, Gfx *gfx);
760
761  virtual GfxShading *copy();
762
763  void getDomain(double *x0A, double *y0A, double *x1A, double *y1A)
764    { *x0A = x0; *y0A = y0; *x1A = x1; *y1A = y1; }
765  double *getMatrix() { return matrix; }
766  int getNFuncs() { return nFuncs; }
767  Function *getFunc(int i) { return funcs[i]; }
768  void getColor(double x, double y, GfxColor *color);
769
770private:
771
772  double x0, y0, x1, y1;
773  double matrix[6];
774  Function *funcs[gfxColorMaxComps];
775  int nFuncs;
776};
777
778//------------------------------------------------------------------------
779// GfxAxialShading
780//------------------------------------------------------------------------
781
782class GfxAxialShading: public GfxShading {
783public:
784
785  GfxAxialShading(double x0A, double y0A,
786                  double x1A, double y1A,
787                  double t0A, double t1A,
788                  Function **funcsA, int nFuncsA,
789                  GBool extend0A, GBool extend1A);
790  GfxAxialShading(GfxAxialShading *shading);
791  virtual ~GfxAxialShading();
792
793  static GfxAxialShading *parse(Dict *dict, Gfx *gfx);
794
795  virtual GfxShading *copy();
796
797  void getCoords(double *x0A, double *y0A, double *x1A, double *y1A)
798    { *x0A = x0; *y0A = y0; *x1A = x1; *y1A = y1; }
799  double getDomain0() { return t0; }
800  double getDomain1() { return t1; }
801  GBool getExtend0() { return extend0; }
802  GBool getExtend1() { return extend1; }
803  int getNFuncs() { return nFuncs; }
804  Function *getFunc(int i) { return funcs[i]; }
805  void getColor(double t, GfxColor *color);
806
807private:
808
809  double x0, y0, x1, y1;
810  double t0, t1;
811  Function *funcs[gfxColorMaxComps];
812  int nFuncs;
813  GBool extend0, extend1;
814};
815
816//------------------------------------------------------------------------
817// GfxRadialShading
818//------------------------------------------------------------------------
819
820class GfxRadialShading: public GfxShading {
821public:
822
823  GfxRadialShading(double x0A, double y0A, double r0A,
824                   double x1A, double y1A, double r1A,
825                   double t0A, double t1A,
826                   Function **funcsA, int nFuncsA,
827                   GBool extend0A, GBool extend1A);
828  GfxRadialShading(GfxRadialShading *shading);
829  virtual ~GfxRadialShading();
830
831  static GfxRadialShading *parse(Dict *dict, Gfx *gfx);
832
833  virtual GfxShading *copy();
834
835  void getCoords(double *x0A, double *y0A, double *r0A,
836                 double *x1A, double *y1A, double *r1A)
837    { *x0A = x0; *y0A = y0; *r0A = r0; *x1A = x1; *y1A = y1; *r1A = r1; }
838  double getDomain0() { return t0; }
839  double getDomain1() { return t1; }
840  GBool getExtend0() { return extend0; }
841  GBool getExtend1() { return extend1; }
842  int getNFuncs() { return nFuncs; }
843  Function *getFunc(int i) { return funcs[i]; }
844  void getColor(double t, GfxColor *color);
845
846private:
847
848  double x0, y0, r0, x1, y1, r1;
849  double t0, t1;
850  Function *funcs[gfxColorMaxComps];
851  int nFuncs;
852  GBool extend0, extend1;
853};
854
855//------------------------------------------------------------------------
856// GfxGouraudTriangleShading
857//------------------------------------------------------------------------
858
859struct GfxGouraudVertex {
860  double x, y;
861  GfxColor color;
862};
863
864class GfxGouraudTriangleShading: public GfxShading {
865public:
866
867  GfxGouraudTriangleShading(int typeA,
868                            GfxGouraudVertex *verticesA, int nVerticesA,
869                            int (*trianglesA)[3], int nTrianglesA,
870                            Function **funcsA, int nFuncsA);
871  GfxGouraudTriangleShading(GfxGouraudTriangleShading *shading);
872  virtual ~GfxGouraudTriangleShading();
873
874  static GfxGouraudTriangleShading *parse(int typeA, Dict *dict, Stream *str, Gfx *gfx);
875
876  virtual GfxShading *copy();
877
878  int getNTriangles() { return nTriangles; }
879  void getTriangle(int i, double *x0, double *y0, GfxColor *color0,
880                   double *x1, double *y1, GfxColor *color1,
881                   double *x2, double *y2, GfxColor *color2);
882
883private:
884
885  GfxGouraudVertex *vertices;
886  int nVertices;
887  int (*triangles)[3];
888  int nTriangles;
889  Function *funcs[gfxColorMaxComps];
890  int nFuncs;
891};
892
893//------------------------------------------------------------------------
894// GfxPatchMeshShading
895//------------------------------------------------------------------------
896
897struct GfxPatch {
898  double x[4][4];
899  double y[4][4];
900  GfxColor color[2][2];
901};
902
903class GfxPatchMeshShading: public GfxShading {
904public:
905
906  GfxPatchMeshShading(int typeA, GfxPatch *patchesA, int nPatchesA,
907                      Function **funcsA, int nFuncsA);
908  GfxPatchMeshShading(GfxPatchMeshShading *shading);
909  virtual ~GfxPatchMeshShading();
910
911  static GfxPatchMeshShading *parse(int typeA, Dict *dict, Stream *str, Gfx *gfx);
912
913  virtual GfxShading *copy();
914
915  int getNPatches() { return nPatches; }
916  GfxPatch *getPatch(int i) { return &patches[i]; }
917
918private:
919
920  GfxPatch *patches;
921  int nPatches;
922  Function *funcs[gfxColorMaxComps];
923  int nFuncs;
924};
925
926//------------------------------------------------------------------------
927// GfxImageColorMap
928//------------------------------------------------------------------------
929
930class GfxImageColorMap {
931public:
932
933  // Constructor.
934  GfxImageColorMap(int bitsA, Object *decode, GfxColorSpace *colorSpaceA);
935
936  // Destructor.
937  ~GfxImageColorMap();
938
939  // Return a copy of this color map.
940  GfxImageColorMap *copy() { return new GfxImageColorMap(this); }
941
942  // Is color map valid?
943  GBool isOk() { return ok; }
944
945  // Get the color space.
946  GfxColorSpace *getColorSpace() { return colorSpace; }
947
948  // Get stream decoding info.
949  int getNumPixelComps() { return nComps; }
950  int getBits() { return bits; }
951
952  // Get decode table.
953  double getDecodeLow(int i) { return decodeLow[i]; }
954  double getDecodeHigh(int i) { return decodeLow[i] + decodeRange[i]; }
955
956  // Convert an image pixel to a color.
957  void getGray(Guchar *x, GfxGray *gray);
958  void getRGB(Guchar *x, GfxRGB *rgb);
959  void getRGBLine(Guchar *in, unsigned int *out, int length);
960  void getGrayLine(Guchar *in, Guchar *out, int length);
961  void getCMYK(Guchar *x, GfxCMYK *cmyk);
962  void getColor(Guchar *x, GfxColor *color);
963
964private:
965
966  GfxImageColorMap(GfxImageColorMap *colorMap);
967
968  GfxColorSpace *colorSpace;    // the image color space
969  int bits;                     // bits per component
970  int nComps;                   // number of components in a pixel
971  GfxColorSpace *colorSpace2;   // secondary color space
972  int nComps2;                  // number of components in colorSpace2
973  GfxColorComp *                // lookup table
974    lookup[gfxColorMaxComps];
975  Guchar *byte_lookup;
976  double                        // minimum values for each component
977    decodeLow[gfxColorMaxComps];
978  double                        // max - min value for each component
979    decodeRange[gfxColorMaxComps];
980  GBool ok;
981};
982
983//------------------------------------------------------------------------
984// GfxSubpath and GfxPath
985//------------------------------------------------------------------------
986
987class GfxSubpath {
988public:
989
990  // Constructor.
991  GfxSubpath(double x1, double y1);
992
993  // Destructor.
994  ~GfxSubpath();
995
996  // Copy.
997  GfxSubpath *copy() { return new GfxSubpath(this); }
998
999  // Get points.
1000  int getNumPoints() { return n; }
1001  double getX(int i) { return x[i]; }
1002  double getY(int i) { return y[i]; }
1003  GBool getCurve(int i) { return curve[i]; }
1004
1005  // Get last point.
1006  double getLastX() { return x[n-1]; }
1007  double getLastY() { return y[n-1]; }
1008
1009  // Add a line segment.
1010  void lineTo(double x1, double y1);
1011
1012  // Add a Bezier curve.
1013  void curveTo(double x1, double y1, double x2, double y2,
1014               double x3, double y3);
1015
1016  // Close the subpath.
1017  void close();
1018  GBool isClosed() { return closed; }
1019
1020  // Add (<dx>, <dy>) to each point in the subpath.
1021  void offset(double dx, double dy);
1022
1023private:
1024
1025  double *x, *y;                // points
1026  GBool *curve;                 // curve[i] => point i is a control point
1027                                //   for a Bezier curve
1028  int n;                        // number of points
1029  int size;                     // size of x/y arrays
1030  GBool closed;                 // set if path is closed
1031
1032  GfxSubpath(GfxSubpath *subpath);
1033};
1034
1035class GfxPath {
1036public:
1037
1038  // Constructor.
1039  GfxPath();
1040
1041  // Destructor.
1042  ~GfxPath();
1043
1044  // Copy.
1045  GfxPath *copy()
1046    { return new GfxPath(justMoved, firstX, firstY, subpaths, n, size); }
1047
1048  // Is there a current point?
1049  GBool isCurPt() { return n > 0 || justMoved; }
1050
1051  // Is the path non-empty, i.e., is there at least one segment?
1052  GBool isPath() { return n > 0; }
1053
1054  // Get subpaths.
1055  int getNumSubpaths() { return n; }
1056  GfxSubpath *getSubpath(int i) { return subpaths[i]; }
1057
1058  // Get last point on last subpath.
1059  double getLastX() { return subpaths[n-1]->getLastX(); }
1060  double getLastY() { return subpaths[n-1]->getLastY(); }
1061
1062  // Move the current point.
1063  void moveTo(double x, double y);
1064
1065  // Add a segment to the last subpath.
1066  void lineTo(double x, double y);
1067
1068  // Add a Bezier curve to the last subpath
1069  void curveTo(double x1, double y1, double x2, double y2,
1070               double x3, double y3);
1071
1072  // Close the last subpath.
1073  void close();
1074
1075  // Append <path> to <this>.
1076  void append(GfxPath *path);
1077
1078  // Add (<dx>, <dy>) to each point in the path.
1079  void offset(double dx, double dy);
1080
1081private:
1082
1083  GBool justMoved;              // set if a new subpath was just started
1084  double firstX, firstY;        // first point in new subpath
1085  GfxSubpath **subpaths;        // subpaths
1086  int n;                        // number of subpaths
1087  int size;                     // size of subpaths array
1088
1089  GfxPath(GBool justMoved1, double firstX1, double firstY1,
1090          GfxSubpath **subpaths1, int n1, int size1);
1091};
1092
1093//------------------------------------------------------------------------
1094// GfxState
1095//------------------------------------------------------------------------
1096
1097class GfxState {
1098public:
1099
1100  // Construct a default GfxState, for a device with resolution <hDPI>
1101  // x <vDPI>, page box <pageBox>, page rotation <rotateA>, and
1102  // coordinate system specified by <upsideDown>.
1103  GfxState(double hDPIA, double vDPIA, PDFRectangle *pageBox,
1104           int rotateA, GBool upsideDown);
1105
1106  // Destructor.
1107  ~GfxState();
1108
1109  // Copy.
1110  GfxState *copy() { return new GfxState(this); }
1111
1112  // Accessors.
1113  double getHDPI() { return hDPI; }
1114  double getVDPI() { return vDPI; }
1115  double *getCTM() { return ctm; }
1116  void getCTM(Matrix *m) { memcpy (m->m, ctm, sizeof m->m); }
1117  double getX1() { return px1; }
1118  double getY1() { return py1; }
1119  double getX2() { return px2; }
1120  double getY2() { return py2; }
1121  double getPageWidth() { return pageWidth; }
1122  double getPageHeight() { return pageHeight; }
1123  int getRotate() { return rotate; }
1124  GfxColor *getFillColor() { return &fillColor; }
1125  GfxColor *getStrokeColor() { return &strokeColor; }
1126  void getFillGray(GfxGray *gray)
1127    { fillColorSpace->getGray(&fillColor, gray); }
1128  void getStrokeGray(GfxGray *gray)
1129    { strokeColorSpace->getGray(&strokeColor, gray); }
1130  void getFillRGB(GfxRGB *rgb)
1131    { fillColorSpace->getRGB(&fillColor, rgb); }
1132  void getStrokeRGB(GfxRGB *rgb)
1133    { strokeColorSpace->getRGB(&strokeColor, rgb); }
1134  void getFillCMYK(GfxCMYK *cmyk)
1135    { fillColorSpace->getCMYK(&fillColor, cmyk); }
1136  void getStrokeCMYK(GfxCMYK *cmyk)
1137    { strokeColorSpace->getCMYK(&strokeColor, cmyk); }
1138  GfxColorSpace *getFillColorSpace() { return fillColorSpace; }
1139  GfxColorSpace *getStrokeColorSpace() { return strokeColorSpace; }
1140  GfxPattern *getFillPattern() { return fillPattern; }
1141  GfxPattern *getStrokePattern() { return strokePattern; }
1142  GfxBlendMode getBlendMode() { return blendMode; }
1143  double getFillOpacity() { return fillOpacity; }
1144  double getStrokeOpacity() { return strokeOpacity; }
1145  GBool getFillOverprint() { return fillOverprint; }
1146  GBool getStrokeOverprint() { return strokeOverprint; }
1147  Function **getTransfer() { return transfer; }
1148  double getLineWidth() { return lineWidth; }
1149  void getLineDash(double **dash, int *length, double *start)
1150    { *dash = lineDash; *length = lineDashLength; *start = lineDashStart; }
1151  int getFlatness() { return flatness; }
1152  int getLineJoin() { return lineJoin; }
1153  int getLineCap() { return lineCap; }
1154  double getMiterLimit() { return miterLimit; }
1155  GBool getStrokeAdjust() { return strokeAdjust; }
1156  GBool getAlphaIsShape() { return alphaIsShape; }
1157  GBool getTextKnockout() { return textKnockout; }
1158  GfxFont *getFont() { return font; }
1159  double getFontSize() { return fontSize; }
1160  double *getTextMat() { return textMat; }
1161  double getCharSpace() { return charSpace; }
1162  double getWordSpace() { return wordSpace; }
1163  double getHorizScaling() { return horizScaling; }
1164  double getLeading() { return leading; }
1165  double getRise() { return rise; }
1166  int getRender() { return render; }
1167  GfxPath *getPath() { return path; }
1168  void setPath(GfxPath *pathA);
1169  double getCurX() { return curX; }
1170  double getCurY() { return curY; }
1171  void getClipBBox(double *xMin, double *yMin, double *xMax, double *yMax)
1172    { *xMin = clipXMin; *yMin = clipYMin; *xMax = clipXMax; *yMax = clipYMax; }
1173  void getUserClipBBox(double *xMin, double *yMin, double *xMax, double *yMax);
1174  double getLineX() { return lineX; }
1175  double getLineY() { return lineY; }
1176
1177  // Is there a current point/path?
1178  GBool isCurPt() { return path->isCurPt(); }
1179  GBool isPath() { return path->isPath(); }
1180
1181  // Transforms.
1182  void transform(double x1, double y1, double *x2, double *y2)
1183    { *x2 = ctm[0] * x1 + ctm[2] * y1 + ctm[4];
1184      *y2 = ctm[1] * x1 + ctm[3] * y1 + ctm[5]; }
1185  void transformDelta(double x1, double y1, double *x2, double *y2)
1186    { *x2 = ctm[0] * x1 + ctm[2] * y1;
1187      *y2 = ctm[1] * x1 + ctm[3] * y1; }
1188  void textTransform(double x1, double y1, double *x2, double *y2)
1189    { *x2 = textMat[0] * x1 + textMat[2] * y1 + textMat[4];
1190      *y2 = textMat[1] * x1 + textMat[3] * y1 + textMat[5]; }
1191  void textTransformDelta(double x1, double y1, double *x2, double *y2)
1192    { *x2 = textMat[0] * x1 + textMat[2] * y1;
1193      *y2 = textMat[1] * x1 + textMat[3] * y1; }
1194  double transformWidth(double w);
1195  double getTransformedLineWidth()
1196    { return transformWidth(lineWidth); }
1197  double getTransformedFontSize();
1198  void getFontTransMat(double *m11, double *m12, double *m21, double *m22);
1199
1200  // Change state parameters.
1201  void setCTM(double a, double b, double c,
1202              double d, double e, double f);
1203  void concatCTM(double a, double b, double c,
1204                 double d, double e, double f);
1205  void shiftCTM(double tx, double ty);
1206  void setFillColorSpace(GfxColorSpace *colorSpace);
1207  void setStrokeColorSpace(GfxColorSpace *colorSpace);
1208  void setFillColor(GfxColor *color) { fillColor = *color; }
1209  void setStrokeColor(GfxColor *color) { strokeColor = *color; }
1210  void setFillPattern(GfxPattern *pattern);
1211  void setStrokePattern(GfxPattern *pattern);
1212  void setBlendMode(GfxBlendMode mode) { blendMode = mode; }
1213  void setFillOpacity(double opac) { fillOpacity = opac; }
1214  void setStrokeOpacity(double opac) { strokeOpacity = opac; }
1215  void setFillOverprint(GBool op) { fillOverprint = op; }
1216  void setStrokeOverprint(GBool op) { strokeOverprint = op; }
1217  void setTransfer(Function **funcs);
1218  void setLineWidth(double width) { lineWidth = width; }
1219  void setLineDash(double *dash, int length, double start);
1220  void setFlatness(int flatness1) { flatness = flatness1; }
1221  void setLineJoin(int lineJoin1) { lineJoin = lineJoin1; }
1222  void setLineCap(int lineCap1) { lineCap = lineCap1; }
1223  void setMiterLimit(double limit) { miterLimit = limit; }
1224  void setStrokeAdjust(GBool sa) { strokeAdjust = sa; }
1225  void setAlphaIsShape(GBool ais) { alphaIsShape = ais; }
1226  void setTextKnockout(GBool tk) { textKnockout = tk; }
1227  void setFont(GfxFont *fontA, double fontSizeA);
1228  void setTextMat(double a, double b, double c,
1229                  double d, double e, double f)
1230    { textMat[0] = a; textMat[1] = b; textMat[2] = c;
1231      textMat[3] = d; textMat[4] = e; textMat[5] = f; }
1232  void setCharSpace(double space)
1233    { charSpace = space; }
1234  void setWordSpace(double space)
1235    { wordSpace = space; }
1236  void setHorizScaling(double scale)
1237    { horizScaling = 0.01 * scale; }
1238  void setLeading(double leadingA)
1239    { leading = leadingA; }
1240  void setRise(double riseA)
1241    { rise = riseA; }
1242  void setRender(int renderA)
1243    { render = renderA; }
1244
1245  // Add to path.
1246  void moveTo(double x, double y)
1247    { path->moveTo(curX = x, curY = y); }
1248  void lineTo(double x, double y)
1249    { path->lineTo(curX = x, curY = y); }
1250  void curveTo(double x1, double y1, double x2, double y2,
1251               double x3, double y3)
1252    { path->curveTo(x1, y1, x2, y2, curX = x3, curY = y3); }
1253  void closePath()
1254    { path->close(); curX = path->getLastX(); curY = path->getLastY(); }
1255  void clearPath();
1256
1257  // Update clip region.
1258  void clip();
1259  void clipToStrokePath();
1260
1261  // Text position.
1262  void textSetPos(double tx, double ty) { lineX = tx; lineY = ty; }
1263  void textMoveTo(double tx, double ty)
1264    { lineX = tx; lineY = ty; textTransform(tx, ty, &curX, &curY); }
1265  void textShift(double tx, double ty);
1266  void shift(double dx, double dy);
1267
1268  // Push/pop GfxState on/off stack.
1269  GfxState *save();
1270  GfxState *restore();
1271  GBool hasSaves() { return saved != NULL; }
1272  GBool isParentState(GfxState *state) { return saved == state || (saved && saved->isParentState(state)); }
1273
1274  // Misc
1275  GBool parseBlendMode(Object *obj, GfxBlendMode *mode);
1276
1277private:
1278
1279  double hDPI, vDPI;            // resolution
1280  double ctm[6];                // coord transform matrix
1281  double px1, py1, px2, py2;    // page corners (user coords)
1282  double pageWidth, pageHeight; // page size (pixels)
1283  int rotate;                   // page rotation angle
1284
1285  GfxColorSpace *fillColorSpace;   // fill color space
1286  GfxColorSpace *strokeColorSpace; // stroke color space
1287  GfxColor fillColor;           // fill color
1288  GfxColor strokeColor;         // stroke color
1289  GfxPattern *fillPattern;      // fill pattern
1290  GfxPattern *strokePattern;    // stroke pattern
1291  GfxBlendMode blendMode;       // transparency blend mode
1292  double fillOpacity;           // fill opacity
1293  double strokeOpacity;         // stroke opacity
1294  GBool fillOverprint;          // fill overprint
1295  GBool strokeOverprint;        // stroke overprint
1296  Function *transfer[4];        // transfer function (entries may be: all
1297                                //   NULL = identity; last three NULL =
1298                                //   single function; all four non-NULL =
1299                                //   R,G,B,gray functions)
1300
1301  double lineWidth;             // line width
1302  double *lineDash;             // line dash
1303  int lineDashLength;
1304  double lineDashStart;
1305  int flatness;                 // curve flatness
1306  int lineJoin;                 // line join style
1307  int lineCap;                  // line cap style
1308  double miterLimit;            // line miter limit
1309  GBool strokeAdjust;           // stroke adjustment
1310  GBool alphaIsShape;           // alpha is shape
1311  GBool textKnockout;           // text knockout
1312
1313  GfxFont *font;                // font
1314  double fontSize;              // font size
1315  double textMat[6];            // text matrix
1316  double charSpace;             // character spacing
1317  double wordSpace;             // word spacing
1318  double horizScaling;          // horizontal scaling
1319  double leading;               // text leading
1320  double rise;                  // text rise
1321  int render;                   // text rendering mode
1322
1323  GfxPath *path;                // array of path elements
1324  double curX, curY;            // current point (user coords)
1325  double lineX, lineY;          // start of current text line (text coords)
1326
1327  double clipXMin, clipYMin,    // bounding box for clip region
1328         clipXMax, clipYMax;
1329
1330  GfxState *saved;              // next GfxState on stack
1331
1332  GfxState(GfxState *state);
1333};
1334
1335#endif
Note: See TracBrowser for help on using the repository browser.