odgraphicsitem.h

Go to the documentation of this file.

#ifndef odgraphicsitem_h
#define odgraphicsitem_h
 
/*+
________________________________________________________________________
 
 (C) dGB Beheer B.V.; (LICENSE) http://opendtect.org/OpendTect_license.txt
 Author:        Nanne Hemstra
 Date:          April 2008
 RCS:           $Id$
________________________________________________________________________
 
-*/
 
 
#include <QGraphicsItem>
#include <QPolygonF>
#include <QString>
#include <QTextOption>
#include <QMutex>
#include <QWaitCondition>
#include <QFont>
 
#include "draw.h"
 
class uiPixmap;
 
static int ODGraphicsType = 100000;
 
class ODGraphicsHighlightItem
{
public:
    virtual void                highlight()     {}
    virtual void                unHighlight()   {}
 
    virtual void                setQPen(const QPen&)    {}
};
 
 
class ODGraphicsPointItem : public QAbstractGraphicsShapeItem
{
public:
                                ODGraphicsPointItem();
 
    QRectF                      boundingRect() const;
    void                        paint(QPainter*,const QStyleOptionGraphicsItem*,
                                      QWidget*);
 
    void                        drawPoint(QPainter*);
    void                        setHighLight( bool hl )
                                { highlight_ = hl ; }
    void                        setColor( const Color& col )
                                { pencolor_ = col ; }
 
    virtual int                 type() const    { return ODGraphicsType+1; }
 
protected:
    virtual void                mouseMoveEvent(QGraphicsSceneMouseEvent*);
    bool                        highlight_;
    int                         penwidth_;
    Color                       pencolor_;
};
 
 
 
class ODGraphicsMarkerItem : public QAbstractGraphicsShapeItem
{
public:
                                ODGraphicsMarkerItem();
    virtual                     ~ODGraphicsMarkerItem();
 
    QRectF                      boundingRect() const;
    void                        paint(QPainter*,const QStyleOptionGraphicsItem*,
                                      QWidget*);
    static void                 drawMarker(QPainter&,MarkerStyle2D::Type,
                                           float,float);
 
    void                        setMarkerStyle(const MarkerStyle2D&);
    void                        setFill( bool fill )      { fill_ = fill; }
    void                        setFillColor( const Color& col )
                                { fillcolor_ = col; }
    void                        setSideLength( int side ) { side_ = side; }
 
    virtual int                 type() const    { return ODGraphicsType+2; }
    const MarkerStyle2D*        getMarkerStyle() { return mstyle_; }
 
protected:
    virtual void                mouseMoveEvent(QGraphicsSceneMouseEvent*);
    QRectF                      boundingrect_;
    MarkerStyle2D*              mstyle_;
    Color                       fillcolor_;
    bool                        fill_;
    int                         side_;
};
 
 
class ODGraphicsPixmapItem : public QGraphicsPixmapItem
{
public:
                                ODGraphicsPixmapItem();
                                ODGraphicsPixmapItem(const uiPixmap&);
 
    void                        paint(QPainter*,const QStyleOptionGraphicsItem*,
                                      QWidget*);
 
    virtual int                 type() const    { return ODGraphicsType+3; }
    void                        setPaintInCenter(bool);
 
protected:
    virtual void                mouseMoveEvent(QGraphicsSceneMouseEvent*);
    virtual void                hoverEnterEvent(QGraphicsSceneHoverEvent*);
    virtual void                hoverLeaveEvent(QGraphicsSceneHoverEvent*);
 
    bool                        paintincenter_;
 
};
 
 
class ODGraphicsArrowItem : public QAbstractGraphicsShapeItem
{
public:
                                ODGraphicsArrowItem();
 
    QRectF                      boundingRect() const;
    void                        paint(QPainter*,const QStyleOptionGraphicsItem*,
                                      QWidget*);
 
    void                        drawArrow(QPainter&);
    double                      getAddedAngle(double,float);
    QPoint                      getEndPoint(const QPoint&,double,double);
    void                        drawArrowHead(QPainter&,const QPoint&,
                                              const QPoint&);
    void                        setArrowStyle( const ArrowStyle& arrowstyle )
                                { arrowstyle_ = arrowstyle ; }
    void                        setArrowSize( const int arrowsz )
                                { arrowsz_ = arrowsz ; }
    void                        setLineStyle(QPainter&,const OD::LineStyle&);
 
    virtual int                 type() const    { return ODGraphicsType+4; }
 
protected:
    virtual void                mouseMoveEvent(QGraphicsSceneMouseEvent*);
 
    ArrowStyle                  arrowstyle_;
    int                         arrowsz_;
};
 
 
class ODGraphicsTextItem : public QAbstractGraphicsShapeItem
{
public:
                                ODGraphicsTextItem();
 
    QRectF                      boundingRect() const;
    void                        paint(QPainter*,const QStyleOptionGraphicsItem*,
                                      QWidget*);
 
    void                        setText(const QString&);
    void                        setFont(const QFont&);
    QFont                       getFont() const;
 
    void                        setVAlignment(const Qt::Alignment&);
    void                        setHAlignment(const Qt::Alignment&);
 
    virtual int                 type() const    { return ODGraphicsType+5; }
 
protected:
    virtual void                mouseMoveEvent(QGraphicsSceneMouseEvent*);
    QPointF                     getAlignment() const;
 
