diff --git a/libs/flake/tests/TestSvgText.cpp b/libs/flake/tests/TestSvgText.cpp
index e6e9969732..d2bb6bd225 100644
--- a/libs/flake/tests/TestSvgText.cpp
+++ b/libs/flake/tests/TestSvgText.cpp
@@ -1,1292 +1,1328 @@
 /*
  *  Copyright (c) 2017 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "TestSvgText.h"
 
 #include <QTest>
 
 #include "SvgParserTestingUtils.h"
 #include <text/KoSvgText.h>
 #include <text/KoSvgTextProperties.h>
 #include "KoSvgTextShapeMarkupConverter.h"
 
 #include <SvgLoadingContext.h>
 #include <SvgGraphicContext.h>
 #include <QFont>
 
 void addProp(SvgLoadingContext &context,
              KoSvgTextProperties &props,
              const QString &attribute,
              const QString &value,
              KoSvgTextProperties::PropertyId id,
              int newValue)
 {
     props.parseSvgTextAttribute(context, attribute, value);
     if (props.property(id).toInt() != newValue) {
         qDebug() << "Failed to load the property:";
         qDebug() << ppVar(attribute) << ppVar(value);
         qDebug() << ppVar(newValue);
         qDebug() << ppVar(props.property(id));
         QFAIL("Fail :(");
     }
 }
 
 void addProp(SvgLoadingContext &context,
              KoSvgTextProperties &props,
              const QString &attribute,
              const QString &value,
              KoSvgTextProperties::PropertyId id,
              KoSvgText::AutoValue newValue)
 {
     props.parseSvgTextAttribute(context, attribute, value);
     if (props.property(id).value<KoSvgText::AutoValue>() != newValue) {
         qDebug() << "Failed to load the property:";
         qDebug() << ppVar(attribute) << ppVar(value);
         qDebug() << ppVar(newValue);
         qDebug() << ppVar(props.property(id));
         QFAIL("Fail :(");
     }
     QCOMPARE(props.property(id), QVariant::fromValue(newValue));
 }
 
 void addProp(SvgLoadingContext &context,
              KoSvgTextProperties &props,
              const QString &attribute,
              const QString &value,
              KoSvgTextProperties::PropertyId id,
              qreal newValue)
 {
     props.parseSvgTextAttribute(context, attribute, value);
     if (props.property(id).toReal() != newValue) {
         qDebug() << "Failed to load the property:";
         qDebug() << ppVar(attribute) << ppVar(value);
         qDebug() << ppVar(newValue);
         qDebug() << ppVar(props.property(id));
         QFAIL("Fail :(");
     }
 }
 
 
 void TestSvgText::testTextProperties()
 {
     KoDocumentResourceManager resourceManager;
     SvgLoadingContext context(&resourceManager);
     context.pushGraphicsContext();
 
     KoSvgTextProperties props;
 
     addProp(context, props, "writing-mode", "tb-rl", KoSvgTextProperties::WritingModeId, KoSvgText::TopToBottom);
     addProp(context, props, "writing-mode", "rl", KoSvgTextProperties::WritingModeId, KoSvgText::RightToLeft);
 
     addProp(context, props, "glyph-orientation-vertical", "auto", KoSvgTextProperties::GlyphOrientationVerticalId, KoSvgText::AutoValue());
     addProp(context, props, "glyph-orientation-vertical", "0", KoSvgTextProperties::GlyphOrientationVerticalId, KoSvgText::AutoValue(0));
     addProp(context, props, "glyph-orientation-vertical", "90", KoSvgTextProperties::GlyphOrientationVerticalId, KoSvgText::AutoValue(M_PI_2));
     addProp(context, props, "glyph-orientation-vertical", "95", KoSvgTextProperties::GlyphOrientationVerticalId, KoSvgText::AutoValue(M_PI_2));
     addProp(context, props, "glyph-orientation-vertical", "175", KoSvgTextProperties::GlyphOrientationVerticalId, KoSvgText::AutoValue(M_PI));
     addProp(context, props, "glyph-orientation-vertical", "280", KoSvgTextProperties::GlyphOrientationVerticalId, KoSvgText::AutoValue(3 * M_PI_2));
     addProp(context, props, "glyph-orientation-vertical", "350", KoSvgTextProperties::GlyphOrientationVerticalId, KoSvgText::AutoValue(0));
     addProp(context, props, "glyph-orientation-vertical", "105", KoSvgTextProperties::GlyphOrientationVerticalId, KoSvgText::AutoValue(M_PI_2));
 
     addProp(context, props, "glyph-orientation-horizontal", "0", KoSvgTextProperties::GlyphOrientationHorizontalId, 0.0);
     addProp(context, props, "glyph-orientation-horizontal", "90", KoSvgTextProperties::GlyphOrientationHorizontalId, M_PI_2);
     addProp(context, props, "glyph-orientation-horizontal", "95", KoSvgTextProperties::GlyphOrientationHorizontalId, M_PI_2);
     addProp(context, props, "glyph-orientation-horizontal", "175", KoSvgTextProperties::GlyphOrientationHorizontalId, M_PI);
     addProp(context, props, "glyph-orientation-horizontal", "280", KoSvgTextProperties::GlyphOrientationHorizontalId, 3 * M_PI_2);
 
     addProp(context, props, "direction", "rtl", KoSvgTextProperties::WritingModeId, KoSvgText::DirectionRightToLeft);
     addProp(context, props, "unicode-bidi", "embed", KoSvgTextProperties::UnicodeBidiId, KoSvgText::BidiEmbed);
     addProp(context, props, "unicode-bidi", "bidi-override", KoSvgTextProperties::UnicodeBidiId, KoSvgText::BidiOverride);
 
 
     addProp(context, props, "text-anchor", "middle", KoSvgTextProperties::TextAnchorId, KoSvgText::AnchorMiddle);
     addProp(context, props, "dominant-baseline", "ideographic", KoSvgTextProperties::DominantBaselineId, KoSvgText::DominantBaselineIdeographic);
     addProp(context, props, "alignment-baseline", "alphabetic", KoSvgTextProperties::AlignmentBaselineId, KoSvgText::AlignmentBaselineAlphabetic);
     addProp(context, props, "baseline-shift", "sub", KoSvgTextProperties::BaselineShiftModeId, KoSvgText::ShiftSub);
     addProp(context, props, "baseline-shift", "super", KoSvgTextProperties::BaselineShiftModeId, KoSvgText::ShiftSuper);
     addProp(context, props, "baseline-shift", "baseline", KoSvgTextProperties::BaselineShiftModeId, KoSvgText::ShiftNone);
 
     addProp(context, props, "baseline-shift", "10%", KoSvgTextProperties::BaselineShiftModeId, KoSvgText::ShiftPercentage);
     QCOMPARE(props.property(KoSvgTextProperties::BaselineShiftValueId).toDouble(), 0.1);
 
     context.currentGC()->font.setPointSizeF(180);
 
     addProp(context, props, "baseline-shift", "36", KoSvgTextProperties::BaselineShiftModeId, KoSvgText::ShiftPercentage);
     QCOMPARE(props.property(KoSvgTextProperties::BaselineShiftValueId).toDouble(), 0.2);
 
     addProp(context, props, "kerning", "auto", KoSvgTextProperties::KerningId, KoSvgText::AutoValue());
     addProp(context, props, "kerning", "20", KoSvgTextProperties::KerningId, KoSvgText::AutoValue(20.0));
 
     addProp(context, props, "letter-spacing", "normal", KoSvgTextProperties::LetterSpacingId, KoSvgText::AutoValue());
     addProp(context, props, "letter-spacing", "20", KoSvgTextProperties::LetterSpacingId, KoSvgText::AutoValue(20.0));
 
     addProp(context, props, "word-spacing", "normal", KoSvgTextProperties::WordSpacingId, KoSvgText::AutoValue());
     addProp(context, props, "word-spacing", "20", KoSvgTextProperties::WordSpacingId, KoSvgText::AutoValue(20.0));
 }
 
 void TestSvgText::testDefaultTextProperties()
 {
     KoSvgTextProperties props;
 
     QVERIFY(props.isEmpty());
     QVERIFY(!props.hasProperty(KoSvgTextProperties::UnicodeBidiId));
 
     QVERIFY(KoSvgTextProperties::defaultProperties().hasProperty(KoSvgTextProperties::UnicodeBidiId));
     QCOMPARE(KoSvgTextProperties::defaultProperties().property(KoSvgTextProperties::UnicodeBidiId).toInt(), int(KoSvgText::BidiNormal));
 
     props = KoSvgTextProperties::defaultProperties();
 
     QVERIFY(props.hasProperty(KoSvgTextProperties::UnicodeBidiId));
     QCOMPARE(props.property(KoSvgTextProperties::UnicodeBidiId).toInt(), int(KoSvgText::BidiNormal));
 }
 
 void TestSvgText::testTextPropertiesDifference()
 {
     using namespace KoSvgText;
 
     KoSvgTextProperties props;
 
     props.setProperty(KoSvgTextProperties::WritingModeId, RightToLeft);
     props.setProperty(KoSvgTextProperties::DirectionId, DirectionRightToLeft);
     props.setProperty(KoSvgTextProperties::UnicodeBidiId, BidiEmbed);
     props.setProperty(KoSvgTextProperties::TextAnchorId, AnchorEnd);
     props.setProperty(KoSvgTextProperties::DominantBaselineId, DominantBaselineNoChange);
     props.setProperty(KoSvgTextProperties::AlignmentBaselineId, AlignmentBaselineIdeographic);
     props.setProperty(KoSvgTextProperties::BaselineShiftModeId, ShiftPercentage);
     props.setProperty(KoSvgTextProperties::BaselineShiftValueId, 0.5);
     props.setProperty(KoSvgTextProperties::KerningId, fromAutoValue(AutoValue(10)));
     props.setProperty(KoSvgTextProperties::GlyphOrientationVerticalId, fromAutoValue(AutoValue(90)));
     props.setProperty(KoSvgTextProperties::GlyphOrientationHorizontalId, fromAutoValue(AutoValue(180)));
     props.setProperty(KoSvgTextProperties::LetterSpacingId, fromAutoValue(AutoValue(20)));
     props.setProperty(KoSvgTextProperties::WordSpacingId, fromAutoValue(AutoValue(30)));
 
     KoSvgTextProperties newProps = props;
 
     newProps.setProperty(KoSvgTextProperties::KerningId, fromAutoValue(AutoValue(11)));
     newProps.setProperty(KoSvgTextProperties::LetterSpacingId, fromAutoValue(AutoValue(21)));
 
     KoSvgTextProperties diff = newProps.ownProperties(props);
 
     QVERIFY(diff.hasProperty(KoSvgTextProperties::KerningId));
     QVERIFY(diff.hasProperty(KoSvgTextProperties::LetterSpacingId));
 
     QVERIFY(!diff.hasProperty(KoSvgTextProperties::WritingModeId));
     QVERIFY(!diff.hasProperty(KoSvgTextProperties::DirectionId));
 
 
 }
 
 void TestSvgText::testParseFontStyles()
 {
     const QString data =
             "<text x=\"7\" y=\"7\""
             "    font-family=\"Verdana , \'Times New Roman\', serif\" font-size=\"15\" font-style=\"oblique\" fill=\"blue\""
             "    font-stretch=\"extra-condensed\""
             "    font-size-adjust=\"0.56\"" //// not implemented! should issue a warning!
             "    font=\"bold italic large Palatino, serif\"" //// not implemented! should issue a warning!
             "    font-variant=\"small-caps\" font-weight=\"600\" >"
             "    Hello, out there"
             "</text>";
 
     KoXmlDocument doc;
     QVERIFY(doc.setContent(data.toLatin1()));
     KoXmlElement root = doc.documentElement();
 
     KoDocumentResourceManager resourceManager;
     SvgLoadingContext context(&resourceManager);
     context.pushGraphicsContext();
 
     SvgStyles styles = context.styleParser().collectStyles(root);
     context.styleParser().parseFont(styles);
 
     //QCOMPARE(styles.size(), 3);
 
     // TODO: multiple fonts!
     QCOMPARE(context.currentGC()->font.family(), QString("Verdana"));
 
     {
         QStringList expectedFonts = {"Verdana", "Times New Roman", "serif"};
         QCOMPARE(context.currentGC()->fontFamiliesList, expectedFonts);
     }
 
     QCOMPARE(context.currentGC()->font.pointSizeF(), 15.0);
     QCOMPARE(context.currentGC()->font.style(), QFont::StyleOblique);
     QCOMPARE(context.currentGC()->font.capitalization(), QFont::SmallCaps);
     QCOMPARE(context.currentGC()->font.weight(), 66);
 
     {
         SvgStyles fontModifier;
         fontModifier["font-weight"] = "bolder";
         context.styleParser().parseFont(fontModifier);
         QCOMPARE(context.currentGC()->font.weight(), 75);
     }
 
     {
         SvgStyles fontModifier;
         fontModifier["font-weight"] = "lighter";
         context.styleParser().parseFont(fontModifier);
         QCOMPARE(context.currentGC()->font.weight(), 66);
     }
 
     QCOMPARE(context.currentGC()->font.stretch(), int(QFont::ExtraCondensed));
 
     {
         SvgStyles fontModifier;
         fontModifier["font-stretch"] = "narrower";
         context.styleParser().parseFont(fontModifier);
         QCOMPARE(context.currentGC()->font.stretch(), int(QFont::UltraCondensed));
     }
 
     {
         SvgStyles fontModifier;
         fontModifier["font-stretch"] = "wider";
         context.styleParser().parseFont(fontModifier);
         QCOMPARE(context.currentGC()->font.stretch(), int(QFont::ExtraCondensed));
     }
 
     {
         SvgStyles fontModifier;
         fontModifier["text-decoration"] = "underline";
         context.styleParser().parseFont(fontModifier);
         QCOMPARE(context.currentGC()->font.underline(), true);
     }
 
     {
         SvgStyles fontModifier;
         fontModifier["text-decoration"] = "overline";
         context.styleParser().parseFont(fontModifier);
         QCOMPARE(context.currentGC()->font.overline(), true);
     }
 
     {
         SvgStyles fontModifier;
         fontModifier["text-decoration"] = "line-through";
         context.styleParser().parseFont(fontModifier);
         QCOMPARE(context.currentGC()->font.strikeOut(), true);
     }
 
     {
         SvgStyles fontModifier;
         fontModifier["text-decoration"] = " line-through overline";
         context.styleParser().parseFont(fontModifier);
         QCOMPARE(context.currentGC()->font.underline(), false);
         QCOMPARE(context.currentGC()->font.strikeOut(), true);
         QCOMPARE(context.currentGC()->font.overline(), true);
     }
 
 }
 
 void TestSvgText::testParseTextStyles()
 {
     const QString data =
             "<text x=\"7\" y=\"7\""
             "    font-family=\"Verdana\" font-size=\"15\" font-style=\"oblique\" fill=\"blue\""
             "    writing-mode=\"tb-rl\" "
             "    glyph-orientation-vertical=\"90\" >"
             "    Hello, out there"
             "</text>";
 
     KoXmlDocument doc;
     QVERIFY(doc.setContent(data.toLatin1()));
     KoXmlElement root = doc.documentElement();
 
     KoDocumentResourceManager resourceManager;
     SvgLoadingContext context(&resourceManager);
     context.pushGraphicsContext();
 
     SvgStyles styles = context.styleParser().collectStyles(root);
     context.styleParser().parseFont(styles);
 
     QCOMPARE(context.currentGC()->font.family(), QString("Verdana"));
 
     KoSvgTextProperties &props = context.currentGC()->textProperties;
 
     QCOMPARE(props.property(KoSvgTextProperties::WritingModeId).toInt(), int(KoSvgText::TopToBottom));
     QCOMPARE(props.property(KoSvgTextProperties::GlyphOrientationVerticalId).value<KoSvgText::AutoValue>(), KoSvgText::AutoValue(M_PI_2));
 
 }
 
 #include <text/KoSvgTextShape.h>
 #include <text/KoSvgTextChunkShape.h>
 #include <text/KoSvgTextChunkShapeLayoutInterface.h>
 
 void TestSvgText::testSimpleText()
 {
     const QString data =
             "<svg width=\"100px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<g id=\"test\">"
 
             "    <rect id=\"boundingRect\" x=\"4\" y=\"5\" width=\"89\" height=\"19\""
             "        fill=\"none\" stroke=\"red\"/>"
 
             "    <text id=\"testRect\" x=\"7\" y=\"27\""
             "        font-family=\"DejaVu Sans\" font-size=\"15\" fill=\"blue\" >"
             "        Hello, out there!"
             "    </text>"
 
             "</g>"
 
             "</svg>";
 
     QFont testFont("DejaVu Sans");
     if (!QFontInfo(testFont).exactMatch()) {
         QEXPECT_FAIL(0, "DejaVu Sans is *not* found! Text rendering might be broken!", Continue);
     }
 
     SvgRenderTester t (data);
     t.test_standard("text_simple", QSize(175, 40), 72.0);
 
     KoShape *shape = t.findShape("testRect");
     KoSvgTextChunkShape *chunkShape = dynamic_cast<KoSvgTextChunkShape*>(shape);
     QVERIFY(chunkShape);
 
     // root shape is not just a chunk!
     QVERIFY(dynamic_cast<KoSvgTextShape*>(shape));
 
     QCOMPARE(chunkShape->shapeCount(), 0);
     QCOMPARE(chunkShape->layoutInterface()->isTextNode(), true);
 
     QCOMPARE(chunkShape->layoutInterface()->numChars(), 17);
     QCOMPARE(chunkShape->layoutInterface()->nodeText(), QString("Hello, out there!"));
 
     QVector<KoSvgText::CharTransformation> transform = chunkShape->layoutInterface()->localCharTransformations();
     QCOMPARE(transform.size(), 1);
     QVERIFY(bool(transform[0].xPos));
     QVERIFY(bool(transform[0].yPos));
     QVERIFY(!transform[0].dxPos);
     QVERIFY(!transform[0].dyPos);
     QVERIFY(!transform[0].rotate);
 
     QCOMPARE(*transform[0].xPos, 7.0);
     QCOMPARE(*transform[0].yPos, 27.0);
 
     QVector<KoSvgTextChunkShapeLayoutInterface::SubChunk> subChunks =
             chunkShape->layoutInterface()->collectSubChunks();
 
     QCOMPARE(subChunks.size(), 1);
     QCOMPARE(subChunks[0].text.size(), 17);
     //qDebug() << ppVar(subChunks[0].text);
     //qDebug() << ppVar(subChunks[0].transformation);
     //qDebug() << ppVar(subChunks[0].format);
 
 }
 
 inline KoSvgTextChunkShape* toChunkShape(KoShape *shape) {
     KoSvgTextChunkShape *chunkShape = dynamic_cast<KoSvgTextChunkShape*>(shape);
     KIS_ASSERT(chunkShape);
     return chunkShape;
 }
 
 void TestSvgText::testComplexText()
 {
     const QString data =
             "<svg width=\"100px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<g id=\"test\">"
 
             "    <rect id=\"boundingRect\" x=\"5\" y=\"5\" width=\"89\" height=\"19\""
             "        fill=\"none\" stroke=\"red\"/>"
 
             "    <text id=\"testRect\" x=\"7\" y=\"27\" dx=\"0,1,2,3,4,5,6,7,8\""
             "        font-family=\"DejaVu Sans\" font-size=\"15\" fill=\"blue\" >"
             "        Hello, <tspan fill=\"red\" x=\"20\" y=\"46\" text-anchor=\"start\">ou"
             "t</tspan> there <![CDATA[cool cdata --> nice work]]>"
             "    </text>"
 
             "</g>"
 
             "</svg>";
 
     SvgRenderTester t (data);
     t.test_standard("text_complex", QSize(385, 56), 72.0);
 
     KoSvgTextChunkShape *baseShape = toChunkShape(t.findShape("testRect"));
     QVERIFY(baseShape);
 
     // root shape is not just a chunk!
     QVERIFY(dynamic_cast<KoSvgTextShape*>(baseShape));
 
     QCOMPARE(baseShape->shapeCount(), 4);
     QCOMPARE(baseShape->layoutInterface()->isTextNode(), false);
     QCOMPARE(baseShape->layoutInterface()->numChars(), 41);
 
     {   // chunk 0: "Hello, "
         KoSvgTextChunkShape *chunk = toChunkShape(baseShape->shapes()[0]);
 
         QCOMPARE(chunk->shapeCount(), 0);
         QCOMPARE(chunk->layoutInterface()->isTextNode(), true);
 
         QCOMPARE(chunk->layoutInterface()->numChars(), 7);
         QCOMPARE(chunk->layoutInterface()->nodeText(), QString("Hello, "));
 
         QVector<KoSvgText::CharTransformation> transform = chunk->layoutInterface()->localCharTransformations();
         QCOMPARE(transform.size(), 7);
         QVERIFY(bool(transform[0].xPos));
         QVERIFY(!bool(transform[1].xPos));
 
         for (int i = 0; i < 7; i++) {
             QVERIFY(!i || bool(transform[i].dxPos));
 
             if (i) {
                 QCOMPARE(*transform[i].dxPos, qreal(i));
             }
         }
 
         QVector<KoSvgTextChunkShapeLayoutInterface::SubChunk> subChunks =
                 chunk->layoutInterface()->collectSubChunks();
 
         QCOMPARE(subChunks.size(), 7);
         QCOMPARE(subChunks[0].text.size(), 1);
         QCOMPARE(*subChunks[0].transformation.xPos, 7.0);
         QVERIFY(!subChunks[1].transformation.xPos);
     }
 
     {   // chunk 1: "out"
         KoSvgTextChunkShape *chunk = toChunkShape(baseShape->shapes()[1]);
 
         QCOMPARE(chunk->shapeCount(), 0);
         QCOMPARE(chunk->layoutInterface()->isTextNode(), true);
 
         QCOMPARE(chunk->layoutInterface()->numChars(), 3);
         QCOMPARE(chunk->layoutInterface()->nodeText(), QString("out"));
 
         QVector<KoSvgText::CharTransformation> transform = chunk->layoutInterface()->localCharTransformations();
         QCOMPARE(transform.size(), 2);
         QVERIFY(bool(transform[0].xPos));
         QVERIFY(!bool(transform[1].xPos));
 
         for (int i = 0; i < 2; i++) {
             QVERIFY(bool(transform[i].dxPos));
             QCOMPARE(*transform[i].dxPos, qreal(i + 7));
         }
 
         QVector<KoSvgTextChunkShapeLayoutInterface::SubChunk> subChunks =
                 chunk->layoutInterface()->collectSubChunks();
 
         QCOMPARE(subChunks.size(), 2);
         QCOMPARE(subChunks[0].text.size(), 1);
         QCOMPARE(subChunks[1].text.size(), 2);
     }
 
     {   // chunk 2: " there "
         KoSvgTextChunkShape *chunk = toChunkShape(baseShape->shapes()[2]);
 
         QCOMPARE(chunk->shapeCount(), 0);
         QCOMPARE(chunk->layoutInterface()->isTextNode(), true);
 
         QCOMPARE(chunk->layoutInterface()->numChars(), 7);
         QCOMPARE(chunk->layoutInterface()->nodeText(), QString(" there "));
 
         QVector<KoSvgText::CharTransformation> transform = chunk->layoutInterface()->localCharTransformations();
         QCOMPARE(transform.size(), 0);
 
         QVector<KoSvgTextChunkShapeLayoutInterface::SubChunk> subChunks =
                 chunk->layoutInterface()->collectSubChunks();
 
         QCOMPARE(subChunks.size(), 1);
         QCOMPARE(subChunks[0].text.size(), 7);
     }
 
     {   // chunk 3: "cool cdata --> nice work"
         KoSvgTextChunkShape *chunk = toChunkShape(baseShape->shapes()[3]);
 
         QCOMPARE(chunk->shapeCount(), 0);
         QCOMPARE(chunk->layoutInterface()->isTextNode(), true);
 
         QCOMPARE(chunk->layoutInterface()->numChars(), 24);
         QCOMPARE(chunk->layoutInterface()->nodeText(), QString("cool cdata --> nice work"));
 
         QVector<KoSvgText::CharTransformation> transform = chunk->layoutInterface()->localCharTransformations();
         QCOMPARE(transform.size(), 0);
 
         QVector<KoSvgTextChunkShapeLayoutInterface::SubChunk> subChunks =
                 chunk->layoutInterface()->collectSubChunks();
 
         QCOMPARE(subChunks.size(), 1);
         QCOMPARE(subChunks[0].text.size(), 24);
     }
 }
 
 void TestSvgText::testHindiText()
 {
     const QString data =
             "<svg width=\"100px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<g id=\"test\">"
 
             "    <rect id=\"boundingRect\" x=\"4\" y=\"5\" width=\"89\" height=\"19\""
             "        fill=\"none\" stroke=\"red\"/>"
 
             "    <text id=\"testRect\" x=\"4\" y=\"24\""
             "        font-family=\"FreeSans\" font-size=\"15\" fill=\"blue\" >"
             "मौखिक रूप से हिंदी के काफी सामान"
             "    </text>"
 
             "</g>"
 
             "</svg>";
 
     SvgRenderTester t (data);
 
     QFont testFont("FreeSans");
     if (!QFontInfo(testFont).exactMatch()) {
 #ifdef USE_ROUND_TRIP
             return;
 #else
             QEXPECT_FAIL(0, "FreeSans found is *not* found! Hindi rendering might be broken!", Continue);
 #endif
     }
 
     t.test_standard("text_hindi", QSize(260, 30), 72);
 }
 
 void TestSvgText::testTextBaselineShift()
 {
     const QString data =
             "<svg width=\"100px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<g id=\"test\">"
 
             "    <rect id=\"boundingRect\" x=\"5\" y=\"5\" width=\"89\" height=\"19\""
             "        fill=\"none\" stroke=\"red\"/>"
 
             "    <text id=\"testRect\" x=\"4\" y=\"29\" "
             "        font-family=\"DejaVu Sans\" font-size=\"15\" fill=\"blue\" >"
 
             "        <tspan>text<tspan baseline-shift=\"super\">super </tspan>normal<tspan baseline-shift=\"sub\">sub</tspan></tspan>"
 
             "    </text>"
 
             "</g>"
 
             "</svg>";
 
     SvgRenderTester t (data);
 
     t.test_standard("text_baseline_shift", QSize(180, 40), 72);
 
     KoSvgTextChunkShape *baseShape = toChunkShape(t.findShape("testRect"));
     QVERIFY(baseShape);
 
     // root shape is not just a chunk!
     QVERIFY(dynamic_cast<KoSvgTextShape*>(baseShape));
 
 }
 
 void TestSvgText::testTextSpacing()
 {
     const QString data =
             "<svg width=\"100px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<g id=\"test\">"
 
             "    <rect id=\"boundingRect\" x=\"5\" y=\"5\" width=\"89\" height=\"19\""
             "        fill=\"none\" stroke=\"red\"/>"
 
             "    <text id=\"testRect\" x=\"5\" y=\"24\" "
             "        font-family=\"DejaVu Sans\" font-size=\"15\" fill=\"blue\" >"
 
             "        <tspan x=\"5\" dy=\"0.0em\">Lorem ipsum</tspan>"
             "        <tspan x=\"5\" dy=\"1.5em\" letter-spacing=\"4.0\">Lorem ipsum (ls=4)</tspan>"
             "        <tspan x=\"5\" dy=\"1.5em\" letter-spacing=\"-2.0\">Lorem ipsum (ls=-2)</tspan>"
 
             "        <tspan x=\"5\" dy=\"2.0em\">Lorem ipsum</tspan>"
             "        <tspan x=\"5\" dy=\"1.5em\" word-spacing=\"4.0\">Lorem ipsum (ws=4)</tspan>"
             "        <tspan x=\"5\" dy=\"1.5em\" word-spacing=\"-2.0\">Lorem ipsum (ws=-2)</tspan>"
 
             "        <tspan x=\"5\" dy=\"2.0em\">Lorem ipsum</tspan>"
             "        <tspan x=\"5\" dy=\"1.5em\" kerning=\"0.0\">Lorem ipsum (k=0)</tspan>"
             "        <tspan x=\"5\" dy=\"1.5em\" kerning=\"2.0\">Lorem ipsum (k=2)</tspan>"
             "        <tspan x=\"5\" dy=\"1.5em\" kerning=\"2.0\" letter-spacing=\"2.0\">Lorem ipsum (k=2,ls=2)</tspan>"
 
             "    </text>"
 
             "</g>"
 
             "</svg>";
 
     SvgRenderTester t (data);
     t.setFuzzyThreshold(5);
     t.test_standard("text_letter_word_spacing", QSize(340, 250), 72.0);
 
     KoSvgTextChunkShape *baseShape = toChunkShape(t.findShape("testRect"));
     QVERIFY(baseShape);
 
     // root shape is not just a chunk!
     QVERIFY(dynamic_cast<KoSvgTextShape*>(baseShape));
 
 }
 
+void TestSvgText::testTextTabSpacing()
+{
+    const QString data =
+            "<svg width=\"100px\" height=\"30px\""
+            "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
+
+            "<g id=\"test\">"
+
+            "    <rect id=\"boundingRect\" x=\"5\" y=\"5\" width=\"89\" height=\"120\""
+            "        fill=\"none\" stroke=\"red\"/>"
+
+            "    <text id=\"testRect\" x=\"5\" y=\"24\" "
+            "        font-family=\"DejaVu Sans\" font-size=\"15\" fill=\"blue\" >"
+
+            "        <tspan x=\"10\" dy=\"1.0em\">  Lorem</tspan>"
+            "        <tspan x=\"10\" dy=\"2.0em\">	ipsum</tspan>"
+            "        <tspan x=\"10\" dy=\"2.0em\">dolor  sit	amet,</tspan>"
+            "        <tspan x=\"10\" dy=\"2.0em\">		consectetur adipiscing elit.</tspan>"
+
+            "    </text>"
+
+            "</g>"
+
+            "</svg>";
+
+    SvgRenderTester t (data);
+    t.setFuzzyThreshold(5);
+    t.test_standard("text_tab_spacing", QSize(400, 170), 72.0);
+
+    KoSvgTextChunkShape *baseShape = toChunkShape(t.findShape("testRect"));
+    QVERIFY(baseShape);
+
+    // root shape is not just a chunk!
+    QVERIFY(dynamic_cast<KoSvgTextShape*>(baseShape));
+}
+
 void TestSvgText::testTextDecorations()
 {
     const QString data =
             "<svg width=\"100px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<g id=\"test\">"
 
             "    <rect id=\"boundingRect\" x=\"5\" y=\"5\" width=\"89\" height=\"19\""
             "        fill=\"none\" stroke=\"red\"/>"
 
             "    <text id=\"testRect\" x=\"4\" y=\"24\" "
             "        font-family=\"DejaVu Sans\" font-size=\"15\" fill=\"blue\" >"
 
             "        <tspan x=\"20\" dy=\"0.0em\" text-decoration=\"underline\">Lorem ipsum</tspan>"
             "        <tspan x=\"20\" dy=\"2.5em\" text-decoration=\"overline\">Lorem ipsum</tspan>"
             "        <tspan x=\"20\" dy=\"2.0em\" text-decoration=\"line-through\">Lorem ipsum</tspan>"
             "        <tspan x=\"20\" dy=\"2.0em\" text-decoration=\"underline\">Lorem <tspan fill=\"red\">ipsum</tspan> (WRONG!!!)</tspan>"
 
             "    </text>"
 
             "</g>"
 
             "</svg>";
 
     SvgRenderTester t (data);
     t.setFuzzyThreshold(5);
     t.test_standard("text_decorations", QSize(290, 135), 72.0);
 
     KoSvgTextChunkShape *baseShape = toChunkShape(t.findShape("testRect"));
     QVERIFY(baseShape);
 
     // root shape is not just a chunk!
     QVERIFY(dynamic_cast<KoSvgTextShape*>(baseShape));
 
 }
 
 void TestSvgText::testRightToLeft()
 {
     const QString data =
             "<svg width=\"100px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<g id=\"test\">"
 
             "    <rect id=\"boundingRect\" x=\"5\" y=\"5\" width=\"89\" height=\"19\""
             "        fill=\"none\" stroke=\"red\"/>"
 
             "    <text id=\"testRect\" x=\"20\" y=\"34\" "
             "        font-family=\"DejaVu Sans\" font-size=\"15\" fill=\"blue\" text-anchor=\"end\">"
 
             "        <tspan x=\"250\" dy=\"0.0em\" text-anchor=\"middle\" direction=\"rtl\">aa bb cc dd</tspan>"
             "        <tspan x=\"250\" dy=\"2.0em\" text-anchor=\"middle\" direction=\"rtl\">حادثتا السفينتين «بسين Bassein» و«فايبر Viper»</tspan>"
 
             "        <tspan x=\"250\" dy=\"2.0em\" text-anchor=\"middle\">*</tspan>"
 
             "        <tspan x=\"150\" dy=\"2.0em\" text-anchor=\"start\" direction=\"ltr\">aa bb حادثتا السفينتين بسين cc dd </tspan>"
             "        <tspan x=\"350\" dy=\"2.0em\" text-anchor=\"start\" direction=\"rtl\">aa bb حادثتا السفينتين بسين cc dd </tspan>"
 
             "        <tspan x=\"250\" dy=\"2.0em\" text-anchor=\"middle\">*</tspan>"
 
             "        <tspan x=\"150\" dy=\"2.0em\" text-anchor=\"start\" direction=\"ltr\">aa bb <tspan text-decoration=\"underline\">حادثتا</tspan> السفينتين بسين cc dd </tspan>"
             "        <tspan x=\"250\" dy=\"2.0em\" text-anchor=\"middle\" direction=\"ltr\">aa bb <tspan text-decoration=\"underline\">حادثتا</tspan> السفينتين بسين cc dd </tspan>"
             "        <tspan x=\"350\" dy=\"2.0em\" text-anchor=\"end\" direction=\"ltr\">aa bb <tspan text-decoration=\"underline\">حادثتا</tspan> السفينتين بسين cc dd </tspan>"
 
             "        <tspan x=\"250\" dy=\"2.0em\" text-anchor=\"middle\">*</tspan>"
 
             "        <tspan x=\"250\" dy=\"2.0em\" text-anchor=\"middle\" direction=\"ltr\">الناطقون: 295 مليون - 422 مليون</tspan>"
             "        <tspan x=\"250\" dy=\"2.0em\" text-anchor=\"middle\" direction=\"ltr\">Spoken: <tspan direction=\"rtl\" unicode-bidi=\"embed\">295 مليون - 422 مليون </tspan></tspan>"
 
             "        <tspan x=\"250\" dy=\"2.0em\" text-anchor=\"middle\">*</tspan>"
 
             "        <tspan x=\"250\" dy=\"2.0em\" text-anchor=\"middle\" direction=\"ltr\">aa bb <tspan direction=\"rtl\" unicode-bidi=\"bidi-override\">c1 c2 c3 c4</tspan> dd ee</tspan>"
 
 
 
             "    </text>"
 
             "</g>"
 
             "</svg>";
 
     SvgRenderTester t (data);
     t.test_standard("text_right_to_left", QSize(500,450), 72.0);
 
     KoSvgTextChunkShape *baseShape = toChunkShape(t.findShape("testRect"));
     QVERIFY(baseShape);
 
     // root shape is not just a chunk!
     QVERIFY(dynamic_cast<KoSvgTextShape*>(baseShape));
 
 }
 
 #include <QTextLayout>
 #include <QPainter>
 
 void TestSvgText::testQtBidi()
 {
     // Arabic text sample from Wikipedia:
     // https://ar.wikipedia.org/wiki/%D8%A5%D9%85%D8%A7%D8%B1%D8%A7%D8%AA_%D8%A7%D9%84%D8%B3%D8%A7%D8%AD%D9%84_%D8%A7%D9%84%D9%85%D8%AA%D8%B5%D8%A7%D9%84%D8%AD
 
     QStringList ltrText;
     ltrText << "aa bb cc dd";
     ltrText << "aa bb حادثتا السفينتين بسين cc dd";
     ltrText << "aa bb \u202ec1c2 d3d4\u202C ee ff";
 
     QStringList rtlText;
     rtlText << "حادثتا السفينتين «بسين Bassein» و«فايبر Viper»";
     rtlText << "حادثتا السفينتين «بسين aa bb cc dd» و«فايبر Viper»";
 
 
     QImage canvas(500,500,QImage::Format_ARGB32);
     QPainter gc(&canvas);
     QPointF pos(15,15);
 
 
     QVector<QStringList> textSamples;
     textSamples << ltrText;
     textSamples << rtlText;
 
     QVector<Qt::LayoutDirection> textDirections;
     textDirections << Qt::LeftToRight;
     textDirections << Qt::RightToLeft;
 
     for (int i = 0; i < textSamples.size(); i++) {
         Q_FOREACH (const QString str, textSamples[i]) {
             QTextOption option;
             option.setTextDirection(textDirections[i]);
             option.setUseDesignMetrics(true);
 
             QTextLayout layout;
 
             layout.setText(str);
             layout.setFont(QFont("serif", 15.0));
             layout.setCacheEnabled(true);
             layout.beginLayout();
 
             QTextLine line = layout.createLine();
             line.setPosition(pos);
             pos.ry() += 25;
             layout.endLayout();
             layout.draw(&gc, QPointF());
         }
     }
 
     canvas.save("test_bidi.png");
 }
 
 void TestSvgText::testQtDxDy()
 {
     QImage canvas(500,500,QImage::Format_ARGB32);
     QPainter gc(&canvas);
     QPointF pos(15,15);
 
     QTextOption option;
     option.setTextDirection(Qt::LeftToRight);
     option.setUseDesignMetrics(true);
     option.setWrapMode(QTextOption::WrapAnywhere);
 
     QTextLayout layout;
 
     layout.setText("aa bb cc dd ee ff");
     layout.setFont(QFont("serif", 15.0));
     layout.setCacheEnabled(true);
     layout.beginLayout();
     layout.setTextOption(option);
 
     {
         QTextLine line = layout.createLine();
         line.setPosition(pos);
         line.setNumColumns(4);
     }
     pos.ry() += 25;
     pos.rx() += 30;
     {
         QTextLine line = layout.createLine();
         line.setPosition(pos);
     }
 
     layout.endLayout();
     layout.draw(&gc, QPointF());
 
 
     canvas.save("test_dxdy.png");
 }
 
 
 void TestSvgText::testTextOutlineSolid()
 {
     const QString data =
             "<svg width=\"100px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<g id=\"test\">"
 
             "    <rect id=\"boundingRect\" x=\"4\" y=\"5\" width=\"89\" height=\"19\""
             "        fill=\"none\" stroke=\"red\"/>"
 
             "    <text id=\"testRect\" x=\"2\" y=\"24\""
             "        font-family=\"DejaVu Sans\" font-size=\"15\" fill=\"blue\" stroke=\"red\" stroke-width=\"1\">"
             "        SA"
             "    </text>"
 
             "</g>"
 
             "</svg>";
 
     SvgRenderTester t (data);
     t.test_standard("text_outline_solid", QSize(30, 30), 72.0);
 }
 
 void TestSvgText::testNbspHandling()
 {
     const QString data =
             "<svg width=\"100px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<g id=\"test\">"
 
             "    <rect id=\"boundingRect\" x=\"4\" y=\"5\" width=\"89\" height=\"19\""
             "        fill=\"none\" stroke=\"red\"/>"
 
             "    <text id=\"testRect\" x=\"2\" y=\"24\""
             "        font-family=\"DejaVu Sans\" font-size=\"15\" fill=\"blue\" stroke=\"red\" stroke-width=\"1\">"
             "        S\u00A0A"
             "    </text>"
 
             "</g>"
 
             "</svg>";
 
     SvgRenderTester t (data);
     t.test_standard("text_nbsp", QSize(30, 30), 72.0);
 }
 
 void TestSvgText::testMulticolorText()
 {
     const QString data =
             "<svg width=\"100px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<g id=\"test\">"
 
             "    <rect id=\"boundingRect\" x=\"4\" y=\"5\" width=\"89\" height=\"19\""
             "        fill=\"none\" stroke=\"red\"/>"
 
             "    <text id=\"testRect\" x=\"2\" y=\"24\""
             "        font-family=\"DejaVu Sans\" font-size=\"15\" fill=\"blue\" >"
             "        S<tspan fill=\"red\">A</tspan>"
             "    </text>"
 
             "</g>"
 
             "</svg>";
 
     SvgRenderTester t (data);
     t.setFuzzyThreshold(5);
     t.test_standard("text_multicolor", QSize(30, 30), 72.0);
 }
 
 #include <KoColorBackground.h>
 
 void TestSvgText::testConvertToStrippedSvg()
 {
     const QString data =
             "<svg width=\"100px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<g id=\"test\">"
 
             "    <rect id=\"boundingRect\" x=\"4\" y=\"5\" width=\"89\" height=\"19\""
             "        fill=\"none\" stroke=\"red\"/>"
 
             "    <text transform=\"translate(2)\" id=\"testRect\" x=\"2\" y=\"24\""
             "        font-family=\"DejaVu Sans\" font-size=\"15\" fill=\"blue\" >"
             "        S<tspan fill=\"red\">A</tspan><![CDATA[some stuff<><><<<>]]>"
             "    </text>"
 
             "</g>"
 
             "</svg>";
 
     SvgRenderTester t (data);
     t.parser.setResolution(QRectF(QPointF(), QSizeF(30,30)) /* px */, 72.0/* ppi */);
     t.run();
 
     KoSvgTextShape *baseShape = dynamic_cast<KoSvgTextShape*>(t.findShape("testRect"));
     QVERIFY(baseShape);
 
     {
         KoColorBackground *bg = dynamic_cast<KoColorBackground*>(baseShape->background().data());
         QVERIFY(bg);
         QCOMPARE(bg->color(), QColor(Qt::blue));
     }
 
     KoSvgTextShapeMarkupConverter converter(baseShape);
 
     QString svgText;
     QString stylesText;
     QVERIFY(converter.convertToSvg(&svgText, &stylesText));
 
     QCOMPARE(stylesText, QString("<defs/>"));
     QCOMPARE(svgText, QString("<text fill=\"#0000ff\" font-family=\"DejaVu Sans\" font-size=\"15\"><tspan x=\"2\" y=\"24\">S</tspan><tspan fill=\"#ff0000\">A</tspan><tspan>some stuff&lt;&gt;&lt;&gt;&lt;&lt;&lt;&gt;</tspan></text>"));
 
     // test loading
 
     svgText = "<text fill=\"#00ff00\" font-family=\"DejaVu Sans\" font-size=\"19\"><tspan x=\"2\" y=\"24\">S</tspan><tspan fill=\"#ff0000\">A</tspan><tspan>some stuff&lt;&gt;&lt;&gt;&lt;&lt;&lt;&gt;</tspan></text>";
 
     QVERIFY(converter.convertFromSvg(svgText, stylesText, QRectF(0,0,30,30), 72.0));
 
     {
         KoColorBackground *bg = dynamic_cast<KoColorBackground*>(baseShape->background().data());
         QVERIFY(bg);
         QCOMPARE(bg->color(), QColor(Qt::green));
     }
 
     {
         KoSvgTextProperties props = baseShape->textProperties();
         QVERIFY(props.hasProperty(KoSvgTextProperties::FontSizeId));
 
         const qreal fontSize = props.property(KoSvgTextProperties::FontSizeId).toReal();
         QCOMPARE(fontSize, 19.0);
     }
 
     QCOMPARE(baseShape->shapeCount(), 3);
 }
 
 void TestSvgText::testConvertToStrippedSvgNullOrigin()
 {
     const QString data =
             "<svg width=\"100px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<g id=\"test\">"
 
             "    <rect id=\"boundingRect\" x=\"4\" y=\"5\" width=\"89\" height=\"19\""
             "        fill=\"none\" stroke=\"red\"/>"
 
             "    <text transform=\"translate(2)\" id=\"testRect\" x=\"0\" y=\"0\""
             "        font-family=\"DejaVu Sans\" font-size=\"15\" fill=\"blue\" >"
             "        S<tspan fill=\"red\">A</tspan><![CDATA[some stuff<><><<<>]]>"
             "    </text>"
 
             "</g>"
 
             "</svg>";
 
     SvgRenderTester t (data);
     t.parser.setResolution(QRectF(QPointF(), QSizeF(30,30)) /* px */, 72.0/* ppi */);
     t.run();
 
     KoSvgTextShape *baseShape = dynamic_cast<KoSvgTextShape*>(t.findShape("testRect"));
     QVERIFY(baseShape);
 
     KoSvgTextShapeMarkupConverter converter(baseShape);
 
     QString svgText;
     QString stylesText;
     QVERIFY(converter.convertToSvg(&svgText, &stylesText));
 
     QCOMPARE(stylesText, QString("<defs/>"));
     QCOMPARE(svgText, QString("<text fill=\"#0000ff\" font-family=\"DejaVu Sans\" font-size=\"15\"><tspan x=\"0\" y=\"0\">S</tspan><tspan fill=\"#ff0000\">A</tspan><tspan>some stuff&lt;&gt;&lt;&gt;&lt;&lt;&lt;&gt;</tspan></text>"));
 }
 
 void TestSvgText::testConvertFromIncorrectStrippedSvg()
 {
     QScopedPointer<KoSvgTextShape> baseShape(new KoSvgTextShape());
 
     KoSvgTextShapeMarkupConverter converter(baseShape.data());
 
     QString svgText;
     QString stylesText;
 
     svgText = "<text>blah text</text>";
     QVERIFY(converter.convertFromSvg(svgText, stylesText, QRectF(0,0,30,30), 72.0));
     QCOMPARE(converter.errors().size(), 0);
 
     svgText = "<text>>><<><blah text</text>";
     QVERIFY(!converter.convertFromSvg(svgText, stylesText, QRectF(0,0,30,30), 72.0));
     qDebug() << ppVar(converter.errors());
     QCOMPARE(converter.errors().size(), 1);
 
     svgText = "<notext>blah text</notext>";
     QVERIFY(!converter.convertFromSvg(svgText, stylesText, QRectF(0,0,30,30), 72.0));
     qDebug() << ppVar(converter.errors());
     QCOMPARE(converter.errors().size(), 1);
 
     svgText = "<defs/>";
     QVERIFY(!converter.convertFromSvg(svgText, stylesText, QRectF(0,0,30,30), 72.0));
     qDebug() << ppVar(converter.errors());
     QCOMPARE(converter.errors().size(), 1);
 }
 
 void TestSvgText::testEmptyTextChunk()
 {
     const QString data =
             "<svg width=\"100px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<g id=\"test\">"
 
             "    <rect id=\"boundingRect\" x=\"4\" y=\"5\" width=\"89\" height=\"19\""
             "        fill=\"none\" stroke=\"red\"/>"
 
             "    <text id=\"testRect\" x=\"2\" y=\"24\""
             "        font-family=\"DejaVu Sans\" font-size=\"15\" fill=\"blue\" >"
             "        " // no actual text! should not crash!
             "    </text>"
 
             "</g>"
 
             "</svg>";
 
     SvgRenderTester t (data);
 
     // it just shouldn't assert or fail when seeing an empty text block
     t.parser.setResolution(QRectF(QPointF(), QSizeF(30,30)) /* px */, 72.0/* ppi */);
     t.run();
 }
 
 void TestSvgText::testTrailingWhitespace()
 {
     QStringList chunkA;
     chunkA << "aaa";
     chunkA << " aaa";
     chunkA << "aaa ";
     chunkA << " aaa ";
 
     QStringList chunkB;
     chunkB << "bbb";
     chunkB << " bbb";
     chunkB << "bbb ";
     chunkB << " bbb ";
 
     QStringList linkChunk;
     linkChunk << "";
     linkChunk << " ";
     linkChunk << "<tspan></tspan>";
     linkChunk << "<tspan> </tspan>";
 
 
     const QString dataTemplate =
             "<svg width=\"100px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<g id=\"test\">"
 
             "    <rect id=\"boundingRect\" x=\"4\" y=\"5\" width=\"89\" height=\"19\""
             "        fill=\"none\" stroke=\"red\"/>"
 
             "    <text id=\"testRect\" x=\"2\" y=\"24\""
             "        font-family=\"DejaVu Sans\" font-size=\"10\" fill=\"blue\" >"
             "        <tspan>%1</tspan>%2<tspan>%3</tspan>"
             "    </text>"
 
             "</g>"
 
             "</svg>";
 
     for (auto itL = linkChunk.constBegin(); itL != linkChunk.constEnd(); ++itL) {
         for (auto itA = chunkA.constBegin(); itA != chunkA.constEnd(); ++itA) {
             for (auto itB = chunkB.constBegin(); itB != chunkB.constEnd(); ++itB) {
                 if (itA->rightRef(1) != " " &&
                     itB->leftRef(1) != " " &&
                     *itL != " " &&
                     *itL != linkChunk.last()) continue;
 
                 QString cleanLink = *itL;
                 cleanLink.replace('/', '_');
 
                 qDebug() << "Testcase:" << *itA << cleanLink << *itB;
 
                 const QString data = dataTemplate.arg(*itA, *itL, *itB);
                 SvgRenderTester t (data);
                 t.setFuzzyThreshold(5);
                 //t.test_standard(QString("text_trailing_%1_%2_%3").arg(*itA).arg(cleanLink).arg(*itB), QSize(70, 30), 72.0);
 
                 // all files should look exactly the same!
                 t.test_standard(QString("text_whitespace"), QSize(70, 30), 72.0);
             }
         }
     }
 }
 
 void TestSvgText::testConvertHtmlToSvg()
 {
     const QString html =
             "<?xml version=\"1.0\"?>"
             "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0//EN\" \"http://www.w3.org/TR/REC-html40/strict.dtd\">"
             "<html>"
               "<head>"
                 "<meta name=\"qrichtext\" content=\"1\"/>"
                 "<style type=\"text/css\">p, li { white-space: pre-wrap; }</style>"
               "</head>"
               "<body style=\" font-family:'Droid Sans'; font-size:9pt; font-weight:400; font-style:normal;\">"
                 "<p style=\" margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;\">"
                 "  <span style=\" font-family:'Times'; font-size:20pt;\">Lorem ipsum dolor</span>"
                 "</p>"
                 "<p style=\" margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;\">sit am"
                 "<span style=\" font-weight:600;\">et, consectetur adipis</span>cing </p>"
                 "<p style=\" margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;\">"
                 "  <span style=\" font-style:italic;\">elit. </span>"
                 "</p>"
               "</body>"
             "</html>";
 
     KoSvgTextShape shape;
     KoSvgTextShapeMarkupConverter converter(&shape);
 
     QString svg;
     QString defs;
 
     converter.convertFromHtml(html, &svg, &defs);
 
 
     bool r = converter.convertToSvg(&svg, &defs);
 
     qDebug() << r << svg << defs;
 
 }
 
 void TestSvgText::testTextWithMultipleRelativeOffsets()
 {
     const QString data =
             "<svg width=\"100px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<g id=\"test\">"
             "    <text id=\"testRect\" x=\"10\" y=\"40\""
             "        font-family=\"DejaVu Sans\" font-size=\"15\" "
             "        dy=\"0 -3 -3 -3 -3 3 3 3 3 0 -3 -3 -3 -3 3 3 3 3 0 -3 -3 -3 -3 3 3 3 3 0 -3 -3 -3 -3 3 3 3 3 0\">"
             "        Lorem ipsum dolor sit amet"
             "    </text>"
 
             "</g>"
 
             "</svg>";
 
     SvgRenderTester t (data);
     t.setFuzzyThreshold(5);
     t.test_standard("text_multiple_relative_offsets", QSize(300, 80), 72.0);
 }
 
 void TestSvgText::testTextWithMultipleAbsoluteOffsetsArabic()
 {
     /**
      * According to the standard, each **absolute** offset defines a
      * new text chunk, therefore, the arabic text must become
      * ltr reordered
      */
 
     const QString data =
             "<svg width=\"100px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<g id=\"test\">"
             "    <text id=\"testRect\" x=\"10\" y=\"40\""
             "        font-family=\"DejaVu Sans\" font-size=\"15\" "
             "        y=\"40 45 50 55 50 45 40 35 30 25 30 35 40 45 50 55 50 45 40 35 30 25 30 35 40 45 50 55 50 45 40 35 30 25 30 35 40 45 50 55 50 45 40 35 30 25 30 35 40 45 50 55 50 45 40 35 30 25 30 35 40 45 50 55 50 45 40 35 30 25 30 35 \">"
             "        Lo rem اللغة العربية المعيارية الحديثة ip sum"
             "    </text>"
 
             "</g>"
 
             "</svg>";
 
     SvgRenderTester t (data);
     t.test_standard("text_multiple_absolute_offsets_arabic", QSize(530, 70), 72.0);
 }
 
 void TestSvgText::testTextWithMultipleRelativeOffsetsArabic()
 {
     /**
      * According to the standard, **relative** offsets must not define a new
      * text chunk, therefore, the arabic text must be written in native rtl order,
      * even though the individual letters are split.
      */
 
     const QString data =
             "<svg width=\"100px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<g id=\"test\">"
             "    <text id=\"testRect\" x=\"10\" y=\"40\""
             "        font-family=\"DejaVu Sans\" font-size=\"15\" "
             "        dy=\"0 -3 -3 -3 -3 3 3 3 3 0 -3 -3 -3 -3 3 3 3 3 0 -3 -3 -3 -3 3 3 3 3 0 -3 -3 -3 -3 3 3 3 3 0 -3 -3 -3 -3 3 3 3 3 0\">"
             "        Lo rem اللغة العربية المعيارية الحديثة ip sum"
             "    </text>"
 
             "</g>"
 
             "</svg>";
 
     SvgRenderTester t (data);
 
     // we cannot expect more than one failure
 #ifndef USE_ROUND_TRIP
     QEXPECT_FAIL("", "WARNING: in Krita relative offsets also define a new text chunk, that doesn't comply with SVG standard and must be fixed", Continue);
     t.test_standard("text_multiple_relative_offsets_arabic", QSize(530, 70), 72.0);
 #endif
 }
 
 void TestSvgText::testTextOutline()
 {
     const QString data =
             "<svg width=\"100px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<g id=\"test\">"
 
             "    <rect id=\"boundingRect\" x=\"4\" y=\"5\" width=\"89\" height=\"19\""
             "        fill=\"none\" stroke=\"red\"/>"
 
             "    <text id=\"testRect\" x=\"7\" y=\"27\""
             " "
             "        font-family=\"DejaVu Sans\" font-size=\"15\" fill=\"blue\" >"
             "        normal "
             "        <tspan text-decoration=\"line-through\">strikethrough</tspan>"
             "        <tspan text-decoration=\"overline\">overline</tspan>"
             "        <tspan text-decoration=\"underline\">underline</tspan>"
             "    </text>"
 
             "</g>"
 
             "</svg>";
 
     QRect renderRect(0, 0, 450, 40);
 
     SvgRenderTester t (data);
     t.setFuzzyThreshold(5);
     t.test_standard("text_outline", renderRect.size(), 72.0);
 
     KoShape *shape = t.findShape("testRect");
     KoSvgTextChunkShape *chunkShape = dynamic_cast<KoSvgTextChunkShape*>(shape);
     QVERIFY(chunkShape);
 
     KoSvgTextShape *textShape = dynamic_cast<KoSvgTextShape*>(shape);
 
     QImage canvas(renderRect.size(), QImage::Format_ARGB32);
     canvas.fill(0);
     QPainter gc(&canvas);
     gc.setPen(Qt::NoPen);
     gc.setBrush(Qt::black);
     gc.setRenderHint(QPainter::Antialiasing, true);
     gc.drawPath(textShape->textOutline());
 
     QVERIFY(TestUtil::checkQImage(canvas, "svg_render", "load_text_outline", "converted_to_path", 3, 5));
 }
 
 
 
 
 QTEST_MAIN(TestSvgText)
