Ignore:
Timestamp:
Aug 28, 2010, 12:57:56 AM (15 years ago)
Author:
Frederik Heber <heber@…>
Branches:
Action_Thermostats, Add_AtomRandomPerturbation, Add_FitFragmentPartialChargesAction, Add_RotateAroundBondAction, Add_SelectAtomByNameAction, Added_ParseSaveFragmentResults, AddingActions_SaveParseParticleParameters, Adding_Graph_to_ChangeBondActions, Adding_MD_integration_tests, Adding_ParticleName_to_Atom, Adding_StructOpt_integration_tests, AtomFragments, Automaking_mpqc_open, AutomationFragmentation_failures, Candidate_v1.5.4, Candidate_v1.6.0, Candidate_v1.6.1, ChangeBugEmailaddress, ChangingTestPorts, ChemicalSpaceEvaluator, CombiningParticlePotentialParsing, Combining_Subpackages, Debian_Package_split, Debian_package_split_molecuildergui_only, Disabling_MemDebug, Docu_Python_wait, EmpiricalPotential_contain_HomologyGraph, EmpiricalPotential_contain_HomologyGraph_documentation, Enable_parallel_make_install, Enhance_userguide, Enhanced_StructuralOptimization, Enhanced_StructuralOptimization_continued, Example_ManyWaysToTranslateAtom, Exclude_Hydrogens_annealWithBondGraph, FitPartialCharges_GlobalError, Fix_BoundInBox_CenterInBox_MoleculeActions, Fix_ChargeSampling_PBC, Fix_ChronosMutex, Fix_FitPartialCharges, Fix_FitPotential_needs_atomicnumbers, Fix_ForceAnnealing, Fix_IndependentFragmentGrids, Fix_ParseParticles, Fix_ParseParticles_split_forward_backward_Actions, Fix_PopActions, Fix_QtFragmentList_sorted_selection, Fix_Restrictedkeyset_FragmentMolecule, Fix_StatusMsg, Fix_StepWorldTime_single_argument, Fix_Verbose_Codepatterns, Fix_fitting_potentials, Fixes, ForceAnnealing_goodresults, ForceAnnealing_oldresults, ForceAnnealing_tocheck, ForceAnnealing_with_BondGraph, ForceAnnealing_with_BondGraph_continued, ForceAnnealing_with_BondGraph_continued_betteresults, ForceAnnealing_with_BondGraph_contraction-expansion, FragmentAction_writes_AtomFragments, FragmentMolecule_checks_bonddegrees, GeometryObjects, Gui_Fixes, Gui_displays_atomic_force_velocity, ImplicitCharges, IndependentFragmentGrids, IndependentFragmentGrids_IndividualZeroInstances, IndependentFragmentGrids_IntegrationTest, IndependentFragmentGrids_Sole_NN_Calculation, JobMarket_RobustOnKillsSegFaults, JobMarket_StableWorkerPool, JobMarket_unresolvable_hostname_fix, MoreRobust_FragmentAutomation, ODR_violation_mpqc_open, PartialCharges_OrthogonalSummation, PdbParser_setsAtomName, PythonUI_with_named_parameters, QtGui_reactivate_TimeChanged_changes, Recreated_GuiChecks, Rewrite_FitPartialCharges, RotateToPrincipalAxisSystem_UndoRedo, SaturateAtoms_findBestMatching, SaturateAtoms_singleDegree, StoppableMakroAction, Subpackage_CodePatterns, Subpackage_JobMarket, Subpackage_LinearAlgebra, Subpackage_levmar, Subpackage_mpqc_open, Subpackage_vmg, Switchable_LogView, ThirdParty_MPQC_rebuilt_buildsystem, TrajectoryDependenant_MaxOrder, TremoloParser_IncreasedPrecision, TremoloParser_MultipleTimesteps, TremoloParser_setsAtomName, Ubuntu_1604_changes, stable
Children:
966e12
Parents:
53d01c
git-author:
Frederik Heber <heber@…> (08/26/10 21:05:34)
git-committer:
Frederik Heber <heber@…> (08/28/10 00:57:56)
Message:

All Actions are converted to the new macro framework.

  • included all three values that have been used to create or convert the files
    • createdef.sh
    • createCpp.sh
    • createHeader.sh
Location:
src/Actions/WorldAction
Files:
12 added
24 edited

Legend:

