{ int i,j;
if ((!f)||(!use)) return -1;
+ /* TODO: layout, glyphnames */
j = 0;
for (i=0;i<f->numchars;i++)
if (f->glyph[i].shape)
return j;
}
+void swf_FontSort(SWFFONT * font)
+{
+ if(!font) return;
+ int i,j,k;
+ int* newplace = malloc(sizeof(int)*font->numchars);
+ int* newpos;
+
+ for(i=0;i<font->numchars;i++) {
+ newplace[i] = i;
+ }
+ for(i=0;i<font->numchars;i++)
+ for(j=0;j<i;j++) {
+ if(font->glyph2ascii[i] < font->glyph2ascii[j]) {
+ int n1,n2;
+ char* c1,*c2;
+ SWFGLYPH g1,g2;
+ SRECT r1,r2;
+ n1=newplace[i];
+ n2=newplace[j];
+ newplace[j] = n1;
+ newplace[i] = n2;
+ n1=font->glyph2ascii[i];
+ n2=font->glyph2ascii[j];
+ font->glyph2ascii[j] = n1;
+ font->glyph2ascii[i] = n2;
+ g1=font->glyph[i];
+ g2=font->glyph[j];
+ font->glyph[j] = g1;
+ font->glyph[i] = g2;
+ if(font->glyphnames) {
+ c1 = font->glyphnames[i];
+ c2 = font->glyphnames[j];
+ font->glyphnames[j] = c1;
+ font->glyphnames[i] = c2;
+ }
+ if(font->layout) {
+ r1 = font->layout->bounds[i];
+ r2 = font->layout->bounds[j];
+ font->layout->bounds[j] = r1;
+ font->layout->bounds[i] = r2;
+ }
+ }
+ }
+ newpos = malloc(sizeof(int)*font->numchars);
+ for(i=0;i<font->numchars;i++) {
+ newpos[newplace[i]] = i;
+ }
+ for(i=0;i<font->maxascii;i++) {
+ if(font->ascii2glyph[i]>=0)
+ font->ascii2glyph[i] = newpos[font->ascii2glyph[i]];
+ }
+
+ free(newpos);
+ free(newplace);
+}
+
+void swf_FontPrepareForEditText(SWFFONT * font)
+{
+ if(!font->layout)
+ swf_FontCreateLayout(font);
+ swf_FontSort(font);
+}
int swf_FontInitUsage(SWFFONT* f, FONTUSAGE * use)
{ if (!use) return -1;
flags |= 4; //wide codecs
if(fontSize(f)>65535)
flags |= 8; //wide offsets
- flags |= 8; //FIXME: the above check doesn't work
+ flags |= 8|4; //FIXME: the above check doesn't work
if(f->encoding & FONT_ENCODING_ANSI)
flags |= 16; // ansi
/* font code table */
if(flags & 4) /* wide codes */ {
- for(t=0;t<f->numchars;t++) {
+ for(t=0;t<f->numchars;t++) {
swf_SetU16(tag,f->glyph2ascii[t]);
}
} else {
swf_SetU8(t,(flags&0xfe)|wide);
for (i=0;i<f->numchars;i++) {
- if (f->glyph[i].shape)
- wide?swf_SetU16(t,f->glyph2ascii[i]):
- swf_SetU8(t,f->glyph2ascii[i]);
+ if (f->glyph[i].shape) {
+ int g2a = f->glyph2ascii[i];
+ wide?swf_SetU16(t,g2a):swf_SetU8(t,g2a);
+ }
}
return 0;
if(f->glyphnames) {
int t;
for(t=0;t<f->numchars;t++) {
- free(f->glyphnames[t]);
+ if(f->glyphnames[t])
+ free(f->glyphnames[t]);
}
free(f->glyphnames);
}
return res;
}
+SRECT swf_TextCalculateBBoxUTF8(SWFFONT * font,U8 * s,int scale)
+{
+ int pos=0;
+ SRECT r;
+ swf_GetRect(0, &r);
+ while(*s) {
+ int c = readUTF8char(&s);
+ if(c < font->maxascii) {
+ int g = font->ascii2glyph[c];
+ if(g>=0) {
+ SRECT rn = font->layout->bounds[g];
+ rn.xmin = (rn.xmin * scale)/20/100 + pos;
+ rn.xmax = (rn.xmax * scale)/20/100 + pos;
+ rn.ymin = (rn.ymin * scale)/20/100;
+ rn.ymax = (rn.ymax * scale)/20/100;
+ swf_ExpandRect2(&r, &rn);
+ pos += (font->glyph[g].advance*scale)/20/100;
+ }
+ }
+ c++;
+ }
+ return r;
+}
+
+
SWFFONT* swf_ReadFont(char* filename)
{
int f;
swf_SetU16(t, WRITEFONTID);
swf_SetU16(t, font->numchars);
for(c=0;c<font->numchars;c++) {
- swf_SetString(t, font->glyphnames[c]);
+ if(font->glyphnames[c])
+ swf_SetString(t, font->glyphnames[c]);
+ else
+ swf_SetString(t, "");
}
}
U8 gbits, abits;
U8*c = (U8*)text;
int pos = 0;
- swf_GetRect(0, &r);
if(font->layout) {
- while(*c) {
- if(*c < font->maxascii) {
- int g = font->ascii2glyph[*c];
- if(g>=0) {
- SRECT rn = font->layout->bounds[g];
- rn.xmin = (rn.xmin * scale)/100 + pos;
- rn.xmax = (rn.xmax * scale)/100 + pos;
- rn.ymin = (rn.ymin * scale)/100;
- rn.ymax = (rn.ymax * scale)/100;
- swf_ExpandRect2(&r, &rn);
- pos += (font->glyph[g].advance*scale)/100;
- }
- }
- c++;
- }
+ r = swf_TextCalculateBBoxUTF8(font,text,scale*20);
} else {
+ fprintf(stderr, "No layout information- can't compute text bbox accurately");
/* Hm, without layout information, we can't compute a bounding
box. We could call swf_FontCreateLayout to create a layout,
but the caller probably doesn't want us to mess up his font
}
swf_SetRect(tag,&r);
- swf_SetMatrix(tag,NULL);
+
+ /* The text matrix is pretty boring, as it doesn't apply to
+ individual characters, but rather whole text objects (or
+ at least whole char records- haven't tested).
+ So it can't do anything which we can't already do with
+ the placeobject tag we use for placing the text on the scene.
+ */
+ swf_SetMatrix(tag,0);
+
swf_TextCountBitsUTF8(font,text,scale*20,&gbits,&abits);
swf_SetU8(tag,gbits);
swf_SetU8(tag,abits);
they are used)- we now have to guess whether that width might be possible,
which is the case if it isn't either much too big or much too small */
if(width > f->glyph[t].advance*3/2 ||
- width*2 < f->glyph[t].advance)
+ width < f->glyph[t].advance/2)
f->glyph[t].advance = width;
if(-bbox.ymin > f->layout->ascent)
}
}
-void swf_DrawText(drawer_t*draw, SWFFONT*font, char*text)
+void swf_DrawText(drawer_t*draw, SWFFONT*font, int size, char*text)
{
U8*s = (U8*)text;
int advance = 0;
U32 c = readUTF8char(&s);
int g = font->ascii2glyph[c];
shape = font->glyph[g].shape;
+ if(((int)g)<0) {
+ fprintf(stderr, "No char %d in font %s\n", c, font->name?(char*)font->name:"?");
+ continue;
+ }
shape2 = swf_ShapeToShape2(shape);
l = shape2->lines;
while(l) {
if(l->type == moveTo) {
FPOINT to;
- to.x = l->x/20.0+advance;
- to.y = l->y/20.0;
+ to.x = l->x*size/100.0/20.0+advance;
+ to.y = l->y*size/100.0/20.0;
draw->moveTo(draw, &to);
} else if(l->type == lineTo) {
FPOINT to;
- to.x = l->x/20.0+advance;
- to.y = l->y/20.0;
+ to.x = l->x*size/100.0/20.0+advance;
+ to.y = l->y*size/100.0/20.0;
draw->lineTo(draw, &to);
} else if(l->type == splineTo) {
FPOINT mid,to;
- mid.x = l->sx/20.0+advance;
- mid.y = l->sy/20.0;
- to.x = l->x/20.0+advance;
- to.y = l->y/20.0;
+ mid.x = l->sx*size/100.0/20.0+advance;
+ mid.y = l->sy*size/100.0/20.0;
+ to.x = l->x*size/100.0/20.0+advance;
+ to.y = l->y*size/100.0/20.0;
draw->splineTo(draw, &mid, &to);
}
l = l->next;
}
swf_Shape2Free(shape2);
- advance += font->glyph[g].advance/20.0;
+ advance += font->glyph[g].advance*size/100.0/20.0;
}
}
git.asbjorn.biz / swftools.git / blobdiff