void InputListener::onEvent(const sf::Event& event)
{
switch (event.type)
{
/* Window */
case sf::Event::LostFocus: onFocusLost(); break;
case sf::Event::GainedFocus: onFocusGained(); break;
case sf::Event::Closed: onWindowClosed(); break;
case sf::Event::Resized: onWindowResized(event.size); break;
/* Keyboard */
case sf::Event::TextEntered: onTextEntered(event.text); break;
case sf::Event::KeyPressed: onKeyPressed(event.key); break;
case sf::Event::KeyReleased: onKeyReleased(event.key); break;
/* Mouse */
case sf::Event::MouseEntered: onMouseEntered(); break;
case sf::Event::MouseLeft: onMouseLeft(); break;
case sf::Event::MouseMoved: onMouseMoved(event.mouseMove); break;
case sf::Event::MouseWheelMoved: onMouseWheelMoved(event.mouseWheel); break;
case sf::Event::MouseButtonPressed: onMouseButtonPressed(event.mouseButton); break;
case sf::Event::MouseButtonReleased: onMouseButtonReleased(event.mouseButton); break;
/* Joystick */
case sf::Event::JoystickConnected: onJoystickConnected(event.joystickConnect); break;
case sf::Event::JoystickDisconnected: onJoystickDisconnected(event.joystickConnect); break;
case sf::Event::JoystickButtonPressed: onJoystickButtonPressed(event.joystickButton); break;
case sf::Event::JoystickButtonReleased: onJoystickButtonReleased(event.joystickButton); break;
case sf::Event::JoystickMoved: onJoystickMoved(event.joystickMove); break;
default:
Logger::log("Warning", "Unknow event type: %d", event.type);
break;
}
}
void SDLEventHandler::onWindowEvent(const SDL_WindowEvent& e)
{
/*
*SDL provides two "resize" events.
* Warp Drive only provides treatment for the "resize request"
* type, for the moment. Should it prove useful, this will be ammended
*/
if (e.windowID != SDL_GetWindowID(DisplayManager::instance()->getScreen()))
{
return;
}
switch (e.event)
{
case SDL_WINDOWEVENT_SHOWN:
onWindowShown(e);
break;
case SDL_WINDOWEVENT_HIDDEN:
onWindowHidden(e);
break;
case SDL_WINDOWEVENT_EXPOSED:
onWindowExposed(e);
break;
case SDL_WINDOWEVENT_MOVED:
onWindowMoved(e);
break;
case SDL_WINDOWEVENT_SIZE_CHANGED:
onWindowResized(e);
break;
case SDL_WINDOWEVENT_MINIMIZED:
onWindowMinimized(e);
break;
case SDL_WINDOWEVENT_MAXIMIZED:
onWindowMaximized(e);
break;
case SDL_WINDOWEVENT_RESTORED:
onWindowRestored(e);
break;
case SDL_WINDOWEVENT_ENTER:
onMouseEntered(e);
break;
case SDL_WINDOWEVENT_LEAVE:
onMouseLeft(e);
break;
case SDL_WINDOWEVENT_FOCUS_GAINED:
onKeyboardFocus(e);
break;
case SDL_WINDOWEVENT_FOCUS_LOST:
onKeyboardFocusLost(e);
break;
case SDL_WINDOWEVENT_CLOSE:
onWindowCloseRequest(e);
break;
default:
// Unexpected event type!
assert(0);
break;
}
}
bool Chimera_X11::onX11Event( FB::X11Event* evt, FB::PluginWindowX11* w )
{
if( GDK_MAP == evt->m_event->type ) {
onWindowResized( 0, w );
}
return false;
}
// Simple main loop
void mainLoop()
{
// Window is not minimized
bool active = true;
for(;;)// Infinite loop
{
SDL_Event event;
// Wait for event
if(SDL_WaitEvent(&event) == 0) throw SDL_Exception();
// Screen needs redraw
bool redraw = false;
// Handle all waiting events
do
{
camera += cam_velocity;
// Call proper event handlers
switch(event.type)
{
case SDL_ACTIVEEVENT : // Stop redraw when minimized
if(event.active.state == SDL_APPACTIVE)
active = event.active.gain;
break;
case SDL_KEYDOWN :
onKeyDown(event.key.keysym.sym, event.key.keysym.mod);
break;
case SDL_KEYUP :
onKeyUp(event.key.keysym.sym, event.key.keysym.mod);
break;
case SDL_MOUSEMOTION :
onMouseMove(event.motion.x, event.motion.y, event.motion.xrel, event.motion.yrel, event.motion.state);
break;
case SDL_MOUSEBUTTONDOWN :
onMouseDown(event.button.button, event.button.x, event.button.y);
break;
case SDL_MOUSEBUTTONUP :
onMouseUp(event.button.button, event.button.x, event.button.y);
break;
case SDL_QUIT :
return; // End main loop
case SDL_VIDEORESIZE :
onWindowResized(event.resize.w, event.resize.h);
break;
case SDL_VIDEOEXPOSE :
redraw = true;
break;
default : // Do nothing
break;
}
} while(SDL_PollEvent(&event) == 1);
// Optionally redraw window
if(active && redraw) onWindowRedraw();
}
}
void ofxDatGuiComponent::setAnchor(ofxDatGuiAnchor anchor)
{
mAnchor = anchor;
if (mAnchor != ofxDatGuiAnchor::NO_ANCHOR){
ofAddListener(ofEvents().windowResized, this, &ofxDatGuiComponent::onWindowResized);
} else{
ofRemoveListener(ofEvents().windowResized, this, &ofxDatGuiComponent::onWindowResized);
}
onWindowResized();
}
bool FBVLC_Win::onWindowAttached( FB::AttachedEvent* evt, FB::PluginWindowlessWin* w )
{
vlcOpen();
if( get_player().is_open() ) {
vlc::vmem::open( &get_player().basic_player() );
}
onWindowResized( 0, w );
applyPlayerOptions();
return true;
}
void Chimera_X11::setFullscreen( bool fs )
{
if( m_quickViewPtr && m_pluginWindow ) {
if( fs && !isFullscreen() ) {
m_quickViewPtr->hide();
m_quickViewPtr->setParent( 0 );
m_quickViewPtr->showFullScreen();
Q_EMIT fullscreenChanged( true );
} else if( !fs && isFullscreen() ) {
m_quickViewPtr->showNormal();
m_quickViewPtr->hide();
m_quickViewPtr->setParent( m_pluginWindow.data() );
onWindowResized( 0, static_cast<FB::PluginWindowX11*>( GetWindow() ) );
m_quickViewPtr->requestActivate();
Q_EMIT fullscreenChanged( false );
}
}
}
SDL_Surface * init(unsigned width, unsigned height, unsigned color, unsigned depth, unsigned stencil)
{
// Set OpenGL attributes
if(SDL_GL_SetAttribute(SDL_GL_BUFFER_SIZE, color) < 0) throw SDL_Exception();
if(SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, depth) < 0) throw SDL_Exception();
if(SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, stencil) < 0) throw SDL_Exception();
if(SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1) < 0) throw SDL_Exception();
// Create window
SDL_Surface * screen = SDL_SetVideoMode(width, height, color, SDL_OPENGL | SDL_RESIZABLE);
if(screen == NULL) throw SDL_Exception();
// Call init code
onInit();
onWindowResized(width, height);
return screen;
}
SDL_Surface * init(unsigned width, unsigned height, unsigned color, unsigned depth, unsigned stencil)
{
// Set OpenGL attributes
if(SDL_GL_SetAttribute(SDL_GL_BUFFER_SIZE, color) < 0) throw SDL_Exception();
if(SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, depth) < 0) throw SDL_Exception();
if(SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, stencil) < 0) throw SDL_Exception();
if(SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1) < 0) throw SDL_Exception();
// Create window
SDL_Surface * screen = SDL_SetVideoMode(width, height, color, SDL_OPENGL | SDL_RESIZABLE);
if(screen == NULL) throw SDL_Exception();
#ifndef USE_GLEE
// Init extensions
GLenum error = glewInit();
if(error != GLEW_OK)
throw std::runtime_error(std::string("GLEW : Init failed : ") + (const char*)glewGetErrorString(error));
#endif //USE_GLEE
// Call init code
onInit();
onWindowResized(width, height);
return screen;
}
void ofxDatGuiComponent::onWindowResized(ofResizeEventArgs &e)
{
onWindowResized();
}
void RenderThread::processMessage (const Message& message)
{
DBG_PRINT(("RenderThread::processMessage(): message = { %s, %p }\n", getMessageTypeName(message.type), message.payload.window));
switch (message.type)
{
case MESSAGE_RESUME: m_paused = false; break;
case MESSAGE_PAUSE: m_paused = true; break;
case MESSAGE_FINISH: m_finish = true; break;
// \note While Platform / WindowRegistry are currently multi-window -capable,
// the fact that platform gives us windows too late / at unexpected times
// forces us to do some sanity checking and limit system to one window here.
case MESSAGE_WINDOW_CREATED:
if (m_windowState != WINDOWSTATE_NOT_CREATED && m_windowState != WINDOWSTATE_DESTROYED)
throw InternalError("Got unexpected onNativeWindowCreated() event from system");
m_windowState = WINDOWSTATE_NOT_INITIALIZED;
m_window = message.payload.window;
break;
case MESSAGE_WINDOW_RESIZED:
if (m_window != message.payload.window)
throw InternalError("Got onNativeWindowResized() event targeting different window");
if (m_windowState == WINDOWSTATE_NOT_INITIALIZED)
{
// Got first resize event, window is ready for use.
m_windowState = WINDOWSTATE_READY;
onWindowCreated(message.payload.window);
}
else if (m_windowState == WINDOWSTATE_READY)
onWindowResized(message.payload.window);
else
throw InternalError("Got unexpected onNativeWindowResized() event from system");
break;
case MESSAGE_WINDOW_DESTROYED:
if (m_window != message.payload.window)
throw InternalError("Got onNativeWindowDestroyed() event targeting different window");
if (m_windowState != WINDOWSTATE_NOT_INITIALIZED && m_windowState != WINDOWSTATE_READY)
throw InternalError("Got unexpected onNativeWindowDestroyed() event from system");
if (m_windowState == WINDOWSTATE_READY)
onWindowDestroyed(message.payload.window);
m_windowState = WINDOWSTATE_DESTROYED;
m_window = DE_NULL;
break;
case MESSAGE_INPUT_QUEUE_CREATED:
m_inputQueue = message.payload.inputQueue;
break;
case MESSAGE_INPUT_QUEUE_DESTROYED:
m_inputQueue = message.payload.inputQueue;
break;
case MESSAGE_SYNC:
message.payload.semaphore->increment();
break;
default:
throw std::runtime_error("Unknown message type");
break;
}
}
// Animation main loop
// period - maximum time between redraws in ms
void mainLoop(unsigned period)
{
// This main loop requires timer support
if(SDL_InitSubSystem(SDL_INIT_TIMER) < 0) throw SDL_Exception();
// Create redraw timer
class RedrawTimer
{
private :
SDL_TimerID id;
static Uint32 callback(Uint32 interval, void *)
{
redraw();
return interval;
}
public :
RedrawTimer(unsigned interval)
: id(SDL_AddTimer(interval, callback, NULL))
{
if(id == NULL) throw SDL_Exception();
}
~RedrawTimer()
{
if(id != NULL) SDL_RemoveTimer(id);
}
} redrawTimer(period);
// Window is not minimized
bool active = true;
for(;;)// Infinite loop
{
SDL_Event event;
// Wait for event
if(SDL_WaitEvent(&event) == 0) throw SDL_Exception();
// Screen needs redraw
bool redraw = false;
// Handle all waiting events
do
{
// Call proper event handlers
switch(event.type)
{
case SDL_ACTIVEEVENT :// Stop redraw when minimized
if(event.active.state == SDL_APPACTIVE)
active = event.active.gain;
break;
case SDL_KEYDOWN :
onKeyDown(event.key.keysym.sym, event.key.keysym.mod);
break;
case SDL_KEYUP :
onKeyUp(event.key.keysym.sym, event.key.keysym.mod);
break;
case SDL_MOUSEMOTION :
onMouseMove(event.motion.x, event.motion.y, event.motion.xrel, event.motion.yrel, event.motion.state);
break;
case SDL_MOUSEBUTTONDOWN :
onMouseDown(event.button.button, event.button.x, event.button.y);
break;
case SDL_MOUSEBUTTONUP :
onMouseUp(event.button.button, event.button.x, event.button.y);
break;
case SDL_QUIT :
return;// End main loop
case SDL_VIDEORESIZE :
onWindowResized(event.resize.w, event.resize.h);
break;
case SDL_VIDEOEXPOSE :
redraw = true;
break;
default :// Do nothing
break;
}
} while(SDL_PollEvent(&event) == 1);
// Optionally redraw window
if(active && redraw) onWindowRedraw();
}
}
bool FBVLC::onWindowAttached( FB::AttachedEvent *evt, FB::PluginWindow* w )
{
vlc_open();
onWindowResized( 0, w );//some browsers don't send ResizedEvent on startup
return true;
}
