graphic_items.h

Go to the documentation of this file.

#ifndef GRAPHIC_ITEMS_H
#define GRAPHIC_ITEMS_H

#include <QtGui>

#include "module_interface.h"

class GraphicFactory : public ModuleFactory
{
        public:
                GraphicFactory() : ModuleFactory("graphics", "Standard Graphic Items") {};
                void init();
                inline ModulType type() { return ModuleFactory::NoPlugin; }
                ModuleInterface* create(const QString&);
};

class GraphicItem : public PluginInterface, public QGraphicsItem
{
        Q_OBJECT
        Q_PROPERTY(QPointF pos READ pos WRITE setPos)
        Q_PROPERTY(qreal zvalue READ zValue WRITE setZValue)
        Q_PROPERTY(qreal rotate READ rotate WRITE setRotate)
        Q_PROPERTY(qreal scale READ scale WRITE setScale)
        Q_PROPERTY(qreal shear READ shear WRITE setShear)

        private slots:
                void updateTimeline(qreal);
                void forwards();
                void front();
                void backwards();
                void back();

        public:
                GraphicItem();
                bool init();

                void setRotate(qreal);
                void setScale(qreal);
                void setShear(qreal);

                inline QMenu* contextMenu() { return &m_contextMenu; }
                inline qreal rotate() { return m_rotation; }
                inline qreal scale() { return m_scale; }
                inline qreal shear() { return m_shear; }

        protected:
                void drawDecoration(QPainter*, const QRectF&, const QStyleOptionGraphicsItem*);
                QRectF calcBoundingRect(const QRectF&) const;

                void mousePressEvent(QGraphicsSceneMouseEvent*);
                void mouseReleaseEvent(QGraphicsSceneMouseEvent*);
                void mouseMoveEvent(QGraphicsSceneMouseEvent*);
                void hoverMoveEvent(QGraphicsSceneHoverEvent*);

        private:
                enum Segment { NoSegment, TopLeftSegment, TopRightSegment, BottomLeftSegment, BottomRightSegment, NumSegments };
                QRectF rectForSegment(Segment) const;
                bool isPointInSegment(const QPointF&, Segment);

                QMenu m_contextMenu;
                const QSizeF segmentSize;
                QRectF m_boundingRect;
                bool m_grabbed;
                qreal m_opacity;
                qreal m_rotation;
                qreal m_newRotation;
                qreal m_scale;
                qreal m_newScale;
                qreal m_shear;
                QTimeLine m_timeline;
};

class GraphicStandardItem : public GraphicItem
{
        Q_OBJECT
        Q_PROPERTY(QPen pen READ pen WRITE setPen)
        Q_PROPERTY(QBrush brush READ brush WRITE setBrush)

        public:
                bool init();
                inline void setBrush(const QBrush& brush){ m_brush = brush; }
                inline void setPen(const QPen& pen) { m_pen = pen;  }

                inline QBrush brush() const { return m_brush; }
                inline QPen pen() const { return m_pen; }

        private:
                QPen m_pen;
                QBrush m_brush;
};

class GraphicLine : public GraphicStandardItem
{
        Q_OBJECT
        Q_PROPERTY(QLineF line READ line WRITE setLine)

        public:
                bool init();
                void paint(QPainter*, const QStyleOptionGraphicsItem* , QWidget* widget = 0);
                QRectF boundingRect() const;
                inline QGraphicsItem* graphicsItem(){ return this; }

                inline void setLine(const QLineF& line) { prepareGeometryChange(); m_line = line; }
                inline QLineF line() const { return m_line; }

        private:
                QLineF m_line;
};

class GraphicRectangle : public GraphicStandardItem
{
        Q_OBJECT
        Q_PROPERTY(QRectF rect READ rect WRITE setRect)

        public:
                bool init();
                void paint(QPainter*, const QStyleOptionGraphicsItem* , QWidget* widget = 0);
                QRectF boundingRect() const;
                inline QGraphicsItem* graphicsItem(){ return this; }
                inline void setRect(const QRectF& rect) { prepareGeometryChange(); m_rect = rect; }
                inline QRectF rect() const { return m_rect; }

        private:
                QRectF m_rect;
};

class GraphicEllipse : public GraphicStandardItem
{
        Q_OBJECT
        Q_PROPERTY(QRectF rect READ rect WRITE setRect)
        Q_PROPERTY(int startangle READ startAngle WRITE setStartAngle)
        Q_PROPERTY(int spanangle READ spanAngle WRITE setSpanAngle)

