X-Git-Url: http://git.asbjorn.biz/?p=swftools.git;a=blobdiff_plain;f=lib%2Fdevices%2Fswf.c;h=4bf636eb3c9e662729e4cb18dfba941ea812f21b;hp=94e4c36dd030da0d24e43ca9b75fa8f7ad849d80;hb=e0a27e1bd83ff2d60745dd6030e0f5ef7ef97b82;hpb=fd812e6f288b19810fd7cd9b1460b804784b4093

diff --git a/lib/devices/swf.c b/lib/devices/swf.c
index 94e4c36..4bf636e 100644
--- a/lib/devices/swf.c
+++ b/lib/devices/swf.c
@@ -23,18 +23,26 @@
 #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
@@ -68,27 +76,39 @@ typedef struct _swfoutput_internal
     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;
 
@@ -100,6 +120,7 @@ typedef struct _swfoutput_internal
 
     TAG *tag;
     int currentswfid;
+    int startids;
     int depth;
     int startdepth;
     int linewidth;
@@ -107,6 +128,8 @@ typedef struct _swfoutput_internal
     SHAPE* shape;
     int shapeid;
     int textid;
+
+    int watermarks;
     
     int fillstyleid;
     int linestyleid;
@@ -123,12 +146,14 @@ typedef struct _swfoutput_internal
     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;
@@ -140,6 +165,8 @@ typedef struct _swfoutput_internal
     int bboxrectpos;
     SRECT bboxrect;
 
+    SRECT pagebbox;
+
     chardata_t chardata[CHARDATAMAX];
     int chardatapos;
     int firstpage;
@@ -147,8 +174,9 @@ typedef struct _swfoutput_internal
 
     char overflow;
 
+    int current_font_size;
     MATRIX fontmatrix;
-    double fontm11,fontm12,fontm21,fontm22;
+    double lastfontm11,lastfontm12,lastfontm21,lastfontm22;
     SWFFONT *swffont;
     RGBA strokergb;
     RGBA fillrgb;
@@ -170,9 +198,9 @@ static void swf_stroke(gfxdevice_t*dev, gfxline_t*line, gfxcoord_t width, gfxcol
 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);
@@ -211,6 +239,7 @@ static swfoutput_internal* init_internal_struct()
     i->firstpage = 1;
     i->pagefinished = 1;
 
+    i->config_disablelinks=0;
     i->config_dumpfonts=0;
     i->config_ppmsubpixels=0;
     i->config_jpegsubpixels=0;
@@ -219,20 +248,24 @@ static swfoutput_internal* init_internal_struct()
     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;
@@ -246,8 +279,10 @@ static U16 getNewID(gfxdevice_t* dev)
 {
     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);
@@ -257,9 +292,11 @@ static U16 getNewID(gfxdevice_t* dev)
 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);
@@ -277,12 +314,38 @@ typedef struct _plotxy
     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;
@@ -344,18 +407,24 @@ static void addPointToBBox(gfxdevice_t*dev, int px, int py)
 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;
@@ -377,12 +446,12 @@ static void splineto(gfxdevice_t*dev, TAG*tag, plotxy_t control,plotxy_t end)
     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;
     
