Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/trunk/src/modules/notifications/NotificationQueue.h @ 12209

Last change on this file since 12209 was 11071, checked in by landauf, 9 years ago

merged branch cpp11_v3 back to trunk

  • Property svn:eol-style set to native
File size: 8.9 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(Context* context);
97            virtual ~NotificationQueue();
98
99            virtual void tick(float dt) override; // To update from time to time.
100            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
101
102            virtual void changedName(void) override;
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.