Changeset 8448 for code/branches/tutoriallevel2/src

Timestamp:

May 11, 2011, 10:45:56 PM (14 years ago)

Author:

dafrick

Message:

Extending NotificationQueueCEGUI.

Location:

code/branches/tutoriallevel2/src

Files:

• modules/notifications/Notification.cc (modified) (1 diff)
• modules/notifications/NotificationManager.cc (modified) (8 diffs)
• modules/notifications/NotificationManager.h (modified) (3 diffs)
• modules/notifications/NotificationQueue.cc (modified) (2 diffs)
• modules/notifications/NotificationQueue.h (modified) (2 diffs)
• modules/notifications/NotificationQueueCEGUI.cc (modified) (7 diffs)
• modules/notifications/NotificationQueueCEGUI.h (modified) (4 diffs)
• orxonox/interfaces/NotificationListener.cc (modified) (4 diffs)
• orxonox/interfaces/NotificationListener.h (modified) (3 diffs)

code/branches/tutoriallevel2/src/modules/notifications/Notification.cc

@@ -47 +47 @@
     @param sender
         The sender of the Notification.
+    @param type
+        The type of the Notification.
     */
     Notification::Notification(const std::string& message, const std::string& sender, notificationMessageType::Value type)

code/branches/tutoriallevel2/src/modules/notifications/NotificationManager.cc

@@ -36 +36 @@
 #include "core/command/ConsoleCommand.h"
 #include "core/CoreIncludes.h"
-#include "core/GameMode.h"
-#include "core/GUIManager.h"
 #include "core/LuaState.h"
-#include "util/Convert.h"
 #include "util/ScopedSingletonManager.h"
 
@@ -48 +45 @@
 #include "NotificationQueueCEGUI.h"
 
-#include "ToluaBindNotifications.h"
-
 namespace orxonox
 {
-
-    // Register tolua_open function when loading the library.
-    DeclareToluaInterface(Notifications);
 
     ManageScopedSingleton(NotificationManager, ScopeID::Root, false);
@@ -108 +100 @@
     @param sender
         The name of the entity (of the collective) that sent the new Notification.
+    @param type
+        The type of the new Notification.
     @return
         Returns true if successful.
@@ -126 +120 @@
     @param sender
         The The name of the entity (of the collective) that sent the command.
+    @return
+        Returns true if the command was successfully executed.
     */
     bool NotificationManager::executeCommand(notificationCommand::Value command, const std::string& sender)
     {
+        bool commandExecuted = false;
         if(command == notificationCommand::clear)
         {
-            this->commandClear(sender);
-            return true;
-        }
-
-        return false;
+            if(this->commandClear(sender))
+                commandExecuted = true;
+        }
+
+        if(commandExecuted)
+            COUT(3) << "Notification command \"" << NotificationListener::command2Str(command) << "\" executed." << endl;
+
+        return commandExecuted;
     }
 
@@ -143 +143 @@
     @param sender
         The sender of the clear command.
-    */
-    void NotificationManager::commandClear(const std::string& sender)
+    @return
+        Returns true if the command was successfully executed by at least one NotificationQueue, false if it was not executed.
+    */
+    bool NotificationManager::commandClear(const std::string& sender)
     {
         bool all = (sender == NotificationListener::ALL);
+        bool executed = false;
         // Clear all NotificationQueues that have the input sender as target.
         for(std::map<const std::string, NotificationQueue*>::iterator it = this->queues_.begin(); it != this->queues_.end(); it++) // Iterate through all NotificationQueues.
@@ -153 +156 @@
             // If either the sender is 'all', the NotificationQueue has as target all or the NotificationQueue has the input sender as a target.
             if(all || set.find(NotificationListener::ALL) != set.end() || set.find(sender) != set.end())
-                it->second->tidy();
-        }
+                executed = it->second->tidy() || executed;
+        }
+
+        return executed;
     }
     
@@ -385 +390 @@
     /**
     @brief
-        Loads all the NotificationQueues that should exist.
-    */
-    void NotificationManager::loadQueues(void)
-    {
-        NotificationQueue* allQueue = new NotificationQueueCEGUI("all");
-        GUIManager::getInstance().getLuaState()->doString("NotificationLayer.resizeQueue(\"all\", 0.5, 0, " + multi_cast<std::string>(allQueue->getMaxSize()) + ")");
-        GUIManager::getInstance().getLuaState()->doString("NotificationLayer.moveQueue(\"all\", 0, 10, 0.3, 0)");
-
-        NotificationQueue* infoQueue = new NotificationQueueCEGUI("info", NotificationListener::ALL, 1, -1);
-        GUIManager::getInstance().getLuaState()->doString("NotificationLayer.changeQueueFont(\"info\", 24, \"CCFFFF00\")");
-        GUIManager::getInstance().getLuaState()->doString("NotificationLayer.resizeQueue(\"info\", 0.6, 0, " + multi_cast<std::string>(infoQueue->getMaxSize()) + ")");
-        GUIManager::getInstance().getLuaState()->doString("NotificationLayer.moveQueue(\"info\", 0.2, 0, 0.8, 0)");
-        GUIManager::getInstance().getLuaState()->doString("NotificationLayer.changeQueueAlignment(\"info\", \"HorzCentred\")");
-    }
-
-    /**
-    @brief
-        Creates a new NotificationQueue.
-        This is used in lua.
-    @param name
-        The name of the new NotificationQueue.
-    */
-    void NotificationManager::createQueue(const std::string& name)
-    {
-        new NotificationQueue(name);
-    }
-
-    /**
-    @brief
         Get the NotificationQueue with the input name.
     @param name
@@ -430 +406 @@
     }
 
+    /**
+    @brief
+        Loads all the NotificationQueues that should exist.
+    */
+    void NotificationManager::loadQueues(void)
+    {
+        NotificationQueueCEGUI* allQueue = new NotificationQueueCEGUI("all");
+        allQueue->setDisplaySize(Vector2(0.5, 0));
+        allQueue->setPosition(Vector4(0.0, 10, 0.3, 0));
+
+        NotificationQueueCEGUI* infoQueue = new NotificationQueueCEGUI("info", NotificationListener::ALL, 1, -1);
+        infoQueue->setPosition(Vector4(0.2, 0, 0.8, 0));
+        infoQueue->setFontSize(24);
+        infoQueue->setFontColor(Vector4(1.0, 1.0, 0.0, 0.8));
+        infoQueue->setAlignment("HorzCentred");
+        infoQueue->setDisplaySize(Vector2(0.6, 0.0));
+    }
+
 }

code/branches/tutoriallevel2/src/modules/notifications/NotificationManager.h

