Changeset b59da6 for src


Ignore:
Timestamp:
Dec 4, 2010, 11:33:47 PM (14 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:
0af7ef
Parents:
5813ac
git-author:
Frederik Heber <heber@…> (11/08/10 09:36:45)
git-committer:
Frederik Heber <heber@…> (12/04/10 23:33:47)
Message:

Refactoring of Menu structure for Qt and Text UI done.

  • Menu is now the initialising class for the menu structure.
  • MenuInterface contains virtual declarations of all functions that Menu needs to call.
  • TextMenu and QtMenu are templated classes which contain both Menu and MenuInterface and implement the virtual functions.
  • class TxMenu and its ...MenuItems contain most of the old Menu code for the text-based system. Most of the stuff, such as triggers, are now hidden internally.
  • in ..MainWindow() we basically just construct the desired Menu and call init at the correct time.
Location:
src
Files:
6 added
2 deleted
17 edited
11 moved

Legend:

Unmodified
Added
Removed

  • src/Actions/ActionRegistry.cpp

    r5813ac rb59da6  
    5252}
    5353
     54/** Returns the last present action position in the requested menu.
     55 * \param &token token of the menu
     56 * \return last used position
     57 */
     58int ActionRegistry::getLastPosition(const std::string &token) const
     59{
     60  int position = 0;
     61  for (const_iterator iter = getBeginIter();
     62      iter != getEndIter();
     63      ++iter) {
     64    const std::string &MenuName = (iter->second)->Traits.getMenuName();
     65    const int &MenuPosition = (iter->second)->Traits.getMenuPosition();
     66    if ((MenuName == token) && (position < MenuPosition))
     67      position = MenuPosition;
     68  }
     69  return position;
     70}
     71
     72
    5473CONSTRUCT_SINGLETON(ActionRegistry)
    5574CONSTRUCT_REGISTRY(Action)

  • src/Actions/ActionRegistry.hpp

    r5813ac rb59da6  
    3131  Action* getActionByName(const std::string name);
    3232  bool isActionPresentByName(const std::string name) const;
     33  int getLastPosition(const std::string &MenuName) const;
    3334
    3435private:

  • src/Actions/ActionTraits.cpp

    r5813ac rb59da6  
    4646      _Traits.hasDefaultValue() ? _Traits.getDefaultValue() : "",
    4747      _Traits.hasShortForm() ? _Traits.getShortForm() : ""
    48   )
     48  ),
     49  MenuTitle(_Traits.MenuTitle),
     50  MenuPosition(_Traits.MenuPosition)
    4951{
    50   MenuTitle = _Traits.MenuTitle;
    51   MenuPosition = _Traits.MenuPosition;
    5252  for (options_const_iterator iter = _Traits.Options.begin(); iter != _Traits.Options.end(); ++iter) {
    5353    Options.insert(
    … …  
    6565 * \param &_Traits source OptionTrait class to copy
    6666 */
    67 ActionTraits::ActionTraits(const OptionTrait &_Traits) :
    68   OptionTrait(_Traits)
     67ActionTraits::ActionTraits(const OptionTrait &_Traits, const std::string _MenuTitle, const int _MenuPosition) :
     68  OptionTrait(_Traits),
     69  MenuTitle(_MenuTitle),
     70  MenuPosition(_MenuPosition)
    6971{
    7072  //std::cout << "ActionTraits::ActionTraits(OptionTrait &) with " << getName() << ", type " << getTypeName() << " and description " << getDescription() << std::endl;
    … …  
    9496 * \return ActionTraits::MenuPosition as std::string
    9597 */
    96 const int ActionTraits::getMenuPosition() const
     98int ActionTraits::getMenuPosition() const
    9799{
    98100  return MenuPosition;

  • src/Actions/ActionTraits.hpp

    r5813ac rb59da6  
    3131public:
    3232  ActionTraits(const ActionTraits &_Traits);
    33   ActionTraits(const OptionTrait &_Traits);
     33  ActionTraits(const OptionTrait &_Traits, const std::string _MenuTitle = "", const int _MenuPosition = 0);
    3434  explicit ActionTraits(const std::string &_token);
    3535  virtual ~ActionTraits();
    … …  
    4040
    4141  const std::string& getMenuName() const;
    42   const int getMenuPosition() const;
     42  int getMenuPosition() const;
    4343
    4444  // getter for its options

  • src/Makefile.am

    r5813ac rb59da6  
    128128        UIElements/Qt4/QtMainWindow.hpp \
    129129        UIElements/Menu/Qt4/QtMenu.hpp \
     130        UIElements/Menu/Qt4/QtMenuPipe.hpp \
    130131        UIElements/Views/Qt4/QtWorldView.hpp \
    131132        UIElements/Views/Qt4/GLMoleculeView.hpp \
    … …  
    170171        UIElements/Qt4/QtDialog.cpp \
    171172        UIElements/Qt4/QtUIFactory.cpp \
    172         UIElements/Menu/Qt4/QtMenu.cpp \
     173        UIElements/Menu/Qt4/QtMenuPipe.cpp \
    173174        UIElements/Views/Qt4/QtWorldView.cpp \
    174175        UIElements/Views/Qt4/GLMoleculeView.cpp \

  • src/Patterns/Registry_impl.hpp

    r5813ac rb59da6  
    3535  typename std::map<const std::string,T*>::const_iterator iter;
    3636  iter = InstanceMap.find(name);
    37   ASSERT(iter!=InstanceMap.end(),"Query for an instance not stored in registry");
     37  ASSERT(iter!=InstanceMap.end(),"Query for an instance "+name+" not stored in registry");
    3838  return iter->second;
    3939}
    … …  
    5858  //std::cout << "Trying to register instance of type " << typeid(T).name() << " with name " << instance->getName() << "." << std::endl;
    5959  ret = InstanceMap.insert(typename std::pair<const std::string,T*>(instance->getName(),instance));
    60   ASSERT(ret.second,"Two instances with the same name added to registry");
     60  ASSERT(ret.second,"Two instances with the same name "+instance->getName()+" added to registry");
    6161}
    6262

  • src/UIElements/Makefile.am

    r5813ac rb59da6  
    2020  Menu/Menu.cpp \
    2121  Menu/MenuDescription.cpp \
    22   Menu/TextMenu.cpp \
    23   Menu/MenuItem.cpp \
    24   Menu/SubMenuItem.cpp \
    25   Menu/ActionMenuItem.cpp \
    26   Menu/SeperatorItem.cpp \
    27   Menu/DisplayMenuItem.cpp
    28  
     22  Menu/MenuInterface.cpp
     23
    2924MENUHEADER = \
    3025  Menu/Menu.hpp \
    3126  Menu/MenuDescription.hpp \
    32   Menu/TextMenu.hpp \
    33   Menu/MenuItem.hpp \
    34   Menu/SubMenuItem.hpp \
    35   Menu/ActionMenuItem.hpp \
    36   Menu/SeperatorItem.hpp \
    37   Menu/DisplayMenuItem.hpp
     27  Menu/MenuInterface.hpp
     28 
     29TEXTMENUSOURCE = \
     30  Menu/TextMenu/TxMenu.cpp \
     31  Menu/TextMenu/MenuItem.cpp \
     32  Menu/TextMenu/SubMenuItem.cpp \
     33  Menu/TextMenu/ActionMenuItem.cpp \
     34  Menu/TextMenu/SeperatorItem.cpp \
     35  Menu/TextMenu/DisplayMenuItem.cpp
     36 
     37TEXTMENUHEADER = \
     38  Menu/TextMenu/TextMenu.hpp \
     39  Menu/TextMenu/TxMenu.hpp \
     40  Menu/TextMenu/MenuItem.hpp \
     41  Menu/TextMenu/SubMenuItem.hpp \
     42  Menu/TextMenu/ActionMenuItem.hpp \
     43  Menu/TextMenu/SeperatorItem.hpp \
     44  Menu/TextMenu/DisplayMenuItem.hpp
    3845
    3946UISOURCE = \
    … …  
    4148  ${COMMANDLINEUISOURCE} \
    4249  ${MENUSOURCE} \
     50  ${TEXTMENUSOURCE} \
    4351  ${TEXTUISOURCE} \
    4452  ${VIEWSOURCE} \
    … …  
    6977  ${COMMANDLINEUIHEADER} \
    7078  ${MENUHEADER} \
     79  ${TEXTMENUHEADER} \
    7180  ${TEXTUIHEADER} \
    7281  ${VIEWHEADER} \

  • src/UIElements/Menu/Menu.cpp

    r5813ac rb59da6  
    2020#include "Helpers/MemDebug.hpp"
    2121
    22 #include "Menu.hpp"
     22#include <iostream>
    2323
    24 Menu::Menu()
     24#include "Actions/ActionRegistry.hpp"
     25#include "Actions/Action.hpp"
     26#include "Actions/ActionTraits.hpp"
     27#include "Menu/Menu.hpp"
     28
     29/** Constructor of class Menu.
     30 * \param &_name name of menu
     31 */
     32Menu::Menu(const std::string &_name) :
     33  MenuInterface(_name),
     34  name(_name),
     35  TopPosition(0),
     36  LastItem(NoItem)
     37{}
     38
     39/** Destructor of class Menu.
     40 *
     41 */
     42Menu::~Menu()
     43{}
     44
     45/** Initialiser for class Menu.
     46 * Fills menus with items.
     47 */
     48void Menu::init()
    2549{
    26   // TODO Auto-generated constructor stub
    27 
     50  populate();
     51  populateActions();
    2852}
    2953
    30 Menu::~Menu()
     54/** Initializing function.
     55 * Inserts Menus and Actions obtained from MenuDescription and
     56 * ActionRegistry.
     57 */
     58void Menu::populate()
    3159{
    32   // TODO Auto-generated destructor stub
     60  // go through all menus and create them
     61
     62  bool CompleteFlag = false;  // indicates whether all menus have been added
     63  bool PossibleMissingFlag = false; // indicates whether a separator is missing
     64  while (!CompleteFlag) {
     65    CompleteFlag = true;
     66    PossibleMissingFlag = false;
     67    for(MenuDescription::const_iterator iter = menudescriptions.getBeginIter();
     68        iter != menudescriptions.getEndIter();
     69        ++iter) {
     70      // skip when already present
     71      if (!isPresent(iter->first)) {
     72        // have some short refs to infos
     73        const std::string &MenuName = iter->first;
     74        const std::string &TopName = iter->second.first;
     75        const int &MenuPosition = iter->second.second;
     76        std::cout << "MenuName is " << MenuName
     77            << ", TopName is " << TopName
     78            << " and Position is " << MenuPosition
     79            << std::endl;
     80
     81        // does it belong to us?
     82        if (TopName == name) {
     83          if (MenuPosition-1 == TopPosition) {
     84            Menu::addSubmenu(MenuName, MenuPosition);
     85            CompleteFlag = false;
     86          }
     87          // is there a menuposition specified that we have not reached yet?
     88          if (MenuPosition-1 > TopPosition)
     89            PossibleMissingFlag = true;
     90        }
     91      }
     92    }
     93    if (PossibleMissingFlag && (CompleteFlag)) {
     94      Menu::addSeparator();
     95      CompleteFlag = false; // pass once more as there should be a menu to come
     96    }
     97  }
    3398}
     99
     100/** Fills this menu with all Actions that belong to it.
     101 */
     102void Menu::populateActions()
     103{
     104  // go through all actions and add those beloning to this menu
     105  ActionRegistry &AR = ActionRegistry::getInstance();
     106  for (ActionRegistry::const_iterator iter = AR.getBeginIter();
     107      iter != AR.getEndIter();
     108      ++iter) {
     109    const std::string &MenuName = iter->second->Traits.getMenuName();
     110    if (MenuName == name) {
     111      const std::string &ActionName = iter->first;
     112      Menu::addAction(ActionName);
     113    }
     114  }
     115}
     116
     117void Menu::addAction(const std::string &ActionName)
     118{
     119  LastItem = ActionItem;
     120  addActionItem(ActionName, ActionName);
     121}
     122
     123void Menu::addSeparator()
     124{
     125  std::cout << "Creating separator at position " << TopPosition << std::endl;
     126  ASSERT( LastItem != SeparatorItem,
     127      "Menu::populate() - adding another separator after a separator!");
     128  LastItem = SeparatorItem;
     129  addSeparatorItem();
     130  TopPosition++;
     131}
     132
     133void Menu::addSubmenu(const std::string &MenuName, const int MenuPosition)
     134{
     135  std::cout << "Creating top-level menu " << MenuName
     136      << " at position " << TopPosition << std::endl;
     137  ASSERT (!isPresent(MenuName),
     138      "Menu::addSubmenu() - trying to add menu "+MenuName+" with already present token!");
     139  addSubmenuItem(MenuName, menudescriptions.getDescription(MenuName));
     140  DuplicatesList.insert(MenuName);
     141  LastItem = MenuItem;
     142  TopPosition = MenuPosition;
     143}
     144
     145bool Menu::isPresent(const std::string &token)
     146{
     147  return (DuplicatesList.find(token) != DuplicatesList.end());
     148}

  • src/UIElements/Menu/Menu.hpp

    r5813ac rb59da6  
    99#define MENU_MENU_H_
    1010
    11 using namespace std;
     11#include <set>
     12#include <string>
    1213
    13 class MenuItem;
     14#include "Menu/MenuInterface.hpp"
     15#include "Menu/MenuDescription.hpp"
    1416
    15 /**
    16  * Base class for all Types of menus
    17  * contains basic abstract functionality to add Items, remove Items and display the menu
     17/** Base class for all Types of menus.
     18 * Here, we simply initialize the menus. Via the MenuInterface wrapper we may
     19 * access the adding of items for each specific menu in a uniform manner.
    1820 *
    19  * TODO: Make sure all items are only added once.
     21 * Note that this Class is never to be used directly but only via derived
     22 * specializations.
    2023 */
    21 class Menu
     24class Menu : virtual public MenuInterface
    2225{
    2326public:
    24   Menu();
     27  explicit Menu(const std::string &name);
    2528  virtual ~Menu();
    2629
     30  void init();
    2731
    28   /**
    29    * Adding and removing should be handled by the items.
    30    */
    31   virtual void addItem(MenuItem*)=0;
    32   /**
    33    * Adding and removing should be handled by the items.
    34    */
    35   virtual void removeItem(MenuItem*)=0;
    36   virtual void display()=0;
     32protected:
     33  // Unique name of the menu for identification.
     34  const std::string name;
     35
     36  // populater function that adds all menu items
     37  void populate();
     38  void populateActions();
    3739
    3840private:
     41  void addAction(const std::string &ActionName);
     42  void addSeparator();
     43  void addSubmenu(const std::string &MenuName, const int MenuPosition);
     44  bool isPresent(const std::string &token);
     45
     46  enum ItemType {ActionItem, MenuItem, SeparatorItem, NoItem};
     47
     48  int TopPosition;  // current position to add
     49  MenuDescription menudescriptions; // contains the menu tree and description to each item
     50  enum ItemType LastItem;  // check whether separator followed separator
     51  std::set <std::string> DuplicatesList;  // is used to check for duplicates
    3952};
    4053

  • src/UIElements/Menu/MenuDescription.cpp

    r5813ac rb59da6  
    7575 * \return description string of the menu or empty
    7676 */
    77 const std::string MenuDescription::getDescription(std::string token) const
     77const std::string MenuDescription::getDescription(const std::string &token) const
    7878{
    7979  if (MenuDescriptionsMap.find(token) != MenuDescriptionsMap.end())
    … …  
    8787 * \return description string of the menu or empty
    8888 */
    89 const std::string MenuDescription::getName(std::string token) const
     89const std::string MenuDescription::getName(const std::string &token) const
    9090{
    9191  if (MenuNameMap.find(token) != MenuNameMap.end())

  • src/UIElements/Menu/MenuDescription.hpp

    r5813ac rb59da6  
    3232
    3333  // getter for description
    34   const std::string getDescription(std::string token) const;
    35   const std::string getName(std::string token) const;
     34  const std::string getDescription(const std::string &token) const;
     35  const std::string getName(const std::string &token) const;
    3636
    3737  std::multimap <std::string, std::string> getMenuItemsMap() const;

  • src/UIElements/Menu/Qt4/QtMenu.hpp

    r5813ac rb59da6  
    22 * QtMenu.hpp
    33 *
    4  *  Created on: Jan 15, 2010
    5  *      Author: crueger
     4 *  Created on: Nov 5, 2010
     5 *      Author: heber
    66 */
    77
    8 #ifndef QTMENU_HPP_
    9 #define QTMENU_HPP_
     8#ifndef MENUINTERFACEQT_HPP_
     9#define MENUINTERFACEQT_HPP_
    1010
     11#include <Qt/qaction.h>
     12
     13#include <iostream>
    1114#include <list>
    12 
    13 #include <QtGui/QMenu>
    14 #include <QtCore/QObject>
     15#include <map>
     16#include <string>
    1517
    1618#include "Menu/Menu.hpp"
     19#include "Menu/MenuInterface.hpp"
     20#include "Menu/Qt4/QtMenuPipe.hpp"
    1721
    18 class QtMenuPipe;
     22/** QtMenu is a specialization of MenuInterface to Qt-like menus.
     23 * I.e. with this interface we can access QMenu and QMenuBar.
     24 * (The latter is the reason why we have to add this additional wrapping layer).
     25 */
     26template <class T>
     27class QtMenu : virtual public MenuInterface, public Menu
     28{
     29public:
     30  explicit QtMenu(const std::string &_token) :
     31    MenuInterface(_token),
     32    Menu(_token),
     33    MenuInstance(new T(QString(getNameWithAccelerator(_token).c_str()))),
     34    deleteMenu(true)
     35  {}
    1936
    20 class QtMenu : public QMenu, public Menu
    21 {
    22   Q_OBJECT
     37  QtMenu(T *_Menu, const std::string &_token) :
     38    MenuInterface(_token),
     39    Menu(_token),
     40    MenuInstance(_Menu),
     41    deleteMenu(false)
     42  {}
    2343
    24 public:
    25   QtMenu(const char *);
    26   virtual ~QtMenu();
     44  virtual ~QtMenu()
     45  {
     46    for(std::list<QtMenuPipe*>::iterator it=plumbing.begin(); it != plumbing.end(); it++)
     47      delete (*it);
    2748
    28   virtual void addItem(MenuItem*);
    29   virtual void removeItem(MenuItem*);
    30   virtual void display();
     49    if (deleteMenu)
     50      delete MenuInstance;
     51  }
     52
     53  T * const getMenuInstance()
     54  {
     55    return MenuInstance;
     56  }
     57
     58protected:
     59  // We need to have a reference of the Menu, as Qt returns reference to added menu as well
     60  T *MenuInstance;
     61
     62  /** Puts Qt's token, the ampersand, in front of the accelerator char in the menu name.
     63   * \param ActionName Action of menu
     64   * \return name with ampersand added at the right place
     65   */
     66  std::string getNameWithAccelerator(const std::string &ActionName)
     67  {
     68    std::string newname;
     69    bool Inserted = false;
     70    std::pair < MenuShortcutMap::iterator, bool > Inserter;
     71    for (std::string::const_iterator CharRunner = ActionName.begin();
     72        CharRunner != ActionName.end();
     73        ++CharRunner) {
     74      std::cout << "Current char is " << *CharRunner << std::endl;
     75      if (!Inserted) {
     76        Inserter = ShortcutMap.insert(
     77            std::pair<char, std::string > (*CharRunner, ActionName)
     78            );
     79        if (Inserter.second) {
     80          std::cout << "Accelerator is " << *CharRunner << std::endl;
     81          newname += '&';
     82          Inserted = true;
     83        }
     84      }
     85      newname += *CharRunner;
     86    }
     87    return newname;
     88  }
     89
    3190private:
    32   list<QtMenuPipe*> plumbing;
     91  bool deleteMenu;
     92  std::list<QtMenuPipe*> plumbing;
     93
     94  typedef std::map <char, std::string> MenuShortcutMap;
     95  MenuShortcutMap ShortcutMap;
     96
     97  virtual void addActionItem(const std::string &token, const std::string &description)
     98  {
     99    QAction *action = MenuInstance->addAction(QString(getNameWithAccelerator(description).c_str()));
     100    QtMenuPipe *pipe = new QtMenuPipe(token,action);
     101    QObject::connect(action, SIGNAL(triggered()),pipe,SLOT(called()));
     102    plumbing.push_back(pipe);
     103  }
     104
     105  virtual void addSeparatorItem()
     106  {
     107    MenuInstance->addSeparator();
     108  }
     109
     110  virtual void addSubmenuItem(const std::string &token, const std::string &description)
     111  {
     112    QMenu *Menu = MenuInstance->addMenu(QString(token.c_str()));
     113    QtMenu<QMenu> *NewMenu = new QtMenu<QMenu>(Menu, token);
     114    NewMenu->init();
     115  }
     116
    33117};
    34118
    35 // This handles the plumbing from QT to internal Items
    36 // Slots from QT are redirected to internal methods.
    37 // This way methods can be used where no QT is available
    38 class QtMenuPipe : public QObject {
    39   Q_OBJECT
    40 public:
    41   QtMenuPipe(MenuItem*,QAction*);
    42   virtual ~QtMenuPipe();
    43 public slots:
    44   void called();
    45 private:
    46   MenuItem *theItem;
    47   QAction *theAction;
    48 };
    49 
    50 #endif /* QTMENU_HPP_ */
     119#endif /* MENUINTERFACEQT_HPP_ */

  • src/UIElements/Menu/TextMenu/ActionMenuItem.cpp

    r5813ac rb59da6  
    2222#include <iostream>
    2323
    24 #include "Menu/ActionMenuItem.hpp"
    25 #include "Actions/MethodAction.hpp"
     24#include "Menu/TextMenu/ActionMenuItem.hpp"
     25#include "Actions/Action.hpp"
     26#include "Actions/ActionRegistry.hpp"
    2627
    2728using namespace std;
    2829
    29 ActionMenuItem::ActionMenuItem(char _trigger, const char* _description,Menu* _menu,Action* _action)
     30ActionMenuItem::ActionMenuItem(char _trigger, const std::string &_description,TxMenu* const _menu,const std::string &_ActionName)
    3031: MenuItem(_trigger,_description,_menu),
    31   action(_action)
     32  ActionName(_ActionName)
    3233{
    3334}
    … …  
    3738
    3839void ActionMenuItem::doTrigger() {
     40  Action* action = ActionRegistry::getInstance().getActionByName(ActionName);
    3941  action->call();
    4042}
    4143
    4244bool ActionMenuItem::isActive() {
     45  Action* action = ActionRegistry::getInstance().getActionByName(ActionName);
    4346  return action->isActive();
    4447}

  • src/UIElements/Menu/TextMenu/ActionMenuItem.hpp

    r5813ac rb59da6  
    1111#include <string>
    1212
    13 #include "Menu/MenuItem.hpp"
     13#include "Menu/TextMenu/MenuItem.hpp"
    1414
    1515class Action;
     16class TxMenu;
    1617
    1718/**
    … …  
    2122{
    2223public:
    23   ActionMenuItem(char,const char*,Menu*,Action*);
     24  ActionMenuItem(char,const std::string &,TxMenu* const,const std::string &);
    2425  virtual ~ActionMenuItem();
    2526
    … …  
    2930
    3031private:
    31   Action* action; //!< this action will be called when the trigger matches
     32  const std::string ActionName; //!< this action will be called when the trigger matches
    3233};
    3334

  • src/UIElements/Menu/TextMenu/DisplayMenuItem.cpp

    r5813ac rb59da6  
    2323#include <cmath>
    2424
    25 #include "Menu/DisplayMenuItem.hpp"
     25#include "Menu/TextMenu/DisplayMenuItem.hpp"
    2626#include "Views/StringView.hpp"
    2727
    2828
    29 DisplayMenuItem::DisplayMenuItem(Menu* _menu, StringView *_view):
     29DisplayMenuItem::DisplayMenuItem(TxMenu* const _menu, StringView *_view):
    3030  MenuItem('\0',"",_menu),
    3131  view(_view),
    … …  
    3434}
    3535
    36 DisplayMenuItem::DisplayMenuItem(Menu* _menu, StringView *_view, string _title, char _spacer, int _length ):
     36DisplayMenuItem::DisplayMenuItem(TxMenu* const _menu, StringView *_view, const std::string &_title, char _spacer, int _length ):
    3737  MenuItem('\0',"",_menu),
    3838  view(_view),
    … …  
    5252}
    5353
    54 const string DisplayMenuItem::formatEntry(){
    55   stringstream s;
     54const std::string DisplayMenuItem::formatEntry(){
     55  std::stringstream s;
    5656  if(title.length()>0) {
    5757    int pre = floor((length-title.length())/2.0);
    … …  
    6969
    7070
    71 const string DisplayMenuItem::getDescription(){
    72   return string("");
     71const std::string DisplayMenuItem::getDescription(){
     72  return std::string("");
    7373}

  • src/UIElements/Menu/TextMenu/DisplayMenuItem.hpp

    r5813ac rb59da6  
    99#define DISPLAYMENUITEM_HPP_
    1010
    11 #include "Menu/MenuItem.hpp"
     11#include <string>
     12
     13#include "Menu/TextMenu/MenuItem.hpp"
    1214#include "defs.hpp"
    1315
    1416class StringView;
     17class TxMenu;
    1518
    1619/**
    … …  
    2225{
    2326public:
    24   DisplayMenuItem(Menu* _menu, StringView *_view);
    25   DisplayMenuItem(Menu* _menu, StringView *_view, string _title,
     27  DisplayMenuItem(TxMenu* const _menu, StringView *_view);
     28  DisplayMenuItem(TxMenu* const _menu, StringView *_view, const std::string &_title,
    2629                  char _spacer=STD_MENU_TITLE_SPACER, int _length=STD_MENU_LENGTH);
    2730  virtual ~DisplayMenuItem();
    … …  
    3033  virtual bool checkTrigger(char);
    3134
    32   virtual const string formatEntry();
     35  virtual const std::string formatEntry();
    3336
    34   virtual const string getDescription();
     37  virtual const std::string getDescription();
    3538
    3639private:
    3740  StringView *view;
    38   string title;
     41  std::string title;
    3942  int length;
    4043  char spacer;

  • src/UIElements/Menu/TextMenu/MenuItem.cpp

    r5813ac rb59da6  
    2020#include "Helpers/MemDebug.hpp"
    2121
    22 #include "Menu/MenuItem.hpp"
     22#include "Menu/TextMenu/MenuItem.hpp"
     23#include "Menu/TextMenu/TxMenu.hpp"
    2324#include "Menu/Menu.hpp"
    2425#include <sstream>
    25 #include <iostream>
    2626
    2727/**
    … …  
    2929 * The MenuItem is then added to the menu passed to it.
    3030 */
    31 MenuItem::MenuItem(char _trigger, const char* _description,Menu* menu) :
     31MenuItem::MenuItem(char _trigger, const std::string &_description,TxMenu* const menu) :
    3232  trigger(_trigger),
     33  description(_description),
    3334  added(false)
    3435{
    35   description = new string(_description);
    3636  add_to_menu(menu);
    3737}
    3838
    3939MenuItem::~MenuItem()
    40 {
    41   delete description;
    42 }
     40{}
    4341
    4442/**
    … …  
    5957}
    6058
    61 const string MenuItem::getDescription() {
    62   return *description;
     59const std::string MenuItem::getDescription() {
     60  return description;
    6361}
    6462
    … …  
    6765 * Normal format is: "<trigger> - <description>"
    6866 */
    69 const string MenuItem::formatEntry(){
    70   stringstream s;
     67const std::string MenuItem::formatEntry(){
     68  std::stringstream s;
    7169  s << getTrigger() << " - " << getDescription();
    7270
    … …  
    8078 * TODO: include funtionality to move Items from one menu to another
    8179 */
    82 void MenuItem::add_to_menu(Menu* menu) {
     80void MenuItem::add_to_menu(TxMenu* const menu) {
    8381  if(!wasAdded()) {
    8482    menu->addItem(this);

  • src/UIElements/Menu/TextMenu/MenuItem.hpp

    r5813ac rb59da6  
    1111#include <string>
    1212
    13 using namespace std;
    14 
    15 class Menu;
     13class TxMenu;
    1614
    1715/**
    … …  
    2220class MenuItem {
    2321public:
    24   MenuItem(char,const char*,Menu*);
     22  MenuItem(char,const std::string &,TxMenu* const);
    2523  virtual ~MenuItem();
    2624
    … …  
    2826  virtual bool checkTrigger(char);
    2927
    30   virtual const string formatEntry();
     28  virtual const std::string formatEntry();
    3129
    32   virtual const string getDescription();
     30  virtual const std::string getDescription();
    3331  char getTrigger();
    3432
    35   void add_to_menu(Menu*);
     33  void add_to_menu(TxMenu* const);
    3634  bool wasAdded();
    3735
    3836  virtual bool isActive();
    3937
    40 protected:
    41   void setDescription(string);
    42 
    4338private:
    4439  char trigger;
    45   string *description;
     40  const std::string description;
    4641  bool added;
    4742};

  • src/UIElements/Menu/TextMenu/SeperatorItem.cpp

    r5813ac rb59da6  
    2323#include <sstream>
    2424
    25 #include "Menu/SeperatorItem.hpp"
    26 #include "Menu/Menu.hpp"
     25#include "Menu/TextMenu/SeperatorItem.hpp"
    2726#include "defs.hpp"
    2827
    2928
    30 SeperatorItem::SeperatorItem(Menu* menu):
     29SeperatorItem::SeperatorItem(TxMenu* const menu):
    3130  MenuItem('\0',"",menu),
    3231  spacer(STD_SEPERATOR_SPACER),
    … …  
    3736}
    3837
    39 SeperatorItem::SeperatorItem(Menu* menu,char _spacer, int _length):
     38SeperatorItem::SeperatorItem(TxMenu* const menu,char _spacer, int _length):
    4039  MenuItem('\0',"",menu),
    4140  spacer(_spacer),
    … …  
    5756}
    5857
    59 const string SeperatorItem::getDescription() {
    60   return string("");
     58const std::string SeperatorItem::getDescription() {
     59  return std::string("");
    6160}
    6261
    63 const string SeperatorItem::formatEntry(){
    64   stringstream s;
     62const std::string SeperatorItem::formatEntry(){
     63  std::stringstream s;
    6564  for(int i=0; i<length;i++)
    6665    s << spacer;

  • src/UIElements/Menu/TextMenu/SeperatorItem.hpp

    r5813ac rb59da6  
    99#define SEPERATORITEM_H_
    1010
    11 #include "Menu/MenuItem.hpp"
     11#include <string>
     12
     13#include "Menu/TextMenu/MenuItem.hpp"
     14
     15class TxMenu;
    1216
    1317/**
    … …  
    1923{
    2024public:
    21   SeperatorItem(Menu*);
    22   SeperatorItem(Menu*,char,int);
     25  SeperatorItem(TxMenu* const );
     26  SeperatorItem(TxMenu* const ,char,int);
    2327  virtual ~SeperatorItem();
    2428
    … …  
    2630  virtual bool checkTrigger(char);
    2731
    28   virtual const string getDescription();
     32  virtual const std::string getDescription();
    2933
    30   virtual const string formatEntry();
     34  virtual const std::string formatEntry();
    3135private:
    3236  char spacer;

  • src/UIElements/Menu/TextMenu/SubMenuItem.cpp

    r5813ac rb59da6  
    2020#include "Helpers/MemDebug.hpp"
    2121
    22 #include "SubMenuItem.hpp"
     22#include <iostream>
    2323
    24 SubMenuItem::SubMenuItem(char _trigger,const char* _description,Menu* _parent, Menu* _theMenu) :
     24#include "Menu/TextMenu/SubMenuItem.hpp"
     25#include "Menu/TextMenu/TxMenu.hpp"
     26
     27SubMenuItem::SubMenuItem(char _trigger,const std::string &_description,TxMenu* const _parent, TxMenu* const _instance) :
    2528  MenuItem(_trigger,_description,_parent),
    26   theMenu(_theMenu)
    27 {
    28 }
     29  theMenu(_instance)
     30{}
    2931
    3032SubMenuItem::~SubMenuItem()
    31 {
    32   delete theMenu;
    33 }
     33{}
    3434
    3535void SubMenuItem::doTrigger() {

  • src/UIElements/Menu/TextMenu/TxMenu.cpp

    r5813ac rb59da6  
    77
    88/*
    9  * TextMenu.cpp
     9 * TxMenu.cpp
    1010 *
    1111 *  Created on: Dec 10, 2009
    … …  
    2121
    2222#include <boost/bind.hpp>
     23#include <algorithm>
    2324#include <iostream>
    2425#include <cmath>
    25 #include "Menu/TextMenu.hpp"
    26 #include "Menu/MenuItem.hpp"
     26#include "Actions/Action.hpp"
     27#include "Actions/ActionTraits.hpp"
     28#include "Menu/TextMenu/TxMenu.hpp"
     29#include "Menu/TextMenu/MenuItem.hpp"
    2730#include "Helpers/Assert.hpp"
    2831
    … …  
    3235 * The text will later be displayed using the stream passed to the constructor.
    3336 */
    34 TextMenu::TextMenu(ostream& _outputter, const string _title, char _spacer,int _length) :
     37TxMenu::TxMenu(std::ostream& _outputter, const std::string _title, char _spacer,int _length) :
    3538  defaultItem(0),
    3639  outputter(_outputter),
    … …  
    4245}
    4346
    44 TextMenu::~TextMenu()
     47TxMenu::~TxMenu()
    4548{
    46   for(list<MenuItem*>::iterator it=items.begin(); it != items.end(); it++)
     49  for(std::list<MenuItem*>::iterator it=items.begin(); it != items.end(); it++)
    4750    delete (*it);
    4851}
    4952
    50 
    51 void TextMenu::addItem(MenuItem* item) {
     53void TxMenu::addItem(MenuItem* item) {
    5254  items.push_back(item);
    5355}
    5456
    55 void TextMenu::removeItem(MenuItem* item) {
     57void TxMenu::removeItem(MenuItem* item) {
    5658  items.remove(item);
    5759}
    5860
    59 void TextMenu::doQuit(){
     61void TxMenu::doQuit(){
    6062  quit = true;
    6163}
    6264
    63 bool TextMenu::hasQuit(){
     65bool TxMenu::hasQuit(){
    6466  return quit;
    6567}
    6668
    67 void TextMenu::showEntry(MenuItem* entry){
     69void TxMenu::showEntry(MenuItem* entry){
    6870  if(entry->isActive()==false){
    6971    outputter << "(";
    … …  
    7678}
    7779
    78 void TextMenu::display() {
     80void TxMenu::display() {
    7981  char choice;
    8082  bool somethingChosen = false;
    … …  
    8991          outputter << spacer;
    9092    outputter << '\n';
    91     for_each(items.begin(), items.end(), boost::bind(&TextMenu::showEntry,this,_1));
     93    for_each(items.begin(), items.end(), boost::bind(&TxMenu::showEntry,this,_1));
    9294    outputter.flush();
    9395
    94     cin >> choice;
     96    std::cin >> choice;
    9597
    96     list<MenuItem*>::iterator iter;
     98    std::list<MenuItem*>::iterator iter;
    9799    for(iter = items.begin(); iter!=items.end();iter++){
    98100      if((*iter)->isActive()){
    … …  
    106108      }
    107109      else{
    108         outputter << "Invalid Choice!" <<  endl;
     110        outputter << "Invalid Choice!" <<  std::endl;
    109111      }
    110112    }
    … …  
    112114}
    113115
    114 string TextMenu::getTitle(){
     116std::string TxMenu::getTitle(){
    115117  return title;
    116118}
    117119
    118 void TextMenu::addDefault(MenuItem* _defaultItem) {
     120std::ostream& TxMenu::getOutputter()
     121{
     122  return outputter;
     123}
     124
     125
     126void TxMenu::addDefault(MenuItem* _defaultItem) {
    119127  defaultItem = _defaultItem;
    120128}
    … …  
    122130/****************************** Contained Actions ****************/
    123131
    124 TextMenu::LeaveAction::LeaveAction(TextMenu* _menu, const ActionTraits & LeaveActionTrait) :
    125   Action(LeaveActionTrait, false),
     132TxMenu::LeaveAction::LeaveAction(TxMenu* const _menu, const ActionTraits & LeaveActionTrait) :
     133  Action(LeaveActionTrait, true),
    126134  menu(_menu)
    127135{}
    128136
    129 TextMenu::LeaveAction::~LeaveAction(){}
     137TxMenu::LeaveAction::~LeaveAction(){}
    130138
    131 bool TextMenu::LeaveAction::canUndo(){
     139bool TxMenu::LeaveAction::canUndo(){
    132140  return false;
    133141}
    134142
    135 bool TextMenu::LeaveAction::shouldUndo(){
     143bool TxMenu::LeaveAction::shouldUndo(){
    136144  return false;
    137145}
    138146
    139 void TextMenu::LeaveAction::getParametersfromValueStorage()
     147void TxMenu::LeaveAction::getParametersfromValueStorage()
    140148{}
    141149
    142 Dialog* TextMenu::LeaveAction::fillDialog(Dialog *dialog){
     150Dialog* TxMenu::LeaveAction::fillDialog(Dialog *dialog){
    143151  ASSERT(dialog,"No Dialog given when filling action dialog");
    144152  return dialog;
    … …  
    146154
    147155
    148 Action::state_ptr TextMenu::LeaveAction::performCall(){
     156Action::state_ptr TxMenu::LeaveAction::performCall(){
    149157  menu->doQuit();
    150158  return Action::success;
    … …  
    152160
    153161
    154 Action::state_ptr TextMenu::LeaveAction::performUndo(Action::state_ptr){
     162Action::state_ptr TxMenu::LeaveAction::performUndo(Action::state_ptr){
    155163  ASSERT(0,"Cannot undo leaving a menu");
    156164  return Action::success;
    157165}
    158166
    159 Action::state_ptr TextMenu::LeaveAction::performRedo(Action::state_ptr){
     167Action::state_ptr TxMenu::LeaveAction::performRedo(Action::state_ptr){
    160168  ASSERT(0,"Cannot redo leaving a menu");
    161169  return Action::success;

  • src/UIElements/Menu/TextMenu/TxMenu.hpp

    r5813ac rb59da6  
    11/*
    2  * TextMenu.h
     2 * TxMenu.h
    33 *
    44 *  Created on: Dec 10, 2009
    … …  
    66 */
    77
    8 #ifndef TEXTMENU_H_
    9 #define TEXTMENU_H_
     8#ifndef TXMENU_H_
     9#define TXMENU_H_
    1010
    1111#include <list>
    … …  
    2525 * All Items are displayed and user is prompted for a key. The item corresponding to that key is then activated.
    2626 */
    27 class TextMenu : public Menu
     27class TxMenu
    2828{
    2929public:
    3030  class LeaveAction : public Action {
    3131  public:
    32     LeaveAction(TextMenu*, const ActionTraits &_trait);
     32    LeaveAction(TxMenu* const, const ActionTraits &_trait);
    3333    virtual ~LeaveAction();
    3434
    … …  
    4444    virtual Action::state_ptr performRedo(Action::state_ptr);
    4545
    46     ActionTraits *LeaveActionTrait;
    47     TextMenu* menu;
     46    TxMenu* const menu;
    4847  };
    4948
    50   TextMenu(ostream& _outputter, const string _title, char _spacer=STD_MENU_TITLE_SPACER,int _length=STD_MENU_LENGTH);
    51   virtual ~TextMenu();
     49  TxMenu(std::ostream& _outputter, const std::string _title, char _spacer=STD_MENU_TITLE_SPACER,int _length=STD_MENU_LENGTH);
     50  virtual ~TxMenu();
    5251
    53   virtual void addItem(MenuItem*);
    54   virtual void removeItem(MenuItem*);
    55   virtual void display();
    56   virtual string getTitle();
     52  void addItem(MenuItem*);
     53  void removeItem(MenuItem*);
     54  void display();
     55  std::string getTitle();
     56  std::ostream& getOutputter();
     57  char getSuitableShortForm(std::set <char> &ShortcutList, const std::string name) const;
    5758
    5859  /**
    5960   * Call doQuit if you want to return from this menu.
    6061   */
    61   virtual void doQuit();
     62  void doQuit();
    6263  /**
    6364   * Check whether someone has chosen to quit
    6465   */
    65   virtual bool hasQuit();
     66  bool hasQuit();
    6667
    67   virtual void addDefault(MenuItem*);
     68  void addDefault(MenuItem*);
    6869
    6970protected:
    70   virtual void showEntry(MenuItem*);
     71  void showEntry(MenuItem*);
    7172
    7273private:
    73   list<MenuItem*> items;
     74  std::list<MenuItem*> items;
    7475
    7576  MenuItem* defaultItem;
    7677
    77   ostream& outputter;
    78   string title;
     78  std::ostream& outputter;
     79  std::string title;
    7980  char spacer;
    8081  int length;
    … …  
    8384};
    8485
    85 #endif /* TEXTMENU_H_ */
     86#endif /* TXMENU_H_ */

  • src/UIElements/Qt4/QtMainWindow.cpp

    r5813ac rb59da6  
    3939#include "Actions/ActionRegistry.hpp"
    4040#include "Actions/ValueStorage.hpp"
    41 #include "Menu/MenuDescription.hpp"
    42 #include "Menu/Menu.hpp"
    4341#include "Menu/Qt4/QtMenu.hpp"
    44 #include "Menu/ActionMenuItem.hpp"
    45 #include "Menu/SubMenuItem.hpp"
    4642#include "Views/Qt4/QtWorldView.hpp"
    4743#include "Views/Qt4/GLMoleculeView.hpp"
    … …  
    6056  molecule3dDisplay = new GLMoleculeView();
    6157
    62   MenuBar = menuBar();
    63 
    64   // populate menus and add actions
    65   {
    66     QtMenuReferenceMap NametoTextMenuMap; // contains token to menu reference map
    67     MenuShortcutMap ShortcutMap;
    68     populateMenu(NametoTextMenuMap, ShortcutMap);
    69     populateMenuWithActions(NametoTextMenuMap, ShortcutMap);
    70   }
     58  MainMenu = new QtMenu<QMenuBar>(menuBar(), "");
     59  MainMenu->init();
    7160
    7261  setCentralWidget(splitter1);
    … …  
    9382}
    9483
    95 /** Puts Qt's token, the ampersand, in front of the accelerator char in the menu name.
    96  * \param ShortcutMap map to all already present accelerator keys
    97  * \param MenuName Action of menu
    98  * \param ActionName Action of menu
    99  * \return name with ampersand added at the right place
    100  */
    101 std::string QtMainWindow::getNameWithAccelerator(MenuShortcutMap &ShortcutMap, const std::string &MenuName, const std::string &ActionName) const
    102 {
    103   std::string newname;
    104   bool Inserted = false;
    105   std::pair < MenuShortcutMap::iterator, bool > Inserter;
    106   for (std::string::const_iterator CharRunner = ActionName.begin(); CharRunner != ActionName.end(); ++CharRunner) {
    107     if (!Inserted) {
    108       Inserter = ShortcutMap.insert( std::pair<std::string, char> (MenuName, *CharRunner) );
    109       if (Inserter.second) {
    110         newname += '&';
    111         Inserted = true;
    112       }
    113     }
    114     newname += *CharRunner;
    115   }
    116   return newname;
    117 }
    118 
    119 /** Instantiate all menus.
    120  * \param NametoTextMenuMap lookup for token to menu reference
    121  */
    122 void QtMainWindow::populateMenu(QtMenuReferenceMap &NametoTextMenuMap, MenuShortcutMap &ShortcutMap)
    123 {
    124   // go through all menus and create them
    125   std::map <std::string, int> TopPositions;
    126   TopPositions.insert( std::pair<std::string, int> ("", 0) ); // contains which position was added last
    127   QtMenu *Menu = NULL;
    128   MenuDescription menudescriptions;
    129   std::set <char> ShortcutList;
    130   bool CompleteFlag = false;
    131   while (!CompleteFlag) {
    132     CompleteFlag = true;
    133     for(MenuDescription::const_iterator iter = menudescriptions.getBeginIter(); iter != menudescriptions.getEndIter(); ++iter) {
    134       // skip when already present
    135       if (NametoTextMenuMap.find(iter->first) == NametoTextMenuMap.end()) {
    136         // have some short refs to infos
    137         const std::string &MenuName = iter->first;
    138         const std::string &TopName = iter->second.first;
    139         const int &MenuPosition = iter->second.second;
    140         std::cout << "MenuName is " << MenuName << ", TopName is " << TopName << " and Position is " << MenuPosition << std::endl;
    141 
    142         // is it top level?
    143         if (TopName == "") {
    144           ASSERT(TopPositions.find(TopName) != TopPositions.end(),
    145               "QtMainWindow::QtMainWindow() - "+TopName+" not present in TopPositions.");
    146           if (MenuPosition-1 == TopPositions[TopName]) {
    147             std::cout << "Creating top-level menu " << MenuName << " at position " << MenuPosition << std::endl;
    148             Menu = new QtMenu(getNameWithAccelerator(ShortcutMap, TopName, MenuName).c_str());
    149             MenuBar->addMenu(Menu);
    150             NametoTextMenuMap.insert( pair <std::string, QtMenu *> (MenuName, Menu) );
    151             CompleteFlag = false;
    152             TopPositions[TopName] = MenuPosition;
    153             TopPositions[MenuName] = 0;
    154           }
    155         }
    156         // is it a submenu and the top-level menu is present?
    157         else if (NametoTextMenuMap.find(TopName) != NametoTextMenuMap.end()) {
    158           ASSERT(TopPositions.find(TopName) != TopPositions.end(),
    159               "QtMainWindow::QtMainWindow() - "+TopName+" not present in TopPositions.");
    160           if (MenuPosition-1 == TopPositions[TopName]) {
    161             QtMenu *& TopMenu = NametoTextMenuMap[TopName];
    162             std::cout << "Creating submenu " << MenuName << " to menu " << TopName << " at position " << MenuPosition << std::endl;
    163             Menu = new QtMenu(getNameWithAccelerator(ShortcutMap, TopName, MenuName).c_str());
    164             TopMenu->addMenu(Menu);
    165             NametoTextMenuMap.insert( pair <std::string, QtMenu *> (MenuName, Menu) );
    166             CompleteFlag = false;
    167             TopPositions[TopName] = MenuPosition;
    168           }
    169         }
    170       }
    171     }
    172   }
    173 }
    174 
    175 /** Instantiate all actions within the menus.
    176  * \param NametoTextMenuMap lookup for token to menu reference
    177  * \param ShortcutMap map for all shortcuts within one menu
    178  */
    179 void QtMainWindow::populateMenuWithActions(QtMenuReferenceMap &NametoTextMenuMap, MenuShortcutMap &ShortcutMap)
    180 {
    181   typedef std::multimap <std::string, std::string> MenuMap;
    182 
    183   // go through all menus
    184   MenuDescription md;
    185   MenuMap MenuItems = md.getMenuItemsMap();
    186   QtMenu *Menu = NULL;
    187   Action *ActionItem = NULL;
    188   std::string OldMenuName;
    189   for (MenuMap::const_iterator MenuRunner = MenuItems.begin(); MenuRunner != MenuItems.end(); ++MenuRunner) {
    190     const std::string &ActionName = MenuRunner->second;
    191     const std::string &MenuName = MenuRunner->first;
    192     // add the actions to this menu
    193     std::cout << " Adding " << ActionName << " to submenu " << MenuName << std::endl;
    194     ActionItem = ActionRegistry::getInstance().getActionByName(ActionName);
    195     ASSERT(NametoTextMenuMap.find(MenuName) != NametoTextMenuMap.end(),
    196         "QtMainWindow::populateMenu() - cannot find reference for menu "+MenuName+" in NametoTextMenuMap.");
    197     Menu = NametoTextMenuMap[MenuName];
    198     //ASSERT(ShortcutMap.find(MenuName) != ShortcutMap.end(),
    199       //  "QtMainWindow::populateMenuWithActions() - missing "+MenuName+" in ShortcutMap.");
    200     new ActionMenuItem(
    201         'a',
    202         ActionItem->Traits.getDescription().c_str(),
    203         Menu,
    204         ActionItem);
    205   }
    206 }

  • src/UIElements/Qt4/QtMainWindow.hpp

    r5813ac rb59da6  
    1515#include <set>
    1616
     17#include "Menu/Qt4/QtMenu.hpp"
     18
    1719class QtWorldView;
    1820class StringView;
    19 class QtMenu;
    2021class GLMoleculeView;
    2122class QtMoleculeView;
    … …  
    3435
    3536private:
    36   typedef std::map <std::string, QtMenu *> QtMenuReferenceMap;
    37   typedef std::map <std::string, char> MenuShortcutMap;
    38 
    39   void populateMenu(QtMenuReferenceMap &NametoTextMenuMap, MenuShortcutMap &ShortcutMap);
    40   void populateMenuWithActions(QtMenuReferenceMap &NametoTextMenuMap, MenuShortcutMap &ShortcutMap);
    41   std::string getNameWithAccelerator(MenuShortcutMap &ShortcutMap, const std::string &MenuName, const std::string &ActionName) const;
    42 
    4337  // All kinds of QTStuff used in this window
    4438  QApplication *theApp;
    … …  
    4741  QtMoleculeView *moleculeDisplay;
    4842  QtStatusBar *statusBar;
    49   QMenuBar *MenuBar;
     43  QtMenu<QMenuBar> *MainMenu;
    5044
    5145};

  • src/UIElements/TextUI/TextWindow.cpp

    r5813ac rb59da6  
    2323#include <boost/shared_ptr.hpp>
    2424
    25 #include "Menu/Menu.hpp"
    26 #include "Menu/MenuDescription.hpp"
    27 #include "Menu/TextMenu.hpp"
    28 #include "Menu/ActionMenuItem.hpp"
    29 #include "Menu/SeperatorItem.hpp"
    30 #include "Menu/DisplayMenuItem.hpp"
    31 #include "Menu/SubMenuItem.hpp"
     25#include "Menu/TextMenu/TextMenu.hpp"
     26#include "Menu/TextMenu/TxMenu.hpp"
     27#include "Menu/TextMenu/ActionMenuItem.hpp"
     28#include "Menu/TextMenu/SeperatorItem.hpp"
     29#include "Menu/TextMenu/DisplayMenuItem.hpp"
     30#include "Menu/TextMenu/SubMenuItem.hpp"
    3231#include "TextUI/TextStatusIndicator.hpp"
    3332#include "TextUI/TextWindow.hpp"
    … …  
    5756TextWindow::TextWindow()
    5857{
    59   map <std::string, TextMenu *> NametoTextMenuMap;
    60   std::set <char> ShortcutList;
     58  // build the main menu
     59  main_menu = new TextMenu<TxMenu>(std::cout, "");
    6160  // reserve s for save and q for quite
    62   ShortcutList.insert('s');
    63   ShortcutList.insert('q');
    64 
    65   // build the main menu
    66   main_menu = new TextMenu(Log() << Verbose(0), "Main Menu");
     61  main_menu->reserveShortcut('s', "output");
     62  main_menu->reserveShortcut('q', "quit");
    6763
    6864  moleculeView = new StreamStringView(boost::bind(&MoleculeListClass::Enumerate,World::getInstance().getMolecules(),_1));
    69   new DisplayMenuItem(main_menu,moleculeView,"Molecule List");
     65  new DisplayMenuItem(main_menu->getMenuInstance(),moleculeView,"Molecule List");
    7066
    71   new SeperatorItem(main_menu);
     67  new SeperatorItem(main_menu->getMenuInstance());
    7268
    73   Action* undoAction = ActionRegistry::getInstance().getActionByName("undo");
    74   new ActionMenuItem(getSuitableShortForm(ShortcutList,"Undo last operation"),"Undo last operation",main_menu,undoAction);
     69  main_menu->init();
    7570
    76   Action* redoAction = ActionRegistry::getInstance().getActionByName("redo");
    77   new ActionMenuItem(getSuitableShortForm(ShortcutList,"Redo last operation"),"Redo last operation",main_menu,redoAction);
    78 
    79   new SeperatorItem(main_menu);
    80 
    81   MenuDescription menudescriptions;
    82   for(MenuDescription::const_iterator iter = menudescriptions.getBeginIter(); iter != menudescriptions.getEndIter(); ++iter) {
    83     const std::string &MenuName = iter->first;
    84     TextMenu *Menu = new TextMenu((ostream &)std::cout, menudescriptions.getDescription(MenuName));
    85     NametoTextMenuMap.insert( pair <std::string, TextMenu *> (MenuName, Menu) );
    86     new SubMenuItem(getSuitableShortForm(ShortcutList,MenuName),menudescriptions.getDescription(MenuName).c_str(),main_menu,Menu);
    87   }
    88 
    89   new SeperatorItem(main_menu);
     71  new SeperatorItem(main_menu->getMenuInstance());
    9072
    9173  // save has reserved key 's'
    92   Action *saveConfigAction = ActionRegistry::getInstance().getActionByName("output");
    93   new ActionMenuItem('s',"save current setup to config files",main_menu,saveConfigAction);
     74//  Action *saveConfigAction = ActionRegistry::getInstance().getActionByName("output");
     75  new ActionMenuItem('s',"save current setup to config files",main_menu->getMenuInstance(),"output");
    9476
    95   ActionTraits quitTrait(OptionTrait("quitAction", &typeid(void), "quits the program"));
    96   quitAction = new MethodAction(quitTrait,boost::bind(&TextMenu::doQuit,main_menu),false);
    97   new ActionMenuItem('q',"quit",main_menu,quitAction);
    98 
    99   // quit has reserved key 'q'
    100   // go through all menus and create them
    101   for (map <std::string, TextMenu *>::iterator MenuRunner = NametoTextMenuMap.begin(); MenuRunner != NametoTextMenuMap.end(); ++MenuRunner)
    102     populateMenu(MenuRunner->second, MenuRunner->first);
     77  // create a specific quit action for this UI and store in registry
     78  ActionTraits quitTrait(OptionTrait("quit", &typeid(void), "quits the program"));
     79  quitAction = new MethodAction(quitTrait,boost::bind(&TxMenu::doQuit,main_menu->getMenuInstance()),true);
     80  new ActionMenuItem('q',"quit",main_menu->getMenuInstance(),"quit");
    10381
    10482  // Add status indicators etc...
    105 
    10683  statusIndicator = new TextStatusIndicator();
    10784}
    … …  
    12299}
    123100
    124 char TextWindow::getSuitableShortForm(std::set <char> &ShortcutList, const std::string name) const
    125 {
    126   for (std::string::const_iterator CharRunner = name.begin(); CharRunner != name.end(); ++CharRunner) {
    127     if (ShortcutList.find(*CharRunner) == ShortcutList.end()) {
    128       ShortcutList.insert(*CharRunner);
    129       return *CharRunner;
    130     }
    131   }
    132   // if no letter matches, take digits
    133   int i=0;
    134   for (;i<10;++i) {
    135     if (ShortcutList.find((char)i + '0') == ShortcutList.end())
    136       break;
    137   }
    138   if (i != 10) {
    139     ShortcutList.insert((char)i + '0');
    140     return ((char)i + '0');
    141   } else {
    142     DoeLog(1) && (eLog() << Verbose(1) << "Could not find a suitable shortform for " << name << "." << endl);
    143     return '#';
    144   }
    145 }
    146 
    147 void TextWindow::populateMenu(TextMenu* Menu, const  std::string &MenuName)
    148 {
    149   Action *ActionItem = NULL;
    150   set <char> ShortcutList;
    151   // reserve 'q' for quit
    152   ShortcutList.insert('q');
    153   // through all actions for this menu
    154   MenuDescription md;
    155   std::multimap <std::string, std::string> MenuItems = md.getMenuItemsMap();
    156   std::pair < std::multimap <std::string, std::string>::iterator, std::multimap <std::string, std::string>::iterator > MenuActions = MenuItems.equal_range(MenuName);
    157   for (std::multimap <std::string, std::string>::const_iterator MenuRunner = MenuActions.first; MenuRunner != MenuActions.second; ++MenuRunner) {
    158     ActionItem = ActionRegistry::getInstance().getActionByName(MenuRunner->second);
    159     new ActionMenuItem(getSuitableShortForm(ShortcutList, MenuRunner->second),ActionItem->Traits.getDescription().c_str(),Menu,ActionItem);
    160   }
    161   // finally add default quit item
    162   ActionTraits LeaveActionTraits("Leave menu: "+Menu->getTitle());
    163   Action *returnFromAction = new TextMenu::LeaveAction(Menu, LeaveActionTraits);
    164   //returnFromActions.push_back(returnFromAction);
    165   MenuItem *returnFromItem = new ActionMenuItem('q',"return to Main menu",Menu,returnFromAction);
    166   Menu->addDefault(returnFromItem);
    167 }

  • src/UIElements/TextUI/TextWindow.hpp

    r5813ac rb59da6  
    1414#include <set>
    1515
    16 class TextMenu;
     16#include "Menu/TextMenu/TextMenu.hpp"
     17
    1718class Action;
    1819class StringView;
    1920class TextStatusIndicator;
     21class TxMenu;
    2022
    2123
    … …  
    2931
    3032private:
    31   // populaters
    32   char getSuitableShortForm(std::set <char> &ShortcutList, const std::string name) const;
    33   void populateMenu(TextMenu* Menu, const std::string &name);
    34 
    35   TextMenu *main_menu;
     33  TextMenu<TxMenu> *main_menu;
    3634
    3735  // some actions only needed in textMenus

  • src/builder.cpp

    r5813ac rb59da6  
    9090#include "UIElements/MainWindow.hpp"
    9191#include "UIElements/Dialog.hpp"
    92 #include "Menu/ActionMenuItem.hpp"
     92//#include "Menu/ActionMenuItem.hpp"
    9393#include "Helpers/Verbose.hpp"
    9494#include "World.hpp"
Note: See TracChangeset for help on using the changeset viewer.