Part of the swftools package.
Copyright (c) 2001 Rainer Böhme <rfxswf@reflex-studio.de>
+ Copyright (c) 2003,2004 Matthias Kramm
- This file is distributed under the GPL, see file COPYING for details
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
-*/
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
#define TF_TEXTCONTROL 0x80
#define TF_HASFONT 0x08
#define FF2_SHIFTJIS 0x40
#define FF2_LAYOUT 0x80
-int swf_FontIsItalic(SWFFONT * f) { return f->version==2?f->flags&FF2_ITALIC:f->flags&FF_ITALIC; }
-int swf_FontIsBold(SWFFONT * f) { return f->version==2?f->flags&FF2_BOLD:f->flags&FF_BOLD; }
+int swf_FontIsItalic(SWFFONT * f) { return f->style&FONT_STYLE_ITALIC;}
+int swf_FontIsBold(SWFFONT * f) { return f->style&FONT_STYLE_BOLD;}
static const int WRITEFONTID = 0x4e46; // font id for WriteFont and ReadFont
n = 0;
while (t)
- { if (swf_GetTagID(t)==ST_DEFINEFONTINFO ||
+ { if (swf_GetTagID(t)==ST_DEFINEFONTINFO || swf_GetTagID(t)==ST_DEFINEFONTINFO2 ||
swf_GetTagID(t)==ST_DEFINEFONT2)
{ n++;
if (FontCallback)
fid = swf_GetU16(t);
if ((!id)||(id==fid))
- { U16 of,*ofs;
+ { U16 of;
int n,i;
id = fid;
int swf_FontExtract_DefineFontInfo(int id,SWFFONT * f,TAG * t)
{ U16 fid;
U16 maxcode;
+ U8 flags;
swf_SaveTagPos(t);
swf_SetTagPos(t,0);
- if(f->version>1) {
- // DefineFont2 doesn't have FontInfo fields
- fprintf(stderr, "fixme: FontInfo field for DefineFont2 encountered\n");
- return -1;
- }
-
fid = swf_GetU16(t);
if (fid==id)
{ U8 l = swf_GetU8(t);
int i;
+
+ if(f->version>1) {
+ /* Especially with Flash MX, DefineFont2 may have FontInfo fields,
+ too. However, they only add little information to what's already
+ inside the DefineFont2 tag */
+ return id;
+ }
- if (l)
- { if (f->name) free(f->name);
- f->name = (U8*)malloc(l+1);
- if (f->name)
- { swf_GetBlock(t,f->name,l);
- f->name[l] = 0;
- }
- else
- { swf_RestoreTagPos(t);
- return -1;
- }
+ if (f->name) free(f->name);
+
+ f->name = (U8*)malloc(l+1);
+ swf_GetBlock(t,f->name,l);
+ f->name[l] = 0;
+
+ flags = swf_GetU8(t);
+ if(flags & 2)
+ f->style |= FONT_STYLE_BOLD;
+ if(flags & 4)
+ f->style |= FONT_STYLE_ITALIC;
+ if(flags & 8)
+ f->encoding |= FONT_ENCODING_ANSI;
+ if(flags & 16)
+ f->encoding |= FONT_ENCODING_SHIFTJIS;
+ if(flags & 32)
+ f->encoding |= FONT_ENCODING_UNICODE;
+
+ if(t->id == ST_DEFINEFONTINFO2) {
+ f->language = swf_GetU8(t);
}
- f->flags = swf_GetU8(t);
f->glyph2ascii = (U16*)malloc(sizeof(U16)*f->numchars);
maxcode = 0;
for(i=0; i < f->numchars; i++) {
- f->glyph2ascii[i] = ((f->flags&FF_WIDECODES)?swf_GetU16(t):swf_GetU8(t));
+ f->glyph2ascii[i] = ((flags&FF_WIDECODES)?swf_GetU16(t):swf_GetU8(t));
if(f->glyph2ascii[i] > maxcode)
maxcode = f->glyph2ascii[i];
}
return id;
}
+int swf_FontExtract_GlyphNames(int id,SWFFONT * f,TAG * tag)
+{
+ U16 fid;
+ U16 maxcode;
+ U8 flags;
+ swf_SaveTagPos(tag);
+ swf_SetTagPos(tag,0);
+
+ fid = swf_GetU16(tag);
+
+ if (fid==id)
+ {
+ int num = swf_GetU16(tag);
+ int t;
+ f->glyphnames = malloc(sizeof(char*)*num);
+ for(t=0;t<num;t++) {
+ f->glyphnames[t] = strdup(swf_GetString(tag));
+ }
+ }
+
+ swf_RestoreTagPos(tag);
+ return id;
+}
+
+
int swf_FontExtract_DefineFont2(int id,SWFFONT * font,TAG * tag)
{
int t, glyphcount;
font->version=2;
fid = swf_GetU16(tag);
if(id && id!=fid)
- return;
+ return id;
font->id = fid;
flags1 = swf_GetU8(tag);
flags2 = swf_GetU8(tag); //reserved flags
+
+ if(flags1 & 1)
+ font->style |= FONT_STYLE_BOLD;
+ if(flags1 & 2)
+ font->style |= FONT_STYLE_ITALIC;
+ if(flags1 & 16)
+ font->encoding |= FONT_ENCODING_ANSI;
+ if(flags1 & 32)
+ font->encoding |= FONT_ENCODING_UNICODE;
+ if(flags1 & 64)
+ font->encoding |= FONT_ENCODING_SHIFTJIS;
+
namelen = swf_GetU8(tag);
- font->flags = flags1;
font->name = (U8*)malloc(namelen+1);
font->name[namelen]=0;
swf_GetBlock(tag, font->name, namelen);
if(flags1&8) { // wide offsets
for(t=0;t<glyphcount;t++)
swf_GetU32(tag); //offset[t]
- swf_GetU32(tag); // fontcodeoffset
+
+ if(glyphcount) /* this _if_ is not in the specs */
+ swf_GetU32(tag); // fontcodeoffset
} else {
for(t=0;t<glyphcount;t++)
swf_GetU16(tag); //offset[t]
- swf_GetU16(tag); // fontcodeoffset
+
+ if(glyphcount) /* this _if_ is not in the specs */
+ swf_GetU16(tag); // fontcodeoffset
}
for(t=0;t<glyphcount;t++)
swf_GetSimpleShape(tag,&(font->glyph[t].shape));
font->layout->bounds = malloc(glyphcount*sizeof(SRECT));
for(t=0;t<glyphcount;t++) {
swf_ResetReadBits(tag);
- swf_GetRect(tag, font->layout->bounds);
+ swf_GetRect(tag, &font->layout->bounds[t]);
}
+
kerningcount = swf_GetU16(tag);
font->layout->kerningcount = kerningcount;
+
font->layout->kerning = (SWFKERNING*)malloc(sizeof(SWFKERNING)*kerningcount);
if(kerningcount) {
font->layout->kerning =
#define FEDTJ_PRINT 0x01
#define FEDTJ_MODIFY 0x02
+#define FEDTJ_CALLBACK 0x04
-int swf_FontExtract_DefineText(int id,SWFFONT * f,TAG * t,int jobs)
+int swf_FontExtract_DefineTextCallback(int id,SWFFONT * f,TAG * t,int jobs,
+ void(*callback)(int*chars, int nr, int fontid))
{ U16 cid;
SRECT r;
MATRIX m;
flags = swf_GetU8(t);
while(flags)
- { if (flags&TF_TEXTCONTROL)
+ {
+ // FIXME: according to open-swf@macromedia.com, this is wrong.
+ // it should alternate textcontrol and text arrays, not
+ // rely on the high bit. (and length can be 0-255).
+ if (flags&TF_TEXTCONTROL)
{ if (flags&TF_HASFONT) fid = swf_GetU16(t);
if (flags&TF_HASCOLOR)
{ swf_GetU8(t); // rgb
}
else
{ int i;
+ int buf[256];
for (i=0;i<flags;i++)
{ int glyph;
int adv;
glyph = swf_GetBits(t,gbits);
adv = swf_GetBits(t,abits);
if (id==fid) // mitlesen ?
- { int code = f->glyph2ascii[glyph];
- if (jobs&FEDTJ_PRINT) printf("%c",code);
+ if (jobs&FEDTJ_PRINT) {
+ { int code = f->glyph2ascii[glyph];
+ printf("%c",code);
+ }
if (jobs&FEDTJ_MODIFY)
/*if (!f->glyph[code].advance)*/ f->glyph[glyph].advance = adv;
}
+ buf[i] = glyph;
}
if ((id==fid)&&(jobs&FEDTJ_PRINT)) printf("\n");
+ if (jobs&FEDTJ_CALLBACK)
+ callback(buf, flags, fid);
}
flags = swf_GetU8(t);
}
return id;
}
+int swf_FontExtract_DefineText(int id,SWFFONT * f,TAG * t,int jobs)
+{
+ return swf_FontExtract_DefineTextCallback(id,f,t,jobs,0);
+}
+
int swf_FontExtract(SWF * swf,int id,SWFFONT * * font)
{ TAG * t;
SWFFONT * f;
if ((!swf)||(!font)) return -1;
- f = (SWFFONT *)malloc(sizeof(SWFFONT)); font[0] = f;
- if (!f) return -1;
-
+ f = (SWFFONT *)malloc(sizeof(SWFFONT));
memset(f,0x00,sizeof(SWFFONT));
t = swf->firstTag;
break;
case ST_DEFINEFONTINFO:
+ case ST_DEFINEFONTINFO2:
nid = swf_FontExtract_DefineFontInfo(id,f,t);
break;
case ST_DEFINETEXT2:
nid = swf_FontExtract_DefineText(id,f,t,f->layout?0:FEDTJ_MODIFY);
break;
+
+ case ST_GLYPHNAMES:
+ nid = swf_FontExtract_GlyphNames(id,f,t);
+ break;
}
if (nid>0) id = nid;
t = swf_NextTag(t);
}
+ if(f->id != id) {
+ free(f);
+ f=0;
+ }
+ font[0] = f;
return 0;
}
int swf_FontSetID(SWFFONT * f,U16 id) { if (!f) return -1; f->id = id; return 0; }
int swf_FontReduce(SWFFONT * f,FONTUSAGE * use)
-{ int i,j,num;
+{ int i,j;
if ((!f)||(!use)) return -1;
j = 0;
for (i=0;i<f->numchars;i++)
if (f->glyph[i].shape)
- { if (f->glyph2ascii[i]<MAX_CHAR_PER_FONT &&
+ { if (f->glyph2ascii[i]<f->numchars&&
use->code[f->glyph2ascii[i]])
{ f->ascii2glyph[f->glyph2ascii[i]] = j;
f->glyph2ascii[j] = f->glyph2ascii[i];
}
else
{ swf_ShapeFree(f->glyph[i].shape);
- f->ascii2glyph[f->glyph2ascii[i]] = -1;
+ f->ascii2glyph[f->glyph2ascii[i]] = -1;
f->glyph2ascii[i] = 0;
- f->glyph[i].shape = 0;
+ f->glyph[i].shape = NULL;
f->glyph[i].advance = 0;
}
} else f->ascii2glyph[f->glyph2ascii[i]] = -1;
return j;
}
-int swf_FontInitUsage(FONTUSAGE * use)
+int swf_FontInitUsage(SWFFONT* f, FONTUSAGE * use)
{ if (!use) return -1;
- memset(use->code,0,sizeof(use->code[0])*MAX_CHAR_PER_FONT);
+ use->code = malloc(sizeof(use->code[0])*f->numchars);
+ memset(use->code,0,sizeof(use->code[0])*f->numchars);
return 0;
}
+void swf_FontClearUsage(SWFFONT* f, FONTUSAGE * use)
+{ if (!use) return;
+ free(use->code);
+}
+
int swf_FontUse(FONTUSAGE * use,U8 * s)
{ if ((!use)||(!s)) return -1;
while (s[0])
}
for (i=0;i<j;i++) swf_SetU16(t,ofs[i]+j*2);
+ if(!j) {
+ fprintf(stderr, "rfxswf: warning: Font is empty\n");
+ swf_SetU16(t, 0);
+ }
for (i=0;i<f->numchars;i++)
if (f->glyph[i].shape)
return 0;
}
+static inline int fontSize(SWFFONT*font)
+{
+ int t;
+ int size = 0;
+ for(t=0;t<font->numchars;t++) {
+ int l = (font->glyph[t].shape->bitlen+7)/8;
+ size += l+1;
+ }
+ return size + (font->numchars+1)*2;
+}
+
+int swf_FontSetDefine2(TAG *tag, SWFFONT * f)
+{
+ U8 flags = 0;
+ int t;
+ int pos;
+ int pos2;
+ swf_SetU16(tag, f->id);
+
+ if(f->layout)
+ flags |= 128; // haslayout
+ if(f->numchars>256)
+ flags |= 4; // widecodes
+ if(f->style & FONT_STYLE_BOLD)
+ flags |= 1; // bold
+ if(f->style & FONT_STYLE_ITALIC)
+ flags |= 2; // italic
+ if(f->maxascii>=256)
+ flags |= 4; //wide codecs
+ if(fontSize(f)>65535)
+ flags |= 8; //wide offsets
+ flags |= 8; //FIXME: the above check doesn't work
+
+ if(f->encoding & FONT_ENCODING_ANSI)
+ flags |= 16; // ansi
+ if(f->encoding & FONT_ENCODING_UNICODE)
+ flags |= 32; // unicode
+ if(f->encoding & FONT_ENCODING_SHIFTJIS)
+ flags |= 64; // shiftjis
+
+ swf_SetU8(tag, flags);
+ swf_SetU8(tag, 0); //reserved flags
+ if(f->name) {
+ /* font name */
+ swf_SetU8(tag, strlen(f->name));
+ swf_SetBlock(tag, f->name, strlen(f->name));
+ } else {
+ /* font name (="") */
+ swf_SetU8(tag, 0); /*placeholder*/
+ }
+ /* number of glyphs */
+ swf_SetU16(tag, f->numchars);
+ /* font offset table */
+ pos = tag->len;
+ for(t=0;t<=f->numchars;t++)
+ {
+ if(flags&8)
+ swf_SetU32(tag, /* fontoffset */ 0); /*placeholder*/
+ else
+ swf_SetU16(tag, /* fontoffset */ 0); /*placeholder*/
+ }
+
+ for(t=0;t<=f->numchars;t++) {
+ if(flags&8) {
+ tag->data[pos + t*4 ] = (tag->len-pos);
+ tag->data[pos + t*4 + 1] = (tag->len-pos) >> 8;
+ tag->data[pos + t*4 + 2] = (tag->len-pos) >> 16;
+ tag->data[pos + t*4 + 3] = (tag->len-pos) >> 24;
+ } else {
+ if(tag->len - pos > 65535) {
+ fprintf(stderr, "Internal error: Font too big and WideOffsets flag not set\n");
+ exit(1);
+ }
+ tag->data[pos + t*2 ] = (tag->len-pos);
+ tag->data[pos + t*2 + 1] = (tag->len-pos) >> 8;
+ }
+ if(t<f->numchars)
+ swf_SetSimpleShape(tag, f->glyph[t].shape);
+ }
+
+
+ /* font code table */
+ if(flags & 4) /* wide codes */ {
+ for(t=0;t<f->numchars;t++) {
+ swf_SetU16(tag,f->glyph2ascii[t]);
+ }
+ } else {
+ for(t=0;t<f->numchars;t++)
+ swf_SetU8(tag,f->glyph2ascii[t]);
+ }
+ if(f->layout)
+ {
+ swf_SetU16(tag,f->layout->ascent);
+ swf_SetU16(tag,f->layout->descent);
+ swf_SetU16(tag,f->layout->leading);
+ for(t=0;t<f->numchars;t++)
+ swf_SetU16(tag,f->glyph[t].advance);
+ for(t=0;t<f->numchars;t++) {
+ swf_ResetWriteBits(tag);
+ swf_SetRect(tag,&f->layout->bounds[t]);
+ }
+ swf_SetU16(tag, f->layout->kerningcount);
+ for(t=0;t<f->layout->kerningcount;t++) {
+ if(flags & 4) /* wide codes */ {
+ swf_SetU16(tag,f->layout->kerning[t].char1);
+ swf_SetU16(tag,f->layout->kerning[t].char2);
+ } else {
+ swf_SetU8(tag,f->layout->kerning[t].char1);
+ swf_SetU8(tag,f->layout->kerning[t].char2);
+ }
+ swf_SetU16(tag,f->layout->kerning[t].adjustment);
+ }
+ }
+ return 0;
+}
+
+void swf_FontAddLayout(SWFFONT * f, int ascent, int descent, int leading)
+{
+ f->layout = (SWFLAYOUT*)malloc(sizeof(SWFLAYOUT));
+ f->layout->ascent = ascent;
+ f->layout->descent = descent;
+ f->layout->leading = leading;
+ f->layout->kerningcount = 0;
+ f->layout->kerning = 0;
+ f->layout->bounds = (SRECT*)malloc(sizeof(SRECT)*f->numchars);
+ memset(f->layout->bounds, 0, sizeof(SRECT)*f->numchars);
+}
+
int swf_FontSetInfo(TAG * t,SWFFONT * f)
{ int l,i;
U8 wide=0;
+ U8 flags = 0;
if ((!t)||(!f)) return -1;
swf_ResetWriteBits(t);
swf_SetU16(t,f->id);
- l = strlen(f->name); if (l>255) l = 255;
+ l = f->name?strlen(f->name):0; if (l>255) l = 255;
swf_SetU8(t,l);
- swf_SetBlock(t,f->name,l);
+ if(l)
+ swf_SetBlock(t,f->name,l);
if(f->numchars>=256)
wide=1;
- swf_SetU8(t,(f->flags&0xfe)|wide);
+
+ if(f->style & FONT_STYLE_BOLD)
+ flags |= 2;
+ if(f->style & FONT_STYLE_ITALIC)
+ flags |= 4;
+ if(f->style & FONT_ENCODING_ANSI)
+ flags |= 8;
+ if(f->style & FONT_ENCODING_SHIFTJIS)
+ flags |= 16;
+ if(f->style & FONT_ENCODING_UNICODE)
+ flags |= 32;
+
+ swf_SetU8(t,(flags&0xfe)|wide);
for (i=0;i<f->numchars;i++) {
if (f->glyph[i].shape)
return 0;
}
-int swf_FontExport(int handle,SWFFONT * f)
-{ int l;
- int i;
- if (!f) return 0;
-
- l = sizeof(SWFFONT);
- if (handle>=0)
- if (write(handle,f,sizeof(SWFFONT))!=sizeof(SWFFONT)) return -1;
-
- if (f->name)
- { U16 ln = strlen(f->name);
- l+=2+ln;
- if (handle>=0)
- { if (write(handle,&ln,2)!=2) return -1;
- if (write(handle,f->name,ln)!=ln) return -1;
- }
- }
-
- if (f->layout)
- { l+=sizeof(SWFLAYOUT);
- if (handle>=0)
- if (write(handle,f->layout,sizeof(SWFLAYOUT))!=sizeof(SWFLAYOUT)) return -1;
-/* new kerning struct. hope commenting this out doesn't break things
- if (f->layout->kerning.data)
- { l+=f->layout->kerning.count*4;
- if (handle>=0)
- if (write(handle,f->layout->kerning.data,f->layout->kerning.count*4)!=f->layout->kerning.count*4) return -1;
- }*/
- }
-
- for (i=0;i<f->numchars;i++)
- { if (f->glyph[i].shape)
- { int ll = swf_ShapeExport(handle,f->glyph[i].shape);
- if (ll<0) return -1;
- l+=ll;
- }
- }
-
- return l;
-}
-
-int swf_FontImport(int handle,SWFFONT * * font)
-{ SWFFONT * f;
- int layout;
- int i = 0;
-
- if ((!font)||(handle<0)) return -1;
-
- f = (SWFFONT *)malloc(sizeof(SWFFONT)); font[0] = f;
- if (!f) return -1;
-
- memset(f,0x00,sizeof(SWFFONT));
-
- if (read(handle,f,sizeof(SWFFONT))!=sizeof(SWFFONT)) goto fehler;
-
- layout = (f->layout)?1:0; // avoid illegal free()
- f->layout = NULL;
-
- if (f->name)
- { U16 ln;
- f->name = NULL;
- if (read(handle,&ln,2)!=2) goto fehler;
- f->name = (U8*)malloc(ln+1);
- if (!f->name) goto fehler;
- if (read(handle,f->name,ln)!=ln) goto fehler;
- f->name[ln] = 0;
- }
-
- if (f->layout)
- { f->layout = (SWFLAYOUT *)malloc(sizeof(SWFLAYOUT));
- if (!f->layout) goto fehler;
- if (read(handle,f->layout,sizeof(SWFLAYOUT))!=sizeof(SWFLAYOUT)) goto fehler;
- /* new kerning struct. hope commenting this out doesn't break things
- if (f->layout->kerning.data)
- { int l = f->layout->kerning.count*4;
- f->layout->kerning.data = (U8*)malloc(l);
- if (!f->layout->kerning.data) goto fehler;
- if (read(handle,f->layout->kerning.data,l)!=l) goto fehler;
- } */
- }
-
- for (i=0;i<f->numchars;i++)
- { if (f->glyph[i].shape)
- { if (swf_ShapeImport(handle,&f->glyph[i].shape)<0) goto fehler;
- }
- }
-
- f->id = 0;
-
- return 0;
-
-fehler:
- if (f) for (;i<MAX_CHAR_PER_FONT;i++) f->glyph[i].shape = NULL;
- swf_FontFree(f);
- font[0] = NULL;
- return -1;
-}
-
int swf_TextPrintDefineText(TAG * t,SWFFONT * f)
{ int id = swf_GetTagID(t);
if ((id==ST_DEFINETEXT)||(id==ST_DEFINETEXT2)) swf_FontExtract_DefineText(f->id,f,t,FEDTJ_PRINT);
free(f->glyph2ascii);
f->glyph2ascii = NULL;
}
+ if(f->glyphnames) {
+ int t;
+ for(t=0;t<f->numchars;t++) {
+ free(f->glyphnames[t]);
+ }
+ free(f->glyphnames);
+ }
}
free(f);
}
-int swf_TextSetInfoRecord(TAG * t,SWFFONT * font,U16 size,RGBA * color,S16 dx,S16 dy)
+int swf_TextSetInfoRecord(TAG * t,SWFFONT * font,U16 size,RGBA * color,int dx,int dy)
{ U8 flags;
if (!t) return -1;
while(s[0])
{
- int glyph = font->ascii2glyph[s[0]];
+ int glyph = -1;
+ if(s[0] < font->maxascii)
+ glyph = font->ascii2glyph[s[0]];
if(glyph>=0) {
- g = swf_CountBits(glyph,g);
+ g = swf_CountUBits(glyph,g);
a = swf_CountBits((((U32)font->glyph[glyph].advance)*scale)/100,a);
}
s++;
}
int swf_TextSetCharRecord(TAG * t,SWFFONT * font,U8 * s,int scale,U8 gbits,U8 abits)
-{ int l,i;
+{ int l=0,i,pos;
if ((!t)||(!font)||(!s)||(!font->ascii2glyph)) return -1;
- l = strlen(s);
- if (l>0x7f) l = 0x7f;
- swf_SetU8(t,l);
+ pos = t->len;
+ swf_SetU8(t, l); //placeholder
- for (i=0;i<l;i++)
+ for (i=0;s[i];i++)
{
- int g = font->ascii2glyph[s[i]];
+ int g = -1;
+ if(s[i] < font->maxascii)
+ g = font->ascii2glyph[s[i]];
if(g>=0) {
swf_SetBits(t,g,gbits);
swf_SetBits(t,(((U32)font->glyph[g].advance)*scale)/100,abits);
+ l++;
+ if(l==0x7f)
+ break;
}
}
+ PUT8(&t->data[pos], l);
+
swf_ResetWriteBits(t);
return 0;
}
if (font&&s)
{ while (s[0])
{
- int g = font->ascii2glyph[*s];
+ int g = -1;
+ if(*s < font->maxascii)
+ g = font->ascii2glyph[*s];
if(g>=0)
res += font->glyph[g].advance;
s++;
return res;
}
-void swf_WriteFont(SWFFONT*font, char* filename, int useDefineFont2)
+SWFFONT* swf_ReadFont(char* filename)
+{
+ int f;
+ SWF swf;
+ if(!filename)
+ return 0;
+ f = open(filename,O_RDONLY);
+
+ if (f<0 || swf_ReadSWF(f,&swf)<0)
+ { fprintf(stderr,"%s is not a valid SWF font file or contains errors.\n",filename);
+ close(f);
+ return 0;
+ }
+ else
+ { SWFFONT*font;
+ close(f);
+ if(swf_FontExtract(&swf, WRITEFONTID, &font) < 0)
+ return 0;
+ swf_FreeTags(&swf);
+ return font;
+ }
+}
+
+void swf_WriteFont(SWFFONT*font, char* filename)
{ SWF swf;
TAG * t;
SRECT r;
RGBA rgb;
int f;
+ int useDefineFont2 = 0;
+ int storeGlyphNames = 1;
- if(useDefineFont2) {
- fprintf(stderr, "DefineFont2 is not yet supported!\n");
- useDefineFont2 = 0;
- }
+ if(font->layout)
+ useDefineFont2 = 1; /* the only thing new in definefont2
+ is layout information. */
font->id = WRITEFONTID; //"FN"
swf.fileVersion = 4;
swf.frameRate = 0x4000;
- swf.movieSize.xmax = 20*640;
- swf.movieSize.ymax = 20*480;
- if(!useDefineFont2)
/* if we use DefineFont1 to store the characters,
we have to build a textfield to store the
advance values. While at it, we can also
make the whole .swf viewable */
- {
- t = swf_InsertTag(NULL,ST_SETBACKGROUNDCOLOR);
- swf.firstTag = t;
- rgb.r = 0xff;
- rgb.g = 0xff;
- rgb.b = 0xff;
- swf_SetRGB(t,&rgb);
- t = swf_InsertTag(t,ST_DEFINEFONT);
+
+ /* we now always create viewable swfs, even if we
+ did use definefont2 -mk*/
+ t = swf_InsertTag(NULL,ST_SETBACKGROUNDCOLOR);
+ swf.firstTag = t;
+ rgb.r = 0xef;
+ rgb.g = 0xef;
+ rgb.b = 0xff;
+ swf_SetRGB(t,&rgb);
+ if(!useDefineFont2) {
+ t = swf_InsertTag(t,ST_DEFINEFONT);
+ swf_FontSetDefine(t,font);
+ t = swf_InsertTag(t,ST_DEFINEFONTINFO);
+ swf_FontSetInfo(t,font);
+ } else {
+ t = swf_InsertTag(t,ST_DEFINEFONT2);
+ swf_FontSetDefine2(t,font);
}
- else
+
+ if(storeGlyphNames)
{
- t = swf_InsertTag(NULL,ST_DEFINEFONT);
- swf.firstTag = t;
+ int c;
+ t = swf_InsertTag(t,ST_GLYPHNAMES);
+ swf_SetU16(t, font->id);
+ swf_SetU16(t, font->numchars);
+ for(c=0;c<font->numchars;c++) {
+ swf_SetString(t, font->glyphnames[c]);
+ }
}
- swf_FontSetDefine(t,font);
-
- t = swf_InsertTag(t,ST_DEFINEFONTINFO);
- swf_FontSetInfo(t,font);
-
- if(!useDefineFont2)
+ if(1) //neccessary only for df1, but pretty to look at anyhow, so do it always
{
- int textscale = 400;
+ int textscale = 400;
int s;
int xmax = 0;
- int ymax = textscale * 20;
+ int ymax = 0;
+ int ypos = 1;
U8 gbits,abits;
- char text[257];
- int x,y;
- text[256]=0;
- for(s=0;s<256;s++)
+ int x,y,c;
+
+ c=0;
+ for(s=0;s<font->maxascii;s++)
{
int g = font->ascii2glyph[s];
- text[s] = s;
if(g>=0) {
- if(font->glyph[g].advance*textscale/100 > xmax)
- xmax = font->glyph[g].advance*textscale/100;
+ if(font->glyph[g].advance*textscale/64 > xmax) {
+ xmax = font->glyph[g].advance*textscale/64;
+ }
+ c++;
+ }
+ if((s&15)==0) {
+ if(c) {
+ ypos++;
+ }
+ c=0;
}
}
+ ymax = ypos*textscale*2;
+
swf.movieSize.xmax = xmax*20;
swf.movieSize.ymax = ymax;
r.xmin = 0;
r.ymin = 0;
- r.xmax = swf.movieSize.xmax*20;
+ r.xmax = swf.movieSize.xmax;
r.ymax = swf.movieSize.ymax;
swf_SetRect(t,&r);
rgb.r = 0x00;
rgb.g = 0x00;
rgb.b = 0x00;
- for(y=0;y<16;y++)
+ ypos = 1;
+ for(y=0;y<((font->maxascii+15)/16);y++)
{
- int c=0,lastx=-1, firstx=0;
+ int c=0,lastx=-1;
for(x=0;x<16;x++) {
- int g = font->ascii2glyph[y*16+x];
+ int g = (y*16+x<font->maxascii)?font->ascii2glyph[y*16+x]:-1;
if(g>=0 && font->glyph[g].shape) {
c++;
if(lastx<0)
}
}
if(c) {
- swf_TextSetInfoRecord(t,font,textscale,&rgb,lastx+1,textscale*y);
+ swf_TextSetInfoRecord(t,font,textscale,&rgb,lastx+1,textscale*ypos*2);
for(x=0;x<16;x++)
{
- int g = font->ascii2glyph[y*16+x];
+ int g = (y*16+x<font->maxascii)?font->ascii2glyph[y*16+x]:-1;
if(g>=0 && font->glyph[g].shape) {
if(lastx != x*xmax) {
swf_TextSetInfoRecord(t,0,0,0,x*xmax+1,0);
swf_ResetWriteBits(t);
}
}
+ ypos++;
}
}
swf_SetU8(t,0);
+
- t = swf_InsertTag(t,ST_PLACEOBJECT2);
+ t = swf_InsertTag(t,ST_PLACEOBJECT2);
- swf_ObjectPlace(t,font->id+1,1,NULL,NULL,NULL);
+ swf_ObjectPlace(t,font->id+1,1,NULL,NULL,NULL);
- t = swf_InsertTag(t,ST_SHOWFRAME);
+ t = swf_InsertTag(t,ST_SHOWFRAME);
+
}
t = swf_InsertTag(t,ST_END);
swf_FreeTags(&swf);
}
-SWFFONT* swf_ReadFont(char* filename)
+
+void swf_SetEditText(TAG*tag, U16 flags, SRECT r, char*text, RGBA*color,
+ int maxlength, U16 font, U16 height, EditTextLayout*layout, char*variable)
{
- int f;
- SWF swf;
- if(!filename)
- return 0;
- f = open(filename,O_RDONLY);
-
- if (f<0 || swf_ReadSWF(f,&swf)<0)
- { fprintf(stderr,"%s is not a valid SWF font file or contains errors.\n",filename);
- close(f);
- return 0;
- }
- else
- { SWFFONT*font;
- close(f);
- if(swf_FontExtract(&swf, WRITEFONTID, &font) < 0)
- return 0;
- swf_FreeTags(&swf);
- return font;
- }
+ swf_SetRect(tag,&r);
+ swf_ResetWriteBits(tag);
+
+ flags &= ~(ET_HASTEXT|ET_HASTEXTCOLOR|ET_HASMAXLENGTH|ET_HASFONT|ET_HASLAYOUT);
+ if(text) flags |= ET_HASTEXT;
+ if(color) flags |= ET_HASTEXTCOLOR;
+ if(maxlength) flags |= ET_HASMAXLENGTH;
+ if(font) flags |= ET_HASFONT;
+ if(layout) flags |= ET_HASLAYOUT;
+
+ swf_SetBits(tag, flags, 16);
+
+ if(flags & ET_HASFONT) {
+ swf_SetU16(tag, font); //font
+ swf_SetU16(tag, height); //fontheight
+ }
+ if(flags & ET_HASTEXTCOLOR) {
+ swf_SetRGBA(tag, color);
+ }
+ if(flags & ET_HASMAXLENGTH) {
+ swf_SetU16(tag, maxlength); //maxlength
+ }
+ if(flags & ET_HASLAYOUT) {
+ swf_SetU8(tag,layout->align); //align
+ swf_SetU16(tag,layout->leftmargin); //left margin
+ swf_SetU16(tag,layout->rightmargin); //right margin
+ swf_SetU16(tag,layout->indent); //indent
+ swf_SetU16(tag,layout->leading); //leading
+ }
+ swf_SetString(tag, variable);
+ if(flags & ET_HASTEXT)
+ swf_SetString(tag,text);
+}
+
+SRECT swf_SetDefineText(TAG*tag, SWFFONT*font, RGBA*rgb, char*text, int scale)
+{
+ SRECT r;
+ 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*20)/100;
+ }
+ }
+ c++;
+ }
+ } else {
+ /* 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
+ structure.
+ */
+ r.xmin = r.ymin = 0;
+ r.xmax = r.ymax = 1024*20;
+ }
+
+ swf_SetRect(tag,&r);
+ swf_SetMatrix(tag,NULL);
+ swf_TextCountBits(font,text,scale*20,&gbits,&abits);
+ swf_SetU8(tag,gbits);
+ swf_SetU8(tag,abits);
+
+ /* now set the text params- notice that a font size of
+ 1024 means that the glyphs will be displayed exactly
+ as they would be in/with a defineshape. (Try to find
+ *that* in the flash specs)
+ */
+ swf_TextSetInfoRecord(tag,font,(scale*1024)/100,rgb,0,0); //scale
+
+ /* set the actual text- notice that we just pass our scale
+ parameter over, as TextSetCharRecord calculates with
+ percent, too */
+ swf_TextSetCharRecord(tag,font,text,scale*20,gbits,abits);
+
+ swf_SetU8(tag,0);
+ return r;
+}
+
+void swf_FontCreateLayout(SWFFONT*f)
+{
+ S16 leading = 0;
+ int t;
+ if(f->layout)
+ return;
+ if(!f->numchars)
+ return;
+
+ f->layout = (SWFLAYOUT*)malloc(sizeof(SWFLAYOUT));
+ memset(f->layout, 0, sizeof(SWFLAYOUT));
+ f->layout->bounds = (SRECT*)malloc(f->numchars*sizeof(SRECT));
+ f->layout->ascent = -32767;
+ f->layout->descent = -32767;
+
+ for(t=0;t<f->numchars;t++) {
+ SHAPE2*shape2;
+ SRECT bbox;
+ int width;
+ shape2 = swf_ShapeToShape2(f->glyph[t].shape);
+ if(!shape2) {
+ fprintf(stderr, "Shape parse error\n");exit(1);
+ }
+ bbox = swf_GetShapeBoundingBox(shape2);
+ swf_Shape2Free(shape2);
+ f->layout->bounds[t] = bbox;
+ /* FIXME */
+ //width = (bbox.xmax - bbox.xmin)/20;
+ width = (bbox.xmax)/20;
+
+ /* The following is a heuristic- it may be that extractfont_DefineText
+ has already found out some widths for individual characters (from the way
+ 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)
+ f->glyph[t].advance = width;
+
+ if(-bbox.ymin > f->layout->ascent)
+ f->layout->ascent = bbox.ymin;
+ if(bbox.ymax > f->layout->descent)
+ f->layout->descent = bbox.ymax;
+ }
}
+
+static U32 readUTF8char(char**text)
+{
+ U32 c = 0;
+ if(!(*(*text) & 0x80))
+ return *((*text)++);
+
+ /* 0000 0080-0000 07FF 110xxxxx 10xxxxxx */
+ if(((*text)[0] & 0xe0) == 0xc0 && (*text)[1])
+ {
+ c = ((*text)[0] & 0x1f) << 6 | ((*text)[1] & 0x3f);
+ (*text) += 2;
+ return c;
+ }
+ /* 0000 0800-0000 FFFF 1110xxxx 10xxxxxx 10xxxxxx */
+ if(((*text)[0] & 0xf0) == 0xe0 && (*text)[1] && (*text)[2])
+ {
+ c = ((*text)[0] & 0x0f) << 12 | ((*text)[1] & 0x3f) << 6 | ((*text)[2] & 0x3f);
+ (*text) += 3;
+ return c;
+ }
+ /* 0001 0000-001F FFFF 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx */
+ if(((*text)[0] & 0xf8) == 0xf0 && (*text)[1] && (*text)[2] && (*text)[3] )
+ {
+ c = ((*text)[0] & 0x07) << 18 | ((*text)[1] & 0x3f) << 12 | ((*text)[2] & 0x3f)<<6 | ((*text)[3] & 0x3f);
+ (*text) += 4;
+ return c;
+ }
+ /* 0020 0000-03FF FFFF 111110xx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx */
+ if(((*text)[0] & 0xfc) == 0xf8 && (*text)[1] && (*text)[2] && (*text)[3] && (*text)[4])
+ {
+ c = ((*text)[0] & 0x03) << 24 | ((*text)[1] & 0x3f) << 18 | ((*text)[2] & 0x3f)<<12 | ((*text)[3] & 0x3f) << 6 | ((*text)[4] & 0x3f);
+ (*text) += 5;
+ return c;
+ }
+ /* 0400 0000-7FFF FFFF 1111110x 10xxxxxx ... 10xxxxxx */
+ if(((*text)[0] & 0xfe) == 0xfc && (*text)[1] && (*text)[2] && (*text)[3] && (*text)[4] && (*text)[5])
+ {
+ c = ((*text)[0] & 0x01) << 30 | ((*text)[1] & 0x3f) << 24 | ((*text)[2] & 0x3f)<<18 | ((*text)[3] & 0x3f) << 12 | ((*text)[4] & 0x3f) << 6 | ((*text)[5] & 0x3f) << 6;
+ (*text) += 6;
+ return c;
+ }
+ return *((*text)++);
+}
+
+void swf_DrawText(drawer_t*draw, SWFFONT*font, char*text)
+{
+ char*s = text;
+ int advance = 0;
+ while(*s) {
+ SHAPE*shape;
+ SHAPE2*shape2;
+ SHAPELINE*l;
+ U32 c = readUTF8char(&s);
+ int g = font->ascii2glyph[c];
+ shape = font->glyph[g].shape;
+ 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;
+ draw->moveTo(draw, &to);
+ } else if(l->type == lineTo) {
+ FPOINT to;
+ to.x = l->x/20.0+advance;
+ to.y = l->y/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;
+ draw->splineTo(draw, &mid, &to);
+ }
+ l = l->next;
+ }
+ swf_Shape2Free(shape2);
+ advance += font->glyph[g].advance;
+ }
+}
+