        public:
                bool init();
                void paint(QPainter*, const QStyleOptionGraphicsItem* , QWidget* widget = 0);
                QRectF boundingRect() const;
                inline QGraphicsItem* graphicsItem(){ return this; }
                inline void setRect(const QRectF& rect) { prepareGeometryChange(); m_rect = rect; }
                inline void setStartAngle(int startAngle) { m_startAngle = startAngle;  }
                inline void setSpanAngle(int spanAngle) { m_spanAngle = spanAngle;  }

                inline QRectF rect() const { return m_rect; }
                inline int startAngle() { return m_startAngle; }
                inline int spanAngle() { return m_spanAngle; }

        private:
                QRectF m_rect;
                int m_startAngle;
                int m_spanAngle;
};

class GraphicPolygon : public GraphicStandardItem
{
        Q_OBJECT
        Q_PROPERTY(QPolygon polygon READ polygon WRITE setPolygon)

        public:
                bool init();
                void paint(QPainter*, const QStyleOptionGraphicsItem* , QWidget* widget = 0);
                QRectF boundingRect() const;
                inline QGraphicsItem* graphicsItem(){ return this; }
                inline void setPolygon(const QPolygon& polygon) { prepareGeometryChange(); m_polygon = polygon; }
                inline QPolygon polygon() const { return m_polygon; }
                void addPoint(const QPoint&);

        private:
                QPolygon m_polygon;

};

class GraphicPixmap : public GraphicItem
{
        Q_OBJECT
        Q_PROPERTY(QPixmap pixmap READ pixmap WRITE setPixmap)
        Q_PROPERTY(QSize size READ size WRITE setSize)
        Q_PROPERTY(bool invert READ invert WRITE setInvert)
        Q_PROPERTY(DitherStatus dither READ dither WRITE setDither)
        Q_PROPERTY(RatioStatus ratio READ ratio WRITE setRatio)
        Q_ENUMS(DitherStatus)
        Q_ENUMS(RatioStatus)

        public:
                enum DitherStatus { DiffuseDither, OrderedDither, ThresholdDither };
                enum RatioStatus { IgnoreAspectRatio, KeepAspectRatio, KeepAspectRatioByExpanding };
                bool init();
                void paint(QPainter*, const QStyleOptionGraphicsItem* , QWidget* widget = 0);
                QRectF boundingRect() const;
                inline QGraphicsItem* graphicsItem(){ return this; }
                void setPixmap(const QPixmap&);
                void setSize(const QSize&);
                void setInvert(bool);
                void setDither(DitherStatus);
                void setRatio(RatioStatus);
                void setPath(const QString&);
                inline QPixmap pixmap() const { return m_pixmap; }
                inline QString path() const { return m_path; }
                inline QSize size() const { return m_size; }
                inline bool invert() { return m_invert; }
                inline DitherStatus dither() { return m_dither; }
                inline RatioStatus ratio() { return m_ratio; }

        private:
                void updatePixmap();

                DitherStatus m_dither;
                RatioStatus m_ratio;
                QPixmap m_pixmap;
                QPixmap m_tmpPixmap;
                QSize m_size;
                QString m_path;
                bool m_invert;
};

class GraphicText : public GraphicItem
{
        Q_OBJECT
        Q_PROPERTY(QString text READ text WRITE setText)
        Q_PROPERTY(qreal textwidth READ textWidth WRITE setTextWidth)
        Q_PROPERTY(QFont font READ font WRITE setFont)
        Q_PROPERTY(TextType texttype READ textType WRITE setTextType)
        Q_ENUMS(TextType)

        public:
                enum TextType { PlainText, HtmlText };
                bool init();
                void paint(QPainter*, const QStyleOptionGraphicsItem* , QWidget* widget = 0);
                QRectF boundingRect() const;
                inline QGraphicsItem* graphicsItem(){ return this; }
                void setText(const QString&);
                inline void setFont(const QFont& font) { m_doc.setDefaultFont(font);  }
                inline void setTextWidth(qreal textwidth) { prepareGeometryChange(); m_doc.setTextWidth(textwidth); }
                void setTextType(TextType);

                inline QString text() const { return m_text; }
                inline QFont font() const { return m_doc.defaultFont(); }
                inline qreal textWidth() { return m_doc.textWidth(); }
                inline TextType textType() { return m_type; }

        private:
                QTextDocument m_doc;

                QString m_text;
                TextType m_type;
};

#endif

---