{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Clutter.Objects.BindingPool
(
BindingPool(..) ,
IsBindingPool ,
toBindingPool ,
#if defined(ENABLE_OVERLOADING)
ResolveBindingPoolMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
BindingPoolActivateMethodInfo ,
#endif
bindingPoolActivate ,
#if defined(ENABLE_OVERLOADING)
BindingPoolBlockActionMethodInfo ,
#endif
bindingPoolBlockAction ,
bindingPoolFind ,
#if defined(ENABLE_OVERLOADING)
BindingPoolFindActionMethodInfo ,
#endif
bindingPoolFindAction ,
bindingPoolGetForClass ,
#if defined(ENABLE_OVERLOADING)
BindingPoolInstallActionMethodInfo ,
#endif
bindingPoolInstallAction ,
#if defined(ENABLE_OVERLOADING)
BindingPoolInstallClosureMethodInfo ,
#endif
bindingPoolInstallClosure ,
bindingPoolNew ,
#if defined(ENABLE_OVERLOADING)
BindingPoolOverrideActionMethodInfo ,
#endif
bindingPoolOverrideAction ,
#if defined(ENABLE_OVERLOADING)
BindingPoolOverrideClosureMethodInfo ,
#endif
bindingPoolOverrideClosure ,
#if defined(ENABLE_OVERLOADING)
BindingPoolRemoveActionMethodInfo ,
#endif
bindingPoolRemoveAction ,
#if defined(ENABLE_OVERLOADING)
BindingPoolUnblockActionMethodInfo ,
#endif
bindingPoolUnblockAction ,
#if defined(ENABLE_OVERLOADING)
BindingPoolNamePropertyInfo ,
#endif
#if defined(ENABLE_OVERLOADING)
bindingPoolName ,
#endif
constructBindingPoolName ,
getBindingPoolName ,
) 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.GHashTable as B.GHT
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.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.Kind as DK
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 GHC.Records as R
import qualified GI.Clutter.Callbacks as Clutter.Callbacks
import {-# SOURCE #-} qualified GI.Clutter.Flags as Clutter.Flags
import qualified GI.GLib.Callbacks as GLib.Callbacks
import qualified GI.GObject.Objects.Object as GObject.Object
newtype BindingPool = BindingPool (SP.ManagedPtr BindingPool)
deriving (BindingPool -> BindingPool -> Bool
(BindingPool -> BindingPool -> Bool)
-> (BindingPool -> BindingPool -> Bool) -> Eq BindingPool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BindingPool -> BindingPool -> Bool
== :: BindingPool -> BindingPool -> Bool
$c/= :: BindingPool -> BindingPool -> Bool
/= :: BindingPool -> BindingPool -> Bool
Eq)
instance SP.ManagedPtrNewtype BindingPool where
toManagedPtr :: BindingPool -> ManagedPtr BindingPool
toManagedPtr (BindingPool ManagedPtr BindingPool
p) = ManagedPtr BindingPool
p
foreign import ccall "clutter_binding_pool_get_type"
c_clutter_binding_pool_get_type :: IO B.Types.GType
instance B.Types.TypedObject BindingPool where
glibType :: IO GType
glibType = IO GType
c_clutter_binding_pool_get_type
instance B.Types.GObject BindingPool
class (SP.GObject o, O.IsDescendantOf BindingPool o) => IsBindingPool o
instance (SP.GObject o, O.IsDescendantOf BindingPool o) => IsBindingPool o
instance O.HasParentTypes BindingPool
type instance O.ParentTypes BindingPool = '[GObject.Object.Object]
toBindingPool :: (MIO.MonadIO m, IsBindingPool o) => o -> m BindingPool
toBindingPool :: forall (m :: * -> *) o.
(MonadIO m, IsBindingPool o) =>
o -> m BindingPool
toBindingPool = IO BindingPool -> m BindingPool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO BindingPool -> m BindingPool)
-> (o -> IO BindingPool) -> o -> m BindingPool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr BindingPool -> BindingPool) -> o -> IO BindingPool
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr BindingPool -> BindingPool
BindingPool
instance B.GValue.IsGValue (Maybe BindingPool) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_clutter_binding_pool_get_type
gvalueSet_ :: Ptr GValue -> Maybe BindingPool -> IO ()
gvalueSet_ Ptr GValue
gv Maybe BindingPool
P.Nothing = Ptr GValue -> Ptr BindingPool -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr BindingPool
forall a. Ptr a
FP.nullPtr :: FP.Ptr BindingPool)
gvalueSet_ Ptr GValue
gv (P.Just BindingPool
obj) = BindingPool -> (Ptr BindingPool -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr BindingPool
obj (Ptr GValue -> Ptr BindingPool -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe BindingPool)
gvalueGet_ Ptr GValue
gv = do
Ptr BindingPool
ptr <- Ptr GValue -> IO (Ptr BindingPool)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr BindingPool)
if Ptr BindingPool
ptr Ptr BindingPool -> Ptr BindingPool -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr BindingPool
forall a. Ptr a
FP.nullPtr
then BindingPool -> Maybe BindingPool
forall a. a -> Maybe a
P.Just (BindingPool -> Maybe BindingPool)
-> IO BindingPool -> IO (Maybe BindingPool)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr BindingPool -> BindingPool)
-> Ptr BindingPool -> IO BindingPool
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr BindingPool -> BindingPool
BindingPool Ptr BindingPool
ptr
else Maybe BindingPool -> IO (Maybe BindingPool)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe BindingPool
forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveBindingPoolMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveBindingPoolMethod "activate" o = BindingPoolActivateMethodInfo
ResolveBindingPoolMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveBindingPoolMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveBindingPoolMethod "blockAction" o = BindingPoolBlockActionMethodInfo
ResolveBindingPoolMethod "findAction" o = BindingPoolFindActionMethodInfo
ResolveBindingPoolMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveBindingPoolMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveBindingPoolMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveBindingPoolMethod "installAction" o = BindingPoolInstallActionMethodInfo
ResolveBindingPoolMethod "installClosure" o = BindingPoolInstallClosureMethodInfo
ResolveBindingPoolMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveBindingPoolMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveBindingPoolMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveBindingPoolMethod "overrideAction" o = BindingPoolOverrideActionMethodInfo
ResolveBindingPoolMethod "overrideClosure" o = BindingPoolOverrideClosureMethodInfo
ResolveBindingPoolMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveBindingPoolMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveBindingPoolMethod "removeAction" o = BindingPoolRemoveActionMethodInfo
ResolveBindingPoolMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveBindingPoolMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveBindingPoolMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveBindingPoolMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveBindingPoolMethod "unblockAction" o = BindingPoolUnblockActionMethodInfo
ResolveBindingPoolMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveBindingPoolMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveBindingPoolMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveBindingPoolMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveBindingPoolMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveBindingPoolMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveBindingPoolMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveBindingPoolMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveBindingPoolMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveBindingPoolMethod t BindingPool, O.OverloadedMethod info BindingPool p) => OL.IsLabel t (BindingPool -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveBindingPoolMethod t BindingPool, O.OverloadedMethod info BindingPool p, R.HasField t BindingPool p) => R.HasField t BindingPool p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveBindingPoolMethod t BindingPool, O.OverloadedMethodInfo info BindingPool) => OL.IsLabel t (O.MethodProxy info BindingPool) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
getBindingPoolName :: (MonadIO m, IsBindingPool o) => o -> m (Maybe T.Text)
getBindingPoolName :: forall (m :: * -> *) o.
(MonadIO m, IsBindingPool o) =>
o -> m (Maybe Text)
getBindingPoolName o
obj = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe Text)
forall a. GObject a => a -> String -> IO (Maybe Text)
B.Properties.getObjectPropertyString o
obj String
"name"
constructBindingPoolName :: (IsBindingPool o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
constructBindingPoolName :: forall o (m :: * -> *).
(IsBindingPool o, MonadIO m) =>
Text -> m (GValueConstruct o)
constructBindingPoolName Text
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe Text -> IO (GValueConstruct o)
forall o. String -> Maybe Text -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyString String
"name" (Text -> Maybe Text
forall a. a -> Maybe a
P.Just Text
val)
#if defined(ENABLE_OVERLOADING)
data BindingPoolNamePropertyInfo
instance AttrInfo BindingPoolNamePropertyInfo where
type AttrAllowedOps BindingPoolNamePropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
type AttrBaseTypeConstraint BindingPoolNamePropertyInfo = IsBindingPool
type AttrSetTypeConstraint BindingPoolNamePropertyInfo = (~) T.Text
type AttrTransferTypeConstraint BindingPoolNamePropertyInfo = (~) T.Text
type AttrTransferType BindingPoolNamePropertyInfo = T.Text
type AttrGetType BindingPoolNamePropertyInfo = (Maybe T.Text)
type AttrLabel BindingPoolNamePropertyInfo = "name"
type AttrOrigin BindingPoolNamePropertyInfo = BindingPool
attrGet = getBindingPoolName
attrSet = undefined
attrTransfer _ v = do
return v
attrConstruct = constructBindingPoolName
attrClear = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Objects.BindingPool.name"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.5/docs/GI-Clutter-Objects-BindingPool.html#g:attr:name"
})
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList BindingPool
type instance O.AttributeList BindingPool = BindingPoolAttributeList
type BindingPoolAttributeList = ('[ '("name", BindingPoolNamePropertyInfo)] :: [(Symbol, DK.Type)])
#endif
#if defined(ENABLE_OVERLOADING)
bindingPoolName :: AttrLabelProxy "name"
bindingPoolName = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList BindingPool = BindingPoolSignalList
type BindingPoolSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)])
#endif
foreign import ccall "clutter_binding_pool_new" clutter_binding_pool_new ::
CString ->
IO (Ptr BindingPool)
bindingPoolNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m BindingPool
bindingPoolNew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> m BindingPool
bindingPoolNew Text
name = IO BindingPool -> m BindingPool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO BindingPool -> m BindingPool)
-> IO BindingPool -> m BindingPool
forall a b. (a -> b) -> a -> b
$ do
CString
name' <- Text -> IO CString
textToCString Text
name
Ptr BindingPool
result <- CString -> IO (Ptr BindingPool)
clutter_binding_pool_new CString
name'
Text -> Ptr BindingPool -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"bindingPoolNew" Ptr BindingPool
result
BindingPool
result' <- ((ManagedPtr BindingPool -> BindingPool)
-> Ptr BindingPool -> IO BindingPool
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr BindingPool -> BindingPool
BindingPool) Ptr BindingPool
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
BindingPool -> IO BindingPool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return BindingPool
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "clutter_binding_pool_activate" clutter_binding_pool_activate ::
Ptr BindingPool ->
Word32 ->
CUInt ->
Ptr GObject.Object.Object ->
IO CInt
bindingPoolActivate ::
(B.CallStack.HasCallStack, MonadIO m, IsBindingPool a, GObject.Object.IsObject b) =>
a
-> Word32
-> [Clutter.Flags.ModifierType]
-> b
-> m Bool
bindingPoolActivate :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsBindingPool a, IsObject b) =>
a -> Word32 -> [ModifierType] -> b -> m Bool
bindingPoolActivate a
pool Word32
keyVal [ModifierType]
modifiers b
gobject = IO Bool -> m Bool
forall a. IO a -> m a
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 BindingPool
pool' <- a -> IO (Ptr BindingPool)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pool
let modifiers' :: CUInt
modifiers' = [ModifierType] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [ModifierType]
modifiers
Ptr Object
gobject' <- b -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
gobject
CInt
result <- Ptr BindingPool -> Word32 -> CUInt -> Ptr Object -> IO CInt
clutter_binding_pool_activate Ptr BindingPool
pool' Word32
keyVal CUInt
modifiers' Ptr Object
gobject'
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
pool
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
gobject
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data BindingPoolActivateMethodInfo
instance (signature ~ (Word32 -> [Clutter.Flags.ModifierType] -> b -> m Bool), MonadIO m, IsBindingPool a, GObject.Object.IsObject b) => O.OverloadedMethod BindingPoolActivateMethodInfo a signature where
overloadedMethod = bindingPoolActivate
instance O.OverloadedMethodInfo BindingPoolActivateMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Objects.BindingPool.bindingPoolActivate",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.5/docs/GI-Clutter-Objects-BindingPool.html#v:bindingPoolActivate"
})
#endif
foreign import ccall "clutter_binding_pool_block_action" clutter_binding_pool_block_action ::
Ptr BindingPool ->
CString ->
IO ()
bindingPoolBlockAction ::
(B.CallStack.HasCallStack, MonadIO m, IsBindingPool a) =>
a
-> T.Text
-> m ()
bindingPoolBlockAction :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsBindingPool a) =>
a -> Text -> m ()
bindingPoolBlockAction a
pool Text
actionName = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr BindingPool
pool' <- a -> IO (Ptr BindingPool)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pool
CString
actionName' <- Text -> IO CString
textToCString Text
actionName
Ptr BindingPool -> CString -> IO ()
clutter_binding_pool_block_action Ptr BindingPool
pool' CString
actionName'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pool
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
actionName'
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data BindingPoolBlockActionMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsBindingPool a) => O.OverloadedMethod BindingPoolBlockActionMethodInfo a signature where
overloadedMethod = bindingPoolBlockAction
instance O.OverloadedMethodInfo BindingPoolBlockActionMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Objects.BindingPool.bindingPoolBlockAction",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.5/docs/GI-Clutter-Objects-BindingPool.html#v:bindingPoolBlockAction"
})
#endif
foreign import ccall "clutter_binding_pool_find_action" clutter_binding_pool_find_action ::
Ptr BindingPool ->
Word32 ->
CUInt ->
IO CString
bindingPoolFindAction ::
(B.CallStack.HasCallStack, MonadIO m, IsBindingPool a) =>
a
-> Word32
-> [Clutter.Flags.ModifierType]
-> m T.Text
bindingPoolFindAction :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsBindingPool a) =>
a -> Word32 -> [ModifierType] -> m Text
bindingPoolFindAction a
pool Word32
keyVal [ModifierType]
modifiers = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
Ptr BindingPool
pool' <- a -> IO (Ptr BindingPool)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pool
let modifiers' :: CUInt
modifiers' = [ModifierType] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [ModifierType]
modifiers
CString
result <- Ptr BindingPool -> Word32 -> CUInt -> IO CString
clutter_binding_pool_find_action Ptr BindingPool
pool' Word32
keyVal CUInt
modifiers'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"bindingPoolFindAction" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pool
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
data BindingPoolFindActionMethodInfo
instance (signature ~ (Word32 -> [Clutter.Flags.ModifierType] -> m T.Text), MonadIO m, IsBindingPool a) => O.OverloadedMethod BindingPoolFindActionMethodInfo a signature where
overloadedMethod = bindingPoolFindAction
instance O.OverloadedMethodInfo BindingPoolFindActionMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Objects.BindingPool.bindingPoolFindAction",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.5/docs/GI-Clutter-Objects-BindingPool.html#v:bindingPoolFindAction"
})
#endif
foreign import ccall "clutter_binding_pool_install_action" clutter_binding_pool_install_action ::
Ptr BindingPool ->
CString ->
Word32 ->
CUInt ->
FunPtr Clutter.Callbacks.C_BindingActionFunc ->
Ptr () ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
IO ()
bindingPoolInstallAction ::
(B.CallStack.HasCallStack, MonadIO m, IsBindingPool a) =>
a
-> T.Text
-> Word32
-> [Clutter.Flags.ModifierType]
-> Clutter.Callbacks.BindingActionFunc
-> m ()
bindingPoolInstallAction :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsBindingPool a) =>
a -> Text -> Word32 -> [ModifierType] -> BindingActionFunc -> m ()
bindingPoolInstallAction a
pool Text
actionName Word32
keyVal [ModifierType]
modifiers BindingActionFunc
callback = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr BindingPool
pool' <- a -> IO (Ptr BindingPool)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pool
CString
actionName' <- Text -> IO CString
textToCString Text
actionName
let modifiers' :: CUInt
modifiers' = [ModifierType] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [ModifierType]
modifiers
FunPtr C_BindingActionFunc
callback' <- C_BindingActionFunc -> IO (FunPtr C_BindingActionFunc)
Clutter.Callbacks.mk_BindingActionFunc (Maybe (Ptr (FunPtr C_BindingActionFunc))
-> BindingActionFunc_WithClosures -> C_BindingActionFunc
Clutter.Callbacks.wrap_BindingActionFunc Maybe (Ptr (FunPtr C_BindingActionFunc))
forall a. Maybe a
Nothing (BindingActionFunc -> BindingActionFunc_WithClosures
Clutter.Callbacks.drop_closures_BindingActionFunc BindingActionFunc
callback))
let data_ :: Ptr ()
data_ = FunPtr C_BindingActionFunc -> Ptr ()
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_BindingActionFunc
callback'
let notify :: FunPtr (Ptr a -> IO ())
notify = FunPtr (Ptr a -> IO ())
forall a. FunPtr (Ptr a -> IO ())
SP.safeFreeFunPtrPtr
Ptr BindingPool
-> CString
-> Word32
-> CUInt
-> FunPtr C_BindingActionFunc
-> Ptr ()
-> FunPtr C_DestroyNotify
-> IO ()
clutter_binding_pool_install_action Ptr BindingPool
pool' CString
actionName' Word32
keyVal CUInt
modifiers' FunPtr C_BindingActionFunc
callback' Ptr ()
data_ FunPtr C_DestroyNotify
forall a. FunPtr (Ptr a -> IO ())
notify
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pool
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
actionName'
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data BindingPoolInstallActionMethodInfo
instance (signature ~ (T.Text -> Word32 -> [Clutter.Flags.ModifierType] -> Clutter.Callbacks.BindingActionFunc -> m ()), MonadIO m, IsBindingPool a) => O.OverloadedMethod BindingPoolInstallActionMethodInfo a signature where
overloadedMethod = bindingPoolInstallAction
instance O.OverloadedMethodInfo BindingPoolInstallActionMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Objects.BindingPool.bindingPoolInstallAction",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.5/docs/GI-Clutter-Objects-BindingPool.html#v:bindingPoolInstallAction"
})
#endif
foreign import ccall "clutter_binding_pool_install_closure" clutter_binding_pool_install_closure ::
Ptr BindingPool ->
CString ->
Word32 ->
CUInt ->
Ptr (GClosure ()) ->
IO ()
bindingPoolInstallClosure ::
(B.CallStack.HasCallStack, MonadIO m, IsBindingPool a) =>
a
-> T.Text
-> Word32
-> [Clutter.Flags.ModifierType]
-> GClosure b
-> m ()
bindingPoolInstallClosure :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsBindingPool a) =>
a -> Text -> Word32 -> [ModifierType] -> GClosure b -> m ()
bindingPoolInstallClosure a
pool Text
actionName Word32
keyVal [ModifierType]
modifiers GClosure b
closure = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr BindingPool
pool' <- a -> IO (Ptr BindingPool)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pool
CString
actionName' <- Text -> IO CString
textToCString Text
actionName
let modifiers' :: CUInt
modifiers' = [ModifierType] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [ModifierType]
modifiers
Ptr (GClosure ())
closure' <- GClosure b -> IO (Ptr (GClosure ()))
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr GClosure b
closure
Ptr BindingPool
-> CString -> Word32 -> CUInt -> Ptr (GClosure ()) -> IO ()
clutter_binding_pool_install_closure Ptr BindingPool
pool' CString
actionName' Word32
keyVal CUInt
modifiers' Ptr (GClosure ())
closure'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pool
GClosure b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GClosure b
closure
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
actionName'
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data BindingPoolInstallClosureMethodInfo
instance (signature ~ (T.Text -> Word32 -> [Clutter.Flags.ModifierType] -> GClosure b -> m ()), MonadIO m, IsBindingPool a) => O.OverloadedMethod BindingPoolInstallClosureMethodInfo a signature where
overloadedMethod = bindingPoolInstallClosure
instance O.OverloadedMethodInfo BindingPoolInstallClosureMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Objects.BindingPool.bindingPoolInstallClosure",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.5/docs/GI-Clutter-Objects-BindingPool.html#v:bindingPoolInstallClosure"
})
#endif
foreign import ccall "clutter_binding_pool_override_action" clutter_binding_pool_override_action ::
Ptr BindingPool ->
Word32 ->
CUInt ->
FunPtr Clutter.Callbacks.C_BindingActionFunc ->
Ptr () ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
IO ()
bindingPoolOverrideAction ::
(B.CallStack.HasCallStack, MonadIO m, IsBindingPool a) =>
a
-> Word32
-> [Clutter.Flags.ModifierType]
-> Clutter.Callbacks.BindingActionFunc
-> m ()
bindingPoolOverrideAction :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsBindingPool a) =>
a -> Word32 -> [ModifierType] -> BindingActionFunc -> m ()
bindingPoolOverrideAction a
pool Word32
keyVal [ModifierType]
modifiers BindingActionFunc
callback = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr BindingPool
pool' <- a -> IO (Ptr BindingPool)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pool
let modifiers' :: CUInt
modifiers' = [ModifierType] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [ModifierType]
modifiers
FunPtr C_BindingActionFunc
callback' <- C_BindingActionFunc -> IO (FunPtr C_BindingActionFunc)
Clutter.Callbacks.mk_BindingActionFunc (Maybe (Ptr (FunPtr C_BindingActionFunc))
-> BindingActionFunc_WithClosures -> C_BindingActionFunc
Clutter.Callbacks.wrap_BindingActionFunc Maybe (Ptr (FunPtr C_BindingActionFunc))
forall a. Maybe a
Nothing (BindingActionFunc -> BindingActionFunc_WithClosures
Clutter.Callbacks.drop_closures_BindingActionFunc BindingActionFunc
callback))
let data_ :: Ptr ()
data_ = FunPtr C_BindingActionFunc -> Ptr ()
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_BindingActionFunc
callback'
let notify :: FunPtr (Ptr a -> IO ())
notify = FunPtr (Ptr a -> IO ())
forall a. FunPtr (Ptr a -> IO ())
SP.safeFreeFunPtrPtr
Ptr BindingPool
-> Word32
-> CUInt
-> FunPtr C_BindingActionFunc
-> Ptr ()
-> FunPtr C_DestroyNotify
-> IO ()
clutter_binding_pool_override_action Ptr BindingPool
pool' Word32
keyVal CUInt
modifiers' FunPtr C_BindingActionFunc
callback' Ptr ()
data_ FunPtr C_DestroyNotify
forall a. FunPtr (Ptr a -> IO ())
notify
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pool
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data BindingPoolOverrideActionMethodInfo
instance (signature ~ (Word32 -> [Clutter.Flags.ModifierType] -> Clutter.Callbacks.BindingActionFunc -> m ()), MonadIO m, IsBindingPool a) => O.OverloadedMethod BindingPoolOverrideActionMethodInfo a signature where
overloadedMethod = bindingPoolOverrideAction
instance O.OverloadedMethodInfo BindingPoolOverrideActionMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Objects.BindingPool.bindingPoolOverrideAction",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.5/docs/GI-Clutter-Objects-BindingPool.html#v:bindingPoolOverrideAction"
})
#endif
foreign import ccall "clutter_binding_pool_override_closure" clutter_binding_pool_override_closure ::
Ptr BindingPool ->
Word32 ->
CUInt ->
Ptr (GClosure ()) ->
IO ()
bindingPoolOverrideClosure ::
(B.CallStack.HasCallStack, MonadIO m, IsBindingPool a) =>
a
-> Word32
-> [Clutter.Flags.ModifierType]
-> GClosure b
-> m ()
bindingPoolOverrideClosure :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsBindingPool a) =>
a -> Word32 -> [ModifierType] -> GClosure b -> m ()
bindingPoolOverrideClosure a
pool Word32
keyVal [ModifierType]
modifiers GClosure b
closure = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr BindingPool
pool' <- a -> IO (Ptr BindingPool)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pool
let modifiers' :: CUInt
modifiers' = [ModifierType] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [ModifierType]
modifiers
Ptr (GClosure ())
closure' <- GClosure b -> IO (Ptr (GClosure ()))
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr GClosure b
closure
Ptr BindingPool -> Word32 -> CUInt -> Ptr (GClosure ()) -> IO ()
clutter_binding_pool_override_closure Ptr BindingPool
pool' Word32
keyVal CUInt
modifiers' Ptr (GClosure ())
closure'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pool
GClosure b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GClosure b
closure
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data BindingPoolOverrideClosureMethodInfo
instance (signature ~ (Word32 -> [Clutter.Flags.ModifierType] -> GClosure b -> m ()), MonadIO m, IsBindingPool a) => O.OverloadedMethod BindingPoolOverrideClosureMethodInfo a signature where
overloadedMethod = bindingPoolOverrideClosure
instance O.OverloadedMethodInfo BindingPoolOverrideClosureMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Objects.BindingPool.bindingPoolOverrideClosure",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.5/docs/GI-Clutter-Objects-BindingPool.html#v:bindingPoolOverrideClosure"
})
#endif
foreign import ccall "clutter_binding_pool_remove_action" clutter_binding_pool_remove_action ::
Ptr BindingPool ->
Word32 ->
CUInt ->
IO ()
bindingPoolRemoveAction ::
(B.CallStack.HasCallStack, MonadIO m, IsBindingPool a) =>
a
-> Word32
-> [Clutter.Flags.ModifierType]
-> m ()
bindingPoolRemoveAction :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsBindingPool a) =>
a -> Word32 -> [ModifierType] -> m ()
bindingPoolRemoveAction a
pool Word32
keyVal [ModifierType]
modifiers = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr BindingPool
pool' <- a -> IO (Ptr BindingPool)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pool
let modifiers' :: CUInt
modifiers' = [ModifierType] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [ModifierType]
modifiers
Ptr BindingPool -> Word32 -> CUInt -> IO ()
clutter_binding_pool_remove_action Ptr BindingPool
pool' Word32
keyVal CUInt
modifiers'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pool
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data BindingPoolRemoveActionMethodInfo
instance (signature ~ (Word32 -> [Clutter.Flags.ModifierType] -> m ()), MonadIO m, IsBindingPool a) => O.OverloadedMethod BindingPoolRemoveActionMethodInfo a signature where
overloadedMethod = bindingPoolRemoveAction
instance O.OverloadedMethodInfo BindingPoolRemoveActionMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Objects.BindingPool.bindingPoolRemoveAction",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.5/docs/GI-Clutter-Objects-BindingPool.html#v:bindingPoolRemoveAction"
})
#endif
foreign import ccall "clutter_binding_pool_unblock_action" clutter_binding_pool_unblock_action ::
Ptr BindingPool ->
CString ->
IO ()
bindingPoolUnblockAction ::
(B.CallStack.HasCallStack, MonadIO m, IsBindingPool a) =>
a
-> T.Text
-> m ()
bindingPoolUnblockAction :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsBindingPool a) =>
a -> Text -> m ()
bindingPoolUnblockAction a
pool Text
actionName = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr BindingPool
pool' <- a -> IO (Ptr BindingPool)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pool
CString
actionName' <- Text -> IO CString
textToCString Text
actionName
Ptr BindingPool -> CString -> IO ()
clutter_binding_pool_unblock_action Ptr BindingPool
pool' CString
actionName'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pool
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
actionName'
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data BindingPoolUnblockActionMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsBindingPool a) => O.OverloadedMethod BindingPoolUnblockActionMethodInfo a signature where
overloadedMethod = bindingPoolUnblockAction
instance O.OverloadedMethodInfo BindingPoolUnblockActionMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Objects.BindingPool.bindingPoolUnblockAction",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.5/docs/GI-Clutter-Objects-BindingPool.html#v:bindingPoolUnblockAction"
})
#endif
foreign import ccall "clutter_binding_pool_find" clutter_binding_pool_find ::
CString ->
IO (Ptr BindingPool)
bindingPoolFind ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m BindingPool
bindingPoolFind :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> m BindingPool
bindingPoolFind Text
name = IO BindingPool -> m BindingPool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO BindingPool -> m BindingPool)
-> IO BindingPool -> m BindingPool
forall a b. (a -> b) -> a -> b
$ do
CString
name' <- Text -> IO CString
textToCString Text
name
Ptr BindingPool
result <- CString -> IO (Ptr BindingPool)
clutter_binding_pool_find CString
name'
Text -> Ptr BindingPool -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"bindingPoolFind" Ptr BindingPool
result
BindingPool
result' <- ((ManagedPtr BindingPool -> BindingPool)
-> Ptr BindingPool -> IO BindingPool
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr BindingPool -> BindingPool
BindingPool) Ptr BindingPool
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
BindingPool -> IO BindingPool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return BindingPool
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "clutter_binding_pool_get_for_class" clutter_binding_pool_get_for_class ::
Ptr () ->
IO (Ptr BindingPool)
bindingPoolGetForClass ::
(B.CallStack.HasCallStack, MonadIO m) =>
Ptr ()
-> m BindingPool
bindingPoolGetForClass :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Ptr () -> m BindingPool
bindingPoolGetForClass Ptr ()
klass = IO BindingPool -> m BindingPool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO BindingPool -> m BindingPool)
-> IO BindingPool -> m BindingPool
forall a b. (a -> b) -> a -> b
$ do
Ptr BindingPool
result <- Ptr () -> IO (Ptr BindingPool)
clutter_binding_pool_get_for_class Ptr ()
klass
Text -> Ptr BindingPool -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"bindingPoolGetForClass" Ptr BindingPool
result
BindingPool
result' <- ((ManagedPtr BindingPool -> BindingPool)
-> Ptr BindingPool -> IO BindingPool
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr BindingPool -> BindingPool
BindingPool) Ptr BindingPool
result
BindingPool -> IO BindingPool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return BindingPool
result'
#if defined(ENABLE_OVERLOADING)
#endif