canvasmanipulator.h

/***************************************************************************
 *   Copyright (C) 2004-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 CANVAsmANIPULATOR_H
#define CANVAsmANIPULATOR_H

#include "eventinfo.h"

#include <qcanvas.h>
#include <qguardedptr.h>

class CanvasManipulator;
class Connector;
class CMManager;
class CNItem;
class CNItemGroup;
class EventInfo;
class FlowContainer;
class ICNDocument;
class Item;
class ItemDocument;
class ItemGroup;
class ItemView;
class ManipulatorInfo;
class ManualConnectorDraw;
class MechanicsItem;
class MechanicsGroup;
class MechanicsDocument;
class Node;
class NodeGroup;
class ResizeHandle;

class QCanvas;
class QCanvasItem;
class QCanvasLine;
class QCanvasRectangle;
class QMouseEvent;
class QTimer;
class QWheelEvent;

typedef CanvasManipulator*(*CreateManipulatorPtr)( ItemDocument *, CMManager * );
typedef bool(*AcceptManipulationPtr)( uint eventState, uint cmState, uint itemType, uint cnItemType );
typedef QValueList<NodeGroup*> NodeGroupList;
typedef QValueList<QGuardedPtr<Connector> > ConnectorList;
typedef QValueList<QPoint> QPointList;

class ManipulatorInfo
{
public:
        ManipulatorInfo();
        AcceptManipulationPtr m_acceptManipulationPtr;
        CreateManipulatorPtr m_createManipulatorPtr;
};
typedef QValueList<ManipulatorInfo*> ManipulatorInfoList;


class CMManager : public QObject
{
Q_OBJECT
public:
        enum EventState
        {
                es_right_click =        1 << 0,
                es_ctrl_pressed =       1 << 1
        };
        enum CMState
        {
                cms_repeated_add =      1 << 0,
                cms_manual_route =      1 << 1,
                cms_draw =              1 << 2
        };
        enum ItemType
        {
                it_none =               1 << 0,
                it_node =               1 << 1,
                it_connector =          1 << 2,
                it_pin =                1 << 3,
                it_canvas_item =        1 << 4,
                it_mechanics_item =     1 << 5,
                it_resize_handle =      1 << 6,
                it_drawpart =           1 << 7
        };
        enum ItemStateInfo
        {
                isi_isMovable = 0x2,
        };
        CMManager( ItemDocument *itemDocument );
        ~CMManager();
        void mousePressEvent( EventInfo eventInfo );
        void mouseReleaseEvent( const EventInfo &eventInfo );
        void mouseDoubleClickEvent( const EventInfo &eventInfo );
        void mouseMoveEvent( const EventInfo &eventInfo );
        void wheelEvent( const EventInfo &eventInfo );
        void setCMState( CMState type, bool state );
        void cancelCurrentManipulation();
        CanvasManipulator * currentManipulator() const { return m_canvasManipulator; }
        void setRepeatedAddId( const QString & repeatedId = QString::null );
        uint cmState() const { return m_cmState; }
        void addManipulatorInfo( ManipulatorInfo *info );
        QString repeatedItemId() const { return m_repeatedItemId; }
        void setDrawAction( int drawAction );
        int drawAction() const { return m_drawAction; }
        
public slots:
        void slotSetManualRoute( bool manualRoute );
        
signals:
        void manualRoutingChanged( bool manualRouting );
        
protected:
        void updateCurrentResizeHandle( ResizeHandle * mouseOver );
        CanvasManipulator *m_canvasManipulator;
        uint m_cmState;
        QString m_repeatedItemId;
        ItemDocument *p_itemDocument;
        ManipulatorInfoList m_manipulatorInfoList;
        QGuardedPtr<Item> p_lastMouseOverItem; // Pointer to the item where the mouse was last over - this is used to determine when mouse
        QGuardedPtr<ResizeHandle> p_lastMouseOverResizeHandle;
        QGuardedPtr<Item> p_lastItemClicked;
        QTimer *m_allowItemScrollTmr; // When a user scrolls on the canvas, we don't want to stop scrolling when the user gets to (e.g.) a scrollable widget. So this timer prevents scrolling a widget for a few hundred milliseconds after a scroll event if it was initiated over the canvas
        bool b_allowItemScroll; // See above.
        int m_drawAction;
        
private slots:
        void slotAllowItemScroll() { b_allowItemScroll = true; }
};

class CanvasManipulator
{
public:
        CanvasManipulator( ItemDocument *itemDocument, CMManager *cmManager );
        virtual ~CanvasManipulator();
        enum Type
        {
                RepeatedItemAdd,
                RightClick,
                AutoConnector,
                ManualConnector,
                ItemMove,
                ItemResize,
                MechItemMove,
                Select,
                CanvasResize,
                ItemDrag,
                Draw
        };
        virtual Type type() const = 0;
        virtual bool mousePressedInitial( const EventInfo &/*info*/ ) { return false; }
        virtual bool mousePressedRepeat( const EventInfo &/*info*/ ) { return false; };
        virtual bool mouseMoved( const EventInfo &/*info*/ ) { return false; };
        virtual bool mouseReleased( const EventInfo &/*info*/ ) { return true; }
        
