// GENERATED — DO NOT EDIT

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/class.EventControllerKey.html).
pub type EventControllerKey

///|
pub(open) trait IEventControllerKey {
  fn as_event_controller_key(Self) -> EventControllerKey
  fn forward(Self, &IWidget) -> Bool = _
  fn get_group(Self) -> UInt = _
  fn get_im_context(Self) -> IMContext? = _
  fn set_im_context(Self, &IIMContext?) -> Unit = _
  fn connect_im_update(Self, (EventControllerKey) -> Unit) -> UInt64 = _
  fn connect_key_pressed(
    Self,
    (EventControllerKey, UInt, UInt, @gdk.ModifierType) -> Bool,
  ) -> UInt64 = _
  fn connect_key_released(
    Self,
    (EventControllerKey, UInt, UInt, @gdk.ModifierType) -> Unit,
  ) -> UInt64 = _
  fn connect_modifiers(Self, (EventControllerKey, @gdk.ModifierType) -> Bool) -> UInt64 = _
}

///|
pub impl IEventControllerKey for EventControllerKey with fn as_event_controller_key(
  self,
) {
  self
}

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/ctor.EventControllerKey.new.html).
pub extern "c" fn EventControllerKey::new() -> EventControllerKey = "moonbit_gtk_event_controller_key_new"

///|
#borrow(self_, widget)
extern "c" fn moonbit_gtk_event_controller_key_forward(
  self_ : EventControllerKey,
  widget : Widget,
) -> Bool = "moonbit_gtk_event_controller_key_forward"

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/method.EventControllerKey.forward.html).
pub fn EventControllerKey::forward(
  self : EventControllerKey,
  widget : &IWidget,
) -> Bool {
  moonbit_gtk_event_controller_key_forward(self, widget.as_widget())
}

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/method.EventControllerKey.get_group.html).
#borrow(self)
pub extern "c" fn EventControllerKey::get_group(
  self : EventControllerKey,
) -> UInt = "moonbit_gtk_event_controller_key_get_group"

///|
#borrow(self_)
extern "c" fn moonbit_gtk_event_controller_key_get_im_context(
  self_ : EventControllerKey,
) -> @glib.Nullable[IMContext] = "moonbit_gtk_event_controller_key_get_im_context"

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/method.EventControllerKey.get_im_context.html).
pub fn EventControllerKey::get_im_context(
  self : EventControllerKey,
) -> IMContext? {
  let raw_result = moonbit_gtk_event_controller_key_get_im_context(self)
  raw_result.to_option()
}

///|
#borrow(self_, im_context)
extern "c" fn moonbit_gtk_event_controller_key_set_im_context(
  self_ : EventControllerKey,
  im_context : @glib.Nullable[IMContext],
) = "moonbit_gtk_event_controller_key_set_im_context"

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/method.EventControllerKey.set_im_context.html).
pub fn EventControllerKey::set_im_context(
  self : EventControllerKey,
  im_context : &IIMContext?,
) -> Unit {
  moonbit_gtk_event_controller_key_set_im_context(
    self,
    match im_context {
      Some(v) => @glib.Nullable::some(v.as_im_context())
      None => @glib.Nullable::null()
    },
  )
}

///|
#borrow(instance)
extern "c" fn gtk_event_controller_key_connect_im_update(
  instance : EventControllerKey,
  function : FuncRef[(EventControllerKey, (EventControllerKey) -> Unit) -> Unit],
  closure : (EventControllerKey) -> Unit,
) -> UInt64 = "moonbit_gtk_event_controller_key_connect_im_update"

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/signal.EventControllerKey.im-update.html).
pub fn EventControllerKey::connect_im_update(
  self : EventControllerKey,
  f : (EventControllerKey) -> Unit,
) -> UInt64 {
  gtk_event_controller_key_connect_im_update(
    self,
    fn(instance_, f) { f(instance_) },
    f,
  )
}

///|
#borrow(instance)
extern "c" fn gtk_event_controller_key_connect_key_pressed(
  instance : EventControllerKey,
  function : FuncRef[
    (
      EventControllerKey,
      UInt,
      UInt,
      Int,
      (EventControllerKey, UInt, UInt, @gdk.ModifierType) -> Bool,
    ) -> Bool,
  ],
  closure : (EventControllerKey, UInt, UInt, @gdk.ModifierType) -> Bool,
) -> UInt64 = "moonbit_gtk_event_controller_key_connect_key_pressed"

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/signal.EventControllerKey.key-pressed.html).
pub fn EventControllerKey::connect_key_pressed(
  self : EventControllerKey,
  f : (EventControllerKey, UInt, UInt, @gdk.ModifierType) -> Bool,
) -> UInt64 {
  gtk_event_controller_key_connect_key_pressed(
    self,
    fn(instance_, keyval, keycode, state, f) {
      f(instance_, keyval, keycode, @gdk.ModifierType::from_int(state))
    },
    f,
  )
}

///|
#borrow(instance)
extern "c" fn gtk_event_controller_key_connect_key_released(
  instance : EventControllerKey,
  function : FuncRef[
    (
      EventControllerKey,
      UInt,
      UInt,
      Int,
      (EventControllerKey, UInt, UInt, @gdk.ModifierType) -> Unit,
    ) -> Unit,
  ],
  closure : (EventControllerKey, UInt, UInt, @gdk.ModifierType) -> Unit,
) -> UInt64 = "moonbit_gtk_event_controller_key_connect_key_released"

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/signal.EventControllerKey.key-released.html).
pub fn EventControllerKey::connect_key_released(
  self : EventControllerKey,
  f : (EventControllerKey, UInt, UInt, @gdk.ModifierType) -> Unit,
) -> UInt64 {
  gtk_event_controller_key_connect_key_released(
    self,
    fn(instance_, keyval, keycode, state, f) {
      f(instance_, keyval, keycode, @gdk.ModifierType::from_int(state))
    },
    f,
  )
}

///|
#borrow(instance)
extern "c" fn gtk_event_controller_key_connect_modifiers(
  instance : EventControllerKey,
  function : FuncRef[
    (EventControllerKey, Int, (EventControllerKey, @gdk.ModifierType) -> Bool) -> Bool,
  ],
  closure : (EventControllerKey, @gdk.ModifierType) -> Bool,
) -> UInt64 = "moonbit_gtk_event_controller_key_connect_modifiers"

///|
/// [Upstream documentation](https://docs.gtk.org/gtk4/signal.EventControllerKey.modifiers.html).
pub fn EventControllerKey::connect_modifiers(
  self : EventControllerKey,
  f : (EventControllerKey, @gdk.ModifierType) -> Bool,
) -> UInt64 {
  gtk_event_controller_key_connect_modifiers(
    self,
    fn(instance_, state, f) { f(instance_, @gdk.ModifierType::from_int(state)) },
    f,
  )
}

///|
impl IEventControllerKey with fn forward(self, widget) -> Bool {
  self.as_event_controller_key().forward(widget)
}

///|
impl IEventControllerKey with fn get_group(self) -> UInt {
  self.as_event_controller_key().get_group()
}

///|
impl IEventControllerKey with fn get_im_context(self) -> IMContext? {
  self.as_event_controller_key().get_im_context()
}

///|
impl IEventControllerKey with fn set_im_context(self, im_context) -> Unit {
  self.as_event_controller_key().set_im_context(im_context)
}

///|
impl IEventControllerKey with fn connect_im_update(self, f) -> UInt64 {
  self.as_event_controller_key().connect_im_update(f)
}

///|
impl IEventControllerKey with fn connect_key_pressed(self, f) -> UInt64 {
  self.as_event_controller_key().connect_key_pressed(f)
}

///|
impl IEventControllerKey with fn connect_key_released(self, f) -> UInt64 {
  self.as_event_controller_key().connect_key_released(f)
}

///|
impl IEventControllerKey with fn connect_modifiers(self, f) -> UInt64 {
  self.as_event_controller_key().connect_modifiers(f)
}

///|
pub fn EventControllerKey::as_event_controller(
  self : EventControllerKey,
) -> EventController = "%identity"

///|
pub impl IEventController for EventControllerKey with fn as_event_controller(
  self,
) {
  self.as_event_controller()
}

///|
pub fn EventControllerKey::as_gobject_object(
  self : EventControllerKey,
) -> @gobject.Object = "%identity"

///|
pub impl @gobject.IObject for EventControllerKey with fn as_object(self) {
  self.as_gobject_object()
}