Unmodified
Added
Removed

  • src/Actions/WorldAction/AddEmptyBoundaryAction.cpp

    r53d01c r1fd675  
    2020#include "Helpers/MemDebug.hpp"
    2121
    22 #include "Actions/WorldAction/AddEmptyBoundaryAction.hpp"
    23 #include "Actions/ActionRegistry.hpp"
    2422#include "atom.hpp"
    2523#include "Helpers/Log.hpp"
    … …  
    3331using namespace std;
    3432
    35 #include "UIElements/UIFactory.hpp"
    36 #include "UIElements/Dialog.hpp"
    37 #include "Actions/ValueStorage.hpp"
    38 #include "Helpers/Assert.hpp"
     33#include "Actions/WorldAction/AddEmptyBoundaryAction.hpp"
    3934
    40 const char WorldAddEmptyBoundaryAction::NAME[] = "boundary";
    41 
    42 WorldAddEmptyBoundaryAction::WorldAddEmptyBoundaryAction() :
    43   Action(NAME)
    44 {}
    45 
    46 WorldAddEmptyBoundaryAction::~WorldAddEmptyBoundaryAction()
    47 {}
    48 
    49 void WorldAddEmptyBoundary(Vector &boundary) {
    50   ValueStorage::getInstance().setCurrentValue(WorldAddEmptyBoundaryAction::NAME, boundary);
    51   ActionRegistry::getInstance().getActionByName(WorldAddEmptyBoundaryAction::NAME)->call(Action::NonInteractive);
    52 };
    53 
    54 void WorldAddEmptyBoundaryAction::getParametersfromValueStorage()
    55 {};
    56 
    57 Dialog* WorldAddEmptyBoundaryAction::fillDialog(Dialog *dialog) {
    58   ASSERT(dialog,"No Dialog given when filling action dialog");
    59 
    60   dialog->queryVector(NAME, false, ValueStorage::getInstance().getDescription(NAME));
    61 
    62   return dialog;
    63 }
    64 
     35// and construct the stuff
     36#include "AddEmptyBoundaryAction.def"
     37#include "Action_impl_pre.hpp"
     38/** =========== define the function ====================== */
    6539Action::state_ptr WorldAddEmptyBoundaryAction::performCall() {
    66   Vector boundary;
    6740  Vector Min;
    6841  Vector Max;
    6942  int j=0;
    7043
    71   ValueStorage::getInstance().queryCurrentValue(NAME, boundary);
     44  // obtain information
     45  getParametersfromValueStorage();
    7246
    7347  // get maximum and minimum
    … …  
    9266  for (int i=0;i<NDIM;i++) {
    9367    j += i+1;
    94     cell_size[j] = (Max[i]-Min[i]+2.*boundary[i]);
     68    cell_size[j] = (Max[i]-Min[i]+2.*params.boundary[i]);
    9569  }
    9670  World::getInstance().setDomain(cell_size);
    … …  
    9973  AtomRunner = AllAtoms.begin();
    10074  for (; AtomRunner != AllAtoms.end(); ++AtomRunner)
    101     *(*AtomRunner) -= Min - boundary;
     75    *(*AtomRunner) -= Min - params.boundary;
    10276  return Action::success;
    10377}
    … …  
    128102  return NAME;
    129103}
     104/** =========== end of function ====================== */

  • src/Actions/WorldAction/AddEmptyBoundaryAction.hpp

    r53d01c r1fd675  
    1010
    1111#include "Actions/Action.hpp"
    12 #include "LinearAlgebra/Vector.hpp"
    1312
    14 void WorldAddEmptyBoundary(Vector &boundary);
    15 
    16 class WorldAddEmptyBoundaryAction : public Action {
    17   friend void WorldAddEmptyBoundary(Vector &boundary);
    18 
    19 public:
    20   WorldAddEmptyBoundaryAction();
    21   virtual ~WorldAddEmptyBoundaryAction();
    22 
    23   bool canUndo();
    24   bool shouldUndo();
    25 
    26   virtual const std::string getName();
    27 protected:
    28   virtual Dialog * fillDialog(Dialog *dialog);
    29 private:
    30   virtual void getParametersfromValueStorage();
    31   virtual Action::state_ptr performCall();
    32   virtual Action::state_ptr performUndo(Action::state_ptr);
    33   virtual Action::state_ptr performRedo(Action::state_ptr);
    34 
    35   static const char NAME[];
    36 };
     13#include "AddEmptyBoundaryAction.def"
     14#include "Action_impl_header.hpp"
    3715
    3816#endif /* ADDEMPTYBOUNDARYACTION_HPP_ */

  • src/Actions/WorldAction/BoundInBoxAction.cpp

    r53d01c r1fd675  
    2020#include "Helpers/MemDebug.hpp"
    2121
    22 #include "Actions/WorldAction/BoundInBoxAction.hpp"
    23 #include "Actions/ActionRegistry.hpp"
    2422#include "Helpers/Log.hpp"
    2523#include "molecule.hpp"
    … …  
    3230using namespace std;
    3331
    34 #include "UIElements/UIFactory.hpp"
    35 #include "UIElements/Dialog.hpp"
    36 #include "Actions/ValueStorage.hpp"
     32#include "Actions/WorldAction/BoundInBoxAction.hpp"
    3733
    38 const char WorldBoundInBoxAction::NAME[] = "bound-in-box";
    39 
    40 WorldBoundInBoxAction::WorldBoundInBoxAction() :
    41   Action(NAME)
    42 {}
    43 
    44 WorldBoundInBoxAction::~WorldBoundInBoxAction()
    45 {}
    46 
    47 void WorldBoundInBox() {
    48   ActionRegistry::getInstance().getActionByName(WorldBoundInBoxAction::NAME)->call(Action::NonInteractive);
    49 };
    50 
    51 void WorldBoundInBoxAction::getParametersfromValueStorage()
    52 {};
    53 
    54 Dialog* WorldBoundInBoxAction::fillDialog(Dialog *dialog) {
    55   ASSERT(dialog,"No Dialog given when filling action dialog");
    56 
    57   dialog->queryEmpty(NAME, ValueStorage::getInstance().getDescription(NAME));
    58 
    59   return dialog;
    60 }
    61 
     34// and construct the stuff
     35#include "BoundInBoxAction.def"
     36#include "Action_impl_pre.hpp"
     37/** =========== define the function ====================== */
    6238Action::state_ptr WorldBoundInBoxAction::performCall() {
     39  // obtain information
     40  getParametersfromValueStorage();
    6341
    6442  // center
    … …  
    9573  return NAME;
    9674}
     75/** =========== end of function ====================== */

  • src/Actions/WorldAction/BoundInBoxAction.hpp

    r53d01c r1fd675  
    1111#include "Actions/Action.hpp"
    1212
    13 void WorldBoundInBox();
    14 
    15 class WorldBoundInBoxAction : public Action {
    16   friend void WorldBoundInBox();
    17 
    18 public:
    19   WorldBoundInBoxAction();
    20   virtual ~WorldBoundInBoxAction();
    21 
    22   bool canUndo();
    23   bool shouldUndo();
    24 
    25   virtual const std::string getName();
    26 protected:
    27   virtual Dialog * fillDialog(Dialog *dialog);
    28 private:
    29   virtual void getParametersfromValueStorage();
    30   virtual Action::state_ptr performCall();
    31   virtual Action::state_ptr performUndo(Action::state_ptr);
    32   virtual Action::state_ptr performRedo(Action::state_ptr);
    33 
    34   static const char NAME[];
    35 };
     13#include "BoundInBoxAction.def"
     14#include "Action_impl_header.hpp"
    3615
    3716#endif /* BOUNDINBOXACTION_HPP_ */

  • src/Actions/WorldAction/CenterInBoxAction.cpp

    r53d01c r1fd675  
    2020#include "Helpers/MemDebug.hpp"
    2121
    22 #include "Actions/WorldAction/CenterInBoxAction.hpp"
    23 #include "Actions/ActionRegistry.hpp"
    2422#include "Box.hpp"
    2523#include "Helpers/Log.hpp"
    … …  
    3230using namespace std;
    3331
    34 #include "UIElements/UIFactory.hpp"
    35 #include "UIElements/Dialog.hpp"
    36 #include "Actions/ValueStorage.hpp"
     32#include "Actions/WorldAction/CenterInBoxAction.hpp"
    3733
    38 const char WorldCenterInBoxAction::NAME[] = "center-in-box";
     34// and construct the stuff
     35#include "CenterInBoxAction.def"
     36#include "Action_impl_pre.hpp"
     37/** =========== define the function ====================== */
     38Action::state_ptr WorldCenterInBoxAction::performCall() {
     39  // obtain information
     40  getParametersfromValueStorage();
    3941
    40 WorldCenterInBoxAction::WorldCenterInBoxAction() :
    41   Action(NAME)
    42 {}
    43 
    44 WorldCenterInBoxAction::~WorldCenterInBoxAction()
    45 {}
    46 
    47 void WorldCenterInBox(Box &_box) {
    48   ValueStorage::getInstance().setCurrentValue(WorldCenterInBoxAction::NAME, _box);
    49   ActionRegistry::getInstance().getActionByName(WorldCenterInBoxAction::NAME)->call(Action::NonInteractive);
    50 };
    51 
    52 void WorldCenterInBoxAction::getParametersfromValueStorage()
    53 {};
    54 
    55 Dialog* WorldCenterInBoxAction::fillDialog(Dialog *dialog) {
    56   ASSERT(dialog,"No Dialog given when filling action dialog");
    57 
    58   dialog->queryBox(NAME, ValueStorage::getInstance().getDescription(NAME));
    59 
    60   return dialog;
    61 }
    62 
    63 Action::state_ptr WorldCenterInBoxAction::performCall() {
    64 
    65   Box& cell_size = World::getInstance().getDomain();
    66   ValueStorage::getInstance().queryCurrentValue(NAME, cell_size);
    67   World::getInstance().setDomain(cell_size.getM());
     42  World::getInstance().setDomain(params.cell_size.getM());
    6843
    6944  // center
    … …  
    10075  return NAME;
    10176}
     77/** =========== end of function ====================== */

  • src/Actions/WorldAction/CenterInBoxAction.hpp

    r53d01c r1fd675  
    1010
    1111#include "Actions/Action.hpp"
    12 #include "Box.hpp"
    1312
    14 void WorldCenterInBox(Box &_box);
    15 
    16 class WorldCenterInBoxAction : public Action {
    17   friend void WorldCenterInBox(Box &_box);
    18 
    19 public:
    20   WorldCenterInBoxAction();
    21   virtual ~WorldCenterInBoxAction();
    22 
    23   bool canUndo();
    24   bool shouldUndo();
    25 
    26   virtual const std::string getName();
    27 protected:
    28   virtual Dialog * fillDialog(Dialog *dialog);
    29 private:
    30   virtual void getParametersfromValueStorage();
    31   virtual Action::state_ptr performCall();
    32   virtual Action::state_ptr performUndo(Action::state_ptr);
    33   virtual Action::state_ptr performRedo(Action::state_ptr);
    34 
    35   static const char NAME[];
    36 };
     13#include "CenterInBoxAction.def"
     14#include "Action_impl_header.hpp"
    3715
    3816#endif /* CENTERINBOXACTION_HPP_ */

  • src/Actions/WorldAction/CenterOnEdgeAction.cpp

    r53d01c r1fd675  
    2020#include "Helpers/MemDebug.hpp"
    2121
    22 #include "Actions/WorldAction/CenterOnEdgeAction.hpp"
    23 #include "Actions/ActionRegistry.hpp"
    2422#include "atom.hpp"
    2523#include "Helpers/Log.hpp"
    … …  
    3331using namespace std;
    3432
    35 #include "UIElements/UIFactory.hpp"
    36 #include "UIElements/Dialog.hpp"
    37 #include "Actions/ValueStorage.hpp"
    38 #include "Helpers/Assert.hpp"
     33#include "Actions/WorldAction/CenterOnEdgeAction.hpp"
    3934
    40 const char WorldCenterOnEdgeAction::NAME[] = "center-edge";
    41 
    42 WorldCenterOnEdgeAction::WorldCenterOnEdgeAction() :
    43   Action(NAME)
    44 {}
    45 
    46 WorldCenterOnEdgeAction::~WorldCenterOnEdgeAction()
    47 {}
    48 
    49 void WorldCenterOnEdge() {
    50   ActionRegistry::getInstance().getActionByName(WorldCenterOnEdgeAction::NAME)->call(Action::NonInteractive);
    51 };
    52 
    53 void WorldCenterOnEdgeAction::getParametersfromValueStorage()
    54 {};
    55 
    56 Dialog* WorldCenterOnEdgeAction::fillDialog(Dialog *dialog) {
    57   ASSERT(dialog,"No Dialog given when filling action dialog");
    58 
    59   dialog->queryEmpty(NAME, ValueStorage::getInstance().getDescription(NAME));
    60 
    61   return dialog;
    62 }
    63 
     35// and construct the stuff
     36#include "CenterOnEdgeAction.def"
     37#include "Action_impl_pre.hpp"
     38/** =========== define the function ====================== */
    6439Action::state_ptr WorldCenterOnEdgeAction::performCall() {
    6540  Vector Min;
    6641  Vector Max;
     42
     43  // obtain information
     44  getParametersfromValueStorage();
    6745
    6846  // get maximum and minimum
    … …  
    12098  return NAME;
    12199}
     100/** =========== end of function ====================== */

  • src/Actions/WorldAction/CenterOnEdgeAction.hpp

    r53d01c r1fd675  
    1111#include "Actions/Action.hpp"
    1212
    13 void WorldCenterOnEdge();
    14 
    15 class WorldCenterOnEdgeAction : public Action {
    16   friend void WorldCenterOnEdge();
    17 
    18 public:
    19   WorldCenterOnEdgeAction();
    20   virtual ~WorldCenterOnEdgeAction();
    21 
    22   bool canUndo();
    23   bool shouldUndo();
    24 
    25   virtual const std::string getName();
    26 protected:
    27   virtual Dialog * fillDialog(Dialog *dialog);
    28 private:
    29   virtual void getParametersfromValueStorage();
    30   virtual Action::state_ptr performCall();
    31   virtual Action::state_ptr performUndo(Action::state_ptr);
    32   virtual Action::state_ptr performRedo(Action::state_ptr);
    33 
    34   static const char NAME[];
    35 };
     13#include "CenterOnEdgeAction.def"
     14#include "Action_impl_header.hpp"
    3615
    3716#endif /* CENTERONEDGEACTION_HPP_ */

  • src/Actions/WorldAction/ChangeBoxAction.cpp

    r53d01c r1fd675  
    2020#include "Helpers/MemDebug.hpp"
    2121
    22 #include "Actions/WorldAction/ChangeBoxAction.hpp"
    23 #include "Actions/ActionRegistry.hpp"
    2422#include "Helpers/Log.hpp"
    2523#include "Helpers/Verbose.hpp"
    … …  
    3331using namespace std;
    3432
    35 #include "UIElements/UIFactory.hpp"
    36 #include "UIElements/Dialog.hpp"
    37 #include "Actions/ValueStorage.hpp"
     33#include "Actions/WorldAction/ChangeBoxAction.hpp"
    3834
    39 const char WorldChangeBoxAction::NAME[] = "change-box";
     35// and construct the stuff
     36#include "ChangeBoxAction.def"
     37#include "Action_impl_pre.hpp"
     38/** =========== define the function ====================== */
     39Action::state_ptr WorldChangeBoxAction::performCall() {
     40  // obtain information
     41  getParametersfromValueStorage();
    4042
    41 WorldChangeBoxAction::WorldChangeBoxAction() :
    42   Action(NAME)
    43 {}
    44 
    45 WorldChangeBoxAction::~WorldChangeBoxAction()
    46 {}
    47 
    48 void WorldChangeBox(Box &_box) {
    49   ValueStorage::getInstance().setCurrentValue(WorldChangeBoxAction::NAME, _box);
    50   ActionRegistry::getInstance().getActionByName(WorldChangeBoxAction::NAME)->call(Action::NonInteractive);
    51 };
    52 
    53 void WorldChangeBoxAction::getParametersfromValueStorage()
    54 {};
    55 
    56 Dialog* WorldChangeBoxAction::fillDialog(Dialog *dialog) {
    57   ASSERT(dialog,"No Dialog given when filling action dialog");
    58 
    59   dialog->queryBox(NAME, ValueStorage::getInstance().getDescription(NAME));
    60 
    61   return dialog;
    62 }
    63 
    64 Action::state_ptr WorldChangeBoxAction::performCall() {
    65 
    66   Box cell_size;
    67   ValueStorage::getInstance().queryCurrentValue(NAME, cell_size);
    68   World::getInstance().setDomain(cell_size.getM()); // this is needed as only this function is OBSERVEd.
     43  World::getInstance().setDomain(params.cell_size.getM()); // this is needed as only this function is OBSERVEd.
    6944
    7045  DoLog(0) && (Log() << Verbose(0) << "Setting box domain to " << World::getInstance().getDomain().getM() << endl);
    … …  
    9772  return NAME;
    9873}
     74/** =========== end of function ====================== */

  • src/Actions/WorldAction/ChangeBoxAction.hpp

    r53d01c r1fd675  
    1010
    1111#include "Actions/Action.hpp"
    12 #include "Box.hpp"
    1312
    14 void WorldChangeBox(Box &_box);
    15 
    16 class WorldChangeBoxAction : public Action {
    17   friend void WorldChangeBox(Box &_box);
    18 
    19 public:
    20   WorldChangeBoxAction();
    21   virtual ~WorldChangeBoxAction();
    22 
    23   bool canUndo();
    24   bool shouldUndo();
    25 
    26   virtual const std::string getName();
    27 protected:
    28   virtual Dialog * fillDialog(Dialog *dialog);
    29 private:
    30   virtual void getParametersfromValueStorage();
    31   virtual Action::state_ptr performCall();
    32   virtual Action::state_ptr performUndo(Action::state_ptr);
    33   virtual Action::state_ptr performRedo(Action::state_ptr);
    34 
    35   static const char NAME[];
    36 };
     13#include "ChangeBoxAction.def"
     14#include "Action_impl_header.hpp"
    3715
    3816#endif /* CHANGEBOXACTION_HPP_ */

  • src/Actions/WorldAction/InputAction.cpp

    r53d01c r1fd675  
    2020#include "Helpers/MemDebug.hpp"
    2121
    22 #include "Actions/WorldAction/InputAction.hpp"
    23 #include "Actions/ActionRegistry.hpp"
    2422#include "Helpers/Log.hpp"
    2523#include "molecule.hpp"
    … …  
    3432using namespace std;
    3533
    36 #include "UIElements/UIFactory.hpp"
    37 #include "UIElements/Dialog.hpp"
    38 #include "Actions/ValueStorage.hpp"
     34#include "Actions/WorldAction/InputAction.hpp"
    3935
    40 const char WorldInputAction::NAME[] = "input";
    41 
    42 WorldInputAction::WorldInputAction() :
    43   Action(NAME)
    44 {}
    45 
    46 WorldInputAction::~WorldInputAction()
    47 {}
    48 
    49 void WorldInput(std::string &filename) {
    50   ValueStorage::getInstance().setCurrentValue(WorldInputAction::NAME, filename);
    51   ActionRegistry::getInstance().getActionByName(WorldInputAction::NAME)->call(Action::NonInteractive);
    52 };
    53 
    54 void WorldInputAction::getParametersfromValueStorage()
    55 {};
    56 
    57 Dialog* WorldInputAction::fillDialog(Dialog *dialog) {
    58   ASSERT(dialog,"No Dialog given when filling action dialog");
    59 
    60   dialog->queryString(NAME, ValueStorage::getInstance().getDescription(NAME));
    61 
    62   return dialog;
    63 }
    64 
     36// and construct the stuff
     37#include "InputAction.def"
     38#include "Action_impl_pre.hpp"
     39/** =========== define the function ====================== */
    6540Action::state_ptr WorldInputAction::performCall() {
    6641  MoleculeListClass *molecules = World::getInstance().getMolecules();
    6742  molecule *mol = NULL;
    68   std::string filename;
    6943  std::ifstream test;
    7044
    71   ValueStorage::getInstance().queryCurrentValue(NAME, filename);
     45  // obtain information
     46  getParametersfromValueStorage();
    7247
    7348  DoLog(0) && (Log() << Verbose(0) << "Config file given." << endl);
    74   if (filename.find('.') != string::npos) {
    75     std::string FilenamePrefix = filename.substr(0,filename.find_last_of('.'));
    76     std::string FilenameSuffix = filename.substr(filename.find_last_of('.')+1, filename.length());
     49  if (params.filename.find('.') != string::npos) {
     50    std::string FilenamePrefix = params.filename.substr(0,params.filename.find_last_of('.'));
     51    std::string FilenameSuffix = params.filename.substr(params.filename.find_last_of('.')+1, params.filename.length());
    7752    DoLog(1) && (Log() << Verbose(1) << "Setting config file name prefix to " << FilenamePrefix << "." << endl);
    78     test.open(filename.c_str());
     53    test.open(params.filename.c_str());
    7954    if (test == NULL) {
    80       DoLog(1) && (Log() << Verbose(1) << "Specified config file " << filename << " not found." << endl);
     55      DoLog(1) && (Log() << Verbose(1) << "Specified config file " << params.filename << " not found." << endl);
    8156    } else {
    8257      DoLog(1) && (Log() << Verbose(1) << "Specified config file found, parsing ... ");
    … …  
    9873      molecules->insert(mol);
    9974    }
    100     mol->SetNameFromFilename(filename.substr(0,filename.find('.')).c_str());
     75    mol->SetNameFromFilename(params.filename.substr(0,params.filename.find('.')).c_str());
    10176  } else {
    10277    DoeLog(1) && (eLog() << Verbose(1) << "Input file does not have a suffix, cannot recognize format." << endl);
    … …  
    130105  return NAME;
    131106}
     107/** =========== end of function ====================== */

  • src/Actions/WorldAction/InputAction.hpp

    r53d01c r1fd675  
    1111#include "Actions/Action.hpp"
    1212
    13 void WorldInput(std::string &filename);
    14 
    15 class WorldInputAction : public Action {
    16   friend void WorldInput(std::string &filename);
    17 
    18 public:
    19   WorldInputAction();
    20   virtual ~WorldInputAction();
    21 
    22   bool canUndo();
    23   bool shouldUndo();
    24 
    25   virtual const std::string getName();
    26 protected:
    27   virtual Dialog * fillDialog(Dialog *dialog);
    28 private:
    29   virtual void getParametersfromValueStorage();
    30   virtual Action::state_ptr performCall();
    31   virtual Action::state_ptr performUndo(Action::state_ptr);
    32   virtual Action::state_ptr performRedo(Action::state_ptr);
    33 
    34   static const char NAME[];
    35 };
     13#include "InputAction.def"
     14#include "Action_impl_header.hpp"
    3615
    3716#endif /* INPUTACTION_HPP_ */

  • src/Actions/WorldAction/OutputAction.cpp

    r53d01c r1fd675  
    2020#include "Helpers/MemDebug.hpp"
    2121
    22 #include "Actions/WorldAction/OutputAction.hpp"
    23 #include "Actions/ActionRegistry.hpp"
    2422#include "Parser/ChangeTracker.hpp"
    2523#include "Helpers/Log.hpp"
    … …  
    3230using namespace std;
    3331
    34 #include "UIElements/UIFactory.hpp"
    35 #include "UIElements/Dialog.hpp"
    36 #include "Actions/ValueStorage.hpp"
     32#include "Actions/WorldAction/OutputAction.hpp"
    3733
    38 const char WorldOutputAction::NAME[] = "output";
    39 
    40 WorldOutputAction::WorldOutputAction() :
    41   Action(NAME)
    42 {}
    43 
    44 WorldOutputAction::~WorldOutputAction()
    45 {}
    46 
    47 void WorldOutput() {
    48   ActionRegistry::getInstance().getActionByName(WorldOutputAction::NAME)->call(Action::NonInteractive);
    49 };
    50 
    51 void WorldOutputAction::getParametersfromValueStorage()
    52 {};
    53 
    54 Dialog* WorldOutputAction::fillDialog(Dialog *dialog) {
    55   ASSERT(dialog,"No Dialog given when filling action dialog");
    56 
    57   dialog->queryEmpty(NAME, ValueStorage::getInstance().getDescription(NAME));
    58 
    59   return dialog;
    60 }
    61 
     34// and construct the stuff
     35#include "OutputAction.def"
     36#include "Action_impl_pre.hpp"
     37/** =========== define the function ====================== */
    6238Action::state_ptr WorldOutputAction::performCall() {
     39  // obtain information
     40  getParametersfromValueStorage();
    6341
    6442  DoLog(0) && (Log() << Verbose(0) << "Saving world to files." << endl);
    … …  
    9270  return NAME;
    9371}
     72/** =========== end of function ====================== */

  • src/Actions/WorldAction/OutputAction.hpp

    r53d01c r1fd675  
    1111#include "Actions/Action.hpp"
    1212
    13 void WorldOutput();
    14 
    15 class WorldOutputAction : public Action {
    16   friend void WorldOutput();
    17 
    18 public:
    19   WorldOutputAction();
    20   virtual ~WorldOutputAction();
    21 
    22   bool canUndo();
    23   bool shouldUndo();
    24 
    25   virtual const std::string getName();
    26 protected:
    27   virtual Dialog * fillDialog(Dialog *dialog);
    28 private:
    29   virtual void getParametersfromValueStorage();
    30   virtual Action::state_ptr performCall();
    31   virtual Action::state_ptr performUndo(Action::state_ptr);
    32   virtual Action::state_ptr performRedo(Action::state_ptr);
    33 
    34   static const char NAME[];
    35 };
     13#include "OutputAction.def"
     14#include "Action_impl_header.hpp"
    3615
    3716#endif /* OUTPUTACTION_HPP_ */

  • src/Actions/WorldAction/RepeatBoxAction.cpp

    r53d01c r1fd675  
    2020#include "Helpers/MemDebug.hpp"
    2121
    22 #include "Actions/WorldAction/RepeatBoxAction.hpp"
    23 #include "Actions/ActionRegistry.hpp"
     22#include "Descriptors/MoleculePtrDescriptor.hpp"
    2423#include "atom.hpp"
    2524#include "Helpers/Log.hpp"
    … …  
    3736using namespace std;
    3837
    39 #include "UIElements/UIFactory.hpp"
    40 #include "UIElements/Dialog.hpp"
    41 #include "Actions/ValueStorage.hpp"
    42 #include "Descriptors/MoleculeDescriptor.hpp"
    43 #include "Descriptors/MoleculePtrDescriptor.hpp"
     38#include "Actions/WorldAction/RepeatBoxAction.hpp"
    4439
    45 const char WorldRepeatBoxAction::NAME[] = "repeat-box";
    46 
    47 WorldRepeatBoxAction::WorldRepeatBoxAction() :
    48   Action(NAME)
    49 {}
    50 
    51 WorldRepeatBoxAction::~WorldRepeatBoxAction()
    52 {}
    53 
    54 void WorldRepeatBox(Vector &Repeater) {
    55   ValueStorage::getInstance().setCurrentValue(WorldRepeatBoxAction::NAME, Repeater);
    56   ActionRegistry::getInstance().getActionByName(WorldRepeatBoxAction::NAME)->call(Action::NonInteractive);
    57 };
    58 
    59 void WorldRepeatBoxAction::getParametersfromValueStorage()
    60 {};
    61 
    62 Dialog* WorldRepeatBoxAction::fillDialog(Dialog *dialog) {
    63   ASSERT(dialog,"No Dialog given when filling action dialog");
    64 
    65   dialog->queryVector(NAME, false, ValueStorage::getInstance().getDescription(NAME));
    66 
    67   return dialog;
    68 }
    69 
     40// and construct the stuff
     41#include "RepeatBoxAction.def"
     42#include "Action_impl_pre.hpp"
     43/** =========== define the function ====================== */
    7044Action::state_ptr WorldRepeatBoxAction::performCall() {
    71   Vector Repeater;
    7245  int count;
    7346  const element ** Elements;
    … …  
    7750  MoleculeListClass *molecules = World::getInstance().getMolecules();
    7851
    79   ValueStorage::getInstance().queryCurrentValue(NAME, Repeater);
     52  // obtain information
     53  getParametersfromValueStorage();
    8054
    8155  vector<molecule *> AllMolecules;
    … …  
    8862  }
    8963
    90   (cout << "Repeating box " << Repeater << " times for (x,y,z) axis." << endl);
     64  (cout << "Repeating box " << params.Repeater << " times for (x,y,z) axis." << endl);
    9165  Matrix M = World::getInstance().getDomain().getM();
    9266  Matrix newM = M;
    … …  
    9569  Matrix repMat;
    9670  for (int axis = 0; axis < NDIM; axis++) {
    97     Repeater[axis] = floor(Repeater[axis]);
    98     if (Repeater[axis] < 1) {
     71    params.Repeater[axis] = floor(params.Repeater[axis]);
     72    if (params.Repeater[axis] < 1) {
    9973      DoeLog(1) && (eLog()<< Verbose(1) << "Repetition factor must be greater than 1!" << endl);
    100       Repeater[axis] = 1;
     74      params.Repeater[axis] = 1;
    10175    }
    102     repMat.at(axis,axis) = Repeater[axis];
     76    repMat.at(axis,axis) = params.Repeater[axis];
    10377  }
    10478  newM *= repMat;
    … …  
    10781  molecule *newmol = NULL;
    10882  std::vector<Vector> vectors;
    109   for (n[0] = 0; n[0] < Repeater[0]; n[0]++) {
     83  for (n[0] = 0; n[0] < params.Repeater[0]; n[0]++) {
    11084    y[0] = n[0];
    111     for (n[1] = 0; n[1] < Repeater[1]; n[1]++) {
     85    for (n[1] = 0; n[1] < params.Repeater[1]; n[1]++) {
    11286      y[1] = n[1];
    113       for (n[2] = 0; n[2] < Repeater[2]; n[2]++) {
     87      for (n[2] = 0; n[2] < params.Repeater[2]; n[2]++) {
    11488        y[2] = n[2];
    11589        if ((n[0] == 0) && (n[1] == 0) && (n[2] == 0))
    … …  
    178152  return NAME;
    179153}
     154/** =========== end of function ====================== */

  • src/Actions/WorldAction/RepeatBoxAction.hpp

    r53d01c r1fd675  
    1010
    1111#include "Actions/Action.hpp"
    12 #include "LinearAlgebra/Vector.hpp"
    1312
    14 void WorldRepeatBox(Vector &Repeater);
    15 
    16 class WorldRepeatBoxAction : public Action {
    17   friend void WorldRepeatBox(Vector &Repeater);
    18 
    19 public:
    20   WorldRepeatBoxAction();
    21   virtual ~WorldRepeatBoxAction();
    22 
    23   bool canUndo();
    24   bool shouldUndo();
    25 
    26   virtual const std::string getName();
    27 protected:
    28   virtual Dialog * fillDialog(Dialog *dialog);
    29 private:
    30   virtual void getParametersfromValueStorage();
    31   virtual Action::state_ptr performCall();
    32   virtual Action::state_ptr performUndo(Action::state_ptr);
    33   virtual Action::state_ptr performRedo(Action::state_ptr);
    34 
    35   static const char NAME[];
    36 };
     13#include "RepeatBoxAction.def"
     14#include "Action_impl_header.hpp"
    3715
    3816#endif /* REPEATBOXACTION_HPP_ */

  • src/Actions/WorldAction/ScaleBoxAction.cpp

    r53d01c r1fd675  
    2020#include "Helpers/MemDebug.hpp"
    2121
    22 #include "Actions/WorldAction/ScaleBoxAction.hpp"
    23 #include "Actions/ActionRegistry.hpp"
    2422#include "atom.hpp"
    2523#include "Helpers/Log.hpp"
    … …  
    3533using namespace std;
    3634
    37 #include "UIElements/UIFactory.hpp"
    38 #include "UIElements/Dialog.hpp"
    39 #include "Actions/ValueStorage.hpp"
     35#include "Actions/WorldAction/ScaleBoxAction.hpp"
    4036
    41 const char WorldScaleBoxAction::NAME[] = "scale-box";
    42 
    43 WorldScaleBoxAction::WorldScaleBoxAction() :
    44   Action(NAME)
    45 {}
    46 
    47 WorldScaleBoxAction::~WorldScaleBoxAction()
    48 {}
    49 
    50 void WorldScaleBox(Vector &Scaler) {
    51   ValueStorage::getInstance().setCurrentValue(WorldScaleBoxAction::NAME, Scaler);
    52   ActionRegistry::getInstance().getActionByName(WorldScaleBoxAction::NAME)->call(Action::NonInteractive);
    53 };
    54 
    55 void WorldScaleBoxAction::getParametersfromValueStorage()
    56 {};
    57 
    58 Dialog* WorldScaleBoxAction::fillDialog(Dialog *dialog) {
    59   ASSERT(dialog,"No Dialog given when filling action dialog");
    60 
    61   dialog->queryVector(NAME, false, ValueStorage::getInstance().getDescription(NAME));
    62 
    63   return dialog;
    64 }
    65 
     37// and construct the stuff
     38#include "ScaleBoxAction.def"
     39#include "Action_impl_pre.hpp"
     40/** =========== define the function ====================== */
    6641Action::state_ptr WorldScaleBoxAction::performCall() {
    67   Vector Scaler;
    6842  double x[NDIM];
    6943
    70   ValueStorage::getInstance().queryCurrentValue(NAME, Scaler);
     44  // obtain information
     45  getParametersfromValueStorage();
    7146
    7247  DoLog(1) && (Log() << Verbose(1) << "Scaling all atomic positions by factor." << endl);
    7348  for (int i=0;i<NDIM;i++)
    74     x[i] = Scaler[i];
     49    x[i] = params.Scaler[i];
    7550  vector<atom*> AllAtoms = World::getInstance().getAllAtoms();
    7651  for(vector<atom*>::iterator AtomRunner = AllAtoms.begin(); AtomRunner != AllAtoms.end(); ++AtomRunner) {
    … …  
    11590  return NAME;
    11691}
     92/** =========== end of function ====================== */

  • src/Actions/WorldAction/ScaleBoxAction.hpp

    r53d01c r1fd675  
    1010
    1111#include "Actions/Action.hpp"
    12 #include "LinearAlgebra/Vector.hpp"
    1312
    14 void WorldScaleBox(Vector &Scaler);
    15 
    16 class WorldScaleBoxAction : public Action {
    17   friend void WorldScaleBox(Vector &Scaler);
    18 
    19 public:
    20   WorldScaleBoxAction();
    21   virtual ~WorldScaleBoxAction();
    22 
    23   bool canUndo();
    24   bool shouldUndo();
    25 
    26   virtual const std::string getName();
    27 protected:
    28   virtual Dialog * fillDialog(Dialog *dialog);
    29 private:
    30   virtual void getParametersfromValueStorage();
    31   virtual Action::state_ptr performCall();
    32   virtual Action::state_ptr performUndo(Action::state_ptr);
    33   virtual Action::state_ptr performRedo(Action::state_ptr);
    34 
    35   static const char NAME[];
    36 };
     13#include "ScaleBoxAction.def"
     14#include "Action_impl_header.hpp"
    3715
    3816#endif /* SCALEBOXACTION_HPP_ */

  • src/Actions/WorldAction/SetDefaultNameAction.cpp

    r53d01c r1fd675  
    2020#include "Helpers/MemDebug.hpp"
    2121
    22 #include "Actions/WorldAction/SetDefaultNameAction.hpp"
    23 #include "Actions/ActionRegistry.hpp"
    2422#include "Helpers/Log.hpp"
    2523#include "Helpers/Verbose.hpp"
    … …  
    3129using namespace std;
    3230
    33 #include "UIElements/UIFactory.hpp"
    34 #include "UIElements/Dialog.hpp"
    35 #include "Actions/ValueStorage.hpp"
     31#include "Actions/WorldAction/SetDefaultNameAction.hpp"
    3632
     33// and construct the stuff
     34#include "SetDefaultNameAction.def"
     35#include "Action_impl_pre.hpp"
     36/** =========== define the function ====================== */
     37Action::state_ptr WorldSetDefaultNameAction::performCall() {
     38  string Worldsdefaultname;
     39  Worldsdefaultname = World::getInstance().getDefaultName();
     40  WorldSetDefaultNameState *UndoState = new WorldSetDefaultNameState(Worldsdefaultname, params);
    3741
    38 // memento to remember the state when undoing
     42  // obtain information
     43  getParametersfromValueStorage();
    3944
    40 class WorldSetDefaultNameState : public ActionState {
    41 public:
    42   WorldSetDefaultNameState(std::string _lastName) :
    43     lastName(_lastName)
    44   {}
    45   std::string lastName;
    46 };
    47 
    48 const char WorldSetDefaultNameAction::NAME[] = "default-molname";
    49 
    50 WorldSetDefaultNameAction::WorldSetDefaultNameAction() :
    51   Action(NAME)
    52 {}
    53 
    54 WorldSetDefaultNameAction::~WorldSetDefaultNameAction()
    55 {}
    56 
    57 void WorldSetDefaultName(std::string &defaultname) {
    58   ValueStorage::getInstance().setCurrentValue(WorldSetDefaultNameAction::NAME, defaultname);
    59   ActionRegistry::getInstance().getActionByName(WorldSetDefaultNameAction::NAME)->call(Action::NonInteractive);
    60 };
    61 
    62 void WorldSetDefaultNameAction::getParametersfromValueStorage()
    63 {};
    64 
    65 Dialog* WorldSetDefaultNameAction::fillDialog(Dialog *dialog) {
    66   ASSERT(dialog,"No Dialog given when filling action dialog");
    67 
    68   string defaultname = World::getInstance().getDefaultName();
    69   ValueStorage::getInstance().setCurrentValue(NAME, defaultname);
    70   dialog->queryString(NAME, ValueStorage::getInstance().getDescription(NAME));
    71 
    72   return dialog;
    73 }
    74 
    75 Action::state_ptr WorldSetDefaultNameAction::performCall() {
    76   string defaultname;
    77 
    78   defaultname = World::getInstance().getDefaultName();
    79   WorldSetDefaultNameState *UndoState = new WorldSetDefaultNameState(defaultname);
    80   ValueStorage::getInstance().queryCurrentValue(NAME, defaultname);
    81 
    82   World::getInstance().setDefaultName(defaultname);
     45  World::getInstance().setDefaultName(params.newname);
    8346  DoLog(0) && (Log() << Verbose(0) << "Default name of new molecules set to " << World::getInstance().getDefaultName() << "." << endl);
    8447  return Action::state_ptr(UndoState);
    … …  
    8851  WorldSetDefaultNameState *state = assert_cast<WorldSetDefaultNameState*>(_state.get());
    8952
    90   string newName = World::getInstance().getDefaultName();
    91   World::getInstance().setDefaultName(state->lastName);
     53  World::getInstance().setDefaultName(state->lastname);
    9254  DoLog(0) && (Log() << Verbose(0) << "Default name of new molecules set to " << World::getInstance().getDefaultName() << "." << endl);
    9355
    94   return Action::state_ptr(new WorldSetDefaultNameState(newName));
     56  return Action::state_ptr(_state);
    9557}
    9658
    9759Action::state_ptr WorldSetDefaultNameAction::performRedo(Action::state_ptr _state){
    98   return performUndo(_state);
     60  WorldSetDefaultNameState *state = assert_cast<WorldSetDefaultNameState*>(_state.get());
     61
     62  World::getInstance().setDefaultName(state->params.newname);
     63  DoLog(0) && (Log() << Verbose(0) << "Default name of new molecules set to " << World::getInstance().getDefaultName() << "." << endl);
     64
     65  return Action::state_ptr(_state);
    9966}
    10067
    … …  
    11077  return NAME;
    11178}
     79/** =========== end of function ====================== */

  • src/Actions/WorldAction/SetDefaultNameAction.hpp

    r53d01c r1fd675  
    1111#include "Actions/Action.hpp"
    1212
    13 void WorldSetDefaultName(std::string &defaultname);
    14 
    15 class WorldSetDefaultNameAction : public Action {
    16   friend void WorldSetDefaultName(std::string &defaultname);
    17 
    18 public:
    19   WorldSetDefaultNameAction();
    20   virtual ~WorldSetDefaultNameAction();
    21 
    22   bool canUndo();
    23   bool shouldUndo();
    24 
    25   virtual const std::string getName();
    26 protected:
    27   virtual Dialog * fillDialog(Dialog *dialog);
    28 private:
    29   virtual void getParametersfromValueStorage();
    30   virtual Action::state_ptr performCall();
    31   virtual Action::state_ptr performUndo(Action::state_ptr);
    32   virtual Action::state_ptr performRedo(Action::state_ptr);
    33 
    34   static const char NAME[];
    35 };
     13#include "SetDefaultNameAction.def"
     14#include "Action_impl_header.hpp"
    3615
    3716#endif /* SETDEFAULTNAMEACTION_HPP_ */

  • src/Actions/WorldAction/SetGaussianBasisAction.cpp

    r53d01c r1fd675  
    2020#include "Helpers/MemDebug.hpp"
    2121
    22 #include "Actions/WorldAction/SetGaussianBasisAction.hpp"
    23 #include "Actions/ActionRegistry.hpp"
    2422#include "config.hpp"
    2523#include "Helpers/Log.hpp"
    … …  
    3230using namespace std;
    3331
    34 #include "UIElements/UIFactory.hpp"
    35 #include "UIElements/Dialog.hpp"
    36 #include "Actions/ValueStorage.hpp"
     32#include "Actions/WorldAction/SetGaussianBasisAction.hpp"
    3733
    38 
    39 // memento to remember the state when undoing
    40 
    41 class WorldSetGaussianBasisState : public ActionState {
    42 public:
    43   WorldSetGaussianBasisState(std::string _lastName) :
    44     lastName(_lastName)
    45   {}
    46   std::string lastName;
    47 };
    48 
    49 
    50 const char WorldSetGaussianBasisAction::NAME[] = "set-basis";
    51 
    52 WorldSetGaussianBasisAction::WorldSetGaussianBasisAction() :
    53   Action(NAME)
    54 {}
    55 
    56 WorldSetGaussianBasisAction::~WorldSetGaussianBasisAction()
    57 {}
    58 
    59 void WorldSetGaussianBasis(std::string &basisname) {
    60   ValueStorage::getInstance().setCurrentValue(WorldSetGaussianBasisAction::NAME, basisname);
    61   ActionRegistry::getInstance().getActionByName(WorldSetGaussianBasisAction::NAME)->call(Action::NonInteractive);
    62 };
    63 
    64 void WorldSetGaussianBasisAction::getParametersfromValueStorage()
    65 {};
    66 
    67 Dialog* WorldSetGaussianBasisAction::fillDialog(Dialog *dialog) {
    68   ASSERT(dialog,"No Dialog given when filling action dialog");
    69 
    70   dialog->queryString(NAME, ValueStorage::getInstance().getDescription(NAME));
    71 
    72   return dialog;
    73 }
    74 
     34// and construct the stuff
     35#include "SetGaussianBasisAction.def"
     36#include "Action_impl_pre.hpp"
     37/** =========== define the function ====================== */
    7538Action::state_ptr WorldSetGaussianBasisAction::performCall() {
    7639  config *configuration = World::getInstance().getConfig();
    7740
    7841  string lastname = configuration->basis;
    79   ValueStorage::getInstance().queryCurrentValue(NAME, configuration->basis);
     42  // obtain information
     43  getParametersfromValueStorage();
     44  configuration->basis = params.newname;
    8045
    8146  DoLog(1) && (Log() << Verbose(1) << "Setting MPQC basis to " << configuration->basis << "." << endl);
    82   return Action::success;
     47  return Action::state_ptr(new WorldSetGaussianBasisState(lastname, params));
    8348}
    8449
    … …  
    8752
    8853  config *configuration = World::getInstance().getConfig();
    89   string newName = configuration->basis;
    90   configuration->basis = state->lastName;
     54  configuration->basis = state->lastname;
    9155
    92   return Action::state_ptr(new WorldSetGaussianBasisState(newName));
     56  return Action::state_ptr(_state);
    9357}
    9458
    9559Action::state_ptr WorldSetGaussianBasisAction::performRedo(Action::state_ptr _state){
    96   return performUndo(_state);
     60  WorldSetGaussianBasisState *state = assert_cast<WorldSetGaussianBasisState*>(_state.get());
     61
     62  config *configuration = World::getInstance().getConfig();
     63  configuration->basis = state->params.newname;
     64
     65  return Action::state_ptr(_state);
    9766}
    9867
    … …  
    10877  return NAME;
    10978}
     79/** =========== end of function ====================== */

  • src/Actions/WorldAction/SetGaussianBasisAction.hpp

    r53d01c r1fd675  
    1111#include "Actions/Action.hpp"
    1212
    13 void WorldSetGaussianBasis(std::string &basisname);
    14 
    15 class WorldSetGaussianBasisAction : public Action {
    16   friend void WorldSetGaussianBasis(std::string &basisname);
    17 
    18 public:
    19   WorldSetGaussianBasisAction();
    20   virtual ~WorldSetGaussianBasisAction();
    21 
    22   bool canUndo();
    23   bool shouldUndo();
    24 
    25   virtual const std::string getName();
    26 protected:
    27   virtual Dialog * fillDialog(Dialog *dialog);
    28 private:
    29   virtual void getParametersfromValueStorage();
    30   virtual Action::state_ptr performCall();
    31   virtual Action::state_ptr performUndo(Action::state_ptr);
    32   virtual Action::state_ptr performRedo(Action::state_ptr);
    33 
    34   static const char NAME[];
    35 };
     13#include "SetGaussianBasisAction.def"
     14#include "Action_impl_header.hpp"
    3615
    3716#endif /* SETGAUSSIANBASISACTION_HPP_ */

  • src/Actions/WorldAction/SetOutputFormatsAction.cpp

    r53d01c r1fd675  
    2020#include "Helpers/MemDebug.hpp"
    2121
    22 #include "Actions/WorldAction/SetOutputFormatsAction.hpp"
    23 #include "Actions/ActionRegistry.hpp"
    2422#include "Parser/ChangeTracker.hpp"
    2523#include "Parser/FormatParserStorage.hpp"
    … …  
    3331using namespace std;
    3432
    35 #include "UIElements/UIFactory.hpp"
    36 #include "UIElements/Dialog.hpp"
    37 #include "Actions/ValueStorage.hpp"
     33#include "Actions/WorldAction/SetOutputFormatsAction.hpp"
    3834
    39 const char WorldSetOutputFormatsAction::NAME[] = "set-output";
     35// and construct the stuff
     36#include "SetOutputFormatsAction.def"
     37#include "Action_impl_pre.hpp"
     38/** =========== define the function ====================== */
     39Action::state_ptr WorldSetOutputFormatsAction::performCall() {
     40  // obtain information
     41  getParametersfromValueStorage();
    4042
    41 WorldSetOutputFormatsAction::WorldSetOutputFormatsAction() :
    42   Action(NAME)
    43 {}
    44 
    45 WorldSetOutputFormatsAction::~WorldSetOutputFormatsAction()
    46 {}
    47 
    48 void WorldSetOutputFormats(vector<std::string> &FormatList) {
    49   ValueStorage::getInstance().setCurrentValue(WorldSetOutputFormatsAction::NAME, FormatList);
    50   ActionRegistry::getInstance().getActionByName(WorldSetOutputFormatsAction::NAME)->call(Action::NonInteractive);
    51 };
    52 
    53 void WorldSetOutputFormatsAction::getParametersfromValueStorage()
    54 {};
    55 
    56 Dialog* WorldSetOutputFormatsAction::fillDialog(Dialog *dialog) {
    57   ASSERT(dialog,"No Dialog given when filling action dialog");
    58 
    59   dialog->queryStrings(NAME, ValueStorage::getInstance().getDescription(NAME));
    60 
    61   return dialog;
    62 }
    63 
    64 Action::state_ptr WorldSetOutputFormatsAction::performCall() {
    65   vector<std::string> FormatList;
    66 
    67   ValueStorage::getInstance().queryCurrentValue(NAME, FormatList);
    68 
    69   for (vector<std::string>::iterator iter = FormatList.begin(); iter != FormatList.end(); ++iter) {
     43  for (vector<std::string>::iterator iter = params.FormatList.begin(); iter != params.FormatList.end(); ++iter) {
    7044    if (*iter == "mpqc") {
    7145      FormatParserStorage::getInstance().addMpqc();
    … …  
    11387  return NAME;
    11488}
     89/** =========== end of function ====================== */

  • src/Actions/WorldAction/SetOutputFormatsAction.hpp

    r53d01c r1fd675  
    1111#include "Actions/Action.hpp"
    1212
    13 #include <vector>
    14 
    15 void WorldSetOutputFormats(std::vector<std::string> &FormatList);
    16 
    17 class WorldSetOutputFormatsAction : public Action {
    18   friend void WorldSetOutputFormats(std::vector<std::string> &FormatList);
    19 
    20 public:
    21   WorldSetOutputFormatsAction();
    22   virtual ~WorldSetOutputFormatsAction();
    23 
    24   bool canUndo();
    25   bool shouldUndo();
    26 
    27   virtual const std::string getName();
    28 protected:
    29   virtual Dialog * fillDialog(Dialog *dialog);
    30 private:
    31   virtual void getParametersfromValueStorage();
    32   virtual Action::state_ptr performCall();
    33   virtual Action::state_ptr performUndo(Action::state_ptr);
    34   virtual Action::state_ptr performRedo(Action::state_ptr);
    35 
    36   static const char NAME[];
    37 };
     13#include "SetOutputFormatsAction.def"
     14#include "Action_impl_header.hpp"
    3815
    3916#endif /* SETOUTPUTFORMATSACTION_HPP_ */
Note: See TracChangeset for help on using the changeset viewer.