X-Git-Url: http://git.asbjorn.biz/?a=blobdiff_plain;f=lib%2Fmodules%2Fswftext.c;h=4b57c83689bbd9c6164c446c4df6574144d7fd2a;hb=f87cabd9d7dc5e891104f98b8b60f65b8bc86559;hp=181c498f07bae5ac32d011275431ee27e8811b9c;hpb=705601665b6f7e4327ce7984cfba879a0ade0f08;p=swftools.git diff --git a/lib/modules/swftext.c b/lib/modules/swftext.c index 181c498..4b57c83 100644 --- a/lib/modules/swftext.c +++ b/lib/modules/swftext.c @@ -101,7 +101,7 @@ int swf_FontIsBold(SWFFONT * f) 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; @@ -129,7 +129,7 @@ int swf_FontEnumerate(SWF * swf, void (*FontCallback) (U16, U8 *)) s[l] = 0; } - (FontCallback) (id, s); + (FontCallback) (self, id, s); swf_RestoreTagPos(t); } @@ -157,8 +157,7 @@ int swf_FontExtract_DefineFont(int id, SWFFONT * f, TAG * 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); @@ -191,9 +190,9 @@ int swf_FontExtract_DefineFontInfo(int id, SWFFONT * f, TAG * 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; @@ -213,7 +212,7 @@ int swf_FontExtract_DefineFontInfo(int id, SWFFONT * f, TAG * t) 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)); @@ -224,7 +223,7 @@ int swf_FontExtract_DefineFontInfo(int id, SWFFONT * f, TAG * 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++) @@ -248,7 +247,7 @@ int swf_FontExtract_GlyphNames(int id, SWFFONT * f, TAG * tag) 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)); } @@ -264,6 +263,8 @@ int swf_FontExtract_DefineFont2(int id, SWFFONT * font, TAG * tag) int t, glyphcount; int maxcode; int fid; + U32 offset_start; + U32 *offset; U8 flags1, flags2, namelen; swf_SaveTagPos(tag); swf_SetTagPos(tag, 0); @@ -287,33 +288,44 @@ int swf_FontExtract_DefineFont2(int id, SWFFONT * font, TAG * tag) 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++) { @@ -330,7 +342,7 @@ int swf_FontExtract_DefineFont2(int id, SWFFONT * font, TAG * tag) 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; @@ -338,7 +350,7 @@ int swf_FontExtract_DefineFont2(int id, SWFFONT * font, TAG * tag) 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); @@ -346,7 +358,7 @@ int swf_FontExtract_DefineFont2(int id, SWFFONT * font, TAG * 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]); @@ -355,9 +367,9 @@ int swf_FontExtract_DefineFont2(int id, SWFFONT * font, TAG * tag) 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); @@ -382,7 +394,7 @@ int swf_FontExtract_DefineFont2(int id, SWFFONT * font, TAG * 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; @@ -419,6 +431,8 @@ swf_FontExtract_DefineTextCallback(int id, SWFFONT * f, TAG * t, int jobs, 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); @@ -493,8 +507,7 @@ int swf_FontExtract(SWF * swf, int id, SWFFONT * *font) if ((!swf) || (!font)) return -1; - f = (SWFFONT *) malloc(sizeof(SWFFONT)); - memset(f, 0x00, sizeof(SWFFONT)); + f = (SWFFONT *) rfx_calloc(sizeof(SWFFONT)); t = swf->firstTag; @@ -528,7 +541,7 @@ int swf_FontExtract(SWF * swf, int id, SWFFONT * *font) t = swf_NextTag(t); } if (f->id != id) { - free(f); + rfx_free(f); f = 0; } font[0] = f; @@ -543,36 +556,138 @@ int swf_FontSetID(SWFFONT * f, U16 id) 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; @@ -581,7 +696,7 @@ void swf_FontSort(SWFFONT * font) 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; @@ -619,7 +734,7 @@ void swf_FontSort(SWFFONT * font) } } } - newpos = malloc(sizeof(int) * font->numchars); + newpos = rfx_alloc(sizeof(int) * font->numchars); for (i = 0; i < font->numchars; i++) { newpos[newplace[i]] = i; } @@ -628,8 +743,8 @@ void swf_FontSort(SWFFONT * font) font->ascii2glyph[i] = newpos[font->ascii2glyph[i]]; } - free(newpos); - free(newplace); + rfx_free(newpos); + rfx_free(newplace); } void swf_FontPrepareForEditText(SWFFONT * font) @@ -639,36 +754,55 @@ 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)) @@ -696,7 +830,7 @@ int swf_FontSetDefine(TAG * t, SWFFONT * f) swf_SetSimpleShape(t, f->glyph[i].shape); swf_ResetWriteBits(t); - free(ofs); + rfx_free(ofs); return 0; } @@ -705,7 +839,11 @@ 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; + 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; @@ -747,7 +885,7 @@ int swf_FontSetDefine2(TAG * tag, SWFFONT * f) 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); @@ -774,8 +912,13 @@ int swf_FontSetDefine2(TAG * tag, SWFFONT * f) 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) + } + } } @@ -815,14 +958,13 @@ int swf_FontSetDefine2(TAG * tag, SWFFONT * f) 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) @@ -876,59 +1018,35 @@ int swf_TextPrintDefineText(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) @@ -949,10 +1067,24 @@ int swf_TextSetInfoRecord(TAG * t, SWFFONT * font, U16 size, RGBA * color, int d 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); @@ -1029,6 +1161,11 @@ static int swf_TextSetCharRecord2(TAG * t, SWFFONT * font, U8 * s, int scale, U8 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; } @@ -1081,24 +1218,32 @@ U32 swf_TextGetWidth(SWFFONT * font, U8 * s, int scale) 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; } @@ -1110,7 +1255,7 @@ SWFFONT *swf_ReadFont(char *filename) 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); @@ -1283,7 +1428,7 @@ void swf_WriteFont(SWFFONT * font, char *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); @@ -1337,10 +1482,14 @@ SRECT swf_SetDefineText(TAG * tag, SWFFONT * font, RGBA * rgb, char *text, int s { 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 @@ -1350,6 +1499,7 @@ SRECT swf_SetDefineText(TAG * tag, SWFFONT * font, RGBA * rgb, char *text, int s */ r.xmin = r.ymin = 0; r.xmax = r.ymax = 1024 * 20; + ystep = 100; } swf_SetRect(tag, &r); @@ -1366,17 +1516,45 @@ SRECT swf_SetDefineText(TAG * tag, SWFFONT * font, RGBA * rgb, char *text, int s 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; @@ -1391,9 +1569,8 @@ void swf_FontCreateLayout(SWFFONT * f) 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;