9297be9e1468a59096bb3f8f132f2a98c3398b0d
[swftools.git] / 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  
10    This file is distributed under the GPL, see file COPYING for details 
11
12 */
13
14 #define TF_TEXTCONTROL  0x80
15 #define TF_HASFONT      0x08
16 #define TF_HASCOLOR     0x04
17 #define TF_HASYOFFSET   0x02
18 #define TF_HASXOFFSET   0x01
19
20 #define FF_WIDECODES    0x01
21 #define FF_BOLD         0x02
22 #define FF_ITALIC       0x04
23 #define FF_ANSI         0x08
24 #define FF_SHIFTJIS     0x10
25 #define FF_UNICODE      0x20
26
27 #define FF2_BOLD         0x01
28 #define FF2_ITALIC       0x02
29 #define FF2_WIDECODES    0x04
30 #define FF2_WIDEOFFSETS  0x08
31 #define FF2_ANSI         0x10
32 #define FF2_UNICODE      0x20
33 #define FF2_SHIFTJIS     0x40
34 #define FF2_LAYOUT       0x80
35
36 int swf_FontIsItalic(SWFFONT * f) { return f->style&FONT_STYLE_ITALIC;}
37 int swf_FontIsBold(SWFFONT * f)   { return f->style&FONT_STYLE_BOLD;}
38
39 static const int WRITEFONTID = 0x4e46; // font id for WriteFont and ReadFont
40
41 int swf_FontEnumerate(SWF * swf,void (*FontCallback) (U16,U8*))
42 { int n;
43   TAG * t;
44   if (!swf) return -1;
45   t = swf->firstTag;
46   n = 0;
47
48   while (t)
49   { if (swf_GetTagID(t)==ST_DEFINEFONTINFO || swf_GetTagID(t)==ST_DEFINEFONTINFO2 ||
50           swf_GetTagID(t)==ST_DEFINEFONT2)
51     { n++;
52       if (FontCallback)
53       { U16 id;
54         int l;
55         U8 s[257];
56         swf_SaveTagPos(t);
57         swf_SetTagPos(t,0);
58         
59         id  = swf_GetU16(t);
60         if(swf_GetTagID(t) == ST_DEFINEFONT2)
61             swf_GetU16(t);
62         l   = swf_GetU8(t);
63         swf_GetBlock(t,s,l);
64         s[l] = 0;
65
66         (FontCallback)(id,s); 
67       
68         swf_RestoreTagPos(t);
69       }
70     }
71     t = swf_NextTag(t);
72   }
73   return n;
74 }
75
76 int swf_FontExtract_DefineFont(int id,SWFFONT * f,TAG * t)
77 { U16 fid;
78   swf_SaveTagPos(t);
79   swf_SetTagPos(t,0);
80
81   fid = swf_GetU16(t);
82   if ((!id)||(id==fid))
83   { U16 of;
84     int n,i;
85       
86     id = fid;
87     f->version = 1;
88     f->id = fid;
89
90     of = swf_GetU16(t);
91     n = of/2;
92     f->numchars = n;
93     f->glyph = malloc(sizeof(SWFGLYPH)*n);
94     memset(f->glyph, 0, sizeof(SWFGLYPH)*n);
95
96     for (i=1;i<n;i++) swf_GetU16(t);
97     for (i=0;i<n;i++) swf_GetSimpleShape(t,&f->glyph[i].shape);
98   }
99
100   swf_RestoreTagPos(t);
101   return id;
102 }
103
104 int swf_FontExtract_DefineFontInfo(int id,SWFFONT * f,TAG * t)
105 { U16 fid;
106   U16 maxcode;
107   U8 flags;
108   swf_SaveTagPos(t);
109   swf_SetTagPos(t,0);
110
111   fid = swf_GetU16(t);
112   if (fid==id)
113   { U8 l = swf_GetU8(t);
114     int i;
115   
116     if(f->version>1) {
117       /* Especially with Flash MX, DefineFont2 may have FontInfo fields,
118          too. However, they only add little information to what's already
119          inside the DefineFont2 tag */
120       return id;
121     }
122     
123     if (l)
124     { if (f->name) free(f->name);
125       f->name = (U8*)malloc(l+1);
126       if (f->name)
127       { swf_GetBlock(t,f->name,l);
128         f->name[l] = 0;
129       }
130       else
131       { swf_RestoreTagPos(t);
132         return -1;
133       }
134     }
135     flags = swf_GetU8(t);
136     if(flags & 2)
137         f->style |= FONT_STYLE_BOLD;
138     if(flags & 4)
139         f->style |= FONT_STYLE_ITALIC;
140     if(flags & 8)
141         f->encoding |= FONT_ENCODING_ANSI;
142     if(flags & 16)
143         f->encoding |= FONT_ENCODING_SHIFTJIS;
144     if(flags & 32)
145         f->encoding |= FONT_ENCODING_UNICODE;
146
147     if(t->id == ST_DEFINEFONTINFO2) {
148         f->language = swf_GetU8(t);
149     }
150
151     f->glyph2ascii = (U16*)malloc(sizeof(U16)*f->numchars);
152     maxcode = 0;
153     for(i=0; i < f->numchars; i++) {
154       f->glyph2ascii[i] = ((flags&FF_WIDECODES)?swf_GetU16(t):swf_GetU8(t));
155       if(f->glyph2ascii[i] > maxcode)
156           maxcode = f->glyph2ascii[i];
157     }
158     maxcode++;
159     if(maxcode<256)
160         maxcode=256;
161     f->maxascii = maxcode;
162     f->ascii2glyph = (int*)malloc(sizeof(int)*maxcode);
163     memset(f->ascii2glyph, -1, sizeof(int)*maxcode);
164      
165     for(i = 0; i < f->numchars; i++)
166       f->ascii2glyph[f->glyph2ascii[i]] = i;
167   }
168
169   swf_RestoreTagPos(t);
170   return id;
171 }
172
173 int swf_FontExtract_DefineFont2(int id,SWFFONT * font,TAG * tag)
174 {
175     int t, glyphcount;
176     int maxcode;
177     int fid;
178     U8 flags1,flags2,namelen;
179     swf_SaveTagPos(tag);
180     swf_SetTagPos(tag,0);
181     font->version=2;
182     fid = swf_GetU16(tag);
183     if(id && id!=fid)
184         return id;
185     font->id = fid;
186     flags1 = swf_GetU8(tag);
187     flags2 = swf_GetU8(tag); //reserved flags
188
189     if(flags1 & 1)
190         font->style |= FONT_STYLE_BOLD;
191     if(flags1 & 2)
192         font->style |= FONT_STYLE_ITALIC;
193     if(flags1 & 16)
194         font->encoding |= FONT_ENCODING_ANSI;
195     if(flags1 & 32)
196         font->encoding |= FONT_ENCODING_UNICODE;
197     if(flags1 & 64)
198         font->encoding |= FONT_ENCODING_SHIFTJIS;
199
200     namelen = swf_GetU8(tag);
201     font->name = (U8*)malloc(namelen+1);
202     font->name[namelen]=0;
203     swf_GetBlock(tag, font->name, namelen);
204     font->version = 2;
205     glyphcount = swf_GetU16(tag);
206     font->numchars = glyphcount;
207     
208     font->glyph = (SWFGLYPH*)malloc(sizeof(SWFGLYPH)*glyphcount);
209     memset(font->glyph, 0, sizeof(SWFGLYPH)*glyphcount);
210     font->glyph2ascii = (U16*)malloc(sizeof(U16)*glyphcount);
211     memset(font->glyph2ascii, 0, sizeof(U16)*glyphcount);
212
213     if(flags1&8) { // wide offsets
214         for(t=0;t<glyphcount;t++)
215             swf_GetU32(tag); //offset[t]
216         
217         if(glyphcount) /* this _if_ is not in the specs */
218             swf_GetU32(tag); // fontcodeoffset
219     } else {
220         for(t=0;t<glyphcount;t++)
221             swf_GetU16(tag); //offset[t]
222
223         if(glyphcount) /* this _if_ is not in the specs */
224             swf_GetU16(tag); // fontcodeoffset
225     }
226     for(t=0;t<glyphcount;t++)
227         swf_GetSimpleShape(tag,&(font->glyph[t].shape));
228
229     maxcode = 0;
230     for(t=0;t<glyphcount;t++) {
231         int code;
232         if(flags1&4) // wide codes
233             code = swf_GetU16(tag);
234         else
235             code = swf_GetU8(tag);
236         font->glyph2ascii[t] = code;
237         if(code > maxcode)
238             maxcode = code;
239     }
240     maxcode++;
241     if(maxcode<256)
242         maxcode=256;
243     font->maxascii = maxcode;
244     font->ascii2glyph = (int*)malloc(sizeof(int)*maxcode);
245     memset(font->ascii2glyph, -1, sizeof(int)*maxcode);
246     for(t=0;t<glyphcount;t++) 
247     {
248         font->ascii2glyph[font->glyph2ascii[t]] = t;
249     }
250
251     if(flags1&128) { // has layout
252         U16 kerningcount;
253         font->layout = (SWFLAYOUT*)malloc(sizeof(SWFLAYOUT));
254         font->layout->ascent=swf_GetU16(tag);
255         font->layout->descent=swf_GetU16(tag);
256         font->layout->leading=swf_GetU16(tag);
257         for(t=0;t<glyphcount;t++) {
258             S16 advance = swf_GetS16(tag);
259             font->glyph[t].advance = advance;
260         }
261         font->layout->bounds = malloc(glyphcount*sizeof(SRECT));
262         for(t=0;t<glyphcount;t++) {
263             swf_ResetReadBits(tag);
264             swf_GetRect(tag, &font->layout->bounds[t]);
265         }
266
267         kerningcount = swf_GetU16(tag);
268         font->layout->kerningcount = kerningcount;
269
270         font->layout->kerning = (SWFKERNING*)malloc(sizeof(SWFKERNING)*kerningcount);
271         if(kerningcount) {
272             font->layout->kerning = 
273                 malloc(sizeof(*font->layout->kerning)* kerningcount);
274             for(t=0;t<kerningcount;t++)
275             {
276                 if(flags1&4) { // wide codes
277                     font->layout->kerning[t].char1 = swf_GetU16(tag);
278                     font->layout->kerning[t].char2 = swf_GetU16(tag);
279                 } else {
280                     font->layout->kerning[t].char1 = swf_GetU8(tag);
281                     font->layout->kerning[t].char2 = swf_GetU8(tag);
282                 }
283                 font->layout->kerning[t].adjustment = swf_GetS16(tag);
284             }
285         }
286     }
287     swf_RestoreTagPos(t);
288     return font->id;
289 }
290
291
292 #define FEDTJ_PRINT  0x01
293 #define FEDTJ_MODIFY 0x02
294 #define FEDTJ_CALLBACK 0x04
295
296 int swf_FontExtract_DefineTextCallback(int id,SWFFONT * f,TAG * t,int jobs, 
297         void(*callback)(int*chars, int nr, int fontid))
298 { U16    cid;
299   SRECT  r;
300   MATRIX m;
301   U8     gbits, abits, flags;
302   int    fid;
303
304   fid = 0;
305
306   swf_SaveTagPos(t);
307   swf_SetTagPos(t,0);
308
309   cid = swf_GetU16(t);
310   swf_GetRect(t,&r);
311   swf_GetMatrix(t,&m);
312   gbits = swf_GetU8(t);
313   abits = swf_GetU8(t);
314
315   flags = swf_GetU8(t);
316   
317   while(flags)
318   { if (flags&TF_TEXTCONTROL)
319     { if (flags&TF_HASFONT) fid = swf_GetU16(t);
320       if (flags&TF_HASCOLOR)
321       { swf_GetU8(t); // rgb
322         swf_GetU8(t);
323         swf_GetU8(t);
324         if (swf_GetTagID(t)==ST_DEFINETEXT2) swf_GetU8(t);
325       }
326       if (flags&TF_HASXOFFSET) swf_GetS16(t);
327       if (flags&TF_HASYOFFSET) swf_GetS16(t);
328       if (flags&TF_HASFONT) swf_GetU16(t);
329     }
330     else
331     { int i;
332       int buf[256];
333       for (i=0;i<flags;i++)
334       { int glyph;
335         int adv;
336         glyph = swf_GetBits(t,gbits);
337         adv = swf_GetBits(t,abits);
338         if (id==fid)                    // mitlesen ?
339           if (jobs&FEDTJ_PRINT) {
340             { int code = f->glyph2ascii[glyph];
341               printf("%c",code);
342           }
343           if (jobs&FEDTJ_MODIFY)
344             /*if (!f->glyph[code].advance)*/ f->glyph[glyph].advance = adv;
345         }
346         buf[i] = glyph;
347       }
348       if ((id==fid)&&(jobs&FEDTJ_PRINT)) printf("\n");
349       if (jobs&FEDTJ_CALLBACK)
350           callback(buf, flags, fid);
351     }
352     flags = swf_GetU8(t);
353   }
354   
355   swf_RestoreTagPos(t);
356   return id;
357 }  
358
359 int swf_FontExtract_DefineText(int id,SWFFONT * f,TAG * t,int jobs)
360 {
361     return swf_FontExtract_DefineTextCallback(id,f,t,jobs,0);
362 }
363
364 int swf_FontExtract(SWF * swf,int id,SWFFONT * * font)
365 { TAG * t;
366   SWFFONT * f;
367     
368   if ((!swf)||(!font)) return -1;
369
370   f = (SWFFONT *)malloc(sizeof(SWFFONT)); font[0] = f;
371   if (!f) return -1;
372   
373   memset(f,0x00,sizeof(SWFFONT));
374
375   t = swf->firstTag;
376
377   while (t)
378   { int nid = 0;
379     switch (swf_GetTagID(t))
380     { case ST_DEFINEFONT:
381         nid = swf_FontExtract_DefineFont(id,f,t);
382         break;
383     
384       case ST_DEFINEFONT2:
385         nid = swf_FontExtract_DefineFont2(id,f,t);
386         break;
387         
388       case ST_DEFINEFONTINFO:
389         nid = swf_FontExtract_DefineFontInfo(id,f,t);
390         break;
391         
392       case ST_DEFINETEXT:
393       case ST_DEFINETEXT2:
394         nid = swf_FontExtract_DefineText(id,f,t,f->layout?0:FEDTJ_MODIFY);
395         break;
396     }
397     if (nid>0) id = nid;
398     t = swf_NextTag(t);
399   }
400   return 0;
401 }
402
403 int swf_FontSetID(SWFFONT * f,U16 id) { if (!f) return -1; f->id = id; return 0; }
404
405 int swf_FontReduce(SWFFONT * f,FONTUSAGE * use)
406 { int i,j;
407   if ((!f)||(!use)) return -1;
408
409   j = 0;
410   for (i=0;i<f->numchars;i++)
411     if (f->glyph[i].shape)
412     { if (f->glyph2ascii[i]<MAX_CHAR_PER_FONT && 
413             use->code[f->glyph2ascii[i]])
414       { f->ascii2glyph[f->glyph2ascii[i]] = j;
415         f->glyph2ascii[j] = f->glyph2ascii[i];
416         f->glyph[j] = f->glyph[i];
417         j++;
418       }
419       else
420       { swf_ShapeFree(f->glyph[i].shape);
421         f->ascii2glyph[f->glyph2ascii[i]] = -1;
422         f->glyph2ascii[i] = 0;
423         f->glyph[i].shape   = NULL;
424         f->glyph[i].advance = 0;
425       }
426     } else f->ascii2glyph[f->glyph2ascii[i]] = -1;
427
428   f->numchars = j;
429     
430   return j;
431 }
432
433 int swf_FontInitUsage(FONTUSAGE * use)
434 { if (!use) return -1;
435   memset(use->code,0,sizeof(use->code[0])*MAX_CHAR_PER_FONT);
436   return 0;
437 }
438
439 int swf_FontUse(FONTUSAGE * use,U8 * s)
440 { if ((!use)||(!s)) return -1;
441   while (s[0])
442   { use->code[s[0]] = 1;
443     s++;
444   }
445   return 0;  
446 }
447
448 int swf_FontSetDefine(TAG * t,SWFFONT * f)
449 { U16*ofs = (U16*)malloc(f->numchars*2);
450   int p,i,j;
451     
452   if ((!t)||(!f)) return -1;
453   swf_ResetWriteBits(t);
454   swf_SetU16(t,f->id);
455
456   p = 0; j = 0;
457   for (i=0;i<f->numchars;i++)
458     if (f->glyph[i].shape)
459     { ofs[j++] = p;
460       p+=swf_SetSimpleShape(NULL,f->glyph[i].shape);
461     }
462
463   for (i=0;i<j;i++) swf_SetU16(t,ofs[i]+j*2);
464   
465   for (i=0;i<f->numchars;i++)
466     if (f->glyph[i].shape)
467       swf_SetSimpleShape(t,f->glyph[i].shape);
468   
469   swf_ResetWriteBits(t);
470   free(ofs);
471   return 0;
472 }
473
474 int swf_FontSetDefine2(TAG *tag, SWFFONT * f)
475 {
476     U8 flags = 0;
477     int t;
478     int pos;
479     int pos2;
480     swf_SetU16(tag, f->id);
481     if(f->layout) 
482         flags |= 128; // haslayout
483     if(f->numchars>256)
484         flags |= 4; // widecodes
485     if(f->style & FONT_STYLE_BOLD)
486         flags |= 1; // bold
487     if(f->style & FONT_STYLE_ITALIC)
488         flags |= 2; // italic
489     /* wideoffs 8 */
490     if(f->encoding & FONT_ENCODING_ANSI)
491         flags |= 16; // ansi
492     if(f->encoding & FONT_ENCODING_UNICODE)
493         flags |= 32; // unicode
494     if(f->encoding & FONT_ENCODING_SHIFTJIS)
495         flags |= 64; // shiftjis
496
497     swf_SetU8(tag, flags);
498     swf_SetU8(tag, 0); //reserved flags
499     if(f->name) {
500         /* font name */
501         swf_SetU8(tag, strlen(f->name));
502         swf_SetBlock(tag, f->name, strlen(f->name));
503     } else {
504         /* font name (="") */
505         swf_SetU8(tag, 0); /*placeholder*/
506     }
507     /* number of glyphs */
508     swf_SetU16(tag, f->numchars);
509     /* font offset table */
510     pos = tag->len;
511     for(t=0;t<f->numchars;t++)
512     {
513         swf_SetU16(tag, /* fontoffset */ 0); /*placeholder*/
514     }
515     pos2 = tag->len;
516     swf_SetU16(tag, 0); //fontcode-fontoffset
517     for(t=0;t<f->numchars;t++) {
518         tag->data[pos + t*2] = (tag->len-pos);
519         tag->data[pos + t*2 + 1] = (tag->len-pos) >> 8;
520         swf_SetSimpleShape(tag, f->glyph[t].shape);
521     }
522
523     tag->data[pos2] = tag->len - pos;
524     tag->data[pos2 + 1] = (tag->len - pos) >> 8;
525     
526     /* font code table */
527     if(flags & 4) /* wide codes */ {
528         for(t=0;t<f->numchars;t++)
529             swf_SetU16(tag,f->glyph2ascii[t]);
530     } else {
531         for(t=0;t<f->numchars;t++)
532             swf_SetU8(tag,f->glyph2ascii[t]);
533     }
534     if(f->layout) 
535     {
536         swf_SetU16(tag,f->layout->ascent);
537         swf_SetU16(tag,f->layout->descent);
538         swf_SetU16(tag,f->layout->leading);
539         for(t=0;t<f->numchars;t++)
540             swf_SetU16(tag,f->glyph[t].advance);
541         for(t=0;t<f->numchars;t++) {
542             swf_ResetWriteBits(tag);
543             swf_SetRect(tag,&f->layout->bounds[t]);
544         }
545         swf_SetU16(tag, f->layout->kerningcount);
546         for(t=0;t<f->layout->kerningcount;t++) {
547             if(flags & 4) /* wide codes */ {
548                 swf_SetU8(tag,f->layout->kerning[t].char1);
549                 swf_SetU8(tag,f->layout->kerning[t].char2);
550             } else {
551                 swf_SetU16(tag,f->layout->kerning[t].char1);
552                 swf_SetU16(tag,f->layout->kerning[t].char2);
553             }
554             swf_SetU16(tag,f->layout->kerning[t].adjustment);
555         }
556     }
557     return 0;
558 }
559     
560 void swf_FontAddLayout(SWFFONT * f, int ascent, int descent, int leading)
561 {
562     f->layout = (SWFLAYOUT*)malloc(sizeof(SWFLAYOUT));
563     f->layout->ascent = ascent;
564     f->layout->descent = descent;
565     f->layout->leading = leading;
566     f->layout->kerningcount = 0;
567     f->layout->kerning = 0;
568     f->layout->bounds = (SRECT*)malloc(sizeof(SRECT)*f->numchars);
569     memset(f->layout->bounds, 0, sizeof(SRECT)*f->numchars);
570 }
571
572 int swf_FontSetInfo(TAG * t,SWFFONT * f)
573 { int l,i;
574   U8 wide=0;
575   U8 flags = 0;
576   if ((!t)||(!f)) return -1;
577   swf_ResetWriteBits(t);
578   swf_SetU16(t,f->id);
579   l = strlen(f->name); if (l>255) l = 255;
580   swf_SetU8(t,l);
581   swf_SetBlock(t,f->name,l);
582   if(f->numchars>=256)
583       wide=1;
584
585   if(f->style & FONT_STYLE_BOLD)
586       flags |= 2;
587   if(f->style & FONT_STYLE_ITALIC)
588       flags |= 4;
589   if(f->style & FONT_ENCODING_ANSI)
590       flags |= 8;
591   if(f->style & FONT_ENCODING_SHIFTJIS)
592       flags |= 16;
593   if(f->style & FONT_ENCODING_UNICODE)
594       flags |= 32;
595     
596   swf_SetU8(t,(flags&0xfe)|wide);
597
598   for (i=0;i<f->numchars;i++) {
599     if (f->glyph[i].shape)
600       wide?swf_SetU16(t,f->glyph2ascii[i]):
601            swf_SetU8(t,f->glyph2ascii[i]);
602   }
603   
604   return 0;
605 }
606
607 int swf_TextPrintDefineText(TAG * t,SWFFONT * f)
608 { int id = swf_GetTagID(t);
609   if ((id==ST_DEFINETEXT)||(id==ST_DEFINETEXT2)) swf_FontExtract_DefineText(f->id,f,t,FEDTJ_PRINT);
610     else return -1;
611   return 0;
612 }
613
614 void swf_LayoutFree(SWFLAYOUT * l)
615 { if (l)
616   { if (l->kerning) free(l->kerning);
617     l->kerning = NULL;
618     if (l->bounds) free(l->bounds);
619     l->bounds = NULL;
620   }
621   free(l);
622 }
623
624 void swf_FontFree(SWFFONT * f)
625 { if (f)
626   { int i;
627       
628     if (f->name) free(f->name);
629     if (f->layout) swf_LayoutFree(f->layout);
630
631     f->name = NULL;
632     f->layout = NULL;
633
634     if(f->glyph) {
635       for (i=0;i<f->numchars;i++)
636         if (f->glyph[i].shape)
637         { swf_ShapeFree(f->glyph[i].shape);
638           f->glyph[i].shape = NULL;
639         }
640       free(f->glyph);
641       f->glyph = NULL;
642     }
643     if(f->ascii2glyph) {
644       free(f->ascii2glyph);
645       f->ascii2glyph = NULL;
646     }
647     if(f->glyph2ascii) {
648       free(f->glyph2ascii);
649       f->glyph2ascii = NULL;
650     }
651   }
652   free(f);
653 }
654
655 int swf_TextSetInfoRecord(TAG * t,SWFFONT * font,U16 size,RGBA * color,S16 dx,S16 dy)
656 { U8 flags;
657   if (!t) return -1;
658
659   flags = TF_TEXTCONTROL|(font?TF_HASFONT:0)|(color?TF_HASCOLOR:0)|(dx?TF_HASXOFFSET:0)|(dy?TF_HASYOFFSET:0);
660
661   swf_SetU8(t,flags);
662   if (font) swf_SetU16(t,font->id);
663   if (color)
664   { if (swf_GetTagID(t)==ST_DEFINETEXT2) swf_SetRGBA(t,color);
665     else swf_SetRGB(t,color);
666   }
667   if (dx) swf_SetS16(t,dx);
668   if (dy) swf_SetS16(t,dy);
669   if (font) swf_SetU16(t,size);
670   
671   return 0;
672 }
673
674 int swf_TextCountBits(SWFFONT * font,U8 * s,int scale,U8 * gbits,U8 * abits)
675 { U16 g,a;
676   if ((!s)||(!font)||((!gbits)&&(!abits))||(!font->ascii2glyph)) return -1;
677   g = a = 0;
678
679   while(s[0])
680   { 
681     int glyph = font->ascii2glyph[s[0]];
682     if(glyph>=0) {
683        g = swf_CountBits(glyph,g);
684        a = swf_CountBits((((U32)font->glyph[glyph].advance)*scale)/100,a);
685     }
686     s++;
687   }
688
689   if (gbits) gbits[0] = (U8)g;
690   if (abits) abits[0] = (U8)a;
691
692   return 0;
693 }
694
695 int swf_TextSetCharRecord(TAG * t,SWFFONT * font,U8 * s,int scale,U8 gbits,U8 abits)
696 { int l,i;
697     
698   if ((!t)||(!font)||(!s)||(!font->ascii2glyph)) return -1;
699
700   l = strlen(s);
701   if (l>0x7f) l = 0x7f;
702   swf_SetU8(t,l);
703
704   for (i=0;i<l;i++)
705   { 
706     int g = font->ascii2glyph[s[i]];
707     if(g>=0) {
708       swf_SetBits(t,g,gbits);
709       swf_SetBits(t,(((U32)font->glyph[g].advance)*scale)/100,abits);
710     }
711   }
712
713   swf_ResetWriteBits(t);
714   return 0;
715 }
716
717 U32 swf_TextGetWidth(SWFFONT * font,U8 * s,int scale)
718 { U32 res = 0;
719
720   if (font&&s)
721   { while (s[0])
722     { 
723       int g = font->ascii2glyph[*s];
724       if(g>=0)
725         res += font->glyph[g].advance;
726       s++;
727     }
728     if (scale) res = (res*scale)/100;
729   }
730   return res;
731 }
732
733 SWFFONT* swf_ReadFont(char* filename)
734 {
735   int f;
736   SWF swf;
737   if(!filename)
738       return 0;
739   f = open(filename,O_RDONLY);
740   
741   if (f<0 || swf_ReadSWF(f,&swf)<0)
742   { fprintf(stderr,"%s is not a valid SWF font file or contains errors.\n",filename);
743     close(f);
744     return 0;
745   }
746   else
747   { SWFFONT*font;
748     close(f);
749     if(swf_FontExtract(&swf, WRITEFONTID, &font) < 0)
750        return 0;
751     swf_FreeTags(&swf);
752     return font;
753   }
754 }
755
756 void swf_WriteFont(SWFFONT*font, char* filename)
757 { SWF swf;
758   TAG * t;
759   SRECT r;
760   RGBA rgb;
761   int f;
762   int useDefineFont2 = 0;
763
764   if(font->layout)
765       useDefineFont2 = 1; /* the only thing new in definefont2 
766                              is layout information. */
767
768   font->id = WRITEFONTID; //"FN"
769
770   memset(&swf,0x00,sizeof(SWF));
771
772   swf.fileVersion    = 4;
773   swf.frameRate      = 0x4000;
774
775   /* if we use DefineFont1 to store the characters,
776      we have to build a textfield to store the
777      advance values. While at it, we can also
778      make the whole .swf viewable */
779
780   /* we now always create viewable swfs, even if we
781      did use definefont2 -mk*/
782   t = swf_InsertTag(NULL,ST_SETBACKGROUNDCOLOR);
783   swf.firstTag = t;
784         rgb.r = 0xff;
785         rgb.g = 0xff;
786         rgb.b = 0xff;
787         swf_SetRGB(t,&rgb);
788   if(!useDefineFont2) {
789     t = swf_InsertTag(t,ST_DEFINEFONT);
790     swf_FontSetDefine(t,font);
791     t = swf_InsertTag(t,ST_DEFINEFONTINFO);
792     swf_FontSetInfo(t,font);
793   } else {
794     t = swf_InsertTag(t,ST_DEFINEFONT2);
795     swf_FontSetDefine2(t,font);
796   }
797
798   if(1) //useDefineFont2
799   {     int textscale = 400;
800         int s;
801         int xmax = 0;
802         int ymax = textscale * 2 * (font->maxascii/16+1);
803         U8 gbits,abits;
804         char text[MAX_CHAR_PER_FONT+1];
805         int x,y;
806         text[MAX_CHAR_PER_FONT]=0;
807         for(s=0;s<font->maxascii;s++)
808         {
809             int g = font->ascii2glyph[s];
810             text[s] = s;
811             if(g>=0) {
812                if(font->glyph[g].advance*textscale/64 > xmax)
813                    xmax = font->glyph[g].advance*textscale/64;
814             }
815         }
816         swf.movieSize.xmax = xmax*20;
817         swf.movieSize.ymax = ymax;
818
819         t = swf_InsertTag(t,ST_DEFINETEXT);
820
821             swf_SetU16(t,font->id+1);            // ID
822
823             r.xmin = 0;
824             r.ymin = 0;
825             r.xmax = swf.movieSize.xmax*20;
826             r.ymax = swf.movieSize.ymax;
827             
828             swf_SetRect(t,&r);
829
830             swf_SetMatrix(t,NULL);
831
832             abits = swf_CountBits(xmax*16, 0);
833             gbits = 8;
834             
835             swf_SetU8(t,gbits);
836             swf_SetU8(t,abits);
837
838             rgb.r = 0x00;
839             rgb.g = 0x00;
840             rgb.b = 0x00;
841             for(y=0;y<=((font->maxascii-1)/16);y++)
842             {
843                 int c=0,lastx=-1;
844                 /* TODO: firstx?? */
845                 for(x=0;x<16;x++) {
846                     int g = (y*16+x<font->maxascii)?font->ascii2glyph[y*16+x]:-1;
847                     if(g>=0 && font->glyph[g].shape) {
848                         c++;
849                         if(lastx<0) 
850                             lastx = x*xmax;
851                     }
852                 }
853                 if(c) {
854                   swf_TextSetInfoRecord(t,font,textscale,&rgb,lastx+1,textscale*y*2);
855                   for(x=0;x<16;x++)
856                   {
857                       int g = (y*16+x<font->maxascii)?font->ascii2glyph[y*16+x]:-1;
858                       if(g>=0 && font->glyph[g].shape) {
859                         if(lastx != x*xmax) {
860                             swf_TextSetInfoRecord(t,0,0,0,x*xmax+1,0);
861                         }
862                         swf_SetU8(t,1);
863                         swf_SetBits(t, g, gbits);
864                         swf_SetBits(t, font->glyph[g].advance, abits);
865                         lastx = x*xmax+font->glyph[g].advance;
866                         swf_ResetWriteBits(t);
867                       }
868                   }
869                 } 
870             }
871             swf_SetU8(t,0);
872
873         
874         t = swf_InsertTag(t,ST_PLACEOBJECT2);
875
876             swf_ObjectPlace(t,font->id+1,1,NULL,NULL,NULL);
877      
878         t = swf_InsertTag(t,ST_SHOWFRAME);
879   }
880   
881   t = swf_InsertTag(t,ST_END);
882
883   f = open(filename, O_RDWR|O_CREAT|O_TRUNC,0644);
884   if FAILED(swf_WriteSWF(f,&swf)) fprintf(stderr,"WriteSWF() failed in writeFont().\n");
885   close(f);
886
887   swf_FreeTags(&swf);
888 }
889
890
891 void swf_SetEditText(TAG*tag, U16 flags, SRECT r, char*text, RGBA*color, 
892         int maxlength, U16 font, U16 height, EditTextLayout*layout, char*variable)
893 {
894     swf_SetRect(tag,&r);
895     swf_ResetWriteBits(tag);
896
897     flags &= ~(ET_HASTEXT|ET_HASTEXTCOLOR|ET_HASMAXLENGTH|ET_HASFONT|ET_HASLAYOUT);
898     if(text) flags |= ET_HASTEXT;
899     if(color) flags |= ET_HASTEXTCOLOR;
900     if(maxlength) flags |= ET_HASMAXLENGTH;
901     if(font) flags |= ET_HASFONT;
902     if(layout) flags |= ET_HASLAYOUT;
903
904     swf_SetBits(tag, flags, 16);
905
906     if(flags & ET_HASFONT) {
907         swf_SetU16(tag, font); //font
908         swf_SetU16(tag, height); //fontheight
909     }
910     if(flags & ET_HASTEXTCOLOR) {
911         swf_SetRGBA(tag, color);
912     }
913     if(flags & ET_HASMAXLENGTH) {
914         swf_SetU16(tag, maxlength); //maxlength
915     }
916     if(flags & ET_HASLAYOUT) {
917         swf_SetU8(tag,layout->align); //align
918         swf_SetU16(tag,layout->leftmargin); //left margin
919         swf_SetU16(tag,layout->rightmargin); //right margin
920         swf_SetU16(tag,layout->indent); //indent
921         swf_SetU16(tag,layout->leading); //leading
922     }
923     swf_SetString(tag, variable);
924     if(flags & ET_HASTEXT)
925         swf_SetString(tag,text);
926 }
927
928 void swf_SetDefineText(TAG*tag, SWFFONT*font, RGBA*rgb, char*text, int scale)
929 {
930     SRECT r;
931     U8 gbits, abits;
932     
933     r.xmin = r.ymin = 0; /*FIXME*/
934     r.xmax = r.ymax = 1024*20;
935
936     swf_SetRect(tag,&r);
937     swf_SetMatrix(tag,NULL);
938     swf_TextCountBits(font,text,scale,&gbits,&abits);
939     swf_SetU8(tag,gbits);
940     swf_SetU8(tag,abits);
941     swf_TextSetInfoRecord(tag,font,scale,rgb,0,scale);
942     swf_TextSetCharRecord(tag,font,text,scale,gbits,abits);
943     swf_SetU8(tag,0);
944 }
945