module GI.GLib.Structs.Hook
(
Hook(..) ,
newZeroHook ,
noHook ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
HookCompareIdsMethodInfo ,
#endif
hookCompareIds ,
hookDestroy ,
hookDestroyLink ,
hookFree ,
hookInsertBefore ,
hookPrepend ,
hookUnref ,
clearHookData ,
getHookData ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
hook_data ,
#endif
setHookData ,
clearHookDestroy ,
getHookDestroy ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
hook_destroy ,
#endif
setHookDestroy ,
getHookFlags ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
hook_flags ,
#endif
setHookFlags ,
clearHookFunc ,
getHookFunc ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
hook_func ,
#endif
setHookFunc ,
getHookHookId ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
hook_hookId ,
#endif
setHookHookId ,
clearHookNext ,
getHookNext ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
hook_next ,
#endif
setHookNext ,
clearHookPrev ,
getHookPrev ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
hook_prev ,
#endif
setHookPrev ,
getHookRefCount ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GI.GLib.Callbacks as GLib.Callbacks
import qualified GI.GLib.Structs.HookList as GLib.HookList
newtype Hook = Hook (ManagedPtr Hook)
instance WrappedPtr Hook where
wrappedPtrCalloc = callocBytes 64
wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 64 >=> wrapPtr Hook)
wrappedPtrFree = Just ptr_to_g_free
newZeroHook :: MonadIO m => m Hook
newZeroHook = liftIO $ wrappedPtrCalloc >>= wrapPtr Hook
instance tag ~ 'AttrSet => Constructible Hook tag where
new _ attrs = do
o <- newZeroHook
GI.Attributes.set o attrs
return o
noHook :: Maybe Hook
noHook = Nothing
getHookData :: MonadIO m => Hook -> m (Ptr ())
getHookData s = liftIO $ withManagedPtr s $ \ptr -> do
val <- peek (ptr `plusPtr` 0) :: IO (Ptr ())
return val
setHookData :: MonadIO m => Hook -> Ptr () -> m ()
setHookData s val = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 0) (val :: Ptr ())
clearHookData :: MonadIO m => Hook -> m ()
clearHookData s = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 0) (FP.nullPtr :: Ptr ())
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data HookDataFieldInfo
instance AttrInfo HookDataFieldInfo where
type AttrAllowedOps HookDataFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint HookDataFieldInfo = (~) (Ptr ())
type AttrBaseTypeConstraint HookDataFieldInfo = (~) Hook
type AttrGetType HookDataFieldInfo = Ptr ()
type AttrLabel HookDataFieldInfo = "data"
type AttrOrigin HookDataFieldInfo = Hook
attrGet _ = getHookData
attrSet _ = setHookData
attrConstruct = undefined
attrClear _ = clearHookData
hook_data :: AttrLabelProxy "data"
hook_data = AttrLabelProxy
#endif
getHookNext :: MonadIO m => Hook -> m (Maybe Hook)
getHookNext s = liftIO $ withManagedPtr s $ \ptr -> do
val <- peek (ptr `plusPtr` 8) :: IO (Ptr Hook)
result <- SP.convertIfNonNull val $ \val' -> do
val'' <- (newPtr Hook) val'
return val''
return result
setHookNext :: MonadIO m => Hook -> Ptr Hook -> m ()
setHookNext s val = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 8) (val :: Ptr Hook)
clearHookNext :: MonadIO m => Hook -> m ()
clearHookNext s = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 8) (FP.nullPtr :: Ptr Hook)
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data HookNextFieldInfo
instance AttrInfo HookNextFieldInfo where
type AttrAllowedOps HookNextFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint HookNextFieldInfo = (~) (Ptr Hook)
type AttrBaseTypeConstraint HookNextFieldInfo = (~) Hook
type AttrGetType HookNextFieldInfo = Maybe Hook
type AttrLabel HookNextFieldInfo = "next"
type AttrOrigin HookNextFieldInfo = Hook
attrGet _ = getHookNext
attrSet _ = setHookNext
attrConstruct = undefined
attrClear _ = clearHookNext
hook_next :: AttrLabelProxy "next"
hook_next = AttrLabelProxy
#endif
getHookPrev :: MonadIO m => Hook -> m (Maybe Hook)
getHookPrev s = liftIO $ withManagedPtr s $ \ptr -> do
val <- peek (ptr `plusPtr` 16) :: IO (Ptr Hook)
result <- SP.convertIfNonNull val $ \val' -> do
val'' <- (newPtr Hook) val'
return val''
return result
setHookPrev :: MonadIO m => Hook -> Ptr Hook -> m ()
setHookPrev s val = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 16) (val :: Ptr Hook)
clearHookPrev :: MonadIO m => Hook -> m ()
clearHookPrev s = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 16) (FP.nullPtr :: Ptr Hook)
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data HookPrevFieldInfo
instance AttrInfo HookPrevFieldInfo where
type AttrAllowedOps HookPrevFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint HookPrevFieldInfo = (~) (Ptr Hook)
type AttrBaseTypeConstraint HookPrevFieldInfo = (~) Hook
type AttrGetType HookPrevFieldInfo = Maybe Hook
type AttrLabel HookPrevFieldInfo = "prev"
type AttrOrigin HookPrevFieldInfo = Hook
attrGet _ = getHookPrev
attrSet _ = setHookPrev
attrConstruct = undefined
attrClear _ = clearHookPrev
hook_prev :: AttrLabelProxy "prev"
hook_prev = AttrLabelProxy
#endif
getHookRefCount :: MonadIO m => Hook -> m Word32
getHookRefCount s = liftIO $ withManagedPtr s $ \ptr -> do
val <- peek (ptr `plusPtr` 24) :: IO Word32
return val
setHookRefCount :: MonadIO m => Hook -> Word32 -> m ()
setHookRefCount s val = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 24) (val :: Word32)
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data HookRefCountFieldInfo
instance AttrInfo HookRefCountFieldInfo where
type AttrAllowedOps HookRefCountFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint HookRefCountFieldInfo = (~) Word32
type AttrBaseTypeConstraint HookRefCountFieldInfo = (~) Hook
type AttrGetType HookRefCountFieldInfo = Word32
type AttrLabel HookRefCountFieldInfo = "ref_count"
type AttrOrigin HookRefCountFieldInfo = Hook
attrGet _ = getHookRefCount
attrSet _ = setHookRefCount
attrConstruct = undefined
attrClear _ = undefined
hook_refCount :: AttrLabelProxy "refCount"
hook_refCount = AttrLabelProxy
#endif
getHookHookId :: MonadIO m => Hook -> m CULong
getHookHookId s = liftIO $ withManagedPtr s $ \ptr -> do
val <- peek (ptr `plusPtr` 32) :: IO CULong
return val
setHookHookId :: MonadIO m => Hook -> CULong -> m ()
setHookHookId s val = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 32) (val :: CULong)
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data HookHookIdFieldInfo
instance AttrInfo HookHookIdFieldInfo where
type AttrAllowedOps HookHookIdFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint HookHookIdFieldInfo = (~) CULong
type AttrBaseTypeConstraint HookHookIdFieldInfo = (~) Hook
type AttrGetType HookHookIdFieldInfo = CULong
type AttrLabel HookHookIdFieldInfo = "hook_id"
type AttrOrigin HookHookIdFieldInfo = Hook
attrGet _ = getHookHookId
attrSet _ = setHookHookId
attrConstruct = undefined
attrClear _ = undefined
hook_hookId :: AttrLabelProxy "hookId"
hook_hookId = AttrLabelProxy
#endif
getHookFlags :: MonadIO m => Hook -> m Word32
getHookFlags s = liftIO $ withManagedPtr s $ \ptr -> do
val <- peek (ptr `plusPtr` 40) :: IO Word32
return val
setHookFlags :: MonadIO m => Hook -> Word32 -> m ()
setHookFlags s val = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 40) (val :: Word32)
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data HookFlagsFieldInfo
instance AttrInfo HookFlagsFieldInfo where
type AttrAllowedOps HookFlagsFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint HookFlagsFieldInfo = (~) Word32
type AttrBaseTypeConstraint HookFlagsFieldInfo = (~) Hook
type AttrGetType HookFlagsFieldInfo = Word32
type AttrLabel HookFlagsFieldInfo = "flags"
type AttrOrigin HookFlagsFieldInfo = Hook
attrGet _ = getHookFlags
attrSet _ = setHookFlags
attrConstruct = undefined
attrClear _ = undefined
hook_flags :: AttrLabelProxy "flags"
hook_flags = AttrLabelProxy
#endif
getHookFunc :: MonadIO m => Hook -> m (Ptr ())
getHookFunc s = liftIO $ withManagedPtr s $ \ptr -> do
val <- peek (ptr `plusPtr` 48) :: IO (Ptr ())
return val
setHookFunc :: MonadIO m => Hook -> Ptr () -> m ()
setHookFunc s val = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 48) (val :: Ptr ())
clearHookFunc :: MonadIO m => Hook -> m ()
clearHookFunc s = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 48) (FP.nullPtr :: Ptr ())
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data HookFuncFieldInfo
instance AttrInfo HookFuncFieldInfo where
type AttrAllowedOps HookFuncFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint HookFuncFieldInfo = (~) (Ptr ())
type AttrBaseTypeConstraint HookFuncFieldInfo = (~) Hook
type AttrGetType HookFuncFieldInfo = Ptr ()
type AttrLabel HookFuncFieldInfo = "func"
type AttrOrigin HookFuncFieldInfo = Hook
attrGet _ = getHookFunc
attrSet _ = setHookFunc
attrConstruct = undefined
attrClear _ = clearHookFunc
hook_func :: AttrLabelProxy "func"
hook_func = AttrLabelProxy
#endif
getHookDestroy :: MonadIO m => Hook -> m (Maybe GLib.Callbacks.DestroyNotify)
getHookDestroy s = liftIO $ withManagedPtr s $ \ptr -> do
val <- peek (ptr `plusPtr` 56) :: IO (FunPtr GLib.Callbacks.C_DestroyNotify)
result <- SP.convertFunPtrIfNonNull val $ \val' -> do
let val'' = GLib.Callbacks.dynamic_DestroyNotify val'
return val''
return result
setHookDestroy :: MonadIO m => Hook -> FunPtr GLib.Callbacks.C_DestroyNotify -> m ()
setHookDestroy s val = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 56) (val :: FunPtr GLib.Callbacks.C_DestroyNotify)
clearHookDestroy :: MonadIO m => Hook -> m ()
clearHookDestroy s = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 56) (FP.nullFunPtr :: FunPtr GLib.Callbacks.C_DestroyNotify)
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data HookDestroyFieldInfo
instance AttrInfo HookDestroyFieldInfo where
type AttrAllowedOps HookDestroyFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint HookDestroyFieldInfo = (~) (FunPtr GLib.Callbacks.C_DestroyNotify)
type AttrBaseTypeConstraint HookDestroyFieldInfo = (~) Hook
type AttrGetType HookDestroyFieldInfo = Maybe GLib.Callbacks.DestroyNotify
type AttrLabel HookDestroyFieldInfo = "destroy"
type AttrOrigin HookDestroyFieldInfo = Hook
attrGet _ = getHookDestroy
attrSet _ = setHookDestroy
attrConstruct = undefined
attrClear _ = clearHookDestroy
hook_destroy :: AttrLabelProxy "destroy"
hook_destroy = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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, *)])
#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 newHook sibling = liftIO $ do
newHook' <- unsafeManagedPtrGetPtr newHook
sibling' <- unsafeManagedPtrGetPtr sibling
result <- g_hook_compare_ids newHook' sibling'
touchManagedPtr newHook
touchManagedPtr sibling
return result
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data HookCompareIdsMethodInfo
instance (signature ~ (Hook -> m Int32), MonadIO m) => O.MethodInfo HookCompareIdsMethodInfo Hook signature where
overloadedMethod _ = 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 hookList hookId = liftIO $ do
hookList' <- unsafeManagedPtrGetPtr hookList
result <- g_hook_destroy hookList' hookId
let result' = (/= 0) result
touchManagedPtr hookList
return result'
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
#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 hookList hook = liftIO $ do
hookList' <- unsafeManagedPtrGetPtr hookList
hook' <- unsafeManagedPtrGetPtr hook
g_hook_destroy_link hookList' hook'
touchManagedPtr hookList
touchManagedPtr hook
return ()
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
#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 hookList hook = liftIO $ do
hookList' <- unsafeManagedPtrGetPtr hookList
hook' <- unsafeManagedPtrGetPtr hook
g_hook_free hookList' hook'
touchManagedPtr hookList
touchManagedPtr hook
return ()
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
#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 hookList sibling hook = liftIO $ do
hookList' <- unsafeManagedPtrGetPtr hookList
maybeSibling <- case sibling of
Nothing -> return nullPtr
Just jSibling -> do
jSibling' <- unsafeManagedPtrGetPtr jSibling
return jSibling'
hook' <- unsafeManagedPtrGetPtr hook
g_hook_insert_before hookList' maybeSibling hook'
touchManagedPtr hookList
whenJust sibling touchManagedPtr
touchManagedPtr hook
return ()
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
#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 hookList hook = liftIO $ do
hookList' <- unsafeManagedPtrGetPtr hookList
hook' <- unsafeManagedPtrGetPtr hook
g_hook_prepend hookList' hook'
touchManagedPtr hookList
touchManagedPtr hook
return ()
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
#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 hookList hook = liftIO $ do
hookList' <- unsafeManagedPtrGetPtr hookList
hook' <- unsafeManagedPtrGetPtr hook
g_hook_unref hookList' hook'
touchManagedPtr hookList
touchManagedPtr hook
return ()
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
#endif
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
type family ResolveHookMethod (t :: Symbol) (o :: *) :: * where
ResolveHookMethod "compareIds" o = HookCompareIdsMethodInfo
ResolveHookMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveHookMethod t Hook, O.MethodInfo info Hook p) => O.IsLabelProxy t (Hook -> p) where
fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolveHookMethod t Hook, O.MethodInfo info Hook p) => O.IsLabel t (Hook -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#else
fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif
#endif
#endif