You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1386 lines
38 KiB
1386 lines
38 KiB
/***************************************************************************
|
|
* Copyright (C) 2005 by David Saxton *
|
|
* david@bluehaze.org *
|
|
* *
|
|
* This program is free software; you can redistribute it and/or modify *
|
|
* it under the terms of the GNU General Public License as published by *
|
|
* the Free Software Foundation; either version 2 of the License, or *
|
|
* (at your option) any later version. *
|
|
***************************************************************************/
|
|
|
|
#include "canvasmanipulator.h"
|
|
#include "component.h"
|
|
#include "connector.h"
|
|
#include "conrouter.h"
|
|
#include "cnitemgroup.h"
|
|
#include "ecnode.h"
|
|
#include "flowcontainer.h"
|
|
#include "fpnode.h"
|
|
#include "icndocument.h"
|
|
#include "icnview.h"
|
|
#include "itemdocumentdata.h"
|
|
#include "itemlibrary.h"
|
|
#include "ktechlab.h"
|
|
#include "nodegroup.h"
|
|
|
|
#include <tdeapplication.h>
|
|
#include <kdebug.h>
|
|
#include <tqclipboard.h>
|
|
#include <tqtimer.h>
|
|
|
|
ICNDocument::ICNDocument( const TQString &caption, KTechlab *ktechlab, const char *name )
|
|
: ItemDocument( caption, ktechlab, name ),
|
|
m_cells(0l)
|
|
{
|
|
m_canvas->retune(48);
|
|
m_selectList = new CNItemGroup(this);
|
|
|
|
createCellMap();
|
|
|
|
m_cmManager->addManipulatorInfo( CMItemMove::manipulatorInfo() );
|
|
m_cmManager->addManipulatorInfo( CMAutoConnector::manipulatorInfo() );
|
|
m_cmManager->addManipulatorInfo( CMManualConnector::manipulatorInfo() );
|
|
}
|
|
|
|
|
|
ICNDocument::~ICNDocument()
|
|
{
|
|
m_bDeleted = true;
|
|
|
|
// Go to hell, TQCanvas. I'm in charge of what gets deleted.
|
|
TQCanvasItemList all = m_canvas->allItems();
|
|
const TQCanvasItemList::Iterator end = all.end();
|
|
for ( TQCanvasItemList::Iterator it= all.begin(); it != end; ++it )
|
|
(*it)->setCanvas(0l);
|
|
|
|
// Remove all items from the canvas
|
|
selectAll();
|
|
deleteSelection();
|
|
|
|
// Delete anything that got through the above couple of lines
|
|
ConnectorList connectorsToDelete = m_connectorList;
|
|
const ConnectorList::iterator connectorListEnd = connectorsToDelete.end();
|
|
for ( ConnectorList::iterator it = connectorsToDelete.begin(); it != connectorListEnd; ++it )
|
|
delete *it;
|
|
|
|
NodeList nodesToDelete = m_nodeList;
|
|
const NodeList::iterator nodeListEnd = nodesToDelete.end();
|
|
for ( NodeList::iterator it = nodesToDelete.begin(); it != nodeListEnd; ++it )
|
|
delete *it;
|
|
|
|
GuardedNodeGroupList ngToDelete = m_nodeGroupList;
|
|
const GuardedNodeGroupList::iterator nglEnd = ngToDelete.end();
|
|
for ( GuardedNodeGroupList::iterator it = ngToDelete.begin(); it != nglEnd; ++it )
|
|
delete *it;
|
|
|
|
delete m_cells;
|
|
m_cells = 0l;
|
|
delete m_selectList;
|
|
m_selectList = 0l;
|
|
}
|
|
|
|
|
|
View *ICNDocument::createView( ViewContainer *viewContainer, uint viewAreaId, const char *name )
|
|
{
|
|
ICNView *icnView = new ICNView( this, viewContainer, viewAreaId, name );
|
|
handleNewView(icnView);
|
|
return icnView;
|
|
}
|
|
|
|
|
|
ItemGroup* ICNDocument::selectList() const
|
|
{
|
|
return m_selectList;
|
|
}
|
|
|
|
|
|
void ICNDocument::fillContextMenu( const TQPoint &pos )
|
|
{
|
|
ItemDocument::fillContextMenu(pos);
|
|
slotInitItemActions( dynamic_cast<CNItem*>(m_selectList->activeItem()) );
|
|
}
|
|
|
|
|
|
CNItem* ICNDocument::cnItemWithID( const TQString &id )
|
|
{
|
|
return dynamic_cast<CNItem*>(itemWithID(id));
|
|
}
|
|
|
|
|
|
Node *ICNDocument::nodeWithID( const TQString &id )
|
|
{
|
|
const NodeList::iterator end = m_nodeList.end();
|
|
for ( NodeList::iterator it = m_nodeList.begin(); it != end; ++it )
|
|
{
|
|
if ( (*it)->id() == id )
|
|
return *it;
|
|
}
|
|
return 0L;
|
|
}
|
|
|
|
|
|
Connector *ICNDocument::connectorWithID( const TQString &id )
|
|
{
|
|
const ConnectorList::iterator end = m_connectorList.end();
|
|
for ( ConnectorList::iterator it = m_connectorList.begin(); it != end; ++it )
|
|
{
|
|
if ( (*it)->id() == id )
|
|
return *it;
|
|
}
|
|
return 0L;
|
|
}
|
|
|
|
|
|
FlowContainer *ICNDocument::flowContainer( const TQPoint &pos )
|
|
{
|
|
TQCanvasItemList collisions = m_canvas->collisions(pos);
|
|
FlowContainer *flowContainer = 0l;
|
|
int currentLevel = -1;
|
|
const TQCanvasItemList::iterator end = collisions.end();
|
|
for ( TQCanvasItemList::iterator it = collisions.begin(); it != end; ++it )
|
|
{
|
|
if ( FlowContainer *container = dynamic_cast<FlowContainer*>(*it) )
|
|
{
|
|
if ( container->level() > currentLevel && !m_selectList->contains(container) )
|
|
{
|
|
currentLevel = container->level();
|
|
flowContainer = container;
|
|
}
|
|
}
|
|
}
|
|
return flowContainer;
|
|
}
|
|
|
|
|
|
bool ICNDocument::canConnect( TQCanvasItem *qcanvasItem1, TQCanvasItem *qcanvasItem2 ) const
|
|
{
|
|
// Rough outline of what can and can't connect:
|
|
// * At most three connectors to a node
|
|
// * Can't have connectors going between different levels (e.g. can't have
|
|
// a connector coming outside a FlowContainer from inside).
|
|
// * Can't have more than one route between any two nodes
|
|
// * In all connections between nodes, must have at least one input and one
|
|
// output node at the ends.
|
|
|
|
Node *startNode = dynamic_cast<Node*>(qcanvasItem1);
|
|
Node *endNode = dynamic_cast<Node*>(qcanvasItem2);
|
|
|
|
if ( (startNode && startNode->numCon( true, false ) > 2) || (endNode && endNode->numCon( true, false ) > 2) )
|
|
return false;
|
|
|
|
|
|
Connector *startConnector = dynamic_cast<Connector*>(qcanvasItem1);
|
|
Connector *endConnector = dynamic_cast<Connector*>(qcanvasItem2);
|
|
|
|
// Can't have T- or I- junction in PinMapEditor document
|
|
if ( type() == Document::dt_pinMapEditor && (startConnector || endConnector) )
|
|
return false;
|
|
|
|
// Can't have I-junction in flowcode document
|
|
if ( type() == Document::dt_flowcode && startConnector && endConnector )
|
|
return false;
|
|
|
|
|
|
//BEGIN Change connectors to nodes
|
|
Node * startNode1 = 0l;
|
|
Node * startNode2 = 0l;
|
|
if (startConnector)
|
|
{
|
|
startNode1 = startConnector->startNode();
|
|
startNode2 = startConnector->endNode();
|
|
|
|
if ( !startNode1 || !startNode2 )
|
|
return false;
|
|
}
|
|
else if (!startNode)
|
|
return false;
|
|
|
|
Node * endNode1 = 0l;
|
|
Node * endNode2 = 0l;
|
|
if (endConnector)
|
|
{
|
|
endNode1 = endConnector->startNode();
|
|
endNode2 = endConnector->endNode();
|
|
|
|
if ( !endNode1 || !endNode2 )
|
|
return false;
|
|
}
|
|
else if ( !endNode )
|
|
return false;
|
|
|
|
Node * start[3];
|
|
start[0] = startNode;
|
|
start[1] = startNode1;
|
|
start[2] = startNode2;
|
|
|
|
Node * end[3];
|
|
end[0] = endNode;
|
|
end[1] = endNode1;
|
|
end[2] = endNode2;
|
|
//END Change connectors to nodes
|
|
|
|
|
|
//BEGIN Check nodes aren't already connected
|
|
for ( unsigned i = 0; i < 3; i++ )
|
|
{
|
|
for ( unsigned j = 0; j < 3; j++ )
|
|
{
|
|
if ( start[i] && end[j] && start[i]->isConnected(end[j]) )
|
|
return false;
|
|
}
|
|
}
|
|
//END Check nodes aren't already connected together
|
|
|
|
|
|
//BEGIN Check we have appropriate input and output allowance
|
|
if ( type() == Document::dt_flowcode )
|
|
{
|
|
if ( startNode1 && startNode2 && endNode1 && endNode2 )
|
|
{
|
|
// Can't have I-configuration
|
|
return false;
|
|
}
|
|
|
|
if ( startNode && endNode )
|
|
{
|
|
// Nice and easy straight line to check
|
|
|
|
if ( !startNode->acceptInput() && !endNode->acceptInput() )
|
|
return false;
|
|
|
|
if ( !startNode->acceptOutput() && !endNode->acceptOutput() )
|
|
return false;
|
|
}
|
|
|
|
else
|
|
{
|
|
// We're in a T-configuration, we can only make this if the base of
|
|
// the T is an output
|
|
Node * base = startNode ? startNode : endNode;
|
|
if ( !base->acceptOutput() )
|
|
return false;
|
|
}
|
|
}
|
|
//END Check we have appropriate input and output allowance
|
|
|
|
|
|
//BEGIN Simple level check
|
|
for ( unsigned i = 0; i < 3; i++ )
|
|
{
|
|
for ( unsigned j = 0; j < 3; j++ )
|
|
{
|
|
if ( start[i] && end[j] && start[i]->level() != end[j]->level() )
|
|
return false;
|
|
}
|
|
}
|
|
//END Simple level check
|
|
|
|
|
|
//BEGIN Advanced level check
|
|
CNItem * startParentItem[3];
|
|
for ( unsigned i = 0; i < 3; i++ )
|
|
startParentItem[i] = start[i] ? start[i]->parentItem() : 0l;
|
|
|
|
CNItem * endParentItem[3];
|
|
for ( unsigned i = 0; i < 3; i++ )
|
|
endParentItem[i] = end[i] ? end[i]->parentItem() : 0l;
|
|
|
|
Item * container[6] = {0l};
|
|
|
|
for ( unsigned i = 0; i < 3; i++ )
|
|
{
|
|
if (startParentItem[i])
|
|
{
|
|
int dl = start[i]->level() - startParentItem[i]->level();
|
|
if ( dl == 0 )
|
|
container[i] = startParentItem[i]->parentItem();
|
|
else if ( dl == 1 )
|
|
container[i] = startParentItem[i];
|
|
else
|
|
kdError() << k_funcinfo << " start, i="<<i<<" dl="<<dl<<endl;
|
|
}
|
|
if (endParentItem[i])
|
|
{
|
|
int dl = end[i]->level() - endParentItem[i]->level();
|
|
if ( dl == 0 )
|
|
container[i+3] = endParentItem[i]->parentItem();
|
|
else if ( dl == 1 )
|
|
container[i+3] = endParentItem[i];
|
|
else
|
|
kdError() << k_funcinfo << " end, i="<<i<<" dl="<<dl<<endl;
|
|
}
|
|
}
|
|
|
|
// Everything better well have the same container...
|
|
for ( unsigned i = 0; i < 6; ++i )
|
|
{
|
|
for ( unsigned j = 0; j < i; ++j )
|
|
{
|
|
Node * n1 = i < 3 ? start[i] : end[i-3];
|
|
Node * n2 = j < 3 ? start[j] : end[j-3];
|
|
if ( n1 && n2 && (container[i] != container[j]) )
|
|
return false;
|
|
}
|
|
}
|
|
//END Advanced level check
|
|
|
|
|
|
// Well, it looks like we can, afterall, connect them...
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
Connector * ICNDocument::createConnector( Node *startNode, Node *endNode, TQPointList *pointList )
|
|
{
|
|
if ( !canConnect( startNode, endNode ) )
|
|
return 0l;
|
|
|
|
TQPointList autoPoints;
|
|
if (!pointList)
|
|
{
|
|
addAllItemConnectorPoints();
|
|
ConRouter cr(this);
|
|
cr.mapRoute( int(startNode->x()), int(startNode->y()), int(endNode->x()), int(endNode->y()) );
|
|
autoPoints = cr.pointList(false);
|
|
pointList = &autoPoints;
|
|
}
|
|
|
|
Connector * con = 0l;
|
|
|
|
// Check if we need to swap the ends around, and create the connector
|
|
if ( endNode->type() == Node::fp_out )
|
|
con = createConnector( endNode->id(), startNode->id(), pointList );
|
|
else
|
|
con = createConnector( startNode->id(), endNode->id(), pointList );
|
|
|
|
bool startInGroup = deleteNodeGroup(startNode);
|
|
bool endInGroup = deleteNodeGroup(endNode);
|
|
if ( startInGroup || endInGroup )
|
|
{
|
|
NodeGroup *ng = createNodeGroup(startNode);
|
|
ng->addNode( endNode, true );
|
|
ng->init();
|
|
}
|
|
|
|
flushDeleteList();
|
|
return con;
|
|
}
|
|
|
|
Connector * ICNDocument::createConnector( Node *node, Connector *con, const TQPoint &pos2, TQPointList *pointList )
|
|
{
|
|
if ( !canConnect( node, con ) )
|
|
return 0l;
|
|
|
|
Node *conStartNode = con->startNode();
|
|
Node *conEndNode = con->endNode();
|
|
|
|
const bool usedManual = con->usesManualPoints();
|
|
|
|
Node *newNode = 0l;
|
|
if ( type() == Document::dt_circuit )
|
|
newNode = new ECNode( this, Node::ec_junction, Node::dir_right, pos2 );
|
|
|
|
else if ( type() == Document::dt_flowcode )
|
|
newNode = new FPNode( this, Node::fp_junction, Node::dir_right, pos2 );
|
|
|
|
else
|
|
return 0l;
|
|
|
|
TQPointList autoPoints;
|
|
if (!pointList)
|
|
{
|
|
addAllItemConnectorPoints();
|
|
ConRouter cr(this);
|
|
cr.mapRoute( int(node->x()), int(node->y()), pos2.x(), pos2.y() );
|
|
autoPoints = cr.pointList(false);
|
|
pointList = &autoPoints;
|
|
}
|
|
|
|
TQValueList<TQPointList> oldConPoints = con->splitConnectorPoints(pos2);
|
|
con->hide();
|
|
|
|
// The actual new connector
|
|
Connector *new1 = newNode->createInputConnector(node);
|
|
node->addOutputConnector(new1);
|
|
new1->setRoutePoints(*pointList,usedManual);
|
|
|
|
// The two connectors formed from the original one when split
|
|
Connector *new2 = newNode->createInputConnector(conStartNode);
|
|
conStartNode->addOutputConnector(new2);
|
|
new2->setRoutePoints( *oldConPoints.at(0), usedManual );
|
|
|
|
Connector *new3 = conEndNode->createInputConnector(newNode);
|
|
newNode->addOutputConnector(new3);
|
|
new3->setRoutePoints( *oldConPoints.at(1), usedManual );
|
|
|
|
// Avoid flicker: tell them to update their draw lists now
|
|
con->updateConnectorPoints(false);
|
|
new1->updateDrawList();
|
|
new2->updateDrawList();
|
|
new3->updateDrawList();
|
|
|
|
// Now it's safe to remove the connector...
|
|
con->removeConnector();
|
|
flushDeleteList();
|
|
|
|
deleteNodeGroup(conStartNode);
|
|
deleteNodeGroup(conEndNode);
|
|
createNodeGroup(newNode)->init();
|
|
|
|
return new1;
|
|
}
|
|
|
|
Connector * ICNDocument::createConnector( Connector *con1, Connector *con2, const TQPoint &pos1, const TQPoint &pos2, TQPointList *pointList )
|
|
{
|
|
if ( !canConnect( con1, con2 ) )
|
|
return 0l;
|
|
|
|
const bool con1UsedManual = con1->usesManualPoints();
|
|
const bool con2UsedManual = con2->usesManualPoints();
|
|
|
|
TQValueList<TQPointList> oldCon1Points = con1->splitConnectorPoints(pos1);
|
|
TQValueList<TQPointList> oldCon2Points = con2->splitConnectorPoints(pos2);
|
|
|
|
Node *node1a = con1->startNode();
|
|
Node *node1b = con1->endNode();
|
|
|
|
Node *node2a = con2->startNode();
|
|
Node *node2b = con2->endNode();
|
|
|
|
if ( !node1a || !node1b || !node2a || !node2b )
|
|
return 0l;
|
|
|
|
con1->hide();
|
|
con2->hide();
|
|
|
|
if ( type() != Document::dt_circuit )
|
|
return 0l;
|
|
|
|
ECNode * newNode1 = new ECNode( this, Node::ec_junction, Node::dir_right, pos1 );
|
|
ECNode * newNode2 = new ECNode( this, Node::ec_junction, Node::dir_right, pos2 );
|
|
|
|
Connector *con1a = newNode1->createInputConnector(node1a);
|
|
node1a->addOutputConnector(con1a);
|
|
Connector *con1b = newNode1->createInputConnector(node1b);
|
|
node1b->addOutputConnector(con1b);
|
|
|
|
Connector *newCon = newNode1->createInputConnector(newNode2);
|
|
newNode2->addOutputConnector(newCon);
|
|
|
|
Connector *con2a = node2a->createInputConnector(newNode2);
|
|
newNode2->addOutputConnector(con2a);
|
|
Connector *con2b = node2b->createInputConnector(newNode2);
|
|
newNode2->addOutputConnector(con2b);
|
|
|
|
if ( !con1a || !con1b || !con2a || !con2b )
|
|
{
|
|
// This should never happen, as the canConnect function should strictly
|
|
// determine whether the connectors could be created before hand.
|
|
kdWarning() << k_funcinfo << "Not all the connectors were created, this should never happen" << endl;
|
|
|
|
if (con1a)
|
|
con1a->removeConnector();
|
|
|
|
if (con1b)
|
|
con1b->removeConnector();
|
|
|
|
if (con2a)
|
|
con2a->removeConnector();
|
|
|
|
if (con2b)
|
|
con2b->removeConnector();
|
|
|
|
newNode1->removeNode();
|
|
newNode2->removeNode();
|
|
|
|
flushDeleteList();
|
|
return 0l;
|
|
}
|
|
|
|
con1a->setRoutePoints( *oldCon1Points.at(0), con1UsedManual );
|
|
con1b->setRoutePoints( *oldCon1Points.at(1), con1UsedManual );
|
|
|
|
con2a->setRoutePoints( *oldCon2Points.at(0), con2UsedManual );
|
|
con2b->setRoutePoints( *oldCon2Points.at(1), con2UsedManual );
|
|
|
|
TQPointList autoPoints;
|
|
if (!pointList)
|
|
{
|
|
addAllItemConnectorPoints();
|
|
ConRouter cr(this);
|
|
cr.mapRoute( pos1.x(), pos1.y(), pos2.x(), pos2.y() );
|
|
autoPoints = cr.pointList(false);
|
|
pointList = &autoPoints;
|
|
}
|
|
newCon->setRoutePoints(*pointList,true);
|
|
|
|
|
|
// Avoid flicker: tell them to update their draw lists now
|
|
con1->updateConnectorPoints(false);
|
|
con2->updateConnectorPoints(false);
|
|
newCon->updateDrawList();
|
|
con1a->updateDrawList();
|
|
con1b->updateDrawList();
|
|
con2a->updateDrawList();
|
|
con2b->updateDrawList();
|
|
|
|
|
|
// Now it's safe to remove the connectors
|
|
con1->removeConnector();
|
|
con2->removeConnector();
|
|
|
|
flushDeleteList();
|
|
|
|
deleteNodeGroup(node1a);
|
|
deleteNodeGroup(node1b);
|
|
deleteNodeGroup(node2a);
|
|
deleteNodeGroup(node2b);
|
|
NodeGroup *ng = createNodeGroup(newNode1);
|
|
ng->addNode( newNode2, true );
|
|
ng->init();
|
|
|
|
return newCon;
|
|
}
|
|
|
|
|
|
NodeGroup* ICNDocument::createNodeGroup( Node *node )
|
|
{
|
|
if ( !node || node->isChildNode() ) {
|
|
return 0l;
|
|
}
|
|
|
|
const GuardedNodeGroupList::iterator end = m_nodeGroupList.end();
|
|
for ( GuardedNodeGroupList::iterator it = m_nodeGroupList.begin(); it != end; ++it )
|
|
{
|
|
if ( *it && (*it)->contains(node) ) {
|
|
return *it;
|
|
}
|
|
}
|
|
|
|
NodeGroup *group = new NodeGroup(this);
|
|
m_nodeGroupList += group;
|
|
group->addNode( node, true );
|
|
|
|
return group;
|
|
}
|
|
|
|
|
|
bool ICNDocument::deleteNodeGroup( Node *node )
|
|
{
|
|
if ( !node || node->isChildNode() ) {
|
|
return false;
|
|
}
|
|
|
|
const GuardedNodeGroupList::iterator end = m_nodeGroupList.end();
|
|
for ( GuardedNodeGroupList::iterator it = m_nodeGroupList.begin(); it != end; ++it )
|
|
{
|
|
if ( *it && (*it)->contains(node) )
|
|
{
|
|
delete *it;
|
|
m_nodeGroupList.remove(it);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
void ICNDocument::slotRequestAssignNG()
|
|
{
|
|
requestEvent( ItemDocumentEvent::UpdateNodeGroups );
|
|
}
|
|
|
|
|
|
void ICNDocument::slotAssignNodeGroups()
|
|
{
|
|
const GuardedNodeGroupList::iterator nglEnd = m_nodeGroupList.end();
|
|
for ( GuardedNodeGroupList::iterator it = m_nodeGroupList.begin(); it != nglEnd; ++it )
|
|
delete *it;
|
|
m_nodeGroupList.clear();
|
|
|
|
const NodeList::iterator end = m_nodeList.end();
|
|
for ( NodeList::iterator it = m_nodeList.begin(); it != end; ++it )
|
|
{
|
|
NodeGroup *ng = createNodeGroup(*it);
|
|
if (ng)
|
|
ng->init();
|
|
}
|
|
|
|
// We've destroyed the old node groups, so any collapsed flowcontainers
|
|
// containing new node groups need to update them to make them invisible.
|
|
const ItemList::const_iterator itemListEnd = m_itemList.end();
|
|
for ( ItemList::const_iterator it = m_itemList.begin(); it != itemListEnd; ++it )
|
|
{
|
|
if ( FlowContainer * fc = dynamic_cast<FlowContainer*>((Item*)*it) )
|
|
fc->updateContainedVisibility();
|
|
}
|
|
}
|
|
|
|
|
|
void ICNDocument::getTranslatable( const ItemList & itemList, ConnectorList * fixedConnectors, ConnectorList * translatableConnectors, NodeGroupList * translatableNodeGroups )
|
|
{
|
|
ConnectorList tempCL1;
|
|
if ( !fixedConnectors )
|
|
fixedConnectors = &tempCL1;
|
|
|
|
ConnectorList tempCL2;
|
|
if ( !translatableConnectors )
|
|
translatableConnectors = &tempCL2;
|
|
|
|
NodeGroupList tempNGL;
|
|
if ( !translatableNodeGroups )
|
|
translatableNodeGroups = &tempNGL;
|
|
|
|
// We record the connectors attached to the items, and
|
|
// the number of times an item in the list is connected to
|
|
// it - i.e. 1 or 2. For those with 2, it is safe to update their
|
|
// route as it simply involves shifting the route
|
|
typedef TQMap< Connector*, int > ConnectorMap;
|
|
ConnectorMap fixedConnectorMap;
|
|
|
|
// This list of nodes is built up, used for later in determining fixed NodeGroups
|
|
NodeList itemNodeList;
|
|
{
|
|
const ItemList::const_iterator itemListEnd = itemList.end();
|
|
for ( ItemList::const_iterator it = itemList.begin(); it != itemListEnd; ++it )
|
|
{
|
|
CNItem *cnItem = dynamic_cast<CNItem*>((Item*)*it);
|
|
if ( !cnItem || !cnItem->canvas() )
|
|
continue;
|
|
|
|
NodeMap nodeMap = cnItem->nodeMap();
|
|
const NodeMap::iterator nlEnd = nodeMap.end();
|
|
for ( NodeMap::iterator nlIt = nodeMap.begin(); nlIt != nlEnd; ++nlIt )
|
|
{
|
|
itemNodeList.append(nlIt.data().node);
|
|
}
|
|
|
|
ConnectorList conList = cnItem->connectorList();
|
|
conList.remove((Connector*)0l);
|
|
const ConnectorList::iterator clEnd = conList.end();
|
|
for ( ConnectorList::iterator clit = conList.begin(); clit != clEnd; ++clit )
|
|
{
|
|
ConnectorMap::iterator cit = fixedConnectorMap.find(*clit);
|
|
if ( cit != fixedConnectorMap.end() ) {
|
|
cit.data()++;
|
|
} else {
|
|
fixedConnectorMap[*clit] = 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// We now look through the NodeGroups to see if we have all the external
|
|
// nodes for a given nodeGroup - if so, then the connectors in the fixed
|
|
// connectors are ok to be moved
|
|
ConnectorList fixedNGConnectors;
|
|
{
|
|
translatableNodeGroups->clear();
|
|
const GuardedNodeGroupList::const_iterator end = m_nodeGroupList.end();
|
|
for ( GuardedNodeGroupList::const_iterator it = m_nodeGroupList.begin(); it != end; ++it )
|
|
{
|
|
NodeGroup *ng = *it;
|
|
if (!ng)
|
|
continue;
|
|
|
|
NodeList externalNodeList = ng->externalNodeList();
|
|
const NodeList::iterator itemNodeListEnd = itemNodeList.end();
|
|
for ( NodeList::iterator inlIt = itemNodeList.begin(); inlIt != itemNodeListEnd; ++inlIt )
|
|
externalNodeList.remove(*inlIt);
|
|
|
|
if ( externalNodeList.isEmpty() )
|
|
{
|
|
translatableNodeGroups->append(ng);
|
|
|
|
const ConnectorList ngConnectorList = ng->connectorList();
|
|
const ConnectorList::const_iterator ngConnectorListEnd = ngConnectorList.end();
|
|
for ( ConnectorList::const_iterator ngclIt = ngConnectorList.begin(); ngclIt != ngConnectorListEnd; ++ngclIt )
|
|
{
|
|
if (*ngclIt)
|
|
fixedNGConnectors += *ngclIt;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
translatableConnectors->clear();
|
|
const ConnectorMap::iterator fcEnd = fixedConnectorMap.end();
|
|
for ( ConnectorMap::iterator it = fixedConnectorMap.begin(); it != fcEnd; ++it )
|
|
{
|
|
// We allow it to be fixed if it is connected to two of the CNItems in the
|
|
// select list, or is connected to itself (hence only appears to be connected to one,
|
|
// but is fixed anyway
|
|
Node *startNode = it.key()->endNode();
|
|
Node *endNode = it.key()->startNode();
|
|
if ( (it.data() > 1) ||
|
|
(startNode && endNode && startNode->parentItem() == endNode->parentItem()) )
|
|
{
|
|
translatableConnectors->append( const_cast<Connector*>(it.key()) );
|
|
}
|
|
else if ( !fixedNGConnectors.contains(it.key()) && !fixedConnectors->contains(it.key()) )
|
|
{
|
|
fixedConnectors->append(it.key());
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void ICNDocument::addCPenalty( int x, int y, int score )
|
|
{
|
|
if ( isValidCellReference(x,y) )
|
|
{
|
|
(*m_cells)[x][y].Cpenalty += score;
|
|
}
|
|
}
|
|
|
|
|
|
void ICNDocument::createCellMap()
|
|
{
|
|
unsigned newCellsX = TQMAX( canvas()->width()/cellSize, 1 );
|
|
unsigned newCellsY = TQMAX( canvas()->height()/cellSize, 1 );
|
|
|
|
if ( m_cells && newCellsX == m_cellsX && newCellsY == m_cellsY )
|
|
return;
|
|
|
|
const ItemList::iterator ciEnd = m_itemList.end();
|
|
for ( ItemList::iterator it = m_itemList.begin(); it != ciEnd; ++it )
|
|
{
|
|
CNItem *cnItem = dynamic_cast<CNItem*>((Item*)(*it));
|
|
if (cnItem)
|
|
cnItem->updateConnectorPoints(false);
|
|
}
|
|
const ConnectorList::iterator conEnd = m_connectorList.end();
|
|
for ( ConnectorList::iterator it = m_connectorList.begin(); it != conEnd; ++it )
|
|
{
|
|
(*it)->updateConnectorPoints(false);
|
|
}
|
|
|
|
delete m_cells;
|
|
m_cellsX = newCellsX;
|
|
m_cellsY = newCellsY;
|
|
m_cells = new Cells( m_cellsX, m_cellsY );
|
|
|
|
for ( ConnectorList::iterator it = m_connectorList.begin(); it != conEnd; ++it )
|
|
(*it)->updateConnectorPoints(true);
|
|
}
|
|
|
|
|
|
int ICNDocument::gridSnap( int pos )
|
|
{
|
|
return pos-(pos%8)+4;
|
|
// return int((floor(pos/8))*8)+4;
|
|
}
|
|
|
|
TQPoint ICNDocument::gridSnap( const TQPoint &pos )
|
|
{
|
|
return TQPoint( gridSnap( pos.x() ), gridSnap( pos.y() ) );
|
|
}
|
|
|
|
|
|
void ICNDocument::appendDeleteList( TQCanvasItem *qcanvasItem )
|
|
{
|
|
if ( !qcanvasItem || m_itemDeleteList.findIndex(qcanvasItem) != -1 ) {
|
|
return;
|
|
}
|
|
|
|
m_itemDeleteList.append(qcanvasItem);
|
|
|
|
if ( qcanvasItem->rtti() == ItemDocument::RTTI::Node )
|
|
{
|
|
Node *node = dynamic_cast<Node*>(qcanvasItem);
|
|
node->removeNode();
|
|
}
|
|
else if ( qcanvasItem->rtti() == ItemDocument::RTTI::CNItem ||
|
|
qcanvasItem->rtti() == ItemDocument::RTTI::DrawPart )
|
|
{
|
|
Item *item = dynamic_cast<Item*>(qcanvasItem);
|
|
item->removeItem();
|
|
}
|
|
else if ( qcanvasItem->rtti() == ItemDocument::RTTI::Connector ||
|
|
qcanvasItem->rtti() == ItemDocument::RTTI::ConnectorLine )
|
|
{
|
|
Connector *connector = dynamic_cast<Connector*>(qcanvasItem);
|
|
if (!connector)
|
|
connector = (dynamic_cast<ConnectorLine*>(qcanvasItem))->parent();
|
|
connector->removeConnector();
|
|
}
|
|
else
|
|
{
|
|
kdDebug() << k_funcinfo << "unrecognised TQCanvasItem rtti " << TQString::number(qcanvasItem->rtti()) << endl;
|
|
}
|
|
}
|
|
|
|
void ICNDocument::flushDeleteList()
|
|
{
|
|
// Remove duplicate items in the delete list
|
|
TQCanvasItemList::iterator end = m_itemDeleteList.end();
|
|
for ( TQCanvasItemList::iterator it = m_itemDeleteList.begin(); it != end; ++it )
|
|
{
|
|
if ( *it && m_itemDeleteList.contains(*it) > 1 ) {
|
|
*it = 0l;
|
|
}
|
|
}
|
|
m_itemDeleteList.remove(0l);
|
|
|
|
end = m_itemDeleteList.end();
|
|
for ( TQCanvasItemList::iterator it = m_itemDeleteList.begin(); it != end; ++it )
|
|
{
|
|
TQCanvasItem *qcanvasItem = *it;
|
|
m_selectList->removeTQCanvasItem(*it);
|
|
|
|
if ( Item *item = dynamic_cast<Item*>(qcanvasItem) )
|
|
m_itemList.remove(item);
|
|
|
|
else if ( qcanvasItem->rtti() == ItemDocument::RTTI::Node )
|
|
m_nodeList.remove( dynamic_cast<Node*>(qcanvasItem) );
|
|
|
|
else if ( qcanvasItem->rtti() == ItemDocument::RTTI::Connector )
|
|
m_connectorList.remove( dynamic_cast<Connector*>(qcanvasItem) );
|
|
|
|
else
|
|
kdError() << k_funcinfo << "Unknown qcanvasItem! "<<qcanvasItem << endl;
|
|
|
|
qcanvasItem->setCanvas(0l);
|
|
|
|
delete qcanvasItem;
|
|
*it = 0l;
|
|
}
|
|
|
|
// // Check connectors for merging
|
|
bool doneJoin = false;
|
|
const NodeList::iterator nlEnd = m_nodeList.end();
|
|
for ( NodeList::iterator it = m_nodeList.begin(); it != nlEnd; ++it )
|
|
{
|
|
(*it)->removeNullConnectors();
|
|
int conCount = (*it)->inputConnectorList().count() + (*it)->outputConnectorList().count();
|
|
if ( conCount == 2 && !(*it)->parentItem() )
|
|
{
|
|
if ( joinConnectors(*it) )
|
|
doneJoin = true;
|
|
}
|
|
}
|
|
|
|
if (doneJoin)
|
|
flushDeleteList();
|
|
|
|
requestRerouteInvalidatedConnectors();
|
|
}
|
|
|
|
|
|
|
|
bool ICNDocument::joinConnectors( Node *node )
|
|
{
|
|
// We don't want to destroy the node if it has a parent
|
|
if ( node->parentItem() )
|
|
return false;
|
|
|
|
node->removeNullConnectors();
|
|
|
|
int conCount = node->inputConnectorList().count() + node->outputConnectorList().count();
|
|
if ( conCount != 2 )
|
|
return false;
|
|
|
|
Connector *con1, *con2;
|
|
Node *startNode, *endNode;
|
|
TQPointList conPoints;
|
|
|
|
|
|
if ( node->inputConnectorList().count() == 0 )
|
|
{
|
|
// Both connectors emerge from node - output - i.e. node is pure start node
|
|
con1 = *node->outputConnectorList().at(0);
|
|
con2 = *node->outputConnectorList().at(1);
|
|
if ( con1 == con2 ) {
|
|
return false;
|
|
}
|
|
|
|
startNode = con1->endNode();
|
|
endNode = con2->endNode();
|
|
conPoints = con1->connectorPoints(true) + con2->connectorPoints(false);
|
|
}
|
|
else if ( node->inputConnectorList().count() == 1 )
|
|
{
|
|
// Ont input, one output
|
|
con1 = *node->inputConnectorList().at(0);
|
|
con2 = *node->outputConnectorList().at(0);
|
|
if ( con1 == con2 ) {
|
|
return false;
|
|
}
|
|
|
|
startNode = con1->startNode();
|
|
endNode = con2->endNode();
|
|
conPoints = con1->connectorPoints(false) + con2->connectorPoints(false);
|
|
}
|
|
else
|
|
{
|
|
// Both input - i.e. node is pure end node
|
|
con1 = *node->inputConnectorList().at(0);
|
|
con2 = *node->inputConnectorList().at(1);
|
|
if ( con1 == con2 ) {
|
|
return false;
|
|
}
|
|
|
|
startNode = con1->startNode();
|
|
endNode = con2->startNode();
|
|
conPoints = con1->connectorPoints(false) + con2->connectorPoints(true);
|
|
}
|
|
|
|
if ( !startNode || !endNode )
|
|
return false;
|
|
|
|
Connector *newCon = endNode->createInputConnector(startNode);
|
|
if (!newCon)
|
|
return false;
|
|
|
|
startNode->addOutputConnector(newCon);
|
|
newCon->setRoutePoints( conPoints, con1->usesManualPoints() || con2->usesManualPoints() );
|
|
|
|
// Avoid flicker: update draw lists now
|
|
con1->updateConnectorPoints(false);
|
|
con2->updateConnectorPoints(false);
|
|
newCon->updateDrawList();
|
|
|
|
node->removeNode();
|
|
con1->removeConnector();
|
|
con2->removeConnector();
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool ICNDocument::registerItem( TQCanvasItem *qcanvasItem )
|
|
{
|
|
if (!qcanvasItem)
|
|
return false;
|
|
|
|
if ( !ItemDocument::registerItem(qcanvasItem) )
|
|
{
|
|
switch (qcanvasItem->rtti())
|
|
{
|
|
case ItemDocument::RTTI::Node:
|
|
{
|
|
Node *node = (Node*)qcanvasItem;
|
|
m_nodeList.append(node);
|
|
connect( node, TQT_SIGNAL(removed(Node*)), this, TQT_SLOT(requestRerouteInvalidatedConnectors()) );
|
|
emit nodeAdded(node);
|
|
break;
|
|
}
|
|
case ItemDocument::RTTI::Connector:
|
|
{
|
|
Connector *connector = dynamic_cast<Connector*>(qcanvasItem);
|
|
m_connectorList.append(connector);
|
|
connect( connector, TQT_SIGNAL(removed(Connector*)), this, TQT_SLOT(requestRerouteInvalidatedConnectors()) );
|
|
emit connectorAdded(connector);
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
kdError() << k_funcinfo << "Unrecognised item rtti"<<endl;
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
requestRerouteInvalidatedConnectors();
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
void ICNDocument::copy()
|
|
{
|
|
if ( m_selectList->isEmpty() )
|
|
return;
|
|
|
|
ItemDocumentData data( type() );
|
|
|
|
// We only want to copy the connectors who have all ends attached to something in the selection
|
|
ConnectorList connectorList = m_selectList->connectors(false);
|
|
|
|
typedef TQMap< Node*, ConnectorList > NCLMap;
|
|
NCLMap nclMap;
|
|
|
|
ConnectorList::iterator end = connectorList.end();
|
|
for ( ConnectorList::iterator it = connectorList.begin(); it != end; ++it )
|
|
{
|
|
Node *startNode = (*it)->startNode();
|
|
if ( startNode && !startNode->isChildNode() )
|
|
nclMap[startNode].append(*it);
|
|
|
|
Node *endNode = (*it)->endNode();
|
|
if ( endNode && !endNode->isChildNode() )
|
|
nclMap[endNode].append(*it);
|
|
}
|
|
|
|
NodeList nodeList;
|
|
// Remove those connectors (and nodes) which are dangling on an orphan node
|
|
NCLMap::iterator nclEnd = nclMap.end();
|
|
for ( NCLMap::iterator it = nclMap.begin(); it != nclEnd; ++it )
|
|
{
|
|
if ( it.data().size() > 1 )
|
|
nodeList.append(it.key());
|
|
|
|
else if ( it.data().size() > 0 )
|
|
connectorList.remove( it.data().at(0) );
|
|
}
|
|
|
|
data.addItems( m_selectList->items(false) );
|
|
data.addNodes( nodeList );
|
|
data.addConnectors( connectorList );
|
|
|
|
TDEApplication::clipboard()->setText( data.toXML(), TQClipboard::Clipboard );
|
|
}
|
|
|
|
void ICNDocument::selectAll()
|
|
{
|
|
const NodeList::iterator nodeEnd = m_nodeList.end();
|
|
for ( NodeList::iterator nodeIt = m_nodeList.begin(); nodeIt != nodeEnd; ++nodeIt )
|
|
{
|
|
if (*nodeIt)
|
|
select(*nodeIt);
|
|
}
|
|
const ItemList::iterator itemEnd = m_itemList.end();
|
|
for ( ItemList::iterator itemIt = m_itemList.begin(); itemIt != itemEnd; ++itemIt )
|
|
{
|
|
if (*itemIt)
|
|
select(*itemIt);
|
|
}
|
|
const ConnectorList::iterator conEnd = m_connectorList.end();
|
|
for ( ConnectorList::iterator connectorIt = m_connectorList.begin(); connectorIt != conEnd; ++connectorIt )
|
|
{
|
|
if (*connectorIt)
|
|
select(*connectorIt);
|
|
}
|
|
}
|
|
|
|
|
|
Item* ICNDocument::addItem( const TQString &id, const TQPoint &p, bool newItem )
|
|
{
|
|
if ( !isValidItem(id) ) {
|
|
return 0l;
|
|
}
|
|
|
|
// First, we need to tell all containers to go to full bounding so that
|
|
// we can detect a "collision" with them
|
|
const ItemList::iterator end = m_itemList.end();
|
|
for ( ItemList::iterator it = m_itemList.begin(); it != end; ++it )
|
|
{
|
|
if ( FlowContainer *flowContainer = dynamic_cast<FlowContainer*>((Item*)(*it)) )
|
|
flowContainer->setFullBounds(true);
|
|
}
|
|
TQCanvasItemList preCollisions = canvas()->collisions(p);
|
|
for ( ItemList::iterator it = m_itemList.begin(); it != end; ++it )
|
|
{
|
|
if ( FlowContainer *flowContainer = dynamic_cast<FlowContainer*>((Item*)(*it)) )
|
|
flowContainer->setFullBounds(false);
|
|
}
|
|
|
|
|
|
Item *item = itemLibrary()->createItem( id, this, newItem );
|
|
if (!item) return 0L;
|
|
|
|
// Look through the CNItems at the given point (sorted by z-coordinate) for
|
|
// a container item.
|
|
FlowContainer *container = 0l;
|
|
const TQCanvasItemList::iterator pcEnd = preCollisions.end();
|
|
for ( TQCanvasItemList::iterator it = preCollisions.begin(); it != pcEnd && !container; ++it )
|
|
{
|
|
if ( FlowContainer *flowContainer = dynamic_cast<FlowContainer*>(*it) )
|
|
container = flowContainer;
|
|
}
|
|
|
|
// We want to check it is not a special item first as
|
|
// isValidItem may prompt the user about his bad choice
|
|
if ( !isValidItem(item) )
|
|
{
|
|
item->removeItem();
|
|
flushDeleteList();
|
|
return 0L;
|
|
}
|
|
|
|
int x = int(p.x());
|
|
int y = int(p.y());
|
|
|
|
if ( x < 16 || x > canvas()->width() )
|
|
x = 16;
|
|
if ( y < 16 || y > canvas()->height() )
|
|
y = 16;
|
|
|
|
if ( CNItem *cnItem = dynamic_cast<CNItem*>(item) )
|
|
{
|
|
cnItem->snap( x, y );
|
|
|
|
if (container)
|
|
container->addChild(cnItem);
|
|
}
|
|
else
|
|
item->move( x, y );
|
|
|
|
item->show();
|
|
requestStateSave();
|
|
return item;
|
|
}
|
|
|
|
|
|
void ICNDocument::addAllItemConnectorPoints()
|
|
{
|
|
// FIXME The next line crashes sometimes??!
|
|
const ItemList::iterator ciEnd = m_itemList.end();
|
|
for ( ItemList::iterator it = m_itemList.begin(); it != ciEnd; ++it )
|
|
{
|
|
if ( CNItem *cnItem = dynamic_cast<CNItem*>((Item*)(*it)) )
|
|
cnItem->updateConnectorPoints(true);
|
|
}
|
|
}
|
|
|
|
|
|
void ICNDocument::requestRerouteInvalidatedConnectors()
|
|
{
|
|
requestEvent( ItemDocumentEvent::RerouteInvalidatedConnectors );
|
|
}
|
|
void ICNDocument::rerouteInvalidatedConnectors()
|
|
{
|
|
tqApp->processEvents(300);
|
|
|
|
// We only ever need to add the connector points for CNItem's when we're about to reroute...
|
|
addAllItemConnectorPoints();
|
|
|
|
// List of connectors which are to be determined to need rerouting (and whose routes aren't controlled by NodeGroups)
|
|
ConnectorList connectorRerouteList;
|
|
|
|
// For those connectors that are controlled by node groups
|
|
NodeGroupList nodeGroupRerouteList;
|
|
|
|
const ConnectorList::iterator connectorListEnd = m_connectorList.end();
|
|
for ( ConnectorList::iterator it = m_connectorList.begin(); it != connectorListEnd; ++it )
|
|
{
|
|
Connector *connector = *it;
|
|
if ( connector && connector->isVisible() && connector->startNode() && connector->endNode() )
|
|
{
|
|
// Perform a series of tests to see if the connector needs rerouting
|
|
bool needsRerouting = false;
|
|
|
|
// Test to see if we actually have any points
|
|
const TQPointList pointList = connector->connectorPoints();
|
|
if ( pointList.isEmpty() )
|
|
needsRerouting = true;
|
|
|
|
// Test to see if the route doesn't match up with the node positions at either end
|
|
if (!needsRerouting)
|
|
{
|
|
const TQPoint listStart = pointList.first();
|
|
const TQPoint listEnd = pointList.last();
|
|
const TQPoint nodeStart = TQPoint( int(connector->startNode()->x()), int(connector->startNode()->y()) );
|
|
const TQPoint nodeEnd = TQPoint( int(connector->endNode()->x()), int(connector->endNode()->y()) );
|
|
|
|
if ( ((listStart != nodeStart) || (listEnd != nodeEnd)) &&
|
|
((listStart != nodeEnd) || (listEnd != nodeStart)) )
|
|
{
|
|
needsRerouting = true;
|
|
// kdDebug() << "listStart=("<<listStart.x()<<","<<listStart.y()<<") nodeStart=("<<nodeStart.x()<<","<<nodeStart.y()<<") listEnd=("<<listEnd.x()<<","<<listEnd.y()<<") nodeEnd=("<<nodeEnd.x()<<","<<nodeEnd.y()<<")"<<endl;
|
|
}
|
|
}
|
|
|
|
// Test to see if the route intersects any Items (we ignore if it is a manual route)
|
|
if ( !needsRerouting && !connector->usesManualPoints() )
|
|
{
|
|
const TQCanvasItemList collisions = connector->collisions(true);
|
|
const TQCanvasItemList::const_iterator collisionsEnd = collisions.end();
|
|
for ( TQCanvasItemList::const_iterator collisionsIt = collisions.begin(); (collisionsIt != collisionsEnd) && !needsRerouting; ++collisionsIt )
|
|
{
|
|
if ( dynamic_cast<Item*>(*collisionsIt) )
|
|
needsRerouting = true;
|
|
}
|
|
}
|
|
|
|
if (needsRerouting)
|
|
{
|
|
NodeGroup *nodeGroup = connector->nodeGroup();
|
|
|
|
if ( !nodeGroup && !connectorRerouteList.contains(connector) )
|
|
connectorRerouteList.append(connector);
|
|
|
|
else if ( nodeGroup && !nodeGroupRerouteList.contains(nodeGroup) )
|
|
nodeGroupRerouteList.append(nodeGroup);
|
|
}
|
|
}
|
|
}
|
|
|
|
// To allow proper rerouting, we want to start with clean routes for all of the invalidated connectors
|
|
const NodeGroupList::iterator nodeGroupRerouteEnd = nodeGroupRerouteList.end();
|
|
for ( NodeGroupList::iterator it = nodeGroupRerouteList.begin(); it != nodeGroupRerouteEnd; ++it )
|
|
{
|
|
const ConnectorList contained = (*it)->connectorList();
|
|
const ConnectorList::const_iterator end = contained.end();
|
|
for ( ConnectorList::const_iterator it = contained.begin(); it != end; ++it )
|
|
(*it)->updateConnectorPoints(false);
|
|
}
|
|
|
|
const ConnectorList::iterator connectorRerouteEnd = connectorRerouteList.end();
|
|
for ( ConnectorList::iterator it = connectorRerouteList.begin(); it != connectorRerouteEnd; ++it )
|
|
(*it)->updateConnectorPoints(false);
|
|
|
|
// And finally, reroute the connectors
|
|
for ( NodeGroupList::iterator it = nodeGroupRerouteList.begin(); it != nodeGroupRerouteEnd; ++it )
|
|
(*it)->updateRoutes();
|
|
|
|
for ( ConnectorList::iterator it = connectorRerouteList.begin(); it != connectorRerouteEnd; ++it )
|
|
(*it)->rerouteConnector();
|
|
|
|
for ( ConnectorList::iterator it = m_connectorList.begin(); it != connectorListEnd; ++it )
|
|
{
|
|
if (*it)
|
|
(*it)->updateDrawList();
|
|
}
|
|
}
|
|
|
|
|
|
Connector* ICNDocument::createConnector( const TQString &startNodeId, const TQString &endNodeId, TQPointList *pointList )
|
|
{
|
|
Node *startNode = nodeWithID(startNodeId);
|
|
Node *endNode = nodeWithID(endNodeId);
|
|
|
|
if ( !startNode || !endNode )
|
|
{
|
|
kdDebug() << "Either/both the connector start node and end node could not be found" << endl;
|
|
return 0L;
|
|
}
|
|
|
|
Connector *connector = endNode->createInputConnector(startNode);
|
|
if (!connector)
|
|
{
|
|
kdError() << k_funcinfo << "End node did not create the connector" << endl;
|
|
return 0l;
|
|
}
|
|
startNode->addOutputConnector(connector);
|
|
flushDeleteList(); // Delete any connectors that might have been removed by the nodes
|
|
|
|
// Set the route to the manual created one if the user created such a route
|
|
if (pointList)
|
|
connector->setRoutePoints(*pointList,true);
|
|
|
|
ConnectorList connectorList;
|
|
connectorList.append(connector);
|
|
|
|
setModified(true);
|
|
|
|
requestRerouteInvalidatedConnectors();
|
|
return connector;
|
|
}
|
|
|
|
void ICNDocument::deleteSelection()
|
|
{
|
|
// End whatever editing mode we are in, as we don't want to start editing
|
|
// something that is about to no longer exist...
|
|
m_cmManager->cancelCurrentManipulation();
|
|
|
|
if ( m_selectList->isEmpty() )
|
|
return;
|
|
|
|
m_selectList->deleteAllItems();
|
|
flushDeleteList();
|
|
setModified(true);
|
|
|
|
// We need to emit this so that property widgets etc...
|
|
// can clear themselves.
|
|
emit itemUnselected(0L);
|
|
|
|
requestRerouteInvalidatedConnectors();
|
|
requestStateSave();
|
|
}
|
|
|
|
|
|
ConnectorList ICNDocument::getCommonConnectors( const ItemList &list )
|
|
{
|
|
NodeList nodeList = getCommonNodes(list);
|
|
|
|
// Now, get all the connectors, and remove the ones that don't have both end
|
|
// nodes in the above generated list
|
|
ConnectorList connectorList = m_connectorList;
|
|
const ConnectorList::iterator connectorListEnd = connectorList.end();
|
|
for ( ConnectorList::iterator it = connectorList.begin(); it != connectorListEnd; ++it )
|
|
{
|
|
Connector *con = *it;
|
|
if ( !con || !nodeList.contains(con->startNode()) || !nodeList.contains(con->endNode()) ) {
|
|
*it = 0l;
|
|
}
|
|
}
|
|
connectorList.remove((Connector*)0l);
|
|
return connectorList;
|
|
}
|
|
|
|
|
|
NodeList ICNDocument::getCommonNodes( const ItemList &list )
|
|
{
|
|
NodeList nodeList;
|
|
|
|
const ItemList::const_iterator listEnd = list.end();
|
|
for ( ItemList::const_iterator it = list.begin(); it != listEnd; ++it )
|
|
{
|
|
NodeMap nodeMap;
|
|
CNItem *cnItem = dynamic_cast<CNItem*>((Item*)*it);
|
|
if (cnItem)
|
|
nodeMap = cnItem->nodeMap();
|
|
const NodeMap::iterator nodeMapEnd = nodeMap.end();
|
|
for ( NodeMap::iterator it = nodeMap.begin(); it != nodeMapEnd; ++it )
|
|
{
|
|
Node *node = it.data().node;
|
|
|
|
if ( !nodeList.contains(node) ) {
|
|
nodeList += node;
|
|
}
|
|
|
|
NodeGroup *ng = node->nodeGroup();
|
|
if (ng)
|
|
{
|
|
NodeList intNodeList = ng->internalNodeList();
|
|
const NodeList::iterator intNodeListEnd = intNodeList.end();
|
|
for ( NodeList::iterator it = intNodeList.begin(); it != intNodeListEnd; ++it )
|
|
{
|
|
Node *intNode = *it;
|
|
if ( !nodeList.contains(intNode) ) {
|
|
nodeList += intNode;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return nodeList;
|
|
}
|
|
|
|
|
|
|
|
DirCursor *DirCursor::m_self = 0l;
|
|
|
|
DirCursor::DirCursor()
|
|
{
|
|
initCursors();
|
|
}
|
|
|
|
DirCursor::~DirCursor()
|
|
{
|
|
}
|
|
|
|
DirCursor* DirCursor::self()
|
|
{
|
|
if (!m_self) m_self = new DirCursor;
|
|
return m_self;
|
|
}
|
|
|
|
void DirCursor::initCursors()
|
|
{
|
|
// TQCursor c(TQt::ArrowCursor);
|
|
// TQBitmap bitmap = *c.bitmap();
|
|
// TQBitmap mask = *c.mask();
|
|
// TQPixmap pm( bitmap->width(), bitmap->height() );
|
|
// pm.setMask(mask);
|
|
// pm = c.pi
|
|
// @todo finish
|
|
}
|
|
|
|
|
|
#include "icndocument.moc"
|