X-Git-Url: http://git.asbjorn.biz/?a=blobdiff_plain;f=lib%2Fmodules%2Fswftext.c;h=ad17f1c4997e43b3d577964eb52e09f569de8df4;hb=d0884f3fcd06d63b52834d48076a100d0a4e9557;hp=59a8dd978c2f6f10a1e6b1cd6399dab8f680faa8;hpb=2fc61b512b22b9e155195bb25eed1d706a33a179;p=swftools.git

diff --git a/lib/modules/swftext.c b/lib/modules/swftext.c
index 59a8dd9..ad17f1c 100644
--- a/lib/modules/swftext.c
+++ b/lib/modules/swftext.c
@@ -6,6 +6,7 @@
    Part of the swftools package.
 
    Copyright (c) 2001 Rainer Böhme <rfxswf@reflex-studio.de>
+   Copyright (c) 2003,2004 Matthias Kramm
  
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -21,6 +22,50 @@
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
+static U32 readUTF8char(U8**text)
+{
+    U32 c = 0;
+    if(!(*(*text) & 0x80))
+	return *((*text)++);
+
+    /* 0000 0080-0000 07FF   110xxxxx 10xxxxxx */
+    if(((*text)[0] & 0xe0) == 0xc0 && (*text)[1])  
+    {
+	c = ((*text)[0] & 0x1f) << 6 | ((*text)[1] & 0x3f);
+	(*text) += 2;
+	return c;
+    }
+    /* 0000 0800-0000 FFFF   1110xxxx 10xxxxxx 10xxxxxx */
+    if(((*text)[0] & 0xf0) == 0xe0 && (*text)[1] && (*text)[2])
+    {
+	c = ((*text)[0] & 0x0f) << 12 | ((*text)[1] & 0x3f) << 6 | ((*text)[2] & 0x3f);
+	(*text) += 3;
+	return c;
+    }
+    /* 0001 0000-001F FFFF   11110xxx 10xxxxxx 10xxxxxx 10xxxxxx */
+    if(((*text)[0] & 0xf8) == 0xf0 && (*text)[1] && (*text)[2] && (*text)[3] )  
+    {
+	c = ((*text)[0] & 0x07) << 18 | ((*text)[1] & 0x3f) << 12 | ((*text)[2] & 0x3f)<<6 | ((*text)[3] & 0x3f);
+	(*text) += 4;
+	return c;
+    }
+    /* 0020 0000-03FF FFFF   111110xx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx */
+    if(((*text)[0] & 0xfc) == 0xf8 && (*text)[1] && (*text)[2] && (*text)[3] && (*text)[4])  
+    {
+	c = ((*text)[0] & 0x03) << 24 | ((*text)[1] & 0x3f) << 18 | ((*text)[2] & 0x3f)<<12 | ((*text)[3] & 0x3f) << 6 | ((*text)[4] & 0x3f);
+	(*text) += 5;
+	return c;
+    }
+    /* 0400 0000-7FFF FFFF   1111110x 10xxxxxx ... 10xxxxxx */
+    if(((*text)[0] & 0xfe) == 0xfc && (*text)[1] && (*text)[2] && (*text)[3] && (*text)[4] && (*text)[5])  
+    {
+	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;
+	(*text) += 6;
+	return c;
+    }
+    return *((*text)++);
+}
+
 #define TF_TEXTCONTROL  0x80
 #define TF_HASFONT      0x08
 #define TF_HASCOLOR     0x04
@@ -56,22 +101,26 @@ int swf_FontEnumerate(SWF * swf,void (*FontCallback) (U16,U8*))
   n = 0;
 
   while (t)
-  { if (swf_GetTagID(t)==ST_DEFINEFONTINFO || swf_GetTagID(t)==ST_DEFINEFONTINFO2 ||
-	  swf_GetTagID(t)==ST_DEFINEFONT2)
+  { 
+    if (swf_GetTagID(t)==ST_DEFINEFONT2 || swf_GetTagID(t)==ST_DEFINEFONT)
     { n++;
       if (FontCallback)
       { U16 id;
         int l;
         U8 s[257];
+	s[0] = 0;
         swf_SaveTagPos(t);
         swf_SetTagPos(t,0);
 	
         id  = swf_GetU16(t);
-	if(swf_GetTagID(t) == ST_DEFINEFONT2)
+	if(swf_GetTagID(t) == ST_DEFINEFONT2 ||
+	   swf_GetTagID(t) == ST_DEFINEFONTINFO ||
+	   swf_GetTagID(t) == ST_DEFINEFONTINFO2) {
 	    swf_GetU16(t);
-        l   = swf_GetU8(t);
-        swf_GetBlock(t,s,l);
-        s[l] = 0;
+	    l = swf_GetU8(t);
+            swf_GetBlock(t,s,l);
+            s[l] = 0;
+	}
 
         (FontCallback)(id,s); 
       
@@ -174,6 +223,31 @@ int swf_FontExtract_DefineFontInfo(int id,SWFFONT * f,TAG * t)
   return id;
 }
 
+int swf_FontExtract_GlyphNames(int id,SWFFONT * f,TAG * tag)
+{ 
+    U16 fid;
+    U16 maxcode;
+    U8 flags;
+    swf_SaveTagPos(tag);
+    swf_SetTagPos(tag,0);
+
+    fid = swf_GetU16(tag);
+
+    if (fid==id)
+    { 
+        int num = swf_GetU16(tag);
+	int t;
+	f->glyphnames = malloc(sizeof(char*)*num);
+	for(t=0;t<num;t++) {
+	    f->glyphnames[t] = strdup(swf_GetString(tag));
+	}
+    }
+
+    swf_RestoreTagPos(tag);
+    return id;
+}
+
+
 int swf_FontExtract_DefineFont2(int id,SWFFONT * font,TAG * tag)
 {
     int t, glyphcount;
@@ -297,15 +371,18 @@ int swf_FontExtract_DefineFont2(int id,SWFFONT * font,TAG * tag)
 #define FEDTJ_MODIFY 0x02
 #define FEDTJ_CALLBACK 0x04
 
-int swf_FontExtract_DefineTextCallback(int id,SWFFONT * f,TAG * t,int jobs, 
-	void(*callback)(int*chars, int nr, int fontid))
+static int swf_FontExtract_DefineTextCallback(int id,SWFFONT * f,TAG * t,int jobs, 
+	void(*callback)(void*self, int*chars, int*ypos, int nr, int fontid, int fontsize, int xstart, int ystart, RGBA* color), void*self)
 { U16    cid;
   SRECT  r;
   MATRIX m;
-  U8     gbits, abits, flags;
-  int    fid;
+  U8     gbits, abits;
+  int    fid=0;
+  RGBA	 color;
+  int	 x=0,y=0;
+  int	 fontsize=0;
 
-  fid = 0;
+  memset(&color, 0, sizeof(color));
 
   swf_SaveTagPos(t);
   swf_SetTagPos(t,0);
@@ -316,53 +393,77 @@ int swf_FontExtract_DefineTextCallback(int id,SWFFONT * f,TAG * t,int jobs,
   gbits = swf_GetU8(t);
   abits = swf_GetU8(t);
 
-  flags = swf_GetU8(t);
+  while(1)
+  { 
+    int flags,num;
+    flags = swf_GetU8(t);
+    if(!flags)
+	break;
   
-  while(flags)
-  { if (flags&TF_TEXTCONTROL)
+    if (flags&TF_TEXTCONTROL)
     { if (flags&TF_HASFONT) fid = swf_GetU16(t);
       if (flags&TF_HASCOLOR)
-      { swf_GetU8(t); // rgb
-        swf_GetU8(t);
-        swf_GetU8(t);
-        if (swf_GetTagID(t)==ST_DEFINETEXT2) swf_GetU8(t);
+      { color.r = swf_GetU8(t); // rgb
+        color.g = swf_GetU8(t);
+        color.b = swf_GetU8(t);
+        if (swf_GetTagID(t)==ST_DEFINETEXT2) color.a = swf_GetU8(t);
       }
-      if (flags&TF_HASXOFFSET) swf_GetS16(t);
-      if (flags&TF_HASYOFFSET) swf_GetS16(t);
-      if (flags&TF_HASFONT) swf_GetU16(t);
+      if (flags&TF_HASXOFFSET) x = swf_GetS16(t);
+      if (flags&TF_HASYOFFSET) y = swf_GetS16(t);
+      if (flags&TF_HASFONT) fontsize = swf_GetU16(t);
     }
-    else
+
+    num = swf_GetU8(t);
+    if(!num)
+	break;
+
     { int i;
       int buf[256];
-      for (i=0;i<flags;i++)
+      int advance[256];
+      int xpos = 0;
+      for (i=0;i<num;i++)
       { int glyph;
-        int adv;
+        int adv = 0;
+	advance[i] = xpos;
         glyph = swf_GetBits(t,gbits);
         adv = swf_GetBits(t,abits);
-        if (id==fid)                    // mitlesen ?
+	xpos+=adv;
+       
+	// <deprectated>
+	if (id==fid) {
           if (jobs&FEDTJ_PRINT) {
-	    { int code = f->glyph2ascii[glyph];
+	      int code = f->glyph2ascii[glyph];
 	      printf("%c",code);
 	  }
           if (jobs&FEDTJ_MODIFY)
-            /*if (!f->glyph[code].advance)*/ f->glyph[glyph].advance = adv;
-        }
+	    f->glyph[glyph].advance = adv*20; //?
+        } else {
+            if (jobs&FEDTJ_PRINT) {
+		printf("?");
+	    }
+	}
+	// </deprectated>
+
 	buf[i] = glyph;
       }
       if ((id==fid)&&(jobs&FEDTJ_PRINT)) printf("\n");
       if (jobs&FEDTJ_CALLBACK)
-	  callback(buf, flags, fid);
+	  callback(self, buf, advance, num, fid, fontsize, x, y, &color);
+      x += xpos;
     }
-    flags = swf_GetU8(t);
   }
   
   swf_RestoreTagPos(t);
   return id;
 }  
+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)
+{
+    return swf_FontExtract_DefineTextCallback(-1, 0, tag, FEDTJ_CALLBACK, callback, self);
+}
 
 int swf_FontExtract_DefineText(int id,SWFFONT * f,TAG * t,int jobs)
 {
-    return swf_FontExtract_DefineTextCallback(id,f,t,jobs,0);
+    return swf_FontExtract_DefineTextCallback(id,f,t,jobs,0,0);
 }
 
 int swf_FontExtract(SWF * swf,int id,SWFFONT * * font)
@@ -396,6 +497,10 @@ int swf_FontExtract(SWF * swf,int id,SWFFONT * * font)
       case ST_DEFINETEXT2:
         nid = swf_FontExtract_DefineText(id,f,t,f->layout?0:FEDTJ_MODIFY);
         break;
+      
+      case ST_GLYPHNAMES:
+        nid = swf_FontExtract_GlyphNames(id,f,t);
+        break;
     }
     if (nid>0) id = nid;
     t = swf_NextTag(t);
@@ -414,10 +519,11 @@ int swf_FontReduce(SWFFONT * f,FONTUSAGE * use)
 { int i,j;
   if ((!f)||(!use)) return -1;
 
+  /* TODO: layout, glyphnames */
   j = 0;
   for (i=0;i<f->numchars;i++)
     if (f->glyph[i].shape)
-    { if (f->glyph2ascii[i]<MAX_CHAR_PER_FONT && 
+    { if (f->glyph2ascii[i]<f->maxascii&& 
 	    use->code[f->glyph2ascii[i]])
       { f->ascii2glyph[f->glyph2ascii[i]] = j;
         f->glyph2ascii[j] = f->glyph2ascii[i];
@@ -437,14 +543,82 @@ int swf_FontReduce(SWFFONT * f,FONTUSAGE * use)
     
   return j;
 }
+void swf_FontSort(SWFFONT * font)
+{
+    if(!font) return;
+    int i,j,k;
+    int* newplace = malloc(sizeof(int)*font->numchars);
+    int* newpos;
+    
+    for(i=0;i<font->numchars;i++) {
+	newplace[i] = i;
+    }
+    for(i=0;i<font->numchars;i++)
+    for(j=0;j<i;j++) {
+	if(font->glyph2ascii[i] < font->glyph2ascii[j]) {
+	    int n1,n2;
+	    char* c1,*c2;
+	    SWFGLYPH g1,g2;
+	    SRECT r1,r2;
+	    n1=newplace[i];
+	    n2=newplace[j];
+	    newplace[j] = n1;
+	    newplace[i] = n2;
+	    n1=font->glyph2ascii[i];
+	    n2=font->glyph2ascii[j];
+	    font->glyph2ascii[j] = n1;
+	    font->glyph2ascii[i] = n2;
+	    g1=font->glyph[i];
+	    g2=font->glyph[j];
+	    font->glyph[j] = g1;
+	    font->glyph[i] = g2;
+	    if(font->glyphnames) {
+		c1 = font->glyphnames[i];
+		c2 = font->glyphnames[j];
+		font->glyphnames[j] = c1;
+		font->glyphnames[i] = c2;
+	    }
+	    if(font->layout) {
+		r1 = font->layout->bounds[i];
+		r2 = font->layout->bounds[j];
+		font->layout->bounds[j] = r1;
+		font->layout->bounds[i] = r2;
+	    }
+	}
+    }
+    newpos = malloc(sizeof(int)*font->numchars);
+    for(i=0;i<font->numchars;i++) {
+	newpos[newplace[i]] = i;
+    }
+    for(i=0;i<font->maxascii;i++) {
+	if(font->ascii2glyph[i]>=0)
+	    font->ascii2glyph[i] = newpos[font->ascii2glyph[i]];
+    }
 
-int swf_FontInitUsage(FONTUSAGE * use)
+    free(newpos);
+    free(newplace);
+}
+
+void swf_FontPrepareForEditText(SWFFONT * font)
+{
+    if(!font->layout)
+	swf_FontCreateLayout(font);
+    swf_FontSort(font);
+}
+
+int swf_FontInitUsage(SWFFONT* f, FONTUSAGE * use)
 { if (!use) return -1;
-  memset(use->code,0,sizeof(use->code[0])*MAX_CHAR_PER_FONT);
+  use->code = malloc(sizeof(use->code[0])*f->maxascii);
+  memset(use->code,0,sizeof(use->code[0])*f->maxascii);
   return 0;
 }
 
-int swf_FontUse(FONTUSAGE * use,U8 * s)
+void swf_FontClearUsage(SWFFONT* f, FONTUSAGE * use)
+{ if (!use) return;
+  free(use->code);
+}
+
+int swf_FontUse(SWFFONT*f, FONTUSAGE * use,U8 * s)
 { if ((!use)||(!s)) return -1;
   while (s[0])
   { use->code[s[0]] = 1;
@@ -483,6 +657,17 @@ int swf_FontSetDefine(TAG * t,SWFFONT * f)
   return 0;
 }
 
+static inline int fontSize(SWFFONT*font)
+{
+    int t;
+    int size = 0;
+    for(t=0;t<font->numchars;t++) {
+	int l = (font->glyph[t].shape->bitlen+7)/8;
+	size += l+1;
+    }
+    return size + (font->numchars+1)*2;
+}
+
 int swf_FontSetDefine2(TAG *tag, SWFFONT * f)
 {
     U8 flags = 0;
@@ -490,6 +675,7 @@ int swf_FontSetDefine2(TAG *tag, SWFFONT * f)
     int pos;
     int pos2;
     swf_SetU16(tag, f->id);
+
     if(f->layout) 
 	flags |= 128; // haslayout
     if(f->numchars>256)
@@ -498,7 +684,12 @@ int swf_FontSetDefine2(TAG *tag, SWFFONT * f)
 	flags |= 1; // bold
     if(f->style & FONT_STYLE_ITALIC)
 	flags |= 2; // italic
-    /* wideoffs 8 */
+    if(f->maxascii>=256)
+	flags |= 4; //wide codecs
+    if(fontSize(f)>65535)
+	flags |= 8; //wide offsets
+    flags |= 8|4; //FIXME: the above check doesn't work
+
     if(f->encoding & FONT_ENCODING_ANSI)
 	flags |= 16; // ansi
     if(f->encoding & FONT_ENCODING_UNICODE)
@@ -520,25 +711,38 @@ int swf_FontSetDefine2(TAG *tag, SWFFONT * f)
     swf_SetU16(tag, f->numchars);
     /* font offset table */
     pos = tag->len;
-    for(t=0;t<f->numchars;t++)
+    for(t=0;t<=f->numchars;t++)
     {
-	swf_SetU16(tag, /* fontoffset */ 0); /*placeholder*/
+	if(flags&8)
+	    swf_SetU32(tag, /* fontoffset */ 0); /*placeholder*/
+	else
+	    swf_SetU16(tag, /* fontoffset */ 0); /*placeholder*/
     }
-    pos2 = tag->len;
-    swf_SetU16(tag, 0); //fontcode-fontoffset
-    for(t=0;t<f->numchars;t++) {
-	tag->data[pos + t*2] = (tag->len-pos);
-	tag->data[pos + t*2 + 1] = (tag->len-pos) >> 8;
-	swf_SetSimpleShape(tag, f->glyph[t].shape);
+
+    for(t=0;t<=f->numchars;t++) {
+	if(flags&8) {
+	    tag->data[pos + t*4    ] = (tag->len-pos);
+	    tag->data[pos + t*4 + 1] = (tag->len-pos) >> 8;
+	    tag->data[pos + t*4 + 2] = (tag->len-pos) >> 16;
+	    tag->data[pos + t*4 + 3] = (tag->len-pos) >> 24;
+	} else {
+	    if(tag->len - pos > 65535) {
+		fprintf(stderr, "Internal error: Font too big and WideOffsets flag not set\n");
+		exit(1);
+	    }
+	    tag->data[pos + t*2    ] = (tag->len-pos);
+	    tag->data[pos + t*2 + 1] = (tag->len-pos) >> 8;
+	}
+	if(t<f->numchars)
+	    swf_SetSimpleShape(tag, f->glyph[t].shape);
     }
 
-    tag->data[pos2] = tag->len - pos;
-    tag->data[pos2 + 1] = (tag->len - pos) >> 8;
     
     /* font code table */
     if(flags & 4) /* wide codes */ {
-	for(t=0;t<f->numchars;t++)
+	for(t=0;t<f->numchars;t++) { 
 	    swf_SetU16(tag,f->glyph2ascii[t]);
+	}
     } else {
 	for(t=0;t<f->numchars;t++)
 	    swf_SetU8(tag,f->glyph2ascii[t]);
@@ -557,11 +761,11 @@ int swf_FontSetDefine2(TAG *tag, SWFFONT * f)
 	swf_SetU16(tag, f->layout->kerningcount);
 	for(t=0;t<f->layout->kerningcount;t++) {
 	    if(flags & 4) /* wide codes */ {
-		swf_SetU8(tag,f->layout->kerning[t].char1);
-		swf_SetU8(tag,f->layout->kerning[t].char2);
-	    } else {
 		swf_SetU16(tag,f->layout->kerning[t].char1);
 		swf_SetU16(tag,f->layout->kerning[t].char2);
+	    } else {
+		swf_SetU8(tag,f->layout->kerning[t].char1);
+		swf_SetU8(tag,f->layout->kerning[t].char2);
 	    }
 	    swf_SetU16(tag,f->layout->kerning[t].adjustment);
 	}
@@ -609,9 +813,10 @@ int swf_FontSetInfo(TAG * t,SWFFONT * f)
   swf_SetU8(t,(flags&0xfe)|wide);
 
   for (i=0;i<f->numchars;i++) {
-    if (f->glyph[i].shape)
-      wide?swf_SetU16(t,f->glyph2ascii[i]):
-	   swf_SetU8(t,f->glyph2ascii[i]);
+    if (f->glyph[i].shape) {
+      int g2a = f->glyph2ascii[i];
+      wide?swf_SetU16(t,g2a):swf_SetU8(t,g2a);
+    }
   }
   
   return 0;
@@ -661,6 +866,14 @@ void swf_FontFree(SWFFONT * f)
       free(f->glyph2ascii);
       f->glyph2ascii = NULL;
     }
+    if(f->glyphnames) {
+      int t;
+      for(t=0;t<f->numchars;t++) {
+        if(f->glyphnames[t])
+	    free(f->glyphnames[t]);
+      }
+      free(f->glyphnames);
+    }
   }
   free(f);
 }
@@ -684,45 +897,61 @@ int swf_TextSetInfoRecord(TAG * t,SWFFONT * font,U16 size,RGBA * color,int dx,in
   return 0;
 }
 
-int swf_TextCountBits(SWFFONT * font,U8 * s,int scale,U8 * gbits,U8 * abits)
+static int swf_TextCountBits2(SWFFONT * font,U8 * s,int scale,U8 * gbits,U8 * abits, char*encoding)
 { U16 g,a;
+  char utf8=0;
   if ((!s)||(!font)||((!gbits)&&(!abits))||(!font->ascii2glyph)) return -1;
   g = a = 0;
 
-  while(s[0])
+  if(!strcmp(encoding, "UTF8")) utf8=1;
+  else if(!strcmp(encoding, "iso-8859-1")) utf8=0;
+  else fprintf(stderr, "Unknown encoding: %s", encoding);
+
+  while(*s)
   { 
-    int glyph = -1;
-    if(s[0] < font->maxascii)
-	glyph = font->ascii2glyph[s[0]];
+    int glyph = -1,c;
+    
+    if(!utf8) c = *s++;
+    else c = readUTF8char(&s);
+
+    if(c < font->maxascii)
+	glyph = font->ascii2glyph[c];
     if(glyph>=0) {
        g = swf_CountUBits(glyph,g);
-       a = swf_CountBits((((U32)font->glyph[glyph].advance)*scale)/100,a);
+       a = swf_CountBits(((((U32)font->glyph[glyph].advance)*scale)/20)/100,a);
     }
-    s++;
   }
 
   if (gbits) gbits[0] = (U8)g;
   if (abits) abits[0] = (U8)a;
-
   return 0;
 }
 
-int swf_TextSetCharRecord(TAG * t,SWFFONT * font,U8 * s,int scale,U8 gbits,U8 abits)
-{ int l=0,i,pos;
+static int swf_TextSetCharRecord2(TAG * t,SWFFONT * font,U8 * s,int scale,U8 gbits,U8 abits, char*encoding)
+{ int l=0,pos;
+  char utf8=0;
     
   if ((!t)||(!font)||(!s)||(!font->ascii2glyph)) return -1;
+  
+  if(!strcmp(encoding, "UTF8")) utf8=1;
+  else if(!strcmp(encoding, "iso-8859-1")) utf8=0;
+  else fprintf(stderr, "Unknown encoding: %s", encoding);
 
   pos = t->len;
   swf_SetU8(t, l); //placeholder
 
-  for (i=0;s[i];i++)
+  while(*s)
   { 
-    int g = -1;
-    if(s[i] < font->maxascii) 
-	g = font->ascii2glyph[s[i]];
+    int g = -1,c;
+    
+    if(!utf8) c = *s++;
+    else c = readUTF8char(&s);
+
+    if(c < font->maxascii) 
+	g = font->ascii2glyph[c];
     if(g>=0) {
       swf_SetBits(t,g,gbits);
-      swf_SetBits(t,(((U32)font->glyph[g].advance)*scale)/100,abits);
+      swf_SetBits(t,((((U32)font->glyph[g].advance)*scale)/20)/100,abits);
       l++;
       if(l==0x7f)
 	  break;
@@ -735,6 +964,19 @@ int swf_TextSetCharRecord(TAG * t,SWFFONT * font,U8 * s,int scale,U8 gbits,U8 ab
   return 0;
 }
 
+int swf_TextCountBits(SWFFONT * font,U8 * s,int scale,U8 * gbits,U8 * abits) {
+    return swf_TextCountBits2(font,s,scale,gbits,abits,"iso-8859-1");
+}
+int swf_TextSetCharRecord(TAG * t,SWFFONT * font,U8 * s,int scale,U8 gbits,U8 abits) {
+    return swf_TextSetCharRecord2(t,font,s,scale,gbits,abits,"iso-8859-1");
+}
+int swf_TextCountBitsUTF8(SWFFONT * font,U8 * s,int scale,U8 * gbits,U8 * abits) {
+    return swf_TextCountBits2(font,s,scale,gbits,abits,"UTF8");
+}
+int swf_TextSetCharRecordUTF8(TAG * t,SWFFONT * font,U8 * s,int scale,U8 gbits,U8 abits) {
+    return swf_TextSetCharRecord2(t,font,s,scale,gbits,abits,"UTF8");
+}
+
 U32 swf_TextGetWidth(SWFFONT * font,U8 * s,int scale)
 { U32 res = 0;
 
@@ -745,7 +987,7 @@ U32 swf_TextGetWidth(SWFFONT * font,U8 * s,int scale)
       if(*s < font->maxascii) 
 	  g = font->ascii2glyph[*s];
       if(g>=0)
-        res += font->glyph[g].advance;
+        res += font->glyph[g].advance/20;
       s++;
     }
     if (scale) res = (res*scale)/100;
@@ -753,6 +995,31 @@ U32 swf_TextGetWidth(SWFFONT * font,U8 * s,int scale)
   return res;
 }
 
+SRECT swf_TextCalculateBBoxUTF8(SWFFONT * font,U8 * s,int scale)
+{
+    int pos=0;
+    SRECT r;
+    swf_GetRect(0, &r);
+    while(*s) {
+	int c = readUTF8char(&s);
+	if(c < font->maxascii) {
+	    int g = font->ascii2glyph[c];
+	    if(g>=0) {
+		SRECT rn = font->layout->bounds[g];
+		rn.xmin = (rn.xmin * scale)/20/100 + pos;
+		rn.xmax = (rn.xmax * scale)/20/100 + pos;
+		rn.ymin = (rn.ymin * scale)/20/100;
+		rn.ymax = (rn.ymax * scale)/20/100;
+		swf_ExpandRect2(&r, &rn);
+		pos += (font->glyph[g].advance*scale)/20/100;
+	    }
+	}
+	c++;
+    }
+    return r;
+}
+
+
 SWFFONT* swf_ReadFont(char* filename)
 {
   int f;
@@ -783,6 +1050,7 @@ void swf_WriteFont(SWFFONT*font, char* filename)
   RGBA rgb;
   int f;
   int useDefineFont2 = 0;
+  int storeGlyphNames = 1;
 
   if(font->layout)
       useDefineFont2 = 1; /* the only thing new in definefont2 
@@ -804,8 +1072,8 @@ void swf_WriteFont(SWFFONT*font, char* filename)
      did use definefont2 -mk*/
   t = swf_InsertTag(NULL,ST_SETBACKGROUNDCOLOR);
   swf.firstTag = t;
-	rgb.r = 0xff;
-	rgb.g = 0xff;
+	rgb.r = 0xef;
+	rgb.g = 0xef;
 	rgb.b = 0xff;
 	swf_SetRGB(t,&rgb);
   if(!useDefineFont2) {
@@ -818,24 +1086,54 @@ void swf_WriteFont(SWFFONT*font, char* filename)
     swf_FontSetDefine2(t,font);
   }
 
-  if(1) //useDefineFont2
-  {     int textscale = 400;
+  if(storeGlyphNames && font->glyphnames)
+  {
+    int c;
+    t = swf_InsertTag(t,ST_GLYPHNAMES);
+    swf_SetU16(t, WRITEFONTID);
+    swf_SetU16(t, font->numchars);
+    for(c=0;c<font->numchars;c++) {
+	if(font->glyphnames[c])
+	    swf_SetString(t, font->glyphnames[c]);
+	else
+	    swf_SetString(t, "");
+    }
+  }
+
+  if(1) //neccessary only for df1, but pretty to look at anyhow, so do it always
+  {
+        int textscale = 400;
 	int s;
 	int xmax = 0;
-	int ymax = textscale * 2 * (font->maxascii/16+1);
+	int ymax = 0;
+	int ypos = 1;
 	U8 gbits,abits;
-	U8 text[MAX_CHAR_PER_FONT+1];
-	int x,y;
-	text[MAX_CHAR_PER_FONT]=0;
-	for(s=0;s<font->maxascii;s++)
+	int x,y,c;
+	int range = font->maxascii;
+	
+	c=0;
+	if(useDefineFont2 && range > 256) {
+	    range = 256;
+	}
+
+	for(s=0;s<range;s++)
 	{
 	    int g = font->ascii2glyph[s];
-	    text[s] = s;
 	    if(g>=0) {
-	       if(font->glyph[g].advance*textscale/64 > xmax)
-		   xmax = font->glyph[g].advance*textscale/64;
+	       if((font->glyph[g].advance*textscale/20)/64 > xmax) {
+		   xmax = (font->glyph[g].advance*textscale/20)/64;
+	       }
+	       c++;
+	    }
+	    if((s&15)==0) {
+		if(c) {
+		    ypos++;
+		}
+		c=0;
 	    }
 	}
+	ymax = ypos*textscale*2;
+
 	swf.movieSize.xmax = xmax*20;
 	swf.movieSize.ymax = ymax;
 
@@ -845,7 +1143,7 @@ void swf_WriteFont(SWFFONT*font, char* filename)
 
 	    r.xmin = 0;
 	    r.ymin = 0;
-	    r.xmax = swf.movieSize.xmax*20;
+	    r.xmax = swf.movieSize.xmax;
 	    r.ymax = swf.movieSize.ymax;
 	    
 	    swf_SetRect(t,&r);
@@ -861,12 +1159,12 @@ void swf_WriteFont(SWFFONT*font, char* filename)
 	    rgb.r = 0x00;
 	    rgb.g = 0x00;
 	    rgb.b = 0x00;
-	    for(y=0;y<=((font->maxascii-1)/16);y++)
+	    ypos = 1;
+	    for(y=0;y<((range+15)/16);y++)
 	    {
 		int c=0,lastx=-1;
-		/* TODO: firstx?? */
 		for(x=0;x<16;x++) {
-		    int g = (y*16+x<font->maxascii)?font->ascii2glyph[y*16+x]:-1;
+		    int g = (y*16+x<range)?font->ascii2glyph[y*16+x]:-1;
 		    if(g>=0 && font->glyph[g].shape) {
 			c++;
 			if(lastx<0) 
@@ -874,21 +1172,22 @@ void swf_WriteFont(SWFFONT*font, char* filename)
 		    }
 		}
 		if(c) {
-		  swf_TextSetInfoRecord(t,font,textscale,&rgb,lastx+1,textscale*y*2);
+		  swf_TextSetInfoRecord(t,font,textscale,&rgb,lastx+1,textscale*ypos*2);
 		  for(x=0;x<16;x++)
 		  {
-		      int g = (y*16+x<font->maxascii)?font->ascii2glyph[y*16+x]:-1;
+		      int g = (y*16+x<range)?font->ascii2glyph[y*16+x]:-1;
 		      if(g>=0 && font->glyph[g].shape) {
 			if(lastx != x*xmax) {
 			    swf_TextSetInfoRecord(t,0,0,0,x*xmax+1,0);
 			}
 			swf_SetU8(t,1);
 			swf_SetBits(t, g, gbits);
-		        swf_SetBits(t, font->glyph[g].advance, abits);
-			lastx = x*xmax+font->glyph[g].advance;
+		        swf_SetBits(t, font->glyph[g].advance/20, abits);
+			lastx = x*xmax+(font->glyph[g].advance/20);
 			swf_ResetWriteBits(t);
 		      }
 		  }
+		  ypos++;
 		} 
 	    }
 	    swf_SetU8(t,0);
@@ -899,6 +1198,7 @@ void swf_WriteFont(SWFFONT*font, char* filename)
             swf_ObjectPlace(t,font->id+1,1,NULL,NULL,NULL);
      
         t = swf_InsertTag(t,ST_SHOWFRAME);
+
   }
   
   t = swf_InsertTag(t,ST_END);
@@ -954,24 +1254,10 @@ SRECT swf_SetDefineText(TAG*tag, SWFFONT*font, RGBA*rgb, char*text, int scale)
     U8 gbits, abits;
     U8*c = (U8*)text;
     int pos = 0;
-    swf_GetRect(0, &r);
     if(font->layout) {
-	while(*c) {
-	    if(*c < font->maxascii) {
-		int g = font->ascii2glyph[*c];
-		if(g>=0) {
-		    SRECT rn = font->layout->bounds[g];
-		    rn.xmin = (rn.xmin * scale)/100 + pos;
-		    rn.xmax = (rn.xmax * scale)/100 + pos;
-		    rn.ymin = (rn.ymin * scale)/100;
-		    rn.ymax = (rn.ymax * scale)/100;
-		    swf_ExpandRect2(&r, &rn);
-		    pos += (font->glyph[g].advance*scale*20)/100;
-		}
-	    }
-	    c++;
-	}
+	r = swf_TextCalculateBBoxUTF8(font,text,scale*20);
     } else {
+	fprintf(stderr, "No layout information- can't compute text bbox accurately");
 	/* Hm, without layout information, we can't compute a bounding
 	   box. We could call swf_FontCreateLayout to create a layout,
 	   but the caller probably doesn't want us to mess up his font
@@ -982,8 +1268,16 @@ SRECT swf_SetDefineText(TAG*tag, SWFFONT*font, RGBA*rgb, char*text, int scale)
     }
 
     swf_SetRect(tag,&r);
-    swf_SetMatrix(tag,NULL);
-    swf_TextCountBits(font,text,scale*20,&gbits,&abits);
+
+    /* The text matrix is pretty boring, as it doesn't apply to
+       individual characters, but rather whole text objects (or
+       at least whole char records- haven't tested).
+       So it can't do anything which we can't already do with
+       the placeobject tag we use for placing the text on the scene.
+    */
+    swf_SetMatrix(tag,0);
+
+    swf_TextCountBitsUTF8(font,text,scale*20,&gbits,&abits);
     swf_SetU8(tag,gbits);
     swf_SetU8(tag,abits);
 
@@ -997,7 +1291,7 @@ SRECT swf_SetDefineText(TAG*tag, SWFFONT*font, RGBA*rgb, char*text, int scale)
     /* set the actual text- notice that we just pass our scale
        parameter over, as TextSetCharRecord calculates with 
        percent, too */
-    swf_TextSetCharRecord(tag,font,text,scale*20,gbits,abits);
+    swf_TextSetCharRecordUTF8(tag,font,text,scale*20,gbits,abits);
 
     swf_SetU8(tag,0);
     return r;
@@ -1029,16 +1323,15 @@ void swf_FontCreateLayout(SWFFONT*f)
 	bbox = swf_GetShapeBoundingBox(shape2);
 	swf_Shape2Free(shape2);
 	f->layout->bounds[t] = bbox;
-	/* FIXME */
-	//width = (bbox.xmax - bbox.xmin)/20;
-	width = (bbox.xmax)/20;
+	
+	width = (bbox.xmax);
 
 	/* The following is a heuristic- it may be that extractfont_DefineText
 	   has already found out some widths for individual characters (from the way
 	   they are used)- we now have to guess whether that width might be possible,
 	   which is the case if it isn't either much too big or much too small */
 	if(width > f->glyph[t].advance*3/2 ||
-	   width*2 < f->glyph[t].advance)
+	   width < f->glyph[t].advance/2)
 	    f->glyph[t].advance = width;
 
 	if(-bbox.ymin > f->layout->ascent)
@@ -1048,4 +1341,47 @@ void swf_FontCreateLayout(SWFFONT*f)
     }
 }
 	
+void swf_DrawText(drawer_t*draw, SWFFONT*font, int size, char*text)
+{
+    U8*s = (U8*)text;
+    int advance = 0;
+    while(*s) {
+	SHAPE*shape;
+	SHAPE2*shape2;
+	SHAPELINE*l;
+	U32 c = readUTF8char(&s);
+	int g = font->ascii2glyph[c];
+	shape = font->glyph[g].shape;
+	if(((int)g)<0) {
+	    fprintf(stderr, "No char %d in font %s\n", c, font->name?(char*)font->name:"?");
+	    continue;
+	}
+	shape2 = swf_ShapeToShape2(shape);
+	l = shape2->lines;
+	while(l) {
+	    if(l->type == moveTo) {
+		FPOINT to;
+		to.x = l->x*size/100.0/20.0+advance;
+		to.y = l->y*size/100.0/20.0;
+		draw->moveTo(draw, &to);
+	    } else if(l->type == lineTo) {
+		FPOINT to;
+		to.x = l->x*size/100.0/20.0+advance;
+		to.y = l->y*size/100.0/20.0;
+		draw->lineTo(draw, &to);
+	    } else if(l->type == splineTo) {
+		FPOINT mid,to;
+		mid.x = l->sx*size/100.0/20.0+advance;
+		mid.y = l->sy*size/100.0/20.0;
+		to.x = l->x*size/100.0/20.0+advance;
+		to.y = l->y*size/100.0/20.0;
+		draw->splineTo(draw, &mid, &to);
+	    }
+	    l = l->next;
+	}
+	swf_Shape2Free(shape2);
+	advance += font->glyph[g].advance*size/100.0/20.0;
+    }
+}
+