@@ -50 +50 @@
     /**
     @brief
-        The Singleton NotificationManager is a NotificationListener and functions as a gateway between @ref orxonox::Notification "Notifications" and @ref orxonox::NotificationQueues "NotificationQueues".
-        It receives, organizes @ref orxonox::Notification "Notifications" and the redistributes them to the specific @ref orxonox::NotificationLQueue "NotificationQueues".
+        The Singleton NotificationManager is a NotificationListener and functions as a gateway between @ref orxonox::Notification "Notifications" and @ref orxonox::NotificationQueue "NotificationQueues".
+        It receives, organizes @ref orxonox::Notification "Notifications" and the redistributes them to the specific @ref orxonox::NotificationQueue "NotificationQueues".
         It also works as a liaison between the @ref orxonox::NotificationQueue "NotificationQueues" and the GUI that displays notification, called NotificationLayer.
 
@@ -98 +98 @@
             void unregisterQueue(NotificationQueue* queue); // Unregisters a NotificationQueue.
 
-            // tolua_begin
-            void loadQueues(void); // Loads all the NotificationQueues that should exist.
-            void createQueue(const std::string& name); // Creates a new NotificationQueue.
-            orxonox::NotificationQueue* getQueue(const std::string & name); // Get the NotificationQueue with the input name.
-            // tolua_end
+            void loadQueues(void); // tolua_export // Loads all the NotificationQueues that should exist.
+
+            NotificationQueue* getQueue(const std::string & name); // Get the NotificationQueue with the input name.
 
         private:
@@ -115 +113 @@
             
             // Commands
-            void commandClear(const std::string& sender); // The clear command. Clears all NotificationQueues that have its sender as a target.
+            bool commandClear(const std::string& sender); // The clear command. Clears all NotificationQueues that have its sender as a target.
 
     }; // tolua_export

code/branches/tutoriallevel2/src/modules/notifications/NotificationQueue.cc

@@ -208 +208 @@
 
         COUT(5) << "Notification \"" << notification->getMessage() << "\" pushed to NotificationQueue '" << this->getName() << "'" << endl;
+        COUT(3) << "NotificationQueue \"" << this->getName() << "\": " << notification->getMessage() << endl;
     }
 
@@ -374 +375 @@
         }
     }
-    
-    void NotificationQueue::tidy(void)
+
+    /**
+    @brief
+        Pops all Notifications from the NotificationQueue.
+    @return
+        Returns true if successful, false if not.
+    */
+    bool NotificationQueue::tidy(void)
     {
         while(this->size_ > 0)
             this->pop();
+        return true;
     }
 

code/branches/tutoriallevel2/src/modules/notifications/NotificationQueue.h

@@ -142 +142 @@
             const std::string& getTargets(void) const; //!< Returns a string consisting of the concatenation of the targets.
 
-            void tidy(void);
+            bool tidy(void); // Pops all Notifications from the NotificationQueue.
             
         protected:
-            static const unsigned int DEFAULT_SIZE = 5; //!< The default maximum number of Notifications displayed.
-            static const unsigned int DEFAULT_DISPLAY_TIME = 30; //!< The default display time.
-            static const int INF = -1; //!< Constant denoting infinity.
-        
             /**
             @brief Is called when a notification was pushed.
@@ -166 +162 @@
             virtual void clear(bool noGraphics = false); //!< Clears the NotificationQueue by removing all NotificationContainers.
 
+        protected:
+            static const unsigned int DEFAULT_SIZE = 5; //!< The default maximum number of Notifications displayed.
+            static const unsigned int DEFAULT_DISPLAY_TIME = 30; //!< The default display time.
+            static const int INF = -1; //!< Constant denoting infinity.
 
         private:

code/branches/tutoriallevel2/src/modules/notifications/NotificationQueueCEGUI.cc

@@ -33 +33 @@
 
 #include "NotificationQueueCEGUI.h"
+
+#include <sstream>
 
 #include "core/CoreIncludes.h"
@@ -42 +44 @@
 #include "Notification.h"
 
+#include "ToluaBindNotifications.h"
+
 namespace orxonox
 {
 
+    // Register tolua_open function when loading the library.
+    DeclareToluaInterface(Notifications);
+
     NotificationQueueCEGUI::NotificationQueueCEGUI(const std::string& name, const std::string& senders, unsigned int size, unsigned int displayTime) : NotificationQueue(name, senders, size, displayTime)
     {
         RegisterObject(NotificationQueueCEGUI);
+
+        this->displaySize_ = Vector4(1.0, 0.0, 0.0, 0.0);
+        this->position_ = Vector4(0.0, 0.0, 0.0, 0.0);
+        this->alignment_ = "LeftAligned";
+        this->fontSize_ = 12;
+        this->fontColor_ = Vector4(1.0, 1.0, 1.0, 1.0);
+        this->fontColorStr_ = "FFFFFFFF";
         
         // Create the NotificationQueueCEGUI in lua.
@@ -73 +87 @@
         NotificationQueue::destroy();
     }
-    
+
+    /**
+    @brief
+        Set the size of the window that displays the NotificationQueue.
+    @param size
+        The size is a vector with components:
+        - The relative width of the window. (A value between 0 and 1)
+        - The absolute width in pixels. (Additional to the relative width, can be negative)
+        - The relative height of the window. (A value between 0 and 1)
+        - The absolute height in pixels. (Additional to the relative width, can be negative.)
+        If both the 3rd and 4th component of size are set to 0 the height is set such that exactly as many Notifications fit as is the maximum size of the NotificationQueue (in terms of the number of Notifications).
+    */
+    void NotificationQueueCEGUI::setDisplaySize(const Vector4& size)
+    {
+        if(this->displaySize_ == size)
+            return;
+
+        if(size.x < 0.0 || size.x > 1.0 || size.z < 0.0 || size.z > 1.0)
+        {
+            COUT(2) << "The display size of the NotificationQueueCEGUI " << this->getName() << " was trying to be set, but the relative size was not in [0,1]. Aborting..." << endl;
+            return;
+        }
+
+        this->displaySize_ = size;
+        if(size.z == 0.0 && size.w == 0.0)
+            GUIManager::getInstance().getLuaState()->doString("NotificationLayer.resizeQueue(\"" + this->getName() + "\", " + multi_cast<std::string>(this->displaySize_.x) + ", " + multi_cast<std::string>(this->displaySize_.y) + ")");
+        else
+            GUIManager::getInstance().getLuaState()->doString("NotificationLayer.resizeQueue(\"" + this->getName() + "\", " + multi_cast<std::string>(this->displaySize_.x) + ", " + multi_cast<std::string>(this->displaySize_.y) + ", " + multi_cast<std::string>(this->displaySize_.z) + ", " + multi_cast<std::string>(this->displaySize_.w) + ")");
+    }
+
+    /**
+    @brief
+        Set the position of the window that displays the NotificationQueue.
+    @param position
+        The position is a vector with components:
+        - The relative x-position of the window. (A value between 0 and 1)
+        - The absolute x-position in pixels. (Additional to the relative x-position, can be negative)
+        - The relative y-position of the window. (A value between 0 and 1)
+        - The absolute y-position in pixels. (Additional to the relative y-position, can be negative.)
+    */
+    void NotificationQueueCEGUI::setPosition(const Vector4& position)
+    {
+        if(this->position_ == position)
+            return;
+
+        if(position.x < 0.0 || position.x > 1.0 || position.z < 0.0 || position.z > 1.0)
+        {
+            COUT(2) << "The position the NotificationQueueCEGUI " << this->getName() << " was trying to be set, but the relative position was not in [0,1]. Aborting..." << endl;
+            return;
+        }
+
+        this->position_ = position;
+        GUIManager::getInstance().getLuaState()->doString("NotificationLayer.moveQueue(\"" + this->getName() + "\", " + multi_cast<std::string>(this->position_.x) + ", " + multi_cast<std::string>(this->position_.y) + ", " + multi_cast<std::string>(this->position_.z) + ", " + multi_cast<std::string>(this->position_.w) + ")");
+    }
+
+    /**
+    @brief
+        Set the horizontal alignment of the Notifications text.
+    @param alignment
+        The alignment of the Notifications, they are the possible string that the CEGUI Falagard StaticText HorzFormatting property can take.
+    @see http://cegui.org.uk/api_reference/classCEGUI_1_1FalagardStaticTextProperties_1_1HorzFormatting.html
+    */
+    void NotificationQueueCEGUI::setAlignment(const std::string& alignment)
+    {
+        if(this->alignment_ == alignment)
+            return;
+
+        // TODO: Check whether the alignment string is correct?
+        this->alignment_ = alignment;
+        GUIManager::getInstance().getLuaState()->doString("NotificationLayer.changeQueueAlignment(\"" + this->getName() + "\", \"" + this->alignment_ + "\")");
+    }
+
+    /**
+    @brief
+        Set the font size of the text displayed by this NotificationQueue.
+    @param size
+        The font size.
+    */
+    void NotificationQueueCEGUI::setFontSize(unsigned int size)
+    {
+        if(this->fontSize_ == size)
+            return;
+
+        this->fontSize_ = size;
+        GUIManager::getInstance().getLuaState()->doString("NotificationLayer.changeQueueFontSize(\"" + this->getName() + "\", " + multi_cast<std::string>(this->fontSize_) + ")");
+    }
+
+    /**
+    @brief
+        Set the font color if the text displayed by this NotificationQueue.
+    @param color
+        The color is a vector with the components being RGBA and taking values from 0 to 1.
+    */
+    void NotificationQueueCEGUI::setFontColor(const Vector4& color)
+    {
+        if(this->fontColor_ == color)
+            return;
+
+        this->fontColor_ = color;
+        // Convert to ARGB format.
+        std::stringstream stream;
+        for(unsigned int i = 0; i < 4; i++)
+            stream << std::hex << std::setw(2) << std::setfill('0') << int(this->fontColor_[(i+3)%4]*255);
+        this->fontColorStr_ = stream.str();
+        GUIManager::getInstance().getLuaState()->doString("NotificationLayer.changeQueueFontColor(\"" + this->getName() + "\", \"" + this->fontColorStr_ + "\")");
+    }
+
+    /**
+    @brief
+        Get the NotificationQueueCEGUI with the input name.
+    @param name
+        The name of the NotificationQueueCEGUI to be got.
+    @return
+        Returns a pointer to the NotificationQueueCEGUI, or NULL if it doesn't exist.
+    */
+    /*static*/ NotificationQueueCEGUI* NotificationQueueCEGUI::getQueue(const std::string& name)
+    {
+        NotificationQueue* queue = NotificationManager::getInstance().getQueue(name);
+        if(queue == NULL || !queue->isA(Class(NotificationQueueCEGUI)))
+            return NULL;
+        return static_cast<NotificationQueueCEGUI*>(queue);
+    }
+
     /**
     @brief
@@ -86 +222 @@
             GUIManager::getInstance().getLuaState()->doString("NotificationLayer.pushNotification(\"" + this->getName() + "\", \"" + notification->getMessage() + "\")");
     }
-    
+
     /**
     @brief
@@ -97 +233 @@
             GUIManager::getInstance().getLuaState()->doString("NotificationLayer.popNotification(\"" + this->getName() + "\")");
     }
-    
+
     /**
     @brief Is called when a notification was removed.
@@ -108 +244 @@
             GUIManager::getInstance().getLuaState()->doString("NotificationLayer.removeNotification(\"" + this->getName() + "\", " + multi_cast<std::string>(index) + ")");
     }
-    
+
     /**
     @brief
@@ -118 +254 @@
     {
         NotificationQueue::clear(noGraphics);
-        
+
         // Clear the NotificationQueue in the GUI.
         if(GameMode::showsGraphics() && !noGraphics)
             GUIManager::getInstance().getLuaState()->doString("NotificationLayer.clearQueue(\"" + this->getName() + "\")");
     }
-    
+
     /**
     @brief

code/branches/tutoriallevel2/src/modules/notifications/NotificationQueueCEGUI.h

@@ -39 +39 @@
 
 #include <string>
+#include "util/Math.h"
 
 #include "NotificationManager.h"
+
 #include "NotificationQueue.h"
 
@@ -46 +48 @@
 { // tolua_export
 
-    //TODO: Update.
     /**
     @brief
-        Displays @ref orxonox::Notification "Notifications" from specific senders.
+        Displays @ref orxonox::Notification "Notifications" using CEGUI.
 
-        There are quite some parameters that influence the behavior of the NotificationQueue:
-        - @b name The name of the NotificationQueue. It needs to be unique.
-        - @b senders The senders that are targets of this NotificationQueue, i.e. the names of senders whose Notifications this NotificationQueue displays.
-        - @b size The size of the NotificationQueue, it specifies how many @ref orxonox::Notification "Notifications" are displayed at once at the most.
-        - @b displayTime The time a @ref orxonox::Notification "Notification" is displayed with this NotificationQueue.
+        Apart form the parameters inherited by the @ref orxonox::NotificationQueue "NotificationQueue", there are some more parameters that influence the behavior of the NotificationQueueCEGUI:
+        - @b displaySize The size of the window that displays the NotificationQueue.
+        - @b position The position if the window that displays the NotificationQueue.
+        - @b alignment The horizontal alignment of the displayed Notifications.
+        - @b fontSize The font size of the displayed Notifications.
+        - @b fontColor The font color of the displayed Notifications.
 
     @author
         Damian 'Mozork' Frick
 
+    @see NotificationQueue
     @ingroup Notifications
     */
