fl_keyboard_manager.h File Reference

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

Go to the source code of this file.

Typedefs
typedef guint(*	FlKeyboardManagerLookupKeyHandler) (const GdkKeymapKey *key, 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)
void	fl_keyboard_manager_add_redispatched_event (FlKeyboardManager *manager, FlKeyEvent *event)
void	fl_keyboard_manager_handle_event (FlKeyboardManager *manager, FlKeyEvent *event, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data)
gboolean	fl_keyboard_manager_handle_event_finish (FlKeyboardManager *manager, GAsyncResult *result, FlKeyEvent **redispatched_event, GError **error)
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_lookup_key_handler (FlKeyboardManager *manager, FlKeyboardManagerLookupKeyHandler lookup_key_handler, gpointer user_data)

Typedef Documentation

FlKeyboardManagerLookupKeyHandler

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

Definition at line 120 of file fl_keyboard_manager.h.

Function Documentation

fl_keyboard_manager_add_redispatched_event()

void fl_keyboard_manager_add_redispatched_event	(	FlKeyboardManager *	manager,
		FlKeyEvent *	event
	)

fl_keyboard_manager_add_redispatched_event: @manager: an #FlKeyboardManager. @event: an event that will be handled by the manager in the future.

Add an event that will be redispatched and handled by the manager in the future. When that event is received it will be ignored.

Definition at line 362 of file fl_keyboard_manager.cc.

                                                                   {
  g_return_if_fail(FL_IS_KEYBOARD_MANAGER(self));
 
  g_ptr_array_add(self->redispatched_key_events, g_object_ref(event));
}

References self.

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 430 of file fl_keyboard_manager.cc.

                                                                           {
  g_return_val_if_fail(FL_IS_KEYBOARD_MANAGER(self), nullptr);
  return fl_key_embedder_responder_get_pressed_state(
      self->key_embedder_responder);
}

References fl_key_embedder_responder_get_pressed_state(), and self.

Referenced by get_keyboard_state().

fl_keyboard_manager_handle_event()

void fl_keyboard_manager_handle_event	(	FlKeyboardManager *	manager,
		FlKeyEvent *	event,
		GCancellable *	cancellable,
		GAsyncReadyCallback	callback,
		gpointer	user_data
	)

fl_keyboard_manager_handle_event: @manager: an #FlKeyboardManager. @event: the event to be dispatched. It is usually a wrap of a GdkEventKey. This event will be managed and released by #FlKeyboardManager. @cancellable: (allow-none): a #GCancellable or NULL. @callback: (scope async): a #GAsyncReadyCallback to call when the view is added. @user_data: (closure): user data to pass to @callback.

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 369 of file fl_keyboard_manager.cc.

                                                          {
  g_return_if_fail(FL_IS_KEYBOARD_MANAGER(self));
  g_return_if_fail(event != nullptr);
 
  g_autoptr(GTask) task = g_task_new(self, cancellable, callback, user_data);
 
  guarantee_layout(self, event);
 
  g_task_set_task_data(
      task, handle_event_data_new(event),
      reinterpret_cast<GDestroyNotify>(handle_event_data_free));
 
  if (event_is_redispatched(self, event)) {
    HandleEventData* data =
        static_cast<HandleEventData*>(g_task_get_task_data(task));
    data->handled = TRUE;
    g_task_return_boolean(task, TRUE);
    return;
  }
 
  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,
      self->cancellable, responder_handle_embedder_event_cb,
      g_object_ref(task));
  fl_key_channel_responder_handle_event(
      self->key_channel_responder, event, specified_logical_key,
      self->cancellable, responder_handle_channel_event_cb, g_object_ref(task));
}

References callback, event_is_redispatched(), fl_key_channel_responder_handle_event(), fl_key_embedder_responder_handle_event(), fl_key_event_get_group(), fl_key_event_get_keycode(), fl_keyboard_layout_get_logical_key(), g_autoptr(), guarantee_layout(), handle_event_data_free(), handle_event_data_new(), responder_handle_channel_event_cb(), responder_handle_embedder_event_cb(), self, TRUE, and user_data.

Referenced by handle_key_event(), and TEST_F().

fl_keyboard_manager_handle_event_finish()

gboolean fl_keyboard_manager_handle_event_finish	(	FlKeyboardManager *	manager,
		GAsyncResult *	result,
		FlKeyEvent **	redispatched_event,
		GError **	error
	)

fl_keyboard_manager_handle_event_finish: @manager: an #FlKeyboardManager.

Returns

: a #GAsyncResult. @redispatched_event: FIXME @error: (allow-none): #GError location to store the error occurring, or NULL to ignore. If error is not NULL, *error must be initialized (typically NULL, but an error from a previous call using GLib error handling is explicitly valid).

Completes request started with fl_keyboard_manager_handle_event().

Returns: TRUE on success.

Definition at line 405 of file fl_keyboard_manager.cc.

                    {
  g_return_val_if_fail(FL_IS_KEYBOARD_MANAGER(self), FALSE);
  g_return_val_if_fail(g_task_is_valid(result, self), FALSE);
 
  HandleEventData* data =
      static_cast<HandleEventData*>(g_task_get_task_data(G_TASK(result)));
  if (redispatched_event != nullptr && data->redispatch) {
    *redispatched_event = FL_KEY_EVENT(g_object_ref(data->event));
  }
 
  return g_task_propagate_boolean(G_TASK(result), error);
}

References error, and self.

Referenced by TEST_F().

fl_keyboard_manager_new()

FlKeyboardManager * fl_keyboard_manager_new

(

FlEngine *

engine

)

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.

Create a new #FlKeyboardManager.

Returns: a new #FlKeyboardManager.

Definition at line 351 of file fl_keyboard_manager.cc.

                                                             {
  FlKeyboardManager* self = FL_KEYBOARD_MANAGER(
      g_object_new(fl_keyboard_manager_get_type(), nullptr));
 
  self->key_embedder_responder = fl_key_embedder_responder_new(engine);
  self->key_channel_responder =
      fl_key_channel_responder_new(fl_engine_get_binary_messenger(engine));
 
  return self;
}

References engine, fl_engine_get_binary_messenger(), fl_key_channel_responder_new(), fl_key_embedder_responder_new(), and self.

Referenced by fl_engine_new_full(), FlKeyboardHandlerTest::SetUp(), and setup_keyboard().

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 436 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 self, and 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 422 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 self.

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
	)