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

Aller à la documentation de ce fichier.

/* This file is part of the KDE project
 * Copyright (C) 2006 Jan Hambrecht <jaham@gmx.net>
 * 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 KOPATHCOMMAND_H
#define KOPATHCOMMAND_H

#include <kcommand.h>
#include <QList>
#include <QMap>
#include <QPointF>
#include "KoPathShape.h"

class KoParameterShape;

class KoPathBaseCommand : public KCommand {
public:
    KoPathBaseCommand( KoPathShape *shape );
protected:
    void repaint( const QRectF &oldControlPointRect );
    KoPathShape *m_shape; 
};

class KoPointMoveCommand : public KCommand 
{
public:
    KoPointMoveCommand( const KoPathShapePointMap &pointMap, const QPointF &offset );

    void execute();
    void unexecute();
    QString name() const;
private:
    KoPathShapePointMap m_pointMap;
    QPointF m_offset;
};

class KoControlPointMoveCommand : public KCommand
{
public:
    KoControlPointMoveCommand( KoPathPoint *point, const QPointF &offset, KoPathPoint::KoPointType pointType );
    void execute();
    void unexecute();
    QString name() const;
private:
    KoPathPoint * m_point;
    // the offset in shape coordinates
    QPointF m_offset;
    KoPathPoint::KoPointType m_pointType;
};

class KoPointPropertyCommand : public KoPathBaseCommand {
public:
    KoPointPropertyCommand( KoPathShape *shape, KoPathPoint *point, KoPathPoint::KoPointProperties property );
    void execute();
    void unexecute();
    QString name() const;
private:
    KoPathPoint* m_point;
    KoPathPoint::KoPointProperties m_newProperties;
    KoPathPoint::KoPointProperties m_oldProperties;
    QPointF m_controlPoint1;
    QPointF m_controlPoint2;
};

class KoPointRemoveCommand : public KCommand {
public:
    KoPointRemoveCommand( const KoPathShapePointMap &pointMap );
    void execute();
    void unexecute();
    QString name() const;
private:
    struct KoPointRemoveData
    {
        KoPointRemoveData( KoPathPoint * point, KoSubpath * subpath, int position )
        : m_point( point )
        , m_subpath( subpath )
        , m_position( position )
        {}
        KoPathPoint * m_point;
        KoSubpath * m_subpath;
        int m_position;
    };
    KoPathShapePointMap m_pointMap;
    QList<KoPointRemoveData> m_data;
};

class KoSegmentSplitCommand : public KoPathBaseCommand
{
public:
    KoSegmentSplitCommand( KoPathShape *shape, const KoPathSegment &segment, double splitPosition );
    KoSegmentSplitCommand( KoPathShape *shape, const QList<KoPathSegment> &segments, const QList<double> &splitPositions );
    KoSegmentSplitCommand( KoPathShape *shape, const QList<KoPathSegment> &segments, double splitPosition );
    virtual ~KoSegmentSplitCommand();
    void execute();
    void unexecute();
    QString name() const;
private:
    QList<KoPathSegment> m_segments;
    typedef QPair<KoPathPoint,KoPathPoint> KoSegmentData;
    QList<KoSegmentData> m_oldNeighbors;
    QList<KoSegmentData> m_newNeighbors;
    QList<double> m_splitPos;
    QList<KoPathPoint*> m_splitPoints;
    bool m_deletePoint;
    QList< QPair<KoSubpath*,int> > m_splitPointPos;
};

class KoPointJoinCommand : public KoPathBaseCommand
{
public:
    KoPointJoinCommand( KoPathShape *shape, KoPathPoint *point1, KoPathPoint *point2 );
    void execute();
    void unexecute();
    QString name() const;
private:
    KoPathPoint* m_point1;
    KoPathPoint* m_point2;
    bool m_joined;
};

class KoSubpathBreakCommand : public KoPathBaseCommand
{
public:
    KoSubpathBreakCommand( KoPathShape *shape, KoPathPoint *breakPoint );
    KoSubpathBreakCommand( KoPathShape *shape, const KoPathSegment &segment );
    virtual ~KoSubpathBreakCommand();
    void execute();
    void unexecute();
    QString name() const;
private:
    KoPathPoint* m_breakPoint;
    KoPathSegment m_segment;
    bool m_breakSegment;
    bool m_broken;
    KoPathPoint* m_newPoint;
    KoPathPoint m_pointData1; 
    KoPathPoint m_pointData2; 
};

class KoSegmentTypeCommand : public KoPathBaseCommand
{
public:
    KoSegmentTypeCommand( KoPathShape *shape, const KoPathSegment &segment, bool changeToLine );
    KoSegmentTypeCommand( KoPathShape *shape, const QList<KoPathSegment> &segments, bool changeToLine );
    void execute();
    void unexecute();
    QString name() const;
private:
    QList<KoPathSegment> m_segments;
    QMap<KoPathPoint*,KoPathPoint> m_oldPointData;
    bool m_changeToLine;
};

class KoShapeControllerBase;

class KoPathCombineCommand : public KCommand
{
public:
    KoPathCombineCommand( KoShapeControllerBase *controller, const QList<KoPathShape*> &paths );
    virtual ~KoPathCombineCommand();
    void execute();
    void unexecute();
    QString name() const;
private:
    KoShapeControllerBase *m_controller;
    QList<KoPathShape*> m_paths;
    KoPathShape *m_combinedPath;
    bool m_isCombined;
};

class KoParameterChangeCommand : public KCommand
{
public:
    KoParameterChangeCommand( KoParameterShape *shape, int handleId, const QPointF &startPoint, const QPointF &endPoint );
    virtual ~KoParameterChangeCommand();

    void execute();
    void unexecute();
    QString name() const;
private:
    KoParameterShape *m_shape;
    int m_handleId;
    QPointF m_startPoint;
    QPointF m_endPoint;
};

class KoParameterToPathCommand : public KCommand
{
public:
    KoParameterToPathCommand( KoParameterShape *shape );
    virtual ~KoParameterToPathCommand();

    void execute();
    void unexecute();
    QString name() const;
private:
    KoParameterShape *m_shape;
};

class KoPathSeparateCommand : public KCommand
{
public:
    KoPathSeparateCommand( KoShapeControllerBase *controller, const QList<KoPathShape*> &paths );
    virtual ~KoPathSeparateCommand();
    void execute();
    void unexecute();
    QString name() const;
private:
    KoShapeControllerBase *m_controller;
    QList<KoPathShape*> m_paths;
    QList<KoPathShape*> m_separatedPaths;
    bool m_isSeparated;
};

#endif

---