Changeset e4afb4 for src/UIElements

Timestamp:

Oct 30, 2010, 8:42:44 PM (15 years ago)

Author:

Frederik Heber <heber@…>

Branches:

Action_Thermostats, Add_AtomRandomPerturbation, Add_FitFragmentPartialChargesAction, Add_RotateAroundBondAction, Add_SelectAtomByNameAction, Added_ParseSaveFragmentResults, AddingActions_SaveParseParticleParameters, Adding_Graph_to_ChangeBondActions, Adding_MD_integration_tests, Adding_ParticleName_to_Atom, Adding_StructOpt_integration_tests, AtomFragments, Automaking_mpqc_open, AutomationFragmentation_failures, Candidate_v1.5.4, Candidate_v1.6.0, Candidate_v1.6.1, Candidate_v1.7.0, Candidate_v1.7.1, ChangeBugEmailaddress, ChangingTestPorts, ChemicalSpaceEvaluator, CombiningParticlePotentialParsing, Combining_Subpackages, Debian_Package_split, Debian_package_split_molecuildergui_only, Disabling_MemDebug, Docu_Python_wait, EmpiricalPotential_contain_HomologyGraph, EmpiricalPotential_contain_HomologyGraph_documentation, Enable_parallel_make_install, Enhance_userguide, Enhanced_StructuralOptimization, Enhanced_StructuralOptimization_continued, Example_ManyWaysToTranslateAtom, Exclude_Hydrogens_annealWithBondGraph, FitPartialCharges_GlobalError, Fix_BoundInBox_CenterInBox_MoleculeActions, Fix_ChargeSampling_PBC, Fix_ChronosMutex, Fix_FitPartialCharges, Fix_FitPotential_needs_atomicnumbers, Fix_ForceAnnealing, Fix_IndependentFragmentGrids, Fix_ParseParticles, Fix_ParseParticles_split_forward_backward_Actions, Fix_PopActions, Fix_QtFragmentList_sorted_selection, Fix_Restrictedkeyset_FragmentMolecule, Fix_StatusMsg, Fix_StepWorldTime_single_argument, Fix_Verbose_Codepatterns, Fix_fitting_potentials, Fixes, ForceAnnealing_goodresults, ForceAnnealing_oldresults, ForceAnnealing_tocheck, ForceAnnealing_with_BondGraph, ForceAnnealing_with_BondGraph_continued, ForceAnnealing_with_BondGraph_continued_betteresults, ForceAnnealing_with_BondGraph_contraction-expansion, FragmentAction_writes_AtomFragments, FragmentMolecule_checks_bonddegrees, GeometryObjects, Gui_Fixes, Gui_displays_atomic_force_velocity, ImplicitCharges, IndependentFragmentGrids, IndependentFragmentGrids_IndividualZeroInstances, IndependentFragmentGrids_IntegrationTest, IndependentFragmentGrids_Sole_NN_Calculation, JobMarket_RobustOnKillsSegFaults, JobMarket_StableWorkerPool, JobMarket_unresolvable_hostname_fix, MoreRobust_FragmentAutomation, ODR_violation_mpqc_open, PartialCharges_OrthogonalSummation, PdbParser_setsAtomName, PythonUI_with_named_parameters, QtGui_reactivate_TimeChanged_changes, Recreated_GuiChecks, Rewrite_FitPartialCharges, RotateToPrincipalAxisSystem_UndoRedo, SaturateAtoms_findBestMatching, SaturateAtoms_singleDegree, StoppableMakroAction, Subpackage_CodePatterns, Subpackage_JobMarket, Subpackage_LinearAlgebra, Subpackage_levmar, Subpackage_mpqc_open, Subpackage_vmg, Switchable_LogView, ThirdParty_MPQC_rebuilt_buildsystem, TrajectoryDependenant_MaxOrder, TremoloParser_IncreasedPrecision, TremoloParser_MultipleTimesteps, TremoloParser_setsAtomName, Ubuntu_1604_changes, stable

Children:

76cec6, c38826

Parents:

23359f

git-author:

Frederik Heber <heber@…> (10/30/10 19:55:54)

git-committer:

Frederik Heber <heber@…> (10/30/10 20:42:44)

Message:

Huge refactoring: Introduction of Traits to Actions.

This change is really big but the introduction of the Trait concept (at least
in its current light form) is so fundamental that lots of pieces had to be
changed in order to get everything working.

The main point why it was necessary to add these traits in the first place was
to comfortably allow for adding extension of Actions information-wise, i.e.
with stuff that is only important for the QtUI, such as icons, or tooltips, ...
This extra information should not be stored with Action itself, as it has
nothing to do with the workings of the Action. And neither should it get
stored with some blown-out-of-proportions MapOfActions class ...

The gist of the change is as follows:

• OptionTrait contains the token, description, shortform and type of an option, such as ("position", "position in space, none, typeid(Vector)).
• ActionTrait is the derived form for actions where additionally MenuPosition and MenuName are stored (and probably more to come for the GUI), also we have a set of OptionTrait instances, one for each option of the Action.
• Action then contains this ActionTrait, specialized for each Action.
• the preprocessor macros have been enhanced to gather all this information from the .def files.
• MapOfActions is gone. Completely. Most of its use was to store this extra information and the ValueStorage part now is just in class ValueStorage.
• ValueStorage is no more an interface to MapOfActions but as the name says a (type-safe) ValueStorage.

Listing the (remaining) changes in alphabetical order of the class:

• Action
  • member value ::name dropped, ::getName() uses ActionTraits::getName()
  • new define NODEFAULT which is used in paramdefaults in .def files
  • all derived actions classes such as Process, Calculations, MakroAction,... have been adapated to use the ActionTrait concept as well.

• ActionHistory
  • extraced RedoAction and UndoAction, shifted implementation into their own object files and they use .def files as well (i.e. streamlined with method used for other actions)

• CommandLineParser
  • CommandLineParser goes through ActionRegistry to get arguments and types to add
  • we use TypeEnumContainer which before was present in MapOfActions, as CommandLineParser::AddOptionsToParser() needs enums in its switch statement, we can't switch on types and types are not known until run-time. Hence, templates won't do either.
  • ShortFormMap is created here now (and used here only)
  • File was moved over to UIElements/CommandLineUI.

• MenuDescription
  • contain information on Menus such as name, ...
  • new unit test checks for consistency

• molecule
  • const member functions: Copy(), Output() and OutputBonds()

• OptionRegistry
  • new registry class for options only
  • we want the same type throughout the code for each token, e.g. "position"
  • the registry containts checks for consistency

• OptionTrait
  • default values are specified in paramdefaults, none are given by NODEFAULT
  • introduced default for translate-atoms, point-correlation, pair-correlation

• Registry pattern
  • new unit test, but only sceleton code so far

• ...Query, also ...Pipe
  • atoms, molecule and elements are now all const
  • also ValueStorage's signatures all have const therein

• ValueStorage
  • set/queryCurrentValue from MapOfActions
  • at times VectorValue has been in .def files where Vector was in the signature. This is cleared. Such stuff is only present for e.g. BoxVector being queried as a Vector. But this is a feature and intended.

• World
  • most of the (un)selection functions now work on const atoms and molecules
  • in one case we need a const_cast to remove this, but this is intentional, as the vector of selected atoms stores non-const pointers and this is ok.

There is only one test which had to be changed slightly because a specific
option token as "position" must now have the same type everywhere, e.g. always
Vector.

• TESTFIX: Simple_configuration/2: --position -> --domain-position (and associated to BoxVector)

Location:

src/UIElements

Files:

• CommandLineUI/CommandLineParser.cpp (added)
• CommandLineUI/CommandLineParser.hpp (moved) (moved from src/CommandLineParser.hpp ) (5 diffs)
• CommandLineUI/CommandLineWindow.cpp (modified) (1 diff)
• CommandLineUI/Query/AtomCommandLineQuery.cpp (modified) (1 diff)
• CommandLineUI/Query/AtomsCommandLineQuery.cpp (modified) (1 diff)
• CommandLineUI/Query/BooleanCommandLineQuery.cpp (modified) (1 diff)
• CommandLineUI/Query/BoxCommandLineQuery.cpp (modified) (1 diff)
• CommandLineUI/Query/DoubleCommandLineQuery.cpp (modified) (1 diff)
• CommandLineUI/Query/DoublesCommandLineQuery.cpp (modified) (1 diff)
• CommandLineUI/Query/ElementCommandLineQuery.cpp (modified) (1 diff)
• CommandLineUI/Query/ElementsCommandLineQuery.cpp (modified) (1 diff)
• CommandLineUI/Query/EmptyCommandLineQuery.cpp (modified) (1 diff)
• CommandLineUI/Query/FileCommandLineQuery.cpp (modified) (1 diff)
• CommandLineUI/Query/IntCommandLineQuery.cpp (modified) (1 diff)
• CommandLineUI/Query/IntsCommandLineQuery.cpp (modified) (1 diff)
• CommandLineUI/Query/MoleculeCommandLineQuery.cpp (modified) (1 diff)
• CommandLineUI/Query/MoleculesCommandLineQuery.cpp (modified) (1 diff)
• CommandLineUI/Query/StringCommandLineQuery.cpp (modified) (1 diff)
• CommandLineUI/Query/StringsCommandLineQuery.cpp (modified) (2 diffs)
• CommandLineUI/Query/VectorCommandLineQuery.cpp (modified) (1 diff)
• CommandLineUI/Query/VectorsCommandLineQuery.cpp (modified) (1 diff)
• CommandLineUI/TypeEnumContainer.cpp (added)
• CommandLineUI/TypeEnumContainer.hpp (added)
• Dialog.cpp (modified) (1 diff)
• Dialog.hpp (modified) (5 diffs)
• Makefile.am (modified) (1 diff)
• Menu/MenuDescription.cpp (modified) (2 diffs)
• Menu/MenuDescription.hpp (modified) (2 diffs)
• Menu/TextMenu.cpp (modified) (1 diff)
• Menu/TextMenu.hpp (modified) (3 diffs)
• Qt4/Pipe/AtomQtQueryPipe.cpp (modified) (1 diff)
• Qt4/Pipe/AtomsQtQueryPipe.cpp (modified) (2 diffs)
• Qt4/Pipe/MoleculeQtQueryPipe.cpp (modified) (1 diff)
• Qt4/Pipe/MoleculesQtQueryPipe.cpp (modified) (1 diff)
• Qt4/QtDialog.hpp (modified) (8 diffs)
• Qt4/QtMainWindow.cpp (modified) (3 diffs)
• TextUI/TextWindow.cpp (modified) (6 diffs)
• TextUI/TextWindow.hpp (modified) (1 diff)

src/UIElements/CommandLineUI/CommandLineParser.hpp

@@ -14 +14 @@
 
 #include "Patterns/Singleton.hpp"
+#include "UIElements/CommandLineUI/TypeEnumContainer.hpp"
 
-#include <list>
+#include <map>
+
+class Action;
+class OptionTrait;
 
 /** This class is a wrapper for boost::program_options.
@@ -92 +96 @@
 
   // Parses the command line arguments in CommandLineParser::**argv with currently known options.
-  void Run(int _argc, char **_argv, std::map <std::string, std::string> &ShortFormToActionMap);
+  void Run(int _argc, char **_argv);
+
+  // Initialises all options from ActionRegistry.
+  void InitializeCommandArguments();
 
   // Checks whether there have been any commands on the command line.
@@ -102 +109 @@
    * -# hidden options: options which the user is not shown on "help"
    */
-  po::options_description generic;
-  po::options_description config;
-  po::options_description hidden;
-  po::positional_options_description inputfile;
+  po::options_description analysis;
+  po::options_description atom;
+  po::options_description command;
+  po::options_description edit;
+  po::options_description fragmentation;
+  po::options_description molecule;
+  po::options_description parser;
+  po::options_description selection;
+  po::options_description tesselation;
+  po::options_description world;
+  po::options_description options;
 
   po::options_description visible;
@@ -125 +139 @@
   po::options_description config_file_options;
 
+  // adds options to the parser
+  void AddOptionToParser(const OptionTrait * const currentOption, po::options_description* OptionList);
+
+  // creates a map from short forms to action tokens needed to parse command line
+  std::map <std::string, std::string> getShortFormToActionMap();
+
+  // lookup list from "configmenus" to the ones of CommandLineParser
+  std::map< std::string , po::options_description *> CmdParserLookup;
+
   // Sets the options from the three cases.
   void setOptions(int _argc, char **_argv);
@@ -133 +156 @@
   // as boost's program_options does not care about of order of appearance but we do for actions,
   // we have to have a list and a function to obtain it.
-  void scanforSequenceOfArguments(std::map <std::string, std::string> &ShortFormToActionMap);
+  void scanforSequenceOfArguments();
+
+  TypeEnumContainer TypeToEnums;
 
   // argument counter and array passed on from main()

src/UIElements/CommandLineUI/CommandLineWindow.cpp

@@ -28 +28 @@
 #include "Actions/ActionRegistry.hpp"
 
-#include "CommandLineParser.hpp"
+#include "UIElements/CommandLineUI/CommandLineParser.hpp"
 
 #include <iostream>

src/UIElements/CommandLineUI/Query/AtomCommandLineQuery.cpp

@@ -26 +26 @@
 #include "CommandLineUI/CommandLineDialog.hpp"
 
-#include "CommandLineParser.hpp"
+#include "CommandLineUI/CommandLineParser.hpp"
 #include "Helpers/Log.hpp"
 #include "Helpers/Verbose.hpp"

src/UIElements/CommandLineUI/Query/AtomsCommandLineQuery.cpp

@@ -24 +24 @@
 #include "CommandLineUI/CommandLineDialog.hpp"
 
+#include "CommandLineUI/CommandLineParser.hpp"
 #include "Helpers/Log.hpp"
 #include "Helpers/Verbose.hpp"
-#include "CommandLineParser.hpp"
 #include "World.hpp"
 

src/UIElements/CommandLineUI/Query/BooleanCommandLineQuery.cpp

@@ -22 +22 @@
 #include "CommandLineUI/CommandLineDialog.hpp"
 
+#include "CommandLineUI/CommandLineParser.hpp"
 #include "Helpers/Log.hpp"
 #include "Helpers/Verbose.hpp"
-#include "CommandLineParser.hpp"
 
 CommandLineDialog::BooleanCommandLineQuery::BooleanCommandLineQuery(string title, string _description) :

src/UIElements/CommandLineUI/Query/BoxCommandLineQuery.cpp

@@ -23 +23 @@
 
 #include "Actions/Values.hpp"
+#include "CommandLineUI/CommandLineParser.hpp"
 #include "Helpers/Log.hpp"
 #include "Helpers/Verbose.hpp"
 #include "LinearAlgebra/Matrix.hpp"
-#include "CommandLineParser.hpp"
 
 CommandLineDialog::BoxCommandLineQuery::BoxCommandLineQuery(string title, string _description) :

src/UIElements/CommandLineUI/Query/DoubleCommandLineQuery.cpp

@@ -22 +22 @@
 #include "CommandLineUI/CommandLineDialog.hpp"
 
+#include "CommandLineUI/CommandLineParser.hpp"
 #include "Helpers/Log.hpp"
 #include "Helpers/Verbose.hpp"
-#include "CommandLineParser.hpp"
 
 

src/UIElements/CommandLineUI/Query/DoublesCommandLineQuery.cpp

@@ -22 +22 @@
 #include "CommandLineUI/CommandLineDialog.hpp"
 
+#include "CommandLineUI/CommandLineParser.hpp"
 #include "Helpers/Log.hpp"
 #include "Helpers/Verbose.hpp"
-#include "CommandLineParser.hpp"
 
 CommandLineDialog::DoublesCommandLineQuery::DoublesCommandLineQuery(string title, string _description) :

src/UIElements/CommandLineUI/Query/ElementCommandLineQuery.cpp

@@ -22 +22 @@
 #include "CommandLineUI/CommandLineDialog.hpp"
 
+#include "CommandLineUI/CommandLineParser.hpp"
 #include "Helpers/Log.hpp"
 #include "Helpers/Verbose.hpp"
-#include "CommandLineParser.hpp"
 #include "element.hpp"
 #include "periodentafel.hpp"

src/UIElements/CommandLineUI/Query/ElementsCommandLineQuery.cpp

@@ -22 +22 @@
 #include "CommandLineUI/CommandLineDialog.hpp"
 
+#include "CommandLineUI/CommandLineParser.hpp"
 #include "Helpers/Log.hpp"
 #include "Helpers/Verbose.hpp"
-#include "CommandLineParser.hpp"
 #include "element.hpp"
 #include "periodentafel.hpp"

src/UIElements/CommandLineUI/Query/EmptyCommandLineQuery.cpp

@@ -24 +24 @@
 #include "CommandLineUI/CommandLineDialog.hpp"
 
+#include "CommandLineUI/CommandLineParser.hpp"
 #include "Helpers/Log.hpp"
 #include "Helpers/Verbose.hpp"
-#include "CommandLineParser.hpp"
 
 CommandLineDialog::EmptyCommandLineQuery::EmptyCommandLineQuery(string title, string _description) :

src/UIElements/CommandLineUI/Query/FileCommandLineQuery.cpp

@@ -22 +22 @@
 #include "CommandLineUI/CommandLineDialog.hpp"
 
+#include "CommandLineUI/CommandLineParser.hpp"
 #include "Helpers/Log.hpp"
 #include "Helpers/Verbose.hpp"
-#include "CommandLineParser.hpp"
 
 CommandLineDialog::FileCommandLineQuery::FileCommandLineQuery(string title, string _description) :

src/UIElements/CommandLineUI/Query/IntCommandLineQuery.cpp

@@ -22 +22 @@
 #include "CommandLineUI/CommandLineDialog.hpp"
 
+#include "CommandLineUI/CommandLineParser.hpp"
 #include "Helpers/Log.hpp"
 #include "Helpers/Verbose.hpp"
-#include "CommandLineParser.hpp"
 
 CommandLineDialog::IntCommandLineQuery::IntCommandLineQuery(string title, string _description) :

src/UIElements/CommandLineUI/Query/IntsCommandLineQuery.cpp

@@ -22 +22 @@
 #include "CommandLineUI/CommandLineDialog.hpp"
 
+#include "CommandLineUI/CommandLineParser.hpp"
 #include "Helpers/Log.hpp"
 #include "Helpers/Verbose.hpp"
-#include "CommandLineParser.hpp"
 
 CommandLineDialog::IntsCommandLineQuery::IntsCommandLineQuery(string title, string _description) :

src/UIElements/CommandLineUI/Query/MoleculeCommandLineQuery.cpp

@@ -24 +24 @@
 #include "CommandLineUI/CommandLineDialog.hpp"
 
+#include "CommandLineUI/CommandLineParser.hpp"
 #include "Helpers/Log.hpp"
 #include "Helpers/Verbose.hpp"
-#include "CommandLineParser.hpp"
 
 CommandLineDialog::MoleculeCommandLineQuery::MoleculeCommandLineQuery(string title, string _description) :

src/UIElements/CommandLineUI/Query/MoleculesCommandLineQuery.cpp

@@ -24 +24 @@
 #include "CommandLineUI/CommandLineDialog.hpp"
 
+#include "CommandLineUI/CommandLineParser.hpp"
 #include "Helpers/Log.hpp"
 #include "Helpers/Verbose.hpp"
-#include "CommandLineParser.hpp"
 #include "World.hpp"
 

src/UIElements/CommandLineUI/Query/StringCommandLineQuery.cpp

@@ -22 +22 @@
 #include "CommandLineUI/CommandLineDialog.hpp"
 
+#include "CommandLineUI/CommandLineParser.hpp"
 #include "Helpers/Log.hpp"
 #include "Helpers/Verbose.hpp"
-#include "CommandLineParser.hpp"
 
 CommandLineDialog::StringCommandLineQuery::StringCommandLineQuery(string title, string _description) :

src/UIElements/CommandLineUI/Query/StringsCommandLineQuery.cpp

@@ -22 +22 @@
 #include "CommandLineUI/CommandLineDialog.hpp"
 
+#include "CommandLineUI/CommandLineParser.hpp"
 #include "Helpers/Log.hpp"
 #include "Helpers/Verbose.hpp"
-#include "CommandLineParser.hpp"
 
 CommandLineDialog::StringsCommandLineQuery::StringsCommandLineQuery(string title, string _description) :
@@ -34 +34 @@
 bool CommandLineDialog::StringsCommandLineQuery::handle() {
   if (CommandLineParser::getInstance().vm.count(getTitle())) {
-    tmp = CommandLineParser::getInstance().vm[getTitle()].as< vector<string> >();
+    tmp = CommandLineParser::getInstance().vm[getTitle()].as< std::vector<std::string> >();
     return true;
   } else {

src/UIElements/CommandLineUI/Query/VectorCommandLineQuery.cpp

@@ -23 +23 @@
 
 #include "Actions/Values.hpp"
+#include "CommandLineUI/CommandLineParser.hpp"
 #include "Helpers/Log.hpp"
 #include "Helpers/Verbose.hpp"
-#include "CommandLineParser.hpp"
 #include "LinearAlgebra/Vector.hpp"
 #include "Box.hpp"

src/UIElements/CommandLineUI/Query/VectorsCommandLineQuery.cpp

@@ -25 +25 @@
 
 #include "Actions/Values.hpp"
+#include "CommandLineUI/CommandLineParser.hpp"
 #include "Helpers/Log.hpp"
 #include "Helpers/Verbose.hpp"
-#include "CommandLineParser.hpp"
 #include "World.hpp"
 

src/UIElements/Dialog.cpp

@@ -126 +126 @@
 }
 
-template <> void Dialog::query<atom *>(const char *token, std::string description)
+template <> void Dialog::query<const atom *>(const char *token, std::string description)
 {
   queryAtom(token, description);
 }
 
-template <> void Dialog::query< std::vector<atom *> >(const char *token, std::string description)
+template <> void Dialog::query< std::vector<const atom *> >(const char *token, std::string description)
 {
   queryAtoms(token, description);
 }
 
-template <> void Dialog::query<molecule *>(const char *token, std::string description)
+template <> void Dialog::query<const molecule *>(const char *token, std::string description)
 {
   queryMolecule(token, description);
 }
 
-template <> void Dialog::query< std::vector<molecule *> >(const char *token, std::string description)
+template <> void Dialog::query< std::vector<const molecule *> >(const char *token, std::string description)
 {
   queryMolecules(token, description);

src/UIElements/Dialog.hpp

@@ -33 +33 @@
  * string, but also advanced types such as element, molecule or Vector. There
  * is also an empty query for displaying text.
+ *
+ * Note that the templatization of Dialog::query() allows for easy implementation
+ * of new types that correspond to/are derived from old ones.
+ *
+ * <H3>How do Dialogs operate?</H3>
+ *
+ * Dialogs are initiated by Action::FillDialog() function calls. Within Action::Call()
+ * a dialog is created and passed on to FillDialog(), which is specialized in each
+ * specific Action to ask for the specific parameter it needs.
+ *
+ * Dialogs are derived for each of the UI types
+ *  -# CommandLineDialog
+ *  -# QtDialog
+ *  -# TextDialog
+ *
+ * This "asking" for parameters is done via the Query class.  There are four types
+ * of Query types:
+ *  -# Query, members in class Dialog
+ *  -# CommandLineQuery, members in class CommandLineDialog
+ *  -# QtQuery, members in class QtDialog
+ *  -# TextQuery, members in class TextDialog
+ * Each embodies a certain way of asking the user for the specific type of parameter
+ * needed, e.g. a file via the TextMenu interface would be done in member functions of
+ * TextDialog::FileTextQuery.
+ *
+ *
+ * Generally, the sequence of events is as follows:
+ *  -# Action::fillDialog() calls upon Dialog::query<T> for some type T, let's say T
+ *     stands for double
+ *  -# Dialog::query<double> call a function queryDouble()
+ *  -# depending on the currently used UIFactory, the Dialog above is actually either
+ *     of the three specialized types, let's say CommandLine. And we see that within
+ *     CommandLineDialog we have the respective method ueryDouble() that registers
+ *     a new instance of the class CommandLineDialog::DoubleCommandLineQuery.
+ *  -# The Query's are first registered, as multiple parameters may be needed for
+ *     a single Action and we don't want the popping up of a dialog window for each
+ *     alone. Rather, we want to merge the Query's into a single Dialog. Therefore,
+ *     they are first registered and then executed in sequence. This is done in
+ *     Dialog::display(), i.e. when the dialog is finally shown to the user.
+ *  -# Then each of the registered Query's, here our CommandLineDialog::
+ *     DoubleCommandLineQuery, constructor is called.
+ *     -# This will call the constructor of its base class, where the actual value
+ *        is stored and later stored into the ValueStorage class by
+ *        Dialog::Query::setResult().
+ *     -# Also, e.g. for the Qt interface, the buttons, labels and so forth are
+ *        created and added to the dialog.
+ *  -# Now the users enters information for each UI something different happens:
+ *    -# CommandLine: The actual value retrieval is done by the CommandLineParser and
+ *       the boost::program_options library, the value is stored therein for the moment.
+ *       (see here: http://www.boost.org/doc/libs/1_44_0/doc/html/program_options/)
+ *    -# TextMenu: The value is requested via std::cin from the user.
+ *    -# QtMenu: The users enters the value in a Dialog. Due to Qt necessities a
+ *       Pipe class obtains the value from the Dialog with Qt's signal/slot mechanism
+ *       and put it into Dialog::...Query value.
+ *  -# in our case DoubleCommandLineQuery::handle() will be called. The value is
+ *     retrieved and put into Dialog::DoubleQuery::tmp
+ *  -# Finally, for each Query, also Dialog::DoubleQuery, setResult() is called which
+ *     puts the value as a string into the ValueStorage under a given token that is
+ *     associated with a type (and thereby we assure type-safety).
+ *
+ * <H3>Regarding derived types of types with already present queries</H3>
+ *
+ * Example: We have got a derived Vector class, called BoxVector, that is by any means
+ * a Vector but with one difference: it is always bound to lie within the current domain.
+ * With regards to type-casting it to and from a string however, nothing is different
+ * between Vector and BoxVector.
+ *
+ * So, do we need a new Query for this?
+ * No.
+ *
+ * We just have to do this:
+ *  -# add a specialization of Dialog::query<BoxVector> where queryVector()is used.
+ *     @code
+ *     template <> void Dialog::query<BoxVector>(const char *token, std::string description) {
+ *        queryVector(token, false, description);
+ *     }
+ *     @endcode
+ *  -# make sure that
+ *     -# ValueStorage::setCurrentValue() the specialization for class Vector has an
+ *     if case also for BoxVector and does something appropriate.
+ *     -# ValueStorage::queryCurrentValue() has another specialization doing the same
+ *     as for Vector but for BoxVector in its signature.
+ *
+ * And that's all.
+ *
+ *
+ * <H3>Adding new queries</H3>
+ *
+ * Check first whether you really need a new query or whether we can derive it and re-use
+ * one of the present ones.
+ *
+ * Due to the three present UI interfaces we have to add a specific Query for each, here
+ * is a list:
+ *   -# add ValueStorage::setCurrentValue() and ValueStorage::queryCurrentValue() for
+ *      both types
+ *   -# add Dialog::query...()
+ *   -# add Dialog::query<>() specialization calling the above function
+ *   -# add CommandLineDialog::query...(), TextDialog::query...(), and QtDialog::query...(),
+ *      i.e. for each of the three interface
+ *   -# add Dialog::...Query class with tmp value of desired type
+ *   -# add CommandLineDialog::...Query, TextDialog::...Query, QtDialog::...Query
+ *   -# you probably also need a QtDialog::...QueryPipe() to handle the signal/slot stuff,
+ *      Qt's moc does not like nested classes. Hence, this has to go extra.
+ *
  */
 class Dialog
@@ -210 +314 @@
     virtual void setResult();
   protected:
-    molecule *tmp;
+    const molecule *tmp;
   };
 
@@ -220 +324 @@
     virtual void setResult();
   protected:
-    molecule * temp;
-    std::vector<molecule *> tmp;
+    const molecule * temp;
+    std::vector<const molecule *> tmp;
   };
 
@@ -231 +335 @@
     virtual void setResult();
   protected:
-    atom *tmp;
+    const atom *tmp;
   };
 
@@ -241 +345 @@
     virtual void setResult();
   protected:
-    atom *temp;
-    std::vector<atom *> tmp;
+    const atom *temp;
+    std::vector<const atom *> tmp;
   };
 

