canvasmanipulator.cpp

/***************************************************************************
 *   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.                                   *
 ***************************************************************************/

#include "cnitemgroup.h"
#include "canvasitemparts.h"
#include "dptext.h"
#include "canvasmanipulator.h"
#include "connector.h"
#include "flowcontainer.h"
#include "icndocument.h"
#include "itemview.h"
#include "mechanicsdocument.h"
#include "mechanicsgroup.h"
#include "mechanicsitem.h"
#include "node.h"
#include "nodegroup.h"
#include "picitem.h"
#include "resizeoverlay.h"

#include <cmath>

#include <kconfig.h>
#include <kdebug.h>
#include <kglobal.h>

#include <qpainter.h>
#include <qtimer.h>

/* TODO AUDIT CODE
Formatting was very ugly. Probably buggy and/or poorly factored. 
*/ 


CMManager::CMManager( ItemDocument *itemDocument )
        : QObject()
{
        b_allowItemScroll = true;
        p_lastMouseOverResizeHandle = 0;
        m_canvasManipulator = 0;
        p_itemDocument = itemDocument;
        m_cmState = 0;
        p_lastMouseOverItem = 0;
        p_lastItemClicked = 0;
        m_drawAction = -1;
        m_allowItemScrollTmr = new QTimer(this);
        connect( m_allowItemScrollTmr, SIGNAL(timeout()), this, SLOT(slotAllowItemScroll()) );

        KGlobal::config()->setGroup("General");
        slotSetManualRoute( KGlobal::config()->readBoolEntry( "ManualRouting", false));
}

CMManager::~CMManager()
{
        delete m_allowItemScrollTmr;
        delete m_canvasManipulator;

        const ManipulatorInfoList::iterator end = m_manipulatorInfoList.end();
        for ( ManipulatorInfoList::iterator it = m_manipulatorInfoList.begin(); it != end; ++it ) {
                delete *it;
        }

        m_manipulatorInfoList.clear();
}

void CMManager::addManipulatorInfo( ManipulatorInfo *eventInfo )
{
        if ( eventInfo && !m_manipulatorInfoList.contains(eventInfo) ) {
                m_manipulatorInfoList.prepend(eventInfo);
        }
}

void CMManager::cancelCurrentManipulation()
{
        delete m_canvasManipulator;
        m_canvasManipulator = 0;
        setRepeatedAddId();
}

void CMManager::mousePressEvent( EventInfo eventInfo )
{
        if (m_canvasManipulator) {
                if (m_canvasManipulator->mousePressedRepeat(eventInfo)) {
                        delete m_canvasManipulator;
                        m_canvasManipulator = 0;
                }
                return;
        }

        uint eventState=0;
        if(eventInfo.isRightClick)
                eventState |= CMManager::es_right_click;

        if(eventInfo.ctrlPressed)
                eventState |= CMManager::es_ctrl_pressed;

        uint itemType=0;
        uint cnItemType=0;

        switch(eventInfo.itemRtti) {
                case ItemDocument::RTTI::None: itemType = CMManager::it_none; break;
                case ItemDocument::RTTI::Node: itemType = CMManager::it_node; break;
                case ItemDocument::RTTI::Connector: itemType = CMManager::it_connector; break;
                case ItemDocument::RTTI::Pin: itemType = CMManager::it_pin; break;
                case ItemDocument::RTTI::ResizeHandle: itemType = CMManager::it_resize_handle; break;
                case ItemDocument::RTTI::DrawPart:
                {
                        itemType = CMManager::it_drawpart;
                        DrawPart *drawPartClickedOn = dynamic_cast<DrawPart*>(eventInfo.qcanvasItemClickedOn);
                        
                        if ( drawPartClickedOn->mousePressEvent(eventInfo) ) {
                                p_lastItemClicked = drawPartClickedOn;
                                return;
                        }
                        
                        if ( drawPartClickedOn->isMovable() )
                                cnItemType |= CMManager::isi_isMovable;
                        break;
                }
                case ItemDocument::RTTI::Widget:
                {
                        Widget *widget = dynamic_cast<Widget*>(eventInfo.qcanvasItemClickedOn);
                        if (widget)
                                eventInfo.qcanvasItemClickedOn = widget->parent();
                }
                case ItemDocument::RTTI::CNItem:
                {
                        itemType = CMManager::it_canvas_item;
                        CNItem *cnItemClickedOn = dynamic_cast<CNItem*>(eventInfo.qcanvasItemClickedOn);

                        if(cnItemClickedOn->mousePressEvent(eventInfo) )
                        {
                                p_lastItemClicked = cnItemClickedOn;
                                return;
                        }
                        
                        if(cnItemClickedOn->isMovable() )
                                cnItemType |= CMManager::isi_isMovable;
                        break;
                }
                case ItemDocument::RTTI::MechanicsItem:
                {
                        itemType = CMManager::it_mechanics_item;
                        MechanicsItem *p_mechanicsItemClickedOn = dynamic_cast<MechanicsItem*>(eventInfo.qcanvasItemClickedOn);
                        
                        if ( p_mechanicsItemClickedOn->mousePressEvent(eventInfo) )
                        {
                                p_lastItemClicked = p_mechanicsItemClickedOn;
                                return;
                        }
                        break;
                }
        }
        
//      uint highestScore=0;
//      ManipulatorInfo *best=0;
        const ManipulatorInfoList::iterator end = m_manipulatorInfoList.end();

        for ( ManipulatorInfoList::iterator it = m_manipulatorInfoList.begin(); it != end && !m_canvasManipulator; ++it ) {
                if ( (*it)->m_acceptManipulationPtr( eventState, m_cmState, itemType, cnItemType ) ) {
                        m_canvasManipulator = (*it)->m_createManipulatorPtr( p_itemDocument, this );
                }
        }

        if (m_canvasManipulator) {
                if (m_canvasManipulator->mousePressedInitial(eventInfo)) {
                        delete m_canvasManipulator;
                        m_canvasManipulator = 0;
                }
        }
}

void CMManager::mouseDoubleClickEvent( const EventInfo &eventInfo )
{
        Item *item = dynamic_cast<Item*>(eventInfo.qcanvasItemClickedOn);
        if (item) {
                item->mouseDoubleClickEvent(eventInfo);
                return;
        }

        Widget *widget = dynamic_cast<Widget*>(eventInfo.qcanvasItemClickedOn);
        if (widget) {
                widget->parent()->mouseDoubleClickEvent(eventInfo);
                return;
        }
}

void CMManager::mouseMoveEvent( const EventInfo &eventInfo )
{
        if (m_canvasManipulator)
        {
                if (m_canvasManipulator->mouseMoved(eventInfo))
                {
                        kdDebug() << k_funcinfo << "About to delete" << endl;
                        delete m_canvasManipulator;
                        kdDebug() << k_funcinfo << "Deleted" << endl;
                        m_canvasManipulator = 0;
                        kdDebug() << k_funcinfo << "Nullified" << endl;
                }
                ItemView *itemView = dynamic_cast<ItemView*>(p_itemDocument->activeView());

                if (itemView) itemView->scrollToMouse(eventInfo.pos);
                return;
        }
        
        //BEGIN
        QCanvasItem *qcnItem = p_itemDocument->itemAtTop(eventInfo.pos);
        Item *item;
        Widget *widget = dynamic_cast<Widget*>(qcnItem);
        if(widget) item = widget->parent();
        else item = dynamic_cast<Item*>(qcnItem);
        
        if ( p_lastMouseOverItem != (QGuardedPtr<Item>)item ) {
                QEvent event(QEvent::Leave);
                
                if (p_lastMouseOverItem) p_lastMouseOverItem->leaveEvent();

                if (item) item->enterEvent();

                p_lastMouseOverItem = item;
        }
        
        // If we clicked on an item, then continue to pass mouse events to that item until we release the mouse...
        if(p_lastItemClicked) {
                p_lastItemClicked->mouseMoveEvent(eventInfo);
        } else if(item) {
                item->mouseMoveEvent(eventInfo);
        }
        //END

        updateCurrentResizeHandle( dynamic_cast<ResizeHandle*>(qcnItem) );
}

void CMManager::updateCurrentResizeHandle( ResizeHandle * resizeHandle )
{
        if ( p_lastMouseOverResizeHandle != (QGuardedPtr<ResizeHandle>)resizeHandle )
        {
                if (p_lastMouseOverResizeHandle)
                        p_lastMouseOverResizeHandle->setHover(false);
                p_lastMouseOverResizeHandle = resizeHandle;
                if (resizeHandle) resizeHandle->setHover(true);
        }
}

void CMManager::mouseReleaseEvent( const EventInfo &eventInfo )
{
        // If it returns true, then it has finished its editing operation
        if(m_canvasManipulator && m_canvasManipulator->mouseReleased(eventInfo)) {
                delete m_canvasManipulator;
                m_canvasManipulator = 0;
        }
        
        if (p_lastItemClicked) {
                p_lastItemClicked->mouseReleaseEvent(eventInfo);
                p_lastItemClicked=0;
        }
        
        updateCurrentResizeHandle( dynamic_cast<ResizeHandle*>( p_itemDocument->itemAtTop(eventInfo.pos) ) );
}

void CMManager::wheelEvent( const EventInfo &eventInfo )
{
        bool accepted = false;
        if (b_allowItemScroll) {
                QCanvasItem *qcnItem = p_itemDocument->itemAtTop(eventInfo.pos);
                Item *item;
                Widget *widget = dynamic_cast<Widget*>(qcnItem);
                if(widget) item = widget->parent();
                else item = dynamic_cast<Item*>(qcnItem);
                
                if(item) accepted = item->wheelEvent(eventInfo);
        }

        if (!accepted) {
                // Only allow scrolling of items if we have not just been scrolling the canvas
                b_allowItemScroll = false;
                m_allowItemScrollTmr->stop();
                m_allowItemScrollTmr->start(500,true);
                
                ItemView *itemView = dynamic_cast<ItemView*>(p_itemDocument->activeView());
                if (itemView) {
                        itemView->cvbEditor()->setPassEventsToView(false);
                        itemView->cvbEditor()->contentsWheelEvent( eventInfo.wheelEvent( 0, 0 ) );
                        itemView->cvbEditor()->setPassEventsToView(true);
                }
        }
}

void CMManager::setDrawAction( int drawAction )
{
        if ( m_drawAction == drawAction ) return;

        m_drawAction = drawAction;
        setCMState( cms_draw, (m_drawAction != -1) );
}

void CMManager::slotSetManualRoute( bool manualRoute )
{
        KGlobal::config()->setGroup("General");
        KGlobal::config()->writeEntry( "ManualRouting", manualRoute );
        
        setCMState( cms_manual_route, manualRoute );
}

void CMManager::setCMState( CMState type, bool state )
{
        // Set or clear the correct bit
        state ? (m_cmState|=type) : (m_cmState&=(~type));
        
        if ( type == CMManager::cms_manual_route )
                emit manualRoutingChanged(state);
}

void CMManager::setRepeatedAddId( const QString & repeatedId )
{
        m_repeatedItemId = repeatedId;
}

CanvasManipulator::CanvasManipulator( ItemDocument *itemDocument, CMManager *cmManager )
{
        p_itemDocument = itemDocument;
        p_icnDocument = dynamic_cast<ICNDocument*>(itemDocument);
        p_mechanicsDocument = dynamic_cast<MechanicsDocument*>(itemDocument);
        p_canvas = p_itemDocument->canvas();
//      b_connectorsAllowedRouting = true;
        p_selectList = p_itemDocument->selectList();
        p_cnItemSelectList = dynamic_cast<CNItemGroup*>(p_selectList);
        p_mechItemSelectList = dynamic_cast<MechanicsGroup*>(p_selectList);
        p_cnItemClickedOn = 0;
        p_cmManager = cmManager;
}

CanvasManipulator::~CanvasManipulator()
{
}

CMRepeatedItemAdd::CMRepeatedItemAdd( ItemDocument *itemDocument, CMManager *cmManager )
        : CanvasManipulator( itemDocument, cmManager )
{
}

CMRepeatedItemAdd::~CMRepeatedItemAdd()
{
}

CanvasManipulator* CMRepeatedItemAdd::construct( ItemDocument *itemDocument, CMManager *cmManager )
{
        return new CMRepeatedItemAdd(itemDocument,cmManager);
}

ManipulatorInfo *CMRepeatedItemAdd::manipulatorInfo()
{
        ManipulatorInfo *eventInfo = new ManipulatorInfo();
        eventInfo->m_acceptManipulationPtr = CMRepeatedItemAdd::acceptManipulation;
        eventInfo->m_createManipulatorPtr = CMRepeatedItemAdd::construct;
        return eventInfo;
}

