{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.GLib.Structs.Hook
(
Hook(..) ,
newZeroHook ,
#if defined(ENABLE_OVERLOADING)
ResolveHookMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
HookCompareIdsMethodInfo ,
#endif
hookCompareIds ,
hookDestroy ,
hookDestroyLink ,
hookFree ,
hookInsertBefore ,
hookPrepend ,
hookUnref ,
clearHookData ,
getHookData ,
#if defined(ENABLE_OVERLOADING)
hook_data ,
#endif
setHookData ,
clearHookDestroy ,
getHookDestroy ,
#if defined(ENABLE_OVERLOADING)
hook_destroy ,
#endif
setHookDestroy ,
getHookFlags ,
#if defined(ENABLE_OVERLOADING)
hook_flags ,
#endif
setHookFlags ,
clearHookFunc ,
getHookFunc ,
#if defined(ENABLE_OVERLOADING)
hook_func ,
#endif
setHookFunc ,
getHookHookId ,
#if defined(ENABLE_OVERLOADING)
hook_hookId ,
#endif
setHookHookId ,
clearHookNext ,
getHookNext ,
#if defined(ENABLE_OVERLOADING)
hook_next ,
#endif
setHookNext ,
clearHookPrev ,
getHookPrev ,
#if defined(ENABLE_OVERLOADING)
hook_prev ,
#endif
setHookPrev ,
getHookRefCount ,
#if defined(ENABLE_OVERLOADING)
hook_refCount ,
#endif
setHookRefCount ,
) 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.HookList as GLib.HookList
newtype Hook = Hook (SP.ManagedPtr Hook)
deriving (Hook -> Hook -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Hook -> Hook -> Bool
$c/= :: Hook -> Hook -> Bool
== :: Hook -> Hook -> Bool
$c== :: Hook -> Hook -> Bool
Eq)
instance SP.ManagedPtrNewtype Hook where
toManagedPtr :: Hook -> ManagedPtr Hook
toManagedPtr (Hook ManagedPtr Hook
p) = ManagedPtr Hook
p
instance BoxedPtr Hook where
boxedPtrCopy :: Hook -> IO Hook
boxedPtrCopy = \Hook
p -> forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Hook
p (forall a. (HasCallStack, CallocPtr a) => Int -> Ptr a -> IO (Ptr a)
copyBytes Int
64 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 Hook -> Hook
Hook)
boxedPtrFree :: Hook -> IO ()
boxedPtrFree = \Hook
x -> forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
SP.withManagedPtr Hook
x forall a. Ptr a -> IO ()
SP.freeMem
instance CallocPtr Hook where
boxedPtrCalloc :: IO (Ptr Hook)
boxedPtrCalloc = forall a. Int -> IO (Ptr a)
callocBytes Int
64
newZeroHook :: MonadIO m => m Hook
newZeroHook :: forall (m :: * -> *). MonadIO m => m Hook
newZeroHook = 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 Hook -> Hook
Hook
instance tag ~ 'AttrSet => Constructible Hook tag where
new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr Hook -> Hook) -> [AttrOp Hook tag] -> m Hook
new ManagedPtr Hook -> Hook
_ [AttrOp Hook tag]
attrs = do
Hook
o <- forall (m :: * -> *). MonadIO m => m Hook
newZeroHook
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set Hook
o [AttrOp Hook tag]
attrs
forall (m :: * -> *) a. Monad m => a -> m a
return Hook
o
getHookData :: MonadIO m => Hook -> m (Ptr ())
getHookData :: forall (m :: * -> *). MonadIO m => Hook -> m (Ptr ())
getHookData Hook
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 Hook
s forall a b. (a -> b) -> a -> b
$ \Ptr Hook
ptr -> do
Ptr ()
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr Hook
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) :: IO (Ptr ())
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ()
val
setHookData :: MonadIO m => Hook -> Ptr () -> m ()
setHookData :: forall (m :: * -> *). MonadIO m => Hook -> Ptr () -> m ()
setHookData Hook
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 Hook
s forall a b. (a -> b) -> a -> b
$ \Ptr Hook
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Hook
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (Ptr ()
val :: Ptr ())
clearHookData :: MonadIO m => Hook -> m ()
clearHookData :: forall (m :: * -> *). MonadIO m => Hook -> m ()
clearHookData Hook
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 Hook
s forall a b. (a -> b) -> a -> b
$ \Ptr Hook
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Hook
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (forall a. Ptr a
FP.nullPtr :: Ptr ())
#if defined(ENABLE_OVERLOADING)
data HookDataFieldInfo
instance AttrInfo HookDataFieldInfo where
type AttrBaseTypeConstraint HookDataFieldInfo = (~) Hook
type AttrAllowedOps HookDataFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint HookDataFieldInfo = (~) (Ptr ())
type AttrTransferTypeConstraint HookDataFieldInfo = (~)(Ptr ())
type AttrTransferType HookDataFieldInfo = (Ptr ())
type AttrGetType HookDataFieldInfo = Ptr ()
type AttrLabel HookDataFieldInfo = "data"
type AttrOrigin HookDataFieldInfo = Hook
attrGet = getHookData
attrSet = setHookData
attrConstruct = undefined
attrClear = clearHookData
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Hook.data"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-Hook.html#g:attr:data"
})
hook_data :: AttrLabelProxy "data"
hook_data = AttrLabelProxy
#endif
getHookNext :: MonadIO m => Hook -> m (Maybe Hook)
getHookNext :: forall (m :: * -> *). MonadIO m => Hook -> m (Maybe Hook)
getHookNext Hook
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 Hook
s forall a b. (a -> b) -> a -> b
$ \Ptr Hook
ptr -> do
Ptr Hook
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr Hook
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) :: IO (Ptr 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
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
setHookNext :: MonadIO m => Hook -> Ptr Hook -> m ()
setHookNext :: forall (m :: * -> *). MonadIO m => Hook -> Ptr Hook -> m ()
setHookNext Hook
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 Hook
s forall a b. (a -> b) -> a -> b
$ \Ptr Hook
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Hook
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (Ptr Hook
val :: Ptr Hook)
clearHookNext :: MonadIO m => Hook -> m ()
clearHookNext :: forall (m :: * -> *). MonadIO m => Hook -> m ()
clearHookNext Hook
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 Hook
s forall a b. (a -> b) -> a -> b
$ \Ptr Hook
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Hook
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (forall a. Ptr a
FP.nullPtr :: Ptr Hook)
#if defined(ENABLE_OVERLOADING)
data HookNextFieldInfo
instance AttrInfo HookNextFieldInfo where
type AttrBaseTypeConstraint HookNextFieldInfo = (~) Hook
type AttrAllowedOps HookNextFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint HookNextFieldInfo = (~) (Ptr Hook)
type AttrTransferTypeConstraint HookNextFieldInfo = (~)(Ptr Hook)
type AttrTransferType HookNextFieldInfo = (Ptr Hook)
type AttrGetType HookNextFieldInfo = Maybe Hook
type AttrLabel HookNextFieldInfo = "next"
type AttrOrigin HookNextFieldInfo = Hook
attrGet = getHookNext
attrSet = setHookNext
attrConstruct = undefined
attrClear = clearHookNext
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Hook.next"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-Hook.html#g:attr:next"
})
hook_next :: AttrLabelProxy "next"
hook_next = AttrLabelProxy
#endif
getHookPrev :: MonadIO m => Hook -> m (Maybe Hook)
getHookPrev :: forall (m :: * -> *). MonadIO m => Hook -> m (Maybe Hook)
getHookPrev Hook
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 Hook
s forall a b. (a -> b) -> a -> b
$ \Ptr Hook
ptr -> do
Ptr Hook
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr Hook
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) :: IO (Ptr 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
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
setHookPrev :: MonadIO m => Hook -> Ptr Hook -> m ()
setHookPrev :: forall (m :: * -> *). MonadIO m => Hook -> Ptr Hook -> m ()
setHookPrev Hook
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 Hook
s forall a b. (a -> b) -> a -> b
$ \Ptr Hook
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Hook
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (Ptr Hook
val :: Ptr Hook)
clearHookPrev :: MonadIO m => Hook -> m ()
clearHookPrev :: forall (m :: * -> *). MonadIO m => Hook -> m ()
clearHookPrev Hook
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 Hook
s forall a b. (a -> b) -> a -> b
$ \Ptr Hook
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Hook
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (forall a. Ptr a
FP.nullPtr :: Ptr Hook)
#if defined(ENABLE_OVERLOADING)
data HookPrevFieldInfo
instance AttrInfo HookPrevFieldInfo where
type AttrBaseTypeConstraint HookPrevFieldInfo = (~) Hook
type AttrAllowedOps HookPrevFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint HookPrevFieldInfo = (~) (Ptr Hook)
type AttrTransferTypeConstraint HookPrevFieldInfo = (~)(Ptr Hook)
type AttrTransferType HookPrevFieldInfo = (Ptr Hook)
type AttrGetType HookPrevFieldInfo = Maybe Hook
type AttrLabel HookPrevFieldInfo = "prev"
type AttrOrigin HookPrevFieldInfo = Hook
attrGet = getHookPrev
attrSet = setHookPrev
attrConstruct = undefined
attrClear = clearHookPrev
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Hook.prev"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-Hook.html#g:attr:prev"
})
hook_prev :: AttrLabelProxy "prev"
hook_prev = AttrLabelProxy
#endif
getHookRefCount :: MonadIO m => Hook -> m Word32
getHookRefCount :: forall (m :: * -> *). MonadIO m => Hook -> m Word32
getHookRefCount Hook
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 Hook
s forall a b. (a -> b) -> a -> b
$ \Ptr Hook
ptr -> do
Word32
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr Hook
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) :: IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
val
setHookRefCount :: MonadIO m => Hook -> Word32 -> m ()
setHookRefCount :: forall (m :: * -> *). MonadIO m => Hook -> Word32 -> m ()
setHookRefCount Hook
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 Hook
s forall a b. (a -> b) -> a -> b
$ \Ptr Hook
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Hook
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) (Word32
val :: Word32)
#if defined(ENABLE_OVERLOADING)
data HookRefCountFieldInfo
instance AttrInfo HookRefCountFieldInfo where
type AttrBaseTypeConstraint HookRefCountFieldInfo = (~) Hook
type AttrAllowedOps HookRefCountFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint HookRefCountFieldInfo = (~) Word32
type AttrTransferTypeConstraint HookRefCountFieldInfo = (~)Word32
type AttrTransferType HookRefCountFieldInfo = Word32
type AttrGetType HookRefCountFieldInfo = Word32
type AttrLabel HookRefCountFieldInfo = "ref_count"
type AttrOrigin HookRefCountFieldInfo = Hook
attrGet = getHookRefCount
attrSet = setHookRefCount
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Hook.refCount"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-Hook.html#g:attr:refCount"
})
hook_refCount :: AttrLabelProxy "refCount"
hook_refCount = AttrLabelProxy
#endif
getHookHookId :: MonadIO m => Hook -> m CULong
getHookHookId :: forall (m :: * -> *). MonadIO m => Hook -> m CULong
getHookHookId Hook
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 Hook
s forall a b. (a -> b) -> a -> b
$ \Ptr Hook
ptr -> do
CULong
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr Hook
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) :: IO CULong
forall (m :: * -> *) a. Monad m => a -> m a
return CULong
val
setHookHookId :: MonadIO m => Hook -> CULong -> m ()
setHookHookId :: forall (m :: * -> *). MonadIO m => Hook -> CULong -> m ()
setHookHookId Hook
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 Hook
s forall a b. (a -> b) -> a -> b
$ \Ptr Hook
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Hook
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) (CULong
val :: CULong)
#if defined(ENABLE_OVERLOADING)
data HookHookIdFieldInfo
instance AttrInfo HookHookIdFieldInfo where
type AttrBaseTypeConstraint HookHookIdFieldInfo = (~) Hook
type AttrAllowedOps HookHookIdFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint HookHookIdFieldInfo = (~) CULong
type AttrTransferTypeConstraint HookHookIdFieldInfo = (~)CULong
type AttrTransferType HookHookIdFieldInfo = CULong
type AttrGetType HookHookIdFieldInfo = CULong
type AttrLabel HookHookIdFieldInfo = "hook_id"
type AttrOrigin HookHookIdFieldInfo = Hook
attrGet = getHookHookId
attrSet = setHookHookId
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Hook.hookId"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-Hook.html#g:attr:hookId"
})
hook_hookId :: AttrLabelProxy "hookId"
hook_hookId = AttrLabelProxy
#endif
getHookFlags :: MonadIO m => Hook -> m Word32
getHookFlags :: forall (m :: * -> *). MonadIO m => Hook -> m Word32
getHookFlags Hook
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 Hook
s forall a b. (a -> b) -> a -> b
$ \Ptr Hook
ptr -> do
Word32
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr Hook
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
40) :: IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
val
setHookFlags :: MonadIO m => Hook -> Word32 -> m ()
setHookFlags :: forall (m :: * -> *). MonadIO m => Hook -> Word32 -> m ()
setHookFlags Hook
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 Hook
s forall a b. (a -> b) -> a -> b
$ \Ptr Hook
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Hook
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
40) (Word32
val :: Word32)
#if defined(ENABLE_OVERLOADING)
data HookFlagsFieldInfo
instance AttrInfo HookFlagsFieldInfo where
type AttrBaseTypeConstraint HookFlagsFieldInfo = (~) Hook
type AttrAllowedOps HookFlagsFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint HookFlagsFieldInfo = (~) Word32
type AttrTransferTypeConstraint HookFlagsFieldInfo = (~)Word32
type AttrTransferType HookFlagsFieldInfo = Word32
type AttrGetType HookFlagsFieldInfo = Word32
type AttrLabel HookFlagsFieldInfo = "flags"
type AttrOrigin HookFlagsFieldInfo = Hook
attrGet = getHookFlags
attrSet = setHookFlags
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Hook.flags"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-Hook.html#g:attr:flags"
})
hook_flags :: AttrLabelProxy "flags"
hook_flags = AttrLabelProxy
#endif
getHookFunc :: MonadIO m => Hook -> m (Ptr ())
getHookFunc :: forall (m :: * -> *). MonadIO m => Hook -> m (Ptr ())
getHookFunc Hook
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 Hook
s forall a b. (a -> b) -> a -> b
$ \Ptr Hook
ptr -> do
Ptr ()
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr Hook
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
48) :: IO (Ptr ())
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ()
val
setHookFunc :: MonadIO m => Hook -> Ptr () -> m ()
setHookFunc :: forall (m :: * -> *). MonadIO m => Hook -> Ptr () -> m ()
setHookFunc Hook
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 Hook
s forall a b. (a -> b) -> a -> b
$ \Ptr Hook
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Hook
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
48) (Ptr ()
val :: Ptr ())
clearHookFunc :: MonadIO m => Hook -> m ()
clearHookFunc :: forall (m :: * -> *). MonadIO m => Hook -> m ()
clearHookFunc Hook
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 Hook
s forall a b. (a -> b) -> a -> b
$ \Ptr Hook
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Hook
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
48) (forall a. Ptr a
FP.nullPtr :: Ptr ())
#if defined(ENABLE_OVERLOADING)
data HookFuncFieldInfo
instance AttrInfo HookFuncFieldInfo where
type AttrBaseTypeConstraint HookFuncFieldInfo = (~) Hook
type AttrAllowedOps HookFuncFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint HookFuncFieldInfo = (~) (Ptr ())
type AttrTransferTypeConstraint HookFuncFieldInfo = (~)(Ptr ())
type AttrTransferType HookFuncFieldInfo = (Ptr ())
type AttrGetType HookFuncFieldInfo = Ptr ()
type AttrLabel HookFuncFieldInfo = "func"
type AttrOrigin HookFuncFieldInfo = Hook
attrGet = getHookFunc
attrSet = setHookFunc
attrConstruct = undefined
attrClear = clearHookFunc
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Hook.func"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-Hook.html#g:attr:func"
})
hook_func :: AttrLabelProxy "func"
hook_func = AttrLabelProxy
#endif
getHookDestroy :: MonadIO m => Hook -> m (Maybe GLib.Callbacks.DestroyNotify)
getHookDestroy :: forall (m :: * -> *). MonadIO m => Hook -> m (Maybe DestroyNotify)
getHookDestroy Hook
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 Hook
s forall a b. (a -> b) -> a -> b
$ \Ptr Hook
ptr -> do
FunPtr DestroyNotify
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr Hook
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
56) :: IO (FunPtr GLib.Callbacks.C_DestroyNotify)
Maybe DestroyNotify
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr DestroyNotify
val forall a b. (a -> b) -> a -> b
$ \FunPtr DestroyNotify
val' -> do
let val'' :: DestroyNotify
val'' = forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
FunPtr DestroyNotify -> Ptr () -> m ()
GLib.Callbacks.dynamic_DestroyNotify FunPtr DestroyNotify
val'
forall (m :: * -> *) a. Monad m => a -> m a
return DestroyNotify
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe DestroyNotify
result
setHookDestroy :: MonadIO m => Hook -> FunPtr GLib.Callbacks.C_DestroyNotify -> m ()
setHookDestroy :: forall (m :: * -> *).
MonadIO m =>
Hook -> FunPtr DestroyNotify -> m ()
setHookDestroy Hook
s FunPtr DestroyNotify
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 Hook
s forall a b. (a -> b) -> a -> b
$ \Ptr Hook
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Hook
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
56) (FunPtr DestroyNotify
val :: FunPtr GLib.Callbacks.C_DestroyNotify)
clearHookDestroy :: MonadIO m => Hook -> m ()
clearHookDestroy :: forall (m :: * -> *). MonadIO m => Hook -> m ()
clearHookDestroy Hook
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 Hook
s forall a b. (a -> b) -> a -> b
$ \Ptr Hook
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Hook
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
56) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr GLib.Callbacks.C_DestroyNotify)
#if defined(ENABLE_OVERLOADING)
data HookDestroyFieldInfo
instance AttrInfo HookDestroyFieldInfo where
type AttrBaseTypeConstraint HookDestroyFieldInfo = (~) Hook
type AttrAllowedOps HookDestroyFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint HookDestroyFieldInfo = (~) (FunPtr GLib.Callbacks.C_DestroyNotify)
type AttrTransferTypeConstraint HookDestroyFieldInfo = (~)GLib.Callbacks.DestroyNotify
type AttrTransferType HookDestroyFieldInfo = (FunPtr GLib.Callbacks.C_DestroyNotify)
type AttrGetType HookDestroyFieldInfo = Maybe GLib.Callbacks.DestroyNotify
type AttrLabel HookDestroyFieldInfo = "destroy"
type AttrOrigin HookDestroyFieldInfo = Hook
attrGet = getHookDestroy
attrSet = setHookDestroy
attrConstruct = undefined
attrClear = clearHookDestroy
attrTransfer _ v = do
GLib.Callbacks.mk_DestroyNotify (GLib.Callbacks.wrap_DestroyNotify Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Hook.destroy"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-Hook.html#g:attr:destroy"
})
hook_destroy :: AttrLabelProxy "destroy"
hook_destroy = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Hook
type instance O.AttributeList Hook = HookAttributeList
type HookAttributeList = ('[ '("data", HookDataFieldInfo), '("next", HookNextFieldInfo), '("prev", HookPrevFieldInfo), '("refCount", HookRefCountFieldInfo), '("hookId", HookHookIdFieldInfo), '("flags", HookFlagsFieldInfo), '("func", HookFuncFieldInfo), '("destroy", HookDestroyFieldInfo)] :: [(Symbol, DK.Type)])
#endif
foreign import ccall "g_hook_compare_ids" g_hook_compare_ids ::
Ptr Hook ->
Ptr Hook ->
IO Int32
hookCompareIds ::
(B.CallStack.HasCallStack, MonadIO m) =>
Hook
-> Hook
-> m Int32
hookCompareIds :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Hook -> Hook -> m Int32
hookCompareIds Hook
newHook Hook
sibling = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Hook
newHook' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Hook
newHook
Ptr Hook
sibling' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Hook
sibling
Int32
result <- Ptr Hook -> Ptr Hook -> IO Int32
g_hook_compare_ids Ptr Hook
newHook' Ptr Hook
sibling'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Hook
newHook
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Hook
sibling
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data HookCompareIdsMethodInfo
instance (signature ~ (Hook -> m Int32), MonadIO m) => O.OverloadedMethod HookCompareIdsMethodInfo Hook signature where
overloadedMethod = hookCompareIds
instance O.OverloadedMethodInfo HookCompareIdsMethodInfo Hook where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Hook.hookCompareIds",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-Hook.html#v:hookCompareIds"
})
#endif
foreign import ccall "g_hook_destroy" g_hook_destroy ::
Ptr GLib.HookList.HookList ->
CULong ->
IO CInt
hookDestroy ::
(B.CallStack.HasCallStack, MonadIO m) =>
GLib.HookList.HookList
-> CULong
-> m Bool
hookDestroy :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
HookList -> CULong -> m Bool
hookDestroy HookList
hookList CULong
hookId = 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
CInt
result <- Ptr HookList -> CULong -> IO CInt
g_hook_destroy Ptr HookList
hookList' CULong
hookId
let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr HookList
hookList
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_hook_destroy_link" g_hook_destroy_link ::
Ptr GLib.HookList.HookList ->
Ptr Hook ->
IO ()
hookDestroyLink ::
(B.CallStack.HasCallStack, MonadIO m) =>
GLib.HookList.HookList
-> Hook
-> m ()
hookDestroyLink :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
HookList -> Hook -> m ()
hookDestroyLink HookList
hookList Hook
hook = 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 Hook
hook' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Hook
hook
Ptr HookList -> Ptr Hook -> IO ()
g_hook_destroy_link Ptr HookList
hookList' Ptr Hook
hook'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr HookList
hookList
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Hook
hook
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_hook_free" g_hook_free ::
Ptr GLib.HookList.HookList ->
Ptr Hook ->
IO ()
hookFree ::
(B.CallStack.HasCallStack, MonadIO m) =>
GLib.HookList.HookList
-> Hook
-> m ()
hookFree :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
HookList -> Hook -> m ()
hookFree HookList
hookList Hook
hook = 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 Hook
hook' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Hook
hook
Ptr HookList -> Ptr Hook -> IO ()
g_hook_free Ptr HookList
hookList' Ptr Hook
hook'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr HookList
hookList
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Hook
hook
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_hook_insert_before" g_hook_insert_before ::
Ptr GLib.HookList.HookList ->
Ptr Hook ->
Ptr Hook ->
IO ()
hookInsertBefore ::
(B.CallStack.HasCallStack, MonadIO m) =>
GLib.HookList.HookList
-> Maybe (Hook)
-> Hook
-> m ()
hookInsertBefore :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
HookList -> Maybe Hook -> Hook -> m ()
hookInsertBefore HookList
hookList Maybe Hook
sibling Hook
hook = 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 Hook
maybeSibling <- case Maybe Hook
sibling of
Maybe Hook
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
Just Hook
jSibling -> do
Ptr Hook
jSibling' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Hook
jSibling
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Hook
jSibling'
Ptr Hook
hook' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Hook
hook
Ptr HookList -> Ptr Hook -> Ptr Hook -> IO ()
g_hook_insert_before Ptr HookList
hookList' Ptr Hook
maybeSibling Ptr Hook
hook'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr HookList
hookList
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe Hook
sibling forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Hook
hook
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_hook_prepend" g_hook_prepend ::
Ptr GLib.HookList.HookList ->
Ptr Hook ->
IO ()
hookPrepend ::
(B.CallStack.HasCallStack, MonadIO m) =>
GLib.HookList.HookList
-> Hook
-> m ()
hookPrepend :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
HookList -> Hook -> m ()
hookPrepend HookList
hookList Hook
hook = 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 Hook
hook' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Hook
hook
Ptr HookList -> Ptr Hook -> IO ()
g_hook_prepend Ptr HookList
hookList' Ptr Hook
hook'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr HookList
hookList
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Hook
hook
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_hook_unref" g_hook_unref ::
Ptr GLib.HookList.HookList ->
Ptr Hook ->
IO ()
hookUnref ::
(B.CallStack.HasCallStack, MonadIO m) =>
GLib.HookList.HookList
-> Hook
-> m ()
hookUnref :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
HookList -> Hook -> m ()
hookUnref HookList
hookList Hook
hook = 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 Hook
hook' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Hook
hook
Ptr HookList -> Ptr Hook -> IO ()
g_hook_unref Ptr HookList
hookList' Ptr Hook
hook'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr HookList
hookList
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Hook
hook
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveHookMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveHookMethod "compareIds" o = HookCompareIdsMethodInfo
ResolveHookMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveHookMethod t Hook, O.OverloadedMethod info Hook p) => OL.IsLabel t (Hook -> 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 ~ ResolveHookMethod t Hook, O.OverloadedMethod info Hook p, R.HasField t Hook p) => R.HasField t Hook p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveHookMethod t Hook, O.OverloadedMethodInfo info Hook) => OL.IsLabel t (O.MethodProxy info Hook) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif