#include <kis_image.h>

Inheritance diagram for KisImage:

Classes
class	KisImagePrivate

Public Slots
void	explicitRegenerateLevelOfDetail ()

KisImageGlobalSelectionManagementInterface *	globalSelectionManagementInterface () const

void	requestRedoDuringStroke ()

void	requestStrokeCancellation ()

void	requestStrokeEnd ()

void	requestStrokeEndActiveNode ()

void	requestUndoDuringStroke ()

void	stopIsolatedMode ()

UndoResult	tryUndoUnfinishedLod0Stroke ()

Signals
void	sigAboutToBeDeleted ()

void	sigColorSpaceChanged (const KoColorSpace *cs)

void	sigImageModified ()

void	sigImageModifiedWithoutUndo ()

void	sigImageUpdated (const QRect &)

void	sigInternalStopIsolatedModeRequested ()

void	sigIsolatedModeChanged ()

void	sigLayersChangedAsync ()

void	sigNodeAddedAsync (KisNodeSP node, KisNodeAdditionFlags flags)

void	sigNodeChanged (KisNodeSP node)

void	sigNodeCollapsedChanged ()

void	sigProfileChanged (const KoColorProfile *profile)

void	sigProofingConfigChanged ()

void	sigRedoDuringStrokeRequested ()

void	sigRemoveNodeAsync (KisNodeSP node)

void	sigRequestNodeReselection (KisNodeSP activeNode, const KisNodeList &selectedNodes)

void	sigResolutionChanged (double xRes, double yRes)

void	sigSizeChanged (const QPointF &oldStillPoint, const QPointF &newStillPoint)

void	sigStrokeCancellationRequested ()

void	sigStrokeEndRequested ()

void	sigStrokeEndRequestedActiveNodeFiltered ()

void	sigUndoDuringStrokeRequested ()

Public Member Functions
void	aboutToAddANode (KisNode *parent, int index) override

void	aboutToRemoveANode (KisNode *parent, int index) override

void	addAnnotation (KisAnnotationSP annotation)

void	addComposition (KisLayerCompositionSP composition)

void	addJob (KisStrokeId id, KisStrokeJobData *data) override

KisProjectionUpdatesFilterCookie	addProjectionUpdatesFilter (KisProjectionUpdatesFilterSP filter) override

void	addSpontaneousJob (KisSpontaneousJob *spontaneousJob)

bool	allowMasksOnRootNode () const

KisImageAnimationInterface *	animationInterface () const

KisAnnotationSP	annotation (const QString &type)

bool	assignImageProfile (const KoColorProfile *profile, bool blockAllUpdates=false)

bool	assignLayerProfile (KisNodeSP node, const KoColorProfile *profile)

void	barrierLock (bool readOnly=false)
	Wait until all the queued background jobs are completed and lock the image.

vKisAnnotationSP_it	beginAnnotations ()

void	blockUpdates () override
	blockUpdates block updating the image projection

QRect	bounds () const override

bool	cancelStroke (KisStrokeId id) override

bool	canReselectGlobalSelection ()

KisImage *	clone (bool exactCopy=false)

const KoColorSpace *	colorSpace () const

KisCompositeProgressProxy *	compositeProgressProxy ()

QList< KisLayerCompositionSP >	compositions ()

void	convertImageColorSpace (const KoColorSpace *dstColorSpace, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags)

void	convertImageProjectionColorSpace (const KoColorSpace *dstColorSpace)

void	convertLayerColorSpace (KisNodeSP node, const KoColorSpace *dstColorSpace, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags)

QImage	convertToQImage (const QSize &scaledImageSize, const KoColorProfile *profile)

QImage	convertToQImage (qint32 x1, qint32 y1, qint32 width, qint32 height, const KoColorProfile *profile)

QImage	convertToQImage (QRect imageRect, const KoColorProfile *profile)

void	copyFromImage (const KisImage &rhs)

void	cropImage (const QRect &newRect)
	start asynchronous operation on cropping the image

void	cropNode (KisNodeSP node, const QRect &newRect, const bool activeFrameOnly=false)
	start asynchronous operation on cropping a subtree of nodes starting at `node`

void	cropNodes (KisNodeList nodes, const QRect &newRect, const bool activeFrameOnly=false)

int	currentLevelOfDetail () const

KisProjectionUpdatesFilterCookie	currentProjectionUpdatesFilter () const override

KoColor	defaultProjectionColor () const

void	disableDirtyRequests () override

void	disableUIUpdates () override

QPoint	documentToImagePixelFloored (const QPointF &documentCoord) const

QPointF	documentToPixel (const QPointF &documentCoord) const

QRectF	documentToPixel (const QRectF &documentRect) const

QRect	effectiveLodBounds () const

void	enableDirtyRequests () override

QVector< QRect >	enableUIUpdates () override

vKisAnnotationSP_it	endAnnotations ()

void	endStroke (KisStrokeId id) override

void	flatten (KisNodeSP activeNode)

void	flattenLayer (KisLayerSP layer)

KisSelectionSP	globalSelection () const

KisNode *	graphOverlayNode () const override

bool	hasOverlaySelectionMask () const

bool	hasUpdatesRunning () const override

qint32	height () const

void	immediateLockForReadOnly ()

void	initialRefreshGraph ()

void	invalidateAllFrames () override

void	invalidateFrames (const KisTimeSpan &range, const QRect &rect) override

bool	isIdle (bool allowLocked=false)

bool	isIsolatingGroup () const

bool	isIsolatingLayer () const

KisNodeSP	isolationRootNode () const

void	keyframeChannelAboutToBeRemoved (KisNode node, KisKeyframeChannel channel) override

void	keyframeChannelHasBeenAdded (KisNode node, KisKeyframeChannel channel) override

	KisImage (KisUndoStore undoStore, qint32 width, qint32 height, const KoColorSpace colorSpace, const QString &name)
	`colorSpace` can be null. In that case, it will be initialised to a default color space.

const KUndo2Command *	lastExecutedCommand () const override

bool	locked () const

KisLodPreferences	lodPreferences () const

void	mergeDown (KisLayerSP l, const KisMetaData::MergeStrategy *strategy)

void	mergeMultipleLayers (QList< KisNodeSP > mergedLayers, KisNodeSP putAfter)

QPointF	mirrorAxesCenter () const

void	moveCompositionDown (KisLayerCompositionSP composition)

void	moveCompositionUp (KisLayerCompositionSP composition)

qint32	nChildLayers () const

QString	nextLayerName (const QString &baseName="") const

qint32	nHiddenLayers () const

qint32	nlayers () const

void	nodeChanged (KisNode *node) override

void	nodeCollapsedChanged (KisNode *node) override

void	nodeHasBeenAdded (KisNode *parent, int index, KisNodeAdditionFlags flags) override

void	notifyAboutToBeDeleted ()

void	notifyBatchUpdateEnded () override

void	notifyBatchUpdateStarted () override

void	notifyLayersChanged ()
	use if the layers have changed completely (eg. when flattening)

void	notifyProjectionUpdated (const QRect &rc) override

void	notifySelectionChanged () override

void	notifyUIUpdateCompleted (const QRect &rc) override

KisSelectionMaskSP	overlaySelectionMask () const

QPointF	pixelToDocument (const QPoint &pixelCoord) const

QPointF	pixelToDocument (const QPointF &pixelCoord) const

QRectF	pixelToDocument (const QRectF &pixelCoord) const

KisPostExecutionUndoAdapter *	postExecutionUndoAdapter () const override

const KoColorProfile *	profile () const

KisPaintDeviceSP	projection () const

KisProofingConfigurationSP	proofingConfiguration () const
	proofingConfiguration

void	purgeUnusedData (bool isCancellable)
	purge all pixels that have default pixel to free up memory

void	refreshGraphAsync (KisNodeSP root, const QRect &rc, const QRect &cropRect, KisProjectionUpdateFlags flags=KisProjectionUpdateFlag::None)

void	refreshGraphAsync (KisNodeSP root, const QRect &rc, KisProjectionUpdateFlags flags=KisProjectionUpdateFlag::None)

virtual void	refreshGraphAsync (KisNodeSP root, const QVector< QRect > &rc, const QRect &cropRect, KisProjectionUpdateFlags flags=KisProjectionUpdateFlag::None)=0

void	refreshGraphAsync (KisNodeSP root, const QVector< QRect > &rects, const QRect &cropRect, KisProjectionUpdateFlags flags=KisProjectionUpdateFlag::None) override

void	refreshGraphAsync (KisNodeSP root=nullptr, KisProjectionUpdateFlags flags=KisProjectionUpdateFlag::None)

void	removeAnnotation (const QString &type)

void	removeComposition (KisLayerCompositionSP composition)

KisProjectionUpdatesFilterSP	removeProjectionUpdatesFilter (KisProjectionUpdatesFilterCookie cookie) override
	removes already installed filter from the stack of updates filers

void	requestProjectionUpdate (KisNode *node, const QVector< QRect > &rects, KisProjectionUpdateFlags flags) override

void	requestTimeSwitch (int time) override

void	resizeImage (const QRect &newRect)
	start asynchronous operation on resizing the image

KisGroupLayerSP	rootLayer () const

void	rotateImage (double radians)
	start asynchronous operation on rotating the image

void	rotateNode (KisNodeSP node, double radians, KisSelectionSP selection)
	start asynchronous operation on rotating a subtree of nodes starting at `node`

void	rotateNodes (KisNodeList nodes, double radians, KisSelectionSP selection)

void	scaleImage (const QSize &size, qreal xres, qreal yres, KisFilterStrategy *filterStrategy)
	start asynchronous operation on scaling the image

void	scaleNode (KisNodeSP node, const QPointF &center, qreal scaleX, qreal scaleY, KisFilterStrategy *filterStrategy, KisSelectionSP selection)
	start asynchronous operation on scaling a subtree of nodes starting at `node`

void	scaleNodes (KisNodeList nodes, const QPointF &center, qreal scaleX, qreal scaleY, KisFilterStrategy *filterStrategy, KisSelectionSP selection)

void	setAllowMasksOnRootNode (bool value)

void	setDefaultProjectionColor (const KoColor &color)

void	setLodPreferences (const KisLodPreferences &value)

void	setMirrorAxesCenter (const QPointF &value) const

void	setModifiedWithoutUndo ()

void	setOverlaySelectionMask (KisSelectionMaskSP mask)

void	setProofingConfiguration (KisProofingConfigurationSP proofingConfig)
	setProofingConfiguration, this sets the image's proofing configuration, and signals the proofingConfiguration has changed.

void	setResolution (double xres, double yres)

void	setRootLayer (KisGroupLayerSP rootLayer)

void	setUndoStore (KisUndoStore *undoStore)

void	setWorkingThreadsLimit (int value)

void	setWrapAroundModeAxis (WrapAroundAxis value)

void	setWrapAroundModePermitted (bool value)

void	shear (double angleX, double angleY)
	start asynchronous operation on shearing the image

void	shearNode (KisNodeSP node, double angleX, double angleY, KisSelectionSP selection)
	start asynchronous operation on shearing a subtree of nodes starting at `node`

void	shearNodes (KisNodeList nodes, double angleX, double angleY, KisSelectionSP selection)

KisImageSignalRouter *	signalRouter ()

QSize	size () const

bool	startIsolatedMode (KisNodeSP node, bool isolateLayer, bool isolateGroup)

KisStrokeId	startStroke (KisStrokeStrategy *strokeStrategy) override

bool	tryBarrierLock (bool readOnly=false)
	Tries to lock the image without waiting for the jobs to finish.

void	unblockUpdates () override
	unblockUpdates unblock updating the image project. This only restarts the scheduler and does not schedule a full refresh.

KisUndoAdapter *	undoAdapter () const

KisUndoStore *	undoStore ()

void	unifyLayersColorSpace ()

void	unlock ()

void	waitForDone ()

qint32	width () const

int	workingThreadsLimit () const

bool	wrapAroundModeActive () const

WrapAroundAxis	wrapAroundModeAxis () const

bool	wrapAroundModePermitted () const

double	xRes () const

double	yRes () const

	~KisImage () override

Public Member Functions inherited from KisStrokesFacade
virtual	~KisStrokesFacade ()

Public Member Functions inherited from KisStrokeUndoFacade
virtual	~KisStrokeUndoFacade ()

Public Member Functions inherited from KisUpdatesFacade
void	refreshGraphAsync (KisNodeSP root, const QRect &rc, const QRect &cropRect, KisProjectionUpdateFlags flags=KisProjectionUpdateFlag::None)

void	refreshGraphAsync (KisNodeSP root, const QRect &rc, KisProjectionUpdateFlags flags=KisProjectionUpdateFlag::None)

void	refreshGraphAsync (KisNodeSP root=nullptr, KisProjectionUpdateFlags flags=KisProjectionUpdateFlag::None)

virtual	~KisUpdatesFacade ()

Public Member Functions inherited from KisProjectionUpdateListener
virtual	~KisProjectionUpdateListener ()

Public Member Functions inherited from KisNodeFacade
bool	addNode (KisNodeSP node, KisNodeSP parent, KisNodeSP aboveThis, KisNodeAdditionFlags flags=KisNodeAdditionFlag::None)

bool	addNode (KisNodeSP node, KisNodeSP parent, quint32 index, KisNodeAdditionFlags flags=KisNodeAdditionFlag::None)

bool	addNode (KisNodeSP node, KisNodeSP parent=KisNodeSP(), KisNodeAdditionFlags flags=KisNodeAdditionFlag::None)

	KisNodeFacade ()

	KisNodeFacade (KisNodeSP root)

bool	moveNode (KisNodeSP node, KisNodeSP parent, KisNodeSP aboveThis)

bool	moveNode (KisNodeSP node, KisNodeSP parent, quint32 index)

bool	removeNode (KisNodeSP node)

const KisNodeSP	root () const

void	setRoot (KisNodeSP root)

virtual	~KisNodeFacade ()

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

Public Member Functions inherited from KisNodeGraphListener
virtual void	aboutToMoveNode (KisNode *node, int oldIndex, int newIndex)

int	graphSequenceNumber () const

	KisNodeGraphListener ()

virtual void	nodeHasBeenMoved (KisNode *node, int oldIndex, int newIndex)

virtual void	nodeHasBeenRemoved (KisNode *parent, int index)

	Private ()

virtual	~KisNodeGraphListener ()

Public Member Functions inherited from KisShared
bool	deref ()

bool	ref ()

int	refCount ()

QAtomicInt *	sharedWeakReference ()

Static Public Member Functions
static KisImageSP	fromQImage (const QImage &image, KisUndoStore *undoStore)

Private Types
enum	CopyPolicy { CONSTRUCT = 1 , REPLACE = 2 , EXACT_COPY = 4 }

Private Member Functions
void	copyFromImageImpl (const KisImage &rhs, int policy)

void	emitSizeChanged ()

	KisImage (const KisImage &rhs, KisUndoStore *undoStore, bool exactCopy)

KisImage &	operator= (const KisImage &rhs)

void	refreshHiddenArea (KisNodeSP rootNode, const QRect &preparedArea)

void	resizeImageImpl (const QRect &newRect, bool cropLayers)

void	rotateImpl (const KUndo2MagicString &actionName, KisNodeList nodes, double radians, bool resizeImage, KisSelectionSP selection)

void	rotateImpl (const KUndo2MagicString &actionName, KisNodeSP rootNode, double radians, bool resizeImage, KisSelectionSP selection)

void	safeRemoveTwoNodes (KisNodeSP node1, KisNodeSP node2)

void	setProjectionColorSpace (const KoColorSpace *colorSpace)

void	setSize (const QSize &size)

void	shearImpl (const KUndo2MagicString &actionName, KisNodeList nodes, bool resizeImage, double angleX, double angleY, KisSelectionSP selection)

void	shearImpl (const KUndo2MagicString &actionName, KisNodeSP rootNode, bool resizeImage, double angleX, double angleY, KisSelectionSP selection)

Private Attributes
KisImagePrivate *	m_d

Friends
class	KisImageGlobalSelectionManagementInterface

class	KisImageResizeCommand

Additional Inherited Members
Public Attributes inherited from KisNodeFacade
KisNodeWSP	root

Public Attributes inherited from Private
KisCanvas2 *	canvas

int	displayedFrame

int	intendedFrame

Public Attributes inherited from KisNodeGraphListener
int	sequenceNumber

Protected Member Functions inherited from KisShared
	KisShared ()

	~KisShared ()

Detailed Description

This is the image class, it contains a tree of KisLayer stack and meta information about the image. And it also provides some functions to manipulate the whole image.

Definition at line 56 of file kis_image.h.

Member Enumeration Documentation

◆ CopyPolicy

enum KisImage::CopyPolicy

private

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

Definition at line 124 of file kis_image.h.

                    {
        CONSTRUCT = 1, 
        REPLACE = 2, 
        EXACT_COPY = 4, 
    };

Constructor & Destructor Documentation

◆ KisImage() [1/2]

KisImage::KisImage	(	KisUndoStore *	undoStore,
		qint32	width,
		qint32	height,
		const KoColorSpace *	colorSpace,
		const QString &	name )

colorSpace can be null. In that case, it will be initialised to a default color space.

Definition at line 315 of file kis_image.cc.

        : QObject(0)
        , KisShared()
        , m_d(new KisImagePrivate(this, width, height,
                                  colorSpace, undoStore,
                                  new KisImageAnimationInterface(this)))
{
    // make sure KisImage belongs to the GUI thread
    moveToThread(qApp->thread());
    connect(this, SIGNAL(sigInternalStopIsolatedModeRequested()), SLOT(stopIsolatedMode()));
 
    setObjectName(name);
    setRootLayer(new KisGroupLayer(this, "root", OPACITY_OPAQUE_U8));
}

References OPACITY_OPAQUE_U8, setRootLayer(), sigInternalStopIsolatedModeRequested(), and stopIsolatedMode().

◆ ~KisImage()

KisImage::~KisImage ( )

override

Request the tools to end currently running strokes

Definition at line 330 of file kis_image.cc.

{
    waitForDone();
 
    delete m_d;
    disconnect(); // in case Qt gets confused
}

References m_d, and waitForDone().

◆ KisImage() [2/2]

KisImage::KisImage	(	const KisImage &	rhs,
		KisUndoStore *	undoStore,
		bool	exactCopy )

private

Definition at line 565 of file kis_image.cc.

    : KisNodeFacade(),
      KisNodeGraphListener(),
      KisShared(),
      m_d(new KisImagePrivate(this,
                              rhs.width(), rhs.height(),
                              rhs.colorSpace(),
                              undoStore ? undoStore : new KisDumbUndoStore(),
                              new KisImageAnimationInterface(*rhs.animationInterface(), this)))
{
    // make sure KisImage belongs to the GUI thread
    moveToThread(qApp->thread());
    connect(this, SIGNAL(sigInternalStopIsolatedModeRequested()), SLOT(stopIsolatedMode()));
 
    copyFromImageImpl(rhs, CONSTRUCT | (exactCopy ? EXACT_COPY : 0));
}

References CONSTRUCT, copyFromImageImpl(), EXACT_COPY, sigInternalStopIsolatedModeRequested(), and stopIsolatedMode().

Member Function Documentation

◆ aboutToAddANode()

void KisImage::aboutToAddANode	(	KisNode *	parent,
		int	index )

overridevirtual

Inform the model that we're going to add a node.

Reimplemented from KisNodeGraphListener.

Definition at line 582 of file kis_image.cc.

{
    KisNodeGraphListener::aboutToAddANode(parent, index);
    SANITY_CHECK_LOCKED("aboutToAddANode");
}

References KisNodeGraphListener::aboutToAddANode(), and SANITY_CHECK_LOCKED.

◆ aboutToRemoveANode()

void KisImage::aboutToRemoveANode	(	KisNode *	parent,
		int	index )

overridevirtual

Inform the model we're going to remove a node.

Reimplemented from KisNodeGraphListener.

Definition at line 604 of file kis_image.cc.

