KisLayerManager Class Reference

#include <kis_layer_manager.h>

Inheritance diagram for KisLayerManager:

Public Member Functions
	KisLayerManager (KisViewManager *view)
void	setView (QPointer< KisView >view)
	~KisLayerManager () override

Private Slots
bool	activeLayerHasSelection ()
KisNodeSP	addAdjustmentLayer (KisNodeSP activeNode)
KisAdjustmentLayerSP	addAdjustmentLayer (KisNodeSP activeNode, const QString &name, KisFilterConfigurationSP filter, KisSelectionSP selection, KisProcessingApplicator *applicator)
KisNodeSP	addCloneLayer (KisNodeList nodes)
KisNodeSP	addFileLayer (KisNodeSP activeNode)
KisNodeSP	addGeneratorLayer (KisNodeSP activeNode)
KisGeneratorLayerSP	addGeneratorLayer (KisNodeSP activeNode, const QString &name, KisFilterConfigurationSP filter, KisSelectionSP selection, KisProcessingApplicator *applicator)
KisNodeSP	addGroupLayer (KisNodeSP activeNode)
KisLayerSP	addPaintLayer (KisNodeSP activeNode)
KisNodeSP	addShapeLayer (KisNodeSP activeNode)
void	changeCloneSource ()
void	convertGroupToAnimated ()
void	convertLayerToFileLayer (KisNodeSP source)
void	convertNodeToPaintLayer (KisNodeSP source)
void	copyLayerStyle ()
void	flattenImage ()
void	flattenLayer ()
void	imageResizeToActiveLayer ()
void	layerProperties ()
void	layerPropertiesDialogClosed ()
void	layerStyle ()
void	layersUpdated ()
void	mergeLayer ()
void	pasteLayerStyle ()
void	purgeUnusedImageData ()
void	saveGroupLayers ()
void	trimToImage ()

Private Member Functions
void	activateLayer (KisLayerSP layer)
KisPaintDeviceSP	activeDevice ()
KisLayerSP	activeLayer ()
void	addLayerCommon (KisNodeSP activeNode, KisNodeSP layer, bool updateImage=true, KisProcessingApplicator *applicator=0)
void	adjustLayerPosition (KisNodeSP node, KisNodeSP activeNode, KisNodeSP &parent, KisNodeSP &above)
void	setup (KisActionManager *actionManager)
void	updateGUI ()

Private Attributes
KisNodeCommandsAdapter *	m_commandsAdapter
KisAction *	m_convertGroupAnimated {0}
KisAction *	m_copyLayerStyle {0}
KisAction *	m_flattenLayer {0}
KisAction *	m_groupLayersSave {0}
KisAction *	m_imageFlatten {0}
KisAction *	m_imageMergeLayer {0}
KisAction *	m_imageResizeToLayer {0}
QPointer< KisView >	m_imageView {0}
bool	m_layerPropertiesDialogActive {false}
KisAction *	m_layerStyle {0}
KisAction *	m_pasteLayerStyle {0}
KisAction *	m_rasterizeLayer {0}
KisViewManager *	m_view

Friends
class	KisNodeManager

Detailed Description

KisLayerManager takes care of the gui around working with layers: adding, removing, editing. It also keeps track of the active layer for this view.

Definition at line 29 of file kis_layer_manager.h.

Constructor & Destructor Documentation

KisLayerManager()

KisLayerManager::KisLayerManager

(

KisViewManager *

view

)

Definition at line 104 of file kis_layer_manager.cc.

    : m_view(view)
    , m_commandsAdapter(new KisNodeCommandsAdapter(m_view))
 
{
}

~KisLayerManager()

KisLayerManager::~KisLayerManager ( )

override

Definition at line 111 of file kis_layer_manager.cc.

{
    delete m_commandsAdapter;
}

References m_commandsAdapter.

Member Function Documentation

activateLayer()

void KisLayerManager::activateLayer ( KisLayerSP layer )

private

Activate the specified layer. The layer may be 0.

Definition at line 137 of file kis_layer_manager.cc.

{
    if (m_imageView) {
        layersUpdated();
        if (layer) {
            m_view->canvasResourceProvider()->slotNodeActivated(layer.data());
        }
    }
}

References KisViewManager::canvasResourceProvider(), KisSharedPtr< T >::data(), layersUpdated(), m_imageView, m_view, and KisCanvasResourceProvider::slotNodeActivated().

activeDevice()

KisPaintDeviceSP KisLayerManager::activeDevice ( )

private

Definition at line 129 of file kis_layer_manager.cc.

{
    if (activeLayer()) {
        return activeLayer()->paintDevice();
    }
    return 0;
}

References activeLayer(), and KisBaseNode::paintDevice().

activeLayer()

KisLayerSP KisLayerManager::activeLayer ( )

private

Definition at line 121 of file kis_layer_manager.cc.

{
    if (m_imageView) {
        return m_imageView->currentLayer();
    }
    return 0;
}

References m_imageView.

activeLayerHasSelection

bool KisLayerManager::activeLayerHasSelection ( )

privateslot

Definition at line 1025 of file kis_layer_manager.cc.

{
    return (activeLayer()->selection() != 0);
}

References activeLayer().

addAdjustmentLayer [1/2]

KisNodeSP KisLayerManager::addAdjustmentLayer ( KisNodeSP activeNode )

privateslot

Definition at line 736 of file kis_layer_manager.cc.

{
    KisImageWSP image = m_view->image();
 
    KisSelectionSP selection = m_view->selection();
 
    KisProcessingApplicator applicator(image, 0, KisProcessingApplicator::NONE,
                                       KisImageSignalVector(),
                                       kundo2_i18n("Add Layer"));
 
 
    KisAdjustmentLayerSP adjl = addAdjustmentLayer(activeNode, QString(), 0, selection, &applicator);
    applicator.end();
    image->waitForDone(); // So that previewDevice doesn't end up empty and result in empty histograms
 
    KisPaintDeviceSP previewDevice = new KisPaintDevice(*adjl->original());
 
    KisDlgAdjustmentLayer dlg(adjl, adjl.data(), previewDevice, image->nextLayerName(i18n("Filter Layer")), i18n("New Filter Layer"), m_view, qApp->activeWindow());
    dlg.resize(dlg.minimumSizeHint());
 
    // ensure that the device may be free'd by the dialog
    // when it is not needed anymore
    previewDevice = 0;
 
    if (dlg.exec() != QDialog::Accepted || adjl->filter().isNull()) {
        // XXX: add messagebox warning if there's no filter set!
        m_commandsAdapter->undoLastCommand();
    } else {
        adjl->setName(dlg.layerName());
    }
 
    return adjl;
}

References addAdjustmentLayer(), KisSharedPtr< T >::data(), KisProcessingApplicator::end(), KisViewManager::image(), kundo2_i18n(), KisDlgAdjustmentLayer::layerName(), m_commandsAdapter, m_view, KoDialog::minimumSizeHint(), KisImage::nextLayerName(), KisProcessingApplicator::NONE, KisViewManager::selection(), KisNodeCommandsAdapter::undoLastCommand(), and KisImage::waitForDone().

addAdjustmentLayer [2/2]

KisAdjustmentLayerSP KisLayerManager::addAdjustmentLayer ( KisNodeSP activeNode, const QString & name, KisFilterConfigurationSP filter, KisSelectionSP selection, KisProcessingApplicator * applicator )

