path.h

Go to the documentation of this file.

#ifndef PATH_H
#define PATH_H

#include <QObject>
#include <QTransform>
#include <QPolygonF>

#include <string>
#include <grid.h>



class Path : public QObject {
    Q_OBJECT
private:
    QPolygonF points;
    std::string opcode;
    double turtle_angle;

    LineStyle defaultLineStyle;
    LineStyleVector lineStyles;

public:
   /*
    *  All methods that are marked as Q_INVOKABLE
    *  are exposed to JavaScript.
    * */

    Q_INVOKABLE
    Path(QObject* parent=0);

    Q_INVOKABLE
    Path(const Path& that);
//    Path(const Path&& that) : points(that.points), rel(that.rel) { }

    Q_INVOKABLE
    Path(const Path* that);
//    Path(const Path&& that) : points(that.points), rel(that.rel) { }

    Q_INVOKABLE
    Path(QString svg, bool forceAbsolute=false, QObject* parent=0);

    static Path svgPath(QString str, bool forceAbsolute=false);
    static Path ipePath(QString str);

    const QPolygonF& toCurve(int precision=0);

    Q_INVOKABLE
    Path& operator= (const Path& that);
 //   Path& operator= (const Path&&);

    Q_INVOKABLE
    Path& operator+= (const Path& that);

    Q_INVOKABLE
    Path& operator+= (QString svg);

public slots:
    int size() const { return points.size(); }

    /*
     * All public slots are exposed to JavaScript.
     * Cool. But works only with Path*.
     **/
    Path* appendPath(Path* that) { (*this) += (*that); return this; }
    Path* appendString(QString svg) { (*this) += svg; return this; }

    /*
     * append points
     * absolute:
     */
    Path* M(QPointF p) { append(p,'M'); return this; }
    Path* M(double x, double y) { return M(QPointF(x,y)); }
    Path* H(double h) { append(QPointF(h,0),'H'); return this; }
    Path* V(double v) { append(QPointF(0,v),'V'); return this; }
    Path* close();
    Path* Z();
    Path* undo();
    Path* ensureClosed();

    /*
     * append points
     * relative:
     */
    Path* m(QPointF p) { append(p,'m'); return this; }
    Path* m(double x, double y) { return m(QPointF(x,y)); }
    Path* h(double h) { append(QPointF(h,0),'h'); return this; }
    Path* v(double v) { append(QPointF(0,v),'v'); return this; }
    Path* polar(double angle,double distance);

    /*
     * Transforms
     */
    Path* map(QTransform tf);
    Path* map(QMatrix mx);

    Path* scale(double scale);
    Path* scale(double scalex, double scaley);
    Path* rotate(double angle);

    Path* translate(QPointF offset);
    Path* translate(double dx, double dy);
    Path* mirrorx();
    Path* mirrory();
    Path* revert();

    /*
     *  Turtle Graphics
     * */
    Path* left(double angle);
    Path* right(double angle);
    Path* reset(double angle=0.0);
    Path* forward(double distance);

    void lineStyle(int);
    void setDefaultLineStyle(int);
    void outerLineStyle(int);

public:
    /*
     * String parsing
     */
    void parseSvg(QString str, bool forceAbsolute=false);
    void parseIpe(QString str);
    LineStyle getDefaultLineStyle() const { return defaultLineStyle; }
    const LineStyleVector& getLineStyles() const { return lineStyles; }

private:
    void append(QPointF p, char opcode);
    void absolutize();
    void setPrecision(int precision);
    void removeDuplicates();
   // void concat(QBitArray& a, const QBitArray& b);
};

#endif // PATH_H