bool CMRepeatedItemAdd::acceptManipulation( uint /*eventState*/, uint cmState, uint /*itemType*/, uint /*cnItemType*/ )
{
        return (cmState & CMManager::cms_repeated_add);
}

bool CMRepeatedItemAdd::mousePressedRepeat( const EventInfo &eventInfo )
{
        return mousePressedInitial(eventInfo);
}

bool CMRepeatedItemAdd::mousePressedInitial( const EventInfo &eventInfo )
{
        m_eventInfo = eventInfo;
        if (eventInfo.isRightClick) {
                p_cmManager->setCMState( CMManager::cms_repeated_add, false );
                return true;
        }

        p_icnDocument->addItem( p_cmManager->repeatedItemId(), eventInfo.pos, true );
        p_itemDocument->requestStateSave();
        return false;
}

bool CMRepeatedItemAdd::mouseMoved( const EventInfo &/*eventInfo*/ )
{
        return false;
}

bool CMRepeatedItemAdd::mouseReleased( const EventInfo &/*eventInfo*/ )
{
        return false;
}

CMRightClick::CMRightClick( ItemDocument *itemDocument, CMManager *cmManager )
        : CanvasManipulator( itemDocument, cmManager )
{
}

CMRightClick::~CMRightClick()
{
}

CanvasManipulator* CMRightClick::construct( ItemDocument *itemDocument, CMManager *cmManager )
{
        return new CMRightClick(itemDocument,cmManager);
}

ManipulatorInfo *CMRightClick::manipulatorInfo()
{
        ManipulatorInfo *eventInfo = new ManipulatorInfo();
//      eventInfo->m_eventState.m_activate = CMManager::es_right_click;
        eventInfo->m_acceptManipulationPtr = CMRightClick::acceptManipulation;
        eventInfo->m_createManipulatorPtr = CMRightClick::construct;
        return eventInfo;
}

bool CMRightClick::acceptManipulation( uint eventState, uint /*cmState*/, uint /*itemType*/, uint /*cnItemType*/ )
{
        return eventState & CMManager::es_right_click;
}

bool CMRightClick::mousePressedInitial( const EventInfo &eventInfo )
{
        m_eventInfo = eventInfo;
        p_itemDocument->canvasRightClick( eventInfo.globalPos, eventInfo.qcanvasItemClickedOn );
        return true;
}

bool CMRightClick::mouseMoved( const EventInfo &/*eventInfo*/ )
{
        return true;
}

bool CMRightClick::mouseReleased( const EventInfo &/*eventInfo*/ )
{
        return true;
}

//BEGIN class ConnectorDraw
ConnectorDraw::ConnectorDraw( ItemDocument *itemDocument, CMManager *cmManager )
        : CanvasManipulator( itemDocument, cmManager )
{
        p_startNode = 0;
        p_startConnector = 0;
        p_endNode = 0;
        p_endConnector = 0;
}

ConnectorDraw::~ConnectorDraw()
{
}

QColor ConnectorDraw::validConnectionColor()
{
        return QColor(255, 166, 0);
}

static double qpoint_distance( const QPoint & p1, const QPoint & p2 )
{
        double dx = p1.x() - p2.x();
        double dy = p1.y() - p2.y();

        return std::sqrt( dx*dx + dy*dy );
}

QPoint ConnectorDraw::toValidPos( const QPoint & clickPos, Connector * clickedConnector ) const
{
        if(!clickedConnector ) return clickPos;
        
        const QPointList pointList = clickedConnector->connectorPoints();
        QPointList::const_iterator end = pointList.end();
        
        double dl[] = { 0.5, 8.5, 11.5, 18.0, 23.0 }; // various distances rounded up of (0,0) cells, (0,1), etc

        for ( unsigned i = 0; i < 5; ++i ) {
                for ( QPointList::const_iterator it = pointList.begin(); it != end; ++it ) {
                        if(qpoint_distance( *it, clickPos ) <= dl[i]) return *it;
                }
        }

        return clickPos;
}

Connector *ConnectorDraw::toConnector( Node * node )
{
        if( !node || node->numCon( true, false ) < 3) return 0;

        const ConnectorList inList = node->inputConnectorList();
        if( !inList.isEmpty() )
                return *inList.begin();

        const ConnectorList outList = node->outputConnectorList();
        if( !outList.isEmpty() )
                return *outList.begin();

        return 0;
}

