ItemHandle.h

Go to the documentation of this file.

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

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

An Item Handle represents a single item in a network. The Handle can either
be a Node or a Connection. Each Connection can be connected to multiple
Nodes, with a relationship integer describing the role of the Node. -1 and 1 are
reserved roles, indicating "in" and "out" nodes. 

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

#ifndef TINKERCELL_HANDLER_H
#define TINKERCELL_HANDLER_H

#include <QList>
#include <QQueue>
#include <QStack>
#include <QHash>
#include <QPair>
#include <QUndoCommand>
#include <QGraphicsItem>

#include "DataTable.h"
#include "ItemFamily.h"

namespace Tinkercell
{
        class Tool;
        class ItemHandle;
        class NodeHandle;
        class NetworkHandle;
        class ConnectionHandle;
        class NodeGraphicsItem;
        class ConnectionGraphicsItem;
        
        TINKERCELLCOREEXPORT QString RemoveDisallowedCharactersFromName(const QString&);

        class TINKERCELLCOREEXPORT ItemData
        {
                friend class ItemHandle;
        private:
                QHash<QString,NumericalDataTable > numericalData;
                QHash<QString,TextDataTable > textData;
                ItemData();
                ItemData(const ItemData&);
                virtual ItemData& operator = (const ItemData&);
        };

        class TINKERCELLCOREEXPORT ItemHandle: public QObject
        {
                Q_OBJECT
        
        protected:
                ItemData* data;

        public:
                ItemHandle(const QString& name = QString());
                ItemHandle(const ItemHandle&);

                QString name;
                QList<QGraphicsItem*> graphicsItems;
                QList<Tool*> tools;
                
                NetworkHandle * network;
                ItemHandle * parent;
                QList<ItemHandle*> children;
                int type;

                virtual ItemHandle& operator = (const ItemHandle&);
                virtual ~ItemHandle();
                virtual ItemHandle * clone() const;
                virtual ItemFamily* family() const;
                virtual void setFamily(ItemFamily*, bool useCommand=true);
                virtual bool isA(const ItemFamily* family) const;
                virtual bool isA(const QString& family) const;
                virtual QString fullName(const QString& sep = QString(".")) const;
                virtual void setParent(ItemHandle * parent, bool useCommand=true);
                virtual void rename(const QString&);
                virtual void changeData(const QString& hashstring, const NumericalDataTable* newdata);
                virtual void changeData(const QString& hashstring, const TextDataTable* newdata);               
                virtual ItemHandle* root(const QString& family=QString("")) const;
                virtual ItemHandle* parentOfFamily(const QString& family) const;
                virtual bool isChildOf(ItemHandle * handle) const;
                virtual int depth() const;
                virtual QList<QGraphicsItem*> allGraphicsItems() const;
                virtual QList<ItemHandle*> allChildren() const;
                QStringList numericalDataNames() const;
                QStringList textDataNames() const;
                bool hasNumericalData(const QString& name) const;
                bool hasTextData(const QString& name) const;
                qreal numericalData(const QString& name, int row=0, int column=0) const;
                qreal numericalData(const QString& name, const QString& row, const QString& column=QString()) const;
                QString textData(const QString& name, int row=0, int column=0) const;
                QString textData(const QString& name, const QString& row, const QString& column=QString()) const;
                qreal& numericalData(const QString& name, int row=0, int column=0);
                qreal& numericalData(const QString& name, const QString& row, const QString& column=QString());
                QString& textData(const QString& name, int row=0, int column=0);
                QString& textData(const QString& name, const QString& row, const QString& column=QString());
                NumericalDataTable& numericalDataTable(const QString& name);
                TextDataTable& textDataTable(const QString& name);
                virtual void copyDataTablesFrom(ItemHandle*);
        };

        class TINKERCELLCOREEXPORT NodeHandle : public ItemHandle
        {
                Q_OBJECT

        public:
                static const int TYPE = 1;
                virtual QList<ConnectionHandle*> connections() const;
                NodeFamily* nodeFamily;
                NodeHandle(const QString& name = QString(), NodeFamily * nodeFamily = 0);
                NodeHandle(const NodeHandle & copy);
                virtual NodeHandle& operator = (const NodeHandle&);
                NodeHandle(NodeFamily * nodeFamily, NodeGraphicsItem * item);
                NodeHandle(NodeFamily * nodeFamily, const QString& name = QString());
                virtual ItemHandle * clone() const;
                virtual ItemFamily* family() const;
                virtual void setFamily(ItemFamily *, bool useCommand=true);
                static NodeHandle* cast(ItemHandle *);
                static QList<NodeHandle*> cast(const QList<ItemHandle*>&);
        };

        class TINKERCELLCOREEXPORT ConnectionHandle : public ItemHandle
        {
        public:
                static const int TYPE = 2;
                virtual QList<NodeHandle*> nodes(int role = 0) const;
                virtual void addNode(NodeHandle*, int role=0);
                virtual void clearNodes();
                virtual QList<NodeHandle*> nodesIn() const;
                virtual QList<NodeHandle*> nodesOut() const;
                ConnectionFamily* connectionFamily;
                ConnectionHandle(const QString& name = QString(), ConnectionFamily * family = 0);
                ConnectionHandle(ConnectionFamily * family, const QString& name = QString());
                ConnectionHandle(const ConnectionHandle&);
                virtual ConnectionHandle& operator = (const ConnectionHandle&);
                ConnectionHandle(ConnectionFamily * family, ConnectionGraphicsItem * item);
                virtual void setFamily(ItemFamily * family, bool useCommand=true);
                virtual ItemHandle * clone() const;
                virtual ItemFamily* family() const;
                virtual QList<ItemFamily*> findValidChildFamilies() const;
                static ConnectionHandle * cast(ItemHandle *);
                static QList<ConnectionHandle*> cast(const QList<ItemHandle*>&);
                QList< QPair<NodeHandle*, int> > nodesWithRoles;
        };

        TINKERCELLCOREEXPORT ItemHandle * getHandle(QGraphicsItem*);
        TINKERCELLCOREEXPORT QList<ItemHandle*> getHandle(const QList<QGraphicsItem*>&, bool includeNull=true);
        TINKERCELLCOREEXPORT void setHandle(QGraphicsItem*, ItemHandle*);
}

#endif