fl_keyboard_manager.cc File Reference

#include "flutter/shell/platform/linux/fl_keyboard_manager.h"
#include <array>
#include <cinttypes>
#include <memory>
#include <string>
#include "flutter/shell/platform/linux/fl_engine_private.h"
#include "flutter/shell/platform/linux/fl_key_channel_responder.h"
#include "flutter/shell/platform/linux/fl_key_embedder_responder.h"
#include "flutter/shell/platform/linux/fl_keyboard_layout.h"
#include "flutter/shell/platform/linux/fl_keyboard_pending_event.h"
#include "flutter/shell/platform/linux/key_mapping.h"

Go to the source code of this file.

Classes
struct	_FlKeyboardManagerData
struct	_FlKeyboardManager

Macros
#define	DEBUG_PRINT_LAYOUT

Functions
	G_DECLARE_FINAL_TYPE (FlKeyboardManagerData, fl_keyboard_manager_data, FL, KEYBOARD_MANAGER_DATA, GObject)
static void	fl_keyboard_manager_data_dispose (GObject *object)
static void	fl_keyboard_manager_data_class_init (FlKeyboardManagerDataClass *klass)
static void	fl_keyboard_manager_data_init (FlKeyboardManagerData *self)
static FlKeyboardManagerData *	fl_keyboard_manager_data_new (FlKeyboardManager *manager, FlKeyboardPendingEvent *pending)
	G_DEFINE_TYPE (FlKeyboardManager, fl_keyboard_manager, G_TYPE_OBJECT)
static void	keymap_keys_changed_cb (FlKeyboardManager *self)
static gboolean	g_ptr_array_find_with_equal_func1 (GPtrArray *haystack, gconstpointer needle, GEqualFunc equal_func, guint *index_)
static gboolean	compare_pending_by_hash (gconstpointer a, gconstpointer b)
static bool	fl_keyboard_manager_remove_redispatched (FlKeyboardManager *self, uint64_t hash)
static void	responder_handle_event_callback (FlKeyboardManager *self, FlKeyboardPendingEvent *pending)
static void	responder_handle_embedder_event_callback (bool handled, gpointer user_data)
static void	responder_handle_channel_event_cb (GObject *object, GAsyncResult *result, gpointer user_data)
static uint16_t	convert_key_to_char (FlKeyboardManager *self, guint keycode, gint group, gint level)
static void	guarantee_layout (FlKeyboardManager *self, FlKeyEvent *event)
static void	fl_keyboard_manager_dispose (GObject *object)
static void	fl_keyboard_manager_class_init (FlKeyboardManagerClass *klass)
static void	fl_keyboard_manager_init (FlKeyboardManager *self)
FlKeyboardManager *	fl_keyboard_manager_new (FlEngine *engine, FlKeyboardViewDelegate *view_delegate)
gboolean	fl_keyboard_manager_handle_event (FlKeyboardManager *self, FlKeyEvent *event)
gboolean	fl_keyboard_manager_is_state_clear (FlKeyboardManager *self)
void	fl_keyboard_manager_sync_modifier_if_needed (FlKeyboardManager *self, guint state, double event_time)
GHashTable *	fl_keyboard_manager_get_pressed_state (FlKeyboardManager *self)
void	fl_keyboard_manager_set_send_key_event_handler (FlKeyboardManager *self, FlKeyboardManagerSendKeyEventHandler send_key_event_handler, gpointer user_data)
void	fl_keyboard_manager_set_lookup_key_handler (FlKeyboardManager *self, FlKeyboardManagerLookupKeyHandler lookup_key_handler, gpointer user_data)
void	fl_keyboard_manager_set_redispatch_handler (FlKeyboardManager *self, FlKeyboardManagerRedispatchEventHandler redispatch_handler, gpointer user_data)
void	fl_keyboard_manager_set_get_pressed_state_handler (FlKeyboardManager *self, FlKeyboardManagerGetPressedStateHandler get_pressed_state_handler, gpointer user_data)

Macro Definition Documentation

DEBUG_PRINT_LAYOUT

#define DEBUG_PRINT_LAYOUT

Definition at line 21 of file fl_keyboard_manager.cc.

