indent classes, align by spaces
This commit is contained in:
Garux
702
radiant/undo.cpp
702
radiant/undo.cpp
@@ -39,338 +39,338 @@
|
||||
|
||||
class DebugScopeTimer
|
||||
{
|
||||
Timer m_timer;
|
||||
const char* m_operation;
|
||||
Timer m_timer;
|
||||
const char* m_operation;
|
||||
public:
|
||||
DebugScopeTimer( const char* operation )
|
||||
: m_operation( operation ){
|
||||
m_timer.start();
|
||||
}
|
||||
~DebugScopeTimer(){
|
||||
unsigned int elapsed = m_timer.elapsed_msec();
|
||||
if ( elapsed > 0 ) {
|
||||
globalOutputStream() << m_operation << ": " << elapsed << " msec\n";
|
||||
DebugScopeTimer( const char* operation )
|
||||
: m_operation( operation ){
|
||||
m_timer.start();
|
||||
}
|
||||
~DebugScopeTimer(){
|
||||
unsigned int elapsed = m_timer.elapsed_msec();
|
||||
if ( elapsed > 0 ) {
|
||||
globalOutputStream() << m_operation << ": " << elapsed << " msec\n";
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
class RadiantUndoSystem : public UndoSystem
|
||||
{
|
||||
INTEGER_CONSTANT( MAX_UNDO_LEVELS, 4096 );
|
||||
INTEGER_CONSTANT( MAX_UNDO_LEVELS, 4096 );
|
||||
|
||||
class Snapshot
|
||||
{
|
||||
class StateApplicator
|
||||
{
|
||||
public:
|
||||
Undoable* m_undoable;
|
||||
private:
|
||||
UndoMemento* m_data;
|
||||
public:
|
||||
|
||||
StateApplicator( Undoable* undoable, UndoMemento* data )
|
||||
: m_undoable( undoable ), m_data( data ){
|
||||
}
|
||||
void restore(){
|
||||
m_undoable->importState( m_data );
|
||||
}
|
||||
void release(){
|
||||
m_data->release();
|
||||
}
|
||||
};
|
||||
|
||||
typedef std::list<StateApplicator> states_t;
|
||||
states_t m_states;
|
||||
|
||||
public:
|
||||
bool empty() const {
|
||||
return m_states.empty();
|
||||
}
|
||||
std::size_t size() const {
|
||||
return m_states.size();
|
||||
}
|
||||
void save( Undoable* undoable ){
|
||||
m_states.push_front( StateApplicator( undoable, undoable->exportState() ) );
|
||||
}
|
||||
void restore(){
|
||||
for ( states_t::iterator i = m_states.begin(); i != m_states.end(); ++i )
|
||||
class Snapshot
|
||||
{
|
||||
( *i ).restore();
|
||||
}
|
||||
}
|
||||
void release(){
|
||||
for ( states_t::iterator i = m_states.begin(); i != m_states.end(); ++i )
|
||||
{
|
||||
( *i ).release();
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
struct Operation
|
||||
{
|
||||
Snapshot m_snapshot;
|
||||
CopiedString m_command;
|
||||
|
||||
Operation( const char* command )
|
||||
: m_command( command ){
|
||||
}
|
||||
~Operation(){
|
||||
m_snapshot.release();
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
class UndoStack
|
||||
{
|
||||
//! Note: using std::list instead of vector/deque, to avoid copying of undos
|
||||
typedef std::list<Operation*> Operations;
|
||||
|
||||
Operations m_stack;
|
||||
Operation* m_pending;
|
||||
|
||||
public:
|
||||
UndoStack() : m_pending( 0 ){
|
||||
}
|
||||
~UndoStack(){
|
||||
clear();
|
||||
}
|
||||
bool empty() const {
|
||||
return m_stack.empty();
|
||||
}
|
||||
std::size_t size() const {
|
||||
return m_stack.size();
|
||||
}
|
||||
Operation* back(){
|
||||
return m_stack.back();
|
||||
}
|
||||
const Operation* back() const {
|
||||
return m_stack.back();
|
||||
}
|
||||
Operation* front(){
|
||||
return m_stack.front();
|
||||
}
|
||||
const Operation* front() const {
|
||||
return m_stack.front();
|
||||
}
|
||||
void pop_front(){
|
||||
delete m_stack.front();
|
||||
m_stack.pop_front();
|
||||
}
|
||||
void pop_back(){
|
||||
delete m_stack.back();
|
||||
m_stack.pop_back();
|
||||
}
|
||||
void clear(){
|
||||
if ( !m_stack.empty() ) {
|
||||
for ( Operations::iterator i = m_stack.begin(); i != m_stack.end(); ++i )
|
||||
class StateApplicator
|
||||
{
|
||||
delete *i;
|
||||
public:
|
||||
Undoable* m_undoable;
|
||||
private:
|
||||
UndoMemento* m_data;
|
||||
public:
|
||||
|
||||
StateApplicator( Undoable* undoable, UndoMemento* data )
|
||||
: m_undoable( undoable ), m_data( data ){
|
||||
}
|
||||
void restore(){
|
||||
m_undoable->importState( m_data );
|
||||
}
|
||||
void release(){
|
||||
m_data->release();
|
||||
}
|
||||
};
|
||||
|
||||
typedef std::list<StateApplicator> states_t;
|
||||
states_t m_states;
|
||||
|
||||
public:
|
||||
bool empty() const {
|
||||
return m_states.empty();
|
||||
}
|
||||
m_stack.clear();
|
||||
}
|
||||
}
|
||||
void start( const char* command ){
|
||||
if ( m_pending != 0 ) {
|
||||
delete m_pending;
|
||||
}
|
||||
m_pending = new Operation( command );
|
||||
}
|
||||
bool finish( const char* command ){
|
||||
if ( m_pending != 0 ) {
|
||||
delete m_pending;
|
||||
m_pending = 0;
|
||||
return false;
|
||||
}
|
||||
else
|
||||
std::size_t size() const {
|
||||
return m_states.size();
|
||||
}
|
||||
void save( Undoable* undoable ){
|
||||
m_states.push_front( StateApplicator( undoable, undoable->exportState() ) );
|
||||
}
|
||||
void restore(){
|
||||
for ( states_t::iterator i = m_states.begin(); i != m_states.end(); ++i )
|
||||
{
|
||||
( *i ).restore();
|
||||
}
|
||||
}
|
||||
void release(){
|
||||
for ( states_t::iterator i = m_states.begin(); i != m_states.end(); ++i )
|
||||
{
|
||||
( *i ).release();
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
struct Operation
|
||||
{
|
||||
ASSERT_MESSAGE( !m_stack.empty(), "undo stack empty" );
|
||||
m_stack.back()->m_command = command;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
void save( Undoable* undoable ){
|
||||
if ( m_pending != 0 ) {
|
||||
m_stack.push_back( m_pending );
|
||||
m_pending = 0;
|
||||
}
|
||||
back()->m_snapshot.save( undoable );
|
||||
}
|
||||
};
|
||||
Snapshot m_snapshot;
|
||||
CopiedString m_command;
|
||||
|
||||
UndoStack m_undo_stack;
|
||||
UndoStack m_redo_stack;
|
||||
Operation( const char* command )
|
||||
: m_command( command ){
|
||||
}
|
||||
~Operation(){
|
||||
m_snapshot.release();
|
||||
}
|
||||
};
|
||||
|
||||
class UndoStackFiller : public UndoObserver
|
||||
{
|
||||
UndoStack* m_stack;
|
||||
|
||||
class UndoStack
|
||||
{
|
||||
//! Note: using std::list instead of vector/deque, to avoid copying of undos
|
||||
typedef std::list<Operation*> Operations;
|
||||
|
||||
Operations m_stack;
|
||||
Operation* m_pending;
|
||||
|
||||
public:
|
||||
UndoStack() : m_pending( 0 ){
|
||||
}
|
||||
~UndoStack(){
|
||||
clear();
|
||||
}
|
||||
bool empty() const {
|
||||
return m_stack.empty();
|
||||
}
|
||||
std::size_t size() const {
|
||||
return m_stack.size();
|
||||
}
|
||||
Operation* back(){
|
||||
return m_stack.back();
|
||||
}
|
||||
const Operation* back() const {
|
||||
return m_stack.back();
|
||||
}
|
||||
Operation* front(){
|
||||
return m_stack.front();
|
||||
}
|
||||
const Operation* front() const {
|
||||
return m_stack.front();
|
||||
}
|
||||
void pop_front(){
|
||||
delete m_stack.front();
|
||||
m_stack.pop_front();
|
||||
}
|
||||
void pop_back(){
|
||||
delete m_stack.back();
|
||||
m_stack.pop_back();
|
||||
}
|
||||
void clear(){
|
||||
if ( !m_stack.empty() ) {
|
||||
for ( Operations::iterator i = m_stack.begin(); i != m_stack.end(); ++i )
|
||||
{
|
||||
delete *i;
|
||||
}
|
||||
m_stack.clear();
|
||||
}
|
||||
}
|
||||
void start( const char* command ){
|
||||
if ( m_pending != 0 ) {
|
||||
delete m_pending;
|
||||
}
|
||||
m_pending = new Operation( command );
|
||||
}
|
||||
bool finish( const char* command ){
|
||||
if ( m_pending != 0 ) {
|
||||
delete m_pending;
|
||||
m_pending = 0;
|
||||
return false;
|
||||
}
|
||||
else
|
||||
{
|
||||
ASSERT_MESSAGE( !m_stack.empty(), "undo stack empty" );
|
||||
m_stack.back()->m_command = command;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
void save( Undoable* undoable ){
|
||||
if ( m_pending != 0 ) {
|
||||
m_stack.push_back( m_pending );
|
||||
m_pending = 0;
|
||||
}
|
||||
back()->m_snapshot.save( undoable );
|
||||
}
|
||||
};
|
||||
|
||||
UndoStack m_undo_stack;
|
||||
UndoStack m_redo_stack;
|
||||
|
||||
class UndoStackFiller : public UndoObserver
|
||||
{
|
||||
UndoStack* m_stack;
|
||||
public:
|
||||
|
||||
UndoStackFiller()
|
||||
: m_stack( 0 ){
|
||||
}
|
||||
void save( Undoable* undoable ){
|
||||
ASSERT_NOTNULL( undoable );
|
||||
|
||||
if ( m_stack != 0 ) {
|
||||
m_stack->save( undoable );
|
||||
m_stack = 0;
|
||||
}
|
||||
}
|
||||
void setStack( UndoStack* stack ){
|
||||
m_stack = stack;
|
||||
}
|
||||
};
|
||||
|
||||
typedef std::map<Undoable*, UndoStackFiller> undoables_t;
|
||||
undoables_t m_undoables;
|
||||
|
||||
void mark_undoables( UndoStack* stack ){
|
||||
for ( undoables_t::iterator i = m_undoables.begin(); i != m_undoables.end(); ++i )
|
||||
{
|
||||
( *i ).second.setStack( stack );
|
||||
}
|
||||
}
|
||||
|
||||
std::size_t m_undo_levels;
|
||||
|
||||
typedef std::set<UndoTracker*> Trackers;
|
||||
Trackers m_trackers;
|
||||
public:
|
||||
|
||||
UndoStackFiller()
|
||||
: m_stack( 0 ){
|
||||
}
|
||||
void save( Undoable* undoable ){
|
||||
ASSERT_NOTNULL( undoable );
|
||||
|
||||
if ( m_stack != 0 ) {
|
||||
m_stack->save( undoable );
|
||||
m_stack = 0;
|
||||
RadiantUndoSystem()
|
||||
: m_undo_levels( 512 ){
|
||||
}
|
||||
}
|
||||
void setStack( UndoStack* stack ){
|
||||
m_stack = stack;
|
||||
}
|
||||
};
|
||||
|
||||
typedef std::map<Undoable*, UndoStackFiller> undoables_t;
|
||||
undoables_t m_undoables;
|
||||
|
||||
void mark_undoables( UndoStack* stack ){
|
||||
for ( undoables_t::iterator i = m_undoables.begin(); i != m_undoables.end(); ++i )
|
||||
{
|
||||
( *i ).second.setStack( stack );
|
||||
~RadiantUndoSystem(){
|
||||
clear();
|
||||
}
|
||||
}
|
||||
UndoObserver* observer( Undoable* undoable ){
|
||||
ASSERT_NOTNULL( undoable );
|
||||
|
||||
std::size_t m_undo_levels;
|
||||
return &m_undoables[undoable];
|
||||
}
|
||||
void release( Undoable* undoable ){
|
||||
ASSERT_NOTNULL( undoable );
|
||||
|
||||
typedef std::set<UndoTracker*> Trackers;
|
||||
Trackers m_trackers;
|
||||
public:
|
||||
RadiantUndoSystem()
|
||||
: m_undo_levels( 512 ){
|
||||
}
|
||||
~RadiantUndoSystem(){
|
||||
clear();
|
||||
}
|
||||
UndoObserver* observer( Undoable* undoable ){
|
||||
ASSERT_NOTNULL( undoable );
|
||||
m_undoables.erase( undoable );
|
||||
}
|
||||
void setLevels( std::size_t levels ){
|
||||
if ( levels > static_cast<unsigned>( MAX_UNDO_LEVELS() ) ) {
|
||||
levels = MAX_UNDO_LEVELS();
|
||||
}
|
||||
|
||||
return &m_undoables[undoable];
|
||||
}
|
||||
void release( Undoable* undoable ){
|
||||
ASSERT_NOTNULL( undoable );
|
||||
|
||||
m_undoables.erase( undoable );
|
||||
}
|
||||
void setLevels( std::size_t levels ){
|
||||
if ( levels > static_cast<unsigned>( MAX_UNDO_LEVELS() ) ) {
|
||||
levels = MAX_UNDO_LEVELS();
|
||||
while ( m_undo_stack.size() > levels )
|
||||
{
|
||||
m_undo_stack.pop_front();
|
||||
}
|
||||
m_undo_levels = levels;
|
||||
}
|
||||
|
||||
while ( m_undo_stack.size() > levels )
|
||||
{
|
||||
m_undo_stack.pop_front();
|
||||
std::size_t getLevels() const {
|
||||
return m_undo_levels;
|
||||
}
|
||||
m_undo_levels = levels;
|
||||
}
|
||||
std::size_t getLevels() const {
|
||||
return m_undo_levels;
|
||||
}
|
||||
std::size_t size() const {
|
||||
return m_undo_stack.size();
|
||||
}
|
||||
void startUndo(){
|
||||
m_undo_stack.start( "unnamedCommand" );
|
||||
mark_undoables( &m_undo_stack );
|
||||
}
|
||||
bool finishUndo( const char* command ){
|
||||
bool changed = m_undo_stack.finish( command );
|
||||
mark_undoables( 0 );
|
||||
return changed;
|
||||
}
|
||||
void startRedo(){
|
||||
m_redo_stack.start( "unnamedCommand" );
|
||||
mark_undoables( &m_redo_stack );
|
||||
}
|
||||
bool finishRedo( const char* command ){
|
||||
bool changed = m_redo_stack.finish( command );
|
||||
mark_undoables( 0 );
|
||||
return changed;
|
||||
}
|
||||
void start(){
|
||||
m_redo_stack.clear();
|
||||
if ( m_undo_stack.size() == m_undo_levels ) {
|
||||
m_undo_stack.pop_front();
|
||||
std::size_t size() const {
|
||||
return m_undo_stack.size();
|
||||
}
|
||||
startUndo();
|
||||
trackersBegin();
|
||||
}
|
||||
void finish( const char* command ){
|
||||
if ( finishUndo( command ) ) {
|
||||
globalOutputStream() << command << '\n';
|
||||
void startUndo(){
|
||||
m_undo_stack.start( "unnamedCommand" );
|
||||
mark_undoables( &m_undo_stack );
|
||||
}
|
||||
}
|
||||
void undo(){
|
||||
if ( m_undo_stack.empty() ) {
|
||||
globalOutputStream() << "Undo: no undo available\n";
|
||||
bool finishUndo( const char* command ){
|
||||
bool changed = m_undo_stack.finish( command );
|
||||
mark_undoables( 0 );
|
||||
return changed;
|
||||
}
|
||||
else
|
||||
{
|
||||
Operation* operation = m_undo_stack.back();
|
||||
globalOutputStream() << "Undo: " << operation->m_command.c_str() << "\n";
|
||||
|
||||
startRedo();
|
||||
trackersUndo();
|
||||
operation->m_snapshot.restore();
|
||||
finishRedo( operation->m_command.c_str() );
|
||||
m_undo_stack.pop_back();
|
||||
void startRedo(){
|
||||
m_redo_stack.start( "unnamedCommand" );
|
||||
mark_undoables( &m_redo_stack );
|
||||
}
|
||||
}
|
||||
void redo(){
|
||||
if ( m_redo_stack.empty() ) {
|
||||
globalOutputStream() << "Redo: no redo available\n";
|
||||
bool finishRedo( const char* command ){
|
||||
bool changed = m_redo_stack.finish( command );
|
||||
mark_undoables( 0 );
|
||||
return changed;
|
||||
}
|
||||
else
|
||||
{
|
||||
Operation* operation = m_redo_stack.back();
|
||||
globalOutputStream() << "Redo: " << operation->m_command.c_str() << "\n";
|
||||
|
||||
void start(){
|
||||
m_redo_stack.clear();
|
||||
if ( m_undo_stack.size() == m_undo_levels ) {
|
||||
m_undo_stack.pop_front();
|
||||
}
|
||||
startUndo();
|
||||
trackersRedo();
|
||||
operation->m_snapshot.restore();
|
||||
finishUndo( operation->m_command.c_str() );
|
||||
m_redo_stack.pop_back();
|
||||
trackersBegin();
|
||||
}
|
||||
}
|
||||
void clear(){
|
||||
mark_undoables( 0 );
|
||||
m_undo_stack.clear();
|
||||
m_redo_stack.clear();
|
||||
trackersClear();
|
||||
}
|
||||
void trackerAttach( UndoTracker& tracker ){
|
||||
const bool inserted = m_trackers.insert( &tracker ).second;
|
||||
ASSERT_MESSAGE( inserted, "undo tracker already attached" );
|
||||
}
|
||||
void trackerDetach( UndoTracker& tracker ){
|
||||
const bool erased = m_trackers.erase( &tracker );
|
||||
ASSERT_MESSAGE( erased, "undo tracker cannot be detached" );
|
||||
}
|
||||
void trackersClear() const {
|
||||
for ( Trackers::const_iterator i = m_trackers.begin(); i != m_trackers.end(); ++i )
|
||||
{
|
||||
( *i )->clear();
|
||||
void finish( const char* command ){
|
||||
if ( finishUndo( command ) ) {
|
||||
globalOutputStream() << command << '\n';
|
||||
}
|
||||
}
|
||||
}
|
||||
void trackersBegin() const {
|
||||
for ( Trackers::const_iterator i = m_trackers.begin(); i != m_trackers.end(); ++i )
|
||||
{
|
||||
( *i )->begin();
|
||||
void undo(){
|
||||
if ( m_undo_stack.empty() ) {
|
||||
globalOutputStream() << "Undo: no undo available\n";
|
||||
}
|
||||
else
|
||||
{
|
||||
Operation* operation = m_undo_stack.back();
|
||||
globalOutputStream() << "Undo: " << operation->m_command.c_str() << "\n";
|
||||
|
||||
startRedo();
|
||||
trackersUndo();
|
||||
operation->m_snapshot.restore();
|
||||
finishRedo( operation->m_command.c_str() );
|
||||
m_undo_stack.pop_back();
|
||||
}
|
||||
}
|
||||
}
|
||||
void trackersUndo() const {
|
||||
for ( Trackers::const_iterator i = m_trackers.begin(); i != m_trackers.end(); ++i )
|
||||
{
|
||||
( *i )->undo();
|
||||
void redo(){
|
||||
if ( m_redo_stack.empty() ) {
|
||||
globalOutputStream() << "Redo: no redo available\n";
|
||||
}
|
||||
else
|
||||
{
|
||||
Operation* operation = m_redo_stack.back();
|
||||
globalOutputStream() << "Redo: " << operation->m_command.c_str() << "\n";
|
||||
|
||||
startUndo();
|
||||
trackersRedo();
|
||||
operation->m_snapshot.restore();
|
||||
finishUndo( operation->m_command.c_str() );
|
||||
m_redo_stack.pop_back();
|
||||
}
|
||||
}
|
||||
}
|
||||
void trackersRedo() const {
|
||||
for ( Trackers::const_iterator i = m_trackers.begin(); i != m_trackers.end(); ++i )
|
||||
{
|
||||
( *i )->redo();
|
||||
void clear(){
|
||||
mark_undoables( 0 );
|
||||
m_undo_stack.clear();
|
||||
m_redo_stack.clear();
|
||||
trackersClear();
|
||||
}
|
||||
void trackerAttach( UndoTracker& tracker ){
|
||||
const bool inserted = m_trackers.insert( &tracker ).second;
|
||||
ASSERT_MESSAGE( inserted, "undo tracker already attached" );
|
||||
}
|
||||
void trackerDetach( UndoTracker& tracker ){
|
||||
const bool erased = m_trackers.erase( &tracker );
|
||||
ASSERT_MESSAGE( erased, "undo tracker cannot be detached" );
|
||||
}
|
||||
void trackersClear() const {
|
||||
for ( Trackers::const_iterator i = m_trackers.begin(); i != m_trackers.end(); ++i )
|
||||
{
|
||||
( *i )->clear();
|
||||
}
|
||||
}
|
||||
void trackersBegin() const {
|
||||
for ( Trackers::const_iterator i = m_trackers.begin(); i != m_trackers.end(); ++i )
|
||||
{
|
||||
( *i )->begin();
|
||||
}
|
||||
}
|
||||
void trackersUndo() const {
|
||||
for ( Trackers::const_iterator i = m_trackers.begin(); i != m_trackers.end(); ++i )
|
||||
{
|
||||
( *i )->undo();
|
||||
}
|
||||
}
|
||||
void trackersRedo() const {
|
||||
for ( Trackers::const_iterator i = m_trackers.begin(); i != m_trackers.end(); ++i )
|
||||
{
|
||||
( *i )->redo();
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
@@ -415,19 +415,19 @@ class UndoSystemDependencies : public GlobalPreferenceSystemModuleRef
|
||||
|
||||
class UndoSystemAPI
|
||||
{
|
||||
RadiantUndoSystem m_undosystem;
|
||||
RadiantUndoSystem m_undosystem;
|
||||
public:
|
||||
typedef UndoSystem Type;
|
||||
STRING_CONSTANT( Name, "*" );
|
||||
typedef UndoSystem Type;
|
||||
STRING_CONSTANT( Name, "*" );
|
||||
|
||||
UndoSystemAPI(){
|
||||
GlobalPreferenceSystem().registerPreference( "UndoLevels", makeIntStringImportCallback( UndoLevelsImportCaller( m_undosystem ) ), makeIntStringExportCallback( UndoLevelsExportCaller( m_undosystem ) ) );
|
||||
UndoSystemAPI(){
|
||||
GlobalPreferenceSystem().registerPreference( "UndoLevels", makeIntStringImportCallback( UndoLevelsImportCaller( m_undosystem ) ), makeIntStringExportCallback( UndoLevelsExportCaller( m_undosystem ) ) );
|
||||
|
||||
Undo_registerPreferencesPage( m_undosystem );
|
||||
}
|
||||
UndoSystem* getTable(){
|
||||
return &m_undosystem;
|
||||
}
|
||||
Undo_registerPreferencesPage( m_undosystem );
|
||||
}
|
||||
UndoSystem* getTable(){
|
||||
return &m_undosystem;
|
||||
}
|
||||
};
|
||||
|
||||
#include "modulesystem/singletonmodule.h"
|
||||
@@ -448,41 +448,41 @@ StaticRegisterModule staticRegisterUndoSystem( StaticUndoSystemModule::instance(
|
||||
|
||||
class undoable_test : public Undoable
|
||||
{
|
||||
struct state_type : public UndoMemento
|
||||
{
|
||||
state_type() : test_data( 0 ){
|
||||
}
|
||||
state_type( const state_type& other ) : UndoMemento( other ), test_data( other.test_data ){
|
||||
}
|
||||
void release(){
|
||||
delete this;
|
||||
}
|
||||
struct state_type : public UndoMemento
|
||||
{
|
||||
state_type() : test_data( 0 ){
|
||||
}
|
||||
state_type( const state_type& other ) : UndoMemento( other ), test_data( other.test_data ){
|
||||
}
|
||||
void release(){
|
||||
delete this;
|
||||
}
|
||||
|
||||
int test_data;
|
||||
};
|
||||
state_type m_state;
|
||||
UndoObserver* m_observer;
|
||||
int test_data;
|
||||
};
|
||||
state_type m_state;
|
||||
UndoObserver* m_observer;
|
||||
public:
|
||||
undoable_test()
|
||||
: m_observer( GlobalUndoSystem().observer( this ) ){
|
||||
}
|
||||
~undoable_test(){
|
||||
GlobalUndoSystem().release( this );
|
||||
}
|
||||
UndoMemento* exportState() const {
|
||||
return new state_type( m_state );
|
||||
}
|
||||
void importState( const UndoMemento* state ){
|
||||
ASSERT_NOTNULL( state );
|
||||
undoable_test()
|
||||
: m_observer( GlobalUndoSystem().observer( this ) ){
|
||||
}
|
||||
~undoable_test(){
|
||||
GlobalUndoSystem().release( this );
|
||||
}
|
||||
UndoMemento* exportState() const {
|
||||
return new state_type( m_state );
|
||||
}
|
||||
void importState( const UndoMemento* state ){
|
||||
ASSERT_NOTNULL( state );
|
||||
|
||||
m_observer->save( this );
|
||||
m_state = *( static_cast<const state_type*>( state ) );
|
||||
}
|
||||
m_observer->save( this );
|
||||
m_state = *( static_cast<const state_type*>( state ) );
|
||||
}
|
||||
|
||||
void mutate( unsigned int data ){
|
||||
m_observer->save( this );
|
||||
m_state.test_data = data;
|
||||
}
|
||||
void mutate( unsigned int data ){
|
||||
m_observer->save( this );
|
||||
m_state.test_data = data;
|
||||
}
|
||||
};
|
||||
|
||||
#if 0
|
||||
@@ -490,17 +490,17 @@ void mutate( unsigned int data ){
|
||||
class TestUndo
|
||||
{
|
||||
public:
|
||||
TestUndo(){
|
||||
undoable_test test;
|
||||
GlobalUndoSystem().begin( "bleh" );
|
||||
test.mutate( 3 );
|
||||
GlobalUndoSystem().begin( "blah" );
|
||||
test.mutate( 4 );
|
||||
GlobalUndoSystem().undo();
|
||||
GlobalUndoSystem().undo();
|
||||
GlobalUndoSystem().redo();
|
||||
GlobalUndoSystem().redo();
|
||||
}
|
||||
TestUndo(){
|
||||
undoable_test test;
|
||||
GlobalUndoSystem().begin( "bleh" );
|
||||
test.mutate( 3 );
|
||||
GlobalUndoSystem().begin( "blah" );
|
||||
test.mutate( 4 );
|
||||
GlobalUndoSystem().undo();
|
||||
GlobalUndoSystem().undo();
|
||||
GlobalUndoSystem().redo();
|
||||
GlobalUndoSystem().redo();
|
||||
}
|
||||
};
|
||||
|
||||
TestUndo g_TestUndo;
|
||||
|
||||
Reference in New Issue
Block a user