kis_mask_manager.cc

Go to the documentation of this file.

/* This file is part of the KDE project
 * SPDX-FileCopyrightText: 2006 Boudewijn Rempt <boud@valdyas.org>
 *
 *  SPDX-License-Identifier: GPL-2.0-or-later
 */
 
#include "kis_mask_manager.h"
 
#include <kactioncollection.h>
 
#include <KoProperties.h>
 
#include <kis_transaction.h>
#include <filter/kis_filter_configuration.h>
#include <commands/kis_node_commands.h>
#include <kis_undo_adapter.h>
#include <kis_paint_layer.h>
#include "KisDocument.h"
#include "KisViewManager.h"
#include <kis_layer.h>
#include <kis_clone_layer.h>
#include <kis_group_layer.h>
#include <kis_filter_mask.h>
#include <lazybrush/kis_colorize_mask.h>
#include <kis_transform_mask.h>
#include <kis_transparency_mask.h>
#include <kis_selection_mask.h>
#include <kis_effect_mask.h>
#include "dialogs/kis_dlg_adjustment_layer.h"
#include "widgets/kis_mask_widgets.h"
#include <kis_selection.h>
#include <kis_selection_manager.h>
#include <kis_pixel_selection.h>
#include "commands/KisNodeRenameCommand.h"
#include <kis_command_utils.h>
#include <kis_image.h>
#include <kis_transform_worker.h>
#include <KoColorSpace.h>
#include <KoColor.h>
#include "kis_node_commands_adapter.h"
#include "commands/kis_deselect_global_selection_command.h"
#include "commands_new/KisLayerCollapseCommand.h"
#include "kis_iterator_ng.h"
#include <KisGlobalResourcesInterface.h>
#include "kis_node_manager.h"
 
 
KisMaskManager::KisMaskManager(KisViewManager * view)
    : m_view(view)
    , m_imageView(0)
    , m_commandsAdapter(new KisNodeCommandsAdapter(m_view))
{
}
 
void KisMaskManager::setView(QPointer<KisView>imageView)
{
    m_imageView = imageView;
}
 
void KisMaskManager::setup(KisKActionCollection *actionCollection, KisActionManager *actionManager)
{
    Q_UNUSED(actionCollection);
    Q_UNUSED(actionManager);
}
 
void KisMaskManager::updateGUI()
{
    // XXX: enable/disable menu items according to whether there's a mask selected currently
    // XXX: disable the selection mask item if there's already a selection mask
    // YYY: doesn't KisAction do that already?
}
 
KisMaskSP KisMaskManager::activeMask()
{
    if (m_imageView) {
        return m_imageView->currentMask();
    }
    return 0;
}
 
KisPaintDeviceSP KisMaskManager::activeDevice()
{
    KisMaskSP mask = activeMask();
    return mask ? mask->paintDevice() : 0;
}
 
void KisMaskManager::activateMask(KisMaskSP mask)
{
    Q_UNUSED(mask);
}
 
void KisMaskManager::masksUpdated()
{
    m_view->updateGUI();
}
 
void KisMaskManager::adjustMaskPosition(KisNodeSP node, KisNodeSP activeNode, bool avoidActiveNode, KisNodeSP &parent, KisNodeSP &above)
{
    Q_ASSERT(node);
    Q_ASSERT(activeNode);
 
    if (!avoidActiveNode && activeNode->allowAsChild(node)) {
        parent = activeNode;
        above = activeNode->lastChild();
    } else if (activeNode->parent() && activeNode->parent()->allowAsChild(node)
               && activeNode->parent()->parent() /* we don't want to add masks to root */) {
        parent = activeNode->parent();
        above = activeNode;
    } else {
        KisNodeSP t = activeNode;
        while ((t = t->nextSibling())) {
            if (t->allowAsChild(node)) {
                parent = t;
                above = t->lastChild();
                break;
            }
        }
 
        if (!t) {
            t = activeNode;
            while ((t = t->prevSibling())) {
                if (t->allowAsChild(node)) {
                    parent = t;
                    above = t->lastChild();
                    break;
                }
            }
        }
 
        if (!t && activeNode->parent()) {
            adjustMaskPosition(node, activeNode->parent(), true, parent, above);
        } else if (!t) {
            KisImageWSP image = m_view->image();
            KisLayerSP layer = new KisPaintLayer(image.data(), image->nextLayerName(), OPACITY_OPAQUE_U8, image->colorSpace());
            m_commandsAdapter->addNode(layer, activeNode, 0);
 
            parent = layer;
            above = 0;
        }
    }
}
 
void KisMaskManager::createMaskCommon(KisMaskSP mask,
                                      KisNodeSP activeNode,
                                      KisPaintDeviceSP copyFrom,
                                      const KUndo2MagicString& macroName,
                                      const QString &nodeType,
                                      const QString &nodeName,
                                      bool suppressSelection,
                                      bool avoidActiveNode,
                                      bool updateImage)
{
    m_commandsAdapter->beginMacro(macroName);
 
    KisNodeSP parent;
    KisNodeSP above;
    adjustMaskPosition(mask, activeNode, avoidActiveNode, parent, above);
 
    KisLayerSP parentLayer = qobject_cast<KisLayer*>(parent.data());
    Q_ASSERT(parentLayer);
 
    bool shouldDeselectGlobalSelection = false;
 
    if (!suppressSelection) {
        if (copyFrom) {
            mask->initSelection(copyFrom, parentLayer);
        } else {
            mask->initSelection(m_view->selection(), parentLayer);
            shouldDeselectGlobalSelection = m_view->selection();
        }
    }
 
    mask->setName( createMaskNameCommon(parentLayer, nodeType, nodeName) );
 
    KisImageLayerAddCommand::Flags flags =
        updateImage ?
            KisImageLayerAddCommand::DoUndoUpdates | KisImageLayerAddCommand::DoRedoUpdates :
            KisImageLayerAddCommand::None;
 
    m_commandsAdapter->addNode(mask, parentLayer, above, flags);
 
    if (shouldDeselectGlobalSelection) {
        m_commandsAdapter->addExtraCommand(new KisDeselectGlobalSelectionCommand(m_imageView->image()));
    }
 
    m_commandsAdapter->endMacro();
 
    masksUpdated();
}
 
QString KisMaskManager::createMaskNameCommon(KisNodeSP targetNode, const QString &nodeType, const QString &desiredName)
{
    QList<KisNodeSP> masks = targetNode->childNodes(QStringList(nodeType),KoProperties());
    int number = masks.count() + 1;
    return desiredName + QString(" ") + QString::number(number);
}
 
KisNodeSP KisMaskManager::createSelectionMask(KisNodeSP activeNode, KisPaintDeviceSP copyFrom, bool convertActiveNode)
{
    if (!m_view->nodeManager()->canModifyLayer(activeNode)) return 0;
 
    KisSelectionMaskSP mask = new KisSelectionMask(m_view->image());
 
    createMaskCommon(mask, activeNode, copyFrom, kundo2_i18n("Add Selection Mask"), "KisSelectionMask", i18n("Selection"), false, convertActiveNode, false);
    mask->setActive(true);
    if (convertActiveNode) {
        m_commandsAdapter->removeNode(activeNode);
    }
    return mask;
}
 
KisNodeSP KisMaskManager::createTransparencyMask(KisNodeSP activeNode, KisPaintDeviceSP copyFrom, bool convertActiveNode)
{
    if (!m_view->nodeManager()->canModifyLayer(activeNode)) return 0;
 
    KisMaskSP mask = new KisTransparencyMask(m_view->image(), "");
    createMaskCommon(mask, activeNode, copyFrom, kundo2_i18n("Add Transparency Mask"), "KisTransparencyMask", i18n("Transparency Mask"), false, convertActiveNode);
    if (convertActiveNode) {
        m_commandsAdapter->removeNode(activeNode);
    }
    return mask;
}
 
 
KisNodeSP KisMaskManager::createFilterMask(KisNodeSP activeNode, KisPaintDeviceSP copyFrom, bool quiet, bool convertActiveNode)
{
    if (!m_view->nodeManager()->canModifyLayer(activeNode)) return 0;
 
    KisFilterMaskSP mask = new KisFilterMask(m_view->image(), "");
    createMaskCommon(mask, activeNode, copyFrom, kundo2_i18n("Add Filter Mask"), "KisFilterMask", i18n("Filter Mask"), false, convertActiveNode);
 
    if (convertActiveNode) {
        m_commandsAdapter->removeNode(activeNode);
    }
 
    KisPaintDeviceSP originalDevice = mask->parent()->original();
 
 
    KisDlgAdjustmentLayer dialog(mask, mask.data(), originalDevice,
                                 mask->name(), i18n("New Filter Mask"),
                                 m_view, qApp->activeWindow());
 
    // If we are supposed to not disturb the user, don't start asking them about things.
    if(quiet) {
        KisFilterConfigurationSP filter = KisFilterRegistry::instance()->values().first()->defaultConfiguration(KisGlobalResourcesInterface::instance());
        if (filter) {
            mask->setFilter(filter->cloneWithResourcesSnapshot());
            mask->setName(mask->name());
        }
        return mask;
    }
 
    if (dialog.exec() == QDialog::Accepted) {
        KisFilterConfigurationSP filter = dialog.filterConfiguration();
        if (filter) {
            QString name = dialog.layerName();
            mask->setFilter(filter->cloneWithResourcesSnapshot());
            mask->setName(name);
        }
 
        return mask;
 
    } else {
        m_commandsAdapter->undoLastCommand();
    }
 
    return 0;
}
 
 
KisNodeSP KisMaskManager::createColorizeMask(KisNodeSP activeNode)
{
    if (!m_view->nodeManager()->canModifyLayer(activeNode)) return 0;
 
    KisColorizeMaskSP mask = new KisColorizeMask(m_view->image(), "");
    createMaskCommon(mask, activeNode, 0, kundo2_i18n("Add Colorize Mask"), "KisColorizeMask", i18n("Colorize Mask"), true, false);
    mask->initializeCompositeOp();
    delete mask->setColorSpace(mask->parent()->colorSpace());
    return mask;
}
 
 
KisNodeSP KisMaskManager::createTransformMask(KisNodeSP activeNode)
{
    if (!m_view->nodeManager()->canModifyLayer(activeNode)) return 0;
 
    KisTransformMaskSP mask = new KisTransformMask(m_view->image(), "");
    createMaskCommon(mask, activeNode, 0, kundo2_i18n("Add Transform Mask"), "KisTransformMask", i18n("Transform Mask"), true, false);
    return mask;
}
 
KisNodeSP KisMaskManager::createFastColorOverlayMask(KisNodeSP activeNode)
{
    if (!m_view->nodeManager()->canModifyLayer(activeNode)) return 0;
 
    KisLayerSP activeLayer = qobject_cast<KisLayer*>(activeNode.data());
    Q_ASSERT(activeLayer);
 
    KisFilterConfigurationSP filter =
        KisFilterRegistry::instance()->value("fastcoloroverlay")->defaultConfiguration(KisGlobalResourcesInterface::instance());
    if (!filter) return nullptr;
 
    m_commandsAdapter->beginMacro(kundo2_i18n("Add Fast Color Overlay"));
 
    KisFilterMaskSP mask = new KisFilterMask(m_view->image(), "");
    mask->initSelection(activeLayer);
    mask->setName(createMaskNameCommon(activeLayer, "KisFilterMask", i18n("Color Overlay Mask")));
    mask->setFilter(filter->cloneWithResourcesSnapshot());
 
    KisImageLayerAddCommand::Flags flags =
        KisImageLayerAddCommand::DoUndoUpdates |
        KisImageLayerAddCommand::DoRedoUpdates;
 
    if (activeLayer->childCount() == 0) {
        m_commandsAdapter->addExtraCommand(
                    new KisLayerCollapseCommand(
                        activeNode, true));
 
        flags |= KisImageLayerAddCommand::DontActivateOnAddition;
    };
 
    m_commandsAdapter->addNode(mask, activeLayer, activeLayer->lastChild(), flags);
 
    m_commandsAdapter->endMacro();
 
    return mask;
}
 
void KisMaskManager::maskProperties()
{
    if (!activeMask()) return;
 
    if (!m_view->nodeManager()->canModifyLayer(activeMask())) return;
 
    if (activeMask()->inherits("KisFilterMask")) {
        KisFilterMask *mask = static_cast<KisFilterMask*>(activeMask().data());
 
        KisLayerSP layer = qobject_cast<KisLayer*>(mask->parent().data());
        if (! layer)
            return;
 
 
        KisPaintDeviceSP dev = layer->original();
        if (!dev) {
            return;
        }
 
        KisDlgAdjustmentLayer dlg(mask, mask, dev, mask->name(),
                                  i18n("Filter Mask Properties"), m_view,
                                  m_view->mainWindowAsQWidget(), mask->filter());
 
        KisFilterConfigurationSP configBefore(mask->filter());
        Q_ASSERT(configBefore);
        QString xmlBefore = configBefore->toXML();
 
        if (dlg.exec() == QDialog::Accepted) {
 
            KisFilterConfigurationSP configAfter(dlg.filterConfiguration());
            Q_ASSERT(configAfter);
            QString xmlAfter = configAfter->toXML();
 
            KUndo2Command *cmd = nullptr;
 
            if(xmlBefore != xmlAfter) {
                cmd = KisCommandUtils::composeCommands(cmd,
                    new KisChangeFilterCmd(mask,
                                           configBefore->cloneWithResourcesSnapshot(),
                                           configAfter->cloneWithResourcesSnapshot()));
            }
 
            if (mask->name() != dlg.layerName()) {
                cmd = KisCommandUtils::composeCommands(cmd,
                    new KisNodeRenameCommand(mask, mask->name(), dlg.layerName()));
            }
 
            if (cmd) {
                m_view->undoAdapter()->addCommand(cmd);
                m_view->document()->setModified(true);
            }
        }
        else {
            KisFilterConfigurationSP configAfter(dlg.filterConfiguration());
            Q_ASSERT(configAfter);
            QString xmlAfter = configAfter->toXML();
 
            if(xmlBefore != xmlAfter) {
                mask->setFilter(configBefore->cloneWithResourcesSnapshot());
                mask->setDirty();
            }
        }
 
    } else {
        // Not much to show for transparency or selection masks?
    }
}