KisClipboard Class Reference

#include <kis_clipboard.h>

Inheritance diagram for KisClipboard:

Public Types
enum	PasteBehaviour { PASTE_ASSUME_WEB = 0 , PASTE_ASSUME_MONITOR , PASTE_ASK }
enum	PasteFormatBehaviour { PASTE_FORMAT_ASK = 0 , PASTE_FORMAT_DOWNLOAD , PASTE_FORMAT_LOCAL , PASTE_FORMAT_CLIP }

Signals
void	clipChanged ()

Public Member Functions
QPair< bool, PasteFormatBehaviour >	askUserForSource (const QMimeData *data, bool useClipboardFallback=false) const
QPair< bool, PasteFormatBehaviour >	askUserForSourceWithData (QImage qimage, const QList< QUrl > urls, bool useClipboardFallback=false) const
KisPaintDeviceSP	clip (const QRect &imageBounds, bool showPopup, int overridePasteBehaviour=-1, KisTimeSpan *clipRange=nullptr) const
KisPaintDeviceSP	clipFromBoardContents (const QMimeData *data, const QRect &imageBounds, bool showPopup, int overridePasteBehaviour=-1, bool useClipboardFallback=false, QPair< bool, PasteFormatBehaviour > source={ false, PasteFormatBehaviour::PASTE_FORMAT_ASK}) const
KisPaintDeviceSP	clipFromBoardContentsWithData (QImage image, const QList< QUrl > urls, const QRect &imageBounds, bool showPopup, int overridePasteBehaviour=-1, bool useClipboardFallback=false, QPair< bool, PasteFormatBehaviour > source={false, PasteFormatBehaviour::PASTE_FORMAT_ASK}) const
KisPaintDeviceSP	clipFromKritaLayers (const KoColorSpace *cs) const
KisPaintDeviceSP	clipFromMimeData (const QMimeData *data, const QRect &imageBounds, bool showPopup, int overridePasteBehaviour=-1, KisTimeSpan *clipRange=nullptr, bool useClipboardFallback=false) const
QSize	clipSize () const
QImage	getImageWithFallback (const QMimeData *cbData, bool useClipboardFallback=false) const
bool	hasClip () const
bool	hasImage () const
bool	hasLayers () const
bool	hasLayerStyles () const
bool	hasUrls () const
	KisClipboard ()
const QMimeData *	layersMimeData () const
void	setClip (KisPaintDeviceSP dev, const QPoint &topLeft)
void	setClip (KisPaintDeviceSP dev, const QPoint &topLeft, const KisTimeSpan &range)
void	setLayers (KisNodeList nodes, KisImageSP image, bool forceCopy=false)
	~KisClipboard () override

Static Public Member Functions
static KisClipboard *	instance ()

Properties
bool	clip

Private Slots
void	clipboardDataChanged ()

Private Member Functions
KisPaintDeviceSP	clipFromKritaSelection (const QMimeData *data, const QRect &imageBounds, KisTimeSpan *clipRange) const
KisPaintDeviceSP	fetchImageByURL (const QUrl &originalUrl) const
QImage	getImageFromMimeData (const QMimeData *cbData) const
	Q_DISABLE_COPY (KisClipboard)

Private Attributes
KisClipboardPrivate *const	d

Detailed Description

The Krita clipboard is a clipboard that can store paint devices instead of just qimage's.

Definition at line 31 of file kis_clipboard.h.

Member Enumeration Documentation

PasteBehaviour

enum KisClipboard::PasteBehaviour

Enumerator
PASTE_ASSUME_WEB
PASTE_ASSUME_MONITOR
PASTE_ASK

Definition at line 38 of file kis_clipboard.h.

{ PASTE_ASSUME_WEB = 0, PASTE_ASSUME_MONITOR, PASTE_ASK };

PasteFormatBehaviour

enum KisClipboard::PasteFormatBehaviour

Enumerator
PASTE_FORMAT_ASK
PASTE_FORMAT_DOWNLOAD
PASTE_FORMAT_LOCAL
PASTE_FORMAT_CLIP

Definition at line 40 of file kis_clipboard.h.

{ PASTE_FORMAT_ASK = 0, PASTE_FORMAT_DOWNLOAD, PASTE_FORMAT_LOCAL, PASTE_FORMAT_CLIP };

Constructor & Destructor Documentation

KisClipboard()

KisClipboard::KisClipboard

(

)

Definition at line 67 of file kis_clipboard.cc.

    : d(new KisClipboardPrivate)
{
    // Check that we don't already have a clip ready
    clipboardDataChanged();
 
    // Make sure we are notified when clipboard changes
    connect(d->clipboard, &QClipboard::dataChanged, this, &KisClipboard::clipboardDataChanged, Qt::UniqueConnection);
}

References KisClipboardPrivate::clipboard, clipboardDataChanged(), and d.

~KisClipboard()

KisClipboard::~KisClipboard ( )

override

Definition at line 77 of file kis_clipboard.cc.

{
    dbgRegistry << "deleting KisClipBoard";
    delete d;
}

References d, and dbgRegistry.

Member Function Documentation

askUserForSource()

QPair< bool, KisClipboard::PasteFormatBehaviour > KisClipboard::askUserForSource	(	const QMimeData *	data,
		bool	useClipboardFallback = false ) const

Given the mimedata for a paste event, ask user which source they'll want to use for the image.

Returns

A pair of bool and PasteFormatBehaviour: The boolean indicates acceptance of the paste event. If set, the PasteFormatBehaviour member indicates the chosen source.

Definition at line 383 of file kis_clipboard.cc.

{
    if (!cbData) {
        return {false, PASTE_FORMAT_ASK};
    }
    const QImage qimage = getImageWithFallback(cbData, useClipboardFallback);
    QList<QUrl> urls = cbData->urls();
 
    return askUserForSourceWithData(qimage, urls, useClipboardFallback);
}

References askUserForSourceWithData(), getImageWithFallback(), and PASTE_FORMAT_ASK.

askUserForSourceWithData()

QPair< bool, KisClipboard::PasteFormatBehaviour > KisClipboard::askUserForSourceWithData	(	QImage	qimage,
		const QList< QUrl >	urls,
		bool	useClipboardFallback = false ) const

Definition at line 395 of file kis_clipboard.cc.

{
    KisConfig cfg(true);
 
    bool saveSourceSetting = false;
 
    auto choice = (PasteFormatBehaviour)cfg.pasteFormat(false);
 
    if (!qimage.isNull() || !urls.isEmpty()) {
        bool local = false;
        bool remote = false;
        bool isURI = false;
 
        std::for_each(urls.constBegin(), urls.constEnd(), [&](const QUrl &url) {
            local |= url.isLocalFile();
            remote |= !url.isLocalFile();
            isURI |= url.scheme() == "data";
        });
 
        const bool hasMultipleFormatsAvailable = (remote && local)
                || (remote && !qimage.isNull()) || (local && !qimage.isNull());
 
        const bool defaultOptionUnavailable =
                (!remote && choice == PASTE_FORMAT_DOWNLOAD)
                || (!local && choice == PASTE_FORMAT_LOCAL)
                || (qimage.isNull() && choice == PASTE_FORMAT_CLIP);
 
        dbgUI << "Incoming paste event:";
        dbgUI << "\tHas attached bitmap:" << !qimage.isNull();
        dbgUI << "\tHas local images:" << local;
        dbgUI << "\tHas remote images:" << remote;
        dbgUI << "\tHas multiple formats:" << hasMultipleFormatsAvailable;
        dbgUI << "\tDefault source preference" << choice;
        dbgUI << "\tDefault source available:" << !defaultOptionUnavailable;
        dbgUI << "\tIs data URI:" << isURI;
 
        if (hasMultipleFormatsAvailable && choice == PASTE_FORMAT_ASK && !isURI) {
            KisDlgPasteFormat dlg(qApp->activeWindow());
 
            dlg.setSourceAvailable(PASTE_FORMAT_DOWNLOAD, remote);
            dlg.setSourceAvailable(PASTE_FORMAT_LOCAL, local);
            dlg.setSourceAvailable(PASTE_FORMAT_CLIP, !qimage.isNull());
 
            if (dlg.exec() != KoDialog::Accepted) {
                return {false, PASTE_FORMAT_ASK};
            };
 
            choice = dlg.source();
 
            saveSourceSetting = dlg.remember();
        } else if (defaultOptionUnavailable || choice == PASTE_FORMAT_ASK) {
            if (remote) {
                choice = PASTE_FORMAT_DOWNLOAD;
            } else if (local) {
                choice = PASTE_FORMAT_LOCAL;
            } else if (!qimage.isNull()) {
                choice = PASTE_FORMAT_CLIP;
            } else {
                return {false, PASTE_FORMAT_ASK};
            }
        } else if (isURI) {
            choice = PASTE_FORMAT_DOWNLOAD;
        }
    }
 
    if (saveSourceSetting) {
        cfg.setPasteFormat(choice);
    }
 
    dbgUI << "Selected source for the paste:" << choice;
 
    return {true, choice};
}