void ConnectorDraw::grabEndStuff( QCanvasItem * endItem, const QPoint & pos, bool posIsExact )
{
        if (!endItem) return;

        CNItem * cnItem = dynamic_cast<CNItem*>(endItem);
        if ( cnItem && !posIsExact )
                p_endNode = cnItem->getClosestNode(pos);
        else p_endNode = dynamic_cast<Node*>(endItem);

        if ( p_endNode && p_endNode->numCon( true, false ) > 2 ) {
                p_endConnector = toConnector(p_endNode);
                p_endNode = 0;
        }

        // If the endItem is a node, we have to finish exactly on the end when posIsExact is true
        if ( posIsExact && p_endNode && (p_endNode->x() != pos.x() || p_endNode->y() != pos.y()) )
                p_endNode = 0;

        if(!p_endConnector)
                p_endConnector = dynamic_cast<Connector*>(endItem);
}
//END class ConnectorDraw

//BEGIN class CMAutoConnector
CMAutoConnector::CMAutoConnector( ItemDocument *itemDocument, CMManager *cmManager )
        : ConnectorDraw( itemDocument, cmManager )
{
        m_connectorLine = 0;
        p_startNode = 0;
        p_startConnector = 0;
}

CMAutoConnector::~CMAutoConnector()
{
        delete m_connectorLine;
        m_connectorLine = 0;
}

CanvasManipulator* CMAutoConnector::construct( ItemDocument *itemDocument, CMManager *cmManager )
{
        return new CMAutoConnector(itemDocument,cmManager);
}

ManipulatorInfo *CMAutoConnector::manipulatorInfo()
{
        ManipulatorInfo *eventInfo = new ManipulatorInfo();
        eventInfo->m_acceptManipulationPtr = CMAutoConnector::acceptManipulation;
        eventInfo->m_createManipulatorPtr = CMAutoConnector::construct;
        return eventInfo;
}

bool CMAutoConnector::acceptManipulation( uint /*eventState*/, uint cmState, uint itemType, uint /*cnItemType*/ )
{
        return (itemType & (CMManager::it_node | CMManager::it_connector)) && !(cmState & CMManager::cms_manual_route);
}

bool CMAutoConnector::mousePressedInitial( const EventInfo &eventInfo )
{
        m_eventInfo = eventInfo;
        p_startNode = dynamic_cast<Node*>(eventInfo.qcanvasItemClickedOn);
        
        if (p_startNode) {
                m_eventInfo.pos = m_prevPos = p_icnDocument->gridSnap( QPoint( (int)p_startNode->x(), (int)p_startNode->y() ) );
                if (p_startNode->numCon( true, false ) > 2)
                {
                        p_startConnector = toConnector(p_startNode);
                        p_startNode = 0;
                }
        } else if (p_startConnector = dynamic_cast<Connector*>(eventInfo.qcanvasItemClickedOn) )
        {
//              startConnectorPoint = m_eventInfo.pos = m_prevPos = p_icnDocument->gridSnap(m_eventInfo.pos);
                startConnectorPoint = m_eventInfo.pos = m_prevPos = toValidPos( m_eventInfo.pos, p_startConnector );
        } else return true;
                
        p_icnDocument->unselectAll();
        
        delete m_connectorLine;
        m_connectorLine = new QCanvasLine(p_canvas);
        m_connectorLine->setPen( QColor(0,0,0) );
        m_connectorLine->setZ( ItemDocument::Z::ConnectorCreateLine );
        m_connectorLine->show();
        return false;
}

