001c137867d2484cc147a1ff05004680d30db236
[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  * Primitive Graphic routines
639  *----------------------------------------------------------------------------*/
640
641 void SWFOutputDev::stroke(GfxState *state) 
642 {
643     GfxPath * path = state->getPath();
644     int lineCap = state->getLineCap(); // 0=butt, 1=round 2=square
645     int lineJoin = state->getLineJoin(); // 0=miter, 1=round 2=bevel
646     double miterLimit = state->getMiterLimit();
647     double width = state->getTransformedLineWidth();
648
649     GfxRGB rgb;
650     double opaq = state->getStrokeOpacity();
651     state->getStrokeRGB(&rgb);
652     gfxcolor_t col;
653     col.r = (unsigned char)(rgb.r*255);
654     col.g = (unsigned char)(rgb.g*255);
655     col.b = (unsigned char)(rgb.b*255);
656     col.a = (unsigned char)(opaq*255);
657     
658     gfx_capType capType = gfx_capRound;
659     if(lineCap == 0) capType = gfx_capButt;
660     else if(lineCap == 1) capType = gfx_capRound;
661     else if(lineCap == 2) capType = gfx_capSquare;
662
663     gfx_joinType joinType = gfx_joinRound;
664     if(lineJoin == 0) joinType = gfx_joinMiter;
665     else if(lineJoin == 1) joinType = gfx_joinRound;
666     else if(lineJoin == 2) joinType = gfx_joinBevel;
667
668     gfxline_t*line= gfxPath_to_gfxline(state, path, 0);
669     
670     int dashnum = 0;
671     double dashstart = 0;
672     double * ldash = 0;
673     state->getLineDash(&ldash, &dashnum, &dashstart);
674     if(dashnum && ldash) {
675         float * dash = (float*)malloc(sizeof(float)*(dashnum+2));
676         dash[0] = dashstart;
677         int t;
678         for(t=0;t<dashnum;t++) {
679             dash[t+1] = ldash[t];
680         }
681         dash[dashnum+1] = 0;
682
683         gfxline_t*line2 = gfxtool_dash_line(line, dash);
684         gfxline_free(line);
685         line = line2;
686     }
687     
688     if(getLogLevel() >= LOGLEVEL_TRACE)  {
689         msg("<trace> stroke width=%f join=%s cap=%s dashes=%d\n",
690                 width,
691                 lineJoin==0?"miter": (lineJoin==1?"round":"bevel"),
692                 lineCap==0?"butt": (lineJoin==1?"round":"square"),
693                 dashnum
694                 );
695         //gfxline_show(line, stdout);
696     }
697    
698     swfoutput_drawgfxline(&output, line, width, &col, capType, joinType, miterLimit);
699     gfxline_free(line);
700 }
701 void SWFOutputDev::fill(GfxState *state) 
702 {
703     GfxPath * path = state->getPath();
704     double opaq = state->getFillOpacity();
705     GfxRGB rgb;
706     state->getFillRGB(&rgb);
707     gfxcolor_t col;
708     col.r = (unsigned char)(rgb.r*255);
709     col.g = (unsigned char)(rgb.g*255);
710     col.b = (unsigned char)(rgb.b*255);
711     col.a = (unsigned char)(opaq*255);
712
713     gfxline_t*line= gfxPath_to_gfxline(state, path, 1);
714
715     if(getLogLevel() >= LOGLEVEL_TRACE)  {
716         msg("<trace> fill\n");
717         //dump_outline(line);
718     }
719
720     swfoutput_fillgfxline(&output, line, &col);
721     gfxline_free(line);
722 }
723 void SWFOutputDev::eoFill(GfxState *state) 
724 {
725     GfxPath * path = state->getPath();
726     double opaq = state->getFillOpacity();
727     GfxRGB rgb;
728     state->getFillRGB(&rgb);
729     gfxcolor_t col;
730     col.r = (unsigned char)(rgb.r*255);
731     col.g = (unsigned char)(rgb.g*255);
732     col.b = (unsigned char)(rgb.b*255);
733     col.a = (unsigned char)(opaq*255);
734
735     gfxline_t*line= gfxPath_to_gfxline(state, path, 1);
736
737     if(getLogLevel() >= LOGLEVEL_TRACE)  {
738         msg("<trace> eofill\n");
739         //dump_outline(line);
740     }
741
742     swfoutput_fillgfxline(&output, line, &col);
743     gfxline_free(line);
744 }
745 void SWFOutputDev::clip(GfxState *state) 
746 {
747     GfxPath * path = state->getPath();
748     gfxline_t*line = gfxPath_to_gfxline(state, path, 1);
749
750     if(getLogLevel() >= LOGLEVEL_TRACE)  {
751         msg("<trace> clip\n");
752         //dump_outline(line);
753     }
754
755     swfoutput_startclip(&output, line);
756     clipping[clippos] ++;
757     gfxline_free(line);
758 }
759 void SWFOutputDev::eoClip(GfxState *state) 
760 {
761     GfxPath * path = state->getPath();
762     gfxline_t*line = gfxPath_to_gfxline(state, path, 1);
763
764     if(getLogLevel() >= LOGLEVEL_TRACE)  {
765         msg("<trace> eoclip\n");
766         //dump_outline(line);
767     }
768
769     swfoutput_startclip(&output, line);
770     clipping[clippos] ++;
771     gfxline_free(line);
772 }
773
774 /* pass through functions for swf_output */
775 int SWFOutputDev::save(char*filename)
776 {
777     return swfoutput_save(&output, filename);
778 }
779 void SWFOutputDev::pagefeed()
780 {
781     swfoutput_pagefeed(&output);
782 }
783 void* SWFOutputDev::getSWF()
784 {
785     return (void*)swfoutput_get(&output);
786 }
787
788 SWFOutputDev::~SWFOutputDev() 
789 {
790     swfoutput_destroy(&output);
791     outputstarted = 0;
792 };
793 GBool SWFOutputDev::upsideDown() 
794 {
795     msg("<debug> upsidedown? yes");
796     return gTrue;
797 };
798 GBool SWFOutputDev::useDrawChar() 
799 {
800     return gTrue;
801 }
802 GBool SWFOutputDev::useGradients()
803 {
804     if(!gradientinfo)
805     {
806         msg("<notice> File contains gradients");
807         gradientinfo = 1;
808     }
809     return gTrue;
810 }
811
812 void SWFOutputDev::beginString(GfxState *state, GString *s) 
813
814     double m11,m21,m12,m22;
815 //    msg("<debug> %s beginstring \"%s\"\n", gfxstate2str(state), s->getCString());
816     state->getFontTransMat(&m11, &m12, &m21, &m22);
817     m11 *= state->getHorizScaling();
818     m21 *= state->getHorizScaling();
819     swfoutput_setfontmatrix(&output, m11, -m21, m12, -m22);
820 }
821
822 void SWFOutputDev::drawChar(GfxState *state, double x, double y,
823                         double dx, double dy,
824                         double originX, double originY,
825                         CharCode c, Unicode *_u, int uLen)
826 {
827     // check for invisible text -- this is used by Acrobat Capture
828     if ((state->getRender() & 3) == 3)
829         return;
830     GfxRGB rgb;
831     double opaq = state->getFillOpacity();
832     state->getFillRGB(&rgb);
833     gfxcolor_t col;
834     col.r = (unsigned char)(rgb.r*255);
835     col.g = (unsigned char)(rgb.g*255);
836     col.b = (unsigned char)(rgb.b*255);
837     col.a = (unsigned char)(opaq*255);
838
839     Gushort *CIDToGIDMap = 0;
840     GfxFont*font = state->getFont();
841
842     if(font->getType() == fontType3) {
843         /* type 3 chars are passed as graphics */
844         return;
845     }
846     double x1,y1;
847     x1 = x;
848     y1 = y;
849     state->transform(x, y, &x1, &y1);
850     
851     Unicode u=0;
852     char*name=0;
853
854     if(_u && uLen) {
855         u = *_u;
856         if (u) {
857             int t;
858             /* find out char name from unicode index 
859                TODO: should be precomputed
860              */
861             for(t=0;t<sizeof(nameToUnicodeTab)/sizeof(nameToUnicodeTab[0]);t++) {
862                 if(nameToUnicodeTab[t].u == u) {
863                     name = nameToUnicodeTab[t].name;
864                     break;
865                 }
866             }
867         }
868     }
869
870     if(font->isCIDFont()) {
871         GfxCIDFont*cfont = (GfxCIDFont*)font;
872
873         if(font->getType() == fontCIDType2) {
874             CIDToGIDMap = cfont->getCIDToGID();
875         }
876     } else {
877         Gfx8BitFont*font8;
878         font8 = (Gfx8BitFont*)font;
879         char**enc=font8->getEncoding();
880         if(enc && enc[c])
881            name = enc[c];
882     }
883  
884     if (CIDToGIDMap) {
885         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));
886         swfoutput_drawchar(&output, x1, y1, name, CIDToGIDMap[c], u, &col);
887     } else {
888         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));
889         swfoutput_drawchar(&output, x1, y1, name, c, u, &col);
890     }
891 }
892
893 void SWFOutputDev::endString(GfxState *state) { 
894 }    
895
896  
897 GBool SWFOutputDev::beginType3Char(GfxState *state,
898                                CharCode code, Unicode *u, int uLen)
899 {
900     msg("<debug> beginType3Char %d, %08x, %d", code, *u, uLen);
901     type3active = 1;
902     /* the character itself is going to be passed using
903        drawImageMask() */
904     return gFalse; /* gTrue= is_in_cache? */
905 }
906
907 void SWFOutputDev::endType3Char(GfxState *state)
908 {
909     type3active = 0;
910     msg("<debug> endType3Char");
911 }
912
913 void SWFOutputDev::startPage(int pageNum, GfxState *state, double crop_x1, double crop_y1, double crop_x2, double crop_y2) 
914 {
915     this->currentpage = pageNum;
916     double x1,y1,x2,y2;
917     int rot = doc->getPageRotate(1);
918     laststate = state;
919     msg("<verbose> startPage %d (%f,%f,%f,%f)\n", pageNum, crop_x1, crop_y1, crop_x2, crop_y2);
920     if(rot!=0)
921         msg("<verbose> page is rotated %d degrees\n", rot);
922
923     /* state->transform(state->getX1(),state->getY1(),&x1,&y1);
924     state->transform(state->getX2(),state->getY2(),&x2,&y2);
925     Use CropBox, not MediaBox, as page size
926     */
927     
928     /*x1 = crop_x1;
929     y1 = crop_y1;
930     x2 = crop_x2;
931     y2 = crop_y2;*/
932     state->transform(crop_x1,crop_y1,&x1,&y1);
933     state->transform(crop_x2,crop_y2,&x2,&y2);
934
935     if(x2<x1) {double x3=x1;x1=x2;x2=x3;}
936     if(y2<y1) {double y3=y1;y1=y2;y2=y3;}
937
938     /* apply user clip box */
939     if(user_clipx1|user_clipy1|user_clipx2|user_clipy2) {
940         /*if(user_clipx1 > x1)*/ x1 = user_clipx1;
941         /*if(user_clipx2 < x2)*/ x2 = user_clipx2;
942         /*if(user_clipy1 > y1)*/ y1 = user_clipy1;
943         /*if(user_clipy2 < y2)*/ y2 = user_clipy2;
944     }
945
946     if(!outputstarted) {
947         msg("<verbose> Bounding box is (%f,%f)-(%f,%f)", x1,y1,x2,y2);
948         swfoutput_init(&output);
949         outputstarted = 1;
950     }
951       
952     swfoutput_newpage(&output, pageNum, user_movex, user_movey, (int)x1, (int)y1, (int)x2, (int)y2);
953 }
954
955 void SWFOutputDev::drawLink(Link *link, Catalog *catalog) 
956 {
957     msg("<debug> drawlink\n");
958     double x1, y1, x2, y2, w;
959     GfxRGB rgb;
960     swfcoord points[5];
961     int x, y;
962
963 #ifdef XPDF_101
964     link->getBorder(&x1, &y1, &x2, &y2, &w);
965 #else
966     link->getRect(&x1, &y1, &x2, &y2);
967 #endif
968     rgb.r = 0;
969     rgb.g = 0;
970     rgb.b = 1;
971     cvtUserToDev(x1, y1, &x, &y);
972     points[0].x = points[4].x = (int)x;
973     points[0].y = points[4].y = (int)y;
974     cvtUserToDev(x2, y1, &x, &y);
975     points[1].x = (int)x;
976     points[1].y = (int)y;
977     cvtUserToDev(x2, y2, &x, &y);
978     points[2].x = (int)x;
979     points[2].y = (int)y;
980     cvtUserToDev(x1, y2, &x, &y);
981     points[3].x = (int)x;
982     points[3].y = (int)y;
983
984     LinkAction*action=link->getAction();
985     char buf[128];
986     char*s = 0;
987     char*type = "-?-";
988     char*url = 0;
989     char*named = 0;
990     int page = -1;
991     switch(action->getKind())
992     {
993         case actionGoTo: {
994             type = "GoTo";
995             LinkGoTo *ha=(LinkGoTo *)link->getAction();
996             LinkDest *dest=NULL;
997             if (ha->getDest()==NULL) 
998                 dest=catalog->findDest(ha->getNamedDest());
999             else dest=ha->getDest();
1000             if (dest){ 
1001               if (dest->isPageRef()){
1002                 Ref pageref=dest->getPageRef();
1003                 page=catalog->findPage(pageref.num,pageref.gen);
1004               }
1005               else  page=dest->getPageNum();
1006               sprintf(buf, "%d", page);
1007               s = strdup(buf);
1008             }
1009         }
1010         break;
1011         case actionGoToR: {
1012             type = "GoToR";
1013             LinkGoToR*l = (LinkGoToR*)action;
1014             GString*g = l->getNamedDest();
1015             if(g)
1016              s = strdup(g->getCString());
1017         }
1018         break;
1019         case actionNamed: {
1020             type = "Named";
1021             LinkNamed*l = (LinkNamed*)action;
1022             GString*name = l->getName();
1023             if(name) {
1024                 s = strdup(name->lowerCase()->getCString());
1025                 named = name->getCString();
1026                 if(!strchr(s,':')) 
1027                 {
1028                     if(strstr(s, "next") || strstr(s, "forward"))
1029                     {
1030                         page = currentpage + 1;
1031                     }
1032                     else if(strstr(s, "prev") || strstr(s, "back"))
1033                     {
1034                         page = currentpage - 1;
1035                     }
1036                     else if(strstr(s, "last") || strstr(s, "end"))
1037                     {
1038                         page = pagepos>0?pages[pagepos-1]:0;
1039                     }
1040                     else if(strstr(s, "first") || strstr(s, "top"))
1041                     {
1042                         page = 1;
1043                     }
1044                 }
1045             }
1046         }
1047         break;
1048         case actionLaunch: {
1049             type = "Launch";
1050             LinkLaunch*l = (LinkLaunch*)action;
1051             GString * str = new GString(l->getFileName());
1052             str->append(l->getParams());
1053             s = strdup(str->getCString());
1054             delete str;
1055         }
1056         break;
1057         case actionURI: {
1058             type = "URI";
1059             LinkURI*l = (LinkURI*)action;
1060             GString*g = l->getURI();
1061             if(g) {
1062              url = g->getCString();
1063              s = strdup(url);
1064             }
1065         }
1066         break;
1067         case actionUnknown: {
1068             type = "Unknown";
1069             LinkUnknown*l = (LinkUnknown*)action;
1070             s = strdup("");
1071         }
1072         break;
1073         default: {
1074             msg("<error> Unknown link type!\n");
1075             break;
1076         }
1077     }
1078     if(!s) s = strdup("-?-");
1079
1080     if(!linkinfo && (page || url))
1081     {
1082         msg("<notice> File contains links");
1083         linkinfo = 1;
1084     }
1085     if(page>0)
1086     {
1087         int t;
1088         for(t=0;t<pagepos;t++)
1089             if(pages[t]==page)
1090                 break;
1091         if(t!=pagepos)
1092             swfoutput_linktopage(&output, t, points);
1093     }
1094     else if(url)
1095     {
1096         swfoutput_linktourl(&output, url, points);
1097     }
1098     else if(named)
1099     {
1100         swfoutput_namedlink(&output, named, points);
1101     }
1102     msg("<verbose> \"%s\" link to \"%s\" (%d)\n", type, FIXNULL(s), page);
1103     free(s);s=0;
1104 }
1105
1106 void SWFOutputDev::saveState(GfxState *state) {
1107   msg("<debug> saveState\n");
1108   updateAll(state);
1109   if(clippos<64)
1110     clippos ++;
1111   else
1112     msg("<error> Too many nested states in pdf.");
1113   clipping[clippos] = 0;
1114 };
1115
1116 void SWFOutputDev::restoreState(GfxState *state) {
1117   msg("<debug> restoreState\n");
1118   updateAll(state);
1119   while(clipping[clippos]) {
1120       swfoutput_endclip(&output);
1121       clipping[clippos]--;
1122   }
1123   clippos--;
1124 }
1125
1126 char* SWFOutputDev::searchFont(char*name) 
1127 {       
1128     int i;
1129     char*filename=0;
1130     int is_standard_font = 0;
1131         
1132     msg("<verbose> SearchFont(%s)", name);
1133
1134     /* see if it is a pdf standard font */
1135     for(i=0;i<sizeof(pdf2t1map)/sizeof(mapping);i++) 
1136     {
1137         if(!strcmp(name, pdf2t1map[i].pdffont))
1138         {
1139             name = pdf2t1map[i].filename;
1140             is_standard_font = 1;
1141             break;
1142         }
1143     }
1144     /* look in all font files */
1145     for(i=0;i<fontnum;i++) 
1146     {
1147         if(strstr(fonts[i].filename, name))
1148         {
1149             if(!fonts[i].used) {
1150
1151                 fonts[i].used = 1;
1152                 if(!is_standard_font)
1153                     msg("<notice> Using %s for %s", fonts[i].filename, name);
1154             }
1155             return strdup(fonts[i].filename);
1156         }
1157     }
1158     return 0;
1159 }
1160
1161 void SWFOutputDev::updateLineWidth(GfxState *state)
1162 {
1163     double width = state->getTransformedLineWidth();
1164     //swfoutput_setlinewidth(&output, width);
1165 }
1166
1167 void SWFOutputDev::updateLineCap(GfxState *state)
1168 {
1169     int c = state->getLineCap();
1170 }
1171
1172 void SWFOutputDev::updateLineJoin(GfxState *state)
1173 {
1174     int j = state->getLineJoin();
1175 }
1176
1177 void SWFOutputDev::updateFillColor(GfxState *state) 
1178 {
1179     GfxRGB rgb;
1180     double opaq = state->getFillOpacity();
1181     state->getFillRGB(&rgb);
1182
1183     //swfoutput_setfillcolor(&output, (char)(rgb.r*255), (char)(rgb.g*255), (char)(rgb.b*255), (char)(opaq*255));
1184 }
1185
1186 void SWFOutputDev::updateStrokeColor(GfxState *state) 
1187 {
1188     GfxRGB rgb;
1189     double opaq = state->getStrokeOpacity();
1190     state->getStrokeRGB(&rgb);
1191
1192     //swfoutput_setstrokecolor(&output, (char)(rgb.r*255), (char)(rgb.g*255), (char)(rgb.b*255), (char)(opaq*255));
1193 }
1194
1195 void FoFiWrite(void *stream, char *data, int len)
1196 {
1197    fwrite(data, len, 1, (FILE*)stream);
1198 }
1199
1200 char*SWFOutputDev::writeEmbeddedFontToFile(XRef*ref, GfxFont*font)
1201 {
1202     char*tmpFileName = NULL;
1203     FILE *f;
1204     int c;
1205     char *fontBuf;
1206     int fontLen;
1207     Ref embRef;
1208     Object refObj, strObj;
1209     char namebuf[512];
1210     tmpFileName = mktmpname(namebuf);
1211     int ret;
1212
1213     ret = font->getEmbeddedFontID(&embRef);
1214     if(!ret) {
1215         msg("<verbose> Didn't get embedded font id");
1216         /* not embedded- the caller should now search the font
1217            directories for this font */
1218         return 0;
1219     }
1220
1221     f = fopen(tmpFileName, "wb");
1222     if (!f) {
1223       msg("<error> Couldn't create temporary Type 1 font file");
1224         return 0;
1225     }
1226
1227     /*if(font->isCIDFont()) {
1228         GfxCIDFont* cidFont = (GfxCIDFont *)font;
1229         GString c = cidFont->getCollection();
1230         msg("<notice> Collection: %s", c.getCString());
1231     }*/
1232
1233     if (font->getType() == fontType1C ||
1234         font->getType() == fontCIDType0C) {
1235       if (!(fontBuf = font->readEmbFontFile(xref, &fontLen))) {
1236         fclose(f);
1237         msg("<error> Couldn't read embedded font file");
1238         return 0;
1239       }
1240 #ifdef XPDF_101
1241       Type1CFontFile *cvt = new Type1CFontFile(fontBuf, fontLen);
1242       if(!cvt) return 0;
1243       cvt->convertToType1(f);
1244 #else
1245       FoFiType1C *cvt = FoFiType1C::make(fontBuf, fontLen);
1246       if(!cvt) return 0;
1247       cvt->convertToType1(NULL, gTrue, FoFiWrite, f);
1248 #endif
1249       //cvt->convertToCIDType0("test", f);
1250       //cvt->convertToType0("test", f);
1251       delete cvt;
1252       gfree(fontBuf);
1253     } else if(font->getType() == fontTrueType) {
1254       msg("<verbose> writing font using TrueTypeFontFile::writeTTF");
1255       if (!(fontBuf = font->readEmbFontFile(xref, &fontLen))) {
1256         fclose(f);
1257         msg("<error> Couldn't read embedded font file");
1258         return 0;
1259       }
1260 #ifdef XPDF_101
1261       TrueTypeFontFile *cvt = new TrueTypeFontFile(fontBuf, fontLen);
1262       cvt->writeTTF(f);
1263 #else
1264       FoFiTrueType *cvt = FoFiTrueType::make(fontBuf, fontLen);
1265       cvt->writeTTF(FoFiWrite, f);
1266 #endif
1267       delete cvt;
1268       gfree(fontBuf);
1269     } else {
1270       font->getEmbeddedFontID(&embRef);
1271       refObj.initRef(embRef.num, embRef.gen);
1272       refObj.fetch(ref, &strObj);
1273       refObj.free();
1274       strObj.streamReset();
1275       int f4[4];
1276       char f4c[4];
1277       int t;
1278       for(t=0;t<4;t++) {
1279           f4[t] = strObj.streamGetChar();
1280           f4c[t] = (char)f4[t];
1281           if(f4[t] == EOF)
1282               break;
1283       }
1284       if(t==4) {
1285           if(!strncmp(f4c, "true", 4)) {
1286               /* some weird TTF fonts don't start with 0,1,0,0 but with "true".
1287                  Change this on the fly */
1288               f4[0] = f4[2] = f4[3] = 0;
1289               f4[1] = 1;
1290           }
1291           fputc(f4[0], f);
1292           fputc(f4[1], f);
1293           fputc(f4[2], f);
1294           fputc(f4[3], f);
1295
1296           while ((c = strObj.streamGetChar()) != EOF) {
1297             fputc(c, f);
1298           }
1299       }
1300       strObj.streamClose();
1301       strObj.free();
1302     }
1303     fclose(f);
1304
1305     return strdup(tmpFileName);
1306 }
1307     
1308 char* searchForSuitableFont(GfxFont*gfxFont)
1309 {
1310     char*name = getFontName(gfxFont);
1311     char*fontname = 0;
1312     char*filename = 0;
1313
1314     if(!config_use_fontconfig)
1315         return 0;
1316     
1317 #ifdef HAVE_FONTCONFIG
1318     FcPattern *pattern, *match;
1319     FcResult result;
1320     FcChar8 *v;
1321
1322     static int fcinitcalled = false; 
1323         
1324     msg("<debug> searchForSuitableFont(%s)", name);
1325     
1326     // call init ony once
1327     if (!fcinitcalled) {
1328         msg("<debug> Initializing FontConfig...");
1329         fcinitcalled = true;
1330         if(FcInit()) {
1331             msg("<debug> FontConfig Initialization failed. Disabling.");
1332             config_use_fontconfig = 0;
1333             return 0;
1334         }
1335         msg("<debug> ...initialized FontConfig");
1336     }
1337    
1338     msg("<debug> FontConfig: Create \"%s\" Family Pattern", name);
1339     pattern = FcPatternBuild(NULL, FC_FAMILY, FcTypeString, name, NULL);
1340     if (gfxFont->isItalic()) // check for italic
1341         msg("<debug> FontConfig: Adding Italic Slant");
1342         FcPatternAddInteger(pattern, FC_SLANT, FC_SLANT_ITALIC);
1343     if (gfxFont->isBold()) // check for bold
1344         msg("<debug> FontConfig: Adding Bold Weight");
1345         FcPatternAddInteger(pattern, FC_WEIGHT, FC_WEIGHT_BOLD);
1346
1347     msg("<debug> FontConfig: Try to match...");
1348     // configure and match using the original font name 
1349     FcConfigSubstitute(0, pattern, FcMatchPattern); 
1350     FcDefaultSubstitute(pattern);
1351     match = FcFontMatch(0, pattern, &result);
1352     
1353     if (FcPatternGetString(match, "family", 0, &v) == FcResultMatch) {
1354         msg("<debug> FontConfig: family=%s", (char*)v);
1355         // if we get an exact match
1356         if (strcmp((char *)v, name) == 0) {
1357             if (FcPatternGetString(match, "file", 0, &v) == FcResultMatch) {
1358                 filename = strdup((char*)v);
1359                 char *nfn = strrchr(filename, '/');
1360                 if(nfn) fontname = strdup(nfn+1);
1361                 else    fontname = filename;
1362             }
1363             msg("<debug> FontConfig: Returning \"%s\"", fontname);
1364         } else {
1365             // initialize patterns
1366             FcPatternDestroy(pattern);
1367             FcPatternDestroy(match);
1368
1369             // now match against serif etc.
1370             if (gfxFont->isSerif()) {
1371                 msg("<debug> FontConfig: Create Serif Family Pattern");
1372                 pattern = FcPatternBuild (NULL, FC_FAMILY, FcTypeString, "serif", NULL);
1373             } else if (gfxFont->isFixedWidth()) {
1374                 msg("<debug> FontConfig: Create Monospace Family Pattern");
1375                 pattern = FcPatternBuild (NULL, FC_FAMILY, FcTypeString, "monospace", NULL);
1376             } else {
1377                 msg("<debug> FontConfig: Create Sans Family Pattern");
1378                 pattern = FcPatternBuild (NULL, FC_FAMILY, FcTypeString, "sans", NULL);
1379             }
1380
1381             // check for italic
1382             if (gfxFont->isItalic()) {
1383                 msg("<debug> FontConfig: Adding Italic Slant");
1384                 int bb = FcPatternAddInteger(pattern, FC_SLANT, FC_SLANT_ITALIC);
1385             }
1386             // check for bold
1387             if (gfxFont->isBold()) {
1388                 msg("<debug> FontConfig: Adding Bold Weight");
1389                 int bb = FcPatternAddInteger(pattern, FC_WEIGHT, FC_WEIGHT_BOLD);
1390             }
1391
1392             msg("<debug> FontConfig: Try to match... (2)");
1393             // configure and match using serif etc
1394             FcConfigSubstitute (0, pattern, FcMatchPattern);
1395             FcDefaultSubstitute (pattern);
1396             match = FcFontMatch (0, pattern, &result);
1397             
1398             if (FcPatternGetString(match, "file", 0, &v) == FcResultMatch) {
1399                 filename = strdup((char*)v);
1400                 char *nfn = strrchr(filename, '/');
1401                 if(nfn) fontname = strdup(nfn+1);
1402                 else    fontname = filename;
1403             }
1404             msg("<debug> FontConfig: Returning \"%s\"", fontname);
1405         }        
1406     }
1407
1408     //printf("FONTCONFIG: pattern");
1409     //FcPatternPrint(pattern);
1410     //printf("FONTCONFIG: match");
1411     //FcPatternPrint(match);
1412  
1413     FcPatternDestroy(pattern);
1414     FcPatternDestroy(match);
1415
1416     pdfswf_addfont(filename);
1417     return fontname;
1418 #else
1419     return 0;
1420 #endif
1421 }
1422
1423 char* SWFOutputDev::substituteFont(GfxFont*gfxFont, char* oldname)
1424 {
1425     char*fontname = 0, *filename = 0;
1426     msg("<notice> subsituteFont(%s)", oldname);
1427
1428     if(!(fontname = searchForSuitableFont(gfxFont))) {
1429         fontname = "Times-Roman";
1430     }
1431     filename = searchFont(fontname);
1432     if(!filename) {
1433         msg("<error> Couldn't find font %s- did you install the default fonts?");
1434         return 0;
1435     }
1436
1437     if(substitutepos>=sizeof(substitutesource)/sizeof(char*)) {
1438         msg("<fatal> Too many fonts in file.");
1439         exit(1);
1440     }
1441     if(oldname) {
1442         substitutesource[substitutepos] = oldname;
1443         substitutetarget[substitutepos] = fontname;
1444         msg("<notice> substituting %s -> %s", FIXNULL(oldname), FIXNULL(fontname));
1445         substitutepos ++;
1446     }
1447     return strdup(filename);
1448 }
1449
1450 void unlinkfont(char* filename)
1451 {
1452     int l;
1453     if(!filename)
1454         return;
1455     l=strlen(filename);
1456     unlink(filename);
1457     if(!strncmp(&filename[l-4],".afm",4)) {
1458         memcpy(&filename[l-4],".pfb",4);
1459         unlink(filename);
1460         memcpy(&filename[l-4],".pfa",4);
1461         unlink(filename);
1462         memcpy(&filename[l-4],".afm",4);
1463         return;
1464     } else 
1465     if(!strncmp(&filename[l-4],".pfa",4)) {
1466         memcpy(&filename[l-4],".afm",4);
1467         unlink(filename);
1468         memcpy(&filename[l-4],".pfa",4);
1469         return;
1470     } else 
1471     if(!strncmp(&filename[l-4],".pfb",4)) {
1472         memcpy(&filename[l-4],".afm",4);
1473         unlink(filename);
1474         memcpy(&filename[l-4],".pfb",4);
1475         return;
1476     }
1477 }
1478
1479 void SWFOutputDev::setXRef(PDFDoc*doc, XRef *xref) 
1480 {
1481     this->doc = doc;
1482     this->xref = xref;
1483 }
1484
1485
1486 void SWFOutputDev::updateFont(GfxState *state) 
1487 {
1488     GfxFont*gfxFont = state->getFont();
1489       
1490     if (!gfxFont) {
1491         return;
1492     }  
1493     char * fontid = getFontID(gfxFont);
1494     
1495     int t;
1496     /* first, look if we substituted this font before-
1497        this way, we don't initialize the T1 Fonts
1498        too often */
1499     for(t=0;t<substitutepos;t++) {
1500         if(!strcmp(fontid, substitutesource[t])) {
1501             fontid = substitutetarget[t];
1502             break;
1503         }
1504     }
1505
1506     /* second, see if swfoutput already has this font
1507        cached- if so, we are done */
1508     if(swfoutput_queryfont(&output, fontid))
1509     {
1510         swfoutput_setfont(&output, fontid, 0);
1511         
1512         msg("<debug> updateFont(%s) [cached]", fontid);
1513         return;
1514     }
1515
1516     // look for Type 3 font
1517     if (gfxFont->getType() == fontType3) {
1518         if(!type3Warning) {
1519             type3Warning = gTrue;
1520             showFontError(gfxFont, 2);
1521         }
1522         return;
1523     }
1524
1525     /* now either load the font, or find a substitution */
1526
1527     Ref embRef;
1528     GBool embedded = gfxFont->getEmbeddedFontID(&embRef);
1529
1530     char*fileName = 0;
1531     int del = 0;
1532     if(embedded &&
1533        (gfxFont->getType() == fontType1 ||
1534         gfxFont->getType() == fontType1C ||
1535        (gfxFont->getType() == fontCIDType0C && forceType0Fonts) ||
1536         gfxFont->getType() == fontTrueType ||
1537         gfxFont->getType() == fontCIDType2
1538        ))
1539     {
1540       fileName = writeEmbeddedFontToFile(xref, gfxFont);
1541       if(!fileName) showFontError(gfxFont,0);
1542       else del = 1;
1543     } else {
1544       char * fontname = getFontName(gfxFont);
1545       fileName = searchFont(fontname);
1546       if(!fileName) showFontError(gfxFont,0);
1547     }
1548     if(!fileName) {
1549         char * fontname = getFontName(gfxFont);
1550         msg("<warning> Font %s %scould not be loaded.", fontname, embedded?"":"(not embedded) ");
1551         msg("<warning> Try putting a TTF version of that font (named \"%s.ttf\") into /swftools/fonts", fontname);
1552         fileName = substituteFont(gfxFont, fontid);
1553         if(fontid) { fontid = substitutetarget[substitutepos-1]; /*ugly hack*/};
1554         msg("<notice> Font is now %s (%s)", fontid, fileName);
1555     }
1556
1557     if(!fileName) {
1558         msg("<error> Couldn't set font %s\n", fontid);
1559         return;
1560     }
1561         
1562     msg("<verbose> updateFont(%s) -> %s", fontid, fileName);
1563     dumpFontInfo("<verbose>", gfxFont);
1564
1565     swfoutput_setfont(&output, fontid, fileName);
1566    
1567     if(fileName && del)
1568         unlinkfont(fileName);
1569     if(fileName)
1570         free(fileName);
1571 }
1572
1573 #define SQR(x) ((x)*(x))
1574
1575 unsigned char* antialize(unsigned char*data, int width, int height, int newwidth, int newheight, int palettesize)
1576 {
1577     if((newwidth<2 || newheight<2) ||
1578        (width<=newwidth || height<=newheight))
1579         return 0;
1580     unsigned char*newdata;
1581     int x,y;
1582     newdata= (unsigned char*)malloc(newwidth*newheight);
1583     int t;
1584     double fx = (double)(width)/newwidth;
1585     double fy = (double)(height)/newheight;
1586     double px = 0;
1587     int blocksize = (int)(8192/(fx*fy));
1588     int r = 8192*256/palettesize;
1589     for(x=0;x<newwidth;x++) {
1590         double ex = px + fx;
1591         int fromx = (int)px;
1592         int tox = (int)ex;
1593         int xweight1 = (int)(((fromx+1)-px)*256);
1594         int xweight2 = (int)((ex-tox)*256);
1595         double py =0;
1596         for(y=0;y<newheight;y++) {
1597             double ey = py + fy;
1598             int fromy = (int)py;
1599             int toy = (int)ey;
1600             int yweight1 = (int)(((fromy+1)-py)*256);
1601             int yweight2 = (int)((ey-toy)*256);
1602             int a = 0;
1603             int xx,yy;
1604             for(xx=fromx;xx<=tox;xx++)
1605             for(yy=fromy;yy<=toy;yy++) {
1606                 int b = 1-data[width*yy+xx];
1607                 int weight=256;
1608                 if(xx==fromx) weight = (weight*xweight1)/256;
1609                 if(xx==tox) weight = (weight*xweight2)/256;
1610                 if(yy==fromy) weight = (weight*yweight1)/256;
1611                 if(yy==toy) weight = (weight*yweight2)/256;
1612                 a+=b*weight;
1613             }
1614             //if(a) a=(palettesize-1)*r/blocksize;
1615             newdata[y*newwidth+x] = (a*blocksize)/r;
1616             py = ey;
1617         }
1618         px = ex;
1619     }
1620     return newdata;
1621 }
1622
1623 void SWFOutputDev::drawGeneralImage(GfxState *state, Object *ref, Stream *str,
1624                                    int width, int height, GfxImageColorMap*colorMap, GBool invert,
1625                                    GBool inlineImg, int mask)
1626 {
1627   FILE *fi;
1628   int c;
1629   char fileName[128];
1630   double x1,y1,x2,y2,x3,y3,x4,y4;
1631   ImageStream *imgStr;
1632   Guchar pixBuf[4];
1633   GfxRGB rgb;
1634   int ncomps = 1;
1635   int bits = 1;
1636                                  
1637   if(colorMap) {
1638     ncomps = colorMap->getNumPixelComps();
1639     bits = colorMap->getBits();
1640   }
1641   imgStr = new ImageStream(str, width, ncomps,bits);
1642   imgStr->reset();
1643
1644   if(!width || !height || (height<=1 && width<=1))
1645   {
1646       msg("<verbose> Ignoring %d by %d image", width, height);
1647       unsigned char buf[8];
1648       int x,y;
1649       for (y = 0; y < height; ++y)
1650       for (x = 0; x < width; ++x) {
1651           imgStr->getPixel(buf);
1652       }
1653       delete imgStr;
1654       return;
1655   }
1656   
1657   state->transform(0, 1, &x1, &y1);
1658   state->transform(0, 0, &x2, &y2);
1659   state->transform(1, 0, &x3, &y3);
1660   state->transform(1, 1, &x4, &y4);
1661
1662   if(!pbminfo && !(str->getKind()==strDCT)) {
1663       if(!type3active) {
1664           msg("<notice> file contains pbm pictures %s",mask?"(masked)":"");
1665           pbminfo = 1;
1666       }
1667       if(mask)
1668       msg("<verbose> drawing %d by %d masked picture\n", width, height);
1669   }
1670   if(!jpeginfo && (str->getKind()==strDCT)) {
1671       msg("<notice> file contains jpeg pictures");
1672       jpeginfo = 1;
1673   }
1674
1675   if(mask) {
1676       int i,j;
1677       unsigned char buf[8];
1678       int x,y;
1679       unsigned char*pic = new unsigned char[width*height];
1680       RGBA pal[256];
1681       GfxRGB rgb;
1682       state->getFillRGB(&rgb);
1683
1684       memset(pal,255,sizeof(pal));
1685       pal[0].r = (int)(rgb.r*255); pal[1].r = 0;
1686       pal[0].g = (int)(rgb.g*255); pal[1].g = 0;
1687       pal[0].b = (int)(rgb.b*255); pal[1].b = 0;
1688       pal[0].a = 255;              pal[1].a = 0;
1689
1690       int numpalette = 2;
1691       int realwidth = (int)sqrt(SQR(x2-x3) + SQR(y2-y3));
1692       int realheight = (int)sqrt(SQR(x1-x2) + SQR(y1-y2));
1693       for (y = 0; y < height; ++y)
1694       for (x = 0; x < width; ++x)
1695       {
1696             imgStr->getPixel(buf);
1697             if(invert) 
1698                 buf[0]=1-buf[0];
1699             pic[width*y+x] = buf[0];
1700       }
1701       
1702       /* the size of the drawn image is added to the identifier
1703          as the same image may require different bitmaps if displayed
1704          at different sizes (due to antialiasing): */
1705       int t,found = -1;
1706       if(type3active) {
1707           unsigned char*pic2 = 0;
1708           numpalette = 16;
1709           
1710           pic2 = antialize(pic,width,height,realwidth,realheight,numpalette);
1711
1712           if(!pic2) {
1713             delete pic;
1714             delete imgStr;
1715             return;
1716           }
1717
1718           width = realwidth;
1719           height = realheight;
1720           free(pic);
1721           pic = pic2;
1722           
1723           /* make a black/white palette */
1724           GfxRGB rgb2;
1725           rgb2.r = 1 - rgb.r;
1726           rgb2.g = 1 - rgb.g;
1727           rgb2.b = 1 - rgb.b;
1728           float r = 255/(numpalette-1);
1729           int t;
1730           for(t=0;t<numpalette;t++) {
1731               pal[t].r = (U8)(255*rgb.r);
1732               pal[t].g = (U8)(255*rgb.g);
1733               pal[t].b = (U8)(255*rgb.b);
1734               pal[t].a = (U8)(t*r);
1735           }
1736       }
1737
1738       RGBA*pic2 = new RGBA[width*height];
1739       for (y = 0; y < height; ++y) {
1740         for (x = 0; x < width; ++x) {
1741           pic2[width*y+x] = pal[pic[y*width+x]];
1742         }
1743       }
1744       swfoutput_drawimagelossless(&output, pic2, width, height, x1,y1,x2,y2,x3,y3,x4,y4);
1745       free(pic2);
1746       free(pic);
1747       delete imgStr;
1748       return;
1749   } 
1750
1751   int x,y;
1752   
1753   if(colorMap->getNumPixelComps()!=1 || str->getKind()==strDCT) {
1754       RGBA*pic=new RGBA[width*height];
1755       for (y = 0; y < height; ++y) {
1756         for (x = 0; x < width; ++x) {
1757           imgStr->getPixel(pixBuf);
1758           colorMap->getRGB(pixBuf, &rgb);
1759           pic[width*y+x].r = (U8)(rgb.r * 255 + 0.5);
1760           pic[width*y+x].g = (U8)(rgb.g * 255 + 0.5);
1761           pic[width*y+x].b = (U8)(rgb.b * 255 + 0.5);
1762           pic[width*y+x].a = 255;//(U8)(rgb.a * 255 + 0.5);
1763         }
1764       }
1765       if(str->getKind()==strDCT)
1766           swfoutput_drawimagejpeg(&output, pic, width, height, x1,y1,x2,y2,x3,y3,x4,y4);
1767       else
1768           swfoutput_drawimagelossless(&output, pic, width, height, x1,y1,x2,y2,x3,y3,x4,y4);
1769       delete pic;
1770       delete imgStr;
1771       return;
1772   } else {
1773       RGBA*pic=new RGBA[width*height];
1774       RGBA pal[256];
1775       int t;
1776       for(t=0;t<256;t++) {
1777           pixBuf[0] = t;
1778           colorMap->getRGB(pixBuf, &rgb);
1779           pal[t].r = (U8)(rgb.r * 255 + 0.5);
1780           pal[t].g = (U8)(rgb.g * 255 + 0.5);
1781           pal[t].b = (U8)(rgb.b * 255 + 0.5);
1782           pal[t].a = 255;//(U8)(rgb.b * 255 + 0.5);
1783       }
1784       for (y = 0; y < height; ++y) {
1785         for (x = 0; x < width; ++x) {
1786           imgStr->getPixel(pixBuf);
1787           pic[width*y+x] = pal[pixBuf[0]];
1788         }
1789       }
1790       swfoutput_drawimagelossless(&output, pic, width, height, x1,y1,x2,y2,x3,y3,x4,y4);
1791
1792       delete pic;
1793       delete imgStr;
1794       return;
1795   }
1796 }
1797
1798 void SWFOutputDev::drawImageMask(GfxState *state, Object *ref, Stream *str,
1799                                    int width, int height, GBool invert,
1800                                    GBool inlineImg) 
1801 {
1802   msg("<verbose> drawImageMask %dx%d, invert=%d inline=%d", width, height, invert, inlineImg);
1803   drawGeneralImage(state,ref,str,width,height,0,invert,inlineImg,1);
1804 }
1805
1806 void SWFOutputDev::drawImage(GfxState *state, Object *ref, Stream *str,
1807                          int width, int height, GfxImageColorMap *colorMap,
1808                          int *maskColors, GBool inlineImg)
1809 {
1810   msg("<verbose> drawImage %dx%d, %s %s, inline=%d", width, height, 
1811           colorMap?"colorMap":"no colorMap", 
1812           maskColors?"maskColors":"no maskColors",
1813           inlineImg);
1814   if(colorMap)
1815       msg("<verbose> colorMap pixcomps:%d bits:%d mode:%d\n", colorMap->getNumPixelComps(),
1816               colorMap->getBits(),colorMap->getColorSpace()->getMode());
1817   drawGeneralImage(state,ref,str,width,height,colorMap,0,inlineImg,0);
1818 }
1819
1820 SWFOutputDev*output = 0; 
1821
1822 static void printInfoString(Dict *infoDict, char *key, char *fmt) {
1823   Object obj;
1824   GString *s1, *s2;
1825   int i;
1826
1827   if (infoDict->lookup(key, &obj)->isString()) {
1828     s1 = obj.getString();
1829     if ((s1->getChar(0) & 0xff) == 0xfe &&
1830         (s1->getChar(1) & 0xff) == 0xff) {
1831       s2 = new GString();
1832       for (i = 2; i < obj.getString()->getLength(); i += 2) {
1833         if (s1->getChar(i) == '\0') {
1834           s2->append(s1->getChar(i+1));
1835         } else {
1836           delete s2;
1837           s2 = new GString("<unicode>");
1838           break;
1839         }
1840       }
1841       printf(fmt, s2->getCString());
1842       delete s2;
1843     } else {
1844       printf(fmt, s1->getCString());
1845     }
1846   }
1847   obj.free();
1848 }
1849
1850 static void printInfoDate(Dict *infoDict, char *key, char *fmt) {
1851   Object obj;
1852   char *s;
1853
1854   if (infoDict->lookup(key, &obj)->isString()) {
1855     s = obj.getString()->getCString();
1856     if (s[0] == 'D' && s[1] == ':') {
1857       s += 2;
1858     }
1859     printf(fmt, s);
1860   }
1861   obj.free();
1862 }
1863
1864 int jpeg_dpi = 0;
1865 int ppm_dpi = 0;
1866
1867 void pdfswf_setparameter(char*name, char*value)
1868 {
1869     msg("<verbose> setting parameter %s to \"%s\"", name, value);
1870     if(!strcmp(name, "caplinewidth")) {
1871         caplinewidth = atof(value);
1872     } else if(!strcmp(name, "zoom")) {
1873         char buf[80];
1874         zoom = atoi(value);
1875         sprintf(buf, "%f", (double)jpeg_dpi/(double)zoom);
1876         swfoutput_setparameter("jpegsubpixels", buf);
1877         sprintf(buf, "%f", (double)ppm_dpi/(double)zoom);
1878         swfoutput_setparameter("ppmsubpixels", buf);
1879     } else if(!strcmp(name, "jpegdpi")) {
1880         char buf[80];
1881         jpeg_dpi = atoi(value);
1882         sprintf(buf, "%f", (double)jpeg_dpi/(double)zoom);
1883         swfoutput_setparameter("jpegsubpixels", buf);
1884     } else if(!strcmp(name, "ppmdpi")) {
1885         char buf[80];
1886         ppm_dpi = atoi(value);
1887         sprintf(buf, "%f", (double)ppm_dpi/(double)zoom);
1888         swfoutput_setparameter("ppmsubpixels", buf);
1889     } else if(!strcmp(name, "forceType0Fonts")) {
1890         forceType0Fonts = atoi(value);
1891     } else if(!strcmp(name, "fontdir")) {
1892         pdfswf_addfontdir(value);
1893     } else if(!strcmp(name, "languagedir")) {
1894         pdfswf_addlanguagedir(value);
1895     } else if(!strcmp(name, "fontconfig")) {
1896         config_use_fontconfig = atoi(value);
1897     } else {
1898         swfoutput_setparameter(name, value);
1899     }
1900 }
1901 void pdfswf_addfont(char*filename)
1902 {
1903     fontfile_t f;
1904     memset(&f, 0, sizeof(fontfile_t));
1905     f.filename = filename;
1906     if(fontnum < sizeof(fonts)/sizeof(fonts[0])) {
1907         fonts[fontnum++] = f;
1908     } else {
1909         msg("<error> Too many external fonts. Not adding font file \"%s\".", filename);
1910     }
1911 }
1912
1913 static char* dirseparator()
1914 {
1915 #ifdef WIN32
1916     return "\\";
1917 #else
1918     return "/";
1919 #endif
1920 }
1921
1922 void pdfswf_addlanguagedir(char*dir)
1923 {
1924     if(!globalParams)
1925         globalParams = new GlobalParams("");
1926     
1927     msg("<notice> Adding %s to language pack directories", dir);
1928
1929     int l;
1930     FILE*fi = 0;
1931     char* config_file = (char*)malloc(strlen(dir) + 1 + sizeof("add-to-xpdfrc"));
1932     strcpy(config_file, dir);
1933     strcat(config_file, dirseparator());
1934     strcat(config_file, "add-to-xpdfrc");
1935
1936     fi = fopen(config_file, "rb");
1937     if(!fi) {
1938         msg("<error> Could not open %s", config_file);
1939         return;
1940     }
1941     globalParams->parseFile(new GString(config_file), fi);
1942     fclose(fi);
1943 }
1944
1945 void pdfswf_addfontdir(char*dirname)
1946 {
1947 #ifdef HAVE_DIRENT_H
1948     msg("<notice> Adding %s to font directories", dirname);
1949     DIR*dir = opendir(dirname);
1950     if(!dir) {
1951         msg("<warning> Couldn't open directory %s\n", dirname);
1952         return;
1953     }
1954     struct dirent*ent;
1955     while(1) {
1956         ent = readdir (dir);
1957         if (!ent) 
1958             break;
1959         int l;
1960         char*name = ent->d_name;
1961         char type = 0;
1962         if(!name) continue;
1963         l=strlen(name);
1964         if(l<4)
1965             continue;
1966         if(!strncasecmp(&name[l-4], ".pfa", 4)) 
1967             type=1;
1968         if(!strncasecmp(&name[l-4], ".pfb", 4)) 
1969             type=3;
1970         if(!strncasecmp(&name[l-4], ".ttf", 4)) 
1971             type=2;
1972         if(type)
1973         {
1974             char*fontname = (char*)malloc(strlen(dirname)+strlen(name)+2);
1975             strcpy(fontname, dirname);
1976             strcat(fontname, dirseparator());
1977             strcat(fontname, name);
1978             msg("<verbose> Adding %s to fonts", fontname);
1979             pdfswf_addfont(fontname);
1980         }
1981     }
1982     closedir(dir);
1983 #else
1984     msg("<warning> No dirent.h- unable to add font dir %s", dir);
1985 #endif
1986 }
1987
1988
1989 typedef struct _pdf_doc_internal
1990 {
1991     int protect;
1992     PDFDoc*doc;
1993 } pdf_doc_internal_t;
1994 typedef struct _pdf_page_internal
1995 {
1996 } pdf_page_internal_t;
1997 typedef struct _swf_output_internal
1998 {
1999     SWFOutputDev*outputDev;
2000 } swf_output_internal_t;
2001
2002 pdf_doc_t* pdf_init(char*filename, char*userPassword)
2003 {
2004     pdf_doc_t*pdf_doc = (pdf_doc_t*)malloc(sizeof(pdf_doc_t));
2005     memset(pdf_doc, 0, sizeof(pdf_doc_t));
2006     pdf_doc_internal_t*i= (pdf_doc_internal_t*)malloc(sizeof(pdf_doc_internal_t));
2007     memset(i, 0, sizeof(pdf_doc_internal_t));
2008     pdf_doc->internal = i;
2009     
2010     GString *fileName = new GString(filename);
2011     GString *userPW;
2012     Object info;
2013
2014     // read config file
2015     if(!globalParams)
2016         globalParams = new GlobalParams("");
2017
2018     // open PDF file
2019     if (userPassword && userPassword[0]) {
2020       userPW = new GString(userPassword);
2021     } else {
2022       userPW = NULL;
2023     }
2024     i->doc = new PDFDoc(fileName, userPW);
2025     if (userPW) {
2026       delete userPW;
2027     }
2028     if (!i->doc->isOk()) {
2029         return 0;
2030     }
2031
2032     // print doc info
2033     i->doc->getDocInfo(&info);
2034     if (info.isDict() &&
2035       (getScreenLogLevel()>=LOGLEVEL_NOTICE)) {
2036       printInfoString(info.getDict(), "Title",        "Title:        %s\n");
2037       printInfoString(info.getDict(), "Subject",      "Subject:      %s\n");
2038       printInfoString(info.getDict(), "Keywords",     "Keywords:     %s\n");
2039       printInfoString(info.getDict(), "Author",       "Author:       %s\n");
2040       printInfoString(info.getDict(), "Creator",      "Creator:      %s\n");
2041       printInfoString(info.getDict(), "Producer",     "Producer:     %s\n");
2042       printInfoDate(info.getDict(),   "CreationDate", "CreationDate: %s\n");
2043       printInfoDate(info.getDict(),   "ModDate",      "ModDate:      %s\n");
2044       printf("Pages:        %d\n", i->doc->getNumPages());
2045       printf("Linearized:   %s\n", i->doc->isLinearized() ? "yes" : "no");
2046       printf("Encrypted:    ");
2047       if (i->doc->isEncrypted()) {
2048         printf("yes (print:%s copy:%s change:%s addNotes:%s)\n",
2049                i->doc->okToPrint() ? "yes" : "no",
2050                i->doc->okToCopy() ? "yes" : "no",
2051                i->doc->okToChange() ? "yes" : "no",
2052                i->doc->okToAddNotes() ? "yes" : "no");
2053       } else {
2054         printf("no\n");
2055       }
2056     }
2057     info.free();
2058                    
2059     pdf_doc->num_pages = i->doc->getNumPages();
2060     i->protect = 0;
2061     if (i->doc->isEncrypted()) {
2062           if(!i->doc->okToCopy()) {
2063               printf("PDF disallows copying.\n");
2064               return 0;
2065           }
2066           if(!i->doc->okToChange() || !i->doc->okToAddNotes())
2067               i->protect = 1;
2068     }
2069    
2070     return pdf_doc;
2071 }
2072
2073 void pdfswf_preparepage(int page)
2074 {
2075     /*FIXME*/
2076     if(!pages) {
2077         pages = (int*)malloc(1024*sizeof(int));
2078         pagebuflen = 1024;
2079     } else {
2080         if(pagepos == pagebuflen)
2081         {
2082             pagebuflen+=1024;
2083             pages = (int*)realloc(pages, pagebuflen);
2084         }
2085     }
2086     pages[pagepos++] = page;
2087 }
2088
2089 class MemCheck
2090 {
2091     public: ~MemCheck()
2092     {
2093         delete globalParams;globalParams=0;
2094         Object::memCheck(stderr);
2095         gMemReport(stderr);
2096     }
2097 } myMemCheck;
2098
2099 void pdf_destroy(pdf_doc_t*pdf_doc)
2100 {
2101     pdf_doc_internal_t*i= (pdf_doc_internal_t*)pdf_doc->internal;
2102
2103     msg("<debug> pdfswf.cc: pdfswf_close()");
2104     delete i->doc; i->doc=0;
2105     
2106     free(pages); pages = 0; //FIXME
2107
2108     free(pdf_doc->internal);pdf_doc->internal=0;
2109     free(pdf_doc);pdf_doc=0;
2110 }
2111
2112 pdf_page_t* pdf_getpage(pdf_doc_t*pdf_doc, int page)
2113 {
2114     pdf_doc_internal_t*di= (pdf_doc_internal_t*)pdf_doc->internal;
2115
2116     if(page < 1 || page > pdf_doc->num_pages)
2117         return 0;
2118     
2119     pdf_page_t* pdf_page = (pdf_page_t*)malloc(sizeof(pdf_page_t));
2120     pdf_page_internal_t*pi= (pdf_page_internal_t*)malloc(sizeof(pdf_page_internal_t));
2121     memset(pi, 0, sizeof(pdf_page_internal_t));
2122     pdf_page->internal = pi;
2123
2124     pdf_page->parent = pdf_doc;
2125     pdf_page->nr = page;
2126     return pdf_page;
2127 }
2128
2129 void pdf_page_destroy(pdf_page_t*pdf_page)
2130 {
2131     pdf_page_internal_t*i= (pdf_page_internal_t*)pdf_page->internal;
2132     free(pdf_page->internal);pdf_page->internal = 0;
2133     free(pdf_page);pdf_page=0;
2134 }
2135
2136 swf_output_t* swf_output_init() 
2137 {
2138     swf_output_t*swf_output = (swf_output_t*)malloc(sizeof(swf_output_t));
2139     memset(swf_output, 0, sizeof(swf_output_t));
2140     swf_output_internal_t*i= (swf_output_internal_t*)malloc(sizeof(swf_output_internal_t));
2141     memset(i, 0, sizeof(swf_output_internal_t));
2142     swf_output->internal = i;
2143
2144     i->outputDev = new SWFOutputDev();
2145     return swf_output;
2146 }
2147
2148 void swf_output_setparameter(swf_output_t*swf_output, char*name, char*value)
2149 {
2150     /* FIXME */
2151     pdfswf_setparameter(name, value);
2152 }
2153
2154 void swf_output_pagefeed(swf_output_t*swf)
2155 {
2156     swf_output_internal_t*i= (swf_output_internal_t*)swf->internal;
2157     i->outputDev->pagefeed();
2158     i->outputDev->getDimensions(&swf->x1, &swf->y1, &swf->x2, &swf->y2);
2159 }
2160
2161 int swf_output_save(swf_output_t*swf, char*filename)
2162 {
2163     swf_output_internal_t*i= (swf_output_internal_t*)swf->internal;
2164     int ret = i->outputDev->save(filename);
2165     i->outputDev->getDimensions(&swf->x1, &swf->y1, &swf->x2, &swf->y2);
2166     return ret;
2167 }
2168
2169 void* swf_output_get(swf_output_t*swf)
2170 {
2171     swf_output_internal_t*i= (swf_output_internal_t*)swf->internal;
2172     void* ret = i->outputDev->getSWF();
2173     i->outputDev->getDimensions(&swf->x1, &swf->y1, &swf->x2, &swf->y2);
2174     return ret;
2175 }
2176
2177 void swf_output_destroy(swf_output_t*output)
2178 {
2179     swf_output_internal_t*i = (swf_output_internal_t*)output->internal;
2180     delete i->outputDev; i->outputDev=0;
2181     free(output->internal);output->internal=0;
2182     free(output);
2183 }
2184
2185 void pdf_page_render2(pdf_page_t*page, swf_output_t*swf)
2186 {
2187     pdf_doc_internal_t*pi = (pdf_doc_internal_t*)page->parent->internal;
2188     swf_output_internal_t*si = (swf_output_internal_t*)swf->internal;
2189
2190     if(pi->protect) {
2191         swfoutput_setparameter("protect", "1");
2192     }
2193     si->outputDev->setXRef(pi->doc, pi->doc->getXRef());
2194 #ifdef XPDF_101
2195     pi->doc->displayPage((OutputDev*)si->outputDev, page->nr, /*zoom*/zoom, /*rotate*/0, /*doLinks*/(int)1);
2196 #else
2197     pi->doc->displayPage((OutputDev*)si->outputDev, page->nr, zoom, zoom, /*rotate*/0, true, /*doLinks*/(int)1);
2198 #endif
2199     si->outputDev->getDimensions(&swf->x1, &swf->y1, &swf->x2, &swf->y2);
2200 }
2201
2202 void pdf_page_rendersection(pdf_page_t*page, swf_output_t*output, int x, int y, int x1, int y1, int x2, int y2)
2203 {
2204     pdf_doc_internal_t*pi = (pdf_doc_internal_t*)page->parent->internal;
2205     swf_output_internal_t*si = (swf_output_internal_t*)output->internal;
2206
2207     si->outputDev->setMove(x,y);
2208     if((x1|y1|x2|y2)==0) x2++;
2209     si->outputDev->setClip(x1,y1,x2,y2);
2210
2211     pdf_page_render2(page, output);
2212 }
2213 void pdf_page_render(pdf_page_t*page, swf_output_t*output)
2214 {
2215     pdf_doc_internal_t*pi = (pdf_doc_internal_t*)page->parent->internal;
2216     swf_output_internal_t*si = (swf_output_internal_t*)output->internal;
2217     
2218     si->outputDev->setMove(0,0);
2219     si->outputDev->setClip(0,0,0,0);
2220     
2221     pdf_page_render2(page, output);
2222 }
2223
2224
2225 pdf_page_info_t* pdf_page_getinfo(pdf_page_t*page)
2226 {
2227     pdf_doc_internal_t*pi = (pdf_doc_internal_t*)page->parent->internal;
2228     pdf_page_internal_t*i= (pdf_page_internal_t*)page->internal;
2229     pdf_page_info_t*info = (pdf_page_info_t*)malloc(sizeof(pdf_page_info_t));
2230     memset(info, 0, sizeof(pdf_page_info_t));
2231
2232     InfoOutputDev*output = new InfoOutputDev;
2233     
2234 #ifdef XPDF_101
2235     pi->doc->displayPage((OutputDev*)output, page->nr, /*zoom*/zoom, /*rotate*/0, /*doLinks*/(int)1);
2236 #else
2237     pi->doc->displayPage((OutputDev*)output, page->nr, zoom, zoom, /*rotate*/0, true, /*doLinks*/(int)1);
2238 #endif
2239
2240     info->xMin = output->x1;
2241     info->yMin = output->y1;
2242     info->xMax = output->x2;
2243     info->yMax = output->y2;
2244     info->number_of_images = output->num_images;
2245     info->number_of_links = output->num_links;
2246     info->number_of_fonts = output->num_fonts;
2247
2248     delete output;
2249
2250     return info;
2251 }
2252
2253 void pdf_page_info_destroy(pdf_page_info_t*info)
2254 {
2255     free(info);
2256 }