?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
upgrade to xpdf 3.00.
[swftools.git] / pdf2swf / xpdf / Gfx.cc
bloba52aa02ac8dbfe71ca43cf3774e3d2a047f8f7ca
1 //========================================================================
2 //
3 // Gfx.cc
4 //
5 // Copyright 1996-2003 Glyph & Cog, LLC
6 //
7 //========================================================================
8
9 #include <aconf.h>
10
11 #ifdef USE_GCC_PRAGMAS
12 #pragma implementation
13 #endif
14
15 #include <stdio.h>
16 #include <stddef.h>
17 #include <string.h>
18 #include <math.h>
19 #include "gmem.h"
20 #include "GlobalParams.h"
21 #include "CharTypes.h"
22 #include "Object.h"
23 #include "Array.h"
24 #include "Dict.h"
25 #include "Stream.h"
26 #include "Lexer.h"
27 #include "Parser.h"
28 #include "GfxFont.h"
29 #include "GfxState.h"
30 #include "OutputDev.h"
31 #include "Page.h"
32 #include "Error.h"
33 #include "Gfx.h"
34
35 // the MSVC math.h doesn't define this
36 #ifndef M_PI
37 #define M_PI 3.14159265358979323846
38 #endif
39
40 //------------------------------------------------------------------------
41 // constants
42 //------------------------------------------------------------------------
43
44 // Max recursive depth for a function shading fill.
45 #define functionMaxDepth 6
46
47 // Max delta allowed in any color component for a function shading fill.
48 #define functionColorDelta (1 / 256.0)
49
50 // Max number of splits along the t axis for an axial shading fill.
51 #define axialMaxSplits 256
52
53 // Max delta allowed in any color component for an axial shading fill.
54 #define axialColorDelta (1 / 256.0)
55
56 // Max number of splits along the t axis for a radial shading fill.
57 #define radialMaxSplits 256
58
59 // Max delta allowed in any color component for a radial shading fill.
60 #define radialColorDelta (1 / 256.0)
61
62 //------------------------------------------------------------------------
63 // Operator table
64 //------------------------------------------------------------------------
65
66 #ifdef WIN32 // this works around a bug in the VC7 compiler
67 # pragma optimize("",off)
68 #endif
69
70 Operator Gfx::opTab[] = {
71 {"\"", 3, {tchkNum, tchkNum, tchkString},
72 &Gfx::opMoveSetShowText},
73 {"'", 1, {tchkString},
74 &Gfx::opMoveShowText},
75 {"B", 0, {tchkNone},
76 &Gfx::opFillStroke},
77 {"B*", 0, {tchkNone},
78 &Gfx::opEOFillStroke},
79 {"BDC", 2, {tchkName, tchkProps},
80 &Gfx::opBeginMarkedContent},
81 {"BI", 0, {tchkNone},
82 &Gfx::opBeginImage},
83 {"BMC", 1, {tchkName},
84 &Gfx::opBeginMarkedContent},
85 {"BT", 0, {tchkNone},
86 &Gfx::opBeginText},
87 {"BX", 0, {tchkNone},
88 &Gfx::opBeginIgnoreUndef},
89 {"CS", 1, {tchkName},
90 &Gfx::opSetStrokeColorSpace},
91 {"DP", 2, {tchkName, tchkProps},
92 &Gfx::opMarkPoint},
93 {"Do", 1, {tchkName},
94 &Gfx::opXObject},
95 {"EI", 0, {tchkNone},
96 &Gfx::opEndImage},
97 {"EMC", 0, {tchkNone},
98 &Gfx::opEndMarkedContent},
99 {"ET", 0, {tchkNone},
100 &Gfx::opEndText},
101 {"EX", 0, {tchkNone},
102 &Gfx::opEndIgnoreUndef},
103 {"F", 0, {tchkNone},
104 &Gfx::opFill},
105 {"G", 1, {tchkNum},
106 &Gfx::opSetStrokeGray},
107 {"ID", 0, {tchkNone},
108 &Gfx::opImageData},
109 {"J", 1, {tchkInt},
110 &Gfx::opSetLineCap},
111 {"K", 4, {tchkNum, tchkNum, tchkNum, tchkNum},
112 &Gfx::opSetStrokeCMYKColor},
113 {"M", 1, {tchkNum},
114 &Gfx::opSetMiterLimit},
115 {"MP", 1, {tchkName},
116 &Gfx::opMarkPoint},
117 {"Q", 0, {tchkNone},
118 &Gfx::opRestore},
119 {"RG", 3, {tchkNum, tchkNum, tchkNum},
120 &Gfx::opSetStrokeRGBColor},
121 {"S", 0, {tchkNone},
122 &Gfx::opStroke},
123 {"SC", -4, {tchkNum, tchkNum, tchkNum, tchkNum},
124 &Gfx::opSetStrokeColor},
125 {"SCN", -5, {tchkSCN, tchkSCN, tchkSCN, tchkSCN,
126 tchkSCN},
127 &Gfx::opSetStrokeColorN},
128 {"T*", 0, {tchkNone},
129 &Gfx::opTextNextLine},
130 {"TD", 2, {tchkNum, tchkNum},
131 &Gfx::opTextMoveSet},
132 {"TJ", 1, {tchkArray},
133 &Gfx::opShowSpaceText},
134 {"TL", 1, {tchkNum},
135 &Gfx::opSetTextLeading},
136 {"Tc", 1, {tchkNum},
137 &Gfx::opSetCharSpacing},
138 {"Td", 2, {tchkNum, tchkNum},
139 &Gfx::opTextMove},
140 {"Tf", 2, {tchkName, tchkNum},
141 &Gfx::opSetFont},
142 {"Tj", 1, {tchkString},
143 &Gfx::opShowText},
144 {"Tm", 6, {tchkNum, tchkNum, tchkNum, tchkNum,
145 tchkNum, tchkNum},
146 &Gfx::opSetTextMatrix},
147 {"Tr", 1, {tchkInt},
148 &Gfx::opSetTextRender},
149 {"Ts", 1, {tchkNum},
150 &Gfx::opSetTextRise},
151 {"Tw", 1, {tchkNum},
152 &Gfx::opSetWordSpacing},
153 {"Tz", 1, {tchkNum},
154 &Gfx::opSetHorizScaling},
155 {"W", 0, {tchkNone},
156 &Gfx::opClip},
157 {"W*", 0, {tchkNone},
158 &Gfx::opEOClip},
159 {"b", 0, {tchkNone},
160 &Gfx::opCloseFillStroke},
161 {"b*", 0, {tchkNone},
162 &Gfx::opCloseEOFillStroke},
163 {"c", 6, {tchkNum, tchkNum, tchkNum, tchkNum,
164 tchkNum, tchkNum},
165 &Gfx::opCurveTo},
166 {"cm", 6, {tchkNum, tchkNum, tchkNum, tchkNum,
167 tchkNum, tchkNum},
168 &Gfx::opConcat},
169 {"cs", 1, {tchkName},
170 &Gfx::opSetFillColorSpace},
171 {"d", 2, {tchkArray, tchkNum},
172 &Gfx::opSetDash},
173 {"d0", 2, {tchkNum, tchkNum},
174 &Gfx::opSetCharWidth},
175 {"d1", 6, {tchkNum, tchkNum, tchkNum, tchkNum,
176 tchkNum, tchkNum},
177 &Gfx::opSetCacheDevice},
178 {"f", 0, {tchkNone},
179 &Gfx::opFill},
180 {"f*", 0, {tchkNone},
181 &Gfx::opEOFill},
182 {"g", 1, {tchkNum},
183 &Gfx::opSetFillGray},
184 {"gs", 1, {tchkName},
185 &Gfx::opSetExtGState},
186 {"h", 0, {tchkNone},
187 &Gfx::opClosePath},
188 {"i", 1, {tchkNum},
189 &Gfx::opSetFlat},
190 {"j", 1, {tchkInt},
191 &Gfx::opSetLineJoin},
192 {"k", 4, {tchkNum, tchkNum, tchkNum, tchkNum},
193 &Gfx::opSetFillCMYKColor},
194 {"l", 2, {tchkNum, tchkNum},
195 &Gfx::opLineTo},
196 {"m", 2, {tchkNum, tchkNum},
197 &Gfx::opMoveTo},
198 {"n", 0, {tchkNone},
199 &Gfx::opEndPath},
200 {"q", 0, {tchkNone},
201 &Gfx::opSave},
202 {"re", 4, {tchkNum, tchkNum, tchkNum, tchkNum},
203 &Gfx::opRectangle},
204 {"rg", 3, {tchkNum, tchkNum, tchkNum},
205 &Gfx::opSetFillRGBColor},
206 {"ri", 1, {tchkName},
207 &Gfx::opSetRenderingIntent},
208 {"s", 0, {tchkNone},
209 &Gfx::opCloseStroke},
210 {"sc", -4, {tchkNum, tchkNum, tchkNum, tchkNum},
211 &Gfx::opSetFillColor},
212 {"scn", -5, {tchkSCN, tchkSCN, tchkSCN, tchkSCN,
213 tchkSCN},
214 &Gfx::opSetFillColorN},
215 {"sh", 1, {tchkName},
216 &Gfx::opShFill},
217 {"v", 4, {tchkNum, tchkNum, tchkNum, tchkNum},
218 &Gfx::opCurveTo1},
219 {"w", 1, {tchkNum},
220 &Gfx::opSetLineWidth},
221 {"y", 4, {tchkNum, tchkNum, tchkNum, tchkNum},
222 &Gfx::opCurveTo2},
223 };
224
225 #ifdef WIN32 // this works around a bug in the VC7 compiler
226 # pragma optimize("",on)
227 #endif
228
229 #define numOps (sizeof(opTab) / sizeof(Operator))
230
231 //------------------------------------------------------------------------
232 // GfxResources
233 //------------------------------------------------------------------------
234
235 GfxResources::GfxResources(XRef *xref, Dict *resDict, GfxResources *nextA) {
236 Object obj1, obj2;
237 Ref r;
238
239 if (resDict) {
240
241 // build font dictionary
242 fonts = NULL;
243 resDict->lookupNF("Font", &obj1);
244 if (obj1.isRef()) {
245 obj1.fetch(xref, &obj2);
246 if (obj2.isDict()) {
247 r = obj1.getRef();
248 fonts = new GfxFontDict(xref, &r, obj2.getDict());
249 }
250 obj2.free();
251 } else if (obj1.isDict()) {
252 fonts = new GfxFontDict(xref, NULL, obj1.getDict());
253 }
254 obj1.free();
255
256 // get XObject dictionary
257 resDict->lookup("XObject", &xObjDict);
258
259 // get color space dictionary
260 resDict->lookup("ColorSpace", &colorSpaceDict);
261
262 // get pattern dictionary
263 resDict->lookup("Pattern", &patternDict);
264
265 // get shading dictionary
266 resDict->lookup("Shading", &shadingDict);
267
268 // get graphics state parameter dictionary
269 resDict->lookup("ExtGState", &gStateDict);
270
271 } else {
272 fonts = NULL;
273 xObjDict.initNull();
274 colorSpaceDict.initNull();
275 patternDict.initNull();
276 shadingDict.initNull();
277 gStateDict.initNull();
278 }
279
280 next = nextA;
281 }
282
283 GfxResources::~GfxResources() {
284 if (fonts) {
285 delete fonts;
286 }
287 xObjDict.free();
288 colorSpaceDict.free();
289 patternDict.free();
290 shadingDict.free();
291 gStateDict.free();
292 }
293
294 GfxFont *GfxResources::lookupFont(char *name) {
295 GfxFont *font;
296 GfxResources *resPtr;
297
298 for (resPtr = this; resPtr; resPtr = resPtr->next) {
299 if (resPtr->fonts) {
300 if ((font = resPtr->fonts->lookup(name)))
301 return font;
302 }
303 }
304 error(-1, "Unknown font tag '%s'", name);
305 return NULL;
306 }
307
308 GBool GfxResources::lookupXObject(char *name, Object *obj) {
309 GfxResources *resPtr;
310
311 for (resPtr = this; resPtr; resPtr = resPtr->next) {
312 if (resPtr->xObjDict.isDict()) {
313 if (!resPtr->xObjDict.dictLookup(name, obj)->isNull())
314 return gTrue;
315 obj->free();
316 }
317 }
318 error(-1, "XObject '%s' is unknown", name);
319 return gFalse;
320 }
321
322 GBool GfxResources::lookupXObjectNF(char *name, Object *obj) {
323 GfxResources *resPtr;
324
325 for (resPtr = this; resPtr; resPtr = resPtr->next) {
326 if (resPtr->xObjDict.isDict()) {
327 if (!resPtr->xObjDict.dictLookupNF(name, obj)->isNull())
328 return gTrue;
329 obj->free();
330 }
331 }
332 error(-1, "XObject '%s' is unknown", name);
333 return gFalse;
334 }
335
336 void GfxResources::lookupColorSpace(char *name, Object *obj) {
337 GfxResources *resPtr;
338
339 for (resPtr = this; resPtr; resPtr = resPtr->next) {
340 if (resPtr->colorSpaceDict.isDict()) {
341 if (!resPtr->colorSpaceDict.dictLookup(name, obj)->isNull()) {
342 return;
343 }
344 obj->free();
345 }
346 }
347 obj->initNull();
348 }
349
350 GfxPattern *GfxResources::lookupPattern(char *name) {
351 GfxResources *resPtr;
352 GfxPattern *pattern;
353 Object obj;
354
355 for (resPtr = this; resPtr; resPtr = resPtr->next) {
356 if (resPtr->patternDict.isDict()) {
357 if (!resPtr->patternDict.dictLookup(name, &obj)->isNull()) {
358 pattern = GfxPattern::parse(&obj);
359 obj.free();
360 return pattern;
361 }
362 obj.free();
363 }
364 }
365 error(-1, "Unknown pattern '%s'", name);
366 return NULL;
367 }
368
369 GfxShading *GfxResources::lookupShading(char *name) {
370 GfxResources *resPtr;
371 GfxShading *shading;
372 Object obj;
373
374 for (resPtr = this; resPtr; resPtr = resPtr->next) {
375 if (resPtr->shadingDict.isDict()) {
376 if (!resPtr->shadingDict.dictLookup(name, &obj)->isNull()) {
377 shading = GfxShading::parse(&obj);
378 obj.free();
379 return shading;
380 }
381 obj.free();
382 }
383 }
384 error(-1, "Unknown shading '%s'", name);
385 return NULL;
386 }
387
388 GBool GfxResources::lookupGState(char *name, Object *obj) {
389 GfxResources *resPtr;
390
391 for (resPtr = this; resPtr; resPtr = resPtr->next) {
392 if (resPtr->gStateDict.isDict()) {
393 if (!resPtr->gStateDict.dictLookup(name, obj)->isNull()) {
394 return gTrue;
395 }
396 obj->free();
397 }
398 }
399 error(-1, "ExtGState '%s' is unknown", name);
400 return gFalse;
401 }
402
403 //------------------------------------------------------------------------
404 // Gfx
405 //------------------------------------------------------------------------
406
407 Gfx::Gfx(XRef *xrefA, OutputDev *outA, int pageNum, Dict *resDict,
408 double hDPI, double vDPI, PDFRectangle *box, GBool crop,
409 PDFRectangle *cropBox, int rotate,
410 GBool (*abortCheckCbkA)(void *data),
411 void *abortCheckCbkDataA) {
412 int i;
413
414 xref = xrefA;
415 subPage = gFalse;
416 printCommands = globalParams->getPrintCommands();
417
418 // start the resource stack
419 res = new GfxResources(xref, resDict, NULL);
420
421 // initialize
422 out = outA;
423 state = new GfxState(hDPI, vDPI, box, rotate, out->upsideDown());
424 fontChanged = gFalse;
425 clip = clipNone;
426 ignoreUndef = 0;
427 out->startPage(pageNum, state);
428 out->setDefaultCTM(state->getCTM());
429 out->updateAll(state);
430 for (i = 0; i < 6; ++i) {
431 baseMatrix[i] = state->getCTM()[i];
432 }
433 formDepth = 0;
434 abortCheckCbk = abortCheckCbkA;
435 abortCheckCbkData = abortCheckCbkDataA;
436
437 // set crop box
438 if (crop) {
439 state->moveTo(cropBox->x1, cropBox->y1);
440 state->lineTo(cropBox->x2, cropBox->y1);
441 state->lineTo(cropBox->x2, cropBox->y2);
442 state->lineTo(cropBox->x1, cropBox->y2);
443 state->closePath();
444 state->clip();
445 out->clip(state);
446 state->clearPath();
447 }
448 }
449
450 Gfx::Gfx(XRef *xrefA, OutputDev *outA, Dict *resDict,
451 PDFRectangle *box, GBool crop, PDFRectangle *cropBox,
452 GBool (*abortCheckCbkA)(void *data),
453 void *abortCheckCbkDataA) {
454 int i;
455
456 xref = xrefA;
457 subPage = gTrue;
458 printCommands = globalParams->getPrintCommands();
459
460 // start the resource stack
461 res = new GfxResources(xref, resDict, NULL);
462
463 // initialize
464 out = outA;
465 state = new GfxState(72, 72, box, 0, gFalse);
466 fontChanged = gFalse;
467 clip = clipNone;
468 ignoreUndef = 0;
469 for (i = 0; i < 6; ++i) {
470 baseMatrix[i] = state->getCTM()[i];
471 }
472 formDepth = 0;
473 abortCheckCbk = abortCheckCbkA;
474 abortCheckCbkData = abortCheckCbkDataA;
475
476 // set crop box
477 if (crop) {
478 state->moveTo(cropBox->x1, cropBox->y1);
479 state->lineTo(cropBox->x2, cropBox->y1);
480 state->lineTo(cropBox->x2, cropBox->y2);
481 state->lineTo(cropBox->x1, cropBox->y2);
482 state->closePath();
483 state->clip();
484 out->clip(state);
485 state->clearPath();
486 }
487 }
488
489 Gfx::~Gfx() {
490 while (state->hasSaves()) {
491 restoreState();
492 }
493 if (!subPage) {
494 out->endPage();
495 }
496 while (res) {
497 popResources();
498 }
499 if (state) {
500 delete state;
501 }
502 }
503
504 void Gfx::display(Object *obj, GBool topLevel) {
505 Object obj2;
506 int i;
507
508 if (obj->isArray()) {
509 for (i = 0; i < obj->arrayGetLength(); ++i) {
510 obj->arrayGet(i, &obj2);
511 if (!obj2.isStream()) {
512 error(-1, "Weird page contents");
513 obj2.free();
514 return;
515 }
516 obj2.free();
517 }
518 } else if (!obj->isStream()) {
519 error(-1, "Weird page contents");
520 return;
521 }
522 parser = new Parser(xref, new Lexer(xref, obj));
523 go(topLevel);
524 delete parser;
525 parser = NULL;
526 }
527
528 void Gfx::go(GBool topLevel) {
529 Object obj;
530 Object args[maxArgs];
531 int numArgs, i;
532 int lastAbortCheck;
533
534 // scan a sequence of objects
535 updateLevel = lastAbortCheck = 0;
536 numArgs = 0;
537 parser->getObj(&obj);
538 while (!obj.isEOF()) {
539
540 // got a command - execute it
541 if (obj.isCmd()) {
542 if (printCommands) {
543 obj.print(stdout);
544 for (i = 0; i < numArgs; ++i) {
545 printf(" ");
546 args[i].print(stdout);
547 }
548 printf("\n");
549 fflush(stdout);
550 }
551 execOp(&obj, args, numArgs);
552 obj.free();
553 for (i = 0; i < numArgs; ++i)
554 args[i].free();
555 numArgs = 0;
556
557 // periodically update display
558 if (++updateLevel >= 20000) {
559 out->dump();
560 updateLevel = 0;
561 }
562
563 // check for an abort
564 if (abortCheckCbk) {
565 if (updateLevel - lastAbortCheck > 10) {
566 if ((*abortCheckCbk)(abortCheckCbkData)) {
567 break;
568 }
569 lastAbortCheck = updateLevel;
570 }
571 }
572
573 // got an argument - save it
574 } else if (numArgs < maxArgs) {
575 args[numArgs++] = obj;
576
577 // too many arguments - something is wrong
578 } else {
579 error(getPos(), "Too many args in content stream");
580 if (printCommands) {
581 printf("throwing away arg: ");
582 obj.print(stdout);
583 printf("\n");
584 fflush(stdout);
585 }
586 obj.free();
587 }
588
589 // grab the next object
590 parser->getObj(&obj);
591 }
592 obj.free();
593
594 // args at end with no command
595 if (numArgs > 0) {
596 error(getPos(), "Leftover args in content stream");
597 if (printCommands) {
598 printf("%d leftovers:", numArgs);
599 for (i = 0; i < numArgs; ++i) {
600 printf(" ");
601 args[i].print(stdout);
602 }
603 printf("\n");
604 fflush(stdout);
605 }
606 for (i = 0; i < numArgs; ++i)
607 args[i].free();
608 }
609
610 // update display
611 if (topLevel && updateLevel > 0) {
612 out->dump();
613 }
614 }
615
616 void Gfx::execOp(Object *cmd, Object args[], int numArgs) {
617 Operator *op;
618 char *name;
619 Object *argPtr;
620 int i;
621
622 // find operator
623 name = cmd->getCmd();
624 if (!(op = findOp(name))) {
625 if (ignoreUndef == 0)
626 error(getPos(), "Unknown operator '%s'", name);
627 return;
628 }
629
630 // type check args
631 argPtr = args;
632 if (op->numArgs >= 0) {
633 if (numArgs < op->numArgs) {
634 error(getPos(), "Too few (%d) args to '%s' operator", numArgs, name);
635 return;
636 }
637 if (numArgs > op->numArgs) {
638 #if 0
639 error(getPos(), "Too many (%d) args to '%s' operator", numArgs, name);
640 #endif
641 argPtr += numArgs - op->numArgs;
642 numArgs = op->numArgs;
643 }
644 } else {
645 if (numArgs > -op->numArgs) {
646 error(getPos(), "Too many (%d) args to '%s' operator",
647 numArgs, name);
648 return;
649 }
650 }
651 for (i = 0; i < numArgs; ++i) {
652 if (!checkArg(&argPtr[i], op->tchk[i])) {
653 error(getPos(), "Arg #%d to '%s' operator is wrong type (%s)",
654 i, name, argPtr[i].getTypeName());
655 return;
656 }
657 }
658
659 // do it
660 (this->*op->func)(argPtr, numArgs);
661 }
662
663 Operator *Gfx::findOp(char *name) {
664 int a, b, m, cmp;
665
666 a = -1;
667 b = numOps;
668 // invariant: opTab[a] < name < opTab[b]
669 while (b - a > 1) {
670 m = (a + b) / 2;
671 cmp = strcmp(opTab[m].name, name);
672 if (cmp < 0)
673 a = m;
674 else if (cmp > 0)
675 b = m;
676 else
677 a = b = m;
678 }
679 if (cmp != 0)
680 return NULL;
681 return &opTab[a];
682 }
683
684 GBool Gfx::checkArg(Object *arg, TchkType type) {
685 switch (type) {
686 case tchkBool: return arg->isBool();
687 case tchkInt: return arg->isInt();
688 case tchkNum: return arg->isNum();
689 case tchkString: return arg->isString();
690 case tchkName: return arg->isName();
691 case tchkArray: return arg->isArray();
692 case tchkProps: return arg->isDict() || arg->isName();
693 case tchkSCN: return arg->isNum() || arg->isName();
694 case tchkNone: return gFalse;
695 }
696 return gFalse;
697 }
698
699 int Gfx::getPos() {
700 return parser ? parser->getPos() : -1;
701 }
702
703 //------------------------------------------------------------------------
704 // graphics state operators
705 //------------------------------------------------------------------------
706
707 void Gfx::opSave(Object args[], int numArgs) {
708 saveState();
709 }
710
711 void Gfx::opRestore(Object args[], int numArgs) {
712 restoreState();
713 }
714
715 void Gfx::opConcat(Object args[], int numArgs) {
716 state->concatCTM(args[0].getNum(), args[1].getNum(),
717 args[2].getNum(), args[3].getNum(),
718 args[4].getNum(), args[5].getNum());
719 out->updateCTM(state, args[0].getNum(), args[1].getNum(),
720 args[2].getNum(), args[3].getNum(),
721 args[4].getNum(), args[5].getNum());
722 fontChanged = gTrue;
723 }
724
725 void Gfx::opSetDash(Object args[], int numArgs) {
726 Array *a;
727 int length;
728 Object obj;
729 double *dash;
730 int i;
731
732 a = args[0].getArray();
733 length = a->getLength();
734 if (length == 0) {
735 dash = NULL;
736 } else {
737 dash = (double *)gmalloc(length * sizeof(double));
738 for (i = 0; i < length; ++i) {
739 dash[i] = a->get(i, &obj)->getNum();
740 obj.free();
741 }
742 }
743 state->setLineDash(dash, length, args[1].getNum());
744 out->updateLineDash(state);
745 }
746
747 void Gfx::opSetFlat(Object args[], int numArgs) {
748 state->setFlatness((int)args[0].getNum());
749 out->updateFlatness(state);
750 }
751
752 void Gfx::opSetLineJoin(Object args[], int numArgs) {
753 state->setLineJoin(args[0].getInt());
754 out->updateLineJoin(state);
755 }
756
757 void Gfx::opSetLineCap(Object args[], int numArgs) {
758 state->setLineCap(args[0].getInt());
759 out->updateLineCap(state);
760 }
761
762 void Gfx::opSetMiterLimit(Object args[], int numArgs) {
763 state->setMiterLimit(args[0].getNum());
764 out->updateMiterLimit(state);
765 }
766
767 void Gfx::opSetLineWidth(Object args[], int numArgs) {
768 state->setLineWidth(args[0].getNum());
769 out->updateLineWidth(state);
770 }
771
772 void Gfx::opSetExtGState(Object args[], int numArgs) {
773 Object obj1, obj2;
774
775 if (!res->lookupGState(args[0].getName(), &obj1)) {
776 return;
777 }
778 if (!obj1.isDict()) {
779 error(getPos(), "ExtGState '%s' is wrong type", args[0].getName());
780 obj1.free();
781 return;
782 }
783 if (obj1.dictLookup("ca", &obj2)->isNum()) {
784 state->setFillOpacity(obj2.getNum());
785 out->updateFillOpacity(state);
786 }
787 obj2.free();
788 if (obj1.dictLookup("CA", &obj2)->isNum()) {
789 state->setStrokeOpacity(obj2.getNum());
790 out->updateStrokeOpacity(state);
791 }
792 obj2.free();
793 obj1.free();
794 }
795
796 void Gfx::opSetRenderingIntent(Object args[], int numArgs) {
797 }
798
799 //------------------------------------------------------------------------
800 // color operators
801 //------------------------------------------------------------------------
802
803 void Gfx::opSetFillGray(Object args[], int numArgs) {
804 GfxColor color;
805
806 state->setFillPattern(NULL);
807 state->setFillColorSpace(new GfxDeviceGrayColorSpace());
808 color.c[0] = args[0].getNum();
809 state->setFillColor(&color);
810 out->updateFillColor(state);
811 }
812
813 void Gfx::opSetStrokeGray(Object args[], int numArgs) {
814 GfxColor color;
815
816 state->setStrokePattern(NULL);
817 state->setStrokeColorSpace(new GfxDeviceGrayColorSpace());
818 color.c[0] = args[0].getNum();
819 state->setStrokeColor(&color);
820 out->updateStrokeColor(state);
821 }
822
823 void Gfx::opSetFillCMYKColor(Object args[], int numArgs) {
824 GfxColor color;
825 int i;
826
827 state->setFillPattern(NULL);
828 state->setFillColorSpace(new GfxDeviceCMYKColorSpace());
829 for (i = 0; i < 4; ++i) {
830 color.c[i] = args[i].getNum();
831 }
832 state->setFillColor(&color);
833 out->updateFillColor(state);
834 }
835
836 void Gfx::opSetStrokeCMYKColor(Object args[], int numArgs) {
837 GfxColor color;
838 int i;
839
840 state->setStrokePattern(NULL);
841 state->setStrokeColorSpace(new GfxDeviceCMYKColorSpace());
842 for (i = 0; i < 4; ++i) {
843 color.c[i] = args[i].getNum();
844 }
845 state->setStrokeColor(&color);
846 out->updateStrokeColor(state);
847 }
848
849 void Gfx::opSetFillRGBColor(Object args[], int numArgs) {
850 GfxColor color;
851 int i;
852
853 state->setFillPattern(NULL);
854 state->setFillColorSpace(new GfxDeviceRGBColorSpace());
855 for (i = 0; i < 3; ++i) {
856 color.c[i] = args[i].getNum();
857 }
858 state->setFillColor(&color);
859 out->updateFillColor(state);
860 }
861
862 void Gfx::opSetStrokeRGBColor(Object args[], int numArgs) {
863 GfxColor color;
864 int i;
865
866 state->setStrokePattern(NULL);
867 state->setStrokeColorSpace(new GfxDeviceRGBColorSpace());
868 for (i = 0; i < 3; ++i) {
869 color.c[i] = args[i].getNum();
870 }
871 state->setStrokeColor(&color);
872 out->updateStrokeColor(state);
873 }
874
875 void Gfx::opSetFillColorSpace(Object args[], int numArgs) {
876 Object obj;
877 GfxColorSpace *colorSpace;
878 GfxColor color;
879 int i;
880
881 state->setFillPattern(NULL);
882 res->lookupColorSpace(args[0].getName(), &obj);
883 if (obj.isNull()) {
884 colorSpace = GfxColorSpace::parse(&args[0]);
885 } else {
886 colorSpace = GfxColorSpace::parse(&obj);
887 }
888 obj.free();
889 if (colorSpace) {
890 state->setFillColorSpace(colorSpace);
891 } else {
892 error(getPos(), "Bad color space (fill)");
893 }
894 for (i = 0; i < gfxColorMaxComps; ++i) {
895 color.c[i] = 0;
896 }
897 state->setFillColor(&color);
898 out->updateFillColor(state);
899 }
900
901 void Gfx::opSetStrokeColorSpace(Object args[], int numArgs) {
902 Object obj;
903 GfxColorSpace *colorSpace;
904 GfxColor color;
905 int i;
906
907 state->setStrokePattern(NULL);
908 res->lookupColorSpace(args[0].getName(), &obj);
909 if (obj.isNull()) {
910 colorSpace = GfxColorSpace::parse(&args[0]);
911 } else {
912 colorSpace = GfxColorSpace::parse(&obj);
913 }
914 obj.free();
915 if (colorSpace) {
916 state->setStrokeColorSpace(colorSpace);
917 } else {
918 error(getPos(), "Bad color space (stroke)");
919 }
920 for (i = 0; i < gfxColorMaxComps; ++i) {
921 color.c[i] = 0;
922 }
923 state->setStrokeColor(&color);
924 out->updateStrokeColor(state);
925 }
926
927 void Gfx::opSetFillColor(Object args[], int numArgs) {
928 GfxColor color;
929 int i;
930
931 state->setFillPattern(NULL);
932 for (i = 0; i < numArgs; ++i) {
933 color.c[i] = args[i].getNum();
934 }
935 state->setFillColor(&color);
936 out->updateFillColor(state);
937 }
938
939 void Gfx::opSetStrokeColor(Object args[], int numArgs) {
940 GfxColor color;
941 int i;
942
943 state->setStrokePattern(NULL);
944 for (i = 0; i < numArgs; ++i) {
945 color.c[i] = args[i].getNum();
946 }
947 state->setStrokeColor(&color);
948 out->updateStrokeColor(state);
949 }
950
951 void Gfx::opSetFillColorN(Object args[], int numArgs) {
952 GfxColor color;
953 GfxPattern *pattern;
954 int i;
955
956 if (state->getFillColorSpace()->getMode() == csPattern) {
957 if (numArgs > 1) {
958 for (i = 0; i < numArgs && i < 4; ++i) {
959 if (args[i].isNum()) {
960 color.c[i] = args[i].getNum();
961 }
962 }
963 state->setFillColor(&color);
964 out->updateFillColor(state);
965 }
966 if (args[numArgs-1].isName() &&
967 (pattern = res->lookupPattern(args[numArgs-1].getName()))) {
968 state->setFillPattern(pattern);
969 }
970
971 } else {
972 state->setFillPattern(NULL);
973 for (i = 0; i < numArgs && i < 4; ++i) {
974 if (args[i].isNum()) {
975 color.c[i] = args[i].getNum();
976 }
977 }
978 state->setFillColor(&color);
979 out->updateFillColor(state);
980 }
981 }
982
983 void Gfx::opSetStrokeColorN(Object args[], int numArgs) {
984 GfxColor color;
985 GfxPattern *pattern;
986 int i;
987
988 if (state->getStrokeColorSpace()->getMode() == csPattern) {
989 if (numArgs > 1) {
990 for (i = 0; i < numArgs && i < 4; ++i) {
991 if (args[i].isNum()) {
992 color.c[i] = args[i].getNum();
993 }
994 }
995 state->setStrokeColor(&color);
996 out->updateStrokeColor(state);
997 }
998 if (args[numArgs-1].isName() &&
999 (pattern = res->lookupPattern(args[numArgs-1].getName()))) {
1000 state->setStrokePattern(pattern);
1001 }
1002
1003 } else {
1004 state->setStrokePattern(NULL);
1005 for (i = 0; i < numArgs && i < 4; ++i) {
1006 if (args[i].isNum()) {
1007 color.c[i] = args[i].getNum();
1008 }
1009 }
1010 state->setStrokeColor(&color);
1011 out->updateStrokeColor(state);
1012 }
1013 }
1014
1015 //------------------------------------------------------------------------
1016 // path segment operators
1017 //------------------------------------------------------------------------
1018
1019 void Gfx::opMoveTo(Object args[], int numArgs) {
1020 state->moveTo(args[0].getNum(), args[1].getNum());
1021 }
1022
1023 void Gfx::opLineTo(Object args[], int numArgs) {
1024 if (!state->isCurPt()) {
1025 error(getPos(), "No current point in lineto");
1026 return;
1027 }
1028 state->lineTo(args[0].getNum(), args[1].getNum());
1029 }
1030
1031 void Gfx::opCurveTo(Object args[], int numArgs) {
1032 double x1, y1, x2, y2, x3, y3;
1033
1034 if (!state->isCurPt()) {
1035 error(getPos(), "No current point in curveto");
1036 return;
1037 }
1038 x1 = args[0].getNum();
1039 y1 = args[1].getNum();
1040 x2 = args[2].getNum();
1041 y2 = args[3].getNum();
1042 x3 = args[4].getNum();
1043 y3 = args[5].getNum();
1044 state->curveTo(x1, y1, x2, y2, x3, y3);
1045 }
1046
1047 void Gfx::opCurveTo1(Object args[], int numArgs) {
1048 double x1, y1, x2, y2, x3, y3;
1049
1050 if (!state->isCurPt()) {
1051 error(getPos(), "No current point in curveto1");
1052 return;
1053 }
1054 x1 = state->getCurX();
1055 y1 = state->getCurY();
1056 x2 = args[0].getNum();
1057 y2 = args[1].getNum();
1058 x3 = args[2].getNum();
1059 y3 = args[3].getNum();
1060 state->curveTo(x1, y1, x2, y2, x3, y3);
1061 }
1062
1063 void Gfx::opCurveTo2(Object args[], int numArgs) {
1064 double x1, y1, x2, y2, x3, y3;
1065
1066 if (!state->isCurPt()) {
1067 error(getPos(), "No current point in curveto2");
1068 return;
1069 }
1070 x1 = args[0].getNum();
1071 y1 = args[1].getNum();
1072 x2 = args[2].getNum();
1073 y2 = args[3].getNum();
1074 x3 = x2;
1075 y3 = y2;
1076 state->curveTo(x1, y1, x2, y2, x3, y3);
1077 }
1078
1079 void Gfx::opRectangle(Object args[], int numArgs) {
1080 double x, y, w, h;
1081
1082 x = args[0].getNum();
1083 y = args[1].getNum();
1084 w = args[2].getNum();
1085 h = args[3].getNum();
1086 state->moveTo(x, y);
1087 state->lineTo(x + w, y);
1088 state->lineTo(x + w, y + h);
1089 state->lineTo(x, y + h);
1090 state->closePath();
1091 }
1092
1093 void Gfx::opClosePath(Object args[], int numArgs) {
1094 if (!state->isCurPt()) {
1095 error(getPos(), "No current point in closepath");
1096 return;
1097 }
1098 state->closePath();
1099 }
1100
1101 //------------------------------------------------------------------------
1102 // path painting operators
1103 //------------------------------------------------------------------------
1104
1105 void Gfx::opEndPath(Object args[], int numArgs) {
1106 doEndPath();
1107 }
1108
1109 void Gfx::opStroke(Object args[], int numArgs) {
1110 if (!state->isCurPt()) {
1111 //error(getPos(), "No path in stroke");
1112 return;
1113 }
1114 if (state->isPath())
1115 out->stroke(state);
1116 doEndPath();
1117 }
1118
1119 void Gfx::opCloseStroke(Object args[], int numArgs) {
1120 if (!state->isCurPt()) {
1121 //error(getPos(), "No path in closepath/stroke");
1122 return;
1123 }
1124 if (state->isPath()) {
1125 state->closePath();
1126 out->stroke(state);
1127 }
1128 doEndPath();
1129 }
1130
1131 void Gfx::opFill(Object args[], int numArgs) {
1132 if (!state->isCurPt()) {
1133 //error(getPos(), "No path in fill");
1134 return;
1135 }
1136 if (state->isPath()) {
1137 if (state->getFillColorSpace()->getMode() == csPattern) {
1138 doPatternFill(gFalse);
1139 } else {
1140 out->fill(state);
1141 }
1142 }
1143 doEndPath();
1144 }
1145
1146 void Gfx::opEOFill(Object args[], int numArgs) {
1147 if (!state->isCurPt()) {
1148 //error(getPos(), "No path in eofill");
1149 return;
1150 }
1151 if (state->isPath()) {
1152 if (state->getFillColorSpace()->getMode() == csPattern) {
1153 doPatternFill(gTrue);
1154 } else {
1155 out->eoFill(state);
1156 }
1157 }
1158 doEndPath();
1159 }
1160
1161 void Gfx::opFillStroke(Object args[], int numArgs) {
1162 if (!state->isCurPt()) {
1163 //error(getPos(), "No path in fill/stroke");
1164 return;
1165 }
1166 if (state->isPath()) {
1167 if (state->getFillColorSpace()->getMode() == csPattern) {
1168 doPatternFill(gFalse);
1169 } else {
1170 out->fill(state);
1171 }
1172 out->stroke(state);
1173 }
1174 doEndPath();
1175 }
1176
1177 void Gfx::opCloseFillStroke(Object args[], int numArgs) {
1178 if (!state->isCurPt()) {
1179 //error(getPos(), "No path in closepath/fill/stroke");
1180 return;
1181 }
1182 if (state->isPath()) {
1183 state->closePath();
1184 if (state->getFillColorSpace()->getMode() == csPattern) {
1185 doPatternFill(gFalse);
1186 } else {
1187 out->fill(state);
1188 }
1189 out->stroke(state);
1190 }
1191 doEndPath();
1192 }
1193
1194 void Gfx::opEOFillStroke(Object args[], int numArgs) {
1195 if (!state->isCurPt()) {
1196 //error(getPos(), "No path in eofill/stroke");
1197 return;
1198 }
1199 if (state->isPath()) {
1200 if (state->getFillColorSpace()->getMode() == csPattern) {
1201 doPatternFill(gTrue);
1202 } else {
1203 out->eoFill(state);
1204 }
1205 out->stroke(state);
1206 }
1207 doEndPath();
1208 }
1209
1210 void Gfx::opCloseEOFillStroke(Object args[], int numArgs) {
1211 if (!state->isCurPt()) {
1212 //error(getPos(), "No path in closepath/eofill/stroke");
1213 return;
1214 }
1215 if (state->isPath()) {
1216 state->closePath();
1217 if (state->getFillColorSpace()->getMode() == csPattern) {
1218 doPatternFill(gTrue);
1219 } else {
1220 out->eoFill(state);
1221 }
1222 out->stroke(state);
1223 }
1224 doEndPath();
1225 }
1226
1227 void Gfx::doPatternFill(GBool eoFill) {
1228 GfxPattern *pattern;
1229
1230 // this is a bit of a kludge -- patterns can be really slow, so we
1231 // skip them if we're only doing text extraction, since they almost
1232 // certainly don't contain any text
1233 if (!out->needNonText()) {
1234 return;
1235 }
1236
1237 if (!(pattern = state->getFillPattern())) {
1238 return;
1239 }
1240 switch (pattern->getType()) {
1241 case 1:
1242 doTilingPatternFill((GfxTilingPattern *)pattern, eoFill);
1243 break;
1244 case 2:
1245 doShadingPatternFill((GfxShadingPattern *)pattern, eoFill);
1246 break;
1247 default:
1248 error(getPos(), "Unimplemented pattern type (%d) in fill",
1249 pattern->getType());
1250 break;
1251 }
1252 }
1253
1254 void Gfx::doTilingPatternFill(GfxTilingPattern *tPat, GBool eoFill) {
1255 GfxPatternColorSpace *patCS;
1256 GfxColorSpace *cs;
1257 GfxPath *savedPath;
1258 double xMin, yMin, xMax, yMax, x, y, x1, y1;
1259 double cxMin, cyMin, cxMax, cyMax;
1260 int xi0, yi0, xi1, yi1, xi, yi;
1261 double *ctm, *btm, *ptm;
1262 double m[6], ictm[6], m1[6], imb[6];
1263 double det;
1264 double xstep, ystep;
1265 int i;
1266
1267 // get color space
1268 patCS = (GfxPatternColorSpace *)state->getFillColorSpace();
1269
1270 // construct a (pattern space) -> (current space) transform matrix
1271 ctm = state->getCTM();
1272 btm = baseMatrix;
1273 ptm = tPat->getMatrix();
1274 // iCTM = invert CTM
1275 det = 1 / (ctm[0] * ctm[3] - ctm[1] * ctm[2]);
1276 ictm[0] = ctm[3] * det;
1277 ictm[1] = -ctm[1] * det;
1278 ictm[2] = -ctm[2] * det;
1279 ictm[3] = ctm[0] * det;
1280 ictm[4] = (ctm[2] * ctm[5] - ctm[3] * ctm[4]) * det;
1281 ictm[5] = (ctm[1] * ctm[4] - ctm[0] * ctm[5]) * det;
1282 // m1 = PTM * BTM = PTM * base transform matrix
1283 m1[0] = ptm[0] * btm[0] + ptm[1] * btm[2];
1284 m1[1] = ptm[0] * btm[1] + ptm[1] * btm[3];
1285 m1[2] = ptm[2] * btm[0] + ptm[3] * btm[2];
1286 m1[3] = ptm[2] * btm[1] + ptm[3] * btm[3];
1287 m1[4] = ptm[4] * btm[0] + ptm[5] * btm[2] + btm[4];
1288 m1[5] = ptm[4] * btm[1] + ptm[5] * btm[3] + btm[5];
1289 // m = m1 * iCTM = (PTM * BTM) * (iCTM)
1290 m[0] = m1[0] * ictm[0] + m1[1] * ictm[2];
1291 m[1] = m1[0] * ictm[1] + m1[1] * ictm[3];
1292 m[2] = m1[2] * ictm[0] + m1[3] * ictm[2];
1293 m[3] = m1[2] * ictm[1] + m1[3] * ictm[3];
1294 m[4] = m1[4] * ictm[0] + m1[5] * ictm[2] + ictm[4];
1295 m[5] = m1[4] * ictm[1] + m1[5] * ictm[3] + ictm[5];
1296
1297 // construct a (base space) -> (pattern space) transform matrix
1298 det = 1 / (m1[0] * m1[3] - m1[1] * m1[2]);
1299 imb[0] = m1[3] * det;
1300 imb[1] = -m1[1] * det;
1301 imb[2] = -m1[2] * det;
1302 imb[3] = m1[0] * det;
1303 imb[4] = (m1[2] * m1[5] - m1[3] * m1[4]) * det;
1304 imb[5] = (m1[1] * m1[4] - m1[0] * m1[5]) * det;
1305
1306 // save current graphics state
1307 savedPath = state->getPath()->copy();
1308 saveState();
1309
1310 // set underlying color space (for uncolored tiling patterns); set
1311 // various other parameters (stroke color, line width) to match
1312 // Adobe's behavior
1313 if (tPat->getPaintType() == 2 && (cs = patCS->getUnder())) {
1314 state->setFillColorSpace(cs->copy());
1315 state->setStrokeColorSpace(cs->copy());
1316 state->setStrokeColor(state->getFillColor());
1317 } else {
1318 state->setFillColorSpace(new GfxDeviceGrayColorSpace());
1319 state->setStrokeColorSpace(new GfxDeviceGrayColorSpace());
1320 }
1321 state->setFillPattern(NULL);
1322 out->updateFillColor(state);
1323 state->setStrokePattern(NULL);
1324 out->updateStrokeColor(state);
1325 state->setLineWidth(0);
1326 out->updateLineWidth(state);
1327
1328 // clip to current path
1329 state->clip();
1330 if (eoFill) {
1331 out->eoClip(state);
1332 } else {
1333 out->clip(state);
1334 }
1335 state->clearPath();
1336
1337 // transform clip region bbox to pattern space
1338 state->getClipBBox(&cxMin, &cyMin, &cxMax, &cyMax);
1339 xMin = xMax = cxMin * imb[0] + cyMin * imb[2] + imb[4];
1340 yMin = yMax = cxMin * imb[1] + cyMin * imb[3] + imb[5];
1341 x1 = cxMin * imb[0] + cyMax * imb[2] + imb[4];
1342 y1 = cxMin * imb[1] + cyMax * imb[3] + imb[5];
1343 if (x1 < xMin) {
1344 xMin = x1;
1345 } else if (x1 > xMax) {
1346 xMax = x1;
1347 }
1348 if (y1 < yMin) {
1349 yMin = y1;
1350 } else if (y1 > yMax) {
1351 yMax = y1;
1352 }
1353 x1 = cxMax * imb[0] + cyMin * imb[2] + imb[4];
1354 y1 = cxMax * imb[1] + cyMin * imb[3] + imb[5];
1355 if (x1 < xMin) {
1356 xMin = x1;
1357 } else if (x1 > xMax) {
1358 xMax = x1;
1359 }
1360 if (y1 < yMin) {
1361 yMin = y1;
1362 } else if (y1 > yMax) {
1363 yMax = y1;
1364 }
1365 x1 = cxMax * imb[0] + cyMax * imb[2] + imb[4];
1366 y1 = cxMax * imb[1] + cyMax * imb[3] + imb[5];
1367 if (x1 < xMin) {
1368 xMin = x1;
1369 } else if (x1 > xMax) {
1370 xMax = x1;
1371 }
1372 if (y1 < yMin) {
1373 yMin = y1;
1374 } else if (y1 > yMax) {
1375 yMax = y1;
1376 }
1377
1378 // draw the pattern
1379 //~ this should treat negative steps differently -- start at right/top
1380 //~ edge instead of left/bottom (?)
1381 xstep = fabs(tPat->getXStep());
1382 ystep = fabs(tPat->getYStep());
1383 xi0 = (int)floor((xMin - tPat->getBBox()[0]) / xstep);
1384 xi1 = (int)ceil((xMax - tPat->getBBox()[0]) / xstep);
1385 yi0 = (int)floor((yMin - tPat->getBBox()[1]) / ystep);
1386 yi1 = (int)ceil((yMax - tPat->getBBox()[1]) / ystep);
1387 for (i = 0; i < 4; ++i) {
1388 m1[i] = m[i];
1389 }
1390 for (yi = yi0; yi < yi1; ++yi) {
1391 for (xi = xi0; xi < xi1; ++xi) {
1392 x = xi * xstep;
1393 y = yi * ystep;
1394 m1[4] = x * m[0] + y * m[2] + m[4];
1395 m1[5] = x * m[1] + y * m[3] + m[5];
1396 doForm1(tPat->getContentStream(), tPat->getResDict(),
1397 m1, tPat->getBBox());
1398 }
1399 }
1400
1401 // restore graphics state
1402 restoreState();
1403 state->setPath(savedPath);
1404 }
1405
1406 void Gfx::doShadingPatternFill(GfxShadingPattern *sPat, GBool eoFill) {
1407 GfxShading *shading;
1408 GfxPath *savedPath;
1409 double *ctm, *btm, *ptm;
1410 double m[6], ictm[6], m1[6];
1411 double xMin, yMin, xMax, yMax;
1412 double det;
1413
1414 shading = sPat->getShading();
1415
1416 // save current graphics state
1417 savedPath = state->getPath()->copy();
1418 saveState();
1419
1420 // clip to bbox
1421 if (shading->getHasBBox()) {
1422 shading->getBBox(&xMin, &yMin, &xMax, &yMax);
1423 state->moveTo(xMin, yMin);
1424 state->lineTo(xMax, yMin);
1425 state->lineTo(xMax, yMax);
1426 state->lineTo(xMin, yMax);
1427 state->closePath();
1428 state->clip();
1429 out->clip(state);
1430 state->clearPath();
1431 }
1432
1433 // clip to current path
1434 state->clip();
1435 if (eoFill) {
1436 out->eoClip(state);
1437 } else {
1438 out->clip(state);
1439 }
1440 state->clearPath();
1441
1442 // construct a (pattern space) -> (current space) transform matrix
1443 ctm = state->getCTM();
1444 btm = baseMatrix;
1445 ptm = sPat->getMatrix();
1446 // iCTM = invert CTM
1447 det = 1 / (ctm[0] * ctm[3] - ctm[1] * ctm[2]);
1448 ictm[0] = ctm[3] * det;
1449 ictm[1] = -ctm[1] * det;
1450 ictm[2] = -ctm[2] * det;
1451 ictm[3] = ctm[0] * det;
1452 ictm[4] = (ctm[2] * ctm[5] - ctm[3] * ctm[4]) * det;
1453 ictm[5] = (ctm[1] * ctm[4] - ctm[0] * ctm[5]) * det;
1454 // m1 = PTM * BTM = PTM * base transform matrix
1455 m1[0] = ptm[0] * btm[0] + ptm[1] * btm[2];
1456 m1[1] = ptm[0] * btm[1] + ptm[1] * btm[3];
1457 m1[2] = ptm[2] * btm[0] + ptm[3] * btm[2];
1458 m1[3] = ptm[2] * btm[1] + ptm[3] * btm[3];
1459 m1[4] = ptm[4] * btm[0] + ptm[5] * btm[2] + btm[4];
1460 m1[5] = ptm[4] * btm[1] + ptm[5] * btm[3] + btm[5];
1461 // m = m1 * iCTM = (PTM * BTM) * (iCTM)
1462 m[0] = m1[0] * ictm[0] + m1[1] * ictm[2];
1463 m[1] = m1[0] * ictm[1] + m1[1] * ictm[3];
1464 m[2] = m1[2] * ictm[0] + m1[3] * ictm[2];
1465 m[3] = m1[2] * ictm[1] + m1[3] * ictm[3];
1466 m[4] = m1[4] * ictm[0] + m1[5] * ictm[2] + ictm[4];
1467 m[5] = m1[4] * ictm[1] + m1[5] * ictm[3] + ictm[5];
1468
1469 // set the new matrix
1470 state->concatCTM(m[0], m[1], m[2], m[3], m[4], m[5]);
1471 out->updateCTM(state, m[0], m[1], m[2], m[3], m[4], m[5]);
1472
1473 // set the color space
1474 state->setFillColorSpace(shading->getColorSpace()->copy());
1475
1476 // do shading type-specific operations
1477 switch (shading->getType()) {
1478 case 1:
1479 doFunctionShFill((GfxFunctionShading *)shading);
1480 break;
1481 case 2:
1482 doAxialShFill((GfxAxialShading *)shading);
1483 break;
1484 case 3:
1485 doRadialShFill((GfxRadialShading *)shading);
1486 break;
1487 }
1488
1489 // restore graphics state
1490 restoreState();
1491 state->setPath(savedPath);
1492 }
1493
1494 void Gfx::opShFill(Object args[], int numArgs) {
1495 GfxShading *shading;
1496 GfxPath *savedPath;
1497 double xMin, yMin, xMax, yMax;
1498
1499 if (!(shading = res->lookupShading(args[0].getName()))) {
1500 return;
1501 }
1502
1503 // save current graphics state
1504 savedPath = state->getPath()->copy();
1505 saveState();
1506
1507 // clip to bbox
1508 if (shading->getHasBBox()) {
1509 shading->getBBox(&xMin, &yMin, &xMax, &yMax);
1510 state->moveTo(xMin, yMin);
1511 state->lineTo(xMax, yMin);
1512 state->lineTo(xMax, yMax);
1513 state->lineTo(xMin, yMax);
1514 state->closePath();
1515 state->clip();
1516 out->clip(state);
1517 state->clearPath();
1518 }
1519
1520 // set the color space
1521 state->setFillColorSpace(shading->getColorSpace()->copy());
1522
1523 // do shading type-specific operations
1524 switch (shading->getType()) {
1525 case 1:
1526 doFunctionShFill((GfxFunctionShading *)shading);
1527 break;
1528 case 2:
1529 doAxialShFill((GfxAxialShading *)shading);
1530 break;
1531 case 3:
1532 doRadialShFill((GfxRadialShading *)shading);
1533 break;
1534 }
1535
1536 // restore graphics state
1537 restoreState();
1538 state->setPath(savedPath);
1539
1540 delete shading;
1541 }
1542
1543 void Gfx::doFunctionShFill(GfxFunctionShading *shading) {
1544 double x0, y0, x1, y1;
1545 GfxColor colors[4];
1546
1547 shading->getDomain(&x0, &y0, &x1, &y1);
1548 shading->getColor(x0, y0, &colors[0]);
1549 shading->getColor(x0, y1, &colors[1]);
1550 shading->getColor(x1, y0, &colors[2]);
1551 shading->getColor(x1, y1, &colors[3]);
1552 doFunctionShFill1(shading, x0, y0, x1, y1, colors, 0);
1553 }
1554
1555 void Gfx::doFunctionShFill1(GfxFunctionShading *shading,
1556 double x0, double y0,
1557 double x1, double y1,
1558 GfxColor *colors, int depth) {
1559 GfxColor fillColor;
1560 GfxColor color0M, color1M, colorM0, colorM1, colorMM;
1561 GfxColor colors2[4];
1562 double *matrix;
1563 double xM, yM;
1564 int nComps, i, j;
1565
1566 nComps = shading->getColorSpace()->getNComps();
1567 matrix = shading->getMatrix();
1568
1569 // compare the four corner colors
1570 for (i = 0; i < 4; ++i) {
1571 for (j = 0; j < nComps; ++j) {
1572 if (fabs(colors[i].c[j] - colors[(i+1)&3].c[j]) > functionColorDelta) {
1573 break;
1574 }
1575 }
1576 if (j < nComps) {
1577 break;
1578 }
1579 }
1580
1581 // center of the rectangle
1582 xM = 0.5 * (x0 + x1);
1583 yM = 0.5 * (y0 + y1);
1584
1585 // the four corner colors are close (or we hit the recursive limit)
1586 // -- fill the rectangle; but require at least one subdivision
1587 // (depth==0) to avoid problems when the four outer corners of the
1588 // shaded region are the same color
1589 if ((i == 4 && depth > 0) || depth == functionMaxDepth) {
1590
1591 // use the center color
1592 shading->getColor(xM, yM, &fillColor);
1593 state->setFillColor(&fillColor);
1594 out->updateFillColor(state);
1595
1596 // fill the rectangle
1597 state->moveTo(x0 * matrix[0] + y0 * matrix[2] + matrix[4],
1598 x0 * matrix[1] + y0 * matrix[3] + matrix[5]);
1599 state->lineTo(x1 * matrix[0] + y0 * matrix[2] + matrix[4],
1600 x1 * matrix[1] + y0 * matrix[3] + matrix[5]);
1601 state->lineTo(x1 * matrix[0] + y1 * matrix[2] + matrix[4],
1602 x1 * matrix[1] + y1 * matrix[3] + matrix[5]);
1603 state->lineTo(x0 * matrix[0] + y1 * matrix[2] + matrix[4],
1604 x0 * matrix[1] + y1 * matrix[3] + matrix[5]);
1605 state->closePath();
1606 out->fill(state);
1607 state->clearPath();
1608
1609 // the four corner colors are not close enough -- subdivide the
1610 // rectangle
1611 } else {
1612
1613 // colors[0] colorM0 colors[2]
1614 // (x0,y0) (xM,y0) (x1,y0)
1615 // +----------+----------+
1616 // | | |
1617 // | UL | UR |
1618 // color0M | colorMM | color1M
1619 // (x0,yM) +----------+----------+ (x1,yM)
1620 // | (xM,yM) |
1621 // | LL | LR |
1622 // | | |
1623 // +----------+----------+
1624 // colors[1] colorM1 colors[3]
1625 // (x0,y1) (xM,y1) (x1,y1)
1626
1627 shading->getColor(x0, yM, &color0M);
1628 shading->getColor(x1, yM, &color1M);
1629 shading->getColor(xM, y0, &colorM0);
1630 shading->getColor(xM, y1, &colorM1);
1631 shading->getColor(xM, yM, &colorMM);
1632
1633 // upper-left sub-rectangle
1634 colors2[0] = colors[0];
1635 colors2[1] = color0M;
1636 colors2[2] = colorM0;
1637 colors2[3] = colorMM;
1638 doFunctionShFill1(shading, x0, y0, xM, yM, colors2, depth + 1);
1639
1640 // lower-left sub-rectangle
1641 colors2[0] = color0M;
1642 colors2[1] = colors[1];
1643 colors2[2] = colorMM;
1644 colors2[3] = colorM1;
1645 doFunctionShFill1(shading, x0, yM, xM, y1, colors2, depth + 1);
1646
1647 // upper-right sub-rectangle
1648 colors2[0] = colorM0;
1649 colors2[1] = colorMM;
1650 colors2[2] = colors[2];
1651 colors2[3] = color1M;
1652 doFunctionShFill1(shading, xM, y0, x1, yM, colors2, depth + 1);
1653
1654 // lower-right sub-rectangle
1655 colors2[0] = colorMM;
1656 colors2[1] = colorM1;
1657 colors2[2] = color1M;
1658 colors2[3] = colors[3];
1659 doFunctionShFill1(shading, xM, yM, x1, y1, colors2, depth + 1);
1660 }
1661 }
1662
1663 void Gfx::doAxialShFill(GfxAxialShading *shading) {
1664 double xMin, yMin, xMax, yMax;
1665 double x0, y0, x1, y1;
1666 double dx, dy, mul;
1667 double tMin, tMax, t, tx, ty;
1668 double s[4], sMin, sMax, tmp;
1669 double ux0, uy0, ux1, uy1, vx0, vy0, vx1, vy1;
1670 double t0, t1, tt;
1671 double ta[axialMaxSplits + 1];
1672 int next[axialMaxSplits + 1];
1673 GfxColor color0, color1;
1674 int nComps;
1675 int i, j, k, kk;
1676
1677 // get the clip region bbox
1678 state->getUserClipBBox(&xMin, &yMin, &xMax, &yMax);
1679
1680 // compute min and max t values, based on the four corners of the
1681 // clip region bbox
1682 shading->getCoords(&x0, &y0, &x1, &y1);
1683 dx = x1 - x0;
1684 dy = y1 - y0;
1685 mul = 1 / (dx * dx + dy * dy);
1686 tMin = tMax = ((xMin - x0) * dx + (yMin - y0) * dy) * mul;
1687 t = ((xMin - x0) * dx + (yMax - y0) * dy) * mul;
1688 if (t < tMin) {
1689 tMin = t;
1690 } else if (t > tMax) {
1691 tMax = t;
1692 }
1693 t = ((xMax - x0) * dx + (yMin - y0) * dy) * mul;
1694 if (t < tMin) {
1695 tMin = t;
1696 } else if (t > tMax) {
1697 tMax = t;
1698 }
1699 t = ((xMax - x0) * dx + (yMax - y0) * dy) * mul;
1700 if (t < tMin) {
1701 tMin = t;
1702 } else if (t > tMax) {
1703 tMax = t;
1704 }
1705 if (tMin < 0 && !shading->getExtend0()) {
1706 tMin = 0;
1707 }
1708 if (tMax > 1 && !shading->getExtend1()) {
1709 tMax = 1;
1710 }
1711
1712 // get the function domain
1713 t0 = shading->getDomain0();
1714 t1 = shading->getDomain1();
1715
1716 // Traverse the t axis and do the shading.
1717 //
1718 // For each point (tx, ty) on the t axis, consider a line through
1719 // that point perpendicular to the t axis:
1720 //
1721 // x(s) = tx + s * -dy --> s = (x - tx) / -dy
1722 // y(s) = ty + s * dx --> s = (y - ty) / dx
1723 //
1724 // Then look at the intersection of this line with the bounding box
1725 // (xMin, yMin, xMax, yMax). In the general case, there are four
1726 // intersection points:
1727 //
1728 // s0 = (xMin - tx) / -dy
1729 // s1 = (xMax - tx) / -dy
1730 // s2 = (yMin - ty) / dx
1731 // s3 = (yMax - ty) / dx
1732 //
1733 // and we want the middle two s values.
1734 //
1735 // In the case where dx = 0, take s0 and s1; in the case where dy =
1736 // 0, take s2 and s3.
1737 //
1738 // Each filled polygon is bounded by two of these line segments
1739 // perpdendicular to the t axis.
1740 //
1741 // The t axis is bisected into smaller regions until the color
1742 // difference across a region is small enough, and then the region
1743 // is painted with a single color.
1744
1745 // set up: require at least one split to avoid problems when the two
1746 // ends of the t axis have the same color
1747 nComps = shading->getColorSpace()->getNComps();
1748 ta[0] = tMin;
1749 next[0] = axialMaxSplits / 2;
1750 ta[axialMaxSplits / 2] = 0.5 * (tMin + tMax);
1751 next[axialMaxSplits / 2] = axialMaxSplits;
1752 ta[axialMaxSplits] = tMax;
1753
1754 // compute the color at t = tMin
1755 if (tMin < 0) {
1756 tt = t0;
1757 } else if (tMin > 1) {
1758 tt = t1;
1759 } else {
1760 tt = t0 + (t1 - t0) * tMin;
1761 }
1762 shading->getColor(tt, &color0);
1763
1764 // compute the coordinates of the point on the t axis at t = tMin;
1765 // then compute the intersection of the perpendicular line with the
1766 // bounding box
1767 tx = x0 + tMin * dx;
1768 ty = y0 + tMin * dy;
1769 if (dx == 0 && dy == 0) {
1770 sMin = sMax = 0;
1771 } if (dx == 0) {
1772 sMin = (xMin - tx) / -dy;
1773 sMax = (xMax - tx) / -dy;
1774 if (sMin > sMax) { tmp = sMin; sMin = sMax; sMax = tmp; }
1775 } else if (dy == 0) {
1776 sMin = (yMin - ty) / dx;
1777 sMax = (yMax - ty) / dx;
1778 if (sMin > sMax) { tmp = sMin; sMin = sMax; sMax = tmp; }
1779 } else {
1780 s[0] = (yMin - ty) / dx;
1781 s[1] = (yMax - ty) / dx;
1782 s[2] = (xMin - tx) / -dy;
1783 s[3] = (xMax - tx) / -dy;
1784 for (j = 0; j < 3; ++j) {
1785 kk = j;
1786 for (k = j + 1; k < 4; ++k) {
1787 if (s[k] < s[kk]) {
1788 kk = k;
1789 }
1790 }
1791 tmp = s[j]; s[j] = s[kk]; s[kk] = tmp;
1792 }
1793 sMin = s[1];
1794 sMax = s[2];
1795 }
1796 ux0 = tx - sMin * dy;
1797 uy0 = ty + sMin * dx;
1798 vx0 = tx - sMax * dy;
1799 vy0 = ty + sMax * dx;
1800
1801 i = 0;
1802 while (i < axialMaxSplits) {
1803
1804 // bisect until color difference is small enough or we hit the
1805 // bisection limit
1806 j = next[i];
1807 while (j > i + 1) {
1808 if (ta[j] < 0) {
1809 tt = t0;
1810 } else if (ta[j] > 1) {
1811 tt = t1;
1812 } else {
1813 tt = t0 + (t1 - t0) * ta[j];
1814 }
1815 shading->getColor(tt, &color1);
1816 for (k = 0; k < nComps; ++k) {
1817 if (fabs(color1.c[k] - color0.c[k]) > axialColorDelta) {
1818 break;
1819 }
1820 }
1821 if (k == nComps) {
1822 break;
1823 }
1824 k = (i + j) / 2;
1825 ta[k] = 0.5 * (ta[i] + ta[j]);
1826 next[i] = k;
1827 next[k] = j;
1828 j = k;
1829 }
1830
1831 // use the average of the colors of the two sides of the region
1832 for (k = 0; k < nComps; ++k) {
1833 color0.c[k] = 0.5 * (color0.c[k] + color1.c[k]);
1834 }
1835
1836 // compute the coordinates of the point on the t axis; then
1837 // compute the intersection of the perpendicular line with the
1838 // bounding box
1839 tx = x0 + ta[j] * dx;
1840 ty = y0 + ta[j] * dy;
1841 if (dx == 0 && dy == 0) {
1842 sMin = sMax = 0;
1843 } if (dx == 0) {
1844 sMin = (xMin - tx) / -dy;
1845 sMax = (xMax - tx) / -dy;
1846 if (sMin > sMax) { tmp = sMin; sMin = sMax; sMax = tmp; }
1847 } else if (dy == 0) {
1848 sMin = (yMin - ty) / dx;
1849 sMax = (yMax - ty) / dx;
1850 if (sMin > sMax) { tmp = sMin; sMin = sMax; sMax = tmp; }
1851 } else {
1852 s[0] = (yMin - ty) / dx;
1853 s[1] = (yMax - ty) / dx;
1854 s[2] = (xMin - tx) / -dy;
1855 s[3] = (xMax - tx) / -dy;
1856 for (j = 0; j < 3; ++j) {
1857 kk = j;
1858 for (k = j + 1; k < 4; ++k) {
1859 if (s[k] < s[kk]) {
1860 kk = k;
1861 }
1862 }
1863 tmp = s[j]; s[j] = s[kk]; s[kk] = tmp;
1864 }
1865 sMin = s[1];
1866 sMax = s[2];
1867 }
1868 ux1 = tx - sMin * dy;
1869 uy1 = ty + sMin * dx;
1870 vx1 = tx - sMax * dy;
1871 vy1 = ty + sMax * dx;
1872
1873 // set the color
1874 state->setFillColor(&color0);
1875 out->updateFillColor(state);
1876
1877 // fill the region
1878 state->moveTo(ux0, uy0);
1879 state->lineTo(vx0, vy0);
1880 state->lineTo(vx1, vy1);
1881 state->lineTo(ux1, uy1);
1882 state->closePath();
1883 out->fill(state);
1884 state->clearPath();
1885
1886 // set up for next region
1887 ux0 = ux1;
1888 uy0 = uy1;
1889 vx0 = vx1;
1890 vy0 = vy1;
1891 color0 = color1;
1892 i = next[i];
1893 }
1894 }
1895
1896 void Gfx::doRadialShFill(GfxRadialShading *shading) {
1897 double sMin, sMax, xMin, yMin, xMax, yMax;
1898 double x0, y0, r0, x1, y1, r1, t0, t1;
1899 int nComps;
1900 GfxColor colorA, colorB;
1901 double xa, ya, xb, yb, ra, rb;
1902 double ta, tb, sa, sb;
1903 int ia, ib, k, n;
1904 double *ctm;
1905 double angle, t;
1906
1907 // get the shading info
1908 shading->getCoords(&x0, &y0, &r0, &x1, &y1, &r1);
1909 t0 = shading->getDomain0();
1910 t1 = shading->getDomain1();
1911 nComps = shading->getColorSpace()->getNComps();
1912
1913 // compute the (possibly extended) s range
1914 sMin = 0;
1915 sMax = 1;
1916 if (shading->getExtend0()) {
1917 if (r0 < r1) {
1918 // extend the smaller end
1919 sMin = -r0 / (r1 - r0);
1920 } else {
1921 // extend the larger end
1922 //~ this computes the diagonal of the bounding box -- we should
1923 //~ really compute the intersection of the moving/expanding
1924 //~ circles with each of the four corners and look for the max
1925 //~ radius
1926 state->getUserClipBBox(&xMin, &yMin, &xMax, &yMax);
1927 sMin = (sqrt((xMax - xMin) * (xMax - xMin) +
1928 (yMax - yMin) * (yMax - yMin)) - r0) / (r1 - r0);
1929 if (sMin > 0) {
1930 sMin = 0;
1931 } else if (sMin < -20) {
1932 // sanity check
1933 sMin = -20;
1934 }
1935 }
1936 }
1937 if (shading->getExtend1()) {
1938 if (r1 < r0) {
1939 // extend the smaller end
1940 sMax = -r0 / (r1 - r0);
1941 } else if (r1 > r0) {
1942 // extend the larger end
1943 state->getUserClipBBox(&xMin, &yMin, &xMax, &yMax);
1944 sMax = (sqrt((xMax - xMin) * (xMax - xMin) +
1945 (yMax - yMin) * (yMax - yMin)) - r0) / (r1 - r0);
1946 if (sMax < 1) {
1947 sMin = 1;
1948 } else if (sMax > 20) {
1949 // sanity check
1950 sMax = 20;
1951 }
1952 }
1953 }
1954
1955 // compute the number of steps into which circles must be divided to
1956 // achieve a curve flatness of 0.1 pixel in device space for the
1957 // largest circle (note that "device space" is 72 dpi when generating
1958 // PostScript, hence the relatively small 0.1 pixel accuracy)
1959 ctm = state->getCTM();
1960 t = fabs(ctm[0]);
1961 if (fabs(ctm[1]) > t) {
1962 t = fabs(ctm[1]);
1963 }
1964 if (fabs(ctm[2]) > t) {
1965 t = fabs(ctm[2]);
1966 }
1967 if (fabs(ctm[3]) > t) {
1968 t = fabs(ctm[3]);
1969 }
1970 if (r0 > r1) {
1971 t *= r0;
1972 } else {
1973 t *= r1;
1974 }
1975 if (t < 1) {
1976 n = 3;
1977 } else {
1978 n = (int)(M_PI / acos(1 - 0.1 / t));
1979 if (n < 3) {
1980 n = 3;
1981 } else if (n > 200) {
1982 n = 200;
1983 }
1984 }
1985
1986 // Traverse the t axis and do the shading.
1987 //
1988 // This generates and fills a series of rings. Each ring is defined
1989 // by two circles:
1990 // sa, ta, xa, ya, ra, colorA
1991 // sb, tb, xb, yb, rb, colorB
1992 //
1993 // The s/t axis is divided into radialMaxSplits parts; these parts
1994 // are combined as much as possible while respecting the
1995 // radialColorDelta parameter.
1996
1997 // setup for the start circle
1998 ia = 0;
1999 sa = sMin;
2000 ta = t0 + sa * (t1 - t0);
2001 xa = x0 + sa * (x1 - x0);
2002 ya = y0 + sa * (y1 - y0);
2003 ra = r0 + sa * (r1 - r0);
2004 if (ta < t0) {
2005 shading->getColor(t0, &colorA);
2006 } else if (ta > t1) {
2007 shading->getColor(t1, &colorA);
2008 } else {
2009 shading->getColor(ta, &colorA);
2010 }
2011
2012 while (ia < radialMaxSplits) {
2013
2014 // go as far along the t axis (toward t1) as we can, such that the
2015 // color difference is within the tolerance (radialColorDelta) --
2016 // this uses bisection (between the current value, t, and t1),
2017 // limited to radialMaxSplits points along the t axis; require at
2018 // least one split to avoid problems when the innermost and
2019 // outermost colors are the same
2020 ib = radialMaxSplits;
2021 sb = sMin + ((double)ib / (double)radialMaxSplits) * (sMax - sMin);
2022 tb = t0 + sb * (t1 - t0);
2023 if (tb < t0) {
2024 shading->getColor(t0, &colorB);
2025 } else if (tb > t1) {
2026 shading->getColor(t1, &colorB);
2027 } else {
2028 shading->getColor(tb, &colorB);
2029 }
2030 while (ib - ia > 1) {
2031 for (k = 0; k < nComps; ++k) {
2032 if (fabs(colorB.c[k] - colorA.c[k]) > radialColorDelta) {
2033 break;
2034 }
2035 }
2036 if (k == nComps && ib < radialMaxSplits) {
2037 break;
2038 }
2039 ib = (ia + ib) / 2;
2040 sb = sMin + ((double)ib / (double)radialMaxSplits) * (sMax - sMin);
2041 tb = t0 + sb * (t1 - t0);
2042 if (tb < t0) {
2043 shading->getColor(t0, &colorB);
2044 } else if (tb > t1) {
2045 shading->getColor(t1, &colorB);
2046 } else {
2047 shading->getColor(tb, &colorB);
2048 }
2049 }
2050
2051 // compute center and radius of the circle
2052 xb = x0 + sb * (x1 - x0);
2053 yb = y0 + sb * (y1 - y0);
2054 rb = r0 + sb * (r1 - r0);
2055
2056 // use the average of the colors at the two circles
2057 for (k = 0; k < nComps; ++k) {
2058 colorA.c[k] = 0.5 * (colorA.c[k] + colorB.c[k]);
2059 }
2060 state->setFillColor(&colorA);
2061 out->updateFillColor(state);
2062
2063 // construct path for first circle
2064 state->moveTo(xa + ra, ya);
2065 for (k = 1; k < n; ++k) {
2066 angle = ((double)k / (double)n) * 2 * M_PI;
2067 state->lineTo(xa + ra * cos(angle), ya + ra * sin(angle));
2068 }
2069 state->closePath();
2070
2071 // construct and append path for second circle
2072 state->moveTo(xb + rb, yb);
2073 for (k = 1; k < n; ++k) {
2074 angle = ((double)k / (double)n) * 2 * M_PI;
2075 state->lineTo(xb + rb * cos(angle), yb + rb * sin(angle));
2076 }
2077 state->closePath();
2078
2079 // fill the ring
2080 out->eoFill(state);
2081 state->clearPath();
2082
2083 // step to the next value of t
2084 ia = ib;
2085 sa = sb;
2086 ta = tb;
2087 xa = xb;
2088 ya = yb;
2089 ra = rb;
2090 colorA = colorB;
2091 }
2092 }
2093
2094 void Gfx::doEndPath() {
2095 if (state->isCurPt() && clip != clipNone) {
2096 state->clip();
2097 if (clip == clipNormal) {
2098 out->clip(state);
2099 } else {
2100 out->eoClip(state);
2101 }
2102 }
2103 clip = clipNone;
2104 state->clearPath();
2105 }
2106
2107 //------------------------------------------------------------------------
2108 // path clipping operators
2109 //------------------------------------------------------------------------
2110
2111 void Gfx::opClip(Object args[], int numArgs) {
2112 clip = clipNormal;
2113 }
2114
2115 void Gfx::opEOClip(Object args[], int numArgs) {
2116 clip = clipEO;
2117 }
2118
2119 //------------------------------------------------------------------------
2120 // text object operators
2121 //------------------------------------------------------------------------
2122
2123 void Gfx::opBeginText(Object args[], int numArgs) {
2124 state->setTextMat(1, 0, 0, 1, 0, 0);
2125 state->textMoveTo(0, 0);
2126 out->updateTextMat(state);
2127 out->updateTextPos(state);
2128 fontChanged = gTrue;
2129 }
2130
2131 void Gfx::opEndText(Object args[], int numArgs) {
2132 out->endTextObject(state);
2133 }
2134
2135 //------------------------------------------------------------------------
2136 // text state operators
2137 //------------------------------------------------------------------------
2138
2139 void Gfx::opSetCharSpacing(Object args[], int numArgs) {
2140 state->setCharSpace(args[0].getNum());
2141 out->updateCharSpace(state);
2142 }
2143
2144 void Gfx::opSetFont(Object args[], int numArgs) {
2145 GfxFont *font;
2146
2147 if (!(font = res->lookupFont(args[0].getName()))) {
2148 return;
2149 }
2150 if (printCommands) {
2151 printf(" font: tag=%s name='%s' %g\n",
2152 font->getTag()->getCString(),
2153 font->getName() ? font->getName()->getCString() : "???",
2154 args[1].getNum());
2155 fflush(stdout);
2156 }
2157 state->setFont(font, args[1].getNum());
2158 fontChanged = gTrue;
2159 }
2160
2161 void Gfx::opSetTextLeading(Object args[], int numArgs) {
2162 state->setLeading(args[0].getNum());
2163 }
2164
2165 void Gfx::opSetTextRender(Object args[], int numArgs) {
2166 state->setRender(args[0].getInt());
2167 out->updateRender(state);
2168 }
2169
2170 void Gfx::opSetTextRise(Object args[], int numArgs) {
2171 state->setRise(args[0].getNum());
2172 out->updateRise(state);
2173 }
2174
2175 void Gfx::opSetWordSpacing(Object args[], int numArgs) {
2176 state->setWordSpace(args[0].getNum());
2177 out->updateWordSpace(state);
2178 }
2179
2180 void Gfx::opSetHorizScaling(Object args[], int numArgs) {
2181 state->setHorizScaling(args[0].getNum());
2182 out->updateHorizScaling(state);
2183 fontChanged = gTrue;
2184 }
2185
2186 //------------------------------------------------------------------------
2187 // text positioning operators
2188 //------------------------------------------------------------------------
2189
2190 void Gfx::opTextMove(Object args[], int numArgs) {
2191 double tx, ty;
2192
2193 tx = state->getLineX() + args[0].getNum();
2194 ty = state->getLineY() + args[1].getNum();
2195 state->textMoveTo(tx, ty);
2196 out->updateTextPos(state);
2197 }
2198
2199 void Gfx::opTextMoveSet(Object args[], int numArgs) {
2200 double tx, ty;
2201
2202 tx = state->getLineX() + args[0].getNum();
2203 ty = args[1].getNum();
2204 state->setLeading(-ty);
2205 ty += state->getLineY();
2206 state->textMoveTo(tx, ty);
2207 out->updateTextPos(state);
2208 }
2209
2210 void Gfx::opSetTextMatrix(Object args[], int numArgs) {
2211 state->setTextMat(args[0].getNum(), args[1].getNum(),
2212 args[2].getNum(), args[3].getNum(),
2213 args[4].getNum(), args[5].getNum());
2214 state->textMoveTo(0, 0);
2215 out->updateTextMat(state);
2216 out->updateTextPos(state);
2217 fontChanged = gTrue;
2218 }
2219
2220 void Gfx::opTextNextLine(Object args[], int numArgs) {
2221 double tx, ty;
2222
2223 tx = state->getLineX();
2224 ty = state->getLineY() - state->getLeading();
2225 state->textMoveTo(tx, ty);
2226 out->updateTextPos(state);
2227 }
2228
2229 //------------------------------------------------------------------------
2230 // text string operators
2231 //------------------------------------------------------------------------
2232
2233 void Gfx::opShowText(Object args[], int numArgs) {
2234 if (!state->getFont()) {
2235 error(getPos(), "No font in show");
2236 return;
2237 }
2238 doShowText(args[0].getString());
2239 }
2240
2241 void Gfx::opMoveShowText(Object args[], int numArgs) {
2242 double tx, ty;
2243
2244 if (!state->getFont()) {
2245 error(getPos(), "No font in move/show");
2246 return;
2247 }
2248 tx = state->getLineX();
2249 ty = state->getLineY() - state->getLeading();
2250 state->textMoveTo(tx, ty);
2251 out->updateTextPos(state);
2252 doShowText(args[0].getString());
2253 }
2254
2255 void Gfx::opMoveSetShowText(Object args[], int numArgs) {
2256 double tx, ty;
2257
2258 if (!state->getFont()) {
2259 error(getPos(), "No font in move/set/show");
2260 return;
2261 }
2262 state->setWordSpace(args[0].getNum());
2263 state->setCharSpace(args[1].getNum());
2264 tx = state->getLineX();
2265 ty = state->getLineY() - state->getLeading();
2266 state->textMoveTo(tx, ty);
2267 out->updateWordSpace(state);
2268 out->updateCharSpace(state);
2269 out->updateTextPos(state);
2270 doShowText(args[2].getString());
2271 }
2272
2273 void Gfx::opShowSpaceText(Object args[], int numArgs) {
2274 Array *a;
2275 Object obj;
2276 int wMode;
2277 int i;
2278
2279 if (!state->getFont()) {
2280 error(getPos(), "No font in show/space");
2281 return;
2282 }
2283 wMode = state->getFont()->getWMode();
2284 a = args[0].getArray();
2285 for (i = 0; i < a->getLength(); ++i) {
2286 a->get(i, &obj);
2287 if (obj.isNum()) {
2288 if (wMode) {
2289 state->textShift(0, -obj.getNum() * 0.001 * state->getFontSize());
2290 } else {
2291 state->textShift(-obj.getNum() * 0.001 * state->getFontSize(), 0);
2292 }
2293 out->updateTextShift(state, obj.getNum());
2294 } else if (obj.isString()) {
2295 doShowText(obj.getString());
2296 } else {
2297 error(getPos(), "Element of show/space array must be number or string");
2298 }
2299 obj.free();
2300 }
2301 }
2302
2303 void Gfx::doShowText(GString *s) {
2304 GfxFont *font;
2305 int wMode;
2306 double riseX, riseY;
2307 CharCode code;
2308 Unicode u[8];
2309 double x, y, dx, dy, dx2, dy2, curX, curY, tdx, tdy, lineX, lineY;
2310 double originX, originY, tOriginX, tOriginY;
2311 double oldCTM[6], newCTM[6];
2312 double *mat;
2313 Object charProc;
2314 Dict *resDict;
2315 Parser *oldParser;
2316 char *p;
2317 int len, n, uLen, nChars, nSpaces, i;
2318
2319 if (fontChanged) {
2320 out->updateFont(state);
2321 fontChanged = gFalse;
2322 }
2323 font = state->getFont();
2324 wMode = font->getWMode();
2325
2326 if (out->useDrawChar()) {
2327 out->beginString(state, s);
2328 }
2329
2330 // handle a Type 3 char
2331 if (font->getType() == fontType3 && out->interpretType3Chars()) {
2332 mat = state->getCTM();
2333 for (i = 0; i < 6; ++i) {
2334 oldCTM[i] = mat[i];
2335 }
2336 mat = state->getTextMat();
2337 newCTM[0] = mat[0] * oldCTM[0] + mat[1] * oldCTM[2];
2338 newCTM[1] = mat[0] * oldCTM[1] + mat[1] * oldCTM[3];
2339 newCTM[2] = mat[2] * oldCTM[0] + mat[3] * oldCTM[2];
2340 newCTM[3] = mat[2] * oldCTM[1] + mat[3] * oldCTM[3];
2341 mat = font->getFontMatrix();
2342 newCTM[0] = mat[0] * newCTM[0] + mat[1] * newCTM[2];
2343 newCTM[1] = mat[0] * newCTM[1] + mat[1] * newCTM[3];
2344 newCTM[2] = mat[2] * newCTM[0] + mat[3] * newCTM[2];
2345 newCTM[3] = mat[2] * newCTM[1] + mat[3] * newCTM[3];
2346 newCTM[0] *= state->getFontSize();
2347 newCTM[1] *= state->getFontSize();
2348 newCTM[2] *= state->getFontSize();
2349 newCTM[3] *= state->getFontSize();
2350 newCTM[0] *= state->getHorizScaling();
2351 newCTM[2] *= state->getHorizScaling();
2352 state->textTransformDelta(0, state->getRise(), &riseX, &riseY);
2353 curX = state->getCurX();
2354 curY = state->getCurY();
2355 lineX = state->getLineX();
2356 lineY = state->getLineY();
2357 oldParser = parser;
2358 p = s->getCString();
2359 len = s->getLength();
2360 while (len > 0) {
2361 n = font->getNextChar(p, len, &code,
2362 u, (int)(sizeof(u) / sizeof(Unicode)), &uLen,
2363 &dx, &dy, &originX, &originY);
2364 dx = dx * state->getFontSize() + state->getCharSpace();
2365 if (n == 1 && *p == ' ') {
2366 dx += state->getWordSpace();
2367 }
2368 dx *= state->getHorizScaling();
2369 dy *= state->getFontSize();
2370 state->textTransformDelta(dx, dy, &tdx, &tdy);
2371 state->transform(curX + riseX, curY + riseY, &x, &y);
2372 saveState();
2373 state->setCTM(newCTM[0], newCTM[1], newCTM[2], newCTM[3], x, y);
2374 //~ out->updateCTM(???)
2375 if (!out->beginType3Char(state, curX + riseX, curY + riseY, tdx, tdy,
2376 code, u, uLen)) {
2377 ((Gfx8BitFont *)font)->getCharProc(code, &charProc);
2378 if ((resDict = ((Gfx8BitFont *)font)->getResources())) {
2379 pushResources(resDict);
2380 }
2381 if (charProc.isStream()) {
2382 display(&charProc, gFalse);
2383 } else {
2384 error(getPos(), "Missing or bad Type3 CharProc entry");
2385 }
2386 out->endType3Char(state);
2387 if (resDict) {
2388 popResources();
2389 }
2390 charProc.free();
2391 }
2392 restoreState();
2393 // GfxState::restore() does *not* restore the current position,
2394 // so we deal with it here using (curX, curY) and (lineX, lineY)
2395 curX += tdx;
2396 curY += tdy;
2397 state->moveTo(curX, curY);
2398 state->textSetPos(lineX, lineY);
2399 p += n;
2400 len -= n;
2401 }
2402 parser = oldParser;
2403
2404 } else if (out->useDrawChar()) {
2405 state->textTransformDelta(0, state->getRise(), &riseX, &riseY);
2406 p = s->getCString();
2407 len = s->getLength();
2408 while (len > 0) {
2409 n = font->getNextChar(p, len, &code,
2410 u, (int)(sizeof(u) / sizeof(Unicode)), &uLen,
2411 &dx, &dy, &originX, &originY);
2412 if (wMode) {
2413 dx *= state->getFontSize();
2414 dy = dy * state->getFontSize() + state->getCharSpace();
2415 if (n == 1 && *p == ' ') {
2416 dy += state->getWordSpace();
2417 }
2418 } else {
2419 dx = dx * state->getFontSize() + state->getCharSpace();
2420 if (n == 1 && *p == ' ') {
2421 dx += state->getWordSpace();
2422 }
2423 dx *= state->getHorizScaling();
2424 dy *= state->getFontSize();
2425 }
2426 state->textTransformDelta(dx, dy, &tdx, &tdy);
2427 originX *= state->getFontSize();
2428 originY *= state->getFontSize();
2429 state->textTransformDelta(originX, originY, &tOriginX, &tOriginY);
2430 out->drawChar(state, state->getCurX() + riseX, state->getCurY() + riseY,
2431 tdx, tdy, tOriginX, tOriginY, code, u, uLen);
2432 state->shift(tdx, tdy);
2433 p += n;
2434 len -= n;
2435 }
2436
2437 } else {
2438 dx = dy = 0;
2439 p = s->getCString();
2440 len = s->getLength();
2441 nChars = nSpaces = 0;
2442 while (len > 0) {
2443 n = font->getNextChar(p, len, &code,
2444 u, (int)(sizeof(u) / sizeof(Unicode)), &uLen,
2445 &dx2, &dy2, &originX, &originY);
2446 dx += dx2;
2447 dy += dy2;
2448 if (n == 1 && *p == ' ') {
2449 ++nSpaces;
2450 }
2451 ++nChars;
2452 p += n;
2453 len -= n;
2454 }
2455 if (wMode) {
2456 dx *= state->getFontSize();
2457 dy = dy * state->getFontSize()
2458 + nChars * state->getCharSpace()
2459 + nSpaces * state->getWordSpace();
2460 } else {
2461 dx = dx * state->getFontSize()
2462 + nChars * state->getCharSpace()
2463 + nSpaces * state->getWordSpace();
2464 dx *= state->getHorizScaling();
2465 dy *= state->getFontSize();
2466 }
2467 state->textTransformDelta(dx, dy, &tdx, &tdy);
2468 out->drawString(state, s);
2469 state->shift(tdx, tdy);
2470 }
2471
2472 if (out->useDrawChar()) {
2473 out->endString(state);
2474 }
2475
2476 updateLevel += 10 * s->getLength();
2477 }
2478
2479 //------------------------------------------------------------------------
2480 // XObject operators
2481 //------------------------------------------------------------------------
2482
2483 void Gfx::opXObject(Object args[], int numArgs) {
2484 Object obj1, obj2, obj3, refObj;
2485 #if OPI_SUPPORT
2486 Object opiDict;
2487 #endif
2488
2489 if (!res->lookupXObject(args[0].getName(), &obj1)) {
2490 return;
2491 }
2492 if (!obj1.isStream()) {
2493 error(getPos(), "XObject '%s' is wrong type", args[0].getName());
2494 obj1.free();
2495 return;
2496 }
2497 #if OPI_SUPPORT
2498 obj1.streamGetDict()->lookup("OPI", &opiDict);
2499 if (opiDict.isDict()) {
2500 out->opiBegin(state, opiDict.getDict());
2501 }
2502 #endif
2503 obj1.streamGetDict()->lookup("Subtype", &obj2);
2504 if (obj2.isName("Image")) {
2505 res->lookupXObjectNF(args[0].getName(), &refObj);
2506 doImage(&refObj, obj1.getStream(), gFalse);
2507 refObj.free();
2508 } else if (obj2.isName("Form")) {
2509 doForm(&obj1);
2510 } else if (obj2.isName("PS")) {
2511 obj1.streamGetDict()->lookup("Level1", &obj3);
2512 out->psXObject(obj1.getStream(),
2513 obj3.isStream() ? obj3.getStream() : (Stream *)NULL);
2514 } else if (obj2.isName()) {
2515 error(getPos(), "Unknown XObject subtype '%s'", obj2.getName());
2516 } else {
2517 error(getPos(), "XObject subtype is missing or wrong type");
2518 }
2519 obj2.free();
2520 #if OPI_SUPPORT
2521 if (opiDict.isDict()) {
2522 out->opiEnd(state, opiDict.getDict());
2523 }
2524 opiDict.free();
2525 #endif
2526 obj1.free();
2527 }
2528
2529 void Gfx::doImage(Object *ref, Stream *str, GBool inlineImg) {
2530 Dict *dict;
2531 int width, height;
2532 int bits;
2533 GBool mask;
2534 GBool invert;
2535 GfxColorSpace *colorSpace;
2536 GfxImageColorMap *colorMap;
2537 Object maskObj;
2538 GBool haveMask;
2539 int maskColors[2*gfxColorMaxComps];
2540 Object obj1, obj2;
2541 int i;
2542
2543 // get stream dict
2544 dict = str->getDict();
2545
2546 // get size
2547 dict->lookup("Width", &obj1);
2548 if (obj1.isNull()) {
2549 obj1.free();
2550 dict->lookup("W", &obj1);
2551 }
2552 if (!obj1.isInt())
2553 goto err2;
2554 width = obj1.getInt();
2555 obj1.free();
2556 dict->lookup("Height", &obj1);
2557 if (obj1.isNull()) {
2558 obj1.free();
2559 dict->lookup("H", &obj1);
2560 }
2561 if (!obj1.isInt())
2562 goto err2;
2563 height = obj1.getInt();
2564 obj1.free();
2565
2566 // image or mask?
2567 dict->lookup("ImageMask", &obj1);
2568 if (obj1.isNull()) {
2569 obj1.free();
2570 dict->lookup("IM", &obj1);
2571 }
2572 mask = gFalse;
2573 if (obj1.isBool())
2574 mask = obj1.getBool();
2575 else if (!obj1.isNull())
2576 goto err2;
2577 obj1.free();
2578
2579 // bit depth
2580 dict->lookup("BitsPerComponent", &obj1);
2581 if (obj1.isNull()) {
2582 obj1.free();
2583 dict->lookup("BPC", &obj1);
2584 }
2585 if (obj1.isInt()) {
2586 bits = obj1.getInt();
2587 } else if (mask) {
2588 bits = 1;
2589 } else {
2590 goto err2;
2591 }
2592 obj1.free();
2593
2594 // display a mask
2595 if (mask) {
2596
2597 // check for inverted mask
2598 if (bits != 1)
2599 goto err1;
2600 invert = gFalse;
2601 dict->lookup("Decode", &obj1);
2602 if (obj1.isNull()) {
2603 obj1.free();
2604 dict->lookup("D", &obj1);
2605 }
2606 if (obj1.isArray()) {
2607 obj1.arrayGet(0, &obj2);
2608 if (obj2.isInt() && obj2.getInt() == 1)
2609 invert = gTrue;
2610 obj2.free();
2611 } else if (!obj1.isNull()) {
2612 goto err2;
2613 }
2614 obj1.free();
2615
2616 // draw it
2617 out->drawImageMask(state, ref, str, width, height, invert, inlineImg);
2618
2619 } else {
2620
2621 // get color space and color map
2622 dict->lookup("ColorSpace", &obj1);
2623 if (obj1.isNull()) {
2624 obj1.free();
2625 dict->lookup("CS", &obj1);
2626 }
2627 if (obj1.isName()) {
2628 res->lookupColorSpace(obj1.getName(), &obj2);
2629 if (!obj2.isNull()) {
2630 obj1.free();
2631 obj1 = obj2;
2632 } else {
2633 obj2.free();
2634 }
2635 }
2636 colorSpace = GfxColorSpace::parse(&obj1);
2637 obj1.free();
2638 if (!colorSpace) {
2639 goto err1;
2640 }
2641 dict->lookup("Decode", &obj1);
2642 if (obj1.isNull()) {
2643 obj1.free();
2644 dict->lookup("D", &obj1);
2645 }
2646 colorMap = new GfxImageColorMap(bits, &obj1, colorSpace);
2647 obj1.free();
2648 if (!colorMap->isOk()) {
2649 delete colorMap;
2650 goto err1;
2651 }
2652
2653 // get the mask
2654 haveMask = gFalse;
2655 dict->lookup("Mask", &maskObj);
2656 if (maskObj.isArray()) {
2657 for (i = 0; i < maskObj.arrayGetLength(); ++i) {
2658 maskObj.arrayGet(i, &obj1);
2659 maskColors[i] = obj1.getInt();
2660 obj1.free();
2661 }
2662 haveMask = gTrue;
2663 }
2664
2665 // draw it
2666 out->drawImage(state, ref, str, width, height, colorMap,
2667 haveMask ? maskColors : (int *)NULL, inlineImg);
2668 delete colorMap;
2669
2670 maskObj.free();
2671 }
2672
2673 if ((i = width * height) > 1000) {
2674 i = 1000;
2675 }
2676 updateLevel += i;
2677
2678 return;
2679
2680 err2:
2681 obj1.free();
2682 err1:
2683 error(getPos(), "Bad image parameters");
2684 }
2685
2686 void Gfx::doForm(Object *str) {
2687 Dict *dict;
2688 Object matrixObj, bboxObj;
2689 double m[6], bbox[6];
2690 Object resObj;
2691 Dict *resDict;
2692 Object obj1;
2693 int i;
2694
2695 // check for excessive recursion
2696 if (formDepth > 20) {
2697 return;
2698 }
2699
2700 // get stream dict
2701 dict = str->streamGetDict();
2702
2703 // check form type
2704 dict->lookup("FormType", &obj1);
2705 if (!(obj1.isInt() && obj1.getInt() == 1)) {
2706 error(getPos(), "Unknown form type");
2707 }
2708 obj1.free();
2709
2710 // get bounding box
2711 dict->lookup("BBox", &bboxObj);
2712 if (!bboxObj.isArray()) {
2713 matrixObj.free();
2714 bboxObj.free();
2715 error(getPos(), "Bad form bounding box");
2716 return;
2717 }
2718 for (i = 0; i < 4; ++i) {
2719 bboxObj.arrayGet(i, &obj1);
2720 bbox[i] = obj1.getNum();
2721 obj1.free();
2722 }
2723 bboxObj.free();
2724
2725 // get matrix
2726 dict->lookup("Matrix", &matrixObj);
2727 if (matrixObj.isArray()) {
2728 for (i = 0; i < 6; ++i) {
2729 matrixObj.arrayGet(i, &obj1);
2730 m[i] = obj1.getNum();
2731 obj1.free();
2732 }
2733 } else {
2734 m[0] = 1; m[1] = 0;
2735 m[2] = 0; m[3] = 1;
2736 m[4] = 0; m[5] = 0;
2737 }
2738 matrixObj.free();
2739
2740 // get resources
2741 dict->lookup("Resources", &resObj);
2742 resDict = resObj.isDict() ? resObj.getDict() : (Dict *)NULL;
2743
2744 // draw it
2745 ++formDepth;
2746 doForm1(str, resDict, m, bbox);
2747 --formDepth;
2748
2749 resObj.free();
2750 }
2751
2752 void Gfx::doAnnot(Object *str, double xMin, double yMin,
2753 double xMax, double yMax) {
2754 Dict *dict, *resDict;
2755 Object matrixObj, bboxObj, resObj;
2756 Object obj1;
2757 double m[6], bbox[6], ictm[6];
2758 double *ctm;
2759 double formX0, formY0, formX1, formY1;
2760 double annotX0, annotY0, annotX1, annotY1;
2761 double det, x, y, sx, sy;
2762 int i;
2763
2764 // get stream dict
2765 dict = str->streamGetDict();
2766
2767 // get the form bounding box
2768 dict->lookup("BBox", &bboxObj);
2769 if (!bboxObj.isArray()) {
2770 bboxObj.free();
2771 error(getPos(), "Bad form bounding box");
2772 return;
2773 }
2774 for (i = 0; i < 4; ++i) {
2775 bboxObj.arrayGet(i, &obj1);
2776 bbox[i] = obj1.getNum();
2777 obj1.free();
2778 }
2779 bboxObj.free();
2780
2781 // get the form matrix
2782 dict->lookup("Matrix", &matrixObj);
2783 if (matrixObj.isArray()) {
2784 for (i = 0; i < 6; ++i) {
2785 matrixObj.arrayGet(i, &obj1);
2786 m[i] = obj1.getNum();
2787 obj1.free();
2788 }
2789 } else {
2790 m[0] = 1; m[1] = 0;
2791 m[2] = 0; m[3] = 1;
2792 m[4] = 0; m[5] = 0;
2793 }
2794 matrixObj.free();
2795
2796 // transform the form bbox from form space to user space
2797 formX0 = bbox[0] * m[0] + bbox[1] * m[2] + m[4];
2798 formY0 = bbox[0] * m[1] + bbox[1] * m[3] + m[5];
2799 formX1 = bbox[2] * m[0] + bbox[3] * m[2] + m[4];
2800 formY1 = bbox[2] * m[1] + bbox[3] * m[3] + m[5];
2801
2802 // transform the annotation bbox from default user space to user
2803 // space: (bbox * baseMatrix) * iCTM
2804 ctm = state->getCTM();
2805 det = 1 / (ctm[0] * ctm[3] - ctm[1] * ctm[2]);
2806 ictm[0] = ctm[3] * det;
2807 ictm[1] = -ctm[1] * det;
2808 ictm[2] = -ctm[2] * det;
2809 ictm[3] = ctm[0] * det;
2810 ictm[4] = (ctm[2] * ctm[5] - ctm[3] * ctm[4]) * det;
2811 ictm[5] = (ctm[1] * ctm[4] - ctm[0] * ctm[5]) * det;
2812 x = baseMatrix[0] * xMin + baseMatrix[2] * yMin + baseMatrix[4];
2813 y = baseMatrix[1] * xMin + baseMatrix[3] * yMin + baseMatrix[5];
2814 annotX0 = ictm[0] * x + ictm[2] * y + ictm[4];
2815 annotY0 = ictm[1] * x + ictm[3] * y + ictm[5];
2816 x = baseMatrix[0] * xMax + baseMatrix[2] * yMax + baseMatrix[4];
2817 y = baseMatrix[1] * xMax + baseMatrix[3] * yMax + baseMatrix[5];
2818 annotX1 = ictm[0] * x + ictm[2] * y + ictm[4];
2819 annotY1 = ictm[1] * x + ictm[3] * y + ictm[5];
2820
2821 // swap min/max coords
2822 if (formX0 > formX1) {
2823 x = formX0; formX0 = formX1; formX1 = x;
2824 }
2825 if (formY0 > formY1) {
2826 y = formY0; formY0 = formY1; formY1 = y;
2827 }
2828 if (annotX0 > annotX1) {
2829 x = annotX0; annotX0 = annotX1; annotX1 = x;
2830 }
2831 if (annotY0 > annotY1) {
2832 y = annotY0; annotY0 = annotY1; annotY1 = y;
2833 }
2834
2835 // scale the form to fit the annotation bbox
2836 if (formX1 == formX0) {
2837 // this shouldn't happen
2838 sx = 1;
2839 } else {
2840 sx = (annotX1 - annotX0) / (formX1 - formX0);
2841 }
2842 if (formY1 == formY0) {
2843 // this shouldn't happen
2844 sy = 1;
2845 } else {
2846 sy = (annotY1 - annotY0) / (formY1 - formY0);
2847 }
2848 m[0] *= sx;
2849 m[2] *= sx;
2850 m[4] = (m[4] - formX0) * sx + annotX0;
2851 m[1] *= sy;
2852 m[3] *= sy;
2853 m[5] = (m[5] - formY0) * sy + annotY0;
2854
2855 // get resources
2856 dict->lookup("Resources", &resObj);
2857 resDict = resObj.isDict() ? resObj.getDict() : (Dict *)NULL;
2858
2859 // draw it
2860 doForm1(str, resDict, m, bbox);
2861
2862 resObj.free();
2863 bboxObj.free();
2864 }
2865
2866 void Gfx::doForm1(Object *str, Dict *resDict, double *matrix, double *bbox) {
2867 Parser *oldParser;
2868 double oldBaseMatrix[6];
2869 int i;
2870
2871 // push new resources on stack
2872 pushResources(resDict);
2873
2874 // save current graphics state
2875 saveState();
2876
2877 // kill any pre-existing path
2878 state->clearPath();
2879
2880 // save current parser
2881 oldParser = parser;
2882
2883 // set form transformation matrix
2884 state->concatCTM(matrix[0], matrix[1], matrix[2],
2885 matrix[3], matrix[4], matrix[5]);
2886 out->updateCTM(state, matrix[0], matrix[1], matrix[2],
2887 matrix[3], matrix[4], matrix[5]);
2888
2889 // set new base matrix
2890 for (i = 0; i < 6; ++i) {
2891 oldBaseMatrix[i] = baseMatrix[i];
2892 baseMatrix[i] = state->getCTM()[i];
2893 }
2894
2895 // set form bounding box
2896 state->moveTo(bbox[0], bbox[1]);
2897 state->lineTo(bbox[2], bbox[1]);
2898 state->lineTo(bbox[2], bbox[3]);
2899 state->lineTo(bbox[0], bbox[3]);
2900 state->closePath();
2901 state->clip();
2902 out->clip(state);
2903 state->clearPath();
2904
2905 // draw the form
2906 display(str, gFalse);
2907
2908 // restore base matrix
2909 for (i = 0; i < 6; ++i) {
2910 baseMatrix[i] = oldBaseMatrix[i];
2911 }
2912
2913 // restore parser
2914 parser = oldParser;
2915
2916 // restore graphics state
2917 restoreState();
2918
2919 // pop resource stack
2920 popResources();
2921
2922 return;
2923 }
2924
2925 //------------------------------------------------------------------------
2926 // in-line image operators
2927 //------------------------------------------------------------------------
2928
2929 void Gfx::opBeginImage(Object args[], int numArgs) {
2930 Stream *str;
2931 int c1, c2;
2932
2933 // build dict/stream
2934 str = buildImageStream();
2935
2936 // display the image
2937 if (str) {
2938 doImage(NULL, str, gTrue);
2939
2940 // skip 'EI' tag
2941 c1 = str->getBaseStream()->getChar();
2942 c2 = str->getBaseStream()->getChar();
2943 while (!(c1 == 'E' && c2 == 'I') && c2 != EOF) {
2944 c1 = c2;
2945 c2 = str->getBaseStream()->getChar();
2946 }
2947 delete str;
2948 }
2949 }
2950
2951 Stream *Gfx::buildImageStream() {
2952 Object dict;
2953 Object obj;
2954 char *key;
2955 Stream *str;
2956
2957 // build dictionary
2958 dict.initDict(xref);
2959 parser->getObj(&obj);
2960 while (!obj.isCmd("ID") && !obj.isEOF()) {
2961 if (!obj.isName()) {
2962 error(getPos(), "Inline image dictionary key must be a name object");
2963 obj.free();
2964 } else {
2965 key = copyString(obj.getName());
2966 obj.free();
2967 parser->getObj(&obj);
2968 if (obj.isEOF() || obj.isError()) {
2969 gfree(key);
2970 break;
2971 }
2972 dict.dictAdd(key, &obj);
2973 }
2974 parser->getObj(&obj);
2975 }
2976 if (obj.isEOF()) {
2977 error(getPos(), "End of file in inline image");
2978 obj.free();
2979 dict.free();
2980 return NULL;
2981 }
2982 obj.free();
2983
2984 // make stream
2985 str = new EmbedStream(parser->getStream(), &dict, gFalse, 0);
2986 str = str->addFilters(&dict);
2987
2988 return str;
2989 }
2990
2991 void Gfx::opImageData(Object args[], int numArgs) {
2992 error(getPos(), "Internal: got 'ID' operator");
2993 }
2994
2995 void Gfx::opEndImage(Object args[], int numArgs) {
2996 error(getPos(), "Internal: got 'EI' operator");
2997 }
2998
2999 //------------------------------------------------------------------------
3000 // type 3 font operators
3001 //------------------------------------------------------------------------
3002
3003 void Gfx::opSetCharWidth(Object args[], int numArgs) {
3004 out->type3D0(state, args[0].getNum(), args[1].getNum());
3005 }
3006
3007 void Gfx::opSetCacheDevice(Object args[], int numArgs) {
3008 out->type3D1(state, args[0].getNum(), args[1].getNum(),
3009 args[2].getNum(), args[3].getNum(),
3010 args[4].getNum(), args[5].getNum());
3011 }
3012
3013 //------------------------------------------------------------------------
3014 // compatibility operators
3015 //------------------------------------------------------------------------
3016
3017 void Gfx::opBeginIgnoreUndef(Object args[], int numArgs) {
3018 ++ignoreUndef;
3019 }
3020
3021 void Gfx::opEndIgnoreUndef(Object args[], int numArgs) {
3022 if (ignoreUndef > 0)
3023 --ignoreUndef;
3024 }
3025
3026 //------------------------------------------------------------------------
3027 // marked content operators
3028 //------------------------------------------------------------------------
3029
3030 void Gfx::opBeginMarkedContent(Object args[], int numArgs) {
3031 if (printCommands) {
3032 printf(" marked content: %s ", args[0].getName());
3033 if (numArgs == 2)
3034 args[2].print(stdout);
3035 printf("\n");
3036 fflush(stdout);
3037 }
3038 }
3039
3040 void Gfx::opEndMarkedContent(Object args[], int numArgs) {
3041 }
3042
3043 void Gfx::opMarkPoint(Object args[], int numArgs) {
3044 if (printCommands) {
3045 printf(" mark point: %s ", args[0].getName());
3046 if (numArgs == 2)
3047 args[2].print(stdout);
3048 printf("\n");
3049 fflush(stdout);
3050 }
3051 }
3052
3053 //------------------------------------------------------------------------
3054 // misc
3055 //------------------------------------------------------------------------
3056
3057 void Gfx::saveState() {
3058 out->saveState(state);
3059 state = state->save();
3060 }
3061
3062 void Gfx::restoreState() {
3063 state = state->restore();
3064 out->restoreState(state);
3065 }
3066
3067 void Gfx::pushResources(Dict *resDict) {
3068 res = new GfxResources(xref, resDict, res);
3069 }
3070
3071 void Gfx::popResources() {
3072 GfxResources *resPtr;
3073
3074 resPtr = res->getNext();
3075 delete res;
3076 res = resPtr;
3077 }
SWFTools is a collection of utilities for working with Adobe Flash files