src/UIElements/Makefile.am

@@ -123 +123 @@
   CommandLineUI/Query/VectorsCommandLineQuery.cpp \
   CommandLineUI/CommandLineDialog.cpp \
+  CommandLineUI/CommandLineParser.cpp \
   CommandLineUI/CommandLineStatusIndicator.cpp \
   CommandLineUI/CommandLineUIFactory.cpp \
-  CommandLineUI/CommandLineWindow.cpp
+  CommandLineUI/CommandLineWindow.cpp \
+  CommandLineUI/TypeEnumContainer.cpp
+  
 COMMANDLINEUIHEADER = \
   CommandLineUI/CommandLineDialog.hpp \
+  CommandLineUI/CommandLineParser.hpp \
   CommandLineUI/CommandLineStatusIndicator.hpp \
   CommandLineUI/CommandLineUIFactory.hpp \
-  CommandLineUI/CommandLineWindow.hpp
+  CommandLineUI/CommandLineWindow.hpp \
+  CommandLineUI/TypeEnumContainer.cpp
 
 lib_LTLIBRARIES = libMolecuilderUI-@MOLECUILDER_API_VERSION@.la

src/UIElements/Menu/MenuDescription.cpp

@@ -16 +16 @@
 #include <string>
 
+#include "Actions/ActionRegistry.hpp"
 #include "Menu/MenuDescription.hpp"
 
