diff --git a/src/extension/internal/pdfinput/pdf-parser.cpp b/src/extension/internal/pdfinput/pdf-parser.cpp
index 9233361b2ea2263121fa2b55bb10e98bc04bb6a2..118896fd30318d74881f4d97a1a273ee592bc1ed 100644 (file)
// constants
//------------------------------------------------------------------------
-// Max recursive depth for a function shading fill.
-#define functionMaxDepth 6
+// Default max delta allowed in any color component for a shading fill.
+#define defaultShadingColorDelta (dblToCol( 1 / 2.0 ))
-// Max delta allowed in any color component for a function shading fill.
-#define functionColorDelta (dblToCol(1 / 2.0))
-
-// Max number of splits along the t axis for an axial shading fill.
-#define axialMaxSplits 256
-
-// Max delta allowed in any color component for an axial shading fill.
-#define axialColorDelta (dblToCol(1 / 2.0))
-
-// Max number of splits along the t axis for a radial shading fill.
-#define radialMaxSplits 256
-
-// Max delta allowed in any color component for a radial shading fill.
-#define radialColorDelta (dblToCol(1 / 2.0))
-
-// Max recursive depth for a Gouraud triangle shading fill.
-#define gouraudMaxDepth 6
-
-// Max delta allowed in any color component for a Gouraud triangle
-// shading fill.
-#define gouraudColorDelta (dblToCol(1 / 2.0))
-
-// Max recursive depth for a patch mesh shading fill.
-#define patchMaxDepth 6
-
-// Max delta allowed in any color component for a patch mesh shading
-// fill.
-#define patchColorDelta (dblToCol(1 / 2.0))
+// Default max recursive depth for a shading fill.
+#define defaultShadingMaxDepth 6
// Max number of operators kept in the history list.
#define maxOperatorHistoryDepth 16
//------------------------------------------------------------------------
PdfParser::PdfParser(XRef *xrefA, Inkscape::Extension::Internal::SvgBuilder *builderA,
- int pageNum, int rotate, Dict *resDict, PDFRectangle *cropBox) {
+ int pageNum, int rotate, Dict *resDict,
+ PDFRectangle *box, PDFRectangle *cropBox) {
int i;
@@ -295,8 +270,9 @@ PdfParser::PdfParser(XRef *xrefA, Inkscape::Extension::Internal::SvgBuilder *bui
res = new GfxResources(xref, resDict, NULL);
// initialize
- state = new GfxState(72.0, 72.0, cropBox, rotate, gTrue);
+ state = new GfxState(72.0, 72.0, box, rotate, gTrue);
clipHistory = new ClipHistoryEntry();
+ setDefaultApproximationPrecision();
fontChanged = gFalse;
clip = clipNone;
ignoreUndef = 0;
@@ -354,6 +330,8 @@ PdfParser::PdfParser(XRef *xrefA, Inkscape::Extension::Internal::SvgBuilder *bui
builder = builderA;
state = new GfxState(72, 72, box, 0, gFalse);
clipHistory = new ClipHistoryEntry();
+ setDefaultApproximationPrecision();
+
fontChanged = gFalse;
clip = clipNone;
ignoreUndef = 0;
for (i = 0; i < obj->arrayGetLength(); ++i) {
obj->arrayGet(i, &obj2);
if (!obj2.isStream()) {
- error(-1, "Weird page contents");
+ error(-1, const_cast<char*>("Weird page contents"));
obj2.free();
return;
}
obj2.free();
}
} else if (!obj->isStream()) {
- error(-1, "Weird page contents");
+ error(-1, const_cast<char*>("Weird page contents"));
return;
}
parser = new Parser(xref, new Lexer(xref, obj), gFalse);
Object obj;
Object args[maxArgs];
int numArgs, i;
- int lastAbortCheck;
// scan a sequence of objects
numArgs = 0;
// too many arguments - something is wrong
} else {
- error(getPos(), "Too many args in content stream");
+ error(getPos(), const_cast<char*>("Too many args in content stream"));
if (printCommands) {
printf("throwing away arg: ");
obj.print(stdout);
// args at end with no command
if (numArgs > 0) {
- error(getPos(), "Leftover args in content stream");
+ error(getPos(), const_cast<char*>("Leftover args in content stream"));
if (printCommands) {
printf("%d leftovers:", numArgs);
for (i = 0; i < numArgs; ++i) {
name = cmd->getCmd();
if (!(op = findOp(name))) {
if (ignoreUndef == 0)
- error(getPos(), "Unknown operator '%s'", name);
+ error(getPos(), const_cast<char*>("Unknown operator '%s'"), name);
return;
}
argPtr = args;
if (op->numArgs >= 0) {
if (numArgs < op->numArgs) {
- error(getPos(), "Too few (%d) args to '%s' operator", numArgs, name);
+ error(getPos(), const_cast<char*>("Too few (%d) args to '%s' operator"), numArgs, name);
return;
}
if (numArgs > op->numArgs) {
}
} else {
if (numArgs > -op->numArgs) {
- error(getPos(), "Too many (%d) args to '%s' operator",
+ error(getPos(), const_cast<char*>("Too many (%d) args to '%s' operator"),
numArgs, name);
return;
}
}
for (i = 0; i < numArgs; ++i) {
if (!checkArg(&argPtr[i], op->tchk[i])) {
- error(getPos(), "Arg #%d to '%s' operator is wrong type (%s)",
+ error(getPos(), const_cast<char*>("Arg #%d to '%s' operator is wrong type (%s)"),
i, name, argPtr[i].getTypeName());
return;
}
} else if (!strcmp(prevOp, "cm") || !strcmp(prevOp, "startPage")) {
// multiply it with the previous transform
double otherMatrix[6];
- if (!builder->getTransform((double*)&otherMatrix)) { // invalid transform
+ if (!builder->getTransform(otherMatrix)) { // invalid transform
// construct identity matrix
otherMatrix[0] = otherMatrix[3] = 1.0;
otherMatrix[1] = otherMatrix[2] = otherMatrix[4] = otherMatrix[5] = 0.0;
return;
}
if (!obj1.isDict()) {
- error(getPos(), "ExtGState '%s' is wrong type", args[0].getName());
+ error(getPos(), const_cast<char*>("ExtGState '%s' is wrong type"), args[0].getName());
obj1.free();
return;
}
}
// transparency support: blend mode, fill/stroke opacity
- if (!obj1.dictLookup("BM", &obj2)->isNull()) {
+ if (!obj1.dictLookup(const_cast<char*>("BM"), &obj2)->isNull()) {
if (state->parseBlendMode(&obj2, &mode)) {
state->setBlendMode(mode);
} else {
- error(getPos(), "Invalid blend mode in ExtGState");
+ error(getPos(), const_cast<char*>("Invalid blend mode in ExtGState"));
}
}
obj2.free();
- if (obj1.dictLookup("ca", &obj2)->isNum()) {
+ if (obj1.dictLookup(const_cast<char*>("ca"), &obj2)->isNum()) {
state->setFillOpacity(obj2.getNum());
}
obj2.free();
- if (obj1.dictLookup("CA", &obj2)->isNum()) {
+ if (obj1.dictLookup(const_cast<char*>("CA"), &obj2)->isNum()) {
state->setStrokeOpacity(obj2.getNum());
}
obj2.free();
// fill/stroke overprint
- if ((haveFillOP = (obj1.dictLookup("op", &obj2)->isBool()))) {
+ if ((haveFillOP = (obj1.dictLookup(const_cast<char*>("op"), &obj2)->isBool()))) {
state->setFillOverprint(obj2.getBool());
}
obj2.free();
- if (obj1.dictLookup("OP", &obj2)->isBool()) {
+ if (obj1.dictLookup(const_cast<char*>("OP"), &obj2)->isBool()) {
state->setStrokeOverprint(obj2.getBool());
if (!haveFillOP) {
state->setFillOverprint(obj2.getBool());
obj2.free();
// stroke adjust
- if (obj1.dictLookup("SA", &obj2)->isBool()) {
+ if (obj1.dictLookup(const_cast<char*>("SA"), &obj2)->isBool()) {
state->setStrokeAdjust(obj2.getBool());
}
obj2.free();
// transfer function
- if (obj1.dictLookup("TR2", &obj2)->isNull()) {
+ if (obj1.dictLookup(const_cast<char*>("TR2"), &obj2)->isNull()) {
obj2.free();
- obj1.dictLookup("TR", &obj2);
+ obj1.dictLookup(const_cast<char*>("TR"), &obj2);
}
- if (obj2.isName("Default") ||
- obj2.isName("Identity")) {
+ if (obj2.isName(const_cast<char*>("Default")) ||
+ obj2.isName(const_cast<char*>("Identity"))) {
funcs[0] = funcs[1] = funcs[2] = funcs[3] = NULL;
state->setTransfer(funcs);
} else if (obj2.isArray() && obj2.arrayGetLength() == 4) {
state->setTransfer(funcs);
}
} else if (!obj2.isNull()) {
- error(getPos(), "Invalid transfer function in ExtGState");
+ error(getPos(), const_cast<char*>("Invalid transfer function in ExtGState"));
}
obj2.free();
// soft mask
- if (!obj1.dictLookup("SMask", &obj2)->isNull()) {
- if (obj2.isName("None")) {
+ if (!obj1.dictLookup(const_cast<char*>("SMask"), &obj2)->isNull()) {
+ if (obj2.isName(const_cast<char*>("None"))) {
builder->clearSoftMask(state);
} else if (obj2.isDict()) {
- if (obj2.dictLookup("S", &obj3)->isName("Alpha")) {
+ if (obj2.dictLookup(const_cast<char*>("S"), &obj3)->isName(const_cast<char*>("Alpha"))) {
alpha = gTrue;
} else { // "Luminosity"
alpha = gFalse;
}
obj3.free();
funcs[0] = NULL;
- if (!obj2.dictLookup("TR", &obj3)->isNull()) {
+ if (!obj2.dictLookup(const_cast<char*>("TR"), &obj3)->isNull()) {
funcs[0] = Function::parse(&obj3);
if (funcs[0]->getInputSize() != 1 ||
funcs[0]->getOutputSize() != 1) {
error(getPos(),
- "Invalid transfer function in soft mask in ExtGState");
+ const_cast<char*>("Invalid transfer function in soft mask in ExtGState"));
delete funcs[0];
funcs[0] = NULL;
}
}
obj3.free();
- if ((haveBackdropColor = obj2.dictLookup("BC", &obj3)->isArray())) {
+ if ((haveBackdropColor = obj2.dictLookup(const_cast<char*>("BC"), &obj3)->isArray())) {
for (i = 0; i < gfxColorMaxComps; ++i) {
backdropColor.c[i] = 0;
}
}
}
obj3.free();
- if (obj2.dictLookup("G", &obj3)->isStream()) {
- if (obj3.streamGetDict()->lookup("Group", &obj4)->isDict()) {
+ if (obj2.dictLookup(const_cast<char*>("G"), &obj3)->isStream()) {
+ if (obj3.streamGetDict()->lookup(const_cast<char*>("Group"), &obj4)->isDict()) {
blendingColorSpace = NULL;
isolated = knockout = gFalse;
- if (!obj4.dictLookup("CS", &obj5)->isNull()) {
+ if (!obj4.dictLookup(const_cast<char*>("CS"), &obj5)->isNull()) {
blendingColorSpace = GfxColorSpace::parse(&obj5);
}
obj5.free();
- if (obj4.dictLookup("I", &obj5)->isBool()) {
+ if (obj4.dictLookup(const_cast<char*>("I"), &obj5)->isBool()) {
isolated = obj5.getBool();
}
obj5.free();
- if (obj4.dictLookup("K", &obj5)->isBool()) {
+ if (obj4.dictLookup(const_cast<char*>("K"), &obj5)->isBool()) {
knockout = obj5.getBool();
}
obj5.free();
delete funcs[0];
}
} else {
- error(getPos(), "Invalid soft mask in ExtGState - missing group");
+ error(getPos(), const_cast<char*>("Invalid soft mask in ExtGState - missing group"));
}
obj4.free();
} else {
- error(getPos(), "Invalid soft mask in ExtGState - missing group");
+ error(getPos(), const_cast<char*>("Invalid soft mask in ExtGState - missing group"));
}
obj3.free();
} else if (!obj2.isNull()) {
- error(getPos(), "Invalid soft mask in ExtGState");
+ error(getPos(), const_cast<char*>("Invalid soft mask in ExtGState"));
}
}
obj2.free();
dict = str->streamGetDict();
// check form type
- dict->lookup("FormType", &obj1);
+ dict->lookup(const_cast<char*>("FormType"), &obj1);
if (!(obj1.isNull() || (obj1.isInt() && obj1.getInt() == 1))) {
- error(getPos(), "Unknown form type");
+ error(getPos(), const_cast<char*>("Unknown form type"));
}
obj1.free();
// get bounding box
- dict->lookup("BBox", &obj1);
+ dict->lookup(const_cast<char*>("BBox"), &obj1);
if (!obj1.isArray()) {
obj1.free();
- error(getPos(), "Bad form bounding box");
+ error(getPos(), const_cast<char*>("Bad form bounding box"));
return;
}
for (i = 0; i < 4; ++i) {
obj1.free();
// get matrix
- dict->lookup("Matrix", &obj1);
+ dict->lookup(const_cast<char*>("Matrix"), &obj1);
if (obj1.isArray()) {
for (i = 0; i < 6; ++i) {
obj1.arrayGet(i, &obj2);
obj1.free();
// get resources
- dict->lookup("Resources", &obj1);
+ dict->lookup(const_cast<char*>("Resources"), &obj1);
resDict = obj1.isDict() ? obj1.getDict() : (Dict *)NULL;
// draw it
state->setFillColor(&color);
builder->updateStyle(state);
} else {
- error(getPos(), "Bad color space (fill)");
+ error(getPos(), const_cast<char*>("Bad color space (fill)"));
}
}
state->setStrokeColor(&color);
builder->updateStyle(state);
} else {
- error(getPos(), "Bad color space (stroke)");
+ error(getPos(), const_cast<char*>("Bad color space (stroke)"));
}
}
int i;
if (numArgs != state->getFillColorSpace()->getNComps()) {
- error(getPos(), "Incorrect number of arguments in 'sc' command");
+ error(getPos(), const_cast<char*>("Incorrect number of arguments in 'sc' command"));
return;
}
state->setFillPattern(NULL);
int i;
if (numArgs != state->getStrokeColorSpace()->getNComps()) {
- error(getPos(), "Incorrect number of arguments in 'SC' command");
+ error(getPos(), const_cast<char*>("Incorrect number of arguments in 'SC' command"));
return;
}
state->setStrokePattern(NULL);
if (!((GfxPatternColorSpace *)state->getFillColorSpace())->getUnder() ||
numArgs - 1 != ((GfxPatternColorSpace *)state->getFillColorSpace())
->getUnder()->getNComps()) {
- error(getPos(), "Incorrect number of arguments in 'scn' command");
+ error(getPos(), const_cast<char*>("Incorrect number of arguments in 'scn' command"));
return;
}
for (i = 0; i < numArgs - 1 && i < gfxColorMaxComps; ++i) {
if (args[numArgs-1].isName() &&
(pattern = res->lookupPattern(args[numArgs-1].getName()))) {
state->setFillPattern(pattern);
+ builder->updateStyle(state);
}
} else {
if (numArgs != state->getFillColorSpace()->getNComps()) {
- error(getPos(), "Incorrect number of arguments in 'scn' command");
+ error(getPos(), const_cast<char*>("Incorrect number of arguments in 'scn' command"));
return;
}
state->setFillPattern(NULL);
->getUnder() ||
numArgs - 1 != ((GfxPatternColorSpace *)state->getStrokeColorSpace())
->getUnder()->getNComps()) {
- error(getPos(), "Incorrect number of arguments in 'SCN' command");
+ error(getPos(), const_cast<char*>("Incorrect number of arguments in 'SCN' command"));
return;
}
for (i = 0; i < numArgs - 1 && i < gfxColorMaxComps; ++i) {
if (args[numArgs-1].isName() &&
(pattern = res->lookupPattern(args[numArgs-1].getName()))) {
state->setStrokePattern(pattern);
+ builder->updateStyle(state);
}
} else {
if (numArgs != state->getStrokeColorSpace()->getNComps()) {
- error(getPos(), "Incorrect number of arguments in 'SCN' command");
+ error(getPos(), const_cast<char*>("Incorrect number of arguments in 'SCN' command"));
return;
}
state->setStrokePattern(NULL);
void PdfParser::opLineTo(Object args[], int numArgs) {
if (!state->isCurPt()) {
- error(getPos(), "No current point in lineto");
+ error(getPos(), const_cast<char*>("No current point in lineto"));
return;
}
state->lineTo(args[0].getNum(), args[1].getNum());
double x1, y1, x2, y2, x3, y3;
if (!state->isCurPt()) {
- error(getPos(), "No current point in curveto");
+ error(getPos(), const_cast<char*>("No current point in curveto"));
return;
}
x1 = args[0].getNum();
double x1, y1, x2, y2, x3, y3;
if (!state->isCurPt()) {
- error(getPos(), "No current point in curveto1");
+ error(getPos(), const_cast<char*>("No current point in curveto1"));
return;
}
x1 = state->getCurX();
double x1, y1, x2, y2, x3, y3;
if (!state->isCurPt()) {
- error(getPos(), "No current point in curveto2");
+ error(getPos(), const_cast<char*>("No current point in curveto2"));
return;
}
x1 = args[0].getNum();
void PdfParser::opClosePath(Object args[], int numArgs) {
if (!state->isCurPt()) {
- error(getPos(), "No current point in closepath");
+ error(getPos(), const_cast<char*>("No current point in closepath"));
return;
}
state->closePath();
void PdfParser::opStroke(Object args[], int numArgs) {
if (!state->isCurPt()) {
- //error(getPos(), "No path in stroke");
+ //error(getPos(), const_cast<char*>("No path in stroke"));
return;
}
if (state->isPath()) {
void PdfParser::opCloseStroke(Object * /*args[]*/, int /*numArgs*/) {
if (!state->isCurPt()) {
- //error(getPos(), "No path in closepath/stroke");
+ //error(getPos(), const_cast<char*>("No path in closepath/stroke"));
return;
}
state->closePath();
void PdfParser::opFill(Object args[], int numArgs) {
if (!state->isCurPt()) {
- //error(getPos(), "No path in fill");
+ //error(getPos(), const_cast<char*>("No path in fill"));
return;
}
if (state->isPath()) {
void PdfParser::opEOFill(Object args[], int numArgs) {
if (!state->isCurPt()) {
- //error(getPos(), "No path in eofill");
+ //error(getPos(), const_cast<char*>("No path in eofill"));
return;
}
if (state->isPath()) {
void PdfParser::opFillStroke(Object args[], int numArgs) {
if (!state->isCurPt()) {
- //error(getPos(), "No path in fill/stroke");
+ //error(getPos(), const_cast<char*>("No path in fill/stroke"));
return;
}
if (state->isPath()) {
void PdfParser::opCloseFillStroke(Object args[], int numArgs) {
if (!state->isCurPt()) {
- //error(getPos(), "No path in closepath/fill/stroke");
+ //error(getPos(), const_cast<char*>("No path in closepath/fill/stroke"));
return;
}
if (state->isPath()) {
void PdfParser::opEOFillStroke(Object args[], int numArgs) {
if (!state->isCurPt()) {
- //error(getPos(), "No path in eofill/stroke");
+ //error(getPos(), const_cast<char*>("No path in eofill/stroke"));
return;
}
if (state->isPath()) {
void PdfParser::opCloseEOFillStroke(Object args[], int numArgs) {
if (!state->isCurPt()) {
- //error(getPos(), "No path in closepath/eofill/stroke");
+ //error(getPos(), const_cast<char*>("No path in closepath/eofill/stroke"));
return;
}
if (state->isPath()) {
doShadingPatternFillFallback((GfxShadingPattern *)pattern, gFalse, eoFill);
break;
default:
- error(getPos(), "Unimplemented pattern type (%d) in fill",
+ error(getPos(), const_cast<char*>("Unimplemented pattern type (%d) in fill"),
pattern->getType());
break;
}
doShadingPatternFillFallback((GfxShadingPattern *)pattern, gTrue, gFalse);
break;
default:
- error(getPos(), "Unimplemented pattern type (%d) in stroke",
+ error(getPos(), const_cast<char*>("Unimplemented pattern type (%d) in stroke"),
pattern->getType());
break;
}
} else {
state->clip();
if (eoFill) {
- builder->clip(state, true);
+ builder->setClipPath(state, true);
} else {
- builder->clip(state);
+ builder->setClipPath(state);
}
}
void PdfParser::opShFill(Object args[], int numArgs) {
GfxShading *shading;
- GfxPath *savedPath;
+ GfxPath *savedPath = NULL;
double xMin, yMin, xMax, yMax;
double gradientTransform[6];
double *matrix = NULL;
}
if (seenConcat && seenClip) {
- if (builder->getTransform((double*)&gradientTransform)) {
+ if (builder->getTransform(gradientTransform)) {
matrix = (double*)&gradientTransform;
builder->setTransform(1.0, 0.0, 0.0, 1.0, 0.0, 0.0); // remove transform
}
GfxColor fillColor;
GfxColor color0M, color1M, colorM0, colorM1, colorMM;
GfxColor colors2[4];
+ double functionColorDelta = colorDeltas[pdfFunctionShading-1];
double *matrix;
double xM, yM;
int nComps, i, j;
// -- fill the rectangle; but require at least one subdivision
// (depth==0) to avoid problems when the four outer corners of the
// shaded region are the same color
- if ((i == 4 && depth > 0) || depth == functionMaxDepth) {
+ if ((i == 4 && depth > 0) || depth == maxDepths[pdfFunctionShading-1]) {
// use the center color
shading->getColor(xM, yM, &fillColor);
double x2, double y2, GfxColor *color2,
int nComps, int depth) {
double x01, y01, x12, y12, x20, y20;
+ double gouraudColorDelta = colorDeltas[pdfGouraudTriangleShading-1];
GfxColor color01, color12, color20;
int i;
for (i = 0; i < nComps; ++i) {
if (abs(color0->c[i] - color1->c[i]) > gouraudColorDelta ||
- abs(color1->c[i] - color2->c[i]) > gouraudColorDelta) {
+ abs(color1->c[i] - color2->c[i]) > gouraudColorDelta) {
break;
}
}
- if (i == nComps || depth == gouraudMaxDepth) {
+ if (i == nComps || depth == maxDepths[pdfGouraudTriangleShading-1]) {
state->setFillColor(color0);
state->moveTo(x0, y0);
state->lineTo(x1, y1);
GfxPatch patch00, patch01, patch10, patch11;
double xx[4][8], yy[4][8];
double xxm, yym;
+ double patchColorDelta = colorDeltas[pdfPatchMeshShading-1];
int i;
for (i = 0; i < nComps; ++i) {
break;
}
}
- if (i == nComps || depth == patchMaxDepth) {
+ if (i == nComps || depth == maxDepths[pdfPatchMeshShading-1]) {
state->setFillColor(&patch->color[0][0]);
state->moveTo(patch->x[0][0], patch->y[0][0]);
state->curveTo(patch->x[0][1], patch->y[0][1],
GfxFont *font;
if (!(font = res->lookupFont(args[0].getName()))) {
+ // unsetting the font (drawing no text) is better than using the
+ // previous one and drawing random glyphs from it
+ state->setFont(NULL, args[1].getNum());
+ fontChanged = gTrue;
return;
}
if (printCommands) {
void PdfParser::opShowText(Object args[], int numArgs) {
if (!state->getFont()) {
- error(getPos(), "No font in show");
+ error(getPos(), const_cast<char*>("No font in show"));
return;
}
if (fontChanged) {
double tx, ty;
if (!state->getFont()) {
- error(getPos(), "No font in move/show");
+ error(getPos(), const_cast<char*>("No font in move/show"));
return;
}
if (fontChanged) {
double tx, ty;
if (!state->getFont()) {
- error(getPos(), "No font in move/set/show");
+ error(getPos(), const_cast<char*>("No font in move/set/show"));
return;
}
if (fontChanged) {
int i;
if (!state->getFont()) {
- error(getPos(), "No font in show/space");
+ error(getPos(), const_cast<char*>("No font in show/space"));
return;
}
if (fontChanged) {
} else if (obj.isString()) {
doShowText(obj.getString());
} else {
- error(getPos(), "Element of show/space array must be number or string");
+ error(getPos(), const_cast<char*>("Element of show/space array must be number or string"));
}
obj.free();
}
}
+
+
+/*
+ * The `POPPLER_NEW_GFXFONT' stuff is for the change to GfxFont's getNextChar() call.
+ * Thanks to tsdgeos for the fix.
+ * Miklos, does this look ok?
+ */
+
void PdfParser::doShowText(GooString *s) {
GfxFont *font;
int wMode;
double riseX, riseY;
CharCode code;
+#ifdef POPPLER_NEW_GFXFONT
+ Unicode *u = NULL;
+#else
Unicode u[8];
- double x, y, dx, dy, dx2, dy2, curX, curY, tdx, tdy, lineX, lineY;
+#endif
+ double x, y, dx, dy, curX, curY, tdx, tdy, lineX, lineY;
double originX, originY, tOriginX, tOriginY;
double oldCTM[6], newCTM[6];
double *mat;
Dict *resDict;
Parser *oldParser;
char *p;
- int len, n, uLen, nChars, nSpaces, i;
+ int len, n, uLen, i;
font = state->getFont();
wMode = font->getWMode();
len = s->getLength();
while (len > 0) {
n = font->getNextChar(p, len, &code,
+#ifdef POPPLER_NEW_GFXFONT
+ &u, &uLen, /* TODO: This looks like a memory leak for u. */
+#else
u, (int)(sizeof(u) / sizeof(Unicode)), &uLen,
+#endif
&dx, &dy, &originX, &originY);
dx = dx * state->getFontSize() + state->getCharSpace();
if (n == 1 && *p == ' ') {
if (charProc.isStream()) {
//parse(&charProc, gFalse); // TODO: parse into SVG font
} else {
- error(getPos(), "Missing or bad Type3 CharProc entry");
+ error(getPos(), const_cast<char*>("Missing or bad Type3 CharProc entry"));
}
//out->endType3Char(state);
if (resDict) {
len = s->getLength();
while (len > 0) {
n = font->getNextChar(p, len, &code,
+#ifdef POPPLER_NEW_GFXFONT
+ &u, &uLen, /* TODO: This looks like a memory leak for u. */
+#else
u, (int)(sizeof(u) / sizeof(Unicode)), &uLen,
+#endif
&dx, &dy, &originX, &originY);
if (wMode) {
builder->endString(state);
}
+
//------------------------------------------------------------------------
// XObject operators
//------------------------------------------------------------------------
return;
}
if (!obj1.isStream()) {
- error(getPos(), "XObject '%s' is wrong type", name);
+ error(getPos(), const_cast<char*>("XObject '%s' is wrong type"), name);
obj1.free();
return;
}
- obj1.streamGetDict()->lookup("Subtype", &obj2);
- if (obj2.isName("Image")) {
+ obj1.streamGetDict()->lookup(const_cast<char*>("Subtype"), &obj2);
+ if (obj2.isName(const_cast<char*>("Image"))) {
res->lookupXObjectNF(name, &refObj);
doImage(&refObj, obj1.getStream(), gFalse);
refObj.free();
- } else if (obj2.isName("Form")) {
+ } else if (obj2.isName(const_cast<char*>("Form"))) {
doForm(&obj1);
- } else if (obj2.isName("PS")) {
- obj1.streamGetDict()->lookup("Level1", &obj3);
+ } else if (obj2.isName(const_cast<char*>("PS"))) {
+ obj1.streamGetDict()->lookup(const_cast<char*>("Level1"), &obj3);
/* out->psXObject(obj1.getStream(),
obj3.isStream() ? obj3.getStream() : (Stream *)NULL);*/
} else if (obj2.isName()) {
- error(getPos(), "Unknown XObject subtype '%s'", obj2.getName());
+ error(getPos(), const_cast<char*>("Unknown XObject subtype '%s'"), obj2.getName());
} else {
- error(getPos(), "XObject subtype is missing or wrong type");
+ error(getPos(), const_cast<char*>("XObject subtype is missing or wrong type"));
}
obj2.free();
obj1.free();
dict = str->getDict();
// get size
- dict->lookup("Width", &obj1);
+ dict->lookup(const_cast<char*>("Width"), &obj1);
if (obj1.isNull()) {
obj1.free();
- dict->lookup("W", &obj1);
+ dict->lookup(const_cast<char*>("W"), &obj1);
}
if (obj1.isInt())
width = obj1.getInt();
else
goto err2;
obj1.free();
- dict->lookup("Height", &obj1);
+ dict->lookup(const_cast<char*>("Height"), &obj1);
if (obj1.isNull()) {
obj1.free();
- dict->lookup("H", &obj1);
+ dict->lookup(const_cast<char*>("H"), &obj1);
}
if (obj1.isInt())
height = obj1.getInt();
obj1.free();
// image or mask?
- dict->lookup("ImageMask", &obj1);
+ dict->lookup(const_cast<char*>("ImageMask"), &obj1);
if (obj1.isNull()) {
obj1.free();
- dict->lookup("IM", &obj1);
+ dict->lookup(const_cast<char*>("IM"), &obj1);
}
mask = gFalse;
if (obj1.isBool())
// bit depth
if (bits == 0) {
- dict->lookup("BitsPerComponent", &obj1);
+ dict->lookup(const_cast<char*>("BitsPerComponent"), &obj1);
if (obj1.isNull()) {
obj1.free();
- dict->lookup("BPC", &obj1);
+ dict->lookup(const_cast<char*>("BPC"), &obj1);
}
if (obj1.isInt()) {
bits = obj1.getInt();
if (bits != 1)
goto err1;
invert = gFalse;
- dict->lookup("Decode", &obj1);
+ dict->lookup(const_cast<char*>("Decode"), &obj1);
if (obj1.isNull()) {
obj1.free();
- dict->lookup("D", &obj1);
+ dict->lookup(const_cast<char*>("D"), &obj1);
}
if (obj1.isArray()) {
obj1.arrayGet(0, &obj2);
} else {
// get color space and color map
- dict->lookup("ColorSpace", &obj1);
+ dict->lookup(const_cast<char*>("ColorSpace"), &obj1);
if (obj1.isNull()) {
obj1.free();
- dict->lookup("CS", &obj1);
+ dict->lookup(const_cast<char*>("CS"), &obj1);
}
if (obj1.isName()) {
res->lookupColorSpace(obj1.getName(), &obj2);
if (!colorSpace) {
goto err1;
}
- dict->lookup("Decode", &obj1);
+ dict->lookup(const_cast<char*>("Decode"), &obj1);
if (obj1.isNull()) {
obj1.free();
- dict->lookup("D", &obj1);
+ dict->lookup(const_cast<char*>("D"), &obj1);
}
colorMap = new GfxImageColorMap(bits, &obj1, colorSpace);
obj1.free();
maskWidth = maskHeight = 0; // make gcc happy
maskInvert = gFalse; // make gcc happy
maskColorMap = NULL; // make gcc happy
- dict->lookup("Mask", &maskObj);
- dict->lookup("SMask", &smaskObj);
+ dict->lookup(const_cast<char*>("Mask"), &maskObj);
+ dict->lookup(const_cast<char*>("SMask"), &smaskObj);
if (smaskObj.isStream()) {
// soft mask
if (inlineImg) {
}
maskStr = smaskObj.getStream();
maskDict = smaskObj.streamGetDict();
- maskDict->lookup("Width", &obj1);
+ maskDict->lookup(const_cast<char*>("Width"), &obj1);
if (obj1.isNull()) {
obj1.free();
- maskDict->lookup("W", &obj1);
+ maskDict->lookup(const_cast<char*>("W"), &obj1);
}
if (!obj1.isInt()) {
goto err2;
}
maskWidth = obj1.getInt();
obj1.free();
- maskDict->lookup("Height", &obj1);
+ maskDict->lookup(const_cast<char*>("Height"), &obj1);
if (obj1.isNull()) {
obj1.free();
- maskDict->lookup("H", &obj1);
+ maskDict->lookup(const_cast<char*>("H"), &obj1);
}
if (!obj1.isInt()) {
goto err2;
}
maskHeight = obj1.getInt();
obj1.free();
- maskDict->lookup("BitsPerComponent", &obj1);
+ maskDict->lookup(const_cast<char*>("BitsPerComponent"), &obj1);
if (obj1.isNull()) {
obj1.free();
- maskDict->lookup("BPC", &obj1);
+ maskDict->lookup(const_cast<char*>("BPC"), &obj1);
}
if (!obj1.isInt()) {
goto err2;
}
maskBits = obj1.getInt();
obj1.free();
- maskDict->lookup("ColorSpace", &obj1);
+ maskDict->lookup(const_cast<char*>("ColorSpace"), &obj1);
if (obj1.isNull()) {
obj1.free();
- maskDict->lookup("CS", &obj1);
+ maskDict->lookup(const_cast<char*>("CS"), &obj1);
}
if (obj1.isName()) {
res->lookupColorSpace(obj1.getName(), &obj2);
if (!maskColorSpace || maskColorSpace->getMode() != csDeviceGray) {
goto err1;
}
- maskDict->lookup("Decode", &obj1);
+ maskDict->lookup(const_cast<char*>("Decode"), &obj1);
if (obj1.isNull()) {
obj1.free();
- maskDict->lookup("D", &obj1);
+ maskDict->lookup(const_cast<char*>("D"), &obj1);
}
maskColorMap = new GfxImageColorMap(maskBits, &obj1, maskColorSpace);
obj1.free();
}
maskStr = maskObj.getStream();
maskDict = maskObj.streamGetDict();
- maskDict->lookup("Width", &obj1);
+ maskDict->lookup(const_cast<char*>("Width"), &obj1);
if (obj1.isNull()) {
obj1.free();
- maskDict->lookup("W", &obj1);
+ maskDict->lookup(const_cast<char*>("W"), &obj1);
}
if (!obj1.isInt()) {
goto err2;
}
maskWidth = obj1.getInt();
obj1.free();
- maskDict->lookup("Height", &obj1);
+ maskDict->lookup(const_cast<char*>("Height"), &obj1);
if (obj1.isNull()) {
obj1.free();
- maskDict->lookup("H", &obj1);
+ maskDict->lookup(const_cast<char*>("H"), &obj1);
}
if (!obj1.isInt()) {
goto err2;
}
maskHeight = obj1.getInt();
obj1.free();
- maskDict->lookup("ImageMask", &obj1);
+ maskDict->lookup(const_cast<char*>("ImageMask"), &obj1);
if (obj1.isNull()) {
obj1.free();
- maskDict->lookup("IM", &obj1);
+ maskDict->lookup(const_cast<char*>("IM"), &obj1);
}
if (!obj1.isBool() || !obj1.getBool()) {
goto err2;
}
obj1.free();
maskInvert = gFalse;
- maskDict->lookup("Decode", &obj1);
+ maskDict->lookup(const_cast<char*>("Decode"), &obj1);
if (obj1.isNull()) {
obj1.free();
- maskDict->lookup("D", &obj1);
+ maskDict->lookup(const_cast<char*>("D"), &obj1);
}
if (obj1.isArray()) {
obj1.arrayGet(0, &obj2);
err2:
obj1.free();
err1:
- error(getPos(), "Bad image parameters");
+ error(getPos(), const_cast<char*>("Bad image parameters"));
}
void PdfParser::doForm(Object *str) {
dict = str->streamGetDict();
// check form type
- dict->lookup("FormType", &obj1);
+ dict->lookup(const_cast<char*>("FormType"), &obj1);
if (!(obj1.isNull() || (obj1.isInt() && obj1.getInt() == 1))) {
- error(getPos(), "Unknown form type");
+ error(getPos(), const_cast<char*>("Unknown form type"));
}
obj1.free();
// get bounding box
- dict->lookup("BBox", &bboxObj);
+ dict->lookup(const_cast<char*>("BBox"), &bboxObj);
if (!bboxObj.isArray()) {
bboxObj.free();
- error(getPos(), "Bad form bounding box");
+ error(getPos(), const_cast<char*>("Bad form bounding box"));
return;
}
for (i = 0; i < 4; ++i) {
bboxObj.free();
// get matrix
- dict->lookup("Matrix", &matrixObj);
+ dict->lookup(const_cast<char*>("Matrix"), &matrixObj);
if (matrixObj.isArray()) {
for (i = 0; i < 6; ++i) {
matrixObj.arrayGet(i, &obj1);
matrixObj.free();
// get resources
- dict->lookup("Resources", &resObj);
+ dict->lookup(const_cast<char*>("Resources"), &resObj);
resDict = resObj.isDict() ? resObj.getDict() : (Dict *)NULL;
// check for a transparency group
transpGroup = isolated = knockout = gFalse;
blendingColorSpace = NULL;
- if (dict->lookup("Group", &obj1)->isDict()) {
- if (obj1.dictLookup("S", &obj2)->isName("Transparency")) {
+ if (dict->lookup(const_cast<char*>("Group"), &obj1)->isDict()) {
+ if (obj1.dictLookup(const_cast<char*>("S"), &obj2)->isName(const_cast<char*>("Transparency"))) {
transpGroup = gTrue;
- if (!obj1.dictLookup("CS", &obj3)->isNull()) {
+ if (!obj1.dictLookup(const_cast<char*>("CS"), &obj3)->isNull()) {
blendingColorSpace = GfxColorSpace::parse(&obj3);
}
obj3.free();
- if (obj1.dictLookup("I", &obj3)->isBool()) {
+ if (obj1.dictLookup(const_cast<char*>("I"), &obj3)->isBool()) {
isolated = obj3.getBool();
}
obj3.free();
- if (obj1.dictLookup("K", &obj3)->isBool()) {
+ if (obj1.dictLookup(const_cast<char*>("K"), &obj3)->isBool()) {
knockout = obj3.getBool();
}
obj3.free();
// build dictionary
dict.initDict(xref);
parser->getObj(&obj);
- while (!obj.isCmd("ID") && !obj.isEOF()) {
+ while (!obj.isCmd(const_cast<char*>("ID")) && !obj.isEOF()) {
if (!obj.isName()) {
- error(getPos(), "Inline image dictionary key must be a name object");
+ error(getPos(), const_cast<char*>("Inline image dictionary key must be a name object"));
obj.free();
} else {
key = copyString(obj.getName());
parser->getObj(&obj);
}
if (obj.isEOF()) {
- error(getPos(), "End of file in inline image");
+ error(getPos(), const_cast<char*>("End of file in inline image"));
obj.free();
dict.free();
return NULL;
}
void PdfParser::opImageData(Object args[], int numArgs) {
- error(getPos(), "Internal: got 'ID' operator");
+ error(getPos(), const_cast<char*>("Internal: got 'ID' operator"));
}
void PdfParser::opEndImage(Object args[], int numArgs) {
- error(getPos(), "Internal: got 'EI' operator");
+ error(getPos(), const_cast<char*>("Internal: got 'EI' operator"));
}
//------------------------------------------------------------------------
res = resPtr;
}
+void PdfParser::setDefaultApproximationPrecision() {
+ int i;
+
+ for (i = 1; i <= pdfNumShadingTypes; ++i) {
+ setApproximationPrecision(i, defaultShadingColorDelta, defaultShadingMaxDepth);
+ }
+}
+
+void PdfParser::setApproximationPrecision(int shadingType, double colorDelta,
+ int maxDepth) {
+
+ if (shadingType > pdfNumShadingTypes || shadingType < 1) {
+ return;
+ }
+ colorDeltas[shadingType-1] = dblToCol(colorDelta);
+ maxDepths[shadingType-1] = maxDepth;
+}
+
//------------------------------------------------------------------------
// ClipHistoryEntry
//------------------------------------------------------------------------