Context Navigation

-              rf82ac4e
+              ref81b0
 Action::Action()
+{
+  // TODO Auto-generated constructor stub
+}
+{}
 Action::~Action()
+{
+  // TODO Auto-generated destructor stub
+}
+{}

src/Actions/Action.hpp

-              rf82ac4e
+              ref81b0
 #define ACTION_H_
+/**
+ * Base class for all actions.
+ *
+ * Actions describe something that has to be done.
+ * Actions can be passed around, stored, performed and undone (Command-Pattern).
+ *
+ * TODO: Add queues of actions that have been performed to allow easy implementation of multiple-step undo
+ */
 class Action
+{

-              rf82ac4e
+              ref81b0
 #include "Actions/Action.hpp"
+/**
+ * Wrapper class that allows the construction of Actions from any kind of Method
+ */
 class MethodAction : public Action
+{
 …
   virtual bool canUndo();
   boost::function<void()> executeMethod;
+  boost::function<void()> executeMethod; //!< this stores the method to be called

-              rf82ac4e
+              ref81b0
 class Action;
+/**
+ * Produce MenuItems that take an appropriate action when called.
+ */
 class ActionMenuItem : public MenuItem
+{
 …
 private:
   Action* action;
+  Action* action; //!< this action will be called when the trigger matches
 };

-              rf82ac4e
+              ref81b0
 class StringView;
+/**
+ * Display any kind of StringView within a Menu
+ *
+ * Any trigger are ignored for this type of Item
+ */
 class DisplayMenuItem : public MenuItem
+{

-              rf82ac4e
+              ref81b0
 class MenuItem;
+/**
+ * Base class for all Types of menus
+ * contains basic abstract functionality to add Items, remove Items and display the menu
+ *
+ * TODO: Make sure all items are only added once.
+ */
 class Menu
+{
 …
   virtual ~Menu();
+  /**
+   * Adding and removing should be handled by the items.
+   */
   virtual void addItem(MenuItem*)=0;
+  /**
+   * Adding and removing should be handled by the items.
+   */
   virtual void removeItem(MenuItem*)=0;
   virtual void display()=0;

-              rf82ac4e
+              ref81b0
 #include <iostream>
+/**
+ * produce a new MenuItem using with a description and a trigger.
+ * The MenuItem is then added to the menu passed to it.
+ */
 MenuItem::MenuItem(char _trigger, const char* _description,Menu* menu) :
 trigger(_trigger),
 …
+}
+/**
+ * check if the trigger matches and call doTrigger if it does.
+ */
 void MenuItem::checkTrigger(char key) {
   if(key == trigger)
 …
+}
+/**
+ * Produce a formated output of this item containing trigger and description
+ * Normal format is: "<trigger> - <description>"
+ */
 const string MenuItem::formatEntry(){
   stringstream s;
 …
+}
+/**
+ * check if this item is within a menu and add to menu if it is not yet contained anywhere
+ *
+ * TODO: include funtionality to move Items from one menu to another
+ */
 void MenuItem::add_to_menu(Menu* menu) {
   if(!wasAdded()) {

-              rf82ac4e
+              ref81b0
 class Menu;
+/**
+ * Base class for all kinds of MenuItems
+ *
+ * This class takes care of checking the triggers and performing appropriate actions.
+ */
 class MenuItem {
 private:

-              rf82ac4e
+              ref81b0
 #include "Menu/MenuItem.hpp"
+/**
+ * Produce a Seperator within a Menu.
+ *
+ * All triggers are ignored for this Item.
+ */
 class SeperatorItem : public MenuItem
+{

-              rf82ac4e
+              ref81b0
 #include <iostream>
 #include <cmath>
-#include "defs.hpp"
 #include "Menu/TextMenu.hpp"
 #include "Menu/MenuItem.hpp"
+/**
+ * produce a text menu with a given title.
+ * The text will later be displayed using the stream passed to the constructor.
+ */
 TextMenu::TextMenu(ostream& _outputter, string _title, char _spacer,int _length) :
 outputter(_outputter),
 …
 spacer(_spacer),
 length(_length),
-quit(false)
+{
+}
-TextMenu::TextMenu(ostream& _outputter, string _title) :
-outputter(_outputter),
-title(_title),
-spacer(STD_MENU_TITLE_SPACER),
-length(STD_MENU_LENGTH),
 quit(false)
+{

-              rf82ac4e
+              ref81b0
 #include "Menu/Menu.hpp"
+#include "defs.hpp"
 class MenuItem;
+/**
+ * Used to produce any kind of text menu
+ *
+ * All Items are displayed and user is prompted for a key. The item corresponding to that key is then activated.
+ */
 class TextMenu : public Menu
+{
 public:
+  TextMenu(ostream&,string,char,int);
+  TextMenu(ostream&,string);
+  TextMenu(ostream& _outputter, string _title, char _spacer=STD_MENU_TITLE_SPACER,int _length=STD_MENU_LENGTH);
   virtual ~TextMenu();
 …
   virtual void display();
+  /**
+   * Call doQuit if you want to return from this menu.
+   */
   virtual void doQuit();
+  /**
+   * Check wether someone has chosen to quit
+   */
   virtual bool hasQuit();

-              rf82ac4e
+              ref81b0
 #include "Views/StringView.hpp"
+/**
+ * Wrapper to produce a StringView from any method that returns a String.
+ */
 class MethodStringView : public StringView
+{

-              rf82ac4e
+              ref81b0
 #include "Views/StringView.hpp"
+/**
+ * Wrapper to produce a StringView from any method that uses a stream to display something.
+ *
+ * The function is called with a stringstream which then is turned into a string later.
+ *
+ * Caveat: Make sure the stream passed to the method is actually used. Some methods seem to use a stream parameter for
+ * legacy reasons. These methods internally use the "Log() << Verbose()" mechanism instead of the stream.
+ */
 class StreamStringView : public StringView
+{

-              rf82ac4e
+              ref81b0
 using namespace std;
+/**
+ * View to show something as a string
+ *
+ * This View is used by calling the toString method.
+ * This View does *not* use the observer pattern.
+ */
 class StringView : public View
+{

-              rf82ac4e
+              ref81b0
 #define VIEW_H_
+/**
+ * Base class for all Views
+ *
+ * TODO: is this really needed or helpfull at all?
+ */
 class View
+{

Note: See TracChangeset for help on using the changeset viewer.