Changeset 8637 for code/branches/presentation/src/modules

Timestamp:

May 28, 2011, 5:10:01 PM (14 years ago)

Author:

dafrick

Message:

Merging tutoriallevel3 branch into presentation branch.

Location:

code/branches/presentation

Files:

• . (modified) (1 prop)
• src/modules/notifications/CMakeLists.txt (modified) (2 diffs)
• src/modules/notifications/Notification.cc (deleted)
• src/modules/notifications/Notification.h (deleted)
• src/modules/notifications/NotificationDispatcher.cc (modified) (4 diffs)
• src/modules/notifications/NotificationManager.cc (modified) (14 diffs)
• src/modules/notifications/NotificationManager.h (modified) (5 diffs)
• src/modules/notifications/NotificationQueue.cc (modified) (16 diffs)
• src/modules/notifications/NotificationQueue.h (modified) (7 diffs)
• src/modules/notifications/NotificationQueueCEGUI.cc (copied) (copied from code/branches/tutoriallevel3/src/modules/notifications/NotificationQueueCEGUI.cc)
• src/modules/notifications/NotificationQueueCEGUI.h (copied) (copied from code/branches/tutoriallevel3/src/modules/notifications/NotificationQueueCEGUI.h)
• src/modules/objects/triggers/DistanceTrigger.cc (modified) (1 diff)
• src/modules/objects/triggers/DistanceTrigger.h (modified) (1 diff)
• src/modules/objects/triggers/EventTrigger.h (modified) (1 diff)
• src/modules/objects/triggers/MultiTrigger.cc (modified) (1 diff)
• src/modules/objects/triggers/TriggerBase.h (modified) (1 diff)
• src/modules/overlays/hud/CMakeLists.txt (modified) (1 diff)
• src/modules/overlays/hud/GametypeStatus.cc (deleted)
• src/modules/overlays/hud/GametypeStatus.h (deleted)
• src/modules/questsystem/QuestDescription.cc (modified) (2 diffs)
• src/modules/questsystem/QuestManager.cc (modified) (6 diffs)
• src/modules/questsystem/QuestManager.h (modified) (1 diff)

code/branches/presentation/src/modules/notifications/CMakeLists.txt

@@ -1 +1 @@
 SET_SOURCE_FILES(NOTIFICATIONS_SRC_FILES
-  Notification.cc
   NotificationDispatcher.cc
   NotificationManager.cc
   NotificationQueue.cc
+  NotificationQueueCEGUI.cc
 )
 
@@ -13 +13 @@
   TOLUA_FILES
     NotificationManager.h
-    NotificationQueue.h
+    NotificationQueueCEGUI.h
   PCH_FILE
     NotificationsPrecompiledHeaders.h

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

@@ -41 +41 @@
 
 #include "infos/PlayerInfo.h"
+#include "interfaces/NotificationListener.h"
 #include "interfaces/PlayerTrigger.h"
 #include "worldentities/pawns/Pawn.h"
-
-#include "NotificationManager.h"
 
 namespace orxonox
@@ -61 +60 @@
         RegisterObject(NotificationDispatcher);
 
-        this->sender_ = NotificationManager::NONE;
+        this->sender_ = NotificationListener::NONE;
         this->registerVariables();
     }
@@ -114 +113 @@
         {
             const std::string message = this->createNotificationMessage();
-            NotificationManager::sendNotification(message, clientId, this->getSender());
+            // TODO: Make the type configurable.
+            NotificationListener::sendNotification(message, this->getSender(), notificationMessageType::info, notificationSendMode::network, clientId);
         }
         else if(GameMode::isServer())
@@ -164 +164 @@
         if(player == NULL)
         {
-            COUT(3) << "The PlayerInfo* is NULL." << std::endl;
+            CCOUT(3) << "The PlayerInfo* is NULL." << std::endl;
             return false;
         }

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

@@ -36 +36 @@
 #include "core/command/ConsoleCommand.h"
 #include "core/CoreIncludes.h"
-#include "core/GUIManager.h"
 #include "core/LuaState.h"
-#include "network/Host.h"
-#include "network/NetworkFunction.h"
 #include "util/ScopedSingletonManager.h"
 
 #include "interfaces/NotificationListener.h"
 
-#include "Notification.h"
 #include "NotificationQueue.h"
-
-#include "ToluaBindNotifications.h"
+#include "NotificationQueueCEGUI.h"
 
 namespace orxonox
 {
 
-    const std::string NotificationManager::ALL("all");
-    const std::string NotificationManager::NONE("none");
-
-    // Register tolua_open function when loading the library.
-    DeclareToluaInterface(Notifications);
-
     ManageScopedSingleton(NotificationManager, ScopeID::Root, false);
 
-    // Setting console command to enter the edit mode.
-    SetConsoleCommand("enterEditMode", &NotificationManager::enterEditMode);
-
-    registerStaticNetworkFunction(NotificationManager::sendNotification);
-
     /**
     @brief
@@ -73 +57 @@
         RegisterRootObject(NotificationManager);
 
-        this->highestIndex_ = 0;
-
-        ModifyConsoleCommand("enterEditMode").setObject(this);
-
         COUT(3) << "NotificatioManager created." << std::endl;
     }
@@ -86 +66 @@
     NotificationManager::~NotificationManager()
     {
-        ModifyConsoleCommand("enterEditMode").setObject(NULL);
-
         // Destroys all Notifications.
         for(std::multimap<std::time_t, Notification*>::iterator it = this->allNotificationsList_.begin(); it!= this->allNotificationsList_.end(); it++)
@@ -106 +84 @@
         while(it != this->queues_.end())
         {
-            it->second->destroy(true);
+            it->second->destroy();
             it = this->queues_.begin();
         }
@@ -115 +93 @@
     /**
     @brief
-        Sends a Notification with the specified message to the specified client from the specified sender.
+        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 that should be sent.
-    @param clientId
-        The id of the client the notification should be sent to.
+        The message of the new Notification.
     @param sender
-        The sender that sent the notification.
-    @param isLocal
-        If this is set to true (false is default), then the Notification is sent to the client where this function is executed, meaning the Notification is sent locally.
-    */
-    /*static*/ void NotificationManager::sendNotification(const std::string& message, unsigned int clientId, const std::string& sender, bool isLocal)
-    {
-        // If we're in standalone mode or we're already no the right client we create and send the Notification.
-        if(GameMode::isStandalone() || isLocal || Host::getPlayerID() == clientId)
-        {
-            Notification* notification = new Notification(message, sender);
-            if(NotificationManager::getInstance().registerNotification(notification))
-                COUT(3) << "Notification \"" << notification->getMessage() << "\" sent." << std::endl;
-        }
-        // If we're on the server (and the server is not the intended recipient of the Notification) we send it over the network.
-        else if(GameMode::isServer())
-        {
-            callStaticNetworkFunction(NotificationManager::sendNotification, clientId, message, clientId, sender);
-        }
-    }
-
-    /**
-    @brief
-        Registers a Notification within the NotificationManager and makes sure that the Notification is sent to all the NotificationListeners associated with its 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.
+    */
+    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.
+    @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)
+        {
+            if(this->commandClear(sender))
+                commandExecuted = true;
+        }
+
+        if(commandExecuted)
+            COUT(3) << "Notification command \"" << NotificationListener::command2Str(command) << "\" executed." << endl;
+
+        return commandExecuted;
+    }
+
+    /**
+    @brief
+        The clear command. Clears all NotificationQueues that have its sender as a target.
+    @param sender
+        The sender of the clear command.
+    @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.
+        {
+            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())
+                executed = it->second->tidy() || executed;
+        }
+
+        return executed;
+    }
+    
+    /**
+    @brief
+        Registers a Notification within the NotificationManager and makes sure that the Notification is sent to all the NotificationQueues associated with its sender.
     @param notification
         The Notification to be registered.
@@ -158 +178 @@
         this->allNotificationsList_.insert(std::pair<std::time_t, Notification*>(time, notification));
 
-        if(notification->getSender() == NotificationManager::NONE) // If the sender has no specific name, then the Notification is only added to the list of all Notifications.
+        if(notification->getSender() == NotificationListener::NONE) // If the sender has no specific name, then the Notification is only added to the list of all Notifications.
             return true;
 
-        bool all = false;
-        if(notification->getSender() == NotificationManager::ALL) // If all are the sender, then the Notifications is added to every NotificationListener.
-            all = true;
-
-        // Insert the Notification in all NotificationListeners that have its sender as target.
-        for(std::map<NotificationListener*, unsigned int>::iterator it = this->listenerList_.begin(); it != this->listenerList_.end(); it++) // Iterate through all NotificationListeners.
-        {
-            const std::set<std::string>& set = it->first->getTargetsSet();
-            bool bAll = set.find(NotificationManager::ALL) != set.end();
-            // If either the Notification has as sender 'all', the NotificationListener displays all Notifications or the NotificationListener has the sender of the Notification as target.
+        // 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.
+        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();
+            bool bAll = set.find(NotificationListener::ALL) != set.end();
+            // If either the Notification has as sender 'all', the NotificationQueue displays all Notifications or the NotificationQueue has the sender of the Notification as target.
             if(all || bAll || set.find(notification->getSender()) != set.end())
             {
                 if(!bAll)
-                    this->notificationLists_[it->second]->insert(std::pair<std::time_t, Notification*>(time, notification)); // Insert the Notification in the notifications list of the current NotificationListener.
-                it->first->update(notification, time); // Update the NotificationListener.
+                    this->notificationLists_[it->second->getName()]->insert(std::pair<std::time_t, Notification*>(time, notification)); // Insert the Notification in the notifications list of the current NotificationQueue.
+                it->second->update(notification, time); // Update the NotificationQueue.
             }
         }
@@ -186 +205 @@
     /**
     @brief
-        Unregisters a Notification within the NotificationManager for a given NotificationListener.
+        Unregisters a Notification within the NotificationManager for a given NotificationQueue.
     @param notification
         A pointer to the Notification to be unregistered.
-    @param listener
-        A pointer to the NotificationListener the Notification is unregistered for.
-    */
-    void NotificationManager::unregisterNotification(Notification* notification, NotificationListener* listener)
+    @param queue
+        A pointer to the NotificationQueue the Notification is unregistered for.
+    */
+    void NotificationManager::unregisterNotification(Notification* notification, NotificationQueue* queue)
     {
         assert(notification);
-        assert(listener);
-
-        // Remove the Notification from the list of Notifications of the input NotificationListener.
-        this->removeNotification(notification, *(this->notificationLists_.find(this->listenerList_.find(listener)->second)->second));
-
-        COUT(4) << "Notification (&" << notification << ") unregistered with the NotificationManager from listener (&" << listener << ")" << std::endl;
+        assert(queue);
+
+        // Remove the Notification from the list of Notifications of the input NotificationQueue.
+        this->removeNotification(notification, *(this->notificationLists_.find(queue->getName())->second));
+
+        COUT(4) << "Notification (&" << notification << ") unregistered with the NotificationManager from NotificationQueue " << queue->getName() << "." << std::endl;
     }
 
@@ -230 +249 @@
     /**
     @brief
-        Registers a NotificationListener within the NotificationManager.
-    @param listener
-        The NotificationListener to be registered.
-    @return
-        Returns true if successful.  Fales if the NotificationListener is already registered.
-    */
-    bool NotificationManager::registerListener(NotificationListener* listener)
-    {
-        assert(listener);
-
-        // If the NotificationListener is already registered.
-        if(this->listenerList_.find(listener) != this->listenerList_.end())
-            return false;
-
-        this->highestIndex_ += 1;
-        unsigned int index = this->highestIndex_; // An identifier that identifies each registered NotificationListener uniquely.
-
-        this->listenerList_[listener] = index; // Add the NotificationListener to the list of NotificationListeners.
-
-        const std::set<std::string>& set = listener->getTargetsSet();
-
-        // If all senders are the target of the NotificationListener, then the list of Notifications for that specific NotificationListener is the same as the list of all Notifications.
-        bool bAll = set.find(NotificationManager::ALL) != set.end();
-        std::multimap<std::time_t, Notification*>* map = NULL;
-        if(bAll)
-            this->notificationLists_[index] = &this->allNotificationsList_;
-        // Else a new list (resp. multimap) is created and added to the list of Notification lists for NotificationListeners.
-        else
-        {
-            this->notificationLists_[index] = new std::multimap<std::time_t, Notification*>;
-            map = this->notificationLists_[index];
-        }
-
-        // Iterate through all Notifications to determine whether any of them should belong to the newly registered NotificationListener.
-        for(std::multimap<std::time_t, Notification*>::iterator it = this->allNotificationsList_.begin(); it != this->allNotificationsList_.end(); it++)
-        {
-            if(!bAll && set.find(it->second->getSender()) != set.end()) // Checks whether the listener has the sender of the current Notification as target.
-                map->insert(std::pair<std::time_t, Notification*>(it->first, it->second));
-        }
-
-        listener->update(); // Update the listener.
-
-        COUT(4) << "NotificationListener registered with the NotificationManager." << std::endl;
-
-        return true;
-    }
-
-    /**
-    @brief
-        Unregisters a NotificationListener within the NotificationManager.
-    @param listener
-        The NotificationListener to be unregistered.
-    */
-    void NotificationManager::unregisterListener(NotificationListener* listener)
-    {
-        assert(listener);
-
-        unsigned int identifier = this->listenerList_.find(listener)->second;
-        std::multimap<std::time_t, Notification*>* map = this->notificationLists_.find(identifier)->second;
-
-        // If the map is not the map of all Notifications, make sure all Notifications are unregistered.
-        std::multimap<std::time_t, Notification*>::iterator it = map->begin();
-        if(map != &this->allNotificationsList_)
-        {
-            while(it != map->end())
-            {
-                this->unregisterNotification(it->second, listener);
-                it = map->begin();
-            }
-            delete map;
-        }
-
-        COUT(4) << "NotificationListener '" << identifier << "' unregistered with the NotificationManager." << std::endl;
-
-        // Remove the NotificationListener from the list of NotificationListeners.
-        this->listenerList_.erase(listener);
-        // Remove the Notifications list that was associated with the input NotificationListener.
-        this->notificationLists_.erase(identifier);
-    }
-
-    /**
-    @brief
-        Fetches the Notifications for a specific NotificationListener in a specified timeframe and stores them in the input map.
-    @param listener
-        The NotificationListener the Notifications are fetched for.
+        Fetches the Notifications for a specific NotificationQueue in a specified timeframe 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.
@@ -324 +261 @@
         Returns true if successful.
     */
