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 (KisDefaultBoundsBaseSP defaultBounds, bool showPopup, int overridePasteBehaviour=-1) const
KisImageSP	clipFromBoardContentsWithData (QImage image, const QList< QUrl > urls, bool showPopup, int overridePasteBehaviour=-1, QPair< bool, PasteFormatBehaviour > source={false, PasteFormatBehaviour::PASTE_FORMAT_ASK}) const
KisPaintDeviceSP	clipFromKritaLayers (const KoColorSpace *cs, KisDefaultBoundsBaseSP defaultBounds) const
KisImageSP	clipImage (bool showPopup, int overridePasteBehaviour=-1) const
KisImageSP	clipImageFromBoardContents (bool showPopup, int overridePasteBehaviour, QPair< bool, PasteFormatBehaviour > source={false, PasteFormatBehaviour::PASTE_FORMAT_ASK}) const
KisImageSP	clipImageFromKritaLayers (const KoColorSpace *cs=nullptr) const
KisImageSP	fetchImageByURL (const QUrl &originalUrl) 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
const KoColorSpace *	referenceColorSpace () const
void	setLayers (KisNodeList nodes, KisImageSP image, const QRect referenceRect, bool forceCopy=false)
	~KisClipboard () override

Static Public Member Functions
static KisClipboard *	instance ()

Properties
bool	clip

Private Slots
void	clipboardDataChanged ()

Private Member Functions
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 34 of file kis_clipboard.h.

Member Enumeration Documentation

PasteBehaviour

enum KisClipboard::PasteBehaviour

Enumerator
PASTE_ASSUME_WEB
PASTE_ASSUME_MONITOR
PASTE_ASK

Definition at line 41 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 43 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 71 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 81 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 184 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 196 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	(	KisDefaultBoundsBaseSP	defaultBounds,
		bool	showPopup,
		int	overridePasteBehaviour = -1 ) const

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

If the paint device originates from Krita itself, it may have non-transparent default pixel and hence infinite visual extent. To handle the case properly, the caller must provide a valid defaultBounds object, which will make the infinite clip to limit itself inside the bounds of the relevant image.

Definition at line 92 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();
 
    KisPaintDeviceSP clip = clipFromKritaLayers(nullptr, defaultBounds);
 
    if (!clip) {
        KisImageSP clipImage = clipImageFromBoardContents(showPopup, overridePasteBehaviour);
        if (clipImage) {
            clip = new KisPaintDevice(*clipImage->projection());
            clip->setDefaultBounds(defaultBounds);
        }
    }
 
    return clip;
}

References clip, KisClipboardPrivate::clipboard, clipFromKritaLayers(), clipImage(), clipImageFromBoardContents(), d, dbgUI, and KisImage::projection().

clipboardDataChanged

void KisClipboard::clipboardDataChanged ( )

privateslot

Definition at line 359 of file kis_clipboard.cc.

{
    d->hasClip = d->clipboard->mimeData()->hasImage();
 
    const KisMimeData *mimedata = qobject_cast<const KisMimeData *>(d->clipboard->mimeData());
    if (mimedata) {
        d->referenceColorSpace = mimedata->referenceColorSpace();
    } else {
        d->referenceColorSpace = nullptr;
    }
 
    Q_EMIT clipChanged();
}

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

clipChanged

void KisClipboard::clipChanged ( )

signal

clipFromBoardContentsWithData()

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

Definition at line 270 of file kis_clipboard.cc.

{
    KisImageSP clipImage;
    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 = overridePasteBehaviour;
        bool saveColorSetting = false;
 
        KisConfig cfg(true);
 
        if (overridePasteBehaviour == -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();
        }
 
        KisImageSP image = new KisImage(nullptr, qimage.width(), qimage.height(), cs, "clip");
        if (qimage.dotsPerMeterX() > 0 && qimage.dotsPerMeterY() > 0) {
            image->setResolution(qimage.dotsPerMeterX() / 72.0 * 0.0254, qimage.dotsPerMeterY() / 72.0 * 0.0254);
        }
        KisPaintLayerSP layer = new KisPaintLayer(image, "clip", OPACITY_OPAQUE_U8);
        image->addNode(layer);
        layer->paintDevice()->convertFromQImage(qimage, profile);
 
        clipImage = image;
 
        // 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()) {
            clipImage = fetchImageByURL(*url);
        }
    }
 
    return clipImage;
}

References KisNodeFacade::addNode(), askUserForSourceWithData(), clipImage(), KisPaintDevice::convertFromQImage(), KisMimeData::displayConfigForMimePastes(), fetchImageByURL(), KoColorSpaceRegistry::instance(), KIS_SAFE_ASSERT_RECOVER, OPACITY_OPAQUE_U8, KisPaintLayer::paintDevice, 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(), KisImage::setResolution(), KisDlgMissingColorProfile::source(), source(), and warnKrita.

clipFromKritaLayers()

KisPaintDeviceSP KisClipboard::clipFromKritaLayers	(	const KoColorSpace *	cs,
		KisDefaultBoundsBaseSP	defaultBounds ) const

Definition at line 157 of file kis_clipboard.cc.

{
    KisPaintDeviceSP result;
 
    const QMimeData *data = KisClipboard::instance()->layersMimeData();
    if (!data) return result;
 
    const KisMimeData *mimedata = qobject_cast<const KisMimeData *>(data);
    if (!mimedata) return result;
 
    return mimedata->clipFromKritaLayers(cs, defaultBounds);
}

References KisMimeData::clipFromKritaLayers(), instance(), and layersMimeData().

clipImage()

KisImageSP KisClipboard::clipImage	(	bool	showPopup,
		int	overridePasteBehaviour = -1 ) const

