#include <KisDocument.h>

Inheritance diagram for KisDocument:

Public Types
enum	OpenFlag { None = 0 , DontAddToRecent = 0x1 , RecoveryFile = 0x2 }

Signals
void	canceled (const QString &)

void	clearStatusBarMessage ()

void	completed ()

void	modified (bool)

void	sigAssistantsChanged ()

void	sigAudioLevelChanged (qreal level)

void	sigAudioTracksChanged ()

void	sigBackgroundSavingFinished (KisImportExportErrorCode status, const QString &errorMessage, const QString &warningMessage)

void	sigCompleteBackgroundSaving (const KritaUtils::ExportFileJob &job, KisImportExportErrorCode status, const QString &errorMessage, const QString &warningMessage)

void	sigGridConfigChanged (const KisGridConfig &config)

void	sigGuidesConfigChanged (const KisGuidesConfig &config)

void	sigLoadingFinished ()

void	sigMirrorAxisConfigChanged ()

void	sigPaletteListChanged (const QList< KoColorSetSP > &oldPaletteList, const QList< KoColorSetSP > &newPaletteList)

void	sigPathChanged (const QString &path)

void	sigReadWriteChanged (bool value)

void	sigRecoveredChanged (bool value)

void	sigReferenceImagesChanged ()

void	sigReferenceImagesLayerChanged (KisSharedPtr< KisReferenceImagesLayer > layer)

void	sigSavingFinished (const QString &filePath)

void	sigStoryboardCommentListChanged ()

void	sigStoryboardItemListChanged ()

void	statusBarMessage (const QString &text, int timeout=0)

void	unitChanged (const KoUnit &unit)

Public Member Functions
QList< KisPaintingAssistantSP >	assistants () const

QColor	assistantsGlobalColor ()

void	autoSaveOnPause ()
	Start saving when android activity is pushed to the background.

QString	caption () const

void	clearUndoHistory ()

KisDocument *	clone (bool addStorage=false)
	creates a clone of the document and returns it. Please make sure that you hold all the necessary locks on the image before asking for a clone!

bool	closePath (bool promptToSave=true)

QList< KoColor >	colorHistoryColors () const

KisUniqueColorSet *	colorHistoryModel ()

void	copyFrom (const Private &rhs, KisDocument *q)

void	copyFromDocument (const KisDocument &rhs)

void	copyFromImpl (const Private &rhs, KisDocument *q, KisDocument::CopyPolicy policy)

KoDocumentInfoDlg *	createDocumentInfoDialog (QWidget parent, KoDocumentInfo docInfo) const

QDomDocument	createDomDocument (const QString &tagName, const QString &version) const

KisUndoStore *	createUndoStore ()

QRectF	documentBounds () const

KoDocumentInfo *	documentInfo () const

QString	embeddedResourcesStorageId () const

QString	errorMessage () const

bool	exportDocument (const QString &path, const QByteArray &mimeType, bool isAdvancedExporting=false, bool showWarnings=false, KisPropertiesConfigurationSP exportConfiguration=0)

bool	exportDocumentSync (const QString &path, const QByteArray &mimeType, KisPropertiesConfigurationSP exportConfiguration=0)

bool	fileBatchMode () const

QPixmap	generatePreview (const QSize &size)
	Generates a preview picture of the document.

qreal	getAudioLevel ()

QVector< QFileInfo >	getAudioTracks () const

QVector< StoryboardComment >	getStoryboardCommentsList ()
	returns the list of comments for the storyboard docker in the document

StoryboardItemList	getStoryboardItemList ()
	returns the list of pointers to storyboard Items for the document

KisGridConfig	gridConfig () const

const KisGuidesConfig &	guidesConfig () const
	returns the guides data for this document.

void	hackPreliminarySetImage (KisImageSP image)

KisImageWSP	image () const

bool	importDocument (const QString &path)

KisImportExportManager *	importExportManager () const
	importExportManager gives access to the internal import/export manager

bool	isAutoSaveActive ()

bool	isAutosaving () const

bool	isInSaving () const
	isInSaving shown if the document has any (background) saving process or not

bool	isModified () const

bool	isNativeFormat (const QByteArray &mimeType) const
	Checks whether a given mimeType can be handled natively.

bool	isReadWrite () const

bool	isRecovered () const

bool	isSaving () const

QList< KoResourceLoadResult >	linkedDocumentResources ()
	linkedDocumentResources List returns all the resources linked to the document, such as palettes

QString	linkedResourcesStorageId () const

bool	loadNativeFormat (const QString &file)

QString	localFilePath () const

KisDocument *	lockAndCloneForSaving ()
	try to clone the image. This method handles all the locking for you. If locking has failed, no cloning happens

KisDocument *	lockAndCloneImpl (bool fetchResourcesFromLayers)

KisDocument *	lockAndCreateSnapshot ()

QByteArray	mimeType () const

const KisMirrorAxisConfig &	mirrorAxisConfig () const

bool	newImage (const QString &name, qint32 width, qint32 height, const KoColorSpace *cs, const KoColor &bgColor, KisConfig::BackgroundStyle bgStyle, int numberOfLayers, const QString &imageDescription, const double imageResolution)

bool	openPath (const QString &path, OpenFlags flags=None)
	openPath Open a Path

QString	path () const

KisNodeSP	preActivatedNode () const

	Private (const Private &rhs, KisDocument *_q)

	Private (KisDocument *_q)

KisSharedPtr< KisReferenceImagesLayer >	referenceImagesLayer () const

void	removeAutoSaveFiles (const QString &autosaveBaseName, bool wasRecovered)

void	resetPath ()

bool	save (bool showWarnings, KisPropertiesConfigurationSP exportConfiguration)

bool	saveAs (const QString &path, const QByteArray &mimeType, bool showWarnings, KisPropertiesConfigurationSP exportConfiguration=0)

KisImageSP	savingImage () const
	savingImage provides a detached, shallow copy of the original image that must be used when saving. Any strokes in progress will not be applied to this image, so the result might be missing some data. On the other hand, it won't block.

QByteArray	serializeToNativeByteArray ()
	serializeToNativeByteArray daves the document into a .kra file written to a memory-based byte-array

void	setAssistants (const QList< KisPaintingAssistantSP > &value)
	@replace the current list of assistants with

void	setAssistantsGlobalColor (QColor color)

void	setAudioTracks (QVector< QFileInfo > f)

void	setAudioVolume (qreal level)

void	setAutoSaveActive (bool autoSaveIsActive)

void	setColorHistoryColors (const QList< KoColor > &colors)

void	setCurrentImage (KisImageSP image, bool forceInitialUpdate=true, KisNodeSP preActivatedNode=nullptr)

void	setEmergencyAutoSaveInterval ()

void	setEmpty (bool empty=true)
	Sets the document to empty.

void	setErrorMessage (const QString &errMsg)

void	setFileBatchMode (const bool batchMode)

void	setGridConfig (const KisGridConfig &config)

void	setGuidesConfig (const KisGuidesConfig &data)

void	setImageAndInitIdleWatcher (KisImageSP _image)

void	setInfiniteAutoSaveInterval ()

void	setLocalFilePath (const QString &localFilePath)

void	setMimeType (const QByteArray &mimeType)
	Sets the mime type for the document.

void	setMimeTypeAfterLoading (const QString &mimeType)

void	setMirrorAxisConfig (const KisMirrorAxisConfig &config)

void	setModified (bool _mod)

void	setNormalAutoSaveInterval ()

void	setPaletteList (const QList< KoColorSetSP > &paletteList, bool emitSignal=false)
	setPaletteList replaces the palettes in the document's local resource storage with the list of palettes passed to this function. It will then Q_EMIT sigPaletteListChanged with both the old and the new list, if emitSignal is true.

void	setPath (const QString &path)

void	setPreActivatedNode (KisNodeSP activatedNode)

void	setReadWrite (bool readwrite=true)
	Sets whether the document can be edited or is read only.

void	setRecovered (bool value)

void	setReferenceImagesLayer (KisSharedPtr< KisReferenceImagesLayer > layer, bool updateImage)

void	setStoryboardCommentList (const QVector< StoryboardComment > &storyboardCommentList, bool emitSignal=false)
	sets the list of comments for the storyboard docker in the document, emits empty signal if emitSignal is true.

void	setStoryboardItemList (const StoryboardItemList &storyboardItemList, bool emitSignal=false)
	sets the storyboardItemList in the document, emits empty signal if emitSignal is true.

void	setUnit (const KoUnit &unit)

void	setWarningMessage (const QString &warningMsg)

KoShapeControllerBase *	shapeController () const

KoShapeLayer *	shapeForNode (KisNodeSP layer) const

void	syncDecorationsWrapperLayerState ()

KUndo2Stack *	undoStack ()

KoUnit	unit () const

void	updateDocumentMetadataOnSaving (const QString &filePath, const QByteArray &mimeType)

void	updateEditingTime (bool forceStoreElapsed)

void	uploadLinkedResourcesFromLayersToStorage ()

void	waitForSavingToComplete ()

QString	warningMessage () const

	~KisDocument ()

	~Private ()

Static Public Member Functions
static QDomDocument	createDomDocument (const QString &appName, const QString &tagName, const QString &version)

static QStringList	extraNativeMimeTypes ()

static QByteArray	nativeFormatMimeType ()

Public Attributes
QList< KisPaintingAssistantSP >	assistants

qreal	audioLevel = 1.0

QVector< QFileInfo >	audioTracks

bool	autoSaveActive = true

int	autoSaveDelay = 300

int	autoSaveFailureCount = 0

QTimer *	autoSaveTimer

std::unique_ptr< KisDocument >	backgroundSaveDocument

KritaUtils::ExportFileJob	backgroundSaveJob

bool	batchMode { false }

QFuture< KisImportExportErrorCode >	childSavingFuture

KisUniqueColorSet	colorHistoryModel

QMetaObject::Connection	completeSavingConnection

bool	decorationsSyncingDisabled = false

bool	disregardAutosaveFailure = false

KoDocumentInfo *	docInfo = 0

bool	documentIsClosing = false

QString	embeddedResourcesStorageID

KisResourceStorageSP	embeddedResourceStorage

QDateTime	firstMod

QColor	globalAssistantsColor

KisGridConfig	gridConfig

KisGuidesConfig	guidesConfig

KisImageSP	image

QScopedPointer< KisSignalAutoConnection >	imageIdleConnection

KisIdleWatcher	imageIdleWatcher

bool	imageModifiedWithoutUndo = false

KisImportExportManager *	importExportManager = 0

bool	isAutosaving = false

bool	isRecovered = false

KoShapeController *	koShapeController = 0

QString	lastErrorMessage

QDateTime	lastMod

QString	lastWarningMessage

QString	linkedResourcesStorageID

KisResourceStorageSP	linkedResourceStorage

bool	m_bAutoDetectedMime = false

QString	m_file

QString	m_path

QVector< StoryboardComment >	m_storyboardCommentList

StoryboardItemList	m_storyboardItemList

QByteArray	mimeType

KisMirrorAxisConfig	mirrorAxisConfig

bool	modified = false

bool	modifiedAfterAutosave = false

bool	modifiedWhileSaving = false

KisNameServer *	nserver

QByteArray	outputMimeType

KisNodeWSP	preActivatedNode

KisDocument *	q = 0

bool	readwrite = false

KisSignalAutoConnectionsStore	referenceLayerConnections

KisImageSP	savingImage

QMutex	savingMutex

QPointer< KoUpdater >	savingUpdater

KisShapeController *	shapeController = 0

KUndo2Stack *	undoStack = 0

KoUnit	unit

bool	wasStorageAdded = false

Protected Member Functions
	KisDocument (bool addStorage=true)

	KisDocument (const KisDocument &rhs, bool addStorage)
	KisDocument makes a deep copy of the document `rhs`. The caller must ensure that the image is properly locked and is in consistent state before asking for cloning.

Private Types
enum	CopyPolicy { CONSTRUCT = 0 , REPLACE }

Private Slots
void	finishExportInBackground ()

void	setImageModified ()

void	setImageModifiedWithoutUndo ()

void	slotAutoSave ()

void	slotChildCompletedSavingInBackground (KisImportExportErrorCode status, const QString &errorMessage, const QString &warningMessage)

void	slotCompleteAutoSaving (const KritaUtils::ExportFileJob &job, KisImportExportErrorCode status, const QString &errorMessage, const QString &warningMessage)

void	slotCompleteSavingDocument (const KritaUtils::ExportFileJob &job, KisImportExportErrorCode status, const QString &errorMessage, const QString &warningMessage)

void	slotConfigChanged ()

void	slotDocumentCloningCancelled ()

void	slotImageRootChanged ()

void	slotInitiateAsyncAutosaving (KisDocument *clonedDocument)

void	slotPerformIdleRoutines ()

void	slotUndoStackCleanChanged (bool value)

Private Member Functions
void	copyFromDocumentImpl (const KisDocument &rhs, CopyPolicy policy)

bool	exportDocumentImpl (const KritaUtils::ExportFileJob &job, KisPropertiesConfigurationSP exportConfiguration, bool isAdvancedExporting=false)

QString	exportErrorToUserMessage (KisImportExportErrorCode status, const QString &errorMessage)

QString	generateAutoSaveFileName (const QString &path) const

KritaUtils::BackgroudSavingStartResult	initiateSavingInBackground (const QString actionName, const QObject receiverObject, const char receiverMethod, const KritaUtils::ExportFileJob &job, KisPropertiesConfigurationSP exportConfiguration, bool isAdvancedExporting=false)

KritaUtils::BackgroudSavingStartResult	initiateSavingInBackground (const QString actionName, const QObject receiverObject, const char receiverMethod, const KritaUtils::ExportFileJob &job, KisPropertiesConfigurationSP exportConfiguration, std::unique_ptr< KisDocument > &&optionalClonedDocument, bool isAdvancedExporting=false)

QString	newObjectName ()

bool	openFile ()

bool	openPathInternal (const QString &path)

QString	prettyPath () const

bool	resourceSavingFilter (const QString &path, const QByteArray &mimeType, KisPropertiesConfigurationSP exportConfiguration)

void	setAutoSaveDelay (int delay)

void	slotAutoSaveImpl (std::unique_ptr< KisDocument > &&optionalClonedDocument)

KisImportExportErrorCode	startExportInBackground (const QString &actionName, const QString &location, const QString &realLocation, const QByteArray &mimeType, bool showWarnings, KisPropertiesConfigurationSP exportConfiguration, bool isAdvancedExporting=false)

Private Member Functions inherited from Private
	Private (KisCanvas2 *c)

Private Attributes
Private *const	d

Private Attributes inherited from Private
KisCanvas2 *	canvas

int	displayedFrame

int	intendedFrame

Friends
class	KisPart

class	SafeSavingLocker

Detailed Description

KisDocument contains the image and keeps track of loading, modification, undo stack and saving.

Definition at line 295 of file KisDocument.cpp.

Member Enumeration Documentation

◆ CopyPolicy

enum KisDocument::CopyPolicy

private

Enumerator
CONSTRUCT	we are copy-constructing a new KisDocument
REPLACE	we are replacing the current KisDocument with another

Definition at line 744 of file KisDocument.h.

                    {
        CONSTRUCT = 0, 
        REPLACE 
    };

◆ OpenFlag

enum KisDocument::OpenFlag

Enumerator
None
DontAddToRecent
RecoveryFile

Definition at line 80 of file KisDocument.h.

                  {
        None = 0,
        DontAddToRecent = 0x1,
        RecoveryFile = 0x2
    };

Constructor & Destructor Documentation

◆ ~Private()

KisDocument::~Private ( )

inline

Definition at line 338 of file KisDocument.cpp.

               {
        // Don't delete m_d->shapeController because it's in a QObject hierarchy.
        delete nserver;
    }

◆ KisDocument() [1/2]

KisDocument::KisDocument ( bool addStorage = true )

explicitprotected

Definition at line 605 of file KisDocument.cpp.

    : d(new Private(this))
{
    connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(slotConfigChanged()));
    connect(d->undoStack, SIGNAL(cleanChanged(bool)), this, SLOT(slotUndoStackCleanChanged(bool)));
    connect(d->autoSaveTimer, SIGNAL(timeout()), this, SLOT(slotAutoSave()));
    setObjectName(newObjectName());
 
#ifdef Q_OS_MACOS
    KisMacosSecurityBookmarkManager *bookmarkmngr = KisMacosSecurityBookmarkManager::instance();
    if (bookmarkmngr->isSandboxed()) {
        connect(this, SIGNAL(sigSavingFinished(const QString&)), bookmarkmngr, SLOT(slotCreateBookmark(const QString&)));
    }
#endif
 
 
    if (addStorage) {
        d->linkedResourcesStorageID = QUuid::createUuid().toString();
        d->linkedResourceStorage.reset(new KisResourceStorage(d->linkedResourcesStorageID));
        KisResourceLocator::instance()->addStorage(d->linkedResourcesStorageID, d->linkedResourceStorage);
 
        d->embeddedResourcesStorageID = QUuid::createUuid().toString();
        d->embeddedResourceStorage.reset(new KisResourceStorage(d->embeddedResourcesStorageID));
        KisResourceLocator::instance()->addStorage(d->embeddedResourcesStorageID, d->embeddedResourceStorage);
 
        d->wasStorageAdded = true;
    }
 
    // preload the krita resources
    KisResourceServerProvider::instance();
 
    d->shapeController = new KisShapeController(d->nserver, d->undoStack, this);
    d->koShapeController = new KoShapeController(0, d->shapeController);
 
    slotConfigChanged();
}

