Node* shuffleMerge(Node* a, Node* b) {
Node dummy;
Node* tail=&dummy;
dummy.next=NULL;
while (1) {
if (a==NULL) {
tail->next=b;
break;
}
else if (b==NULL) {
tail->next=a;
break;
}
else {
moveNode(&a, &(tail->next));
tail=tail->next;
moveNode(&b, &(tail->next));
tail=tail->next;
}
}
return dummy.next;
}
///////////////////////////////////////////////////////////////////////
// set method
///////////////////////////////////////////////////////////////////////
void set(int key, int value) {
if (mp.find(key)!=mp.end()){
moveNode(mp[key]);
mp[key]->value = value;
}else{
if (mp.size()==cp){
mp.erase(head->key);
rmNode(head);
}
Node * node = new Node(key,value);
mp[key] = node;
insertNode(node);
}
}
bool KisNodeFacade::lowerNode(KisNodeSP node)
{
if (!node) return false;
if (!node->parent()) return false;
KisNodeSP parent = node->parent();
KisNodeSP prevSibling = node->prevSibling();
if (node->prevSibling()) {
int prevIndex = parent->index(prevSibling);
return moveNode(node, parent, prevIndex);
} else {
return true; // We're already at bottom, but there's no sense
// in complaining
}
}
typename SortedList<T, Pred>::Node* SortedList<T, Pred>::merge_lists(typename SortedList<T, Pred>::Node* list1, unsigned length1, typename SortedList<T, Pred>::Node* list2, unsigned length2, const Sorter &sorter)
{
unsigned i = 0, j = 0;
SortedList<T, Pred>::Node* front = sorter(list1->Data, list2->Data) ? list1 : list2;
// I will arbitrarily decide to just shove everything into list1.
while (i < length1 && j < length2 && list2 != tail_)
{
if (sorter(list1->Data, list2->Data))
{
list1 = list1->Next;
++i;
}
else
{
SortedList<T, Pred>::Node* temp = list2;
list2 = list2->Next;
++j;
moveNode(temp, list1->Prev);
}
}
// If there's any left over, append the rest.
// If list1 is longer it's already in order and junk, so we
// don't worry about it at all.
/* while (j < length2 && list2 != tail_)
{
SortedList<T, Pred>::Node* temp = list2;
list2 = list2->Next;
++j;
moveNode(temp, list1->Prev);
list1 = list1->Next;
} */
// Aaaaaactually, all that is unnecessary.
// In mergesort, the right block is always adjacent to the left block.
// So, there's no point worrying about it, it's already appended for
// your convenience.
// The two should be stuck together now.
// This should work because lists we're comparing should all be
// adjacent to each other.
return(front);
}
void KOrthogonalMap::removeTileLayer(U32 TileID, U16 LayerIndex) {
// check range
if (TileID >= _krootList.size()) {
KD_PRINT("tile id is out of range or tile map is not created yet");
return;
}
// empty tile (there is no layer)
if (_krootList[TileID].layerSize == 0) return;
// iterate over layers
SIZE nodeIndex = _krootList[TileID].firstNode;
SIZE prevNode = nodeIndex;
for (U16 i = 0; i < _krootList[TileID].layerSize; ++i) {
// layer not found
if (_knodeList[nodeIndex].layerIndex > LayerIndex) break;
// layer found
if (_knodeList[nodeIndex].layerIndex == LayerIndex) {
// first node
if (i == 0) {
_krootList[TileID].firstNode = _knodeList[nodeIndex].nextNode;
} else {
_knodeList[prevNode].nextNode = _knodeList[nodeIndex].nextNode;
}
--_krootList[TileID].layerSize;
// swap and remove methode
moveNode(_knodeList.back(), nodeIndex);
_knodeList.pop_back();
break;
}
// store current node
prevNode = nodeIndex;
// move to next node
nodeIndex = _knodeList[nodeIndex].nextNode;
}
}
void KOrthogonalMap::removeTileLayers(U32 TileID) {
// check range
if (TileID >= _krootList.size()) {
KD_PRINT("tile id is out of range or tile map is not created yet");
return;
}
// iterate over nodes and remove them
auto tempSize = _krootList[TileID].layerSize;
for (SIZE i = 0; i < tempSize; ++i) {
--_krootList[TileID].layerSize;
// swap and remove methode
// swap removed node with last node in the list
moveNode(_knodeList.back(), _krootList[TileID].firstNode);
_knodeList.pop_back();
// move first pointer to next node
_krootList[TileID].firstNode = _knodeList[_krootList[TileID].firstNode].nextNode;
}
// cleanup root
_krootList[TileID].firstNode = 0;
}
node9->setPos(50, 50);*/
newNodeAct=new QAction(tr("&New Node"),this);
newNodeAct->setShortcuts(QKeySequence::New);
newNodeAct->setStatusTip(tr("Create a new node"));
connect(newNodeAct,SIGNAL(triggered()),this,SLOT(newNode()));
newEdgeAct=new QAction(tr("N&ew Edge"),this);
//newEdgeAct->setShortcuts(QKeySequence::New);
newEdgeAct->setStatusTip(tr("Create a new edge"));
connect(newEdgeAct,SIGNAL(triggered()),this,SLOT(newEdge()));
moveNodeAct=new QAction(tr("&Move Nodes"),this);
moveNodeAct->setStatusTip(tr("Move nodes"));
connect(moveNodeAct,SIGNAL(triggered()),this,SLOT(moveNode()));
scale(qreal(0.8), qreal(0.8));
setMinimumSize(400, 400);
setWindowTitle(tr("Elastic Nodes"));
}
GraphWidget::~GraphWidget()
{
foreach(PyObject* module,moduleList) {
Py_DECREF(module);
}
void SceneGraph::initialize(void (*callbackFn)(int nNode, void *info), void *callbackFnInfo)
{
Node *node;
int nNode = 0;
for (node = Parser::getNodes(); node; node = node->nextTraversal()) {
node->setSceneGraph(this);
if (node->isInstanceNode() == false)
node->initialize();
nNode++;
if (callbackFn)
callbackFn(nNode, callbackFnInfo);
}
// Convert from InstanceNode into DEFNode
node = Parser::getNodes();
while(node != NULL) {
Node *nextNode = node->nextTraversal();
if (node->isInstanceNode() == true && node->isDEFNode() == false) {
Node *referenceNode = node->getReferenceNode();
Node *parentNode = node->getParentNode();
Node *defNode;
defNode = referenceNode->createDEFNode();
if (parentNode != NULL)
parentNode->addChildNode(defNode, false);
else
addNode(defNode, false);
node->remove();
delete node;
nextNode = defNode->nextTraversal();
}
node = nextNode;
}
// Convert from DEFNode into InstanceNode
node = Parser::getNodes();
while(node != NULL) {
Node *nextNode = node->nextTraversal();
if (node->isDEFNode() == true) {
Node *defNode = findNode(node->getName());
assert(defNode);
if (defNode) {
Node *instanceNode = defNode->createInstanceNode();
Node *parentNode = node->getParentNode();
if (parentNode != NULL)
parentNode->moveChildNode(instanceNode);
else
moveNode(instanceNode);
node->remove();
delete node;
}
}
node = nextNode;
}
recomputeBoundingBox();
for (Route *route = Parser::getRoutes(); route; route = route->next())
route->initialize();
}
