{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.GLib.Structs.HookList
(
HookList(..) ,
newZeroHookList ,
#if defined(ENABLE_OVERLOADING)
ResolveHookListMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
HookListClearMethodInfo ,
#endif
hookListClear ,
#if defined(ENABLE_OVERLOADING)
HookListInitMethodInfo ,
#endif
hookListInit ,
#if defined(ENABLE_OVERLOADING)
HookListInvokeMethodInfo ,
#endif
hookListInvoke ,
#if defined(ENABLE_OVERLOADING)
HookListInvokeCheckMethodInfo ,
#endif
hookListInvokeCheck ,
clearHookListDummy3 ,
getHookListDummy3 ,
#if defined(ENABLE_OVERLOADING)
hookList_dummy3 ,
#endif
setHookListDummy3 ,
clearHookListFinalizeHook ,
getHookListFinalizeHook ,
#if defined(ENABLE_OVERLOADING)
hookList_finalizeHook ,
#endif
setHookListFinalizeHook ,
getHookListHookSize ,
#if defined(ENABLE_OVERLOADING)
hookList_hookSize ,
#endif
setHookListHookSize ,
clearHookListHooks ,
getHookListHooks ,
#if defined(ENABLE_OVERLOADING)
hookList_hooks ,
#endif
setHookListHooks ,
getHookListIsSetup ,
#if defined(ENABLE_OVERLOADING)
hookList_isSetup ,
#endif
setHookListIsSetup ,
getHookListSeqId ,
#if defined(ENABLE_OVERLOADING)
hookList_seqId ,
#endif
setHookListSeqId ,
) 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.GLib.Callbacks as GLib.Callbacks
import {-# SOURCE #-} qualified GI.GLib.Structs.Hook as GLib.Hook
newtype HookList = HookList (SP.ManagedPtr HookList)
deriving (HookList -> HookList -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: HookList -> HookList -> Bool
$c/= :: HookList -> HookList -> Bool
== :: HookList -> HookList -> Bool
$c== :: HookList -> HookList -> Bool
Eq)
instance SP.ManagedPtrNewtype HookList where
toManagedPtr :: HookList -> ManagedPtr HookList
toManagedPtr (HookList ManagedPtr HookList
p) = ManagedPtr HookList
p
instance BoxedPtr HookList where
boxedPtrCopy :: HookList -> IO HookList
boxedPtrCopy = \HookList
p -> forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr HookList
p (forall a. (HasCallStack, CallocPtr a) => Int -> Ptr a -> IO (Ptr a)
copyBytes Int
56 forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.wrapPtr ManagedPtr HookList -> HookList
HookList)
boxedPtrFree :: HookList -> IO ()
boxedPtrFree = \HookList
x -> forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
SP.withManagedPtr HookList
x forall a. Ptr a -> IO ()
SP.freeMem
instance CallocPtr HookList where
boxedPtrCalloc :: IO (Ptr HookList)
boxedPtrCalloc = forall a. Int -> IO (Ptr a)
callocBytes Int
56
newZeroHookList :: MonadIO m => m HookList
newZeroHookList :: forall (m :: * -> *). MonadIO m => m HookList
newZeroHookList = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a. CallocPtr a => IO (Ptr a)
boxedPtrCalloc forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr HookList -> HookList
HookList
instance tag ~ 'AttrSet => Constructible HookList tag where
new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr HookList -> HookList)
-> [AttrOp HookList tag] -> m HookList
new ManagedPtr HookList -> HookList
_ [AttrOp HookList tag]
attrs = do
HookList
o <- forall (m :: * -> *). MonadIO m => m HookList
newZeroHookList
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set HookList
o [AttrOp HookList tag]
attrs
forall (m :: * -> *) a. Monad m => a -> m a
return HookList
o
getHookListSeqId :: MonadIO m => HookList -> m CULong
getHookListSeqId :: forall (m :: * -> *). MonadIO m => HookList -> m CULong
getHookListSeqId HookList
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr HookList
s forall a b. (a -> b) -> a -> b
$ \Ptr HookList
ptr -> do
CULong
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr HookList
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) :: IO CULong
forall (m :: * -> *) a. Monad m => a -> m a
return CULong
val
setHookListSeqId :: MonadIO m => HookList -> CULong -> m ()
setHookListSeqId :: forall (m :: * -> *). MonadIO m => HookList -> CULong -> m ()
setHookListSeqId HookList
s CULong
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr HookList
s forall a b. (a -> b) -> a -> b
$ \Ptr HookList
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr HookList
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (CULong
val :: CULong)
#if defined(ENABLE_OVERLOADING)
data HookListSeqIdFieldInfo
instance AttrInfo HookListSeqIdFieldInfo where
type AttrBaseTypeConstraint HookListSeqIdFieldInfo = (~) HookList
type AttrAllowedOps HookListSeqIdFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint HookListSeqIdFieldInfo = (~) CULong
type AttrTransferTypeConstraint HookListSeqIdFieldInfo = (~)CULong
type AttrTransferType HookListSeqIdFieldInfo = CULong
type AttrGetType HookListSeqIdFieldInfo = CULong
type AttrLabel HookListSeqIdFieldInfo = "seq_id"
type AttrOrigin HookListSeqIdFieldInfo = HookList
attrGet = getHookListSeqId
attrSet = setHookListSeqId
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.HookList.seqId"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-HookList.html#g:attr:seqId"
})
hookList_seqId :: AttrLabelProxy "seqId"
hookList_seqId = AttrLabelProxy
#endif
getHookListHookSize :: MonadIO m => HookList -> m Word32
getHookListHookSize :: forall (m :: * -> *). MonadIO m => HookList -> m Word32
getHookListHookSize HookList
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr HookList
s forall a b. (a -> b) -> a -> b
$ \Ptr HookList
ptr -> do
Word32
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr HookList
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) :: IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
val
setHookListHookSize :: MonadIO m => HookList -> Word32 -> m ()
setHookListHookSize :: forall (m :: * -> *). MonadIO m => HookList -> Word32 -> m ()
setHookListHookSize HookList
s Word32
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr HookList
s forall a b. (a -> b) -> a -> b
$ \Ptr HookList
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr HookList
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (Word32
val :: Word32)
#if defined(ENABLE_OVERLOADING)
data HookListHookSizeFieldInfo
instance AttrInfo HookListHookSizeFieldInfo where
type AttrBaseTypeConstraint HookListHookSizeFieldInfo = (~) HookList
type AttrAllowedOps HookListHookSizeFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint HookListHookSizeFieldInfo = (~) Word32
type AttrTransferTypeConstraint HookListHookSizeFieldInfo = (~)Word32
type AttrTransferType HookListHookSizeFieldInfo = Word32
type AttrGetType HookListHookSizeFieldInfo = Word32
type AttrLabel HookListHookSizeFieldInfo = "hook_size"
type AttrOrigin HookListHookSizeFieldInfo = HookList
attrGet = getHookListHookSize
attrSet = setHookListHookSize
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.HookList.hookSize"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-HookList.html#g:attr:hookSize"
})
hookList_hookSize :: AttrLabelProxy "hookSize"
hookList_hookSize = AttrLabelProxy
#endif
getHookListIsSetup :: MonadIO m => HookList -> m Word32
getHookListIsSetup :: forall (m :: * -> *). MonadIO m => HookList -> m Word32
getHookListIsSetup HookList
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr HookList
s forall a b. (a -> b) -> a -> b
$ \Ptr HookList
ptr -> do
Word32
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr HookList
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
12) :: IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
val
setHookListIsSetup :: MonadIO m => HookList -> Word32 -> m ()
setHookListIsSetup :: forall (m :: * -> *). MonadIO m => HookList -> Word32 -> m ()
setHookListIsSetup HookList
s Word32
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr HookList
s forall a b. (a -> b) -> a -> b
$ \Ptr HookList
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr HookList
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
12) (Word32
val :: Word32)
#if defined(ENABLE_OVERLOADING)
data HookListIsSetupFieldInfo
instance AttrInfo HookListIsSetupFieldInfo where
type AttrBaseTypeConstraint HookListIsSetupFieldInfo = (~) HookList
type AttrAllowedOps HookListIsSetupFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint HookListIsSetupFieldInfo = (~) Word32
type AttrTransferTypeConstraint HookListIsSetupFieldInfo = (~)Word32
type AttrTransferType HookListIsSetupFieldInfo = Word32
type AttrGetType HookListIsSetupFieldInfo = Word32
type AttrLabel HookListIsSetupFieldInfo = "is_setup"
type AttrOrigin HookListIsSetupFieldInfo = HookList
attrGet = getHookListIsSetup
attrSet = setHookListIsSetup
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.HookList.isSetup"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-HookList.html#g:attr:isSetup"
})
hookList_isSetup :: AttrLabelProxy "isSetup"
hookList_isSetup = AttrLabelProxy
#endif
getHookListHooks :: MonadIO m => HookList -> m (Maybe GLib.Hook.Hook)
getHookListHooks :: forall (m :: * -> *). MonadIO m => HookList -> m (Maybe Hook)
getHookListHooks HookList
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr HookList
s forall a b. (a -> b) -> a -> b
$ \Ptr HookList
ptr -> do
Ptr Hook
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr HookList
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) :: IO (Ptr GLib.Hook.Hook)
Maybe Hook
result <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull Ptr Hook
val forall a b. (a -> b) -> a -> b
$ \Ptr Hook
val' -> do
Hook
val'' <- (forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr Hook -> Hook
GLib.Hook.Hook) Ptr Hook
val'
forall (m :: * -> *) a. Monad m => a -> m a
return Hook
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Hook
result
setHookListHooks :: MonadIO m => HookList -> Ptr GLib.Hook.Hook -> m ()
setHookListHooks :: forall (m :: * -> *). MonadIO m => HookList -> Ptr Hook -> m ()
setHookListHooks HookList
s Ptr Hook
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr HookList
s forall a b. (a -> b) -> a -> b
$ \Ptr HookList
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr HookList
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (Ptr Hook
val :: Ptr GLib.Hook.Hook)
clearHookListHooks :: MonadIO m => HookList -> m ()
clearHookListHooks :: forall (m :: * -> *). MonadIO m => HookList -> m ()
clearHookListHooks HookList
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr HookList
s forall a b. (a -> b) -> a -> b
$ \Ptr HookList
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr HookList
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (forall a. Ptr a
FP.nullPtr :: Ptr GLib.Hook.Hook)
#if defined(ENABLE_OVERLOADING)
data HookListHooksFieldInfo
instance AttrInfo HookListHooksFieldInfo where
type AttrBaseTypeConstraint HookListHooksFieldInfo = (~) HookList
type AttrAllowedOps HookListHooksFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint HookListHooksFieldInfo = (~) (Ptr GLib.Hook.Hook)
type AttrTransferTypeConstraint HookListHooksFieldInfo = (~)(Ptr GLib.Hook.Hook)
type AttrTransferType HookListHooksFieldInfo = (Ptr GLib.Hook.Hook)
type AttrGetType HookListHooksFieldInfo = Maybe GLib.Hook.Hook
type AttrLabel HookListHooksFieldInfo = "hooks"
type AttrOrigin HookListHooksFieldInfo = HookList
attrGet = getHookListHooks
attrSet = setHookListHooks
attrConstruct = undefined
attrClear = clearHookListHooks
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.HookList.hooks"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-HookList.html#g:attr:hooks"
})
hookList_hooks :: AttrLabelProxy "hooks"
hookList_hooks = AttrLabelProxy
#endif
getHookListDummy3 :: MonadIO m => HookList -> m (Ptr ())
getHookListDummy3 :: forall (m :: * -> *). MonadIO m => HookList -> m (Ptr ())
getHookListDummy3 HookList
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr HookList
s forall a b. (a -> b) -> a -> b
$ \Ptr HookList
ptr -> do
Ptr ()
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr HookList
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) :: IO (Ptr ())
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ()
val
setHookListDummy3 :: MonadIO m => HookList -> Ptr () -> m ()
setHookListDummy3 :: forall (m :: * -> *). MonadIO m => HookList -> Ptr () -> m ()
setHookListDummy3 HookList
s Ptr ()
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr HookList
s forall a b. (a -> b) -> a -> b
$ \Ptr HookList
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr HookList
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) (Ptr ()
val :: Ptr ())
clearHookListDummy3 :: MonadIO m => HookList -> m ()
clearHookListDummy3 :: forall (m :: * -> *). MonadIO m => HookList -> m ()
clearHookListDummy3 HookList
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr HookList
s forall a b. (a -> b) -> a -> b
$ \Ptr HookList
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr HookList
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) (forall a. Ptr a
FP.nullPtr :: Ptr ())
#if defined(ENABLE_OVERLOADING)
data HookListDummy3FieldInfo
instance AttrInfo HookListDummy3FieldInfo where
type AttrBaseTypeConstraint HookListDummy3FieldInfo = (~) HookList
type AttrAllowedOps HookListDummy3FieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint HookListDummy3FieldInfo = (~) (Ptr ())
type AttrTransferTypeConstraint HookListDummy3FieldInfo = (~)(Ptr ())
type AttrTransferType HookListDummy3FieldInfo = (Ptr ())
type AttrGetType HookListDummy3FieldInfo = Ptr ()
type AttrLabel HookListDummy3FieldInfo = "dummy3"
type AttrOrigin HookListDummy3FieldInfo = HookList
attrGet = getHookListDummy3
attrSet = setHookListDummy3
attrConstruct = undefined
attrClear = clearHookListDummy3
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.HookList.dummy3"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-HookList.html#g:attr:dummy3"
})
hookList_dummy3 :: AttrLabelProxy "dummy3"
hookList_dummy3 = AttrLabelProxy
#endif
getHookListFinalizeHook :: MonadIO m => HookList -> m (Maybe GLib.Callbacks.HookFinalizeFunc)
getHookListFinalizeHook :: forall (m :: * -> *).
MonadIO m =>
HookList -> m (Maybe HookFinalizeFunc)
getHookListFinalizeHook HookList
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr HookList
s forall a b. (a -> b) -> a -> b
$ \Ptr HookList
ptr -> do
FunPtr C_HookFinalizeFunc
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr HookList
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) :: IO (FunPtr GLib.Callbacks.C_HookFinalizeFunc)
Maybe HookFinalizeFunc
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_HookFinalizeFunc
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_HookFinalizeFunc
val' -> do
let val'' :: HookFinalizeFunc
val'' = forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
FunPtr C_HookFinalizeFunc -> HookList -> Hook -> m ()
GLib.Callbacks.dynamic_HookFinalizeFunc FunPtr C_HookFinalizeFunc
val'
forall (m :: * -> *) a. Monad m => a -> m a
return HookFinalizeFunc
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe HookFinalizeFunc
result
setHookListFinalizeHook :: MonadIO m => HookList -> FunPtr GLib.Callbacks.C_HookFinalizeFunc -> m ()
setHookListFinalizeHook :: forall (m :: * -> *).
MonadIO m =>
HookList -> FunPtr C_HookFinalizeFunc -> m ()
setHookListFinalizeHook HookList
s FunPtr C_HookFinalizeFunc
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr HookList
s forall a b. (a -> b) -> a -> b
$ \Ptr HookList
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr HookList
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) (FunPtr C_HookFinalizeFunc
val :: FunPtr GLib.Callbacks.C_HookFinalizeFunc)
clearHookListFinalizeHook :: MonadIO m => HookList -> m ()
clearHookListFinalizeHook :: forall (m :: * -> *). MonadIO m => HookList -> m ()
clearHookListFinalizeHook HookList
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr HookList
s forall a b. (a -> b) -> a -> b
$ \Ptr HookList
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr HookList
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr GLib.Callbacks.C_HookFinalizeFunc)
#if defined(ENABLE_OVERLOADING)
data HookListFinalizeHookFieldInfo
instance AttrInfo HookListFinalizeHookFieldInfo where
type AttrBaseTypeConstraint HookListFinalizeHookFieldInfo = (~) HookList
type AttrAllowedOps HookListFinalizeHookFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint HookListFinalizeHookFieldInfo = (~) (FunPtr GLib.Callbacks.C_HookFinalizeFunc)
type AttrTransferTypeConstraint HookListFinalizeHookFieldInfo = (~)GLib.Callbacks.HookFinalizeFunc
type AttrTransferType HookListFinalizeHookFieldInfo = (FunPtr GLib.Callbacks.C_HookFinalizeFunc)
type AttrGetType HookListFinalizeHookFieldInfo = Maybe GLib.Callbacks.HookFinalizeFunc
type AttrLabel HookListFinalizeHookFieldInfo = "finalize_hook"
type AttrOrigin HookListFinalizeHookFieldInfo = HookList
attrGet = getHookListFinalizeHook
attrSet = setHookListFinalizeHook
attrConstruct = undefined
attrClear = clearHookListFinalizeHook
attrTransfer _ v = do
GLib.Callbacks.mk_HookFinalizeFunc (GLib.Callbacks.wrap_HookFinalizeFunc Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.HookList.finalizeHook"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-HookList.html#g:attr:finalizeHook"
})
hookList_finalizeHook :: AttrLabelProxy "finalizeHook"
hookList_finalizeHook = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList HookList
type instance O.AttributeList HookList = HookListAttributeList
type HookListAttributeList = ('[ '("seqId", HookListSeqIdFieldInfo), '("hookSize", HookListHookSizeFieldInfo), '("isSetup", HookListIsSetupFieldInfo), '("hooks", HookListHooksFieldInfo), '("dummy3", HookListDummy3FieldInfo), '("finalizeHook", HookListFinalizeHookFieldInfo)] :: [(Symbol, DK.Type)])
#endif
foreign import ccall "g_hook_list_clear" g_hook_list_clear ::
Ptr HookList ->
IO ()
hookListClear ::
(B.CallStack.HasCallStack, MonadIO m) =>
HookList
-> m ()
hookListClear :: forall (m :: * -> *). (HasCallStack, MonadIO m) => HookList -> m ()
hookListClear HookList
hookList = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr HookList
hookList' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr HookList
hookList
Ptr HookList -> IO ()
g_hook_list_clear Ptr HookList
hookList'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr HookList
hookList
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data HookListClearMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod HookListClearMethodInfo HookList signature where
overloadedMethod = hookListClear
instance O.OverloadedMethodInfo HookListClearMethodInfo HookList where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.HookList.hookListClear",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-HookList.html#v:hookListClear"
})
#endif
foreign import ccall "g_hook_list_init" g_hook_list_init ::
Ptr HookList ->
Word32 ->
IO ()
hookListInit ::
(B.CallStack.HasCallStack, MonadIO m) =>
HookList
-> Word32
-> m ()
hookListInit :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
HookList -> Word32 -> m ()
hookListInit HookList
hookList Word32
hookSize = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr HookList
hookList' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr HookList
hookList
Ptr HookList -> Word32 -> IO ()
g_hook_list_init Ptr HookList
hookList' Word32
hookSize
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr HookList
hookList
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data HookListInitMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m) => O.OverloadedMethod HookListInitMethodInfo HookList signature where
overloadedMethod = hookListInit
instance O.OverloadedMethodInfo HookListInitMethodInfo HookList where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.HookList.hookListInit",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-HookList.html#v:hookListInit"
})
#endif
foreign import ccall "g_hook_list_invoke" g_hook_list_invoke ::
Ptr HookList ->
CInt ->
IO ()
hookListInvoke ::
(B.CallStack.HasCallStack, MonadIO m) =>
HookList
-> Bool
-> m ()
hookListInvoke :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
HookList -> Bool -> m ()
hookListInvoke HookList
hookList Bool
mayRecurse = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr HookList
hookList' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr HookList
hookList
let mayRecurse' :: CInt
mayRecurse' = (forall a b. (Integral a, Num b) => a -> b
P.fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
P.fromEnum) Bool
mayRecurse
Ptr HookList -> CInt -> IO ()
g_hook_list_invoke Ptr HookList
hookList' CInt
mayRecurse'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr HookList
hookList
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data HookListInvokeMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m) => O.OverloadedMethod HookListInvokeMethodInfo HookList signature where
overloadedMethod = hookListInvoke
instance O.OverloadedMethodInfo HookListInvokeMethodInfo HookList where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.HookList.hookListInvoke",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-HookList.html#v:hookListInvoke"
})
#endif
foreign import ccall "g_hook_list_invoke_check" g_hook_list_invoke_check ::
Ptr HookList ->
CInt ->
IO ()
hookListInvokeCheck ::
(B.CallStack.HasCallStack, MonadIO m) =>
HookList
-> Bool
-> m ()
hookListInvokeCheck :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
HookList -> Bool -> m ()
hookListInvokeCheck HookList
hookList Bool
mayRecurse = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr HookList
hookList' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr HookList
hookList
let mayRecurse' :: CInt
mayRecurse' = (forall a b. (Integral a, Num b) => a -> b
P.fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
P.fromEnum) Bool
mayRecurse
Ptr HookList -> CInt -> IO ()
g_hook_list_invoke_check Ptr HookList
hookList' CInt
mayRecurse'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr HookList
hookList
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data HookListInvokeCheckMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m) => O.OverloadedMethod HookListInvokeCheckMethodInfo HookList signature where
overloadedMethod = hookListInvokeCheck
instance O.OverloadedMethodInfo HookListInvokeCheckMethodInfo HookList where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.HookList.hookListInvokeCheck",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-HookList.html#v:hookListInvokeCheck"
})
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveHookListMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveHookListMethod "clear" o = HookListClearMethodInfo
ResolveHookListMethod "init" o = HookListInitMethodInfo
ResolveHookListMethod "invoke" o = HookListInvokeMethodInfo
ResolveHookListMethod "invokeCheck" o = HookListInvokeCheckMethodInfo
ResolveHookListMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveHookListMethod t HookList, O.OverloadedMethod info HookList p) => OL.IsLabel t (HookList -> 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 ~ ResolveHookListMethod t HookList, O.OverloadedMethod info HookList p, R.HasField t HookList p) => R.HasField t HookList p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveHookListMethod t HookList, O.OverloadedMethodInfo info HookList) => OL.IsLabel t (O.MethodProxy info HookList) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif