ConnectionGraphicsItem.h

Go to the documentation of this file.

/****************************************************************************

Copyright (c) 2008 Deepak Chandran
Contact: Deepak Chandran (dchandran1@gmail.com)
See COPYRIGHT.TXT

This is the header file for the connection graphics item, which is a Qt graphics path item
that draws a connection between two or more nodes. 

The connection graphics items defines a new control point item inside itself. 

This header file also contains the arrow head item class. The arrow head item inherits from
node graphics item and is used to draw the arrow heads at the end of the connection items.


****************************************************************************/

#ifndef TINKERCELL_CONNECTIONGRAPHICSITEM_H
#define TINKERCELL_CONNECTIONGRAPHICSITEM_H

#include <math.h>
#include <QtDebug>
#include <QString>
#include <QColor>
#include <QPointF>
#include <QPainter>
#include <QGraphicsEllipseItem>
#include <QGraphicsItem>
#include <QStyleOptionGraphicsItem>
#include <QGraphicsScene>
#include "NodeGraphicsItem.h"

namespace Tinkercell
{
        class ItemHandle;

        TINKERCELLCOREEXPORT QPointF pointOnEdge(const QRectF&, const QPointF&, qreal dist = 0, bool straight = false);
        TINKERCELLCOREEXPORT QPointF pointOnEdge(const NodeGraphicsItem&, const QPointF&, qreal dist = 0, bool straight = false);

        class GraphicsScene;
        class ItemHandle;
        class ConnectionGraphicsItem;
        
        class TINKERCELLCOREEXPORT ArrowHeadItem : public NodeGraphicsItem
        {
        public:
                ConnectionGraphicsItem * connectionItem;
                qreal angle;
                ArrowHeadItem(ConnectionGraphicsItem * c = 0);
                ArrowHeadItem(const QString&, ConnectionGraphicsItem * c = 0);
                ArrowHeadItem(const ArrowHeadItem&);
                virtual void paint(QPainter *painter, const QStyleOptionGraphicsItem *option=new QStyleOptionGraphicsItem() ,QWidget *widget=0);        
                virtual NodeGraphicsItem* clone() const;
                static ArrowHeadItem* cast(QGraphicsItem *);
                enum { Type = UserType + 6 };
                virtual int type() const
                {
                        // Enable the use of dynamic_cast with this item.
                        return Type;
                }
                static const QString CLASSNAME;
        };

        class TINKERCELLCOREEXPORT ConnectionGraphicsItem : public QGraphicsItemGroup
        {
        public:
                static ConnectionGraphicsItem* cast(QGraphicsItem*);
                static QList<ConnectionGraphicsItem*> cast(const QList<QGraphicsItem*>&);
                static const QString CLASSNAME;
                static QString DefaultMiddleItemFile;
                static QString DefaultArrowHeadFile;
                QString name;
                QString className;
                QPen defaultPen;
                static ConnectionGraphicsItem * topLevelConnectionItem(QGraphicsItem* item,bool includeControlPoints = false);
                ConnectionGraphicsItem(QGraphicsItem * parent = 0 );
                ConnectionGraphicsItem(const QList<NodeGraphicsItem*>&, const QList<NodeGraphicsItem*>&, QGraphicsItem * parent = 0);
                ConnectionGraphicsItem(const ConnectionGraphicsItem& copy);
                virtual ConnectionGraphicsItem& operator = (const ConnectionGraphicsItem& copy);
                virtual ConnectionGraphicsItem& copyPoints (const ConnectionGraphicsItem& copy);
                virtual ConnectionGraphicsItem* clone() const;
                //virtual QRectF boundingRect() const;
                //virtual void paint(QPainter *painter, const QStyleOptionGraphicsItem *option=new QStyleOptionGraphicsItem() ,QWidget *widget=0);
                virtual bool isValid();
                static const int numLineTypes = 2;
                QString groupID;
                typedef enum {line, bezier} LineType;

                LineType lineType;

