Changeset 2785

Timestamp:

Mar 15, 2009, 11:41:25 AM (15 years ago)

Author:

dafrick

Message:

Made QuestManager and NotificationManager to Singletons. Fixed/Changed som other stuff I don't remember…

Location:

code/branches/questsystem5/src/orxonox

Files:

• objects/quest/AddQuest.cc (modified) (1 diff)
• objects/quest/AddQuestHint.cc (modified) (1 diff)
• objects/quest/CompleteQuest.cc (modified) (1 diff)
• objects/quest/FailQuest.cc (modified) (1 diff)
• objects/quest/Quest.cc (modified) (1 diff)
• objects/quest/QuestHint.cc (modified) (1 diff)
• objects/quest/QuestListener.cc (modified) (1 diff)
• objects/quest/QuestManager.cc (modified) (10 diffs)
• objects/quest/QuestManager.h (modified) (2 diffs)
• overlays/notifications/Notification.cc (modified) (1 diff)
• overlays/notifications/NotificationManager.cc (modified) (9 diffs)
• overlays/notifications/NotificationManager.h (modified) (5 diffs)
• overlays/notifications/NotificationOverlay.cc (modified) (1 diff)
• overlays/notifications/NotificationQueue.cc (modified) (8 diffs)
• overlays/notifications/NotificationQueue.h (modified) (6 diffs)

code/branches/questsystem5/src/orxonox/objects/quest/AddQuest.cc

