![[tokkee]](http://tokkee.org/images/avatar.png){kind=avatar}
summary | shortlog | log | commit | commitdiff | tree
raw | patch | inline | side by side (parent: c6c387a)
raw | patch | inline | side by side (parent: c6c387a)
| author | miklosh <miklosh@users.sourceforge.net> | |
| Sat, 21 Jul 2007 17:59:49 +0000 (17:59 +0000) | ||
| committer | miklosh <miklosh@users.sourceforge.net> | |
| Sat, 21 Jul 2007 17:59:49 +0000 (17:59 +0000) |
adjustments.
diff --git a/src/extension/internal/pdfinput/pdf-input.cpp b/src/extension/internal/pdfinput/pdf-input.cpp
index b9e616025c95a54e2c48f91bee764996a9931032..db401731f1d975322ec36aced5ca2a0250144bbb 100644 (file)
// Initialize the globalParams variable for poppler
if (!globalParams) {
globalParams = new GlobalParams();
- g_message("Created globalParams");
}
GooString *filename_goo = new GooString(uri);
PDFDoc *pdf_doc = new PDFDoc(filename_goo, NULL, NULL, NULL); // TODO: Could ask for password
Catalog *catalog = pdf_doc->getCatalog();
Page *page = catalog->getPage(page_num);
- double width, height;
- int rotate = page->getRotate();
- if (rotate == 90 || rotate == 270) {
- width = page->getCropHeight();
- height = page->getCropWidth();
- } else {
- width = page->getCropWidth();
- height = page->getCropHeight();
- }
-
SPDocument *doc = sp_document_new(NULL, TRUE, TRUE);
bool saved = sp_document_get_undo_sensitive(doc);
sp_document_set_undo_sensitive(doc, false); // No need to undo in this temporary document
// Create builder and parser
SvgBuilder *builder = new SvgBuilder(doc);
- PdfParser *pdf_parser = new PdfParser(pdf_doc->getXRef(), builder, page_num-1,
+ PdfParser *pdf_parser = new PdfParser(pdf_doc->getXRef(), builder, page_num-1, page->getRotate(),
page->getResourceDict(), page->getCropBox());
// Parse the document structure
obj.free();
delete pdf_parser;
delete builder;
+ delete pdf_doc;
// Restore undo
sp_document_set_undo_sensitive(doc, saved);
diff --git a/src/extension/internal/pdfinput/pdf-parser.cpp b/src/extension/internal/pdfinput/pdf-parser.cpp
index b8804ac00b0a69e18aa92e78447450b5d7e165d7..c64f5de06fe3b4fbfda037c531dd2d0b773b0957 100644 (file)
#define patchColorDelta (dblToCol(1 / 256.0))
// Max number of operators kept in the history list.
-#define maxOperatorHistoryDepth 5
+#define maxOperatorHistoryDepth 16
//------------------------------------------------------------------------
// Operator table
//------------------------------------------------------------------------
PdfParser::PdfParser(XRef *xrefA, Inkscape::Extension::Internal::SvgBuilder *builderA,
- int pageNum, Dict *resDict, PDFRectangle *cropBox,
- GBool (*abortCheckCbkA)(void *data),
- void *abortCheckCbkDataA) {
+ int pageNum, int rotate, Dict *resDict, PDFRectangle *cropBox) {
+
int i;
xref = xrefA;
@@ -296,7 +295,7 @@ PdfParser::PdfParser(XRef *xrefA, Inkscape::Extension::Internal::SvgBuilder *bui
res = new GfxResources(xref, resDict, NULL);
// initialize
- state = new GfxState(72.0, 72.0, cropBox, 0, gFalse);
+ state = new GfxState(72.0, 72.0, cropBox, rotate, gTrue);
fontChanged = gFalse;
clip = clipNone;
ignoreUndef = 0;
@@ -304,16 +303,15 @@ PdfParser::PdfParser(XRef *xrefA, Inkscape::Extension::Internal::SvgBuilder *bui
builder = builderA;
builder->setDocumentSize(state->getPageWidth()*PX_PER_PT,
state->getPageHeight()*PX_PER_PT);
-
+
+ double *ctm = state->getCTM();
+ double scaledCTM[6];
for (i = 0; i < 6; ++i) {
- baseMatrix[i] = state->getCTM()[i];
+ baseMatrix[i] = ctm[i];
+ scaledCTM[i] = PX_PER_PT * ctm[i];
}
- // scale by PX_PER_PT and flip by the y axis
- builder->setTransform(PX_PER_PT, 0.0, 0.0, -PX_PER_PT, 0.0,
- state->getPageHeight()*PX_PER_PT);
+ builder->setTransform((double*)&scaledCTM);
formDepth = 0;
- abortCheckCbk = abortCheckCbkA;
- abortCheckCbkData = abortCheckCbkDataA;
// set crop box
if (cropBox) {
int lastAbortCheck;
// scan a sequence of objects
- updateLevel = lastAbortCheck = 0;
numArgs = 0;
parser->getObj(&obj);
while (!obj.isEOF()) {
args[i].free();
numArgs = 0;
- // check for an abort
- if (abortCheckCbk) {
- if (updateLevel - lastAbortCheck > 10) {
- if ((*abortCheckCbk)(abortCheckCbkData)) {
- break;
- }
- lastAbortCheck = updateLevel;
- }
- }
-
// got an argument - save it
} else if (numArgs < maxArgs) {
args[numArgs++] = obj;
}
}
-const char *PdfParser::getPreviousOperator() {
+const char *PdfParser::getPreviousOperator(unsigned int look_back) {
OpHistoryEntry *prev = NULL;
- if (operatorHistory != NULL) {
+ if (operatorHistory != NULL && look_back > 0) {
prev = operatorHistory->next;
+ while (--look_back > 0 && prev != NULL) {
+ prev = prev->next;
+ }
}
if (prev != NULL) {
return prev->name;
double a5 = args[5].getNum();
if (!strcmp(prevOp, "q")) {
builder->setTransform(a0, a1, a2, a3, a4, a5);
- } else if (!strcmp(prevOp, "startPage")) {
- // multiply it with the current baseMatrix
- double c0 = baseMatrix[0]*a0 + baseMatrix[1]*a2;
- double c1 = baseMatrix[0]*a1 + baseMatrix[1]*a3;
- double c2 = baseMatrix[2]*a0 + baseMatrix[3]*a2;
- double c3 = baseMatrix[2]*a1 + baseMatrix[3]*a3;
- double c4 = baseMatrix[4]*a0 + baseMatrix[5]*a2 + a4;
- double c5 = baseMatrix[4]*a1 + baseMatrix[5]*a3 + a5;
+ } else if (!strcmp(prevOp, "cm")) {
+ // multiply it with the previous transform
+ double otherMatrix[6];
+ if (!builder->getTransform((double*)&otherMatrix)) { // invalid transform
+ // construct identity matrix
+ otherMatrix[0] = otherMatrix[3] = 1.0;
+ otherMatrix[1] = otherMatrix[2] = otherMatrix[4] = otherMatrix[5] = 0.0;
+ }
+ double c0 = otherMatrix[0]*a0 + otherMatrix[1]*a2;
+ double c1 = otherMatrix[0]*a1 + otherMatrix[1]*a3;
+ double c2 = otherMatrix[2]*a0 + otherMatrix[3]*a2;
+ double c3 = otherMatrix[2]*a1 + otherMatrix[3]*a3;
+ double c4 = otherMatrix[4]*a0 + otherMatrix[5]*a2 + a4;
+ double c5 = otherMatrix[4]*a1 + otherMatrix[5]*a3 + a5;
builder->setTransform(c0, c1, c2, c3, c4, c5);
} else {
builder->pushGroup();
}
}
state->setLineDash(dash, length, args[1].getNum());
+ builder->updateStyle(state);
}
void PdfParser::opSetFlat(Object args[], int numArgs) {
void PdfParser::opSetLineJoin(Object args[], int numArgs) {
state->setLineJoin(args[0].getInt());
+ builder->updateStyle(state);
}
void PdfParser::opSetLineCap(Object args[], int numArgs) {
state->setLineCap(args[0].getInt());
+ builder->updateStyle(state);
}
void PdfParser::opSetMiterLimit(Object args[], int numArgs) {
state->setMiterLimit(args[0].getNum());
+ builder->updateStyle(state);
}
void PdfParser::opSetLineWidth(Object args[], int numArgs) {
state->setLineWidth(args[0].getNum());
+ builder->updateStyle(state);
}
void PdfParser::opSetExtGState(Object args[], int numArgs) {
state->setFillColorSpace(new GfxDeviceGrayColorSpace());
color.c[0] = dblToCol(args[0].getNum());
state->setFillColor(&color);
+ builder->updateStyle(state);
}
void PdfParser::opSetStrokeGray(Object args[], int numArgs) {
state->setStrokeColorSpace(new GfxDeviceGrayColorSpace());
color.c[0] = dblToCol(args[0].getNum());
state->setStrokeColor(&color);
+ builder->updateStyle(state);
}
void PdfParser::opSetFillCMYKColor(Object args[], int numArgs) {
color.c[i] = dblToCol(args[i].getNum());
}
state->setFillColor(&color);
+ builder->updateStyle(state);
}
void PdfParser::opSetStrokeCMYKColor(Object args[], int numArgs) {
color.c[i] = dblToCol(args[i].getNum());
}
state->setStrokeColor(&color);
+ builder->updateStyle(state);
}
void PdfParser::opSetFillRGBColor(Object args[], int numArgs) {
color.c[i] = dblToCol(args[i].getNum());
}
state->setFillColor(&color);
+ builder->updateStyle(state);
}
void PdfParser::opSetStrokeRGBColor(Object args[], int numArgs) {
color.c[i] = dblToCol(args[i].getNum());
}
state->setStrokeColor(&color);
+ builder->updateStyle(state);
}
void PdfParser::opSetFillColorSpace(Object args[], int numArgs) {
state->setFillColorSpace(colorSpace);
colorSpace->getDefaultColor(&color);
state->setFillColor(&color);
+ builder->updateStyle(state);
} else {
error(getPos(), "Bad color space (fill)");
}
state->setStrokeColorSpace(colorSpace);
colorSpace->getDefaultColor(&color);
state->setStrokeColor(&color);
+ builder->updateStyle(state);
} else {
error(getPos(), "Bad color space (stroke)");
}
color.c[i] = dblToCol(args[i].getNum());
}
state->setFillColor(&color);
+ builder->updateStyle(state);
}
void PdfParser::opSetStrokeColor(Object args[], int numArgs) {
color.c[i] = dblToCol(args[i].getNum());
}
state->setStrokeColor(&color);
+ builder->updateStyle(state);
}
void PdfParser::opSetFillColorN(Object args[], int numArgs) {
}
}
state->setFillColor(&color);
+ builder->updateStyle(state);
}
if (args[numArgs-1].isName() &&
(pattern = res->lookupPattern(args[numArgs-1].getName()))) {
}
}
state->setFillColor(&color);
+ builder->updateStyle(state);
}
}
}
}
state->setStrokeColor(&color);
+ builder->updateStyle(state);
}
if (args[numArgs-1].isName() &&
(pattern = res->lookupPattern(args[numArgs-1].getName()))) {
}
}
state->setStrokeColor(&color);
+ builder->updateStyle(state);
}
}
state->setTextMat(1, 0, 0, 1, 0, 0);
state->textMoveTo(0, 0);
fontChanged = gTrue;
+ builder->beginTextObject(state);
}
void PdfParser::opEndText(Object args[], int numArgs) {
- //NEEDED out->endTextObject(state);
+ builder->endTextObject(state);
}
//------------------------------------------------------------------------
void PdfParser::opSetTextRender(Object args[], int numArgs) {
state->setRender(args[0].getInt());
+ builder->updateStyle(state);
}
void PdfParser::opSetTextRise(Object args[], int numArgs) {
void PdfParser::opSetWordSpacing(Object args[], int numArgs) {
state->setWordSpace(args[0].getNum());
- //out->updateWordSpace(state);
}
void PdfParser::opSetHorizScaling(Object args[], int numArgs) {
state->setHorizScaling(args[0].getNum());
- //out->updateHorizScaling(state);
fontChanged = gTrue;
}
return;
}
if (fontChanged) {
- //NEEDED out->updateFont(state);
+ builder->updateFont(state);
fontChanged = gFalse;
}
- //out->beginStringOp(state);
doShowText(args[0].getString());
- //out->endStringOp(state);
}
void PdfParser::opMoveShowText(Object args[], int numArgs) {
return;
}
if (fontChanged) {
- //out->updateFont(state);
+ builder->updateFont(state);
fontChanged = gFalse;
}
tx = state->getLineX();
ty = state->getLineY() - state->getLeading();
state->textMoveTo(tx, ty);
- //out->beginStringOp(state);
doShowText(args[0].getString());
- //out->endStringOp(state);
}
void PdfParser::opMoveSetShowText(Object args[], int numArgs) {
return;
}
if (fontChanged) {
- //out->updateFont(state);
+ builder->updateFont(state);
fontChanged = gFalse;
}
state->setWordSpace(args[0].getNum());
tx = state->getLineX();
ty = state->getLineY() - state->getLeading();
state->textMoveTo(tx, ty);
- //out->beginStringOp(state);
doShowText(args[2].getString());
- //out->endStringOp(state);
}
void PdfParser::opShowSpaceText(Object args[], int numArgs) {
return;
}
if (fontChanged) {
- //out->updateFont(state);
+ builder->updateFont(state);
fontChanged = gFalse;
}
- //out->beginStringOp(state);
wMode = state->getFont()->getWMode();
a = args[0].getArray();
for (i = 0; i < a->getLength(); ++i) {
}
obj.free();
}
- //out->endStringOp(state);
-}
-
-#include <glib-object.h>
-#include <UnicodeMap.h>
-
-static gchar *
-unicode_to_char (Unicode *unicode,
- int len)
-{
- static UnicodeMap *uMap = NULL;
- if (uMap == NULL) {
- GooString *enc = new GooString("UTF-8");
- uMap = globalParams->getUnicodeMap(enc);
- uMap->incRefCnt ();
- delete enc;
- }
-
- GooString gstr;
- gchar buf[8]; /* 8 is enough for mapping an unicode char to a string */
- int i, n;
-
- for (i = 0; i < len; ++i) {
- n = uMap->mapUnicode(unicode[i], buf, sizeof(buf));
- gstr.append(buf, n);
- }
-
- return g_strdup (gstr.getCString ());
}
-
void PdfParser::doShowText(GooString *s) {
GfxFont *font;
int wMode;
font = state->getFont();
wMode = font->getWMode();
-printf("doShowText() called\n");
-// if (out->useDrawChar()) {
-// out->beginString(state, s);
-// }
+
+ builder->beginString(state, s);
// handle a Type 3 char
if (font->getType() == fontType3 && 0) {//out->interpretType3Chars()) {
}
parser = oldParser;
- } else if (1){//out->useDrawChar()) {
+ } else {
state->textTransformDelta(0, state->getRise(), &riseX, &riseY);
p = s->getCString();
len = s->getLength();
u, (int)(sizeof(u) / sizeof(Unicode)), &uLen,
&dx, &dy, &originX, &originY);
- if (uLen > 0) {
- gchar *sc = unicode_to_char((Unicode*)&u, uLen);
- printf("%s", sc);
- g_free(sc);
- }
if (wMode) {
dx *= state->getFontSize();
dy = dy * state->getFontSize() + state->getCharSpace();
originX *= state->getFontSize();
originY *= state->getFontSize();
state->textTransformDelta(originX, originY, &tOriginX, &tOriginY);
-// out->drawChar(state, state->getCurX() + riseX, state->getCurY() + riseY,
-// tdx, tdy, tOriginX, tOriginY, code, n, u, uLen);
+ builder->addChar(state, state->getCurX() + riseX, state->getCurY() + riseY,
+ tdx, tdy, tOriginX, tOriginY, code, n, u, uLen);
state->shift(tdx, tdy);
p += n;
len -= n;
}
-
- } else {
- dx = dy = 0;
- p = s->getCString();
- len = s->getLength();
- nChars = nSpaces = 0;
- while (len > 0) {
- n = font->getNextChar(p, len, &code,
- u, (int)(sizeof(u) / sizeof(Unicode)), &uLen,
- &dx2, &dy2, &originX, &originY);
- dx += dx2;
- dy += dy2;
- if (n == 1 && *p == ' ') {
- ++nSpaces;
- }
- ++nChars;
- p += n;
- len -= n;
- }
- if (wMode) {
- dx *= state->getFontSize();
- dy = dy * state->getFontSize()
- + nChars * state->getCharSpace()
- + nSpaces * state->getWordSpace();
- } else {
- dx = dx * state->getFontSize()
- + nChars * state->getCharSpace()
- + nSpaces * state->getWordSpace();
- dx *= state->getHorizScaling();
- dy *= state->getFontSize();
- }
- state->textTransformDelta(dx, dy, &tdx, &tdy);
-// out->drawString(state, s);
- state->shift(tdx, tdy);
}
-// if (out->useDrawChar()) {
-// out->endString(state);
-// }
-
- updateLevel += 10 * s->getLength();
+ builder->endString(state);
}
//------------------------------------------------------------------------
/* out->drawMaskedImage(state, ref, str, width, height, colorMap,
maskStr, maskWidth, maskHeight, maskInvert);*/
} else {
-/* out->drawImage(state, ref, str, width, height, colorMap,
- haveColorKeyMask ? maskColors : (int *)NULL, inlineImg);*/
+ builder->addImage(state, str, width, height, colorMap,
+ haveColorKeyMask ? maskColors : (int *)NULL);
}
delete colorMap;
smaskObj.free();
}
- if ((i = width * height) > 1000) {
- i = 1000;
- }
- updateLevel += i;
-
return;
err2:
diff --git a/src/extension/internal/pdfinput/pdf-parser.h b/src/extension/internal/pdfinput/pdf-parser.h
index 4c6676999dcde6af6ce020f4b924f9c2d1e6e297..394c9ca830e092fabb84b95c750fee089efdf202 100644 (file)
public:
// Constructor for regular output.
- PdfParser(XRef *xrefA, SvgBuilder *builderA,
- int pageNum, Dict *resDict, PDFRectangle *cropBox,
- GBool (*abortCheckCbkA)(void *data) = NULL,
- void *abortCheckCbkDataA = NULL);
+ PdfParser(XRef *xrefA, SvgBuilder *builderA, int pageNum, int rotate,
+ Dict *resDict, PDFRectangle *cropBox);
~PdfParser();
GBool subPage; // is this a sub-page object?
GBool printCommands; // print the drawing commands (for debugging)
GfxResources *res; // resource stack
- int updateLevel;
GfxState *state; // current graphics state
GBool fontChanged; // set if font or text matrix has changed
Parser *parser; // parser for page content stream(s)
- GBool // callback to check for an abort
- (*abortCheckCbk)(void *data);
- void *abortCheckCbkData;
-
static PdfOperator opTab[]; // table of operators
OpHistoryEntry *operatorHistory; // list containing the last N operators
void pushOperator(const char *name);
OpHistoryEntry *popOperator();
- const char *getPreviousOperator(); // returns the previous operator's name
+ const char *getPreviousOperator(unsigned int look_back=1); // returns the nth previous operator's name
void go(GBool topLevel);
void execOp(Object *cmd, Object args[], int numArgs);
diff --git a/src/extension/internal/pdfinput/svg-builder.cpp b/src/extension/internal/pdfinput/svg-builder.cpp
index 9457d225487f23434f355d919b31a991ec41a92b..c67b191e16d8b68f0014aebdd7dc9aae0dde7bf2 100644 (file)
#include "svg-builder.h"
#include "pdf-parser.h"
+#include <png.h>
+
#include "document-private.h"
#include "xml/document.h"
#include "xml/node.h"
#include "svg/svg-color.h"
#include "color.h"
#include "unit-constants.h"
+#include "io/stringstream.h"
+#include "io/base64stream.h"
+#include "libnr/nr-matrix-ops.h"
+#include "libnrtype/font-instance.h"
#include "Function.h"
#include "GfxState.h"
+#include "GfxFont.h"
+#include "Stream.h"
+#include "UnicodeMap.h"
+#include "GlobalParams.h"
namespace Inkscape {
namespace Extension {
namespace Internal {
-#define LOG(expr) ( expr );
+//#define IFTRACE(_code) _code
+#define IFTRACE(_code)
+
+#define TRACE(_args) IFTRACE(g_print _args)
+
/**
* \class SvgBuilder
*
*/
+SvgBuilder::SvgBuilder() {
+ _in_text_object = false;
+ _need_font_update = true;
+ _invalidated_style = true;
+ _font_style = NULL;
+ _current_font = NULL;
+ _current_state = NULL;
+}
+
SvgBuilder::SvgBuilder(SPDocument *document) {
- doc = document;
- xml_doc = sp_document_repr_doc(doc);
- container = root = doc->rroot;
+ _doc = document;
+ _xml_doc = sp_document_repr_doc(_doc);
+ _container = _root = _doc->rroot;
+ SvgBuilder();
}
SvgBuilder::SvgBuilder(SvgBuilder *parent, Inkscape::XML::Node *root) {
- doc = parent->doc;
- xml_doc = parent->xml_doc;
- container = this->root = root;
+ _doc = parent->_doc;
+ _xml_doc = parent->_xml_doc;
+ _container = this->_root = root;
+ SvgBuilder();
}
SvgBuilder::~SvgBuilder() {
}
void SvgBuilder::setDocumentSize(double width, double height) {
- sp_repr_set_svg_double(root, "width", width);
- sp_repr_set_svg_double(root, "height", height);
- this->width = width;
- this->height = height;
+ sp_repr_set_svg_double(_root, "width", width);
+ sp_repr_set_svg_double(_root, "height", height);
+ this->_width = width;
+ this->_height = height;
}
void SvgBuilder::saveState() {
- groupDepth.push_back(0);
+ _group_depth.push_back(0);
pushGroup();
}
void SvgBuilder::restoreState() {
- int depth = groupDepth.back();
- while (groupDepth.back() > 0) {
+ while (_group_depth.back() > 0) {
popGroup();
}
- groupDepth.pop_back();
+ _group_depth.pop_back();
}
Inkscape::XML::Node *SvgBuilder::pushGroup() {
- Inkscape::XML::Node *node = xml_doc->createElement("svg:g");
- container->appendChild(node);
- container = node;
+ Inkscape::XML::Node *node = _xml_doc->createElement("svg:g");
+ _container->appendChild(node);
+ _container = node;
Inkscape::GC::release(node);
- groupDepth.back()++;
+ _group_depth.back()++;
- return container;
+ return _container;
}
Inkscape::XML::Node *SvgBuilder::popGroup() {
- if (container != root) { // Pop if the current container isn't root
- container = container->parent();
- groupDepth[groupDepth.size()-1] = --groupDepth.back();
+ if (_container != _root) { // Pop if the current container isn't root
+ _container = _container->parent();
+ _group_depth[_group_depth.size()-1] = --_group_depth.back();
}
- return container;
+ return _container;
}
Inkscape::XML::Node *SvgBuilder::getContainer() {
- return container;
+ return _container;
}
static gchar *svgConvertRGBToText(double r, double g, double b) {
SP_COLOR_F_TO_U(r),
SP_COLOR_F_TO_U(g),
SP_COLOR_F_TO_U(b));
- return (gchar*)&tmp;
+ return (gchar *)&tmp;
}
static gchar *svgConvertGfxRGB(GfxRGB *color) {
return svgConvertRGBToText(r, g, b);
}
-static gchar *svgInterpretTransform(double c0, double c1, double c2, double c3,
- double c4, double c5) {
+static void svgSetTransform(Inkscape::XML::Node *node, double c0, double c1,
+ double c2, double c3, double c4, double c5) {
NR::Matrix matrix(c0, c1, c2, c3, c4, c5);
- return sp_svg_transform_write(matrix);
+ gchar *transform_text = sp_svg_transform_write(matrix);
+ node->setAttribute("transform", transform_text);
+ g_free(transform_text);
}
-static gchar *svgInterpretTransform(double *transform) {
- return svgInterpretTransform(transform[0], transform[1], transform[2],
- transform[3], transform[4], transform[5]);
+static void svgSetTransform(Inkscape::XML::Node *node, double *transform) {
+ svgSetTransform(node, transform[0], transform[1], transform[2], transform[3],
+ transform[4], transform[5]);
}
+/**
+ * \brief Generates a SVG path string from poppler's data structure
+ */
static gchar *svgInterpretPath(GfxPath *path) {
GfxSubpath *subpath;
Inkscape::SVG::PathString pathString;
int i, j;
- for (i = 0; i < path->getNumSubpaths(); ++i) {
+ for ( i = 0 ; i < path->getNumSubpaths() ; ++i ) {
subpath = path->getSubpath(i);
if (subpath->getNumPoints() > 0) {
pathString.moveTo(subpath->getX(0), subpath->getY(0));
* \brief Sets stroke style from poppler's GfxState data structure
* Uses the given SPCSSAttr for storing the style properties
*/
-void SvgBuilder::setStrokeStyle(SPCSSAttr *css, GfxState *state) {
+void SvgBuilder::_setStrokeStyle(SPCSSAttr *css, GfxState *state) {
// Check line width
- if (state->getLineWidth() <= 0.0) {
+ if ( state->getLineWidth() <= 0.0 ) {
// Ignore stroke
+ sp_repr_css_set_property(css, "stroke", "none");
return;
}
// Stroke color/pattern
- if (state->getStrokeColorSpace()->getMode() == csPattern) {
- gchar *urltext = createPattern(state->getStrokePattern());
+ if ( state->getStrokeColorSpace()->getMode() == csPattern ) {
+ gchar *urltext = _createPattern(state->getStrokePattern());
sp_repr_css_set_property(css, "stroke", urltext);
if (urltext) {
g_free(urltext);
int dash_length;
double dash_start;
state->getLineDash(&dash_pattern, &dash_length, &dash_start);
- if (dash_length > 0) {
+ if ( dash_length > 0 ) {
Inkscape::CSSOStringStream os_array;
- for (int i = 0; i < dash_length; i++) {
+ for ( int i = 0 ; i < dash_length ; i++ ) {
os_array << dash_pattern[i];
if (i < (dash_length - 1)) {
os_array << ",";
}
}
- printf("aaaa %s\n", os_array.str().c_str());
sp_repr_css_set_property(css, "stroke-dasharray", os_array.str().c_str());
Inkscape::CSSOStringStream os_offset;
* \brief Sets fill style from poppler's GfxState data structure
* Uses the given SPCSSAttr for storing the style properties.
*/
-void SvgBuilder::setFillStyle(SPCSSAttr *css, GfxState *state, bool even_odd) {
+void SvgBuilder::_setFillStyle(SPCSSAttr *css, GfxState *state, bool even_odd) {
// Fill color/pattern
- if (state->getFillColorSpace()->getMode() == csPattern) {
- gchar *urltext = createPattern(state->getFillPattern());
+ if ( state->getFillColorSpace()->getMode() == csPattern ) {
+ gchar *urltext = _createPattern(state->getFillPattern());
sp_repr_css_set_property(css, "fill", urltext);
if (urltext) {
g_free(urltext);
@@ -283,16 +312,16 @@ void SvgBuilder::setFillStyle(SPCSSAttr *css, GfxState *state, bool even_odd) {
* \brief Sets style properties from poppler's GfxState data structure
* \return SPCSSAttr with all the relevant properties set
*/
-SPCSSAttr *SvgBuilder::setStyle(GfxState *state, bool fill, bool stroke, bool even_odd) {
+SPCSSAttr *SvgBuilder::_setStyle(GfxState *state, bool fill, bool stroke, bool even_odd) {
SPCSSAttr *css = sp_repr_css_attr_new();
if (fill) {
- setFillStyle(css, state, even_odd);
+ _setFillStyle(css, state, even_odd);
} else {
sp_repr_css_set_property(css, "fill", "none");
}
if (stroke) {
- setStrokeStyle(css, state);
+ _setStrokeStyle(css, state);
} else {
sp_repr_css_set_property(css, "stroke", "none");
}
@@ -309,20 +338,25 @@ SPCSSAttr *SvgBuilder::setStyle(GfxState *state, bool fill, bool stroke, bool ev
* \param even_odd whether the even-odd rule should be used when filling the path
*/
void SvgBuilder::addPath(GfxState *state, bool fill, bool stroke, bool even_odd) {
- Inkscape::XML::Node *path = xml_doc->createElement("svg:path");
+ Inkscape::XML::Node *path = _xml_doc->createElement("svg:path");
gchar *pathtext = svgInterpretPath(state->getPath());
path->setAttribute("d", pathtext);
g_free(pathtext);
// Set style
- SPCSSAttr *css = setStyle(state, fill, stroke, even_odd);
+ SPCSSAttr *css = _setStyle(state, fill, stroke, even_odd);
sp_repr_css_change(path, css, "style");
sp_repr_css_attr_unref(css);
- container->appendChild(path);
+ _container->appendChild(path);
Inkscape::GC::release(path);
}
+/**
+ * \brief Clips to the current path set in GfxState
+ * \param state poppler's data structure
+ * \param even_odd whether the even-odd rule should be applied
+ */
void SvgBuilder::clip(GfxState *state, bool even_odd) {
pushGroup();
setClipPath(state, even_odd);
void SvgBuilder::setClipPath(GfxState *state, bool even_odd) {
// Create the clipPath repr
- Inkscape::XML::Node *clip_path = xml_doc->createElement("svg:clipPath");
+ Inkscape::XML::Node *clip_path = _xml_doc->createElement("svg:clipPath");
clip_path->setAttribute("clipPathUnits", "userSpaceOnUse");
// Create the path
- Inkscape::XML::Node *path = xml_doc->createElement("svg:path");
+ Inkscape::XML::Node *path = _xml_doc->createElement("svg:path");
gchar *pathtext = svgInterpretPath(state->getPath());
path->setAttribute("d", pathtext);
g_free(pathtext);
clip_path->appendChild(path);
Inkscape::GC::release(path);
// Append clipPath to defs and get id
- SP_OBJECT_REPR (SP_DOCUMENT_DEFS (doc))->appendChild(clip_path);
+ SP_OBJECT_REPR (SP_DOCUMENT_DEFS (_doc))->appendChild(clip_path);
gchar *urltext = g_strdup_printf ("url(#%s)", clip_path->attribute("id"));
Inkscape::GC::release(clip_path);
- container->setAttribute("clip-path", urltext);
+ _container->setAttribute("clip-path", urltext);
g_free(urltext);
}
+/**
+ * \brief Fills the given array with the current container's transform, if set
+ * \param transform array of doubles to be filled
+ * \return true on success; false on invalid transformation
+ */
bool SvgBuilder::getTransform(double *transform) {
NR::Matrix svd;
- gchar const *tr = container->attribute("transform");
+ gchar const *tr = _container->attribute("transform");
bool valid = sp_svg_transform_read(tr, &svd);
if (valid) {
- for (unsigned i = 0; i < 6; i++) {
+ for ( int i = 0 ; i < 6 ; i++ ) {
transform[i] = svd[i];
}
return true;
}
}
+/**
+ * \brief Sets the transformation matrix of the current container
+ */
void SvgBuilder::setTransform(double c0, double c1, double c2, double c3,
double c4, double c5) {
- gchar *transform_text = svgInterpretTransform(c0, c1, c2, c3, c4, c5);
- LOG(g_message("setTransform: %f %f %f %f %f %f", c0, c1, c2, c3, c4, c5));
- container->setAttribute("transform", transform_text);
- g_free(transform_text);
+ TRACE(("setTransform: %f %f %f %f %f %f\n", c0, c1, c2, c3, c4, c5));
+ svgSetTransform(_container, c0, c1, c2, c3, c4, c5);
}
void SvgBuilder::setTransform(double *transform) {
* Used by PdfParser to decide when to do fallback operations.
*/
bool SvgBuilder::isPatternTypeSupported(GfxPattern *pattern) {
- if (pattern != NULL) {
- if (pattern->getType() == 2) { // shading pattern
+ if ( pattern != NULL ) {
+ if ( pattern->getType() == 2 ) { // shading pattern
GfxShading *shading = ((GfxShadingPattern *)pattern)->getShading();
int shadingType = shading->getType();
- if (shadingType == 2 || // axial shading
- shadingType == 3) { // radial shading
+ if ( shadingType == 2 || // axial shading
+ shadingType == 3 ) { // radial shading
return true;
}
return false;
- } else if (pattern->getType() == 1) { // tiling pattern
+ } else if ( pattern->getType() == 1 ) { // tiling pattern
return true;
}
}
* build a tiling pattern.
* \return an url pointing to the created pattern
*/
-gchar *SvgBuilder::createPattern(GfxPattern *pattern) {
+gchar *SvgBuilder::_createPattern(GfxPattern *pattern) {
gchar *id = NULL;
- if (pattern != NULL) {
- if (pattern->getType() == 2) { // Shading pattern
- id = createGradient((GfxShadingPattern*)pattern);
- } else if (pattern->getType() == 1) { // Tiling pattern
- id = createTilingPattern((GfxTilingPattern*)pattern);
+ if ( pattern != NULL ) {
+ if ( pattern->getType() == 2 ) { // Shading pattern
+ id = _createGradient((GfxShadingPattern*)pattern);
+ } else if ( pattern->getType() == 1 ) { // Tiling pattern
+ id = _createTilingPattern((GfxTilingPattern*)pattern);
}
} else {
return NULL;
return urltext;
}
-gchar *SvgBuilder::createTilingPattern(GfxTilingPattern *tiling_pattern) {
+gchar *SvgBuilder::_createTilingPattern(GfxTilingPattern *tiling_pattern) {
return NULL;
}
* \brief Creates a linear or radial gradient from poppler's data structure
* \return id of the created object
*/
-gchar *SvgBuilder::createGradient(GfxShadingPattern *shading_pattern) {
+gchar *SvgBuilder::_createGradient(GfxShadingPattern *shading_pattern) {
GfxShading *shading = shading_pattern->getShading();
Inkscape::XML::Node *gradient;
Function *func;
int num_funcs;
bool extend0, extend1;
- if (shading->getType() == 2) { // Axial shading
- gradient = xml_doc->createElement("svg:linearGradient");
+
+ if ( shading->getType() == 2 ) { // Axial shading
+ gradient = _xml_doc->createElement("svg:linearGradient");
GfxAxialShading *axial_shading = (GfxAxialShading*)shading;
double x1, y1, x2, y2;
axial_shading->getCoords(&x1, &y1, &x2, &y2);
num_funcs = axial_shading->getNFuncs();
func = axial_shading->getFunc(0);
} else if (shading->getType() == 3) { // Radial shading
- gradient = xml_doc->createElement("svg:radialGradient");
+ gradient = _xml_doc->createElement("svg:radialGradient");
GfxRadialShading *radial_shading = (GfxRadialShading*)shading;
double x1, y1, r1, x2, y2, r2;
radial_shading->getCoords(&x1, &y1, &r1, &x2, &y2, &r2);
// Flip the gradient transform around the y axis
double *p2u = shading_pattern->getMatrix();
NR::Matrix pat_matrix(p2u[0], p2u[1], p2u[2], p2u[3], p2u[4], p2u[5]);
- NR::Matrix flip(1.0, 0.0, 0.0, -1.0, 0.0, height*PT_PER_PX);
+ NR::Matrix flip(1.0, 0.0, 0.0, -1.0, 0.0, _height * PT_PER_PX);
pat_matrix *= flip;
- gradient->setAttribute("gradientTransform", sp_svg_transform_write(pat_matrix));
+ gchar *transform_text = sp_svg_transform_write(pat_matrix);
+ gradient->setAttribute("gradientTransform", transform_text);
+ g_free(transform_text);
- if (extend0 && extend1) {
+ if ( extend0 && extend1 ) {
gradient->setAttribute("spreadMethod", "pad");
}
- if (num_funcs > 1 || !addStopsToGradient(gradient, func, 1.0)) {
+
+ if ( num_funcs > 1 || !_addStopsToGradient(gradient, func, 1.0) ) {
Inkscape::GC::release(gradient);
return NULL;
}
- Inkscape::XML::Node *defs = SP_OBJECT_REPR (SP_DOCUMENT_DEFS (doc));
+ Inkscape::XML::Node *defs = SP_OBJECT_REPR (SP_DOCUMENT_DEFS (_doc));
defs->appendChild(gradient);
gchar *id = g_strdup(gradient->attribute("id"));
Inkscape::GC::release(gradient);
}
#define EPSILON 0.0001
-bool SvgBuilder::addSamplesToGradient(Inkscape::XML::Node *gradient,
- SampledFunction *func, double offset0,
- double offset1, double opacity) {
+bool SvgBuilder::_addSamplesToGradient(Inkscape::XML::Node *gradient,
+ SampledFunction *func, double offset0,
+ double offset1, double opacity) {
// Check whether this sampled function can be converted to color stops
int sample_size = func->getSampleSize(0);
- if (sample_size != 2)
+ if ( sample_size != 2 )
return false;
int num_comps = func->getOutputSize();
- if (num_comps != 3)
+ if ( num_comps != 3 )
return false;
double *samples = func->getSamples();
- // See if this is the continuation of the previous sampled function
- bool is_continuation = false;
unsigned stop_count = gradient->childCount();
- if (stop_count > 0) {
+ bool is_continuation = false;
+ // Check if this sampled function is the continuation of the previous one
+ if ( stop_count > 0 ) {
// Get previous stop
Inkscape::XML::Node *prev_stop = gradient->nthChild(stop_count-1);
-
// Read its properties
- double offset;
- sp_repr_get_double(prev_stop, "offset", &offset);
+ double prev_offset;
+ sp_repr_get_double(prev_stop, "offset", &prev_offset);
SPCSSAttr *css = sp_repr_css_attr(prev_stop, "style");
- guint32 prev_color = sp_svg_read_color(sp_repr_css_property(css, "stop-color", NULL), 0);
- double alpha = sp_repr_css_double_property(css, "stop-opacity", 1.0);
+ guint32 prev_stop_color = sp_svg_read_color(sp_repr_css_property(css, "stop-color", NULL), 0);
sp_repr_css_attr_unref(css);
// Convert colors
- double r = SP_RGBA32_R_F(prev_color);
- double g = SP_RGBA32_G_F(prev_color);
- double b = SP_RGBA32_B_F(prev_color);
-
- if (fabs(offset - offset0) < EPSILON &&
- fabs(samples[0] - r) < EPSILON &&
- fabs(samples[1] - g) < EPSILON &&
- fabs(samples[2] - b) < EPSILON &&
- fabs(alpha - opacity) < EPSILON) { // Identical
+ double r = SP_RGBA32_R_F (prev_stop_color);
+ double g = SP_RGBA32_G_F (prev_stop_color);
+ double b = SP_RGBA32_B_F (prev_stop_color);
+ if ( fabs(prev_offset - offset0) < EPSILON &&
+ fabs(samples[0] - r) < EPSILON &&
+ fabs(samples[1] - g) < EPSILON &&
+ fabs(samples[2] - b) < EPSILON ) {
is_continuation = true;
- LOG(g_message("gradient offsets merged"));
}
}
- int i = 0;
- if (is_continuation)
- i = num_comps;
+ int i = is_continuation ? num_comps : 0;
while (i < sample_size*num_comps) {
- Inkscape::XML::Node *stop = xml_doc->createElement("svg:stop");
+ Inkscape::XML::Node *stop = _xml_doc->createElement("svg:stop");
SPCSSAttr *css = sp_repr_css_attr_new();
Inkscape::CSSOStringStream os_opacity;
os_opacity << opacity;
sp_repr_css_set_property(css, "stop-opacity", os_opacity.str().c_str());
- sp_repr_css_set_property(css, "stop-color",
- svgConvertRGBToText(samples[i], samples[i+1],
- samples[i+2]));
+ gchar c[64];
+ sp_svg_write_color (c, 64, SP_RGBA32_F_COMPOSE (samples[i], samples[i+1], samples[i+2], 1.0));
+ sp_repr_css_set_property(css, "stop-color", c);
sp_repr_css_change(stop, css, "style");
sp_repr_css_attr_unref(css);
- sp_repr_set_css_double(stop, "offset", (i < num_comps) ? offset0 : offset1);
+ sp_repr_set_css_double(stop, "offset", ( i < num_comps ) ? offset0 : offset1);
gradient->appendChild(stop);
Inkscape::GC::release(stop);
return true;
}
-bool SvgBuilder::addStopsToGradient(Inkscape::XML::Node *gradient, Function *func,
- double opacity) {
+bool SvgBuilder::_addStopsToGradient(Inkscape::XML::Node *gradient, Function *func,
+ double opacity) {
int type = func->getType();
- if (type == 0) { // Sampled
+ if ( type == 0 ) { // Sampled
SampledFunction *sampledFunc = (SampledFunction*)func;
- addSamplesToGradient(gradient, sampledFunc, 0.0, 1.0, opacity);
- } else if (type == 3) { // Stitching
+ _addSamplesToGradient(gradient, sampledFunc, 0.0, 1.0, opacity);
+ } else if ( type == 3 ) { // Stitching
StitchingFunction *stitchingFunc = (StitchingFunction*)func;
double *bounds = stitchingFunc->getBounds();
- // bounds might be outside of [0..1]!!!!
- double *encode = stitchingFunc->getEncode();
- // should check whether all of them are [0..1]
int num_funcs = stitchingFunc->getNumFuncs();
// Add samples from all the stitched functions
- for (int i=0; i<num_funcs; i++) {
+ for ( int i = 0 ; i < num_funcs ; i++ ) {
Function *func = stitchingFunc->getFunc(i);
- if (func->getType() != 0) // Only sampled functions are supported
+ if ( func->getType() != 0 ) // Only sampled functions are supported
continue;
-
- LOG(g_message("t%i i%i o%i m%f m%f",
- func->getType(),
- func->getInputSize(), func->getOutputSize(),
- func->getDomainMin(0), func->getDomainMax(0)));
-
+
SampledFunction *sampledFunc = (SampledFunction*)func;
- addSamplesToGradient(gradient, sampledFunc, bounds[i],
- bounds[i+1], opacity);
+ _addSamplesToGradient(gradient, sampledFunc, bounds[i],
+ bounds[i+1], opacity);
}
} else { // Unsupported function type
return false;
@@ -592,7 +621,568 @@ bool SvgBuilder::addStopsToGradient(Inkscape::XML::Node *gradient, Function *fun
return true;
}
-} } } /* namespace Inkscape, Extension, Internal, PdfInput */
+/**
+ * \brief Sets _invalidated_style to true to indicate that styles have to be updated
+ * Used for text output when glyphs are buffered till a font change
+ */
+void SvgBuilder::updateStyle(GfxState *state) {
+ if (_in_text_object) {
+ _invalidated_style = true;
+ _current_state = state;
+ }
+}
+
+/**
+ * \brief Updates _font_style according to the font set in parameter state
+ */
+void SvgBuilder::updateFont(GfxState *state) {
+
+ TRACE(("updateFont()\n"));
+ _need_font_update = false;
+ // Flush buffered text before resetting matrices and font style
+ _flushText();
+
+ if (_font_style) {
+ //sp_repr_css_attr_unref(_font_style);
+ }
+ _font_style = sp_repr_css_attr_new();
+ GfxFont *font = state->getFont();
+ // Store original name
+ if (font->getOrigName()) {
+ _font_specification = font->getOrigName()->getCString();
+ } else {
+ _font_specification = font->getName()->getCString();
+ }
+
+ // Prune the font name to get the correct font family name
+ // In a PDF font names can look like this: IONIPB+MetaPlusBold-Italic
+ char *font_family = NULL;
+ char *font_style = NULL;
+ char *plus_sign = strstr(_font_specification, "+");
+ if (plus_sign) {
+ font_family = g_strdup(plus_sign + 1);
+ _font_specification = plus_sign + 1;
+ } else {
+ font_family = g_strdup(_font_specification);
+ }
+ char *minus_sign = g_strrstr(font_family, "-");
+ if (minus_sign) {
+ font_style = minus_sign + 1;
+ minus_sign[0] = 0;
+ }
+
+ // Font family
+ if (font->getFamily()) {
+ const gchar *family = font->getFamily()->getCString();
+ sp_repr_css_set_property(_font_style, "font-family", font->getFamily()->getCString());
+ } else {
+ sp_repr_css_set_property(_font_style, "font-family", font_family);
+ }
+ g_free(font_family);
+
+ // Font style
+ if (font->isItalic()) {
+ sp_repr_css_set_property(_font_style, "font-style", "italic");
+ }
+
+ // Font variant -- default 'normal' value
+ sp_repr_css_set_property(_font_style, "font-variant", "normal");
+
+ // Font weight
+ GfxFont::Weight font_weight = font->getWeight();
+ if ( font_weight != GfxFont::WeightNotDefined ) {
+ if ( font_weight == GfxFont::W400 ) {
+ sp_repr_css_set_property(_font_style, "font-weight", "normal");
+ } else if ( font_weight == GfxFont::W700 ) {
+ sp_repr_css_set_property(_font_style, "font-weight", "bold");
+ } else {
+ gchar weight_num[4] = "100";
+ weight_num[0] = (gchar)( '1' + (font_weight - GfxFont::W100) );
+ sp_repr_css_set_property(_font_style, "font-weight", (gchar *)&weight_num);
+ }
+ }
+
+ // Font stretch
+ GfxFont::Stretch font_stretch = font->getStretch();
+ gchar *stretch_value = NULL;
+ switch (font_stretch) {
+ case GfxFont::UltraCondensed:
+ stretch_value = "ultra-condensed";
+ break;
+ case GfxFont::ExtraCondensed:
+ stretch_value = "extra-condensed";
+ break;
+ case GfxFont::Condensed:
+ stretch_value = "condensed";
+ break;
+ case GfxFont::SemiCondensed:
+ stretch_value = "semi-condensed";
+ break;
+ case GfxFont::Normal:
+ stretch_value = "normal";
+ break;
+ case GfxFont::SemiExpanded:
+ stretch_value = "semi-expanded";
+ break;
+ case GfxFont::Expanded:
+ stretch_value = "expanded";
+ break;
+ case GfxFont::ExtraExpanded:
+ stretch_value = "extra-expanded";
+ break;
+ case GfxFont::UltraExpanded:
+ stretch_value = "ultra-expanded";
+ break;
+ default:
+ break;
+ }
+ if ( stretch_value != NULL ) {
+ sp_repr_css_set_property(_font_style, "font-stretch", stretch_value);
+ }
+
+ // Font size
+ Inkscape::CSSOStringStream os_font_size;
+ double *text_matrix = state->getTextMat();
+ double font_size = sqrt( text_matrix[0] * text_matrix[3] - text_matrix[1] * text_matrix[2] );
+ font_size *= state->getFontSize() * state->getHorizScaling();
+ os_font_size << font_size;
+ sp_repr_css_set_property(_font_style, "font-size", os_font_size.str().c_str());
+
+ // Writing mode
+ if ( font->getWMode() == 0 ) {
+ sp_repr_css_set_property(_font_style, "writing-mode", "lr");
+ } else {
+ sp_repr_css_set_property(_font_style, "writing-mode", "tb");
+ }
+
+ // Calculate new text matrix
+ double *font_matrix = font->getFontMatrix();
+ NR::Matrix nr_font_matrix(font_matrix[0], font_matrix[1], font_matrix[2],
+ font_matrix[3], font_matrix[4], font_matrix[5]);
+ NR::Matrix new_text_matrix(text_matrix[0], text_matrix[1],
+ -text_matrix[2], -text_matrix[3],
+ 0.0, 0.0);
+ new_text_matrix *= NR::scale( 1.0 / font_size, 1.0 / font_size );
+ _text_matrix = nr_font_matrix * new_text_matrix;
+
+ _current_font = font;
+}
+
+/**
+ * \brief Writes the buffered characters to the SVG document
+ */
+void SvgBuilder::_flushText() {
+ // Ignore empty strings
+ if ( _glyphs.size() < 1 ) {
+ _glyphs.clear();
+ return;
+ }
+ const SvgGlyph& first_glyph = _glyphs[0];
+ int render_mode = first_glyph.render_mode;
+ // Ignore invisible characters
+ if ( render_mode == 3 ) {
+ _glyphs.clear();
+ return;
+ }
+
+ Inkscape::XML::Node *text_node = _xml_doc->createElement("svg:text");
+ // Set current text position
+ sp_repr_set_svg_double(text_node, "x", first_glyph.transformed_position[0]);
+ sp_repr_set_svg_double(text_node, "y", first_glyph.transformed_position[1]);
+ // Set style
+ sp_repr_css_change(text_node, first_glyph.style, "style");
+ text_node->setAttribute("inkscape:font-specification", _font_specification);
+ // Set text matrix
+ gchar *transform = sp_svg_transform_write(_text_matrix);
+ text_node->setAttribute("transform", transform);
+ g_free(transform);
+
+ bool new_tspan = true;
+ Inkscape::XML::Node *tspan_node = NULL;
+ Glib::ustring x_coords;
+ Glib::ustring y_coords;
+ Glib::ustring text_buffer;
+ bool is_vertical = !strcmp(sp_repr_css_property(_font_style, "writing-mode", "lr"), "tb"); // FIXME
+
+ // Output all buffered glyphs
+ std::vector<SvgGlyph>::iterator i = _glyphs.begin();
+ while (1) {
+ const SvgGlyph& glyph = (*i);
+ std::vector<SvgGlyph>::iterator prev_iterator = i - 1;
+ // Check if we need to make a new tspan
+ if (glyph.style_changed) {
+ new_tspan = true;
+ } else if ( i != _glyphs.begin() ) {
+ const SvgGlyph& prev_glyph = (*prev_iterator);
+ if ( ( is_vertical && prev_glyph.transformed_position[0] != glyph.transformed_position[0] ) ||
+ ( !is_vertical && prev_glyph.transformed_position[1] != glyph.transformed_position[1] ) ) {
+ new_tspan = true;
+ }
+ }
+ // Create tspan node if needed
+ if ( new_tspan || i == _glyphs.end() ) {
+ if (tspan_node) {
+ // Set the x and y coordinate arrays
+ tspan_node->setAttribute("x", x_coords.c_str());
+ tspan_node->setAttribute("y", y_coords.c_str());
+ TRACE(("tspan content: %s\n", text_buffer.c_str()));
+ // Add text content node to tspan
+ Inkscape::XML::Node *text_content = _xml_doc->createTextNode(text_buffer.c_str());
+ tspan_node->appendChild(text_content);
+ Inkscape::GC::release(text_content);
+ text_node->appendChild(tspan_node);
+ // Clear temporary buffers
+ x_coords.clear();
+ y_coords.clear();
+ text_buffer.clear();
+ Inkscape::GC::release(tspan_node);
+ }
+ if ( i == _glyphs.end() ) {
+ sp_repr_css_attr_unref((*prev_iterator).style);
+ break;
+ } else {
+ tspan_node = _xml_doc->createElement("svg:tspan");
+ // Set style and unref SPCSSAttr if it won't be needed anymore
+ if ( i != _glyphs.begin() ) {
+ sp_repr_css_change(tspan_node, glyph.style, "style");
+ if (glyph.style_changed) { // Free previous style
+ sp_repr_css_attr_unref((*prev_iterator).style);
+ }
+ }
+ }
+ new_tspan = false;
+ }
+ if ( x_coords.length() > 0 ) {
+ x_coords.append(" ");
+ y_coords.append(" ");
+ }
+ // Append the coordinates to their respective strings
+ Inkscape::CSSOStringStream os_x;
+ os_x << glyph.transformed_position[0];
+ x_coords.append(os_x.str());
+ Inkscape::CSSOStringStream os_y;
+ os_y << glyph.transformed_position[1];
+ y_coords.append(os_y.str());
+
+ // Append the character to the text buffer
+ text_buffer.append((char *)&glyph.code, 1);
+
+ i++;
+ }
+ _container->appendChild(text_node);
+ Inkscape::GC::release(text_node);
+
+ _glyphs.clear();
+}
+
+void SvgBuilder::beginString(GfxState *state, GooString *s) {
+ if (_need_font_update) {
+ updateFont(state);
+ }
+ IFTRACE(double *m = state->getTextMat());
+ TRACE(("tm: %f %f %f %f %f %f\n",m[0], m[1],m[2], m[3], m[4], m[5]));
+ IFTRACE(m = _current_font->getFontMatrix());
+ TRACE(("fm: %f %f %f %f %f %f\n",m[0], m[1],m[2], m[3], m[4], m[5]));
+ IFTRACE(m = state->getCTM());
+ TRACE(("ctm: %f %f %f %f %f %f\n",m[0], m[1],m[2], m[3], m[4], m[5]));
+}
+
+/**
+ * \brief Adds the specified character to the text buffer
+ * Takes care of converting it to UTF-8 and generates a new style repr if style
+ * has changed since the last call.
+ */
+void SvgBuilder::addChar(GfxState *state, double x, double y,
+ double dx, double dy,
+ double originX, double originY,
+ CharCode code, int nBytes, Unicode *u, int uLen) {
+
+
+ bool is_space = ( uLen == 1 && u[0] == 32 );
+ // Skip beginning space
+ if ( is_space && _glyphs.size() < 1 ) {
+ return;
+ }
+ // Allow only one space in a row
+ if ( is_space && _glyphs[_glyphs.size() - 1].code_size == 1 &&
+ _glyphs[_glyphs.size() - 1].code[0] == 32 ) {
+ return;
+ }
+
+ SvgGlyph new_glyph;
+ new_glyph.is_space = is_space;
+ new_glyph.position = NR::Point( x - originX, y - originY );
+ new_glyph.transformed_position = new_glyph.position * _text_matrix;
+ new_glyph.dx = dx;
+ new_glyph.dy = dy;
+
+ // Convert the character to UTF-8 since that's our SVG document's encoding
+ static UnicodeMap *u_map = NULL;
+ if ( u_map == NULL ) {
+ GooString *enc = new GooString("UTF-8");
+ u_map = globalParams->getUnicodeMap(enc);
+ u_map->incRefCnt();
+ delete enc;
+ }
+ int code_size = 0;
+ for ( int i = 0 ; i < uLen ; i++ ) {
+ code_size += u_map->mapUnicode(u[i], (char *)&new_glyph.code[code_size], sizeof(new_glyph.code) - code_size);
+ }
+ new_glyph.code_size = code_size;
+
+ // Copy current style if it has changed since the previous glyph
+ if (_invalidated_style || _glyphs.size() == 0 ) {
+ new_glyph.style_changed = true;
+ int render_mode = state->getRender();
+ // Set style
+ bool has_fill = !( render_mode & 1 );
+ bool has_stroke = ( render_mode & 3 ) == 1 || ( render_mode & 3 ) == 2;
+ new_glyph.style = _setStyle(state, has_fill, has_stroke);
+ new_glyph.render_mode = render_mode;
+ sp_repr_css_merge(new_glyph.style, _font_style); // Merge with font style
+ _invalidated_style = false;
+ } else {
+ new_glyph.style_changed = false;
+ // Point to previous glyph's style information
+ const SvgGlyph& prev_glyph = _glyphs.back();
+ new_glyph.style = prev_glyph.style;
+ new_glyph.render_mode = prev_glyph.render_mode;
+ }
+ _glyphs.push_back(new_glyph);
+}
+
+void SvgBuilder::endString(GfxState *state) {
+}
+
+void SvgBuilder::beginTextObject(GfxState *state) {
+ _in_text_object = true;
+ _invalidated_style = true; // Force copying of current state
+ _current_state = state;
+}
+
+void SvgBuilder::endTextObject(GfxState *state) {
+ _flushText();
+ // TODO: clip if render_mode >= 4
+ _in_text_object = false;
+}
+
+/**
+ * Helper functions for supporting direct PNG output into a base64 encoded stream
+ */
+void png_write_base64stream(png_structp png_ptr, png_bytep data, png_size_t length)
+{
+ Inkscape::IO::Base64OutputStream *stream =
+ (Inkscape::IO::Base64OutputStream*)png_get_io_ptr(png_ptr); // Get pointer to stream
+ for ( unsigned i = 0 ; i < length ; i++ ) {
+ stream->put((int)data[i]);
+ }
+}
+
+void png_flush_base64stream(png_structp png_ptr)
+{
+ Inkscape::IO::Base64OutputStream *stream =
+ (Inkscape::IO::Base64OutputStream*)png_get_io_ptr(png_ptr); // Get pointer to stream
+ stream->flush();
+}
+
+/**
+ * \brief Creates an <image> element containing the given ImageStream as a PNG
+ *
+ */
+Inkscape::XML::Node *SvgBuilder::_createImage(Stream *str, int width, int height,
+ GfxImageColorMap *color_map, int *mask_colors, bool alpha_only, bool invert_alpha) {
+
+ // Create PNG write struct
+ png_structp png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
+ if ( png_ptr == NULL ) {
+ return NULL;
+ }
+ // Create PNG info struct
+ png_infop info_ptr = png_create_info_struct(png_ptr);
+ if ( info_ptr == NULL ) {
+ png_destroy_write_struct(&png_ptr, NULL);
+ return NULL;
+ }
+ // Set error handler
+ if (setjmp(png_ptr->jmpbuf)) {
+ png_destroy_write_struct(&png_ptr, &info_ptr);
+ return NULL;
+ }
+
+ // Set read/write functions
+ Inkscape::IO::StringOutputStream base64_string;
+ Inkscape::IO::Base64OutputStream base64_stream(base64_string);
+ FILE *fp;
+ gchar *file_name;
+ bool embed_image = true;
+ if (embed_image) {
+ base64_stream.setColumnWidth(0); // Disable line breaks
+ png_set_write_fn(png_ptr, &base64_stream, png_write_base64stream, png_flush_base64stream);
+ } else {
+ static int counter = 0;
+ file_name = g_strdup_printf("createImage%d.png", counter++);
+ fp = fopen(file_name, "wb");
+ if ( fp == NULL ) {
+ png_destroy_write_struct(&png_ptr, &info_ptr);
+ g_free(file_name);
+ return NULL;
+ }
+ png_init_io(png_ptr, fp);
+ }
+
+ // Set header data
+ if (!invert_alpha) {
+ png_set_invert_alpha(png_ptr);
+ }
+ png_color_8 sig_bit;
+ if (alpha_only) {
+ png_set_IHDR(png_ptr, info_ptr,
+ width,
+ height,
+ 8, /* bit_depth */
+ PNG_COLOR_TYPE_GRAY,
+ PNG_INTERLACE_NONE,
+ PNG_COMPRESSION_TYPE_BASE,
+ PNG_FILTER_TYPE_BASE);
+ sig_bit.red = 0;
+ sig_bit.green = 0;
+ sig_bit.blue = 0;
+ sig_bit.gray = 8;
+ sig_bit.alpha = 0;
+ } else {
+ png_set_IHDR(png_ptr, info_ptr,
+ width,
+ height,
+ 8, /* bit_depth */
+ PNG_COLOR_TYPE_RGB_ALPHA,
+ PNG_INTERLACE_NONE,
+ PNG_COMPRESSION_TYPE_BASE,
+ PNG_FILTER_TYPE_BASE);
+ sig_bit.red = 8;
+ sig_bit.green = 8;
+ sig_bit.blue = 8;
+ sig_bit.alpha = 8;
+ }
+ png_set_sBIT(png_ptr, info_ptr, &sig_bit);
+ png_set_bgr(png_ptr);
+ // Write the file header
+ png_write_info(png_ptr, info_ptr);
+
+ // Convert pixels
+ ImageStream *image_stream;
+ if (alpha_only) {
+ if (color_map) {
+ image_stream = new ImageStream(str, width, color_map->getNumPixelComps(),
+ color_map->getBits());
+ } else {
+ image_stream = new ImageStream(str, width, 1, 1);
+ }
+ image_stream->reset();
+
+ // Convert grayscale values
+ if (color_map) {
+ unsigned char *buffer = new unsigned char[width];
+ for ( int y = 0 ; y < height ; y++ ) {
+ unsigned char *row = image_stream->getLine();
+ color_map->getGrayLine(row, buffer, width);
+ png_write_row(png_ptr, (png_bytep)buffer);
+ }
+ delete buffer;
+ } else {
+ for ( int y = 0 ; y < height ; y++ ) {
+ unsigned char *row = image_stream->getLine();
+ png_write_row(png_ptr, (png_bytep)row);
+ }
+ }
+ } else if (color_map) {
+ image_stream = new ImageStream(str, width,
+ color_map->getNumPixelComps(),
+ color_map->getBits());
+ image_stream->reset();
+
+ // Convert RGB values
+ unsigned int *buffer = new unsigned int[width];
+ if (mask_colors) {
+ for ( int y = 0 ; y < height ; y++ ) {
+ unsigned char *row = image_stream->getLine();
+ color_map->getRGBLine(row, buffer, width);
+
+ unsigned int *dest = buffer;
+ for ( int x = 0 ; x < width ; x++ ) {
+ // Check each color component against the mask
+ for ( int i = 0; i < color_map->getNumPixelComps() ; i++) {
+ if ( row[i] < mask_colors[2*i] * 255 ||
+ row[i] > mask_colors[2*i + 1] * 255 ) {
+ *dest = *dest | 0xff000000;
+ break;
+ }
+ }
+ // Advance to the next pixel
+ row += color_map->getNumPixelComps();
+ dest++;
+ }
+ // Write it to the PNG
+ png_write_row(png_ptr, (png_bytep)buffer);
+ }
+ } else {
+ for ( int i = 0 ; i < height ; i++ ) {
+ unsigned char *row = image_stream->getLine();
+ memset((void*)buffer, 0xff, sizeof(int) * width);
+ color_map->getRGBLine(row, buffer, width);
+ png_write_row(png_ptr, (png_bytep)buffer);
+ }
+ }
+ delete buffer;
+
+ } else { // A colormap must be provided, so quit
+ png_destroy_write_struct(&png_ptr, &info_ptr);
+ if (!embed_image) {
+ fclose(fp);
+ g_free(file_name);
+ }
+ return NULL;
+ }
+ delete image_stream;
+ str->close();
+ // Close PNG
+ png_write_end(png_ptr, info_ptr);
+ png_destroy_write_struct(&png_ptr, &info_ptr);
+ base64_stream.close();
+
+ // Create repr
+ Inkscape::XML::Node *image_node = _xml_doc->createElement("svg:image");
+ sp_repr_set_svg_double(image_node, "width", width);
+ sp_repr_set_svg_double(image_node, "height", height);
+ // Set transformation
+ svgSetTransform(image_node, 1.0/(double)width, 0.0, 0.0, -1.0/(double)height, 0.0, 1.0);
+
+ // Create href
+ if (embed_image) {
+ // Append format specification to the URI
+ Glib::ustring& png_data = base64_string.getString();
+ png_data.insert(0, "data:image/png;base64,");
+ image_node->setAttribute("xlink:href", png_data.c_str());
+ } else {
+ fclose(fp);
+ image_node->setAttribute("xlink:href", file_name);
+ g_free(file_name);
+ }
+
+ return image_node;
+}
+
+void SvgBuilder::addImage(GfxState *state, Stream *str, int width, int height,
+ GfxImageColorMap *color_map, int *mask_colors) {
+
+ Inkscape::XML::Node *image_node = _createImage(str, width, height, color_map, mask_colors);
+ if (image_node) {
+ _container->appendChild(image_node);
+ Inkscape::GC::release(image_node);
+ }
+}
+
+
+} } } /* namespace Inkscape, Extension, Internal */
#endif /* HAVE_POPPLER */
diff --git a/src/extension/internal/pdfinput/svg-builder.h b/src/extension/internal/pdfinput/svg-builder.h
index 0422184130c8e74c44fec0f77629c948c10eb20b..8145a45224a99c460de6c2c67cddc8ec9beecb46 100644 (file)
}
}
+#include "libnr/nr-point.h"
+#include "libnr/nr-matrix.h"
+
+#include "CharTypes.h"
+class GooString;
class Function;
class SampledFunction;
struct GfxState;
class GfxPattern;
class GfxShadingPattern;
class GfxTilingPattern;
+class GfxFont;
+class GfxImageColorMap;
+class Stream;
class SPCSSAttr;
namespace Extension {
namespace Internal {
+/**
+ * \struct SvgGlyph
+ * Holds information about glyphs added by PdfParser which haven't been added
+ * to the document yet.
+ */
+struct SvgGlyph {
+ NR::Point position; // Absolute glyph coords
+ NR::Point transformed_position; // Glyph coords transformed by text matrix
+ double dx, dy; // Advance values
+ char code[8]; // UTF-8 coded character
+ int code_size;
+ bool is_space;
+
+ bool style_changed; // Set to true if style has to be reset
+ SPCSSAttr *style;
+ int render_mode; // Text render mode
+};
+
/**
* \class SvgBuilder
*
// Path adding
void addPath(GfxState *state, bool fill, bool stroke, bool even_odd=false);
+ // Image handling
+ void addImage(GfxState *state, Stream *str, int width, int height,
+ GfxImageColorMap *color_map, int *mask_colors);
+
+ // Text handling
+ void beginString(GfxState *state, GooString *s);
+ void endString(GfxState *state);
+ void addChar(GfxState *state, double x, double y,
+ double dx, double dy,
+ double originX, double originY,
+ CharCode code, int nBytes, Unicode *u, int uLen);
+ void beginTextObject(GfxState *state);
+ void endTextObject(GfxState *state);
+
bool isPatternTypeSupported(GfxPattern *pattern);
// State manipulation
void saveState();
void restoreState();
+ void updateStyle(GfxState *state);
+ void updateFont(GfxState *state);
// Clipping
void clip(GfxState *state, bool even_odd=false);
bool getTransform(double *transform);
private:
+ SvgBuilder();
+
// Pattern creation
- gchar *createPattern(GfxPattern *pattern);
- gchar *createGradient(GfxShadingPattern *shading_pattern);
- bool addStopsToGradient(Inkscape::XML::Node *gradient, Function *func, double opacity);
- bool addSamplesToGradient(Inkscape::XML::Node *gradient, SampledFunction *func,
+ gchar *_createPattern(GfxPattern *pattern);
+ gchar *_createGradient(GfxShadingPattern *shading_pattern);
+ bool _addStopsToGradient(Inkscape::XML::Node *gradient, Function *func, double opacity);
+ bool _addSamplesToGradient(Inkscape::XML::Node *gradient, SampledFunction *func,
double offset0, double offset1, double opacity);
- gchar *createTilingPattern(GfxTilingPattern *tiling_pattern);
+ gchar *_createTilingPattern(GfxTilingPattern *tiling_pattern);
+ // Image/mask creation
+ Inkscape::XML::Node *_createImage(Stream *str, int width, int height,
+ GfxImageColorMap *color_map, int *mask_colors,
+ bool alpha_only=false, bool invert_alpha=false);
// Style setting
- SPCSSAttr *setStyle(GfxState *state, bool fill, bool stroke, bool even_odd);
- void setStrokeStyle(SPCSSAttr *css, GfxState *state);
- void setFillStyle(SPCSSAttr *css, GfxState *state, bool even_odd);
-
- std::vector<int> groupDepth; // Depth of nesting groups
-
- SPDocument *doc;
- Inkscape::XML::Document *xml_doc;
- Inkscape::XML::Node *root; // Root node from the point of view of this SvgBuilder
- Inkscape::XML::Node *container; // Current container (group/pattern/mask)
- double width, height; // Document size in px
+ SPCSSAttr *_setStyle(GfxState *state, bool fill, bool stroke, bool even_odd=false);
+ void _setStrokeStyle(SPCSSAttr *css, GfxState *state);
+ void _setFillStyle(SPCSSAttr *css, GfxState *state, bool even_odd);
+
+ void _flushText(); // Write buffered text into doc
+
+ std::vector<int> _group_depth; // Depth of nesting groups
+
+ SPCSSAttr *_font_style; // Current font style
+ GfxFont *_current_font;
+ char *_font_specification;
+ bool _need_font_update;
+ NR::Matrix _text_matrix;
+ std::vector<SvgGlyph> _glyphs; // Added characters
+ bool _in_text_object; // Whether we are inside a text object
+ bool _invalidated_style;
+ GfxState *_current_state;
+
+ SPDocument *_doc;
+ Inkscape::XML::Document *_xml_doc;
+ Inkscape::XML::Node *_root; // Root node from the point of view of this SvgBuilder
+ Inkscape::XML::Node *_container; // Current container (group/pattern/mask)
+ double _width, _height; // Document size in px
};
-} } } /* namespace Inkscape, Extension, Internal, PdfInput */
+} } } /* namespace Inkscape, Extension, Internal */
#endif /* HAVE_POPPLER */