Function Documentation

compare_pending_by_hash()

static gboolean compare_pending_by_hash ( gconstpointer  a, gconstpointer  b  )

static

Definition at line 207 of file fl_keyboard_manager.cc.

                                                                          {
  FlKeyboardPendingEvent* pending =
      FL_KEYBOARD_PENDING_EVENT(const_cast<gpointer>(a));
  uint64_t hash = *reinterpret_cast<const uint64_t*>(b);
  return fl_keyboard_pending_event_get_hash(pending) == hash;
}

References fl_keyboard_pending_event_get_hash().

Referenced by fl_keyboard_manager_remove_redispatched().

convert_key_to_char()

static uint16_t convert_key_to_char ( FlKeyboardManager *  self, guint  keycode, gint  group, gint  level  )

static

Definition at line 306 of file fl_keyboard_manager.cc.

                                                {
  GdkKeymapKey key = {keycode, group, level};
  constexpr int kBmpMax = 0xD7FF;
  guint origin;
  if (self->lookup_key_handler != nullptr) {
    origin = self->lookup_key_handler(&key, self->lookup_key_handler_user_data);
  } else {
    origin = gdk_keymap_lookup_key(self->keymap, &key);
  }
  return origin < kBmpMax ? origin : 0xFFFF;
}

Referenced by guarantee_layout().

fl_keyboard_manager_class_init()

static void fl_keyboard_manager_class_init ( FlKeyboardManagerClass *  klass )

static

Definition at line 435 of file fl_keyboard_manager.cc.

                                                                          {
  G_OBJECT_CLASS(klass)->dispose = fl_keyboard_manager_dispose;
}

References fl_keyboard_manager_dispose().

fl_keyboard_manager_data_class_init()

static void fl_keyboard_manager_data_class_init ( FlKeyboardManagerDataClass *  klass )

static

Definition at line 94 of file fl_keyboard_manager.cc.

                                       {
  G_OBJECT_CLASS(klass)->dispose = fl_keyboard_manager_data_dispose;
}

References fl_keyboard_manager_data_dispose().

fl_keyboard_manager_data_dispose()

static void fl_keyboard_manager_data_dispose ( GObject *  object )

static

Definition at line 85 of file fl_keyboard_manager.cc.

                                                              {
  g_return_if_fail(FL_IS_KEYBOARD_MANAGER_DATA(object));
  FlKeyboardManagerData* self = FL_KEYBOARD_MANAGER_DATA(object);
 
  g_weak_ref_clear(&self->manager);
 
  G_OBJECT_CLASS(fl_keyboard_manager_data_parent_class)->dispose(object);
}

Referenced by fl_keyboard_manager_data_class_init().

fl_keyboard_manager_data_init()

static void fl_keyboard_manager_data_init ( FlKeyboardManagerData *  self )

static

Definition at line 99 of file fl_keyboard_manager.cc.

{}

fl_keyboard_manager_data_new()

static FlKeyboardManagerData* fl_keyboard_manager_data_new ( FlKeyboardManager *  manager, FlKeyboardPendingEvent *  pending  )

static

Definition at line 102 of file fl_keyboard_manager.cc.

                                     {
  FlKeyboardManagerData* self = FL_KEYBOARD_MANAGER_DATA(
      g_object_new(fl_keyboard_manager_data_get_type(), nullptr));
 
  g_weak_ref_init(&self->manager, manager);
  self->pending = FL_KEYBOARD_PENDING_EVENT(g_object_ref(pending));
  return self;
}

Referenced by fl_keyboard_manager_handle_event().

fl_keyboard_manager_dispose()

static void fl_keyboard_manager_dispose ( GObject *  object )

static

Definition at line 409 of file fl_keyboard_manager.cc.

                                                         {
  FlKeyboardManager* self = FL_KEYBOARD_MANAGER(object);
 
  g_cancellable_cancel(self->cancellable);
 
  g_weak_ref_clear(&self->engine);
  g_weak_ref_clear(&self->view_delegate);
 
  self->keycode_to_goals.reset();
  self->logical_to_mandatory_goals.reset();
 
  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);
  g_clear_object(&self->derived_layout);
  if (self->keymap_keys_changed_cb_id != 0) {
    g_signal_handler_disconnect(self->keymap, self->keymap_keys_changed_cb_id);
    self->keymap_keys_changed_cb_id = 0;
  }
  g_clear_object(&self->cancellable);
 
  G_OBJECT_CLASS(fl_keyboard_manager_parent_class)->dispose(object);
}

References TRUE.

Referenced by fl_keyboard_manager_class_init().

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_init()

static void fl_keyboard_manager_init ( FlKeyboardManager *  self )

static

Definition at line 439 of file fl_keyboard_manager.cc.

                                                              {
  self->derived_layout = fl_keyboard_layout_new();
 
  self->keycode_to_goals =
      std::make_unique<std::map<uint16_t, const LayoutGoal*>>();
  self->logical_to_mandatory_goals =
      std::make_unique<std::map<uint64_t, const LayoutGoal*>>();
  for (const LayoutGoal& goal : layout_goals) {
    (*self->keycode_to_goals)[goal.keycode] = &goal;
    if (goal.mandatory) {
      (*self->logical_to_mandatory_goals)[goal.logical_key] = &goal;
    }
  }
 
  self->pending_responds = g_ptr_array_new();
  self->pending_redispatches = g_ptr_array_new_with_free_func(g_object_unref);
 
  self->keymap = gdk_keymap_get_for_display(gdk_display_get_default());
  self->keymap_keys_changed_cb_id = g_signal_connect_swapped(
      self->keymap, "keys-changed", G_CALLBACK(keymap_keys_changed_cb), self);
  self->cancellable = g_cancellable_new();
}

References fl_keyboard_layout_new(), if(), keymap_keys_changed_cb(), and layout_goals.

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_remove_redispatched()

static bool fl_keyboard_manager_remove_redispatched ( FlKeyboardManager *  self, uint64_t  hash  )

static

Definition at line 218 of file fl_keyboard_manager.cc.

                                                                   {
  guint result_index;
  gboolean found = g_ptr_array_find_with_equal_func1(
      self->pending_redispatches, static_cast<const uint64_t*>(&hash),
      compare_pending_by_hash, &result_index);
  if (found) {
    // The removed object is freed due to `pending_redispatches`'s free_func.
    g_ptr_array_remove_index_fast(self->pending_redispatches, result_index);
    return TRUE;
  } else {
    return FALSE;
  }
}

References compare_pending_by_hash(), g_ptr_array_find_with_equal_func1(), and TRUE.

Referenced by fl_keyboard_manager_handle_event().

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_DECLARE_FINAL_TYPE	(	FlKeyboardManagerData	,
		fl_keyboard_manager_data	,
		FL	,
		KEYBOARD_MANAGER_DATA	,
		GObject
	)

G_DEFINE_TYPE()

G_DEFINE_TYPE	(	FlKeyboardManager	,
		fl_keyboard_manager	,
		G_TYPE_OBJECT
	)

g_ptr_array_find_with_equal_func1()

static gboolean g_ptr_array_find_with_equal_func1 ( GPtrArray *  haystack, gconstpointer  needle, GEqualFunc  equal_func, guint *  index_  )

static

Definition at line 185 of file fl_keyboard_manager.cc.

                                                                 {
  guint i;
  g_return_val_if_fail(haystack != NULL, FALSE);
  if (equal_func == NULL) {
    equal_func = g_direct_equal;
  }
  for (i = 0; i < haystack->len; i++) {
    if (equal_func(g_ptr_array_index(haystack, i), needle)) {
      if (index_ != NULL) {
        *index_ = i;
      }
      return TRUE;
    }
  }
 
  return FALSE;
}

References i, and TRUE.

Referenced by fl_keyboard_manager_remove_redispatched().

guarantee_layout()

static void guarantee_layout ( FlKeyboardManager *  self, FlKeyEvent *  event  )

static

