give a name to each link
[swftools.git] / lib / devices / swf.c
1 /* gfxdevice_swf.c
2
3    Part of the swftools package.
4
5    Copyright (c) 2001,2002,2003,2004,2005 Matthias Kramm <kramm@quiss.org> 
6
7    Swftools is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 2 of the License, or
10    (at your option) any later version.
11
12    Swftools is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16
17    You should have received a copy of the GNU General Public License
18    along with swftools; if not, write to the Free Software
19    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
20
21 #include <stdlib.h>
22 #include <stdio.h>
23 #include <string.h>
24 #include "../../config.h"
25 #include <fcntl.h>
26 #ifdef HAVE_UNISTD_H
27 #include <unistd.h>
28 #endif
29 #ifdef HAVE_IO_H
30 #include <io.h>
31 #endif
32 #ifdef HAVE_ASSERT_H
33 #include <assert.h>
34 #else
35 #define assert(a)
36 #endif
37 #include <math.h>
38 #include "../mem.h"
39 #include "../log.h"
40 #include "../rfxswf.h"
41 #include "../gfxdevice.h"
42 #include "../gfxtools.h"
43 #include "../art/libart.h"
44 #include "swf.h"
45 #include "../gfxpoly.h"
46
47 #define CHARDATAMAX 8192
48 #define CHARMIDX 0
49 #define CHARMIDY 0
50
51 typedef struct _chardata {
52     int charid;
53     int fontid; /* TODO: use a SWFFONT instead */
54     int x;
55     int y;
56     int size;
57     RGBA color;
58 } chardata_t;
59
60 typedef struct _fontlist
61 {
62     SWFFONT *swffont;
63     struct _fontlist*next;
64 } fontlist_t;
65
66 typedef long int twip;
67
68 typedef struct _swfmatrix {
69     double m11,m12,m21,m22,m31,m32;
70 } swfmatrix_t;
71
72 typedef struct _swfoutput_internal
73 {
74     gfxdevice_t*dev; // the gfxdevice object where this internal struct resides
75
76     double config_dumpfonts;
77     double config_ppmsubpixels;
78     double config_jpegsubpixels;
79     int config_opennewwindow;
80     int config_ignoredraworder;
81     int config_drawonlyshapes;
82     int config_jpegquality;
83     int config_storeallcharacters;
84     int config_enablezlib;
85     int config_insertstoptag;
86     int config_watermark;
87     int config_flashversion;
88     int config_reordertags;
89     int config_showclipshapes;
90     int config_splinemaxerror;
91     int config_fontsplinemaxerror;
92     int config_filloverlap;
93     int config_protect;
94     int config_bboxvars;
95     int config_disable_polygon_conversion;
96     int config_normalize_polygon_positions;
97     RGBA config_linkcolor;
98     float config_minlinewidth;
99     double config_caplinewidth;
100     char* config_linktarget;
101     char*config_internallinkfunction;
102     char*config_externallinkfunction;
103     char config_animate;
104     double config_framerate;
105
106     SWF* swf;
107
108     fontlist_t* fontlist;
109
110     char storefont;
111
112     MATRIX page_matrix;
113
114     TAG *tag;
115     int currentswfid;
116     int depth;
117     int startdepth;
118     int linewidth;
119     
120     SHAPE* shape;
121     int shapeid;
122     int textid;
123
124     int watermarks;
125     
126     int fillstyleid;
127     int linestyleid;
128     int swflastx;
129     int swflasty;
130     int lastwasfill;
131     int shapeisempty;
132     char fill;
133     int min_x,max_x;
134     int min_y,max_y;
135     TAG* cliptags[128];
136     int clipshapes[128];
137     U32 clipdepths[128];
138     int clippos;
139
140     /* image cache */
141     int pic_xids[1024];
142     int pic_yids[1024];
143     int pic_ids[1024];
144     int pic_width[1024];
145     int pic_height[1024];
146     int picpos;
147
148     int frameno;
149     int lastframeno;
150     
151     char fillstylechanged;
152
153     int jpeg; //next image type
154     
155     int bboxrectpos;
156     SRECT bboxrect;
157
158     SRECT pagebbox;
159
160     chardata_t chardata[CHARDATAMAX];
161     int chardatapos;
162     int firstpage;
163     char pagefinished;
164
165     char overflow;
166
167     int current_font_size;
168     MATRIX fontmatrix;
169     double lastfontm11,lastfontm12,lastfontm21,lastfontm22;
170     SWFFONT *swffont;
171     RGBA strokergb;
172     RGBA fillrgb;
173     int drawmode;
174
175     int shapeposx;
176     int shapeposy;
177
178     char* mark;
179
180 } swfoutput_internal;
181     
182 static void swf_fillbitmap(gfxdevice_t*driver, gfxline_t*line, gfximage_t*img, gfxmatrix_t*move, gfxcxform_t*cxform);
183 static int  swf_setparameter(gfxdevice_t*driver, const char*key, const char*value);
184 static void swf_drawstroke(gfxdevice_t*dev, gfxline_t*line, gfxcoord_t width, gfxcolor_t*color, gfx_capType cap_style, gfx_joinType joint_style, gfxcoord_t miterLimit);
185 static void swf_startclip(gfxdevice_t*dev, gfxline_t*line);
186 static void swf_endclip(gfxdevice_t*dev);
187 static void swf_stroke(gfxdevice_t*dev, gfxline_t*line, gfxcoord_t width, gfxcolor_t*color, gfx_capType cap_style, gfx_joinType joint_style, gfxcoord_t miterLimit);
188 static void swf_fill(gfxdevice_t*dev, gfxline_t*line, gfxcolor_t*color);
189 static void swf_fillbitmap(gfxdevice_t*dev, gfxline_t*line, gfximage_t*img, gfxmatrix_t*matrix, gfxcxform_t*cxform);
190 static void swf_fillgradient(gfxdevice_t*dev, gfxline_t*line, gfxgradient_t*gradient, gfxgradienttype_t type, gfxmatrix_t*matrix);
191 static void swf_drawchar(gfxdevice_t*dev, gfxfont_t*font, int glyph, gfxcolor_t*color, gfxmatrix_t*matrix);
192 static void swf_addfont(gfxdevice_t*dev, gfxfont_t*font);
193 static void swf_drawlink(gfxdevice_t*dev, gfxline_t*line, const char*action);
194 static void swf_startframe(gfxdevice_t*dev, int width, int height);
195 static void swf_endframe(gfxdevice_t*dev);
196 static gfxresult_t* swf_finish(gfxdevice_t*driver);
197
198 static swfoutput_internal* init_internal_struct()
199 {
200     swfoutput_internal*i = (swfoutput_internal*)malloc(sizeof(swfoutput_internal));
201     memset(i, 0, sizeof(swfoutput_internal));
202
203     i->storefont = 0;
204     i->currentswfid = 0;
205     i->depth = 0;
206     i->overflow = 0;
207     i->startdepth = 0;
208     i->linewidth = 0;
209     i->shapeid = -1;
210     i->textid = -1;
211     i->frameno = 0;
212     i->lastframeno = 0;
213
214     i->mark = 0;
215
216     i->fillstyleid;
217     i->linestyleid;
218     i->swflastx=0;
219     i->swflasty=0;
220     i->lastwasfill = 0;
221     i->shapeisempty = 1;
222     i->fill = 0;
223     i->clippos = 0;
224
225     i->fillstylechanged = 0;
226
227     i->bboxrectpos = -1;
228     i->chardatapos = 0;
229     i->firstpage = 1;
230     i->pagefinished = 1;
231
232     i->config_dumpfonts=0;
233     i->config_ppmsubpixels=0;
234     i->config_jpegsubpixels=0;
235     i->config_opennewwindow=1;
236     i->config_ignoredraworder=0;
237     i->config_drawonlyshapes=0;
238     i->config_jpegquality=85;
239     i->config_storeallcharacters=0;
240     i->config_enablezlib=0;
241     i->config_insertstoptag=0;
242     i->config_flashversion=6;
243     i->config_framerate=0.25;
244     i->config_splinemaxerror=1;
245     i->config_fontsplinemaxerror=1;
246     i->config_filloverlap=0;
247     i->config_protect=0;
248     i->config_bboxvars=0;
249     i->config_showclipshapes=0;
250     i->config_minlinewidth=0.05;
251     i->config_caplinewidth=1;
252     i->config_linktarget=0;
253     i->config_internallinkfunction=0;
254     i->config_externallinkfunction=0;
255     i->config_reordertags=1;
256
257     i->config_linkcolor.r = i->config_linkcolor.g = i->config_linkcolor.b = 255;
258     i->config_linkcolor.a = 0x40;
259
260     return i;
261 };
262
263 static int id_error = 0;
264
265 static U16 getNewID(gfxdevice_t* dev)
266 {
267     swfoutput_internal*i = (swfoutput_internal*)dev->internal;
268     if(i->currentswfid == 65535) {
269         if(!id_error) {
270             msg("<error> ID Table overflow");
271             msg("<error> This file is too complex to render- SWF only supports 65536 shapes at once");
272         }
273         id_error=1;
274         i->overflow = 1;
275         exit(1);
276     }
277     return ++i->currentswfid;
278 }
279 static U16 getNewDepth(gfxdevice_t* dev)
280 {
281     swfoutput_internal*i = (swfoutput_internal*)dev->internal;
282     if(i->depth == 65535) {
283         if(!id_error) {
284             msg("<error> Depth Table overflow");
285             msg("<error> This file is too complex to render- SWF only supports 65536 shapes at once");
286         }
287         id_error=1;
288         i->overflow = 1;
289         exit(1);
290     }
291     return ++i->depth;
292 }
293
294 static void startshape(gfxdevice_t* dev);
295 static void starttext(gfxdevice_t* dev);
296 static void endshape(gfxdevice_t* dev);
297 static void endtext(gfxdevice_t* dev);
298
299 typedef struct _plotxy
300 {
301     double x,y;
302 } plotxy_t;
303
304 // write a move-to command into the swf
305 static int movetoxy(gfxdevice_t*dev, TAG*tag, plotxy_t p0)
306 {
307     swfoutput_internal*i = (swfoutput_internal*)dev->internal;
308     int rx = (int)(p0.x*20);
309     int ry = (int)(p0.y*20);
310     if(rx!=i->swflastx || ry!=i->swflasty || i->fillstylechanged) {
311       swf_ShapeSetMove (tag, i->shape, rx,ry);
312       i->fillstylechanged = 0;
313       i->swflastx=rx;
314       i->swflasty=ry;
315       return 1;
316     }
317     return 0;
318 }
319 static int moveto(gfxdevice_t*dev, TAG*tag, double  x, double y)
320 {
321     swfoutput_internal*i = (swfoutput_internal*)dev->internal;
322     plotxy_t p;
323     p.x = x;
324     p.y = y;
325     return movetoxy(dev, tag, p);
326 }
327 static void addPointToBBox(gfxdevice_t*dev, int px, int py) 
328 {
329     swfoutput_internal*i = (swfoutput_internal*)dev->internal;
330
331     SPOINT p;
332     p.x = px;
333     p.y = py;
334     if(i->fill) {
335         swf_ExpandRect(&i->bboxrect, p);
336     } else {
337         swf_ExpandRect3(&i->bboxrect, p, i->linewidth*3/2);
338     }
339 }
340
341 /*static void plot(gfxdevice_t*dev, int x, int y, TAG*tag)
342 {
343     swfoutput_internal*i = (swfoutput_internal*)dev->internal;
344     int width = i->linewidth/4;
345     if(width > 5)
346         width = 5;
347     ////square
348     //swf_ShapeSetLine(tag, i->shape,-width,-width);
349     //swf_ShapeSetLine(tag, i->shape,width*2,0);
350     //swf_ShapeSetLine(tag, i->shape,0,width*2);
351     //swf_ShapeSetLine(tag, i->shape,-width*2,0);
352     //swf_ShapeSetLine(tag, i->shape,0,-width*2);
353     //swf_ShapeSetLine(tag, i->shape,width,width);
354    
355     // diamond
356     swf_ShapeSetLine(tag, i->shape,-width,0);
357     swf_ShapeSetLine(tag, i->shape,width,-width);
358     swf_ShapeSetLine(tag, i->shape,width,width);
359     swf_ShapeSetLine(tag, i->shape,-width,width);
360     swf_ShapeSetLine(tag, i->shape,-width,-width);
361     swf_ShapeSetLine(tag, i->shape,width,0);
362
363     addPointToBBox(dev, x-width ,y-width);
364     addPointToBBox(dev, x+width ,y+width);
365 }*/
366
367 // write a line-to command into the swf
368 static void linetoxy(gfxdevice_t*dev, TAG*tag, plotxy_t p0)
369 {
370     swfoutput_internal*i = (swfoutput_internal*)dev->internal;
371     int px = (int)(p0.x*20);
372     int py = (int)(p0.y*20);
373     int rx = (px-i->swflastx);
374     int ry = (py-i->swflasty);
375     if(rx|ry) {
376         swf_ShapeSetLine (tag, i->shape, rx,ry);
377         addPointToBBox(dev, i->swflastx,i->swflasty);
378         addPointToBBox(dev, px,py);
379     }/* else if(!i->fill) {
380        // treat lines of length 0 as plots, making them
381        // at least 1 twip wide so Flash will display them
382         plot(dev, i->swflastx, i->swflasty, tag);
383     }*/
384
385     i->shapeisempty = 0;
386     i->swflastx+=rx;
387     i->swflasty+=ry;
388 }
389 static void lineto(gfxdevice_t*dev, TAG*tag, double x, double y)
390 {
391     plotxy_t p;
392     p.x = x;
393     p.y = y;
394     linetoxy(dev,tag, p);
395 }
396
397 // write a spline-to command into the swf
398 static void splineto(gfxdevice_t*dev, TAG*tag, plotxy_t control,plotxy_t end)
399 {
400     swfoutput_internal*i = (swfoutput_internal*)dev->internal;
401     int lastlastx = i->swflastx;
402     int lastlasty = i->swflasty;
403
404     int cx = ((int)(control.x*20)-i->swflastx);
405     int cy = ((int)(control.y*20)-i->swflasty);
406     i->swflastx += cx;
407     i->swflasty += cy;
408     int ex = ((int)(end.x*20)-i->swflastx);
409     int ey = ((int)(end.y*20)-i->swflasty);
410     i->swflastx += ex;
411     i->swflasty += ey;
412     
413     if((cx || cy) && (ex || ey)) {
414         swf_ShapeSetCurve(tag, i->shape, cx,cy,ex,ey);
415         addPointToBBox(dev, lastlastx   ,lastlasty   );
416         addPointToBBox(dev, lastlastx+cx,lastlasty+cy);
417         addPointToBBox(dev, lastlastx+cx+ex,lastlasty+cy+ey);
418     } else if(cx || cy || ex || ey) {
419         swf_ShapeSetLine(tag, i->shape, cx+ex,cy+ey);
420         addPointToBBox(dev, lastlastx   ,lastlasty   );
421         addPointToBBox(dev, lastlastx+cx,lastlasty+cy);
422         addPointToBBox(dev, lastlastx+cx+ex,lastlasty+cy+ey);
423     }
424
425     i->shapeisempty = 0;
426 }
427
428 /* write a line, given two points and the transformation
429    matrix. */
430 /*static void line(gfxdevice_t*dev, TAG*tag, plotxy_t p0, plotxy_t p1)
431 {
432     moveto(dev, tag, p0);
433     lineto(dev, tag, p1);
434 }*/
435
436 void resetdrawer(gfxdevice_t*dev)
437 {
438     swfoutput_internal*i = (swfoutput_internal*)dev->internal;
439     i->swflastx = 0;
440     i->swflasty = 0;
441 }
442
443 static void stopFill(gfxdevice_t*dev)
444 {
445     swfoutput_internal*i = (swfoutput_internal*)dev->internal;
446     if(i->lastwasfill!=0)
447     {
448         swf_ShapeSetStyle(i->tag,i->shape,i->linestyleid,0x8000,0);
449         i->fillstylechanged = 1;
450         i->lastwasfill = 0;
451     }
452 }
453 static void startFill(gfxdevice_t*dev)
454 {
455     swfoutput_internal*i = (swfoutput_internal*)dev->internal;
456     if(i->lastwasfill!=1)
457     {
458         swf_ShapeSetStyle(i->tag,i->shape,0x8000,i->fillstyleid,0);
459         i->fillstylechanged = 1;
460         i->lastwasfill = 1;
461     }
462 }
463
464 static inline int colorcompare(gfxdevice_t*dev, RGBA*a,RGBA*b)
465 {
466
467     if(a->r!=b->r ||
468        a->g!=b->g ||
469        a->b!=b->b ||
470        a->a!=b->a) {
471         return 0;
472     }
473     return 1;
474 }
475
476 static SRECT getcharacterbbox(gfxdevice_t*dev, SWFFONT*font, MATRIX* m)
477 {
478     swfoutput_internal*i = (swfoutput_internal*)dev->internal;
479     SRECT r;
480     char debug = 0;
481     memset(&r, 0, sizeof(r));
482
483     int t;
484     if(debug) printf("\n");
485     for(t=0;t<i->chardatapos;t++)
486     {
487         if(i->chardata[t].fontid != font->id) {
488             msg("<error> Internal error: fontid %d != fontid %d", i->chardata[t].fontid, font->id);
489             exit(1);
490         }
491         SRECT b = font->layout->bounds[i->chardata[t].charid];
492         b.xmin *= i->chardata[t].size;
493         b.ymin *= i->chardata[t].size;
494         b.xmax *= i->chardata[t].size;
495         b.ymax *= i->chardata[t].size;
496
497         /* divide by 1024, rounding xmax/ymax up */
498         b.xmax += 1023; b.ymax += 1023; b.xmin /= 1024; b.ymin /= 1024; b.xmax /= 1024; b.ymax /= 1024;
499
500         b.xmin += i->chardata[t].x;
501         b.ymin += i->chardata[t].y;
502         b.xmax += i->chardata[t].x;
503         b.ymax += i->chardata[t].y;
504
505         /* until we solve the INTERNAL_SCALING problem (see below)
506            make sure the bounding box is big enough */
507         b.xmin -= 20;
508         b.ymin -= 20;
509         b.xmax += 20;
510         b.ymax += 20;
511
512         b = swf_TurnRect(b, m);
513
514         if(debug) printf("(%f,%f,%f,%f) -> (%f,%f,%f,%f) [font %d/%d, char %d]\n",
515                 font->layout->bounds[i->chardata[t].charid].xmin/20.0,
516                 font->layout->bounds[i->chardata[t].charid].ymin/20.0,
517                 font->layout->bounds[i->chardata[t].charid].xmax/20.0,
518                 font->layout->bounds[i->chardata[t].charid].ymax/20.0,
519                 b.xmin/20.0,
520                 b.ymin/20.0,
521                 b.xmax/20.0,
522                 b.ymax/20.0,
523                 i->chardata[t].fontid,
524                 font->id,
525                 i->chardata[t].charid
526                 );
527         swf_ExpandRect2(&r, &b);
528     }
529     if(debug) printf("-----> (%f,%f,%f,%f)\n",
530             r.xmin/20.0,
531             r.ymin/20.0,
532             r.xmax/20.0,
533             r.ymax/20.0);
534     return r;
535 }
536
537 static void putcharacters(gfxdevice_t*dev, TAG*tag)
538 {
539     swfoutput_internal*i = (swfoutput_internal*)dev->internal;
540     int t;
541     SWFFONT font;
542     RGBA color;
543     color.r = i->chardata[0].color.r^255;
544     color.g = 0;
545     color.b = 0;
546     color.a = 0;
547     int lastfontid;
548     int lastx;
549     int lasty;
550     int lastsize;
551     int charids[128];
552     int charadvance[128];
553     int charstorepos;
554     int pass;
555     int glyphbits=1; //TODO: can this be zero?
556     int advancebits=1;
557
558     if(tag->id != ST_DEFINETEXT &&
559         tag->id != ST_DEFINETEXT2) {
560         msg("<error> internal error: putcharacters needs an text tag, not %d\n",tag->id);
561         exit(1);
562     }
563     if(!i->chardatapos) {
564         msg("<warning> putcharacters called with zero characters");
565     }
566
567     for(pass = 0; pass < 2; pass++)
568     {
569         charstorepos = 0;
570         lastfontid = -1;
571         lastx = CHARMIDX;
572         lasty = CHARMIDY;
573         lastsize = -1;
574
575         if(pass==1)
576         {
577             advancebits++; // add sign bit
578             swf_SetU8(tag, glyphbits);
579             swf_SetU8(tag, advancebits);
580         }
581
582         for(t=0;t<=i->chardatapos;t++)
583         {
584             if(lastfontid != i->chardata[t].fontid || 
585                     lastx!=i->chardata[t].x ||
586                     lasty!=i->chardata[t].y ||
587                     !colorcompare(dev,&color, &i->chardata[t].color) ||
588                     charstorepos==127 ||
589                     lastsize != i->chardata[t].size ||
590                     t == i->chardatapos)
591             {
592                 if(charstorepos && pass==0)
593                 {
594                     int s;
595                     for(s=0;s<charstorepos;s++)
596                     {
597                         while(charids[s]>=(1<<glyphbits))
598                             glyphbits++;
599                         while(charadvance[s]>=(1<<advancebits))
600                             advancebits++;
601                     }
602                 }
603                 if(charstorepos && pass==1)
604                 {
605                     tag->writeBit = 0; // Q&D
606                     swf_SetBits(tag, 0, 1); // GLYPH Record
607                     swf_SetBits(tag, charstorepos, 7); // number of glyphs
608                     int s;
609                     for(s=0;s<charstorepos;s++)
610                     {
611                         swf_SetBits(tag, charids[s], glyphbits);
612                         swf_SetBits(tag, charadvance[s], advancebits);
613                     }
614                 }
615                 charstorepos = 0;
616
617                 if(pass == 1 && t<i->chardatapos)
618                 {
619                     RGBA*newcolor=0;
620                     SWFFONT*newfont=0;
621                     int newx = 0;
622                     int newy = 0;
623                     if(lastx != i->chardata[t].x ||
624                        lasty != i->chardata[t].y)
625                     {
626                         newx = i->chardata[t].x;
627                         newy = i->chardata[t].y;
628                         if(newx == 0)
629                             newx = SET_TO_ZERO;
630                         if(newy == 0)
631                             newy = SET_TO_ZERO;
632                     }
633                     if(!colorcompare(dev,&color, &i->chardata[t].color)) 
634                     {
635                         color = i->chardata[t].color;
636                         newcolor = &color;
637                     }
638                     font.id = i->chardata[t].fontid;
639                     if(lastfontid != i->chardata[t].fontid || lastsize != i->chardata[t].size)
640                         newfont = &font;
641
642                     tag->writeBit = 0; // Q&D
643                     swf_TextSetInfoRecord(tag, newfont, i->chardata[t].size, newcolor, newx,newy);
644                 }
645
646                 lastfontid = i->chardata[t].fontid;
647                 lastx = i->chardata[t].x;
648                 lasty = i->chardata[t].y;
649                 lastsize = i->chardata[t].size;
650             }
651
652             if(t==i->chardatapos)
653                     break;
654
655             int advance;
656             int nextt = t==i->chardatapos-1?t:t+1;
657             int rel = i->chardata[nextt].x-i->chardata[t].x;
658             if(rel>=0 && (rel<(1<<(advancebits-1)) || pass==0)) {
659                advance = rel;
660                lastx=i->chardata[nextt].x;
661             }
662             else {
663                advance = 0;
664                lastx=i->chardata[t].x;
665             }
666             charids[charstorepos] = i->chardata[t].charid;
667             charadvance[charstorepos] = advance;
668             charstorepos ++;
669         }
670     }
671     i->chardatapos = 0;
672 }
673
674 static void putcharacter(gfxdevice_t*dev, int fontid, int charid, int x,int y, int size, RGBA color)
675 {
676     swfoutput_internal*i = (swfoutput_internal*)dev->internal;
677     if(i->chardatapos == CHARDATAMAX)
678     {
679         msg("<warning> Character buffer too small. SWF will be slightly bigger");
680         endtext(dev);
681         starttext(dev);
682     }
683     i->chardata[i->chardatapos].fontid = fontid;
684     i->chardata[i->chardatapos].charid = charid;
685     i->chardata[i->chardatapos].x = x;
686     i->chardata[i->chardatapos].y = y;
687     i->chardata[i->chardatapos].color = color;
688     i->chardata[i->chardatapos].size = size;
689     i->chardatapos++;
690 }
691
692 /* Notice: we can only put chars in the range -1639,1638 (-32768/20,32768/20).
693    So if we set this value to high, the char coordinates will overflow.
694    If we set it to low, however, the char positions will be inaccurate */
695 #define GLYPH_SCALE 1
696
697 static void endtext(gfxdevice_t*dev)
698 {
699     swfoutput_internal*i = (swfoutput_internal*)dev->internal;
700     if(i->textid<0)
701         return;
702
703     i->tag = swf_InsertTag(i->tag,ST_DEFINETEXT2);
704     swf_SetU16(i->tag, i->textid);
705
706     SRECT r;
707     r = getcharacterbbox(dev, i->swffont, &i->fontmatrix);
708     r = swf_ClipRect(i->pagebbox, r);
709     swf_SetRect(i->tag,&r);
710
711     swf_SetMatrix(i->tag,&i->fontmatrix);
712
713     msg("<trace> Placing text (%d characters) as ID %d", i->chardatapos, i->textid);
714
715     putcharacters(dev, i->tag);
716     swf_SetU8(i->tag,0);
717
718     if(i->swf->fileVersion >= 8) {
719         i->tag = swf_InsertTag(i->tag, ST_CSMTEXTSETTINGS);
720         swf_SetU16(i->tag, i->textid);
721
722         //swf_SetU8(i->tag, /*subpixel grid*/(2<<3)|/*flashtype*/0x40);
723         swf_SetU8(i->tag, /*grid*/(1<<3)|/*flashtype*/0x40);
724         //swf_SetU8(i->tag, /*no grid*/(0<<3)|/*flashtype*/0x40);
725
726         swf_SetU32(i->tag, 0);//thickness
727         swf_SetU32(i->tag, 0);//sharpness
728         swf_SetU8(i->tag, 0);//reserved
729     }
730     i->tag = swf_InsertTag(i->tag,ST_PLACEOBJECT2);
731     
732     swf_ObjectPlace(i->tag,i->textid,getNewDepth(dev),&i->page_matrix,NULL,NULL);
733     i->textid = -1;
734 }
735
736 /* set's the matrix which is to be applied to characters drawn by swfoutput_drawchar() */
737 static void setfontscale(gfxdevice_t*dev,double m11,double m12, double m21,double m22,double x, double y, char force)
738 {
739     m11 *= 1024;
740     m12 *= 1024;
741     m21 *= 1024;
742     m22 *= 1024;
743     swfoutput_internal*i = (swfoutput_internal*)dev->internal;
744     if(i->lastfontm11 == m11 &&
745        i->lastfontm12 == m12 &&
746        i->lastfontm21 == m21 &&
747        i->lastfontm22 == m22 && !force)
748         return;
749    if(i->textid>=0)
750         endtext(dev);
751     
752     i->lastfontm11 = m11;
753     i->lastfontm12 = m12;
754     i->lastfontm21 = m21;
755     i->lastfontm22 = m22;
756
757     double xsize = sqrt(m11*m11 + m12*m12);
758     double ysize = sqrt(m21*m21 + m22*m22);
759     i->current_font_size = (xsize>ysize?xsize:ysize)*1;
760     if(i->current_font_size < 1)
761         i->current_font_size = 1;
762     double ifs = 1.0 / (i->current_font_size*GLYPH_SCALE);
763
764     MATRIX m;
765     m.sx = (S32)((m11*ifs)*65536); m.r1 = (S32)((m21*ifs)*65536);
766     m.r0 = (S32)((m12*ifs)*65536); m.sy = (S32)((m22*ifs)*65536); 
767     /* this is the position of the first char to set a new fontmatrix-
768        we hope that it's close enough to all other characters using the
769        font, so we use its position as origin for the matrix */
770     m.tx = x*20;
771     m.ty = y*20;
772     i->fontmatrix = m;
773 }
774
775 static int watermark2_width=47;
776 static int watermark2_height=11;
777 static int watermark2[47] = {95,1989,71,0,2015,337,1678,0,2015,5,1921,320,1938,25,2006,1024,
778                              1042,21,13,960,1039,976,8,2000,1359,1088,31,1989,321,1728,0,1152,
779                              1344,832,0,1984,0,896,1088,1088,896,0,1984,128,256,512,1984};
780
781 static void draw_watermark(gfxdevice_t*dev, gfxbbox_t r, char drawall)
782 {
783     swfoutput_internal*i = (swfoutput_internal*)dev->internal;
784     double wx = r.xmax / 5.0;
785     double tx = r.xmax*4.0 / 5.0;
786     double ty = r.ymax-wx*watermark2_height/watermark2_width;
787     double sx = (r.xmax - tx) / watermark2_width;
788     double sy = (r.ymax - ty) / watermark2_height;
789     double px = sx-0.5;
790     double py = sy-0.5;
791     if(ty > 0 && px > 1.0 && py > 1.0) {
792         int x,y;
793         for(y=0;y<watermark2_height;y++)
794         for(x=0;x<watermark2_width;x++) {
795             if(((watermark2[x]>>y)&1)) {
796                 if(!drawall && rand()%5)
797                     continue;
798                 unsigned int b = rand();
799                 moveto(dev, i->tag, x*sx+tx+((b>>1)&1)/20.0, y*sy+ty+((b>>3)&1)/20.0);
800                 lineto(dev, i->tag, x*sx+px+tx+((b>>2)&1)/20.0, y*sy+ty+((b>>3)&1)/20.0);
801                 lineto(dev, i->tag, x*sx+px+tx+((b>>2)&1)/20.0, y*sy+py+ty+((b>>4)&1)/20.0);
802                 lineto(dev, i->tag, x*sx+tx+((b>>1)&1)/20.0, y*sy+py+ty+((b>>4)&1)/20.0);
803                 lineto(dev, i->tag, x*sx+tx+((b>>1)&1)/20.0, y*sy+ty+((b>>3)&1)/20.0);
804             }
805         }
806     }
807 }
808
809 static void swfoutput_setfillcolor(gfxdevice_t* dev, U8 r, U8 g, U8 b, U8 a)
810 {
811     swfoutput_internal*i = (swfoutput_internal*)dev->internal;
812     if(i->fillrgb.r == r &&
813        i->fillrgb.g == g &&
814        i->fillrgb.b == b &&
815        i->fillrgb.a == a) return;
816     if(i->shapeid>=0)
817      endshape(dev);
818
819     i->fillrgb.r = r;
820     i->fillrgb.g = g;
821     i->fillrgb.b = b;
822     i->fillrgb.a = a;
823 }
824 static void insert_watermark(gfxdevice_t*dev, char drawall)
825 {
826     swfoutput_internal*i = (swfoutput_internal*)dev->internal;
827     if(!drawall && i->watermarks>20)
828         return;
829     endshape(dev);
830     endtext(dev);
831    
832     if(drawall) {
833         swfoutput_setfillcolor(dev, 0,0,255,192);
834     } else {
835         swfoutput_setfillcolor(dev, rand(),rand(),rand(),(rand()&127)+128);
836     }
837     startshape(dev);
838     startFill(dev);
839
840     gfxbbox_t r; r.xmin = r.ymin = 0;
841     r.xmax = i->max_x;
842     r.ymax = i->max_y;
843     draw_watermark(dev, r, drawall);
844     endshape(dev);
845     i->watermarks++;
846 }
847
848
849 static void endpage(gfxdevice_t*dev)
850 {
851     swfoutput_internal*i = (swfoutput_internal*)dev->internal;
852     if(i->pagefinished)
853       return;
854     if(i->shapeid>=0)
855       endshape(dev);
856     if(i->textid>=0)
857       endtext(dev);
858     
859     while(i->clippos)
860         dev->endclip(dev);
861
862     if(i->config_watermark) {
863         insert_watermark(dev, 1);
864     }
865
866     i->pagefinished = 1;
867 }
868
869 void swf_startframe(gfxdevice_t*dev, int width, int height)
870 {
871     swfoutput_internal*i = (swfoutput_internal*)dev->internal;
872     if(!i->firstpage && !i->pagefinished)
873         endpage(dev);
874     msg("<verbose> Starting new SWF page of size %dx%d", width, height);
875
876     swf_GetMatrix(0, &i->page_matrix);
877     i->page_matrix.tx = 0;
878     i->page_matrix.ty = 0;
879     i->min_x = 0;
880     i->min_y = 0;
881     i->max_x = width;
882     i->max_y = height;
883     i->watermarks = 0;
884
885     /* create a bbox structure with the page size. This is used
886        for clipping shape and text bounding boxes. As we don't want to
887        generate bounding boxes which extend beyond the movie size (in
888        order to not confuse Flash), we clip everything against i->pagebbox */
889     i->pagebbox.xmin = 0;
890     i->pagebbox.ymin = 0;
891     i->pagebbox.xmax = width*20;
892     i->pagebbox.ymax = height*20;
893
894     /* increase SWF's bounding box */
895     swf_ExpandRect2(&i->swf->movieSize, &i->pagebbox);
896
897     i->lastframeno = i->frameno;
898     i->firstpage = 0;
899     i->pagefinished = 0;
900 }
901
902 void swf_endframe(gfxdevice_t*dev)
903 {
904     swfoutput_internal*i = (swfoutput_internal*)dev->internal;
905     
906     if(!i->pagefinished)
907         endpage(dev);
908
909     if( (i->swf->fileVersion <= 8) && (i->config_insertstoptag) ) {
910         ActionTAG*atag=0;
911         atag = action_Stop(atag);
912         atag = action_End(atag);
913         i->tag = swf_InsertTag(i->tag,ST_DOACTION);
914         swf_ActionSet(i->tag,atag);
915     }
916     i->tag = swf_InsertTag(i->tag,ST_SHOWFRAME);
917     i->frameno ++;
918     
919     for(i->depth;i->depth>i->startdepth;i->depth--) {
920         i->tag = swf_InsertTag(i->tag,ST_REMOVEOBJECT2);
921         swf_SetU16(i->tag,i->depth);
922     }
923     i->depth = i->startdepth;
924 }
925
926 static void setBackground(gfxdevice_t*dev, int x1, int y1, int x2, int y2)
927 {
928     swfoutput_internal*i = (swfoutput_internal*)dev->internal;
929     RGBA rgb;
930     rgb.a = rgb.r = rgb.g = rgb.b = 0xff;
931     SRECT r;
932     SHAPE* s;
933     int ls1=0,fs1=0;
934     int shapeid = getNewID(dev);
935     r.xmin = x1;
936     r.ymin = y1;
937     r.xmax = x2;
938     r.ymax = y2;
939     i->tag = swf_InsertTag(i->tag, ST_DEFINESHAPE);
940     swf_ShapeNew(&s);
941     fs1 = swf_ShapeAddSolidFillStyle(s, &rgb);
942     swf_SetU16(i->tag,shapeid);
943     swf_SetRect(i->tag,&r);
944     swf_SetShapeHeader(i->tag,s);
945     swf_ShapeSetAll(i->tag,s,x1,y1,ls1,fs1,0);
946     swf_ShapeSetLine(i->tag,s,(x2-x1),0);
947     swf_ShapeSetLine(i->tag,s,0,(y2-y1));
948     swf_ShapeSetLine(i->tag,s,(x1-x2),0);
949     swf_ShapeSetLine(i->tag,s,0,(y1-y2));
950     swf_ShapeSetEnd(i->tag);
951     swf_ShapeFree(s);
952     i->tag = swf_InsertTag(i->tag, ST_PLACEOBJECT2);
953     swf_ObjectPlace(i->tag,shapeid,getNewDepth(dev),0,0,0);
954     i->tag = swf_InsertTag(i->tag, ST_PLACEOBJECT2);
955     swf_ObjectPlaceClip(i->tag,shapeid,getNewDepth(dev),0,0,0,65535);
956 }
957
958 /* initialize the swf writer */
959 void gfxdevice_swf_init(gfxdevice_t* dev)
960 {
961     memset(dev, 0, sizeof(gfxdevice_t));
962     
963     dev->name = "swf";
964
965     dev->internal = init_internal_struct();
966
967     dev->startpage = swf_startframe;
968     dev->endpage = swf_endframe;
969     dev->finish = swf_finish;
970     dev->fillbitmap = swf_fillbitmap;
971     dev->setparameter = swf_setparameter;
972     dev->stroke = swf_stroke;
973     dev->startclip = swf_startclip;
974     dev->endclip = swf_endclip;
975     dev->fill = swf_fill;
976     dev->fillbitmap = swf_fillbitmap;
977     dev->fillgradient = swf_fillgradient;
978     dev->addfont = swf_addfont;
979     dev->drawchar = swf_drawchar;
980     dev->drawlink = swf_drawlink;
981
982     swfoutput_internal*i = (swfoutput_internal*)dev->internal;
983     i->dev = dev;
984
985     RGBA rgb;
986
987     msg("<verbose> initializing swf output\n", i->max_x,i->max_y);
988
989     i->swffont = 0;
990    
991     i->swf = (SWF*)rfx_calloc(sizeof(SWF));
992     i->swf->fileVersion    = i->config_flashversion;
993     i->swf->frameRate      = i->config_framerate*0x100;
994     i->swf->movieSize.xmin = 0;
995     i->swf->movieSize.ymin = 0;
996     i->swf->movieSize.xmax = 0;
997     i->swf->movieSize.ymax = 0;
998     
999     i->swf->firstTag = swf_InsertTag(NULL,ST_SETBACKGROUNDCOLOR);
1000     i->tag = i->swf->firstTag;
1001     rgb.a = rgb.r = rgb.g = rgb.b = 0xff;
1002     rgb.r = 0;
1003     swf_SetRGB(i->tag,&rgb);
1004
1005     i->startdepth = i->depth = 0;
1006     
1007     if(i->config_protect)
1008       i->tag = swf_InsertTag(i->tag, ST_PROTECT);
1009 }
1010
1011 static void startshape(gfxdevice_t*dev)
1012 {
1013     swfoutput_internal*i = (swfoutput_internal*)dev->internal;
1014     SRECT r;
1015
1016     if(i->shapeid>=0)
1017         return;
1018     //if(i->chardatapos && i->chardata[i->chardatapos-1].color.a)
1019     endtext(dev);
1020
1021     i->tag = swf_InsertTag(i->tag,ST_DEFINESHAPE3);
1022
1023     swf_ShapeNew(&i->shape);
1024     i->linestyleid = swf_ShapeAddLineStyle(i->shape,i->linewidth,&i->strokergb);
1025     i->fillstyleid = swf_ShapeAddSolidFillStyle(i->shape,&i->fillrgb);
1026     if(i->mark) {
1027         RGBA markcol = {0,i->mark[0],i->mark[1],i->mark[2]};
1028         swf_ShapeAddSolidFillStyle(i->shape,&markcol);
1029     }
1030
1031     i->shapeid = getNewID(dev);
1032     
1033     msg("<debug> Using shape id %d", i->shapeid);
1034
1035     swf_SetU16(i->tag,i->shapeid);  // ID
1036
1037     i->bboxrectpos = i->tag->len;
1038     /* changed later */
1039     swf_SetRect(i->tag,&i->pagebbox);
1040    
1041     memset(&i->bboxrect, 0, sizeof(i->bboxrect));
1042
1043     swf_SetShapeStyles(i->tag,i->shape);
1044     swf_ShapeCountBits(i->shape,NULL,NULL);
1045     swf_SetShapeBits(i->tag,i->shape);
1046
1047     /* TODO: do we really need this? */
1048     //swf_ShapeSetAll(i->tag,i->shape,/*x*/0,/*y*/0,i->linestyleid,0,0);
1049     //swf_ShapeSetAll(i->tag,i->shape,/*x*/UNDEFINED_COORD,/*y*/UNDEFINED_COORD,i->linestyleid,0,0);
1050     i->swflastx=i->swflasty=UNDEFINED_COORD;
1051     i->lastwasfill = -1;
1052     i->shapeisempty = 1;
1053 }
1054
1055 static void starttext(gfxdevice_t*dev)
1056 {
1057     swfoutput_internal*i = (swfoutput_internal*)dev->internal;
1058     if(i->shapeid>=0)
1059         endshape(dev);
1060
1061     if(i->config_watermark) {
1062         insert_watermark(dev, 0);
1063     }
1064     i->textid = getNewID(dev);
1065     i->swflastx=i->swflasty=0;
1066 }
1067             
1068
1069 /* TODO: move to ../lib/rfxswf */
1070 void changeRect(gfxdevice_t*dev, TAG*tag, int pos, SRECT*newrect)
1071 {
1072     swfoutput_internal*i = (swfoutput_internal*)dev->internal;
1073     /* determine length of old rect */
1074     tag->pos = pos;
1075     tag->readBit = 0;
1076     SRECT old;
1077     swf_GetRect(tag, &old);
1078     swf_ResetReadBits(tag);
1079     int pos_end = tag->pos;
1080
1081     int len = tag->len - pos_end;
1082     U8*data = (U8*)malloc(len);
1083     memcpy(data, &tag->data[pos_end], len);
1084     tag->writeBit = 0;
1085     tag->len = pos;
1086     swf_SetRect(tag, newrect);
1087     swf_SetBlock(tag, data, len);
1088     free(data);
1089     tag->pos = tag->readBit = 0;
1090 }
1091
1092 void cancelshape(gfxdevice_t*dev)
1093 {
1094     swfoutput_internal*i = (swfoutput_internal*)dev->internal;
1095     /* delete old shape tag */
1096     TAG*todel = i->tag;
1097     i->tag = i->tag->prev;
1098     swf_DeleteTag(todel);
1099     if(i->shape) {swf_ShapeFree(i->shape);i->shape=0;}
1100     i->shapeid = -1;
1101     i->bboxrectpos = -1;
1102
1103 //    i->currentswfid--; // this was an *exceptionally* bad idea
1104 }
1105
1106 void fixAreas(gfxdevice_t*dev)
1107 {
1108     swfoutput_internal*i = (swfoutput_internal*)dev->internal;
1109     if(!i->shapeisempty && i->fill &&
1110        (i->bboxrect.xmin == i->bboxrect.xmax ||
1111         i->bboxrect.ymin == i->bboxrect.ymax) &&
1112         i->config_minlinewidth >= 0.001
1113        ) {
1114         msg("<debug> Shape has size 0: width=%.2f height=%.2f",
1115                 (i->bboxrect.xmax-i->bboxrect.xmin)/20.0,
1116                 (i->bboxrect.ymax-i->bboxrect.ymin)/20.0
1117                 );
1118     
1119         SRECT r = i->bboxrect;
1120         
1121         if(r.xmin == r.xmax && r.ymin == r.ymax) {
1122             /* this thing comes down to a single dot- nothing to fix here */
1123             return;
1124         }
1125
1126         cancelshape(dev);
1127
1128         RGBA save_col = i->strokergb;
1129         int  save_width = i->linewidth;
1130
1131         i->strokergb = i->fillrgb;
1132         i->linewidth = (int)(i->config_minlinewidth*20);
1133         if(i->linewidth==0) i->linewidth = 1;
1134         
1135         startshape(dev);
1136         stopFill(dev);
1137
1138         moveto(dev, i->tag, r.xmin/20.0,r.ymin/20.0);
1139         lineto(dev, i->tag, r.xmax/20.0,r.ymax/20.0);
1140
1141         i->strokergb = save_col;
1142         i->linewidth = save_width;
1143     }
1144     
1145 }
1146
1147 static void endshape_noput(gfxdevice_t*dev)
1148 {
1149     swfoutput_internal*i = (swfoutput_internal*)dev->internal;
1150     if(i->shapeid<0) 
1151         return;
1152     //changeRect(dev, i->tag, i->bboxrectpos, &i->bboxrect);
1153     i->shapeid = -1;
1154     if(i->shape) {
1155         swf_ShapeFree(i->shape);
1156         i->shape=0;
1157     }
1158     i->fill=0;
1159     i->shapeposx=0;
1160     i->shapeposy=0;
1161 }
1162
1163 static void endshape(gfxdevice_t*dev)
1164 {
1165     swfoutput_internal*i = (swfoutput_internal*)dev->internal;
1166     if(i->shapeid<0) 
1167         return;
1168
1169     fixAreas(dev);
1170         
1171     if(i->shapeisempty ||
1172        /*bbox empty?*/
1173        (i->bboxrect.xmin == i->bboxrect.xmax && 
1174         i->bboxrect.ymin == i->bboxrect.ymax))
1175     {
1176         // delete the shape again, we didn't do anything
1177         msg("<debug> cancelling shape: bbox is (%f,%f,%f,%f)",
1178                 i->bboxrect.xmin /20.0,
1179                 i->bboxrect.ymin /20.0,
1180                 i->bboxrect.xmax /20.0,
1181                 i->bboxrect.ymax /20.0
1182                 );
1183         cancelshape(dev);
1184         return;
1185     }
1186     
1187     swf_ShapeSetEnd(i->tag);
1188
1189     SRECT r = swf_ClipRect(i->pagebbox, i->bboxrect);
1190     changeRect(dev, i->tag, i->bboxrectpos, &r);
1191
1192     msg("<trace> Placing shape ID %d", i->shapeid);
1193
1194     i->tag = swf_InsertTag(i->tag,ST_PLACEOBJECT2);
1195     MATRIX m = i->page_matrix;
1196     m.tx += i->shapeposx;
1197     m.ty += i->shapeposy;
1198     swf_ObjectPlace(i->tag,i->shapeid,getNewDepth(dev),&m,NULL,NULL);
1199
1200     if(i->config_animate) {
1201         i->tag = swf_InsertTag(i->tag,ST_SHOWFRAME);
1202     }
1203
1204     swf_ShapeFree(i->shape);
1205     i->shape = 0;
1206     i->shapeid = -1;
1207     i->bboxrectpos = -1;
1208
1209     i->fill=0;
1210     i->shapeposx=0;
1211     i->shapeposy=0;
1212 }
1213
1214 void wipeSWF(SWF*swf)
1215 {
1216     TAG*tag = swf->firstTag;
1217     while(tag) {
1218         TAG*next = tag->next;
1219         if(tag->id != ST_SETBACKGROUNDCOLOR &&
1220            tag->id != ST_END &&
1221            tag->id != ST_DOACTION &&
1222            tag->id != ST_SHOWFRAME) {
1223             swf_DeleteTag(tag);
1224         }
1225         tag = next;
1226     }
1227 }
1228
1229 void swfoutput_finalize(gfxdevice_t*dev)
1230 {
1231     swfoutput_internal*i = (swfoutput_internal*)dev->internal;
1232
1233     if(i->tag && i->tag->id == ST_END)
1234         return; //already done
1235
1236     if(i->config_bboxvars) {
1237         TAG* tag = swf_InsertTag(i->swf->firstTag, ST_DOACTION);
1238         ActionTAG*a = 0;
1239         a = action_PushString(a, "xmin");
1240         a = action_PushFloat(a, i->swf->movieSize.xmin / 20.0);
1241         a = action_SetVariable(a);
1242         a = action_PushString(a, "ymin");
1243         a = action_PushFloat(a, i->swf->movieSize.ymin / 20.0);
1244         a = action_SetVariable(a);
1245         a = action_PushString(a, "xmax");
1246         a = action_PushFloat(a, i->swf->movieSize.xmax / 20.0);
1247         a = action_SetVariable(a);
1248         a = action_PushString(a, "ymax");
1249         a = action_PushFloat(a, i->swf->movieSize.ymax / 20.0);
1250         a = action_SetVariable(a);
1251         a = action_PushString(a, "width");
1252         a = action_PushFloat(a, (i->swf->movieSize.xmax - i->swf->movieSize.xmin) / 20.0);
1253         a = action_SetVariable(a);
1254         a = action_PushString(a, "height");
1255         a = action_PushFloat(a, (i->swf->movieSize.ymax - i->swf->movieSize.ymin) / 20.0);
1256         a = action_SetVariable(a);
1257         a = action_End(a);
1258         swf_ActionSet(tag, a);
1259         swf_ActionFree(a);
1260     }
1261
1262     if(i->mark) {
1263         free(i->mark);i->mark = 0;
1264     }
1265
1266     endpage(dev);
1267     fontlist_t *iterator = i->fontlist;
1268     while(iterator) {
1269         TAG*mtag = i->swf->firstTag;
1270         if(iterator->swffont) {
1271             if(!i->config_storeallcharacters) {
1272                 msg("<debug> Reducing font %s", iterator->swffont->name);
1273                 swf_FontReduce(iterator->swffont);
1274             }
1275             int used = iterator->swffont->use && iterator->swffont->use->used_glyphs;
1276             if(used) {
1277                 mtag = swf_InsertTag(mtag, ST_DEFINEFONT2);
1278                 swf_FontSetDefine2(mtag, iterator->swffont);
1279             }
1280         }
1281
1282         iterator = iterator->next;
1283     }
1284     i->tag = swf_InsertTag(i->tag,ST_END);
1285     TAG* tag = i->tag->prev;
1286
1287     /* remove the removeobject2 tags between the last ST_SHOWFRAME
1288        and the ST_END- they confuse the flash player  */
1289     while(tag->id == ST_REMOVEOBJECT2) {
1290         TAG* prev = tag->prev;
1291         swf_DeleteTag(tag);
1292         tag = prev;
1293     }
1294     
1295     if(i->overflow) {
1296         wipeSWF(i->swf);
1297     }
1298     if(i->config_enablezlib || i->config_flashversion>=6) {
1299         i->swf->compressed = 1;
1300     }
1301
1302     /* Initialize AVM2 if it is a Flash9 file */
1303     if(i->config_flashversion>=9 && i->config_insertstoptag) {
1304         AVM2_InsertStops(i->swf);
1305     }
1306 //    if(i->config_reordertags)
1307 //      swf_Optimize(i->swf);
1308 }
1309
1310 int swfresult_save(gfxresult_t*gfx, const char*filename)
1311 {
1312     SWF*swf = (SWF*)gfx->internal;
1313     int fi;
1314     if(filename)
1315      fi = open(filename, O_BINARY|O_CREAT|O_TRUNC|O_WRONLY, 0777);
1316     else
1317      fi = 1; // stdout
1318     
1319     if(fi<=0) {
1320         msg("<fatal> Could not create \"%s\". ", FIXNULL(filename));
1321         return -1;
1322     }
1323     
1324     if FAILED(swf_WriteSWF(fi,swf)) 
1325         msg("<error> WriteSWF() failed.\n");
1326
1327     if(filename)
1328      close(fi);
1329     return 0;
1330 }
1331 void* swfresult_get(gfxresult_t*gfx, const char*name)
1332 {
1333     SWF*swf = (SWF*)gfx->internal;
1334     if(!strcmp(name, "swf")) {
1335         return (void*)swf_CopySWF(swf);
1336     } else if(!strcmp(name, "xmin")) {
1337         return (void*)(swf->movieSize.xmin/20);
1338     } else if(!strcmp(name, "ymin")) {
1339         return (void*)(swf->movieSize.ymin/20);
1340     } else if(!strcmp(name, "xmax")) {
1341         return (void*)(swf->movieSize.xmax/20);
1342     } else if(!strcmp(name, "ymax")) {
1343         return (void*)(swf->movieSize.ymax/20);
1344     } else if(!strcmp(name, "width")) {
1345         return (void*)((swf->movieSize.xmax - swf->movieSize.xmin)/20);
1346     } else if(!strcmp(name, "height")) {
1347         return (void*)((swf->movieSize.ymax - swf->movieSize.ymin)/20);
1348     }
1349     return 0;
1350 }
1351 void swfresult_destroy(gfxresult_t*gfx)
1352 {
1353     if(gfx->internal) {
1354         swf_FreeTags((SWF*)gfx->internal);
1355         free(gfx->internal);
1356         gfx->internal = 0;
1357     }
1358     memset(gfx, 0, sizeof(gfxresult_t));
1359     free(gfx);
1360 }
1361
1362 static void swfoutput_destroy(gfxdevice_t* dev);
1363
1364 gfxresult_t* swf_finish(gfxdevice_t* dev)
1365 {
1366     swfoutput_internal*i = (swfoutput_internal*)dev->internal;
1367     gfxresult_t*result;
1368
1369     if(i->config_linktarget) {
1370         free(i->config_linktarget);
1371         i->config_linktarget = 0;
1372     }
1373
1374     swfoutput_finalize(dev);
1375     SWF* swf = i->swf;i->swf = 0;
1376     swfoutput_destroy(dev);
1377
1378     result = (gfxresult_t*)rfx_calloc(sizeof(gfxresult_t));
1379     result->internal = swf;
1380     result->save = swfresult_save;
1381     result->write = 0;
1382     result->get = swfresult_get;
1383     result->destroy = swfresult_destroy;
1384     return result;
1385 }
1386
1387 /* Perform cleaning up */
1388 static void swfoutput_destroy(gfxdevice_t* dev) 
1389 {
1390     swfoutput_internal*i = (swfoutput_internal*)dev->internal;
1391     if(!i) {
1392         /* not initialized yet- nothing to destroy */
1393         return;
1394     }
1395
1396     fontlist_t *tmp,*iterator = i->fontlist;
1397     while(iterator) {
1398         if(iterator->swffont) {
1399             swf_FontFree(iterator->swffont);iterator->swffont=0;
1400         }
1401         tmp = iterator;
1402         iterator = iterator->next;
1403         free(tmp);
1404     }
1405     if(i->swf) {swf_FreeTags(i->swf);free(i->swf);i->swf = 0;}
1406
1407     free(i);i=0;
1408     memset(dev, 0, sizeof(gfxdevice_t));
1409 }
1410
1411 static void swfoutput_setstrokecolor(gfxdevice_t* dev, U8 r, U8 g, U8 b, U8 a)
1412 {
1413     swfoutput_internal*i = (swfoutput_internal*)dev->internal;
1414     if(i->strokergb.r == r &&
1415        i->strokergb.g == g &&
1416        i->strokergb.b == b &&
1417        i->strokergb.a == a) return;
1418
1419     if(i->shapeid>=0)
1420      endshape(dev);
1421     i->strokergb.r = r;
1422     i->strokergb.g = g;
1423     i->strokergb.b = b;
1424     i->strokergb.a = a;
1425 }
1426
1427 //#define ROUND_UP 19
1428 //#define ROUND_UP 10
1429
1430 static void swfoutput_setlinewidth(gfxdevice_t*dev, double _linewidth)
1431 {
1432     swfoutput_internal*i = (swfoutput_internal*)dev->internal;
1433     if(i->linewidth == (U16)(_linewidth*20+19.0/20.0))
1434         return;
1435     if(i->shapeid>=0)
1436         endshape(dev);
1437     i->linewidth = (U16)(_linewidth*20+19.0/20.0);
1438 }
1439
1440
1441 static void drawlink(gfxdevice_t*dev, ActionTAG*,ActionTAG*, gfxline_t*points, char mouseover);
1442 static void swfoutput_namedlink(gfxdevice_t*dev, char*name, gfxline_t*points);
1443 static void swfoutput_linktopage(gfxdevice_t*dev, int page, gfxline_t*points);
1444 static void swfoutput_linktourl(gfxdevice_t*dev, const char*url, gfxline_t*points);
1445
1446 /*void swfoutput_drawlink(gfxdevice_t*dev, char*url, gfxline_t*points)
1447 {
1448     swfoutput_internal*i = (swfoutput_internal*)dev->internal;
1449     dev->drawlink(dev, points, url);
1450 }*/
1451
1452 void swf_drawlink(gfxdevice_t*dev, gfxline_t*points, const char*url)
1453 {
1454     swfoutput_internal*i = (swfoutput_internal*)dev->internal;
1455
1456     if(!strncmp("http://pdf2swf:", url, 15)) {
1457         char*tmp = strdup(url);
1458         int l = strlen(tmp);
1459         if(tmp[l-1] == '/')
1460            tmp[l-1] = 0;
1461         swfoutput_namedlink(dev, tmp+15, points);
1462         free(tmp);
1463         return;
1464     } else if(!strncmp("page", url, 4)) {
1465         int t, nodigit=0;
1466         for(t=4;url[t];t++)
1467             if(url[t]<'0' || url[t]>'9')
1468                 nodigit = 1;
1469         if(!nodigit) {
1470             int page = atoi(&url[4]);
1471             if(page<0) page = 0;
1472             swfoutput_linktopage(dev, page, points);
1473         }
1474     } else {
1475         swfoutput_linktourl(dev, url, points);
1476     }
1477 }
1478 void swfoutput_linktourl(gfxdevice_t*dev, const char*url, gfxline_t*points)
1479 {
1480     ActionTAG* actions = 0;
1481     swfoutput_internal*i = (swfoutput_internal*)dev->internal;
1482     if(i->shapeid>=0)
1483         endshape(dev);
1484     if(i->textid>=0)
1485         endtext(dev);
1486     
1487     if(i->config_externallinkfunction) {
1488         actions = action_PushString(actions, url); //parameter
1489         actions = action_PushInt(actions, 1); //number of parameters (1)
1490         actions = action_PushString(actions, i->config_externallinkfunction); //function name
1491         actions = action_CallFunction(actions);
1492     } else if(!i->config_linktarget) {
1493         if(!i->config_opennewwindow)
1494           actions = action_GetUrl(actions, url, "_parent");
1495         else
1496           actions = action_GetUrl(actions, url, "_this");
1497     } else {
1498         actions = action_GetUrl(actions, url, i->config_linktarget);
1499     }
1500     actions = action_End(actions);
1501    
1502     drawlink(dev, actions, 0, points, 0);
1503 }
1504 void swfoutput_linktopage(gfxdevice_t*dev, int page, gfxline_t*points)
1505 {
1506     swfoutput_internal*i = (swfoutput_internal*)dev->internal;
1507     ActionTAG* actions = 0;
1508
1509     if(i->shapeid>=0)
1510         endshape(dev);
1511     if(i->textid>=0)
1512         endtext(dev);
1513   
1514     if(!i->config_internallinkfunction) {
1515         actions = action_GotoFrame(actions, page-1);
1516         actions = action_End(actions);
1517     } else {
1518         actions = action_PushInt(actions, page); //parameter
1519         actions = action_PushInt(actions, 1); //number of parameters (1)
1520         actions = action_PushString(actions, i->config_internallinkfunction); //function name
1521         actions = action_CallFunction(actions);
1522         actions = action_End(actions);
1523     }
1524
1525     drawlink(dev, actions, 0, points, 0);
1526 }
1527
1528 /* Named Links (a.k.a. Acrobatmenu) are used to implement various gadgets
1529    of the viewer objects, like subtitles, index elements etc.
1530 */
1531 void swfoutput_namedlink(gfxdevice_t*dev, char*name, gfxline_t*points)
1532 {
1533     swfoutput_internal*i = (swfoutput_internal*)dev->internal;
1534     ActionTAG *actions1,*actions2;
1535     char*tmp = strdup(name);
1536     char mouseover = 1;
1537
1538     if(i->shapeid>=0)
1539         endshape(dev);
1540     if(i->textid>=0)
1541         endtext(dev);
1542
1543     if(!strncmp(tmp, "call:", 5))
1544     {
1545         char*x = strchr(&tmp[5], ':');
1546         if(!x) {
1547             actions1 = action_PushInt(0, 0); //number of parameters (0)
1548             actions1 = action_PushString(actions1, &tmp[5]); //function name
1549             actions1 = action_CallFunction(actions1);
1550             actions1 = action_End(actions1);
1551         } else {
1552             *x = 0;
1553             actions1 = action_PushString(0, x+1); //parameter
1554             actions1 = action_PushInt(actions1, 1); //number of parameters (1)
1555             actions1 = action_PushString(actions1, &tmp[5]); //function name
1556             actions1 = action_CallFunction(actions1);
1557             actions1 = action_End(actions1);
1558         }
1559         actions2 = action_End(0);
1560         mouseover = 0;
1561     }
1562     else
1563     {
1564         actions1 = action_PushString(0, "/:subtitle");
1565         actions1 = action_PushString(actions1, name);
1566         actions1 = action_SetVariable(actions1);
1567         actions1 = action_End(actions1);
1568
1569         actions2 = action_PushString(0, "/:subtitle");
1570         actions2 = action_PushString(actions2, "");
1571         actions2 = action_SetVariable(actions2);
1572         actions2 = action_End(actions2);
1573     }
1574
1575     drawlink(dev, actions1, actions2, points, mouseover);
1576
1577     swf_ActionFree(actions1);
1578     swf_ActionFree(actions2);
1579     free(tmp);
1580 }
1581
1582 static void drawgfxline(gfxdevice_t*dev, gfxline_t*line)
1583 {
1584     swfoutput_internal*i = (swfoutput_internal*)dev->internal;
1585     gfxcoord_t lastx=0,lasty=0,px=0,py=0;
1586     char lastwasmoveto;
1587     int lines= 0, splines=0;
1588     while(1) {
1589         if(!line)
1590             break;
1591         /* check whether the next segment is zero */
1592         if(line->type == gfx_moveTo) {
1593             moveto(dev, i->tag, line->x, line->y);
1594             px = lastx = line->x;
1595             py = lasty = line->y;
1596             lastwasmoveto = 1;
1597         } if(line->type == gfx_lineTo) {
1598             lineto(dev, i->tag, line->x, line->y);
1599             px = line->x;
1600             py = line->y;
1601             lastwasmoveto = 0;
1602             lines++;
1603         } else if(line->type == gfx_splineTo) {
1604             plotxy_t s,p;
1605             s.x = line->sx;p.x = line->x;
1606             s.y = line->sy;p.y = line->y;
1607             splineto(dev, i->tag, s, p);
1608             px = line->x;
1609             py = line->y;
1610             lastwasmoveto = 0;
1611             splines++;
1612         }
1613         line = line->next;
1614     }
1615     msg("<trace> drawgfxline, %d lines, %d splines", lines, splines);
1616 }
1617
1618
1619 static void drawlink(gfxdevice_t*dev, ActionTAG*actions1, ActionTAG*actions2, gfxline_t*points, char mouseover)
1620 {
1621     swfoutput_internal*i = (swfoutput_internal*)dev->internal;
1622     RGBA rgb;
1623     SRECT r;
1624     int lsid=0;
1625     int fsid;
1626     int myshapeid;
1627     int myshapeid2;
1628     double posx = 0;
1629     double posy = 0;
1630     int buttonid = getNewID(dev);
1631     gfxbbox_t bbox = gfxline_getbbox(points);
1632
1633     /* shape */
1634     myshapeid = getNewID(dev);
1635     i->tag = swf_InsertTag(i->tag,ST_DEFINESHAPE3);
1636     swf_ShapeNew(&i->shape);
1637     rgb.r = rgb.b = rgb.a = rgb.g = 0; 
1638     fsid = swf_ShapeAddSolidFillStyle(i->shape,&rgb);
1639     swf_SetU16(i->tag, myshapeid);
1640     r.xmin = (int)(bbox.xmin*20);
1641     r.ymin = (int)(bbox.ymin*20);
1642     r.xmax = (int)(bbox.xmax*20);
1643     r.ymax = (int)(bbox.ymax*20);
1644     r = swf_ClipRect(i->pagebbox, r);
1645     swf_SetRect(i->tag,&r);
1646     swf_SetShapeStyles(i->tag,i->shape);
1647     swf_ShapeCountBits(i->shape,NULL,NULL);
1648     swf_SetShapeBits(i->tag,i->shape);
1649     swf_ShapeSetAll(i->tag,i->shape,/*x*/0,/*y*/0,0,fsid,0);
1650     i->swflastx = i->swflasty = 0;
1651     drawgfxline(dev, points);
1652     swf_ShapeSetEnd(i->tag);
1653
1654     /* shape2 */
1655     myshapeid2 = getNewID(dev);
1656     i->tag = swf_InsertTag(i->tag,ST_DEFINESHAPE3);
1657     swf_ShapeNew(&i->shape);
1658     
1659     rgb = i->config_linkcolor;
1660
1661     fsid = swf_ShapeAddSolidFillStyle(i->shape,&rgb);
1662     swf_SetU16(i->tag, myshapeid2);
1663     r.xmin = (int)(bbox.xmin*20);
1664     r.ymin = (int)(bbox.ymin*20);
1665     r.xmax = (int)(bbox.xmax*20);
1666     r.ymax = (int)(bbox.ymax*20);
1667     r = swf_ClipRect(i->pagebbox, r);
1668     swf_SetRect(i->tag,&r);
1669     swf_SetShapeStyles(i->tag,i->shape);
1670     swf_ShapeCountBits(i->shape,NULL,NULL);
1671     swf_SetShapeBits(i->tag,i->shape);
1672     swf_ShapeSetAll(i->tag,i->shape,/*x*/0,/*y*/0,0,fsid,0);
1673     i->swflastx = i->swflasty = 0;
1674     drawgfxline(dev, points);
1675     swf_ShapeSetEnd(i->tag);
1676
1677     if(!mouseover)
1678     {
1679         i->tag = swf_InsertTag(i->tag,ST_DEFINEBUTTON);
1680         swf_SetU16(i->tag,buttonid); //id
1681         swf_ButtonSetFlags(i->tag, 0); //menu=no
1682         swf_ButtonSetRecord(i->tag,0x01,myshapeid,i->depth,0,0);
1683         swf_ButtonSetRecord(i->tag,0x02,myshapeid2,i->depth,0,0);
1684         swf_ButtonSetRecord(i->tag,0x04,myshapeid2,i->depth,0,0);
1685         swf_ButtonSetRecord(i->tag,0x08,myshapeid,i->depth,0,0);
1686         swf_SetU8(i->tag,0);
1687         swf_ActionSet(i->tag,actions1);
1688         swf_SetU8(i->tag,0);
1689     }
1690     else
1691     {
1692         i->tag = swf_InsertTag(i->tag,ST_DEFINEBUTTON2);
1693         swf_SetU16(i->tag,buttonid); //id
1694         swf_ButtonSetFlags(i->tag, 0); //menu=no
1695         swf_ButtonSetRecord(i->tag,0x01,myshapeid,i->depth,0,0);
1696         swf_ButtonSetRecord(i->tag,0x02,myshapeid2,i->depth,0,0);
1697         swf_ButtonSetRecord(i->tag,0x04,myshapeid2,i->depth,0,0);
1698         swf_ButtonSetRecord(i->tag,0x08,myshapeid,i->depth,0,0);
1699         swf_SetU8(i->tag,0); // end of button records
1700         swf_ButtonSetCondition(i->tag, BC_IDLE_OVERUP);
1701         swf_ActionSet(i->tag,actions1);
1702         if(actions2) {
1703             swf_ButtonSetCondition(i->tag, BC_OVERUP_IDLE);
1704             swf_ActionSet(i->tag,actions2);
1705             swf_SetU8(i->tag,0);
1706             swf_ButtonPostProcess(i->tag, 2);
1707         } else {
1708             swf_SetU8(i->tag,0);
1709             swf_ButtonPostProcess(i->tag, 1);
1710         }
1711     }
1712     char name[80];
1713     sprintf(name, "link%d", buttonid);
1714     
1715     msg("<trace> Placing link ID %d", buttonid);
1716     i->tag = swf_InsertTag(i->tag,ST_PLACEOBJECT2);
1717
1718     if(posx!=0 || posy!=0) {
1719         SPOINT p;
1720         p.x = (int)(posx*20);
1721         p.y = (int)(posy*20);
1722         p = swf_TurnPoint(p, &i->page_matrix);
1723         MATRIX m;
1724         m = i->page_matrix;
1725         m.tx = p.x;
1726         m.ty = p.y;
1727         swf_ObjectPlace(i->tag, buttonid, getNewDepth(dev),&m,0,name);
1728     } else {
1729         swf_ObjectPlace(i->tag, buttonid, getNewDepth(dev),&i->page_matrix,0,name);
1730     }
1731 }
1732
1733       
1734 ///////////
1735 /*
1736 for(t=0;t<picpos;t++)
1737       {
1738           if(pic_xids[t] == xid &&
1739              pic_yids[t] == yid) {
1740               width = pic_width[t];
1741               height = pic_height[t];
1742               found = t;break;
1743           }
1744       }
1745           pic_ids[picpos] = swfoutput_drawimagelosslessN(&output, pic, pal, width, height, x1,y1,x2,y2,x3,y3,x4,y4, numpalette);
1746           pic_xids[picpos] = xid;
1747           pic_yids[picpos] = yid;
1748           pic_width[picpos] = width;
1749           pic_height[picpos] = height;
1750           if(picpos<1024)
1751               picpos++;
1752             pic[width*y+x] = buf[0];
1753             xid+=x*buf[0]+1;
1754             yid+=y*buf[0]*3+1;
1755       
1756             xid += pal[1].r*3 + pal[1].g*11 + pal[1].b*17;
1757       yid += pal[1].r*7 + pal[1].g*5 + pal[1].b*23;
1758       
1759       int xid = 0;
1760       int yid = 0;
1761           xid += x*r+x*b*3+x*g*7+x*a*11;
1762           yid += y*r*3+y*b*17+y*g*19+y*a*11;
1763       int t,found = -1;
1764       for(t=0;t<picpos;t++)
1765       {
1766           if(pic_xids[t] == xid &&
1767              pic_yids[t] == yid) {
1768               found = t;break;
1769           }
1770       }
1771       if(found<0) {
1772 */
1773 ///////////
1774
1775
1776 int swf_setparameter(gfxdevice_t*dev, const char*name, const char*value)
1777 {
1778     swfoutput_internal*i = (swfoutput_internal*)dev->internal;
1779
1780     msg("<trace> swfdevice: %s=%s", name, value);
1781     if(!strcmp(name, "jpegsubpixels")) {
1782         i->config_jpegsubpixels = atof(value);
1783     } else if(!strcmp(name, "ppmsubpixels")) {
1784         i->config_ppmsubpixels = atof(value);
1785     } else if(!strcmp(name, "subpixels")) {
1786         i->config_ppmsubpixels = i->config_jpegsubpixels = atof(value);
1787     } else if(!strcmp(name, "drawonlyshapes")) {
1788         i->config_drawonlyshapes = atoi(value);
1789     } else if(!strcmp(name, "ignoredraworder")) {
1790         i->config_ignoredraworder = atoi(value);
1791     } else if(!strcmp(name, "mark")) {
1792         if(!value || !value[0]) {
1793             if(i->mark) free(i->mark);
1794             i->mark = 0;
1795         } else {
1796             int t;
1797             i->mark = strdup("...");
1798             for(t=0;t<3;t++) if(value[t]) i->mark[t] = value[t];
1799         }
1800     } else if(!strcmp(name, "filloverlap")) {
1801         i->config_filloverlap = atoi(value);
1802     } else if(!strcmp(name, "linksopennewwindow")) {
1803         i->config_opennewwindow = atoi(value);
1804     } else if(!strcmp(name, "opennewwindow")) {
1805         i->config_opennewwindow = atoi(value);
1806     } else if(!strcmp(name, "storeallcharacters")) {
1807         i->config_storeallcharacters = atoi(value);
1808     } else if(!strcmp(name, "enablezlib")) {
1809         i->config_enablezlib = atoi(value);
1810     } else if(!strcmp(name, "bboxvars")) {
1811         i->config_bboxvars = atoi(value);
1812     } else if(!strcmp(name, "showclipshapes")) {
1813         i->config_showclipshapes = atoi(value);
1814     } else if(!strcmp(name, "reordertags")) {
1815         i->config_reordertags = atoi(value);
1816     } else if(!strcmp(name, "internallinkfunction")) {
1817         i->config_internallinkfunction = strdup(value);
1818     } else if(!strcmp(name, "externallinkfunction")) {
1819         i->config_externallinkfunction = strdup(value);
1820     } else if(!strcmp(name, "linkfunction")) { //sets both internallinkfunction and externallinkfunction
1821         i->config_internallinkfunction = strdup(value);
1822         i->config_externallinkfunction = strdup(value);
1823     } else if(!strcmp(name, "disable_polygon_conversion")) {
1824         i->config_disable_polygon_conversion = atoi(value);
1825     } else if(!strcmp(name, "normalize_polygon_positions")) {
1826         i->config_normalize_polygon_positions = atoi(value);
1827     } else if(!strcmp(name, "wxwindowparams")) {
1828         i->config_watermark = atoi(value);
1829     } else if(!strcmp(name, "insertstop")) {
1830         i->config_insertstoptag = atoi(value);
1831     } else if(!strcmp(name, "protect")) {
1832         i->config_protect = atoi(value);
1833         if(i->config_protect && i->tag) {
1834             i->tag = swf_InsertTag(i->tag, ST_PROTECT);
1835         }
1836     } else if(!strcmp(name, "flashversion")) {
1837         i->config_flashversion = atoi(value);
1838         if(i->swf) {
1839             i->swf->fileVersion = i->config_flashversion;
1840         }
1841     } else if(!strcmp(name, "framerate")) {
1842         i->config_framerate = atoi(value);
1843         if(i->swf) {
1844             i->swf->frameRate = i->config_framerate*0x100;
1845         }
1846     } else if(!strcmp(name, "minlinewidth")) {
1847         i->config_minlinewidth = atof(value);
1848     } else if(!strcmp(name, "caplinewidth")) {
1849         i->config_caplinewidth = atof(value);
1850     } else if(!strcmp(name, "linktarget")) {
1851         i->config_linktarget = strdup(value);
1852     } else if(!strcmp(name, "dumpfonts")) {
1853         i->config_dumpfonts = atoi(value);
1854     } else if(!strcmp(name, "animate")) {
1855         i->config_animate = atoi(value);
1856     } else if(!strcmp(name, "next_bitmap_is_jpeg")) {
1857         i->jpeg = 1;
1858     } else if(!strcmp(name, "jpegquality")) {
1859         int val = atoi(value);
1860         if(val<0) val=0;
1861         if(val>101) val=101;
1862         i->config_jpegquality = val;
1863     } else if(!strcmp(name, "splinequality")) {
1864         int v = atoi(value);
1865         v = 500-(v*5); // 100% = 0.25 pixel, 0% = 25 pixel
1866         if(v<1) v = 1;
1867         i->config_splinemaxerror = v;
1868     } else if(!strcmp(name, "fontquality")) {
1869         int v = atoi(value);
1870         v = 500-(v*5); // 100% = 0.25 pixel, 0% = 25 pixel
1871         if(v<1) v = 1;
1872         i->config_fontsplinemaxerror = v;
1873     } else if(!strcmp(name, "linkcolor")) {
1874         if(strlen(value)!=8) {
1875             fprintf(stderr, "Unknown format for option 'linkcolor'. (%s <-> RRGGBBAA)\n", value);
1876             return 1;
1877         }
1878 #       define NIBBLE(s) (((s)>='0' && (s)<='9')?((s)-'0'):((s)&0x0f)+9)
1879         i->config_linkcolor.r = NIBBLE(value[0])<<4 | NIBBLE(value[1]);
1880         i->config_linkcolor.g = NIBBLE(value[2])<<4 | NIBBLE(value[3]);
1881         i->config_linkcolor.b = NIBBLE(value[4])<<4 | NIBBLE(value[5]);
1882         i->config_linkcolor.a = NIBBLE(value[6])<<4 | NIBBLE(value[7]);
1883     } else if(!strcmp(name, "help")) {
1884         printf("\nSWF layer options:\n");
1885         printf("jpegdpi=<dpi>               resolution adjustment for jpeg images\n");
1886         printf("jpegsubpixels=<pixels>      resolution adjustment for jpeg images (same as jpegdpi, but in pixels)\n");
1887         printf("ppmdpi=<dpi>                resolution adjustment for lossless images\n");
1888         printf("ppmsubpixels=<pixels        resolution adjustment for  lossless images (same as ppmdpi, but in pixels)\n");
1889         printf("subpixels=<pixels>          shortcut for setting both jpegsubpixels and ppmsubpixels\n");
1890         printf("drawonlyshapes              convert everything to shapes (currently broken)\n");
1891         printf("ignoredraworder             allow to perform a few optimizations for creating smaller SWFs\n");
1892         printf("linksopennewwindow          make links open a new browser window\n");
1893         printf("linktarget                  target window name of new links\n");
1894         printf("linkcolor=<color)           color of links (format: RRGGBBAA)\n");
1895         printf("storeallcharacters          don't reduce the fonts to used characters in the output file\n");
1896         printf("enablezlib                  switch on zlib compression (also done if flashversion>=7)\n");
1897         printf("bboxvars                    store the bounding box of the SWF file in actionscript variables\n");
1898         printf("reordertags=0/1             (default: 1) perform some tag optimizations\n");
1899         printf("internallinkfunction=<name> when the user clicks a internal link (to a different page) in the converted file, this actionscript function is called\n");
1900         printf("externallinkfunction=<name> when the user clicks an external link (e.g. http://www.foo.bar/) on the converted file, this actionscript function is called\n");
1901         printf("disable_polygon_conversion  never convert strokes to polygons (will remove capstyles and joint styles)\n");
1902         printf("caplinewidth=<width>        the minimum thichness a line needs to have so that capstyles become visible (and are converted)\n");
1903         printf("insertstop                  put an ActionScript \"STOP\" tag in every frame\n");
1904         printf("protect                     add a \"protect\" tag to the file, to prevent loading in the Flash editor\n");
1905         printf("flashversion=<version>      the SWF fileversion (6)\n");
1906         printf("minlinewidth=<width>        convert horizontal/vertical boxes smaller than this width to lines (0.05) \n");
1907         printf("animate                     insert a showframe tag after each placeobject (animate draw order of PDF files)\n");
1908         printf("jpegquality=<quality>       set compression quality of jpeg images\n");
1909     } else {
1910         return 0;
1911     }
1912     return 1;
1913 }
1914
1915 // --------------------------------------------------------------------
1916
1917 static CXFORM gfxcxform_to_cxform(gfxcxform_t* c)
1918 {
1919     CXFORM cx;
1920     swf_GetCXForm(0, &cx, 1);
1921     if(!c)
1922         return cx;
1923     if(c->rg!=0 || c->rb!=0 || c->ra!=0 ||
1924        c->gr!=0 || c->gb!=0 || c->ga!=0 ||
1925        c->br!=0 || c->bg!=0 || c->ba!=0 ||
1926        c->ar!=0 || c->ag!=0 || c->ab!=0)
1927         msg("<warning> CXForm not SWF-compatible");
1928
1929     cx.a0 = (S16)(c->aa*256);
1930     cx.r0 = (S16)(c->rr*256);
1931     cx.g0 = (S16)(c->gg*256);
1932     cx.b0 = (S16)(c->bb*256);
1933     cx.a1 = c->ta;
1934     cx.r1 = c->tr;
1935     cx.g1 = c->tg;
1936     cx.b1 = c->tb;
1937     return cx;
1938 }
1939
1940 /* TODO */
1941 static int imageInCache(gfxdevice_t*dev, void*data, int width, int height)
1942 {
1943     return -1;
1944 }
1945 static void addImageToCache(gfxdevice_t*dev, void*data, int width, int height)
1946 {
1947 }
1948     
1949 static int add_image(swfoutput_internal*i, gfximage_t*img, int targetwidth, int targetheight, int* newwidth, int* newheight)
1950 {
1951     gfxdevice_t*dev = i->dev;
1952     RGBA*newpic = 0;
1953     RGBA*mem = (RGBA*)img->data;
1954     
1955     int sizex = img->width;
1956     int sizey = img->height;
1957     int is_jpeg = i->jpeg;
1958     i->jpeg = 0;
1959
1960     int newsizex=sizex, newsizey=sizey;
1961
1962     /// {
1963     if(is_jpeg && i->config_jpegsubpixels) {
1964         newsizex = (int)(targetwidth*i->config_jpegsubpixels + 0.5);
1965         newsizey = (int)(targetheight*i->config_jpegsubpixels + 0.5);
1966     } else if(!is_jpeg && i->config_ppmsubpixels) {
1967         newsizex = (int)(targetwidth*i->config_ppmsubpixels + 0.5);
1968         newsizey = (int)(targetheight*i->config_ppmsubpixels + 0.5);
1969     }
1970     /// }
1971
1972     if(sizex<=0 || sizey<=0)
1973         return -1;
1974     if(newsizex<=0)
1975         newsizex = 1;
1976     if(newsizey<=0)
1977         newsizey = 1;
1978
1979     /* TODO: cache images */
1980     
1981     if(newsizex<sizex || newsizey<sizey) {
1982         msg("<verbose> Scaling %dx%d image to %dx%d", sizex, sizey, newsizex, newsizey);
1983         newpic = swf_ImageScale(mem, sizex, sizey, newsizex, newsizey);
1984         *newwidth = sizex = newsizex;
1985         *newheight  = sizey = newsizey;
1986         mem = newpic;
1987     } else {
1988         *newwidth = newsizex = sizex;
1989         *newheight = newsizey  = sizey;
1990     }
1991
1992     int num_colors = swf_ImageGetNumberOfPaletteEntries(mem,sizex,sizey,0);
1993     int has_alpha = swf_ImageHasAlpha(mem,sizex,sizey);
1994     
1995     msg("<verbose> Drawing %dx%d %s%simage (id %d) at size %dx%d (%dx%d), %s%d colors",
1996             sizex, sizey, 
1997             has_alpha?(has_alpha==2?"semi-transparent ":"transparent "):"", 
1998             is_jpeg?"jpeg-":"", i->currentswfid+1,
1999             newsizex, newsizey,
2000             targetwidth, targetheight,
2001             /*newsizex, newsizey,*/
2002             num_colors>256?">":"", num_colors>256?256:num_colors);
2003
2004     /*RGBA* pal = (RGBA*)rfx_alloc(sizeof(RGBA)*num_colors);
2005     swf_ImageGetNumberOfPaletteEntries(mem,sizex,sizey,pal);
2006     int t;
2007     for(t=0;t<num_colors;t++) {
2008         printf("%02x%02x%02x%02x ",
2009                 pal[t].r, pal[t].g, pal[t].b, pal[t].a);
2010         if((t&7)==7)
2011             printf("\n");
2012     }
2013     printf("\n");*/
2014
2015     int bitid = -1;
2016     int cacheid = imageInCache(dev, mem, sizex, sizey);
2017
2018     if(cacheid<=0) {
2019         bitid = getNewID(dev);
2020         i->tag = swf_AddImage(i->tag, bitid, mem, sizex, sizey, i->config_jpegquality);
2021         addImageToCache(dev, mem, sizex, sizey);
2022     } else {
2023         bitid = cacheid;
2024     }
2025
2026     if(newpic)
2027         free(newpic);
2028     return bitid;
2029 }
2030
2031 static SRECT gfxline_getSWFbbox(gfxline_t*line)
2032 {
2033     gfxbbox_t bbox = gfxline_getbbox(line);
2034     SRECT r;
2035     r.xmin = (int)(bbox.xmin*20);
2036     r.ymin = (int)(bbox.ymin*20);
2037     r.xmax = (int)(bbox.xmax*20);
2038     r.ymax = (int)(bbox.ymax*20);
2039     return r;
2040 }
2041
2042 int line_is_empty(gfxline_t*line)
2043 {
2044     while(line) {
2045         if(line->type != gfx_moveTo)
2046             return 0;
2047         line = line->next;
2048     }
2049     return 1;
2050 }
2051
2052 static void swf_fillbitmap(gfxdevice_t*dev, gfxline_t*line, gfximage_t*img, gfxmatrix_t*matrix, gfxcxform_t*cxform)
2053 {
2054     swfoutput_internal*i = (swfoutput_internal*)dev->internal;
2055     
2056     if(line_is_empty(line))
2057         return;
2058
2059     endshape(dev);
2060     endtext(dev);
2061
2062     int targetx = (int)(sqrt(matrix->m00*matrix->m00 + matrix->m01*matrix->m01)*img->width);
2063     int targety = (int)(sqrt(matrix->m10*matrix->m10 + matrix->m11*matrix->m11)*img->height);
2064
2065     int newwidth=0,newheight=0;
2066     int bitid = add_image(i, img, targetx, targety, &newwidth, &newheight);
2067     if(bitid<0)
2068         return;
2069     double fx = (double)img->width / (double)newwidth;
2070     double fy = (double)img->height / (double)newheight;
2071
2072     MATRIX m;
2073     m.sx = (int)(65536*20*matrix->m00*fx); m.r1 = (int)(65536*20*matrix->m10*fy);
2074     m.r0 = (int)(65536*20*matrix->m01*fx); m.sy = (int)(65536*20*matrix->m11*fy);
2075     m.tx = (int)(matrix->tx*20);
2076     m.ty = (int)(matrix->ty*20);
2077   
2078     /* shape */
2079     int myshapeid = getNewID(dev);
2080     i->tag = swf_InsertTag(i->tag,ST_DEFINESHAPE);
2081     SHAPE*shape;
2082     swf_ShapeNew(&shape);
2083     int fsid = swf_ShapeAddBitmapFillStyle(shape,&m,bitid,1);
2084     swf_SetU16(i->tag, myshapeid);
2085     SRECT r = gfxline_getSWFbbox(line);
2086     r = swf_ClipRect(i->pagebbox, r);
2087     swf_SetRect(i->tag,&r);
2088     swf_SetShapeStyles(i->tag,shape);
2089     swf_ShapeCountBits(shape,NULL,NULL);
2090     swf_SetShapeBits(i->tag,shape);
2091     swf_ShapeSetAll(i->tag,shape,UNDEFINED_COORD,UNDEFINED_COORD,0,fsid,0);
2092     i->swflastx = i->swflasty = UNDEFINED_COORD;
2093     drawgfxline(dev, line);
2094     swf_ShapeSetEnd(i->tag);
2095     swf_ShapeFree(shape);
2096
2097     msg("<trace> Placing image, shape ID %d, bitmap ID %d", myshapeid, bitid);
2098     i->tag = swf_InsertTag(i->tag,ST_PLACEOBJECT2);
2099     CXFORM cxform2 = gfxcxform_to_cxform(cxform);
2100     swf_ObjectPlace(i->tag,myshapeid,getNewDepth(dev),&i->page_matrix,&cxform2,NULL);
2101 }
2102
2103 static RGBA col_black = {255,0,0,0};
2104
2105 static void drawoutline(gfxdevice_t*dev, gfxline_t*line)
2106 {
2107     swfoutput_internal*i = (swfoutput_internal*)dev->internal;
2108
2109     int myshapeid = getNewID(dev);
2110     i->tag = swf_InsertTag(i->tag,ST_DEFINESHAPE3);
2111
2112     SHAPE*shape;
2113     swf_ShapeNew(&shape);
2114     int lsid = swf_ShapeAddLineStyle(shape,1,&col_black);
2115
2116     swf_SetU16(i->tag,myshapeid);
2117     SRECT r = gfxline_getSWFbbox(line);
2118     r = swf_ClipRect(i->pagebbox, r);
2119     swf_SetRect(i->tag,&r);
2120     swf_SetShapeStyles(i->tag,shape);
2121     swf_ShapeCountBits(shape,NULL,NULL);
2122     swf_SetShapeBits(i->tag,shape);
2123     swf_ShapeSetAll(i->tag,shape,UNDEFINED_COORD,UNDEFINED_COORD,lsid,0,0);
2124     drawgfxline(dev, line);
2125     swf_ShapeSetEnd(i->tag);
2126     swf_ShapeFree(shape);
2127         
2128     i->tag = swf_InsertTag(i->tag,ST_PLACEOBJECT2);
2129     swf_ObjectPlace(i->tag, myshapeid, getNewDepth(dev), 0,0,0);
2130 }
2131
2132 static void swf_startclip(gfxdevice_t*dev, gfxline_t*line)
2133 {
2134     swfoutput_internal*i = (swfoutput_internal*)dev->internal;
2135
2136     endtext(dev);
2137     endshape(dev);
2138
2139     if(i->clippos >= 127)
2140     {
2141         msg("<warning> Too many clip levels.");
2142         i->clippos --;
2143     } 
2144
2145     if(i->config_showclipshapes)
2146         drawoutline(dev, line);
2147
2148     int myshapeid = getNewID(dev);
2149     i->tag = swf_InsertTag(i->tag,ST_DEFINESHAPE3);
2150     RGBA col;
2151     memset(&col, 0, sizeof(RGBA));
2152     col.a = 255;
2153     SHAPE*shape;
2154     swf_ShapeNew(&shape);
2155     int fsid = swf_ShapeAddSolidFillStyle(shape,&col);
2156     if(i->mark) {
2157         RGBA markcol = {0,i->mark[0],i->mark[1],i->mark[2]};
2158         swf_ShapeAddSolidFillStyle(shape,&markcol);
2159     }
2160     swf_SetU16(i->tag,myshapeid);
2161     SRECT r = gfxline_getSWFbbox(line);
2162     r = swf_ClipRect(i->pagebbox, r);
2163     swf_SetRect(i->tag,&r);
2164     swf_SetShapeStyles(i->tag,shape);
2165     swf_ShapeCountBits(shape,NULL,NULL);
2166     swf_SetShapeBits(i->tag,shape);
2167     swf_ShapeSetAll(i->tag,shape,UNDEFINED_COORD,UNDEFINED_COORD,0,fsid,0);
2168     i->swflastx = i->swflasty = UNDEFINED_COORD;
2169     i->shapeisempty = 1;
2170     drawgfxline(dev, line);
2171     if(i->shapeisempty) {
2172         /* an empty clip shape is equivalent to a shape with no area */
2173         int x = line?line->x:0;
2174         int y = line?line->y:0;
2175         moveto(dev, i->tag, x,y);
2176         lineto(dev, i->tag, x,y);
2177         lineto(dev, i->tag, x,y);
2178     }
2179     if(!i->shapeisempty && i->currentswfid==1 && r.xmin==0 && r.ymin==0 && r.xmax==(int)(i->max_x*20) && r.ymax==(int)(i->max_y*20)) {
2180         if(i->config_watermark) {
2181             gfxbbox_t r; r.xmin = r.ymin = 0;r.xmax = i->max_x;r.ymax = i->max_y;
2182             draw_watermark(dev, r, 1);
2183         }
2184     }
2185     swf_ShapeSetEnd(i->tag);
2186     swf_ShapeFree(shape);
2187
2188     /* TODO: remember the bbox, and check all shapes against it */
2189     
2190     msg("<trace> Placing clip ID %d", myshapeid);
2191     i->tag = swf_InsertTag(i->tag,ST_PLACEOBJECT2);
2192     i->cliptags[i->clippos] = i->tag;
2193     i->clipshapes[i->clippos] = myshapeid;
2194     i->clipdepths[i->clippos] = getNewDepth(dev);
2195     i->clippos++;
2196 }
2197
2198 static void swf_endclip(gfxdevice_t*dev)
2199 {
2200     swfoutput_internal*i = (swfoutput_internal*)dev->internal;
2201     if(i->textid>=0)
2202         endtext(dev);
2203     if(i->shapeid>=0)
2204         endshape(dev);
2205
2206     if(!i->clippos) {
2207         msg("<error> Invalid end of clipping region");
2208         return;
2209     }
2210     i->clippos--;
2211     /*swf_ObjectPlaceClip(i->cliptags[i->clippos],i->clipshapes[i->clippos],i->clipdepths[i->clippos],&i->page_matrix,NULL,NULL,
2212             / * clip to depth: * / i->depth <= i->clipdepths[i->clippos]? i->depth : i->depth - 1);
2213     i->depth ++;*/
2214     swf_ObjectPlaceClip(i->cliptags[i->clippos],i->clipshapes[i->clippos],i->clipdepths[i->clippos],&i->page_matrix,NULL,NULL,i->depth);
2215 }
2216 static int gfxline_type(gfxline_t*line)
2217 {
2218     int tmplines=0;
2219     int tmpsplines=0;
2220     int lines=0;
2221     int splines=0;
2222     int haszerosegments=0;
2223     int length=0;
2224     while(line) {
2225         if(line->type == gfx_moveTo) {
2226             tmplines=0;
2227             tmpsplines=0;
2228         } else if(line->type == gfx_lineTo) {
2229             tmplines++;
2230             if(tmplines>lines)
2231                 lines=tmplines;
2232         } else if(line->type == gfx_splineTo) {
2233             tmpsplines++;
2234             if(tmpsplines>lines)
2235                 splines=tmpsplines;
2236         }
2237         length++;
2238         line = line->next;
2239     }
2240     if(length>400)
2241         return 5;
2242     if(lines==0 && splines==0) return 0;
2243     else if(lines==1 && splines==0) return 1;
2244     else if(lines==0 && splines==1) return 2;
2245     else if(splines==0) return 3;
2246     else return 4;
2247 }
2248
2249 static int gfxline_has_dots(gfxline_t*line)
2250 {
2251     int tmplines=0;
2252     double x=0,y=0;
2253     double dist = 0;
2254     int isline = 0;
2255     int short_gap = 0;
2256     while(line) {
2257         if(line->type == gfx_moveTo) {
2258             /* test the length of the preceding line, and assume it is a dot if
2259                it's length is less than 1.0. But *only* if there's a noticable 
2260                gap between the previous line and the next moveTo. (I've come
2261                across a PDF where thousands of "dots" were stringed together,
2262                forming a line) */
2263             int last_short_gap = short_gap;
2264             if((fabs(line->x - x) + fabs(line->y - y)) < 1.0) {
2265                 short_gap = 1;
2266             } else {
2267                 short_gap = 0;
2268             }
2269             if(isline && dist < 1 && !short_gap && !last_short_gap) {
2270                 return 1;
2271             }
2272             dist = 0;
2273             isline = 0;
2274         } else if(line->type == gfx_lineTo) {
2275             dist += fabs(line->x - x) + fabs(line->y - y);
2276             isline = 1;
2277         } else if(line->type == gfx_splineTo) {
2278             dist += fabs(line->sx - x) + fabs(line->sy - y) + 
2279                     fabs(line->x - line->sx) + fabs(line->y - line->sy);
2280             isline = 1;
2281         }
2282         x = line->x;
2283         y = line->y;
2284         line = line->next;
2285     }
2286     if(isline && dist < 1 && !short_gap) {
2287         return 1;
2288     }
2289     return 0;
2290 }
2291
2292 static int gfxline_fix_short_edges(gfxline_t*line)
2293 {
2294     double x,y;
2295     while(line) {
2296         if(line->type == gfx_lineTo) {
2297             if(fabs(line->x - x) + fabs(line->y - y) < 0.01) {
2298                 line->x += 0.01;
2299             }
2300         } else if(line->type == gfx_splineTo) {
2301             if(fabs(line->sx - x) + fabs(line->sy - y) + 
2302                fabs(line->x - line->sx) + fabs(line->y - line->sy) < 0.01) {
2303                 line->x += 0.01;
2304             }
2305         }
2306         x = line->x;
2307         y = line->y;
2308         line = line->next;
2309     }
2310     return 0;
2311 }
2312
2313 static char is_inside_page(gfxdevice_t*dev, gfxcoord_t x, gfxcoord_t y)
2314 {
2315     swfoutput_internal*i = (swfoutput_internal*)dev->internal;
2316     if(x<i->min_x || x>i->max_x) return 0;
2317     if(y<i->min_y || y>i->max_y) return 0;
2318     return 1;
2319 }
2320
2321 gfxline_t* gfxline_move(gfxline_t*line, double x, double y)
2322 {
2323     gfxline_t*l = line = gfxline_clone(line);
2324
2325     while(l) {
2326         l->x += x;
2327         l->y += y;
2328         l->sx += x;
2329         l->sy += y;
2330         l = l->next;
2331     }
2332     return line;
2333 }
2334
2335 //#define NORMALIZE_POLYGON_POSITIONS
2336
2337 static void swf_stroke(gfxdevice_t*dev, gfxline_t*line, gfxcoord_t width, gfxcolor_t*color, gfx_capType cap_style, gfx_joinType joint_style, gfxcoord_t miterLimit)
2338 {
2339     swfoutput_internal*i = (swfoutput_internal*)dev->internal;
2340     if(line_is_empty(line))
2341         return;
2342     int type = gfxline_type(line);
2343     int has_dots = gfxline_has_dots(line);
2344     gfxbbox_t r = gfxline_getbbox(line);
2345     int is_outside_page = !is_inside_page(dev, r.xmin, r.ymin) || !is_inside_page(dev, r.xmax, r.ymax);
2346
2347     /* TODO: * split line into segments, and perform this check for all segments */
2348
2349     if(i->config_disable_polygon_conversion || type>=5 ||
2350        (!has_dots &&
2351         (width <= i->config_caplinewidth 
2352         || (cap_style == gfx_capRound && joint_style == gfx_joinRound)
2353         || (cap_style == gfx_capRound && type<=2)))) {} else 
2354     {
2355         /* convert line to polygon */
2356         msg("<trace> draw as polygon, type=%d dots=%d", type, has_dots);
2357         if(has_dots)
2358             gfxline_fix_short_edges(line);
2359         /* we need to convert the line into a polygon */
2360         gfxpoly_t* poly = gfxpoly_strokeToPoly(line, width, cap_style, joint_style, miterLimit);
2361         gfxline_t*gfxline = gfxpoly_to_gfxline(poly);
2362         dev->fill(dev, gfxline, color);
2363         gfxline_free(gfxline);
2364         gfxpoly_free(poly);
2365         return;
2366     }
2367
2368     msg("<trace> draw as stroke, type=%d dots=%d", type, has_dots);
2369     endtext(dev);
2370
2371     if(i->config_normalize_polygon_positions) {
2372         endshape(dev);
2373         double startx = 0, starty = 0;
2374         if(line && line->type == gfx_moveTo) {
2375             startx = line->x;
2376             starty = line->y;
2377         }
2378         line = gfxline_move(line, -startx, -starty);
2379         i->shapeposx = (int)(startx*20);
2380         i->shapeposy = (int)(starty*20);
2381     }
2382
2383     swfoutput_setstrokecolor(dev, color->r, color->g, color->b, color->a);
2384     swfoutput_setlinewidth(dev, width);
2385     startshape(dev);
2386     stopFill(dev);
2387     drawgfxline(dev, line);
2388
2389     if(i->config_normalize_polygon_positions) {
2390         free(line); //account for _move
2391     }
2392
2393 }
2394
2395 static void swf_fill(gfxdevice_t*dev, gfxline_t*line, gfxcolor_t*color)
2396 {
2397     swfoutput_internal*i = (swfoutput_internal*)dev->internal;
2398     if(line_is_empty(line))
2399         return;
2400     if(!color->a)
2401         return;
2402     gfxbbox_t r = gfxline_getbbox(line);
2403     int is_outside_page = !is_inside_page(dev, r.xmin, r.ymin) || !is_inside_page(dev, r.xmax, r.ymax);
2404
2405     //if(i->chardatapos && i->chardata[i->chardatapos-1].color.a) {
2406     endtext(dev);
2407
2408     if(!i->config_ignoredraworder)
2409         endshape(dev);
2410
2411     if(i->config_normalize_polygon_positions) {
2412         endshape(dev);
2413         double startx = 0, starty = 0;
2414         if(line && line->type == gfx_moveTo) {
2415             startx = line->x;
2416             starty = line->y;
2417         }
2418         line = gfxline_move(line, -startx, -starty);
2419         i->shapeposx = (int)(startx*20);
2420         i->shapeposy = (int)(starty*20);
2421     }
2422
2423     swfoutput_setfillcolor(dev, color->r, color->g, color->b, color->a);
2424     startshape(dev);
2425     startFill(dev);
2426     i->fill=1;
2427     drawgfxline(dev, line);
2428     
2429     if(i->currentswfid==2 && r.xmin==0 && r.ymin==0 && r.xmax==i->max_x && r.ymax==i->max_y) {
2430         if(i->config_watermark) {
2431             draw_watermark(dev, r, 1);
2432         }
2433     }
2434
2435     msg("<trace> end of swf_fill (shapeid=%d)", i->shapeid);
2436
2437     if(i->config_normalize_polygon_positions) {
2438         free(line); //account for _move
2439     }
2440 }
2441
2442 static GRADIENT* gfxgradient_to_GRADIENT(gfxgradient_t*gradient)
2443 {
2444     int num = 0;
2445     gfxgradient_t*g = gradient;
2446     while(g) {
2447         num++;
2448         g = g->next;
2449     }
2450     GRADIENT* swfgradient = malloc(sizeof(GRADIENT));
2451     swfgradient->num = num;
2452     swfgradient->rgba = malloc(sizeof(swfgradient->rgba[0])*num);
2453     swfgradient->ratios = malloc(sizeof(swfgradient->ratios[0])*num);
2454
2455     g = gradient;
2456     num = 0;
2457     while(g) {
2458         swfgradient->ratios[num] = g->pos*255;
2459         swfgradient->rgba[num] = *(RGBA*)&g->color;
2460         num++;
2461         g = g->next;
2462     }
2463     return swfgradient;
2464 }
2465
2466 static void swf_fillgradient(gfxdevice_t*dev, gfxline_t*line, gfxgradient_t*gradient, gfxgradienttype_t type, gfxmatrix_t*matrix)
2467 {
2468     if(line_is_empty(line))
2469         return;
2470     swfoutput_internal*i = (swfoutput_internal*)dev->internal;
2471     
2472     if(line_is_empty(line))
2473         return;
2474
2475     GRADIENT* swfgradient = gfxgradient_to_GRADIENT(gradient);
2476     if(!swfgradient)
2477         return;
2478   
2479     endshape(dev);
2480     endtext(dev);
2481
2482     double f = type==gfxgradient_radial?4:4;
2483     MATRIX m;
2484     m.sx = (int)(matrix->m00*20*f); m.r1 = (int)(matrix->m10*20*f);
2485     m.r0 = (int)(matrix->m01*20*f); m.sy = (int)(matrix->m11*20*f);
2486     m.tx = (int)(matrix->tx*20);
2487     m.ty = (int)(matrix->ty*20);
2488
2489     /* shape */
2490     int myshapeid = getNewID(dev);
2491     i->tag = swf_InsertTag(i->tag, ST_DEFINESHAPE2);
2492     SHAPE*shape;
2493     swf_ShapeNew(&shape);
2494     int fsid = swf_ShapeAddGradientFillStyle(shape,&m,swfgradient,type==gfxgradient_radial);
2495     swf_SetU16(i->tag, myshapeid);
2496     SRECT r = gfxline_getSWFbbox(line);
2497     r = swf_ClipRect(i->pagebbox, r);
2498     swf_SetRect(i->tag,&r);
2499     swf_SetShapeStyles(i->tag,shape);
2500     swf_ShapeCountBits(shape,NULL,NULL);
2501     swf_SetShapeBits(i->tag,shape);
2502     swf_ShapeSetAll(i->tag,shape,UNDEFINED_COORD,UNDEFINED_COORD,0,fsid,0);
2503     i->swflastx = i->swflasty = UNDEFINED_COORD;
2504     drawgfxline(dev, line);
2505     swf_ShapeSetEnd(i->tag);
2506     swf_ShapeFree(shape);
2507
2508     int depth = getNewDepth(dev);
2509     msg("<trace> Placing gradient, shape ID %d, depth %d", myshapeid, depth);
2510     i->tag = swf_InsertTag(i->tag,ST_PLACEOBJECT2);
2511     swf_ObjectPlace(i->tag,myshapeid,depth,&i->page_matrix,NULL,NULL);
2512
2513     swf_FreeGradient(swfgradient);free(swfgradient);
2514 }
2515
2516 static SWFFONT* gfxfont_to_swffont(gfxfont_t*font, const char* id)
2517 {
2518     SWFFONT*swffont = (SWFFONT*)rfx_calloc(sizeof(SWFFONT));
2519     int t;
2520     SRECT bounds = {0,0,0,0};
2521     swffont->id = -1;
2522     swffont->version = 2;
2523     swffont->name = (U8*)strdup(id);
2524     swffont->layout = (SWFLAYOUT*)rfx_calloc(sizeof(SWFLAYOUT));
2525     swffont->layout->ascent = 0; /* ? */
2526     swffont->layout->descent = 0;
2527     swffont->layout->leading = 0;
2528     swffont->layout->bounds = (SRECT*)rfx_calloc(sizeof(SRECT)*font->num_glyphs);
2529     swffont->encoding = FONT_ENCODING_UNICODE;
2530     swffont->numchars = font->num_glyphs;
2531     swffont->maxascii = font->max_unicode;
2532     swffont->ascii2glyph = (int*)rfx_calloc(sizeof(int)*swffont->maxascii);
2533     swffont->glyph2ascii = (U16*)rfx_calloc(sizeof(U16)*swffont->numchars);
2534     swffont->glyph = (SWFGLYPH*)rfx_calloc(sizeof(SWFGLYPH)*swffont->numchars);
2535     swffont->glyphnames = (char**)rfx_calloc(sizeof(char*)*swffont->numchars);
2536     for(t=0;t<font->max_unicode;t++) {
2537         swffont->ascii2glyph[t] = font->unicode2glyph[t];
2538     }
2539     for(t=0;t<font->num_glyphs;t++) {
2540         drawer_t draw;
2541         gfxline_t*line;
2542         int advance = 0;
2543         swffont->glyph2ascii[t] = font->glyphs[t].unicode;
2544         if(swffont->glyph2ascii[t] == 0xffff || swffont->glyph2ascii[t] == 0x0000) {
2545             /* flash 8 flashtype requires unique unicode IDs for each character.
2546                We use the Unicode private user area to assign characters, hoping that
2547                the font doesn't contain more than 2048 glyphs */
2548             swffont->glyph2ascii[t] = 0xe000 + (t&0x1fff);
2549         }
2550
2551         if(font->glyphs[t].name) {
2552             swffont->glyphnames[t] = strdup(font->glyphs[t].name);
2553         } else {
2554             swffont->glyphnames[t] = 0;
2555         }
2556         advance = (int)(font->glyphs[t].advance);
2557
2558         swf_Shape01DrawerInit(&draw, 0);
2559         line = font->glyphs[t].line;
2560         while(line) {
2561             FPOINT c,to;
2562             c.x = line->sx * GLYPH_SCALE; c.y = line->sy * GLYPH_SCALE;
2563             to.x = line->x * GLYPH_SCALE; to.y = line->y * GLYPH_SCALE;
2564             if(line->type == gfx_moveTo) {
2565                 draw.moveTo(&draw, &to);
2566             } else if(line->type == gfx_lineTo) {
2567                 draw.lineTo(&draw, &to);
2568             } else if(line->type == gfx_splineTo) {
2569                 draw.splineTo(&draw, &c, &to);
2570             }
2571             line = line->next;
2572         }
2573         draw.finish(&draw);
2574         swffont->glyph[t].shape = swf_ShapeDrawerToShape(&draw);
2575         swffont->layout->bounds[t] = swf_ShapeDrawerGetBBox(&draw);
2576
2577         int xmax = swffont->layout->bounds[t].xmax / 20;
2578         if(xmax>0 && xmax*2 < advance) {
2579             printf("fix bad advance value: bbox=%d, advance=%d (%f)\n", xmax, advance, font->glyphs[t].advance);
2580             advance = xmax;
2581         }
2582             
2583         if(advance<32768/20) {
2584             swffont->glyph[t].advance = advance*20;
2585         } else {
2586             swffont->glyph[t].advance = 32767;
2587         }
2588
2589         draw.dealloc(&draw);
2590
2591         swf_ExpandRect2(&bounds, &swffont->layout->bounds[t]);
2592     }
2593     if(bounds.ymin < 0 && bounds.ymax > 0) {
2594         swffont->layout->ascent = -bounds.ymin;
2595         swffont->layout->descent = bounds.ymax;
2596         swffont->layout->leading = bounds.ymax - bounds.ymin;
2597     } else {
2598         swffont->layout->ascent = (bounds.ymax - bounds.ymin)/2;
2599         swffont->layout->descent = (bounds.ymax - bounds.ymin)/2;
2600         swffont->layout->leading = bounds.ymax - bounds.ymin;
2601     }
2602     swffont->layout->descent= (bounds.ymax - bounds.ymin);
2603     swffont->layout->ascent = 0;
2604     swffont->layout->leading = bounds.ymax - bounds.ymin;
2605
2606     return swffont;
2607 }
2608
2609 static void swf_addfont(gfxdevice_t*dev, gfxfont_t*font)
2610 {
2611     swfoutput_internal*i = (swfoutput_internal*)dev->internal;
2612
2613     if(i->swffont && i->swffont->name && !strcmp((char*)i->swffont->name,font->id))
2614         return; // the requested font is the current font
2615     
2616     fontlist_t*last=0,*l = i->fontlist;
2617     while(l) {
2618         last = l;
2619         if(!strcmp((char*)l->swffont->name, font->id)) {
2620             return; // we already know this font
2621         }
2622         l = l->next;
2623     }
2624     l = (fontlist_t*)rfx_calloc(sizeof(fontlist_t));
2625     l->swffont = gfxfont_to_swffont(font, font->id);
2626     l->next = 0;
2627     if(last) {
2628         last->next = l;
2629     } else {
2630         i->fontlist = l;
2631     }
2632     swf_FontSetID(l->swffont, getNewID(i->dev));
2633
2634     if(getScreenLogLevel() >= LOGLEVEL_DEBUG)  {
2635         int iii;
2636         // print font information
2637         msg("<debug> Font %s",font->id);
2638         msg("<debug> |   ID: %d", l->swffont->id);
2639         msg("<debug> |   Version: %d", l->swffont->version);
2640         msg("<debug> |   Name: %s", l->swffont->name);
2641         msg("<debug> |   Numchars: %d", l->swffont->numchars);
2642         msg("<debug> |   Maxascii: %d", l->swffont->maxascii);
2643         msg("<debug> |   Style: %d", l->swffont->style);
2644         msg("<debug> |   Encoding: %d", l->swffont->encoding);
2645         for(iii=0; iii<l->swffont->numchars;iii++) {
2646             msg("<debug> |   Glyph %d) name=%s, unicode=%d size=%d bbox=(%.2f,%.2f,%.2f,%.2f)\n", iii, l->swffont->glyphnames?l->swffont->glyphnames[iii]:"<nonames>", l->swffont->glyph2ascii[iii], l->swffont->glyph[iii].shape->bitlen, 
2647                     l->swffont->layout->bounds[iii].xmin/20.0,
2648                     l->swffont->layout->bounds[iii].ymin/20.0,
2649                     l->swffont->layout->bounds[iii].xmax/20.0,
2650                     l->swffont->layout->bounds[iii].ymax/20.0
2651                     );
2652             int t;
2653             for(t=0;t<l->swffont->maxascii;t++) {
2654                 if(l->swffont->ascii2glyph[t] == iii)
2655                     msg("<debug> | - maps to %d",t);
2656             }
2657         }
2658     }
2659 }
2660
2661 static void swf_switchfont(gfxdevice_t*dev, const char*fontid)
2662 {
2663     swfoutput_internal*i = (swfoutput_internal*)dev->internal;
2664
2665     if(i->swffont && i->swffont->name && !strcmp((char*)i->swffont->name,fontid))
2666         return; // the requested font is the current font
2667     
2668     fontlist_t*l = i->fontlist;
2669     while(l) {
2670         if(!strcmp((char*)l->swffont->name, fontid)) {
2671             i->swffont = l->swffont;
2672             return; //done!
2673         }
2674         l = l->next;
2675     }
2676     msg("<error> Unknown font id: %s", fontid);
2677     return;
2678 }
2679
2680 static void swf_drawchar(gfxdevice_t*dev, gfxfont_t*font, int glyph, gfxcolor_t*color, gfxmatrix_t*matrix)
2681 {
2682     swfoutput_internal*i = (swfoutput_internal*)dev->internal;
2683     if(!font) {
2684         msg("<error> swf_drawchar called (glyph %d) without font", glyph);
2685         return;
2686     }
2687     if(!i->swffont || !i->swffont->name || strcmp((char*)i->swffont->name,font->id)) // not equal to current font
2688     {
2689         /* TODO: remove the need for this (enhance getcharacterbbox so that it can cope
2690                  with multiple fonts */
2691         endtext(dev);
2692         swf_switchfont(dev, font->id); // set the current font
2693     }
2694     if(!i->swffont) {
2695         msg("<warning> swf_drawchar: Font is NULL");
2696         return;
2697     }
2698     if(glyph<0 || glyph>=i->swffont->numchars) {
2699         msg("<warning> No character %d in font %s (%d chars)", glyph, FIXNULL((char*)i->swffont->name), i->swffont->numchars);
2700         return;
2701     }
2702     
2703     setfontscale(dev, matrix->m00, matrix->m01, matrix->m10, matrix->m11, matrix->tx, matrix->ty, 0);
2704     
2705     double det = i->fontmatrix.sx/65536.0 * i->fontmatrix.sy/65536.0 - 
2706                  i->fontmatrix.r0/65536.0 * i->fontmatrix.r1/65536.0;
2707     if(fabs(det) < 0.0005) { 
2708         /* x direction equals y direction- the text is invisible */
2709         msg("<verbose> Not drawing invisible character character %d (det=%f, m=[%f %f;%f %f]\n", glyph, 
2710                 det,
2711                 i->fontmatrix.sx/65536.0, i->fontmatrix.r1/65536.0, 
2712                 i->fontmatrix.r0/65536.0, i->fontmatrix.sy/65536.0);
2713         return;
2714     }
2715
2716     /*if(i->swffont->glyph[glyph].shape->bitlen <= 16) {
2717         msg("<warning> Glyph %d in current charset (%s, %d characters) is empty", 
2718                 glyph, FIXNULL((char*)i->swffont->name), i->swffont->numchars);
2719         return 1;
2720     }*/
2721
2722     /* calculate character position with respect to the current font matrix */
2723     double s = 20 * GLYPH_SCALE / det;
2724     double px = matrix->tx - i->fontmatrix.tx/20.0;
2725     double py = matrix->ty - i->fontmatrix.ty/20.0;
2726     int x = (SCOORD)((  px * i->fontmatrix.sy/65536.0 - py * i->fontmatrix.r1/65536.0)*s);
2727     int y = (SCOORD)((- px * i->fontmatrix.r0/65536.0 + py * i->fontmatrix.sx/65536.0)*s);
2728     if(x>32767 || x<-32768 || y>32767 || y<-32768) {
2729         msg("<verbose> Moving character origin to %f %f\n", matrix->tx, matrix->ty);
2730         endtext(dev);
2731         setfontscale(dev, matrix->m00, matrix->m01, matrix->m10, matrix->m11, matrix->tx, matrix->ty, 1);
2732     }
2733     
2734     if(i->shapeid>=0)
2735         endshape(dev);
2736     if(i->textid<0)
2737         starttext(dev);
2738
2739     msg("<trace> Drawing char %d in font %d at %d,%d in color %02x%02x%02x%02x", 
2740             glyph, i->swffont->id, x, y, color->r, color->g, color->b, color->a);
2741
2742     putcharacter(dev, i->swffont->id, glyph, x, y, i->current_font_size, *(RGBA*)color);
2743     swf_FontUseGlyph(i->swffont, glyph);
2744     return;
2745 }