References KisResourceLocator::addStorage(), KisConfigNotifier::instance(), KisMacosSecurityBookmarkManager::instance(), KisResourceLocator::instance(), KisResourceServerProvider::instance(), and KisMacosSecurityBookmarkManager::isSandboxed().

◆ KisDocument() [2/2]

KisDocument::KisDocument	(	const KisDocument &	rhs,
		bool	addStorage )

explicitprotected

KisDocument makes a deep copy of the document rhs. The caller must ensure that the image is properly locked and is in consistent state before asking for cloning.

Parameters

rhs	the source document to copy from

Definition at line 642 of file KisDocument.cpp.

    : QObject(),
      d(new Private(*rhs.d, this))
{
    copyFromDocumentImpl(rhs, CONSTRUCT);
 
    if (addStorage) {
        KisResourceLocator::instance()->addStorage(d->linkedResourcesStorageID, d->linkedResourceStorage);
        KisResourceLocator::instance()->addStorage(d->embeddedResourcesStorageID, d->embeddedResourceStorage);
        d->wasStorageAdded = true;
    }
}

References KisResourceLocator::addStorage(), CONSTRUCT, copyFromDocumentImpl(), d, and KisResourceLocator::instance().

◆ ~KisDocument()

KisDocument::~KisDocument ( )

Destructor.

The destructor does not delete any attached KisView objects and it does not delete the attached widget as returned by widget().

Push a timebomb, which will try to release the memory after the document has been deleted

WARNING: We should wait for all the internal image jobs to finish before entering KisImage's destructor. The problem is, while execution of KisImage::~KisImage, all the weak shared pointers pointing to the image enter an inconsistent state(!). The shared counter is already zero and destruction has started, but the weak reference doesn't know about it, because KisShared::~KisShared hasn't been executed yet. So all the threads running in background and having weak pointers will enter the KisImage's destructor as well.

Definition at line 655 of file KisDocument.cpp.

{
    d->documentIsClosing = true;
 
    // wait until all the pending operations are in progress
    waitForSavingToComplete();
    d->imageIdleWatcher.setTrackedImage(0);
 
    KisPaintDevice::createMemoryReleaseObject()->deleteLater();
 
    d->autoSaveTimer->disconnect(this);
    d->autoSaveTimer->stop();
 
    delete d->importExportManager;
 
    // Despite being QObject they needs to be deleted before the image
    delete d->shapeController;
 
    delete d->koShapeController;
 
    if (d->image) {
        d->image->animationInterface()->blockBackgroundFrameGeneration();
 
        d->image->notifyAboutToBeDeleted();
 
        d->image->requestStrokeCancellation();
        d->image->waitForDone();
 
        // clear undo commands that can still point to the image
        d->undoStack->clear();
        d->image->waitForDone();
 
        KisImageWSP sanityCheckPointer = d->image;
        Q_UNUSED(sanityCheckPointer);
 
        // The following line trigger the deletion of the image
        d->image.clear();
 
        // check if the image has actually been deleted
        KIS_SAFE_ASSERT_RECOVER_NOOP(!sanityCheckPointer.isValid());
    }
 
    if (d->wasStorageAdded) {
        if (KisResourceLocator::instance()->hasStorage(d->linkedResourcesStorageID)) {
            KisResourceLocator::instance()->removeStorage(d->linkedResourcesStorageID);
        }
        if (KisResourceLocator::instance()->hasStorage(d->embeddedResourcesStorageID)) {
            KisResourceLocator::instance()->removeStorage(d->embeddedResourcesStorageID);
        }
    }
 
    delete d;
}

References KisPaintDevice::createMemoryReleaseObject(), d, KisResourceLocator::instance(), KisWeakSharedPtr< T >::isValid(), KIS_SAFE_ASSERT_RECOVER_NOOP, KisResourceLocator::removeStorage(), and waitForSavingToComplete().

Member Function Documentation

◆ assistants()

QList< KisPaintingAssistantSP > KisDocument::assistants ( ) const

Returns: the list of assistants associated with this document

◆ assistantsGlobalColor()

QColor KisDocument::assistantsGlobalColor ( )

Definition at line 2947 of file KisDocument.cpp.

{
    return d->globalAssistantsColor;
}

References d.

◆ autoSaveOnPause()

void KisDocument::autoSaveOnPause ( )

Start saving when android activity is pushed to the background.

Definition at line 2110 of file KisDocument.cpp.

{
    if (!d->modified || !d->modifiedAfterAutosave)
        return;
 
    const QString autoSaveFileName = generateAutoSaveFileName(localFilePath());
 
    bool started = exportDocumentSync(autoSaveFileName, nativeFormatMimeType());
 
    if (started)
    {
        d->modifiedAfterAutosave = false;
        dbgAndroid << "autoSaveOnPause successful";
    }
    else
    {
        qWarning() << "Could not auto-save when paused";
    }
}

References d, dbgAndroid, exportDocumentSync(), generateAutoSaveFileName(), localFilePath(), and nativeFormatMimeType().

◆ canceled

void KisDocument::canceled ( const QString & )

signal

◆ caption()

QString KisDocument::caption ( ) const

Returns: caption of the document

Caption is of the form "[title] - [path]", built out of the document info (title) and pretty-printed document Path. If the title is not present, only the Path it returned.

Definition at line 2225 of file KisDocument.cpp.

{
    QString c;
    const QString _url(QFileInfo(path()).fileName());
 
    // if URL is empty...it is probably an unsaved file
    if (_url.isEmpty()) {
        c = " [" + i18n("Not Saved") + "] ";
    } else {
        c = _url; // Fall back to document URL
    }
 
    return c;
}

References path().

◆ clearStatusBarMessage

void KisDocument::clearStatusBarMessage ( )

signal

Emitted e.g. at the end of a save operation This is emitted by KisDocument and used by KisView to clear the statusbar message

◆ clearUndoHistory()

void KisDocument::clearUndoHistory ( )

Definition at line 2373 of file KisDocument.cpp.

{
    d->undoStack->clear();
}

References d.

◆ clone()

KisDocument * KisDocument::clone ( bool addStorage = false )

creates a clone of the document and returns it. Please make sure that you hold all the necessary locks on the image before asking for a clone!

Definition at line 735 of file KisDocument.cpp.

{
    return new KisDocument(*this, addStorage);
}

References KisDocument().

◆ closePath()

bool KisDocument::closePath ( bool promptToSave = true )

Definition at line 2571 of file KisDocument.cpp.

{
    if (promptToSave) {
        if ( isReadWrite() && isModified()) {
            Q_FOREACH (KisView *view, KisPart::instance()->views()) {
                if (view && view->document() == this) {
                    if (!view->queryClose()) {
                        return false;
                    }
                }
            }
        }
    }
    // Not modified => ok and delete temp file.
    d->mimeType = QByteArray();
 
    // It always succeeds for a read-only part,
    // but the return value exists for reimplementations
    // (e.g. pressing cancel for a modified read-write part)
    return true;
}

References d, KisView::document, KisPart::instance(), isModified(), isReadWrite(), and KisView::queryClose().

◆ colorHistoryColors()

QList< KoColor > KisDocument::colorHistoryColors ( ) const

Return the per-document history of the last-used colors, from the newest to oldest.

The actual values are stored in the model returned by colorHistoryModel()

Definition at line 2970 of file KisDocument.cpp.

{
    return d->colorHistoryModel.colorList();
}

References d.

◆ colorHistoryModel()

KisUniqueColorSet * KisDocument::colorHistoryModel ( )

Return an internal model for managing the last used colors of the document. The model can be used to manipulate the colors and subscribe to updates.

◆ completed

void KisDocument::completed ( )

signal

◆ copyFrom()

void KisDocument::copyFrom	(	const Private &	rhs,
		KisDocument *	q )

◆ copyFromDocument()

void KisDocument::copyFromDocument ( const KisDocument & rhs )

Definition at line 1250 of file KisDocument.cpp.

{
    copyFromDocumentImpl(rhs, REPLACE);
}

References copyFromDocumentImpl(), and REPLACE.

◆ copyFromDocumentImpl()

void KisDocument::copyFromDocumentImpl	(	const KisDocument &	rhs,
		CopyPolicy	policy )

private

Definition at line 1255 of file KisDocument.cpp.

{
    if (policy == REPLACE) {
        d->decorationsSyncingDisabled = true;
        d->copyFrom(*(rhs.d), this);
        d->decorationsSyncingDisabled = false;
 
        d->undoStack->clear();
    } else {
        // in CONSTRUCT mode, d should be already initialized
        connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(slotConfigChanged()));
        connect(d->undoStack, SIGNAL(cleanChanged(bool)), this, SLOT(slotUndoStackCleanChanged(bool)));
        connect(d->autoSaveTimer, SIGNAL(timeout()), this, SLOT(slotAutoSave()));
 
        d->shapeController = new KisShapeController(d->nserver, d->undoStack, this);
        d->koShapeController = new KoShapeController(0, d->shapeController);
    }
 
    setObjectName(rhs.objectName());
 
    slotConfigChanged();
 
    if (rhs.d->image) {
        if (policy == REPLACE) {
            d->image->barrierLock(/* readOnly = */ false);
            rhs.d->image->barrierLock(/* readOnly = */ true);
            d->image->copyFromImage(*(rhs.d->image));
            d->image->unlock();
            rhs.d->image->unlock();
 
            setCurrentImage(d->image, /* forceInitialUpdate = */ true);
        } else {
            // clone the image with keeping the GUIDs of the layers intact
            // NOTE: we expect the image to be locked!
            setCurrentImage(rhs.image()->clone(/* exactCopy = */ true), /* forceInitialUpdate = */ false);
        }
    }
 
    if (policy == REPLACE) {
        d->syncDecorationsWrapperLayerState();
    }
 
    if (rhs.d->preActivatedNode) {
        QQueue<KisNodeSP> linearizedNodes;
        KisLayerUtils::recursiveApplyNodes(rhs.d->image->root(),
                                           [&linearizedNodes](KisNodeSP node) {
            linearizedNodes.enqueue(node);
        });
        KisLayerUtils::recursiveApplyNodes(d->image->root(),
                                           [&linearizedNodes, &rhs, this](KisNodeSP node) {
            KisNodeSP refNode = linearizedNodes.dequeue();
            if (rhs.d->preActivatedNode.data() == refNode.data()) {
                d->preActivatedNode = node;
            }
        });
    }
 
    // reinitialize references' signal connection
    KisReferenceImagesLayerSP referencesLayer = this->referenceImagesLayer();
    if (referencesLayer) {
        d->referenceLayerConnections.clear();
        d->referenceLayerConnections.addConnection(
                    referencesLayer, SIGNAL(sigUpdateCanvas(QRectF)),
                    this, SIGNAL(sigReferenceImagesChanged()));
 
        Q_EMIT sigReferenceImagesLayerChanged(referencesLayer);
        Q_EMIT sigReferenceImagesChanged();
    }
 
    KisDecorationsWrapperLayerSP decorationsLayer =
            KisLayerUtils::findNodeByType<KisDecorationsWrapperLayer>(d->image->root());
    if (decorationsLayer) {
        decorationsLayer->setDocument(this);
    }
 
 
    if (policy == REPLACE) {
        setModified(true);
    }
}

References KisImage::clone(), d, image, KisConfigNotifier::instance(), KisLayerUtils::recursiveApplyNodes(), REPLACE, setCurrentImage(), slotAutoSave(), slotConfigChanged(), and slotUndoStackCleanChanged().

◆ copyFromImpl()

void KisDocument::copyFromImpl	(	const Private &	rhs,
		KisDocument *	q,
		KisDocument::CopyPolicy	policy )

◆ createDocumentInfoDialog()

KoDocumentInfoDlg * KisDocument::createDocumentInfoDialog	(	QWidget *	parent,
		KoDocumentInfo *	docInfo ) const

Definition at line 2556 of file KisDocument.cpp.

{
    return new KoDocumentInfoDlg(parent, docInfo);
}

References docInfo.

◆ createDomDocument() [1/2]

QDomDocument KisDocument::createDomDocument	(	const QString &	appName,
		const QString &	tagName,
		const QString &	version )

static

Return a correctly created QDomDocument for an old (1.3-style) Krita document, including processing instruction, complete DOCTYPE tag (with systemId and publicId), and root element. This static method can be used e.g. by filters.

Parameters

appName	the app's instance name, e.g. words, kspread, kpresenter etc.
tagName	the name of the tag for the root element, e.g. DOC for words/kpresenter.
version	the DTD version (usually the application's version).

Definition at line 2246 of file KisDocument.cpp.

{
    QDomImplementation impl;
    QString url = QString("http://www.calligra.org/DTD/%1-%2.dtd").arg(appName).arg(version);
    QDomDocumentType dtype = impl.createDocumentType(tagName,
                                                     QString("-//KDE//DTD %1 %2//EN").arg(appName).arg(version),
                                                     url);
    // The namespace URN doesn't need to include the version number.
    QString namespaceURN = QString("http://www.calligra.org/DTD/%1").arg(appName);
    QDomDocument doc = impl.createDocument(namespaceURN, tagName, dtype);
    doc.insertBefore(doc.createProcessingInstruction("xml", "version=\"1.0\" encoding=\"UTF-8\""), doc.documentElement());
    return doc;
}

◆ createDomDocument() [2/2]

QDomDocument KisDocument::createDomDocument	(	const QString &	tagName,
		const QString &	version ) const

Return a correctly created QDomDocument for this KisDocument, including processing instruction, complete DOCTYPE tag (with systemId and publicId), and root element.

Parameters

tagName	the name of the tag for the root element
version	the DTD version (usually the application's version).

Definition at line 2240 of file KisDocument.cpp.

{
    return createDomDocument("krita", tagName, version);
}

References createDomDocument().

◆ createUndoStore()

KisUndoStore * KisDocument::createUndoStore ( )

Definition at line 2927 of file KisDocument.cpp.

{
    return new KisDocumentUndoStore(this);
}

◆ documentBounds()

QRectF KisDocument::documentBounds ( ) const

Return the bounding box of the image and associated elements (e.g. reference images)

Definition at line 2952 of file KisDocument.cpp.

{
    QRectF bounds = d->image->bounds();
 
    KisReferenceImagesLayerSP referenceImagesLayer = this->referenceImagesLayer();
 
    if (referenceImagesLayer) {
        bounds |= referenceImagesLayer->boundingImageRect();
    }
 
    return bounds;
}

References KisReferenceImagesLayer::boundingImageRect(), bounds, d, and referenceImagesLayer().

◆ documentInfo()

KoDocumentInfo * KisDocument::documentInfo ( ) const

Returns: the information concerning this document.

See also: KoDocumentInfo

Definition at line 1844 of file KisDocument.cpp.

{
    return d->docInfo;
}

References d.

◆ embeddedResourcesStorageId()

QString KisDocument::embeddedResourcesStorageId ( ) const

Temporary storage for the resources that are embedded into other resources used by the document. E.g. patterns embedded into layer styles.

Definition at line 725 of file KisDocument.cpp.

{
    return d->embeddedResourcesStorageID;
}

References d.

◆ errorMessage()

QString KisDocument::errorMessage ( ) const

Return the last error message. Usually KisDocument takes care of showing it; this method is mostly provided for non-interactive use.

Definition at line 2272 of file KisDocument.cpp.

{
    return d->lastErrorMessage;
}

References d.

◆ exportDocument()

bool KisDocument::exportDocument	(	const QString &	path,
		const QByteArray &	mimeType,
		bool	isAdvancedExporting = false,
		bool	showWarnings = false,
		KisPropertiesConfigurationSP	exportConfiguration = 0 )

Saves the document as path without changing the state of the KisDocument (Path, modified flag etc.). Call this instead of saveAs() to implement KisMainWindow's File --> Export feature. Make sure to provide two separate bool parameters otherwise it will mix them

Definition at line 930 of file KisDocument.cpp.

{
    using namespace KritaUtils;
 
    SaveFlags flags = SaveIsExporting;
    if (showWarnings) {
        flags |= SaveShowWarnings;
    }
 
    KisUsageLogger::log(QString("Exporting Document: %1 as %2. %3 * %4 pixels, %5 layers, %6 frames, %7 "
                                "framerate. Export configuration: %8")
                            .arg(path, QString::fromLatin1(mimeType), QString::number(d->image->width()),
                                 QString::number(d->image->height()), QString::number(d->image->nlayers()),
                                 QString::number(d->image->animationInterface()->totalLength()),
                                 QString::number(d->image->animationInterface()->framerate()),
                                 (exportConfiguration ? exportConfiguration->toXML() : "No configuration")));
 
    return exportDocumentImpl(KritaUtils::ExportFileJob(path,
                                                        mimeType,
                                                        flags),
                              exportConfiguration, isAdvancedExporting);
}

References d, exportDocumentImpl(), KisUsageLogger::log(), and mimeType.

◆ exportDocumentImpl()

bool KisDocument::exportDocumentImpl	(	const KritaUtils::ExportFileJob &	job,
		KisPropertiesConfigurationSP	exportConfiguration,
		bool	isAdvancedExporting = false )

private

Definition at line 740 of file KisDocument.cpp.

{
    // ANDROID NOTES (other comments in this file reference this one!)
    //
    // The Android file system doesn't work like on a real operating system.
    // Instead of normal file paths, we get to deal with "content URIs", which
    // can have various kinds of storage providers behind them. For example,
    // there's a "normal" storage provider, a slightly less normal documents
    // provider, a Google Drive provider and various kinds of third-party
    // providers that are mostly just good at losing the data you give them.
    // For example, we have reports of compression programs that provide a
    // storage provider to write to ZIP or RAR archives or something. Except
    // that they don't seem to work at all, they just accept the data with no
    // error and throw it on the floor.
    //
    // The providers are particularly unreliable with regards to permissions,
    // so calling "isWritable" will just always return false on some of them.
    // This includes the default provider on some devices, which means checking
    // whether a file is writable will mean that the user can't save anything!
    // So, all the Android code skips over the writability check and assumes the
    // files are writable. If they're not, we'll notice later anyway, by the
    // fact that writing to them fails.
    //
    // Another issue is that it's only possible to overwrite files using File >
    // Save. Using File > Save As or File > Export can't replace existing
    // files. The reason for this is that we have to go through the operating
    // system to request access to a file and the only things you can ask for
    // is to open an existing file or to create a new file. Out of necessity,
    // Save As and Export use the latter. If the user selects an existing file,
    // the operating system "helpfully" appends a number to the path, *after*
    // the file extension of course, because it hates the living. So that's
    // another reason we can't go with the "safer" option of assuming that files
    // aren't writable in some cases, since that would prevent the user from
    // saving them normally and end up with a lot of "kiki.kra (2)".
    //
    // Also, when you request a file from the operating system, it always
    // creates an empty file. That means checking whether a file exists will
    // pretty much always succeed, so to know whether a file actually exists
    // you have to check whether it isn't empty. Of course providers may fail to
    // implement this correctly, but I'm not aware of any of them botching it
    // that hard. Well, at least none of the ones that actually save files, as
    // mentioned above some of them just seem to lose whatever you give them.
 
    QFileInfo filePathInfo(job.filePath);
    bool fileExists = filePathInfo.exists();
#ifdef Q_OS_ANDROID
    if (fileExists) {
        fileExists = filePathInfo.size() > 0;
    }
#else
    if (fileExists && !filePathInfo.isWritable()) {
        slotCompleteSavingDocument(job, ImportExportCodes::NoAccessToWrite,
                                   i18n("%1 cannot be written to. Please save under a different name.", job.filePath),
                                   "");
        return false;
    }
#endif
 
    KisConfig cfg(true);
    if (cfg.backupFile() && fileExists) {
 
        QString backupDir;
 
        switch(cfg.readEntry<int>("backupfilelocation", 0)) {
        case 1:
            backupDir = QStandardPaths::writableLocation(QStandardPaths::HomeLocation);
            break;
        case 2:
            backupDir = QStandardPaths::writableLocation(QStandardPaths::TempLocation);
            break;
        default:
#ifdef Q_OS_ANDROID
            // We deal with URIs, there may or may not be a "directory"
            backupDir = KisAutoSaveRecoveryDialog::autoSaveLocation();
            QDir().mkpath(backupDir);
#endif
 
#ifdef Q_OS_MACOS
            KisMacosSecurityBookmarkManager *bookmarkmngr = KisMacosSecurityBookmarkManager::instance();
            if (bookmarkmngr->isSandboxed()) {
                // If the user does not have directory permission force backup
                // files to be inside Container tmp
                QUrl fileUrl = QUrl::fromLocalFile(job.filePath);
                if( !bookmarkmngr->parentDirHasPermissions(fileUrl.path()) ) {
                    backupDir = QDir::tempPath();
                }
            }
#endif
 
            // Do nothing: the empty string is user file location
            break;
        }
 
        int numOfBackupsKept = cfg.readEntry<int>("numberofbackupfiles", 1);
        QString suffix = cfg.readEntry<QString>("backupfilesuffix", "~");
 
        if (numOfBackupsKept == 1) {
            if (!KisBackup::simpleBackupFile(job.filePath, backupDir, suffix)) {
                qWarning() << "Failed to create simple backup file!" << job.filePath << backupDir << suffix;
                KisUsageLogger::log(QString("Failed to create a simple backup for %1 in %2.")
                                        .arg(job.filePath, backupDir.isEmpty()
                                                               ? "the same location as the file"
                                                               : backupDir));
                slotCompleteSavingDocument(job, ImportExportCodes::ErrorWhileWriting, i18nc("Saving error message", "Failed to create a backup file"), "");
                return false;
            }
            else {
                KisUsageLogger::log(QString("Create a simple backup for %1 in %2.")
                                        .arg(job.filePath, backupDir.isEmpty()
                                                               ? "the same location as the file"
                                                               : backupDir));
            }
        }
        else if (numOfBackupsKept > 1) {
            if (!KisBackup::numberedBackupFile(job.filePath, backupDir, suffix, numOfBackupsKept)) {
                qWarning() << "Failed to create numbered backup file!" << job.filePath << backupDir << suffix;
                KisUsageLogger::log(QString("Failed to create a numbered backup for %2.")
                                        .arg(job.filePath, backupDir.isEmpty()
                                                               ? "the same location as the file"
                                                               : backupDir));
                slotCompleteSavingDocument(job, ImportExportCodes::ErrorWhileWriting, i18nc("Saving error message", "Failed to create a numbered backup file"), "");
                return false;
            }
            else {
                KisUsageLogger::log(QString("Create a simple backup for %1 in %2.")
                                        .arg(job.filePath, backupDir.isEmpty()
                                                               ? "the same location as the file"
                                                               : backupDir));
            }
        }
    }
 
    //KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(!job.mimeType.isEmpty(), false);
    if (job.mimeType.isEmpty()) {
        KisImportExportErrorCode error = ImportExportCodes::FileFormatNotSupported;
        slotCompleteSavingDocument(job, error, error.errorMessage(), "");
        return false;
 
    }
 
    const QString actionName =
            job.flags & KritaUtils::SaveIsExporting ?
                i18n("Exporting Document...") :
                i18n("Saving Document...");
 
    KritaUtils::BackgroudSavingStartResult result =
            initiateSavingInBackground(actionName,
                                       this, SLOT(slotCompleteSavingDocument(KritaUtils::ExportFileJob, KisImportExportErrorCode, QString, QString)),
                                       job, exportConfiguration, isAdvancedExporting);
 
    if (result != KritaUtils::BackgroudSavingStartResult::Success) {
        QString errorShortLog;
        QString errorMessage;
        ImportExportCodes::ErrorCodeID errorCode = ImportExportCodes::Failure;
 
        switch (result) {
        case KritaUtils::BackgroudSavingStartResult::AnotherSavingInProgress:
            errorShortLog = "another save operation is in progress";
            errorMessage = i18n("Could not start saving %1. Wait until the current save operation has finished.", job.filePath);
            errorCode = ImportExportCodes::Failure;
            break;
        case KritaUtils::BackgroudSavingStartResult::ImageLockFailure:
            errorShortLog = "failed to lock and clone the image";
            errorMessage = i18n("Could not start saving %1. Image is busy", job.filePath);
            errorCode = ImportExportCodes::Busy;
            break;
        case KritaUtils::BackgroudSavingStartResult::Failure:
            errorShortLog = "failed to start background saving";
            errorMessage = i18n("Could not start saving %1. Unknown failure has happened", job.filePath);
            errorCode = ImportExportCodes::Failure;
            break;
        case KritaUtils::BackgroudSavingStartResult::Cancelled:
            errorCode = ImportExportCodes::Cancelled;
            break;
        case KritaUtils::BackgroudSavingStartResult::Success:
            // noop, not possible
            break;
        }
 
        KisUsageLogger::log(QString("Failed to initiate saving %1 in background: %2").arg(job.filePath).arg(errorShortLog));
 
        slotCompleteSavingDocument(job, errorCode,
                                   errorMessage,
                                   "");
        return false;
    }
 
    return (result == KritaUtils::BackgroudSavingStartResult::Success);
}

References KritaUtils::AnotherSavingInProgress, KisAutoSaveRecoveryDialog::autoSaveLocation(), KisConfig::backupFile(), ImportExportCodes::Busy, ImportExportCodes::Cancelled, KritaUtils::Cancelled, errorMessage(), KisImportExportErrorCode::errorMessage(), ImportExportCodes::ErrorWhileWriting, ImportExportCodes::Failure, KritaUtils::Failure, ImportExportCodes::FileFormatNotSupported, KritaUtils::ExportFileJob::filePath, KritaUtils::ExportFileJob::flags, KritaUtils::ImageLockFailure, initiateSavingInBackground(), KisMacosSecurityBookmarkManager::instance(), KisMacosSecurityBookmarkManager::isSandboxed(), KisUsageLogger::log(), KritaUtils::ExportFileJob::mimeType, ImportExportCodes::NoAccessToWrite, KisBackup::numberedBackupFile(), KisMacosSecurityBookmarkManager::parentDirHasPermissions(), KisConfig::readEntry(), KritaUtils::SaveIsExporting, KisBackup::simpleBackupFile(), slotCompleteSavingDocument(), and KritaUtils::Success.

◆ exportDocumentSync()

bool KisDocument::exportDocumentSync	(	const QString &	path,
		const QByteArray &	mimeType,
		KisPropertiesConfigurationSP	exportConfiguration = 0 )

Exports he document is a synchronous way. The caller must ensure that the image is not accessed by any other actors, because the exporting happens without holding the image lock.

The caller guarantees that no one else uses the document (usually, it is a temporary document created specifically for exporting), so we don't need to copy or lock the document. Instead we should just ensure the barrier lock is synced and then released.

Definition at line 1336 of file KisDocument.cpp.

{
    {
        Private::StrippedSafeSavingLocker locker(&d->savingMutex, d->image);
        if (!locker.successfullyLocked()) {
            return false;
        }
    }
 
    d->savingImage = d->image;
 
    KisImportExportErrorCode status =
            d->importExportManager->
            exportDocument(path, path, mimeType, false, exportConfiguration);
 
    d->savingImage = 0;
 
    return status.isOk();
}

References d, exportDocument(), KisImportExportErrorCode::isOk(), and mimeType.

◆ exportErrorToUserMessage()

QString KisDocument::exportErrorToUserMessage	(	KisImportExportErrorCode	status,
		const QString &	errorMessage )

private

Definition at line 2937 of file KisDocument.cpp.

{
    return errorMessage.isEmpty() ? status.errorMessage() : errorMessage;
}

References errorMessage(), and KisImportExportErrorCode::errorMessage().

◆ extraNativeMimeTypes()

static QStringList KisDocument::extraNativeMimeTypes ( )

inlinestatic

Returns a list of the mimeTypes considered "native", i.e. which can be saved by KisDocument without a filter, in addition to the main one

Definition at line 178 of file KisDocument.h.

178{ return QStringList() << KIS_MIME_TYPE; }

KIS_MIME_TYPE

#define KIS_MIME_TYPE

Definition KisDocument.h:57

QStringList

QList< QString > QStringList

Definition KisQStringListFwd.h:18

References KIS_MIME_TYPE.

◆ fileBatchMode()

bool KisDocument::fileBatchMode ( ) const

Returns: true if file operations should inhibit the option dialog

Definition at line 1145 of file KisDocument.cpp.

{
    return d->batchMode;
}

References d.

◆ finishExportInBackground

void KisDocument::finishExportInBackground ( )

privateslot

Definition at line 1760 of file KisDocument.cpp.

{
    KIS_SAFE_ASSERT_RECOVER(d->childSavingFuture.isFinished()) {
        Q_EMIT sigBackgroundSavingFinished(ImportExportCodes::InternalError, "", "");
        return;
    }
 
    KisImportExportErrorCode status = d->childSavingFuture.result();
    QString errorMessage = status.errorMessage();
    QString warningMessage = d->lastWarningMessage;
 
    if (!d->lastErrorMessage.isEmpty()) {
        if (status == ImportExportCodes::InternalError || status == ImportExportCodes::Failure) {
            errorMessage = d->lastErrorMessage;
        } else {
            errorMessage += "\n" + d->lastErrorMessage;
        }
    }
 
    d->savingImage.clear();
    d->childSavingFuture = QFuture<KisImportExportErrorCode>();
    d->lastErrorMessage.clear();
    d->lastWarningMessage.clear();
 
    if (d->savingUpdater) {
        d->savingUpdater->setProgress(100);
    }
 
    Q_EMIT sigBackgroundSavingFinished(status, errorMessage, warningMessage);
}

References d, errorMessage(), KisImportExportErrorCode::errorMessage(), ImportExportCodes::Failure, ImportExportCodes::InternalError, KIS_SAFE_ASSERT_RECOVER, sigBackgroundSavingFinished(), and warningMessage().

◆ generateAutoSaveFileName()

QString KisDocument::generateAutoSaveFileName ( const QString & path ) const

private

Definition at line 1897 of file KisDocument.cpp.

{
    QString retval;
 
    // Using the extension allows to avoid relying on the mime magic when opening
    const QString extension (".kra");
    QString prefix = KisConfig(true).readEntry<bool>("autosavefileshidden") ? QString(".") : QString();
    QRegularExpression autosavePattern1("^\\..+-autosave.kra$");
    QRegularExpression autosavePattern2("^.+-autosave.kra$");
 
    QFileInfo fi(path);
    QString dir = fi.absolutePath();
 
#ifdef Q_OS_ANDROID
    // URIs may or may not have a directory backing them, so we save to our default autosave location
    if (path.startsWith("content://")) {
        dir = KisAutoSaveRecoveryDialog::autoSaveLocation();
        QDir().mkpath(dir);
    }
#endif
 
    QString filename = fi.fileName();
 
    if (path.isEmpty() || autosavePattern1.match(filename).hasMatch() || autosavePattern2.match(filename).hasMatch() || !fi.isWritable()) {
        // Never saved?
        retval = QString("%1%2%3%4-%5-%6-autosave%7")
                     .arg(KisAutoSaveRecoveryDialog::autoSaveLocation())
                     .arg('/')
                     .arg(prefix)
                     .arg("krita")
                     .arg(qApp->applicationPid())
                     .arg(objectName())
                     .arg(extension);
    } else {
        // Beware: don't reorder arguments
        //   otherwise in case of filename = '1-file.kra' it will become '.-file.kra-autosave.kra' instead of '.1-file.kra-autosave.kra'
        retval = QString("%1%2%3%4-autosave%5").arg(dir).arg('/').arg(prefix).arg(filename).arg(extension);
    }
 
    //qDebug() << "generateAutoSaveFileName() for path" << path << ":" << retval;
    return retval;
}

References KisAutoSaveRecoveryDialog::autoSaveLocation(), and KisConfig::readEntry().

◆ generatePreview()

QPixmap KisDocument::generatePreview ( const QSize & size )

Generates a preview picture of the document.

Note: The preview is used in the File Dialog and also to create the Thumbnail

Definition at line 1854 of file KisDocument.cpp.

{
    KisImageSP image = d->image;
    if (d->savingImage) image = d->savingImage;
 
    if (image) {
        QRect bounds = image->bounds();
        QSize originalSize = bounds.size();
        // QSize may round down one dimension to zero on extreme aspect rations, so ensure 1px minimum
        QSize newSize = originalSize.scaled(size, Qt::KeepAspectRatio).expandedTo({1, 1});
 
        bool pixelArt = false;
        // determine if the image is pixel art or not
        if (originalSize.width() < size.width() && originalSize.height() < size.height()) {
            // the image must be smaller than the requested preview
            // the scale must be integer
            if (newSize.height()%originalSize.height() == 0 && newSize.width()%originalSize.width() == 0) {
                pixelArt = true;
            }
        }
 
        QPixmap px;
        if (pixelArt) {
            // do not scale while converting (because it uses Bicubic)
            QImage original = image->convertToQImage(originalSize, 0);
            // scale using FastTransformation, which is probably Nearest neighbour, suitable for pixel art
            QImage scaled = original.scaled(newSize, Qt::KeepAspectRatio, Qt::FastTransformation);
            px = QPixmap::fromImage(scaled);
        } else {
            px = QPixmap::fromImage(image->convertToQImage(newSize, 0));
        }
        if (px.size() == QSize(0,0)) {
            px = QPixmap(newSize);
            QPainter gc(&px);
            QBrush checkBrush = QBrush(KisCanvasWidgetBase::createCheckersImage(newSize.width() / 5));
            gc.fillRect(px.rect(), checkBrush);
            gc.end();
        }
        return px;
    }
    return QPixmap(size);
}

References KisImage::bounds(), bounds, KisImage::convertToQImage(), KisCanvasWidgetBase::createCheckersImage(), d, and image.

◆ getAudioLevel()

qreal KisDocument::getAudioLevel ( )

Definition at line 2510 of file KisDocument.cpp.

{
    return d->audioLevel;
}

References d.

◆ getAudioTracks()

QVector< QFileInfo > KisDocument::getAudioTracks ( ) const

Definition at line 2494 of file KisDocument.cpp.

                                                     {
    return d->audioTracks;
}

References d.

◆ getStoryboardCommentsList()

QVector< StoryboardComment > KisDocument::getStoryboardCommentsList ( )

returns the list of comments for the storyboard docker in the document

Definition at line 2481 of file KisDocument.cpp.

{
    return d->m_storyboardCommentList;
}

References d.

◆ getStoryboardItemList()

StoryboardItemList KisDocument::getStoryboardItemList ( )

returns the list of pointers to storyboard Items for the document

Definition at line 2468 of file KisDocument.cpp.

{
    return d->m_storyboardItemList;
}

References d.

◆ gridConfig()

KisGridConfig KisDocument::gridConfig ( ) const

◆ guidesConfig()

const KisGuidesConfig & KisDocument::guidesConfig ( ) const

returns the guides data for this document.

◆ hackPreliminarySetImage()

void KisDocument::hackPreliminarySetImage ( KisImageSP image )

Set the image of the document preliminary, before the document has completed loading. Some of the document items (shapes) may want to access image properties (bounds and resolution), so we should provide it to them even before the entire image is loaded.

Right now, the only use by KoShapeRegistry::createShapeFromOdf(), remove after it is deprecated.

Definition at line 2904 of file KisDocument.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN(!d->image);
 
    // we set image without connecting idle-watcher, because loading
    // hasn't been finished yet
    d->image = image;
    d->shapeController->setImage(image);
}

References d, image, and KIS_SAFE_ASSERT_RECOVER_RETURN.

◆ image()

KisImageWSP KisDocument::image ( ) const

◆ importDocument()

bool KisDocument::importDocument ( const QString & path )

Opens the document given by path, without storing the Path in the KisDocument. Call this instead of openPath() to implement KisMainWindow's File --> Import feature.

Note: This will call openPath(). To differentiate this from an ordinary Open operation (in any reimplementation of openPath() or openFile()) call isImporting().

Definition at line 1940 of file KisDocument.cpp.

{
    bool ret;
 
    dbgUI << "path=" << _path;
 
    // open...
    ret = openPath(_path);
 
    // reset url & m_file (kindly? set by KisParts::openUrl()) to simulate a
    // File --> Import
    if (ret) {
        dbgUI << "success, resetting url";
        resetPath();
    }
 
    return ret;
}

References dbgUI, openPath(), and resetPath().

◆ importExportManager()

KisImportExportManager * KisDocument::importExportManager ( ) const

importExportManager gives access to the internal import/export manager

Returns: the document's import/export manager

◆ initiateSavingInBackground() [1/2]

KritaUtils::BackgroudSavingStartResult KisDocument::initiateSavingInBackground	(	const QString	actionName,
		const QObject *	receiverObject,
		const char *	receiverMethod,
		const KritaUtils::ExportFileJob &	job,
		KisPropertiesConfigurationSP	exportConfiguration,
		bool	isAdvancedExporting = false )

private

Definition at line 1363 of file KisDocument.cpp.

{
    return initiateSavingInBackground(actionName, receiverObject, receiverMethod,
                                      job, exportConfiguration, std::unique_ptr<KisDocument>(), isAdvancedExporting);
}

References initiateSavingInBackground().

◆ initiateSavingInBackground() [2/2]

KritaUtils::BackgroudSavingStartResult KisDocument::initiateSavingInBackground	(	const QString	actionName,
		const QObject *	receiverObject,
		const char *	receiverMethod,
		const KritaUtils::ExportFileJob &	job,
		KisPropertiesConfigurationSP	exportConfiguration,
		std::unique_ptr< KisDocument > &&	optionalClonedDocument,
		bool	isAdvancedExporting = false )

private

This lock will later release() when we start the background thread, it means that the ownership is transferred to the background thread

From now on no return statements are allowed, even inside asserts, since the ownership over the saving mutex has already been passed to the background thread.

The cancellation process should go through slotChildCompletedSavingInBackground(), which will unlock the mutex itself.

Definition at line 1372 of file KisDocument.cpp.

{
    KIS_ASSERT_RECOVER_RETURN_VALUE(job.isValid(), KritaUtils::BackgroudSavingStartResult::Failure);
 
    std::unique_ptr<KisDocument> clonedDocument;
 
    if (!optionalClonedDocument) {
        clonedDocument.reset(lockAndCloneForSaving());
    } else {
        clonedDocument.reset(optionalClonedDocument.release());
    }
 
    if (!d->savingMutex.tryLock()){
        return KritaUtils::BackgroudSavingStartResult::AnotherSavingInProgress;
    }
 
    std::unique_lock<QMutex> savingMutexLock(d->savingMutex, std::adopt_lock);
 
    if (!clonedDocument) {
        return KritaUtils::BackgroudSavingStartResult::ImageLockFailure;
    }
 
    auto waitForImage = [] (KisImageSP image) {
        KisMainWindow *window = KisPart::instance()->currentMainwindow();
        if (window) {
            if (window->viewManager()) {
                window->viewManager()->blockUntilOperationsFinishedForced(image);
            }
        }
    };
 
    {
        KisNodeSP newRoot = clonedDocument->image()->root();
        KIS_SAFE_ASSERT_RECOVER(!KisLayerUtils::hasDelayedNodeWithUpdates(newRoot)) {
            KisLayerUtils::forceAllDelayedNodesUpdate(newRoot);
            waitForImage(clonedDocument->image());
        }
    }
 
    if (clonedDocument->image()->hasOverlaySelectionMask()) {
        clonedDocument->image()->setOverlaySelectionMask(0);
        waitForImage(clonedDocument->image());
    }
 
    KisConfig cfg(true);
    if (cfg.trimKra()) {
        clonedDocument->image()->cropImage(clonedDocument->image()->bounds());
        clonedDocument->image()->purgeUnusedData(false);
        waitForImage(clonedDocument->image());
    }
 
    KIS_SAFE_ASSERT_RECOVER(clonedDocument->image()->isIdle()) {
        waitForImage(clonedDocument->image());
    }
 
    KIS_ASSERT_RECOVER_RETURN_VALUE(!d->backgroundSaveDocument, KritaUtils::BackgroudSavingStartResult::Failure);
    KIS_ASSERT_RECOVER_RETURN_VALUE(!d->backgroundSaveJob.isValid(), KritaUtils::BackgroudSavingStartResult::Failure);
 
    savingMutexLock.release();
 
    d->backgroundSaveDocument.reset(clonedDocument.release());
    d->backgroundSaveJob = job;
    d->modifiedWhileSaving = false;
 
    if (d->backgroundSaveJob.flags & KritaUtils::SaveInAutosaveMode) {
        d->backgroundSaveDocument->d->isAutosaving = true;
    }
 
    connect(d->backgroundSaveDocument.get(),
            SIGNAL(sigBackgroundSavingFinished(KisImportExportErrorCode, QString, QString)),
            this,
            SLOT(slotChildCompletedSavingInBackground(KisImportExportErrorCode, QString, QString)));
 
 
    if (d->completeSavingConnection) {
        disconnect(d->completeSavingConnection);
    }
    d->completeSavingConnection = connect(
        this, SIGNAL(sigCompleteBackgroundSaving(KritaUtils::ExportFileJob, KisImportExportErrorCode, QString, QString)),
        receiverObject, receiverMethod);
 
    KisImportExportErrorCode error =
            d->backgroundSaveDocument->startExportInBackground(actionName,
                                                               job.filePath,
                                                               job.filePath,
                                                               job.mimeType,
                                                               job.flags & KritaUtils::SaveShowWarnings,
                                                               exportConfiguration, isAdvancedExporting);
    if (!error.isOk()) {
        // the state should have been deinitialized in slotChildCompletedSavingInBackground()
        KIS_SAFE_ASSERT_RECOVER (!d->backgroundSaveDocument && !d->backgroundSaveJob.isValid()) {
            d->backgroundSaveDocument.release()->deleteLater();
            d->savingMutex.unlock();
            d->backgroundSaveJob = KritaUtils::ExportFileJob();
        }
        if (error.isCancelled()) {
            return KritaUtils::BackgroudSavingStartResult::Cancelled;
        }
        return KritaUtils::BackgroudSavingStartResult::Failure;
    }
 
    return KritaUtils::BackgroudSavingStartResult::Success;
}

References KritaUtils::AnotherSavingInProgress, KisViewManager::blockUntilOperationsFinishedForced(), KritaUtils::Cancelled, KisPart::currentMainwindow(), d, KritaUtils::Failure, KritaUtils::ExportFileJob::filePath, KritaUtils::ExportFileJob::flags, KisLayerUtils::forceAllDelayedNodesUpdate(), KisLayerUtils::hasDelayedNodeWithUpdates(), KisBaseNode::image, image, KritaUtils::ImageLockFailure, KisPart::instance(), KisImportExportErrorCode::isCancelled(), KisImportExportErrorCode::isOk(), KritaUtils::ExportFileJob::isValid(), KIS_ASSERT_RECOVER_RETURN_VALUE, KIS_SAFE_ASSERT_RECOVER, lockAndCloneForSaving(), KritaUtils::ExportFileJob::mimeType, KisNodeFacade::root, KritaUtils::SaveInAutosaveMode, KritaUtils::SaveShowWarnings, sigBackgroundSavingFinished(), sigCompleteBackgroundSaving(), slotChildCompletedSavingInBackground(), KritaUtils::Success, KisConfig::trimKra(), and KisMainWindow::viewManager.

◆ isAutoSaveActive()

bool KisDocument::isAutoSaveActive ( )

Indicate if autosave is active or inactive

the value is independent of auto save delay

Definition at line 1839 of file KisDocument.cpp.

{
    return d->autoSaveActive;
}

References d.

◆ isAutosaving()

bool KisDocument::isAutosaving ( ) const

◆ isInSaving()

bool KisDocument::isInSaving ( ) const

isInSaving shown if the document has any (background) saving process or not

Returns: true if there is some saving in action

◆ isModified()

bool KisDocument::isModified ( ) const

Returns true if this document or any of its internal child documents are modified.

Definition at line 1849 of file KisDocument.cpp.

{
    return d->modified;
}

References d.

◆ isNativeFormat()

bool KisDocument::isNativeFormat ( const QByteArray & mimeType ) const

Checks whether a given mimeType can be handled natively.

Definition at line 2260 of file KisDocument.cpp.

{
    if (mimeType == nativeFormatMimeType())
        return true;
    return extraNativeMimeTypes().contains(mimeType);
}

References extraNativeMimeTypes(), mimeType, and nativeFormatMimeType().

◆ isReadWrite()

bool KisDocument::isReadWrite ( ) const

Definition at line 2561 of file KisDocument.cpp.

{
    return d->readwrite;
}

References d.

◆ isRecovered()

bool KisDocument::isRecovered ( ) const

◆ isSaving()

bool KisDocument::isSaving ( ) const

Definition at line 2768 of file KisDocument.cpp.

{
    const bool result = d->savingMutex.tryLock();
    if (result) {
        d->savingMutex.unlock();
    }
    return !result;
}

References d.

◆ linkedDocumentResources()

QList< KoResourceLoadResult > KisDocument::linkedDocumentResources ( )

linkedDocumentResources List returns all the resources linked to the document, such as palettes

In some cases (e.g. when the document is temporary), the underlying document storage will not be registered in the resource system, so we cannot get fully initialized resources from it (resourceId(), active(), md5() and storageLocation() fields will be uninitialized). Therefore we just return KoEmbeddedResource which is suitable for saving this data into hard drive.

The returned KoResourceLoadResult object can either be in EmbeddedResource or FailedLink state. The former means the resource has been prepared for embedding, the latter means there was some issue with serializing the resource. In the latter case the called should check result.signature() to find out which resource has failed.

NOTE: the returned result can NOT have ExistingResource state!

Definition at line 2396 of file KisDocument.cpp.

{
    QList<KoResourceLoadResult> result;
    if (!d->linkedResourceStorage) {
        return result;
    }
 
    Q_FOREACH(const QString &resourceType, KisResourceLoaderRegistry::instance()->resourceTypes()) {
        QSharedPointer<KisResourceStorage::ResourceIterator> iter = d->linkedResourceStorage->resources(resourceType);
        while (iter->hasNext()) {
            iter->next();
 
            QBuffer buf;
            buf.open(QBuffer::WriteOnly);
            bool exportSuccessful =
                d->linkedResourceStorage->exportResource(iter->url(), &buf);
 
            KoResourceSP resource = d->linkedResourceStorage->resource(iter->url());
            exportSuccessful &= bool(resource);
 
            const QString name = resource ? resource->name() : QString();
            const QString fileName = QFileInfo(iter->url()).fileName();
            const KoResourceSignature signature(resourceType,
                                                KoMD5Generator::generateHash(buf.data()),
                                                fileName, name);
 
            if (exportSuccessful) {
                result << KoEmbeddedResource(signature, buf.data());
            } else {
                result << signature;
            }
        }
    }
 
    return result;
}

References d, KoMD5Generator::generateHash(), and KisResourceLoaderRegistry::instance().

◆ linkedResourcesStorageId()

QString KisDocument::linkedResourcesStorageId ( ) const

Persistent storage for the resources that are linked but the resources embedded in the document. These resources are not embedded into their own container resource, so they should be stored by the document

All these resources are saved into the document itself and loaded alongside the document.

Definition at line 730 of file KisDocument.cpp.

{
    return d->linkedResourcesStorageID;
}

References d.

◆ loadNativeFormat()

bool KisDocument::loadNativeFormat ( const QString & file )

Loads a document in the native format from a given Path. Reimplement if your native format isn't XML.

Parameters

file	the file to load - usually KReadOnlyPart::m_file or the result of a filter

Definition at line 2138 of file KisDocument.cpp.

{
    return openPath(file_);
}

References openPath().

◆ localFilePath()

QString KisDocument::localFilePath ( ) const

Definition at line 2606 of file KisDocument.cpp.

{
    return d->m_file;
}

References d.

◆ lockAndCloneForSaving()

KisDocument * KisDocument::lockAndCloneForSaving ( )

try to clone the image. This method handles all the locking for you. If locking has failed, no cloning happens

Returns: cloned document on success, null otherwise

Definition at line 1240 of file KisDocument.cpp.

{
    return d->lockAndCloneImpl(true);
}

References d.

◆ lockAndCloneImpl()

KisDocument * KisDocument::lockAndCloneImpl ( bool fetchResourcesFromLayers )

◆ lockAndCreateSnapshot()

KisDocument * KisDocument::lockAndCreateSnapshot ( )

Definition at line 1245 of file KisDocument.cpp.

{
    return d->lockAndCloneImpl(false);
}

References d.

◆ mimeType()

QByteArray KisDocument::mimeType ( ) const

Returns the actual mimeType of the document

◆ mirrorAxisConfig()

const KisMirrorAxisConfig & KisDocument::mirrorAxisConfig ( ) const

◆ modified

void KisDocument::modified ( bool )

signal

Emitted when the document is modified

◆ nativeFormatMimeType()

static QByteArray KisDocument::nativeFormatMimeType ( )

inlinestatic

To be preferred when a document exists. It is fast when calling it multiple times since it caches the result that readNativeFormatMimeType() delivers. This comes from the X-KDE-NativeMimeType key in the .desktop file.

Definition at line 171 of file KisDocument.h.

171{ return KIS_MIME_TYPE; }

References KIS_MIME_TYPE.

◆ newImage()

bool KisDocument::newImage	(	const QString &	name,
		qint32	width,
		qint32	height,
		const KoColorSpace *	cs,
		const KoColor &	bgColor,
		KisConfig::BackgroundStyle	bgStyle,
		int	numberOfLayers,
		const QString &	imageDescription,
		const double	imageResolution )

Create a new image that has this document as a parent and replace the current image with this image.

Preinitialize color history for new documents when possible

Definition at line 2663 of file KisDocument.cpp.

{
    Q_ASSERT(cs);
 
    KisImageSP image;
 
    if (!cs) return false;
 
    KisCursorOverrideLock cursorLock(Qt::BusyCursor);
 
    image = new KisImage(createUndoStore(), width, height, cs, name);
 
    Q_CHECK_PTR(image);
 
    connect(image, SIGNAL(sigImageModified()), this, SLOT(setImageModified()), Qt::UniqueConnection);
    connect(image, SIGNAL(sigImageModifiedWithoutUndo()), this, SLOT(setImageModifiedWithoutUndo()), Qt::UniqueConnection);
    image->setResolution(imageResolution, imageResolution);
 
    image->assignImageProfile(cs->profile());
    image->waitForDone();
 
    documentInfo()->setAboutInfo("title", name);
    documentInfo()->setAboutInfo("abstract", description);
 
    KisConfig cfg(false);
    cfg.defImageWidth(width);
    cfg.defImageHeight(height);
    cfg.defImageResolution(imageResolution);
    if (!cfg.useDefaultColorSpace())
    {
        cfg.defColorModel(image->colorSpace()->colorModelId().id());
        cfg.setDefaultColorDepth(image->colorSpace()->colorDepthId().id());
        cfg.defColorProfile(image->colorSpace()->profile()->name());
    }
 
    bool autopin = cfg.autoPinLayersToTimeline();
 
    KisLayerSP bgLayer;
    if (bgStyle == KisConfig::RASTER_LAYER || bgStyle == KisConfig::FILL_LAYER) {
        KoColor strippedAlpha = bgColor;
        strippedAlpha.setOpacity(OPACITY_OPAQUE_U8);
 
        if (bgStyle == KisConfig::RASTER_LAYER) {
            bgLayer = new KisPaintLayer(image.data(), i18nc("Name for the bottom-most layer in the layerstack", "Background"), OPACITY_OPAQUE_U8, cs);
            bgLayer->paintDevice()->setDefaultPixel(strippedAlpha);
            bgLayer->setPinnedToTimeline(autopin);
        } else if (bgStyle == KisConfig::FILL_LAYER) {
            KisFilterConfigurationSP filter_config = KisGeneratorRegistry::instance()->get("color")->defaultConfiguration(KisGlobalResourcesInterface::instance());
            filter_config->setProperty("color", strippedAlpha.toQColor());
            filter_config->createLocalResourcesSnapshot();
            bgLayer = new KisGeneratorLayer(image.data(), i18nc("Name of automatically created background color fill layer", "Background Fill"), filter_config, image->globalSelection());
        }
 
        bgLayer->setOpacity(bgColor.opacityU8());
 
        if (numberOfLayers > 1) {
            //Lock bg layer if others are present.
            bgLayer->setUserLocked(true);
        }
    }
    else { // KisConfig::CANVAS_COLOR (needs an unlocked starting layer).
        image->setDefaultProjectionColor(bgColor);
        bgLayer = new KisPaintLayer(image.data(), image->nextLayerName(), OPACITY_OPAQUE_U8, cs);
    }
 
    Q_CHECK_PTR(bgLayer);
    image->addNode(bgLayer.data(), image->rootLayer().data());
    bgLayer->setDirty(QRect(0, 0, width, height));
 
    // reset mirror axis to default:
    d->mirrorAxisConfig.setAxisPosition(QRectF(image->bounds()).center());
    setCurrentImage(image);
 
    for(int i = 1; i < numberOfLayers; ++i) {
        KisPaintLayerSP layer = new KisPaintLayer(image, image->nextLayerName(), OPACITY_OPAQUE_U8, cs);
        layer->setPinnedToTimeline(autopin);
        image->addNode(layer, image->root(), i);
        layer->setDirty(QRect(0, 0, width, height));
    }
 
    {
        KisMainWindow *window = KisPart::instance()->currentMainwindow();
        if (window) {
            setColorHistoryColors(window->viewManager()->canvasResourceProvider()->colorHistoryColors());
        }
    }
 
    KisUsageLogger::log(
        QString("Created image \"%1\", %2 * %3 pixels, %4 dpi. Color model: %6 %5 (%7). Layers: %8")
            .arg(name, QString::number(width), QString::number(height),
                 QString::number(imageResolution * 72.0), image->colorSpace()->colorModelId().name(),
                 image->colorSpace()->colorDepthId().name(), image->colorSpace()->profile()->name(),
                 QString::number(numberOfLayers)));
 
    return true;
}

References KisNodeFacade::addNode(), KisImage::assignImageProfile(), KisConfig::autoPinLayersToTimeline(), KisImage::bounds(), KisViewManager::canvasResourceProvider(), KoColorSpace::colorDepthId(), KisCanvasResourceProvider::colorHistoryColors(), KoColorSpace::colorModelId(), KisImage::colorSpace(), createUndoStore(), KisPart::currentMainwindow(), d, KisSharedPtr< T >::data(), KisBaseProcessor::defaultConfiguration(), KisConfig::defColorModel(), KisConfig::defColorProfile(), KisConfig::defImageHeight(), KisConfig::defImageResolution(), KisConfig::defImageWidth(), documentInfo(), KisConfig::FILL_LAYER, KoGenericRegistry< T >::get(), KisImage::globalSelection(), KoID::id(), image, KisGeneratorRegistry::instance(), KisGlobalResourcesInterface::instance(), KisPart::instance(), KisUsageLogger::log(), KoID::name(), KoColorProfile::name, KisImage::nextLayerName(), OPACITY_OPAQUE_U8, KoColor::opacityU8(), KisBaseNode::paintDevice(), KoColorSpace::profile(), KisConfig::RASTER_LAYER, KisNodeFacade::root, KisImage::rootLayer(), KoDocumentInfo::setAboutInfo(), setColorHistoryColors(), setCurrentImage(), KisConfig::setDefaultColorDepth(), KisPaintDevice::setDefaultPixel(), KisImage::setDefaultProjectionColor(), KisNode::setDirty(), setImageModified(), setImageModifiedWithoutUndo(), KoColor::setOpacity(), KisBaseNode::setOpacity(), KisBaseNode::setPinnedToTimeline(), KisImage::setResolution(), KisBaseNode::setUserLocked(), KoColor::toQColor(), KisConfig::useDefaultColorSpace(), KisMainWindow::viewManager, and KisImage::waitForDone().

◆ newObjectName()

QString KisDocument::newObjectName ( )

private

Generate a name for the document.

Definition at line 160 of file KisDocument.cpp.

{
    static int s_docIFNumber = 0;
    QString name; name.setNum(s_docIFNumber++); name.prepend("document_");
    return name;
}

◆ openFile()

bool KisDocument::openFile ( )

private

Loads a document

Applies a filter if necessary, and calls loadNativeFormat in any case You should not have to reimplement, except for very special cases.

NOTE: this method also creates a new KisView instance!

This method is called from the KReadOnlyPart::openPath method.

Definition at line 2035 of file KisDocument.cpp.

{
    //dbgUI <<"for" << localFilePath();
    if (!QFile::exists(localFilePath()) && !fileBatchMode()) {
        QMessageBox::critical(qApp->activeWindow(), i18nc("@title:window", "Krita"), i18n("File %1 does not exist.", localFilePath()));
        return false;
    }
 
    QString filename = localFilePath();
    QString typeName = mimeType();
 
    if (typeName.isEmpty()) {
        typeName = KisMimeDatabase::mimeTypeForFile(filename);
    }
 
    // Allow to open backup files, don't keep the mimeType application/x-trash.
    if (typeName == "application/x-trash") {
        QString path = filename;
        while (path.length() > 0) {
            path.chop(1);
            typeName = KisMimeDatabase::mimeTypeForFile(path);
            //qDebug() << "\t" << path << typeName;
            if (!typeName.isEmpty()) {
                break;
            }
        }
        //qDebug() << "chopped" << filename  << "to" << path << "Was trash, is" << typeName;
    }
    dbgUI << localFilePath() << "type:" << typeName;
 
    KisMainWindow *window = KisPart::instance()->currentMainwindow();
    KoUpdaterPtr updater;
    if (window && window->viewManager()) {
        updater = window->viewManager()->createUnthreadedUpdater(i18n("Opening document"));
        d->importExportManager->setUpdater(updater);
    }
 
    KisImportExportErrorCode status = d->importExportManager->importDocument(localFilePath(), typeName);
 
    if (!status.isOk()) {
        if (window && window->viewManager()) {
            updater->cancel();
        }
        QString msg = status.errorMessage();
        KisUsageLogger::log(QString("Loading %1 failed: %2").arg(prettyPath(), msg));
 
        if (!msg.isEmpty() && !fileBatchMode()) {
            DlgLoadMessages dlg(i18nc("@title:window", "Krita"),
                                i18n("Could not open %1.", prettyPath()),
                                errorMessage().split("\n", Qt::SkipEmptyParts)
                                    + warningMessage().split("\n", Qt::SkipEmptyParts),
                                msg);
 
            dlg.exec();
        }
        return false;
    }
    else if (!warningMessage().isEmpty() && !fileBatchMode()) {
        DlgLoadMessages dlg(i18nc("@title:window", "Krita"),
                            i18n("There were problems opening %1.", prettyPath()),
                            warningMessage().split("\n", Qt::SkipEmptyParts));
 
        dlg.exec();
        setPath(QString());
    }
 
    setMimeTypeAfterLoading(typeName);
    d->syncDecorationsWrapperLayerState();
    Q_EMIT sigLoadingFinished();
 
    undoStack()->clear();
 
    return true;
}

References KUndo2QStack::clear(), KisViewManager::createUnthreadedUpdater(), KisPart::currentMainwindow(), d, dbgUI, errorMessage(), KisImportExportErrorCode::errorMessage(), fileBatchMode(), KisPart::instance(), KisImportExportErrorCode::isOk(), localFilePath(), KisUsageLogger::log(), mimeType, KisMimeDatabase::mimeTypeForFile(), prettyPath(), setMimeTypeAfterLoading(), setPath(), sigLoadingFinished(), undoStack, KisMainWindow::viewManager, and warningMessage().

◆ openPath()

bool KisDocument::openPath	(	const QString &	path,
		OpenFlags	flags = None )

openPath Open a Path

Parameters

path	Path to file
flags	Control specific behavior

Returns: success status

Definition at line 1960 of file KisDocument.cpp.

{
    dbgUI << "path=" << _path;
    d->lastErrorMessage.clear();
 
    // Reimplemented, to add a check for autosave files and to improve error reporting
    if (_path.isEmpty()) {
        d->lastErrorMessage = i18n("Malformed Path\n%1", _path);  // ## used anywhere ?
        return false;
    }
 
    QString path = _path;
    QString original  = "";
    bool autosaveOpened = false;
    if (!fileBatchMode()) {
        QString file = path;
        QString asf = generateAutoSaveFileName(file);
        if (QFile::exists(asf)) {
            KisApplication *kisApp = static_cast<KisApplication*>(qApp);
            kisApp->hideSplashScreen();
            //qDebug() <<"asf=" << asf;
            // ## TODO compare timestamps ?
            KisRecoverNamedAutosaveDialog dlg(0, file, asf);
            dlg.exec();
            int res = dlg.result();
 
            switch (res) {
            case KisRecoverNamedAutosaveDialog::OpenAutosave :
                original = file;
                path = asf;
                autosaveOpened = true;
                break;
            case KisRecoverNamedAutosaveDialog::OpenMainFile :
                KisUsageLogger::log(QString("Removing autosave file: %1").arg(asf));
                QFile::remove(asf);
                break;
            default: // Cancel
                return false;
            }
        }
    }
 
    bool ret = openPathInternal(path);
 
    if (autosaveOpened || flags & RecoveryFile) {
        setReadWrite(true); // enable save button
        setModified(true);
        setRecovered(true);
 
        setPath(original); // since it was an autosave, it will be a local file
        setLocalFilePath(original);
    }
    else {
        if (ret) {
 
            if (!(flags & DontAddToRecent)) {
                KisPart::instance()->addRecentURLToAllMainWindows(QUrl::fromLocalFile(_path));
            }
 
#ifdef Q_OS_ANDROID
            // See the comment titled "ANDROID NOTES" in this file for an
            // explanation of what this is about. (This is not that comment.)
            setReadWrite(true);
#else
            QFileInfo fi(_path);
            setReadWrite(fi.isWritable());
#endif
        }
 
        setRecovered(false);
    }
 
    return ret;
}

References KisPart::addRecentURLToAllMainWindows(), d, dbgUI, DontAddToRecent, fileBatchMode(), generateAutoSaveFileName(), KisApplication::hideSplashScreen(), KisPart::instance(), KisUsageLogger::log(), KisRecoverNamedAutosaveDialog::OpenAutosave, KisRecoverNamedAutosaveDialog::OpenMainFile, openPathInternal(), path(), RecoveryFile, setLocalFilePath(), setModified(), setPath(), setReadWrite(), and setRecovered().

◆ openPathInternal()

bool KisDocument::openPathInternal ( const QString & path )

private

Definition at line 2617 of file KisDocument.cpp.

{
    if ( path.isEmpty() ) {
        return false;
    }
 
    if (d->m_bAutoDetectedMime) {
        d->mimeType = QByteArray();
        d->m_bAutoDetectedMime = false;
    }
 
    QByteArray mimeType = d->mimeType;
 
    if ( !closePath() ) {
        return false;
    }
 
    d->mimeType = mimeType;
    setPath(path);
 
    d->m_file.clear();
 
    d->m_file = d->m_path;
 
    bool ret = false;
    // set the mimeType only if it was not already set (for example, by the host application)
    if (d->mimeType.isEmpty()) {
        // get the mimeType of the file
        // using findByUrl() to avoid another string -> url conversion
        QString mime = KisMimeDatabase::mimeTypeForFile(d->m_path);
        d->mimeType = mime.toLocal8Bit();
        d->m_bAutoDetectedMime = true;
    }
 
    setPath(d->m_path);
    ret = openFile();
 
    if (ret) {
        Q_EMIT completed();
    }
    else {
        Q_EMIT canceled(QString());
    }
    return ret;
}

References canceled(), closePath(), completed(), d, mimeType, KisMimeDatabase::mimeTypeForFile(), openFile(), and setPath().

◆ path()

QString KisDocument::path ( ) const

Definition at line 2566 of file KisDocument.cpp.

{
    return d->m_path;
}

References d.

◆ preActivatedNode()

KisNodeSP KisDocument::preActivatedNode ( ) const

Returns: the node that was set as active during loading. Used only for saving loading. Never use it for tools or processing.

◆ prettyPath()

QString KisDocument::prettyPath ( ) const

private

Definition at line 2215 of file KisDocument.cpp.

{
    QString _url(path());
#ifdef Q_OS_WIN
    _url = QDir::toNativeSeparators(_url);
#endif
    return _url;
}

References path().

◆ Private() [1/2]

KisDocument::Private	(	const Private &	rhs,
		KisDocument *	_q )

inline

Definition at line 323 of file KisDocument.cpp.

        : q(_q)
        , docInfo(new KoDocumentInfo(*rhs.docInfo, _q))
        , importExportManager(new KisImportExportManager(_q))
        , autoSaveTimer(new QTimer(_q))
        , undoStack(new UndoStack(_q))
        , nserver(new KisNameServer(*rhs.nserver))
        , preActivatedNode(0) // the node is from another hierarchy!
        , imageIdleWatcher(2000 /*ms*/)
        , colorHistoryModel(rhs.colorHistoryModel)
    {
        copyFromImpl(rhs, _q, CONSTRUCT);
        connect(&imageIdleWatcher, SIGNAL(startedIdleMode()), q, SLOT(slotPerformIdleRoutines()));
    }

◆ Private() [2/2]

KisDocument::Private ( KisDocument * _q )

inline

Definition at line 298 of file KisDocument.cpp.

        : q(_q)
        , docInfo(new KoDocumentInfo(_q)) // deleted by QObject
        , importExportManager(new KisImportExportManager(_q)) // deleted manually
        , autoSaveTimer(new QTimer(_q))
        , undoStack(new UndoStack(_q)) // deleted by QObject
        , m_bAutoDetectedMime(false)
        , modified(false)
        , readwrite(true)
        , autoSaveActive(true)
        , firstMod(QDateTime::currentDateTime())
        , lastMod(firstMod)
        , nserver(new KisNameServer(1))
        , imageIdleWatcher(2000 /*ms*/)
        , globalAssistantsColor(KisConfig(true).defaultAssistantsColor())
        , batchMode(false)
    {
        if (QLocale().measurementSystem() == QLocale::ImperialSystem) {
            unit = KoUnit::Inch;
        } else {
            unit = KoUnit::Centimeter;
        }
        connect(&imageIdleWatcher, SIGNAL(startedIdleMode()), q, SLOT(slotPerformIdleRoutines()));
    }

References KoUnit::Centimeter, and KoUnit::Inch.

◆ referenceImagesLayer()

KisReferenceImagesLayerSP KisDocument::referenceImagesLayer ( ) const

Get existing reference images layer or null if none exists.

Definition at line 2809 of file KisDocument.cpp.

{
    if (!d->image) return KisReferenceImagesLayerSP();
 
    KisReferenceImagesLayerSP referencesLayer =
            KisLayerUtils::findNodeByType<KisReferenceImagesLayer>(d->image->root());
 
    return referencesLayer;
}

References d.

◆ removeAutoSaveFiles()

void KisDocument::removeAutoSaveFiles	(	const QString &	autosaveBaseName,
		bool	wasRecovered )

Performs a cleanup of unneeded backup files

Definition at line 2288 of file KisDocument.cpp.

{
    // Eliminate any auto-save file
    QString asf = generateAutoSaveFileName(autosaveBaseName);   // the one in the current dir
    if (QFile::exists(asf)) {
        KisUsageLogger::log(QString("Removing autosave file: %1").arg(asf));
        QFile::remove(asf);
    }
    asf = generateAutoSaveFileName(QString());   // and the one in $HOME
 
    if (QFile::exists(asf)) {
        KisUsageLogger::log(QString("Removing autosave file: %1").arg(asf));
        QFile::remove(asf);
    }
 
    QList<QRegularExpression> expressions;
 
    expressions << QRegularExpression("^\\..+-autosave.kra$")
                << QRegularExpression("^.+-autosave.kra$");
 
    Q_FOREACH(const QRegularExpression &rex, expressions) {
        if (wasRecovered &&
                !autosaveBaseName.isEmpty() &&
                rex.match(QFileInfo(autosaveBaseName).fileName()).hasMatch() &&
                QFile::exists(autosaveBaseName)) {
 
            KisUsageLogger::log(QString("Removing autosave file: %1").arg(autosaveBaseName));
            QFile::remove(autosaveBaseName);
        }
    }
}

References generateAutoSaveFileName(), and KisUsageLogger::log().

◆ resetPath()

void KisDocument::resetPath ( )

Sets the document Path to empty Path After using loadNativeFormat on a template, one wants to set the path to QString()

Definition at line 2551 of file KisDocument.cpp.

                            {
    setPath(QString());
    setLocalFilePath(QString());
}

References setLocalFilePath(), and setPath().

◆ resourceSavingFilter()

bool KisDocument::resourceSavingFilter	(	const QString &	path,
		const QByteArray &	mimeType,
		KisPropertiesConfigurationSP	exportConfiguration )

private

Checks whether we are saving a resource we've been editing, and if so, uses the resource server to update the resource.

Returns: true if this was a resource, false if the document needs to be saved

Definition at line 1577 of file KisDocument.cpp.

{
    if (QFileInfo(path).absolutePath().startsWith(KisResourceLocator::instance()->resourceLocationBase())) {
 
        QStringList pathParts = QFileInfo(path).absolutePath().split('/');
        if (pathParts.size() > 0) {
            QString resourceType = pathParts.last();
            if (KisResourceLoaderRegistry::instance()->resourceTypes().contains(resourceType)) {
 
                KisResourceModel model(resourceType);
                model.setResourceFilter(KisResourceModel::ShowAllResources);
 
                QString tempFileName = QDir::tempPath() + "/" + QFileInfo(path).fileName();
 
                if (QFileInfo(path).exists()) {
 
                    int outResourceId;
                    KoResourceSP res;
                    if (KisResourceCacheDb::getResourceIdFromVersionedFilename(QFileInfo(path).fileName(), resourceType, "", outResourceId)) {
                        res = model.resourceForId(outResourceId);
                    }
 
                    if (res) {
                        d->modifiedWhileSaving = false;
 
                        if (!exportConfiguration) {
                            QScopedPointer<KisImportExportFilter> filter(
                                KisImportExportManager::filterForMimeType(mimeType, KisImportExportManager::Export));
                            if (filter) {
                                exportConfiguration = filter->defaultConfiguration(nativeFormatMimeType(), mimeType);
                            }
                        }
 
                        if (exportConfiguration) {
                            // make sure the name of the resource doesn't change
                            exportConfiguration->setProperty("name", res->name());
                        }
 
                        if (exportDocumentSync(tempFileName, mimeType, exportConfiguration)) {
                            QFile f2(tempFileName);
                            KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(f2.open(QFile::ReadOnly), false);
 
                            QByteArray ba = f2.readAll();
 
                            QBuffer buf(&ba);
                            buf.open(QBuffer::ReadOnly);
 
 
 
                            if (res->loadFromDevice(&buf, KisGlobalResourcesInterface::instance())) {
                                if (model.updateResource(res)) {
                                    const QString filePath =
                                        KisResourceLocator::instance()->filePathForResource(res);
 
                                    d->updateDocumentMetadataOnSaving(filePath, mimeType);
 
                                    return true;
                                }
                            }
                        }
                    }
                }
                else {
                    d->modifiedWhileSaving = false;
                    if (exportDocumentSync(tempFileName, mimeType, exportConfiguration)) {
                        KoResourceSP res = model.importResourceFile(tempFileName, false);
                        if (res) {
                            const QString filePath =
                                KisResourceLocator::instance()->filePathForResource(res);
 
                            d->updateDocumentMetadataOnSaving(filePath, mimeType);
 
                            return true;
                        }
                    }
                }
            }
        }
    }
    return false;
}

References d, KisImportExportManager::Export, exportDocumentSync(), KisResourceLocator::filePathForResource(), KisImportExportManager::filterForMimeType(), KisResourceCacheDb::getResourceIdFromVersionedFilename(), KisResourceModel::importResourceFile(), KisGlobalResourcesInterface::instance(), KisResourceLoaderRegistry::instance(), KisResourceLocator::instance(), KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, mimeType, nativeFormatMimeType(), KisResourceModel::resourceForId(), KisResourceModel::setResourceFilter(), KisAbstractResourceFilterInterface::ShowAllResources, and KisResourceModel::updateResource().

◆ save()

bool KisDocument::save	(	bool	showWarnings,
		KisPropertiesConfigurationSP	exportConfiguration )

Definition at line 977 of file KisDocument.cpp.

{
    return saveAs(path(), mimeType(), showWarnings, exportConfiguration);
}

References mimeType, path(), and saveAs().

◆ saveAs()

bool KisDocument::saveAs	(	const QString &	path,
		const QByteArray &	mimeType,
		bool	showWarnings,
		KisPropertiesConfigurationSP	exportConfiguration = 0 )

Definition at line 953 of file KisDocument.cpp.

{
    using namespace KritaUtils;
 
    KisUsageLogger::log(QString("Saving Document %9 as %1 (mime: %2). %3 * %4 pixels, %5 layers.  %6 frames, "
                                "%7 framerate. Export configuration: %8")
                            .arg(_path, QString::fromLatin1(mimeType), QString::number(d->image->width()),
                                 QString::number(d->image->height()), QString::number(d->image->nlayers()),
                                 QString::number(d->image->animationInterface()->totalLength()),
                                 QString::number(d->image->animationInterface()->framerate()),
                                 (exportConfiguration ? exportConfiguration->toXML() : "No configuration"),
                                 path()));
 
    // Check whether it's an existing resource were are saving to
    if (resourceSavingFilter(_path, mimeType, exportConfiguration)) {
        return true;
    }
 
    return exportDocumentImpl(ExportFileJob(_path,
                                            mimeType,
                                            showWarnings ? SaveShowWarnings : SaveNone),
                              exportConfiguration);
}

References d, exportDocumentImpl(), KisUsageLogger::log(), mimeType, path(), and resourceSavingFilter().

◆ savingImage()

KisImageSP KisDocument::savingImage ( ) const

savingImage provides a detached, shallow copy of the original image that must be used when saving. Any strokes in progress will not be applied to this image, so the result might be missing some data. On the other hand, it won't block.

Returns: a shallow copy of the original image, or 0 is saving is not in progress

◆ serializeToNativeByteArray()

QByteArray KisDocument::serializeToNativeByteArray ( )

serializeToNativeByteArray daves the document into a .kra file written to a memory-based byte-array

Returns: a byte array containing the .kra file

Definition at line 982 of file KisDocument.cpp.

{
    QBuffer buffer;
 
    QScopedPointer<KisImportExportFilter> filter(KisImportExportManager::filterForMimeType(nativeFormatMimeType(), KisImportExportManager::Export));
    filter->setBatchMode(true);
    filter->setMimeType(nativeFormatMimeType());
 
    Private::StrippedSafeSavingLocker locker(&d->savingMutex, d->image);
    if (!locker.successfullyLocked()) {
        return buffer.data();
    }
 
    d->savingImage = d->image;
 
    if (!filter->convert(this, &buffer).isOk()) {
        qWarning() << "serializeToByteArray():: Could not export to our native format";
    }
 
    return buffer.data();
}

References d, KisImportExportManager::Export, KisImportExportManager::filterForMimeType(), and nativeFormatMimeType().

◆ setAssistants()

void KisDocument::setAssistants ( const QList< KisPaintingAssistantSP > & value )

@replace the current list of assistants with

Parameters

value

Definition at line 2800 of file KisDocument.cpp.

{
    if (d->assistants != value) {
        d->assistants = value;
        d->syncDecorationsWrapperLayerState();
        Q_EMIT sigAssistantsChanged();
    }
}

References d, sigAssistantsChanged(), and value().

◆ setAssistantsGlobalColor()

void KisDocument::setAssistantsGlobalColor ( QColor color )

Definition at line 2942 of file KisDocument.cpp.

{
    d->globalAssistantsColor = color;
}

References d.

◆ setAudioTracks()

void KisDocument::setAudioTracks ( QVector< QFileInfo > f )

Definition at line 2498 of file KisDocument.cpp.

{
    d->audioTracks = f;
    Q_EMIT sigAudioTracksChanged();
}

References d, and sigAudioTracksChanged().

◆ setAudioVolume()

void KisDocument::setAudioVolume ( qreal level )

Definition at line 2504 of file KisDocument.cpp.

{
    d->audioLevel = level;
    Q_EMIT sigAudioLevelChanged(level);
}

References d, and sigAudioLevelChanged().

◆ setAutoSaveActive()

void KisDocument::setAutoSaveActive ( bool autoSaveIsActive )

Allow to activate or deactivate autosave on document, independently of auto save delay

the value is independent of auto save delay

Definition at line 1802 of file KisDocument.cpp.

{
    const bool changed = autoSaveActive != d->autoSaveActive;
 
    if (changed) {
        d->autoSaveActive = autoSaveActive;
        setNormalAutoSaveInterval();
    }
}

References autoSaveActive, d, and setNormalAutoSaveInterval().

◆ setAutoSaveDelay()

void KisDocument::setAutoSaveDelay ( int delay )

private

Activate/deactivate/configure the autosave feature.

Parameters

delay in seconds, 0 to disable

Definition at line 1812 of file KisDocument.cpp.

{
    if (isReadWrite() && delay > 0 && d->autoSaveActive) {
        d->autoSaveTimer->start(delay * 1000);
    } else {
        d->autoSaveTimer->stop();
    }
}

References d, and isReadWrite().

◆ setColorHistoryColors()

void KisDocument::setColorHistoryColors ( const QList< KoColor > & colors )

Replaces the per-document history of the last-used colors, from the newest to oldest.

The actual values are stored in the model returned by colorHistoryModel()

Definition at line 2965 of file KisDocument.cpp.

{
    d->colorHistoryModel.setColorList(colors);
}

References d.

◆ setCurrentImage()

void KisDocument::setCurrentImage	(	KisImageSP	image,
		bool	forceInitialUpdate = true,
		KisNodeSP	preActivatedNode = nullptr )

Set the current image to the specified image and turn undo on.

Definition at line 2874 of file KisDocument.cpp.

{
    if (d->image) {
        // Disconnect existing sig/slot connections
        d->image->setUndoStore(new KisDumbUndoStore());
        d->image->disconnect(this);
        d->shapeController->setImage(0);
        d->image = 0;
    }
 
    if (!image) return;
 
    if (d->linkedResourceStorage){
        d->linkedResourceStorage->setMetaData(KisResourceStorage::s_meta_name, image->objectName());
    }
 
    d->setImageAndInitIdleWatcher(image);
    d->image->setUndoStore(new KisDocumentUndoStore(this));
    d->shapeController->setImage(image, preActivatedNode);
    d->image->setMirrorAxesCenter(KisAlgebra2D::absoluteToRelative(d->mirrorAxisConfig.axisPosition(), image->bounds()));
    setModified(false);
    connect(d->image, SIGNAL(sigImageModified()), this, SLOT(setImageModified()), Qt::UniqueConnection);
    connect(d->image, SIGNAL(sigImageModifiedWithoutUndo()), this, SLOT(setImageModifiedWithoutUndo()), Qt::UniqueConnection);
    connect(d->image, SIGNAL(sigLayersChangedAsync()), this, SLOT(slotImageRootChanged()));
 
    if (forceInitialUpdate) {
        d->image->initialRefreshGraph();
    }
}

References KisAlgebra2D::absoluteToRelative(), KisImage::bounds(), d, image, preActivatedNode, KisResourceStorage::s_meta_name, setImageModified(), setImageModifiedWithoutUndo(), setModified(), and slotImageRootChanged().

◆ setEmergencyAutoSaveInterval()

void KisDocument::setEmergencyAutoSaveInterval ( )

Set emergency interval that autosave uses when the image is busy, by default it is 10 sec

Definition at line 1827 of file KisDocument.cpp.

{
    const int emergencyAutoSaveInterval = 10; /* sec */
    setAutoSaveDelay(emergencyAutoSaveInterval);
    d->autoSaveFailureCount++;
}

References d, and setAutoSaveDelay().

◆ setEmpty()

void KisDocument::setEmpty ( bool empty = true )

Sets the document to empty.

Used after loading a template (which is not empty, but not the user's input).

See also: isEmpty()

◆ setErrorMessage()

void KisDocument::setErrorMessage ( const QString & errMsg )

Sets the error message to be shown to the user (use i18n()!) when loading or saving fails. If you asked the user about something and they chose "Cancel",

Definition at line 2267 of file KisDocument.cpp.

{
    d->lastErrorMessage = errMsg;
}

References d.

◆ setFileBatchMode()

void KisDocument::setFileBatchMode ( const bool batchMode )

Parameters

batchMode if true, do not show the option dialog for file operations.

Definition at line 1150 of file KisDocument.cpp.

{
    d->batchMode = batchMode;
}

References batchMode, and d.

◆ setGridConfig()

void KisDocument::setGridConfig ( const KisGridConfig & config )

Definition at line 2383 of file KisDocument.cpp.

{
    if (d->gridConfig != config) {
        d->gridConfig = config;
        d->syncDecorationsWrapperLayerState();
        Q_EMIT sigGridConfigChanged(config);
 
        // Store last assigned value as future default...
        KisConfig cfg(false);
        cfg.setDefaultGridSpacing(config.spacing());
    }
}

References d, KisConfig::setDefaultGridSpacing(), sigGridConfigChanged(), and KisGridConfig::spacing().

◆ setGuidesConfig()

void KisDocument::setGuidesConfig ( const KisGuidesConfig & data )

Definition at line 2520 of file KisDocument.cpp.

{
    if (d->guidesConfig == data) return;
 
    d->guidesConfig = data;
    d->syncDecorationsWrapperLayerState();
    Q_EMIT sigGuidesConfigChanged(d->guidesConfig);
}

References d, and sigGuidesConfigChanged().

◆ setImageAndInitIdleWatcher()

void KisDocument::setImageAndInitIdleWatcher ( KisImageSP _image )

inline

Definition at line 431 of file KisDocument.cpp.

                                                       {
        image = _image;
 
        imageIdleWatcher.setTrackedImage(image);
    }

References KisIdleWatcher::setTrackedImage().

◆ setImageModified

void KisDocument::setImageModified ( )

privateslot

Definition at line 2914 of file KisDocument.cpp.

{
    // we only set as modified if undo stack is not at clean state
    setModified(d->imageModifiedWithoutUndo || !d->undoStack->isClean());
}

References d, and setModified().

◆ setImageModifiedWithoutUndo

void KisDocument::setImageModifiedWithoutUndo ( )

privateslot

Definition at line 2920 of file KisDocument.cpp.

{
    d->imageModifiedWithoutUndo = true;
    setImageModified();
}

References d, and setImageModified().

◆ setInfiniteAutoSaveInterval()

void KisDocument::setInfiniteAutoSaveInterval ( )

Disable autosave

Definition at line 1834 of file KisDocument.cpp.

{
    setAutoSaveDelay(-1);
}

References setAutoSaveDelay().

◆ setLocalFilePath()

void KisDocument::setLocalFilePath ( const QString & localFilePath )

Definition at line 2612 of file KisDocument.cpp.

{
    d->m_file = localFilePath;
}

References d, and localFilePath().

◆ setMimeType()

void KisDocument::setMimeType ( const QByteArray & mimeType )

Sets the mime type for the document.

When choosing "save as" this is also the mime type selected by default.

Definition at line 1140 of file KisDocument.cpp.

{
    d->mimeType = mimeType;
}

References d, and mimeType.

◆ setMimeTypeAfterLoading()

void KisDocument::setMimeTypeAfterLoading ( const QString & mimeType )

Definition at line 2131 of file KisDocument.cpp.

{
    d->mimeType = mimeType.toLatin1();
    d->outputMimeType = d->mimeType;
}

References d, and mimeType.

◆ setMirrorAxisConfig()

void KisDocument::setMirrorAxisConfig ( const KisMirrorAxisConfig & config )

Definition at line 2535 of file KisDocument.cpp.

{
    if (d->mirrorAxisConfig == config) {
        return;
    }
 
    d->mirrorAxisConfig = config;
    if (d->image) {
        d->image->setMirrorAxesCenter(KisAlgebra2D::absoluteToRelative(d->mirrorAxisConfig.axisPosition(),
                                                                       d->image->bounds()));
    }
    setModified(true);
 
    Q_EMIT sigMirrorAxisConfigChanged();
}

References KisAlgebra2D::absoluteToRelative(), d, setModified(), and sigMirrorAxisConfigChanged().

◆ setModified()

void KisDocument::setModified ( bool _mod )

Sets the modified flag on the document. This means that it has to be saved or not before deleting it.

1) Ignore setModified calls due to autosaving 2) When closing a document, QUndoStack emits a lot of modified signals, when clearing itself, so we should ignore all of them.

Definition at line 2143 of file KisDocument.cpp.

{
    if (mod) {
        updateEditingTime(false);
    }
 
    if (d->isAutosaving || d->documentIsClosing)
        return;
 
    //dbgUI<<" url:" << url.path();
    //dbgUI<<" mod="<<mod<<" MParts mod="<<KisParts::ReadWritePart::isModified()<<" isModified="<<isModified();
 
    if (mod && !d->autoSaveTimer->isActive()) {
        // First change since last autosave -> start the autosave timer
        setNormalAutoSaveInterval();
    }
    d->modifiedAfterAutosave = mod;
    d->modifiedWhileSaving = mod;
 
    if (!mod) {
        d->imageModifiedWithoutUndo = mod;
    }
 
    if (mod == isModified())
        return;
 
    d->modified = mod;
 
    if (mod) {
        documentInfo()->updateParameters();
    }
 
    Q_EMIT modified(mod);
}

References d, documentInfo(), isModified(), modified, setNormalAutoSaveInterval(), updateEditingTime(), and KoDocumentInfo::updateParameters().

◆ setNormalAutoSaveInterval()

void KisDocument::setNormalAutoSaveInterval ( )

Set standard autosave interval that is set by a config file

Definition at line 1821 of file KisDocument.cpp.

{
    setAutoSaveDelay(d->autoSaveDelay);
    d->autoSaveFailureCount = 0;
}

References d, and setAutoSaveDelay().

◆ setPaletteList()

void KisDocument::setPaletteList	(	const QList< KoColorSetSP > &	paletteList,
		bool	emitSignal = false )

setPaletteList replaces the palettes in the document's local resource storage with the list of palettes passed to this function. It will then Q_EMIT sigPaletteListChanged with both the old and the new list, if emitSignal is true.

Definition at line 2433 of file KisDocument.cpp.

{
    QList<KoColorSetSP> oldPaletteList;
    if (d->linkedResourceStorage) {
        QSharedPointer<KisResourceStorage::ResourceIterator> iter = d->linkedResourceStorage->resources(ResourceType::Palettes);
        while (iter->hasNext()) {
            iter->next();
            KoResourceSP resource = iter->resource();
            if (resource && resource->valid()) {
                oldPaletteList << resource.dynamicCast<KoColorSet>();
            }
        }
        if (oldPaletteList != paletteList) {
            KisResourceModel resourceModel(ResourceType::Palettes);
            Q_FOREACH(KoColorSetSP palette, oldPaletteList) {
                if (!paletteList.contains(palette)) {
                    resourceModel.setResourceInactive(resourceModel.indexForResource(palette));
                }
            }
            Q_FOREACH(KoColorSetSP palette, paletteList) {
                if (!oldPaletteList.contains(palette)) {
                    resourceModel.addResource(palette, d->linkedResourcesStorageID);
                }
                else {
                    palette->setStorageLocation(d->linkedResourcesStorageID);
                    resourceModel.updateResource(palette);
                }
            }
            if (emitSignal) {
                Q_EMIT sigPaletteListChanged(oldPaletteList, paletteList);
            }
        }
    }
}