@@ -87 +88 @@
 }
 
+/** Constructs a multimap of all menus running over all actions belonging to it.
+ * \return multimap with which actions belongs to which menu.
+ */
+std::multimap <std::string, std::string> MenuDescription::getMenuItemsMap() const
+{
+  std::multimap <std::string, std::string> result;
+
+  ActionRegistry &AR = ActionRegistry::getInstance();
+  for (ActionRegistry::const_iterator iter = AR.getBeginIter();iter != AR.getEndIter();++iter) {
+    result.insert( std::pair<std::string, std::string> ((iter->second)->Traits.getMenuName(), (iter->second)->getName()));
+  }
+  // TODO: MenuPosition is not yet realized.
+  return result;
+}
+
 /** Forward iterator from beginning of list of descriptions.
  * \return iterator

src/UIElements/Menu/MenuDescription.hpp

@@ -32 +32 @@
   const std::string getName(std::string token) const;
 
+  std::multimap <std::string, std::string> getMenuItemsMap() const;
+
   // iterators
   iterator getBeginIter();
@@ -42 +44 @@
   std::map<std::string, std::string> MenuDescriptionsMap;
   std::map<std::string, std::string> MenuNameMap;
+  std::multimap <std::string, std::string> MenuItemMap;
 };
 

src/UIElements/Menu/TextMenu.cpp

@@ -122 +122 @@
 /****************************** Contained Actions ****************/
 
