aboutsummaryrefslogtreecommitdiffstats
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/menu/application.cpp20
-rw-r--r--src/menu/event_manager.cpp106
-rw-r--r--src/menu/event_manager.hpp128
3 files changed, 250 insertions, 4 deletions
diff --git a/src/menu/application.cpp b/src/menu/application.cpp
index 00b9a6f3..670e4c77 100644
--- a/src/menu/application.cpp
+++ b/src/menu/application.cpp
@@ -25,6 +25,7 @@
*/
#include "application.hpp"
+#include "event_manager.hpp"
#include <exception>
namespace usdx
@@ -84,6 +85,8 @@ namespace usdx
void Application::main_loop(SDL_Surface* display)
{
SDL_Event event;
+ EventManager event_manager;
+ boost::thread event_thread(boost::bind(&EventManager::handle_events, &event_manager));
running = true;
while (running) {
@@ -94,17 +97,26 @@ namespace usdx
LOG4CXX_TRACE(log, L"repaint");
// poll current events
- while (SDL_PollEvent(&event)) {
+ while (event_manager.available() && SDL_PollEvent(&event)) {
switch (event.type) {
case SDL_QUIT:
running = false;
- return;
+ event_thread.interrupt();
+ break;
+
+ default:
+ event_manager.add_event(event);
+ break;
}
}
- // limit frames
- SDL_framerateDelay(fps_manager);
+ if (running) {
+ // limit frames
+ SDL_framerateDelay(fps_manager);
+ }
}
+
+ event_thread.join();
}
void Application::run(void)
diff --git a/src/menu/event_manager.cpp b/src/menu/event_manager.cpp
new file mode 100644
index 00000000..990df875
--- /dev/null
+++ b/src/menu/event_manager.cpp
@@ -0,0 +1,106 @@
+/*
+ * UltraStar Deluxe - Karaoke Game
+ *
+ * UltraStar Deluxe is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ *
+ * $URL$
+ * $Id$
+ */
+
+#include "event_manager.hpp"
+#include <iostream>
+
+namespace usdx
+{
+ log4cxx::LoggerPtr EventManager::log =
+ log4cxx::Logger::getLogger("usdx.menu.event_manager");
+
+ EventManager::EventManager(int capacity) :
+ buffer(capacity), waiting(0)
+ {
+ }
+
+ EventManager::~EventManager(void)
+ {
+ }
+
+ bool EventManager::is_not_full() const
+ {
+ return waiting < buffer.capacity();
+ }
+
+ bool EventManager::is_not_empty() const
+ {
+ return waiting > 0;
+ }
+
+ void EventManager::add_event(const SDL_Event& event)
+ {
+ boost::mutex::scoped_lock lock(mutex);
+
+ not_full.wait(lock, boost::bind(&EventManager::is_not_full, this));
+
+ buffer.push_front(new SDL_Event(event));
+ ++waiting;
+
+ lock.unlock();
+ not_empty.notify_one();
+ }
+
+ void EventManager::get_next_event(SDL_Event& event)
+ {
+ boost::mutex::scoped_lock lock(mutex);
+
+ not_empty.wait(lock, boost::bind(&EventManager::is_not_empty, this));
+
+ --waiting;
+ event = *buffer[waiting];
+ delete buffer[waiting];
+
+ lock.unlock();
+ not_full.notify_one();
+ }
+
+ bool EventManager::available(void)
+ {
+ boost::mutex::scoped_lock lock(mutex);
+ return waiting < buffer.capacity();
+ }
+
+ void EventManager::handle_events(void)
+ {
+ SDL_Event event;
+
+ // run forever until this thread is interrupted
+ while (true) {
+ get_next_event(event);
+
+ switch (event.type) {
+ case SDL_KEYDOWN:
+ LOG4CXX_ERROR(log, L"key");
+ break;
+
+ case SDL_MOUSEMOTION:
+ LOG4CXX_ERROR(log, L"mouse");
+ }
+ }
+ }
+};
+
diff --git a/src/menu/event_manager.hpp b/src/menu/event_manager.hpp
new file mode 100644
index 00000000..03529dca
--- /dev/null
+++ b/src/menu/event_manager.hpp
@@ -0,0 +1,128 @@
+/*
+ * UltraStar Deluxe - Karaoke Game
+ *
+ * UltraStar Deluxe is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ *
+ * $URL$
+ * $Id$
+ */
+
+#ifndef EVENT_MANAGER_HPP
+#define EVENT_MANAGER_HPP
+
+#include <SDL/SDL.h>
+
+#include <boost/bind.hpp>
+#include <boost/circular_buffer.hpp>
+#include <boost/progress.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/thread/condition.hpp>
+#include <boost/thread/mutex.hpp>
+#include <boost/thread/thread.hpp>
+
+#include <log4cxx/logger.h>
+
+namespace usdx
+{
+ /**
+ * This class is the junction point between the SDL Thread (with the SDL
+ * main loop) and the event thread. The EventManager buffers the SDL
+ * Events until the thread has time to handle the events. Because one
+ * thread pushes the events and an other thread is reading the access to
+ * the buffer have to be mutual exclusive.
+ */
+ class EventManager
+ {
+ private:
+ static log4cxx::LoggerPtr log;
+
+ EventManager(const EventManager&); //< no copy
+ EventManager& operator=(const EventManager&); //< no assignment
+
+ /**
+ * Type of the buffer for the Events.
+ */
+ typedef boost::circular_buffer<const SDL_Event*> buffer_type;
+
+ /**
+ * Buffer to store the events.
+ */
+ buffer_type buffer;
+
+ /**
+ * How many events currently waiting to getting handled.
+ */
+ buffer_type::size_type waiting;
+
+ /**
+ * Mutex to guaranty the mutual exclusion between the multiple
+ * threads.
+ */
+ boost::mutex mutex;
+
+ boost::condition not_empty;
+ boost::condition not_full;
+
+ /**
+ * Returns if the buffer is contains at least one element or
+ * not.
+ * This functions is not thread-safe! Intended to use as
+ * condition for boost::condition#wait.
+ */
+ bool is_not_empty() const;
+
+ /**
+ * Returns if the buffer has at least space for one element left
+ * or not.
+ * This functions is not thread-safe! Intended to use as
+ * condition for boost::condition#wait.
+ */
+ bool is_not_full() const;
+
+ /**
+ * This function is used to get the next event from the
+ * buffer. If no event is waiting, this method blocks until
+ * there is one event available.
+ */
+ void get_next_event(SDL_Event& event);
+
+ public:
+ EventManager(int capacity = 20);
+ virtual ~EventManager();
+
+ void add_event(const SDL_Event& item);
+
+ /**
+ * This function is intended to be used as separate thread. It
+ * will run forever until for example a
+ * boost::thread_interrupted is thrown.
+ */
+ void handle_events(void);
+
+ /**
+ * This function returns (thread-safe) weather there is space in
+ * left the buffer for a new element or not.
+ */
+ bool available(void);
+ };
+};
+
+
+#endif
generated by cgit v1.2.3 (git 2.25.1) at 2024-12-26 08:28:29 +0000