privateslot

Definition at line 770 of file kis_layer_manager.cc.

{
    KisImageWSP image = m_view->image();
    KisAdjustmentLayerSP layer = new KisAdjustmentLayer(image, name, filter ? filter->cloneWithResourcesSnapshot() : 0, selection);
    addLayerCommon(activeNode, layer, true, applicator);
 
    return layer;
}

References addLayerCommon(), KisViewManager::image(), and m_view.

addCloneLayer

KisNodeSP KisLayerManager::addCloneLayer ( KisNodeList nodes )

privateslot

Definition at line 705 of file kis_layer_manager.cc.

{
    KisImageWSP image = m_view->image();
 
    KisNodeList filteredNodes = KisLayerUtils::sortAndFilterMergeableInternalNodes(nodes, false);
    if (filteredNodes.isEmpty()) return KisNodeSP();
 
    KisNodeSP newAbove = filteredNodes.last();
 
    KisNodeSP node, lastClonedNode;
    Q_FOREACH (node, filteredNodes) {
        lastClonedNode = new KisCloneLayer(qobject_cast<KisLayer*>(node.data()), image.data(), image->nextLayerName( i18n("Clone Layer") ), OPACITY_OPAQUE_U8);
        addLayerCommon(newAbove, lastClonedNode, true, 0 );
    }
 
    return lastClonedNode;
}

References addLayerCommon(), KisSharedPtr< T >::data(), KisWeakSharedPtr< T >::data(), KisViewManager::image(), m_view, KisImage::nextLayerName(), OPACITY_OPAQUE_U8, and KisLayerUtils::sortAndFilterMergeableInternalNodes().

addFileLayer

KisNodeSP KisLayerManager::addFileLayer ( KisNodeSP activeNode )

privateslot

Definition at line 1030 of file kis_layer_manager.cc.

{
    QString basePath;
    QString path = m_view->document()->path();
    basePath = QFileInfo(path).absolutePath();
    KisImageWSP image = m_view->image();
 
    KisDlgFileLayer dlg(basePath, image->nextLayerName(i18n("File Layer")), m_view->mainWindow());
    dlg.resize(dlg.minimumSizeHint());
 
    if (dlg.exec() == QDialog::Accepted) {
        QString name = dlg.layerName();
        QString fileName = dlg.fileName();
 
        if(fileName.isEmpty()){
            QMessageBox::critical(m_view->mainWindow(), i18nc("@title:window", "Krita"), i18n("No file name specified"));
            return 0;
        }
 
        KisFileLayer::ScalingMethod scalingMethod = dlg.scaleToImageResolution();
        QString scalingFilter = dlg.scalingFilter();
        KisNodeSP node = new KisFileLayer(image, basePath, fileName, scalingMethod, scalingFilter, name, OPACITY_OPAQUE_U8);
        addLayerCommon(activeNode, node, true, 0);
        return node;
    }
    return 0;
}

References addLayerCommon(), KisViewManager::document(), KisDlgFileLayer::fileName(), KisViewManager::image(), KisDlgFileLayer::layerName(), m_view, KisViewManager::mainWindow(), KoDialog::minimumSizeHint(), KisImage::nextLayerName(), OPACITY_OPAQUE_U8, KisDocument::path(), KisDlgFileLayer::scaleToImageResolution(), and KisDlgFileLayer::scalingFilter().

addGeneratorLayer [1/2]

KisNodeSP KisLayerManager::addGeneratorLayer ( KisNodeSP activeNode )

privateslot

Definition at line 791 of file kis_layer_manager.cc.

{
    KisImageWSP image = m_view->image();
    KisSelectionSP selection = m_view->selection();
    QColor currentForeground = m_view->canvasResourceProvider()->fgColor().toQColor();
 
    KisProcessingApplicator applicator(image, 0, KisProcessingApplicator::NONE, KisImageSignalVector(), kundo2_i18n("Add Layer"));
 
    KisGeneratorLayerSP node = addGeneratorLayer(activeNode, QString(), nullptr, selection, &applicator);
 
    KisDlgGeneratorLayer dlg(image->nextLayerName(i18n("Fill Layer")), m_view, m_view->mainWindow(), node, nullptr, applicator.getStroke());
    KisFilterConfigurationSP defaultConfig = dlg.configuration();
    defaultConfig->setProperty("color", currentForeground);
    dlg.setConfiguration(defaultConfig);
 
    if (dlg.exec() == QDialog::Accepted) {
        applicator.applyCommand(new KisNodeRenameCommand(node, node->name(), dlg.layerName()));
        applicator.end();
        return node;
    }
    else {
        applicator.cancel();
        return nullptr;
    }
}

References addGeneratorLayer(), KisProcessingApplicator::applyCommand(), KisProcessingApplicator::cancel(), KisViewManager::canvasResourceProvider(), KisDlgGeneratorLayer::configuration(), KisProcessingApplicator::end(), KisCanvasResourceProvider::fgColor(), KisProcessingApplicator::getStroke(), KisViewManager::image(), kundo2_i18n(), KisDlgGeneratorLayer::layerName(), m_view, KisViewManager::mainWindow(), KisBaseNode::name(), KisImage::nextLayerName(), KisProcessingApplicator::NONE, KisViewManager::selection(), KisDlgGeneratorLayer::setConfiguration(), and KoColor::toQColor().

addGeneratorLayer [2/2]

KisGeneratorLayerSP KisLayerManager::addGeneratorLayer ( KisNodeSP activeNode, const QString & name, KisFilterConfigurationSP filter, KisSelectionSP selection, KisProcessingApplicator * applicator )

privateslot

Definition at line 782 of file kis_layer_manager.cc.

{
    KisImageWSP image = m_view->image();
    auto layer = new KisGeneratorLayer(image, name, filter, selection);
    addLayerCommon(activeNode, layer, true, applicator);
 
    return layer;
}

References addLayerCommon(), KisViewManager::image(), and m_view.

addGroupLayer

KisNodeSP KisLayerManager::addGroupLayer ( KisNodeSP activeNode )

privateslot

Definition at line 697 of file kis_layer_manager.cc.

{
    KisImageWSP image = m_view->image();
    KisGroupLayerSP group = new KisGroupLayer(image.data(), image->nextLayerName( i18nc("A group of layers", "Group") ), OPACITY_OPAQUE_U8);
    addLayerCommon(activeNode, group, false, 0);
    return group;
}

References addLayerCommon(), KisWeakSharedPtr< T >::data(), KisViewManager::image(), m_view, KisImage::nextLayerName(), and OPACITY_OPAQUE_U8.

addLayerCommon()

void KisLayerManager::addLayerCommon ( KisNodeSP activeNode, KisNodeSP layer, bool updateImage = true, KisProcessingApplicator * applicator = 0 )

private

Definition at line 658 of file kis_layer_manager.cc.

{
    KisNodeSP parent;
    KisNodeSP above;
    adjustLayerPosition(layer, activeNode, parent, above);
 
    KisGroupLayer *group = dynamic_cast<KisGroupLayer*>(parent.data());
 
    if (layer->inherits("KisGroupLayer") || layer->inherits("KisPaintLayer")) {
        const KoColorSpace *colorSpace = group->colorSpace();
 
        if (layer->inherits("KisGroupLayer")) {
            KisGroupLayer *newLayer = dynamic_cast<KisGroupLayer*>(layer.data());
            newLayer->resetCache(colorSpace);
        } else {
            KisPaintLayer *newLayer = qobject_cast<KisPaintLayer *>(layer.data());
            newLayer->paintDevice()->convertTo(colorSpace);
        }
    }
 
    const bool parentForceUpdate = group && !group->projectionIsValid();
    updateImage |= parentForceUpdate;
 
    m_commandsAdapter->addNodeAsync(layer, parent, above, updateImage, updateImage, applicator);
}

References KisNodeCommandsAdapter::addNodeAsync(), adjustLayerPosition(), KisGroupLayer::colorSpace(), KisPaintDevice::convertTo(), KisSharedPtr< T >::data(), m_commandsAdapter, KisPaintLayer::paintDevice, KisGroupLayer::projectionIsValid(), and KisGroupLayer::resetCache().

addPaintLayer

KisLayerSP KisLayerManager::addPaintLayer ( KisNodeSP activeNode )

privateslot

Definition at line 684 of file kis_layer_manager.cc.

{
    KisImageWSP image = m_view->image();    
    KisLayerSP layer = new KisPaintLayer(image.data(),  image->nextLayerName( i18n("Paint Layer") ), OPACITY_OPAQUE_U8, image->colorSpace());
 
    KisConfig cfg(true);
    layer->setPinnedToTimeline(cfg.autoPinLayersToTimeline());
 
    addLayerCommon(activeNode, layer, false, 0);
 
    return layer;
}

References addLayerCommon(), KisConfig::autoPinLayersToTimeline(), KisImage::colorSpace(), KisWeakSharedPtr< T >::data(), KisViewManager::image(), m_view, KisImage::nextLayerName(), OPACITY_OPAQUE_U8, and KisBaseNode::setPinnedToTimeline().

addShapeLayer

KisNodeSP KisLayerManager::addShapeLayer ( KisNodeSP activeNode )

privateslot

Definition at line 723 of file kis_layer_manager.cc.

{
    if (!m_view) return 0;
    if (!m_view->document()) return 0;
 
    KisImageWSP image = m_view->image();
    KisShapeLayerSP layer = new KisShapeLayer(m_view->document()->shapeController(), image.data(), image->nextLayerName(i18n("Vector Layer")), OPACITY_OPAQUE_U8);
 
    addLayerCommon(activeNode, layer, false, 0);
 
    return layer;
}

References addLayerCommon(), KisWeakSharedPtr< T >::data(), KisViewManager::document(), KisViewManager::image(), m_view, KisImage::nextLayerName(), OPACITY_OPAQUE_U8, and KisDocument::shapeController.

adjustLayerPosition()

void KisLayerManager::adjustLayerPosition ( KisNodeSP node, KisNodeSP activeNode, KisNodeSP & parent, KisNodeSP & above )

private

Definition at line 629 of file kis_layer_manager.cc.

{
    Q_ASSERT(activeNode);
 
    parent = activeNode;
    above = parent->lastChild();
 
    if (parent->inherits("KisGroupLayer") && parent->collapsed()) {
        above = parent;
        parent = parent->parent();
        return;
    }
 
    while (parent &&
           (!parent->allowAsChild(node) || !parent->isEditable(false))) {
 
        above = parent;
        parent = parent->parent();
    }
 
    if (!parent) {
        warnKrita << "KisLayerManager::adjustLayerPosition:"
                  << "No node accepted newly created node";
 
        parent = m_view->image()->root();
        above = parent->lastChild();
    }
}

References KisViewManager::image(), m_view, KisNodeFacade::root, and warnKrita.

changeCloneSource

void KisLayerManager::changeCloneSource ( )

privateslot

Definition at line 399 of file kis_layer_manager.cc.

{
    QList<KisNodeSP> selectedNodes = m_view->nodeManager()->selectedNodes();
    if (selectedNodes.isEmpty()) {
        return;
    }
 
    QList<KisCloneLayerSP> cloneLayers;
    KisNodeSP node;
    Q_FOREACH (node, selectedNodes) {
        KisCloneLayerSP cloneLayer(qobject_cast<KisCloneLayer *>(node.data()));
        if (cloneLayer) {
            cloneLayers << cloneLayer;
        }
    }
 
    if (cloneLayers.isEmpty()) {
        return;
    }
 
    if (!m_view->nodeManager()->canModifyLayers(implicitCastList<KisNodeSP>(cloneLayers))) return;
 
    KisDlgChangeCloneSource *dialog = new KisDlgChangeCloneSource(cloneLayers, m_view);
    dialog->setCaption(i18n("Change Clone Layer"));
    dialog->resize(dialog->minimumSizeHint());
    dialog->setAttribute(Qt::WA_DeleteOnClose);
    Qt::WindowFlags flags = dialog->windowFlags();
    dialog->setWindowFlags(flags | Qt::Tool | Qt::Dialog);
    dialog->show();
    dialog->activateWindow();
}

References KisNodeManager::canModifyLayers(), KisSharedPtr< T >::data(), m_view, KisViewManager::nodeManager(), and KisNodeManager::selectedNodes().

convertGroupToAnimated

void KisLayerManager::convertGroupToAnimated ( )

privateslot

Definition at line 509 of file kis_layer_manager.cc.

{
    KisGroupLayerSP targetGroup = dynamic_cast<KisGroupLayer*>(activeLayer().data());
    if (targetGroup.isNull()) {
        // Try containing group, if it exists...
        KisNodeSP parent = activeLayer()->parent();
        if (!parent->parent()) return; // watch out for the root node!
        targetGroup = dynamic_cast<KisGroupLayer*>(parent.data());
    }
 
    if (targetGroup.isNull()) return;
    if (!m_view->nodeManager()->canModifyLayer(targetGroup)) return;
 
    KisPaintLayerSP animatedLayer = new KisPaintLayer(m_view->image(), targetGroup->name(), OPACITY_OPAQUE_U8);
    animatedLayer->enableAnimation();
    KisRasterKeyframeChannel *keyframeChannel = dynamic_cast<KisRasterKeyframeChannel*>(
                animatedLayer->getKeyframeChannel(KisKeyframeChannel::Raster.id(), true));
    KIS_ASSERT_RECOVER_RETURN(keyframeChannel);
 
    KisNodeSP childNode = targetGroup->firstChild();
    int time = 0;
    while (childNode) {
        keyframeChannel->importFrame(time, childNode->projection(), NULL);
        time++;
 
        childNode = childNode->nextSibling();
    }
 
    m_commandsAdapter->beginMacro(kundo2_i18n("Convert Group to Animated Layer"));
    m_commandsAdapter->addNode(animatedLayer, targetGroup->parent(), targetGroup);
    m_commandsAdapter->removeNode(targetGroup);
    m_commandsAdapter->endMacro();
}

References activeLayer(), KisNodeCommandsAdapter::addNode(), KisNodeCommandsAdapter::beginMacro(), KisNodeManager::canModifyLayer(), KisSharedPtr< T >::data(), KisBaseNode::enableAnimation(), KisNodeCommandsAdapter::endMacro(), KisNode::firstChild(), KisBaseNode::getKeyframeChannel(), KisViewManager::image(), KisRasterKeyframeChannel::importFrame(), KisSharedPtr< T >::isNull(), KIS_ASSERT_RECOVER_RETURN, kundo2_i18n(), m_commandsAdapter, m_view, KisBaseNode::name(), KisNode::nextSibling(), KisViewManager::nodeManager(), OPACITY_OPAQUE_U8, KisNode::parent, KisBaseNode::projection(), KisKeyframeChannel::Raster, and KisNodeCommandsAdapter::removeNode().

convertLayerToFileLayer

void KisLayerManager::convertLayerToFileLayer ( KisNodeSP source )

privateslot

Definition at line 543 of file kis_layer_manager.cc.

{
    KisImageSP image = m_view->image();
    if (!image) return;
 
    // this precondition must be checked at higher level
    KIS_SAFE_ASSERT_RECOVER_RETURN(source->isEditable(false));
 
    QStringList listMimeFilter = KisImportExportManager::supportedMimeTypes(KisImportExportManager::Export);
 
    KoDialog dlg;
    QWidget *page = new QWidget(&dlg);
    dlg.setMainWidget(page);
    QBoxLayout *layout = new QVBoxLayout(page);
    dlg.setWindowTitle(i18n("Save layers to..."));
    QLabel *lbl = new QLabel(i18n("Choose the location where the layer will be saved to. The new file layer will then reference this location."));
    lbl->setWordWrap(true);
    layout->addWidget(lbl);
    KisFileNameRequester *urlRequester = new KisFileNameRequester(page);
    urlRequester->setMode(KoFileDialog::SaveFile);
    urlRequester->setMimeTypeFilters(listMimeFilter);
    urlRequester->setFileName(m_view->document()->path());
    if (!m_view->document()->path().isEmpty()) {
        QFileInfo location = QFileInfo(m_view->document()->path());
        location.setFile(location.dir(), location.completeBaseName() + "_" + source->name() + ".png");
        urlRequester->setFileName(location.absoluteFilePath());
    }
    else {
        const QFileInfo location = QFileInfo(QStandardPaths::writableLocation(QStandardPaths::HomeLocation));
        const QString proposedFileName = QDir(location.absoluteFilePath()).absoluteFilePath(source->name() + ".png");
        urlRequester->setFileName(proposedFileName);
    }
 
    layout->addWidget(urlRequester);
    if (!dlg.exec()) return;
 
    QString path = urlRequester->fileName();
 
    if (path.isEmpty()) return;
 
    QFileInfo f(path);
 
    QString mimeType= KisMimeDatabase::mimeTypeForFile(f.fileName());
    if (mimeType.isEmpty()) {
        mimeType = "image/png";
    }
    QScopedPointer<KisDocument> doc(KisPart::instance()->createDocument());
 
    QRect bounds = source->exactBounds();
    if (bounds.isEmpty()) {
        bounds = image->bounds();
    }
    KisImageSP dst = new KisImage(doc->createUndoStore(),
                                  image->width(),
                                  image->height(),
                                  image->projection()->compositionSourceColorSpace(),
                                  source->name());
    dst->setResolution(image->xRes(), image->yRes());
    doc->setFileBatchMode(false);
    doc->setCurrentImage(dst);
    KisNodeSP node = source->clone();
    dst->addNode(node);
    dst->initialRefreshGraph();
    dst->cropImage(bounds);
    dst->waitForDone();
 
    bool r = doc->exportDocumentSync(path, mimeType.toLatin1());
    if (!r) {
 
        qWarning() << "Converting layer to file layer. path:"<< path << "gave errors" << doc->errorMessage();
    } else {
        QString basePath = QFileInfo(m_view->document()->path()).absolutePath();
        QString relativePath = QDir(basePath).relativeFilePath(path);
        KisFileLayer *fileLayer = new KisFileLayer(image, basePath, relativePath, KisFileLayer::None, "Bicubic", source->name(), OPACITY_OPAQUE_U8);
        fileLayer->setX(bounds.x());
        fileLayer->setY(bounds.y());
        KisNodeSP dstParent = source->parent();
        KisNodeSP dstAboveThis = source->prevSibling();
        m_commandsAdapter->beginMacro(kundo2_i18n("Convert to a file layer"));
        m_commandsAdapter->removeNode(source);
        m_commandsAdapter->addNode(fileLayer, dstParent, dstAboveThis);
        m_commandsAdapter->endMacro();
    }
    doc->closePath(false);
}

References KisNodeCommandsAdapter::addNode(), KisNodeFacade::addNode(), KisNodeCommandsAdapter::beginMacro(), KisImage::bounds(), bounds, KisPaintDevice::compositionSourceColorSpace(), createDocument(), KisImage::cropImage(), KisViewManager::document(), KisNodeCommandsAdapter::endMacro(), KisImportExportManager::Export, KisFileNameRequester::fileName(), KisImage::height(), KisViewManager::image(), KisImage::initialRefreshGraph(), KisPart::instance(), KIS_SAFE_ASSERT_RECOVER_RETURN, kundo2_i18n(), m_commandsAdapter, m_view, KisMimeDatabase::mimeTypeForFile(), KisFileLayer::None, OPACITY_OPAQUE_U8, KisDocument::path(), KisImage::projection(), KisNodeCommandsAdapter::removeNode(), KoFileDialog::SaveFile, KisFileNameRequester::setFileName(), KoDialog::setMainWidget(), KisFileNameRequester::setMimeTypeFilters(), KisFileNameRequester::setMode(), KisImage::setResolution(), KisLayer::setX(), KisLayer::setY(), source(), KisImportExportManager::supportedMimeTypes(), KisImage::waitForDone(), KisImage::width(), KisImage::xRes(), and KisImage::yRes().

convertNodeToPaintLayer

void KisLayerManager::convertNodeToPaintLayer ( KisNodeSP source )

privateslot

Definition at line 492 of file kis_layer_manager.cc.

{
    KisImageWSP image = m_view->image();
    if (!image) return;
 
    // this precondition must be checked at higher level
    KIS_SAFE_ASSERT_RECOVER_RETURN(source->isEditable(false));
 
    KisLayer *srcLayer = qobject_cast<KisLayer*>(source.data());
    if (srcLayer && (srcLayer->inherits("KisGroupLayer") || srcLayer->layerStyle() || srcLayer->childCount() > 0)) {
        image->flattenLayer(srcLayer);
        return;
    }
 
    (void) KisLayerUtils::convertToPaintLayer(image, source);
}

References KisNode::childCount(), KisLayerUtils::convertToPaintLayer(), KisImage::flattenLayer(), KisViewManager::image(), KIS_SAFE_ASSERT_RECOVER_RETURN, KisLayer::layerStyle, m_view, source(), and void().

copyLayerStyle

void KisLayerManager::copyLayerStyle ( )

privateslot

Definition at line 431 of file kis_layer_manager.cc.

{
    KisImageSP image = m_view->image();
    if (!image) return;
 
    KisLayerSP layer = activeLayer();
    if (!layer) return;
 
    KisPSDLayerStyleSP layerStyle = layer->layerStyle();
    if (!layerStyle) return;
 
    KisAslLayerStyleSerializer serializer;
    serializer.setStyles(QVector<KisPSDLayerStyleSP>() << layerStyle);
    QString psdxml = serializer.formPsdXmlDocument().toString();
 
    if (!psdxml.isEmpty()) {
        QMimeData *mimeData = new QMimeData;
 
        mimeData->setText(psdxml);
        mimeData->setData("application/x-krita-layer-style", psdxml.toUtf8());
 
        QGuiApplication::clipboard()->setMimeData(mimeData);
    }
}

