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