Method nextEvent

src/program/GameEventsXcb.cpp:81–204

}

GameEventsXcb::EventType GameEventsXcb::nextEvent(struct HotKey &hk)
{
    while (true) {
        std::unique_ptr<xcb_generic_event_t> event;

        if (next_event) {
            event = std::move(next_event);
        }
        else {
            event.reset(xcb_poll_for_event(context->conn));
        }

        if (!event) {

            if (!context->hotkey_pressed_queue.empty()) {
                /* Processing a pressed hotkey pushed by the UI */
                context->hotkey_pressed_queue.pop(hk.type);
                return EVENT_TYPE_PRESS;
            }
            else if (!context->hotkey_released_queue.empty()) {
                /* Processing a pressed hotkey pushed by the UI */
                context->hotkey_released_queue.pop(hk.type);
                return EVENT_TYPE_RELEASE;
            }
            else {
                return EVENT_TYPE_NONE;
            }
        }
        else {
            /* Processing a hotkey pressed by the user */
            uint8_t response_type = (event->response_type & ~0x80);

            if ((response_type == XCB_KEY_PRESS) || (response_type == XCB_KEY_RELEASE)) {
                /* Get the actual pressed/released key */
                xcb_key_press_event_t* key_event = reinterpret_cast<xcb_key_press_event_t*>(event.get());
                xcb_keycode_t kc = key_event->detail;

                /* Detecting auto-repeat, either if detectable auto-repeat is
                 * supported or not by the X server.
                 * If detectable auto-repeat is supported, we detect if pressed
                 * event is from the same key as the last pressed key, without
                 * a key release.
                 * If detectable auto-repeat is not supported, we detect if a
                 * released event is followed by a pressed event with the same
                 * sequence number. If not, we must keep the later event for
                 * the next call (xcb does not support peeking events).
                 */
                if (kc == last_pressed_key) {
                    if (response_type == XCB_KEY_RELEASE) {
                        /* Check the next event. We wait a bit for the next
                         * event to be generated if auto-repeat. There are still
                         * are few cases where we would have to wait a significantly
                         * longer time.
                         */
                        usleep(500);
                        next_event.reset(xcb_poll_for_event(context->conn));
                        xcb_key_press_event_t* next_key_event = reinterpret_cast<xcb_key_press_event_t*>(next_event.get());