References activeLayer(), KisAslLayerStyleSerializer::formPsdXmlDocument(), KisViewManager::image(), KisLayer::layerStyle, layerStyle(), m_view, and KisAslLayerStyleSerializer::setStyles().

flattenImage

void KisLayerManager::flattenImage ( )

privateslot

Definition at line 817 of file kis_layer_manager.cc.

{
    KisImageSP image = m_view->image();
 
    if (!m_view->blockUntilOperationsFinished(image)) return;
 
    if (image) {
        bool doIt = true;
 
        if (image->nHiddenLayers() > 0) {
            int answer = QMessageBox::warning(m_view->mainWindow(),
                                              i18nc("@title:window", "Flatten Image"),
                                              i18n("The image contains hidden layers that will be lost. Do you want to flatten the image?"),
                                              QMessageBox::Yes | QMessageBox::No,
                                              QMessageBox::No);
 
            if (answer != QMessageBox::Yes) {
                doIt = false;
            }
        }
 
        if (doIt) {
            image->flatten(m_view->activeNode());
        }
    }
}

References KisViewManager::activeNode(), KisViewManager::blockUntilOperationsFinished(), KisImage::flatten(), KisViewManager::image(), m_view, KisViewManager::mainWindow(), and KisImage::nHiddenLayers().

flattenLayer

void KisLayerManager::flattenLayer ( )

privateslot

Definition at line 956 of file kis_layer_manager.cc.

{
    KisImageSP image = m_view->image();
    if (!image) return;
 
    KisLayerSP layer = activeLayer();
    if (!layer) return;
 
    if (!m_view->blockUntilOperationsFinished(image)) return;
    if (!m_view->nodeManager()->canModifyLayer(layer)) return;
 
    convertNodeToPaintLayer(layer);
    m_view->updateGUI();
}

References activeLayer(), KisViewManager::blockUntilOperationsFinished(), KisNodeManager::canModifyLayer(), convertNodeToPaintLayer(), KisViewManager::image(), m_view, KisViewManager::nodeManager(), and KisViewManager::updateGUI().

imageResizeToActiveLayer

void KisLayerManager::imageResizeToActiveLayer ( )

privateslot

Definition at line 207 of file kis_layer_manager.cc.

{
    KisLayerSP layer;
    KisImageWSP image = m_view->image();
 
    if (image && (layer = activeLayer())) {
        QRect cropRect = layer->projection()->nonDefaultPixelArea();
        if (!cropRect.isEmpty()) {
            image->cropImage(cropRect);
        } else {
            m_view->showFloatingMessage(
                        i18nc("floating message in layer manager",
                              "Layer is empty "),
                        QIcon(), 2000, KisFloatingMessage::Low);
        }
    }
}

References activeLayer(), KisImage::cropImage(), KisViewManager::image(), KisFloatingMessage::Low, m_view, KisPaintDevice::nonDefaultPixelArea(), KisLayer::projection(), and KisViewManager::showFloatingMessage().

layerProperties

void KisLayerManager::layerProperties ( )

privateslot

Definition at line 241 of file kis_layer_manager.cc.

{
    if (!m_view) return;
    if (!m_view->document()) return;
 
    // For non-modal dialogs, only allow one instance of the dialog to exist.
    // Modal dialogs won't set this.
    if (m_layerPropertiesDialogActive) return;
 
    KisLayerSP layer = activeLayer();
    if (!layer) return;
 
    const QList<KisNodeSP> selectedNodes = m_view->nodeManager()->selectedNodes();
    const bool multipleLayersSelected = selectedNodes.size() > 1;
 
    if (!m_view->nodeManager()->canModifyLayers(selectedNodes)) return;
 
    KisAdjustmentLayerSP adjustmentLayer = KisAdjustmentLayerSP(dynamic_cast<KisAdjustmentLayer*>(layer.data()));
    KisGeneratorLayerSP generatorLayer = KisGeneratorLayerSP(dynamic_cast<KisGeneratorLayer*>(layer.data()));
    KisFileLayerSP fileLayer = KisFileLayerSP(dynamic_cast<KisFileLayer*>(layer.data()));
 
    if (adjustmentLayer && !multipleLayersSelected) {
        KisPaintDeviceSP dev = adjustmentLayer->projection();
 
        KisDlgAdjustmentLayer dlg(adjustmentLayer, adjustmentLayer.data(), dev,
                                  adjustmentLayer->name(), i18n("Filter Layer Properties"),
                                  m_view, m_view->mainWindow(), adjustmentLayer->filter());
        dlg.resize(dlg.minimumSizeHint());
 
        KisFilterConfigurationSP configBefore(adjustmentLayer->filter());
        KIS_ASSERT_RECOVER_RETURN(configBefore);
        QString xmlBefore = configBefore->toXML();
 
        if (dlg.exec() == QDialog::Accepted) {
            KUndo2Command *cmd = nullptr;
 
            KisFilterConfigurationSP configAfter(dlg.filterConfiguration());
            Q_ASSERT(configAfter);
            QString xmlAfter = configAfter->toXML();
 
            if(xmlBefore != xmlAfter) {
                cmd = KisCommandUtils::composeCommands(cmd,
                    new KisChangeFilterCmd(adjustmentLayer,
                                           configBefore->cloneWithResourcesSnapshot(),
                                           configAfter->cloneWithResourcesSnapshot()));
            }
 
            if (adjustmentLayer->name() != dlg.layerName()) {
                cmd = KisCommandUtils::composeCommands(cmd,
                    new KisNodeRenameCommand(adjustmentLayer,
                                             adjustmentLayer->name(),
                                             dlg.layerName()));
            }
 
            if (cmd) {
                m_view->undoAdapter()->addCommand(cmd);
            }
        }
        else {
            KisFilterConfigurationSP configAfter(dlg.filterConfiguration());
            Q_ASSERT(configAfter);
            QString xmlAfter = configAfter->toXML();
 
            if(xmlBefore != xmlAfter) {
                adjustmentLayer->setFilter(configBefore->cloneWithResourcesSnapshot());
                adjustmentLayer->setDirty();
            }
        }
    }
    else if (fileLayer && !multipleLayersSelected){
        QString basePath = QFileInfo(m_view->document()->path()).absolutePath();
        QString fileNameOld = fileLayer->fileName();
        KisFileLayer::ScalingMethod scalingMethodOld = fileLayer->scalingMethod();
        QString scalingFilterOld = fileLayer->scalingFilter();
        KisDlgFileLayer dlg(basePath, fileLayer->name(), m_view->mainWindow());
        dlg.setCaption(i18n("File Layer Properties"));
        dlg.setFileName(fileNameOld);
        dlg.setScalingMethod(scalingMethodOld);
        dlg.setScalingFilter(scalingFilterOld);
 
        if (dlg.exec() == QDialog::Accepted) {
            const QString fileNameNew = dlg.fileName();
            KisFileLayer::ScalingMethod scalingMethodNew = dlg.scaleToImageResolution();
            QString scalingFilterNew = dlg.scalingFilter();
 
            if(fileNameNew.isEmpty()){
                QMessageBox::critical(m_view->mainWindow(), i18nc("@title:window", "Krita"), i18n("No file name specified"));
                return;
            }
 
            KUndo2Command *cmd = nullptr;
 
            if (fileNameOld != fileNameNew || scalingMethodOld != scalingMethodNew
                || scalingFilterOld != scalingFilterNew) {
 
                cmd = KisCommandUtils::composeCommands(cmd,
                    new KisChangeFileLayerCmd(fileLayer,
                                                basePath,
                                                fileNameOld,
                                                scalingMethodOld,
                                                scalingFilterOld,
                                                basePath,
                                                fileNameNew,
                                                scalingMethodNew,
                                                scalingFilterNew));
            }
 
            if (fileLayer->name() != dlg.layerName()) {
                cmd = KisCommandUtils::composeCommands(cmd,
                    new KisNodeRenameCommand(fileLayer, fileLayer->name(), dlg.layerName()));
            }
 
            if (cmd) {
                m_view->undoAdapter()->addCommand(cmd);
            }
        }
    } else {
        QDialog* dlg = nullptr;
 
        if (generatorLayer && !multipleLayersSelected) {
            KisFilterConfigurationSP configBefore(generatorLayer->filter());
            Q_ASSERT(configBefore);
 
            auto* genDlg = new KisDlgGeneratorLayer(generatorLayer->name(), m_view, m_view->canvas(), generatorLayer, configBefore, KisStrokeId());
            genDlg->setWindowTitle(i18n("Fill Layer Properties"));
            genDlg->setConfiguration(configBefore.data());
 
            dlg = genDlg;
        }
 
        // Handle these layer(s) as normal painting layer, vector layer, or group layer
        if (!dlg) {
            dlg = new KisDlgLayerProperties(selectedNodes, m_view, m_view->canvas());
        }
 
        dlg->resize(dlg->minimumSizeHint());
        dlg->setAttribute(Qt::WA_DeleteOnClose);
 
        const Qt::WindowFlags flags = dlg->windowFlags();
#ifdef Q_OS_ANDROID
        // a Qt::Tool window seems incapable of receiving keyboard focus
        dlg->setWindowFlags(flags | Qt::Dialog);
#else
        dlg->setWindowFlags(flags | Qt::Tool | Qt::Dialog);
#endif
        connect(dlg, SIGNAL(destroyed()), this, SLOT(layerPropertiesDialogClosed()));
        m_layerPropertiesDialogActive = true;
 
        dlg->show();
        dlg->activateWindow();
    }
}