References KisResourceModel::addResource(), d, KisResourceModel::indexForResource(), palette, ResourceType::Palettes, KisAbstractResourceModel::setResourceInactive(), sigPaletteListChanged(), and KisResourceModel::updateResource().

◆ setPath()

void KisDocument::setPath ( const QString & path )

Definition at line 2595 of file KisDocument.cpp.

{
    const bool changed = path != d->m_path;
 
    d->m_path = path;
 
    if (changed) {
        Q_EMIT sigPathChanged(path);
    }
}

References d, path(), and sigPathChanged().

◆ setPreActivatedNode()

void KisDocument::setPreActivatedNode ( KisNodeSP activatedNode )

Set the list of nodes that was marked as currently active. Used only for saving loading. Never use it for tools or processing.

Definition at line 2853 of file KisDocument.cpp.

{
    d->preActivatedNode = activatedNode;
}

References d.

◆ setReadWrite()

void KisDocument::setReadWrite ( bool readwrite = true )

Sets whether the document can be edited or is read only.

This recursively applied to all child documents and KisView::updateReadWrite is called for every attached view.

Definition at line 1791 of file KisDocument.cpp.

{
    const bool changed = readwrite != d->readwrite;
 
    d->readwrite = readwrite;
 
    if (changed) {
        Q_EMIT sigReadWriteChanged(readwrite);
    }
}