Get the contents of the clipboard in a form of a bounded image. To get the contents of the image just use the normal image->projection() device.

The origin of the "clip" is always placed at point (0,0) of the image. The size of the image equals to the size of the original "clip"

The meaning of the "clip size" depends on where the clip comes from:

• when pasted from the clipboard buffer (i.e. QClipboard::image()), the size of the image equals to the size of the image in the buffer

• when pasted from a URL, the size of the image also equals the size of the image in the file.

  There is small complication though: if the source file is .kra, then image->projection() may have non-transparent default pixel. The caller should be ready to handle that by either keeping the parent KisImage alive all the time or by setting his own defaultBounds object on it.

• when pasted from a Krita selection, then the top-left of the selection is placed at point (0,0) and the size of the image equals to the original size of the selection
• when paster from a Krita layer, then the size of the image equals to the size of the original source image

Definition at line 120 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();
 
    KisImageSP clipImage = clipImageFromKritaLayers(nullptr);
 
    if (!clipImage) {
        clipImage = clipImageFromBoardContents(showPopup, overridePasteBehaviour);
    }
 
    return clipImage;
}

References KisClipboardPrivate::clipboard, clipImage(), clipImageFromBoardContents(), clipImageFromKritaLayers(), d, and dbgUI.

clipImageFromBoardContents()

KisImageSP KisClipboard::clipImageFromBoardContents	(	bool	showPopup,
		int	overridePasteBehaviour,
		QPair< bool, PasteFormatBehaviour >	source = {false, PasteFormatBehaviour::PASTE_FORMAT_ASK} ) const

Definition at line 142 of file kis_clipboard.cc.

{
    const QMimeData *cbData = d->clipboard->mimeData();
 
    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, true);
 
    return clipFromBoardContentsWithData(qimage, urls, showPopup, overridePasteBehaviour, source);
}

References KisClipboardPrivate::clipboard, clipFromBoardContentsWithData(), d, getImageWithFallback(), and source().

clipImageFromKritaLayers()

KisImageSP KisClipboard::clipImageFromKritaLayers

(

const KoColorSpace *

cs = nullptr

)

const

Definition at line 170 of file kis_clipboard.cc.

{
    KisImageSP resultImage;
 
    const QMimeData *data = KisClipboard::instance()->layersMimeData();
    if (!data) return resultImage;
 
    const KisMimeData *mimedata = qobject_cast<const KisMimeData *>(data);
    if (!mimedata) return resultImage;
 
    return mimedata->clipImageFromKritaLayers(cs);
}

References KisMimeData::clipImageFromKritaLayers(), instance(), and layersMimeData().

fetchImageByURL()

KisImageSP KisClipboard::fetchImageByURL

(

const QUrl &

originalUrl

)

const

Definition at line 476 of file kis_clipboard.cc.

{
    KisImageSP clipImage;
    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 clipImage;
        }
        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 clipImage;
        }
 
        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();
 
            KisPaintDeviceSP clonedProjection(new KisPaintDevice(*doc->image()->projection()));
 
            KisImageSP image = new KisImage(nullptr, doc->image()->width(), doc->image()->height(), doc->image()->projection()->colorSpace(), "clip");
            image->setResolution(doc->image()->xRes(), doc->image()->yRes());
 
            KisPaintLayerSP layer = new KisPaintLayer(image, "clip", OPACITY_OPAQUE_U8, clonedProjection);
            image->addNode(layer);
 
            clipImage = image;
        } else {
            qWarning() << "Failed to import file" << url.toLocalFile();
        }
    }
 
    return clipImage;
}

References KisNodeFacade::addNode(), clipImage(), KisDocument::DontAddToRecent, KisImportExportErrorCode::errorMessage(), KisRemoteFileFetcher::fetchFile(), ImportExportCodes::FileFormatNotSupported, KisLayerUtils::forceAllDelayedNodesUpdate(), KisImportExportManager::Import, KisPart::instance(), KisMimeDatabase::mimeTypeForFile(), OPACITY_OPAQUE_U8, KisImage::setResolution(), and KisImportExportManager::supportedMimeTypes().

getImageFromMimeData()

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

private

Definition at line 438 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 373 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 384 of file kis_clipboard.cc.

{
    return d->hasClip;
}

References d, and KisClipboardPrivate::hasClip.

hasImage()

bool KisClipboard::hasImage

(

)

const

Definition at line 433 of file kis_clipboard.cc.

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

References KisClipboardPrivate::clipboard, and d.

hasLayers()

bool KisClipboard::hasLayers

(

)

const

Definition at line 406 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 412 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 427 of file kis_clipboard.cc.

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

References KisClipboardPrivate::clipboard, and d.

instance()

KisClipboard * KisClipboard::instance ( )

static

Definition at line 87 of file kis_clipboard.cc.

{
    return s_instance;
}

layersMimeData()

const QMimeData * KisClipboard::layersMimeData

(

)

const

Definition at line 421 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

referenceColorSpace()

const KoColorSpace * KisClipboard::referenceColorSpace

(

)

const

See also

KisMimeData::referenceColorSpace()

Definition at line 389 of file kis_clipboard.cc.

{
    return d->referenceColorSpace;
}

References d, and KisClipboardPrivate::referenceColorSpace.

setLayers()

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

See a comment in KisMimeData::deepCopyNodes()

Definition at line 394 of file kis_clipboard.cc.

{
    QMimeData *data = KisMimeData::mimeForLayersDeepCopy(nodes, image, referenceRect, 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 153 of file kis_clipboard.h.

Property Documentation

clip

bool KisClipboard::clip

read

Definition at line 38 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