bool KisOpenRasterStackSaveVisitor::visit(KisGroupLayer *layer)
{
QDomElement* previousElt = d->currentElement;
QDomElement elt = d->layerStack.createElement("stack");
d->currentElement = &elt;
saveLayerInfo(elt, layer);
visitAll(layer);
if (previousElt) {
previousElt->appendChild(elt);
d->currentElement = previousElt;
} else {
QDomElement imageElt = d->layerStack.createElement("image");
int width = layer->image()->width();
int height = layer->image()->height();
imageElt.setAttribute("w", width);
imageElt.setAttribute("h", height);
imageElt.appendChild(elt);
d->layerStack.insertBefore(imageElt, QDomNode());
d->currentElement = 0;
d->saveContext->saveStack(d->layerStack);
}
return true;
}
const std::vector<GLSLAnnotation*>& AnnotationVisitor::getAnnotations(ParseTreeNode* const root)
{
freeAnnotations();
freeAnnotations_ = false;
visitAll(root);
return annotations_;
}
bool PreprocessorVisitor::visitNode(IncludeDirective* const n) {
if (n == 0)
return false;
bool res = false;
try {
std::string includeFile = adjustIncludeFile(n->getFileName());
PreprocessorParser includeParser(includeFile);
log_ << "parsing included file '" << n->getFileName() << "'...\n";
ParseTreeNode* root = includeParser.parse();
if (root != 0) {
visitAll(root);
res = true;
} else {
log_ << "failed to parse include directive '" << n->getFileName() << "':\n";
log_ << includeParser.getLog().str() << "\n";
}
delete root;
} catch (std::bad_alloc&) {
log_ << "failed to open file '" << n->getFileName() << "' for inclusion!\n";
}
return res;
}
std::ostringstream& PreprocessorVisitor::translate(ParseTreeNode* const root) {
translation_.str("");
visitAll(root);
return translation_;
}
virtual bool visit(KisGroupLayer* layer)
{
bool result = visitAll(layer);
if(layer == layer->image()->rootLayer()) {
return result;
}
return result && process(layer);
}
bool KisCountVisitor::check(KisNode * node)
{
if (m_nodeTypes.isEmpty() || inList(node)) {
if (m_properties.isEmpty() || node->check(m_properties)) {
m_count++;
}
}
visitAll(node);
return true;
}
const std::vector<PlotFunctionVisitor::TokenVector>& PlotFunctionVisitor::getPlotFunctionToken(ParseTreeNode* const root) {
tokens_.clear();
temptokens_.clear();
getPartialTrees(root);
if (partialTrees_.size() == 0) {
visitAll(root);
tokens_.resize(1);
tokens_[0].function = temptokens_;
}
else {
for (size_t i = 0; i < partialTrees_.size(); ++i) {
tokens_.resize(partialTrees_.size());
temptokens_.clear();
visitAll(partialTrees_[i].function);
tokens_[i].function = temptokens_;
temptokens_.clear();
visitAll(partialTrees_[i].interval);
tokens_[i].interval = temptokens_;
}
}
return tokens_;
}
bool KisMirrorVisitor::visit(KisExternalLayer* layer)
{
if (m_orientation == Qt::Horizontal) {
KisTransformVisitor visitor(m_image, -1.0, 1.0, 0.0, 0.0, 0.0, m_image->width(), 0, 0, 0);
layer->accept(visitor);
} else {
KisTransformVisitor visitor(m_image, 1.0, -1.0, 0.0, 0.0, 0.0, 0, m_image->height(), 0, 0);
layer->accept(visitor);
}
visitAll(layer);
return true;
}
bool KisMirrorVisitor::visit(KisPaintLayer* layer)
{
KisPaintDeviceSP dev = layer->paintDevice();
QString name;
if (m_orientation == Qt::Horizontal) {
name = i18n("Mirror Layer X");
} else {
name = i18n("Mirror Layer Y");
}
KisTransaction transaction(name, dev);
QRect dirty;
if (m_orientation == Qt::Horizontal) {
dirty = KisTransformWorker::mirrorX(dev, m_image->width()/2.0f);
} else {
dirty = KisTransformWorker::mirrorY(dev, m_image->height()/2.0f);
}
layer->setDirty(dirty);
transaction.commit(m_image->undoAdapter());
visitAll(layer);
return true;
}
bool KisMirrorVisitor::visit(KisGroupLayer* layer)
{
visitAll(layer);
return true;
}
bool KisTIFFWriterVisitor::visit(KisGroupLayer *layer)
{
dbgFile << "Visiting on grouplayer" << layer->name() << "";
return visitAll(layer, true);
}
