KisTransactionData Class Reference

#include <kis_transaction_data.h>

Inheritance diagram for KisTransactionData:

Public Member Functions
KisDataManagerSP	dataManager ()
virtual void	endTransaction ()
	KisTransactionData (const KUndo2MagicString &name, KisPaintDeviceSP device, bool resetSelectionOutlineCache, KisTransactionWrapperFactory *interstrokeDataFactory, KUndo2Command *parent, bool suppressUpdates)
void	moveDevice (const QPoint newOffset)
void	possiblySwitchCurrentTime ()
void	redo () override
void	undo () override
	~KisTransactionData () override
Public Member Functions inherited from KUndo2Command
QString	actionText () const
virtual bool	canAnnihilateWith (const KUndo2Command *other) const
const KUndo2Command *	child (int index) const
int	childCount () const
virtual QTime	endTime () const
KUndo2CommandExtraData *	extraData () const
bool	hasParent () const
virtual int	id () const
virtual bool	isMerged () const
	KUndo2Command (const KUndo2MagicString &text, KUndo2Command *parent=0)
	KUndo2Command (KUndo2Command *parent=0)
virtual QVector< KUndo2Command * >	mergeCommandsVector () const
virtual bool	mergeWith (const KUndo2Command *other)
virtual void	redoMergedCommands ()
void	setEndTime ()
virtual void	setEndTime (const QTime &time)
void	setExtraData (KUndo2CommandExtraData *data)
void	setText (const KUndo2MagicString &text)
void	setTime ()
virtual void	setTime (const QTime &time)
virtual void	setTimedID (int timedID)
KUndo2MagicString	text () const
virtual QTime	time () const
virtual int	timedId () const
virtual bool	timedMergeWith (KUndo2Command *other)
virtual void	undoMergedCommands ()
virtual	~KUndo2Command ()

Public Attributes
bool	defaultPixelChanged = false
KisPaintDeviceSP	device
bool	firstRedo
QScopedPointer< KUndo2Command >	flattenUndoCommand
QScopedPointer< OptionalInterstrokeInfo >	interstrokeInfo
KisMementoSP	memento
QPoint	newOffset
KoColor	oldDefaultPixel
QPoint	oldOffset
bool	resetSelectionOutlineCache
KisDataManagerSP	savedDataManager
QPainterPath	savedOutlineCache
bool	savedOutlineCacheValid
bool	suppressUpdates = false
bool	transactionFinished
int	transactionFrameId
int	transactionTime

Protected Member Functions
virtual void	restoreSelectionOutlineCache (bool undo)
virtual void	saveSelectionOutlineCache ()

Private Member Functions
void	doFlattenUndoRedo (bool undo)
void	init (KisPaintDeviceSP device)
void	possiblyFlattenSelection (KisPaintDeviceSP device)
void	possiblyNotifySelectionChanged ()
void	possiblyResetOutlineCache ()
void	startUpdates ()
Private Member Functions inherited from Private
	Private (KisCanvas2 *c)

Private Attributes
Private *const	m_d
Private Attributes inherited from Private
KisCanvas2 *	canvas
int	displayedFrame
int	intendedFrame

Detailed Description

A tile based undo command.

Ordinary KUndo2Command subclasses store parameters and apply the action in the redo() command, however, Krita doesn't work like this. Undo replaces the current tiles in a paint device with the old tiles, redo replaces them again with the new tiles without actually executing the command that changed the image data again.

Definition at line 37 of file kis_transaction_data.cpp.

Constructor & Destructor Documentation

KisTransactionData()

KisTransactionData::KisTransactionData	(	const KUndo2MagicString &	name,
		KisPaintDeviceSP	device,
		bool	resetSelectionOutlineCache,
		KisTransactionWrapperFactory *	interstrokeDataFactory,
		KUndo2Command *	parent,
		bool	suppressUpdates )