    QFont                       font_;
    QString                     text_;
    Qt::Alignment               hal_;
    Qt::Alignment               val_;
};
 
 
class ODGraphicsAdvancedTextItem : public QGraphicsTextItem
{
public:
                                ODGraphicsAdvancedTextItem(bool);
 
protected:
    virtual void                mouseMoveEvent(QGraphicsSceneMouseEvent*);
};
 
 
class ODGraphicsPathItem : public QGraphicsPathItem
                         , public ODGraphicsHighlightItem
{
public:
                                ODGraphicsPathItem();
                                ~ODGraphicsPathItem();
 
    void                        set(const QPainterPath&);
    QPainterPath                shape() const;
 
    void                        setQPen(const QPen& pen);
    void                        highlight();
    void                        unHighlight();
 
protected:
    QPainterPath                path_;
    QPen&                       mypen_;
};
 
 
class ODGraphicsPolyLineItem : public QAbstractGraphicsShapeItem
                             , public ODGraphicsHighlightItem
{
public:
                                ODGraphicsPolyLineItem();
                                ~ODGraphicsPolyLineItem();
 
    QRectF                      boundingRect() const;
    void                        paint(QPainter*,const QStyleOptionGraphicsItem*,
                                      QWidget*);
    QPainterPath                shape() const;
 
    void                        setPolyLine(const QPolygonF&,bool closed);
    void                        setFillRule(Qt::FillRule);
    bool                        isEmpty() const;
    void                        setEmpty();
 
    void                        setQPen(const QPen& pen);
    void                        highlight();
    void                        unHighlight();
 
    virtual int                 type() const    { return ODGraphicsType+6; }
 
protected:
    virtual void                mouseMoveEvent(QGraphicsSceneMouseEvent*);
 
    bool                        closed_;
    QPolygonF                   qpolygon_;
    Qt::FillRule                fillrule_;
    QPainterPath                path_;
    QPen&                       mypen_;
};
 
 
class ODGraphicsMultiColorPolyLineItem : public QAbstractGraphicsShapeItem
                                       , public ODGraphicsHighlightItem
{
public:
                                ODGraphicsMultiColorPolyLineItem();
                                ~ODGraphicsMultiColorPolyLineItem();
 
    QRectF                      boundingRect() const;
    void                        paint(QPainter*,
                                      const QStyleOptionGraphicsItem*,
                                      QWidget*);
    QPainterPath                shape() const;
 
    void                        setPolyLine(const QPolygonF&);
    void                        setQPens(const QVector<QPen>&);
    void                        setPenWidth(int);
 
    void                        highlight()     { highlight_ = true; }
    void                        unHighlight()   { highlight_ = false; }
 
    virtual int                 type() const    { return ODGraphicsType+8; }
 
protected:
 
                                class ODLineSegment
                                {
                                public:
                                    QPolygonF           qpolygon_;
                                    QVector<QPen>       qpens_;
 
                                    bool                isEmpty() const;
                                    void                add(const QPointF&,
                                                            const QPen&);
                                    void                setWidth(int);
                                };
 
    virtual void                mouseMoveEvent(QGraphicsSceneMouseEvent*);
    void                        cleanupPolygon();
 
    bool                        highlight_;
    QPolygonF                   inputqpolygon_;
    QVector<QPen>               inputqpens_;
    QVector<ODLineSegment>      odlinesegments_;
    QRectF                      brect_;
    QPainterPath                path_;
};
 
 
class ODGraphicsItemGroup : public QGraphicsItemGroup
{
public:
                                ODGraphicsItemGroup();
 
    QRectF                      boundingRect() const;
    void                        paint(QPainter*,const QStyleOptionGraphicsItem*,
                                      QWidget*);
protected:
    virtual void                mouseMoveEvent(QGraphicsSceneMouseEvent*);
 
};
 
 
class ODGraphicsDynamicImageItem : public QGraphicsItem, public CallBacker
{
public:
                                ODGraphicsDynamicImageItem();
 
    QRectF                      boundingRect() const { return bbox_; }
    void                        paint(QPainter*,const QStyleOptionGraphicsItem*,
                                      QWidget*);
 
    void                        setImage(bool isdynamic,const QImage&,
                                         const QRectF&);
    bool                        updateResolution(const QPainter*);
    const QRectF&               wantedWorldRect() const;
    const QSize&                wantedScreenSize() const;
 
    virtual int                 type() const    { return ODGraphicsType+7; }
 
    Notifier<ODGraphicsDynamicImageItem>        wantsData;
    bool                                        isSnapshot() const;
protected:
    virtual void                mouseMoveEvent(QGraphicsSceneMouseEvent*);
 
    QRectF                      wantedwr_;
    QSize                       wantedscreensz_;
 
    QMutex                      imagelock_;
    QWaitCondition              imagecond_;
    bool                        updatedynpixmap_;
    QImage                      dynamicimage_;
    QRectF                      dynamicimagebbox_;
    bool                        dynamicrev_[2];
    bool                        updatebasepixmap_;
    QImage                      baseimage_;
    QRectF                      bbox_;
    bool                        baserev_[2];
    bool                        issnapshot_;
 
    PtrMan<QPixmap>             basepixmap_;    //Only access in paint
    PtrMan<QPixmap>             dynamicpixmap_; //Only access in paint
    QRectF                      dynamicpixmapbbox_; //Only access in paint
 
};
 
#endif