bool CMAutoConnector::mouseMoved( const EventInfo &eventInfo )
{
        const QPoint pos = eventInfo.pos;
        
        int newX = p_icnDocument->gridSnap( pos.x() );
        int newY = p_icnDocument->gridSnap( pos.y() );

        bool movedFlag = false;

        if ( newX != m_prevPos.x() ) {
                m_prevPos.setX(newX);
                movedFlag = true;
        }

        if ( newY != m_prevPos.y() ) {
                m_prevPos.setY(newY);
                movedFlag = true;
        }

        m_connectorLine->setPoints( m_eventInfo.pos.x(), m_eventInfo.pos.y(), newX, newY );

        if (movedFlag) {
                QCanvasItem *startItem = 0;
                if (p_startNode)
                        startItem = p_startNode;
                else if (p_startConnector)
                        startItem = p_startConnector;
                
                QCanvasItem *endItem = p_icnDocument->itemAtTop( QPoint( newX, newY ) );
                if ( endItem && endItem->rtti() == ItemDocument::RTTI::CNItem )
                        endItem = (static_cast<CNItem*>(endItem))->getClosestNode( QPoint( newX, newY ) );
                
                bool validLine = p_icnDocument->canConnect( startItem, endItem );
                m_connectorLine->setPen( validLine ? validConnectionColor() : Qt::black );
        }
        return false;
}

bool CMAutoConnector::mouseReleased( const EventInfo &eventInfo )
{
        const QPoint pos = eventInfo.pos;
        
        QPoint end = m_connectorLine->endPoint();
        delete m_connectorLine;
        m_connectorLine = 0;
        
        QCanvasItem *qcanvasItem = p_icnDocument->itemAtTop(end);
        if ( !qcanvasItem )
                return true;
        
        grabEndStuff( qcanvasItem, pos, false );
        
        if (p_startConnector) {
                if (p_endConnector) {
                        if ( !p_icnDocument->createConnector( p_endConnector, p_startConnector, p_icnDocument->gridSnap(pos), startConnectorPoint ) )
                                return true;
                } else if (p_endNode) {
                        if ( !p_icnDocument->createConnector( p_endNode, p_startConnector, startConnectorPoint ) )
                                return true;
                } else return true;
        } else if (p_startNode) {
                if (p_endConnector) {
                        if ( !p_icnDocument->createConnector( p_startNode, p_endConnector, p_icnDocument->gridSnap(pos) ) )
                                return true;
                } else if (p_endNode) {
                        if ( !p_icnDocument->createConnector( p_startNode, p_endNode ) )
                                return true;
                } else return true;
        } else return true;

        p_itemDocument->requestStateSave();
        return true;
}
//END class CMAutoConnector

//BEGIN class CMManualConnector

CMManualConnector::CMManualConnector( ItemDocument *itemDocument, CMManager *cmManager )
        : ConnectorDraw( itemDocument, cmManager )
{
        m_manualConnectorDraw = 0;
}

CMManualConnector::~CMManualConnector()
{
        delete m_manualConnectorDraw;
        m_manualConnectorDraw = 0;
}

CanvasManipulator* CMManualConnector::construct( ItemDocument *itemDocument, CMManager *cmManager )
{
        return new CMManualConnector(itemDocument,cmManager);
}

ManipulatorInfo *CMManualConnector::manipulatorInfo()
{
        ManipulatorInfo *eventInfo = new ManipulatorInfo();
        eventInfo->m_acceptManipulationPtr = CMManualConnector::acceptManipulation;
        eventInfo->m_createManipulatorPtr = CMManualConnector::construct;
        return eventInfo;
}

bool CMManualConnector::acceptManipulation( uint /*eventState*/, uint cmState, uint itemType, uint /*cnItemType*/ )
{
        return (itemType & (CMManager::it_node | CMManager::it_connector)) && (cmState & CMManager::cms_manual_route);
}

bool CMManualConnector::mousePressedInitial( const EventInfo &eventInfo )
{
        if ( eventInfo.isRightClick ) return true;

        m_eventInfo = eventInfo;
        p_icnDocument->unselectAll();
        QPoint sp;

        if ( eventInfo.itemRtti == ItemDocument::RTTI::Node ) {
                p_startNode = static_cast<Node*>(eventInfo.qcanvasItemClickedOn);
                sp.setX( (int)p_startNode->x() );
                sp.setY( (int)p_startNode->y() );
                if ( p_startNode->numCon( true, false ) > 2 ) {
                        p_startConnector = toConnector(p_startNode);
                        p_startNode = 0;
                }
        } else {
                p_startConnector = dynamic_cast<Connector*>(eventInfo.qcanvasItemClickedOn);
                sp = toValidPos( eventInfo.pos, p_startConnector );
        }
        startConnectorPoint = sp;
        
        if (m_manualConnectorDraw) {
                delete m_manualConnectorDraw;
                m_manualConnectorDraw = 0;
        }
        m_manualConnectorDraw = new ManualConnectorDraw( p_icnDocument, sp );
        return false;
}

