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