Changeset b59da6 for src/UIElements/Menu


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/UIElements/Menu
Files:
6 added
2 deleted
5 edited
11 moved

Legend:

Unmodified
Added
Removed

  • 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_ */
Note: See TracChangeset for help on using the changeset viewer.