@@ -97 +97 @@
         try
         {
-            Quest* quest = QuestManager::findQuest(this->getQuestId());
+            Quest* quest = QuestManager::getInstance().findQuest(this->getQuestId());
             if(quest == NULL || !quest->start(player))
             {

code/branches/questsystem5/src/orxonox/objects/quest/AddQuestHint.cc

@@ -117 +117 @@
         try
         {
-            QuestHint* hint = QuestManager::findHint(this->hintId_);
+            QuestHint* hint = QuestManager::getInstance().findHint(this->hintId_);
             if(hint == NULL || !hint->setActive(player))
             {

code/branches/questsystem5/src/orxonox/objects/quest/CompleteQuest.cc

@@ -96 +96 @@
         try
         {
-            quest = QuestManager::findQuest(this->getQuestId());
+            quest = QuestManager::getInstance().findQuest(this->getQuestId());
             if(quest == NULL || !quest->complete(player))
             {

code/branches/questsystem5/src/orxonox/objects/quest/FailQuest.cc

@@ -95 +95 @@
         try
         {
-            quest = QuestManager::findQuest(this->getQuestId());
+            quest = QuestManager::getInstance().findQuest(this->getQuestId());
             if(quest == NULL || !quest->fail(player))
             {

code/branches/questsystem5/src/orxonox/objects/quest/Quest.cc

@@ -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/branches/questsystem5/src/orxonox/objects/quest/QuestHint.cc

@@ -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/branches/questsystem5/src/orxonox/objects/quest/QuestListener.cc

@@ -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/branches/questsystem5/src/orxonox/objects/quest/QuestManager.cc

@@ -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() : BaseObject(this)
+    {
+        RegisterRootObject(QuestManager);
+
     }
 
@@ -64 +65 @@
     {
 
+    }
+
+    /**
+    @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()
+    {
+        if(singletonRef_s == NULL)
+        {
+            singletonRef_s = new QuestManager();
+        }
+        return *singletonRef_s;
     }
 
@@ -75 +91 @@
         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 +100 @@
 
         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 +123 @@
         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 +132 @@
 
         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 +157 @@
         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 +165 @@
 
         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 +191 @@
         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 +199 @@
 
         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/branches/questsystem5/src/orxonox/objects/quest/QuestManager.h

@@ -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
@@ -54 +54 @@
     {
 
+        protected:
+            QuestManager();
+
         public:
-            QuestManager(BaseObject* creator);
             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/branches/questsystem5/src/orxonox/overlays/notifications/Notification.cc

@@ -106 +106 @@
     {
         this->sender_ = sender;
-        bool successful = NotificationManager::registerNotification(this);
+        bool successful = NotificationManager::getInstance().registerNotification(this);
         if(!successful)
             return false;

code/branches/questsystem5/src/orxonox/overlays/notifications/NotificationManager.cc

@@ -48 +48 @@
     const std::string NotificationManager::NONE = "none";
 
-    std::multimap<std::time_t,Notification*> NotificationManager::allNotificationsList_s;
-    std::map<int,std::multimap<std::time_t,Notification*>*> NotificationManager::notificationLists_s;
-    std::map<NotificationQueue*,int> NotificationManager::queueList_s;
-    
-    int NotificationManager::highestIndex_s = 0;
+    NotificationManager* NotificationManager::singletonRef_s = NULL;
 
     /**
@@ -58 +54 @@
         Constructor. Registers the Object.
     */
-    NotificationManager::NotificationManager(BaseObject* creator) : BaseObject(creator)
-    {
-        RegisterObject(NotificationManager);
+    NotificationManager::NotificationManager() : BaseObject(this)
+    {
+        RegisterRootObject(NotificationManager);
+
+        this->highestIndex_ = 0;
     }
 
@@ -69 +67 @@
     NotificationManager::~NotificationManager()
     {
+    }
+
+    /**
+    @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()
+    {
+        if(singletonRef_s == NULL)
+        {
+            singletonRef_s = new NotificationManager();
+        }
+        return *singletonRef_s;
     }
     
@@ -79 +92 @@
         Returns true if successful.
     */
-    /*static*/ bool NotificationManager::registerNotification(Notification* notification)
+    bool NotificationManager::registerNotification(Notification* notification)
     {
     
@@ -87 +100 @@
         std::time_t time = std::time(0); //TDO: Doesn't this expire? //!< Get current time.
         
-        allNotificationsList_s.insert(std::pair<std::time_t,Notification*>(time,notification));
+        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.
@@ -97 +110 @@
         
         //!< Insert the notification in all queues that have its sender as target.
-        for(std::map<NotificationQueue*,int>::iterator it = queueList_s.begin(); it != queueList_s.end(); it++) //!< Iterate through all queues.
+        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.
             {
-                notificationLists_s[it->second]->insert(std::pair<std::time_t,Notification*>(time,notification)); //!< Insert the Notification in the Notifications list of the current NotificationQueue.
+                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.
             }
@@ -120 +133 @@
         Returns true if successful.
     */
-    /*static*/ bool NotificationManager::registerQueue(NotificationQueue* queue)
-    {
-        NotificationManager::highestIndex_s += 1;
-        int index = NotificationManager::highestIndex_s;
-        
-        queueList_s[queue] = index; //!< Add the NotificationQueue to the list of queues.
+    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?
@@ -132 +145 @@
         if(set.find(ALL) != set.end())
         {
-            notificationLists_s[index] = &allNotificationsList_s;
+            this->notificationLists_[index] = &this->allNotificationsList_;
             COUT(3) << "NotificationQueue registered with the NotificationManager." << std::endl;
             return true;
         }
         
-        notificationLists_s[index] = new std::multimap<std::time_t,Notification*>;
-        std::multimap<std::time_t,Notification*> map = *notificationLists_s[index];
+        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 = allNotificationsList_s.begin(); it != allNotificationsList_s.end(); it++)
+        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.
@@ -170 +183 @@
         Make sure the map is deleted.
     */
-    /*static*/ std::multimap<std::time_t,Notification*>* NotificationManager::getNotifications(NotificationQueue* queue, const std::time_t & timeFrameStart, const std::time_t & timeFrameEnd)
-    {
-        std::multimap<std::time_t,Notification*>* notifications = NotificationManager::notificationLists_s[NotificationManager::queueList_s[queue]];
+    std::multimap<std::time_t,Notification*>* NotificationManager::getNotifications(NotificationQueue* queue, const std::time_t & timeFrameStart, const std::time_t & timeFrameEnd)
+    {
+        std::multimap<std::time_t,Notification*>* notifications = this->notificationLists_[this->queueList_[queue]];
         
         if(notifications == NULL)

code/branches/questsystem5/src/orxonox/overlays/notifications/NotificationManager.h

@@ -50 +50 @@
     /**
     @brief
-        The NotificationManager functions as a gateway between Notifications and NotificationQueues.
+        The Singleton NotificationManager functions as a gateway between Notifications and NotificationQueues.
         It receives, organizes Notifications and the redistributes them to the specific NotificationQueues.
     @author
@@ -57 +57 @@
     class _OrxonoxExport NotificationManager : public BaseObject
     {
+        protected:
+            NotificationManager();
+
         public:
-            NotificationManager(BaseObject* creator);
             virtual ~NotificationManager();
                 
@@ -64 +66 @@
             static const std::string NONE;
          
+            static NotificationManager & getInstance(); //! Returns a reference to the single instance of the NotificationManager.
+
             //TDO: Visibility?
-            static bool registerNotification(Notification* notification); //!< Registers a Notification within the NotificationManager.
-            static bool registerQueue(NotificationQueue* queue); //!< Registers a NotificationQueue within the NotificationManager.
+            bool registerNotification(Notification* notification); //!< Registers a Notification within the NotificationManager.
+            bool registerQueue(NotificationQueue* queue); //!< Registers a NotificationQueue within the NotificationManager.
             
-            static std::multimap<std::time_t,Notification*>* getNotifications(NotificationQueue* queue, const std::time_t & timeFrameStart, const std::time_t & timeFrameEnd); //!< Returns the Notifications for a specific NotificationQueue in a specified timeframe.
+            std::multimap<std::time_t,Notification*>* getNotifications(NotificationQueue* queue, const std::time_t & timeFrameStart, const std::time_t & timeFrameEnd); //!< Returns the Notifications for a specific NotificationQueue in a specified timeframe.
             
             /**
@@ -76 +80 @@
             @return Returns a time-ordered list of Notifications.
             */
-            static std::multimap<std::time_t,Notification*>* getNotifications(NotificationQueue* queue, const std::time_t & timeFrameStart)
-                { return NotificationManager::getNotifications(queue, timeFrameStart, std::time(0)); }
+            std::multimap<std::time_t,Notification*>* getNotifications(NotificationQueue* queue, const std::time_t & timeFrameStart)
+                { return this->getNotifications(queue, timeFrameStart, std::time(0)); }
             /**
             @brief Fetches the Notifications for a specific NotificationQueue starting at a specified timespan before now.
@@ -84 +88 @@
             @return Returns a time-ordered list of Notifications.
             */
-            static std::multimap<std::time_t,Notification*>* getNotifications(NotificationQueue* queue, int timeDelay)
-                { return NotificationManager::getNotifications(queue, std::time(0)-timeDelay, std::time(0)); }
+            std::multimap<std::time_t,Notification*>* getNotifications(NotificationQueue* queue, int timeDelay)
+                { return this->getNotifications(queue, std::time(0)-timeDelay, std::time(0)); }
      
-               private:
-            static int highestIndex_s; //!< This variable holds the highest index (resp. key) in notificationLists_s, to secure that  no key appears twice.
+        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 std::multimap<std::time_t,Notification*> allNotificationsList_s; //!< Container where all notifications are stored (together with their respecive timestamps).
-            static std::map<NotificationQueue*,int> queueList_s; //!< Container where all NotificationQueues are stored with a number as identifier.
-            static std::map<int,std::multimap<std::time_t,Notification*>*> notificationLists_s; //!< Container where all Notifications, for each identifier (associated with a NotificationQueue), are stored.
+            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/branches/questsystem5/src/orxonox/overlays/notifications/NotificationOverlay.cc

@@ -74 +74 @@
         this->setFont(this->queue_->getFont());
         this->setTextSize(this->queue_->getFontSize());
+
+        this->setPosition(this->queue_->getPosition());
     }
 

code/branches/questsystem5/src/orxonox/overlays/notifications/NotificationQueue.cc

@@ -46 +46 @@
     
     const std::string NotificationQueue::DEFAULT_FONT = "VeraMono";
+    const Vector2 NotificationQueue::DEFAULT_POSITION = Vector2(0.0,0.0);
 
     /**
@@ -78 +79 @@
         this->tickTime_ = 0.0;
         
-        NotificationManager::registerQueue(this);
+        NotificationManager::getInstance().registerQueue(this);
     }
     
@@ -90 +91 @@
         this->setNotificationLength(DEFAULT_LENGTH);
         this->setDisplayTime(DEFAULT_DISPLAY_TIME);
+        this->setPosition(DEFAULT_POSITION);
         
         this->setTargets(NotificationManager::ALL);
@@ -113 +115 @@
         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;
@@ -152 +155 @@
         this->clear();
     
-        std::multimap<std::time_t,Notification*>* notifications = NotificationManager::getNotifications(this, this->displayTime_);
+        std::multimap<std::time_t,Notification*>* notifications = NotificationManager::getInstance().getNotifications(this, this->displayTime_);
         
         if(notifications == NULL)
@@ -315 +318 @@
             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.
+        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);
@@ -333 +336 @@
     {
         this->font_ = font;
-        for (std::map<Notification*, NotificationOverlayContainer*>::iterator it = this->overlays_.begin(); it != this->overlays_.end(); ++it) //!< Set the font for each overlay.
+        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);
@@ -345 +348 @@
         {
             it->second->overlay->scroll(pos);
+        }
+    }
+
+    void NotificationQueue::positionChanged()
+    {
+        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++;
         }
     }

code/branches/questsystem5/src/orxonox/overlays/notifications/NotificationQueue.h

@@ -44 +44 @@
 #include <map>
 #include <ctime>
-#include "util/Math.h"
 
 #include "orxonox/overlays/OverlayGroup.h"
@@ -114 +113 @@
             inline int getDisplayTime() const
                 { return this->displayTime_; }
-                
             /**
-            @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.
+            @brief Returns the position of the NotificationQueue.
+            @return Returns the position.
             */
-            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.
-            
+            inline const Vector2 & getPosition() const
+                { return this->position_; }
             /**
             @brief Returns the font size used to display the Notifications.
@@ -135 +131 @@
             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.
+            
+            inline void setPosition(Vector2 pos)
+                { this->position_ = pos; this->positionChanged(); }
 
             void scroll(const Vector2 pos);
@@ -142 +149 @@
             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.02; //!< The default font size.
+            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.
@@ -149 +158 @@
             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.
@@ -172 +182 @@
             bool setFontSize(float size); //!< Set the font size.
             bool setFont(const std::string & font); //!< Set the font.
+
+            void positionChanged();
             
             void addNotification(Notification* notification, const std::time_t & time); //!< Add a notification to the queue.