bool InputHandler::key_released(std::vector<sf::Keyboard::Key> keys)
{
for(int i = 0; i < keys.size(); ++i)
{
if(key_released(keys[i]))
return true;
}
return false;
}
void key_callback(GLFWwindow *wnd, int key, int scan, int action, int mod) {
switch(action) {
case GLFW_PRESS:
key_pressed(key, scan, mod);
break;
case GLFW_REPEAT:
key_repeated(key, scan, mod);
break;
case GLFW_RELEASE:
key_released(key, scan, mod);
break;
}
}
static void kkbrd(void *arg)
{
kbrd_instance_t *instance = (kbrd_instance_t *) arg;
while (true) {
wchar_t sc = indev_pop_character(&instance->raw);
if (sc == IGNORE_CODE)
continue;
if (sc & KEY_RELEASE)
key_released(instance, (sc ^ KEY_RELEASE) & 0x7f);
else
key_pressed(instance, sc & 0x7f);
}
}
int dispatcher::execute( void )
{
xcb_flush( _connection );
_exit_code = 0;
bool done = false;
while ( !done )
{
auto event = core::wrap_cptr( xcb_wait_for_event( _connection ) );
if ( !event )
break;
switch ( event->response_type & ~0x80 )
{
case XCB_EXPOSE:
{
auto *ev = reinterpret_cast<xcb_expose_event_t*>( event.get() );
if ( ev->count == 0 )
_windows[ev->window]->exposed();
xcb_flush( _connection );
break;
}
case XCB_CONFIGURE_NOTIFY:
{
auto *ev = reinterpret_cast<xcb_configure_notify_event_t*>( event.get() );
auto w = _windows[ev->window];
if ( w->check_last_position( ev->x, ev->y ) )
w->moved( ev->x, ev->y );
if ( w->check_last_size( ev->width, ev->height ) )
w->resize_canvas( ev->width, ev->height );
break;
}
case XCB_DESTROY_NOTIFY:
{
auto *ev = reinterpret_cast<xcb_destroy_notify_event_t*>( event.get() );
auto w = _windows[ev->window];
w->closed();
break;
}
case XCB_MAP_NOTIFY:
{
auto *ev = reinterpret_cast<xcb_map_notify_event_t*>( event.get() );
auto w = _windows[ev->window];
w->shown();
w->restored();
break;
}
case XCB_UNMAP_NOTIFY:
{
auto *ev = reinterpret_cast<xcb_unmap_notify_event_t*>( event.get() );
auto w = _windows[ev->window];
w->hidden();
w->minimized();
break;
}
case XCB_ENTER_NOTIFY:
{
auto *ev = reinterpret_cast<xcb_enter_notify_event_t*>( event.get() );
auto w = _windows[ev->event];
w->entered();
break;
}
case XCB_LEAVE_NOTIFY:
{
auto *ev = reinterpret_cast<xcb_leave_notify_event_t*>( event.get() );
auto w = _windows[ev->event];
w->exited();
break;
}
case XCB_KEY_PRESS:
{
auto *ev = reinterpret_cast<xcb_key_press_event_t*>( event.get() );
auto w = _windows[ev->event];
platform::scancode sc = _keyboard->get_scancode( ev->detail );
w->key_pressed( _keyboard, sc );
break;
}
case XCB_KEY_RELEASE:
{
auto *ev = reinterpret_cast<xcb_key_press_event_t*>( event.get() );
auto w = _windows[ev->event];
platform::scancode sc = _keyboard->get_scancode( ev->detail );
w->key_released( _keyboard, sc );
break;
}
case XCB_MAPPING_NOTIFY:
{
auto *ev = reinterpret_cast<xcb_mapping_notify_event_t*>( event.get() );
if ( ev->request == XCB_MAPPING_MODIFIER || ev->request == XCB_MAPPING_KEYBOARD )
_keyboard->update_mapping();
break;
}
case XCB_BUTTON_PRESS:
{
auto *ev = reinterpret_cast<xcb_button_press_event_t*>( event.get() );
auto w = _windows[ev->event];
switch ( ev->detail )
{
case 1:
case 2:
case 3:
w->mouse_pressed( _mouse, { double(ev->event_x), double(ev->event_y) }, ev->detail );
break;
case 4: // Mouse wheel up
case 5: // Mouse wheel down
break;
}
break;
}
case XCB_BUTTON_RELEASE:
{
auto *ev = reinterpret_cast<xcb_button_press_event_t*>( event.get() );
auto w = _windows[ev->event];
switch ( ev->detail )
{
case 1:
case 2:
case 3:
w->mouse_released( _mouse, { double(ev->event_x), double(ev->event_y) }, ev->detail );
break;
case 4: // Mouse wheel up
case 5: // Mouse wheel down
break;
}
break;
}
case XCB_MOTION_NOTIFY:
{
auto *ev = reinterpret_cast<xcb_motion_notify_event_t*>( event.get() );
auto w = _windows[ev->event];
w->mouse_moved( _mouse, { double(ev->event_x), double(ev->event_y) } );
break;
}
case XCB_VISIBILITY_NOTIFY:
case XCB_REPARENT_NOTIFY:
break;
case XCB_CLIENT_MESSAGE:
{
auto *ev = reinterpret_cast<xcb_client_message_event_t*>( event.get() );
if ( ev->data.data32[0] == _atom_delete_window )
{
auto w = _windows[ev->window];
w->hide();
_windows.erase( w->id() );
done = _windows.empty();
}
break;
}
default:
std::cout << "Unknown event: " << uint32_t( event->response_type & ~0x80 ) << ' ' << uint32_t( event->response_type ) << std::endl;
}
}
return _exit_code;
}
void kb_event_handler(unsigned short key) {
if (key & KB_BREAKCODE)
key_released(key);
else
key_pressed(key);
}
window::window( const std::shared_ptr<platform::window> &win )
: _window( win )
{
precondition( bool(_window), "null window" );
_window->exposed = [this] ( void ) { paint(); };
_window->resized = [this] ( double w, double h ) { resized( w, h ); };
_window->mouse_pressed = [this]( const std::shared_ptr<platform::mouse> &, const base::point &p, int b ) { mouse_press( p, b ); };
_window->mouse_released = [this]( const std::shared_ptr<platform::mouse> &, const base::point &p, int b ) { mouse_release( p, b ); };
_window->mouse_moved = [this]( const std::shared_ptr<platform::mouse> &, const base::point &p ) { mouse_moved( p ); };
_window->mouse_wheel = [this]( const std::shared_ptr<platform::mouse> &, int i ) { mouse_wheel( i ); };
_window->key_pressed = [this]( const std::shared_ptr<platform::keyboard> &, const platform::scancode &c ) { key_pressed( c ); };
_window->key_released = [this]( const std::shared_ptr<platform::keyboard> &, const platform::scancode &c ) { key_released( c ); };
_window->text_entered = [this]( const std::shared_ptr<platform::keyboard> &, const char32_t &c ) { text_entered( c ); };
_canvas = std::make_shared<draw::canvas>();
}
void GameControls::notify_input(InputEvent &event) {
if(event.is_keyboard_key_pressed())
key_pressed(event.get_keyboard_key());
else if(event.is_keyboard_key_released())
key_released(event.get_keyboard_key());
}