-    void NotificationManager::getNotifications(NotificationListener* listener, std::multimap<std::time_t,Notification*>* map, const std::time_t & timeFrameStart, const std::time_t & timeFrameEnd)
-    {
-        assert(listener);
+    void NotificationManager::getNotifications(NotificationQueue* queue, std::multimap<std::time_t,Notification*>* map, const std::time_t & timeFrameStart, const std::time_t & timeFrameEnd)
+    {
+        assert(queue);
         assert(map);
 
-        std::multimap<std::time_t, Notification*>* notifications = this->notificationLists_[this->listenerList_[listener]]; // All the Notifications for the input NotificationListener.
+        std::multimap<std::time_t, Notification*>* notifications = this->notificationLists_[queue->getName()]; // All the Notifications for the input NotificationQueue.
 
         std::multimap<std::time_t,Notification*>::iterator it, itLowest, itHighest;
@@ -342 +279 @@
     /**
     @brief
-        Enters the edit mode of the NotificationLayer.
-    */
-    void NotificationManager::enterEditMode(void)
-    {
-        if(GameMode::showsGraphics())
-        {
-            GUIManager::getInstance().hideGUI("NotificationLayer");
-            GUIManager::getInstance().showGUI("NotificationLayer", false, false);
-            GUIManager::getInstance().getLuaState()->doString("NotificationLayer.enterEditMode()");
+        Fetches the newest Notifications for a specific NotificationQueue 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 numberOfNotifications
+        The number of newest Notifications to be got.
+    @return
+        Returns true if successful.
+    */
+    void NotificationManager::getNewestNotifications(NotificationQueue* queue, std::multimap<std::time_t, Notification*>* map, int numberOfNotifications)
+    {
+        assert(queue);
+        assert(map);
+
+        std::multimap<std::time_t, Notification*>* notifications = this->notificationLists_[queue->getName()]; // All the Notifications for the input NotificationQueue.
+
+        if(!notifications->empty()) // If the list of Notifications is not empty.
+        {
+            std::multimap<std::time_t,Notification*>::iterator it = notifications->end();
+            for(int i = 0; i < numberOfNotifications; i++) // Iterate through the Notifications from the newest until we have the specified number of notifications.
+            {
+                it--;
+                map->insert(std::pair<std::time_t, Notification*>(it->first, it->second)); // Add the found Notifications to the map.
+                if(it == notifications->begin())
+                    break;
+            }
         }
     }
@@ -357 +312 @@
     @brief
         Registers a NotificationQueue.
-        This makes sure that the NotificationQueue can be attained through lua by name. It also makes sure that the NotificationQueue is destroyed upon destruction of the NotificationManager.
+        This makes sure that the NotificationQueue can be accessed through lua by name. It also makes sure that the NotificationQueue is destroyed upon destruction of the NotificationManager.
     @param queue
         A pointer to the NotificationQueue to be registered.
@@ -365 +320 @@
     bool NotificationManager::registerQueue(NotificationQueue* queue)
     {
+        assert(queue);
+
+        // If the NotificationQueue is already registered.
+        if(this->queues_.find(queue->getName()) != this->queues_.end())
+            return false;
+
+        this->queues_.insert(std::pair<const std::string, NotificationQueue*>(queue->getName(), queue)); // Add the NotificationQueue to the list of NotificationQueues.
+
+        const std::set<std::string>& set = queue->getTargetsSet();
+
+        // If all senders are the target of the NotificationQueue, then the list of Notifications for that specific NotificationQueue is the same as the list of all Notifications.
+        bool bAll = set.find(NotificationListener::ALL) != set.end();
+        std::multimap<std::time_t, Notification*>* map = NULL;
+        if(bAll)
+            this->notificationLists_[queue->getName()] = &this->allNotificationsList_;
+        // Else a new list (resp. multimap) is created and added to the list of Notification lists for NotificationQueues.
+        else
+        {
+            this->notificationLists_[queue->getName()] = new std::multimap<std::time_t, Notification*>;
+            map = this->notificationLists_[queue->getName()];
+        }
+
+        // Iterate through all Notifications to determine whether any of them should belong to the newly registered NotificationQueue.
+        for(std::multimap<std::time_t, Notification*>::iterator it = this->allNotificationsList_.begin(); it != this->allNotificationsList_.end(); it++)
+        {
+            if(!bAll && set.find(it->second->getSender()) != set.end()) // Checks whether the listener has the sender of the current Notification as target.
+                map->insert(std::pair<std::time_t, Notification*>(it->first, it->second));
+        }
+
+        queue->update(); // Update the queue.
+        
         COUT(4) << "NotificationQueue '" << queue->getName() << "' registered with the NotificationManager." << std::endl;
-        return this->queues_.insert(std::pair<const std::string, NotificationQueue*>(queue->getName(), queue)).second;
+        return true;
     }
 
@@ -377 +363 @@
     void NotificationManager::unregisterQueue(NotificationQueue* queue)
     {
+        assert(queue);
+
+        std::multimap<std::time_t, Notification*>* map = this->notificationLists_.find(queue->getName())->second;
+
+        // If the map is not the map of all Notifications, make sure all Notifications are unregistered.
+        std::multimap<std::time_t, Notification*>::iterator it = map->begin();
+        if(map != &this->allNotificationsList_)
+        {
+            while(it != map->end())
+            {
+                this->unregisterNotification(it->second, queue);
+                it = map->begin();
+            }
+            delete map;
+        }
+
+        // Remove the NotificationQueue from the list of NotificationQueues.
+        this->queues_.erase(queue->getName());
+        // Remove the Notifications list that was associated with the input NotificationQueue.
+        this->notificationLists_.erase(queue->getName());
+        
         COUT(4) << "NotificationQueue '" << queue->getName() << "' unregistered with the NotificationManager." << std::endl;
-        this->queues_.erase(queue->getName());
-    }
-
-    /**
-    @brief
-        Loads all the NotificationQueues that should exist.
-    */
-    void NotificationManager::loadQueues(void)
-    {
-        new NotificationQueue("all");
-    }
-
-    /**
-    @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);
     }
 
@@ -420 +405 @@
     }
 
+    /**
+    @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", "gameinfo", 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));*/
+    }
+
+    // Notification class
+
+    /**
+    @brief
+        Constructor. Creates a Notification with the input message and sender.
+    @param message
+        The message of the Notification.
+    @param sender
+        The sender of the Notification.
+    @param type
+
+    */
+    Notification::Notification(const std::string& message, const std::string& sender, notificationMessageType::Value type)
+    {
+        this->initialize();
+        this->message_ = message;
+        this->sender_ = sender;
+        this->type_ = type;
+    }
+
+    /**
+    @brief
+        Destructor.
+    */
+    Notification::~Notification()
+    {
+
+    }
+
+    /**
+    @brief
+        Registers the object and sets some default values.
+    */
+    void Notification::initialize(void)
+    {
+        this->message_.clear();
+        this->sender_ = NotificationListener::NONE;
+    }
+
 }

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

@@ -42 +42 @@
 #include <string>
 
+#include "core/OrxonoxClass.h"
 #include "util/Singleton.h"
-#include "core/OrxonoxClass.h"
+#include "interfaces/NotificationListener.h"
 
 namespace orxonox // tolua_export
@@ -50 +51 @@
     /**
     @brief
-        The Singleton NotificationManager functions as a gateway between @ref orxonox::Notification "Notifications" and @ref orxonox::NotificationListener "NotificationListeners".
-        It receives, organizes @ref orxonox::Notification "Notifications" and the redistributes them to the specific @ref orxonox::NotificationListener "NotificationListeners".
-        It also provides a static function to send @ref orxonox::Notification "Notifications" and works as a liaison between the @ref orxonox::NotificationQueue "NotificationQueues" and the GUI that displays notification, called NotificationLayer.
+        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 data structure that is used internally by the Notifications module.
+
+    @author
+        Damian 'Mozork' Frick
+
+    @ingroup Notifications
+    */
+    class _NotificationsExport Notification
+    {
+        public:
+            Notification(const std::string& message, const std::string& sender, notificationMessageType::Value type);
+            virtual ~Notification();
+
+            /**
+            @brief Destroys the Notification.
+            */
+            void destroy(void)
+                { delete this; }
+
+            /**
+            @brief Get the message of the Notification.
+            @return Returns the message of the Notification.
+            */
+            inline const std::string & getMessage(void) const
+                { return this->message_; }
+
+            /**
+            @brief Get the sender of the Notification.
+            @return Returns the sender of the Notification.
+            */
+            inline const std::string & getSender(void) const
+                { 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.
+
+    };
+
+    /**
+    @brief
+        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.
 
     @author
@@ -60 +114 @@
     */
     class _NotificationsExport NotificationManager // tolua_export
-        : public Singleton<NotificationManager>, public OrxonoxClass
+        : public Singleton<NotificationManager>, public NotificationListener
     { // tolua_export
             friend class Singleton<NotificationManager>;
@@ -67 +121 @@
             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 +129 @@
             static NotificationManager& getInstance() { return Singleton<NotificationManager>::getInstance(); } // tolua_export
 
-            static const std::string ALL; //!< Static string to indicate a sender that sends to all NotificationListeners.
-            static const std::string NONE; //!< Static string to indicare a sender that sends to no specific NotificationListener.
+            virtual bool registerNotification(const std::string& message, const std::string& sender, notificationMessageType::Value type);
+            virtual bool executeCommand(notificationCommand::Value command, const std::string& sender);
 
-            //! Sends a Notification with the specified message to the specified client from the specified sender.
-            static void sendNotification(const std::string& message, unsigned int clientId, const std::string& sender = NotificationManager::NONE, bool isLocal = false);
+            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, NotificationListener* listener); //!< Unregisters a Notification within the NotificationManager for a given NotificationListener.
-            bool registerListener(NotificationListener* listener); //!< Registers a NotificationListener within the NotificationManager.
-            void unregisterListener(NotificationListener* listener); //!< Unregisters a NotificationListener withing the NotificationManager.
-
-            void getNotifications(NotificationListener* listener, std::multimap<std::time_t, Notification*>* map, const std::time_t & timeFrameStart, const std::time_t & timeFrameEnd); //!< Fetches the Notifications for a specific NotificationListener 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 NotificationListener in a timeframe from now-timeDelay to now and stores them in the input map.
-            @param listener The NotificationListener 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.
             @return Returns true if successful.
             */
-            void getNotifications(NotificationListener* listener, std::multimap<std::time_t, Notification*>* map, int timeDelay)
-                { this->getNotifications(listener, map, std::time(0)-timeDelay, std::time(0)); }
+            void getNotifications(NotificationQueue* queue, std::multimap<std::time_t, Notification*>* map, int timeDelay)
+                { this->getNotifications(queue, map, std::time(0)-timeDelay, std::time(0)); }
 
-            void enterEditMode(void); //!< Enters the edit mode of the NotificationLayer.
+            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.
 
-            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.
-            // 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:
             static NotificationManager* singletonPtr_s;
 
-            unsigned int highestIndex_; //!< This variable holds the highest index (resp. key) in notificationLists_s, to secure that no key appears twice.
-
             std::multimap<std::time_t, Notification*> allNotificationsList_; //!< Container where all Notifications are stored.
-            std::map<NotificationListener*, unsigned int> listenerList_; //!< Container where all NotificationListeners are stored with a number as identifier.
-            std::map<int,std::multimap<std::time_t, Notification*>*> notificationLists_; //!< Container where all Notifications, for each identifier (associated with a NotificationListener), are stored.
+            std::map<const std::string, std::multimap<std::time_t, Notification*>*> notificationLists_; //!< Container where all Notifications, for each identifier (associated with a NotificationQueue), are stored.
 
             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
+            bool commandClear(const std::string& sender); // The clear command. Clears all NotificationQueues that have its sender as a target.
 
     }; // tolua_export

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

@@ -38 +38 @@
 
 #include "core/CoreIncludes.h"
-#include "core/GameMode.h"
-#include "core/GUIManager.h"
-#include "core/LuaState.h"
-#include "util/Convert.h"
+#include "core/XMLPort.h"
 #include "util/SubString.h"
-
-#include "Notification.h"
 
 namespace orxonox
 {
 
-    /**
-    @brief
-        Constructor. Creates and initializes the object.
+    CreateFactory(NotificationQueue);
+    
+    /**
+    @brief
+        Default constructor. Registers and initializes the object.
+    @param creator
+        The creator of the NotificationQueue.
+    */
+    NotificationQueue::NotificationQueue(BaseObject* creator) : BaseObject(creator), registered_(false)
+    {
+        RegisterObject(NotificationQueue);
+
+        this->initialize();
+    }
+
+    // TODO move to docu.
+    /**
+    @brief
+        Constructor. Registers and initializes the object.
+    @param creator
+        The creator of the NotificationQueue
     @param name
         The name of the new NotificationQueue. It needs to be unique
@@ -62 +75 @@
         The time during which a Notification is (at most) displayed.
     */
-    NotificationQueue::NotificationQueue(const std::string& name, const std::string& senders, unsigned int size, unsigned int displayTime)
-    {
-        this->registered_ = false;
-
-        RegisterRootObject(NotificationQueue);
-
-        // Initialize.
+
+    /**
+    @brief
+        Destructor.
+    */
+    NotificationQueue::~NotificationQueue()
+    {
+        this->targets_.clear();
+
+        if(this->isRegistered()) // If the NotificationQueue is registered.
+        {
+            this->clear(true);
+
+            // Unregister with the NotificationManager.
+            NotificationManager::getInstance().unregisterQueue(this);
+        }
+    }
+
+    /**
+    @brief
+        Initializes the NotificationQueue.
+    */
+    void NotificationQueue::initialize(void)
+    {
         this->size_ = 0;
         this->tickTime_ = 0.0f;
-
-        // Sets the input values.
-        this->setTargets(senders);
-        this->name_ = name;
-        this->maxSize_ = size;
-        this->setDisplayTime(displayTime);
-
+        this->maxSize_ = NotificationQueue::DEFAULT_SIZE;
+        this->displayTime_ = NotificationQueue::DEFAULT_DISPLAY_TIME;
+
+        this->creationTime_ = std::time(0);
+    }
+
+    /**
+    @brief
+        Creates the NotificationQueue.
+    */
+    void NotificationQueue::create(void)
+    {
         // Register the NotificationQueue with the NotificationManager.
         bool queueRegistered = NotificationManager::getInstance().registerQueue(this);
@@ -88 +123 @@
         }
 
-        this->create(); // Creates the NotificationQueue in lua.
-
-        // Register the NotificationQueue as NotificationListener with the NotificationManager.
-        bool listenerRegistered = NotificationManager::getInstance().registerListener(this);
-        if(!listenerRegistered) // If the registration has failed.
-        {
-            this->registered_ = false;
-            // Remove the NotificationQueue in lua.
-            if(GameMode::showsGraphics())
-                GUIManager::getInstance().getLuaState()->doString("NotificationLayer.removeQueue(\"" + this->getName() +  "\")");
-            NotificationManager::getInstance().unregisterQueue(this);
-            COUT(1) << "Error: NotificationQueue '" << this->getName() << "' could not be registered." << std::endl;
-            return;
-        }
-
         COUT(3) << "NotificationQueue '" << this->getName() << "' created." << std::endl;
-    }
-
-    /**
-    @brief
-        Destructor.
-    */
-    NotificationQueue::~NotificationQueue()
-    {
-        this->targets_.clear();
-
-        if(this->registered_) // If the NotificationQueue is registered.
-        {
-            this->clear(true);
-
-            // Unregister with the NotificationManager.
-            NotificationManager::getInstance().unregisterListener(this);
-            NotificationManager::getInstance().unregisterQueue(this);
-        }
-    }
-
-    /**
-    @brief
-        Destroys the NotificationQueue.
-        Used in lua and NotificationManager.
-    @param noGraphics
-        If this is set to true (false is default), then the queue is not removed in lua. This is used to destroy the queue, after the GUIManager has been destroyed.
-    */
-    void NotificationQueue::destroy(bool noGraphics)
-    {
-        // Remove the NotificationQueue in lua.
-        if(GameMode::showsGraphics() && !noGraphics)
-            GUIManager::getInstance().getLuaState()->doString("NotificationLayer.removeQueue(\"" + this->getName() +  "\")");
-
-        COUT(3) << "NotificationQueue '" << this->getName() << "' destroyed." << std::endl;
-
-        this->OrxonoxClass::destroy();
-    }
-
-    /**
-    @brief
-        Creates the NotificationQueue in lua.
-    */
-    void NotificationQueue::create(void)
-    {
-        if(GameMode::showsGraphics())
-            GUIManager::getInstance().getLuaState()->doString("NotificationLayer.createQueue(\"" + this->getName() +  "\", " + multi_cast<std::string>(this->getMaxSize()) + ")");
     }
 
@@ -161 +135 @@
     {
         this->tickTime_ += dt; // Add the time interval that has passed to the time counter.
-        if(this->tickTime_ >= 1.0) // If the time counter is greater than 1s all Notifications that have expired are removed, if it is smaller we wait to the next tick.
-        {
-            this->timeLimit_.time = std::time(0)-this->displayTime_; // Container containig the current time.
+        if(this->displayTime_ != INF && this->tickTime_ >= 1.0) // If the time counter is greater than 1s all Notifications that have expired are removed, if it is smaller we wait to the next tick.
+        {
+            this->timeLimit_.time = std::time(0)-this->displayTime_; // Container containing the current time.
 
             std::multiset<NotificationContainer*, NotificationContainerCompare>::iterator it = this->ordering_.begin();
@@ -177 +151 @@
     }
 
+    void NotificationQueue::XMLPort(Element& xmlelement, XMLPort::Mode mode)
+    {
+        SUPER(NotificationQueue, XMLPort, xmlelement, mode);
+
+        XMLPortParam(NotificationQueue, "targets", setTargets, getTargets, xmlelement, mode).defaultValues(NotificationListener::ALL);
+        XMLPortParam(NotificationQueue, "size", setMaxSize, getMaxSize, xmlelement, mode);
+        XMLPortParam(NotificationQueue, "displayTime", setDisplayTime, getDisplayTime, xmlelement, mode);
+
+        this->create();
+    }
+
     /**
     @brief
         Updates the NotificationQueue.
         Updates by clearing the queue and requesting all relevant Notifications from the NotificationManager and inserting them into the queue.
+        This is called by the NotificationManager when the Notifications have changed so much, that the NotificationQueue may have to re-initialize his operations.
     */
     void NotificationQueue::update(void)
@@ -188 +174 @@
         std::multimap<std::time_t, Notification*>* notifications = new std::multimap<std::time_t, Notification*>;
         // Get the Notifications sent in the interval from now to now minus the display time.
-        NotificationManager::getInstance().getNotifications(this, notifications, this->displayTime_);
+        if(this->displayTime_ == INF)
+            NotificationManager::getInstance().getNewestNotifications(this, notifications, this->getMaxSize());
+        else
+            NotificationManager::getInstance().getNotifications(this, notifications, this->displayTime_);
 
         if(!notifications->empty())
         {
-            // Add all Notifications.
+            // Add all Notifications that have been created after this NotificationQueue was created.
             for(std::multimap<std::time_t, Notification*>::iterator it = notifications->begin(); it != notifications->end(); it++)
-                this->push(it->second, it->first);
+            {
+                if(it->first >= this->creationTime_)
+                    this->push(it->second, it->first);
+            }
         }
 
@@ -246 +238 @@
         this->notifications_.insert(this->notifications_.begin(), container);
 
-        // Push the Notification to the GUI.
-        if(GameMode::showsGraphics())
-            GUIManager::getInstance().getLuaState()->doString("NotificationLayer.pushNotification(\"" + this->getName() + "\", \"" + notification->getMessage() + "\")");
+        // Inform that a Notification was pushed.
+        this->notificationPushed(notification);
 
         COUT(5) << "Notification \"" << notification->getMessage() << "\" pushed to NotificationQueue '" << this->getName() << "'" << endl;
+        COUT(3) << "NotificationQueue \"" << this->getName() << "\": " << notification->getMessage() << endl;
     }
 
@@ -279 +271 @@
         delete container;
 
-        // Pops the Notification from the GUI.
-        if(GameMode::showsGraphics())
-            GUIManager::getInstance().getLuaState()->doString("NotificationLayer.popNotification(\"" + this->getName() + "\")");
+        // Inform that a Notification was popped.
+        this->notificationPopped();
     }
 
@@ -305 +296 @@
         delete *containerIterator;
 
-        // Removes the Notification from the GUI.
-        if(GameMode::showsGraphics())
-            GUIManager::getInstance().getLuaState()->doString("NotificationLayer.removeNotification(\"" + this->getName() + "\", " + multi_cast<std::string>(index) + ")");
+        // TODO: index automatically cast?
+        // Inform that a Notification was removed.
+        this->notificationRemoved(index);
     }
 
@@ -314 +305 @@
         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)
@@ -326 +317 @@
         this->notifications_.clear();
         this->size_ = 0;
-
-        // Clear the NotificationQueue in the GUI.
-        if(GameMode::showsGraphics() && !noGraphics)
-            GUIManager::getInstance().getLuaState()->doString("NotificationLayer.clearQueue(\"" + this->getName() + "\")");
     }
 
