Changeset 8445 for code/branches/tutoriallevel2/src/modules

Timestamp:

May 10, 2011, 11:37:22 PM (13 years ago)

Author:

dafrick

Message:

NotificationListener is new an entity which is informed of new notifications. The NotificationManager is, so far, the only NotificationListener. This means that Notifications can now be sent from within orxonox (though not libraries or external).
Also introduced notification commands to affect the NotificationQueues in more ways than just have them display messages (e.g. clearing them).
Added a message type which allows to send Notifications of different importance, allowing the NotificationQueus to display them differently.

Location:

code/branches/tutoriallevel2/src/modules

Files:

• notifications/Notification.cc (modified) (2 diffs)
• notifications/Notification.h (modified) (4 diffs)
• notifications/NotificationDispatcher.cc (modified) (1 diff)
• notifications/NotificationManager.cc (modified) (3 diffs)
• notifications/NotificationManager.h (modified) (4 diffs)
• notifications/NotificationQueue.cc (modified) (5 diffs)
• notifications/NotificationQueue.h (modified) (2 diffs)
• questsystem/QuestDescription.cc (modified) (1 diff)

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

@@ -48 +48 @@
         The sender of the Notification.
     */
-    Notification::Notification(const std::string& message, const std::string& sender)
+    Notification::Notification(const std::string& message, const std::string& sender, notificationMessageType::Value type)
     {
         RegisterRootObject(Notification);
@@ -54 +54 @@
         this->message_ = message;
         this->sender_ = sender;
+        this->type_ = type;
     }
 

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

@@ -40 +40 @@
 #include <string>
 #include "core/OrxonoxClass.h"
+#include "interfaces/NotificationListener.h"
 
 namespace orxonox
@@ -48 +49 @@
         A Notification represents a short message used to inform the player about something that just happened. With the @ref orxonox::NotificationManager "NotificationManager" a Notification can be sent from any part of orxonox and is then displayed by the proper @ref orxonox::NotificationQueue "NotificationQueue(s)" (depending on which senders the specific @ref orxonox::NotificationQueue "NotificationQueues" accepts).
 
-        A Notification is just a datastructure that is used internally by the Notifications module.
+        A Notification is just a data structure that is used internally by the Notifications module.
 
     @author
@@ -58 +59 @@
     {
         public:
-            Notification(const std::string& message, const std::string& sender);
+            Notification(const std::string& message, const std::string& sender, notificationMessageType::Value type);
             virtual ~Notification();
 
@@ -75 +76 @@
                 { return this->sender_; }
 
+            /**
+            @brief Get the type of the Notification.
+            @return Returns an enum with the type of the Notification.
+            */
+            inline notificationMessageType::Value getType(void) const
+                { return this->type_; }
+
         private:
             std::string message_; //!< The Notification message.
             std::string sender_; //!< The sender of the notification.
+            notificationMessageType::Value type_; //!< The type of the notification.
 
             void initialize(void); //!< Registers the object and sets some default values.

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

@@ -113 +113 @@
         {
             const std::string message = this->createNotificationMessage();
-            NotificationListener::sendNotification(message, this->getSender(), notificationMessageMode::message, notificationSendMode::network, clientId);
+            // TODO: Make the type configurable.
+            NotificationListener::sendNotification(message, this->getSender(), notificationMessageType::info, notificationSendMode::network, clientId);
         }
         else if(GameMode::isServer())

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

@@ -105 +105 @@
         this->queues_.clear();
     }
+
+    /**
+    @brief
+        Creates and registers a Notification with the input message from the input sender.
+        This is called by the NotificationListener, whenever a new notification arrives.
+    @param message
+        The message of the new Notification.
+    @param sender
+        The name of the entity (of the collective) that sent the new Notification.
+    @return
+        Returns true if successful.
+    */
+    bool NotificationManager::registerNotification(const std::string& message, const std::string& sender, notificationMessageType::Value type)
+    {
+        // TODO: Do something with the type.
+        Notification* notification = new Notification(message, sender, type);
+        return this->registerNotification(notification);
+    }
+
+    /**
+    @brief
+        Executes the input command from the input sender.
+        This is called by the NotificationListener, whenever a new command arrives.
+    @param command
+        The command to be executed,
+    @param sender
+        The The name of the entity (of the collective) that sent the command.
+    */
+    bool NotificationManager::executeCommand(notificationCommand::Value command, const std::string& sender)
+    {
+        if(command == notificationCommand::clear)
+        {
+            this->commandClear(sender);
+            return true;
+        }
+
+        return false;
+    }
+
+    /**
+    @brief
+        The clear command. Clears all NotificationQueues that have its sender as a target.
+    @param sender
+        The sender of the clear command.
+    */
+    void NotificationManager::commandClear(const std::string& sender)
+    {
+        bool all = (sender == NotificationListener::ALL);
+        // 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.
+        {
+            const std::set<std::string>& set = it->second->getTargetsSet();
+            // 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();
+        }
+    }
     
-    bool NotificationManager::registerNotification(const std::string& message, const std::string& sender)
-    {
-        Notification* notification = new Notification(message, sender);
-        return this->registerNotification(notification);
-    }
-
     /**
     @brief
@@ -132 +183 @@
             return true;
 
-        bool all = false;
-        if(notification->getSender() == NotificationListener::ALL) // If all are the sender, then the Notifications is added to every NotificationQueue.
-            all = true;
+        // If all are the sender, then the Notifications is added to every NotificationQueue.
+        bool all = (notification->getSender() == NotificationListener::ALL);
 
         // Insert the Notification in all NotificationQueues that have its sender as target.
@@ -364 +414 @@
 
         NotificationQueue* infoQueue = new NotificationQueue("info", NotificationListener::ALL, 1, -1);
-        GUIManager::getInstance().getLuaState()->doString("NotificationLayer.changeQueueFont(\"info\", 24, \"FFFFFF00\")");
+        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)");

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

@@ -67 +67 @@
             virtual ~NotificationManager();
 
-            virtual void preDestroy(void); //!< Is called before the object is destroyed.
+            virtual void preDestroy(void); // Is called before the object is destroyed.
 
             /**
@@ -75 +75 @@
             static NotificationManager& getInstance() { return Singleton<NotificationManager>::getInstance(); } // tolua_export
 
-            virtual bool registerNotification(const std::string& message, const std::string& sender);
+            virtual bool registerNotification(const std::string& message, const std::string& sender, notificationMessageType::Value type);
+            virtual bool executeCommand(notificationCommand::Value command, const std::string& sender);
 
-            bool registerNotification(Notification* notification); //!< Registers a Notification within the NotificationManager.
-            void unregisterNotification(Notification* notification, NotificationQueue* queue); //!< Unregisters a Notification within the NotificationManager for a given NotificationQueue.
+            bool registerNotification(Notification* notification); // Registers a Notification within the NotificationManager.
+            void unregisterNotification(Notification* notification, NotificationQueue* queue); // Unregisters a Notification within the NotificationManager for a given NotificationQueue.
 
-            void getNotifications(NotificationQueue* queue, std::multimap<std::time_t, Notification*>* map, const std::time_t & timeFrameStart, const std::time_t & timeFrameEnd); //!< Fetches the Notifications for a specific NotificationQueue in a specified timeframe and stores them in the input map.
+            void getNotifications(NotificationQueue* queue, std::multimap<std::time_t, Notification*>* map, const std::time_t & timeFrameStart, const std::time_t & timeFrameEnd); // Fetches the Notifications for a specific NotificationQueue in a specified timeframe and stores them in the input map.
 
             /**
-            @brief Fetches the Notifications for a specific NotificationQueue in a timeframe from now-timeDelay to now and stores them in the input map.
-            @param listener The NotificationQueue the Notifications are fetched for.
+            @brief Fetches the Notifications for a specific NotificationQueue in a timeframe from (now-timeDelay) to now and stores them in the input map.
+            @param queue The NotificationQueue the Notifications are fetched for.
             @param map A pointer to a multimap, in which the notifications are stored. The map needs to have been allocated.
             @param timeDelay The timespan.
@@ -92 +93 @@
                 { this->getNotifications(queue, map, std::time(0)-timeDelay, std::time(0)); }
 
-            void getNewestNotifications(NotificationQueue* queue, std::multimap<std::time_t, Notification*>* map, int numberOfNotifications); //!< Fetches the newest Notifications for a specific NotificationQueue and stores them in the input map.
+            void getNewestNotifications(NotificationQueue* queue, std::multimap<std::time_t, Notification*>* map, int numberOfNotifications); // Fetches the newest Notifications for a specific NotificationQueue and stores them in the input map.
 
-            void enterEditMode(void); //!< Enters the edit mode of the NotificationLayer.
+            void enterEditMode(void); // Enters the edit mode of the NotificationLayer.
 
-            bool registerQueue(NotificationQueue* queue); //!< Registers a NotificationQueue.
-            void unregisterQueue(NotificationQueue* queue); //!< Unregisters a NotificationQueue.
+            bool registerQueue(NotificationQueue* queue); // Registers a NotificationQueue.
+            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.
+            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
 
@@ -113 +114 @@
             std::map<const std::string, NotificationQueue*> queues_; //!< The list of NotificationQueues created by the NotificationManager.
 
-            bool removeNotification(Notification* notification, std::multimap<std::time_t, Notification*>& map); //!< Helper method that removes an input Notification form an input map.
+            bool removeNotification(Notification* notification, std::multimap<std::time_t, Notification*>& map); // Helper method that removes an input Notification form an input map.
+            
+            // Commands
+            void 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

@@ -56 +56 @@
     @param senders
         The senders that are targets of this NotificationQueue, i.e. the names of senders whose Notifications this NotificationQueue displays.
-        The senders need to be seperated by commas.
+        The senders need to be separated by commas.
     @param size
         The size (the maximum number of displayed Notifications) of this NotificationQueue.
@@ -304 +304 @@
         Clears the NotificationQueue by removing all NotificationContainers.
     @param noGraphics
-        If this is eset to true the GUI is not informed of the clearing of the NotificationQueue. This is needed only internally.
+        If this is set to true the GUI is not informed of the clearing of the NotificationQueue. This is needed only internally.
     */
     void NotificationQueue::clear(bool noGraphics)
