+
+void swf_FontFree(SWFFONT * f)
+{
+ int i;
+ if (!f)
+ return;
+
+ if (f->glyph)
+ {
+ for (i = 0; i < f->numchars; i++)
+ if (f->glyph[i].shape)
+ {
+ swf_ShapeFree(f->glyph[i].shape);
+ f->glyph[i].shape = NULL;
+ }
+ rfx_free(f->glyph);
+ f->glyph = NULL;
+ }
+ if (f->ascii2glyph)
+ {
+ rfx_free(f->ascii2glyph);
+ f->ascii2glyph = NULL;
+ }
+ if (f->glyph2ascii)
+ {
+ rfx_free(f->glyph2ascii);
+ f->glyph2ascii = NULL;
+ }
+ font_freename(f);
+ font_freelayout(f);
+ font_freeglyphnames(f);
+ font_freeusage(f);
+
+ rfx_free(f);
+}
+
+int swf_TextSetInfoRecord(TAG * t, SWFFONT * font, U16 size, RGBA * color, int dx, int dy)
+{
+ U8 flags;
+ if (!t)
+ return -1;
+
+ flags = TF_TEXTCONTROL | (font ? TF_HASFONT : 0) | (color ? TF_HASCOLOR : 0) | (dx ? TF_HASXOFFSET : 0)
+ | (dy ? TF_HASYOFFSET : 0);
+
+ swf_SetU8(t, flags);
+ if (font)
+ swf_SetU16(t, font->id);
+ if (color) {
+ if (swf_GetTagID(t) == ST_DEFINETEXT2)
+ swf_SetRGBA(t, color);
+ else
+ swf_SetRGB(t, color);
+ }
+ if (dx) {
+ if(dx != SET_TO_ZERO) {
+ if(dx>32767 || dx<-32768)
+ fprintf(stderr, "Warning: Horizontal char position overflow: %d\n", dx);
+ swf_SetS16(t, dx);
+ } else {
+ swf_SetS16(t, 0);
+ }
+ }
+ if (dy) {
+ if(dy != SET_TO_ZERO) {
+ if(dy>32767 || dy<-32768)
+ fprintf(stderr, "Warning: Vertical char position overflow: %d\n", dy);
+ swf_SetS16(t, dy);
+ } else {
+ swf_SetS16(t, 0);
+ }
+ }
+ if (font)
+ swf_SetU16(t, size);
+
+ return 0;
+}
+
+static int swf_TextCountBits2(SWFFONT * font, U8 * s, int scale, U8 * gbits, U8 * abits, char *encoding)
+{
+ U16 g, a;
+ char utf8 = 0;
+ if ((!s) || (!font) || ((!gbits) && (!abits)) || (!font->ascii2glyph))
+ return -1;
+ g = a = 0;
+
+ if (!strcmp(encoding, "UTF8"))
+ utf8 = 1;
+ else if (!strcmp(encoding, "iso-8859-1"))
+ utf8 = 0;
+ else
+ fprintf(stderr, "Unknown encoding: %s", encoding);
+
+ while (*s) {
+ int glyph = -1, c;
+
+ if (!utf8)
+ c = *s++;
+ else
+ c = readUTF8char(&s);
+
+ if (c < font->maxascii)
+ glyph = font->ascii2glyph[c];
+ if (glyph >= 0) {
+ g = swf_CountUBits(glyph, g);
+ a = swf_CountBits(((((U32) font->glyph[glyph].advance) * scale) / 20) / 100, a);
+ }
+ }
+
+ if (gbits)
+ gbits[0] = (U8) g;
+ if (abits)
+ abits[0] = (U8) a;
+ return 0;
+}
+
+static int swf_TextSetCharRecord2(TAG * t, SWFFONT * font, U8 * s, int scale, U8 gbits, U8 abits, char *encoding)
+{
+ int l = 0, pos;
+ char utf8 = 0;
+
+ if ((!t) || (!font) || (!s) || (!font->ascii2glyph))
+ return -1;
+
+ if (!strcmp(encoding, "UTF8"))
+ utf8 = 1;
+ else if (!strcmp(encoding, "iso-8859-1"))
+ utf8 = 0;
+ else
+ fprintf(stderr, "Unknown encoding: %s", encoding);
+
+ pos = t->len;
+ swf_SetU8(t, l); //placeholder
+
+ while (*s) {
+ int g = -1, c;
+
+ if (!utf8)
+ c = *s++;
+ else
+ c = readUTF8char(&s);
+
+ if (c < font->maxascii)
+ g = font->ascii2glyph[c];
+ if (g >= 0) {
+ swf_SetBits(t, g, gbits);
+ swf_SetBits(t, ((((U32) font->glyph[g].advance) * scale) / 20) / 100, abits);
+ l++;
+ /* We split into 127 characters per text field.
+ We could do 255, by the (formerly wrong) flash specification,
+ but some SWF parsing code out there still assumes that char blocks
+ are at max 127 characters, and it would save only a few bits.
+ */
+ if (l == 0x7f)
+ break;
+ }
+ }
+
+ PUT8(&t->data[pos], l);
+
+ swf_ResetWriteBits(t);
+ return 0;
+}
+
+int swf_TextCountBits(SWFFONT * font, U8 * s, int scale, U8 * gbits, U8 * abits)
+{
+ return swf_TextCountBits2(font, s, scale, gbits, abits, "iso-8859-1");
+}
+
+int swf_TextSetCharRecord(TAG * t, SWFFONT * font, U8 * s, int scale, U8 gbits, U8 abits)
+{
+ return swf_TextSetCharRecord2(t, font, s, scale, gbits, abits, "iso-8859-1");
+}
+
+int swf_TextCountBitsUTF8(SWFFONT * font, U8 * s, int scale, U8 * gbits, U8 * abits)
+{
+ return swf_TextCountBits2(font, s, scale, gbits, abits, "UTF8");
+}
+
+int swf_TextSetCharRecordUTF8(TAG * t, SWFFONT * font, U8 * s, int scale, U8 gbits, U8 abits)
+{
+ return swf_TextSetCharRecord2(t, font, s, scale, gbits, abits, "UTF8");
+}
+
+U32 swf_TextGetWidth(SWFFONT * font, U8 * s, int scale)
+{
+ U32 res = 0;
+
+ if (font && s) {
+ while (s[0]) {
+ int g = -1;
+ if (*s < font->maxascii)
+ g = font->ascii2glyph[*s];
+ if (g >= 0)
+ res += font->glyph[g].advance / 20;
+ s++;
+ }
+ if (scale)
+ res = (res * scale) / 100;
+ }
+ return res;
+}
+
+SRECT swf_TextCalculateBBoxUTF8(SWFFONT * font, U8 * s, int scale)
+{
+ int xpos = 0;
+ int ypos = 0;
+ SRECT r;
+ swf_GetRect(0, &r);
+ while (*s) {
+ int c = readUTF8char(&s);
+ if(c==13 || c==10) {
+ if(s[0] == 10) {
+ s++;
+ }
+ xpos=0;
+ ypos+=font->layout->leading;
+ continue;
+ }
+ 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 + xpos;
+ rn.xmax = (rn.xmax * scale) / 20 / 100 + xpos;
+ rn.ymin = (rn.ymin * scale) / 20 / 100 + ypos;
+ rn.ymax = (rn.ymax * scale) / 20 / 100 + ypos;
+ swf_ExpandRect2(&r, &rn);
+ xpos += (font->glyph[g].advance * scale) / 20 / 100;
+ }
+ }
+ }
+ return r;
+}
+
+
+SWFFONT *swf_ReadFont(char *filename)
+{
+ int f;
+ SWF swf;
+ if (!filename)
+ return 0;
+ f = open(filename, O_RDONLY|O_BINARY);
+
+ 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 (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 = 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);
+ }
+
+ if (storeGlyphNames && font->glyphnames) {
+ int c;
+ t = swf_InsertTag(t, ST_GLYPHNAMES);
+ swf_SetU16(t, WRITEFONTID);
+ swf_SetU16(t, font->numchars);
+ for (c = 0; c < font->numchars; c++) {
+ if (font->glyphnames[c])
+ swf_SetString(t, font->glyphnames[c]);
+ else
+ swf_SetString(t, "");
+ }
+ }
+
+ if (1) //neccessary only for df1, but pretty to look at anyhow, so do it always
+ {
+ int textscale = 400;
+ int s;
+ int xmax = 0;
+ int ymax = 0;
+ int ypos = 1;
+ U8 gbits, abits;
+ int x, y, c;
+ int range = font->maxascii;
+
+ c = 0;
+ if (useDefineFont2 && range > 256) {
+ range = 256;
+ }
+
+ for (s = 0; s < range; s++) {
+ int g = font->ascii2glyph[s];
+ if (g >= 0) {
+ if ((font->glyph[g].advance * textscale / 20) / 64 > xmax) {
+ xmax = (font->glyph[g].advance * textscale / 20) / 64;
+ }
+ c++;
+ }
+ if ((s & 15) == 0) {
+ if (c) {
+ ypos++;
+ }
+ c = 0;
+ }
+ }
+ ymax = ypos * textscale * 2;
+
+ 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;
+ 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;
+ ypos = 1;
+ for (y = 0; y < ((range + 15) / 16); y++) {
+ int c = 0, lastx = -1;
+ for (x = 0; x < 16; x++) {
+ int g = (y * 16 + x < range) ? 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 * ypos * 2);
+ for (x = 0; x < 16; x++) {
+ int g = (y * 16 + x < range) ? 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 / 20, abits);
+ lastx = x * xmax + (font->glyph[g].advance / 20);
+ swf_ResetWriteBits(t);
+ }
+ }
+ ypos++;
+ }
+ }
+ 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 | O_BINARY, 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 *utext = (U8 *) strdup(text);
+ U8 *upos = utext;
+ int x = 0, y = 0;
+ int pos = 0;
+ int ystep = 0;
+ if (font->layout) {
+ r = swf_TextCalculateBBoxUTF8(font, text, scale * 20);
+ ystep = font->layout->leading;
+ } 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
+ structure.
+ */
+ r.xmin = r.ymin = 0;
+ r.xmax = r.ymax = 1024 * 20;
+ ystep = 100;
+ }
+
+ swf_SetRect(tag, &r);
+
+ /* 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);
+
+ while(*upos) {
+ U8*next = upos;
+ int count = 0;
+
+ swf_TextSetInfoRecord(tag, font, (scale * 1024) / 100, rgb, x, y); //scale
+ x = 0;
+
+ while(*next && *next!=13 && *next!=10 && count<127) {
+ readUTF8char(&next);
+ count++;
+ }
+ if(next[0] == 13 || next[0] == 10) {
+ x = SET_TO_ZERO;
+ y += ystep;
+ }
+
+ if(next[0] == 13 && next[1] == 10)
+ next++;
+
+ if(next[0] == 13 || next[0] == 10) {
+ *next = 0;
+ next++;
+ }
+
+ /* 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)
+ */
+ /* set the actual text- notice that we just pass our scale
+ parameter over, as TextSetCharRecord calculates with
+ percent, too */
+ swf_TextSetCharRecordUTF8(tag, font, upos, scale * 20, gbits, abits);
+
+ upos= next;
+ }
+ free(utext);
+
+ 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 *) rfx_calloc(sizeof(SWFLAYOUT));
+ f->layout->bounds = (SRECT *) rfx_alloc(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;
+
+ width = (bbox.xmax);
+
+ /* 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 < f->glyph[t].advance / 2)
+ 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;
+ }
+}
+
+void swf_DrawText(drawer_t * draw, SWFFONT * font, int size, char *text)
+{
+ U8 *s = (U8 *) 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;
+ 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 * 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 * 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 * 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 * size / 100.0 / 20.0;