void expandTree(binaryTreePtr tree)
/* This procedure expands a unique tree for the current game state
* Pre-condition: the tree has been allocated in memory
* Post-condition: a tree has been created for the given game state
*/
{
if (tree != NULL)
{
//get the current gamestate for the level in tree we are on
infoPtr gameInfo = retrieveNodeElm(tree);
//store the adress of the current node in the tree
treeNodePtr current;
current = getCurrentNode(tree);
//get the root level's game state
nextNode(tree,TOROOT);
infoPtr rootInfo = retrieveNodeElm(tree);
//go back to current level
setCurrentNode(tree,current);
//we only extend 2 levels, this counts how many we have done
int cmpSquares = squaresAvailable(rootInfo) - squaresAvailable(gameInfo);
//is there any sqaures available?
if ( (cmpSquares < 3) && (squaresAvailable(gameInfo) != 0) )
{
//generate the next level for the tree
generateSquares(tree);
//go back to the node we started with
setCurrentNode(tree, current);
//go to the first node on the next level
nextNode(tree, TOLEFT);
//set this as the current node
current = getCurrentNode(tree);
//call this procedure again, to expand the next level
expandTree(tree);
//go back to first node of level we are working with
setCurrentNode(tree, current);
//does it have a next node on this level?
while (existNode(tree, TORIGHT) == 1)
{
//then go to the next node
nextNode(tree, TORIGHT);
//get node on this level we are working with
current = getCurrentNode(tree);
//generate a next level for this node
expandTree(tree);
//back to working level
setCurrentNode(tree, current);
}
}
}
}
void
TreeCanvas::inspectPath(void) {
QMutexLocker locker(&mutex);
setCurrentNode(root);
if (currentNode->isOnPath()) {
inspectCurrentNode();
int nextAlt = currentNode->getPathAlternative(*na);
while (nextAlt >= 0) {
setCurrentNode(currentNode->getChild(*na,nextAlt));
inspectCurrentNode();
nextAlt = currentNode->getPathAlternative(*na);
}
}
update();
}
bool BookStoreFileSystemTree::canGoUp()
{
if (!canGoUp())
{
return 0;
}
return setCurrentNode(dynamic_cast<ContainerNode *>(current_node_->mutableParent()));
}
void
TreeCanvas::mousePressEvent(QMouseEvent* event) {
if (mutex.tryLock()) {
if (event->button() == Qt::LeftButton) {
VisualNode* n = eventNode(event);
if (compareNodes) {
if (n != NULL && n->getStatus() != UNDETERMINED &&
currentNode != NULL &&
currentNode->getStatus() != UNDETERMINED) {
Space* curSpace = NULL;
Space* compareSpace = NULL;
for (int i=0; i<comparators.size(); i++) {
if (comparators[i].second) {
if (curSpace == NULL) {
curSpace = currentNode->getSpace(*na,curBest,c_d,a_d);
if (!compareNodesBeforeFP || n->isRoot()) {
compareSpace = n->getSpace(*na,curBest,c_d,a_d);
} else {
VisualNode* p = n->getParent(*na);
compareSpace = p->getSpace(*na,curBest,c_d,a_d);
switch (compareSpace->status()) {
case SS_SOLVED:
case SS_FAILED:
break;
case SS_BRANCH:
compareSpace->commit(*p->getChoice(),
n->getAlternative(*na));
break;
default:
GECODE_NEVER;
}
}
}
try {
comparators[i].first->compare(*curSpace,*compareSpace);
} catch (Exception& e) {
qFatal("Exception in comparator %d: %s.\n Stopping.",
i, e.what());
}
}
}
}
} else {
setCurrentNode(n);
}
compareNodes = false;
setCursor(QCursor(Qt::ArrowCursor));
if (n != NULL) {
event->accept();
mutex.unlock();
return;
}
}
mutex.unlock();
}
event->ignore();
}
ContainerNode * BookStoreFileSystemTree::cdContainerNodeWithinTopNode(const string& name)
{
Node* ptr = root_node_.node(name);
if (ptr == 0)
{
return 0;
}
return setCurrentNode(dynamic_cast<ContainerNode *>(ptr));
}
void GameControllerAttachment::createNodeAttachment()
{
Q_ASSERT(m_currentNode != 0);
QDomElement node = m_currentNode->xmlNode().insertBefore(QDomDocument().createElement("Attachment"), QDomNode()).toElement();
node.setAttribute("type", plugInName());
node.setAttribute("name", m_currentNode->property("Name").toString() + "_" + m_currentNode->property("ID").toString());
initNodeAttachment(m_currentNode);
setCurrentNode(m_currentNode);
}
ContainerNode * BookStoreFileSystemTree::cd(const string& name)
{
// Get child node.
NodePtr ptr = current_node_->node(name);
if (ptr != 0)
{
return setCurrentNode(dynamic_cast<ContainerNode *>(ptr));
}
return 0;
}
void TagAttributeTree::slotDelayedSetCurrentNode()
{
setCurrentNode(m_newNode);
if (ViewManager::ref()->activeDocument())
{
if (ViewManager::ref()->activeView()->hadLastFocus() == QuantaView::SourceFocus)
ViewManager::ref()->activeDocument()->view()->setFocus();
else
KafkaDocument::ref()->getKafkaWidget()->view()->setFocus();
}
}
bool XMLTokenizer::enterText()
{
#if !USE(QXMLSTREAM)
ASSERT(m_bufferedText.size() == 0);
#endif
RefPtr<Node> newNode = new Text(m_doc, "");
if (!m_currentNode->addChild(newNode.get()))
return false;
setCurrentNode(newNode.get());
return true;
}
bool XMLTokenizer::enterText()
{
#if !USE(QXMLSTREAM) && !USE(UTFXML) // UTFXml is much like QXml: they are a streaming API as opposed to a SAX API.
ASSERT(m_bufferedText.size() == 0);
#endif
RefPtr<Node> newNode = new Text(m_doc, "");
if (!m_currentNode->addChild(newNode.get()))
return false;
setCurrentNode(newNode.get());
return true;
}
NodeImpl *TreeWalkerImpl::nextNode()
{
NodeImpl *result = 0;
for (NodeImpl *node = currentNode()->traverseNextNode(); node; node = node->traverseNextNode()) {
if (acceptNode(node) == NodeFilter::FILTER_ACCEPT && !ancestorRejected(node)) {
setCurrentNode(node);
result = node;
break;
}
}
return result;
}
NodeImpl *TreeWalkerImpl::nextSibling()
{
NodeImpl *result = 0;
for (NodeImpl *node = currentNode()->nextSibling(); node; node = node->nextSibling()) {
if (acceptNode(node) == NodeFilter::FILTER_ACCEPT) {
setCurrentNode(node);
result = node;
break;
}
}
return result;
}
NodeImpl *TreeWalkerImpl::parentNode()
{
NodeImpl *result = 0;
for (NodeImpl *node = currentNode()->parentNode(); node && node != root(); node = node->parentNode()) {
if (acceptNode(node) == NodeFilter::FILTER_ACCEPT) {
setCurrentNode(node);
result = node;
break;
}
}
return result;
}
void
TreeCanvas::navUp(void) {
QMutexLocker locker(&mutex);
VisualNode* p = currentNode->getParent(*na);
setCurrentNode(p);
if (p != NULL) {
centerCurrentNode();
}
}
QDomNode KGameSvgDocument::elementByUniqueAttributeValue(const QString& attributeName, const QString& attributeValue)
{
/* DOM is always "live", so there maybe a new root node. We always have to ask for the
* root node instead of keeping a pointer to it.
*/
QDomElement docElem = documentElement();
QDomNode n = docElem.firstChild();
QDomNode node = d->findElementById(attributeName, attributeValue, n);
setCurrentNode(node);
return node;
}
void
TreeCanvas::navNextSol(bool back) {
QMutexLocker locker(&mutex);
NextSolCursor nsc(currentNode,back,*na);
PreorderNodeVisitor<NextSolCursor> nsv(nsc);
nsv.run();
VisualNode* n = nsv.getCursor().node();
if (n != root) {
setCurrentNode(n);
centerCurrentNode();
}
}
void
TreeCanvas::navRight(void) {
QMutexLocker locker(&mutex);
VisualNode* p = currentNode->getParent(*na);
if (p != NULL) {
unsigned int alt = currentNode->getAlternative(*na);
if (alt + 1 < p->getNumberOfChildren()) {
VisualNode* n = p->getChild(*na,alt+1);
setCurrentNode(n);
centerCurrentNode();
}
}
}
void
TreeCanvas::navLeft(void) {
QMutexLocker locker(&mutex);
VisualNode* p = currentNode->getParent(*na);
if (p != NULL) {
int alt = currentNode->getAlternative(*na);
if (alt > 0) {
VisualNode* n = p->getChild(*na,alt-1);
setCurrentNode(n);
centerCurrentNode();
}
}
}
KisResourcesSnapshot::KisResourcesSnapshot(KisImageWSP image, KisPostExecutionUndoAdapter *undoAdapter, KoCanvasResourceManager *resourceManager, KisDefaultBoundsBaseSP bounds)
: m_d(new Private())
{
m_d->image = image;
if (!bounds) {
bounds = new KisDefaultBounds(m_d->image);
}
m_d->bounds = bounds;
m_d->undoAdapter = undoAdapter;
m_d->currentFgColor = resourceManager->resource(KoCanvasResourceManager::ForegroundColor).value<KoColor>();
m_d->currentBgColor = resourceManager->resource(KoCanvasResourceManager::BackgroundColor).value<KoColor>();
m_d->currentPattern = static_cast<KoPattern*>(resourceManager->resource(KisCanvasResourceProvider::CurrentPattern).value<void*>());
m_d->currentGradient = static_cast<KoAbstractGradient*>(resourceManager->resource(KisCanvasResourceProvider::CurrentGradient).value<void*>());
m_d->currentPaintOpPreset = resourceManager->resource(KisCanvasResourceProvider::CurrentPaintOpPreset).value<KisPaintOpPresetSP>();
#ifdef HAVE_THREADED_TEXT_RENDERING_WORKAROUND
KisPaintOpRegistry::instance()->preinitializePaintOpIfNeeded(m_d->currentPaintOpPreset);
#endif /* HAVE_THREADED_TEXT_RENDERING_WORKAROUND */
m_d->currentExposure = resourceManager->resource(KisCanvasResourceProvider::HdrExposure).toDouble();
m_d->currentGenerator = static_cast<KisFilterConfiguration*>(resourceManager->resource(KisCanvasResourceProvider::CurrentGeneratorConfiguration).value<void*>());
m_d->axesCenter = resourceManager->resource(KisCanvasResourceProvider::MirrorAxesCenter).toPointF();
if (m_d->axesCenter.isNull()){
QRect bounds = m_d->bounds->bounds();
m_d->axesCenter = QPointF(0.5 * bounds.width(), 0.5 * bounds.height());
}
m_d->mirrorMaskHorizontal = resourceManager->resource(KisCanvasResourceProvider::MirrorHorizontal).toBool();
m_d->mirrorMaskVertical = resourceManager->resource(KisCanvasResourceProvider::MirrorVertical).toBool();
qreal normOpacity = resourceManager->resource(KisCanvasResourceProvider::Opacity).toDouble();
m_d->opacity = quint8(normOpacity * OPACITY_OPAQUE_U8);
m_d->compositeOpId = resourceManager->resource(KisCanvasResourceProvider::CurrentCompositeOp).toString();
setCurrentNode(resourceManager->resource(KisCanvasResourceProvider::CurrentKritaNode).value<KisNodeSP>());
/**
* Fill and Stroke styles are not a part of the resource manager
* so the tools should set them manually
* TODO: port stroke and fill styles to be a part
* of the resource manager
*/
m_d->strokeStyle = KisPainter::StrokeStyleBrush;
m_d->fillStyle = KisPainter::FillStyleNone;
m_d->globalAlphaLock = resourceManager->resource(KisCanvasResourceProvider::GlobalAlphaLock).toBool();
m_d->effectiveZoom = resourceManager->resource(KisCanvasResourceProvider::EffectiveZoom).toDouble();
}
void KisLayerBox::setCanvas(KoCanvasBase *canvas)
{
if (m_canvas) {
m_canvas->disconnectCanvasObserver(this);
m_nodeModel->setDummiesFacade(0, 0);
disconnect(m_image, 0, this, 0);
disconnect(m_nodeManager, 0, this, 0);
disconnect(m_nodeModel, 0, m_nodeManager, 0);
disconnect(m_nodeModel, SIGNAL(nodeActivated(KisNodeSP)), this, SLOT(updateUI()));
}
m_canvas = dynamic_cast<KisCanvas2*>(canvas);
if (m_canvas) {
m_image = m_canvas->view()->image();
m_nodeManager = m_canvas->view()->nodeManager();
KisDummiesFacadeBase *kritaDummiesFacade = dynamic_cast<KisDummiesFacadeBase*>(m_canvas->view()->document()->shapeController());
m_nodeModel->setDummiesFacade(kritaDummiesFacade, m_image);
connect(m_image, SIGNAL(sigAboutToBeDeleted()), SLOT(notifyImageDeleted()));
// cold start
setCurrentNode(m_nodeManager->activeNode());
// Connection KisNodeManager -> KisLayerBox
connect(m_nodeManager, SIGNAL(sigUiNeedChangeActiveNode(KisNodeSP)), this, SLOT(setCurrentNode(KisNodeSP)));
// Connection KisLayerBox -> KisNodeManager
// The order of these connections is important! See comment in the ctor
connect(m_nodeModel, SIGNAL(nodeActivated(KisNodeSP)), m_nodeManager, SLOT(slotUiActivatedNode(KisNodeSP)));
connect(m_nodeModel, SIGNAL(nodeActivated(KisNodeSP)), SLOT(updateUI()));
// Node manipulation methods are forwarded to the node manager
connect(m_nodeModel, SIGNAL(requestAddNode(KisNodeSP, KisNodeSP, KisNodeSP)),
m_nodeManager, SLOT(addNodeDirect(KisNodeSP, KisNodeSP, KisNodeSP)));
connect(m_nodeModel, SIGNAL(requestMoveNode(KisNodeSP, KisNodeSP, KisNodeSP)),
m_nodeManager, SLOT(moveNodeDirect(KisNodeSP, KisNodeSP, KisNodeSP)));
m_wdgLayerBox->listLayers->expandAll();
expandNodesRecursively(m_image->rootLayer(), m_nodeModel, m_wdgLayerBox->listLayers);
m_wdgLayerBox->listLayers->scrollToBottom();
foreach(KisAction *action, m_actions) {
m_canvas->view()->actionManager()->addAction(action);
}
}
void XMLTokenizer::end()
{
doEnd();
if (m_sawError)
insertErrorMessageBlock();
else {
exitText();
m_doc->updateStyleSelector();
}
setCurrentNode(0);
if (!m_parsingFragment)
m_doc->finishedParsing();
}
void GameControllerAttachment::removeNodeAttachment()
{
QDomElement node = m_currentNode->xmlNode().firstChildElement("Attachment");
unsigned int entityID = GameEngine::entityWorldID( qPrintable(node.attribute("name")) );
// Reset scene graph component to avoid removement of Horde's scenegraph node
GameEngine::setEntitySceneGraphID( entityID, 0 );
m_currentNode->xmlNode().removeChild(node);
if( m_currentNode->property("__AttachmentModel").isValid() )
{
delete static_cast<AttachmentTreeModel*>(m_currentNode->property("__AttachmentModel").value<void*>());
m_currentNode->setProperty("__AttachmentModel", QVariant::fromValue<void*>(0));
GameEngine::removeGameEntity( entityID );
}
setCurrentNode(m_currentNode);
}
void
TreeCanvas::contextMenuEvent(QContextMenuEvent* event) {
if (mutex.tryLock()) {
VisualNode* n = eventNode(event);
if (n != NULL) {
setCurrentNode(n);
emit contextMenu(event);
event->accept();
mutex.unlock();
return;
}
mutex.unlock();
}
event->ignore();
}
void
TreeCanvas::navDown(void) {
QMutexLocker locker(&mutex);
if (!currentNode->isHidden()) {
switch (currentNode->getStatus()) {
case STOP:
case UNSTOP:
case BRANCH:
{
int alt = std::max(0, currentNode->getPathAlternative(*na));
VisualNode* n = currentNode->getChild(*na,alt);
setCurrentNode(n);
centerCurrentNode();
break;
}
case SOLVED:
case FAILED:
case UNDETERMINED:
break;
}
}
}
bool BookStoreFileSystemTree::cdPath(const ModelPath& path)
{
if (path.size() <= 0)
{
return false;
}
string root_path = path.front();
if (root_path != root_node_.absolutePath())
{
return false;
}
Node* node = &root_node_;
for (int i = 1; i < path.size(); i++)
{
if (node == 0)
{
return false;
}
ContainerNode* container = dynamic_cast<ContainerNode*>(node);
if (container != 0)
{
node = container->node(path[i]).get();
}
else
{
return false;
}
}
ContainerNode* current_node = dynamic_cast<ContainerNode*>(node);
if (current_node != 0)
{
setCurrentNode(current_node);
return true;
}
return false;
}
void XMLTokenizer::exitText()
{
if (m_parserStopped)
return;
if (!m_currentNode || !m_currentNode->isTextNode())
return;
#if !USE(QXMLSTREAM) && !USE(UTFXML) // UTFXml is much like QXml: they are a streaming API as opposed to a SAX API.
ExceptionCode ec = 0;
static_cast<Text*>(m_currentNode)->appendData(toString(m_bufferedText.data(), m_bufferedText.size()), ec);
Vector<xmlChar> empty;
m_bufferedText.swap(empty);
#endif
if (m_view && m_currentNode && !m_currentNode->attached())
m_currentNode->attach();
// FIXME: What's the right thing to do if the parent is really 0?
// Just leaving the current node set to the text node doesn't make much sense.
if (Node* par = m_currentNode->parentNode())
setCurrentNode(par);
}
void TreeWalkerImpl::setCurrentNode(NodeImpl *node)
{
assert(node);
int dummy;
setCurrentNode(node, dummy);
}
BasicBlock* SubCfgBuilderUtils::newBB(void)
{
BasicBlock* bb = (BasicBlock*)m_subCFG->createBlockNode();
setCurrentNode(bb);
return bb;
}
void bestMove(binaryTreePtr tree)
/* This procedure will determine the best move available
* by using a minmax method to either compute the value (on a leaf)
* or sending it one level up where will be decided if the minimum or the maximum value will be used
* Pre-condition:none
* Post-condition: the root of the tree now has the minmax value needed
*/
{
infoPtr gameInfo,temp;
treeNodePtr current;
//retrieve the current node's info
gameInfo = retrieveNodeElm(tree);
//is this a leaf?
if ((existNode(tree,TOLEFT)== -1) )
{
//then compute the value of this square
gameInfo->eval = evaluateSquares(gameInfo);
}else
{
//go down a level, to first node
nextNode(tree, TOLEFT);
//get the current node in tree
current = getCurrentNode(tree);
//get the info for this node
temp = retrieveNodeElm(tree);
//call this procedure again, this will send up a value
bestMove(tree);
//go back to first node on the level
setCurrentNode(tree, current);
//set the parent level's value to this node's
gameInfo->eval = temp->eval;
//is there a next node on this level?
while (existNode(tree,TORIGHT) == 1)
{
//then go to the next node
nextNode(tree, TORIGHT);
//set this as the current node on this level
current = getCurrentNode(tree);
//get the info for this node
temp = retrieveNodeElm(tree);
//call this procedure again, this will send up a value
bestMove(tree);
//go back to node on this level we're working on
setCurrentNode(tree, current);
//who's turn was it last
if (gameInfo->turn == COMPUTER)
{
//if temp->eval is smaller
if (gameInfo->eval > temp->eval)
{
//this is the new minimum value
gameInfo->eval = temp->eval;
}
}else
{
//if temp->eval is bigger
if (gameInfo->eval < temp->eval)
{
//this is the new maximum value
gameInfo->eval = temp->eval;
}
}
}
}
}
void
TreeCanvas::navRoot(void) {
QMutexLocker locker(&mutex);
setCurrentNode(root);
centerCurrentNode();
}