References dbgUI, PASTE_FORMAT_ASK, PASTE_FORMAT_CLIP, PASTE_FORMAT_DOWNLOAD, PASTE_FORMAT_LOCAL, KisConfig::pasteFormat(), KisDlgPasteFormat::remember(), KisConfig::setPasteFormat(), KisDlgPasteFormat::setSourceAvailable(), and KisDlgPasteFormat::source().

clip()

KisPaintDeviceSP KisClipboard::clip	(	const QRect &	imageBounds,
		bool	showPopup,
		int	overridePasteBehaviour = -1,
		KisTimeSpan *	clipRange = nullptr ) const

Get the contents of the clipboard in the form of a paint device.

Definition at line 182 of file kis_clipboard.cc.

{
    const QMimeData *cbData = d->clipboard->mimeData();
 
    if (!cbData) {
        return nullptr;
    }
 
    dbgUI << Q_FUNC_INFO;
    dbgUI << "\tFormats: " << cbData->formats();
    dbgUI << "\tUrls: " << cbData->urls();
    dbgUI << "\tHas images: " << cbData->hasImage();
 
    return clipFromMimeData(cbData, imageBounds, showPopup, overridePasteBehaviour, clipRange, true);
}

References KisClipboardPrivate::clipboard, clipFromMimeData(), d, and dbgUI.

clipboardDataChanged

void KisClipboard::clipboardDataChanged ( )

privateslot

Definition at line 584 of file kis_clipboard.cc.

{
    if (!d->pushedClipboard) {
        const QMimeData *cbData = d->clipboard->mimeData();
        d->hasClip = d->clipboard->mimeData()->hasImage()
                || (cbData && cbData->hasFormat("application/x-krita-selection"));
    }
    d->pushedClipboard = false;
    Q_EMIT clipChanged();
}

References KisClipboardPrivate::clipboard, clipChanged(), d, KisClipboardPrivate::hasClip, and KisClipboardPrivate::pushedClipboard.

clipChanged

void KisClipboard::clipChanged ( )

signal

clipFromBoardContents()

KisPaintDeviceSP KisClipboard::clipFromBoardContents	(	const QMimeData *	data,
		const QRect &	imageBounds,
		bool	showPopup,
		int	overridePasteBehaviour = -1,
		bool	useClipboardFallback = false,
		QPair< bool, PasteFormatBehaviour >	source = { false, PasteFormatBehaviour::PASTE_FORMAT_ASK} ) const

Definition at line 469 of file kis_clipboard.cc.

{
    if (!cbData) {
        return nullptr;
    }
 
    // On wayland opening a dialog invalidates the clipboard data so we cache all the data beforehand
    const auto &urls = cbData->urls();
    const QImage qimage = getImageWithFallback(cbData, useClipboardFallback);
 
    return clipFromBoardContentsWithData(qimage,
                                         urls,
                                         imageBounds,
                                         showPopup,
                                         pasteBehaviourOverride,
                                         useClipboardFallback,
                                         source);
}

References clipFromBoardContentsWithData(), getImageWithFallback(), and source().

clipFromBoardContentsWithData()

KisPaintDeviceSP KisClipboard::clipFromBoardContentsWithData	(	QImage	image,
		const QList< QUrl >	urls,
		const QRect &	imageBounds,
		bool	showPopup,
		int	overridePasteBehaviour = -1,
		bool	useClipboardFallback = false,
		QPair< bool, PasteFormatBehaviour >	source = {false, PasteFormatBehaviour::PASTE_FORMAT_ASK} ) const

Definition at line 493 of file kis_clipboard.cc.

{
    KisPaintDeviceSP clip;
    PasteFormatBehaviour choice = PASTE_FORMAT_ASK;
 
    if (!source.first) {
        choice = askUserForSourceWithData(qimage , urls).second;
    } else {
        choice = source.second;
    }
 
    if (choice == PASTE_FORMAT_CLIP) {
        KIS_SAFE_ASSERT_RECOVER(!qimage.isNull())
        {
            warnKrita << "Clipboard was cleared before loading image";
            return nullptr;
        }
 
        int behaviour = pasteBehaviourOverride;
        bool saveColorSetting = false;
 
        KisConfig cfg(true);
 
        if (pasteBehaviourOverride == -1) {
            behaviour = cfg.pasteBehaviour();
        }
 
        if (behaviour == PASTE_ASK && showPopup) {
            // Ask user each time.
            KisDlgMissingColorProfile dlg(qApp->activeWindow());
 
            if (dlg.exec() != QDialog::Accepted) {
                return nullptr;
            }
 
            behaviour = dlg.source();
 
            saveColorSetting = dlg.remember(); // should we save this option to the config for next time?
        }
 
        const KoColorSpace *cs = nullptr;
        const KoColorProfile *profile = nullptr;
        if (!profile && behaviour == PASTE_ASSUME_MONITOR)
            profile = KisMimeData::displayConfigForMimePastes().profile;
 
        cs = KoColorSpaceRegistry::instance()->rgb8(profile);
        if (!cs) {
            cs = KoColorSpaceRegistry::instance()->rgb8();
            profile = cs->profile();
        }
 
        clip = new KisPaintDevice(cs);
        Q_CHECK_PTR(clip);
        clip->convertFromQImage(qimage, profile);
 
        // save the user's selection to the configuration if the option is checked
        if (saveColorSetting) {
            cfg.setPasteBehaviour(behaviour);
        }
    } else {
        const auto url = std::find_if(urls.constBegin(), urls.constEnd(), [&](const QUrl &url) {
            if (choice == PASTE_FORMAT_DOWNLOAD) {
                return !url.isLocalFile();
            } else if (choice == PASTE_FORMAT_LOCAL) {
                return url.isLocalFile();
            } else {
                return false;
            }
        });
 
        if (url != urls.constEnd()) {
            clip = fetchImageByURL(*url);
        }
    }
 
    if (clip && !imageBounds.isEmpty()) {
        QRect clipBounds = clip->exactBounds();
        QPoint diff = imageBounds.center() - clipBounds.center();
        clip->setX(diff.x());
        clip->setY(diff.y());
    }
 
    return clip;
}

References askUserForSourceWithData(), clip, KisMimeData::displayConfigForMimePastes(), fetchImageByURL(), KoColorSpaceRegistry::instance(), KIS_SAFE_ASSERT_RECOVER, PASTE_ASK, PASTE_ASSUME_MONITOR, PASTE_FORMAT_ASK, PASTE_FORMAT_CLIP, PASTE_FORMAT_LOCAL, KisConfig::pasteBehaviour(), KoColorSpace::profile(), KisDisplayConfig::profile, KisDlgMissingColorProfile::remember(), KoColorSpaceRegistry::rgb8(), KisConfig::setPasteBehaviour(), KisDlgMissingColorProfile::source(), source(), and warnKrita.

clipFromKritaLayers()

KisPaintDeviceSP KisClipboard::clipFromKritaLayers

(

const KoColorSpace *

cs

)

const

Definition at line 314 of file kis_clipboard.cc.

{
    const QMimeData *data = KisClipboard::instance()->layersMimeData();
 
    if (!data) {
        return nullptr;
    }
 
    const KisMimeData *mimedata = qobject_cast<const KisMimeData *>(data);
    if (!mimedata) return 0;
 
    KisNodeList nodes = mimedata->nodes();
 
    if (nodes.size() > 1) {
        // we explicitly include point (0,0) into the bounds since that
        // is a requirement for the image
        const QRect bounds =
            std::accumulate(nodes.begin(), nodes.end(), QRect(0, 0, 1, 1),
                            kismpl::mem_bit_or(&KisNode::exactBounds));
 
        // if no color space provided choose the most used one in the layer data
        if (cs == nullptr) {
            QHash<const KoColorSpace *, int> colorSpacesCount;
 
            Q_FOREACH (KisNodeSP node, nodes) {
                const KoColorSpace *colorSpace = node->colorSpace();
                if (colorSpace != nullptr) {
                    colorSpacesCount.insert(colorSpace, colorSpacesCount.value(colorSpace) + 1);
                }
            }
 
            int max = 0;
            for (auto it = colorSpacesCount.begin(); it != colorSpacesCount.end(); ++it) {
                if (it.value() > max) {
                    max = it.value();
                    cs = it.key();
                }
            }
 
            // fallback to rgb8 if no color space found
            // It is likely that this will never be triggered, but it's probably best to handle this just in case
            if (cs == nullptr) {
                cs = KoColorSpaceRegistry::instance()->rgb8();
            }
        }
 
        KisImageSP tempImage = new KisImage(nullptr,
                                            bounds.width(),
                                            bounds.height(),
                                            cs,
                                            "ClipImage");
 
        KisLayerUtils::filterMergeableNodes(nodes, false);
        for (KisNodeSP node : nodes) {
            tempImage->addNode(node, tempImage->root());
        }
        tempImage->refreshGraphAsync();
        KisLayerUtils::refreshHiddenAreaAsync(tempImage, tempImage->root(), bounds);
        tempImage->waitForDone();
 
        return tempImage->projection();
    } else if (!nodes.isEmpty()) {
        return nodes.first()->projection();
    }
 
    return nullptr;
}