Definition at line 67 of file kis_transaction_data.cpp.

    : KUndo2Command(name, parent)
    , m_d(new Private())
{
    m_d->resetSelectionOutlineCache = resetSelectionOutlineCache;
    m_d->suppressUpdates = suppressUpdates;
    setTimedID(-1);
 
    if (!interstrokeDataFactory && device->interstrokeData()) {
        interstrokeDataFactory = new KisInterstrokeDataTransactionWrapperFactory(0);
    }
 
    if (interstrokeDataFactory) {
        m_d->interstrokeInfo.reset(new OptionalInterstrokeInfo());
        m_d->interstrokeInfo->factory.reset(interstrokeDataFactory);
    }
 
    possiblyFlattenSelection(device);
    init(device);
    saveSelectionOutlineCache();
}

References device, init(), KisPaintDevice::interstrokeData(), m_d, possiblyFlattenSelection(), resetSelectionOutlineCache, saveSelectionOutlineCache(), KUndo2Command::setTimedID(), and suppressUpdates.

~KisTransactionData()

KisTransactionData::~KisTransactionData ( )

override

Definition at line 115 of file kis_transaction_data.cpp.

{
    Q_ASSERT(m_d->memento);
    m_d->savedDataManager->purgeHistory(m_d->memento);
 
    delete m_d;
}

References m_d.

Member Function Documentation

dataManager()

KisDataManagerSP KisTransactionData::dataManager

(

)

doFlattenUndoRedo()

void KisTransactionData::doFlattenUndoRedo ( bool undo )

private

Definition at line 226 of file kis_transaction_data.cpp.

{
    KisPixelSelectionSP pixelSelection =
        dynamic_cast<KisPixelSelection*>(m_d->device.data());
 
    if (pixelSelection) {
        if (m_d->flattenUndoCommand) {
            if (undo) {
                m_d->flattenUndoCommand->undo();
            } else {
                m_d->flattenUndoCommand->redo();
            }
        }
    }
}

References m_d, and undo().

endTransaction()

void KisTransactionData::endTransaction ( )

virtual

Definition at line 132 of file kis_transaction_data.cpp.

{
    if(!m_d->transactionFinished) {
        // make sure the time didn't change during the transaction
        KIS_ASSERT_RECOVER_RETURN(
            m_d->transactionTime == m_d->device->defaultBounds()->currentTime());
 
        DEBUG_ACTION("Transaction ended");
        m_d->transactionFinished = true;
        m_d->savedDataManager->commit();
        m_d->newOffset = QPoint(m_d->device->x(), m_d->device->y());
        m_d->defaultPixelChanged = m_d->oldDefaultPixel != m_d->device->defaultPixel();
 
        if (m_d->interstrokeInfo) {
            m_d->interstrokeInfo->endTransactionCommand.reset(m_d->interstrokeInfo->factory->createEndTransactionCommand());
            if (m_d->interstrokeInfo->endTransactionCommand) {
                m_d->interstrokeInfo->endTransactionCommand->redo();
            }
            m_d->interstrokeInfo->factory.reset();
        }
    }
}

References DEBUG_ACTION, KIS_ASSERT_RECOVER_RETURN, and m_d.

init()

void KisTransactionData::init ( KisPaintDeviceSP device )

private

Definition at line 89 of file kis_transaction_data.cpp.

{
    m_d->device = device;
    DEBUG_ACTION("Transaction started");
 
    m_d->oldOffset = QPoint(device->x(), device->y());
    m_d->oldDefaultPixel = device->defaultPixel();
    m_d->firstRedo = true;
    m_d->transactionFinished = false;
 
    m_d->transactionTime = device->defaultBounds()->currentTime();
 
    if (m_d->interstrokeInfo) {
        m_d->interstrokeInfo->beginTransactionCommand.reset(m_d->interstrokeInfo->factory->createBeginTransactionCommand(m_d->device));
        if (m_d->interstrokeInfo->beginTransactionCommand) {
            m_d->interstrokeInfo->beginTransactionCommand->redo();
        }
    }
 
    m_d->transactionFrameId = device->framesInterface() ? device->framesInterface()->currentFrameId() : -1;
    m_d->savedDataManager = m_d->transactionFrameId >= 0 ?
        m_d->device->framesInterface()->frameDataManager(m_d->transactionFrameId) :
        m_d->device->dataManager();
    m_d->memento = m_d->savedDataManager->getMemento();
}