-const string TextMenu::LeaveAction::nameBase = "Leave menu: ";
-
-TextMenu::LeaveAction::LeaveAction(TextMenu* _menu) :
-  Action(nameBase+_menu->getTitle()),
+TextMenu::LeaveAction::LeaveAction(TextMenu* _menu, const ActionTraits & LeaveActionTrait) :
+  Action(LeaveActionTrait, false),
   menu(_menu)
 {}

src/UIElements/Menu/TextMenu.hpp

@@ -15 +15 @@
 #include "Menu/Menu.hpp"
 #include "Actions/Action.hpp"
+#include "Actions/ActionTraits.hpp"
 #include "defs.hpp"
 
@@ -29 +30 @@
   class LeaveAction : public Action {
   public:
-    LeaveAction(TextMenu*);
+    LeaveAction(TextMenu*, const ActionTraits &_trait);
     virtual ~LeaveAction();
 
@@ -43 +44 @@
     virtual Action::state_ptr performRedo(Action::state_ptr);
 
+    ActionTraits *LeaveActionTrait;
     TextMenu* menu;
-
-    static const string nameBase;
   };
 

src/UIElements/Qt4/Pipe/AtomQtQueryPipe.cpp

@@ -27 +27 @@
 
 
-AtomQtQueryPipe::AtomQtQueryPipe(atom **_content, QtDialog *_dialog, QComboBox *_theBox) :
+AtomQtQueryPipe::AtomQtQueryPipe(const atom **_content, QtDialog *_dialog, QComboBox *_theBox) :
   content(_content),
   dialog(_dialog),

src/UIElements/Qt4/Pipe/AtomsQtQueryPipe.cpp

@@ -29 +29 @@
 
 
-AtomsQtQueryPipe::AtomsQtQueryPipe(std::vector<atom *>*_content, QtDialog *_dialog, QListWidget *_theList) :
+AtomsQtQueryPipe::AtomsQtQueryPipe(std::vector<const atom *>*_content, QtDialog *_dialog, QListWidget *_theList) :
   content(_content),
   dialog(_dialog),
@@ -41 +41 @@
   // clear target and put all atoms therein
   (*content).clear();
-  for (std::set<atom *>::iterator iter = currentList.begin(); iter != currentList.end(); ++iter)
+  for (std::set<const atom *>::iterator iter = currentList.begin(); iter != currentList.end(); ++iter)
     (*content).push_back(*iter);
   dialog->update();

src/UIElements/Qt4/Pipe/MoleculeQtQueryPipe.cpp

@@ -26 +26 @@
 
 
-MoleculeQtQueryPipe::MoleculeQtQueryPipe(molecule **_content, QtDialog *_dialog, QComboBox *_theBox) :
+MoleculeQtQueryPipe::MoleculeQtQueryPipe(const molecule **_content, QtDialog *_dialog, QComboBox *_theBox) :
   content(_content),
   dialog(_dialog),

