icndocument.h

/***************************************************************************
 *   Copyright (C) 2005 by David Saxton                                    *
 *   david@bluehaze.org                                                    *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 ***************************************************************************/

#ifndef ICNDOCUMENT_H
#define ICNDOCUMENT_H

#include "itemdocument.h"


class Cells;
class CNItem;
class CNItemGroup;
class Connector;
class ECNode;
class FlowContainer;
class Node;
class NodeGroup;

typedef QValueList<QGuardedPtr<Connector> > ConnectorList;
typedef QValueList<QGuardedPtr<Node> > NodeList;
typedef QValueList<NodeGroup*> NodeGroupList;
typedef QValueList<QGuardedPtr<NodeGroup> > GuardedNodeGroupList;

class ICNDocument : public ItemDocument
{
Q_OBJECT
public:
        ICNDocument( const QString &caption, KTechlab *ktechlab, const char *name );
        virtual ~ICNDocument();
        
        enum hit_score
        {
                hs_none = 0,
                hs_connector = 4,
                hs_item = 1000
        };

        virtual View *createView( ViewContainer *viewContainer, uint viewAreaId, const char *name = 0 );
        
        virtual Item* addItem( const QString &id, const QPoint &p, bool newItem );
        Connector* createConnector( const QString &startNodeId, const QString &endNodeId, QPointList *pointList = 0 );
        CNItem* cnItemWithID( const QString &id );
        Node* nodeWithID( const QString &id );
        Connector* connectorWithID( const QString &id );
        virtual void appendDeleteList( QCanvasItem *qcanvasItem );
        virtual void flushDeleteList();
        virtual bool canConnect( QCanvasItem *qcanvasItem1, QCanvasItem *qcanvasItem2 ) const;
        virtual void copy();
        virtual void selectAll();


        virtual bool registerItem( QCanvasItem *qcanvasItem );
        Cells *cells() const { return m_cells; }
        inline bool isValidCellReference( const uint x, const uint y ) const
        {
                return ( x<m_cellsX && y<m_cellsY );
        }
        void addCPenalty( int x, int y, int score );
        bool joinConnectors( Node *node );
        static int gridSnap( int pos ); 
        static QPoint gridSnap( const QPoint &pos );
        virtual bool isValidItem( Item *item ) = 0;
        virtual bool isValidItem( const QString &itemId ) = 0;
        ConnectorList getCommonConnectors( const ItemList &list );
        NodeList getCommonNodes( const ItemList &list );
        const NodeList & nodeList() const { return m_nodeList; }
        const ConnectorList & connectorList() const { return m_connectorList; }
        const GuardedNodeGroupList & nodeGroupList() const { return m_nodeGroupList; }
        virtual ItemGroup *selectList() const;
        Connector * createConnector( Node *node1, Node *node2, QPointList *pointList = 0 );
        Connector * createConnector( Node *node, Connector *con, const QPoint &pos2, QPointList *pointList = 0 );
        Connector * createConnector( Connector *con1, Connector *con2, const QPoint &pos1, const QPoint &pos2, QPointList *pointList = 0 );
        FlowContainer *flowContainer( const QPoint &pos );
        void setItemResizeCursor( int cornerType );
        
        void getTranslatable( const ItemList & itemList, ConnectorList * fixedConnectors = 0, ConnectorList * translatableConnectors = 0, NodeGroupList * translatableNodeGroups = 0 );
        void rerouteInvalidatedConnectors();
        void slotAssignNodeGroups();
        
public slots:
        virtual void deleteSelection();
        void requestRerouteInvalidatedConnectors();
        void createCellMap();
        void slotRequestAssignNG();

signals:
        void connectorAdded( Connector *connector );
        void nodeAdded( Node *node );
        
protected:
        void addAllItemConnectorPoints();
        virtual void fillContextMenu( const QPoint &pos );
        NodeGroup* createNodeGroup( Node *node );
        bool deleteNodeGroup( Node *node );
    
        friend class CanvasEditor;
        
        Cells *m_cells;
        uint m_cellsX, m_cellsY;
        NodeList m_nodeList;
        ConnectorList m_connectorList;
        CNItemGroup *m_selectList; // Selected objects
        GuardedNodeGroupList m_nodeGroupList;
        
private:
        QCanvasItemList m_itemDeleteList; // List of canvas items to be deleted
};


class DirCursor
{
public:
        static DirCursor* self();
        ~DirCursor();
        
        static QPixmap leftArrow()
        {
                return self()->m_leftArrow;
        }
        
        static QPixmap rightArrow()
        {
                return self()->m_rightArrow;
        }
        
        static QPixmap upArrow()
        {
                return self()->m_upArrow;
        }
        
        static QPixmap downArrow()
        {
                return self()->m_downArrow;
        }
        
protected:
        DirCursor();
        void initCursors();
        
        static DirCursor *m_self;
        QPixmap m_leftArrow;
        QPixmap m_rightArrow;
        QPixmap m_upArrow;
        QPixmap m_downArrow;
};


#endif

---