Changeset b0acc3 for src


Ignore:
Timestamp:
Jun 26, 2010, 10:14:22 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, 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:
b2531f
Parents:
b80021 (diff), 326bbe (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge branch 'stable' into QT4Refactoring

Conflicts:

molecuilder/src/Makefile.am

  • molecuilder/src/Makefile.am: No more present (in stable) Legacy was conflicting
Location:
src
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • src/Actions/MapOfActions.cpp

    rb80021 rb0acc3  
    2222#include "verbose.hpp"
    2323
     24#include "Actions/ActionRegistry.hpp"
     25#include "Actions/AnalysisAction/MolecularVolumeAction.hpp"
     26#include "Actions/AnalysisAction/PairCorrelationAction.hpp"
     27#include "Actions/AnalysisAction/PrincipalAxisSystemAction.hpp"
     28#include "Actions/AtomAction/AddAction.hpp"
     29#include "Actions/AtomAction/ChangeElementAction.hpp"
     30#include "Actions/AtomAction/RemoveAction.hpp"
     31#include "Actions/CmdAction/BondLengthTableAction.hpp"
     32#include "Actions/CmdAction/ElementDbAction.hpp"
     33#include "Actions/CmdAction/FastParsingAction.hpp"
     34#include "Actions/CmdAction/HelpAction.hpp"
     35#include "Actions/CmdAction/VerboseAction.hpp"
     36#include "Actions/CmdAction/VersionAction.hpp"
     37#include "Actions/FragmentationAction/DepthFirstSearchAction.hpp"
     38#include "Actions/FragmentationAction/SubgraphDissectionAction.hpp"
     39#include "Actions/FragmentationAction/FragmentationAction.hpp"
     40#include "Actions/MoleculeAction/BondFileAction.hpp"
     41#include "Actions/MoleculeAction/ChangeNameAction.hpp"
     42#include "Actions/MoleculeAction/FillWithMoleculeAction.hpp"
     43#include "Actions/MoleculeAction/LinearInterpolationofTrajectoriesAction.hpp"
     44#include "Actions/MoleculeAction/SaveAdjacencyAction.hpp"
     45#include "Actions/MoleculeAction/SaveBondsAction.hpp"
     46#include "Actions/MoleculeAction/SaveTemperatureAction.hpp"
     47#include "Actions/MoleculeAction/TranslateAction.hpp"
     48#include "Actions/MoleculeAction/VerletIntegrationAction.hpp"
     49#include "Actions/ParserAction/LoadXyzAction.hpp"
     50#include "Actions/ParserAction/SaveXyzAction.hpp"
     51#include "Actions/TesselationAction/ConvexEnvelopeAction.hpp"
     52#include "Actions/TesselationAction/NonConvexEnvelopeAction.hpp"
     53#include "Actions/WorldAction/AddEmptyBoundaryAction.hpp"
     54#include "Actions/WorldAction/BoundInBoxAction.hpp"
     55#include "Actions/WorldAction/CenterInBoxAction.hpp"
     56#include "Actions/WorldAction/CenterOnEdgeAction.hpp"
     57#include "Actions/WorldAction/ChangeBoxAction.hpp"
     58#include "Actions/WorldAction/InputAction.hpp"
     59#include "Actions/WorldAction/OutputAction.hpp"
     60#include "Actions/WorldAction/RemoveSphereOfAtomsAction.hpp"
     61#include "Actions/WorldAction/RepeatBoxAction.hpp"
     62#include "Actions/WorldAction/ScaleBoxAction.hpp"
     63#include "Actions/WorldAction/SetDefaultNameAction.hpp"
     64#include "Actions/WorldAction/SetGaussianBasisAction.hpp"
    2465#include "Actions/Values.hpp"
    2566
    … …  
    99140  DescriptionMap["save-bonds"] = "name of the bonds file to write to";
    100141  DescriptionMap["save-temperature"] = "name of the temperature file to write to";
     142  DescriptionMap["SaveXyz"] = "save world as xyz file";
    101143  DescriptionMap["scale-box"] = "scale box and atomic positions inside";
    102144  DescriptionMap["subgraph-dissect"] = "dissect the molecular system into molecules representing disconnected subgraphs";
    … …  
    245287  DefaultValue["periodic"] = "0";
    246288
    247 
    248   // list of generic actions
     289  // put action into each menu category
     290  MenuContainsActionMap.insert( pair<std::string, std::string> ("analysis", "molecular-volume") );
     291  MenuContainsActionMap.insert( pair<std::string, std::string> ("analysis", "pair-correlation") );
     292  MenuContainsActionMap.insert( pair<std::string, std::string> ("analysis", "principal-axis-system") );
     293
     294  MenuContainsActionMap.insert( pair<std::string, std::string> ("atom", "add-atom") );
     295  MenuContainsActionMap.insert( pair<std::string, std::string> ("atom", "change-element") );
     296  MenuContainsActionMap.insert( pair<std::string, std::string> ("atom", "remove-atom") );
     297
     298  MenuContainsActionMap.insert( pair<std::string, std::string> ("command", "bond-table") );
     299  MenuContainsActionMap.insert( pair<std::string, std::string> ("command", "element-db") );
     300  MenuContainsActionMap.insert( pair<std::string, std::string> ("command", "fastparsing") );
     301  MenuContainsActionMap.insert( pair<std::string, std::string> ("command", "verbose") );
     302  MenuContainsActionMap.insert( pair<std::string, std::string> ("command", "version") );
     303
     304  MenuContainsActionMap.insert( pair<std::string, std::string> ("fragmentation", "depth-first-search") );
     305  MenuContainsActionMap.insert( pair<std::string, std::string> ("fragmentation", "fragment-mol") );
     306  MenuContainsActionMap.insert( pair<std::string, std::string> ("fragmentation", "subgraph-dissect") );
     307
     308  MenuContainsActionMap.insert( pair<std::string, std::string> ("molecule", "bond-file") );
     309  MenuContainsActionMap.insert( pair<std::string, std::string> ("molecule", "change-molname") );
     310  MenuContainsActionMap.insert( pair<std::string, std::string> ("molecule", "fill-molecule") );
     311  MenuContainsActionMap.insert( pair<std::string, std::string> ("molecule", "linear-interpolate") );
     312  MenuContainsActionMap.insert( pair<std::string, std::string> ("molecule", "rotate-to-pas") );
     313  MenuContainsActionMap.insert( pair<std::string, std::string> ("molecule", "save-adjacency") );
     314  MenuContainsActionMap.insert( pair<std::string, std::string> ("molecule", "save-bonds") );
     315  MenuContainsActionMap.insert( pair<std::string, std::string> ("molecule", "save-temperature") );
     316  MenuContainsActionMap.insert( pair<std::string, std::string> ("molecule", "suspend-in-water") );
     317  MenuContainsActionMap.insert( pair<std::string, std::string> ("molecule", "translate-mol") );
     318  MenuContainsActionMap.insert( pair<std::string, std::string> ("molecule", "verlet-integrate") );
     319
     320  MenuContainsActionMap.insert( pair<std::string, std::string> ("parser", "parse-xyz") );
     321  MenuContainsActionMap.insert( pair<std::string, std::string> ("parser", "SaveXyz") );
     322
     323  MenuContainsActionMap.insert( pair<std::string, std::string> ("tesselation", "convex-envelope") );
     324  MenuContainsActionMap.insert( pair<std::string, std::string> ("tesselation", "nonconvex-envelope") );
     325
     326  MenuContainsActionMap.insert( pair<std::string, std::string> ("world", "boundary") );
     327  MenuContainsActionMap.insert( pair<std::string, std::string> ("world", "bound-in-box") );
     328  MenuContainsActionMap.insert( pair<std::string, std::string> ("world", "center-in-box") );
     329  MenuContainsActionMap.insert( pair<std::string, std::string> ("world", "center-edge") );
     330  MenuContainsActionMap.insert( pair<std::string, std::string> ("world", "change-box") );
     331  MenuContainsActionMap.insert( pair<std::string, std::string> ("world", "input") );
     332  MenuContainsActionMap.insert( pair<std::string, std::string> ("world", "output") );
     333  MenuContainsActionMap.insert( pair<std::string, std::string> ("world", "remove-sphere") );
     334  MenuContainsActionMap.insert( pair<std::string, std::string> ("world", "repeat-box") );
     335  MenuContainsActionMap.insert( pair<std::string, std::string> ("world", "scale-box") );
     336  MenuContainsActionMap.insert( pair<std::string, std::string> ("world", "default-molname") );
     337  MenuContainsActionMap.insert( pair<std::string, std::string> ("world", "set-basis") );
     338
     339  // put actions into command line category
    249340        generic.insert("add-atom");
    250341  generic.insert("bond-file");
    … …  
    328419}
    329420
     421
     422void MapOfActions::populateActions()
     423{
     424  new AnalysisMolecularVolumeAction();
     425  new AnalysisPairCorrelationAction();
     426  new AnalysisPrincipalAxisSystemAction();
     427
     428  new AtomAddAction();
     429  new AtomChangeElementAction();
     430  new AtomRemoveAction();
     431
     432  new CommandLineBondLengthTableAction();
     433  new CommandLineElementDbAction();
     434  new CommandLineFastParsingAction();
     435  new CommandLineHelpAction();
     436  new CommandLineVerboseAction();
     437  new CommandLineVersionAction();
     438
     439  new FragmentationDepthFirstSearchAction();
     440  new FragmentationFragmentationAction();
     441  new FragmentationSubgraphDissectionAction();
     442
     443  new MoleculeBondFileAction();
     444  new MoleculeChangeNameAction();
     445  new MoleculeFillWithMoleculeAction();
     446  new MoleculeLinearInterpolationofTrajectoriesAction();
     447  new MoleculeSaveAdjacencyAction();
     448  new MoleculeSaveBondsAction();
     449  new MoleculeSaveTemperatureAction();
     450  new MoleculeTranslateAction();
     451  new MoleculeVerletIntegrationAction();
     452
     453  new ParserLoadXyzAction();
     454  new ParserSaveXyzAction();
     455
     456  new TesselationConvexEnvelopeAction();
     457  new TesselationNonConvexEnvelopeAction();
     458
     459  new WorldAddEmptyBoundaryAction();
     460  new WorldBoundInBoxAction();
     461  new WorldCenterInBoxAction();
     462  new WorldCenterOnEdgeAction();
     463  new WorldChangeBoxAction();
     464  new WorldInputAction();
     465  new WorldOutputAction();
     466  new WorldRemoveSphereOfAtomsAction();
     467  new WorldRepeatBoxAction();
     468  new WorldScaleBoxAction();
     469  new WorldSetDefaultNameAction();
     470  new WorldSetGaussianBasisAction();
     471}
     472
     473
    330474/** Adds all options to the CommandLineParser.
    331475 *

  • src/Actions/MapOfActions.hpp

    rb80021 rb0acc3  
    1111#include "Helpers/Assert.hpp"
    1212#include <boost/program_options.hpp>
     13
    1314#include <map>
    1415#include <set>
    … …  
    2021namespace po = boost::program_options;
    2122
     23/** Central class for adding functionality to the code.
     24 *
     25 * In Molecuilder everything that can be done - such as adding atoms,
     26 * translating molecules, saving bind information - is an Action.
     27 *
     28 * In order to reference Action's with what the user sees, this class is the
     29 * mediator.
     30 *
     31 * An Action is described to the user by:
     32 * -# a name (this is the most important information)
     33 * -# a description
     34 * -# a shortform (single letter for use on the command line)
     35 * -# a text menu it resides in
     36 * -# the type of its argument
     37 * -# the command line category
     38 *
     39 * The Action::NAME is the most important information because every Action
     40 * registers itself automatically with the ActionRegistry and can be retrieved
     41 * therefrom and from this MapOfActions simply by knowing its name alone.
     42 *
     43 * In the constructor of MapOfActions all this is set.
     44 *
     45 * Note that Action will require input from the user. This is done via class
     46 * Query.
     47 *
     48 * And note also that MapOfActions actually contains more than just all
     49 * Actions: There are a number of names that actually are just arguments to
     50 * actions (e.g. "output-file").
     51 *
     52 * <h1> Howto add an Action</h1>
     53 *
     54 * Let us assume your new action (class) is called SuperDuperAction, consisting
     55 * of two files SuperDuperAction.cpp and SuperDuperAction.hpp.
     56 *
     57 * Furthermore, let's say you Action needs two values: a double value as a
     58 * upper threshold and a string which is the name of the output file.
     59 *
     60 * <h2> Command Line preliminaries </h2>
     61 *
     62 * You have to decide whether (for the command line) it makes sense to have an
     63 * extra argument requesting the arguments, or one should be the argument of
     64 * your action. I.e. your action name is "super-duper", then the use may
     65 * call your action like this:
     66 *
     67 * ./molecuilder --super-duper 4 --output-file test.dat
     68 *
     69 * Here, we have picked the threshold as the value for your action and the
     70 * name of the output file is given by an additional argument. Of course,
     71 * it can be the other way round or by two arguments such as here:
     72 *
     73 * ./molecuilder --super-duper --threshold 4 --output-file test.dat
     74 *
     75 * It depends on what possible arguments are already there (don't make up
     76 * new ones if present ones actually make sense for your action) and which
     77 * argument is more natural or closer to what your action does.
     78 *
     79 * <h2> Menu preliminaries </h2>
     80 *
     81 * Whatever you decide, your action will need some Query dialogs to request
     82 * the necessary information from the user, either via a command line
     83 * argument (--output-file) via a text dialog (referenced by "output-file")
     84 * or via a graphical dialog (same reference). And therein, the names
     85 * of the arguments have to re-appear.
     86 *
     87 * Then, the following steps have to be done to incorporate your Action:
     88 * -# create a unique name for your action (no capital letters) to reference
     89 *    it, this name has to appear in the file SuperDuperAction.cpp, e.g.
     90 *    "super-duper"
     91 * -# pick names the other required arguments, best if they are already
     92 *    present in the MapOfActions. They have to appear in Query's in the
     93 *    code of your Action.
     94 * -# With this name create entries in the following maps for the action
     95 *    name and for each names of a desired addtional argument if not present:
     96 *   -# DescriptionMap, a catchy description of what your action does
     97 *   -# TypeMap, see MapOfActions::OptionTypes for possible types of the single
     98 *      argument it takes.
     99 *   -# MenuContainsActionMap, in which menu should your action appear
     100 *   -# ShortFormMap (optional), single letter for command line call
     101 *   -# DefaultValueMap (optional), the default value (always a string)
     102 * -# add to one of the command line sets by the following categories
     103 *   -# generic - generic options (i.e. not one of the others)
     104 *   -# config - action/argument only considers internal bevahior, user
     105 *      does not have to see it while still having full functionality
     106 *   -# hidden - this should be hidden from the user
     107 *   -# visible - this should be visible to the user
     108 *   -# inputfile - this should only be parsed from an input file, not
     109 *      from command line
     110 * -# add to a menu, i.e. make an entry in MenuContainsActionMap.
     111 * -# add header file SuperDuperAction.hpp to MapOfActions.cpp and instantiate
     112 *    your action in populateMenu() (mind the sorting: 1. menu,
     113 *    2. alphabetical)
     114 *
     115 *  And that's.
     116 *
     117 *  Now, your action can be called from the command line, within the text
     118 *  menu and the graphical user interface.
     119 *
     120 */
    22121class MapOfActions : public Singleton<MapOfActions> {
    23122  friend class Singleton<MapOfActions>;
    … …  
    27126
    28127  // getter for the action descriptions and short forms
    29   std::string getDescription(string actionname);
    30   std::string getKeyAndShortForm(string actionname);
    31   std::string getShortForm(string actionname);
    32   map <std::string, std::string> getShortFormToActionMap();
     128  std::string getDescription(std::string actionname);
     129  std::string getKeyAndShortForm(std::string actionname);
     130  std::string getShortForm(std::string actionname);
     131  std::map <std::string, std::string> getShortFormToActionMap();
    33132
    34133  void AddOptionsToParser();
    35134
    36135  // check presence and getter for action type
    37   bool hasValue(string actionname);
    38   bool isShortFormPresent(string shortform);
    39   enum OptionTypes getValueType(string actionname);
     136  bool hasValue(std::string actionname);
     137  bool isShortFormPresent(std::string shortform);
     138  enum OptionTypes getValueType(std::string actionname);
    40139
    41   set<string> generic;
    42   set<string> config;
    43   set<string> hidden;
    44   set<string> visible;
    45   set<string> inputfile;
     140  std::set<std::string> generic;
     141  std::set<std::string> config;
     142  std::set<std::string> hidden;
     143  std::set<std::string> visible;
     144  std::set<std::string> inputfile;
     145
     146  std::multimap <std::string, std::string> MenuContainsActionMap;
     147
     148  // instantiates and puts all known actions into the ActionRegistry
     149  void populateActions();
    46150
    47151private:
    … …  
    51155
    52156  // lookup list from our configs to the ones of CommandLineParser
    53   map< set<std::string> *, po::options_description *> CmdParserLookup;
     157  std::map< std::set<std::string> *, po::options_description *> CmdParserLookup;
    54158
    55159  // map of the action names and their description
    56   map<std::string, std::string> DefaultValue;
    57   map<std::string, std::string> DescriptionMap;
    58   map<std::string, std::string> ShortFormMap;
    59   map<std::string, enum OptionTypes > TypeMap;
     160  std::map<std::string, std::string> DefaultValue;
     161  std::map<std::string, std::string> DescriptionMap;
     162  std::map<std::string, std::string> ShortFormMap;
     163  std::map<std::string, enum OptionTypes > TypeMap;
    60164};
    61165

  • src/Actions/MoleculeAction/ChangeNameAction.cpp

    rb80021 rb0acc3  
    3636};
    3737
    38 const char MoleculeChangeNameAction::NAME[] = "Change filename of Molecule";
     38const char MoleculeChangeNameAction::NAME[] = "change-molname";
    3939
    4040MoleculeChangeNameAction::MoleculeChangeNameAction() :

  • src/Makefile.am

    rb80021 rb0acc3  
    101101  Patterns/Observer.hpp \
    102102  Patterns/Singleton.hpp
    103 
    104 # all these files are only used for legacy reasons while the transition is in progress
    105 # they are only needed to keep the program usable at any point of the transition and will be
    106 # deleted once everything is fully refactored
    107 LEGACYSOURCE = Legacy/oldmenu.cpp
    108 LEGACYHEADER = Legacy/oldmenu.hpp
    109103
    110104QTUIMOC_HEADER = UIElements/QT4/QTDialog.hpp \
    … …  
    175169  ${DESCRIPTORSOURCE} \
    176170  ${HELPERSOURCE} \
    177   ${LEGACYSOURCE} \
    178171  ${EXCEPTIONSOURCE} \
    179172  bond.cpp \
    … …  
    223216  ${DESCRIPTORHEADER} \
    224217  ${EXCEPTIONHEADER} \
    225   ${LEGACYHEADER} \
    226218  bond.hpp \
    227219  bondgraph.hpp \

  • src/UIElements/CommandLineUI/CommandLineWindow.cpp

    rb80021 rb0acc3  
    1313#include "CommandLineUI/CommandLineStatusIndicator.hpp"
    1414
     15#include "Actions/Action.hpp"
     16#include "Actions/MapOfActions.hpp"
    1517#include "Actions/ActionRegistry.hpp"
    16 #include "Actions/AnalysisAction/MolecularVolumeAction.hpp"
    17 #include "Actions/AnalysisAction/PairCorrelationAction.hpp"
    18 #include "Actions/AnalysisAction/PrincipalAxisSystemAction.hpp"
    19 #include "Actions/AtomAction/AddAction.hpp"
    20 #include "Actions/AtomAction/ChangeElementAction.hpp"
    21 #include "Actions/AtomAction/RemoveAction.hpp"
    22 #include "Actions/CmdAction/BondLengthTableAction.hpp"
    23 #include "Actions/CmdAction/ElementDbAction.hpp"
    24 #include "Actions/CmdAction/FastParsingAction.hpp"
    25 #include "Actions/CmdAction/HelpAction.hpp"
    26 #include "Actions/CmdAction/VerboseAction.hpp"
    27 #include "Actions/CmdAction/VersionAction.hpp"
    28 #include "Actions/FragmentationAction/DepthFirstSearchAction.hpp"
    29 #include "Actions/FragmentationAction/SubgraphDissectionAction.hpp"
    30 #include "Actions/FragmentationAction/FragmentationAction.hpp"
    31 #include "Actions/MoleculeAction/BondFileAction.hpp"
    32 #include "Actions/MoleculeAction/ChangeNameAction.hpp"
    33 #include "Actions/MoleculeAction/FillWithMoleculeAction.hpp"
    34 #include "Actions/MoleculeAction/LinearInterpolationofTrajectoriesAction.hpp"
    35 #include "Actions/MoleculeAction/SaveAdjacencyAction.hpp"
    36 #include "Actions/MoleculeAction/SaveBondsAction.hpp"
    37 #include "Actions/MoleculeAction/SaveTemperatureAction.hpp"
    38 #include "Actions/MoleculeAction/TranslateAction.hpp"
    39 #include "Actions/MoleculeAction/VerletIntegrationAction.hpp"
    40 #include "Actions/ParserAction/LoadXyzAction.hpp"
    41 #include "Actions/ParserAction/SaveXyzAction.hpp"
    42 #include "Actions/TesselationAction/ConvexEnvelopeAction.hpp"
    43 #include "Actions/TesselationAction/NonConvexEnvelopeAction.hpp"
    44 #include "Actions/WorldAction/AddEmptyBoundaryAction.hpp"
    45 #include "Actions/WorldAction/BoundInBoxAction.hpp"
    46 #include "Actions/WorldAction/CenterInBoxAction.hpp"
    47 #include "Actions/WorldAction/CenterOnEdgeAction.hpp"
    48 #include "Actions/WorldAction/ChangeBoxAction.hpp"
    49 #include "Actions/WorldAction/InputAction.hpp"
    50 #include "Actions/WorldAction/OutputAction.hpp"
    51 #include "Actions/WorldAction/RemoveSphereOfAtomsAction.hpp"
    52 #include "Actions/WorldAction/RepeatBoxAction.hpp"
    53 #include "Actions/WorldAction/ScaleBoxAction.hpp"
    54 #include "Actions/WorldAction/SetDefaultNameAction.hpp"
    55 #include "Actions/WorldAction/SetGaussianBasisAction.hpp"
     18
    5619#include "CommandLineParser.hpp"
    5720
    … …  
    6427{
    6528  // create and register all command line callable actions
    66   populateAnalysisActions();
    67   populateAtomActions();
    68   populateCmdActions();
    69   populateFragmentationActions();
    70   populateMoleculeActions();
    71   populateParserActions();
    72   populateTesselationActions();
    73   populateWorldActions();
     29  MapOfActions::getInstance().populateActions();
    7430
    7531  // Add status indicators etc...
    … …  
    9753}
    9854
    99 void CommandLineWindow::populateAnalysisActions()
    100 {
    101   new AnalysisMolecularVolumeAction();
    102   new AnalysisPairCorrelationAction();
    103   new AnalysisPrincipalAxisSystemAction();
    104 }
    105 
    106 void CommandLineWindow::populateAtomActions()
    107 {
    108   new AtomAddAction();
    109   new AtomChangeElementAction();
    110   new AtomRemoveAction();
    111 }
    112 
    113 void CommandLineWindow::populateCmdActions()
    114 {
    115   new CommandLineBondLengthTableAction();
    116   new CommandLineElementDbAction();
    117   new CommandLineFastParsingAction();
    118   new CommandLineHelpAction();
    119   new CommandLineVerboseAction();
    120   new CommandLineVersionAction();
    121 }
    122 
    123 void CommandLineWindow::populateFragmentationActions()
    124 {
    125   new FragmentationDepthFirstSearchAction();
    126   new FragmentationFragmentationAction();
    127   new FragmentationSubgraphDissectionAction();
    128 }
    129 
    130 void CommandLineWindow::populateMoleculeActions()
    131 {
    132   new MoleculeBondFileAction();
    133   new MoleculeChangeNameAction();
    134   new MoleculeFillWithMoleculeAction();
    135   new MoleculeLinearInterpolationofTrajectoriesAction();
    136   new MoleculeSaveAdjacencyAction();
    137   new MoleculeSaveBondsAction();
    138   new MoleculeSaveTemperatureAction();
    139   new MoleculeTranslateAction();
    140   new MoleculeVerletIntegrationAction();
    141 }
    142 
    143 void CommandLineWindow::populateParserActions()
    144 {
    145   new ParserLoadXyzAction();
    146   new ParserSaveXyzAction();
    147 }
    148 
    149 void CommandLineWindow::populateTesselationActions()
    150 {
    151   new TesselationConvexEnvelopeAction();
    152   new TesselationNonConvexEnvelopeAction();
    153 }
    154 
    155 void CommandLineWindow::populateWorldActions()
    156 {
    157   new WorldAddEmptyBoundaryAction();
    158   new WorldBoundInBoxAction();
    159   new WorldCenterInBoxAction();
    160   new WorldCenterOnEdgeAction();
    161   new WorldChangeBoxAction();
    162   new WorldInputAction();
    163   new WorldOutputAction();
    164   new WorldRemoveSphereOfAtomsAction();
    165   new WorldRepeatBoxAction();
    166   new WorldScaleBoxAction();
    167   new WorldSetDefaultNameAction();
    168   new WorldSetGaussianBasisAction();
    169 }

  • src/UIElements/TextUI/TextWindow.cpp

    rb80021 rb0acc3  
    1212#include <boost/bind.hpp>
    1313
    14 
    15 // TODO: When done with refactoring most of these wont be needed anymore
    16 #include "analysis_correlation.hpp"
    17 #include "atom.hpp"
    18 #include "bond.hpp"
    19 #include "bondgraph.hpp"
    20 #include "boundary.hpp"
    21 #include "config.hpp"
    22 #include "element.hpp"
    23 #include "ellipsoid.hpp"
    24 #include "helpers.hpp"
    25 #include "leastsquaremin.hpp"
    26 #include "linkedcell.hpp"
    27 #include "log.hpp"
    28 #include "memoryusageobserver.hpp"
    29 #include "molecule.hpp"
    30 #include "periodentafel.hpp"
    31 #include "World.hpp"
    32 
    33 #include "Legacy/oldmenu.hpp"
    34 
    3514#include "Menu/Menu.hpp"
    3615#include "Menu/TextMenu.hpp"
    … …  
    4019#include "Menu/SubMenuItem.hpp"
    4120#include "TextUI/TextStatusIndicator.hpp"
     21#include "Actions/MapOfActions.hpp"
    4222#include "Actions/MethodAction.hpp"
    43 #include "Actions/MoleculeAction/ChangeNameAction.hpp"
    4423#include "Actions/ErrorAction.hpp"
    4524#include "Actions/ActionRegistry.hpp"
    … …  
    4827#include "Helpers/MemDebug.hpp"
    4928
     29#include "defs.hpp"
     30#include "log.hpp"
     31#include "verbose.hpp"
     32
     33// all needed due to config::SaveAll()
     34#include "config.hpp"
     35#include "periodentafel.hpp"
     36
     37// config::SaveAll() and enumerate()
     38#include "molecule.hpp"
     39
    5040#include <iostream>
     41#include <map>
    5142
    5243using namespace std;
    … …  
    5546TextWindow::TextWindow()
    5647{
    57   MoleculeListClass *molecules = World::getInstance().getMolecules();
    58   config *configuration = World::getInstance().getConfig();
    59   periodentafel *periode = World::getInstance().getPeriode();
    60   char *ConfigFileName = NULL;
    61   old_menu = new oldmenu;
     48  char ConfigFileName[MAXSTRINGSIZE];
     49  map <std::string, TextMenu *> NametoTextMenuMap;
     50
     51  // populate all actions
     52  MapOfActions::getInstance().populateActions();
    6253
    6354  // build the main menu
    6455  main_menu = new TextMenu(Log() << Verbose(0), "Main Menu");
    6556
    66   moleculeView = new StreamStringView(boost::bind(&MoleculeListClass::Enumerate,molecules,_1));
     57  moleculeView = new StreamStringView(boost::bind(&MoleculeListClass::Enumerate,World::getInstance().getMolecules(),_1));
    6758  new DisplayMenuItem(main_menu,moleculeView,"Molecule List");
    6859
    … …  
    7768  new SeperatorItem(main_menu);
    7869
    79   Action *setMoleculeAction = new MethodAction("setMoleculeAction",boost::bind(&MoleculeListClass::flipChosen,molecules));
     70  Action *setMoleculeAction = new MethodAction("setMoleculeAction",boost::bind(&MoleculeListClass::flipChosen,World::getInstance().getMolecules()));
    8071  new ActionMenuItem('a',"set molecule (in)active",main_menu,setMoleculeAction);
    8172
    82   TextMenu *editMoleculesMenu = new TextMenu(Log() << Verbose(0), "Edit Molecules");
    83   new SubMenuItem('e',"edit molecules (load, parse, save)",main_menu,editMoleculesMenu);
     73  TextMenu *AnalysisMenu = new TextMenu(Log() << Verbose(0), "Analysis");
     74  NametoTextMenuMap.insert( pair <std::string, TextMenu *> ("analysis", AnalysisMenu) );
     75  new SubMenuItem('A',"Analysis (pair correlation, volume)",main_menu,AnalysisMenu);
    8476
    85   Action *manipulateMoleculeAction = new MethodAction("manipulateMoleculeAction",boost::bind(&oldmenu::ManipulateMolecules,old_menu,periode, molecules, configuration));
    86   new ActionMenuItem('g',"globally manipulate atoms in molecule",main_menu,manipulateMoleculeAction);
     77  TextMenu *CommandMenu = new TextMenu(Log() << Verbose(0), "Configuration");
     78  NametoTextMenuMap.insert( pair <std::string, TextMenu *> ("command", CommandMenu) );
     79  new SubMenuItem('c',"configuration",main_menu,CommandMenu);
    8780
    88   Action *mergeMoleculeAction = new MethodAction("mergeMoleculeAction",boost::bind(&oldmenu::MergeMolecules,old_menu,periode, molecules));
    89   new ActionMenuItem('M',"Merge molecules",main_menu,mergeMoleculeAction);
     81  TextMenu *AtomMenu = new TextMenu(Log() << Verbose(0), "Atoms");
     82  NametoTextMenuMap.insert( pair <std::string, TextMenu *> ("atom", AtomMenu) );
     83  new SubMenuItem('e',"edit atoms",main_menu,AtomMenu);
    9084
    91   Action *manipulateAtomsAction = new MethodAction("manipulateAtomsAction",boost::bind(&oldmenu::ManipulateAtoms,old_menu,periode, molecules, configuration));
    92   new ActionMenuItem('m',"manipulate atoms",main_menu,manipulateAtomsAction);
     85  TextMenu *FragmentationMenu = new TextMenu(Log() << Verbose(0), "Fragmentation");
     86  NametoTextMenuMap.insert( pair <std::string, TextMenu *> ("fragmentation", FragmentationMenu) );
     87  new SubMenuItem('f',"fragmentation",main_menu,FragmentationMenu);
     88
     89  TextMenu *ParserMenu = new TextMenu(Log() << Verbose(0), "Parse files");
     90  NametoTextMenuMap.insert( pair <std::string, TextMenu *> ("parser", ParserMenu) );
     91  new SubMenuItem('p',"parse files into system",main_menu,ParserMenu);
     92
     93  TextMenu *MoleculesMenu = new TextMenu(Log() << Verbose(0), "Edit Molecules");
     94  NametoTextMenuMap.insert( pair <std::string, TextMenu *> ("analysis", AnalysisMenu) );
     95  new SubMenuItem('m',"edit molecules (load, parse, save)",main_menu,MoleculesMenu);
     96
     97  TextMenu *TesselationMenu = new TextMenu(Log() << Verbose(0), "Tesselate Molecules");
     98  NametoTextMenuMap.insert( pair <std::string, TextMenu *> ("tesselation", TesselationMenu) );
     99  new SubMenuItem('t',"tesselate molecules",main_menu,TesselationMenu);
     100
     101  TextMenu *WorldMenu = new TextMenu(Log() << Verbose(0), "World");
     102  NametoTextMenuMap.insert( pair <std::string, TextMenu *> ("world", WorldMenu) );
     103  new SubMenuItem('w',"edit world",main_menu,WorldMenu);
    93104
    94105  new SeperatorItem(main_menu);
    95106
    96   Action *editConfigAction = new MethodAction("editConfigAction",boost::bind(&config::Edit,configuration));
    97   new ActionMenuItem('c',"edit the current configuration",main_menu,editConfigAction);
    98 
    99   new SeperatorItem(main_menu);
    100 
    101   Action *saveConfigAction = new MethodAction("saveConfigAction",boost::bind(&config::SaveAll,configuration, ConfigFileName, periode, molecules));
     107  Action *saveConfigAction = new MethodAction("saveConfigAction",boost::bind(&config::SaveAll,World::getInstance().getConfig(), ConfigFileName, World::getInstance().getPeriode(), World::getInstance().getMolecules()));
    102108  new ActionMenuItem('s',"save current setup to config file",main_menu,saveConfigAction);
    103 
    104   Action *doTestAction = new MethodAction("doTestAction",boost::bind(&oldmenu::testroutine,old_menu,molecules));
    105   new ActionMenuItem('T',"call the current test routine",main_menu,doTestAction);
    106109
    107110  quitAction = new MethodAction("quitAction",boost::bind(&TextMenu::doQuit,main_menu),false);
    108111  new ActionMenuItem('q',"quit",main_menu,quitAction);
    109112
    110   // call all functions used to build the submenus
    111 
    112   populateEditMoleculesMenu(editMoleculesMenu);
    113 
    114   Action *returnFromEditMoleculeAction = new TextMenu::LeaveAction(editMoleculesMenu);
    115   MenuItem *returnItem = new ActionMenuItem('q',"return to Main menu",editMoleculesMenu,returnFromEditMoleculeAction);
    116 
    117   editMoleculesMenu->addDefault(returnItem);
     113  // go through all menus and create them
     114  for (map <std::string, TextMenu *>::iterator MenuRunner = NametoTextMenuMap.begin(); MenuRunner != NametoTextMenuMap.end(); ++MenuRunner) {
     115    cout << "Creating Menu " << MenuRunner->first << "." << endl;
     116    populateMenu(MenuRunner->second, MenuRunner->first);
     117  }
    118118
    119119  // Add status indicators etc...
    … …  
    124124TextWindow::~TextWindow()
    125125{
    126   delete old_menu;
    127126  delete quitAction;
    128127  delete moleculeView;
    … …  
    135134}
    136135
    137 void TextWindow::populateEditMoleculesMenu(Menu* editMoleculesMenu)
     136char TextWindow::getSuitableShortForm(set <char> &ShortcutList, const std::string name) const
    138137{
    139   MoleculeListClass *molecules = World::getInstance().getMolecules();
    140   periodentafel *periode = World::getInstance().getPeriode();
     138  for (std::string::const_iterator CharRunner = name.begin(); CharRunner != name.end(); ++CharRunner) {
     139    if (ShortcutList.find(*CharRunner) == ShortcutList.end())
     140      return *CharRunner;
     141  }
     142  DoeLog(1) && (eLog() << Verbose(1) << "Could not find a suitable shortform for TextWindow::getSuitableShortForm()." << endl);
     143  return ((char)(ShortcutList.size() % 10) + '0');
     144}
    141145
    142   // build the EditMoleculesMenu
    143   Action *createMoleculeAction = new MethodAction("createMoleculeAction",boost::bind(&MoleculeListClass::createNewMolecule,molecules,periode));
    144   new ActionMenuItem('c',"create new molecule",editMoleculesMenu,createMoleculeAction);
    145 
    146   Action *loadMoleculeAction = new MethodAction("loadMoleculeAction",boost::bind(&MoleculeListClass::loadFromXYZ,molecules,periode));
    147   new ActionMenuItem('l',"load molecule from xyz file",editMoleculesMenu,loadMoleculeAction);
    148 
    149   Action *changeFilenameAction = new MoleculeChangeNameAction();
    150   new ActionMenuItem('n',"change molecule's name",editMoleculesMenu,changeFilenameAction);
    151 
    152   Action *giveFilenameAction = new MethodAction("giveFilenameAction",boost::bind(&MoleculeListClass::setMoleculeFilename,molecules));
    153   new ActionMenuItem('N',"give molecules filename",editMoleculesMenu,giveFilenameAction);
    154 
    155   Action *parseAtomsAction = new MethodAction("parseAtomsAction",boost::bind(&MoleculeListClass::parseXYZIntoMolecule,molecules));
    156   new ActionMenuItem('p',"parse atoms in xyz file into molecule",editMoleculesMenu,parseAtomsAction);
    157 
    158   Action *eraseMoleculeAction = new MethodAction("eraseMoleculeAction",boost::bind(&MoleculeListClass::eraseMolecule,molecules));
    159   new ActionMenuItem('r',"remove a molecule",editMoleculesMenu,eraseMoleculeAction);
    160 
     146void TextWindow::populateMenu(TextMenu* Menu, const  std::string &MenuName)
     147{
     148  Action *ActionItem = NULL;
     149  set <char> ShortcutList;
     150  // through all actions for this menu
     151  pair < multimap <std::string, std::string>::iterator, multimap <std::string, std::string>::iterator > MenuActions = MapOfActions::getInstance().MenuContainsActionMap.equal_range(MenuName);
     152  for (multimap <std::string, std::string>::const_iterator MenuRunner = MenuActions.first; MenuRunner != MenuActions.second; ++MenuRunner) {
     153    cout << " Adding " << MenuRunner->second << " to submenu " << MenuName << endl;
     154    ActionItem = ActionRegistry::getInstance().getActionByName(MenuRunner->second);
     155    new ActionMenuItem(getSuitableShortForm(ShortcutList, MenuRunner->second),MapOfActions::getInstance().getDescription(MenuRunner->second).c_str(),Menu,ActionItem);
     156  }
     157  // finally add default quit item
     158  Action *returnFromAction = new TextMenu::LeaveAction(Menu);
     159  MenuItem *returnFromItem = new ActionMenuItem('q',"return to Main menu",Menu,returnFromAction);
     160  Menu->addDefault(returnFromItem);
    161161}

  • src/UIElements/TextUI/TextWindow.hpp

    rb80021 rb0acc3  
    1111#include "MainWindow.hpp"
    1212
     13#include <set>
     14
    1315class TextMenu;
    1416class Action;
    15 class oldmenu;
    1617class StringView;
    1718class TextStatusIndicator;
    … …  
    2728private:
    2829  // populaters
    29   void populateEditMoleculesMenu(Menu* editMoleculesMenu);
     30  char getSuitableShortForm(std::set <char> &ShortcutList, const std::string name) const;
     31  void populateMenu(TextMenu* Menu, const std::string &name);
    3032
    3133  TextMenu *main_menu;
    … …  
    3638  StringView *moleculeView;
    3739  TextStatusIndicator *statusIndicator;
    38 
    39   // This class still contains a lot of scattered functionality
    40   oldmenu *old_menu;
    4140};
    4241

  • src/builder.cpp

    rb80021 rb0acc3  
    126126  // print version check whether arguments are present at all
    127127  cout << ESPACKVersion << endl;
    128   if (argc < 2) {
    129     cout << "Obtain help with " << argv[0] << " -h." << endl;
    130     cleanUp();
    131     Memory::getState();
    132     return(1);
    133   }
    134 
    135128
    136129  setVerbosity(0);
    … …  
    157150    }
    158151    // handle remaining arguments by CommandLineParser
    159     MapOfActions::getInstance().AddOptionsToParser();
    160     map <std::string, std::string> ShortFormToActionMap = MapOfActions::getInstance().getShortFormToActionMap();
    161     CommandLineParser::getInstance().Run(argc,argv, ShortFormToActionMap);
    162     if (!CommandLineParser::getInstance().isEmpty()) {
     152    if (argc>1) {
     153      MapOfActions::getInstance().AddOptionsToParser();
     154      map <std::string, std::string> ShortFormToActionMap = MapOfActions::getInstance().getShortFormToActionMap();
     155      CommandLineParser::getInstance().Run(argc,argv, ShortFormToActionMap);
    163156      DoLog(0) && (Log() << Verbose(0) << "Setting UI to CommandLine." << endl);
    164157      UIFactory::registerFactory(new CommandLineUIFactory::description());
Note: See TracChangeset for help on using the changeset viewer.