@@ -354 +341 @@
             return;
 
+        if(size == 0)
+        {
+            COUT(2) << "Trying to set maximal size of NotificationQueue '" << this->getName() << "' to 0. Ignoring..." << endl;
+            return;
+        }
+        
         this->maxSize_ = size;
 
-        if(this->registered_)
+        if(this->isRegistered())
             this->update();
     }
@@ -364 +357 @@
         Sets the maximum number of seconds a Notification is displayed.
     @param time
-        The number of seconds the Notifications is displayed.
-    @return
-        Returns true if successful.
-    */
-    void NotificationQueue::setDisplayTime(unsigned int time)
+        The number of seconds a Notification is displayed.
+    */
+    void NotificationQueue::setDisplayTime(int time)
     {
         if(this->displayTime_ == time)
             return;
 
+        if(time != NotificationQueue::INF && time <= 0)
+        {
+            COUT(2) << "Trying to set display time of NotificationQueue '" << this->getName() << "' to non-positive value. Ignoring..." << endl;
+        }
+            
         this->displayTime_ = time;
 
-        if(this->registered_)
+        if(this->isRegistered())
             this->update();
     }
@@ -381 +377 @@
     /**
     @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.
@@ -407 +403 @@
         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)
@@ -417 +413 @@
             this->targets_.insert(string[i]);
 
-        if(this->registered_)
-        {
-            NotificationManager::getInstance().unregisterListener(this);
-            NotificationManager::getInstance().registerListener(this);
-        }
+        // TODO: Why?
+        if(this->isRegistered())
+        {
+            NotificationManager::getInstance().unregisterQueue(this);
+            NotificationManager::getInstance().registerQueue(this);
+        }
+    }
+
+    /**
+    @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/presentation/src/modules/notifications/NotificationQueue.h

@@ -45 +45 @@
 #include "NotificationManager.h"
 
+#include "core/BaseObject.h"
 #include "tools/interfaces/Tickable.h"
-#include "interfaces/NotificationListener.h"
-
-namespace orxonox // tolua_export
-{ // tolua_export
+
+namespace orxonox
+{
 
     /**
@@ -78 +78 @@
         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.
@@ -89 +89 @@
     @ingroup Notifications
     */
