diff options
Diffstat (limited to '')
| -rw-r--r-- | src/menu/application.cpp | 20 | ||||
| -rw-r--r-- | src/menu/event_manager.cpp | 106 | ||||
| -rw-r--r-- | src/menu/event_manager.hpp | 128 |
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 |