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

Macros
#define	FL_TYPE_KEYBOARD_HANDLER fl_keyboard_handler_get_type()

Functions
	G_DECLARE_FINAL_TYPE (FlKeyboardHandler, fl_keyboard_handler, FL, KEYBOARD_HANDLER, GObject)

FlKeyboardHandler *	fl_keyboard_handler_new (FlBinaryMessenger messenger, FlKeyboardViewDelegate view_delegate)

gboolean	fl_keyboard_handler_handle_event (FlKeyboardHandler handler, FlKeyEvent event)

gboolean	fl_keyboard_handler_is_state_clear (FlKeyboardHandler *handler)

void	fl_keyboard_handler_sync_modifier_if_needed (FlKeyboardHandler *handler, guint state, double event_time)

GHashTable *	fl_keyboard_handler_get_pressed_state (FlKeyboardHandler *handler)

Macro Definition Documentation

◆ FL_TYPE_KEYBOARD_HANDLER

#define FL_TYPE_KEYBOARD_HANDLER fl_keyboard_handler_get_type()

Definition at line 14 of file fl_keyboard_handler.h.

Function Documentation

◆ fl_keyboard_handler_get_pressed_state()

GHashTable* fl_keyboard_handler_get_pressed_state ( FlKeyboardHandler * handler )

fl_keyboard_handler_get_pressed_state: @handler: the #FlKeyboardHandler 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 590 of file fl_keyboard_handler.cc.

                                                                            {
   g_return_val_if_fail(FL_IS_KEYBOARD_HANDLER(self), nullptr);
  
   // The embedder responder is the first element in
   // FlKeyboardHandler.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);
 }

References fl_key_embedder_responder_get_pressed_state().

Referenced by fl_view_get_keyboard_state().

◆ fl_keyboard_handler_handle_event()

gboolean fl_keyboard_handler_handle_event	(	FlKeyboardHandler *	handler,
		FlKeyEvent *	event
	)

fl_keyboard_handler_handle_event: @handler: the #FlKeyboardHandler self. @event: the event to be dispatched. It is usually a wrap of a GdkEventKey. This event will be managed and released by #FlKeyboardHandler.

Make the handler 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 541 of file fl_keyboard_handler.cc.

                                                              {
   g_return_val_if_fail(FL_IS_KEYBOARD_HANDLER(self), FALSE);
   g_return_val_if_fail(event != nullptr, FALSE);
   g_return_val_if_fail(self->view_delegate != nullptr, FALSE);
  
   guarantee_layout(self, event);
  
   uint64_t incoming_hash = fl_key_event_hash(event);
   if (fl_keyboard_handler_remove_redispatched(self, incoming_hash)) {
     return FALSE;
   }
  
   FlKeyboardPendingEvent* pending = fl_keyboard_pending_event_new(
       event, ++self->last_sequence_id, self->responder_list->len);
  
   g_ptr_array_add(self->pending_responds, pending);
   FlKeyboardHandlerUserData* user_data = fl_keyboard_handler_user_data_new(
       self, fl_keyboard_pending_event_get_sequence_id(pending));
   DispatchToResponderLoopContext data{
       .event = event,
       .specified_logical_key =
           get_logical_key_from_layout(event, *self->derived_layout),
       .user_data = user_data,
   };
   g_ptr_array_foreach(self->responder_list, dispatch_to_responder, &data);
  
   return TRUE;
 }

References dispatch_to_responder(), event, fl_key_event_hash(), fl_keyboard_handler_remove_redispatched(), fl_keyboard_handler_user_data_new(), fl_keyboard_pending_event_get_sequence_id(), fl_keyboard_pending_event_new(), get_logical_key_from_layout(), guarantee_layout(), TRUE, and user_data.

Referenced by fl_view_key_press_event(), and fl_view_key_release_event().

◆ fl_keyboard_handler_is_state_clear()