-    class _NotificationsExport NotificationQueue // tolua_export
-        : public Tickable, public NotificationListener
-    { // tolua_export
+    class _NotificationsExport NotificationQueue : public BaseObject, public Tickable
+    {
 
         public:
-            NotificationQueue(const std::string& name, const std::string& senders = NotificationManager::ALL, unsigned int size = NotificationQueue::DEFAULT_SIZE, unsigned int displayTime = NotificationQueue::DEFAULT_DISPLAY_TIME);
+            NotificationQueue(BaseObject* creator);
+            NotificationQueue(BaseObject* creator, const std::string& name, const std::string& senders = NotificationListener::ALL, unsigned int size = NotificationQueue::DEFAULT_SIZE, unsigned int displayTime = NotificationQueue::DEFAULT_DISPLAY_TIME);
             virtual ~NotificationQueue();
 
-            //! Destroys the NotificationQueue.
-            void destroy(bool noGraphics = false); // tolua_export
-
-            virtual void tick(float dt); //!< To update from time to time.
-
-            void update(void); //!< Updates the NotificationQueue.
-            void update(Notification* notification, const std::time_t & time); //!< Updates the NotificationQueue by adding an new Notification.
+            virtual void tick(float dt); // To update from time to time.
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+
+            void update(void); // Updates the NotificationQueue.
+            void update(Notification* notification, const std::time_t & time); // Updates the NotificationQueue by adding an new Notification.
 
             // tolua_begin
@@ -110 +108 @@
             @return Returns the name.
             */
-            inline const std::string& getName() const
-                { return this->name_; }
-
-            void setMaxSize(unsigned int size); //!< Sets the maximum number of displayed Notifications.
+            inline const std::string& getName(void) const
+                { return this->BaseObject::getName(); }
+
+            void setMaxSize(unsigned int size); // Sets the maximum number of displayed Notifications.
             /**
             @brief Returns the maximum number of Notifications displayed.
             @return Returns maximum size.
             */
-            inline unsigned int getMaxSize() const
+            inline unsigned int getMaxSize(void) const
                 { return this->maxSize_; }
 
-            void setDisplayTime(unsigned int time); //!< Sets the maximum number of seconds a Notification is displayed.
+            void setDisplayTime(int time); // Sets the maximum number of seconds a Notification is displayed.
             /**
             @brief Returns the time interval the Notification is displayed.
             @return Returns the display time.
             */
-            inline unsigned int getDisplayTime() const
+            inline int getDisplayTime(void) const
                 { return this->displayTime_; }
             // tolua_end
@@ -134 +132 @@
             @return Returns the size of the NotificationQueue.
             */
-            inline unsigned int getSize() const
+            inline unsigned int getSize(void) const
                 { return this->size_; }
 
@@ -141 +139 @@
             @return Returns a set of strings holding the different targets.
             */
-            inline const std::set<std::string> & getTargetsSet()
+            inline const std::set<std::string> & getTargetsSet(void)
                 { return this->targets_; }
 
-            // 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.
-            // tolua_end
-
-        private:
+            void setTargets(const std::string & targets); // Set the targets of this NotificationQueue.
+            const std::string& getTargets(void) const; // Returns a string consisting of the concatenation of the targets.
+
+            /**
+            @brief Check whether the NotificationQueue is registered with the NotificationManager.
+            @return Returns true if it is registered, false if not.
+            */
+            inline bool isRegistered(void)
+                { return this->registered_; }
+
+            bool tidy(void); // Pops all Notifications from the NotificationQueue.
+            
+        protected:
+            /**
+            @brief Is called when a notification was pushed.
+            @param notification The Notification that was pushed.
+            */
+            virtual void notificationPushed(Notification* notification) {}
+            /**
+            @brief Is called when a notification was popped.
+            */
+            virtual void notificationPopped(void) {}
+            /**
+            @brief Is called when a notification was removed.
+            @param index The index the removed notification was at.
+            */
+            virtual void notificationRemoved(unsigned int index) {}
+            
+            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.
-
-            std::string name_; //!< The name of the NotificationQueue.
-
+            static const int INF = -1; //!< Constant denoting infinity.
+
+            virtual void create(void); // Creates the NotificationQueue.
+
+        private:
+            void initialize(void); // Initializes the NotificationQueue.
+
+            time_t creationTime_; // The time this NotificationQueue was created.
+            
             unsigned int maxSize_; //!< The maximal number of Notifications displayed.
             unsigned int size_; //!< The number of Notifications displayed.
-            unsigned int displayTime_; //!< The time a Notification is displayed.
+            int displayTime_; //!< The time a Notification is displayed.
 
             bool registered_; //!< Helper variable to remember whether the NotificationQueue is registered already.
@@ -169 +198 @@
             NotificationContainer timeLimit_; //!< Helper object to check against to determine whether Notifications have expired.
 
-            void create(void); //!< Creates the NotificationQueue in lua.
-
             void setName(const std::string& name); //!< Sets the name of the NotificationQueue.
 
-            void push(Notification* notification, const std::time_t & time); //!< Adds (pushes) a Notification to the NotificationQueue.
-            void pop(void); //!< Removes (pops) the least recently added Notification form the NotificationQueue.
-            void remove(const std::multiset<NotificationContainer*, NotificationContainerCompare>::iterator& containerIterator); //!< Removes the Notification that is stored in the input NotificationContainer.
-
-            void clear(bool noGraphics = false); //!< Clears the NotificationQueue by removing all NotificationContainers.
-
-    }; // tolua_export
-
-} // tolua_export
-
-#endif /* _NotificationOverlay_H__ */
+            void push(Notification* notification, const std::time_t & time); // Adds (pushes) a Notification to the NotificationQueue.
+            void pop(void); // Removes (pops) the least recently added Notification form the NotificationQueue.
+            void remove(const std::multiset<NotificationContainer*, NotificationContainerCompare>::iterator& containerIterator); // Removes the Notification that is stored in the input NotificationContainer.
+
+    };
+
+}
+
+#endif /* _NotificationQueue_H__ */

