Added KDE3 version of ktechlab

git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/applications/ktechlab@1095338 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 1904 insertions, 0 deletions

diff --git a/src/canvasmanipulator.cpp b/src/canvasmanipulator.cpp
new file mode 100644
index 0000000..7c3ed17
--- /dev/null
+++ b/src/canvasmanipulator.cpp
@@ -0,0 +1,1904 @@
+/***************************************************************************
+ *   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>
+
+
+CMManager::CMManager( ItemDocument *itemDocument )
+	: QObject()
+{
+	b_allowItemScroll = true;
+	p_lastMouseOverResizeHandle = 0l;
+	m_canvasManipulator = 0l;
+	p_itemDocument = itemDocument;
+	m_cmState = 0;
+	p_lastMouseOverItem = 0l;
+	p_lastItemClicked = 0l;
+	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;
+	m_allowItemScrollTmr = 0l;
+	delete m_canvasManipulator;
+	m_canvasManipulator = 0l;
+	
+	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 = 0l;
+	setRepeatedAddId();
+}
+
+
+void CMManager::mousePressEvent( EventInfo eventInfo )
+{
+	if (m_canvasManipulator)
+	{
+		if (m_canvasManipulator->mousePressedRepeat(eventInfo))
+		{
+			delete m_canvasManipulator;
+			m_canvasManipulator = 0l;
+		}
+		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=0l;
+	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 = 0l;
+		}
+	}
+}
+
+
+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 = 0l;
+			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 = 0l;
+	}
+	
+	if (p_lastItemClicked)
+	{
+		p_lastItemClicked->mouseReleaseEvent(eventInfo);
+		p_lastItemClicked=0l;
+	}
+	
+	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 = 0l;
+	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 = 0l;
+	p_startConnector = 0l;
+	p_endNode = 0l;
+	p_endConnector = 0l;
+}
+
+
+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 0l;
+	
+	const ConnectorList inList = node->inputConnectorList();
+	if ( !inList.isEmpty() )
+		return *inList.begin();
+	
+	const ConnectorList outList = node->outputConnectorList();
+	if ( !outList.isEmpty() )
+		return *outList.begin();
+	
+	return 0l;
+}
+
+
+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 = 0l;
+	}
+	
+	// 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 = 0l;
+	
+	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 = 0l;
+	p_startNode = 0l;
+	p_startConnector = 0l;
+}
+CMAutoConnector::~CMAutoConnector()
+{
+	delete m_connectorLine;
+	m_connectorLine = 0l;
+}
+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 = 0l;
+		}
+	}
+	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 = 0l;
+		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 = 0l;
+	
+	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 = 0l;
+}
+CMManualConnector::~CMManualConnector()
+{
+	delete m_manualConnectorDraw;
+	m_manualConnectorDraw = 0l;
+}
+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 = 0l;
+		}
+	}
+	else
+	{
+		p_startConnector = dynamic_cast<Connector*>(eventInfo.qcanvasItemClickedOn);
+		sp = toValidPos( eventInfo.pos, p_startConnector );
+	}
+	startConnectorPoint = sp;
+	
+	if (m_manualConnectorDraw)
+		delete m_manualConnectorDraw;
+	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 = 0l;
+		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 = 0l;
+		}
+		
+		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 = 0l;
+	
+	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_endNode)
+		{
+			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_endNode)
+		{
+			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 = 0l;
+}
+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 = 0l;
+	{
+		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*)0l);
+	
+	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 = 0l;
+		}
+	}
+	if (fc)
+	{
+		p_flowContainerCandidate = fc;
+		p_flowContainerCandidate->setSelected(true);
+	}
+	
+	p_itemDocument->requestEvent( ItemDocument::ItemDocumentEvent::ResizeCanvasToItems );
+	p_canvas->update();
+	m_prevPos = eventInfo.pos;
+	return false;
+}
+
+
+bool CMItemMove::mouseReleased( const EventInfo &eventInfo )
+{
+	QStringList itemIDs;
+	
+	const ItemList itemList = p_cnItemSelectList->items();
+	const ItemList::const_iterator ilEnd = itemList.end();
+	for ( ItemList::const_iterator it = itemList.begin(); it != ilEnd; ++it )
+	{
+		if (*it)
+			itemIDs.append( (*it)->id() );
+	}
+	
+	const QPoint pos = eventInfo.pos;
+	
+	// And make sure all connectors are properly shown
+	const ConnectorList &connectorList = p_icnDocument->connectorList();
+	const ConnectorList::const_iterator conEnd = connectorList.end();
+	for ( ConnectorList::const_iterator it = connectorList.begin(); it != conEnd; ++it )
+	{
+		(*it)->setSemiHidden(false);
+	}
+	
+	if (p_flowContainerCandidate)
+	{
+		for ( ItemList::const_iterator it = itemList.begin(); it != ilEnd; ++it )
+			p_flowContainerCandidate->addChild(*it);
+		
+		p_flowContainerCandidate->setSelected(false);
+		p_flowContainerCandidate = 0l;
+	}
+	else
+	{
+		for ( ItemList::const_iterator it = itemList.begin(); it != ilEnd; ++it )
+			(*it)->setParentItem(0l);
+	}
+	
+	// And disable the FlowContainers again...
+	const ItemList &cnItemList = p_icnDocument->itemList();
+	const ItemList::const_iterator end = cnItemList.end();
+	for ( ItemList::const_iterator it = cnItemList.begin(); it != end; ++it )
+	{
+		if ( FlowContainer *flowContainer = dynamic_cast<FlowContainer*>((Item*)*it) )
+			flowContainer->setFullBounds(false);
+	}
+	
+	if (p_icnDocument)
+		p_icnDocument->requestRerouteInvalidatedConnectors();
+	
+	if ( m_eventInfo.pos != eventInfo.pos )
+		p_itemDocument->requestStateSave();
+	
+	p_itemDocument->requestEvent( ItemDocument::ItemDocumentEvent::ResizeCanvasToItems );
+	
+	return true;
+}
+
+
+
+
+
+CMItemResize::CMItemResize( ItemDocument *itemDocument, CMManager *cmManager )
+	: CanvasManipulator( itemDocument, cmManager )
+{
+}
+CMItemResize::~CMItemResize()
+{
+}
+CanvasManipulator* CMItemResize::construct( ItemDocument *itemDocument, CMManager *cmManager )
+{
+	return new CMItemResize(itemDocument,cmManager);
+}
+ManipulatorInfo *CMItemResize::manipulatorInfo()
+{
+	ManipulatorInfo *eventInfo = new ManipulatorInfo();
+// 	eventInfo->m_itemType.m_activate = CMManager::it_canvas_item;
+	eventInfo->m_acceptManipulationPtr = CMItemResize::acceptManipulation;
+	eventInfo->m_createManipulatorPtr = CMItemResize::construct;
+	return eventInfo;
+}
+bool CMItemResize::acceptManipulation( uint eventState, uint /*cmState*/, uint itemType, uint /*cnItemType*/ )
+{
+	return (itemType & CMManager::it_resize_handle) && !(eventState & CMManager::es_right_click);
+}
+
+
+
+bool CMItemResize::mousePressedInitial( const EventInfo &eventInfo )
+{
+	m_eventInfo = eventInfo;
+	p_resizeHandle = dynamic_cast<ResizeHandle*>(eventInfo.qcanvasItemClickedOn);
+	m_rh_dx = p_resizeHandle->x()-eventInfo.pos.x();
+	m_rh_dy = p_resizeHandle->y()-eventInfo.pos.y();
+	return false;
+}
+
+
+bool CMItemResize::mouseMoved( const EventInfo &eventInfo )
+{
+	int _x = int(m_rh_dx + eventInfo.pos.x());
+	int _y = int(m_rh_dy + eventInfo.pos.y());
+	
+	// Shift pressed == snap to grid
+	if ( eventInfo.shiftPressed )
+	{
+		_x = int(_x/8)*8+4;
+		_y = int(_y/8)*8+4;
+	}
+	
+	p_resizeHandle->moveRH( _x, _y );
+	return false;
+}
+
+
+bool CMItemResize::mouseReleased( const EventInfo &/*eventInfo*/ )
+{
+	if (p_icnDocument)
+		p_icnDocument->requestRerouteInvalidatedConnectors();
+	p_itemDocument->requestStateSave();
+	return true;
+}
+
+
+
+
+
+
+
+CMMechItemMove::CMMechItemMove( ItemDocument *itemDocument, CMManager *cmManager )
+	: CanvasManipulator( itemDocument, cmManager )
+{
+}
+CMMechItemMove::~CMMechItemMove()
+{
+}
+CanvasManipulator* CMMechItemMove::construct( ItemDocument *itemDocument, CMManager *cmManager )
+{
+	return new CMMechItemMove(itemDocument,cmManager);
+}
+ManipulatorInfo *CMMechItemMove::manipulatorInfo()
+{
+	ManipulatorInfo *eventInfo = new ManipulatorInfo();
+// 	eventInfo->m_itemType.m_activate = CMManager::it_canvas_item;
+	eventInfo->m_acceptManipulationPtr = CMMechItemMove::acceptManipulation;
+	eventInfo->m_createManipulatorPtr = CMMechItemMove::construct;
+	return eventInfo;
+}
+bool CMMechItemMove::acceptManipulation( uint eventState, uint /*cmState*/, uint itemType, uint /*cnItemType*/ )
+{
+	return ((itemType & CMManager::it_mechanics_item) || (itemType & CMManager::it_drawpart)) && !(eventState & CMManager::es_right_click);
+}
+
+
+bool CMMechItemMove::mousePressedInitial( const EventInfo &eventInfo )
+{
+	m_eventInfo = eventInfo;
+	m_prevPos = eventInfo.pos;
+	
+	Item *item = dynamic_cast<Item*>(eventInfo.qcanvasItemClickedOn);
+	if (!item)
+		return true;
+	
+	MechanicsItem *mechItem = dynamic_cast<MechanicsItem*>(eventInfo.qcanvasItemClickedOn);
+	
+	if (mechItem)
+		m_prevClickedOnSM = mechItem->selectionMode();
+	
+	if (eventInfo.shiftPressed)
+	{
+		p_mechanicsDocument->unselectAll();
+		p_mechanicsDocument->select(item);
+		if (mechItem)
+		{
+			mechItem->setSelectionMode(MechanicsItem::sm_move);
+			mechItem->setParentItem(0l);
+		}
+	}
+	else if ( !p_selectList->contains(mechItem) )
+	{
+		if (!eventInfo.ctrlPressed)
+			p_mechanicsDocument->unselectAll();
+		
+		p_mechanicsDocument->select(item);
+		
+		if (mechItem)
+			mechItem->setSelectionMode(MechanicsItem::sm_move);
+	}
+	else
+	{
+		if (mechItem)
+			mechItem->setSelectionMode(MechanicsItem::sm_move);
+		
+		if (m_eventInfo.ctrlPressed)
+			p_mechanicsDocument->unselect(item);
+	}
+	
+	if ( p_selectList->isEmpty() )
+		return true;
+	
+	p_mechItemSelectList->setSelectionMode( MechanicsItem::sm_move );
+	p_mechItemSelectList->setRaised(true);
+	return false;
+}
+
+
+bool CMMechItemMove::mouseMoved( const EventInfo &eventInfo )
+{
+	const QPoint pos = eventInfo.pos;
+	
+	int x = pos.x();
+	int y = pos.y();
+	
+	const MechItemList itemList = p_mechItemSelectList->toplevelMechItemList();
+	const MechItemList::const_iterator ilEnd = itemList.end();
+	for ( MechItemList::const_iterator it = itemList.begin(); it != ilEnd; ++it )
+	{
+		if (*it)
+			(*it)->moveBy( x - m_prevPos.x(), y - m_prevPos.y() );
+	}
+	
+	m_prevPos = QPoint( x, y );
+	
+	p_canvas->update();
+	p_itemDocument->requestEvent( ItemDocument::ItemDocumentEvent::ResizeCanvasToItems );
+	return false;
+}
+
+
+bool CMMechItemMove::mouseReleased( const EventInfo &eventInfo )
+{
+	const QPoint pos = eventInfo.pos;
+			
+	int dx = pos.x() - m_eventInfo.pos.x();
+	int dy = pos.y() - m_eventInfo.pos.y();
+	
+	p_mechItemSelectList->setRaised(false);
+	
+	MechanicsItem *mechItem = dynamic_cast<MechanicsItem*>(m_eventInfo.qcanvasItemClickedOn);
+	if ( dx == 0 && dy == 0 )
+	{
+		if ( mechItem && mechItem->isSelected() )
+		{
+			if ( m_prevClickedOnSM == MechanicsItem::sm_resize )
+				mechItem->setSelectionMode( MechanicsItem::sm_rotate );
+			else
+				mechItem->setSelectionMode( MechanicsItem::sm_resize );
+		}
+		p_itemDocument->requestStateSave();
+		return true;
+	}
+	
+	if ( mechItem && mechItem->isSelected() )
+	{
+		if ( m_prevClickedOnSM == MechanicsItem::sm_rotate )
+			mechItem->setSelectionMode(MechanicsItem::sm_rotate);
+		else
+			mechItem->setSelectionMode(MechanicsItem::sm_resize);
+	}
+	
+	QStringList itemIDs;
+	
+	ItemList itemList = p_mechItemSelectList->items();
+	const ItemList::iterator ilEnd = itemList.end();
+	for ( ItemList::iterator it = itemList.begin(); it != ilEnd; ++it )
+	{
+		if (*it) {
+			itemIDs.append( (*it)->id() );
+		}
+	}
+	
+	p_mechItemSelectList->setSelectionMode( MechanicsItem::sm_resize );
+	p_itemDocument->requestStateSave();
+	p_itemDocument->requestEvent( ItemDocument::ItemDocumentEvent::ResizeCanvasToItems );
+	return true;
+}
+
+
+
+//BEGIN class SelectRectangle
+SelectRectangle::SelectRectangle( int x, int y, int w, int h, QCanvas *qcanvas )
+	: m_x(x), m_y(y)
+{
+	m_topLine = new QCanvasLine(qcanvas);
+	m_rightLine = new QCanvasLine(qcanvas);
+	m_bottomLine = new QCanvasLine(qcanvas);
+	m_leftLine = new QCanvasLine(qcanvas);
+	setSize( w, h );
+	
+	QCanvasLine* lines[] = { m_topLine, m_rightLine, m_bottomLine, m_leftLine };
+	for ( int i=0; i<4; ++ i)
+	{
+		lines[i]->setPen( QPen( QColor(190,190,190), 1, Qt::DotLine ) );
+		lines[i]->setZ( ICNDocument::Z::Select );
+		lines[i]->show();
+	}
+}
+
+
+SelectRectangle::~SelectRectangle()
+{
+	delete m_topLine;
+	delete m_rightLine;
+	delete m_bottomLine;
+	delete m_leftLine;
+}
+
+
+void SelectRectangle::setSize( int w, int h )
+{
+	m_topLine->setPoints( m_x, m_y, m_x+w, m_y );
+	m_rightLine->setPoints( m_x+w, m_y, m_x+w, m_y+h );
+	m_bottomLine->setPoints( m_x+w, m_y+h, m_x, m_y+h );
+	m_leftLine->setPoints( m_x, m_y+h, m_x, m_y );
+	m_w = w;
+	m_h = h;
+}
+
+
+QCanvasItemList SelectRectangle::collisions()
+{
+	QCanvas *canvas = m_topLine->canvas();
+	
+	return canvas->collisions( QRect( m_x, m_y, m_w, m_h ) );
+}
+//END class SelectRectangle
+
+
+//BEGIN class CMSelect
+CMSelect::CMSelect( ItemDocument *itemDocument, CMManager *cmManager )
+	: CanvasManipulator( itemDocument, cmManager )
+{
+	m_selectRectangle = 0l;
+}
+CMSelect::~CMSelect()
+{
+	delete m_selectRectangle;
+	m_selectRectangle = 0l;
+}
+CanvasManipulator* CMSelect::construct( ItemDocument *itemDocument, CMManager *cmManager )
+{
+	return new CMSelect(itemDocument,cmManager);
+}
+ManipulatorInfo *CMSelect::manipulatorInfo()
+{
+	ManipulatorInfo *eventInfo = new ManipulatorInfo();
+// 	eventInfo->m_itemType.m_activate = CMManager::it_none;
+	eventInfo->m_acceptManipulationPtr = CMSelect::acceptManipulation;
+	eventInfo->m_createManipulatorPtr = CMSelect::construct;
+	return eventInfo;
+}
+bool CMSelect::acceptManipulation( uint /*eventState*/, uint /*cmState*/, uint itemType, uint /*cnItemType*/ )
+{
+	return (itemType & CMManager::it_none);
+}
+
+
+bool CMSelect::mousePressedInitial( const EventInfo &eventInfo )
+{
+	m_eventInfo = eventInfo;
+	
+    if (!eventInfo.ctrlPressed) {
+		p_itemDocument->unselectAll();
+	}
+	
+	m_selectRectangle = new SelectRectangle( eventInfo.pos.x(), eventInfo.pos.y(), 0, 0, p_canvas );
+	return false;
+}
+
+
+bool CMSelect::mouseMoved( const EventInfo &eventInfo )
+{
+	QPoint pos = eventInfo.pos;
+	
+    m_selectRectangle->setSize( pos.x()-m_eventInfo.pos.x(), pos.y()-m_eventInfo.pos.y() );
+	
+	if (m_eventInfo.ctrlPressed) {
+		p_itemDocument->select( m_selectRectangle->collisions() );
+	} else if (p_selectList) {
+		p_selectList->setItems( m_selectRectangle->collisions() );
+	}
+
+	if (p_selectList && !p_mechanicsDocument) {
+		p_selectList->setSelected(true);
+	}
+	return false;
+}
+
+
+bool CMSelect::mouseReleased( const EventInfo &/*eventInfo*/ )
+{
+	delete m_selectRectangle;
+	m_selectRectangle = 0l;
+	
+	return true;
+}
+//END class CMSelect
+
+
+
+
+CMItemDrag::CMItemDrag( ItemDocument *itemDocument, CMManager *cmManager )
+	: CanvasManipulator( itemDocument, cmManager )
+{
+	b_dragged = false;
+}
+CMItemDrag::~CMItemDrag()
+{
+}
+CanvasManipulator* CMItemDrag::construct( ItemDocument *itemDocument, CMManager *cmManager )
+{
+	return new CMItemDrag(itemDocument,cmManager);
+}
+ManipulatorInfo *CMItemDrag::manipulatorInfo()
+{
+	ManipulatorInfo *eventInfo = new ManipulatorInfo();
+// 	eventInfo->m_itemType.m_activate = CMManager::it_canvas_item;
+	eventInfo->m_acceptManipulationPtr = CMItemDrag::acceptManipulation;
+	eventInfo->m_createManipulatorPtr = CMItemDrag::construct;
+	return eventInfo;
+}
+bool CMItemDrag::acceptManipulation( uint /*eventState*/, uint /*cmState*/, uint itemType, uint cnItemType )
+{
+	return (itemType & (CMManager::it_canvas_item|CMManager::it_pin)) && !(cnItemType & CMManager::isi_isMovable);
+}
+
+
+bool CMItemDrag::mousePressedInitial( const EventInfo &eventInfo )
+{
+	m_eventInfo = eventInfo;
+	b_dragged = false;
+	return false;
+}
+
+
+bool CMItemDrag::mouseMoved( const EventInfo &eventInfo )
+{
+	const QPoint pos = eventInfo.pos;
+			
+	if ( b_dragged ||
+		 pos.x() > (m_eventInfo.pos.x()+4 ) ||
+		 pos.x() < (m_eventInfo.pos.x()-4) ||
+		 pos.y() > (m_eventInfo.pos.y()+4) ||
+		 pos.y() < (m_eventInfo.pos.y()-4) )
+	{
+	
+		b_dragged = true;
+		
+		if ( m_eventInfo.itemRtti == ItemDocument::RTTI::Pin )
+			((PinItem*)m_eventInfo.qcanvasItemClickedOn)->dragged( pos.x() - m_eventInfo.pos.x() );
+	}
+	return false;
+}
+
+
+bool CMItemDrag::mouseReleased( const EventInfo &/*eventInfo*/ )
+{
+	if ( !b_dragged && m_eventInfo.itemRtti == ItemDocument::RTTI::Pin )
+		(static_cast<PinItem*>(m_eventInfo.qcanvasItemClickedOn))->switchState();
+	
+	p_itemDocument->requestStateSave();
+	return true;
+}
+
+
+//BEGIN class CanvasEllipseDraw
+CanvasEllipseDraw::CanvasEllipseDraw( int x, int y, QCanvas * canvas )
+	: QCanvasEllipse( 0, 0, canvas )
+{
+	move( x, y );
+}
+
+
+void CanvasEllipseDraw::drawShape( QPainter & p )
+{
+	p.drawEllipse( int(x()-width()/2), int(y()-height()/2), width(), height() );
+}
+//END class CanvasEllipseDraw
+
+
+
+//BEGIN class CMDraw
+CMDraw::CMDraw( ItemDocument *itemDocument, CMManager *cmManager )
+	: CanvasManipulator( itemDocument, cmManager )
+{
+	m_pDrawLine = 0l;
+	m_pDrawRectangle = 0l;
+	m_pDrawEllipse = 0l;
+}
+CMDraw::~CMDraw()
+{
+	p_cmManager->setDrawAction(-1);
+}
+CanvasManipulator* CMDraw::construct( ItemDocument *itemDocument, CMManager *cmManager )
+{
+	return new CMDraw(itemDocument,cmManager);
+}
+ManipulatorInfo *CMDraw::manipulatorInfo()
+{
+	ManipulatorInfo *eventInfo = new ManipulatorInfo();
+	eventInfo->m_acceptManipulationPtr = CMDraw::acceptManipulation;
+	eventInfo->m_createManipulatorPtr = CMDraw::construct;
+	return eventInfo;
+}
+bool CMDraw::acceptManipulation( uint /*eventState*/, uint cmState, uint /*itemType*/, uint /*cnItemType*/ )
+{
+	return (cmState & CMManager::cms_draw);
+}
+
+
+bool CMDraw::mousePressedInitial( const EventInfo &eventInfo )
+{
+	m_eventInfo = eventInfo;
+	
+	switch ( (DrawPart::DrawAction) p_cmManager->drawAction() )
+	{
+		case DrawPart::da_text:
+		case DrawPart::da_rectangle:
+		{
+			m_pDrawRectangle = new QCanvasRectangle( eventInfo.pos.x(), eventInfo.pos.y(), 0, 0, p_canvas );
+			m_pDrawRectangle->setPen( QPen( QColor(0,0,0), 1 ) );
+			m_pDrawRectangle->setZ( ICNDocument::Z::Select );
+			m_pDrawRectangle->show();
+			break;
+		}
+		case DrawPart::da_ellipse:
+		{
+			m_pDrawEllipse = new CanvasEllipseDraw( eventInfo.pos.x(), eventInfo.pos.y(), p_canvas );
+			m_pDrawEllipse->setPen( QPen( QColor(0,0,0), 1 ) );
+			m_pDrawEllipse->setZ( ICNDocument::Z::Select );
+			m_pDrawEllipse->show();
+			break;
+		}
+		case DrawPart::da_line:
+		case DrawPart::da_arrow:
+		{
+			m_pDrawLine = new QCanvasLine(p_canvas);
+			m_pDrawLine->setPoints( eventInfo.pos.x(), eventInfo.pos.y(), eventInfo.pos.x(), eventInfo.pos.y() );
+			m_pDrawLine->setPen( QPen( QColor(0,0,0), 1 ) );
+			m_pDrawLine->setZ( ICNDocument::Z::Select );
+			m_pDrawLine->show();
+			break;
+		}
+		default:
+			return true;
+	}
+	
+	return false;
+}
+
+
+bool CMDraw::mouseMoved( const EventInfo &eventInfo )
+{
+	const QPoint pos = eventInfo.pos;
+	
+	if (m_pDrawRectangle)
+		m_pDrawRectangle->setSize( pos.x()-m_eventInfo.pos.x(), pos.y()-m_eventInfo.pos.y() );
+	
+	else if (m_pDrawEllipse)
+	{
+// 		QRect r( m_eventInfo.pos.x(), m_eventInfo.pos.y(), pos.x()-m_eventInfo.pos.x(), pos.y()-m_eventInfo.pos.y() );
+// 		r = r.normalize();
+// 		
+// 		m_pDrawEllipse->setSize( r.width(), r.height() );
+// 		m_pDrawEllipse->move( r.left()+(r.width()/2), r.top()+(r.height()/2) );
+		
+		m_pDrawEllipse->setSize( 2*QABS(pos.x()-m_eventInfo.pos.x()), 2*QABS(pos.y()-m_eventInfo.pos.y()) );
+	}
+	
+	else if (m_pDrawLine)
+		m_pDrawLine->setPoints( eventInfo.pos.x(), eventInfo.pos.y(), m_pDrawLine->endPoint().x(), m_pDrawLine->endPoint().y() );
+	
+	else
+		return true;
+	
+	return false;
+}
+
+
+bool CMDraw::mouseReleased( const EventInfo &eventInfo )
+{
+	const QPoint pos = eventInfo.pos;
+	
+	QRect sizeRect;
+	
+	if ( m_pDrawRectangle || m_pDrawEllipse )
+	{
+		if (m_pDrawRectangle)
+		{
+			sizeRect = m_pDrawRectangle->rect();
+			
+			// We have to manually adjust the size rect so that it matches up with what the user has drawn
+			
+			sizeRect.setWidth( sizeRect.width()+1 );
+			sizeRect.setHeight( sizeRect.height()+1 );
+			
+			sizeRect = sizeRect.normalize();
+			
+			if ( m_pDrawRectangle->rect().width() < 0 )
+				sizeRect.moveLeft( sizeRect.left() + 1);
+			
+			if ( m_pDrawRectangle->rect().height() < 0 )
+				sizeRect.moveTop( sizeRect.top() + 1);
+		}
+		else
+		{
+			int w = m_pDrawEllipse->width()+1;
+			int h = m_pDrawEllipse->height()+1;
+			int x = int(m_pDrawEllipse->x()-w/2);
+			int y = int(m_pDrawEllipse->y()-h/2);
+			sizeRect = QRect( x, y, w, h ).normalize();
+		}
+	
+		delete m_pDrawRectangle;
+		delete m_pDrawEllipse;
+		m_pDrawRectangle = 0l;
+		m_pDrawEllipse = 0l;
+	}
+	else if (m_pDrawLine)
+	{
+		int sx = m_pDrawLine->startPoint().x();
+		int sy = m_pDrawLine->startPoint().y();
+		int ex = m_pDrawLine->endPoint().x();
+		int ey = m_pDrawLine->endPoint().y();
+		
+		sizeRect = QRect( ex, ey, sx-ex, sy-ey );
+		
+		delete m_pDrawLine;
+		m_pDrawLine = 0l;
+	}
+	else
+		return true;
+	
+	QString id;
+	switch ( (DrawPart::DrawAction) p_cmManager->drawAction() )
+	{
+		case DrawPart::da_rectangle:
+			id = "dp/rectangle";
+			break;
+			
+		case DrawPart::da_ellipse:
+			id = "dp/ellipse";
+			break;
+			
+		case DrawPart::da_text:
+			id = "dp/canvas_text";
+			
+			if ( sizeRect.width() < 56 )
+				sizeRect.setWidth( 56 );
+			
+			if ( sizeRect.height() < 24 )
+				sizeRect.setHeight( 24 );
+			
+			break;
+			
+		case DrawPart::da_line:
+			id = "dp/line";
+			break;
+			
+		case DrawPart::da_arrow:
+			id = "dp/arrow";
+			break;
+	}
+	if ( id.isEmpty() )
+		return true;
+	
+	Item * item = p_itemDocument->addItem( id, sizeRect.topLeft(), true );
+	if (!item)
+		return true;
+	item->move( sizeRect.x(), sizeRect.y() ); // We call this again as p_itemDocument->addItem will move the item if it is slightly off the canvas.
+	
+	item->setSize( 0, 0, sizeRect.width(), sizeRect.height() );
+	
+	p_itemDocument->requestStateSave();
+	return true;
+}
+//END class CMDraw
+
+
+
+//BEGIN class ManualConnectorDraw
+ManualConnectorDraw::ManualConnectorDraw( ICNDocument *_icnDocument, const QPoint &initialPos )
+{
+	m_color = Qt::black;
+	
+	icnDocument = _icnDocument;
+	m_currentPos = m_previousPos = m_initialPos = initialPos;
+	p_initialItem = icnDocument->itemAtTop(initialPos);
+	
+	b_currentVertical = false;
+	b_orientationDefined = false;
+	
+	m_connectorLines.append( m_previousCon = new QCanvasLine( icnDocument->canvas() ) );
+	m_connectorLines.append( m_currentCon = new QCanvasLine( icnDocument->canvas() ) );
+	
+	m_currentCon->setPoints( initialPos.x(), initialPos.y(), initialPos.x(), initialPos.y() );
+	m_previousCon->setPoints( initialPos.x(), initialPos.y(), initialPos.x(), initialPos.y() );
+	
+	m_currentCon->setPen( m_color );
+	m_previousCon->setPen( m_color );
+	
+	updateConnectorEnds();
+	
+	m_currentCon->show();
+	m_previousCon->show();
+}
+
+
+ManualConnectorDraw::~ManualConnectorDraw()
+{
+	const QValueList<QCanvasLine*>::iterator end = m_connectorLines.end();
+	for ( QValueList<QCanvasLine*>::iterator it = m_connectorLines.begin(); it != end; ++it )
+		delete *it;
+	
+	m_connectorLines.clear();
+}
+
+
+void ManualConnectorDraw::setColor( const QColor & color )
+{
+	m_color = color;
+	
+	const QValueList<QCanvasLine*>::iterator end = m_connectorLines.end();
+	for ( QValueList<QCanvasLine*>::iterator it = m_connectorLines.begin(); it != end; ++it )
+		(*it)->setPen( m_color );
+}
+
+
+void ManualConnectorDraw::mouseMoved( const QPoint &pos )
+{
+	if ( m_currentPos == pos ) return;
+	
+	if (!b_orientationDefined)
+	{
+		QPoint previousStart = m_previousCon->startPoint();
+		
+		double distance = std::sqrt( std::pow( (double)(m_currentPos.x()-previousStart.x()), 2. ) +
+									 std::pow( (double)(m_currentPos.y()-previousStart.y()), 2. ) );
+	
+		if ( distance < 24 )
+		{
+			b_currentVertical = ( std::abs( double(m_currentPos.x()-previousStart.x()) ) >= std::abs( double(m_currentPos.y()-previousStart.y()) ) );
+		}
+		
+	}
+	
+	m_previousPos = m_currentPos;
+	m_currentPos = pos;
+	updateConnectorEnds();
+}
+
+
+QCanvasItem* ManualConnectorDraw::mouseClicked( const QPoint &pos )
+{
+	if (b_orientationDefined)
+		b_currentVertical = !b_currentVertical;
+	
+	else
+		mouseMoved(pos);
+	
+	b_orientationDefined = true;
+
+	m_currentPos = pos;
+	
+	QCanvasItem * qcanvasItem = icnDocument->itemAtTop(pos);
+	
+	if ( qcanvasItem && pos != m_initialPos && qcanvasItem != p_initialItem )
+		return qcanvasItem;
+	
+	m_previousCon = m_currentCon;
+	
+	m_connectorLines.append( m_currentCon = new QCanvasLine( icnDocument->canvas() ) );
+	m_currentCon->setPoints( pos.x(), pos.y(), pos.x(), pos.y() );
+	m_currentCon->setPen( m_color );
+	updateConnectorEnds();
+	m_currentCon->show();
+	
+	return 0L;
+}
+
+
+void ManualConnectorDraw::updateConnectorEnds()
+{
+	QPoint pivot = m_currentPos;
+	QPoint previousStart = m_previousCon->startPoint();
+	
+	if (b_currentVertical)
+	{
+		pivot.setY( previousStart.y() );
+		m_currentCon->setPoints( pivot.x(), pivot.y(), pivot.x(), m_currentPos.y() );
+	}
+	else
+	{
+		pivot.setX( previousStart.x() );
+		m_currentCon->setPoints( pivot.x(), pivot.y(), m_currentPos.x(), pivot.y() );
+	}
+	
+	m_previousCon->setPoints( previousStart.x(), previousStart.y(), pivot.x(), pivot.y() );
+}
+
+
+QPointList ManualConnectorDraw::pointList()
+{
+	QPointList list;
+	list.append(m_initialPos);
+	
+	const QValueList<QCanvasLine*>::iterator end = m_connectorLines.end();
+	for ( QValueList<QCanvasLine*>::iterator it = m_connectorLines.begin(); it != end; ++it )
+	{
+		list.append( (*it)->endPoint() );
+	}
+	
+	return list;
+}
+//END class ManualConnectorDraw
+
+
+//BEGIN class ManipulatorInfo
+ManipulatorInfo::ManipulatorInfo()
+{
+}
+//END class ManipulatorInfo
+
+
+#include "canvasmanipulator.moc"