static const int WRITEFONTID = 0x4e46; // font id for WriteFont and ReadFont
-int swf_FontEnumerate(SWF * swf, void (*FontCallback) (U16, U8 *))
+int swf_FontEnumerate(SWF * swf, void (*FontCallback) (void*, U16, U8 *), void*self)
{
int n;
TAG *t;
s[l] = 0;
}
- (FontCallback) (id, s);
+ (FontCallback) (self, id, s);
swf_RestoreTagPos(t);
}
of = swf_GetU16(t);
n = of / 2;
f->numchars = n;
- f->glyph = malloc(sizeof(SWFGLYPH) * n);
- memset(f->glyph, 0, sizeof(SWFGLYPH) * n);
+ f->glyph = rfx_calloc(sizeof(SWFGLYPH) * n);
for (i = 1; i < n; i++)
swf_GetU16(t);
}
if (f->name)
- free(f->name);
+ rfx_free(f->name);
- f->name = (U8 *) malloc(l + 1);
+ f->name = (U8 *) rfx_alloc(l + 1);
swf_GetBlock(t, f->name, l);
f->name[l] = 0;
f->language = swf_GetU8(t);
}
- f->glyph2ascii = (U16 *) malloc(sizeof(U16) * f->numchars);
+ f->glyph2ascii = (U16 *) rfx_alloc(sizeof(U16) * f->numchars);
maxcode = 0;
for (i = 0; i < f->numchars; i++) {
f->glyph2ascii[i] = ((flags & FF_WIDECODES) ? swf_GetU16(t) : swf_GetU8(t));
if (maxcode < 256)
maxcode = 256;
f->maxascii = maxcode;
- f->ascii2glyph = (int *) malloc(sizeof(int) * maxcode);
+ f->ascii2glyph = (int *) rfx_alloc(sizeof(int) * maxcode);
memset(f->ascii2glyph, -1, sizeof(int) * maxcode);
for (i = 0; i < f->numchars; i++)
if (fid == id) {
int num = swf_GetU16(tag);
int t;
- f->glyphnames = malloc(sizeof(char *) * num);
+ f->glyphnames = rfx_alloc(sizeof(char *) * num);
for (t = 0; t < num; t++) {
f->glyphnames[t] = strdup(swf_GetString(tag));
}
int t, glyphcount;
int maxcode;
int fid;
+ U32 offset_start;
+ U32 *offset;
U8 flags1, flags2, namelen;
swf_SaveTagPos(tag);
swf_SetTagPos(tag, 0);
font->encoding |= FONT_ENCODING_SHIFTJIS;
namelen = swf_GetU8(tag);
- font->name = (U8 *) malloc(namelen + 1);
+ font->name = (U8 *) rfx_alloc(namelen + 1);
font->name[namelen] = 0;
swf_GetBlock(tag, font->name, namelen);
font->version = 2;
glyphcount = swf_GetU16(tag);
font->numchars = glyphcount;
- font->glyph = (SWFGLYPH *) malloc(sizeof(SWFGLYPH) * glyphcount);
- memset(font->glyph, 0, sizeof(SWFGLYPH) * glyphcount);
- font->glyph2ascii = (U16 *) malloc(sizeof(U16) * glyphcount);
- memset(font->glyph2ascii, 0, sizeof(U16) * glyphcount);
+ font->glyph = (SWFGLYPH *) rfx_calloc(sizeof(SWFGLYPH) * glyphcount);
+ font->glyph2ascii = (U16 *) rfx_calloc(sizeof(U16) * glyphcount);
+
+ offset = rfx_calloc(sizeof(U32)*(glyphcount+1));
+ offset_start = tag->pos;
if (flags1 & 8) { // wide offsets
for (t = 0; t < glyphcount; t++)
- swf_GetU32(tag); //offset[t]
+ offset[t] = swf_GetU32(tag); //offset[t]
if (glyphcount) /* this _if_ is not in the specs */
- swf_GetU32(tag); // fontcodeoffset
+ offset[glyphcount] = swf_GetU32(tag); // fontcodeoffset
+ else
+ offset[glyphcount] = tag->pos;
} else {
for (t = 0; t < glyphcount; t++)
- swf_GetU16(tag); //offset[t]
+ offset[t] = swf_GetU16(tag); //offset[t]
if (glyphcount) /* this _if_ is not in the specs */
- swf_GetU16(tag); // fontcodeoffset
+ offset[glyphcount] = swf_GetU16(tag); // fontcodeoffset
+ else
+ offset[glyphcount] = tag->pos;
}
- for (t = 0; t < glyphcount; t++)
+ for (t = 0; t < glyphcount; t++) {
+ swf_SetTagPos(tag, offset[t]+offset_start);
swf_GetSimpleShape(tag, &(font->glyph[t].shape));
+ }
+
+ swf_SetTagPos(tag, offset[glyphcount]+offset_start);
+
+ free(offset);
maxcode = 0;
for (t = 0; t < glyphcount; t++) {
if (maxcode < 256)
maxcode = 256;
font->maxascii = maxcode;
- font->ascii2glyph = (int *) malloc(sizeof(int) * maxcode);
+ font->ascii2glyph = (int *) rfx_alloc(sizeof(int) * maxcode);
memset(font->ascii2glyph, -1, sizeof(int) * maxcode);
for (t = 0; t < glyphcount; t++) {
font->ascii2glyph[font->glyph2ascii[t]] = t;
if (flags1 & 128) { // has layout
U16 kerningcount;
- font->layout = (SWFLAYOUT *) malloc(sizeof(SWFLAYOUT));
+ font->layout = (SWFLAYOUT *) rfx_alloc(sizeof(SWFLAYOUT));
font->layout->ascent = swf_GetU16(tag);
font->layout->descent = swf_GetU16(tag);
font->layout->leading = swf_GetU16(tag);
S16 advance = swf_GetS16(tag);
font->glyph[t].advance = advance;
}
- font->layout->bounds = malloc(glyphcount * sizeof(SRECT));
+ font->layout->bounds = rfx_alloc(glyphcount * sizeof(SRECT));
for (t = 0; t < glyphcount; t++) {
swf_ResetReadBits(tag);
swf_GetRect(tag, &font->layout->bounds[t]);
kerningcount = swf_GetU16(tag);
font->layout->kerningcount = kerningcount;
- font->layout->kerning = (SWFKERNING *) malloc(sizeof(SWFKERNING) * kerningcount);
+ font->layout->kerning = (SWFKERNING *) rfx_alloc(sizeof(SWFKERNING) * kerningcount);
if (kerningcount) {
- font->layout->kerning = malloc(sizeof(*font->layout->kerning) * kerningcount);
+ font->layout->kerning = rfx_alloc(sizeof(*font->layout->kerning) * kerningcount);
for (t = 0; t < kerningcount; t++) {
if (flags1 & 4) { // wide codes
font->layout->kerning[t].char1 = swf_GetU16(tag);
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)
+ int *chars, int *xpos, int nr, int fontid, int fontsize, int xstart, int ystart, RGBA * color), void *self)
{
U16 cid;
SRECT r;
color.b = swf_GetU8(t);
if (swf_GetTagID(t) == ST_DEFINETEXT2)
color.a = swf_GetU8(t);
+ else
+ color.a = 255;
}
if (flags & TF_HASXOFFSET)
x = swf_GetS16(t);
if ((!swf) || (!font))
return -1;
- f = (SWFFONT *) malloc(sizeof(SWFFONT));
- memset(f, 0x00, sizeof(SWFFONT));
+ f = (SWFFONT *) rfx_calloc(sizeof(SWFFONT));
t = swf->firstTag;
t = swf_NextTag(t);
}
if (f->id != id) {
- free(f);
+ rfx_free(f);
f = 0;
}
font[0] = f;
return 0;
}
-int swf_FontReduce(SWFFONT * f, FONTUSAGE * use)
+void swf_LayoutFree(SWFLAYOUT * l)
+{
+ if (l) {
+ if (l->kerning)
+ rfx_free(l->kerning);
+ l->kerning = NULL;
+ if (l->bounds)
+ rfx_free(l->bounds);
+ l->bounds = NULL;
+ }
+ rfx_free(l);
+}
+
+
+static void font_freeglyphnames(SWFFONT*f)
+{
+ if (f->glyphnames) {
+ int t;
+ for (t = 0; t < f->numchars; t++) {
+ if (f->glyphnames[t]) {
+ rfx_free(f->glyphnames[t]);
+ f->glyphnames[t] = 0;
+ }
+ }
+ rfx_free(f->glyphnames);
+ f->glyphnames = 0;
+ }
+
+}
+static void font_freeusage(SWFFONT*f)
+{
+ if (f->use) {
+ if(f->use->chars) {
+ rfx_free(f->use->chars);f->use->chars = 0;
+ }
+ rfx_free(f->use); f->use = 0;
+ }
+}
+static void font_freelayout(SWFFONT*f)
+{
+ if (f->layout) {
+ swf_LayoutFree(f->layout);
+ f->layout = 0;
+ }
+}
+static void font_freename(SWFFONT*f)
+{
+ if (f->name) {
+ rfx_free(f->name);
+ f->name = 0;
+ }
+}
+
+int swf_FontReduce_old(SWFFONT * f)
{
int i, j;
- if ((!f) || (!use))
+ int max_unicode = 0;
+ if ((!f) || (!f->use) || f->use->is_reduced)
return -1;
- /* TODO: layout, glyphnames */
j = 0;
- for (i = 0; i < f->numchars; i++)
- if (f->glyph[i].shape) {
- if (f->glyph2ascii[i] < f->maxascii && use->code[f->glyph2ascii[i]]) {
- f->ascii2glyph[f->glyph2ascii[i]] = j;
- f->glyph2ascii[j] = f->glyph2ascii[i];
- f->glyph[j] = f->glyph[i];
- j++;
- } else {
+
+ for (i = 0; i < f->numchars; i++) {
+ if (f->glyph[i].shape && f->use->chars[i]) {
+ f->glyph2ascii[j] = f->glyph2ascii[i];
+ f->glyph[j] = f->glyph[i];
+ f->use->chars[i] = j;
+ j++;
+ } else {
+ f->glyph2ascii[i] = 0;
+ if(f->glyph[i].shape) {
swf_ShapeFree(f->glyph[i].shape);
- f->ascii2glyph[f->glyph2ascii[i]] = -1;
- f->glyph2ascii[i] = 0;
- f->glyph[i].shape = NULL;
+ f->glyph[i].shape = 0;
f->glyph[i].advance = 0;
}
- } else
- f->ascii2glyph[f->glyph2ascii[i]] = -1;
-
+ f->use->chars[i] = -1;
+ j++; //TODO: remove
+ }
+ }
+ for (i = 0; i < f->maxascii; i++) {
+ if(f->use->chars[f->ascii2glyph[i]]<0) {
+ f->ascii2glyph[i] = -1;
+ } else {
+ f->ascii2glyph[i] = f->use->chars[f->ascii2glyph[i]];
+ max_unicode = i;
+ }
+ }
+ f->maxascii = max_unicode;
+ f->use->is_reduced = 1;
f->numchars = j;
-
+ font_freelayout(f);
+ font_freeglyphnames(f);
+ font_freename(f);
return j;
}
+int swf_FontReduce(SWFFONT * f)
+{
+ int i;
+ int max_unicode = 0;
+ int max_glyph = 0;
+ if ((!f) || (!f->use) || f->use->is_reduced)
+ return -1;
+
+ font_freelayout(f);
+ font_freeglyphnames(f);
+
+ for (i = 0; i < f->numchars; i++) {
+ if(!f->use->chars[i]) {
+ f->glyph2ascii[i] = 0;
+ if(f->glyph[i].shape) {
+ swf_ShapeFree(f->glyph[i].shape);
+ f->glyph[i].shape = 0;
+ f->glyph[i].advance = 0;
+ }
+ } else {
+ max_glyph = i+1;
+ }
+ }
+ for (i = 0; i < f->maxascii; i++) {
+ if(!f->use->chars[f->ascii2glyph[i]]) {
+ f->ascii2glyph[i] = -1;
+ } else {
+ max_unicode = i+1;
+ }
+ }
+ f->maxascii = max_unicode;
+ f->numchars = max_glyph;
+ font_freename(f);
+ return 0;
+}
+
void swf_FontSort(SWFFONT * font)
{
int i, j, k;
if (!font)
return;
- newplace = malloc(sizeof(int) * font->numchars);
+ newplace = rfx_alloc(sizeof(int) * font->numchars);
for (i = 0; i < font->numchars; i++) {
newplace[i] = i;
}
}
}
- newpos = malloc(sizeof(int) * font->numchars);
+ newpos = rfx_alloc(sizeof(int) * font->numchars);
for (i = 0; i < font->numchars; i++) {
newpos[newplace[i]] = i;
}
font->ascii2glyph[i] = newpos[font->ascii2glyph[i]];
}
- free(newpos);
- free(newplace);
+ rfx_free(newpos);
+ rfx_free(newplace);
}
void swf_FontPrepareForEditText(SWFFONT * font)
swf_FontSort(font);
}
-int swf_FontInitUsage(SWFFONT * f, FONTUSAGE * use)
+int swf_FontInitUsage(SWFFONT * f)
{
- if (!use)
+ if (!f)
return -1;
- use->code = malloc(sizeof(use->code[0]) * f->maxascii);
- memset(use->code, 0, sizeof(use->code[0]) * f->maxascii);
+ if(f->use) {
+ fprintf(stderr, "Usage initialized twice");
+ return -1;
+ }
+ f->use = rfx_alloc(sizeof(FONTUSAGE));
+ f->use->is_reduced = 0;
+ f->use->chars = rfx_calloc(sizeof(f->use->chars[0]) * f->numchars);
return 0;
}
-void swf_FontClearUsage(SWFFONT * f, FONTUSAGE * use)
+void swf_FontClearUsage(SWFFONT * f)
{
- if (!use)
+ if (!f || !f->use)
return;
- free(use->code);
+ rfx_free(f->use->chars); f->use->chars = 0;
+ rfx_free(f->use); f->use = 0;
}
-int swf_FontUse(SWFFONT * f, FONTUSAGE * use, U8 * s)
+int swf_FontUse(SWFFONT * f, U8 * s)
{
- if ((!use) || (!s))
+ if (!f->use)
+ swf_FontInitUsage(f);
+ if( (!s))
return -1;
- while (s[0]) {
- use->code[s[0]] = 1;
+ while (*s) {
+ if(*s < f->maxascii && f->ascii2glyph[*s]>=0)
+ f->use->chars[f->ascii2glyph[*s]] = 1;
s++;
}
return 0;
}
+int swf_FontUseGlyph(SWFFONT * f, int glyph)
+{
+ if (!f->use)
+ swf_FontInitUsage(f);
+ if(glyph < 0 || glyph >= f->numchars)
+ return -1;
+ f->use->chars[glyph] = 1;
+ return 0;
+}
+
int swf_FontSetDefine(TAG * t, SWFFONT * f)
{
- U16 *ofs = (U16 *) malloc(f->numchars * 2);
+ U16 *ofs = (U16 *) rfx_alloc(f->numchars * 2);
int p, i, j;
if ((!t) || (!f))
swf_SetSimpleShape(t, f->glyph[i].shape);
swf_ResetWriteBits(t);
- free(ofs);
+ rfx_free(ofs);
return 0;
}
int t;
int size = 0;
for (t = 0; t < font->numchars; t++) {
- int l = (font->glyph[t].shape->bitlen + 7) / 8;
+ int l = 0;
+ if(font->glyph[t].shape)
+ l = (font->glyph[t].shape->bitlen + 7) / 8;
+ else
+ l = 8;
size += l + 1;
}
return size + (font->numchars + 1) * 2;
swf_SetBlock(tag, f->name, strlen(f->name));
} else {
/* font name (="") */
- swf_SetU8(tag, 0); /*placeholder */
+ swf_SetU8(tag, 0);
}
/* number of glyphs */
swf_SetU16(tag, f->numchars);
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);
+ if (t < f->numchars) {
+ if(f->glyph[t].shape) {
+ swf_SetSimpleShape(tag, f->glyph[t].shape);
+ } else {
+ swf_SetU8(tag, 0); //non-edge(1) + edge flags(5)
+ }
+ }
}
void swf_FontAddLayout(SWFFONT * f, int ascent, int descent, int leading)
{
- f->layout = (SWFLAYOUT *) malloc(sizeof(SWFLAYOUT));
+ f->layout = (SWFLAYOUT *) rfx_alloc(sizeof(SWFLAYOUT));
f->layout->ascent = ascent;
f->layout->descent = descent;
f->layout->leading = leading;
f->layout->kerningcount = 0;
f->layout->kerning = 0;
- f->layout->bounds = (SRECT *) malloc(sizeof(SRECT) * f->numchars);
- memset(f->layout->bounds, 0, sizeof(SRECT) * f->numchars);
+ f->layout->bounds = (SRECT *) rfx_calloc(sizeof(SRECT) * f->numchars);
}
int swf_FontSetInfo(TAG * t, SWFFONT * f)
return 0;
}
-void swf_LayoutFree(SWFLAYOUT * l)
-{
- if (l) {
- if (l->kerning)
- free(l->kerning);
- l->kerning = NULL;
- if (l->bounds)
- free(l->bounds);
- l->bounds = NULL;
- }
- free(l);
-}
-
void swf_FontFree(SWFFONT * f)
{
- if (f) {
- int i;
+ int i;
+ if (!f)
+ return;
- if (f->name)
- free(f->name);
- if (f->layout)
- swf_LayoutFree(f->layout);
-
- f->name = NULL;
- f->layout = NULL;
-
- if (f->glyph) {
- for (i = 0; i < f->numchars; i++)
- if (f->glyph[i].shape) {
- swf_ShapeFree(f->glyph[i].shape);
- f->glyph[i].shape = NULL;
- }
- free(f->glyph);
- f->glyph = NULL;
- }
- if (f->ascii2glyph) {
- free(f->ascii2glyph);
- f->ascii2glyph = NULL;
- }
- if (f->glyph2ascii) {
- 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]);
+ if (f->glyph) {
+ for (i = 0; i < f->numchars; i++)
+ if (f->glyph[i].shape) {
+ swf_ShapeFree(f->glyph[i].shape);
+ f->glyph[i].shape = NULL;
}
- free(f->glyphnames);
- }
+ rfx_free(f->glyph);
+ f->glyph = NULL;
}
- free(f);
+ if (f->ascii2glyph) {
+ rfx_free(f->ascii2glyph);
+ f->ascii2glyph = NULL;
+ }
+ if (f->glyph2ascii) {
+ rfx_free(f->glyph2ascii);
+ f->glyph2ascii = NULL;
+ }
+ font_freename(f);
+ font_freelayout(f);
+ font_freeglyphnames(f);
+ font_freeusage(f);
+
+ rfx_free(f);
}
int swf_TextSetInfoRecord(TAG * t, SWFFONT * font, U16 size, RGBA * color, int dx, int dy)
else
swf_SetRGB(t, color);
}
- if (dx)
- swf_SetS16(t, dx);
- if (dy)
- swf_SetS16(t, dy);
+ if (dx) {
+ if(dx != SET_TO_ZERO) {
+ if(dx>32767 || dx<-32768)
+ fprintf(stderr, "Warning: Horizontal char position overflow: %d\n", dx);
+ swf_SetS16(t, dx);
+ } else {
+ swf_SetS16(t, 0);
+ }
+ }
+ if (dy) {
+ if(dy != SET_TO_ZERO) {
+ if(dy>32767 || dy<-32768)
+ fprintf(stderr, "Warning: Vertical char position overflow: %d\n", dy);
+ swf_SetS16(t, dy);
+ } else {
+ swf_SetS16(t, 0);
+ }
+ }
if (font)
swf_SetU16(t, size);
swf_SetBits(t, g, gbits);
swf_SetBits(t, ((((U32) font->glyph[g].advance) * scale) / 20) / 100, abits);
l++;
+ /* We split into 127 characters per text field.
+ We could do 255, by the (formerly wrong) flash specification,
+ but some SWF parsing code out there still assumes that char blocks
+ are at max 127 characters, and it would save only a few bits.
+ */
if (l == 0x7f)
break;
}
SRECT swf_TextCalculateBBoxUTF8(SWFFONT * font, U8 * s, int scale)
{
- int pos = 0;
+ int xpos = 0;
+ int ypos = 0;
SRECT r;
swf_GetRect(0, &r);
while (*s) {
int c = readUTF8char(&s);
+ if(c==13 || c==10) {
+ if(s[0] == 10) {
+ s++;
+ }
+ xpos=0;
+ ypos+=font->layout->leading;
+ continue;
+ }
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;
+ rn.xmin = (rn.xmin * scale) / 20 / 100 + xpos;
+ rn.xmax = (rn.xmax * scale) / 20 / 100 + xpos;
+ rn.ymin = (rn.ymin * scale) / 20 / 100 + ypos;
+ rn.ymax = (rn.ymax * scale) / 20 / 100 + ypos;
swf_ExpandRect2(&r, &rn);
- pos += (font->glyph[g].advance * scale) / 20 / 100;
+ xpos += (font->glyph[g].advance * scale) / 20 / 100;
}
}
- c++;
}
return r;
}
SWF swf;
if (!filename)
return 0;
- f = open(filename, O_RDONLY);
+ f = open(filename, O_RDONLY|O_BINARY);
if (f < 0 || swf_ReadSWF(f, &swf) < 0) {
fprintf(stderr, "%s is not a valid SWF font file or contains errors.\n", filename);
t = swf_InsertTag(t, ST_END);
- f = open(filename, O_RDWR | O_CREAT | O_TRUNC, 0644);
+ f = open(filename, O_RDWR | O_CREAT | O_TRUNC | O_BINARY, 0644);
if FAILED
(swf_WriteSWF(f, &swf)) fprintf(stderr, "WriteSWF() failed in writeFont().\n");
close(f);
{
SRECT r;
U8 gbits, abits;
- U8 *c = (U8 *) text;
+ U8 *utext = (U8 *) strdup(text);
+ U8 *upos = utext;
+ int x = 0, y = 0;
int pos = 0;
+ int ystep = 0;
if (font->layout) {
r = swf_TextCalculateBBoxUTF8(font, text, scale * 20);
+ ystep = font->layout->leading;
} else {
fprintf(stderr, "No layout information- can't compute text bbox accurately");
/* Hm, without layout information, we can't compute a bounding
*/
r.xmin = r.ymin = 0;
r.xmax = r.ymax = 1024 * 20;
+ ystep = 100;
}
swf_SetRect(tag, &r);
swf_SetU8(tag, gbits);
swf_SetU8(tag, abits);
- /* now set the text params- notice that a font size of
- 1024 means that the glyphs will be displayed exactly
- as they would be in/with a defineshape. (Try to find
- *that* in the flash specs)
- */
- swf_TextSetInfoRecord(tag, font, (scale * 1024) / 100, rgb, 0, 0); //scale
+ while(*upos) {
+ U8*next = upos;
+ int count = 0;
+
+ swf_TextSetInfoRecord(tag, font, (scale * 1024) / 100, rgb, x, y); //scale
+ x = 0;
+
+ while(*next && *next!=13 && *next!=10 && count<127) {
+ readUTF8char(&next);
+ count++;
+ }
+ if(next[0] == 13 || next[0] == 10) {
+ x = SET_TO_ZERO;
+ y += ystep;
+ }
+
+ if(next[0] == 13 && next[1] == 10)
+ next++;
+
+ if(next[0] == 13 || next[0] == 10) {
+ *next = 0;
+ next++;
+ }
- /* set the actual text- notice that we just pass our scale
- parameter over, as TextSetCharRecord calculates with
- percent, too */
- swf_TextSetCharRecordUTF8(tag, font, text, scale * 20, gbits, abits);
+ /* now set the text params- notice that a font size of
+ 1024 means that the glyphs will be displayed exactly
+ as they would be in/with a defineshape. (Try to find
+ *that* in the flash specs)
+ */
+ /* set the actual text- notice that we just pass our scale
+ parameter over, as TextSetCharRecord calculates with
+ percent, too */
+ swf_TextSetCharRecordUTF8(tag, font, upos, scale * 20, gbits, abits);
+
+ upos= next;
+
+ printf("%s\n", upos);
+ }
+ free(utext);
swf_SetU8(tag, 0);
return r;
if (!f->numchars)
return;
- f->layout = (SWFLAYOUT *) malloc(sizeof(SWFLAYOUT));
- memset(f->layout, 0, sizeof(SWFLAYOUT));
- f->layout->bounds = (SRECT *) malloc(f->numchars * sizeof(SRECT));
+ f->layout = (SWFLAYOUT *) rfx_calloc(sizeof(SWFLAYOUT));
+ f->layout->bounds = (SRECT *) rfx_alloc(f->numchars * sizeof(SRECT));
f->layout->ascent = -32767;
f->layout->descent = -32767;
git.asbjorn.biz / swftools.git / blobdiff