void
_gdk_mir_print_event (const MirEvent *event)
{
switch (mir_event_get_type (event))
{
case mir_event_type_key:
_gdk_mir_print_key_event (mir_event_get_input_event (event));
break;
case mir_event_type_motion:
_gdk_mir_print_motion_event (mir_event_get_input_event (event));
break;
case mir_event_type_surface:
_gdk_mir_print_surface_event (mir_event_get_surface_event (event));
break;
case mir_event_type_resize:
_gdk_mir_print_resize_event (mir_event_get_resize_event (event));
break;
case mir_event_type_close_surface:
_gdk_mir_print_close_event (mir_event_get_close_surface_event (event));
break;
default:
g_printerr ("EVENT %u\n", mir_event_get_type (event));
break;
}
}
static void
gdk_mir_event_source_queue_event (GdkDisplay *display,
GdkWindow *window,
const MirEvent *event)
{
const MirInputEvent *input_event;
// FIXME: Only generate events if the window wanted them?
switch (mir_event_get_type (event))
{
case mir_event_type_input:
input_event = mir_event_get_input_event (event);
switch (mir_input_event_get_type (input_event))
{
case mir_input_event_type_key:
handle_key_event (window, input_event);
break;
case mir_input_event_type_touch:
handle_motion_event (window, input_event);
break;
case mir_input_event_type_pointer:
handle_motion_event (window, input_event);
break;
}
break;
case mir_event_type_key:
handle_key_event (window, mir_event_get_input_event (event));
break;
case mir_event_type_motion:
handle_motion_event (window, mir_event_get_input_event (event));
break;
case mir_event_type_surface:
handle_surface_event (window, mir_event_get_surface_event (event));
break;
case mir_event_type_resize:
handle_resize_event (window, mir_event_get_resize_event (event));
break;
case mir_event_type_prompt_session_state_change:
// FIXME?
break;
case mir_event_type_orientation:
// FIXME?
break;
case mir_event_type_close_surface:
handle_close_event (window, mir_event_get_close_surface_event (event));
break;
default:
g_warning ("Ignoring unknown Mir event %d", mir_event_get_type (event));
// FIXME?
break;
}
}
void MirSurface::handle_event(MirEvent const& e)
{
std::unique_lock<decltype(mutex)> lock(mutex);
switch (mir_event_get_type(&e))
{
case mir_event_type_surface:
{
auto sev = mir_event_get_surface_event(&e);
auto a = mir_surface_event_get_attribute(sev);
if (a < mir_surface_attribs)
attrib_cache[a] = mir_surface_event_get_attribute_value(sev);
break;
}
case mir_event_type_orientation:
orientation = mir_orientation_event_get_direction(mir_event_get_orientation_event(&e));
break;
case mir_event_type_keymap:
{
xkb_rule_names names;
mir_keymap_event_get_rules(mir_event_get_keymap_event(&e), &names);
keymapper->set_rules(names);
break;
}
case mir_event_type_resize:
{
if (auto_resize_stream)
{
auto resize_event = mir_event_get_resize_event(&e);
buffer_stream->set_size(geom::Size{
mir_resize_event_get_width(resize_event),
mir_resize_event_get_height(resize_event)});
}
break;
}
default:
break;
};
if (handle_event_callback)
{
auto callback = handle_event_callback;
lock.unlock();
callback(&e);
}
}
void QMirClientInput::customEvent(QEvent* event)
{
Q_ASSERT(QThread::currentThread() == thread());
UbuntuEvent* ubuntuEvent = static_cast<UbuntuEvent*>(event);
const MirEvent *nativeEvent = ubuntuEvent->nativeEvent;
if ((ubuntuEvent->window == nullptr) || (ubuntuEvent->window->window() == nullptr)) {
qCWarning(mirclient) << "Attempted to deliver an event to a non-existent window, ignoring.";
return;
}
// Event filtering.
long result;
if (QWindowSystemInterface::handleNativeEvent(
ubuntuEvent->window->window(), mEventFilterType,
const_cast<void *>(static_cast<const void *>(nativeEvent)), &result) == true) {
qCDebug(mirclient, "event filtered out by native interface");
return;
}
qCDebug(mirclientInput, "customEvent(type=%s)", nativeEventTypeToStr(mir_event_get_type(nativeEvent)));
// Event dispatching.
switch (mir_event_get_type(nativeEvent))
{
case mir_event_type_input:
dispatchInputEvent(ubuntuEvent->window, mir_event_get_input_event(nativeEvent));
break;
case mir_event_type_resize:
{
auto resizeEvent = mir_event_get_resize_event(nativeEvent);
// Enable workaround for Screen rotation
auto const targetWindow = ubuntuEvent->window;
if (targetWindow) {
auto const screen = static_cast<QMirClientScreen*>(targetWindow->screen());
if (screen) {
screen->handleWindowSurfaceResize(
mir_resize_event_get_width(resizeEvent),
mir_resize_event_get_height(resizeEvent));
}
targetWindow->handleSurfaceResized(
mir_resize_event_get_width(resizeEvent),
mir_resize_event_get_height(resizeEvent));
}
break;
}
case mir_event_type_surface:
handleSurfaceEvent(ubuntuEvent->window, mir_event_get_surface_event(nativeEvent));
break;
case mir_event_type_surface_output:
handleSurfaceOutputEvent(ubuntuEvent->window, mir_event_get_surface_output_event(nativeEvent));
break;
case mir_event_type_orientation:
dispatchOrientationEvent(ubuntuEvent->window->window(), mir_event_get_orientation_event(nativeEvent));
break;
case mir_event_type_close_surface:
QWindowSystemInterface::handleCloseEvent(ubuntuEvent->window->window());
break;
default:
qCDebug(mirclient, "unhandled event type: %d", static_cast<int>(mir_event_get_type(nativeEvent)));
}
}
