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