KisNodeSP KisKraLoader::loadNodes(const KoXmlElement& element, KisImageWSP image, KisNodeSP parent)
{
KoXmlNode node = element.firstChild();
KoXmlNode child;
if (!node.isNull()) {
if (node.isElement()) {
if (node.nodeName().toUpper() == LAYERS.toUpper() || node.nodeName().toUpper() == MASKS.toUpper()) {
for (child = node.lastChild(); !child.isNull(); child = child.previousSibling()) {
KisNodeSP node = loadNode(child.toElement(), image, parent);
if (node) {
image->nextLayerName(); // Make sure the nameserver is current with the number of nodes.
image->addNode(node, parent);
if (node->inherits("KisLayer") && child.childNodesCount() > 0) {
loadNodes(child.toElement(), image, node);
}
}
}
}
}
}
return parent;
}
void KisSelectAllActionFactory::run(KisView2 *view)
{
KisProcessingApplicator *ap = beginAction(view, i18n("Select All"));
KisImageWSP image = view->image();
if (!image->globalSelection()) {
ap->applyCommand(new KisSetEmptyGlobalSelectionCommand(image),
KisStrokeJobData::SEQUENTIAL,
KisStrokeJobData::EXCLUSIVE);
}
struct SelectAll : public KisTransactionBasedCommand {
SelectAll(KisImageSP image) : m_image(image) {}
KisImageSP m_image;
KUndo2Command* paint() {
KisSelectionSP selection = m_image->globalSelection();
KisSelectionTransaction transaction(QString(), m_image->undoAdapter(), selection);
selection->getOrCreatePixelSelection()->select(m_image->bounds());
return transaction.endAndTake();
}
};
ap->applyCommand(new SelectAll(image),
KisStrokeJobData::SEQUENTIAL,
KisStrokeJobData::EXCLUSIVE);
endAction(ap, KisOperationConfiguration(id()).toXML());
}
KisFigurePaintingToolHelper::KisFigurePaintingToolHelper(const QString &name,
KisImageWSP image,
KoCanvasResourceManager *resourceManager,
KisPainter::StrokeStyle strokeStyle,
KisPainter::FillStyle fillStyle)
{
m_strokesFacade = image.data();
m_resources =
new KisResourcesSnapshot(image,
image->postExecutionUndoAdapter(),
resourceManager);
m_resources->setStrokeStyle(strokeStyle);
m_resources->setFillStyle(fillStyle);
m_painterInfo =
new PainterInfo(new KisPainter(),
new KisDistanceInformation());
bool indirectPainting = m_resources->needsIndirectPainting();
KisStrokeStrategy *stroke =
new FreehandStrokeStrategy(indirectPainting, m_resources, m_painterInfo, name);
m_strokeId = m_strokesFacade->startStroke(stroke);
}
bool checkLayers(KisImageWSP image,
const QString &prefix)
{
KisNodeSP layer1 = image->rootLayer()->firstChild();
KisNodeSP layer2 = layer1->nextSibling();
QVector<QImage> images(3);
images[0] = image->projection()->convertToQImage(0, 0, 0, 300, 300);
images[1] = layer1->paintDevice()->convertToQImage(0, 0, 0, 300, 300);
images[2] = layer2->paintDevice()->convertToQImage(0, 0, 0, 300, 300);
QVector<QString> names(3);
names[0] = QString("applicator_") + prefix + "_projection.png";
names[1] = QString("applicator_") + prefix + "_layer1.png";
names[2] = QString("applicator_") + prefix + "_layer2.png";
bool valid = true;
for(int i = 0; i < 3; i++) {
QImage ref(QString(FILES_DATA_DIR) + QDir::separator() +
"applicator" + QDir::separator() + names[i]);
QPoint temp;
if(!TestUtil::compareQImages(temp, ref, images[i], 1)) {
qDebug() << "--- Wrong image:" << names[i];
valid = false;
images[i].save(QString(FILES_OUTPUT_DIR) + QDir::separator() + names[i]);
}
}
return valid;
}
void KisDummiesFacadeBase::setImage(KisImageWSP image)
{
if (m_d->image) {
emit sigActivateNode(0);
m_d->image->disconnect(this);
KisNodeDummy *rootDummy = this->rootDummy();
if(rootDummy) {
slotRemoveNode(rootDummy->node());
}
}
m_d->image = image;
if (image) {
slotNodeAdded(image->root());
connect(image, SIGNAL(sigNodeAddedAsync(KisNodeSP)),
SLOT(slotNodeAdded(KisNodeSP)), Qt::DirectConnection);
connect(image, SIGNAL(sigRemoveNodeAsync(KisNodeSP)),
SLOT(slotRemoveNode(KisNodeSP)), Qt::DirectConnection);
connect(image, SIGNAL(sigLayersChangedAsync()),
SLOT(slotLayersChanged()), Qt::DirectConnection);
connect(image, SIGNAL(sigNodeChanged(KisNodeSP)),
SLOT(slotNodeChanged(KisNodeSP)));
connect(image, SIGNAL(sigNodeAddedAsync(KisNodeSP)),
SLOT(slotNodeActivationRequested(KisNodeSP)), Qt::AutoConnection);
emit sigActivateNode(findFirstLayer(image->root()));
}
}
void testObligeSingleChildImpl(bool transpDefaultPixel)
{
QString id = !transpDefaultPixel ?
"single_layer_no_channel_flags_nontransp_def_pixel.kra" :
"single_layer_no_channel_flags_transp_def_pixel.kra";
QString fileName = TestUtil::fetchDataFileLazy(id);
KisDocument *doc = KisPart::instance()->createDocument();
doc->loadNativeFormat(fileName);
KisImageWSP image = doc->image();
QVERIFY(image);
QCOMPARE(image->nlayers(), 2);
KisNodeSP root = image->root();
KisNodeSP child = root->firstChild();
QVERIFY(child);
QCOMPARE(root->original(), root->projection());
if (transpDefaultPixel) {
QCOMPARE(root->original(), child->projection());
} else {
QVERIFY(root->original() != child->projection());
}
delete doc;
}
void KisPerspectiveGridManager::updateGUI()
{
KisImageWSP image = m_view->image();
if (image) {
KisPerspectiveGrid* pGrid = image->perspectiveGrid();
m_toggleGrid->setEnabled(pGrid->hasSubGrids());
}
}
void copyFromDevice(KisViewManager *view, KisPaintDeviceSP device, bool makeSharpClip = false)
{
KisImageWSP image = view->image();
if (!image) return;
KisSelectionSP selection = view->selection();
QRect rc = (selection) ? selection->selectedExactRect() : image->bounds();
KisPaintDeviceSP clip = new KisPaintDevice(device->colorSpace());
Q_CHECK_PTR(clip);
const KoColorSpace *cs = clip->colorSpace();
// TODO if the source is linked... copy from all linked layers?!?
// Copy image data
KisPainter::copyAreaOptimized(QPoint(), device, clip, rc);
if (selection) {
// Apply selection mask.
KisPaintDeviceSP selectionProjection = selection->projection();
KisHLineIteratorSP layerIt = clip->createHLineIteratorNG(0, 0, rc.width());
KisHLineConstIteratorSP selectionIt = selectionProjection->createHLineIteratorNG(rc.x(), rc.y(), rc.width());
const KoColorSpace *selCs = selection->projection()->colorSpace();
for (qint32 y = 0; y < rc.height(); y++) {
for (qint32 x = 0; x < rc.width(); x++) {
/**
* Sharp method is an exact reverse of COMPOSITE_OVER
* so if you cover the cut/copied piece over its source
* you get an exactly the same image without any seams
*/
if (makeSharpClip) {
qreal dstAlpha = cs->opacityF(layerIt->rawData());
qreal sel = selCs->opacityF(selectionIt->oldRawData());
qreal newAlpha = sel * dstAlpha / (1.0 - dstAlpha + sel * dstAlpha);
float mask = newAlpha / dstAlpha;
cs->applyAlphaNormedFloatMask(layerIt->rawData(), &mask, 1);
} else {
cs->applyAlphaU8Mask(layerIt->rawData(), selectionIt->oldRawData(), 1);
}
layerIt->nextPixel();
selectionIt->nextPixel();
}
layerIt->nextRow();
selectionIt->nextRow();
}
}
KisClipboard::instance()->setClip(clip, rc.topLeft());
}
QRectF KisNodeShape::boundingRect() const
{
QRect br = m_d->node->extent();
KisImageWSP image = getImage();
return QRectF(int(br.left()) / image->xRes(), int(br.top()) / image->yRes(),
int(1 + br.right()) / image->xRes(), int(1 + br.bottom()) / image->yRes());
}
void KisPerspectiveGridManager::clearPerspectiveGrid()
{
KisImageWSP image = m_view->image();
if (image) {
image->perspectiveGrid()->clearSubGrids();
m_view->canvas()->update();
m_toggleGrid->setChecked(false);
m_toggleGrid->setEnabled(false);
}
}
QDomElement KisKraSaver::saveXML(QDomDocument& doc, KisImageWSP image)
{
QDomElement imageElement = doc.createElement("IMAGE"); // Legacy!
Q_ASSERT(image);
imageElement.setAttribute(NAME, m_d->imageName);
imageElement.setAttribute(MIME, NATIVE_MIMETYPE);
imageElement.setAttribute(WIDTH, image->width());
imageElement.setAttribute(HEIGHT, image->height());
imageElement.setAttribute(COLORSPACE_NAME, image->colorSpace()->id());
imageElement.setAttribute(DESCRIPTION, m_d->doc->documentInfo()->aboutInfo("comment"));
// XXX: Save profile as blob inside the image, instead of the product name.
if (image->profile() && image->profile()-> valid()) {
imageElement.setAttribute(PROFILE, image->profile()->name());
}
imageElement.setAttribute(X_RESOLUTION, image->xRes()*72.0);
imageElement.setAttribute(Y_RESOLUTION, image->yRes()*72.0);
quint32 count = 1; // We don't save the root layer, but it does count
KisSaveXmlVisitor visitor(doc, imageElement, count, true);
image->rootLayer()->accept(visitor);
m_d->nodeFileNames = visitor.nodeFileNames();
return imageElement;
}
QRectF KisDuplicateOpSettings::duplicateOutlineRect(const QPointF& pos, KisImageWSP image) const
{
// Compute the rectangle for the offset
QRectF rect2 = QRectF(-5, -5, 10, 10);
if (m_isOffsetNotUptodate) {
rect2.translate(m_position);
} else {
rect2.translate(- m_offset + image->documentToPixel(pos));
}
return image->pixelToDocument(rect2);
}
void KisCopyMergedActionFactory::run(KisView2 *view)
{
KisImageWSP image = view->image();
image->barrierLock();
KisPaintDeviceSP dev = image->root()->projection();
ActionHelper::copyFromDevice(view, dev);
image->unlock();
KisProcessingApplicator *ap = beginAction(view, i18n("Copy Merged"));
endAction(ap, KisOperationConfiguration(id()).toXML());
}
bool KisKraSaver::saveBinaryData(KoStore* store, KisImageWSP image, const QString & uri, bool external)
{
QString location;
// Save the layers data
quint32 count = 0;
KisKraSaveVisitor visitor(image, store, count, m_d->imageName, m_d->nodeFileNames);
if (external)
visitor.setExternalUri(uri);
image->rootLayer()->accept(visitor);
// saving annotations
// XXX this only saves EXIF and ICC info. This would probably need
// a redesign of the dtd of the krita file to do this more generally correct
// e.g. have <ANNOTATION> tags or so.
KisAnnotationSP annotation = image->annotation("exif");
if (annotation) {
location = external ? QString::null : uri;
location += m_d->imageName + EXIF_PATH;
if (store->open(location)) {
store->write(annotation->annotation());
store->close();
}
}
if (image->profile()) {
const KoColorProfile *profile = image->profile();
KisAnnotationSP annotation;
if (profile) {
QByteArray profileRawData = profile->rawData();
if (!profileRawData.isEmpty()) {
if (profile->type() == "icc") {
annotation = new KisAnnotation(ICC, profile->name(), profile->rawData());
} else {
annotation = new KisAnnotation(PROFILE, profile->name(), profile->rawData());
}
}
}
if (annotation) {
location = external ? QString::null : uri;
location += m_d->imageName + ICC_PATH;
if (store->open(location)) {
store->write(annotation->annotation());
store->close();
}
}
}
return true;
}
Private(KisDocument *document, int fromTime, int toTime)
: document(document),
image(document->image()),
firstFrame(fromTime),
lastFrame(toTime),
tmpDoc(KisPart::instance()->createDocument()),
exporting(false),
batchMode(false)
{
tmpDoc->setAutoSave(0);
tmpImage = new KisImage(tmpDoc->createUndoStore(),
image->bounds().width(),
image->bounds().height(),
image->colorSpace(),
QString());
tmpImage->setResolution(image->xRes(), image->yRes());
tmpDoc->setCurrentImage(tmpImage);
KisPaintLayer* paintLayer = new KisPaintLayer(tmpImage, "paint device", 255);
tmpImage->addNode(paintLayer, tmpImage->rootLayer(), KisLayerSP(0));
tmpDevice = paintLayer->paintDevice();
}
QSizeF KisNodeShape::size() const
{
Q_ASSERT(m_d);
Q_ASSERT(m_d->node);
QRect br = m_d->node->extent();
KisImageWSP image = getImage();
if (!image) return QSizeF(0.0, 0.0);
dbgUI << "KisNodeShape::size extent:" << br << ", x res:" << image->xRes() << ", y res:" << image->yRes();
return QSizeF(br.width() / image->xRes(), br.height() / image->yRes());
}
void KisNodeShape::setPosition(const QPointF & position)
{
Q_ASSERT(m_d);
Q_ASSERT(m_d->node);
KisImageWSP image = getImage();
if (image) {
// XXX: Does flake handle undo for us?
QPointF pf(position.x() / image->xRes(), position.y() / image->yRes());
QPoint p = pf.toPoint();
m_d->node->setX(p.x());
m_d->node->setY(p.y());
}
}
void KisCanvasResourceProvider::slotOnScreenResolutionChanged()
{
KisImageWSP image = m_view->image();
KisCanvas2 *canvas = m_view->canvasBase();
if(!image || !canvas) return;
qreal zoomX, zoomY;
canvas->coordinatesConverter()->zoom(&zoomX, &zoomY);
qreal scaleX = zoomX / image->xRes();
qreal scaleY = zoomY / image->yRes();
emit sigOnScreenResolutionChanged(scaleX, scaleY);
}
KisSelectionBasedLayer::KisSelectionBasedLayer(KisImageWSP image,
const QString &name,
KisSelectionSP selection,
KisFilterConfiguration *filterConfig,
bool useGeneratorRegistry)
: KisLayer(image.data(), name, OPACITY_OPAQUE_U8),
KisNodeFilterInterface(filterConfig, useGeneratorRegistry),
m_d(new Private())
{
if (!selection)
initSelection();
else
setInternalSelection(selection);
m_d->paintDevice = new KisPaintDevice(this, image->colorSpace(), new KisDefaultBounds(image));
}
void rebuildLayerList(KisNodeSP layer = 0)
{
bool refreshingFromRoot = false;
if (!image)
{
layers.clear();
return;
}
if (layer == 0)
{
refreshingFromRoot = true;
layers.clear();
layer = image->rootLayer();
}
// implementation node: The root node is not a visible node, and so
// is never added to the list of layers
QList<KisNodeSP> children = layer->childNodes(layerClassNames(), KoProperties());
if (children.count() == 0)
return;
for(quint32 i = children.count(); i > 0; --i)
{
layers << children.at(i-1);
rebuildLayerList(children.at(i-1));
}
if (refreshingFromRoot)
refreshLayerMovementAbilities();
}
void CSVSaver::createTempImage(KisDocument* exportDoc)
{
exportDoc->setAutoSave(0);
exportDoc->setOutputMimeType("image/png");
exportDoc->setFileBatchMode(true);
KisImageWSP exportImage = new KisImage(exportDoc->createUndoStore(),
m_image->width(), m_image->height(), m_image->colorSpace(),
QString());
exportImage->setResolution(m_image->xRes(), m_image->yRes());
exportDoc->setCurrentImage(exportImage);
KisPaintLayer* paintLayer = new KisPaintLayer(exportImage, "paint device", OPACITY_OPAQUE_U8);
exportImage->addNode(paintLayer, exportImage->rootLayer(), KisLayerSP(0));
}
KisFigurePaintingToolHelper::KisFigurePaintingToolHelper(const KUndo2MagicString &name,
KisImageWSP image,
KisNodeSP currentNode,
KoCanvasResourceManager *resourceManager,
KisPainter::StrokeStyle strokeStyle,
KisPainter::FillStyle fillStyle)
{
m_strokesFacade = image.data();
m_resources =
new KisResourcesSnapshot(image,
currentNode,
resourceManager);
m_resources->setStrokeStyle(strokeStyle);
m_resources->setFillStyle(fillStyle);
PainterInfo *painterInfo = new PainterInfo();
KisStrokeStrategy *stroke =
new FreehandStrokeStrategy(m_resources->needsIndirectPainting(),
m_resources->indirectPaintingCompositeOp(),
m_resources, painterInfo, name);
m_strokeId = m_strokesFacade->startStroke(stroke);
}
void addPaintingJobs(KisImageWSP image, KisResourcesSnapshotSP resources) {
Q_UNUSED(resources);
image->addJob(strokeId(),
new KisFilterStrokeStrategy::
Data(QRect(100,100,100,100), true));
image->addJob(strokeId(),
new KisFilterStrokeStrategy::
Data(QRect(200,100,100,100), true));
image->addJob(strokeId(),
new KisFilterStrokeStrategy::
Data(QRect(100,200,100,100), true));
}
KisNodeSP KisKraLoader::loadFileLayer(const KoXmlElement& element, KisImageWSP image, const QString& name, quint32 opacity)
{
QString filename = element.attribute("source", QString());
if (filename.isNull()) return 0;
bool scale = (element.attribute("scale", "true") == "true");
int scalingMethod = element.attribute("scalingmethod", "-1").toInt();
if (scalingMethod < 0) {
if (scale) {
scalingMethod = KisFileLayer::ToImagePPI;
}
else {
scalingMethod = KisFileLayer::None;
}
}
QString documentPath;
if (m_d->document) {
documentPath = m_d->document->url().toLocalFile();
}
QFileInfo info(documentPath);
QString basePath = info.absolutePath();
QString fullPath = basePath + QDir::separator() + filename;
// Entering the event loop to show the messagebox will delete the image, so up the ref by one
image->ref();
if (!QFileInfo(fullPath).exists()) {
qApp->setOverrideCursor(Qt::ArrowCursor);
QString msg = i18nc(
"@info",
"The file associated to a file layer with the name \"%1\" is not found.<nl/><nl/>"
"Expected path:<nl/>"
"%2<nl/><nl/>"
"Do you want to locate it manually?", name, fullPath);
int result = QMessageBox::warning(0, i18nc("@title:window", "File not found"), msg, QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes);
if (result == QMessageBox::Yes) {
KoFileDialog dialog(0, KoFileDialog::OpenFile, "OpenDocument");
dialog.setMimeTypeFilters(KisImportExportManager::mimeFilter("application/x-krita", KisImportExportManager::Import));
dialog.setDefaultDir(basePath);
QString url = dialog.filename();
if (!QFileInfo(basePath).exists()) {
filename = url;
} else {
QDir d(basePath);
filename = d.relativeFilePath(url);
}
}
qApp->restoreOverrideCursor();
}
KisLayer *layer = new KisFileLayer(image, basePath, filename, (KisFileLayer::ScalingMethod)scalingMethod, name, opacity);
Q_CHECK_PTR(layer);
return layer;
}
void KisKraLoader::loadCompositions(const KoXmlElement& elem, KisImageWSP image)
{
KoXmlNode child;
for (child = elem.firstChild(); !child.isNull(); child = child.nextSibling()) {
KoXmlElement e = child.toElement();
QString name = e.attribute("name");
bool exportEnabled = e.attribute("exportEnabled", "1") == "0" ? false : true;
KisLayerComposition* composition = new KisLayerComposition(image, name);
composition->setExportEnabled(exportEnabled);
KoXmlNode value;
for (value = child.lastChild(); !value.isNull(); value = value.previousSibling()) {
KoXmlElement e = value.toElement();
QUuid uuid(e.attribute("uuid"));
bool visible = e.attribute("visible", "1") == "0" ? false : true;
composition->setVisible(uuid, visible);
bool collapsed = e.attribute("collapsed", "1") == "0" ? false : true;
composition->setCollapsed(uuid, collapsed);
}
image->addComposition(composition);
}
}
KisImageBuilder_Result CSVSaver::getLayer(CSVLayerRecord* layer, KisDocument* exportDoc, KisKeyframeSP keyframe, const QString &path, int frame, int idx)
{
//render to the temp layer
KisImageWSP image = exportDoc->image();
KisPaintDeviceSP device = image->rootLayer()->firstChild()->projection();
layer->channel->fetchFrame(keyframe, device);
QRect bounds = device->exactBounds();
if (bounds.isEmpty()) {
layer->last = ""; //empty frame
return KisImageBuilder_RESULT_OK;
}
layer->last = QString("frame%1-%2.png").arg(idx + 1,5,10,QChar('0')).arg(frame,5,10,QChar('0'));
QString filename = path;
filename.append(layer->last);
//save to PNG
KisSequentialConstIterator it(device, image->bounds());
const KoColorSpace* cs = device->colorSpace();
bool isThereAlpha = false;
do {
if (cs->opacityU8(it.oldRawData()) != OPACITY_OPAQUE_U8) {
isThereAlpha = true;
break;
}
} while (it.nextPixel());
if (!KisPNGConverter::isColorSpaceSupported(cs)) {
device = new KisPaintDevice(*device.data());
KUndo2Command *cmd= device->convertTo(KoColorSpaceRegistry::instance()->rgb8());
delete cmd;
}
KisPNGOptions options;
options.alpha = isThereAlpha;
options.interlace = false;
options.compression = 8;
options.tryToSaveAsIndexed = false;
options.transparencyFillColor = QColor(0,0,0);
options.saveSRGBProfile = true; //TVPaint can use only sRGB
options.forceSRGB = false;
KisPNGConverter kpc(exportDoc);
KisImageBuilder_Result result = kpc.buildFile(QUrl::fromLocalFile(filename), image->bounds(),
image->xRes(), image->yRes(), device,
image->beginAnnotations(), image->endAnnotations(),
options, (KisMetaData::Store* )0 );
return result;
}
void KisKraLoaderTest::testLoading()
{
KisDocument *doc = KisPart::instance()->createDocument();
doc->loadNativeFormat(QString(FILES_DATA_DIR) + QDir::separator() + "load_test.kra");
KisImageWSP image = doc->image();
image->lock();
QCOMPARE(image->nlayers(), 12);
QCOMPARE(doc->documentInfo()->aboutInfo("title"), QString("test image for loading"));
QCOMPARE(image->height(), 753);
QCOMPARE(image->width(), 1000);
QCOMPARE(image->colorSpace()->id(), KoColorSpaceRegistry::instance()->rgb8()->id());
KisNodeSP node = image->root()->firstChild();
QVERIFY(node);
QCOMPARE(node->name(), QString("Background"));
QVERIFY(node->inherits("KisPaintLayer"));
node = node->nextSibling();
QVERIFY(node);
QCOMPARE(node->name(), QString("Group 1"));
QVERIFY(node->inherits("KisGroupLayer"));
QCOMPARE((int) node->childCount(), 2);
delete doc;
}
KisImageResizeCommand::KisImageResizeCommand(KisImageWSP image,
const QSize& newSize)
: KUndo2Command(kundo2_i18n("Resize Image")),
m_image(image)
{
// do we really need a translatable name for the command?
m_sizeBefore = image->size();
m_sizeAfter = newSize;
}
void KisExperimentPaintOpSettings::paintOutline(const QPointF& pos, KisImageWSP image, QPainter &painter, OutlineMode _mode) const
{
if (_mode != CursorIsOutline) return;
qreal width = getInt(EXPERIMENT_START_SIZE); /* scale();*/
qreal height = getInt(EXPERIMENT_START_SIZE); /* scale();*/
painter.setPen(QColor(255,128,255));
painter.setCompositionMode(QPainter::RasterOp_SourceXorDestination);
painter.drawEllipse(image->pixelToDocument(QRectF(0, 0, width, height).translated(- QPoint(width * 0.5, height * 0.5))).translated(pos));
}
void KisRecordedFilterAction::play(KisNodeSP node, const KisPlayInfo& _info, KoUpdater* _updater) const
{
KisFilterConfiguration * kfc = d->configuration();
KisPaintDeviceSP dev = node->paintDevice();
KisLayerSP layer = dynamic_cast<KisLayer*>(node.data());
QRect r1 = dev->extent();
KisTransaction transaction(kundo2_i18n("Filter: \"%1\"", d->filter->name()), dev);
KisImageWSP image = _info.image();
r1 = r1.intersected(image->bounds());
if (layer && layer->selection()) {
r1 = r1.intersected(layer->selection()->selectedExactRect());
}
d->filter->process(dev, dev, layer->selection(), r1, kfc, _updater);
node->setDirty(r1);
transaction.commit(_info.undoAdapter());
}