@@ -369 +369 @@
     /**
     @brief
-        Produces all targets of the NotificationQueue concatinated as string, with commas (',') as seperators.
+        Produces all targets of the NotificationQueue concatenated as string, with commas (',') as separators.
     @return
         Returns the targets as a string.
@@ -395 +395 @@
         The targets are the senders whose Notifications are displayed in this queue.
     @param targets
-        Accepts a string of targets, each seperated by commas (','), spaces are ignored.
+        Accepts a string of targets, each separated by commas (','), spaces are ignored.
     */
     void NotificationQueue::setTargets(const std::string & targets)
@@ -412 +412 @@
         }
     }
+    
+    void NotificationQueue::tidy(void)
+    {
+        while(this->size_ > 0)
+            this->pop();
+    }
 
 }

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

@@ -77 +77 @@
         Displays @ref orxonox::Notification "Notifications" from specific senders.
 
-        There are quite some parameters that influence the behaviour of the NotificationQueue:
+        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.
@@ -145 +145 @@
             // tolua_begin
             void setTargets(const std::string & targets); //!< Set the targets of this NotificationQueue.
-            const std::string& getTargets(void) const; //!< Returns a string consisting of the concatination of the targets.
+            const std::string& getTargets(void) const; //!< Returns a string consisting of the concatenation of the targets.
             // tolua_end
+
+            void tidy(void);
 
         private:

code/branches/tutoriallevel2/src/modules/questsystem/QuestDescription.cc

@@ -119 +119 @@
         }
 
-        NotificationListener::sendNotification(message, QuestDescription::SENDER, notificationMessageMode::message, notificationSendMode::network, player->getClientID());
+        NotificationListener::sendNotification(message, QuestDescription::SENDER, notificationMessageType::info, notificationSendMode::network, player->getClientID());
         return true;
     }