Changeset 2911 for code/trunk

Timestamp:

Apr 8, 2009, 2:58:40 AM (16 years ago)

Author:

landauf

Message:

Merged r1-2096 of questsystem5 back to trunk

I hope there weren't more "hidden merge changes" in r2909 than the one in OverlayGroup (removeElement) (and related to this the adjustments in NotificationQueue).

The corresponding media commit seems not yet to be done, but it doesn't break the build.

Location:

code/trunk

Files:

• . (modified) (1 prop)
• bin/client1.bat.in (modified) (1 prop)
• bin/client2.bat.in (modified) (1 prop)
• bin/dedicated.bat.in (modified) (1 prop)
• bin/run.bat.in (modified) (1 prop)
• bin/server.bat.in (modified) (1 prop)
• bin/standalone.bat.in (modified) (1 prop)
• cmake/FindDirectX.cmake (modified) (1 prop)
• cmake/LibraryConfigTardis.cmake (modified) (1 prop)
• src/core/LuaBind.cc (modified) (1 prop)
• src/core/LuaBind.h (modified) (1 prop)
• src/core/Template.cc (modified) (1 prop)
• src/core/Template.h (modified) (1 prop)
• src/core/XMLFile.h (modified) (1 prop)
• src/core/XMLIncludes.h (modified) (1 prop)
• src/cpptcl/cpptcl.cc (modified) (1 prop)
• src/cpptcl/cpptcl.h (modified) (1 prop)
• src/network/synchronisable/NetworkCallback.h (modified) (1 prop)
• src/network/synchronisable/Synchronisable.cc (modified) (1 prop)
• src/network/synchronisable/Synchronisable.h (modified) (1 prop)
• src/orxonox/CameraManager.cc (modified) (1 prop)
• src/orxonox/CameraManager.h (modified) (1 prop)
• src/orxonox/OrxonoxPrereqs.h (modified) (2 diffs)
• src/orxonox/gamestates/GSLevel.cc (modified) (3 diffs)
• src/orxonox/gamestates/GSLevel.h (modified) (1 diff)
• src/orxonox/objects/Level.cc (modified) (1 prop)
• src/orxonox/objects/Level.h (modified) (1 prop)
• src/orxonox/objects/collisionshapes (modified) (1 prop)
• src/orxonox/objects/pickup/Usable.h (modified) (1 prop)
• src/orxonox/objects/quest/AddQuest.cc (modified) (4 diffs, 1 prop)
• src/orxonox/objects/quest/AddQuest.h (modified) (1 diff, 1 prop)
• src/orxonox/objects/quest/AddQuestHint.cc (modified) (2 diffs, 1 prop)
• src/orxonox/objects/quest/AddQuestHint.h (modified) (1 diff, 1 prop)
• src/orxonox/objects/quest/AddReward.cc (modified) (1 diff, 1 prop)
• src/orxonox/objects/quest/AddReward.h (modified) (1 diff, 1 prop)
• src/orxonox/objects/quest/CMakeLists.txt (modified) (1 diff)
• src/orxonox/objects/quest/ChangeQuestStatus.cc (modified) (1 diff, 1 prop)
• src/orxonox/objects/quest/ChangeQuestStatus.h (modified) (1 diff, 1 prop)
• src/orxonox/objects/quest/CompleteQuest.cc (modified) (2 diffs, 1 prop)
• src/orxonox/objects/quest/CompleteQuest.h (modified) (1 diff, 1 prop)
• src/orxonox/objects/quest/FailQuest.cc (modified) (2 diffs, 1 prop)
• src/orxonox/objects/quest/FailQuest.h (modified) (1 diff, 1 prop)
• src/orxonox/objects/quest/GlobalQuest.cc (modified) (1 diff, 1 prop)
• src/orxonox/objects/quest/GlobalQuest.h (modified) (1 diff, 1 prop)
• src/orxonox/objects/quest/LocalQuest.cc (modified) (1 diff, 1 prop)
• src/orxonox/objects/quest/LocalQuest.h (modified) (1 diff, 1 prop)
• src/orxonox/objects/quest/Quest.cc (modified) (2 diffs, 1 prop)
• src/orxonox/objects/quest/Quest.h (modified) (1 diff, 1 prop)
• src/orxonox/objects/quest/QuestDescription.cc (modified) (5 diffs, 1 prop)
• src/orxonox/objects/quest/QuestDescription.h (modified) (1 diff, 1 prop)
• src/orxonox/objects/quest/QuestEffect.cc (modified) (1 diff, 1 prop)
• src/orxonox/objects/quest/QuestEffect.h (modified) (1 diff, 1 prop)
• src/orxonox/objects/quest/QuestEffectBeacon.cc (modified) (1 diff)
• src/orxonox/objects/quest/QuestEffectBeacon.h (modified) (1 diff)
• src/orxonox/objects/quest/QuestHint.cc (modified) (2 diffs, 1 prop)
• src/orxonox/objects/quest/QuestHint.h (modified) (1 diff, 1 prop)
• src/orxonox/objects/quest/QuestItem.cc (modified) (1 diff, 1 prop)
• src/orxonox/objects/quest/QuestItem.h (modified) (1 diff, 1 prop)
• src/orxonox/objects/quest/QuestListener.cc (modified) (2 diffs)
• src/orxonox/objects/quest/QuestListener.h (modified) (1 diff)
• src/orxonox/objects/quest/QuestManager.cc (modified) (11 diffs, 1 prop)
• src/orxonox/objects/quest/QuestManager.h (modified) (3 diffs, 1 prop)
• src/orxonox/objects/quest/QuestNotification.cc (copied) (copied from code/branches/questsystem5/src/orxonox/objects/quest/QuestNotification.cc)
• src/orxonox/objects/quest/QuestNotification.h (copied) (copied from code/branches/questsystem5/src/orxonox/objects/quest/QuestNotification.h)
• src/orxonox/objects/quest/Rewardable.cc (modified) (1 diff, 1 prop)
• src/orxonox/objects/quest/Rewardable.h (modified) (1 diff, 1 prop)
• src/orxonox/objects/weaponSystem/WeaponSystem.cc (modified) (1 prop)
• src/orxonox/objects/weaponSystem/WeaponSystem.h (modified) (1 prop)
• src/orxonox/objects/worldentities/Backlight.cc (modified) (1 prop)
• src/orxonox/objects/worldentities/Backlight.h (modified) (1 prop)
• src/orxonox/objects/worldentities/Camera.cc (modified) (1 prop)
• src/orxonox/objects/worldentities/Camera.h (modified) (1 prop)
• src/orxonox/objects/worldentities/MobileEntity.cc (modified) (1 prop)
• src/orxonox/objects/worldentities/MobileEntity.h (modified) (1 prop)
• src/orxonox/objects/worldentities/ParticleSpawner.cc (modified) (1 prop)
• src/orxonox/objects/worldentities/ParticleSpawner.h (modified) (1 prop)
• src/orxonox/objects/worldentities/StaticEntity.cc (modified) (1 prop)
• src/orxonox/objects/worldentities/StaticEntity.h (modified) (1 prop)
• src/orxonox/objects/worldentities/triggers/DistanceTrigger.cc (modified) (1 prop)
• src/orxonox/objects/worldentities/triggers/DistanceTrigger.h (modified) (1 prop)
• src/orxonox/objects/worldentities/triggers/Trigger.cc (modified) (1 prop)
• src/orxonox/objects/worldentities/triggers/Trigger.h (modified) (1 prop)
• src/orxonox/overlays/OverlayGroup.cc (modified) (1 diff)
• src/orxonox/overlays/OverlayGroup.h (modified) (1 diff)
• src/orxonox/overlays/notifications/CMakeLists.txt (modified) (1 diff)
• src/orxonox/overlays/notifications/Notification.cc (modified) (2 diffs)
• src/orxonox/overlays/notifications/Notification.h (modified) (3 diffs)
• src/orxonox/overlays/notifications/NotificationManager.cc (modified) (2 diffs)
• src/orxonox/overlays/notifications/NotificationManager.h (modified) (2 diffs)
• src/orxonox/overlays/notifications/NotificationOverlay.cc (copied) (copied from code/branches/questsystem5/src/orxonox/overlays/notifications/NotificationOverlay.cc)
• src/orxonox/overlays/notifications/NotificationOverlay.h (copied) (copied from code/branches/questsystem5/src/orxonox/overlays/notifications/NotificationOverlay.h)
• src/orxonox/overlays/notifications/NotificationQueue.cc (modified) (1 diff)
• src/orxonox/overlays/notifications/NotificationQueue.h (modified) (1 diff)
• src/tolua/all-5.0.lua (modified) (1 prop)
• src/tolua/all-5.1.lua (modified) (1 prop)
• src/util (modified) (1 prop)
• src/util/Exception.cc (modified) (1 prop)
• src/util/Exception.h (modified) (1 prop)
• src/util/SignalHandler.cc (modified) (1 prop)
• src/util/SignalHandler.h (modified) (1 prop)

code/trunk/src/orxonox/OrxonoxPrereqs.h

