F:/KPlato/koffice/libs/flake/KoPathShape.h

Aller à la documentation de ce fichier.

/* This file is part of the KDE project
   Copyright (C) 2006 Thorsten Zachmann <zachmann@kde.org>

   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.

   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
   Library General Public License for more details.

   You should have received a copy of the GNU Library General Public License
   along with this library; see the file COPYING.LIB.  If not, write to
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
*/

#ifndef KOPATHSHAPE_H
#define KOPATHSHAPE_H

#include <koffice_export.h>

#include <QFlags>
#include <QPainterPath>
#include <QSet>
#include <QList>

#include "KoShape.h"

#define KoPathShapeId "KoPathShape"

class KoPathShape;
class KoPointGroup;
class KoPathPoint;

typedef QMap<KoPathShape *, QSet<KoPathPoint *> > KoPathShapePointMap;
typedef QPair<int,int> KoPathPointIndex;
typedef QMap<KoPathShape *, QSet<KoPathPointIndex> > KoPathShapePointIndexMap;

class KoPathPoint
{
public:
    enum KoPointProperty
    {
        Normal = 0, 
        CanHaveControlPoint1 = 1, 
        CanHaveControlPoint2 = 2, 
        HasControlPoint1 = 4, 
        HasControlPoint2 = 8, 
        StartSubpath = 16, 
        CloseSubpath = 32, 
        IsSmooth = 64, 
        IsSymmetric = 128 
    };
    Q_DECLARE_FLAGS( KoPointProperties, KoPointProperty )

    
    enum KoPointType {
        Node,          
        ControlPoint1, 
        ControlPoint2  
    };

    KoPathPoint( KoPathShape * path, const QPointF & point, KoPointProperties properties = Normal )
    : m_shape( path )
    , m_point( point )
    , m_properties( properties )
    , m_pointGroup( 0 )
    {}

    KoPathPoint( const KoPathPoint & pathPoint );

    KoPathPoint& operator=( const KoPathPoint &rhs );

    ~KoPathPoint() {}

    QPointF point() const { return m_point; }

    QPointF controlPoint1() const { return m_controlPoint1; }

    QPointF controlPoint2() const { return m_controlPoint2; }

    void setPoint( const QPointF & point );

    void setControlPoint1( const QPointF & point );

    void setControlPoint2( const QPointF & point );

    void removeControlPoint1() { /*TODO*/ }
    void removeControlPoint2() { /*TODO*/ }

    KoPointProperties properties() const { return m_properties; }

    void setProperties( KoPointProperties properties );

    void setProperty( KoPointProperty property );

    void unsetProperty( KoPointProperty property );

    bool activeControlPoint1() const;

    bool activeControlPoint2() const;

    void map( const QMatrix &matrix, bool mapGroup = false );

    void paint(QPainter &painter, const QSizeF &size, bool selected );

    void setParent( KoPathShape* parent );

    KoPathShape * parent() const { return m_shape; }

    QRectF boundingRect() const;

    void reverse();
protected:
    friend class KoPointGroup;
    friend class KoPathShape;
    void removeFromGroup();
    void addToGroup( KoPointGroup *pointGroup );
    KoPointGroup * group() { return m_pointGroup; }
private:
    KoPathShape * m_shape;
    QPointF m_point;
    QPointF m_controlPoint1;
    QPointF m_controlPoint2;
    KoPointProperties m_properties;
    KoPointGroup * m_pointGroup;
};

class KoPointGroup
{
public:    
    KoPointGroup() {}
    ~KoPointGroup() {}

    void add( KoPathPoint * point );
    void remove( KoPathPoint * point );

    void map( const QMatrix &matrix );

    const QSet<KoPathPoint *> & points() const { return m_points; }

private:
    QSet<KoPathPoint *> m_points;
};

typedef QList<KoPathPoint *> KoSubpath;
typedef QList<KoSubpath *> KoSubpathList;
typedef QPair<KoPathPoint*,KoPathPoint*> KoPathSegment;
typedef QPair<KoSubpath*, int> KoPointPosition;
class FLAKE_EXPORT KoPathShape : public KoShape
{
public:
    KoPathShape();

    virtual ~KoPathShape();

    virtual void paint(QPainter &painter, const KoViewConverter &converter);
    virtual void paintPoints( QPainter &painter, const KoViewConverter &converter );
    virtual const QPainterPath outline() const;
    virtual QRectF boundingRect() const;
    virtual QSizeF size() const;
    virtual QPointF position() const;
    virtual void resize( const QSizeF &size );

    KoPathPoint * moveTo( const QPointF &p );

    KoPathPoint * lineTo( const QPointF &p );

    KoPathPoint * curveTo( const QPointF &c1, const QPointF &c2, const QPointF &p );

    KoPathPoint * arcTo( double rx, double ry, double startAngle, double sweepAngle );

    void close();

    void closeMerge();

    void update();

    virtual QPointF normalize();

    QList<KoPathPoint*> pointsAt( const QRectF &r );

    void insertPoint( KoPathPoint* point, KoSubpath* subpath, int position );

    KoPointPosition removePoint( KoPathPoint *point );

    KoPathPoint* splitAt( const KoPathSegment &segment, double t );

    bool breakAt( KoPathPoint *breakPoint, KoPathPoint* &insertedPoint );

    bool breakAt( const KoPathSegment &segment );

    bool joinBetween( KoPathPoint *endPoint1, KoPathPoint *endPoint2 );

    bool combine( KoPathShape *path );

    bool separate( QList<KoPathShape*> & separatedPaths );

#if 0 // not used yet

    bool insertPointAfter( KoPathPoint *point, KoPathPoint *prevPoint );

    bool insertPointBefore( KoPathPoint *point, KoPathPoint *nextPoint );

    KoPathPoint* prevPoint( KoPathPoint* point );
#endif

    KoPathPoint* nextPoint( KoPathPoint* point );

    void debugPath();

    QPointF shapeToDocument( const QPointF &point ) const;
    
    QRectF shapeToDocument( const QRectF &rect ) const;
    
    QPointF documentToShape( const QPointF &point ) const;
    
    QRectF documentToShape( const QRectF &rect ) const;

private:
    void map( const QMatrix &matrix );

    void updateLast( KoPathPoint ** lastPoint );

    void closeSubpath( KoSubpath *subpath );
    void closeMergeSubpath( KoSubpath *subpath );
    KoPointPosition findPoint( KoPathPoint* point );
    void reverseSubpath( KoSubpath &subpath );
#ifndef NDEBUG
    void paintDebug( QPainter &painter );
#endif

protected:    
    QRectF handleRect( const QPointF &p ) const;
    int arcToCurve( double rx, double ry, double startAngle, double sweepAngle, const QPointF & offset, QPointF * curvePoints ) const;

    KoSubpathList m_subpaths;
};

Q_DECLARE_OPERATORS_FOR_FLAGS( KoPathPoint::KoPointProperties )

#endif /* KOPATHSHAPE_H */

---