{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- t'GI.Gtk.Objects.EventControllerKey.EventControllerKey' is an event controller meant for situations
-- where you need access to key events.
-- 
-- This object was added in 3.24.

#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.Gtk.Objects.EventControllerKey
    ( 

-- * Exported types
    EventControllerKey(..)                  ,
    IsEventControllerKey                    ,
    toEventControllerKey                    ,


 -- * Methods
-- ** Overloaded methods #method:Overloaded methods#

#if defined(ENABLE_OVERLOADING)
    ResolveEventControllerKeyMethod         ,
#endif


-- ** forward #method:forward#

#if defined(ENABLE_OVERLOADING)
    EventControllerKeyForwardMethodInfo     ,
#endif
    eventControllerKeyForward               ,


-- ** getGroup #method:getGroup#

#if defined(ENABLE_OVERLOADING)
    EventControllerKeyGetGroupMethodInfo    ,
#endif
    eventControllerKeyGetGroup              ,


-- ** getImContext #method:getImContext#

#if defined(ENABLE_OVERLOADING)
    EventControllerKeyGetImContextMethodInfo,
#endif
    eventControllerKeyGetImContext          ,


-- ** new #method:new#

    eventControllerKeyNew                   ,


-- ** setImContext #method:setImContext#

#if defined(ENABLE_OVERLOADING)
    EventControllerKeySetImContextMethodInfo,
#endif
    eventControllerKeySetImContext          ,




 -- * Signals
-- ** focusIn #signal:focusIn#

    C_EventControllerKeyFocusInCallback     ,
    EventControllerKeyFocusInCallback       ,
#if defined(ENABLE_OVERLOADING)
    EventControllerKeyFocusInSignalInfo     ,
#endif
    afterEventControllerKeyFocusIn          ,
    genClosure_EventControllerKeyFocusIn    ,
    mk_EventControllerKeyFocusInCallback    ,
    noEventControllerKeyFocusInCallback     ,
    onEventControllerKeyFocusIn             ,
    wrap_EventControllerKeyFocusInCallback  ,


-- ** focusOut #signal:focusOut#

    C_EventControllerKeyFocusOutCallback    ,
    EventControllerKeyFocusOutCallback      ,
#if defined(ENABLE_OVERLOADING)
    EventControllerKeyFocusOutSignalInfo    ,
#endif
    afterEventControllerKeyFocusOut         ,
    genClosure_EventControllerKeyFocusOut   ,
    mk_EventControllerKeyFocusOutCallback   ,
    noEventControllerKeyFocusOutCallback    ,
    onEventControllerKeyFocusOut            ,
    wrap_EventControllerKeyFocusOutCallback ,


-- ** imUpdate #signal:imUpdate#

    C_EventControllerKeyImUpdateCallback    ,
    EventControllerKeyImUpdateCallback      ,
#if defined(ENABLE_OVERLOADING)
    EventControllerKeyImUpdateSignalInfo    ,
#endif
    afterEventControllerKeyImUpdate         ,
    genClosure_EventControllerKeyImUpdate   ,
    mk_EventControllerKeyImUpdateCallback   ,
    noEventControllerKeyImUpdateCallback    ,
    onEventControllerKeyImUpdate            ,
    wrap_EventControllerKeyImUpdateCallback ,


-- ** keyPressed #signal:keyPressed#

    C_EventControllerKeyKeyPressedCallback  ,
    EventControllerKeyKeyPressedCallback    ,
#if defined(ENABLE_OVERLOADING)
    EventControllerKeyKeyPressedSignalInfo  ,
#endif
    afterEventControllerKeyKeyPressed       ,
    genClosure_EventControllerKeyKeyPressed ,
    mk_EventControllerKeyKeyPressedCallback ,
    noEventControllerKeyKeyPressedCallback  ,
    onEventControllerKeyKeyPressed          ,
    wrap_EventControllerKeyKeyPressedCallback,


-- ** keyReleased #signal:keyReleased#

    C_EventControllerKeyKeyReleasedCallback ,
    EventControllerKeyKeyReleasedCallback   ,
#if defined(ENABLE_OVERLOADING)
    EventControllerKeyKeyReleasedSignalInfo ,
#endif
    afterEventControllerKeyKeyReleased      ,
    genClosure_EventControllerKeyKeyReleased,
    mk_EventControllerKeyKeyReleasedCallback,
    noEventControllerKeyKeyReleasedCallback ,
    onEventControllerKeyKeyReleased         ,
    wrap_EventControllerKeyKeyReleasedCallback,


-- ** modifiers #signal:modifiers#

    C_EventControllerKeyModifiersCallback   ,
    EventControllerKeyModifiersCallback     ,
#if defined(ENABLE_OVERLOADING)
    EventControllerKeyModifiersSignalInfo   ,
#endif
    afterEventControllerKeyModifiers        ,
    genClosure_EventControllerKeyModifiers  ,
    mk_EventControllerKeyModifiersCallback  ,
    noEventControllerKeyModifiersCallback   ,
    onEventControllerKeyModifiers           ,
    wrap_EventControllerKeyModifiersCallback,




    ) where

import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL

import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gdk.Flags as Gdk.Flags
import {-# SOURCE #-} qualified GI.Gtk.Objects.EventController as Gtk.EventController
import {-# SOURCE #-} qualified GI.Gtk.Objects.IMContext as Gtk.IMContext
import {-# SOURCE #-} qualified GI.Gtk.Objects.Widget as Gtk.Widget

-- | Memory-managed wrapper type.
newtype EventControllerKey = EventControllerKey (SP.ManagedPtr EventControllerKey)
    deriving (EventControllerKey -> EventControllerKey -> Bool
(EventControllerKey -> EventControllerKey -> Bool)
-> (EventControllerKey -> EventControllerKey -> Bool)
-> Eq EventControllerKey
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: EventControllerKey -> EventControllerKey -> Bool
$c/= :: EventControllerKey -> EventControllerKey -> Bool
== :: EventControllerKey -> EventControllerKey -> Bool
$c== :: EventControllerKey -> EventControllerKey -> Bool
Eq)

instance SP.ManagedPtrNewtype EventControllerKey where
    toManagedPtr :: EventControllerKey -> ManagedPtr EventControllerKey
toManagedPtr (EventControllerKey ManagedPtr EventControllerKey
p) = ManagedPtr EventControllerKey
p

foreign import ccall "gtk_event_controller_key_get_type"
    c_gtk_event_controller_key_get_type :: IO B.Types.GType

instance B.Types.TypedObject EventControllerKey where
    glibType :: IO GType
glibType = IO GType
c_gtk_event_controller_key_get_type

instance B.Types.GObject EventControllerKey

-- | Convert 'EventControllerKey' to and from 'Data.GI.Base.GValue.GValue' with 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue EventControllerKey where
    toGValue :: EventControllerKey -> IO GValue
toGValue EventControllerKey
o = do
        GType
gtype <- IO GType
c_gtk_event_controller_key_get_type
        EventControllerKey
-> (Ptr EventControllerKey -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr EventControllerKey
o (GType
-> (GValue -> Ptr EventControllerKey -> IO ())
-> Ptr EventControllerKey
-> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr EventControllerKey -> IO ()
forall a. GObject a => GValue -> Ptr a -> IO ()
B.GValue.set_object)
        
    fromGValue :: GValue -> IO EventControllerKey
fromGValue GValue
gv = do
        Ptr EventControllerKey
ptr <- GValue -> IO (Ptr EventControllerKey)
forall b. GObject b => GValue -> IO (Ptr b)
B.GValue.get_object GValue
gv :: IO (Ptr EventControllerKey)
        (ManagedPtr EventControllerKey -> EventControllerKey)
-> Ptr EventControllerKey -> IO EventControllerKey
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr EventControllerKey -> EventControllerKey
EventControllerKey Ptr EventControllerKey
ptr
        
    

-- | Type class for types which can be safely cast to `EventControllerKey`, for instance with `toEventControllerKey`.
class (SP.GObject o, O.IsDescendantOf EventControllerKey o) => IsEventControllerKey o
instance (SP.GObject o, O.IsDescendantOf EventControllerKey o) => IsEventControllerKey o

instance O.HasParentTypes EventControllerKey
type instance O.ParentTypes EventControllerKey = '[Gtk.EventController.EventController, GObject.Object.Object]

-- | Cast to `EventControllerKey`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toEventControllerKey :: (MonadIO m, IsEventControllerKey o) => o -> m EventControllerKey
toEventControllerKey :: o -> m EventControllerKey
toEventControllerKey = IO EventControllerKey -> m EventControllerKey
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO EventControllerKey -> m EventControllerKey)
-> (o -> IO EventControllerKey) -> o -> m EventControllerKey
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr EventControllerKey -> EventControllerKey)
-> o -> IO EventControllerKey
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
 ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
unsafeCastTo ManagedPtr EventControllerKey -> EventControllerKey
EventControllerKey

#if defined(ENABLE_OVERLOADING)
type family ResolveEventControllerKeyMethod (t :: Symbol) (o :: *) :: * where
    ResolveEventControllerKeyMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveEventControllerKeyMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveEventControllerKeyMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveEventControllerKeyMethod "forward" o = EventControllerKeyForwardMethodInfo
    ResolveEventControllerKeyMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveEventControllerKeyMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveEventControllerKeyMethod "handleEvent" o = Gtk.EventController.EventControllerHandleEventMethodInfo
    ResolveEventControllerKeyMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveEventControllerKeyMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveEventControllerKeyMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveEventControllerKeyMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveEventControllerKeyMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveEventControllerKeyMethod "reset" o = Gtk.EventController.EventControllerResetMethodInfo
    ResolveEventControllerKeyMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveEventControllerKeyMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveEventControllerKeyMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveEventControllerKeyMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveEventControllerKeyMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveEventControllerKeyMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveEventControllerKeyMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveEventControllerKeyMethod "getGroup" o = EventControllerKeyGetGroupMethodInfo
    ResolveEventControllerKeyMethod "getImContext" o = EventControllerKeyGetImContextMethodInfo
    ResolveEventControllerKeyMethod "getPropagationPhase" o = Gtk.EventController.EventControllerGetPropagationPhaseMethodInfo
    ResolveEventControllerKeyMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveEventControllerKeyMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveEventControllerKeyMethod "getWidget" o = Gtk.EventController.EventControllerGetWidgetMethodInfo
    ResolveEventControllerKeyMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveEventControllerKeyMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveEventControllerKeyMethod "setImContext" o = EventControllerKeySetImContextMethodInfo
    ResolveEventControllerKeyMethod "setPropagationPhase" o = Gtk.EventController.EventControllerSetPropagationPhaseMethodInfo
    ResolveEventControllerKeyMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveEventControllerKeyMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveEventControllerKeyMethod t EventControllerKey, O.MethodInfo info EventControllerKey p) => OL.IsLabel t (EventControllerKey -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod @info
#else
    fromLabel _ = O.overloadedMethod @info
#endif

#endif

-- signal EventControllerKey::focus-in
-- | /No description available in the introspection data./
type EventControllerKeyFocusInCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `EventControllerKeyFocusInCallback`@.
noEventControllerKeyFocusInCallback :: Maybe EventControllerKeyFocusInCallback
noEventControllerKeyFocusInCallback :: Maybe (IO ())
noEventControllerKeyFocusInCallback = Maybe (IO ())
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_EventControllerKeyFocusInCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_EventControllerKeyFocusInCallback`.
foreign import ccall "wrapper"
    mk_EventControllerKeyFocusInCallback :: C_EventControllerKeyFocusInCallback -> IO (FunPtr C_EventControllerKeyFocusInCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_EventControllerKeyFocusIn :: MonadIO m => EventControllerKeyFocusInCallback -> m (GClosure C_EventControllerKeyFocusInCallback)
genClosure_EventControllerKeyFocusIn :: IO () -> m (GClosure C_EventControllerKeyFocusInCallback)
genClosure_EventControllerKeyFocusIn IO ()
cb = IO (GClosure C_EventControllerKeyFocusInCallback)
-> m (GClosure C_EventControllerKeyFocusInCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_EventControllerKeyFocusInCallback)
 -> m (GClosure C_EventControllerKeyFocusInCallback))
-> IO (GClosure C_EventControllerKeyFocusInCallback)
-> m (GClosure C_EventControllerKeyFocusInCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EventControllerKeyFocusInCallback
cb' = IO () -> C_EventControllerKeyFocusInCallback
wrap_EventControllerKeyFocusInCallback IO ()
cb
    C_EventControllerKeyFocusInCallback
-> IO (FunPtr C_EventControllerKeyFocusInCallback)
mk_EventControllerKeyFocusInCallback C_EventControllerKeyFocusInCallback
cb' IO (FunPtr C_EventControllerKeyFocusInCallback)
-> (FunPtr C_EventControllerKeyFocusInCallback
    -> IO (GClosure C_EventControllerKeyFocusInCallback))
-> IO (GClosure C_EventControllerKeyFocusInCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_EventControllerKeyFocusInCallback
-> IO (GClosure C_EventControllerKeyFocusInCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `EventControllerKeyFocusInCallback` into a `C_EventControllerKeyFocusInCallback`.
wrap_EventControllerKeyFocusInCallback ::
    EventControllerKeyFocusInCallback ->
    C_EventControllerKeyFocusInCallback
wrap_EventControllerKeyFocusInCallback :: IO () -> C_EventControllerKeyFocusInCallback
wrap_EventControllerKeyFocusInCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
    IO ()
_cb 


-- | Connect a signal handler for the [focusIn](#signal:focusIn) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' eventControllerKey #focusIn callback
-- @
-- 
-- 
onEventControllerKeyFocusIn :: (IsEventControllerKey a, MonadIO m) => a -> EventControllerKeyFocusInCallback -> m SignalHandlerId
onEventControllerKeyFocusIn :: a -> IO () -> m SignalHandlerId
onEventControllerKeyFocusIn a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EventControllerKeyFocusInCallback
cb' = IO () -> C_EventControllerKeyFocusInCallback
wrap_EventControllerKeyFocusInCallback IO ()
cb
    FunPtr C_EventControllerKeyFocusInCallback
cb'' <- C_EventControllerKeyFocusInCallback
-> IO (FunPtr C_EventControllerKeyFocusInCallback)
mk_EventControllerKeyFocusInCallback C_EventControllerKeyFocusInCallback
cb'
    a
-> Text
-> FunPtr C_EventControllerKeyFocusInCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"focus-in" FunPtr C_EventControllerKeyFocusInCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [focusIn](#signal:focusIn) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' eventControllerKey #focusIn callback
-- @
-- 
-- 
afterEventControllerKeyFocusIn :: (IsEventControllerKey a, MonadIO m) => a -> EventControllerKeyFocusInCallback -> m SignalHandlerId
afterEventControllerKeyFocusIn :: a -> IO () -> m SignalHandlerId
afterEventControllerKeyFocusIn a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EventControllerKeyFocusInCallback
cb' = IO () -> C_EventControllerKeyFocusInCallback
wrap_EventControllerKeyFocusInCallback IO ()
cb
    FunPtr C_EventControllerKeyFocusInCallback
cb'' <- C_EventControllerKeyFocusInCallback
-> IO (FunPtr C_EventControllerKeyFocusInCallback)
mk_EventControllerKeyFocusInCallback C_EventControllerKeyFocusInCallback
cb'
    a
-> Text
-> FunPtr C_EventControllerKeyFocusInCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"focus-in" FunPtr C_EventControllerKeyFocusInCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data EventControllerKeyFocusInSignalInfo
instance SignalInfo EventControllerKeyFocusInSignalInfo where
    type HaskellCallbackType EventControllerKeyFocusInSignalInfo = EventControllerKeyFocusInCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_EventControllerKeyFocusInCallback cb
        cb'' <- mk_EventControllerKeyFocusInCallback cb'
        connectSignalFunPtr obj "focus-in" cb'' connectMode detail

#endif

-- signal EventControllerKey::focus-out
-- | /No description available in the introspection data./
type EventControllerKeyFocusOutCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `EventControllerKeyFocusOutCallback`@.
noEventControllerKeyFocusOutCallback :: Maybe EventControllerKeyFocusOutCallback
noEventControllerKeyFocusOutCallback :: Maybe (IO ())
noEventControllerKeyFocusOutCallback = Maybe (IO ())
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_EventControllerKeyFocusOutCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_EventControllerKeyFocusOutCallback`.
foreign import ccall "wrapper"
    mk_EventControllerKeyFocusOutCallback :: C_EventControllerKeyFocusOutCallback -> IO (FunPtr C_EventControllerKeyFocusOutCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_EventControllerKeyFocusOut :: MonadIO m => EventControllerKeyFocusOutCallback -> m (GClosure C_EventControllerKeyFocusOutCallback)
genClosure_EventControllerKeyFocusOut :: IO () -> m (GClosure C_EventControllerKeyFocusInCallback)
genClosure_EventControllerKeyFocusOut IO ()
cb = IO (GClosure C_EventControllerKeyFocusInCallback)
-> m (GClosure C_EventControllerKeyFocusInCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_EventControllerKeyFocusInCallback)
 -> m (GClosure C_EventControllerKeyFocusInCallback))
-> IO (GClosure C_EventControllerKeyFocusInCallback)
-> m (GClosure C_EventControllerKeyFocusInCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EventControllerKeyFocusInCallback
cb' = IO () -> C_EventControllerKeyFocusInCallback
wrap_EventControllerKeyFocusOutCallback IO ()
cb
    C_EventControllerKeyFocusInCallback
-> IO (FunPtr C_EventControllerKeyFocusInCallback)
mk_EventControllerKeyFocusOutCallback C_EventControllerKeyFocusInCallback
cb' IO (FunPtr C_EventControllerKeyFocusInCallback)
-> (FunPtr C_EventControllerKeyFocusInCallback
    -> IO (GClosure C_EventControllerKeyFocusInCallback))
-> IO (GClosure C_EventControllerKeyFocusInCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_EventControllerKeyFocusInCallback
-> IO (GClosure C_EventControllerKeyFocusInCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `EventControllerKeyFocusOutCallback` into a `C_EventControllerKeyFocusOutCallback`.
wrap_EventControllerKeyFocusOutCallback ::
    EventControllerKeyFocusOutCallback ->
    C_EventControllerKeyFocusOutCallback
wrap_EventControllerKeyFocusOutCallback :: IO () -> C_EventControllerKeyFocusInCallback
wrap_EventControllerKeyFocusOutCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
    IO ()
_cb 


-- | Connect a signal handler for the [focusOut](#signal:focusOut) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' eventControllerKey #focusOut callback
-- @
-- 
-- 
onEventControllerKeyFocusOut :: (IsEventControllerKey a, MonadIO m) => a -> EventControllerKeyFocusOutCallback -> m SignalHandlerId
onEventControllerKeyFocusOut :: a -> IO () -> m SignalHandlerId
onEventControllerKeyFocusOut a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EventControllerKeyFocusInCallback
cb' = IO () -> C_EventControllerKeyFocusInCallback
wrap_EventControllerKeyFocusOutCallback IO ()
cb
    FunPtr C_EventControllerKeyFocusInCallback
cb'' <- C_EventControllerKeyFocusInCallback
-> IO (FunPtr C_EventControllerKeyFocusInCallback)
mk_EventControllerKeyFocusOutCallback C_EventControllerKeyFocusInCallback
cb'
    a
-> Text
-> FunPtr C_EventControllerKeyFocusInCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"focus-out" FunPtr C_EventControllerKeyFocusInCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [focusOut](#signal:focusOut) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' eventControllerKey #focusOut callback
-- @
-- 
-- 
afterEventControllerKeyFocusOut :: (IsEventControllerKey a, MonadIO m) => a -> EventControllerKeyFocusOutCallback -> m SignalHandlerId
afterEventControllerKeyFocusOut :: a -> IO () -> m SignalHandlerId
afterEventControllerKeyFocusOut a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EventControllerKeyFocusInCallback
cb' = IO () -> C_EventControllerKeyFocusInCallback
wrap_EventControllerKeyFocusOutCallback IO ()
cb
    FunPtr C_EventControllerKeyFocusInCallback
cb'' <- C_EventControllerKeyFocusInCallback
-> IO (FunPtr C_EventControllerKeyFocusInCallback)
mk_EventControllerKeyFocusOutCallback C_EventControllerKeyFocusInCallback
cb'
    a
-> Text
-> FunPtr C_EventControllerKeyFocusInCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"focus-out" FunPtr C_EventControllerKeyFocusInCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data EventControllerKeyFocusOutSignalInfo
instance SignalInfo EventControllerKeyFocusOutSignalInfo where
    type HaskellCallbackType EventControllerKeyFocusOutSignalInfo = EventControllerKeyFocusOutCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_EventControllerKeyFocusOutCallback cb
        cb'' <- mk_EventControllerKeyFocusOutCallback cb'
        connectSignalFunPtr obj "focus-out" cb'' connectMode detail

#endif

-- signal EventControllerKey::im-update
-- | /No description available in the introspection data./
type EventControllerKeyImUpdateCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `EventControllerKeyImUpdateCallback`@.
noEventControllerKeyImUpdateCallback :: Maybe EventControllerKeyImUpdateCallback
noEventControllerKeyImUpdateCallback :: Maybe (IO ())
noEventControllerKeyImUpdateCallback = Maybe (IO ())
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_EventControllerKeyImUpdateCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_EventControllerKeyImUpdateCallback`.
foreign import ccall "wrapper"
    mk_EventControllerKeyImUpdateCallback :: C_EventControllerKeyImUpdateCallback -> IO (FunPtr C_EventControllerKeyImUpdateCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_EventControllerKeyImUpdate :: MonadIO m => EventControllerKeyImUpdateCallback -> m (GClosure C_EventControllerKeyImUpdateCallback)
genClosure_EventControllerKeyImUpdate :: IO () -> m (GClosure C_EventControllerKeyFocusInCallback)
genClosure_EventControllerKeyImUpdate IO ()
cb = IO (GClosure C_EventControllerKeyFocusInCallback)
-> m (GClosure C_EventControllerKeyFocusInCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_EventControllerKeyFocusInCallback)
 -> m (GClosure C_EventControllerKeyFocusInCallback))
-> IO (GClosure C_EventControllerKeyFocusInCallback)
-> m (GClosure C_EventControllerKeyFocusInCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EventControllerKeyFocusInCallback
cb' = IO () -> C_EventControllerKeyFocusInCallback
wrap_EventControllerKeyImUpdateCallback IO ()
cb
    C_EventControllerKeyFocusInCallback
-> IO (FunPtr C_EventControllerKeyFocusInCallback)
mk_EventControllerKeyImUpdateCallback C_EventControllerKeyFocusInCallback
cb' IO (FunPtr C_EventControllerKeyFocusInCallback)
-> (FunPtr C_EventControllerKeyFocusInCallback
    -> IO (GClosure C_EventControllerKeyFocusInCallback))
-> IO (GClosure C_EventControllerKeyFocusInCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_EventControllerKeyFocusInCallback
-> IO (GClosure C_EventControllerKeyFocusInCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `EventControllerKeyImUpdateCallback` into a `C_EventControllerKeyImUpdateCallback`.
wrap_EventControllerKeyImUpdateCallback ::
    EventControllerKeyImUpdateCallback ->
    C_EventControllerKeyImUpdateCallback
wrap_EventControllerKeyImUpdateCallback :: IO () -> C_EventControllerKeyFocusInCallback
wrap_EventControllerKeyImUpdateCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
    IO ()
_cb 


-- | Connect a signal handler for the [imUpdate](#signal:imUpdate) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' eventControllerKey #imUpdate callback
-- @
-- 
-- 
onEventControllerKeyImUpdate :: (IsEventControllerKey a, MonadIO m) => a -> EventControllerKeyImUpdateCallback -> m SignalHandlerId
onEventControllerKeyImUpdate :: a -> IO () -> m SignalHandlerId
onEventControllerKeyImUpdate a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EventControllerKeyFocusInCallback
cb' = IO () -> C_EventControllerKeyFocusInCallback
wrap_EventControllerKeyImUpdateCallback IO ()
cb
    FunPtr C_EventControllerKeyFocusInCallback
cb'' <- C_EventControllerKeyFocusInCallback
-> IO (FunPtr C_EventControllerKeyFocusInCallback)
mk_EventControllerKeyImUpdateCallback C_EventControllerKeyFocusInCallback
cb'
    a
-> Text
-> FunPtr C_EventControllerKeyFocusInCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"im-update" FunPtr C_EventControllerKeyFocusInCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [imUpdate](#signal:imUpdate) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' eventControllerKey #imUpdate callback
-- @
-- 
-- 
afterEventControllerKeyImUpdate :: (IsEventControllerKey a, MonadIO m) => a -> EventControllerKeyImUpdateCallback -> m SignalHandlerId
afterEventControllerKeyImUpdate :: a -> IO () -> m SignalHandlerId
afterEventControllerKeyImUpdate a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EventControllerKeyFocusInCallback
cb' = IO () -> C_EventControllerKeyFocusInCallback
wrap_EventControllerKeyImUpdateCallback IO ()
cb
    FunPtr C_EventControllerKeyFocusInCallback
cb'' <- C_EventControllerKeyFocusInCallback
-> IO (FunPtr C_EventControllerKeyFocusInCallback)
mk_EventControllerKeyImUpdateCallback C_EventControllerKeyFocusInCallback
cb'
    a
-> Text
-> FunPtr C_EventControllerKeyFocusInCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"im-update" FunPtr C_EventControllerKeyFocusInCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data EventControllerKeyImUpdateSignalInfo
instance SignalInfo EventControllerKeyImUpdateSignalInfo where
    type HaskellCallbackType EventControllerKeyImUpdateSignalInfo = EventControllerKeyImUpdateCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_EventControllerKeyImUpdateCallback cb
        cb'' <- mk_EventControllerKeyImUpdateCallback cb'
        connectSignalFunPtr obj "im-update" cb'' connectMode detail

#endif

-- signal EventControllerKey::key-pressed
-- | This signal is emitted whenever a key is pressed.
-- 
-- /Since: 3.24/
type EventControllerKeyKeyPressedCallback =
    Word32
    -- ^ /@keyval@/: the pressed key.
    -> Word32
    -- ^ /@keycode@/: the raw code of the pressed key.
    -> [Gdk.Flags.ModifierType]
    -- ^ /@state@/: the bitmask, representing the state of modifier keys and pointer buttons. See t'GI.Gdk.Flags.ModifierType'.
    -> IO Bool
    -- ^ __Returns:__ 'P.True' if the key press was handled, 'P.False' otherwise.

-- | A convenience synonym for @`Nothing` :: `Maybe` `EventControllerKeyKeyPressedCallback`@.
noEventControllerKeyKeyPressedCallback :: Maybe EventControllerKeyKeyPressedCallback
noEventControllerKeyKeyPressedCallback :: Maybe EventControllerKeyKeyPressedCallback
noEventControllerKeyKeyPressedCallback = Maybe EventControllerKeyKeyPressedCallback
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_EventControllerKeyKeyPressedCallback =
    Ptr () ->                               -- object
    Word32 ->
    Word32 ->
    CUInt ->
    Ptr () ->                               -- user_data
    IO CInt

-- | Generate a function pointer callable from C code, from a `C_EventControllerKeyKeyPressedCallback`.
foreign import ccall "wrapper"
    mk_EventControllerKeyKeyPressedCallback :: C_EventControllerKeyKeyPressedCallback -> IO (FunPtr C_EventControllerKeyKeyPressedCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_EventControllerKeyKeyPressed :: MonadIO m => EventControllerKeyKeyPressedCallback -> m (GClosure C_EventControllerKeyKeyPressedCallback)
genClosure_EventControllerKeyKeyPressed :: EventControllerKeyKeyPressedCallback
-> m (GClosure C_EventControllerKeyKeyPressedCallback)
genClosure_EventControllerKeyKeyPressed EventControllerKeyKeyPressedCallback
cb = IO (GClosure C_EventControllerKeyKeyPressedCallback)
-> m (GClosure C_EventControllerKeyKeyPressedCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_EventControllerKeyKeyPressedCallback)
 -> m (GClosure C_EventControllerKeyKeyPressedCallback))
-> IO (GClosure C_EventControllerKeyKeyPressedCallback)
-> m (GClosure C_EventControllerKeyKeyPressedCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EventControllerKeyKeyPressedCallback
cb' = EventControllerKeyKeyPressedCallback
-> C_EventControllerKeyKeyPressedCallback
wrap_EventControllerKeyKeyPressedCallback EventControllerKeyKeyPressedCallback
cb
    C_EventControllerKeyKeyPressedCallback
-> IO (FunPtr C_EventControllerKeyKeyPressedCallback)
mk_EventControllerKeyKeyPressedCallback C_EventControllerKeyKeyPressedCallback
cb' IO (FunPtr C_EventControllerKeyKeyPressedCallback)
-> (FunPtr C_EventControllerKeyKeyPressedCallback
    -> IO (GClosure C_EventControllerKeyKeyPressedCallback))
-> IO (GClosure C_EventControllerKeyKeyPressedCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_EventControllerKeyKeyPressedCallback
-> IO (GClosure C_EventControllerKeyKeyPressedCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `EventControllerKeyKeyPressedCallback` into a `C_EventControllerKeyKeyPressedCallback`.
wrap_EventControllerKeyKeyPressedCallback ::
    EventControllerKeyKeyPressedCallback ->
    C_EventControllerKeyKeyPressedCallback
wrap_EventControllerKeyKeyPressedCallback :: EventControllerKeyKeyPressedCallback
-> C_EventControllerKeyKeyPressedCallback
wrap_EventControllerKeyKeyPressedCallback EventControllerKeyKeyPressedCallback
_cb Ptr ()
_ Word32
keyval Word32
keycode CUInt
state Ptr ()
_ = do
    let state' :: [ModifierType]
state' = CUInt -> [ModifierType]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
state
    Bool
result <- EventControllerKeyKeyPressedCallback
_cb  Word32
keyval Word32
keycode [ModifierType]
state'
    let result' :: CInt
result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
result
    CInt -> IO CInt
forall (m :: * -> *) a. Monad m => a -> m a
return CInt
result'


-- | Connect a signal handler for the [keyPressed](#signal:keyPressed) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' eventControllerKey #keyPressed callback
-- @
-- 
-- 
onEventControllerKeyKeyPressed :: (IsEventControllerKey a, MonadIO m) => a -> EventControllerKeyKeyPressedCallback -> m SignalHandlerId
onEventControllerKeyKeyPressed :: a -> EventControllerKeyKeyPressedCallback -> m SignalHandlerId
onEventControllerKeyKeyPressed a
obj EventControllerKeyKeyPressedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EventControllerKeyKeyPressedCallback
cb' = EventControllerKeyKeyPressedCallback
-> C_EventControllerKeyKeyPressedCallback
wrap_EventControllerKeyKeyPressedCallback EventControllerKeyKeyPressedCallback
cb
    FunPtr C_EventControllerKeyKeyPressedCallback
cb'' <- C_EventControllerKeyKeyPressedCallback
-> IO (FunPtr C_EventControllerKeyKeyPressedCallback)
mk_EventControllerKeyKeyPressedCallback C_EventControllerKeyKeyPressedCallback
cb'
    a
-> Text
-> FunPtr C_EventControllerKeyKeyPressedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"key-pressed" FunPtr C_EventControllerKeyKeyPressedCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [keyPressed](#signal:keyPressed) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' eventControllerKey #keyPressed callback
-- @
-- 
-- 
afterEventControllerKeyKeyPressed :: (IsEventControllerKey a, MonadIO m) => a -> EventControllerKeyKeyPressedCallback -> m SignalHandlerId
afterEventControllerKeyKeyPressed :: a -> EventControllerKeyKeyPressedCallback -> m SignalHandlerId
afterEventControllerKeyKeyPressed a
obj EventControllerKeyKeyPressedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EventControllerKeyKeyPressedCallback
cb' = EventControllerKeyKeyPressedCallback
-> C_EventControllerKeyKeyPressedCallback
wrap_EventControllerKeyKeyPressedCallback EventControllerKeyKeyPressedCallback
cb
    FunPtr C_EventControllerKeyKeyPressedCallback
cb'' <- C_EventControllerKeyKeyPressedCallback
-> IO (FunPtr C_EventControllerKeyKeyPressedCallback)
mk_EventControllerKeyKeyPressedCallback C_EventControllerKeyKeyPressedCallback
cb'
    a
-> Text
-> FunPtr C_EventControllerKeyKeyPressedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"key-pressed" FunPtr C_EventControllerKeyKeyPressedCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data EventControllerKeyKeyPressedSignalInfo
instance SignalInfo EventControllerKeyKeyPressedSignalInfo where
    type HaskellCallbackType EventControllerKeyKeyPressedSignalInfo = EventControllerKeyKeyPressedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_EventControllerKeyKeyPressedCallback cb
        cb'' <- mk_EventControllerKeyKeyPressedCallback cb'
        connectSignalFunPtr obj "key-pressed" cb'' connectMode detail

#endif

-- signal EventControllerKey::key-released
-- | This signal is emitted whenever a key is released.
-- 
-- /Since: 3.24/
type EventControllerKeyKeyReleasedCallback =
    Word32
    -- ^ /@keyval@/: the released key.
    -> Word32
    -- ^ /@keycode@/: the raw code of the released key.
    -> [Gdk.Flags.ModifierType]
    -- ^ /@state@/: the bitmask, representing the state of modifier keys and pointer buttons. See t'GI.Gdk.Flags.ModifierType'.
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `EventControllerKeyKeyReleasedCallback`@.
noEventControllerKeyKeyReleasedCallback :: Maybe EventControllerKeyKeyReleasedCallback
noEventControllerKeyKeyReleasedCallback :: Maybe EventControllerKeyKeyReleasedCallback
noEventControllerKeyKeyReleasedCallback = Maybe EventControllerKeyKeyReleasedCallback
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_EventControllerKeyKeyReleasedCallback =
    Ptr () ->                               -- object
    Word32 ->
    Word32 ->
    CUInt ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_EventControllerKeyKeyReleasedCallback`.
foreign import ccall "wrapper"
    mk_EventControllerKeyKeyReleasedCallback :: C_EventControllerKeyKeyReleasedCallback -> IO (FunPtr C_EventControllerKeyKeyReleasedCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_EventControllerKeyKeyReleased :: MonadIO m => EventControllerKeyKeyReleasedCallback -> m (GClosure C_EventControllerKeyKeyReleasedCallback)
genClosure_EventControllerKeyKeyReleased :: EventControllerKeyKeyReleasedCallback
-> m (GClosure C_EventControllerKeyKeyReleasedCallback)
genClosure_EventControllerKeyKeyReleased EventControllerKeyKeyReleasedCallback
cb = IO (GClosure C_EventControllerKeyKeyReleasedCallback)
-> m (GClosure C_EventControllerKeyKeyReleasedCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_EventControllerKeyKeyReleasedCallback)
 -> m (GClosure C_EventControllerKeyKeyReleasedCallback))
-> IO (GClosure C_EventControllerKeyKeyReleasedCallback)
-> m (GClosure C_EventControllerKeyKeyReleasedCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EventControllerKeyKeyReleasedCallback
cb' = EventControllerKeyKeyReleasedCallback
-> C_EventControllerKeyKeyReleasedCallback
wrap_EventControllerKeyKeyReleasedCallback EventControllerKeyKeyReleasedCallback
cb
    C_EventControllerKeyKeyReleasedCallback
-> IO (FunPtr C_EventControllerKeyKeyReleasedCallback)
mk_EventControllerKeyKeyReleasedCallback C_EventControllerKeyKeyReleasedCallback
cb' IO (FunPtr C_EventControllerKeyKeyReleasedCallback)
-> (FunPtr C_EventControllerKeyKeyReleasedCallback
    -> IO (GClosure C_EventControllerKeyKeyReleasedCallback))
-> IO (GClosure C_EventControllerKeyKeyReleasedCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_EventControllerKeyKeyReleasedCallback
-> IO (GClosure C_EventControllerKeyKeyReleasedCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `EventControllerKeyKeyReleasedCallback` into a `C_EventControllerKeyKeyReleasedCallback`.
wrap_EventControllerKeyKeyReleasedCallback ::
    EventControllerKeyKeyReleasedCallback ->
    C_EventControllerKeyKeyReleasedCallback
wrap_EventControllerKeyKeyReleasedCallback :: EventControllerKeyKeyReleasedCallback
-> C_EventControllerKeyKeyReleasedCallback
wrap_EventControllerKeyKeyReleasedCallback EventControllerKeyKeyReleasedCallback
_cb Ptr ()
_ Word32
keyval Word32
keycode CUInt
state Ptr ()
_ = do
    let state' :: [ModifierType]
state' = CUInt -> [ModifierType]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
state
    EventControllerKeyKeyReleasedCallback
_cb  Word32
keyval Word32
keycode [ModifierType]
state'


-- | Connect a signal handler for the [keyReleased](#signal:keyReleased) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' eventControllerKey #keyReleased callback
-- @
-- 
-- 
onEventControllerKeyKeyReleased :: (IsEventControllerKey a, MonadIO m) => a -> EventControllerKeyKeyReleasedCallback -> m SignalHandlerId
onEventControllerKeyKeyReleased :: a -> EventControllerKeyKeyReleasedCallback -> m SignalHandlerId
onEventControllerKeyKeyReleased a
obj EventControllerKeyKeyReleasedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EventControllerKeyKeyReleasedCallback
cb' = EventControllerKeyKeyReleasedCallback
-> C_EventControllerKeyKeyReleasedCallback
wrap_EventControllerKeyKeyReleasedCallback EventControllerKeyKeyReleasedCallback
cb
    FunPtr C_EventControllerKeyKeyReleasedCallback
cb'' <- C_EventControllerKeyKeyReleasedCallback
-> IO (FunPtr C_EventControllerKeyKeyReleasedCallback)
mk_EventControllerKeyKeyReleasedCallback C_EventControllerKeyKeyReleasedCallback
cb'
    a
-> Text
-> FunPtr C_EventControllerKeyKeyReleasedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"key-released" FunPtr C_EventControllerKeyKeyReleasedCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [keyReleased](#signal:keyReleased) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' eventControllerKey #keyReleased callback
-- @
-- 
-- 
afterEventControllerKeyKeyReleased :: (IsEventControllerKey a, MonadIO m) => a -> EventControllerKeyKeyReleasedCallback -> m SignalHandlerId
afterEventControllerKeyKeyReleased :: a -> EventControllerKeyKeyReleasedCallback -> m SignalHandlerId
afterEventControllerKeyKeyReleased a
obj EventControllerKeyKeyReleasedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EventControllerKeyKeyReleasedCallback
cb' = EventControllerKeyKeyReleasedCallback
-> C_EventControllerKeyKeyReleasedCallback
wrap_EventControllerKeyKeyReleasedCallback EventControllerKeyKeyReleasedCallback
cb
    FunPtr C_EventControllerKeyKeyReleasedCallback
cb'' <- C_EventControllerKeyKeyReleasedCallback
-> IO (FunPtr C_EventControllerKeyKeyReleasedCallback)
mk_EventControllerKeyKeyReleasedCallback C_EventControllerKeyKeyReleasedCallback
cb'
    a
-> Text
-> FunPtr C_EventControllerKeyKeyReleasedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"key-released" FunPtr C_EventControllerKeyKeyReleasedCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data EventControllerKeyKeyReleasedSignalInfo
instance SignalInfo EventControllerKeyKeyReleasedSignalInfo where
    type HaskellCallbackType EventControllerKeyKeyReleasedSignalInfo = EventControllerKeyKeyReleasedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_EventControllerKeyKeyReleasedCallback cb
        cb'' <- mk_EventControllerKeyKeyReleasedCallback cb'
        connectSignalFunPtr obj "key-released" cb'' connectMode detail

#endif

-- signal EventControllerKey::modifiers
-- | /No description available in the introspection data./
type EventControllerKeyModifiersCallback =
    [Gdk.Flags.ModifierType]
    -> IO Bool

-- | A convenience synonym for @`Nothing` :: `Maybe` `EventControllerKeyModifiersCallback`@.
noEventControllerKeyModifiersCallback :: Maybe EventControllerKeyModifiersCallback
noEventControllerKeyModifiersCallback :: Maybe EventControllerKeyModifiersCallback
noEventControllerKeyModifiersCallback = Maybe EventControllerKeyModifiersCallback
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_EventControllerKeyModifiersCallback =
    Ptr () ->                               -- object
    CUInt ->
    Ptr () ->                               -- user_data
    IO CInt

-- | Generate a function pointer callable from C code, from a `C_EventControllerKeyModifiersCallback`.
foreign import ccall "wrapper"
    mk_EventControllerKeyModifiersCallback :: C_EventControllerKeyModifiersCallback -> IO (FunPtr C_EventControllerKeyModifiersCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_EventControllerKeyModifiers :: MonadIO m => EventControllerKeyModifiersCallback -> m (GClosure C_EventControllerKeyModifiersCallback)
genClosure_EventControllerKeyModifiers :: EventControllerKeyModifiersCallback
-> m (GClosure C_EventControllerKeyModifiersCallback)
genClosure_EventControllerKeyModifiers EventControllerKeyModifiersCallback
cb = IO (GClosure C_EventControllerKeyModifiersCallback)
-> m (GClosure C_EventControllerKeyModifiersCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_EventControllerKeyModifiersCallback)
 -> m (GClosure C_EventControllerKeyModifiersCallback))
-> IO (GClosure C_EventControllerKeyModifiersCallback)
-> m (GClosure C_EventControllerKeyModifiersCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EventControllerKeyModifiersCallback
cb' = EventControllerKeyModifiersCallback
-> C_EventControllerKeyModifiersCallback
wrap_EventControllerKeyModifiersCallback EventControllerKeyModifiersCallback
cb
    C_EventControllerKeyModifiersCallback
-> IO (FunPtr C_EventControllerKeyModifiersCallback)
mk_EventControllerKeyModifiersCallback C_EventControllerKeyModifiersCallback
cb' IO (FunPtr C_EventControllerKeyModifiersCallback)
-> (FunPtr C_EventControllerKeyModifiersCallback
    -> IO (GClosure C_EventControllerKeyModifiersCallback))
-> IO (GClosure C_EventControllerKeyModifiersCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_EventControllerKeyModifiersCallback
-> IO (GClosure C_EventControllerKeyModifiersCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `EventControllerKeyModifiersCallback` into a `C_EventControllerKeyModifiersCallback`.
wrap_EventControllerKeyModifiersCallback ::
    EventControllerKeyModifiersCallback ->
    C_EventControllerKeyModifiersCallback
wrap_EventControllerKeyModifiersCallback :: EventControllerKeyModifiersCallback
-> C_EventControllerKeyModifiersCallback
wrap_EventControllerKeyModifiersCallback EventControllerKeyModifiersCallback
_cb Ptr ()
_ CUInt
object Ptr ()
_ = do
    let object' :: [ModifierType]
object' = CUInt -> [ModifierType]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
object
    Bool
result <- EventControllerKeyModifiersCallback
_cb  [ModifierType]
object'
    let result' :: CInt
result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
result
    CInt -> IO CInt
forall (m :: * -> *) a. Monad m => a -> m a
return CInt
result'


-- | Connect a signal handler for the [modifiers](#signal:modifiers) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' eventControllerKey #modifiers callback
-- @
-- 
-- 
onEventControllerKeyModifiers :: (IsEventControllerKey a, MonadIO m) => a -> EventControllerKeyModifiersCallback -> m SignalHandlerId
onEventControllerKeyModifiers :: a -> EventControllerKeyModifiersCallback -> m SignalHandlerId
onEventControllerKeyModifiers a
obj EventControllerKeyModifiersCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EventControllerKeyModifiersCallback
cb' = EventControllerKeyModifiersCallback
-> C_EventControllerKeyModifiersCallback
wrap_EventControllerKeyModifiersCallback EventControllerKeyModifiersCallback
cb
    FunPtr C_EventControllerKeyModifiersCallback
cb'' <- C_EventControllerKeyModifiersCallback
-> IO (FunPtr C_EventControllerKeyModifiersCallback)
mk_EventControllerKeyModifiersCallback C_EventControllerKeyModifiersCallback
cb'
    a
-> Text
-> FunPtr C_EventControllerKeyModifiersCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"modifiers" FunPtr C_EventControllerKeyModifiersCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [modifiers](#signal:modifiers) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' eventControllerKey #modifiers callback
-- @
-- 
-- 
afterEventControllerKeyModifiers :: (IsEventControllerKey a, MonadIO m) => a -> EventControllerKeyModifiersCallback -> m SignalHandlerId
afterEventControllerKeyModifiers :: a -> EventControllerKeyModifiersCallback -> m SignalHandlerId
afterEventControllerKeyModifiers a
obj EventControllerKeyModifiersCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EventControllerKeyModifiersCallback
cb' = EventControllerKeyModifiersCallback
-> C_EventControllerKeyModifiersCallback
wrap_EventControllerKeyModifiersCallback EventControllerKeyModifiersCallback
cb
    FunPtr C_EventControllerKeyModifiersCallback
cb'' <- C_EventControllerKeyModifiersCallback
-> IO (FunPtr C_EventControllerKeyModifiersCallback)
mk_EventControllerKeyModifiersCallback C_EventControllerKeyModifiersCallback
cb'
    a
-> Text
-> FunPtr C_EventControllerKeyModifiersCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"modifiers" FunPtr C_EventControllerKeyModifiersCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data EventControllerKeyModifiersSignalInfo
instance SignalInfo EventControllerKeyModifiersSignalInfo where
    type HaskellCallbackType EventControllerKeyModifiersSignalInfo = EventControllerKeyModifiersCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_EventControllerKeyModifiersCallback cb
        cb'' <- mk_EventControllerKeyModifiersCallback cb'
        connectSignalFunPtr obj "modifiers" cb'' connectMode detail

#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList EventControllerKey
type instance O.AttributeList EventControllerKey = EventControllerKeyAttributeList
type EventControllerKeyAttributeList = ('[ '("propagationPhase", Gtk.EventController.EventControllerPropagationPhasePropertyInfo), '("widget", Gtk.EventController.EventControllerWidgetPropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList EventControllerKey = EventControllerKeySignalList
type EventControllerKeySignalList = ('[ '("focusIn", EventControllerKeyFocusInSignalInfo), '("focusOut", EventControllerKeyFocusOutSignalInfo), '("imUpdate", EventControllerKeyImUpdateSignalInfo), '("keyPressed", EventControllerKeyKeyPressedSignalInfo), '("keyReleased", EventControllerKeyKeyReleasedSignalInfo), '("modifiers", EventControllerKeyModifiersSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

#endif

-- method EventControllerKey::new
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "widget"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "Gtk" , name = "EventControllerKey" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_event_controller_key_new" gtk_event_controller_key_new :: 
    Ptr Gtk.Widget.Widget ->                -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO (Ptr EventControllerKey)

-- | /No description available in the introspection data./
eventControllerKeyNew ::
    (B.CallStack.HasCallStack, MonadIO m, Gtk.Widget.IsWidget a) =>
    a
    -> m EventControllerKey
eventControllerKeyNew :: a -> m EventControllerKey
eventControllerKeyNew a
widget = IO EventControllerKey -> m EventControllerKey
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO EventControllerKey -> m EventControllerKey)
-> IO EventControllerKey -> m EventControllerKey
forall a b. (a -> b) -> a -> b
$ do
    Ptr Widget
widget' <- a -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
widget
    Ptr EventControllerKey
result <- Ptr Widget -> IO (Ptr EventControllerKey)
gtk_event_controller_key_new Ptr Widget
widget'
    Text -> Ptr EventControllerKey -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"eventControllerKeyNew" Ptr EventControllerKey
result
    EventControllerKey
result' <- ((ManagedPtr EventControllerKey -> EventControllerKey)
-> Ptr EventControllerKey -> IO EventControllerKey
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr EventControllerKey -> EventControllerKey
EventControllerKey) Ptr EventControllerKey
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
widget
    EventControllerKey -> IO EventControllerKey
forall (m :: * -> *) a. Monad m => a -> m a
return EventControllerKey
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method EventControllerKey::forward
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "controller"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "EventControllerKey" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "widget"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_event_controller_key_forward" gtk_event_controller_key_forward :: 
    Ptr EventControllerKey ->               -- controller : TInterface (Name {namespace = "Gtk", name = "EventControllerKey"})
    Ptr Gtk.Widget.Widget ->                -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO CInt

-- | /No description available in the introspection data./
eventControllerKeyForward ::
    (B.CallStack.HasCallStack, MonadIO m, IsEventControllerKey a, Gtk.Widget.IsWidget b) =>
    a
    -> b
    -> m Bool
eventControllerKeyForward :: a -> b -> m Bool
eventControllerKeyForward a
controller b
widget = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr EventControllerKey
controller' <- a -> IO (Ptr EventControllerKey)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
controller
    Ptr Widget
widget' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
widget
    CInt
result <- Ptr EventControllerKey -> Ptr Widget -> IO CInt
gtk_event_controller_key_forward Ptr EventControllerKey
controller' Ptr Widget
widget'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
controller
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
widget
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data EventControllerKeyForwardMethodInfo
instance (signature ~ (b -> m Bool), MonadIO m, IsEventControllerKey a, Gtk.Widget.IsWidget b) => O.MethodInfo EventControllerKeyForwardMethodInfo a signature where
    overloadedMethod = eventControllerKeyForward

#endif

-- method EventControllerKey::get_group
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "controller"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "EventControllerKey" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUInt)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_event_controller_key_get_group" gtk_event_controller_key_get_group :: 
    Ptr EventControllerKey ->               -- controller : TInterface (Name {namespace = "Gtk", name = "EventControllerKey"})
    IO Word32

-- | /No description available in the introspection data./
eventControllerKeyGetGroup ::
    (B.CallStack.HasCallStack, MonadIO m, IsEventControllerKey a) =>
    a
    -> m Word32
eventControllerKeyGetGroup :: a -> m Word32
eventControllerKeyGetGroup a
controller = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
    Ptr EventControllerKey
controller' <- a -> IO (Ptr EventControllerKey)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
controller
    Word32
result <- Ptr EventControllerKey -> IO Word32
gtk_event_controller_key_get_group Ptr EventControllerKey
controller'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
controller
    Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result

#if defined(ENABLE_OVERLOADING)
data EventControllerKeyGetGroupMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsEventControllerKey a) => O.MethodInfo EventControllerKeyGetGroupMethodInfo a signature where
    overloadedMethod = eventControllerKeyGetGroup

#endif

-- method EventControllerKey::get_im_context
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "controller"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "EventControllerKey" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkEventControllerKey"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gtk" , name = "IMContext" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_event_controller_key_get_im_context" gtk_event_controller_key_get_im_context :: 
    Ptr EventControllerKey ->               -- controller : TInterface (Name {namespace = "Gtk", name = "EventControllerKey"})
    IO (Ptr Gtk.IMContext.IMContext)

-- | Gets the IM context of a key controller.
-- 
-- /Since: 3.24/
eventControllerKeyGetImContext ::
    (B.CallStack.HasCallStack, MonadIO m, IsEventControllerKey a) =>
    a
    -- ^ /@controller@/: a t'GI.Gtk.Objects.EventControllerKey.EventControllerKey'
    -> m Gtk.IMContext.IMContext
    -- ^ __Returns:__ the IM context
eventControllerKeyGetImContext :: a -> m IMContext
eventControllerKeyGetImContext a
controller = IO IMContext -> m IMContext
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO IMContext -> m IMContext) -> IO IMContext -> m IMContext
forall a b. (a -> b) -> a -> b
$ do
    Ptr EventControllerKey
controller' <- a -> IO (Ptr EventControllerKey)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
controller
    Ptr IMContext
result <- Ptr EventControllerKey -> IO (Ptr IMContext)
gtk_event_controller_key_get_im_context Ptr EventControllerKey
controller'
    Text -> Ptr IMContext -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"eventControllerKeyGetImContext" Ptr IMContext
result
    IMContext
result' <- ((ManagedPtr IMContext -> IMContext)
-> Ptr IMContext -> IO IMContext
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr IMContext -> IMContext
Gtk.IMContext.IMContext) Ptr IMContext
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
controller
    IMContext -> IO IMContext
forall (m :: * -> *) a. Monad m => a -> m a
return IMContext
result'

#if defined(ENABLE_OVERLOADING)
data EventControllerKeyGetImContextMethodInfo
instance (signature ~ (m Gtk.IMContext.IMContext), MonadIO m, IsEventControllerKey a) => O.MethodInfo EventControllerKeyGetImContextMethodInfo a signature where
    overloadedMethod = eventControllerKeyGetImContext

#endif

-- method EventControllerKey::set_im_context
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "controller"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "EventControllerKey" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "im_context"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "IMContext" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_event_controller_key_set_im_context" gtk_event_controller_key_set_im_context :: 
    Ptr EventControllerKey ->               -- controller : TInterface (Name {namespace = "Gtk", name = "EventControllerKey"})
    Ptr Gtk.IMContext.IMContext ->          -- im_context : TInterface (Name {namespace = "Gtk", name = "IMContext"})
    IO ()

-- | /No description available in the introspection data./
eventControllerKeySetImContext ::
    (B.CallStack.HasCallStack, MonadIO m, IsEventControllerKey a, Gtk.IMContext.IsIMContext b) =>
    a
    -> b
    -> m ()
eventControllerKeySetImContext :: a -> b -> m ()
eventControllerKeySetImContext a
controller b
imContext = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr EventControllerKey
controller' <- a -> IO (Ptr EventControllerKey)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
controller
    Ptr IMContext
imContext' <- b -> IO (Ptr IMContext)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
imContext
    Ptr EventControllerKey -> Ptr IMContext -> IO ()
gtk_event_controller_key_set_im_context Ptr EventControllerKey
controller' Ptr IMContext
imContext'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
controller
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
imContext
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data EventControllerKeySetImContextMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsEventControllerKey a, Gtk.IMContext.IsIMContext b) => O.MethodInfo EventControllerKeySetImContextMethodInfo a signature where
    overloadedMethod = eventControllerKeySetImContext

#endif