bool CMManualConnector::mousePressedRepeat( const EventInfo &eventInfo )
{
        m_eventInfo = eventInfo;
        if ( eventInfo.isRightClick ) return true;

        m_manualConnectorDraw->mouseClicked( p_icnDocument->gridSnap(m_eventInfo.pos) );
        return false;
}

bool CMManualConnector::mouseMoved( const EventInfo &eventInfo )
{
        if(!m_manualConnectorDraw ) return true;

        const QPoint pos = eventInfo.pos;

        int newX = p_icnDocument->gridSnap( pos.x() );
        int newY = p_icnDocument->gridSnap( pos.y() );

        bool movedFlag = false;

        if(newX != m_prevPos.x()) {
                m_prevPos.setX(newX);
                movedFlag = true;
        }

        if(newY != m_prevPos.y() ) {
                m_prevPos.setY(newY);
                movedFlag = true;
        }
        
        if ( movedFlag ) {
                QCanvasItem *startItem = 0;
                if (p_startNode) startItem = p_startNode;
                else if (p_startConnector)
                        startItem = p_startConnector;
                
                QCanvasItem * endItem = p_icnDocument->itemAtTop( QPoint( newX, newY ) );
                
                // If the endItem is a node, we have to finish exactly on the end.
                if(Node * node = dynamic_cast<Node*>(endItem) ) {
                        if(node->x() != newX || node->y() != newY )
                                endItem = 0;
                }

                bool validLine = p_icnDocument->canConnect( startItem, endItem );

                m_manualConnectorDraw->setColor( validLine ? validConnectionColor() : Qt::black );
                m_manualConnectorDraw->mouseMoved( QPoint( newX, newY ) );
        }

        return false;
}

bool CMManualConnector::mouseReleased( const EventInfo &eventInfo )
{
        if (!m_manualConnectorDraw) return true;

        QPoint pos = p_icnDocument->gridSnap(eventInfo.pos);
        grabEndStuff( m_manualConnectorDraw->mouseClicked(pos), pos, true );
        
        if(!p_endNode && !p_endConnector ) return false;
        
        // Create the points that define the manual route
        QPointList list = m_manualConnectorDraw->pointList();
        delete m_manualConnectorDraw;
        m_manualConnectorDraw = 0;
        
        if (p_startConnector) {
                if (p_endConnector) {
                        if ( !p_icnDocument->createConnector( p_endConnector, p_startConnector, p_icnDocument->gridSnap(pos), startConnectorPoint, &list ) )
                                return true;
                } else {
                        if ( !p_icnDocument->createConnector( p_endNode, p_startConnector, startConnectorPoint, &list ) )
                                return true;
                }
        } else if (p_startNode) {
                if (p_endConnector) {
                        if ( !p_icnDocument->createConnector( p_startNode, p_endConnector, p_icnDocument->gridSnap(pos), &list ) )
                                return true;
                } else {
                        if ( !p_icnDocument->createConnector( p_startNode, p_endNode, &list ) )
                                return true;
                }
        } else return true;
        
        p_itemDocument->requestStateSave();
        return true;
}
//END class CMManualConnector

CMItemMove::CMItemMove( ItemDocument *itemDocument, CMManager *cmManager )
        : CanvasManipulator( itemDocument, cmManager )
{
        p_flowContainerCandidate = 0;
}

CMItemMove::~CMItemMove()
{
}

CanvasManipulator* CMItemMove::construct( ItemDocument *itemDocument, CMManager *cmManager )
{
        return new CMItemMove(itemDocument,cmManager);
}

ManipulatorInfo *CMItemMove::manipulatorInfo()
{
        ManipulatorInfo *eventInfo = new ManipulatorInfo();
        eventInfo->m_acceptManipulationPtr = CMItemMove::acceptManipulation;
        eventInfo->m_createManipulatorPtr = CMItemMove::construct;
        return eventInfo;
}

bool CMItemMove::acceptManipulation( uint eventState, uint /*cmState*/, uint itemType, uint cnItemType )
{
        return ((itemType & CMManager::it_canvas_item) || (itemType & CMManager::it_drawpart)) && (cnItemType & CMManager::isi_isMovable) && !(eventState & CMManager::es_right_click);
}