src/UIElements/Qt4/Pipe/MoleculesQtQueryPipe.cpp

@@ -28 +28 @@
 
 
-MoleculesQtQueryPipe::MoleculesQtQueryPipe(std::vector<molecule *>*_content, QtDialog *_dialog, QComboBox *_theBox) :
+MoleculesQtQueryPipe::MoleculesQtQueryPipe(std::vector<const molecule *>*_content, QtDialog *_dialog, QComboBox *_theBox) :
   content(_content),
   dialog(_dialog),

src/UIElements/Qt4/QtDialog.hpp

@@ -445 +445 @@
   Q_OBJECT
 public:
-  AtomQtQueryPipe(atom **_content, QtDialog *_dialog, QComboBox *_theBox);
+  AtomQtQueryPipe(const atom **_content, QtDialog *_dialog, QComboBox *_theBox);
   virtual ~AtomQtQueryPipe();
 
@@ -452 +452 @@
 
 private:
-  atom **content;
+  const atom **content;
   QtDialog *dialog;
   QComboBox *theBox;
@@ -462 +462 @@
   Q_OBJECT
 public:
-  AtomsQtQueryPipe(std::vector<atom *>*_content, QtDialog *_dialog, QListWidget *_theList);
+  AtomsQtQueryPipe(std::vector<const atom *>*_content, QtDialog *_dialog, QListWidget *_theList);
   virtual ~AtomsQtQueryPipe();
 
@@ -471 +471 @@
 
 private:
-  std::vector<atom *>*content;
-  std::map<int, atom *> lookup;
-  std::set<atom *> currentList;
+  std::vector<const atom *>*content;
+  std::map<int, const atom *> lookup;
+  std::set<const atom *> currentList;
   QtDialog *dialog;
   QListWidget *theList;
@@ -482 +482 @@
   Q_OBJECT
 public:
-  MoleculeQtQueryPipe(molecule **_content, QtDialog *_dialog, QComboBox *_theBox);
+  MoleculeQtQueryPipe(const molecule **_content, QtDialog *_dialog, QComboBox *_theBox);
   virtual ~MoleculeQtQueryPipe();
 
@@ -489 +489 @@
 
 private:
-  molecule **content;
+  const molecule **content;
   QtDialog *dialog;
   QComboBox *theBox;
@@ -498 +498 @@
   Q_OBJECT
 public:
-  MoleculesQtQueryPipe(std::vector<molecule *>*_content, QtDialog *_dialog, QComboBox *_theBox);
+  MoleculesQtQueryPipe(std::vector<const molecule *>*_content, QtDialog *_dialog, QComboBox *_theBox);
   virtual ~MoleculesQtQueryPipe();
 
@@ -505 +505 @@
 
 private:
-  std::vector<molecule *>*content;
+  std::vector<const molecule *>*content;
   QtDialog *dialog;
   QComboBox *theBox;

src/UIElements/Qt4/QtMainWindow.cpp

@@ -38 +38 @@
 #include "Actions/Action.hpp"
 #include "Actions/ActionRegistry.hpp"
-#include "Actions/MapOfActions.hpp"
+#include "Actions/ValueStorage.hpp"
+#include "Menu/MenuDescription.hpp"
 #include "Menu/Menu.hpp"
 #include "Menu/Qt4/QtMenu.hpp"
@@ -65 +66 @@
   // go through all menus and create them
   QtMenu *Menu = NULL;
