Diff [7067bd6466a60f69edb4e9266035bf78437cb954:677e130f3cbb80cdb1d7c6766dd729592710cd05] for / – MoleCuilder

configure.ac

r7067bd6	r677e13
8	8	AC_CONFIG_HEADER([config.h])
9	9
10		AM_INIT_AUTOMAKE(dist-bzip2)
	10	AM_INIT_AUTOMAKE(dist-bzip2 parallel-tests)
11	11
12	12	# Checks for programs.

src/Actions/Action.cpp

-              r7067bd6
+              r677e13
 #include "Actions/ActionRegistry.hpp"
 #include "Actions/ActionHistory.hpp"
+#include "Exceptions/MissingValueException.hpp"
+#include "UIElements/Dialog.hpp"
 #include "Helpers/MemDebug.hpp"
+#include "log.hpp"
+#include "verbose.hpp"
 using namespace std;
 …
+}
 void Action::call(){
+void Action::call(enum QueryOptions flag){
   if(!isActive()){
     return;
+  }
   // forward to private virtual
+  state_ptr state = performCall();
+  if (flag == Interactive) {
+    Dialog* dialog = createDialog();
+    if (dialog != NULL) {
+      dialog->display();
+      delete(dialog);
+    }
+  }
+  state_ptr state = Action::failure;
+//  try {
+    state = performCall();
+//  } catch(MissingValueException&) {
+//    DoeLog(0) && (eLog() << Verbose(0) << "There is a value missing for action " << getName() << endl);
+//  };
   if(shouldUndo() && state != failure){
     if(canUndo()){

src/Actions/Action.hpp

-              r7067bd6
+              r677e13
 class ActionState;
 class ActionSequence;
+class Dialog;
 /**
 …
  * hasRedo() method respectively.
+ *
+ * Note that an Action always has two functions createDialog() and performCall(). The former
+ * returns a Dialog filled with query...() functions for all information that we need from the
+ * user. The latter must not contain any interaction but just uses these values (which are
+ * temporarily stored by class ValueStorage) to perform the Action.
+ *
+ * Furthermore, there is a global action function that makes the action callable with already
+ * present parameters (i.e. without user interaction and for internal use within the code only).
+ * This function is basically just a macro, that puts the parameters into the ValueStorage and
+ * calls Action::call(Action::NonInteractive).
+ *
  * Actions can be set to be active or inactive. If an action is set to inactive it is signaling, that
  * some condition necessary for this action to be executed is not currently met. For example the
 …
  * Building actions is fairly easy. Simply derive from the abstract Action base class and implement
  * the virtual methods. The main code that needs to be executed upon call() should be implemented in
+ * the performCall() method. You should also indicate whether the action supports undo by implementing
+ * the performCall() method. Any user interaction should be placed into the dialog returned by
+ * createDialog(). You should also indicate whether the action supports undo by implementing
  * the shouldUndo() and canUndo() methods to return the appropriate flags.
+ *
+ * Also, create the global function to allow for easy calling of your function internally (i.e.
+ * without user interaction). It should have the name of the Action class without the suffix Action.
+ *
  * The constructor of your derived class also needs to call the Base constructor, passing it the
 …
  *  <li/> derive YourAction from Action
  *  <li/> pass name and flag for registry to the base constructor
+ *  <li/> implement performCall(), performUndo(), performRedo()
+ *  <li/> implement createDialog(), performCall(), performUndo(), performRedo()
+ *  <li/> implement the global function call/macro.
  *  <li/> implement the functions that return the flags for the undo mechanism
  *  <li/> Derive YourActionState from ActionState as necessary
 …
+ *
  * <ul>
+ *  <li/> createDialog():
+ *  <ul>
+ *   <li/> Call makeDialog() from the UIFactory.
+ *   <li/> Call any needed Dialog->Query...() for the values you need with specific keywords.
+ *   <li/> if the action needs to save a state return a custom state object
+ *   <li/> otherwise return Action::success
+ *  </ul>
  *  <li/> performCall():
  *  <ul>
+ *   <li/> obtain parameters you need by ValueStorage::getCurrentValue, matching
+ *         key words from createDialog().
  *   <li/> do whatever is needed to make the action work
  *   <li/> if the action was abborted return Action::failure
 …
 public:
+  enum QueryOptions {Interactive, NonInteractive};
   /**
    * This type is used to store pointers to ActionStates while allowing multiple ownership
 …
    * If the call needs to undone you have to use the History, to avoid destroying
    * invariants used by the History.
+   */
+  void call();
+   *
+   * Note that this call can be Interactive (i.e. a dialog will ask the user for
+   * necessary information) and NonInteractive (i.e. the information will have to
+   * be present already within the ValueStorage class or else a MissingArgumentException
+   * is thrown)
+   */
+  void call(enum QueryOptions state = Interactive);
   /**
 …
 private:
   /**
+   * This is called internally when the call is being done. Implement this method to do the actuall
+   * This creates the dialog requesting the information needed for this action from the user
+   * via means of the user interface.
+   */
+  virtual Dialog * createDialog()=0;
+  /**
+   * This is called internally when the call is being done. Implement this method to do the actual
    * work of the Action. Implement this in your Derived classes. Needs to return a state that can be
    * used to undo the action.

src/Actions/ActionHistory.cpp

-              r7067bd6
+              r677e13
+}
+Dialog* ActionHistory::UndoAction::createDialog(){
+  return NULL;
+}
 Action::state_ptr ActionHistory::UndoAction::performCall(){
   hist->undoLast();
 …
+}
+Dialog* ActionHistory::RedoAction::createDialog(){
+  return NULL;
+}
 Action::state_ptr ActionHistory::RedoAction::performCall(){
   hist->redoLast();

src/Actions/ActionHistory.hpp

-              r7067bd6
+              r677e13
   private:
+    virtual Dialog * createDialog();
     virtual Action::state_ptr performCall();
     virtual Action::state_ptr performUndo(Action::state_ptr);
 …
   private:
+    virtual Dialog * createDialog();
     virtual Action::state_ptr performCall();
     virtual Action::state_ptr performUndo(Action::state_ptr);

src/Actions/ActionSequence.cpp

-              r7067bd6
+              r677e13
 #include "Actions/ActionSequence.hpp"
 #include "Actions/Action.hpp"
+#include "UIElements/Dialog.hpp"
 #include "Helpers/Assert.hpp"
 …
     return theAction;
+  }
+}
+// this method is used outside the ActionModule
+// Each action registers itself with the history
+void ActionSequence::callAllDialogs(){
+  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
+    Dialog * dialog = (*it)->createDialog();
+    if (dialog != NULL) {
+      dialog->display();
+      delete(dialog);
+    }
+  }
+}
+// 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::callAllDialogs(bool){
+  stateSet states;
+  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)->createDialog()->display();
+  }
+  return states;
+}

src/Actions/ActionSequence.hpp

-              r7067bd6
+              r677e13
   void callAll();
+  void callAllDialogs();
   bool canUndo();
 …
 protected:
   stateSet callAll(bool); // Dummy parameter to allow overloading
+  stateSet callAllDialogs(bool); // Dummy parameter to allow overloading
   stateSet undoAll(stateSet);
   stateSet redoAll(stateSet);

src/Actions/AnalysisAction/MolecularVolumeAction.cpp

-              r7067bd6
+              r677e13
 #include "Actions/AnalysisAction/MolecularVolumeAction.hpp"
+#include "Actions/ActionRegistry.hpp"
 #include "boundary.hpp"
 #include "config.hpp"
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
 #include "Actions/MapOfActions.hpp"
+#include "UIElements/ValueStorage.hpp"
 const char AnalysisMolecularVolumeAction::NAME[] = "molecular-volume";
 …
 {}
+void AnalysisMolecularVolume() {
+  ActionRegistry::getInstance().getActionByName(AnalysisMolecularVolumeAction::NAME)->call(Action::NonInteractive);
+};
+Dialog * AnalysisMolecularVolumeAction::createDialog() {
+  Dialog *dialog = UIFactory::getInstance().makeDialog();
+  dialog->queryEmpty(NAME, ValueStorage::getInstance().getDescription(NAME));
+  return dialog;
+}
 Action::state_ptr AnalysisMolecularVolumeAction::performCall() {
+  Dialog *dialog = UIFactory::getInstance().makeDialog();
+  molecule *mol = NULL;
+  int molID = -1;
+  // obtain information
+  ValueStorage::getInstance().queryCurrentValue(NAME, molID);
   dialog->queryMolecule(NAME, &mol, MapOfActions::getInstance().getDescription(NAME));
   if(dialog->display()) {
+  // execute action
+  for (World::MoleculeSelectionIterator iter = World::getInstance().beginMoleculeSelection(); iter != World::getInstance().endMoleculeSelection(); ++iter) {
+    molecule *mol = iter->second;
     class Tesselation *TesselStruct = NULL;
     const LinkedCell *LCList = NULL;
 …
     delete(TesselStruct);
     delete(LCList);
-    delete dialog;
-    return Action::success;
-  } else {
-    delete dialog;
-    return Action::failure;
+  }
+  return Action::success;
+}
 Action::state_ptr AnalysisMolecularVolumeAction::performUndo(Action::state_ptr _state) {
+//  ParserLoadXyzState *state = assert_cast<ParserLoadXyzState*>(_state.get());
+  return Action::failure;
+//  string newName = state->mol->getName();
+//  state->mol->setName(state->lastName);
+//
+//  return Action::state_ptr(new ParserLoadXyzState(state->mol,newName));
+  return Action::success;
+}
 Action::state_ptr AnalysisMolecularVolumeAction::performRedo(Action::state_ptr _state){
   return Action::failure;
+  return Action::success;
+}
 bool AnalysisMolecularVolumeAction::canUndo() {
   return false;
+  return true;
+}
 bool AnalysisMolecularVolumeAction::shouldUndo() {
   return false;
+  return true;
+}

src/Actions/AnalysisAction/MolecularVolumeAction.hpp

-              r7067bd6
+              r677e13
 #include "Actions/Action.hpp"
+void AnalysisMolecularVolume();
 class AnalysisMolecularVolumeAction : public Action {
+  friend void AnalysisMolecularVolume();
 public:
   AnalysisMolecularVolumeAction();
 …
   virtual const std::string getName();
 private:
+  virtual Dialog * createDialog();
   virtual Action::state_ptr performCall();
   virtual Action::state_ptr performUndo(Action::state_ptr);

src/Actions/AnalysisAction/PairCorrelationAction.cpp

-              r7067bd6
+              r677e13
 #include "Actions/AnalysisAction/PairCorrelationAction.hpp"
+#include "Actions/ActionRegistry.hpp"
 #include "analysis_correlation.hpp"
 #include "boundary.hpp"
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
 #include "Actions/MapOfActions.hpp"
+#include "UIElements/ValueStorage.hpp"
 const char AnalysisPairCorrelationAction::NAME[] = "pair-correlation";
 …
 {}
+void AnalysisPairCorrelation(std::vector< element *> &elements, double BinStart, double BinWidth, double BinEnd, string &outputname, string &binoutputname, bool periodic) {
+  ValueStorage::getInstance().setCurrentValue("elements", elements);
+  ValueStorage::getInstance().setCurrentValue("bin-start", BinStart);
+  ValueStorage::getInstance().setCurrentValue("bin-width", BinWidth);
+  ValueStorage::getInstance().setCurrentValue("bin-end", BinEnd);
+  ValueStorage::getInstance().setCurrentValue("output-file", outputname);
+  ValueStorage::getInstance().setCurrentValue("bin-output-file", binoutputname);
+  ValueStorage::getInstance().setCurrentValue("periodic", periodic);
+  ActionRegistry::getInstance().getActionByName(AnalysisPairCorrelationAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* AnalysisPairCorrelationAction::createDialog() {
+  Dialog *dialog = UIFactory::getInstance().makeDialog();
+  dialog->queryElements("elements", ValueStorage::getInstance().getDescription("elements"));
+  dialog->queryDouble("bin-start", ValueStorage::getInstance().getDescription("bin-start"));
+  dialog->queryDouble("bin-width", ValueStorage::getInstance().getDescription("bin-width"));
+  dialog->queryDouble("bin-end", ValueStorage::getInstance().getDescription("bin-end"));
+  dialog->queryString("output-file", ValueStorage::getInstance().getDescription("output-file"));
+  dialog->queryString("bin-output-file", ValueStorage::getInstance().getDescription("bin-output-file"));
+  dialog->queryBoolean("periodic", ValueStorage::getInstance().getDescription("periodic"));
+  return dialog;
+}
 Action::state_ptr AnalysisPairCorrelationAction::performCall() {
-  Dialog *dialog = UIFactory::getInstance().makeDialog();
   int ranges[3] = {1, 1, 1};
   double BinEnd = 0.;
 …
   Vector Point;
   BinPairMap *binmap = NULL;
-  MoleculeListClass *molecules = World::getInstance().getMolecules();
   // first dialog: Obtain which type of correlation
   dialog->queryString(NAME, &type, MapOfActions::getInstance().getDescription(NAME));
   if(dialog->display()) {
     delete dialog;
   } else {
     delete dialog;
     return Action::failure;
+  }
+  // obtain information
+  ValueStorage::getInstance().queryCurrentValue("elements", elements);
+  ValueStorage::getInstance().queryCurrentValue("bin-start", BinStart);
+  ValueStorage::getInstance().queryCurrentValue("bin-width", BinWidth);
+  ValueStorage::getInstance().queryCurrentValue("bin-end", BinEnd);
+  ValueStorage::getInstance().queryCurrentValue("output-file", outputname);
+  ValueStorage::getInstance().queryCurrentValue("bin-output-file", binoutputname);
+  ValueStorage::getInstance().queryCurrentValue("periodic", periodic);
+  // second dialog: Obtain parameters specific to this type
+  dialog = UIFactory::getInstance().makeDialog();
+  if (type == "P")
+    dialog->queryVector("position", &Point, false, MapOfActions::getInstance().getDescription("position"));
+  if (type == "S")
+    dialog->queryMolecule("molecule-by-id", &Boundary, MapOfActions::getInstance().getDescription("molecule-by-id"));
+  dialog->queryElement("elements", &elements, MapOfActions::getInstance().getDescription("elements"));
+  dialog->queryDouble("bin-start", &BinStart, MapOfActions::getInstance().getDescription("bin-start"));
+  dialog->queryDouble("bin-width", &BinWidth, MapOfActions::getInstance().getDescription("bin-width"));
+  dialog->queryDouble("bin-end", &BinEnd, MapOfActions::getInstance().getDescription("bin-end"));
+  dialog->queryString("output-file", &outputname, MapOfActions::getInstance().getDescription("output-file"));
+  dialog->queryString("bin-output-file", &binoutputname, MapOfActions::getInstance().getDescription("bin-output-file"));
+  dialog->queryBoolean("periodic", &periodic, MapOfActions::getInstance().getDescription("periodic"));
+  if(dialog->display()) {
+    output.open(outputname.c_str());
+    binoutput.open(binoutputname.c_str());
+    if (type == "E") {
+      PairCorrelationMap *correlationmap = NULL;
+      if (periodic)
+        correlationmap = PeriodicPairCorrelation(World::getInstance().getMolecules(), elements, ranges);
+      else
+        correlationmap = PairCorrelation(World::getInstance().getMolecules(), elements);
+      OutputPairCorrelation(&output, correlationmap);
+      binmap = BinData( correlationmap, BinWidth, BinStart, BinEnd );
+      OutputCorrelation ( &binoutput, binmap );
+      delete(binmap);
+      delete(correlationmap);
+    } else if (type == "P")  {
+      cout << "Point to correlate to is  " << Point << endl;
+      CorrelationToPointMap *correlationmap = NULL;
+      if (periodic)
+        correlationmap  = PeriodicCorrelationToPoint(molecules, elements, &Point, ranges);
+      else
+        correlationmap = CorrelationToPoint(molecules, elements, &Point);
+      OutputCorrelationToPoint(&output, correlationmap);
+      binmap = BinData( correlationmap, BinWidth, BinStart, BinEnd );
+      OutputCorrelation ( &binoutput, binmap );
+      delete(binmap);
+      delete(correlationmap);
+    } else if (type == "S") {
+      ASSERT(Boundary != NULL, "No molecule specified for SurfaceCorrelation.");
+      const double radius = 4.;
+      double LCWidth = 20.;
+      if (BinEnd > 0) {
+        if (BinEnd > 2.*radius)
+          LCWidth = BinEnd;
+        else
+          LCWidth = 2.*radius;
+      }
+      // get the boundary
+      class Tesselation *TesselStruct = NULL;
+      const LinkedCell *LCList = NULL;
+      // find biggest molecule
+      int counter  = molecules->ListOfMolecules.size();
+      bool *Actives = new bool[counter];
+      counter = 0;
+      for (MoleculeList::iterator BigFinder = molecules->ListOfMolecules.begin(); BigFinder != molecules->ListOfMolecules.end(); BigFinder++) {
+        Actives[counter++] = (*BigFinder)->ActiveFlag;
+        (*BigFinder)->ActiveFlag = (*BigFinder == Boundary) ? false : true;
+      }
+      LCList = new LinkedCell(Boundary, LCWidth);
+      FindNonConvexBorder(Boundary, TesselStruct, LCList, radius, NULL);
+      CorrelationToSurfaceMap *surfacemap = NULL;
+      if (periodic)
+        surfacemap = PeriodicCorrelationToSurface( molecules, elements, TesselStruct, LCList, ranges);
+      else
+        surfacemap = CorrelationToSurface( molecules, elements, TesselStruct, LCList);
+      delete LCList;
+      OutputCorrelationToSurface(&output, surfacemap);
+      // re-set ActiveFlag
+      counter = 0;
+      for (MoleculeList::iterator BigFinder = molecules->ListOfMolecules.begin(); BigFinder != molecules->ListOfMolecules.end(); BigFinder++) {
+        (*BigFinder)->ActiveFlag = Actives[counter++];
+      }
+      delete[] Actives;
+      // check whether radius was appropriate
+      {
+        double start; double end;
+        GetMinMax( surfacemap, start, end);
+        if (LCWidth < end)
+          DoeLog(1) && (eLog()<< Verbose(1) << "Linked Cell width is smaller than the found range of values! Bins can only be correct up to: " << radius << "." << endl);
+      }
+      binmap = BinData( surfacemap, BinWidth, BinStart, BinEnd );
+      OutputCorrelation ( &binoutput, binmap );
+      delete TesselStruct;  // surfacemap contains refs to triangles! delete here, not earlier!
+      delete(binmap);
+      delete(surfacemap);
+    } else {
+      return Action::failure;
+    }
+    output.close();
+    binoutput.close();
+    delete dialog;
+    return Action::success;
+  } else {
+    delete dialog;
+    return Action::failure;
+  }
+  // execute action
+  output.open(outputname.c_str());
+  binoutput.open(binoutputname.c_str());
+  PairCorrelationMap *correlationmap = NULL;
+  std::vector<molecule*> molecules = World::getInstance().getSelectedMolecules();
+  if (periodic)
+    correlationmap = PeriodicPairCorrelation(molecules, elements, ranges);
+  else
+    correlationmap = PairCorrelation(molecules, elements);
+  OutputPairCorrelation(&output, correlationmap);
+  binmap = BinData( correlationmap, BinWidth, BinStart, BinEnd );
+  OutputCorrelation ( &binoutput, binmap );
+  delete(binmap);
+  delete(correlationmap);
+  output.close();
+  binoutput.close();
+  return Action::success;
+}
 Action::state_ptr AnalysisPairCorrelationAction::performUndo(Action::state_ptr _state) {
+//  ParserLoadXyzState *state = assert_cast<ParserLoadXyzState*>(_state.get());
+  return Action::failure;
+//  string newName = state->mol->getName();
+//  state->mol->setName(state->lastName);
+//
+//  return Action::state_ptr(new ParserLoadXyzState(state->mol,newName));
+  return Action::success;
+}
 Action::state_ptr AnalysisPairCorrelationAction::performRedo(Action::state_ptr _state){
   return Action::failure;
+  return Action::success;
+}
 bool AnalysisPairCorrelationAction::canUndo() {
   return false;
+  return true;
+}
 bool AnalysisPairCorrelationAction::shouldUndo() {
   return false;
+  return true;
+}

src/Actions/AnalysisAction/PairCorrelationAction.hpp

-              r7067bd6
+              r677e13
 #include "Actions/Action.hpp"
+class element;
+void AnalysisPairCorrelation(std::vector< element *> &elements, double BinStart, double BinWidth, double BinEnd, std::string &outputname, std::string &binoutputname, bool periodic);
 class AnalysisPairCorrelationAction : public Action {
+  friend void AnalysisPairCorrelation(std::vector< element *> &elements, double BinStart, double BinWidth, double BinEnd, std::string &outputname, std::string &binoutputname, bool periodic);
 public:
   AnalysisPairCorrelationAction();
 …
   virtual const std::string getName();
 private:
+  virtual Dialog * createDialog();
   virtual Action::state_ptr performCall();
   virtual Action::state_ptr performUndo(Action::state_ptr);

src/Actions/AnalysisAction/PrincipalAxisSystemAction.cpp

-              r7067bd6
+              r677e13
 #include "Actions/AnalysisAction/PrincipalAxisSystemAction.hpp"
+#include "Actions/ActionRegistry.hpp"
 #include "molecule.hpp"
 #include "log.hpp"
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
 #include "Actions/MapOfActions.hpp"
+#include "UIElements/ValueStorage.hpp"
 const char AnalysisPrincipalAxisSystemAction::NAME[] = "principal-axis-system";
 …
 {}
+void AnalysisPrincipalAxisSystem() {
+  ActionRegistry::getInstance().getActionByName(AnalysisPrincipalAxisSystemAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* AnalysisPrincipalAxisSystemAction::createDialog() {
+  Dialog *dialog = UIFactory::getInstance().makeDialog();
+  dialog->queryEmpty(NAME, ValueStorage::getInstance().getDescription(NAME));
+  return dialog;
+}
 Action::state_ptr AnalysisPrincipalAxisSystemAction::performCall() {
-  Dialog *dialog = UIFactory::getInstance().makeDialog();
   molecule *mol = NULL;
   dialog->queryMolecule(NAME, &mol, MapOfActions::getInstance().getDescription(NAME));
   if(dialog->display()) {
     DoLog(0) && (Log() << Verbose(0) << "Evaluating prinicipal axis." << endl);
+  ValueStorage::getInstance().queryCurrentValue(NAME, mol);
+  DoLog(0) && (Log() << Verbose(0) << "Evaluating prinicipal axis." << endl);
+  for (World::MoleculeSelectionIterator iter = World::getInstance().beginMoleculeSelection(); iter != World::getInstance().endMoleculeSelection(); ++iter) {
+    molecule *mol = iter->second;
     mol->PrincipalAxisSystem(false);
-    delete dialog;
-    return Action::success;
-  } else {
-    delete dialog;
-    return Action::failure;
+  }
+  return Action::success;
+}
 Action::state_ptr AnalysisPrincipalAxisSystemAction::performUndo(Action::state_ptr _state) {
+//  ParserLoadXyzState *state = assert_cast<ParserLoadXyzState*>(_state.get());
+  return Action::failure;
+//  string newName = state->mol->getName();
+//  state->mol->setName(state->lastName);
+//
+//  return Action::state_ptr(new ParserLoadXyzState(state->mol,newName));
+  return Action::success;
+}
 Action::state_ptr AnalysisPrincipalAxisSystemAction::performRedo(Action::state_ptr _state){
   return Action::failure;
+  return Action::success;
+}
 bool AnalysisPrincipalAxisSystemAction::canUndo() {
   return false;
+  return true;
+}
 bool AnalysisPrincipalAxisSystemAction::shouldUndo() {
   return false;
+  return true;
+}

src/Actions/AnalysisAction/PrincipalAxisSystemAction.hpp

-              r7067bd6
+              r677e13
 #include "Actions/Action.hpp"
+void AnalysisPrincipalAxisSystem();
 class AnalysisPrincipalAxisSystemAction : public Action {
+  friend void AnalysisPrincipalAxisSystem();
 public:
   AnalysisPrincipalAxisSystemAction();
 …
   virtual const std::string getName();
 private:
+  virtual Dialog * createDialog();
   virtual Action::state_ptr performCall();
   virtual Action::state_ptr performUndo(Action::state_ptr);

src/Actions/AtomAction/AddAction.cpp

-              r7067bd6
+              r677e13
 #include "Actions/AtomAction/AddAction.hpp"
+#include "Actions/ActionRegistry.hpp"
 #include "atom.hpp"
 #include "element.hpp"
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
 #include "Actions/MapOfActions.hpp"
+#include "UIElements/ValueStorage.hpp"
 const char AtomAddAction::NAME[] = "add-atom";
 …
 {}
+void AtomAdd(element *elemental, Vector &position) {
+  ValueStorage::getInstance().setCurrentValue(AtomAddAction::NAME, elemental);
+  ValueStorage::getInstance().setCurrentValue("position", elemental);
+  ActionRegistry::getInstance().getActionByName(AtomAddAction::NAME)->call(Action::NonInteractive);
+};
+Dialog * AtomAddAction::createDialog() {
+  Dialog *dialog = UIFactory::getInstance().makeDialog();
+  dialog->queryElement(NAME, ValueStorage::getInstance().getDescription(NAME));
+  dialog->queryVector("position", true, ValueStorage::getInstance().getDescription("position"));
+  return dialog;
+}
 Action::state_ptr AtomAddAction::performCall() {
+  Dialog *dialog = UIFactory::getInstance().makeDialog();
+  std::vector<element *> elements;
+  element * elemental = NULL;
   Vector position;
   dialog->queryElement(NAME, &elements, MapOfActions::getInstance().getDescription(NAME));
   dialog->queryVector("position", &position, true, MapOfActions::getInstance().getDescription("position"));
   cout << "pre-dialog" << endl;
+  // obtain information
+  ValueStorage::getInstance().queryCurrentValue(NAME, elemental);
+  ValueStorage::getInstance().queryCurrentValue("position", position);
+  if(dialog->display()) {
+    cout << "post-dialog" << endl;
+    delete dialog;
+    if (elements.size() == 1) {
+      atom * first = World::getInstance().createAtom();
+      first->type = *(elements.begin());
+      first->x = position;
+      DoLog(1) && (Log() << Verbose(1) << "Adding new atom with element " << first->type->name << " at " << (first->x) << "." << endl);
+      // TODO: remove when all of World's atoms are stored.
+      std::vector<molecule *> molecules = World::getInstance().getAllMolecules();
+      if (!molecules.empty()) {
+        std::vector<molecule *>::iterator iter = molecules.begin();
+        (*iter)->AddAtom(first);
+      }
+      return Action::success;
+    } else {
+      DoeLog(1) && (eLog()<< Verbose(1) << "Could not find the specified element." << endl);
+      return Action::failure;
+    }
+  } else {
+    delete dialog;
+    return Action::failure;
+  // execute action
+  atom * first = World::getInstance().createAtom();
+  first->type = elemental;
+  first->x = position;
+  DoLog(1) && (Log() << Verbose(1) << "Adding new atom with element " << first->type->name << " at " << (first->x) << "." << endl);
+  // TODO: remove when all of World's atoms are stored.
+  std::vector<molecule *> molecules = World::getInstance().getAllMolecules();
+  if (!molecules.empty()) {
+    std::vector<molecule *>::iterator iter = molecules.begin();
+    (*iter)->AddAtom(first);
+  }
+  return Action::success;
+}

src/Actions/AtomAction/AddAction.hpp

-              r7067bd6
+              r677e13
 #include "Actions/Action.hpp"
+#include "vector.hpp"
+class element;
+void AtomAdd(element *elemental, Vector &position);
 class AtomAddAction : public Action {
+  friend void AtomAdd(element *elemental, Vector &position);
 public:
   AtomAddAction();
 …
   virtual const std::string getName();
 private:
+  virtual Dialog * createDialog();
   virtual Action::state_ptr performCall();
   virtual Action::state_ptr performUndo(Action::state_ptr);

src/Actions/AtomAction/ChangeElementAction.cpp

-              r7067bd6
+              r677e13
 #include "Actions/AtomAction/ChangeElementAction.hpp"
+#include "Actions/ActionRegistry.hpp"
 #include "atom.hpp"
+#include "element.hpp"
 #include "log.hpp"
 #include "vector.hpp"
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
 #include "Actions/MapOfActions.hpp"
+#include "UIElements/ValueStorage.hpp"
 const char AtomChangeElementAction::NAME[] = "change-element";
 …
 {}
+void AtomChangeElement(element *elemental) {
+  ValueStorage::getInstance().setCurrentValue(AtomChangeElementAction::NAME, elemental);
+  ActionRegistry::getInstance().getActionByName(AtomChangeElementAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* AtomChangeElementAction::createDialog() {
+  Dialog *dialog = UIFactory::getInstance().makeDialog();
+  dialog->queryElement(NAME, ValueStorage::getInstance().getDescription(NAME));
+return dialog;
+}
 Action::state_ptr AtomChangeElementAction::performCall() {
-  Dialog *dialog = UIFactory::getInstance().makeDialog();
   atom *first = NULL;
   std::vector<element *> elements;
+  element *elemental = NULL;
+  dialog->queryElement(NAME, &elements, MapOfActions::getInstance().getDescription(NAME));
+  dialog->queryAtom("atom-by-id", &first, MapOfActions::getInstance().getDescription("atom-by-id"));
+  ValueStorage::getInstance().queryCurrentValue(NAME, elemental);
+  if(dialog->display()) {
+    delete dialog;
+    ASSERT(elements.size() == 1, "Unequal to one element specified when changing an atom's element");
+    ASSERT(first != NULL, "No valid atom specified");
+    DoLog(1) && (Log() << Verbose(1) << "Changing atom " << *first << " to element " << elements.at(0) << "." << endl);
+    if (elements.at(0) != NULL) {
+      first->type = elements.at(0);
+      return Action::success;
+    } else
+      return Action::failure;
+  } else {
+    delete dialog;
+    return Action::failure;
+  for (World::AtomSelectionIterator iter = World::getInstance().beginAtomSelection(); iter != World::getInstance().endAtomSelection(); ++iter) {
+    first = iter->second;
+    DoLog(1) && (Log() << Verbose(1) << "Changing atom " << *first << " to element " << elemental->symbol << "." << endl);
+    first->type = elemental;
+  }
+  return Action::success;
+}

src/Actions/AtomAction/ChangeElementAction.hpp

-              r7067bd6
+              r677e13
 #include "Actions/Action.hpp"
+class element;
+void AtomChangeElement(element *elemental);
 class AtomChangeElementAction : public Action {
+  friend void AtomChangeElement(element *elemental);
 public:
   AtomChangeElementAction();
 …
   virtual const std::string getName();
 private:
+  virtual Dialog * createDialog();
   virtual Action::state_ptr performCall();
   virtual Action::state_ptr performUndo(Action::state_ptr);

src/Actions/AtomAction/RemoveAction.cpp

-              r7067bd6
+              r677e13
 #include "Actions/AtomAction/RemoveAction.hpp"
+#include "Actions/ActionRegistry.hpp"
 #include "atom.hpp"
 #include "Descriptors/AtomDescriptor.hpp"
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
 #include "Actions/MapOfActions.hpp"
+#include "UIElements/ValueStorage.hpp"
 const char AtomRemoveAction::NAME[] = "remove-atom";
 …
 {}
+void AtomRemove() {
+  ActionRegistry::getInstance().getActionByName(AtomRemoveAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* AtomRemoveAction::createDialog() {
+  Dialog *dialog = UIFactory::getInstance().makeDialog();
+  dialog->queryEmpty(NAME, ValueStorage::getInstance().getDescription(NAME));
+  return dialog;
+}
 Action::state_ptr AtomRemoveAction::performCall() {
-  Dialog *dialog = UIFactory::getInstance().makeDialog();
   atom *first = NULL;
+  dialog->queryAtom(NAME, &first, MapOfActions::getInstance().getDescription(NAME));
+  if(dialog->display()) {
+    delete dialog;
+  std::vector<molecule *> molecules = World::getInstance().getAllMolecules();
+  for (World::AtomSelectionIterator iter = World::getInstance().beginAtomSelection(); iter != World::getInstance().endAtomSelection(); ++iter) {
+    first = iter->second;
     DoLog(1) && (Log() << Verbose(1) << "Removing atom " << first->getId() << "." << endl);
     // TODO: this is not necessary when atoms and their storing to file are handled by the World
     // simply try to erase in every molecule found
-    std::vector<molecule *> molecules = World::getInstance().getAllMolecules();
     for (std::vector<molecule *>::iterator iter = molecules.begin();iter != molecules.end(); ++iter) {
       (*iter)->erase(first);
+    }
     World::getInstance().destroyAtom(first);
-    return Action::success;
-  } else {
-    delete dialog;
-    return Action::failure;
+  }
+  return Action::success;
+}

src/Actions/AtomAction/RemoveAction.hpp

-              r7067bd6
+              r677e13
 #include "Actions/Action.hpp"
+void AtomRemove();
 class AtomRemoveAction : public Action {
+  friend void AtomRemove();
 public:
   AtomRemoveAction();
 …
   virtual const std::string getName();
 private:
+  virtual Dialog * createDialog();
   virtual Action::state_ptr performCall();
   virtual Action::state_ptr performUndo(Action::state_ptr);

src/Actions/Calculation.hpp

r7067bd6	r677e13
64	64	virtual T* doCalc()=0;
65	65	private:
	66	virtual Dialog* createDialog();
66	67	virtual Action::state_ptr performCall();
67	68	virtual Action::state_ptr performUndo(Action::state_ptr);

src/Actions/Calculation_impl.hpp

-              r7067bd6
+              r677e13
 // methods inherited from Action
+template<typename T>
+Dialog* Calculation<T>::createDialog(){
+  return NULL;
+}
 template<typename T>

src/Actions/CmdAction/BondLengthTableAction.cpp

-              r7067bd6
+              r677e13
 #include "Actions/CmdAction/BondLengthTableAction.hpp"
+#include "Actions/ActionRegistry.hpp"
 #include "bondgraph.hpp"
 #include "config.hpp"
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
 #include "Actions/MapOfActions.hpp"
+#include "UIElements/ValueStorage.hpp"
 const char CommandLineBondLengthTableAction::NAME[] = "bond-table";
 …
 {}
+void CommandBondLengthTable(std::string &BondGraphFileName) {
+  ValueStorage::getInstance().setCurrentValue(CommandLineBondLengthTableAction::NAME, BondGraphFileName);
+  ActionRegistry::getInstance().getActionByName(CommandLineBondLengthTableAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* CommandLineBondLengthTableAction::createDialog() {
+  Dialog *dialog = UIFactory::getInstance().makeDialog();
+  dialog->queryString(NAME, ValueStorage::getInstance().getDescription(NAME));
+  return dialog;
+}
 Action::state_ptr CommandLineBondLengthTableAction::performCall() {
   ostringstream usage;
   string BondGraphFileName;
-  Dialog *dialog = UIFactory::getInstance().makeDialog();
+  ValueStorage::getInstance().queryCurrentValue(NAME, BondGraphFileName);
+  DoLog(0) && (Log() << Verbose(0) << "Using " << BondGraphFileName << " as bond length table." << endl);
   config *configuration = World::getInstance().getConfig();
-  dialog->queryString(NAME, &BondGraphFileName, MapOfActions::getInstance().getDescription(NAME));
-  if(dialog->display()) {
-    DoLog(0) && (Log() << Verbose(0) << "Using " << BondGraphFileName << " as bond length table." << endl);
-    delete dialog;
-  } else {
-    delete dialog;
-    return Action::failure;
+  }
   if (configuration->BG == NULL) {
     configuration->BG = new BondGraph(configuration->GetIsAngstroem());

src/Actions/CmdAction/BondLengthTableAction.hpp

-              r7067bd6
+              r677e13
 #include "Actions/Action.hpp"
+void CommandBondLengthTable(std::string &BondGraphFileName);
 class CommandLineBondLengthTableAction : public Action {
+  friend void CommandBondLengthTable(std::string &BondGraphFileName);
 public:
   CommandLineBondLengthTableAction();
 …
   virtual const std::string getName();
 private:
+  virtual Dialog * createDialog();
   virtual Action::state_ptr performCall();
   virtual Action::state_ptr performUndo(Action::state_ptr);

src/Actions/CmdAction/ElementDbAction.cpp

-              r7067bd6
+              r677e13
 #include "Actions/CmdAction/ElementDbAction.hpp"
+#include "Actions/ActionRegistry.hpp"
 #include "config.hpp"
 #include "log.hpp"
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
 #include "Actions/MapOfActions.hpp"
+#include "UIElements/ValueStorage.hpp"
 const char CommandLineElementDbAction::NAME[] = "element-db";
 …
 {}
+void CommandElementDb(std::string &databasepath) {
+  ValueStorage::getInstance().setCurrentValue(CommandLineElementDbAction::NAME, databasepath);
+  ActionRegistry::getInstance().getActionByName(CommandLineElementDbAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* CommandLineElementDbAction::createDialog() {
+  Dialog *dialog = UIFactory::getInstance().makeDialog();
+  dialog->queryString(NAME, ValueStorage::getInstance().getDescription(NAME));
+  return dialog;
+}
 Action::state_ptr CommandLineElementDbAction::performCall() {
   ostringstream usage;
   string databasepath;
-  Dialog *dialog = UIFactory::getInstance().makeDialog();
   // get the path
   // TODO: Make databasepath a std::string
   config *configuration = World::getInstance().getConfig();
+  dialog->queryString(NAME, &databasepath, MapOfActions::getInstance().getDescription(NAME));
+  if(dialog->display()) {
+    strcpy(configuration->databasepath, databasepath.c_str());
+    delete dialog;
+  } else {
+    delete dialog;
+    return Action::failure;
+  }
+  ValueStorage::getInstance().queryCurrentValue(NAME, databasepath);
+  strcpy(configuration->databasepath, databasepath.c_str());
   // load table

src/Actions/CmdAction/ElementDbAction.hpp

-              r7067bd6
+              r677e13
 #include "Actions/Action.hpp"
+void CommandElementDb(std::string &databasepath);
 class CommandLineElementDbAction : public Action {
+  friend void CommandElementDb(std::string &databasepath);
 public:
   CommandLineElementDbAction();
 …
   virtual const std::string getName();
 private:
+  virtual Dialog * createDialog();
   virtual Action::state_ptr performCall();
   virtual Action::state_ptr performUndo(Action::state_ptr);

src/Actions/CmdAction/FastParsingAction.cpp

-              r7067bd6
+              r677e13
 #include "Actions/CmdAction/FastParsingAction.hpp"
+#include "Actions/ActionRegistry.hpp"
 #include "config.hpp"
 #include "log.hpp"
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
+#include "Actions/MapOfActions.hpp"
+#include "UIElements/ValueStorage.hpp"
+// memento to remember the state when undoing
+class CommandLineFastParsingState : public ActionState {
+public:
+  CommandLineFastParsingState(bool _bool) :
+    boolean(_bool)
+  {}
+  bool boolean;
+};
 const char CommandLineFastParsingAction::NAME[] = "fastparsing";
 …
 {}
+Action::state_ptr CommandLineFastParsingAction::performCall() {
+void CommandFastParsing(bool fastparsing) {
+  ValueStorage::getInstance().setCurrentValue(CommandLineFastParsingAction::NAME, fastparsing);
+  ActionRegistry::getInstance().getActionByName(CommandLineFastParsingAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* CommandLineFastParsingAction::createDialog() {
   Dialog *dialog = UIFactory::getInstance().makeDialog();
+  dialog->queryBoolean(NAME, MapOfActions::getInstance().getDescription(NAME));
+  return dialog;
+}
+Action::state_ptr CommandLineFastParsingAction::performCall() {
   config *configuration = World::getInstance().getConfig();
+  dialog->queryBoolean(NAME, &configuration->FastParsing, MapOfActions::getInstance().getDescription(NAME));
+  if(dialog->display()) {
+    if (configuration->FastParsing)
+      DoLog(0) && (Log() << Verbose(0) << "I won't parse trajectories." << endl);
+    else
+      DoLog(0) && (Log() << Verbose(0) << "I will parse trajectories." << endl);
+    delete dialog;
+    return Action::success;
+  } else {
+    delete dialog;
+    return Action::failure;
+  }
+  ValueStorage::getInstance().queryCurrentValue(NAME, configuration->FastParsing);
+  if (configuration->FastParsing)
+    DoLog(0) && (Log() << Verbose(0) << "I won't parse trajectories." << endl);
+  else
+    DoLog(0) && (Log() << Verbose(0) << "I will parse trajectories." << endl);
+  return Action::success;
+}
 Action::state_ptr CommandLineFastParsingAction::performUndo(Action::state_ptr _state) {
 //  ParserLoadXyzState *state = assert_cast<ParserLoadXyzState*>(_state.get());
+  CommandLineFastParsingState *state = assert_cast<CommandLineFastParsingState*>(_state.get());
+  return Action::failure;
+//  string newName = state->mol->getName();
+//  state->mol->setName(state->lastName);
+//
+//  return Action::state_ptr(new ParserLoadXyzState(state->mol,newName));
+  config *configuration = World::getInstance().getConfig();
+  configuration->FastParsing = state->boolean;
+  return Action::state_ptr(new CommandLineFastParsingState(!state->boolean));
+}
 Action::state_ptr CommandLineFastParsingAction::performRedo(Action::state_ptr _state){
   return Action::failure;
+  performUndo(_state);
+}
 bool CommandLineFastParsingAction::canUndo() {
   return false;
+  return true;
+}
 bool CommandLineFastParsingAction::shouldUndo() {
   return false;
+  return true;
+}

src/Actions/CmdAction/FastParsingAction.hpp

-              r7067bd6
+              r677e13
 #include "Actions/Action.hpp"
+void CommandFastParsing(bool fastparsing);
 class CommandLineFastParsingAction : public Action {
+  friend void CommandFastParsing(bool fastparsing);
 public:
   CommandLineFastParsingAction();
 …
   virtual const std::string getName();
 private:
+  virtual Dialog * createDialog();
   virtual Action::state_ptr performCall();
   virtual Action::state_ptr performUndo(Action::state_ptr);

src/Actions/CmdAction/HelpAction.cpp

-              r7067bd6
+              r677e13
 #include "Actions/CmdAction/HelpAction.hpp"
+#include "Actions/ActionRegistry.hpp"
 #include "CommandLineParser.hpp"
 …
 {}
+Action::state_ptr CommandLineHelpAction::performCall() {
+  ostringstream usage;
+void CommandHelp() {
+  ActionRegistry::getInstance().getActionByName(CommandLineHelpAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* CommandLineHelpAction::createDialog() {
   Dialog *dialog = UIFactory::getInstance().makeDialog();
+  ostringstream usage;
   usage << CommandLineParser::getInstance().visible << endl;
   dialog->queryEmpty(NAME, usage.str());
+  if(dialog->display()) {
+    delete dialog;
+    return Action::success;
+  } else {
+    delete dialog;
+    return Action::failure;
+  }
+  return dialog;
+}
+Action::state_ptr CommandLineHelpAction::performCall() {
+  return Action::success;
+}
 Action::state_ptr CommandLineHelpAction::performUndo(Action::state_ptr _state) {
+//  ParserLoadXyzState *state = assert_cast<ParserLoadXyzState*>(_state.get());
+  return Action::failure;
+//  string newName = state->mol->getName();
+//  state->mol->setName(state->lastName);
+//
+//  return Action::state_ptr(new ParserLoadXyzState(state->mol,newName));
+  return Action::success;
+}
 Action::state_ptr CommandLineHelpAction::performRedo(Action::state_ptr _state){
   return Action::failure;
+  return Action::success;
+}
 bool CommandLineHelpAction::canUndo() {
   return false;
+  return true;
+}
 bool CommandLineHelpAction::shouldUndo() {
   return false;
+  return true;
+}

src/Actions/CmdAction/HelpAction.hpp

-              r7067bd6
+              r677e13
 #include "Actions/Action.hpp"
+void CommandHelp();
 class CommandLineHelpAction : public Action {
+  friend void CommandHelp();
 public:
   CommandLineHelpAction();
 …
   virtual const std::string getName();
 private:
+  virtual Dialog * createDialog();
   virtual Action::state_ptr performCall();
   virtual Action::state_ptr performUndo(Action::state_ptr);

src/Actions/CmdAction/VerboseAction.cpp

-              r7067bd6
+              r677e13
 #include "Actions/CmdAction/VerboseAction.hpp"
+#include "Actions/ActionRegistry.hpp"
 #include "log.hpp"
 #include "verbose.hpp"
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
+#include "Actions/MapOfActions.hpp"
+#include "UIElements/ValueStorage.hpp"
+// memento to remember the state when undoing
+class CommandLineVerboseState : public ActionState {
+public:
+  CommandLineVerboseState(int _verbosity) :
+    verbosity(_verbosity)
+  {}
+  int verbosity;
+};
 const char CommandLineVerboseAction::NAME[] = "verbose";
 …
 {}
+void CommandVerbose(int verbosity) {
+  ValueStorage::getInstance().setCurrentValue(CommandLineVerboseAction::NAME, verbosity);
+  ActionRegistry::getInstance().getActionByName(CommandLineVerboseAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* CommandLineVerboseAction::createDialog() {
+  Dialog *dialog = UIFactory::getInstance().makeDialog();
+  dialog->queryInt(NAME, ValueStorage::getInstance().getDescription(NAME));
+  return dialog;
+}
 Action::state_ptr CommandLineVerboseAction::performCall() {
-  Dialog *dialog = UIFactory::getInstance().makeDialog();
   int verbosity = 2;
   dialog->queryInt(NAME, &verbosity, MapOfActions::getInstance().getDescription(NAME));
+  ValueStorage::getInstance().queryCurrentValue(NAME, verbosity);
+  if(dialog->display()) {
+    setVerbosity(verbosity);
+    DoLog(0) && (Log() << Verbose(0) << "Setting verbosity to " << verbosity << "." << endl);
+    delete dialog;
+    return Action::success;
+  } else {
+    delete dialog;
+    return Action::failure;
+  }
+  setVerbosity(verbosity);
+  DoLog(0) && (Log() << Verbose(0) << "Setting verbosity to " << verbosity << "." << endl);
+  return Action::success;
+}
 Action::state_ptr CommandLineVerboseAction::performUndo(Action::state_ptr _state) {
 //  ParserLoadXyzState *state = assert_cast<ParserLoadXyzState*>(_state.get());
+  CommandLineVerboseState *state = assert_cast<CommandLineVerboseState*>(_state.get());
   return Action::failure;
 //  string newName = state->mol->getName();
+//  state->mol->setName(state->lastName);
+//
 //  return Action::state_ptr(new ParserLoadXyzState(state->mol,newName));
+  int verbosity = 2;
+  ValueStorage::getInstance().queryCurrentValue(NAME, verbosity);
+  setVerbosity(state->verbosity);
+  return Action::state_ptr(new CommandLineVerboseState(verbosity));
+}
 Action::state_ptr CommandLineVerboseAction::performRedo(Action::state_ptr _state){
   return Action::failure;
+  performUndo(_state);
+}
 bool CommandLineVerboseAction::canUndo() {
   return false;
+  return true;
+}
 bool CommandLineVerboseAction::shouldUndo() {
   return false;
+  return true;
+}

src/Actions/CmdAction/VerboseAction.hpp

-              r7067bd6
+              r677e13
 #include "Actions/Action.hpp"
+void CommandVerbose(int verbosity);
 class CommandLineVerboseAction : public Action {
+  friend void CommandVerbose(int verbosity);
 public:
   CommandLineVerboseAction();
 …
   virtual const std::string getName();
 private:
+  virtual Dialog * createDialog();
   virtual Action::state_ptr performCall();
   virtual Action::state_ptr performUndo(Action::state_ptr);

src/Actions/CmdAction/VersionAction.cpp

-              r7067bd6
+              r677e13
 #include "Actions/CmdAction/VersionAction.hpp"
+#include "Actions/ActionRegistry.hpp"
 #include <iostream>
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
 #include "Actions/MapOfActions.hpp"
+#include "UIElements/ValueStorage.hpp"
 const char CommandLineVersionAction::NAME[] = "version";
 …
 {}
+Action::state_ptr CommandLineVersionAction::performCall() {
+void CommandVersion() {
+  ActionRegistry::getInstance().getActionByName(CommandLineVersionAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* CommandLineVersionAction::createDialog() {
   Dialog *dialog = UIFactory::getInstance().makeDialog();
   dialog->queryEmpty(NAME, ESPACKVersion);
+  if(dialog->display()) {
+    delete dialog;
+    return Action::success;
+  } else {
+    delete dialog;
+    return Action::failure;
+  }
+  return dialog;
+}
+Action::state_ptr CommandLineVersionAction::performCall() {
+  return Action::success;
+}
 Action::state_ptr CommandLineVersionAction::performUndo(Action::state_ptr _state) {
+//  ParserLoadXyzState *state = assert_cast<ParserLoadXyzState*>(_state.get());
+  return Action::failure;
+//  string newName = state->mol->getName();
+//  state->mol->setName(state->lastName);
+//
+//  return Action::state_ptr(new ParserLoadXyzState(state->mol,newName));
+  return Action::success;
+}
 Action::state_ptr CommandLineVersionAction::performRedo(Action::state_ptr _state){
   return Action::failure;
+  return Action::success;
+}
 bool CommandLineVersionAction::canUndo() {
   return false;
+  return true;
+}
 bool CommandLineVersionAction::shouldUndo() {
   return false;
+  return true;
+}

src/Actions/CmdAction/VersionAction.hpp

-              r7067bd6
+              r677e13
 #include "version.h"
+void CommandVersion();
 class CommandLineVersionAction : public Action {
+  friend void CommandVersion();
 public:
   CommandLineVersionAction();
 …
   virtual const std::string getName();
 private:
+  virtual Dialog * createDialog();
   virtual Action::state_ptr performCall();
   virtual Action::state_ptr performUndo(Action::state_ptr);

src/Actions/ErrorAction.cpp

-              r7067bd6
+              r677e13
+}
+Dialog* ErrorAction::createDialog() {
+  return NULL;
+}
 Action::state_ptr ErrorAction::performCall() {
   Log() << Verbose(0) << errorMsg << endl;

src/Actions/ErrorAction.hpp

r7067bd6	r677e13
22	22
23	23	private:
24
	24	virtual Dialog * createDialog();
25	25	virtual Action::state_ptr performCall();
26	26	virtual Action::state_ptr performUndo(Action::state_ptr);

src/Actions/FragmentationAction/DepthFirstSearchAction.cpp

-              r7067bd6
+              r677e13
 #include "Actions/FragmentationAction/DepthFirstSearchAction.hpp"
+#include "Actions/ActionRegistry.hpp"
 #include "atom.hpp"
 #include "bondgraph.hpp"
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
 #include "Actions/MapOfActions.hpp"
+#include "UIElements/ValueStorage.hpp"
 const char FragmentationDepthFirstSearchAction::NAME[] = "depth-first-search";
 …
 {}
+void FragmentationDepthFirstSearch(double distance) {
+  ValueStorage::getInstance().setCurrentValue(FragmentationDepthFirstSearchAction::NAME, distance);
+  ActionRegistry::getInstance().getActionByName(FragmentationDepthFirstSearchAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* FragmentationDepthFirstSearchAction::createDialog() {
+  Dialog *dialog = UIFactory::getInstance().makeDialog();
+  dialog->queryDouble(NAME, ValueStorage::getInstance().getDescription(NAME));
+  return dialog;
+}
 Action::state_ptr FragmentationDepthFirstSearchAction::performCall() {
-  Dialog *dialog = UIFactory::getInstance().makeDialog();
   double distance;
   dialog->queryDouble(NAME, &distance, MapOfActions::getInstance().getDescription(NAME));
+  ValueStorage::getInstance().queryCurrentValue(NAME, distance);
+  if(dialog->display()) {
+    DoLog(1) && (Log() << Verbose(1) << "Depth-First-Search Analysis." << endl);
+    molecule * const mol = World::getInstance().getMolecule(MoleculeById(0));
+    MoleculeLeafClass *Subgraphs = NULL;      // list of subgraphs from DFS analysis
+    int *MinimumRingSize = new int[mol->getAtomCount()];
+    atom **ListOfAtoms = NULL;
+    class StackClass<bond *> *BackEdgeStack = NULL;
+    class StackClass<bond *> *LocalBackEdgeStack = NULL;
+    mol->CreateAdjacencyList(distance, World::getInstance().getConfig()->GetIsAngstroem(), &BondGraph::CovalentMinMaxDistance, NULL);
+    Subgraphs = mol->DepthFirstSearchAnalysis(BackEdgeStack);
+    if (Subgraphs != NULL) {
+      int FragmentCounter = 0;
+      while (Subgraphs->next != NULL) {
+        Subgraphs = Subgraphs->next;
+        ListOfAtoms = NULL;
+        Subgraphs->FillBondStructureFromReference(mol, ListOfAtoms, false);  // we want to keep the created ListOfLocalAtoms
+        LocalBackEdgeStack = new StackClass<bond *> (Subgraphs->Leaf->BondCount);
+        Subgraphs->Leaf->PickLocalBackEdges(ListOfAtoms, BackEdgeStack, LocalBackEdgeStack);
+        Subgraphs->Leaf->CyclicStructureAnalysis(LocalBackEdgeStack, MinimumRingSize);
+        delete(LocalBackEdgeStack);
+        delete(Subgraphs->previous);
+        delete[](ListOfAtoms);  // and here we remove it
+        FragmentCounter++;
+      }
+      delete(Subgraphs);
+  DoLog(1) && (Log() << Verbose(1) << "Depth-First-Search Analysis." << endl);
+  molecule * const mol = World::getInstance().getMolecule(MoleculeById(0));
+  MoleculeLeafClass *Subgraphs = NULL;      // list of subgraphs from DFS analysis
+  int *MinimumRingSize = new int[mol->getAtomCount()];
+  atom **ListOfAtoms = NULL;
+  class StackClass<bond *> *BackEdgeStack = NULL;
+  class StackClass<bond *> *LocalBackEdgeStack = NULL;
+  mol->CreateAdjacencyList(distance, World::getInstance().getConfig()->GetIsAngstroem(), &BondGraph::CovalentMinMaxDistance, NULL);
+  Subgraphs = mol->DepthFirstSearchAnalysis(BackEdgeStack);
+  if (Subgraphs != NULL) {
+    int FragmentCounter = 0;
+    while (Subgraphs->next != NULL) {
+      Subgraphs = Subgraphs->next;
+      ListOfAtoms = NULL;
+      Subgraphs->FillBondStructureFromReference(mol, ListOfAtoms, false);  // we want to keep the created ListOfLocalAtoms
+      LocalBackEdgeStack = new StackClass<bond *> (Subgraphs->Leaf->BondCount);
+      Subgraphs->Leaf->PickLocalBackEdges(ListOfAtoms, BackEdgeStack, LocalBackEdgeStack);
+      Subgraphs->Leaf->CyclicStructureAnalysis(LocalBackEdgeStack, MinimumRingSize);
+      delete(LocalBackEdgeStack);
+      delete(Subgraphs->previous);
+      delete[](ListOfAtoms);  // and here we remove it
+      FragmentCounter++;
+    }
+    delete(BackEdgeStack);
+    delete[](MinimumRingSize);
+    delete dialog;
+    return Action::success;
+  } else {
+    delete dialog;
+    return Action::failure;
+    delete(Subgraphs);
+  }
+  delete(BackEdgeStack);
+  delete[](MinimumRingSize);
+  return Action::success;
+}
 Action::state_ptr FragmentationDepthFirstSearchAction::performUndo(Action::state_ptr _state) {
+//  ParserLoadXyzState *state = assert_cast<ParserLoadXyzState*>(_state.get());
+  return Action::failure;
+//  string newName = state->mol->getName();
+//  state->mol->setName(state->lastName);
+//
+//  return Action::state_ptr(new ParserLoadXyzState(state->mol,newName));
+  return Action::success;
+}
 Action::state_ptr FragmentationDepthFirstSearchAction::performRedo(Action::state_ptr _state){
   return Action::failure;
+  return Action::success;
+}
 bool FragmentationDepthFirstSearchAction::canUndo() {
   return false;
+  return true;
+}
 bool FragmentationDepthFirstSearchAction::shouldUndo() {
   return false;
+  return true;
+}

src/Actions/FragmentationAction/DepthFirstSearchAction.hpp

-              r7067bd6
+              r677e13
 #include "Actions/Action.hpp"
+void FragmentationDepthFirstSearch(double distance);
 class FragmentationDepthFirstSearchAction : public Action {
+  friend void FragmentationDepthFirstSearch(double distance);
 public:
   FragmentationDepthFirstSearchAction();
 …
   virtual const std::string getName();
 private:
+  virtual Dialog * createDialog();
   virtual Action::state_ptr performCall();
   virtual Action::state_ptr performUndo(Action::state_ptr);

src/Actions/FragmentationAction/FragmentationAction.cpp

-              r7067bd6
+              r677e13
 #include "Actions/FragmentationAction/FragmentationAction.hpp"
+#include "Actions/ActionRegistry.hpp"
 #include "atom.hpp"
 #include "bondgraph.hpp"
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
 #include "Actions/MapOfActions.hpp"
+#include "UIElements/ValueStorage.hpp"
 const char FragmentationFragmentationAction::NAME[] = "fragment-mol";
 …
 {}
+void FragmentationFragmentation(std::string &path, double distance, int order) {
+  ValueStorage::getInstance().setCurrentValue(FragmentationFragmentationAction::NAME, path);
+  ValueStorage::getInstance().setCurrentValue("distance", distance);
+  ValueStorage::getInstance().setCurrentValue("order", order);
+  ActionRegistry::getInstance().getActionByName(FragmentationFragmentationAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* FragmentationFragmentationAction::createDialog() {
+  Dialog *dialog = UIFactory::getInstance().makeDialog();
+  dialog->queryString(NAME, ValueStorage::getInstance().getDescription(NAME));
+  dialog->queryDouble("distance", ValueStorage::getInstance().getDescription("distance"));
+  dialog->queryInt("order", ValueStorage::getInstance().getDescription("order"));
+  return dialog;
+}
 Action::state_ptr FragmentationFragmentationAction::performCall() {
-  Dialog *dialog = UIFactory::getInstance().makeDialog();
   clock_t start,end;
   molecule *mol = NULL;
 …
   int ExitFlag = 0;
+  cout << "pre-dialog"<< endl;
+  dialog->queryString(NAME, &path, MapOfActions::getInstance().getDescription(NAME));
+  dialog->queryMolecule("molecule-by-id", &mol, MapOfActions::getInstance().getDescription("molecule-by-id"));
+  dialog->queryDouble("distance", &distance, MapOfActions::getInstance().getDescription("distance"));
+  dialog->queryInt("order", &order, MapOfActions::getInstance().getDescription("order"));
+  ValueStorage::getInstance().queryCurrentValue(NAME, path);
+  ValueStorage::getInstance().queryCurrentValue("distance", distance);
+  ValueStorage::getInstance().queryCurrentValue("order", order);
   if(dialog->display()) {
     cout << "POST-dialog"<< endl;
+  for (World::MoleculeSelectionIterator iter = World::getInstance().beginMoleculeSelection(); iter != World::getInstance().endMoleculeSelection(); ++iter) {
+    mol = iter->second;
     ASSERT(mol != NULL, "No molecule has been picked for fragmentation.");
     DoLog(0) && (Log() << Verbose(0) << "Fragmenting molecule with bond distance " << distance << " angstroem, order of " << order << "." << endl);
 …
     end = clock();
     DoLog(0) && (Log() << Verbose(0) << "Clocks for this operation: " << (end-start) << ", time: " << ((double)(end-start)/CLOCKS_PER_SEC) << "s." << endl);
-    delete dialog;
-    return Action::success;
-  } else {
-    delete dialog;
-    return Action::failure;
+  }
+  return Action::success;
+}
 Action::state_ptr FragmentationFragmentationAction::performUndo(Action::state_ptr _state) {
+//  ParserLoadXyzState *state = assert_cast<ParserLoadXyzState*>(_state.get());
+  return Action::failure;
+//  string newName = state->mol->getName();
+//  state->mol->setName(state->lastName);
+//
+//  return Action::state_ptr(new ParserLoadXyzState(state->mol,newName));
+  return Action::success;
+}
 Action::state_ptr FragmentationFragmentationAction::performRedo(Action::state_ptr _state){
   return Action::failure;
+  return Action::success;
+}
 bool FragmentationFragmentationAction::canUndo() {
   return false;
+  return true;
+}
 bool FragmentationFragmentationAction::shouldUndo() {
   return false;
+  return true;
+}

src/Actions/FragmentationAction/FragmentationAction.hpp

-              r7067bd6
+              r677e13
 #include "Actions/Action.hpp"
+void FragmentationFragmentation(std::string &path, double distance, int order);
 class FragmentationFragmentationAction : public Action {
+  friend void FragmentationFragmentation(std::string &path, double distance, int order);
 public:
   FragmentationFragmentationAction();
 …
   virtual const std::string getName();
 private:
+  virtual Dialog * createDialog();
   virtual Action::state_ptr performCall();
   virtual Action::state_ptr performUndo(Action::state_ptr);

src/Actions/FragmentationAction/SubgraphDissectionAction.cpp

-              r7067bd6
+              r677e13
 #include "Actions/FragmentationAction/SubgraphDissectionAction.hpp"
+#include "Actions/ActionRegistry.hpp"
 #include "atom.hpp"
 #include "config.hpp"
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
 #include "Actions/MapOfActions.hpp"
+#include "UIElements/ValueStorage.hpp"
 const char FragmentationSubgraphDissectionAction::NAME[] = "subgraph-dissect";
 …
 {}
+Action::state_ptr FragmentationSubgraphDissectionAction::performCall() {
+void FragmentationSubgraphDissection() {
+  ActionRegistry::getInstance().getActionByName(FragmentationSubgraphDissectionAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* FragmentationSubgraphDissectionAction::createDialog() {
   Dialog *dialog = UIFactory::getInstance().makeDialog();
   dialog->queryEmpty(NAME, MapOfActions::getInstance().getDescription(NAME));
+  if(dialog->display()) {
+    DoLog(1) && (Log() << Verbose(1) << "Dissecting molecular system into a set of disconnected subgraphs ... " << endl);
+    // @TODO rather do the dissection afterwards
+    MoleculeListClass *molecules = World::getInstance().getMolecules();
+    molecules->DissectMoleculeIntoConnectedSubgraphs(World::getInstance().getPeriode(), World::getInstance().getConfig());
+    delete dialog;
+    return Action::success;
+  } else {
+    delete dialog;
+    return Action::failure;
+  }
+  return dialog;
+}
+Action::state_ptr FragmentationSubgraphDissectionAction::performCall() {
+  DoLog(1) && (Log() << Verbose(1) << "Dissecting molecular system into a set of disconnected subgraphs ... " << endl);
+  // @TODO rather do the dissection afterwards
+  MoleculeListClass *molecules = World::getInstance().getMolecules();
+  molecules->DissectMoleculeIntoConnectedSubgraphs(World::getInstance().getPeriode(), World::getInstance().getConfig());
+  return Action::success;
+}

src/Actions/FragmentationAction/SubgraphDissectionAction.hpp

-              r7067bd6
+              r677e13
 #include "Actions/Action.hpp"
+void FragmentationSubgraphDissection();
 class FragmentationSubgraphDissectionAction : public Action {
+  friend void FragmentationSubgraphDissection();
 public:
   FragmentationSubgraphDissectionAction();
 …
   virtual const std::string getName();
 private:
+  virtual Dialog * createDialog();
   virtual Action::state_ptr performCall();
   virtual Action::state_ptr performUndo(Action::state_ptr);

src/Actions/Makefile.am

-              r7067bd6
+              r677e13
   ${MOLECULEACTIONSOURCE} \
   ${PARSERACTIONSOURCE} \
+  ${SELECTIONACTIONSOURCE} \
   ${TESSELATIONACTIONSOURCE} \
   ${WORLDACTIONSOURCE} \
 …
   ${MOLECULEACTIONHEADER} \
   ${PARSERACTIONHEADER} \
+  ${SELECTIONACTIONHEADER} \
   ${TESSELATIONACTIONHEADER} \
   ${WORLDACTIONHEADER} \
 …
   AnalysisAction/MolecularVolumeAction.cpp \
   AnalysisAction/PairCorrelationAction.cpp \
+  AnalysisAction/PrincipalAxisSystemAction.cpp
+  AnalysisAction/PointCorrelationAction.cpp \
+  AnalysisAction/PrincipalAxisSystemAction.cpp \
+  AnalysisAction/SurfaceCorrelationAction.cpp
 ANALYSISACTIONHEADER = \
   AnalysisAction/MolecularVolumeAction.hpp \
   AnalysisAction/PairCorrelationAction.hpp \
+  AnalysisAction/PrincipalAxisSystemAction.hpp
+  AnalysisAction/PointCorrelationAction.hpp \
+  AnalysisAction/PrincipalAxisSystemAction.hpp \
+  AnalysisAction/SurfaceCorrelationAction.hpp
 ATOMACTIONSOURCE = \
 …
   ParserAction/SaveXyzAction.hpp
+SELECTIONACTIONSOURCE = \
+        SelectionAction/AllAtomsAction.cpp \
+        SelectionAction/AllMoleculesAction.cpp \
+        SelectionAction/AtomByIdAction.cpp \
+        SelectionAction/MoleculeByIdAction.cpp \
+        SelectionAction/NotAllAtomsAction.cpp \
+        SelectionAction/NotAllMoleculesAction.cpp \
+        SelectionAction/NotAtomByIdAction.cpp \
+        SelectionAction/NotMoleculeByIdAction.cpp
+SELECTIONACTIONHEADER = \
+        SelectionAction/AllAtomsAction.hpp \
+        SelectionAction/AllMoleculesAction.hpp \
+        SelectionAction/AtomByIdAction.hpp \
+        SelectionAction/MoleculeByIdAction.hpp \
+        SelectionAction/NotAllAtomsAction.hpp \
+        SelectionAction/NotAllMoleculesAction.hpp \
+        SelectionAction/NotAtomByIdAction.hpp \
+        SelectionAction/NotMoleculeByIdAction.hpp
 TESSELATIONACTIONSOURCE = \
   TesselationAction/ConvexEnvelopeAction.cpp \

src/Actions/MakroAction.cpp

-              r7067bd6
+              r677e13
+}
+Dialog* MakroAction::createDialog() {
+  actions->callAllDialogs();
+}
 Action::state_ptr MakroAction::performCall(){

src/Actions/MakroAction.hpp

r7067bd6	r677e13
30	30
31	31	private:
	32	virtual Dialog * createDialog();
32	33	virtual Action::state_ptr performCall();
33	34	virtual Action::state_ptr performUndo(Action::state_ptr);

src/Actions/ManipulateAtomsProcess.cpp

-              r7067bd6
+              r677e13
 ManipulateAtomsProcess::~ManipulateAtomsProcess()
 {}
+Dialog* ManipulateAtomsProcess::createDialog(){
+  return NULL;
+}
 Action::state_ptr ManipulateAtomsProcess::performCall(){

src/Actions/ManipulateAtomsProcess.hpp

r7067bd6	r677e13
29	29	private:
30	30
	31	virtual Dialog* createDialog();
31	32	virtual Action::state_ptr performCall();
32	33	virtual Action::state_ptr performUndo(Action::state_ptr);

src/Actions/MapOfActions.cpp

-              r7067bd6
+              r677e13
 using namespace std;
+#include "Actions/MapOfActions.hpp"
+#include "Descriptors/AtomIdDescriptor.hpp"
+#include "Descriptors/MoleculeIdDescriptor.hpp"
+#include "Helpers/Assert.hpp"
 #include "Patterns/Singleton_impl.hpp"
-#include "Actions/MapOfActions.hpp"
-#include "Helpers/Assert.hpp"
 #include <boost/lexical_cast.hpp>
 …
 #include <iostream>
+#include "atom.hpp"
+#include "Box.hpp"
 #include "CommandLineParser.hpp"
+#include "element.hpp"
 #include "log.hpp"
+#include "Matrix.hpp"
+#include "molecule.hpp"
+#include "periodentafel.hpp"
+#include "vector.hpp"
 #include "verbose.hpp"
 …
 #include "Actions/AnalysisAction/MolecularVolumeAction.hpp"
 #include "Actions/AnalysisAction/PairCorrelationAction.hpp"
+#include "Actions/AnalysisAction/PointCorrelationAction.hpp"
 #include "Actions/AnalysisAction/PrincipalAxisSystemAction.hpp"
+#include "Actions/AnalysisAction/SurfaceCorrelationAction.hpp"
 #include "Actions/AtomAction/AddAction.hpp"
 #include "Actions/AtomAction/ChangeElementAction.hpp"
 …
 #include "Actions/ParserAction/LoadXyzAction.hpp"
 #include "Actions/ParserAction/SaveXyzAction.hpp"
+#include "Actions/SelectionAction/AllAtomsAction.hpp"
+#include "Actions/SelectionAction/AllMoleculesAction.hpp"
+#include "Actions/SelectionAction/AtomByIdAction.hpp"
+#include "Actions/SelectionAction/MoleculeByIdAction.hpp"
+#include "Actions/SelectionAction/NotAllAtomsAction.hpp"
+#include "Actions/SelectionAction/NotAllMoleculesAction.hpp"
+#include "Actions/SelectionAction/NotAtomByIdAction.hpp"
+#include "Actions/SelectionAction/NotMoleculeByIdAction.hpp"
 #include "Actions/TesselationAction/ConvexEnvelopeAction.hpp"
 #include "Actions/TesselationAction/NonConvexEnvelopeAction.hpp"
 …
+  }
   BV.xx = boost::lexical_cast<double>(components.at(0));
   BV.xy = boost::lexical_cast<double>(components.at(1));
   BV.xz = boost::lexical_cast<double>(components.at(2));
   BV.yy = boost::lexical_cast<double>(components.at(3));
   BV.yz = boost::lexical_cast<double>(components.at(4));
+  BV.yx = boost::lexical_cast<double>(components.at(1));
+  BV.yy = boost::lexical_cast<double>(components.at(2));
+  BV.zx = boost::lexical_cast<double>(components.at(3));
+  BV.zy = boost::lexical_cast<double>(components.at(4));
   BV.zz = boost::lexical_cast<double>(components.at(5));
   v = boost::any(BoxValue(BV));
 …
   DescriptionMap["output"] = "write output files";
   DescriptionMap["set-output"] = "specify output formats";
   DescriptionMap["pair-correlation"] = "pair correlation analysis between two elements, element and point or element and surface";
+  DescriptionMap["pair-correlation"] = "pair correlation analysis between two elements";
   DescriptionMap["parse-xyz"] = "parse xyz file into World";
+  DescriptionMap["point-correlation"] = "pair correlation analysis between element and point";
   DescriptionMap["principal-axis-system"] = "calculate the principal axis system of the specified molecule";
   DescriptionMap["remove-atom"] = "remove a specified atom";
 …
   DescriptionMap["SaveXyz"] = "save world as xyz file";
   DescriptionMap["scale-box"] = "scale box and atomic positions inside";
+  DescriptionMap["select-all-atoms"] = "select all atoms";
+  DescriptionMap["select-all-molecules"] = "select all molecules";
+  DescriptionMap["select-atom-by-id"] = "select an atom by index";
+  DescriptionMap["select-molecule-by-id"] = "select a molecule by index";
   DescriptionMap["set-basis"] = "set the name of the gaussian basis set for MPQC";
   DescriptionMap["set-output"] = "specify output formats";
   DescriptionMap["subgraph-dissect"] = "dissect the molecular system into molecules representing disconnected subgraphs";
+  DescriptionMap["surface-correlation"] = "pair correlation analysis between element and surface";
   DescriptionMap["suspend-in-water"] = "suspend the given molecule in water such that in the domain the mean density is as specified";
   DescriptionMap["translate-mol"] = "translate molecule by given vector";
+  DescriptionMap["unselect-all-atoms"] = "unselect all atoms";
+  DescriptionMap["unselect-all-molecules"] = "unselect all molecules";
+  DescriptionMap["unselect-atom-by-id"] = "unselect an atom by index";
+  DescriptionMap["unselect-molecule-by-id"] = "unselect a molecule by index";
   DescriptionMap["verbose"] = "set verbosity level";
   DescriptionMap["verlet-integrate"] = "perform verlet integration of a given force file";
   DescriptionMap["version"] = "show version";
   // keys for values
-  DescriptionMap["atom-by-id"] = "index of an atom";
   DescriptionMap["bin-output-file"] = "name of the bin output file";
   DescriptionMap["bin-end"] = "start of the last bin";
 …
   DescriptionMap["MaxDistance"] = "maximum distance in space";
   DescriptionMap["molecule-by-id"] = "index of a molecule";
-  DescriptionMap["molecule-by-name"] = "name of a molecule";
   DescriptionMap["nonconvex-file"] = "filename of the non-convex envelope";
   DescriptionMap["order"] = "order of a discretization, dissection, ...";
 …
   DescriptionMap["periodic"] = "system is constraint to periodic boundary conditions (y/n)";
   DescriptionMap["position"] = "position in R^3 space";
-  DescriptionMap["sphere-radius"] = "radius of tesselation sphere";
   DescriptionMap["start-step"] = "first or start step";
 …
   ShortFormMap["nonconvex-envelope"] = "N";
 //  ShortFormMap["output"] = "o";
   ShortFormMap["pair-correlation"] = "C";
+//  ShortFormMap["pair-correlation"] = "C";
   ShortFormMap["parse-xyz"] = "p";
   ShortFormMap["remove-atom"] = "r";
 …
   // value types for the actions
+  TypeMap["add-atom"] = Element;
+  TypeMap["bond-file"] = String;
+  TypeMap["bond-table"] = String;
+  TypeMap["boundary"] = Vector;
+  TypeMap["center-in-box"] = Box;
+  TypeMap["change-box"] = Box;
+  TypeMap["change-element"] = Element;
+  TypeMap["change-molname"] = String;
+  TypeMap["convex-envelope"] = Molecule;
+  TypeMap["default-molname"] = String;
+  TypeMap["depth-first-search"] = Double;
+  TypeMap["element-db"] = String;
+  TypeMap["fastparsing"] = Boolean;
+  TypeMap["fill-molecule"] = String;
+  TypeMap["fragment-mol"] = String;
+  TypeMap["input"] = String;
+  TypeMap["linear-interpolate"] = String;
+  TypeMap["molecular-volume"] = Molecule;
+  TypeMap["nonconvex-envelope"] = Molecule;
+  TypeMap["output"] = None;
+  TypeMap["parse-xyz"] = String;
+  TypeMap["pair-correlation"] = String;
+  TypeMap["principal-axis-system"] = Molecule;
+  TypeMap["remove-atom"] = Atom;
+  TypeMap["remove-sphere"] = Double;
+  TypeMap["repeat-box"] = Vector;
+  TypeMap["rotate-to-pas"] = Molecule;
+  TypeMap["save-adjacency"] = String;
+  TypeMap["save-bonds"] = String;
+  TypeMap["save-temperature"] = String;
+  TypeMap["scale-box"] = Vector;
+  TypeMap["set-basis"] = String;
+  TypeMap["set-output"] = ListOfString;
+  TypeMap["subgraph-dissect"] = None;
+  TypeMap["suspend-in-water"] = Double;
+  TypeMap["translate-mol"] = Vector;
+  TypeMap["verlet-integrate"] = String;
+  TypeMap["verbose"] = Integer;
+  TypeMap["add-atom"] = &typeid(element);
+  TypeMap["bond-file"] = &typeid(std::string);
+  TypeMap["bond-table"] = &typeid(std::string);
+  TypeMap["boundary"] = &typeid(VectorValue);
+  TypeMap["center-in-box"] = &typeid(BoxValue);
+  TypeMap["change-box"] = &typeid(BoxValue);
+  TypeMap["change-element"] = &typeid(element);
+  TypeMap["change-molname"] = &typeid(std::string);
+  TypeMap["convex-envelope"] = &typeid(void);
+  TypeMap["default-molname"] = &typeid(std::string);
+  TypeMap["depth-first-search"] = &typeid(double);
+  TypeMap["element-db"] = &typeid(std::string);
+  TypeMap["fastparsing"] = &typeid(bool);
+  TypeMap["fill-molecule"] = &typeid(std::string);
+  TypeMap["fragment-mol"] = &typeid(std::string);
+  TypeMap["input"] = &typeid(std::string);
+  TypeMap["linear-interpolate"] = &typeid(std::string);
+  TypeMap["molecular-volume"] = &typeid(molecule);
+  TypeMap["nonconvex-envelope"] = &typeid(double);
+  TypeMap["output"] = &typeid(void);
+  TypeMap["parse-xyz"] = &typeid(std::string);
+  TypeMap["pair-correlation"] = &typeid(void);
+  TypeMap["point-correlation"] = &typeid(void);
+  TypeMap["principal-axis-system"] = &typeid(void);
+  TypeMap["remove-atom"] = &typeid(void);
+  TypeMap["remove-sphere"] = &typeid(double);
+  TypeMap["repeat-box"] = &typeid(VectorValue);
+  TypeMap["rotate-to-pas"] = &typeid(molecule);
+  TypeMap["save-adjacency"] = &typeid(std::string);
+  TypeMap["save-bonds"] = &typeid(std::string);
+  TypeMap["save-temperature"] = &typeid(std::string);
+  TypeMap["scale-box"] = &typeid(VectorValue);
+  TypeMap["set-basis"] = &typeid(std::string);
+  TypeMap["set-output"] = &typeid(std::vector<std::string>);
+  TypeMap["subgraph-dissect"] = &typeid(void);
+  TypeMap["surface-correlation"] = &typeid(void);
+  TypeMap["suspend-in-water"] = &typeid(double);
+  TypeMap["translate-mol"] = &typeid(VectorValue);
+  TypeMap["verlet-integrate"] = &typeid(std::string);
+  TypeMap["verbose"] = &typeid(int);
   // value types for the values
+  TypeMap["atom-by-id"] = Atom;
+  TypeMap["bin-output-file"] = String;
+  TypeMap["bin-end"] = Double;
+  TypeMap["bin-start"] = Double;
+  TypeMap["bin-width"] = Double;
+  TypeMap["convex-file"] = String;
+  TypeMap["distance"] = Double;
+  TypeMap["distances"] = Vector;
+  TypeMap["DoRotate"] = Boolean;
+  TypeMap["element"] = Element;
+  TypeMap["elements"] = ListOfElements;
+  TypeMap["end-step"] = Integer;
+  TypeMap["id-mapping"] = Boolean;
+  TypeMap["length"] = Double;
+  TypeMap["lengths"] = Vector;
+  TypeMap["MaxDistance"] = Double;
+  TypeMap["molecule-by-id"] = Molecule;
+  TypeMap["molecule-by-name"] = String;
+  TypeMap["nonconvex-file"] = String;
+  TypeMap["order"] = Integer;
+  TypeMap["output-file"] = String;
+  TypeMap["periodic"] = Boolean;
+  TypeMap["position"] = Vector;
+  TypeMap["sphere-radius"] = Double;
+  TypeMap["start-step"] = Integer;
+  TypeMap["bin-output-file"] = &typeid(std::string);
+  TypeMap["bin-end"] = &typeid(double);
+  TypeMap["bin-start"] = &typeid(double);
+  TypeMap["bin-width"] = &typeid(double);
+  TypeMap["convex-file"] = &typeid(std::string);
+  TypeMap["distance"] = &typeid(double);
+  TypeMap["distances"] = &typeid(VectorValue);
+  TypeMap["DoRotate"] = &typeid(bool);
+  TypeMap["element"] = &typeid(element);
+  TypeMap["elements"] = &typeid(std::vector<element *>);
+  TypeMap["end-step"] = &typeid(int);
+  TypeMap["id-mapping"] = &typeid(bool);
+  TypeMap["length"] = &typeid(double);
+  TypeMap["lengths"] = &typeid(VectorValue);
+  TypeMap["MaxDistance"] = &typeid(double);
+  TypeMap["molecule-by-id"] = &typeid(molecule);
+  TypeMap["nonconvex-file"] = &typeid(std::string);
+  TypeMap["order"] = &typeid(int);
+  TypeMap["output-file"] = &typeid(std::string);
+  TypeMap["periodic"] = &typeid(bool);
+  TypeMap["position"] = &typeid(VectorValue);
+  TypeMap["select-all-atoms"] = &typeid(void);
+  TypeMap["select-all-molecules"] = &typeid(void);
+  TypeMap["select-atom-by-id"] = &typeid(atom);
+  TypeMap["select-molecule-by-id"] = &typeid(molecule);
+  TypeMap["start-step"] = &typeid(int);
+  TypeMap["unselect-all-atoms"] = &typeid(void);
+  TypeMap["unselect-all-molecules"] = &typeid(void);
+  TypeMap["unselect-atom-by-id"] = &typeid(atom);
+  TypeMap["unselect-molecule-by-id"] = &typeid(molecule);
+  TypeEnumMap[&typeid(void)] = None;
+  TypeEnumMap[&typeid(bool)] = Boolean;
+  TypeEnumMap[&typeid(int)] = Integer;
+  TypeEnumMap[&typeid(std::vector<int>)] = ListOfIntegers;
+  TypeEnumMap[&typeid(double)] = Double;
+  TypeEnumMap[&typeid(std::vector<double>)] = ListOfDoubles;
+  TypeEnumMap[&typeid(std::string)] = String;
+  TypeEnumMap[&typeid(std::vector<std::string>)] = ListOfStrings;
+  TypeEnumMap[&typeid(VectorValue)] = Vector;
+  TypeEnumMap[&typeid(std::vector<VectorValue>)] = ListOfVectors;
+  TypeEnumMap[&typeid(BoxValue)] = Box;
+  TypeEnumMap[&typeid(molecule)] = Molecule;
+  TypeEnumMap[&typeid(std::vector<molecule *>)] = ListOfMolecules;
+  TypeEnumMap[&typeid(atom)] = Atom;
+  TypeEnumMap[&typeid(std::vector<atom *>)] = ListOfAtoms;
+  TypeEnumMap[&typeid(element)] = Element;
+  TypeEnumMap[&typeid(std::vector<element *>)] = ListOfElements;
   // default values for any action that needs one (always string!)
+  DefaultValue["bin-width"] = "0.5";
+  DefaultValue["fastparsing"] = "0";
+  DefaultValue["atom-by-id"] = "-1";
+  DefaultValue["molecule-by-id"] = "-1";
+  DefaultValue["periodic"] = "0";
+  CurrentValue["bin-width"] = "0.5";
+  CurrentValue["fastparsing"] = "0";
+  CurrentValue["periodic"] = "0";
   // put action into each menu category
   MenuDescription["analysis"] = pair<std::string,std::string>("Analysis (pair correlation, volume)", "Analysis");
   MenuDescription["atom"] = pair<std::string,std::string>("Edit atoms", "Edit atoms");
   MenuDescription["command"] = pair<std::string,std::string>("Configuration", "Configuration");
+  MenuDescription["atom"] = pair<std::string,std::string>("Edit atoms", "Atoms");
+  MenuDescription["command"] = pair<std::string,std::string>("Configuration", "configuration options");
   MenuDescription["fragmentation"] = pair<std::string,std::string>("Fragmentation", "Fragmentation");
+  MenuDescription["molecule"] = pair<std::string,std::string>("Parse files into system", "Parse files");
+  MenuDescription["parser"] = pair<std::string,std::string>("Edit molecules (load, parse, save)", "Edit molecules");
+  MenuDescription["tesselation"] = pair<std::string,std::string>("Tesselate molecules", "Tesselate molecules");
+  MenuDescription["world"] = pair<std::string,std::string>("Edit world", "Edit world");
+  MenuDescription["molecule"] = pair<std::string,std::string>("Parse files into system", "Molecules");
+  MenuDescription["parser"] = pair<std::string,std::string>("Edit molecules (load, parse, save)", "Input/Output");
+  MenuDescription["selection"] = pair<std::string,std::string>("Select atoms/molecules", "Selection");
+  MenuDescription["tesselation"] = pair<std::string,std::string>("Tesselate molecules", "Tesselation");
+  MenuDescription["world"] = pair<std::string,std::string>("Edit world", "Globals");
   MenuContainsActionMap.insert( pair<std::string, std::string> ("analysis", "molecular-volume") );
   MenuContainsActionMap.insert( pair<std::string, std::string> ("analysis", "pair-correlation") );
+  MenuContainsActionMap.insert( pair<std::string, std::string> ("analysis", "point-correlation") );
+  MenuContainsActionMap.insert( pair<std::string, std::string> ("analysis", "surface-correlation") );
   MenuContainsActionMap.insert( pair<std::string, std::string> ("analysis", "principal-axis-system") );
 …
   MenuContainsActionMap.insert( pair<std::string, std::string> ("parser", "parse-xyz") );
   MenuContainsActionMap.insert( pair<std::string, std::string> ("parser", "SaveXyz") );
+  MenuContainsActionMap.insert( pair<std::string, std::string> ("selection", "select-atom-by-id") );
+  MenuContainsActionMap.insert( pair<std::string, std::string> ("selection", "select-molecule-by-id") );
+  MenuContainsActionMap.insert( pair<std::string, std::string> ("selection", "unselect-atom-by-id") );
+  MenuContainsActionMap.insert( pair<std::string, std::string> ("selection", "unselect-molecule-by-id") );
   MenuContainsActionMap.insert( pair<std::string, std::string> ("tesselation", "convex-envelope") );
 …
         generic.insert("pair-correlation");
         generic.insert("parse-xyz");
+  generic.insert("point-correlation");
 //  generic.insert("principal-axis-system");
   generic.insert("remove-atom");
 …
   generic.insert("save-temperature");
   generic.insert("scale-box");
+  generic.insert("select-all-atoms");
+  generic.insert("select-all-molecules");
+  generic.insert("select-atom-by-id");
+  generic.insert("select-molecule-by-id");
   generic.insert("set-basis");
   generic.insert("set-output");
         generic.insert("subgraph-dissect");
+  generic.insert("surface-correlation");
   generic.insert("suspend-in-water");
   generic.insert("translate-mol");
+  generic.insert("unselect-all-atoms");
+  generic.insert("unselect-all-molecules");
+  generic.insert("unselect-atom-by-id");
+  generic.insert("unselect-molecule-by-id");
         generic.insert("verbose");
   generic.insert("verlet-integrate");
 …
     // positional arguments
   generic.insert("input");
-  inputfile.insert("input");
     // hidden arguments
+  generic.insert("atom-by-id");
+  generic.insert("bin-end");
+  generic.insert("bin-output-file");
+  generic.insert("bin-start");
+  generic.insert("bin-width");
+  generic.insert("convex-file");
+  generic.insert("distance");
+  generic.insert("DoRotate");
+  generic.insert("distances");
+  generic.insert("element");
+  generic.insert("elements");
+  generic.insert("end-step");
+  generic.insert("id-mapping");
+  generic.insert("lengths");
+  generic.insert("MaxDistance");
+  generic.insert("molecule-by-id");
+  generic.insert("molecule-by-name");
+  generic.insert("nonconvex-file");
+  generic.insert("order");
+  generic.insert("output-file");
+  generic.insert("periodic");
+  generic.insert("position");
+  generic.insert("sphere-radius");
+  generic.insert("start-step");
+  hidden.insert("bin-end");
+  hidden.insert("bin-output-file");
+  hidden.insert("bin-start");
+  hidden.insert("bin-width");
+  hidden.insert("convex-file");
+  hidden.insert("distance");
+  hidden.insert("DoRotate");
+  hidden.insert("distances");
+  hidden.insert("element");
+  hidden.insert("elements");
+  hidden.insert("end-step");
+  hidden.insert("id-mapping");
+  hidden.insert("lengths");
+  hidden.insert("MaxDistance");
+  hidden.insert("molecule-by-id");
+  hidden.insert("nonconvex-file");
+  hidden.insert("order");
+  hidden.insert("output-file");
+  hidden.insert("periodic");
+  hidden.insert("position");
+  hidden.insert("start-step");
+}
 …
+}
+void MapOfActions::queryCurrentValue(const char * name, class atom * &_T)
+{
+  int atomID = -1;
+  if (typeid( atom ) == *TypeMap[name]) {
+    if (CurrentValue.find(name) == CurrentValue.end())
+      throw MissingValueException(__FILE__, __LINE__);
+    atomID = lexical_cast<int>(CurrentValue[name].c_str());
+    CurrentValue.erase(name);
+  } else
+    throw IllegalTypeException(__FILE__,__LINE__);
+  _T = World::getInstance().getAtom(AtomById(atomID));
+}
+void MapOfActions::queryCurrentValue(const char * name, class element * &_T)  {
+  int Z = -1;
+  if (typeid( element ) == *TypeMap[name]) {
+    if (CurrentValue.find(name) == CurrentValue.end())
+      throw MissingValueException(__FILE__, __LINE__);
+    Z = lexical_cast<int>(CurrentValue[name].c_str());
+    CurrentValue.erase(name);
+  } else
+    throw IllegalTypeException(__FILE__,__LINE__);
+  _T = World::getInstance().getPeriode()->FindElement(Z);
+}
+void MapOfActions::queryCurrentValue(const char * name, class molecule * &_T) {
+  int molID = -1;
+  if (typeid( molecule ) == *TypeMap[name]) {
+    if (CurrentValue.find(name) == CurrentValue.end())
+      throw MissingValueException(__FILE__, __LINE__);
+    molID = lexical_cast<int>(CurrentValue[name].c_str());
+    CurrentValue.erase(name);
+  } else
+    throw IllegalTypeException(__FILE__,__LINE__);
+  _T = World::getInstance().getMolecule(MoleculeById(molID));
+}
+void MapOfActions::queryCurrentValue(const char * name, class Box &_T) {
+  Matrix M;
+  double tmp;
+  if (typeid( BoxValue ) == *TypeMap[name]) {
+    if (CurrentValue.find(name) == CurrentValue.end())
+      throw MissingValueException(__FILE__, __LINE__);
+    std::istringstream stream(CurrentValue[name]);
+    stream >> tmp;
+    M.set(0,0,tmp);
+    stream >> tmp;
+    M.set(0,1,tmp);
+    M.set(1,0,tmp);
+    stream >> tmp;
+    M.set(0,2,tmp);
+    M.set(2,0,tmp);
+    stream >> tmp;
+    M.set(1,1,tmp);
+    stream >> tmp;
+    M.set(1,2,tmp);
+    M.set(2,1,tmp);
+    stream >> tmp;
+    M.set(2,2,tmp);
+    _T = M;
+    CurrentValue.erase(name);
+  } else
+    throw IllegalTypeException(__FILE__,__LINE__);
+}
+void MapOfActions::queryCurrentValue(const char * name, class Vector &_T) {
+  if (typeid( VectorValue ) == *TypeMap[name]) {
+    std::istringstream stream(CurrentValue[name]);
+    CurrentValue.erase(name);
+    stream >> _T[0];
+    stream >> _T[1];
+    stream >> _T[2];
+  } else
+    throw IllegalTypeException(__FILE__,__LINE__);
+}
+void MapOfActions::queryCurrentValue(const char * name, std::vector<atom *>&_T)
+{
+  int atomID = -1;
+  atom *Walker = NULL;
+  if (typeid( std::vector<atom *> ) == *TypeMap[name]) {
+    if (CurrentValue.find(name) == CurrentValue.end())
+      throw MissingValueException(__FILE__, __LINE__);
+    std::istringstream stream(CurrentValue[name]);
+    CurrentValue.erase(name);
+    while (!stream.fail()) {
+      stream >> atomID >> ws;
+      Walker = World::getInstance().getAtom(AtomById(atomID));
+      if (Walker != NULL)
+        _T.push_back(Walker);
+      atomID = -1;
+      Walker = NULL;
+    }
+  } else
+    throw IllegalTypeException(__FILE__,__LINE__);
+}
+void MapOfActions::queryCurrentValue(const char * name, std::vector<element *>&_T)
+{
+  int Z = -1;
+  element *elemental = NULL;
+  if (typeid( std::vector<element *> ) == *TypeMap[name]) {
+    if (CurrentValue.find(name) == CurrentValue.end())
+      throw MissingValueException(__FILE__, __LINE__);
+    std::istringstream stream(CurrentValue[name]);
+    CurrentValue.erase(name);
+    while (!stream.fail()) {
+      stream >> Z >> ws;
+      elemental = World::getInstance().getPeriode()->FindElement(Z);
+      if (elemental != NULL)
+        _T.push_back(elemental);
+      Z = -1;
+    }
+  } else
+    throw IllegalTypeException(__FILE__,__LINE__);
+}
+void MapOfActions::queryCurrentValue(const char * name, std::vector<molecule *>&_T)
+{
+  int molID = -1;
+  molecule *mol = NULL;
+  if (typeid( std::vector<molecule *> ) == *TypeMap[name]) {
+    if (CurrentValue.find(name) == CurrentValue.end())
+      throw MissingValueException(__FILE__, __LINE__);
+    std::istringstream stream(CurrentValue[name]);
+    CurrentValue.erase(name);
+    while (!stream.fail()) {
+      stream >> molID >> ws;
+      mol = World::getInstance().getMolecule(MoleculeById(molID));
+      if (mol != NULL)
+        _T.push_back(mol);
+      molID = -1;
+      mol = NULL;
+    }
+  } else
+    throw IllegalTypeException(__FILE__,__LINE__);
+}
+void MapOfActions::setCurrentValue(const char * name, class atom * &_T)
+{
+  if (typeid( atom ) == *TypeMap[name]) {
+    std::ostringstream stream;
+    stream << _T->getId();
+    CurrentValue[name] = stream.str();
+  } else
+    throw IllegalTypeException(__FILE__,__LINE__);
+}
+void MapOfActions::setCurrentValue(const char * name, class element * &_T)
+{
+  if (typeid( element ) == *TypeMap[name]) {
+    std::ostringstream stream;
+    stream << _T->Z;
+    CurrentValue[name] = stream.str();
+  } else
+    throw IllegalTypeException(__FILE__,__LINE__);
+}
+void MapOfActions::setCurrentValue(const char * name, class molecule * &_T)
+{
+  if (typeid( molecule ) == *TypeMap[name]) {
+    std::ostringstream stream;
+    stream << _T->getId();
+    CurrentValue[name] = stream.str();
+  } else
+    throw IllegalTypeException(__FILE__,__LINE__);
+}
+void MapOfActions::setCurrentValue(const char * name, class Box &_T)
+{
+  const Matrix &M = _T.getM();
+  if (typeid( BoxValue ) == *TypeMap[name]) {
+    std::ostringstream stream;
+    stream << M.at(0,0) << " ";
+    stream << M.at(0,1) << " ";
+    stream << M.at(0,2) << " ";
+    stream << M.at(1,1) << " ";
+    stream << M.at(1,2) << " ";
+    stream << M.at(2,2) << " ";
+    CurrentValue[name] = stream.str();
+  } else
+    throw IllegalTypeException(__FILE__,__LINE__);
+}
+void MapOfActions::setCurrentValue(const char * name, class Vector &_T)
+{
+  if (typeid( VectorValue ) == *TypeMap[name]){
+    std::ostringstream stream;
+    stream << _T[0] << " ";
+    stream << _T[1] << " ";
+    stream << _T[2] << " ";
+    CurrentValue[name] = stream.str();
+  } else
+    throw IllegalTypeException(__FILE__,__LINE__);
+}
+void MapOfActions::setCurrentValue(const char * name, std::vector<atom *>&_T)
+{
+  if (typeid( std::vector<atom *> ) == *TypeMap[name]) {
+    std::ostringstream stream;
+    for (std::vector<atom *>::iterator iter = _T.begin(); iter != _T.end(); ++iter) {
+      stream << (*iter)->getId() << " ";
+    }
+    CurrentValue[name] = stream.str();
+  } else
+    throw IllegalTypeException(__FILE__,__LINE__);
+}
+void MapOfActions::setCurrentValue(const char * name, std::vector<element *>&_T)
+{
+  if (typeid( std::vector<element *> ) == *TypeMap[name]) {
+    std::ostringstream stream;
+    for (std::vector<element *>::iterator iter = _T.begin(); iter != _T.end(); ++iter) {
+      stream << (*iter)->Z << " ";
+    }
+    CurrentValue[name] = stream.str();
+  } else
+    throw IllegalTypeException(__FILE__,__LINE__);
+}
+void MapOfActions::setCurrentValue(const char * name, std::vector<molecule *>&_T)
+{
+  if (typeid( std::vector<molecule *> ) == *TypeMap[name]) {
+    std::ostringstream stream;
+    for (std::vector<molecule *>::iterator iter = _T.begin(); iter != _T.end(); ++iter) {
+      stream << (*iter)->getId() << " ";
+    }
+    CurrentValue[name] = stream.str();
+  } else
+    throw IllegalTypeException(__FILE__,__LINE__);
+}
 void MapOfActions::populateActions()
 …
   new AnalysisMolecularVolumeAction();
   new AnalysisPairCorrelationAction();
+  new AnalysisPointCorrelationAction();
   new AnalysisPrincipalAxisSystemAction();
+  new AnalysisSurfaceCorrelationAction();
   new AtomAddAction();
 …
   new ParserLoadXyzAction();
   new ParserSaveXyzAction();
+  new SelectionAllAtomsAction();
+  new SelectionAllMoleculesAction();
+  new SelectionAtomByIdAction();
+  new SelectionMoleculeByIdAction();
+  new SelectionNotAllAtomsAction();
+  new SelectionNotAllMoleculesAction();
+  new SelectionNotAtomByIdAction();
+  new SelectionNotMoleculeByIdAction();
   new TesselationConvexEnvelopeAction();
 …
+}
 /** Adds all options to the CommandLineParser.
+ *
 …
     for (set<string>::iterator OptionRunner = ListRunner->first->begin(); OptionRunner != ListRunner->first->end(); ++OptionRunner) {
       if (hasValue(*OptionRunner)) {
         DoLog(0) && (Log() << Verbose(0) << "Adding option " << *OptionRunner << " with type " << TypeMap[*OptionRunner] << " to CommandLineParser." << endl);
            switch((enum OptionTypes) TypeMap[*OptionRunner]) {
+        DoLog(1) && (Log() << Verbose(1) << "Adding option " << *OptionRunner << " with type " << TypeMap[*OptionRunner]->name() << " to CommandLineParser." << endl);
+           switch(TypeEnumMap[TypeMap[*OptionRunner]]) {
           default:
           case None:
 …
             ListRunner->second->add_options()
               (getKeyAndShortForm(*OptionRunner).c_str(),
                   DefaultValue.find(*OptionRunner) != DefaultValue.end() ?
                         po::value< bool >()->default_value(atoi(DefaultValue[*OptionRunner].c_str())) :
+                  CurrentValue.find(*OptionRunner) != CurrentValue.end() ?
+                        po::value< bool >()->default_value(lexical_cast<int>(CurrentValue[*OptionRunner].c_str())) :
                         po::value< bool >(),
                   getDescription(*OptionRunner).c_str())
 …
             ListRunner->second->add_options()
               (getKeyAndShortForm(*OptionRunner).c_str(),
                   po::value<BoxValue>()->multitoken(),
+                  po::value<BoxValue>(),
                   getDescription(*OptionRunner).c_str())
+              ;
 …
             ListRunner->second->add_options()
               (getKeyAndShortForm(*OptionRunner).c_str(),
                   DefaultValue.find(*OptionRunner) != DefaultValue.end() ?
                         po::value< int >()->default_value(atoi(DefaultValue[*OptionRunner].c_str())) :
+                  CurrentValue.find(*OptionRunner) != CurrentValue.end() ?
+                        po::value< int >()->default_value(lexical_cast<int>(CurrentValue[*OptionRunner].c_str())) :
                         po::value< int >(),
                   getDescription(*OptionRunner).c_str())
+              ;
             break;
           case ListOfInts:
+          case ListOfIntegers:
             ListRunner->second->add_options()
               (getKeyAndShortForm(*OptionRunner).c_str(),
 …
             ListRunner->second->add_options()
               (getKeyAndShortForm(*OptionRunner).c_str(),
                   DefaultValue.find(*OptionRunner) != DefaultValue.end() ?
                         po::value< double >()->default_value(atof(DefaultValue[*OptionRunner].c_str())) :
+                  CurrentValue.find(*OptionRunner) != CurrentValue.end() ?
+                        po::value< double >()->default_value(lexical_cast<double>(CurrentValue[*OptionRunner].c_str())) :
                         po::value< double >(),
                   getDescription(*OptionRunner).c_str())
 …
             ListRunner->second->add_options()
               (getKeyAndShortForm(*OptionRunner).c_str(),
                   DefaultValue.find(*OptionRunner) != DefaultValue.end() ?
                         po::value< std::string >()->default_value(DefaultValue[*OptionRunner]) :
+                  CurrentValue.find(*OptionRunner) != CurrentValue.end() ?
+                        po::value< std::string >()->default_value(CurrentValue[*OptionRunner]) :
                         po::value< std::string >(),
                   getDescription(*OptionRunner).c_str())
+              ;
             break;
           case ListOfString:
+          case ListOfStrings:
             ListRunner->second->add_options()
               (getKeyAndShortForm(*OptionRunner).c_str(),
 …
+              ;
             break;
+          case Axis:
+            ListRunner->second->add_options()
+              (getKeyAndShortForm(*OptionRunner).c_str(),
+                  DefaultValue.find(*OptionRunner) != DefaultValue.end() ?
+                        po::value< int >()->default_value(atoi(DefaultValue[*OptionRunner].c_str())) :
+          case Vector:
+            ListRunner->second->add_options()
+              (getKeyAndShortForm(*OptionRunner).c_str(),
+                  po::value<VectorValue>(),
+                  getDescription(*OptionRunner).c_str())
+              ;
+            break;
+          case ListOfVectors:
+            ListRunner->second->add_options()
+              (getKeyAndShortForm(*OptionRunner).c_str(),
+                  po::value< vector<VectorValue> >()->multitoken(),
+                  getDescription(*OptionRunner).c_str())
+              ;
+            break;
+          case Molecule:
+            ListRunner->second->add_options()
+              (getKeyAndShortForm(*OptionRunner).c_str(),
+                  CurrentValue.find(*OptionRunner) != CurrentValue.end() ?
+                        po::value< int >()->default_value(lexical_cast<int>(CurrentValue[*OptionRunner].c_str())) :
                         po::value< int >(),
                   getDescription(*OptionRunner).c_str())
+              ;
             break;
           case Vector:
             ListRunner->second->add_options()
               (getKeyAndShortForm(*OptionRunner).c_str(),
                   po::value<VectorValue>(),
                   getDescription(*OptionRunner).c_str())
+              ;
             break;
           case Molecule:
             ListRunner->second->add_options()
               (getKeyAndShortForm(*OptionRunner).c_str(),
                   DefaultValue.find(*OptionRunner) != DefaultValue.end() ?
                         po::value< int >()->default_value(atoi(DefaultValue[*OptionRunner].c_str())) :
+          case ListOfMolecules:
+            ListRunner->second->add_options()
+              (getKeyAndShortForm(*OptionRunner).c_str(),
+                  po::value< vector<int> >()->multitoken(),
+                  getDescription(*OptionRunner).c_str())
+              ;
+            break;
+          case Atom:
+            ListRunner->second->add_options()
+              (getKeyAndShortForm(*OptionRunner).c_str(),
+                  CurrentValue.find(*OptionRunner) != CurrentValue.end() ?
+                        po::value< int >()->default_value(lexical_cast<int>(CurrentValue[*OptionRunner].c_str())) :
                         po::value< int >(),
                   getDescription(*OptionRunner).c_str())
+              ;
             break;
           case ListOfMolecules:
+          case ListOfAtoms:
             ListRunner->second->add_options()
               (getKeyAndShortForm(*OptionRunner).c_str(),
 …
+              ;
             break;
-          case Atom:
-            ListRunner->second->add_options()
-              (getKeyAndShortForm(*OptionRunner).c_str(),
-                  DefaultValue.find(*OptionRunner) != DefaultValue.end() ?
-                        po::value< int >()->default_value(atoi(DefaultValue[*OptionRunner].c_str())) :
-                        po::value< int >(),
-                  getDescription(*OptionRunner).c_str())
+              ;
-            break;
-          case ListOfAtoms:
-            ListRunner->second->add_options()
-              (getKeyAndShortForm(*OptionRunner).c_str(),
-                  po::value< vector<int> >()->multitoken(),
-                  getDescription(*OptionRunner).c_str())
+              ;
-            break;
           case Element:
             ListRunner->second->add_options()
               (getKeyAndShortForm(*OptionRunner).c_str(),
                   po::value< vector<int> >(),
+                  po::value< int >(),
                   getDescription(*OptionRunner).c_str())
+              ;
 …
+        }
       } else {
         DoLog(0) && (Log() << Verbose(0) << "Adding option " << *OptionRunner << " to CommandLineParser." << endl);
+        DoLog(3) && (Log() << Verbose(3) << "Adding option " << *OptionRunner << " to CommandLineParser." << endl);
         ListRunner->second->add_options()
           (getKeyAndShortForm(*OptionRunner).c_str(), getDescription(*OptionRunner).c_str())
 …
+    }
+  }
-  // add positional arguments
-  for (set<string>::iterator OptionRunner = inputfile.begin(); OptionRunner != inputfile.end(); ++OptionRunner) {
-    DoLog(0) && (Log() << Verbose(0) << "Adding option " << *OptionRunner << " to positional CommandLineParser." << endl);
-    CommandLineParser::getInstance().inputfile.add((*OptionRunner).c_str(), -1);
+  }
-  cout << "Name for position 1: " << CommandLineParser::getInstance().inputfile.name_for_position(1) << endl;
+}
 …
  * \return type of the action
  */
 enum MapOfActions::OptionTypes MapOfActions::getValueType(string actionname)
+{
   return TypeMap[actionname];
+std::string MapOfActions::getValueType(string actionname)
+{
+  return TypeMap[actionname]->name();
+}

src/Actions/MapOfActions.hpp

-              r7067bd6
+              r677e13
 #define MAPOFACTIONS_HPP_
-#include "Helpers/Assert.hpp"
 #include <boost/program_options.hpp>
 #include <map>
 #include <set>
+#include <vector>
+#include <typeinfo>
+#include "Exceptions/IllegalTypeException.hpp"
+#include "Exceptions/MissingValueException.hpp"
+#include "Helpers/Assert.hpp"
+#include "Patterns/Singleton.hpp"
 class MapOfActionsTest;
+#include "Patterns/Singleton.hpp"
+class Box;
+class atom;
+class element;
+class molecule;
+class Vector;
 namespace po = boost::program_options;
+using boost::lexical_cast;
 /** Central class for adding functionality to the code.
 …
   friend class MapOfActionsTest;
 public:
   enum OptionTypes { None, Boolean, Integer, ListOfInts, Double, ListOfDoubles, String, ListOfString, Axis, Vector, Box, Molecule, ListOfMolecules, Atom, ListOfAtoms, Element, ListOfElements };
+  enum OptionTypes { None, Boolean, Integer, ListOfIntegers, Double, ListOfDoubles, String, ListOfStrings, Vector, ListOfVectors, Box, Molecule, ListOfMolecules, Atom, ListOfAtoms, Element, ListOfElements };
   // getter for the action descriptions and short forms
 …
   bool hasValue(std::string actionname);
   bool isShortFormPresent(std::string shortform);
   enum OptionTypes getValueType(std::string actionname);
+  std::string  getValueType(std::string actionname);
   std::set<std::string> generic;
 …
   void populateActions();
+  void queryCurrentValue(const char * name, class atom * &_T);
+  void queryCurrentValue(const char * name, class element * &_T);
+  void queryCurrentValue(const char * name, class molecule * &_T);
+  void queryCurrentValue(const char * name, class Box &_T);
+  void queryCurrentValue(const char * name, class Vector &_T);
+  void queryCurrentValue(const char * name, std::vector<atom *>&_T);
+  void queryCurrentValue(const char * name, std::vector<element *>&_T);
+  void queryCurrentValue(const char * name, std::vector<molecule *>&_T);
+  template<typename T> void queryCurrentValue(const char * name, T &_T)
+  {
+    if (typeid( T ) == *TypeMap[name]) { // constructor of type_info is private, hence can only store by ref or ptr
+      if (CurrentValue.find(name) == CurrentValue.end())
+        throw MissingValueException(__FILE__, __LINE__);
+      _T = lexical_cast<T>(CurrentValue[name].c_str());
+      CurrentValue.erase(name);
+    } else
+      throw IllegalTypeException(__FILE__,__LINE__);
+  }
+  template<typename T> void queryCurrentValue(const char * name, std::vector<T> &_T)
+  {
+    T temp;
+    if (typeid( std::vector<T> ) == *TypeMap[name]) { // constructor of type_info is private, hence can only store by ref or ptr
+      if (CurrentValue.find(name) == CurrentValue.end())
+        throw MissingValueException(__FILE__, __LINE__);
+      std::istringstream stream(CurrentValue[name]);
+      CurrentValue.erase(name);
+      while (!stream.fail()) {
+        stream >> temp >> std::ws;
+        _T.push_back(temp);
+      }
+    } else
+      throw IllegalTypeException(__FILE__,__LINE__);
+  }
+  void setCurrentValue(const char * name, class atom * &_T);
+  void setCurrentValue(const char * name, class element * &_T);
+  void setCurrentValue(const char * name, class molecule * &_T);
+  void setCurrentValue(const char * name, class Box &_T);
+  void setCurrentValue(const char * name, class Vector &_T);
+  void setCurrentValue(const char * name, std::vector<atom *>&_T);
+  void setCurrentValue(const char * name, std::vector<element *>&_T);
+  void setCurrentValue(const char * name, std::vector<molecule *>&_T);
+  template<class T> void setCurrentValue(const char * name, T &_T)
+  {
+    std::ostringstream stream;
+    if (typeid( T ) == *TypeMap[name]) {  // constructor of type_info is private, hence can only store by ref or ptr
+      stream << _T;
+      CurrentValue[name] = stream.str();
+    } else
+      throw IllegalTypeException(__FILE__,__LINE__);
+  }
+  template<class T> void setCurrentValue(const char * name, std::vector<T> &_T)
+  {
+    std::ostringstream stream;
+    if (typeid( std::vector<T> ) == *TypeMap[name]) {  // constructor of type_info is private, hence can only store by ref or ptr
+      std::ostringstream stream;
+      for (typename std::vector<T>::iterator iter = _T.begin(); iter != _T.end(); ++iter) {
+        stream << (*iter) << " ";
+      }
+      CurrentValue[name] = stream.str();
+    } else
+      throw IllegalTypeException(__FILE__,__LINE__);
+  }
 private:
   // private constructor and destructor
 …
   // map of the action names and their description
   std::map<std::string, std::string> DefaultValue;
+  std::map<std::string, std::string> CurrentValue;
   std::map<std::string, std::string> DescriptionMap;
   std::map<std::string, std::string> ShortFormMap;
+  std::map<std::string, enum OptionTypes > TypeMap;
+  std::map<std::string, const std::type_info * > TypeMap;
+  std::map<const std::type_info *, enum OptionTypes > TypeEnumMap;
 };

src/Actions/MethodAction.cpp

-              r7067bd6
+              r677e13
 {}
+Dialog* MethodAction::createDialog() {
+  return NULL;
+}
 Action::state_ptr MethodAction::performCall() {

src/Actions/MethodAction.hpp

r7067bd6	r677e13
26	26
27	27	private:
	28	virtual Dialog * createDialog();
28	29	virtual Action::state_ptr performCall();
29	30	virtual Action::state_ptr performUndo(Action::state_ptr);

src/Actions/MoleculeAction/BondFileAction.cpp

-              r7067bd6
+              r677e13
 #include "Actions/MoleculeAction/BondFileAction.hpp"
+#include "Actions/ActionRegistry.hpp"
+#include "log.hpp"
+#include "molecule.hpp"
+#include "verbose.hpp"
+#include "World.hpp"
 #include <iostream>
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
 #include "Actions/MapOfActions.hpp"
+#include "UIElements/ValueStorage.hpp"
-#include "atom.hpp"
-#include "bondgraph.hpp"
-#include "config.hpp"
-#include "defs.hpp"
-#include "verbose.hpp"
-#include "log.hpp"
-#include "molecule.hpp"
-#include "vector.hpp"
-#include "World.hpp"
 /****** MoleculeBondFileAction *****/
 …
 {}
+void MoleculeBondFile(std::string &bondfile) {
+  ValueStorage::getInstance().setCurrentValue(MoleculeBondFileAction::NAME, bondfile);
+  ActionRegistry::getInstance().getActionByName(MoleculeBondFileAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* MoleculeBondFileAction::createDialog() {
+  Dialog *dialog = UIFactory::getInstance().makeDialog();
+  dialog->queryString(NAME, MapOfActions::getInstance().getDescription(NAME));
+  return dialog;
+}
 Action::state_ptr MoleculeBondFileAction::performCall() {
   string filename;
-  Dialog *dialog = UIFactory::getInstance().makeDialog();
   molecule *mol = NULL;
+  dialog->queryString(NAME, &filename, MapOfActions::getInstance().getDescription(NAME));
+  dialog->queryMolecule("molecule-by-id", &mol, MapOfActions::getInstance().getDescription("molecule-by-id"));
+  ValueStorage::getInstance().queryCurrentValue(NAME, filename);
+  if(dialog->display()) {
+  if(World::getInstance().countSelectedMolecules() == 1) {
+    mol = World::getInstance().beginMoleculeSelection()->second;
     DoLog(0) && (Log() << Verbose(0) << "Parsing bonds from " << filename << "." << endl);
     ifstream input(filename.c_str());
     mol->CreateAdjacencyListFromDbondFile(&input);
     input.close();
-    delete dialog;
     return Action::success;
+  }
+  delete dialog;
+  return Action::failure;
+  } else
+    return Action::failure;
+}

src/Actions/MoleculeAction/BondFileAction.hpp

-              r7067bd6
+              r677e13
 class MoleculeListClass;
+void MoleculeBondFile(std::string &bondfile);
 class MoleculeBondFileAction : public Action {
+  friend void MoleculeBondFile(std::string &bondfile);
 public:
   MoleculeBondFileAction();
 …
   virtual const std::string getName();
 private:
+  virtual Dialog * createDialog();
   virtual Action::state_ptr performCall();
   virtual Action::state_ptr performUndo(Action::state_ptr);

src/Actions/MoleculeAction/ChangeNameAction.cpp

-              r7067bd6
+              r677e13
 #include "Actions/MoleculeAction/ChangeNameAction.hpp"
+#include "Actions/ActionRegistry.hpp"
+#include "atom.hpp"
+#include "molecule.hpp"
 #include <iostream>
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
+#include "Actions/MapOfActions.hpp"
+#include "atom.hpp"
+#include "molecule.hpp"
+#include "UIElements/ValueStorage.hpp"
 /****** MoleculeChangeNameAction *****/
 …
 {}
+void MoleculeChangeName(std::string &name) {
+  ValueStorage::getInstance().setCurrentValue(MoleculeChangeNameAction::NAME, name);
+  ActionRegistry::getInstance().getActionByName(MoleculeChangeNameAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* MoleculeChangeNameAction::createDialog() {
+  Dialog *dialog = UIFactory::getInstance().makeDialog();
+  dialog->queryString(NAME, ValueStorage::getInstance().getDescription(NAME));
+  return dialog;
+}
 Action::state_ptr MoleculeChangeNameAction::performCall() {
   string filename;
   molecule *mol = NULL;
-  Dialog *dialog = UIFactory::getInstance().makeDialog();
+  dialog->queryMolecule(NAME, &mol, MapOfActions::getInstance().getDescription(NAME));
+  dialog->queryString("Enter name: ",&filename);
+  ValueStorage::getInstance().queryCurrentValue(NAME, filename);
+  if(dialog->display()) {
+  if (World::getInstance().countSelectedMolecules() == 1) {
+    mol = World::getInstance().beginMoleculeSelection()->second;
     string oldName = mol->getName();
     mol->setName(filename);
-    delete dialog;
     return Action::state_ptr(new MoleculeChangeNameState(mol,oldName));
+  }
+  delete dialog;
+  return Action::failure;
+  } else
+    return Action::failure;
+}

src/Actions/MoleculeAction/ChangeNameAction.hpp

-              r7067bd6
+              r677e13
 class MoleculeListClass;
+void MoleculeChangeName(std::string &name);
 class MoleculeChangeNameAction : public Action {
+  friend void MoleculeChangeName(std::string &name);
 public:
   MoleculeChangeNameAction();
 …
   virtual const std::string getName();
 private:
+  virtual Dialog * createDialog();
   virtual Action::state_ptr performCall();
   virtual Action::state_ptr performUndo(Action::state_ptr);

src/Actions/MoleculeAction/FillWithMoleculeAction.cpp

-              r7067bd6
+              r677e13
 #include "Actions/MoleculeAction/FillWithMoleculeAction.hpp"
+#include "Actions/ActionRegistry.hpp"
+#include "atom.hpp"
+#include "bondgraph.hpp"
+#include "boundary.hpp"
+#include "config.hpp"
+#include "molecule.hpp"
+#include "verbose.hpp"
+#include "World.hpp"
 #include <iostream>
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
+#include "Actions/MapOfActions.hpp"
+#include "atom.hpp"
+#include "bondgraph.hpp"
+#include "boundary.hpp"
+#include "config.hpp"
+#include "defs.hpp"
+#include "molecule.hpp"
+#include "periodentafel.hpp"
+#include "vector.hpp"
+#include "verbose.hpp"
+#include "World.hpp"
+#include "UIElements/ValueStorage.hpp"
 /****** MoleculeFillWithMoleculeAction *****/
 …
 {}
+void MoleculeFillWithMolecule(std::string &fillername, Vector &distances, Vector &lengths, double MaxDistance, bool DoRotate) {
+  ValueStorage::getInstance().setCurrentValue(MoleculeFillWithMoleculeAction::NAME, fillername);
+  ValueStorage::getInstance().setCurrentValue("distances", distances);
+  ValueStorage::getInstance().setCurrentValue("lengths", lengths);
+  ValueStorage::getInstance().setCurrentValue("DoRotate", MaxDistance);
+  ValueStorage::getInstance().setCurrentValue("MaxDistance", DoRotate);
+  ActionRegistry::getInstance().getActionByName(MoleculeFillWithMoleculeAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* MoleculeFillWithMoleculeAction::createDialog() {
+  Dialog *dialog = UIFactory::getInstance().makeDialog();
+  dialog->queryString(NAME, ValueStorage::getInstance().getDescription(NAME));
+  dialog->queryVector("distances", false, ValueStorage::getInstance().getDescription("distances"));
+  dialog->queryVector("lengths", false, ValueStorage::getInstance().getDescription("lengths"));
+  dialog->queryBoolean("DoRotate", ValueStorage::getInstance().getDescription("DoRotate"));
+  dialog->queryDouble("MaxDistance", ValueStorage::getInstance().getDescription("MaxDistance"));
+  return dialog;
+}
 Action::state_ptr MoleculeFillWithMoleculeAction::performCall() {
   string filename;
-  Dialog *dialog = UIFactory::getInstance().makeDialog();
   Vector distances;
   Vector lengths;
 …
   bool DoRotate = false;
   dialog->queryString(NAME, &filename, MapOfActions::getInstance().getDescription(NAME));
   dialog->queryVector("distances", &distances, false, MapOfActions::getInstance().getDescription("distances"));
   dialog->queryVector("lengths", &lengths, false, MapOfActions::getInstance().getDescription("lengths"));
   dialog->queryBoolean("DoRotate", &DoRotate, MapOfActions::getInstance().getDescription("DoRotate"));
   dialog->queryDouble("MaxDistance", &MaxDistance, MapOfActions::getInstance().getDescription("MaxDistance"));
+  ValueStorage::getInstance().queryCurrentValue(NAME, filename);
+  ValueStorage::getInstance().queryCurrentValue("distances", distances);
+  ValueStorage::getInstance().queryCurrentValue("lengths", lengths);
+  ValueStorage::getInstance().queryCurrentValue("DoRotate", DoRotate);
+  ValueStorage::getInstance().queryCurrentValue("MaxDistance", MaxDistance);
+  if(dialog->display()) {
+    DoLog(1) && (Log() << Verbose(1) << "Filling Box with water molecules, lengths(" << lengths[0] << "," << lengths[1] << "," << lengths[2] << "), distances (" << distances[0] << "," << distances[1] << "," << distances[2] << "), MaxDistance " << MaxDistance << ", DoRotate " << DoRotate << "." << endl);
+    // construct water molecule
+    molecule *filler = World::getInstance().createMolecule();
+    if (!filler->AddXYZFile(filename)) {
+      DoeLog(0) && (eLog()<< Verbose(0) << "Could not parse filler molecule from " << filename << "." << endl);
+    }
+    filler->SetNameFromFilename(filename.c_str());
+    molecule *Filling = NULL;
+  DoLog(1) && (Log() << Verbose(1) << "Filling Box with water molecules, lengths(" << lengths[0] << "," << lengths[1] << "," << lengths[2] << "), distances (" << distances[0] << "," << distances[1] << "," << distances[2] << "), MaxDistance " << MaxDistance << ", DoRotate " << DoRotate << "." << endl);
+  // construct water molecule
+  molecule *filler = World::getInstance().createMolecule();
+  if (!filler->AddXYZFile(filename)) {
+    DoeLog(0) && (eLog()<< Verbose(0) << "Could not parse filler molecule from " << filename << "." << endl);
+  }
+  filler->SetNameFromFilename(filename.c_str());
+  molecule *Filling = NULL;
 //    atom *first = NULL, *second = NULL, *third = NULL;
 //    first = World::getInstance().createAtom();
 …
 //    filler->AddBond(first, third, 1);
 //    filler->AddBond(second, third, 1);
     World::getInstance().getConfig()->BG->ConstructBondGraph(filler);
+  World::getInstance().getConfig()->BG->ConstructBondGraph(filler);
 //    filler->SetNameFromFilename("water");
     // call routine
     double distance[NDIM];
     for (int i=0;i<NDIM;i++)
       distance[i] = distances[i];
     Filling = FillBoxWithMolecule(World::getInstance().getMolecules(), filler, *(World::getInstance().getConfig()), MaxDistance, distance, lengths[0], lengths[1], lengths[2], DoRotate);
     if (Filling != NULL) {
       Filling->ActiveFlag = false;
       World::getInstance().getMolecules()->insert(Filling);
+    }
     for (molecule::iterator iter = filler->begin(); !filler->empty(); iter = filler->begin()) {
       atom *Walker = *iter;
       filler->erase(iter);
       World::getInstance().destroyAtom(Walker);
+    }
     World::getInstance().destroyMolecule(filler);
+  // call routine
+  double distance[NDIM];
+  for (int i=0;i<NDIM;i++)
+    distance[i] = distances[i];
+  Filling = FillBoxWithMolecule(World::getInstance().getMolecules(), filler, *(World::getInstance().getConfig()), MaxDistance, distance, lengths[0], lengths[1], lengths[2], DoRotate);
+  if (Filling != NULL) {
+    Filling->ActiveFlag = false;
+    World::getInstance().getMolecules()->insert(Filling);
+  }
+  for (molecule::iterator iter = filler->begin(); !filler->empty(); iter = filler->begin()) {
+    atom *Walker = *iter;
+    filler->erase(iter);
+    World::getInstance().destroyAtom(Walker);
+  }
+  World::getInstance().destroyMolecule(filler);
+    delete dialog;
+    return Action::success;
+  }
+  delete dialog;
+  return Action::failure;
+  return Action::success;
+}

src/Actions/MoleculeAction/FillWithMoleculeAction.hpp

-              r7067bd6
+              r677e13
 #include "Actions/Action.hpp"
 #include "Actions/Process.hpp"
+#include "vector.hpp"
 class MoleculeListClass;
+void MoleculeFillWithMolecule(std::string &fillername, Vector &distances, Vector &lengths, double MaxDistance, bool DoRotate);
 class MoleculeFillWithMoleculeAction : public Action {
+  friend void MoleculeFillWithMolecule(std::string &fillername, Vector &distances, Vector &lengths, double MaxDistance, bool DoRotate);
 public:
   MoleculeFillWithMoleculeAction();
 …
   virtual const std::string getName();
 private:
+  virtual Dialog * createDialog();
   virtual Action::state_ptr performCall();
   virtual Action::state_ptr performUndo(Action::state_ptr);

src/Actions/MoleculeAction/LinearInterpolationofTrajectoriesAction.cpp

-              r7067bd6
+              r677e13
 #include "Actions/MoleculeAction/LinearInterpolationofTrajectoriesAction.hpp"
+#include "Actions/ActionRegistry.hpp"
+#include "atom.hpp"
+#include "defs.hpp"
+#include "log.hpp"
+#include "molecule.hpp"
+#include "verbose.hpp"
+#include "World.hpp"
 #include <iostream>
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
 #include "Actions/MapOfActions.hpp"
+#include "UIElements/ValueStorage.hpp"
-#include "atom.hpp"
-#include "defs.hpp"
-#include "log.hpp"
-#include "molecule.hpp"
-#include "verbose.hpp"
-#include "World.hpp"
 /****** MoleculeLinearInterpolationofTrajectoriesAction *****/
 …
 {}
+void MoleculeLinearInterpolationofTrajectories(std::string &filename, int start, int end, bool IdMapping) {
+  ValueStorage::getInstance().setCurrentValue(MoleculeLinearInterpolationofTrajectoriesAction::NAME, filename);
+  ValueStorage::getInstance().setCurrentValue("start-step", start);
+  ValueStorage::getInstance().setCurrentValue("end-step", end);
+  ValueStorage::getInstance().setCurrentValue("id-mapping", IdMapping);
+  ActionRegistry::getInstance().getActionByName(MoleculeLinearInterpolationofTrajectoriesAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* MoleculeLinearInterpolationofTrajectoriesAction::createDialog() {
+  Dialog *dialog = UIFactory::getInstance().makeDialog();
+  dialog->queryString(NAME, MapOfActions::getInstance().getDescription(NAME));
+  dialog->queryInt("start-step", MapOfActions::getInstance().getDescription("start-step"));
+  dialog->queryInt("end-step", MapOfActions::getInstance().getDescription("end-step"));
+  dialog->queryBoolean("id-mapping", MapOfActions::getInstance().getDescription("id-mapping"));
+  return dialog;
+}
 Action::state_ptr MoleculeLinearInterpolationofTrajectoriesAction::performCall() {
   string filename;
-  Dialog *dialog = UIFactory::getInstance().makeDialog();
   molecule *mol = NULL;
   int start = -1;
 …
   bool IdMapping = true;
+  ValueStorage::getInstance().queryCurrentValue(NAME, filename);
+  ValueStorage::getInstance().queryCurrentValue("start-step", start);
+  ValueStorage::getInstance().queryCurrentValue("end-step", end);
+  ValueStorage::getInstance().queryCurrentValue("id-mapping", IdMapping);
+  dialog->queryString(NAME, &filename, MapOfActions::getInstance().getDescription(NAME));
+  dialog->queryInt("start-step", &start, MapOfActions::getInstance().getDescription("start-step"));
+  dialog->queryInt("end-step", &end, MapOfActions::getInstance().getDescription("end-step"));
+  dialog->queryMolecule("molecule-by-id", &mol, MapOfActions::getInstance().getDescription("molecule-by-id"));
+  dialog->queryBoolean("id-mapping", &IdMapping, MapOfActions::getInstance().getDescription("id-mapping"));
+  if(dialog->display()) {
+  for (World::MoleculeSelectionIterator iter = World::getInstance().beginMoleculeSelection(); iter != World::getInstance().endMoleculeSelection(); ++iter) {
+    mol = iter->second;
     DoLog(1) && (Log() << Verbose(1) << "Linear interpolation between configuration " << start << " and " << end << "." << endl);
     if (IdMapping)
 …
     else
       DoLog(2) && (Log() << Verbose(2) << "Steps created and " << filename << " files stored." << endl);
-    delete dialog;
-    return Action::success;
+  }
+  delete dialog;
+  return Action::failure;
+  return Action::success;
+}

src/Actions/MoleculeAction/LinearInterpolationofTrajectoriesAction.hpp

-              r7067bd6
+              r677e13
 class MoleculeListClass;
+void MoleculeLinearInterpolationofTrajectories(std::string &filename, int start, int end, bool IdMapping);
 class MoleculeLinearInterpolationofTrajectoriesAction : public Action {
+  friend void MoleculeLinearInterpolationofTrajectories(std::string &filename, int start, int end, bool IdMapping);
 public:
   MoleculeLinearInterpolationofTrajectoriesAction();
 …
   virtual const std::string getName();
 private:
+  virtual Dialog * createDialog();
   virtual Action::state_ptr performCall();
   virtual Action::state_ptr performUndo(Action::state_ptr);

src/Actions/MoleculeAction/RotateToPrincipalAxisSystemAction.cpp

-              r7067bd6
+              r677e13
 #include "Actions/MoleculeAction/RotateToPrincipalAxisSystemAction.hpp"
+#include "Actions/ActionRegistry.hpp"
+#include "log.hpp"
+#include "molecule.hpp"
+#include "verbose.hpp"
 #include <iostream>
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
+#include "Actions/MapOfActions.hpp"
+#include "log.hpp"
+#include "molecule.hpp"
+#include "verbose.hpp"
+#include "UIElements/ValueStorage.hpp"
 /****** MoleculeRotateToPrincipalAxisSystemAction *****/
 …
 {}
+void MoleculeRotateToPrincipalAxisSystem() {
+  ActionRegistry::getInstance().getActionByName(MoleculeRotateToPrincipalAxisSystemAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* MoleculeRotateToPrincipalAxisSystemAction::createDialog() {
+  Dialog *dialog = UIFactory::getInstance().makeDialog();
+  dialog->queryEmpty(NAME, MapOfActions::getInstance().getDescription(NAME));
+  return dialog;
+}
 Action::state_ptr MoleculeRotateToPrincipalAxisSystemAction::performCall() {
-  Dialog *dialog = UIFactory::getInstance().makeDialog();
   molecule *mol = NULL;
+  dialog->queryMolecule(NAME, &mol, MapOfActions::getInstance().getDescription(NAME));
+  if(dialog->display()) {
+  for (World::MoleculeSelectionIterator iter = World::getInstance().beginMoleculeSelection(); iter != World::getInstance().endMoleculeSelection(); ++iter) {
+    mol = iter->second;
     DoLog(0) && (Log() << Verbose(0) << "Converting to prinicipal axis system." << endl);
     mol->PrincipalAxisSystem(true);
-    delete dialog;
-    return Action::success;
+  }
+  delete dialog;
+  return Action::failure;
+  return Action::success;
+}

src/Actions/MoleculeAction/RotateToPrincipalAxisSystemAction.hpp

-              r7067bd6
+              r677e13
 class MoleculeListClass;
+void MoleculeRotateToPrincipalAxisSystem();
 class MoleculeRotateToPrincipalAxisSystemAction : public Action {
+  friend void MoleculeRotateToPrincipalAxisSystem();
 public:
   MoleculeRotateToPrincipalAxisSystemAction();
 …
   virtual const std::string getName();
 private:
+  virtual Dialog * createDialog();
   virtual Action::state_ptr performCall();
   virtual Action::state_ptr performUndo(Action::state_ptr);

src/Actions/MoleculeAction/SaveAdjacencyAction.cpp

-              r7067bd6
+              r677e13
 #include "Actions/MoleculeAction/SaveAdjacencyAction.hpp"
+#include "Actions/ActionRegistry.hpp"
+#include "bondgraph.hpp"
+#include "config.hpp"
+#include "log.hpp"
+#include "molecule.hpp"
+#include "verbose.hpp"
+#include "World.hpp"
 #include <iostream>
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
+#include "Actions/MapOfActions.hpp"
+#include "atom.hpp"
+#include "bondgraph.hpp"
+#include "config.hpp"
+#include "defs.hpp"
+#include "log.hpp"
+#include "molecule.hpp"
+#include "vector.hpp"
+#include "verbose.hpp"
+#include "World.hpp"
+#include "UIElements/ValueStorage.hpp"
 /****** MoleculeSaveAdjacencyAction *****/
 …
 {}
+void MoleculeSaveAdjacency(std::string &adjacencyfile) {
+  ValueStorage::getInstance().setCurrentValue(MoleculeSaveAdjacencyAction::NAME, adjacencyfile);
+  ActionRegistry::getInstance().getActionByName(MoleculeSaveAdjacencyAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* MoleculeSaveAdjacencyAction::createDialog() {
+  Dialog *dialog = UIFactory::getInstance().makeDialog();
+  dialog->queryString(NAME, ValueStorage::getInstance().getDescription(NAME));
+  return dialog;
+}
 Action::state_ptr MoleculeSaveAdjacencyAction::performCall() {
   string filename;
-  Dialog *dialog = UIFactory::getInstance().makeDialog();
   molecule *mol = NULL;
+  dialog->queryString(NAME, &filename, MapOfActions::getInstance().getDescription(NAME));
+  dialog->queryMolecule("molecule-by-id", &mol, MapOfActions::getInstance().getDescription("molecule-by-id"));
+  ValueStorage::getInstance().queryCurrentValue(NAME, filename);
+  if(dialog->display()) {
+  for (World::MoleculeSelectionIterator iter = World::getInstance().beginMoleculeSelection(); iter != World::getInstance().endMoleculeSelection(); ++iter) {
+    mol = iter->second;
     DoLog(0) && (Log() << Verbose(0) << "Storing adjacency to path " << filename << "." << endl);
     World::getInstance().getConfig()->BG->ConstructBondGraph(mol);
     // TODO: sollte stream nicht filename benutzen, besser fuer unit test
     mol->StoreAdjacencyToFile(filename);
-    delete dialog;
-    return Action::success;
+  }
+  delete dialog;
+  return Action::failure;
+  return Action::success;
+}

src/Actions/MoleculeAction/SaveAdjacencyAction.hpp

-              r7067bd6
+              r677e13
 class MoleculeListClass;
+void MoleculeSaveAdjacency(std::string &adjacencyfile);
 class MoleculeSaveAdjacencyAction : public Action {
+  friend void MoleculeSaveAdjacency(std::string &adjacencyfile);
 public:
   MoleculeSaveAdjacencyAction();
 …
   virtual const std::string getName();
 private:
+  virtual Dialog * createDialog();
   virtual Action::state_ptr performCall();
   virtual Action::state_ptr performUndo(Action::state_ptr);

src/Actions/MoleculeAction/SaveBondsAction.cpp

-              r7067bd6
+              r677e13
 #include "Actions/MoleculeAction/SaveBondsAction.hpp"
+#include "Actions/ActionRegistry.hpp"
+#include "bondgraph.hpp"
+#include "config.hpp"
+#include "log.hpp"
+#include "molecule.hpp"
+#include "verbose.hpp"
+#include "World.hpp"
 #include <iostream>
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
+#include "Actions/MapOfActions.hpp"
+#include "atom.hpp"
+#include "bondgraph.hpp"
+#include "config.hpp"
+#include "defs.hpp"
+#include "log.hpp"
+#include "molecule.hpp"
+#include "vector.hpp"
+#include "verbose.hpp"
+#include "World.hpp"
+#include "UIElements/ValueStorage.hpp"
 /****** MoleculeSaveBondsAction *****/
 …
 {}
+void MoleculeSaveBonds(std::string &bondsfile) {
+  ValueStorage::getInstance().setCurrentValue(MoleculeSaveBondsAction::NAME, bondsfile);
+  ActionRegistry::getInstance().getActionByName(MoleculeSaveBondsAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* MoleculeSaveBondsAction::createDialog() {
+  Dialog *dialog = UIFactory::getInstance().makeDialog();
+  dialog->queryString(NAME, ValueStorage::getInstance().getDescription(NAME));
+  return dialog;
+}
 Action::state_ptr MoleculeSaveBondsAction::performCall() {
   string filename;
-  Dialog *dialog = UIFactory::getInstance().makeDialog();
   molecule *mol = NULL;
+  dialog->queryString(NAME, &filename, MapOfActions::getInstance().getDescription(NAME));
+  dialog->queryMolecule("molecule-by-id", &mol, MapOfActions::getInstance().getDescription("molecule-by-id"));
+  ValueStorage::getInstance().queryCurrentValue(NAME, filename);
+  if(dialog->display()) {
+  for (World::MoleculeSelectionIterator iter = World::getInstance().beginMoleculeSelection(); iter != World::getInstance().endMoleculeSelection(); ++iter) {
+    mol = iter->second;
     DoLog(0) && (Log() << Verbose(0) << "Storing bonds to path " << filename << "." << endl);
     World::getInstance().getConfig()->BG->ConstructBondGraph(mol);
     // TODO: sollte stream, nicht filenamen direkt nutzen, besser fuer unit tests
     mol->StoreBondsToFile(filename);
-    delete dialog;
-    return Action::success;
+  }
+  delete dialog;
+  return Action::failure;
+  return Action::success;
+}

src/Actions/MoleculeAction/SaveBondsAction.hpp

-              r7067bd6
+              r677e13
 class MoleculeListClass;
+void MoleculeSaveBonds(std::string &bondsfile);
 class MoleculeSaveBondsAction : public Action {
+  friend void MoleculeSaveBonds(std::string &bondsfile);
 public:
   MoleculeSaveBondsAction();
 …
   virtual const std::string getName();
 private:
+  virtual Dialog * createDialog();
   virtual Action::state_ptr performCall();
   virtual Action::state_ptr performUndo(Action::state_ptr);

src/Actions/MoleculeAction/SaveTemperatureAction.cpp

-              r7067bd6
+              r677e13
 #include "Actions/MoleculeAction/SaveTemperatureAction.hpp"
+#include "Actions/ActionRegistry.hpp"
+#include "log.hpp"
+#include "molecule.hpp"
+#include "verbose.hpp"
+#include "World.hpp"
 #include <iostream>
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
+#include "Actions/MapOfActions.hpp"
+#include "atom.hpp"
+#include "log.hpp"
+#include "molecule.hpp"
+#include "verbose.hpp"
+#include "World.hpp"
+#include "UIElements/ValueStorage.hpp"
 /****** MoleculeSaveTemperatureAction *****/
 …
 {}
+void MoleculeSaveTemperature(std::string &temperaturefile) {
+  ValueStorage::getInstance().setCurrentValue(MoleculeSaveTemperatureAction::NAME, temperaturefile);
+  ActionRegistry::getInstance().getActionByName(MoleculeSaveTemperatureAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* MoleculeSaveTemperatureAction::createDialog() {
+  Dialog *dialog = UIFactory::getInstance().makeDialog();
+  dialog->queryString(NAME, ValueStorage::getInstance().getDescription(NAME));
+  return dialog;
+}
 Action::state_ptr MoleculeSaveTemperatureAction::performCall() {
   string filename;
-  Dialog *dialog = UIFactory::getInstance().makeDialog();
   molecule *mol = NULL;
+  dialog->queryString(NAME, &filename, MapOfActions::getInstance().getDescription(NAME));
+  dialog->queryMolecule("molecule-by-id", &mol, MapOfActions::getInstance().getDescription("molecule-by-id"));
+  ValueStorage::getInstance().queryCurrentValue(NAME, filename);
+  if(dialog->display()) {
+  for (World::MoleculeSelectionIterator iter = World::getInstance().beginMoleculeSelection(); iter != World::getInstance().endMoleculeSelection(); ++iter) {
+    mol = iter->second;
     DoLog(1) && (Log() << Verbose(1) << "Storing temperatures in " << filename << "." << endl);
     ofstream output;
 …
       DoLog(2) && (Log() << Verbose(2) << "File stored." << endl);
     output.close();
-    delete dialog;
-    return Action::success;
+  }
+  delete dialog;
+  return Action::failure;
+  return Action::success;
+}

src/Actions/MoleculeAction/SaveTemperatureAction.hpp

-              r7067bd6
+              r677e13
 class MoleculeListClass;
+void MoleculeSaveTemperature(std::string &temperaturefile);
 class MoleculeSaveTemperatureAction : public Action {
+  friend void MoleculeSaveTemperature(std::string &temperaturefile);
 public:
   MoleculeSaveTemperatureAction();
 …
   virtual const std::string getName();
 private:
+  virtual Dialog * createDialog();
   virtual Action::state_ptr performCall();
   virtual Action::state_ptr performUndo(Action::state_ptr);

src/Actions/MoleculeAction/SuspendInWaterAction.cpp

-              r7067bd6
+              r677e13
 #include "Actions/MoleculeAction/SuspendInWaterAction.hpp"
+#include "Actions/ActionRegistry.hpp"
+#include "boundary.hpp"
+#include "config.hpp"
+#include "log.hpp"
+#include "verbose.hpp"
+#include "World.hpp"
 #include <iostream>
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
+#include "Actions/MapOfActions.hpp"
+#include "atom.hpp"
+#include "boundary.hpp"
+#include "config.hpp"
+#include "verbose.hpp"
+#include "log.hpp"
+#include "config.hpp"
+#include "World.hpp"
+#include "UIElements/ValueStorage.hpp"
 /****** MoleculeSuspendInWaterAction *****/
 …
 {}
+void MoleculeSuspendInWater(double density) {
+  ValueStorage::getInstance().setCurrentValue(MoleculeSuspendInWaterAction::NAME, density);
+  ActionRegistry::getInstance().getActionByName(MoleculeSuspendInWaterAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* MoleculeSuspendInWaterAction::createDialog() {
+  Dialog *dialog = UIFactory::getInstance().makeDialog();
+  dialog->queryDouble(NAME, ValueStorage::getInstance().getDescription(NAME));
+  return dialog;
+}
 Action::state_ptr MoleculeSuspendInWaterAction::performCall() {
   molecule *mol = NULL;
-  Dialog *dialog = UIFactory::getInstance().makeDialog();
   double density;
   double volume = 0.;
+  dialog->queryDouble(NAME, &density, MapOfActions::getInstance().getDescription(NAME));
+  dialog->queryMolecule("molecule-by-id", &mol, MapOfActions::getInstance().getDescription("molecule-by-id"));
+  ValueStorage::getInstance().queryCurrentValue(NAME, density);
+  if(dialog->display()) {
+  for (World::MoleculeSelectionIterator iter = World::getInstance().beginMoleculeSelection(); iter != World::getInstance().endMoleculeSelection(); ++iter) {
+    mol = iter->second;
     DoLog(0) && (Log() << Verbose(0) << "Evaluating necessary cell volume for a cluster suspended in water.");
     if (density < 1.0) {
 …
     } else {
       PrepareClustersinWater(World::getInstance().getConfig(), mol, volume, density);  // if volume == 0, will calculate from ConvexEnvelope
-      delete dialog;
-      return Action::success;
+    }
+  }
+  delete dialog;
+  return Action::failure;
+  return Action::success;
+}

src/Actions/MoleculeAction/SuspendInWaterAction.hpp

-              r7067bd6
+              r677e13
 class MoleculeListClass;
+void MoleculeSuspendInWater(double density);
 class MoleculeSuspendInWaterAction : public Action {
+  friend void MoleculeSuspendInWater(double density);
 public:
   MoleculeSuspendInWaterAction();
 …
   virtual const std::string getName();
 private:
+  virtual Dialog * createDialog();
   virtual Action::state_ptr performCall();
   virtual Action::state_ptr performUndo(Action::state_ptr);

src/Actions/MoleculeAction/TranslateAction.cpp

-              r7067bd6
+              r677e13
 #include "Actions/MoleculeAction/TranslateAction.hpp"
+#include "Actions/ActionRegistry.hpp"
+#include "log.hpp"
+#include "molecule.hpp"
+#include "vector.hpp"
+#include "verbose.hpp"
+#include "World.hpp"
 #include <iostream>
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
+#include "Actions/MapOfActions.hpp"
+#include "atom.hpp"
+#include "log.hpp"
+#include "molecule.hpp"
+#include "verbose.hpp"
+#include "World.hpp"
+#include "UIElements/ValueStorage.hpp"
 /****** MoleculeTranslateAction *****/
 …
 {}
+void MoleculeTranslate(Vector &x, bool periodic) {
+  ValueStorage::getInstance().setCurrentValue(MoleculeTranslateAction::NAME, x);
+  ValueStorage::getInstance().setCurrentValue("periodic", periodic);
+  ActionRegistry::getInstance().getActionByName(MoleculeTranslateAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* MoleculeTranslateAction::createDialog() {
+  Dialog *dialog = UIFactory::getInstance().makeDialog();
+  dialog->queryVector(NAME, false, ValueStorage::getInstance().getDescription(NAME));
+  dialog->queryBoolean("periodic", ValueStorage::getInstance().getDescription("periodic"));
+  return dialog;
+}
 Action::state_ptr MoleculeTranslateAction::performCall() {
-  Dialog *dialog = UIFactory::getInstance().makeDialog();
   molecule *mol = NULL;
   Vector x;
   bool periodic = false;
+  dialog->queryVector(NAME, &x, false, MapOfActions::getInstance().getDescription(NAME));
+  dialog->queryMolecule("molecule-by-id", &mol, MapOfActions::getInstance().getDescription("molecule-by-id"));
+  dialog->queryBoolean("periodic", &periodic, MapOfActions::getInstance().getDescription("periodic"));
+  cout << "pre-dialog" << endl;
+  ValueStorage::getInstance().queryCurrentValue(NAME, x);
+  ValueStorage::getInstance().queryCurrentValue("periodic", periodic);
   if(dialog->display()) {
     cout << "post-dialog" << endl;
+  for (World::MoleculeSelectionIterator iter = World::getInstance().beginMoleculeSelection(); iter != World::getInstance().endMoleculeSelection(); ++iter) {
+    mol = iter->second;
     DoLog(1) && (Log() << Verbose(1) << "Translating all ions by given vector." << endl);
     if (periodic)
 …
     else
       mol->Translate((const Vector *)&x);
-    delete dialog;
-    return Action::success;
+  }
+  delete dialog;
+  return Action::failure;
+  return Action::success;
+}

src/Actions/MoleculeAction/TranslateAction.hpp

-              r7067bd6
+              r677e13
 #include "Actions/Action.hpp"
 #include "Actions/Process.hpp"
+#include "vector.hpp"
 class MoleculeListClass;
+void MoleculeTranslate(Vector &x, bool periodic);
 class MoleculeTranslateAction : public Action {
+  friend void MoleculeTranslate(Vector &x, bool periodic);
 public:
   MoleculeTranslateAction();
 …
   virtual const std::string getName();
 private:
+  virtual Dialog * createDialog();
   virtual Action::state_ptr performCall();
   virtual Action::state_ptr performUndo(Action::state_ptr);

src/Actions/MoleculeAction/VerletIntegrationAction.cpp

-              r7067bd6
+              r677e13
 #include "Actions/MoleculeAction/VerletIntegrationAction.hpp"
+#include "Actions/ActionRegistry.hpp"
+#include "log.hpp"
+#include "molecule.hpp"
+#include "verbose.hpp"
+#include "World.hpp"
 #include <iostream>
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
+#include "Actions/MapOfActions.hpp"
+#include "atom.hpp"
+#include "log.hpp"
+#include "molecule.hpp"
+#include "verbose.hpp"
+#include "World.hpp"
+#include "UIElements/ValueStorage.hpp"
 /****** MoleculeVerletIntegrationAction *****/
 …
 {}
+void MoleculeVerletIntegration(std::string &forcesfile) {
+  ValueStorage::getInstance().setCurrentValue(MoleculeVerletIntegrationAction::NAME, forcesfile);
+  ActionRegistry::getInstance().getActionByName(MoleculeVerletIntegrationAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* MoleculeVerletIntegrationAction::createDialog() {
+  Dialog *dialog = UIFactory::getInstance().makeDialog();
+  dialog->queryString(NAME, ValueStorage::getInstance().getDescription(NAME));
+  return dialog;
+}
 Action::state_ptr MoleculeVerletIntegrationAction::performCall() {
   string filename;
-  Dialog *dialog = UIFactory::getInstance().makeDialog();
   molecule *mol = NULL;
+  dialog->queryString(NAME, &filename, MapOfActions::getInstance().getDescription(NAME));
+  dialog->queryMolecule("molecule-by-id", &mol, MapOfActions::getInstance().getDescription("molecule-by-id"));
+  ValueStorage::getInstance().queryCurrentValue(NAME, filename);
+  if(dialog->display()) {
+  for (World::MoleculeSelectionIterator iter = World::getInstance().beginMoleculeSelection(); iter != World::getInstance().endMoleculeSelection(); ++iter) {
+    mol = iter->second;
     DoLog(1) && (Log() << Verbose(1) << "Parsing forces file and Verlet integrating." << endl);
     // TODO: sollte besser stream nutzen, nicht filename direkt (es sei denn, ist prefix), besser fuer unit test
 …
     else
       DoLog(2) && (Log() << Verbose(2) << "File found and parsed." << endl);
-    delete dialog;
-    return Action::success;
+  }
+  delete dialog;
+  return Action::failure;
+  return Action::success;
+}

src/Actions/MoleculeAction/VerletIntegrationAction.hpp

-              r7067bd6
+              r677e13
 class MoleculeListClass;
+void MoleculeVerletIntegration(std::string &forcesfile);
 class MoleculeVerletIntegrationAction : public Action {
+  friend void MoleculeVerletIntegration(std::string &forcesfile);
 public:
   MoleculeVerletIntegrationAction();
 …
   virtual const std::string getName();
 private:
+  virtual Dialog * createDialog();
   virtual Action::state_ptr performCall();
   virtual Action::state_ptr performUndo(Action::state_ptr);

src/Actions/ParserAction/LoadXyzAction.cpp

-              r7067bd6
+              r677e13
 #include "Actions/ParserAction/LoadXyzAction.hpp"
+#include "Actions/ActionRegistry.hpp"
 #include "Parser/XyzParser.hpp"
+#include "atom.hpp"
+#include "log.hpp"
+#include "molecule.hpp"
+#include "verbose.hpp"
+#include "World.hpp"
 #include <iostream>
 …
 #include <vector>
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
+#include "Actions/MapOfActions.hpp"
+#include "atom.hpp"
+#include "log.hpp"
+#include "molecule.hpp"
+#include "verbose.hpp"
+#include "World.hpp"
+#include "UIElements/ValueStorage.hpp"
 /****** ParserLoadXyzAction *****/
 …
 {}
+void ParserLoadXyz(std::string &filename) {
+  ValueStorage::getInstance().setCurrentValue(ParserLoadXyzAction::NAME, filename);
+  ActionRegistry::getInstance().getActionByName(ParserLoadXyzAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* ParserLoadXyzAction::createDialog() {
+  Dialog *dialog = UIFactory::getInstance().makeDialog();
+  dialog->queryString(NAME, ValueStorage::getInstance().getDescription(NAME));
+  return dialog;
+}
 Action::state_ptr ParserLoadXyzAction::performCall() {
   string filename;
-  Dialog *dialog = UIFactory::getInstance().makeDialog();
   dialog->queryString(NAME,&filename, NAME);
+  ValueStorage::getInstance().queryCurrentValue(NAME, filename);
+  if(dialog->display()) {
+    DoLog(1) && (Log() << Verbose(1) << "Parsing xyz file for new atoms." << endl);
+    // parse xyz file
+    ifstream input;
+    input.open(filename.c_str());
+    if (!input.fail()) {
+      // TODO: Remove the insertion into molecule when saving does not depend on them anymore. Also, remove molecule.hpp include
+      set <atom*> UniqueList;
+      {
+        vector<atom *> ListBefore = World::getInstance().getAllAtoms();
+        for (vector<atom *>::iterator runner = ListBefore.begin();runner != ListBefore.end(); ++runner)
+          UniqueList.insert(*runner);
+  DoLog(1) && (Log() << Verbose(1) << "Parsing xyz file for new atoms." << endl);
+  // parse xyz file
+  ifstream input;
+  input.open(filename.c_str());
+  if (!input.fail()) {
+    // TODO: Remove the insertion into molecule when saving does not depend on them anymore. Also, remove molecule.hpp include
+    set <atom*> UniqueList;
+    {
+      vector<atom *> ListBefore = World::getInstance().getAllAtoms();
+      for (vector<atom *>::iterator runner = ListBefore.begin();runner != ListBefore.end(); ++runner)
+        UniqueList.insert(*runner);
+    }
+    XyzParser parser; // briefly instantiate a parser which is removed at end of focus
+    parser.load(&input);
+    {
+      vector<atom *> ListAfter = World::getInstance().getAllAtoms();
+      pair< set<atom *>::iterator, bool > Inserter;
+      if (UniqueList.size() != ListAfter.size()) { // only create if new atoms have been parsed
+        MoleculeListClass *molecules = World::getInstance().getMolecules();
+        molecule *mol = World::getInstance().createMolecule();
+        molecules->insert(mol);
+        for (vector<atom *>::iterator runner = ListAfter.begin(); runner != ListAfter.end(); ++runner) {
+          Inserter = UniqueList.insert(*runner);
+          if (Inserter.second) { // if not present, then new (just parsed) atom, add ...
+            cout << "Adding new atom " << **runner << " to new mol." << endl;
+            mol->AddAtom(*runner);
+          }
+        }
+        mol->doCountAtoms();
+      } else {
+        cout << "No atoms parsed?" << endl;
+      }
-      XyzParser parser; // briefly instantiate a parser which is removed at end of focus
-      parser.load(&input);
+      {
-        vector<atom *> ListAfter = World::getInstance().getAllAtoms();
-        pair< set<atom *>::iterator, bool > Inserter;
-        if (UniqueList.size() != ListAfter.size()) { // only create if new atoms have been parsed
-          MoleculeListClass *molecules = World::getInstance().getMolecules();
-          molecule *mol = World::getInstance().createMolecule();
-          molecules->insert(mol);
-          for (vector<atom *>::iterator runner = ListAfter.begin(); runner != ListAfter.end(); ++runner) {
-            Inserter = UniqueList.insert(*runner);
-            if (Inserter.second) { // if not present, then new (just parsed) atom, add ...
-              cout << "Adding new atom " << **runner << " to new mol." << endl;
-              mol->AddAtom(*runner);
+            }
+          }
-          mol->doCountAtoms();
-        } else {
-          cout << "No atoms parsed?" << endl;
+        }
+      }
-    } else {
-      DoeLog(1) && (eLog() << Verbose(1) << "Could not open file " << filename << "." << endl);
+    }
+    input.close();
+  } else {
+    DoeLog(1) && (eLog() << Verbose(1) << "Could not open file " << filename << "." << endl);
+  }
   delete dialog;
   return Action::failure;
+  input.close();
+  return Action::success;
+}

src/Actions/ParserAction/LoadXyzAction.hpp

-              r7067bd6
+              r677e13
 #include "Actions/Process.hpp"
+void ParserLoadXyz(std::string &filename);
 class ParserLoadXyzAction : public Action {
+  friend void ParserLoadXyz(std::string &filename);
 public:
   ParserLoadXyzAction();
 …
   virtual const std::string getName();
 private:
+  virtual Dialog * createDialog();
   virtual Action::state_ptr performCall();
   virtual Action::state_ptr performUndo(Action::state_ptr);

src/Actions/ParserAction/SaveXyzAction.cpp

-              r7067bd6
+              r677e13
 #include "Actions/ParserAction/SaveXyzAction.hpp"
+#include "Actions/ActionRegistry.hpp"
 #include "Parser/XyzParser.hpp"
+#include "atom.hpp"
+#include "molecule.hpp"
 #include <iostream>
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
 #include "Actions/MapOfActions.hpp"
+#include "UIElements/ValueStorage.hpp"
-#include "atom.hpp"
-#include "molecule.hpp"
 /****** ParserSaveXyzAction *****/
 …
 {}
+void ParserSaveXyz(std::string &filename) {
+  ValueStorage::getInstance().setCurrentValue(ParserSaveXyzAction::NAME, filename);
+  ActionRegistry::getInstance().getActionByName(ParserSaveXyzAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* ParserSaveXyzAction::createDialog() {
+  Dialog *dialog = UIFactory::getInstance().makeDialog();
+  dialog->queryString(NAME, ValueStorage::getInstance().getDescription(NAME));
+  return dialog;
+}
 Action::state_ptr ParserSaveXyzAction::performCall() {
   string filename;
   XyzParser parser;
-  Dialog *dialog = UIFactory::getInstance().makeDialog();
   dialog->queryString("filename",&filename, "Filename of the xyz file");
+  ValueStorage::getInstance().queryCurrentValue(NAME, filename);
+  if(dialog->display()) {
+    // store xyz file
+    ofstream output;
+    output.open(filename.c_str());
+    if (!output.fail())
+      parser.save(&output);
+    output.close();
+  }
+  delete dialog;
+  // store xyz file
+  ofstream output;
+  output.open(filename.c_str());
+  if (!output.fail())
+    parser.save(&output);
+  output.close();
   return Action::failure;
+}

src/Actions/ParserAction/SaveXyzAction.hpp

-              r7067bd6
+              r677e13
 #include "Actions/Process.hpp"
+void ParserSaveXyz(std::string &filename);
 class ParserSaveXyzAction : public Action {
+  friend void ParserSaveXyz(std::string &filename);
 public:
   ParserSaveXyzAction();
 …
   virtual const std::string getName();
 private:
+  virtual Dialog * createDialog();
   virtual Action::state_ptr performCall();
   virtual Action::state_ptr performUndo(Action::state_ptr);

src/Actions/TesselationAction/ConvexEnvelopeAction.cpp

-              r7067bd6
+              r677e13
 #include "Actions/TesselationAction/ConvexEnvelopeAction.hpp"
+#include "Actions/ActionRegistry.hpp"
+#include "boundary.hpp"
+#include "config.hpp"
+#include "linkedcell.hpp"
+#include "log.hpp"
+#include "molecule.hpp"
+#include "verbose.hpp"
+#include "World.hpp"
 #include <iostream>
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
+#include "Actions/MapOfActions.hpp"
+#include "atom.hpp"
+#include "boundary.hpp"
+#include "config.hpp"
+#include "linkedcell.hpp"
+#include "log.hpp"
+#include "molecule.hpp"
+#include "verbose.hpp"
+#include "World.hpp"
+#include "UIElements/ValueStorage.hpp"
 /****** TesselationConvexEnvelopeAction *****/
 …
 {}
+void TesselationConvexEnvelope(std::string &filenameConvex, std::string &filenameNonConvex) {
+  ValueStorage::getInstance().setCurrentValue("convex-file", filenameConvex);
+  ValueStorage::getInstance().setCurrentValue("nonconvex-file", filenameConvex);
+  ActionRegistry::getInstance().getActionByName(TesselationConvexEnvelopeAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* TesselationConvexEnvelopeAction::createDialog() {
+  Dialog *dialog = UIFactory::getInstance().makeDialog();
+  dialog->queryEmpty(NAME, ValueStorage::getInstance().getDescription(NAME));
+  dialog->queryString("convex-file", ValueStorage::getInstance().getDescription("convex-file"));
+  dialog->queryString("nonconvex-file", ValueStorage::getInstance().getDescription("nonconvex-file"));
+  return dialog;
+}
 Action::state_ptr TesselationConvexEnvelopeAction::performCall() {
   string filenameConvex;
   string filenameNonConvex;
-  Dialog *dialog = UIFactory::getInstance().makeDialog();
   molecule * mol = NULL;
   bool Success = false;
+  bool Success = true;
   config *configuration = World::getInstance().getConfig();
+  dialog->queryMolecule(NAME, &mol, MapOfActions::getInstance().getDescription(NAME));
+  dialog->queryString("convex-file", &filenameConvex, MapOfActions::getInstance().getDescription("convex-file"));
+  dialog->queryString("nonconvex-file", &filenameNonConvex, MapOfActions::getInstance().getDescription("nonconvex-file"));
+  ValueStorage::getInstance().queryCurrentValue("convex-file", filenameConvex);
+  ValueStorage::getInstance().queryCurrentValue("nonconvex-file", filenameNonConvex);
+  if(dialog->display()) {
+  for (World::MoleculeSelectionIterator iter = World::getInstance().beginMoleculeSelection(); iter != World::getInstance().endMoleculeSelection(); ++iter) {
+    mol = iter->second;
     class Tesselation *TesselStruct = NULL;
     const LinkedCell *LCList = NULL;
 …
     delete(TesselStruct);
     delete(LCList);
-    delete dialog;
-    if (Success)
-      return Action::success;
-    else
-      return Action::failure;
+  }
+  delete dialog;
+  return Action::failure;
+  if (Success)
+    return Action::success;
+  else
+    return Action::failure;
+}

src/Actions/TesselationAction/ConvexEnvelopeAction.hpp

-              r7067bd6
+              r677e13
 class TesselationListClass;
+void TesselationConvexEnvelope(std::string &filenameConvex, std::string &filenameNonConvex);
 class TesselationConvexEnvelopeAction : public Action {
+  friend void TesselationConvexEnvelope(std::string &filenameConvex, std::string &filenameNonConvex);
 public:
   TesselationConvexEnvelopeAction();
 …
   virtual const std::string getName();
 private:
+  virtual Dialog * createDialog();
   virtual Action::state_ptr performCall();
   virtual Action::state_ptr performUndo(Action::state_ptr);

src/Actions/TesselationAction/NonConvexEnvelopeAction.cpp

-              r7067bd6
+              r677e13
 #include "Actions/TesselationAction/NonConvexEnvelopeAction.hpp"
+#include "Actions/ActionRegistry.hpp"
+#include "boundary.hpp"
+#include "linkedcell.hpp"
+#include "log.hpp"
+#include "molecule.hpp"
+#include "verbose.hpp"
+#include "World.hpp"
 #include <iostream>
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
+#include "Actions/MapOfActions.hpp"
+#include "atom.hpp"
+#include "boundary.hpp"
+#include "linkedcell.hpp"
+#include "log.hpp"
+#include "molecule.hpp"
+#include "verbose.hpp"
+#include "World.hpp"
+#include "UIElements/ValueStorage.hpp"
 /****** TesselationNonConvexEnvelopeAction *****/
 …
 {}
+void TesselationNonConvexEnvelope(double radius, std::string &filename) {
+  ValueStorage::getInstance().setCurrentValue(TesselationNonConvexEnvelopeAction::NAME, radius);
+  ValueStorage::getInstance().setCurrentValue("nonconvex-file", filename);
+  ActionRegistry::getInstance().getActionByName(TesselationNonConvexEnvelopeAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* TesselationNonConvexEnvelopeAction::createDialog() {
+  Dialog *dialog = UIFactory::getInstance().makeDialog();
+  dialog->queryDouble(NAME, MapOfActions::getInstance().getDescription(NAME));
+  dialog->queryString("nonconvex-file", MapOfActions::getInstance().getDescription("nonconvex-file"));
+  return dialog;
+}
 Action::state_ptr TesselationNonConvexEnvelopeAction::performCall() {
   string filename;
-  Dialog *dialog = UIFactory::getInstance().makeDialog();
   molecule * Boundary = NULL;
   double SphereRadius = 0;
 …
   clock_t start,end;
+  dialog->queryMolecule(NAME, &Boundary, MapOfActions::getInstance().getDescription(NAME));
+  dialog->queryString("nonconvex-file", &filename, MapOfActions::getInstance().getDescription("nonconvex-file"));
+  dialog->queryDouble("sphere-radius", &SphereRadius, MapOfActions::getInstance().getDescription("sphere-radius"));
+  ValueStorage::getInstance().queryCurrentValue(NAME, SphereRadius);
+  ValueStorage::getInstance().queryCurrentValue("nonconvex-file", filename);
+  if(dialog->display()) {
+  for (World::MoleculeSelectionIterator iter = World::getInstance().beginMoleculeSelection(); iter != World::getInstance().endMoleculeSelection(); ++iter) {
+    Boundary = iter->second;
     class Tesselation *T = NULL;
     const LinkedCell *LCList = NULL;
 …
     delete(LCList);
     delete(T);
-    delete dialog;
-    if (Success)
-      return Action::success;
-    else
-      return Action::failure;
+  }
+  delete dialog;
+  return Action::failure;
+  if (Success)
+    return Action::success;
+  else
+    return Action::failure;
+}

src/Actions/TesselationAction/NonConvexEnvelopeAction.hpp

-              r7067bd6
+              r677e13
 class TesselationListClass;
+void TesselationNonConvexEnvelope(double radius, std::string &filename);
 class TesselationNonConvexEnvelopeAction : public Action {
+  friend void TesselationNonConvexEnvelope(double radius, std::string &filename);
 public:
   TesselationNonConvexEnvelopeAction();
 …
   virtual const std::string getName();
 private:
+  virtual Dialog * createDialog();
   virtual Action::state_ptr performCall();
   virtual Action::state_ptr performUndo(Action::state_ptr);

src/Actions/Values.hpp

-              r7067bd6
+              r677e13
+{
   double xx;
+  double xy;
+  double xz;
+  double yx;
   double yy;
+  double yz;
+  double zx;
+  double zy;
   double zz;
 };

src/Actions/WorldAction/AddEmptyBoundaryAction.cpp

-              r7067bd6
+              r677e13
 #include "Actions/WorldAction/AddEmptyBoundaryAction.hpp"
+#include "Actions/ActionRegistry.hpp"
 #include "atom.hpp"
 #include "log.hpp"
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
 #include "Actions/MapOfActions.hpp"
+#include "UIElements/ValueStorage.hpp"
 #include "Helpers/Assert.hpp"
 …
 {}
+void WorldAddEmptyBoundary(Vector &boundary) {
+  ValueStorage::getInstance().setCurrentValue(WorldAddEmptyBoundaryAction::NAME, boundary);
+  ActionRegistry::getInstance().getActionByName(WorldAddEmptyBoundaryAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* WorldAddEmptyBoundaryAction::createDialog() {
+  Dialog *dialog = UIFactory::getInstance().makeDialog();
+  dialog->queryVector(NAME, false, ValueStorage::getInstance().getDescription(NAME));
+  return dialog;
+}
 Action::state_ptr WorldAddEmptyBoundaryAction::performCall() {
-  Dialog *dialog = UIFactory::getInstance().makeDialog();
   Vector boundary;
   Vector Min;
 …
   int j=0;
   dialog->queryVector(NAME, &boundary, false, MapOfActions::getInstance().getDescription(NAME));
+  ValueStorage::getInstance().queryCurrentValue(NAME, boundary);
+  if(dialog->display()) {
+    // get maximum and minimum
+    vector<atom *> AllAtoms = World::getInstance().getAllAtoms();
+    ASSERT(AllAtoms.size() > 0, "There must be atoms present for AddingEmptyBoundary.");
+    vector<atom *>::iterator AtomRunner = AllAtoms.begin();
+    Min = (*AtomRunner)->x;
+    Max = (*AtomRunner)->x;
+    for (; AtomRunner != AllAtoms.end(); ++AtomRunner) {
+      for (int i=0;i<NDIM;i++) {
+        if ((*AtomRunner)->x[i] > Max[i])
+          Max[i] = (*AtomRunner)->x[i];
+        if ((*AtomRunner)->x[i] < Min[i])
+          Min[i] = (*AtomRunner)->x[i];
+      }
+  // get maximum and minimum
+  vector<atom *> AllAtoms = World::getInstance().getAllAtoms();
+  ASSERT(AllAtoms.size() > 0, "There must be atoms present for AddingEmptyBoundary.");
+  vector<atom *>::iterator AtomRunner = AllAtoms.begin();
+  Min = (*AtomRunner)->x;
+  Max = (*AtomRunner)->x;
+  for (; AtomRunner != AllAtoms.end(); ++AtomRunner) {
+    for (int i=0;i<NDIM;i++) {
+      if ((*AtomRunner)->x[i] > Max[i])
+        Max[i] = (*AtomRunner)->x[i];
+      if ((*AtomRunner)->x[i] < Min[i])
+        Min[i] = (*AtomRunner)->x[i];
+    }
-    // set new box size
-    double * const cell_size = new double[6];
-    for (j=0;j<6;j++)
-      cell_size[j] = 0.;
-    j=-1;
-    for (int i=0;i<NDIM;i++) {
-      j += i+1;
-      cell_size[j] = (Max[i]-Min[i]+2.*boundary[i]);
+    }
-    World::getInstance().setDomain(cell_size);
-    delete[] cell_size;
-    // translate all atoms, such that Min is aty (0,0,0)
-    AtomRunner = AllAtoms.begin();
-    for (; AtomRunner != AllAtoms.end(); ++AtomRunner)
-      (*AtomRunner)->x -= Min - boundary;
-    delete dialog;
-    return Action::success;
-  } else {
-    delete dialog;
-    return Action::failure;
+  }
+  // set new box size
+  double * const cell_size = new double[6];
+  for (j=0;j<6;j++)
+    cell_size[j] = 0.;
+  j=-1;
+  for (int i=0;i<NDIM;i++) {
+    j += i+1;
+    cell_size[j] = (Max[i]-Min[i]+2.*boundary[i]);
+  }
+  World::getInstance().setDomain(cell_size);
+  delete[] cell_size;
+  // translate all atoms, such that Min is aty (0,0,0)
+  AtomRunner = AllAtoms.begin();
+  for (; AtomRunner != AllAtoms.end(); ++AtomRunner)
+    (*AtomRunner)->x -= Min - boundary;
+  return Action::success;
+}

src/Actions/WorldAction/AddEmptyBoundaryAction.hpp

-              r7067bd6
+              r677e13
 #include "Actions/Action.hpp"
+#include "vector.hpp"
+void WorldAddEmptyBoundary(Vector &boundary);
 class WorldAddEmptyBoundaryAction : public Action {
+  friend void WorldAddEmptyBoundary(Vector &boundary);
 public:
   WorldAddEmptyBoundaryAction();
 …
   virtual const std::string getName();
 private:
+  virtual Dialog * createDialog();
   virtual Action::state_ptr performCall();
   virtual Action::state_ptr performUndo(Action::state_ptr);

src/Actions/WorldAction/BoundInBoxAction.cpp

-              r7067bd6
+              r677e13
 #include "Actions/WorldAction/BoundInBoxAction.hpp"
+#include "Actions/ActionRegistry.hpp"
 #include "log.hpp"
 #include "molecule.hpp"
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
 #include "Actions/MapOfActions.hpp"
+#include "UIElements/ValueStorage.hpp"
 const char WorldBoundInBoxAction::NAME[] = "bound-in-box";
 …
 {}
+Action::state_ptr WorldBoundInBoxAction::performCall() {
+void WorldBoundInBox() {
+  ActionRegistry::getInstance().getActionByName(WorldBoundInBoxAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* WorldBoundInBoxAction::createDialog() {
   Dialog *dialog = UIFactory::getInstance().makeDialog();
   dialog->queryEmpty(NAME, MapOfActions::getInstance().getDescription(NAME));
+  dialog->queryEmpty(NAME, ValueStorage::getInstance().getDescription(NAME));
+  if(dialog->display()) {
+    // center
+    vector<molecule*> AllMolecules = World::getInstance().getAllMolecules();
+    for (vector<molecule*>::iterator MolRunner = AllMolecules.begin(); MolRunner != AllMolecules.end(); ++MolRunner) {
+      (*MolRunner)->BoundInBox();
+    }
+    delete dialog;
+    return Action::success;
+  } else {
+    delete dialog;
+    return Action::failure;
+  return dialog;
+}
+Action::state_ptr WorldBoundInBoxAction::performCall() {
+  // center
+  vector<molecule*> AllMolecules = World::getInstance().getAllMolecules();
+  for (vector<molecule*>::iterator MolRunner = AllMolecules.begin(); MolRunner != AllMolecules.end(); ++MolRunner) {
+    (*MolRunner)->BoundInBox();
+  }
+  return Action::success;
+}

src/Actions/WorldAction/BoundInBoxAction.hpp

-              r7067bd6
+              r677e13
 #include "Actions/Action.hpp"
+void WorldBoundInBox();
 class WorldBoundInBoxAction : public Action {
+  friend void WorldBoundInBox();
 public:
   WorldBoundInBoxAction();
 …
   virtual const std::string getName();
 private:
+  virtual Dialog * createDialog();
   virtual Action::state_ptr performCall();
   virtual Action::state_ptr performUndo(Action::state_ptr);

src/Actions/WorldAction/CenterInBoxAction.cpp

-              r7067bd6
+              r677e13
 #include "Actions/WorldAction/CenterInBoxAction.hpp"
+#include "Actions/ActionRegistry.hpp"
+#include "Box.hpp"
 #include "log.hpp"
 #include "molecule.hpp"
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
 #include "Actions/MapOfActions.hpp"
+#include "UIElements/ValueStorage.hpp"
 const char WorldCenterInBoxAction::NAME[] = "center-in-box";
 …
 {}
+Action::state_ptr WorldCenterInBoxAction::performCall() {
+void WorldCenterInBox(Box &_box) {
+  ValueStorage::getInstance().setCurrentValue(WorldCenterInBoxAction::NAME, _box);
+  ActionRegistry::getInstance().getActionByName(WorldCenterInBoxAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* WorldCenterInBoxAction::createDialog() {
   Dialog *dialog = UIFactory::getInstance().makeDialog();
+  dialog->queryBox(NAME, ValueStorage::getInstance().getDescription(NAME));
+  return dialog;
+}
+Action::state_ptr WorldCenterInBoxAction::performCall() {
   Box& cell_size = World::getInstance().getDomain();
+  dialog->queryBox(NAME, &cell_size, MapOfActions::getInstance().getDescription(NAME));
+  ValueStorage::getInstance().queryCurrentValue(NAME, cell_size);
+  World::getInstance().setDomain(cell_size.getM());
+  if(dialog->display()) {
+    // center
+    vector<molecule *> AllMolecules = World::getInstance().getAllMolecules();
+    for (vector<molecule*>::iterator MolRunner = AllMolecules.begin(); MolRunner != AllMolecules.end(); ++MolRunner) {
+      (*MolRunner)->CenterInBox();
+    }
+    delete dialog;
+    return Action::success;
+  } else {
+    delete dialog;
+    return Action::failure;
+  // center
+  vector<molecule *> AllMolecules = World::getInstance().getAllMolecules();
+  for (vector<molecule*>::iterator MolRunner = AllMolecules.begin(); MolRunner != AllMolecules.end(); ++MolRunner) {
+    (*MolRunner)->CenterInBox();
+  }
+  return Action::success;
+}

src/Actions/WorldAction/CenterInBoxAction.hpp

-              r7067bd6
+              r677e13
 #include "Actions/Action.hpp"
+#include "Box.hpp"
+void WorldCenterInBox(Box &_box);
 class WorldCenterInBoxAction : public Action {
+  friend void WorldCenterInBox(Box &_box);
 public:
   WorldCenterInBoxAction();
 …
   virtual const std::string getName();
 private:
+  virtual Dialog * createDialog();
   virtual Action::state_ptr performCall();
   virtual Action::state_ptr performUndo(Action::state_ptr);

src/Actions/WorldAction/CenterOnEdgeAction.cpp

-              r7067bd6
+              r677e13
 #include "Actions/WorldAction/CenterOnEdgeAction.hpp"
+#include "Actions/ActionRegistry.hpp"
 #include "atom.hpp"
 #include "log.hpp"
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
 #include "Actions/MapOfActions.hpp"
+#include "UIElements/ValueStorage.hpp"
 #include "Helpers/Assert.hpp"
 …
 {}
+void WorldCenterOnEdge() {
+  ActionRegistry::getInstance().getActionByName(WorldCenterOnEdgeAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* WorldCenterOnEdgeAction::createDialog() {
+  Dialog *dialog = UIFactory::getInstance().makeDialog();
+  dialog->queryEmpty(NAME, ValueStorage::getInstance().getDescription(NAME));
+  return dialog;
+}
 Action::state_ptr WorldCenterOnEdgeAction::performCall() {
-  Dialog *dialog = UIFactory::getInstance().makeDialog();
   Vector Min;
   Vector Max;
+  dialog->queryEmpty(NAME, MapOfActions::getInstance().getDescription(NAME));
+  // get maximum and minimum
+  vector<atom *> AllAtoms = World::getInstance().getAllAtoms();
+  ASSERT(AllAtoms.size() > 0, "For CenteronEdge atoms must be present.");
+  vector<atom *>::iterator AtomRunner = AllAtoms.begin();
+  Min = (*AtomRunner)->x;
+  Max = (*AtomRunner)->x;
+  for (; AtomRunner != AllAtoms.end(); ++AtomRunner) {
+    for (int i=0;i<NDIM;i++) {
+      if ((*AtomRunner)->x[i] > Max[i])
+        Max[i] = (*AtomRunner)->x[i];
+      if ((*AtomRunner)->x[i] < Min[i])
+        Min[i] = (*AtomRunner)->x[i];
+    }
+  }
+  // set new box size
+  Matrix domain;
+  for (int i=0;i<NDIM;i++) {
+    double tmp = Max[i]-Min[i];
+    tmp = fabs(tmp)>=1. ? tmp : 1.0;
+    domain.at(i,i) = tmp;
+  }
+  World::getInstance().setDomain(domain);
+  // translate all atoms, such that Min is aty (0,0,0)
+  for (vector<atom*>::iterator AtomRunner = AllAtoms.begin(); AtomRunner != AllAtoms.end(); ++AtomRunner)
+    (*AtomRunner)->x -= Min;
+  if(dialog->display()) {
+    // get maximum and minimum
+    vector<atom *> AllAtoms = World::getInstance().getAllAtoms();
+    ASSERT(AllAtoms.size() > 0, "For CenteronEdge atoms must be present.");
+    vector<atom *>::iterator AtomRunner = AllAtoms.begin();
+    Min = (*AtomRunner)->x;
+    Max = (*AtomRunner)->x;
+    for (; AtomRunner != AllAtoms.end(); ++AtomRunner) {
+      for (int i=0;i<NDIM;i++) {
+        if ((*AtomRunner)->x[i] > Max[i])
+          Max[i] = (*AtomRunner)->x[i];
+        if ((*AtomRunner)->x[i] < Min[i])
+          Min[i] = (*AtomRunner)->x[i];
+      }
+    }
+    // set new box size
+    Matrix domain;
+    for (int i=0;i<NDIM;i++) {
+      double tmp = Max[i]-Min[i];
+      tmp = fabs(tmp)>=1. ? tmp : 1.0;
+      domain.at(i,i) = tmp;
+    }
+    World::getInstance().setDomain(domain);
+    // translate all atoms, such that Min is aty (0,0,0)
+    for (vector<atom*>::iterator AtomRunner = AllAtoms.begin(); AtomRunner != AllAtoms.end(); ++AtomRunner)
+      (*AtomRunner)->x -= Min;
+    delete dialog;
+    return Action::success;
+  } else {
+    delete dialog;
+    return Action::failure;
+  }
+  return Action::success;
+}

src/Actions/WorldAction/CenterOnEdgeAction.hpp

-              r7067bd6
+              r677e13
 #include "Actions/Action.hpp"
+void WorldCenterOnEdge();
 class WorldCenterOnEdgeAction : public Action {
+  friend void WorldCenterOnEdge();
 public:
   WorldCenterOnEdgeAction();
 …
   virtual const std::string getName();
 private:
+  virtual Dialog * createDialog();
   virtual Action::state_ptr performCall();
   virtual Action::state_ptr performUndo(Action::state_ptr);

src/Actions/WorldAction/ChangeBoxAction.cpp

-              r7067bd6
+              r677e13
 #include "Actions/WorldAction/ChangeBoxAction.hpp"
+#include "Actions/ActionRegistry.hpp"
 #include "log.hpp"
 #include "verbose.hpp"
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
 #include "Actions/MapOfActions.hpp"
+#include "UIElements/ValueStorage.hpp"
 const char WorldChangeBoxAction::NAME[] = "change-box";
 …
 {}
+Action::state_ptr WorldChangeBoxAction::performCall() {
+void WorldChangeBox(Box &_box) {
+  ValueStorage::getInstance().setCurrentValue(WorldChangeBoxAction::NAME, _box);
+  ActionRegistry::getInstance().getActionByName(WorldChangeBoxAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* WorldChangeBoxAction::createDialog() {
   Dialog *dialog = UIFactory::getInstance().makeDialog();
+  Box& cell_size = World::getInstance().getDomain();
+  dialog->queryBox(NAME, &cell_size, MapOfActions::getInstance().getDescription(NAME));
+  dialog->queryBox(NAME, ValueStorage::getInstance().getDescription(NAME));
+  if(dialog->display()) {
+    DoLog(0) && (Log() << Verbose(0) << "Setting box domain to " << cell_size.getM() << endl);
+    World::getInstance().setDomain(cell_size.getM());
+    delete dialog;
+    return Action::success;
+  } else {
+    delete dialog;
+    return Action::failure;
+  }
+  return dialog;
+}
+Action::state_ptr WorldChangeBoxAction::performCall() {
+  Box cell_size;
+  ValueStorage::getInstance().queryCurrentValue(NAME, cell_size);
+  World::getInstance().setDomain(cell_size.getM()); // this is needed as only this function is OBSERVEd.
+  DoLog(0) && (Log() << Verbose(0) << "Setting box domain to " << World::getInstance().getDomain().getM() << endl);
+  return Action::success;
+}

src/Actions/WorldAction/ChangeBoxAction.hpp

-              r7067bd6
+              r677e13
 #include "Actions/Action.hpp"
+#include "Box.hpp"
+void WorldChangeBox(Box &_box);
 class WorldChangeBoxAction : public Action {
+  friend void WorldChangeBox(Box &_box);
 public:
   WorldChangeBoxAction();
 …
   virtual const std::string getName();
 private:
+  virtual Dialog * createDialog();
   virtual Action::state_ptr performCall();
   virtual Action::state_ptr performUndo(Action::state_ptr);

src/Actions/WorldAction/InputAction.cpp

-              r7067bd6
+              r677e13
 #include "Actions/WorldAction/InputAction.hpp"
+#include "Actions/ActionRegistry.hpp"
 #include "log.hpp"
 #include "molecule.hpp"
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
 #include "Actions/MapOfActions.hpp"
+#include "UIElements/ValueStorage.hpp"
 const char WorldInputAction::NAME[] = "input";
 …
 {}
+void WorldInput(std::string &filename) {
+  ValueStorage::getInstance().setCurrentValue(WorldInputAction::NAME, filename);
+  ActionRegistry::getInstance().getActionByName(WorldInputAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* WorldInputAction::createDialog() {
+  Dialog *dialog = UIFactory::getInstance().makeDialog();
+  dialog->queryString(NAME, ValueStorage::getInstance().getDescription(NAME));
+  return dialog;
+}
 Action::state_ptr WorldInputAction::performCall() {
-  Dialog *dialog = UIFactory::getInstance().makeDialog();
   MoleculeListClass *molecules = World::getInstance().getMolecules();
   molecule *mol = NULL;
 …
   std::ifstream test;
   dialog->queryString(NAME, &filename, MapOfActions::getInstance().getDescription(NAME));
+  ValueStorage::getInstance().queryCurrentValue(NAME, filename);
+  if(dialog->display()) {
+    DoLog(0) && (Log() << Verbose(0) << "Config file given." << endl);
+    if (filename.find('.') != string::npos) {
+      std::string FilenamePrefix = filename.substr(0,filename.find_last_of('.'));
+      std::string FilenameSuffix = filename.substr(filename.find_last_of('.')+1, filename.length());
+      DoLog(1) && (Log() << Verbose(1) << "Setting config file name prefix to " << FilenamePrefix << "." << endl);
+      test.open(filename.c_str());
+      if (test == NULL) {
+        DoLog(1) && (Log() << Verbose(1) << "Specified config file " << filename << " not found." << endl);
+      } else {
+        DoLog(1) && (Log() << Verbose(1) << "Specified config file found, parsing ... ");
+        FormatParserStorage::getInstance().get((std::istream &)test, FilenameSuffix);
+        test.close();
+      }
+      FormatParserStorage::getInstance().SetOutputPrefixForAll(FilenamePrefix);
+      // set mol to first active molecule
+      if (molecules->ListOfMolecules.size() != 0) {
+        for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++)
+          if ((*ListRunner)->ActiveFlag) {
+            mol = *ListRunner;
+            break;
+          }
+      }
+      if (mol == NULL) {
+        mol = World::getInstance().createMolecule();
+        mol->ActiveFlag = true;
+        molecules->insert(mol);
+      }
+      mol->SetNameFromFilename(filename.substr(0,filename.find('.')).c_str());
+  DoLog(0) && (Log() << Verbose(0) << "Config file given." << endl);
+  if (filename.find('.') != string::npos) {
+    std::string FilenamePrefix = filename.substr(0,filename.find_last_of('.'));
+    std::string FilenameSuffix = filename.substr(filename.find_last_of('.')+1, filename.length());
+    DoLog(1) && (Log() << Verbose(1) << "Setting config file name prefix to " << FilenamePrefix << "." << endl);
+    test.open(filename.c_str());
+    if (test == NULL) {
+      DoLog(1) && (Log() << Verbose(1) << "Specified config file " << filename << " not found." << endl);
     } else {
+      DoeLog(1) && (eLog() << Verbose(1) << "Input file does not have a suffix, cannot recognize format." << endl);
+      DoLog(1) && (Log() << Verbose(1) << "Specified config file found, parsing ... ");
+      FormatParserStorage::getInstance().get((std::istream &)test, FilenameSuffix);
+      test.close();
+    }
+    delete dialog;
+    return Action::success;
+    FormatParserStorage::getInstance().SetOutputPrefixForAll(FilenamePrefix);
+    // set mol to first active molecule
+    if (molecules->ListOfMolecules.size() != 0) {
+      for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++)
+        if ((*ListRunner)->ActiveFlag) {
+          mol = *ListRunner;
+          break;
+        }
+    }
+    if (mol == NULL) {
+      mol = World::getInstance().createMolecule();
+      mol->ActiveFlag = true;
+      molecules->insert(mol);
+    }
+    mol->SetNameFromFilename(filename.substr(0,filename.find('.')).c_str());
   } else {
+    delete dialog;
+    return Action::failure;
+    DoeLog(1) && (eLog() << Verbose(1) << "Input file does not have a suffix, cannot recognize format." << endl);
+  }
+  return Action::success;
+}

src/Actions/WorldAction/InputAction.hpp

-              r7067bd6
+              r677e13
 #include "Actions/Action.hpp"
+void WorldInput(std::string &filename);
 class WorldInputAction : public Action {
+  friend void WorldInput(std::string &filename);
 public:
   WorldInputAction();
 …
   virtual const std::string getName();
 private:
+  virtual Dialog * createDialog();
   virtual Action::state_ptr performCall();
   virtual Action::state_ptr performUndo(Action::state_ptr);

src/Actions/WorldAction/OutputAction.cpp

-              r7067bd6
+              r677e13
 #include "Actions/WorldAction/OutputAction.hpp"
+#include "Actions/ActionRegistry.hpp"
 #include "Parser/ChangeTracker.hpp"
 #include "log.hpp"
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
 #include "Actions/MapOfActions.hpp"
+#include "UIElements/ValueStorage.hpp"
 const char WorldOutputAction::NAME[] = "output";
 …
 {}
+Action::state_ptr WorldOutputAction::performCall() {
+void WorldOutput() {
+  ActionRegistry::getInstance().getActionByName(WorldOutputAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* WorldOutputAction::createDialog() {
   Dialog *dialog = UIFactory::getInstance().makeDialog();
   dialog->queryEmpty(NAME, MapOfActions::getInstance().getDescription(NAME));
+  dialog->queryEmpty(NAME, ValueStorage::getInstance().getDescription(NAME));
+  if(dialog->display()) {
+    DoLog(0) && (Log() << Verbose(0) << "Saving world to files." << endl);
+    ChangeTracker::getInstance().saveStatus();
+    delete dialog;
+    return Action::success;
+  } else {
+    delete dialog;
+    return Action::failure;
+  }
+  return dialog;
+}
+Action::state_ptr WorldOutputAction::performCall() {
+  DoLog(0) && (Log() << Verbose(0) << "Saving world to files." << endl);
+  ChangeTracker::getInstance().saveStatus();
+  return Action::success;
+}

src/Actions/WorldAction/OutputAction.hpp

-              r7067bd6
+              r677e13
 #include "Actions/Action.hpp"
+void WorldOutput();
 class WorldOutputAction : public Action {
+  friend void WorldOutput();
 public:
   WorldOutputAction();
 …
   virtual const std::string getName();
 private:
+  virtual Dialog * createDialog();
   virtual Action::state_ptr performCall();
   virtual Action::state_ptr performUndo(Action::state_ptr);

src/Actions/WorldAction/RemoveSphereOfAtomsAction.cpp

-              r7067bd6
+              r677e13
 #include "Actions/WorldAction/RemoveSphereOfAtomsAction.hpp"
+#include "Actions/ActionRegistry.hpp"
+#include "Descriptors/AtomDescriptor.hpp"
 #include "atom.hpp"
-#include "Descriptors/AtomDescriptor.hpp"
 #include "log.hpp"
 #include "molecule.hpp"
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
 #include "Actions/MapOfActions.hpp"
+#include "UIElements/ValueStorage.hpp"
 const char WorldRemoveSphereOfAtomsAction::NAME[] = "remove-sphere";
 …
 {}
+void WorldRemoveSphereOfAtoms(double radius, Vector &point) {
+  ValueStorage::getInstance().setCurrentValue(WorldRemoveSphereOfAtomsAction::NAME, radius);
+  ValueStorage::getInstance().setCurrentValue("position", point);
+  ActionRegistry::getInstance().getActionByName(WorldRemoveSphereOfAtomsAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* WorldRemoveSphereOfAtomsAction::createDialog() {
+  Dialog *dialog = UIFactory::getInstance().makeDialog();
+  dialog->queryDouble(NAME, ValueStorage::getInstance().getDescription(NAME));
+  dialog->queryVector("position", false, ValueStorage::getInstance().getDescription("position"));
+  return dialog;
+}
 Action::state_ptr WorldRemoveSphereOfAtomsAction::performCall() {
-  Dialog *dialog = UIFactory::getInstance().makeDialog();
   double radius = 0.;
   Vector point;
   dialog->queryDouble(NAME, &radius, MapOfActions::getInstance().getDescription(NAME));
   dialog->queryVector("position", &point, false, MapOfActions::getInstance().getDescription("position"));
+  ValueStorage::getInstance().queryCurrentValue(NAME, radius);
+  ValueStorage::getInstance().queryCurrentValue("position", point);
+  if(dialog->display()) {
+    delete dialog;
+    DoLog(1) && (Log() << Verbose(1) << "Removing atoms around " << point << " with radius " << radius << "." << endl);
+    vector<atom*> AllAtoms = World::getInstance().getAllAtoms();
+    vector<molecule *> molecules = World::getInstance().getAllMolecules();
+    for (vector<atom*>::iterator AtomRunner = AllAtoms.begin(); AtomRunner != AllAtoms.end(); ++AtomRunner) {
+      if (point.DistanceSquared((*AtomRunner)->x) > radius*radius) { // distance to first above radius ...
+        // TODO: This is not necessary anymore when atoms are completely handled by World (create/destroy and load/save)
+        for (vector<molecule *>::iterator iter = molecules.begin();iter != molecules.end();++iter)
+          (*iter)->erase(*AtomRunner);
+        World::getInstance().destroyAtom(*AtomRunner);
+      }
+  DoLog(1) && (Log() << Verbose(1) << "Removing atoms around " << point << " with radius " << radius << "." << endl);
+  vector<atom*> AllAtoms = World::getInstance().getAllAtoms();
+  vector<molecule *> molecules = World::getInstance().getAllMolecules();
+  for (vector<atom*>::iterator AtomRunner = AllAtoms.begin(); AtomRunner != AllAtoms.end(); ++AtomRunner) {
+    if (point.DistanceSquared((*AtomRunner)->x) > radius*radius) { // distance to first above radius ...
+      // TODO: This is not necessary anymore when atoms are completely handled by World (create/destroy and load/save)
+      for (vector<molecule *>::iterator iter = molecules.begin();iter != molecules.end();++iter)
+        (*iter)->erase(*AtomRunner);
+      World::getInstance().destroyAtom(*AtomRunner);
+    }
-    return Action::success;
-  } else {
-    delete dialog;
-    return Action::failure;
+  }
+  return Action::success;
+}

src/Actions/WorldAction/RemoveSphereOfAtomsAction.hpp

-              r7067bd6
+              r677e13
 #include "Actions/Action.hpp"
+#include "vector.hpp"
+void WorldRemoveSphereOfAtoms(double radius, Vector &point);
 class WorldRemoveSphereOfAtomsAction : public Action {
+  friend void WorldRemoveSphereOfAtoms(double radius, Vector &point);
 public:
   WorldRemoveSphereOfAtomsAction();
 …
   virtual const std::string getName();
 private:
+  virtual Dialog * createDialog();
   virtual Action::state_ptr performCall();
   virtual Action::state_ptr performUndo(Action::state_ptr);

src/Actions/WorldAction/RepeatBoxAction.cpp

-              r7067bd6
+              r677e13
 #include "Actions/WorldAction/RepeatBoxAction.hpp"
+#include "Actions/ActionRegistry.hpp"
 #include "atom.hpp"
 #include "log.hpp"
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
 #include "Actions/MapOfActions.hpp"
+#include "UIElements/ValueStorage.hpp"
 #include "Descriptors/MoleculeDescriptor.hpp"
 #include "Descriptors/MoleculePtrDescriptor.hpp"
 …
 {}
+void WorldRepeatBox(Vector &Repeater) {
+  ValueStorage::getInstance().setCurrentValue(WorldRepeatBoxAction::NAME, Repeater);
+  ActionRegistry::getInstance().getActionByName(WorldRepeatBoxAction::NAME)->call(Action::NonInteractive);
+};
+Dialog * WorldRepeatBoxAction::createDialog() {
+  Dialog *dialog = UIFactory::getInstance().makeDialog();
+  dialog->queryVector(NAME, false, ValueStorage::getInstance().getDescription(NAME));
+  return dialog;
+}
 Action::state_ptr WorldRepeatBoxAction::performCall() {
-  Dialog *dialog = UIFactory::getInstance().makeDialog();
   Vector Repeater;
   int count;
 …
   MoleculeListClass *molecules = World::getInstance().getMolecules();
   dialog->queryVector(NAME, &Repeater, false, MapOfActions::getInstance().getDescription(NAME));
+  //dialog->queryMolecule("molecule-by-id", &mol,MapOfActions::getInstance().getDescription("molecule-by-id"));
+  ValueStorage::getInstance().queryCurrentValue(NAME, Repeater);
   vector<molecule *> AllMolecules;
   if (mol != NULL) {
 …
+  }
+  if(dialog->display()) {
+    (cout << "Repeating box " << Repeater << " times for (x,y,z) axis." << endl);
+    Matrix M = World::getInstance().getDomain().getM();
+    Matrix newM = M;
+    Vector x,y;
+    int n[NDIM];
+    Matrix repMat;
+    for (int axis = 0; axis < NDIM; axis++) {
+      Repeater[axis] = floor(Repeater[axis]);
+      if (Repeater[axis] < 1) {
+        DoeLog(1) && (eLog()<< Verbose(1) << "Repetition factor must be greater than 1!" << endl);
+        Repeater[axis] = 1;
+      }
+      repMat.at(axis,axis) = Repeater[axis];
+  (cout << "Repeating box " << Repeater << " times for (x,y,z) axis." << endl);
+  Matrix M = World::getInstance().getDomain().getM();
+  Matrix newM = M;
+  Vector x,y;
+  int n[NDIM];
+  Matrix repMat;
+  for (int axis = 0; axis < NDIM; axis++) {
+    Repeater[axis] = floor(Repeater[axis]);
+    if (Repeater[axis] < 1) {
+      DoeLog(1) && (eLog()<< Verbose(1) << "Repetition factor must be greater than 1!" << endl);
+      Repeater[axis] = 1;
+    }
+    newM *= repMat;
+    World::getInstance().setDomain(newM);
+    repMat.at(axis,axis) = Repeater[axis];
+  }
+  newM *= repMat;
+  World::getInstance().setDomain(newM);
+    molecule *newmol = NULL;
+    Vector ** vectors = NULL;
+    for (n[0] = 0; n[0] < Repeater[0]; n[0]++) {
+      y[0] = n[0];
+      for (n[1] = 0; n[1] < Repeater[1]; n[1]++) {
+        y[1] = n[1];
+        for (n[2] = 0; n[2] < Repeater[2]; n[2]++) {
+          y[2] = n[2];
+          if ((n[0] == 0) && (n[1] == 0) && (n[2] == 0))
+            continue;
+          for (vector<molecule *>::iterator MolRunner = AllMolecules.begin(); MolRunner != AllMolecules.end(); ++MolRunner) {
+            mol = *MolRunner;
+            DoLog(1) && (Log() << Verbose(1) << "Current mol is " << mol->name << "." << endl);
+            count = mol->getAtomCount();   // is changed becausing of adding, thus has to be stored away beforehand
+            if (count != 0) {  // if there is more than none
+              Elements = new const element *[count];
+              vectors = new Vector *[count];
+              j = 0;
+              for(molecule::iterator AtomRunner = mol->begin(); AtomRunner != mol->end(); ++AtomRunner) {
+                Elements[j] = (*AtomRunner)->type;
+                vectors[j] = &(*AtomRunner)->x;
+                j++;
+              }
+              if (count != j)
+                DoeLog(1) && (eLog()<< Verbose(1) << "AtomCount " << count << " is not equal to number of atoms in molecule " << j << "!" << endl);
+              x = y;
+              x *= M;
+              newmol = World::getInstance().createMolecule();
+              molecules->insert(newmol);
+              for (int k=count;k--;) { // go through every atom of the original cell
+                Walker = World::getInstance().createAtom(); // create a new body
+                Walker->x = (*vectors[k]) + x;
+                Walker->type = Elements[k];  // insert original element
+                cout << "new atom is " << *Walker << endl;
+                newmol->AddAtom(Walker);        // and add to the molecule (which increments ElementsInMolecule, AtomCount, ...)
+              }
+              // free memory
+              delete[](Elements);
+              delete[](vectors);
+            } else {
+              DoLog(1) && (Log() << Verbose(1) << "\t ... is empty." << endl);
+  molecule *newmol = NULL;
+  Vector ** vectors = NULL;
+  for (n[0] = 0; n[0] < Repeater[0]; n[0]++) {
+    y[0] = n[0];
+    for (n[1] = 0; n[1] < Repeater[1]; n[1]++) {
+      y[1] = n[1];
+      for (n[2] = 0; n[2] < Repeater[2]; n[2]++) {
+        y[2] = n[2];
+        if ((n[0] == 0) && (n[1] == 0) && (n[2] == 0))
+          continue;
+        for (vector<molecule *>::iterator MolRunner = AllMolecules.begin(); MolRunner != AllMolecules.end(); ++MolRunner) {
+          mol = *MolRunner;
+          DoLog(1) && (Log() << Verbose(1) << "Current mol is " << mol->name << "." << endl);
+          count = mol->getAtomCount();   // is changed becausing of adding, thus has to be stored away beforehand
+          if (count != 0) {  // if there is more than none
+            Elements = new const element *[count];
+            vectors = new Vector *[count];
+            j = 0;
+            for(molecule::iterator AtomRunner = mol->begin(); AtomRunner != mol->end(); ++AtomRunner) {
+              Elements[j] = (*AtomRunner)->type;
+              vectors[j] = &(*AtomRunner)->x;
+              j++;
+            }
+            if (count != j)
+              DoeLog(1) && (eLog()<< Verbose(1) << "AtomCount " << count << " is not equal to number of atoms in molecule " << j << "!" << endl);
+            x = y;
+            x *= M;
+            newmol = World::getInstance().createMolecule();
+            molecules->insert(newmol);
+            for (int k=count;k--;) { // go through every atom of the original cell
+              Walker = World::getInstance().createAtom(); // create a new body
+              Walker->x = (*vectors[k]) + x;
+              Walker->type = Elements[k];  // insert original element
+              cout << "new atom is " << *Walker << endl;
+              newmol->AddAtom(Walker);        // and add to the molecule (which increments ElementsInMolecule, AtomCount, ...)
+            }
+            // free memory
+            delete[](Elements);
+            delete[](vectors);
+          } else {
+            DoLog(1) && (Log() << Verbose(1) << "\t ... is empty." << endl);
+          }
+        }
+      }
+    }
-    delete dialog;
-    return Action::success;
-  } else {
-    delete dialog;
-    return Action::failure;
+  }
+  return Action::success;
+}

src/Actions/WorldAction/RepeatBoxAction.hpp

-              r7067bd6
+              r677e13
 #include "Actions/Action.hpp"
+#include "vector.hpp"
+void WorldRepeatBox(Vector &Repeater);
 class WorldRepeatBoxAction : public Action {
+  friend void WorldRepeatBox(Vector &Repeater);
 public:
   WorldRepeatBoxAction();
 …
   virtual const std::string getName();
 private:
+  virtual Dialog * createDialog();
   virtual Action::state_ptr performCall();
   virtual Action::state_ptr performUndo(Action::state_ptr);

src/Actions/WorldAction/ScaleBoxAction.cpp

-              r7067bd6
+              r677e13
 #include "Actions/WorldAction/ScaleBoxAction.hpp"
+#include "Actions/ActionRegistry.hpp"
 #include "atom.hpp"
 #include "log.hpp"
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
 #include "Actions/MapOfActions.hpp"
+#include "UIElements/ValueStorage.hpp"
 const char WorldScaleBoxAction::NAME[] = "scale-box";
 …
 {}
+void WorldScaleBox(Vector &Scaler) {
+  ValueStorage::getInstance().setCurrentValue(WorldScaleBoxAction::NAME, Scaler);
+  ActionRegistry::getInstance().getActionByName(WorldScaleBoxAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* WorldScaleBoxAction::createDialog() {
+  Dialog *dialog = UIFactory::getInstance().makeDialog();
+  dialog->queryVector(NAME, false, ValueStorage::getInstance().getDescription(NAME));
+  return dialog;
+}
 Action::state_ptr WorldScaleBoxAction::performCall() {
-  Dialog *dialog = UIFactory::getInstance().makeDialog();
   Vector Scaler;
   double x[NDIM];
   dialog->queryVector(NAME, &Scaler, false, MapOfActions::getInstance().getDescription(NAME));
+  ValueStorage::getInstance().queryCurrentValue(NAME, Scaler);
+  if(dialog->display()) {
+    DoLog(1) && (Log() << Verbose(1) << "Scaling all atomic positions by factor." << endl);
+    for (int i=0;i<NDIM;i++)
+      x[i] = Scaler[i];
+    vector<atom*> AllAtoms = World::getInstance().getAllAtoms();
+    for(vector<atom*>::iterator AtomRunner = AllAtoms.begin(); AtomRunner != AllAtoms.end(); ++AtomRunner) {
+      (*AtomRunner)->x.ScaleAll(x);
+    }
+  DoLog(1) && (Log() << Verbose(1) << "Scaling all atomic positions by factor." << endl);
+  for (int i=0;i<NDIM;i++)
+    x[i] = Scaler[i];
+  vector<atom*> AllAtoms = World::getInstance().getAllAtoms();
+  for(vector<atom*>::iterator AtomRunner = AllAtoms.begin(); AtomRunner != AllAtoms.end(); ++AtomRunner) {
+    (*AtomRunner)->x.ScaleAll(x);
+  }
     Matrix M = World::getInstance().getDomain().getM();
     Matrix scale;
+  Matrix M = World::getInstance().getDomain().getM();
+  Matrix scale;
     for (int i=0;i<NDIM;i++) {
       scale.at(i,i) = x[i];
+    }
     M *= scale;
     World::getInstance().setDomain(M);
+  for (int i=0;i<NDIM;i++) {
+    scale.at(i,i) = x[i];
+  }
+  M *= scale;
+  World::getInstance().setDomain(M);
+    delete dialog;
+    return Action::success;
+  } else {
+    delete dialog;
+    return Action::failure;
+  }
+  return Action::success;
+}

src/Actions/WorldAction/ScaleBoxAction.hpp

-              r7067bd6
+              r677e13
 #include "Actions/Action.hpp"
+#include "vector.hpp"
+void WorldScaleBox(Vector &Scaler);
 class WorldScaleBoxAction : public Action {
+  friend void WorldScaleBox(Vector &Scaler);
 public:
   WorldScaleBoxAction();
 …
   virtual const std::string getName();
 private:
+  virtual Dialog * createDialog();
   virtual Action::state_ptr performCall();
   virtual Action::state_ptr performUndo(Action::state_ptr);

src/Actions/WorldAction/SetDefaultNameAction.cpp

-              r7067bd6
+              r677e13
 #include "Actions/WorldAction/SetDefaultNameAction.hpp"
+#include "Actions/ActionRegistry.hpp"
 #include "log.hpp"
 #include "verbose.hpp"
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
+#include "Actions/MapOfActions.hpp"
+#include "UIElements/ValueStorage.hpp"
+// memento to remember the state when undoing
+class WorldSetDefaultNameState : public ActionState {
+public:
+  WorldSetDefaultNameState(std::string _lastName) :
+    lastName(_lastName)
+  {}
+  std::string lastName;
+};
 const char WorldSetDefaultNameAction::NAME[] = "default-molname";
 …
 {}
+void WorldSetDefaultName(std::string &defaultname) {
+  ValueStorage::getInstance().setCurrentValue(WorldSetDefaultNameAction::NAME, defaultname);
+  ActionRegistry::getInstance().getActionByName(WorldSetDefaultNameAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* WorldSetDefaultNameAction::createDialog() {
+  Dialog *dialog = UIFactory::getInstance().makeDialog();
+  string defaultname = World::getInstance().getDefaultName();
+  ValueStorage::getInstance().setCurrentValue(NAME, defaultname);
+  dialog->queryString(NAME, MapOfActions::getInstance().getDescription(NAME));
+  return dialog;
+}
 Action::state_ptr WorldSetDefaultNameAction::performCall() {
-  Dialog *dialog = UIFactory::getInstance().makeDialog();
   string defaultname;
   defaultname = World::getInstance().getDefaultName();
   dialog->queryString(NAME, &defaultname, MapOfActions::getInstance().getDescription(NAME));
+  ValueStorage::getInstance().queryCurrentValue(NAME, defaultname);
+  if(dialog->display()) {
+    World::getInstance().setDefaultName(defaultname);
+    DoLog(0) && (Log() << Verbose(0) << "Default name of new molecules set to " << World::getInstance().getDefaultName() << "." << endl);
+    delete dialog;
+    return Action::success;
+  } else {
+    delete dialog;
+    return Action::failure;
+  }
+  World::getInstance().setDefaultName(defaultname);
+  DoLog(0) && (Log() << Verbose(0) << "Default name of new molecules set to " << World::getInstance().getDefaultName() << "." << endl);
+  return Action::success;
+}
 Action::state_ptr WorldSetDefaultNameAction::performUndo(Action::state_ptr _state) {
 //  ParserLoadXyzState *state = assert_cast<ParserLoadXyzState*>(_state.get());
+  WorldSetDefaultNameState *state = assert_cast<WorldSetDefaultNameState*>(_state.get());
+  return Action::failure;
+//  string newName = state->mol->getName();
+//  state->mol->setName(state->lastName);
+//
+//  return Action::state_ptr(new ParserLoadXyzState(state->mol,newName));
+  string newName = World::getInstance().getDefaultName();
+  World::getInstance().setDefaultName(state->lastName);
+  return Action::state_ptr(new WorldSetDefaultNameState(newName));
+}
 Action::state_ptr WorldSetDefaultNameAction::performRedo(Action::state_ptr _state){
   return Action::failure;
+  performUndo(_state);
+}
 bool WorldSetDefaultNameAction::canUndo() {
   return false;
+  return true;
+}
 bool WorldSetDefaultNameAction::shouldUndo() {
   return false;
+  return true;
+}

src/Actions/WorldAction/SetDefaultNameAction.hpp

-              r7067bd6
+              r677e13
 #include "Actions/Action.hpp"
+void WorldSetDefaultName(std::string &defaultname);
 class WorldSetDefaultNameAction : public Action {
+  friend void WorldSetDefaultName(std::string &defaultname);
 public:
   WorldSetDefaultNameAction();
 …
   virtual const std::string getName();
 private:
+  virtual Dialog * createDialog();
   virtual Action::state_ptr performCall();
   virtual Action::state_ptr performUndo(Action::state_ptr);

src/Actions/WorldAction/SetGaussianBasisAction.cpp

-              r7067bd6
+              r677e13
 #include "Actions/WorldAction/SetGaussianBasisAction.hpp"
+#include "Actions/ActionRegistry.hpp"
 #include "config.hpp"
 #include "log.hpp"
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
+#include "Actions/MapOfActions.hpp"
+#include "UIElements/ValueStorage.hpp"
+// memento to remember the state when undoing
+class WorldSetGaussianBasisState : public ActionState {
+public:
+  WorldSetGaussianBasisState(std::string _lastName) :
+    lastName(_lastName)
+  {}
+  std::string lastName;
+};
 const char WorldSetGaussianBasisAction::NAME[] = "set-basis";
 …
 {}
+void WorldSetGaussianBasis(std::string &basisname) {
+  ValueStorage::getInstance().setCurrentValue(WorldSetGaussianBasisAction::NAME, basisname);
+  ActionRegistry::getInstance().getActionByName(WorldSetGaussianBasisAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* WorldSetGaussianBasisAction::createDialog() {
+  Dialog *dialog = UIFactory::getInstance().makeDialog();
+  dialog->queryString(NAME, ValueStorage::getInstance().getDescription(NAME));
+  return dialog;
+}
 Action::state_ptr WorldSetGaussianBasisAction::performCall() {
-  Dialog *dialog = UIFactory::getInstance().makeDialog();
   config *configuration = World::getInstance().getConfig();
-  dialog->queryString(NAME, &(configuration->basis), MapOfActions::getInstance().getDescription(NAME));
+  if(dialog->display()) {
+    DoLog(1) && (Log() << Verbose(1) << "Setting MPQC basis to " << configuration->basis << "." << endl);
+    delete dialog;
+    return Action::success;
+  } else {
+    delete dialog;
+    return Action::failure;
+  }
+  string lastname = configuration->basis;
+  ValueStorage::getInstance().queryCurrentValue(NAME, configuration->basis);
+  DoLog(1) && (Log() << Verbose(1) << "Setting MPQC basis to " << configuration->basis << "." << endl);
+  return Action::success;
+}
 Action::state_ptr WorldSetGaussianBasisAction::performUndo(Action::state_ptr _state) {
 //  ParserLoadXyzState *state = assert_cast<ParserLoadXyzState*>(_state.get());
+  WorldSetGaussianBasisState *state = assert_cast<WorldSetGaussianBasisState*>(_state.get());
   return Action::failure;
 //  string newName = state->mol->getName();
 //  state->mol->setName(state->lastName);
+//
 //  return Action::state_ptr(new ParserLoadXyzState(state->mol,newName));
+  config *configuration = World::getInstance().getConfig();
+  string newName = configuration->basis;
+  configuration->basis = state->lastName;
+  return Action::state_ptr(new WorldSetGaussianBasisState(newName));
+}
 Action::state_ptr WorldSetGaussianBasisAction::performRedo(Action::state_ptr _state){
   return Action::failure;
+  performUndo(_state);
+}
 bool WorldSetGaussianBasisAction::canUndo() {
   return false;
+  return true;
+}
 bool WorldSetGaussianBasisAction::shouldUndo() {
   return false;
+  return true;
+}

src/Actions/WorldAction/SetGaussianBasisAction.hpp

-              r7067bd6
+              r677e13
 #include "Actions/Action.hpp"
+void WorldSetGaussianBasis(std::string &basisname);
 class WorldSetGaussianBasisAction : public Action {
+  friend void WorldSetGaussianBasis(std::string &basisname);
 public:
   WorldSetGaussianBasisAction();
 …
   virtual const std::string getName();
 private:
+  virtual Dialog * createDialog();
   virtual Action::state_ptr performCall();
   virtual Action::state_ptr performUndo(Action::state_ptr);

src/Actions/WorldAction/SetOutputFormatsAction.cpp

-              r7067bd6
+              r677e13
 #include "Actions/WorldAction/SetOutputFormatsAction.hpp"
+#include "Actions/ActionRegistry.hpp"
 #include "Parser/ChangeTracker.hpp"
 #include "Parser/FormatParserStorage.hpp"
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
 #include "Actions/MapOfActions.hpp"
+#include "UIElements/ValueStorage.hpp"
 const char WorldSetOutputFormatsAction::NAME[] = "set-output";
 …
 {}
+void WorldSetOutputFormats(vector<std::string> &FormatList) {
+  ValueStorage::getInstance().setCurrentValue(WorldSetOutputFormatsAction::NAME, FormatList);
+  ActionRegistry::getInstance().getActionByName(WorldSetOutputFormatsAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* WorldSetOutputFormatsAction::createDialog() {
+  Dialog *dialog = UIFactory::getInstance().makeDialog();
+  dialog->queryStrings(NAME, ValueStorage::getInstance().getDescription(NAME));
+  return dialog;
+}
 Action::state_ptr WorldSetOutputFormatsAction::performCall() {
-  Dialog *dialog = UIFactory::getInstance().makeDialog();
   vector<std::string> FormatList;
   dialog->queryStrings(NAME, &FormatList, MapOfActions::getInstance().getDescription(NAME));
+  ValueStorage::getInstance().queryCurrentValue(NAME, FormatList);
+  if(dialog->display()) {
+    for (vector<std::string>::iterator iter = FormatList.begin(); iter != FormatList.end(); ++iter) {
+      if (*iter == "mpqc") {
+        FormatParserStorage::getInstance().addMpqc();
+        DoLog(0) && (Log() << Verbose(0) << "Adding mpqc type to output." << endl);
+      } else if (*iter == "pcp") {
+        FormatParserStorage::getInstance().addPcp();
+        DoLog(0) && (Log() << Verbose(0) << "Adding pcp type to output." << endl);
+      } else if (*iter == "tremolo") {
+        FormatParserStorage::getInstance().addTremolo();
+        DoLog(0) && (Log() << Verbose(0) << "Adding tremolo type to output." << endl);
+      } else if (*iter == "xyz") {
+        FormatParserStorage::getInstance().addXyz();
+        DoLog(0) && (Log() << Verbose(0) << "Adding xyz type to output." << endl);
+      } else {
+        DoeLog(1) && (eLog() << Verbose(1) << "Unknown format." << endl);
+      }
+  for (vector<std::string>::iterator iter = FormatList.begin(); iter != FormatList.end(); ++iter) {
+    if (*iter == "mpqc") {
+      FormatParserStorage::getInstance().addMpqc();
+      DoLog(0) && (Log() << Verbose(0) << "Adding mpqc type to output." << endl);
+    } else if (*iter == "pcp") {
+      FormatParserStorage::getInstance().addPcp();
+      DoLog(0) && (Log() << Verbose(0) << "Adding pcp type to output." << endl);
+    } else if (*iter == "tremolo") {
+      FormatParserStorage::getInstance().addTremolo();
+      DoLog(0) && (Log() << Verbose(0) << "Adding tremolo type to output." << endl);
+    } else if (*iter == "xyz") {
+      FormatParserStorage::getInstance().addXyz();
+      DoLog(0) && (Log() << Verbose(0) << "Adding xyz type to output." << endl);
+    } else {
+      DoeLog(1) && (eLog() << Verbose(1) << "Unknown format:" << *iter << endl);
+    }
-    ChangeTracker::getInstance().saveStatus();
-    delete dialog;
-    return Action::success;
-  } else {
-    delete dialog;
-    return Action::failure;
+  }
+  ChangeTracker::getInstance().saveStatus();
+  return Action::success;
+}

src/Actions/WorldAction/SetOutputFormatsAction.hpp

-              r7067bd6
+              r677e13
 #include "Actions/Action.hpp"
+#include <vector>
+void WorldSetOutputFormats(std::vector<std::string> &FormatList);
 class WorldSetOutputFormatsAction : public Action {
+  friend void WorldSetOutputFormats(std::vector<std::string> &FormatList);
 public:
   WorldSetOutputFormatsAction();
 …
   virtual const std::string getName();
 private:
+  virtual Dialog * createDialog();
   virtual Action::state_ptr performCall();
   virtual Action::state_ptr performUndo(Action::state_ptr);

src/Box.cpp

-              r7067bd6
+              r677e13
   return translateIn(helper);
+}
+bool Box::isInside(const Vector &point) const
+{
+  bool result = true;
+  Vector tester = (*Minv) * point;
+  for(int i=0;i<NDIM;i++)
+    result = result && ((tester[i] >= -MYEPSILON) && ((tester[i] - 1.) < MYEPSILON));
+  return result;
+}
 VECTORSET(std::list) Box::explode(const Vector &point,int n) const{

src/Box.hpp

-              r7067bd6
+              r677e13
   /**
+   * Checks whether a given vector is inside the box.
+   */
+  bool isInside(const Vector &point) const;
+  /**
    * Produce corresponding points in several adjacent boxes.
+   *

src/CommandLineParser.cpp

r7067bd6	r677e13
41	41	void CommandLineParser::Parse()
42	42	{
43		po::store(po::command_line_parser(argc,argv).options(cmdline_options).~~options(visible).~~run(), vm);
	43	po::store(po::command_line_parser(argc,argv).options(cmdline_options).run(), vm);
44	44	ifstream input;
45	45	input.open("example.cfg");

src/Makefile.am

-              r7067bd6
+              r677e13
 EXCEPTIONSOURCE = \
   Exceptions/CustomException.cpp \
+  Exceptions/IllegalTypeException.cpp \
   Exceptions/LinearDependenceException.cpp \
   Exceptions/MathException.cpp \
+  Exceptions/MissingValueException.cpp \
   Exceptions/NotInvertibleException.cpp \
   Exceptions/ParseError.cpp \
 …
 EXCEPTIONHEADER = \
   Exceptions/CustomException.hpp \
+  Exceptions/IllegalTypeException.hpp \
   Exceptions/LinearDependenceException.hpp \
   Exceptions/MathException.hpp \
+  Exceptions/MissingValueException.hpp \
   Exceptions/NotInvertibleException.hpp \
   Exceptions/ParseError.hpp \
 …
 QTUIMOC_HEADER = UIElements/QT4/QTDialog.hpp \
                                  UIElements/QT4/QTMainWindow.hpp \
                                  UIElements/Menu/QT4/QTMenu.hpp \
                                  UIElements/Views/QT4/QTWorldView.hpp \
                                  UIElements/Views/QT4/GLMoleculeView.hpp \
                                  UIElements/Views/QT4/QTMoleculeView.hpp \
                                  UIElements/Views/QT4/QTStatusBar.hpp
+        UIElements/QT4/QTMainWindow.hpp \
+        UIElements/Menu/QT4/QTMenu.hpp \
+        UIElements/Views/QT4/QTWorldView.hpp \
+        UIElements/Views/QT4/GLMoleculeView.hpp \
+        UIElements/Views/QT4/QTMoleculeView.hpp \
+        UIElements/Views/QT4/QTStatusBar.hpp
 QTUIMOC_TARGETS = QTMainWindow.moc.cpp \
                       QTMenu.moc.cpp\
                       QTDialog.moc.cpp \
                       QTWorldView.moc.cpp \
                       GLMoleculeView.moc.cpp \
                       QTMoleculeView.moc.cpp \
                       QTStatusBar.moc.cpp
+        QTMenu.moc.cpp\
+        QTDialog.moc.cpp \
+        QTWorldView.moc.cpp \
+        GLMoleculeView.moc.cpp \
+        QTMoleculeView.moc.cpp \
+        QTStatusBar.moc.cpp
 DESCRIPTORSOURCE = Descriptors/AtomDescriptor.cpp \
 …
 QTUISOURCE = ${QTUIMOC_TARGETS} \
                          UIElements/QT4/QTMainWindow.cpp \
                          UIElements/QT4/QTDialog.cpp \
                          UIElements/QT4/QTUIFactory.cpp \
                          UIElements/Menu/QT4/QTMenu.cpp \
                          UIElements/Views/QT4/QTWorldView.cpp \
                          UIElements/Views/QT4/GLMoleculeView.cpp \
                          UIElements/Views/QT4/QTMoleculeView.cpp \
                          UIElements/Views/QT4/QTStatusBar.cpp
+        UIElements/QT4/QTMainWindow.cpp \
+        UIElements/QT4/QTDialog.cpp \
+        UIElements/QT4/QTUIFactory.cpp \
+        UIElements/Menu/QT4/QTMenu.cpp \
+        UIElements/Views/QT4/QTWorldView.cpp \
+        UIElements/Views/QT4/GLMoleculeView.cpp \
+        UIElements/Views/QT4/QTMoleculeView.cpp \
+        UIElements/Views/QT4/QTStatusBar.cpp
 QTUIHEADER = ${QTUIMOC_HEADER} UIElements/QT4/QTUIFactory.hpp

src/UIElements/CommandLineUI/CommandLineDialog.cpp

-              r7067bd6
+              r677e13
 #include "defs.hpp"
 #include "log.hpp"
+#include "Matrix.hpp"
 #include "periodentafel.hpp"
 #include "verbose.hpp"
 …
+}
+void CommandLineDialog::queryInt(const char* title, int* target, string _description){
+  registerQuery(new IntCommandLineQuery(title,target, _description));
+}
+void CommandLineDialog::queryBoolean(const char* title, bool* target, string _description){
+  registerQuery(new BooleanCommandLineQuery(title,target, _description));
+}
+void CommandLineDialog::queryDouble(const char* title, double* target, string _description){
+  registerQuery(new DoubleCommandLineQuery(title,target, _description));
+}
+void CommandLineDialog::queryString(const char* title, string* target, string _description){
+  registerQuery(new StringCommandLineQuery(title,target, _description));
+}
+void CommandLineDialog::queryStrings(const char* title, vector<string> * target, string _description){
+  registerQuery(new StringsCommandLineQuery(title,target, _description));
+}
+void CommandLineDialog::queryAtom(const char* title, atom **target, string _description) {
+  registerQuery(new AtomCommandLineQuery(title,target, _description));
+}
+void CommandLineDialog::queryMolecule(const char* title, molecule **target, string _description) {
+  registerQuery(new MoleculeCommandLineQuery(title,target, _description));
+}
+void CommandLineDialog::queryVector(const char* title, Vector *target, bool check, string _description) {
+  registerQuery(new VectorCommandLineQuery(title,target,check, _description));
+}
+void CommandLineDialog::queryBox(const char* title, Box* cellSize, string _description) {
+  registerQuery(new BoxCommandLineQuery(title,cellSize,_description));
+}
+void CommandLineDialog::queryElement(const char* title, std::vector<element *> *target, string _description){
+  registerQuery(new ElementCommandLineQuery(title,target, _description));
+void CommandLineDialog::queryInt(const char* title, string _description){
+  registerQuery(new IntCommandLineQuery(title, _description));
+}
+void CommandLineDialog::queryInts(const char* title, string _description){
+  registerQuery(new IntsCommandLineQuery(title, _description));
+}
+void CommandLineDialog::queryBoolean(const char* title, string _description){
+  registerQuery(new BooleanCommandLineQuery(title, _description));
+}
+void CommandLineDialog::queryDouble(const char* title, string _description){
+  registerQuery(new DoubleCommandLineQuery(title, _description));
+}
+void CommandLineDialog::queryDoubles(const char* title, string _description){
+  registerQuery(new DoublesCommandLineQuery(title, _description));
+}
+void CommandLineDialog::queryString(const char* title, string _description){
+  registerQuery(new StringCommandLineQuery(title, _description));
+}
+void CommandLineDialog::queryStrings(const char* title, string _description){
+  registerQuery(new StringsCommandLineQuery(title, _description));
+}
+void CommandLineDialog::queryAtom(const char* title, string _description) {
+  registerQuery(new AtomCommandLineQuery(title, _description));
+}
+void CommandLineDialog::queryAtoms(const char* title, string _description) {
+  registerQuery(new AtomsCommandLineQuery(title, _description));
+}
+void CommandLineDialog::queryMolecule(const char* title, string _description) {
+  registerQuery(new MoleculeCommandLineQuery(title, _description));
+}
+void CommandLineDialog::queryMolecules(const char* title, string _description) {
+  registerQuery(new MoleculesCommandLineQuery(title, _description));
+}
+void CommandLineDialog::queryVector(const char* title, bool check, string _description) {
+  registerQuery(new VectorCommandLineQuery(title,check, _description));
+}
+void CommandLineDialog::queryVectors(const char* title, bool check, string _description) {
+  registerQuery(new VectorsCommandLineQuery(title,check, _description));
+}
+void CommandLineDialog::queryBox(const char* title, string _description) {
+  registerQuery(new BoxCommandLineQuery(title,_description));
+}
+void CommandLineDialog::queryElement(const char* title, string _description){
+  registerQuery(new ElementCommandLineQuery(title, _description));
+}
+void CommandLineDialog::queryElements(const char* title, string _description){
+  registerQuery(new ElementsCommandLineQuery(title, _description));
+}
 …
+}
 CommandLineDialog::IntCommandLineQuery::IntCommandLineQuery(string title,int *_target, string _description) :
     Dialog::IntQuery(title,_target, _description)
+CommandLineDialog::IntCommandLineQuery::IntCommandLineQuery(string title, string _description) :
+    Dialog::IntQuery(title, _description)
 {}
 …
+}
+CommandLineDialog::BooleanCommandLineQuery::BooleanCommandLineQuery(string title,bool *_target, string _description) :
+    Dialog::BooleanQuery(title,_target, _description)
+CommandLineDialog::IntsCommandLineQuery::IntsCommandLineQuery(string title, string _description) :
+    Dialog::IntsQuery(title, _description)
+{}
+CommandLineDialog::IntsCommandLineQuery::~IntsCommandLineQuery() {}
+bool CommandLineDialog::IntsCommandLineQuery::handle() {
+  if (CommandLineParser::getInstance().vm.count(getTitle())) {
+    tmp = CommandLineParser::getInstance().vm[getTitle()].as< std::vector<int> >();
+    return true;
+  } else {
+    DoeLog(1) && (eLog() << Verbose(1) << "CommandLineUI parsing error: Missing integers for " << getTitle() << "." << endl);
+    return false;
+  }
+}
+CommandLineDialog::BooleanCommandLineQuery::BooleanCommandLineQuery(string title, string _description) :
+    Dialog::BooleanQuery(title, _description)
 {}
 …
+}
 CommandLineDialog::StringCommandLineQuery::StringCommandLineQuery(string title,string *_target, string _description) :
     Dialog::StringQuery(title,_target, _description)
+CommandLineDialog::StringCommandLineQuery::StringCommandLineQuery(string title, string _description) :
+    Dialog::StringQuery(title, _description)
 {}
 …
+}
 CommandLineDialog::StringsCommandLineQuery::StringsCommandLineQuery(string title,vector<string> *_target, string _description) :
     Dialog::StringsQuery(title,_target, _description)
+CommandLineDialog::StringsCommandLineQuery::StringsCommandLineQuery(string title, string _description) :
+    Dialog::StringsQuery(title, _description)
 {}
 …
     return true;
   } else {
     DoeLog(1) && (eLog() << Verbose(1) << "CommandLineUI parsing error: Missing string for " << getTitle() << "." << endl);
     return false;
+  }
+}
 CommandLineDialog::DoubleCommandLineQuery::DoubleCommandLineQuery(string title,double *_target, string _description) :
     Dialog::DoubleQuery(title,_target, _description)
+    DoeLog(1) && (eLog() << Verbose(1) << "CommandLineUI parsing error: Missing strings for " << getTitle() << "." << endl);
+    return false;
+  }
+}
+CommandLineDialog::DoubleCommandLineQuery::DoubleCommandLineQuery(string title, string _description) :
+    Dialog::DoubleQuery(title, _description)
 {}
 …
+}
+CommandLineDialog::AtomCommandLineQuery::AtomCommandLineQuery(string title, atom **_target, string _description) :
+    Dialog::AtomQuery(title,_target, _description)
+CommandLineDialog::DoublesCommandLineQuery::DoublesCommandLineQuery(string title, string _description) :
+    Dialog::DoublesQuery(title, _description)
+{}
+CommandLineDialog::DoublesCommandLineQuery::~DoublesCommandLineQuery() {}
+bool CommandLineDialog::DoublesCommandLineQuery::handle() {
+  if (CommandLineParser::getInstance().vm.count(getTitle())) {
+    tmp = CommandLineParser::getInstance().vm[getTitle()].as< std::vector<double> >();
+    return true;
+  } else {
+    DoeLog(1) && (eLog() << Verbose(1) << "CommandLineUI parsing error: Missing doubles for " << getTitle() << "." << endl);
+    return false;
+  }
+}
+CommandLineDialog::AtomCommandLineQuery::AtomCommandLineQuery(string title, string _description) :
+    Dialog::AtomQuery(title, _description)
 {}
 …
+}
+CommandLineDialog::MoleculeCommandLineQuery::MoleculeCommandLineQuery(string title, molecule **_target, string _description) :
+    Dialog::MoleculeQuery(title,_target, _description)
+CommandLineDialog::AtomsCommandLineQuery::AtomsCommandLineQuery(string title, string _description) :
+    Dialog::AtomsQuery(title, _description)
+{}
+CommandLineDialog::AtomsCommandLineQuery::~AtomsCommandLineQuery() {}
+bool CommandLineDialog::AtomsCommandLineQuery::handle() {
+  std::vector<int> IdxOfAtom;
+  if (CommandLineParser::getInstance().vm.count(getTitle())) {
+    IdxOfAtom = CommandLineParser::getInstance().vm[getTitle()].as< std::vector<int> >();
+    for (std::vector<int>::iterator iter = IdxOfAtom.begin(); iter != IdxOfAtom.end(); ++iter) {
+      temp = World::getInstance().getAtom(AtomById(*iter));
+      if (temp)
+        tmp.push_back(temp);
+    }
+    return true;
+  } else {
+    DoeLog(1) && (eLog() << Verbose(1) << "CommandLineUI parsing error: Missing atoms for " << getTitle() << "." << endl);
+    return false;
+  }
+}
+CommandLineDialog::MoleculeCommandLineQuery::MoleculeCommandLineQuery(string title, string _description) :
+    Dialog::MoleculeQuery(title, _description)
 {}
 …
   if (CommandLineParser::getInstance().vm.count(getTitle())) {
     IdxOfMol = CommandLineParser::getInstance().vm[getTitle()].as<int>();
+    cout << "IdxOfMol " << IdxOfMol << endl;
+    if (IdxOfMol >= 0)
+      tmp = World::getInstance().getMolecule(MoleculeById(IdxOfMol));
+    else
+      tmp = NULL;
+    tmp = World::getInstance().getMolecule(MoleculeById(IdxOfMol));
     return true;
   } else {
 …
+}
+CommandLineDialog::VectorCommandLineQuery::VectorCommandLineQuery(string title, Vector *_target, bool _check, string _description) :
+    Dialog::VectorQuery(title,_target,_check, _description)
+CommandLineDialog::MoleculesCommandLineQuery::MoleculesCommandLineQuery(string title, string _description) :
+    Dialog::MoleculesQuery(title, _description)
+{}
+CommandLineDialog::MoleculesCommandLineQuery::~MoleculesCommandLineQuery() {}
+bool CommandLineDialog::MoleculesCommandLineQuery::handle() {
+  std::vector<int> IdxOfMol;
+  if (CommandLineParser::getInstance().vm.count(getTitle())) {
+    IdxOfMol = CommandLineParser::getInstance().vm[getTitle()].as< std::vector<int> >();
+    for (std::vector<int>::iterator iter = IdxOfMol.begin(); iter != IdxOfMol.end(); ++iter) {
+      temp = World::getInstance().getMolecule(MoleculeById(*iter));
+      if (temp)
+        tmp.push_back(temp);
+    }
+    return true;
+  } else {
+    DoeLog(1) && (eLog() << Verbose(1) << "CommandLineUI parsing error: Missing molecules for " << getTitle() << "." << endl);
+    return false;
+  }
+}
+CommandLineDialog::VectorCommandLineQuery::VectorCommandLineQuery(string title, bool _check, string _description) :
+    Dialog::VectorQuery(title,_check, _description)
 {}
 …
   if (CommandLineParser::getInstance().vm.count(getTitle())) {
     temp = CommandLineParser::getInstance().vm[getTitle()].as< VectorValue >();
+    tmp->at(0) = temp.x;
+    tmp->at(1) = temp.y;
+    tmp->at(2) = temp.z;
+    tmp[0] = temp.x;
+    tmp[1] = temp.y;
+    tmp[2] = temp.z;
+    if ((check) && (!World::getInstance().getDomain().isInside(tmp))) {
+      DoeLog(1) && (eLog() << Verbose(1) << "Vector " << tmp << " would be outside of box domain." << endl);
+      return false;
+    }
     return true;
   } else {
 …
+}
+CommandLineDialog::BoxCommandLineQuery::BoxCommandLineQuery(string title, Box* _cellSize, string _description) :
+    Dialog::BoxQuery(title,_cellSize, _description)
+CommandLineDialog::VectorsCommandLineQuery::VectorsCommandLineQuery(string title, bool _check, string _description) :
+    Dialog::VectorsQuery(title,_check, _description)
+{}
+CommandLineDialog::VectorsCommandLineQuery::~VectorsCommandLineQuery()
+{}
+bool CommandLineDialog::VectorsCommandLineQuery::handle() {
+  std::vector<VectorValue> temporary;
+  if (CommandLineParser::getInstance().vm.count(getTitle())) {
+    temporary = CommandLineParser::getInstance().vm[getTitle()].as< std::vector<VectorValue> >();
+    for(std::vector<VectorValue>::iterator iter = temporary.begin(); iter != temporary.end(); ++iter) {
+      temp[0] = (*iter).x;
+      temp[1] = (*iter).y;
+      temp[2] = (*iter).z;
+      if ((!check) || (World::getInstance().getDomain().isInside(temp)))
+        tmp.push_back(temp);
+      else
+        DoeLog(1) && (eLog() << Verbose(1) << "Vector " << temp << " would be outside of box domain." << endl);
+    }
+    return true;
+  } else {
+    DoeLog(1) && (eLog() << Verbose(1) << "CommandLineUI parsing error: Missing vectors for " << getTitle() << "." << endl);
+    return false;
+  }
+}
+CommandLineDialog::BoxCommandLineQuery::BoxCommandLineQuery(string title, string _description) :
+    Dialog::BoxQuery(title, _description)
 {}
 …
   if (CommandLineParser::getInstance().vm.count(getTitle())) {
     temp = CommandLineParser::getInstance().vm[getTitle()].as< BoxValue >();
+    tmp[0] = temp.xx;
+    tmp[1] = temp.xy;
+    tmp[2] = temp.xz;
+    tmp[3] = temp.yy;
+    tmp[4] = temp.yz;
+    tmp[5] = temp.zz;
+    Matrix M;
+    M.set(0,0, temp.xx);
+    M.set(0,1, temp.yx);
+    M.set(0,2, temp.zx);
+    M.set(1,0, temp.yx);
+    M.set(1,1, temp.yy);
+    M.set(1,2, temp.zy);
+    M.set(2,0, temp.zx);
+    M.set(2,1, temp.zy);
+    M.set(2,2, temp.zz);
+    tmp.setM(M);
     return true;
   } else {
 …
+}
 CommandLineDialog::ElementCommandLineQuery::ElementCommandLineQuery(string title, std::vector<element *> *target, string _description) :
     Dialog::ElementQuery(title,target, _description)
+CommandLineDialog::ElementCommandLineQuery::ElementCommandLineQuery(string title, string _description) :
+    Dialog::ElementQuery(title, _description)
 {}
 …
   // TODO: vector of ints and removing first is not correctly implemented yet. How to remove from a vector?
   periodentafel *periode = World::getInstance().getPeriode();
+  element *elemental = NULL;
+  if (CommandLineParser::getInstance().vm.count(getTitle())) {
+    int Z = CommandLineParser::getInstance().vm[getTitle()].as< int >();
+    tmp = periode->FindElement(Z);
+    ASSERT(tmp != NULL, "Invalid element specified in ElementCommandLineQuery");
+    return true;
+  } else {
+    DoeLog(1) && (eLog() << Verbose(1) << "CommandLineUI parsing error: Missing element for " << getTitle() << "." << endl);
+    return false;
+  }
+}
+CommandLineDialog::ElementsCommandLineQuery::ElementsCommandLineQuery(string title, string _description) :
+    Dialog::ElementsQuery(title, _description)
+{}
+CommandLineDialog::ElementsCommandLineQuery::~ElementsCommandLineQuery()
+{}
+bool CommandLineDialog::ElementsCommandLineQuery::handle() {
+  // TODO: vector of ints and removing first is not correctly implemented yet. How to remove from a vector?
+  periodentafel *periode = World::getInstance().getPeriode();
   if (CommandLineParser::getInstance().vm.count(getTitle())) {
     vector<int> AllElements = CommandLineParser::getInstance().vm[getTitle()].as< vector<int> >();
     for (vector<int>::iterator ZRunner = AllElements.begin(); ZRunner != AllElements.end(); ++ZRunner) {
       elemental = periode->FindElement(*ZRunner);
       ASSERT(elemental != NULL, "Invalid element specified in ElementCommandLineQuery");
       elements.push_back(elemental);
+      temp = periode->FindElement(*ZRunner);
+      ASSERT(temp != NULL, "Invalid element specified in ElementCommandLineQuery");
+      tmp.push_back(temp);
+    }
     return true;
   } else {
     DoeLog(1) && (eLog() << Verbose(1) << "CommandLineUI parsing error: Missing element for " << getTitle() << "." << endl);
     return false;
+  }
+}
+    DoeLog(1) && (eLog() << Verbose(1) << "CommandLineUI parsing error: Missing elements for " << getTitle() << "." << endl);
+    return false;
+  }
+}

src/UIElements/CommandLineUI/CommandLineDialog.hpp

-              r7067bd6
+              r677e13
   virtual void queryEmpty(const char *, std::string = "");
+  virtual void queryInt(const char *, int *, std::string = "");
+  virtual void queryBoolean(const char *, bool *, std::string = "");
+  virtual void queryString(const char*, std::string *, std::string = "");
+  virtual void queryStrings(const char*, std::vector<std::string> *, std::string = "");
+  virtual void queryDouble(const char*, double*, std::string = "");
+  virtual void queryAtom(const char*,atom**, std::string = "");
+  virtual void queryMolecule(const char*,molecule**,std::string = "");
+  virtual void queryVector(const char*,Vector *,bool, std::string = "");
+  virtual void queryBox(const char*,Box *, std::string = "");
+  virtual void queryElement(const char*, std::vector<element *> *, std::string = "");
+  virtual void queryInt(const char *, std::string = "");
+  virtual void queryInts(const char *, std::string = "");
+  virtual void queryBoolean(const char *, std::string = "");
+  virtual void queryString(const char*, std::string = "");
+  virtual void queryStrings(const char*, std::string = "");
+  virtual void queryDouble(const char*, std::string = "");
+  virtual void queryDoubles(const char*, std::string = "");
+  virtual void queryAtom(const char*, std::string = "");
+  virtual void queryAtoms(const char*, std::string = "");
+  virtual void queryMolecule(const char*, std::string = "");
+  virtual void queryMolecules(const char*, std::string = "");
+  virtual void queryVector(const char*, bool, std::string = "");
+  virtual void queryVectors(const char*, bool, std::string = "");
+  virtual void queryBox(const char*, std::string = "");
+  virtual void queryElement(const char*, std::string = "");
+  virtual void queryElements(const char*, std::string = "");
 protected:
 …
   class IntCommandLineQuery : public Dialog::IntQuery {
   public:
     IntCommandLineQuery(std::string title, int *_target, std::string _description = "");
+    IntCommandLineQuery(std::string title, std::string _description = "");
     virtual ~IntCommandLineQuery();
+    virtual bool handle();
+  };
+  class IntsCommandLineQuery : public Dialog::IntsQuery {
+  public:
+    IntsCommandLineQuery(std::string title, std::string _description = "");
+    virtual ~IntsCommandLineQuery();
     virtual bool handle();
   };
 …
   class BooleanCommandLineQuery : public Dialog::BooleanQuery {
   public:
     BooleanCommandLineQuery(std::string title, bool *_target, std::string _description = "");
+    BooleanCommandLineQuery(std::string title, std::string _description = "");
     virtual ~BooleanCommandLineQuery();
     virtual bool handle();
 …
   class DoubleCommandLineQuery : public Dialog::DoubleQuery {
   public:
     DoubleCommandLineQuery(std::string title, double *_target, std::string _description = "");
+    DoubleCommandLineQuery(std::string title, std::string _description = "");
     virtual ~DoubleCommandLineQuery();
+    virtual bool handle();
+  };
+  class DoublesCommandLineQuery : public Dialog::DoublesQuery {
+  public:
+    DoublesCommandLineQuery(std::string title, std::string _description = "");
+    virtual ~DoublesCommandLineQuery();
     virtual bool handle();
   };
 …
   class StringCommandLineQuery : public Dialog::StringQuery {
   public:
     StringCommandLineQuery(std::string title, std::string *_target, std::string _description = "");
+    StringCommandLineQuery(std::string title, std::string _description = "");
     virtual ~StringCommandLineQuery();
     virtual bool handle();
 …
   class StringsCommandLineQuery : public Dialog::StringsQuery {
   public:
     StringsCommandLineQuery(std::string title, std::vector<std::string> *_target, std::string _description = "");
+    StringsCommandLineQuery(std::string title, std::string _description = "");
     virtual ~StringsCommandLineQuery();
     virtual bool handle();
 …
   class AtomCommandLineQuery : public Dialog::AtomQuery {
   public:
     AtomCommandLineQuery(std::string title, atom **_target, std::string _description = "");
+    AtomCommandLineQuery(std::string title, std::string _description = "");
     virtual ~AtomCommandLineQuery();
+    virtual bool handle();
+  };
+  class AtomsCommandLineQuery : public Dialog::AtomsQuery {
+  public:
+    AtomsCommandLineQuery(std::string title, std::string _description = "");
+    virtual ~AtomsCommandLineQuery();
     virtual bool handle();
   };
 …
   class MoleculeCommandLineQuery : public Dialog::MoleculeQuery {
   public:
     MoleculeCommandLineQuery(std::string title, molecule **_target, std::string _description = "");
+    MoleculeCommandLineQuery(std::string title, std::string _description = "");
     virtual ~MoleculeCommandLineQuery();
+    virtual bool handle();
+  };
+  class MoleculesCommandLineQuery : public Dialog::MoleculesQuery {
+  public:
+    MoleculesCommandLineQuery(std::string title, std::string _description = "");
+    virtual ~MoleculesCommandLineQuery();
     virtual bool handle();
   };
 …
   class VectorCommandLineQuery : public Dialog::VectorQuery {
   public:
     VectorCommandLineQuery(std::string title,Vector *_target,bool _check, std::string _description = "");
+    VectorCommandLineQuery(std::string title,bool _check, std::string _description = "");
     virtual ~VectorCommandLineQuery();
+    virtual bool handle();
+  };
+  class VectorsCommandLineQuery : public Dialog::VectorsQuery {
+  public:
+    VectorsCommandLineQuery(std::string title,bool _check, std::string _description = "");
+    virtual ~VectorsCommandLineQuery();
     virtual bool handle();
   };
 …
   class BoxCommandLineQuery : public Dialog::BoxQuery {
   public:
     BoxCommandLineQuery(std::string title,Box* _cellSize, std::string _description = "");
+    BoxCommandLineQuery(std::string title, std::string _description = "");
     virtual ~BoxCommandLineQuery();
     virtual bool handle();
 …
   class ElementCommandLineQuery : public Dialog::ElementQuery {
   public:
     ElementCommandLineQuery(std::string title, std::vector<element *> *_target, std::string _description = "");
+    ElementCommandLineQuery(std::string title, std::string _description = "");
     virtual ~ElementCommandLineQuery();
+    virtual bool handle();
+  };
+  class ElementsCommandLineQuery : public Dialog::ElementsQuery {
+  public:
+    ElementsCommandLineQuery(std::string title, std::string _description = "");
+    virtual ~ElementsCommandLineQuery();
     virtual bool handle();
   };

src/UIElements/Dialog.cpp

-              r7067bd6
+              r677e13
 #include "Dialog.hpp"
+#include "ValueStorage.hpp"
 #include "verbose.hpp"
 …
 // Int Queries
 Dialog::IntQuery::IntQuery(string title,int *_target, std::string description) :
     Query(title, description), target(_target)
+Dialog::IntQuery::IntQuery(string title, std::string description) :
+    Query(title, description)
 {}
 …
 void Dialog::IntQuery::setResult() {
+  *target = tmp;
+}
+// Int Queries
+Dialog::BooleanQuery::BooleanQuery(string title,bool *_target, std::string description) :
+    Query(title, description), target(_target)
+  ValueStorage::getInstance().setCurrentValue(title.c_str(), tmp);
+}
+// Ints Queries
+Dialog::IntsQuery::IntsQuery(string title, std::string description) :
+    Query(title, description)
+{}
+Dialog::IntsQuery::~IntsQuery() {}
+void Dialog::IntsQuery::setResult() {
+  ValueStorage::getInstance().setCurrentValue(title.c_str(), tmp);
+}
+// Bool Queries
+Dialog::BooleanQuery::BooleanQuery(string title,std::string description) :
+    Query(title, description)
 {}
 …
 void Dialog::BooleanQuery::setResult() {
   *target = tmp;
+  ValueStorage::getInstance().setCurrentValue(title.c_str(), tmp);
+}
 // String Queries
 Dialog::StringQuery::StringQuery(string title,string *_target, std::string _description) :
     Query(title, _description), target(_target)
+Dialog::StringQuery::StringQuery(string title,std::string _description) :
+    Query(title, _description)
 {}
 …
 void Dialog::StringQuery::setResult() {
   *target = tmp;
+  ValueStorage::getInstance().setCurrentValue(title.c_str(), tmp);
+}
 // Strings Queries
 Dialog::StringsQuery::StringsQuery(string title,vector<string> *_target, std::string _description) :
     Query(title, _description), target(_target)
+Dialog::StringsQuery::StringsQuery(string title,std::string _description) :
+    Query(title, _description)
 {}
 …
 void Dialog::StringsQuery::setResult() {
   *target = tmp;
+  ValueStorage::getInstance().setCurrentValue(title.c_str(), tmp);
+}
 // Double Queries
 Dialog::DoubleQuery::DoubleQuery(string title,double *_target, std::string _description) :
     Query(title, _description), target(_target)
+Dialog::DoubleQuery::DoubleQuery(string title, std::string _description) :
+    Query(title, _description)
 {}
 …
 void Dialog::DoubleQuery::setResult() {
+  *target = tmp;
+  ValueStorage::getInstance().setCurrentValue(title.c_str(), tmp);
+}
+// Doubles Queries
+Dialog::DoublesQuery::DoublesQuery(string title, std::string _description) :
+    Query(title, _description)
+{}
+Dialog::DoublesQuery::~DoublesQuery() {};
+void Dialog::DoublesQuery::setResult() {
+  ValueStorage::getInstance().setCurrentValue(title.c_str(), tmp);
+}
 …
 // Atom Queries
+Dialog::AtomQuery::AtomQuery(string title, atom **_target, std::string _description) :
+    Query(title, _description),
+    tmp(0),
+    target(_target)
+Dialog::AtomQuery::AtomQuery(string title, std::string _description) :
+    Query(title, _description),
+    tmp(0)
 {}
 …
 void Dialog::AtomQuery::setResult() {
+  *target = tmp;
+  ValueStorage::getInstance().setCurrentValue(title.c_str(), tmp);
+}
+// Atoms Queries
+Dialog::AtomsQuery::AtomsQuery(string title, std::string _description) :
+    Query(title, _description),
+    tmp(0)
+{}
+Dialog::AtomsQuery::~AtomsQuery() {}
+void Dialog::AtomsQuery::setResult() {
+  ValueStorage::getInstance().setCurrentValue(title.c_str(), tmp);
+}
 // Molecule Queries
+Dialog::MoleculeQuery::MoleculeQuery(string title, molecule **_target, std::string _description) :
+    Query(title, _description),
+    tmp(0),
+    target(_target)
+Dialog::MoleculeQuery::MoleculeQuery(string title, std::string _description) :
+    Query(title, _description),
+    tmp(0)
 {}
 …
 void Dialog::MoleculeQuery::setResult() {
+  *target = tmp;
+  ValueStorage::getInstance().setCurrentValue(title.c_str(), tmp);
+}
+// Molecules Queries
+Dialog::MoleculesQuery::MoleculesQuery(string title, std::string _description) :
+    Query(title, _description),
+    tmp(0)
+{}
+Dialog::MoleculesQuery::~MoleculesQuery() {}
+void Dialog::MoleculesQuery::setResult() {
+  ValueStorage::getInstance().setCurrentValue(title.c_str(), tmp);
+}
 // Vector Queries
 Dialog::VectorQuery::VectorQuery(std::string title,Vector *_target,bool _check, std::string _description) :
+Dialog::VectorQuery::VectorQuery(std::string title,bool _check, std::string _description) :
   Query(title, _description),
+  check(_check),
+  target(_target)
+{
+  tmp = new Vector();
+}
+  check(_check)
+{}
 Dialog::VectorQuery::~VectorQuery()
+{
+  delete tmp;
+}
+{}
 void Dialog::VectorQuery::setResult() {
+  *target = *tmp;
+  ValueStorage::getInstance().setCurrentValue(title.c_str(), tmp);
+}
+// Vectors Queries
+Dialog::VectorsQuery::VectorsQuery(std::string title,bool _check, std::string _description) :
+  Query(title, _description),
+  check(_check)
+{}
+Dialog::VectorsQuery::~VectorsQuery()
+{}
+void Dialog::VectorsQuery::setResult() {
+  ValueStorage::getInstance().setCurrentValue(title.c_str(), tmp);
+}
 // Box Queries
+Dialog::BoxQuery::BoxQuery(std::string title, Box* _cellSize, std::string _description) :
+  Query(title, _description),
+  target(_cellSize)
+{
+    tmp = new double[6];
+}
+Dialog::BoxQuery::BoxQuery(std::string title, std::string _description) :
+  Query(title, _description)
+{}
 Dialog::BoxQuery::~BoxQuery()
+{
+  delete[] tmp;
+}
+{}
 void Dialog::BoxQuery::setResult() {
   (*target)= ReturnFullMatrixforSymmetric(tmp);
+  ValueStorage::getInstance().setCurrentValue(title.c_str(), tmp);
+}
 // Element Queries
+Dialog::ElementQuery::ElementQuery(std::string title, std::vector<element *> *_target, std::string _description) :
+  Query(title, _description),
+  target(_target)
+Dialog::ElementQuery::ElementQuery(std::string title, std::string _description) :
+  Query(title, _description)
   {}
 …
 void Dialog::ElementQuery::setResult(){
+  *target=elements;
+}
+  ValueStorage::getInstance().setCurrentValue(title.c_str(), tmp);
+}
+// Elements Queries
+Dialog::ElementsQuery::ElementsQuery(std::string title, std::string _description) :
+  Query(title, _description)
+  {}
+Dialog::ElementsQuery::~ElementsQuery(){}
+void Dialog::ElementsQuery::setResult(){
+  ValueStorage::getInstance().setCurrentValue(title.c_str(), tmp);
+}

src/UIElements/Dialog.hpp

-              r7067bd6
+              r677e13
 #include<vector>
+#include "Box.hpp"
+#include "vector.hpp"
 class atom;
 class Box;
 class element;
 class molecule;
-class Vector;
 …
   virtual void queryEmpty(const char *, std::string = "")=0;
+  virtual void queryBoolean(const char *, bool *, std::string = "")=0;
+  virtual void queryInt(const char *, int *, std::string = "")=0;
+  virtual void queryDouble(const char*,double *, std::string = "")=0;
+  virtual void queryString(const char*, std::string *, std::string = "")=0;
+  virtual void queryStrings(const char*, std::vector<std::string> *, std::string = "")=0;
+  virtual void queryAtom(const char*,atom**,std::string = "")=0;
+  virtual void queryMolecule(const char*,molecule**, std::string = "")=0;
+  virtual void queryVector(const char*,Vector *,bool, std::string = "")=0;
+  virtual void queryBox(const char*,Box*, std::string = "")=0;
+  virtual void queryElement(const char*, std::vector<element *> *, std::string = "")=0;
+  virtual void queryBoolean(const char *, std::string = "")=0;
+  virtual void queryInt(const char *, std::string = "")=0;
+  virtual void queryInts(const char *, std::string = "")=0;
+  virtual void queryDouble(const char*, std::string = "")=0;
+  virtual void queryDoubles(const char*, std::string = "")=0;
+  virtual void queryString(const char*, std::string = "")=0;
+  virtual void queryStrings(const char*, std::string = "")=0;
+  virtual void queryAtom(const char*,std::string = "")=0;
+  virtual void queryAtoms(const char*,std::string = "")=0;
+  virtual void queryMolecule(const char*, std::string = "")=0;
+  virtual void queryMolecules(const char*, std::string = "")=0;
+  virtual void queryVector(const char*,bool, std::string = "")=0;
+  virtual void queryVectors(const char*,bool, std::string = "")=0;
+  virtual void queryBox(const char*, std::string = "")=0;
+  virtual void queryElement(const char*, std::string = "")=0;
+  virtual void queryElements(const char*, std::string = "")=0;
   virtual bool display();
 …
   class BooleanQuery : public Query {
   public:
     BooleanQuery(std::string title,bool *_target, std::string _description = "");
+    BooleanQuery(std::string title, std::string _description = "");
     virtual ~BooleanQuery();
     virtual bool handle()=0;
 …
   protected:
     bool tmp;
-  private:
-    bool *target;
   };
   class IntQuery : public Query {
   public:
     IntQuery(std::string title,int *_target, std::string _description = "");
+    IntQuery(std::string title, std::string _description = "");
     virtual ~IntQuery();
     virtual bool handle()=0;
 …
   protected:
     int tmp;
+  private:
+    int *target;
+  };
+  class IntsQuery : public Query {
+  public:
+    IntsQuery(std::string title, std::string _description = "");
+    virtual ~IntsQuery();
+    virtual bool handle()=0;
+    virtual void setResult();
+  protected:
+    int temp;
+    std::vector<int> tmp;
   };
   class DoubleQuery : public Query {
   public:
     DoubleQuery(std::string title,double *_target, std::string _description = "");
+    DoubleQuery(std::string title, std::string _description = "");
     virtual ~DoubleQuery();
     virtual bool handle()=0;
 …
   protected:
     double tmp;
+  private:
+    double *target;
+  };
+  class DoublesQuery : public Query {
+  public:
+    DoublesQuery(std::string title, std::string _description = "");
+    virtual ~DoublesQuery();
+    virtual bool handle()=0;
+    virtual void setResult();
+  protected:
+    double temp;
+    std::vector<double> tmp;
   };
   class StringQuery : public Query {
   public:
     StringQuery(std::string title,std::string *_target, std::string _description = "");
+    StringQuery(std::string title, std::string _description = "");
     virtual ~StringQuery();
     virtual bool handle()=0;
 …
   protected:
     std::string tmp;
-  private:
-    std::string *target;
   };
   class StringsQuery : public Query {
   public:
     StringsQuery(std::string title,std::vector<std::string> *_target, std::string _description = "");
+    StringsQuery(std::string title, std::string _description = "");
     virtual ~StringsQuery();
     virtual bool handle()=0;
 …
     std::string temp;
     std::vector<std::string> tmp;
-  private:
-    std::vector<std::string> *target;
   };
   class MoleculeQuery : public Query {
   public:
     MoleculeQuery(std::string title, molecule **_target, std::string _description = "");
+    MoleculeQuery(std::string title, std::string _description = "");
     virtual ~MoleculeQuery();
     virtual bool handle()=0;
 …
   protected:
     molecule *tmp;
+  private:
+    molecule **target;
+  };
+  class MoleculesQuery : public Query {
+  public:
+    MoleculesQuery(std::string title, std::string _description = "");
+    virtual ~MoleculesQuery();
+    virtual bool handle()=0;
+    virtual void setResult();
+  protected:
+    molecule * temp;
+    std::vector<molecule *> tmp;
   };
   class AtomQuery : public Query {
   public:
     AtomQuery(std::string title, atom **_target, std::string _description = "");
+    AtomQuery(std::string title, std::string _description = "");
     virtual ~AtomQuery();
     virtual bool handle()=0;
 …
   protected:
     atom *tmp;
+  private:
+    atom **target;
+  };
+  class AtomsQuery : public Query {
+  public:
+    AtomsQuery(std::string title, std::string _description = "");
+    virtual ~AtomsQuery();
+    virtual bool handle()=0;
+    virtual void setResult();
+  protected:
+    atom *temp;
+    std::vector<atom *> tmp;
   };
   class VectorQuery : public Query {
   public:
       VectorQuery(std::string title,Vector *_target,bool _check, std::string _description = "");
+      VectorQuery(std::string title,bool _check, std::string _description = "");
       virtual ~VectorQuery();
       virtual bool handle()=0;
       virtual void setResult();
     protected:
       Vector *tmp;
+      Vector tmp;
       bool check;
+    private:
+      Vector *target;
+  };
+  class VectorsQuery : public Query {
+  public:
+      VectorsQuery(std::string title,bool _check, std::string _description = "");
+      virtual ~VectorsQuery();
+      virtual bool handle()=0;
+      virtual void setResult();
+    protected:
+      Vector temp;
+      std::vector<Vector> tmp;
+      bool check;
   };
   class BoxQuery : public Query {
   public:
       BoxQuery(std::string title,Box *_cellSize, std::string _description = "");
+      BoxQuery(std::string title, std::string _description = "");
       virtual ~BoxQuery();
       virtual bool handle()=0;
       virtual void setResult();
     protected:
+      double* tmp;
+    private:
+      Box* target;
+      Box tmp;
   };
   class ElementQuery : public Query {
   public:
     ElementQuery(std::string title, std::vector<element *> *_target, std::string _description = "");
+    ElementQuery(std::string title, std::string _description = "");
     virtual ~ElementQuery();
     virtual bool handle()=0;
     virtual void setResult();
   protected:
+    std::vector<element *> elements;
+  private:
+    std::vector<element *> * const target;
+    element * tmp;
+  };
+  class ElementsQuery : public Query {
+  public:
+    ElementsQuery(std::string title, std::string _description = "");
+    virtual ~ElementsQuery();
+    virtual bool handle()=0;
+    virtual void setResult();
+  protected:
+    element *temp;
+    std::vector<element *> tmp;
   };

src/UIElements/Makefile.am

-              r7067bd6
+              r677e13
   Dialog.cpp \
   MainWindow.cpp \
+  UIFactory.cpp
+  UIFactory.cpp \
+  ValueStorage.cpp
 UIHEADER = \
 …
   Dialog.hpp \
   MainWindow.hpp \
+  UIFactory.hpp
+  UIFactory.hpp \
+  ValueStorage.hpp
 TEXTUISOURCE = \

src/UIElements/Menu/TextMenu.cpp

-              r7067bd6
+              r677e13
+}
+Dialog* TextMenu::LeaveAction::createDialog(){
+}
 Action::state_ptr TextMenu::LeaveAction::performCall(){
   menu->doQuit();

src/UIElements/Menu/TextMenu.hpp

r7067bd6	r677e13
36	36
37	37	private:
	38	virtual Dialog* createDialog();
38	39	virtual Action::state_ptr performCall();
39	40	virtual Action::state_ptr performUndo(Action::state_ptr);

src/UIElements/QT4/QTDialog.cpp

-              r7067bd6
+              r677e13
 #include <QtGui/QDoubleSpinBox>
 #include <Qt/qlineedit.h>
+#include <Qt/qlistwidget.h>
 #include <Qt/qdialogbuttonbox.h>
 #include <Qt/qpushbutton.h>
 …
 #include "element.hpp"
 #include "molecule.hpp"
+#include "Descriptors/AtomIdDescriptor.hpp"
 #include "Descriptors/MoleculeIdDescriptor.hpp"
 #include "Matrix.hpp"
 …
+}
 void QTDialog::queryBoolean(char const*, bool*,string){
+void QTDialog::queryBoolean(char const*,string){
   // TODO
   ASSERT(false, "Not implemented yet");
+}
 void QTDialog::queryAtom(char const*, atom**, string){
+void QTDialog::queryAtom(char const*, string){
   // TODO
   ASSERT(false, "Not implemented yet");
+}
 void QTDialog::queryBox(char const*, Box*, string){
+void QTDialog::queryAtoms(char const*, string){
   // TODO
   ASSERT(false, "Not implemented yet");
+}
+void QTDialog::queryInt(const char *title, int *target,string)
+{
+  registerQuery(new IntQTQuery(title,target,inputLayout,this));
+}
+void QTDialog::queryDouble(const char* title, double* target,string){
+  registerQuery(new DoubleQTQuery(title,target,inputLayout,this));
+}
+void QTDialog::queryString(const char* title, std::string *target,string)
+{
+  registerQuery(new StringQTQuery(title,target,inputLayout,this));
+}
+void QTDialog::queryStrings(const char* title, std::vector<std::string> *target,string)
+{
+  registerQuery(new StringsQTQuery(title,target,inputLayout,this));
+}
+void QTDialog::queryMolecule(const char *title,molecule **target,string)
+{
+  registerQuery(new MoleculeQTQuery(title,target,inputLayout,this));
+}
+void QTDialog::queryVector(const char* title, Vector *target, bool check,string) {
+  registerQuery(new VectorQTQuery(title,target,check,inputLayout,this));
+}
+void QTDialog::queryElement(const char* title, std::vector<element *> *target,string){
+  registerQuery(new ElementQTQuery(title,target,inputLayout,this));
+void QTDialog::queryBox(char const*, string){
+  // TODO
+  ASSERT(false, "Not implemented yet");
+}
+void QTDialog::queryInt(const char *title,string)
+{
+  registerQuery(new IntQTQuery(title,inputLayout,this));
+}
+void QTDialog::queryInts(const char *title,string)
+{
+  registerQuery(new IntsQTQuery(title,inputLayout,this));
+}
+void QTDialog::queryDouble(const char* title,string){
+  registerQuery(new DoubleQTQuery(title,inputLayout,this));
+}
+void QTDialog::queryDoubles(const char* title,string){
+  registerQuery(new DoublesQTQuery(title,inputLayout,this));
+}
+void QTDialog::queryString(const char* title,string)
+{
+  registerQuery(new StringQTQuery(title,inputLayout,this));
+}
+void QTDialog::queryStrings(const char* title,string)
+{
+  registerQuery(new StringsQTQuery(title,inputLayout,this));
+}
+void QTDialog::queryMolecule(const char *title,string)
+{
+  registerQuery(new MoleculeQTQuery(title,inputLayout,this));
+}
+void QTDialog::queryMolecules(const char *title,string)
+{
+  // TODO
+  ASSERT(false, "Not implemented yet");
+}
+void QTDialog::queryVector(const char* title, bool check,string) {
+  registerQuery(new VectorQTQuery(title,check,inputLayout,this));
+}
+void QTDialog::queryVectors(const char* title, bool check,string) {
+  // TODO
+  ASSERT(false, "Not implemented yet");
+}
+void QTDialog::queryElement(const char* title, string){
+  registerQuery(new ElementQTQuery(title,inputLayout,this));
+}
+void QTDialog::queryElements(const char* title, string){
+  // TODO
+  ASSERT(false, "Not implemented yet");
+}
 /************************** Query Objects *******************************/
 QTDialog::IntQTQuery::IntQTQuery(string _title,int *_target,QBoxLayout *_parent,QTDialog *_dialog) :
     Dialog::IntQuery(_title,_target),
+QTDialog::IntQTQuery::IntQTQuery(string _title,QBoxLayout *_parent,QTDialog *_dialog) :
+    Dialog::IntQuery(_title),
     parent(_parent)
+{
 …
+}
+// Handling is easy since the GUI makes it impossible to enter invalid values
+bool QTDialog::IntQTQuery::handle()
+{
+  return true;
+}
+QTDialog::DoubleQTQuery::DoubleQTQuery(string title,double *_target,QBoxLayout *_parent,QTDialog *_dialog) :
+    Dialog::DoubleQuery(title,_target),
+bool QTDialog::IntQTQuery::handle() {
+  return true;
+}
+QTDialog::IntsQTQuery::IntsQTQuery(string _title,QBoxLayout *_parent,QTDialog *_dialog) :
+    Dialog::IntsQuery(_title),
+    parent(_parent)
+{
+  QHBoxLayout * thisHLayout = new QHBoxLayout();
+  QVBoxLayout * thisV1Layout = new QVBoxLayout();
+  QVBoxLayout * thisV2Layout = new QVBoxLayout();
+  QLabel *titleLabel = new QLabel(QString(getTitle().c_str()));
+  QLabel *inputLabel = new QLabel("Enter to add");
+  QListWidget* inputList = new QListWidget();
+  inputList->setSelectionMode(QAbstractItemView::ExtendedSelection);
+  QLineEdit* inputBox = new QLineEdit();
+  inputLabel->setBuddy(inputBox);
+  titleLabel->setBuddy(inputList);
+  QPushButton* AddButton = new QPushButton("Add");
+  AddButton->setEnabled(false);
+  QPushButton* RemoveButton = new QPushButton("Remove");
+  RemoveButton->setEnabled(false);
+  thisV1Layout->addWidget(titleLabel);
+  thisV1Layout->addWidget(inputList);
+  thisV2Layout->addWidget(inputLabel);
+  thisV2Layout->addWidget(inputBox);
+  thisV2Layout->addWidget(AddButton);
+  thisV2Layout->addWidget(RemoveButton);
+  parent->addLayout(thisHLayout);
+  thisHLayout->addLayout(thisV1Layout);
+  thisHLayout->addLayout(thisV2Layout);
+  pipe = new QTQueryListPipe<int>(&tmp,_dialog,inputBox,inputList,AddButton,RemoveButton);
+  connect(inputBox,SIGNAL(textChanged(const QString&)),pipe,SLOT(IntegerEntered(const QString&)));
+  connect(inputList,SIGNAL(itemSelectionChanged()),pipe,SLOT(IntegerSelected()));
+  connect(AddButton,SIGNAL(Clicked()),pipe,SLOT(AddValue()));
+  connect(RemoveButton,SIGNAL(Clicked()),pipe,SLOT(RemoveRow()));
+}
+QTDialog::IntsQTQuery::~IntsQTQuery()
+{
+  delete pipe;
+}
+bool QTDialog::IntsQTQuery::handle() {
+  return true;
+}
+QTDialog::DoubleQTQuery::DoubleQTQuery(string title,QBoxLayout *_parent,QTDialog *_dialog) :
+    Dialog::DoubleQuery(title),
     parent(_parent)
+{
 …
+QTDialog::StringQTQuery::StringQTQuery(string _title,string *_target,QBoxLayout *_parent,QTDialog *_dialog) :
+    Dialog::StringQuery(_title,_target),
+QTDialog::DoublesQTQuery::DoublesQTQuery(string title,QBoxLayout *_parent,QTDialog *_dialog) :
+    Dialog::DoublesQuery(title),
+    parent(_parent)
+{
+  QHBoxLayout * thisHLayout = new QHBoxLayout();
+  QVBoxLayout * thisV1Layout = new QVBoxLayout();
+  QVBoxLayout * thisV2Layout = new QVBoxLayout();
+  QLabel *titleLabel = new QLabel(QString(getTitle().c_str()));
+  QLabel *inputLabel = new QLabel("Enter to add");
+  QListWidget* inputList = new QListWidget();
+  inputList->setSelectionMode(QAbstractItemView::ExtendedSelection);
+  QLineEdit* inputBox = new QLineEdit();
+  inputLabel->setBuddy(inputBox);
+  titleLabel->setBuddy(inputList);
+  QPushButton* AddButton = new QPushButton("Add");
+  AddButton->setEnabled(false);
+  QPushButton* RemoveButton = new QPushButton("Remove");
+  RemoveButton->setEnabled(false);
+  thisV1Layout->addWidget(titleLabel);
+  thisV1Layout->addWidget(inputList);
+  thisV2Layout->addWidget(inputLabel);
+  thisV2Layout->addWidget(inputBox);
+  thisV2Layout->addWidget(AddButton);
+  thisV2Layout->addWidget(RemoveButton);
+  parent->addLayout(thisHLayout);
+  thisHLayout->addLayout(thisV1Layout);
+  thisHLayout->addLayout(thisV2Layout);
+  pipe = new QTQueryListPipe<double>(&tmp,_dialog,inputBox,inputList,AddButton,RemoveButton);
+  connect(inputBox,SIGNAL(textChanged(const QString&)),pipe,SLOT(IntegerEntered(const QString&)));
+  connect(inputList,SIGNAL(itemSelectionChanged()),pipe,SLOT(IntegerSelected()));
+  connect(AddButton,SIGNAL(Clicked()),pipe,SLOT(AddValue()));
+  connect(RemoveButton,SIGNAL(Clicked()),pipe,SLOT(RemoveRow()));}
+QTDialog::DoublesQTQuery::~DoublesQTQuery()
+{
+  delete pipe;
+}
+bool QTDialog::DoublesQTQuery::handle() {
+  return true;
+}
+QTDialog::StringQTQuery::StringQTQuery(string _title,QBoxLayout *_parent,QTDialog *_dialog) :
+    Dialog::StringQuery(_title),
     parent(_parent)
+{
 …
+}
+QTDialog::StringsQTQuery::StringsQTQuery(string _title,vector<string> *_target,QBoxLayout *_parent,QTDialog *_dialog) :
+    Dialog::StringsQuery(_title,_target),
+    parent(_parent)
+{
+  thisLayout = new QHBoxLayout();
+  titleLabel = new QLabel(QString(getTitle().c_str()));
+  inputBox = new QLineEdit();
+  parent->addLayout(thisLayout);
+  thisLayout->addWidget(titleLabel);
+  thisLayout->addWidget(inputBox);
+  pipe = new StringQTQueryPipe(&temp,_dialog);
+  pipe->update(inputBox->text());
+  connect(inputBox,SIGNAL(textChanged(const QString&)),pipe,SLOT(update(const QString&)));
+}
+QTDialog::StringsQTQuery::StringsQTQuery(string _title,QBoxLayout *_parent,QTDialog *_dialog) :
+    Dialog::StringsQuery(_title),
+    parent(_parent)
+{
+  QHBoxLayout * thisHLayout = new QHBoxLayout();
+  QVBoxLayout * thisV1Layout = new QVBoxLayout();
+  QVBoxLayout * thisV2Layout = new QVBoxLayout();
+  QLabel *titleLabel = new QLabel(QString(getTitle().c_str()));
+  QLabel *inputLabel = new QLabel("Enter to add");
+  QListWidget* inputList = new QListWidget();
+  inputList->setSelectionMode(QAbstractItemView::ExtendedSelection);
+  QLineEdit* inputBox = new QLineEdit();
+  inputLabel->setBuddy(inputBox);
+  titleLabel->setBuddy(inputList);
+  QPushButton* AddButton = new QPushButton("Add");
+  AddButton->setEnabled(false);
+  QPushButton* RemoveButton = new QPushButton("Remove");
+  RemoveButton->setEnabled(false);
+  thisV1Layout->addWidget(titleLabel);
+  thisV1Layout->addWidget(inputList);
+  thisV2Layout->addWidget(inputLabel);
+  thisV2Layout->addWidget(inputBox);
+  thisV2Layout->addWidget(AddButton);
+  thisV2Layout->addWidget(RemoveButton);
+  parent->addLayout(thisHLayout);
+  thisHLayout->addLayout(thisV1Layout);
+  thisHLayout->addLayout(thisV2Layout);
+  pipe = new QTQueryListPipe<std::string>(&tmp,_dialog,inputBox,inputList,AddButton,RemoveButton);
+  connect(inputBox,SIGNAL(textChanged(const QString&)),pipe,SLOT(IntegerEntered(const QString&)));
+  connect(inputList,SIGNAL(itemSelectionChanged()),pipe,SLOT(IntegerSelected()));
+  connect(AddButton,SIGNAL(Clicked()),pipe,SLOT(AddValue()));
+  connect(RemoveButton,SIGNAL(Clicked()),pipe,SLOT(RemoveRow()));}
 QTDialog::StringsQTQuery::~StringsQTQuery()
 …
+}
 QTDialog::MoleculeQTQuery::MoleculeQTQuery(string _title, molecule **_target, QBoxLayout *_parent,QTDialog *_dialog) :
     Dialog::MoleculeQuery(_title,_target),
+QTDialog::MoleculeQTQuery::MoleculeQTQuery(string _title, QBoxLayout *_parent,QTDialog *_dialog) :
+    Dialog::MoleculeQuery(_title),
     parent(_parent)
+{
 …
+}
+QTDialog::VectorQTQuery::VectorQTQuery(std::string title, Vector *_target, bool _check,QBoxLayout *_parent,QTDialog *_dialog) :
+    Dialog::VectorQuery(title,_target,_check),
+QTDialog::MoleculesQTQuery::MoleculesQTQuery(string _title, QBoxLayout *_parent,QTDialog *_dialog) :
+    Dialog::MoleculesQuery(_title),
+    parent(_parent)
+{
+  thisLayout = new QHBoxLayout();
+  titleLabel = new QLabel(QString(getTitle().c_str()));
+  inputBox = new QComboBox();
+  // add all molecules to the combo box
+  vector<molecule*> molecules = World::getInstance().getAllMolecules();
+  for(vector<molecule*>::iterator iter  = molecules.begin();
+      iter != molecules.end();
+      ++iter) {
+    stringstream sstr;
+    sstr << (*iter)->IndexNr << "\t" << (*iter)->getName();
+    inputBox->addItem(QString(sstr.str().c_str()),QVariant((*iter)->IndexNr));
+  }
+  parent->addLayout(thisLayout);
+  thisLayout->addWidget(titleLabel);
+  thisLayout->addWidget(inputBox);
+  pipe = new MoleculesQTQueryPipe(&tmp,_dialog,inputBox);
+  pipe->update(inputBox->currentIndex());
+  connect(inputBox,SIGNAL(currentIndexChanged(int)),pipe,SLOT(update(int)));
+}
+QTDialog::MoleculesQTQuery::~MoleculesQTQuery()
+{
+  delete pipe;
+}
+// Handling is easy, since the GUI makes it impossible to select invalid values
+bool QTDialog::MoleculesQTQuery::handle()
+{
+  return true;
+}
+QTDialog::VectorQTQuery::VectorQTQuery(std::string title, bool _check,QBoxLayout *_parent,QTDialog *_dialog) :
+    Dialog::VectorQuery(title,_check),
     parent(_parent)
+{
 …
   subLayout = new QVBoxLayout();
   mainLayout->addLayout(subLayout);
+  for(int i=0; i<3; i++) {
+    coordLayout[i] = new QHBoxLayout();
+    subLayout->addLayout(coordLayout[i]);
+    coordLabel[i] = new QLabel(QString(coords[i]));
+    coordLayout[i]->addWidget(coordLabel[i]);
+    coordInput[i] = new QDoubleSpinBox();
+    coordInput[i]->setRange(0,M.at(i,i));
+    coordInput[i]->setDecimals(3);
+    coordLayout[i]->addWidget(coordInput[i]);
+    pipe[i] = new DoubleQTQueryPipe(&((*tmp)[i]),_dialog);
+    pipe[i]->update(coordInput[i]->value());
+    connect(coordInput[i],SIGNAL(valueChanged(double)),pipe[i],SLOT(update(double)));
+  }
+  QComboBox* inputBox = new QComboBox();
+  coordLayout = new QHBoxLayout();
+  subLayout->addLayout(coordLayout);
+  coordLabel = new QLabel(QString("x,y,z"));
+  coordLayout->addWidget(coordLabel);
+  coordInput = new QDoubleSpinBox();
+//  coordInput->setRange(0,M.at(i,i));
+  coordInput->setDecimals(3);
+  coordLayout->addWidget(coordInput);
+  pipe = new VectorQTQueryPipe(&(tmp),_dialog,inputBox);
+  //pipe->update(coordInput->value());
+  connect(coordInput,SIGNAL(valueChanged(double)),pipe,SLOT(update(double)));
   parent->addLayout(mainLayout);
+}
 …
+QTDialog::ElementQTQuery::ElementQTQuery(std::string _title, vector<element *> *_target, QBoxLayout *_parent, QTDialog *_dialog) :
+    Dialog::ElementQuery(_title,_target),
+QTDialog::VectorsQTQuery::VectorsQTQuery(std::string title, bool _check,QBoxLayout *_parent,QTDialog *_dialog) :
+    Dialog::VectorsQuery(title,_check),
+    parent(_parent)
+{
+  const Matrix& M = World::getInstance().getDomain().getM();
+  const char *coords[3] = {"x:","y:","z:"};
+  mainLayout= new QHBoxLayout();
+  titleLabel = new QLabel(QString(getTitle().c_str()));
+  mainLayout->addWidget(titleLabel);
+  subLayout = new QVBoxLayout();
+  mainLayout->addLayout(subLayout);
+  QComboBox* inputBox = new QComboBox();
+  coordLayout = new QHBoxLayout();
+  subLayout->addLayout(coordLayout);
+  coordLabel = new QLabel(QString("x,y,z"));
+  coordLayout->addWidget(coordLabel);
+  coordInput = new QDoubleSpinBox();
+//  coordInput->setRange(0,M.at(i,i));
+  coordInput->setDecimals(3);
+  coordLayout->addWidget(coordInput);
+  pipe = new VectorsQTQueryPipe(&(tmp),_dialog,inputBox);
+  //pipe->update(coordInput->value());
+  connect(coordInput,SIGNAL(valueChanged(double)),pipe,SLOT(update(double)));
+  parent->addLayout(mainLayout);
+}
+QTDialog::VectorsQTQuery::~VectorsQTQuery()
+{}
+bool QTDialog::VectorsQTQuery::handle() {
+  return true;
+}
+QTDialog::ElementQTQuery::ElementQTQuery(std::string _title, QBoxLayout *_parent, QTDialog *_dialog) :
+    Dialog::ElementQuery(_title),
     parent(_parent)
+{
 …
   thisLayout->addWidget(inputBox);
   pipe = new ElementQTQueryPipe(&elements,_dialog,inputBox);
+  pipe = new ElementQTQueryPipe(&tmp,_dialog,inputBox);
   pipe->update(inputBox->currentIndex());
   connect(inputBox,SIGNAL(currentIndexChanged(int)),pipe,SLOT(update(int)));
 …
+}
+QTDialog::ElementsQTQuery::ElementsQTQuery(std::string _title, QBoxLayout *_parent, QTDialog *_dialog) :
+    Dialog::ElementsQuery(_title),
+    parent(_parent)
+{
+  periodentafel *periode = World::getInstance().getPeriode();
+  thisLayout = new QHBoxLayout();
+  titleLabel = new QLabel(QString(getTitle().c_str()));
+  inputBox = new QComboBox();
+  for(periodentafel::const_iterator iter = periode->begin();
+      iter!=periode->end();
+      ++iter)
+  {
+    stringstream sstr;
+    sstr << (*iter).first << "\t" << (*iter).second->name;
+    inputBox->addItem(QString(sstr.str().c_str()),QVariant((*iter).first));
+  }
+  parent->addLayout(thisLayout);
+  thisLayout->addWidget(titleLabel);
+  thisLayout->addWidget(inputBox);
+  pipe = new ElementsQTQueryPipe(&tmp,_dialog,inputBox);
+  pipe->update(inputBox->currentIndex());
+  connect(inputBox,SIGNAL(currentIndexChanged(int)),pipe,SLOT(update(int)));
+}
+QTDialog::ElementsQTQuery::~ElementsQTQuery()
+{
+  delete pipe;
+}
+bool QTDialog::ElementsQTQuery::handle(){
+  return true;
+}
 /*************************** Plumbing *******************************/
+template<typename T> QTQueryListPipe<T>::QTQueryListPipe(std::vector<T> *_content, QTDialog *_dialog, QLineEdit *_inputBox, QListWidget *_inputList, QPushButton *_AddButton, QPushButton *_RemoveButton) :
+  content(_content),
+  dialog(_dialog),
+  inputBox(_inputBox),
+  inputList(_inputList),
+  AddButton(_AddButton),
+  RemoveButton(_RemoveButton)
+{}
+template<typename T> QTQueryListPipe<T>::~QTQueryListPipe()
+{}
+template<typename T> void QTQueryListPipe<T>::IntegerEntered(const QString&)
+{
+  AddButton->setEnabled(true);
+}
+template<typename T> void QTQueryListPipe<T>::IntegerSelected()
+{
+  if (inputList->selectedItems().empty())
+    RemoveButton->setEnabled(false);
+  else
+    RemoveButton->setEnabled(true);
+}
+template<typename T> void QTQueryListPipe<T>::AddInteger() {
+  // type-check
+  std::string text = inputBox->text().toStdString();
+  int number = 0;
+  try {
+    number = boost::lexical_cast<int>(text);
+  } catch (boost::bad_lexical_cast&) {
+    return;
+  };
+  // add item to both
+  inputList->addItem(QString(number));
+  AddValue(number);
+}
+template<typename T> void QTQueryListPipe<T>::AddValue(T item) {
+  content->push_back(item);
+  dialog->update();
+}
+template<typename T> void QTQueryListPipe<T>::RemoveInteger() {
+  QList<QListWidgetItem *> items = inputList->selectedItems();
+  for (QList<QListWidgetItem *>::iterator iter = items.begin(); !items.empty(); iter = items.begin()) {
+    // obtain which position item has (by making it current item)
+    inputList->setCurrentItem(*iter);
+    // remove
+    QTQueryListPipe<T>::RemoteRow(inputList->currentRow()); // template parameters needs to be known, such that compiler knows which to call
+    inputList->removeItemWidget(*iter);
+  }
+}
+template<typename T> void QTQueryListPipe<T>::RemoveRow(int row) {
+  int counter = 0;
+  typename std::vector<T>::iterator iter = content->begin();
+  for (; iter != content->end(); ++iter)
+    if (counter++ == row)
+      break;
+  if (iter != content->end())
+      content->erase(iter);
+}
 StringQTQueryPipe::StringQTQueryPipe(string *_content, QTDialog *_dialog) :
 …
   dialog->update();
+}
+VectorQTQueryPipe::VectorQTQueryPipe(Vector *_content, QTDialog *_dialog, QComboBox *_theBox) :
+  content(_content),
+  dialog(_dialog),
+  theBox(_theBox)
+{}
+VectorQTQueryPipe::~VectorQTQueryPipe()
+{}
+void VectorQTQueryPipe::update() {
+  dialog->update();
+}
+VectorsQTQueryPipe::VectorsQTQueryPipe(std::vector<Vector> *_content, QTDialog *_dialog, QComboBox *_theBox) :
+  content(_content),
+  dialog(_dialog),
+  theBox(_theBox)
+{}
+VectorsQTQueryPipe::~VectorsQTQueryPipe()
+{}
+void VectorsQTQueryPipe::update() {
+  dialog->update();
+}
+AtomQTQueryPipe::AtomQTQueryPipe(atom **_content, QTDialog *_dialog, QComboBox *_theBox) :
+  content(_content),
+  dialog(_dialog),
+  theBox(_theBox)
+{}
+AtomQTQueryPipe::~AtomQTQueryPipe()
+{}
+void AtomQTQueryPipe::update(int newIndex) {
+  QVariant data = theBox->itemData(newIndex);
+  int idx = data.toInt();
+  (*content) = World::getInstance().getAtom(AtomById(idx));
+  dialog->update();
+}
+AtomsQTQueryPipe::AtomsQTQueryPipe(std::vector<atom *>*_content, QTDialog *_dialog, QComboBox *_theBox) :
+  content(_content),
+  dialog(_dialog),
+  theBox(_theBox)
+{}
+AtomsQTQueryPipe::~AtomsQTQueryPipe()
+{}
+void AtomsQTQueryPipe::update(int newIndex) {
+  QVariant data = theBox->itemData(newIndex);
+  int idx = data.toInt();
+  atom *Walker = World::getInstance().getAtom(AtomById(idx));
+  if (Walker)
+    (*content).push_back(Walker) ;
+  dialog->update();
+}
 MoleculeQTQueryPipe::MoleculeQTQueryPipe(molecule **_content, QTDialog *_dialog, QComboBox *_theBox) :
 …
+}
+ElementQTQueryPipe::ElementQTQueryPipe(std::vector<element *> *_content, QTDialog *_dialog, QComboBox *_theBox) :
+MoleculesQTQueryPipe::MoleculesQTQueryPipe(std::vector<molecule *>*_content, QTDialog *_dialog, QComboBox *_theBox) :
   content(_content),
   dialog(_dialog),
   theBox(_theBox)
+{
+  content->resize(1);
+}
+{}
+MoleculesQTQueryPipe::~MoleculesQTQueryPipe()
+{}
+void MoleculesQTQueryPipe::update(int newIndex) {
+  QVariant data = theBox->itemData(newIndex);
+  int idx = data.toInt();
+  molecule *mol = World::getInstance().getMolecule(MoleculeById(idx));
+  if (mol)
+    (*content).push_back(mol);
+  dialog->update();
+}
+ElementQTQueryPipe::ElementQTQueryPipe(element **_content, QTDialog *_dialog, QComboBox *_theBox) :
+  content(_content),
+  dialog(_dialog),
+  theBox(_theBox)
+{}
 ElementQTQueryPipe::~ElementQTQueryPipe()
 …
   QVariant data = theBox->itemData(newIndex);
   int idx = data.toInt();
+  (*content)[0] = World::getInstance().getPeriode()->FindElement(idx);
+  dialog->update();
+}
+  *content = World::getInstance().getPeriode()->FindElement(idx);
+  dialog->update();
+}
+ElementsQTQueryPipe::ElementsQTQueryPipe(std::vector<element *>*_content, QTDialog *_dialog, QComboBox *_theBox) :
+  content(_content),
+  dialog(_dialog),
+  theBox(_theBox)
+{}
+ElementsQTQueryPipe::~ElementsQTQueryPipe()
+{}
+void ElementsQTQueryPipe::update(int newIndex) {
+  QVariant data = theBox->itemData(newIndex);
+  int idx = data.toInt();
+  element *elemental = World::getInstance().getPeriode()->FindElement(idx);
+  if(elemental)
+    (*content).push_back(elemental);
+  dialog->update();
+}

src/UIElements/QT4/QTDialog.hpp

-              r7067bd6
+              r677e13
 class QDoubleSpinBox;
 class QLineEdit;
+class QListWidget;
 class QComboBox;
 class QDialogButtonBox;
 …
 // Forward declarations for plumbing
+template<typename T> class QTQueryListPipe;
 class StringQTQueryPipe;
+class StringsQTQueryPipe;
 class IntQTQueryPipe;
 class DoubleQTQueryPipe;
+class DoublesQTQueryPipe;
+class AtomQTQueryPipe;
+class AtomsQTQueryPipe;
 class MoleculeQTQueryPipe;
+class MoleculesQTQueryPipe;
 class ElementQTQueryPipe;
+class ElementsQTQueryPipe;
+class VectorQTQueryPipe;
+class VectorsQTQueryPipe;
 class QTDialog : public QDialog, public Dialog
 …
   virtual void queryEmpty(const char*, std::string);
+  virtual void queryBoolean(const char *, bool *, std::string = "");
+  virtual void queryInt(const char *, int *,std::string = "");
+  virtual void queryDouble(const char*,double *,std::string = "");
+  virtual void queryString(const char*, std::string *,std::string = "");
+  virtual void queryStrings(const char*, std::vector<std::string> *,std::string = "");
+  virtual void queryAtom(const char*,atom**,std::string = "");
+  virtual void queryMolecule(const char*,molecule**,std::string = "");
+  virtual void queryVector(const char*,Vector *,bool,std::string = "");
+  virtual void queryBox(const char*,Box*, std::string = "");
+  virtual void queryElement(const char*,std::vector<element *> *_target,std::string = "");
+  virtual void queryBoolean(const char *, std::string = "");
+  virtual void queryInt(const char *,std::string = "");
+  virtual void queryInts(const char *,std::string = "");
+  virtual void queryDouble(const char*,std::string = "");
+  virtual void queryDoubles(const char*,std::string = "");
+  virtual void queryString(const char*,std::string = "");
+  virtual void queryStrings(const char*,std::string = "");
+  virtual void queryAtom(const char*,std::string = "");
+  virtual void queryAtoms(const char*,std::string = "");
+  virtual void queryMolecule(const char*,std::string = "");
+  virtual void queryMolecules(const char*,std::string = "");
+  virtual void queryVector(const char*,bool,std::string = "");
+  virtual void queryVectors(const char*,bool,std::string = "");
+  virtual void queryBox(const char*, std::string = "");
+  virtual void queryElement(const char*,std::string = "");
+  virtual void queryElements(const char*,std::string = "");
   virtual bool display();
 …
   class IntQTQuery : public Dialog::IntQuery {
     public:
       IntQTQuery(std::string _title, int *_target,QBoxLayout *_parent,QTDialog *_dialog);
+      IntQTQuery(std::string _title,QBoxLayout *_parent,QTDialog *_dialog);
       virtual ~IntQTQuery();
       virtual bool handle();
 …
     };
+  class IntsQTQuery : public Dialog::IntsQuery {
+    public:
+      IntsQTQuery(std::string _title,QBoxLayout *_parent,QTDialog *_dialog);
+      virtual ~IntsQTQuery();
+      virtual bool handle();
+      void IntegerEntered(const QString&);
+      void IntegerSelected();
+      void AddInteger();
+      void RemoveInteger();
+    private:
+      QBoxLayout *parent;
+      QBoxLayout *thisLayout;
+      QLabel *titleLabel;
+      QTQueryListPipe<int> *pipe;
+    };
     class DoubleQTQuery : public Dialog::DoubleQuery {
     public:
       DoubleQTQuery(std::string title, double *_target,QBoxLayout *_parent,QTDialog *_dialog);
+      DoubleQTQuery(std::string title,QBoxLayout *_parent,QTDialog *_dialog);
       virtual ~DoubleQTQuery();
       virtual bool handle();
 …
     };
+    class DoublesQTQuery : public Dialog::DoublesQuery {
+    public:
+      DoublesQTQuery(std::string title,QBoxLayout *_parent,QTDialog *_dialog);
+      virtual ~DoublesQTQuery();
+      virtual bool handle();
+    private:
+      QBoxLayout *parent;
+      QBoxLayout *thisLayout;
+      QLabel *titleLabel;
+      QDoubleSpinBox *inputBox;
+      QTQueryListPipe<double> *pipe;
+    };
     class StringQTQuery : public Dialog::StringQuery {
     public:
       StringQTQuery(std::string _title, std::string *_target, QBoxLayout *_parent,QTDialog *_dialog);
+      StringQTQuery(std::string _title, QBoxLayout *_parent,QTDialog *_dialog);
       virtual ~StringQTQuery();
       virtual bool handle();
 …
     class StringsQTQuery : public Dialog::StringsQuery {
     public:
       StringsQTQuery(std::string _title, std::vector<std::string> *_target, QBoxLayout *_parent,QTDialog *_dialog);
+      StringsQTQuery(std::string _title, QBoxLayout *_parent,QTDialog *_dialog);
       virtual ~StringsQTQuery();
       virtual bool handle();
 …
       QLineEdit *inputBox;
+      StringQTQueryPipe *pipe;
+      QTQueryListPipe<std::string> *pipe;
+    };
+    class AtomQTQuery : public Dialog::AtomQuery {
+    public:
+      AtomQTQuery(std::string _title, QBoxLayout *_parent,QTDialog *_dialog);
+      virtual ~AtomQTQuery();
+      virtual bool handle();
+    private:
+      QBoxLayout *parent;
+      QBoxLayout *thisLayout;
+      QLabel *titleLabel;
+      QComboBox *inputBox;
+      AtomQTQueryPipe *pipe;
+    };
+    class AtomsQTQuery : public Dialog::AtomsQuery {
+    public:
+      AtomsQTQuery(std::string _title, QBoxLayout *_parent,QTDialog *_dialog);
+      virtual ~AtomsQTQuery();
+      virtual bool handle();
+    private:
+      QBoxLayout *parent;
+      QBoxLayout *thisLayout;
+      QLabel *titleLabel;
+      QComboBox *inputBox;
+      AtomsQTQueryPipe *pipe;
     };
     class MoleculeQTQuery : public Dialog::MoleculeQuery {
     public:
       MoleculeQTQuery(std::string _title, molecule **_target, QBoxLayout *_parent,QTDialog *_dialog);
+      MoleculeQTQuery(std::string _title, QBoxLayout *_parent,QTDialog *_dialog);
       virtual ~MoleculeQTQuery();
       virtual bool handle();
 …
     };
+    class MoleculesQTQuery : public Dialog::MoleculesQuery {
+    public:
+      MoleculesQTQuery(std::string _title, QBoxLayout *_parent,QTDialog *_dialog);
+      virtual ~MoleculesQTQuery();
+      virtual bool handle();
+    private:
+      QBoxLayout *parent;
+      QBoxLayout *thisLayout;
+      QLabel *titleLabel;
+      QComboBox *inputBox;
+      MoleculesQTQueryPipe *pipe;
+    };
     class VectorQTQuery : public Dialog::VectorQuery {
     public:
       VectorQTQuery(std::string title,Vector *_target,bool _check,QBoxLayout *,QTDialog *);
+      VectorQTQuery(std::string title,bool _check,QBoxLayout *,QTDialog *);
       virtual ~VectorQTQuery();
       virtual bool handle();
 …
       QLabel *titleLabel;
       QBoxLayout *subLayout;
+      QBoxLayout *coordLayout[3];
+      QLabel *coordLabel[3];
+      QDoubleSpinBox *coordInput[3];
+      DoubleQTQueryPipe *pipe[3];
+      QBoxLayout *coordLayout;
+      QLabel *coordLabel;
+      QDoubleSpinBox *coordInput;
+      VectorQTQueryPipe *pipe;
+    };
+    class VectorsQTQuery : public Dialog::VectorsQuery {
+    public:
+      VectorsQTQuery(std::string title,bool _check,QBoxLayout *,QTDialog *);
+      virtual ~VectorsQTQuery();
+      virtual bool handle();
+    private:
+      QBoxLayout *parent;
+      QBoxLayout *mainLayout;
+      QLabel *titleLabel;
+      QBoxLayout *subLayout;
+      QBoxLayout *coordLayout;
+      QLabel *coordLabel;
+      QDoubleSpinBox *coordInput;
+      VectorsQTQueryPipe *pipe;
     };
     class ElementQTQuery : public Dialog::ElementQuery {
     public:
       ElementQTQuery(std::string _title, std::vector<element *> *_target, QBoxLayout *_parent, QTDialog *_dialog);
+      ElementQTQuery(std::string _title, QBoxLayout *_parent, QTDialog *_dialog);
       virtual ~ElementQTQuery();
       virtual bool handle();
 …
       ElementQTQueryPipe *pipe;
+    };
+    class ElementsQTQuery : public Dialog::ElementsQuery {
+    public:
+      ElementsQTQuery(std::string _title, QBoxLayout *_parent, QTDialog *_dialog);
+      virtual ~ElementsQTQuery();
+      virtual bool handle();
+    private:
+      QBoxLayout *parent;
+      QBoxLayout *thisLayout;
+      QLabel *titleLabel;
+      QComboBox *inputBox;
+      ElementsQTQueryPipe *pipe;
     };
 …
 // since MOC doesn't like nested classes
+template<typename T> class QTQueryListPipe : public QWidget {
+  public:
+    QTQueryListPipe(std::vector<T> *_content, QTDialog *_dialog, QLineEdit *_inputBox, QListWidget *_inputList, QPushButton *_AddButton, QPushButton *_RemoveButton);
+    virtual ~QTQueryListPipe();
+    void AddInteger();
+    void RemoveInteger();
+    void IntegerSelected();
+    void IntegerEntered(const QString&);
+  private:
+    void AddValue(T item);
+    void RemoveRow(int row);
+    std::vector<T> *content;
+    QTDialog *dialog;
+    QLineEdit *inputBox;
+    QListWidget *inputList;
+    QPushButton *AddButton;
+    QPushButton *RemoveButton;
+};
 class StringQTQueryPipe : public QWidget {
   Q_OBJECT
 …
 };
 class DoubleQTQueryPipe : public QWidget {
   Q_OBJECT
 …
 };
+class AtomQTQueryPipe : public QWidget {
+  Q_OBJECT
+public:
+  AtomQTQueryPipe(atom **_content, QTDialog *_dialog, QComboBox *_theBox);
+  virtual ~AtomQTQueryPipe();
+public slots:
+  void update(int);
+private:
+  atom **content;
+  QTDialog *dialog;
+  QComboBox *theBox;
+};
+class AtomsQTQueryPipe : public QWidget {
+  Q_OBJECT
+public:
+  AtomsQTQueryPipe(std::vector<atom *>*_content, QTDialog *_dialog, QComboBox *_theBox);
+  virtual ~AtomsQTQueryPipe();
+public slots:
+  void update(int);
+private:
+  std::vector<atom *>*content;
+  QTDialog *dialog;
+  QComboBox *theBox;
+};
 class MoleculeQTQueryPipe : public QWidget {
   Q_OBJECT
 …
 };
+class MoleculesQTQueryPipe : public QWidget {
+  Q_OBJECT
+public:
+  MoleculesQTQueryPipe(std::vector<molecule *>*_content, QTDialog *_dialog, QComboBox *_theBox);
+  virtual ~MoleculesQTQueryPipe();
+public slots:
+  void update(int);
+private:
+  std::vector<molecule *>*content;
+  QTDialog *dialog;
+  QComboBox *theBox;
+};
+class VectorQTQueryPipe : public QWidget {
+  Q_OBJECT
+public:
+  VectorQTQueryPipe(Vector *_content, QTDialog *_dialog, QComboBox *_theBox);
+  virtual ~VectorQTQueryPipe();
+public slots:
+  void update();
+private:
+  Vector *content;
+  QTDialog *dialog;
+  QComboBox *theBox;
+};
+class VectorsQTQueryPipe : public QWidget {
+  Q_OBJECT
+public:
+  VectorsQTQueryPipe(std::vector<Vector>*_content, QTDialog *_dialog, QComboBox *_theBox);
+  virtual ~VectorsQTQueryPipe();
+public slots:
+  void update();
+private:
+  std::vector<Vector> *content;
+  QTDialog *dialog;
+  QComboBox *theBox;
+};
 class ElementQTQueryPipe : public QWidget {
   Q_OBJECT
 public:
   ElementQTQueryPipe(std::vector<element *> *_content, QTDialog *_dialog, QComboBox *_theBox);
+  ElementQTQueryPipe(element **_content, QTDialog *_dialog, QComboBox *_theBox);
   virtual ~ElementQTQueryPipe();
 …
 private:
+  std::vector<element *> *content;
+  element **content;
+  QTDialog *dialog;
+  QComboBox *theBox;
+};
+class ElementsQTQueryPipe : public QWidget {
+  Q_OBJECT
+public:
+  ElementsQTQueryPipe(std::vector<element *>*_content, QTDialog *_dialog, QComboBox *_theBox);
+  virtual ~ElementsQTQueryPipe();
+public slots:
+  void update(int);
+private:
+  std::vector<element *>*content;
   QTDialog *dialog;
   QComboBox *theBox;

src/UIElements/TextUI/TextDialog.cpp

-              r7067bd6
+              r677e13
 using namespace std;
+using boost::lexical_cast;
+using boost::bad_lexical_cast;
 TextDialog::TextDialog()
 …
+}
+void TextDialog::queryBoolean(const char* title, bool* target, string description){
+  registerQuery(new BooleanTextQuery(title,target,description));
+}
+void TextDialog::queryInt(const char* title, int* target, string description){
+  registerQuery(new IntTextQuery(title,target,description));
+}
+void TextDialog::queryDouble(const char* title, double* target, string description){
+  registerQuery(new DoubleTextQuery(title,target,description));
+}
+void TextDialog::queryString(const char* title, string* target, string description){
+  registerQuery(new StringTextQuery(title,target,description));
+}
+void TextDialog::queryStrings(const char* title, vector<string>* target, string description){
+  registerQuery(new StringsTextQuery(title,target,description));
+}
+void TextDialog::queryAtom(const char* title, atom **target, string description) {
+  registerQuery(new AtomTextQuery(title,target,description));
+}
+void TextDialog::queryMolecule(const char* title, molecule **target, string description) {
+  registerQuery(new MoleculeTextQuery(title,target,description));
+}
+void TextDialog::queryVector(const char* title, Vector *target, bool check, string description) {
+  registerQuery(new VectorTextQuery(title,target,check,description));
+}
+void TextDialog::queryBox(const char* title,Box* cellSize, string description) {
+  registerQuery(new BoxTextQuery(title,cellSize,description));
+}
+void TextDialog::queryElement(const char* title, std::vector<element *> *target, string description){
+  registerQuery(new ElementTextQuery(title,target,description));
+void TextDialog::queryBoolean(const char* title, string description){
+  registerQuery(new BooleanTextQuery(title,description));
+}
+void TextDialog::queryInt(const char* title, string description){
+  registerQuery(new IntTextQuery(title,description));
+}
+void TextDialog::queryInts(const char* title, string description){
+  registerQuery(new IntsTextQuery(title,description));
+}
+void TextDialog::queryDouble(const char* title, string description){
+  registerQuery(new DoubleTextQuery(title,description));
+}
+void TextDialog::queryDoubles(const char* title, string description){
+  registerQuery(new DoublesTextQuery(title,description));
+}
+void TextDialog::queryString(const char* title, string description){
+  registerQuery(new StringTextQuery(title,description));
+}
+void TextDialog::queryStrings(const char* title, string description){
+  registerQuery(new StringsTextQuery(title,description));
+}
+void TextDialog::queryAtom(const char* title, string description) {
+  registerQuery(new AtomTextQuery(title,description));
+}
+void TextDialog::queryAtoms(const char* title, string description) {
+  registerQuery(new AtomsTextQuery(title,description));
+}
+void TextDialog::queryMolecule(const char* title, string description) {
+  registerQuery(new MoleculeTextQuery(title,description));
+}
+void TextDialog::queryMolecules(const char* title, string description) {
+  registerQuery(new MoleculesTextQuery(title,description));
+}
+void TextDialog::queryVector(const char* title, bool check, string description) {
+  registerQuery(new VectorTextQuery(title,check,description));
+}
+void TextDialog::queryVectors(const char* title, bool check, string description) {
+  registerQuery(new VectorsTextQuery(title,check,description));
+}
+void TextDialog::queryBox(const char* title, string description) {
+  registerQuery(new BoxTextQuery(title,description));
+}
+void TextDialog::queryElement(const char* title, string description){
+  registerQuery(new ElementTextQuery(title,description));
+}
+void TextDialog::queryElements(const char* title, string description){
+  registerQuery(new ElementsTextQuery(title,description));
+}
 …
+}
 TextDialog::IntTextQuery::IntTextQuery(string title, int * _target, std::string _description) :
     Dialog::IntQuery(title,_target,_description)
+TextDialog::IntTextQuery::IntTextQuery(string title, std::string _description) :
+    Dialog::IntQuery(title,_description)
 {}
 …
+}
+TextDialog::BooleanTextQuery::BooleanTextQuery(string title, bool * _target, std::string _description) :
+    Dialog::BooleanQuery(title,_target,_description)
+TextDialog::IntsTextQuery::IntsTextQuery(string title, std::string _description) :
+    Dialog::IntsQuery(title,_description)
+{}
+TextDialog::IntsTextQuery::~IntsTextQuery() {}
+bool TextDialog::IntsTextQuery::handle() {
+  Log() << Verbose(0) << getTitle();
+  std::string line;
+  getline(cin,line);
+  // dissect by " "
+  string::iterator olditer = line.begin();
+  for(string::iterator iter = line.begin(); iter != line.end(); ++iter) {
+    if (*iter == ' ') {
+      std::istringstream stream(string(iter, olditer));
+      stream >> temp;
+      tmp.push_back(temp);
+      olditer = iter;
+    }
+  }
+  if (olditer != line.begin()) { // insert last part also
+    std::istringstream stream(string(olditer, line.end()));
+    stream >> temp;
+    tmp.push_back(temp);
+  }
+  return true;
+}
+TextDialog::BooleanTextQuery::BooleanTextQuery(string title, std::string _description) :
+    Dialog::BooleanQuery(title,_description)
 {}
 …
+}
 TextDialog::StringTextQuery::StringTextQuery(string title,string *_target, std::string _description) :
     Dialog::StringQuery(title,_target,_description)
+TextDialog::StringTextQuery::StringTextQuery(string title, std::string _description) :
+    Dialog::StringQuery(title,_description)
 {}
 …
+}
 TextDialog::StringsTextQuery::StringsTextQuery(string title,vector<string> *_target, std::string _description) :
     Dialog::StringsQuery(title,_target,_description)
+TextDialog::StringsTextQuery::StringsTextQuery(string title, std::string _description) :
+    Dialog::StringsQuery(title,_description)
 {}
 …
   Log() << Verbose(0) << getTitle();
   getline(cin,temp);
   // dissect by ","
+  // dissect by " "
   string::iterator olditer = temp.begin();
   for(string::iterator iter = temp.begin(); iter != temp.end(); ++iter) {
 …
+}
 TextDialog::DoubleTextQuery::DoubleTextQuery(string title,double *_target, std::string _description) :
     Dialog::DoubleQuery(title,_target,_description)
+TextDialog::DoubleTextQuery::DoubleTextQuery(string title, std::string _description) :
+    Dialog::DoubleQuery(title,_description)
 {}
 …
+}
+TextDialog::AtomTextQuery::AtomTextQuery(string title, atom **_target, std::string _description) :
+    Dialog::AtomQuery(title,_target,_description)
+TextDialog::DoublesTextQuery::DoublesTextQuery(string title, std::string _description) :
+    Dialog::DoublesQuery(title,_description)
+{}
+TextDialog::DoublesTextQuery::~DoublesTextQuery() {}
+bool TextDialog::DoublesTextQuery::handle() {
+  Log() << Verbose(0) << getTitle();
+  std::string line;
+  getline(cin,line);
+  // dissect by " "
+  string::iterator olditer = line.begin();
+  for(string::iterator iter = line.begin(); iter != line.end(); ++iter) {
+    if (*iter == ' ') {
+      std::istringstream stream(string(iter, olditer));
+      stream >> temp;
+      tmp.push_back(temp);
+      olditer = iter;
+    }
+  }
+  if (olditer != line.begin()) { // insert last part also
+    std::istringstream stream(string(olditer, line.end()));
+    stream >> temp;
+    tmp.push_back(temp);
+  }
+  return true;
+}
+TextDialog::AtomTextQuery::AtomTextQuery(string title, std::string _description) :
+    Dialog::AtomQuery(title,_description)
 {}
 …
 bool TextDialog::AtomTextQuery::handle() {
   int idxOfAtom=0;
+  int idxOfAtom=-1;
   bool badInput = false;
   do{
 …
     tmp = World::getInstance().getAtom(AtomById(idxOfAtom));
     if(!tmp && idxOfAtom!=-1){
       Log() << Verbose(0) << "Invalid Atom Index" << endl;
+      Log() << Verbose(0) << "Invalid Atom Index" << idxOfAtom << endl;
       badInput = true;
+    }
 …
+}
+TextDialog::MoleculeTextQuery::MoleculeTextQuery(string title, molecule **_target, std::string _description) :
+    Dialog::MoleculeQuery(title,_target,_description)
+TextDialog::AtomsTextQuery::AtomsTextQuery(string title, std::string _description) :
+    Dialog::AtomsQuery(title,_description)
+{}
+TextDialog::AtomsTextQuery::~AtomsTextQuery() {}
+bool TextDialog::AtomsTextQuery::handle() {
+  int idxOfAtom=-1;
+  Log() << Verbose(0) << getTitle();
+  std::string line;
+  getline(cin,line);
+  // dissect by " "
+  string::iterator olditer = line.begin();
+  for(string::iterator iter = line.begin(); iter != line.end(); ++iter) {
+    if (*iter == ' ') {
+      std::istringstream stream(string(iter, olditer));
+      stream >> idxOfAtom;
+      temp = World::getInstance().getAtom(AtomById(idxOfAtom));
+      if(!temp && idxOfAtom!=-1){
+        Log() << Verbose(0) << "Invalid Atom Index" << idxOfAtom << endl;
+        break;
+      }
+      tmp.push_back(temp);
+      olditer = iter;
+    }
+  }
+  if (olditer != line.begin()) { // insert last part also
+    std::istringstream stream(string(olditer, line.end()));
+    stream >> idxOfAtom;
+    temp = World::getInstance().getAtom(AtomById(idxOfAtom));
+    if(!temp && idxOfAtom!=-1) {
+      Log() << Verbose(0) << "Invalid Atom Index" << idxOfAtom << endl;
+      tmp.push_back(temp);
+    }
+  }
+  return (idxOfAtom!=-1);
+}
+TextDialog::MoleculeTextQuery::MoleculeTextQuery(string title, std::string _description) :
+    Dialog::MoleculeQuery(title,_description)
 {}
 …
+}
+TextDialog::VectorTextQuery::VectorTextQuery(std::string title, Vector *_target, bool _check, std::string _description) :
+    Dialog::VectorQuery(title,_target,_check,_description)
+TextDialog::MoleculesTextQuery::MoleculesTextQuery(string title, std::string _description) :
+    Dialog::MoleculesQuery(title,_description)
+{}
+TextDialog::MoleculesTextQuery::~MoleculesTextQuery() {}
+bool TextDialog::MoleculesTextQuery::handle() {
+  int idxOfMol=-1;
+  Log() << Verbose(0) << getTitle();
+  std::string line;
+  getline(cin,line);
+  // dissect by " "
+  string::iterator olditer = line.begin();
+  for(string::iterator iter = line.begin(); iter != line.end(); ++iter) {
+    if (*iter == ' ') {
+      std::istringstream stream(string(iter, olditer));
+      stream >> idxOfMol;
+      temp = World::getInstance().getMolecule(MoleculeById(idxOfMol));
+      if(!temp && idxOfMol!=-1){
+        Log() << Verbose(0) << "Invalid Molecule Index" << idxOfMol << endl;
+        break;
+      }
+      tmp.push_back(temp);
+      olditer = iter;
+    }
+  }
+  if (olditer != line.begin()) { // insert last part also
+    std::istringstream stream(string(olditer, line.end()));
+    stream >> idxOfMol;
+    temp = World::getInstance().getMolecule(MoleculeById(idxOfMol));
+    if(!temp && idxOfMol!=-1){
+      Log() << Verbose(0) << "Invalid Molecule Index" << idxOfMol << endl;
+      tmp.push_back(temp);
+    }
+  }
+  return (idxOfMol!=-1);
+}
+TextDialog::VectorTextQuery::VectorTextQuery(std::string title, bool _check, std::string _description) :
+    Dialog::VectorQuery(title,_check,_description)
 {}
 …
 bool TextDialog::VectorTextQuery::handle() {
+  Log() << Verbose(0) << getTitle();
+  std::cout << getTitle();
   const Matrix &M = World::getInstance().getDomain().getM();
+  char coords[3] = {'x','y','z'};
+  for (int i=0;i<3;i++) {
+    do {
+      Log() << Verbose(0) << coords[i] << "[0.." << M.at(i,i) << "]: ";
+      cin >> (*tmp)[i];
+    } while ((((*tmp)[i] < 0) || ((*tmp)[i] >= M.at(i,i))) && (check));
+  }
+  return true;
+}
+TextDialog::BoxTextQuery::BoxTextQuery(std::string title, Box* _cellSize, std::string _description) :
+    Dialog::BoxQuery(title,_cellSize,_description)
+  char coords[3] = {'x', 'y', 'z'};
+  for (int i=0;i<3;i++)
+    std::cout << coords[i] << "[0.." << M.at(i,i) << ( (i!=2) ? "], " : "]: ");
+  std::string line;
+  getline(cin,line);
+  // dissect by ","
+  double coord = 0.;
+  int counter = 0;
+  string::iterator olditer = line.begin();
+  for(string::iterator iter = line.begin(); (iter != line.end()) && (counter != 3); ++iter) {
+    if (*iter == ',') {
+      std::istringstream stream(string(iter, olditer));
+      stream >> coord;
+      tmp[counter++] = coord;
+      olditer = iter;
+    }
+  }
+  if ((olditer != line.begin()) && (counter != 3)) { // insert last part also
+    std::istringstream stream(string(olditer, line.end()));
+    stream >> coord;
+    tmp[counter++] = coord;
+  }
+  // check vector
+  return World::getInstance().getDomain().isInside(tmp);
+}
+TextDialog::VectorsTextQuery::VectorsTextQuery(std::string title, bool _check, std::string _description) :
+    Dialog::VectorsQuery(title,_check,_description)
+{}
+TextDialog::VectorsTextQuery::~VectorsTextQuery()
+{}
+bool TextDialog::VectorsTextQuery::handle() {
+  std::cout << getTitle();
+  char coords[3] = {'x', 'y', 'z'};
+  const Matrix &M = World::getInstance().getDomain().getM();
+  for (int i=0;i<3;i++)
+    std::cout << coords[i] << "[0.." << M.at(i,i) << ( (i!=2) ? "], " : "]: ");
+  std::string line;
+  getline(cin,line);
+  // dissect by ","
+  double coord = 0.;
+  string::iterator olditerspace = line.begin();
+  string::iterator olditercomma = line.begin();
+  int counter = 0;
+  for(string::iterator vectoriter = line.begin(); vectoriter != line.end(); ++vectoriter) {
+    if (*vectoriter == ',')
+      counter++;
+    if ((*vectoriter == ' ') && (counter == 2)) {
+      counter = 0;
+      for(string::iterator componentiter = olditerspace; (componentiter != vectoriter) && (counter !=3); ++componentiter) {
+        if (*componentiter == ',') {
+          std::istringstream stream(string(componentiter, olditercomma));
+          stream >> coord;
+          temp[counter++] = coord;
+          olditercomma = componentiter;
+        }
+      }
+      if ((olditercomma != line.begin()) && (counter != 3)) { // insert last part also
+        std::istringstream stream(string(olditercomma, vectoriter));
+        stream >> coord;
+        temp[counter++] = coord;
+      }
+      if (World::getInstance().getDomain().isInside(temp))
+        tmp.push_back(temp);
+      olditerspace = vectoriter;
+    }
+  }
+}
+TextDialog::BoxTextQuery::BoxTextQuery(std::string title, std::string _description) :
+    Dialog::BoxQuery(title,_description)
 {}
 …
   Log() << Verbose(0) << getTitle();
+  std::string coords[6] = {"xx","xy","xz", "yy", "yz", "zz"};
+  double temp[6];
+  std::string coords[6] = {"xx","yx","yy", "zx", "zy", "zz"};
   for (int i=0;i<6;i++) {
     Log() << Verbose(0) << coords[i] << ": ";
+    cin >> tmp[i];
+  }
+  return true;
+}
+TextDialog::ElementTextQuery::ElementTextQuery(std::string title, std::vector<element *> *_target, std::string _description) :
+    Dialog::ElementQuery(title,_target,_description)
+    cin >> temp[i];
+  }
+  Matrix M;
+  M.set(0,0, temp[0]);
+  M.set(0,1, temp[1]);
+  M.set(0,2, temp[2]);
+  M.set(1,0, temp[1]);
+  M.set(1,1, temp[3]);
+  M.set(1,2, temp[4]);
+  M.set(2,0, temp[2]);
+  M.set(2,1, temp[4]);
+  M.set(2,2, temp[5]);
+  tmp.setM(M);
+  return true;
+}
+TextDialog::ElementTextQuery::ElementTextQuery(std::string title, std::string _description) :
+    Dialog::ElementQuery(title,_description)
 {}
 …
   bool badInput=false;
   bool aborted = false;
   element * tmp = NULL;
+  element * temp = NULL;
   do{
     badInput = false;
 …
+      }
       else{
         tmp = World::getInstance().getPeriode()->FindElement(Z);
         if(!tmp){
+        temp = World::getInstance().getPeriode()->FindElement(Z);
+        if(!temp){
           Log() << Verbose(0) << "No element with this atomic number!" << endl;
           badInput = true;
-        } else {
-          elements.push_back(tmp);
+        }
+      }
 …
+      }
       else{
         tmp = World::getInstance().getPeriode()->FindElement(shorthand.c_str());
         if(!tmp){
+        temp = World::getInstance().getPeriode()->FindElement(shorthand.c_str());
+        if(!temp){
           Log() << Verbose(0) << "No element with this shorthand!" << endl;
           badInput = true;
-        } else {
-          elements.push_back(tmp);
+        }
+      }
 …
   return !aborted;
+}
+TextDialog::ElementsTextQuery::ElementsTextQuery(std::string title, std::string _description) :
+    Dialog::ElementsQuery(title,_description)
+{}
+TextDialog::ElementsTextQuery::~ElementsTextQuery()
+{}
+bool TextDialog::ElementsTextQuery::handle() {
+  std::string shorthand;
+  int Z=-1;
+  Log() << Verbose(0) << getTitle();
+  std::string line;
+  getline(cin,line);
+  // dissect by " "
+  string::iterator olditer = line.begin();
+  for(string::iterator iter = line.begin(); iter != line.end(); ++iter) {
+    if (*iter == ' ') {
+      std::istringstream stream(string(iter, olditer));
+      stream >> shorthand;
+      try {
+        Z = lexical_cast<int>(shorthand);
+        temp = World::getInstance().getPeriode()->FindElement(Z);
+      } catch (bad_lexical_cast) {
+        temp = World::getInstance().getPeriode()->FindElement(shorthand.c_str());
+      };
+      if(!temp && Z!=-1){
+        Log() << Verbose(0) << "Invalid Element" << shorthand << endl;
+        break;
+      }
+      tmp.push_back(temp);
+      olditer = iter;
+    }
+  }
+  if (olditer != line.begin()) { // insert last part also
+    std::istringstream stream(string(olditer, line.end()));
+    stream >> shorthand;
+    try {
+      Z = lexical_cast<int>(shorthand);
+      temp = World::getInstance().getPeriode()->FindElement(Z);
+    } catch (bad_lexical_cast) {
+      temp = World::getInstance().getPeriode()->FindElement(shorthand.c_str());
+    };
+    if(!temp && Z!=-1) {
+      Log() << Verbose(0) << "Invalid Element" << shorthand << endl;
+      tmp.push_back(temp);
+    }
+  }
+  return (Z!=-1);
+}

src/UIElements/TextUI/TextDialog.hpp

-              r7067bd6
+              r677e13
   virtual void queryEmpty(const char *, std::string = "");
+  virtual void queryBoolean(const char *, bool *, std::string = "");
+  virtual void queryInt(const char *, int *, std::string = "");
+  virtual void queryString(const char*, std::string *, std::string = "");
+  virtual void queryStrings(const char*, std::vector<std::string> *, std::string = "");
+  virtual void queryDouble(const char*, double*, std::string = "");
+  virtual void queryAtom(const char*,atom**,std::string = "");
+  virtual void queryMolecule(const char*,molecule**,std::string = "");
+  virtual void queryVector(const char*,Vector *,bool, std::string = "");
+  virtual void queryBox(const char*,Box*, std::string = "");
+  virtual void queryElement(const char*, std::vector<element *> *, std::string = "");
+  virtual void queryBoolean(const char *, std::string = "");
+  virtual void queryInt(const char *, std::string = "");
+  virtual void queryInts(const char *, std::string = "");
+  virtual void queryString(const char*, std::string = "");
+  virtual void queryStrings(const char*, std::string = "");
+  virtual void queryDouble(const char*, std::string = "");
+  virtual void queryDoubles(const char*, std::string = "");
+  virtual void queryAtom(const char*,std::string = "");
+  virtual void queryAtoms(const char*,std::string = "");
+  virtual void queryMolecule(const char*,std::string = "");
+  virtual void queryMolecules(const char*,std::string = "");
+  virtual void queryVector(const char*,bool, std::string = "");
+  virtual void queryVectors(const char*,bool, std::string = "");
+  virtual void queryBox(const char*, std::string = "");
+  virtual void queryElement(const char*, std::string = "");
+  virtual void queryElements(const char*, std::string = "");
 protected:
 …
   class BooleanTextQuery : public Dialog::BooleanQuery {
   public:
     BooleanTextQuery(std::string title, bool *_target, std::string _description = NULL);
+    BooleanTextQuery(std::string title, std::string _description = NULL);
     virtual ~BooleanTextQuery();
     virtual bool handle();
 …
   class IntTextQuery : public Dialog::IntQuery {
   public:
     IntTextQuery(std::string title, int *_target, std::string _description = NULL);
+    IntTextQuery(std::string title, std::string _description = NULL);
     virtual ~IntTextQuery();
+    virtual bool handle();
+  };
+  class IntsTextQuery : public Dialog::IntsQuery {
+  public:
+    IntsTextQuery(std::string title, std::string _description = NULL);
+    virtual ~IntsTextQuery();
     virtual bool handle();
   };
 …
   class DoubleTextQuery : public Dialog::DoubleQuery {
   public:
     DoubleTextQuery(std::string title, double *_target, std::string _description = NULL);
+    DoubleTextQuery(std::string title, std::string _description = NULL);
     virtual ~DoubleTextQuery();
+    virtual bool handle();
+  };
+  class DoublesTextQuery : public Dialog::DoublesQuery {
+  public:
+    DoublesTextQuery(std::string title, std::string _description = NULL);
+    virtual ~DoublesTextQuery();
     virtual bool handle();
   };
 …
   class StringTextQuery : public Dialog::StringQuery {
   public:
     StringTextQuery(std::string title, std::string *_target, std::string _description = NULL);
+    StringTextQuery(std::string title, std::string _description = NULL);
     virtual ~StringTextQuery();
     virtual bool handle();
 …
   class StringsTextQuery : public Dialog::StringsQuery {
   public:
     StringsTextQuery(std::string title, std::vector<std::string> *_target, std::string _description = NULL);
+    StringsTextQuery(std::string title, std::string _description = NULL);
     virtual ~StringsTextQuery();
     virtual bool handle();
 …
   class AtomTextQuery : public Dialog::AtomQuery {
   public:
     AtomTextQuery(std::string title, atom **_target, std::string _description = NULL);
+    AtomTextQuery(std::string title, std::string _description = NULL);
     virtual ~AtomTextQuery();
+    virtual bool handle();
+  };
+  class AtomsTextQuery : public Dialog::AtomsQuery {
+  public:
+    AtomsTextQuery(std::string title, std::string _description = NULL);
+    virtual ~AtomsTextQuery();
     virtual bool handle();
   };
 …
   class MoleculeTextQuery : public Dialog::MoleculeQuery {
   public:
     MoleculeTextQuery(std::string title, molecule **_target, std::string _description = NULL);
+    MoleculeTextQuery(std::string title, std::string _description = NULL);
     virtual ~MoleculeTextQuery();
+    virtual bool handle();
+  };
+  class MoleculesTextQuery : public Dialog::MoleculesQuery {
+  public:
+    MoleculesTextQuery(std::string title, std::string _description = NULL);
+    virtual ~MoleculesTextQuery();
     virtual bool handle();
   };
 …
   class VectorTextQuery : public Dialog::VectorQuery {
   public:
     VectorTextQuery(std::string title,Vector *_target,bool _check, std::string _description = NULL);
+    VectorTextQuery(std::string title,bool _check, std::string _description = NULL);
     virtual ~VectorTextQuery();
+    virtual bool handle();
+  };
+  class VectorsTextQuery : public Dialog::VectorsQuery {
+  public:
+    VectorsTextQuery(std::string title,bool _check, std::string _description = NULL);
+    virtual ~VectorsTextQuery();
     virtual bool handle();
   };
 …
   class BoxTextQuery : public Dialog::BoxQuery {
   public:
     BoxTextQuery(std::string title,Box* _cellSize, std::string _description = NULL);
+    BoxTextQuery(std::string title, std::string _description = NULL);
     virtual ~BoxTextQuery();
     virtual bool handle();
 …
   class ElementTextQuery : public Dialog::ElementQuery {
   public:
     ElementTextQuery(std::string title, std::vector<element *> *_target, std::string _description = NULL);
+    ElementTextQuery(std::string title, std::string _description = NULL);
     virtual ~ElementTextQuery();
+    virtual bool handle();
+  };
+  class ElementsTextQuery : public Dialog::ElementsQuery {
+  public:
+    ElementsTextQuery(std::string title, std::string _description = NULL);
+    virtual ~ElementsTextQuery();
     virtual bool handle();
   };

src/World.cpp

-              r7067bd6
+              r677e13
+}
+size_t World::countSelectedAtoms() const {
+  size_t count = 0;
+  for (AtomSet::const_iterator iter = selectedAtoms.begin(); iter != selectedAtoms.end(); ++iter)
+    count++;
+  return count;
+}
+bool World::isSelected(atom *atom) const {
+  return selectedAtoms.find(atom->getId()) != selectedAtoms.end();
+}
+const std::vector<atom *> World::getSelectedAtoms() const {
+  std::vector<atom *> returnAtoms;
+  returnAtoms.resize(countSelectedAtoms());
+  int count = 0;
+  for (AtomSet::const_iterator iter = selectedAtoms.begin(); iter != selectedAtoms.end(); ++iter)
+    returnAtoms[count++] = iter->second;
+  return returnAtoms;
+}
 // Molecules
 …
+}
 void World::selectAllMoleculess(MoleculeDescriptor descr){
+void World::selectAllMolecules(MoleculeDescriptor descr){
   internal_MoleculeIterator begin = getMoleculeIter_internal(descr);
   internal_MoleculeIterator end = moleculeEnd_internal();
 …
+}
 void World::unselectAllMoleculess(MoleculeDescriptor descr){
+void World::unselectAllMolecules(MoleculeDescriptor descr){
   internal_MoleculeIterator begin = getMoleculeIter_internal(descr);
   internal_MoleculeIterator end = moleculeEnd_internal();
 …
   ASSERT(atoms.count(id),"No such atom with given ID in selection of Molecules of Atom");\
   unselectMoleculeOfAtom(atoms[id]);
+}
+size_t World::countSelectedMolecules() const {
+  size_t count = 0;
+  for (MoleculeSet::const_iterator iter = selectedMolecules.begin(); iter != selectedMolecules.end(); ++iter)
+    count++;
+  return count;
+}
+bool World::isSelected(molecule *mol) const {
+  return selectedMolecules.find(mol->getId()) != selectedMolecules.end();
+}
+const std::vector<molecule *> World::getSelectedMolecules() const {
+  std::vector<molecule *> returnMolecules;
+  returnMolecules.resize(countSelectedMolecules());
+  int count = 0;
+  for (MoleculeSet::const_iterator iter = selectedMolecules.begin(); iter != selectedMolecules.end(); ++iter)
+    returnMolecules[count++] = iter->second;
+  return returnMolecules;
+}

src/World.hpp

-              r7067bd6
+              r677e13
   void unselectAtomsOfMolecule(molecule*);
   void unselectAtomsOfMolecule(moleculeId_t);
+  size_t countSelectedAtoms() const;
+  bool isSelected(atom *_atom) const;
+  const std::vector<atom *> getSelectedAtoms() const;
   void clearMoleculeSelection();
   void selectMolecule(molecule*);
   void selectMolecule(moleculeId_t);
   void selectAllMoleculess(MoleculeDescriptor);
+  void selectAllMolecules(MoleculeDescriptor);
   void selectMoleculeOfAtom(atom*);
   void selectMoleculeOfAtom(atomId_t);
   void unselectMolecule(molecule*);
   void unselectMolecule(moleculeId_t);
   void unselectAllMoleculess(MoleculeDescriptor);
+  void unselectAllMolecules(MoleculeDescriptor);
   void unselectMoleculeOfAtom(atom*);
   void unselectMoleculeOfAtom(atomId_t);
+  size_t countSelectedMolecules() const;
+  bool isSelected(molecule *_mol) const;
+  const std::vector<molecule *> getSelectedMolecules() const;
   /******************** Iterators to selections *****************/

src/analysis_correlation.cpp

-              r7067bd6
+              r677e13
 /** Calculates the pair correlation between given elements.
  * Note given element order is unimportant (i.e. g(Si, O) === g(O, Si))
  * \param *molecules list of molecules structure
+ * \param *molecules vector of molecules
  * \param &elements vector of elements to correlate
  * \return Map of doubles with values the pair of the two atoms.
  */
 PairCorrelationMap *PairCorrelation(MoleculeListClass * const &molecules, const std::vector<element *> &elements)
+PairCorrelationMap *PairCorrelation(std::vector<molecule *> &molecules, const std::vector<element *> &elements)
+{
   Info FunctionInfo(__func__);
 …
   Box &domain = World::getInstance().getDomain();
   if (molecules->ListOfMolecules.empty()) {
+  if (molecules.empty()) {
     DoeLog(1) && (eLog()<< Verbose(1) <<"No molecule given." << endl);
     return outmap;
+  }
   for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin(); MolWalker != molecules->ListOfMolecules.end(); MolWalker++)
+  for (std::vector<molecule *>::const_iterator MolWalker = molecules.begin(); MolWalker != molecules.end(); MolWalker++)
     (*MolWalker)->doCountAtoms();
 …
   outmap = new PairCorrelationMap;
+  for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin(); MolWalker != molecules->ListOfMolecules.end(); MolWalker++){
+    if ((*MolWalker)->ActiveFlag) {
+      DoeLog(2) && (eLog()<< Verbose(2) << "Current molecule is " << *MolWalker << "." << endl);
+      eLog() << Verbose(2) << "Current molecule is " << *MolWalker << "." << endl;
+      for (molecule::const_iterator iter = (*MolWalker)->begin(); iter != (*MolWalker)->end(); ++iter) {
+        DoLog(3) && (Log() << Verbose(3) << "Current atom is " << **iter << "." << endl);
+        for (MoleculeList::const_iterator MolOtherWalker = MolWalker; MolOtherWalker != molecules->ListOfMolecules.end(); MolOtherWalker++){
+          if ((*MolOtherWalker)->ActiveFlag) {
+            DoLog(2) && (Log() << Verbose(2) << "Current other molecule is " << *MolOtherWalker << "." << endl);
+            for (molecule::const_iterator runner = (*MolOtherWalker)->begin(); runner != (*MolOtherWalker)->end(); ++runner) {
+              DoLog(3) && (Log() << Verbose(3) << "Current otheratom is " << **runner << "." << endl);
+              if ((*iter)->getId() < (*runner)->getId()){
+                for (set <pair<element *, element *> >::iterator PairRunner = PairsOfElements.begin(); PairRunner != PairsOfElements.end(); ++PairRunner)
+                  if ((PairRunner->first == (**iter).type) && (PairRunner->second == (**runner).type)) {
+                    distance = domain.periodicDistance(*(*iter)->node,*(*runner)->node);
+                    //Log() << Verbose(1) <<"Inserting " << *(*iter) << " and " << *(*runner) << endl;
+                    outmap->insert ( pair<double, pair <atom *, atom*> > (distance, pair<atom *, atom*> ((*iter), (*runner)) ) );
+                  }
+  for (std::vector<molecule *>::const_iterator MolWalker = molecules.begin(); MolWalker != molecules.end(); MolWalker++){
+    DoLog(2) && (Log()<< Verbose(2) << "Current molecule is " << *MolWalker << "." << endl);
+    for (molecule::const_iterator iter = (*MolWalker)->begin(); iter != (*MolWalker)->end(); ++iter) {
+      DoLog(3) && (Log() << Verbose(3) << "Current atom is " << **iter << "." << endl);
+      for (std::vector<molecule *>::const_iterator MolOtherWalker = MolWalker; MolOtherWalker != molecules.end(); MolOtherWalker++){
+        DoLog(2) && (Log() << Verbose(2) << "Current other molecule is " << *MolOtherWalker << "." << endl);
+        for (molecule::const_iterator runner = (*MolOtherWalker)->begin(); runner != (*MolOtherWalker)->end(); ++runner) {
+          DoLog(3) && (Log() << Verbose(3) << "Current otheratom is " << **runner << "." << endl);
+          if ((*iter)->getId() < (*runner)->getId()){
+            for (set <pair<element *, element *> >::iterator PairRunner = PairsOfElements.begin(); PairRunner != PairsOfElements.end(); ++PairRunner)
+              if ((PairRunner->first == (**iter).type) && (PairRunner->second == (**runner).type)) {
+                distance = domain.periodicDistance(*(*iter)->node,*(*runner)->node);
+                //Log() << Verbose(1) <<"Inserting " << *(*iter) << " and " << *(*runner) << endl;
+                outmap->insert ( pair<double, pair <atom *, atom*> > (distance, pair<atom *, atom*> ((*iter), (*runner)) ) );
+              }
+            }
+          }
+        }
 …
  * \return Map of doubles with values the pair of the two atoms.
  */
 PairCorrelationMap *PeriodicPairCorrelation(MoleculeListClass * const &molecules, const std::vector<element *> &elements, const int ranges[NDIM] )
+PairCorrelationMap *PeriodicPairCorrelation(std::vector<molecule *> &molecules, const std::vector<element *> &elements, const int ranges[NDIM] )
+{
   Info FunctionInfo(__func__);
 …
   Vector periodicOtherX;
   if (molecules->ListOfMolecules.empty()) {
+  if (molecules.empty()) {
     DoeLog(1) && (eLog()<< Verbose(1) <<"No molecule given." << endl);
     return outmap;
+  }
   for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin(); MolWalker != molecules->ListOfMolecules.end(); MolWalker++)
+  for (std::vector<molecule *>::const_iterator MolWalker = molecules.begin(); MolWalker != molecules.end(); MolWalker++)
     (*MolWalker)->doCountAtoms();
 …
   outmap = new PairCorrelationMap;
+  for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin(); MolWalker != molecules->ListOfMolecules.end(); MolWalker++){
+    if ((*MolWalker)->ActiveFlag) {
+      Matrix FullMatrix = World::getInstance().getDomain().getM();
+      Matrix FullInverseMatrix = World::getInstance().getDomain().getMinv();
+      DoeLog(2) && (eLog()<< Verbose(2) << "Current molecule is " << *MolWalker << "." << endl);
+      eLog() << Verbose(2) << "Current molecule is " << *MolWalker << "." << endl;
+      for (molecule::const_iterator iter = (*MolWalker)->begin(); iter != (*MolWalker)->end(); ++iter) {
+        DoLog(3) && (Log() << Verbose(3) << "Current atom is " << **iter << "." << endl);
+        periodicX = FullInverseMatrix * (*(*iter)->node); // x now in [0,1)^3
+        // go through every range in xyz and get distance
+        for (n[0]=-ranges[0]; n[0] <= ranges[0]; n[0]++)
+          for (n[1]=-ranges[1]; n[1] <= ranges[1]; n[1]++)
+            for (n[2]=-ranges[2]; n[2] <= ranges[2]; n[2]++) {
+              checkX = FullMatrix * (Vector(n[0], n[1], n[2]) + periodicX);
+              for (MoleculeList::const_iterator MolOtherWalker = MolWalker; MolOtherWalker != molecules->ListOfMolecules.end(); MolOtherWalker++){
+                if ((*MolOtherWalker)->ActiveFlag) {
+                  DoLog(2) && (Log() << Verbose(2) << "Current other molecule is " << *MolOtherWalker << "." << endl);
+                  for (molecule::const_iterator runner = (*MolOtherWalker)->begin(); runner != (*MolOtherWalker)->end(); ++runner) {
+                    DoLog(3) && (Log() << Verbose(3) << "Current otheratom is " << **runner << "." << endl);
+                    if ((*iter)->getId() < (*runner)->getId()){
+                      for (set <pair<element *, element *> >::iterator PairRunner = PairsOfElements.begin(); PairRunner != PairsOfElements.end(); ++PairRunner)
+                        if ((PairRunner->first == (**iter).type) && (PairRunner->second == (**runner).type)) {
+                          periodicOtherX = FullInverseMatrix * (*(*runner)->node); // x now in [0,1)^3
+                          // go through every range in xyz and get distance
+                          for (Othern[0]=-ranges[0]; Othern[0] <= ranges[0]; Othern[0]++)
+                            for (Othern[1]=-ranges[1]; Othern[1] <= ranges[1]; Othern[1]++)
+                              for (Othern[2]=-ranges[2]; Othern[2] <= ranges[2]; Othern[2]++) {
+                                checkOtherX = FullMatrix * (Vector(Othern[0], Othern[1], Othern[2]) + periodicOtherX);
+                                distance = checkX.distance(checkOtherX);
+                                //Log() << Verbose(1) <<"Inserting " << *(*iter) << " and " << *(*runner) << endl;
+                                outmap->insert ( pair<double, pair <atom *, atom*> > (distance, pair<atom *, atom*> ((*iter), (*runner)) ) );
+                              }
+                        }
+  for (std::vector<molecule *>::const_iterator MolWalker = molecules.begin(); MolWalker != molecules.end(); MolWalker++){
+    Matrix FullMatrix = World::getInstance().getDomain().getM();
+    Matrix FullInverseMatrix = World::getInstance().getDomain().getMinv();
+    DoLog(2) && (Log()<< Verbose(2) << "Current molecule is " << *MolWalker << "." << endl);
+    for (molecule::const_iterator iter = (*MolWalker)->begin(); iter != (*MolWalker)->end(); ++iter) {
+      DoLog(3) && (Log() << Verbose(3) << "Current atom is " << **iter << "." << endl);
+      periodicX = FullInverseMatrix * (*(*iter)->node); // x now in [0,1)^3
+      // go through every range in xyz and get distance
+      for (n[0]=-ranges[0]; n[0] <= ranges[0]; n[0]++)
+        for (n[1]=-ranges[1]; n[1] <= ranges[1]; n[1]++)
+          for (n[2]=-ranges[2]; n[2] <= ranges[2]; n[2]++) {
+            checkX = FullMatrix * (Vector(n[0], n[1], n[2]) + periodicX);
+            for (std::vector<molecule *>::const_iterator MolOtherWalker = MolWalker; MolOtherWalker != molecules.end(); MolOtherWalker++){
+                DoLog(2) && (Log() << Verbose(2) << "Current other molecule is " << *MolOtherWalker << "." << endl);
+                for (molecule::const_iterator runner = (*MolOtherWalker)->begin(); runner != (*MolOtherWalker)->end(); ++runner) {
+                  DoLog(3) && (Log() << Verbose(3) << "Current otheratom is " << **runner << "." << endl);
+                  if ((*iter)->getId() < (*runner)->getId()){
+                    for (set <pair<element *, element *> >::iterator PairRunner = PairsOfElements.begin(); PairRunner != PairsOfElements.end(); ++PairRunner)
+                      if ((PairRunner->first == (**iter).type) && (PairRunner->second == (**runner).type)) {
+                        periodicOtherX = FullInverseMatrix * (*(*runner)->node); // x now in [0,1)^3
+                        // go through every range in xyz and get distance
+                        for (Othern[0]=-ranges[0]; Othern[0] <= ranges[0]; Othern[0]++)
+                          for (Othern[1]=-ranges[1]; Othern[1] <= ranges[1]; Othern[1]++)
+                            for (Othern[2]=-ranges[2]; Othern[2] <= ranges[2]; Othern[2]++) {
+                              checkOtherX = FullMatrix * (Vector(Othern[0], Othern[1], Othern[2]) + periodicOtherX);
+                              distance = checkX.distance(checkOtherX);
+                              //Log() << Verbose(1) <<"Inserting " << *(*iter) << " and " << *(*runner) << endl;
+                              outmap->insert ( pair<double, pair <atom *, atom*> > (distance, pair<atom *, atom*> ((*iter), (*runner)) ) );
+                            }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+      }
+    }
 …
  * \return Map of dobules with values as pairs of atom and the vector
  */
 CorrelationToPointMap *CorrelationToPoint(MoleculeListClass * const &molecules, const std::vector<element *> &elements, const Vector *point )
+CorrelationToPointMap *CorrelationToPoint(std::vector<molecule *> &molecules, const std::vector<element *> &elements, const Vector *point )
+{
   Info FunctionInfo(__func__);
 …
   Box &domain = World::getInstance().getDomain();
   if (molecules->ListOfMolecules.empty()) {
+  if (molecules.empty()) {
     DoLog(1) && (Log() << Verbose(1) <<"No molecule given." << endl);
     return outmap;
+  }
   for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin(); MolWalker != molecules->ListOfMolecules.end(); MolWalker++)
+  for (std::vector<molecule *>::const_iterator MolWalker = molecules.begin(); MolWalker != molecules.end(); MolWalker++)
     (*MolWalker)->doCountAtoms();
   outmap = new CorrelationToPointMap;
+  for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin(); MolWalker != molecules->ListOfMolecules.end(); MolWalker++)
+    if ((*MolWalker)->ActiveFlag) {
+      DoLog(2) && (Log() << Verbose(2) << "Current molecule is " << *MolWalker << "." << endl);
+      for (molecule::const_iterator iter = (*MolWalker)->begin(); iter != (*MolWalker)->end(); ++iter) {
+        DoLog(3) && (Log() << Verbose(3) << "Current atom is " << **iter << "." << endl);
+        for (vector<element *>::const_iterator type = elements.begin(); type != elements.end(); ++type)
+          if ((*type == NULL) || ((*iter)->type == *type)) {
+            distance = domain.periodicDistance(*(*iter)->node,*point);
+            DoLog(4) && (Log() << Verbose(4) << "Current distance is " << distance << "." << endl);
+            outmap->insert ( pair<double, pair<atom *, const Vector*> >(distance, pair<atom *, const Vector*> ((*iter), point) ) );
+          }
+      }
+    }
+  for (std::vector<molecule *>::const_iterator MolWalker = molecules.begin(); MolWalker != molecules.end(); MolWalker++) {
+    DoLog(2) && (Log() << Verbose(2) << "Current molecule is " << *MolWalker << "." << endl);
+    for (molecule::const_iterator iter = (*MolWalker)->begin(); iter != (*MolWalker)->end(); ++iter) {
+      DoLog(3) && (Log() << Verbose(3) << "Current atom is " << **iter << "." << endl);
+      for (vector<element *>::const_iterator type = elements.begin(); type != elements.end(); ++type)
+        if ((*type == NULL) || ((*iter)->type == *type)) {
+          distance = domain.periodicDistance(*(*iter)->node,*point);
+          DoLog(4) && (Log() << Verbose(4) << "Current distance is " << distance << "." << endl);
+          outmap->insert ( pair<double, pair<atom *, const Vector*> >(distance, pair<atom *, const Vector*> ((*iter), point) ) );
+        }
+    }
+  }
   return outmap;
 …
  * \return Map of dobules with values as pairs of atom and the vector
  */
 CorrelationToPointMap *PeriodicCorrelationToPoint(MoleculeListClass * const &molecules, const std::vector<element *> &elements, const Vector *point, const int ranges[NDIM] )
+CorrelationToPointMap *PeriodicCorrelationToPoint(std::vector<molecule *> &molecules, const std::vector<element *> &elements, const Vector *point, const int ranges[NDIM] )
+{
   Info FunctionInfo(__func__);
 …
   Vector checkX;
   if (molecules->ListOfMolecules.empty()) {
+  if (molecules.empty()) {
     DoLog(1) && (Log() << Verbose(1) <<"No molecule given." << endl);
     return outmap;
+  }
   for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin(); MolWalker != molecules->ListOfMolecules.end(); MolWalker++)
+  for (std::vector<molecule *>::const_iterator MolWalker = molecules.begin(); MolWalker != molecules.end(); MolWalker++)
     (*MolWalker)->doCountAtoms();
   outmap = new CorrelationToPointMap;
+  for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin(); MolWalker != molecules->ListOfMolecules.end(); MolWalker++)
+    if ((*MolWalker)->ActiveFlag) {
+      Matrix FullMatrix = World::getInstance().getDomain().getM();
+      Matrix FullInverseMatrix = World::getInstance().getDomain().getMinv();
+      DoLog(2) && (Log() << Verbose(2) << "Current molecule is " << *MolWalker << "." << endl);
+      for (molecule::const_iterator iter = (*MolWalker)->begin(); iter != (*MolWalker)->end(); ++iter) {
+        DoLog(3) && (Log() << Verbose(3) << "Current atom is " << **iter << "." << endl);
+        for (vector<element *>::const_iterator type = elements.begin(); type != elements.end(); ++type)
+          if ((*type == NULL) || ((*iter)->type == *type)) {
+            periodicX = FullInverseMatrix * (*(*iter)->node); // x now in [0,1)^3
+            // go through every range in xyz and get distance
+            for (n[0]=-ranges[0]; n[0] <= ranges[0]; n[0]++)
+              for (n[1]=-ranges[1]; n[1] <= ranges[1]; n[1]++)
+                for (n[2]=-ranges[2]; n[2] <= ranges[2]; n[2]++) {
+                  checkX = FullMatrix * (Vector(n[0], n[1], n[2]) + periodicX);
+                  distance = checkX.distance(*point);
+                  DoLog(4) && (Log() << Verbose(4) << "Current distance is " << distance << "." << endl);
+                  outmap->insert ( pair<double, pair<atom *, const Vector*> >(distance, pair<atom *, const Vector*> (*iter, point) ) );
+                }
+          }
+      }
+    }
+  for (std::vector<molecule *>::const_iterator MolWalker = molecules.begin(); MolWalker != molecules.end(); MolWalker++) {
+    Matrix FullMatrix = World::getInstance().getDomain().getM();
+    Matrix FullInverseMatrix = World::getInstance().getDomain().getMinv();
+    DoLog(2) && (Log() << Verbose(2) << "Current molecule is " << *MolWalker << "." << endl);
+    for (molecule::const_iterator iter = (*MolWalker)->begin(); iter != (*MolWalker)->end(); ++iter) {
+      DoLog(3) && (Log() << Verbose(3) << "Current atom is " << **iter << "." << endl);
+      for (vector<element *>::const_iterator type = elements.begin(); type != elements.end(); ++type)
+        if ((*type == NULL) || ((*iter)->type == *type)) {
+          periodicX = FullInverseMatrix * (*(*iter)->node); // x now in [0,1)^3
+          // go through every range in xyz and get distance
+          for (n[0]=-ranges[0]; n[0] <= ranges[0]; n[0]++)
+            for (n[1]=-ranges[1]; n[1] <= ranges[1]; n[1]++)
+              for (n[2]=-ranges[2]; n[2] <= ranges[2]; n[2]++) {
+                checkX = FullMatrix * (Vector(n[0], n[1], n[2]) + periodicX);
+                distance = checkX.distance(*point);
+                DoLog(4) && (Log() << Verbose(4) << "Current distance is " << distance << "." << endl);
+                outmap->insert ( pair<double, pair<atom *, const Vector*> >(distance, pair<atom *, const Vector*> (*iter, point) ) );
+              }
+        }
+    }
+  }
   return outmap;
 …
  * \return Map of doubles with values as pairs of atom and the BoundaryTriangleSet that's closest
  */
 CorrelationToSurfaceMap *CorrelationToSurface(MoleculeListClass * const &molecules, const std::vector<element *> &elements, const Tesselation * const Surface, const LinkedCell *LC )
+CorrelationToSurfaceMap *CorrelationToSurface(std::vector<molecule *> &molecules, const std::vector<element *> &elements, const Tesselation * const Surface, const LinkedCell *LC )
+{
   Info FunctionInfo(__func__);
 …
   Vector centroid;
   if ((Surface == NULL) || (LC == NULL) || (molecules->ListOfMolecules.empty())) {
+  if ((Surface == NULL) || (LC == NULL) || (molecules.empty())) {
     DoeLog(1) && (eLog()<< Verbose(1) <<"No Tesselation, no LinkedCell or no molecule given." << endl);
     return outmap;
+  }
   for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin(); MolWalker != molecules->ListOfMolecules.end(); MolWalker++)
+  for (std::vector<molecule *>::const_iterator MolWalker = molecules.begin(); MolWalker != molecules.end(); MolWalker++)
     (*MolWalker)->doCountAtoms();
   outmap = new CorrelationToSurfaceMap;
+  for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin(); MolWalker != molecules->ListOfMolecules.end(); MolWalker++)
+    if ((*MolWalker)->ActiveFlag) {
+      DoLog(1) && (Log() << Verbose(1) << "Current molecule is " << (*MolWalker)->name << "." << endl);
+      if ((*MolWalker)->empty())
+        DoLog(1) && (1) && (Log() << Verbose(1) << "\t is empty." << endl);
+      for (molecule::const_iterator iter = (*MolWalker)->begin(); iter != (*MolWalker)->end(); ++iter) {
+        DoLog(1) && (Log() << Verbose(1) << "\tCurrent atom is " << *(*iter) << "." << endl);
+        for (vector<element *>::const_iterator type = elements.begin(); type != elements.end(); ++type)
+          if ((*type == NULL) || ((*iter)->type == *type)) {
+            TriangleIntersectionList Intersections((*iter)->node,Surface,LC);
+            distance = Intersections.GetSmallestDistance();
+            triangle = Intersections.GetClosestTriangle();
+            outmap->insert ( pair<double, pair<atom *, BoundaryTriangleSet*> >(distance, pair<atom *, BoundaryTriangleSet*> ((*iter), triangle) ) );
+          }
+      }
+    } else {
+      DoLog(1) && (Log() << Verbose(1) << "molecule " << (*MolWalker)->name << " is not active." << endl);
+    }
+  for (std::vector<molecule *>::const_iterator MolWalker = molecules.begin(); MolWalker != molecules.end(); MolWalker++) {
+    DoLog(2) && (Log() << Verbose(2) << "Current molecule is " << (*MolWalker)->name << "." << endl);
+    if ((*MolWalker)->empty())
+      DoLog(2) && (2) && (Log() << Verbose(2) << "\t is empty." << endl);
+    for (molecule::const_iterator iter = (*MolWalker)->begin(); iter != (*MolWalker)->end(); ++iter) {
+      DoLog(3) && (Log() << Verbose(3) << "\tCurrent atom is " << *(*iter) << "." << endl);
+      for (vector<element *>::const_iterator type = elements.begin(); type != elements.end(); ++type)
+        if ((*type == NULL) || ((*iter)->type == *type)) {
+          TriangleIntersectionList Intersections((*iter)->node,Surface,LC);
+          distance = Intersections.GetSmallestDistance();
+          triangle = Intersections.GetClosestTriangle();
+          outmap->insert ( pair<double, pair<atom *, BoundaryTriangleSet*> >(distance, pair<atom *, BoundaryTriangleSet*> ((*iter), triangle) ) );
+        }
+    }
+  }
   return outmap;
 …
  * \return Map of doubles with values as pairs of atom and the BoundaryTriangleSet that's closest
  */
 CorrelationToSurfaceMap *PeriodicCorrelationToSurface(MoleculeListClass * const &molecules, const std::vector<element *> &elements, const Tesselation * const Surface, const LinkedCell *LC, const int ranges[NDIM] )
+CorrelationToSurfaceMap *PeriodicCorrelationToSurface(std::vector<molecule *> &molecules, const std::vector<element *> &elements, const Tesselation * const Surface, const LinkedCell *LC, const int ranges[NDIM] )
+{
   Info FunctionInfo(__func__);
 …
   Vector checkX;
   if ((Surface == NULL) || (LC == NULL) || (molecules->ListOfMolecules.empty())) {
+  if ((Surface == NULL) || (LC == NULL) || (molecules.empty())) {
     DoLog(1) && (Log() << Verbose(1) <<"No Tesselation, no LinkedCell or no molecule given." << endl);
     return outmap;
+  }
   for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin(); MolWalker != molecules->ListOfMolecules.end(); MolWalker++)
+  for (std::vector<molecule *>::const_iterator MolWalker = molecules.begin(); MolWalker != molecules.end(); MolWalker++)
     (*MolWalker)->doCountAtoms();
   outmap = new CorrelationToSurfaceMap;
   double ShortestDistance = 0.;
   BoundaryTriangleSet *ShortestTriangle = NULL;
+  for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin(); MolWalker != molecules->ListOfMolecules.end(); MolWalker++)
+    if ((*MolWalker)->ActiveFlag) {
+      Matrix FullMatrix = World::getInstance().getDomain().getM();
+      Matrix FullInverseMatrix = World::getInstance().getDomain().getMinv();
+      DoLog(2) && (Log() << Verbose(2) << "Current molecule is " << *MolWalker << "." << endl);
+      for (molecule::const_iterator iter = (*MolWalker)->begin(); iter != (*MolWalker)->end(); ++iter) {
+        DoLog(3) && (Log() << Verbose(3) << "Current atom is " << **iter << "." << endl);
+        for (vector<element *>::const_iterator type = elements.begin(); type != elements.end(); ++type)
+          if ((*type == NULL) || ((*iter)->type == *type)) {
+            periodicX = FullInverseMatrix * (*(*iter)->node); // x now in [0,1)^3
+            // go through every range in xyz and get distance
+            ShortestDistance = -1.;
+            for (n[0]=-ranges[0]; n[0] <= ranges[0]; n[0]++)
+              for (n[1]=-ranges[1]; n[1] <= ranges[1]; n[1]++)
+                for (n[2]=-ranges[2]; n[2] <= ranges[2]; n[2]++) {
+                  checkX = FullMatrix * (Vector(n[0], n[1], n[2]) + periodicX);
+                  TriangleIntersectionList Intersections(&checkX,Surface,LC);
+                  distance = Intersections.GetSmallestDistance();
+                  triangle = Intersections.GetClosestTriangle();
+                  if ((ShortestDistance == -1.) || (distance < ShortestDistance)) {
+                    ShortestDistance = distance;
+                    ShortestTriangle = triangle;
+                  }
+  for (std::vector<molecule *>::const_iterator MolWalker = molecules.begin(); MolWalker != molecules.end(); MolWalker++) {
+    Matrix FullMatrix = World::getInstance().getDomain().getM();
+    Matrix FullInverseMatrix = World::getInstance().getDomain().getMinv();
+    DoLog(2) && (Log() << Verbose(2) << "Current molecule is " << *MolWalker << "." << endl);
+    for (molecule::const_iterator iter = (*MolWalker)->begin(); iter != (*MolWalker)->end(); ++iter) {
+      DoLog(3) && (Log() << Verbose(3) << "Current atom is " << **iter << "." << endl);
+      for (vector<element *>::const_iterator type = elements.begin(); type != elements.end(); ++type)
+        if ((*type == NULL) || ((*iter)->type == *type)) {
+          periodicX = FullInverseMatrix * (*(*iter)->node); // x now in [0,1)^3
+          // go through every range in xyz and get distance
+          ShortestDistance = -1.;
+          for (n[0]=-ranges[0]; n[0] <= ranges[0]; n[0]++)
+            for (n[1]=-ranges[1]; n[1] <= ranges[1]; n[1]++)
+              for (n[2]=-ranges[2]; n[2] <= ranges[2]; n[2]++) {
+                checkX = FullMatrix * (Vector(n[0], n[1], n[2]) + periodicX);
+                TriangleIntersectionList Intersections(&checkX,Surface,LC);
+                distance = Intersections.GetSmallestDistance();
+                triangle = Intersections.GetClosestTriangle();
+                if ((ShortestDistance == -1.) || (distance < ShortestDistance)) {
+                  ShortestDistance = distance;
+                  ShortestTriangle = triangle;
+                }
+            // insert
+            outmap->insert ( pair<double, pair<atom *, BoundaryTriangleSet*> >(ShortestDistance, pair<atom *, BoundaryTriangleSet*> (*iter, ShortestTriangle) ) );
+            //Log() << Verbose(1) << "INFO: Inserting " << Walker << " with distance " << ShortestDistance << " to " << *ShortestTriangle << "." << endl;
+          }
+      }
+    }
+              }
+          // insert
+          outmap->insert ( pair<double, pair<atom *, BoundaryTriangleSet*> >(ShortestDistance, pair<atom *, BoundaryTriangleSet*> (*iter, ShortestTriangle) ) );
+          //Log() << Verbose(1) << "INFO: Inserting " << Walker << " with distance " << ShortestDistance << " to " << *ShortestTriangle << "." << endl;
+        }
+    }
+  }
   return outmap;

src/analysis_correlation.hpp

-              r7067bd6
+              r677e13
 // STL headers
 #include <map>
+#include <vector>
 #include "defs.hpp"
 …
 class element;
 class LinkedCell;
-class MoleculeListClass;
 class Tesselation;
 class Vector;
 …
 /********************************************** declarations *******************************/
 PairCorrelationMap *PairCorrelation(MoleculeListClass * const &molecules, const std::vector<element *> &elements);
 CorrelationToPointMap *CorrelationToPoint(MoleculeListClass * const &molecules, const std::vector<element *> &elements, const Vector *point );
 CorrelationToSurfaceMap *CorrelationToSurface(MoleculeListClass * const &molecules, const std::vector<element *> &elements, const Tesselation * const Surface, const LinkedCell *LC );
 PairCorrelationMap *PeriodicPairCorrelation(MoleculeListClass * const &molecules, const std::vector<element *> &elements, const int ranges[NDIM] );
 CorrelationToPointMap *PeriodicCorrelationToPoint(MoleculeListClass * const &molecules, const std::vector<element *> &elements, const Vector *point, const int ranges[NDIM] );
 CorrelationToSurfaceMap *PeriodicCorrelationToSurface(MoleculeListClass * const &molecules, const std::vector<element *> &elements, const Tesselation * const Surface, const LinkedCell *LC, const int ranges[NDIM] );
+PairCorrelationMap *PairCorrelation(std::vector<molecule *> &molecules, const std::vector<element *> &elements);
+CorrelationToPointMap *CorrelationToPoint(std::vector<molecule *> &molecules, const std::vector<element *> &elements, const Vector *point );
+CorrelationToSurfaceMap *CorrelationToSurface(std::vector<molecule *> &molecules, const std::vector<element *> &elements, const Tesselation * const Surface, const LinkedCell *LC );
+PairCorrelationMap *PeriodicPairCorrelation(std::vector<molecule *> &molecules, const std::vector<element *> &elements, const int ranges[NDIM] );
+CorrelationToPointMap *PeriodicCorrelationToPoint(std::vector<molecule *> &molecules, const std::vector<element *> &elements, const Vector *point, const int ranges[NDIM] );
+CorrelationToSurfaceMap *PeriodicCorrelationToSurface(std::vector<molecule *> &molecules, const std::vector<element *> &elements, const Tesselation * const Surface, const LinkedCell *LC, const int ranges[NDIM] );
 int GetBin ( const double value, const double BinWidth, const double BinStart );
 void OutputCorrelation( ofstream * const file, const BinPairMap * const map );

src/unittests/ActionSequenceTest.cpp

-              r7067bd6
+              r677e13
   virtual ~canUndoActionStub(){}
+  virtual Dialog* createDialog(){
+    return NULL;
+  }
   virtual Action::state_ptr performCall(){
     return Action::success;
 …
   cannotUndoActionStub() : Action("cannotUndoActionStub",false){}
   virtual ~cannotUndoActionStub(){}
+  virtual Dialog* createDialog(){
+    return NULL;
+  }
   virtual Action::state_ptr performCall(){
 …
   virtual ~wasCalledActionStub(){}
+  virtual Dialog* createDialog(){
+    return NULL;
+  }
   virtual Action::state_ptr performCall(){
     called = true;

src/unittests/AnalysisCorrelationToPointUnitTest.cpp

-              r7067bd6
+              r677e13
 #include "analysis_correlation.hpp"
 #include "AnalysisCorrelationToPointUnitTest.hpp"
+#include "Descriptors/MoleculeDescriptor.hpp"
 #include "atom.hpp"
 …
   // init private all pointers to zero
-  TestList = NULL;
   TestMolecule = NULL;
   pointmap = NULL;
 …
   CPPUNIT_ASSERT_EQUAL( TestMolecule->getAtomCount(), 4 );
-  TestList = World::getInstance().getMolecules();
-  TestList->insert(TestMolecule);
   TestMolecule->ActiveFlag = true;
 …
   // init maps
+  pointmap = CorrelationToPoint( (MoleculeListClass * const)TestList, elements, (const Vector *)point );
+  World::getInstance().selectAllMolecules(AllMolecules());
+  allMolecules = World::getInstance().getSelectedMolecules();
+  CPPUNIT_ASSERT_EQUAL( (size_t) 1, allMolecules.size());
+  pointmap = CorrelationToPoint( allMolecules, elements, (const Vector *)point );
   binmap = NULL;

src/unittests/AnalysisCorrelationToPointUnitTest.hpp

r7067bd6	r677e13
35	35	private:
36	36
37		~~MoleculeListClass *TestList~~;
	37	std::vector<molecule *> allMolecules;
38	38	molecule *TestMolecule;
39	39	element *hydrogen;

src/unittests/AnalysisCorrelationToSurfaceUnitTest.cpp

-              r7067bd6
+              r677e13
 #include "analysis_correlation.hpp"
 #include "AnalysisCorrelationToSurfaceUnitTest.hpp"
+#include "Descriptors/MoleculeDescriptor.hpp"
 #include "atom.hpp"
 …
   // init private all pointers to zero
-  TestList = NULL;
   TestSurfaceMolecule = NULL;
   surfacemap = NULL;
 …
   CPPUNIT_ASSERT_EQUAL( TestSurfaceMolecule->getAtomCount(), 4 );
-  TestList = World::getInstance().getMolecules();
   TestSurfaceMolecule->ActiveFlag = true;
-  TestList->insert(TestSurfaceMolecule);
   // init tesselation and linked cell
 …
   TestSurfaceMolecule->AddAtom(Walker);
+  TestSurfaceMolecule->ActiveFlag = true;
+  TestList->insert(TestSurfaceMolecule);
+  World::getInstance().selectAllMolecules(AllMolecules());
+  allMolecules = World::getInstance().getSelectedMolecules();
+  CPPUNIT_ASSERT_EQUAL( (size_t) 2, allMolecules.size());
   // init maps
 …
+{
   CPPUNIT_ASSERT_EQUAL( 4, TestSurfaceMolecule->getAtomCount() );
   CPPUNIT_ASSERT_EQUAL( (size_t)2, TestList->ListOfMolecules.size() );
+  CPPUNIT_ASSERT_EQUAL( (size_t)2, allMolecules.size() );
   CPPUNIT_ASSERT_EQUAL( (size_t)4, Surface->PointsOnBoundary.size() );
   CPPUNIT_ASSERT_EQUAL( (size_t)6, Surface->LinesOnBoundary.size() );
 …
   // do the pair correlation
   elements.push_back(hydrogen);
   surfacemap = CorrelationToSurface( TestList, elements, Surface, LC );
+  surfacemap = CorrelationToSurface( allMolecules, elements, Surface, LC );
 //  OutputCorrelationToSurface ( (ofstream *)&cout, surfacemap );
   CPPUNIT_ASSERT( surfacemap != NULL );
 …
   BinPairMap::iterator tester;
   elements.push_back(hydrogen);
   surfacemap = CorrelationToSurface( TestList, elements, Surface, LC );
+  surfacemap = CorrelationToSurface( allMolecules, elements, Surface, LC );
   // put pair correlation into bins and check with no range
 //  OutputCorrelationToSurface ( (ofstream *)&cout, surfacemap );
 …
   BinPairMap::iterator tester;
   elements.push_back(hydrogen);
   surfacemap = CorrelationToSurface( TestList, elements, Surface, LC );
+  surfacemap = CorrelationToSurface( allMolecules, elements, Surface, LC );
 //  OutputCorrelationToSurface ( (ofstream *)&cout, surfacemap );
   // ... and check with [0., 2.] range
 …
   BinPairMap::iterator tester;
   elements.push_back(carbon);
   surfacemap = CorrelationToSurface( TestList, elements, Surface, LC );
+  surfacemap = CorrelationToSurface( allMolecules, elements, Surface, LC );
 //  OutputCorrelationToSurface ( (ofstream *)&cout, surfacemap );
   // put pair correlation into bins and check with no range
 …
   BinPairMap::iterator tester;
   elements.push_back(carbon);
   surfacemap = CorrelationToSurface( TestList, elements, Surface, LC );
+  surfacemap = CorrelationToSurface( allMolecules, elements, Surface, LC );
 //  OutputCorrelationToSurface ( (ofstream *)&cout, surfacemap );
   // ... and check with [0., 2.] range

src/unittests/AnalysisCorrelationToSurfaceUnitTest.hpp

r7067bd6	r677e13
43	43	private:
44	44
45		~~MoleculeListClass *TestList~~;
	45	std::vector<molecule *> allMolecules;
46	46	molecule *TestSurfaceMolecule;
47	47	element *hydrogen;

src/unittests/AnalysisPairCorrelationUnitTest.cpp

-              r7067bd6
+              r677e13
 #include "analysis_correlation.hpp"
 #include "AnalysisPairCorrelationUnitTest.hpp"
+#include "Descriptors/MoleculeDescriptor.hpp"
 #include "World.hpp"
 …
   // init private all pointers to zero
-  TestList = NULL;
   TestMolecule = NULL;
   correlationmap = NULL;
 …
   CPPUNIT_ASSERT_EQUAL( TestMolecule->getAtomCount(), 4 );
-  TestList = World::getInstance().getMolecules();
-  TestMolecule->ActiveFlag = true;
-  TestList->insert(TestMolecule);
   // init maps
+  correlationmap = PairCorrelation( TestList, elements);
+  World::getInstance().selectAllMolecules(AllMolecules());
+  allMolecules = World::getInstance().getSelectedMolecules();
+  CPPUNIT_ASSERT_EQUAL( (size_t) 1, allMolecules.size());
+  correlationmap = PairCorrelation( allMolecules, elements);
   binmap = NULL;

src/unittests/AnalysisPairCorrelationUnitTest.hpp

r7067bd6	r677e13
35	35	private:
36	36
37		~~MoleculeListClass *TestList~~;
	37	std::vector<molecule *> allMolecules;
38	38	molecule *TestMolecule;
39	39	element *hydrogen;

test_all.sh

-              r7067bd6
+              r677e13
 outfile="test.log";
 logfile="full.log";
+noprocs=1;
 docheck=0;
 docheck_mem=0;
 …
   echo "  -o <outfile>          Outfile to use for test results";
   echo "  -f <logfile>          File to use for output from commands";
+  echo "  -j <no_proc>          Parallel compiling and tests";
   echo "  -s                    Short tests (no memcheck)";
   echo "  -c                    Only configure and compile (implies -s)";
   echo "  -O <opt-level>        Only compile this optimization level";
   echo "  -t <tmpDir>           Use tmpDir as temporary directory";
   echo "  -p <prefix>           Prefix to use for directory names (standart MolecuilderTest)";
+}
 while getopts âho:f:scO:t:p:â OPTION
+  echo "  -p <prefix>           Prefix to use for directory names (standard MolecuilderTest)";
+}
+while getopts âho:f:j:scO:t:p:â OPTION
 do
   case $OPTION in
 …
      logfile="$OPTARG";
      ;;
+   j)
+     noprocs=("$OPTARG");
+     ;;
    s)
      docheck_mem=1;
 …
 function compile(){
   echo "Making";
+  make all install >>$logfile 2>&1;
+  if [ $noprocs -gt 1 ]; then
+    make -j$noprocs all install >>$logfile 2>&1;
+  else
+    make all install >>$logfile 2>&1;
+  fi
+}
 function check(){
   echo "Checking";
+  make check >> $logfile 2>&1;
+  if [ $noprocs -gt 1 ]; then
+    make -j$noprocs check >> $logfile 2>&1;
+  else
+    make check >> $logfile 2>&1;
+  fi
+}

tests/Tesselations/defs.in

-              r7067bd6
+              r677e13
         #echo "Current dir is `pwd`, calling $MOLECUILDER $mol.conf -e $exec_prefix -p ../$mol.xyz -N $RADIUS $FILENAME."
         if [ -e $mol.dbond ]; then
                 $MOLECUILDER $mol.conf -e $exec_prefix -p ../$mol.xyz -A $mol.dbond -N 0 --sphere-radius $RADIUS --nonconvex-file $FILENAME 2>stderr >stdout || exitcode=$?
+                $MOLECUILDER $mol.conf -e $exec_prefix -p ../$mol.xyz -A $mol.dbond --select-molecule-by-id 0 -N $RADIUS --nonconvex-file $FILENAME 2>stderr >stdout || exitcode=$?
         else
                 $MOLECUILDER $mol.conf -e $exec_prefix -p ../$mol.xyz -N 0 --sphere-radius $RADIUS --nonconvex-file $FILENAME 2>stderr >stdout || exitcode=$?
+                $MOLECUILDER $mol.conf -e $exec_prefix -p ../$mol.xyz --select-molecule-by-id 0 -N $RADIUS --nonconvex-file $FILENAME 2>stderr >stdout || exitcode=$?
         fi
         #echo "Molecuilder done with exitcode $exitcode."

tests/Tesselations/heptan/1.5/NonConvexEnvelope-heptan.dat

-              r7067bd6
+              r677e13
 .2492 0.921941 -0.849545 18.7222
 .2492 0.921941 0.930455 18.7222
 -2.4985 -1.22006 -0.849545 27.4727
+-2.4985 -1.22006 -0.849545 19.9769
 -2.4985 -1.22006 0.930455 19.9769
 .4985 -1.22006 0.930455 27.4727
 .4985 -1.22006 -0.849545 19.9769
+.4985 -1.22006 -0.849545 27.4727
 -4.6377 -0.336759 0.0404545 21.541
 -3.7477 0.921941 0.930455 18.8853
 …
 -1.2492 0.292641 0.0404545 23.0167
 .2492 0.292641 0.0404545 23.0172
 -2.4985 -0.590759 0.0404545 18.9798
 .4985 -0.590759 0.0404545 18.9798
+-2.4985 -0.590759 0.0404545 21.8516
+.4985 -0.590759 0.0404545 16.0669
 -3.7477 0.292641 0.0404545 39.5267
 .7477 0.292641 0.0404545 20.5497
 …
 2 17
 2 17
 17 21
 10 21
+17 21
+10 17
 17 20
 8 20
 …
 11 20
 11 20
 17 20
 7 17
+17 20
+7 20

tests/regression/testsuite-analysis.at

-              r7067bd6
+              r677e13
 AT_KEYWORDS([analysis])
 AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Analysis/1/pre/test.conf .], 0)
 AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -v 3 -C E --elements 1 8 --output-file output.csv --bin-output-file bin_output.csv --bin-start 0 --bin-end 20], 0, [stdout], [stderr])
+AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -v 3 --select-all-molecules --pair-correlation --elements 1 8 --output-file output.csv --bin-output-file bin_output.csv --bin-start 0 --bin-end 20], 0, [stdout], [stderr])
 AT_CHECK([fgrep "Begin of PairCorrelation" stdout], 0, [ignore], [ignore])
 #AT_CHECK([file=output.csv; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Analysis/1/post/$file], 0, [ignore], [ignore])
 …
 AT_KEYWORDS([analysis])
 AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Analysis/2/pre/test.conf .], 0)
 AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -v 3 -C E --elements 1 8 --output-file output-5.csv --bin-output-file bin_output-5.csv --bin-start 0 --bin-end 5], 0, [stdout], [stderr])
+AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -v 3 --select-all-molecules --pair-correlation --elements 1 8 --output-file output-5.csv --bin-output-file bin_output-5.csv --bin-start 0 --bin-end 5], 0, [stdout], [stderr])
 #AT_CHECK([file=output-5.csv; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Analysis/2/post/$file], 0, [ignore], [ignore])
 AT_CHECK([file=bin_output-5.csv; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Analysis/2/post/$file], 0, [ignore], [ignore])
 AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -v 3 -C E --elements 1 8 --output-file output-10.csv --bin-output-file bin_output-10.csv --bin-start 5 --bin-end 10], 0, [stdout], [stderr])
+AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -v 3 --select-all-molecules --pair-correlation --elements 1 8 --output-file output-10.csv --bin-output-file bin_output-10.csv --bin-start 5 --bin-end 10], 0, [stdout], [stderr])
 #AT_CHECK([file=output-10.csv; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Analysis/2/post/$file], 0, [ignore], [ignore])
 AT_CHECK([file=bin_output-10.csv; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Analysis/2/post/$file], 0, [ignore], [ignore])
 AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -v 3 -C E --elements 1 8 --output-file output-20.csv --bin-output-file bin_output-20.csv --bin-start 10 --bin-end 20], 0, [stdout], [stderr])
+AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -v 3 --select-all-molecules --pair-correlation --elements 1 8 --output-file output-20.csv --bin-output-file bin_output-20.csv --bin-start 10 --bin-end 20], 0, [stdout], [stderr])
 #AT_CHECK([file=output-20.csv; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Analysis/2/post/$file], 0, [ignore], [ignore])
 AT_CHECK([file=bin_output-20.csv; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Analysis/2/post/$file], 0, [ignore], [ignore])
 …
 AT_KEYWORDS([analysis])
 AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Analysis/3/pre/test.conf .], 0)
 AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -v 7 -C P --elements 1 --position "10., 10., 10." --output-file output.csv --bin-output-file bin_output.csv --bin-start 0 --bin-end 20], 0, [stdout], [stderr])
+AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -v 7 --select-all-molecules --point-correlation --elements 1 --position "10., 10., 10." --output-file output.csv --bin-output-file bin_output.csv --bin-start 0 --bin-end 20], 0, [stdout], [stderr])
 AT_CHECK([fgrep "Begin of CorrelationToPoint" stdout], 0, [ignore], [ignore])
 #AT_CHECK([file=output.csv; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Analysis/3/post/$file], 0, [ignore], [ignore])
 …
 AT_KEYWORDS([analysis])
 AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Analysis/4/pre/test.conf .], 0)
 AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -v 3 -I -C S --elements 1 --output-file output.csv --bin-output-file bin_output.csv --bin-start 0 --bin-width 1. --bin-end 20 --molecule-by-id 207], 0, [stdout], [stderr])
+AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -v 3 -I --select-all-molecules --unselect-molecule-by-id 207 --surface-correlation --elements 1 --output-file output.csv --bin-output-file bin_output.csv --bin-start 0 --bin-width 1. --bin-end 20 --molecule-by-id 207], 0, [stdout], [stderr])
 AT_CHECK([fgrep "Begin of CorrelationToSurface" stdout], 0, [ignore], [ignore])
 #AT_CHECK([file=output.csv; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Analysis/4/post/$file], 0, [ignore], [ignore])

tests/regression/testsuite-filling.at

r7067bd6	r677e13
18	18	AT_KEYWORDS([filling])
19	19	AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Filling/2/pre/test.conf .], 0)
20		AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -v 3 -~~u 1.3 --molecule-by-id 0~~], 0, [stdout], [stderr])
	20	AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -v 3 --select-molecule-by-id 0 -u 1.3], 0, [stdout], [stderr])
21	21	#AT_CHECK([file=test.conf; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Filling/2/post/$file], 0, [ignore], [ignore])
22	22	AT_CLEANUP

tests/regression/testsuite-fragmentation.at

-              r7067bd6
+              r677e13
 AT_SETUP([Fragmentation - Fragmentation])
 AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Fragmentation/2/pre/test.conf .], 0)
 AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -v 1 -f ./BondFragment --molecule-by-id 0 --distance 1.55 --order 2], 0, [ignore], [ignore])
+AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -v 1 --select-molecule-by-id 0 -f ./BondFragment --distance 1.55 --order 2], 0, [ignore], [ignore])
 AT_CHECK([ls -l BondFragment*.conf | wc -l], 0, [5
 ], [ignore])
 …
 AT_SETUP([Fragmentation - BROKEN: Fragmentation is at MaxOrder])
 AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Fragmentation/3/pre/test.conf .], 0)
 AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -v 1 -f ./BondFragment --molecule-by-id 0 --distance 1.55 --order 2], 0, [ignore], [ignore])
 AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -v 1 -f ./BondFragment --molecule-by-id 0 --distance 1.55 --order 2], [ignore], [ignore], [ignore])
+AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -v 1 --select-molecule-by-id 0 -f ./BondFragment --distance 1.55 --order 2], 0, [ignore], [ignore])
+AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -v 1 --select-molecule-by-id 0 -f ./BondFragment --distance 1.55 --order 2], [ignore], [ignore], [ignore])
 AT_CLEANUP

tests/regression/testsuite-molecules.at

-              r7067bd6
+              r677e13
 AT_KEYWORDS([Molecules])
 AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Molecules/1/pre/test.* .], 0)
 AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -v 4 -A test.dbond --molecule-by-id 0], 0, [stdout], [stderr])
+AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -v 4 --select-molecule-by-id 0 -A test.dbond], 0, [stdout], [stderr])
 AT_CHECK([fgrep "Looking for atoms 2 and 9." stdout], 0, [ignore], [ignore])
 AT_CLEANUP
 …
 AT_KEYWORDS([Molecules])
 AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Molecules/2/pre/test.conf .], 0)
 AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -v 1 -j test.dbond --molecule-by-id 0], 0, [stdout], [stderr])
+AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -v 1 --select-molecule-by-id 0 -j test.dbond], 0, [stdout], [stderr])
 AT_CHECK([file=test.dbond; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Molecules/2/post/$file], 0, [ignore], [ignore])
 AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -v 1 -J test.adj --molecule-by-id 0], 0, [stdout], [stderr])
+AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -v 1 --select-molecule-by-id 0 -J test.adj], 0, [stdout], [stderr])
 AT_CHECK([file=test.adj; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Molecules/2/post/$file], 0, [ignore], [ignore])
 AT_CLEANUP
 …
 AT_KEYWORDS([Molecules])
 AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Molecules/3/pre/test.conf .], 0)
 AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -S test.ekin --molecule-by-id 0], 0, [stdout], [stderr])
+AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ --select-molecule-by-id 0 -S test.ekin], 0, [stdout], [stderr])
 AT_CHECK([file=test.ekin; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Molecules/3/post/$file], 0, [ignore], [ignore])
 AT_CLEANUP
 …
 AT_KEYWORDS([Molecules])
 AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Molecules/4/pre/test.conf .], 0)
 AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -L teststep --start-step 0 --end-step 1 --molecule-by-id 0 --id-mapping 1], 0, [stdout], [stderr])
+AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ --select-molecule-by-id 0 -L teststep --start-step 0 --end-step 1 --id-mapping 1], 0, [stdout], [stderr])
 AT_CLEANUP
 …
 AT_KEYWORDS([Molecules])
 AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Molecules/5/pre/test.* .], 0)
 AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -P test.forces --molecule-by-id 0], 0, [stdout], [stderr])
+AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ --select-molecule-by-id 0 -P test.forces], 0, [stdout], [stderr])
 #AT_CHECK([file=test.conf; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Molecules/5/post/$file], 0, [ignore], [ignore])
 AT_CLEANUP
 …
 AT_KEYWORDS([Molecules])
 AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Molecules/6/pre/test.* .], 0)
 AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -t "1., 1., 1." --molecule-by-id 0 --periodic 0], 0, [stdout], [stderr])
+AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ --select-molecule-by-id 0 -t "1., 1., 1." --periodic 0], 0, [stdout], [stderr])
 AT_CHECK([file=test.conf; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Molecules/6/post/$file], 0, [ignore], [ignore])
 AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Molecules/6/pre/test2.* .], 0)
 AT_CHECK([../../molecuilder -i test2.conf -e ${abs_top_srcdir}/src/ -t "-1., -1., -1." --molecule-by-id 0 --periodic 0], 0, [stdout], [stderr])
+AT_CHECK([../../molecuilder -i test2.conf -e ${abs_top_srcdir}/src/ --select-molecule-by-id 0 -t "-1., -1., -1." --periodic 0], 0, [stdout], [stderr])
 AT_CHECK([file=test2.conf; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Molecules/6/post/$file], 0, [ignore], [ignore])
 AT_CLEANUP
 …
 AT_KEYWORDS([Molecules])
 AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Molecules/7/pre/test.* .], 0)
 AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -t "12., 12., 12." --molecule-by-id 0 --periodic 1], 0, [stdout], [stderr])
+AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ --select-molecule-by-id 0 -t "12., 12., 12." --periodic 1], 0, [stdout], [stderr])
 AT_CHECK([file=test.conf; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Molecules/7/post/$file], 0, [ignore], [ignore])
 AT_CLEANUP
 …
 AT_KEYWORDS([Molecules])
 AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Molecules/8/pre/test.* .], 0)
 AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -m 0], 0, [stdout], [stderr])
+AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ --select-molecule-by-id 0 -m 0], 0, [stdout], [stderr])
 #AT_CHECK([file=test.conf; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Molecules/8/post/$file], 0, [ignore], [ignore])
 AT_CLEANUP

tests/regression/testsuite-simple_configuration.at

-              r7067bd6
+              r677e13
 AT_CHECK([file=test.in; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/3/post/$file], 0, [ignore], [ignore])
 AT_CHECK([file=test.xyz; diff -I '.*Created by molecuilder.*' $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/3/post/$file], 0, [ignore], [ignore])
+AT_CHECK([../../molecuilder -i test2.conf -e ${abs_top_srcdir}/src/ -o mpqc pcp xyz -a 1 --position "0., 0., -1."], 0, [ignore], [ignore])
+AT_CHECK([file=test2.conf; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/3/post/$file], 0, [ignore], [ignore])
+AT_CHECK([file=test2.in; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/3/post/$file], 0, [ignore], [ignore])
+AT_CHECK([file=test2.xyz; diff -I '.*Created by molecuilder.*' $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/3/post/$file], 0, [ignore], [ignore])
+AT_CHECK([../../molecuilder -i test2.conf -e ${abs_top_srcdir}/src/ -o mpqc pcp xyz -a 1 --position "0., 0., -1."], 134, [ignore], [ignore])
 AT_CLEANUP
 …
 AT_KEYWORDS([configuration])
 AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/4/pre/test.xyz test.xyz], 0)
 AT_CHECK([../../molecuilder -i test.xyz -e ${abs_top_srcdir}/src/ -E 6 --atom-by-id 0], 0, [ignore], [ignore])
+AT_CHECK([../../molecuilder -i test.xyz -e ${abs_top_srcdir}/src/ --select-atom-by-id 0 -E 6 ], 0, [ignore], [ignore])
 AT_CHECK([file=test.xyz; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/4/post/$file], 0, [ignore], [ignore])
 AT_CLEANUP
 …
 AT_KEYWORDS([configuration])
 AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/5/pre/test.conf .], 0)
 AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -o mpqc pcp xyz -r 0], 0, [ignore], [ignore])
+AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -o mpqc pcp xyz --select-atom-by-id 0 -r], 0, [ignore], [ignore])
 AT_CHECK([file=test.conf; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/5/post/$file], 0, [ignore], [ignore])
 AT_CHECK([file=test.in; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/5/post/$file], 0, [ignore], [ignore])

tests/regression/testsuite-tesselation.at

-              r7067bd6
+              r677e13
 AT_KEYWORDS([Tesselation])
 AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Tesselation/1/pre/* .], 0)
 AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -N 0 --sphere-radius 4. --nonconvex-file NonConvexEnvelope], 0, [stdout], [stderr])
+AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ --select-molecule-by-id 0 -N 4. --nonconvex-file NonConvexEnvelope], 0, [stdout], [stderr])
 AT_CHECK([file=NonConvexEnvelope.dat; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Tesselation/1/post/$file], 0, [ignore], [ignore])
 #AT_CHECK([file=NonConvexEnvelope.r3d; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Tesselation/1/post/$file], 0, [ignore], [ignore])
 …
 AT_SETUP([Tesselation - Convex Envelope])
 AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Tesselation/2/pre/* .], 0)
 AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ --convex-envelope 0 --convex-file ConvexEnvelope --nonconvex-file NonConvexEnvelope], 0, [stdout], [stderr])
+AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ --select-molecule-by-id 0 --convex-envelope --convex-file ConvexEnvelope --nonconvex-file NonConvexEnvelope], 0, [stdout], [stderr])
 AT_CHECK([file=ConvexEnvelope.dat; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Tesselation/2/post/$file], 0, [ignore], [ignore])
 #AT_CHECK([file=ConvexEnvelope.r3d; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Tesselation/2/post/$file], 0, [ignore], [ignore])
 …
 AT_SETUP([Tesselation - Big non-Convex Envelope])
 AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Tesselation/3/pre/* .], 0)
 AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -N 0 --sphere-radius 4. --nonconvex-file NonConvexEnvelope], 0, [stdout], [stderr])
+AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ --select-molecule-by-id 0 -N 4. --nonconvex-file NonConvexEnvelope], 0, [stdout], [stderr])
 AT_CHECK([file=NonConvexEnvelope.dat; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Tesselation/3/post/$file], 0, [ignore], [ignore])
 #AT_CHECK([file=NonConvexEnvelope.r3d; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Tesselation/3/post/$file], 0, [ignore], [ignore])
 …
 #AT_SETUP([Tesselation - big convex Envelope])
 #AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Tesselation/4/pre/* .], 0)
 #AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ --convex-envelope ConvexEnvelope NonConvexEnvelope], 0, [stdout], [stderr])
+#AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ --select-molecule-by-id 0 --convex-envelope ConvexEnvelope NonConvexEnvelope], 0, [stdout], [stderr])
 #AT_CHECK([file=ConvexEnvelope.dat; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Tesselation/4/post/$file], 0, [ignore], [ignore])
 #AT_CHECK([file=ConvexEnvelope.r3d; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Tesselation/4/post/$file], 0, [ignore], [ignore])

Context Navigation

Changes in / [7067bd6:677e13]

Legend:

Download in other formats: