{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.GObject.Structs.TypeValueTable
(
TypeValueTable(..) ,
newZeroTypeValueTable ,
#if defined(ENABLE_OVERLOADING)
ResolveTypeValueTableMethod ,
#endif
clearTypeValueTableCollectFormat ,
getTypeValueTableCollectFormat ,
setTypeValueTableCollectFormat ,
#if defined(ENABLE_OVERLOADING)
typeValueTable_collectFormat ,
#endif
clearTypeValueTableCollectValue ,
getTypeValueTableCollectValue ,
setTypeValueTableCollectValue ,
#if defined(ENABLE_OVERLOADING)
typeValueTable_collectValue ,
#endif
clearTypeValueTableLcopyFormat ,
getTypeValueTableLcopyFormat ,
setTypeValueTableLcopyFormat ,
#if defined(ENABLE_OVERLOADING)
typeValueTable_lcopyFormat ,
#endif
clearTypeValueTableLcopyValue ,
getTypeValueTableLcopyValue ,
setTypeValueTableLcopyValue ,
#if defined(ENABLE_OVERLOADING)
typeValueTable_lcopyValue ,
#endif
clearTypeValueTableValueCopy ,
getTypeValueTableValueCopy ,
setTypeValueTableValueCopy ,
#if defined(ENABLE_OVERLOADING)
typeValueTable_valueCopy ,
#endif
clearTypeValueTableValueFree ,
getTypeValueTableValueFree ,
setTypeValueTableValueFree ,
#if defined(ENABLE_OVERLOADING)
typeValueTable_valueFree ,
#endif
clearTypeValueTableValueInit ,
getTypeValueTableValueInit ,
setTypeValueTableValueInit ,
#if defined(ENABLE_OVERLOADING)
typeValueTable_valueInit ,
#endif
clearTypeValueTableValuePeekPointer ,
getTypeValueTableValuePeekPointer ,
setTypeValueTableValuePeekPointer ,
#if defined(ENABLE_OVERLOADING)
typeValueTable_valuePeekPointer ,
#endif
) 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.GObject.Callbacks as GObject.Callbacks
newtype TypeValueTable = TypeValueTable (SP.ManagedPtr TypeValueTable)
deriving (TypeValueTable -> TypeValueTable -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TypeValueTable -> TypeValueTable -> Bool
$c/= :: TypeValueTable -> TypeValueTable -> Bool
== :: TypeValueTable -> TypeValueTable -> Bool
$c== :: TypeValueTable -> TypeValueTable -> Bool
Eq)
instance SP.ManagedPtrNewtype TypeValueTable where
toManagedPtr :: TypeValueTable -> ManagedPtr TypeValueTable
toManagedPtr (TypeValueTable ManagedPtr TypeValueTable
p) = ManagedPtr TypeValueTable
p
instance BoxedPtr TypeValueTable where
boxedPtrCopy :: TypeValueTable -> IO TypeValueTable
boxedPtrCopy = \TypeValueTable
p -> forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr TypeValueTable
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 TypeValueTable -> TypeValueTable
TypeValueTable)
boxedPtrFree :: TypeValueTable -> IO ()
boxedPtrFree = \TypeValueTable
x -> forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
SP.withManagedPtr TypeValueTable
x forall a. Ptr a -> IO ()
SP.freeMem
instance CallocPtr TypeValueTable where
boxedPtrCalloc :: IO (Ptr TypeValueTable)
boxedPtrCalloc = forall a. Int -> IO (Ptr a)
callocBytes Int
64
newZeroTypeValueTable :: MonadIO m => m TypeValueTable
newZeroTypeValueTable :: forall (m :: * -> *). MonadIO m => m TypeValueTable
newZeroTypeValueTable = 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 TypeValueTable -> TypeValueTable
TypeValueTable
instance tag ~ 'AttrSet => Constructible TypeValueTable tag where
new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr TypeValueTable -> TypeValueTable)
-> [AttrOp TypeValueTable tag] -> m TypeValueTable
new ManagedPtr TypeValueTable -> TypeValueTable
_ [AttrOp TypeValueTable tag]
attrs = do
TypeValueTable
o <- forall (m :: * -> *). MonadIO m => m TypeValueTable
newZeroTypeValueTable
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set TypeValueTable
o [AttrOp TypeValueTable tag]
attrs
forall (m :: * -> *) a. Monad m => a -> m a
return TypeValueTable
o
getTypeValueTableValueInit :: MonadIO m => TypeValueTable -> m (Maybe GObject.Callbacks.TypeValueTableValueInitFieldCallback)
getTypeValueTableValueInit :: forall (m :: * -> *).
MonadIO m =>
TypeValueTable -> m (Maybe TypeValueTableValueInitFieldCallback)
getTypeValueTableValueInit TypeValueTable
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 TypeValueTable
s forall a b. (a -> b) -> a -> b
$ \Ptr TypeValueTable
ptr -> do
FunPtr C_TypeValueTableValueInitFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr TypeValueTable
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) :: IO (FunPtr GObject.Callbacks.C_TypeValueTableValueInitFieldCallback)
Maybe TypeValueTableValueInitFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_TypeValueTableValueInitFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_TypeValueTableValueInitFieldCallback
val' -> do
let val'' :: TypeValueTableValueInitFieldCallback
val'' = forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
FunPtr C_TypeValueTableValueInitFieldCallback -> GValue -> m ()
GObject.Callbacks.dynamic_TypeValueTableValueInitFieldCallback FunPtr C_TypeValueTableValueInitFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return TypeValueTableValueInitFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe TypeValueTableValueInitFieldCallback
result
setTypeValueTableValueInit :: MonadIO m => TypeValueTable -> FunPtr GObject.Callbacks.C_TypeValueTableValueInitFieldCallback -> m ()
setTypeValueTableValueInit :: forall (m :: * -> *).
MonadIO m =>
TypeValueTable
-> FunPtr C_TypeValueTableValueInitFieldCallback -> m ()
setTypeValueTableValueInit TypeValueTable
s FunPtr C_TypeValueTableValueInitFieldCallback
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 TypeValueTable
s forall a b. (a -> b) -> a -> b
$ \Ptr TypeValueTable
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TypeValueTable
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (FunPtr C_TypeValueTableValueInitFieldCallback
val :: FunPtr GObject.Callbacks.C_TypeValueTableValueInitFieldCallback)
clearTypeValueTableValueInit :: MonadIO m => TypeValueTable -> m ()
clearTypeValueTableValueInit :: forall (m :: * -> *). MonadIO m => TypeValueTable -> m ()
clearTypeValueTableValueInit TypeValueTable
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 TypeValueTable
s forall a b. (a -> b) -> a -> b
$ \Ptr TypeValueTable
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TypeValueTable
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr GObject.Callbacks.C_TypeValueTableValueInitFieldCallback)
#if defined(ENABLE_OVERLOADING)
data TypeValueTableValueInitFieldInfo
instance AttrInfo TypeValueTableValueInitFieldInfo where
type AttrBaseTypeConstraint TypeValueTableValueInitFieldInfo = (~) TypeValueTable
type AttrAllowedOps TypeValueTableValueInitFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint TypeValueTableValueInitFieldInfo = (~) (FunPtr GObject.Callbacks.C_TypeValueTableValueInitFieldCallback)
type AttrTransferTypeConstraint TypeValueTableValueInitFieldInfo = (~)GObject.Callbacks.TypeValueTableValueInitFieldCallback
type AttrTransferType TypeValueTableValueInitFieldInfo = (FunPtr GObject.Callbacks.C_TypeValueTableValueInitFieldCallback)
type AttrGetType TypeValueTableValueInitFieldInfo = Maybe GObject.Callbacks.TypeValueTableValueInitFieldCallback
type AttrLabel TypeValueTableValueInitFieldInfo = "value_init"
type AttrOrigin TypeValueTableValueInitFieldInfo = TypeValueTable
attrGet = getTypeValueTableValueInit
attrSet = setTypeValueTableValueInit
attrConstruct = undefined
attrClear = clearTypeValueTableValueInit
attrTransfer _ v = do
GObject.Callbacks.mk_TypeValueTableValueInitFieldCallback (GObject.Callbacks.wrap_TypeValueTableValueInitFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GObject.Structs.TypeValueTable.valueInit"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.28/docs/GI-GObject-Structs-TypeValueTable.html#g:attr:valueInit"
})
typeValueTable_valueInit :: AttrLabelProxy "valueInit"
typeValueTable_valueInit = AttrLabelProxy
#endif
getTypeValueTableValueFree :: MonadIO m => TypeValueTable -> m (Maybe GObject.Callbacks.TypeValueTableValueFreeFieldCallback)
getTypeValueTableValueFree :: forall (m :: * -> *).
MonadIO m =>
TypeValueTable -> m (Maybe TypeValueTableValueInitFieldCallback)
getTypeValueTableValueFree TypeValueTable
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 TypeValueTable
s forall a b. (a -> b) -> a -> b
$ \Ptr TypeValueTable
ptr -> do
FunPtr C_TypeValueTableValueInitFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr TypeValueTable
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) :: IO (FunPtr GObject.Callbacks.C_TypeValueTableValueFreeFieldCallback)
Maybe TypeValueTableValueInitFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_TypeValueTableValueInitFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_TypeValueTableValueInitFieldCallback
val' -> do
let val'' :: TypeValueTableValueInitFieldCallback
val'' = forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
FunPtr C_TypeValueTableValueInitFieldCallback -> GValue -> m ()
GObject.Callbacks.dynamic_TypeValueTableValueFreeFieldCallback FunPtr C_TypeValueTableValueInitFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return TypeValueTableValueInitFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe TypeValueTableValueInitFieldCallback
result
setTypeValueTableValueFree :: MonadIO m => TypeValueTable -> FunPtr GObject.Callbacks.C_TypeValueTableValueFreeFieldCallback -> m ()
setTypeValueTableValueFree :: forall (m :: * -> *).
MonadIO m =>
TypeValueTable
-> FunPtr C_TypeValueTableValueInitFieldCallback -> m ()
setTypeValueTableValueFree TypeValueTable
s FunPtr C_TypeValueTableValueInitFieldCallback
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 TypeValueTable
s forall a b. (a -> b) -> a -> b
$ \Ptr TypeValueTable
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TypeValueTable
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (FunPtr C_TypeValueTableValueInitFieldCallback
val :: FunPtr GObject.Callbacks.C_TypeValueTableValueFreeFieldCallback)
clearTypeValueTableValueFree :: MonadIO m => TypeValueTable -> m ()
clearTypeValueTableValueFree :: forall (m :: * -> *). MonadIO m => TypeValueTable -> m ()
clearTypeValueTableValueFree TypeValueTable
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 TypeValueTable
s forall a b. (a -> b) -> a -> b
$ \Ptr TypeValueTable
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TypeValueTable
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr GObject.Callbacks.C_TypeValueTableValueFreeFieldCallback)
#if defined(ENABLE_OVERLOADING)
data TypeValueTableValueFreeFieldInfo
instance AttrInfo TypeValueTableValueFreeFieldInfo where
type AttrBaseTypeConstraint TypeValueTableValueFreeFieldInfo = (~) TypeValueTable
type AttrAllowedOps TypeValueTableValueFreeFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint TypeValueTableValueFreeFieldInfo = (~) (FunPtr GObject.Callbacks.C_TypeValueTableValueFreeFieldCallback)
type AttrTransferTypeConstraint TypeValueTableValueFreeFieldInfo = (~)GObject.Callbacks.TypeValueTableValueFreeFieldCallback
type AttrTransferType TypeValueTableValueFreeFieldInfo = (FunPtr GObject.Callbacks.C_TypeValueTableValueFreeFieldCallback)
type AttrGetType TypeValueTableValueFreeFieldInfo = Maybe GObject.Callbacks.TypeValueTableValueFreeFieldCallback
type AttrLabel TypeValueTableValueFreeFieldInfo = "value_free"
type AttrOrigin TypeValueTableValueFreeFieldInfo = TypeValueTable
attrGet = getTypeValueTableValueFree
attrSet = setTypeValueTableValueFree
attrConstruct = undefined
attrClear = clearTypeValueTableValueFree
attrTransfer _ v = do
GObject.Callbacks.mk_TypeValueTableValueFreeFieldCallback (GObject.Callbacks.wrap_TypeValueTableValueFreeFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GObject.Structs.TypeValueTable.valueFree"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.28/docs/GI-GObject-Structs-TypeValueTable.html#g:attr:valueFree"
})
typeValueTable_valueFree :: AttrLabelProxy "valueFree"
typeValueTable_valueFree = AttrLabelProxy
#endif
getTypeValueTableValueCopy :: MonadIO m => TypeValueTable -> m (Maybe GObject.Callbacks.TypeValueTableValueCopyFieldCallback)
getTypeValueTableValueCopy :: forall (m :: * -> *).
MonadIO m =>
TypeValueTable -> m (Maybe TypeValueTableValueCopyFieldCallback)
getTypeValueTableValueCopy TypeValueTable
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 TypeValueTable
s forall a b. (a -> b) -> a -> b
$ \Ptr TypeValueTable
ptr -> do
FunPtr C_TypeValueTableValueCopyFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr TypeValueTable
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) :: IO (FunPtr GObject.Callbacks.C_TypeValueTableValueCopyFieldCallback)
Maybe TypeValueTableValueCopyFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_TypeValueTableValueCopyFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_TypeValueTableValueCopyFieldCallback
val' -> do
let val'' :: TypeValueTableValueCopyFieldCallback
val'' = forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
FunPtr C_TypeValueTableValueCopyFieldCallback
-> GValue -> GValue -> m ()
GObject.Callbacks.dynamic_TypeValueTableValueCopyFieldCallback FunPtr C_TypeValueTableValueCopyFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return TypeValueTableValueCopyFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe TypeValueTableValueCopyFieldCallback
result
setTypeValueTableValueCopy :: MonadIO m => TypeValueTable -> FunPtr GObject.Callbacks.C_TypeValueTableValueCopyFieldCallback -> m ()
setTypeValueTableValueCopy :: forall (m :: * -> *).
MonadIO m =>
TypeValueTable
-> FunPtr C_TypeValueTableValueCopyFieldCallback -> m ()
setTypeValueTableValueCopy TypeValueTable
s FunPtr C_TypeValueTableValueCopyFieldCallback
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 TypeValueTable
s forall a b. (a -> b) -> a -> b
$ \Ptr TypeValueTable
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TypeValueTable
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (FunPtr C_TypeValueTableValueCopyFieldCallback
val :: FunPtr GObject.Callbacks.C_TypeValueTableValueCopyFieldCallback)
clearTypeValueTableValueCopy :: MonadIO m => TypeValueTable -> m ()
clearTypeValueTableValueCopy :: forall (m :: * -> *). MonadIO m => TypeValueTable -> m ()
clearTypeValueTableValueCopy TypeValueTable
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 TypeValueTable
s forall a b. (a -> b) -> a -> b
$ \Ptr TypeValueTable
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TypeValueTable
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr GObject.Callbacks.C_TypeValueTableValueCopyFieldCallback)
#if defined(ENABLE_OVERLOADING)
data TypeValueTableValueCopyFieldInfo
instance AttrInfo TypeValueTableValueCopyFieldInfo where
type AttrBaseTypeConstraint TypeValueTableValueCopyFieldInfo = (~) TypeValueTable
type AttrAllowedOps TypeValueTableValueCopyFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint TypeValueTableValueCopyFieldInfo = (~) (FunPtr GObject.Callbacks.C_TypeValueTableValueCopyFieldCallback)
type AttrTransferTypeConstraint TypeValueTableValueCopyFieldInfo = (~)GObject.Callbacks.TypeValueTableValueCopyFieldCallback
type AttrTransferType TypeValueTableValueCopyFieldInfo = (FunPtr GObject.Callbacks.C_TypeValueTableValueCopyFieldCallback)
type AttrGetType TypeValueTableValueCopyFieldInfo = Maybe GObject.Callbacks.TypeValueTableValueCopyFieldCallback
type AttrLabel TypeValueTableValueCopyFieldInfo = "value_copy"
type AttrOrigin TypeValueTableValueCopyFieldInfo = TypeValueTable
attrGet = getTypeValueTableValueCopy
attrSet = setTypeValueTableValueCopy
attrConstruct = undefined
attrClear = clearTypeValueTableValueCopy
attrTransfer _ v = do
GObject.Callbacks.mk_TypeValueTableValueCopyFieldCallback (GObject.Callbacks.wrap_TypeValueTableValueCopyFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GObject.Structs.TypeValueTable.valueCopy"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.28/docs/GI-GObject-Structs-TypeValueTable.html#g:attr:valueCopy"
})
typeValueTable_valueCopy :: AttrLabelProxy "valueCopy"
typeValueTable_valueCopy = AttrLabelProxy
#endif
getTypeValueTableValuePeekPointer :: MonadIO m => TypeValueTable -> m (Maybe GObject.Callbacks.TypeValueTableValuePeekPointerFieldCallback)
getTypeValueTableValuePeekPointer :: forall (m :: * -> *).
MonadIO m =>
TypeValueTable
-> m (Maybe TypeValueTableValuePeekPointerFieldCallback)
getTypeValueTableValuePeekPointer TypeValueTable
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 TypeValueTable
s forall a b. (a -> b) -> a -> b
$ \Ptr TypeValueTable
ptr -> do
FunPtr C_TypeValueTableValuePeekPointerFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr TypeValueTable
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) :: IO (FunPtr GObject.Callbacks.C_TypeValueTableValuePeekPointerFieldCallback)
Maybe TypeValueTableValuePeekPointerFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_TypeValueTableValuePeekPointerFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_TypeValueTableValuePeekPointerFieldCallback
val' -> do
let val'' :: TypeValueTableValuePeekPointerFieldCallback
val'' = forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
FunPtr C_TypeValueTableValuePeekPointerFieldCallback
-> GValue -> m (Ptr ())
GObject.Callbacks.dynamic_TypeValueTableValuePeekPointerFieldCallback FunPtr C_TypeValueTableValuePeekPointerFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return TypeValueTableValuePeekPointerFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe TypeValueTableValuePeekPointerFieldCallback
result
setTypeValueTableValuePeekPointer :: MonadIO m => TypeValueTable -> FunPtr GObject.Callbacks.C_TypeValueTableValuePeekPointerFieldCallback -> m ()
setTypeValueTableValuePeekPointer :: forall (m :: * -> *).
MonadIO m =>
TypeValueTable
-> FunPtr C_TypeValueTableValuePeekPointerFieldCallback -> m ()
setTypeValueTableValuePeekPointer TypeValueTable
s FunPtr C_TypeValueTableValuePeekPointerFieldCallback
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 TypeValueTable
s forall a b. (a -> b) -> a -> b
$ \Ptr TypeValueTable
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TypeValueTable
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) (FunPtr C_TypeValueTableValuePeekPointerFieldCallback
val :: FunPtr GObject.Callbacks.C_TypeValueTableValuePeekPointerFieldCallback)
clearTypeValueTableValuePeekPointer :: MonadIO m => TypeValueTable -> m ()
clearTypeValueTableValuePeekPointer :: forall (m :: * -> *). MonadIO m => TypeValueTable -> m ()
clearTypeValueTableValuePeekPointer TypeValueTable
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 TypeValueTable
s forall a b. (a -> b) -> a -> b
$ \Ptr TypeValueTable
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TypeValueTable
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr GObject.Callbacks.C_TypeValueTableValuePeekPointerFieldCallback)
#if defined(ENABLE_OVERLOADING)
data TypeValueTableValuePeekPointerFieldInfo
instance AttrInfo TypeValueTableValuePeekPointerFieldInfo where
type AttrBaseTypeConstraint TypeValueTableValuePeekPointerFieldInfo = (~) TypeValueTable
type AttrAllowedOps TypeValueTableValuePeekPointerFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint TypeValueTableValuePeekPointerFieldInfo = (~) (FunPtr GObject.Callbacks.C_TypeValueTableValuePeekPointerFieldCallback)
type AttrTransferTypeConstraint TypeValueTableValuePeekPointerFieldInfo = (~)GObject.Callbacks.TypeValueTableValuePeekPointerFieldCallback
type AttrTransferType TypeValueTableValuePeekPointerFieldInfo = (FunPtr GObject.Callbacks.C_TypeValueTableValuePeekPointerFieldCallback)
type AttrGetType TypeValueTableValuePeekPointerFieldInfo = Maybe GObject.Callbacks.TypeValueTableValuePeekPointerFieldCallback
type AttrLabel TypeValueTableValuePeekPointerFieldInfo = "value_peek_pointer"
type AttrOrigin TypeValueTableValuePeekPointerFieldInfo = TypeValueTable
attrGet = getTypeValueTableValuePeekPointer
attrSet = setTypeValueTableValuePeekPointer
attrConstruct = undefined
attrClear = clearTypeValueTableValuePeekPointer
attrTransfer _ v = do
GObject.Callbacks.mk_TypeValueTableValuePeekPointerFieldCallback (GObject.Callbacks.wrap_TypeValueTableValuePeekPointerFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GObject.Structs.TypeValueTable.valuePeekPointer"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.28/docs/GI-GObject-Structs-TypeValueTable.html#g:attr:valuePeekPointer"
})
typeValueTable_valuePeekPointer :: AttrLabelProxy "valuePeekPointer"
typeValueTable_valuePeekPointer = AttrLabelProxy
#endif
getTypeValueTableCollectFormat :: MonadIO m => TypeValueTable -> m (Maybe T.Text)
getTypeValueTableCollectFormat :: forall (m :: * -> *). MonadIO m => TypeValueTable -> m (Maybe Text)
getTypeValueTableCollectFormat TypeValueTable
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 TypeValueTable
s forall a b. (a -> b) -> a -> b
$ \Ptr TypeValueTable
ptr -> do
CString
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr TypeValueTable
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) :: IO CString
Maybe Text
result <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull CString
val forall a b. (a -> b) -> a -> b
$ \CString
val' -> do
Text
val'' <- HasCallStack => CString -> IO Text
cstringToText CString
val'
forall (m :: * -> *) a. Monad m => a -> m a
return Text
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
result
setTypeValueTableCollectFormat :: MonadIO m => TypeValueTable -> CString -> m ()
setTypeValueTableCollectFormat :: forall (m :: * -> *).
MonadIO m =>
TypeValueTable -> CString -> m ()
setTypeValueTableCollectFormat TypeValueTable
s CString
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 TypeValueTable
s forall a b. (a -> b) -> a -> b
$ \Ptr TypeValueTable
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TypeValueTable
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) (CString
val :: CString)
clearTypeValueTableCollectFormat :: MonadIO m => TypeValueTable -> m ()
clearTypeValueTableCollectFormat :: forall (m :: * -> *). MonadIO m => TypeValueTable -> m ()
clearTypeValueTableCollectFormat TypeValueTable
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 TypeValueTable
s forall a b. (a -> b) -> a -> b
$ \Ptr TypeValueTable
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TypeValueTable
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) (forall a. Ptr a
FP.nullPtr :: CString)
#if defined(ENABLE_OVERLOADING)
data TypeValueTableCollectFormatFieldInfo
instance AttrInfo TypeValueTableCollectFormatFieldInfo where
type AttrBaseTypeConstraint TypeValueTableCollectFormatFieldInfo = (~) TypeValueTable
type AttrAllowedOps TypeValueTableCollectFormatFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint TypeValueTableCollectFormatFieldInfo = (~) CString
type AttrTransferTypeConstraint TypeValueTableCollectFormatFieldInfo = (~)CString
type AttrTransferType TypeValueTableCollectFormatFieldInfo = CString
type AttrGetType TypeValueTableCollectFormatFieldInfo = Maybe T.Text
type AttrLabel TypeValueTableCollectFormatFieldInfo = "collect_format"
type AttrOrigin TypeValueTableCollectFormatFieldInfo = TypeValueTable
attrGet = getTypeValueTableCollectFormat
attrSet = setTypeValueTableCollectFormat
attrConstruct = undefined
attrClear = clearTypeValueTableCollectFormat
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GObject.Structs.TypeValueTable.collectFormat"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.28/docs/GI-GObject-Structs-TypeValueTable.html#g:attr:collectFormat"
})
typeValueTable_collectFormat :: AttrLabelProxy "collectFormat"
typeValueTable_collectFormat = AttrLabelProxy
#endif
getTypeValueTableCollectValue :: MonadIO m => TypeValueTable -> m (Maybe GObject.Callbacks.TypeValueTableCollectValueFieldCallback)
getTypeValueTableCollectValue :: forall (m :: * -> *).
MonadIO m =>
TypeValueTable -> m (Maybe TypeValueTableCollectValueFieldCallback)
getTypeValueTableCollectValue TypeValueTable
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 TypeValueTable
s forall a b. (a -> b) -> a -> b
$ \Ptr TypeValueTable
ptr -> do
FunPtr C_TypeValueTableCollectValueFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr TypeValueTable
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
40) :: IO (FunPtr GObject.Callbacks.C_TypeValueTableCollectValueFieldCallback)
Maybe TypeValueTableCollectValueFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_TypeValueTableCollectValueFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_TypeValueTableCollectValueFieldCallback
val' -> do
let val'' :: TypeValueTableCollectValueFieldCallback
val'' = forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
FunPtr C_TypeValueTableCollectValueFieldCallback
-> GValue -> Word32 -> TypeCValue -> Word32 -> m Text
GObject.Callbacks.dynamic_TypeValueTableCollectValueFieldCallback FunPtr C_TypeValueTableCollectValueFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return TypeValueTableCollectValueFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe TypeValueTableCollectValueFieldCallback
result
setTypeValueTableCollectValue :: MonadIO m => TypeValueTable -> FunPtr GObject.Callbacks.C_TypeValueTableCollectValueFieldCallback -> m ()
setTypeValueTableCollectValue :: forall (m :: * -> *).
MonadIO m =>
TypeValueTable
-> FunPtr C_TypeValueTableCollectValueFieldCallback -> m ()
setTypeValueTableCollectValue TypeValueTable
s FunPtr C_TypeValueTableCollectValueFieldCallback
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 TypeValueTable
s forall a b. (a -> b) -> a -> b
$ \Ptr TypeValueTable
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TypeValueTable
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
40) (FunPtr C_TypeValueTableCollectValueFieldCallback
val :: FunPtr GObject.Callbacks.C_TypeValueTableCollectValueFieldCallback)
clearTypeValueTableCollectValue :: MonadIO m => TypeValueTable -> m ()
clearTypeValueTableCollectValue :: forall (m :: * -> *). MonadIO m => TypeValueTable -> m ()
clearTypeValueTableCollectValue TypeValueTable
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 TypeValueTable
s forall a b. (a -> b) -> a -> b
$ \Ptr TypeValueTable
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TypeValueTable
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
40) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr GObject.Callbacks.C_TypeValueTableCollectValueFieldCallback)
#if defined(ENABLE_OVERLOADING)
data TypeValueTableCollectValueFieldInfo
instance AttrInfo TypeValueTableCollectValueFieldInfo where
type AttrBaseTypeConstraint TypeValueTableCollectValueFieldInfo = (~) TypeValueTable
type AttrAllowedOps TypeValueTableCollectValueFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint TypeValueTableCollectValueFieldInfo = (~) (FunPtr GObject.Callbacks.C_TypeValueTableCollectValueFieldCallback)
type AttrTransferTypeConstraint TypeValueTableCollectValueFieldInfo = (~)GObject.Callbacks.TypeValueTableCollectValueFieldCallback
type AttrTransferType TypeValueTableCollectValueFieldInfo = (FunPtr GObject.Callbacks.C_TypeValueTableCollectValueFieldCallback)
type AttrGetType TypeValueTableCollectValueFieldInfo = Maybe GObject.Callbacks.TypeValueTableCollectValueFieldCallback
type AttrLabel TypeValueTableCollectValueFieldInfo = "collect_value"
type AttrOrigin TypeValueTableCollectValueFieldInfo = TypeValueTable
attrGet = getTypeValueTableCollectValue
attrSet = setTypeValueTableCollectValue
attrConstruct = undefined
attrClear = clearTypeValueTableCollectValue
attrTransfer _ v = do
GObject.Callbacks.mk_TypeValueTableCollectValueFieldCallback (GObject.Callbacks.wrap_TypeValueTableCollectValueFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GObject.Structs.TypeValueTable.collectValue"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.28/docs/GI-GObject-Structs-TypeValueTable.html#g:attr:collectValue"
})
typeValueTable_collectValue :: AttrLabelProxy "collectValue"
typeValueTable_collectValue = AttrLabelProxy
#endif
getTypeValueTableLcopyFormat :: MonadIO m => TypeValueTable -> m (Maybe T.Text)
getTypeValueTableLcopyFormat :: forall (m :: * -> *). MonadIO m => TypeValueTable -> m (Maybe Text)
getTypeValueTableLcopyFormat TypeValueTable
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 TypeValueTable
s forall a b. (a -> b) -> a -> b
$ \Ptr TypeValueTable
ptr -> do
CString
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr TypeValueTable
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
48) :: IO CString
Maybe Text
result <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull CString
val forall a b. (a -> b) -> a -> b
$ \CString
val' -> do
Text
val'' <- HasCallStack => CString -> IO Text
cstringToText CString
val'
forall (m :: * -> *) a. Monad m => a -> m a
return Text
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
result
setTypeValueTableLcopyFormat :: MonadIO m => TypeValueTable -> CString -> m ()
setTypeValueTableLcopyFormat :: forall (m :: * -> *).
MonadIO m =>
TypeValueTable -> CString -> m ()
setTypeValueTableLcopyFormat TypeValueTable
s CString
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 TypeValueTable
s forall a b. (a -> b) -> a -> b
$ \Ptr TypeValueTable
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TypeValueTable
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
48) (CString
val :: CString)
clearTypeValueTableLcopyFormat :: MonadIO m => TypeValueTable -> m ()
clearTypeValueTableLcopyFormat :: forall (m :: * -> *). MonadIO m => TypeValueTable -> m ()
clearTypeValueTableLcopyFormat TypeValueTable
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 TypeValueTable
s forall a b. (a -> b) -> a -> b
$ \Ptr TypeValueTable
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TypeValueTable
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
48) (forall a. Ptr a
FP.nullPtr :: CString)
#if defined(ENABLE_OVERLOADING)
data TypeValueTableLcopyFormatFieldInfo
instance AttrInfo TypeValueTableLcopyFormatFieldInfo where
type AttrBaseTypeConstraint TypeValueTableLcopyFormatFieldInfo = (~) TypeValueTable
type AttrAllowedOps TypeValueTableLcopyFormatFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint TypeValueTableLcopyFormatFieldInfo = (~) CString
type AttrTransferTypeConstraint TypeValueTableLcopyFormatFieldInfo = (~)CString
type AttrTransferType TypeValueTableLcopyFormatFieldInfo = CString
type AttrGetType TypeValueTableLcopyFormatFieldInfo = Maybe T.Text
type AttrLabel TypeValueTableLcopyFormatFieldInfo = "lcopy_format"
type AttrOrigin TypeValueTableLcopyFormatFieldInfo = TypeValueTable
attrGet = getTypeValueTableLcopyFormat
attrSet = setTypeValueTableLcopyFormat
attrConstruct = undefined
attrClear = clearTypeValueTableLcopyFormat
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GObject.Structs.TypeValueTable.lcopyFormat"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.28/docs/GI-GObject-Structs-TypeValueTable.html#g:attr:lcopyFormat"
})
typeValueTable_lcopyFormat :: AttrLabelProxy "lcopyFormat"
typeValueTable_lcopyFormat = AttrLabelProxy
#endif
getTypeValueTableLcopyValue :: MonadIO m => TypeValueTable -> m (Maybe GObject.Callbacks.TypeValueTableLcopyValueFieldCallback)
getTypeValueTableLcopyValue :: forall (m :: * -> *).
MonadIO m =>
TypeValueTable -> m (Maybe TypeValueTableCollectValueFieldCallback)
getTypeValueTableLcopyValue TypeValueTable
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 TypeValueTable
s forall a b. (a -> b) -> a -> b
$ \Ptr TypeValueTable
ptr -> do
FunPtr C_TypeValueTableCollectValueFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr TypeValueTable
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
56) :: IO (FunPtr GObject.Callbacks.C_TypeValueTableLcopyValueFieldCallback)
Maybe TypeValueTableCollectValueFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_TypeValueTableCollectValueFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_TypeValueTableCollectValueFieldCallback
val' -> do
let val'' :: TypeValueTableCollectValueFieldCallback
val'' = forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
FunPtr C_TypeValueTableCollectValueFieldCallback
-> GValue -> Word32 -> TypeCValue -> Word32 -> m Text
GObject.Callbacks.dynamic_TypeValueTableLcopyValueFieldCallback FunPtr C_TypeValueTableCollectValueFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return TypeValueTableCollectValueFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe TypeValueTableCollectValueFieldCallback
result
setTypeValueTableLcopyValue :: MonadIO m => TypeValueTable -> FunPtr GObject.Callbacks.C_TypeValueTableLcopyValueFieldCallback -> m ()
setTypeValueTableLcopyValue :: forall (m :: * -> *).
MonadIO m =>
TypeValueTable
-> FunPtr C_TypeValueTableCollectValueFieldCallback -> m ()
setTypeValueTableLcopyValue TypeValueTable
s FunPtr C_TypeValueTableCollectValueFieldCallback
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 TypeValueTable
s forall a b. (a -> b) -> a -> b
$ \Ptr TypeValueTable
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TypeValueTable
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
56) (FunPtr C_TypeValueTableCollectValueFieldCallback
val :: FunPtr GObject.Callbacks.C_TypeValueTableLcopyValueFieldCallback)
clearTypeValueTableLcopyValue :: MonadIO m => TypeValueTable -> m ()
clearTypeValueTableLcopyValue :: forall (m :: * -> *). MonadIO m => TypeValueTable -> m ()
clearTypeValueTableLcopyValue TypeValueTable
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 TypeValueTable
s forall a b. (a -> b) -> a -> b
$ \Ptr TypeValueTable
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TypeValueTable
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
56) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr GObject.Callbacks.C_TypeValueTableLcopyValueFieldCallback)
#if defined(ENABLE_OVERLOADING)
data TypeValueTableLcopyValueFieldInfo
instance AttrInfo TypeValueTableLcopyValueFieldInfo where
type AttrBaseTypeConstraint TypeValueTableLcopyValueFieldInfo = (~) TypeValueTable
type AttrAllowedOps TypeValueTableLcopyValueFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint TypeValueTableLcopyValueFieldInfo = (~) (FunPtr GObject.Callbacks.C_TypeValueTableLcopyValueFieldCallback)
type AttrTransferTypeConstraint TypeValueTableLcopyValueFieldInfo = (~)GObject.Callbacks.TypeValueTableLcopyValueFieldCallback
type AttrTransferType TypeValueTableLcopyValueFieldInfo = (FunPtr GObject.Callbacks.C_TypeValueTableLcopyValueFieldCallback)
type AttrGetType TypeValueTableLcopyValueFieldInfo = Maybe GObject.Callbacks.TypeValueTableLcopyValueFieldCallback
type AttrLabel TypeValueTableLcopyValueFieldInfo = "lcopy_value"
type AttrOrigin TypeValueTableLcopyValueFieldInfo = TypeValueTable
attrGet = getTypeValueTableLcopyValue
attrSet = setTypeValueTableLcopyValue
attrConstruct = undefined
attrClear = clearTypeValueTableLcopyValue
attrTransfer _ v = do
GObject.Callbacks.mk_TypeValueTableLcopyValueFieldCallback (GObject.Callbacks.wrap_TypeValueTableLcopyValueFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GObject.Structs.TypeValueTable.lcopyValue"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.28/docs/GI-GObject-Structs-TypeValueTable.html#g:attr:lcopyValue"
})
typeValueTable_lcopyValue :: AttrLabelProxy "lcopyValue"
typeValueTable_lcopyValue = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList TypeValueTable
type instance O.AttributeList TypeValueTable = TypeValueTableAttributeList
type TypeValueTableAttributeList = ('[ '("valueInit", TypeValueTableValueInitFieldInfo), '("valueFree", TypeValueTableValueFreeFieldInfo), '("valueCopy", TypeValueTableValueCopyFieldInfo), '("valuePeekPointer", TypeValueTableValuePeekPointerFieldInfo), '("collectFormat", TypeValueTableCollectFormatFieldInfo), '("collectValue", TypeValueTableCollectValueFieldInfo), '("lcopyFormat", TypeValueTableLcopyFormatFieldInfo), '("lcopyValue", TypeValueTableLcopyValueFieldInfo)] :: [(Symbol, DK.Type)])
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveTypeValueTableMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveTypeValueTableMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveTypeValueTableMethod t TypeValueTable, O.OverloadedMethod info TypeValueTable p) => OL.IsLabel t (TypeValueTable -> 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 ~ ResolveTypeValueTableMethod t TypeValueTable, O.OverloadedMethod info TypeValueTable p, R.HasField t TypeValueTable p) => R.HasField t TypeValueTable p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveTypeValueTableMethod t TypeValueTable, O.OverloadedMethodInfo info TypeValueTable) => OL.IsLabel t (O.MethodProxy info TypeValueTable) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif