TheCloud/panda3d
1
0
Fork 0
mirror of https://github.com/panda3d/panda3d.git synced 2025-10-19 13:15:00 -04:00
Code Issues Packages Projects Releases Wiki Activity

dynamic event queue

Browse Source
This commit is contained in:
David Rose 2004-08-02 23:20:26 +00:00
parent f51f95b9bd
commit cdfdf30f97
2 changed files with 39 additions and 44 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

61
panda/src/event/eventQueue.cxx
View File

@ -18,13 +18,14 @@
#include "eventQueue.h" #include "eventQueue.h"
#include "config_event.h" #include "config_event.h"
#include "mutexHolder.h"
EventQueue *EventQueue::_global_event_queue = NULL; EventQueue *EventQueue::_global_event_queue = NULL;
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
// Function: EventQueue::Constructor // Function: EventQueue::Constructor
// Access: Public // Access: Published
// Description: // Description:
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
EventQueue:: EventQueue::
@ -33,7 +34,7 @@ EventQueue() {
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
// Function: EventQueue::Destructor // Function: EventQueue::Destructor
// Access: Public // Access: Published
// Description: // Description:
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
EventQueue:: EventQueue::
@ -42,74 +43,76 @@ EventQueue::
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
// Function: EventQueue::queue_event // Function: EventQueue::queue_event
// Access: Public // Access: Published
// Description: // Description:
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
void EventQueue:: void EventQueue::
queue_event(CPT_Event event) { queue_event(CPT_Event event) {
nassertv(!event.is_null()); nassertv(!event.is_null());
#ifdef OLD_HAVE_IPC MutexHolder holder(_lock);
mutex_lock lock(_lock);
#endif _queue.push_back(event);
if (_queue.full()) { if (event_cat.is_spam() || event_cat.is_debug()) {
event_cat.error() if (event->get_name() == "NewFrame") {
<< "Ignoring event " << *event << "; event queue full.\n"; // Don't bother us with this particularly spammy event.
} else { event_cat.spam()
_queue.push_back(event); << "Throwing event " << *event << "\n";
if (event_cat.is_spam() || event_cat.is_debug()) { } else {
if (event->get_name() == "NewFrame") { event_cat.debug()
// Don't bother us with this particularly spammy event. << "Throwing event " << *event << "\n";
event_cat.spam()
<< "Throwing event " << *event << "\n";
} else {
event_cat.debug()
<< "Throwing event " << *event << "\n";
}
} }
} }
} }
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
// Function: EventQueue::clear // Function: EventQueue::clear
// Access: Public // Access: Published
// Description: Empties all events on the queue, throwing them on the // Description: Empties all events on the queue, throwing them on the
// floor. // floor.
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
void EventQueue:: void EventQueue::
clear() { clear() {
while (!_queue.empty()) { MutexHolder holder(_lock);
_queue.pop_front();
} _queue.clear();
} }
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
// Function: EventQueue::is_queue_empty // Function: EventQueue::is_queue_empty
// Access: Public // Access: Published
// Description: // Description:
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
bool EventQueue:: bool EventQueue::
is_queue_empty() const { is_queue_empty() const {
MutexHolder holder(_lock);
return _queue.empty(); return _queue.empty();
} }
////////////////////////////////////////////////////////////////////
// Function: EventQueue::is_queue_full
// Access: Published
// Description: This function is deprecated--the queue is never full
// these days.
////////////////////////////////////////////////////////////////////
bool EventQueue:: bool EventQueue::
is_queue_full() const { is_queue_full() const {
return _queue.full(); return false;
} }
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
// Function: EventQueue::dequeue_event // Function: EventQueue::dequeue_event
// Access: Public // Access: Published
// Description: // Description:
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
CPT_Event EventQueue:: CPT_Event EventQueue::
dequeue_event() { dequeue_event() {
// We need no mutex protection here, as long as there is only one MutexHolder holder(_lock);
// thread extracting events. The magic of circular buffers.
CPT_Event result = _queue.front(); CPT_Event result = _queue.front();
_queue.pop_front(); _queue.pop_front();
nassertr(!result.is_null(), result); nassertr(!result.is_null(), result);
return result; return result;
} }

22
panda/src/event/eventQueue.h
View File

@ -23,12 +23,8 @@
#include "event.h" #include "event.h"
#include "pt_Event.h" #include "pt_Event.h"
#include "pmutex.h"
#include "circBuffer.h" #include "pdeque.h"
#ifdef OLD_HAVE_IPC
#include <ipc_mutex.h>
#endif
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
// Class : EventQueue // Class : EventQueue
@ -38,9 +34,6 @@
// processed. // processed.
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
class EXPCL_PANDA EventQueue { class EXPCL_PANDA EventQueue {
public:
enum { max_events = 500 };
PUBLISHED: PUBLISHED:
EventQueue(); EventQueue();
~EventQueue(); ~EventQueue();
@ -54,15 +47,14 @@ PUBLISHED:
INLINE static EventQueue *get_global_event_queue(); INLINE static EventQueue *get_global_event_queue();
protected: private:
CircBuffer<CPT_Event, max_events> _queue;
static void make_global_event_queue(); static void make_global_event_queue();
static EventQueue *_global_event_queue; static EventQueue *_global_event_queue;
#ifdef OLD_HAVE_IPC typedef pdeque<CPT_Event> Events;
mutex _lock; Events _queue;
#endif
Mutex _lock;
}; };
#include "eventQueue.I" #include "eventQueue.I"