Definition at line 323 of file fl_keyboard_manager.cc.

                                                                         {
  g_autoptr(FlKeyboardViewDelegate) view_delegate =
      FL_KEYBOARD_VIEW_DELEGATE(g_weak_ref_get(&self->view_delegate));
  if (view_delegate == nullptr) {
    return;
  }
 
  guint8 group = fl_key_event_get_group(event);
  if (fl_keyboard_layout_has_group(self->derived_layout, group)) {
    return;
  }
  if (self->keycode_to_goals->find(fl_key_event_get_keycode(event)) ==
      self->keycode_to_goals->end()) {
    return;
  }
 
  // Clone all mandatory goals. Each goal is removed from this cloned map when
  // fulfilled, and the remaining ones will be assigned to a default position.
  std::map<uint64_t, const LayoutGoal*> remaining_mandatory_goals =
      *self->logical_to_mandatory_goals;
 
#ifdef DEBUG_PRINT_LAYOUT
  std::string debug_layout_data;
  for (uint16_t keycode = 0; keycode < 128; keycode += 1) {
    std::vector<uint16_t> this_key_clues = {
        convert_key_to_char(self, keycode, group, 0),
        convert_key_to_char(self, keycode, group, 1),  // Shift
    };
    debug_format_layout_data(debug_layout_data, keycode, this_key_clues[0],
                             this_key_clues[1]);
  }
#endif
 
  // It's important to only traverse layout goals instead of all keycodes.
  // Some key codes outside of the standard keyboard also gives alpha-numeric
  // letters, and will therefore take over mandatory goals from standard
  // keyboard keys if they come first. Example: French keyboard digit 1.
  for (const LayoutGoal& keycode_goal : layout_goals) {
    uint16_t keycode = keycode_goal.keycode;
    std::vector<uint16_t> this_key_clues = {
        convert_key_to_char(self, keycode, group, 0),
        convert_key_to_char(self, keycode, group, 1),  // Shift
    };
 
    // The logical key should be the first available clue from below:
    //
    //  - Mandatory goal, if it matches any clue. This ensures that all alnum
    //    keys can be found somewhere.
    //  - US layout, if neither clue of the key is EASCII. This ensures that
    //    there are no non-latin logical keys.
    //  - A value derived on the fly from keycode & keyval.
    for (uint16_t clue : this_key_clues) {
      auto matching_goal = remaining_mandatory_goals.find(clue);
      if (matching_goal != remaining_mandatory_goals.end()) {
        // Found a key that produces a mandatory char. Use it.
        g_return_if_fail(fl_keyboard_layout_get_logical_key(
                             self->derived_layout, group, keycode) == 0);
        fl_keyboard_layout_set_logical_key(self->derived_layout, group, keycode,
                                           clue);
        remaining_mandatory_goals.erase(matching_goal);
        break;
      }
    }
    bool has_any_eascii =
        is_eascii(this_key_clues[0]) || is_eascii(this_key_clues[1]);
    // See if any produced char meets the requirement as a logical key.
    if (fl_keyboard_layout_get_logical_key(self->derived_layout, group,
                                           keycode) == 0 &&
        !has_any_eascii) {
      auto found_us_layout = self->keycode_to_goals->find(keycode);
      if (found_us_layout != self->keycode_to_goals->end()) {
        fl_keyboard_layout_set_logical_key(
            self->derived_layout, group, keycode,
            found_us_layout->second->logical_key);
      }
    }
  }
 
  // Ensure all mandatory goals are assigned.
  for (const auto mandatory_goal_iter : remaining_mandatory_goals) {
    const LayoutGoal* goal = mandatory_goal_iter.second;
    fl_keyboard_layout_set_logical_key(self->derived_layout, group,
                                       goal->keycode, goal->logical_key);
  }
}

References convert_key_to_char(), fl_key_event_get_group(), fl_key_event_get_keycode(), fl_keyboard_layout_get_logical_key(), fl_keyboard_layout_has_group(), fl_keyboard_layout_set_logical_key(), LayoutGoal::keycode, layout_goals, and LayoutGoal::logical_key.

Referenced by fl_keyboard_manager_handle_event().

keymap_keys_changed_cb()

static void keymap_keys_changed_cb ( FlKeyboardManager *  self )

static

Definition at line 177 of file fl_keyboard_manager.cc.

                                                            {
  g_clear_object(&self->derived_layout);
  self->derived_layout = fl_keyboard_layout_new();
}

References fl_keyboard_layout_new().

Referenced by fl_keyboard_manager_init().

responder_handle_channel_event_cb()

static void responder_handle_channel_event_cb ( GObject *  object, GAsyncResult *  result, gpointer  user_data  )

static

Definition at line 280 of file fl_keyboard_manager.cc.

                                                                  {
  g_autoptr(FlKeyboardManagerData) data = FL_KEYBOARD_MANAGER_DATA(user_data);
 
  g_autoptr(GError) error = nullptr;
  gboolean handled;
  if (!fl_key_channel_responder_handle_event_finish(
          FL_KEY_CHANNEL_RESPONDER(object), result, &handled, &error)) {
    if (!g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) {
      g_warning("Failed to handle key event in platform: %s", error->message);
    }
    return;
  }
 
  g_autoptr(FlKeyboardManager) self =
      FL_KEYBOARD_MANAGER(g_weak_ref_get(&data->manager));
  if (self == nullptr) {
    return;
  }
 
  fl_keyboard_pending_event_mark_channel_replied(data->pending, handled);
 
  responder_handle_event_callback(self, data->pending);
}

References error, fl_key_channel_responder_handle_event_finish(), fl_keyboard_pending_event_mark_channel_replied(), responder_handle_event_callback(), and user_data.

Referenced by fl_keyboard_manager_handle_event().

responder_handle_embedder_event_callback()

static void responder_handle_embedder_event_callback ( bool  handled, gpointer  user_data  )

static

Definition at line 265 of file fl_keyboard_manager.cc.

                                                                         {
  g_autoptr(FlKeyboardManagerData) data = FL_KEYBOARD_MANAGER_DATA(user_data);
 
  fl_keyboard_pending_event_mark_embedder_replied(data->pending, handled);
 
  g_autoptr(FlKeyboardManager) self =
      FL_KEYBOARD_MANAGER(g_weak_ref_get(&data->manager));
  if (self == nullptr) {
    return;
  }
 
  responder_handle_event_callback(self, data->pending);
}

References fl_keyboard_pending_event_mark_embedder_replied(), responder_handle_event_callback(), and user_data.

Referenced by fl_keyboard_manager_handle_event().

responder_handle_event_callback()

static void responder_handle_event_callback ( FlKeyboardManager *  self, FlKeyboardPendingEvent *  pending  )

static

Definition at line 234 of file fl_keyboard_manager.cc.

                                                                             {
  g_autoptr(FlKeyboardViewDelegate) view_delegate =
      FL_KEYBOARD_VIEW_DELEGATE(g_weak_ref_get(&self->view_delegate));
  if (view_delegate == nullptr) {
    return;
  }
 
  // All responders have replied.
  if (fl_keyboard_pending_event_is_complete(pending)) {
    g_ptr_array_remove(self->pending_responds, pending);
    bool should_redispatch =
        !fl_keyboard_pending_event_get_any_handled(pending) &&
        !fl_keyboard_view_delegate_text_filter_key_press(
            view_delegate, fl_keyboard_pending_event_get_event(pending));
    if (should_redispatch) {
      g_ptr_array_add(self->pending_redispatches, g_object_ref(pending));
      FlKeyEvent* event = fl_keyboard_pending_event_get_event(pending);
      if (self->redispatch_handler != nullptr) {
        self->redispatch_handler(event, self->redispatch_handler_user_data);
      } else {
        GdkEventType event_type =
            gdk_event_get_event_type(fl_key_event_get_origin(event));
        g_return_if_fail(event_type == GDK_KEY_PRESS ||
                         event_type == GDK_KEY_RELEASE);
        gdk_event_put(fl_key_event_get_origin(event));
      }
    }
  }
}

References fl_key_event_get_origin(), fl_keyboard_pending_event_get_any_handled(), fl_keyboard_pending_event_get_event(), fl_keyboard_pending_event_is_complete(), and fl_keyboard_view_delegate_text_filter_key_press().

Referenced by responder_handle_channel_event_cb(), and responder_handle_embedder_event_callback().