@@ -70 +73 @@
             virtual ~NotificationQueueCEGUI();
 
-            //! Destroys the NotificationQueue.
-            void destroy(bool noGraphics = false); // tolua_export
+            void destroy(bool noGraphics = false); // Destroys the NotificationQueue.
+
+            /**
+            @brief Set the size of the window that displays the NotificationQueue.
+            @param size A vector whose first component is the relative width of the window (a value between 0 and 1) and whose second component is the absolute width in pixels (additional to the relative width, can be negative). The height is set such that exactly as many Notifications fit as is the maximum size of the NotificationQueue (in terms of the number of Notifications).
+            */
+            inline void setDisplaySize(const Vector2& size)
+                { this->setDisplaySize(Vector4(size.x, size.y, 0.0, 0.0)); }
+            void setDisplaySize(const Vector4& size); // Set the size of the window that displays the NotificationQueue.
+            /**
+            @brief Get the size of the window that displays the NotificationQueue.
+            @return Returns a vector with the display size.
+            */
+            inline const Vector4& getDisplaySize(void) const
+                { return this->displaySize_; }
+
+            void setPosition(const Vector4& position); // Set the position of the window that displays the NotificationQueue.
+            /**
+            @brief Get the position of the window that displays the NotificationQueue.
+            @return Returns a vector with the position.
+            */
+            inline const Vector4& getPosition(void) const
+                { return this->position_; }
+
+            void setAlignment(const std::string& alignment); // Set the horizontal alignment of the Notifications text.
+            /**
+            @brief Get the horizontal alignment of the Notifications text.
+            @return Returns a string with the horizontal alignment property.
+            */
+            inline const std::string& getAlignment(void)
+                { return this->alignment_; }
+
+            void setFontSize(unsigned int size); // Set the font size of the text displayed by this NotificationQueue.
+            /**
+            @brief Get the font size of the text displayed by this NotificationQueue.
+            @return Returns the font size.
+            */
+            inline unsigned int getFontSize(void)
+                { return this->fontSize_; }
+
+            void setFontColor(const Vector4& color); // Set the font color if the text displayed by this NotificationQueue.
+            /**
+            @brief Get the font color of the text displayed by this NotificationQueue.
+            @return Returns a vector with the components being RGBA, with values from 0 to 1.
+            */
+            inline const Vector4& getFontColor(void) const
+                { return this->fontColor_; }
+            /**
+            @brief Get the font color of the text displayed by this NotificationQueue.
+            @return Returns a string with the ARGB values in hexadecimal format.
+            */
+            inline const std::string& getFontColorStr(void) const
+                { return this->fontColorStr_; }
+
+            static NotificationQueueCEGUI* getQueue(const std::string& name); // tolua_export
             
         protected:
@@ -81 +137 @@
             
         private:
-            void create(void); // Creates the NotificationQueue in lua.            
+            Vector4 displaySize_; //!< The size of the window that displays the NotificationQueue.
+            Vector4 position_; //!< The position of the window that displays the NotificationQueue.
+            std::string alignment_; //!< The horizontal alignment of the Notifications text.
+            unsigned int fontSize_; //!< The font size of the Notifications text.
+            Vector4 fontColor_; //!< The font color of the Notifications text as a vector, in RGBA form, with values from 0 to 1.
+            std::string fontColorStr_; //!< The font color of the Notifications text as a string with the ARGB hexadecimal values.
+            
+            void create(void); // Creates the NotificationQueue in lua.
 
     }; // tolua_export

code/branches/tutoriallevel2/src/orxonox/interfaces/NotificationListener.cc

@@ -47 +47 @@
     // Commands
     /*static*/ const std::string NotificationListener::COMMAND_CLEAR("clear");
+    /*static*/ const std::string NotificationListener::COMMAND_NONE("none");
     
     registerStaticNetworkFunction(NotificationListener::sendHelper);
@@ -108 +109 @@
         {
             // If the notification is a message.
-            if(!isCommand && it->registerNotification(message, sender, notificationMessageType::Value(messageType)))
-                COUT(3) << "Notification \"" << message << "\" sent." << std::endl;
+            if(!isCommand)
+                it->registerNotification(message, sender, notificationMessageType::Value(messageType));
 
             // If the notification is a command.
@@ -115 +116 @@
             {
                 notificationCommand::Value command = str2Command(message);
-                if(command != notificationCommand::none && it->executeCommand(command, sender))
-                    COUT(3) << "Command \"" << message << "\" executed." << std::endl;
+                if(command != notificationCommand::none)
+                    it->executeCommand(command, sender);
             }
         }
