KisMimeData Class Reference

#include <kis_mimedata.h>

Inheritance diagram for KisMimeData:

Public Member Functions
void	deepCopyNodes ()
QStringList	formats () const override
	KisMimeData (QList< KisNodeSP > nodes, KisImageSP image, bool forceCopy=false)
QList< KisNodeSP >	nodes () const
	return the node set on this mimedata object – for internal use

Static Public Member Functions
static KisDisplayConfig	displayConfigForMimePastes ()
static bool	insertMimeLayers (const QMimeData *data, KisImageSP image, KisShapeController *shapeController, KisNodeDummy *parentDummy, KisNodeDummy *aboveThisDummy, bool copyNode, KisNodeInsertionAdapter *nodeInsertionAdapter, bool changeOffset=false, QPointF offset=QPointF(), KisProcessingApplicator *applicator=nullptr)
static bool	isNodeMimeDataFromSameImage (const QMimeData *data, KisImageSP image)
static KisNodeList	loadNodesFast (const QMimeData *data, KisImageSP image, KisShapeController *shapeController, bool &copyNode)
static KisNodeList	loadNodesFastAndRecenter (const QPoint &preferredCenter, const QMimeData *data, KisImageSP image, KisShapeController *shapeController, bool &copyNode)
static QMimeData *	mimeForLayers (const KisNodeList &nodes, KisImageSP image, bool forceCopy=false)
static QMimeData *	mimeForLayersDeepCopy (const KisNodeList &nodes, KisImageSP image, bool forceCopy)

Protected Member Functions
QVariant	retrieveData (const QString &mimetype, QMetaType preferredType) const override

Static Private Member Functions
static void	initializeExternalNode (KisNodeSP *nodes, KisImageSP srcImage, KisImageSP dstImage, KisShapeController *shapeController)
static KisNodeList	loadNonNativeNodes (const QMimeData *data, KisImageWSP image)
static KisNodeList	tryLoadInternalNodes (const QMimeData *data, KisImageSP image, KisShapeController *shapeController, bool &copyNode)

Private Attributes
QRect	m_copiedBounds
bool	m_forceCopy
KisImageSP	m_image
QList< KisNodeSP >	m_nodes

Detailed Description

KisMimeData implements delayed retrieval of nodes for d&d and copy/paste.

TODO: implement support for the ora format.

Definition at line 28 of file kis_mimedata.h.

Constructor & Destructor Documentation

KisMimeData()

KisMimeData::KisMimeData	(	QList< KisNodeSP >	nodes,
		KisImageSP	image,
		bool	forceCopy = false )

Definition at line 62 of file kis_mimedata.cpp.

    : QMimeData()
    , m_nodes(nodes)
    , m_forceCopy(forceCopy)
    , m_image(image)
{
    Q_ASSERT(m_nodes.size() > 0);
 
    KIS_SAFE_ASSERT_RECOVER_RETURN(image);
 
    Q_FOREACH (KisNodeSP node, nodes) {
        m_copiedBounds |= KisLayerUtils::recursiveTightNodeVisibleBounds(node);
    }
}

References KIS_SAFE_ASSERT_RECOVER_RETURN, m_copiedBounds, m_nodes, nodes(), and KisLayerUtils::recursiveTightNodeVisibleBounds().

Member Function Documentation

deepCopyNodes()

void KisMimeData::deepCopyNodes

(

)

For Cut/Copy/Paste operations we should detach the contents of the mime data from the actual image because the user can modify our image between the Copy/Cut and Paste calls. So we just copy all our nodes into the internal array.

It also fixes the problem of Cutting group layers. If we don't copy the node and all its children, it'll be deleted by the Cut operation and we will not be able to paste it correctly later.

Definition at line 103 of file kis_mimedata.cpp.

{
    KisNodeList newNodes;
 
    {
        KisImageReadOnlyBarrierLock lock(m_image, std::defer_lock);
        if (m_image) {
            lock.lock();
        }
 
        Q_FOREACH (KisNodeSP node, m_nodes) {
            KisNodeSP newNode = safeCopyNode(node);
            newNode->setImage(nullptr);
 
            newNodes << newNode;
        }
    }
 
    m_nodes = newNodes;
    m_image = 0;
}

References m_image, m_nodes, and KisNode::setImage().

displayConfigForMimePastes()

KisDisplayConfig KisMimeData::displayConfigForMimePastes ( )

static

Conversion options for mime clips when they are pasted into clipboard or fetched from clipboard (with user selecting "display" space)

On unmanaged compositors they should coincide with the space of the display. On managed ones they should be set to the default color space, e.g. sRGB.

When the surface is managed, we just put the data in sRGB mode, because the compositor expects untagged data to be sRGB.

Definition at line 77 of file kis_mimedata.cpp.

{
    KisDisplayConfig result;
 
    if (KisPlatformPluginInterfaceFactory::instance()->surfaceColorManagedByOS() ||
        KisOpenGLModeProber::instance()->useHDRMode()) {
        result.profile = KoColorSpaceRegistry::instance()->p709SRGBProfile();
    } else {
        KisConfig cfg(true);
        const KoColorProfile *profile = cfg.displayProfile(KisPortingUtils::getScreenNumberForWidget(QApplication::activeWindow()));
        KIS_SAFE_ASSERT_RECOVER(profile) {
            result.profile = KoColorSpaceRegistry::instance()->p709SRGBProfile();
        }
    }
 
    result.intent = KoColorConversionTransformation::internalRenderingIntent();
    result.conversionFlags = KoColorConversionTransformation::internalConversionFlags();
    result.isHDR = false;
 
    return result;
}

References KisDisplayConfig::conversionFlags, KisConfig::displayProfile(), KisPortingUtils::getScreenNumberForWidget(), KoColorSpaceRegistry::instance(), KisPlatformPluginInterfaceFactory::instance(), KisOpenGLModeProber::instance(), KisDisplayConfig::intent, KoColorConversionTransformation::internalConversionFlags(), KoColorConversionTransformation::internalRenderingIntent(), KisDisplayConfig::isHDR, KIS_SAFE_ASSERT_RECOVER, KoColorSpaceRegistry::p709SRGBProfile(), and KisDisplayConfig::profile.

formats()

QStringList KisMimeData::formats ( ) const

override

KisMimeData provides the following formats if a node has been set:

• application/x-krita-node-internal-pointer: requests a pointer to a Krita node.
• application/x-qt-image: fallback for other applications, returns a QImage of the current node's paintdevice
• application/zip: allows drop targets that can handle zip files to open the data

Definition at line 130 of file kis_mimedata.cpp.

{
    QStringList f = QMimeData::formats();
    if (m_nodes.size() > 0) {
        f << "application/x-qt-image"
          << "application/zip"
          << "application/x-krita-node-internal-pointer";
    }
    return f;
}

References m_nodes.

initializeExternalNode()

void KisMimeData::initializeExternalNode ( KisNodeSP * nodes, KisImageSP srcImage, KisImageSP dstImage, KisShapeController * shapeController )

staticprivate

Definition at line 252 of file kis_mimedata.cpp.

{
    KisShapeLayer *shapeLayer = dynamic_cast<KisShapeLayer*>(node->data());
    if (shapeLayer) {
        // attach the layer to a new shape controller
        KisShapeLayer *shapeLayer2 = new KisShapeLayer(*shapeLayer, shapeController);
 
        if (srcImage
            && (!qFuzzyCompare(dstImage->xRes(), srcImage->xRes())
                || !qFuzzyCompare(dstImage->yRes(), srcImage->yRes()))) {
 
            const QTransform t = QTransform::fromScale(srcImage->xRes() / dstImage->xRes(),
                                                       srcImage->yRes() / dstImage->yRes());
 
            shapeLayer2->setTransformation(shapeLayer2->transformation() * t);
        }
 
        *node = shapeLayer2;
    }
}

References qFuzzyCompare(), KoShape::setTransformation(), KoShape::transformation(), KisImage::xRes(), and KisImage::yRes().

insertMimeLayers()

bool KisMimeData::insertMimeLayers ( const QMimeData * data, KisImageSP image, KisShapeController * shapeController, KisNodeDummy * parentDummy, KisNodeDummy * aboveThisDummy, bool copyNode, KisNodeInsertionAdapter * nodeInsertionAdapter, bool changeOffset = false, QPointF offset = QPointF(), KisProcessingApplicator * applicator = nullptr )

static

We have the node juggler running, so it will delay the update of the generator layers that might be included into the paste. To avoid that we should forcefully to make it stop

Definition at line 493 of file kis_mimedata.cpp.

{
    QList<KisNodeSP> nodes = loadNodesFast(data, image, shapeController, copyNode /* IN-OUT */);
 
    if (changeOffset) {
        Q_FOREACH (KisNodeSP node, nodes) {
            KisLayerUtils::recursiveApplyNodes(node, [offset] (KisNodeSP node){
                const QPoint newOffset(node->x() + offset.x(), node->y() + offset.y());
                node->setX(newOffset.x());
                node->setY(newOffset.y());
            });
        }
    }
 
    if (nodes.isEmpty()) return false;
 
    bool result = true;
 
    if (!correctNewNodeLocation(nodes, parentDummy, aboveThisDummy)) {
        return false;
    }
 
    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(nodeInsertionAdapter, false);
    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(parentDummy, false);
 
    KisNodeSP aboveThisNode = aboveThisDummy ? aboveThisDummy->node() : 0;
 
    if (!applicator) {
        if (copyNode) {
            nodeInsertionAdapter->addNodes(nodes, parentDummy->node(), aboveThisNode);
        }
        else {
            KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(nodes.first()->graphListener() == image.data(), false);
            nodeInsertionAdapter->moveNodes(nodes, parentDummy->node(), aboveThisNode);
        }
    } else {
        {
            if (copyNode) {
                KisNodeSP prevNode = aboveThisNode;
                Q_FOREACH (KisNodeSP node, nodes) {
                    applicator->applyCommand(
                        new KisImageLayerAddCommand(image, node, parentDummy->node(), prevNode));
                    prevNode = node;
                }
            } else {
                KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(nodes.first()->graphListener() == image.data(), false);
 
                KisNodeSP prevNode = aboveThisNode;
                Q_FOREACH (KisNodeSP node, nodes) {
                    applicator->applyCommand(
                        new KisImageLayerMoveCommand(image, node, parentDummy->node(), prevNode));
                    prevNode = node;
                }
            }
        }
    }
 
    const bool hasDelayedNodes =
        std::find_if(nodes.begin(), nodes.end(),
                     [] (KisNodeSP node) {
                         return bool(dynamic_cast<KisDelayedUpdateNodeInterface*>(node.data()));
                     }) != nodes.end();
 
    if (hasDelayedNodes) {
        image->requestStrokeEnd();
    }
 
    return result;
}

References KisNodeInsertionAdapter::addNodes(), KisProcessingApplicator::applyCommand(), correctNewNodeLocation(), KisSharedPtr< T >::data(), KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, loadNodesFast(), KisNodeInsertionAdapter::moveNodes(), KisNodeDummy::node(), nodes(), KisLayerUtils::recursiveApplyNodes(), KisImage::requestStrokeEnd(), KisBaseNode::setX(), KisBaseNode::setY(), KisBaseNode::x(), and KisBaseNode::y().

isNodeMimeDataFromSameImage()

bool KisMimeData::isNodeMimeDataFromSameImage ( const QMimeData * data, KisImageSP image )

static

Definition at line 448 of file kis_mimedata.cpp.

{
    const KisMimeData *mimedata = qobject_cast<const KisMimeData*>(data);
    return mimedata && mimedata->m_image == image;
}

References m_image.

loadNodesFast()

KisNodeList KisMimeData::loadNodesFast ( const QMimeData * data, KisImageSP image, KisShapeController * shapeController, bool & copyNode )

static

Don't try to move a node originating from another image, just copy it.

Definition at line 454 of file kis_mimedata.cpp.

{
    QList<KisNodeSP> nodes =
        KisMimeData::tryLoadInternalNodes(data,
                                          image,
                                          shapeController,
                                          copyNode /* IN-OUT */);
 
    if (nodes.isEmpty()) {
        nodes = KisMimeData::loadNonNativeNodes(data, image);
        copyNode = true;
    }
 
    return nodes;
}

References loadNonNativeNodes(), nodes(), and tryLoadInternalNodes().

loadNodesFastAndRecenter()

KisNodeList KisMimeData::loadNodesFastAndRecenter ( const QPoint & preferredCenter, const QMimeData * data, KisImageSP image, KisShapeController * shapeController, bool & copyNode )

static

Definition at line 478 of file kis_mimedata.cpp.

{
    KisNodeList nodes = loadNodesFast(data, image, shapeController, copyNode);
 
    Q_FOREACH (KisNodeSP node, nodes) {
        const QRect layerBounds = node->exactBounds();
        const QPoint offset = preferredCenter - layerBounds.center();
 
        node->setX(node->x() + offset.x());
        node->setY(node->y() + offset.y());
    }
 
    return nodes;
}

References KisBaseNode::exactBounds(), loadNodesFast(), nodes(), KisBaseNode::setX(), KisBaseNode::setY(), KisBaseNode::x(), and KisBaseNode::y().

loadNonNativeNodes()

QList< KisNodeSP > KisMimeData::loadNonNativeNodes ( const QMimeData * data, KisImageWSP image )

staticprivate

Loads a node from a mime container Supports image and color types.

Definition at line 338 of file kis_mimedata.cpp.

{
    bool doRecenter = false;
    QList<KisNodeSP> nodes;
 
    if (nodes.isEmpty() && (data->hasFormat("application/x-color") || data->hasFormat("krita/x-colorsetentry"))) {
        QColor color = data->hasColor() ? qvariant_cast<QColor>(data->colorData()) : QColor(255, 0, 255);
        if (!data->hasColor() && data->hasFormat("krita/x-colorsetentry")) {
            QByteArray byteData = data->data("krita/x-colorsetentry");
            KisSwatch s = KisSwatch::fromByteArray(byteData);
            color = s.color().toQColor();
        }
        KisGeneratorSP generator = KisGeneratorRegistry::instance()->value("color");
        KisFilterConfigurationSP defaultConfig = generator->factoryConfiguration(KisGlobalResourcesInterface::instance());
        defaultConfig->setProperty("color", color);
        defaultConfig->createLocalResourcesSnapshot(KisGlobalResourcesInterface::instance());
 
        if (image) {
            KisGeneratorLayerSP fillLayer = new KisGeneratorLayer(image, image->nextLayerName(i18n("Fill Layer")),
                                                                  defaultConfig, image->globalSelection());
            nodes << fillLayer;
        }
    }
 
    if (nodes.isEmpty() && data->hasImage()) {
        QImage qimage = qvariant_cast<QImage>(data->imageData());
 
        KisPaintDeviceSP device = new KisPaintDevice(KoColorSpaceRegistry::instance()->rgb8());
        device->convertFromQImage(qimage, 0);
 
        if (image) {
            nodes << new KisPaintLayer(image.data(), image->nextLayerName(), OPACITY_OPAQUE_U8, device);
        }
 
        doRecenter = true;
    }
 
    if (!nodes.isEmpty() && doRecenter) {
        const QRect imageBounds = image->bounds();
 
        Q_FOREACH (KisNodeSP node, nodes) {
            const QRect layerBounds = node->projection()->exactBounds();
            if (doRecenter) {
                QPoint pt = imageBounds.center() - layerBounds.center();
                node->setX(pt.x());
                node->setY(pt.y());
            }
        }
    }
 
    return nodes;
}

References KisImage::bounds(), KisSwatch::color(), KisPaintDevice::convertFromQImage(), KisWeakSharedPtr< T >::data(), KisPaintDevice::exactBounds(), KisBaseProcessor::factoryConfiguration(), KisSwatch::fromByteArray(), KisImage::globalSelection(), KisGeneratorRegistry::instance(), KoColorSpaceRegistry::instance(), KisGlobalResourcesInterface::instance(), KisImage::nextLayerName(), nodes(), OPACITY_OPAQUE_U8, KisBaseNode::projection(), KisBaseNode::setX(), KisBaseNode::setY(), KoColor::toQColor(), and KoGenericRegistry< T >::value().

mimeForLayers()

QMimeData * KisMimeData::mimeForLayers ( const KisNodeList & nodes, KisImageSP image, bool forceCopy = false )

static

Definition at line 392 of file kis_mimedata.cpp.

{
    KisNodeList inputNodes = nodes;
    KisNodeList sortedNodes;
    KisLayerUtils::sortMergeableNodes(image->root(), inputNodes, sortedNodes);
    if (sortedNodes.isEmpty()) return 0;
 
    KisMimeData* data = new KisMimeData(sortedNodes, image, forceCopy);
    return data;
}

References KisMimeData(), nodes(), KisNodeFacade::root, and KisLayerUtils::sortMergeableNodes().

mimeForLayersDeepCopy()

QMimeData * KisMimeData::mimeForLayersDeepCopy ( const KisNodeList & nodes, KisImageSP image, bool forceCopy )

static

Definition at line 403 of file kis_mimedata.cpp.

{
    KisNodeList inputNodes = nodes;
    KisNodeList sortedNodes;
    KisLayerUtils::sortMergeableNodes(image->root(), inputNodes, sortedNodes);
    if (sortedNodes.isEmpty()) return 0;
 
    KisMimeData* data = new KisMimeData(sortedNodes, image, forceCopy);
    data->deepCopyNodes();
    return data;
}

References deepCopyNodes(), KisMimeData(), nodes(), KisNodeFacade::root, and KisLayerUtils::sortMergeableNodes().

nodes()

QList< KisNodeSP > KisMimeData::nodes

(

)

const

return the node set on this mimedata object – for internal use

Definition at line 125 of file kis_mimedata.cpp.

{
    return m_nodes;
}

References m_nodes.

retrieveData()

QVariant KisMimeData::retrieveData ( const QString & mimetype, QMetaType preferredType ) const

overrideprotected

HACK ALERT:

Sometimes Qt requests the data after destruction of Krita, we cannot load the nodes in that case, because we need signals and timers. So we just skip serializing.

Definition at line 198 of file kis_mimedata.cpp.

{
    if (!QApplication::instance()) return QVariant();
 
 
    Q_ASSERT(m_nodes.size() > 0);
 
    if (mimetype == "application/x-qt-image") {
        KisConfig cfg(true);
 
        QScopedPointer<KisDocument> doc(createDocument(m_nodes, m_image, m_copiedBounds));
 
        const KisDisplayConfig displayConfig = this->displayConfigForMimePastes();
        return doc->image()->projection()->convertToQImage(displayConfig.profile,
                                                           displayConfig.intent,
                                                           displayConfig.conversionFlags);
    }
    else if (mimetype == "application/zip") {
 
        QByteArray ba = serializeToByteArray(m_nodes, m_image, m_copiedBounds);
        return ba;
 
    }
    else if (mimetype == "application/x-krita-node-internal-pointer") {
 
        QDomDocument doc("krita_internal_node_pointer");
        QDomElement root = doc.createElement("pointer");
        root.setAttribute("application_pid", (qint64)QApplication::applicationPid());
        root.setAttribute("force_copy", m_forceCopy);
        root.setAttribute("image_pointer_value", (qint64)m_image.data());
        doc.appendChild(root);
 
        Q_FOREACH (KisNodeSP node, m_nodes) {
            QDomElement element = doc.createElement("node");
            element.setAttribute("pointer_value", (qint64)node.data());
            root.appendChild(element);
        }
 
        return doc.toByteArray();
 
    }
    else {
        return QMimeData::retrieveData(mimetype, preferredType);
    }
}

References KisDisplayConfig::conversionFlags, createDocument(), KisSharedPtr< T >::data(), KisDisplayConfig::intent, KisDisplayConfig::profile, and serializeToByteArray().

tryLoadInternalNodes()

QList< KisNodeSP > KisMimeData::tryLoadInternalNodes ( const QMimeData * data, KisImageSP image, KisShapeController * shapeController, bool & copyNode )

staticprivate

Try load the node, which belongs to the same Krita instance, that is can be fetched without serialization

Definition at line 276 of file kis_mimedata.cpp.

{
    QList<KisNodeSP> nodes;
    bool forceCopy = false;
    KisImageSP sourceImage;
 
    // Qt 4.7 and Qt 5.5 way
    const KisMimeData *mimedata = qobject_cast<const KisMimeData*>(data);
    if (mimedata) {
        nodes = mimedata->nodes();
        forceCopy = mimedata->m_forceCopy;
        sourceImage = mimedata->m_image;
    }
 
    // Qt 4.8 way
    if (nodes.isEmpty() && data->hasFormat("application/x-krita-node-internal-pointer")) {
        QByteArray nodeXml = data->data("application/x-krita-node-internal-pointer");
 
        QDomDocument doc;
        doc.setContent(nodeXml);
 
        QDomElement root = doc.documentElement();
        qint64 pid = root.attribute("application_pid").toLongLong();
        forceCopy = root.attribute("force_copy").toInt();
        qint64 imagePointerValue = root.attribute("image_pointer_value").toLongLong();
        sourceImage = reinterpret_cast<KisImage*>(imagePointerValue);
 
        if (pid == QApplication::applicationPid()) {
            QDomElement e;
            for (e = root.firstChildElement(); !e.isNull(); e = e.nextSiblingElement()) {
                qint64 pointerValue = e.attribute("pointer_value").toLongLong();
                if (pointerValue) {
                    nodes << reinterpret_cast<KisNode*>(pointerValue);
                }
            }
        }
    }
 
    if (!nodes.isEmpty() && (forceCopy || copyNode || sourceImage != image)) {
        KisImageReadOnlyBarrierLock lock(sourceImage, std::defer_lock);
        if (sourceImage) {
            lock.lock();
        }
 
        QList<KisNodeSP> clones;
        Q_FOREACH (KisNodeSP node, nodes) {
            node = safeCopyNode(node, sourceImage != image);
            if ((forceCopy || copyNode) && sourceImage == image) {
                KisLayerUtils::addCopyOfNameTag(node);
            }
            initializeExternalNode(&node, sourceImage, image, shapeController);
            clones << node;
        }
        nodes = clones;
        copyNode = true;
    }
    return nodes;
}

References KisLayerUtils::addCopyOfNameTag(), initializeExternalNode(), m_forceCopy, m_image, and nodes().

Member Data Documentation

m_copiedBounds

QRect KisMimeData::m_copiedBounds

private

Definition at line 133 of file kis_mimedata.h.

m_forceCopy

bool KisMimeData::m_forceCopy

private

Definition at line 131 of file kis_mimedata.h.

m_image

KisImageSP KisMimeData::m_image

private

Definition at line 132 of file kis_mimedata.h.

m_nodes

QList<KisNodeSP> KisMimeData::m_nodes

private

Definition at line 130 of file kis_mimedata.h.

---

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

• libs/ui/kis_mimedata.h
• libs/ui/kis_mimedata.cpp