References activeLayer(), KisUndoAdapter::addCommand(), KisNodeManager::canModifyLayers(), KisViewManager::canvas(), KisCommandUtils::composeCommands(), KisSharedPtr< T >::data(), KisViewManager::document(), KisDlgFileLayer::fileName(), KisFileLayer::fileName(), KisNodeFilterInterface::filter(), KisDlgAdjustmentLayer::filterConfiguration(), KIS_ASSERT_RECOVER_RETURN, KisDlgAdjustmentLayer::layerName(), KisDlgFileLayer::layerName(), layerPropertiesDialogClosed(), m_layerPropertiesDialogActive, m_view, KisViewManager::mainWindow(), KoDialog::minimumSizeHint(), KisBaseNode::name(), KisViewManager::nodeManager(), KisDocument::path(), KisDlgFileLayer::scaleToImageResolution(), KisDlgFileLayer::scalingFilter(), KisFileLayer::scalingFilter(), KisFileLayer::scalingMethod(), KisNodeManager::selectedNodes(), KoDialog::setCaption(), KisDlgFileLayer::setFileName(), KisDlgFileLayer::setScalingFilter(), KisDlgFileLayer::setScalingMethod(), and KisViewManager::undoAdapter().

layerPropertiesDialogClosed

void KisLayerManager::layerPropertiesDialogClosed ( )

privateslot

Definition at line 394 of file kis_layer_manager.cc.

{
    m_layerPropertiesDialogActive = false;
}

References m_layerPropertiesDialogActive.

layerStyle

void KisLayerManager::layerStyle ( )

privateslot

Definition at line 1066 of file kis_layer_manager.cc.

{
    KisImageWSP image = m_view->image();
    if (!image) return;
 
    KisLayerSP layer = activeLayer();
    if (!layer) return;
 
    if (!m_view->blockUntilOperationsFinished(image)) return;
    if (!m_view->nodeManager()->canModifyLayer(layer)) return;
 
    KoCanvasResourcesInterfaceSP canvasResourcesInterface = m_view->canvasBase()->resourceManager()->canvasResourcesInterface();
 
    KisPSDLayerStyleSP oldStyle;
    if (layer->layerStyle()) {
        oldStyle = layer->layerStyle()->clone().dynamicCast<KisPSDLayerStyle>();
 
    } else {
        oldStyle = toQShared(new KisPSDLayerStyle("", KisGlobalResourcesInterface::instance()))
                ->cloneWithResourcesSnapshot(KisGlobalResourcesInterface::instance(),
                                             canvasResourcesInterface);
    }
 
    KisPSDLayerStyleSP newStyle = oldStyle->clone().dynamicCast<KisPSDLayerStyle>();
    // We want to also change the UUID, else it might be considered the same style after save and won't load correctly
    newStyle->setUuid(QUuid::createUuid());
 
    KisDlgLayerStyle dlg(newStyle, m_view->canvasResourceProvider());
 
    std::function<void ()> updateCall(std::bind(updateLayerStyles, layer, &dlg, canvasResourcesInterface));
    SignalToFunctionProxy proxy(updateCall);
    connect(&dlg, SIGNAL(configChanged()), &proxy, SLOT(start()));
 
    if (dlg.exec() == QDialog::Accepted) {
        KisPSDLayerStyleSP newStyle =
            dlg.style()->cloneWithResourcesSnapshot(KisGlobalResourcesInterface::instance(),
                                                    canvasResourcesInterface);
 
        KUndo2CommandSP command = toQShared(
                    new KisSetLayerStyleCommand(layer, oldStyle, newStyle));
 
        image->postExecutionUndoAdapter()->addCommand(command);
    }
}

References activeLayer(), KisPostExecutionUndoAdapter::addCommand(), KisViewManager::blockUntilOperationsFinished(), KisNodeManager::canModifyLayer(), KisViewManager::canvasBase(), KisViewManager::canvasResourceProvider(), KisViewManager::image(), KisGlobalResourcesInterface::instance(), KisLayer::layerStyle, m_view, KisViewManager::nodeManager(), KisImage::postExecutionUndoAdapter(), KoCanvasBase::resourceManager, KisDlgLayerStyle::style(), toQShared(), updateLayerStyles(), and void().

layersUpdated

void KisLayerManager::layersUpdated ( )

privateslot

Definition at line 971 of file kis_layer_manager.cc.

{
    KisLayerSP layer = activeLayer();
    if (!layer) return;
 
    m_view->updateGUI();
}

References activeLayer(), m_view, and KisViewManager::updateGUI().

mergeLayer

void KisLayerManager::mergeLayer ( )

privateslot

Definition at line 883 of file kis_layer_manager.cc.

