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