#include <stdarg.h>
#include <stddef.h>
#include <string.h>
+#ifdef HAVE_UNISTD_H
#include <unistd.h>
+#endif
#include "../../config.h"
#include "../os.h"
#ifdef HAVE_DIRENT_H
#include "GHash.h"
#include "GFXOutputDev.h"
-//swftools header files
+// swftools header files
#include "../log.h"
#include "../gfxdevice.h"
#include "../gfxtools.h"
#include "../devices/render.h"
#include "../art/libart.h"
-#include "../devices/artsutils.c"
+#include "../devices/artsutils.h"
#include "../png.h"
#include "fonts.h"
typedef struct _fontfile
{
const char*filename;
+ int len; // basename length
int used;
+ struct _fontfile*next;
} fontfile_t;
// for pdfswf_addfont
-static fontfile_t fonts[2048];
+
+static fontfile_t* global_fonts = 0;
+static fontfile_t* global_fonts_next = 0;
+
static int fontnum = 0;
/* config */
} feature_t;
feature_t*featurewarnings = 0;
-void GFXOutputDev::showfeature(const char*feature,char fully, char warn)
+void GFXOutputDev::showfeature(const char*feature, char fully, char warn)
{
feature_t*f = featurewarnings;
while(f) {
return dfp;
}
}
- for(t=0;t<fontnum;t++) {
- if(strstr(fonts[t].filename, name)) {
- DisplayFontParam *dfp = new DisplayFontParam(new GString(fontName), displayFontT1);
- dfp->t1.fileName = new GString(fonts[t].filename);
- return dfp;
- }
+
+ int bestlen = 0x7fffffff;
+ const char*bestfilename = 0;
+
+ fontfile_t*f = 0;
+ while(f) {
+ if(strstr(f->filename, name)) {
+ if(f->len < bestlen) {
+ bestlen = f->len;
+ bestfilename = f->filename;
+ }
+ }
+ f = f->next;
+ }
+ if(bestfilename) {
+ DisplayFontParam *dfp = new DisplayFontParam(new GString(fontName), displayFontT1);
+ dfp->t1.fileName = new GString(bestfilename);
+ return dfp;
}
return GlobalParams::getDisplayFont(fontName);
}
this->config_remapunicode=0;
this->config_transparent=0;
this->config_extrafontdata = 0;
+ this->config_fontquality = 10;
this->gfxfontlist = gfxfontlist_create();
this->config_transparent = atoi(value);
} else if(!strcmp(key,"extrafontdata")) {
this->config_extrafontdata = atoi(value);
+ } else if(!strcmp(key,"fontquality")) {
+ this->config_fontquality = atof(value);
+ if(this->config_fontquality<=1)
+ this->config_fontquality=1;
} else if(!strcmp(key,"help")) {
printf("\nPDF layer options:\n");
printf("breakonwarning=0/1 Abort conversion if graphic objects are found which\n");
printf(" are not 100%% supported\n");
printf("transparent=0/1 Make PDF transparent (alpha background)\n");
printf("extrafontdata=0/1 Store Type3 characters and capture characters\n");
+ printf("fontquality=1..100 Curve approximation quality of the fonts\n");
}
}
}
void GFXOutputDev::endPage()
{
- msg("<verbose> endPage");
+ msg("<verbose> endPage (GfxOutputDev)");
if(outer_clip_box) {
device->endclip(device);
outer_clip_box = 0;
msg("<trace> %d dashes", dashnum);
msg("<trace> | phase: %f", dashphase);
for(t=0;t<dashnum;t++) {
- dash[t] = ldash[t];
+ dash[t] = (float)ldash[t];
msg("<trace> | d%-3d: %f", t, ldash[t]);
}
dash[dashnum] = -1;
dump_outline(line);
}
- line2 = gfxtool_dash_line(line, dash, dashphase);
+ line2 = gfxtool_dash_line(line, dash, (float)dashphase);
line = line2;
free(dash);
msg("<trace> After dashing:");
CharCode charid, int nBytes, Unicode *_u, int uLen)
{
if(!current_fontinfo || (unsigned)charid >= current_fontinfo->num_glyphs || !current_fontinfo->glyphs[charid]) {
- msg("<error> Invalid charid %d for font %s", charid, current_font_id);
+ msg("<error> Invalid charid %d for font (%d characters)", charid, current_fontinfo?current_fontinfo->num_glyphs:0);
return;
}
m.ty += user_movey + clipmovey;
if(!current_fontinfo || (unsigned)charid >= current_fontinfo->num_glyphs || !current_fontinfo->glyphs[charid]) {
- msg("<error> Invalid charid %d for font %s", charid, current_font_id);
+ msg("<error> Invalid charid %d for font", charid);
return gFalse;
}
gfxcolor_t col={0,0,0,0};
this->currentpage = pageNum;
double x1,y1,x2,y2;
int rot = doc->getPageRotate(1);
- gfxcolor_t white;
+ gfxcolor_t white = {255,255,255,255};
+ gfxcolor_t black = {255,0,0,0};
laststate = state;
gfxline_t clippath[5];
- white.r = white.g = white.b = white.a = 255;
-
/* state->transform(state->getX1(),state->getY1(),&x1,&y1);
state->transform(state->getX2(),state->getY2(),&x2,&y2);
Use CropBox, not MediaBox, as page size
void GFXOutputDev::processLink(Link *link, Catalog *catalog)
{
- double x1, y1, x2, y2, w;
+ double x1, y1, x2, y2;
gfxline_t points[5];
int x, y;
points[1].x, points[1].y,
points[2].x, points[2].y,
points[3].x, points[3].y);
+
+ if(getLogLevel() >= LOGLEVEL_TRACE) {
+ dump_outline(points);
+ }
LinkAction*action=link->getAction();
char buf[128];
}
-gfxfont_t* createGfxFont(GfxFont*xpdffont, FontInfo*src)
+gfxfont_t* createGfxFont(GfxFont*xpdffont, FontInfo*src, double config_fontquality)
{
gfxfont_t*font = (gfxfont_t*)malloc(sizeof(gfxfont_t));
memset(font, 0, sizeof(gfxfont_t));
memset(font->glyphs, 0, sizeof(gfxglyph_t)*src->num_glyphs);
font->id = strdup(getFontID(xpdffont));
int t;
- double quality = (INTERNAL_FONT_SIZE * 20) / src->max_size;
+
+ double quality = (INTERNAL_FONT_SIZE * 200 / config_fontquality) / src->max_size;
double scale = 1;
//printf("%d glyphs\n", font->num_glyphs);
font->num_glyphs = 0;
this->current_fontinfo = this->info->getFont(id);
if(!this->current_fontinfo) {
msg("<error> Internal Error: no fontinfo for font %s\n", id);
+ return;
}
if(!this->current_fontinfo->seen) {
dumpFontInfo("<verbose>", gfxFont);
gfxfont_t*font = gfxfontlist_findfont(this->gfxfontlist,id);
if(!font) {
- font = createGfxFont(gfxFont, current_fontinfo);
+ font = createGfxFont(gfxFont, current_fontinfo, this->config_fontquality);
font->id = strdup(id);
this->gfxfontlist = gfxfontlist_addfont(this->gfxfontlist, font);
device->addfont(device, font);
unsigned char*newdata;
int x,y;
newdata= (unsigned char*)malloc(newwidth*newheight);
- int t;
double fx = (double)(width)/newwidth;
double fy = (double)(height)/newheight;
double px = 0;
p5.y = (int)(p5.y*20)/20.0;
}
- float m00,m10,tx;
- float m01,m11,ty;
-
gfxmatrix_t m;
m.m00 = (p4.x-p1.x)/sizex; m.m10 = (p2.x-p1.x)/sizey;
m.m01 = (p4.y-p1.y)/sizex; m.m11 = (p2.y-p1.y)/sizey;
imgStr = new ImageStream(str, width, ncomps,bits);
imgStr->reset();
- if(!width || !height || (height<=1 && width<=1))
+ if(!width || !height || (height<=1 && width<=1 && maskWidth<=1 && maskHeight<=1))
{
msg("<verbose> Ignoring %d by %d image", width, height);
unsigned char buf[8];
}
if(mask) {
- int i,j;
unsigned char buf[8];
int x,y;
unsigned char*pic = new unsigned char[width*height];
/* the size of the drawn image is added to the identifier
as the same image may require different bitmaps if displayed
at different sizes (due to antialiasing): */
- int t,found = -1;
+ int found = -1;
if(type3active) {
unsigned char*pic2 = 0;
numpalette = 16;
pic2 = antialize(pic,width,height,realwidth,realheight,numpalette);
if(!pic2) {
- delete pic;
+ delete[] pic;
delete imgStr;
return;
}
/* make a black/white palette */
- float r = 255/(numpalette-1);
+ float r = 255./(float)(numpalette-1);
int t;
for(t=0;t<numpalette;t++) {
pal[t].r = colToByte(rgb.r);
drawimagejpeg(device, pic, width, height, x1,y1,x2,y2,x3,y3,x4,y4);
else
drawimagelossless(device, pic, width, height, x1,y1,x2,y2,x3,y3,x4,y4);
- delete pic;
+ delete[] pic;
delete imgStr;
if(maskbitmap) free(maskbitmap);
return;
for (x = 0; x < width; ++x) {
imgStr->getPixel(pixBuf);
pic[width*y+x] = pal[pixBuf[0]];
- if(maskbitmap) {
- pic[width*y+x].a = maskbitmap[(y*maskHeight/height)*maskWidth+(x*maskWidth/width)];
- }
}
}
+ if(maskbitmap) {
+ if(maskWidth < width && maskHeight < height) {
+ for(y = 0; y < height; y++) {
+ for (x = 0; x < width; x++) {
+ pic[width*y+x].a = maskbitmap[(y*maskHeight/height)*maskWidth+(x*maskWidth/width)];
+ }
+ }
+ } else {
+ msg("<verbose> resampling %dx%d to mask size (%dx%d)", width, height, maskWidth, maskHeight);
+ gfxcolor_t*newpic=new gfxcolor_t[maskWidth*maskHeight];
+ double dx = width / maskWidth;
+ double dy = height / maskHeight;
+ double yy = 0;
+ for(y = 0; y < maskHeight; y++) {
+ double xx = 0;
+ for (x = 0; x < maskWidth; x++) {
+ newpic[maskWidth*y+x] = pic[int(yy)*width+int(xx)];
+ newpic[maskWidth*y+x].a = maskbitmap[maskWidth*y+x];
+ xx += dx;
+ }
+ yy += dy;
+ }
+ delete[] pic;
+ pic = newpic;
+ width = maskWidth;
+ height = maskHeight;
+ }
+ }
drawimagelossless(device, pic, width, height, x1,y1,x2,y2,x3,y3,x4,y4);
- delete pic;
+ delete[] pic;
delete imgStr;
if(maskbitmap) free(maskbitmap);
return;
void addGlobalFont(const char*filename)
{
- fontfile_t f;
- memset(&f, 0, sizeof(fontfile_t));
- f.filename = filename;
- if(fontnum < sizeof(fonts)/sizeof(fonts[0])) {
- msg("<notice> Adding font \"%s\".", filename);
- fonts[fontnum++] = f;
+ fontfile_t* f = (fontfile_t*)malloc(sizeof(fontfile_t));
+ memset(f, 0, sizeof(fontfile_t));
+ f->filename = filename;
+ int len = strlen(filename);
+ char*r1 = strrchr(filename, '/');
+ char*r2 = strrchr(filename, '\\');
+ if(r2>r1)
+ r1 = r2;
+ if(r1) {
+ len = strlen(r1+1);
+ }
+ f->len = len;
+
+ msg("<notice> Adding font \"%s\".", filename);
+ if(global_fonts_next) {
+ global_fonts_next->next = f;
+ global_fonts_next = global_fonts_next->next;
} else {
- msg("<error> Too many external fonts. Not adding font file \"%s\".", filename);
+ global_fonts_next = global_fonts = f;
}
}
{
msg("<notice> Adding %s to language pack directories", dir);
- int l;
FILE*fi = 0;
char* config_file = (char*)malloc(strlen(dir) + 1 + sizeof("add-to-xpdfrc") + 1);
strcpy(config_file, dir);
}
closedir(dir);
#else
- msg("<warning> No dirent.h- unable to add font dir %s", dir);
+ msg("<warning> No dirent.h- unable to add font dir %s", dirname);
#endif
}
dbg("beginTransparencyGroup %.1f/%.1f/%.1f/%.1f %s isolated=%d knockout=%d forsoftmask=%d", bbox[0],bbox[1],bbox[2],bbox[3], colormodename, isolated, knockout, forSoftMask);
msg("<verbose> beginTransparencyGroup %.1f/%.1f/%.1f/%.1f %s isolated=%d knockout=%d forsoftmask=%d", bbox[0],bbox[1],bbox[2],bbox[3], colormodename, isolated, knockout, forSoftMask);
- states[statepos].createsoftmask |= forSoftMask;
+ //states[statepos].createsoftmask |= forSoftMask;
+ states[statepos].createsoftmask = forSoftMask;
states[statepos].transparencygroup = !forSoftMask;
states[statepos].isolated = isolated;
this->device = states[statepos].olddevice;
+ gfxresult_t*recording = r->finish(r);
if(states[statepos].createsoftmask) {
- states[statepos-1].softmaskrecording = r->finish(r);
+ states[statepos-1].softmaskrecording = recording;
} else {
- states[statepos-1].grouprecording = r->finish(r);
+ states[statepos-1].grouprecording = recording;
}
states[statepos].createsoftmask = 0;