lib/modules/swftext.c

   1 /* swftext.c
   2
   3    Text and font routines
   4
   5    Extension module for the rfxswf library.
   6    Part of the swftools package.
   7
   8    Copyright (c) 2001 Rainer Böhme <rfxswf@reflex-studio.de>
   9    Copyright (c) 2003,2004 Matthias Kramm
  10
  11    This program is free software; you can redistribute it and/or modify
  12    it under the terms of the GNU General Public License as published by
  13    the Free Software Foundation; either version 2 of the License, or
  14    (at your option) any later version.
  15
  16    This program is distributed in the hope that it will be useful,
  17    but WITHOUT ANY WARRANTY; without even the implied warranty of
  18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19    GNU General Public License for more details.
  20
  21    You should have received a copy of the GNU General Public License
  22    along with this program; if not, write to the Free Software
  23    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  24
  25 static U32 readUTF8char(U8 ** text)
  26 {
  27     U32 c = 0;
  28     if (!(*(*text) & 0x80))
  29         return *((*text)++);
  30
  31     /* 0000 0080-0000 07FF   110xxxxx 10xxxxxx */
  32     if (((*text)[0] & 0xe0) == 0xc0 && (*text)[1]) {
  33         c = ((*text)[0] & 0x1f) << 6 | ((*text)[1] & 0x3f);
  34         (*text) += 2;
  35         return c;
  36     }
  37     /* 0000 0800-0000 FFFF   1110xxxx 10xxxxxx 10xxxxxx */
  38     if (((*text)[0] & 0xf0) == 0xe0 && (*text)[1] && (*text)[2]) {
  39         c = ((*text)[0] & 0x0f) << 12 | ((*text)[1] & 0x3f) << 6 | ((*text)[2] & 0x3f);
  40         (*text) += 3;
  41         return c;
  42     }
  43     /* 0001 0000-001F FFFF   11110xxx 10xxxxxx 10xxxxxx 10xxxxxx */
  44     if (((*text)[0] & 0xf8) == 0xf0 && (*text)[1] && (*text)[2]
  45         && (*text)[3]) {
  46         c = ((*text)[0] & 0x07) << 18 | ((*text)[1] & 0x3f) << 12 | ((*text)[2] & 0x3f) << 6 | ((*text)[3] & 0x3f);
  47         (*text) += 4;
  48         return c;
  49     }
  50     /* 0020 0000-03FF FFFF   111110xx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx */
  51     if (((*text)[0] & 0xfc) == 0xf8 && (*text)[1] && (*text)[2]
  52         && (*text)[3]
  53         && (*text)[4]) {
  54         c = ((*text)[0] & 0x03) << 24 | ((*text)[1] & 0x3f) << 18 | ((*text)[2] & 0x3f) << 12 | ((*text)[3] & 0x3f) << 6 | ((*text)[4] & 0x3f);
  55         (*text) += 5;
  56         return c;
  57     }
  58     /* 0400 0000-7FFF FFFF   1111110x 10xxxxxx ... 10xxxxxx */
  59     if (((*text)[0] & 0xfe) == 0xfc && (*text)[1] && (*text)[2]
  60         && (*text)[3]
  61         && (*text)[4] && (*text)[5]) {
  62         c = ((*text)[0] & 0x01) << 30 | ((*text)[1] & 0x3f) << 24 |
  63             ((*text)[2] & 0x3f) << 18 | ((*text)[3] & 0x3f) << 12 | ((*text)[4] & 0x3f) << 6 | ((*text)[5] & 0x3f) << 6;
  64         (*text) += 6;
  65         return c;
  66     }
  67     return *((*text)++);
  68 }
  69
  70 #define TF_TEXTCONTROL  0x80
  71 #define TF_HASFONT      0x08
  72 #define TF_HASCOLOR     0x04
  73 #define TF_HASYOFFSET   0x02
  74 #define TF_HASXOFFSET   0x01
  75
  76 #define FF_WIDECODES    0x01
  77 #define FF_BOLD         0x02
  78 #define FF_ITALIC       0x04
  79 #define FF_ANSI         0x08
  80 #define FF_SHIFTJIS     0x10
  81 #define FF_UNICODE      0x20
  82
  83 #define FF2_BOLD         0x01
  84 #define FF2_ITALIC       0x02
  85 #define FF2_WIDECODES    0x04
  86 #define FF2_WIDEOFFSETS  0x08
  87 #define FF2_ANSI         0x10
  88 #define FF2_UNICODE      0x20
  89 #define FF2_SHIFTJIS     0x40
  90 #define FF2_LAYOUT       0x80
  91
  92 int swf_FontIsItalic(SWFFONT * f)
  93 {
  94     return f->style & FONT_STYLE_ITALIC;
  95 }
  96
  97 int swf_FontIsBold(SWFFONT * f)
  98 {
  99     return f->style & FONT_STYLE_BOLD;
 100 }
 101
 102 static const int WRITEFONTID = 0x4e46;  // font id for WriteFont and ReadFont
 103
 104 int swf_FontEnumerate(SWF * swf, void (*FontCallback) (U16, U8 *))
 105 {
 106     int n;
 107     TAG *t;
 108     if (!swf)
 109         return -1;
 110     t = swf->firstTag;
 111     n = 0;
 112
 113     while (t) {
 114         if (swf_GetTagID(t) == ST_DEFINEFONT2 || swf_GetTagID(t) == ST_DEFINEFONT) {
 115             n++;
 116             if (FontCallback) {
 117                 U16 id;
 118                 int l;
 119                 U8 s[257];
 120                 s[0] = 0;
 121                 swf_SaveTagPos(t);
 122                 swf_SetTagPos(t, 0);
 123
 124                 id = swf_GetU16(t);
 125                 if (swf_GetTagID(t) == ST_DEFINEFONT2 || swf_GetTagID(t) == ST_DEFINEFONTINFO || swf_GetTagID(t) == ST_DEFINEFONTINFO2) {
 126                     swf_GetU16(t);
 127                     l = swf_GetU8(t);
 128                     swf_GetBlock(t, s, l);
 129                     s[l] = 0;
 130                 }
 131
 132                 (FontCallback) (id, s);
 133
 134                 swf_RestoreTagPos(t);
 135             }
 136         }
 137         t = swf_NextTag(t);
 138     }
 139     return n;
 140 }
 141
 142 int swf_FontExtract_DefineFont(int id, SWFFONT * f, TAG * t)
 143 {
 144     U16 fid;
 145     swf_SaveTagPos(t);
 146     swf_SetTagPos(t, 0);
 147
 148     fid = swf_GetU16(t);
 149     if ((!id) || (id == fid)) {
 150         U16 of;
 151         int n, i;
 152
 153         id = fid;
 154         f->version = 1;
 155         f->id = fid;
 156
 157         of = swf_GetU16(t);
 158         n = of / 2;
 159         f->numchars = n;
 160         f->glyph = malloc(sizeof(SWFGLYPH) * n);
 161         memset(f->glyph, 0, sizeof(SWFGLYPH) * n);
 162
 163         for (i = 1; i < n; i++)
 164             swf_GetU16(t);
 165         for (i = 0; i < n; i++)
 166             swf_GetSimpleShape(t, &f->glyph[i].shape);
 167     }
 168
 169     swf_RestoreTagPos(t);
 170     return id;
 171 }
 172
 173 int swf_FontExtract_DefineFontInfo(int id, SWFFONT * f, TAG * t)
 174 {
 175     U16 fid;
 176     U16 maxcode;
 177     U8 flags;
 178     swf_SaveTagPos(t);
 179     swf_SetTagPos(t, 0);
 180
 181     fid = swf_GetU16(t);
 182     if (fid == id) {
 183         U8 l = swf_GetU8(t);
 184         int i;
 185
 186         if (f->version > 1) {
 187             /* Especially with Flash MX, DefineFont2 may have FontInfo fields,
 188                too. However, they only add little information to what's already
 189                inside the DefineFont2 tag */
 190             return id;
 191         }
 192
 193         if (f->name)
 194             free(f->name);
 195
 196         f->name = (U8 *) malloc(l + 1);
 197         swf_GetBlock(t, f->name, l);
 198         f->name[l] = 0;
 199
 200         flags = swf_GetU8(t);
 201         if (flags & 2)
 202             f->style |= FONT_STYLE_BOLD;
 203         if (flags & 4)
 204             f->style |= FONT_STYLE_ITALIC;
 205         if (flags & 8)
 206             f->encoding |= FONT_ENCODING_ANSI;
 207         if (flags & 16)
 208             f->encoding |= FONT_ENCODING_SHIFTJIS;
 209         if (flags & 32)
 210             f->encoding |= FONT_ENCODING_UNICODE;
 211
 212         if (t->id == ST_DEFINEFONTINFO2) {
 213             f->language = swf_GetU8(t);
 214         }
 215
 216         f->glyph2ascii = (U16 *) malloc(sizeof(U16) * f->numchars);
 217         maxcode = 0;
 218         for (i = 0; i < f->numchars; i++) {
 219             f->glyph2ascii[i] = ((flags & FF_WIDECODES) ? swf_GetU16(t) : swf_GetU8(t));
 220             if (f->glyph2ascii[i] > maxcode)
 221                 maxcode = f->glyph2ascii[i];
 222         }
 223         maxcode++;
 224         if (maxcode < 256)
 225             maxcode = 256;
 226         f->maxascii = maxcode;
 227         f->ascii2glyph = (int *) malloc(sizeof(int) * maxcode);
 228         memset(f->ascii2glyph, -1, sizeof(int) * maxcode);
 229
 230         for (i = 0; i < f->numchars; i++)
 231             f->ascii2glyph[f->glyph2ascii[i]] = i;
 232     }
 233
 234     swf_RestoreTagPos(t);
 235     return id;
 236 }
 237
 238 int swf_FontExtract_GlyphNames(int id, SWFFONT * f, TAG * tag)
 239 {
 240     U16 fid;
 241     U16 maxcode;
 242     U8 flags;
 243     swf_SaveTagPos(tag);
 244     swf_SetTagPos(tag, 0);
 245
 246     fid = swf_GetU16(tag);
 247
 248     if (fid == id) {
 249         int num = swf_GetU16(tag);
 250         int t;
 251         f->glyphnames = malloc(sizeof(char *) * num);
 252         for (t = 0; t < num; t++) {
 253             f->glyphnames[t] = strdup(swf_GetString(tag));
 254         }
 255     }
 256
 257     swf_RestoreTagPos(tag);
 258     return id;
 259 }
 260
 261
 262 int swf_FontExtract_DefineFont2(int id, SWFFONT * font, TAG * tag)
 263 {
 264     int t, glyphcount;
 265     int maxcode;
 266     int fid;
 267     U8 flags1, flags2, namelen;
 268     swf_SaveTagPos(tag);
 269     swf_SetTagPos(tag, 0);
 270     font->version = 2;
 271     fid = swf_GetU16(tag);
 272     if (id && id != fid)
 273         return id;
 274     font->id = fid;
 275     flags1 = swf_GetU8(tag);
 276     flags2 = swf_GetU8(tag);    //reserved flags
 277
 278     if (flags1 & 1)
 279         font->style |= FONT_STYLE_BOLD;
 280     if (flags1 & 2)
 281         font->style |= FONT_STYLE_ITALIC;
 282     if (flags1 & 16)
 283         font->encoding |= FONT_ENCODING_ANSI;
 284     if (flags1 & 32)
 285         font->encoding |= FONT_ENCODING_UNICODE;
 286     if (flags1 & 64)
 287         font->encoding |= FONT_ENCODING_SHIFTJIS;
 288
 289     namelen = swf_GetU8(tag);
 290     font->name = (U8 *) malloc(namelen + 1);
 291     font->name[namelen] = 0;
 292     swf_GetBlock(tag, font->name, namelen);
 293     font->version = 2;
 294     glyphcount = swf_GetU16(tag);
 295     font->numchars = glyphcount;
 296
 297     font->glyph = (SWFGLYPH *) malloc(sizeof(SWFGLYPH) * glyphcount);
 298     memset(font->glyph, 0, sizeof(SWFGLYPH) * glyphcount);
 299     font->glyph2ascii = (U16 *) malloc(sizeof(U16) * glyphcount);
 300     memset(font->glyph2ascii, 0, sizeof(U16) * glyphcount);
 301
 302     if (flags1 & 8) {           // wide offsets
 303         for (t = 0; t < glyphcount; t++)
 304             swf_GetU32(tag);    //offset[t]
 305
 306         if (glyphcount)         /* this _if_ is not in the specs */
 307             swf_GetU32(tag);    // fontcodeoffset
 308     } else {
 309         for (t = 0; t < glyphcount; t++)
 310             swf_GetU16(tag);    //offset[t]
 311
 312         if (glyphcount)         /* this _if_ is not in the specs */
 313             swf_GetU16(tag);    // fontcodeoffset
 314     }
 315     for (t = 0; t < glyphcount; t++)
 316         swf_GetSimpleShape(tag, &(font->glyph[t].shape));
 317
 318     maxcode = 0;
 319     for (t = 0; t < glyphcount; t++) {
 320         int code;
 321         if (flags1 & 4)         // wide codes
 322             code = swf_GetU16(tag);
 323         else
 324             code = swf_GetU8(tag);
 325         font->glyph2ascii[t] = code;
 326         if (code > maxcode)
 327             maxcode = code;
 328     }
 329     maxcode++;
 330     if (maxcode < 256)
 331         maxcode = 256;
 332     font->maxascii = maxcode;
 333     font->ascii2glyph = (int *) malloc(sizeof(int) * maxcode);
 334     memset(font->ascii2glyph, -1, sizeof(int) * maxcode);
 335     for (t = 0; t < glyphcount; t++) {
 336         font->ascii2glyph[font->glyph2ascii[t]] = t;
 337     }
 338
 339     if (flags1 & 128) {         // has layout
 340         U16 kerningcount;
 341         font->layout = (SWFLAYOUT *) malloc(sizeof(SWFLAYOUT));
 342         font->layout->ascent = swf_GetU16(tag);
 343         font->layout->descent = swf_GetU16(tag);
 344         font->layout->leading = swf_GetU16(tag);
 345         for (t = 0; t < glyphcount; t++) {
 346             S16 advance = swf_GetS16(tag);
 347             font->glyph[t].advance = advance;
 348         }
 349         font->layout->bounds = malloc(glyphcount * sizeof(SRECT));
 350         for (t = 0; t < glyphcount; t++) {
 351             swf_ResetReadBits(tag);
 352             swf_GetRect(tag, &font->layout->bounds[t]);
 353         }
 354
 355         kerningcount = swf_GetU16(tag);
 356         font->layout->kerningcount = kerningcount;
 357
 358         font->layout->kerning = (SWFKERNING *) malloc(sizeof(SWFKERNING) * kerningcount);
 359         if (kerningcount) {
 360             font->layout->kerning = malloc(sizeof(*font->layout->kerning) * kerningcount);
 361             for (t = 0; t < kerningcount; t++) {
 362                 if (flags1 & 4) {       // wide codes
 363                     font->layout->kerning[t].char1 = swf_GetU16(tag);
 364                     font->layout->kerning[t].char2 = swf_GetU16(tag);
 365                 } else {
 366                     font->layout->kerning[t].char1 = swf_GetU8(tag);
 367                     font->layout->kerning[t].char2 = swf_GetU8(tag);
 368                 }
 369                 font->layout->kerning[t].adjustment = swf_GetS16(tag);
 370             }
 371         }
 372     }
 373     swf_RestoreTagPos(t);
 374     return font->id;
 375 }
 376
 377
 378 #define FEDTJ_PRINT  0x01
 379 #define FEDTJ_MODIFY 0x02
 380 #define FEDTJ_CALLBACK 0x04
 381
 382 static int
 383 swf_FontExtract_DefineTextCallback(int id, SWFFONT * f, TAG * t, int jobs,
 384                                    void (*callback) (void *self,
 385                                                      int *chars, int *ypos, int nr, int fontid, int fontsize, int xstart, int ystart, RGBA * color), void *self)
 386 {
 387     U16 cid;
 388     SRECT r;
 389     MATRIX m;
 390     U8 gbits, abits;
 391     int fid = 0;
 392     RGBA color;
 393     int x = 0, y = 0;
 394     int fontsize = 0;
 395
 396     memset(&color, 0, sizeof(color));
 397
 398     swf_SaveTagPos(t);
 399     swf_SetTagPos(t, 0);
 400
 401     cid = swf_GetU16(t);
 402     swf_GetRect(t, &r);
 403     swf_GetMatrix(t, &m);
 404     gbits = swf_GetU8(t);
 405     abits = swf_GetU8(t);
 406
 407     while (1) {
 408         int flags, num;
 409         flags = swf_GetU8(t);
 410         if (!flags)
 411             break;
 412
 413         if (flags & TF_TEXTCONTROL) {
 414             if (flags & TF_HASFONT)
 415                 fid = swf_GetU16(t);
 416             if (flags & TF_HASCOLOR) {
 417                 color.r = swf_GetU8(t); // rgb
 418                 color.g = swf_GetU8(t);
 419                 color.b = swf_GetU8(t);
 420                 if (swf_GetTagID(t) == ST_DEFINETEXT2)
 421                     color.a = swf_GetU8(t);
 422             }
 423             if (flags & TF_HASXOFFSET)
 424                 x = swf_GetS16(t);
 425             if (flags & TF_HASYOFFSET)
 426                 y = swf_GetS16(t);
 427             if (flags & TF_HASFONT)
 428                 fontsize = swf_GetU16(t);
 429         }
 430
 431         num = swf_GetU8(t);
 432         if (!num)
 433             break;
 434
 435         {
 436             int i;
 437             int buf[256];
 438             int advance[256];
 439             int xpos = 0;
 440             for (i = 0; i < num; i++) {
 441                 int glyph;
 442                 int adv = 0;
 443                 advance[i] = xpos;
 444                 glyph = swf_GetBits(t, gbits);
 445                 adv = swf_GetBits(t, abits);
 446                 xpos += adv;
 447
 448                 // <deprecated>
 449                 if (id == fid) {
 450                     if (jobs & FEDTJ_PRINT) {
 451                         int code = f->glyph2ascii[glyph];
 452                         printf("%c", code);
 453                     }
 454                     if (jobs & FEDTJ_MODIFY)
 455                         f->glyph[glyph].advance = adv * 20;     //?
 456                 } else {
 457                     if (jobs & FEDTJ_PRINT) {
 458                         printf("?");
 459                     }
 460                 }
 461                 // </deprecated>
 462
 463                 buf[i] = glyph;
 464             }
 465             if ((id == fid) && (jobs & FEDTJ_PRINT))
 466                 printf("\n");
 467             if (jobs & FEDTJ_CALLBACK)
 468                 callback(self, buf, advance, num, fid, fontsize, x, y, &color);
 469             x += xpos;
 470         }
 471     }
 472
 473     swf_RestoreTagPos(t);
 474     return id;
 475 }
 476
 477 int swf_ParseDefineText(TAG * tag,
 478                     void (*callback) (void *self, int *chars, int *ypos, int nr, int fontid, int fontsize, int xstart, int ystart, RGBA * color), void *self)
 479 {
 480     return swf_FontExtract_DefineTextCallback(-1, 0, tag, FEDTJ_CALLBACK, callback, self);
 481 }
 482
 483 int swf_FontExtract_DefineText(int id, SWFFONT * f, TAG * t, int jobs)
 484 {
 485     return swf_FontExtract_DefineTextCallback(id, f, t, jobs, 0, 0);
 486 }
 487
 488 int swf_FontExtract(SWF * swf, int id, SWFFONT * *font)
 489 {
 490     TAG *t;
 491     SWFFONT *f;
 492
 493     if ((!swf) || (!font))
 494         return -1;
 495
 496     f = (SWFFONT *) malloc(sizeof(SWFFONT));
 497     memset(f, 0x00, sizeof(SWFFONT));
 498
 499     t = swf->firstTag;
 500
 501     while (t) {
 502         int nid = 0;
 503         switch (swf_GetTagID(t)) {
 504         case ST_DEFINEFONT:
 505             nid = swf_FontExtract_DefineFont(id, f, t);
 506             break;
 507
 508         case ST_DEFINEFONT2:
 509             nid = swf_FontExtract_DefineFont2(id, f, t);
 510             break;
 511
 512         case ST_DEFINEFONTINFO:
 513         case ST_DEFINEFONTINFO2:
 514             nid = swf_FontExtract_DefineFontInfo(id, f, t);
 515             break;
 516
 517         case ST_DEFINETEXT:
 518         case ST_DEFINETEXT2:
 519             nid = swf_FontExtract_DefineText(id, f, t, f->layout ? 0 : FEDTJ_MODIFY);
 520             break;
 521
 522         case ST_GLYPHNAMES:
 523             nid = swf_FontExtract_GlyphNames(id, f, t);
 524             break;
 525         }
 526         if (nid > 0)
 527             id = nid;
 528         t = swf_NextTag(t);
 529     }
 530     if (f->id != id) {
 531         free(f);
 532         f = 0;
 533     }
 534     font[0] = f;
 535     return 0;
 536 }
 537
 538 int swf_FontSetID(SWFFONT * f, U16 id)
 539 {
 540     if (!f)
 541         return -1;
 542     f->id = id;
 543     return 0;
 544 }
 545
 546 int swf_FontReduce(SWFFONT * f, FONTUSAGE * use)
 547 {
 548     int i, j;
 549     if ((!f) || (!use))
 550         return -1;
 551
 552     /* TODO: layout, glyphnames */
 553     j = 0;
 554     for (i = 0; i < f->numchars; i++)
 555         if (f->glyph[i].shape) {
 556             if (f->glyph2ascii[i] < f->maxascii && use->code[f->glyph2ascii[i]]) {
 557                 f->ascii2glyph[f->glyph2ascii[i]] = j;
 558                 f->glyph2ascii[j] = f->glyph2ascii[i];
 559                 f->glyph[j] = f->glyph[i];
 560                 j++;
 561             } else {
 562                 swf_ShapeFree(f->glyph[i].shape);
 563                 f->ascii2glyph[f->glyph2ascii[i]] = -1;
 564                 f->glyph2ascii[i] = 0;
 565                 f->glyph[i].shape = NULL;
 566                 f->glyph[i].advance = 0;
 567             }
 568         } else
 569             f->ascii2glyph[f->glyph2ascii[i]] = -1;
 570
 571     f->numchars = j;
 572
 573     return j;
 574 }
 575
 576 void swf_FontSort(SWFFONT * font)
 577 {
 578     if (!font)
 579         return;
 580     int i, j, k;
 581     int *newplace = malloc(sizeof(int) * font->numchars);
 582     int *newpos;
 583
 584     for (i = 0; i < font->numchars; i++) {
 585         newplace[i] = i;
 586     }
 587     for (i = 0; i < font->numchars; i++)
 588         for (j = 0; j < i; j++) {
 589             if (font->glyph2ascii[i] < font->glyph2ascii[j]) {
 590                 int n1, n2;
 591                 char *c1, *c2;
 592                 SWFGLYPH g1, g2;
 593                 SRECT r1, r2;
 594                 n1 = newplace[i];
 595                 n2 = newplace[j];
 596                 newplace[j] = n1;
 597                 newplace[i] = n2;
 598                 n1 = font->glyph2ascii[i];
 599                 n2 = font->glyph2ascii[j];
 600                 font->glyph2ascii[j] = n1;
 601                 font->glyph2ascii[i] = n2;
 602                 g1 = font->glyph[i];
 603                 g2 = font->glyph[j];
 604                 font->glyph[j] = g1;
 605                 font->glyph[i] = g2;
 606                 if (font->glyphnames) {
 607                     c1 = font->glyphnames[i];
 608                     c2 = font->glyphnames[j];
 609                     font->glyphnames[j] = c1;
 610                     font->glyphnames[i] = c2;
 611                 }
 612                 if (font->layout) {
 613                     r1 = font->layout->bounds[i];
 614                     r2 = font->layout->bounds[j];
 615                     font->layout->bounds[j] = r1;
 616                     font->layout->bounds[i] = r2;
 617                 }
 618             }
 619         }
 620     newpos = malloc(sizeof(int) * font->numchars);
 621     for (i = 0; i < font->numchars; i++) {
 622         newpos[newplace[i]] = i;
 623     }
 624     for (i = 0; i < font->maxascii; i++) {
 625         if (font->ascii2glyph[i] >= 0)
 626             font->ascii2glyph[i] = newpos[font->ascii2glyph[i]];
 627     }
 628
 629     free(newpos);
 630     free(newplace);
 631 }
 632
 633 void swf_FontPrepareForEditText(SWFFONT * font)
 634 {
 635     if (!font->layout)
 636         swf_FontCreateLayout(font);
 637     swf_FontSort(font);
 638 }
 639
 640 int swf_FontInitUsage(SWFFONT * f, FONTUSAGE * use)
 641 {
 642     if (!use)
 643         return -1;
 644     use->code = malloc(sizeof(use->code[0]) * f->maxascii);
 645     memset(use->code, 0, sizeof(use->code[0]) * f->maxascii);
 646     return 0;
 647 }
 648
 649 void swf_FontClearUsage(SWFFONT * f, FONTUSAGE * use)
 650 {
 651     if (!use)
 652         return;
 653     free(use->code);
 654 }
 655
 656 int swf_FontUse(SWFFONT * f, FONTUSAGE * use, U8 * s)
 657 {
 658     if ((!use) || (!s))
 659         return -1;
 660     while (s[0]) {
 661         use->code[s[0]] = 1;
 662         s++;
 663     }
 664     return 0;
 665 }
 666
 667 int swf_FontSetDefine(TAG * t, SWFFONT * f)
 668 {
 669     U16 *ofs = (U16 *) malloc(f->numchars * 2);
 670     int p, i, j;
 671
 672     if ((!t) || (!f))
 673         return -1;
 674     swf_ResetWriteBits(t);
 675     swf_SetU16(t, f->id);
 676
 677     p = 0;
 678     j = 0;
 679     for (i = 0; i < f->numchars; i++)
 680         if (f->glyph[i].shape) {
 681             ofs[j++] = p;
 682             p += swf_SetSimpleShape(NULL, f->glyph[i].shape);
 683         }
 684
 685     for (i = 0; i < j; i++)
 686         swf_SetU16(t, ofs[i] + j * 2);
 687     if (!j) {
 688         fprintf(stderr, "rfxswf: warning: Font is empty\n");
 689         swf_SetU16(t, 0);
 690     }
 691
 692     for (i = 0; i < f->numchars; i++)
 693         if (f->glyph[i].shape)
 694             swf_SetSimpleShape(t, f->glyph[i].shape);
 695
 696     swf_ResetWriteBits(t);
 697     free(ofs);
 698     return 0;
 699 }
 700
 701 static inline int fontSize(SWFFONT * font)
 702 {
 703     int t;
 704     int size = 0;
 705     for (t = 0; t < font->numchars; t++) {
 706         int l = (font->glyph[t].shape->bitlen + 7) / 8;
 707         size += l + 1;
 708     }
 709     return size + (font->numchars + 1) * 2;
 710 }
 711
 712 int swf_FontSetDefine2(TAG * tag, SWFFONT * f)
 713 {
 714     U8 flags = 0;
 715     int t;
 716     int pos;
 717     int pos2;
 718     swf_SetU16(tag, f->id);
 719
 720     if (f->layout) flags |= 128;                // haslayout
 721     if (f->numchars > 256)
 722         flags |= 4;             // widecodes
 723     if (f->style & FONT_STYLE_BOLD)
 724         flags |= 1;             // bold
 725     if (f->style & FONT_STYLE_ITALIC)
 726         flags |= 2;             // italic
 727     if (f->maxascii >= 256)
 728         flags |= 4;             //wide codecs
 729     if (fontSize(f) > 65535)
 730         flags |= 8;             //wide offsets
 731     flags |= 8 | 4;             //FIXME: the above check doesn't work
 732
 733     if (f->encoding & FONT_ENCODING_ANSI)
 734         flags |= 16;            // ansi
 735     if (f->encoding & FONT_ENCODING_UNICODE)
 736         flags |= 32;            // unicode
 737     if (f->encoding & FONT_ENCODING_SHIFTJIS)
 738         flags |= 64;            // shiftjis
 739
 740     swf_SetU8(tag, flags);
 741     swf_SetU8(tag, 0);          //reserved flags
 742     if (f->name) {
 743         /* font name */
 744         swf_SetU8(tag, strlen(f->name));
 745         swf_SetBlock(tag, f->name, strlen(f->name));
 746     } else {
 747         /* font name (="") */
 748         swf_SetU8(tag, 0);      /*placeholder */
 749     }
 750     /* number of glyphs */
 751     swf_SetU16(tag, f->numchars);
 752     /* font offset table */
 753     pos = tag->len;
 754     for (t = 0; t <= f->numchars; t++) {
 755         if (flags & 8)
 756             swf_SetU32(tag, /* fontoffset */ 0);        /*placeholder */
 757         else
 758             swf_SetU16(tag, /* fontoffset */ 0);        /*placeholder */
 759     }
 760
 761     for (t = 0; t <= f->numchars; t++) {
 762         if (flags & 8) {
 763             tag->data[pos + t * 4] = (tag->len - pos);
 764             tag->data[pos + t * 4 + 1] = (tag->len - pos) >> 8;
 765             tag->data[pos + t * 4 + 2] = (tag->len - pos) >> 16;
 766             tag->data[pos + t * 4 + 3] = (tag->len - pos) >> 24;
 767         } else {
 768             if (tag->len - pos > 65535) {
 769                 fprintf(stderr, "Internal error: Font too big and WideOffsets flag not set\n");
 770                 exit(1);
 771             }
 772             tag->data[pos + t * 2] = (tag->len - pos);
 773             tag->data[pos + t * 2 + 1] = (tag->len - pos) >> 8;
 774         }
 775         if (t < f->numchars)
 776             swf_SetSimpleShape(tag, f->glyph[t].shape);
 777     }
 778
 779
 780     /* font code table */
 781     if (flags & 4) {            /* wide codes */
 782         for (t = 0; t < f->numchars; t++) {
 783             swf_SetU16(tag, f->glyph2ascii[t]);
 784         }
 785     } else {
 786         for (t = 0; t < f->numchars; t++)
 787             swf_SetU8(tag, f->glyph2ascii[t]);
 788     }
 789     if (f->layout) {
 790         swf_SetU16(tag, f->layout->ascent);
 791         swf_SetU16(tag, f->layout->descent);
 792         swf_SetU16(tag, f->layout->leading);
 793         for (t = 0; t < f->numchars; t++)
 794             swf_SetU16(tag, f->glyph[t].advance);
 795         for (t = 0; t < f->numchars; t++) {
 796             swf_ResetWriteBits(tag);
 797             swf_SetRect(tag, &f->layout->bounds[t]);
 798         }
 799         swf_SetU16(tag, f->layout->kerningcount);
 800         for (t = 0; t < f->layout->kerningcount; t++) {
 801             if (flags & 4) {    /* wide codes */
 802                 swf_SetU16(tag, f->layout->kerning[t].char1);
 803                 swf_SetU16(tag, f->layout->kerning[t].char2);
 804             } else {
 805                 swf_SetU8(tag, f->layout->kerning[t].char1);
 806                 swf_SetU8(tag, f->layout->kerning[t].char2);
 807             }
 808             swf_SetU16(tag, f->layout->kerning[t].adjustment);
 809         }
 810     }
 811     return 0;
 812 }
 813
 814 void swf_FontAddLayout(SWFFONT * f, int ascent, int descent, int leading)
 815 {
 816     f->layout = (SWFLAYOUT *) malloc(sizeof(SWFLAYOUT));
 817     f->layout->ascent = ascent;
 818     f->layout->descent = descent;
 819     f->layout->leading = leading;
 820     f->layout->kerningcount = 0;
 821     f->layout->kerning = 0;
 822     f->layout->bounds = (SRECT *) malloc(sizeof(SRECT) * f->numchars);
 823     memset(f->layout->bounds, 0, sizeof(SRECT) * f->numchars);
 824 }
 825
 826 int swf_FontSetInfo(TAG * t, SWFFONT * f)
 827 {
 828     int l, i;
 829     U8 wide = 0;
 830     U8 flags = 0;
 831     if ((!t) || (!f))
 832         return -1;
 833     swf_ResetWriteBits(t);
 834     swf_SetU16(t, f->id);
 835     l = f->name ? strlen(f->name) : 0;
 836     if (l > 255)
 837         l = 255;
 838     swf_SetU8(t, l);
 839     if (l)
 840         swf_SetBlock(t, f->name, l);
 841     if (f->numchars >= 256)
 842         wide = 1;
 843
 844     if (f->style & FONT_STYLE_BOLD)
 845         flags |= 2;
 846     if (f->style & FONT_STYLE_ITALIC)
 847         flags |= 4;
 848     if (f->style & FONT_ENCODING_ANSI)
 849         flags |= 8;
 850     if (f->style & FONT_ENCODING_SHIFTJIS)
 851         flags |= 16;
 852     if (f->style & FONT_ENCODING_UNICODE)
 853         flags |= 32;
 854
 855     swf_SetU8(t, (flags & 0xfe) | wide);
 856
 857     for (i = 0; i < f->numchars; i++) {
 858         if (f->glyph[i].shape) {
 859             int g2a = f->glyph2ascii[i];
 860             wide ? swf_SetU16(t, g2a) : swf_SetU8(t, g2a);
 861         }
 862     }
 863
 864     return 0;
 865 }
 866
 867 int swf_TextPrintDefineText(TAG * t, SWFFONT * f)
 868 {
 869     int id = swf_GetTagID(t);
 870     if ((id == ST_DEFINETEXT) || (id == ST_DEFINETEXT2))
 871         swf_FontExtract_DefineText(f->id, f, t, FEDTJ_PRINT);
 872     else
 873         return -1;
 874     return 0;
 875 }
 876
 877 void swf_LayoutFree(SWFLAYOUT * l)
 878 {
 879     if (l) {
 880         if (l->kerning)
 881             free(l->kerning);
 882         l->kerning = NULL;
 883         if (l->bounds)
 884             free(l->bounds);
 885         l->bounds = NULL;
 886     }
 887     free(l);
 888 }
 889
 890 void swf_FontFree(SWFFONT * f)
 891 {
 892     if (f) {
 893         int i;
 894
 895         if (f->name)
 896             free(f->name);
 897         if (f->layout)
 898             swf_LayoutFree(f->layout);
 899
 900         f->name = NULL;
 901         f->layout = NULL;
 902
 903         if (f->glyph) {
 904             for (i = 0; i < f->numchars; i++)
 905                 if (f->glyph[i].shape) {
 906                     swf_ShapeFree(f->glyph[i].shape);
 907                     f->glyph[i].shape = NULL;
 908                 }
 909             free(f->glyph);
 910             f->glyph = NULL;
 911         }
 912         if (f->ascii2glyph) {
 913             free(f->ascii2glyph);
 914             f->ascii2glyph = NULL;
 915         }
 916         if (f->glyph2ascii) {
 917             free(f->glyph2ascii);
 918             f->glyph2ascii = NULL;
 919         }
 920         if (f->glyphnames) {
 921             int t;
 922             for (t = 0; t < f->numchars; t++) {
 923                 if (f->glyphnames[t])
 924                     free(f->glyphnames[t]);
 925             }
 926             free(f->glyphnames);
 927         }
 928     }
 929     free(f);
 930 }
 931
 932 int swf_TextSetInfoRecord(TAG * t, SWFFONT * font, U16 size, RGBA * color, int dx, int dy)
 933 {
 934     U8 flags;
 935     if (!t)
 936         return -1;
 937
 938     flags = TF_TEXTCONTROL | (font ? TF_HASFONT : 0) | (color ? TF_HASCOLOR : 0) | (dx ? TF_HASXOFFSET : 0)
 939         | (dy ? TF_HASYOFFSET : 0);
 940
 941     swf_SetU8(t, flags);
 942     if (font)
 943         swf_SetU16(t, font->id);
 944     if (color) {
 945         if (swf_GetTagID(t) == ST_DEFINETEXT2)
 946             swf_SetRGBA(t, color);
 947         else
 948             swf_SetRGB(t, color);
 949     }
 950     if (dx)
 951         swf_SetS16(t, dx);
 952     if (dy)
 953         swf_SetS16(t, dy);
 954     if (font)
 955         swf_SetU16(t, size);
 956
 957     return 0;
 958 }
 959
 960 static int swf_TextCountBits2(SWFFONT * font, U8 * s, int scale, U8 * gbits, U8 * abits, char *encoding)
 961 {
 962     U16 g, a;
 963     char utf8 = 0;
 964     if ((!s) || (!font) || ((!gbits) && (!abits)) || (!font->ascii2glyph))
 965         return -1;
 966     g = a = 0;
 967
 968     if (!strcmp(encoding, "UTF8"))
 969         utf8 = 1;
 970     else if (!strcmp(encoding, "iso-8859-1"))
 971         utf8 = 0;
 972     else
 973         fprintf(stderr, "Unknown encoding: %s", encoding);
 974
 975     while (*s) {
 976         int glyph = -1, c;
 977
 978         if (!utf8)
 979             c = *s++;
 980         else
 981             c = readUTF8char(&s);
 982
 983         if (c < font->maxascii)
 984             glyph = font->ascii2glyph[c];
 985         if (glyph >= 0) {
 986             g = swf_CountUBits(glyph, g);
 987             a = swf_CountBits(((((U32) font->glyph[glyph].advance) * scale) / 20) / 100, a);
 988         }
 989     }
 990
 991     if (gbits)
 992         gbits[0] = (U8) g;
 993     if (abits)
 994         abits[0] = (U8) a;
 995     return 0;
 996 }
 997
 998 static int swf_TextSetCharRecord2(TAG * t, SWFFONT * font, U8 * s, int scale, U8 gbits, U8 abits, char *encoding)
 999 {
1000     int l = 0, pos;
1001     char utf8 = 0;
1002
1003     if ((!t) || (!font) || (!s) || (!font->ascii2glyph))
1004         return -1;
1005
1006     if (!strcmp(encoding, "UTF8"))
1007         utf8 = 1;
1008     else if (!strcmp(encoding, "iso-8859-1"))
1009         utf8 = 0;
1010     else
1011         fprintf(stderr, "Unknown encoding: %s", encoding);
1012
1013     pos = t->len;
1014     swf_SetU8(t, l);            //placeholder
1015
1016     while (*s) {
1017         int g = -1, c;
1018
1019         if (!utf8)
1020             c = *s++;
1021         else
1022             c = readUTF8char(&s);
1023
1024         if (c < font->maxascii)
1025             g = font->ascii2glyph[c];
1026         if (g >= 0) {
1027             swf_SetBits(t, g, gbits);
1028             swf_SetBits(t, ((((U32) font->glyph[g].advance) * scale) / 20) / 100, abits);
1029             l++;
1030             if (l == 0x7f)
1031                 break;
1032         }
1033     }
1034
1035     PUT8(&t->data[pos], l);
1036
1037     swf_ResetWriteBits(t);
1038     return 0;
1039 }
1040
1041 int swf_TextCountBits(SWFFONT * font, U8 * s, int scale, U8 * gbits, U8 * abits)
1042 {
1043     return swf_TextCountBits2(font, s, scale, gbits, abits, "iso-8859-1");
1044 }
1045
1046 int swf_TextSetCharRecord(TAG * t, SWFFONT * font, U8 * s, int scale, U8 gbits, U8 abits)
1047 {
1048     return swf_TextSetCharRecord2(t, font, s, scale, gbits, abits, "iso-8859-1");
1049 }
1050
1051 int swf_TextCountBitsUTF8(SWFFONT * font, U8 * s, int scale, U8 * gbits, U8 * abits)
1052 {
1053     return swf_TextCountBits2(font, s, scale, gbits, abits, "UTF8");
1054 }
1055
1056 int swf_TextSetCharRecordUTF8(TAG * t, SWFFONT * font, U8 * s, int scale, U8 gbits, U8 abits)
1057 {
1058     return swf_TextSetCharRecord2(t, font, s, scale, gbits, abits, "UTF8");
1059 }
1060
1061 U32 swf_TextGetWidth(SWFFONT * font, U8 * s, int scale)
1062 {
1063     U32 res = 0;
1064
1065     if (font && s) {
1066         while (s[0]) {
1067             int g = -1;
1068             if (*s < font->maxascii)
1069                 g = font->ascii2glyph[*s];
1070             if (g >= 0)
1071                 res += font->glyph[g].advance / 20;
1072             s++;
1073         }
1074         if (scale)
1075             res = (res * scale) / 100;
1076     }
1077     return res;
1078 }
1079
1080 SRECT swf_TextCalculateBBoxUTF8(SWFFONT * font, U8 * s, int scale)
1081 {
1082     int pos = 0;
1083     SRECT r;
1084     swf_GetRect(0, &r);
1085     while (*s) {
1086         int c = readUTF8char(&s);
1087         if (c < font->maxascii) {
1088             int g = font->ascii2glyph[c];
1089             if (g >= 0) {
1090                 SRECT rn = font->layout->bounds[g];
1091                 rn.xmin = (rn.xmin * scale) / 20 / 100 + pos;
1092                 rn.xmax = (rn.xmax * scale) / 20 / 100 + pos;
1093                 rn.ymin = (rn.ymin * scale) / 20 / 100;
1094                 rn.ymax = (rn.ymax * scale) / 20 / 100;
1095                 swf_ExpandRect2(&r, &rn);
1096                 pos += (font->glyph[g].advance * scale) / 20 / 100;
1097             }
1098         }
1099         c++;
1100     }
1101     return r;
1102 }
1103
1104
1105 SWFFONT *swf_ReadFont(char *filename)
1106 {
1107     int f;
1108     SWF swf;
1109     if (!filename)
1110         return 0;
1111     f = open(filename, O_RDONLY);
1112
1113     if (f < 0 || swf_ReadSWF(f, &swf) < 0) {
1114         fprintf(stderr, "%s is not a valid SWF font file or contains errors.\n", filename);
1115         close(f);
1116         return 0;
1117     } else {
1118         SWFFONT *font;
1119         close(f);
1120         if (swf_FontExtract(&swf, WRITEFONTID, &font) < 0)
1121             return 0;
1122         swf_FreeTags(&swf);
1123         return font;
1124     }
1125 }
1126
1127 void swf_WriteFont(SWFFONT * font, char *filename)
1128 {
1129     SWF swf;
1130     TAG *t;
1131     SRECT r;
1132     RGBA rgb;
1133     int f;
1134     int useDefineFont2 = 0;
1135     int storeGlyphNames = 1;
1136
1137     if (font->layout)
1138         useDefineFont2 = 1;     /* the only thing new in definefont2
1139                                    is layout information. */
1140
1141     font->id = WRITEFONTID;     //"FN"
1142
1143     memset(&swf, 0x00, sizeof(SWF));
1144
1145     swf.fileVersion = 4;
1146     swf.frameRate = 0x4000;
1147
1148     /* if we use DefineFont1 to store the characters,
1149        we have to build a textfield to store the
1150        advance values. While at it, we can also
1151        make the whole .swf viewable */
1152
1153     /* we now always create viewable swfs, even if we
1154        did use definefont2 -mk */
1155     t = swf_InsertTag(NULL, ST_SETBACKGROUNDCOLOR);
1156     swf.firstTag = t;
1157     rgb.r = 0xef;
1158     rgb.g = 0xef;
1159     rgb.b = 0xff;
1160     swf_SetRGB(t, &rgb);
1161     if (!useDefineFont2) {
1162         t = swf_InsertTag(t, ST_DEFINEFONT);
1163         swf_FontSetDefine(t, font);
1164         t = swf_InsertTag(t, ST_DEFINEFONTINFO);
1165         swf_FontSetInfo(t, font);
1166     } else {
1167         t = swf_InsertTag(t, ST_DEFINEFONT2);
1168         swf_FontSetDefine2(t, font);
1169     }
1170
1171     if (storeGlyphNames && font->glyphnames) {
1172         int c;
1173         t = swf_InsertTag(t, ST_GLYPHNAMES);
1174         swf_SetU16(t, WRITEFONTID);
1175         swf_SetU16(t, font->numchars);
1176         for (c = 0; c < font->numchars; c++) {
1177             if (font->glyphnames[c])
1178                 swf_SetString(t, font->glyphnames[c]);
1179             else
1180                 swf_SetString(t, "");
1181         }
1182     }
1183
1184     if (1)                      //neccessary only for df1, but pretty to look at anyhow, so do it always
1185     {
1186         int textscale = 400;
1187         int s;
1188         int xmax = 0;
1189         int ymax = 0;
1190         int ypos = 1;
1191         U8 gbits, abits;
1192         int x, y, c;
1193         int range = font->maxascii;
1194
1195         c = 0;
1196         if (useDefineFont2 && range > 256) {
1197             range = 256;
1198         }
1199
1200         for (s = 0; s < range; s++) {
1201             int g = font->ascii2glyph[s];
1202             if (g >= 0) {
1203                 if ((font->glyph[g].advance * textscale / 20) / 64 > xmax) {
1204                     xmax = (font->glyph[g].advance * textscale / 20) / 64;
1205                 }
1206                 c++;
1207             }
1208             if ((s & 15) == 0) {
1209                 if (c) {
1210                     ypos++;
1211                 }
1212                 c = 0;
1213             }
1214         }
1215         ymax = ypos * textscale * 2;
1216
1217         swf.movieSize.xmax = xmax * 20;
1218         swf.movieSize.ymax = ymax;
1219
1220         t = swf_InsertTag(t, ST_DEFINETEXT);
1221
1222         swf_SetU16(t, font->id + 1);    // ID
1223
1224         r.xmin = 0;
1225         r.ymin = 0;
1226         r.xmax = swf.movieSize.xmax;
1227         r.ymax = swf.movieSize.ymax;
1228
1229         swf_SetRect(t, &r);
1230
1231         swf_SetMatrix(t, NULL);
1232
1233         abits = swf_CountBits(xmax * 16, 0);
1234         gbits = 8;
1235
1236         swf_SetU8(t, gbits);
1237         swf_SetU8(t, abits);
1238
1239         rgb.r = 0x00;
1240         rgb.g = 0x00;
1241         rgb.b = 0x00;
1242         ypos = 1;
1243         for (y = 0; y < ((range + 15) / 16); y++) {
1244             int c = 0, lastx = -1;
1245             for (x = 0; x < 16; x++) {
1246                 int g = (y * 16 + x < range) ? font->ascii2glyph[y * 16 + x] : -1;
1247                 if (g >= 0 && font->glyph[g].shape) {
1248                     c++;
1249                     if (lastx < 0)
1250                         lastx = x * xmax;
1251                 }
1252             }
1253             if (c) {
1254                 swf_TextSetInfoRecord(t, font, textscale, &rgb, lastx + 1, textscale * ypos * 2);
1255                 for (x = 0; x < 16; x++) {
1256                     int g = (y * 16 + x < range) ? font->ascii2glyph[y * 16 + x] : -1;
1257                     if (g >= 0 && font->glyph[g].shape) {
1258                         if (lastx != x * xmax) {
1259                             swf_TextSetInfoRecord(t, 0, 0, 0, x * xmax + 1, 0);
1260                         }
1261                         swf_SetU8(t, 1);
1262                         swf_SetBits(t, g, gbits);
1263                         swf_SetBits(t, font->glyph[g].advance / 20, abits);
1264                         lastx = x * xmax + (font->glyph[g].advance / 20);
1265                         swf_ResetWriteBits(t);
1266                     }
1267                 }
1268                 ypos++;
1269             }
1270         }
1271         swf_SetU8(t, 0);
1272
1273
1274         t = swf_InsertTag(t, ST_PLACEOBJECT2);
1275
1276         swf_ObjectPlace(t, font->id + 1, 1, NULL, NULL, NULL);
1277
1278         t = swf_InsertTag(t, ST_SHOWFRAME);
1279
1280     }
1281
1282     t = swf_InsertTag(t, ST_END);
1283
1284     f = open(filename, O_RDWR | O_CREAT | O_TRUNC, 0644);
1285     if FAILED
1286         (swf_WriteSWF(f, &swf)) fprintf(stderr, "WriteSWF() failed in writeFont().\n");
1287     close(f);
1288
1289     swf_FreeTags(&swf);
1290 }
1291
1292
1293 void swf_SetEditText(TAG * tag, U16 flags, SRECT r, char *text, RGBA * color, int maxlength, U16 font, U16 height, EditTextLayout * layout, char *variable)
1294 {
1295     swf_SetRect(tag, &r);
1296     swf_ResetWriteBits(tag);
1297
1298     flags &= ~(ET_HASTEXT | ET_HASTEXTCOLOR | ET_HASMAXLENGTH | ET_HASFONT | ET_HASLAYOUT);
1299     if (text)
1300         flags |= ET_HASTEXT;
1301     if (color)
1302         flags |= ET_HASTEXTCOLOR;
1303     if (maxlength)
1304         flags |= ET_HASMAXLENGTH;
1305     if (font)
1306         flags |= ET_HASFONT;
1307     if (layout)
1308         flags |= ET_HASLAYOUT;
1309
1310     swf_SetBits(tag, flags, 16);
1311
1312     if (flags & ET_HASFONT) {
1313         swf_SetU16(tag, font);  //font
1314         swf_SetU16(tag, height);        //fontheight
1315     }
1316     if (flags & ET_HASTEXTCOLOR) {
1317         swf_SetRGBA(tag, color);
1318     }
1319     if (flags & ET_HASMAXLENGTH) {
1320         swf_SetU16(tag, maxlength);     //maxlength
1321     }
1322     if (flags & ET_HASLAYOUT) {
1323         swf_SetU8(tag, layout->align);  //align
1324         swf_SetU16(tag, layout->leftmargin);    //left margin
1325         swf_SetU16(tag, layout->rightmargin);   //right margin
1326         swf_SetU16(tag, layout->indent);        //indent
1327         swf_SetU16(tag, layout->leading);       //leading
1328     }
1329     swf_SetString(tag, variable);
1330     if (flags & ET_HASTEXT)
1331         swf_SetString(tag, text);
1332 }
1333
1334 SRECT swf_SetDefineText(TAG * tag, SWFFONT * font, RGBA * rgb, char *text, int scale)
1335 {
1336     SRECT r;
1337     U8 gbits, abits;
1338     U8 *c = (U8 *) text;
1339     int pos = 0;
1340     if (font->layout) {
1341         r = swf_TextCalculateBBoxUTF8(font, text, scale * 20);
1342     } else {
1343         fprintf(stderr, "No layout information- can't compute text bbox accurately");
1344         /* Hm, without layout information, we can't compute a bounding
1345            box. We could call swf_FontCreateLayout to create a layout,
1346            but the caller probably doesn't want us to mess up his font
1347            structure.
1348          */
1349         r.xmin = r.ymin = 0;
1350         r.xmax = r.ymax = 1024 * 20;
1351     }
1352
1353     swf_SetRect(tag, &r);
1354
1355     /* The text matrix is pretty boring, as it doesn't apply to
1356        individual characters, but rather whole text objects (or
1357        at least whole char records- haven't tested).
1358        So it can't do anything which we can't already do with
1359        the placeobject tag we use for placing the text on the scene.
1360      */
1361     swf_SetMatrix(tag, 0);
1362
1363     swf_TextCountBitsUTF8(font, text, scale * 20, &gbits, &abits);
1364     swf_SetU8(tag, gbits);
1365     swf_SetU8(tag, abits);
1366
1367     /* now set the text params- notice that a font size of
1368        1024 means that the glyphs will be displayed exactly
1369        as they would be in/with a defineshape. (Try to find
1370        *that* in the flash specs)
1371      */
1372     swf_TextSetInfoRecord(tag, font, (scale * 1024) / 100, rgb, 0, 0);  //scale
1373
1374     /* set the actual text- notice that we just pass our scale
1375        parameter over, as TextSetCharRecord calculates with
1376        percent, too */
1377     swf_TextSetCharRecordUTF8(tag, font, text, scale * 20, gbits, abits);
1378
1379     swf_SetU8(tag, 0);
1380     return r;
1381 }
1382
1383 void swf_FontCreateLayout(SWFFONT * f)
1384 {
1385     S16 leading = 0;
1386     int t;
1387     if (f->layout)
1388         return;
1389     if (!f->numchars)
1390         return;
1391
1392     f->layout = (SWFLAYOUT *) malloc(sizeof(SWFLAYOUT));
1393     memset(f->layout, 0, sizeof(SWFLAYOUT));
1394     f->layout->bounds = (SRECT *) malloc(f->numchars * sizeof(SRECT));
1395     f->layout->ascent = -32767;
1396     f->layout->descent = -32767;
1397
1398     for (t = 0; t < f->numchars; t++) {
1399         SHAPE2 *shape2;
1400         SRECT bbox;
1401         int width;
1402         shape2 = swf_ShapeToShape2(f->glyph[t].shape);
1403         if (!shape2) {
1404             fprintf(stderr, "Shape parse error\n");
1405             exit(1);
1406         }
1407         bbox = swf_GetShapeBoundingBox(shape2);
1408         swf_Shape2Free(shape2);
1409         f->layout->bounds[t] = bbox;
1410
1411         width = (bbox.xmax);
1412
1413         /* The following is a heuristic- it may be that extractfont_DefineText
1414            has already found out some widths for individual characters (from the way
1415            they are used)- we now have to guess whether that width might be possible,
1416            which is the case if it isn't either much too big or much too small */
1417         if (width > f->glyph[t].advance * 3 / 2 || width < f->glyph[t].advance / 2)
1418             f->glyph[t].advance = width;
1419
1420         if (-bbox.ymin > f->layout->ascent)
1421             f->layout->ascent = bbox.ymin;
1422         if (bbox.ymax > f->layout->descent)
1423             f->layout->descent = bbox.ymax;
1424     }
1425 }
1426
1427 void swf_DrawText(drawer_t * draw, SWFFONT * font, int size, char *text)
1428 {
1429     U8 *s = (U8 *) text;
1430     int advance = 0;
1431     while (*s) {
1432         SHAPE *shape;
1433         SHAPE2 *shape2;
1434         SHAPELINE *l;
1435         U32 c = readUTF8char(&s);
1436         int g = font->ascii2glyph[c];
1437         shape = font->glyph[g].shape;
1438         if (((int) g) < 0) {
1439             fprintf(stderr, "No char %d in font %s\n", c, font->name ? (char *) font->name : "?");
1440             continue;
1441         }
1442         shape2 = swf_ShapeToShape2(shape);
1443         l = shape2->lines;
1444         while (l) {
1445             if (l->type == moveTo) {
1446                 FPOINT to;
1447                 to.x = l->x * size / 100.0 / 20.0 + advance;
1448                 to.y = l->y * size / 100.0 / 20.0;
1449                 draw->moveTo(draw, &to);
1450             } else if (l->type == lineTo) {
1451                 FPOINT to;
1452                 to.x = l->x * size / 100.0 / 20.0 + advance;
1453                 to.y = l->y * size / 100.0 / 20.0;
1454                 draw->lineTo(draw, &to);
1455             } else if (l->type == splineTo) {
1456                 FPOINT mid, to;
1457                 mid.x = l->sx * size / 100.0 / 20.0 + advance;
1458                 mid.y = l->sy * size / 100.0 / 20.0;
1459                 to.x = l->x * size / 100.0 / 20.0 + advance;
1460                 to.y = l->y * size / 100.0 / 20.0;
1461                 draw->splineTo(draw, &mid, &to);
1462             }
1463             l = l->next;
1464         }
1465         swf_Shape2Free(shape2);
1466         advance += font->glyph[g].advance * size / 100.0 / 20.0;
1467     }
1468 }