References d, readwrite, and sigReadWriteChanged().

◆ setRecovered()

void KisDocument::setRecovered ( bool value )

Definition at line 2182 of file KisDocument.cpp.

{
    const bool changed = value != d->isRecovered;
 
    d->isRecovered = value;
 
    if (changed) {
        Q_EMIT sigRecoveredChanged(value);
    }
}

References d, sigRecoveredChanged(), and value().

◆ setReferenceImagesLayer()

void KisDocument::setReferenceImagesLayer	(	KisSharedPtr< KisReferenceImagesLayer >	layer,
		bool	updateImage )

Definition at line 2819 of file KisDocument.cpp.

{
    KisReferenceImagesLayerSP currentReferenceLayer = referenceImagesLayer();
 
    // updateImage=false inherently means we are not changing the
    // reference images layer, but just would like to update its signals.
    if (currentReferenceLayer == layer && updateImage) {
        return;
    }
 
    d->referenceLayerConnections.clear();
 
    if (updateImage) {
        if (currentReferenceLayer) {
            d->image->removeNode(currentReferenceLayer);
        }
 
        if (layer) {
            d->image->addNode(layer);
        }
    }
 
    currentReferenceLayer = layer;
 
    if (currentReferenceLayer) {
        d->referenceLayerConnections.addConnection(
                    currentReferenceLayer, SIGNAL(sigUpdateCanvas(QRectF)),
                    this, SIGNAL(sigReferenceImagesChanged()));
    }
 
    Q_EMIT sigReferenceImagesLayerChanged(layer);
    Q_EMIT sigReferenceImagesChanged();
}

References d, referenceImagesLayer(), sigReferenceImagesChanged(), and sigReferenceImagesLayerChanged().

◆ setStoryboardCommentList()

void KisDocument::setStoryboardCommentList	(	const QVector< StoryboardComment > &	storyboardCommentList,
		bool	emitSignal = false )

sets the list of comments for the storyboard docker in the document, emits empty signal if emitSignal is true.

Definition at line 2486 of file KisDocument.cpp.

{
    d->m_storyboardCommentList = storyboardCommentList;
    if (emitSignal) {
        Q_EMIT sigStoryboardCommentListChanged();
    }
}

References d, and sigStoryboardCommentListChanged().

◆ setStoryboardItemList()

void KisDocument::setStoryboardItemList	(	const StoryboardItemList &	storyboardItemList,
		bool	emitSignal = false )

sets the storyboardItemList in the document, emits empty signal if emitSignal is true.

Definition at line 2473 of file KisDocument.cpp.

{
    d->m_storyboardItemList = storyboardItemList;
    if (emitSignal) {
        Q_EMIT sigStoryboardItemListChanged();
    }
}

References d, and sigStoryboardItemListChanged().

◆ setUnit()

void KisDocument::setUnit ( const KoUnit & unit )

Sets the unit used to display all measures/distances.

Definition at line 2325 of file KisDocument.cpp.

{
    if (d->unit != unit) {
        d->unit = unit;
        Q_EMIT unitChanged(unit);
    }
}

References d, unit, and unitChanged().

◆ setWarningMessage()

void KisDocument::setWarningMessage ( const QString & warningMsg )

Sets the warning message to be shown to the user (use i18n()!) when loading or saving fails.

Definition at line 2277 of file KisDocument.cpp.

{
    d->lastWarningMessage = warningMsg;
}

References d.

◆ shapeController()

KoShapeControllerBase * KisDocument::shapeController ( ) const

The shape controller matches internal krita image layers with the flake shape hierarchy.

◆ shapeForNode()

KoShapeLayer * KisDocument::shapeForNode ( KisNodeSP layer ) const

Definition at line 2790 of file KisDocument.cpp.

{
    return d->shapeController->shapeForNode(layer);
}

References d.

◆ sigAssistantsChanged

void KisDocument::sigAssistantsChanged ( )

signal

◆ sigAudioLevelChanged

void KisDocument::sigAudioLevelChanged ( qreal level )

signal

◆ sigAudioTracksChanged

void KisDocument::sigAudioTracksChanged ( )

signal

◆ sigBackgroundSavingFinished

void KisDocument::sigBackgroundSavingFinished	(	KisImportExportErrorCode	status,
		const QString &	errorMessage,
		const QString &	warningMessage )

signal

◆ sigCompleteBackgroundSaving

void KisDocument::sigCompleteBackgroundSaving	(	const KritaUtils::ExportFileJob &	job,
		KisImportExportErrorCode	status,
		const QString &	errorMessage,
		const QString &	warningMessage )

signal

◆ sigGridConfigChanged

void KisDocument::sigGridConfigChanged ( const KisGridConfig & config )

signal

◆ sigGuidesConfigChanged

void KisDocument::sigGuidesConfigChanged ( const KisGuidesConfig & config )

signal

◆ sigLoadingFinished

void KisDocument::sigLoadingFinished ( )

signal

◆ sigMirrorAxisConfigChanged

void KisDocument::sigMirrorAxisConfigChanged ( )

signal

◆ sigPaletteListChanged

void KisDocument::sigPaletteListChanged	(	const QList< KoColorSetSP > &	oldPaletteList,
		const QList< KoColorSetSP > &	newPaletteList )

signal

Emitted when the palette list has changed. The pointers in oldPaletteList are to be deleted by the resource server.

◆ sigPathChanged

void KisDocument::sigPathChanged ( const QString & path )

signal

◆ sigReadWriteChanged

void KisDocument::sigReadWriteChanged ( bool value )

signal

◆ sigRecoveredChanged

void KisDocument::sigRecoveredChanged ( bool value )

signal

◆ sigReferenceImagesChanged

void KisDocument::sigReferenceImagesChanged ( )

signal

◆ sigReferenceImagesLayerChanged

void KisDocument::sigReferenceImagesLayerChanged ( KisSharedPtr< KisReferenceImagesLayer > layer )

signal

◆ sigSavingFinished

void KisDocument::sigSavingFinished ( const QString & filePath )

signal

◆ sigStoryboardCommentListChanged

void KisDocument::sigStoryboardCommentListChanged ( )

signal

◆ sigStoryboardItemListChanged

void KisDocument::sigStoryboardItemListChanged ( )

signal

◆ slotAutoSave

void KisDocument::slotAutoSave ( )

privateslot

Definition at line 1659 of file KisDocument.cpp.

{
    slotAutoSaveImpl(std::unique_ptr<KisDocument>());
}

References slotAutoSaveImpl().

◆ slotAutoSaveImpl()

void KisDocument::slotAutoSaveImpl ( std::unique_ptr< KisDocument > && optionalClonedDocument )

private

Definition at line 1534 of file KisDocument.cpp.

{
    if (!d->modified || !d->modifiedAfterAutosave) return;
    const QString autoSaveFileName = generateAutoSaveFileName(localFilePath());
 
    Q_EMIT statusBarMessage(i18n("Autosaving... %1", autoSaveFileName), successMessageTimeout);
 
    KisUsageLogger::log(QString("Autosaving: %1").arg(autoSaveFileName));
 
    const bool hadClonedDocument = bool(optionalClonedDocument);
    KritaUtils::BackgroudSavingStartResult result = KritaUtils::BackgroudSavingStartResult::Failure;
 
    if (d->image->isIdle() || hadClonedDocument) {
        result = initiateSavingInBackground(i18n("Autosaving..."),
                                             this, SLOT(slotCompleteAutoSaving(KritaUtils::ExportFileJob, KisImportExportErrorCode, QString, QString)),
                                             KritaUtils::ExportFileJob(autoSaveFileName, nativeFormatMimeType(), KritaUtils::SaveIsExporting | KritaUtils::SaveInAutosaveMode),
                                             0,
                                             std::move(optionalClonedDocument));
    } else {
        Q_EMIT statusBarMessage(i18n("Autosaving postponed: document is busy..."), errorMessageTimeout);
    }
 
    if (result != KritaUtils::BackgroudSavingStartResult::Success && !hadClonedDocument && d->autoSaveFailureCount >= 3) {
        KisCloneDocumentStroke *stroke = new KisCloneDocumentStroke(this);
        connect(stroke, SIGNAL(sigDocumentCloned(KisDocument*)),
                this, SLOT(slotInitiateAsyncAutosaving(KisDocument*)),
                Qt::BlockingQueuedConnection);
        connect(stroke, SIGNAL(sigCloningCancelled()),
                this, SLOT(slotDocumentCloningCancelled()),
                Qt::BlockingQueuedConnection);
 
        KisStrokeId strokeId = d->image->startStroke(stroke);
        d->image->endStroke(strokeId);
 
        setInfiniteAutoSaveInterval();
 
    } else if (result != KritaUtils::BackgroudSavingStartResult::Success) {
        setEmergencyAutoSaveInterval();
    } else {
        d->modifiedAfterAutosave = false;
    }
}

References d, KritaUtils::Failure, generateAutoSaveFileName(), initiateSavingInBackground(), localFilePath(), KisUsageLogger::log(), nativeFormatMimeType(), KritaUtils::SaveInAutosaveMode, KritaUtils::SaveIsExporting, setEmergencyAutoSaveInterval(), setInfiniteAutoSaveInterval(), slotCompleteAutoSaving(), slotDocumentCloningCancelled(), slotInitiateAsyncAutosaving(), statusBarMessage(), and KritaUtils::Success.

◆ slotChildCompletedSavingInBackground

void KisDocument::slotChildCompletedSavingInBackground	(	KisImportExportErrorCode	status,
		const QString &	errorMessage,
		const QString &	warningMessage )

privateslot

Take back the ownership of the saving mutex and make sure it well be released whatever the result of executing this function will be, even if it asserts.

Definition at line 1494 of file KisDocument.cpp.

{
    KIS_ASSERT_RECOVER_RETURN(isSaving());
 
    std::unique_lock<QMutex> savingMutexLock(d->savingMutex, std::adopt_lock);
 
    KIS_ASSERT_RECOVER_RETURN(d->backgroundSaveDocument);
 
    if (d->backgroundSaveJob.flags & KritaUtils::SaveInAutosaveMode) {
        d->backgroundSaveDocument->d->isAutosaving = false;
    }
 
    d->backgroundSaveDocument.release()->deleteLater();
 
    KIS_ASSERT_RECOVER_RETURN(d->backgroundSaveJob.isValid());
 
    const KritaUtils::ExportFileJob job = d->backgroundSaveJob;
    d->backgroundSaveJob = KritaUtils::ExportFileJob();
 
    // unlock at the very end
    savingMutexLock.unlock();
 
    QFileInfo fi(job.filePath);
    KisUsageLogger::log(QString("Completed saving %1 (mime: %2). Result: %3. Warning: %4. Size: %5")
                            .arg(job.filePath, QString::fromLatin1(job.mimeType),
                                 (!status.isOk() ? errorMessage : "OK"), warningMessage,
                                 QString::number(fi.size())));
 
    Q_EMIT sigCompleteBackgroundSaving(job, status, errorMessage, warningMessage);
    // One-shot: disconnect immediately after firing so future save completions
    // don't invoke a stale or unrelated slot.
    disconnect(d->completeSavingConnection);
    d->completeSavingConnection = {};
}

References d, errorMessage(), KritaUtils::ExportFileJob::filePath, KisImportExportErrorCode::isOk(), isSaving(), KIS_ASSERT_RECOVER_RETURN, KisUsageLogger::log(), KritaUtils::ExportFileJob::mimeType, KritaUtils::SaveInAutosaveMode, sigCompleteBackgroundSaving(), and warningMessage().

◆ slotCompleteAutoSaving

void KisDocument::slotCompleteAutoSaving	(	const KritaUtils::ExportFileJob &	job,
		KisImportExportErrorCode	status,
		const QString &	errorMessage,
		const QString &	warningMessage )

privateslot

Definition at line 1686 of file KisDocument.cpp.

{
    Q_UNUSED(job);
    Q_UNUSED(warningMessage);
 
    const QString fileName = QFileInfo(job.filePath).fileName();
 
    if (!status.isOk()) {
        setEmergencyAutoSaveInterval();
        Q_EMIT statusBarMessage(i18nc("%1 --- failing file name, %2 --- error message",
                                    "Error during autosaving %1: %2",
                                    fileName,
                                    exportErrorToUserMessage(status, errorMessage)), errorMessageTimeout);
    } else {
        KisConfig cfg(true);
        d->autoSaveDelay = cfg.autoSaveInterval();
 
        if (!d->modifiedWhileSaving) {
            d->autoSaveTimer->stop(); // until the next change
            d->autoSaveFailureCount = 0;
        } else {
            setNormalAutoSaveInterval();
        }
 
        Q_EMIT statusBarMessage(i18n("Finished autosaving %1", fileName), successMessageTimeout);
    }
}

References KisConfig::autoSaveInterval(), d, errorMessage(), exportErrorToUserMessage(), KritaUtils::ExportFileJob::filePath, KisImportExportErrorCode::isOk(), setEmergencyAutoSaveInterval(), setNormalAutoSaveInterval(), statusBarMessage(), and warningMessage().

◆ slotCompleteSavingDocument

void KisDocument::slotCompleteSavingDocument	(	const KritaUtils::ExportFileJob &	job,
		KisImportExportErrorCode	status,
		const QString &	errorMessage,
		const QString &	warningMessage )

privateslot

Definition at line 1042 of file KisDocument.cpp.

{
    if (status.isCancelled())
        return;
 
    const QString fileName = QFileInfo(job.filePath).fileName();
 
    if (!status.isOk()) {
        Q_EMIT statusBarMessage(i18nc("%1 --- failing file name, %2 --- error message",
                                    "Error during saving %1: %2",
                                    fileName,
                                    errorMessage), errorMessageTimeout);
 
 
        if (!fileBatchMode()) {
            DlgLoadMessages dlg(i18nc("@title:window", "Krita"),
                                i18n("Could not save %1.", job.filePath),
                                errorMessage.split("\n", Qt::SkipEmptyParts)
                                    + warningMessage.split("\n", Qt::SkipEmptyParts),
                                status.errorMessage());
 
            dlg.exec();
        }
    }
    else {
        if (!fileBatchMode() && !warningMessage.isEmpty()) {
 
            QStringList reasons = warningMessage.split("\n", Qt::SkipEmptyParts);
 
            DlgLoadMessages dlg(
                i18nc("@title:window", "Krita"),
                i18nc("dialog box shown to the user if there were warnings while saving the document, "
                      "%1 is the file path",
                      "%1 has been saved but is incomplete.",
                      job.filePath),
                reasons,
                reasons.isEmpty()
                    ? ""
                    : i18nc("dialog box shown to the user if there were warnings while saving the document",
                            "Some problems were encountered when saving."));
            dlg.exec();
        }
 
 
        if (!(job.flags & KritaUtils::SaveIsExporting)) {
            const QString existingAutoSaveBaseName = localFilePath();
            const bool wasRecovered = isRecovered();
 
            d->updateDocumentMetadataOnSaving(job.filePath, job.mimeType);
 
            removeAutoSaveFiles(existingAutoSaveBaseName, wasRecovered);
        }
 
        Q_EMIT completed();
        Q_EMIT sigSavingFinished(job.filePath);
 
        Q_EMIT statusBarMessage(i18n("Finished saving %1", fileName), successMessageTimeout);
    }
}

References completed(), d, errorMessage(), KisImportExportErrorCode::errorMessage(), fileBatchMode(), KritaUtils::ExportFileJob::filePath, KritaUtils::ExportFileJob::flags, KisImportExportErrorCode::isCancelled(), KisImportExportErrorCode::isOk(), isRecovered, localFilePath(), KritaUtils::ExportFileJob::mimeType, removeAutoSaveFiles(), KritaUtils::SaveIsExporting, sigSavingFinished(), statusBarMessage(), and warningMessage().

◆ slotConfigChanged

void KisDocument::slotConfigChanged ( )

