typedef struct _fontfile
{
- char*filename;
+ const char*filename;
int used;
} fontfile_t;
static char* lastfontdir = 0;
struct fontentry {
- char*pdffont;
- char*filename;
+ const char*pdffont;
+ const char*filename;
char*afm;
int afmlen;
char*pfb;
static int verbose = 0;
static int dbgindent = 0;
-static void dbg(char*format, ...)
+static void dbg(const char*format, ...)
{
char buf[1024];
int l;
} feature_t;
feature_t*featurewarnings = 0;
-void GFXOutputDev::showfeature(char*feature,char fully, char warn)
+void GFXOutputDev::showfeature(const char*feature,char fully, char warn)
{
feature_t*f = featurewarnings;
while(f) {
msg("<notice> File contains %s",feature);
}
}
-void GFXOutputDev::warnfeature(char*feature,char fully)
+void GFXOutputDev::warnfeature(const char*feature,char fully)
{
showfeature(feature,fully,1);
}
-void GFXOutputDev::infofeature(char*feature)
+void GFXOutputDev::infofeature(const char*feature)
{
showfeature(feature,0,0);
}
GFXOutputState::GFXOutputState() {
this->clipping = 0;
- this->textRender = 0;
this->createsoftmask = 0;
this->transparencygroup = 0;
this->softmask = 0;
this->pagepos = 0;
this->config_use_fontconfig=1;
this->config_break_on_warning=0;
+ this->config_remapunicode=0;
+ this->config_transparent=0;
this->do_interpretType3Chars = gTrue;
this->parameters = p;
}
};
-void GFXOutputDev::setParameter(char*key, char*value)
+void GFXOutputDev::setParameter(const char*key, const char*value)
{
if(!strcmp(key,"rawtext")) {
this->do_interpretType3Chars = atoi(value)^1;
this->config_break_on_warning = atoi(value);
} else if(!strcmp(key,"fontconfig")) {
this->config_use_fontconfig = atoi(value);
+ } else if(!strcmp(key,"remapunicode")) {
+ this->config_remapunicode = atoi(value);
+ } else if(!strcmp(p->name,"transparent")) {
+ this->config_transparent = atoi(p->value);
} else {
msg("<warning> Ignored parameter: %s=%s", key, value);
}
return mybuf;
}
-static void dumpFontInfo(char*loglevel, GfxFont*font);
+static void dumpFontInfo(const char*loglevel, GfxFont*font);
static int lastdumps[1024];
static int lastdumppos = 0;
/* nr = 0 unknown
else if(nr == 1)
msg("<warning> The following font caused problems (substituting):");
else if(nr == 2)
- msg("<warning> The following Type 3 Font will be rendered as bitmap:");
+ msg("<warning> The following Type 3 Font will be rendered as graphics:");
dumpFontInfo("<warning>", font);
}
-static void dumpFontInfo(char*loglevel, GfxFont*font)
+static void dumpFontInfo(const char*loglevel, GfxFont*font)
{
char* id = getFontID(font);
char* name = getFontName(font);
infofeature("shaded fills");
return gFalse;
}
+
+GBool GFXOutputDev::useDrawForm()
+{
+ infofeature("forms");
+ return gFalse;
+}
+void GFXOutputDev::drawForm(Ref id)
+{
+ msg("<error> drawForm not implemented");
+}
+GBool GFXOutputDev::needNonText()
+{
+ return gTrue;
+}
+void GFXOutputDev::endPage()
+{
+ msg("<verbose> endPage");
+}
#define STROKE_FILL 1
#define STROKE_CLIP 2
return gTrue;
}
-char*renderModeDesc[]= {"fill", "stroke", "fill+stroke", "invisible",
+const char*renderModeDesc[]= {"fill", "stroke", "fill+stroke", "invisible",
"clip+fill", "stroke+clip", "fill+stroke+clip", "clip"};
#define RENDER_FILL 0
int getGfxCharID(gfxfont_t*font, int charnr, char *charname, int u)
{
- char*uniname = 0;
+ const char*uniname = 0;
if(!font)
return charnr;
if(u>0) {
msg("<debug> Char [%d,%s,>%d<] maps to %d\n", charnr, charname, u, font->unicode2glyph[u]);
return font->unicode2glyph[u];
}
+ /* try to use the unicode|0xe000 (needed for some WingDings fonts)
+ FIXME: do this only if we know the font is wingdings?
+ */
+ u |= 0xe000;
+ if(u>=0 && u<font->max_unicode && font->unicode2glyph[u]>=0) {
+ msg("<debug> Char [%d,%s,>%d<] maps to %d\n", charnr, charname, u, font->unicode2glyph[u]);
+ return font->unicode2glyph[u];
+ }
if(charnr>=0 && charnr<font->num_glyphs) {
msg("<debug> Char [>%d<,%s,%d] maps to %d\n", charnr, charname, u, charnr);
this->current_font_matrix.ty = 0;
gfxmatrix_t m = this->current_font_matrix;
+}
- states[statepos].textRender = render;
+static gfxline_t* mkEmptyGfxShape(double x, double y)
+{
+ gfxline_t*line = (gfxline_t*)malloc(sizeof(gfxline_t));
+ line->x = x;line->y = y;line->type = gfx_moveTo;line->next = 0;
+ return line;
+}
+
+static char isValidUnicode(int c)
+{
+ if(c>=32 && c<0x2fffe)
+ return 1;
+ return 0;
}
void GFXOutputDev::drawChar(GfxState *state, double x, double y,
return;
}
- if(states[statepos].textRender != render)
- msg("<error> Internal error: drawChar.render!=beginString.render");
-
gfxcolor_t col = getFillColor(state);
Gushort *CIDToGIDMap = 0;
if(uLen)
u = _u[0];
+/* char*fontname = getFontName(font);
+ if(u<256 && strstr(fontname, "ingdings")) {
+ // symbols are at 0xe000 in the unicode table
+ u |= 0xe000;
+ }
+ free(fontname);*/
+
if(font->isCIDFont()) {
GfxCIDFont*cfont = (GfxCIDFont*)font;
FIXNULL(name),c, u, FIXNULL((char*)current_gfxfont->id), current_gfxfont->num_glyphs);
return;
}
+ //useless- the font has already been passed to the output device
+ //if(!isValidUnicode(current_gfxfont->glyphs[charid].unicode) && isValidUnicode(u)) {
+ // current_gfxfont->glyphs[charid].
+ //}
gfxmatrix_t m = this->current_font_matrix;
state->transform(x, y, &m.tx, &m.ty);
m.tx += user_movex + clipmovex;
m.ty += user_movey + clipmovey;
+ if((!name || strcmp(name, "space")) && charid!=32 && u!=32)
+ {
+ gfxline_t*l = current_gfxfont->glyphs[charid].line;
+ double x,y;
+ char ok = 0;
+ while(l) {
+ if((l->type == gfx_lineTo || l->type == gfx_splineTo) && l->x!=x && l->y!=y) {
+ ok = 1;
+ }
+ l = l->next;
+ }
+ if(!ok) {
+ static int lastemptychar = 0;
+ if(charid != lastemptychar)
+ msg("<warning> Drawing empty character charid=%d u=%d", charid, u);
+ lastemptychar = charid;
+ }
+ }
+
if(render == RENDER_FILL) {
device->drawchar(device, current_gfxfont, charid, &col, &m);
} else {
if(render&RENDER_CLIP) {
gfxline_t*add = gfxline_clone(tglyph);
current_text_clip = gfxline_append(current_text_clip, add);
+ if(!current_text_clip) {
+ current_text_clip = mkEmptyGfxShape(m.tx, m.ty);
+ }
}
gfxline_free(tglyph);
}
{
int render = state->getRender();
msg("<trace> endString() render=%d textstroke=%08x", render, current_text_stroke);
- if(states[statepos].textRender != render)
- msg("<error> Internal error: drawChar.render!=beginString.render");
if(current_text_stroke) {
/* fillstroke and stroke text rendering objects we can process right
{
int render = state->getRender();
msg("<trace> endTextObject() render=%d textstroke=%08x clipstroke=%08x", render, current_text_stroke, current_text_clip);
- if(states[statepos].textRender != render)
- msg("<error> Internal error: drawChar.render!=beginString.render");
if(current_text_clip) {
device->setparameter(device, "mark","TXT");
clippath[3].type = gfx_lineTo;clippath[3].x = x1; clippath[3].y = y2; clippath[3].next = &clippath[4];
clippath[4].type = gfx_lineTo;clippath[4].x = x1; clippath[4].y = y1; clippath[4].next = 0;
device->startclip(device, clippath); outer_clip_box = 1;
- device->fill(device, clippath, &white);
+ if(!config_transparent)
+ device->fill(device, clippath, &white);
}
LinkAction*action=link->getAction();
char buf[128];
char*s = 0;
- char*type = "-?-";
+ const char*type = "-?-";
char*named = 0;
int page = -1;
msg("<trace> drawlink action=%d\n", action->getKind());
return;
}
statepos ++;
- states[statepos].textRender = states[statepos-1].textRender;
states[statepos].createsoftmask = states[statepos-1].createsoftmask;
states[statepos].transparencygroup = states[statepos-1].transparencygroup;
states[statepos].clipping = 0;
msg("<error> Invalid restoreState");
return;
}
- msg("<trace> restoreState");
+ msg("<trace> restoreState%s%s", states[statepos].softmask?" (end softmask)":"",
+ states[statepos].clipping?" (end clipping)":"");
if(states[statepos].softmask) {
clearSoftMask(state);
}
return strdup(namebuf2);
}
-char* GFXOutputDev::searchFont(char*name)
+char* GFXOutputDev::searchFont(const char*name)
{
int i;
char*filename=0;
char* GFXOutputDev::substituteFont(GfxFont*gfxFont, char* oldname)
{
- char*fontname = 0, *filename = 0;
+ const char*fontname = 0, *filename = 0;
msg("<notice> substituteFont(%s)", oldname);
if(!(fontname = searchForSuitableFont(gfxFont))) {
this->xref = xref;
}
-int GFXOutputDev::setGfxFont(char*id, char*name, char*filename, double maxSize)
+int GFXOutputDev::setGfxFont(char*id, char*name, char*filename, double maxSize, CharCodeToUnicode*ctu)
{
gfxfont_t*font = 0;
fontlist_t*last=0,*l = this->fontlist;
double quality = (1024 * 0.05) / maxSize;
msg("<verbose> Loading %s...", filename);
- font = gfxfont_load(id, filename, quality);
+ font = gfxfont_load(id, filename, 0, quality);
if(!font) {
msg("<verbose> Couldn't load Font %s (%s)", filename, id);
return 0;
}
msg("<verbose> Font %s (%s) loaded successfully", filename, id);
+ if(this->config_remapunicode && ctu) {
+ int c;
+ for(c=0;c<font->num_glyphs;c++) {
+ Unicode u[8];
+ int uLen = ctu->mapToUnicode(c, u, 8);
+ if(uLen && !isValidUnicode(font->glyphs[c].unicode) && isValidUnicode(u[0]))
+ font->glyphs[c].unicode = u[0];
+ }
+ }
+
l = new fontlist_t;
l->font = font;
l->filename = strdup(filename);
/* second, see if this is a font which was used before-
if so, we are done */
- if(setGfxFont(fontid, fontname, 0, 0)) {
+ if(setGfxFont(fontid, fontname, 0, 0, gfxFont->getCTU())) {
free(fontid);
free(fontname);
return;
//swfoutput_setfont(&device, fontid, fileName);
- if(!setGfxFont(fontid, fontname, 0, 0)) {
- setGfxFont(fontid, fontname, fileName, maxSize);
+ if(!setGfxFont(fontid, fontname, 0, 0, gfxFont->getCTU())) {
+ setGfxFont(fontid, fontname, fileName, maxSize, gfxFont->getCTU());
}
if(fileName && del)
}
-static char* dirseparator()
+static const char* dirseparator()
{
#ifdef WIN32
return "\\";
#endif
}
-void addGlobalFont(char*filename)
+void addGlobalFont(const char*filename)
{
fontfile_t f;
memset(&f, 0, sizeof(fontfile_t));
}
}
-void addGlobalLanguageDir(char*dir)
+void addGlobalLanguageDir(const char*dir)
{
if(!globalParams)
- globalParams = new GlobalParams("");
+ globalParams = new GlobalParams((char*)"");
msg("<notice> Adding %s to language pack directories", dir);
fclose(fi);
}
-void addGlobalFontDir(char*dirname)
+void addGlobalFontDir(const char*dirname)
{
#ifdef HAVE_DIRENT_H
msg("<notice> Adding %s to font directories", dirname);
GBool isolated, GBool knockout,
GBool forSoftMask)
{
- char*colormodename = "";
+ const char*colormodename = "";
BBox rect = mkBBox(state, bbox, this->width, this->height);
if(blendingColorSpace) {
void GFXOutputDev::paintTransparencyGroup(GfxState *state, double *bbox)
{
- char*blendmodes[] = {"normal","multiply","screen","overlay","darken", "lighten",
- "colordodge","colorburn","hardlight","softlight","difference",
- "exclusion","hue","saturation","color","luminosity"};
+ const char*blendmodes[] = {"normal","multiply","screen","overlay","darken", "lighten",
+ "colordodge","colorburn","hardlight","softlight","difference",
+ "exclusion","hue","saturation","color","luminosity"};
dbg("paintTransparencyGroup blend=%s softmaskon=%d", blendmodes[state->getBlendMode()], states[statepos].softmask);
msg("<verbose> paintTransparencyGroup blend=%s softmaskon=%d", blendmodes[state->getBlendMode()], states[statepos].softmask);
return (Guchar)((x + (x >> 8) + 0x80) >> 8);
}
+static unsigned char clampU8(unsigned char c, unsigned char min, unsigned char max)
+{
+ if(c < min) c = min;
+ if(c > max) c = max;
+ return c;
+}
+
void GFXOutputDev::clearSoftMask(GfxState *state)
{
if(!states[statepos].softmask)
alpha = (77*l1->r + 151*l1->g + 28*l1->b) >> 8;
}
- /* premultiply alpha */
l2->a = div255(alpha*l2->a);
- l2->r = div255(alpha*l2->r);
- l2->g = div255(alpha*l2->g);
- l2->b = div255(alpha*l2->b);
+
+ /* DON'T premultiply alpha- this is done by fillbitmap,
+ depending on the output device */
+ //l2->r = div255(alpha*l2->r);
+ //l2->g = div255(alpha*l2->g);
+ //l2->b = div255(alpha*l2->b);
l1++;
l2++;
git.asbjorn.biz / swftools.git / blobdiff