+
+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;
+
+ if(font->layout)
+ useDefineFont2 = 1; /* the only thing new in definefont2
+ is layout information. */
+
+ font->id = WRITEFONTID; //"FN"
+
+ memset(&swf,0x00,sizeof(SWF));
+
+ swf.fileVersion = 4;
+ swf.frameRate = 0x4000;
+
+ /* 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 */
+
+ /* we now always create viewable swfs, even if we
+ did use definefont2 -mk*/
+ t = swf_InsertTag(NULL,ST_SETBACKGROUNDCOLOR);
+ swf.firstTag = t;
+ rgb.r = 0xff;
+ rgb.g = 0xff;
+ 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);
+ }
+
+ if(1) //useDefineFont2
+ { int textscale = 400;
+ int s;
+ int xmax = 0;
+ int ymax = textscale * 2 * (font->maxascii/16+1);
+ U8 gbits,abits;
+ U8 text[MAX_CHAR_PER_FONT+1];
+ int x,y;
+ text[MAX_CHAR_PER_FONT]=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/64 > xmax)
+ xmax = font->glyph[g].advance*textscale/64;
+ }
+ }
+ swf.movieSize.xmax = xmax*20;
+ swf.movieSize.ymax = ymax;
+
+ t = swf_InsertTag(t,ST_DEFINETEXT);
+
+ swf_SetU16(t,font->id+1); // ID
+
+ r.xmin = 0;
+ r.ymin = 0;
+ r.xmax = swf.movieSize.xmax*20;
+ r.ymax = swf.movieSize.ymax;
+
+ swf_SetRect(t,&r);
+
+ swf_SetMatrix(t,NULL);
+
+ abits = swf_CountBits(xmax*16, 0);
+ gbits = 8;
+
+ swf_SetU8(t,gbits);
+ swf_SetU8(t,abits);
+
+ rgb.r = 0x00;
+ rgb.g = 0x00;
+ rgb.b = 0x00;
+ for(y=0;y<=((font->maxascii-1)/16);y++)
+ {
+ int c=0,lastx=-1;
+ /* TODO: firstx?? */
+ for(x=0;x<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)
+ lastx = x*xmax;
+ }
+ }
+ if(c) {
+ swf_TextSetInfoRecord(t,font,textscale,&rgb,lastx+1,textscale*y*2);
+ for(x=0;x<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_SetU8(t,1);
+ swf_SetBits(t, g, gbits);
+ swf_SetBits(t, font->glyph[g].advance, abits);
+ lastx = x*xmax+font->glyph[g].advance;
+ swf_ResetWriteBits(t);
+ }
+ }
+ }
+ }
+ swf_SetU8(t,0);
+
+
+ t = swf_InsertTag(t,ST_PLACEOBJECT2);
+
+ swf_ObjectPlace(t,font->id+1,1,NULL,NULL,NULL);
+
+ t = swf_InsertTag(t,ST_SHOWFRAME);
+ }
+
+ t = swf_InsertTag(t,ST_END);
+
+ f = open(filename, O_RDWR|O_CREAT|O_TRUNC,0644);
+ if FAILED(swf_WriteSWF(f,&swf)) fprintf(stderr,"WriteSWF() failed in writeFont().\n");
+ close(f);
+
+ swf_FreeTags(&swf);
+}
+
+
+void swf_SetEditText(TAG*tag, U16 flags, SRECT r, char*text, RGBA*color,
+ int maxlength, U16 font, U16 height, EditTextLayout*layout, char*variable)
+{
+ 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->lines);
+ 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;
+ }
+}
+
+