gboolean fl_keyboard_handler_is_state_clear ( FlKeyboardHandler * handler )

fl_keyboard_handler_is_state_clear: @handler: the #FlKeyboardHandler self.

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

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

Definition at line 571 of file fl_keyboard_handler.cc.

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

◆ fl_keyboard_handler_new()

FlKeyboardHandler* fl_keyboard_handler_new	(	FlBinaryMessenger *	messenger,
		FlKeyboardViewDelegate *	view_delegate
	)

FlKeyboardHandler:

Processes keyboard events and cooperate with TextInputHandler.

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 TextInputHandler) and are handled synchronously.
Redispatching: Events are inserted back to the system for redispatching. fl_keyboard_handler_new: @view_delegate: An interface that the handler requires to communicate with the platform. Usually implemented by FlView.

Create a new #FlKeyboardHandler.

Returns: a new #FlKeyboardHandler.

Definition at line 499 of file fl_keyboard_handler.cc.

                                            {
   g_return_val_if_fail(FL_IS_KEYBOARD_VIEW_DELEGATE(view_delegate), nullptr);
  
   FlKeyboardHandler* self = FL_KEYBOARD_HANDLER(
       g_object_new(fl_keyboard_handler_get_type(), nullptr));
  
   self->view_delegate = view_delegate;
   g_object_add_weak_pointer(
       G_OBJECT(view_delegate),
       reinterpret_cast<gpointer*>(&(self->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) {
             FlKeyboardHandler* self =
                 FL_KEYBOARD_HANDLER(send_key_event_user_data);
             g_return_if_fail(self->view_delegate != nullptr);
             fl_keyboard_view_delegate_send_key_event(
                 self->view_delegate, event, callback, callback_user_data);
           },
           self)));
   g_ptr_array_add(self->responder_list,
                   FL_KEY_RESPONDER(fl_key_channel_responder_new(
                       fl_keyboard_view_delegate_get_messenger(view_delegate))));
  
   fl_keyboard_view_delegate_subscribe_to_layout_change(
       self->view_delegate, [self]() { self->derived_layout->clear(); });
  
   // Setup the flutter/keyboard channel.
   g_autoptr(FlStandardMethodCodec) codec = fl_standard_method_codec_new();
   self->channel =
       fl_method_channel_new(messenger, kChannelName, FL_METHOD_CODEC(codec));
   fl_method_channel_set_method_call_handler(self->channel, method_call_handler,
                                             self, nullptr);
   return self;
 }

References callback, event, fl_key_channel_responder_new(), fl_key_embedder_responder_new(), fl_keyboard_view_delegate_get_messenger(), fl_keyboard_view_delegate_send_key_event(), fl_keyboard_view_delegate_subscribe_to_layout_change(), fl_method_channel_new(), fl_method_channel_set_method_call_handler(), fl_standard_method_codec_new(), kChannelName, and method_call_handler().

Referenced by init_keyboard().

◆ fl_keyboard_handler_sync_modifier_if_needed()

void fl_keyboard_handler_sync_modifier_if_needed	(	FlKeyboardHandler *	handler,
		guint	state,
		double	event_time
	)

fl_keyboard_handler_sync_modifier_if_needed: @handler: the #FlKeyboardHandler 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 577 of file fl_keyboard_handler.cc.

                                                                     {
   g_return_if_fail(FL_IS_KEYBOARD_HANDLER(self));
  
   // The embedder responder is the first element in
   // FlKeyboardHandler.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);
 }

References fl_key_embedder_responder_sync_modifiers_if_needed(), and state.

Referenced by motion_notify_event_cb(), and send_pointer_button_event().

◆ G_DECLARE_FINAL_TYPE()

G_DECLARE_FINAL_TYPE	(	FlKeyboardHandler	,
		fl_keyboard_handler	,
		FL	,
		KEYBOARD_HANDLER	,
		GObject
	)

Macros

Functions