code/branches/presentation/src/modules/objects/triggers/DistanceTrigger.cc

@@ -280 +280 @@
         Check whether the DistanceTrigger is triggered.
         It is triggered if it is triggered according only to its mode (i.e. its sub-triggers) and if a target is in range.
-    @param
+    @param mode
+        The mode for which it is tested, whether the DistanceTrigger is triggered.
+    @return
         Returns true if it is triggered ,false if not.
     */

code/branches/presentation/src/modules/objects/triggers/DistanceTrigger.h

@@ -71 +71 @@
         - @b target Which specifies the class of objects that can trigger the DistanceTrigger. Default is <code>"Pawn"</code>.
         - @b beaconMode Which specifies, whether the DistanceTrigger operates on @ref orxonox::DistanceTriggerBeacon "DistanceTriggerBeacons" or not. If <em>off</em> the DistanceMultiTrigger works as usual. If set to <em>identify</em> the DistanceTrigger is only triggered by objects that have a @ref orxonox::DistanceTriggerBeacon "DistanceTriggerBeacon", with the same name as specified in <em>targetname</em>, attached to them. If set to <em>exclude</em> the DistanceTrigger is only triggered by objects that don't have a @ref orxonox::DistanceTriggerBeacon "DistanceTriggerBeacon", with the same name as specified in <em>targetname</em>, attached to them. Default is <em>off</em>.
