Path.h

/* Copyright (C) 2017 Marc Boris Duerner
   Copyright (C) 2017 Aloysius Indrayanto
 
  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.
 
  As a special exception, you may use this file as part of a free
  software library without restriction. Specifically, if other files
  instantiate templates or use macros or inline functions from this
  file, or you compile this file and link it with other files to
  produce an executable, this file does not by itself cause the
  resulting executable to be covered by the GNU General Public
  License. This exception does not however invalidate any other
  reasons why the executable file might be covered by the GNU Library
  General Public License.
 
  This library 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
  Lesser General Public License for more details.
 
  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the Free Software
  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
  MA 02110-1301 USA
*/
 
#ifndef PT_GFX_PATH_H
#define PT_GFX_PATH_H
 
#include <Pt/Gfx/Api.h>
#include <Pt/Gfx/FillRule.h>
#include <Pt/Gfx/Point.h>
#include <Pt/Gfx/Rect.h>
#include <Pt/Gfx/Polygon.h>
#include <Pt/Gfx/Transform.h>
#include <Pt/SmartPtr.h>
 
#include <vector>
#include <iterator>
#include <cstddef>
 
namespace Pt {
 
namespace Gfx {
 
class PathData;
class PathElement;
class PathIterator;

class PT_GFX_API Path
{
    public:
        enum ElementType
        {
            MoveTo,
            LineTo,
            QuadTo,
            CubicTo,
            Close
        };
 
        typedef PathIterator Iterator;
        typedef PathElement Element;
 
    public:
        Path();

        Path(const Path& other);

        Path& operator=(const Path& other);

        ~Path();

        std::size_t size() const;

        bool isEmpty() const;

        Iterator begin() const;

        Iterator end() const;

        void clear();

        RectF boundingRect() const;

        bool contains(const PointF& point, FillRule rule = FillRule::NonZero) const;

        bool contains(const RectF& rect, FillRule rule = FillRule::NonZero) const;

        bool intersects(const RectF& rect, FillRule rule = FillRule::NonZero) const;

        const PointF& currentPosition() const;

        void moveTo(const PointF& p);

        void lineTo(const PointF& p);

        void quadTo(const PointF &cp, const PointF& to);

        void cubicTo(const PointF &cp1, const PointF &cp2, const PointF& to);

        void arcTo(const PointF& topLeft, const SizeF& size,
                   double degBegin, double degEnd);

        void close();

        void addPath(const Path& p);

        void addRect(const RectF& rect);

        void addRoundedRect(const RectF& rect, double radius);

        void addRoundedRect(const RectF& rect, double rx, double ry);

        void addEllipse(const PointF& topLeft, const SizeF& size);

        void addArc(const PointF& topLeft, const SizeF& size,
                    double degBegin, double degEnd);

        void addPie(const PointF& topLeft, const SizeF& size,
                    double degBegin, double degEnd);

        void addChord(const PointF& topLeft, const SizeF& size,
                      double degBegin, double degEnd);

        void addPolyline(const PointF* points, std::size_t count);

        void addPolygon(const PointF* points, std::size_t count);

        void transform(const Transform& transform);

        Path toTransformed(const Transform& transform) const;

        Iterator getPolygon(Iterator it, Polygon& polygon, float tolerance = 0.25f) const;
 
    private:
        void detach();
 
    private:
        SmartPtr<PathData> _pathData;
};
 
/* @internal @brief Path entry.
*/
class PathEntry
{
    public:
        typedef Path::ElementType Type;
 
    public:
        PathEntry(Type type, std::size_t n)
        : _type(type)
        , _size(n)
        {
        }
 
        Type type() const
        {
            return _type;
        }
 
        std::size_t size() const
        {
            return _size;
        }
 
    private:
        Type         _type;
        std::size_t  _size;
};

class PathElement 
{
    friend class PathIterator;
 
    protected:
        PathElement(const PathEntry* entry, const PointF* points)
        : _entry(entry)
        , _pos(0.0, 0.0)
        , _points(points)
        {
        }
        
        void setPosition(const PointF& pos)
        {
            _pos = pos;
        }
 
        void setEntry(const PathEntry* entry, const PointF* points)
        {
            _entry = entry;
            _points =  points;
        }
    
    public:
        Path::ElementType type() const
        {
            return _entry->type();
        }
        
        std::size_t size() const
        {
            return _entry->size();
        }

        const PointF& position() const
        {
            return _pos;
        }

        const PointF& point(std::size_t n) const
        {
            return _points[n];
        }

        void flatten(Polygon& points, double tolerance = 0.25) const;
 
    private:
        const PathEntry*  _entry;
        PointF            _pos;
        const PointF*     _points;
};

class PathIterator
{
    public:
        using iterator_category = std::forward_iterator_tag;
        using value_type = Path::Element;
        using difference_type = std::ptrdiff_t;
        using pointer = const Path::Element*;
        using reference = const Path::Element&;

        PathIterator()
        : _entry(0)
        , _points(0)
        , _element(0, 0)
        {
        }

        PathIterator(const PathEntry* entry, const PointF* points)
        : _entry(entry)
        , _points(points)
        , _element(_entry, _points)
        {
        }

        const Path::Element& operator*() const 
        {
            return _element;
        }

        const Path::Element* operator->() const 
        {
            return &_element;
        }

        PathIterator& operator++() 
        {
            if( _entry->size() > 0)
            {
                const PointF& pos = _points[ _entry->size() - 1 ];
                _element.setPosition(pos);
            }
 
            _points += _entry->size();
            ++_entry;
            
            _element.setEntry(_entry, _points);
            return *this;
        }

        PathIterator operator++(int) 
        {
            PathIterator tmp = *this;
            ++(*this);
            return tmp;
        }

        bool operator == (const PathIterator& other) const 
        { 
            return _entry == other._entry; 
        }
        
        bool operator != (const PathIterator& other) const 
        { 
            return _entry != other._entry; 
        }

        bool operator < (const PathIterator & other) const
        {
          return _entry < other._entry;
        }
 
    private:
        const PathEntry*  _entry;
        const PointF*     _points;
        Path::Element     _element;
};
 
/* @internal Path data.
*/
class PathData
{
    public:
        PathData()
        { }
 
        ~PathData()
        { }
 
        const PointF& currentPosition() const
        {
            return _position;
        }
 
        void setCurrentPosition(const PointF& p)
        {
            _position = p;
        }
 
        Path::Iterator begin() const 
        {
            return Path::Iterator( _entries.data(), _points.data() );
        }
 
        Path::Iterator end() const 
        {
            return Path::Iterator(_entries.data() + _entries.size(), _points.data() + _points.size());
        }
 
        std::size_t size() const
        {
            return _entries.size();
        }
 
        bool isEmpty() const
        {
            return _entries.empty();
        }
 
        void clear()
        {
            _entries.clear();
            _points.clear();
            _start = PointF();
            _position = PointF();
        }
 
        void append(const PathData& path);
 
        void moveTo(const PointF& pos);
 
        void lineTo(const PointF& pos);
 
        void quadTo(const PointF& cp, const PointF& to);
 
        void cubicTo(const PointF& cp1, const PointF& cp2, const PointF& to);
 
        void close();
 
        void transform(const Transform& tform);
 
    private:
        std::vector<PathEntry> _entries;
        std::vector<PointF>    _points;
        PointF                 _start;
        PointF                 _position;
};
 
} // namespace
 
} // namespace
 
#endif