SvgTransformParser.cpp File Reference

#include "SvgTransformParser.h"
#include <QtGlobal>
#include <boost/config/warning_disable.hpp>
#include <boost/phoenix/fusion.hpp>
#include <boost/phoenix/operator.hpp>
#include <boost/phoenix/stl.hpp>
#include <boost/spirit/include/qi.hpp>

Go to the source code of this file.

Classes
struct	Private::matrix
struct	Private::rotate
struct	Private::scale
struct	Private::skewX
struct	Private::skewY
struct	Private::transform_unit
struct	Private::translate

Namespaces
namespace	Private

Macros
#define	BOOST_SPIRIT_DEBUG   1

Functions
	BOOST_FUSION_ADAPT_STRUCT (Private::matrix,(qreal, a)(qreal, b)(qreal, c)(qreal, d)(qreal, e)(qreal, f)) BOOST_FUSION_ADAPT_STRUCT(Private

Macro Definition Documentation

BOOST_SPIRIT_DEBUG

#define BOOST_SPIRIT_DEBUG   1

Function Documentation

BOOST_FUSION_ADAPT_STRUCT()

BOOST_FUSION_ADAPT_STRUCT	(	Private::matrix	,
		(qreal, a)(qreal, b)(qreal, c)(qreal, d)(qreal, e)(qreal, f)	)

Definition at line 111 of file SvgTransformParser.cpp.

{
    // Define our grammar
 
    namespace qi = boost::spirit::qi;
    namespace ascii = boost::spirit::ascii;
 
    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::at_c;
            using phoenix::push_back;
            using namespace qi::labels;
 
 
            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_ [at_c<2>(_val) = true]
                >>  ')';
 
 
            // due to braces "-(...)" we cannot use automated
            // semantic actions without relayouting the structure
            rotate_rule =
                lit("rotate")
                >> '('
                >>  double_ [at_c<0>(_val) = _1]
                >> comma
                >>  -(double_ [at_c<1>(_val) = _1]
                      >> comma
                      >> double_ [at_c<2>(_val) = _1])
                >>  ')';
 
            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;
    };
}
 
 
SvgTransformParser::SvgTransformParser(const QString &_str)
    : m_isValid(false)
{
    using boost::spirit::ascii::space;
    typedef std::string::const_iterator iterator_type;
    typedef Private::transform_unit_parser<iterator_type> transform_unit_parser;
 
    transform_unit_parser g; // Our grammar
    const std::string str = _str.toStdString();
 
    std::vector<Private::transform_unit> transforms;
    iterator_type iter = str.begin();
    iterator_type end = str.end();
    bool r = phrase_parse(iter, end, g, space, transforms);
 
    if (r && iter == end) {
        m_isValid = true;
 
        for (const Private::transform_unit &t : transforms) {
             m_transform = t.transform * m_transform;
         }
    }
}