{
    KisNodeSP deletedNode = parent->at(index);
    if (!dynamic_cast<KisSelectionMask*>(deletedNode.data()) &&
        deletedNode == m_d->isolationRootNode) {
 
        Q_EMIT sigInternalStopIsolatedModeRequested();
    }
 
    KisLayerUtils::recursiveApplyNodes(KisSharedPtr<KisNode>(parent), [this](KisNodeSP node){
       QMap<QString, KisKeyframeChannel*> chans = node->keyframeChannels();
       Q_FOREACH(KisKeyframeChannel* chan, chans.values()) {
           this->keyframeChannelAboutToBeRemoved(node.data(), chan);
       }
    });
 
    KisNodeGraphListener::aboutToRemoveANode(parent, index);
 
    SANITY_CHECK_LOCKED("aboutToRemoveANode");
    m_d->signalRouter.emitAboutToRemoveANode(parent, index);
}

References KisNodeGraphListener::aboutToRemoveANode(), KisSharedPtr< T >::data(), KisImageSignalRouter::emitAboutToRemoveANode(), KisImage::KisImagePrivate::isolationRootNode, keyframeChannelAboutToBeRemoved(), KisBaseNode::keyframeChannels, m_d, KisLayerUtils::recursiveApplyNodes(), SANITY_CHECK_LOCKED, sigInternalStopIsolatedModeRequested(), and KisImage::KisImagePrivate::signalRouter.

◆ addAnnotation()

void KisImage::addAnnotation ( KisAnnotationSP annotation )

Add an annotation for this image. This can be anything: Gamma, EXIF, etc. Note that the "icc" annotation is reserved for the color strategies. If the annotation already exists, overwrite it with this one.

Definition at line 1889 of file kis_image.cc.

{
    // Find the icc annotation, if there is one
    vKisAnnotationSP_it it = m_d->annotations.begin();
    while (it != m_d->annotations.end()) {
        if ((*it)->type() == annotation->type()) {
            *it = annotation;
            setModifiedWithoutUndo();
            return;
        }
        ++it;
    }
    m_d->annotations.push_back(annotation);
    setModifiedWithoutUndo();
}

References annotation(), KisImage::KisImagePrivate::annotations, m_d, and setModifiedWithoutUndo().

◆ addComposition()

void KisImage::addComposition ( KisLayerCompositionSP composition )

Adds a new layer composition, will be saved with the image

Definition at line 2507 of file kis_image.cc.

{
    m_d->compositions.append(composition);
}

References KisImage::KisImagePrivate::compositions, and m_d.

◆ addJob()

void KisImage::addJob	(	KisStrokeId	id,
		KisStrokeJobData *	data )

overridevirtual

Implements KisStrokesFacade.

Definition at line 2156 of file kis_image.cc.

{
    KisUpdateTimeMonitor::instance()->reportJobStarted(data);
    m_d->scheduler.addJob(id, data);
}

References KisUpdateScheduler::addJob(), KisUpdateTimeMonitor::instance(), m_d, KisUpdateTimeMonitor::reportJobStarted(), and KisImage::KisImagePrivate::scheduler.

◆ addProjectionUpdatesFilter()

KisProjectionUpdatesFilterCookie KisImage::addProjectionUpdatesFilter ( KisProjectionUpdatesFilterSP filter )

overridevirtual

Installs a filter object that will filter all the incoming projection update requests. If the filter return true, the incoming update is dropped.

NOTE: you can add multiple filters to the image, but the calls to add/remove must be nested and balanced. E.g.

auto cookie1 = image->addProjectionUpdatesFilter(filter1);
auto cookie2 = image->addProjectionUpdatesFilter(filter2);
 
 
image->removeProjectionUpdatesFilter(cookie2)
image->removeProjectionUpdatesFilter(cookie1)
 
// image->removeProjectionUpdatesFilter(cookie1)
// image->removeProjectionUpdatesFilter(cookie2)

Implements KisUpdatesFacade.

Definition at line 2289 of file kis_image.cc.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(filter, KisProjectionUpdatesFilterCookie());
 
    m_d->projectionUpdatesFilters.append(filter);
 
    return KisProjectionUpdatesFilterCookie(filter.data());
}

References KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, m_d, and KisImage::KisImagePrivate::projectionUpdatesFilters.

◆ addSpontaneousJob()

void KisImage::addSpontaneousJob ( KisSpontaneousJob * spontaneousJob )

Adds a spontaneous job to the updates queue.

A spontaneous job may do some trivial tasks in the background, like updating the outline of selection or purging unused tiles from the existing paint devices.

Definition at line 2279 of file kis_image.cc.

{
    m_d->scheduler.addSpontaneousJob(spontaneousJob);
}

References KisUpdateScheduler::addSpontaneousJob(), m_d, and KisImage::KisImagePrivate::scheduler.

◆ allowMasksOnRootNode()

bool KisImage::allowMasksOnRootNode ( ) const

See also: setAllowMasksOnRootNode()

Definition at line 2676 of file kis_image.cc.

{
    return m_d->allowMasksOnRootNode;
}

References KisImage::KisImagePrivate::allowMasksOnRootNode, and m_d.

◆ animationInterface()

KisImageAnimationInterface * KisImage::animationInterface ( ) const

Definition at line 2634 of file kis_image.cc.

{
    return m_d->animationInterface;
}

References KisImage::KisImagePrivate::animationInterface, and m_d.

◆ annotation()

KisAnnotationSP KisImage::annotation ( const QString & type )

get the annotation with the given type, can return 0

Definition at line 1905 of file kis_image.cc.

{
    vKisAnnotationSP_it it = m_d->annotations.begin();
    while (it != m_d->annotations.end()) {
        if ((*it) && (*it)->type() == type) {
            return *it;
        }
        else if (!*it) {
            qWarning() << "Skipping deleted annotation";
        }
        ++it;
    }
    return KisAnnotationSP(0);
}

References KisImage::KisImagePrivate::annotations, and m_d.

◆ assignImageProfile()

bool KisImage::assignImageProfile	(	const KoColorProfile *	profile,
		bool	blockAllUpdates = false )

Set the profile of the image to the new profile and do the same for all layers that have the same colorspace and profile of the image. It doesn't do any pixel conversion.

This is essential if you have loaded an image that didn't have an embedded profile to which you want to attach the right profile.

Returns: false if the profile could not be assigned

Definition at line 1518 of file kis_image.cc.

{
    if (!profile) return false;
 
    const KoColorSpace *srcColorSpace = m_d->colorSpace;
    bool imageProfileIsSame = *srcColorSpace->profile() == *profile;
 
    imageProfileIsSame &=
        !KisLayerUtils::recursiveFindNode(m_d->rootLayer,
            [profile] (KisNodeSP node) {
                return *node->colorSpace()->profile() != *profile;
            });
 
    if (imageProfileIsSame) {
        dbgImage << "Trying to set the same image profile again" << ppVar(srcColorSpace->profile()->name()) << ppVar(profile->name());
        return true;
    }
 
    KUndo2MagicString actionName = kundo2_i18n("Assign Profile");
 
    KisImageSignalVector emitSignals;
    emitSignals << ProfileChangedSignal;
 
    const KoColorSpace *dstColorSpace = KoColorSpaceRegistry::instance()->colorSpace(colorSpace()->colorModelId().id(), colorSpace()->colorDepthId().id(), profile);
    if (!dstColorSpace) return false;
 
    KisProcessingApplicator applicator(this, m_d->rootLayer,
                                       KisProcessingApplicator::RECURSIVE |
                                       (!blockAllUpdates ?
                                            KisProcessingApplicator::NO_UI_UPDATES :
                                            KisProcessingApplicator::NO_IMAGE_UPDATES),
                                       emitSignals, actionName);
 
    applicator.applyCommand(
        new KisImagePrivate::SetImageProjectionColorSpace(dstColorSpace,
                                                          KisImageWSP(this),
                                                          KisCommandUtils::FlipFlopCommand::INITIALIZING),
        KisStrokeJobData::BARRIER);
 
    applicator.applyVisitor(
        new KisAssignProfileProcessingVisitor(
            srcColorSpace, dstColorSpace),
        KisStrokeJobData::CONCURRENT);
 
    applicator.applyCommand(
        new KisImagePrivate::SetImageProjectionColorSpace(srcColorSpace,
                                                          KisImageWSP(this),
                                                          KisCommandUtils::FlipFlopCommand::FINALIZING),
        KisStrokeJobData::BARRIER);
 
 
    applicator.end();
 
    return true;
}

References KisProcessingApplicator::applyCommand(), KisProcessingApplicator::applyVisitor(), KisStrokeJobData::BARRIER, KisImage::KisImagePrivate::colorSpace, colorSpace(), KoColorSpaceRegistry::colorSpace(), KisStrokeJobData::CONCURRENT, dbgImage, KisProcessingApplicator::end(), KisCommandUtils::FlipFlopCommand::FINALIZING, KisCommandUtils::FlipFlopCommand::INITIALIZING, KoColorSpaceRegistry::instance(), kundo2_i18n(), m_d, KoColorProfile::name, KisProcessingApplicator::NO_IMAGE_UPDATES, KisProcessingApplicator::NO_UI_UPDATES, ppVar, profile(), KoColorSpace::profile(), ProfileChangedSignal, KisProcessingApplicator::RECURSIVE, KisLayerUtils::recursiveFindNode(), and KisImage::KisImagePrivate::rootLayer.

◆ assignLayerProfile()

bool KisImage::assignLayerProfile	(	KisNodeSP	node,
		const KoColorProfile *	profile )

Set the profile of the layer and all its children to the new profile. It doesn't do any pixel conversion.

This is essential if you have loaded an image that didn't have an embedded profile to which you want to attach the right profile.

Returns: false if the profile could not be assigned

Definition at line 1488 of file kis_image.cc.

{
    const KoColorSpace *srcColorSpace = node->colorSpace();
 
    if (!node->projectionLeaf()->isLayer()) return false;
    if (!profile || *srcColorSpace->profile() == *profile) return false;
 
    KUndo2MagicString actionName = kundo2_i18n("Assign Profile to Layer");
 
    KisImageSignalVector emitSignals;
 
    const KoColorSpace *dstColorSpace = KoColorSpaceRegistry::instance()->colorSpace(colorSpace()->colorModelId().id(), colorSpace()->colorDepthId().id(), profile);
    if (!dstColorSpace) return false;
 
    KisProcessingApplicator applicator(this, node,
                                       KisProcessingApplicator::RECURSIVE |
                                       KisProcessingApplicator::NO_UI_UPDATES,
                                       emitSignals, actionName);
 
    applicator.applyVisitor(
        new KisAssignProfileProcessingVisitor(
            srcColorSpace, dstColorSpace),
        KisStrokeJobData::CONCURRENT);
 
    applicator.end();
 
    return true;
}

References KisProcessingApplicator::applyVisitor(), colorSpace(), KisBaseNode::colorSpace(), KoColorSpaceRegistry::colorSpace(), KisStrokeJobData::CONCURRENT, KisProcessingApplicator::end(), KoColorSpaceRegistry::instance(), kundo2_i18n(), KisProcessingApplicator::NO_UI_UPDATES, profile(), KoColorSpace::profile(), KisNode::projectionLeaf, and KisProcessingApplicator::RECURSIVE.

◆ barrierLock()

void KisImage::barrierLock ( bool readOnly = false )

Wait until all the queued background jobs are completed and lock the image.

KisImage object has a local scheduler that executes long-running image rendering/modifying jobs (we call them "strokes") in a background. Basically, one should either access the image from the scope of such jobs (strokes) or just lock the image before using.

Calling barrierLock() will wait until all the queued operations are finished and lock the image, so you can start accessing it in a safe way.

readOnly tells the image if the caller is going to modify the image during holding the lock. Locking with non-readOnly access will reset all the internal caches of the image (lod-planes) when the lock status will be lifted.

Definition at line 756 of file kis_image.cc.

{
    if (!locked()) {
        requestStrokeEnd();
        KisBusyWaitBroker::instance()->notifyWaitOnImageStarted(this);
        m_d->scheduler.barrierLock();
        KisBusyWaitBroker::instance()->notifyWaitOnImageEnded(this);
        m_d->lockedForReadOnly = readOnly;
    } else {
        m_d->lockedForReadOnly &= readOnly;
    }
 
    m_d->lockCount++;
}

References KisUpdateScheduler::barrierLock(), KisBusyWaitBroker::instance(), KisImage::KisImagePrivate::lockCount, locked(), KisImage::KisImagePrivate::lockedForReadOnly, m_d, KisBusyWaitBroker::notifyWaitOnImageEnded(), KisBusyWaitBroker::notifyWaitOnImageStarted(), requestStrokeEnd(), and KisImage::KisImagePrivate::scheduler.

◆ beginAnnotations()

vKisAnnotationSP_it KisImage::beginAnnotations ( )

Start of an iteration over the annotations of this image (including the ICC Profile)

Definition at line 1933 of file kis_image.cc.

{
    return m_d->annotations.begin();
}

References KisImage::KisImagePrivate::annotations, and m_d.

◆ blockUpdates()

void KisImage::blockUpdates ( )

overridevirtual

blockUpdates block updating the image projection

Implements KisUpdatesFacade.

Definition at line 818 of file kis_image.cc.

{
    m_d->scheduler.blockUpdates();
}

References KisUpdateScheduler::blockUpdates(), m_d, and KisImage::KisImagePrivate::scheduler.

◆ bounds()

QRect KisImage::bounds ( ) const

overridevirtual

Returns: the exact bounds of the image in pixel coordinates.

Implements KisUpdatesFacade.

Definition at line 1797 of file kis_image.cc.

{
    return QRect(0, 0, width(), height());
}

References height(), and width().

◆ cancelStroke()

bool KisImage::cancelStroke ( KisStrokeId id )

overridevirtual

Implements KisStrokesFacade.

Definition at line 2167 of file kis_image.cc.

{
    return m_d->scheduler.cancelStroke(id);
}

References KisUpdateScheduler::cancelStroke(), m_d, and KisImage::KisImagePrivate::scheduler.

◆ canReselectGlobalSelection()

bool KisImage::canReselectGlobalSelection ( )

Returns whether we can reselect current global selection

See also: reselectGlobalSelection()

Definition at line 705 of file kis_image.cc.

{
    return m_d->deselectedGlobalSelectionMask;
}

References KisImage::KisImagePrivate::deselectedGlobalSelectionMask, and m_d.

◆ clone()

KisImage * KisImage::clone ( bool exactCopy = false )

Makes a copy of the image with all the layers. If possible, shallow copies of the layers are made.

exactCopy shows if the copied image should look exactly the same as the other one (according to it's .kra xml representation). It means that the layers will have the same UUID keys and, therefore, you are not expected to use the copied image anywhere except for saving. Don't use this option if you plan to work with the copied image later.

Definition at line 405 of file kis_image.cc.

{
    return new KisImage(*this, 0, exactCopy);
}

References KisImage().

◆ colorSpace()

const KoColorSpace * KisImage::colorSpace ( ) const

The default colorspace of this image: new layers will have this colorspace and the projection will have this colorspace.

Definition at line 1579 of file kis_image.cc.

{
    return m_d->colorSpace;
}

References KisImage::KisImagePrivate::colorSpace, and m_d.

◆ compositeProgressProxy()

KisCompositeProgressProxy * KisImage::compositeProgressProxy ( )

Definition at line 746 of file kis_image.cc.

{
    return &m_d->compositeProgressProxy;
}

References KisImage::KisImagePrivate::compositeProgressProxy, and m_d.

◆ compositions()

QList< KisLayerCompositionSP > KisImage::compositions ( )

Returns the layer compositions for the image

Definition at line 2502 of file kis_image.cc.

{
    return m_d->compositions;
}

References KisImage::KisImagePrivate::compositions, and m_d.

◆ convertImageColorSpace()

void KisImage::convertImageColorSpace	(	const KoColorSpace *	dstColorSpace,
		KoColorConversionTransformation::Intent	renderingIntent,
		KoColorConversionTransformation::ConversionFlags	conversionFlags )

Convert the image and all its layers to the dstColorSpace

Definition at line 1449 of file kis_image.cc.

{
    m_d->convertImageColorSpaceImpl(dstColorSpace, true, renderingIntent, conversionFlags);
}

References KisImage::KisImagePrivate::convertImageColorSpaceImpl(), and m_d.

◆ convertImageProjectionColorSpace()

void KisImage::convertImageProjectionColorSpace ( const KoColorSpace * dstColorSpace )

Convert image projection to dstColorSpace, keeping all the layers intouched.

Definition at line 1456 of file kis_image.cc.

{
    m_d->convertImageColorSpaceImpl(dstColorSpace, false,
                                    KoColorConversionTransformation::internalRenderingIntent(),
                                    KoColorConversionTransformation::internalConversionFlags());
}

References KisImage::KisImagePrivate::convertImageColorSpaceImpl(), KoColorConversionTransformation::internalConversionFlags(), KoColorConversionTransformation::internalRenderingIntent(), and m_d.

◆ convertLayerColorSpace()

void KisImage::convertLayerColorSpace	(	KisNodeSP	node,
		const KoColorSpace *	dstColorSpace,
		KoColorConversionTransformation::Intent	renderingIntent,
		KoColorConversionTransformation::ConversionFlags	conversionFlags )

Convert layer and all its child layers to dstColorSpace

Definition at line 1347 of file kis_image.cc.

{
    if (!node->projectionLeaf()->isLayer()) return;
    // must not be an image root, use convertImageColorSpace() for that:
    KIS_SAFE_ASSERT_RECOVER_RETURN(!node->image() || (node.data() != node->image()->rootLayer().data()));
 
    const KoColorSpace *srcColorSpace = node->colorSpace();
 
    if (!dstColorSpace || *srcColorSpace == *dstColorSpace) return;
 
    KUndo2MagicString actionName =
        kundo2_i18n("Convert Layer Color Space");
 
    KisImageSignalVector emitSignals;
 
    KisProcessingApplicator applicator(this, node,
                                       KisProcessingApplicator::RECURSIVE,
                                       emitSignals, actionName);
 
    applicator.applyVisitor(
        new KisConvertColorSpaceProcessingVisitor(
            srcColorSpace, dstColorSpace,
            renderingIntent, conversionFlags),
        KisStrokeJobData::CONCURRENT);
 
    applicator.end();
}

References KisProcessingApplicator::applyVisitor(), KisBaseNode::colorSpace(), KisStrokeJobData::CONCURRENT, KisSharedPtr< T >::data(), KisProcessingApplicator::end(), KisBaseNode::image, KIS_SAFE_ASSERT_RECOVER_RETURN, kundo2_i18n(), KisNode::projectionLeaf, KisProcessingApplicator::RECURSIVE, and rootLayer().

◆ convertToQImage() [1/3]

QImage KisImage::convertToQImage	(	const QSize &	scaledImageSize,
		const KoColorProfile *	profile )

Render a thumbnail of the projection onto a QImage.

Definition at line 1762 of file kis_image.cc.

{
    if (scaledImageSize.isEmpty()) {
        return QImage();
    }
 
    KisPaintDeviceSP dev = new KisPaintDevice(colorSpace());
    KisPainter gc;
    gc.copyAreaOptimized(QPoint(0, 0), projection(), dev, bounds());
    gc.end();
    double scaleX = qreal(scaledImageSize.width()) / width();
    double scaleY = qreal(scaledImageSize.height()) / height();
 
 
    if (scaleX < 1.0/256 || scaleY < 1.0/256) {
        // quick checking if we're not trying to scale too much
        // convertToQImage uses KisFixedPoint values, which means that the scale cannot be smaller than 1/2^8
        // BUG:432182
        // FIXME: would be best to extend KisFixedPoint instead
        return convertToQImage(size(), profile).scaled(scaledImageSize, Qt::KeepAspectRatio, Qt::SmoothTransformation);
    }
 
    KoDummyUpdaterHolder updaterHolder;
    QPointer<KoUpdater> updater = updaterHolder.updater();
 
    KisTransformWorker worker(dev, scaleX, scaleY, 0.0, 0.0, 0.0, 0.0, 0.0, updater, KisFilterStrategyRegistry::instance()->value("Bicubic"));
    worker.run();
 
    return dev->convertToQImage(profile);
}

References bounds(), colorSpace(), KisPaintDevice::convertToQImage(), convertToQImage(), KisPainter::copyAreaOptimized(), KisPainter::end(), height(), KisFilterStrategyRegistry::instance(), profile(), projection(), KisTransformWorker::run(), size(), KoDummyUpdaterHolder::updater(), value(), and width().

◆ convertToQImage() [2/3]

QImage KisImage::convertToQImage	(	qint32	x1,
		qint32	y1,
		qint32	width,
		qint32	height,
		const KoColorProfile *	profile )

Render the projection onto a QImage.

Definition at line 1745 of file kis_image.cc.

{
    KisPaintDeviceSP dev = projection();
    if (!dev) return QImage();
    QImage image = dev->convertToQImage(const_cast<KoColorProfile*>(profile), x, y, w, h,
                                        KoColorConversionTransformation::internalRenderingIntent(),
                                        KoColorConversionTransformation::internalConversionFlags());
 
    return image;
}

References KisPaintDevice::convertToQImage(), KoColorConversionTransformation::internalConversionFlags(), KoColorConversionTransformation::internalRenderingIntent(), profile(), and projection().

◆ convertToQImage() [3/3]

QImage KisImage::convertToQImage	(	QRect	imageRect,
		const KoColorProfile *	profile )

Render the projection onto a QImage. (this is an overloaded function)

Definition at line 1734 of file kis_image.cc.

{
    qint32 x;
    qint32 y;
    qint32 w;
    qint32 h;
    imageRect.getRect(&x, &y, &w, &h);
    return convertToQImage(x, y, w, h, profile);
}

References convertToQImage(), and profile().

◆ copyFromImage()

void KisImage::copyFromImage ( const KisImage & rhs )

Definition at line 410 of file kis_image.cc.

{
    copyFromImageImpl(rhs, REPLACE);
}

References copyFromImageImpl(), and REPLACE.

◆ copyFromImageImpl()

void KisImage::copyFromImageImpl	(	const KisImage &	rhs,
		int	policy )

private

We should replace the root before emitting any signals, because some of the layers may be subscribed to sigSizeChanged() signal (e.g. KisSelectionBasedLayer). So the old layers should be fully detached before we actually Q_EMIT this signal.

We should also change all the dimensional properties of the image before setting the image on the nodes, because some nodes may emit signals if something changes internally (e.g. resolution).

See bug 447599 for more details.

Definition at line 415 of file kis_image.cc.

{
    // make sure we choose exactly one from REPLACE and CONSTRUCT
    KIS_ASSERT_RECOVER_RETURN(bool(policy & REPLACE) != bool(policy & CONSTRUCT));
 
    const bool sizeChanged = m_d->width != rhs.width() || m_d->height != rhs.height();
    const bool colorSpaceChanged = *m_d->colorSpace != *rhs.colorSpace();
    const bool resolutionChanged = m_d->xres != rhs.m_d->xres || m_d->yres != rhs.m_d->yres;
 
    if (sizeChanged) {
        m_d->width = rhs.width();
        m_d->height = rhs.height();
    }
 
    if (colorSpaceChanged) {
        m_d->colorSpace = rhs.colorSpace();
    }
 
    if (resolutionChanged) {
        m_d->xres = rhs.m_d->xres;
        m_d->yres = rhs.m_d->yres;
    }
 
    // from KisImage::KisImage(const KisImage &, KisUndoStore *, bool)
    setObjectName(rhs.objectName());
 
    KisNodeSP oldRoot = this->root();
    KisNodeSP newRoot = rhs.root()->clone();
    newRoot->setGraphListener(this);
    newRoot->setImage(this);
 
    m_d->rootLayer = dynamic_cast<KisGroupLayer*>(newRoot.data());
    setRoot(newRoot);
 
    if (oldRoot) {
        oldRoot->setImage(0);
        oldRoot->setGraphListener(0);
        oldRoot->disconnect();
    }
 
    // only when replacing do we need to Q_EMIT signals
#define EMIT_IF_NEEDED if (!(policy & REPLACE)) {} else emit
 
    if (sizeChanged) {
        EMIT_IF_NEEDED sigSizeChanged(QPointF(), QPointF());
    }
    if (colorSpaceChanged) {
        EMIT_IF_NEEDED sigColorSpaceChanged(m_d->colorSpace);
    }
    if (resolutionChanged) {
        EMIT_IF_NEEDED sigResolutionChanged(m_d->xres, m_d->yres);
    }
 
    m_d->allowMasksOnRootNode = rhs.m_d->allowMasksOnRootNode;
 
    if (rhs.m_d->proofingConfig) {
        KisProofingConfigurationSP proofingConfig(new KisProofingConfiguration(*rhs.m_d->proofingConfig));
        if (policy & REPLACE) {
            setProofingConfiguration(proofingConfig);
        } else {
            m_d->proofingConfig = proofingConfig;
        }
    }
 
    bool exactCopy = policy & EXACT_COPY;
 
    if (exactCopy || rhs.m_d->isolationRootNode || rhs.m_d->overlaySelectionMask) {
        m_d->isolateLayer = rhs.m_d->isolateLayer;
        m_d->isolateGroup = rhs.m_d->isolateGroup;
 
        QQueue<KisNodeSP> linearizedNodes;
        KisLayerUtils::recursiveApplyNodes(rhs.root(),
                                           [&linearizedNodes](KisNodeSP node) {
                                               linearizedNodes.enqueue(node);
                                           });
        KisLayerUtils::recursiveApplyNodes(newRoot,
                                           [&linearizedNodes, exactCopy, &rhs, this](KisNodeSP node) {
                                               KisNodeSP refNode = linearizedNodes.dequeue();
 
                                               if (exactCopy) {
                                                   node->setUuid(refNode->uuid());
                                               }
 
                                               if (rhs.m_d->isolationRootNode &&
                                                   rhs.m_d->isolationRootNode == refNode) {
                                                   m_d->isolationRootNode = node;
                                               }
 
                                               if (rhs.m_d->overlaySelectionMask &&
                                                   KisNodeSP(rhs.m_d->overlaySelectionMask) == refNode) {
                                                   m_d->targetOverlaySelectionMask = dynamic_cast<KisSelectionMask*>(node.data());
                                                   m_d->overlaySelectionMask = m_d->targetOverlaySelectionMask;
                                                   m_d->rootLayer->notifyChildMaskChanged();
                                               }
 
 
                                               // Re-establish DefaultBounds Instances for Existing Nodes
                                               // This is a workaround for copy-constructors failing to pass
                                               // proper DefaultBounds due to either lacking image data on construction
                                               // We should change the way "DefaultBounds" works to try to make it
                                               // safer for threading races.
                                               using KeyframeChannelContainer = QMap<QString, KisKeyframeChannel*>;
                                               KeyframeChannelContainer keyframeChannels = node->keyframeChannels();
                                               for (KeyframeChannelContainer::iterator i = keyframeChannels.begin();
                                                    i != keyframeChannels.end(); i++) {
                                                   keyframeChannels[i.key()]->setNode(node);
                                               }
                                           });
    }
 
    KisLayerUtils::recursiveApplyNodes(newRoot,
                                       [](KisNodeSP node) {
                                           dbgImage << "Node: " << (void *)node.data();
                                       });
 
 
 
    m_d->compositions.clear();
 
    Q_FOREACH (KisLayerCompositionSP comp, rhs.m_d->compositions) {
        m_d->compositions << toQShared(new KisLayerComposition(*comp, this));
    }
 
    EMIT_IF_NEEDED sigLayersChangedAsync();
 
    vKisAnnotationSP newAnnotations;
    Q_FOREACH (KisAnnotationSP annotation, rhs.m_d->annotations) {
        newAnnotations << annotation->clone();
    }
    m_d->annotations = newAnnotations;
 
    KIS_ASSERT_RECOVER_NOOP(rhs.m_d->projectionUpdatesFilters.isEmpty());
    KIS_ASSERT_RECOVER_NOOP(!rhs.m_d->disableUIUpdateSignals);
    KIS_ASSERT_RECOVER_NOOP(!rhs.m_d->disableDirtyRequests);
 
#undef EMIT_IF_NEEDED
}

◆ cropImage()

void KisImage::cropImage ( const QRect & newRect )

start asynchronous operation on cropping the image

The method will drop all the image data outside newRect and resize the image to fit the new size. The GUI will get correct notification with old and new sizes, so it adjust canvas origin accordingly and avoid jumping of the canvas on screen

Parameters

newRect the rectangle of the image which will be cut-out

Please note that the actual operation starts asynchronously in a background, so you cannot expect the image having new size right after this call.

Definition at line 870 of file kis_image.cc.

{
    resizeImageImpl(newRect, true);
}

References resizeImageImpl().

◆ cropNode()

void KisImage::cropNode	(	KisNodeSP	node,
		const QRect &	newRect,
		const bool	activeFrameOnly = false )

start asynchronous operation on cropping a subtree of nodes starting at node

The method will drop all the layer data outside newRect. Neither image nor a layer will be moved anywhere

Parameters

node	node to crop
newRect	the rectangle of the layer which will be cut-out
activeFrameOnly	whether to crop every animation frame or just the current one.

Please note that the actual operation starts asynchronously in a background, so you cannot expect the image having new size right after this call.

Definition at line 986 of file kis_image.cc.

{
    const bool isLayer = qobject_cast<KisLayer*>(node.data());
    KUndo2MagicString actionName = isLayer ?
        kundo2_i18n("Crop Layer") :
        kundo2_i18n("Crop Mask");
 
    KisImageSignalVector emitSignals;
 
    KisCropSavedExtraData *extraData =
        new KisCropSavedExtraData(KisCropSavedExtraData::CROP_LAYER,
                                  newRect, node);
 
    KisProcessingApplicator applicator(this, node,
                                       KisProcessingApplicator::RECURSIVE,
                                       emitSignals, actionName, extraData);
 
    KisProcessingVisitorSP visitor =
        new KisCropProcessingVisitor(newRect, true, false);
 
    if (node->isAnimated() && activeFrameOnly) {
        // Crop active frame..
        applicator.applyVisitor(visitor, KisStrokeJobData::CONCURRENT);
    } else {
        // Crop all frames..
        applicator.applyVisitorAllFrames(visitor, KisStrokeJobData::CONCURRENT);
    }
    applicator.end();
}

References KisProcessingApplicator::applyVisitor(), KisProcessingApplicator::applyVisitorAllFrames(), KisStrokeJobData::CONCURRENT, KisCropSavedExtraData::CROP_LAYER, KisSharedPtr< T >::data(), KisProcessingApplicator::end(), KisBaseNode::isAnimated(), isLayer(), kundo2_i18n(), and KisProcessingApplicator::RECURSIVE.

◆ cropNodes()

void KisImage::cropNodes	(	KisNodeList	nodes,
		const QRect &	newRect,
		const bool	activeFrameOnly = false )

◆ currentLevelOfDetail()

int KisImage::currentLevelOfDetail ( ) const

Returns: current level of detail which is used when processing the image. Current working zoom = 2 ^ (- currentLevelOfDetail()). Default value is null, which means we work on the original image.

Definition at line 2604 of file kis_image.cc.

{
    return m_d->scheduler.currentLevelOfDetail();
}

References KisUpdateScheduler::currentLevelOfDetail(), m_d, and KisImage::KisImagePrivate::scheduler.

◆ currentProjectionUpdatesFilter()

KisProjectionUpdatesFilterCookie KisImage::currentProjectionUpdatesFilter ( ) const

overridevirtual

Return the cookie of the lastly-installed filter

See also: addProjectionUpdatesFilter()

Implements KisUpdatesFacade.

Definition at line 2313 of file kis_image.cc.

{
    return !m_d->projectionUpdatesFilters.isEmpty() ?
                m_d->projectionUpdatesFilters.last().data() :
                KisProjectionUpdatesFilterCookie();
}

References m_d, and KisImage::KisImagePrivate::projectionUpdatesFilters.

◆ defaultProjectionColor()

KoColor KisImage::defaultProjectionColor ( ) const

See also: setDefaultProjectionColor()

Definition at line 1856 of file kis_image.cc.

{
    KIS_ASSERT_RECOVER(m_d->rootLayer) {
        return KoColor::createTransparent(m_d->colorSpace);
    }
 
    return m_d->rootLayer->defaultProjectionColor();
}

References KisImage::KisImagePrivate::colorSpace, KoColor::createTransparent(), KisGroupLayer::defaultProjectionColor(), KIS_ASSERT_RECOVER, m_d, and KisImage::KisImagePrivate::rootLayer.

◆ disableDirtyRequests()

void KisImage::disableDirtyRequests ( )

overridevirtual

Disables the processing of all the setDirty() requests that come to the image. The incoming requests are effectively dropped.

This feature is used by KisProcessingApplicator. For many cases it provides its own updates interface, which recalculates the whole subtree of nodes. But while we change any particular node, it can ask for an update itself. This method is a way of blocking such intermediate (and excessive) requests.

NOTE: this is a convenience function for addProjectionUpdatesFilter() that installs a predefined filter that eats everything. Please note that these calls are not recursive.

WARNING: The calls to enable/disable must be balanced.

Implements KisUpdatesFacade.

Definition at line 2320 of file kis_image.cc.

{
    m_d->disabledUpdatesCookies.push(
        addProjectionUpdatesFilter(toQShared(new KisDropAllProjectionUpdatesFilter())));
}

References addProjectionUpdatesFilter(), KisImage::KisImagePrivate::disabledUpdatesCookies, m_d, and toQShared().

◆ disableUIUpdates()

void KisImage::disableUIUpdates ( )

overridevirtual

Disables notification of the UI about the changes in the image. This feature is used by KisProcessingApplicator. It is needed when we change the size of the image. In this case, the whole image will be reloaded into UI by sigSizeChanged(), so there is no need to inform the UI about individual dirty rects.

The last call to enableUIUpdates() will return the list of updates that were requested while they were blocked.

Implements KisUpdatesFacade.

Definition at line 2332 of file kis_image.cc.

{
    m_d->disableUIUpdateSignals.ref();
}

References KisImage::KisImagePrivate::disableUIUpdateSignals, and m_d.

◆ documentToImagePixelFloored()

QPoint KisImage::documentToImagePixelFloored ( const QPointF & documentCoord ) const

Convert a document coordinate to an integer pixel coordinate rounded down.

Parameters

documentCoord PostScript Pt coordinate to convert.

Definition at line 1619 of file kis_image.cc.

{
    QPointF pixelCoord = documentToPixel(documentCoord);
    return QPoint(qFloor(pixelCoord.x()), qFloor(pixelCoord.y()));
}

References documentToPixel().

◆ documentToPixel() [1/2]

QPointF KisImage::documentToPixel ( const QPointF & documentCoord ) const

Convert a document coordinate to a pixel coordinate.

Parameters

documentCoord PostScript Pt coordinate to convert.

Definition at line 1614 of file kis_image.cc.

{
    return QPointF(documentCoord.x() * xRes(), documentCoord.y() * yRes());
}

References xRes(), and yRes().

◆ documentToPixel() [2/2]

QRectF KisImage::documentToPixel ( const QRectF & documentRect ) const

Convert a document rectangle to a pixel rectangle.

Parameters

documentRect PostScript Pt rectangle to convert.

Definition at line 1625 of file kis_image.cc.

{
    return QRectF(documentToPixel(documentRect.topLeft()), documentToPixel(documentRect.bottomRight()));
}

References documentToPixel().

◆ effectiveLodBounds()

QRect KisImage::effectiveLodBounds ( ) const

Returns the actual bounds of the image, taking LevelOfDetail into account. This value is used as a bounds() value of KisDefaultBounds object.

Definition at line 1802 of file kis_image.cc.

{
    QRect boundRect = bounds();
 
    const int lod = currentLevelOfDetail();
    if (lod > 0) {
        KisLodTransform t(lod);
        boundRect = t.map(boundRect);
    }
 
    return boundRect;
}

References bounds(), currentLevelOfDetail(), and KisLodTransform::map().

◆ emitSizeChanged()

void KisImage::emitSizeChanged ( )

private

◆ enableDirtyRequests()

void KisImage::enableDirtyRequests ( )

overridevirtual

See also: disableDirtyRequests()

Implements KisUpdatesFacade.

Definition at line 2326 of file kis_image.cc.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN(!m_d->disabledUpdatesCookies.isEmpty());
    removeProjectionUpdatesFilter(m_d->disabledUpdatesCookies.pop());
}

References KisImage::KisImagePrivate::disabledUpdatesCookies, KIS_SAFE_ASSERT_RECOVER_RETURN, m_d, and removeProjectionUpdatesFilter().

◆ enableUIUpdates()

QVector< QRect > KisImage::enableUIUpdates ( )

overridevirtual

See also: disableUIUpdates

Implements KisUpdatesFacade.

Definition at line 2352 of file kis_image.cc.

{
    m_d->disableUIUpdateSignals.deref();
 
    QRect rect;
    QVector<QRect> postponedUpdates;
 
    while (m_d->savedDisabledUIUpdates.pop(rect)) {
        postponedUpdates.append(rect);
    }
 
    return postponedUpdates;
}

References KisImage::KisImagePrivate::disableUIUpdateSignals, m_d, KisLocklessStack< T >::pop(), and KisImage::KisImagePrivate::savedDisabledUIUpdates.

◆ endAnnotations()

vKisAnnotationSP_it KisImage::endAnnotations ( )

end of an iteration over the annotations of this image

Definition at line 1938 of file kis_image.cc.

{
    return m_d->annotations.end();
}

References KisImage::KisImagePrivate::annotations, and m_d.

◆ endStroke()

void KisImage::endStroke ( KisStrokeId id )

overridevirtual

Implements KisStrokesFacade.

Definition at line 2162 of file kis_image.cc.

{
    m_d->scheduler.endStroke(id);
}

References KisUpdateScheduler::endStroke(), m_d, and KisImage::KisImagePrivate::scheduler.

◆ explicitRegenerateLevelOfDetail

void KisImage::explicitRegenerateLevelOfDetail ( )

slot

Explicitly start regeneration of LoD planes of all the devices in the image. This call should be performed when the user is idle, just to make the quality of image updates better.

Definition at line 2609 of file kis_image.cc.

{
    const KisLodPreferences pref = m_d->scheduler.lodPreferences();
 
    if (pref.lodSupported() && pref.lodPreferred()) {
        m_d->scheduler.explicitRegenerateLevelOfDetail();
    }
}

References KisUpdateScheduler::explicitRegenerateLevelOfDetail(), KisUpdateScheduler::lodPreferences(), KisLodPreferences::lodPreferred(), KisLodPreferences::lodSupported(), m_d, and KisImage::KisImagePrivate::scheduler.

◆ flatten()

void KisImage::flatten ( KisNodeSP activeNode )

Merge all visible layers and discard hidden ones.

Definition at line 1708 of file kis_image.cc.

{
    KisLayerUtils::flattenImage(this, activeNode);
}

References KisLayerUtils::flattenImage().

◆ flattenLayer()

void KisImage::flattenLayer ( KisLayerSP layer )

flatten the layer: that is, the projection becomes the layer and all subnodes are removed. If this is not a paint layer, it will morph into a paint layer.

Definition at line 1723 of file kis_image.cc.

{
    KisLayerUtils::flattenLayer(this, layer);
}

References KisLayerUtils::flattenLayer().

◆ fromQImage()

KisImageSP KisImage::fromQImage	(	const QImage &	image,
		KisUndoStore *	undoStore )

static

Definition at line 341 of file kis_image.cc.

{
    const KoColorSpace *colorSpace = 0;
 
    switch (image.format()) {
    case QImage::Format_Invalid:
    case QImage::Format_Mono:
    case QImage::Format_MonoLSB:
        colorSpace = KoColorSpaceRegistry::instance()->graya8();
        break;
    case QImage::Format_Indexed8:
    case QImage::Format_RGB32:
    case QImage::Format_ARGB32:
    case QImage::Format_ARGB32_Premultiplied:
        colorSpace = KoColorSpaceRegistry::instance()->rgb8();
        break;
    case QImage::Format_RGB16:
        colorSpace = KoColorSpaceRegistry::instance()->rgb16();
        break;
    case QImage::Format_ARGB8565_Premultiplied:
    case QImage::Format_RGB666:
    case QImage::Format_ARGB6666_Premultiplied:
    case QImage::Format_RGB555:
    case QImage::Format_ARGB8555_Premultiplied:
    case QImage::Format_RGB888:
    case QImage::Format_RGB444:
    case QImage::Format_ARGB4444_Premultiplied:
    case QImage::Format_RGBX8888:
    case QImage::Format_RGBA8888:
    case QImage::Format_RGBA8888_Premultiplied:
        colorSpace = KoColorSpaceRegistry::instance()->rgb8();
        break;
    case QImage::Format_BGR30:
    case QImage::Format_A2BGR30_Premultiplied:
    case QImage::Format_RGB30:
    case QImage::Format_A2RGB30_Premultiplied:
        colorSpace = KoColorSpaceRegistry::instance()->rgb8();
        break;
    case QImage::Format_Alpha8:
        colorSpace = KoColorSpaceRegistry::instance()->alpha8();
        break;
    case QImage::Format_Grayscale8:
        colorSpace = KoColorSpaceRegistry::instance()->graya8();
        break;
    case QImage::Format_Grayscale16:
        colorSpace = KoColorSpaceRegistry::instance()->graya16();
        break;
    case QImage::Format_RGBX64:
    case QImage::Format_RGBA64:
    case QImage::Format_RGBA64_Premultiplied:
        colorSpace = KoColorSpaceRegistry::instance()->colorSpace(RGBAColorModelID.id(), Float32BitsColorDepthID.id(), 0);
        break;
    default:
        colorSpace = 0;
    }
 
    KisImageSP img = new KisImage(undoStore, image.width(), image.height(), colorSpace, i18n("Imported Image"));
    KisPaintLayerSP layer = new KisPaintLayer(img, img->nextLayerName(), 255);
    layer->paintDevice()->convertFromQImage(image, 0, 0, 0);
    img->addNode(layer.data(), img->rootLayer().data());
 
    return img;
}

References KisNodeFacade::addNode(), KoColorSpaceRegistry::alpha8(), colorSpace(), KoColorSpaceRegistry::colorSpace(), KisPaintDevice::convertFromQImage(), KisSharedPtr< T >::data(), Float32BitsColorDepthID, KoColorSpaceRegistry::graya16(), KoColorSpaceRegistry::graya8(), KoID::id(), KoColorSpaceRegistry::instance(), KisImage(), nextLayerName(), KisPaintLayer::paintDevice, KoColorSpaceRegistry::rgb16(), KoColorSpaceRegistry::rgb8(), RGBAColorModelID, rootLayer(), and undoStore().

◆ globalSelection()

KisSelectionSP KisImage::globalSelection ( ) const

Returns: the global selection object or 0 if there is none. The global selection is always read-write.

Definition at line 695 of file kis_image.cc.

{
    KisSelectionMaskSP selectionMask = m_d->rootLayer->selectionMask();
    if (selectionMask) {
        return selectionMask->selection();
    } else {
        return 0;
    }
}

References m_d, KisImage::KisImagePrivate::rootLayer, KisMask::selection, and KisLayer::selectionMask().

◆ globalSelectionManagementInterface

KisImageGlobalSelectionManagementInterface * KisImage::globalSelectionManagementInterface ( ) const

slot

A special interface that commands use to modify image's global selection

Definition at line 710 of file kis_image.cc.

{
    return &m_d->globalSelectionInterface;
}

References KisImage::KisImagePrivate::globalSelectionInterface, and m_d.

◆ graphOverlayNode()

KisNode * KisImage::graphOverlayNode ( ) const

overridevirtual

Reimplemented from KisNodeGraphListener.

Definition at line 2481 of file kis_image.cc.

{
    return m_d->overlaySelectionMask.data();
}

References KisSharedPtr< T >::data(), m_d, and KisImage::KisImagePrivate::overlaySelectionMask.

◆ hasOverlaySelectionMask()

bool KisImage::hasOverlaySelectionMask ( ) const

See also: setOverlaySelectionMask

Definition at line 690 of file kis_image.cc.

{
    return m_d->overlaySelectionMask;
}

References m_d, and KisImage::KisImagePrivate::overlaySelectionMask.

◆ hasUpdatesRunning()

bool KisImage::hasUpdatesRunning ( ) const

overridevirtual

Returns: true if there are some updates in the updates queue. Please note, that is doesn't guarantee that there are no updates running in the updater context at the very moment. To guarantee that there are no updates left at all, please use barrier jobs instead.

Implements KisUpdatesFacade.

Definition at line 2284 of file kis_image.cc.

{
    return m_d->scheduler.hasUpdatesRunning();
}

References KisUpdateScheduler::hasUpdatesRunning(), m_d, and KisImage::KisImagePrivate::scheduler.

◆ height()

qint32 KisImage::height ( ) const

Return the height of the image

Definition at line 1650 of file kis_image.cc.

{
    return m_d->height;
}

References KisImage::KisImagePrivate::height, and m_d.

◆ immediateLockForReadOnly()

void KisImage::immediateLockForReadOnly ( )

[low-level] Lock the image without waiting for all the internal job queues are processed

WARNING: Don't use it unless you really know what you are doing! Use barrierLock() instead!

Waits for all the currently running internal jobs to complete and locks the image for writing. Please note that this function does not wait for all the internal queues to process, so there might be some non-finished actions pending. It means that you just postpone these actions until you unlock() the image back. Until then, then image might easily be frozen in some inconsistent state.

The only sane usage for this function is to lock the image for emergency processing, when some internal action or scheduler got hung up, and you just want to fetch some data from the image without races.

In all other cases, please use barrierLock() instead!

Definition at line 793 of file kis_image.cc.

{
    if (!locked()) {
        requestStrokeEnd();
        KisBusyWaitBroker::instance()->notifyWaitOnImageStarted(this);
        m_d->scheduler.immediateLockForReadOnly();
        KisBusyWaitBroker::instance()->notifyWaitOnImageEnded(this);
    }
    m_d->lockCount++;
    m_d->lockedForReadOnly = true;
}

References KisUpdateScheduler::immediateLockForReadOnly(), KisBusyWaitBroker::instance(), KisImage::KisImagePrivate::lockCount, locked(), KisImage::KisImagePrivate::lockedForReadOnly, m_d, KisBusyWaitBroker::notifyWaitOnImageEnded(), KisBusyWaitBroker::notifyWaitOnImageStarted(), requestStrokeEnd(), and KisImage::KisImagePrivate::scheduler.

◆ initialRefreshGraph()

void KisImage::initialRefreshGraph ( )

Triggers synchronous recomposition of the projection on the document opening, i.e. with the cropRect set to null. Unlimited crop rect forces the clone layers to regenerate all its sources.

WARNING: If you are not loading a multilayered document, consider using refreshGraphAsync() instead, possibly coupled with waitForDone().

NOTE: Tricky part. We set crop rect to null, so the clones will not rely on precalculated projections of their sources

Definition at line 2210 of file kis_image.cc.

{
    refreshGraphAsync(0, bounds(), QRect());
    waitForDone();
}

References bounds(), refreshGraphAsync(), and waitForDone().

◆ invalidateAllFrames()

void KisImage::invalidateAllFrames ( )

overridevirtual

Reimplemented from KisNodeGraphListener.

Definition at line 632 of file kis_image.cc.

{
    invalidateFrames(KisTimeSpan::infinite(0), QRect());
}

References KisTimeSpan::infinite(), and invalidateFrames().

◆ invalidateFrames()

void KisImage::invalidateFrames	(	const KisTimeSpan &	range,
		const QRect &	rect )

overridevirtual

Reimplemented from KisNodeGraphListener.

Definition at line 2471 of file kis_image.cc.

{
    m_d->animationInterface->invalidateFrames(range, rect);
}

References KisImage::KisImagePrivate::animationInterface, KisImageAnimationInterface::invalidateFrames(), and m_d.

◆ isIdle()

bool KisImage::isIdle ( bool allowLocked = false )

Definition at line 788 of file kis_image.cc.

{
    return (allowLocked || !locked()) && m_d->scheduler.isIdle();
}

References KisUpdateScheduler::isIdle(), locked(), m_d, and KisImage::KisImagePrivate::scheduler.

◆ isIsolatingGroup()

bool KisImage::isIsolatingGroup ( ) const

Definition at line 2151 of file kis_image.cc.

{
     return m_d->isolateGroup;
}

References KisImage::KisImagePrivate::isolateGroup, and m_d.

◆ isIsolatingLayer()

bool KisImage::isIsolatingLayer ( ) const

Definition at line 2146 of file kis_image.cc.

{
    return m_d->isolateLayer;
}

References KisImage::KisImagePrivate::isolateLayer, and m_d.

◆ isolationRootNode()

KisNodeSP KisImage::isolationRootNode ( ) const

Definition at line 2142 of file kis_image.cc.

                                            {
    return m_d->isolationRootNode;
}

References KisImage::KisImagePrivate::isolationRootNode, and m_d.

◆ keyframeChannelAboutToBeRemoved()

void KisImage::keyframeChannelAboutToBeRemoved	(	KisNode *	node,
		KisKeyframeChannel *	channel )

overridevirtual

Reimplemented from KisNodeGraphListener.

Definition at line 2494 of file kis_image.cc.

{
    Q_UNUSED(node);
 
    channel->disconnect(channel, SIGNAL(sigAddedKeyframe(const KisKeyframeChannel*, int)), m_d->animationInterface, SIGNAL(sigKeyframeAdded(const KisKeyframeChannel*, int)));
    channel->disconnect(channel, SIGNAL(sigKeyframeHasBeenRemoved(const KisKeyframeChannel*, int)), m_d->animationInterface, SIGNAL(sigKeyframeRemoved(const KisKeyframeChannel*, int)));
}

References KisImage::KisImagePrivate::animationInterface, and m_d.

◆ keyframeChannelHasBeenAdded()

void KisImage::keyframeChannelHasBeenAdded	(	KisNode *	node,
		KisKeyframeChannel *	channel )

overridevirtual

Inform the model that a keyframe channel has been added or removed.

Reimplemented from KisNodeGraphListener.

Definition at line 2486 of file kis_image.cc.

{
    Q_UNUSED(node);
 
    channel->connect(channel, SIGNAL(sigAddedKeyframe(const KisKeyframeChannel*, int)), m_d->animationInterface, SIGNAL(sigKeyframeAdded(const KisKeyframeChannel*, int)), Qt::UniqueConnection);
    channel->connect(channel, SIGNAL(sigKeyframeHasBeenRemoved(const KisKeyframeChannel*,int)), m_d->animationInterface, SIGNAL(sigKeyframeRemoved(const KisKeyframeChannel*, int)), Qt::UniqueConnection);
}

References KisImage::KisImagePrivate::animationInterface, and m_d.

◆ lastExecutedCommand()

const KUndo2Command * KisImage::lastExecutedCommand ( ) const

overridevirtual

Return the lastly executed LoD0 command. It is effectively the same as to call undoAdapter()->presentCommand();

Implements KisStrokeUndoFacade.

Definition at line 1823 of file kis_image.cc.

{
    return m_d->undoStore->presentCommand();
}

References m_d, and KisImage::KisImagePrivate::undoStore.

◆ locked()

bool KisImage::locked ( ) const

Returns: return true if the image is in a locked state, i.e. all the internal jobs are blocked from execution by calling either lock() or barrierLock().

When the image is locked, the user can do some modifications to the image contents safely without a perspective having race conditions with internal image jobs.

Definition at line 751 of file kis_image.cc.

{
    return m_d->lockCount != 0;
}

References KisImage::KisImagePrivate::lockCount, and m_d.

◆ lodPreferences()

KisLodPreferences KisImage::lodPreferences ( ) const

Return current lod-preferences used by the strokes queue. They may differ from the preferences that has been assigned before due to multi-stage application process (due to multithreading considerations)

Definition at line 2623 of file kis_image.cc.

{
    return m_d->scheduler.lodPreferences();
}

References KisUpdateScheduler::lodPreferences(), m_d, and KisImage::KisImagePrivate::scheduler.

◆ mergeDown()

void KisImage::mergeDown	(	KisLayerSP	l,
		const KisMetaData::MergeStrategy *	strategy )

Merge the specified layer with the layer below this layer, remove the specified layer.

Definition at line 1718 of file kis_image.cc.

{
    KisLayerUtils::mergeDown(this, layer, strategy);
}

References KisLayerUtils::mergeDown().

◆ mergeMultipleLayers()

void KisImage::mergeMultipleLayers	(	QList< KisNodeSP >	mergedLayers,
		KisNodeSP	putAfter )

Merges layers in mergedLayers and creates a new layer above putAfter

Definition at line 1713 of file kis_image.cc.

{
    KisLayerUtils::mergeMultipleNodes(this, mergedNodes, putAfter);
}

References KisLayerUtils::mergeMultipleNodes().

◆ mirrorAxesCenter()

QPointF KisImage::mirrorAxesCenter ( ) const

Relative position of the mirror axis center 0,0 - topleft corner of the image 1,1 - bottomright corner of the image

Definition at line 2661 of file kis_image.cc.

{
    return m_d->axesCenter;
}

References KisImage::KisImagePrivate::axesCenter, and m_d.

◆ moveCompositionDown()

void KisImage::moveCompositionDown ( KisLayerCompositionSP composition )

Move a composition down in the composition list

Definition at line 2526 of file kis_image.cc.

{
    int index = m_d->compositions.indexOf(composition);
    if (index >= m_d->compositions.size() -1) {
        return;
    }
    m_d->compositions.move(index, index + 1);
}

References KisImage::KisImagePrivate::compositions, and m_d.

◆ moveCompositionUp()

void KisImage::moveCompositionUp ( KisLayerCompositionSP composition )

Move a composition up in the composition list

Definition at line 2517 of file kis_image.cc.

{
    int index = m_d->compositions.indexOf(composition);
    if (index <= 0) {
        return;
    }
    m_d->compositions.move(index, index - 1);
}

References KisImage::KisImagePrivate::compositions, and m_d.

◆ nChildLayers()

qint32 KisImage::nChildLayers ( ) const

Definition at line 1695 of file kis_image.cc.

{
    const QStringList list = {"KisLayer"};
 
    KoProperties koProperties;
    KisCountVisitor visitor(list, koProperties);
    const QList<KisNodeSP> childNodes = m_d->rootLayer->childNodes(list, koProperties);
    for (KisNodeSP childNode: childNodes) {
        childNode->accept(visitor);
    }
    return visitor.count();
}

References KisNode::childNodes(), KisCountVisitor::count(), m_d, and KisImage::KisImagePrivate::rootLayer.

◆ nextLayerName()

QString KisImage::nextLayerName ( const QString & baseName = "" ) const

Retrieve the next automatic layername (XXX: fix to add option to return Mask X)

Definition at line 715 of file kis_image.cc.

{
    QString baseName = _baseName;
 
    int numLayers = 0;
    int maxLayerIndex = 0;
    QRegularExpression numberedLayerRegexp(".* (\\d+)$");
    KisLayerUtils::recursiveApplyNodes(root(),
        [&numLayers, &maxLayerIndex, &numberedLayerRegexp] (KisNodeSP node) {
            if (node->inherits("KisLayer")) {
                QRegularExpressionMatch match = numberedLayerRegexp.match(node->name());
 
                if (match.hasMatch()) {
                    maxLayerIndex = qMax(maxLayerIndex, match.captured(1).toInt());
                }
                numLayers++;
            }
        });
 
    // special case if there is only root node
    if (numLayers == 1) {
        return i18nc("Name for the bottom-most layer in the layerstack", "Background");
    }
 
    if (baseName.isEmpty()) {
        baseName = i18n("Paint Layer");
    }
 
    return QString("%1 %2").arg(baseName).arg(maxLayerIndex + 1);
}

References KisLayerUtils::recursiveApplyNodes(), and KisNodeFacade::root.

◆ nHiddenLayers()

qint32 KisImage::nHiddenLayers ( ) const

Return the number of layers (not other node types) that are in this image and that are hidden.

Definition at line 1683 of file kis_image.cc.

{
    QStringList list;
    list << "KisLayer";
    KoProperties properties;
    properties.setProperty("visible", false);
    KisCountVisitor visitor(list, properties);
    m_d->rootLayer->accept(visitor);
 
    return visitor.count();
}

References KisGroupLayer::accept(), KisCountVisitor::count(), m_d, KisImage::KisImagePrivate::rootLayer, and KoProperties::setProperty().

◆ nlayers()

qint32 KisImage::nlayers ( ) const

Return the number of layers (not other nodes) that are in this image.

Definition at line 1673 of file kis_image.cc.

{
    QStringList list;
    list << "KisLayer";
 
    KisCountVisitor visitor(list, KoProperties());
    m_d->rootLayer->accept(visitor);
    return visitor.count();
}

References KisGroupLayer::accept(), KisCountVisitor::count(), m_d, and KisImage::KisImagePrivate::rootLayer.

◆ nodeChanged()

void KisImage::nodeChanged ( KisNode * node )

overridevirtual

Reimplemented from KisNodeGraphListener.

Definition at line 626 of file kis_image.cc.

{
    KisNodeGraphListener::nodeChanged(node);
    m_d->signalRouter.emitNodeChanged(node);
}

References KisImageSignalRouter::emitNodeChanged(), m_d, KisNodeGraphListener::nodeChanged(), and KisImage::KisImagePrivate::signalRouter.

◆ nodeCollapsedChanged()

void KisImage::nodeCollapsedChanged ( KisNode * node )

overridevirtual

Reimplemented from KisNodeGraphListener.

Definition at line 2628 of file kis_image.cc.

{
    Q_UNUSED(node);
    Q_EMIT sigNodeCollapsedChanged();
}

References sigNodeCollapsedChanged().

◆ nodeHasBeenAdded()

void KisImage::nodeHasBeenAdded	(	KisNode *	parent,
		int	index,
		KisNodeAdditionFlags	flags )

overridevirtual

Inform the model we're done adding a node.

Reimplemented from KisNodeGraphListener.

Definition at line 588 of file kis_image.cc.

{
    KisNodeGraphListener::nodeHasBeenAdded(parent, index, flags);
 
    KisLayerUtils::recursiveApplyNodes(KisSharedPtr<KisNode>(parent), [this](KisNodeSP node){
       QMap<QString, KisKeyframeChannel*> chans = node->keyframeChannels();
       Q_FOREACH(KisKeyframeChannel* chan, chans.values()) {
           chan->setNode(node);
           this->keyframeChannelHasBeenAdded(node.data(), chan);
       }
    });
 
    SANITY_CHECK_LOCKED("nodeHasBeenAdded");
    m_d->signalRouter.emitNodeHasBeenAdded(parent, index, flags);
}

References KisSharedPtr< T >::data(), KisImageSignalRouter::emitNodeHasBeenAdded(), keyframeChannelHasBeenAdded(), KisBaseNode::keyframeChannels, m_d, KisNodeGraphListener::nodeHasBeenAdded(), KisLayerUtils::recursiveApplyNodes(), SANITY_CHECK_LOCKED, KisKeyframeChannel::setNode(), and KisImage::KisImagePrivate::signalRouter.

◆ notifyAboutToBeDeleted()

void KisImage::notifyAboutToBeDeleted ( )

Called before the image is deleted and sends the sigAboutToBeDeleted signal

Definition at line 1943 of file kis_image.cc.

{
    Q_EMIT sigAboutToBeDeleted();
}

References sigAboutToBeDeleted().

◆ notifyBatchUpdateEnded()

void KisImage::notifyBatchUpdateEnded ( )

overridevirtual

Notify GUI that batch update has been completed. Now GUI can start showing all of them on screen.

Implements KisUpdatesFacade.

Definition at line 2342 of file kis_image.cc.

{
    m_d->signalRouter.emitNotifyBatchUpdateEnded();
}

References KisImageSignalRouter::emitNotifyBatchUpdateEnded(), m_d, and KisImage::KisImagePrivate::signalRouter.

◆ notifyBatchUpdateStarted()

void KisImage::notifyBatchUpdateStarted ( )

overridevirtual

Notify GUI about a bunch of updates planned. GUI is expected to wait until all the updates are completed, and render them on screen only in the very and of the batch.