References KisPaintDeviceFramesInterface::currentFrameId(), KisDefaultBoundsBase::currentTime(), DEBUG_ACTION, KisPaintDevice::defaultBounds(), KisPaintDevice::defaultPixel(), device, KisPaintDevice::framesInterface(), m_d, KisPaintDevice::x(), and KisPaintDevice::y().

moveDevice()

void KisTransactionData::moveDevice

(

const QPoint

newOffset

)

possiblyFlattenSelection()

void KisTransactionData::possiblyFlattenSelection ( KisPaintDeviceSP device )

private

Definition at line 209 of file kis_transaction_data.cpp.

{
    KisPixelSelectionSP pixelSelection =
        dynamic_cast<KisPixelSelection*>(device.data());
 
    if (pixelSelection) {
        KisSelection *selection = pixelSelection->parentSelection().data();
        if (selection) {
            m_d->flattenUndoCommand.reset(selection->flatten());
 
            if (m_d->flattenUndoCommand) {
                m_d->flattenUndoCommand->redo();
            }
        }
    }
}

References KisSharedPtr< T >::data(), KisWeakSharedPtr< T >::data(), device, KisSelection::flatten(), m_d, and KisPixelSelection::parentSelection.

possiblyNotifySelectionChanged()

void KisTransactionData::possiblyNotifySelectionChanged ( )

private

Definition at line 186 of file kis_transaction_data.cpp.

{
    KisPixelSelectionSP pixelSelection =
        dynamic_cast<KisPixelSelection*>(m_d->device.data());
 
    KisSelectionSP selection;
    if (pixelSelection && (selection = pixelSelection->parentSelection())) {
        selection->notifySelectionChanged();
    }
}

References m_d, KisSelection::notifySelectionChanged(), and KisPixelSelection::parentSelection.

possiblyResetOutlineCache()

void KisTransactionData::possiblyResetOutlineCache ( )

private

Definition at line 197 of file kis_transaction_data.cpp.

{
    KisPixelSelectionSP pixelSelection;
 
    if (m_d->resetSelectionOutlineCache &&
        (pixelSelection =
         dynamic_cast<KisPixelSelection*>(m_d->device.data()))) {
 
        pixelSelection->invalidateOutlineCache();
    }
}

References KisPixelSelection::invalidateOutlineCache(), and m_d.

possiblySwitchCurrentTime()

void KisTransactionData::possiblySwitchCurrentTime

(

)

redo()

void KisTransactionData::redo ( )

overridevirtual

Applies a change to the document. This function must be implemented in the derived class. Calling KUndo2QStack::push(), KUndo2QStack::undo() or KUndo2QStack::redo() from this function leads to undefined behavior.

The default implementation calls redo() on all child commands.

See also

undo()

Reimplemented from KUndo2Command.

Definition at line 249 of file kis_transaction_data.cpp.

{
    //KUndo2QStack calls redo(), so the first call needs to be blocked
    if (m_d->firstRedo) {
        m_d->firstRedo = false;
 
 
        possiblyResetOutlineCache();
        possiblyNotifySelectionChanged();
        return;
    }
 
 
 
    doFlattenUndoRedo(false);
    restoreSelectionOutlineCache(false);
 
    DEBUG_ACTION("Redo()");
 
    if (m_d->interstrokeInfo && m_d->interstrokeInfo->beginTransactionCommand) {
        m_d->interstrokeInfo->beginTransactionCommand->redo();
    }
 
    Q_ASSERT(m_d->memento);
    m_d->savedDataManager->rollforward(m_d->memento);
 
    if (m_d->newOffset != m_d->oldOffset) {
        m_d->moveDevice(m_d->newOffset);
    }
 
    if (m_d->interstrokeInfo && m_d->interstrokeInfo->endTransactionCommand) {
        m_d->interstrokeInfo->endTransactionCommand->redo();
    }
 
    m_d->possiblySwitchCurrentTime();
    startUpdates();
    possiblyNotifySelectionChanged();
}

