Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/branches/tutorial3/src/modules/notifications/NotificationQueue.h @ 10904

Last change on this file since 10904 was 8706, checked in by dafrick, 13 years ago

Merging presentation branch back into trunk.
There are many new features and also a lot of other changes and bugfixes, if you want to know, digg through the svn log.
Not everything is yet working as it should, but it should be fairly stable. If you habe any bug reports, just send me an email.

  • Property svn:eol-style set to native
File size: 8.8 KB
Line 
1/*
2 *   ORXONOX - the hottest 3D action shooter ever to exist
3 *                    > www.orxonox.net <
4 *
5 *
6 *   License notice:
7 *
8 *   This program is free software; you can redistribute it and/or
9 *   modify it under the terms of the GNU General Public License
10 *   as published by the Free Software Foundation; either version 2
11 *   of the License, or (at your option) any later version.
12 *
13 *   This program is distributed in the hope that it will be useful,
14 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
15 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 *   GNU General Public License for more details.
17 *
18 *   You should have received a copy of the GNU General Public License
19 *   along with this program; if not, write to the Free Software
20 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
21 *
22 *   Author:
23 *      Damian 'Mozork' Frick
24 *   Co-authors:
25 *      ...
26 *
27 */
28
29/**
30    @file NotificationQueue.h
31    @brief Definition of the NotificationQueue class.
32    @ingroup Notifications
33*/
34
35#ifndef _NotificationOueue_H__
36#define _NotificationOueue_H__
37
38#include "notifications/NotificationsPrereqs.h"
39
40#include <ctime>
41#include <set>
42#include <string>
43#include <vector>
44
45#include "NotificationManager.h"
46
47#include "core/BaseObject.h"
48#include "tools/interfaces/Tickable.h"
49#include "network/synchronisable/Synchronisable.h"
50
51namespace orxonox
52{
53
54    /**
55    @brief
56        Container to allow easy handling of the @ref orxonox::Notification "Notifications".
57
58    @ingroup Notifications
59    */
60    struct NotificationContainer
61    {
62        Notification* notification; //!< The Notification displayed.
63        time_t time; //!< The time the Notification was sent and thus first displayed.
64    };
65
66    /**
67    @brief
68        Struct to allow ordering of @ref orxonox::NotificationContainer "NotificationContainers".
69
70    @ingroup Notifications
71    */
72    struct NotificationContainerCompare {
73        bool operator() (const NotificationContainer* const & a, const NotificationContainer* const & b) const
74            { return a->time < b->time; } //!< Ordering by time.
75    };
76
77    /**
78    @brief
79        Displays @ref orxonox::Notification "Notifications" from specific senders.
80
81        There are quite some parameters that influence the behavior of the NotificationQueue:
82        - @b name The name of the NotificationQueue. It needs to be unique.
83        - @b senders The senders that are targets of this NotificationQueue, i.e. the names of senders whose Notifications this NotificationQueue displays.
84        - @b size The size of the NotificationQueue, it specifies how many @ref orxonox::Notification "Notifications" are displayed at once at the most.
85        - @b displayTime The time a @ref orxonox::Notification "Notification" is displayed with this NotificationQueue.
86
87    @author
88        Damian 'Mozork' Frick
89
90    @ingroup Notifications
91    */
92    class _NotificationsExport NotificationQueue : public BaseObject, public Tickable, public Synchronisable
93    {
94
95        public:
96            NotificationQueue(BaseObject* creator);
97            virtual ~NotificationQueue();
98
99            virtual void tick(float dt); // To update from time to time.
100            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
101
102            virtual void changedName(void);
103           
104            void update(void); // Updates the NotificationQueue.
105            void update(Notification* notification, const std::time_t & time); // Updates the NotificationQueue by adding an new Notification.
106
107            // tolua_begin
108            /**
109            @brief Get the name of the NotificationQueue.
110            @return Returns the name.
111            */
112            inline const std::string& getName(void) const
113                { return this->BaseObject::getName(); }
114
115            void setMaxSize(unsigned int size); // Sets the maximum number of displayed Notifications.
116            /**
117            @brief Returns the maximum number of Notifications displayed.
118            @return Returns maximum size.
119            */
120            inline unsigned int getMaxSize(void) const
121                { return this->maxSize_; }
122
123            void setDisplayTime(int time); // Sets the maximum number of seconds a Notification is displayed.
124            /**
125            @brief Returns the time interval the Notification is displayed.
126            @return Returns the display time.
127            */
128            inline int getDisplayTime(void) const
129                { return this->displayTime_; }
130            // tolua_end
131            void maxSizeChanged(void); // Is called when the maximum number of displayed Notifications has changed.
132            void displayTimeChanged(void);
133
134            /**
135            @brief Returns the current number of Notifications displayed.
136            @return Returns the size of the NotificationQueue.
137            */
138            inline unsigned int getSize(void) const
139                { return this->size_; }
140
141            /**
142            @brief Returns the targets of this NotificationQueue, reps. the senders which Notifications are displayed in this NotificationQueue.
143            @return Returns a set of strings holding the different targets.
144            */
145            inline const std::set<std::string> & getTargetsSet(void)
146                { return this->targets_; }
147
148            void setTargets(const std::string & targets); // Set the targets of this NotificationQueue.
149            const std::string& getTargets(void) const; // Returns a string consisting of the concatenation of the targets.
150            void targetsChanged(void); // Is called when the NotificationQueue's targets have changed.
151
152            /**
153            @brief Check whether the NotificationQueue is registered with the NotificationManager.
154            @return Returns true if it is registered, false if not.
155            */
156            inline bool isRegistered(void)
157                { return this->registered_; }
158
159            bool tidy(void); // Pops all Notifications from the NotificationQueue.
160           
161        protected:
162            void registerVariables();
163           
164            /**
165            @brief Is called when a notification was pushed.
166            @param notification The Notification that was pushed.
167            */
168            virtual void notificationPushed(Notification* notification) {}
169            /**
170            @brief Is called when a notification was popped.
171            */
172            virtual void notificationPopped(void) {}
173            /**
174            @brief Is called when a notification was removed.
175            @param index The index the removed notification was at.
176            */
177            virtual void notificationRemoved(unsigned int index) {}
178           
179            virtual void clear(bool noGraphics = false); // Clears the NotificationQueue by removing all NotificationContainers.
180
181        protected:
182            static const unsigned int DEFAULT_SIZE = 5; //!< The default maximum number of Notifications displayed.
183            static const unsigned int DEFAULT_DISPLAY_TIME = 30; //!< The default display time.
184            static const int INF = -1; //!< Constant denoting infinity.
185
186            virtual void create(void); // Creates the NotificationQueue.
187
188        private:
189            time_t creationTime_; //!< The time this NotificationQueue was created.
190           
191            unsigned int maxSize_; //!< The maximal number of Notifications displayed.
192            unsigned int size_; //!< The number of Notifications displayed.
193            int displayTime_; //!< The time a Notification is displayed.
194
195            bool registered_; //!< Helper variable to remember whether the NotificationQueue is registered already.
196
197            std::set<std::string> targets_; //!< The targets the NotificationQueue displays Notifications of.
198
199            std::multiset<NotificationContainer*, NotificationContainerCompare> ordering_; //!< The NotificationContainers ordered by the time they were registered.
200            std::vector<NotificationContainer*> notifications_; //!< The NotificationContainers in the order they were added to the NotificationQueue.
201
202            float tickTime_; //!< Helper variable, to not have to check for Notifications that have been displayed too long, every tick.
203            NotificationContainer timeLimit_; //!< Helper object to check against to determine whether Notifications have expired.
204
205            void setName(const std::string& name); //!< Sets the name of the NotificationQueue.
206
207            void push(Notification* notification, const std::time_t & time); // Adds (pushes) a Notification to the NotificationQueue.
208            void pop(void); // Removes (pops) the least recently added Notification form the NotificationQueue.
209            void remove(const std::multiset<NotificationContainer*, NotificationContainerCompare>::iterator& containerIterator); // Removes the Notification that is stored in the input NotificationContainer.
210
211    };
212
213}
214
215#endif /* _NotificationQueue_H__ */
Note: See TracBrowser for help on using the repository browser.