Command.cpp

Go to the documentation of this file.

#include "Command.h"

// The maximum amount of undo history saved by the command invoker
const int MAX_UNDO_COUNT = 100;

CompositeCommand::~CompositeCommand()
{
    //we must delete all child commands when this is being deleted
    FOREACH(iter, std::list<ICommand*>, _commands)
        delete *iter;
}

void CompositeCommand::addCommand(ICommand* command)
{
    _commands.push_back(command);
}

bool CompositeCommand::isCumulative(ICommand* command)
{
    //the command must be a composite
    CompositeCommand* cmd = dynamic_cast<CompositeCommand*>(command);
    if(cmd == NULL)
        return false;

    //it must contain the same number of commands
    if(cmd->_commands.size() != _commands.size())
        return false;

    //each command must be equivalent to its matching command
    std::list<ICommand*>::const_iterator myIter = _commands.begin();
    std::list<ICommand*>::const_iterator theirIter = cmd->_commands.begin();
    while(myIter != _commands.end())
    {
        //if they do not match, reject
        if(!((*myIter)->isCumulative(*theirIter)))
            return false;
        //otherwise move on
        ++myIter;
        ++theirIter;
    }

    //if all of the above is met, they must be cumulative
    return true;
}

void CompositeCommand::executeCumulative(ICommand* command)
{
    CompositeCommand* cmd = dynamic_cast<CompositeCommand*>(command);

    //go through all the commands between each composite
    std::list<ICommand*>::const_iterator myIter = _commands.begin();
    std::list<ICommand*>::const_iterator theirIter = cmd->_commands.begin();
    while(myIter != _commands.end())
    {
        //apply from this object to the given objects
        (*myIter)->executeCumulative(*theirIter);
        ++myIter;
        ++theirIter;
    }
}

void CompositeCommand::execute()
{
    FOREACH(iter, std::list<ICommand*>, _commands)
        (*iter)->execute();
}

void CompositeCommand::undo()
{
    FOREACH(iter, std::list<ICommand*>, _commands)
        (*iter)->undo();
}

void CommandInvoker::clearUndo()
{
    FOREACH(iter, std::list<ICommand*>, _undoCommands)
        delete *iter;
    
    _undoCommands.clear();
}

void CommandInvoker::clearRedo()
{
    FOREACH(iter, std::list<ICommand*>, _redoCommands)
        delete *iter;
    
    _redoCommands.clear();
}

void CommandInvoker::addCommandToUndo(ICommand* command)
{
    //if undo is not enabled, then we cannot add this
    if(!_undoEnabled)
        return;

    //add command to list
    _undoCommands.push_back(command);
    //if list is too long now, trim it down
    if(_undoCommands.size() > MAX_UNDO_COUNT)
        _undoCommands.pop_front();
}

CommandInvoker::CommandInvoker():
    _undoEnabled(true),
    _redoEnabled(true)
{
}

CommandInvoker::~CommandInvoker()
{
    clearUndo();
    clearRedo();
}

ICommand* CommandInvoker::getLastCommand()
{
    if(_undoCommands.size() > 0)
        return _undoCommands.back();
    else
        return NULL;
}

void CommandInvoker::submitCommand(ICommand* command)
{
    //check if the command is cumulative
    if(command->isCumulative(getLastCommand()))
    {
        //if command is cumulative, then execute as cumulative
        //then delete because necessary state is now in last command
        command->executeCumulative(getLastCommand());
        delete command;
    }
    else
    {
        //if command is non-cumulative, then execute and add to undo
        command->execute();
        addCommandToUndo(command);      
    }

    //submitting a new command always invalidates redo
    clearRedo();
}

void CommandInvoker::undo()
{
    //ensure there is a command to undo
    if(_undoCommands.size() == 0 || !_undoEnabled)
        return;

    //get the last command
    ICommand* lastCommand = getLastCommand();
    _undoCommands.pop_back();

    //undo the command
    lastCommand->undo();

    //save to redo list
    if(_redoEnabled)
        _redoCommands.push_back(lastCommand);
}

void CommandInvoker::redo()
{
    //ensure there is a command to redo
    if(_redoCommands.size() == 0 || !_redoEnabled)
        return;

    // Get the last command from the list
    ICommand* lastCommandUndone = _redoCommands.back();
    _redoCommands.pop_back();

    //execute it 
    lastCommandUndone->execute();

    //then put it back on the undo list
    addCommandToUndo(lastCommandUndone);
}

bool CommandInvoker::isUndoAvailable()
{
    return _undoCommands.size() != 0;
}

bool CommandInvoker::isRedoAvailable()
{
    return _redoCommands.size() != 0;
}

void CommandInvoker::setUndoEnabled(bool enabled)
{
    _undoEnabled = enabled;
    if(!_undoEnabled)
        clearUndo();
}

void CommandInvoker::setRedoEnabled(bool enabled)
{
    _redoEnabled = enabled;
    if(!_redoEnabled)
        clearRedo();
}