#include <string.h>
#include "../../config.h"
#include <fcntl.h>
+#ifdef HAVE_UNISTD_H
#include <unistd.h>
+#endif
+#ifdef HAVE_IO_H
+#include <io.h>
+#endif
#ifdef HAVE_ASSERT_H
#include <assert.h>
#else
#define assert(a)
#endif
#include <math.h>
+#include "../mem.h"
#include "../log.h"
#include "../rfxswf.h"
#include "../gfxdevice.h"
#include "../gfxtools.h"
-#include "../art/libart.h"
+#include "swf.h"
+#include "../gfxpoly.h"
+#include "../png.h"
#define CHARDATAMAX 8192
#define CHARMIDX 0
double config_dumpfonts;
double config_ppmsubpixels;
double config_jpegsubpixels;
+ char hasbuttons;
+ int config_dots;
+ int config_simpleviewer;
int config_opennewwindow;
int config_ignoredraworder;
int config_drawonlyshapes;
+ int config_frameresets;
+ int config_linknameurl;
int config_jpegquality;
int config_storeallcharacters;
- int config_generate_fake_tags;
int config_enablezlib;
int config_insertstoptag;
+ int config_watermark;
+ int config_noclips;
int config_flashversion;
+ int config_reordertags;
+ int config_showclipshapes;
int config_splinemaxerror;
int config_fontsplinemaxerror;
int config_filloverlap;
int config_protect;
int config_bboxvars;
+ int config_disable_polygon_conversion;
+ int config_normalize_polygon_positions;
+ char config_disablelinks;
RGBA config_linkcolor;
float config_minlinewidth;
double config_caplinewidth;
char* config_linktarget;
char*config_internallinkfunction;
+ char*config_externallinkfunction;
+ char config_animate;
+ double config_framerate;
SWF* swf;
TAG *tag;
int currentswfid;
+ int startids;
int depth;
int startdepth;
int linewidth;
SHAPE* shape;
int shapeid;
int textid;
+
+ int watermarks;
int fillstyleid;
int linestyleid;
int clippos;
/* image cache */
+ /*
int pic_xids[1024];
int pic_yids[1024];
int pic_ids[1024];
int pic_width[1024];
int pic_height[1024];
int picpos;
+ */
int frameno;
int lastframeno;
int bboxrectpos;
SRECT bboxrect;
+ SRECT pagebbox;
+
chardata_t chardata[CHARDATAMAX];
int chardatapos;
int firstpage;
char overflow;
+ int current_font_size;
MATRIX fontmatrix;
- double fontm11,fontm12,fontm21,fontm22;
+ double lastfontm11,lastfontm12,lastfontm21,lastfontm22;
SWFFONT *swffont;
RGBA strokergb;
RGBA fillrgb;
int shapeposx;
int shapeposy;
+ char* mark;
+
} swfoutput_internal;
static void swf_fillbitmap(gfxdevice_t*driver, gfxline_t*line, gfximage_t*img, gfxmatrix_t*move, gfxcxform_t*cxform);
static void swf_fill(gfxdevice_t*dev, gfxline_t*line, gfxcolor_t*color);
static void swf_fillbitmap(gfxdevice_t*dev, gfxline_t*line, gfximage_t*img, gfxmatrix_t*matrix, gfxcxform_t*cxform);
static void swf_fillgradient(gfxdevice_t*dev, gfxline_t*line, gfxgradient_t*gradient, gfxgradienttype_t type, gfxmatrix_t*matrix);
-static void swf_drawchar(gfxdevice_t*dev, char*fontid, int glyph, gfxcolor_t*color, gfxmatrix_t*matrix);
-static void swf_addfont(gfxdevice_t*dev, char*fontid, gfxfont_t*font);
-static void swf_drawlink(gfxdevice_t*dev, gfxline_t*line, char*action);
+static void swf_drawchar(gfxdevice_t*dev, gfxfont_t*font, int glyph, gfxcolor_t*color, gfxmatrix_t*matrix);
+static void swf_addfont(gfxdevice_t*dev, gfxfont_t*font);
+static void swf_drawlink(gfxdevice_t*dev, gfxline_t*line, const char*action);
static void swf_startframe(gfxdevice_t*dev, int width, int height);
static void swf_endframe(gfxdevice_t*dev);
static gfxresult_t* swf_finish(gfxdevice_t*driver);
i->frameno = 0;
i->lastframeno = 0;
+ i->mark = 0;
+
i->fillstyleid;
i->linestyleid;
i->swflastx=0;
i->firstpage = 1;
i->pagefinished = 1;
+ i->config_disablelinks=0;
i->config_dumpfonts=0;
i->config_ppmsubpixels=0;
i->config_jpegsubpixels=0;
i->config_drawonlyshapes=0;
i->config_jpegquality=85;
i->config_storeallcharacters=0;
+ i->config_dots=1;
i->config_enablezlib=0;
- i->config_generate_fake_tags=0;
i->config_insertstoptag=0;
i->config_flashversion=6;
+ i->config_framerate=0.25;
i->config_splinemaxerror=1;
i->config_fontsplinemaxerror=1;
i->config_filloverlap=0;
i->config_protect=0;
i->config_bboxvars=0;
+ i->config_showclipshapes=0;
i->config_minlinewidth=0.05;
i->config_caplinewidth=1;
i->config_linktarget=0;
i->config_internallinkfunction=0;
+ i->config_externallinkfunction=0;
+ i->config_reordertags=1;
+ i->config_linknameurl=0;
i->config_linkcolor.r = i->config_linkcolor.g = i->config_linkcolor.b = 255;
i->config_linkcolor.a = 0x40;
{
swfoutput_internal*i = (swfoutput_internal*)dev->internal;
if(i->currentswfid == 65535) {
- if(!id_error)
+ if(!id_error) {
msg("<error> ID Table overflow");
+ msg("<error> This file is too complex to render- SWF only supports 65536 shapes at once");
+ }
id_error=1;
i->overflow = 1;
+ exit(1);
}
return ++i->currentswfid;
}
static U16 getNewDepth(gfxdevice_t* dev)
{
swfoutput_internal*i = (swfoutput_internal*)dev->internal;
- if(i->depth == 65535) {
- if(!id_error)
+ if(i->depth == 65520) {
+ if(!id_error) {
msg("<error> Depth Table overflow");
+ msg("<error> This file is too complex to render- SWF only supports 65536 shapes at once");
+ }
id_error=1;
i->overflow = 1;
+ exit(1);
}
return ++i->depth;
}
double x,y;
} plotxy_t;
+static inline int twipsnap(double f)
+{
+ /* if(f < -0x40000000/20.0) {
+ fprintf(stderr, "Warning: Coordinate underflow (%f)\n", f);
+ f = -0x40000000/20.0;
+ } else if(f>0x3fffffff/20.0) {
+ fprintf(stderr, "Warning: Coordinate overflow (%f)\n", f);
+ f = 0x3fffffff/20.0;
+ }*/
+
+ /* clamp coordinates to a rectangle with the property that we
+ can represent a line from the upper left corner to the upper
+ right corner using no more than 64 strokes */
+ const double min = -(1<<(18+4))/20.0;
+ const double max = ((1<<(18+4))-1)/20.0;
+ if(f < min) {
+ fprintf(stderr, "Warning: Coordinate underflow (%f)\n", f);
+ f = min;
+ } else if(f>max) {
+ fprintf(stderr, "Warning: Coordinate overflow (%f)\n", f);
+ f = max;
+ }
+
+ return (int)(f*20);
+}
+
// write a move-to command into the swf
static int movetoxy(gfxdevice_t*dev, TAG*tag, plotxy_t p0)
{
swfoutput_internal*i = (swfoutput_internal*)dev->internal;
- int rx = (int)(p0.x*20);
- int ry = (int)(p0.y*20);
+ int rx = twipsnap(p0.x);
+ int ry = twipsnap(p0.y);
if(rx!=i->swflastx || ry!=i->swflasty || i->fillstylechanged) {
swf_ShapeSetMove (tag, i->shape, rx,ry);
i->fillstylechanged = 0;
static void linetoxy(gfxdevice_t*dev, TAG*tag, plotxy_t p0)
{
swfoutput_internal*i = (swfoutput_internal*)dev->internal;
- int px = (int)(p0.x*20);
- int py = (int)(p0.y*20);
+ int px = twipsnap(p0.x);
+ int py = twipsnap(p0.y);
int rx = (px-i->swflastx);
int ry = (py-i->swflasty);
if(rx|ry) {
swf_ShapeSetLine (tag, i->shape, rx,ry);
addPointToBBox(dev, i->swflastx,i->swflasty);
addPointToBBox(dev, px,py);
- }/* else if(!i->fill) {
+ } /* this is a nice idea, but doesn't work with current flash
+ players (the pixel will be invisible if they're not
+ precisely on a pixel boundary)
+ Besides, we should only do this if this lineto itself
+ is again followed by a "move".
+ else if(!i->fill && i->config_dots) {
// treat lines of length 0 as plots, making them
// at least 1 twip wide so Flash will display them
- plot(dev, i->swflastx, i->swflasty, tag);
+ //plot(dev, i->swflastx, i->swflasty, tag);
+ swf_ShapeSetLine (tag, i->shape, rx+1,ry);
}*/
i->shapeisempty = 0;
int lastlastx = i->swflastx;
int lastlasty = i->swflasty;
- int cx = ((int)(control.x*20)-i->swflastx);
- int cy = ((int)(control.y*20)-i->swflasty);
+ int cx = (twipsnap(control.x)-i->swflastx);
+ int cy = (twipsnap(control.y)-i->swflasty);
i->swflastx += cx;
i->swflasty += cy;
- int ex = ((int)(end.x*20)-i->swflastx);
- int ey = ((int)(end.y*20)-i->swflasty);
+ int ex = (twipsnap(end.x)-i->swflastx);
+ int ey = (twipsnap(end.y)-i->swflasty);
i->swflastx += ex;
i->swflasty += ey;
- if(cx || cy || ex || ey) {
- swf_ShapeSetCurve(tag, i->shape, cx,cy,ex,ey);
- addPointToBBox(dev, lastlastx ,lastlasty );
- addPointToBBox(dev, lastlastx+cx,lastlasty+cy);
- addPointToBBox(dev, lastlastx+cx+ex,lastlasty+cy+ey);
- }/* else if(!i->fill) {
- // treat splines of length 0 as plots
- plot(dev, lastlastx, lastlasty, tag);
- }*/
+ if((cx || cy) && (ex || ey)) {
+ swf_ShapeSetCurve(tag, i->shape, cx,cy,ex,ey);
+ addPointToBBox(dev, lastlastx ,lastlasty );
+ addPointToBBox(dev, lastlastx+cx,lastlasty+cy);
+ addPointToBBox(dev, lastlastx+cx+ex,lastlasty+cy+ey);
+ } else if(cx || cy || ex || ey) {
+ swf_ShapeSetLine(tag, i->shape, cx+ex,cy+ey);
+ addPointToBBox(dev, lastlastx ,lastlasty );
+ addPointToBBox(dev, lastlastx+cx,lastlasty+cy);
+ addPointToBBox(dev, lastlastx+cx+ex,lastlasty+cy+ey);
+ }
+
i->shapeisempty = 0;
}
static void stopFill(gfxdevice_t*dev)
{
swfoutput_internal*i = (swfoutput_internal*)dev->internal;
- if(i->lastwasfill)
+ if(i->lastwasfill!=0)
{
swf_ShapeSetStyle(i->tag,i->shape,i->linestyleid,0x8000,0);
i->fillstylechanged = 1;
static void startFill(gfxdevice_t*dev)
{
swfoutput_internal*i = (swfoutput_internal*)dev->internal;
- if(!i->lastwasfill)
+ if(i->lastwasfill!=1)
{
swf_ShapeSetStyle(i->tag,i->shape,0x8000,i->fillstyleid,0);
i->fillstylechanged = 1;
/* Notice: we can only put chars in the range -1639,1638 (-32768/20,32768/20).
So if we set this value to high, the char coordinates will overflow.
If we set it to low, however, the char positions will be inaccurate */
-#define FONT_INTERNAL_SIZE 4
-
-/* process a character. */
-static int drawchar(gfxdevice_t*dev, SWFFONT *swffont, int charid, swfmatrix_t*m, gfxcolor_t*col)
-{
- swfoutput_internal*i = (swfoutput_internal*)dev->internal;
- if(!swffont) {
- msg("<warning> Font is NULL");
- return 0;
- }
-
- if(charid<0 || charid>=swffont->numchars) {
- msg("<warning> No character %d in font %s ", charid, FIXNULL((char*)swffont->name));
- return 0;
- }
- /*if(swffont->glyph[charid].shape->bitlen <= 16) {
- msg("<warning> Glyph %d in current charset (%s, %d characters) is empty",
- charid, FIXNULL((char*)swffont->name), swffont->numchars);
- return 1;
- }*/
-
- if(i->shapeid>=0)
- endshape(dev);
- if(i->textid<0)
- starttext(dev);
-
- float x = m->m31;
- float y = m->m32;
- float det = ((m->m11*m->m22)-(m->m21*m->m12));
- if(fabs(det) < 0.0005) {
- /* x direction equals y direction- the text is invisible */
- return 1;
- }
- det = 20*FONT_INTERNAL_SIZE / det;
-
- SPOINT p;
- p.x = (SCOORD)(( x * m->m22 - y * m->m12)*det);
- p.y = (SCOORD)((- x * m->m21 + y * m->m11)*det);
-
- RGBA rgba = *(RGBA*)col;
- putcharacter(dev, swffont->id, charid,p.x,p.y,FONT_INTERNAL_SIZE, rgba);
- swf_FontUseGlyph(swffont, charid);
- return 1;
-}
+#define GLYPH_SCALE 1
static void endtext(gfxdevice_t*dev)
{
if(i->textid<0)
return;
- i->tag = swf_InsertTag(i->tag,ST_DEFINETEXT);
+ i->tag = swf_InsertTag(i->tag,ST_DEFINETEXT2);
swf_SetU16(i->tag, i->textid);
SRECT r;
r = getcharacterbbox(dev, i->swffont, &i->fontmatrix);
-
+ r = swf_ClipRect(i->pagebbox, r);
swf_SetRect(i->tag,&r);
swf_SetMatrix(i->tag,&i->fontmatrix);
putcharacters(dev, i->tag);
swf_SetU8(i->tag,0);
- i->tag = swf_InsertTag(i->tag,ST_PLACEOBJECT2);
+ if(i->swf->fileVersion >= 8) {
+ i->tag = swf_InsertTag(i->tag, ST_CSMTEXTSETTINGS);
+ swf_SetU16(i->tag, i->textid);
+
+ //swf_SetU8(i->tag, /*subpixel grid*/(2<<3)|/*flashtype*/0x40);
+ swf_SetU8(i->tag, /*grid*/(1<<3)|/*flashtype*/0x40);
+ //swf_SetU8(i->tag, /*no grid*/(0<<3)|/*flashtype*/0x40);
+
+ swf_SetU32(i->tag, 0);//thickness
+ swf_SetU32(i->tag, 0);//sharpness
+ swf_SetU8(i->tag, 0);//reserved
+ }
+ i->tag = swf_InsertTag(i->tag,ST_PLACEOBJECT2);
+
swf_ObjectPlace(i->tag,i->textid,getNewDepth(dev),&i->page_matrix,NULL,NULL);
i->textid = -1;
}
/* set's the matrix which is to be applied to characters drawn by swfoutput_drawchar() */
-static void swfoutput_setfontmatrix(gfxdevice_t*dev,double m11,double m21,
- double m12,double m22)
+static void setfontscale(gfxdevice_t*dev,double m11,double m12, double m21,double m22,double x, double y, char force)
{
m11 *= 1024;
m12 *= 1024;
m21 *= 1024;
m22 *= 1024;
swfoutput_internal*i = (swfoutput_internal*)dev->internal;
- if(i->fontm11 == m11 &&
- i->fontm12 == m12 &&
- i->fontm21 == m21 &&
- i->fontm22 == m22)
+ if(i->lastfontm11 == m11 &&
+ i->lastfontm12 == m12 &&
+ i->lastfontm21 == m21 &&
+ i->lastfontm22 == m22 && !force)
return;
if(i->textid>=0)
endtext(dev);
- i->fontm11 = m11;
- i->fontm12 = m12;
- i->fontm21 = m21;
- i->fontm22 = m22;
+ i->lastfontm11 = m11;
+ i->lastfontm12 = m12;
+ i->lastfontm21 = m21;
+ i->lastfontm22 = m22;
+
+ double xsize = sqrt(m11*m11 + m12*m12);
+ double ysize = sqrt(m21*m21 + m22*m22);
+ i->current_font_size = (xsize>ysize?xsize:ysize)*1;
+ if(i->current_font_size < 1)
+ i->current_font_size = 1;
+ double ifs = 1.0 / (i->current_font_size*GLYPH_SCALE);
+
MATRIX m;
- m.sx = (U32)(((i->fontm11)*65536)/FONT_INTERNAL_SIZE); m.r1 = (U32)(((i->fontm12)*65536)/FONT_INTERNAL_SIZE);
- m.r0 = (U32)(((i->fontm21)*65536)/FONT_INTERNAL_SIZE); m.sy = (U32)(((i->fontm22)*65536)/FONT_INTERNAL_SIZE);
- m.tx = 0;
- m.ty = 0;
+ m.sx = (S32)((m11*ifs)*65536); m.r1 = (S32)((m21*ifs)*65536);
+ m.r0 = (S32)((m12*ifs)*65536); m.sy = (S32)((m22*ifs)*65536);
+ /* this is the position of the first char to set a new fontmatrix-
+ we hope that it's close enough to all other characters using the
+ font, so we use its position as origin for the matrix */
+ m.tx = x*20;
+ m.ty = y*20;
i->fontmatrix = m;
}
+static int watermark2_width=47;
+static int watermark2_height=11;
+static int watermark2[47] = {95,1989,71,0,2015,337,1678,0,2015,5,1921,320,1938,25,2006,1024,
+ 1042,21,13,960,1039,976,8,2000,1359,1088,31,1989,321,1728,0,1152,
+ 1344,832,0,1984,0,896,1088,1088,896,0,1984,128,256,512,1984};
+
+static void draw_watermark(gfxdevice_t*dev, gfxbbox_t r, char drawall)
+{
+ swfoutput_internal*i = (swfoutput_internal*)dev->internal;
+ double wx = r.xmax / 5.0;
+ double tx = r.xmax*4.0 / 5.0;
+ double ty = r.ymax-wx*watermark2_height/watermark2_width;
+ double sx = (r.xmax - tx) / watermark2_width;
+ double sy = (r.ymax - ty) / watermark2_height;
+ double px = sx-0.5;
+ double py = sy-0.5;
+ if(ty > 0 && px > 1.0 && py > 1.0) {
+ int x,y;
+ for(y=0;y<watermark2_height;y++)
+ for(x=0;x<watermark2_width;x++) {
+ if(((watermark2[x]>>y)&1)) {
+ if(!drawall && rand()%5)
+ continue;
+ unsigned int b = rand();
+ moveto(dev, i->tag, x*sx+tx+((b>>1)&1)/20.0, y*sy+ty+((b>>3)&1)/20.0);
+ lineto(dev, i->tag, x*sx+px+tx+((b>>2)&1)/20.0, y*sy+ty+((b>>3)&1)/20.0);
+ lineto(dev, i->tag, x*sx+px+tx+((b>>2)&1)/20.0, y*sy+py+ty+((b>>4)&1)/20.0);
+ lineto(dev, i->tag, x*sx+tx+((b>>1)&1)/20.0, y*sy+py+ty+((b>>4)&1)/20.0);
+ lineto(dev, i->tag, x*sx+tx+((b>>1)&1)/20.0, y*sy+ty+((b>>3)&1)/20.0);
+ }
+ }
+ }
+}
+
+static void swfoutput_setfillcolor(gfxdevice_t* dev, U8 r, U8 g, U8 b, U8 a)
+{
+ swfoutput_internal*i = (swfoutput_internal*)dev->internal;
+ if(i->fillrgb.r == r &&
+ i->fillrgb.g == g &&
+ i->fillrgb.b == b &&
+ i->fillrgb.a == a) return;
+ if(i->shapeid>=0)
+ endshape(dev);
+
+ i->fillrgb.r = r;
+ i->fillrgb.g = g;
+ i->fillrgb.b = b;
+ i->fillrgb.a = a;
+}
+static void insert_watermark(gfxdevice_t*dev, char drawall)
+{
+ swfoutput_internal*i = (swfoutput_internal*)dev->internal;
+ if(!drawall && i->watermarks>20)
+ return;
+ endshape(dev);
+ endtext(dev);
+
+ if(drawall) {
+ swfoutput_setfillcolor(dev, 0,0,255,192);
+ } else {
+ swfoutput_setfillcolor(dev, rand(),rand(),rand(),(rand()&127)+128);
+ }
+ startshape(dev);
+ startFill(dev);
+
+ gfxbbox_t r; r.xmin = r.ymin = 0;
+ r.xmax = i->max_x;
+ r.ymax = i->max_y;
+ draw_watermark(dev, r, drawall);
+ endshape(dev);
+ i->watermarks++;
+}
+
+
static void endpage(gfxdevice_t*dev)
{
swfoutput_internal*i = (swfoutput_internal*)dev->internal;
+ if(i->pagefinished)
+ return;
if(i->shapeid>=0)
endshape(dev);
if(i->textid>=0)
endtext(dev);
+
while(i->clippos)
dev->endclip(dev);
+
+ if(i->config_watermark) {
+ insert_watermark(dev, 1);
+ }
+
i->pagefinished = 1;
}
+static void addViewer(gfxdevice_t* dev)
+{
+ swfoutput_internal*i = (swfoutput_internal*)dev->internal;
+
+ SHAPE*s;
+ RGBA button_colors[3]= {{0xbf,0x00,0x00,0x80},{0xbf,0x20,0x20,0xc0}, {0xbf,0xc0,0xc0,0xff}};
+ int ids[6];
+ int button_sizex = 20;
+ int button_sizey = 20;
+ int t;
+ RGBA black = {255,0,0,0};
+ for(t=0;t<6;t++) {
+ i->tag = swf_InsertTag(i->tag,ST_DEFINESHAPE3);
+ swf_ShapeNew(&s);
+ int ls1 = swf_ShapeAddLineStyle(s,40,&black);
+ int fs1 = swf_ShapeAddSolidFillStyle(s,&button_colors[t/2]);
+ int shapeid = ids[t] = getNewID(dev);
+ swf_SetU16(i->tag,shapeid);
+ SRECT r;
+ r.xmin = -20*button_sizex;
+ r.xmax = 20*button_sizex;
+ r.ymin = 0;
+ r.ymax = 40*button_sizey;
+ swf_SetRect(i->tag,&r); // set shape bounds
+ swf_SetShapeHeader(i->tag,s); // write all styles to tag
+ swf_ShapeSetAll(i->tag,s,0*button_sizex,0,ls1,fs1,0);
+ swf_ShapeSetLine(i->tag,s,(1-(t&1)*2)*20*button_sizex,20*button_sizey);
+ swf_ShapeSetLine(i->tag,s,-(1-(t&1)*2)*20*button_sizex,20*button_sizey);
+ swf_ShapeSetLine(i->tag,s,0,-40*button_sizey);
+ swf_ShapeSetEnd(i->tag); // finish drawing
+ swf_ShapeFree(s); // clean shape structure (which isn't needed anymore after writing the tag)
+ }
+ ActionTAG*a1=0,*a2=0,*a3=0;
+ a1 = action_NextFrame(a1);
+ a1 = action_Stop(a1);
+ a1 = action_End(a1);
+
+ a2 = action_PreviousFrame(a2);
+ a2 = action_Stop(a2);
+ a2 = action_End(a2);
+
+ a3 = action_Stop(a3);
+ a3 = action_End(a3);
+
+ i->tag = swf_InsertTag(i->tag, ST_DOACTION);
+ swf_ActionSet(i->tag,a3);
+
+ i->tag = swf_InsertTag(i->tag,ST_DEFINEBUTTON);
+ int buttonid1 = getNewID(dev);
+ swf_SetU16(i->tag, buttonid1);
+ swf_ButtonSetRecord(i->tag,BS_UP|BS_HIT,ids[0],1,NULL,NULL);
+ swf_ButtonSetRecord(i->tag,BS_OVER,ids[2],1,NULL,NULL);
+ swf_ButtonSetRecord(i->tag,BS_DOWN,ids[4],1,NULL,NULL);
+ swf_SetU8(i->tag,0); // end of button records
+ swf_ActionSet(i->tag,a1);
+
+ i->tag = swf_InsertTag(i->tag,ST_DEFINEBUTTON);
+ int buttonid2 = getNewID(dev);
+ swf_SetU16(i->tag, buttonid2);
+ swf_ButtonSetRecord(i->tag,BS_UP|BS_HIT,ids[1],1,NULL,NULL);
+ swf_ButtonSetRecord(i->tag,BS_OVER,ids[3],1,NULL,NULL);
+ swf_ButtonSetRecord(i->tag,BS_DOWN,ids[5],1,NULL,NULL);
+ swf_SetU8(i->tag,0); // end of button records
+ swf_ActionSet(i->tag,a2);
+
+ i->tag = swf_InsertTag(i->tag,ST_PLACEOBJECT2);
+ MATRIX m;
+ swf_GetMatrix(0, &m);
+ m.tx = button_sizex*20+200;
+ swf_ObjectPlace(i->tag, buttonid2, 65534,&m,0,0);
+ i->tag = swf_InsertTag(i->tag,ST_PLACEOBJECT2);
+ m.tx = button_sizex*20+200+200;
+ swf_ObjectPlace(i->tag, buttonid1, 65535,&m,0,0);
+}
+
+
void swf_startframe(gfxdevice_t*dev, int width, int height)
{
swfoutput_internal*i = (swfoutput_internal*)dev->internal;
+ if(i->firstpage) {
+ if(i->config_protect) {
+ i->tag = swf_InsertTag(i->tag, ST_PROTECT);
+ i->config_protect = 0;
+ }
+ if(i->config_simpleviewer) {
+ addViewer(dev);
+ }
+ }
+
if(!i->firstpage && !i->pagefinished)
endpage(dev);
+
msg("<verbose> Starting new SWF page of size %dx%d", width, height);
swf_GetMatrix(0, &i->page_matrix);
i->min_y = 0;
i->max_x = width;
i->max_y = height;
+ i->watermarks = 0;
- /* set clipping/background rectangle */
- /* TODO: this should all be done in SWFOutputDev */
- //setBackground(dev, x1, y1, x2, y2);
+ /* create a bbox structure with the page size. This is used
+ for clipping shape and text bounding boxes. As we don't want to
+ generate bounding boxes which extend beyond the movie size (in
+ order to not confuse Flash), we clip everything against i->pagebbox */
+ i->pagebbox.xmin = 0;
+ i->pagebbox.ymin = 0;
+ i->pagebbox.xmax = width*20;
+ i->pagebbox.ymax = height*20;
/* increase SWF's bounding box */
- SRECT r;
- r.xmin = 0;
- r.ymin = 0;
- r.xmax = width*20;
- r.ymax = height*20;
- swf_ExpandRect2(&i->swf->movieSize, &r);
+ swf_ExpandRect2(&i->swf->movieSize, &i->pagebbox);
i->lastframeno = i->frameno;
i->firstpage = 0;
if(!i->pagefinished)
endpage(dev);
- if(i->config_insertstoptag) {
+ if( (i->swf->fileVersion <= 8) && (i->config_insertstoptag) ) {
ActionTAG*atag=0;
atag = action_Stop(atag);
atag = action_End(atag);
swf_SetU16(i->tag,i->depth);
}
i->depth = i->startdepth;
+
+ if(i->config_frameresets) {
+ for(i->currentswfid;i->currentswfid>i->startids;i->currentswfid--) {
+ i->tag = swf_InsertTag(i->tag,ST_FREECHARACTER);
+ swf_SetU16(i->tag,i->currentswfid);
+ }
+ i->currentswfid = i->startids;
+ }
}
static void setBackground(gfxdevice_t*dev, int x1, int y1, int x2, int y2)
void gfxdevice_swf_init(gfxdevice_t* dev)
{
memset(dev, 0, sizeof(gfxdevice_t));
- dev->internal = init_internal_struct();
+
+ dev->name = "swf";
+
+ dev->internal = init_internal_struct(); // set config to default values
dev->startpage = swf_startframe;
dev->endpage = swf_endframe;
swfoutput_internal*i = (swfoutput_internal*)dev->internal;
i->dev = dev;
- SRECT r;
- RGBA rgb;
-
msg("<verbose> initializing swf output\n", i->max_x,i->max_y);
i->swffont = 0;
i->swf = (SWF*)rfx_calloc(sizeof(SWF));
- i->swf->fileVersion = i->config_flashversion;
- i->swf->frameRate = 0x0040; // 1 frame per 4 seconds
+ i->swf->fileVersion = 0;
+ i->swf->frameRate = 0x80;
i->swf->movieSize.xmin = 0;
i->swf->movieSize.ymin = 0;
i->swf->movieSize.xmax = 0;
i->swf->movieSize.ymax = 0;
+ i->swf->fileAttributes = 9; // as3, local-with-network
i->swf->firstTag = swf_InsertTag(NULL,ST_SETBACKGROUNDCOLOR);
i->tag = i->swf->firstTag;
+ RGBA rgb;
rgb.a = rgb.r = rgb.g = rgb.b = 0xff;
+ //rgb.r = 0;
swf_SetRGB(i->tag,&rgb);
i->startdepth = i->depth = 0;
-
- if(i->config_protect)
- i->tag = swf_InsertTag(i->tag, ST_PROTECT);
+ i->startids = i->currentswfid = 0;
}
static void startshape(gfxdevice_t*dev)
if(i->shapeid>=0)
return;
+ //if(i->chardatapos && i->chardata[i->chardatapos-1].color.a)
+ endtext(dev);
- if(i->textid>=0)
- endtext(dev);
-
- i->tag = swf_InsertTag(i->tag,ST_DEFINESHAPE);
+ i->tag = swf_InsertTag(i->tag,ST_DEFINESHAPE3);
swf_ShapeNew(&i->shape);
i->linestyleid = swf_ShapeAddLineStyle(i->shape,i->linewidth,&i->strokergb);
i->fillstyleid = swf_ShapeAddSolidFillStyle(i->shape,&i->fillrgb);
+ if(i->mark) {
+ RGBA markcol = {0,i->mark[0],i->mark[1],i->mark[2]};
+ swf_ShapeAddSolidFillStyle(i->shape,&markcol);
+ }
i->shapeid = getNewID(dev);
i->bboxrectpos = i->tag->len;
/* changed later */
- r.xmin = 0;
- r.ymin = 0;
- r.xmax = 20*i->max_x;
- r.ymax = 20*i->max_y;
- swf_SetRect(i->tag,&r);
+ swf_SetRect(i->tag,&i->pagebbox);
memset(&i->bboxrect, 0, sizeof(i->bboxrect));
swf_SetShapeBits(i->tag,i->shape);
/* TODO: do we really need this? */
- swf_ShapeSetAll(i->tag,i->shape,/*x*/0,/*y*/0,i->linestyleid,0,0);
- i->swflastx=i->swflasty=0;
- i->lastwasfill = 0;
+ //swf_ShapeSetAll(i->tag,i->shape,/*x*/0,/*y*/0,i->linestyleid,0,0);
+ //swf_ShapeSetAll(i->tag,i->shape,/*x*/UNDEFINED_COORD,/*y*/UNDEFINED_COORD,i->linestyleid,0,0);
+ i->swflastx=i->swflasty=UNDEFINED_COORD;
+ i->lastwasfill = -1;
i->shapeisempty = 1;
}
swfoutput_internal*i = (swfoutput_internal*)dev->internal;
if(i->shapeid>=0)
endshape(dev);
-
- i->textid = getNewID(dev);
+ if(i->config_watermark) {
+ insert_watermark(dev, 0);
+ }
+ i->textid = getNewID(dev);
i->swflastx=i->swflasty=0;
}
/* delete old shape tag */
TAG*todel = i->tag;
i->tag = i->tag->prev;
- swf_DeleteTag(todel);
+ swf_DeleteTag(0, todel);
if(i->shape) {swf_ShapeFree(i->shape);i->shape=0;}
i->shapeid = -1;
i->bboxrectpos = -1;
+
+// i->currentswfid--; // doesn't work, for some reason
}
void fixAreas(gfxdevice_t*dev)
if(i->linewidth==0) i->linewidth = 1;
startshape(dev);
+ stopFill(dev);
moveto(dev, i->tag, r.xmin/20.0,r.ymin/20.0);
lineto(dev, i->tag, r.xmax/20.0,r.ymax/20.0);
swf_ShapeSetEnd(i->tag);
- changeRect(dev, i->tag, i->bboxrectpos, &i->bboxrect);
+ SRECT r = swf_ClipRect(i->pagebbox, i->bboxrect);
+ changeRect(dev, i->tag, i->bboxrectpos, &r);
- msg("<trace> Placing shape id %d", i->shapeid);
+ msg("<trace> Placing shape ID %d", i->shapeid);
i->tag = swf_InsertTag(i->tag,ST_PLACEOBJECT2);
MATRIX m = i->page_matrix;
m.ty += i->shapeposy;
swf_ObjectPlace(i->tag,i->shapeid,getNewDepth(dev),&m,NULL,NULL);
+ if(i->config_animate) {
+ i->tag = swf_InsertTag(i->tag,ST_SHOWFRAME);
+ }
+
swf_ShapeFree(i->shape);
i->shape = 0;
i->shapeid = -1;
tag->id != ST_END &&
tag->id != ST_DOACTION &&
tag->id != ST_SHOWFRAME) {
- swf_DeleteTag(tag);
+ swf_DeleteTag(swf, tag);
}
tag = next;
}
}
-
void swfoutput_finalize(gfxdevice_t*dev)
{
swfoutput_internal*i = (swfoutput_internal*)dev->internal;
if(i->tag && i->tag->id == ST_END)
return; //already done
+ i->swf->fileVersion = i->config_flashversion;
+ i->swf->frameRate = i->config_framerate*0x100;
+
if(i->config_bboxvars) {
TAG* tag = swf_InsertTag(i->swf->firstTag, ST_DOACTION);
ActionTAG*a = 0;
swf_ActionFree(a);
}
- if(i->frameno == i->lastframeno) // fix: add missing pagefeed
- dev->endpage(dev);
+ if(i->mark) {
+ free(i->mark);i->mark = 0;
+ }
endpage(dev);
- fontlist_t *tmp,*iterator = i->fontlist;
+ fontlist_t *iterator = i->fontlist;
while(iterator) {
TAG*mtag = i->swf->firstTag;
if(iterator->swffont) {
- mtag = swf_InsertTag(mtag, ST_DEFINEFONT2);
if(!i->config_storeallcharacters) {
msg("<debug> Reducing font %s", iterator->swffont->name);
swf_FontReduce(iterator->swffont);
}
- swf_FontSetDefine2(mtag, iterator->swffont);
+ int used = iterator->swffont->use && iterator->swffont->use->used_glyphs;
+ if(used) {
+ mtag = swf_InsertTag(mtag, ST_DEFINEFONT2);
+ swf_FontSetDefine2(mtag, iterator->swffont);
+ }
}
iterator = iterator->next;
}
+
i->tag = swf_InsertTag(i->tag,ST_END);
TAG* tag = i->tag->prev;
and the ST_END- they confuse the flash player */
while(tag->id == ST_REMOVEOBJECT2) {
TAG* prev = tag->prev;
- swf_DeleteTag(tag);
+ swf_DeleteTag(i->swf, tag);
tag = prev;
}
if(i->config_enablezlib || i->config_flashversion>=6) {
i->swf->compressed = 1;
}
+
+ /* Add AVM2 actionscript */
+ if(i->config_flashversion>=9 &&
+ (i->config_insertstoptag || i->hasbuttons)) {
+ swf_AddButtonLinks(i->swf, i->config_insertstoptag,
+ i->config_internallinkfunction||i->config_externallinkfunction);
+ }
+// if(i->config_reordertags)
+// swf_Optimize(i->swf);
}
-int swfresult_save(gfxresult_t*gfx, char*filename)
+int swfresult_save(gfxresult_t*gfx, const char*filename)
{
SWF*swf = (SWF*)gfx->internal;
int fi;
return -1;
}
- if(swf->compressed) {
- if FAILED(swf_WriteSWC(fi,swf))
- msg("<error> WriteSWC() failed.\n");
- } else {
- if FAILED(swf_WriteSWF(fi,swf))
- msg("<error> WriteSWF() failed.\n");
- }
+ if FAILED(swf_WriteSWF(fi,swf))
+ msg("<error> WriteSWF() failed.\n");
if(filename)
close(fi);
return 0;
}
-void* swfresult_get(gfxresult_t*gfx, char*name)
+void* swfresult_get(gfxresult_t*gfx, const char*name)
{
SWF*swf = (SWF*)gfx->internal;
if(!strcmp(name, "swf")) {
return (void*)swf_CopySWF(swf);
} else if(!strcmp(name, "xmin")) {
- return (void*)(swf->movieSize.xmin/20);
+ return (void*)(ptroff_t)(swf->movieSize.xmin/20);
} else if(!strcmp(name, "ymin")) {
- return (void*)(swf->movieSize.ymin/20);
+ return (void*)(ptroff_t)(swf->movieSize.ymin/20);
} else if(!strcmp(name, "xmax")) {
- return (void*)(swf->movieSize.xmax/20);
+ return (void*)(ptroff_t)(swf->movieSize.xmax/20);
} else if(!strcmp(name, "ymax")) {
- return (void*)(swf->movieSize.ymax/20);
+ return (void*)(ptroff_t)(swf->movieSize.ymax/20);
} else if(!strcmp(name, "width")) {
- return (void*)((swf->movieSize.xmax - swf->movieSize.xmin)/20);
+ return (void*)(ptroff_t)((swf->movieSize.xmax - swf->movieSize.xmin)/20);
} else if(!strcmp(name, "height")) {
- return (void*)((swf->movieSize.ymax - swf->movieSize.ymin)/20);
+ return (void*)(ptroff_t)((swf->movieSize.ymax - swf->movieSize.ymin)/20);
}
return 0;
}
memset(dev, 0, sizeof(gfxdevice_t));
}
-static void swfoutput_setfillcolor(gfxdevice_t* dev, U8 r, U8 g, U8 b, U8 a)
-{
- swfoutput_internal*i = (swfoutput_internal*)dev->internal;
- if(i->fillrgb.r == r &&
- i->fillrgb.g == g &&
- i->fillrgb.b == b &&
- i->fillrgb.a == a) return;
- if(i->shapeid>=0)
- endshape(dev);
-
- i->fillrgb.r = r;
- i->fillrgb.g = g;
- i->fillrgb.b = b;
- i->fillrgb.a = a;
-}
-
static void swfoutput_setstrokecolor(gfxdevice_t* dev, U8 r, U8 g, U8 b, U8 a)
{
swfoutput_internal*i = (swfoutput_internal*)dev->internal;
}
-static void drawlink(gfxdevice_t*dev, ActionTAG*,ActionTAG*, gfxline_t*points, char mouseover);
+static void drawlink(gfxdevice_t*dev, ActionTAG*,ActionTAG*, gfxline_t*points, char mouseover, const char*url);
static void swfoutput_namedlink(gfxdevice_t*dev, char*name, gfxline_t*points);
static void swfoutput_linktopage(gfxdevice_t*dev, int page, gfxline_t*points);
-static void swfoutput_linktourl(gfxdevice_t*dev, char*url, gfxline_t*points);
+static void swfoutput_linktourl(gfxdevice_t*dev, const char*url, gfxline_t*points);
-void swfoutput_drawlink(gfxdevice_t*dev, char*url, gfxline_t*points)
+/*void swfoutput_drawlink(gfxdevice_t*dev, char*url, gfxline_t*points)
{
swfoutput_internal*i = (swfoutput_internal*)dev->internal;
dev->drawlink(dev, points, url);
-}
+}*/
-void swf_drawlink(gfxdevice_t*dev, gfxline_t*points, char*url)
+void swf_drawlink(gfxdevice_t*dev, gfxline_t*points, const char*url)
{
swfoutput_internal*i = (swfoutput_internal*)dev->internal;
+ if(i->config_disablelinks)
+ return;
+
if(!strncmp("http://pdf2swf:", url, 15)) {
char*tmp = strdup(url);
int l = strlen(tmp);
if(url[t]<'0' || url[t]>'9')
nodigit = 1;
if(!nodigit) {
- int page = atoi(&url[4]) - 1;
+ int page = atoi(&url[4]);
if(page<0) page = 0;
swfoutput_linktopage(dev, page, points);
}
swfoutput_linktourl(dev, url, points);
}
}
-void swfoutput_linktourl(gfxdevice_t*dev, char*url, gfxline_t*points)
+void swfoutput_linktourl(gfxdevice_t*dev, const char*url, gfxline_t*points)
{
- ActionTAG* actions;
+ ActionTAG* actions = 0;
swfoutput_internal*i = (swfoutput_internal*)dev->internal;
if(i->shapeid>=0)
endshape(dev);
if(i->textid>=0)
endtext(dev);
-
- if(!i->config_linktarget) {
+
+ /* TODO: escape special characters in url */
+
+ if(i->config_externallinkfunction && i->config_flashversion<=8) {
+ actions = action_PushString(actions, url); //parameter
+ actions = action_PushInt(actions, 1); //number of parameters (1)
+ actions = action_PushString(actions, i->config_externallinkfunction); //function name
+ actions = action_CallFunction(actions);
+ } else if(!i->config_linktarget) {
if(!i->config_opennewwindow)
- actions = action_GetUrl(0, url, "_parent");
+ actions = action_GetUrl(actions, url, "_parent");
else
- actions = action_GetUrl(0, url, "_this");
+ actions = action_GetUrl(actions, url, "_this");
} else {
- actions = action_GetUrl(0, url, i->config_linktarget);
+ actions = action_GetUrl(actions, url, i->config_linktarget);
}
actions = action_End(actions);
-
- drawlink(dev, actions, 0, points,0);
+
+ drawlink(dev, actions, 0, points, 0, url);
+
+ swf_ActionFree(actions);
}
void swfoutput_linktopage(gfxdevice_t*dev, int page, gfxline_t*points)
{
if(i->textid>=0)
endtext(dev);
- if(!i->config_internallinkfunction) {
- actions = action_GotoFrame(actions, page);
+ if(!i->config_internallinkfunction || i->config_flashversion>=9) {
+ actions = action_GotoFrame(actions, page-1);
actions = action_End(actions);
} else {
actions = action_PushInt(actions, page); //parameter
actions = action_PushInt(actions, 1); //number of parameters (1)
actions = action_PushString(actions, i->config_internallinkfunction); //function name
actions = action_CallFunction(actions);
+ actions = action_End(actions);
}
- drawlink(dev, actions, 0, points,0);
+ char name[80];
+ sprintf(name, "page%d", page);
+
+ drawlink(dev, actions, 0, points, 0, name);
+
+ swf_ActionFree(actions);
}
/* Named Links (a.k.a. Acrobatmenu) are used to implement various gadgets
actions1 = action_PushInt(0, 0); //number of parameters (0)
actions1 = action_PushString(actions1, &tmp[5]); //function name
actions1 = action_CallFunction(actions1);
+ actions1 = action_End(actions1);
} else {
*x = 0;
actions1 = action_PushString(0, x+1); //parameter
actions1 = action_PushInt(actions1, 1); //number of parameters (1)
actions1 = action_PushString(actions1, &tmp[5]); //function name
actions1 = action_CallFunction(actions1);
+ actions1 = action_End(actions1);
}
actions2 = action_End(0);
mouseover = 0;
actions2 = action_End(actions2);
}
- drawlink(dev, actions1, actions2, points,mouseover);
+ drawlink(dev, actions1, actions2, points, mouseover, name);
swf_ActionFree(actions1);
swf_ActionFree(actions2);
free(tmp);
}
-static void drawgfxline(gfxdevice_t*dev, gfxline_t*line)
+static void drawgfxline(gfxdevice_t*dev, gfxline_t*line, int fill)
{
swfoutput_internal*i = (swfoutput_internal*)dev->internal;
gfxcoord_t lastx=0,lasty=0,px=0,py=0;
char lastwasmoveto;
+ int lines= 0, splines=0;
+
+ i->fill = fill;
+
while(1) {
if(!line)
break;
/* check whether the next segment is zero */
if(line->type == gfx_moveTo) {
- msg("<trace> ======== moveTo %.2f %.2f", line->x, line->y);
moveto(dev, i->tag, line->x, line->y);
px = lastx = line->x;
py = lasty = line->y;
lastwasmoveto = 1;
} if(line->type == gfx_lineTo) {
- msg("<trace> ======== lineTo %.2f %.2f", line->x, line->y);
lineto(dev, i->tag, line->x, line->y);
px = line->x;
py = line->y;
lastwasmoveto = 0;
+ lines++;
} else if(line->type == gfx_splineTo) {
- msg("<trace> ======== splineTo %.2f %.2f", line->x, line->y);
plotxy_t s,p;
s.x = line->sx;p.x = line->x;
s.y = line->sy;p.y = line->y;
px = line->x;
py = line->y;
lastwasmoveto = 0;
+ splines++;
}
line = line->next;
}
+ msg("<trace> drawgfxline, %d lines, %d splines", lines, splines);
}
-static void drawlink(gfxdevice_t*dev, ActionTAG*actions1, ActionTAG*actions2, gfxline_t*points, char mouseover)
+static void drawlink(gfxdevice_t*dev, ActionTAG*actions1, ActionTAG*actions2, gfxline_t*points, char mouseover, const char*url)
{
swfoutput_internal*i = (swfoutput_internal*)dev->internal;
RGBA rgb;
SRECT r;
int lsid=0;
int fsid;
- plotxy_t p1,p2,p3,p4;
int myshapeid;
int myshapeid2;
double posx = 0;
double posy = 0;
- int t;
int buttonid = getNewID(dev);
gfxbbox_t bbox = gfxline_getbbox(points);
+
+ i->hasbuttons = 1;
/* shape */
myshapeid = getNewID(dev);
r.ymin = (int)(bbox.ymin*20);
r.xmax = (int)(bbox.xmax*20);
r.ymax = (int)(bbox.ymax*20);
+ r = swf_ClipRect(i->pagebbox, r);
swf_SetRect(i->tag,&r);
swf_SetShapeStyles(i->tag,i->shape);
swf_ShapeCountBits(i->shape,NULL,NULL);
swf_SetShapeBits(i->tag,i->shape);
swf_ShapeSetAll(i->tag,i->shape,/*x*/0,/*y*/0,0,fsid,0);
i->swflastx = i->swflasty = 0;
- drawgfxline(dev, points);
+ drawgfxline(dev, points, 1);
swf_ShapeSetEnd(i->tag);
+ swf_ShapeFree(i->shape);
/* shape2 */
myshapeid2 = getNewID(dev);
r.ymin = (int)(bbox.ymin*20);
r.xmax = (int)(bbox.xmax*20);
r.ymax = (int)(bbox.ymax*20);
+ r = swf_ClipRect(i->pagebbox, r);
swf_SetRect(i->tag,&r);
swf_SetShapeStyles(i->tag,i->shape);
swf_ShapeCountBits(i->shape,NULL,NULL);
swf_SetShapeBits(i->tag,i->shape);
swf_ShapeSetAll(i->tag,i->shape,/*x*/0,/*y*/0,0,fsid,0);
i->swflastx = i->swflasty = 0;
- drawgfxline(dev, points);
+ drawgfxline(dev, points, 1);
swf_ShapeSetEnd(i->tag);
+ swf_ShapeFree(i->shape);
if(!mouseover)
{
swf_ButtonPostProcess(i->tag, 1);
}
}
+ char buf[80];
+ const char* name = 0;
+ if(i->config_linknameurl) {
+ name = url;
+ } else {
+ name = buf;
+ sprintf(buf, "button%d", buttonid);
+ }
+ msg("<trace> Placing link ID %d", buttonid);
i->tag = swf_InsertTag(i->tag,ST_PLACEOBJECT2);
if(posx!=0 || posy!=0) {
m = i->page_matrix;
m.tx = p.x;
m.ty = p.y;
- swf_ObjectPlace(i->tag, buttonid, getNewDepth(dev),&m,0,0);
+ swf_ObjectPlace(i->tag, buttonid, getNewDepth(dev),&m,0,(U8*)name);
} else {
- swf_ObjectPlace(i->tag, buttonid, getNewDepth(dev),&i->page_matrix,0,0);
+ swf_ObjectPlace(i->tag, buttonid, getNewDepth(dev),&i->page_matrix,0,(U8*)name);
}
}
{
swfoutput_internal*i = (swfoutput_internal*)dev->internal;
+ msg("<trace> swfdevice: %s=%s", name, value);
if(!strcmp(name, "jpegsubpixels")) {
i->config_jpegsubpixels = atof(value);
} else if(!strcmp(name, "ppmsubpixels")) {
i->config_drawonlyshapes = atoi(value);
} else if(!strcmp(name, "ignoredraworder")) {
i->config_ignoredraworder = atoi(value);
+ } else if(!strcmp(name, "mark")) {
+ if(!value || !value[0]) {
+ if(i->mark) free(i->mark);
+ i->mark = 0;
+ } else {
+ int t;
+ i->mark = strdup("...");
+ for(t=0;t<3;t++) if(value[t]) i->mark[t] = value[t];
+ }
} else if(!strcmp(name, "filloverlap")) {
i->config_filloverlap = atoi(value);
} else if(!strcmp(name, "linksopennewwindow")) {
i->config_enablezlib = atoi(value);
} else if(!strcmp(name, "bboxvars")) {
i->config_bboxvars = atoi(value);
+ } else if(!strcmp(name, "dots")) {
+ i->config_dots = atoi(value);
+ } else if(!strcmp(name, "frameresets")) {
+ i->config_frameresets = atoi(value);
+ } else if(!strcmp(name, "showclipshapes")) {
+ i->config_showclipshapes = atoi(value);
+ } else if(!strcmp(name, "reordertags")) {
+ i->config_reordertags = atoi(value);
} else if(!strcmp(name, "internallinkfunction")) {
i->config_internallinkfunction = strdup(value);
+ } else if(!strcmp(name, "externallinkfunction")) {
+ i->config_externallinkfunction = strdup(value);
+ } else if(!strcmp(name, "linkfunction")) { //sets both internallinkfunction and externallinkfunction
+ i->config_internallinkfunction = strdup(value);
+ i->config_externallinkfunction = strdup(value);
+ } else if(!strcmp(name, "disable_polygon_conversion")) {
+ i->config_disable_polygon_conversion = atoi(value);
+ } else if(!strcmp(name, "normalize_polygon_positions")) {
+ i->config_normalize_polygon_positions = atoi(value);
+ } else if(!strcmp(name, "wxwindowparams")) {
+ i->config_watermark = atoi(value);
} else if(!strcmp(name, "insertstop")) {
i->config_insertstoptag = atoi(value);
} else if(!strcmp(name, "protect")) {
if(i->config_protect && i->tag) {
i->tag = swf_InsertTag(i->tag, ST_PROTECT);
}
- } else if(!strcmp(name, "faketags")) {
- i->config_generate_fake_tags = atoi(value);
} else if(!strcmp(name, "flashversion")) {
i->config_flashversion = atoi(value);
if(i->swf) {
i->swf->fileVersion = i->config_flashversion;
}
+ } else if(!strcmp(name, "framerate")) {
+ i->config_framerate = atof(value);
+ if(i->swf) {
+ i->swf->frameRate = i->config_framerate*0x100;
+ }
} else if(!strcmp(name, "minlinewidth")) {
i->config_minlinewidth = atof(value);
} else if(!strcmp(name, "caplinewidth")) {
i->config_caplinewidth = atof(value);
} else if(!strcmp(name, "linktarget")) {
i->config_linktarget = strdup(value);
+ } else if(!strcmp(name, "noclips")) {
+ i->config_noclips = atoi(value);
} else if(!strcmp(name, "dumpfonts")) {
i->config_dumpfonts = atoi(value);
+ } else if(!strcmp(name, "animate")) {
+ i->config_animate = atoi(value);
+ } else if(!strcmp(name, "disablelinks")) {
+ i->config_disablelinks = atoi(value);
+ } else if(!strcmp(name, "simpleviewer")) {
+ i->config_simpleviewer = atoi(value);
} else if(!strcmp(name, "next_bitmap_is_jpeg")) {
i->jpeg = 1;
} else if(!strcmp(name, "jpegquality")) {
int val = atoi(value);
if(val<0) val=0;
- if(val>100) val=100;
+ if(val>101) val=101;
i->config_jpegquality = val;
} else if(!strcmp(name, "splinequality")) {
int v = atoi(value);
i->config_linkcolor.g = NIBBLE(value[2])<<4 | NIBBLE(value[3]);
i->config_linkcolor.b = NIBBLE(value[4])<<4 | NIBBLE(value[5]);
i->config_linkcolor.a = NIBBLE(value[6])<<4 | NIBBLE(value[7]);
- printf("%02x%02x%02x%02x\n",
- i->config_linkcolor.r,
- i->config_linkcolor.g,
- i->config_linkcolor.b,
- i->config_linkcolor.a);
-
+ } else if(!strcmp(name, "help")) {
+ printf("\nSWF layer options:\n");
+ printf("jpegsubpixels=<pixels> resolution adjustment for jpeg images (same as jpegdpi, but in pixels)\n");
+ printf("ppmsubpixels=<pixels resolution adjustment for lossless images (same as ppmdpi, but in pixels)\n");
+ printf("subpixels=<pixels> shortcut for setting both jpegsubpixels and ppmsubpixels\n");
+ printf("drawonlyshapes convert everything to shapes (currently broken)\n");
+ printf("ignoredraworder allow to perform a few optimizations for creating smaller SWFs\n");
+ printf("linksopennewwindow make links open a new browser window\n");
+ printf("linktarget target window name of new links\n");
+ printf("linkcolor=<color) color of links (format: RRGGBBAA)\n");
+ printf("linknameurl Link buttons will be named like the URL they refer to (handy for iterating through links with actionscript)\n");
+ printf("storeallcharacters don't reduce the fonts to used characters in the output file\n");
+ printf("enablezlib switch on zlib compression (also done if flashversion>=7)\n");
+ printf("bboxvars store the bounding box of the SWF file in actionscript variables\n");
+ printf("dots Take care to handle dots correctly\n");
+ printf("reordertags=0/1 (default: 1) perform some tag optimizations\n");
+ printf("internallinkfunction=<name> when the user clicks a internal link (to a different page) in the converted file, this actionscript function is called\n");
+ 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");
+ printf("disable_polygon_conversion never convert strokes to polygons (will remove capstyles and joint styles)\n");
+ printf("caplinewidth=<width> the minimum thichness a line needs to have so that capstyles become visible (and are converted)\n");
+ printf("insertstop put an ActionScript \"STOP\" tag in every frame\n");
+ printf("protect add a \"protect\" tag to the file, to prevent loading in the Flash editor\n");
+ printf("flashversion=<version> the SWF fileversion (6)\n");
+ printf("framerate=<fps> SWF framerate\n");
+ printf("minlinewidth=<width> convert horizontal/vertical boxes smaller than this width to lines (0.05) \n");
+ printf("simpleviewer Add next/previous buttons to the SWF\n");
+ printf("animate insert a showframe tag after each placeobject (animate draw order of PDF files)\n");
+ printf("jpegquality=<quality> set compression quality of jpeg images\n");
+ printf("splinequality=<value> Set the quality of spline convertion to value (0-100, default: 100).\n");
+ printf("disablelinks Disable links.\n");
} else {
- fprintf(stderr, "unknown parameter: %s (=%s)\n", name, value);
return 0;
}
return 1;
cx.r0 = (S16)(c->rr*256);
cx.g0 = (S16)(c->gg*256);
cx.b0 = (S16)(c->bb*256);
- cx.a1 = c->t.a;
- cx.r1 = c->t.r;
- cx.g1 = c->t.g;
- cx.b1 = c->t.b;
+ cx.a1 = c->ta;
+ cx.r1 = c->tr;
+ cx.g1 = c->tg;
+ cx.b1 = c->tb;
return cx;
}
-static ArtVpath* gfxline_to_ArtVpath(gfxline_t*line)
-{
- ArtVpath *vec = NULL;
- int pos=0,len=0;
- gfxline_t*l2;
- double x=0,y=0;
-
- /* factor which determines into how many line fragments a spline is converted */
- double subfraction = 2.4;//0.3
-
- l2 = line;
- while(l2) {
- if(l2->type == gfx_moveTo) {
- pos ++;
- } if(l2->type == gfx_lineTo) {
- pos ++;
- } if(l2->type == gfx_splineTo) {
- int parts = (int)(sqrt(fabs(l2->x-2*l2->sx+x) + fabs(l2->y-2*l2->sy+y))*subfraction);
- if(!parts) parts = 1;
- pos += parts + 1;
- }
- x = l2->x;
- y = l2->y;
- l2 = l2->next;
- }
- pos++;
- len = pos;
-
- vec = art_new (ArtVpath, len);
-
- pos = 0;
- l2 = line;
- while(l2) {
- if(l2->type == gfx_moveTo) {
- vec[pos].code = ART_MOVETO;
- vec[pos].x = l2->x;
- vec[pos].y = l2->y;
- pos++;
- assert(pos<=len);
- } else if(l2->type == gfx_lineTo) {
- vec[pos].code = ART_LINETO;
- vec[pos].x = l2->x;
- vec[pos].y = l2->y;
- pos++;
- assert(pos<=len);
- } else if(l2->type == gfx_splineTo) {
- int i;
- int parts = (int)(sqrt(fabs(l2->x-2*l2->sx+x) + fabs(l2->y-2*l2->sy+y))*subfraction);
- if(!parts) parts = 1;
- for(i=0;i<=parts;i++) {
- double t = (double)i/(double)parts;
- vec[pos].code = ART_LINETO;
- vec[pos].x = l2->x*t*t + 2*l2->sx*t*(1-t) + x*(1-t)*(1-t);
- vec[pos].y = l2->y*t*t + 2*l2->sy*t*(1-t) + y*(1-t)*(1-t);
- pos++;
- assert(pos<=len);
- }
- }
- x = l2->x;
- y = l2->y;
- l2 = l2->next;
- }
- vec[pos].code = ART_END;
-
- return vec;
-}
-
-static ArtSVP* gfxfillToSVP(gfxline_t*line)
-{
- ArtVpath* vec = gfxline_to_ArtVpath(line);
- ArtSVP *svp = art_svp_from_vpath(vec);
- free(vec);
- return svp;
-}
-
-static ArtSVP* gfxstrokeToSVP(gfxline_t*line, gfxcoord_t width, gfx_capType cap_style, gfx_joinType joint_style, double miterLimit)
-{
- ArtVpath* vec = gfxline_to_ArtVpath(line);
- ArtSVP *svp = art_svp_vpath_stroke (vec,
- (joint_style==gfx_joinMiter)?ART_PATH_STROKE_JOIN_MITER:
- ((joint_style==gfx_joinRound)?ART_PATH_STROKE_JOIN_ROUND:
- ((joint_style==gfx_joinBevel)?ART_PATH_STROKE_JOIN_BEVEL:ART_PATH_STROKE_JOIN_BEVEL)),
- (cap_style==gfx_capButt)?ART_PATH_STROKE_CAP_BUTT:
- ((cap_style==gfx_capRound)?ART_PATH_STROKE_CAP_ROUND:
- ((cap_style==gfx_capSquare)?ART_PATH_STROKE_CAP_SQUARE:ART_PATH_STROKE_CAP_SQUARE)),
- width, //line_width
- miterLimit, //miter_limit
- 0.05 //flatness
- );
- free(vec);
- return svp;
-}
-
-static gfxline_t* SVPtogfxline(ArtSVP*svp)
-{
- int size = 0;
- int t;
- int pos = 0;
- for(t=0;t<svp->n_segs;t++) {
- size += svp->segs[t].n_points + 1;
- }
- gfxline_t* lines = (gfxline_t*)rfx_alloc(sizeof(gfxline_t)*size);
-
- for(t=0;t<svp->n_segs;t++) {
- ArtSVPSeg* seg = &svp->segs[t];
- int p;
- for(p=0;p<seg->n_points;p++) {
- lines[pos].type = p==0?gfx_moveTo:gfx_lineTo;
- ArtPoint* point = &seg->points[p];
- lines[pos].x = point->x;
- lines[pos].y = point->y;
- lines[pos].next = &lines[pos+1];
- pos++;
- }
- }
- if(pos) {
- lines[pos-1].next = 0;
- return lines;
- } else {
- return 0;
- }
-}
-
/* TODO */
static int imageInCache(gfxdevice_t*dev, void*data, int width, int height)
{
/// {
if(is_jpeg && i->config_jpegsubpixels) {
- newsizex = (int)(targetwidth*i->config_jpegsubpixels+0.5);
- newsizey = (int)(targetheight*i->config_jpegsubpixels+0.5);
+ newsizex = (int)(targetwidth*i->config_jpegsubpixels + 0.5);
+ newsizey = (int)(targetheight*i->config_jpegsubpixels + 0.5);
} else if(!is_jpeg && i->config_ppmsubpixels) {
- newsizex = (int)(targetwidth*i->config_ppmsubpixels+0.5);
- newsizey = (int)(targetheight*i->config_ppmsubpixels+0.5);
+ newsizex = (int)(targetwidth*i->config_ppmsubpixels + 0.5);
+ newsizey = (int)(targetheight*i->config_ppmsubpixels + 0.5);
}
/// }
- if(sizex<=0 || sizey<=0 || newsizex<=0 || newsizey<=0)
+ if(sizex<=0 || sizey<=0)
return -1;
+ if(newsizex<=0)
+ newsizex = 1;
+ if(newsizey<=0)
+ newsizey = 1;
/* TODO: cache images */
int num_colors = swf_ImageGetNumberOfPaletteEntries(mem,sizex,sizey,0);
int has_alpha = swf_ImageHasAlpha(mem,sizex,sizey);
- msg("<verbose> Drawing %dx%d %s%simage at size %dx%d (%dx%d), %s%d colors",
+ msg("<verbose> Drawing %dx%d %s%simage (id %d) at size %dx%d (%dx%d), %s%d colors",
sizex, sizey,
has_alpha?(has_alpha==2?"semi-transparent ":"transparent "):"",
- is_jpeg?"jpeg-":"",
+ is_jpeg?"jpeg-":"", i->currentswfid+1,
newsizex, newsizey,
targetwidth, targetheight,
/*newsizex, newsizey,*/
if(cacheid<=0) {
bitid = getNewID(dev);
+
i->tag = swf_AddImage(i->tag, bitid, mem, sizex, sizey, i->config_jpegquality);
addImageToCache(dev, mem, sizex, sizey);
} else {
return r;
}
+int line_is_empty(gfxline_t*line)
+{
+ while(line) {
+ if(line->type != gfx_moveTo)
+ return 0;
+ line = line->next;
+ }
+ return 1;
+}
+
static void swf_fillbitmap(gfxdevice_t*dev, gfxline_t*line, gfximage_t*img, gfxmatrix_t*matrix, gfxcxform_t*cxform)
{
swfoutput_internal*i = (swfoutput_internal*)dev->internal;
+
+ if(line_is_empty(line))
+ return;
endshape(dev);
endtext(dev);
double fy = (double)img->height / (double)newheight;
MATRIX m;
- float m00,m10,tx;
- float m01,m11,ty;
m.sx = (int)(65536*20*matrix->m00*fx); m.r1 = (int)(65536*20*matrix->m10*fy);
m.r0 = (int)(65536*20*matrix->m01*fx); m.sy = (int)(65536*20*matrix->m11*fy);
m.tx = (int)(matrix->tx*20);
int fsid = swf_ShapeAddBitmapFillStyle(shape,&m,bitid,1);
swf_SetU16(i->tag, myshapeid);
SRECT r = gfxline_getSWFbbox(line);
+ r = swf_ClipRect(i->pagebbox, r);
swf_SetRect(i->tag,&r);
swf_SetShapeStyles(i->tag,shape);
swf_ShapeCountBits(shape,NULL,NULL);
swf_SetShapeBits(i->tag,shape);
swf_ShapeSetAll(i->tag,shape,UNDEFINED_COORD,UNDEFINED_COORD,0,fsid,0);
i->swflastx = i->swflasty = UNDEFINED_COORD;
- drawgfxline(dev, line);
+ drawgfxline(dev, line, 1);
swf_ShapeSetEnd(i->tag);
swf_ShapeFree(shape);
+ msg("<trace> Placing image, shape ID %d, bitmap ID %d", myshapeid, bitid);
i->tag = swf_InsertTag(i->tag,ST_PLACEOBJECT2);
CXFORM cxform2 = gfxcxform_to_cxform(cxform);
swf_ObjectPlace(i->tag,myshapeid,getNewDepth(dev),&i->page_matrix,&cxform2,NULL);
}
+static RGBA col_black = {255,0,0,0};
+
+static void drawoutline(gfxdevice_t*dev, gfxline_t*line)
+{
+ swfoutput_internal*i = (swfoutput_internal*)dev->internal;
+
+ int myshapeid = getNewID(dev);
+ i->tag = swf_InsertTag(i->tag,ST_DEFINESHAPE3);
+
+ SHAPE*shape;
+ swf_ShapeNew(&shape);
+ int lsid = swf_ShapeAddLineStyle(shape,1,&col_black);
+
+ swf_SetU16(i->tag,myshapeid);
+ SRECT r = gfxline_getSWFbbox(line);
+ r = swf_ClipRect(i->pagebbox, r);
+ swf_SetRect(i->tag,&r);
+ swf_SetShapeStyles(i->tag,shape);
+ swf_ShapeCountBits(shape,NULL,NULL);
+ swf_SetShapeBits(i->tag,shape);
+ swf_ShapeSetAll(i->tag,shape,UNDEFINED_COORD,UNDEFINED_COORD,lsid,0,0);
+ drawgfxline(dev, line, 1);
+ swf_ShapeSetEnd(i->tag);
+ swf_ShapeFree(shape);
+
+ i->tag = swf_InsertTag(i->tag,ST_PLACEOBJECT2);
+ swf_ObjectPlace(i->tag, myshapeid, getNewDepth(dev), 0,0,0);
+}
+
static void swf_startclip(gfxdevice_t*dev, gfxline_t*line)
{
swfoutput_internal*i = (swfoutput_internal*)dev->internal;
+ if(i->config_noclips)
+ return;
endtext(dev);
endshape(dev);
i->clippos --;
}
+ if(i->config_showclipshapes)
+ drawoutline(dev, line);
+
int myshapeid = getNewID(dev);
- i->tag = swf_InsertTag(i->tag,ST_DEFINESHAPE);
+ i->tag = swf_InsertTag(i->tag,ST_DEFINESHAPE3);
RGBA col;
memset(&col, 0, sizeof(RGBA));
+ col.a = 255;
SHAPE*shape;
swf_ShapeNew(&shape);
int fsid = swf_ShapeAddSolidFillStyle(shape,&col);
+ if(i->mark) {
+ RGBA markcol = {0,i->mark[0],i->mark[1],i->mark[2]};
+ swf_ShapeAddSolidFillStyle(shape,&markcol);
+ }
swf_SetU16(i->tag,myshapeid);
SRECT r = gfxline_getSWFbbox(line);
+ r = swf_ClipRect(i->pagebbox, r);
swf_SetRect(i->tag,&r);
swf_SetShapeStyles(i->tag,shape);
swf_ShapeCountBits(shape,NULL,NULL);
swf_SetShapeBits(i->tag,shape);
swf_ShapeSetAll(i->tag,shape,UNDEFINED_COORD,UNDEFINED_COORD,0,fsid,0);
i->swflastx = i->swflasty = UNDEFINED_COORD;
- drawgfxline(dev, line);
+ i->shapeisempty = 1;
+ drawgfxline(dev, line, 1);
+ if(i->shapeisempty) {
+ /* an empty clip shape is equivalent to a shape with no area */
+ int x = line?line->x:0;
+ int y = line?line->y:0;
+ moveto(dev, i->tag, x,y);
+ lineto(dev, i->tag, x,y);
+ lineto(dev, i->tag, x,y);
+ }
+ 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)) {
+ if(i->config_watermark) {
+ gfxbbox_t r; r.xmin = r.ymin = 0;r.xmax = i->max_x;r.ymax = i->max_y;
+ draw_watermark(dev, r, 1);
+ }
+ }
swf_ShapeSetEnd(i->tag);
swf_ShapeFree(shape);
/* TODO: remember the bbox, and check all shapes against it */
+ msg("<trace> Placing clip ID %d", myshapeid);
i->tag = swf_InsertTag(i->tag,ST_PLACEOBJECT2);
i->cliptags[i->clippos] = i->tag;
i->clipshapes[i->clippos] = myshapeid;
static void swf_endclip(gfxdevice_t*dev)
{
swfoutput_internal*i = (swfoutput_internal*)dev->internal;
+ if(i->config_noclips)
+ return;
if(i->textid>=0)
endtext(dev);
if(i->shapeid>=0)
int lines=0;
int splines=0;
int haszerosegments=0;
+ int length=0;
while(line) {
if(line->type == gfx_moveTo) {
tmplines=0;
if(tmpsplines>lines)
splines=tmpsplines;
}
+ length++;
line = line->next;
}
+ if(length>400)
+ return 5;
if(lines==0 && splines==0) return 0;
else if(lines==1 && splines==0) return 1;
else if(lines==0 && splines==1) return 2;
static int gfxline_has_dots(gfxline_t*line)
{
int tmplines=0;
- double x,y;
+ double x=0,y=0;
double dist = 0;
int isline = 0;
+ int short_gap = 0;
while(line) {
if(line->type == gfx_moveTo) {
- if(isline && dist < 1) {
+ /* test the length of the preceding line, and assume it is a dot if
+ it's length is less than 1.0. But *only* if there's a noticable
+ gap between the previous line and the next moveTo. (I've come
+ across a PDF where thousands of "dots" were stringed together,
+ forming a line) */
+ int last_short_gap = short_gap;
+ if((fabs(line->x - x) + fabs(line->y - y)) < 1.0) {
+ short_gap = 1;
+ } else {
+ short_gap = 0;
+ }
+ if(isline && dist < 1 && !short_gap && !last_short_gap) {
return 1;
}
dist = 0;
y = line->y;
line = line->next;
}
- if(isline && dist < 1) {
+ if(isline && dist < 1 && !short_gap) {
return 1;
}
return 0;
return 1;
}
-static void show_path(ArtSVP*path)
-{
- int t;
- printf("Segments: %d\n", path->n_segs);
- for(t=0;t<path->n_segs;t++) {
- ArtSVPSeg* seg = &path->segs[t];
- printf("Segment %d: %d points, %s, BBox: (%f,%f,%f,%f)\n",
- t, seg->n_points, seg->dir==0?"UP ":"DOWN",
- seg->bbox.x0, seg->bbox.y0, seg->bbox.x1, seg->bbox.y1);
- int p;
- for(p=0;p<seg->n_points;p++) {
- ArtPoint* point = &seg->points[p];
- printf(" (%f,%f)\n", point->x, point->y);
- }
- }
- printf("\n");
-}
-
gfxline_t* gfxline_move(gfxline_t*line, double x, double y)
{
gfxline_t*l = line = gfxline_clone(line);
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)
{
swfoutput_internal*i = (swfoutput_internal*)dev->internal;
+ if(line_is_empty(line))
+ return;
int type = gfxline_type(line);
int has_dots = gfxline_has_dots(line);
gfxbbox_t r = gfxline_getbbox(line);
/* TODO: * split line into segments, and perform this check for all segments */
- if(!has_dots &&
- (width <= i->config_caplinewidth
+ if(i->config_disable_polygon_conversion || /*type>=5 ||*/
+ (!has_dots &&
+ (width <= i->config_caplinewidth
|| (cap_style == gfx_capRound && joint_style == gfx_joinRound)
- || (cap_style == gfx_capRound && type<=2))) {} else
+ || (cap_style == gfx_capRound && type<=2))))
{
+ // ...
+ } else {
/* convert line to polygon */
msg("<trace> draw as polygon, type=%d dots=%d", type, has_dots);
if(has_dots)
gfxline_fix_short_edges(line);
/* we need to convert the line into a polygon */
- ArtSVP* svp = gfxstrokeToSVP(line, width, cap_style, joint_style, miterLimit);
- gfxline_t*gfxline = SVPtogfxline(svp);
+ gfxpoly_t* poly = gfxpoly_from_stroke(line, width, cap_style, joint_style, miterLimit, DEFAULT_GRID);
+ gfxline_t*gfxline = gfxline_from_gfxpoly(poly);
dev->fill(dev, gfxline, color);
- free(gfxline);
- art_svp_free(svp);
+ gfxline_free(gfxline);
+ gfxpoly_destroy(poly);
return;
}
msg("<trace> draw as stroke, type=%d dots=%d", type, has_dots);
endtext(dev);
-#ifdef NORMALIZE_POLYGON_POSITIONS
- endshape(dev);
- double startx = 0, starty = 0;
- if(line && line->type == gfx_moveTo) {
- startx = line->x;
- starty = line->y;
- }
- line = gfxline_move(line, -startx, -starty);
- i->shapeposx = (int)(startx*20);
- i->shapeposy = (int)(starty*20);
-#endif
+ if(i->config_normalize_polygon_positions) {
+ endshape(dev);
+ double startx = 0, starty = 0;
+ if(line && line->type == gfx_moveTo) {
+ startx = line->x;
+ starty = line->y;
+ }
+ line = gfxline_move(line, -startx, -starty);
+ i->shapeposx = (int)(startx*20);
+ i->shapeposy = (int)(starty*20);
+ }
swfoutput_setstrokecolor(dev, color->r, color->g, color->b, color->a);
swfoutput_setlinewidth(dev, width);
startshape(dev);
stopFill(dev);
- drawgfxline(dev, line);
+ drawgfxline(dev, line, 0);
-#ifdef NORMALIZE_POLYGON_POSITIONS
- free(line); //account for _move
-#endif
+ if(i->config_normalize_polygon_positions) {
+ free(line); //account for _move
+ }
}
+
static void swf_fill(gfxdevice_t*dev, gfxline_t*line, gfxcolor_t*color)
{
swfoutput_internal*i = (swfoutput_internal*)dev->internal;
+ if(line_is_empty(line))
+ return;
+ if(!color->a)
+ return;
gfxbbox_t r = gfxline_getbbox(line);
int is_outside_page = !is_inside_page(dev, r.xmin, r.ymin) || !is_inside_page(dev, r.xmax, r.ymax);
+ //if(i->chardatapos && i->chardata[i->chardatapos-1].color.a) {
endtext(dev);
+
if(!i->config_ignoredraworder)
endshape(dev);
-#ifdef NORMALIZE_POLYGON_POSITIONS
- endshape(dev);
- double startx = 0, starty = 0;
- if(line && line->type == gfx_moveTo) {
- startx = line->x;
- starty = line->y;
- }
- line = gfxline_move(line, -startx, -starty);
- i->shapeposx = (int)(startx*20);
- i->shapeposy = (int)(starty*20);
-#endif
+ if(i->config_normalize_polygon_positions) {
+ endshape(dev);
+ double startx = 0, starty = 0;
+ if(line && line->type == gfx_moveTo) {
+ startx = line->x;
+ starty = line->y;
+ }
+ line = gfxline_move(line, -startx, -starty);
+ i->shapeposx = (int)(startx*20);
+ i->shapeposy = (int)(starty*20);
+ }
swfoutput_setfillcolor(dev, color->r, color->g, color->b, color->a);
startshape(dev);
startFill(dev);
- i->fill=1;
- drawgfxline(dev, line);
+ drawgfxline(dev, line, 1);
+
+ if(i->currentswfid==2 && r.xmin==0 && r.ymin==0 && r.xmax==i->max_x && r.ymax==i->max_y) {
+ if(i->config_watermark) {
+ draw_watermark(dev, r, 1);
+ }
+ }
+
msg("<trace> end of swf_fill (shapeid=%d)", i->shapeid);
-#ifdef NORMALIZE_POLYGON_POSITIONS
- free(line); //account for _move
-#endif
+ if(i->config_normalize_polygon_positions) {
+ free(line); //account for _move
+ }
+}
+
+static GRADIENT* gfxgradient_to_GRADIENT(gfxgradient_t*gradient)
+{
+ int num = 0;
+ gfxgradient_t*g = gradient;
+ while(g) {
+ num++;
+ g = g->next;
+ }
+ GRADIENT* swfgradient = malloc(sizeof(GRADIENT));
+ swfgradient->num = num;
+ swfgradient->rgba = malloc(sizeof(swfgradient->rgba[0])*num);
+ swfgradient->ratios = malloc(sizeof(swfgradient->ratios[0])*num);
+
+ g = gradient;
+ num = 0;
+ while(g) {
+ swfgradient->ratios[num] = g->pos*255;
+ swfgradient->rgba[num] = *(RGBA*)&g->color;
+ num++;
+ g = g->next;
+ }
+ return swfgradient;
}
+
static void swf_fillgradient(gfxdevice_t*dev, gfxline_t*line, gfxgradient_t*gradient, gfxgradienttype_t type, gfxmatrix_t*matrix)
{
- msg("<error> Gradient filling not implemented yet");
+ if(line_is_empty(line))
+ return;
+ swfoutput_internal*i = (swfoutput_internal*)dev->internal;
+
+ if(line_is_empty(line))
+ return;
+
+ GRADIENT* swfgradient = gfxgradient_to_GRADIENT(gradient);
+ if(!swfgradient)
+ return;
+
+ endshape(dev);
+ endtext(dev);
+
+ double f = type==gfxgradient_radial?4:4;
+ MATRIX m;
+ m.sx = (int)(matrix->m00*20*f); m.r1 = (int)(matrix->m10*20*f);
+ m.r0 = (int)(matrix->m01*20*f); m.sy = (int)(matrix->m11*20*f);
+ m.tx = (int)(matrix->tx*20);
+ m.ty = (int)(matrix->ty*20);
+
+ /* shape */
+ int myshapeid = getNewID(dev);
+ i->tag = swf_InsertTag(i->tag, ST_DEFINESHAPE2);
+ SHAPE*shape;
+ swf_ShapeNew(&shape);
+ int fsid = swf_ShapeAddGradientFillStyle(shape,&m,swfgradient,type==gfxgradient_radial);
+ swf_SetU16(i->tag, myshapeid);
+ SRECT r = gfxline_getSWFbbox(line);
+ r = swf_ClipRect(i->pagebbox, r);
+ swf_SetRect(i->tag,&r);
+ swf_SetShapeStyles(i->tag,shape);
+ swf_ShapeCountBits(shape,NULL,NULL);
+ swf_SetShapeBits(i->tag,shape);
+ swf_ShapeSetAll(i->tag,shape,UNDEFINED_COORD,UNDEFINED_COORD,0,fsid,0);
+ i->swflastx = i->swflasty = UNDEFINED_COORD;
+ drawgfxline(dev, line, 1);
+ swf_ShapeSetEnd(i->tag);
+ swf_ShapeFree(shape);
+
+ int depth = getNewDepth(dev);
+ msg("<trace> Placing gradient, shape ID %d, depth %d", myshapeid, depth);
+ i->tag = swf_InsertTag(i->tag,ST_PLACEOBJECT2);
+ swf_ObjectPlace(i->tag,myshapeid,depth,&i->page_matrix,NULL,NULL);
+
+ swf_FreeGradient(swfgradient);free(swfgradient);
}
-static SWFFONT* gfxfont_to_swffont(gfxfont_t*font, char* id)
+static SWFFONT* gfxfont_to_swffont(gfxfont_t*font, const char* id)
{
SWFFONT*swffont = (SWFFONT*)rfx_calloc(sizeof(SWFFONT));
int t;
swffont->version = 2;
swffont->name = (U8*)strdup(id);
swffont->layout = (SWFLAYOUT*)rfx_calloc(sizeof(SWFLAYOUT));
- swffont->layout->ascent = 0; /* ? */
+ swffont->layout->ascent = 0;
swffont->layout->descent = 0;
swffont->layout->leading = 0;
swffont->layout->bounds = (SRECT*)rfx_calloc(sizeof(SRECT)*font->num_glyphs);
for(t=0;t<font->max_unicode;t++) {
swffont->ascii2glyph[t] = font->unicode2glyph[t];
}
+ SRECT max = {0,0,0,0};
for(t=0;t<font->num_glyphs;t++) {
drawer_t draw;
gfxline_t*line;
- int advance = 0;
+ double advance = 0;
swffont->glyph2ascii[t] = font->glyphs[t].unicode;
+ if(swffont->glyph2ascii[t] == 0xffff || swffont->glyph2ascii[t] == 0x0000) {
+ /* flash 8 flashtype requires unique unicode IDs for each character.
+ We use the Unicode private user area to assign characters, hoping that
+ the font doesn't contain more than 2048 glyphs */
+ swffont->glyph2ascii[t] = 0xe000 + (t&0x1fff);
+ }
+
if(font->glyphs[t].name) {
swffont->glyphnames[t] = strdup(font->glyphs[t].name);
} else {
swffont->glyphnames[t] = 0;
}
- advance = (int)(font->glyphs[t].advance * 20);
+ advance = font->glyphs[t].advance;
swf_Shape01DrawerInit(&draw, 0);
line = font->glyphs[t].line;
while(line) {
FPOINT c,to;
- c.x = line->sx; c.y = line->sy;
- to.x = line->x; to.y = line->y;
+ c.x = line->sx * GLYPH_SCALE; c.y = line->sy * GLYPH_SCALE;
+ to.x = line->x * GLYPH_SCALE; to.y = line->y * GLYPH_SCALE;
if(line->type == gfx_moveTo) {
draw.moveTo(&draw, &to);
} else if(line->type == gfx_lineTo) {
}
draw.finish(&draw);
swffont->glyph[t].shape = swf_ShapeDrawerToShape(&draw);
- swffont->layout->bounds[t] = swf_ShapeDrawerGetBBox(&draw);
- if(swffont->layout->bounds[t].xmax*2 < advance) {
- printf("fix bad advance value\n");
- advance = swffont->layout->bounds[t].xmax;
- }
+ SRECT bbox = swf_ShapeDrawerGetBBox(&draw);
+ swf_ExpandRect2(&max, &bbox);
+
+ swffont->layout->bounds[t] = bbox;
- if(advance<32768) {
- swffont->glyph[t].advance = advance;
+ if(advance<32768.0/20) {
+ swffont->glyph[t].advance = (int)(advance*20);
} else {
+ //msg("<warning> Advance value overflow in glyph %d", t);
swffont->glyph[t].advance = 32767;
}
swf_ExpandRect2(&bounds, &swffont->layout->bounds[t]);
}
- if(bounds.ymin < 0 && bounds.ymax > 0) {
- swffont->layout->ascent = -bounds.ymin;
- swffont->layout->descent = bounds.ymax;
- swffont->layout->leading = bounds.ymax - bounds.ymin;
- } else {
- swffont->layout->ascent = (bounds.ymax - bounds.ymin)/2;
- swffont->layout->descent = (bounds.ymax - bounds.ymin)/2;
- swffont->layout->leading = bounds.ymax - bounds.ymin;
+ for(t=0;t<font->num_glyphs;t++) {
+ SRECT bbox = swffont->layout->bounds[t];
+
+ /* if the glyph doesn't have a bounding box, use the
+ combined bounding box (necessary e.g. for space characters) */
+ if(!(bbox.xmin|bbox.ymin|bbox.xmax|bbox.ymax)) {
+ swffont->layout->bounds[t] = bbox = max;
+ }
+
+ /* check that the advance value is reasonable, by comparing it
+ with the bounding box */
+ if(bbox.xmax>0 && (bbox.xmax*10 < swffont->glyph[t].advance || !swffont->glyph[t].advance)) {
+ if(swffont->glyph[t].advance)
+ 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);
+ swffont->glyph[t].advance = bbox.xmax;
+ }
+ //swffont->glyph[t].advance = bbox.xmax - bbox.xmin;
}
+
+ /* Flash player will use the advance value from the char, and the ascent/descent values
+ from the layout for text selection.
+ ascent will extend the char into negative y direction, from the baseline, while descent
+ will extend in positive y direction, also from the baseline.
+ The baseline is defined as the y-position zero
+ */
+
+ swffont->layout->ascent = -bounds.ymin;
+ if(swffont->layout->ascent < 0)
+ swffont->layout->ascent = 0;
+ swffont->layout->descent = bounds.ymax;
+ if(swffont->layout->descent < 0)
+ swffont->layout->descent = 0;
+ swffont->layout->leading = bounds.ymax - bounds.ymin;
+
+ /* if the font has proper ascent/descent values (>0) and those define
+ greater line spacing that what we estimated from the bounding boxes,
+ use the font's parameters */
+ if(font->ascent*20 > swffont->layout->ascent)
+ swffont->layout->ascent = font->ascent*20;
+ if(font->descent*20 > swffont->layout->descent)
+ swffont->layout->descent = font->descent*20;
+
return swffont;
}
-static void swf_addfont(gfxdevice_t*dev, char*fontid, gfxfont_t*font)
+static void swf_addfont(gfxdevice_t*dev, gfxfont_t*font)
{
swfoutput_internal*i = (swfoutput_internal*)dev->internal;
- if(i->swffont && i->swffont->name && !strcmp((char*)i->swffont->name,fontid))
+ if(i->swffont && i->swffont->name && !strcmp((char*)i->swffont->name,font->id))
return; // the requested font is the current font
fontlist_t*last=0,*l = i->fontlist;
while(l) {
last = l;
- if(!strcmp((char*)l->swffont->name, fontid)) {
+ if(!strcmp((char*)l->swffont->name, font->id)) {
return; // we already know this font
}
l = l->next;
}
l = (fontlist_t*)rfx_calloc(sizeof(fontlist_t));
- l->swffont = gfxfont_to_swffont(font, fontid);
+ l->swffont = gfxfont_to_swffont(font, font->id);
l->next = 0;
if(last) {
last->next = l;
if(getScreenLogLevel() >= LOGLEVEL_DEBUG) {
int iii;
// print font information
- msg("<debug> Font %s",fontid);
+ msg("<debug> Font %s",font->id);
msg("<debug> | ID: %d", l->swffont->id);
msg("<debug> | Version: %d", l->swffont->version);
msg("<debug> | Name: %s", l->swffont->name);
}
}
-static void swf_switchfont(gfxdevice_t*dev, char*fontid)
+static void swf_switchfont(gfxdevice_t*dev, const char*fontid)
{
swfoutput_internal*i = (swfoutput_internal*)dev->internal;
return;
}
-static void swf_drawchar(gfxdevice_t*dev, char*fontid, int glyph, gfxcolor_t*color, gfxmatrix_t*matrix)
+static void swf_drawchar(gfxdevice_t*dev, gfxfont_t*font, int glyph, gfxcolor_t*color, gfxmatrix_t*matrix)
{
swfoutput_internal*i = (swfoutput_internal*)dev->internal;
-
- if(!i->swffont || !i->swffont->name || strcmp((char*)i->swffont->name,fontid)) // not equal to current font
+ if(!font) {
+ msg("<error> swf_drawchar called (glyph %d) without font", glyph);
+ return;
+ }
+
+ if(i->config_drawonlyshapes) {
+ gfxglyph_t*g = &font->glyphs[glyph];
+ gfxline_t*line2 = gfxline_clone(g->line);
+ gfxline_transform(line2, matrix);
+ dev->fill(dev, line2, color);
+ gfxline_free(line2);
+ return;
+ }
+
+ if(!i->swffont || !i->swffont->name || strcmp((char*)i->swffont->name,font->id)) // not equal to current font
{
/* TODO: remove the need for this (enhance getcharacterbbox so that it can cope
with multiple fonts */
endtext(dev);
-
- swf_switchfont(dev, fontid); // set the current font
+ swf_switchfont(dev, font->id); // set the current font
}
- swfoutput_setfontmatrix(dev, matrix->m00, matrix->m01, matrix->m10, matrix->m11);
-
- swfmatrix_t m;
- m.m11 = i->fontm11;
- m.m12 = i->fontm12;
- m.m21 = i->fontm21;
- m.m22 = i->fontm22;
- m.m31 = matrix->tx;
- m.m32 = matrix->ty;
-
-/* printf("%f %f\n", m.m31, m.m32);
- {
- static int xpos = 40;
- static int ypos = 200;
- m.m31 = xpos;
- m.m32 = ypos;
- xpos += 10;
+ if(!i->swffont) {
+ msg("<warning> swf_drawchar: Font is NULL");
+ return;
+ }
+ if(glyph<0 || glyph>=i->swffont->numchars) {
+ msg("<warning> No character %d in font %s (%d chars)", glyph, FIXNULL((char*)i->swffont->name), i->swffont->numchars);
+ return;
+ }
+
+ setfontscale(dev, matrix->m00, matrix->m01, matrix->m10, matrix->m11, matrix->tx, matrix->ty, 0);
+
+ double det = i->fontmatrix.sx/65536.0 * i->fontmatrix.sy/65536.0 -
+ i->fontmatrix.r0/65536.0 * i->fontmatrix.r1/65536.0;
+ if(fabs(det) < 0.0005) {
+ /* x direction equals y direction- the text is invisible */
+ msg("<verbose> Not drawing invisible character character %d (det=%f, m=[%f %f;%f %f]\n", glyph,
+ det,
+ i->fontmatrix.sx/65536.0, i->fontmatrix.r1/65536.0,
+ i->fontmatrix.r0/65536.0, i->fontmatrix.sy/65536.0);
+ return;
+ }
+
+ /*if(i->swffont->glyph[glyph].shape->bitlen <= 16) {
+ msg("<warning> Glyph %d in current charset (%s, %d characters) is empty",
+ glyph, FIXNULL((char*)i->swffont->name), i->swffont->numchars);
+ return 1;
}*/
+ /* calculate character position with respect to the current font matrix */
+ double s = 20 * GLYPH_SCALE / det;
+ double px = matrix->tx - i->fontmatrix.tx/20.0;
+ double py = matrix->ty - i->fontmatrix.ty/20.0;
+ int x = (SCOORD)(( px * i->fontmatrix.sy/65536.0 - py * i->fontmatrix.r1/65536.0)*s);
+ int y = (SCOORD)((- px * i->fontmatrix.r0/65536.0 + py * i->fontmatrix.sx/65536.0)*s);
+ if(x>32767 || x<-32768 || y>32767 || y<-32768) {
+ msg("<verbose> Moving character origin to %f %f\n", matrix->tx, matrix->ty);
+ endtext(dev);
+ setfontscale(dev, matrix->m00, matrix->m01, matrix->m10, matrix->m11, matrix->tx, matrix->ty, 1);
+ /* since we just moved the char origin to the current char's position,
+ it now has the relative position (0,0) */
+ x = y = 0;
+ }
+
+ if(i->shapeid>=0)
+ endshape(dev);
+ if(i->textid<0)
+ starttext(dev);
+
+ msg("<trace> Drawing char %d in font %d at %d,%d in color %02x%02x%02x%02x",
+ glyph, i->swffont->id, x, y, color->r, color->g, color->b, color->a);
- drawchar(dev, i->swffont, glyph, &m, color);
+ putcharacter(dev, i->swffont->id, glyph, x, y, i->current_font_size, *(RGBA*)color);
+ swf_FontUseGlyph(i->swffont, glyph);
+ return;
}
git.asbjorn.biz / swftools.git / blobdiff