#include "../gfxdevice.h"
#include "../gfxtools.h"
#include "../art/libart.h"
+#include "artsutils.c"
#define CHARDATAMAX 8192
#define CHARMIDX 0
int config_filloverlap;
int config_protect;
int config_bboxvars;
+ int config_disable_polygon_conversion;
RGBA config_linkcolor;
float config_minlinewidth;
double config_caplinewidth;
char* config_linktarget;
+ char*config_internallinkfunction;
+ char*config_externallinkfunction;
SWF* swf;
int shapeposx;
int shapeposy;
+ char* mark;
+
} swfoutput_internal;
static void swf_fillbitmap(gfxdevice_t*driver, gfxline_t*line, gfximage_t*img, gfxmatrix_t*move, gfxcxform_t*cxform);
static void swf_fill(gfxdevice_t*dev, gfxline_t*line, gfxcolor_t*color);
static void swf_fillbitmap(gfxdevice_t*dev, gfxline_t*line, gfximage_t*img, gfxmatrix_t*matrix, gfxcxform_t*cxform);
static void swf_fillgradient(gfxdevice_t*dev, gfxline_t*line, gfxgradient_t*gradient, gfxgradienttype_t type, gfxmatrix_t*matrix);
-static void swf_drawchar(gfxdevice_t*dev, char*fontid, int glyph, gfxcolor_t*color, gfxmatrix_t*matrix);
-static void swf_addfont(gfxdevice_t*dev, char*fontid, gfxfont_t*font);
+static void swf_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_startframe(gfxdevice_t*dev, int width, int height);
static void swf_endframe(gfxdevice_t*dev);
i->frameno = 0;
i->lastframeno = 0;
+ i->mark = 0;
+
i->fillstyleid;
i->linestyleid;
i->swflastx=0;
i->config_minlinewidth=0.05;
i->config_caplinewidth=1;
i->config_linktarget=0;
+ i->config_internallinkfunction=0;
+ i->config_externallinkfunction=0;
i->config_linkcolor.r = i->config_linkcolor.g = i->config_linkcolor.b = 255;
i->config_linkcolor.a = 0x40;
{
swfoutput_internal*i = (swfoutput_internal*)dev->internal;
if(i->currentswfid == 65535) {
- if(!id_error)
+ if(!id_error) {
msg("<error> ID Table overflow");
+ msg("<error> This file is too complex to render- SWF only supports 65536 shapes at once");
+ }
id_error=1;
i->overflow = 1;
+ exit(1);
}
return ++i->currentswfid;
}
{
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);
}
return ++i->depth;
}
i->swflastx += ex;
i->swflasty += ey;
- if(cx || cy || ex || ey) {
- swf_ShapeSetCurve(tag, i->shape, cx,cy,ex,ey);
- addPointToBBox(dev, lastlastx ,lastlasty );
- addPointToBBox(dev, lastlastx+cx,lastlasty+cy);
- addPointToBBox(dev, lastlastx+cx+ex,lastlasty+cy+ey);
- }/* else if(!i->fill) {
- // treat splines of length 0 as plots
- plot(dev, lastlastx, lastlasty, tag);
- }*/
+ if((cx || cy) && (ex || ey)) {
+ swf_ShapeSetCurve(tag, i->shape, cx,cy,ex,ey);
+ addPointToBBox(dev, lastlastx ,lastlasty );
+ addPointToBBox(dev, lastlastx+cx,lastlasty+cy);
+ addPointToBBox(dev, lastlastx+cx+ex,lastlasty+cy+ey);
+ } else if(cx || cy || ex || ey) {
+ swf_ShapeSetLine(tag, i->shape, cx+ex,cy+ey);
+ addPointToBBox(dev, lastlastx ,lastlasty );
+ addPointToBBox(dev, lastlastx+cx,lastlasty+cy);
+ addPointToBBox(dev, lastlastx+cx+ex,lastlasty+cy+ey);
+ }
+
i->shapeisempty = 0;
}
static void stopFill(gfxdevice_t*dev)
{
swfoutput_internal*i = (swfoutput_internal*)dev->internal;
- if(i->lastwasfill)
+ if(i->lastwasfill!=0)
{
swf_ShapeSetStyle(i->tag,i->shape,i->linestyleid,0x8000,0);
i->fillstylechanged = 1;
static void startFill(gfxdevice_t*dev)
{
swfoutput_internal*i = (swfoutput_internal*)dev->internal;
- if(!i->lastwasfill)
+ if(i->lastwasfill!=1)
{
swf_ShapeSetStyle(i->tag,i->shape,0x8000,i->fillstyleid,0);
i->fillstylechanged = 1;
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;
if(i->textid>=0)
endtext(dev);
- i->tag = swf_InsertTag(i->tag,ST_DEFINESHAPE);
+ i->tag = swf_InsertTag(i->tag,ST_DEFINESHAPE3);
swf_ShapeNew(&i->shape);
i->linestyleid = swf_ShapeAddLineStyle(i->shape,i->linewidth,&i->strokergb);
i->fillstyleid = swf_ShapeAddSolidFillStyle(i->shape,&i->fillrgb);
+ if(i->mark) {
+ RGBA markcol = {0,i->mark[0],i->mark[1],i->mark[2]};
+ swf_ShapeAddSolidFillStyle(i->shape,&markcol);
+ }
i->shapeid = getNewID(dev);
swf_SetShapeBits(i->tag,i->shape);
/* TODO: do we really need this? */
- swf_ShapeSetAll(i->tag,i->shape,/*x*/0,/*y*/0,i->linestyleid,0,0);
- i->swflastx=i->swflasty=0;
- i->lastwasfill = 0;
+ //swf_ShapeSetAll(i->tag,i->shape,/*x*/0,/*y*/0,i->linestyleid,0,0);
+ //swf_ShapeSetAll(i->tag,i->shape,/*x*/UNDEFINED_COORD,/*y*/UNDEFINED_COORD,i->linestyleid,0,0);
+ i->swflastx=i->swflasty=UNDEFINED_COORD;
+ i->lastwasfill = -1;
i->shapeisempty = 1;
}
if(i->shape) {swf_ShapeFree(i->shape);i->shape=0;}
i->shapeid = -1;
i->bboxrectpos = -1;
+
+// i->currentswfid--; // this was an *exceptionally* bad idea
}
void fixAreas(gfxdevice_t*dev)
if(i->linewidth==0) i->linewidth = 1;
startshape(dev);
+ stopFill(dev);
moveto(dev, i->tag, r.xmin/20.0,r.ymin/20.0);
lineto(dev, i->tag, r.xmax/20.0,r.ymax/20.0);
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;
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(i->config_storeallcharacters || used) {
+ mtag = swf_InsertTag(mtag, ST_DEFINEFONT2);
+ swf_FontSetDefine2(mtag, iterator->swffont);
+ }
}
iterator = iterator->next;
if(i->config_enablezlib || i->config_flashversion>=6) {
i->swf->compressed = 1;
}
+
+ swf_Optimize(i->swf);
}
int swfresult_save(gfxresult_t*gfx, char*filename)
if(url[t]<'0' || url[t]>'9')
nodigit = 1;
if(!nodigit) {
- int page = atoi(&url[4]) - 1;
+ int page = atoi(&url[4]);
if(page<0) page = 0;
swfoutput_linktopage(dev, page, points);
}
}
void swfoutput_linktourl(gfxdevice_t*dev, char*url, gfxline_t*points)
{
- ActionTAG* actions;
+ ActionTAG* actions = 0;
swfoutput_internal*i = (swfoutput_internal*)dev->internal;
if(i->shapeid>=0)
endshape(dev);
if(i->textid>=0)
endtext(dev);
-
- if(!i->config_linktarget) {
+
+ if(i->config_externallinkfunction) {
+ actions = action_PushString(actions, url); //parameter
+ actions = action_PushInt(actions, 1); //number of parameters (1)
+ actions = action_PushString(actions, i->config_externallinkfunction); //function name
+ actions = action_CallFunction(actions);
+ } else if(!i->config_linktarget) {
if(!i->config_opennewwindow)
- actions = action_GetUrl(0, url, "_parent");
+ actions = action_GetUrl(actions, url, "_parent");
else
- actions = action_GetUrl(0, url, "_this");
+ actions = action_GetUrl(actions, url, "_this");
} else {
- actions = action_GetUrl(0, url, i->config_linktarget);
+ actions = action_GetUrl(actions, url, i->config_linktarget);
}
actions = action_End(actions);
void swfoutput_linktopage(gfxdevice_t*dev, int page, gfxline_t*points)
{
swfoutput_internal*i = (swfoutput_internal*)dev->internal;
- ActionTAG* actions;
+ ActionTAG* actions = 0;
if(i->shapeid>=0)
endshape(dev);
if(i->textid>=0)
endtext(dev);
-
- actions = action_GotoFrame(0, page);
- actions = action_End(actions);
+
+ if(!i->config_internallinkfunction) {
+ actions = action_GotoFrame(actions, page-1);
+ actions = action_End(actions);
+ } else {
+ actions = action_PushInt(actions, page); //parameter
+ actions = action_PushInt(actions, 1); //number of parameters (1)
+ actions = action_PushString(actions, i->config_internallinkfunction); //function name
+ actions = action_CallFunction(actions);
+ actions = action_End(actions);
+ }
drawlink(dev, actions, 0, points,0);
}
actions1 = action_PushInt(0, 0); //number of parameters (0)
actions1 = action_PushString(actions1, &tmp[5]); //function name
actions1 = action_CallFunction(actions1);
+ actions1 = action_End(actions1);
} else {
*x = 0;
actions1 = action_PushString(0, x+1); //parameter
actions1 = action_PushInt(actions1, 1); //number of parameters (1)
actions1 = action_PushString(actions1, &tmp[5]); //function name
actions1 = action_CallFunction(actions1);
+ actions1 = action_End(actions1);
}
actions2 = action_End(0);
mouseover = 0;
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);
}
{
swfoutput_internal*i = (swfoutput_internal*)dev->internal;
+ msg("<trace> swfdevice: %s=%s", name, value);
if(!strcmp(name, "jpegsubpixels")) {
i->config_jpegsubpixels = atof(value);
} else if(!strcmp(name, "ppmsubpixels")) {
i->config_drawonlyshapes = atoi(value);
} else if(!strcmp(name, "ignoredraworder")) {
i->config_ignoredraworder = atoi(value);
+ } else if(!strcmp(name, "mark")) {
+ if(!value || !value[0]) {
+ if(i->mark) free(i->mark);
+ i->mark = 0;
+ } else {
+ int t;
+ i->mark = strdup("...");
+ for(t=0;t<3;t++) if(value[t]) i->mark[t] = value[t];
+ }
} else if(!strcmp(name, "filloverlap")) {
i->config_filloverlap = atoi(value);
} else if(!strcmp(name, "linksopennewwindow")) {
i->config_enablezlib = atoi(value);
} else if(!strcmp(name, "bboxvars")) {
i->config_bboxvars = atoi(value);
+ } else if(!strcmp(name, "internallinkfunction")) {
+ i->config_internallinkfunction = strdup(value);
+ } else if(!strcmp(name, "externallinkfunction")) {
+ i->config_externallinkfunction = strdup(value);
+ } else if(!strcmp(name, "disable_polygon_conversion")) {
+ i->config_disable_polygon_conversion = atoi(value);
} else if(!strcmp(name, "insertstop")) {
i->config_insertstoptag = atoi(value);
} else if(!strcmp(name, "protect")) {
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)
{
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);
}
int myshapeid = getNewID(dev);
- i->tag = swf_InsertTag(i->tag,ST_DEFINESHAPE);
+ i->tag = swf_InsertTag(i->tag,ST_DEFINESHAPE3);
RGBA col;
memset(&col, 0, sizeof(RGBA));
+ col.a = 255;
SHAPE*shape;
swf_ShapeNew(&shape);
int fsid = swf_ShapeAddSolidFillStyle(shape,&col);
+ if(i->mark) {
+ RGBA markcol = {0,i->mark[0],i->mark[1],i->mark[2]};
+ swf_ShapeAddSolidFillStyle(shape,&markcol);
+ }
swf_SetU16(i->tag,myshapeid);
SRECT r = gfxline_getSWFbbox(line);
swf_SetRect(i->tag,&r);
int lines=0;
int splines=0;
int haszerosegments=0;
+ int length=0;
while(line) {
if(line->type == gfx_moveTo) {
tmplines=0;
if(tmpsplines>lines)
splines=tmpsplines;
}
+ length++;
line = line->next;
}
+ if(length>400)
+ return 5;
if(lines==0 && splines==0) return 0;
else if(lines==1 && splines==0) return 1;
else if(lines==0 && splines==1) return 2;
static int gfxline_has_dots(gfxline_t*line)
{
int tmplines=0;
- double x,y;
+ double x=0,y=0;
double dist = 0;
int isline = 0;
+ int short_gap = 0;
while(line) {
if(line->type == gfx_moveTo) {
- if(isline && dist < 1) {
+ /* test the length of the preceding line, and assume it is a dot if
+ it's length is less than 1.0. But *only* if there's a noticable
+ gap between the previous line and the next moveTo. (I've come
+ across a PDF where thousands of "dots" were stringed together,
+ forming a line) */
+ int last_short_gap = short_gap;
+ if((fabs(line->x - x) + fabs(line->y - y)) < 1.0) {
+ short_gap = 1;
+ } else {
+ short_gap = 0;
+ }
+ if(isline && dist < 1 && !short_gap && !last_short_gap) {
return 1;
}
dist = 0;
y = line->y;
line = line->next;
}
- if(isline && dist < 1) {
+ if(isline && dist < 1 && !short_gap) {
return 1;
}
return 0;
return 1;
}
-static void show_path(ArtSVP*path)
-{
- int t;
- printf("Segments: %d\n", path->n_segs);
- for(t=0;t<path->n_segs;t++) {
- ArtSVPSeg* seg = &path->segs[t];
- printf("Segment %d: %d points, %s, BBox: (%f,%f,%f,%f)\n",
- t, seg->n_points, seg->dir==0?"UP ":"DOWN",
- seg->bbox.x0, seg->bbox.y0, seg->bbox.x1, seg->bbox.y1);
- int p;
- for(p=0;p<seg->n_points;p++) {
- ArtPoint* point = &seg->points[p];
- printf(" (%f,%f)\n", point->x, point->y);
- }
- }
- printf("\n");
-}
-
gfxline_t* gfxline_move(gfxline_t*line, double x, double y)
{
gfxline_t*l = line = gfxline_clone(line);
static void swf_stroke(gfxdevice_t*dev, gfxline_t*line, gfxcoord_t width, gfxcolor_t*color, gfx_capType cap_style, gfx_joinType joint_style, gfxcoord_t miterLimit)
{
swfoutput_internal*i = (swfoutput_internal*)dev->internal;
+ if(line_is_empty(line))
+ return;
int type = gfxline_type(line);
int has_dots = gfxline_has_dots(line);
gfxbbox_t r = gfxline_getbbox(line);
/* TODO: * split line into segments, and perform this check for all segments */
- if(!has_dots &&
- (width <= i->config_caplinewidth
+ if(i->config_disable_polygon_conversion || type>=5 ||
+ (!has_dots &&
+ (width <= i->config_caplinewidth
|| (cap_style == gfx_capRound && joint_style == gfx_joinRound)
- || (cap_style == gfx_capRound && type<=2))) {} else
+ || (cap_style == gfx_capRound && type<=2)))) {} else
{
/* convert line to polygon */
msg("<trace> draw as polygon, type=%d dots=%d", type, has_dots);
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);
}
static void swf_fillgradient(gfxdevice_t*dev, gfxline_t*line, gfxgradient_t*gradient, gfxgradienttype_t type, gfxmatrix_t*matrix)
{
+ if(line_is_empty(line))
+ return;
msg("<error> Gradient filling not implemented yet");
}
{
SWFFONT*swffont = (SWFFONT*)rfx_calloc(sizeof(SWFFONT));
int t;
+ SRECT bounds = {0,0,0,0};
swffont->id = -1;
swffont->version = 2;
swffont->name = (U8*)strdup(id);
for(t=0;t<font->num_glyphs;t++) {
drawer_t draw;
gfxline_t*line;
+ int advance = 0;
swffont->glyph2ascii[t] = font->glyphs[t].unicode;
if(font->glyphs[t].name) {
swffont->glyphnames[t] = strdup(font->glyphs[t].name);
} else {
swffont->glyphnames[t] = 0;
}
- swffont->glyph[t].advance = (int)(font->glyphs[t].advance * 20);
+ advance = (int)(font->glyphs[t].advance);
swf_Shape01DrawerInit(&draw, 0);
line = font->glyphs[t].line;
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;
+ }
+
+ if(advance<32768) {
+ swffont->glyph[t].advance = advance;
+ } else {
+ swffont->glyph[t].advance = 32767;
+ }
+
draw.dealloc(&draw);
+
+ 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;
+ }
+
return swffont;
}
-static void swf_addfont(gfxdevice_t*dev, char*fontid, gfxfont_t*font)
+static void swf_addfont(gfxdevice_t*dev, gfxfont_t*font)
{
swfoutput_internal*i = (swfoutput_internal*)dev->internal;
- if(i->swffont && i->swffont->name && !strcmp((char*)i->swffont->name,fontid))
+ if(i->swffont && i->swffont->name && !strcmp((char*)i->swffont->name,font->id))
return; // the requested font is the current font
fontlist_t*last=0,*l = i->fontlist;
while(l) {
last = l;
- if(!strcmp((char*)l->swffont->name, fontid)) {
+ if(!strcmp((char*)l->swffont->name, font->id)) {
return; // we already know this font
}
l = l->next;
}
l = (fontlist_t*)rfx_calloc(sizeof(fontlist_t));
- l->swffont = gfxfont_to_swffont(font, fontid);
+ l->swffont = gfxfont_to_swffont(font, font->id);
l->next = 0;
if(last) {
last->next = l;
if(getScreenLogLevel() >= LOGLEVEL_DEBUG) {
int iii;
// print font information
- msg("<debug> Font %s",fontid);
+ msg("<debug> Font %s",font->id);
msg("<debug> | ID: %d", l->swffont->id);
msg("<debug> | Version: %d", l->swffont->version);
msg("<debug> | Name: %s", l->swffont->name);
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(!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);