{
    KisImageSP image = m_view->image();
    if (!image) return;
 
    KisLayerSP layer = activeLayer();
    if (!layer) return;
 
    if (!m_view->blockUntilOperationsFinished(image)) return;
 
    QList<KisNodeSP> selectedNodes = m_view->nodeManager()->selectedNodes();
 
    // check if all the layers are a part of a locked group
    bool hasEditableLayer = false;
    Q_FOREACH (KisNodeSP node, selectedNodes) {
        if (node->isEditable(false)) {
            hasEditableLayer = true;
            break;
        }
    }
 
    if (!hasEditableLayer) {
        m_view->showFloatingMessage(
                    i18ncp("floating message in layer manager",
                          "Layer is locked", "Layers are locked", selectedNodes.size()),
                    QIcon(), 2000, KisFloatingMessage::Low);
        return;
    }
 
    if (selectedNodes.size() > 1) {
        image->mergeMultipleLayers(selectedNodes, m_view->activeNode());
    }
 
    else if (tryMergeSelectionMasks(m_view->activeNode(), image)) {
        // already done!
    } else if (tryFlattenGroupLayer(m_view->activeNode(), image)) {
        // already done!
    } else {
 
        if (!layer->prevSibling()) return;
        KisLayer *prevLayer = qobject_cast<KisLayer*>(layer->prevSibling().data());
        if (!prevLayer) return;
 
        if (prevLayer->userLocked()) {
            m_view->showFloatingMessage(
                        i18nc("floating message in layer manager when previous layer is locked",
                              "Layer is locked"),
                        QIcon(), 2000, KisFloatingMessage::Low);
        } else {
            const KisMetaData::MergeStrategy* strategy = nullptr;
 
            if (layer->metaData()->isEmpty() && prevLayer->metaData()->isEmpty()) {
                strategy = KisMetaData::MergeStrategyRegistry::instance()->get("Drop");
            }
            else {
                strategy = KisMetaDataMergeStrategyChooserWidget::showDialog(m_view->mainWindow());
            }
 
            if (!strategy) return;
 
            if (!layer->isAnimated() && prevLayer->isAnimated()) {
                m_view->showFloatingMessage(
                            i18nc("floating message in layer manager when trying to merge a non-animated layer into an animated one",
                                  "Non-animated layer is merged into the current frame. To merge it into the whole clip, create at least one frame"),
                            QIcon(), 5000, KisFloatingMessage::Medium);
            }
            image->mergeDown(layer, strategy);
        }
    }
 
    m_view->updateGUI();
}

References activeLayer(), KisViewManager::activeNode(), KisViewManager::blockUntilOperationsFinished(), KisSharedPtr< T >::data(), KoGenericRegistry< T >::get(), KisViewManager::image(), KisMetaData::MergeStrategyRegistry::instance(), KisBaseNode::isAnimated(), KisBaseNode::isEditable(), KisMetaData::Store::isEmpty(), KisFloatingMessage::Low, m_view, KisViewManager::mainWindow(), KisFloatingMessage::Medium, KisImage::mergeDown(), KisImage::mergeMultipleLayers(), KisLayer::metaData(), KisViewManager::nodeManager(), KisNode::prevSibling(), KisNodeManager::selectedNodes(), KisMetaDataMergeStrategyChooserWidget::showDialog(), KisViewManager::showFloatingMessage(), tryFlattenGroupLayer(), tryMergeSelectionMasks(), KisViewManager::updateGUI(), and KisBaseNode::userLocked().

pasteLayerStyle

void KisLayerManager::pasteLayerStyle ( )

privateslot

Definition at line 456 of file kis_layer_manager.cc.

{
    KisImageSP image = m_view->image();
    if (!image) return;
 
    KisLayerSP layer = activeLayer();
    if (!layer) return;
 
    QString aslXml;
 
    if (KisClipboard::instance()->hasLayerStyles()) {
        aslXml = QString::fromUtf8(QGuiApplication::clipboard()->mimeData()->data("application/x-krita-layer-style"));
    } else {
        aslXml = QGuiApplication::clipboard()->text();
    }
 
    if (aslXml.isEmpty()) return;
 
    QDomDocument aslDoc;
    if (!aslDoc.setContent(aslXml)) return;
 
    KisAslLayerStyleSerializer serializer;
    serializer.registerPSDPattern(aslDoc);
    serializer.readFromPSDXML(aslDoc);
 
    if (serializer.styles().size() != 1) return;
 
    KisPSDLayerStyleSP newStyle = serializer.styles().first()->cloneWithResourcesSnapshot(
        KisGlobalResourcesInterface::instance(),
        m_view->canvasBase()->resourceManager()->canvasResourcesInterface());
    KUndo2Command *cmd = new KisSetLayerStyleCommand(layer, layer->layerStyle(), newStyle);
 
    KisProcessingApplicator::runSingleCommandStroke(image, cmd);
    image->waitForDone();
}

References activeLayer(), KisViewManager::canvasBase(), KisViewManager::image(), KisGlobalResourcesInterface::instance(), KisClipboard::instance(), KisLayer::layerStyle, m_view, KisAslLayerStyleSerializer::readFromPSDXML(), KisAslLayerStyleSerializer::registerPSDPattern(), KoCanvasBase::resourceManager, KisProcessingApplicator::runSingleCommandStroke(), KisAslLayerStyleSerializer::styles(), and KisImage::waitForDone().

purgeUnusedImageData

void KisLayerManager::purgeUnusedImageData ( )

privateslot

Definition at line 233 of file kis_layer_manager.cc.

{
    KisImageWSP image = m_view->image();
    if (image) {
        image->purgeUnusedData(false);
    }
}

References KisViewManager::image(), m_view, and KisImage::purgeUnusedData().

saveGroupLayers

void KisLayerManager::saveGroupLayers ( )

privateslot

Definition at line 979 of file kis_layer_manager.cc.

{
    QStringList listMimeFilter = KisImportExportManager::supportedMimeTypes(KisImportExportManager::Export);
 
    KoDialog dlg;
    QWidget *page = new QWidget(&dlg);
    dlg.setMainWidget(page);
    QBoxLayout *layout = new QVBoxLayout(page);
 
    KisFileNameRequester *urlRequester = new KisFileNameRequester(page);
    urlRequester->setMode(KoFileDialog::SaveFile);
    urlRequester->setStartDir(QFileInfo(m_view->document()->path()).absolutePath());
    urlRequester->setMimeTypeFilters(listMimeFilter);
    urlRequester->setFileName(m_view->document()->path());
    layout->addWidget(urlRequester);
 
    QCheckBox *chkInvisible = new QCheckBox(i18n("Convert Invisible Groups"), page);
    chkInvisible->setChecked(false);
    layout->addWidget(chkInvisible);
    QCheckBox *chkDepth = new QCheckBox(i18n("Export Only Toplevel Groups"), page);
    chkDepth->setChecked(true);
    layout->addWidget(chkDepth);
 
    if (!dlg.exec()) return;
 
    QString path = urlRequester->fileName();
 
    if (path.isEmpty()) return;
 
    QFileInfo f(path);
 
    QString mimeType= KisMimeDatabase::mimeTypeForFile(f.fileName(), false);
    if (mimeType.isEmpty()) {
        mimeType = "image/png";
    }
    QString extension = KisMimeDatabase::suffixesForMimeType(mimeType).first();
    QString basename = f.completeBaseName();
 
    KisImageSP image = m_view->image();
    if (!image) return;
 
    KisSaveGroupVisitor v(image, chkInvisible->isChecked(), chkDepth->isChecked(), f.absolutePath(), basename, extension, mimeType);
    image->rootLayer()->accept(v);
 
}