@@ -129 +129 @@
     class QuestListener;
     class QuestManager;
+    class QuestNotification;
     class Rewardable;
 
@@ -238 +239 @@
     class Notification;
     class NotificationManager;
+    class NotificationOverlay;
     class NotificationQueue;
     class OrxonoxOverlay;

code/trunk/src/orxonox/gamestates/GSLevel.cc

@@ -51 +51 @@
 #include "PlayerManager.h"
 #include "gui/GUIManager.h"
+#include "objects/quest/QuestManager.h"
+#include "overlays/notifications/NotificationManager.h"
 
 namespace orxonox
@@ -110 +112 @@
 
         this->playerManager_ = new PlayerManager();
+
+        this->questManager_ = new QuestManager();
+
+        this->notificationManager_ = new NotificationManager();
 
         if (GameMode::isMaster())
@@ -203 +209 @@
             delete this->playerManager_;
             this->playerManager_ = 0;
+        }
+
+        if (this->questManager_)
+        {
+            delete this->questManager_;
+            this->questManager_ = NULL;
+        }
+
+        if (this->notificationManager_)
+        {
+            delete this->notificationManager_;
+            this->notificationManager_ = NULL;
         }
 

code/trunk/src/orxonox/gamestates/GSLevel.h

@@ -67 +67 @@
         LevelManager*         levelManager_;            //!< global level manager
         PlayerManager*        playerManager_;           //!< player manager for this level
+        QuestManager*          questManager_;
+        NotificationManager*  notificationManager_;
 
         //##### ConfigValues #####

code/trunk/src/orxonox/objects/quest/AddQuest.cc

@@ -28 +28 @@
 
 /**
-    @file
+    @file AddQuest.cc
     @brief Implementation of the AddQuest class.
 */
@@ -42 +42 @@
 #include "orxonox/objects/infos/PlayerInfo.h"
 #include "QuestManager.h"
+#include "QuestDescription.h"
 #include "Quest.h"
 
@@ -72 +73 @@
     {
         SUPER(AddQuest, XMLPort, xmlelement, mode);
-        
+
         COUT(3) << "New AddQuest, with target Quest {" << this->getQuestId() << "}, created." << std::endl;
     }
