{-# 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 ,
#if defined(ENABLE_OVERLOADING)
HookListMarshalMethodInfo ,
#endif
hookListMarshal ,
#if defined(ENABLE_OVERLOADING)
HookListMarshalCheckMethodInfo ,
#endif
hookListMarshalCheck ,
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 Data.Word as DW
import qualified Data.Int as DI
import qualified Data.Bits as DB
import qualified System.Posix.Types as SPT
import qualified Foreign.C.Types as FCT
#if MIN_VERSION_base(4,18,0)
import qualified GI.GLib.Callbacks as GLib.Callbacks
import {-# SOURCE #-} qualified GI.GLib.Structs.Hook as GLib.Hook
#else
import qualified GI.GLib.Callbacks as GLib.Callbacks
import {-# SOURCE #-} qualified GI.GLib.Structs.Hook as GLib.Hook
#endif
newtype HookList = HookList (SP.ManagedPtr HookList)
deriving (HookList -> HookList -> Bool
(HookList -> HookList -> Bool)
-> (HookList -> HookList -> Bool) -> Eq HookList
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: HookList -> HookList -> Bool
== :: HookList -> HookList -> Bool
$c/= :: HookList -> HookList -> Bool
/= :: 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 -> HookList -> (Ptr HookList -> IO HookList) -> IO HookList
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr HookList
p (Int -> Ptr HookList -> IO (Ptr HookList)
forall a. (HasCallStack, CallocPtr a) => Int -> Ptr a -> IO (Ptr a)
copyBytes Int
56 (Ptr HookList -> IO (Ptr HookList))
-> (Ptr HookList -> IO HookList) -> Ptr HookList -> IO HookList
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (ManagedPtr HookList -> HookList) -> Ptr HookList -> IO HookList
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 -> HookList -> (Ptr HookList -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
SP.withManagedPtr HookList
x Ptr HookList -> IO ()
forall a. Ptr a -> IO ()
SP.freeMem
instance CallocPtr HookList where
boxedPtrCalloc :: IO (Ptr HookList)
boxedPtrCalloc = Int -> IO (Ptr HookList)
forall a. Int -> IO (Ptr a)
callocBytes Int
56
newZeroHookList :: MonadIO m => m HookList
newZeroHookList :: forall (m :: * -> *). MonadIO m => m HookList
newZeroHookList = IO HookList -> m HookList
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO HookList -> m HookList) -> IO HookList -> m HookList
forall a b. (a -> b) -> a -> b
$ IO (Ptr HookList)
forall a. CallocPtr a => IO (Ptr a)
boxedPtrCalloc IO (Ptr HookList) -> (Ptr HookList -> IO HookList) -> IO HookList
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr HookList -> HookList) -> Ptr HookList -> IO HookList
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
o <- m HookList
forall (m :: * -> *). MonadIO m => m HookList
newZeroHookList
GI.Attributes.set o attrs
return o
getHookListSeqId :: MonadIO m => HookList -> m FCT.CULong
getHookListSeqId :: forall (m :: * -> *). MonadIO m => HookList -> m CULong
getHookListSeqId HookList
s = IO CULong -> m CULong
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CULong -> m CULong) -> IO CULong -> m CULong
forall a b. (a -> b) -> a -> b
$ HookList -> (Ptr HookList -> IO CULong) -> IO CULong
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr HookList
s ((Ptr HookList -> IO CULong) -> IO CULong)
-> (Ptr HookList -> IO CULong) -> IO CULong
forall a b. (a -> b) -> a -> b
$ \Ptr HookList
ptr -> do
val <- Ptr CULong -> IO CULong
forall a. Storable a => Ptr a -> IO a
peek (Ptr HookList
ptr Ptr HookList -> Int -> Ptr CULong
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) :: IO FCT.CULong
return val
setHookListSeqId :: MonadIO m => HookList -> FCT.CULong -> m ()
setHookListSeqId :: forall (m :: * -> *). MonadIO m => HookList -> CULong -> m ()
setHookListSeqId HookList
s CULong
val = 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
$ HookList -> (Ptr HookList -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr HookList
s ((Ptr HookList -> IO ()) -> IO ())
-> (Ptr HookList -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr HookList
ptr -> do
Ptr CULong -> CULong -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr HookList
ptr Ptr HookList -> Int -> Ptr CULong
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (CULong
val :: FCT.CULong)
#if defined(ENABLE_OVERLOADING)
data HookListSeqIdFieldInfo
instance AttrInfo HookListSeqIdFieldInfo where
type AttrBaseTypeConstraint HookListSeqIdFieldInfo = (~) HookList
type AttrAllowedOps HookListSeqIdFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint HookListSeqIdFieldInfo = (~) FCT.CULong
type AttrTransferTypeConstraint HookListSeqIdFieldInfo = (~)FCT.CULong
type AttrTransferType HookListSeqIdFieldInfo = FCT.CULong
type AttrGetType HookListSeqIdFieldInfo = FCT.CULong
type AttrLabel HookListSeqIdFieldInfo = "seq_id"
type AttrOrigin HookListSeqIdFieldInfo = HookList
attrGet :: forall o.
AttrBaseTypeConstraint HookListSeqIdFieldInfo o =>
o -> IO (AttrGetType HookListSeqIdFieldInfo)
attrGet = o -> IO (AttrGetType HookListSeqIdFieldInfo)
HookList -> IO CULong
forall (m :: * -> *). MonadIO m => HookList -> m CULong
getHookListSeqId
attrSet :: forall o b.
(AttrBaseTypeConstraint HookListSeqIdFieldInfo o,
AttrSetTypeConstraint HookListSeqIdFieldInfo b) =>
o -> b -> IO ()
attrSet = o -> b -> IO ()
HookList -> CULong -> IO ()
forall (m :: * -> *). MonadIO m => HookList -> CULong -> m ()
setHookListSeqId
attrConstruct :: forall o b.
(AttrBaseTypeConstraint HookListSeqIdFieldInfo o,
AttrSetTypeConstraint HookListSeqIdFieldInfo b) =>
b -> IO (GValueConstruct o)
attrConstruct = b -> IO (GValueConstruct o)
forall a. HasCallStack => a
undefined
attrClear :: forall o.
AttrBaseTypeConstraint HookListSeqIdFieldInfo o =>
o -> IO ()
attrClear = o -> IO ()
forall a. HasCallStack => a
undefined
attrTransfer :: forall o b.
(AttrBaseTypeConstraint HookListSeqIdFieldInfo o,
AttrTransferTypeConstraint HookListSeqIdFieldInfo b) =>
Proxy o -> b -> IO (AttrTransferType HookListSeqIdFieldInfo)
attrTransfer Proxy o
_ b
v = do
b -> IO b
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return b
v
dbgAttrInfo :: Maybe ResolvedSymbolInfo
dbgAttrInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.HookList.seqId"
, resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-HookList.html#g:attr:seqId"
})
hookList_seqId :: AttrLabelProxy "seqId"
hookList_seqId :: AttrLabelProxy "seqId"
hookList_seqId = AttrLabelProxy "seqId"
forall (a :: Symbol). AttrLabelProxy a
AttrLabelProxy
#endif
getHookListHookSize :: MonadIO m => HookList -> m Word32
getHookListHookSize :: forall (m :: * -> *). MonadIO m => HookList -> m Word32
getHookListHookSize HookList
s = IO Word32 -> m Word32
forall a. IO a -> m a
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
$ HookList -> (Ptr HookList -> IO Word32) -> IO Word32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr HookList
s ((Ptr HookList -> IO Word32) -> IO Word32)
-> (Ptr HookList -> IO Word32) -> IO Word32
forall a b. (a -> b) -> a -> b
$ \Ptr HookList
ptr -> do
val <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek (Ptr HookList
ptr Ptr HookList -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) :: IO Word32
let bitfield = Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
DB.shiftR (Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
DB.shiftL Word32
val (Word32 -> Int
forall b. FiniteBits b => b -> Int
DB.finiteBitSize Word32
val Int -> Int -> Int
forall a. Num a => a -> a -> a
P.- Int
16)) (Word32 -> Int
forall b. FiniteBits b => b -> Int
DB.finiteBitSize Word32
val Int -> Int -> Int
forall a. Num a => a -> a -> a
P.- Int
16)
return bitfield
setHookListHookSize :: MonadIO m => HookList -> Word32 -> m ()
setHookListHookSize :: forall (m :: * -> *). MonadIO m => HookList -> Word32 -> m ()
setHookListHookSize HookList
s Word32
val = 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
$ HookList -> (Ptr HookList -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr HookList
s ((Ptr HookList -> IO ()) -> IO ())
-> (Ptr HookList -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr HookList
ptr -> do
old <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek (Ptr HookList
ptr Ptr HookList -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) :: IO (Word32)
let mask = Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
DB.shiftL (Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
DB.shiftL Word32
1 Int
16 Word32 -> Word32 -> Word32
forall a. Num a => a -> a -> a
P.- Word32
1) Int
0 :: Word32
poke (ptr `plusPtr` 8) ((old DB..&. DB.complement mask) DB..|. (DB.shiftL (val :: Word32) 0 DB..&. mask))
#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 :: forall o.
AttrBaseTypeConstraint HookListHookSizeFieldInfo o =>
o -> IO (AttrGetType HookListHookSizeFieldInfo)
attrGet = o -> IO (AttrGetType HookListHookSizeFieldInfo)
HookList -> IO Word32
forall (m :: * -> *). MonadIO m => HookList -> m Word32
getHookListHookSize
attrSet :: forall o b.
(AttrBaseTypeConstraint HookListHookSizeFieldInfo o,
AttrSetTypeConstraint HookListHookSizeFieldInfo b) =>
o -> b -> IO ()
attrSet = o -> b -> IO ()
HookList -> Word32 -> IO ()
forall (m :: * -> *). MonadIO m => HookList -> Word32 -> m ()
setHookListHookSize
attrConstruct :: forall o b.
(AttrBaseTypeConstraint HookListHookSizeFieldInfo o,
AttrSetTypeConstraint HookListHookSizeFieldInfo b) =>
b -> IO (GValueConstruct o)
attrConstruct = b -> IO (GValueConstruct o)
forall a. HasCallStack => a
undefined
attrClear :: forall o.
AttrBaseTypeConstraint HookListHookSizeFieldInfo o =>
o -> IO ()
attrClear = o -> IO ()
forall a. HasCallStack => a
undefined
attrTransfer :: forall o b.
(AttrBaseTypeConstraint HookListHookSizeFieldInfo o,
AttrTransferTypeConstraint HookListHookSizeFieldInfo b) =>
Proxy o -> b -> IO (AttrTransferType HookListHookSizeFieldInfo)
attrTransfer Proxy o
_ b
v = do
b -> IO b
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return b
v
dbgAttrInfo :: Maybe ResolvedSymbolInfo
dbgAttrInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.HookList.hookSize"
, resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-HookList.html#g:attr:hookSize"
})
hookList_hookSize :: AttrLabelProxy "hookSize"
hookList_hookSize :: AttrLabelProxy "hookSize"
hookList_hookSize = AttrLabelProxy "hookSize"
forall (a :: Symbol). AttrLabelProxy a
AttrLabelProxy
#endif
getHookListIsSetup :: MonadIO m => HookList -> m Word32
getHookListIsSetup :: forall (m :: * -> *). MonadIO m => HookList -> m Word32
getHookListIsSetup HookList
s = IO Word32 -> m Word32
forall a. IO a -> m a
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
$ HookList -> (Ptr HookList -> IO Word32) -> IO Word32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr HookList
s ((Ptr HookList -> IO Word32) -> IO Word32)
-> (Ptr HookList -> IO Word32) -> IO Word32
forall a b. (a -> b) -> a -> b
$ \Ptr HookList
ptr -> do
val <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek (Ptr HookList
ptr Ptr HookList -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) :: IO Word32
let bitfield = Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
DB.shiftR (Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
DB.shiftL Word32
val (Word32 -> Int
forall b. FiniteBits b => b -> Int
DB.finiteBitSize Word32
val Int -> Int -> Int
forall a. Num a => a -> a -> a
P.- Int
17)) (Word32 -> Int
forall b. FiniteBits b => b -> Int
DB.finiteBitSize Word32
val Int -> Int -> Int
forall a. Num a => a -> a -> a
P.- Int
1)
return bitfield
setHookListIsSetup :: MonadIO m => HookList -> Word32 -> m ()
setHookListIsSetup :: forall (m :: * -> *). MonadIO m => HookList -> Word32 -> m ()
setHookListIsSetup HookList
s Word32
val = 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
$ HookList -> (Ptr HookList -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr HookList
s ((Ptr HookList -> IO ()) -> IO ())
-> (Ptr HookList -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr HookList
ptr -> do
old <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek (Ptr HookList
ptr Ptr HookList -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) :: IO (Word32)
let mask = Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
DB.shiftL (Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
DB.shiftL Word32
1 Int
1 Word32 -> Word32 -> Word32
forall a. Num a => a -> a -> a
P.- Word32
1) Int
16 :: Word32
poke (ptr `plusPtr` 8) ((old DB..&. DB.complement mask) DB..|. (DB.shiftL (val :: Word32) 16 DB..&. mask))
#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 :: forall o.
AttrBaseTypeConstraint HookListIsSetupFieldInfo o =>
o -> IO (AttrGetType HookListIsSetupFieldInfo)
attrGet = o -> IO (AttrGetType HookListIsSetupFieldInfo)
HookList -> IO Word32
forall (m :: * -> *). MonadIO m => HookList -> m Word32
getHookListIsSetup
attrSet :: forall o b.
(AttrBaseTypeConstraint HookListIsSetupFieldInfo o,
AttrSetTypeConstraint HookListIsSetupFieldInfo b) =>
o -> b -> IO ()
attrSet = o -> b -> IO ()
HookList -> Word32 -> IO ()
forall (m :: * -> *). MonadIO m => HookList -> Word32 -> m ()
setHookListIsSetup
attrConstruct :: forall o b.
(AttrBaseTypeConstraint HookListIsSetupFieldInfo o,
AttrSetTypeConstraint HookListIsSetupFieldInfo b) =>
b -> IO (GValueConstruct o)
attrConstruct = b -> IO (GValueConstruct o)
forall a. HasCallStack => a
undefined
attrClear :: forall o.
AttrBaseTypeConstraint HookListIsSetupFieldInfo o =>
o -> IO ()
attrClear = o -> IO ()
forall a. HasCallStack => a
undefined
attrTransfer :: forall o b.
(AttrBaseTypeConstraint HookListIsSetupFieldInfo o,
AttrTransferTypeConstraint HookListIsSetupFieldInfo b) =>
Proxy o -> b -> IO (AttrTransferType HookListIsSetupFieldInfo)
attrTransfer Proxy o
_ b
v = do
b -> IO b
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return b
v
dbgAttrInfo :: Maybe ResolvedSymbolInfo
dbgAttrInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.HookList.isSetup"
, resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-HookList.html#g:attr:isSetup"
})
hookList_isSetup :: AttrLabelProxy "isSetup"
hookList_isSetup :: AttrLabelProxy "isSetup"
hookList_isSetup = AttrLabelProxy "isSetup"
forall (a :: Symbol). AttrLabelProxy a
AttrLabelProxy
#endif
getHookListHooks :: MonadIO m => HookList -> m (Maybe GLib.Hook.Hook)
getHookListHooks :: forall (m :: * -> *). MonadIO m => HookList -> m (Maybe Hook)
getHookListHooks HookList
s = IO (Maybe Hook) -> m (Maybe Hook)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Hook) -> m (Maybe Hook))
-> IO (Maybe Hook) -> m (Maybe Hook)
forall a b. (a -> b) -> a -> b
$ HookList -> (Ptr HookList -> IO (Maybe Hook)) -> IO (Maybe Hook)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr HookList
s ((Ptr HookList -> IO (Maybe Hook)) -> IO (Maybe Hook))
-> (Ptr HookList -> IO (Maybe Hook)) -> IO (Maybe Hook)
forall a b. (a -> b) -> a -> b
$ \Ptr HookList
ptr -> do
val <- Ptr (Ptr Hook) -> IO (Ptr Hook)
forall a. Storable a => Ptr a -> IO a
peek (Ptr HookList
ptr Ptr HookList -> Int -> Ptr (Ptr Hook)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) :: IO (Ptr GLib.Hook.Hook)
result <- SP.convertIfNonNull val $ \Ptr Hook
val' -> do
val'' <- ((ManagedPtr Hook -> Hook) -> Ptr Hook -> IO Hook
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr Hook -> Hook
GLib.Hook.Hook) Ptr Hook
val'
return val''
return 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 = 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
$ HookList -> (Ptr HookList -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr HookList
s ((Ptr HookList -> IO ()) -> IO ())
-> (Ptr HookList -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr HookList
ptr -> do
Ptr (Ptr Hook) -> Ptr Hook -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr HookList
ptr Ptr HookList -> Int -> Ptr (Ptr Hook)
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 = 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
$ HookList -> (Ptr HookList -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr HookList
s ((Ptr HookList -> IO ()) -> IO ())
-> (Ptr HookList -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr HookList
ptr -> do
Ptr (Ptr Hook) -> Ptr Hook -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr HookList
ptr Ptr HookList -> Int -> Ptr (Ptr Hook)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (Ptr Hook
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 :: forall o.
AttrBaseTypeConstraint HookListHooksFieldInfo o =>
o -> IO (AttrGetType HookListHooksFieldInfo)
attrGet = o -> IO (AttrGetType HookListHooksFieldInfo)
HookList -> IO (Maybe Hook)
forall (m :: * -> *). MonadIO m => HookList -> m (Maybe Hook)
getHookListHooks
attrSet :: forall o b.
(AttrBaseTypeConstraint HookListHooksFieldInfo o,
AttrSetTypeConstraint HookListHooksFieldInfo b) =>
o -> b -> IO ()
attrSet = o -> b -> IO ()
HookList -> Ptr Hook -> IO ()
forall (m :: * -> *). MonadIO m => HookList -> Ptr Hook -> m ()
setHookListHooks
attrConstruct :: forall o b.
(AttrBaseTypeConstraint HookListHooksFieldInfo o,
AttrSetTypeConstraint HookListHooksFieldInfo b) =>
b -> IO (GValueConstruct o)
attrConstruct = b -> IO (GValueConstruct o)
forall a. HasCallStack => a
undefined
attrClear :: forall o.
AttrBaseTypeConstraint HookListHooksFieldInfo o =>
o -> IO ()
attrClear = o -> IO ()
HookList -> IO ()
forall (m :: * -> *). MonadIO m => HookList -> m ()
clearHookListHooks
attrTransfer :: forall o b.
(AttrBaseTypeConstraint HookListHooksFieldInfo o,
AttrTransferTypeConstraint HookListHooksFieldInfo b) =>
Proxy o -> b -> IO (AttrTransferType HookListHooksFieldInfo)
attrTransfer Proxy o
_ b
v = do
b -> IO b
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return b
v
dbgAttrInfo :: Maybe ResolvedSymbolInfo
dbgAttrInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.HookList.hooks"
, resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-HookList.html#g:attr:hooks"
})
hookList_hooks :: AttrLabelProxy "hooks"
hookList_hooks :: AttrLabelProxy "hooks"
hookList_hooks = AttrLabelProxy "hooks"
forall (a :: Symbol). AttrLabelProxy a
AttrLabelProxy
#endif
getHookListDummy3 :: MonadIO m => HookList -> m (Ptr ())
getHookListDummy3 :: forall (m :: * -> *). MonadIO m => HookList -> m (Ptr ())
getHookListDummy3 HookList
s = IO (Ptr ()) -> m (Ptr ())
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Ptr ()) -> m (Ptr ())) -> IO (Ptr ()) -> m (Ptr ())
forall a b. (a -> b) -> a -> b
$ HookList -> (Ptr HookList -> IO (Ptr ())) -> IO (Ptr ())
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr HookList
s ((Ptr HookList -> IO (Ptr ())) -> IO (Ptr ()))
-> (Ptr HookList -> IO (Ptr ())) -> IO (Ptr ())
forall a b. (a -> b) -> a -> b
$ \Ptr HookList
ptr -> do
val <- Ptr (Ptr ()) -> IO (Ptr ())
forall a. Storable a => Ptr a -> IO a
peek (Ptr HookList
ptr Ptr HookList -> Int -> Ptr (Ptr ())
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) :: IO (Ptr ())
return val
setHookListDummy3 :: MonadIO m => HookList -> Ptr () -> m ()
setHookListDummy3 :: forall (m :: * -> *). MonadIO m => HookList -> Ptr () -> m ()
setHookListDummy3 HookList
s Ptr ()
val = 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
$ HookList -> (Ptr HookList -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr HookList
s ((Ptr HookList -> IO ()) -> IO ())
-> (Ptr HookList -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr HookList
ptr -> do
Ptr (Ptr ()) -> Ptr () -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr HookList
ptr Ptr HookList -> Int -> Ptr (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 = 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
$ HookList -> (Ptr HookList -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr HookList
s ((Ptr HookList -> IO ()) -> IO ())
-> (Ptr HookList -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr HookList
ptr -> do
Ptr (Ptr ()) -> Ptr () -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr HookList
ptr Ptr HookList -> Int -> Ptr (Ptr ())
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) (Ptr ()
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 :: forall o.
AttrBaseTypeConstraint HookListDummy3FieldInfo o =>
o -> IO (AttrGetType HookListDummy3FieldInfo)
attrGet = o -> IO (AttrGetType HookListDummy3FieldInfo)
HookList -> IO (Ptr ())
forall (m :: * -> *). MonadIO m => HookList -> m (Ptr ())
getHookListDummy3
attrSet :: forall o b.
(AttrBaseTypeConstraint HookListDummy3FieldInfo o,
AttrSetTypeConstraint HookListDummy3FieldInfo b) =>
o -> b -> IO ()
attrSet = o -> b -> IO ()
HookList -> Ptr () -> IO ()
forall (m :: * -> *). MonadIO m => HookList -> Ptr () -> m ()
setHookListDummy3
attrConstruct :: forall o b.
(AttrBaseTypeConstraint HookListDummy3FieldInfo o,
AttrSetTypeConstraint HookListDummy3FieldInfo b) =>
b -> IO (GValueConstruct o)
attrConstruct = b -> IO (GValueConstruct o)
forall a. HasCallStack => a
undefined
attrClear :: forall o.
AttrBaseTypeConstraint HookListDummy3FieldInfo o =>
o -> IO ()
attrClear = o -> IO ()
HookList -> IO ()
forall (m :: * -> *). MonadIO m => HookList -> m ()
clearHookListDummy3
attrTransfer :: forall o b.
(AttrBaseTypeConstraint HookListDummy3FieldInfo o,
AttrTransferTypeConstraint HookListDummy3FieldInfo b) =>
Proxy o -> b -> IO (AttrTransferType HookListDummy3FieldInfo)
attrTransfer Proxy o
_ b
v = do
b -> IO b
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return b
v
dbgAttrInfo :: Maybe ResolvedSymbolInfo
dbgAttrInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.HookList.dummy3"
, resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-HookList.html#g:attr:dummy3"
})
hookList_dummy3 :: AttrLabelProxy "dummy3"
hookList_dummy3 :: AttrLabelProxy "dummy3"
hookList_dummy3 = AttrLabelProxy "dummy3"
forall (a :: Symbol). AttrLabelProxy a
AttrLabelProxy
#endif
getHookListFinalizeHook :: MonadIO m => HookList -> m (Maybe GLib.Callbacks.HookFinalizeFunc)
getHookListFinalizeHook :: forall (m :: * -> *).
MonadIO m =>
HookList -> m (Maybe HookFinalizeFunc)
getHookListFinalizeHook HookList
s = IO (Maybe HookFinalizeFunc) -> m (Maybe HookFinalizeFunc)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe HookFinalizeFunc) -> m (Maybe HookFinalizeFunc))
-> IO (Maybe HookFinalizeFunc) -> m (Maybe HookFinalizeFunc)
forall a b. (a -> b) -> a -> b
$ HookList
-> (Ptr HookList -> IO (Maybe HookFinalizeFunc))
-> IO (Maybe HookFinalizeFunc)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr HookList
s ((Ptr HookList -> IO (Maybe HookFinalizeFunc))
-> IO (Maybe HookFinalizeFunc))
-> (Ptr HookList -> IO (Maybe HookFinalizeFunc))
-> IO (Maybe HookFinalizeFunc)
forall a b. (a -> b) -> a -> b
$ \Ptr HookList
ptr -> do
val <- Ptr (FunPtr C_HookFinalizeFunc) -> IO (FunPtr C_HookFinalizeFunc)
forall a. Storable a => Ptr a -> IO a
peek (Ptr HookList
ptr Ptr HookList -> Int -> Ptr (FunPtr C_HookFinalizeFunc)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) :: IO (FunPtr GLib.Callbacks.C_HookFinalizeFunc)
result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_HookFinalizeFunc
val' -> do
let val'' :: HookFinalizeFunc
val'' = FunPtr C_HookFinalizeFunc -> HookFinalizeFunc
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
FunPtr C_HookFinalizeFunc -> HookList -> Hook -> m ()
GLib.Callbacks.dynamic_HookFinalizeFunc FunPtr C_HookFinalizeFunc
val'
HookFinalizeFunc -> IO HookFinalizeFunc
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return HookFinalizeFunc
val''
return 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 = 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
$ HookList -> (Ptr HookList -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr HookList
s ((Ptr HookList -> IO ()) -> IO ())
-> (Ptr HookList -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr HookList
ptr -> do
Ptr (FunPtr C_HookFinalizeFunc)
-> FunPtr C_HookFinalizeFunc -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr HookList
ptr Ptr HookList -> Int -> Ptr (FunPtr C_HookFinalizeFunc)
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 = 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
$ HookList -> (Ptr HookList -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr HookList
s ((Ptr HookList -> IO ()) -> IO ())
-> (Ptr HookList -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr HookList
ptr -> do
Ptr (FunPtr C_HookFinalizeFunc)
-> FunPtr C_HookFinalizeFunc -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr HookList
ptr Ptr HookList -> Int -> Ptr (FunPtr C_HookFinalizeFunc)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) (FunPtr C_HookFinalizeFunc
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 :: forall o.
AttrBaseTypeConstraint HookListFinalizeHookFieldInfo o =>
o -> IO (AttrGetType HookListFinalizeHookFieldInfo)
attrGet = o -> IO (AttrGetType HookListFinalizeHookFieldInfo)
HookList -> IO (Maybe HookFinalizeFunc)
forall (m :: * -> *).
MonadIO m =>
HookList -> m (Maybe HookFinalizeFunc)
getHookListFinalizeHook
attrSet :: forall o b.
(AttrBaseTypeConstraint HookListFinalizeHookFieldInfo o,
AttrSetTypeConstraint HookListFinalizeHookFieldInfo b) =>
o -> b -> IO ()
attrSet = o -> b -> IO ()
HookList -> FunPtr C_HookFinalizeFunc -> IO ()
forall (m :: * -> *).
MonadIO m =>
HookList -> FunPtr C_HookFinalizeFunc -> m ()
setHookListFinalizeHook
attrConstruct :: forall o b.
(AttrBaseTypeConstraint HookListFinalizeHookFieldInfo o,
AttrSetTypeConstraint HookListFinalizeHookFieldInfo b) =>
b -> IO (GValueConstruct o)
attrConstruct = b -> IO (GValueConstruct o)
forall a. HasCallStack => a
undefined
attrClear :: forall o.
AttrBaseTypeConstraint HookListFinalizeHookFieldInfo o =>
o -> IO ()
attrClear = o -> IO ()
HookList -> IO ()
forall (m :: * -> *). MonadIO m => HookList -> m ()
clearHookListFinalizeHook
attrTransfer :: forall o b.
(AttrBaseTypeConstraint HookListFinalizeHookFieldInfo o,
AttrTransferTypeConstraint HookListFinalizeHookFieldInfo b) =>
Proxy o -> b -> IO (AttrTransferType HookListFinalizeHookFieldInfo)
attrTransfer Proxy o
_ b
v = do
C_HookFinalizeFunc -> IO (FunPtr C_HookFinalizeFunc)
GLib.Callbacks.mk_HookFinalizeFunc (Maybe (Ptr (FunPtr C_HookFinalizeFunc))
-> HookFinalizeFunc -> C_HookFinalizeFunc
GLib.Callbacks.wrap_HookFinalizeFunc Maybe (Ptr (FunPtr C_HookFinalizeFunc))
forall a. Maybe a
Nothing b
HookFinalizeFunc
v)
dbgAttrInfo :: Maybe ResolvedSymbolInfo
dbgAttrInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.HookList.finalizeHook"
, resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-HookList.html#g:attr:finalizeHook"
})
hookList_finalizeHook :: AttrLabelProxy "finalizeHook"
hookList_finalizeHook :: AttrLabelProxy "finalizeHook"
hookList_finalizeHook = AttrLabelProxy "finalizeHook"
forall (a :: Symbol). AttrLabelProxy a
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 = 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
hookList' <- HookList -> IO (Ptr HookList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr HookList
hookList
g_hook_list_clear hookList'
touchManagedPtr hookList
return ()
#if defined(ENABLE_OVERLOADING)
data HookListClearMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod HookListClearMethodInfo HookList signature where
overloadedMethod :: HookList -> signature
overloadedMethod = HookList -> signature
HookList -> m ()
forall (m :: * -> *). (HasCallStack, MonadIO m) => HookList -> m ()
hookListClear
instance O.OverloadedMethodInfo HookListClearMethodInfo HookList where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.HookList.hookListClear",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/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 = 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
hookList' <- HookList -> IO (Ptr HookList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr HookList
hookList
g_hook_list_init hookList' hookSize
touchManagedPtr hookList
return ()
#if defined(ENABLE_OVERLOADING)
data HookListInitMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m) => O.OverloadedMethod HookListInitMethodInfo HookList signature where
overloadedMethod :: HookList -> signature
overloadedMethod = HookList -> signature
HookList -> Word32 -> m ()
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
HookList -> Word32 -> m ()
hookListInit
instance O.OverloadedMethodInfo HookListInitMethodInfo HookList where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.HookList.hookListInit",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/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 = 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
hookList' <- HookList -> IO (Ptr HookList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr HookList
hookList
let mayRecurse' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.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
P.fromEnum) Bool
mayRecurse
g_hook_list_invoke hookList' mayRecurse'
touchManagedPtr hookList
return ()
#if defined(ENABLE_OVERLOADING)
data HookListInvokeMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m) => O.OverloadedMethod HookListInvokeMethodInfo HookList signature where
overloadedMethod :: HookList -> signature
overloadedMethod = HookList -> signature
HookList -> Bool -> m ()
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
HookList -> Bool -> m ()
hookListInvoke
instance O.OverloadedMethodInfo HookListInvokeMethodInfo HookList where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.HookList.hookListInvoke",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/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 = 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
hookList' <- HookList -> IO (Ptr HookList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr HookList
hookList
let mayRecurse' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.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
P.fromEnum) Bool
mayRecurse
g_hook_list_invoke_check hookList' mayRecurse'
touchManagedPtr hookList
return ()
#if defined(ENABLE_OVERLOADING)
data HookListInvokeCheckMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m) => O.OverloadedMethod HookListInvokeCheckMethodInfo HookList signature where
overloadedMethod :: HookList -> signature
overloadedMethod = HookList -> signature
HookList -> Bool -> m ()
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
HookList -> Bool -> m ()
hookListInvokeCheck
instance O.OverloadedMethodInfo HookListInvokeCheckMethodInfo HookList where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.HookList.hookListInvokeCheck",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-HookList.html#v:hookListInvokeCheck"
})
#endif
foreign import ccall "g_hook_list_marshal" g_hook_list_marshal ::
Ptr HookList ->
CInt ->
FunPtr GLib.Callbacks.C_HookMarshaller ->
Ptr () ->
IO ()
hookListMarshal ::
(B.CallStack.HasCallStack, MonadIO m) =>
HookList
-> Bool
-> GLib.Callbacks.HookMarshaller
-> m ()
hookListMarshal :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
HookList -> Bool -> HookMarshaller -> m ()
hookListMarshal HookList
hookList Bool
mayRecurse HookMarshaller
marshaller = 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
hookList' <- HookList -> IO (Ptr HookList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr HookList
hookList
let mayRecurse' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.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
P.fromEnum) Bool
mayRecurse
marshaller' <- GLib.Callbacks.mk_HookMarshaller (GLib.Callbacks.wrap_HookMarshaller Nothing marshaller)
let marshalData = Ptr a
forall a. Ptr a
nullPtr
g_hook_list_marshal hookList' mayRecurse' marshaller' marshalData
safeFreeFunPtr $ castFunPtrToPtr marshaller'
touchManagedPtr hookList
return ()
#if defined(ENABLE_OVERLOADING)
data HookListMarshalMethodInfo
instance (signature ~ (Bool -> GLib.Callbacks.HookMarshaller -> m ()), MonadIO m) => O.OverloadedMethod HookListMarshalMethodInfo HookList signature where
overloadedMethod :: HookList -> signature
overloadedMethod = HookList -> signature
HookList -> Bool -> HookMarshaller -> m ()
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
HookList -> Bool -> HookMarshaller -> m ()
hookListMarshal
instance O.OverloadedMethodInfo HookListMarshalMethodInfo HookList where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.HookList.hookListMarshal",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-HookList.html#v:hookListMarshal"
})
#endif
foreign import ccall "g_hook_list_marshal_check" g_hook_list_marshal_check ::
Ptr HookList ->
CInt ->
FunPtr GLib.Callbacks.C_HookCheckMarshaller ->
Ptr () ->
IO ()
hookListMarshalCheck ::
(B.CallStack.HasCallStack, MonadIO m) =>
HookList
-> Bool
-> GLib.Callbacks.HookCheckMarshaller
-> m ()
hookListMarshalCheck :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
HookList -> Bool -> HookCheckMarshaller -> m ()
hookListMarshalCheck HookList
hookList Bool
mayRecurse HookCheckMarshaller
marshaller = 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
hookList' <- HookList -> IO (Ptr HookList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr HookList
hookList
let mayRecurse' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.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
P.fromEnum) Bool
mayRecurse
marshaller' <- GLib.Callbacks.mk_HookCheckMarshaller (GLib.Callbacks.wrap_HookCheckMarshaller Nothing marshaller)
let marshalData = Ptr a
forall a. Ptr a
nullPtr
g_hook_list_marshal_check hookList' mayRecurse' marshaller' marshalData
safeFreeFunPtr $ castFunPtrToPtr marshaller'
touchManagedPtr hookList
return ()
#if defined(ENABLE_OVERLOADING)
data HookListMarshalCheckMethodInfo
instance (signature ~ (Bool -> GLib.Callbacks.HookCheckMarshaller -> m ()), MonadIO m) => O.OverloadedMethod HookListMarshalCheckMethodInfo HookList signature where
overloadedMethod :: HookList -> signature
overloadedMethod = HookList -> signature
HookList -> Bool -> HookCheckMarshaller -> m ()
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
HookList -> Bool -> HookCheckMarshaller -> m ()
hookListMarshalCheck
instance O.OverloadedMethodInfo HookListMarshalCheckMethodInfo HookList where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.HookList.hookListMarshalCheck",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-HookList.html#v:hookListMarshalCheck"
})
#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 "marshal" o = HookListMarshalMethodInfo
ResolveHookListMethod "marshalCheck" o = HookListMarshalCheckMethodInfo
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 :: HookList -> p
fromLabel = forall {k} (i :: k) o s. OverloadedMethod i o s => o -> s
forall i o s. OverloadedMethod i o s => o -> s
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 :: HookList -> p
getField = forall {k} (i :: k) o s. OverloadedMethod i o s => o -> s
forall i o s. OverloadedMethod i o s => o -> s
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 :: MethodProxy info HookList
fromLabel = MethodProxy info HookList
forall info obj. MethodProxy info obj
O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif