fixed bugs in ttf generator

[swftools.git] / lib / gfxfont.c

diff --git a/lib/gfxfont.c b/lib/gfxfont.c
index 85af571..8e39272 100644 (file)
--- a/lib/gfxfont.c
+++ b/lib/gfxfont.c
@@ -25,6 +25,7 @@
 #include "gfxdevice.h"
 #include "gfxtools.h"
 #include "gfxfont.h"
+#include "ttf.h"
 
 static int loadfont_scale = 64;
 static int full_unicode = 1;
@@ -173,7 +174,7 @@ gfxfont_t* gfxfont_load(char*id, char*filename, unsigned int flags, double quali
        return 0;
     }
     if(face->num_glyphs <= 0) {
-       fprintf(stderr, "File %s contains %d glyphs\n", face->num_glyphs);
+       fprintf(stderr, "File %s contains %d glyphs\n", filename, (int)face->num_glyphs);
        return 0;
     }
 
@@ -333,9 +334,9 @@ gfxfont_t* gfxfont_load(char*id, char*filename, unsigned int flags, double quali
            error = FT_Load_Glyph(face, t, FT_LOAD_NO_BITMAP);
            if(error) {
                if(hasname)
-                   fprintf(stderr, "Warning: glyph %d/%d (unicode %d, name %s) has return code %d\n", t, face->num_glyphs, glyph2unicode[t], name, error);
+                   fprintf(stderr, "Warning: glyph %d/%d (unicode %d, name %s) has return code %d\n", t, (int)face->num_glyphs, glyph2unicode[t], name, error);
                else
-                   fprintf(stderr, "Warning: glyph %d/%d (unicode %d) has return code %d\n", t, face->num_glyphs, glyph2unicode[t], error);
+                   fprintf(stderr, "Warning: glyph %d/%d (unicode %d) has return code %d\n", t, (int)face->num_glyphs, glyph2unicode[t], error);
                omit = 2;
 
 #if 0
@@ -358,7 +359,7 @@ gfxfont_t* gfxfont_load(char*id, char*filename, unsigned int flags, double quali
        if(!omit) {
            error = FT_Get_Glyph(face->glyph, &glyph);
            if(error) {
-               fprintf(stderr, "Couldn't get glyph %d/%d, error:%d\n", t, face->num_glyphs, error);
+               fprintf(stderr, "Couldn't get glyph %d/%d, error:%d\n", t, (int)face->num_glyphs, error);
                omit = 3;
            }
        }
@@ -488,9 +489,10 @@ gfxfont_t* gfxfont_load(char*id, char*filename, unsigned int flags, double quali
 }
 #else
 
-gfxfont_t* gfxfont_load(char*filename)
+gfxfont_t* gfxfont_load(char*id, char*filename, unsigned int flags, double quality)
 {
     fprintf(stderr, "No freetype support compiled in! Not able to load %s\n", filename);
+    return 0;
 }
 
 #endif
@@ -508,6 +510,117 @@ void gfxfont_free(gfxfont_t*font)
     if(font->unicode2glyph) {
        free(font->unicode2glyph);font->unicode2glyph = 0;
     }
+    if(font->id) {
+       free((void*)font->id);font->id=0;
+    }
+    if(font->kerning) {
+       free(font->kerning);font->kerning=0;
+    }
+
     free(font);
 }
 
+ttf_t* gfxfont_to_ttf(gfxfont_t*font)
+{
+    ttf_t*ttf = ttf_new();
+    int num_glyphs = font->num_glyphs;
+    int offset = 0;
+    int t;
+    char has_nondef_glyph = 
+       font->num_glyphs && font->glyphs[0].unicode==-1 && 
+       (!font->glyphs[0].line || !font->glyphs[0].line->next);
+
+    if(!has_nondef_glyph) {
+       /* insert a new .nondef glyph at the start of the font */
+       offset++;
+       num_glyphs++;
+    }
+    ttf->num_glyphs = num_glyphs;
+    ttf->glyphs = rfx_calloc(num_glyphs*sizeof(ttfglyph_t));
+    double scale = 1.0;
+    int max_unicode = font->max_unicode;
+    for(t=0;t<font->num_glyphs;t++) {
+       gfxglyph_t*src = &font->glyphs[t];
+       ttfglyph_t*dest = &ttf->glyphs[t+offset];
+       gfxline_t*line = src->line;
+       int count = 0;
+       while(line) {
+           count++;
+           if(line->type == gfx_splineTo) 
+               count++;
+           line=line->next;
+       }
+       dest->num_points = count;
+       dest->points = rfx_calloc(count*sizeof(ttfpoint_t));
+       count = 0;
+       line = src->line;
+       while(line) {
+           if(line->type == gfx_splineTo) {
+               dest->points[count].x = line->sx*scale;
+               dest->points[count].y = line->sy*scale;
+               count++;
+           }
+           dest->points[count].x = line->x*scale;
+           dest->points[count].y = line->y*scale;
+           dest->points[count].flags |= GLYPH_ON_CURVE;
+           if(line->type == gfx_moveTo) {
+               dest->points[count].flags |= GLYPH_CONTOUR_START;
+               if(count)
+                   dest->points[count-1].flags |= GLYPH_CONTOUR_END;
+           }
+           count++;
+           line=line->next;
+       }
+       if(count)
+           dest->points[count-1].flags |= GLYPH_CONTOUR_END;
+
+       /* compute bounding box */
+       int s;
+       if(count) {
+           dest->xmin = dest->xmax = dest->points[0].x;
+           dest->ymin = dest->ymax = dest->points[0].y;
+           for(s=1;s<count;s++) {
+               if(dest->points[s].x < dest->xmin) 
+                   dest->xmin = dest->points[s].x;
+               if(dest->points[s].y < dest->ymin) 
+                   dest->ymin = dest->points[s].y;
+               if(dest->points[s].x > dest->xmax) 
+                   dest->xmax = dest->points[s].x;
+               if(dest->points[s].y > dest->ymax) 
+                   dest->ymax = dest->points[s].y;
+           }
+       }
+
+       dest->advance = src->advance*scale;
+       if(src->unicode > max_unicode)
+           max_unicode = src->unicode;
+    }
+    ttf->unicode_size = max_unicode+1;
+    ttf->unicode = rfx_calloc(sizeof(unicode_t)*ttf->unicode_size);
+    for(t=0;t<font->num_glyphs;t++) {
+       gfxglyph_t*src = &font->glyphs[t];
+       int u = font->glyphs[t].unicode;
+       if(u>=0)
+           ttf->unicode[u] = t+offset;
+    }
+    int u;
+    for(u=0;u<font->max_unicode;u++) {
+       int g = font->unicode2glyph[u];
+       if(g>=0) {
+           ttf->unicode[u] = g+offset;
+       }
+    }
+    ttf->ascent = font->ascent;
+    ttf->descent = font->descent;
+    ttf->lineGap = font->ascent + font->descent;
+
+    ttf_create_truetype_tables(ttf);
+    return ttf;
+}
+
+void gfxfont_save(gfxfont_t*font, const char*filename)
+{
+    ttf_t*ttf = gfxfont_to_ttf(font);
+    ttf_save(ttf, filename);
+}
+