References KisGroupLayer::accept(), KisViewManager::document(), KisImportExportManager::Export, KisFileNameRequester::fileName(), KisViewManager::image(), m_view, KisMimeDatabase::mimeTypeForFile(), KisDocument::path(), KisImage::rootLayer(), KoFileDialog::SaveFile, KisFileNameRequester::setFileName(), KoDialog::setMainWidget(), KisFileNameRequester::setMimeTypeFilters(), KisFileNameRequester::setMode(), KisFileNameRequester::setStartDir(), KisMimeDatabase::suffixesForMimeType(), KisImportExportManager::supportedMimeTypes(), and v.

setup()

void KisLayerManager::setup ( KisActionManager * actionManager )

private

Definition at line 148 of file kis_layer_manager.cc.

{
    m_imageFlatten = actionManager->createAction("flatten_image");
    connect(m_imageFlatten, SIGNAL(triggered()), this, SLOT(flattenImage()));
 
    m_imageMergeLayer = actionManager->createAction("merge_layer");
    connect(m_imageMergeLayer, SIGNAL(triggered()), this, SLOT(mergeLayer()));
 
    m_flattenLayer = actionManager->createAction("flatten_layer");
    connect(m_flattenLayer, SIGNAL(triggered()), this, SLOT(flattenLayer()));
 
    m_groupLayersSave = actionManager->createAction("save_groups_as_images");
    connect(m_groupLayersSave, SIGNAL(triggered()), this, SLOT(saveGroupLayers()));
 
    m_convertGroupAnimated = actionManager->createAction("convert_group_to_animated");
    connect(m_convertGroupAnimated, SIGNAL(triggered()), this, SLOT(convertGroupToAnimated()));
 
    m_imageResizeToLayer = actionManager->createAction("resizeimagetolayer");
    connect(m_imageResizeToLayer, SIGNAL(triggered()), this, SLOT(imageResizeToActiveLayer()));
 
    KisAction *action = actionManager->createAction("trim_to_image");
    connect(action, SIGNAL(triggered()), this, SLOT(trimToImage()));
 
    action = actionManager->createAction("purge_unused_image_data");
    connect(action, SIGNAL(triggered()), this, SLOT(purgeUnusedImageData()));
 
    m_layerStyle  = actionManager->createAction("layer_style");
    connect(m_layerStyle, SIGNAL(triggered()), this, SLOT(layerStyle()));
 
    m_copyLayerStyle = actionManager->createAction("copy_layer_style");
    connect(m_copyLayerStyle, SIGNAL(triggered()), this, SLOT(copyLayerStyle()));
 
    m_pasteLayerStyle = actionManager->createAction("paste_layer_style");
    connect(m_pasteLayerStyle, SIGNAL(triggered()), this, SLOT(pasteLayerStyle()));
}

References convertGroupToAnimated(), copyLayerStyle(), KisActionManager::createAction(), flattenImage(), flattenLayer(), imageResizeToActiveLayer(), layerStyle(), m_convertGroupAnimated, m_copyLayerStyle, m_flattenLayer, m_groupLayersSave, m_imageFlatten, m_imageMergeLayer, m_imageResizeToLayer, m_layerStyle, m_pasteLayerStyle, mergeLayer(), pasteLayerStyle(), purgeUnusedImageData(), saveGroupLayers(), and trimToImage().

setView()

void KisLayerManager::setView

(

QPointer< KisView >

view

)

Definition at line 116 of file kis_layer_manager.cc.

{
    m_imageView = view;
}

References m_imageView.

trimToImage

void KisLayerManager::trimToImage ( )

privateslot

Definition at line 225 of file kis_layer_manager.cc.

{
    KisImageWSP image = m_view->image();
    if (image) {
        image->cropImage(image->bounds());
    }
}

References KisImage::bounds(), KisImage::cropImage(), KisViewManager::image(), and m_view.

updateGUI()

void KisLayerManager::updateGUI ( )

private

Definition at line 184 of file kis_layer_manager.cc.

{
    KisImageSP image = m_view->image();
    KisLayerSP layer = activeLayer();
 
    const bool isGroupLayer = layer && layer->inherits("KisGroupLayer");
 
    QString mergeLayerText;
    if (m_view->nodeManager()->selectedNodes().size() > 1) {
        mergeLayerText = i18nc("@action:inmenu", "Merge Selected Layers");
    } else if (isGroupLayer) {
        mergeLayerText = i18nc("@action:inmenu", "Merge Group");
    } else {
        mergeLayerText = i18nc("@action:inmenu", "Merge with Layer Below");
    }
    m_imageMergeLayer->setText(mergeLayerText);
 
    m_flattenLayer->setVisible(!isGroupLayer);
 
    if (m_view->statusBar())
        m_view->statusBar()->setProfile(image);
}

References activeLayer(), KisViewManager::image(), m_flattenLayer, m_imageMergeLayer, m_view, KisViewManager::nodeManager(), KisNodeManager::selectedNodes(), KisStatusBar::setProfile(), and KisViewManager::statusBar().

Friends And Related Symbol Documentation

KisNodeManager

friend class KisNodeManager

friend

Definition at line 44 of file kis_layer_manager.h.

Member Data Documentation

m_commandsAdapter

KisNodeCommandsAdapter* KisLayerManager::m_commandsAdapter

private

Definition at line 123 of file kis_layer_manager.h.

m_convertGroupAnimated

KisAction* KisLayerManager::m_convertGroupAnimated {0}

private

Definition at line 119 of file kis_layer_manager.h.

{0};

m_copyLayerStyle

KisAction* KisLayerManager::m_copyLayerStyle {0}

private

Definition at line 126 of file kis_layer_manager.h.

{0};

m_flattenLayer

KisAction* KisLayerManager::m_flattenLayer {0}

private

Definition at line 121 of file kis_layer_manager.h.

{0};

m_groupLayersSave

KisAction* KisLayerManager::m_groupLayersSave {0}

private

Definition at line 118 of file kis_layer_manager.h.

{0};

m_imageFlatten

KisAction* KisLayerManager::m_imageFlatten {0}

private

Definition at line 116 of file kis_layer_manager.h.

{0};

m_imageMergeLayer

KisAction* KisLayerManager::m_imageMergeLayer {0}

private

Definition at line 117 of file kis_layer_manager.h.

{0};

m_imageResizeToLayer

KisAction* KisLayerManager::m_imageResizeToLayer {0}

private

Definition at line 120 of file kis_layer_manager.h.

{0};

m_imageView

QPointer<KisView> KisLayerManager::m_imageView {0}

private

Definition at line 114 of file kis_layer_manager.h.

{0};

m_layerPropertiesDialogActive

bool KisLayerManager::m_layerPropertiesDialogActive {false}

private

Definition at line 129 of file kis_layer_manager.h.

{false};

m_layerStyle

KisAction* KisLayerManager::m_layerStyle {0}

private

Definition at line 125 of file kis_layer_manager.h.

{0};

m_pasteLayerStyle

KisAction* KisLayerManager::m_pasteLayerStyle {0}

private

Definition at line 127 of file kis_layer_manager.h.

{0};

m_rasterizeLayer

KisAction* KisLayerManager::m_rasterizeLayer {0}

private

Definition at line 122 of file kis_layer_manager.h.

{0};

m_view

KisViewManager* KisLayerManager::m_view

private

Definition at line 113 of file kis_layer_manager.h.

---

The documentation for this class was generated from the following files:

• libs/ui/kis_layer_manager.h
• libs/ui/kis_layer_manager.cc