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

Last change on this file since 2 was 2, checked in by Eugene Romanenko, 16 years ago

First import

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