{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gtk.Objects.EventControllerKey
(
EventControllerKey(..) ,
IsEventControllerKey ,
toEventControllerKey ,
noEventControllerKey ,
#if defined(ENABLE_OVERLOADING)
ResolveEventControllerKeyMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
EventControllerKeyForwardMethodInfo ,
#endif
eventControllerKeyForward ,
#if defined(ENABLE_OVERLOADING)
EventControllerKeyGetFocusOriginMethodInfo,
#endif
eventControllerKeyGetFocusOrigin ,
#if defined(ENABLE_OVERLOADING)
EventControllerKeyGetFocusTargetMethodInfo,
#endif
eventControllerKeyGetFocusTarget ,
#if defined(ENABLE_OVERLOADING)
EventControllerKeyGetGroupMethodInfo ,
#endif
eventControllerKeyGetGroup ,
#if defined(ENABLE_OVERLOADING)
EventControllerKeyGetImContextMethodInfo,
#endif
eventControllerKeyGetImContext ,
eventControllerKeyNew ,
#if defined(ENABLE_OVERLOADING)
EventControllerKeySetImContextMethodInfo,
#endif
eventControllerKeySetImContext ,
#if defined(ENABLE_OVERLOADING)
EventControllerKeyContainsFocusPropertyInfo,
#endif
#if defined(ENABLE_OVERLOADING)
eventControllerKeyContainsFocus ,
#endif
getEventControllerKeyContainsFocus ,
#if defined(ENABLE_OVERLOADING)
EventControllerKeyIsFocusPropertyInfo ,
#endif
#if defined(ENABLE_OVERLOADING)
eventControllerKeyIsFocus ,
#endif
getEventControllerKeyIsFocus ,
C_EventControllerKeyFocusInCallback ,
EventControllerKeyFocusInCallback ,
#if defined(ENABLE_OVERLOADING)
EventControllerKeyFocusInSignalInfo ,
#endif
afterEventControllerKeyFocusIn ,
genClosure_EventControllerKeyFocusIn ,
mk_EventControllerKeyFocusInCallback ,
noEventControllerKeyFocusInCallback ,
onEventControllerKeyFocusIn ,
wrap_EventControllerKeyFocusInCallback ,
C_EventControllerKeyFocusOutCallback ,
EventControllerKeyFocusOutCallback ,
#if defined(ENABLE_OVERLOADING)
EventControllerKeyFocusOutSignalInfo ,
#endif
afterEventControllerKeyFocusOut ,
genClosure_EventControllerKeyFocusOut ,
mk_EventControllerKeyFocusOutCallback ,
noEventControllerKeyFocusOutCallback ,
onEventControllerKeyFocusOut ,
wrap_EventControllerKeyFocusOutCallback ,
C_EventControllerKeyImUpdateCallback ,
EventControllerKeyImUpdateCallback ,
#if defined(ENABLE_OVERLOADING)
EventControllerKeyImUpdateSignalInfo ,
#endif
afterEventControllerKeyImUpdate ,
genClosure_EventControllerKeyImUpdate ,
mk_EventControllerKeyImUpdateCallback ,
noEventControllerKeyImUpdateCallback ,
onEventControllerKeyImUpdate ,
wrap_EventControllerKeyImUpdateCallback ,
C_EventControllerKeyKeyPressedCallback ,
EventControllerKeyKeyPressedCallback ,
#if defined(ENABLE_OVERLOADING)
EventControllerKeyKeyPressedSignalInfo ,
#endif
afterEventControllerKeyKeyPressed ,
genClosure_EventControllerKeyKeyPressed ,
mk_EventControllerKeyKeyPressedCallback ,
noEventControllerKeyKeyPressedCallback ,
onEventControllerKeyKeyPressed ,
wrap_EventControllerKeyKeyPressedCallback,
C_EventControllerKeyKeyReleasedCallback ,
EventControllerKeyKeyReleasedCallback ,
#if defined(ENABLE_OVERLOADING)
EventControllerKeyKeyReleasedSignalInfo ,
#endif
afterEventControllerKeyKeyReleased ,
genClosure_EventControllerKeyKeyReleased,
mk_EventControllerKeyKeyReleasedCallback,
noEventControllerKeyKeyReleasedCallback ,
onEventControllerKeyKeyReleased ,
wrap_EventControllerKeyKeyReleasedCallback,
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.ManagedPtr as B.ManagedPtr
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 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.Enums as Gdk.Enums
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
newtype EventControllerKey = EventControllerKey (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)
foreign import ccall "gtk_event_controller_key_get_type"
c_gtk_event_controller_key_get_type :: IO GType
instance GObject EventControllerKey where
gobjectType :: IO GType
gobjectType = IO GType
c_gtk_event_controller_key_get_type
instance B.GValue.IsGValue EventControllerKey where
toGValue :: EventControllerKey -> IO GValue
toGValue o :: 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 gv :: 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
class (GObject o, O.IsDescendantOf EventControllerKey o) => IsEventControllerKey o
instance (GObject o, O.IsDescendantOf EventControllerKey o) => IsEventControllerKey o
instance O.HasParentTypes EventControllerKey
type instance O.ParentTypes EventControllerKey = '[Gtk.EventController.EventController, GObject.Object.Object]
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, GObject o, GObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
unsafeCastTo ManagedPtr EventControllerKey -> EventControllerKey
EventControllerKey
noEventControllerKey :: Maybe EventControllerKey
noEventControllerKey :: Maybe EventControllerKey
noEventControllerKey = Maybe EventControllerKey
forall a. Maybe a
Nothing
#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 "getFocusOrigin" o = EventControllerKeyGetFocusOriginMethodInfo
ResolveEventControllerKeyMethod "getFocusTarget" o = EventControllerKeyGetFocusTargetMethodInfo
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
type EventControllerKeyFocusInCallback =
Gdk.Enums.CrossingMode
-> Gdk.Enums.NotifyType
-> IO ()
noEventControllerKeyFocusInCallback :: Maybe EventControllerKeyFocusInCallback
noEventControllerKeyFocusInCallback :: Maybe EventControllerKeyFocusInCallback
noEventControllerKeyFocusInCallback = Maybe EventControllerKeyFocusInCallback
forall a. Maybe a
Nothing
type C_EventControllerKeyFocusInCallback =
Ptr () ->
CUInt ->
CUInt ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_EventControllerKeyFocusInCallback :: C_EventControllerKeyFocusInCallback -> IO (FunPtr C_EventControllerKeyFocusInCallback)
genClosure_EventControllerKeyFocusIn :: MonadIO m => EventControllerKeyFocusInCallback -> m (GClosure C_EventControllerKeyFocusInCallback)
genClosure_EventControllerKeyFocusIn :: EventControllerKeyFocusInCallback
-> m (GClosure C_EventControllerKeyFocusInCallback)
genClosure_EventControllerKeyFocusIn cb :: EventControllerKeyFocusInCallback
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' = EventControllerKeyFocusInCallback
-> C_EventControllerKeyFocusInCallback
wrap_EventControllerKeyFocusInCallback EventControllerKeyFocusInCallback
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_EventControllerKeyFocusInCallback ::
EventControllerKeyFocusInCallback ->
C_EventControllerKeyFocusInCallback
wrap_EventControllerKeyFocusInCallback :: EventControllerKeyFocusInCallback
-> C_EventControllerKeyFocusInCallback
wrap_EventControllerKeyFocusInCallback _cb :: EventControllerKeyFocusInCallback
_cb _ mode :: CUInt
mode detail :: CUInt
detail _ = do
let mode' :: CrossingMode
mode' = (Int -> CrossingMode
forall a. Enum a => Int -> a
toEnum (Int -> CrossingMode) -> (CUInt -> Int) -> CUInt -> CrossingMode
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
mode
let detail' :: NotifyType
detail' = (Int -> NotifyType
forall a. Enum a => Int -> a
toEnum (Int -> NotifyType) -> (CUInt -> Int) -> CUInt -> NotifyType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
detail
EventControllerKeyFocusInCallback
_cb CrossingMode
mode' NotifyType
detail'
onEventControllerKeyFocusIn :: (IsEventControllerKey a, MonadIO m) => a -> EventControllerKeyFocusInCallback -> m SignalHandlerId
onEventControllerKeyFocusIn :: a -> EventControllerKeyFocusInCallback -> m SignalHandlerId
onEventControllerKeyFocusIn obj :: a
obj cb :: EventControllerKeyFocusInCallback
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' = EventControllerKeyFocusInCallback
-> C_EventControllerKeyFocusInCallback
wrap_EventControllerKeyFocusInCallback EventControllerKeyFocusInCallback
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 "focus-in" FunPtr C_EventControllerKeyFocusInCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterEventControllerKeyFocusIn :: (IsEventControllerKey a, MonadIO m) => a -> EventControllerKeyFocusInCallback -> m SignalHandlerId
afterEventControllerKeyFocusIn :: a -> EventControllerKeyFocusInCallback -> m SignalHandlerId
afterEventControllerKeyFocusIn obj :: a
obj cb :: EventControllerKeyFocusInCallback
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' = EventControllerKeyFocusInCallback
-> C_EventControllerKeyFocusInCallback
wrap_EventControllerKeyFocusInCallback EventControllerKeyFocusInCallback
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 "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
type EventControllerKeyFocusOutCallback =
Gdk.Enums.CrossingMode
-> Gdk.Enums.NotifyType
-> IO ()
noEventControllerKeyFocusOutCallback :: Maybe EventControllerKeyFocusOutCallback
noEventControllerKeyFocusOutCallback :: Maybe EventControllerKeyFocusInCallback
noEventControllerKeyFocusOutCallback = Maybe EventControllerKeyFocusInCallback
forall a. Maybe a
Nothing
type C_EventControllerKeyFocusOutCallback =
Ptr () ->
CUInt ->
CUInt ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_EventControllerKeyFocusOutCallback :: C_EventControllerKeyFocusOutCallback -> IO (FunPtr C_EventControllerKeyFocusOutCallback)
genClosure_EventControllerKeyFocusOut :: MonadIO m => EventControllerKeyFocusOutCallback -> m (GClosure C_EventControllerKeyFocusOutCallback)
genClosure_EventControllerKeyFocusOut :: EventControllerKeyFocusInCallback
-> m (GClosure C_EventControllerKeyFocusInCallback)
genClosure_EventControllerKeyFocusOut cb :: EventControllerKeyFocusInCallback
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' = EventControllerKeyFocusInCallback
-> C_EventControllerKeyFocusInCallback
wrap_EventControllerKeyFocusOutCallback EventControllerKeyFocusInCallback
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_EventControllerKeyFocusOutCallback ::
EventControllerKeyFocusOutCallback ->
C_EventControllerKeyFocusOutCallback
wrap_EventControllerKeyFocusOutCallback :: EventControllerKeyFocusInCallback
-> C_EventControllerKeyFocusInCallback
wrap_EventControllerKeyFocusOutCallback _cb :: EventControllerKeyFocusInCallback
_cb _ mode :: CUInt
mode detail :: CUInt
detail _ = do
let mode' :: CrossingMode
mode' = (Int -> CrossingMode
forall a. Enum a => Int -> a
toEnum (Int -> CrossingMode) -> (CUInt -> Int) -> CUInt -> CrossingMode
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
mode
let detail' :: NotifyType
detail' = (Int -> NotifyType
forall a. Enum a => Int -> a
toEnum (Int -> NotifyType) -> (CUInt -> Int) -> CUInt -> NotifyType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
detail
EventControllerKeyFocusInCallback
_cb CrossingMode
mode' NotifyType
detail'
onEventControllerKeyFocusOut :: (IsEventControllerKey a, MonadIO m) => a -> EventControllerKeyFocusOutCallback -> m SignalHandlerId
onEventControllerKeyFocusOut :: a -> EventControllerKeyFocusInCallback -> m SignalHandlerId
onEventControllerKeyFocusOut obj :: a
obj cb :: EventControllerKeyFocusInCallback
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' = EventControllerKeyFocusInCallback
-> C_EventControllerKeyFocusInCallback
wrap_EventControllerKeyFocusOutCallback EventControllerKeyFocusInCallback
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 "focus-out" FunPtr C_EventControllerKeyFocusInCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterEventControllerKeyFocusOut :: (IsEventControllerKey a, MonadIO m) => a -> EventControllerKeyFocusOutCallback -> m SignalHandlerId
afterEventControllerKeyFocusOut :: a -> EventControllerKeyFocusInCallback -> m SignalHandlerId
afterEventControllerKeyFocusOut obj :: a
obj cb :: EventControllerKeyFocusInCallback
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' = EventControllerKeyFocusInCallback
-> C_EventControllerKeyFocusInCallback
wrap_EventControllerKeyFocusOutCallback EventControllerKeyFocusInCallback
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 "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
type EventControllerKeyImUpdateCallback =
IO ()
noEventControllerKeyImUpdateCallback :: Maybe EventControllerKeyImUpdateCallback
noEventControllerKeyImUpdateCallback :: Maybe (IO ())
noEventControllerKeyImUpdateCallback = Maybe (IO ())
forall a. Maybe a
Nothing
type C_EventControllerKeyImUpdateCallback =
Ptr () ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_EventControllerKeyImUpdateCallback :: C_EventControllerKeyImUpdateCallback -> IO (FunPtr C_EventControllerKeyImUpdateCallback)
genClosure_EventControllerKeyImUpdate :: MonadIO m => EventControllerKeyImUpdateCallback -> m (GClosure C_EventControllerKeyImUpdateCallback)
genClosure_EventControllerKeyImUpdate :: IO () -> m (GClosure C_EventControllerKeyImUpdateCallback)
genClosure_EventControllerKeyImUpdate cb :: IO ()
cb = IO (GClosure C_EventControllerKeyImUpdateCallback)
-> m (GClosure C_EventControllerKeyImUpdateCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_EventControllerKeyImUpdateCallback)
-> m (GClosure C_EventControllerKeyImUpdateCallback))
-> IO (GClosure C_EventControllerKeyImUpdateCallback)
-> m (GClosure C_EventControllerKeyImUpdateCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_EventControllerKeyImUpdateCallback
cb' = IO () -> C_EventControllerKeyImUpdateCallback
wrap_EventControllerKeyImUpdateCallback IO ()
cb
C_EventControllerKeyImUpdateCallback
-> IO (FunPtr C_EventControllerKeyImUpdateCallback)
mk_EventControllerKeyImUpdateCallback C_EventControllerKeyImUpdateCallback
cb' IO (FunPtr C_EventControllerKeyImUpdateCallback)
-> (FunPtr C_EventControllerKeyImUpdateCallback
-> IO (GClosure C_EventControllerKeyImUpdateCallback))
-> IO (GClosure C_EventControllerKeyImUpdateCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_EventControllerKeyImUpdateCallback
-> IO (GClosure C_EventControllerKeyImUpdateCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_EventControllerKeyImUpdateCallback ::
EventControllerKeyImUpdateCallback ->
C_EventControllerKeyImUpdateCallback
wrap_EventControllerKeyImUpdateCallback :: IO () -> C_EventControllerKeyImUpdateCallback
wrap_EventControllerKeyImUpdateCallback _cb :: IO ()
_cb _ _ = do
IO ()
_cb
onEventControllerKeyImUpdate :: (IsEventControllerKey a, MonadIO m) => a -> EventControllerKeyImUpdateCallback -> m SignalHandlerId
onEventControllerKeyImUpdate :: a -> IO () -> m SignalHandlerId
onEventControllerKeyImUpdate obj :: a
obj cb :: 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_EventControllerKeyImUpdateCallback
cb' = IO () -> C_EventControllerKeyImUpdateCallback
wrap_EventControllerKeyImUpdateCallback IO ()
cb
FunPtr C_EventControllerKeyImUpdateCallback
cb'' <- C_EventControllerKeyImUpdateCallback
-> IO (FunPtr C_EventControllerKeyImUpdateCallback)
mk_EventControllerKeyImUpdateCallback C_EventControllerKeyImUpdateCallback
cb'
a
-> Text
-> FunPtr C_EventControllerKeyImUpdateCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "im-update" FunPtr C_EventControllerKeyImUpdateCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterEventControllerKeyImUpdate :: (IsEventControllerKey a, MonadIO m) => a -> EventControllerKeyImUpdateCallback -> m SignalHandlerId
afterEventControllerKeyImUpdate :: a -> IO () -> m SignalHandlerId
afterEventControllerKeyImUpdate obj :: a
obj cb :: 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_EventControllerKeyImUpdateCallback
cb' = IO () -> C_EventControllerKeyImUpdateCallback
wrap_EventControllerKeyImUpdateCallback IO ()
cb
FunPtr C_EventControllerKeyImUpdateCallback
cb'' <- C_EventControllerKeyImUpdateCallback
-> IO (FunPtr C_EventControllerKeyImUpdateCallback)
mk_EventControllerKeyImUpdateCallback C_EventControllerKeyImUpdateCallback
cb'
a
-> Text
-> FunPtr C_EventControllerKeyImUpdateCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "im-update" FunPtr C_EventControllerKeyImUpdateCallback
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
type EventControllerKeyKeyPressedCallback =
Word32
-> Word32
-> [Gdk.Flags.ModifierType]
-> IO Bool
noEventControllerKeyKeyPressedCallback :: Maybe EventControllerKeyKeyPressedCallback
noEventControllerKeyKeyPressedCallback :: Maybe EventControllerKeyKeyPressedCallback
noEventControllerKeyKeyPressedCallback = Maybe EventControllerKeyKeyPressedCallback
forall a. Maybe a
Nothing
type C_EventControllerKeyKeyPressedCallback =
Ptr () ->
Word32 ->
Word32 ->
CUInt ->
Ptr () ->
IO CInt
foreign import ccall "wrapper"
mk_EventControllerKeyKeyPressedCallback :: C_EventControllerKeyKeyPressedCallback -> IO (FunPtr C_EventControllerKeyKeyPressedCallback)
genClosure_EventControllerKeyKeyPressed :: MonadIO m => EventControllerKeyKeyPressedCallback -> m (GClosure C_EventControllerKeyKeyPressedCallback)
genClosure_EventControllerKeyKeyPressed :: EventControllerKeyKeyPressedCallback
-> m (GClosure C_EventControllerKeyKeyPressedCallback)
genClosure_EventControllerKeyKeyPressed cb :: 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_EventControllerKeyKeyPressedCallback ::
EventControllerKeyKeyPressedCallback ->
C_EventControllerKeyKeyPressedCallback
wrap_EventControllerKeyKeyPressedCallback :: EventControllerKeyKeyPressedCallback
-> C_EventControllerKeyKeyPressedCallback
wrap_EventControllerKeyKeyPressedCallback _cb :: EventControllerKeyKeyPressedCallback
_cb _ keyval :: Word32
keyval keycode :: Word32
keycode state :: CUInt
state _ = 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'
onEventControllerKeyKeyPressed :: (IsEventControllerKey a, MonadIO m) => a -> EventControllerKeyKeyPressedCallback -> m SignalHandlerId
onEventControllerKeyKeyPressed :: a -> EventControllerKeyKeyPressedCallback -> m SignalHandlerId
onEventControllerKeyKeyPressed obj :: a
obj cb :: 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 "key-pressed" FunPtr C_EventControllerKeyKeyPressedCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterEventControllerKeyKeyPressed :: (IsEventControllerKey a, MonadIO m) => a -> EventControllerKeyKeyPressedCallback -> m SignalHandlerId
afterEventControllerKeyKeyPressed :: a -> EventControllerKeyKeyPressedCallback -> m SignalHandlerId
afterEventControllerKeyKeyPressed obj :: a
obj cb :: 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 "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
type EventControllerKeyKeyReleasedCallback =
Word32
-> Word32
-> [Gdk.Flags.ModifierType]
-> IO ()
noEventControllerKeyKeyReleasedCallback :: Maybe EventControllerKeyKeyReleasedCallback
noEventControllerKeyKeyReleasedCallback :: Maybe EventControllerKeyKeyReleasedCallback
noEventControllerKeyKeyReleasedCallback = Maybe EventControllerKeyKeyReleasedCallback
forall a. Maybe a
Nothing
type C_EventControllerKeyKeyReleasedCallback =
Ptr () ->
Word32 ->
Word32 ->
CUInt ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_EventControllerKeyKeyReleasedCallback :: C_EventControllerKeyKeyReleasedCallback -> IO (FunPtr C_EventControllerKeyKeyReleasedCallback)
genClosure_EventControllerKeyKeyReleased :: MonadIO m => EventControllerKeyKeyReleasedCallback -> m (GClosure C_EventControllerKeyKeyReleasedCallback)
genClosure_EventControllerKeyKeyReleased :: EventControllerKeyKeyReleasedCallback
-> m (GClosure C_EventControllerKeyKeyReleasedCallback)
genClosure_EventControllerKeyKeyReleased cb :: 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_EventControllerKeyKeyReleasedCallback ::
EventControllerKeyKeyReleasedCallback ->
C_EventControllerKeyKeyReleasedCallback
wrap_EventControllerKeyKeyReleasedCallback :: EventControllerKeyKeyReleasedCallback
-> C_EventControllerKeyKeyReleasedCallback
wrap_EventControllerKeyKeyReleasedCallback _cb :: EventControllerKeyKeyReleasedCallback
_cb _ keyval :: Word32
keyval keycode :: Word32
keycode state :: CUInt
state _ = 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'
onEventControllerKeyKeyReleased :: (IsEventControllerKey a, MonadIO m) => a -> EventControllerKeyKeyReleasedCallback -> m SignalHandlerId
onEventControllerKeyKeyReleased :: a -> EventControllerKeyKeyReleasedCallback -> m SignalHandlerId
onEventControllerKeyKeyReleased obj :: a
obj cb :: 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 "key-released" FunPtr C_EventControllerKeyKeyReleasedCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterEventControllerKeyKeyReleased :: (IsEventControllerKey a, MonadIO m) => a -> EventControllerKeyKeyReleasedCallback -> m SignalHandlerId
afterEventControllerKeyKeyReleased :: a -> EventControllerKeyKeyReleasedCallback -> m SignalHandlerId
afterEventControllerKeyKeyReleased obj :: a
obj cb :: 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 "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
type EventControllerKeyModifiersCallback =
[Gdk.Flags.ModifierType]
-> IO Bool
noEventControllerKeyModifiersCallback :: Maybe EventControllerKeyModifiersCallback
noEventControllerKeyModifiersCallback :: Maybe EventControllerKeyModifiersCallback
noEventControllerKeyModifiersCallback = Maybe EventControllerKeyModifiersCallback
forall a. Maybe a
Nothing
type C_EventControllerKeyModifiersCallback =
Ptr () ->
CUInt ->
Ptr () ->
IO CInt
foreign import ccall "wrapper"
mk_EventControllerKeyModifiersCallback :: C_EventControllerKeyModifiersCallback -> IO (FunPtr C_EventControllerKeyModifiersCallback)
genClosure_EventControllerKeyModifiers :: MonadIO m => EventControllerKeyModifiersCallback -> m (GClosure C_EventControllerKeyModifiersCallback)
genClosure_EventControllerKeyModifiers :: EventControllerKeyModifiersCallback
-> m (GClosure C_EventControllerKeyModifiersCallback)
genClosure_EventControllerKeyModifiers cb :: 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_EventControllerKeyModifiersCallback ::
EventControllerKeyModifiersCallback ->
C_EventControllerKeyModifiersCallback
wrap_EventControllerKeyModifiersCallback :: EventControllerKeyModifiersCallback
-> C_EventControllerKeyModifiersCallback
wrap_EventControllerKeyModifiersCallback _cb :: EventControllerKeyModifiersCallback
_cb _ keyval :: CUInt
keyval _ = do
let keyval' :: [ModifierType]
keyval' = CUInt -> [ModifierType]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
keyval
Bool
result <- EventControllerKeyModifiersCallback
_cb [ModifierType]
keyval'
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'
onEventControllerKeyModifiers :: (IsEventControllerKey a, MonadIO m) => a -> EventControllerKeyModifiersCallback -> m SignalHandlerId
onEventControllerKeyModifiers :: a -> EventControllerKeyModifiersCallback -> m SignalHandlerId
onEventControllerKeyModifiers obj :: a
obj cb :: 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 "modifiers" FunPtr C_EventControllerKeyModifiersCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterEventControllerKeyModifiers :: (IsEventControllerKey a, MonadIO m) => a -> EventControllerKeyModifiersCallback -> m SignalHandlerId
afterEventControllerKeyModifiers :: a -> EventControllerKeyModifiersCallback -> m SignalHandlerId
afterEventControllerKeyModifiers obj :: a
obj cb :: 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 "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
getEventControllerKeyContainsFocus :: (MonadIO m, IsEventControllerKey o) => o -> m Bool
getEventControllerKeyContainsFocus :: o -> m Bool
getEventControllerKeyContainsFocus obj :: o
obj = 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
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj "contains-focus"
#if defined(ENABLE_OVERLOADING)
data EventControllerKeyContainsFocusPropertyInfo
instance AttrInfo EventControllerKeyContainsFocusPropertyInfo where
type AttrAllowedOps EventControllerKeyContainsFocusPropertyInfo = '[ 'AttrGet]
type AttrBaseTypeConstraint EventControllerKeyContainsFocusPropertyInfo = IsEventControllerKey
type AttrSetTypeConstraint EventControllerKeyContainsFocusPropertyInfo = (~) ()
type AttrTransferTypeConstraint EventControllerKeyContainsFocusPropertyInfo = (~) ()
type AttrTransferType EventControllerKeyContainsFocusPropertyInfo = ()
type AttrGetType EventControllerKeyContainsFocusPropertyInfo = Bool
type AttrLabel EventControllerKeyContainsFocusPropertyInfo = "contains-focus"
type AttrOrigin EventControllerKeyContainsFocusPropertyInfo = EventControllerKey
attrGet = getEventControllerKeyContainsFocus
attrSet = undefined
attrTransfer _ = undefined
attrConstruct = undefined
attrClear = undefined
#endif
getEventControllerKeyIsFocus :: (MonadIO m, IsEventControllerKey o) => o -> m Bool
getEventControllerKeyIsFocus :: o -> m Bool
getEventControllerKeyIsFocus obj :: o
obj = 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
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj "is-focus"
#if defined(ENABLE_OVERLOADING)
data EventControllerKeyIsFocusPropertyInfo
instance AttrInfo EventControllerKeyIsFocusPropertyInfo where
type AttrAllowedOps EventControllerKeyIsFocusPropertyInfo = '[ 'AttrGet]
type AttrBaseTypeConstraint EventControllerKeyIsFocusPropertyInfo = IsEventControllerKey
type AttrSetTypeConstraint EventControllerKeyIsFocusPropertyInfo = (~) ()
type AttrTransferTypeConstraint EventControllerKeyIsFocusPropertyInfo = (~) ()
type AttrTransferType EventControllerKeyIsFocusPropertyInfo = ()
type AttrGetType EventControllerKeyIsFocusPropertyInfo = Bool
type AttrLabel EventControllerKeyIsFocusPropertyInfo = "is-focus"
type AttrOrigin EventControllerKeyIsFocusPropertyInfo = EventControllerKey
attrGet = getEventControllerKeyIsFocus
attrSet = undefined
attrTransfer _ = undefined
attrConstruct = undefined
attrClear = undefined
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList EventControllerKey
type instance O.AttributeList EventControllerKey = EventControllerKeyAttributeList
type EventControllerKeyAttributeList = ('[ '("containsFocus", EventControllerKeyContainsFocusPropertyInfo), '("isFocus", EventControllerKeyIsFocusPropertyInfo), '("propagationPhase", Gtk.EventController.EventControllerPropagationPhasePropertyInfo), '("widget", Gtk.EventController.EventControllerWidgetPropertyInfo)] :: [(Symbol, *)])
#endif
#if defined(ENABLE_OVERLOADING)
eventControllerKeyContainsFocus :: AttrLabelProxy "containsFocus"
eventControllerKeyContainsFocus = AttrLabelProxy
eventControllerKeyIsFocus :: AttrLabelProxy "isFocus"
eventControllerKeyIsFocus = AttrLabelProxy
#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
foreign import ccall "gtk_event_controller_key_new" gtk_event_controller_key_new ::
IO (Ptr EventControllerKey)
eventControllerKeyNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
m EventControllerKey
eventControllerKeyNew :: m EventControllerKey
eventControllerKeyNew = 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 EventControllerKey
result <- IO (Ptr EventControllerKey)
gtk_event_controller_key_new
Text -> Ptr EventControllerKey -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "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
EventControllerKey -> IO EventControllerKey
forall (m :: * -> *) a. Monad m => a -> m a
return EventControllerKey
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gtk_event_controller_key_forward" gtk_event_controller_key_forward ::
Ptr EventControllerKey ->
Ptr Gtk.Widget.Widget ->
IO CInt
eventControllerKeyForward ::
(B.CallStack.HasCallStack, MonadIO m, IsEventControllerKey a, Gtk.Widget.IsWidget b) =>
a
-> b
-> m Bool
eventControllerKeyForward :: a -> b -> m Bool
eventControllerKeyForward controller :: a
controller widget :: 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
/= 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
foreign import ccall "gtk_event_controller_key_get_focus_origin" gtk_event_controller_key_get_focus_origin ::
Ptr EventControllerKey ->
IO (Ptr Gtk.Widget.Widget)
eventControllerKeyGetFocusOrigin ::
(B.CallStack.HasCallStack, MonadIO m, IsEventControllerKey a) =>
a
-> m Gtk.Widget.Widget
eventControllerKeyGetFocusOrigin :: a -> m Widget
eventControllerKeyGetFocusOrigin controller :: a
controller = IO Widget -> m Widget
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Widget -> m Widget) -> IO Widget -> m Widget
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
result <- Ptr EventControllerKey -> IO (Ptr Widget)
gtk_event_controller_key_get_focus_origin Ptr EventControllerKey
controller'
Text -> Ptr Widget -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "eventControllerKeyGetFocusOrigin" Ptr Widget
result
Widget
result' <- ((ManagedPtr Widget -> Widget) -> Ptr Widget -> IO Widget
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Widget -> Widget
Gtk.Widget.Widget) Ptr Widget
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
controller
Widget -> IO Widget
forall (m :: * -> *) a. Monad m => a -> m a
return Widget
result'
#if defined(ENABLE_OVERLOADING)
data EventControllerKeyGetFocusOriginMethodInfo
instance (signature ~ (m Gtk.Widget.Widget), MonadIO m, IsEventControllerKey a) => O.MethodInfo EventControllerKeyGetFocusOriginMethodInfo a signature where
overloadedMethod = eventControllerKeyGetFocusOrigin
#endif
foreign import ccall "gtk_event_controller_key_get_focus_target" gtk_event_controller_key_get_focus_target ::
Ptr EventControllerKey ->
IO (Ptr Gtk.Widget.Widget)
eventControllerKeyGetFocusTarget ::
(B.CallStack.HasCallStack, MonadIO m, IsEventControllerKey a) =>
a
-> m Gtk.Widget.Widget
eventControllerKeyGetFocusTarget :: a -> m Widget
eventControllerKeyGetFocusTarget controller :: a
controller = IO Widget -> m Widget
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Widget -> m Widget) -> IO Widget -> m Widget
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
result <- Ptr EventControllerKey -> IO (Ptr Widget)
gtk_event_controller_key_get_focus_target Ptr EventControllerKey
controller'
Text -> Ptr Widget -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "eventControllerKeyGetFocusTarget" Ptr Widget
result
Widget
result' <- ((ManagedPtr Widget -> Widget) -> Ptr Widget -> IO Widget
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Widget -> Widget
Gtk.Widget.Widget) Ptr Widget
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
controller
Widget -> IO Widget
forall (m :: * -> *) a. Monad m => a -> m a
return Widget
result'
#if defined(ENABLE_OVERLOADING)
data EventControllerKeyGetFocusTargetMethodInfo
instance (signature ~ (m Gtk.Widget.Widget), MonadIO m, IsEventControllerKey a) => O.MethodInfo EventControllerKeyGetFocusTargetMethodInfo a signature where
overloadedMethod = eventControllerKeyGetFocusTarget
#endif
foreign import ccall "gtk_event_controller_key_get_group" gtk_event_controller_key_get_group ::
Ptr EventControllerKey ->
IO Word32
eventControllerKeyGetGroup ::
(B.CallStack.HasCallStack, MonadIO m, IsEventControllerKey a) =>
a
-> m Word32
eventControllerKeyGetGroup :: a -> m Word32
eventControllerKeyGetGroup controller :: 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
foreign import ccall "gtk_event_controller_key_get_im_context" gtk_event_controller_key_get_im_context ::
Ptr EventControllerKey ->
IO (Ptr Gtk.IMContext.IMContext)
eventControllerKeyGetImContext ::
(B.CallStack.HasCallStack, MonadIO m, IsEventControllerKey a) =>
a
-> m Gtk.IMContext.IMContext
eventControllerKeyGetImContext :: a -> m IMContext
eventControllerKeyGetImContext controller :: 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 "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
foreign import ccall "gtk_event_controller_key_set_im_context" gtk_event_controller_key_set_im_context ::
Ptr EventControllerKey ->
Ptr Gtk.IMContext.IMContext ->
IO ()
eventControllerKeySetImContext ::
(B.CallStack.HasCallStack, MonadIO m, IsEventControllerKey a, Gtk.IMContext.IsIMContext b) =>
a
-> b
-> m ()
eventControllerKeySetImContext :: a -> b -> m ()
eventControllerKeySetImContext controller :: a
controller imContext :: 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