@@ -668,50 +737,7 @@ static void putcharacter(gfxdevice_t*dev, int fontid, int charid, int x,int y, i
 /* 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)
 {
@@ -719,12 +745,12 @@ 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);
@@ -733,58 +759,250 @@ static void endtext(gfxdevice_t*dev)
 
     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);
@@ -794,18 +1012,19 @@ void swf_startframe(gfxdevice_t*dev, int width, int height)
     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;
@@ -819,7 +1038,7 @@ void swf_endframe(gfxdevice_t*dev)
     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);
@@ -834,6 +1053,14 @@ void swf_endframe(gfxdevice_t*dev)
         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)
@@ -872,7 +1099,10 @@ 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;
@@ -892,30 +1122,28 @@ void gfxdevice_swf_init(gfxdevice_t* dev)
     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)
@@ -925,9 +1153,8 @@ static void startshape(gfxdevice_t*dev)
 
     if(i->shapeid>=0)
 	return;
-
-    if(i->textid>=0)
-        endtext(dev);
+    //if(i->chardatapos && i->chardata[i->chardatapos-1].color.a)
+    endtext(dev);
 
     i->tag = swf_InsertTag(i->tag,ST_DEFINESHAPE3);
 
@@ -947,11 +1174,7 @@ static void startshape(gfxdevice_t*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));
 
@@ -972,9 +1195,11 @@ static void starttext(gfxdevice_t*dev)
     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;
 }
 	    
@@ -1008,12 +1233,12 @@ void cancelshape(gfxdevice_t*dev)
     /* 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--; // this was an *exceptionally* bad idea
+//    i->currentswfid--; // doesn't work, for some reason
 }
 
 void fixAreas(gfxdevice_t*dev)
@@ -1099,9 +1324,10 @@ static void endshape(gfxdevice_t*dev)
     
     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;
@@ -1109,6 +1335,10 @@ static void endshape(gfxdevice_t*dev)
     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;
@@ -1128,13 +1358,12 @@ void wipeSWF(SWF*swf)
 	   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;
@@ -1142,6 +1371,9 @@ void swfoutput_finalize(gfxdevice_t*dev)
     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;
@@ -1168,28 +1400,29 @@ void swfoutput_finalize(gfxdevice_t*dev)
 	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;
 
@@ -1197,7 +1430,7 @@ void swfoutput_finalize(gfxdevice_t*dev)
        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;
     }
     
@@ -1207,9 +1440,18 @@ void swfoutput_finalize(gfxdevice_t*dev)
     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;
@@ -1223,35 +1465,30 @@ int swfresult_save(gfxresult_t*gfx, char*filename)
 	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;
 }
@@ -1315,22 +1552,6 @@ static void swfoutput_destroy(gfxdevice_t* dev)
     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;
@@ -1361,21 +1582,24 @@ static void swfoutput_setlinewidth(gfxdevice_t*dev, double _linewidth)
 }
 
 
-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);
@@ -1398,7 +1622,7 @@ void swf_drawlink(gfxdevice_t*dev, gfxline_t*points, char*url)
 	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 = 0;
     swfoutput_internal*i = (swfoutput_internal*)dev->internal;
@@ -1406,8 +1630,10 @@ void swfoutput_linktourl(gfxdevice_t*dev, char*url, gfxline_t*points)
 	endshape(dev);
     if(i->textid>=0)
 	endtext(dev);
+
+    /* TODO: escape special characters in url */
     
-    if(i->config_externallinkfunction) {
+    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
@@ -1421,8 +1647,10 @@ void swfoutput_linktourl(gfxdevice_t*dev, char*url, gfxline_t*points)
 	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)
 {
@@ -1434,7 +1662,7 @@ void swfoutput_linktopage(gfxdevice_t*dev, int page, gfxline_t*points)
     if(i->textid>=0)
 	endtext(dev);
   
-    if(!i->config_internallinkfunction) {
+    if(!i->config_internallinkfunction || i->config_flashversion>=9) {
 	actions = action_GotoFrame(actions, page-1);
 	actions = action_End(actions);
     } else {
@@ -1445,7 +1673,12 @@ void swfoutput_linktopage(gfxdevice_t*dev, int page, gfxline_t*points)
 	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
@@ -1495,36 +1728,38 @@ void swfoutput_namedlink(gfxdevice_t*dev, char*name, gfxline_t*points)
 	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;
@@ -1532,27 +1767,29 @@ static void drawgfxline(gfxdevice_t*dev, gfxline_t*line)
 	    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);
@@ -1565,14 +1802,16 @@ static void drawlink(gfxdevice_t*dev, ActionTAG*actions1, ActionTAG*actions2, gf
     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);
@@ -1587,14 +1826,16 @@ static void drawlink(gfxdevice_t*dev, ActionTAG*actions1, ActionTAG*actions2, gf
     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)
     {
@@ -1631,7 +1872,16 @@ static void drawlink(gfxdevice_t*dev, ActionTAG*actions1, ActionTAG*actions2, gf
             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) {
@@ -1643,9 +1893,9 @@ static void drawlink(gfxdevice_t*dev, ActionTAG*actions1, ActionTAG*actions2, gf
         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);
     }
 }
 
@@ -1696,6 +1946,7 @@ int swf_setparameter(gfxdevice_t*dev, const char*name, const char*value)
 {
     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")) {
@@ -1727,12 +1978,27 @@ int swf_setparameter(gfxdevice_t*dev, const char*name, const char*value)
 	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")) {
@@ -1740,27 +2006,38 @@ int swf_setparameter(gfxdevice_t*dev, const char*name, const char*value)
 	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);
@@ -1782,14 +2059,37 @@ int swf_setparameter(gfxdevice_t*dev, const char*name, const char*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;
@@ -1813,136 +2113,13 @@ static CXFORM gfxcxform_to_cxform(gfxcxform_t* c)
     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)
 {
@@ -1967,16 +2144,20 @@ static int add_image(swfoutput_internal*i, gfximage_t*img, int targetwidth, int
 
     /// {
     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 */
     
@@ -1994,10 +2175,10 @@ static int add_image(swfoutput_internal*i, gfximage_t*img, int targetwidth, int
     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,*/
@@ -2019,6 +2200,7 @@ static int add_image(swfoutput_internal*i, gfximage_t*img, int targetwidth, int
 
     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 {
@@ -2041,9 +2223,22 @@ static SRECT gfxline_getSWFbbox(gfxline_t*line)
     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);
@@ -2059,8 +2254,6 @@ static void swf_fillbitmap(gfxdevice_t*dev, gfxline_t*line, gfximage_t*img, gfxm
     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);
@@ -2074,24 +2267,57 @@ static void swf_fillbitmap(gfxdevice_t*dev, gfxline_t*line, gfximage_t*img, gfxm
     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);
@@ -2102,10 +2328,14 @@ static void swf_startclip(gfxdevice_t*dev, gfxline_t*line)
         i->clippos --;
     } 
 
+    if(i->config_showclipshapes)
+	drawoutline(dev, line);
+
     int myshapeid = getNewID(dev);
     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);
@@ -2115,18 +2345,35 @@ static void swf_startclip(gfxdevice_t*dev, gfxline_t*line)
     }
     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;
@@ -2137,6 +2384,8 @@ static void swf_startclip(gfxdevice_t*dev, gfxline_t*line)
 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)
@@ -2159,6 +2408,7 @@ static int gfxline_type(gfxline_t*line)
     int lines=0;
     int splines=0;
     int haszerosegments=0;
+    int length=0;
     while(line) {
 	if(line->type == gfx_moveTo) {
 	    tmplines=0;
@@ -2172,8 +2422,11 @@ static int gfxline_type(gfxline_t*line)
 	    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;
@@ -2253,24 +2506,6 @@ static char is_inside_page(gfxdevice_t*dev, gfxcoord_t x, gfxcoord_t y)
     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);
@@ -2290,6 +2525,8 @@ gfxline_t* gfxline_move(gfxline_t*line, double x, double y)
 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);
@@ -2297,90 +2534,175 @@ static void swf_stroke(gfxdevice_t*dev, gfxline_t*line, gfxcoord_t width, gfxcol
 
     /* TODO: * split line into segments, and perform this check for all segments */
 
-    if(i->config_disable_polygon_conversion ||
+    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;
@@ -2389,7 +2711,7 @@ static SWFFONT* gfxfont_to_swffont(gfxfont_t*font, char* id)
     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);
@@ -2403,24 +2725,32 @@ static SWFFONT* gfxfont_to_swffont(gfxfont_t*font, char* id)
     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);
+	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) {
@@ -2432,16 +2762,16 @@ static SWFFONT* gfxfont_to_swffont(gfxfont_t*font, char* id)
 	}
 	draw.finish(&draw);
 	swffont->glyph[t].shape = swf_ShapeDrawerToShape(&draw);
-	swffont->layout->bounds[t] = swf_ShapeDrawerGetBBox(&draw);
 
-	if(swffont->layout->bounds[t].xmax && swffont->layout->bounds[t].xmax*2 < advance) {
-	    printf("fix bad advance value: bbox=%d, advance=%d (%f)\n", swffont->layout->bounds[t].xmax, advance, font->glyphs[t].advance);
-	    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;
 	}
 
@@ -2449,36 +2779,69 @@ static SWFFONT* gfxfont_to_swffont(gfxfont_t*font, char* id)
 
 	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;
@@ -2490,7 +2853,7 @@ static void swf_addfont(gfxdevice_t*dev, char*fontid, gfxfont_t*font)
     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);
@@ -2514,7 +2877,7 @@ static void swf_addfont(gfxdevice_t*dev, char*fontid, gfxfont_t*font)
     }
 }
 
-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;
 
@@ -2533,37 +2896,82 @@ static void swf_switchfont(gfxdevice_t*dev, char*fontid)
     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);
 
-    drawchar(dev, i->swffont, glyph, &m, color);
+    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);
+
+    putcharacter(dev, i->swffont->id, glyph, x, y, i->current_font_size, *(RGBA*)color);
+    swf_FontUseGlyph(i->swffont, glyph);
+    return;
 }