/* swftext.c
Text and font routines
-
+
Extension module for the rfxswf library.
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
the Free Software Foundation; either version 2 of the License, or
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)
+#include "../rfxswf.h"
+
+U32 readUTF8char(U8 ** text)
{
U32 c = 0;
if (!(*(*text) & 0x80))
int l;
U8 s[257];
s[0] = 0;
- swf_SaveTagPos(t);
swf_SetTagPos(t, 0);
id = swf_GetU16(t);
}
(FontCallback) (self, id, s);
-
- swf_RestoreTagPos(t);
}
}
t = swf_NextTag(t);
int swf_FontExtract_DefineFont(int id, SWFFONT * f, TAG * t)
{
U16 fid;
- swf_SaveTagPos(t);
swf_SetTagPos(t, 0);
fid = swf_GetU16(t);
of = swf_GetU16(t);
n = of / 2;
f->numchars = n;
- f->glyph = rfx_calloc(sizeof(SWFGLYPH) * n);
+ f->glyph = (SWFGLYPH*)rfx_calloc(sizeof(SWFGLYPH) * n);
for (i = 1; i < n; i++)
swf_GetU16(t);
for (i = 0; i < n; i++)
swf_GetSimpleShape(t, &f->glyph[i].shape);
}
-
- swf_RestoreTagPos(t);
return id;
}
U16 fid;
U16 maxcode;
U8 flags;
- swf_SaveTagPos(t);
swf_SetTagPos(t, 0);
fid = swf_GetU16(t);
for (i = 0; i < f->numchars; i++)
f->ascii2glyph[f->glyph2ascii[i]] = i;
}
-
- swf_RestoreTagPos(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 = rfx_alloc(sizeof(char *) * num);
+ f->glyphnames = (char**)rfx_alloc(sizeof(char *) * num);
for (t = 0; t < num; t++) {
f->glyphnames[t] = strdup(swf_GetString(tag));
}
}
-
- swf_RestoreTagPos(tag);
return id;
}
U32 offset_start;
U32 *offset;
U8 flags1, flags2, namelen;
- swf_SaveTagPos(tag);
swf_SetTagPos(tag, 0);
font->version = 2;
fid = swf_GetU16(tag);
font->glyph = (SWFGLYPH *) rfx_calloc(sizeof(SWFGLYPH) * glyphcount);
font->glyph2ascii = (U16 *) rfx_calloc(sizeof(U16) * glyphcount);
- offset = rfx_calloc(sizeof(U32)*(glyphcount+1));
+ offset = (U32*)rfx_calloc(sizeof(U32)*(glyphcount+1));
offset_start = tag->pos;
if (flags1 & 8) { // wide offsets
swf_GetSimpleShape(tag, &(font->glyph[t].shape));
}
- swf_SetTagPos(tag, offset[glyphcount]+offset_start);
+ if(glyphcount)
+ swf_SetTagPos(tag, offset[glyphcount]+offset_start);
free(offset);
S16 advance = swf_GetS16(tag);
font->glyph[t].advance = advance;
}
- font->layout->bounds = rfx_alloc(glyphcount * sizeof(SRECT));
+ font->layout->bounds = (SRECT*)rfx_alloc(glyphcount * sizeof(SRECT));
for (t = 0; t < glyphcount; t++) {
swf_ResetReadBits(tag);
swf_GetRect(tag, &font->layout->bounds[t]);
font->layout->kerning = (SWFKERNING *) rfx_alloc(sizeof(SWFKERNING) * kerningcount);
if (kerningcount) {
- font->layout->kerning = rfx_alloc(sizeof(*font->layout->kerning) * kerningcount);
+ font->layout->kerning = (SWFKERNING*)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);
}
}
}
- swf_RestoreTagPos(t);
return font->id;
}
SRECT r;
MATRIX m;
U8 gbits, abits;
- int fid = 0;
+ int fid = -1;
RGBA color;
int x = 0, y = 0;
int fontsize = 0;
memset(&color, 0, sizeof(color));
- swf_SaveTagPos(t);
swf_SetTagPos(t, 0);
cid = swf_GetU16(t);
adv = swf_GetBits(t, abits);
xpos += adv;
- // <deprecated>
if (id == fid) {
if (jobs & FEDTJ_PRINT) {
int code = f->glyph2ascii[glyph];
}
if (jobs & FEDTJ_MODIFY)
f->glyph[glyph].advance = adv * 20; //?
- } else {
- if (jobs & FEDTJ_PRINT) {
- printf("?");
- }
}
- // </deprecated>
buf[i] = glyph;
}
}
}
- swf_RestoreTagPos(t);
return id;
}
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;
- }
+ 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;
}
- rfx_free(f->glyphnames);
- f->glyphnames = 0;
- }
-
}
static void font_freeusage(SWFFONT*f)
{
return j;
}
+int swf_FontReduce_swfc(SWFFONT * f)
+{
+ int i, j;
+ int max_unicode = 0;
+ if ((!f) || (!f->use) || f->use->is_reduced)
+ return -1;
+
+ font_freeglyphnames(f);
+
+ j = 0;
+ for (i = 0; i < f->numchars; i++) {
+ if (f->glyph[i].shape && f->use->chars[i]) {
+ f->glyph2ascii[j] = f->glyph2ascii[i];
+ if (f->layout)
+ f->layout->bounds[j] = f->layout->bounds[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->glyph[i].shape = 0;
+ f->glyph[i].advance = 0;
+ }
+ f->use->chars[i] = -1;
+ }
+ }
+ f->use->used_glyphs = j;
+ for (i = 0; i < f->maxascii; i++) {
+ if(f->ascii2glyph[i] > -1) {
+ if (f->use->chars[f->ascii2glyph[i]]<0) {
+ f->use->chars[f->ascii2glyph[i]] = 0;
+ f->ascii2glyph[i] = -1;
+ } else {
+ f->ascii2glyph[i] = f->use->chars[f->ascii2glyph[i]];
+ f->use->chars[f->ascii2glyph[i]] = 1;
+ max_unicode = i + 1;
+ }
+ }
+ }
+ f->maxascii = max_unicode;
+ f->use->is_reduced = 1;
+ f->numchars = j;
+ font_freename(f);
+ return j;
+}
+
int swf_FontReduce(SWFFONT * f)
{
int i;
int max_glyph = 0;
if ((!f) || (!f->use) || f->use->is_reduced)
return -1;
-
+
font_freelayout(f);
font_freeglyphnames(f);
f->glyph[i].shape = 0;
f->glyph[i].advance = 0;
}
- f->use->used_glyphs++;
+// f->use->used_glyphs++;
} else {
+ f->use->used_glyphs++;
max_glyph = i+1;
}
}
for (i = 0; i < f->maxascii; i++) {
- if(!f->use->chars[f->ascii2glyph[i]]) {
+ if(f->ascii2glyph[i] > -1 && !f->use->chars[f->ascii2glyph[i]]) {
if(f->ascii2glyph) {
f->ascii2glyph[i] = -1;
}
void swf_FontSort(SWFFONT * font)
{
- int i, j, k;
+ int i, j;
int *newplace;
int *newpos;
if (!font)
return;
-
- newplace = rfx_alloc(sizeof(int) * font->numchars);
+
+ newplace = (int*)rfx_alloc(sizeof(int) * font->numchars);
for (i = 0; i < font->numchars; i++) {
newplace[i] = i;
}
}
}
- newpos = rfx_alloc(sizeof(int) * font->numchars);
+ newpos = (int*)rfx_alloc(sizeof(int) * font->numchars);
for (i = 0; i < font->numchars; i++) {
newpos[newplace[i]] = i;
}
fprintf(stderr, "Usage initialized twice");
return -1;
}
- f->use = rfx_alloc(sizeof(FONTUSAGE));
+ f->use = (FONTUSAGE*)rfx_alloc(sizeof(FONTUSAGE));
f->use->is_reduced = 0;
- f->use->chars = rfx_calloc(sizeof(f->use->chars[0]) * f->numchars);
+ f->use->used_glyphs = 0;
+ f->use->chars = (int*)rfx_calloc(sizeof(f->use->chars[0]) * f->numchars);
+ f->use->glyphs_specified = 0;
return 0;
}
return 0;
}
+int swf_FontUseUTF8(SWFFONT * f, U8 * s)
+{
+ if( (!s))
+ return -1;
+ int ascii;
+ while (*s)
+ {
+ ascii = readUTF8char(&s);
+ if(ascii < f->maxascii && f->ascii2glyph[ascii]>=0)
+ swf_FontUseGlyph(f, f->ascii2glyph[ascii]);
+ }
+ return 0;
+}
+
+int swf_FontUseAll(SWFFONT* f)
+{
+ int i;
+
+ if (!f->use)
+ swf_FontInitUsage(f);
+ for (i = 0; i < f->numchars; i++)
+ f->use->chars[i] = 1;
+ f->use->used_glyphs = f->numchars;
+ return 0;
+}
+
int swf_FontUseGlyph(SWFFONT * f, int glyph)
{
- if (!f->use)
+ if (!f->use)
swf_FontInitUsage(f);
if(glyph < 0 || glyph >= f->numchars)
return -1;
int size = 0;
for (t = 0; t < font->numchars; t++) {
int l = 0;
- if(font->glyph[t].shape)
+ if(font->glyph[t].shape)
l = (font->glyph[t].shape->bitlen + 7) / 8;
else
l = 8;
U8 flags = 0;
int t;
int pos;
- int pos2;
swf_SetU16(tag, f->id);
if (f->layout) flags |= 128; // haslayout
swf_SetU8(tag, 0); //reserved flags
if (f->name) {
/* font name */
- swf_SetU8(tag, strlen(f->name));
- swf_SetBlock(tag, f->name, strlen(f->name));
+ swf_SetU8(tag, strlen((const char*)f->name)+1);
+ swf_SetBlock(tag, f->name, strlen((const char*)f->name)+1);
} else {
/* font name (="") */
+ swf_SetU8(tag, 1);
swf_SetU8(tag, 0);
}
/* number of glyphs */
return -1;
swf_ResetWriteBits(t);
swf_SetU16(t, f->id);
- l = f->name ? strlen(f->name) : 0;
+ l = f->name ? strlen((const char *)f->name) : 0;
if (l > 255)
l = 255;
swf_SetU8(t, l);
{
int i;
if (!f)
- return;
+ return;
- 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;
- }
- rfx_free(f->glyph);
- f->glyph = 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;
+ }
+ rfx_free(f->glyph);
+ f->glyph = NULL;
}
- if (f->ascii2glyph) {
- rfx_free(f->ascii2glyph);
- f->ascii2glyph = NULL;
+ if (f->ascii2glyph)
+ {
+ rfx_free(f->ascii2glyph);
+ f->ascii2glyph = NULL;
}
- if (f->glyph2ascii) {
- rfx_free(f->glyph2ascii);
- f->glyph2ascii = NULL;
+ if (f->glyph2ascii)
+ {
+ rfx_free(f->glyph2ascii);
+ f->glyph2ascii = NULL;
}
font_freename(f);
font_freelayout(f);
rfx_free(f);
}
-int swf_TextSetInfoRecord(TAG * t, SWFFONT * font, U16 size, RGBA * color, int dx, int dy)
+int swf_TextSetInfoRecord(TAG * t, SWFFONT * font, U16 size, RGBA * color, int x, int y)
{
U8 flags;
if (!t)
return -1;
- flags = TF_TEXTCONTROL | (font ? TF_HASFONT : 0) | (color ? TF_HASCOLOR : 0) | (dx ? TF_HASXOFFSET : 0)
- | (dy ? TF_HASYOFFSET : 0);
+ flags = TF_TEXTCONTROL | (font ? TF_HASFONT : 0) | (color ? TF_HASCOLOR : 0) | (x ? TF_HASXOFFSET : 0)
+ | (y ? TF_HASYOFFSET : 0);
swf_SetU8(t, flags);
if (font)
else
swf_SetRGB(t, color);
}
- 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);
+ if (x) {
+ if(x != SET_TO_ZERO) {
+ if(x>32767 || x<-32768)
+ fprintf(stderr, "Warning: Horizontal char position overflow: %d\n", x);
+ swf_SetS16(t, x);
} 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);
+ if (y) {
+ if(y != SET_TO_ZERO) {
+ if(y>32767 || y<-32768)
+ fprintf(stderr, "Warning: Vertical char position overflow: %d\n", y);
+ swf_SetS16(t, y);
} else {
swf_SetS16(t, 0);
}
}
-SWFFONT *swf_ReadFont(char *filename)
+SWFFONT *swf_ReadFont(const char *filename)
{
int f;
SWF swf;
int storeGlyphNames = 1;
if (font->layout)
- useDefineFont2 = 1; /* the only thing new in definefont2
+ useDefineFont2 = 1; /* the only thing new in definefont2
is layout information. */
font->id = WRITEFONTID; //"FN"
memset(&swf, 0x00, sizeof(SWF));
- swf.fileVersion = 4;
+ swf.fileVersion = 9;
swf.frameRate = 0x4000;
/* if we use DefineFont1 to store the characters,
t = swf_InsertTag(t, ST_DEFINEFONT2);
swf_FontSetDefine2(t, font);
}
+ if(font->name) {
+ t = swf_InsertTag(t, ST_NAMECHARACTER);
+ swf_SetU16(t, WRITEFONTID);
+ swf_SetString(t, font->name);
+ t = swf_InsertTag(t, ST_EXPORTASSETS);
+ swf_SetU16(t, 1);
+ swf_SetU16(t, WRITEFONTID);
+ swf_SetString(t, font->name);
+
+ t = swf_AddAS3FontDefine(t, WRITEFONTID, font->name);
+ }
if (storeGlyphNames && font->glyphnames) {
int c;
swf_SetU16(t, font->numchars);
for (c = 0; c < font->numchars; c++) {
if (font->glyphnames[c])
- swf_SetString(t, font->glyphnames[c]);
+ swf_SetString(t, (U8*)font->glyphnames[c]);
else
- swf_SetString(t, "");
+ swf_SetString(t, (U8*)"");
}
}
}
-void swf_SetEditText(TAG * tag, U16 flags, SRECT r, char *text, RGBA * color, int maxlength, U16 font, U16 height, EditTextLayout * layout, char *variable)
+void swf_SetEditText(TAG * tag, U16 flags, SRECT r, const char *text, RGBA * color, int maxlength, U16 font, U16 height, EditTextLayout * layout, const char *variable)
{
swf_SetRect(tag, &r);
swf_ResetWriteBits(tag);
swf_SetU16(tag, layout->indent); //indent
swf_SetU16(tag, layout->leading); //leading
}
- swf_SetString(tag, variable);
+ swf_SetString(tag, (U8*)variable);
if (flags & ET_HASTEXT)
- swf_SetString(tag, text);
+ swf_SetString(tag, (U8*)text);
}
-SRECT swf_SetDefineText(TAG * tag, SWFFONT * font, RGBA * rgb, char *text, int scale)
+SRECT swf_SetDefineText(TAG * tag, SWFFONT * font, RGBA * rgb, const char *text, int scale)
{
SRECT r;
U8 gbits, abits;
int pos = 0;
int ystep = 0;
if (font->layout) {
- r = swf_TextCalculateBBoxUTF8(font, text, scale * 20);
+ r = swf_TextCalculateBBoxUTF8(font, (U8*)text, scale * 20);
ystep = font->layout->leading;
} else {
fprintf(stderr, "No layout information- can't compute text bbox accurately");
*/
swf_SetMatrix(tag, 0);
- swf_TextCountBitsUTF8(font, text, scale * 20, &gbits, &abits);
+ swf_TextCountBitsUTF8(font, (U8*)text, scale * 20, &gbits, &abits);
swf_SetU8(tag, gbits);
swf_SetU8(tag, abits);
while(*upos) {
U8*next = upos;
int count = 0;
-
+
swf_TextSetInfoRecord(tag, font, (scale * 1024) / 100, rgb, x, y); //scale
x = 0;
if(next[0] == 13 && next[1] == 10)
next++;
-
+
if(next[0] == 13 || next[0] == 10) {
*next = 0;
next++;
*that* in the flash specs)
*/
/* set the actual text- notice that we just pass our scale
- parameter over, as TextSetCharRecord calculates with
+ parameter over, as TextSetCharRecord calculates with
percent, too */
swf_TextSetCharRecordUTF8(tag, font, upos, scale * 20, gbits, abits);
}
}
-void swf_DrawText(drawer_t * draw, SWFFONT * font, int size, char *text)
+void swf_DrawText(drawer_t * draw, SWFFONT * font, int size, const char *text)
{
U8 *s = (U8 *) text;
int advance = 0;
git.asbjorn.biz / swftools.git / blobdiff