Implements KisUpdatesFacade.

Definition at line 2337 of file kis_image.cc.

{
    m_d->signalRouter.emitNotifyBatchUpdateStarted();
}

References KisImageSignalRouter::emitNotifyBatchUpdateStarted(), m_d, and KisImage::KisImagePrivate::signalRouter.

◆ notifyLayersChanged()

void KisImage::notifyLayersChanged ( )

use if the layers have changed completely (eg. when flattening)

Definition at line 1792 of file kis_image.cc.

{
    m_d->signalRouter.emitNotification(LayersChangedSignal);
}

References KisImageSignalRouter::emitNotification(), LayersChangedSignal, m_d, and KisImage::KisImagePrivate::signalRouter.

◆ notifyProjectionUpdated()

void KisImage::notifyProjectionUpdated ( const QRect & rc )

overridevirtual

Implements KisProjectionUpdateListener.

Definition at line 2366 of file kis_image.cc.

{
    KisUpdateTimeMonitor::instance()->reportUpdateFinished(rc);
 
    if (!m_d->disableUIUpdateSignals) {
        int lod = currentLevelOfDetail();
        QRect dirtyRect = !lod ? rc : KisLodTransform::upscaledRect(rc, lod);
 
        if (dirtyRect.isEmpty()) return;
 
        Q_EMIT sigImageUpdated(dirtyRect);
    } else {
        m_d->savedDisabledUIUpdates.push(rc);
    }
}

References currentLevelOfDetail(), KisImage::KisImagePrivate::disableUIUpdateSignals, KisUpdateTimeMonitor::instance(), m_d, KisLocklessStack< T >::push(), KisUpdateTimeMonitor::reportUpdateFinished(), KisImage::KisImagePrivate::savedDisabledUIUpdates, sigImageUpdated(), and KisLodTransformBase::upscaledRect().

◆ notifySelectionChanged()

void KisImage::notifySelectionChanged ( )

overridevirtual

Inform the model that one of the selections in the graph is changed. The sender is not passed to the function (at least for now) because the UI should decide itself whether it needs to fetch new selection of not.

The selection is calculated asynchronously, so it is not handled by disableUIUpdates() and other special signals of KisImageSignalRouter

Editing of selection masks doesn't necessary produce a setDirty() call, so in the end of the stroke we need to request direct update of the UI's cache.

Reimplemented from KisNodeGraphListener.

Definition at line 2392 of file kis_image.cc.

{
    m_d->legacyUndoAdapter.emitSelectionChanged();
 
    if (m_d->isolationRootNode &&
        dynamic_cast<KisSelectionMask*>(m_d->isolationRootNode.data())) {
 
        notifyProjectionUpdated(bounds());
    }
}

References bounds(), KisSharedPtr< T >::data(), KisUndoAdapter::emitSelectionChanged(), KisImage::KisImagePrivate::isolationRootNode, KisImage::KisImagePrivate::legacyUndoAdapter, m_d, and notifyProjectionUpdated().

◆ notifyUIUpdateCompleted()

void KisImage::notifyUIUpdateCompleted ( const QRect & rc )

overridevirtual

Notify GUI that rect rc is now prepared in the image and GUI can read data from it.

WARNING: GUI will read the data right in the handler of this signal, so exclusive access to the area must be guaranteed by the caller.

Implements KisUpdatesFacade.

Definition at line 2347 of file kis_image.cc.

{
    notifyProjectionUpdated(rc);
}

References notifyProjectionUpdated().

◆ operator=()

KisImage & KisImage::operator= ( const KisImage & rhs )

private

◆ overlaySelectionMask()

KisSelectionMaskSP KisImage::overlaySelectionMask ( ) const

See also: setOverlaySelectionMask

Definition at line 685 of file kis_image.cc.

{
    return m_d->overlaySelectionMask;
}

References m_d, and KisImage::KisImagePrivate::overlaySelectionMask.

◆ pixelToDocument() [1/3]

QPointF KisImage::pixelToDocument ( const QPoint & pixelCoord ) const

Convert an integer pixel coordinate to a document coordinate. The document coordinate is at the centre of the pixel.

Parameters

pixelCoord pixel coordinate to convert.

Definition at line 1635 of file kis_image.cc.

{
    return QPointF((pixelCoord.x() + 0.5) / xRes(), (pixelCoord.y() + 0.5) / yRes());
}

References xRes(), and yRes().

◆ pixelToDocument() [2/3]

QPointF KisImage::pixelToDocument ( const QPointF & pixelCoord ) const

Convert a pixel coordinate to a document coordinate.

Parameters

pixelCoord pixel coordinate to convert.

Definition at line 1630 of file kis_image.cc.

{
    return QPointF(pixelCoord.x() / xRes(), pixelCoord.y() / yRes());
}

References xRes(), and yRes().

◆ pixelToDocument() [3/3]

QRectF KisImage::pixelToDocument ( const QRectF & pixelCoord ) const

Convert a document rectangle to an integer pixel rectangle.

Parameters

pixelCoord pixel coordinate to convert.

Definition at line 1640 of file kis_image.cc.

{
    return QRectF(pixelToDocument(pixelCoord.topLeft()), pixelToDocument(pixelCoord.bottomRight()));
}

References pixelToDocument().

◆ postExecutionUndoAdapter()

KisPostExecutionUndoAdapter * KisImage::postExecutionUndoAdapter ( ) const

overridevirtual

This adapter is used by the strokes system. The commands are added to it after redo() is done (in the scheduler context). They are wrapped into a special command and added to the undo stack. redo() in not called.

Implements KisStrokeUndoFacade.

Definition at line 1815 of file kis_image.cc.

{
    const int lod = currentLevelOfDetail();
    return lod > 0 ?
        m_d->scheduler.lodNPostExecutionUndoAdapter() :
        &m_d->postExecutionUndoAdapter;
}

References currentLevelOfDetail(), KisUpdateScheduler::lodNPostExecutionUndoAdapter(), m_d, KisImage::KisImagePrivate::postExecutionUndoAdapter, and KisImage::KisImagePrivate::scheduler.

◆ profile()

const KoColorProfile * KisImage::profile ( ) const

Definition at line 1584 of file kis_image.cc.

{
    return colorSpace()->profile();
}

References colorSpace(), and KoColorSpace::profile().

◆ projection()

KisPaintDeviceSP KisImage::projection ( ) const

Return the projection; that is, the complete, composited representation of this image.

Definition at line 1661 of file kis_image.cc.

{
    if (m_d->isolationRootNode) {
        return m_d->isolationRootNode->projection();
    }
 
    Q_ASSERT(m_d->rootLayer);
    KisPaintDeviceSP projection = m_d->rootLayer->projection();
    Q_ASSERT(projection);
    return projection;
}

References KisImage::KisImagePrivate::isolationRootNode, m_d, projection(), KisBaseNode::projection(), KisLayer::projection(), and KisImage::KisImagePrivate::rootLayer.

◆ proofingConfiguration()

KisProofingConfigurationSP KisImage::proofingConfiguration ( ) const

proofingConfiguration

Returns: the proofing configuration of the image.

Definition at line 2653 of file kis_image.cc.

{
    if (m_d->proofingConfig) {
        return m_d->proofingConfig;
    }
    return KisProofingConfigurationSP();
}

References m_d, and KisImage::KisImagePrivate::proofingConfig.

◆ purgeUnusedData()

void KisImage::purgeUnusedData ( bool isCancellable )

purge all pixels that have default pixel to free up memory

Parameters

isCancellable if true, the scheduler is allower to stop and cancel purging operation as soon as the user starts any action. If isCancellable is false, then the user will not be allowed to do anything until purging operation is completed.

In cancellable mode, the action does not touch the paint devices of the image, only projections, because it can break undo/redo.

make sure we deduplicate the list to avoid concurrent write access to the devices

Definition at line 875 of file kis_image.cc.

{
    struct PurgeUnusedDataStroke : public KisRunnableBasedStrokeStrategy {
        PurgeUnusedDataStroke(KisImageSP image, bool isCancellable)
            : KisRunnableBasedStrokeStrategy(QLatin1String("purge-unused-data"),
                                             kundo2_i18n("Purge Unused Data")),
              m_image(image),
              m_finalCommand(new KUndo2Command(this->name()))
 
        {
            this->enableJob(JOB_INIT, true, KisStrokeJobData::BARRIER, KisStrokeJobData::EXCLUSIVE);
            this->enableJob(JOB_DOSTROKE, true);
            this->enableJob(JOB_FINISH, true, KisStrokeJobData::SEQUENTIAL);
 
            setClearsRedoOnStart(!isCancellable);
            setRequestsOtherStrokesToEnd(!isCancellable);
            setCanForgetAboutMe(isCancellable);
        }
 
        void initStrokeCallback() override
        {
            KisPaintDeviceList paintDevicesList;
            KisPaintDeviceList projectionsList;
            QVector<KisStrokeJobData*> jobsData;
 
            KisLayerUtils::recursiveApplyNodes(m_image->root(),
                [&paintDevicesList, &projectionsList, this](KisNodeSP node) {
                    KisPaintDeviceList deviceList = node->getLodCapableDevices();
 
                    Q_FOREACH (KisPaintDeviceSP dev, deviceList) {
                        if (!dev) continue;
 
                        // we do **not** strip paint devices in the forgettable
                        // mode, since we should handle transactions for them
                        if (dev == node->paintDevice() && !canForgetAboutMe()) {
                            paintDevicesList << dev;
                        } else {
                            projectionsList << dev;
                        }
                    }
                 });
 
            KritaUtils::makeContainerUnique(paintDevicesList);
            KritaUtils::makeContainerUnique(projectionsList);
 
            Q_FOREACH(KisPaintDeviceSP dev, paintDevicesList) {
                projectionsList.removeAll(dev);
 
                // all transactions will be linked to the final command via the
                // parent-child relationship
                m_transactions.emplace_back(dev, m_finalCommand.data(), -1, nullptr, KisTransaction::None);
            }
 
            // now, when the transactions are started, we can merge the two lists
            paintDevicesList << projectionsList;
            projectionsList.clear();
 
            Q_FOREACH (KisPaintDeviceSP device, paintDevicesList) {
                KritaUtils::addJobConcurrent(jobsData,
                    [device] () {
                        const_cast<KisPaintDevice*>(device.data())->purgeDefaultPixels();
                    });
            }
 
            addMutatedJobs(jobsData);
        }
 
        void finishStrokeCallback() override {
            for (auto it = m_transactions.begin(); it != m_transactions.end(); ++it) {
                QScopedPointer<KUndo2Command> cmd(it->endAndTake());
 
                // verify the transaction command is linked to m_finalCommand,
                // if not, just delete on return
                KIS_SAFE_ASSERT_RECOVER(cmd->hasParent()) { continue; }
 
                // if has a parent, release...
                (void)cmd.take();
            }
 
            m_transactions.clear();
 
            m_finalCommand->redo();
            m_image->postExecutionUndoAdapter()->addCommand(toQShared(m_finalCommand.take()));
 
            // now reset the thumbnail generation limitation
            KisLayerUtils::recursiveApplyNodes(m_image->root(),
                [](KisNodeSP node) {
                    if (node->preferredThumbnailBoundsMode() != KisThumbnailBoundsMode::Precise) {
                        node->setPreferredThumbnailBoundsMode(KisThumbnailBoundsMode::Precise);
                    }
                });
        }
 
    private:
        KisImageSP m_image;
        QScopedPointer<KUndo2Command> m_finalCommand;
        std::vector<KisTransaction> m_transactions;
    };
 
    KisStrokeId id = startStroke(new PurgeUnusedDataStroke(this, isCancellable));
    endStroke(id);
}

References KritaUtils::addJobConcurrent(), KisStrokeJobData::BARRIER, KisSharedPtr< T >::data(), KisStrokeJobData::EXCLUSIVE, KIS_SAFE_ASSERT_RECOVER, kundo2_i18n(), KritaUtils::makeContainerUnique(), KisTransaction::None, KisPaintDevice::purgeDefaultPixels(), KisLayerUtils::recursiveApplyNodes(), KisStrokeJobData::SEQUENTIAL, toQShared(), and void().

◆ refreshGraphAsync() [1/5]

void KisUpdatesFacade::refreshGraphAsync	(	KisNodeSP	root,
		const QRect &	rc,
		const QRect &	cropRect,
		KisProjectionUpdateFlags	flags = KisProjectionUpdateFlag::None )

Definition at line 54 of file kis_image_interfaces.cpp.

{
    refreshGraphAsync(root, QVector<QRect>({rc}), cropRect, flags);
}

◆ refreshGraphAsync() [2/5]

void KisUpdatesFacade::refreshGraphAsync	(	KisNodeSP	root,
		const QRect &	rc,
		KisProjectionUpdateFlags	flags = KisProjectionUpdateFlag::None )

Definition at line 53 of file kis_image_interfaces.cpp.

{
    refreshGraphAsync(root, rc, bounds(), flags);
}

◆ refreshGraphAsync() [3/5]

virtual void KisUpdatesFacade::refreshGraphAsync	(	KisNodeSP	root,
		const QVector< QRect > &	rc,
		const QRect &	cropRect,
		KisProjectionUpdateFlags	flags = KisProjectionUpdateFlag::None )

virtual

Implements KisUpdatesFacade.

◆ refreshGraphAsync() [4/5]

void KisImage::refreshGraphAsync	(	KisNodeSP	root,
		const QVector< QRect > &	rects,
		const QRect &	cropRect,
		KisProjectionUpdateFlags	flags = KisProjectionUpdateFlag::None )

overridevirtual

We cannot regenerate a pass-through group, since it is not present in the layers stack. Instead we should delegate this regeneration pass to the parent group.

We should also take into account the change rect of all the layers that lay above the "dirty" pass-through group (i.e. convert the change rect of the child into a change rect of the parent). That is required for a case, when there are adjustment layers laying above the pass-through group.

We iterate through the filters in a reversed way. It makes the most nested filters to execute first.

Implements KisUpdatesFacade.

Definition at line 2221 of file kis_image.cc.

{
    if (!root) root = m_d->rootLayer;
 
    QVector<QRect> requestedRects = rects;
 
    KisGroupLayer *group = dynamic_cast<KisGroupLayer*>(root.data());
    if (group && group->passThroughMode()) {
        QVector<QRect> changeRects = requestedRects;
        KisProjectionLeafSP leaf = root->projectionLeaf()->nextSibling();
        while (leaf) {
            if (leaf->shouldBeRendered()) {
                for (auto it = changeRects.begin(); it != changeRects.end(); ++it) {
                    *it = leaf->projectionPlane()->changeRect(*it, leaf->node() == root ? KisNode::N_FILTHY : KisNode::N_ABOVE_FILTHY);
                }
            }
 
            leaf = leaf->nextSibling();
        }
 
        std::swap(requestedRects, changeRects);
        root = group->parent();
 
        KIS_SAFE_ASSERT_RECOVER_RETURN(root);
    }
 
    for (auto it = m_d->projectionUpdatesFilters.rbegin();
         it != m_d->projectionUpdatesFilters.rend();
         ++it) {
 
        KIS_SAFE_ASSERT_RECOVER(*it) { continue; }
 
        if ((*it)->filterRefreshGraph(this, root.data(), requestedRects, cropRect, flags)) {
            return;
        }
    }
 
    if (!flags.testFlag(KisProjectionUpdateFlag::DontInvalidateFrames)) {
        m_d->animationInterface->notifyNodeChanged(root.data(), requestedRects, true);
    }
 
    m_d->scheduler.fullRefreshAsync(root, requestedRects, cropRect, flags);
}

References KisImage::KisImagePrivate::animationInterface, KisWeakSharedPtr< T >::data(), DontInvalidateFrames, KisUpdateScheduler::fullRefreshAsync(), KIS_SAFE_ASSERT_RECOVER, KIS_SAFE_ASSERT_RECOVER_RETURN, m_d, KisNode::N_ABOVE_FILTHY, KisNode::N_FILTHY, KisImageAnimationInterface::notifyNodeChanged(), KisNode::parent, KisGroupLayer::passThroughMode, KisNode::projectionLeaf, KisImage::KisImagePrivate::projectionUpdatesFilters, KisNodeFacade::root, KisImage::KisImagePrivate::rootLayer, and KisImage::KisImagePrivate::scheduler.

◆ refreshGraphAsync() [5/5]

void KisUpdatesFacade::refreshGraphAsync	(	KisNodeSP	root = nullptr,
		KisProjectionUpdateFlags	flags = KisProjectionUpdateFlag::None )

Definition at line 52 of file kis_image_interfaces.cpp.

{
    refreshGraphAsync(root, bounds(), bounds(), flags);
}

◆ refreshHiddenArea()

void KisImage::refreshHiddenArea	(	KisNodeSP	rootNode,
		const QRect &	preparedArea )

private

◆ removeAnnotation()

void KisImage::removeAnnotation ( const QString & type )

delete the annotation, if the image contains it

Definition at line 1920 of file kis_image.cc.

{
    vKisAnnotationSP_it it = m_d->annotations.begin();
    while (it != m_d->annotations.end()) {
        if ((*it)->type() == type) {
            m_d->annotations.erase(it);
            setModifiedWithoutUndo();
            return;
        }
        ++it;
    }
}

References KisImage::KisImagePrivate::annotations, m_d, and setModifiedWithoutUndo().

◆ removeComposition()

void KisImage::removeComposition ( KisLayerCompositionSP composition )

Remove the layer composition

Definition at line 2512 of file kis_image.cc.

{
    m_d->compositions.removeAll(composition);
}

References KisImage::KisImagePrivate::compositions, and m_d.

◆ removeProjectionUpdatesFilter()

KisProjectionUpdatesFilterSP KisImage::removeProjectionUpdatesFilter ( KisProjectionUpdatesFilterCookie cookie )

overridevirtual

removes already installed filter from the stack of updates filers

Parameters

cookie a cookie object returned by addProjectionUpdatesFilter() on installation

Returns: the installed filter. If the cookie is invalid, or nesting rule has been broken, then removeProjectionUpdatesFilter() may safe-assert and return nullptr.

NOTE: some weird code (e.g. KisRegenerateFrameStrokeStrategy) needs to temporary remove all the filters and then install them back. Current implementation ensures that after removal and the following installation, cookies will be preserved. So this operation is considered safe.

See also: addProjectionUpdatesFilter()

Implements KisUpdatesFacade.

Definition at line 2298 of file kis_image.cc.

{
    KIS_SAFE_ASSERT_RECOVER_NOOP(cookie);
    KIS_SAFE_ASSERT_RECOVER_NOOP(m_d->projectionUpdatesFilters.last() == cookie);
 
    auto it = std::find(m_d->projectionUpdatesFilters.begin(), m_d->projectionUpdatesFilters.end(), cookie);
    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(it != m_d->projectionUpdatesFilters.end(), KisProjectionUpdatesFilterSP());
 
    KisProjectionUpdatesFilterSP filter = *it;
 
    m_d->projectionUpdatesFilters.erase(it);
 
    return filter;
}

References KIS_SAFE_ASSERT_RECOVER_NOOP, KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, m_d, and KisImage::KisImagePrivate::projectionUpdatesFilters.

◆ requestProjectionUpdate()

void KisImage::requestProjectionUpdate	(	KisNode *	node,
		const QVector< QRect > &	rects,
		KisProjectionUpdateFlags	flags )

overridevirtual

Inform the model that a node has been changed (setDirty)

We iterate through the filters in a reversed way. It makes the most nested filters to execute first.

Here we use 'permitted' instead of 'active' intentively, because the updates may come after the actual stroke has been finished. And having some more updates for the stroke not supporting the wrap-around mode will not make much harm.

TODO: Remove the no-filthy condition. I have no idea, why it is present. Or replace it with an assert. (DK)

Reimplemented from KisNodeGraphListener.

Definition at line 2424 of file kis_image.cc.

{
    for (auto it = m_d->projectionUpdatesFilters.rbegin();
         it != m_d->projectionUpdatesFilters.rend();
         ++it) {
 
        KIS_SAFE_ASSERT_RECOVER(*it) { continue; }
 
        if ((*it)->filter(this, node, rects, flags)) {
            return;
        }
    }
 
    if (!flags.testFlag(KisProjectionUpdateFlag::DontInvalidateFrames)) {
        m_d->animationInterface->notifyNodeChanged(node, rects, false);
    }
 
    if (m_d->wrapAroundModePermitted && !flags.testFlag(KisProjectionUpdateFlag::NoFilthy)) {
        QVector<QRect> allSplitRects;
 
        const QRect boundRect = effectiveLodBounds();
        Q_FOREACH (const QRect &rc, rects) {
            KisWrappedRect splitRect(rc, boundRect, m_d->wrapAroundModeAxis);
            allSplitRects.append(splitRect);
        }
 
        m_d->requestProjectionUpdateImpl(node, allSplitRects, boundRect, flags);
 
    } else {
        m_d->requestProjectionUpdateImpl(node, rects, bounds(), flags);
    }
 
    KisNodeGraphListener::requestProjectionUpdate(node, rects, flags);
}

References KisImage::KisImagePrivate::animationInterface, bounds(), DontInvalidateFrames, effectiveLodBounds(), KIS_SAFE_ASSERT_RECOVER, m_d, NoFilthy, KisImageAnimationInterface::notifyNodeChanged(), KisImage::KisImagePrivate::projectionUpdatesFilters, KisNodeGraphListener::requestProjectionUpdate(), KisImage::KisImagePrivate::requestProjectionUpdateImpl(), KisImage::KisImagePrivate::wrapAroundModeAxis, and KisImage::KisImagePrivate::wrapAroundModePermitted.

◆ requestRedoDuringStroke

void KisImage::requestRedoDuringStroke ( )

slot

This method is called by the UI (not by the creator of the stroke) when it thinks the current stroke should redo its last undo, for example, when the user presses Ctrl+Shift+Z while some stroke is active.

If the creator of the stroke supports undoing/redoing of an intermediate actions, it will be notified about this request and can undo its last action.

Definition at line 2182 of file kis_image.cc.

{
    Q_EMIT sigRedoDuringStrokeRequested();
}

References sigRedoDuringStrokeRequested().

◆ requestStrokeCancellation

void KisImage::requestStrokeCancellation ( )

slot

This method is called by the UI (not by the creator of the stroke) when it thinks current stroke should be cancelled. If there is a running stroke that has already been detached from its creator (ended or cancelled), it will be forcefully cancelled and reverted. If there is an open stroke present, and if its creator supports cancelling, it will be notified about the request and the stroke will be cancelled

Definition at line 2187 of file kis_image.cc.

{
    if (!m_d->tryCancelCurrentStrokeAsync()) {
        Q_EMIT sigStrokeCancellationRequested();
    }
}

References m_d, sigStrokeCancellationRequested(), and KisImage::KisImagePrivate::tryCancelCurrentStrokeAsync().

◆ requestStrokeEnd

void KisImage::requestStrokeEnd ( )

slot

This method is called when image or some other part of Krita (not the creator of the stroke) decides that the stroke should be ended. If the creator of the stroke supports it, it will be notified and the stroke will be cancelled

Definition at line 2199 of file kis_image.cc.

{
    Q_EMIT sigStrokeEndRequested();
    Q_EMIT sigStrokeEndRequestedActiveNodeFiltered();
}

References sigStrokeEndRequested(), and sigStrokeEndRequestedActiveNodeFiltered().

◆ requestStrokeEndActiveNode

void KisImage::requestStrokeEndActiveNode ( )

slot

Same as requestStrokeEnd() but is called by view manager when the current node is changed. Use to distinguish sigStrokeEndRequested() and sigStrokeEndRequestedActiveNodeFiltered() which are used by KisNodeJugglerCompressed

Definition at line 2205 of file kis_image.cc.

{
    Q_EMIT sigStrokeEndRequested();
}

References sigStrokeEndRequested().

◆ requestTimeSwitch()

void KisImage::requestTimeSwitch ( int time )

overridevirtual

Reimplemented from KisNodeGraphListener.

Definition at line 2476 of file kis_image.cc.

{
    m_d->animationInterface->requestTimeSwitchNonGUI(time);
}

References KisImage::KisImagePrivate::animationInterface, m_d, and KisImageAnimationInterface::requestTimeSwitchNonGUI().

◆ requestUndoDuringStroke

void KisImage::requestUndoDuringStroke ( )

slot

This method is called by the UI (not by the creator of the stroke) when it thinks the current stroke should undo its last action, for example, when the user presses Ctrl+Z while some stroke is active.

If the creator of the stroke supports undoing of intermediate actions, it will be notified about this request and can undo its last action.

Definition at line 2177 of file kis_image.cc.

{
    Q_EMIT sigUndoDuringStrokeRequested();
}

References sigUndoDuringStrokeRequested().

◆ resizeImage()

void KisImage::resizeImage ( const QRect & newRect )

start asynchronous operation on resizing the image

The method will resize the image to fit the new size without dropping any pixel data. The GUI will get correct notification with old and new sizes, so it adjust canvas origin accordingly and avoid jumping of the canvas on screen

Parameters

newRect the rectangle of the image which will be visible after operation is completed

Please note that the actual operation starts asynchronously in a background, so you cannot expect the image having new size right after this call.

Definition at line 865 of file kis_image.cc.

{
    resizeImageImpl(newRect, false);
}

References resizeImageImpl().

◆ resizeImageImpl()

void KisImage::resizeImageImpl	(	const QRect &	newRect,
		bool	cropLayers )

private

Definition at line 834 of file kis_image.cc.

{
    if (newRect == bounds() && !cropLayers) return;
 
    KUndo2MagicString actionName = cropLayers ?
        kundo2_i18n("Crop Image") :
        kundo2_i18n("Resize Image");
 
    KisImageSignalVector emitSignals;
    emitSignals << ComplexSizeChangedSignal(newRect, newRect.size());
 
    KisCropSavedExtraData *extraData =
        new KisCropSavedExtraData(cropLayers ?
                                  KisCropSavedExtraData::CROP_IMAGE :
                                  KisCropSavedExtraData::RESIZE_IMAGE,
                                  newRect);
 
    KisProcessingApplicator applicator(this, m_d->rootLayer,
                                       KisProcessingApplicator::RECURSIVE |
                                       KisProcessingApplicator::NO_UI_UPDATES,
                                       emitSignals, actionName, extraData);
 
    if (cropLayers || !newRect.topLeft().isNull()) {
        KisProcessingVisitorSP visitor =
            new KisCropProcessingVisitor(newRect, cropLayers, true);
        applicator.applyVisitorAllFrames(visitor, KisStrokeJobData::CONCURRENT);
    }
    applicator.applyCommand(new KisImageResizeCommand(this, newRect.size()));
    applicator.end();
}

References bounds(), KisStrokeJobData::CONCURRENT, KisCropSavedExtraData::CROP_IMAGE, KisImageResizeCommand, kundo2_i18n(), m_d, KisProcessingApplicator::NO_UI_UPDATES, KisProcessingApplicator::RECURSIVE, KisCropSavedExtraData::RESIZE_IMAGE, and KisImage::KisImagePrivate::rootLayer.

◆ rootLayer()

KisGroupLayerSP KisImage::rootLayer ( ) const

Returns: the root node of the image node graph

Definition at line 1655 of file kis_image.cc.

{
    Q_ASSERT(m_d->rootLayer);
    return m_d->rootLayer;
}

References m_d, and KisImage::KisImagePrivate::rootLayer.

◆ rotateImage()

void KisImage::rotateImage ( double radians )

start asynchronous operation on rotating the image

The image is resized to fit the rotated rectangle

Parameters

radians rotation angle in radians

Please note that the actual operation starts asynchronously in a background, so you cannot expect the operation being completed right after the call

Definition at line 1216 of file kis_image.cc.

{
    rotateImpl(kundo2_i18n("Rotate Image"), root(), radians, true, 0);
}

References kundo2_i18n(), KisNodeFacade::root, and rotateImpl().

◆ rotateImpl() [1/2]

void KisImage::rotateImpl	(	const KUndo2MagicString &	actionName,
		KisNodeList	nodes,
		double	radians,
		bool	resizeImage,
		KisSelectionSP	selection )

private

Definition at line 1124 of file kis_image.cc.

{
    // we can either transform (and resize) the whole image or
    // transform a selection, we cannot do both at the same time
    KIS_SAFE_ASSERT_RECOVER(!(bool(selection) && resizeImage)) {
        selection = 0;
    }
 
    QRect baseBounds;
    if (resizeImage) {
        baseBounds = bounds();
    }
    else if (selection) {
        baseBounds = selection->selectedExactRect();
    }
    else {
        Q_FOREACH(KisNodeSP node, nodes) {
            baseBounds = baseBounds.united(node->exactBounds());
        }
    }
 
    QPointF offset;
    QSize newSize;
 
    {
        KisTransformWorker worker(0,
                                  1.0, 1.0,
                                  0, 0,
                                  radians,
                                  0, 0, 0, 0);
        QTransform transform = worker.transform();
 
        if (resizeImage) {
            QRect newRect = transform.mapRect(baseBounds);
            newSize = newRect.size();
            offset = -newRect.topLeft();
        }
        else {
            QPointF origin = QRectF(baseBounds).center();
 
            newSize = size();
            offset = -(transform.map(origin) - origin);
        }
    }
 
    bool sizeChanged = resizeImage &&
        (newSize.width() != baseBounds.width() ||
         newSize.height() != baseBounds.height());
 
    // These signals will be emitted after processing is done
    KisImageSignalVector emitSignals;
    if (sizeChanged) emitSignals << ComplexSizeChangedSignal(baseBounds, newSize);
 
    // These flags determine whether updates are transferred to the UI during processing
    KisProcessingApplicator::ProcessingFlags signalFlags =
        sizeChanged ?
        KisProcessingApplicator::NO_UI_UPDATES :
        KisProcessingApplicator::NONE;
 
 
    KisProcessingApplicator applicator(this, nodes,
                                       KisProcessingApplicator::RECURSIVE | signalFlags,
                                       emitSignals, actionName);
 
    KisFilterStrategy *filter = KisFilterStrategyRegistry::instance()->value("Bicubic");
 
    KisTransformProcessingVisitor *visitor =
            new KisTransformProcessingVisitor(1.0, 1.0, 0.0, 0.0,
                                              radians,
                                              offset.x(), offset.y(),
                                              filter);
    if (selection) {
        visitor->setSelection(selection);
    }
 
    if (selection) {
        applicator.applyVisitor(visitor, KisStrokeJobData::CONCURRENT);
    } else {
        applicator.applyVisitorAllFrames(visitor, KisStrokeJobData::CONCURRENT);
    }
 
    if (sizeChanged) {
        applicator.applyCommand(new KisImageResizeCommand(this, newSize));
    }
    applicator.end();
}

References KisProcessingApplicator::applyCommand(), KisProcessingApplicator::applyVisitor(), KisProcessingApplicator::applyVisitorAllFrames(), bounds(), KisStrokeJobData::CONCURRENT, KisProcessingApplicator::end(), KisBaseNode::exactBounds(), KisFilterStrategyRegistry::instance(), KIS_SAFE_ASSERT_RECOVER, KisImageResizeCommand, KisProcessingApplicator::NO_UI_UPDATES, KisProcessingApplicator::NONE, KisProcessingApplicator::RECURSIVE, resizeImage(), KisSelection::selectedExactRect(), KisTransformProcessingVisitor::setSelection(), size(), KisTransformWorker::transform(), and KoGenericRegistry< T >::value().

◆ rotateImpl() [2/2]

void KisImage::rotateImpl	(	const KUndo2MagicString &	actionName,
		KisNodeSP	rootNode,
		double	radians,
		bool	resizeImage,
		KisSelectionSP	selection )

private

Definition at line 1116 of file kis_image.cc.

{
    rotateImpl(actionName, KisNodeList{rootNode}, radians, resizeImage, selection);
}

References resizeImage(), and rotateImpl().

◆ rotateNode()

void KisImage::rotateNode	(	KisNodeSP	node,
		double	radians,
		KisSelectionSP	selection )

start asynchronous operation on rotating a subtree of nodes starting at node

The image is not resized!

Parameters

node	the root of the subtree to rotate
radians	rotation angle in radians
selection	the selection we based on

Please note that the actual operation starts asynchronously in a background, so you cannot expect the operation being completed right after the call

Definition at line 1221 of file kis_image.cc.

{
    rotateNodes(KisNodeList{node}, radians, selection);
}

References rotateNodes().

◆ rotateNodes()

void KisImage::rotateNodes	(	KisNodeList	nodes,
		double	radians,
		KisSelectionSP	selection )

Definition at line 1225 of file kis_image.cc.

{
    if (nodes.size() == 1 && nodes[0]->inherits("KisMask")) {
        rotateImpl(kundo2_i18n("Rotate Mask"), nodes, radians, false, selection);
    }
    else {
        rotateImpl(kundo2_i18np("Rotate Layer", "Rotate %1 Layers", nodes.size()), nodes, radians, false, selection);
    }
}

References kundo2_i18n(), kundo2_i18np(), and rotateImpl().

◆ safeRemoveTwoNodes()

void KisImage::safeRemoveTwoNodes	(	KisNodeSP	node1,
		KisNodeSP	node2 )

private

◆ scaleImage()

void KisImage::scaleImage	(	const QSize &	size,
		qreal	xres,
		qreal	yres,
		KisFilterStrategy *	filterStrategy )

start asynchronous operation on scaling the image

Parameters

size	new image size in pixels
xres	new image x-resolution pixels-per-pt
yres	new image y-resolution pixels-per-pt
filterStrategy	filtering strategy

Please note that the actual operation starts asynchronously in a background, so you cannot expect the image having new size right after this call.

Definition at line 1016 of file kis_image.cc.

{
    bool resolutionChanged = !qFuzzyCompare(xRes(), xres) || !qFuzzyCompare(yRes(), yres);
    bool sizeChanged = size != this->size();
 
    if (!resolutionChanged && !sizeChanged) return;
 
    KisImageSignalVector emitSignals;
    if (resolutionChanged) emitSignals << ResolutionChangedSignal;
    if (sizeChanged) emitSignals << ComplexSizeChangedSignal(bounds(), size);
 
    KUndo2MagicString actionName = sizeChanged ?
        kundo2_i18n("Scale Image") :
        kundo2_i18n("Change Image Resolution");
 
    KisProcessingApplicator::ProcessingFlags signalFlags =
        (resolutionChanged || sizeChanged) ?
                KisProcessingApplicator::NO_UI_UPDATES :
                KisProcessingApplicator::NONE;
 
    KisProcessingApplicator applicator(this, m_d->rootLayer,
                                       KisProcessingApplicator::RECURSIVE | signalFlags,
                                       emitSignals, actionName);
 
    qreal sx = qreal(size.width()) / this->size().width();
    qreal sy = qreal(size.height()) / this->size().height();
 
    QTransform shapesCorrection;
 
    if (resolutionChanged) {
        shapesCorrection = QTransform::fromScale(xRes() / xres, yRes() / yres);
    }
 
    KisProcessingVisitorSP visitor =
        new KisTransformProcessingVisitor(sx, sy,
                                          0, 0,
                                          0,
                                          0, 0,
                                          filterStrategy,
                                          shapesCorrection);
 
    applicator.applyVisitorAllFrames(visitor, KisStrokeJobData::CONCURRENT);
 
    if (resolutionChanged) {
        KUndo2Command *parent =
            new KisResetShapesCommand(m_d->rootLayer);
        new KisImageSetResolutionCommand(this, xres, yres, parent);
        applicator.applyCommand(parent);
    }
 
    if (sizeChanged) {
        applicator.applyCommand(new KisImageResizeCommand(this, size));
    }
 
    applicator.end();
}

References KisProcessingApplicator::applyCommand(), KisProcessingApplicator::applyVisitorAllFrames(), bounds(), KisStrokeJobData::CONCURRENT, KisProcessingApplicator::end(), KisImageResizeCommand, kundo2_i18n(), m_d, KisProcessingApplicator::NO_UI_UPDATES, KisProcessingApplicator::NONE, qFuzzyCompare(), KisProcessingApplicator::RECURSIVE, ResolutionChangedSignal, KisImage::KisImagePrivate::rootLayer, size(), xRes(), and yRes().

◆ scaleNode()

void KisImage::scaleNode	(	KisNodeSP	node,
		const QPointF &	center,
		qreal	scaleX,
		qreal	scaleY,
		KisFilterStrategy *	filterStrategy,
		KisSelectionSP	selection )

start asynchronous operation on scaling a subtree of nodes starting at node

Parameters

node	node to scale
center	the center of the scaling
scaleX	x-scale coefficient to be applied to the node
scaleY	y-scale coefficient to be applied to the node
filterStrategy	filtering strategy
selection	the selection we based on

Please note that the actual operation starts asynchronously in a background, so you cannot expect the image having new size right after this call.

Definition at line 1073 of file kis_image.cc.

{
    scaleNodes(KisNodeList{node}, center, scaleX, scaleY, filterStrategy, selection);
}

References scaleNodes().

◆ scaleNodes()

void KisImage::scaleNodes	(	KisNodeList	nodes,
		const QPointF &	center,
		qreal	scaleX,
		qreal	scaleY,
		KisFilterStrategy *	filterStrategy,
		KisSelectionSP	selection )

Definition at line 1077 of file kis_image.cc.

{
    KUndo2MagicString actionName(kundo2_i18np("Scale Layer", "Scale %1 Layers", nodes.size()));
    KisImageSignalVector emitSignals;
 
    QPointF offset;
    {
        KisTransformWorker worker(0,
                                  scaleX, scaleY,
                                  0, 0,
                                  0.0,
                                  0, 0, 0, 0);
        QTransform transform = worker.transform();
 
        offset = center - transform.map(center);
    }
 
    KisProcessingApplicator applicator(this, nodes,
                                       KisProcessingApplicator::RECURSIVE,
                                       emitSignals, actionName);
 
    KisTransformProcessingVisitor *visitor =
        new KisTransformProcessingVisitor(scaleX, scaleY,
                                          0, 0,
                                          0,
                                          offset.x(), offset.y(),
                                          filterStrategy);
 
    visitor->setSelection(selection);
 
    if (selection) {
        applicator.applyVisitor(visitor, KisStrokeJobData::CONCURRENT);
    } else {
        applicator.applyVisitorAllFrames(visitor, KisStrokeJobData::CONCURRENT);
    }
 
    applicator.end();
}

References KisProcessingApplicator::applyVisitor(), KisProcessingApplicator::applyVisitorAllFrames(), KisStrokeJobData::CONCURRENT, KisProcessingApplicator::end(), kundo2_i18np(), KisProcessingApplicator::RECURSIVE, KisTransformProcessingVisitor::setSelection(), and KisTransformWorker::transform().

◆ setAllowMasksOnRootNode()

void KisImage::setAllowMasksOnRootNode ( bool value )

Configure the image to allow masks on the root not (as reported by root()->allowAsChild()). By default it is not allowed (because it looks weird from GUI point of view)

Definition at line 2671 of file kis_image.cc.

{
    m_d->allowMasksOnRootNode = value;
}

References KisImage::KisImagePrivate::allowMasksOnRootNode, m_d, and value().

◆ setDefaultProjectionColor()

void KisImage::setDefaultProjectionColor ( const KoColor & color )

Sets the default color of the root layer projection. All the layers will be merged on top of this very color

Definition at line 1850 of file kis_image.cc.

{
    KIS_ASSERT_RECOVER_RETURN(m_d->rootLayer);
    m_d->rootLayer->setDefaultProjectionColor(color);
}

References KIS_ASSERT_RECOVER_RETURN, m_d, KisImage::KisImagePrivate::rootLayer, and KisGroupLayer::setDefaultProjectionColor().

◆ setLodPreferences()

void KisImage::setLodPreferences ( const KisLodPreferences & value )

Set preferences for the level-of-detail functionality. Due to multithreading considerations they may be applied not immediately, but some time later.

Definition at line 2618 of file kis_image.cc.

{
    m_d->scheduler.setLodPreferences(value);
}