-        - @b targetname Which specifies the name @ref oroxnox::DistanceTriggerBeacon "DistanceTriggerBeacons" need to have to make the DistanceTrigger react to them if it is in <em>beacon-mode</em> (the beaconMode is not <em>off</em>).
+        - @b targetname Which specifies the name @ref orxonox::DistanceTriggerBeacon "DistanceTriggerBeacons" need to have to make the DistanceTrigger react to them if it is in <em>beacon-mode</em> (the beaconMode is not <em>off</em>).
 
         A simple DistanceTrigger could look like this:

code/branches/presentation/src/modules/objects/triggers/EventTrigger.h

@@ -60 +60 @@
 
     @see Trigger
-        For more information on @ref oroxnox::Trigger "Triggers".
+        For more information on @ref orxonox::Trigger "Triggers".
 
     @author

code/branches/presentation/src/modules/objects/triggers/MultiTrigger.cc

@@ -198 +198 @@
                         if(bActive ^ this->isActive(state->originator))
                         {
-
                             bool bFire = true;
 

code/branches/presentation/src/modules/objects/triggers/TriggerBase.h

@@ -133 +133 @@
             inline int getActivations(void) const
                 { return this->remainingActivations_; }
+            /**
+            @brief Check whether the trigger has still at least one remaining activation.
+            @return Returns true if the trigger has remaining activations (i.e. the number of remaining activations is not zero).
+            */
+            inline bool hasRemainingActivations(void) const
+                { return this->remainingActivations_ > 0 || this->remainingActivations_ == INF_s; }
 
             /**

code/branches/presentation/src/modules/overlays/hud/CMakeLists.txt

@@ -7 +7 @@
   HUDTimer.cc
   ChatOverlay.cc
-  GametypeStatus.cc
   AnnounceMessage.cc
   KillMessage.cc

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

@@ -40 +40 @@
 #include "infos/PlayerInfo.h"
 
-#include "notifications/NotificationManager.h"
+#include "interfaces/NotificationListener.h"
 
 namespace orxonox
@@ -119 +119 @@
         }
 
-        NotificationManager::sendNotification(message, player->getClientID(), QuestDescription::SENDER);
+        NotificationListener::sendNotification(message, QuestDescription::SENDER, notificationMessageType::info, notificationSendMode::network, player->getClientID());
         return true;
     }

code/branches/presentation/src/modules/questsystem/QuestManager.cc

@@ -274 +274 @@
     int QuestManager::getNumSubQuests(Quest* quest, PlayerInfo* player)
     {
+        if(quest == NULL)
+            return this->getNumRootQuests(player);
+
         std::list<Quest*> quests = quest->getSubQuestList();
         int numQuests = 0;
@@ -296 +299 @@
     Quest* QuestManager::getSubQuest(Quest* quest, PlayerInfo* player, int index)
     {
+        if(quest == NULL)
+            return this->getRootQuest(player, index);
+
         std::list<Quest*> quests = quest->getSubQuestList();
         for(std::list<Quest*>::iterator it = quests.begin(); it != quests.end(); it++)
@@ -312 +318 @@
     @param player
         The player.
-    @return Returns the number of QuestHints of the input Quest for the input player.
+    @return
+        Returns the number of QuestHints of the input Quest for the input player.
     */
     int QuestManager::getNumHints(Quest* quest, PlayerInfo* player)
@@ -335 +342 @@
     @param index
         The index of the QuestHint.
+    @return
+        Returns a pointer to the index-th QuestHint of the input Quest for the input player.
     */
     QuestHint* QuestManager::getHints(Quest* quest, PlayerInfo* player, int index)
@@ -345 +354 @@
         }
         return NULL;
+    }
+
+    /**
+    @brief
+        Get the parent-quest of the input Quest.
+    @param quest
+        The Quest to get the parent-quest of.
+    @return
+        Returns a pointer to the parent-quest of the input Quest.
+    */
+    Quest* QuestManager::getParentQuest(Quest* quest)
+    {
+        return quest->getParentQuest();
     }
 
@@ -375 +397 @@
     /**
     @brief
+        Get the id of the input Quest.
+    @param item
+        The Quest to get the id of.
+    @return
+        Returns the id of the input Quest.
+    */
+    const std::string QuestManager::getId(Quest* item) const
+    {
+        return item->getId();
+    }
+
+    /**
+    @brief
+        Get the id of the input QuestHint.
+    @param item
+        The QuestHint to get the id of.
+    @return
+        Returns the id of the input QuestHint.
+    */
+    const std::string QuestManager::getId(QuestHint* item) const
+    {
+        return item->getId();
+    }
+
+    /**
+    @brief
         Retrieve the player for a certain GUI.
     @param guiName

code/branches/presentation/src/modules/questsystem/QuestManager.h

@@ -81 +81 @@
             QuestHint* getHints(Quest* quest, orxonox::PlayerInfo* player, int index); //!< Get the index-th QuestHint of the input Quest for the input player.
 
-            QuestDescription* getDescription(Quest* item);
-            QuestDescription* getDescription(QuestHint* item);
+            Quest* getParentQuest(Quest* quest); //!< Get the parent-quest of the input Quest.
+
+            QuestDescription* getDescription(Quest* item); //!< Get the QuestDescription of the input Quest.
+            QuestDescription* getDescription(QuestHint* item); //!< Get the QuestDescription of the input QuestHint.
+
+            const std::string getId(Quest* item) const; //!< Get the id of the input Quest.
+            const std::string getId(QuestHint* item) const; //!< Get the id of the input QuestHint.
             // tolua_end