KisCutCopyActionFactory Struct Reference

#include <kis_selection_action_factories.h>

Inheritance diagram for KisCutCopyActionFactory:

Public Types
enum	Flag { None = 0x0 , CutClip = 0x1 , SharpClip = 0x2 }
Public Types inherited from KisOperation
enum	Flag { Normal = 0x0 , ReadOnly = 0x1 }

Public Member Functions
	KisCutCopyActionFactory ()
void	run (Flags flags, KisViewManager *view)
void	runFromXML (KisViewManager *view, const KisOperationConfiguration &config) override
Public Member Functions inherited from KisOperation
QString	id () const
	KisOperation (const QString &id)
virtual	~KisOperation ()

Additional Inherited Members
Protected Member Functions inherited from KisOperation
KisProcessingApplicator *	beginAction (KisViewManager *view, const KUndo2MagicString &actionName, Flags flags=Normal)
void	endAction (KisProcessingApplicator *applicator, const QString &xmlData)

Detailed Description

Definition at line 57 of file kis_selection_action_factories.h.

Member Enumeration Documentation

Flag

enum KisCutCopyActionFactory::Flag

Enumerator
None
CutClip
SharpClip

Definition at line 58 of file kis_selection_action_factories.h.

              {
        None = 0x0,
        CutClip = 0x1,
        SharpClip = 0x2
    };

Constructor & Destructor Documentation

KisCutCopyActionFactory()

KisCutCopyActionFactory::KisCutCopyActionFactory ( )

inline

Definition at line 65 of file kis_selection_action_factories.h.

: KisOperation("cut-copy-ui-action") {}

Member Function Documentation

run()

void KisCutCopyActionFactory::run	(	Flags	flags,
		KisViewManager *	view )

Make sure that we use tryBarrierLock() here because it does not cause requestStrokeEnd() to be called in the tools, hence does not prevent disruptions in the text tool.

Definition at line 224 of file kis_selection_action_factories.cpp.

{
    KisImageSP image = view->image();
    if (!image) return;
 
    if (!view->blockUntilOperationsFinished(image)) return;
 
    // Reference layers is a fake node, so it isn't added to the layer stack, this results in KisSelectedShapesProxy not
    // being aware of the active shapeManager and its selected shapes.
    const auto currentToolHasSelection =
        view->canvasBase()->toolProxy()->hasSelection();
 
    const bool haveShapesSelected =
            view->selectionManager()->haveShapesSelected();
 
    KisSelectionSP selection = view->selection();
 
    const bool skipShapes = selection && !currentToolHasSelection;
 
    if (!skipShapes && !flags.testFlag(SharpClip) && (haveShapesSelected || currentToolHasSelection)) {
        // XXX: "Add saving of XML data for Cut/Copy of shapes"
 
        KisImageBarrierLock lock(image, std::try_to_lock);
        if (!lock.owns_lock()) return;
 
        if (flags & CutClip) {
            view->canvasBase()->toolProxy()->cut();
        } else {
            view->canvasBase()->toolProxy()->copy();
        }
    } else if (selection) {
        KisNodeList selectedNodes = view->nodeManager()->selectedNodes();
 
        KisNodeList masks;
        Q_FOREACH (KisNodeSP node, selectedNodes) {
            if (node->inherits("KisMask")) {
                masks.append(node);
            }
        }
 
        selectedNodes = KisLayerUtils::sortAndFilterMergeableInternalNodes(selectedNodes);
 
        KisNodeList nodes;
        Q_FOREACH (KisNodeSP node, selectedNodes) {
            KisNodeSP dupNode;
            if (node->inherits("KisShapeLayer") || node->inherits("KisFileLayer")
 
                // also recreate the node for animated layers, since we have no
                // API for making a node non-animated
                || (node->inherits("KisPaintLayer") && node->isAnimated())) {
 
                KisPaintDeviceSP dev = new KisPaintDevice(*node->projection());
                // might have to change node's name (vector to paint layer)
                dupNode = new KisPaintLayer(image, node->name(), node->opacity(), dev);
            } else {
                dupNode = node->clone();
            }
            nodes.append(dupNode);
        }
 
        Q_FOREACH (KisNodeSP node, nodes) {
            KisLayerUtils::recursiveApplyNodes(node, [image, view, flags] (KisNodeSP node) {
                if (node && node->paintDevice() && !node->inherits("KisMask")) {
                    KisToolUtils::trimDeviceForClipboard(image, node->paintDevice(), view->selection(), flags.testFlag(SharpClip));
                }
            });
        }
 
        KisImageSP tempImage = KisToolUtils::buildImageForClipboard(image, nodes);
        KisClipboard::instance()->setLayers(nodes, tempImage, selection->selectedExactRect());
 
 
        KUndo2MagicString actionName = flags & CutClip ?
                    kundo2_i18n("Cut") :
                    kundo2_i18n("Copy");
        KisProcessingApplicator *ap =
            beginAction(view,
                        actionName,
                        flags & CutClip ? KisOperation::Normal : KisOperation::ReadOnly);
 
        if (flags & CutClip) {
            selectedNodes.append(masks);
            Q_FOREACH (KisNodeSP node, selectedNodes) {
                KisLayerUtils::recursiveApplyNodes(node, [selection, masks, ap] (KisNodeSP node){
 
                    if (!node->hasEditablePaintDevice()) {
                        return;
                    }
 
                    // applied on masks if selected explicitly (when CTRL-X(cut) is used for deletion)
                    if (node->inherits("KisMask") && !masks.contains(node)) {
                        return;
                    }
 
                    struct ClearSelection : public KisTransactionBasedCommand {
                        ClearSelection(KisNodeSP node, KisSelectionSP sel)
                            : m_node(node), m_sel(sel) {}
                        KisNodeSP m_node;
                        KisSelectionSP m_sel;
 
                        KUndo2Command* paint() override {
                            KisSelectionSP cutSelection = m_sel;
                            // Shrinking the cutting area was previously used
                            // for getting seamless cut-paste. Now we use makeSharpClip
                            // instead.
                            // QRect originalRect = cutSelection->selectedExactRect();
                            // static const int preciseSelectionThreshold = 16;
                            //
                            // if (originalRect.width() > preciseSelectionThreshold ||
                            //     originalRect.height() > preciseSelectionThreshold) {
                            //     cutSelection = new KisSelection(*m_sel);
                            //     delete cutSelection->flatten();
                            //
                            //     KisSelectionFilter* filter = new KisShrinkSelectionFilter(1, 1, false);
                            //
                            //     QRect processingRect = filter->changeRect(originalRect);
                            //     filter->process(cutSelection->pixelSelection(), processingRect);
                            // }
 
                            KisTransaction transaction(m_node->paintDevice());
                            m_node->paintDevice()->clearSelection(cutSelection);
                            m_node->setDirty(cutSelection->selectedRect());
                            return transaction.endAndTake();
                        }
                    };
 
                    KUndo2Command *command = new ClearSelection(node, selection);
                    ap->applyCommand(command, KisStrokeJobData::CONCURRENT, KisStrokeJobData::NORMAL);
 
                });
            }
        }
 
        KisOperationConfiguration config(id());
        config.setProperty("will-cut", flags.testFlag(CutClip));
        config.setProperty("use-sharp-clip", flags.testFlag(SharpClip));
        endAction(ap, config.toXML());
    } else if (!flags.testFlag(SharpClip)) {
        if (flags & CutClip) {
            view->nodeManager()->cutLayersToClipboard();
        } else {
            view->nodeManager()->copyLayersToClipboard();
        }
    }
}

References KisProcessingApplicator::applyCommand(), KisOperation::beginAction(), KisViewManager::blockUntilOperationsFinished(), KisToolUtils::buildImageForClipboard(), KisViewManager::canvasBase(), KisPaintDevice::clearSelection(), KisNode::clone(), KisStrokeJobData::CONCURRENT, KoToolProxy::copy(), KisNodeManager::copyLayersToClipboard(), KoToolProxy::cut(), CutClip, KisNodeManager::cutLayersToClipboard(), KisOperation::endAction(), KisTransaction::endAndTake(), KisBaseNode::hasEditablePaintDevice(), KoToolProxy::hasSelection(), KisSelectionManager::haveShapesSelected(), KisViewManager::image(), KisClipboard::instance(), KisBaseNode::isAnimated(), kundo2_i18n(), KisBaseNode::name(), KisViewManager::nodeManager(), KisStrokeJobData::NORMAL, KisOperation::Normal, KisBaseNode::opacity(), KisBaseNode::paintDevice(), KisBaseNode::projection(), KisOperation::ReadOnly, KisLayerUtils::recursiveApplyNodes(), KisSelection::selectedExactRect(), KisNodeManager::selectedNodes(), KisSelection::selectedRect(), KisViewManager::selection(), KisViewManager::selectionManager(), KisNode::setDirty(), KisClipboard::setLayers(), KisPropertiesConfiguration::setProperty(), SharpClip, KisLayerUtils::sortAndFilterMergeableInternalNodes(), KisCanvas2::toolProxy, and KisPropertiesConfiguration::toXML().

runFromXML()

void KisCutCopyActionFactory::runFromXML ( KisViewManager * view, const KisOperationConfiguration & config )

inlineoverridevirtual

Reimplemented from KisOperation.

Definition at line 66 of file kis_selection_action_factories.h.

                                                                                            {
        Flags flags;
        flags.setFlag(CutClip, config.getBool("will-cut", false));
        flags.setFlag(SharpClip, config.getBool("use-sharp-clip", false));
        run(flags, view);
    }

References KisPropertiesConfiguration::getBool(), and KisNoParameterActionFactory::run().

---

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

• libs/ui/actions/kis_selection_action_factories.h
• libs/ui/actions/kis_selection_action_factories.cpp