@@ -96 +97 @@
         try
         {
-            Quest* quest = QuestManager::findQuest(this->getQuestId());
+            Quest* quest = QuestManager::getInstance().findQuest(this->getQuestId());
             if(quest == NULL || !quest->start(player))
             {

code/trunk/src/orxonox/objects/quest/AddQuest.h

@@ -28 +28 @@
 
 /**
-    @file
+    @file AddQuest.h
     @brief Definition of the AddQuest class.
 */

code/trunk/src/orxonox/objects/quest/AddQuestHint.cc

@@ -28 +28 @@
 
 /**
-    @file
+    @file AddQuestHint.cc
     @brief Implementation of the AddQuestHint class.
 */
@@ -117 +117 @@
         try
         {
-            QuestHint* hint = QuestManager::findHint(this->hintId_);
+            QuestHint* hint = QuestManager::getInstance().findHint(this->hintId_);
             if(hint == NULL || !hint->setActive(player))
             {

code/trunk/src/orxonox/objects/quest/AddQuestHint.h

@@ -28 +28 @@
 
 /**
-    @file
+    @file AddQuestHint.h
     @brief Definition of the AddQuestHint class.
 */

code/trunk/src/orxonox/objects/quest/AddReward.cc

@@ -28 +28 @@
 
 /**
-    @file
+    @file AddReward.cc
     @brief Implementation of the AddReward class.
 */

code/trunk/src/orxonox/objects/quest/AddReward.h

@@ -28 +28 @@
 
 /**
-    @file
+    @file AddReward.h
     @brief Definition of the AddReward class.
 */

code/trunk/src/orxonox/objects/quest/CMakeLists.txt

@@ -16 +16 @@
   QuestListener.cc
   QuestManager.cc
+  QuestNotification.cc
   Rewardable.cc
 )

code/trunk/src/orxonox/objects/quest/ChangeQuestStatus.cc

@@ -28 +28 @@
 
 /**
-    @file
+    @file ChangeQuestStatus.cc
     @brief Implementation of the ChangeQuestStatus class.
 */

code/trunk/src/orxonox/objects/quest/ChangeQuestStatus.h

@@ -28 +28 @@
 
 /**
-    @file
+    @file ChangeQuestStatus.h
     @brief Definition of the ChangeQuestStatus class.
 */

code/trunk/src/orxonox/objects/quest/CompleteQuest.cc

@@ -28 +28 @@
  
 /**
-    @file
+    @file CompleteQuest.cc
     @brief Implementation of the CompleteQuest class.
 */
@@ -96 +96 @@
         try
         {
-            quest = QuestManager::findQuest(this->getQuestId());
+            quest = QuestManager::getInstance().findQuest(this->getQuestId());
             if(quest == NULL || !quest->complete(player))
             {

code/trunk/src/orxonox/objects/quest/CompleteQuest.h

@@ -28 +28 @@
 
 /**
-    @file
+    @file CompleteQuest.h
     @brief Definition of the CompleteQuest class.
 */

code/trunk/src/orxonox/objects/quest/FailQuest.cc

@@ -28 +28 @@
  
 /**
-    @file
+    @file FailQuest.cc
     @brief Implementation of the FailQuest class.
 */
@@ -95 +95 @@
         try
         {
-            quest = QuestManager::findQuest(this->getQuestId());
+            quest = QuestManager::getInstance().findQuest(this->getQuestId());
             if(quest == NULL || !quest->fail(player))
             {

code/trunk/src/orxonox/objects/quest/FailQuest.h

@@ -28 +28 @@
 
 /**
-    @file
+    @file FailQuest.h
     @brief Definition of the FailQuest class.
 */

code/trunk/src/orxonox/objects/quest/GlobalQuest.cc

@@ -28 +28 @@
  
 /**
-    @file
+    @file GlobalQuest.cc
     @brief Implementation of the GlobalQuest class.
 */

code/trunk/src/orxonox/objects/quest/GlobalQuest.h

@@ -28 +28 @@
  
 /**
-    @file
+    @file GlobalQuest.h
     @brief Definition of the GlobalQuest class.
 */

code/trunk/src/orxonox/objects/quest/LocalQuest.cc

@@ -28 +28 @@
 
 /**
-    @file
+    @file LocalQuest.cc
     @brief Implementation of the LocalQuest class.
 */

code/trunk/src/orxonox/objects/quest/LocalQuest.h

@@ -28 +28 @@
  
 /**
-    @file
+    @file LocalQuest.h
     @brief Definition of the LocalQuest class.
 */

code/trunk/src/orxonox/objects/quest/Quest.cc

@@ -28 +28 @@
  
 /**
-    @file
+    @file Quest.cc
     @brief Implementation of the Quest class.
 */
@@ -79 +79 @@
         XMLPortObject(Quest, QuestEffect, "complete-effects", addCompleteEffect, getCompleteEffect, xmlelement, mode);
 
-        QuestManager::registerQuest(this); //!<Registers the Quest with the QuestManager.
+        QuestManager::getInstance().registerQuest(this); //!<Registers the Quest with the QuestManager.
     }
 

code/trunk/src/orxonox/objects/quest/Quest.h

@@ -28 +28 @@
  
 /**
-    @file
+    @file Quest.h
     @brief Definition of the Quest class.
         The Quest is the parent class of LocalQuest and GlobalQuest.

code/trunk/src/orxonox/objects/quest/QuestDescription.cc

@@ -28 +28 @@
 
 /**
-    @file
+    @file QuestDescription.cc
     @brief Implementation of the QuestDescription class.
 */
@@ -37 +37 @@
 
 #include "core/CoreIncludes.h"
-#include "orxonox/overlays/notifications/Notification.h"
+#include "QuestNotification.h"
 
 namespace orxonox
@@ -89 +89 @@
     @return
         Returns true if successful.
+    @todo
+        Make sure the messages meet the conditions.
     */
     bool QuestDescription::notificationHelper(const std::string & item, const std::string & status) const
     {
         std::string message = "";
-        std::string title = "";
         if(item == "hint")
         {
-            title = "You received a hint: '" + this->title_ + "'";
-            message = this->description_;
+            message = "You received a hint: '" + this->title_ + "'";
         }
         else if(item == "quest")
@@ -103 +103 @@
             if(status == "start")
             {
-                title = "You received a new quest: '" + this->title_ + "'";
-                message = this->description_;
+                message = "You received a new quest: '" + this->title_ + "'";
             }
             else if(status == "fail")
             {
-                title = "You failed the quest: '" + this->title_ + "'";
-                message = this->failMessage_;
+                message = "You failed the quest: '" + this->title_ + "'";
             }
             else if(status == "complete")
             {
-                title = "You successfully completed the quest: '" + this->title_ + "'";
-                message = this->completeMessage_;
+                message = "You successfully completed the quest: '" + this->title_ + "'";
             }
             else
@@ -128 +125 @@
         }
         
-        Notification* notification = new Notification(0, message, title, 30);
+        QuestNotification* notification = new QuestNotification(message);
         notification->send();
         return true;

code/trunk/src/orxonox/objects/quest/QuestDescription.h

@@ -28 +28 @@
 
 /**
-    @file
+    @file QuestDescription.h
     @brief Definition of the QuestDescription class.
 */

code/trunk/src/orxonox/objects/quest/QuestEffect.cc

@@ -28 +28 @@
 
 /**
-    @file
+    @file QuestEffect.cc
     @brief Implementation of the QuestEffect class.
 */

code/trunk/src/orxonox/objects/quest/QuestEffect.h

@@ -28 +28 @@
  
 /**
-    @file
+    @file QuestEffect.h
     @brief Definition of the QuestEffect class.
 */

code/trunk/src/orxonox/objects/quest/QuestEffectBeacon.cc

@@ -28 +28 @@
 
 /**
-    @file
+    @file QuestEffectBeacon.cc
     @brief Implementation of the QuestEffectBeacon class.
 */

code/trunk/src/orxonox/objects/quest/QuestEffectBeacon.h

@@ -28 +28 @@
 
 /**
-    @file
+    @file QuestEffectBeacon.h
     @brief Definition of the QuestEffectBeacon class.
 */

code/trunk/src/orxonox/objects/quest/QuestHint.cc

@@ -28 +28 @@
  
 /**
-    @file
+    @file QuestHint.cc
     @brief Implementation of the QuestHint class.
 */
@@ -73 +73 @@
         SUPER(QuestHint, XMLPort, xmlelement, mode);
 
-        QuestManager::registerHint(this); //!< Registers the QuestHint with the QuestManager.
+        QuestManager::getInstance().registerHint(this); //!< Registers the QuestHint with the QuestManager.
         
         COUT(3) << "New QuestHint {" << this->getId() << "} created." << std::endl;

code/trunk/src/orxonox/objects/quest/QuestHint.h

@@ -28 +28 @@
  
 /**
-    @file
+    @file QuestHint.h
     @brief Definition of the QuestHint class.
 */

code/trunk/src/orxonox/objects/quest/QuestItem.cc

@@ -28 +28 @@
  
 /**
-    @file
+    @file QuestItem.cc
     @brief Implementation of the QuestItem class.
 */

code/trunk/src/orxonox/objects/quest/QuestItem.h

@@ -28 +28 @@
  
 /**
-    @file
+    @file QuestItem.h
     @brief Definition of the QuestItem class.
         The QuestItem is the parent class of Quest and QuestHint.

code/trunk/src/orxonox/objects/quest/QuestListener.cc

@@ -28 +28 @@
 
 /**
-    @file
+    @file QuestListener.cc
     @brief Implementation of the QuestListener class.
 */
@@ -112 +112 @@
     bool QuestListener::setQuestId(const std::string & id)
     {
-        this->quest_ = QuestManager::findQuest(id); //!< Find the Quest corresponding to the given questId.
+        this->quest_ = QuestManager::getInstance().findQuest(id); //!< Find the Quest corresponding to the given questId.
         
         if(this->quest_ == NULL) //!< If there is no such Quest.

code/trunk/src/orxonox/objects/quest/QuestListener.h

@@ -28 +28 @@
 
 /**
-    @file
+    @file QuestListener.h
     @brief Definition of the QuestListener class.
 */

code/trunk/src/orxonox/objects/quest/QuestManager.cc

@@ -28 +28 @@
 
 /**
-    @file
+    @file QuestManager.cc
     @brief Implementation of the QuestManager class.
 */
@@ -43 +43 @@
 namespace orxonox
 {
-    //! All Quests registered by their id's.
-    std::map<std::string, Quest*> QuestManager::questMap_s;
-    //! All QuestHints registered by their id's.
-    std::map<std::string, QuestHint*> QuestManager::hintMap_s;
+    //! Pointer to the current (and single) instance of this class.
+    QuestManager* QuestManager::singletonRef_s = NULL;
 
     /**
     @brief
         Constructor. Registers the object.
-    */
-    QuestManager::QuestManager(BaseObject* creator) : BaseObject(creator)
-    {
-        RegisterObject(QuestManager);
+    @todo
+        Is inheriting from BaseObject proper?
+    */
+    QuestManager::QuestManager()
+    {
+        RegisterRootObject(QuestManager);
+
+        assert(singletonRef_s == 0);
+        singletonRef_s = this;
     }
 
@@ -64 +67 @@
     {
 
+    }
+
+    /**
+    @brief
+        Returns a reference to the current (and single) instance of the QuestManager, and creates one if there isn't one to begin with.
+    @return
+        Returns a reference to the single instance of the Quest Manager.
+    */
+    /*static*/ QuestManager & QuestManager::getInstance()
+    {
+        assert(singletonRef_s);
+        return *singletonRef_s;
     }
 
@@ -75 +90 @@
         Returns true if successful, false if not.
     */
-    /*static*/ bool QuestManager::registerQuest(Quest* quest)
+    bool QuestManager::registerQuest(Quest* quest)
     {
         if(quest == NULL) //!< Doh! Just as if there were actual quests behind NULL-pointers.
@@ -84 +99 @@
 
         std::pair<std::map<std::string, Quest*>::iterator,bool> result;
-        result = questMap_s.insert( std::pair<std::string,Quest*>(quest->getId(),quest) ); //!< Inserting the Quest.
+        result = this->questMap_.insert( std::pair<std::string,Quest*>(quest->getId(),quest) ); //!< Inserting the Quest.
 
         if(result.second) //!< If inserting was a success.
@@ -107 +122 @@
         Returns true if successful, false if not.
     */
-    /*static*/ bool QuestManager::registerHint(QuestHint* hint)
+    bool QuestManager::registerHint(QuestHint* hint)
     {
         if(hint == NULL) //!< Still not liking NULL-pointers.
@@ -116 +131 @@
 
         std::pair<std::map<std::string, QuestHint*>::iterator,bool> result;
-        result = hintMap_s.insert ( std::pair<std::string,QuestHint*>(hint->getId(),hint) ); //!< Inserting the QuestHSint.
+        result = this->hintMap_.insert ( std::pair<std::string,QuestHint*>(hint->getId(),hint) ); //!< Inserting the QuestHSint.
 
         if(result.second) //!< If inserting was a success.
@@ -141 +156 @@
         Throws an exception if the given questId is invalid.
     */
-    /*static*/ Quest* QuestManager::findQuest(const std::string & questId)
+    Quest* QuestManager::findQuest(const std::string & questId)
     {
         if(!QuestItem::isId(questId)) //!< Check vor validity of the given id.
@@ -149 +164 @@
 
         Quest* quest;
-        std::map<std::string, Quest*>::iterator it = questMap_s.find(questId);
-        if (it != questMap_s.end()) //!< If the Quest is registered.
+        std::map<std::string, Quest*>::iterator it = this->questMap_.find(questId);
+        if (it != this->questMap_.end()) //!< If the Quest is registered.
         {
             quest = it->second;
@@ -175 +190 @@
         Throws an exception if the given hintId is invalid.
     */
-    /*static*/ QuestHint* QuestManager::findHint(const std::string & hintId)
+    QuestHint* QuestManager::findHint(const std::string & hintId)
     {
         if(!QuestItem::isId(hintId)) //!< Check vor validity of the given id.
@@ -183 +198 @@
 
         QuestHint* hint;
-        std::map<std::string, QuestHint*>::iterator it = hintMap_s.find(hintId);
-        if (it != hintMap_s.end()) //!< If the QuestHint is registered.
+        std::map<std::string, QuestHint*>::iterator it = this->hintMap_.find(hintId);
+        if (it != this->hintMap_.end()) //!< If the QuestHint is registered.
         {
             hint = it->second;

code/trunk/src/orxonox/objects/quest/QuestManager.h

@@ -28 +28 @@
 
 /**
-    @file
+    @file QuestManager.h
     @brief Definition of the QuestManager class.
 */
@@ -40 +40 @@
 #include <string>
 
-#include "core/BaseObject.h"
+#include "core/OrxonoxClass.h"
 
 namespace orxonox
@@ -46 +46 @@
     /**
     @brief
-        Is a static class and manages Quests, by registering every Quest/QuestHint (through registerX()) and making them globally accessable (through findX()).
+        Is a Singleton and manages Quests, by registering every Quest/QuestHint (through registerX()) and making them globally accessable (through findX()).
         Quests (and QuestHints) are registered in the QuestManager with their id, and can be accessed in the same way.
     @author
         Damian 'Mozork' Frick
     */
-    class _OrxonoxExport QuestManager : public BaseObject
+    class _OrxonoxExport QuestManager : public OrxonoxClass
     {
-
         public:
-            QuestManager(BaseObject* creator);
+            QuestManager();
             virtual ~QuestManager();
 
-            static bool registerQuest(Quest* quest); //!< Registers a Quest in the QuestManager.
-            static bool registerHint(QuestHint* quest); //!< Registers a QuestHint in the QuestManager.
+            static QuestManager& getInstance(); //!< Returns a reference to the single instance of the Quest Manager.
 
-            static Quest* findQuest(const std::string & questId); //!< Returns the Quest with the input id.
-            static QuestHint* findHint(const std::string & hintId); //!< Returns the QuestHint with the input id.
+            bool registerQuest(Quest* quest); //!< Registers a Quest in the QuestManager.
+            bool registerHint(QuestHint* quest); //!< Registers a QuestHint in the QuestManager.
+
+            Quest* findQuest(const std::string & questId); //!< Returns the Quest with the input id.
+            QuestHint* findHint(const std::string & hintId); //!< Returns the QuestHint with the input id.
 
         private:
-            static std::map<std::string, Quest*> questMap_s; //!< All Quests registered by their id's.
-            static std::map<std::string, QuestHint*> hintMap_s; //!< All QuestHints registered by their id's.
+            static QuestManager* singletonRef_s;
+
+            std::map<std::string, Quest*> questMap_; //!< All Quests registered by their id's.
+            std::map<std::string, QuestHint*> hintMap_; //!< All QuestHints registered by their id's.
 
     };

code/trunk/src/orxonox/objects/quest/Rewardable.cc

@@ -28 +28 @@
 
 /**
-    @file
+    @file Rewardable.cc
     @brief Implementation of the Rewardable class.
 */

code/trunk/src/orxonox/objects/quest/Rewardable.h

@@ -28 +28 @@
 
 /**
-    @file
+    @file Rewardable.h
     @brief Definition of the Rewardable class.
 */

code/trunk/src/orxonox/overlays/OverlayGroup.cc

@@ -113 +113 @@
     }
 
+        /**
+    @brief
+        Removes an element from the map.
+    @param name
+        The name of the element that is removed.
+    @return
+        Returns true if there was such an element to remove, false if not.
+    */
+    bool OverlayGroup::removeElement(OrxonoxOverlay* element)
+    {
+        if(this->hudElements_.erase(element) == 0)
+            return false;
+        return true;
+    }
+
     //! Returns a different element as long as index < hudElements_.size().
     OrxonoxOverlay* OverlayGroup::getElement(unsigned int index)

code/trunk/src/orxonox/overlays/OverlayGroup.h

@@ -86 +86 @@
 
         void addElement(OrxonoxOverlay* element);
+        bool removeElement(OrxonoxOverlay* element);
         OrxonoxOverlay* getElement(unsigned int index);
 

code/trunk/src/orxonox/overlays/notifications/CMakeLists.txt

@@ -2 +2 @@
   Notification.cc
   NotificationManager.cc
+  NotificationOverlay.cc
   NotificationQueue.cc
 )

code/trunk/src/orxonox/overlays/notifications/Notification.cc

@@ -27 +27 @@
  */
 
+/**
+    @file Notification.cc
+    @brief Implementation of the Notification class.
+*/
+
 #include "OrxonoxStableHeaders.h"
 #include "Notification.h"
 
 #include "core/CoreIncludes.h"
+#include "util/Exception.h"
 
 #include "NotificationManager.h"
@@ -36 +42 @@
 namespace orxonox
 {
+
+    /**
+    @brief
+        Default constructor. Initializes the object.
+    */
     Notification::Notification(BaseObject* creator) : BaseObject(creator)
     {
-        RegisterObject(Notification);
+        this->initialize();
     }
     
-    Notification::Notification(BaseObject* creator, const std::string & message, const std::string & title, float time) : BaseObject(creator)
+    /**
+    @brief
+        Constructor. Creates a Notification with the input message.
+    @param message
+        The message of the Notification.
+    */
+    Notification::Notification(const std::string & message) : BaseObject(this)
     {
-        this->title_ = title;
         this->message_ = message;
-        if(time > 0)
-            this->displayTime_ = time;
     }
     
+    /**
+    @brief
+        Destructor.
+    */
     Notification::~Notification()
     {
     }
     
+    /**
+    @brief
+        Registers the object and sets some default values.
+    */
     void Notification::initialize(void)
     {
         RegisterObject(Notification);
         
-        this->title_ = "";
         this->message_ = "";
-        this->displayTime_ = NOTIFICATION_DISPLAY_TIME;
+        this->sender_ = NotificationManager::NONE;
         this->sent_ = false;
     }
     
+    /**
+    @brief
+        Sends the Notification to the Notificationmanager, with sender NetificationManager::NONE.
+    @return
+        Returns true if successful.
+    */
     bool Notification::send(void)
     {
-        bool successful = NotificationManager::insertNotification(this);
-        if(successful)
-            this->sent_ = true;
-        return successful;
+        return this->send(NotificationManager::NONE);
     }
     
-    bool Notification::setTitle(const std::string & title)
+    /**
+    @brief
+        Sends the Notification to the Notificationmanager, which then in turn distributes it to the different NotificationQueues.
+    @param sender
+        The sender the Notification was sent by. Used by the NotificationManager to distributes the notification to the correct NotificationQueues.
+    @return
+        Returns true if successful.
+    */
+    bool Notification::send(const std::string & sender)
     {
-        if(this->isSent())
+        this->sender_ = sender;
+        bool successful = NotificationManager::getInstance().registerNotification(this);
+        if(!successful)
             return false;
-        this->title_ = title;
+        this->sent_ = true;
+        
+        COUT(3) << "Notification \"" << this->getMessage() << "\" sent." << std::endl;
+        
         return true;
     }
     
+    /**
+    @brief
+        Sets the message of the notification.
+    @param message
+        The message to be set.
+    @return
+        Returns true if successful.
+    */
     bool Notification::setMessage(const std::string & message)
     {
-        if(this->isSent())
+        if(this->isSent()) //!< The message cannot be changed if the message has already been sent.
             return false;
         this->message_ = message;
         return true;
     }
-    
-    bool Notification::setDisplayTime(float time)
-    {
-        if(this->isSent())
-        {
-            return false;
-        }
-        if(time > 0)
-        {
-            this->displayTime_ = time;
-            return true;
-        }
-        return false;
-    }
+
 }

code/trunk/src/orxonox/overlays/notifications/Notification.h

@@ -27 +27 @@
  */
 
+/**
+    @file Notification.h
+    @brief Definition of the Notification class.
+*/
+
 #ifndef _Notification_H__
 #define _Notification_H__
@@ -38 +43 @@
 namespace orxonox
 {
-    static const float NOTIFICATION_DISPLAY_TIME = 4.0;
 
     /**
     @brief
-        This is rather temporary, so don't start relying on it, some better version will come soon but the Interface will not likely be the same.
+        A Notification is a short message used to inform the player about something that just happened. A Notification can be sent from any part of orxonox and is then displayed in the proper NotificationQueue (depending on which senders the specific NotificationQueue accepts).
     @author
         Damian 'Mozork' Frick
@@ -48 +52 @@
     class _OrxonoxExport Notification : public BaseObject
     {
-    public:
-        Notification(BaseObject* creator);
-        Notification(BaseObject* creator, const std::string & message, const std::string & title = "", float time = NOTIFICATION_DISPLAY_TIME);
-        virtual ~Notification();
-        
-        bool send(void);
-        
-        inline bool isSent(void) const
-            { return this->sent_; }
-        inline const std::string & getTitle(void) const
-            { return this->title_; }
-        inline const std::string & getMessage(void) const
-            { return this->message_; }
-        inline const float getDisplayTime(void) const
-            { return displayTime_; }
-        
-        bool setTitle(const std::string & title);
-        bool setMessage(const std::string & message);
-        bool setDisplayTime(float time);
-        
-    private:
-        std::string title_; //!< The title of the Notification.
-        std::string message_; //!< The Notification message.
-        float displayTime_; //!< The time duration the Notification is displayed in seconds.
-        bool sent_; //!< Whether Notification has been sent, if so it cannot be changed.
-        
-        void initialize(void);
+        public:
+            Notification(BaseObject* creator);
+            Notification(const std::string & message);
+            virtual ~Notification();
+            
+            bool send(void); //!< Sends the Notification to the Notificationmanager, with sender NotificationManager::NONE;
+            bool send(const std::string & sender); //!< Sends the Notification to the Notificationmanager.
+            
+            /**
+            @brief Checks whether the Notification was sent.
+            @return Returns true if the Notification was sent already.
+            */
+            inline bool isSent(void) const
+                { return this->sent_; }
+            /**
+            @brief Returns the message of the Notification.
+            @return Returns the message of the Notification.
+            */
+            inline const std::string & getMessage(void) const
+                { return this->message_; }
+                
+            inline const std::string & getSender(void) const
+                { return this->sender_; }
+            
+            bool setMessage(const std::string & message); //!< Sets the message of the notification.
+            
+        private:
+            std::string message_; //!< The Notification message.
+            std::string sender_; //!< The sender of the notification.
+            bool sent_; //!< Whether Notification has been sent, if so it cannot be changed.
+            
+            void initialize(void);
+        
     };
+
 }
 

code/trunk/src/orxonox/overlays/notifications/NotificationManager.cc

@@ -27 +27 @@
  */
 
+/**
+    @file NotificationManager.cc
+    @brief Implementation of the NotificationManager class.
+*/
+
 #include "OrxonoxStableHeaders.h"
 #include "NotificationManager.h"
@@ -32 +37 @@
 #include "core/CoreIncludes.h"
 
+#include <set>
+
 #include "Notification.h"
-
 #include "NotificationQueue.h"
 
 namespace orxonox
 {
-    std::list<NotificationContainer*> NotificationManager::notifications_s;
-
-    NotificationManager::NotificationManager(BaseObject* creator) : BaseObject(creator)
-    {
-        RegisterObject(NotificationManager);
-    }
-
+
+    const std::string NotificationManager::ALL = "all";
+    const std::string NotificationManager::NONE = "none";
+
+    NotificationManager* NotificationManager::singletonRef_s = NULL;
+
+    /**
+    @brief
+        Constructor. Registers the Object.
+    */
+    NotificationManager::NotificationManager()
+    {
+        RegisterRootObject(NotificationManager);
+
+        assert(singletonRef_s == 0);
+        singletonRef_s = this;
+
+        this->highestIndex_ = 0;
+    }
+
+    /**
+    @brief
+        Destructor.
+    */
     NotificationManager::~NotificationManager()
     {
-        //TDO: Destroy the containers
-    }
-
-    void NotificationManager::tick(float dt)
-    {
-        bool update = false;
-
-        for (std::list<NotificationContainer*>::iterator notification = notifications_s.begin(); notification != notifications_s.end(); ++notification)
-        {
-            NotificationContainer* container = *notification;
-            if(container->remainingTime == 0)
+    }
+
+    /**
+    @brief
+        Returns the current (and single) instance of the NotificationManager. Creates one, if there isn't one to begin with.
+    @return
+        Returns a reference to the single instance of the NotificationManager.
+    */
+    /*static*/ NotificationManager & NotificationManager::getInstance()
+    {
+        assert(singletonRef_s);
+        return *singletonRef_s;
+    }
+    
+    /**
+    @brief
+        Registers a Notification within the NotificationManager and makes sure that the Notification is displayed in all the NotificationQueues associated with its sender.
+    @param notification
+        The Notification to be registered.
+    @return
+        Returns true if successful.
+    */
+    bool NotificationManager::registerNotification(Notification* notification)
+    {
+    
+        if(notification == NULL) //!< A NULL-Notification cannot be registered.
+            return false;
+        
+        std::time_t time = std::time(0); //TDO: Doesn't this expire? //!< Get current time.
+        
+        this->allNotificationsList_.insert(std::pair<std::time_t,Notification*>(time,notification));
+        
+        if(notification->getSender() == 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() == ALL) //!< If all are the sender, then the Notifications is added to every NotificationQueue.
+            all = true;
+        
+        //!< Insert the notification in all queues that have its sender as target.
+        for(std::map<NotificationQueue*,int>::iterator it = this->queueList_.begin(); it != this->queueList_.end(); it++) //!< Iterate through all queues.
+        {
+            std::set<std::string> set = it->first->getTargetsSet();
+            if(all || set.find(notification->getSender()) != set.end() || set.find(ALL) != set.end()) //TDO: Make sure this works.
             {
-                continue;
+                this->notificationLists_[it->second]->insert(std::pair<std::time_t,Notification*>(time,notification)); //!< Insert the Notification in the Notifications list of the current NotificationQueue.
+                it->first->update(notification, time); //!< Update the queue.
             }
-            else if(container->remainingTime - dt <= 0)
+        }
+        
+        COUT(3) << "Notification registered with the NotificationManager." << std::endl;
+        
+        return true;
+    }
+    
+    /**
+    @brief
+        Registers a NotificationQueue within the NotificationManager.
+    @param queue
+        The NotificationQueue to be registered.
+    @return
+        Returns true if successful.
+    */
+    bool NotificationManager::registerQueue(NotificationQueue* queue)
+    {
+        this->highestIndex_ += 1;
+        int index = this->highestIndex_;
+        
+        this->queueList_[queue] = index; //!< Add the NotificationQueue to the list of queues.
+        
+        std::set<std::string> set = queue->getTargetsSet(); //TDO: Works this?
+        
+        //! If all senders are the target of the queue, then the list of notification for that specific queue is te same as the list of all Notifications.
+        if(set.find(ALL) != set.end())
+        {
+            this->notificationLists_[index] = &this->allNotificationsList_;
+            COUT(3) << "NotificationQueue registered with the NotificationManager." << std::endl;
+            return true;
+        }
+        
+        this->notificationLists_[index] = new std::multimap<std::time_t,Notification*>;
+        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 NotificationQueue.
+        for(std::multimap<std::time_t,Notification*>::iterator it = this->allNotificationsList_.begin(); it != this->allNotificationsList_.end(); it++)
+        {
+            if(set.find(it->second->getSender()) != set.end()) //!< Checks whether the overlay has the sender of the current notification as target.
             {
-                container->remainingTime = 0;
-                update = true;
+                map.insert(std::pair<std::time_t,Notification*>(it->first, it->second));
             }
-            else
-            {
-                container->remainingTime = container->remainingTime -dt;
-            }
-        }
-
-        if(update)
-            updateQueue();
-    }
-
-    bool NotificationManager::insertNotification(Notification* notification)
-    {
-        if(notification == NULL)
+        }
+        
+        queue->update(); //!< Update the queue.
+
+        COUT(3) << "NotificationQueue registered with the NotificationManager." << std::endl;
+        
+        return true;
+    }
+    
+    /**
+    @brief
+        Fetches the Notifications for a specific NotificationQueue in a specified timeframe.
+    @param queue
+        The NotificationQueue the Notifications are fetched for.
+    @param map
+        A multimap, in which the notifications are stored.
+    @param timeFrameStart
+        The start time of the timeframe.
+    @param timeFrameEnd
+        The end time of the timeframe.
+    @return
+        Returns true if successful.
+    */
+    bool NotificationManager::getNotifications(NotificationQueue* queue, std::multimap<std::time_t,Notification*>* map, const std::time_t & timeFrameStart, const std::time_t & timeFrameEnd)
+    {
+        if(queue == NULL || map == NULL)
             return false;
 
-        NotificationContainer* container = new NotificationContainer;
-        container->notification = notification;
-        container->remainingTime = notification->getDisplayTime();
-        notifications_s.push_front(container);
-
-        updateQueue();
-
-        COUT(4) << "Notification inserted. Title: " << notification->getTitle() << std::endl;
-
+        std::multimap<std::time_t,Notification*>* notifications = this->notificationLists_[this->queueList_[queue]]; //!< The Notifications for the input NotificationQueue.
+        
+        if(notifications == NULL) //!< Returns NULL, if there are no Notifications.
+            return true;
+    
+        std::multimap<std::time_t,Notification*>::iterator it, itLowest, itHighest;
+        itLowest = notifications->lower_bound(timeFrameStart);
+        itHighest = notifications->upper_bound(timeFrameStart);
+        
+        for(it = itLowest; it != itHighest; it++) //!< Iterate through the Notifications from the start of the time Frame to the end of it.
+        {
+            map->insert(std::pair<std::time_t,Notification*>(it->first,it->second)); //!< Add the found Notifications to the map.
+        }
+        
         return true;
     }
 
-    void NotificationManager::updateQueue(void)
-    {
-        std::string text = "";
-
-        if (!NotificationQueue::queue_s)
-            return;
-
-        int i = NotificationQueue::queue_s->getLength();
-        for (std::list<NotificationContainer*>::iterator notification = notifications_s.begin(); notification != notifications_s.end() && i > 0; ++notification)
-        {
-            i--;
-            NotificationContainer* container = *notification;
-            if(container->remainingTime == 0.0)
-                continue;
-
-            text = text + "\n\n\n------------\n\n" + clipMessage(container->notification->getTitle()) + "\n\n" + clipMessage(container->notification->getMessage());
-        }
-
-        NotificationQueue::queue_s->setQueueText(text);
-    }
-
-    const std::string NotificationManager::clipMessage(const std::string & str)
-    {
-
-        std::string message = str;
-        unsigned int i = 0;
-
-        unsigned int found = message.find("\\n", i);
-        while(found != std::string::npos)
-        {
-            message.replace(found, 2, "\n");
-            i = found+2;
-            found = message.find("\\n", i);
-        }
-
-        std::string clippedMessage = "";
-        int wordLength = 0;
-        i = 0;
-        int widthLeft = NotificationQueue::queue_s->getWidth();
-        while(i < message.length())
-        {
-            while(i < message.length() && message[i] != ' ' && message[i] != '\n')
-            {
-                i++;
-                wordLength++;
-            }
-
-            if(wordLength <= widthLeft)
-            {
-                clippedMessage = clippedMessage + message.substr(i-wordLength, wordLength);
-                if(i < message.length())
-                {
-                    clippedMessage = clippedMessage + message.substr(i,1);
-                }
-                widthLeft -= (wordLength+1);
-                if(message[i] == '\n')
-                {
-                    widthLeft = NotificationQueue::queue_s->getWidth() - (wordLength+1);
-                }
-                wordLength = 0;
-                i++;
-            }
-            else
-            {
-                clippedMessage.push_back('\n');
-                clippedMessage = clippedMessage + message.substr(i-wordLength, wordLength);
-                if(i < message.length())
-                {
-                    clippedMessage = clippedMessage + message.substr(i,1);
-                }
-                widthLeft = NotificationQueue::queue_s->getWidth() - (wordLength+1);
-                i++;
-                wordLength = 0;
-            }
-        }
-
-        return clippedMessage;
-    }
-
 }

code/trunk/src/orxonox/overlays/notifications/NotificationManager.h

@@ -27 +27 @@
  */
 
+/**
+    @file NotificationManager.h
+    @brief Definition of the NotificationManager class.
+*/
+
 #ifndef _NotificationManager_H__
 #define _NotificationManager_H__
@@ -32 +37 @@
 #include "OrxonoxPrereqs.h"
 
-#include "core/BaseObject.h"
+#include "core/OrxonoxClass.h"
 
-#include <list>
+#include <map>
 #include <string>
+#include <ctime>
+
+#include "NotificationOverlay.h"
 
 namespace orxonox
 {
-    struct NotificationContainer
-    {
-        Notification* notification;
-        float remainingTime;
-    };
 
     /**
     @brief
-        
+        The Singleton NotificationManager functions as a gateway between Notifications and NotificationQueues.
+        It receives, organizes Notifications and the redistributes them to the specific NotificationQueues.
     @author
         Damian 'Mozork' Frick
     */
-    class _OrxonoxExport NotificationManager : public BaseObject
+    class _OrxonoxExport NotificationManager : public OrxonoxClass
     {
-    
-    public:
-        NotificationManager(BaseObject* creator);
-        virtual ~NotificationManager();
+        public:
+            NotificationManager();
+            virtual ~NotificationManager();
+                
+            static const std::string ALL;
+            static const std::string NONE;
+         
+            static NotificationManager & getInstance(); //! Returns a reference to the single instance of the NotificationManager.
+
+            bool registerNotification(Notification* notification); //!< Registers a Notification within the NotificationManager.
+            bool registerQueue(NotificationQueue* queue); //!< Registers a NotificationQueue within the NotificationManager.
+            
+            bool getNotifications(NotificationQueue* queue, std::multimap<std::time_t,Notification*>* map, const std::time_t & timeFrameStart, const std::time_t & timeFrameEnd); //!< Returns the Notifications for a specific NotificationQueue in a specified timeframe.
+            
+            /**
+            @brief Fetches the Notifications for a specific NotificationQueue starting at a specified time.
+            @param queue The NotificationQueue the Notifications are fetched for.
+            @param map A multimap, in which the notifications are stored.
+            @param timeFrameStart The start time the Notifications are fetched from.
+            @return Returns true if successful.
+            */
+            bool getNotifications(NotificationQueue* queue, std::multimap<std::time_t,Notification*>* map, const std::time_t & timeFrameStart)
+                { return this->getNotifications(queue, map, timeFrameStart, std::time(0)); }
+            /**
+            @brief Fetches the Notifications for a specific NotificationQueue starting at a specified timespan before now.
+            @param queue The NotificationQueue the Notifications are fetched for.
+            @param map A multimap, in which the notifications are stored.
+            @param timeDelay The timespan.
+            @return Returns true if successful.
+            */
+            bool getNotifications(NotificationQueue* queue, std::multimap<std::time_t,Notification*>* map, int timeDelay)
+                { return this->getNotifications(queue, map, std::time(0)-timeDelay, std::time(0)); }
+     
+        private:
+            static NotificationManager* singletonRef_s;
+
+            int highestIndex_; //!< This variable holds the highest index (resp. key) in notificationLists_s, to secure that  no key appears twice.
         
-        static bool insertNotification(Notification* notification);
-        
-        static void tick(float dt);
-        
-    private:
-        static std::list<NotificationContainer*> notifications_s;
-        
-        static void updateQueue(void);
-        static const std::string clipMessage(const std::string & message);
+            std::multimap<std::time_t,Notification*> allNotificationsList_; //!< Container where all notifications are stored (together with their respecive timestamps).
+            std::map<NotificationQueue*,int> queueList_; //!< Container where all NotificationQueues 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 NotificationQueue), are stored.
+            
 
     };

code/trunk/src/orxonox/overlays/notifications/NotificationQueue.cc

@@ -27 +27 @@
  */
 
+/**
+    @file NotificationQueue.cc
+    @brief Implementation of the NotificationQueue class.
+*/
+
 #include "OrxonoxStableHeaders.h"
 #include "NotificationQueue.h"
 
+#include <OgreOverlayManager.h>
+#include <OgreTextAreaOverlayElement.h>
+#include <list>
+#include <iostream>
+#include <sstream>
+
 #include "core/CoreIncludes.h"
 #include "core/XMLPort.h"
 
-#include "NotificationManager.h"
+#include "Notification.h"
+#include "NotificationOverlay.h"
 
 namespace orxonox
 {
-    NotificationQueue* NotificationQueue::queue_s = 0;
 
     CreateFactory(NotificationQueue);
 
-    NotificationQueue::NotificationQueue(BaseObject* creator) : OverlayText(creator)
+    const std::string NotificationQueue::DEFAULT_FONT = "VeraMono";
+    const Vector2 NotificationQueue::DEFAULT_POSITION = Vector2(0.0,0.0);
+
+    /**
+    @brief
+        Constructor. Creates and initializes the object.
+    */
+    NotificationQueue::NotificationQueue(BaseObject* creator) : OverlayGroup(creator)
+    {
+        this->initialize();
+    }
+
+    /**
+    @brief
+        Destructor.
+    */
+    NotificationQueue::~NotificationQueue()
+    {
+        this->targets_.clear();
+        this->clear();
+    }
+
+    /**
+    @brief
+        Initializes the object.
+        Registers the object, initializes variables, sets default values and registers the queue with the NotificationManager.
+    */
+    void NotificationQueue::initialize(void)
     {
         RegisterObject(NotificationQueue);
-        //TDO: Does this work?
-        if(queue_s != NULL)
-        {
-                COUT(2) << "There is now more than one NotificationQueue, this shouldn't happen, since only the first NotificationQueue will be targeted by the NotificationManager." << std::endl;
-        }
-        else
-        {
-                queue_s = this;
-        }
-
-        this->length_ = 3;
-        this->width_ = 50;
-    }
-
-    NotificationQueue::~NotificationQueue()
-    {
-
-    }
-
+
+        this->size_ = 0;
+        this->tickTime_ = 0.0;
+
+        NotificationManager::getInstance().registerQueue(this);
+    }
+
+    /**
+    @brief
+        Sets the defaults.
+    */
+    void NotificationQueue::setDefaults(void)
+    {
+        this->setMaxSize(DEFAULT_SIZE);
+        this->setNotificationLength(DEFAULT_LENGTH);
+        this->setDisplayTime(DEFAULT_DISPLAY_TIME);
+        this->setPosition(DEFAULT_POSITION);
+
+        this->setTargets(NotificationManager::ALL);
+
+        this->setFontSize(DEFAULT_FONT_SIZE);
+        this->setFont(DEFAULT_FONT);
+    }
+
+    /**
+    @brief
+        Method for creating a NotificationQueue object through XML.
+    */
     void NotificationQueue::XMLPort(Element& xmlElement, XMLPort::Mode mode)
     {
         SUPER(NotificationQueue, XMLPort, xmlElement, mode);
 
-        XMLPortParam(NotificationQueue, "length", setLength, getLength, xmlElement, mode);
-        XMLPortParam(NotificationQueue, "width", setWidth, getWidth, xmlElement, mode);
-    }
-
+        this->setDefaults();
+
+        XMLPortParam(NotificationQueue, "maxSize", setMaxSize, getMaxSize, xmlElement, mode);
+        XMLPortParam(NotificationQueue, "notificationLength", setNotificationLength, getNotificationLength, xmlElement, mode);
+        XMLPortParam(NotificationQueue, "displayTime", setDisplayTime, getDisplayTime, xmlElement, mode);
+        XMLPortParam(NotificationQueue, "targets", setTargets, getTargets, xmlElement, mode);
+        XMLPortParam(NotificationQueue, "font", setFont, getFont, xmlElement, mode);
+        XMLPortParam(NotificationQueue, "fontSize", setFontSize, getFontSize, xmlElement, mode);
+        XMLPortParam(NotificationQueue, "position", setPosition, getPosition, xmlElement, mode);
+
+        COUT(3) << "NotificationQueue created." << std::endl;
+    }
+
+    /**
+    @brief
+        Updates the queue from time to time.
+    @param dt
+        The time interval that has passed since the last tick.
+    */
     void NotificationQueue::tick(float dt)
     {
-        NotificationManager::tick(dt);
-
-        update();
-    }
-
-    bool NotificationQueue::setLength(int length)
-    {
-        if(length > 0)
-        {
-            this->length_ = length;
-            return true;
-        }
-        return false;
-    }
-
-    bool NotificationQueue::setWidth(int width)
-    {
-        if(width > 0)
-        {
-            this->width_ = width;
-            return true;
-        }
-        return false;
-    }
-
-    void NotificationQueue::setQueueText(const std::string & text)
-    {
-        this->queueText_ = text;
-    }
-
+        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.
+
+            std::multiset<NotificationOverlayContainer*, NotificationOverlayContainerCompare>::iterator it;
+            it = this->containers_.begin();
+            while(it != this->containers_.upper_bound(&this->timeLimit_)) //!< Iterate through all elements whose creation time is smaller than the current time minus the display time.
+            {
+                this->removeContainer(*it);
+                this->scroll(Vector2(0.0,-(1.1*this->getFontSize())));
+                it = this->containers_.begin(); //TDO: Needed?
+            }
+
+            this->tickTime_ = 0.0; //!< Reset time counter.
+        }
+    }
+
+    /**
+    @brief
+        Updates the NotificationQueue.
+        Updates by clearing the queue and requesting all relevant Notifications from the NotificationManager and inserting the in the queue.
+    */
     void NotificationQueue::update(void)
     {
-        this->text_->setCaption(queueText_);
-    }
+        this->clear();
+
+        std::multimap<std::time_t,Notification*>* notifications = new std::multimap<std::time_t,Notification*>;
+        if(!NotificationManager::getInstance().getNotifications(this, notifications, this->displayTime_)) //!< Get the Notifications sent in the interval form now to minus the display time.
+        {
+            COUT(1) << "NotificationQueue update failed due to undetermined cause." << std::endl;
+            return;
+        }
+
+        if(notifications->empty())
+            return;
+
+        for(std::multimap<std::time_t,Notification*>::iterator it = notifications->begin(); it != notifications->end(); it++) //!> Add all Notifications.
+        {
+            this->addNotification(it->second, it->first);
+        }
+
+        delete notifications;
+
+        COUT(3) << "NotificationQueue updated." << std::endl;
+    }
+
+    /**
+    @brief
+        Updates the NotificationQueue by adding an new Notification.
+    @param notification
+        Pointer to the Notification.
+    @param time
+        The time the Notification was sent.
+    */
+    void NotificationQueue::update(Notification* notification, const std::time_t & time)
+    {
+        this->addNotification(notification, time);
+
+        std::multiset<NotificationOverlayContainer*, NotificationOverlayContainerCompare>::iterator it;
+        while(this->getSize() > this->getMaxSize())
+        {
+            it = this->containers_.begin();
+            this->removeContainer(*it);
+            this->scroll(Vector2(0.0,-(1.1*this->getFontSize())));
+        }
+
+        COUT(3) << "NotificationQueue updated. A new Notifications has been added." << std::endl;
+    }
+
+    /**
+    @brief
+        Sets the maximum number of displayed Notifications.
+    @param size
+        The size to be set.
+    @return
+        Returns true if successful.
+    */
+    bool NotificationQueue::setMaxSize(int size)
+    {
+        if(size < 0)
+            return false;
+        this->maxSize_ = size;
+        this->update();
+        return true;
+    }
+
+    /**
+    @brief
+        Sets the maximum number of characters a Notification message displayed by this queue is allowed to have.
+    @param length
+        The length to be set.
+    @return
+        Returns true if successful.
+    */
+    bool NotificationQueue::setNotificationLength(int length)
+    {
+        if(length < 0)
+            return false;
+        this->notificationLength_ = length;
+        this->update();
+        return true;
+    }
+
+    /**
+    @brief
+        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.
+    */
+    bool NotificationQueue::setDisplayTime(int time)
+    {
+        if(time < 0)
+            return false;
+        this->displayTime_ = time;
+        this->update();
+        return true;
+    }
+
+    /**
+    @brief
+        Produces all targets concatinated as string, with kommas (',') as seperators.
+    @param string
+        Pointer to a string which will be used by the method to fill with the concatination of the targets.
+    @return
+        Returns true if successful.
+    */
+    bool NotificationQueue::getTargets(std::string* string) const
+    {
+        if(string == NULL)
+        {
+            COUT(4) << "Input string must have memory allocated." << std::endl;
+            return false;
+        }
+        string->clear();
+        bool first = true;
+        for(std::set<std::string>::iterator it = this->targets_.begin(); it != this->targets_.end(); it++) //!< Iterate through the set of targets.
+        {
+            if(!first)
+            {
+                *string += ",";
+            }
+            else
+            {
+                first = false;
+            }
+            *string += *it;
+        }
+
+        return true;
+    }
+
+    /**
+    @brief
+        Sets the targets of the queue.
+        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.
+    @return
+        Returns true if successful.
+    */
+    bool NotificationQueue::setTargets(const std::string & targets)
+    {
+        this->targets_.clear();
+
+        std::string* pTemp;
+        unsigned int index = 0;
+        while( index < targets.size() ) //!< Go through the string, character by character until the end is reached.
+        {
+            pTemp = new std::string("");
+            while(index < targets.size() && targets[index] != ',' && targets[index] != ' ')
+            {
+                *pTemp += targets[index];
+                index++;
+            }
+            index++;
+            this->targets_.insert(*pTemp);
+        }
+
+        return true;
+    }
+
+    /**
+    @brief
+        Sets the font size.
+    @param size
+        The font size.
+    @return
+        Returns true if successful.
+    */
+    bool NotificationQueue::setFontSize(float size)
+    {
+        if(size <= 0)
+            return false;
+        this->fontSize_ = size;
+        for (std::map<Notification*, NotificationOverlayContainer*>::iterator it = this->overlays_.begin(); it != this->overlays_.end(); it++) //!< Set the font size for each overlay.
+        {
+            it->second->overlay->setFontSize(size);
+        }
+        return true;
+    }
+
+    /**
+    @brief
+        Sets the font.
+    @param font
+        The font.
+    @return
+        Returns true if successful.
+    */
+    bool NotificationQueue::setFont(const std::string & font)
+    {
+        this->font_ = font;
+        for (std::map<Notification*, NotificationOverlayContainer*>::iterator it = this->overlays_.begin(); it != this->overlays_.end(); it++) //!< Set the font for each overlay.
+        {
+            it->second->overlay->setFont(font);
+        }
+        return true;
+    }
+
+    /**
+    @brief
+        Scrolls the NotificationQueue, meaning all NotificationOverlays are moved the input vector.
+    @param pos
+        The vector the NotificationQueue is scrolled.
+    */
+    void NotificationQueue::scroll(const Vector2 pos)
+    {
+        for (std::map<Notification*, NotificationOverlayContainer*>::iterator it = this->overlays_.begin(); it != this->overlays_.end(); ++it) //!< Scroll each overlay.
+        {
+            it->second->overlay->scroll(pos);
+        }
+    }
+
+    /**
+    @brief
+        Aligns all the Notifications to the position of the NotificationQueue.
+    */
+    void NotificationQueue::positionChanged(void)
+    {
+        int counter = 0;
+        for (std::multiset<NotificationOverlayContainer*, NotificationOverlayContainerCompare>::iterator it = this->containers_.begin(); it != this->containers_.end(); it++) //!< Set the position for each overlay.
+        {
+            (*it)->overlay->setPosition(this->getPosition());
+            (*it)->overlay->scroll(Vector2(0.0,(1.1*this->getFontSize())*counter));
+            counter++;
+        }
+    }
+
+    /**
+    @brief
+        Adds a Notification, to the queue.
+        It inserts it into the storage containers, creates an corresponding overlay and a container.
+    @param notification
+        The Notification.
+    @param time
+        The time.
+    */
+    void NotificationQueue::addNotification(Notification* notification, const std::time_t & time)
+    {
+        NotificationOverlayContainer* container = new NotificationOverlayContainer;
+        container->overlay = new NotificationOverlay(this, notification);
+        container->notification = notification;
+        container->time = time;
+        std::string timeString = std::ctime(&time);
+        timeString.erase(timeString.length()-1);
+        std::ostringstream stream;
+        stream << (unsigned long)notification;
+        std::string addressString = stream.str() ;
+        container->name = "NotificationOverlay(" + timeString + ")&" + addressString;
+
+        this->containers_.insert(container);
+        this->overlays_[notification] = container;
+        this->addElement(container->overlay);
+        this->size_= this->size_+1;
+
+        container->overlay->scroll(Vector2(0.0,(1.1*this->getFontSize())*(this->getSize()-1)));
+    }
+
+    /**
+    @brief
+        Removes a container from the queue.
+    @param container
+        A pointer to the container.
+    @return
+        Returns true if successful.
+    */
+    bool NotificationQueue::removeContainer(NotificationOverlayContainer* container)
+    {
+        if(this->size_ == 0) //!< You cannot remove anything if the queue is empty.
+            return false;
+
+        this->removeElement(container->overlay);
+        this->containers_.erase(container);
+        this->overlays_.erase(container->notification);
+        delete container->overlay;
+        delete container;
+        this->size_= this->size_-1;
+
+        return true;
+    }
+
+    /**
+    @brief
+        Clears the queue by removing all containers.
+    */
+    void NotificationQueue::clear(void)
+    {
+        std::multiset<NotificationOverlayContainer*, NotificationOverlayContainerCompare>::iterator it = this->containers_.begin();
+        while(it != this->containers_.end())
+        {
+            this->removeContainer(*it);
+            it = this->containers_.begin(); //TDO: Needed?
+        }
+    }
+
 }

code/trunk/src/orxonox/overlays/notifications/NotificationQueue.h

@@ -27 +27 @@
  */
 
+/**
+    @file NotificationQueue.h
+    @brief Definition of the NotificationQueue class.
+*/
+
 #ifndef _NotificationOueue_H__
 #define _NotificationOueue_H__
 
 #include "OrxonoxPrereqs.h"
+
+#include <string>
+#include <set>
+#include <OgreOverlayManager.h>
 #include <OgreTextAreaOverlayElement.h>
-
-#include "orxonox/overlays/OverlayText.h"
+#include <OgrePanelOverlayElement.h>
+#include <map>
+#include <ctime>
+
+#include "orxonox/overlays/OverlayGroup.h"
 #include "orxonox/objects/Tickable.h"
 
-#include <string>
+#include "NotificationManager.h"
 
 namespace orxonox
 {
+
+    //! Container to allow easy handling.
+    struct NotificationOverlayContainer
+    {
+        NotificationOverlay* overlay; //!< Pointer to the NotificationOverlay, everything is about.
+        Notification* notification; //!< The Notification displayed by the overlay.
+        time_t time; //!< The time the Notification was sent and thus first displayed.
+        std::string name; //!< The name of the overlay.
+    };
+    
+    //! Struct to allow ordering of NotificationOverlayContainers.
+    struct NotificationOverlayContainerCompare {
+        bool operator() (const NotificationOverlayContainer* const & a, const NotificationOverlayContainer* const & b) const
+            { return a->time < b->time; } //!< Ordered by time.
+    };
+
     /**
     @brief
-
+        Displays Notifications from specific senders.
+        Beware! The NotificationQueue is an OverlayGruop and thus cannot be be a sub-element of an OverlayGroup (at least no for now.)
+
+        Creating a NotificationQueue through XML goes as follows:
+        <NotificationQueue
+            name = "SuperQueue" //Name of your OverlayQueue.
+            maxSize = "5" //The maximum size of Notifications displayed.
+            notificationLength = "64" //The maximum number of characters of a Notification, that are displayed. (Default is 5)
+            displayTime = "30" //The time a Notification is displayed in seconds. (Default is 30)
+            targets = "target1, target2" //The senders this NotificationQueue displays Notifications from. (all, if all Notifications should be displayed.)
+            font = "VeraMono" //The font (Default is VeraMono)
+            fontSize = '0.4' //The font size. (Default is 0.025)
+            position = "0.0, .0.0" //The position of the NotificationQueue. (Default is 0.0,0.0)
+        />
     @author
         Damian 'Mozork' Frick
     */
-    class _OrxonoxExport NotificationQueue : public OverlayText, public Tickable
+
+    class _OrxonoxExport NotificationQueue : public OverlayGroup, public Tickable
     {
-    public:
-        NotificationQueue(BaseObject* creator);
-        virtual ~NotificationQueue();
-
-        static NotificationQueue* queue_s; //TDO Singleton? oder im level.
-
-        virtual void XMLPort(Element& xmlElement, XMLPort::Mode mode);
-
-        virtual void tick(float dt);
-
-        void update(void);
-
-        int getLength(void) const
-                { return this->length_; }
-        int getWidth(void) const
-                { return this->width_; }
-
-        void setQueueText(const std::string & text);
-        bool setLength(int length);
-        bool setWidth(int width);
-
-    private:
-        Ogre::UTFString queueText_;
-        int length_;
-        int width_;
-
+    
+        public:
+            NotificationQueue(BaseObject* creator);
+            virtual ~NotificationQueue();
+            
+            virtual void XMLPort(Element& xmlElement, XMLPort::Mode mode); //!< Method for creating a NotificationQueue object through XML.
+            
+            virtual void tick(float dt); //!< To update from time to time.
+            
+            void update(void); //!< Updates the queue.
+            void update(Notification* notification, const std::time_t & time); //!< Adds a Notification to the queue.
+            
+            /**
+            @brief Returns the maximum number of Notifications displayed.
+            @return Returns maximum size.
+            */
+            inline int getMaxSize() const
+                { return this->maxSize_; }
+            /**
+            @brief Returns the current number of Notifications displayed.
+            @return Returns the size of the queue.
+            */
+            inline int getSize() const
+                { return this->size_; }
+            /**
+            @brief Returns the maximum length in characters a Notification message is allowed to have.
+            @return Returns the maximum Notification length.
+            */
+            inline int getNotificationLength() const
+                { return this->notificationLength_; }
+            /**
+            @brief Returns the time interval the Notification is displayed.
+            @return Returns the display time.
+            */
+            inline int getDisplayTime() const
+                { return this->displayTime_; }
+            /**
+            @brief Returns the position of the NotificationQueue.
+            @return Returns the position.
+            */
+            inline const Vector2 & getPosition() const
+                { return this->position_; }
+            /**
+            @brief Returns the font size used to display the Notifications.
+            @return  Returns the font size.
+            */
+            inline float getFontSize() const
+                { return this->fontSize_; }
+            /**
+            @brief Returns the font used to display the Notifications.
+            @return Returns the font.
+            */
+            inline const std::string & getFont() const
+                { return this->font_; }
+                
+            /**
+            @brief Returns the targets of this queue, reps. the senders which Notifications are displayed in this queue.
+            @return Retuns a set of string holding the different targets.
+            */
+            inline const std::set<std::string> & getTargetsSet()
+                { return this->targets_; }
+            bool getTargets(std::string* string) const; //!< Returns a string consisting of the concatination of the targets.
+            
+            /**
+            @brief Sets the position of the NotificationQueue.
+            @param pos The position.
+            */
+            inline void setPosition(Vector2 pos) 
+                { this->position_ = pos; this->positionChanged(); }
+
+            void scroll(const Vector2 pos); //!< Scrolls the NotificationQueue, meaning all NotificationOverlays are moved the input vector.
+            
+        private:
+            static const int DEFAULT_SIZE = 5; //!< The default maximum number of Notifications displayed.
+            static const int DEFAULT_LENGTH = 64; //!< The default maximum number of Notifications displayed.
+            static const int DEFAULT_DISPLAY_TIME = 30; //!< The default display time.
+            static const float DEFAULT_FONT_SIZE = 0.025; //!< The default font size.
+
+            static const std::string DEFAULT_FONT; //!< The default font.
+            static const Vector2 DEFAULT_POSITION; //!< the default position.
+        
+            int maxSize_; //!< The maximal number of Notifications displayed.
+            int size_; //!< The number of Notifications displayed.
+            int notificationLength_; //!< The maximal number of characters a Notification-message is allowed to have.
+            int displayTime_; //!< The time a Notification is displayed.
+            Vector2 position_; //!< The position of the NotificationQueue.
+            
+            std::set<std::string> targets_; //!< The targets the Queue displays Notifications of.
+            
+            float fontSize_; //!< The font size.
+            std::string font_; //!< The font.
+            
+            std::multiset<NotificationOverlayContainer*, NotificationOverlayContainerCompare> containers_; //!< Multiset, because the ordering is based on, not necessarily unique, timestamps.
+            std::map<Notification*, NotificationOverlayContainer*> overlays_; //!< Mapping notifications to their corresponding overlay containers, for easier association and finding.
+            
+            float tickTime_; //!< Helper variable, to not have to check for overlays that have been displayed too long, every tick.
+            NotificationOverlayContainer timeLimit_; //!< Helper object to check against to determine whether Notifications have expired.
+            
+            void initialize(void); //!< Initializes the object.
+            void setDefaults(void); //!< Helper method to set the default values.
+            
+            bool setMaxSize(int size); //!< Sets the maximum number of displayed Notifications.
+            bool setNotificationLength(int length); //!< Sets the maximum number of characters a Notification message displayed by this queue is allowed to have.
+            bool setDisplayTime(int time); //!< Sets the maximum number of seconds a Notification is displayed.
+            
+            bool setTargets(const std::string & targets); //!< Set the targets of this queue.
+            
+            bool setFontSize(float size); //!< Set the font size.
+            bool setFont(const std::string & font); //!< Set the font.
+
+            void positionChanged(void); //!< Aligns all the Notifications to the position of the NotificationQueue.
+            
+            void addNotification(Notification* notification, const std::time_t & time); //!< Add a notification to the queue.
+            bool removeContainer(NotificationOverlayContainer* container); //!< Remove a container from the queue.
+            
+            void clear(void); //!< Clear the queue.
+    
     };