References DEBUG_ACTION, doFlattenUndoRedo(), m_d, possiblyNotifySelectionChanged(), possiblyResetOutlineCache(), restoreSelectionOutlineCache(), and startUpdates().

restoreSelectionOutlineCache()

void KisTransactionData::restoreSelectionOutlineCache ( bool undo )

protectedvirtual

Definition at line 332 of file kis_transaction_data.cpp.

{
    Q_UNUSED(undo);
    KisPixelSelectionSP pixelSelection =
        dynamic_cast<KisPixelSelection*>(m_d->device.data());
 
    if (pixelSelection) {
        bool savedOutlineCacheValid;
        QPainterPath savedOutlineCache;
 
        savedOutlineCacheValid = pixelSelection->outlineCacheValid();
        if (savedOutlineCacheValid) {
            savedOutlineCache = pixelSelection->outlineCache();
        }
 
        if (m_d->savedOutlineCacheValid) {
            pixelSelection->setOutlineCache(m_d->savedOutlineCache);
        } else {
            pixelSelection->invalidateOutlineCache();
        }
 
        m_d->savedOutlineCacheValid = savedOutlineCacheValid;
        if (m_d->savedOutlineCacheValid) {
            m_d->savedOutlineCache = savedOutlineCache;
        }
    }
}

References KisPixelSelection::invalidateOutlineCache(), m_d, KisPixelSelection::outlineCache, KisPixelSelection::outlineCacheValid, savedOutlineCache, savedOutlineCacheValid, KisPixelSelection::setOutlineCache(), and undo().

saveSelectionOutlineCache()

void KisTransactionData::saveSelectionOutlineCache ( )

protectedvirtual

Definition at line 315 of file kis_transaction_data.cpp.

{
    m_d->savedOutlineCacheValid = false;
 
    KisPixelSelectionSP pixelSelection =
        dynamic_cast<KisPixelSelection*>(m_d->device.data());
 
    if (pixelSelection) {
        m_d->savedOutlineCacheValid = pixelSelection->outlineCacheValid();
        if (m_d->savedOutlineCacheValid) {
            m_d->savedOutlineCache = pixelSelection->outlineCache();
 
            possiblyResetOutlineCache();
        }
    }
}

References m_d, KisPixelSelection::outlineCache, KisPixelSelection::outlineCacheValid, and possiblyResetOutlineCache().

startUpdates()

void KisTransactionData::startUpdates ( )

private

Definition at line 155 of file kis_transaction_data.cpp.

{
    if (m_d->suppressUpdates) return;
 
    if (m_d->transactionFrameId == -1 ||
        m_d->transactionFrameId ==
        m_d->device->framesInterface()->currentFrameId()) {
 
        QRect rc;
        QRect mementoExtent = m_d->memento->extent();
 
        if (m_d->newOffset == m_d->oldOffset) {
            rc = mementoExtent.translated(m_d->device->x(), m_d->device->y());
        } else {
            QRect totalExtent =
                m_d->savedDataManager->extent() | mementoExtent;
 
            rc = totalExtent.translated(m_d->oldOffset) |
                totalExtent.translated(m_d->newOffset);
        }
 
        if (m_d->defaultPixelChanged) {
            rc |= m_d->device->defaultBounds()->bounds();
        }
 
        m_d->device->setDirty(rc);
    } else {
        m_d->device->framesInterface()->invalidateFrameCache(m_d->transactionFrameId);
    }
}

References m_d.

undo()

void KisTransactionData::undo ( )

overridevirtual