protected:
        Type m_type;
        EventInfo m_eventInfo;
        QPoint m_prevPos;
        ItemDocument *p_itemDocument;
        ICNDocument *p_icnDocument;
        MechanicsDocument *p_mechanicsDocument;
        QCanvas *p_canvas;
        ItemGroup *p_selectList;
        CNItemGroup *p_cnItemSelectList;
        MechanicsGroup *p_mechItemSelectList;
        CNItem *p_cnItemClickedOn;
        MechanicsItem *p_mechanicsItemClickedOn;
        CMManager *p_cmManager;
};

class CMRepeatedItemAdd : public CanvasManipulator
{
public:
        CMRepeatedItemAdd( ItemDocument *itemDocument, CMManager *cmManager );
        virtual ~CMRepeatedItemAdd();
        virtual Type type() const { return RepeatedItemAdd; }
        
        static CanvasManipulator* construct( ItemDocument *itemDocument, CMManager *cmManager );
        static ManipulatorInfo *manipulatorInfo();
        static bool acceptManipulation( uint eventState, uint cmState, uint itemType, uint cnItemType );
        
        virtual bool mousePressedInitial( const EventInfo &info );
        virtual bool mousePressedRepeat( const EventInfo &info );
        virtual bool mouseMoved( const EventInfo &info );
        virtual bool mouseReleased( const EventInfo &info );
        
protected:
};

class CMRightClick : public CanvasManipulator
{
public:
        CMRightClick( ItemDocument *itemDocument, CMManager *cmManager );
        virtual ~CMRightClick();
        virtual Type type() const { return RightClick; }
        
        static CanvasManipulator* construct( ItemDocument *itemDocument, CMManager *cmManager );
        static ManipulatorInfo *manipulatorInfo();
        static bool acceptManipulation( uint eventState, uint cmState, uint itemType, uint cnItemType );
        
        virtual bool mousePressedInitial( const EventInfo &info );
        virtual bool mouseMoved( const EventInfo &info );
        virtual bool mouseReleased( const EventInfo &info );
        
protected:
};


class ConnectorDraw : public CanvasManipulator
{
        public:
                ConnectorDraw( ItemDocument *itemDocument, CMManager *cmManager );
                virtual ~ConnectorDraw();
                
                static QColor validConnectionColor();
                
        protected:
                Connector * toConnector( Node * node );
                void grabEndStuff( QCanvasItem * endItem, const QPoint & pos, bool posIsExact );
                QPoint toValidPos( const QPoint & clickPos, Connector * clickedConnector ) const;
                
                QGuardedPtr<Node> p_startNode;
                QGuardedPtr<Connector> p_startConnector;
                Node * p_endNode;
                Connector * p_endConnector;
                QPoint startConnectorPoint;
};

class CMAutoConnector : public ConnectorDraw
{
public:
        CMAutoConnector( ItemDocument *itemDocument, CMManager *cmManager );
        virtual ~CMAutoConnector();
        virtual Type type() const { return AutoConnector; }
        
        static CanvasManipulator* construct( ItemDocument *itemDocument, CMManager *cmManager );
        static ManipulatorInfo *manipulatorInfo();
        static bool acceptManipulation( uint eventState, uint cmState, uint itemType, uint cnItemType );
        
        virtual bool mousePressedInitial( const EventInfo &info );
        virtual bool mouseMoved( const EventInfo &info );
        virtual bool mouseReleased( const EventInfo &info );
        
protected:
        QCanvasLine *m_connectorLine;
};

class CMManualConnector : public ConnectorDraw
{
public:
        CMManualConnector( ItemDocument *itemDocument, CMManager *cmManager );
        virtual ~CMManualConnector();
        virtual Type type() const { return ManualConnector; }
        
        static CanvasManipulator* construct( ItemDocument *itemDocument, CMManager *cmManager );
        static ManipulatorInfo *manipulatorInfo();
        static bool acceptManipulation( uint eventState, uint cmState, uint itemType, uint cnItemType );
        
        virtual bool mousePressedInitial( const EventInfo &info );
        virtual bool mousePressedRepeat( const EventInfo &info );
        virtual bool mouseMoved( const EventInfo &info );
        virtual bool mouseReleased( const EventInfo &info );
        
protected:
        ConnectorList m_fixedRouteConnectors;
        ManualConnectorDraw *m_manualConnectorDraw;
};

class CMItemMove : public CanvasManipulator
{
public:
        CMItemMove( ItemDocument *itemDocument, CMManager *cmManager );
        virtual ~CMItemMove();
        virtual Type type() const { return ItemMove; }
        
        static CanvasManipulator* construct( ItemDocument *itemDocument, CMManager *cmManager );
        static ManipulatorInfo *manipulatorInfo();
        static bool acceptManipulation( uint eventState, uint cmState, uint itemType, uint cnItemType );
        
        virtual bool mousePressedInitial( const EventInfo &info );
        virtual bool mouseMoved( const EventInfo &info );
        virtual bool mouseReleased( const EventInfo &info );
        
protected:
        ConnectorList m_translatableConnectors;
        NodeGroupList m_translatableNodeGroups;
        FlowContainer *p_flowContainerCandidate;
};

class CMItemResize : public CanvasManipulator
{
public:
        CMItemResize( ItemDocument *itemDocument, CMManager *cmManager );
        virtual ~CMItemResize();
        virtual Type type() const { return ItemResize; }
        
        static CanvasManipulator* construct( ItemDocument *itemDocument, CMManager *cmManager );
        static ManipulatorInfo *manipulatorInfo();
        static bool acceptManipulation( uint eventState, uint cmState, uint itemType, uint cnItemType );
        
        virtual bool mousePressedInitial( const EventInfo &info );
        virtual bool mouseMoved( const EventInfo &info );
        virtual bool mouseReleased( const EventInfo &info );
        
protected:
        ResizeHandle *p_resizeHandle;
        double m_rh_dx;
        double m_rh_dy;
};

class CMMechItemMove : public CanvasManipulator
{
public:
        CMMechItemMove( ItemDocument *itemDocument, CMManager *cmManager );
        virtual ~CMMechItemMove();
        virtual Type type() const { return MechItemMove; }
        
        static CanvasManipulator* construct( ItemDocument *itemDocument, CMManager *cmManager );
        static ManipulatorInfo *manipulatorInfo();
        static bool acceptManipulation( uint eventState, uint cmState, uint itemType, uint cnItemType );
        
        virtual bool mousePressedInitial( const EventInfo &info );
        virtual bool mouseMoved( const EventInfo &info );
        virtual bool mouseReleased( const EventInfo &info );
        
protected:
        uint m_prevClickedOnSM; // Previous select mode of the item that was clicked on
};