bool CMItemMove::mousePressedInitial( const EventInfo &eventInfo )
{
        m_eventInfo = eventInfo;
        m_prevPos = eventInfo.pos;
        
        Item *item = dynamic_cast<Item*>(eventInfo.qcanvasItemClickedOn);
        if (!item) return true;

        if ( !p_selectList->contains(item) )
        {
                if (!eventInfo.ctrlPressed)
                        p_itemDocument->unselectAll();

                p_itemDocument->select(item);
        } else if (m_eventInfo.ctrlPressed)
                p_itemDocument->unselect(item);
        
        if ( p_selectList->isEmpty() ) return true;
        
        // We want to allow dragging into FlowContainers if this is a FlowView
        p_flowContainerCandidate = 0;
        {
                const ItemList &itemList = p_icnDocument->itemList();
                const ItemList::const_iterator ciEnd = itemList.end();
                for ( ItemList::const_iterator it = itemList.begin(); it != ciEnd; ++it )
                {
                        if ( FlowContainer *flowContainer = dynamic_cast<FlowContainer*>((Item*)*it) )
                                flowContainer->setFullBounds(true);
                }
        }
        
        ItemList itemList = p_cnItemSelectList->items(false);
        itemList.remove((Item*)0);
        
        const ItemList::iterator itemListEnd = itemList.end();
        for ( ItemList::iterator it = itemList.begin(); it != itemListEnd; ++it )
        {
                CNItem *cnItem = dynamic_cast<CNItem*>((Item*)*it);
                if ( !cnItem || !cnItem->canvas() ) continue;

                cnItem->setInitialPos(m_eventInfo.pos);
        }

        ConnectorList fixedConnectors;
        p_icnDocument->getTranslatable( itemList, &fixedConnectors, &m_translatableConnectors, &m_translatableNodeGroups );
        
        const ConnectorList::iterator fixedConnectorsEnd = fixedConnectors.end();
        for ( ConnectorList::iterator it = fixedConnectors.begin(); it != fixedConnectorsEnd; ++it )
                (*it)->setSemiHidden(true);

        p_flowContainerCandidate = p_icnDocument->flowContainer(eventInfo.pos);

        return false;
}

bool CMItemMove::mouseMoved( const EventInfo &eventInfo )
{
        const QPoint pos = eventInfo.pos;

        int x = pos.x();
        int y = pos.y();

        const ItemList itemList = p_cnItemSelectList->items();
        const ItemList::const_iterator end = itemList.end();
        int dx=0, dy=0;

        for ( ItemList::const_iterator it = itemList.begin(); it != end; ++it )
        {
                if(!*it || !(*it)->isMovable() )
                        continue;
                
                const QRect oldRect = (*it)->boundingRect();
                (*it)->setChanged();
                
                if(CNItem *cnItem = dynamic_cast<CNItem*>((Item*)*it) ) {
                        dx = -int((*it)->x());
                        dy = -int((*it)->y());
                        cnItem->snap( x, y );
                        dx += int((*it)->x());
                        dy += int((*it)->y());
                } else (*it)->moveBy( eventInfo.pos.x()-m_prevPos.x(), eventInfo.pos.y()-m_prevPos.y() );

                QRect newRect = (*it)->boundingRect();
                QRect merged = oldRect | newRect;
        }

        if ( (dx != 0) || (dy != 0) ) {
                const ConnectorList::iterator frEnd = m_translatableConnectors.end();
                for ( ConnectorList::iterator it = m_translatableConnectors.begin(); it != frEnd; ++it )
                        (*it)->translateRoute( dx, dy );

                const NodeGroupList::iterator end = m_translatableNodeGroups.end();
                for ( NodeGroupList::iterator it = m_translatableNodeGroups.begin(); it != end; ++it )
                        (*it)->translate( dx, dy );
        }

        FlowContainer *fc = p_icnDocument->flowContainer(pos);
        if(fc != p_flowContainerCandidate ) {
                if(p_flowContainerCandidate ) {
                        p_flowContainerCandidate->setSelected(false);
                        p_flowContainerCandidate = 0;
                }
        }

        if (fc) {
                p_flowContainerCandidate = fc;
                p_flowContainerCandidate->setSelected(true);
        }
        
        p_itemDocument->