3 Part of the swftools package.
5 Copyright (c) 2001,2002,2003,2004,2005 Matthias Kramm <kramm@quiss.org>
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.
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.
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 */
24 #include "../../config.h"
40 #include "../rfxswf.h"
41 #include "../gfxdevice.h"
42 #include "../gfxtools.h"
44 #include "../gfxpoly.h"
47 #define CHARDATAMAX 8192
51 typedef struct _chardata {
53 int fontid; /* TODO: use a SWFFONT instead */
60 typedef struct _fontlist
63 struct _fontlist*next;
66 typedef long int twip;
68 typedef struct _swfmatrix {
69 double m11,m12,m21,m22,m31,m32;
72 typedef struct _swfoutput_internal
74 gfxdevice_t*dev; // the gfxdevice object where this internal struct resides
76 double config_dumpfonts;
77 double config_ppmsubpixels;
78 double config_jpegsubpixels;
80 int config_simpleviewer;
81 int config_opennewwindow;
82 int config_ignoredraworder;
83 int config_drawonlyshapes;
84 int config_frameresets;
85 int config_linknameurl;
86 int config_jpegquality;
87 int config_storeallcharacters;
88 int config_enablezlib;
89 int config_insertstoptag;
91 int config_flashversion;
92 int config_reordertags;
93 int config_showclipshapes;
94 int config_splinemaxerror;
95 int config_fontsplinemaxerror;
96 int config_filloverlap;
99 int config_disable_polygon_conversion;
100 int config_normalize_polygon_positions;
101 RGBA config_linkcolor;
102 float config_minlinewidth;
103 double config_caplinewidth;
104 char* config_linktarget;
105 char*config_internallinkfunction;
106 char*config_externallinkfunction;
108 double config_framerate;
112 fontlist_t* fontlist;
151 int pic_height[1024];
158 char fillstylechanged;
160 int jpeg; //next image type
167 chardata_t chardata[CHARDATAMAX];
174 int current_font_size;
176 double lastfontm11,lastfontm12,lastfontm21,lastfontm22;
187 } swfoutput_internal;
189 static void swf_fillbitmap(gfxdevice_t*driver, gfxline_t*line, gfximage_t*img, gfxmatrix_t*move, gfxcxform_t*cxform);
190 static int swf_setparameter(gfxdevice_t*driver, const char*key, const char*value);
191 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);
192 static void swf_startclip(gfxdevice_t*dev, gfxline_t*line);
193 static void swf_endclip(gfxdevice_t*dev);
194 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);
195 static void swf_fill(gfxdevice_t*dev, gfxline_t*line, gfxcolor_t*color);
196 static void swf_fillbitmap(gfxdevice_t*dev, gfxline_t*line, gfximage_t*img, gfxmatrix_t*matrix, gfxcxform_t*cxform);
197 static void swf_fillgradient(gfxdevice_t*dev, gfxline_t*line, gfxgradient_t*gradient, gfxgradienttype_t type, gfxmatrix_t*matrix);
198 static void swf_drawchar(gfxdevice_t*dev, gfxfont_t*font, int glyph, gfxcolor_t*color, gfxmatrix_t*matrix);
199 static void swf_addfont(gfxdevice_t*dev, gfxfont_t*font);
200 static void swf_drawlink(gfxdevice_t*dev, gfxline_t*line, const char*action);
201 static void swf_startframe(gfxdevice_t*dev, int width, int height);
202 static void swf_endframe(gfxdevice_t*dev);
203 static gfxresult_t* swf_finish(gfxdevice_t*driver);
205 static swfoutput_internal* init_internal_struct()
207 swfoutput_internal*i = (swfoutput_internal*)malloc(sizeof(swfoutput_internal));
208 memset(i, 0, sizeof(swfoutput_internal));
232 i->fillstylechanged = 0;
239 i->config_dumpfonts=0;
240 i->config_ppmsubpixels=0;
241 i->config_jpegsubpixels=0;
242 i->config_opennewwindow=1;
243 i->config_ignoredraworder=0;
244 i->config_drawonlyshapes=0;
245 i->config_jpegquality=85;
246 i->config_storeallcharacters=0;
247 i->config_enablezlib=0;
248 i->config_insertstoptag=0;
249 i->config_flashversion=6;
250 i->config_framerate=0.25;
251 i->config_splinemaxerror=1;
252 i->config_fontsplinemaxerror=1;
253 i->config_filloverlap=0;
255 i->config_bboxvars=0;
256 i->config_showclipshapes=0;
257 i->config_minlinewidth=0.05;
258 i->config_caplinewidth=1;
259 i->config_linktarget=0;
260 i->config_internallinkfunction=0;
261 i->config_externallinkfunction=0;
262 i->config_reordertags=1;
263 i->config_linknameurl=0;
265 i->config_linkcolor.r = i->config_linkcolor.g = i->config_linkcolor.b = 255;
266 i->config_linkcolor.a = 0x40;
271 static int id_error = 0;
273 static U16 getNewID(gfxdevice_t* dev)
275 swfoutput_internal*i = (swfoutput_internal*)dev->internal;
276 if(i->currentswfid == 65535) {
278 msg("<error> ID Table overflow");
279 msg("<error> This file is too complex to render- SWF only supports 65536 shapes at once");
285 return ++i->currentswfid;
287 static U16 getNewDepth(gfxdevice_t* dev)
289 swfoutput_internal*i = (swfoutput_internal*)dev->internal;
290 if(i->depth == 65520) {
292 msg("<error> Depth Table overflow");
293 msg("<error> This file is too complex to render- SWF only supports 65536 shapes at once");
302 static void startshape(gfxdevice_t* dev);
303 static void starttext(gfxdevice_t* dev);
304 static void endshape(gfxdevice_t* dev);
305 static void endtext(gfxdevice_t* dev);
307 typedef struct _plotxy
312 // write a move-to command into the swf
313 static int movetoxy(gfxdevice_t*dev, TAG*tag, plotxy_t p0)
315 swfoutput_internal*i = (swfoutput_internal*)dev->internal;
316 int rx = (int)(p0.x*20);
317 int ry = (int)(p0.y*20);
318 if(rx!=i->swflastx || ry!=i->swflasty || i->fillstylechanged) {
319 swf_ShapeSetMove (tag, i->shape, rx,ry);
320 i->fillstylechanged = 0;
327 static int moveto(gfxdevice_t*dev, TAG*tag, double x, double y)
329 swfoutput_internal*i = (swfoutput_internal*)dev->internal;
333 return movetoxy(dev, tag, p);
335 static void addPointToBBox(gfxdevice_t*dev, int px, int py)
337 swfoutput_internal*i = (swfoutput_internal*)dev->internal;
343 swf_ExpandRect(&i->bboxrect, p);
345 swf_ExpandRect3(&i->bboxrect, p, i->linewidth*3/2);
349 /*static void plot(gfxdevice_t*dev, int x, int y, TAG*tag)
351 swfoutput_internal*i = (swfoutput_internal*)dev->internal;
352 int width = i->linewidth/4;
356 //swf_ShapeSetLine(tag, i->shape,-width,-width);
357 //swf_ShapeSetLine(tag, i->shape,width*2,0);
358 //swf_ShapeSetLine(tag, i->shape,0,width*2);
359 //swf_ShapeSetLine(tag, i->shape,-width*2,0);
360 //swf_ShapeSetLine(tag, i->shape,0,-width*2);
361 //swf_ShapeSetLine(tag, i->shape,width,width);
364 swf_ShapeSetLine(tag, i->shape,-width,0);
365 swf_ShapeSetLine(tag, i->shape,width,-width);
366 swf_ShapeSetLine(tag, i->shape,width,width);
367 swf_ShapeSetLine(tag, i->shape,-width,width);
368 swf_ShapeSetLine(tag, i->shape,-width,-width);
369 swf_ShapeSetLine(tag, i->shape,width,0);
371 addPointToBBox(dev, x-width ,y-width);
372 addPointToBBox(dev, x+width ,y+width);
375 // write a line-to command into the swf
376 static void linetoxy(gfxdevice_t*dev, TAG*tag, plotxy_t p0)
378 swfoutput_internal*i = (swfoutput_internal*)dev->internal;
379 int px = (int)(p0.x*20);
380 int py = (int)(p0.y*20);
381 int rx = (px-i->swflastx);
382 int ry = (py-i->swflasty);
384 swf_ShapeSetLine (tag, i->shape, rx,ry);
385 addPointToBBox(dev, i->swflastx,i->swflasty);
386 addPointToBBox(dev, px,py);
387 }/* else if(!i->fill) {
388 // treat lines of length 0 as plots, making them
389 // at least 1 twip wide so Flash will display them
390 plot(dev, i->swflastx, i->swflasty, tag);
397 static void lineto(gfxdevice_t*dev, TAG*tag, double x, double y)
402 linetoxy(dev,tag, p);
405 // write a spline-to command into the swf
406 static void splineto(gfxdevice_t*dev, TAG*tag, plotxy_t control,plotxy_t end)
408 swfoutput_internal*i = (swfoutput_internal*)dev->internal;
409 int lastlastx = i->swflastx;
410 int lastlasty = i->swflasty;
412 int cx = ((int)(control.x*20)-i->swflastx);
413 int cy = ((int)(control.y*20)-i->swflasty);
416 int ex = ((int)(end.x*20)-i->swflastx);
417 int ey = ((int)(end.y*20)-i->swflasty);
421 if((cx || cy) && (ex || ey)) {
422 swf_ShapeSetCurve(tag, i->shape, cx,cy,ex,ey);
423 addPointToBBox(dev, lastlastx ,lastlasty );
424 addPointToBBox(dev, lastlastx+cx,lastlasty+cy);
425 addPointToBBox(dev, lastlastx+cx+ex,lastlasty+cy+ey);
426 } else if(cx || cy || ex || ey) {
427 swf_ShapeSetLine(tag, i->shape, cx+ex,cy+ey);
428 addPointToBBox(dev, lastlastx ,lastlasty );
429 addPointToBBox(dev, lastlastx+cx,lastlasty+cy);
430 addPointToBBox(dev, lastlastx+cx+ex,lastlasty+cy+ey);
436 /* write a line, given two points and the transformation
438 /*static void line(gfxdevice_t*dev, TAG*tag, plotxy_t p0, plotxy_t p1)
440 moveto(dev, tag, p0);
441 lineto(dev, tag, p1);
444 void resetdrawer(gfxdevice_t*dev)
446 swfoutput_internal*i = (swfoutput_internal*)dev->internal;
451 static void stopFill(gfxdevice_t*dev)
453 swfoutput_internal*i = (swfoutput_internal*)dev->internal;
454 if(i->lastwasfill!=0)
456 swf_ShapeSetStyle(i->tag,i->shape,i->linestyleid,0x8000,0);
457 i->fillstylechanged = 1;
461 static void startFill(gfxdevice_t*dev)
463 swfoutput_internal*i = (swfoutput_internal*)dev->internal;
464 if(i->lastwasfill!=1)
466 swf_ShapeSetStyle(i->tag,i->shape,0x8000,i->fillstyleid,0);
467 i->fillstylechanged = 1;
472 static inline int colorcompare(gfxdevice_t*dev, RGBA*a,RGBA*b)
484 static SRECT getcharacterbbox(gfxdevice_t*dev, SWFFONT*font, MATRIX* m)
486 swfoutput_internal*i = (swfoutput_internal*)dev->internal;
489 memset(&r, 0, sizeof(r));
492 if(debug) printf("\n");
493 for(t=0;t<i->chardatapos;t++)
495 if(i->chardata[t].fontid != font->id) {
496 msg("<error> Internal error: fontid %d != fontid %d", i->chardata[t].fontid, font->id);
499 SRECT b = font->layout->bounds[i->chardata[t].charid];
500 b.xmin *= i->chardata[t].size;
501 b.ymin *= i->chardata[t].size;
502 b.xmax *= i->chardata[t].size;
503 b.ymax *= i->chardata[t].size;
505 /* divide by 1024, rounding xmax/ymax up */
506 b.xmax += 1023; b.ymax += 1023; b.xmin /= 1024; b.ymin /= 1024; b.xmax /= 1024; b.ymax /= 1024;
508 b.xmin += i->chardata[t].x;
509 b.ymin += i->chardata[t].y;
510 b.xmax += i->chardata[t].x;
511 b.ymax += i->chardata[t].y;
513 /* until we solve the INTERNAL_SCALING problem (see below)
514 make sure the bounding box is big enough */
520 b = swf_TurnRect(b, m);
522 if(debug) printf("(%f,%f,%f,%f) -> (%f,%f,%f,%f) [font %d/%d, char %d]\n",
523 font->layout->bounds[i->chardata[t].charid].xmin/20.0,
524 font->layout->bounds[i->chardata[t].charid].ymin/20.0,
525 font->layout->bounds[i->chardata[t].charid].xmax/20.0,
526 font->layout->bounds[i->chardata[t].charid].ymax/20.0,
531 i->chardata[t].fontid,
533 i->chardata[t].charid
535 swf_ExpandRect2(&r, &b);
537 if(debug) printf("-----> (%f,%f,%f,%f)\n",
545 static void putcharacters(gfxdevice_t*dev, TAG*tag)
547 swfoutput_internal*i = (swfoutput_internal*)dev->internal;
551 color.r = i->chardata[0].color.r^255;
560 int charadvance[128];
563 int glyphbits=1; //TODO: can this be zero?
566 if(tag->id != ST_DEFINETEXT &&
567 tag->id != ST_DEFINETEXT2) {
568 msg("<error> internal error: putcharacters needs an text tag, not %d\n",tag->id);
571 if(!i->chardatapos) {
572 msg("<warning> putcharacters called with zero characters");
575 for(pass = 0; pass < 2; pass++)
585 advancebits++; // add sign bit
586 swf_SetU8(tag, glyphbits);
587 swf_SetU8(tag, advancebits);
590 for(t=0;t<=i->chardatapos;t++)
592 if(lastfontid != i->chardata[t].fontid ||
593 lastx!=i->chardata[t].x ||
594 lasty!=i->chardata[t].y ||
595 !colorcompare(dev,&color, &i->chardata[t].color) ||
597 lastsize != i->chardata[t].size ||
600 if(charstorepos && pass==0)
603 for(s=0;s<charstorepos;s++)
605 while(charids[s]>=(1<<glyphbits))
607 while(charadvance[s]>=(1<<advancebits))
611 if(charstorepos && pass==1)
613 tag->writeBit = 0; // Q&D
614 swf_SetBits(tag, 0, 1); // GLYPH Record
615 swf_SetBits(tag, charstorepos, 7); // number of glyphs
617 for(s=0;s<charstorepos;s++)
619 swf_SetBits(tag, charids[s], glyphbits);
620 swf_SetBits(tag, charadvance[s], advancebits);
625 if(pass == 1 && t<i->chardatapos)
631 if(lastx != i->chardata[t].x ||
632 lasty != i->chardata[t].y)
634 newx = i->chardata[t].x;
635 newy = i->chardata[t].y;
641 if(!colorcompare(dev,&color, &i->chardata[t].color))
643 color = i->chardata[t].color;
646 font.id = i->chardata[t].fontid;
647 if(lastfontid != i->chardata[t].fontid || lastsize != i->chardata[t].size)
650 tag->writeBit = 0; // Q&D
651 swf_TextSetInfoRecord(tag, newfont, i->chardata[t].size, newcolor, newx,newy);
654 lastfontid = i->chardata[t].fontid;
655 lastx = i->chardata[t].x;
656 lasty = i->chardata[t].y;
657 lastsize = i->chardata[t].size;
660 if(t==i->chardatapos)
664 int nextt = t==i->chardatapos-1?t:t+1;
665 int rel = i->chardata[nextt].x-i->chardata[t].x;
666 if(rel>=0 && (rel<(1<<(advancebits-1)) || pass==0)) {
668 lastx=i->chardata[nextt].x;
672 lastx=i->chardata[t].x;
674 charids[charstorepos] = i->chardata[t].charid;
675 charadvance[charstorepos] = advance;
682 static void putcharacter(gfxdevice_t*dev, int fontid, int charid, int x,int y, int size, RGBA color)
684 swfoutput_internal*i = (swfoutput_internal*)dev->internal;
685 if(i->chardatapos == CHARDATAMAX)
687 msg("<warning> Character buffer too small. SWF will be slightly bigger");
691 i->chardata[i->chardatapos].fontid = fontid;
692 i->chardata[i->chardatapos].charid = charid;
693 i->chardata[i->chardatapos].x = x;
694 i->chardata[i->chardatapos].y = y;
695 i->chardata[i->chardatapos].color = color;
696 i->chardata[i->chardatapos].size = size;
700 /* Notice: we can only put chars in the range -1639,1638 (-32768/20,32768/20).
701 So if we set this value to high, the char coordinates will overflow.
702 If we set it to low, however, the char positions will be inaccurate */
703 #define GLYPH_SCALE 1
705 static void endtext(gfxdevice_t*dev)
707 swfoutput_internal*i = (swfoutput_internal*)dev->internal;
711 i->tag = swf_InsertTag(i->tag,ST_DEFINETEXT2);
712 swf_SetU16(i->tag, i->textid);
715 r = getcharacterbbox(dev, i->swffont, &i->fontmatrix);
716 r = swf_ClipRect(i->pagebbox, r);
717 swf_SetRect(i->tag,&r);
719 swf_SetMatrix(i->tag,&i->fontmatrix);
721 msg("<trace> Placing text (%d characters) as ID %d", i->chardatapos, i->textid);
723 putcharacters(dev, i->tag);
726 if(i->swf->fileVersion >= 8) {
727 i->tag = swf_InsertTag(i->tag, ST_CSMTEXTSETTINGS);
728 swf_SetU16(i->tag, i->textid);
730 //swf_SetU8(i->tag, /*subpixel grid*/(2<<3)|/*flashtype*/0x40);
731 swf_SetU8(i->tag, /*grid*/(1<<3)|/*flashtype*/0x40);
732 //swf_SetU8(i->tag, /*no grid*/(0<<3)|/*flashtype*/0x40);
734 swf_SetU32(i->tag, 0);//thickness
735 swf_SetU32(i->tag, 0);//sharpness
736 swf_SetU8(i->tag, 0);//reserved
738 i->tag = swf_InsertTag(i->tag,ST_PLACEOBJECT2);
740 swf_ObjectPlace(i->tag,i->textid,getNewDepth(dev),&i->page_matrix,NULL,NULL);
744 /* set's the matrix which is to be applied to characters drawn by swfoutput_drawchar() */
745 static void setfontscale(gfxdevice_t*dev,double m11,double m12, double m21,double m22,double x, double y, char force)
751 swfoutput_internal*i = (swfoutput_internal*)dev->internal;
752 if(i->lastfontm11 == m11 &&
753 i->lastfontm12 == m12 &&
754 i->lastfontm21 == m21 &&
755 i->lastfontm22 == m22 && !force)
760 i->lastfontm11 = m11;
761 i->lastfontm12 = m12;
762 i->lastfontm21 = m21;
763 i->lastfontm22 = m22;
765 double xsize = sqrt(m11*m11 + m12*m12);
766 double ysize = sqrt(m21*m21 + m22*m22);
767 i->current_font_size = (xsize>ysize?xsize:ysize)*1;
768 if(i->current_font_size < 1)
769 i->current_font_size = 1;
770 double ifs = 1.0 / (i->current_font_size*GLYPH_SCALE);
773 m.sx = (S32)((m11*ifs)*65536); m.r1 = (S32)((m21*ifs)*65536);
774 m.r0 = (S32)((m12*ifs)*65536); m.sy = (S32)((m22*ifs)*65536);
775 /* this is the position of the first char to set a new fontmatrix-
776 we hope that it's close enough to all other characters using the
777 font, so we use its position as origin for the matrix */
783 static int watermark2_width=47;
784 static int watermark2_height=11;
785 static int watermark2[47] = {95,1989,71,0,2015,337,1678,0,2015,5,1921,320,1938,25,2006,1024,
786 1042,21,13,960,1039,976,8,2000,1359,1088,31,1989,321,1728,0,1152,
787 1344,832,0,1984,0,896,1088,1088,896,0,1984,128,256,512,1984};
789 static void draw_watermark(gfxdevice_t*dev, gfxbbox_t r, char drawall)
791 swfoutput_internal*i = (swfoutput_internal*)dev->internal;
792 double wx = r.xmax / 5.0;
793 double tx = r.xmax*4.0 / 5.0;
794 double ty = r.ymax-wx*watermark2_height/watermark2_width;
795 double sx = (r.xmax - tx) / watermark2_width;
796 double sy = (r.ymax - ty) / watermark2_height;
799 if(ty > 0 && px > 1.0 && py > 1.0) {
801 for(y=0;y<watermark2_height;y++)
802 for(x=0;x<watermark2_width;x++) {
803 if(((watermark2[x]>>y)&1)) {
804 if(!drawall && rand()%5)
806 unsigned int b = rand();
807 moveto(dev, i->tag, x*sx+tx+((b>>1)&1)/20.0, y*sy+ty+((b>>3)&1)/20.0);
808 lineto(dev, i->tag, x*sx+px+tx+((b>>2)&1)/20.0, y*sy+ty+((b>>3)&1)/20.0);
809 lineto(dev, i->tag, x*sx+px+tx+((b>>2)&1)/20.0, y*sy+py+ty+((b>>4)&1)/20.0);
810 lineto(dev, i->tag, x*sx+tx+((b>>1)&1)/20.0, y*sy+py+ty+((b>>4)&1)/20.0);
811 lineto(dev, i->tag, x*sx+tx+((b>>1)&1)/20.0, y*sy+ty+((b>>3)&1)/20.0);
817 static void swfoutput_setfillcolor(gfxdevice_t* dev, U8 r, U8 g, U8 b, U8 a)
819 swfoutput_internal*i = (swfoutput_internal*)dev->internal;
820 if(i->fillrgb.r == r &&
823 i->fillrgb.a == a) return;
832 static void insert_watermark(gfxdevice_t*dev, char drawall)
834 swfoutput_internal*i = (swfoutput_internal*)dev->internal;
835 if(!drawall && i->watermarks>20)
841 swfoutput_setfillcolor(dev, 0,0,255,192);
843 swfoutput_setfillcolor(dev, rand(),rand(),rand(),(rand()&127)+128);
848 gfxbbox_t r; r.xmin = r.ymin = 0;
851 draw_watermark(dev, r, drawall);
857 static void endpage(gfxdevice_t*dev)
859 swfoutput_internal*i = (swfoutput_internal*)dev->internal;
870 if(i->config_watermark) {
871 insert_watermark(dev, 1);
877 static void addViewer(gfxdevice_t* dev)
879 swfoutput_internal*i = (swfoutput_internal*)dev->internal;
882 RGBA button_colors[3]= {{0xbf,0x00,0x00,0x80},{0xbf,0x20,0x20,0xc0}, {0xbf,0xc0,0xc0,0xff}};
884 int button_sizex = 20;
885 int button_sizey = 20;
887 RGBA black = {255,0,0,0};
889 i->tag = swf_InsertTag(i->tag,ST_DEFINESHAPE3);
891 int ls1 = swf_ShapeAddLineStyle(s,40,&black);
892 int fs1 = swf_ShapeAddSolidFillStyle(s,&button_colors[t/2]);
893 int shapeid = ids[t] = getNewID(dev);
894 swf_SetU16(i->tag,shapeid);
896 r.xmin = -20*button_sizex;
897 r.xmax = 20*button_sizex;
899 r.ymax = 40*button_sizey;
900 swf_SetRect(i->tag,&r); // set shape bounds
901 swf_SetShapeHeader(i->tag,s); // write all styles to tag
902 swf_ShapeSetAll(i->tag,s,0*button_sizex,0,ls1,fs1,0);
903 swf_ShapeSetLine(i->tag,s,(1-(t&1)*2)*20*button_sizex,20*button_sizey);
904 swf_ShapeSetLine(i->tag,s,-(1-(t&1)*2)*20*button_sizex,20*button_sizey);
905 swf_ShapeSetLine(i->tag,s,0,-40*button_sizey);
906 swf_ShapeSetEnd(i->tag); // finish drawing
907 swf_ShapeFree(s); // clean shape structure (which isn't needed anymore after writing the tag)
909 ActionTAG*a1=0,*a2=0,*a3=0;
910 a1 = action_NextFrame(a1);
911 a1 = action_Stop(a1);
914 a2 = action_PreviousFrame(a2);
915 a2 = action_Stop(a2);
918 a3 = action_Stop(a3);
921 i->tag = swf_InsertTag(i->tag, ST_DOACTION);
922 swf_ActionSet(i->tag,a3);
924 i->tag = swf_InsertTag(i->tag,ST_DEFINEBUTTON);
925 int buttonid1 = getNewID(dev);
926 swf_SetU16(i->tag, buttonid1);
927 swf_ButtonSetRecord(i->tag,BS_UP|BS_HIT,ids[0],1,NULL,NULL);
928 swf_ButtonSetRecord(i->tag,BS_OVER,ids[2],1,NULL,NULL);
929 swf_ButtonSetRecord(i->tag,BS_DOWN,ids[4],1,NULL,NULL);
930 swf_SetU8(i->tag,0); // end of button records
931 swf_ActionSet(i->tag,a1);
933 i->tag = swf_InsertTag(i->tag,ST_DEFINEBUTTON);
934 int buttonid2 = getNewID(dev);
935 swf_SetU16(i->tag, buttonid2);
936 swf_ButtonSetRecord(i->tag,BS_UP|BS_HIT,ids[1],1,NULL,NULL);
937 swf_ButtonSetRecord(i->tag,BS_OVER,ids[3],1,NULL,NULL);
938 swf_ButtonSetRecord(i->tag,BS_DOWN,ids[5],1,NULL,NULL);
939 swf_SetU8(i->tag,0); // end of button records
940 swf_ActionSet(i->tag,a2);
942 i->tag = swf_InsertTag(i->tag,ST_PLACEOBJECT2);
944 swf_GetMatrix(0, &m);
945 m.tx = button_sizex*20+200;
946 swf_ObjectPlace(i->tag, buttonid2, 65534,&m,0,0);
947 i->tag = swf_InsertTag(i->tag,ST_PLACEOBJECT2);
948 m.tx = button_sizex*20+200+200;
949 swf_ObjectPlace(i->tag, buttonid1, 65535,&m,0,0);
953 void swf_startframe(gfxdevice_t*dev, int width, int height)
955 swfoutput_internal*i = (swfoutput_internal*)dev->internal;
957 if(i->config_protect) {
958 i->tag = swf_InsertTag(i->tag, ST_PROTECT);
959 i->config_protect = 0;
961 if(i->config_simpleviewer) {
966 if(!i->firstpage && !i->pagefinished)
969 msg("<verbose> Starting new SWF page of size %dx%d", width, height);
971 swf_GetMatrix(0, &i->page_matrix);
972 i->page_matrix.tx = 0;
973 i->page_matrix.ty = 0;
980 /* create a bbox structure with the page size. This is used
981 for clipping shape and text bounding boxes. As we don't want to
982 generate bounding boxes which extend beyond the movie size (in
983 order to not confuse Flash), we clip everything against i->pagebbox */
984 i->pagebbox.xmin = 0;
985 i->pagebbox.ymin = 0;
986 i->pagebbox.xmax = width*20;
987 i->pagebbox.ymax = height*20;
989 /* increase SWF's bounding box */
990 swf_ExpandRect2(&i->swf->movieSize, &i->pagebbox);
992 i->lastframeno = i->frameno;
997 void swf_endframe(gfxdevice_t*dev)
999 swfoutput_internal*i = (swfoutput_internal*)dev->internal;
1001 if(!i->pagefinished)
1004 if( (i->swf->fileVersion <= 8) && (i->config_insertstoptag) ) {
1006 atag = action_Stop(atag);
1007 atag = action_End(atag);
1008 i->tag = swf_InsertTag(i->tag,ST_DOACTION);
1009 swf_ActionSet(i->tag,atag);
1011 i->tag = swf_InsertTag(i->tag,ST_SHOWFRAME);
1014 for(i->depth;i->depth>i->startdepth;i->depth--) {
1015 i->tag = swf_InsertTag(i->tag,ST_REMOVEOBJECT2);
1016 swf_SetU16(i->tag,i->depth);
1018 i->depth = i->startdepth;
1020 if(i->config_frameresets) {
1021 for(i->currentswfid;i->currentswfid>i->startids;i->currentswfid--) {
1022 i->tag = swf_InsertTag(i->tag,ST_FREECHARACTER);
1023 swf_SetU16(i->tag,i->currentswfid);
1025 i->currentswfid = i->startids;
1029 static void setBackground(gfxdevice_t*dev, int x1, int y1, int x2, int y2)
1031 swfoutput_internal*i = (swfoutput_internal*)dev->internal;
1033 rgb.a = rgb.r = rgb.g = rgb.b = 0xff;
1037 int shapeid = getNewID(dev);
1042 i->tag = swf_InsertTag(i->tag, ST_DEFINESHAPE);
1044 fs1 = swf_ShapeAddSolidFillStyle(s, &rgb);
1045 swf_SetU16(i->tag,shapeid);
1046 swf_SetRect(i->tag,&r);
1047 swf_SetShapeHeader(i->tag,s);
1048 swf_ShapeSetAll(i->tag,s,x1,y1,ls1,fs1,0);
1049 swf_ShapeSetLine(i->tag,s,(x2-x1),0);
1050 swf_ShapeSetLine(i->tag,s,0,(y2-y1));
1051 swf_ShapeSetLine(i->tag,s,(x1-x2),0);
1052 swf_ShapeSetLine(i->tag,s,0,(y1-y2));
1053 swf_ShapeSetEnd(i->tag);
1055 i->tag = swf_InsertTag(i->tag, ST_PLACEOBJECT2);
1056 swf_ObjectPlace(i->tag,shapeid,getNewDepth(dev),0,0,0);
1057 i->tag = swf_InsertTag(i->tag, ST_PLACEOBJECT2);
1058 swf_ObjectPlaceClip(i->tag,shapeid,getNewDepth(dev),0,0,0,65535);
1061 /* initialize the swf writer */
1062 void gfxdevice_swf_init(gfxdevice_t* dev)
1064 memset(dev, 0, sizeof(gfxdevice_t));
1068 dev->internal = init_internal_struct(); // set config to default values
1070 dev->startpage = swf_startframe;
1071 dev->endpage = swf_endframe;
1072 dev->finish = swf_finish;
1073 dev->fillbitmap = swf_fillbitmap;
1074 dev->setparameter = swf_setparameter;
1075 dev->stroke = swf_stroke;
1076 dev->startclip = swf_startclip;
1077 dev->endclip = swf_endclip;
1078 dev->fill = swf_fill;
1079 dev->fillbitmap = swf_fillbitmap;
1080 dev->fillgradient = swf_fillgradient;
1081 dev->addfont = swf_addfont;
1082 dev->drawchar = swf_drawchar;
1083 dev->drawlink = swf_drawlink;
1085 swfoutput_internal*i = (swfoutput_internal*)dev->internal;
1088 msg("<verbose> initializing swf output\n", i->max_x,i->max_y);
1092 i->swf = (SWF*)rfx_calloc(sizeof(SWF));
1093 i->swf->fileVersion = 0;
1094 i->swf->frameRate = 0x80;
1095 i->swf->movieSize.xmin = 0;
1096 i->swf->movieSize.ymin = 0;
1097 i->swf->movieSize.xmax = 0;
1098 i->swf->movieSize.ymax = 0;
1100 i->swf->firstTag = swf_InsertTag(NULL,ST_SETBACKGROUNDCOLOR);
1101 i->tag = i->swf->firstTag;
1103 rgb.a = rgb.r = rgb.g = rgb.b = 0xff;
1105 swf_SetRGB(i->tag,&rgb);
1107 i->startdepth = i->depth = 0;
1108 i->startids = i->currentswfid = 0;
1111 static void startshape(gfxdevice_t*dev)
1113 swfoutput_internal*i = (swfoutput_internal*)dev->internal;
1118 //if(i->chardatapos && i->chardata[i->chardatapos-1].color.a)
1121 i->tag = swf_InsertTag(i->tag,ST_DEFINESHAPE3);
1123 swf_ShapeNew(&i->shape);
1124 i->linestyleid = swf_ShapeAddLineStyle(i->shape,i->linewidth,&i->strokergb);
1125 i->fillstyleid = swf_ShapeAddSolidFillStyle(i->shape,&i->fillrgb);
1127 RGBA markcol = {0,i->mark[0],i->mark[1],i->mark[2]};
1128 swf_ShapeAddSolidFillStyle(i->shape,&markcol);
1131 i->shapeid = getNewID(dev);
1133 msg("<debug> Using shape id %d", i->shapeid);
1135 swf_SetU16(i->tag,i->shapeid); // ID
1137 i->bboxrectpos = i->tag->len;
1139 swf_SetRect(i->tag,&i->pagebbox);
1141 memset(&i->bboxrect, 0, sizeof(i->bboxrect));
1143 swf_SetShapeStyles(i->tag,i->shape);
1144 swf_ShapeCountBits(i->shape,NULL,NULL);
1145 swf_SetShapeBits(i->tag,i->shape);
1147 /* TODO: do we really need this? */
1148 //swf_ShapeSetAll(i->tag,i->shape,/*x*/0,/*y*/0,i->linestyleid,0,0);
1149 //swf_ShapeSetAll(i->tag,i->shape,/*x*/UNDEFINED_COORD,/*y*/UNDEFINED_COORD,i->linestyleid,0,0);
1150 i->swflastx=i->swflasty=UNDEFINED_COORD;
1151 i->lastwasfill = -1;
1152 i->shapeisempty = 1;
1155 static void starttext(gfxdevice_t*dev)
1157 swfoutput_internal*i = (swfoutput_internal*)dev->internal;
1161 if(i->config_watermark) {
1162 insert_watermark(dev, 0);
1164 i->textid = getNewID(dev);
1165 i->swflastx=i->swflasty=0;
1169 /* TODO: move to ../lib/rfxswf */
1170 void changeRect(gfxdevice_t*dev, TAG*tag, int pos, SRECT*newrect)
1172 swfoutput_internal*i = (swfoutput_internal*)dev->internal;
1173 /* determine length of old rect */
1177 swf_GetRect(tag, &old);
1178 swf_ResetReadBits(tag);
1179 int pos_end = tag->pos;
1181 int len = tag->len - pos_end;
1182 U8*data = (U8*)malloc(len);
1183 memcpy(data, &tag->data[pos_end], len);
1186 swf_SetRect(tag, newrect);
1187 swf_SetBlock(tag, data, len);
1189 tag->pos = tag->readBit = 0;
1192 void cancelshape(gfxdevice_t*dev)
1194 swfoutput_internal*i = (swfoutput_internal*)dev->internal;
1195 /* delete old shape tag */
1197 i->tag = i->tag->prev;
1198 swf_DeleteTag(0, todel);
1199 if(i->shape) {swf_ShapeFree(i->shape);i->shape=0;}
1201 i->bboxrectpos = -1;
1203 // i->currentswfid--; // doesn't work, for some reason
1206 void fixAreas(gfxdevice_t*dev)
1208 swfoutput_internal*i = (swfoutput_internal*)dev->internal;
1209 if(!i->shapeisempty && i->fill &&
1210 (i->bboxrect.xmin == i->bboxrect.xmax ||
1211 i->bboxrect.ymin == i->bboxrect.ymax) &&
1212 i->config_minlinewidth >= 0.001
1214 msg("<debug> Shape has size 0: width=%.2f height=%.2f",
1215 (i->bboxrect.xmax-i->bboxrect.xmin)/20.0,
1216 (i->bboxrect.ymax-i->bboxrect.ymin)/20.0
1219 SRECT r = i->bboxrect;
1221 if(r.xmin == r.xmax && r.ymin == r.ymax) {
1222 /* this thing comes down to a single dot- nothing to fix here */
1228 RGBA save_col = i->strokergb;
1229 int save_width = i->linewidth;
1231 i->strokergb = i->fillrgb;
1232 i->linewidth = (int)(i->config_minlinewidth*20);
1233 if(i->linewidth==0) i->linewidth = 1;
1238 moveto(dev, i->tag, r.xmin/20.0,r.ymin/20.0);
1239 lineto(dev, i->tag, r.xmax/20.0,r.ymax/20.0);
1241 i->strokergb = save_col;
1242 i->linewidth = save_width;
1247 static void endshape_noput(gfxdevice_t*dev)
1249 swfoutput_internal*i = (swfoutput_internal*)dev->internal;
1252 //changeRect(dev, i->tag, i->bboxrectpos, &i->bboxrect);
1255 swf_ShapeFree(i->shape);
1263 static void endshape(gfxdevice_t*dev)
1265 swfoutput_internal*i = (swfoutput_internal*)dev->internal;
1271 if(i->shapeisempty ||
1273 (i->bboxrect.xmin == i->bboxrect.xmax &&
1274 i->bboxrect.ymin == i->bboxrect.ymax))
1276 // delete the shape again, we didn't do anything
1277 msg("<debug> cancelling shape: bbox is (%f,%f,%f,%f)",
1278 i->bboxrect.xmin /20.0,
1279 i->bboxrect.ymin /20.0,
1280 i->bboxrect.xmax /20.0,
1281 i->bboxrect.ymax /20.0
1287 swf_ShapeSetEnd(i->tag);
1289 SRECT r = swf_ClipRect(i->pagebbox, i->bboxrect);
1290 changeRect(dev, i->tag, i->bboxrectpos, &r);
1292 msg("<trace> Placing shape ID %d", i->shapeid);
1294 i->tag = swf_InsertTag(i->tag,ST_PLACEOBJECT2);
1295 MATRIX m = i->page_matrix;
1296 m.tx += i->shapeposx;
1297 m.ty += i->shapeposy;
1298 swf_ObjectPlace(i->tag,i->shapeid,getNewDepth(dev),&m,NULL,NULL);
1300 if(i->config_animate) {
1301 i->tag = swf_InsertTag(i->tag,ST_SHOWFRAME);
1304 swf_ShapeFree(i->shape);
1307 i->bboxrectpos = -1;
1314 void wipeSWF(SWF*swf)
1316 TAG*tag = swf->firstTag;
1318 TAG*next = tag->next;
1319 if(tag->id != ST_SETBACKGROUNDCOLOR &&
1320 tag->id != ST_END &&
1321 tag->id != ST_DOACTION &&
1322 tag->id != ST_SHOWFRAME) {
1323 swf_DeleteTag(swf, tag);
1329 void swfoutput_finalize(gfxdevice_t*dev)
1331 swfoutput_internal*i = (swfoutput_internal*)dev->internal;
1333 if(i->tag && i->tag->id == ST_END)
1334 return; //already done
1336 i->swf->fileVersion = i->config_flashversion;
1337 i->swf->frameRate = i->config_framerate*0x100;
1339 if(i->config_bboxvars) {
1340 TAG* tag = swf_InsertTag(i->swf->firstTag, ST_DOACTION);
1342 a = action_PushString(a, "xmin");
1343 a = action_PushFloat(a, i->swf->movieSize.xmin / 20.0);
1344 a = action_SetVariable(a);
1345 a = action_PushString(a, "ymin");
1346 a = action_PushFloat(a, i->swf->movieSize.ymin / 20.0);
1347 a = action_SetVariable(a);
1348 a = action_PushString(a, "xmax");
1349 a = action_PushFloat(a, i->swf->movieSize.xmax / 20.0);
1350 a = action_SetVariable(a);
1351 a = action_PushString(a, "ymax");
1352 a = action_PushFloat(a, i->swf->movieSize.ymax / 20.0);
1353 a = action_SetVariable(a);
1354 a = action_PushString(a, "width");
1355 a = action_PushFloat(a, (i->swf->movieSize.xmax - i->swf->movieSize.xmin) / 20.0);
1356 a = action_SetVariable(a);
1357 a = action_PushString(a, "height");
1358 a = action_PushFloat(a, (i->swf->movieSize.ymax - i->swf->movieSize.ymin) / 20.0);
1359 a = action_SetVariable(a);
1361 swf_ActionSet(tag, a);
1366 free(i->mark);i->mark = 0;
1370 fontlist_t *iterator = i->fontlist;
1372 TAG*mtag = i->swf->firstTag;
1373 if(iterator->swffont) {
1374 if(!i->config_storeallcharacters) {
1375 msg("<debug> Reducing font %s", iterator->swffont->name);
1376 swf_FontReduce(iterator->swffont);
1378 int used = iterator->swffont->use && iterator->swffont->use->used_glyphs;
1380 mtag = swf_InsertTag(mtag, ST_DEFINEFONT2);
1381 swf_FontSetDefine2(mtag, iterator->swffont);
1385 iterator = iterator->next;
1388 i->tag = swf_InsertTag(i->tag,ST_END);
1389 TAG* tag = i->tag->prev;
1391 /* remove the removeobject2 tags between the last ST_SHOWFRAME
1392 and the ST_END- they confuse the flash player */
1393 while(tag->id == ST_REMOVEOBJECT2) {
1394 TAG* prev = tag->prev;
1395 swf_DeleteTag(i->swf, tag);
1402 if(i->config_enablezlib || i->config_flashversion>=6) {
1403 i->swf->compressed = 1;
1406 /* Add AVM2 actionscript */
1407 if(i->config_flashversion>=9 &&
1408 (i->config_insertstoptag || i->hasbuttons)) {
1409 swf_AddButtonLinks(i->swf, i->config_insertstoptag,
1410 i->config_internallinkfunction||i->config_externallinkfunction);
1412 // if(i->config_reordertags)
1413 // swf_Optimize(i->swf);
1416 int swfresult_save(gfxresult_t*gfx, const char*filename)
1418 SWF*swf = (SWF*)gfx->internal;
1421 fi = open(filename, O_BINARY|O_CREAT|O_TRUNC|O_WRONLY, 0777);
1426 msg("<fatal> Could not create \"%s\". ", FIXNULL(filename));
1430 if FAILED(swf_WriteSWF(fi,swf))
1431 msg("<error> WriteSWF() failed.\n");
1437 void* swfresult_get(gfxresult_t*gfx, const char*name)
1439 SWF*swf = (SWF*)gfx->internal;
1440 if(!strcmp(name, "swf")) {
1441 return (void*)swf_CopySWF(swf);
1442 } else if(!strcmp(name, "xmin")) {
1443 return (void*)(swf->movieSize.xmin/20);
1444 } else if(!strcmp(name, "ymin")) {
1445 return (void*)(swf->movieSize.ymin/20);
1446 } else if(!strcmp(name, "xmax")) {
1447 return (void*)(swf->movieSize.xmax/20);
1448 } else if(!strcmp(name, "ymax")) {
1449 return (void*)(swf->movieSize.ymax/20);
1450 } else if(!strcmp(name, "width")) {
1451 return (void*)((swf->movieSize.xmax - swf->movieSize.xmin)/20);
1452 } else if(!strcmp(name, "height")) {
1453 return (void*)((swf->movieSize.ymax - swf->movieSize.ymin)/20);
1457 void swfresult_destroy(gfxresult_t*gfx)
1460 swf_FreeTags((SWF*)gfx->internal);
1461 free(gfx->internal);
1464 memset(gfx, 0, sizeof(gfxresult_t));
1468 static void swfoutput_destroy(gfxdevice_t* dev);
1470 gfxresult_t* swf_finish(gfxdevice_t* dev)
1472 swfoutput_internal*i = (swfoutput_internal*)dev->internal;
1475 if(i->config_linktarget) {
1476 free(i->config_linktarget);
1477 i->config_linktarget = 0;
1480 swfoutput_finalize(dev);
1481 SWF* swf = i->swf;i->swf = 0;
1482 swfoutput_destroy(dev);
1484 result = (gfxresult_t*)rfx_calloc(sizeof(gfxresult_t));
1485 result->internal = swf;
1486 result->save = swfresult_save;
1488 result->get = swfresult_get;
1489 result->destroy = swfresult_destroy;
1493 /* Perform cleaning up */
1494 static void swfoutput_destroy(gfxdevice_t* dev)
1496 swfoutput_internal*i = (swfoutput_internal*)dev->internal;
1498 /* not initialized yet- nothing to destroy */
1502 fontlist_t *tmp,*iterator = i->fontlist;
1504 if(iterator->swffont) {
1505 swf_FontFree(iterator->swffont);iterator->swffont=0;
1508 iterator = iterator->next;
1511 if(i->swf) {swf_FreeTags(i->swf);free(i->swf);i->swf = 0;}
1514 memset(dev, 0, sizeof(gfxdevice_t));
1517 static void swfoutput_setstrokecolor(gfxdevice_t* dev, U8 r, U8 g, U8 b, U8 a)
1519 swfoutput_internal*i = (swfoutput_internal*)dev->internal;
1520 if(i->strokergb.r == r &&
1521 i->strokergb.g == g &&
1522 i->strokergb.b == b &&
1523 i->strokergb.a == a) return;
1533 //#define ROUND_UP 19
1534 //#define ROUND_UP 10
1536 static void swfoutput_setlinewidth(gfxdevice_t*dev, double _linewidth)
1538 swfoutput_internal*i = (swfoutput_internal*)dev->internal;
1539 if(i->linewidth == (U16)(_linewidth*20+19.0/20.0))
1543 i->linewidth = (U16)(_linewidth*20+19.0/20.0);
1547 static void drawlink(gfxdevice_t*dev, ActionTAG*,ActionTAG*, gfxline_t*points, char mouseover, const char*url);
1548 static void swfoutput_namedlink(gfxdevice_t*dev, char*name, gfxline_t*points);
1549 static void swfoutput_linktopage(gfxdevice_t*dev, int page, gfxline_t*points);
1550 static void swfoutput_linktourl(gfxdevice_t*dev, const char*url, gfxline_t*points);
1552 /*void swfoutput_drawlink(gfxdevice_t*dev, char*url, gfxline_t*points)
1554 swfoutput_internal*i = (swfoutput_internal*)dev->internal;
1555 dev->drawlink(dev, points, url);
1558 void swf_drawlink(gfxdevice_t*dev, gfxline_t*points, const char*url)
1560 swfoutput_internal*i = (swfoutput_internal*)dev->internal;
1562 if(!strncmp("http://pdf2swf:", url, 15)) {
1563 char*tmp = strdup(url);
1564 int l = strlen(tmp);
1567 swfoutput_namedlink(dev, tmp+15, points);
1570 } else if(!strncmp("page", url, 4)) {
1573 if(url[t]<'0' || url[t]>'9')
1576 int page = atoi(&url[4]);
1577 if(page<0) page = 0;
1578 swfoutput_linktopage(dev, page, points);
1581 swfoutput_linktourl(dev, url, points);
1584 void swfoutput_linktourl(gfxdevice_t*dev, const char*url, gfxline_t*points)
1586 ActionTAG* actions = 0;
1587 swfoutput_internal*i = (swfoutput_internal*)dev->internal;
1593 if(i->config_externallinkfunction && i->config_flashversion<=8) {
1594 actions = action_PushString(actions, url); //parameter
1595 actions = action_PushInt(actions, 1); //number of parameters (1)
1596 actions = action_PushString(actions, i->config_externallinkfunction); //function name
1597 actions = action_CallFunction(actions);
1598 } else if(!i->config_linktarget) {
1599 if(!i->config_opennewwindow)
1600 actions = action_GetUrl(actions, url, "_parent");
1602 actions = action_GetUrl(actions, url, "_this");
1604 actions = action_GetUrl(actions, url, i->config_linktarget);
1606 actions = action_End(actions);
1608 drawlink(dev, actions, 0, points, 0, url);
1610 void swfoutput_linktopage(gfxdevice_t*dev, int page, gfxline_t*points)
1612 swfoutput_internal*i = (swfoutput_internal*)dev->internal;
1613 ActionTAG* actions = 0;
1620 if(!i->config_internallinkfunction || i->config_flashversion>=9) {
1621 actions = action_GotoFrame(actions, page-1);
1622 actions = action_End(actions);
1624 actions = action_PushInt(actions, page); //parameter
1625 actions = action_PushInt(actions, 1); //number of parameters (1)
1626 actions = action_PushString(actions, i->config_internallinkfunction); //function name
1627 actions = action_CallFunction(actions);
1628 actions = action_End(actions);
1632 sprintf(name, "page%d", page);
1634 drawlink(dev, actions, 0, points, 0, name);
1637 /* Named Links (a.k.a. Acrobatmenu) are used to implement various gadgets
1638 of the viewer objects, like subtitles, index elements etc.
1640 void swfoutput_namedlink(gfxdevice_t*dev, char*name, gfxline_t*points)
1642 swfoutput_internal*i = (swfoutput_internal*)dev->internal;
1643 ActionTAG *actions1,*actions2;
1644 char*tmp = strdup(name);
1652 if(!strncmp(tmp, "call:", 5))
1654 char*x = strchr(&tmp[5], ':');
1656 actions1 = action_PushInt(0, 0); //number of parameters (0)
1657 actions1 = action_PushString(actions1, &tmp[5]); //function name
1658 actions1 = action_CallFunction(actions1);
1659 actions1 = action_End(actions1);
1662 actions1 = action_PushString(0, x+1); //parameter
1663 actions1 = action_PushInt(actions1, 1); //number of parameters (1)
1664 actions1 = action_PushString(actions1, &tmp[5]); //function name
1665 actions1 = action_CallFunction(actions1);
1666 actions1 = action_End(actions1);
1668 actions2 = action_End(0);
1673 actions1 = action_PushString(0, "/:subtitle");
1674 actions1 = action_PushString(actions1, name);
1675 actions1 = action_SetVariable(actions1);
1676 actions1 = action_End(actions1);
1678 actions2 = action_PushString(0, "/:subtitle");
1679 actions2 = action_PushString(actions2, "");
1680 actions2 = action_SetVariable(actions2);
1681 actions2 = action_End(actions2);
1684 drawlink(dev, actions1, actions2, points, mouseover, name);
1686 swf_ActionFree(actions1);
1687 swf_ActionFree(actions2);
1691 static void drawgfxline(gfxdevice_t*dev, gfxline_t*line, int fill)
1693 swfoutput_internal*i = (swfoutput_internal*)dev->internal;
1694 gfxcoord_t lastx=0,lasty=0,px=0,py=0;
1696 int lines= 0, splines=0;
1703 /* check whether the next segment is zero */
1704 if(line->type == gfx_moveTo) {
1705 moveto(dev, i->tag, line->x, line->y);
1706 px = lastx = line->x;
1707 py = lasty = line->y;
1709 } if(line->type == gfx_lineTo) {
1710 lineto(dev, i->tag, line->x, line->y);
1715 } else if(line->type == gfx_splineTo) {
1717 s.x = line->sx;p.x = line->x;
1718 s.y = line->sy;p.y = line->y;
1719 splineto(dev, i->tag, s, p);
1727 msg("<trace> drawgfxline, %d lines, %d splines", lines, splines);
1731 static void drawlink(gfxdevice_t*dev, ActionTAG*actions1, ActionTAG*actions2, gfxline_t*points, char mouseover, const char*url)
1733 swfoutput_internal*i = (swfoutput_internal*)dev->internal;
1742 int buttonid = getNewID(dev);
1743 gfxbbox_t bbox = gfxline_getbbox(points);
1748 myshapeid = getNewID(dev);
1749 i->tag = swf_InsertTag(i->tag,ST_DEFINESHAPE3);
1750 swf_ShapeNew(&i->shape);
1751 rgb.r = rgb.b = rgb.a = rgb.g = 0;
1752 fsid = swf_ShapeAddSolidFillStyle(i->shape,&rgb);
1753 swf_SetU16(i->tag, myshapeid);
1754 r.xmin = (int)(bbox.xmin*20);
1755 r.ymin = (int)(bbox.ymin*20);
1756 r.xmax = (int)(bbox.xmax*20);
1757 r.ymax = (int)(bbox.ymax*20);
1758 r = swf_ClipRect(i->pagebbox, r);
1759 swf_SetRect(i->tag,&r);
1760 swf_SetShapeStyles(i->tag,i->shape);
1761 swf_ShapeCountBits(i->shape,NULL,NULL);
1762 swf_SetShapeBits(i->tag,i->shape);
1763 swf_ShapeSetAll(i->tag,i->shape,/*x*/0,/*y*/0,0,fsid,0);
1764 i->swflastx = i->swflasty = 0;
1765 drawgfxline(dev, points, 1);
1766 swf_ShapeSetEnd(i->tag);
1769 myshapeid2 = getNewID(dev);
1770 i->tag = swf_InsertTag(i->tag,ST_DEFINESHAPE3);
1771 swf_ShapeNew(&i->shape);
1773 rgb = i->config_linkcolor;
1775 fsid = swf_ShapeAddSolidFillStyle(i->shape,&rgb);
1776 swf_SetU16(i->tag, myshapeid2);
1777 r.xmin = (int)(bbox.xmin*20);
1778 r.ymin = (int)(bbox.ymin*20);
1779 r.xmax = (int)(bbox.xmax*20);
1780 r.ymax = (int)(bbox.ymax*20);
1781 r = swf_ClipRect(i->pagebbox, r);
1782 swf_SetRect(i->tag,&r);
1783 swf_SetShapeStyles(i->tag,i->shape);
1784 swf_ShapeCountBits(i->shape,NULL,NULL);
1785 swf_SetShapeBits(i->tag,i->shape);
1786 swf_ShapeSetAll(i->tag,i->shape,/*x*/0,/*y*/0,0,fsid,0);
1787 i->swflastx = i->swflasty = 0;
1788 drawgfxline(dev, points, 1);
1789 swf_ShapeSetEnd(i->tag);
1793 i->tag = swf_InsertTag(i->tag,ST_DEFINEBUTTON);
1794 swf_SetU16(i->tag,buttonid); //id
1795 swf_ButtonSetFlags(i->tag, 0); //menu=no
1796 swf_ButtonSetRecord(i->tag,0x01,myshapeid,i->depth,0,0);
1797 swf_ButtonSetRecord(i->tag,0x02,myshapeid2,i->depth,0,0);
1798 swf_ButtonSetRecord(i->tag,0x04,myshapeid2,i->depth,0,0);
1799 swf_ButtonSetRecord(i->tag,0x08,myshapeid,i->depth,0,0);
1800 swf_SetU8(i->tag,0);
1801 swf_ActionSet(i->tag,actions1);
1802 swf_SetU8(i->tag,0);
1806 i->tag = swf_InsertTag(i->tag,ST_DEFINEBUTTON2);
1807 swf_SetU16(i->tag,buttonid); //id
1808 swf_ButtonSetFlags(i->tag, 0); //menu=no
1809 swf_ButtonSetRecord(i->tag,0x01,myshapeid,i->depth,0,0);
1810 swf_ButtonSetRecord(i->tag,0x02,myshapeid2,i->depth,0,0);
1811 swf_ButtonSetRecord(i->tag,0x04,myshapeid2,i->depth,0,0);
1812 swf_ButtonSetRecord(i->tag,0x08,myshapeid,i->depth,0,0);
1813 swf_SetU8(i->tag,0); // end of button records
1814 swf_ButtonSetCondition(i->tag, BC_IDLE_OVERUP);
1815 swf_ActionSet(i->tag,actions1);
1817 swf_ButtonSetCondition(i->tag, BC_OVERUP_IDLE);
1818 swf_ActionSet(i->tag,actions2);
1819 swf_SetU8(i->tag,0);
1820 swf_ButtonPostProcess(i->tag, 2);
1822 swf_SetU8(i->tag,0);
1823 swf_ButtonPostProcess(i->tag, 1);
1827 const char* name = 0;
1828 if(i->config_linknameurl) {
1832 sprintf(buf, "button%d", buttonid);
1835 msg("<trace> Placing link ID %d", buttonid);
1836 i->tag = swf_InsertTag(i->tag,ST_PLACEOBJECT2);
1838 if(posx!=0 || posy!=0) {
1840 p.x = (int)(posx*20);
1841 p.y = (int)(posy*20);
1842 p = swf_TurnPoint(p, &i->page_matrix);
1847 swf_ObjectPlace(i->tag, buttonid, getNewDepth(dev),&m,0,name);
1849 swf_ObjectPlace(i->tag, buttonid, getNewDepth(dev),&i->page_matrix,0,name);
1856 for(t=0;t<picpos;t++)
1858 if(pic_xids[t] == xid &&
1859 pic_yids[t] == yid) {
1860 width = pic_width[t];
1861 height = pic_height[t];
1865 pic_ids[picpos] = swfoutput_drawimagelosslessN(&output, pic, pal, width, height, x1,y1,x2,y2,x3,y3,x4,y4, numpalette);
1866 pic_xids[picpos] = xid;
1867 pic_yids[picpos] = yid;
1868 pic_width[picpos] = width;
1869 pic_height[picpos] = height;
1872 pic[width*y+x] = buf[0];
1876 xid += pal[1].r*3 + pal[1].g*11 + pal[1].b*17;
1877 yid += pal[1].r*7 + pal[1].g*5 + pal[1].b*23;
1881 xid += x*r+x*b*3+x*g*7+x*a*11;
1882 yid += y*r*3+y*b*17+y*g*19+y*a*11;
1884 for(t=0;t<picpos;t++)
1886 if(pic_xids[t] == xid &&
1887 pic_yids[t] == yid) {
1896 int swf_setparameter(gfxdevice_t*dev, const char*name, const char*value)
1898 swfoutput_internal*i = (swfoutput_internal*)dev->internal;
1900 msg("<trace> swfdevice: %s=%s", name, value);
1901 if(!strcmp(name, "jpegsubpixels")) {
1902 i->config_jpegsubpixels = atof(value);
1903 } else if(!strcmp(name, "ppmsubpixels")) {
1904 i->config_ppmsubpixels = atof(value);
1905 } else if(!strcmp(name, "subpixels")) {
1906 i->config_ppmsubpixels = i->config_jpegsubpixels = atof(value);
1907 } else if(!strcmp(name, "drawonlyshapes")) {
1908 i->config_drawonlyshapes = atoi(value);
1909 } else if(!strcmp(name, "ignoredraworder")) {
1910 i->config_ignoredraworder = atoi(value);
1911 } else if(!strcmp(name, "mark")) {
1912 if(!value || !value[0]) {
1913 if(i->mark) free(i->mark);
1917 i->mark = strdup("...");
1918 for(t=0;t<3;t++) if(value[t]) i->mark[t] = value[t];
1920 } else if(!strcmp(name, "filloverlap")) {
1921 i->config_filloverlap = atoi(value);
1922 } else if(!strcmp(name, "linksopennewwindow")) {
1923 i->config_opennewwindow = atoi(value);
1924 } else if(!strcmp(name, "opennewwindow")) {
1925 i->config_opennewwindow = atoi(value);
1926 } else if(!strcmp(name, "storeallcharacters")) {
1927 i->config_storeallcharacters = atoi(value);
1928 } else if(!strcmp(name, "enablezlib")) {
1929 i->config_enablezlib = atoi(value);
1930 } else if(!strcmp(name, "bboxvars")) {
1931 i->config_bboxvars = atoi(value);
1932 } else if(!strcmp(name, "frameresets")) {
1933 i->config_frameresets = atoi(value);
1934 } else if(!strcmp(name, "showclipshapes")) {
1935 i->config_showclipshapes = atoi(value);
1936 } else if(!strcmp(name, "reordertags")) {
1937 i->config_reordertags = atoi(value);
1938 } else if(!strcmp(name, "internallinkfunction")) {
1939 i->config_internallinkfunction = strdup(value);
1940 } else if(!strcmp(name, "externallinkfunction")) {
1941 i->config_externallinkfunction = strdup(value);
1942 } else if(!strcmp(name, "linkfunction")) { //sets both internallinkfunction and externallinkfunction
1943 i->config_internallinkfunction = strdup(value);
1944 i->config_externallinkfunction = strdup(value);
1945 } else if(!strcmp(name, "disable_polygon_conversion")) {
1946 i->config_disable_polygon_conversion = atoi(value);
1947 } else if(!strcmp(name, "normalize_polygon_positions")) {
1948 i->config_normalize_polygon_positions = atoi(value);
1949 } else if(!strcmp(name, "wxwindowparams")) {
1950 i->config_watermark = atoi(value);
1951 } else if(!strcmp(name, "insertstop")) {
1952 i->config_insertstoptag = atoi(value);
1953 } else if(!strcmp(name, "protect")) {
1954 i->config_protect = atoi(value);
1955 if(i->config_protect && i->tag) {
1956 i->tag = swf_InsertTag(i->tag, ST_PROTECT);
1958 } else if(!strcmp(name, "flashversion")) {
1959 i->config_flashversion = atoi(value);
1961 i->swf->fileVersion = i->config_flashversion;
1963 } else if(!strcmp(name, "framerate")) {
1964 i->config_framerate = atof(value);
1966 i->swf->frameRate = i->config_framerate*0x100;
1968 } else if(!strcmp(name, "minlinewidth")) {
1969 i->config_minlinewidth = atof(value);
1970 } else if(!strcmp(name, "caplinewidth")) {
1971 i->config_caplinewidth = atof(value);
1972 } else if(!strcmp(name, "linktarget")) {
1973 i->config_linktarget = strdup(value);
1974 } else if(!strcmp(name, "dumpfonts")) {
1975 i->config_dumpfonts = atoi(value);
1976 } else if(!strcmp(name, "animate")) {
1977 i->config_animate = atoi(value);
1978 } else if(!strcmp(name, "simpleviewer")) {
1979 i->config_simpleviewer = atoi(value);
1980 } else if(!strcmp(name, "next_bitmap_is_jpeg")) {
1982 } else if(!strcmp(name, "jpegquality")) {
1983 int val = atoi(value);
1985 if(val>101) val=101;
1986 i->config_jpegquality = val;
1987 } else if(!strcmp(name, "splinequality")) {
1988 int v = atoi(value);
1989 v = 500-(v*5); // 100% = 0.25 pixel, 0% = 25 pixel
1991 i->config_splinemaxerror = v;
1992 } else if(!strcmp(name, "fontquality")) {
1993 int v = atoi(value);
1994 v = 500-(v*5); // 100% = 0.25 pixel, 0% = 25 pixel
1996 i->config_fontsplinemaxerror = v;
1997 } else if(!strcmp(name, "linkcolor")) {
1998 if(strlen(value)!=8) {
1999 fprintf(stderr, "Unknown format for option 'linkcolor'. (%s <-> RRGGBBAA)\n", value);
2002 # define NIBBLE(s) (((s)>='0' && (s)<='9')?((s)-'0'):((s)&0x0f)+9)
2003 i->config_linkcolor.r = NIBBLE(value[0])<<4 | NIBBLE(value[1]);
2004 i->config_linkcolor.g = NIBBLE(value[2])<<4 | NIBBLE(value[3]);
2005 i->config_linkcolor.b = NIBBLE(value[4])<<4 | NIBBLE(value[5]);
2006 i->config_linkcolor.a = NIBBLE(value[6])<<4 | NIBBLE(value[7]);
2007 } else if(!strcmp(name, "help")) {
2008 printf("\nSWF layer options:\n");
2009 printf("jpegsubpixels=<pixels> resolution adjustment for jpeg images (same as jpegdpi, but in pixels)\n");
2010 printf("ppmsubpixels=<pixels resolution adjustment for lossless images (same as ppmdpi, but in pixels)\n");
2011 printf("subpixels=<pixels> shortcut for setting both jpegsubpixels and ppmsubpixels\n");
2012 printf("drawonlyshapes convert everything to shapes (currently broken)\n");
2013 printf("ignoredraworder allow to perform a few optimizations for creating smaller SWFs\n");
2014 printf("linksopennewwindow make links open a new browser window\n");
2015 printf("linktarget target window name of new links\n");
2016 printf("linkcolor=<color) color of links (format: RRGGBBAA)\n");
2017 printf("linknameurl Link buttons will be named like the URL they refer to (handy for iterating through links with actionscript)\n");
2018 printf("storeallcharacters don't reduce the fonts to used characters in the output file\n");
2019 printf("enablezlib switch on zlib compression (also done if flashversion>=7)\n");
2020 printf("bboxvars store the bounding box of the SWF file in actionscript variables\n");
2021 printf("reordertags=0/1 (default: 1) perform some tag optimizations\n");
2022 printf("internallinkfunction=<name> when the user clicks a internal link (to a different page) in the converted file, this actionscript function is called\n");
2023 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");
2024 printf("disable_polygon_conversion never convert strokes to polygons (will remove capstyles and joint styles)\n");
2025 printf("caplinewidth=<width> the minimum thichness a line needs to have so that capstyles become visible (and are converted)\n");
2026 printf("insertstop put an ActionScript \"STOP\" tag in every frame\n");
2027 printf("protect add a \"protect\" tag to the file, to prevent loading in the Flash editor\n");
2028 printf("flashversion=<version> the SWF fileversion (6)\n");
2029 printf("framerate=<fps> SWF framerate\n");
2030 printf("minlinewidth=<width> convert horizontal/vertical boxes smaller than this width to lines (0.05) \n");
2031 printf("simpleviewer Add next/previous buttons to the SWF\n");
2032 printf("animate insert a showframe tag after each placeobject (animate draw order of PDF files)\n");
2033 printf("jpegquality=<quality> set compression quality of jpeg images\n");
2034 printf("splinequality=<value> Set the quality of spline convertion to value (0-100, default: 100).\n");
2041 // --------------------------------------------------------------------
2043 static CXFORM gfxcxform_to_cxform(gfxcxform_t* c)
2046 swf_GetCXForm(0, &cx, 1);
2049 if(c->rg!=0 || c->rb!=0 || c->ra!=0 ||
2050 c->gr!=0 || c->gb!=0 || c->ga!=0 ||
2051 c->br!=0 || c->bg!=0 || c->ba!=0 ||
2052 c->ar!=0 || c->ag!=0 || c->ab!=0)
2053 msg("<warning> CXForm not SWF-compatible");
2055 cx.a0 = (S16)(c->aa*256);
2056 cx.r0 = (S16)(c->rr*256);
2057 cx.g0 = (S16)(c->gg*256);
2058 cx.b0 = (S16)(c->bb*256);
2067 static int imageInCache(gfxdevice_t*dev, void*data, int width, int height)
2071 static void addImageToCache(gfxdevice_t*dev, void*data, int width, int height)
2075 static int add_image(swfoutput_internal*i, gfximage_t*img, int targetwidth, int targetheight, int* newwidth, int* newheight)
2077 gfxdevice_t*dev = i->dev;
2079 RGBA*mem = (RGBA*)img->data;
2081 int sizex = img->width;
2082 int sizey = img->height;
2083 int is_jpeg = i->jpeg;
2086 int newsizex=sizex, newsizey=sizey;
2089 if(is_jpeg && i->config_jpegsubpixels) {
2090 newsizex = (int)(targetwidth*i->config_jpegsubpixels + 0.5);
2091 newsizey = (int)(targetheight*i->config_jpegsubpixels + 0.5);
2092 } else if(!is_jpeg && i->config_ppmsubpixels) {
2093 newsizex = (int)(targetwidth*i->config_ppmsubpixels + 0.5);
2094 newsizey = (int)(targetheight*i->config_ppmsubpixels + 0.5);
2098 if(sizex<=0 || sizey<=0)
2105 /* TODO: cache images */
2107 if(newsizex<sizex || newsizey<sizey) {
2108 msg("<verbose> Scaling %dx%d image to %dx%d", sizex, sizey, newsizex, newsizey);
2109 newpic = swf_ImageScale(mem, sizex, sizey, newsizex, newsizey);
2110 *newwidth = sizex = newsizex;
2111 *newheight = sizey = newsizey;
2114 *newwidth = newsizex = sizex;
2115 *newheight = newsizey = sizey;
2118 int num_colors = swf_ImageGetNumberOfPaletteEntries(mem,sizex,sizey,0);
2119 int has_alpha = swf_ImageHasAlpha(mem,sizex,sizey);
2121 msg("<verbose> Drawing %dx%d %s%simage (id %d) at size %dx%d (%dx%d), %s%d colors",
2123 has_alpha?(has_alpha==2?"semi-transparent ":"transparent "):"",
2124 is_jpeg?"jpeg-":"", i->currentswfid+1,
2126 targetwidth, targetheight,
2127 /*newsizex, newsizey,*/
2128 num_colors>256?">":"", num_colors>256?256:num_colors);
2130 /*RGBA* pal = (RGBA*)rfx_alloc(sizeof(RGBA)*num_colors);
2131 swf_ImageGetNumberOfPaletteEntries(mem,sizex,sizey,pal);
2133 for(t=0;t<num_colors;t++) {
2134 printf("%02x%02x%02x%02x ",
2135 pal[t].r, pal[t].g, pal[t].b, pal[t].a);
2142 int cacheid = imageInCache(dev, mem, sizex, sizey);
2145 bitid = getNewID(dev);
2147 i->tag = swf_AddImage(i->tag, bitid, mem, sizex, sizey, i->config_jpegquality);
2148 addImageToCache(dev, mem, sizex, sizey);
2158 static SRECT gfxline_getSWFbbox(gfxline_t*line)
2160 gfxbbox_t bbox = gfxline_getbbox(line);
2162 r.xmin = (int)(bbox.xmin*20);
2163 r.ymin = (int)(bbox.ymin*20);
2164 r.xmax = (int)(bbox.xmax*20);
2165 r.ymax = (int)(bbox.ymax*20);
2169 int line_is_empty(gfxline_t*line)
2172 if(line->type != gfx_moveTo)
2179 static void swf_fillbitmap(gfxdevice_t*dev, gfxline_t*line, gfximage_t*img, gfxmatrix_t*matrix, gfxcxform_t*cxform)
2181 swfoutput_internal*i = (swfoutput_internal*)dev->internal;
2183 if(line_is_empty(line))
2189 int targetx = (int)(sqrt(matrix->m00*matrix->m00 + matrix->m01*matrix->m01)*img->width);
2190 int targety = (int)(sqrt(matrix->m10*matrix->m10 + matrix->m11*matrix->m11)*img->height);
2192 int newwidth=0,newheight=0;
2193 int bitid = add_image(i, img, targetx, targety, &newwidth, &newheight);
2196 double fx = (double)img->width / (double)newwidth;
2197 double fy = (double)img->height / (double)newheight;
2200 m.sx = (int)(65536*20*matrix->m00*fx); m.r1 = (int)(65536*20*matrix->m10*fy);
2201 m.r0 = (int)(65536*20*matrix->m01*fx); m.sy = (int)(65536*20*matrix->m11*fy);
2202 m.tx = (int)(matrix->tx*20);
2203 m.ty = (int)(matrix->ty*20);
2206 int myshapeid = getNewID(dev);
2207 i->tag = swf_InsertTag(i->tag,ST_DEFINESHAPE);
2209 swf_ShapeNew(&shape);
2210 int fsid = swf_ShapeAddBitmapFillStyle(shape,&m,bitid,1);
2211 swf_SetU16(i->tag, myshapeid);
2212 SRECT r = gfxline_getSWFbbox(line);
2213 r = swf_ClipRect(i->pagebbox, r);
2214 swf_SetRect(i->tag,&r);
2215 swf_SetShapeStyles(i->tag,shape);
2216 swf_ShapeCountBits(shape,NULL,NULL);
2217 swf_SetShapeBits(i->tag,shape);
2218 swf_ShapeSetAll(i->tag,shape,UNDEFINED_COORD,UNDEFINED_COORD,0,fsid,0);
2219 i->swflastx = i->swflasty = UNDEFINED_COORD;
2220 drawgfxline(dev, line, 1);
2221 swf_ShapeSetEnd(i->tag);
2222 swf_ShapeFree(shape);
2224 msg("<trace> Placing image, shape ID %d, bitmap ID %d", myshapeid, bitid);
2225 i->tag = swf_InsertTag(i->tag,ST_PLACEOBJECT2);
2226 CXFORM cxform2 = gfxcxform_to_cxform(cxform);
2227 swf_ObjectPlace(i->tag,myshapeid,getNewDepth(dev),&i->page_matrix,&cxform2,NULL);
2230 static RGBA col_black = {255,0,0,0};
2232 static void drawoutline(gfxdevice_t*dev, gfxline_t*line)
2234 swfoutput_internal*i = (swfoutput_internal*)dev->internal;
2236 int myshapeid = getNewID(dev);
2237 i->tag = swf_InsertTag(i->tag,ST_DEFINESHAPE3);
2240 swf_ShapeNew(&shape);
2241 int lsid = swf_ShapeAddLineStyle(shape,1,&col_black);
2243 swf_SetU16(i->tag,myshapeid);
2244 SRECT r = gfxline_getSWFbbox(line);
2245 r = swf_ClipRect(i->pagebbox, r);
2246 swf_SetRect(i->tag,&r);
2247 swf_SetShapeStyles(i->tag,shape);
2248 swf_ShapeCountBits(shape,NULL,NULL);
2249 swf_SetShapeBits(i->tag,shape);
2250 swf_ShapeSetAll(i->tag,shape,UNDEFINED_COORD,UNDEFINED_COORD,lsid,0,0);
2251 drawgfxline(dev, line, 1);
2252 swf_ShapeSetEnd(i->tag);
2253 swf_ShapeFree(shape);
2255 i->tag = swf_InsertTag(i->tag,ST_PLACEOBJECT2);
2256 swf_ObjectPlace(i->tag, myshapeid, getNewDepth(dev), 0,0,0);
2259 static void swf_startclip(gfxdevice_t*dev, gfxline_t*line)
2261 swfoutput_internal*i = (swfoutput_internal*)dev->internal;
2266 if(i->clippos >= 127)
2268 msg("<warning> Too many clip levels.");
2272 if(i->config_showclipshapes)
2273 drawoutline(dev, line);
2275 int myshapeid = getNewID(dev);
2276 i->tag = swf_InsertTag(i->tag,ST_DEFINESHAPE3);
2278 memset(&col, 0, sizeof(RGBA));
2281 swf_ShapeNew(&shape);
2282 int fsid = swf_ShapeAddSolidFillStyle(shape,&col);
2284 RGBA markcol = {0,i->mark[0],i->mark[1],i->mark[2]};
2285 swf_ShapeAddSolidFillStyle(shape,&markcol);
2287 swf_SetU16(i->tag,myshapeid);
2288 SRECT r = gfxline_getSWFbbox(line);
2289 r = swf_ClipRect(i->pagebbox, r);
2290 swf_SetRect(i->tag,&r);
2291 swf_SetShapeStyles(i->tag,shape);
2292 swf_ShapeCountBits(shape,NULL,NULL);
2293 swf_SetShapeBits(i->tag,shape);
2294 swf_ShapeSetAll(i->tag,shape,UNDEFINED_COORD,UNDEFINED_COORD,0,fsid,0);
2295 i->swflastx = i->swflasty = UNDEFINED_COORD;
2296 i->shapeisempty = 1;
2297 drawgfxline(dev, line, 1);
2298 if(i->shapeisempty) {
2299 /* an empty clip shape is equivalent to a shape with no area */
2300 int x = line?line->x:0;
2301 int y = line?line->y:0;
2302 moveto(dev, i->tag, x,y);
2303 lineto(dev, i->tag, x,y);
2304 lineto(dev, i->tag, x,y);
2306 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)) {
2307 if(i->config_watermark) {
2308 gfxbbox_t r; r.xmin = r.ymin = 0;r.xmax = i->max_x;r.ymax = i->max_y;
2309 draw_watermark(dev, r, 1);
2312 swf_ShapeSetEnd(i->tag);
2313 swf_ShapeFree(shape);
2315 /* TODO: remember the bbox, and check all shapes against it */
2317 msg("<trace> Placing clip ID %d", myshapeid);
2318 i->tag = swf_InsertTag(i->tag,ST_PLACEOBJECT2);
2319 i->cliptags[i->clippos] = i->tag;
2320 i->clipshapes[i->clippos] = myshapeid;
2321 i->clipdepths[i->clippos] = getNewDepth(dev);
2325 static void swf_endclip(gfxdevice_t*dev)
2327 swfoutput_internal*i = (swfoutput_internal*)dev->internal;
2334 msg("<error> Invalid end of clipping region");
2338 /*swf_ObjectPlaceClip(i->cliptags[i->clippos],i->clipshapes[i->clippos],i->clipdepths[i->clippos],&i->page_matrix,NULL,NULL,
2339 / * clip to depth: * / i->depth <= i->clipdepths[i->clippos]? i->depth : i->depth - 1);
2341 swf_ObjectPlaceClip(i->cliptags[i->clippos],i->clipshapes[i->clippos],i->clipdepths[i->clippos],&i->page_matrix,NULL,NULL,i->depth);
2343 static int gfxline_type(gfxline_t*line)
2349 int haszerosegments=0;
2352 if(line->type == gfx_moveTo) {
2355 } else if(line->type == gfx_lineTo) {
2359 } else if(line->type == gfx_splineTo) {
2361 if(tmpsplines>lines)
2369 if(lines==0 && splines==0) return 0;
2370 else if(lines==1 && splines==0) return 1;
2371 else if(lines==0 && splines==1) return 2;
2372 else if(splines==0) return 3;
2376 static int gfxline_has_dots(gfxline_t*line)
2384 if(line->type == gfx_moveTo) {
2385 /* test the length of the preceding line, and assume it is a dot if
2386 it's length is less than 1.0. But *only* if there's a noticable
2387 gap between the previous line and the next moveTo. (I've come
2388 across a PDF where thousands of "dots" were stringed together,
2390 int last_short_gap = short_gap;
2391 if((fabs(line->x - x) + fabs(line->y - y)) < 1.0) {
2396 if(isline && dist < 1 && !short_gap && !last_short_gap) {
2401 } else if(line->type == gfx_lineTo) {
2402 dist += fabs(line->x - x) + fabs(line->y - y);
2404 } else if(line->type == gfx_splineTo) {
2405 dist += fabs(line->sx - x) + fabs(line->sy - y) +
2406 fabs(line->x - line->sx) + fabs(line->y - line->sy);
2413 if(isline && dist < 1 && !short_gap) {
2419 static int gfxline_fix_short_edges(gfxline_t*line)
2423 if(line->type == gfx_lineTo) {
2424 if(fabs(line->x - x) + fabs(line->y - y) < 0.01) {
2427 } else if(line->type == gfx_splineTo) {
2428 if(fabs(line->sx - x) + fabs(line->sy - y) +
2429 fabs(line->x - line->sx) + fabs(line->y - line->sy) < 0.01) {
2440 static char is_inside_page(gfxdevice_t*dev, gfxcoord_t x, gfxcoord_t y)
2442 swfoutput_internal*i = (swfoutput_internal*)dev->internal;
2443 if(x<i->min_x || x>i->max_x) return 0;
2444 if(y<i->min_y || y>i->max_y) return 0;
2448 gfxline_t* gfxline_move(gfxline_t*line, double x, double y)
2450 gfxline_t*l = line = gfxline_clone(line);
2462 //#define NORMALIZE_POLYGON_POSITIONS
2464 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)
2466 swfoutput_internal*i = (swfoutput_internal*)dev->internal;
2467 if(line_is_empty(line))
2469 int type = gfxline_type(line);
2470 int has_dots = gfxline_has_dots(line);
2471 gfxbbox_t r = gfxline_getbbox(line);
2472 int is_outside_page = !is_inside_page(dev, r.xmin, r.ymin) || !is_inside_page(dev, r.xmax, r.ymax);
2474 /* TODO: * split line into segments, and perform this check for all segments */
2476 if(i->config_disable_polygon_conversion || type>=5 ||
2478 (width <= i->config_caplinewidth
2479 || (cap_style == gfx_capRound && joint_style == gfx_joinRound)
2480 || (cap_style == gfx_capRound && type<=2)))) {} else
2482 /* convert line to polygon */
2483 msg("<trace> draw as polygon, type=%d dots=%d", type, has_dots);
2485 gfxline_fix_short_edges(line);
2486 /* we need to convert the line into a polygon */
2487 gfxpoly_t* poly = gfxpoly_strokeToPoly(line, width, cap_style, joint_style, miterLimit);
2488 gfxline_t*gfxline = gfxpoly_to_gfxline(poly);
2489 dev->fill(dev, gfxline, color);
2490 gfxline_free(gfxline);
2495 msg("<trace> draw as stroke, type=%d dots=%d", type, has_dots);
2498 if(i->config_normalize_polygon_positions) {
2500 double startx = 0, starty = 0;
2501 if(line && line->type == gfx_moveTo) {
2505 line = gfxline_move(line, -startx, -starty);
2506 i->shapeposx = (int)(startx*20);
2507 i->shapeposy = (int)(starty*20);
2510 swfoutput_setstrokecolor(dev, color->r, color->g, color->b, color->a);
2511 swfoutput_setlinewidth(dev, width);
2514 drawgfxline(dev, line, 0);
2516 if(i->config_normalize_polygon_positions) {
2517 free(line); //account for _move
2522 static void swf_fill(gfxdevice_t*dev, gfxline_t*line, gfxcolor_t*color)
2524 swfoutput_internal*i = (swfoutput_internal*)dev->internal;
2525 if(line_is_empty(line))
2529 gfxbbox_t r = gfxline_getbbox(line);
2530 int is_outside_page = !is_inside_page(dev, r.xmin, r.ymin) || !is_inside_page(dev, r.xmax, r.ymax);
2532 //if(i->chardatapos && i->chardata[i->chardatapos-1].color.a) {
2535 if(!i->config_ignoredraworder)
2538 if(i->config_normalize_polygon_positions) {
2540 double startx = 0, starty = 0;
2541 if(line && line->type == gfx_moveTo) {
2545 line = gfxline_move(line, -startx, -starty);
2546 i->shapeposx = (int)(startx*20);
2547 i->shapeposy = (int)(starty*20);
2550 swfoutput_setfillcolor(dev, color->r, color->g, color->b, color->a);
2553 drawgfxline(dev, line, 1);
2555 if(i->currentswfid==2 && r.xmin==0 && r.ymin==0 && r.xmax==i->max_x && r.ymax==i->max_y) {
2556 if(i->config_watermark) {
2557 draw_watermark(dev, r, 1);
2561 msg("<trace> end of swf_fill (shapeid=%d)", i->shapeid);
2563 if(i->config_normalize_polygon_positions) {
2564 free(line); //account for _move
2568 static GRADIENT* gfxgradient_to_GRADIENT(gfxgradient_t*gradient)
2571 gfxgradient_t*g = gradient;
2576 GRADIENT* swfgradient = malloc(sizeof(GRADIENT));
2577 swfgradient->num = num;
2578 swfgradient->rgba = malloc(sizeof(swfgradient->rgba[0])*num);
2579 swfgradient->ratios = malloc(sizeof(swfgradient->ratios[0])*num);
2584 swfgradient->ratios[num] = g->pos*255;
2585 swfgradient->rgba[num] = *(RGBA*)&g->color;
2592 static void swf_fillgradient(gfxdevice_t*dev, gfxline_t*line, gfxgradient_t*gradient, gfxgradienttype_t type, gfxmatrix_t*matrix)
2594 if(line_is_empty(line))
2596 swfoutput_internal*i = (swfoutput_internal*)dev->internal;
2598 if(line_is_empty(line))
2601 GRADIENT* swfgradient = gfxgradient_to_GRADIENT(gradient);
2608 double f = type==gfxgradient_radial?4:4;
2610 m.sx = (int)(matrix->m00*20*f); m.r1 = (int)(matrix->m10*20*f);
2611 m.r0 = (int)(matrix->m01*20*f); m.sy = (int)(matrix->m11*20*f);
2612 m.tx = (int)(matrix->tx*20);
2613 m.ty = (int)(matrix->ty*20);
2616 int myshapeid = getNewID(dev);
2617 i->tag = swf_InsertTag(i->tag, ST_DEFINESHAPE2);
2619 swf_ShapeNew(&shape);
2620 int fsid = swf_ShapeAddGradientFillStyle(shape,&m,swfgradient,type==gfxgradient_radial);
2621 swf_SetU16(i->tag, myshapeid);
2622 SRECT r = gfxline_getSWFbbox(line);
2623 r = swf_ClipRect(i->pagebbox, r);
2624 swf_SetRect(i->tag,&r);
2625 swf_SetShapeStyles(i->tag,shape);
2626 swf_ShapeCountBits(shape,NULL,NULL);
2627 swf_SetShapeBits(i->tag,shape);
2628 swf_ShapeSetAll(i->tag,shape,UNDEFINED_COORD,UNDEFINED_COORD,0,fsid,0);
2629 i->swflastx = i->swflasty = UNDEFINED_COORD;
2630 drawgfxline(dev, line, 1);
2631 swf_ShapeSetEnd(i->tag);
2632 swf_ShapeFree(shape);
2634 int depth = getNewDepth(dev);
2635 msg("<trace> Placing gradient, shape ID %d, depth %d", myshapeid, depth);
2636 i->tag = swf_InsertTag(i->tag,ST_PLACEOBJECT2);
2637 swf_ObjectPlace(i->tag,myshapeid,depth,&i->page_matrix,NULL,NULL);
2639 swf_FreeGradient(swfgradient);free(swfgradient);
2642 static SWFFONT* gfxfont_to_swffont(gfxfont_t*font, const char* id)
2644 SWFFONT*swffont = (SWFFONT*)rfx_calloc(sizeof(SWFFONT));
2646 SRECT bounds = {0,0,0,0};
2648 swffont->version = 2;
2649 swffont->name = (U8*)strdup(id);
2650 swffont->layout = (SWFLAYOUT*)rfx_calloc(sizeof(SWFLAYOUT));
2651 swffont->layout->ascent = 0;
2652 swffont->layout->descent = 0;
2653 swffont->layout->leading = 0;
2654 swffont->layout->bounds = (SRECT*)rfx_calloc(sizeof(SRECT)*font->num_glyphs);
2655 swffont->encoding = FONT_ENCODING_UNICODE;
2656 swffont->numchars = font->num_glyphs;
2657 swffont->maxascii = font->max_unicode;
2658 swffont->ascii2glyph = (int*)rfx_calloc(sizeof(int)*swffont->maxascii);
2659 swffont->glyph2ascii = (U16*)rfx_calloc(sizeof(U16)*swffont->numchars);
2660 swffont->glyph = (SWFGLYPH*)rfx_calloc(sizeof(SWFGLYPH)*swffont->numchars);
2661 swffont->glyphnames = (char**)rfx_calloc(sizeof(char*)*swffont->numchars);
2662 for(t=0;t<font->max_unicode;t++) {
2663 swffont->ascii2glyph[t] = font->unicode2glyph[t];
2665 SRECT max = {0,0,0,0};
2666 for(t=0;t<font->num_glyphs;t++) {
2670 swffont->glyph2ascii[t] = font->glyphs[t].unicode;
2671 if(swffont->glyph2ascii[t] == 0xffff || swffont->glyph2ascii[t] == 0x0000) {
2672 /* flash 8 flashtype requires unique unicode IDs for each character.
2673 We use the Unicode private user area to assign characters, hoping that
2674 the font doesn't contain more than 2048 glyphs */
2675 swffont->glyph2ascii[t] = 0xe000 + (t&0x1fff);
2678 if(font->glyphs[t].name) {
2679 swffont->glyphnames[t] = strdup(font->glyphs[t].name);
2681 swffont->glyphnames[t] = 0;
2683 advance = font->glyphs[t].advance;
2685 swf_Shape01DrawerInit(&draw, 0);
2686 line = font->glyphs[t].line;
2689 c.x = line->sx * GLYPH_SCALE; c.y = line->sy * GLYPH_SCALE;
2690 to.x = line->x * GLYPH_SCALE; to.y = line->y * GLYPH_SCALE;
2691 if(line->type == gfx_moveTo) {
2692 draw.moveTo(&draw, &to);
2693 } else if(line->type == gfx_lineTo) {
2694 draw.lineTo(&draw, &to);
2695 } else if(line->type == gfx_splineTo) {
2696 draw.splineTo(&draw, &c, &to);
2701 swffont->glyph[t].shape = swf_ShapeDrawerToShape(&draw);
2703 SRECT bbox = swf_ShapeDrawerGetBBox(&draw);
2704 swf_ExpandRect2(&max, &bbox);
2706 swffont->layout->bounds[t] = bbox;
2708 if(advance<32768.0/20) {
2709 swffont->glyph[t].advance = (int)(advance*20);
2711 //msg("<warning> Advance value overflow in glyph %d", t);
2712 swffont->glyph[t].advance = 32767;
2715 draw.dealloc(&draw);
2717 swf_ExpandRect2(&bounds, &swffont->layout->bounds[t]);
2719 for(t=0;t<font->num_glyphs;t++) {
2720 SRECT bbox = swffont->layout->bounds[t];
2722 /* if the glyph doesn't have a bounding box, use the
2723 combined bounding box (necessary e.g. for space characters) */
2724 if(!(bbox.xmin|bbox.ymin|bbox.xmax|bbox.ymax)) {
2725 swffont->layout->bounds[t] = bbox = max;
2728 /* check that the advance value is reasonable, by comparing it
2729 with the bounding box */
2730 if(bbox.xmax>0 && (bbox.xmax*10 < swffont->glyph[t].advance || !swffont->glyph[t].advance)) {
2731 if(swffont->glyph[t].advance)
2732 msg("<warning> fix bad advance value for char %d: bbox=%.2f, advance=%.2f\n", t, bbox.xmax/20.0, swffont->glyph[t].advance/20.0);
2733 swffont->glyph[t].advance = bbox.xmax;
2735 //swffont->glyph[t].advance = bbox.xmax - bbox.xmin;
2739 /* Flash player will use the advance value from the char, and the ascent/descent values
2740 from the layout for text selection.
2741 ascent will extend the char into negative y direction, from the baseline, while descent
2742 will extend in positive y direction, also from the baseline.
2743 The baseline is defined as the y-position zero
2746 swffont->layout->ascent = -bounds.ymin;
2747 if(swffont->layout->ascent < 0)
2748 swffont->layout->ascent = 0;
2749 swffont->layout->descent = bounds.ymax;
2750 if(swffont->layout->descent < 0)
2751 swffont->layout->descent = 0;
2752 swffont->layout->leading = bounds.ymax - bounds.ymin;
2754 /* if the font has proper ascent/descent values (>0) and those define
2755 greater line spacing that what we estimated from the bounding boxes,
2756 use the font's parameters */
2757 if(font->ascent*20 > swffont->layout->ascent)
2758 swffont->layout->ascent = font->ascent*20;
2759 if(font->descent*20 > swffont->layout->descent)
2760 swffont->layout->descent = font->descent*20;
2765 static void swf_addfont(gfxdevice_t*dev, gfxfont_t*font)
2767 swfoutput_internal*i = (swfoutput_internal*)dev->internal;
2769 if(i->swffont && i->swffont->name && !strcmp((char*)i->swffont->name,font->id))
2770 return; // the requested font is the current font
2772 fontlist_t*last=0,*l = i->fontlist;
2775 if(!strcmp((char*)l->swffont->name, font->id)) {
2776 return; // we already know this font
2780 l = (fontlist_t*)rfx_calloc(sizeof(fontlist_t));
2781 l->swffont = gfxfont_to_swffont(font, font->id);
2788 swf_FontSetID(l->swffont, getNewID(i->dev));
2790 if(getScreenLogLevel() >= LOGLEVEL_DEBUG) {
2792 // print font information
2793 msg("<debug> Font %s",font->id);
2794 msg("<debug> | ID: %d", l->swffont->id);
2795 msg("<debug> | Version: %d", l->swffont->version);
2796 msg("<debug> | Name: %s", l->swffont->name);
2797 msg("<debug> | Numchars: %d", l->swffont->numchars);
2798 msg("<debug> | Maxascii: %d", l->swffont->maxascii);
2799 msg("<debug> | Style: %d", l->swffont->style);
2800 msg("<debug> | Encoding: %d", l->swffont->encoding);
2801 for(iii=0; iii<l->swffont->numchars;iii++) {
2802 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,
2803 l->swffont->layout->bounds[iii].xmin/20.0,
2804 l->swffont->layout->bounds[iii].ymin/20.0,
2805 l->swffont->layout->bounds[iii].xmax/20.0,
2806 l->swffont->layout->bounds[iii].ymax/20.0
2809 for(t=0;t<l->swffont->maxascii;t++) {
2810 if(l->swffont->ascii2glyph[t] == iii)
2811 msg("<debug> | - maps to %d",t);
2817 static void swf_switchfont(gfxdevice_t*dev, const char*fontid)
2819 swfoutput_internal*i = (swfoutput_internal*)dev->internal;
2821 if(i->swffont && i->swffont->name && !strcmp((char*)i->swffont->name,fontid))
2822 return; // the requested font is the current font
2824 fontlist_t*l = i->fontlist;
2826 if(!strcmp((char*)l->swffont->name, fontid)) {
2827 i->swffont = l->swffont;
2832 msg("<error> Unknown font id: %s", fontid);
2836 static void swf_drawchar(gfxdevice_t*dev, gfxfont_t*font, int glyph, gfxcolor_t*color, gfxmatrix_t*matrix)
2838 swfoutput_internal*i = (swfoutput_internal*)dev->internal;
2840 msg("<error> swf_drawchar called (glyph %d) without font", glyph);
2843 if(!i->swffont || !i->swffont->name || strcmp((char*)i->swffont->name,font->id)) // not equal to current font
2845 /* TODO: remove the need for this (enhance getcharacterbbox so that it can cope
2846 with multiple fonts */
2848 swf_switchfont(dev, font->id); // set the current font
2851 msg("<warning> swf_drawchar: Font is NULL");
2854 if(glyph<0 || glyph>=i->swffont->numchars) {
2855 msg("<warning> No character %d in font %s (%d chars)", glyph, FIXNULL((char*)i->swffont->name), i->swffont->numchars);
2859 setfontscale(dev, matrix->m00, matrix->m01, matrix->m10, matrix->m11, matrix->tx, matrix->ty, 0);
2861 double det = i->fontmatrix.sx/65536.0 * i->fontmatrix.sy/65536.0 -
2862 i->fontmatrix.r0/65536.0 * i->fontmatrix.r1/65536.0;
2863 if(fabs(det) < 0.0005) {
2864 /* x direction equals y direction- the text is invisible */
2865 msg("<verbose> Not drawing invisible character character %d (det=%f, m=[%f %f;%f %f]\n", glyph,
2867 i->fontmatrix.sx/65536.0, i->fontmatrix.r1/65536.0,
2868 i->fontmatrix.r0/65536.0, i->fontmatrix.sy/65536.0);
2872 /*if(i->swffont->glyph[glyph].shape->bitlen <= 16) {
2873 msg("<warning> Glyph %d in current charset (%s, %d characters) is empty",
2874 glyph, FIXNULL((char*)i->swffont->name), i->swffont->numchars);
2878 /* calculate character position with respect to the current font matrix */
2879 double s = 20 * GLYPH_SCALE / det;
2880 double px = matrix->tx - i->fontmatrix.tx/20.0;
2881 double py = matrix->ty - i->fontmatrix.ty/20.0;
2882 int x = (SCOORD)(( px * i->fontmatrix.sy/65536.0 - py * i->fontmatrix.r1/65536.0)*s);
2883 int y = (SCOORD)((- px * i->fontmatrix.r0/65536.0 + py * i->fontmatrix.sx/65536.0)*s);
2884 if(x>32767 || x<-32768 || y>32767 || y<-32768) {
2885 msg("<verbose> Moving character origin to %f %f\n", matrix->tx, matrix->ty);
2887 setfontscale(dev, matrix->m00, matrix->m01, matrix->m10, matrix->m11, matrix->tx, matrix->ty, 1);
2888 /* since we just moved the char origin to the current char's position,
2889 it now has the relative position (0,0) */
2898 msg("<trace> Drawing char %d in font %d at %d,%d in color %02x%02x%02x%02x",
2899 glyph, i->swffont->id, x, y, color->r, color->g, color->b, color->a);
2901 putcharacter(dev, i->swffont->id, glyph, x, y, i->current_font_size, *(RGBA*)color);
2902 swf_FontUseGlyph(i->swffont, glyph);