class SelectRectangle
{
        public:
                SelectRectangle( int x, int y, int w, int h, QCanvas *qcanvas );
                ~SelectRectangle();
                
                void setSize( int w, int h );
                QCanvasItemList collisions();
                
        protected:
                QCanvasLine *m_topLine;
                QCanvasLine *m_rightLine;
                QCanvasLine *m_bottomLine;
                QCanvasLine *m_leftLine;
                const int m_x;
                const int m_y;
                int m_w;
                int m_h;
                int m_prevCollisions_w;
                int m_prevCollisions_h;
                QCanvasItemList m_prevCollisions;
};

class CMSelect : public CanvasManipulator
{
public:
        CMSelect( ItemDocument *itemDocument, CMManager *cmManager );
        virtual ~CMSelect();
        virtual Type type() const { return Select; }
        
        static CanvasManipulator* construct( ItemDocument *itemDocument, CMManager *cmManager );
        static ManipulatorInfo *manipulatorInfo();
        static bool acceptManipulation( uint eventState, uint cmState, uint itemType, uint cnItemType );
        
        virtual bool mousePressedInitial( const EventInfo &info );
        virtual bool mouseMoved( const EventInfo &info );
        virtual bool mouseReleased( const EventInfo &info );
        
protected:
        SelectRectangle *m_selectRectangle;
};

class CMItemDrag : public CanvasManipulator
{
public:
        CMItemDrag( ItemDocument *itemDocument, CMManager *cmManager );
        virtual ~CMItemDrag();
        virtual Type type() const { return ItemDrag; }
        
        static CanvasManipulator* construct( ItemDocument *itemDocument, CMManager *cmManager );
        static ManipulatorInfo *manipulatorInfo();
        static bool acceptManipulation( uint eventState, uint cmState, uint itemType, uint cnItemType );
        
        virtual bool mousePressedInitial( const EventInfo &info );
        virtual bool mouseMoved( const EventInfo &info );
        virtual bool mouseReleased( const EventInfo &info );
        
protected:
        bool b_dragged;
};

class CanvasEllipseDraw : public QCanvasEllipse
{
        public:
                CanvasEllipseDraw( int x, int y, QCanvas * canvas );
                
        protected:
                virtual void drawShape( QPainter & p );
};

class CMDraw : public CanvasManipulator
{
        public:
                CMDraw( ItemDocument *itemDocument, CMManager *cmManager );
                virtual ~CMDraw();
                virtual Type type() const { return Draw; }
        
                static CanvasManipulator* construct( ItemDocument *itemDocument, CMManager *cmManager );
                static ManipulatorInfo *manipulatorInfo();
                static bool acceptManipulation( uint eventState, uint cmState, uint itemType, uint cnItemType );
        
                virtual bool mousePressedInitial( const EventInfo &info );
                virtual bool mouseMoved( const EventInfo &info );
                virtual bool mouseReleased( const EventInfo &info );
        
        protected:
                QCanvasRectangle * m_pDrawRectangle;
                CanvasEllipseDraw * m_pDrawEllipse;
                QCanvasLine * m_pDrawLine;
};

class ManualConnectorDraw
{
        public:
                ManualConnectorDraw( ICNDocument *_icnDocument, const QPoint &initialPos );
                virtual ~ManualConnectorDraw();
                
                void mouseMoved( const QPoint &pos );
                QCanvasItem * mouseClicked( const QPoint &pos );
                QPointList pointList();
                void setColor( const QColor & color );

        protected:
                void updateConnectorEnds();
        
                QValueList<QCanvasLine*> m_connectorLines;
                ICNDocument *icnDocument;
        
                bool b_currentVertical;
                bool b_orientationDefined;
        
                QPoint m_initialPos;
                QPoint m_previousPos;
                QPoint m_currentPos;
        
                QCanvasLine *m_currentCon;
                QCanvasLine *m_previousCon;
        
                // The first item that we clicked on
                QCanvasItem *p_initialItem;
        
                QColor m_color;
};

#endif

---