@@ -138 +139 @@
         return command;
     }
+
+    /**
+    @brief
+        Helper method. Converts a command enum into its corresponding string.
+    @param command
+        The command to be converted.
+    @return
+        Returns the corresponding string.
+    */
+    /*static*/ const std::string& NotificationListener::command2Str(notificationCommand::Value command)
+    {
+        switch(command)
+        {
+            case notificationCommand::clear:
+                return NotificationListener::COMMAND_CLEAR;
+            default:
+                return NotificationListener::COMMAND_NONE;
+        }
+    }
     
 }

code/branches/tutoriallevel2/src/orxonox/interfaces/NotificationListener.h

@@ -108 +108 @@
             /**
             @brief Sends a specified command to the specified client from the specified sender.
-            @param message The command that should be sent (and later executed).
+            @param command The command that should be sent (and later executed).
             @param sender The sender that sent the notification. Default is 'none'.
             @param sendMode The mode in which the command is sent, can be 'local' to send the command to the client where this function is executed, 'network' if the command is to be sent to the client with the specified clientID, or 'broadcast' if the command should be sent to all hosts. Default is notificationSendMode::local.
@@ -138 +138 @@
             */
             virtual bool executeCommand(notificationCommand::Value command, const std::string& sender) { return false; }
+
+        public:
             
             static const std::string ALL; //!< Static string to indicate a sender that sends to all NotificationQueues.
@@ -144 +146 @@
             //! Commands
             static const std::string COMMAND_CLEAR;
+            static const std::string COMMAND_NONE;
             
         protected:
             static void sendNetworkHelper(const std::string& message, const std::string& sender, notificationSendMode::Value sendMode, unsigned int clientId, bool isCommand = false, notificationMessageType::Value messageType = notificationMessageType::info); // Helper method to send both notifications and commands over the network.
-            
+
             static notificationCommand::Value str2Command(const std::string& string); // Helper method. Converts a string into the enum for a command.
+            static const std::string& command2Str(notificationCommand::Value command); // Helper method. Converts a command enum into its corresponding string.
     };
 }