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

Aller à la documentation de ce fichier.

/* This file is part of the KDE project
   Copyright (C) 2006 Thorsten Zachmann <zachmann@kde.org>
   Copyright (C) 2006 Casper Boemann Rasmussen <cbr@boemann.dk>
   Copyright (C) 2006 Thomas Zander <zander@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 KOSHAPE_H
#define KOSHAPE_H

#include <QMatrix>
#include <QVector>
#include <QSet>
#include <QBrush>

#include <koffice_export.h>

class QPainter;
class QRectF;
class QPainterPath;
class QVariant;

class KoSelection;
class KoPointerEvent;
class KoShapeContainer;
class KoShapeBorderModel;
class KoShapeManager;
class KoShapeUserData;
class KoViewConverter;

class FLAKE_EXPORT KoShape
{
public:
    KoShape();

    virtual ~KoShape();

    virtual void paint(QPainter &painter, const KoViewConverter &converter) = 0;

    virtual void paintDecorations(QPainter &painter, const KoViewConverter &converter, bool selected);

    void scale( double sx, double sy );

    double scaleX() const { return m_scaleX; }

    double scaleY() const { return m_scaleY; }

    void rotate( double angle );

    double rotation() const { return m_angle; }

    void shear( double sx, double sy );

    double shearX() const { return m_shearX; }

    double shearY() const { return m_shearY; }

    virtual void resize( const QSizeF &size );

    virtual QSizeF size() const { return m_size; }

    virtual void setPosition( const QPointF &position );

    virtual QPointF position() const { return m_pos; }

    virtual bool hitTest( const QPointF &position ) const;

    virtual QRectF boundingRect() const;

    void addConnectionPoint( const QPointF &point ) { m_connectors.append( point ); }

    QList<QPointF> connectors() const { return m_connectors.toList(); }

    void setBackground ( const QBrush & brush ) { m_backgroundBrush = brush; }

    const QBrush& background () { return m_backgroundBrush; }

    virtual bool hasTransparency();

    int zIndex() const;

    void setZIndex(int zIndex) { m_zIndex = zIndex; }

    void setVisible(bool on) { m_visible = on; }
    bool isVisible() const { return m_visible; }

    void setSelectable(bool selectable) { m_selectable = selectable; }
    bool isSelectable() const { return m_selectable; }

    void setLocked(bool locked) { m_locked = locked; }
    bool isLocked() const { return m_locked; }

    KoShapeContainer *parent() const { return m_parent; }

    void setParent(KoShapeContainer *parent);

    virtual void repaint() const;

    void repaint(const QRectF &shape) const;

    void repaint(double x, double y, double width, double height) const;

    static bool compareShapeZIndex(KoShape *g1, KoShape *g2);

    void recalcMatrix();

    virtual const QPainterPath outline() const;

    KoShapeBorderModel *border() { return m_border; }

    void setBorder(KoShapeBorderModel *border) { m_border = border; }

    void setKeepAspectRatio(bool keepAspect) { m_keepAspect = keepAspect; }

    bool keepAspectRatio() const { return m_keepAspect; }

    QPointF absolutePosition() const;

    void setAbsolutePosition(QPointF newPosition);

    void moveBy(double distanceX, double distanceY);

    void setUserData(KoShapeUserData *userData);
    KoShapeUserData *userData() const;

    const QString & shapeId() const { return m_shapeId; }
    void setShapeId(const QString &id) { m_shapeId = id; }

    QMatrix transformationMatrix(const KoViewConverter *converter) const;

    virtual void copySettings(const KoShape *shape);

    static void applyConversion(QPainter &painter, const KoViewConverter &converter);

protected:
    QMatrix m_invMatrix; 
    QBrush m_backgroundBrush; 
    KoShapeBorderModel *m_border; 

    virtual void updateTree();

    enum ChangeType {
        PositionChanged, 
        RotationChanged, 
        ScaleChanged,   
        ShearChanged,   
        SizeChanged,    
        ParentChanged   
    };

    virtual void shapeChanged(ChangeType type) { Q_UNUSED(type); }

private:
    double m_scaleX;
    double m_scaleY;
    double m_angle; // degrees
    double m_shearX;
    double m_shearY;

    QSizeF m_size; // size in pt
    QPointF m_pos; // position (top left) in pt
    QString m_shapeId;

    QMatrix m_matrix;

    QVector<QPointF> m_connectors; // in pt

    int m_zIndex;
    KoShapeContainer *m_parent;

    bool m_visible, m_locked, m_keepAspect, m_selectable;


    QSet<KoShapeManager *> m_shapeManagers;

private:
    friend class KoShapeManager;
    void addShapeManager( KoShapeManager * manager ) { m_shapeManagers.insert( manager ); }
    void removeShapeManager( KoShapeManager * manager ) { m_shapeManagers.remove( manager ); }
    KoShapeUserData *m_userData;
};

#endif

---