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