int config_enablezlib;
int config_insertstoptag;
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;
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;
char overflow;
+ int current_font_size;
MATRIX fontmatrix;
- double fontm11,fontm12,fontm21,fontm22;
+ double lastfontm11,lastfontm12,lastfontm21,lastfontm22;
SWFFONT *swffont;
RGBA strokergb;
RGBA fillrgb;
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, 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, char*action);
+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->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_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);
{
swfoutput_internal*i = (swfoutput_internal*)dev->internal;
if(i->depth == 65535) {
- if(!id_error)
+ 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);
/* 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
+#define GLYPH_SCALE 1
/* process a character. */
-static int drawchar(gfxdevice_t*dev, SWFFONT *swffont, int charid, swfmatrix_t*m, gfxcolor_t*col)
+static int drawchar(gfxdevice_t*dev, SWFFONT *swffont, int charid, float x, float y, gfxcolor_t*col)
{
swfoutput_internal*i = (swfoutput_internal*)dev->internal;
if(!swffont) {
}
if(charid<0 || charid>=swffont->numchars) {
- msg("<warning> No character %d in font %s ", charid, FIXNULL((char*)swffont->name));
+ msg("<warning> No character %d in font %s (%d chars)", charid, FIXNULL((char*)swffont->name), swffont->numchars);
return 0;
}
/*if(swffont->glyph[charid].shape->bitlen <= 16) {
if(i->textid<0)
starttext(dev);
- float x = m->m31;
- float y = m->m32;
- float det = ((m->m11*m->m22)-(m->m21*m->m12));
+ 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 */
return 1;
}
- det = 20*FONT_INTERNAL_SIZE / det;
+ det = 20 * GLYPH_SCALE / det;
SPOINT p;
- p.x = (SCOORD)(( x * m->m22 - y * m->m12)*det);
- p.y = (SCOORD)((- x * m->m21 + y * m->m11)*det);
+ p.x = (SCOORD)(( x * i->fontmatrix.sy/65536.0 - y * i->fontmatrix.r1/65536.0)*det);
+ p.y = (SCOORD)((- x * i->fontmatrix.r0/65536.0 + y * i->fontmatrix.sx/65536.0)*det);
RGBA rgba = *(RGBA*)col;
- putcharacter(dev, swffont->id, charid,p.x,p.y,FONT_INTERNAL_SIZE, rgba);
+ putcharacter(dev, swffont->id, charid,p.x,p.y,i->current_font_size, rgba);
swf_FontUseGlyph(swffont, charid);
return 1;
}
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;
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)
{
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)
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.sx = (U32)((m11*ifs)*65536); m.r1 = (U32)((m21*ifs)*65536);
+ m.r0 = (U32)((m12*ifs)*65536); m.sy = (U32)((m22*ifs)*65536);
m.tx = 0;
m.ty = 0;
i->fontmatrix = m;
void gfxdevice_swf_init(gfxdevice_t* dev)
{
memset(dev, 0, sizeof(gfxdevice_t));
+
+ dev->name = "swf";
+
dev->internal = init_internal_struct();
dev->startpage = swf_startframe;
i->swf = (SWF*)rfx_calloc(sizeof(SWF));
i->swf->fileVersion = i->config_flashversion;
- i->swf->frameRate = 0x0040; // 1 frame per 4 seconds
+ i->swf->frameRate = i->config_framerate*0x100;
i->swf->movieSize.xmin = 0;
i->swf->movieSize.ymin = 0;
i->swf->movieSize.xmax = 0;
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);
changeRect(dev, i->tag, i->bboxrectpos, &i->bboxrect);
- 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;
if(i->config_enablezlib || i->config_flashversion>=6) {
i->swf->compressed = 1;
}
+
+// 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;
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")) {
static void drawlink(gfxdevice_t*dev, ActionTAG*,ActionTAG*, gfxline_t*points, char mouseover);
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;
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;
swfoutput_internal*i = (swfoutput_internal*)dev->internal;
gfxcoord_t lastx=0,lasty=0,px=0,py=0;
char lastwasmoveto;
+ int lines= 0, splines=0;
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);
}
}
}
+ msg("<trace> Placing link ID %d", buttonid);
i->tag = swf_InsertTag(i->tag,ST_PLACEOBJECT2);
if(posx!=0 || posy!=0) {
i->config_enablezlib = atoi(value);
} else if(!strcmp(name, "bboxvars")) {
i->config_bboxvars = 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, "insertstop")) {
i->config_insertstoptag = atoi(value);
} else if(!strcmp(name, "protect")) {
if(i->swf) {
i->swf->fileVersion = i->config_flashversion;
}
+ } else if(!strcmp(name, "framerate")) {
+ i->config_framerate = atoi(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_linktarget = strdup(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, "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.a);
} 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;
}
/// {
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,*/
swf_ShapeSetEnd(i->tag);
swf_ShapeFree(shape);
+ msg("<trace> Placing bitmap ID %d", myshapeid);
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);
+ 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);
+ 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;
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);
swf_SetShapeBits(i->tag,shape);
swf_ShapeSetAll(i->tag,shape,UNDEFINED_COORD,UNDEFINED_COORD,0,fsid,0);
i->swflastx = i->swflasty = UNDEFINED_COORD;
+ i->shapeisempty = 1;
drawgfxline(dev, line);
+ 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);
+ }
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;
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);
stopFill(dev);
drawgfxline(dev, line);
-#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);
drawgfxline(dev, line);
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 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");
}
-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;
gfxline_t*line;
int 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 {
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) {
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;
+ int xmax = swffont->layout->bounds[t].xmax / 20;
+ if(xmax>0 && xmax*2 < advance) {
+ printf("fix bad advance value: bbox=%d, advance=%d (%f)\n", xmax, advance, font->glyphs[t].advance);
+ advance = xmax;
}
if(advance<32768) {
}
}
-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;
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(!font)
+ return;
if(!i->swffont || !i->swffont->name || strcmp((char*)i->swffont->name,font->id)) // not equal to 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;
-
+ setfontscale(dev, matrix->m00, matrix->m01, matrix->m10, matrix->m11);
+
/* printf("%f %f\n", m.m31, m.m32);
{
static int xpos = 40;
}*/
- drawchar(dev, i->swffont, glyph, &m, color);
+ drawchar(dev, i->swffont, glyph, matrix->tx, matrix->ty, color);
}