source: src/Actions/ActionSequence.cpp@ 9c1324

/*
 * Project: MoleCuilder
 * Description: creates and alters molecular systems
 * Copyright (C)  2010-2012 University of Bonn. All rights reserved.
 * 
 *
 *   This file is part of MoleCuilder.
 *
 *    MoleCuilder is free software: you can redistribute it and/or modify
 *    it under the terms of the GNU General Public License as published by
 *    the Free Software Foundation, either version 2 of the License, or
 *    (at your option) any later version.
 *
 *    MoleCuilder is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *    GNU General Public License for more details.
 *
 *    You should have received a copy of the GNU General Public License
 *    along with MoleCuilder.  If not, see <http://www.gnu.org/licenses/>.
 */

/*
 * ActionSequenze.cpp
 *
 *  Created on: Dec 17, 2009
 *      Author: crueger
 */

// include config.h
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include "CodePatterns/MemDebug.hpp"

#include "Actions/ActionSequence.hpp"
#include "Actions/Action.hpp"
#include "UIElements/Dialog.hpp"

#include "CodePatterns/Assert.hpp"

using namespace MoleCuilder;

ActionSequence::ActionSequence() :
    loop(1)
{}

ActionSequence::~ActionSequence()
{}


void ActionSequence::addAction(Action* _action){
  actions.push_back(_action);
}

Action* ActionSequence::removeLastAction(){
  if(actions.empty()) {
    return 0;
  }
  else {
    Action* theAction;
    theAction = actions.back();
    actions.pop_back();
    return theAction;
  }
}

// this method is used outside the ActionModule
// Each action registers itself with the history
Dialog* ActionSequence::fillAllDialogs(Dialog *dialog){
  for(actionSet::iterator it=actions.begin(); it!=actions.end(); it++){
    dialog = (*it)->fillDialog(dialog);
  }
  return dialog;
}

// this method is used outside the ActionModule
// Each action registers itself with the history
void ActionSequence::callAll(){
  for (int i=0;i<loop;++i)
    for(actionSet::iterator it=actions.begin(); it!=actions.end(); it++){
      // we want to have a global bookkeeping for all actions in the sequence, so
      // we bypass the normal call
      (*it)->call();
    }
}

// This method is used internally when MakroActions are constructed.
// In this case only the makro Action should be registered and
// handle the states
ActionSequence::stateSet ActionSequence::callAll(bool){
  stateSet states;
  for (int i=0;i<loop;++i)
    for(actionSet::iterator it=actions.begin(); it!=actions.end(); it++){
      // we want to have a global bookkeeping for all actions in the sequence, so
      // we bypass the normal call
      Action::state_ptr state = (*it)->performCall();
      states.push_back(state);
    }
  return states;
}

ActionSequence::stateSet ActionSequence::undoAll(stateSet states){
  ASSERT(canUndo(),"Trying to undo a sequence that contains methods that can't be undone");
  stateSet res;
  actionSet::reverse_iterator actionRit = actions.rbegin();
  stateSet::reverse_iterator stateRit = states.rbegin();
  for(;actionRit!=actions.rend();++actionRit,++stateRit){
    ASSERT(stateRit!=states.rend(),"End of states prematurely reached.");
    if((*actionRit)->shouldUndo()){
      Action::state_ptr newState = (*actionRit)->performUndo(*stateRit);
      // The order of the states has to correspond to the order of the actions
      // this is why we have to add at the beginning
      res.push_front(newState);
    }
    else{
      res.push_front(Action::success);
    }
  }
  return res;
}

ActionSequence::stateSet ActionSequence::redoAll(stateSet states){
  stateSet res;
  actionSet::iterator actionIt = actions.begin();
  stateSet::iterator stateIt = states.begin();
  for(;actionIt!=actions.end();++actionIt,++stateIt){
    ASSERT(stateIt!=states.end(),"End of states prematurely reached.");
    if((*actionIt)->shouldUndo()){
      Action::state_ptr newState =(*actionIt)->performRedo(*stateIt);
      res.push_back(newState);
    }
    else{
      res.push_back(Action::success);
    }
  }
  return res;
}

bool ActionSequence::canUndo(){
  bool canUndo=true;
  for(std::deque<Action*>::iterator it=actions.begin(); it!=actions.end(); ++it){
    if((*it)->shouldUndo()){
      canUndo &= (*it)->canUndo();
    }
  }
  return canUndo;
}

bool ActionSequence::shouldUndo(){
  bool shouldUndo = false;
  for(std::deque<Action*>::iterator it=actions.begin();it!=actions.end();++it){
    shouldUndo |= (*it)->shouldUndo();
  }
  return shouldUndo;
}