diff --git a/libs/flake/tests/TestSvgParser.cpp b/libs/flake/tests/TestSvgParser.cpp
index 7eec035..ea02372 100644
--- a/libs/flake/tests/TestSvgParser.cpp
+++ b/libs/flake/tests/TestSvgParser.cpp
@@ -482,4 +482,240 @@ void TestSvgParser::testParsePreserveAspectRatio()
}
}
+#if 1
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/spirit/include/qi.hpp>
+#include <boost/spirit/include/phoenix_core.hpp>
+#include <boost/spirit/include/phoenix_operator.hpp>
+#include <boost/spirit/include/phoenix_object.hpp>
+#include <boost/fusion/include/adapt_struct.hpp>
+#include <boost/fusion/include/io.hpp>
+
+#include <boost/spirit/include/phoenix_fusion.hpp>
+#include <boost/spirit/include/phoenix_stl.hpp>
+
+namespace client
+{
+namespace qi = boost::spirit::qi;
+namespace ascii = boost::spirit::ascii;
+
+///////////////////////////////////////////////////////////////////////////
+// Our employee struct
+///////////////////////////////////////////////////////////////////////////
+//[tutorial_employee_struct
+
+struct matrix
+{
+ qreal a = 0;
+ qreal b = 0;
+ qreal c = 0;
+ qreal d = 0;
+ qreal e = 0;
+ qreal f = 0;
+};
+
+struct translate
+{
+ qreal tx = 0.0;
+ qreal ty = 0.0;
+};
+
+struct scale
+{
+ qreal sx = 0;
+ qreal sy = 0;
+};
+
+struct rotate
+{
+ qreal angle = 0;
+ qreal cx = 0;
+ qreal cy = 0;
+};
+
+struct skewX
+{
+ qreal angle = 0;
+};
+
+struct skewY
+{
+ qreal angle = 0;
+};
+
+struct transform_unit
+{
+ transform_unit() {}
+ transform_unit(const matrix &m) {}
+ transform_unit(const translate &t) {}
+ transform_unit(const scale &sc) {}
+ transform_unit(const rotate &r) {}
+ transform_unit(const skewX &sx) {}
+ transform_unit(const skewY &sy) {}
+ QTransform transform;
+};
+//]
+}
+
+// We need to tell fusion about our transform_unit struct
+// to make it a first-class fusion citizen. This has to
+// be in global scope.
+
+BOOST_FUSION_ADAPT_STRUCT(
+ client::matrix,
+ (qreal, a)
+ (qreal, b)
+ (qreal, c)
+ (qreal, d)
+ (qreal, e)
+ (qreal, f)
+ )
+
+BOOST_FUSION_ADAPT_STRUCT(
+ client::translate,
+ (qreal, tx)
+ (qreal, ty)
+ )
+
+BOOST_FUSION_ADAPT_STRUCT(
+ client::scale,
+ (qreal, sx)
+ (qreal, sy)
+ )
+
+BOOST_FUSION_ADAPT_STRUCT(
+ client::rotate,
+ (qreal, angle)
+ (qreal, cx)
+ (qreal, cy)
+ )
+
+BOOST_FUSION_ADAPT_STRUCT(
+ client::skewX,
+ (qreal, angle)
+ )
+
+BOOST_FUSION_ADAPT_STRUCT(
+ client::skewY,
+ (qreal, angle)
+ )
+
+namespace client
+{
+ template <typename Iterator>
+ struct transform_unit_parser : qi::grammar<Iterator, std::vector<transform_unit>(), ascii::space_type>
+ {
+ transform_unit_parser() : transform_unit_parser::base_type(start)
+ {
+ namespace phoenix = boost::phoenix;
+ using qi::lit;
+ using qi::double_;
+ using ascii::char_;
+ using qi::cntrl;
+ using phoenix::push_back;
+
+
+ comma %= -char_(',');
+
+ matrix_rule %=
+ lit("matrix")
+ >> '('
+ >> double_ >> comma
+ >> double_ >> comma
+ >> double_ >> comma
+ >> double_ >> comma
+ >> double_ >> comma
+ >> double_ >> comma
+ >> ')';
+
+ translate_rule %=
+ lit("translate")
+ >> '(' >> double_ >> comma >> -double_ >> ')';
+
+ scale_rule %=
+ lit("scale")
+ >> '(' >> double_ >> comma >> -double_ >> ')';
+
+ rotate_rule %=
+ lit("rotate")
+ >> '('
+ >> double_ >> comma
+ >> -(double_ >> comma >> double_)
+ >> ')';
+
+ skewX_rule %= lit("skewX") >> '(' >> double_ >> ')';
+ skewY_rule %= lit("skewY") >> '(' >> double_ >> ')';
+
+ start %=
+ (matrix_rule | translate_rule | scale_rule |
+ rotate_rule | skewX_rule | skewY_rule) %
+ (cntrl | comma);
+ }
+
+ qi::rule<Iterator, std::vector<transform_unit>(), ascii::space_type> start;
+ qi::rule<Iterator, translate(), ascii::space_type> translate_rule;
+ qi::rule<Iterator, matrix(), ascii::space_type> matrix_rule;
+ qi::rule<Iterator, scale(), ascii::space_type> scale_rule;
+ qi::rule<Iterator, rotate(), ascii::space_type> rotate_rule;
+ qi::rule<Iterator, skewX(), ascii::space_type> skewX_rule;
+ qi::rule<Iterator, skewY(), ascii::space_type> skewY_rule;
+ qi::rule<Iterator> comma;
+ };
+}
+
+void TestSvgParser::testParseTransform()
+{
+ using boost::spirit::ascii::space;
+ typedef std::string::const_iterator iterator_type;
+ typedef client::transform_unit_parser<iterator_type> transform_unit_parser;
+
+ transform_unit_parser g; // Our grammar
+ std::string str("translate(-111.0, 33) matrix (1 1 0 0 1, 3), translate(1)"
+ "scale(0.5) rotate(10) rotate(10, 3 3) skewX(1) skewY(2)");
+
+ std::vector<client::transform_unit> emp;
+ std::string::const_iterator iter = str.begin();
+ std::string::const_iterator end = str.end();
+ bool r = phrase_parse(iter, end, g, space, emp);
+
+ if (r && iter == end) {
+ qDebug() << ppVar(emp.size());
+ } else {
+ std::cout << "-------------------------\n";
+ std::cout << "Parsing failed\n";
+ std::cout << "-------------------------\n";
+ }
+}
+
+#else
+void TestSvgParser::testParseTransform()
+{
+ QString str(" translate(-111.0, 33) translate(-111.0, 33) matrix (1 1 0 0 1, 3), translate(1)"
+ "scale(0.5) rotate(10) rotate(10, 3 3) skewX(1) skewY(2)");
+
+ QRegularExpression base("\\s*((matrix|translate|scale|rotate|skewX|skewY)\\s*\\(([-\\d\\.\\s,]+?)\\))[\\s,]*");
+
+ int startIndex = 0;
+ bool stringValid = false;
+ while (1) {
+ auto match = base.match(str, startIndex, QRegularExpression::NormalMatch, QRegularExpression::AnchoredMatchOption);
+ if (!match.hasMatch()) {
+ break;
+ }
+
+ qDebug() << ppVar(match.capturedTexts());
+
+ startIndex = match.capturedEnd(0);
+ if (startIndex == str.length()) {
+ qDebug() << "END" << ppVar(startIndex);
+ stringValid = true;
+ break;
+ }
+ }
+
+ qDebug() << ppVar(stringValid);
+}
+#endif
+
QTEST_GUILESS_MAIN(TestSvgParser)
diff --git a/libs/flake/tests/TestSvgParser.h b/libs/flake/tests/TestSvgParser.h
index c2eacb7..d1b9b4f 100644
--- a/libs/flake/tests/TestSvgParser.h
+++ b/libs/flake/tests/TestSvgParser.h
@@ -40,6 +40,7 @@ private Q_SLOTS:
void testScalingViewportResolution();
void testScalingViewportPercentInternal();
void testParsePreserveAspectRatio();
+ void testParseTransform();
};