Reverts a change to the document. After undo() is called, the state of the document should be the same as before redo() was called. This function must be implemented in the derived class. Calling KUndo2QStack::push(), KUndo2QStack::undo() or KUndo2QStack::redo() from this function leads to undefined behavior.

The default implementation calls undo() on all child commands in reverse order.

See also

redo()

Reimplemented from KUndo2Command.

Definition at line 288 of file kis_transaction_data.cpp.

{
    DEBUG_ACTION("Undo()");
 
    if (m_d->interstrokeInfo && m_d->interstrokeInfo->endTransactionCommand) {
        m_d->interstrokeInfo->endTransactionCommand->undo();
    }
 
    Q_ASSERT(m_d->memento);
    m_d->savedDataManager->rollback(m_d->memento);
 
    if (m_d->newOffset != m_d->oldOffset) {
        m_d->moveDevice(m_d->oldOffset);
    }
 
    if (m_d->interstrokeInfo && m_d->interstrokeInfo->beginTransactionCommand) {
        m_d->interstrokeInfo->beginTransactionCommand->undo();
    }
 
    restoreSelectionOutlineCache(true);
    doFlattenUndoRedo(true);
 
    m_d->possiblySwitchCurrentTime();
    startUpdates();
    possiblyNotifySelectionChanged();
}

References DEBUG_ACTION, doFlattenUndoRedo(), m_d, possiblyNotifySelectionChanged(), restoreSelectionOutlineCache(), and startUpdates().

Member Data Documentation

defaultPixelChanged

bool KisTransactionData::defaultPixelChanged = false

Definition at line 48 of file kis_transaction_data.cpp.

device

KisPaintDeviceSP KisTransactionData::device

Definition at line 40 of file kis_transaction_data.cpp.

firstRedo

bool KisTransactionData::firstRedo

Definition at line 42 of file kis_transaction_data.cpp.

flattenUndoCommand

QScopedPointer<KUndo2Command> KisTransactionData::flattenUndoCommand

Definition at line 52 of file kis_transaction_data.cpp.

interstrokeInfo

QScopedPointer<OptionalInterstrokeInfo> KisTransactionData::interstrokeInfo

Definition at line 59 of file kis_transaction_data.cpp.

m_d

Private* const KisTransactionData::m_d

private

Definition at line 51 of file kis_transaction_data.h.

memento

KisMementoSP KisTransactionData::memento

Definition at line 41 of file kis_transaction_data.cpp.

newOffset

QPoint KisTransactionData::newOffset

Definition at line 45 of file kis_transaction_data.cpp.

oldDefaultPixel

KoColor KisTransactionData::oldDefaultPixel

Definition at line 47 of file kis_transaction_data.cpp.

oldOffset

QPoint KisTransactionData::oldOffset

Definition at line 44 of file kis_transaction_data.cpp.

resetSelectionOutlineCache

bool KisTransactionData::resetSelectionOutlineCache

Definition at line 53 of file kis_transaction_data.cpp.

savedDataManager

KisDataManagerSP KisTransactionData::savedDataManager

Definition at line 57 of file kis_transaction_data.cpp.

savedOutlineCache

QPainterPath KisTransactionData::savedOutlineCache

Definition at line 51 of file kis_transaction_data.cpp.

savedOutlineCacheValid

bool KisTransactionData::savedOutlineCacheValid

Definition at line 50 of file kis_transaction_data.cpp.

suppressUpdates

bool KisTransactionData::suppressUpdates = false

Definition at line 60 of file kis_transaction_data.cpp.

transactionFinished

bool KisTransactionData::transactionFinished

Definition at line 43 of file kis_transaction_data.cpp.

transactionFrameId

int KisTransactionData::transactionFrameId

Definition at line 56 of file kis_transaction_data.cpp.

transactionTime

int KisTransactionData::transactionTime

Definition at line 55 of file kis_transaction_data.cpp.

---

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

• libs/image/kis_transaction_data.cpp
• libs/image/kis_transaction_data.h