References m_d, KisImage::KisImagePrivate::scheduler, KisUpdateScheduler::setLodPreferences(), and value().

◆ setMirrorAxesCenter()

void KisImage::setMirrorAxesCenter ( const QPointF & value ) const

Sets the relative position of the axes center

See also: mirrorAxesCenter() for details

Definition at line 2666 of file kis_image.cc.

{
    m_d->axesCenter = value;
}

References KisImage::KisImagePrivate::axesCenter, m_d, and value().

◆ setModifiedWithoutUndo()

void KisImage::setModifiedWithoutUndo ( )

Tell the image it's modified without creation of an undo command. It may happen when e.g. layer visibility has changed.

This function emits both, sigImageModified() and sigImageModifiedWithoutUndo()

For normal modifications with undo information the signal emission is triggered by the undo stack

Definition at line 1728 of file kis_image.cc.

{
    m_d->signalRouter.emitNotification(ModifiedWithoutUndoSignal);
    Q_EMIT sigImageModified();
}

References KisImageSignalRouter::emitNotification(), m_d, ModifiedWithoutUndoSignal, sigImageModified(), and KisImage::KisImagePrivate::signalRouter.

◆ setOverlaySelectionMask()

void KisImage::setOverlaySelectionMask ( KisSelectionMaskSP mask )

Sets the mask (it must be a part of the node hierarchy already) to be painted on the top of all layers. This method does all the locking and syncing for you. It is executed asynchronously.

Definition at line 637 of file kis_image.cc.

{
    if (m_d->targetOverlaySelectionMask == mask) return;
 
    m_d->targetOverlaySelectionMask = mask;
 
    struct UpdateOverlaySelectionStroke : public KisSimpleStrokeStrategy {
        UpdateOverlaySelectionStroke(KisImageSP image)
            : KisSimpleStrokeStrategy(QLatin1String("update-overlay-selection-mask"), kundo2_noi18n("update-overlay-selection-mask")),
              m_image(image)
        {
            this->enableJob(JOB_INIT, true, KisStrokeJobData::BARRIER, KisStrokeJobData::EXCLUSIVE);
            setClearsRedoOnStart(false);
        }
 
        void initStrokeCallback() override {
            KisSelectionMaskSP oldMask = m_image->m_d->overlaySelectionMask;
            KisSelectionMaskSP newMask = m_image->m_d->targetOverlaySelectionMask;
            if (oldMask == newMask) return;
 
            KIS_SAFE_ASSERT_RECOVER_RETURN(!newMask || static_cast<KisImage*>(newMask->graphListener()) == m_image);
 
            m_image->m_d->overlaySelectionMask = newMask;
 
            if (oldMask || newMask) {
                m_image->m_d->rootLayer->notifyChildMaskChanged();
            }
 
            if (oldMask) {
                const QRect oldMaskRect = oldMask->graphListener() ? oldMask->extent() : m_image->bounds();
                m_image->m_d->rootLayer->setDirtyDontResetAnimationCache(oldMaskRect);
            }
 
            if (newMask) {
                newMask->setDirty();
            }
 
            m_image->undoAdapter()->emitSelectionChanged();
        }
 
    private:
        KisImageSP m_image;
    };
 
    KisStrokeId id = startStroke(new UpdateOverlaySelectionStroke(this));
    endStroke(id);
}

References KisStrokeJobData::BARRIER, endStroke(), KisStrokeJobData::EXCLUSIVE, KisSelectionMask::extent(), KisNode::graphListener, KIS_SAFE_ASSERT_RECOVER_RETURN, kundo2_noi18n(), m_d, KisSelectionMask::m_d, KisSelectionMask::setDirty(), startStroke(), and KisImage::KisImagePrivate::targetOverlaySelectionMask.

◆ setProjectionColorSpace()

void KisImage::setProjectionColorSpace ( const KoColorSpace * colorSpace )

private

Definition at line 1574 of file kis_image.cc.

{
    m_d->colorSpace = colorSpace;
}

References KisImage::KisImagePrivate::colorSpace, colorSpace(), and m_d.

◆ setProofingConfiguration()

void KisImage::setProofingConfiguration ( KisProofingConfigurationSP proofingConfig )

setProofingConfiguration, this sets the image's proofing configuration, and signals the proofingConfiguration has changed.

Parameters

proofingConfig - the kis proofing config that will be used instead.

Definition at line 2639 of file kis_image.cc.

{
    const bool changed = bool(m_d->proofingConfig) != bool(proofingConfig) ||
        (m_d->proofingConfig && proofingConfig && *m_d->proofingConfig != *proofingConfig);
 
    // we still assign even when unchanged since they can be different
    // shared pointer objects
    m_d->proofingConfig = proofingConfig;
 
    if (changed) {
        Q_EMIT sigProofingConfigChanged();
    }
}

References m_d, KisImage::KisImagePrivate::proofingConfig, and sigProofingConfigChanged().

◆ setResolution()

void KisImage::setResolution	(	double	xres,
		double	yres )

Set the resolution in pixels per pt.

Definition at line 1599 of file kis_image.cc.

{
    if (xres > 0) {
        m_d->xres = xres;
    } else {
        qWarning() << "WARNING: Ignoring attempt to set image x resolution <= 0 (" << xres << ")!";
    }
 
    if (yres > 0) {
        m_d->yres = yres;
    } else {
        qWarning() << "WARNING: Ignoring attempt to set image y resolution <= 0 (" << yres << ")!";
    }
}

References m_d, KisImage::KisImagePrivate::xres, and KisImage::KisImagePrivate::yres.

◆ setRootLayer()

void KisImage::setRootLayer ( KisGroupLayerSP rootLayer )

Definition at line 1865 of file kis_image.cc.

{
    Q_EMIT sigInternalStopIsolatedModeRequested();
 
    KoColor defaultProjectionColor = KoColor::createTransparent(m_d->colorSpace);
 
    if (m_d->rootLayer) {
        m_d->rootLayer->setGraphListener(0);
        m_d->rootLayer->setImage(0);
        m_d->rootLayer->disconnect();
 
        KisPaintDeviceSP original = m_d->rootLayer->original();
        defaultProjectionColor = original->defaultPixel();
    }
 
    m_d->rootLayer = rootLayer;
    m_d->rootLayer->disconnect();
    m_d->rootLayer->setGraphListener(this);
    m_d->rootLayer->setImage(this);
 
    setRoot(m_d->rootLayer.data());
    this->setDefaultProjectionColor(defaultProjectionColor);
}

References KisImage::KisImagePrivate::colorSpace, KoColor::createTransparent(), KisSharedPtr< T >::data(), KisPaintDevice::defaultPixel(), defaultProjectionColor(), m_d, KisGroupLayer::original(), KisImage::KisImagePrivate::rootLayer, rootLayer(), setDefaultProjectionColor(), KisNode::setGraphListener(), KisGroupLayer::setImage(), KisNodeFacade::setRoot(), and sigInternalStopIsolatedModeRequested().

◆ setSize()

void KisImage::setSize ( const QSize & size )

private

Definition at line 828 of file kis_image.cc.

{
    m_d->width = size.width();
    m_d->height = size.height();
}

References KisImage::KisImagePrivate::height, m_d, size(), and KisImage::KisImagePrivate::width.

◆ setUndoStore()

void KisImage::setUndoStore ( KisUndoStore * undoStore )

Replace current undo store with the new one. The old store will be deleted. This method is used by KisDocument for dropping all the commands during file loading.

Definition at line 1828 of file kis_image.cc.

{
    disconnect(m_d->undoStore.data(), SIGNAL(historyStateChanged()), &m_d->signalRouter, SLOT(emitImageModifiedNotification()));
 
    m_d->legacyUndoAdapter.setUndoStore(undoStore);
    m_d->postExecutionUndoAdapter.setUndoStore(undoStore);
    m_d->undoStore.reset(undoStore);
 
    connect(m_d->undoStore.data(), SIGNAL(historyStateChanged()), &m_d->signalRouter, SLOT(emitImageModifiedNotification()));
 
}

References KisImage::KisImagePrivate::legacyUndoAdapter, m_d, KisImage::KisImagePrivate::postExecutionUndoAdapter, KisPostExecutionUndoAdapter::setUndoStore(), KisUndoAdapter::setUndoStore(), KisImage::KisImagePrivate::signalRouter, KisImage::KisImagePrivate::undoStore, and undoStore().

◆ setWorkingThreadsLimit()

void KisImage::setWorkingThreadsLimit ( int value )

Set the number of threads used by the image's working threads

Definition at line 2382 of file kis_image.cc.

{
    m_d->scheduler.setThreadsLimit(value);
}

References m_d, KisImage::KisImagePrivate::scheduler, KisUpdateScheduler::setThreadsLimit(), and value().

◆ setWrapAroundModeAxis()

void KisImage::setWrapAroundModeAxis ( WrapAroundAxis value )

Set which axis to use for wraparound mode

Definition at line 2582 of file kis_image.cc.

{
    m_d->wrapAroundModeAxis = value;
}

References m_d, value(), and KisImage::KisImagePrivate::wrapAroundModeAxis.

◆ setWrapAroundModePermitted()

void KisImage::setWrapAroundModePermitted ( bool value )

Permit or deny the wrap-around mode for all the paint devices of the image. Note that permitting the wraparound mode will not necessarily activate it right now. To be activated the wrap around mode should be 1) permitted; 2) supported by the currently running stroke.

Definition at line 2558 of file kis_image.cc.

{
    if (m_d->wrapAroundModePermitted != value) {
        requestStrokeEnd();
    }
 
    m_d->wrapAroundModePermitted = value;
 
    if (m_d->wrapAroundModePermitted &&
        checkMasksNeedConversion(root(), bounds())) {
 
        KisProcessingApplicator applicator(this, root(),
                                           KisProcessingApplicator::RECURSIVE,
                                           KisImageSignalVector(),
                                           kundo2_i18n("Crop Selections"));
 
        KisProcessingVisitorSP visitor =
            new KisCropSelectionsProcessingVisitor(bounds());
 
        applicator.applyVisitor(visitor, KisStrokeJobData::CONCURRENT);
        applicator.end();
    }
}

References KisProcessingApplicator::applyVisitor(), bounds(), checkMasksNeedConversion(), KisStrokeJobData::CONCURRENT, KisProcessingApplicator::end(), kundo2_i18n(), m_d, KisProcessingApplicator::RECURSIVE, requestStrokeEnd(), KisNodeFacade::root, value(), and KisImage::KisImagePrivate::wrapAroundModePermitted.

◆ shear()

void KisImage::shear	(	double	angleX,
		double	angleY )

start asynchronous operation on shearing the image

The image is resized to fit the sheared polygon

angleX, angleY are given in degrees.

Please note that the actual operation starts asynchronously in a background, so you cannot expect the operation being completed right after the call

Definition at line 1341 of file kis_image.cc.

{
    shearImpl(kundo2_i18n("Shear Image"), m_d->rootLayer, true,
              angleX, angleY, 0);
}

References kundo2_i18n(), m_d, KisImage::KisImagePrivate::rootLayer, and shearImpl().

◆ shearImpl() [1/2]

void KisImage::shearImpl	(	const KUndo2MagicString &	actionName,
		KisNodeList	nodes,
		bool	resizeImage,
		double	angleX,
		double	angleY,
		KisSelectionSP	selection )

private

Definition at line 1243 of file kis_image.cc.

{
    QRect baseBounds;
    if (resizeImage) {
        baseBounds = bounds();
    }
    else if (selection) {
        baseBounds = selection->selectedExactRect();
    }
    else {
        Q_FOREACH(KisNodeSP node, nodes) {
            baseBounds = baseBounds.united(node->exactBounds());
        }
    }
    const QPointF origin = QRectF(baseBounds).center();
 
    //angleX, angleY are in degrees
    const qreal pi = 3.1415926535897932385;
    const qreal deg2rad = pi / 180.0;
 
    qreal tanX = tan(angleX * deg2rad);
    qreal tanY = tan(angleY * deg2rad);
 
    QPointF offset;
    QSize newSize;
 
    {
        KisTransformWorker worker(0,
                                  1.0, 1.0,
                                  tanX, tanY,
                                  0,
                                  0, 0, 0, 0);
 
        QRect newRect = worker.transform().mapRect(baseBounds);
        newSize = newRect.size();
        if (resizeImage) offset = -newRect.topLeft();
        else offset = origin - worker.transform().map(origin);
    }
 
    if (newSize == baseBounds.size()) return;
 
    KisImageSignalVector emitSignals;
    if (resizeImage) emitSignals << ComplexSizeChangedSignal(baseBounds, newSize);
 
    KisProcessingApplicator::ProcessingFlags signalFlags =
        KisProcessingApplicator::RECURSIVE;
    if (resizeImage) signalFlags |= KisProcessingApplicator::NO_UI_UPDATES;
 
    KisProcessingApplicator applicator(this, nodes,
                                       signalFlags,
                                       emitSignals, actionName);
 
    KisFilterStrategy *filter = KisFilterStrategyRegistry::instance()->value("Bilinear");
 
    KisTransformProcessingVisitor *visitor =
            new KisTransformProcessingVisitor(1.0, 1.0,
                                              tanX, tanY,
                                              0,
                                              offset.x(), offset.y(),
                                              filter);
 
    if (selection) {
        visitor->setSelection(selection);
    }
 
    if (selection) {
        applicator.applyVisitor(visitor, KisStrokeJobData::CONCURRENT);
    } else {
        applicator.applyVisitorAllFrames(visitor, KisStrokeJobData::CONCURRENT);
    }
 
    if (resizeImage) {
        applicator.applyCommand(new KisImageResizeCommand(this, newSize));
    }
 
    applicator.end();
}

References KisProcessingApplicator::applyCommand(), KisProcessingApplicator::applyVisitor(), KisProcessingApplicator::applyVisitorAllFrames(), bounds(), KisStrokeJobData::CONCURRENT, KisProcessingApplicator::end(), KisBaseNode::exactBounds(), KisFilterStrategyRegistry::instance(), KisImageResizeCommand, KisProcessingApplicator::NO_UI_UPDATES, KisProcessingApplicator::RECURSIVE, resizeImage(), KisSelection::selectedExactRect(), KisTransformProcessingVisitor::setSelection(), KisTransformWorker::transform(), and KoGenericRegistry< T >::value().

◆ shearImpl() [2/2]

void KisImage::shearImpl	(	const KUndo2MagicString &	actionName,
		KisNodeSP	rootNode,
		bool	resizeImage,
		double	angleX,
		double	angleY,
		KisSelectionSP	selection )

private

Definition at line 1235 of file kis_image.cc.

{
    shearImpl(actionName, KisNodeList{rootNode}, resizeImage, angleX, angleY, selection);
}

References resizeImage(), and shearImpl().

◆ shearNode()

void KisImage::shearNode	(	KisNodeSP	node,
		double	angleX,
		double	angleY,
		KisSelectionSP	selection )

start asynchronous operation on shearing a subtree of nodes starting at node

The image is not resized!

Parameters

node	the root of the subtree to rotate
angleX	x-shear given in degrees.
angleY	y-shear given in degrees.
selection	the selection we based on

Please note that the actual operation starts asynchronously in a background, so you cannot expect the operation being completed right after the call

Definition at line 1325 of file kis_image.cc.

{
    shearNodes(KisNodeList{node}, angleX, angleY, selection);
}

References shearNodes().

◆ shearNodes()

void KisImage::shearNodes	(	KisNodeList	nodes,
		double	angleX,
		double	angleY,
		KisSelectionSP	selection )

Definition at line 1329 of file kis_image.cc.

{
    if (nodes.size() == 1 && nodes[0]->inherits("KisMask")) {
        shearImpl(kundo2_i18n("Shear Mask"), nodes, false,
                  angleX, angleY, selection);
    }
    else {
        shearImpl(kundo2_i18np("Shear Layer", "Shear %1 Layers", nodes.size()), nodes, false,
                  angleX, angleY, selection);
    }
}

References kundo2_i18n(), kundo2_i18np(), and shearImpl().

◆ sigAboutToBeDeleted

void KisImage::sigAboutToBeDeleted ( )

signal

Inform that the image is going to be deleted

◆ sigColorSpaceChanged

void KisImage::sigColorSpaceChanged ( const KoColorSpace * cs )

signal

◆ sigImageModified

void KisImage::sigImageModified ( )

signal

Emitted whenever the image has been modified, so that it doesn't match with the version saved on disk.

◆ sigImageModifiedWithoutUndo

void KisImage::sigImageModifiedWithoutUndo ( )

signal

Emitted whenever the image has been modified without creation of an undo command

◆ sigImageUpdated

void KisImage::sigImageUpdated ( const QRect & )

signal

Emitted whenever an action has caused the image to be recomposited. Parameter is the rect that has been recomposited.

◆ sigInternalStopIsolatedModeRequested

void KisImage::sigInternalStopIsolatedModeRequested ( )

signal

Internal signal for asynchronously requesting isolated mode to stop. Don't use it outside KisImage, use sigIsolatedModeChanged() instead.

◆ sigIsolatedModeChanged

void KisImage::sigIsolatedModeChanged ( )

signal

Emitted when the isolated mode status has changed.

Can be used by the receivers to catch a fact of forcefully stopping the isolated mode by the image when some complex action was requested

◆ sigLayersChangedAsync

void KisImage::sigLayersChangedAsync ( )

signal

Emitted when the root node of the image has changed. It happens, e.g. when we flatten the image. When this happens the receiver should reload information about the image

◆ signalRouter()

KisImageSignalRouter * KisImage::signalRouter ( )

Definition at line 1948 of file kis_image.cc.

{
    return &m_d->signalRouter;
}

References m_d, and KisImage::KisImagePrivate::signalRouter.

◆ sigNodeAddedAsync

void KisImage::sigNodeAddedAsync	(	KisNodeSP	node,
		KisNodeAdditionFlags	flags )

signal

The signal is emitted right after a node has been connected to the graph of the nodes.

WARNING: you must not request any graph-related information about the node being run in a not-scheduler thread. If you need information about the parent/siblings of the node connect with Qt::DirectConnection, get needed information and then Q_EMIT another Qt::AutoConnection signal to pass this information to your thread. See details of the implementation in KisDummiesfacadeBase.

◆ sigNodeChanged

void KisImage::sigNodeChanged ( KisNodeSP node )

signal

Inform the model that a node was changed

◆ sigNodeCollapsedChanged

void KisImage::sigNodeCollapsedChanged ( )

signal

Emitted when one or more nodes changed the collapsed state

◆ sigProfileChanged

void KisImage::sigProfileChanged ( const KoColorProfile * profile )

signal

◆ sigProofingConfigChanged

void KisImage::sigProofingConfigChanged ( )

signal

Emitted when the proofing configuration of the image is being changed.

◆ sigRedoDuringStrokeRequested

void KisImage::sigRedoDuringStrokeRequested ( )

signal

Emitted when the UI has requested the redo of the last undo operation.

If your tool supports undoing/redoing part of its work, just listen to this signal and undo when it comes

◆ sigRemoveNodeAsync

void KisImage::sigRemoveNodeAsync ( KisNodeSP node )

signal

This signal is emitted right before a node is going to removed from the graph of the nodes.

WARNING: you must not request any graph-related information about the node being run in a not-scheduler thread.

See also: comment in sigNodeAddedAsync()

◆ sigRequestNodeReselection

void KisImage::sigRequestNodeReselection	(	KisNodeSP	activeNode,
		const KisNodeList &	selectedNodes )

signal

◆ sigResolutionChanged

void KisImage::sigResolutionChanged	(	double	xRes,
		double	yRes )

signal

◆ sigSizeChanged

void KisImage::sigSizeChanged	(	const QPointF &	oldStillPoint,
		const QPointF &	newStillPoint )

signal

The signal is emitted when the size of the image is changed. oldStillPoint and newStillPoint give the receiver the hint about how the new and old rect of the image correspond to each other. They specify the point of the image around which the conversion was done. This point will stay still on the user's screen. That is the newStillPoint of the new image will be painted at the same screen position, where oldStillPoint of the old image was painted.

Parameters

oldStillPoint	is a still point represented in old image coordinates
newStillPoint	is a still point represented in new image coordinates