-  for(std::map<std::string, std::pair<std::string,std::string> >::iterator iter = MapOfActions::getInstance().MenuDescription.begin(); iter != MapOfActions::getInstance().MenuDescription.end(); ++iter) {
-    cout << "Creating menu " << iter->first << endl;
-    Menu = new QtMenu(iter->first.c_str());
+  MenuDescription menudescriptions;
+  for(MenuDescription::const_iterator iter = menudescriptions.getBeginIter(); iter != menudescriptions.getEndIter(); ++iter) {
+    cout << "Creating menu " << *iter << endl;
+    Menu = new QtMenu(menudescriptions.getName(*iter).c_str());
     MenuBar->addMenu(Menu);
-    NametoTextMenuMap.insert( pair <std::string, QtMenu *> (iter->first, Menu) );
-    //new SubMenuItem(getSuitableShortForm(iter->first),iter->second.first,main_menu,Menu);
+    NametoTextMenuMap.insert( pair <std::string, QtMenu *> (menudescriptions.getName(*iter), Menu) );
+    //new SubMenuItem(getSuitableShortForm(menudescriptions.getName(iter->first.c_str())),menudescriptions.getName(iter->first.c_str()),main_menu,Menu);
   }
 
@@ -118 +120 @@
   set <char> ShortcutList;
   // through all actions for this menu
-  std::pair < std::multimap <std::string, std::string>::iterator, std::multimap <std::string, std::string>::iterator > MenuActions = MapOfActions::getInstance().MenuContainsActionMap.equal_range(MenuName);
+  MenuDescription md;
+  std::multimap <std::string, std::string> MenuItems = md.getMenuItemsMap();
+  std::pair < std::multimap <std::string, std::string>::iterator, std::multimap <std::string, std::string>::iterator > MenuActions = MenuItems.equal_range(MenuName);
   for (std::multimap <std::string, std::string>::const_iterator MenuRunner = MenuActions.first; MenuRunner != MenuActions.second; ++MenuRunner) {
     cout << " Adding " << MenuRunner->second << " to submenu " << MenuName << endl;

src/UIElements/TextUI/TextWindow.cpp

@@ -21 +21 @@
 
 #include <boost/bind.hpp>
+#include <boost/shared_ptr.hpp>
 
 #include "Menu/Menu.hpp"
+#include "Menu/MenuDescription.hpp"
 #include "Menu/TextMenu.hpp"
 #include "Menu/ActionMenuItem.hpp"
@@ -30 +32 @@
 #include "TextUI/TextStatusIndicator.hpp"
 #include "TextUI/TextWindow.hpp"
-#include "Actions/MapOfActions.hpp"
 #include "Actions/MethodAction.hpp"
 #include "Actions/ErrorAction.hpp"
 #include "Actions/ActionRegistry.hpp"
+#include "Actions/ActionTraits.hpp"
 #include "Parser/ChangeTracker.hpp"
 #include "Views/StreamStringView.hpp"
@@ -77 +79 @@
   new SeperatorItem(main_menu);
 
-  for(map<std::string, pair<std::string,std::string> >::iterator iter = MapOfActions::getInstance().MenuDescription.begin(); iter != MapOfActions::getInstance().MenuDescription.end(); ++iter) {
-    TextMenu *Menu = new TextMenu(Log() << Verbose(0), iter->second.second);
-    NametoTextMenuMap.insert( pair <std::string, TextMenu *> (iter->first, Menu) );
-    new SubMenuItem(getSuitableShortForm(ShortcutList,iter->first),iter->second.first.c_str(),main_menu,Menu);
+  MenuDescription menudescriptions;
+  for(MenuDescription::const_iterator iter = menudescriptions.getBeginIter(); iter != menudescriptions.getEndIter(); ++iter) {
+    TextMenu *Menu = new TextMenu((ostream &)std::cout, menudescriptions.getDescription(*iter));
+    NametoTextMenuMap.insert( pair <std::string, TextMenu *> (*iter, Menu) );
+    new SubMenuItem(getSuitableShortForm(ShortcutList,*iter),menudescriptions.getDescription(*iter).c_str(),main_menu,Menu);
   }
 
@@ -89 +92 @@
   new ActionMenuItem('s',"save current setup to config files",main_menu,saveConfigAction);
 
-  quitAction = new MethodAction("quitAction",boost::bind(&TextMenu::doQuit,main_menu),false);
+  ActionTraits quitTrait(OptionTrait("quitAction", &typeid(void), "quits the program"));
+  quitAction = new MethodAction(quitTrait,boost::bind(&TextMenu::doQuit,main_menu),false);
   new ActionMenuItem('q',"quit",main_menu,quitAction);
 
@@ -104 +108 @@
 TextWindow::~TextWindow()
 {
+  for (std::list<Action *>::iterator iter = returnFromActions.begin(); !returnFromActions.empty(); ++iter)
+    delete (*iter);
+  returnFromActions.clear();
   delete quitAction;
   delete moleculeView;
@@ -144 +151 @@
   ShortcutList.insert('q');
   // through all actions for this menu
-  pair < multimap <std::string, std::string>::iterator, multimap <std::string, std::string>::iterator > MenuActions = MapOfActions::getInstance().MenuContainsActionMap.equal_range(MenuName);
-  for (multimap <std::string, std::string>::const_iterator MenuRunner = MenuActions.first; MenuRunner != MenuActions.second; ++MenuRunner) {
+  MenuDescription md;
+  std::multimap <std::string, std::string> MenuItems = md.getMenuItemsMap();
+  std::pair < std::multimap <std::string, std::string>::iterator, std::multimap <std::string, std::string>::iterator > MenuActions = MenuItems.equal_range(MenuName);
+  for (std::multimap <std::string, std::string>::const_iterator MenuRunner = MenuActions.first; MenuRunner != MenuActions.second; ++MenuRunner) {
     ActionItem = ActionRegistry::getInstance().getActionByName(MenuRunner->second);
     new ActionMenuItem(getSuitableShortForm(ShortcutList, MenuRunner->second),ActionItem->Traits.getDescription().c_str(),Menu,ActionItem);
   }
   // finally add default quit item
-  Action *returnFromAction = new TextMenu::LeaveAction(Menu);
+  ActionTraits LeaveActionTraits("Leave menu: "+Menu->getTitle());
+  Action *returnFromAction = new TextMenu::LeaveAction(Menu, LeaveActionTraits);
+  //returnFromActions.push_back(returnFromAction);
   MenuItem *returnFromItem = new ActionMenuItem('q',"return to Main menu",Menu,returnFromAction);
   Menu->addDefault(returnFromItem);

src/UIElements/TextUI/TextWindow.hpp

@@ -36 +36 @@
 
   // some actions only needed in textMenus
+  std::list<Action *> returnFromActions;
   Action *quitAction;
   // all views that are contained in the main Menu