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