MirPointerEvent const* mir_input_event_get_pointer_event(MirInputEvent const* ev)
{
if(mir_input_event_get_type(ev) != mir_input_event_type_pointer)
{
mir::log_critical("expected pointer input event but event was of type " +
input_event_type_to_string(mir_input_event_get_type(ev)));
abort();
}
return reinterpret_cast<MirPointerEvent const*>(ev);
}
MirKeyboardEvent const* mir_input_event_get_keyboard_event(MirInputEvent const* ev)
{
if (mir_input_event_get_type(ev) != mir_input_event_type_key)
{
mir::log_critical("expected key input event but event was of type " +
input_event_type_to_string(mir_input_event_get_type(ev)));
abort();
}
return reinterpret_cast<MirKeyboardEvent const*>(ev);
}
bool me::WindowManager::handle(MirEvent const& event)
{
assert(focus_controller);
assert(display);
assert(compositor);
if (mir_event_get_type(&event) != mir_event_type_input)
return false;
auto iev = mir_event_get_input_event(&event);
auto input_type = mir_input_event_get_type(iev);
if (input_type == mir_input_event_type_key)
{
return handle_key_event(mir_input_event_get_keyboard_event(iev));
}
else if (input_type == mir_input_event_type_pointer &&
focus_controller)
{
return handle_pointer_event(mir_input_event_get_pointer_event(iev));
}
else if (input_type == mir_input_event_type_touch &&
focus_controller)
{
return handle_touch_event(mir_input_event_get_touch_event(iev));
}
return false;
}
TEST_F(InputEventBuilder, makes_valid_pointer_event)
{
MirPointerAction action = mir_pointer_action_enter;
auto depressed_buttons = mir_pointer_button_back | mir_pointer_button_tertiary;
float x_axis_value = 3.9, y_axis_value = 7.4, hscroll_value = .9, vscroll_value = .3;
auto const relative_x_value = 0.0;
auto const relative_y_value = 0.0;
auto ev = mev::make_event(device_id, timestamp, mac, modifiers,
action, depressed_buttons, x_axis_value, y_axis_value,
hscroll_value, vscroll_value, relative_x_value, relative_y_value);
auto e = ev.get();
EXPECT_EQ(mir_event_type_input, mir_event_get_type(e));
auto ie = mir_event_get_input_event(e);
EXPECT_EQ(mir_input_event_type_pointer, mir_input_event_get_type(ie));
auto pev = mir_input_event_get_pointer_event(ie);
EXPECT_EQ(modifiers, mir_pointer_event_modifiers(pev));
EXPECT_EQ(action, mir_pointer_event_action(pev));
EXPECT_EQ(mac, mir_pointer_event_get_cookie(pev).mac);
EXPECT_EQ(timestamp.count(), mir_pointer_event_get_cookie(pev).timestamp);
EXPECT_TRUE(mir_pointer_event_button_state(pev, mir_pointer_button_back));
EXPECT_TRUE(mir_pointer_event_button_state(pev, mir_pointer_button_tertiary));
EXPECT_FALSE(mir_pointer_event_button_state(pev, mir_pointer_button_primary));
EXPECT_FALSE(mir_pointer_event_button_state(pev, mir_pointer_button_secondary));
EXPECT_FALSE(mir_pointer_event_button_state(pev, mir_pointer_button_forward));
EXPECT_EQ(x_axis_value, mir_pointer_event_axis_value(pev, mir_pointer_axis_x));
EXPECT_EQ(y_axis_value, mir_pointer_event_axis_value(pev, mir_pointer_axis_y));
EXPECT_EQ(hscroll_value, mir_pointer_event_axis_value(pev, mir_pointer_axis_hscroll));
EXPECT_EQ(vscroll_value, mir_pointer_event_axis_value(pev, mir_pointer_axis_vscroll));
}
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;
}
}
// The following three requirements can be removed as soon as we remove android::InputDispatcher, which is the
// only remaining part that relies on the difference between mir_motion_action_pointer_{up,down} and
// mir_motion_action_{up,down} and the difference between mir_motion_action_move and mir_motion_action_hover_move.
TEST_F(InputEventBuilder, maps_single_touch_down_to_motion_down)
{
MirTouchAction action = mir_touch_action_down;
auto ev = mev::make_event(device_id, timestamp, mac, modifiers);
mev::add_touch(*ev, 0, action, mir_touch_tooltype_finger, 0, 0, 0, 0, 0, 0);
auto e = ev.get();
EXPECT_EQ(mir_event_type_input, mir_event_get_type(e));
auto ie = mir_event_get_input_event(e);
EXPECT_EQ(mir_input_event_type_touch, mir_input_event_get_type(ie));
auto tev = mir_input_event_get_touch_event(ie);
EXPECT_EQ(action, mir_touch_event_action(tev, 0));
}
static void handleInput(const MirInputEvent* input_event, _GLFWwindow* window)
{
int type = mir_input_event_get_type(input_event);
switch (type)
{
case mir_input_event_type_key:
handleKeyEvent(mir_input_event_get_keyboard_event(input_event), window);
break;
case mir_input_event_type_pointer:
handlePointerEvent(mir_input_event_get_pointer_event(input_event), window);
break;
default:
break;
}
}
void QMirClientInput::dispatchInputEvent(QMirClientWindow *window, const MirInputEvent *ev)
{
switch (mir_input_event_get_type(ev))
{
case mir_input_event_type_key:
dispatchKeyEvent(window, ev);
break;
case mir_input_event_type_touch:
dispatchTouchEvent(window, ev);
break;
case mir_input_event_type_pointer:
dispatchPointerEvent(window, ev);
break;
default:
break;
}
}
// Currently we only validate touch events as they are the most problematic
void mi::Validator::validate_and_dispatch(MirEvent const& event)
{
if (mir_event_get_type(&event) != mir_event_type_input)
{
dispatch_valid_event(event);
return;
}
auto iev = mir_event_get_input_event(&event);
if (mir_input_event_get_type(iev) != mir_input_event_type_touch)
{
dispatch_valid_event(event);
return;
}
auto tev = mir_input_event_get_touch_event(iev);
handle_touch_event(mir_input_event_get_device_id(iev), tev);
return;
}
TEST_F(InputEventBuilder, makes_valid_touch_event)
{
unsigned touch_count = 3;
MirTouchId touch_ids[] = {7, 9, 4};
MirTouchAction actions[] = { mir_touch_action_up, mir_touch_action_change, mir_touch_action_change};
MirTouchTooltype tooltypes[] = {mir_touch_tooltype_unknown, mir_touch_tooltype_finger, mir_touch_tooltype_stylus};
float x_axis_values[] = { 7, 14.3, 19.6 };
float y_axis_values[] = { 3, 9, 11 };
float pressure_values[] = {3, 9, 14.6};
float touch_major_values[] = {11, 9, 14};
float touch_minor_values[] = {13, 3, 9.13};
float size_values[] = {4, 9, 6};
auto ev = mev::make_event(device_id, timestamp,
mac, modifiers);
for (unsigned i = 0; i < touch_count; i++)
{
mev::add_touch(*ev, touch_ids[i], actions[i], tooltypes[i], x_axis_values[i], y_axis_values[i],
pressure_values[i], touch_major_values[i], touch_minor_values[i], size_values[i]);
}
auto e = ev.get();
EXPECT_EQ(mir_event_type_input, mir_event_get_type(e));
auto ie = mir_event_get_input_event(e);
EXPECT_EQ(mir_input_event_type_touch, mir_input_event_get_type(ie));
auto tev = mir_input_event_get_touch_event(ie);
EXPECT_EQ(modifiers, mir_touch_event_modifiers(tev));
EXPECT_EQ(touch_count, mir_touch_event_point_count(tev));
EXPECT_EQ(mac, mir_touch_event_get_cookie(tev).mac);
EXPECT_EQ(timestamp.count(), mir_touch_event_get_cookie(tev).timestamp);
for (unsigned i = 0; i < touch_count; i++)
{
EXPECT_EQ(touch_ids[i], mir_touch_event_id(tev, i));
EXPECT_EQ(actions[i], mir_touch_event_action(tev, i));
EXPECT_EQ(tooltypes[i], mir_touch_event_tooltype(tev, i));
EXPECT_EQ(x_axis_values[i], mir_touch_event_axis_value(tev, i, mir_touch_axis_x));
EXPECT_EQ(y_axis_values[i], mir_touch_event_axis_value(tev, i, mir_touch_axis_y));
EXPECT_EQ(pressure_values[i], mir_touch_event_axis_value(tev, i, mir_touch_axis_pressure));
EXPECT_EQ(touch_major_values[i], mir_touch_event_axis_value(tev, i, mir_touch_axis_touch_major));
EXPECT_EQ(touch_minor_values[i], mir_touch_event_axis_value(tev, i, mir_touch_axis_touch_minor));
EXPECT_EQ(size_values[i], mir_touch_event_axis_value(tev, i, mir_touch_axis_size));
}
}
TEST_F(InputEventBuilder, map_to_hover_if_no_button_pressed)
{
float x_axis_value = 3.9, y_axis_value = 7.4, hscroll_value = .9, vscroll_value = .3;
auto const relative_x_value = 0.0;
auto const relative_y_value = 0.0;
MirPointerAction action = mir_pointer_action_motion;
auto ev = mev::make_event(device_id, timestamp, mac, modifiers,
action, 0, x_axis_value, y_axis_value,
hscroll_value, vscroll_value, relative_x_value, relative_y_value);
auto e = ev.get();
auto ie = mir_event_get_input_event(e);
EXPECT_EQ(mir_input_event_type_pointer, mir_input_event_get_type(ie));
auto pev = mir_input_event_get_pointer_event(ie);
EXPECT_EQ(modifiers, mir_pointer_event_modifiers(pev));
EXPECT_EQ(action, mir_pointer_event_action(pev));
EXPECT_EQ(mac, mir_pointer_event_get_cookie(pev).mac);
EXPECT_EQ(timestamp.count(), mir_pointer_event_get_cookie(pev).timestamp);
}
TEST_F(InputEventBuilder, makes_valid_key_event)
{
MirKeyboardAction const action = mir_keyboard_action_down;
xkb_keysym_t const key_code = 34;
int const scan_code = 17;
auto ev = mev::make_event(device_id, timestamp,
mac, action, key_code, scan_code, modifiers);
auto e = ev.get();
EXPECT_EQ(mir_event_type_input, mir_event_get_type(e));
auto ie = mir_event_get_input_event(e);
EXPECT_EQ(mir_input_event_type_key, mir_input_event_get_type(ie));
auto kev = mir_input_event_get_keyboard_event(ie);
EXPECT_EQ(action, mir_keyboard_event_action(kev));
EXPECT_EQ(key_code, mir_keyboard_event_key_code(kev));
EXPECT_EQ(scan_code, mir_keyboard_event_scan_code(kev));
EXPECT_EQ(modifiers, mir_keyboard_event_modifiers(kev));
EXPECT_EQ(mac, mir_keyboard_event_get_cookie(kev).mac);
EXPECT_EQ(timestamp.count(), mir_keyboard_event_get_cookie(kev).timestamp);
}
