aca8d7cdf8b637ed120a0ff2eff0d5b87a94ebd2
[swftools.git] / pdf2swf / SWFOutputDev.cc
1 /* pdfswf.cc
2    implements a pdf output device (OutputDev).
3
4    This file is part of swftools.
5
6    Swftools is free software; you can redistribute it and/or modify
7    it under the terms of the GNU General Public License as published by
8    the Free Software Foundation; either version 2 of the License, or
9    (at your option) any later version.
10
11    Swftools is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU General Public License for more details.
15
16    You should have received a copy of the GNU General Public License
17    along with swftools; if not, write to the Free Software
18    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
19
20 #include <stdio.h>
21 #include <stdlib.h>
22 #include <stddef.h>
23 #include <string.h>
24 #include <unistd.h>
25 #include "../config.h"
26 #ifdef HAVE_DIRENT_H
27 #include <dirent.h>
28 #endif
29 #ifdef HAVE_SYS_STAT_H
30 #include <sys/stat.h>
31 #endif
32 #ifdef HAVE_FONTCONFIG_H
33 #include <fontconfig.h>
34 #endif
35 //xpdf header files
36 #include "config.h"
37 #include "gfile.h"
38 #include "GString.h"
39 #include "gmem.h"
40 #include "Object.h"
41 #include "Stream.h"
42 #include "Array.h"
43 #include "Dict.h"
44 #include "XRef.h"
45 #include "Catalog.h"
46 #include "Page.h"
47 #include "PDFDoc.h"
48 #include "Error.h"
49 #include "OutputDev.h"
50 #include "GfxState.h"
51 #include "GfxFont.h"
52 #include "CharCodeToUnicode.h"
53 #include "NameToUnicodeTable.h"
54 #include "GlobalParams.h"
55 //#define XPDF_101
56 #ifdef XPDF_101
57 #include "FontFile.h"
58 #else
59 #include "FoFiType1C.h"
60 #include "FoFiTrueType.h"
61 #endif
62 #include "SWFOutputDev.h"
63
64 //swftools header files
65 #include "swfoutput.h"
66 #include "../lib/log.h"
67 #include "../lib/gfxdevice.h"
68 #include "gfxtools.h"
69
70 #include <math.h>
71
72 typedef struct _fontfile
73 {
74     char*filename;
75     int used;
76 } fontfile_t;
77
78 // for pdfswf_addfont
79 static fontfile_t fonts[2048];
80 static int fontnum = 0;
81
82 static int config_use_fontconfig = 1;
83
84 // swf <-> pdf pages
85 // TODO: move into pdf_doc_t
86 static int*pages = 0;
87 static int pagebuflen = 0;
88 static int pagepos = 0;
89
90 /* config */
91 static double caplinewidth = 3.0;
92 static int zoom = 72; /* xpdf: 86 */
93 static int forceType0Fonts = 0;
94
95 static void printInfoString(Dict *infoDict, char *key, char *fmt);
96 static void printInfoDate(Dict *infoDict, char *key, char *fmt);
97
98 struct mapping {
99     char*pdffont;
100     char*filename;
101 } pdf2t1map[] ={
102 {"Times-Roman",           "n021003l"},
103 {"Times-Italic",          "n021023l"},
104 {"Times-Bold",            "n021004l"},
105 {"Times-BoldItalic",      "n021024l"},
106 {"Helvetica",             "n019003l"},
107 {"Helvetica-Oblique",     "n019023l"},
108 {"Helvetica-Bold",        "n019004l"},
109 {"Helvetica-BoldOblique", "n019024l"},
110 {"Courier",               "n022003l"},
111 {"Courier-Oblique",       "n022023l"},
112 {"Courier-Bold",          "n022004l"},
113 {"Courier-BoldOblique",   "n022024l"},
114 {"Symbol",                "s050000l"},
115 {"ZapfDingbats",          "d050000l"}};
116
117 class SWFOutputDev:  public OutputDev {
118   int outputstarted;
119   struct swfoutput output;
120 public:
121
122   // Constructor.
123   SWFOutputDev();
124
125   // Destructor.
126   virtual ~SWFOutputDev() ;
127
128   void setMove(int x,int y);
129   void setClip(int x1,int y1,int x2,int y2);
130   
131   int save(char*filename);
132   void  pagefeed();
133   void* getSWF();
134
135   void getDimensions(int*x1,int*y1,int*x2,int*y2);
136
137   //----- get info about output device
138
139   // Does this device use upside-down coordinates?
140   // (Upside-down means (0,0) is the top left corner of the page.)
141   virtual GBool upsideDown();
142
143   // Does this device use drawChar() or drawString()?
144   virtual GBool useDrawChar();
145   
146   // Can this device draw gradients?
147   virtual GBool useGradients();
148   
149   virtual GBool interpretType3Chars() {return gTrue;}
150
151   //----- initialization and control
152
153   void setXRef(PDFDoc*doc, XRef *xref);
154
155   // Start a page.
156   virtual void startPage(int pageNum, GfxState *state, double x1, double y1, double x2, double y2) ;
157
158   //----- link borders
159   virtual void drawLink(Link *link, Catalog *catalog) ;
160
161   //----- save/restore graphics state
162   virtual void saveState(GfxState *state) ;
163   virtual void restoreState(GfxState *state) ;
164
165   //----- update graphics state
166
167   virtual void updateFont(GfxState *state);
168   virtual void updateFillColor(GfxState *state);
169   virtual void updateStrokeColor(GfxState *state);
170   virtual void updateLineWidth(GfxState *state);
171   virtual void updateLineJoin(GfxState *state);
172   virtual void updateLineCap(GfxState *state);
173   
174   virtual void updateAll(GfxState *state) 
175   {
176       updateFont(state);
177       updateFillColor(state);
178       updateStrokeColor(state);
179       updateLineWidth(state);
180       updateLineJoin(state);
181       updateLineCap(state);
182   };
183
184   //----- path painting
185   virtual void stroke(GfxState *state) ;
186   virtual void fill(GfxState *state) ;
187   virtual void eoFill(GfxState *state) ;
188
189   //----- path clipping
190   virtual void clip(GfxState *state) ;
191   virtual void eoClip(GfxState *state) ;
192
193   //----- text drawing
194   virtual void beginString(GfxState *state, GString *s) ;
195   virtual void endString(GfxState *state) ;
196   virtual void drawChar(GfxState *state, double x, double y,
197                         double dx, double dy,
198                         double originX, double originY,
199                         CharCode code, Unicode *u, int uLen);
200
201   //----- image drawing
202   virtual void drawImageMask(GfxState *state, Object *ref, Stream *str,
203                              int width, int height, GBool invert,
204                              GBool inlineImg);
205   virtual void drawImage(GfxState *state, Object *ref, Stream *str,
206                          int width, int height, GfxImageColorMap *colorMap,
207                          int *maskColors, GBool inlineImg);
208   
209   virtual GBool beginType3Char(GfxState *state,
210                                CharCode code, Unicode *u, int uLen);
211   virtual void endType3Char(GfxState *state);
212
213   private:
214   void drawGeneralImage(GfxState *state, Object *ref, Stream *str,
215                                    int width, int height, GfxImageColorMap*colorMap, GBool invert,
216                                    GBool inlineImg, int mask);
217   int clipping[64];
218   int clippos;
219
220   int currentpage;
221
222   PDFDoc*doc;
223   XRef*xref;
224
225   char* searchFont(char*name);
226   char* substituteFont(GfxFont*gfxFont, char*oldname);
227   char* writeEmbeddedFontToFile(XRef*ref, GfxFont*font);
228   int t1id;
229   int jpeginfo; // did we write "File contains jpegs" yet?
230   int pbminfo; // did we write "File contains jpegs" yet?
231   int linkinfo; // did we write "File contains links" yet?
232   int ttfinfo; // did we write "File contains TrueType Fonts" yet?
233   int gradientinfo; // did we write "File contains Gradients yet?
234
235   int type3active; // are we between beginType3()/endType3()?
236
237   GfxState *laststate;
238
239   char type3Warning;
240
241   char* substitutetarget[256];
242   char* substitutesource[256];
243   int substitutepos;
244
245   int user_movex,user_movey;
246   int user_clipx1,user_clipx2,user_clipy1,user_clipy2;
247 };
248
249 static char*getFontID(GfxFont*font);
250
251 class InfoOutputDev:  public OutputDev 
252 {
253   public:
254   int x1,y1,x2,y2;
255   int num_links;
256   int num_images;
257   int num_fonts;
258
259   InfoOutputDev() 
260   {
261       num_links = 0;
262       num_images = 0;
263       num_fonts = 0;
264   }
265   virtual ~InfoOutputDev() 
266   {
267   }
268   virtual GBool upsideDown() {return gTrue;}
269   virtual GBool useDrawChar() {return gTrue;}
270   virtual GBool useGradients() {return gTrue;}
271   virtual GBool interpretType3Chars() {return gTrue;}
272   virtual void startPage(int pageNum, GfxState *state, double crop_x1, double crop_y1, double crop_x2, double crop_y2)
273   {
274       double x1,y1,x2,y2;
275       state->transform(crop_x1,crop_y1,&x1,&y1);
276       state->transform(crop_x2,crop_y2,&x2,&y2);
277       if(x2<x1) {double x3=x1;x1=x2;x2=x3;}
278       if(y2<y1) {double y3=y1;y1=y2;y2=y3;}
279       this->x1 = (int)x1;
280       this->y1 = (int)y1;
281       this->x2 = (int)x2;
282       this->y2 = (int)y2;
283   }
284   virtual void drawLink(Link *link, Catalog *catalog) 
285   {
286       num_links++;
287   }
288   virtual void updateFont(GfxState *state) 
289   {
290       GfxFont*font = state->getFont();
291       if(!font)
292           return;
293       char*id = getFontID(font);
294       /* FIXME*/
295       num_fonts++;
296   }
297   virtual void drawImageMask(GfxState *state, Object *ref, Stream *str,
298                              int width, int height, GBool invert,
299                              GBool inlineImg) 
300   {
301       num_images++;
302   }
303   virtual void drawImage(GfxState *state, Object *ref, Stream *str,
304                          int width, int height, GfxImageColorMap *colorMap,
305                          int *maskColors, GBool inlineImg)
306   {
307       num_images++;
308   }
309 };
310
311 SWFOutputDev::SWFOutputDev()
312 {
313     jpeginfo = 0;
314     ttfinfo = 0;
315     linkinfo = 0;
316     pbminfo = 0;
317     type3active = 0;
318     clippos = 0;
319     clipping[clippos] = 0;
320     outputstarted = 0;
321     xref = 0;
322     substitutepos = 0;
323     type3Warning = 0;
324     user_movex = 0;
325     user_movey = 0;
326     user_clipx1 = 0;
327     user_clipy1 = 0;
328     user_clipx2 = 0;
329     user_clipy2 = 0;
330     memset(&output, 0, sizeof(output));
331 //    printf("SWFOutputDev::SWFOutputDev() \n");
332 };
333   
334 void SWFOutputDev::setMove(int x,int y)
335 {
336     this->user_movex = x;
337     this->user_movey = y;
338 }
339
340 void SWFOutputDev::setClip(int x1,int y1,int x2,int y2)
341 {
342     if(x2<x1) {int x3=x1;x1=x2;x2=x3;}
343     if(y2<y1) {int y3=y1;y1=y2;y2=y3;}
344
345     this->user_clipx1 = x1;
346     this->user_clipy1 = y1;
347     this->user_clipx2 = x2;
348     this->user_clipy2 = y2;
349 }
350 void SWFOutputDev::getDimensions(int*x1,int*y1,int*x2,int*y2)
351 {
352     return swfoutput_getdimensions(&output, x1,y1,x2,y2);
353 }
354
355 static char*getFontID(GfxFont*font)
356 {
357     GString*gstr = font->getName();
358     char* fontname = gstr==0?0:gstr->getCString();
359     if(fontname==0) {
360         char buf[32];
361         Ref*r=font->getID();
362         sprintf(buf, "UFONT%d", r->num);
363         return strdup(buf);
364     }
365     return strdup(fontname);
366 }
367
368 static char*getFontName(GfxFont*font)
369 {
370     char*fontid = getFontID(font);
371     char*fontname= 0;
372     char* plus = strchr(fontid, '+');
373     if(plus && plus < &fontid[strlen(fontid)-1]) {
374         fontname = strdup(plus+1);
375     } else {
376         fontname = strdup(fontid);
377     }
378     free(fontid);
379     return fontname;
380 }
381
382 static char mybuf[1024];
383 static char* gfxstate2str(GfxState *state)
384 {
385   char*bufpos = mybuf;
386   GfxRGB rgb;
387   bufpos+=sprintf(bufpos,"CTM[%.3f/%.3f/%.3f/%.3f/%.3f/%.3f] ",
388                                     state->getCTM()[0],
389                                     state->getCTM()[1],
390                                     state->getCTM()[2],
391                                     state->getCTM()[3],
392                                     state->getCTM()[4],
393                                     state->getCTM()[5]);
394   if(state->getX1()!=0.0)
395   bufpos+=sprintf(bufpos,"X1-%.1f ",state->getX1());
396   if(state->getY1()!=0.0)
397   bufpos+=sprintf(bufpos,"Y1-%.1f ",state->getY1());
398   bufpos+=sprintf(bufpos,"X2-%.1f ",state->getX2());
399   bufpos+=sprintf(bufpos,"Y2-%.1f ",state->getY2());
400   bufpos+=sprintf(bufpos,"PW%.1f ",state->getPageWidth());
401   bufpos+=sprintf(bufpos,"PH%.1f ",state->getPageHeight());
402   /*bufpos+=sprintf(bufpos,"FC[%.1f/%.1f] ",
403           state->getFillColor()->c[0], state->getFillColor()->c[1]);
404   bufpos+=sprintf(bufpos,"SC[%.1f/%.1f] ",
405           state->getStrokeColor()->c[0], state->getFillColor()->c[1]);*/
406 /*  bufpos+=sprintf(bufpos,"FC[%.1f/%.1f/%.1f/%.1f/%.1f/%.1f/%.1f/%.1f]",
407           state->getFillColor()->c[0], state->getFillColor()->c[1],
408           state->getFillColor()->c[2], state->getFillColor()->c[3],
409           state->getFillColor()->c[4], state->getFillColor()->c[5],
410           state->getFillColor()->c[6], state->getFillColor()->c[7]);
411   bufpos+=sprintf(bufpos,"SC[%.1f/%.1f/%.1f/%.1f/%.1f/%.1f/%.1f/%.1f]",
412           state->getStrokeColor()->c[0], state->getFillColor()->c[1],
413           state->getStrokeColor()->c[2], state->getFillColor()->c[3],
414           state->getStrokeColor()->c[4], state->getFillColor()->c[5],
415           state->getStrokeColor()->c[6], state->getFillColor()->c[7]);*/
416   state->getFillRGB(&rgb);
417   if(rgb.r || rgb.g || rgb.b)
418   bufpos+=sprintf(bufpos,"FR[%.1f/%.1f/%.1f] ", rgb.r,rgb.g,rgb.b);
419   state->getStrokeRGB(&rgb);
420   if(rgb.r || rgb.g || rgb.b)
421   bufpos+=sprintf(bufpos,"SR[%.1f/%.1f/%.1f] ", rgb.r,rgb.g,rgb.b);
422   if(state->getFillColorSpace()->getNComps()>1)
423   bufpos+=sprintf(bufpos,"CS[[%d]] ",state->getFillColorSpace()->getNComps());
424   if(state->getStrokeColorSpace()->getNComps()>1)
425   bufpos+=sprintf(bufpos,"SS[[%d]] ",state->getStrokeColorSpace()->getNComps());
426   if(state->getFillPattern())
427   bufpos+=sprintf(bufpos,"FP%08x ", state->getFillPattern());
428   if(state->getStrokePattern())
429   bufpos+=sprintf(bufpos,"SP%08x ", state->getStrokePattern());
430  
431   if(state->getFillOpacity()!=1.0)
432   bufpos+=sprintf(bufpos,"FO%.1f ", state->getFillOpacity());
433   if(state->getStrokeOpacity()!=1.0)
434   bufpos+=sprintf(bufpos,"SO%.1f ", state->getStrokeOpacity());
435
436   bufpos+=sprintf(bufpos,"LW%.1f ", state->getLineWidth());
437  
438   double * dash;
439   int length;
440   double start;
441   state->getLineDash(&dash, &length, &start);
442   int t;
443   if(length)
444   {
445       bufpos+=sprintf(bufpos,"DASH%.1f[",start);
446       for(t=0;t<length;t++) {
447           bufpos+=sprintf(bufpos,"D%.1f",dash[t]);
448       }
449       bufpos+=sprintf(bufpos,"]");
450   }
451
452   if(state->getFlatness()!=1)
453   bufpos+=sprintf(bufpos,"F%d ", state->getFlatness());
454   if(state->getLineJoin()!=0)
455   bufpos+=sprintf(bufpos,"J%d ", state->getLineJoin());
456   if(state->getLineJoin()!=0)
457   bufpos+=sprintf(bufpos,"C%d ", state->getLineCap());
458   if(state->getLineJoin()!=0)
459   bufpos+=sprintf(bufpos,"ML%d ", state->getMiterLimit());
460
461   if(state->getFont() && getFontID(state->getFont()))
462   bufpos+=sprintf(bufpos,"F\"%s\" ",getFontID(state->getFont()));
463   bufpos+=sprintf(bufpos,"FS%.1f ", state->getFontSize());
464   bufpos+=sprintf(bufpos,"MAT[%.1f/%.1f/%.1f/%.1f/%.1f/%.1f] ", state->getTextMat()[0],state->getTextMat()[1],state->getTextMat()[2],
465                                    state->getTextMat()[3],state->getTextMat()[4],state->getTextMat()[5]);
466   if(state->getCharSpace())
467   bufpos+=sprintf(bufpos,"CS%.5f ", state->getCharSpace());
468   if(state->getWordSpace())
469   bufpos+=sprintf(bufpos,"WS%.5f ", state->getWordSpace());
470   if(state->getHorizScaling()!=1.0)
471   bufpos+=sprintf(bufpos,"SC%.1f ", state->getHorizScaling());
472   if(state->getLeading())
473   bufpos+=sprintf(bufpos,"L%.1f ", state->getLeading());
474   if(state->getRise())
475   bufpos+=sprintf(bufpos,"R%.1f ", state->getRise());
476   if(state->getRender())
477   bufpos+=sprintf(bufpos,"R%d ", state->getRender());
478   bufpos+=sprintf(bufpos,"P%08x ", state->getPath());
479   bufpos+=sprintf(bufpos,"CX%.1f ", state->getCurX());
480   bufpos+=sprintf(bufpos,"CY%.1f ", state->getCurY());
481   if(state->getLineX())
482   bufpos+=sprintf(bufpos,"LX%.1f ", state->getLineX());
483   if(state->getLineY())
484   bufpos+=sprintf(bufpos,"LY%.1f ", state->getLineY());
485   bufpos+=sprintf(bufpos," ");
486   return mybuf;
487 }
488
489 static void dumpFontInfo(char*loglevel, GfxFont*font);
490 static int lastdumps[1024];
491 static int lastdumppos = 0;
492 /* nr = 0  unknown
493    nr = 1  substituting
494    nr = 2  type 3
495  */
496 static void showFontError(GfxFont*font, int nr) 
497 {  
498     Ref*r=font->getID();
499     int t;
500     for(t=0;t<lastdumppos;t++)
501         if(lastdumps[t] == r->num)
502             break;
503     if(t < lastdumppos)
504       return;
505     if(lastdumppos<sizeof(lastdumps)/sizeof(int))
506     lastdumps[lastdumppos++] = r->num;
507     if(nr == 0)
508       msg("<warning> The following font caused problems:");
509     else if(nr == 1)
510       msg("<warning> The following font caused problems (substituting):");
511     else if(nr == 2)
512       msg("<warning> The following Type 3 Font will be rendered as bitmap:");
513     dumpFontInfo("<warning>", font);
514 }
515
516 static void dumpFontInfo(char*loglevel, GfxFont*font)
517 {
518   char* name = getFontID(font);
519   Ref* r=font->getID();
520   msg("%s=========== %s (ID:%d,%d) ==========\n", loglevel, getFontName(font), r->num,r->gen);
521
522   GString*gstr  = font->getTag();
523    
524   msg("%s| Tag: %s\n", loglevel, name);
525   
526   if(font->isCIDFont()) msg("%s| is CID font\n", loglevel);
527
528   GfxFontType type=font->getType();
529   switch(type) {
530     case fontUnknownType:
531      msg("%s| Type: unknown\n",loglevel);
532     break;
533     case fontType1:
534      msg("%s| Type: 1\n",loglevel);
535     break;
536     case fontType1C:
537      msg("%s| Type: 1C\n",loglevel);
538     break;
539     case fontType3:
540      msg("%s| Type: 3\n",loglevel);
541     break;
542     case fontTrueType:
543      msg("%s| Type: TrueType\n",loglevel);
544     break;
545     case fontCIDType0:
546      msg("%s| Type: CIDType0\n",loglevel);
547     break;
548     case fontCIDType0C:
549      msg("%s| Type: CIDType0C\n",loglevel);
550     break;
551     case fontCIDType2:
552      msg("%s| Type: CIDType2\n",loglevel);
553     break;
554   }
555   
556   Ref embRef;
557   GBool embedded = font->getEmbeddedFontID(&embRef);
558   if(font->getEmbeddedFontName())
559     name = font->getEmbeddedFontName()->getCString();
560   if(embedded)
561    msg("%s| Embedded name: %s id: %d\n",loglevel, FIXNULL(name), embRef.num);
562
563   gstr = font->getExtFontFile();
564   if(gstr)
565    msg("%s| External Font file: %s\n", loglevel, FIXNULL(gstr->getCString()));
566
567   // Get font descriptor flags.
568   if(font->isFixedWidth()) msg("%s| is fixed width\n", loglevel);
569   if(font->isSerif()) msg("%s| is serif\n", loglevel);
570   if(font->isSymbolic()) msg("%s| is symbolic\n", loglevel);
571   if(font->isItalic()) msg("%s| is italic\n", loglevel);
572   if(font->isBold()) msg("%s| is bold\n", loglevel);
573 }
574
575 //void SWFOutputDev::drawImageMask(GfxState *state, Object *ref, Stream *str, int width, int height, GBool invert, GBool inlineImg) {printf("void SWFOutputDev::drawImageMask(GfxState *state, Object *ref, Stream *str, int width, int height, GBool invert, GBool inlineImg) \n");}
576 //void SWFOutputDev::drawImage(GfxState *state, Object *ref, Stream *str, int width, int height, GfxImageColorMap *colorMap, GBool inlineImg) {printf("void SWFOutputDev::drawImage(GfxState *state, Object *ref, Stream *str, int width, int height, GfxImageColorMap *colorMap, GBool inlineImg) \n");}
577
578 gfxline_t* gfxPath_to_gfxline(GfxState*state, GfxPath*path, int closed)
579 {
580     int num = path->getNumSubpaths();
581     int s,t;
582     int cpos = 0;
583     double lastx=0,lasty=0,posx=0,posy=0;
584     int needsfix=0;
585     if(!num) {
586         msg("<warning> empty path");
587         return 0;
588     }
589     gfxdrawer_t draw;
590     gfxdrawer_target_gfxline(&draw);
591
592     for(t = 0; t < num; t++) {
593         GfxSubpath *subpath = path->getSubpath(t);
594         int subnum = subpath->getNumPoints();
595         double bx=0,by=0,cx=0,cy=0;
596
597         for(s=0;s<subnum;s++) {
598            double x,y;
599            state->transform(subpath->getX(s),subpath->getY(s),&x,&y);
600            if(s==0) {
601                 if(closed && needsfix && (fabs(posx-lastx)+fabs(posy-lasty))>0.001) {
602                     draw.lineTo(&draw, lastx, lasty);
603                 }
604                 draw.moveTo(&draw, x,y);
605                 posx = lastx = x; 
606                 posy = lasty = y;
607                 cpos = 0;
608                 needsfix = 0;
609            } else if(subpath->getCurve(s) && cpos==0) {
610                 bx = x;
611                 by = y;
612                 cpos = 1;
613            } else if(subpath->getCurve(s) && cpos==1) {
614                 cx = x;
615                 cy = y;
616                 cpos = 2;
617            } else {
618                 posx = x;
619                 posy = y;
620                 if(cpos==0) {
621                     draw.lineTo(&draw, x,y);
622                 } else {
623                     gfxdraw_cubicTo(&draw, bx,by, cx,cy, x,y);
624                 }
625                 needsfix = 1;
626                 cpos = 0;
627            }
628         }
629     }
630     /* fix non-closed lines */
631     if(closed && needsfix && (fabs(posx-lastx)+fabs(posy-lasty))>0.001) {
632         draw.lineTo(&draw, lastx, lasty);
633     }
634     return (gfxline_t*)draw.result(&draw);
635 }
636
637
638 void dump_outline(gfxline_t*line)
639 {
640     while(line) {
641         if(line->type == gfx_moveTo) {
642             msg("<debug> |     moveTo %.2f %.2f", line->x,line->y);
643         } else if(line->type == gfx_lineTo) {
644             msg("<debug> |     lineTo %.2f %.2f", line->x,line->y);
645         } else if(line->type == gfx_splineTo) {
646             msg("<debug> |     splineTo (%.2f %.2f) %.2f %.2f", line->sx,line->sy, line->x, line->y);
647         }
648         line = line->next;
649     }
650 }
651
652 /*----------------------------------------------------------------------------
653  * Primitive Graphic routines
654  *----------------------------------------------------------------------------*/
655
656 void SWFOutputDev::stroke(GfxState *state) 
657 {
658     GfxPath * path = state->getPath();
659     int lineCap = state->getLineCap(); // 0=butt, 1=round 2=square
660     int lineJoin = state->getLineJoin(); // 0=miter, 1=round 2=bevel
661     double miterLimit = state->getMiterLimit();
662     double width = state->getTransformedLineWidth();
663
664     GfxRGB rgb;
665     double opaq = state->getStrokeOpacity();
666     state->getStrokeRGB(&rgb);
667     gfxcolor_t col;
668     col.r = (unsigned char)(rgb.r*255);
669     col.g = (unsigned char)(rgb.g*255);
670     col.b = (unsigned char)(rgb.b*255);
671     col.a = (unsigned char)(opaq*255);
672     
673     gfx_capType capType = gfx_capRound;
674     if(lineCap == 0) capType = gfx_capButt;
675     else if(lineCap == 1) capType = gfx_capRound;
676     else if(lineCap == 2) capType = gfx_capSquare;
677
678     gfx_joinType joinType = gfx_joinRound;
679     if(lineJoin == 0) joinType = gfx_joinMiter;
680     else if(lineJoin == 1) joinType = gfx_joinRound;
681     else if(lineJoin == 2) joinType = gfx_joinBevel;
682
683     gfxline_t*line= gfxPath_to_gfxline(state, path, 0);
684     
685     int dashnum = 0;
686     double dashphase = 0;
687     double * ldash = 0;
688     state->getLineDash(&ldash, &dashnum, &dashphase);
689
690     if(dashnum && ldash) {
691         float * dash = (float*)malloc(sizeof(float)*(dashnum+1));
692         int t;
693         double cut = 0;
694         int fixzero = 0;
695         msg("<trace> %d dashes", dashnum);
696         msg("<trace> |  phase: %f", dashphase);
697         for(t=0;t<dashnum;t++) {
698             dash[t] = ldash[t];
699             msg("<trace> |  d%-3d: %f", t, ldash[t]);
700         }
701         dash[dashnum] = -1;
702         if(getLogLevel() >= LOGLEVEL_TRACE) {
703             dump_outline(line);
704         }
705
706         gfxline_t*line2 = gfxtool_dash_line(line, dash, dashphase);
707         gfxline_free(line);
708         line = line2;
709         msg("<trace> After dashing:");
710     }
711     
712     if(getLogLevel() >= LOGLEVEL_TRACE)  {
713         msg("<trace> stroke width=%f join=%s cap=%s dashes=%d\n",
714                 width,
715                 lineJoin==0?"miter": (lineJoin==1?"round":"bevel"),
716                 lineCap==0?"butt": (lineJoin==1?"round":"square"),
717                 dashnum
718                 );
719         dump_outline(line);
720     }
721    
722     swfoutput_drawgfxline(&output, line, width, &col, capType, joinType, miterLimit);
723     gfxline_free(line);
724 }
725 void SWFOutputDev::fill(GfxState *state) 
726 {
727     GfxPath * path = state->getPath();
728     double opaq = state->getFillOpacity();
729     GfxRGB rgb;
730     state->getFillRGB(&rgb);
731     gfxcolor_t col;
732     col.r = (unsigned char)(rgb.r*255);
733     col.g = (unsigned char)(rgb.g*255);
734     col.b = (unsigned char)(rgb.b*255);
735     col.a = (unsigned char)(opaq*255);
736
737     gfxline_t*line= gfxPath_to_gfxline(state, path, 1);
738
739     if(getLogLevel() >= LOGLEVEL_TRACE)  {
740         msg("<trace> fill %02x%02x%02x%02x\n", col.r, col.g, col.b, col.a);
741         dump_outline(line);
742     }
743
744     swfoutput_fillgfxline(&output, line, &col);
745     gfxline_free(line);
746 }
747 void SWFOutputDev::eoFill(GfxState *state) 
748 {
749     GfxPath * path = state->getPath();
750     double opaq = state->getFillOpacity();
751     GfxRGB rgb;
752     state->getFillRGB(&rgb);
753     gfxcolor_t col;
754     col.r = (unsigned char)(rgb.r*255);
755     col.g = (unsigned char)(rgb.g*255);
756     col.b = (unsigned char)(rgb.b*255);
757     col.a = (unsigned char)(opaq*255);
758
759     gfxline_t*line= gfxPath_to_gfxline(state, path, 1);
760
761     if(getLogLevel() >= LOGLEVEL_TRACE)  {
762         msg("<trace> eofill\n");
763         dump_outline(line);
764     }
765
766     swfoutput_fillgfxline(&output, line, &col);
767     gfxline_free(line);
768 }
769 void SWFOutputDev::clip(GfxState *state) 
770 {
771     GfxPath * path = state->getPath();
772     gfxline_t*line = gfxPath_to_gfxline(state, path, 1);
773
774     if(getLogLevel() >= LOGLEVEL_TRACE)  {
775         msg("<trace> clip\n");
776         dump_outline(line);
777     }
778
779     swfoutput_startclip(&output, line);
780     clipping[clippos] ++;
781     gfxline_free(line);
782 }
783 void SWFOutputDev::eoClip(GfxState *state) 
784 {
785     GfxPath * path = state->getPath();
786     gfxline_t*line = gfxPath_to_gfxline(state, path, 1);
787
788     if(getLogLevel() >= LOGLEVEL_TRACE)  {
789         msg("<trace> eoclip\n");
790         dump_outline(line);
791     }
792
793     swfoutput_startclip(&output, line);
794     clipping[clippos] ++;
795     gfxline_free(line);
796 }
797
798 /* pass through functions for swf_output */
799 int SWFOutputDev::save(char*filename)
800 {
801     return swfoutput_save(&output, filename);
802 }
803 void SWFOutputDev::pagefeed()
804 {
805     swfoutput_pagefeed(&output);
806 }
807 void* SWFOutputDev::getSWF()
808 {
809     return (void*)swfoutput_get(&output);
810 }
811
812 SWFOutputDev::~SWFOutputDev() 
813 {
814     swfoutput_destroy(&output);
815     outputstarted = 0;
816 };
817 GBool SWFOutputDev::upsideDown() 
818 {
819     msg("<debug> upsidedown? yes");
820     return gTrue;
821 };
822 GBool SWFOutputDev::useDrawChar() 
823 {
824     return gTrue;
825 }
826 GBool SWFOutputDev::useGradients()
827 {
828     if(!gradientinfo)
829     {
830         msg("<notice> File contains gradients");
831         gradientinfo = 1;
832     }
833     return gTrue;
834 }
835
836 void SWFOutputDev::beginString(GfxState *state, GString *s) 
837
838     double m11,m21,m12,m22;
839 //    msg("<debug> %s beginstring \"%s\"\n", gfxstate2str(state), s->getCString());
840     state->getFontTransMat(&m11, &m12, &m21, &m22);
841     m11 *= state->getHorizScaling();
842     m21 *= state->getHorizScaling();
843     swfoutput_setfontmatrix(&output, m11, -m21, m12, -m22);
844 }
845
846 void SWFOutputDev::drawChar(GfxState *state, double x, double y,
847                         double dx, double dy,
848                         double originX, double originY,
849                         CharCode c, Unicode *_u, int uLen)
850 {
851     // check for invisible text -- this is used by Acrobat Capture
852     if ((state->getRender() & 3) == 3)
853         return;
854     GfxRGB rgb;
855     double opaq = state->getFillOpacity();
856     state->getFillRGB(&rgb);
857     gfxcolor_t col;
858     col.r = (unsigned char)(rgb.r*255);
859     col.g = (unsigned char)(rgb.g*255);
860     col.b = (unsigned char)(rgb.b*255);
861     col.a = (unsigned char)(opaq*255);
862
863     Gushort *CIDToGIDMap = 0;
864     GfxFont*font = state->getFont();
865
866     if(font->getType() == fontType3) {
867         /* type 3 chars are passed as graphics */
868         return;
869     }
870     double x1,y1;
871     x1 = x;
872     y1 = y;
873     state->transform(x, y, &x1, &y1);
874     
875     Unicode u=0;
876     char*name=0;
877
878     if(_u && uLen) {
879         u = *_u;
880         if (u) {
881             int t;
882             /* find out char name from unicode index 
883                TODO: should be precomputed
884              */
885             for(t=0;t<sizeof(nameToUnicodeTab)/sizeof(nameToUnicodeTab[0]);t++) {
886                 if(nameToUnicodeTab[t].u == u) {
887                     name = nameToUnicodeTab[t].name;
888                     break;
889                 }
890             }
891         }
892     }
893
894     if(font->isCIDFont()) {
895         GfxCIDFont*cfont = (GfxCIDFont*)font;
896
897         if(font->getType() == fontCIDType2) {
898             CIDToGIDMap = cfont->getCIDToGID();
899         }
900     } else {
901         Gfx8BitFont*font8;
902         font8 = (Gfx8BitFont*)font;
903         char**enc=font8->getEncoding();
904         if(enc && enc[c])
905            name = enc[c];
906     }
907  
908     if (CIDToGIDMap) {
909         msg("<debug> drawChar(%f, %f, c='%c' (%d), GID=%d, u=%d <%d>) CID=%d name=\"%s\"\n", x, y, (c&127)>=32?c:'?', c, CIDToGIDMap[c], u, uLen, font->isCIDFont(), FIXNULL(name));
910         swfoutput_drawchar(&output, x1, y1, name, CIDToGIDMap[c], u, &col);
911     } else {
912         msg("<debug> drawChar(%f,%f,c='%c' (%d), u=%d <%d>) CID=%d name=\"%s\"\n",x,y,(c&127)>=32?c:'?',c,u, uLen, font->isCIDFont(), FIXNULL(name));
913         swfoutput_drawchar(&output, x1, y1, name, c, u, &col);
914     }
915 }
916
917 void SWFOutputDev::endString(GfxState *state) { 
918 }    
919
920  
921 GBool SWFOutputDev::beginType3Char(GfxState *state,
922                                CharCode code, Unicode *u, int uLen)
923 {
924     msg("<debug> beginType3Char %d, %08x, %d", code, *u, uLen);
925     type3active = 1;
926     /* the character itself is going to be passed using
927        drawImageMask() */
928     return gFalse; /* gTrue= is_in_cache? */
929 }
930
931 void SWFOutputDev::endType3Char(GfxState *state)
932 {
933     type3active = 0;
934     msg("<debug> endType3Char");
935 }
936
937 void SWFOutputDev::startPage(int pageNum, GfxState *state, double crop_x1, double crop_y1, double crop_x2, double crop_y2) 
938 {
939     this->currentpage = pageNum;
940     double x1,y1,x2,y2;
941     int rot = doc->getPageRotate(1);
942     laststate = state;
943     msg("<verbose> startPage %d (%f,%f,%f,%f)\n", pageNum, crop_x1, crop_y1, crop_x2, crop_y2);
944     if(rot!=0)
945         msg("<verbose> page is rotated %d degrees\n", rot);
946
947     /* state->transform(state->getX1(),state->getY1(),&x1,&y1);
948     state->transform(state->getX2(),state->getY2(),&x2,&y2);
949     Use CropBox, not MediaBox, as page size
950     */
951     
952     /*x1 = crop_x1;
953     y1 = crop_y1;
954     x2 = crop_x2;
955     y2 = crop_y2;*/
956     state->transform(crop_x1,crop_y1,&x1,&y1);
957     state->transform(crop_x2,crop_y2,&x2,&y2);
958
959     if(x2<x1) {double x3=x1;x1=x2;x2=x3;}
960     if(y2<y1) {double y3=y1;y1=y2;y2=y3;}
961
962     /* apply user clip box */
963     if(user_clipx1|user_clipy1|user_clipx2|user_clipy2) {
964         /*if(user_clipx1 > x1)*/ x1 = user_clipx1;
965         /*if(user_clipx2 < x2)*/ x2 = user_clipx2;
966         /*if(user_clipy1 > y1)*/ y1 = user_clipy1;
967         /*if(user_clipy2 < y2)*/ y2 = user_clipy2;
968     }
969
970     if(!outputstarted) {
971         msg("<verbose> Bounding box is (%f,%f)-(%f,%f)", x1,y1,x2,y2);
972         swfoutput_init(&output);
973         outputstarted = 1;
974     }
975       
976     swfoutput_newpage(&output, pageNum, user_movex, user_movey, (int)x1, (int)y1, (int)x2, (int)y2);
977 }
978
979 void SWFOutputDev::drawLink(Link *link, Catalog *catalog) 
980 {
981     msg("<debug> drawlink\n");
982     double x1, y1, x2, y2, w;
983     GfxRGB rgb;
984     swfcoord points[5];
985     int x, y;
986
987 #ifdef XPDF_101
988     link->getBorder(&x1, &y1, &x2, &y2, &w);
989 #else
990     link->getRect(&x1, &y1, &x2, &y2);
991 #endif
992     rgb.r = 0;
993     rgb.g = 0;
994     rgb.b = 1;
995     cvtUserToDev(x1, y1, &x, &y);
996     points[0].x = points[4].x = (int)x;
997     points[0].y = points[4].y = (int)y;
998     cvtUserToDev(x2, y1, &x, &y);
999     points[1].x = (int)x;
1000     points[1].y = (int)y;
1001     cvtUserToDev(x2, y2, &x, &y);
1002     points[2].x = (int)x;
1003     points[2].y = (int)y;
1004     cvtUserToDev(x1, y2, &x, &y);
1005     points[3].x = (int)x;
1006     points[3].y = (int)y;
1007
1008     LinkAction*action=link->getAction();
1009     char buf[128];
1010     char*s = 0;
1011     char*type = "-?-";
1012     char*url = 0;
1013     char*named = 0;
1014     int page = -1;
1015     switch(action->getKind())
1016     {
1017         case actionGoTo: {
1018             type = "GoTo";
1019             LinkGoTo *ha=(LinkGoTo *)link->getAction();
1020             LinkDest *dest=NULL;
1021             if (ha->getDest()==NULL) 
1022                 dest=catalog->findDest(ha->getNamedDest());
1023             else dest=ha->getDest();
1024             if (dest){ 
1025               if (dest->isPageRef()){
1026                 Ref pageref=dest->getPageRef();
1027                 page=catalog->findPage(pageref.num,pageref.gen);
1028               }
1029               else  page=dest->getPageNum();
1030               sprintf(buf, "%d", page);
1031               s = strdup(buf);
1032             }
1033         }
1034         break;
1035         case actionGoToR: {
1036             type = "GoToR";
1037             LinkGoToR*l = (LinkGoToR*)action;
1038             GString*g = l->getNamedDest();
1039             if(g)
1040              s = strdup(g->getCString());
1041         }
1042         break;
1043         case actionNamed: {
1044             type = "Named";
1045             LinkNamed*l = (LinkNamed*)action;
1046             GString*name = l->getName();
1047             if(name) {
1048                 s = strdup(name->lowerCase()->getCString());
1049                 named = name->getCString();
1050                 if(!strchr(s,':')) 
1051                 {
1052                     if(strstr(s, "next") || strstr(s, "forward"))
1053                     {
1054                         page = currentpage + 1;
1055                     }
1056                     else if(strstr(s, "prev") || strstr(s, "back"))
1057                     {
1058                         page = currentpage - 1;
1059                     }
1060                     else if(strstr(s, "last") || strstr(s, "end"))
1061                     {
1062                         page = pagepos>0?pages[pagepos-1]:0;
1063                     }
1064                     else if(strstr(s, "first") || strstr(s, "top"))
1065                     {
1066                         page = 1;
1067                     }
1068                 }
1069             }
1070         }
1071         break;
1072         case actionLaunch: {
1073             type = "Launch";
1074             LinkLaunch*l = (LinkLaunch*)action;
1075             GString * str = new GString(l->getFileName());
1076             str->append(l->getParams());
1077             s = strdup(str->getCString());
1078             delete str;
1079         }
1080         break;
1081         case actionURI: {
1082             type = "URI";
1083             LinkURI*l = (LinkURI*)action;
1084             GString*g = l->getURI();
1085             if(g) {
1086              url = g->getCString();
1087              s = strdup(url);
1088             }
1089         }
1090         break;
1091         case actionUnknown: {
1092             type = "Unknown";
1093             LinkUnknown*l = (LinkUnknown*)action;
1094             s = strdup("");
1095         }
1096         break;
1097         default: {
1098             msg("<error> Unknown link type!\n");
1099             break;
1100         }
1101     }
1102     if(!s) s = strdup("-?-");
1103
1104     if(!linkinfo && (page || url))
1105     {
1106         msg("<notice> File contains links");
1107         linkinfo = 1;
1108     }
1109     if(page>0)
1110     {
1111         int t;
1112         for(t=0;t<pagepos;t++)
1113             if(pages[t]==page)
1114                 break;
1115         if(t!=pagepos)
1116             swfoutput_linktopage(&output, t, points);
1117     }
1118     else if(url)
1119     {
1120         swfoutput_linktourl(&output, url, points);
1121     }
1122     else if(named)
1123     {
1124         swfoutput_namedlink(&output, named, points);
1125     }
1126     msg("<verbose> \"%s\" link to \"%s\" (%d)\n", type, FIXNULL(s), page);
1127     free(s);s=0;
1128 }
1129
1130 void SWFOutputDev::saveState(GfxState *state) {
1131   msg("<debug> saveState\n");
1132   updateAll(state);
1133   if(clippos<64)
1134     clippos ++;
1135   else
1136     msg("<error> Too many nested states in pdf.");
1137   clipping[clippos] = 0;
1138 };
1139
1140 void SWFOutputDev::restoreState(GfxState *state) {
1141   msg("<debug> restoreState\n");
1142   updateAll(state);
1143   while(clipping[clippos]) {
1144       swfoutput_endclip(&output);
1145       clipping[clippos]--;
1146   }
1147   clippos--;
1148 }
1149
1150 char* SWFOutputDev::searchFont(char*name) 
1151 {       
1152     int i;
1153     char*filename=0;
1154     int is_standard_font = 0;
1155         
1156     msg("<verbose> SearchFont(%s)", name);
1157
1158     /* see if it is a pdf standard font */
1159     for(i=0;i<sizeof(pdf2t1map)/sizeof(mapping);i++) 
1160     {
1161         if(!strcmp(name, pdf2t1map[i].pdffont))
1162         {
1163             name = pdf2t1map[i].filename;
1164             is_standard_font = 1;
1165             break;
1166         }
1167     }
1168     /* look in all font files */
1169     for(i=0;i<fontnum;i++) 
1170     {
1171         if(strstr(fonts[i].filename, name))
1172         {
1173             if(!fonts[i].used) {
1174
1175                 fonts[i].used = 1;
1176                 if(!is_standard_font)
1177                     msg("<notice> Using %s for %s", fonts[i].filename, name);
1178             }
1179             return strdup(fonts[i].filename);
1180         }
1181     }
1182     return 0;
1183 }
1184
1185 void SWFOutputDev::updateLineWidth(GfxState *state)
1186 {
1187     double width = state->getTransformedLineWidth();
1188     //swfoutput_setlinewidth(&output, width);
1189 }
1190
1191 void SWFOutputDev::updateLineCap(GfxState *state)
1192 {
1193     int c = state->getLineCap();
1194 }
1195
1196 void SWFOutputDev::updateLineJoin(GfxState *state)
1197 {
1198     int j = state->getLineJoin();
1199 }
1200
1201 void SWFOutputDev::updateFillColor(GfxState *state) 
1202 {
1203     GfxRGB rgb;
1204     double opaq = state->getFillOpacity();
1205     state->getFillRGB(&rgb);
1206
1207     //swfoutput_setfillcolor(&output, (char)(rgb.r*255), (char)(rgb.g*255), (char)(rgb.b*255), (char)(opaq*255));
1208 }
1209
1210 void SWFOutputDev::updateStrokeColor(GfxState *state) 
1211 {
1212     GfxRGB rgb;
1213     double opaq = state->getStrokeOpacity();
1214     state->getStrokeRGB(&rgb);
1215
1216     //swfoutput_setstrokecolor(&output, (char)(rgb.r*255), (char)(rgb.g*255), (char)(rgb.b*255), (char)(opaq*255));
1217 }
1218
1219 void FoFiWrite(void *stream, char *data, int len)
1220 {
1221    fwrite(data, len, 1, (FILE*)stream);
1222 }
1223
1224 char*SWFOutputDev::writeEmbeddedFontToFile(XRef*ref, GfxFont*font)
1225 {
1226     char*tmpFileName = NULL;
1227     FILE *f;
1228     int c;
1229     char *fontBuf;
1230     int fontLen;
1231     Ref embRef;
1232     Object refObj, strObj;
1233     char namebuf[512];
1234     tmpFileName = mktmpname(namebuf);
1235     int ret;
1236
1237     ret = font->getEmbeddedFontID(&embRef);
1238     if(!ret) {
1239         msg("<verbose> Didn't get embedded font id");
1240         /* not embedded- the caller should now search the font
1241            directories for this font */
1242         return 0;
1243     }
1244
1245     f = fopen(tmpFileName, "wb");
1246     if (!f) {
1247       msg("<error> Couldn't create temporary Type 1 font file");
1248         return 0;
1249     }
1250
1251     /*if(font->isCIDFont()) {
1252         GfxCIDFont* cidFont = (GfxCIDFont *)font;
1253         GString c = cidFont->getCollection();
1254         msg("<notice> Collection: %s", c.getCString());
1255     }*/
1256
1257     if (font->getType() == fontType1C ||
1258         font->getType() == fontCIDType0C) {
1259       if (!(fontBuf = font->readEmbFontFile(xref, &fontLen))) {
1260         fclose(f);
1261         msg("<error> Couldn't read embedded font file");
1262         return 0;
1263       }
1264 #ifdef XPDF_101
1265       Type1CFontFile *cvt = new Type1CFontFile(fontBuf, fontLen);
1266       if(!cvt) return 0;
1267       cvt->convertToType1(f);
1268 #else
1269       FoFiType1C *cvt = FoFiType1C::make(fontBuf, fontLen);
1270       if(!cvt) return 0;
1271       cvt->convertToType1(NULL, gTrue, FoFiWrite, f);
1272 #endif
1273       //cvt->convertToCIDType0("test", f);
1274       //cvt->convertToType0("test", f);
1275       delete cvt;
1276       gfree(fontBuf);
1277     } else if(font->getType() == fontTrueType) {
1278       msg("<verbose> writing font using TrueTypeFontFile::writeTTF");
1279       if (!(fontBuf = font->readEmbFontFile(xref, &fontLen))) {
1280         fclose(f);
1281         msg("<error> Couldn't read embedded font file");
1282         return 0;
1283       }
1284 #ifdef XPDF_101
1285       TrueTypeFontFile *cvt = new TrueTypeFontFile(fontBuf, fontLen);
1286       cvt->writeTTF(f);
1287 #else
1288       FoFiTrueType *cvt = FoFiTrueType::make(fontBuf, fontLen);
1289       cvt->writeTTF(FoFiWrite, f);
1290 #endif
1291       delete cvt;
1292       gfree(fontBuf);
1293     } else {
1294       font->getEmbeddedFontID(&embRef);
1295       refObj.initRef(embRef.num, embRef.gen);
1296       refObj.fetch(ref, &strObj);
1297       refObj.free();
1298       strObj.streamReset();
1299       int f4[4];
1300       char f4c[4];
1301       int t;
1302       for(t=0;t<4;t++) {
1303           f4[t] = strObj.streamGetChar();
1304           f4c[t] = (char)f4[t];
1305           if(f4[t] == EOF)
1306               break;
1307       }
1308       if(t==4) {
1309           if(!strncmp(f4c, "true", 4)) {
1310               /* some weird TTF fonts don't start with 0,1,0,0 but with "true".
1311                  Change this on the fly */
1312               f4[0] = f4[2] = f4[3] = 0;
1313               f4[1] = 1;
1314           }
1315           fputc(f4[0], f);
1316           fputc(f4[1], f);
1317           fputc(f4[2], f);
1318           fputc(f4[3], f);
1319
1320           while ((c = strObj.streamGetChar()) != EOF) {
1321             fputc(c, f);
1322           }
1323       }
1324       strObj.streamClose();
1325       strObj.free();
1326     }
1327     fclose(f);
1328
1329     return strdup(tmpFileName);
1330 }
1331     
1332 char* searchForSuitableFont(GfxFont*gfxFont)
1333 {
1334     char*name = getFontName(gfxFont);
1335     char*fontname = 0;
1336     char*filename = 0;
1337
1338     if(!config_use_fontconfig)
1339         return 0;
1340     
1341 #ifdef HAVE_FONTCONFIG
1342     FcPattern *pattern, *match;
1343     FcResult result;
1344     FcChar8 *v;
1345
1346     static int fcinitcalled = false; 
1347         
1348     msg("<debug> searchForSuitableFont(%s)", name);
1349     
1350     // call init ony once
1351     if (!fcinitcalled) {
1352         msg("<debug> Initializing FontConfig...");
1353         fcinitcalled = true;
1354         if(FcInit()) {
1355             msg("<debug> FontConfig Initialization failed. Disabling.");
1356             config_use_fontconfig = 0;
1357             return 0;
1358         }
1359         msg("<debug> ...initialized FontConfig");
1360     }
1361    
1362     msg("<debug> FontConfig: Create \"%s\" Family Pattern", name);
1363     pattern = FcPatternBuild(NULL, FC_FAMILY, FcTypeString, name, NULL);
1364     if (gfxFont->isItalic()) // check for italic
1365         msg("<debug> FontConfig: Adding Italic Slant");
1366         FcPatternAddInteger(pattern, FC_SLANT, FC_SLANT_ITALIC);
1367     if (gfxFont->isBold()) // check for bold
1368         msg("<debug> FontConfig: Adding Bold Weight");
1369         FcPatternAddInteger(pattern, FC_WEIGHT, FC_WEIGHT_BOLD);
1370
1371     msg("<debug> FontConfig: Try to match...");
1372     // configure and match using the original font name 
1373     FcConfigSubstitute(0, pattern, FcMatchPattern); 
1374     FcDefaultSubstitute(pattern);
1375     match = FcFontMatch(0, pattern, &result);
1376     
1377     if (FcPatternGetString(match, "family", 0, &v) == FcResultMatch) {
1378         msg("<debug> FontConfig: family=%s", (char*)v);
1379         // if we get an exact match
1380         if (strcmp((char *)v, name) == 0) {
1381             if (FcPatternGetString(match, "file", 0, &v) == FcResultMatch) {
1382                 filename = strdup((char*)v);
1383                 char *nfn = strrchr(filename, '/');
1384                 if(nfn) fontname = strdup(nfn+1);
1385                 else    fontname = filename;
1386             }
1387             msg("<debug> FontConfig: Returning \"%s\"", fontname);
1388         } else {
1389             // initialize patterns
1390             FcPatternDestroy(pattern);
1391             FcPatternDestroy(match);
1392
1393             // now match against serif etc.
1394             if (gfxFont->isSerif()) {
1395                 msg("<debug> FontConfig: Create Serif Family Pattern");
1396                 pattern = FcPatternBuild (NULL, FC_FAMILY, FcTypeString, "serif", NULL);
1397             } else if (gfxFont->isFixedWidth()) {
1398                 msg("<debug> FontConfig: Create Monospace Family Pattern");
1399                 pattern = FcPatternBuild (NULL, FC_FAMILY, FcTypeString, "monospace", NULL);
1400             } else {
1401                 msg("<debug> FontConfig: Create Sans Family Pattern");
1402                 pattern = FcPatternBuild (NULL, FC_FAMILY, FcTypeString, "sans", NULL);
1403             }
1404
1405             // check for italic
1406             if (gfxFont->isItalic()) {
1407                 msg("<debug> FontConfig: Adding Italic Slant");
1408                 int bb = FcPatternAddInteger(pattern, FC_SLANT, FC_SLANT_ITALIC);
1409             }
1410             // check for bold
1411             if (gfxFont->isBold()) {
1412                 msg("<debug> FontConfig: Adding Bold Weight");
1413                 int bb = FcPatternAddInteger(pattern, FC_WEIGHT, FC_WEIGHT_BOLD);
1414             }
1415
1416             msg("<debug> FontConfig: Try to match... (2)");
1417             // configure and match using serif etc
1418             FcConfigSubstitute (0, pattern, FcMatchPattern);
1419             FcDefaultSubstitute (pattern);
1420             match = FcFontMatch (0, pattern, &result);
1421             
1422             if (FcPatternGetString(match, "file", 0, &v) == FcResultMatch) {
1423                 filename = strdup((char*)v);
1424                 char *nfn = strrchr(filename, '/');
1425                 if(nfn) fontname = strdup(nfn+1);
1426                 else    fontname = filename;
1427             }
1428             msg("<debug> FontConfig: Returning \"%s\"", fontname);
1429         }        
1430     }
1431
1432     //printf("FONTCONFIG: pattern");
1433     //FcPatternPrint(pattern);
1434     //printf("FONTCONFIG: match");
1435     //FcPatternPrint(match);
1436  
1437     FcPatternDestroy(pattern);
1438     FcPatternDestroy(match);
1439
1440     pdfswf_addfont(filename);
1441     return fontname;
1442 #else
1443     return 0;
1444 #endif
1445 }
1446
1447 char* SWFOutputDev::substituteFont(GfxFont*gfxFont, char* oldname)
1448 {
1449     char*fontname = 0, *filename = 0;
1450     msg("<notice> subsituteFont(%s)", oldname);
1451
1452     if(!(fontname = searchForSuitableFont(gfxFont))) {
1453         fontname = "Times-Roman";
1454     }
1455     filename = searchFont(fontname);
1456     if(!filename) {
1457         msg("<error> Couldn't find font %s- did you install the default fonts?");
1458         return 0;
1459     }
1460
1461     if(substitutepos>=sizeof(substitutesource)/sizeof(char*)) {
1462         msg("<fatal> Too many fonts in file.");
1463         exit(1);
1464     }
1465     if(oldname) {
1466         substitutesource[substitutepos] = oldname;
1467         substitutetarget[substitutepos] = fontname;
1468         msg("<notice> substituting %s -> %s", FIXNULL(oldname), FIXNULL(fontname));
1469         substitutepos ++;
1470     }
1471     return strdup(filename);
1472 }
1473
1474 void unlinkfont(char* filename)
1475 {
1476     int l;
1477     if(!filename)
1478         return;
1479     l=strlen(filename);
1480     unlink(filename);
1481     if(!strncmp(&filename[l-4],".afm",4)) {
1482         memcpy(&filename[l-4],".pfb",4);
1483         unlink(filename);
1484         memcpy(&filename[l-4],".pfa",4);
1485         unlink(filename);
1486         memcpy(&filename[l-4],".afm",4);
1487         return;
1488     } else 
1489     if(!strncmp(&filename[l-4],".pfa",4)) {
1490         memcpy(&filename[l-4],".afm",4);
1491         unlink(filename);
1492         memcpy(&filename[l-4],".pfa",4);
1493         return;
1494     } else 
1495     if(!strncmp(&filename[l-4],".pfb",4)) {
1496         memcpy(&filename[l-4],".afm",4);
1497         unlink(filename);
1498         memcpy(&filename[l-4],".pfb",4);
1499         return;
1500     }
1501 }
1502
1503 void SWFOutputDev::setXRef(PDFDoc*doc, XRef *xref) 
1504 {
1505     this->doc = doc;
1506     this->xref = xref;
1507 }
1508
1509
1510 void SWFOutputDev::updateFont(GfxState *state) 
1511 {
1512     GfxFont*gfxFont = state->getFont();
1513       
1514     if (!gfxFont) {
1515         return;
1516     }  
1517     char * fontid = getFontID(gfxFont);
1518     
1519     int t;
1520     /* first, look if we substituted this font before-
1521        this way, we don't initialize the T1 Fonts
1522        too often */
1523     for(t=0;t<substitutepos;t++) {
1524         if(!strcmp(fontid, substitutesource[t])) {
1525             fontid = substitutetarget[t];
1526             break;
1527         }
1528     }
1529
1530     /* second, see if swfoutput already has this font
1531        cached- if so, we are done */
1532     if(swfoutput_queryfont(&output, fontid))
1533     {
1534         swfoutput_setfont(&output, fontid, 0);
1535         
1536         msg("<debug> updateFont(%s) [cached]", fontid);
1537         return;
1538     }
1539
1540     // look for Type 3 font
1541     if (gfxFont->getType() == fontType3) {
1542         if(!type3Warning) {
1543             type3Warning = gTrue;
1544             showFontError(gfxFont, 2);
1545         }
1546         return;
1547     }
1548
1549     /* now either load the font, or find a substitution */
1550
1551     Ref embRef;
1552     GBool embedded = gfxFont->getEmbeddedFontID(&embRef);
1553
1554     char*fileName = 0;
1555     int del = 0;
1556     if(embedded &&
1557        (gfxFont->getType() == fontType1 ||
1558         gfxFont->getType() == fontType1C ||
1559        (gfxFont->getType() == fontCIDType0C && forceType0Fonts) ||
1560         gfxFont->getType() == fontTrueType ||
1561         gfxFont->getType() == fontCIDType2
1562        ))
1563     {
1564       fileName = writeEmbeddedFontToFile(xref, gfxFont);
1565       if(!fileName) showFontError(gfxFont,0);
1566       else del = 1;
1567     } else {
1568       char * fontname = getFontName(gfxFont);
1569       fileName = searchFont(fontname);
1570       if(!fileName) showFontError(gfxFont,0);
1571     }
1572     if(!fileName) {
1573         char * fontname = getFontName(gfxFont);
1574         msg("<warning> Font %s %scould not be loaded.", fontname, embedded?"":"(not embedded) ");
1575         msg("<warning> Try putting a TTF version of that font (named \"%s.ttf\") into /swftools/fonts", fontname);
1576         fileName = substituteFont(gfxFont, fontid);
1577         if(fontid) { fontid = substitutetarget[substitutepos-1]; /*ugly hack*/};
1578         msg("<notice> Font is now %s (%s)", fontid, fileName);
1579     }
1580
1581     if(!fileName) {
1582         msg("<error> Couldn't set font %s\n", fontid);
1583         return;
1584     }
1585         
1586     msg("<verbose> updateFont(%s) -> %s", fontid, fileName);
1587     dumpFontInfo("<verbose>", gfxFont);
1588
1589     swfoutput_setfont(&output, fontid, fileName);
1590    
1591     if(fileName && del)
1592         unlinkfont(fileName);
1593     if(fileName)
1594         free(fileName);
1595 }
1596
1597 #define SQR(x) ((x)*(x))
1598
1599 unsigned char* antialize(unsigned char*data, int width, int height, int newwidth, int newheight, int palettesize)
1600 {
1601     if((newwidth<2 || newheight<2) ||
1602        (width<=newwidth || height<=newheight))
1603         return 0;
1604     unsigned char*newdata;
1605     int x,y;
1606     newdata= (unsigned char*)malloc(newwidth*newheight);
1607     int t;
1608     double fx = (double)(width)/newwidth;
1609     double fy = (double)(height)/newheight;
1610     double px = 0;
1611     int blocksize = (int)(8192/(fx*fy));
1612     int r = 8192*256/palettesize;
1613     for(x=0;x<newwidth;x++) {
1614         double ex = px + fx;
1615         int fromx = (int)px;
1616         int tox = (int)ex;
1617         int xweight1 = (int)(((fromx+1)-px)*256);
1618         int xweight2 = (int)((ex-tox)*256);
1619         double py =0;
1620         for(y=0;y<newheight;y++) {
1621             double ey = py + fy;
1622             int fromy = (int)py;
1623             int toy = (int)ey;
1624             int yweight1 = (int)(((fromy+1)-py)*256);
1625             int yweight2 = (int)((ey-toy)*256);
1626             int a = 0;
1627             int xx,yy;
1628             for(xx=fromx;xx<=tox;xx++)
1629             for(yy=fromy;yy<=toy;yy++) {
1630                 int b = 1-data[width*yy+xx];
1631                 int weight=256;
1632                 if(xx==fromx) weight = (weight*xweight1)/256;
1633                 if(xx==tox) weight = (weight*xweight2)/256;
1634                 if(yy==fromy) weight = (weight*yweight1)/256;
1635                 if(yy==toy) weight = (weight*yweight2)/256;
1636                 a+=b*weight;
1637             }
1638             //if(a) a=(palettesize-1)*r/blocksize;
1639             newdata[y*newwidth+x] = (a*blocksize)/r;
1640             py = ey;
1641         }
1642         px = ex;
1643     }
1644     return newdata;
1645 }
1646
1647 void SWFOutputDev::drawGeneralImage(GfxState *state, Object *ref, Stream *str,
1648                                    int width, int height, GfxImageColorMap*colorMap, GBool invert,
1649                                    GBool inlineImg, int mask)
1650 {
1651   FILE *fi;
1652   int c;
1653   char fileName[128];
1654   double x1,y1,x2,y2,x3,y3,x4,y4;
1655   ImageStream *imgStr;
1656   Guchar pixBuf[4];
1657   GfxRGB rgb;
1658   int ncomps = 1;
1659   int bits = 1;
1660                                  
1661   if(colorMap) {
1662     ncomps = colorMap->getNumPixelComps();
1663     bits = colorMap->getBits();
1664   }
1665   imgStr = new ImageStream(str, width, ncomps,bits);
1666   imgStr->reset();
1667
1668   if(!width || !height || (height<=1 && width<=1))
1669   {
1670       msg("<verbose> Ignoring %d by %d image", width, height);
1671       unsigned char buf[8];
1672       int x,y;
1673       for (y = 0; y < height; ++y)
1674       for (x = 0; x < width; ++x) {
1675           imgStr->getPixel(buf);
1676       }
1677       delete imgStr;
1678       return;
1679   }
1680   
1681   state->transform(0, 1, &x1, &y1);
1682   state->transform(0, 0, &x2, &y2);
1683   state->transform(1, 0, &x3, &y3);
1684   state->transform(1, 1, &x4, &y4);
1685
1686   if(!pbminfo && !(str->getKind()==strDCT)) {
1687       if(!type3active) {
1688           msg("<notice> file contains pbm pictures %s",mask?"(masked)":"");
1689           pbminfo = 1;
1690       }
1691       if(mask)
1692       msg("<verbose> drawing %d by %d masked picture\n", width, height);
1693   }
1694   if(!jpeginfo && (str->getKind()==strDCT)) {
1695       msg("<notice> file contains jpeg pictures");
1696       jpeginfo = 1;
1697   }
1698
1699   if(mask) {
1700       int i,j;
1701       unsigned char buf[8];
1702       int x,y;
1703       unsigned char*pic = new unsigned char[width*height];
1704       RGBA pal[256];
1705       GfxRGB rgb;
1706       state->getFillRGB(&rgb);
1707
1708       memset(pal,255,sizeof(pal));
1709       pal[0].r = (int)(rgb.r*255); pal[1].r = 0;
1710       pal[0].g = (int)(rgb.g*255); pal[1].g = 0;
1711       pal[0].b = (int)(rgb.b*255); pal[1].b = 0;
1712       pal[0].a = 255;              pal[1].a = 0;
1713
1714       int numpalette = 2;
1715       int realwidth = (int)sqrt(SQR(x2-x3) + SQR(y2-y3));
1716       int realheight = (int)sqrt(SQR(x1-x2) + SQR(y1-y2));
1717       for (y = 0; y < height; ++y)
1718       for (x = 0; x < width; ++x)
1719       {
1720             imgStr->getPixel(buf);
1721             if(invert) 
1722                 buf[0]=1-buf[0];
1723             pic[width*y+x] = buf[0];
1724       }
1725       
1726       /* the size of the drawn image is added to the identifier
1727          as the same image may require different bitmaps if displayed
1728          at different sizes (due to antialiasing): */
1729       int t,found = -1;
1730       if(type3active) {
1731           unsigned char*pic2 = 0;
1732           numpalette = 16;
1733           
1734           pic2 = antialize(pic,width,height,realwidth,realheight,numpalette);
1735
1736           if(!pic2) {
1737             delete pic;
1738             delete imgStr;
1739             return;
1740           }
1741
1742           width = realwidth;
1743           height = realheight;
1744           free(pic);
1745           pic = pic2;
1746           
1747           /* make a black/white palette */
1748           GfxRGB rgb2;
1749           rgb2.r = 1 - rgb.r;
1750           rgb2.g = 1 - rgb.g;
1751           rgb2.b = 1 - rgb.b;
1752           float r = 255/(numpalette-1);
1753           int t;
1754           for(t=0;t<numpalette;t++) {
1755               pal[t].r = (U8)(255*rgb.r);
1756               pal[t].g = (U8)(255*rgb.g);
1757               pal[t].b = (U8)(255*rgb.b);
1758               pal[t].a = (U8)(t*r);
1759           }
1760       }
1761
1762       RGBA*pic2 = new RGBA[width*height];
1763       for (y = 0; y < height; ++y) {
1764         for (x = 0; x < width; ++x) {
1765           pic2[width*y+x] = pal[pic[y*width+x]];
1766         }
1767       }
1768       swfoutput_drawimagelossless(&output, pic2, width, height, x1,y1,x2,y2,x3,y3,x4,y4);
1769       free(pic2);
1770       free(pic);
1771       delete imgStr;
1772       return;
1773   } 
1774
1775   int x,y;
1776   
1777   if(colorMap->getNumPixelComps()!=1 || str->getKind()==strDCT) {
1778       RGBA*pic=new RGBA[width*height];
1779       for (y = 0; y < height; ++y) {
1780         for (x = 0; x < width; ++x) {
1781           imgStr->getPixel(pixBuf);
1782           colorMap->getRGB(pixBuf, &rgb);
1783           pic[width*y+x].r = (U8)(rgb.r * 255 + 0.5);
1784           pic[width*y+x].g = (U8)(rgb.g * 255 + 0.5);
1785           pic[width*y+x].b = (U8)(rgb.b * 255 + 0.5);
1786           pic[width*y+x].a = 255;//(U8)(rgb.a * 255 + 0.5);
1787         }
1788       }
1789       if(str->getKind()==strDCT)
1790           swfoutput_drawimagejpeg(&output, pic, width, height, x1,y1,x2,y2,x3,y3,x4,y4);
1791       else
1792           swfoutput_drawimagelossless(&output, pic, width, height, x1,y1,x2,y2,x3,y3,x4,y4);
1793       delete pic;
1794       delete imgStr;
1795       return;
1796   } else {
1797       RGBA*pic=new RGBA[width*height];
1798       RGBA pal[256];
1799       int t;
1800       for(t=0;t<256;t++) {
1801           pixBuf[0] = t;
1802           colorMap->getRGB(pixBuf, &rgb);
1803           pal[t].r = (U8)(rgb.r * 255 + 0.5);
1804           pal[t].g = (U8)(rgb.g * 255 + 0.5);
1805           pal[t].b = (U8)(rgb.b * 255 + 0.5);
1806           pal[t].a = 255;//(U8)(rgb.b * 255 + 0.5);
1807       }
1808       for (y = 0; y < height; ++y) {
1809         for (x = 0; x < width; ++x) {
1810           imgStr->getPixel(pixBuf);
1811           pic[width*y+x] = pal[pixBuf[0]];
1812         }
1813       }
1814       swfoutput_drawimagelossless(&output, pic, width, height, x1,y1,x2,y2,x3,y3,x4,y4);
1815
1816       delete pic;
1817       delete imgStr;
1818       return;
1819   }
1820 }
1821
1822 void SWFOutputDev::drawImageMask(GfxState *state, Object *ref, Stream *str,
1823                                    int width, int height, GBool invert,
1824                                    GBool inlineImg) 
1825 {
1826   msg("<verbose> drawImageMask %dx%d, invert=%d inline=%d", width, height, invert, inlineImg);
1827   drawGeneralImage(state,ref,str,width,height,0,invert,inlineImg,1);
1828 }
1829
1830 void SWFOutputDev::drawImage(GfxState *state, Object *ref, Stream *str,
1831                          int width, int height, GfxImageColorMap *colorMap,
1832                          int *maskColors, GBool inlineImg)
1833 {
1834   msg("<verbose> drawImage %dx%d, %s %s, inline=%d", width, height, 
1835           colorMap?"colorMap":"no colorMap", 
1836           maskColors?"maskColors":"no maskColors",
1837           inlineImg);
1838   if(colorMap)
1839       msg("<verbose> colorMap pixcomps:%d bits:%d mode:%d\n", colorMap->getNumPixelComps(),
1840               colorMap->getBits(),colorMap->getColorSpace()->getMode());
1841   drawGeneralImage(state,ref,str,width,height,colorMap,0,inlineImg,0);
1842 }
1843
1844 SWFOutputDev*output = 0; 
1845
1846 static void printInfoString(Dict *infoDict, char *key, char *fmt) {
1847   Object obj;
1848   GString *s1, *s2;
1849   int i;
1850
1851   if (infoDict->lookup(key, &obj)->isString()) {
1852     s1 = obj.getString();
1853     if ((s1->getChar(0) & 0xff) == 0xfe &&
1854         (s1->getChar(1) & 0xff) == 0xff) {
1855       s2 = new GString();
1856       for (i = 2; i < obj.getString()->getLength(); i += 2) {
1857         if (s1->getChar(i) == '\0') {
1858           s2->append(s1->getChar(i+1));
1859         } else {
1860           delete s2;
1861           s2 = new GString("<unicode>");
1862           break;
1863         }
1864       }
1865       printf(fmt, s2->getCString());
1866       delete s2;
1867     } else {
1868       printf(fmt, s1->getCString());
1869     }
1870   }
1871   obj.free();
1872 }
1873
1874 static void printInfoDate(Dict *infoDict, char *key, char *fmt) {
1875   Object obj;
1876   char *s;
1877
1878   if (infoDict->lookup(key, &obj)->isString()) {
1879     s = obj.getString()->getCString();
1880     if (s[0] == 'D' && s[1] == ':') {
1881       s += 2;
1882     }
1883     printf(fmt, s);
1884   }
1885   obj.free();
1886 }
1887
1888 int jpeg_dpi = 0;
1889 int ppm_dpi = 0;
1890
1891 void pdfswf_setparameter(char*name, char*value)
1892 {
1893     msg("<verbose> setting parameter %s to \"%s\"", name, value);
1894     if(!strcmp(name, "caplinewidth")) {
1895         caplinewidth = atof(value);
1896     } else if(!strcmp(name, "zoom")) {
1897         char buf[80];
1898         zoom = atoi(value);
1899         sprintf(buf, "%f", (double)jpeg_dpi/(double)zoom);
1900         swfoutput_setparameter("jpegsubpixels", buf);
1901         sprintf(buf, "%f", (double)ppm_dpi/(double)zoom);
1902         swfoutput_setparameter("ppmsubpixels", buf);
1903     } else if(!strcmp(name, "jpegdpi")) {
1904         char buf[80];
1905         jpeg_dpi = atoi(value);
1906         sprintf(buf, "%f", (double)jpeg_dpi/(double)zoom);
1907         swfoutput_setparameter("jpegsubpixels", buf);
1908     } else if(!strcmp(name, "ppmdpi")) {
1909         char buf[80];
1910         ppm_dpi = atoi(value);
1911         sprintf(buf, "%f", (double)ppm_dpi/(double)zoom);
1912         swfoutput_setparameter("ppmsubpixels", buf);
1913     } else if(!strcmp(name, "forceType0Fonts")) {
1914         forceType0Fonts = atoi(value);
1915     } else if(!strcmp(name, "fontdir")) {
1916         pdfswf_addfontdir(value);
1917     } else if(!strcmp(name, "languagedir")) {
1918         pdfswf_addlanguagedir(value);
1919     } else if(!strcmp(name, "fontconfig")) {
1920         config_use_fontconfig = atoi(value);
1921     } else {
1922         swfoutput_setparameter(name, value);
1923     }
1924 }
1925 void pdfswf_addfont(char*filename)
1926 {
1927     fontfile_t f;
1928     memset(&f, 0, sizeof(fontfile_t));
1929     f.filename = filename;
1930     if(fontnum < sizeof(fonts)/sizeof(fonts[0])) {
1931         fonts[fontnum++] = f;
1932     } else {
1933         msg("<error> Too many external fonts. Not adding font file \"%s\".", filename);
1934     }
1935 }
1936
1937 static char* dirseparator()
1938 {
1939 #ifdef WIN32
1940     return "\\";
1941 #else
1942     return "/";
1943 #endif
1944 }
1945
1946 void pdfswf_addlanguagedir(char*dir)
1947 {
1948     if(!globalParams)
1949         globalParams = new GlobalParams("");
1950     
1951     msg("<notice> Adding %s to language pack directories", dir);
1952
1953     int l;
1954     FILE*fi = 0;
1955     char* config_file = (char*)malloc(strlen(dir) + 1 + sizeof("add-to-xpdfrc"));
1956     strcpy(config_file, dir);
1957     strcat(config_file, dirseparator());
1958     strcat(config_file, "add-to-xpdfrc");
1959
1960     fi = fopen(config_file, "rb");
1961     if(!fi) {
1962         msg("<error> Could not open %s", config_file);
1963         return;
1964     }
1965     globalParams->parseFile(new GString(config_file), fi);
1966     fclose(fi);
1967 }
1968
1969 void pdfswf_addfontdir(char*dirname)
1970 {
1971 #ifdef HAVE_DIRENT_H
1972     msg("<notice> Adding %s to font directories", dirname);
1973     DIR*dir = opendir(dirname);
1974     if(!dir) {
1975         msg("<warning> Couldn't open directory %s\n", dirname);
1976         return;
1977     }
1978     struct dirent*ent;
1979     while(1) {
1980         ent = readdir (dir);
1981         if (!ent) 
1982             break;
1983         int l;
1984         char*name = ent->d_name;
1985         char type = 0;
1986         if(!name) continue;
1987         l=strlen(name);
1988         if(l<4)
1989             continue;
1990         if(!strncasecmp(&name[l-4], ".pfa", 4)) 
1991             type=1;
1992         if(!strncasecmp(&name[l-4], ".pfb", 4)) 
1993             type=3;
1994         if(!strncasecmp(&name[l-4], ".ttf", 4)) 
1995             type=2;
1996         if(type)
1997         {
1998             char*fontname = (char*)malloc(strlen(dirname)+strlen(name)+2);
1999             strcpy(fontname, dirname);
2000             strcat(fontname, dirseparator());
2001             strcat(fontname, name);
2002             msg("<verbose> Adding %s to fonts", fontname);
2003             pdfswf_addfont(fontname);
2004         }
2005     }
2006     closedir(dir);
2007 #else
2008     msg("<warning> No dirent.h- unable to add font dir %s", dir);
2009 #endif
2010 }
2011
2012
2013 typedef struct _pdf_doc_internal
2014 {
2015     int protect;
2016     PDFDoc*doc;
2017 } pdf_doc_internal_t;
2018 typedef struct _pdf_page_internal
2019 {
2020 } pdf_page_internal_t;
2021 typedef struct _swf_output_internal
2022 {
2023     SWFOutputDev*outputDev;
2024 } swf_output_internal_t;
2025
2026 pdf_doc_t* pdf_init(char*filename, char*userPassword)
2027 {
2028     pdf_doc_t*pdf_doc = (pdf_doc_t*)malloc(sizeof(pdf_doc_t));
2029     memset(pdf_doc, 0, sizeof(pdf_doc_t));
2030     pdf_doc_internal_t*i= (pdf_doc_internal_t*)malloc(sizeof(pdf_doc_internal_t));
2031     memset(i, 0, sizeof(pdf_doc_internal_t));
2032     pdf_doc->internal = i;
2033     
2034     GString *fileName = new GString(filename);
2035     GString *userPW;
2036     Object info;
2037
2038     // read config file
2039     if(!globalParams)
2040         globalParams = new GlobalParams("");
2041
2042     // open PDF file
2043     if (userPassword && userPassword[0]) {
2044       userPW = new GString(userPassword);
2045     } else {
2046       userPW = NULL;
2047     }
2048     i->doc = new PDFDoc(fileName, userPW);
2049     if (userPW) {
2050       delete userPW;
2051     }
2052     if (!i->doc->isOk()) {
2053         return 0;
2054     }
2055
2056     // print doc info
2057     i->doc->getDocInfo(&info);
2058     if (info.isDict() &&
2059       (getScreenLogLevel()>=LOGLEVEL_NOTICE)) {
2060       printInfoString(info.getDict(), "Title",        "Title:        %s\n");
2061       printInfoString(info.getDict(), "Subject",      "Subject:      %s\n");
2062       printInfoString(info.getDict(), "Keywords",     "Keywords:     %s\n");
2063       printInfoString(info.getDict(), "Author",       "Author:       %s\n");
2064       printInfoString(info.getDict(), "Creator",      "Creator:      %s\n");
2065       printInfoString(info.getDict(), "Producer",     "Producer:     %s\n");
2066       printInfoDate(info.getDict(),   "CreationDate", "CreationDate: %s\n");
2067       printInfoDate(info.getDict(),   "ModDate",      "ModDate:      %s\n");
2068       printf("Pages:        %d\n", i->doc->getNumPages());
2069       printf("Linearized:   %s\n", i->doc->isLinearized() ? "yes" : "no");
2070       printf("Encrypted:    ");
2071       if (i->doc->isEncrypted()) {
2072         printf("yes (print:%s copy:%s change:%s addNotes:%s)\n",
2073                i->doc->okToPrint() ? "yes" : "no",
2074                i->doc->okToCopy() ? "yes" : "no",
2075                i->doc->okToChange() ? "yes" : "no",
2076                i->doc->okToAddNotes() ? "yes" : "no");
2077       } else {
2078         printf("no\n");
2079       }
2080     }
2081     info.free();
2082                    
2083     pdf_doc->num_pages = i->doc->getNumPages();
2084     i->protect = 0;
2085     if (i->doc->isEncrypted()) {
2086           if(!i->doc->okToCopy()) {
2087               printf("PDF disallows copying.\n");
2088               return 0;
2089           }
2090           if(!i->doc->okToChange() || !i->doc->okToAddNotes())
2091               i->protect = 1;
2092     }
2093    
2094     return pdf_doc;
2095 }
2096
2097 void pdfswf_preparepage(int page)
2098 {
2099     /*FIXME*/
2100     if(!pages) {
2101         pages = (int*)malloc(1024*sizeof(int));
2102         pagebuflen = 1024;
2103     } else {
2104         if(pagepos == pagebuflen)
2105         {
2106             pagebuflen+=1024;
2107             pages = (int*)realloc(pages, pagebuflen);
2108         }
2109     }
2110     pages[pagepos++] = page;
2111 }
2112
2113 class MemCheck
2114 {
2115     public: ~MemCheck()
2116     {
2117         delete globalParams;globalParams=0;
2118         Object::memCheck(stderr);
2119         gMemReport(stderr);
2120     }
2121 } myMemCheck;
2122
2123 void pdf_destroy(pdf_doc_t*pdf_doc)
2124 {
2125     pdf_doc_internal_t*i= (pdf_doc_internal_t*)pdf_doc->internal;
2126
2127     msg("<debug> pdfswf.cc: pdfswf_close()");
2128     delete i->doc; i->doc=0;
2129     
2130     free(pages); pages = 0; //FIXME
2131
2132     free(pdf_doc->internal);pdf_doc->internal=0;
2133     free(pdf_doc);pdf_doc=0;
2134 }
2135
2136 pdf_page_t* pdf_getpage(pdf_doc_t*pdf_doc, int page)
2137 {
2138     pdf_doc_internal_t*di= (pdf_doc_internal_t*)pdf_doc->internal;
2139
2140     if(page < 1 || page > pdf_doc->num_pages)
2141         return 0;
2142     
2143     pdf_page_t* pdf_page = (pdf_page_t*)malloc(sizeof(pdf_page_t));
2144     pdf_page_internal_t*pi= (pdf_page_internal_t*)malloc(sizeof(pdf_page_internal_t));
2145     memset(pi, 0, sizeof(pdf_page_internal_t));
2146     pdf_page->internal = pi;
2147
2148     pdf_page->parent = pdf_doc;
2149     pdf_page->nr = page;
2150     return pdf_page;
2151 }
2152
2153 void pdf_page_destroy(pdf_page_t*pdf_page)
2154 {
2155     pdf_page_internal_t*i= (pdf_page_internal_t*)pdf_page->internal;
2156     free(pdf_page->internal);pdf_page->internal = 0;
2157     free(pdf_page);pdf_page=0;
2158 }
2159
2160 swf_output_t* swf_output_init() 
2161 {
2162     swf_output_t*swf_output = (swf_output_t*)malloc(sizeof(swf_output_t));
2163     memset(swf_output, 0, sizeof(swf_output_t));
2164     swf_output_internal_t*i= (swf_output_internal_t*)malloc(sizeof(swf_output_internal_t));
2165     memset(i, 0, sizeof(swf_output_internal_t));
2166     swf_output->internal = i;
2167
2168     i->outputDev = new SWFOutputDev();
2169     return swf_output;
2170 }
2171
2172 void swf_output_setparameter(swf_output_t*swf_output, char*name, char*value)
2173 {
2174     /* FIXME */
2175     pdfswf_setparameter(name, value);
2176 }
2177
2178 void swf_output_pagefeed(swf_output_t*swf)
2179 {
2180     swf_output_internal_t*i= (swf_output_internal_t*)swf->internal;
2181     i->outputDev->pagefeed();
2182     i->outputDev->getDimensions(&swf->x1, &swf->y1, &swf->x2, &swf->y2);
2183 }
2184
2185 int swf_output_save(swf_output_t*swf, char*filename)
2186 {
2187     swf_output_internal_t*i= (swf_output_internal_t*)swf->internal;
2188     int ret = i->outputDev->save(filename);
2189     i->outputDev->getDimensions(&swf->x1, &swf->y1, &swf->x2, &swf->y2);
2190     return ret;
2191 }
2192
2193 void* swf_output_get(swf_output_t*swf)
2194 {
2195     swf_output_internal_t*i= (swf_output_internal_t*)swf->internal;
2196     void* ret = i->outputDev->getSWF();
2197     i->outputDev->getDimensions(&swf->x1, &swf->y1, &swf->x2, &swf->y2);
2198     return ret;
2199 }
2200
2201 void swf_output_destroy(swf_output_t*output)
2202 {
2203     swf_output_internal_t*i = (swf_output_internal_t*)output->internal;
2204     delete i->outputDev; i->outputDev=0;
2205     free(output->internal);output->internal=0;
2206     free(output);
2207 }
2208
2209 void pdf_page_render2(pdf_page_t*page, swf_output_t*swf)
2210 {
2211     pdf_doc_internal_t*pi = (pdf_doc_internal_t*)page->parent->internal;
2212     swf_output_internal_t*si = (swf_output_internal_t*)swf->internal;
2213
2214     if(pi->protect) {
2215         swfoutput_setparameter("protect", "1");
2216     }
2217     si->outputDev->setXRef(pi->doc, pi->doc->getXRef());
2218 #ifdef XPDF_101
2219     pi->doc->displayPage((OutputDev*)si->outputDev, page->nr, /*zoom*/zoom, /*rotate*/0, /*doLinks*/(int)1);
2220 #else
2221     pi->doc->displayPage((OutputDev*)si->outputDev, page->nr, zoom, zoom, /*rotate*/0, true, /*doLinks*/(int)1);
2222 #endif
2223     si->outputDev->getDimensions(&swf->x1, &swf->y1, &swf->x2, &swf->y2);
2224 }
2225
2226 void pdf_page_rendersection(pdf_page_t*page, swf_output_t*output, int x, int y, int x1, int y1, int x2, int y2)
2227 {
2228     pdf_doc_internal_t*pi = (pdf_doc_internal_t*)page->parent->internal;
2229     swf_output_internal_t*si = (swf_output_internal_t*)output->internal;
2230
2231     si->outputDev->setMove(x,y);
2232     if((x1|y1|x2|y2)==0) x2++;
2233     si->outputDev->setClip(x1,y1,x2,y2);
2234
2235     pdf_page_render2(page, output);
2236 }
2237 void pdf_page_render(pdf_page_t*page, swf_output_t*output)
2238 {
2239     pdf_doc_internal_t*pi = (pdf_doc_internal_t*)page->parent->internal;
2240     swf_output_internal_t*si = (swf_output_internal_t*)output->internal;
2241     
2242     si->outputDev->setMove(0,0);
2243     si->outputDev->setClip(0,0,0,0);
2244     
2245     pdf_page_render2(page, output);
2246 }
2247
2248
2249 pdf_page_info_t* pdf_page_getinfo(pdf_page_t*page)
2250 {
2251     pdf_doc_internal_t*pi = (pdf_doc_internal_t*)page->parent->internal;
2252     pdf_page_internal_t*i= (pdf_page_internal_t*)page->internal;
2253     pdf_page_info_t*info = (pdf_page_info_t*)malloc(sizeof(pdf_page_info_t));
2254     memset(info, 0, sizeof(pdf_page_info_t));
2255
2256     InfoOutputDev*output = new InfoOutputDev;
2257     
2258 #ifdef XPDF_101
2259     pi->doc->displayPage((OutputDev*)output, page->nr, /*zoom*/zoom, /*rotate*/0, /*doLinks*/(int)1);
2260 #else
2261     pi->doc->displayPage((OutputDev*)output, page->nr, zoom, zoom, /*rotate*/0, true, /*doLinks*/(int)1);
2262 #endif
2263
2264     info->xMin = output->x1;
2265     info->yMin = output->y1;
2266     info->xMax = output->x2;
2267     info->yMax = output->y2;
2268     info->number_of_images = output->num_images;
2269     info->number_of_links = output->num_links;
2270     info->number_of_fonts = output->num_fonts;
2271
2272     delete output;
2273
2274     return info;
2275 }
2276
2277 void pdf_page_info_destroy(pdf_page_info_t*info)
2278 {
2279     free(info);
2280 }