privateslot

Definition at line 2348 of file KisDocument.cpp.

{
    KisConfig cfg(true);
 
    if (d->undoStack->undoLimit() != cfg.undoStackLimit()) {
        if (!d->undoStack->isClean()) {
            d->undoStack->clear();
            // we set this because the document *has* changed, even though the
            // undo history was purged.
            setImageModifiedWithoutUndo();
        }
        d->undoStack->setUndoLimit(cfg.undoStackLimit());
    }
    d->undoStack->setUseCumulativeUndoRedo(cfg.useCumulativeUndoRedo());
    d->undoStack->setCumulativeUndoData(cfg.cumulativeUndoData());
 
    d->autoSaveDelay = cfg.autoSaveInterval();
    setNormalAutoSaveInterval();
}

References KisConfig::autoSaveInterval(), KisConfig::cumulativeUndoData(), d, setImageModifiedWithoutUndo(), setNormalAutoSaveInterval(), KisConfig::undoStackLimit(), and KisConfig::useCumulativeUndoRedo().

◆ slotDocumentCloningCancelled

void KisDocument::slotDocumentCloningCancelled ( )

privateslot

Definition at line 1669 of file KisDocument.cpp.

{
    setEmergencyAutoSaveInterval();
}

References setEmergencyAutoSaveInterval().

◆ slotImageRootChanged

void KisDocument::slotImageRootChanged ( )

privateslot

Definition at line 2368 of file KisDocument.cpp.

{
    d->syncDecorationsWrapperLayerState();
}

References d.

◆ slotInitiateAsyncAutosaving

void KisDocument::slotInitiateAsyncAutosaving ( KisDocument * clonedDocument )

privateslot

Definition at line 1664 of file KisDocument.cpp.

{
    slotAutoSaveImpl(std::unique_ptr<KisDocument>(clonedDocument));
}

References slotAutoSaveImpl().

◆ slotPerformIdleRoutines

void KisDocument::slotPerformIdleRoutines ( )

privateslot

TODO: automatic purging is disabled for now: it modifies data managers without creating a transaction, which breaks undo.

Definition at line 1674 of file KisDocument.cpp.

{
    d->image->explicitRegenerateLevelOfDetail();
 
    // d->image->purgeUnusedData(true);
}

References d.

◆ slotUndoStackCleanChanged

void KisDocument::slotUndoStackCleanChanged ( bool value )

privateslot

Definition at line 2343 of file KisDocument.cpp.

{
    setModified(!value || d->imageModifiedWithoutUndo);
}

References d, setModified(), and value().

◆ startExportInBackground()

KisImportExportErrorCode KisDocument::startExportInBackground	(	const QString &	actionName,
		const QString &	location,
		const QString &	realLocation,
		const QByteArray &	mimeType,
		bool	showWarnings,
		KisPropertiesConfigurationSP	exportConfiguration,
		bool	isAdvancedExporting = false )

private

Definition at line 1714 of file KisDocument.cpp.

{
    d->savingImage = d->image;
 
    KisMainWindow *window = KisPart::instance()->currentMainwindow();
    if (window) {
        if (window->viewManager()) {
            d->savingUpdater = window->viewManager()->createThreadedUpdater(actionName);
            d->importExportManager->setUpdater(d->savingUpdater);
        }
    }
 
    KisImportExportErrorCode initializationStatus(ImportExportCodes::OK);
    d->childSavingFuture =
            d->importExportManager->exportDocumentAsync(location,
                                                       realLocation,
                                                       mimeType,
                                                       initializationStatus,
                                                       showWarnings,
                                                       exportConfiguration,
                                                       isAdvancedExporting);
 
    if (!initializationStatus.isOk()) {
        if (d->savingUpdater) {
            d->savingUpdater->cancel();
        }
        d->savingImage.clear();
        Q_EMIT sigBackgroundSavingFinished(initializationStatus, initializationStatus.errorMessage(), "");
        return initializationStatus;
    }
 
    typedef QFutureWatcher<KisImportExportErrorCode> StatusWatcher;
    StatusWatcher *watcher = new StatusWatcher();
    watcher->setFuture(d->childSavingFuture);
 
    connect(watcher, SIGNAL(finished()), SLOT(finishExportInBackground()));
    connect(watcher, SIGNAL(finished()), watcher, SLOT(deleteLater()));
 
    return initializationStatus;
}

References KisViewManager::createThreadedUpdater(), KisPart::currentMainwindow(), d, KisImportExportErrorCode::errorMessage(), finishExportInBackground(), KisPart::instance(), KisImportExportErrorCode::isOk(), mimeType, ImportExportCodes::OK, sigBackgroundSavingFinished(), and KisMainWindow::viewManager.

◆ statusBarMessage

void KisDocument::statusBarMessage	(	const QString &	text,
		int	timeout = 0 )

signal

Emitted e.g. at the beginning of a save operation This is emitted by KisDocument and used by KisView to display a statusbar message

◆ syncDecorationsWrapperLayerState()

void KisDocument::syncDecorationsWrapperLayerState ( )

◆ undoStack()

KUndo2Stack * KisDocument::undoStack ( )

Returns the global undo stack

◆ unit()

KoUnit KisDocument::unit ( ) const

Returns the unit used to display all measures/distances.

◆ unitChanged

void KisDocument::unitChanged ( const KoUnit & unit )

signal

This signal is emitted when the unit is changed by setUnit(). It is common to connect views to it, in order to change the displayed units (e.g. in the rulers)

◆ updateDocumentMetadataOnSaving()

void KisDocument::updateDocumentMetadataOnSaving	(	const QString &	filePath,
		const QByteArray &	mimeType )

◆ updateEditingTime()

void KisDocument::updateEditingTime ( bool forceStoreElapsed )

Definition at line 2198 of file KisDocument.cpp.

{
    QDateTime now = QDateTime::currentDateTime();
    int firstModDelta = d->firstMod.secsTo(now);
    int lastModDelta = d->lastMod.secsTo(now);
 
    if (lastModDelta > 30) {
        d->docInfo->setAboutInfo("editing-time", QString::number(d->docInfo->aboutInfo("editing-time").toInt() + d->firstMod.secsTo(d->lastMod)));
        d->firstMod = now;
    } else if (firstModDelta > 60 || forceStoreElapsed) {
        d->docInfo->setAboutInfo("editing-time", QString::number(d->docInfo->aboutInfo("editing-time").toInt() + firstModDelta));
        d->firstMod = now;
    }
 
    d->lastMod = now;
}

References d.

◆ uploadLinkedResourcesFromLayersToStorage()

void KisDocument::uploadLinkedResourcesFromLayersToStorage ( )

◆ waitForSavingToComplete()

void KisDocument::waitForSavingToComplete ( )

Definition at line 2777 of file KisDocument.cpp.

{
    if (isSaving()) {
        KisAsyncActionFeedback f(i18nc("progress dialog message when the user closes the document that is being saved", "Waiting for saving to complete..."), 0);
        f.waitForMutex(d->savingMutex);
    }
}

References d, and isSaving().

◆ warningMessage()

QString KisDocument::warningMessage ( ) const

Return the last warning message set by loading or saving. Warnings mean that the document could not be completely loaded, but the errors were not absolutely fatal.

Definition at line 2282 of file KisDocument.cpp.

{
    return d->lastWarningMessage;
}

References d.

Friends And Related Symbol Documentation

◆ KisPart

friend class KisPart

friend

Definition at line 532 of file KisDocument.h.

◆ SafeSavingLocker

friend class SafeSavingLocker

friend

Definition at line 533 of file KisDocument.h.

Member Data Documentation

◆ assistants

QList< KisPaintingAssistantSP > KisDocument::assistants

Definition at line 392 of file KisDocument.cpp.

◆ audioLevel

qreal KisDocument::audioLevel = 1.0

Definition at line 398 of file KisDocument.cpp.

◆ audioTracks

QVector<QFileInfo> KisDocument::audioTracks

Definition at line 397 of file KisDocument.cpp.

◆ autoSaveActive

bool KisDocument::autoSaveActive = true

Definition at line 376 of file KisDocument.cpp.

◆ autoSaveDelay

int KisDocument::autoSaveDelay = 300

Definition at line 357 of file KisDocument.cpp.

◆ autoSaveFailureCount

int KisDocument::autoSaveFailureCount = 0

Definition at line 361 of file KisDocument.cpp.

◆ autoSaveTimer

QTimer* KisDocument::autoSaveTimer

Definition at line 353 of file KisDocument.cpp.

◆ backgroundSaveDocument

std::unique_ptr<KisDocument> KisDocument::backgroundSaveDocument

Definition at line 407 of file KisDocument.cpp.

◆ backgroundSaveJob

KritaUtils::ExportFileJob KisDocument::backgroundSaveJob

Definition at line 410 of file KisDocument.cpp.

◆ batchMode

bool KisDocument::batchMode { false }

Definition at line 416 of file KisDocument.cpp.

416{ false };

◆ childSavingFuture

QFuture<KisImportExportErrorCode> KisDocument::childSavingFuture

Definition at line 409 of file KisDocument.cpp.

◆ colorHistoryModel

KisUniqueColorSet * KisDocument::colorHistoryModel

Definition at line 401 of file KisDocument.cpp.

◆ completeSavingConnection

QMetaObject::Connection KisDocument::completeSavingConnection

Definition at line 411 of file KisDocument.cpp.

◆ d

Private* const KisDocument::d

private

Definition at line 765 of file KisDocument.h.

◆ decorationsSyncingDisabled

bool KisDocument::decorationsSyncingDisabled = false

Definition at line 417 of file KisDocument.cpp.

◆ disregardAutosaveFailure

bool KisDocument::disregardAutosaveFailure = false

Definition at line 360 of file KisDocument.cpp.

◆ docInfo

KoDocumentInfo* KisDocument::docInfo = 0

Definition at line 344 of file KisDocument.cpp.

◆ documentIsClosing

bool KisDocument::documentIsClosing = false

Definition at line 419 of file KisDocument.cpp.

◆ embeddedResourcesStorageID

QString KisDocument::embeddedResourcesStorageID

Definition at line 426 of file KisDocument.cpp.

◆ embeddedResourceStorage

KisResourceStorageSP KisDocument::embeddedResourceStorage

Definition at line 427 of file KisDocument.cpp.

◆ firstMod

QDateTime KisDocument::firstMod

Definition at line 378 of file KisDocument.cpp.

◆ globalAssistantsColor

QColor KisDocument::globalAssistantsColor

Definition at line 400 of file KisDocument.cpp.

◆ gridConfig

KisGridConfig KisDocument::gridConfig

Definition at line 403 of file KisDocument.cpp.

◆ guidesConfig

const KisGuidesConfig & KisDocument::guidesConfig

Definition at line 365 of file KisDocument.cpp.

◆ image

KisImageWSP KisDocument::image

Definition at line 383 of file KisDocument.cpp.

◆ imageIdleConnection

QScopedPointer<KisSignalAutoConnection> KisDocument::imageIdleConnection

Definition at line 390 of file KisDocument.cpp.

◆ imageIdleWatcher

KisIdleWatcher KisDocument::imageIdleWatcher

Definition at line 389 of file KisDocument.cpp.

◆ imageModifiedWithoutUndo

bool KisDocument::imageModifiedWithoutUndo = false

Definition at line 405 of file KisDocument.cpp.

◆ importExportManager

KisImportExportManager * KisDocument::importExportManager = 0

Definition at line 348 of file KisDocument.cpp.

◆ isAutosaving

bool KisDocument::isAutosaving = false

Definition at line 359 of file KisDocument.cpp.

◆ isRecovered

bool KisDocument::isRecovered = false

Definition at line 414 of file KisDocument.cpp.

◆ koShapeController

KoShapeController* KisDocument::koShapeController = 0

Definition at line 388 of file KisDocument.cpp.

◆ lastErrorMessage

QString KisDocument::lastErrorMessage

Definition at line 354 of file KisDocument.cpp.

◆ lastMod

QDateTime KisDocument::lastMod

Definition at line 379 of file KisDocument.cpp.

◆ lastWarningMessage

QString KisDocument::lastWarningMessage

Definition at line 355 of file KisDocument.cpp.

◆ linkedResourcesStorageID

QString KisDocument::linkedResourcesStorageID

Definition at line 422 of file KisDocument.cpp.

◆ linkedResourceStorage

KisResourceStorageSP KisDocument::linkedResourceStorage

Definition at line 423 of file KisDocument.cpp.

◆ m_bAutoDetectedMime

bool KisDocument::m_bAutoDetectedMime = false

Definition at line 368 of file KisDocument.cpp.

◆ m_file

QString KisDocument::m_file

Definition at line 370 of file KisDocument.cpp.

◆ m_path

QString KisDocument::m_path

Definition at line 369 of file KisDocument.cpp.

◆ m_storyboardCommentList

QVector<StoryboardComment> KisDocument::m_storyboardCommentList

Definition at line 395 of file KisDocument.cpp.

◆ m_storyboardItemList

StoryboardItemList KisDocument::m_storyboardItemList

Definition at line 394 of file KisDocument.cpp.

◆ mimeType

QByteArray KisDocument::mimeType

Definition at line 350 of file KisDocument.cpp.

◆ mirrorAxisConfig

const KisMirrorAxisConfig & KisDocument::mirrorAxisConfig

Definition at line 366 of file KisDocument.cpp.

◆ modified

bool KisDocument::modified = false

Definition at line 374 of file KisDocument.cpp.

◆ modifiedAfterAutosave

bool KisDocument::modifiedAfterAutosave = false

Definition at line 358 of file KisDocument.cpp.

◆ modifiedWhileSaving

bool KisDocument::modifiedWhileSaving = false

Definition at line 406 of file KisDocument.cpp.

◆ nserver

KisNameServer* KisDocument::nserver

Definition at line 381 of file KisDocument.cpp.

◆ outputMimeType

QByteArray KisDocument::outputMimeType

Definition at line 351 of file KisDocument.cpp.

◆ preActivatedNode

KisNodeSP KisDocument::preActivatedNode

Definition at line 386 of file KisDocument.cpp.

◆ q

KisDocument* KisDocument::q = 0

Definition at line 343 of file KisDocument.cpp.

◆ readwrite

bool KisDocument::readwrite = false

Definition at line 375 of file KisDocument.cpp.

◆ referenceLayerConnections

KisSignalAutoConnectionsStore KisDocument::referenceLayerConnections

Definition at line 412 of file KisDocument.cpp.

◆ savingImage

KisImageSP KisDocument::savingImage

Definition at line 384 of file KisDocument.cpp.

◆ savingMutex

QMutex KisDocument::savingMutex

Definition at line 372 of file KisDocument.cpp.

◆ savingUpdater

QPointer<KoUpdater> KisDocument::savingUpdater

Definition at line 408 of file KisDocument.cpp.

◆ shapeController

KoShapeControllerBase * KisDocument::shapeController = 0

Definition at line 387 of file KisDocument.cpp.

◆ undoStack

KUndo2Stack * KisDocument::undoStack = 0

Definition at line 363 of file KisDocument.cpp.

◆ unit

KoUnit KisDocument::unit

Definition at line 346 of file KisDocument.cpp.

◆ wasStorageAdded

bool KisDocument::wasStorageAdded = false

Definition at line 418 of file KisDocument.cpp.

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

libs/ui/KisDocument.cpp
libs/ui/KisDocument.h

Public Types

Signals

Public Member Functions

Static Public Member Functions

Public Attributes

Protected Member Functions

Private Types

Private Slots

Private Member Functions

Private Attributes

Friends

Detailed Description

Member Enumeration Documentation

◆ CopyPolicy

◆ OpenFlag

Constructor & Destructor Documentation

◆ ~Private()

◆ KisDocument() [1/2]

◆ KisDocument() [2/2]

◆ ~KisDocument()

Member Function Documentation

◆ assistants()

◆ assistantsGlobalColor()

◆ autoSaveOnPause()

◆ canceled

◆ caption()

◆ clearStatusBarMessage

◆ clearUndoHistory()

◆ clone()

◆ closePath()

◆ colorHistoryColors()

◆ colorHistoryModel()

◆ completed

◆ copyFrom()

◆ copyFromDocument()

◆ copyFromDocumentImpl()

◆ copyFromImpl()

◆ createDocumentInfoDialog()

◆ createDomDocument() [1/2]

◆ createDomDocument() [2/2]

◆ createUndoStore()

◆ documentBounds()

◆ documentInfo()

◆ embeddedResourcesStorageId()

◆ errorMessage()

◆ exportDocument()

◆ exportDocumentImpl()

◆ exportDocumentSync()

◆ exportErrorToUserMessage()

◆ extraNativeMimeTypes()

◆ fileBatchMode()

◆ finishExportInBackground

◆ generateAutoSaveFileName()

◆ generatePreview()

◆ getAudioLevel()

◆ getAudioTracks()

◆ getStoryboardCommentsList()

◆ getStoryboardItemList()

◆ gridConfig()

◆ guidesConfig()

◆ hackPreliminarySetImage()

◆ image()

◆ importDocument()

◆ importExportManager()

◆ initiateSavingInBackground() [1/2]

◆ initiateSavingInBackground() [2/2]

◆ isAutoSaveActive()

◆ isAutosaving()

◆ isInSaving()

◆ isModified()

◆ isNativeFormat()

◆ isReadWrite()

◆ isRecovered()

◆ isSaving()

◆ linkedDocumentResources()

◆ linkedResourcesStorageId()

◆ loadNativeFormat()

◆ localFilePath()

◆ lockAndCloneForSaving()

◆ lockAndCloneImpl()