fl_keyboard_manager.h File Reference

#include <gdk/gdk.h>
#include "flutter/shell/platform/linux/fl_keyboard_view_delegate.h"
#include "flutter/shell/platform/linux/public/flutter_linux/fl_engine.h"

Go to the source code of this file.

Typedefs
typedef void(*	FlKeyboardManagerSendKeyEventHandler) (const FlutterKeyEvent *event, FlutterKeyEventCallback callback, void *callback_user_data, gpointer user_data)
typedef guint(*	FlKeyboardManagerLookupKeyHandler) (const GdkKeymapKey *key, gpointer user_data)
typedef void(*	FlKeyboardManagerRedispatchEventHandler) (FlKeyEvent *event, gpointer user_data)
typedef GHashTable *(*	FlKeyboardManagerGetPressedStateHandler) (gpointer user_data)

Functions
G_BEGIN_DECLS	G_DECLARE_FINAL_TYPE (FlKeyboardManager, fl_keyboard_manager, FL, KEYBOARD_MANAGER, GObject)
FlKeyboardManager *	fl_keyboard_manager_new (FlEngine *engine, FlKeyboardViewDelegate *view_delegate)
gboolean	fl_keyboard_manager_handle_event (FlKeyboardManager *manager, FlKeyEvent *event)
gboolean	fl_keyboard_manager_is_state_clear (FlKeyboardManager *manager)
void	fl_keyboard_manager_sync_modifier_if_needed (FlKeyboardManager *manager, guint state, double event_time)
GHashTable *	fl_keyboard_manager_get_pressed_state (FlKeyboardManager *manager)
void	fl_keyboard_manager_set_send_key_event_handler (FlKeyboardManager *manager, FlKeyboardManagerSendKeyEventHandler send_key_event_handler, gpointer user_data)
void	fl_keyboard_manager_set_lookup_key_handler (FlKeyboardManager *manager, FlKeyboardManagerLookupKeyHandler lookup_key_handler, gpointer user_data)
void	fl_keyboard_manager_set_redispatch_handler (FlKeyboardManager *manager, FlKeyboardManagerRedispatchEventHandler redispatch_handler, gpointer user_data)
void	fl_keyboard_manager_set_get_pressed_state_handler (FlKeyboardManager *manager, FlKeyboardManagerGetPressedStateHandler get_pressed_state_handler, gpointer user_data)

Typedef Documentation

FlKeyboardManagerGetPressedStateHandler

typedef GHashTable*(* FlKeyboardManagerGetPressedStateHandler) (gpointer user_data)

Definition at line 142 of file fl_keyboard_manager.h.

FlKeyboardManagerLookupKeyHandler

typedef guint(* FlKeyboardManagerLookupKeyHandler) (const GdkKeymapKey *key, gpointer user_data)

Definition at line 114 of file fl_keyboard_manager.h.

FlKeyboardManagerRedispatchEventHandler

typedef void(* FlKeyboardManagerRedispatchEventHandler) (FlKeyEvent *event, gpointer user_data)

Definition at line 128 of file fl_keyboard_manager.h.

FlKeyboardManagerSendKeyEventHandler

typedef void(* FlKeyboardManagerSendKeyEventHandler) (const FlutterKeyEvent *event, FlutterKeyEventCallback callback, void *callback_user_data, gpointer user_data)

Definition at line 97 of file fl_keyboard_manager.h.

Function Documentation

fl_keyboard_manager_get_pressed_state()

GHashTable* fl_keyboard_manager_get_pressed_state

(

FlKeyboardManager *

manager

)

fl_keyboard_manager_get_pressed_state: @manager: the #FlKeyboardManager self.

Returns the keyboard pressed state. The hash table contains one entry per pressed keys, mapping from the logical key to the physical key.*

Definition at line 566 of file fl_keyboard_manager.cc.

                                                                           {
  g_return_val_if_fail(FL_IS_KEYBOARD_MANAGER(self), nullptr);
  if (self->get_pressed_state_handler != nullptr) {
    return self->get_pressed_state_handler(
        self->get_pressed_state_handler_user_data);
  } else {
    return fl_key_embedder_responder_get_pressed_state(
        self->key_embedder_responder);
  }
}

References fl_key_embedder_responder_get_pressed_state().

Referenced by get_keyboard_state().

fl_keyboard_manager_handle_event()

gboolean fl_keyboard_manager_handle_event	(	FlKeyboardManager *	manager,
		FlKeyEvent *	event
	)

fl_keyboard_manager_handle_event: @manager: the #FlKeyboardManager self. @event: the event to be dispatched. It is usually a wrap of a GdkEventKey. This event will be managed and released by #FlKeyboardManager.

Make the manager process a system key event. This might eventually send messages to the framework, trigger text input effects, or redispatch the event back to the system.

Definition at line 522 of file fl_keyboard_manager.cc.

                                                             {
  g_return_val_if_fail(FL_IS_KEYBOARD_MANAGER(self), FALSE);
  g_return_val_if_fail(event != nullptr, FALSE);
 
  guarantee_layout(self, event);
 
  uint64_t incoming_hash = fl_key_event_hash(event);
  if (fl_keyboard_manager_remove_redispatched(self, incoming_hash)) {
    return FALSE;
  }
 
  FlKeyboardPendingEvent* pending = fl_keyboard_pending_event_new(event);
 
  g_ptr_array_add(self->pending_responds, pending);
  g_autoptr(FlKeyboardManagerData) data =
      fl_keyboard_manager_data_new(self, pending);
  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));
  fl_key_embedder_responder_handle_event(
      self->key_embedder_responder, event, specified_logical_key,
      responder_handle_embedder_event_callback, g_object_ref(data));
  fl_key_channel_responder_handle_event(
      self->key_channel_responder, event, specified_logical_key,
      self->cancellable, responder_handle_channel_event_cb, g_object_ref(data));
 
  return TRUE;
}

References fl_key_channel_responder_handle_event(), fl_key_embedder_responder_handle_event(), fl_key_event_get_group(), fl_key_event_get_keycode(), fl_key_event_hash(), fl_keyboard_layout_get_logical_key(), fl_keyboard_manager_data_new(), fl_keyboard_manager_remove_redispatched(), fl_keyboard_pending_event_new(), guarantee_layout(), responder_handle_channel_event_cb(), responder_handle_embedder_event_callback(), and TRUE.

Referenced by fl_view_key_press_event(), and fl_view_key_release_event().

fl_keyboard_manager_is_state_clear()

gboolean fl_keyboard_manager_is_state_clear

(

FlKeyboardManager *

manager

)

fl_keyboard_manager_is_state_clear: @manager: the #FlKeyboardManager self.

A debug-only method that queries whether the manager's various states are cleared, i.e. no pending events for redispatching or for responding.

Returns: true if the manager's various states are cleared.

Definition at line 552 of file fl_keyboard_manager.cc.

                                                                     {
  g_return_val_if_fail(FL_IS_KEYBOARD_MANAGER(self), FALSE);
  return self->pending_responds->len == 0 &&
         self->pending_redispatches->len == 0;
}

fl_keyboard_manager_new()

FlKeyboardManager* fl_keyboard_manager_new	(	FlEngine *	engine,
		FlKeyboardViewDelegate *	view_delegate
	)

FlKeyboardManager:

Processes keyboard events and cooperate with TextInputManager.

A keyboard event goes through a few sections, each can choose to handle the event, and only unhandled events can move to the next section:

• Keyboard: Dispatch to the embedder responder and the channel responder simultaneously. After both responders have responded (asynchronously), the event is considered handled if either responder handles it.
• Text input: Events are sent to IM filter (usually owned by TextInputManager) and are handled synchronously.
• Redispatching: Events are inserted back to the system for redispatching. fl_keyboard_manager_new: @engine: an #FlEngine. @view_delegate: An interface that the manager requires to communicate with the platform. Usually implemented by FlView.

Create a new #FlKeyboardManager.

Returns: a new #FlKeyboardManager.

Definition at line 462 of file fl_keyboard_manager.cc.

                                           {
  g_return_val_if_fail(FL_IS_KEYBOARD_VIEW_DELEGATE(view_delegate), nullptr);
 
  FlKeyboardManager* self = FL_KEYBOARD_MANAGER(
      g_object_new(fl_keyboard_manager_get_type(), nullptr));
 
  g_weak_ref_init(&self->engine, engine);
  g_weak_ref_init(&self->view_delegate, view_delegate);
 
  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);
        if (self->send_key_event_handler != nullptr) {
          self->send_key_event_handler(event, callback, callback_user_data,
                                       self->send_key_event_handler_user_data);
        } else {
          g_autoptr(FlEngine) engine = FL_ENGINE(g_weak_ref_get(&self->engine));
          if (engine != nullptr) {
            typedef struct {
              FlutterKeyEventCallback callback;
              void* callback_user_data;
            } SendKeyEventData;
            SendKeyEventData* data = g_new0(SendKeyEventData, 1);
            data->callback = callback;
            data->callback_user_data = callback_user_data;
            fl_engine_send_key_event(
                engine, event, self->cancellable,
                [](GObject* object, GAsyncResult* result, gpointer user_data) {
                  g_autofree SendKeyEventData* data =
                      static_cast<SendKeyEventData*>(user_data);
                  gboolean handled = FALSE;
                  g_autoptr(GError) error = nullptr;
                  if (!fl_engine_send_key_event_finish(
                          FL_ENGINE(object), result, &handled, &error)) {
                    if (g_error_matches(error, G_IO_ERROR,
                                        G_IO_ERROR_CANCELLED)) {
                      return;
                    }
 
                    g_warning("Failed to send key event: %s", error->message);
                  }
 
                  if (data->callback != nullptr) {
                    data->callback(handled, data->callback_user_data);
                  }
                },
                data);
          }
        }
      },
      self);
  self->key_channel_responder =
      fl_key_channel_responder_new(fl_engine_get_binary_messenger(engine));
 
  return self;
}

References fl_engine_send_key_event(), fl_key_embedder_responder_new(), if(), and user_data.

Referenced by init_keyboard(), and TEST().

fl_keyboard_manager_set_get_pressed_state_handler()

void fl_keyboard_manager_set_get_pressed_state_handler	(	FlKeyboardManager *	manager,
		FlKeyboardManagerGetPressedStateHandler	get_pressed_state_handler,
		gpointer	user_data
	)

fl_keyboard_manager_set_get_pressed_state_handler: @manager: the #FlKeyboardManager self.

Set the handler for gettting the keyboard state, for testing purposes only.

Definition at line 604 of file fl_keyboard_manager.cc.

                        {
  g_return_if_fail(FL_IS_KEYBOARD_MANAGER(self));
  self->get_pressed_state_handler = get_pressed_state_handler;
  self->get_pressed_state_handler_user_data = user_data;
}

References user_data.

Referenced by TEST().

fl_keyboard_manager_set_lookup_key_handler()

void fl_keyboard_manager_set_lookup_key_handler	(	FlKeyboardManager *	manager,
		FlKeyboardManagerLookupKeyHandler	lookup_key_handler,
		gpointer	user_data
	)

fl_keyboard_manager_set_lookup_key_handler: @manager: the #FlKeyboardManager self.

Set the handler for key lookup, for testing purposes only.

Definition at line 586 of file fl_keyboard_manager.cc.

                        {
  g_return_if_fail(FL_IS_KEYBOARD_MANAGER(self));
  self->lookup_key_handler = lookup_key_handler;
  self->lookup_key_handler_user_data = user_data;
}

References user_data.

fl_keyboard_manager_set_redispatch_handler()

void fl_keyboard_manager_set_redispatch_handler	(	FlKeyboardManager *	manager,
		FlKeyboardManagerRedispatchEventHandler	redispatch_handler,
		gpointer	user_data
	)

fl_keyboard_manager_set_redispatch_handler: @manager: the #FlKeyboardManager self.

Set the handler for redispatches, for testing purposes only.

Definition at line 595 of file fl_keyboard_manager.cc.

                        {
  g_return_if_fail(FL_IS_KEYBOARD_MANAGER(self));
  self->redispatch_handler = redispatch_handler;
  self->redispatch_handler_user_data = user_data;
}

References user_data.

fl_keyboard_manager_set_send_key_event_handler()

void fl_keyboard_manager_set_send_key_event_handler	(	FlKeyboardManager *	manager,
		FlKeyboardManagerSendKeyEventHandler	send_key_event_handler,
		gpointer	user_data
	)

fl_keyboard_manager_set_send_key_event_handler: @manager: the #FlKeyboardManager self.

Set the handler for sending events, for testing purposes only.

Definition at line 577 of file fl_keyboard_manager.cc.

                        {
  g_return_if_fail(FL_IS_KEYBOARD_MANAGER(self));
  self->send_key_event_handler = send_key_event_handler;
  self->send_key_event_handler_user_data = user_data;
}

References user_data.

fl_keyboard_manager_sync_modifier_if_needed()

void fl_keyboard_manager_sync_modifier_if_needed	(	FlKeyboardManager *	manager,
		guint	state,
		double	event_time
	)

fl_keyboard_manager_sync_modifier_if_needed: @manager: the #FlKeyboardManager self. @state: the state of the modifiers mask. @event_time: the time attribute of the incoming GDK event.

If needed, synthesize modifier keys up and down event by comparing their current pressing states with the given modifiers mask.

Definition at line 558 of file fl_keyboard_manager.cc.

                                                                    {
  g_return_if_fail(FL_IS_KEYBOARD_MANAGER(self));
  fl_key_embedder_responder_sync_modifiers_if_needed(
      self->key_embedder_responder, state, event_time);
}

References fl_key_embedder_responder_sync_modifiers_if_needed(), and state.

Referenced by sync_modifier_if_needed().

G_DECLARE_FINAL_TYPE()

G_BEGIN_DECLS G_DECLARE_FINAL_TYPE	(	FlKeyboardManager	,
		fl_keyboard_manager	,
		FL	,
		KEYBOARD_MANAGER	,
		GObject
	)