◆ sigStrokeCancellationRequested

void KisImage::sigStrokeCancellationRequested ( )

signal

Emitted when the UI has requested the cancellation of the stroke. The point is, we cannot cancel the stroke without its creator knowing about it (which most probably cause a crash), so we just forward this request from the UI to the creator of the stroke.

If your tool supports cancelling of its work in the middle of operation, just listen to this signal and cancel the stroke when it comes

◆ sigStrokeEndRequested

void KisImage::sigStrokeEndRequested ( )

signal

Emitted when the image decides that the stroke should better be ended. The point is, we cannot just end the stroke without its creator knowing about it (which most probably cause a crash), so we just forward this request from the UI to the creator of the stroke.

If your tool supports long strokes that may involve multiple mouse actions in one stroke, just listen to this signal and end the stroke when it comes.

◆ sigStrokeEndRequestedActiveNodeFiltered

void KisImage::sigStrokeEndRequestedActiveNodeFiltered ( )

signal

Same as sigStrokeEndRequested() but is not emitted when the active node is changed.

◆ sigUndoDuringStrokeRequested

void KisImage::sigUndoDuringStrokeRequested ( )

signal

Emitted when the UI has requested the undo of the last stroke's operation. The point is, we cannot deal with the internals of the stroke without its creator knowing about it (which most probably cause a crash), so we just forward this request from the UI to the creator of the stroke.

If your tool supports undoing part of its work, just listen to this signal and undo when it comes

◆ size()

QSize KisImage::size ( ) const

inline

Return the size of the image

Definition at line 547 of file kis_image.h.

                       {
        return QSize(width(), height());
    }

◆ startIsolatedMode()

bool KisImage::startIsolatedMode	(	KisNodeSP	node,
		bool	isolateLayer,
		bool	isolateGroup )

Isolation of transform masks is not possible, so we should not allow that

Definition at line 1993 of file kis_image.cc.

{
    m_d->isolateLayer = isolateLayer;
    m_d->isolateGroup = isolateGroup;
    if ((isolateLayer || isolateGroup) == false) return false;
 
    if (!node->projection()) return false;
 
    struct StartIsolatedModeStroke : public KisRunnableBasedStrokeStrategy {
        StartIsolatedModeStroke(KisNodeSP node, KisImageSP image, bool isolateLayer, bool isolateGroup)
            : KisRunnableBasedStrokeStrategy(QLatin1String("start-isolated-mode"),
                                             kundo2_noi18n("start-isolated-mode")),
              m_newRoot(node),
              m_image(image),
              m_isolateLayer(isolateLayer),
              m_isolateGroup(isolateGroup)
        {
            this->enableJob(JOB_INIT, true, KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::EXCLUSIVE);
            this->enableJob(JOB_DOSTROKE, true);
            this->enableJob(JOB_FINISH, true, KisStrokeJobData::BARRIER);
            setClearsRedoOnStart(false);
        }
 
        void initStrokeCallback() override {
            if (m_isolateLayer == false && m_isolateGroup == true) {
                // Isolate parent node unless node is the root note.
                m_newRoot = m_newRoot->parent() ? m_newRoot->parent() : m_newRoot;
            }
            // pass-though node don't have any projection prepared, so we should
            // explicitly regenerate it before activating isolated mode.
            m_newRoot->projectionLeaf()->explicitlyRegeneratePassThroughProjection();
            m_prevRoot = m_image->m_d->isolationRootNode;
 
            const bool beforeVisibility = m_newRoot->projectionLeaf()->visible();
            const bool prevRootBeforeVisibility = m_prevRoot ? m_prevRoot->projectionLeaf()->visible() : false;
 
            m_image->m_d->isolationRootNode = m_newRoot;
            Q_EMIT m_image->sigIsolatedModeChanged();
 
            const bool afterVisibility = m_newRoot->projectionLeaf()->visible();
            const bool prevRootAfterVisibility = m_prevRoot ? m_prevRoot->projectionLeaf()->visible() : false;
 
            m_newRootNeedsFullRefresh = beforeVisibility != afterVisibility;
            m_prevRootNeedsFullRefresh = prevRootBeforeVisibility != prevRootAfterVisibility;
        }
 
        void finishStrokeCallback() override {
            // the GUI uses our thread to do the color space conversion so we
            // need to Q_EMIT this signal in multiple threads
 
            if (m_prevRoot && m_prevRootNeedsFullRefresh) {
                m_image->refreshGraphAsync(m_prevRoot);
            }
 
            if (m_newRootNeedsFullRefresh) {
                m_image->refreshGraphAsync(m_newRoot);
            }
 
            if (!m_prevRootNeedsFullRefresh && !m_newRootNeedsFullRefresh) {
                QVector<KisRunnableStrokeJobData*> jobs;
                m_image->m_d->notifyProjectionUpdatedInPatches(m_image->bounds(), jobs);
                this->runnableJobsInterface()->addRunnableJobs(jobs);
            }
 
            m_image->invalidateAllFrames();
        }
 
    private:
        KisNodeSP m_newRoot;
        KisNodeSP m_prevRoot;
        KisImageSP m_image;
        bool m_newRootNeedsFullRefresh = false;
        bool m_prevRootNeedsFullRefresh = false;
 
        bool m_isolateLayer;
        bool m_isolateGroup;
    };
 
    KisStrokeId id = startStroke(new StartIsolatedModeStroke(node, this, isolateLayer, isolateGroup));
    endStroke(id);
 
    return true;
}

References KisStrokeJobData::BARRIER, endStroke(), KisStrokeJobData::EXCLUSIVE, KisImage::KisImagePrivate::isolateGroup, KisImage::KisImagePrivate::isolateLayer, kundo2_noi18n(), m_d, KisBaseNode::projection(), KisStrokeJobData::SEQUENTIAL, and startStroke().

◆ startStroke()

KisStrokeId KisImage::startStroke ( KisStrokeStrategy * strokeStrategy )

overridevirtual

Ask open strokes to end gracefully. All the strokes clients (including the one calling this method right now) will get a notification that they should probably end their strokes. However this is purely their choice whether to end a stroke or not.

Implements KisStrokesFacade.

Definition at line 1961 of file kis_image.cc.

{
    if (strokeStrategy->requestsOtherStrokesToEnd()) {
        requestStrokeEnd();
    }
 
    return m_d->scheduler.startStroke(strokeStrategy);
}

References m_d, KisStrokeStrategy::requestsOtherStrokesToEnd(), requestStrokeEnd(), KisImage::KisImagePrivate::scheduler, and KisUpdateScheduler::startStroke().

◆ stopIsolatedMode

void KisImage::stopIsolatedMode ( )

slot

Definition at line 2081 of file kis_image.cc.

{
    if (!m_d->isolationRootNode)  return;
 
    struct StopIsolatedModeStroke : public KisRunnableBasedStrokeStrategy {
        StopIsolatedModeStroke(KisImageSP image)
            : KisRunnableBasedStrokeStrategy(QLatin1String("stop-isolated-mode"), kundo2_noi18n("stop-isolated-mode")),
              m_image(image),
              m_oldRootNode(nullptr),
              m_oldNodeNeedsRefresh(false)
        {
            this->enableJob(JOB_INIT);
            this->enableJob(JOB_DOSTROKE, true);
            this->enableJob(JOB_FINISH, true, KisStrokeJobData::BARRIER);
            setClearsRedoOnStart(false);
        }
 
        void initStrokeCallback() override {
            if (!m_image->m_d->isolationRootNode)  return;
 
            m_oldRootNode = m_image->m_d->isolationRootNode;
 
            const bool beforeVisibility = m_oldRootNode->projectionLeaf()->visible();
            m_image->m_d->isolationRootNode = 0;
            m_image->m_d->isolateLayer = false;
            m_image->m_d->isolateGroup = false;
            Q_EMIT m_image->sigIsolatedModeChanged();
            const bool afterVisibility = m_oldRootNode->projectionLeaf()->visible();
 
            m_oldNodeNeedsRefresh = (beforeVisibility != afterVisibility);
        }
 
        void finishStrokeCallback() override {
 
            m_image->invalidateAllFrames();
 
            if (m_oldNodeNeedsRefresh){
                m_oldRootNode->setDirty(m_image->bounds());
            } else {
                // TODO: Substitute notifyProjectionUpdated() with this code
                // when update optimization is implemented
                //
                // QRect updateRect = bounds() | oldRootNode->extent();
                //oldRootNode->setDirty(updateRect);
 
                QVector<KisRunnableStrokeJobData*> jobs;
                m_image->m_d->notifyProjectionUpdatedInPatches(m_image->bounds(), jobs);
                this->runnableJobsInterface()->addRunnableJobs(jobs);
            }
        }
 
    private:
        KisImageSP m_image;
        KisNodeSP m_oldRootNode;
        bool m_oldNodeNeedsRefresh;
    };
 
    KisStrokeId id = startStroke(new StopIsolatedModeStroke(this));
    endStroke(id);
}

References KisStrokeJobData::BARRIER, endStroke(), KisImage::KisImagePrivate::isolationRootNode, kundo2_noi18n(), m_d, and startStroke().

◆ tryBarrierLock()

bool KisImage::tryBarrierLock ( bool readOnly = false )

Tries to lock the image without waiting for the jobs to finish.

Same as barrierLock(), but doesn't block execution of the calling thread until all the background jobs are finished. Instead, in case of presence of unfinished jobs in the queue, it just returns false

Returns: whether the lock has been acquired

See also: barrierLock

Definition at line 771 of file kis_image.cc.

{
    bool result = true;
 
    if (!locked()) {
        result = m_d->scheduler.tryBarrierLock();
        m_d->lockedForReadOnly = readOnly;
    }
 
    if (result) {
        m_d->lockCount++;
        m_d->lockedForReadOnly &= readOnly;
    }
 
    return result;
}

References KisImage::KisImagePrivate::lockCount, locked(), KisImage::KisImagePrivate::lockedForReadOnly, m_d, KisImage::KisImagePrivate::scheduler, and KisUpdateScheduler::tryBarrierLock().

◆ tryUndoUnfinishedLod0Stroke

UndoResult KisImage::tryUndoUnfinishedLod0Stroke ( )

slot

This method requests the last stroke executed on the image to become undone. If the stroke is not ended, or if all the Lod0 strokes are completed, the method returns UNDO_FAIL. If the last Lod0 is going to be finished soon, then UNDO_WAIT is returned and the caller should just wait for its completion and call global undo instead. UNDO_OK means one unfinished stroke has been undone.

Definition at line 2194 of file kis_image.cc.

{
    return m_d->scheduler.tryUndoLastStrokeAsync();
}

References m_d, KisImage::KisImagePrivate::scheduler, and KisUpdateScheduler::tryUndoLastStrokeAsync().

◆ unblockUpdates()

void KisImage::unblockUpdates ( )

overridevirtual

unblockUpdates unblock updating the image project. This only restarts the scheduler and does not schedule a full refresh.

Implements KisUpdatesFacade.

Definition at line 823 of file kis_image.cc.

{
    m_d->scheduler.unblockUpdates();
}

References m_d, KisImage::KisImagePrivate::scheduler, and KisUpdateScheduler::unblockUpdates().

◆ undoAdapter()

KisUndoAdapter * KisImage::undoAdapter ( ) const

Returns the current undo adapter. You can add new commands to the undo stack using the adapter. This adapter is used for a backward compatibility for old commands created before strokes. It blocks all the processing at the scheduler, waits until it's finished and executes commands exclusively.

Definition at line 1845 of file kis_image.cc.

{
    return &m_d->legacyUndoAdapter;
}

References KisImage::KisImagePrivate::legacyUndoAdapter, and m_d.

◆ undoStore()

KisUndoStore * KisImage::undoStore ( )

Return current undo store of the image

Definition at line 1840 of file kis_image.cc.

{
    return m_d->undoStore.data();
}

References m_d, and KisImage::KisImagePrivate::undoStore.

◆ unifyLayersColorSpace()

void KisImage::unifyLayersColorSpace ( )

Unify layers color space

If any of the layers have color space different from the image color space, convert them into the image color space.

Definition at line 1463 of file kis_image.cc.

{
    const KUndo2MagicString actionName = kundo2_i18n("Unify Layers Color Space");
 
    KisImageSignalVector emitSignals;
 
    KisProcessingApplicator::ProcessingFlags flags =
        KisProcessingApplicator::NO_UI_UPDATES | KisProcessingApplicator::RECURSIVE;
 
    KisProcessingApplicator applicator(this, m_d->rootLayer,
                                       flags,
                                       emitSignals, actionName);
 
    // src and dst color spaces coincide, since we should just unify
    // all our layers
    applicator.applyVisitor(
                new KisConvertColorSpaceProcessingVisitor(
                    m_d->colorSpace, m_d->colorSpace,
                    KoColorConversionTransformation::internalRenderingIntent(),
                    KoColorConversionTransformation::internalConversionFlags()),
                KisStrokeJobData::CONCURRENT);
 
    applicator.end();
}

References KisProcessingApplicator::applyVisitor(), KisImage::KisImagePrivate::colorSpace, KisStrokeJobData::CONCURRENT, KisProcessingApplicator::end(), KoColorConversionTransformation::internalConversionFlags(), KoColorConversionTransformation::internalRenderingIntent(), kundo2_i18n(), m_d, KisProcessingApplicator::NO_UI_UPDATES, KisProcessingApplicator::RECURSIVE, and KisImage::KisImagePrivate::rootLayer.

◆ unlock()

void KisImage::unlock ( )

Unlocks the image and starts/resumes all the pending internal jobs. If the image has been locked for a non-readOnly access, then all the internal caches of the image (e.g. lod-planes) are reset and regeneration jobs are scheduled.

Definition at line 805 of file kis_image.cc.

{
    Q_ASSERT(locked());
 
    if (locked()) {
        m_d->lockCount--;
 
        if (m_d->lockCount == 0) {
            m_d->scheduler.unlock(!m_d->lockedForReadOnly);
        }
    }
}

References KisImage::KisImagePrivate::lockCount, locked(), KisImage::KisImagePrivate::lockedForReadOnly, m_d, KisImage::KisImagePrivate::scheduler, and KisUpdateScheduler::unlock().

◆ waitForDone()

void KisImage::waitForDone ( )

Wait for all the internal image jobs to complete and return without locking the image. This function is handy for tests or other synchronous actions, when one needs to wait for the result of his actions.

Definition at line 1953 of file kis_image.cc.

{
    requestStrokeEnd();
    KisBusyWaitBroker::instance()->notifyWaitOnImageStarted(this);
    m_d->scheduler.waitForDone();
    KisBusyWaitBroker::instance()->notifyWaitOnImageEnded(this);
}

References KisBusyWaitBroker::instance(), m_d, KisBusyWaitBroker::notifyWaitOnImageEnded(), KisBusyWaitBroker::notifyWaitOnImageStarted(), requestStrokeEnd(), KisImage::KisImagePrivate::scheduler, and KisUpdateScheduler::waitForDone().

◆ width()

qint32 KisImage::width ( ) const

Return the width of the image

Definition at line 1645 of file kis_image.cc.

{
    return m_d->width;
}

References m_d, and KisImage::KisImagePrivate::width.

◆ workingThreadsLimit()

int KisImage::workingThreadsLimit ( ) const

Return the number of threads available to the image's working threads

Definition at line 2387 of file kis_image.cc.

{
    return m_d->scheduler.threadsLimit();
}

References m_d, KisImage::KisImagePrivate::scheduler, and KisUpdateScheduler::threadsLimit().

◆ wrapAroundModeActive()

bool KisImage::wrapAroundModeActive ( ) const

Returns: whether the wraparound mode is activated for all the devices of the image. The mode is activated when both factors are true: the user permitted it and the stroke supports it

Definition at line 2598 of file kis_image.cc.

{
    return m_d->wrapAroundModePermitted &&
        m_d->scheduler.wrapAroundModeSupported();
}

References m_d, KisImage::KisImagePrivate::scheduler, KisImage::KisImagePrivate::wrapAroundModePermitted, and KisUpdateScheduler::wrapAroundModeSupported().

◆ wrapAroundModeAxis()

WrapAroundAxis KisImage::wrapAroundModeAxis ( ) const

Returns: the axis being used for wraparound mode

See also: setWrapAroundModeAxis

Definition at line 2587 of file kis_image.cc.

{
    return m_d->wrapAroundModeAxis;
}

References m_d, and KisImage::KisImagePrivate::wrapAroundModeAxis.

◆ wrapAroundModePermitted()

bool KisImage::wrapAroundModePermitted ( ) const

Returns: whether the wrap-around mode is permitted for this image. If the wrap around mode is permitted and the currently running stroke supports it, the mode will be activated for all paint devices of the image.

See also: setWrapAroundMode

Definition at line 2593 of file kis_image.cc.

{
    return m_d->wrapAroundModePermitted;
}

References m_d, and KisImage::KisImagePrivate::wrapAroundModePermitted.

◆ xRes()

double KisImage::xRes ( ) const

X resolution in pixels per pt

Definition at line 1589 of file kis_image.cc.

{
    return m_d->xres;
}

References m_d, and KisImage::KisImagePrivate::xres.

◆ yRes()

double KisImage::yRes ( ) const

Y resolution in pixels per pt

Definition at line 1594 of file kis_image.cc.

{
    return m_d->yres;
}

References m_d, and KisImage::KisImagePrivate::yres.

Friends And Related Symbol Documentation

◆ KisImageGlobalSelectionManagementInterface

friend class KisImageGlobalSelectionManagementInterface

friend

Definition at line 1271 of file kis_image.h.

◆ KisImageResizeCommand

friend class KisImageResizeCommand

friend

Definition at line 1266 of file kis_image.h.

Member Data Documentation

◆ m_d

KisImagePrivate* KisImage::m_d

private

Definition at line 1275 of file kis_image.h.

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

libs/image/kis_image.h
libs/image/kis_image.cc

Classes

Public Slots

Signals

Public Member Functions

Static Public Member Functions

Private Types

Private Member Functions

Private Attributes

Friends

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

◆ CopyPolicy

Constructor & Destructor Documentation

◆ KisImage() [1/2]

◆ ~KisImage()

◆ KisImage() [2/2]

Member Function Documentation

◆ aboutToAddANode()

◆ aboutToRemoveANode()

◆ addAnnotation()

◆ addComposition()

◆ addJob()

◆ addProjectionUpdatesFilter()

◆ addSpontaneousJob()

◆ allowMasksOnRootNode()

◆ animationInterface()

◆ annotation()

◆ assignImageProfile()

◆ assignLayerProfile()

◆ barrierLock()

◆ beginAnnotations()

◆ blockUpdates()

◆ bounds()

◆ cancelStroke()

◆ canReselectGlobalSelection()

◆ clone()

◆ colorSpace()

◆ compositeProgressProxy()

◆ compositions()

◆ convertImageColorSpace()

◆ convertImageProjectionColorSpace()

◆ convertLayerColorSpace()

◆ convertToQImage() [1/3]

◆ convertToQImage() [2/3]

◆ convertToQImage() [3/3]

◆ copyFromImage()

◆ copyFromImageImpl()

◆ cropImage()

◆ cropNode()

◆ cropNodes()

◆ currentLevelOfDetail()

◆ currentProjectionUpdatesFilter()

◆ defaultProjectionColor()

◆ disableDirtyRequests()

◆ disableUIUpdates()

◆ documentToImagePixelFloored()

◆ documentToPixel() [1/2]

◆ documentToPixel() [2/2]

◆ effectiveLodBounds()

◆ emitSizeChanged()

◆ enableDirtyRequests()

◆ enableUIUpdates()

◆ endAnnotations()

◆ endStroke()

◆ explicitRegenerateLevelOfDetail

◆ flatten()

◆ flattenLayer()

◆ fromQImage()

◆ globalSelection()

◆ globalSelectionManagementInterface

◆ graphOverlayNode()

◆ hasOverlaySelectionMask()

◆ hasUpdatesRunning()

◆ height()

◆ immediateLockForReadOnly()

◆ initialRefreshGraph()

◆ invalidateAllFrames()

◆ invalidateFrames()

◆ isIdle()