Changeset 8453 for code/branches/tutoriallevel3/src/modules/notifications
- Timestamp:
- May 12, 2011, 12:31:23 AM (14 years ago)
- Location:
- code/branches/tutoriallevel3
- Files:
-
- 2 deleted
- 7 edited
- 2 copied
Legend:
- Unmodified
- Added
- Removed
-
code/branches/tutoriallevel3
- Property svn:mergeinfo changed
/code/branches/tutoriallevel (added) merged: 7828-7831,7894,8370 /code/branches/tutoriallevel2 (added) merged: 8371,8374,8376-8378,8444-8451
- Property svn:mergeinfo changed
-
code/branches/tutoriallevel3/src/modules/notifications/CMakeLists.txt
r7403 r8453 1 1 SET_SOURCE_FILES(NOTIFICATIONS_SRC_FILES 2 Notification.cc3 2 NotificationDispatcher.cc 4 3 NotificationManager.cc 5 4 NotificationQueue.cc 5 NotificationQueueCEGUI.cc 6 6 ) 7 7 … … 13 13 TOLUA_FILES 14 14 NotificationManager.h 15 NotificationQueue .h15 NotificationQueueCEGUI.h 16 16 PCH_FILE 17 17 NotificationsPrecompiledHeaders.h -
code/branches/tutoriallevel3/src/modules/notifications/NotificationDispatcher.cc
r7552 r8453 41 41 42 42 #include "infos/PlayerInfo.h" 43 #include "interfaces/NotificationListener.h" 43 44 #include "interfaces/PlayerTrigger.h" 44 45 #include "worldentities/pawns/Pawn.h" 45 46 #include "NotificationManager.h"47 46 48 47 namespace orxonox … … 61 60 RegisterObject(NotificationDispatcher); 62 61 63 this->sender_ = Notification Manager::NONE;62 this->sender_ = NotificationListener::NONE; 64 63 this->registerVariables(); 65 64 } … … 114 113 { 115 114 const std::string message = this->createNotificationMessage(); 116 NotificationManager::sendNotification(message, clientId, this->getSender()); 115 // TODO: Make the type configurable. 116 NotificationListener::sendNotification(message, this->getSender(), notificationMessageType::info, notificationSendMode::network, clientId); 117 117 } 118 118 else if(GameMode::isServer()) -
code/branches/tutoriallevel3/src/modules/notifications/NotificationManager.cc
r8079 r8453 36 36 #include "core/command/ConsoleCommand.h" 37 37 #include "core/CoreIncludes.h" 38 #include "core/GUIManager.h"39 38 #include "core/LuaState.h" 40 #include "network/Host.h"41 #include "network/NetworkFunction.h"42 39 #include "util/ScopedSingletonManager.h" 43 40 44 41 #include "interfaces/NotificationListener.h" 45 42 46 #include "Notification.h"47 43 #include "NotificationQueue.h" 48 49 #include "ToluaBindNotifications.h" 44 #include "NotificationQueueCEGUI.h" 50 45 51 46 namespace orxonox 52 47 { 53 48 54 const std::string NotificationManager::ALL("all");55 const std::string NotificationManager::NONE("none");56 57 // Register tolua_open function when loading the library.58 DeclareToluaInterface(Notifications);59 60 49 ManageScopedSingleton(NotificationManager, ScopeID::Root, false); 61 50 62 // Setting console command to enter the edit mode.63 SetConsoleCommand("enterEditMode", &NotificationManager::enterEditMode);64 65 registerStaticNetworkFunction(NotificationManager::sendNotification);66 67 51 /** 68 52 @brief … … 73 57 RegisterRootObject(NotificationManager); 74 58 75 this->highestIndex_ = 0;76 77 ModifyConsoleCommand("enterEditMode").setObject(this);78 79 59 COUT(3) << "NotificatioManager created." << std::endl; 80 60 } … … 86 66 NotificationManager::~NotificationManager() 87 67 { 88 ModifyConsoleCommand("enterEditMode").setObject(NULL);89 90 68 // Destroys all Notifications. 91 69 for(std::multimap<std::time_t, Notification*>::iterator it = this->allNotificationsList_.begin(); it!= this->allNotificationsList_.end(); it++) … … 106 84 while(it != this->queues_.end()) 107 85 { 108 it->second->destroy( true);86 it->second->destroy(); 109 87 it = this->queues_.begin(); 110 88 } … … 115 93 /** 116 94 @brief 117 Sends a Notification with the specified message to the specified client from the specified sender. 95 Creates and registers a Notification with the input message from the input sender. 96 This is called by the NotificationListener, whenever a new notification arrives. 118 97 @param message 119 The message that should be sent. 120 @param clientId 121 The id of the client the notification should be sent to. 98 The message of the new Notification. 122 99 @param sender 123 The sender that sent the notification. 124 @param isLocal 125 If this is set to true (false is default), then the Notification is sent to the client where this function is executed, meaning the Notification is sent locally. 126 */ 127 /*static*/ void NotificationManager::sendNotification(const std::string& message, unsigned int clientId, const std::string& sender, bool isLocal) 128 { 129 // If we're in standalone mode or we're already no the right client we create and send the Notification. 130 if(GameMode::isStandalone() || isLocal || Host::getPlayerID() == clientId) 131 { 132 Notification* notification = new Notification(message, sender); 133 if(NotificationManager::getInstance().registerNotification(notification)) 134 COUT(3) << "Notification \"" << notification->getMessage() << "\" sent." << std::endl; 135 } 136 // If we're on the server (and the server is not the intended recipient of the Notification) we send it over the network. 137 else if(GameMode::isServer()) 138 { 139 callStaticNetworkFunction(NotificationManager::sendNotification, clientId, message, clientId, sender); 140 } 141 } 142 143 /** 144 @brief 145 Registers a Notification within the NotificationManager and makes sure that the Notification is sent to all the NotificationListeners associated with its sender. 100 The name of the entity (of the collective) that sent the new Notification. 101 @param type 102 The type of the new Notification. 103 @return 104 Returns true if successful. 105 */ 106 bool NotificationManager::registerNotification(const std::string& message, const std::string& sender, notificationMessageType::Value type) 107 { 108 // TODO: Do something with the type. 109 Notification* notification = new Notification(message, sender, type); 110 return this->registerNotification(notification); 111 } 112 113 /** 114 @brief 115 Executes the input command from the input sender. 116 This is called by the NotificationListener, whenever a new command arrives. 117 @param command 118 The command to be executed, 119 @param sender 120 The The name of the entity (of the collective) that sent the command. 121 @return 122 Returns true if the command was successfully executed. 123 */ 124 bool NotificationManager::executeCommand(notificationCommand::Value command, const std::string& sender) 125 { 126 bool commandExecuted = false; 127 if(command == notificationCommand::clear) 128 { 129 if(this->commandClear(sender)) 130 commandExecuted = true; 131 } 132 133 if(commandExecuted) 134 COUT(3) << "Notification command \"" << NotificationListener::command2Str(command) << "\" executed." << endl; 135 136 return commandExecuted; 137 } 138 139 /** 140 @brief 141 The clear command. Clears all NotificationQueues that have its sender as a target. 142 @param sender 143 The sender of the clear command. 144 @return 145 Returns true if the command was successfully executed by at least one NotificationQueue, false if it was not executed. 146 */ 147 bool NotificationManager::commandClear(const std::string& sender) 148 { 149 bool all = (sender == NotificationListener::ALL); 150 bool executed = false; 151 // Clear all NotificationQueues that have the input sender as target. 152 for(std::map<const std::string, NotificationQueue*>::iterator it = this->queues_.begin(); it != this->queues_.end(); it++) // Iterate through all NotificationQueues. 153 { 154 const std::set<std::string>& set = it->second->getTargetsSet(); 155 // If either the sender is 'all', the NotificationQueue has as target all or the NotificationQueue has the input sender as a target. 156 if(all || set.find(NotificationListener::ALL) != set.end() || set.find(sender) != set.end()) 157 executed = it->second->tidy() || executed; 158 } 159 160 return executed; 161 } 162 163 /** 164 @brief 165 Registers a Notification within the NotificationManager and makes sure that the Notification is sent to all the NotificationQueues associated with its sender. 146 166 @param notification 147 167 The Notification to be registered. … … 158 178 this->allNotificationsList_.insert(std::pair<std::time_t, Notification*>(time, notification)); 159 179 160 if(notification->getSender() == Notification Manager::NONE) // If the sender has no specific name, then the Notification is only added to the list of all Notifications.180 if(notification->getSender() == NotificationListener::NONE) // If the sender has no specific name, then the Notification is only added to the list of all Notifications. 161 181 return true; 162 182 163 bool all = false; 164 if(notification->getSender() == NotificationManager::ALL) // If all are the sender, then the Notifications is added to every NotificationListener. 165 all = true; 166 167 // Insert the Notification in all NotificationListeners that have its sender as target. 168 for(std::map<NotificationListener*, unsigned int>::iterator it = this->listenerList_.begin(); it != this->listenerList_.end(); it++) // Iterate through all NotificationListeners. 169 { 170 const std::set<std::string>& set = it->first->getTargetsSet(); 171 bool bAll = set.find(NotificationManager::ALL) != set.end(); 172 // If either the Notification has as sender 'all', the NotificationListener displays all Notifications or the NotificationListener has the sender of the Notification as target. 183 // If all are the sender, then the Notifications is added to every NotificationQueue. 184 bool all = (notification->getSender() == NotificationListener::ALL); 185 186 // Insert the Notification in all NotificationQueues that have its sender as target. 187 for(std::map<const std::string, NotificationQueue*>::iterator it = this->queues_.begin(); it != this->queues_.end(); it++) // Iterate through all NotificationQueues. 188 { 189 const std::set<std::string>& set = it->second->getTargetsSet(); 190 bool bAll = set.find(NotificationListener::ALL) != set.end(); 191 // If either the Notification has as sender 'all', the NotificationQueue displays all Notifications or the NotificationQueue has the sender of the Notification as target. 173 192 if(all || bAll || set.find(notification->getSender()) != set.end()) 174 193 { 175 194 if(!bAll) 176 this->notificationLists_[it->second ]->insert(std::pair<std::time_t, Notification*>(time, notification)); // Insert the Notification in the notifications list of the current NotificationListener.177 it-> first->update(notification, time); // Update the NotificationListener.195 this->notificationLists_[it->second->getName()]->insert(std::pair<std::time_t, Notification*>(time, notification)); // Insert the Notification in the notifications list of the current NotificationQueue. 196 it->second->update(notification, time); // Update the NotificationQueue. 178 197 } 179 198 } … … 186 205 /** 187 206 @brief 188 Unregisters a Notification within the NotificationManager for a given Notification Listener.207 Unregisters a Notification within the NotificationManager for a given NotificationQueue. 189 208 @param notification 190 209 A pointer to the Notification to be unregistered. 191 @param listener192 A pointer to the Notification Listenerthe Notification is unregistered for.193 */ 194 void NotificationManager::unregisterNotification(Notification* notification, Notification Listener* listener)210 @param queue 211 A pointer to the NotificationQueue the Notification is unregistered for. 212 */ 213 void NotificationManager::unregisterNotification(Notification* notification, NotificationQueue* queue) 195 214 { 196 215 assert(notification); 197 assert( listener);198 199 // Remove the Notification from the list of Notifications of the input Notification Listener.200 this->removeNotification(notification, *(this->notificationLists_.find( this->listenerList_.find(listener)->second)->second));201 202 COUT(4) << "Notification (&" << notification << ") unregistered with the NotificationManager from listener (&" << listener << ")" << std::endl;216 assert(queue); 217 218 // Remove the Notification from the list of Notifications of the input NotificationQueue. 219 this->removeNotification(notification, *(this->notificationLists_.find(queue->getName())->second)); 220 221 COUT(4) << "Notification (&" << notification << ") unregistered with the NotificationManager from NotificationQueue " << queue->getName() << "." << std::endl; 203 222 } 204 223 … … 230 249 /** 231 250 @brief 232 Registers a NotificationListener within the NotificationManager. 233 @param listener 234 The NotificationListener to be registered. 235 @return 236 Returns true if successful. Fales if the NotificationListener is already registered. 237 */ 238 bool NotificationManager::registerListener(NotificationListener* listener) 239 { 240 assert(listener); 241 242 // If the NotificationListener is already registered. 243 if(this->listenerList_.find(listener) != this->listenerList_.end()) 244 return false; 245 246 this->highestIndex_ += 1; 247 unsigned int index = this->highestIndex_; // An identifier that identifies each registered NotificationListener uniquely. 248 249 this->listenerList_[listener] = index; // Add the NotificationListener to the list of NotificationListeners. 250 251 const std::set<std::string>& set = listener->getTargetsSet(); 252 253 // If all senders are the target of the NotificationListener, then the list of Notifications for that specific NotificationListener is the same as the list of all Notifications. 254 bool bAll = set.find(NotificationManager::ALL) != set.end(); 255 std::multimap<std::time_t, Notification*>* map = NULL; 256 if(bAll) 257 this->notificationLists_[index] = &this->allNotificationsList_; 258 // Else a new list (resp. multimap) is created and added to the list of Notification lists for NotificationListeners. 259 else 260 { 261 this->notificationLists_[index] = new std::multimap<std::time_t, Notification*>; 262 map = this->notificationLists_[index]; 263 } 264 265 // Iterate through all Notifications to determine whether any of them should belong to the newly registered NotificationListener. 266 for(std::multimap<std::time_t, Notification*>::iterator it = this->allNotificationsList_.begin(); it != this->allNotificationsList_.end(); it++) 267 { 268 if(!bAll && set.find(it->second->getSender()) != set.end()) // Checks whether the listener has the sender of the current Notification as target. 269 map->insert(std::pair<std::time_t, Notification*>(it->first, it->second)); 270 } 271 272 listener->update(); // Update the listener. 273 274 COUT(4) << "NotificationListener registered with the NotificationManager." << std::endl; 275 276 return true; 277 } 278 279 /** 280 @brief 281 Unregisters a NotificationListener within the NotificationManager. 282 @param listener 283 The NotificationListener to be unregistered. 284 */ 285 void NotificationManager::unregisterListener(NotificationListener* listener) 286 { 287 assert(listener); 288 289 unsigned int identifier = this->listenerList_.find(listener)->second; 290 std::multimap<std::time_t, Notification*>* map = this->notificationLists_.find(identifier)->second; 291 292 // If the map is not the map of all Notifications, make sure all Notifications are unregistered. 293 std::multimap<std::time_t, Notification*>::iterator it = map->begin(); 294 if(map != &this->allNotificationsList_) 295 { 296 while(it != map->end()) 297 { 298 this->unregisterNotification(it->second, listener); 299 it = map->begin(); 300 } 301 delete map; 302 } 303 304 COUT(4) << "NotificationListener '" << identifier << "' unregistered with the NotificationManager." << std::endl; 305 306 // Remove the NotificationListener from the list of NotificationListeners. 307 this->listenerList_.erase(listener); 308 // Remove the Notifications list that was associated with the input NotificationListener. 309 this->notificationLists_.erase(identifier); 310 } 311 312 /** 313 @brief 314 Fetches the Notifications for a specific NotificationListener in a specified timeframe and stores them in the input map. 315 @param listener 316 The NotificationListener the Notifications are fetched for. 251 Fetches the Notifications for a specific NotificationQueue in a specified timeframe and stores them in the input map. 252 @param queue 253 The NotificationQueue the Notifications are fetched for. 317 254 @param map 318 255 A pointer to a multimap, in which the notifications are stored. The map needs to have been allocated. … … 324 261 Returns true if successful. 325 262 */ 326 void NotificationManager::getNotifications(Notification Listener* listener, std::multimap<std::time_t,Notification*>* map, const std::time_t & timeFrameStart, const std::time_t & timeFrameEnd)327 { 328 assert( listener);263 void NotificationManager::getNotifications(NotificationQueue* queue, std::multimap<std::time_t,Notification*>* map, const std::time_t & timeFrameStart, const std::time_t & timeFrameEnd) 264 { 265 assert(queue); 329 266 assert(map); 330 267 331 std::multimap<std::time_t, Notification*>* notifications = this->notificationLists_[ this->listenerList_[listener]]; // All the Notifications for the input NotificationListener.268 std::multimap<std::time_t, Notification*>* notifications = this->notificationLists_[queue->getName()]; // All the Notifications for the input NotificationQueue. 332 269 333 270 std::multimap<std::time_t,Notification*>::iterator it, itLowest, itHighest; … … 342 279 /** 343 280 @brief 344 Enters the edit mode of the NotificationLayer. 345 */ 346 void NotificationManager::enterEditMode(void) 347 { 348 if(GameMode::showsGraphics()) 349 { 350 GUIManager::getInstance().hideGUI("NotificationLayer"); 351 GUIManager::getInstance().showGUI("NotificationLayer", false, false); 352 GUIManager::getInstance().getLuaState()->doString("NotificationLayer.enterEditMode()"); 281 Fetches the newest Notifications for a specific NotificationQueue and stores them in the input map. 282 @param queue 283 The NotificationQueue the Notifications are fetched for. 284 @param map 285 A pointer to a multimap, in which the notifications are stored. The map needs to have been allocated. 286 @param numberOfNotifications 287 The number of newest Notifications to be got. 288 @return 289 Returns true if successful. 290 */ 291 void NotificationManager::getNewestNotifications(NotificationQueue* queue, std::multimap<std::time_t, Notification*>* map, int numberOfNotifications) 292 { 293 assert(queue); 294 assert(map); 295 296 std::multimap<std::time_t, Notification*>* notifications = this->notificationLists_[queue->getName()]; // All the Notifications for the input NotificationQueue. 297 298 if(!notifications->empty()) // If the list of Notifications is not empty. 299 { 300 std::multimap<std::time_t,Notification*>::iterator it = notifications->end(); 301 for(int i = 0; i < numberOfNotifications; i++) // Iterate through the Notifications from the newest until we have the specified number of notifications. 302 { 303 it--; 304 map->insert(std::pair<std::time_t, Notification*>(it->first, it->second)); // Add the found Notifications to the map. 305 if(it == notifications->begin()) 306 break; 307 } 353 308 } 354 309 } … … 357 312 @brief 358 313 Registers a NotificationQueue. 359 This makes sure that the NotificationQueue can be a ttained through lua by name. It also makes sure that the NotificationQueue is destroyed upon destruction of the NotificationManager.314 This makes sure that the NotificationQueue can be accessed through lua by name. It also makes sure that the NotificationQueue is destroyed upon destruction of the NotificationManager. 360 315 @param queue 361 316 A pointer to the NotificationQueue to be registered. … … 365 320 bool NotificationManager::registerQueue(NotificationQueue* queue) 366 321 { 322 assert(queue); 323 324 // If the NotificationQueue is already registered. 325 if(this->queues_.find(queue->getName()) != this->queues_.end()) 326 return false; 327 328 this->queues_.insert(std::pair<const std::string, NotificationQueue*>(queue->getName(), queue)); // Add the NotificationQueue to the list of NotificationQueues. 329 330 const std::set<std::string>& set = queue->getTargetsSet(); 331 332 // If all senders are the target of the NotificationQueue, then the list of Notifications for that specific NotificationQueue is the same as the list of all Notifications. 333 bool bAll = set.find(NotificationListener::ALL) != set.end(); 334 std::multimap<std::time_t, Notification*>* map = NULL; 335 if(bAll) 336 this->notificationLists_[queue->getName()] = &this->allNotificationsList_; 337 // Else a new list (resp. multimap) is created and added to the list of Notification lists for NotificationQueues. 338 else 339 { 340 this->notificationLists_[queue->getName()] = new std::multimap<std::time_t, Notification*>; 341 map = this->notificationLists_[queue->getName()]; 342 } 343 344 // Iterate through all Notifications to determine whether any of them should belong to the newly registered NotificationQueue. 345 for(std::multimap<std::time_t, Notification*>::iterator it = this->allNotificationsList_.begin(); it != this->allNotificationsList_.end(); it++) 346 { 347 if(!bAll && set.find(it->second->getSender()) != set.end()) // Checks whether the listener has the sender of the current Notification as target. 348 map->insert(std::pair<std::time_t, Notification*>(it->first, it->second)); 349 } 350 351 queue->update(); // Update the queue. 352 367 353 COUT(4) << "NotificationQueue '" << queue->getName() << "' registered with the NotificationManager." << std::endl; 368 return t his->queues_.insert(std::pair<const std::string, NotificationQueue*>(queue->getName(), queue)).second;354 return true; 369 355 } 370 356 … … 377 363 void NotificationManager::unregisterQueue(NotificationQueue* queue) 378 364 { 365 assert(queue); 366 367 std::multimap<std::time_t, Notification*>* map = this->notificationLists_.find(queue->getName())->second; 368 369 // If the map is not the map of all Notifications, make sure all Notifications are unregistered. 370 std::multimap<std::time_t, Notification*>::iterator it = map->begin(); 371 if(map != &this->allNotificationsList_) 372 { 373 while(it != map->end()) 374 { 375 this->unregisterNotification(it->second, queue); 376 it = map->begin(); 377 } 378 delete map; 379 } 380 381 // Remove the NotificationQueue from the list of NotificationQueues. 382 this->queues_.erase(queue->getName()); 383 // Remove the Notifications list that was associated with the input NotificationQueue. 384 this->notificationLists_.erase(queue->getName()); 385 379 386 COUT(4) << "NotificationQueue '" << queue->getName() << "' unregistered with the NotificationManager." << std::endl; 380 this->queues_.erase(queue->getName());381 }382 383 /**384 @brief385 Loads all the NotificationQueues that should exist.386 */387 void NotificationManager::loadQueues(void)388 {389 new NotificationQueue("all");390 }391 392 /**393 @brief394 Creates a new NotificationQueue.395 This is used in lua.396 @param name397 The name of the new NotificationQueue.398 */399 void NotificationManager::createQueue(const std::string& name)400 {401 new NotificationQueue(name);402 387 } 403 388 … … 420 405 } 421 406 407 /** 408 @brief 409 Loads all the NotificationQueues that should exist. 410 */ 411 void NotificationManager::loadQueues(void) 412 { 413 NotificationQueueCEGUI* allQueue = new NotificationQueueCEGUI("all"); 414 allQueue->setDisplaySize(Vector2(0.5, 0)); 415 allQueue->setPosition(Vector4(0.0, 10, 0.3, 0)); 416 417 NotificationQueueCEGUI* infoQueue = new NotificationQueueCEGUI("info", "gameinfo", 1, -1); 418 infoQueue->setPosition(Vector4(0.2, 0, 0.8, 0)); 419 infoQueue->setFontSize(24); 420 infoQueue->setFontColor(Vector4(1.0, 1.0, 0.0, 0.8)); 421 infoQueue->setAlignment("HorzCentred"); 422 infoQueue->setDisplaySize(Vector2(0.6, 0.0)); 423 } 424 425 // Notification class 426 427 /** 428 @brief 429 Constructor. Creates a Notification with the input message and sender. 430 @param message 431 The message of the Notification. 432 @param sender 433 The sender of the Notification. 434 @param type 435 436 */ 437 Notification::Notification(const std::string& message, const std::string& sender, notificationMessageType::Value type) 438 { 439 this->initialize(); 440 this->message_ = message; 441 this->sender_ = sender; 442 this->type_ = type; 443 } 444 445 /** 446 @brief 447 Destructor. 448 */ 449 Notification::~Notification() 450 { 451 452 } 453 454 /** 455 @brief 456 Registers the object and sets some default values. 457 */ 458 void Notification::initialize(void) 459 { 460 this->message_.clear(); 461 this->sender_ = NotificationListener::NONE; 462 } 463 422 464 } -
code/branches/tutoriallevel3/src/modules/notifications/NotificationManager.h
r7552 r8453 42 42 #include <string> 43 43 44 #include "core/OrxonoxClass.h" 44 45 #include "util/Singleton.h" 45 #include " core/OrxonoxClass.h"46 #include "interfaces/NotificationListener.h" 46 47 47 48 namespace orxonox // tolua_export … … 50 51 /** 51 52 @brief 52 The Singleton NotificationManager functions as a gateway between @ref orxonox::Notification "Notifications" and @ref orxonox::NotificationListener "NotificationListeners". 53 It receives, organizes @ref orxonox::Notification "Notifications" and the redistributes them to the specific @ref orxonox::NotificationListener "NotificationListeners". 54 It also provides a static function to send @ref orxonox::Notification "Notifications" and works as a liaison between the @ref orxonox::NotificationQueue "NotificationQueues" and the GUI that displays notification, called NotificationLayer. 53 A Notification represents a short message used to inform the player about something that just happened. With the @ref orxonox::NotificationManager "NotificationManager" a Notification can be sent from any part of orxonox and is then displayed by the proper @ref orxonox::NotificationQueue "NotificationQueue(s)" (depending on which senders the specific @ref orxonox::NotificationQueue "NotificationQueues" accepts). 54 55 A Notification is just a data structure that is used internally by the Notifications module. 56 57 @author 58 Damian 'Mozork' Frick 59 60 @ingroup Notifications 61 */ 62 class _NotificationsExport Notification 63 { 64 public: 65 Notification(const std::string& message, const std::string& sender, notificationMessageType::Value type); 66 virtual ~Notification(); 67 68 /** 69 @brief Destroys the Notification. 70 */ 71 void destroy(void) 72 { delete this; } 73 74 /** 75 @brief Get the message of the Notification. 76 @return Returns the message of the Notification. 77 */ 78 inline const std::string & getMessage(void) const 79 { return this->message_; } 80 81 /** 82 @brief Get the sender of the Notification. 83 @return Returns the sender of the Notification. 84 */ 85 inline const std::string & getSender(void) const 86 { return this->sender_; } 87 88 /** 89 @brief Get the type of the Notification. 90 @return Returns an enum with the type of the Notification. 91 */ 92 inline notificationMessageType::Value getType(void) const 93 { return this->type_; } 94 95 private: 96 std::string message_; //!< The Notification message. 97 std::string sender_; //!< The sender of the notification. 98 notificationMessageType::Value type_; //!< The type of the notification. 99 100 void initialize(void); //!< Registers the object and sets some default values. 101 102 }; 103 104 /** 105 @brief 106 The Singleton NotificationManager is a NotificationListener and functions as a gateway between @ref orxonox::Notification "Notifications" and @ref orxonox::NotificationQueue "NotificationQueues". 107 It receives, organizes @ref orxonox::Notification "Notifications" and the redistributes them to the specific @ref orxonox::NotificationQueue "NotificationQueues". 108 It also works as a liaison between the @ref orxonox::NotificationQueue "NotificationQueues" and the GUI that displays notification, called NotificationLayer. 55 109 56 110 @author … … 60 114 */ 61 115 class _NotificationsExport NotificationManager // tolua_export 62 : public Singleton<NotificationManager>, public OrxonoxClass116 : public Singleton<NotificationManager>, public NotificationListener 63 117 { // tolua_export 64 118 friend class Singleton<NotificationManager>; … … 67 121 virtual ~NotificationManager(); 68 122 69 virtual void preDestroy(void); // !<Is called before the object is destroyed.123 virtual void preDestroy(void); // Is called before the object is destroyed. 70 124 71 125 /** … … 75 129 static NotificationManager& getInstance() { return Singleton<NotificationManager>::getInstance(); } // tolua_export 76 130 77 static const std::string ALL; //!< Static string to indicate a sender that sends to all NotificationListeners.78 static const std::string NONE; //!< Static string to indicare a sender that sends to no specific NotificationListener.131 virtual bool registerNotification(const std::string& message, const std::string& sender, notificationMessageType::Value type); 132 virtual bool executeCommand(notificationCommand::Value command, const std::string& sender); 79 133 80 //! Sends a Notification with the specified message to the specified client from the specified sender.81 static void sendNotification(const std::string& message, unsigned int clientId, const std::string& sender = NotificationManager::NONE, bool isLocal = false);134 bool registerNotification(Notification* notification); // Registers a Notification within the NotificationManager. 135 void unregisterNotification(Notification* notification, NotificationQueue* queue); // Unregisters a Notification within the NotificationManager for a given NotificationQueue. 82 136 83 bool registerNotification(Notification* notification); //!< Registers a Notification within the NotificationManager. 84 void unregisterNotification(Notification* notification, NotificationListener* listener); //!< Unregisters a Notification within the NotificationManager for a given NotificationListener. 85 bool registerListener(NotificationListener* listener); //!< Registers a NotificationListener within the NotificationManager. 86 void unregisterListener(NotificationListener* listener); //!< Unregisters a NotificationListener withing the NotificationManager. 87 88 void getNotifications(NotificationListener* listener, std::multimap<std::time_t, Notification*>* map, const std::time_t & timeFrameStart, const std::time_t & timeFrameEnd); //!< Fetches the Notifications for a specific NotificationListener in a specified timeframe and stores them in the input map. 137 void getNotifications(NotificationQueue* queue, std::multimap<std::time_t, Notification*>* map, const std::time_t & timeFrameStart, const std::time_t & timeFrameEnd); // Fetches the Notifications for a specific NotificationQueue in a specified timeframe and stores them in the input map. 89 138 90 139 /** 91 @brief Fetches the Notifications for a specific Notification Listener in a timeframe from now-timeDelayto now and stores them in the input map.92 @param listener The NotificationListenerthe Notifications are fetched for.140 @brief Fetches the Notifications for a specific NotificationQueue in a timeframe from (now-timeDelay) to now and stores them in the input map. 141 @param queue The NotificationQueue the Notifications are fetched for. 93 142 @param map A pointer to a multimap, in which the notifications are stored. The map needs to have been allocated. 94 143 @param timeDelay The timespan. 95 144 @return Returns true if successful. 96 145 */ 97 void getNotifications(Notification Listener* listener, std::multimap<std::time_t, Notification*>* map, int timeDelay)98 { this->getNotifications( listener, map, std::time(0)-timeDelay, std::time(0)); }146 void getNotifications(NotificationQueue* queue, std::multimap<std::time_t, Notification*>* map, int timeDelay) 147 { this->getNotifications(queue, map, std::time(0)-timeDelay, std::time(0)); } 99 148 100 void enterEditMode(void); //!< Enters the edit mode of the NotificationLayer.149 void getNewestNotifications(NotificationQueue* queue, std::multimap<std::time_t, Notification*>* map, int numberOfNotifications); // Fetches the newest Notifications for a specific NotificationQueue and stores them in the input map. 101 150 102 bool registerQueue(NotificationQueue* queue); // !<Registers a NotificationQueue.103 void unregisterQueue(NotificationQueue* queue); // !<Unregisters a NotificationQueue.151 bool registerQueue(NotificationQueue* queue); // Registers a NotificationQueue. 152 void unregisterQueue(NotificationQueue* queue); // Unregisters a NotificationQueue. 104 153 105 // tolua_begin 106 void loadQueues(void); //!< Loads all the NotificationQueues that should exist. 107 void createQueue(const std::string& name); //!< Creates a new NotificationQueue. 108 orxonox::NotificationQueue* getQueue(const std::string & name); //!< Get the NotificationQueue with the input name. 109 // tolua_end 154 void loadQueues(void); // tolua_export // Loads all the NotificationQueues that should exist. 155 156 NotificationQueue* getQueue(const std::string & name); // Get the NotificationQueue with the input name. 110 157 111 158 private: 112 159 static NotificationManager* singletonPtr_s; 113 160 114 unsigned int highestIndex_; //!< This variable holds the highest index (resp. key) in notificationLists_s, to secure that no key appears twice.115 116 161 std::multimap<std::time_t, Notification*> allNotificationsList_; //!< Container where all Notifications are stored. 117 std::map<NotificationListener*, unsigned int> listenerList_; //!< Container where all NotificationListeners are stored with a number as identifier. 118 std::map<int,std::multimap<std::time_t, Notification*>*> notificationLists_; //!< Container where all Notifications, for each identifier (associated with a NotificationListener), are stored. 162 std::map<const std::string, std::multimap<std::time_t, Notification*>*> notificationLists_; //!< Container where all Notifications, for each identifier (associated with a NotificationQueue), are stored. 119 163 120 164 std::map<const std::string, NotificationQueue*> queues_; //!< The list of NotificationQueues created by the NotificationManager. 121 165 122 bool removeNotification(Notification* notification, std::multimap<std::time_t, Notification*>& map); //!< Helper method that removes an input Notification form an input map. 166 bool removeNotification(Notification* notification, std::multimap<std::time_t, Notification*>& map); // Helper method that removes an input Notification form an input map. 167 168 // Commands 169 bool commandClear(const std::string& sender); // The clear command. Clears all NotificationQueues that have its sender as a target. 123 170 124 171 }; // tolua_export -
code/branches/tutoriallevel3/src/modules/notifications/NotificationQueue.cc
r8079 r8453 38 38 39 39 #include "core/CoreIncludes.h" 40 #include "core/GameMode.h"41 #include "core/GUIManager.h"42 #include "core/LuaState.h"43 #include "util/Convert.h"44 40 #include "util/SubString.h" 45 46 #include "Notification.h"47 41 48 42 namespace orxonox … … 56 50 @param senders 57 51 The senders that are targets of this NotificationQueue, i.e. the names of senders whose Notifications this NotificationQueue displays. 58 The senders need to be sep erated by commas.52 The senders need to be separated by commas. 59 53 @param size 60 54 The size (the maximum number of displayed Notifications) of this NotificationQueue. … … 88 82 } 89 83 90 this->create(); // Creates the NotificationQueue in lua. 91 92 // Register the NotificationQueue as NotificationListener with the NotificationManager. 93 bool listenerRegistered = NotificationManager::getInstance().registerListener(this); 94 if(!listenerRegistered) // If the registration has failed. 95 { 96 this->registered_ = false; 97 // Remove the NotificationQueue in lua. 98 if(GameMode::showsGraphics()) 99 GUIManager::getInstance().getLuaState()->doString("NotificationLayer.removeQueue(\"" + this->getName() + "\")"); 84 COUT(3) << "NotificationQueue '" << this->getName() << "' created." << std::endl; 85 } 86 87 /** 88 @brief 89 Destructor. 90 */ 91 NotificationQueue::~NotificationQueue() 92 { 93 this->targets_.clear(); 94 95 if(this->registered_) // If the NotificationQueue is registered. 96 { 97 this->clear(true); 98 99 // Unregister with the NotificationManager. 100 100 NotificationManager::getInstance().unregisterQueue(this); 101 COUT(1) << "Error: NotificationQueue '" << this->getName() << "' could not be registered." << std::endl; 102 return; 103 } 104 105 COUT(3) << "NotificationQueue '" << this->getName() << "' created." << std::endl; 106 } 107 108 /** 109 @brief 110 Destructor. 111 */ 112 NotificationQueue::~NotificationQueue() 113 { 114 this->targets_.clear(); 115 116 if(this->registered_) // If the NotificationQueue is registered. 117 { 118 this->clear(true); 119 120 // Unregister with the NotificationManager. 121 NotificationManager::getInstance().unregisterListener(this); 122 NotificationManager::getInstance().unregisterQueue(this); 123 } 124 } 125 126 /** 127 @brief 128 Destroys the NotificationQueue. 129 Used in lua and NotificationManager. 130 @param noGraphics 131 If this is set to true (false is default), then the queue is not removed in lua. This is used to destroy the queue, after the GUIManager has been destroyed. 132 */ 133 void NotificationQueue::destroy(bool noGraphics) 134 { 135 // Remove the NotificationQueue in lua. 136 if(GameMode::showsGraphics() && !noGraphics) 137 GUIManager::getInstance().getLuaState()->doString("NotificationLayer.removeQueue(\"" + this->getName() + "\")"); 138 101 } 102 139 103 COUT(3) << "NotificationQueue '" << this->getName() << "' destroyed." << std::endl; 140 141 this->OrxonoxClass::destroy();142 }143 144 /**145 @brief146 Creates the NotificationQueue in lua.147 */148 void NotificationQueue::create(void)149 {150 if(GameMode::showsGraphics())151 GUIManager::getInstance().getLuaState()->doString("NotificationLayer.createQueue(\"" + this->getName() + "\", " + multi_cast<std::string>(this->getMaxSize()) + ")");152 104 } 153 105 … … 161 113 { 162 114 this->tickTime_ += dt; // Add the time interval that has passed to the time counter. 163 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.115 if(this->displayTime_ != INF && this->tickTime_ >= 1.0) // If the time counter is greater than 1s all Notifications that have expired are removed, if it is smaller we wait to the next tick. 164 116 { 165 117 this->timeLimit_.time = std::time(0)-this->displayTime_; // Container containig the current time. … … 181 133 Updates the NotificationQueue. 182 134 Updates by clearing the queue and requesting all relevant Notifications from the NotificationManager and inserting them into the queue. 135 This is called by the NotificationManager when the Notifications have changed so much, that the NotificationQueue may have to re-initialize his operations. 183 136 */ 184 137 void NotificationQueue::update(void) … … 188 141 std::multimap<std::time_t, Notification*>* notifications = new std::multimap<std::time_t, Notification*>; 189 142 // Get the Notifications sent in the interval from now to now minus the display time. 190 NotificationManager::getInstance().getNotifications(this, notifications, this->displayTime_); 143 if(this->displayTime_ == INF) 144 NotificationManager::getInstance().getNewestNotifications(this, notifications, this->getMaxSize()); 145 else 146 NotificationManager::getInstance().getNotifications(this, notifications, this->displayTime_); 191 147 192 148 if(!notifications->empty()) … … 246 202 this->notifications_.insert(this->notifications_.begin(), container); 247 203 248 // Push the Notification to the GUI. 249 if(GameMode::showsGraphics()) 250 GUIManager::getInstance().getLuaState()->doString("NotificationLayer.pushNotification(\"" + this->getName() + "\", \"" + notification->getMessage() + "\")"); 204 // Inform that a Notification was pushed. 205 this->notificationPushed(notification); 251 206 252 207 COUT(5) << "Notification \"" << notification->getMessage() << "\" pushed to NotificationQueue '" << this->getName() << "'" << endl; 208 COUT(3) << "NotificationQueue \"" << this->getName() << "\": " << notification->getMessage() << endl; 253 209 } 254 210 … … 279 235 delete container; 280 236 281 // Pops the Notification from the GUI. 282 if(GameMode::showsGraphics()) 283 GUIManager::getInstance().getLuaState()->doString("NotificationLayer.popNotification(\"" + this->getName() + "\")"); 237 // Inform that a Notification was popped. 238 this->notificationPopped(); 284 239 } 285 240 … … 305 260 delete *containerIterator; 306 261 307 // Removes the Notification from the GUI.308 if(GameMode::showsGraphics())309 GUIManager::getInstance().getLuaState()->doString("NotificationLayer.removeNotification(\"" + this->getName() + "\", " + multi_cast<std::string>(index) + ")");262 // TODO: index automatically cast? 263 // Inform that a Notification was removed. 264 this->notificationRemoved(index); 310 265 } 311 266 … … 314 269 Clears the NotificationQueue by removing all NotificationContainers. 315 270 @param noGraphics 316 If this is eset to true the GUI is not informed of the clearing of the NotificationQueue. This is needed only internally.271 If this is set to true the GUI is not informed of the clearing of the NotificationQueue. This is needed only internally. 317 272 */ 318 273 void NotificationQueue::clear(bool noGraphics) … … 326 281 this->notifications_.clear(); 327 282 this->size_ = 0; 328 329 // Clear the NotificationQueue in the GUI.330 if(GameMode::showsGraphics() && !noGraphics)331 GUIManager::getInstance().getLuaState()->doString("NotificationLayer.clearQueue(\"" + this->getName() + "\")");332 283 } 333 284 … … 364 315 Sets the maximum number of seconds a Notification is displayed. 365 316 @param time 366 The number of seconds the Notifications is displayed. 367 @return 368 Returns true if successful. 369 */ 370 void NotificationQueue::setDisplayTime(unsigned int time) 317 The number of seconds a Notification is displayed. 318 */ 319 void NotificationQueue::setDisplayTime(int time) 371 320 { 372 321 if(this->displayTime_ == time) … … 381 330 /** 382 331 @brief 383 Produces all targets of the NotificationQueue concat inated as string, with commas (',') as seperators.332 Produces all targets of the NotificationQueue concatenated as string, with commas (',') as separators. 384 333 @return 385 334 Returns the targets as a string. … … 407 356 The targets are the senders whose Notifications are displayed in this queue. 408 357 @param targets 409 Accepts a string of targets, each sep erated by commas (','), spaces are ignored.358 Accepts a string of targets, each separated by commas (','), spaces are ignored. 410 359 */ 411 360 void NotificationQueue::setTargets(const std::string & targets) … … 417 366 this->targets_.insert(string[i]); 418 367 368 // TODO: Why? 419 369 if(this->registered_) 420 370 { 421 NotificationManager::getInstance().unregisterListener(this); 422 NotificationManager::getInstance().registerListener(this); 423 } 371 NotificationManager::getInstance().unregisterQueue(this); 372 NotificationManager::getInstance().registerQueue(this); 373 } 374 } 375 376 /** 377 @brief 378 Pops all Notifications from the NotificationQueue. 379 @return 380 Returns true if successful, false if not. 381 */ 382 bool NotificationQueue::tidy(void) 383 { 384 while(this->size_ > 0) 385 this->pop(); 386 return true; 424 387 } 425 388 -
code/branches/tutoriallevel3/src/modules/notifications/NotificationQueue.h
r7552 r8453 46 46 47 47 #include "tools/interfaces/Tickable.h" 48 #include "interfaces/NotificationListener.h"49 48 50 namespace orxonox // tolua_export51 { // tolua_export49 namespace orxonox 50 { 52 51 53 52 /** … … 78 77 Displays @ref orxonox::Notification "Notifications" from specific senders. 79 78 80 There are quite some parameters that influence the behavio ur of the NotificationQueue:79 There are quite some parameters that influence the behavior of the NotificationQueue: 81 80 - @b name The name of the NotificationQueue. It needs to be unique. 82 81 - @b senders The senders that are targets of this NotificationQueue, i.e. the names of senders whose Notifications this NotificationQueue displays. … … 89 88 @ingroup Notifications 90 89 */ 91 class _NotificationsExport NotificationQueue // tolua_export 92 : public Tickable, public NotificationListener 93 { // tolua_export 90 class _NotificationsExport NotificationQueue : public Tickable 91 { 94 92 95 93 public: 96 NotificationQueue(const std::string& name, const std::string& senders = Notification Manager::ALL, unsigned int size = NotificationQueue::DEFAULT_SIZE, unsigned int displayTime = NotificationQueue::DEFAULT_DISPLAY_TIME);94 NotificationQueue(const std::string& name, const std::string& senders = NotificationListener::ALL, unsigned int size = NotificationQueue::DEFAULT_SIZE, unsigned int displayTime = NotificationQueue::DEFAULT_DISPLAY_TIME); 97 95 virtual ~NotificationQueue(); 98 99 //! Destroys the NotificationQueue.100 void destroy(bool noGraphics = false); // tolua_export101 96 102 97 virtual void tick(float dt); //!< To update from time to time. … … 121 116 { return this->maxSize_; } 122 117 123 void setDisplayTime( unsignedint time); //!< Sets the maximum number of seconds a Notification is displayed.118 void setDisplayTime(int time); //!< Sets the maximum number of seconds a Notification is displayed. 124 119 /** 125 120 @brief Returns the time interval the Notification is displayed. 126 121 @return Returns the display time. 127 122 */ 128 inline unsignedint getDisplayTime() const123 inline int getDisplayTime() const 129 124 { return this->displayTime_; } 130 125 // tolua_end … … 144 139 { return this->targets_; } 145 140 146 // tolua_begin147 141 void setTargets(const std::string & targets); //!< Set the targets of this NotificationQueue. 148 const std::string& getTargets(void) const; //!< Returns a string consisting of the concatination of the targets. 149 // tolua_end 142 const std::string& getTargets(void) const; //!< Returns a string consisting of the concatenation of the targets. 143 144 bool tidy(void); // Pops all Notifications from the NotificationQueue. 145 146 protected: 147 /** 148 @brief Is called when a notification was pushed. 149 @param notification The Notification that was pushed. 150 */ 151 virtual void notificationPushed(Notification* notification) {} 152 /** 153 @brief Is called when a notification was popped. 154 */ 155 virtual void notificationPopped(void) {} 156 /** 157 @brief Is called when a notification was removed. 158 @param index The index the removed notification was at. 159 */ 160 virtual void notificationRemoved(unsigned int index) {} 161 162 virtual void clear(bool noGraphics = false); //!< Clears the NotificationQueue by removing all NotificationContainers. 163 164 protected: 165 static const unsigned int DEFAULT_SIZE = 5; //!< The default maximum number of Notifications displayed. 166 static const unsigned int DEFAULT_DISPLAY_TIME = 30; //!< The default display time. 167 static const int INF = -1; //!< Constant denoting infinity. 150 168 151 169 private: 152 static const unsigned int DEFAULT_SIZE = 5; //!< The default maximum number of Notifications displayed.153 static const unsigned int DEFAULT_DISPLAY_TIME = 30; //!< The default display time.154 155 170 std::string name_; //!< The name of the NotificationQueue. 156 171 157 172 unsigned int maxSize_; //!< The maximal number of Notifications displayed. 158 173 unsigned int size_; //!< The number of Notifications displayed. 159 unsignedint displayTime_; //!< The time a Notification is displayed.174 int displayTime_; //!< The time a Notification is displayed. 160 175 161 176 bool registered_; //!< Helper variable to remember whether the NotificationQueue is registered already. … … 169 184 NotificationContainer timeLimit_; //!< Helper object to check against to determine whether Notifications have expired. 170 185 171 void create(void); //!< Creates the NotificationQueue in lua.172 173 186 void setName(const std::string& name); //!< Sets the name of the NotificationQueue. 174 187 … … 177 190 void remove(const std::multiset<NotificationContainer*, NotificationContainerCompare>::iterator& containerIterator); //!< Removes the Notification that is stored in the input NotificationContainer. 178 191 179 void clear(bool noGraphics = false); //!< Clears the NotificationQueue by removing all NotificationContainers.192 }; 180 193 181 }; // tolua_export 194 } 182 195 183 } // tolua_export 184 185 #endif /* _NotificationOverlay_H__ */ 196 #endif /* _NotificationQueue_H__ */
Note: See TracChangeset
for help on using the changeset viewer.