diff --git a/ci/licenses_golden/licenses_flutter b/ci/licenses_golden/licenses_flutter index 283a93a5b1fdf..f2873e025d53f 100644 --- a/ci/licenses_golden/licenses_flutter +++ b/ci/licenses_golden/licenses_flutter @@ -44791,8 +44791,6 @@ ORIGIN: ../../../flutter/shell/platform/linux/fl_key_embedder_responder_private. ORIGIN: ../../../flutter/shell/platform/linux/fl_key_embedder_responder_test.cc + ../../../flutter/LICENSE ORIGIN: ../../../flutter/shell/platform/linux/fl_key_event.cc + ../../../flutter/LICENSE ORIGIN: ../../../flutter/shell/platform/linux/fl_key_event.h + ../../../flutter/LICENSE -ORIGIN: ../../../flutter/shell/platform/linux/fl_key_responder.cc + ../../../flutter/LICENSE -ORIGIN: ../../../flutter/shell/platform/linux/fl_key_responder.h + ../../../flutter/LICENSE ORIGIN: ../../../flutter/shell/platform/linux/fl_keyboard_handler.cc + ../../../flutter/LICENSE ORIGIN: ../../../flutter/shell/platform/linux/fl_keyboard_handler.h + ../../../flutter/LICENSE ORIGIN: ../../../flutter/shell/platform/linux/fl_keyboard_handler_test.cc + ../../../flutter/LICENSE @@ -47694,8 +47692,6 @@ FILE: ../../../flutter/shell/platform/linux/fl_key_embedder_responder_private.h FILE: ../../../flutter/shell/platform/linux/fl_key_embedder_responder_test.cc FILE: ../../../flutter/shell/platform/linux/fl_key_event.cc FILE: ../../../flutter/shell/platform/linux/fl_key_event.h -FILE: ../../../flutter/shell/platform/linux/fl_key_responder.cc -FILE: ../../../flutter/shell/platform/linux/fl_key_responder.h FILE: ../../../flutter/shell/platform/linux/fl_keyboard_handler.cc FILE: ../../../flutter/shell/platform/linux/fl_keyboard_handler.h FILE: ../../../flutter/shell/platform/linux/fl_keyboard_handler_test.cc diff --git a/shell/platform/linux/BUILD.gn b/shell/platform/linux/BUILD.gn index a28e375154cdb..ce15e237bb436 100644 --- a/shell/platform/linux/BUILD.gn +++ b/shell/platform/linux/BUILD.gn @@ -85,7 +85,6 @@ source_set("flutter_linux_sources") { "fl_keyboard_pending_event.h", "fl_keyboard_view_delegate.h", "fl_key_event.h", - "fl_key_responder.h", "fl_key_channel_responder.h", "fl_key_embedder_responder.h", "fl_key_embedder_responder_private.h", @@ -116,7 +115,6 @@ source_set("flutter_linux_sources") { "fl_key_channel_responder.cc", "fl_key_embedder_responder.cc", "fl_key_event.cc", - "fl_key_responder.cc", "fl_keyboard_handler.cc", "fl_keyboard_layout.cc", "fl_keyboard_manager.cc", diff --git a/shell/platform/linux/fl_accessible_node.h b/shell/platform/linux/fl_accessible_node.h index 7969b5419fa34..f793fb68e99ae 100644 --- a/shell/platform/linux/fl_accessible_node.h +++ b/shell/platform/linux/fl_accessible_node.h @@ -19,7 +19,6 @@ G_BEGIN_DECLS G_DEFINE_AUTOPTR_CLEANUP_FUNC(AtkObject, g_object_unref) #endif -#define FL_TYPE_ACCESSIBLE_NODE fl_accessible_node_get_type() G_DECLARE_DERIVABLE_TYPE(FlAccessibleNode, fl_accessible_node, FL, diff --git a/shell/platform/linux/fl_accessible_text_field.cc b/shell/platform/linux/fl_accessible_text_field.cc index 670f0bb59a997..8fdfda6afae4b 100644 --- a/shell/platform/linux/fl_accessible_text_field.cc +++ b/shell/platform/linux/fl_accessible_text_field.cc @@ -30,7 +30,7 @@ static void fl_accessible_editable_text_iface_init(AtkEditableTextIface* iface); G_DEFINE_TYPE_WITH_CODE( FlAccessibleTextField, fl_accessible_text_field, - FL_TYPE_ACCESSIBLE_NODE, + fl_accessible_node_get_type(), G_IMPLEMENT_INTERFACE(ATK_TYPE_TEXT, fl_accessible_text_iface_init) G_IMPLEMENT_INTERFACE(ATK_TYPE_EDITABLE_TEXT, fl_accessible_editable_text_iface_init)) diff --git a/shell/platform/linux/fl_key_channel_responder.cc b/shell/platform/linux/fl_key_channel_responder.cc index fa1970782aac9..757cc5d893937 100644 --- a/shell/platform/linux/fl_key_channel_responder.cc +++ b/shell/platform/linux/fl_key_channel_responder.cc @@ -44,7 +44,7 @@ struct _FlKeyChannelUserData { // The current responder. GWeakRef responder; // The callback provided by the caller #FlKeyboardHandler. - FlKeyResponderAsyncCallback callback; + FlKeyChannelResponderAsyncCallback callback; // The user_data provided by the caller #FlKeyboardHandler. gpointer user_data; }; @@ -76,7 +76,7 @@ static void fl_key_channel_user_data_init(FlKeyChannelUserData* self) {} // The callback and the user_data might be nullptr. static FlKeyChannelUserData* fl_key_channel_user_data_new( FlKeyChannelResponder* responder, - FlKeyResponderAsyncCallback callback, + FlKeyChannelResponderAsyncCallback callback, gpointer user_data) { FlKeyChannelUserData* self = FL_KEY_CHANNEL_USER_DATA( g_object_new(fl_key_channel_user_data_get_type(), nullptr)); @@ -98,28 +98,7 @@ struct _FlKeyChannelResponder { FlKeyChannelResponderMock* mock; }; -static void fl_key_channel_responder_iface_init(FlKeyResponderInterface* iface); - -G_DEFINE_TYPE_WITH_CODE( - FlKeyChannelResponder, - fl_key_channel_responder, - G_TYPE_OBJECT, - G_IMPLEMENT_INTERFACE(FL_TYPE_KEY_RESPONDER, - fl_key_channel_responder_iface_init)) - -static void fl_key_channel_responder_handle_event( - FlKeyResponder* responder, - FlKeyEvent* event, - uint64_t specified_logical_key, - FlKeyResponderAsyncCallback callback, - gpointer user_data); - -static void fl_key_channel_responder_iface_init( - FlKeyResponderInterface* iface) { - iface->handle_event = fl_key_channel_responder_handle_event; -} - -/* Implement FlKeyChannelResponder */ +G_DEFINE_TYPE(FlKeyChannelResponder, fl_key_channel_responder, G_TYPE_OBJECT) // Handles a response from the method channel to a key event sent to the // framework earlier. @@ -194,14 +173,12 @@ FlKeyChannelResponder* fl_key_channel_responder_new( return self; } -// Sends a key event to the framework. -static void fl_key_channel_responder_handle_event( - FlKeyResponder* responder, +void fl_key_channel_responder_handle_event( + FlKeyChannelResponder* self, FlKeyEvent* event, uint64_t specified_logical_key, - FlKeyResponderAsyncCallback callback, + FlKeyChannelResponderAsyncCallback callback, gpointer user_data) { - FlKeyChannelResponder* self = FL_KEY_CHANNEL_RESPONDER(responder); g_return_if_fail(event != nullptr); g_return_if_fail(callback != nullptr); diff --git a/shell/platform/linux/fl_key_channel_responder.h b/shell/platform/linux/fl_key_channel_responder.h index 9f133d64483a5..66a47d22bd1ac 100644 --- a/shell/platform/linux/fl_key_channel_responder.h +++ b/shell/platform/linux/fl_key_channel_responder.h @@ -5,10 +5,7 @@ #ifndef FLUTTER_SHELL_PLATFORM_LINUX_FL_KEY_CHANNEL_RESPONDER_H_ #define FLUTTER_SHELL_PLATFORM_LINUX_FL_KEY_CHANNEL_RESPONDER_H_ -#include - -#include "flutter/shell/platform/linux/fl_key_responder.h" -#include "flutter/shell/platform/linux/fl_keyboard_handler.h" +#include "flutter/shell/platform/linux/fl_key_event.h" #include "flutter/shell/platform/linux/public/flutter_linux/fl_binary_messenger.h" #include "flutter/shell/platform/linux/public/flutter_linux/fl_value.h" @@ -37,13 +34,24 @@ typedef struct _FlKeyChannelResponderMock { G_BEGIN_DECLS -#define FL_TYPE_KEY_CHANNEL_RESPONDER fl_key_channel_responder_get_type() G_DECLARE_FINAL_TYPE(FlKeyChannelResponder, fl_key_channel_responder, FL, KEY_CHANNEL_RESPONDER, GObject); +/** + * FlKeyChannelResponderAsyncCallback: + * @event: whether the event has been handled. + * @user_data: the same value as user_data sent by + * #fl_key_responder_handle_event. + * + * The signature for a callback with which a #FlKeyChannelResponder + *asynchronously reports whether the responder handles the event. + **/ +typedef void (*FlKeyChannelResponderAsyncCallback)(bool handled, + gpointer user_data); + /** * FlKeyChannelResponder: * @@ -66,6 +74,28 @@ FlKeyChannelResponder* fl_key_channel_responder_new( FlBinaryMessenger* messenger, FlKeyChannelResponderMock* mock = nullptr); +/** + * fl_key_channel_responder_handle_event: + * @responder: the #FlKeyChannelResponder self. + * @event: the event to be handled. Must not be null. The object is managed by + * callee and must not be assumed available after this function. + * @specified_logical_key: + * @callback: the callback to report the result. It should be called exactly + * once. Must not be null. + * @user_data: a value that will be sent back in the callback. Can be null. + * + * Let the responder handle an event, expecting the responder to report + * whether to handle the event. The result will be reported by invoking + * `callback` exactly once, which might happen after + * `fl_key_channel_responder_handle_event` or during it. + */ +void fl_key_channel_responder_handle_event( + FlKeyChannelResponder* responder, + FlKeyEvent* event, + uint64_t specified_logical_key, + FlKeyChannelResponderAsyncCallback callback, + gpointer user_data); + G_END_DECLS #endif // FLUTTER_SHELL_PLATFORM_LINUX_FL_KEY_CHANNEL_RESPONDER_H_ diff --git a/shell/platform/linux/fl_key_channel_responder_test.cc b/shell/platform/linux/fl_key_channel_responder_test.cc index 2d38456af29c5..2c68d40b0d12a 100644 --- a/shell/platform/linux/fl_key_channel_responder_test.cc +++ b/shell/platform/linux/fl_key_channel_responder_test.cc @@ -39,12 +39,13 @@ TEST(FlKeyChannelResponderTest, SendKeyEvent) { .value_converter = echo_response_cb, .channel_name = "test/echo", }; - g_autoptr(FlKeyResponder) responder = - FL_KEY_RESPONDER(fl_key_channel_responder_new(messenger, &mock)); + g_autoptr(FlKeyChannelResponder) responder = + fl_key_channel_responder_new(messenger, &mock); g_autoptr(FlKeyEvent) event1 = fl_key_event_new( 12345, TRUE, 0x04, GDK_KEY_A, static_cast(0), 0); - fl_key_responder_handle_event(responder, event1, responder_callback, loop); + fl_key_channel_responder_handle_event(responder, event1, 0, + responder_callback, loop); expected_value = "{type: keydown, keymap: linux, scanCode: 4, toolkit: gtk, keyCode: 65, " "modifiers: 0, unicodeScalarValues: 65}"; @@ -55,7 +56,8 @@ TEST(FlKeyChannelResponderTest, SendKeyEvent) { g_autoptr(FlKeyEvent) event2 = fl_key_event_new( 23456, FALSE, 0x04, GDK_KEY_A, static_cast(0), 0); - fl_key_responder_handle_event(responder, event2, responder_callback, loop); + fl_key_channel_responder_handle_event(responder, event2, 0, + responder_callback, loop); expected_value = "{type: keyup, keymap: linux, scanCode: 4, toolkit: gtk, keyCode: 65, " "modifiers: 0, unicodeScalarValues: 65}"; @@ -76,12 +78,13 @@ void test_lock_event(guint key_code, .value_converter = echo_response_cb, .channel_name = "test/echo", }; - g_autoptr(FlKeyResponder) responder = - FL_KEY_RESPONDER(fl_key_channel_responder_new(messenger, &mock)); + g_autoptr(FlKeyChannelResponder) responder = + fl_key_channel_responder_new(messenger, &mock); g_autoptr(FlKeyEvent) event1 = fl_key_event_new( 12345, TRUE, 0x04, key_code, static_cast(0), 0); - fl_key_responder_handle_event(responder, event1, responder_callback, loop); + fl_key_channel_responder_handle_event(responder, event1, 0, + responder_callback, loop); expected_value = down_expected; expected_handled = FALSE; @@ -92,7 +95,8 @@ void test_lock_event(guint key_code, expected_handled = FALSE; g_autoptr(FlKeyEvent) event2 = fl_key_event_new( 12346, FALSE, 0x04, key_code, static_cast(0), 0); - fl_key_responder_handle_event(responder, event2, responder_callback, loop); + fl_key_channel_responder_handle_event(responder, event2, 0, + responder_callback, loop); // Blocks here until echo_response_cb is called. g_main_loop_run(loop); @@ -134,12 +138,13 @@ TEST(FlKeyChannelResponderTest, TestKeyEventHandledByFramework) { .value_converter = echo_response_cb, .channel_name = "test/echo", }; - g_autoptr(FlKeyResponder) responder = - FL_KEY_RESPONDER(fl_key_channel_responder_new(messenger, &mock)); + g_autoptr(FlKeyChannelResponder) responder = + fl_key_channel_responder_new(messenger, &mock); g_autoptr(FlKeyEvent) event = fl_key_event_new( 12345, TRUE, 0x04, GDK_KEY_A, static_cast(0), 0); - fl_key_responder_handle_event(responder, event, responder_callback, loop); + fl_key_channel_responder_handle_event(responder, event, 0, responder_callback, + loop); expected_handled = TRUE; expected_value = "{type: keydown, keymap: linux, scanCode: 4, toolkit: gtk, " @@ -158,13 +163,13 @@ TEST(FlKeyChannelResponderTest, UseSpecifiedLogicalKey) { .value_converter = echo_response_cb, .channel_name = "test/echo", }; - g_autoptr(FlKeyResponder) responder = - FL_KEY_RESPONDER(fl_key_channel_responder_new(messenger, &mock)); + g_autoptr(FlKeyChannelResponder) responder = + fl_key_channel_responder_new(messenger, &mock); g_autoptr(FlKeyEvent) event = fl_key_event_new( 12345, TRUE, 0x04, GDK_KEY_A, static_cast(0), 0); - fl_key_responder_handle_event(responder, event, responder_callback, loop, - 888); + fl_key_channel_responder_handle_event(responder, event, 888, + responder_callback, loop); expected_handled = TRUE; expected_value = "{type: keydown, keymap: linux, scanCode: 4, toolkit: gtk, " diff --git a/shell/platform/linux/fl_key_embedder_responder.cc b/shell/platform/linux/fl_key_embedder_responder.cc index 922922a956c15..4118b6c1ddaa2 100644 --- a/shell/platform/linux/fl_key_embedder_responder.cc +++ b/shell/platform/linux/fl_key_embedder_responder.cc @@ -73,14 +73,11 @@ static uint64_t to_lower(uint64_t n) { return n; } -/* Define FlKeyEmbedderUserData */ - /** * FlKeyEmbedderUserData: * The user_data used when #FlKeyEmbedderResponder sends message through the * embedder.SendKeyEvent API. */ -#define FL_TYPE_EMBEDDER_USER_DATA fl_key_embedder_user_data_get_type() G_DECLARE_FINAL_TYPE(FlKeyEmbedderUserData, fl_key_embedder_user_data, FL, @@ -90,7 +87,7 @@ G_DECLARE_FINAL_TYPE(FlKeyEmbedderUserData, struct _FlKeyEmbedderUserData { GObject parent_instance; - FlKeyResponderAsyncCallback callback; + FlKeyEmbedderResponderAsyncCallback callback; gpointer user_data; }; @@ -115,18 +112,16 @@ static void fl_key_embedder_user_data_dispose(GObject* object) { // // The callback and the user_data might be nullptr. static FlKeyEmbedderUserData* fl_key_embedder_user_data_new( - FlKeyResponderAsyncCallback callback, + FlKeyEmbedderResponderAsyncCallback callback, gpointer user_data) { FlKeyEmbedderUserData* self = FL_KEY_EMBEDDER_USER_DATA( - g_object_new(FL_TYPE_EMBEDDER_USER_DATA, nullptr)); + g_object_new(fl_key_embedder_user_data_get_type(), nullptr)); self->callback = callback; self->user_data = user_data; return self; } -/* Define FlKeyEmbedderResponder */ - namespace { typedef enum { @@ -197,30 +192,9 @@ struct _FlKeyEmbedderResponder { GHashTable* logical_key_to_lock_bit; }; -static void fl_key_embedder_responder_iface_init( - FlKeyResponderInterface* iface); static void fl_key_embedder_responder_dispose(GObject* object); -#define FL_TYPE_EMBEDDER_RESPONDER_USER_DATA \ - fl_key_embedder_responder_get_type() -G_DEFINE_TYPE_WITH_CODE( - FlKeyEmbedderResponder, - fl_key_embedder_responder, - G_TYPE_OBJECT, - G_IMPLEMENT_INTERFACE(FL_TYPE_KEY_RESPONDER, - fl_key_embedder_responder_iface_init)) - -static void fl_key_embedder_responder_handle_event( - FlKeyResponder* responder, - FlKeyEvent* event, - uint64_t specified_logical_key, - FlKeyResponderAsyncCallback callback, - gpointer user_data); - -static void fl_key_embedder_responder_iface_init( - FlKeyResponderInterface* iface) { - iface->handle_event = fl_key_embedder_responder_handle_event; -} +G_DEFINE_TYPE(FlKeyEmbedderResponder, fl_key_embedder_responder, G_TYPE_OBJECT) // Initializes the FlKeyEmbedderResponder class methods. static void fl_key_embedder_responder_class_init( @@ -264,7 +238,7 @@ FlKeyEmbedderResponder* fl_key_embedder_responder_new( EmbedderSendKeyEvent send_key_event, void* send_key_event_user_data) { FlKeyEmbedderResponder* self = FL_KEY_EMBEDDER_RESPONDER( - g_object_new(FL_TYPE_EMBEDDER_RESPONDER_USER_DATA, nullptr)); + g_object_new(fl_key_embedder_responder_get_type(), nullptr)); self->send_key_event = send_key_event; self->send_key_event_user_data = send_key_event_user_data; @@ -291,8 +265,6 @@ FlKeyEmbedderResponder* fl_key_embedder_responder_new( return self; } -/* Implement FlKeyEmbedderUserData */ - static uint64_t apply_id_plane(uint64_t logical_id, uint64_t plane) { return (logical_id & kValueMask) | plane; } @@ -774,10 +746,10 @@ static uint64_t corrected_modifier_physical_key( } static void fl_key_embedder_responder_handle_event_impl( - FlKeyResponder* responder, + FlKeyEmbedderResponder* responder, FlKeyEvent* event, uint64_t specified_logical_key, - FlKeyResponderAsyncCallback callback, + FlKeyEmbedderResponderAsyncCallback callback, gpointer user_data) { FlKeyEmbedderResponder* self = FL_KEY_EMBEDDER_RESPONDER(responder); @@ -859,17 +831,15 @@ static void fl_key_embedder_responder_handle_event_impl( self->send_key_event_user_data); } -// Sends a key event to the framework. -static void fl_key_embedder_responder_handle_event( - FlKeyResponder* responder, +void fl_key_embedder_responder_handle_event( + FlKeyEmbedderResponder* self, FlKeyEvent* event, uint64_t specified_logical_key, - FlKeyResponderAsyncCallback callback, + FlKeyEmbedderResponderAsyncCallback callback, gpointer user_data) { - FlKeyEmbedderResponder* self = FL_KEY_EMBEDDER_RESPONDER(responder); self->sent_any_events = false; fl_key_embedder_responder_handle_event_impl( - responder, event, specified_logical_key, callback, user_data); + self, event, specified_logical_key, callback, user_data); if (!self->sent_any_events) { self->send_key_event(&kEmptyEvent, nullptr, nullptr, self->send_key_event_user_data); diff --git a/shell/platform/linux/fl_key_embedder_responder.h b/shell/platform/linux/fl_key_embedder_responder.h index c916a6286217a..1905d4b3fa329 100644 --- a/shell/platform/linux/fl_key_embedder_responder.h +++ b/shell/platform/linux/fl_key_embedder_responder.h @@ -5,13 +5,8 @@ #ifndef FLUTTER_SHELL_PLATFORM_LINUX_FL_KEY_EMBEDDER_RESPONDER_H_ #define FLUTTER_SHELL_PLATFORM_LINUX_FL_KEY_EMBEDDER_RESPONDER_H_ -#include -#include - -#include "flutter/shell/platform/linux/fl_key_responder.h" -#include "flutter/shell/platform/linux/fl_keyboard_handler.h" -#include "flutter/shell/platform/linux/public/flutter_linux/fl_binary_messenger.h" -#include "flutter/shell/platform/linux/public/flutter_linux/fl_value.h" +#include "flutter/shell/platform/linux/fl_engine_private.h" +#include "flutter/shell/platform/linux/fl_key_event.h" constexpr int kMaxConvertedKeyData = 3; @@ -31,9 +26,20 @@ typedef void (*EmbedderSendKeyEvent)(const FlutterKeyEvent* event, void* callback_user_data, void* send_key_event_user_data); +/** + * FlKeyEmbedderResponderAsyncCallback: + * @event: whether the event has been handled. + * @user_data: the same value as user_data sent by + * #fl_key_responder_handle_event. + * + * The signature for a callback with which a #FlKeyEmbedderResponder + *asynchronously reports whether the responder handles the event. + **/ +typedef void (*FlKeyEmbedderResponderAsyncCallback)(bool handled, + gpointer user_data); + G_BEGIN_DECLS -#define FL_TYPE_KEY_EMBEDDER_RESPONDER fl_key_embedder_responder_get_type() G_DECLARE_FINAL_TYPE(FlKeyEmbedderResponder, fl_key_embedder_responder, FL, @@ -66,6 +72,28 @@ FlKeyEmbedderResponder* fl_key_embedder_responder_new( EmbedderSendKeyEvent send_key_event, void* send_key_event_user_data); +/** + * fl_key_embedder_responder_handle_event: + * @responder: the #FlKeyEmbedderResponder self. + * @event: the event to be handled. Must not be null. The object is managed by + * callee and must not be assumed available after this function. + * @specified_logical_key: + * @callback: the callback to report the result. It should be called exactly + * once. Must not be null. + * @user_data: a value that will be sent back in the callback. Can be null. + * + * Let the responder handle an event, expecting the responder to report + * whether to handle the event. The result will be reported by invoking + * `callback` exactly once, which might happen after + * `fl_key_embedder_responder_handle_event` or during it. + */ +void fl_key_embedder_responder_handle_event( + FlKeyEmbedderResponder* responder, + FlKeyEvent* event, + uint64_t specified_logical_key, + FlKeyEmbedderResponderAsyncCallback callback, + gpointer user_data); + /** * fl_key_embedder_responder_sync_modifiers_if_needed: * @responder: the #FlKeyEmbedderResponder self. diff --git a/shell/platform/linux/fl_key_embedder_responder_private.h b/shell/platform/linux/fl_key_embedder_responder_private.h index 6e92957eb862d..69b9f271d1845 100644 --- a/shell/platform/linux/fl_key_embedder_responder_private.h +++ b/shell/platform/linux/fl_key_embedder_responder_private.h @@ -7,7 +7,6 @@ #include -#include "flutter/shell/platform/linux/fl_key_responder.h" #include "flutter/shell/platform/linux/fl_keyboard_handler.h" #include "flutter/shell/platform/linux/public/flutter_linux/fl_binary_messenger.h" #include "flutter/shell/platform/linux/public/flutter_linux/fl_value.h" diff --git a/shell/platform/linux/fl_key_embedder_responder_test.cc b/shell/platform/linux/fl_key_embedder_responder_test.cc index 3a1ab31100ca9..568f4160f0ea7 100644 --- a/shell/platform/linux/fl_key_embedder_responder_test.cc +++ b/shell/platform/linux/fl_key_embedder_responder_test.cc @@ -138,8 +138,8 @@ static void clear_g_call_records() { TEST(FlKeyEmbedderResponderTest, SendKeyEvent) { EXPECT_EQ(g_call_records, nullptr); g_call_records = g_ptr_array_new_with_free_func(g_object_unref); - FlKeyResponder* responder = FL_KEY_RESPONDER( - fl_key_embedder_responder_new(record_calls, g_call_records)); + FlKeyEmbedderResponder* responder = + fl_key_embedder_responder_new(record_calls, g_call_records); int user_data = 123; // Arbitrary user data FlKeyEmbedderCallRecord* record; @@ -149,8 +149,8 @@ TEST(FlKeyEmbedderResponderTest, SendKeyEvent) { g_autoptr(FlKeyEvent) event1 = fl_key_event_new(12345, kPress, kKeyCodeKeyA, GDK_KEY_a, static_cast(0), 0); - fl_key_responder_handle_event(responder, event1, verify_response_handled, - &user_data); + fl_key_embedder_responder_handle_event(responder, event1, 0, + verify_response_handled, &user_data); EXPECT_EQ(g_call_records->len, 1u); record = FL_KEY_EMBEDDER_CALL_RECORD(g_ptr_array_index(g_call_records, 0)); @@ -169,8 +169,8 @@ TEST(FlKeyEmbedderResponderTest, SendKeyEvent) { g_autoptr(FlKeyEvent) event2 = fl_key_event_new(12346, kRelease, kKeyCodeKeyA, GDK_KEY_a, static_cast(0), 0); - fl_key_responder_handle_event(responder, event2, verify_response_handled, - &user_data); + fl_key_embedder_responder_handle_event(responder, event2, 0, + verify_response_handled, &user_data); EXPECT_EQ(g_call_records->len, 1u); record = FL_KEY_EMBEDDER_CALL_RECORD(g_ptr_array_index(g_call_records, 0)); @@ -190,8 +190,8 @@ TEST(FlKeyEmbedderResponderTest, SendKeyEvent) { g_autoptr(FlKeyEvent) event3 = fl_key_event_new(12347, kPress, kKeyCodeKeyA, GDK_KEY_q, static_cast(0), 0); - fl_key_responder_handle_event(responder, event3, verify_response_handled, - &user_data); + fl_key_embedder_responder_handle_event(responder, event3, 0, + verify_response_handled, &user_data); EXPECT_EQ(g_call_records->len, 1u); record = FL_KEY_EMBEDDER_CALL_RECORD(g_ptr_array_index(g_call_records, 0)); @@ -210,8 +210,8 @@ TEST(FlKeyEmbedderResponderTest, SendKeyEvent) { g_autoptr(FlKeyEvent) event4 = fl_key_event_new(12348, kRelease, kKeyCodeKeyA, GDK_KEY_q, static_cast(0), 0); - fl_key_responder_handle_event(responder, event4, verify_response_handled, - &user_data); + fl_key_embedder_responder_handle_event(responder, event4, 0, + verify_response_handled, &user_data); EXPECT_EQ(g_call_records->len, 1u); record = FL_KEY_EMBEDDER_CALL_RECORD(g_ptr_array_index(g_call_records, 0)); @@ -234,8 +234,8 @@ TEST(FlKeyEmbedderResponderTest, SendKeyEvent) { TEST(FlKeyEmbedderResponderTest, UsesSpecifiedLogicalKey) { EXPECT_EQ(g_call_records, nullptr); g_call_records = g_ptr_array_new_with_free_func(g_object_unref); - FlKeyResponder* responder = FL_KEY_RESPONDER( - fl_key_embedder_responder_new(record_calls, g_call_records)); + FlKeyEmbedderResponder* responder = + fl_key_embedder_responder_new(record_calls, g_call_records); int user_data = 123; // Arbitrary user data FlKeyEmbedderCallRecord* record; @@ -245,8 +245,8 @@ TEST(FlKeyEmbedderResponderTest, UsesSpecifiedLogicalKey) { g_autoptr(FlKeyEvent) event = fl_key_event_new(12345, kPress, kKeyCodeDigit1, GDK_KEY_ampersand, static_cast(0), 0); - fl_key_responder_handle_event(responder, event, verify_response_handled, - &user_data, kLogicalDigit1); + fl_key_embedder_responder_handle_event(responder, event, kLogicalDigit1, + verify_response_handled, &user_data); EXPECT_EQ(g_call_records->len, 1u); record = FL_KEY_EMBEDDER_CALL_RECORD(g_ptr_array_index(g_call_records, 0)); @@ -269,8 +269,8 @@ TEST(FlKeyEmbedderResponderTest, UsesSpecifiedLogicalKey) { TEST(FlKeyEmbedderResponderTest, PressShiftDuringLetterKeyTap) { EXPECT_EQ(g_call_records, nullptr); g_call_records = g_ptr_array_new_with_free_func(g_object_unref); - FlKeyResponder* responder = FL_KEY_RESPONDER( - fl_key_embedder_responder_new(record_calls, g_call_records)); + FlKeyEmbedderResponder* responder = + fl_key_embedder_responder_new(record_calls, g_call_records); int user_data = 123; // Arbitrary user data FlKeyEmbedderCallRecord* record; @@ -279,8 +279,8 @@ TEST(FlKeyEmbedderResponderTest, PressShiftDuringLetterKeyTap) { g_autoptr(FlKeyEvent) event1 = fl_key_event_new(101, kPress, kKeyCodeShiftRight, GDK_KEY_Shift_R, static_cast(0), 0); - fl_key_responder_handle_event(responder, event1, verify_response_handled, - &user_data); + fl_key_embedder_responder_handle_event(responder, event1, 0, + verify_response_handled, &user_data); EXPECT_EQ(g_call_records->len, 1u); record = FL_KEY_EMBEDDER_CALL_RECORD(g_ptr_array_index(g_call_records, 0)); @@ -296,8 +296,8 @@ TEST(FlKeyEmbedderResponderTest, PressShiftDuringLetterKeyTap) { // Press key A g_autoptr(FlKeyEvent) event2 = fl_key_event_new(102, kPress, kKeyCodeKeyA, GDK_KEY_A, GDK_SHIFT_MASK, 0); - fl_key_responder_handle_event(responder, event2, verify_response_handled, - &user_data); + fl_key_embedder_responder_handle_event(responder, event2, 0, + verify_response_handled, &user_data); EXPECT_EQ(g_call_records->len, 1u); record = FL_KEY_EMBEDDER_CALL_RECORD(g_ptr_array_index(g_call_records, 0)); @@ -313,8 +313,8 @@ TEST(FlKeyEmbedderResponderTest, PressShiftDuringLetterKeyTap) { // Release shift right g_autoptr(FlKeyEvent) event3 = fl_key_event_new( 103, kRelease, kKeyCodeShiftRight, GDK_KEY_Shift_R, GDK_SHIFT_MASK, 0); - fl_key_responder_handle_event(responder, event3, verify_response_handled, - &user_data); + fl_key_embedder_responder_handle_event(responder, event3, 0, + verify_response_handled, &user_data); EXPECT_EQ(g_call_records->len, 1u); record = FL_KEY_EMBEDDER_CALL_RECORD(g_ptr_array_index(g_call_records, 0)); @@ -331,8 +331,8 @@ TEST(FlKeyEmbedderResponderTest, PressShiftDuringLetterKeyTap) { g_autoptr(FlKeyEvent) event4 = fl_key_event_new(104, kRelease, kKeyCodeKeyA, GDK_KEY_A, static_cast(0), 0); - fl_key_responder_handle_event(responder, event4, verify_response_handled, - &user_data); + fl_key_embedder_responder_handle_event(responder, event4, 0, + verify_response_handled, &user_data); EXPECT_EQ(g_call_records->len, 1u); record = FL_KEY_EMBEDDER_CALL_RECORD(g_ptr_array_index(g_call_records, 0)); @@ -360,8 +360,8 @@ TEST(FlKeyEmbedderResponderTest, PressShiftDuringLetterKeyTap) { TEST(FlKeyEmbedderResponderTest, TapNumPadKeysBetweenNumLockEvents) { EXPECT_EQ(g_call_records, nullptr); g_call_records = g_ptr_array_new_with_free_func(g_object_unref); - FlKeyResponder* responder = FL_KEY_RESPONDER( - fl_key_embedder_responder_new(record_calls, g_call_records)); + FlKeyEmbedderResponder* responder = + fl_key_embedder_responder_new(record_calls, g_call_records); int user_data = 123; // Arbitrary user data FlKeyEmbedderCallRecord* record; @@ -370,8 +370,8 @@ TEST(FlKeyEmbedderResponderTest, TapNumPadKeysBetweenNumLockEvents) { g_autoptr(FlKeyEvent) event1 = fl_key_event_new(101, kPress, kKeyCodeNumpad1, GDK_KEY_KP_End, static_cast(0), 0); - fl_key_responder_handle_event(responder, event1, verify_response_handled, - &user_data); + fl_key_embedder_responder_handle_event(responder, event1, 0, + verify_response_handled, &user_data); EXPECT_EQ(g_call_records->len, 1u); record = FL_KEY_EMBEDDER_CALL_RECORD(g_ptr_array_index(g_call_records, 0)); @@ -388,8 +388,8 @@ TEST(FlKeyEmbedderResponderTest, TapNumPadKeysBetweenNumLockEvents) { g_autoptr(FlKeyEvent) event2 = fl_key_event_new(102, kPress, kKeyCodeNumLock, GDK_KEY_Num_Lock, static_cast(0), 0); - fl_key_responder_handle_event(responder, event2, verify_response_handled, - &user_data); + fl_key_embedder_responder_handle_event(responder, event2, 0, + verify_response_handled, &user_data); EXPECT_EQ(g_call_records->len, 1u); record = FL_KEY_EMBEDDER_CALL_RECORD(g_ptr_array_index(g_call_records, 0)); @@ -405,8 +405,8 @@ TEST(FlKeyEmbedderResponderTest, TapNumPadKeysBetweenNumLockEvents) { // Release numpad 1 (stage 1) g_autoptr(FlKeyEvent) event3 = fl_key_event_new( 104, kRelease, kKeyCodeNumpad1, GDK_KEY_KP_1, GDK_MOD2_MASK, 0); - fl_key_responder_handle_event(responder, event3, verify_response_handled, - &user_data); + fl_key_embedder_responder_handle_event(responder, event3, 0, + verify_response_handled, &user_data); EXPECT_EQ(g_call_records->len, 1u); record = FL_KEY_EMBEDDER_CALL_RECORD(g_ptr_array_index(g_call_records, 0)); @@ -422,8 +422,8 @@ TEST(FlKeyEmbedderResponderTest, TapNumPadKeysBetweenNumLockEvents) { // Release NumLock (stage 1 -> 2) g_autoptr(FlKeyEvent) event4 = fl_key_event_new( 103, kRelease, kKeyCodeNumLock, GDK_KEY_Num_Lock, GDK_MOD2_MASK, 0); - fl_key_responder_handle_event(responder, event4, verify_response_handled, - &user_data); + fl_key_embedder_responder_handle_event(responder, event4, 0, + verify_response_handled, &user_data); EXPECT_EQ(g_call_records->len, 1u); record = FL_KEY_EMBEDDER_CALL_RECORD(g_ptr_array_index(g_call_records, 0)); @@ -439,8 +439,8 @@ TEST(FlKeyEmbedderResponderTest, TapNumPadKeysBetweenNumLockEvents) { // Press Numpad 1 (stage 2) g_autoptr(FlKeyEvent) event5 = fl_key_event_new( 101, kPress, kKeyCodeNumpad1, GDK_KEY_KP_End, GDK_MOD2_MASK, 0); - fl_key_responder_handle_event(responder, event5, verify_response_handled, - &user_data); + fl_key_embedder_responder_handle_event(responder, event5, 0, + verify_response_handled, &user_data); EXPECT_EQ(g_call_records->len, 1u); record = FL_KEY_EMBEDDER_CALL_RECORD(g_ptr_array_index(g_call_records, 0)); @@ -456,8 +456,8 @@ TEST(FlKeyEmbedderResponderTest, TapNumPadKeysBetweenNumLockEvents) { // Press NumLock (stage 2 -> 3) g_autoptr(FlKeyEvent) event6 = fl_key_event_new( 102, kPress, kKeyCodeNumLock, GDK_KEY_Num_Lock, GDK_MOD2_MASK, 0); - fl_key_responder_handle_event(responder, event6, verify_response_handled, - &user_data); + fl_key_embedder_responder_handle_event(responder, event6, 0, + verify_response_handled, &user_data); EXPECT_EQ(g_call_records->len, 1u); record = FL_KEY_EMBEDDER_CALL_RECORD(g_ptr_array_index(g_call_records, 0)); @@ -473,8 +473,8 @@ TEST(FlKeyEmbedderResponderTest, TapNumPadKeysBetweenNumLockEvents) { // Release numpad 1 (stage 3) g_autoptr(FlKeyEvent) event7 = fl_key_event_new( 104, kRelease, kKeyCodeNumpad1, GDK_KEY_KP_1, GDK_MOD2_MASK, 0); - fl_key_responder_handle_event(responder, event7, verify_response_handled, - &user_data); + fl_key_embedder_responder_handle_event(responder, event7, 0, + verify_response_handled, &user_data); EXPECT_EQ(g_call_records->len, 1u); record = FL_KEY_EMBEDDER_CALL_RECORD(g_ptr_array_index(g_call_records, 0)); @@ -490,8 +490,8 @@ TEST(FlKeyEmbedderResponderTest, TapNumPadKeysBetweenNumLockEvents) { // Release NumLock (stage 3 -> 0) g_autoptr(FlKeyEvent) event8 = fl_key_event_new( 103, kRelease, kKeyCodeNumLock, GDK_KEY_Num_Lock, GDK_MOD2_MASK, 0); - fl_key_responder_handle_event(responder, event8, verify_response_handled, - &user_data); + fl_key_embedder_responder_handle_event(responder, event8, 0, + verify_response_handled, &user_data); EXPECT_EQ(g_call_records->len, 1u); record = FL_KEY_EMBEDDER_CALL_RECORD(g_ptr_array_index(g_call_records, 0)); @@ -515,8 +515,8 @@ TEST(FlKeyEmbedderResponderTest, TapNumPadKeysBetweenNumLockEvents) { TEST(FlKeyEmbedderResponderTest, ReleaseShiftKeyBetweenDigitKeyEvents) { EXPECT_EQ(g_call_records, nullptr); g_call_records = g_ptr_array_new_with_free_func(g_object_unref); - FlKeyResponder* responder = FL_KEY_RESPONDER( - fl_key_embedder_responder_new(record_calls, g_call_records)); + FlKeyEmbedderResponder* responder = + fl_key_embedder_responder_new(record_calls, g_call_records); int user_data = 123; // Arbitrary user data FlKeyEmbedderCallRecord* record; @@ -526,8 +526,8 @@ TEST(FlKeyEmbedderResponderTest, ReleaseShiftKeyBetweenDigitKeyEvents) { // Press shift left g_autoptr(FlKeyEvent) event1 = fl_key_event_new( 101, kPress, kKeyCodeShiftLeft, GDK_KEY_Shift_L, state, 0); - fl_key_responder_handle_event(responder, event1, verify_response_handled, - &user_data); + fl_key_embedder_responder_handle_event(responder, event1, 0, + verify_response_handled, &user_data); EXPECT_EQ(g_call_records->len, 1u); record = FL_KEY_EMBEDDER_CALL_RECORD(g_ptr_array_index(g_call_records, 0)); @@ -545,8 +545,8 @@ TEST(FlKeyEmbedderResponderTest, ReleaseShiftKeyBetweenDigitKeyEvents) { // Press digit 1, which is '!' on a US keyboard g_autoptr(FlKeyEvent) event2 = fl_key_event_new(102, kPress, kKeyCodeDigit1, GDK_KEY_exclam, state, 0); - fl_key_responder_handle_event(responder, event2, verify_response_handled, - &user_data); + fl_key_embedder_responder_handle_event(responder, event2, 0, + verify_response_handled, &user_data); EXPECT_EQ(g_call_records->len, 1u); record = FL_KEY_EMBEDDER_CALL_RECORD(g_ptr_array_index(g_call_records, 0)); @@ -562,8 +562,8 @@ TEST(FlKeyEmbedderResponderTest, ReleaseShiftKeyBetweenDigitKeyEvents) { // Release shift g_autoptr(FlKeyEvent) event3 = fl_key_event_new( 103, kRelease, kKeyCodeShiftLeft, GDK_KEY_Shift_L, state, 0); - fl_key_responder_handle_event(responder, event3, verify_response_handled, - &user_data); + fl_key_embedder_responder_handle_event(responder, event3, 0, + verify_response_handled, &user_data); EXPECT_EQ(g_call_records->len, 1u); record = FL_KEY_EMBEDDER_CALL_RECORD(g_ptr_array_index(g_call_records, 0)); @@ -581,8 +581,8 @@ TEST(FlKeyEmbedderResponderTest, ReleaseShiftKeyBetweenDigitKeyEvents) { // Release digit 1, which is "1" because shift has been released. g_autoptr(FlKeyEvent) event4 = fl_key_event_new(104, kRelease, kKeyCodeDigit1, GDK_KEY_1, state, 0); - fl_key_responder_handle_event(responder, event4, verify_response_handled, - &user_data); + fl_key_embedder_responder_handle_event(responder, event4, 0, + verify_response_handled, &user_data); EXPECT_EQ(g_call_records->len, 1u); record = FL_KEY_EMBEDDER_CALL_RECORD(g_ptr_array_index(g_call_records, 0)); @@ -606,8 +606,8 @@ TEST(FlKeyEmbedderResponderTest, ReleaseShiftKeyBetweenDigitKeyEvents) { TEST(FlKeyEmbedderResponderTest, TapLetterKeysBetweenCapsLockEvents) { EXPECT_EQ(g_call_records, nullptr); g_call_records = g_ptr_array_new_with_free_func(g_object_unref); - FlKeyResponder* responder = FL_KEY_RESPONDER( - fl_key_embedder_responder_new(record_calls, g_call_records)); + FlKeyEmbedderResponder* responder = + fl_key_embedder_responder_new(record_calls, g_call_records); int user_data = 123; // Arbitrary user data FlKeyEmbedderCallRecord* record; @@ -616,8 +616,8 @@ TEST(FlKeyEmbedderResponderTest, TapLetterKeysBetweenCapsLockEvents) { g_autoptr(FlKeyEvent) event1 = fl_key_event_new(101, kPress, kKeyCodeCapsLock, GDK_KEY_Caps_Lock, static_cast(0), 0); - fl_key_responder_handle_event(responder, event1, verify_response_handled, - &user_data); + fl_key_embedder_responder_handle_event(responder, event1, 0, + verify_response_handled, &user_data); EXPECT_EQ(g_call_records->len, 1u); record = FL_KEY_EMBEDDER_CALL_RECORD(g_ptr_array_index(g_call_records, 0)); @@ -633,8 +633,8 @@ TEST(FlKeyEmbedderResponderTest, TapLetterKeysBetweenCapsLockEvents) { // Press key A (stage 1) g_autoptr(FlKeyEvent) event2 = fl_key_event_new(102, kPress, kKeyCodeKeyA, GDK_KEY_A, GDK_LOCK_MASK, 0); - fl_key_responder_handle_event(responder, event2, verify_response_handled, - &user_data); + fl_key_embedder_responder_handle_event(responder, event2, 0, + verify_response_handled, &user_data); EXPECT_EQ(g_call_records->len, 1u); record = FL_KEY_EMBEDDER_CALL_RECORD(g_ptr_array_index(g_call_records, 0)); @@ -650,8 +650,8 @@ TEST(FlKeyEmbedderResponderTest, TapLetterKeysBetweenCapsLockEvents) { // Release CapsLock (stage 1 -> 2) g_autoptr(FlKeyEvent) event3 = fl_key_event_new( 103, kRelease, kKeyCodeCapsLock, GDK_KEY_Caps_Lock, GDK_LOCK_MASK, 0); - fl_key_responder_handle_event(responder, event3, verify_response_handled, - &user_data); + fl_key_embedder_responder_handle_event(responder, event3, 0, + verify_response_handled, &user_data); EXPECT_EQ(g_call_records->len, 1u); record = FL_KEY_EMBEDDER_CALL_RECORD(g_ptr_array_index(g_call_records, 0)); @@ -667,8 +667,8 @@ TEST(FlKeyEmbedderResponderTest, TapLetterKeysBetweenCapsLockEvents) { // Release key A (stage 2) g_autoptr(FlKeyEvent) event4 = fl_key_event_new(104, kRelease, kKeyCodeKeyA, GDK_KEY_A, GDK_LOCK_MASK, 0); - fl_key_responder_handle_event(responder, event4, verify_response_handled, - &user_data); + fl_key_embedder_responder_handle_event(responder, event4, 0, + verify_response_handled, &user_data); EXPECT_EQ(g_call_records->len, 1u); record = FL_KEY_EMBEDDER_CALL_RECORD(g_ptr_array_index(g_call_records, 0)); @@ -684,8 +684,8 @@ TEST(FlKeyEmbedderResponderTest, TapLetterKeysBetweenCapsLockEvents) { // Press CapsLock (stage 2 -> 3) g_autoptr(FlKeyEvent) event5 = fl_key_event_new( 105, kPress, kKeyCodeCapsLock, GDK_KEY_Caps_Lock, GDK_LOCK_MASK, 0); - fl_key_responder_handle_event(responder, event5, verify_response_handled, - &user_data); + fl_key_embedder_responder_handle_event(responder, event5, 0, + verify_response_handled, &user_data); EXPECT_EQ(g_call_records->len, 1u); record = FL_KEY_EMBEDDER_CALL_RECORD(g_ptr_array_index(g_call_records, 0)); @@ -701,8 +701,8 @@ TEST(FlKeyEmbedderResponderTest, TapLetterKeysBetweenCapsLockEvents) { // Press key A (stage 3) g_autoptr(FlKeyEvent) event6 = fl_key_event_new(106, kPress, kKeyCodeKeyA, GDK_KEY_A, GDK_LOCK_MASK, 0); - fl_key_responder_handle_event(responder, event6, verify_response_handled, - &user_data); + fl_key_embedder_responder_handle_event(responder, event6, 0, + verify_response_handled, &user_data); EXPECT_EQ(g_call_records->len, 1u); record = FL_KEY_EMBEDDER_CALL_RECORD(g_ptr_array_index(g_call_records, 0)); @@ -718,8 +718,8 @@ TEST(FlKeyEmbedderResponderTest, TapLetterKeysBetweenCapsLockEvents) { // Release CapsLock (stage 3 -> 0) g_autoptr(FlKeyEvent) event7 = fl_key_event_new( 107, kRelease, kKeyCodeCapsLock, GDK_KEY_Caps_Lock, GDK_LOCK_MASK, 0); - fl_key_responder_handle_event(responder, event7, verify_response_handled, - &user_data); + fl_key_embedder_responder_handle_event(responder, event7, 0, + verify_response_handled, &user_data); EXPECT_EQ(g_call_records->len, 1u); record = FL_KEY_EMBEDDER_CALL_RECORD(g_ptr_array_index(g_call_records, 0)); @@ -736,8 +736,8 @@ TEST(FlKeyEmbedderResponderTest, TapLetterKeysBetweenCapsLockEvents) { g_autoptr(FlKeyEvent) event8 = fl_key_event_new(108, kRelease, kKeyCodeKeyA, GDK_KEY_a, static_cast(0), 0); - fl_key_responder_handle_event(responder, event8, verify_response_handled, - &user_data); + fl_key_embedder_responder_handle_event(responder, event8, 0, + verify_response_handled, &user_data); EXPECT_EQ(g_call_records->len, 1u); record = FL_KEY_EMBEDDER_CALL_RECORD(g_ptr_array_index(g_call_records, 0)); @@ -761,8 +761,8 @@ TEST(FlKeyEmbedderResponderTest, TapLetterKeysBetweenCapsLockEvents) { TEST(FlKeyEmbedderResponderTest, TapLetterKeysBetweenCapsLockEventsReversed) { EXPECT_EQ(g_call_records, nullptr); g_call_records = g_ptr_array_new_with_free_func(g_object_unref); - FlKeyResponder* responder = FL_KEY_RESPONDER( - fl_key_embedder_responder_new(record_calls, g_call_records)); + FlKeyEmbedderResponder* responder = + fl_key_embedder_responder_new(record_calls, g_call_records); int user_data = 123; // Arbitrary user data FlKeyEmbedderCallRecord* record; @@ -770,8 +770,8 @@ TEST(FlKeyEmbedderResponderTest, TapLetterKeysBetweenCapsLockEventsReversed) { // Press key A (stage 0) g_autoptr(FlKeyEvent) event1 = fl_key_event_new( 101, kPress, kKeyCodeKeyA, GDK_KEY_a, static_cast(0), 0); - fl_key_responder_handle_event(responder, event1, verify_response_handled, - &user_data); + fl_key_embedder_responder_handle_event(responder, event1, 0, + verify_response_handled, &user_data); EXPECT_EQ(g_call_records->len, 1u); record = FL_KEY_EMBEDDER_CALL_RECORD(g_ptr_array_index(g_call_records, 0)); @@ -787,8 +787,8 @@ TEST(FlKeyEmbedderResponderTest, TapLetterKeysBetweenCapsLockEventsReversed) { // Press CapsLock (stage 0 -> 1) g_autoptr(FlKeyEvent) event2 = fl_key_event_new( 102, kPress, kKeyCodeCapsLock, GDK_KEY_Caps_Lock, GDK_LOCK_MASK, 0); - fl_key_responder_handle_event(responder, event2, verify_response_handled, - &user_data); + fl_key_embedder_responder_handle_event(responder, event2, 0, + verify_response_handled, &user_data); EXPECT_EQ(g_call_records->len, 1u); record = FL_KEY_EMBEDDER_CALL_RECORD(g_ptr_array_index(g_call_records, 0)); @@ -804,8 +804,8 @@ TEST(FlKeyEmbedderResponderTest, TapLetterKeysBetweenCapsLockEventsReversed) { // Release CapsLock (stage 1 -> 2) g_autoptr(FlKeyEvent) event3 = fl_key_event_new( 103, kRelease, kKeyCodeCapsLock, GDK_KEY_Caps_Lock, GDK_LOCK_MASK, 0); - fl_key_responder_handle_event(responder, event3, verify_response_handled, - &user_data); + fl_key_embedder_responder_handle_event(responder, event3, 0, + verify_response_handled, &user_data); EXPECT_EQ(g_call_records->len, 1u); record = FL_KEY_EMBEDDER_CALL_RECORD(g_ptr_array_index(g_call_records, 0)); @@ -821,8 +821,8 @@ TEST(FlKeyEmbedderResponderTest, TapLetterKeysBetweenCapsLockEventsReversed) { // Release key A (stage 2) g_autoptr(FlKeyEvent) event4 = fl_key_event_new(104, kRelease, kKeyCodeKeyA, GDK_KEY_A, GDK_LOCK_MASK, 0); - fl_key_responder_handle_event(responder, event4, verify_response_handled, - &user_data); + fl_key_embedder_responder_handle_event(responder, event4, 0, + verify_response_handled, &user_data); EXPECT_EQ(g_call_records->len, 1u); record = FL_KEY_EMBEDDER_CALL_RECORD(g_ptr_array_index(g_call_records, 0)); @@ -838,8 +838,8 @@ TEST(FlKeyEmbedderResponderTest, TapLetterKeysBetweenCapsLockEventsReversed) { // Press key A (stage 2) g_autoptr(FlKeyEvent) event5 = fl_key_event_new(105, kPress, kKeyCodeKeyA, GDK_KEY_A, GDK_LOCK_MASK, 0); - fl_key_responder_handle_event(responder, event5, verify_response_handled, - &user_data); + fl_key_embedder_responder_handle_event(responder, event5, 0, + verify_response_handled, &user_data); EXPECT_EQ(g_call_records->len, 1u); record = FL_KEY_EMBEDDER_CALL_RECORD(g_ptr_array_index(g_call_records, 0)); @@ -856,8 +856,8 @@ TEST(FlKeyEmbedderResponderTest, TapLetterKeysBetweenCapsLockEventsReversed) { g_autoptr(FlKeyEvent) event6 = fl_key_event_new(106, kPress, kKeyCodeCapsLock, GDK_KEY_Caps_Lock, static_cast(0), 0); - fl_key_responder_handle_event(responder, event6, verify_response_handled, - &user_data); + fl_key_embedder_responder_handle_event(responder, event6, 0, + verify_response_handled, &user_data); EXPECT_EQ(g_call_records->len, 1u); record = FL_KEY_EMBEDDER_CALL_RECORD(g_ptr_array_index(g_call_records, 0)); @@ -873,8 +873,8 @@ TEST(FlKeyEmbedderResponderTest, TapLetterKeysBetweenCapsLockEventsReversed) { // Release CapsLock (stage 3 -> 0) g_autoptr(FlKeyEvent) event7 = fl_key_event_new( 107, kRelease, kKeyCodeCapsLock, GDK_KEY_Caps_Lock, GDK_LOCK_MASK, 0); - fl_key_responder_handle_event(responder, event7, verify_response_handled, - &user_data); + fl_key_embedder_responder_handle_event(responder, event7, 0, + verify_response_handled, &user_data); EXPECT_EQ(g_call_records->len, 1u); record = FL_KEY_EMBEDDER_CALL_RECORD(g_ptr_array_index(g_call_records, 0)); @@ -891,8 +891,8 @@ TEST(FlKeyEmbedderResponderTest, TapLetterKeysBetweenCapsLockEventsReversed) { g_autoptr(FlKeyEvent) event8 = fl_key_event_new(108, kRelease, kKeyCodeKeyA, GDK_KEY_a, static_cast(0), 0); - fl_key_responder_handle_event(responder, event8, verify_response_handled, - &user_data); + fl_key_embedder_responder_handle_event(responder, event8, 0, + verify_response_handled, &user_data); EXPECT_EQ(g_call_records->len, 1u); record = FL_KEY_EMBEDDER_CALL_RECORD(g_ptr_array_index(g_call_records, 0)); @@ -912,8 +912,8 @@ TEST(FlKeyEmbedderResponderTest, TapLetterKeysBetweenCapsLockEventsReversed) { TEST(FlKeyEmbedderResponderTest, TurnDuplicateDownEventsToRepeats) { EXPECT_EQ(g_call_records, nullptr); g_call_records = g_ptr_array_new_with_free_func(g_object_unref); - FlKeyResponder* responder = FL_KEY_RESPONDER( - fl_key_embedder_responder_new(record_calls, g_call_records)); + FlKeyEmbedderResponder* responder = + fl_key_embedder_responder_new(record_calls, g_call_records); int user_data = 123; // Arbitrary user data FlKeyEmbedderCallRecord* record; @@ -921,8 +921,8 @@ TEST(FlKeyEmbedderResponderTest, TurnDuplicateDownEventsToRepeats) { // Press KeyA g_autoptr(FlKeyEvent) event1 = fl_key_event_new( 101, kPress, kKeyCodeKeyA, GDK_KEY_a, static_cast(0), 0); - fl_key_responder_handle_event(responder, event1, verify_response_handled, - &user_data); + fl_key_embedder_responder_handle_event(responder, event1, 0, + verify_response_handled, &user_data); EXPECT_EQ(g_call_records->len, 1u); @@ -934,8 +934,8 @@ TEST(FlKeyEmbedderResponderTest, TurnDuplicateDownEventsToRepeats) { g_expected_handled = false; g_autoptr(FlKeyEvent) event2 = fl_key_event_new( 102, kPress, kKeyCodeKeyA, GDK_KEY_a, static_cast(0), 0); - fl_key_responder_handle_event(responder, event2, verify_response_handled, - &user_data); + fl_key_embedder_responder_handle_event(responder, event2, 0, + verify_response_handled, &user_data); EXPECT_EQ(g_call_records->len, 1u); @@ -954,8 +954,8 @@ TEST(FlKeyEmbedderResponderTest, TurnDuplicateDownEventsToRepeats) { g_autoptr(FlKeyEvent) event3 = fl_key_event_new(103, kRelease, kKeyCodeKeyA, GDK_KEY_q, static_cast(0), 0); - fl_key_responder_handle_event(responder, event3, verify_response_handled, - &user_data); + fl_key_embedder_responder_handle_event(responder, event3, 0, + verify_response_handled, &user_data); EXPECT_EQ(g_call_records->len, 1u); record = FL_KEY_EMBEDDER_CALL_RECORD(g_ptr_array_index(g_call_records, 0)); @@ -971,8 +971,8 @@ TEST(FlKeyEmbedderResponderTest, IgnoreAbruptUpEvent) { EXPECT_EQ(g_call_records, nullptr); g_call_records = g_ptr_array_new_with_free_func(g_object_unref); - FlKeyResponder* responder = FL_KEY_RESPONDER( - fl_key_embedder_responder_new(record_calls, g_call_records)); + FlKeyEmbedderResponder* responder = + fl_key_embedder_responder_new(record_calls, g_call_records); int user_data = 123; // Arbitrary user data // Release KeyA before it was even pressed. @@ -980,8 +980,8 @@ TEST(FlKeyEmbedderResponderTest, IgnoreAbruptUpEvent) { g_autoptr(FlKeyEvent) event = fl_key_event_new(103, kRelease, kKeyCodeKeyA, GDK_KEY_q, static_cast(0), 0); - fl_key_responder_handle_event(responder, event, verify_response_handled, - &user_data); + fl_key_embedder_responder_handle_event(responder, event, 0, + verify_response_handled, &user_data); EXPECT_EQ(g_call_records->len, 1u); @@ -1001,8 +1001,8 @@ TEST(FlKeyEmbedderResponderTest, IgnoreAbruptUpEvent) { TEST(FlKeyEmbedderResponderTest, SynthesizeForDesyncPressingStateOnSelfEvents) { EXPECT_EQ(g_call_records, nullptr); g_call_records = g_ptr_array_new_with_free_func(g_object_unref); - FlKeyResponder* responder = FL_KEY_RESPONDER( - fl_key_embedder_responder_new(record_calls, g_call_records)); + FlKeyEmbedderResponder* responder = + fl_key_embedder_responder_new(record_calls, g_call_records); int user_data = 123; // Arbitrary user data FlKeyEmbedderCallRecord* record; @@ -1015,8 +1015,8 @@ TEST(FlKeyEmbedderResponderTest, SynthesizeForDesyncPressingStateOnSelfEvents) { // Send a ControlLeft up g_autoptr(FlKeyEvent) event1 = fl_key_event_new( 101, kRelease, kKeyCodeControlLeft, GDK_KEY_Control_L, state, 0); - fl_key_responder_handle_event(responder, event1, verify_response_handled, - &user_data); + fl_key_embedder_responder_handle_event(responder, event1, 0, + verify_response_handled, &user_data); EXPECT_EQ(g_call_records->len, 2u); record = FL_KEY_EMBEDDER_CALL_RECORD(g_ptr_array_index(g_call_records, 0)); @@ -1044,8 +1044,8 @@ TEST(FlKeyEmbedderResponderTest, SynthesizeForDesyncPressingStateOnSelfEvents) { state = static_cast(0); g_autoptr(FlKeyEvent) event2 = fl_key_event_new( 102, kPress, kKeyCodeControlLeft, GDK_KEY_Control_L, state, 0); - fl_key_responder_handle_event(responder, event2, verify_response_handled, - &user_data); + fl_key_embedder_responder_handle_event(responder, event2, 0, + verify_response_handled, &user_data); EXPECT_EQ(g_call_records->len, 1u); record = FL_KEY_EMBEDDER_CALL_RECORD(g_ptr_array_index(g_call_records, 0)); invoke_record_callback_and_verify(record, TRUE, &user_data); @@ -1057,8 +1057,8 @@ TEST(FlKeyEmbedderResponderTest, SynthesizeForDesyncPressingStateOnSelfEvents) { // Send another ControlLeft down g_autoptr(FlKeyEvent) event3 = fl_key_event_new( 103, kPress, kKeyCodeControlLeft, GDK_KEY_Control_L, state, 0); - fl_key_responder_handle_event(responder, event3, verify_response_handled, - &user_data); + fl_key_embedder_responder_handle_event(responder, event3, 0, + verify_response_handled, &user_data); EXPECT_EQ(g_call_records->len, 2u); record = FL_KEY_EMBEDDER_CALL_RECORD(g_ptr_array_index(g_call_records, 0)); @@ -1084,8 +1084,8 @@ TEST(FlKeyEmbedderResponderTest, SynthesizeForDesyncPressingStateOnSelfEvents) { state = GDK_CONTROL_MASK; g_autoptr(FlKeyEvent) event4 = fl_key_event_new( 104, kRelease, kKeyCodeControlLeft, GDK_KEY_Control_L, state, 0); - fl_key_responder_handle_event(responder, event4, verify_response_handled, - &user_data); + fl_key_embedder_responder_handle_event(responder, event4, 0, + verify_response_handled, &user_data); EXPECT_EQ(g_call_records->len, 1u); record = FL_KEY_EMBEDDER_CALL_RECORD(g_ptr_array_index(g_call_records, 0)); invoke_record_callback_and_verify(record, TRUE, &user_data); @@ -1099,8 +1099,8 @@ TEST(FlKeyEmbedderResponderTest, SynthesizeForDesyncPressingStateOnSelfEvents) { // Send a ControlRight up. g_autoptr(FlKeyEvent) event5 = fl_key_event_new( 105, kRelease, kKeyCodeControlRight, GDK_KEY_Control_R, state, 0); - fl_key_responder_handle_event(responder, event5, verify_response_handled, - &user_data); + fl_key_embedder_responder_handle_event(responder, event5, 0, + verify_response_handled, &user_data); // A ControlLeft down is synthesized, with an empty event. // Reason: The ControlLeft down is synthesized to synchronize the state @@ -1127,8 +1127,8 @@ TEST(FlKeyEmbedderResponderTest, SynthesizeForDesyncPressingStateOnNonSelfEvents) { EXPECT_EQ(g_call_records, nullptr); g_call_records = g_ptr_array_new_with_free_func(g_object_unref); - FlKeyResponder* responder = FL_KEY_RESPONDER( - fl_key_embedder_responder_new(record_calls, g_call_records)); + FlKeyEmbedderResponder* responder = + fl_key_embedder_responder_new(record_calls, g_call_records); int user_data = 123; // Arbitrary user data FlKeyEmbedderCallRecord* record; @@ -1139,8 +1139,8 @@ TEST(FlKeyEmbedderResponderTest, // Send a normal event (KeyA down) g_autoptr(FlKeyEvent) event1 = fl_key_event_new(101, kPress, kKeyCodeKeyA, GDK_KEY_a, state, 0); - fl_key_responder_handle_event(responder, event1, verify_response_handled, - &user_data); + fl_key_embedder_responder_handle_event(responder, event1, 0, + verify_response_handled, &user_data); EXPECT_EQ(g_call_records->len, 2u); record = FL_KEY_EMBEDDER_CALL_RECORD(g_ptr_array_index(g_call_records, 0)); @@ -1168,8 +1168,8 @@ TEST(FlKeyEmbedderResponderTest, // Send a normal event (KeyA up) g_autoptr(FlKeyEvent) event2 = fl_key_event_new(102, kRelease, kKeyCodeKeyA, GDK_KEY_A, state, 0); - fl_key_responder_handle_event(responder, event2, verify_response_handled, - &user_data); + fl_key_embedder_responder_handle_event(responder, event2, 0, + verify_response_handled, &user_data); EXPECT_EQ(g_call_records->len, 2u); record = FL_KEY_EMBEDDER_CALL_RECORD(g_ptr_array_index(g_call_records, 0)); @@ -1198,8 +1198,8 @@ TEST(FlKeyEmbedderResponderTest, g_autoptr(FlKeyEvent) event3 = fl_key_event_new(101, kPress, kKeyCodeCapsLock, GDK_KEY_Control_L, state, 0); - fl_key_responder_handle_event(responder, event3, verify_response_handled, - &user_data); + fl_key_embedder_responder_handle_event(responder, event3, 0, + verify_response_handled, &user_data); EXPECT_EQ(g_call_records->len, 1u); record = FL_KEY_EMBEDDER_CALL_RECORD(g_ptr_array_index(g_call_records, 0)); @@ -1219,8 +1219,8 @@ TEST(FlKeyEmbedderResponderTest, // Send a normal event (KeyA down). g_autoptr(FlKeyEvent) event4 = fl_key_event_new(102, kPress, kKeyCodeKeyA, GDK_KEY_A, state, 0); - fl_key_responder_handle_event(responder, event4, verify_response_handled, - &user_data); + fl_key_embedder_responder_handle_event(responder, event4, 0, + verify_response_handled, &user_data); // The synthesized event should have physical CapsLock and logical // ControlLeft. @@ -1254,8 +1254,8 @@ TEST(FlKeyEmbedderResponderTest, SynthesizeForDesyncPressingStateOnRemappedEvents) { EXPECT_EQ(g_call_records, nullptr); g_call_records = g_ptr_array_new_with_free_func(g_object_unref); - FlKeyResponder* responder = FL_KEY_RESPONDER( - fl_key_embedder_responder_new(record_calls, g_call_records)); + FlKeyEmbedderResponder* responder = + fl_key_embedder_responder_new(record_calls, g_call_records); int user_data = 123; // Arbitrary user data FlKeyEmbedderCallRecord* record; @@ -1265,8 +1265,8 @@ TEST(FlKeyEmbedderResponderTest, g_autoptr(FlKeyEvent) event1 = fl_key_event_new(101, kPress, kKeyCodeCapsLock, GDK_KEY_Control_L, state, 0); - fl_key_responder_handle_event(responder, event1, verify_response_handled, - &user_data); + fl_key_embedder_responder_handle_event(responder, event1, 0, + verify_response_handled, &user_data); EXPECT_EQ(g_call_records->len, 1u); record = FL_KEY_EMBEDDER_CALL_RECORD(g_ptr_array_index(g_call_records, 0)); @@ -1286,8 +1286,8 @@ TEST(FlKeyEmbedderResponderTest, // Send a normal event (KeyA down). g_autoptr(FlKeyEvent) event2 = fl_key_event_new(102, kPress, kKeyCodeKeyA, GDK_KEY_A, state, 0); - fl_key_responder_handle_event(responder, event2, verify_response_handled, - &user_data); + fl_key_embedder_responder_handle_event(responder, event2, 0, + verify_response_handled, &user_data); // The synthesized event should have physical CapsLock and logical // ControlLeft. @@ -1320,8 +1320,8 @@ TEST(FlKeyEmbedderResponderTest, TEST(FlKeyEmbedderResponderTest, SynthesizeForDesyncLockModeOnNonSelfEvents) { EXPECT_EQ(g_call_records, nullptr); g_call_records = g_ptr_array_new_with_free_func(g_object_unref); - FlKeyResponder* responder = FL_KEY_RESPONDER( - fl_key_embedder_responder_new(record_calls, g_call_records)); + FlKeyEmbedderResponder* responder = + fl_key_embedder_responder_new(record_calls, g_call_records); int user_data = 123; // Arbitrary user data FlKeyEmbedderCallRecord* record; @@ -1332,8 +1332,8 @@ TEST(FlKeyEmbedderResponderTest, SynthesizeForDesyncLockModeOnNonSelfEvents) { // Send a normal event g_autoptr(FlKeyEvent) event1 = fl_key_event_new(101, kPress, kKeyCodeKeyA, GDK_KEY_a, state, 0); - fl_key_responder_handle_event(responder, event1, verify_response_handled, - &user_data); + fl_key_embedder_responder_handle_event(responder, event1, 0, + verify_response_handled, &user_data); EXPECT_EQ(g_call_records->len, 2u); record = FL_KEY_EMBEDDER_CALL_RECORD(g_ptr_array_index(g_call_records, 0)); @@ -1361,8 +1361,8 @@ TEST(FlKeyEmbedderResponderTest, SynthesizeForDesyncLockModeOnNonSelfEvents) { // Release key A g_autoptr(FlKeyEvent) event2 = fl_key_event_new(102, kRelease, kKeyCodeKeyA, GDK_KEY_A, state, 0); - fl_key_responder_handle_event(responder, event2, verify_response_handled, - &user_data); + fl_key_embedder_responder_handle_event(responder, event2, 0, + verify_response_handled, &user_data); EXPECT_EQ(g_call_records->len, 4u); record = FL_KEY_EMBEDDER_CALL_RECORD(g_ptr_array_index(g_call_records, 0)); @@ -1405,8 +1405,8 @@ TEST(FlKeyEmbedderResponderTest, SynthesizeForDesyncLockModeOnNonSelfEvents) { g_expected_handled = true; g_autoptr(FlKeyEvent) event3 = fl_key_event_new( 103, kRelease, kKeyCodeNumLock, GDK_KEY_Num_Lock, state, 0); - fl_key_responder_handle_event(responder, event3, verify_response_handled, - &user_data); + fl_key_embedder_responder_handle_event(responder, event3, 0, + verify_response_handled, &user_data); EXPECT_EQ(g_call_records->len, 1u); record = FL_KEY_EMBEDDER_CALL_RECORD(g_ptr_array_index(g_call_records, 0)); @@ -1425,8 +1425,8 @@ TEST(FlKeyEmbedderResponderTest, SynthesizeForDesyncLockModeOnNonSelfEvents) { TEST(FlKeyEmbedderResponderTest, SynthesizeForDesyncLockModeOnSelfEvents) { EXPECT_EQ(g_call_records, nullptr); g_call_records = g_ptr_array_new_with_free_func(g_object_unref); - FlKeyResponder* responder = FL_KEY_RESPONDER( - fl_key_embedder_responder_new(record_calls, g_call_records)); + FlKeyEmbedderResponder* responder = + fl_key_embedder_responder_new(record_calls, g_call_records); int user_data = 123; // Arbitrary user data FlKeyEmbedderCallRecord* record; @@ -1437,8 +1437,8 @@ TEST(FlKeyEmbedderResponderTest, SynthesizeForDesyncLockModeOnSelfEvents) { // NumLock down g_autoptr(FlKeyEvent) event1 = fl_key_event_new(101, kPress, kKeyCodeNumLock, GDK_KEY_Num_Lock, state, 0); - fl_key_responder_handle_event(responder, event1, verify_response_handled, - &user_data); + fl_key_embedder_responder_handle_event(responder, event1, 0, + verify_response_handled, &user_data); EXPECT_EQ(g_call_records->len, 3u); record = FL_KEY_EMBEDDER_CALL_RECORD(g_ptr_array_index(g_call_records, 0)); @@ -1474,8 +1474,8 @@ TEST(FlKeyEmbedderResponderTest, SynthesizeForDesyncLockModeOnSelfEvents) { // NumLock up g_autoptr(FlKeyEvent) event2 = fl_key_event_new(102, kPress, kKeyCodeNumLock, GDK_KEY_Num_Lock, state, 0); - fl_key_responder_handle_event(responder, event2, verify_response_handled, - &user_data); + fl_key_embedder_responder_handle_event(responder, event2, 0, + verify_response_handled, &user_data); EXPECT_EQ(g_call_records->len, 4u); record = FL_KEY_EMBEDDER_CALL_RECORD(g_ptr_array_index(g_call_records, 0)); @@ -1522,8 +1522,8 @@ TEST(FlKeyEmbedderResponderTest, SynthesizeForDesyncLockModeOnSelfEvents) { TEST(FlKeyEmbedderResponderTest, SynthesizationOccursOnIgnoredEvents) { EXPECT_EQ(g_call_records, nullptr); g_call_records = g_ptr_array_new_with_free_func(g_object_unref); - FlKeyResponder* responder = FL_KEY_RESPONDER( - fl_key_embedder_responder_new(record_calls, g_call_records)); + FlKeyEmbedderResponder* responder = + fl_key_embedder_responder_new(record_calls, g_call_records); int user_data = 123; // Arbitrary user data FlKeyEmbedderCallRecord* record; @@ -1536,8 +1536,8 @@ TEST(FlKeyEmbedderResponderTest, SynthesizationOccursOnIgnoredEvents) { g_expected_handled = true; // The ignored event is always handled. g_autoptr(FlKeyEvent) event = fl_key_event_new(101, kRelease, kKeyCodeKeyA, GDK_KEY_a, state, 0); - fl_key_responder_handle_event(responder, event, verify_response_handled, - &user_data); + fl_key_embedder_responder_handle_event(responder, event, 0, + verify_response_handled, &user_data); EXPECT_EQ(g_call_records->len, 2u); record = FL_KEY_EMBEDDER_CALL_RECORD(g_ptr_array_index(g_call_records, 0)); @@ -1575,8 +1575,8 @@ TEST(FlKeyEmbedderResponderTest, SynthesizationOccursOnIgnoredEvents) { TEST(FlKeyEmbedderResponderTest, HandlesShiftAltVersusGroupNext) { EXPECT_EQ(g_call_records, nullptr); g_call_records = g_ptr_array_new_with_free_func(g_object_unref); - FlKeyResponder* responder = FL_KEY_RESPONDER( - fl_key_embedder_responder_new(record_calls, g_call_records)); + FlKeyEmbedderResponder* responder = + fl_key_embedder_responder_new(record_calls, g_call_records); g_expected_handled = true; guint32 now_time = 1; @@ -1588,8 +1588,8 @@ TEST(FlKeyEmbedderResponderTest, HandlesShiftAltVersusGroupNext) { int user_data = 123; // Arbitrary user data g_autoptr(FlKeyEvent) event = fl_key_event_new(now_time, is_press, keycode, keyval, state, 0); - fl_key_responder_handle_event(responder, event, verify_response_handled, - &user_data); + fl_key_embedder_responder_handle_event(responder, event, 0, + verify_response_handled, &user_data); }; FlKeyEmbedderCallRecord* record; @@ -1683,8 +1683,8 @@ TEST(FlKeyEmbedderResponderTest, HandlesShiftAltVersusGroupNext) { TEST(FlKeyEmbedderResponderTest, HandlesShiftAltLeftIsMetaLeft) { EXPECT_EQ(g_call_records, nullptr); g_call_records = g_ptr_array_new_with_free_func(g_object_unref); - FlKeyResponder* responder = FL_KEY_RESPONDER( - fl_key_embedder_responder_new(record_calls, g_call_records)); + FlKeyEmbedderResponder* responder = + fl_key_embedder_responder_new(record_calls, g_call_records); g_expected_handled = true; guint32 now_time = 1; @@ -1696,8 +1696,8 @@ TEST(FlKeyEmbedderResponderTest, HandlesShiftAltLeftIsMetaLeft) { int user_data = 123; // Arbitrary user data g_autoptr(FlKeyEvent) event = fl_key_event_new(now_time, is_press, keycode, keyval, state, 0); - fl_key_responder_handle_event(responder, event, verify_response_handled, - &user_data); + fl_key_embedder_responder_handle_event(responder, event, 0, + verify_response_handled, &user_data); }; FlKeyEmbedderCallRecord* record; diff --git a/shell/platform/linux/fl_key_responder.cc b/shell/platform/linux/fl_key_responder.cc deleted file mode 100644 index 269beab8b0c75..0000000000000 --- a/shell/platform/linux/fl_key_responder.cc +++ /dev/null @@ -1,22 +0,0 @@ -// Copyright 2013 The Flutter Authors. All rights reserved. -// Use of this source code is governed by a BSD-style license that can be -// found in the LICENSE file. - -#include "flutter/shell/platform/linux/fl_key_responder.h" - -G_DEFINE_INTERFACE(FlKeyResponder, fl_key_responder, G_TYPE_OBJECT) - -static void fl_key_responder_default_init(FlKeyResponderInterface* iface) {} - -void fl_key_responder_handle_event(FlKeyResponder* self, - FlKeyEvent* event, - FlKeyResponderAsyncCallback callback, - gpointer user_data, - uint64_t specified_logical_key) { - g_return_if_fail(FL_IS_KEY_RESPONDER(self)); - g_return_if_fail(event != nullptr); - g_return_if_fail(callback != nullptr); - - FL_KEY_RESPONDER_GET_IFACE(self)->handle_event( - self, event, specified_logical_key, callback, user_data); -} diff --git a/shell/platform/linux/fl_key_responder.h b/shell/platform/linux/fl_key_responder.h deleted file mode 100644 index 50fd6c51e6f48..0000000000000 --- a/shell/platform/linux/fl_key_responder.h +++ /dev/null @@ -1,81 +0,0 @@ -// Copyright 2013 The Flutter Authors. All rights reserved. -// Use of this source code is governed by a BSD-style license that can be -// found in the LICENSE file. - -#ifndef FLUTTER_SHELL_PLATFORM_LINUX_FL_KEY_RESPONDER_H_ -#define FLUTTER_SHELL_PLATFORM_LINUX_FL_KEY_RESPONDER_H_ - -#include -#include - -#include "flutter/shell/platform/linux/fl_key_event.h" -#include "flutter/shell/platform/linux/public/flutter_linux/fl_binary_messenger.h" -#include "flutter/shell/platform/linux/public/flutter_linux/fl_value.h" - -G_BEGIN_DECLS - -/** - * FlKeyResponderAsyncCallback: - * @event: whether the event has been handled. - * @user_data: the same value as user_data sent by - * #fl_key_responder_handle_event. - * - * The signature for a callback with which a #FlKeyResponder asynchronously - * reports whether the responder handles the event. - **/ -typedef void (*FlKeyResponderAsyncCallback)(bool handled, gpointer user_data); - -#define FL_TYPE_KEY_RESPONDER fl_key_responder_get_type() -G_DECLARE_INTERFACE(FlKeyResponder, - fl_key_responder, - FL, - KEY_RESPONDER, - GObject); - -/** - * FlKeyResponder: - * - * An interface for a responder that can process a key event and decides - * asynchronously whether to handle an event. - * - * To use this class, add it with #fl_keyboard_handler_add_responder. - */ - -struct _FlKeyResponderInterface { - GTypeInterface g_iface; - - /** - * FlKeyResponder::handle_event: - * - * The implementation of #fl_key_responder_handle_event. - */ - void (*handle_event)(FlKeyResponder* responder, - FlKeyEvent* event, - uint64_t specified_logical_key, - FlKeyResponderAsyncCallback callback, - gpointer user_data); -}; - -/** - * fl_key_responder_handle_event: - * @responder: the #FlKeyResponder self. - * @event: the event to be handled. Must not be null. The object is managed - * by callee and must not be assumed available after this function. - * @callback: the callback to report the result. It should be called exactly - * once. Must not be null. - * @user_data: a value that will be sent back in the callback. Can be null. - * - * Let the responder handle an event, expecting the responder to report - * whether to handle the event. The result will be reported by invoking - * `callback` exactly once, which might happen after - * `fl_key_responder_handle_event` or during it. - */ -void fl_key_responder_handle_event(FlKeyResponder* responder, - FlKeyEvent* event, - FlKeyResponderAsyncCallback callback, - gpointer user_data, - uint64_t specified_logical_key = 0); - -G_END_DECLS - -#endif // FLUTTER_SHELL_PLATFORM_LINUX_FL_KEY_RESPONDER_H_ diff --git a/shell/platform/linux/fl_keyboard_handler.h b/shell/platform/linux/fl_keyboard_handler.h index 57da5e9c729ea..d2631215d8e2d 100644 --- a/shell/platform/linux/fl_keyboard_handler.h +++ b/shell/platform/linux/fl_keyboard_handler.h @@ -12,7 +12,6 @@ G_BEGIN_DECLS -#define FL_TYPE_KEYBOARD_HANDLER fl_keyboard_handler_get_type() G_DECLARE_FINAL_TYPE(FlKeyboardHandler, fl_keyboard_handler, FL, diff --git a/shell/platform/linux/fl_keyboard_manager.cc b/shell/platform/linux/fl_keyboard_manager.cc index 3c0b8f1b6ec4b..72747e79ac4ba 100644 --- a/shell/platform/linux/fl_keyboard_manager.cc +++ b/shell/platform/linux/fl_keyboard_manager.cc @@ -118,10 +118,9 @@ struct _FlKeyboardManager { GWeakRef view_delegate; - // An array of #FlKeyResponder. Elements are added with - // #fl_keyboard_manager_add_responder immediately after initialization and are - // automatically released on dispose. - GPtrArray* responder_list; + FlKeyEmbedderResponder* key_embedder_responder; + + FlKeyChannelResponder* key_channel_responder; // An array of #FlKeyboardPendingEvent. // @@ -221,7 +220,8 @@ static bool fl_keyboard_manager_remove_redispatched(FlKeyboardManager* self, // The callback used by a responder after the event was dispatched. static void responder_handle_event_callback(bool handled, - gpointer user_data_ptr) { + gpointer user_data_ptr, + gboolean is_embedder) { g_return_if_fail(FL_IS_KEYBOARD_MANAGER_USER_DATA(user_data_ptr)); FlKeyboardManagerUserData* user_data = FL_KEYBOARD_MANAGER_USER_DATA(user_data_ptr); @@ -246,7 +246,11 @@ static void responder_handle_event_callback(bool handled, FlKeyboardPendingEvent* pending = FL_KEYBOARD_PENDING_EVENT( g_ptr_array_index(self->pending_responds, result_index)); g_return_if_fail(pending != nullptr); - fl_keyboard_pending_event_mark_replied(pending, handled); + if (is_embedder) { + fl_keyboard_pending_event_mark_embedder_replied(pending, handled); + } else { + fl_keyboard_pending_event_mark_channel_replied(pending, handled); + } // All responders have replied. if (fl_keyboard_pending_event_is_complete(pending)) { g_object_unref(user_data_ptr); @@ -268,6 +272,16 @@ static void responder_handle_event_callback(bool handled, } } +static void responder_handle_embedder_event_callback(bool handled, + gpointer user_data_ptr) { + responder_handle_event_callback(handled, user_data_ptr, TRUE); +} + +static void responder_handle_channel_event_callback(bool handled, + gpointer user_data_ptr) { + responder_handle_event_callback(handled, user_data_ptr, FALSE); +} + static uint16_t convert_key_to_char(FlKeyboardViewDelegate* view_delegate, guint keycode, gint group, @@ -374,7 +388,8 @@ static void fl_keyboard_manager_dispose(GObject* object) { self->keycode_to_goals.reset(); self->logical_to_mandatory_goals.reset(); - g_ptr_array_free(self->responder_list, TRUE); + g_clear_object(&self->key_embedder_responder); + g_clear_object(&self->key_channel_responder); g_ptr_array_set_free_func(self->pending_responds, g_object_unref); g_ptr_array_free(self->pending_responds, TRUE); g_ptr_array_free(self->pending_redispatches, TRUE); @@ -401,8 +416,6 @@ static void fl_keyboard_manager_init(FlKeyboardManager* self) { } } - self->responder_list = g_ptr_array_new_with_free_func(g_object_unref); - self->pending_responds = g_ptr_array_new(); self->pending_redispatches = g_ptr_array_new_with_free_func(g_object_unref); @@ -419,25 +432,20 @@ FlKeyboardManager* fl_keyboard_manager_new( g_weak_ref_init(&self->view_delegate, view_delegate); - // The embedder responder must be added before the channel responder. - g_ptr_array_add( - self->responder_list, - FL_KEY_RESPONDER(fl_key_embedder_responder_new( - [](const FlutterKeyEvent* event, FlutterKeyEventCallback callback, - void* callback_user_data, void* send_key_event_user_data) { - FlKeyboardManager* self = - FL_KEYBOARD_MANAGER(send_key_event_user_data); - g_autoptr(FlKeyboardViewDelegate) view_delegate = - FL_KEYBOARD_VIEW_DELEGATE(g_weak_ref_get(&self->view_delegate)); - if (view_delegate == nullptr) { - return; - } - fl_keyboard_view_delegate_send_key_event( - view_delegate, event, callback, callback_user_data); - }, - self))); - g_ptr_array_add(self->responder_list, - FL_KEY_RESPONDER(fl_key_channel_responder_new(messenger))); + self->key_embedder_responder = fl_key_embedder_responder_new( + [](const FlutterKeyEvent* event, FlutterKeyEventCallback callback, + void* callback_user_data, void* send_key_event_user_data) { + FlKeyboardManager* self = FL_KEYBOARD_MANAGER(send_key_event_user_data); + g_autoptr(FlKeyboardViewDelegate) view_delegate = + FL_KEYBOARD_VIEW_DELEGATE(g_weak_ref_get(&self->view_delegate)); + if (view_delegate == nullptr) { + return; + } + fl_keyboard_view_delegate_send_key_event(view_delegate, event, callback, + callback_user_data); + }, + self); + self->key_channel_responder = fl_key_channel_responder_new(messenger); return self; } @@ -454,8 +462,8 @@ gboolean fl_keyboard_manager_handle_event(FlKeyboardManager* self, return FALSE; } - FlKeyboardPendingEvent* pending = fl_keyboard_pending_event_new( - event, ++self->last_sequence_id, self->responder_list->len); + FlKeyboardPendingEvent* pending = + fl_keyboard_pending_event_new(event, ++self->last_sequence_id); g_ptr_array_add(self->pending_responds, pending); FlKeyboardManagerUserData* user_data = fl_keyboard_manager_user_data_new( @@ -463,13 +471,12 @@ gboolean fl_keyboard_manager_handle_event(FlKeyboardManager* self, uint64_t specified_logical_key = fl_keyboard_layout_get_logical_key( self->derived_layout, fl_key_event_get_group(event), fl_key_event_get_keycode(event)); - for (guint i = 0; i < self->responder_list->len; i++) { - FlKeyResponder* responder = - FL_KEY_RESPONDER(g_ptr_array_index(self->responder_list, i)); - fl_key_responder_handle_event(responder, event, - responder_handle_event_callback, user_data, - specified_logical_key); - } + fl_key_embedder_responder_handle_event( + self->key_embedder_responder, event, specified_logical_key, + responder_handle_embedder_event_callback, user_data); + fl_key_channel_responder_handle_event( + self->key_channel_responder, event, specified_logical_key, + responder_handle_channel_event_callback, user_data); return TRUE; } @@ -484,23 +491,14 @@ void fl_keyboard_manager_sync_modifier_if_needed(FlKeyboardManager* self, guint state, double event_time) { g_return_if_fail(FL_IS_KEYBOARD_MANAGER(self)); - - // The embedder responder is the first element in - // FlKeyboardManager.responder_list. - FlKeyEmbedderResponder* responder = - FL_KEY_EMBEDDER_RESPONDER(g_ptr_array_index(self->responder_list, 0)); - fl_key_embedder_responder_sync_modifiers_if_needed(responder, state, - event_time); + fl_key_embedder_responder_sync_modifiers_if_needed( + self->key_embedder_responder, state, event_time); } GHashTable* fl_keyboard_manager_get_pressed_state(FlKeyboardManager* self) { g_return_val_if_fail(FL_IS_KEYBOARD_MANAGER(self), nullptr); - - // The embedder responder is the first element in - // FlKeyboardManager.responder_list. - FlKeyEmbedderResponder* responder = - FL_KEY_EMBEDDER_RESPONDER(g_ptr_array_index(self->responder_list, 0)); - return fl_key_embedder_responder_get_pressed_state(responder); + return fl_key_embedder_responder_get_pressed_state( + self->key_embedder_responder); } void fl_keyboard_manager_notify_layout_changed(FlKeyboardManager* self) { diff --git a/shell/platform/linux/fl_keyboard_manager.h b/shell/platform/linux/fl_keyboard_manager.h index 383c7f93398c6..863af5212d978 100644 --- a/shell/platform/linux/fl_keyboard_manager.h +++ b/shell/platform/linux/fl_keyboard_manager.h @@ -12,7 +12,6 @@ G_BEGIN_DECLS -#define FL_TYPE_KEYBOARD_MANAGER fl_keyboard_manager_get_type() G_DECLARE_FINAL_TYPE(FlKeyboardManager, fl_keyboard_manager, FL, diff --git a/shell/platform/linux/fl_keyboard_pending_event.cc b/shell/platform/linux/fl_keyboard_pending_event.cc index eb9b6c37e4cfc..7b19cca9fcdb7 100644 --- a/shell/platform/linux/fl_keyboard_pending_event.cc +++ b/shell/platform/linux/fl_keyboard_pending_event.cc @@ -22,11 +22,17 @@ struct _FlKeyboardPendingEvent { // Unique ID to identify pending responds. uint64_t sequence_id; - // The number of responders that haven't replied. - size_t unreplied; + // True if the embedder responder has replied. + bool embedder_replied; - // Whether any replied responders reported true (handled). - bool any_handled; + // True if the channel responder has replied. + bool channel_replied; + + // True if this event was handled by the embedder responder. + bool embedder_handled; + + // True if this event was handled by the channel responder. + bool channel_handled; // A value calculated out of critical event information that can be used // to identify redispatched events. @@ -53,15 +59,12 @@ static void fl_keyboard_pending_event_init(FlKeyboardPendingEvent* self) {} // Creates a new FlKeyboardPendingEvent by providing the target event, // the sequence ID, and the number of responders that will reply. FlKeyboardPendingEvent* fl_keyboard_pending_event_new(FlKeyEvent* event, - uint64_t sequence_id, - size_t to_reply) { + uint64_t sequence_id) { FlKeyboardPendingEvent* self = FL_KEYBOARD_PENDING_EVENT( g_object_new(fl_keyboard_pending_event_get_type(), nullptr)); self->event = FL_KEY_EVENT(g_object_ref(event)); self->sequence_id = sequence_id; - self->unreplied = to_reply; - self->any_handled = false; self->hash = fl_key_event_hash(self->event); return self; @@ -83,23 +86,29 @@ uint64_t fl_keyboard_pending_event_get_hash(FlKeyboardPendingEvent* self) { return self->hash; } -void fl_keyboard_pending_event_mark_replied(FlKeyboardPendingEvent* self, - gboolean handled) { +void fl_keyboard_pending_event_mark_embedder_replied( + FlKeyboardPendingEvent* self, + gboolean handled) { + g_return_if_fail(FL_IS_KEYBOARD_PENDING_EVENT(self)); + self->embedder_replied = true; + self->embedder_handled = handled; +} + +void fl_keyboard_pending_event_mark_channel_replied( + FlKeyboardPendingEvent* self, + gboolean handled) { g_return_if_fail(FL_IS_KEYBOARD_PENDING_EVENT(self)); - g_return_if_fail(self->unreplied > 0); - self->unreplied -= 1; - if (handled) { - self->any_handled = TRUE; - } + self->channel_replied = true; + self->channel_handled = handled; } gboolean fl_keyboard_pending_event_get_any_handled( FlKeyboardPendingEvent* self) { g_return_val_if_fail(FL_IS_KEYBOARD_PENDING_EVENT(self), FALSE); - return self->any_handled; + return self->embedder_handled || self->channel_handled; } gboolean fl_keyboard_pending_event_is_complete(FlKeyboardPendingEvent* self) { g_return_val_if_fail(FL_IS_KEYBOARD_PENDING_EVENT(self), FALSE); - return self->unreplied == 0; + return self->embedder_replied && self->channel_replied; } diff --git a/shell/platform/linux/fl_keyboard_pending_event.h b/shell/platform/linux/fl_keyboard_pending_event.h index 50204d681b429..e419598d17147 100644 --- a/shell/platform/linux/fl_keyboard_pending_event.h +++ b/shell/platform/linux/fl_keyboard_pending_event.h @@ -16,8 +16,7 @@ G_DECLARE_FINAL_TYPE(FlKeyboardPendingEvent, GObject); FlKeyboardPendingEvent* fl_keyboard_pending_event_new(FlKeyEvent* event, - uint64_t sequence_id, - size_t to_reply); + uint64_t sequence_id); FlKeyEvent* fl_keyboard_pending_event_get_event(FlKeyboardPendingEvent* event); @@ -26,8 +25,13 @@ uint64_t fl_keyboard_pending_event_get_sequence_id( uint64_t fl_keyboard_pending_event_get_hash(FlKeyboardPendingEvent* event); -void fl_keyboard_pending_event_mark_replied(FlKeyboardPendingEvent* event, - gboolean handled); +void fl_keyboard_pending_event_mark_embedder_replied( + FlKeyboardPendingEvent* event, + gboolean handled); + +void fl_keyboard_pending_event_mark_channel_replied( + FlKeyboardPendingEvent* event, + gboolean handled); gboolean fl_keyboard_pending_event_get_any_handled( FlKeyboardPendingEvent* event); diff --git a/shell/platform/linux/fl_scrolling_manager.h b/shell/platform/linux/fl_scrolling_manager.h index 5c011876abbfe..db862317ba5df 100644 --- a/shell/platform/linux/fl_scrolling_manager.h +++ b/shell/platform/linux/fl_scrolling_manager.h @@ -11,7 +11,6 @@ G_BEGIN_DECLS -#define FL_TYPE_SCROLLING_MANAGER fl_scrolling_manager_get_type() G_DECLARE_FINAL_TYPE(FlScrollingManager, fl_scrolling_manager, FL,