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