diff --git a/libs/flake/tests/TestSvgText.h b/libs/flake/tests/TestSvgText.h
index dcaf32cd98..3750903f76 100644
--- a/libs/flake/tests/TestSvgText.h
+++ b/libs/flake/tests/TestSvgText.h
@@ -1,67 +1,68 @@
 /*
  *  Copyright (c) 2017 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef TESTSVGTEXT_H
 #define TESTSVGTEXT_H
 
 #include <QtTest>
 
 class TestSvgText : public QObject
 {
     Q_OBJECT
 private Q_SLOTS:
     void testTextProperties();
     void testDefaultTextProperties();
     void testTextPropertiesDifference();
 
     void testParseFontStyles();
     void testParseTextStyles();
 
 
     void testSimpleText();
     void testComplexText();
     void testHindiText();
     void testTextBaselineShift();
     void testTextSpacing();
+    void testTextTabSpacing();
     void testTextDecorations();
     void testRightToLeft();
 
     void testQtBidi();
     void testQtDxDy();
 
     void testTextOutlineSolid();
     void testNbspHandling();
     void testMulticolorText();
 
     void testConvertToStrippedSvg();
     void testConvertToStrippedSvgNullOrigin();
     void testConvertFromIncorrectStrippedSvg();
 
     void testEmptyTextChunk();
     void testTrailingWhitespace();
 
     void testConvertHtmlToSvg();
     void testTextWithMultipleRelativeOffsets();
     void testTextWithMultipleAbsoluteOffsetsArabic();
     void testTextWithMultipleRelativeOffsetsArabic();
 
     void testTextOutline();
 
 };
 
 #endif // TESTSVGTEXT_H
diff --git a/libs/flake/tests/data/svg_render/load_text_tab_spacing.png b/libs/flake/tests/data/svg_render/load_text_tab_spacing.png
new file mode 100644
index 0000000000..3331da24e1
Binary files /dev/null and b/libs/flake/tests/data/svg_render/load_text_tab_spacing.png differ
diff --git a/libs/flake/text/KoSvgTextShape.cpp b/libs/flake/text/KoSvgTextShape.cpp
index 526ca9d7dd..38eb89fcbb 100644
--- a/libs/flake/text/KoSvgTextShape.cpp
+++ b/libs/flake/text/KoSvgTextShape.cpp
@@ -1,628 +1,636 @@
 /*
  *  Copyright (c) 2017 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "KoSvgTextShape.h"
 
 #include <QTextLayout>
 #include <klocalizedstring.h>
 
 #include "KoSvgText.h"
 #include "KoSvgTextProperties.h"
 #include <KoShapeContainer_p.h>
 #include <text/KoSvgTextChunkShape_p.h>
 #include <text/KoSvgTextShapeMarkupConverter.h>
 #include <KoDocumentResourceManager.h>
 #include <KoShapeController.h>
 
 #include "kis_debug.h"
 
 #include <KoXmlReader.h>
 #include <KoXmlNS.h>
 #include <KoShapeLoadingContext.h>
 #include <KoOdfLoadingContext.h>
 #include <KoIcon.h>
 #include <KoProperties.h>
 #include <KoColorBackground.h>
 
 #include <SvgLoadingContext.h>
 #include <SvgGraphicContext.h>
 #include <SvgUtil.h>
 
 #include <QApplication>
 #include <QThread>
 #include <vector>
 #include <memory>
 #include <QPainter>
 #include <boost/optional.hpp>
 
 #include <text/KoSvgTextChunkShapeLayoutInterface.h>
 
 #include <FlakeDebug.h>
 
 class KoSvgTextShapePrivate : public KoSvgTextChunkShapePrivate
 {
     KoSvgTextShapePrivate(KoSvgTextShape *_q)
         : KoSvgTextChunkShapePrivate(_q)
     {
     }
 
     KoSvgTextShapePrivate(const KoSvgTextShapePrivate &rhs, KoSvgTextShape *q)
         : KoSvgTextChunkShapePrivate(rhs, q)
     {
     }
 
     std::vector<std::unique_ptr<QTextLayout>> cachedLayouts;
     std::vector<QPointF> cachedLayoutsOffsets;
     QThread *cachedLayoutsWorkingThread = 0;
 
 
     void clearAssociatedOutlines(KoShape *rootShape);
 
 
     Q_DECLARE_PUBLIC(KoSvgTextShape)
 };
 
 KoSvgTextShape::KoSvgTextShape()
     : KoSvgTextChunkShape(new KoSvgTextShapePrivate(this))
 {
     setShapeId(KoSvgTextShape_SHAPEID);
 }
 
 KoSvgTextShape::KoSvgTextShape(const KoSvgTextShape &rhs)
     : KoSvgTextChunkShape(new KoSvgTextShapePrivate(*rhs.d_func(), this))
 {
     setShapeId(KoSvgTextShape_SHAPEID);
     // QTextLayout has no copy-ctor, so just relayout everything!
     relayout();
 }
 
 KoSvgTextShape::~KoSvgTextShape()
 {
 }
 
 KoShape *KoSvgTextShape::cloneShape() const
 {
     return new KoSvgTextShape(*this);
 }
 
 void KoSvgTextShape::shapeChanged(ChangeType type, KoShape *shape)
 {
     KoSvgTextChunkShape::shapeChanged(type, shape);
 
     if (type == StrokeChanged || type == BackgroundChanged || type == ContentChanged) {
         relayout();
     }
 }
 
 void KoSvgTextShape::paintComponent(QPainter &painter, const KoViewConverter &converter, KoShapePaintingContext &paintContext)
 {
     Q_D(KoSvgTextShape);
 
     Q_UNUSED(paintContext);
 
     /**
      * HACK ALERT:
      * QTextLayout should only be accessed from the thread it has been created in.
      * If the cached layout has been created in a different thread, we should just
      * recreate the layouts in the current thread to be able to render them.
      */
 
     if (QThread::currentThread() != d->cachedLayoutsWorkingThread) {
         relayout();
     }
 
     applyConversion(painter, converter);
     for (int i = 0; i < (int)d->cachedLayouts.size(); i++) {
         d->cachedLayouts[i]->draw(&painter, d->cachedLayoutsOffsets[i]);
     }
 
     /**
      * HACK ALERT:
      * The layouts of non-gui threads must be destroyed in the same thread
      * they have been created. Because the thread might be restarted in the
      * meantime or just destroyed, meaning that the per-thread freetype data
      * will not be available.
      */
     if (QThread::currentThread() != qApp->thread()) {
         d->cachedLayouts.clear();
         d->cachedLayoutsOffsets.clear();
         d->cachedLayoutsWorkingThread = 0;
     }
 }
 
 void KoSvgTextShape::paintStroke(QPainter &painter, const KoViewConverter &converter, KoShapePaintingContext &paintContext)
 {
     Q_UNUSED(painter);
     Q_UNUSED(converter);
     Q_UNUSED(paintContext);
 
     // do nothing! everything is painted in paintComponent()
 }
 
 QPainterPath KoSvgTextShape::textOutline()
 {
     Q_D(KoSvgTextShape);
 
     QPainterPath result;
     result.setFillRule(Qt::WindingFill);
 
 
     for (int i = 0; i < (int)d->cachedLayouts.size(); i++) {
         const QPointF layoutOffset = d->cachedLayoutsOffsets[i];
         const QTextLayout *layout = d->cachedLayouts[i].get();
 
         for (int j = 0; j < layout->lineCount(); j++) {
             QTextLine line = layout->lineAt(j);
 
             Q_FOREACH (const QGlyphRun &run, line.glyphRuns()) {
                 const QVector<quint32> indexes = run.glyphIndexes();
                 const QVector<QPointF> positions = run.positions();
                 const QRawFont font = run.rawFont();
 
                 KIS_SAFE_ASSERT_RECOVER(indexes.size() == positions.size()) { continue; }
 
                 for (int k = 0; k < indexes.size(); k++) {
                     QPainterPath glyph = font.pathForGlyph(indexes[k]);
                     glyph.translate(positions[k] + layoutOffset);
                     result += glyph;
                 }
 
                 const qreal thickness = font.lineThickness();
                 const QRectF runBounds = run.boundingRect();
 
                 if (run.overline()) {
                     // the offset is calculated to be consistent with the way how Qt renders the text
                     const qreal y = line.y();
                     QRectF overlineBlob(runBounds.x(), y, runBounds.width(), thickness);
                     overlineBlob.translate(layoutOffset);
 
                     QPainterPath path;
                     path.addRect(overlineBlob);
 
                     // don't use direct addRect, because it doesn't care about Qt::WindingFill
                     result += path;
                 }
 
                 if (run.strikeOut()) {
                     // the offset is calculated to be consistent with the way how Qt renders the text
                     const qreal y = line.y() + 0.5 * line.height();
                     QRectF strikeThroughBlob(runBounds.x(), y, runBounds.width(), thickness);
                     strikeThroughBlob.translate(layoutOffset);
 
                     QPainterPath path;
                     path.addRect(strikeThroughBlob);
 
                     // don't use direct addRect, because it doesn't care about Qt::WindingFill
                     result += path;
                 }
 
                 if (run.underline()) {
                     const qreal y = line.y() + line.ascent() + font.underlinePosition();
                     QRectF underlineBlob(runBounds.x(), y, runBounds.width(), thickness);
                     underlineBlob.translate(layoutOffset);
 
                     QPainterPath path;
                     path.addRect(underlineBlob);
 
                     // don't use direct addRect, because it doesn't care about Qt::WindingFill
                     result += path;
                 }
             }
         }
     }
 
     return result;
 }
 
 void KoSvgTextShape::resetTextShape()
 {
     KoSvgTextChunkShape::resetTextShape();
     relayout();
 }
 
 struct TextChunk {
     QString text;
     QVector<QTextLayout::FormatRange> formats;
     Qt::LayoutDirection direction = Qt::LeftToRight;
     Qt::Alignment alignment = Qt::AlignLeading;
 
     struct SubChunkOffset {
         QPointF offset;
         int start = 0;
     };
 
     QVector<SubChunkOffset> offsets;
 
     boost::optional<qreal> xStartPos;
     boost::optional<qreal> yStartPos;
 
     QPointF applyStartPosOverride(const QPointF &pos) const {
         QPointF result = pos;
 
         if (xStartPos) {
             result.rx() = *xStartPos;
         }
 
         if (yStartPos) {
             result.ry() = *yStartPos;
         }
 
         return result;
     }
 };
 
 QVector<TextChunk> mergeIntoChunks(const QVector<KoSvgTextChunkShapeLayoutInterface::SubChunk> &subChunks)
 {
     QVector<TextChunk> chunks;
 
     for (auto it = subChunks.begin(); it != subChunks.end(); ++it) {
         if (it->transformation.startsNewChunk() || it == subChunks.begin()) {
             TextChunk newChunk = TextChunk();
             newChunk.direction = it->format.layoutDirection();
             newChunk.alignment = it->format.calculateAlignment();
             newChunk.xStartPos = it->transformation.xPos;
             newChunk.yStartPos = it->transformation.yPos;
             chunks.append(newChunk);
         }
 
         TextChunk &currentChunk = chunks.last();
 
         if (it->transformation.hasRelativeOffset()) {
             TextChunk::SubChunkOffset o;
             o.start = currentChunk.text.size();
             o.offset = it->transformation.relativeOffset();
 
             KIS_SAFE_ASSERT_RECOVER_NOOP(!o.offset.isNull());
             currentChunk.offsets.append(o);
         }
 
         QTextLayout::FormatRange formatRange;
         formatRange.start = currentChunk.text.size();
         formatRange.length = it->text.size();
         formatRange.format = it->format;
 
         currentChunk.formats.append(formatRange);
 
         currentChunk.text += it->text;
     }
 
     return chunks;
 }
 
 /**
  * Qt's QTextLayout has a weird trait, it doesn't count space characters as
  * distinct characters in QTextLayout::setNumColumns(), that is, if we want to
  * position a block of text that starts with a space character in a specific
  * position, QTextLayout will drop this space and will move the text to the left.
  *
  * That is why we have a special wrapper object that ensures that no spaces are
  * dropped and their horizontal advance parameter is taken into account.
  */
 struct LayoutChunkWrapper
 {
     LayoutChunkWrapper(QTextLayout *layout)
         : m_layout(layout)
     {
     }
 
     QPointF addTextChunk(int startPos, int length, const QPointF &textChunkStartPos)
     {
         QPointF currentTextPos = textChunkStartPos;
 
         const int lastPos = startPos + length - 1;
 
         KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(startPos == m_addedChars, currentTextPos);
         KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(lastPos < m_layout->text().size(), currentTextPos);
 
         QTextLine line;
         std::swap(line, m_danglingLine);
 
         if (!line.isValid()) {
             line = m_layout->createLine();
         }
 
         // skip all the space characters that were not included into the Qt's text line
         const int currentLineStart = line.isValid() ? line.textStart() : startPos + length;
         while (startPos < currentLineStart && startPos <= lastPos) {
             currentTextPos.rx() += skipSpaceCharacter(startPos);
             startPos++;
         }
 
         if (startPos <= lastPos) {
+            // defines the number of columns to look for glyphs
             const int numChars = lastPos - startPos + 1;
+            // Tabs break the normal column flow
+            // grow to avoid missing glyphs
+
+            int charOffset = 0;
+            while (line.textLength() < numChars) {
+                line.setNumColumns(numChars + charOffset);
+                charOffset++;
+            }
 
-            line.setNumColumns(numChars);
             line.setPosition(currentTextPos - QPointF(0, line.ascent()));
             currentTextPos.rx() += line.horizontalAdvance();
 
             // skip all the space characters that were not included into the Qt's text line
             for (int i = line.textStart() + line.textLength(); i < lastPos; i++) {
                 currentTextPos.rx() += skipSpaceCharacter(i);
             }
 
         } else {
             // keep the created but unused line for future use
             std::swap(line, m_danglingLine);
         }
         m_addedChars += length;
 
         return currentTextPos;
     }
 
 private:
     qreal skipSpaceCharacter(int pos) {
         const QTextCharFormat format =
             formatForPos(pos, m_layout->formats());
 
         const QChar skippedChar = m_layout->text()[pos];
         KIS_SAFE_ASSERT_RECOVER_NOOP(skippedChar.isSpace() || !skippedChar.isPrint());
 
         QFontMetrics metrics(format.font());
         return metrics.width(skippedChar);
     }
 
     static QTextCharFormat formatForPos(int pos, const QVector<QTextLayout::FormatRange> &formats)
     {
         Q_FOREACH (const QTextLayout::FormatRange &range, formats) {
             if (pos >= range.start && pos < range.start + range.length) {
                 return range.format;
             }
         }
 
         KIS_SAFE_ASSERT_RECOVER_NOOP(0 && "pos should be within the bounds of the layouted text");
 
         return QTextCharFormat();
     }
 
 private:
     int m_addedChars = 0;
     QTextLayout *m_layout;
     QTextLine m_danglingLine;
 };
 
 void KoSvgTextShape::relayout()
 {
     Q_D(KoSvgTextShape);
 
     d->cachedLayouts.clear();
     d->cachedLayoutsOffsets.clear();
     d->cachedLayoutsWorkingThread = QThread::currentThread();
 
     QPointF currentTextPos;
 
     QVector<TextChunk> textChunks = mergeIntoChunks(layoutInterface()->collectSubChunks());
 
     Q_FOREACH (const TextChunk &chunk, textChunks) {
         std::unique_ptr<QTextLayout> layout(new QTextLayout());
 
         QTextOption option;
 
         // WARNING: never activate this option! It breaks the RTL text layout!
         //option.setFlags(QTextOption::ShowTabsAndSpaces);
 
         option.setWrapMode(QTextOption::WrapAnywhere);
         option.setUseDesignMetrics(true); // TODO: investigate if it is needed?
         option.setTextDirection(chunk.direction);
 
         layout->setText(chunk.text);
         layout->setTextOption(option);
         layout->setFormats(chunk.formats);
         layout->setCacheEnabled(true);
 
         layout->beginLayout();
 
         currentTextPos = chunk.applyStartPosOverride(currentTextPos);
         const QPointF anchorPointPos = currentTextPos;
 
         int lastSubChunkStart = 0;
         QPointF lastSubChunkOffset;
 
         LayoutChunkWrapper wrapper(layout.get());
 
         for (int i = 0; i <= chunk.offsets.size(); i++) {
             const bool isFinalPass = i == chunk.offsets.size();
 
             const int length =
                 !isFinalPass ?
                 chunk.offsets[i].start - lastSubChunkStart :
                 chunk.text.size() - lastSubChunkStart;
 
             if (length > 0) {
                 currentTextPos += lastSubChunkOffset;
                 currentTextPos = wrapper.addTextChunk(lastSubChunkStart,
                                                       length,
                                                       currentTextPos);
             }
 
             if (!isFinalPass) {
                 lastSubChunkOffset = chunk.offsets[i].offset;
                 lastSubChunkStart = chunk.offsets[i].start;
             }
         }
 
         layout->endLayout();
 
         QPointF diff;
 
         if (chunk.alignment & Qt::AlignTrailing || chunk.alignment & Qt::AlignHCenter) {
             if (chunk.alignment & Qt::AlignTrailing) {
                 diff = currentTextPos - anchorPointPos;
             } else if (chunk.alignment & Qt::AlignHCenter) {
                 diff = 0.5 * (currentTextPos - anchorPointPos);
             }
 
             // TODO: fix after t2b text implemented
             diff.ry() = 0;
         }
 
         d->cachedLayouts.push_back(std::move(layout));
         d->cachedLayoutsOffsets.push_back(-diff);
 
     }
 
     d->clearAssociatedOutlines(this);
 
     for (int i = 0; i < int(d->cachedLayouts.size()); i++) {
         const QTextLayout &layout = *d->cachedLayouts[i];
         const QPointF layoutOffset = d->cachedLayoutsOffsets[i];
 
         using namespace KoSvgText;
 
         Q_FOREACH (const QTextLayout::FormatRange &range, layout.formats()) {
             const KoSvgCharChunkFormat &format =
                 static_cast<const KoSvgCharChunkFormat&>(range.format);
             AssociatedShapeWrapper wrapper = format.associatedShapeWrapper();
 
             const int rangeStart = range.start;
             const int safeRangeLength = range.length > 0 ? range.length : layout.text().size() - rangeStart;
 
             if (safeRangeLength <= 0) continue;
 
             const int rangeEnd = range.start + safeRangeLength - 1;
 
             const int firstLineIndex = layout.lineForTextPosition(rangeStart).lineNumber();
             const int lastLineIndex = layout.lineForTextPosition(rangeEnd).lineNumber();
 
             for (int i = firstLineIndex; i <= lastLineIndex; i++) {
                 const QTextLine line = layout.lineAt(i);
 
                 // It might happen that the range contains only one (or two)
                 // symbol that is a whitespace symbol. In such a case we should
                 // just skip this (invalid) line.
                 if (!line.isValid()) continue;
 
                 const int posStart = qMax(line.textStart(), rangeStart);
                 const int posEnd = qMin(line.textStart() + line.textLength() - 1, rangeEnd);
 
                 const QList<QGlyphRun> glyphRuns = line.glyphRuns(posStart, posEnd - posStart + 1);
                 Q_FOREACH (const QGlyphRun &run, glyphRuns) {
                     const QPointF firstPosition = run.positions().first();
                     const quint32 firstGlyphIndex = run.glyphIndexes().first();
 
                     const QPointF lastPosition = run.positions().last();
                     const quint32 lastGlyphIndex = run.glyphIndexes().last();
 
                     const QRawFont rawFont = run.rawFont();
 
                     const QRectF firstGlyphRect = rawFont.boundingRect(firstGlyphIndex).translated(firstPosition);
                     const QRectF lastGlyphRect = rawFont.boundingRect(lastGlyphIndex).translated(lastPosition);
 
                     QRectF rect = run.boundingRect();
 
                     /**
                      * HACK ALERT: there is a bug in a way how Qt calculates boundingRect()
                      *             of the glyph run. It doesn't care about left and right bearings
                      *             of the border chars in the run, therefore it becomes cropped.
                      *
                      *             Here we just add a half-char width margin to both sides
                      *             of the glyph run to make sure the glyphs are fully painted.
                      *
                      * BUG: 389528
                      * BUG: 392068
                      */
                     rect.setLeft(qMin(rect.left(), lastGlyphRect.left()) - 0.5 * firstGlyphRect.width());
                     rect.setRight(qMax(rect.right(), lastGlyphRect.right()) + 0.5 * lastGlyphRect.width());
 
                     wrapper.addCharacterRect(rect.translated(layoutOffset));
                 }
             }
         }
     }
 }
 
 void KoSvgTextShapePrivate::clearAssociatedOutlines(KoShape *rootShape)
 {
     KoSvgTextChunkShape *chunkShape = dynamic_cast<KoSvgTextChunkShape*>(rootShape);
     KIS_SAFE_ASSERT_RECOVER_RETURN(chunkShape);
 
     chunkShape->layoutInterface()->clearAssociatedOutline();
 
     Q_FOREACH (KoShape *child, chunkShape->shapes()) {
         clearAssociatedOutlines(child);
     }
 }
 
 bool KoSvgTextShape::isRootTextNode() const
 {
     return true;
 }
 
 KoSvgTextShapeFactory::KoSvgTextShapeFactory()
     : KoShapeFactoryBase(KoSvgTextShape_SHAPEID, i18n("Text"))
 {
     setToolTip(i18n("SVG Text Shape"));
     setIconName(koIconNameCStr("x-shape-text"));
     setLoadingPriority(5);
     setXmlElementNames(KoXmlNS::svg, QStringList("text"));
 
     KoShapeTemplate t;
     t.name = i18n("SVG Text");
     t.iconName = koIconName("x-shape-text");
     t.toolTip = i18n("SVG Text Shape");
     addTemplate(t);
 }
 
 KoShape *KoSvgTextShapeFactory::createDefaultShape(KoDocumentResourceManager *documentResources) const
 {
     debugFlake << "Create default svg text shape";
 
     KoSvgTextShape *shape = new KoSvgTextShape();
     shape->setShapeId(KoSvgTextShape_SHAPEID);
 
     KoSvgTextShapeMarkupConverter converter(shape);
     converter.convertFromSvg("<text>Lorem ipsum dolor sit amet, consectetur adipiscing elit.</text>",
                              "<defs/>",
                              QRectF(0, 0, 200, 60),
                              documentResources->shapeController()->pixelsPerInch());
 
     debugFlake << converter.errors() << converter.warnings();
 
     return shape;
 }
 
 KoShape *KoSvgTextShapeFactory::createShape(const KoProperties *params, KoDocumentResourceManager *documentResources) const
 {
     KoSvgTextShape *shape = new KoSvgTextShape();
     shape->setShapeId(KoSvgTextShape_SHAPEID);
 
     QString svgText = params->stringProperty("svgText", "<text>Lorem ipsum dolor sit amet, consectetur adipiscing elit.</text>");
     QString defs = params->stringProperty("defs" , "<defs/>");
     QRectF shapeRect = QRectF(0, 0, 200, 60);
     QVariant rect = params->property("shapeRect");
 
     if (rect.type()==QVariant::RectF) {
         shapeRect = rect.toRectF();
     }
 
     KoShapeController *controller = documentResources->shapeController();
 
     KoSvgTextShapeMarkupConverter converter(shape);
     converter.convertFromSvg(svgText,
                              defs,
                              shapeRect,
                              controller ? controller->pixelsPerInch() : 72);
 
     shape->setPosition(shapeRect.topLeft());
 
     return shape;
 }
 
 bool KoSvgTextShapeFactory::supports(const KoXmlElement &/*e*/, KoShapeLoadingContext &/*context*/) const
 {
     return false;
 }