References KisNodeFacade::addNode(), bounds, KisBaseNode::colorSpace(), KisBaseNode::exactBounds(), KisLayerUtils::filterMergeableNodes(), KoColorSpaceRegistry::instance(), instance(), layersMimeData(), kismpl::mem_bit_or(), KisMimeData::nodes(), KisImage::projection(), KisImage::refreshGraphAsync(), KisLayerUtils::refreshHiddenAreaAsync(), KoColorSpaceRegistry::rgb8(), KisNodeFacade::root, and KisImage::waitForDone().

clipFromKritaSelection()

KisPaintDeviceSP KisClipboard::clipFromKritaSelection ( const QMimeData * data, const QRect & imageBounds, KisTimeSpan * clipRange ) const

private

Definition at line 222 of file kis_clipboard.cc.

{
    const QByteArray mimeType = QByteArrayLiteral("application/x-krita-selection");
 
    KisPaintDeviceSP clip;
 
    if (!cbData) {
        return nullptr;
    }
 
    if (cbData->hasFormat(mimeType)) {
        QByteArray encodedData = cbData->data(mimeType);
        QBuffer buffer(&encodedData);
        QScopedPointer<KoStore> store(KoStore::createStore(&buffer, KoStore::Read, mimeType));
 
        const KoColorProfile *profile = 0;
 
        QString csDepth, csModel;
 
        // ColorSpace id of layer data
        if (store->hasFile("colormodel")) {
            store->open("colormodel");
            csModel = QString(store->read(store->size()));
            store->close();
        }
 
        if (store->hasFile("colordepth")) {
            store->open("colordepth");
            csDepth = QString(store->read(store->size()));
            store->close();
        }
 
        if (store->hasFile("profile.icc")) {
            QByteArray data;
            store->open("profile.icc");
            data = store->read(store->size());
            store->close();
            profile = KoColorSpaceRegistry::instance()->createColorProfile(csModel, csDepth, data);
        }
 
        const KoColorSpace *cs = KoColorSpaceRegistry::instance()->colorSpace(csModel, csDepth, profile);
        if (cs) {
            clip = new KisPaintDevice(cs);
 
            if (store->hasFile("layerdata")) {
                store->open("layerdata");
                if (!clip->read(store->device())) {
                    clip = 0;
                }
                store->close();
            }
 
            if (clip && !imageBounds.isEmpty()) {
                // load topLeft
                if (store->hasFile("topLeft")) {
                    store->open("topLeft");
                    QString str = store->read(store->size());
                    store->close();
                    QStringList list = str.split(' ');
                    if (list.size() == 2) {
                        QPoint topLeft(list[0].toInt(), list[1].toInt());
                        clip->setX(topLeft.x());
                        clip->setY(topLeft.y());
                    }
                }
 
                QRect clipBounds = clip->exactBounds();
 
                if (!imageBounds.contains(clipBounds) && !imageBounds.intersects(clipBounds)) {
                    QPoint diff = imageBounds.center() - clipBounds.center();
                    clip->setX(clip->x() + diff.x());
                    clip->setY(clip->y() + diff.y());
                }
 
                if (store->hasFile("timeRange") && clipRange) {
                    store->open("timeRange");
                    QString str = store->read(store->size());
                    store->close();
                    QStringList list = str.split(' ');
                    if (list.size() == 2) {
                        KisTimeSpan range = KisTimeSpan::fromTimeToTime(list[0].toInt(), list[1].toInt());
                        *clipRange = range;
                        dbgUI << "Pasted time range" << range;
                    }
                }
            }
        }
    }
 
    return clip;
}

References clip, KoColorSpaceRegistry::colorSpace(), KoColorSpaceRegistry::createColorProfile(), KoStore::createStore(), dbgUI, KisTimeSpan::fromTimeToTime(), KoColorSpaceRegistry::instance(), and KoStore::Read.

clipFromMimeData()

KisPaintDeviceSP KisClipboard::clipFromMimeData	(	const QMimeData *	data,
		const QRect &	imageBounds,
		bool	showPopup,
		int	overridePasteBehaviour = -1,
		KisTimeSpan *	clipRange = nullptr,
		bool	useClipboardFallback = false ) const

Get the contents of the specified mimedata buffer in the form of a paint device.

Definition at line 198 of file kis_clipboard.cc.

{
    if (clipRange) {
        *clipRange = KisTimeSpan();
    }
 
    KisPaintDeviceSP clip = clipFromKritaSelection(cbData, imageBounds, clipRange);
 
    if (!clip) {
        clip = clipFromKritaLayers(nullptr);
    }
 
    if (!clip) {
        clip = clipFromBoardContents(cbData, imageBounds, showPopup, overridePasteBehaviour, useClipboardFallback);
    }
 
    return clip;
}

References clip, clipFromBoardContents(), clipFromKritaLayers(), and clipFromKritaSelection().

clipSize()

QSize KisClipboard::clipSize

(

)

const

Definition at line 611 of file kis_clipboard.cc.

{
    const auto mimeType = QByteArrayLiteral("application/x-krita-selection");
    const QMimeData *cbData = d->clipboard->mimeData();
 
    KisPaintDeviceSP clip;
 
    if (cbData && cbData->hasFormat(mimeType)) {
        QByteArray encodedData = cbData->data(mimeType);
        QBuffer buffer(&encodedData);
        QScopedPointer<KoStore> store(KoStore::createStore(&buffer, KoStore::Read, mimeType));
        const KoColorProfile *profile = 0;
        QString csDepth, csModel;
 
        // ColorSpace id of layer data
        if (store->hasFile("colormodel")) {
            store->open("colormodel");
            csModel = QString(store->read(store->size()));
            store->close();
        }
 
        if (store->hasFile("colordepth")) {
            store->open("colordepth");
            csDepth = QString(store->read(store->size()));
            store->close();
        }
 
        if (store->hasFile("profile.icc")) {
            QByteArray data;
            store->open("profile.icc");
            data = store->read(store->size());
            store->close();
            profile = KoColorSpaceRegistry::instance()->createColorProfile(csModel, csDepth, data);
        }
 
        const KoColorSpace *cs = KoColorSpaceRegistry::instance()->colorSpace(csModel, csDepth, profile);
        if (!cs) {
            cs = KoColorSpaceRegistry::instance()->rgb8();
        }
        clip = new KisPaintDevice(cs);
 
        if (store->hasFile("layerdata")) {
            store->open("layerdata");
            clip->read(store->device());
            store->close();
        }
 
        return clip->exactBounds().size();
    } else {
        if (d->clipboard->mimeData()->hasImage()) {
            QImage qimage = d->clipboard->image();
            return qimage.size();
        }
    }
    return QSize();
}

References clip, KisClipboardPrivate::clipboard, KoColorSpaceRegistry::colorSpace(), KoColorSpaceRegistry::createColorProfile(), KoStore::createStore(), d, KoColorSpaceRegistry::instance(), KoStore::Read, and KoColorSpaceRegistry::rgb8().

fetchImageByURL()

KisPaintDeviceSP KisClipboard::fetchImageByURL ( const QUrl & originalUrl ) const

private

Definition at line 750 of file kis_clipboard.cc.

{
    KisPaintDeviceSP result;
    QUrl url(originalUrl);
    QScopedPointer<QTemporaryFile> tmp;
 
    if (!originalUrl.isLocalFile()) {
        tmp.reset(new QTemporaryFile());
        tmp->setAutoRemove(true);
 
        // download the file and substitute the url
        KisRemoteFileFetcher fetcher;
 
        if (!fetcher.fetchFile(originalUrl, tmp.data())) {
            qWarning() << "Fetching" << originalUrl << "failed";
            return result;
        }
        url = QUrl::fromLocalFile(tmp->fileName());
    }
 
    if (url.isLocalFile()) {
        QFileInfo fileInfo(url.toLocalFile());
 
        QString type = KisMimeDatabase::mimeTypeForFile(url.toLocalFile());
        QStringList mimes = KisImportExportManager::supportedMimeTypes(KisImportExportManager::Import);
 
        if (!mimes.contains(type)) {
            QString msg = KisImportExportErrorCode(ImportExportCodes::FileFormatNotSupported).errorMessage();
            QMessageBox::warning(KisPart::instance()->currentMainwindow(),
                                 i18nc("@title:window", "Krita"),
                                 i18n("Could not open %2.\nReason: %1.", msg, url.toDisplayString()));
            return result;
        }
 
        QScopedPointer<KisDocument> doc(KisPart::instance()->createDocument());
 
        if (doc->openPath(url.toLocalFile(), KisDocument::DontAddToRecent)) {
            // Wait for required updates, if any. BUG: 448256
            KisLayerUtils::forceAllDelayedNodesUpdate(doc->image()->root());
            doc->image()->waitForDone();
            result = new KisPaintDevice(*doc->image()->projection());
        } else {
            qWarning() << "Failed to import file" << url.toLocalFile();
        }
    }
 
    return result;
}

References createDocument(), KisDocument::DontAddToRecent, KisImportExportErrorCode::errorMessage(), KisRemoteFileFetcher::fetchFile(), ImportExportCodes::FileFormatNotSupported, KisLayerUtils::forceAllDelayedNodesUpdate(), KisImportExportManager::Import, KisPart::instance(), KisMimeDatabase::mimeTypeForFile(), and KisImportExportManager::supportedMimeTypes().

getImageFromMimeData()

QImage KisClipboard::getImageFromMimeData ( const QMimeData * cbData ) const

private

Definition at line 712 of file kis_clipboard.cc.

{
    static const QList<ClipboardImageFormat> supportedFormats = {
        {{"image/png"}, "PNG"},
        {{"image/tiff"}, "TIFF"},
        {{"image/bmp", "image/x-bmp", "image/x-MS-bmp", "image/x-win-bitmap"}, "BMP"}};
 
    QImage image;
    QSet<QString> clipboardMimeTypes;
 
    Q_FOREACH (const QString &format, cbData->formats()) {
        clipboardMimeTypes << format;
    }
 
    Q_FOREACH (const ClipboardImageFormat &item, supportedFormats) {
        const QSet<QString> &intersection = item.mimeTypes & clipboardMimeTypes;
        if (intersection.isEmpty()) {
            continue;
        }
 
        const QString &format = *intersection.constBegin();
        const QByteArray &imageData = cbData->data(format);
        if (imageData.isEmpty()) {
            continue;
        }
 
        if (image.loadFromData(imageData, item.format.toLatin1())) {
            break;
        }
    }
 
    if (image.isNull() && cbData->hasImage()) {
        image = qvariant_cast<QImage>(cbData->imageData());
    }
 
    return image;
}

References ClipboardImageFormat::format, and ClipboardImageFormat::mimeTypes.

getImageWithFallback()

QImage KisClipboard::getImageWithFallback	(	const QMimeData *	cbData,
		bool	useClipboardFallback = false ) const

Definition at line 595 of file kis_clipboard.cc.

{
    QImage qimage = getImageFromMimeData(cbData);
 
    if (qimage.isNull() && useClipboardFallback) {
        qimage = d->clipboard->image();
    }
 
    return qimage;
}

References KisClipboardPrivate::clipboard, d, and getImageFromMimeData().

hasClip()

bool KisClipboard::hasClip

(

)

const

Definition at line 606 of file kis_clipboard.cc.

{
    return d->hasClip;
}

References d, and KisClipboardPrivate::hasClip.

hasImage()

bool KisClipboard::hasImage

(

)

const

Definition at line 707 of file kis_clipboard.cc.

{
    return d->clipboard->mimeData()->hasImage();
}

References KisClipboardPrivate::clipboard, and d.

hasLayers()

bool KisClipboard::hasLayers

(

)

const

Definition at line 680 of file kis_clipboard.cc.

{
    const QByteArray mimeType = QByteArrayLiteral("application/x-krita-node-internal-pointer");
    return d->clipboard->mimeData()->hasFormat(mimeType);
}

References KisClipboardPrivate::clipboard, and d.

hasLayerStyles()

bool KisClipboard::hasLayerStyles

(

)

const

Definition at line 686 of file kis_clipboard.cc.

{
    // NOTE: please don't disable the paste action based on the
    //       result of this function, because we allow pasting
    //       of the layer styles as 'text/plain'
 
    return d->clipboard->mimeData()->hasFormat("application/x-krita-layer-style");
}

References KisClipboardPrivate::clipboard, and d.

hasUrls()

bool KisClipboard::hasUrls

(

)

const

Definition at line 701 of file kis_clipboard.cc.

{
    return d->clipboard->mimeData()->hasUrls();
}

References KisClipboardPrivate::clipboard, and d.

instance()

KisClipboard * KisClipboard::instance ( )

static

Definition at line 83 of file kis_clipboard.cc.

{
    return s_instance;
}

layersMimeData()

const QMimeData * KisClipboard::layersMimeData

(

)

const

Definition at line 695 of file kis_clipboard.cc.

{
    const QMimeData *cbData = d->clipboard->mimeData();
    return cbData->hasFormat("application/x-krita-node-internal-pointer") ? cbData : 0;
}

References KisClipboardPrivate::clipboard, and d.

Q_DISABLE_COPY()

KisClipboard::Q_DISABLE_COPY ( KisClipboard )

private

setClip() [1/2]

void KisClipboard::setClip	(	KisPaintDeviceSP	dev,
		const QPoint &	topLeft )

Sets the clipboard to the contents of the specified paint device; also set the system clipboard to a QImage representation of the specified paint device.

Parameters

dev	The paint device that will be stored on the clipboard
topLeft	a hint about the place where the clip should be pasted by default

Definition at line 177 of file kis_clipboard.cc.

{
    setClip(dev, topLeft, KisTimeSpan());
}

References setClip().

setClip() [2/2]

void KisClipboard::setClip	(	KisPaintDeviceSP	dev,
		const QPoint &	topLeft,
		const KisTimeSpan &	range )

Definition at line 88 of file kis_clipboard.cc.

{
    if (!dev)
        return;
 
    d->hasClip = true;
 
    // We'll create a store (ZIP format) in memory
    QBuffer buffer;
    const auto mimeType = QByteArrayLiteral("application/x-krita-selection");
    QScopedPointer<KoStore> store(KoStore::createStore(&buffer, KoStore::Write, mimeType));
    KisStorePaintDeviceWriter writer(store.data());
    Q_ASSERT(store);
    Q_ASSERT(!store->bad());
 
    // Layer data
    if (store->open("layerdata")) {
        if (!dev->write(writer)) {
            dev->disconnect();
            store->close();
            return;
        }
        store->close();
    }
 
    // copied frame time limits
    if (range.isValid() && store->open("timeRange")) {
        store->write(QString("%1 %2").arg(range.start()).arg(range.end()).toLatin1());
        store->close();
    }
 
    // Coordinates
    if (store->open("topLeft")) {
        store->write(QString("%1 %2").arg(topLeft.x()).arg(topLeft.y()).toLatin1());
        store->close();
    }
    // ColorSpace id of layer data
    if (store->open("colormodel")) {
        QString csName = dev->colorSpace()->colorModelId().id();
        store->write(csName.toLatin1());
        store->close();
    }
    if (store->open("colordepth")) {
        QString csName = dev->colorSpace()->colorDepthId().id();
        store->write(csName.toLatin1());
        store->close();
    }
 
    if (dev->colorSpace()->profile()) {
        const KoColorProfile *profile = dev->colorSpace()->profile();
        KisAnnotationSP annotation;
 
        if (profile && profile->type() == "icc" && !profile->rawData().isEmpty()) {
            annotation = new KisAnnotation("icc", profile->name(), profile->rawData());
 
            if (annotation) {
                // save layer profile
                if (store->open("profile.icc")) {
                    store->write(annotation->annotation());
                    store->close();
                }
            }
        }
    }
 
    QMimeData *mimeData = new QMimeData;
    Q_CHECK_PTR(mimeData);
 
    if (mimeData) {
        mimeData->setData(mimeType, buffer.buffer());
    }
 
    // We also create a QImage so we can interchange with other applications
    QImage qimage;
    const KisDisplayConfig displayConfig = KisMimeData::displayConfigForMimePastes();
 
    qimage = dev->convertToQImage(displayConfig.profile,
                                  displayConfig.intent,
                                  displayConfig.conversionFlags);
    if (!qimage.isNull() && mimeData) {
        mimeData->setImageData(qimage);
    }
 
    if (mimeData) {
        d->pushedClipboard = true;
        d->clipboard->setMimeData(mimeData);
    }
}

References KisClipboardPrivate::clipboard, KoColorSpace::colorDepthId(), KoColorSpace::colorModelId(), KisPaintDevice::colorSpace(), KisDisplayConfig::conversionFlags, KisPaintDevice::convertToQImage(), KoStore::createStore(), d, KisMimeData::displayConfigForMimePastes(), KisTimeSpan::end(), KisClipboardPrivate::hasClip, KoID::id(), KisDisplayConfig::intent, KisTimeSpan::isValid(), KoColorProfile::name, KoColorSpace::profile(), KisDisplayConfig::profile, KisClipboardPrivate::pushedClipboard, KoColorProfile::rawData(), KisTimeSpan::start(), KoColorProfile::type(), KisPaintDevice::write(), and KoStore::Write.

setLayers()

void KisClipboard::setLayers	(	KisNodeList	nodes,
		KisImageSP	image,
		bool	forceCopy = false )

See a comment in KisMimeData::deepCopyNodes()

Definition at line 668 of file kis_clipboard.cc.

{
    QMimeData *data = KisMimeData::mimeForLayersDeepCopy(nodes, image, forceCopy);
    if (!data)
        return;
 
    d->clipboard->setMimeData(data);
}

References KisClipboardPrivate::clipboard, d, and KisMimeData::mimeForLayersDeepCopy().

Member Data Documentation

d

KisClipboardPrivate* const KisClipboard::d

private

Definition at line 144 of file kis_clipboard.h.

Property Documentation

clip

bool KisClipboard::clip

read

Definition at line 35 of file kis_clipboard.h.

---

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

• libs/ui/kis_clipboard.h
• libs/ui/kis_clipboard.cc