                class TINKERCELLCOREEXPORT ControlPoint : public Tinkercell::ControlPoint
                {
                public:
                        ConnectionGraphicsItem * connectionItem;
                        ControlPoint(ConnectionGraphicsItem * reaction_ptr = 0, QGraphicsItem * parent = 0);
                        ControlPoint(const QPointF& pos, ConnectionGraphicsItem * reaction_ptr = 0, QGraphicsItem * parent = 0);
                        ControlPoint(const ControlPoint& copy);
                        virtual ControlPoint& operator = (const ControlPoint& copy);
                        enum { Type = UserType + 7 };
                        virtual int type() const
                        {
                                // Enable the use of dynamic_cast with this item.
                                return Type;
                        }
                        ~ControlPoint();
                        //virtual void sideEffect();
                        virtual Tinkercell::ControlPoint* clone() const;
                        virtual ItemHandle * handle() const;
                        virtual void setHandle(ItemHandle *);
                };
                
                virtual ItemHandle * handle() const;
                
                virtual void setHandle(ItemHandle *);
                

                class TINKERCELLCOREEXPORT CurveSegment : public QVector<ConnectionGraphicsItem::ControlPoint*>
                {
                public:
                        CurveSegment();
                        CurveSegment(int);
                        CurveSegment(int,ConnectionGraphicsItem::ControlPoint*);
                        CurveSegment(const CurveSegment&);
                        ArrowHeadItem *arrowStart, *arrowEnd;
                };

                QList<CurveSegment> curveSegments;      
                qreal arrowHeadDistance;
                virtual QList<ControlPoint*> controlPoints(bool includeEnds = false) const;
                virtual QList<QGraphicsItem*> controlPointsAsGraphicsItems(bool includeEnds = false) const;
                virtual QPainterPath shape() const;
                virtual void setPath(const QPainterPath& path);
                virtual void clear(bool all=false);
                virtual void refresh(bool arrows=true);
                virtual void setPen(QPen pen, bool permanently=false);
                virtual QPen pen() const;
                virtual void setControlPointsVisible(bool visible = true);
                void showControlPoints();
                void hideControlPoints();
                virtual bool isModifier() const;
                virtual QList<NodeGraphicsItem*> nodes() const;
                virtual QList<NodeGraphicsItem*> nodesWithArrows() const;
                virtual QList<NodeGraphicsItem*> nodesWithoutArrows() const;
                virtual QList<NodeGraphicsItem*> nodesDisconnected() const;
                virtual QList<QGraphicsItem*> nodesAsGraphicsItems() const;
                virtual QList<ArrowHeadItem*> arrowHeads() const;
                virtual QList<QGraphicsItem*> arrowHeadsAsGraphicsItems() const;
                virtual QList<ArrowHeadItem*> modifierArrowHeads() const;
                virtual NodeGraphicsItem* nodeAt(int index) const;
                virtual int indexOf(QGraphicsItem * node) const;
                virtual void replaceNodeAt(int,NodeGraphicsItem*);
                virtual void replaceNode(NodeGraphicsItem*,NodeGraphicsItem*);
                virtual ArrowHeadItem* arrowAt(int index) const;
                virtual ArrowHeadItem* modifierArrowAt(int index) const;
                virtual ~ConnectionGraphicsItem();
                virtual qreal slopeAtPoint(const QPointF& point);
                bool controlPointsVisible;
                virtual ControlPoint * centerPoint() const;
                virtual QPointF centerLocation() const;
                QSizeF centerRegion;
                ArrowHeadItem * centerRegionItem;
                virtual QRectF boundingRect() const;
                virtual QRectF sceneBoundingRect() const;
                enum { Type = UserType + 5 };
                virtual int type() const
                {
                        // Enable the use of dynamic_cast with this item.
                        return Type;
                }
        protected:
                ItemHandle * itemHandle;
                QGraphicsPathItem * boundaryPathItem;
                QGraphicsPathItem * outerPathItem;
                QGraphicsPathItem * mainPathItem;
                QPainterPath pathShape;
                QRectF pathBoundingRect;
                virtual void refreshBoundaryPath();
                virtual void adjustEndPoints(bool arrows=true);
        };

}
#endif