F:/KPlato/koffice/libs/flake/KoPathTool.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 KOPATHTOOL_H
#define KOPATHTOOL_H

#include "KoPathShape.h"

#include <KoTool.h>
#include <QMap>
#include <QSet>

class KoCanvasBase;
class KoParameterShape;
class KoInteractionStrategy;
class KoPathPointMoveStrategy;
class KoPathPointRubberSelectStrategy;

class KoPathTool : public KoTool {
public:
    KoPathTool(KoCanvasBase *canvas);
    ~KoPathTool();

    void paint( QPainter &painter, KoViewConverter &converter );

    void mousePressEvent( KoPointerEvent *event );
    void mouseDoubleClickEvent( KoPointerEvent *event );
    void mouseMoveEvent( KoPointerEvent *event );
    void mouseReleaseEvent( KoPointerEvent *event );
    void keyPressEvent(QKeyEvent *event);
    void keyReleaseEvent(QKeyEvent *event);

    void activate (bool temporary=false);
    void deactivate();

private:
    void selectPoints( const QRectF &rect, bool clearSelection );

    void repaint( const QRectF &repaintRect );
    QRectF handleRect( const QPointF &p );

    // needed for interaction strategy
    QPointF m_lastPoint;
    QPointF snapToGrid( const QPointF &p, Qt::KeyboardModifiers modifiers );
private:

    class ActiveHandle
    {
    public:    
        ActiveHandle( KoPathTool *tool )
        : m_tool( tool )
        {}
        virtual ~ActiveHandle() {};
        virtual void paint( QPainter &painter, KoViewConverter &converter ) = 0; 
        virtual void repaint() const = 0;
        virtual void mousePressEvent( KoPointerEvent *event ) = 0;

        KoPathTool *m_tool;
    };

    class ActivePointHandle : public ActiveHandle
    {
    public:    
        ActivePointHandle( KoPathTool *tool, KoPathPoint *activePoint, KoPathPoint::KoPointType activePointType )
        : ActiveHandle( tool )
        , m_activePoint( activePoint )
        , m_activePointType( activePointType )
        {}
        void paint( QPainter &painter, KoViewConverter &converter );
        void repaint() const;
        void mousePressEvent( KoPointerEvent *event );

        KoPathPoint *m_activePoint;
        KoPathPoint::KoPointType m_activePointType;
    };

    class ActiveParameterHandle : public ActiveHandle
    {
    public:    
        ActiveParameterHandle( KoPathTool *tool, KoParameterShape *parameterShape, int handleId )
        : ActiveHandle( tool )
        , m_parameterShape( parameterShape )
        , m_handleId( handleId )
        {}
        void paint( QPainter &painter, KoViewConverter &converter );
        void repaint() const;
        void mousePressEvent( KoPointerEvent *event );

        KoParameterShape *m_parameterShape;
        int m_handleId;
    };

    class KoPathPointSelection
    {
    public:    
        KoPathPointSelection( KoPathTool * tool )
        : m_tool( tool )
        {}
        ~KoPathPointSelection() {}

        void paint( QPainter &painter, KoViewConverter &converter ); 
        
        void add( KoPathPoint * point, bool clear );
        
        void remove( KoPathPoint * point );
        
        void clear();

        int objectCount() const { return m_shapePointMap.size(); }

        int size() const { return m_selectedPoints.size(); }

        bool contains( KoPathPoint * point ) { return m_selectedPoints.contains( point ); }

        const QSet<KoPathPoint *> & selectedPoints() const { return m_selectedPoints; }

        const KoPathShapePointMap & selectedPointMap() const { return m_shapePointMap; }

        void repaint();

    private:
        QSet<KoPathPoint *> m_selectedPoints;
        KoPathShapePointMap m_shapePointMap;
        KoPathTool * m_tool;
    };

    
    ActiveHandle * m_activeHandle;       
    int m_handleRadius;                

    KoPathPointSelection m_pointSelection;

    friend class ActiveNoHandle;
    friend class ActivePointHandle;
    friend class KoPathPointSelection;
    friend class KoPathPointMoveStrategy;
    friend class KoPathControlPointMoveStrategy;
    friend class KoPathPointRubberSelectStrategy;

    KoInteractionStrategy *m_currentStrategy; 
};

#endif

---