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

Last change on this file since 257 was 257, checked in by Eugene Romanenko, 13 years ago

PDF plugin: Poppler library updated to version 0.10.0

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