{-# 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 Data.Word as DW
import qualified Data.Int as DI
import qualified Data.Bits as DB
import qualified System.Posix.Types as SPT
import qualified Foreign.C.Types as FCT
#if MIN_VERSION_base(4,18,0)
import qualified GI.GObject.Callbacks as GObject.Callbacks
#else
import qualified GI.GObject.Callbacks as GObject.Callbacks
#endif
newtype TypeValueTable = TypeValueTable (SP.ManagedPtr TypeValueTable)
deriving (TypeValueTable -> TypeValueTable -> Bool
(TypeValueTable -> TypeValueTable -> Bool)
-> (TypeValueTable -> TypeValueTable -> Bool) -> Eq TypeValueTable
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TypeValueTable -> TypeValueTable -> Bool
== :: TypeValueTable -> TypeValueTable -> Bool
$c/= :: TypeValueTable -> TypeValueTable -> Bool
/= :: 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 -> TypeValueTable
-> (Ptr TypeValueTable -> IO TypeValueTable) -> IO TypeValueTable
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr TypeValueTable
p (Int -> Ptr TypeValueTable -> IO (Ptr TypeValueTable)
forall a. (HasCallStack, CallocPtr a) => Int -> Ptr a -> IO (Ptr a)
copyBytes Int
64 (Ptr TypeValueTable -> IO (Ptr TypeValueTable))
-> (Ptr TypeValueTable -> IO TypeValueTable)
-> Ptr TypeValueTable
-> IO TypeValueTable
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (ManagedPtr TypeValueTable -> TypeValueTable)
-> Ptr TypeValueTable -> IO TypeValueTable
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 -> TypeValueTable -> (Ptr TypeValueTable -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
SP.withManagedPtr TypeValueTable
x Ptr TypeValueTable -> IO ()
forall a. Ptr a -> IO ()
SP.freeMem
instance CallocPtr TypeValueTable where
boxedPtrCalloc :: IO (Ptr TypeValueTable)
boxedPtrCalloc = Int -> IO (Ptr TypeValueTable)
forall a. Int -> IO (Ptr a)
callocBytes Int
64
newZeroTypeValueTable :: MonadIO m => m TypeValueTable
newZeroTypeValueTable :: forall (m :: * -> *). MonadIO m => m TypeValueTable
newZeroTypeValueTable = IO TypeValueTable -> m TypeValueTable
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TypeValueTable -> m TypeValueTable)
-> IO TypeValueTable -> m TypeValueTable
forall a b. (a -> b) -> a -> b
$ IO (Ptr TypeValueTable)
forall a. CallocPtr a => IO (Ptr a)
boxedPtrCalloc IO (Ptr TypeValueTable)
-> (Ptr TypeValueTable -> IO TypeValueTable) -> IO TypeValueTable
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr TypeValueTable -> TypeValueTable)
-> Ptr TypeValueTable -> IO TypeValueTable
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
o <- m TypeValueTable
forall (m :: * -> *). MonadIO m => m TypeValueTable
newZeroTypeValueTable
GI.Attributes.set o attrs
return o
getTypeValueTableValueInit :: MonadIO m => TypeValueTable -> m (Maybe GObject.Callbacks.TypeValueInitFunc)
getTypeValueTableValueInit :: forall (m :: * -> *).
MonadIO m =>
TypeValueTable -> m (Maybe TypeValueInitFunc)
getTypeValueTableValueInit TypeValueTable
s = IO (Maybe TypeValueInitFunc) -> m (Maybe TypeValueInitFunc)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe TypeValueInitFunc) -> m (Maybe TypeValueInitFunc))
-> IO (Maybe TypeValueInitFunc) -> m (Maybe TypeValueInitFunc)
forall a b. (a -> b) -> a -> b
$ TypeValueTable
-> (Ptr TypeValueTable -> IO (Maybe TypeValueInitFunc))
-> IO (Maybe TypeValueInitFunc)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TypeValueTable
s ((Ptr TypeValueTable -> IO (Maybe TypeValueInitFunc))
-> IO (Maybe TypeValueInitFunc))
-> (Ptr TypeValueTable -> IO (Maybe TypeValueInitFunc))
-> IO (Maybe TypeValueInitFunc)
forall a b. (a -> b) -> a -> b
$ \Ptr TypeValueTable
ptr -> do
val <- Ptr (FunPtr C_TypeValueInitFunc) -> IO (FunPtr C_TypeValueInitFunc)
forall a. Storable a => Ptr a -> IO a
peek (Ptr TypeValueTable
ptr Ptr TypeValueTable -> Int -> Ptr (FunPtr C_TypeValueInitFunc)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) :: IO (FunPtr GObject.Callbacks.C_TypeValueInitFunc)
result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_TypeValueInitFunc
val' -> do
let val'' :: TypeValueInitFunc
val'' = FunPtr C_TypeValueInitFunc -> TypeValueInitFunc
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
FunPtr C_TypeValueInitFunc -> GValue -> m ()
GObject.Callbacks.dynamic_TypeValueInitFunc FunPtr C_TypeValueInitFunc
val'
TypeValueInitFunc -> IO TypeValueInitFunc
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TypeValueInitFunc
val''
return result
setTypeValueTableValueInit :: MonadIO m => TypeValueTable -> FunPtr GObject.Callbacks.C_TypeValueInitFunc -> m ()
setTypeValueTableValueInit :: forall (m :: * -> *).
MonadIO m =>
TypeValueTable -> FunPtr C_TypeValueInitFunc -> m ()
setTypeValueTableValueInit TypeValueTable
s FunPtr C_TypeValueInitFunc
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ TypeValueTable -> (Ptr TypeValueTable -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TypeValueTable
s ((Ptr TypeValueTable -> IO ()) -> IO ())
-> (Ptr TypeValueTable -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr TypeValueTable
ptr -> do
Ptr (FunPtr C_TypeValueInitFunc)
-> FunPtr C_TypeValueInitFunc -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TypeValueTable
ptr Ptr TypeValueTable -> Int -> Ptr (FunPtr C_TypeValueInitFunc)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (FunPtr C_TypeValueInitFunc
val :: FunPtr GObject.Callbacks.C_TypeValueInitFunc)
clearTypeValueTableValueInit :: MonadIO m => TypeValueTable -> m ()
clearTypeValueTableValueInit :: forall (m :: * -> *). MonadIO m => TypeValueTable -> m ()
clearTypeValueTableValueInit TypeValueTable
s = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ TypeValueTable -> (Ptr TypeValueTable -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TypeValueTable
s ((Ptr TypeValueTable -> IO ()) -> IO ())
-> (Ptr TypeValueTable -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr TypeValueTable
ptr -> do
Ptr (FunPtr C_TypeValueInitFunc)
-> FunPtr C_TypeValueInitFunc -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TypeValueTable
ptr Ptr TypeValueTable -> Int -> Ptr (FunPtr C_TypeValueInitFunc)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (FunPtr C_TypeValueInitFunc
forall a. FunPtr a
FP.nullFunPtr :: FunPtr GObject.Callbacks.C_TypeValueInitFunc)
#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_TypeValueInitFunc)
type AttrTransferTypeConstraint TypeValueTableValueInitFieldInfo = (~)GObject.Callbacks.TypeValueInitFunc
type AttrTransferType TypeValueTableValueInitFieldInfo = (FunPtr GObject.Callbacks.C_TypeValueInitFunc)
type AttrGetType TypeValueTableValueInitFieldInfo = Maybe GObject.Callbacks.TypeValueInitFunc
type AttrLabel TypeValueTableValueInitFieldInfo = "value_init"
type AttrOrigin TypeValueTableValueInitFieldInfo = TypeValueTable
attrGet :: forall o.
AttrBaseTypeConstraint TypeValueTableValueInitFieldInfo o =>
o -> IO (AttrGetType TypeValueTableValueInitFieldInfo)
attrGet = o -> IO (AttrGetType TypeValueTableValueInitFieldInfo)
TypeValueTable -> IO (Maybe TypeValueInitFunc)
forall (m :: * -> *).
MonadIO m =>
TypeValueTable -> m (Maybe TypeValueInitFunc)
getTypeValueTableValueInit
attrSet :: forall o b.
(AttrBaseTypeConstraint TypeValueTableValueInitFieldInfo o,
AttrSetTypeConstraint TypeValueTableValueInitFieldInfo b) =>
o -> b -> IO ()
attrSet = o -> b -> IO ()
TypeValueTable -> FunPtr C_TypeValueInitFunc -> IO ()
forall (m :: * -> *).
MonadIO m =>
TypeValueTable -> FunPtr C_TypeValueInitFunc -> m ()
setTypeValueTableValueInit
attrConstruct :: forall o b.
(AttrBaseTypeConstraint TypeValueTableValueInitFieldInfo o,
AttrSetTypeConstraint TypeValueTableValueInitFieldInfo b) =>
b -> IO (GValueConstruct o)
attrConstruct = b -> IO (GValueConstruct o)
forall a. HasCallStack => a
undefined
attrClear :: forall o.
AttrBaseTypeConstraint TypeValueTableValueInitFieldInfo o =>
o -> IO ()
attrClear = o -> IO ()
TypeValueTable -> IO ()
forall (m :: * -> *). MonadIO m => TypeValueTable -> m ()
clearTypeValueTableValueInit
attrTransfer :: forall o b.
(AttrBaseTypeConstraint TypeValueTableValueInitFieldInfo o,
AttrTransferTypeConstraint TypeValueTableValueInitFieldInfo b) =>
Proxy o
-> b -> IO (AttrTransferType TypeValueTableValueInitFieldInfo)
attrTransfer Proxy o
_ b
v = do
C_TypeValueInitFunc -> IO (FunPtr C_TypeValueInitFunc)
GObject.Callbacks.mk_TypeValueInitFunc (Maybe (Ptr (FunPtr C_TypeValueInitFunc))
-> TypeValueInitFunc -> C_TypeValueInitFunc
GObject.Callbacks.wrap_TypeValueInitFunc Maybe (Ptr (FunPtr C_TypeValueInitFunc))
forall a. Maybe a
Nothing b
TypeValueInitFunc
v)
dbgAttrInfo :: Maybe ResolvedSymbolInfo
dbgAttrInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GObject.Structs.TypeValueTable.valueInit"
, resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-gobject-2.0.32/docs/GI-GObject-Structs-TypeValueTable.html#g:attr:valueInit"
})
typeValueTable_valueInit :: AttrLabelProxy "valueInit"
typeValueTable_valueInit :: AttrLabelProxy "valueInit"
typeValueTable_valueInit = AttrLabelProxy "valueInit"
forall (a :: Symbol). AttrLabelProxy a
AttrLabelProxy
#endif
getTypeValueTableValueFree :: MonadIO m => TypeValueTable -> m (Maybe GObject.Callbacks.TypeValueFreeFunc)
getTypeValueTableValueFree :: forall (m :: * -> *).
MonadIO m =>
TypeValueTable -> m (Maybe TypeValueInitFunc)
getTypeValueTableValueFree TypeValueTable
s = IO (Maybe TypeValueInitFunc) -> m (Maybe TypeValueInitFunc)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe TypeValueInitFunc) -> m (Maybe TypeValueInitFunc))
-> IO (Maybe TypeValueInitFunc) -> m (Maybe TypeValueInitFunc)
forall a b. (a -> b) -> a -> b
$ TypeValueTable
-> (Ptr TypeValueTable -> IO (Maybe TypeValueInitFunc))
-> IO (Maybe TypeValueInitFunc)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TypeValueTable
s ((Ptr TypeValueTable -> IO (Maybe TypeValueInitFunc))
-> IO (Maybe TypeValueInitFunc))
-> (Ptr TypeValueTable -> IO (Maybe TypeValueInitFunc))
-> IO (Maybe TypeValueInitFunc)
forall a b. (a -> b) -> a -> b
$ \Ptr TypeValueTable
ptr -> do
val <- Ptr (FunPtr C_TypeValueInitFunc) -> IO (FunPtr C_TypeValueInitFunc)
forall a. Storable a => Ptr a -> IO a
peek (Ptr TypeValueTable
ptr Ptr TypeValueTable -> Int -> Ptr (FunPtr C_TypeValueInitFunc)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) :: IO (FunPtr GObject.Callbacks.C_TypeValueFreeFunc)
result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_TypeValueInitFunc
val' -> do
let val'' :: TypeValueInitFunc
val'' = FunPtr C_TypeValueInitFunc -> TypeValueInitFunc
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
FunPtr C_TypeValueInitFunc -> GValue -> m ()
GObject.Callbacks.dynamic_TypeValueFreeFunc FunPtr C_TypeValueInitFunc
val'
TypeValueInitFunc -> IO TypeValueInitFunc
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TypeValueInitFunc
val''
return result
setTypeValueTableValueFree :: MonadIO m => TypeValueTable -> FunPtr GObject.Callbacks.C_TypeValueFreeFunc -> m ()
setTypeValueTableValueFree :: forall (m :: * -> *).
MonadIO m =>
TypeValueTable -> FunPtr C_TypeValueInitFunc -> m ()
setTypeValueTableValueFree TypeValueTable
s FunPtr C_TypeValueInitFunc
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ TypeValueTable -> (Ptr TypeValueTable -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TypeValueTable
s ((Ptr TypeValueTable -> IO ()) -> IO ())
-> (Ptr TypeValueTable -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr TypeValueTable
ptr -> do
Ptr (FunPtr C_TypeValueInitFunc)
-> FunPtr C_TypeValueInitFunc -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TypeValueTable
ptr Ptr TypeValueTable -> Int -> Ptr (FunPtr C_TypeValueInitFunc)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (FunPtr C_TypeValueInitFunc
val :: FunPtr GObject.Callbacks.C_TypeValueFreeFunc)
clearTypeValueTableValueFree :: MonadIO m => TypeValueTable -> m ()
clearTypeValueTableValueFree :: forall (m :: * -> *). MonadIO m => TypeValueTable -> m ()
clearTypeValueTableValueFree TypeValueTable
s = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ TypeValueTable -> (Ptr TypeValueTable -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TypeValueTable
s ((Ptr TypeValueTable -> IO ()) -> IO ())
-> (Ptr TypeValueTable -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr TypeValueTable
ptr -> do
Ptr (FunPtr C_TypeValueInitFunc)
-> FunPtr C_TypeValueInitFunc -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TypeValueTable
ptr Ptr TypeValueTable -> Int -> Ptr (FunPtr C_TypeValueInitFunc)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (FunPtr C_TypeValueInitFunc
forall a. FunPtr a
FP.nullFunPtr :: FunPtr GObject.Callbacks.C_TypeValueFreeFunc)
#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_TypeValueFreeFunc)
type AttrTransferTypeConstraint TypeValueTableValueFreeFieldInfo = (~)GObject.Callbacks.TypeValueFreeFunc
type AttrTransferType TypeValueTableValueFreeFieldInfo = (FunPtr GObject.Callbacks.C_TypeValueFreeFunc)
type AttrGetType TypeValueTableValueFreeFieldInfo = Maybe GObject.Callbacks.TypeValueFreeFunc
type AttrLabel TypeValueTableValueFreeFieldInfo = "value_free"
type AttrOrigin TypeValueTableValueFreeFieldInfo = TypeValueTable
attrGet :: forall o.
AttrBaseTypeConstraint TypeValueTableValueFreeFieldInfo o =>
o -> IO (AttrGetType TypeValueTableValueFreeFieldInfo)
attrGet = o -> IO (AttrGetType TypeValueTableValueFreeFieldInfo)
TypeValueTable -> IO (Maybe TypeValueInitFunc)
forall (m :: * -> *).
MonadIO m =>
TypeValueTable -> m (Maybe TypeValueInitFunc)
getTypeValueTableValueFree
attrSet :: forall o b.
(AttrBaseTypeConstraint TypeValueTableValueFreeFieldInfo o,
AttrSetTypeConstraint TypeValueTableValueFreeFieldInfo b) =>
o -> b -> IO ()
attrSet = o -> b -> IO ()
TypeValueTable -> FunPtr C_TypeValueInitFunc -> IO ()
forall (m :: * -> *).
MonadIO m =>
TypeValueTable -> FunPtr C_TypeValueInitFunc -> m ()
setTypeValueTableValueFree
attrConstruct :: forall o b.
(AttrBaseTypeConstraint TypeValueTableValueFreeFieldInfo o,
AttrSetTypeConstraint TypeValueTableValueFreeFieldInfo b) =>
b -> IO (GValueConstruct o)
attrConstruct = b -> IO (GValueConstruct o)
forall a. HasCallStack => a
undefined
attrClear :: forall o.
AttrBaseTypeConstraint TypeValueTableValueFreeFieldInfo o =>
o -> IO ()
attrClear = o -> IO ()
TypeValueTable -> IO ()
forall (m :: * -> *). MonadIO m => TypeValueTable -> m ()
clearTypeValueTableValueFree
attrTransfer :: forall o b.
(AttrBaseTypeConstraint TypeValueTableValueFreeFieldInfo o,
AttrTransferTypeConstraint TypeValueTableValueFreeFieldInfo b) =>
Proxy o
-> b -> IO (AttrTransferType TypeValueTableValueFreeFieldInfo)
attrTransfer Proxy o
_ b
v = do
C_TypeValueInitFunc -> IO (FunPtr C_TypeValueInitFunc)
GObject.Callbacks.mk_TypeValueFreeFunc (Maybe (Ptr (FunPtr C_TypeValueInitFunc))
-> TypeValueInitFunc -> C_TypeValueInitFunc
GObject.Callbacks.wrap_TypeValueFreeFunc Maybe (Ptr (FunPtr C_TypeValueInitFunc))
forall a. Maybe a
Nothing b
TypeValueInitFunc
v)
dbgAttrInfo :: Maybe ResolvedSymbolInfo
dbgAttrInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GObject.Structs.TypeValueTable.valueFree"
, resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-gobject-2.0.32/docs/GI-GObject-Structs-TypeValueTable.html#g:attr:valueFree"
})
typeValueTable_valueFree :: AttrLabelProxy "valueFree"
typeValueTable_valueFree :: AttrLabelProxy "valueFree"
typeValueTable_valueFree = AttrLabelProxy "valueFree"
forall (a :: Symbol). AttrLabelProxy a
AttrLabelProxy
#endif
getTypeValueTableValueCopy :: MonadIO m => TypeValueTable -> m (Maybe GObject.Callbacks.TypeValueCopyFunc)
getTypeValueTableValueCopy :: forall (m :: * -> *).
MonadIO m =>
TypeValueTable -> m (Maybe TypeValueCopyFunc)
getTypeValueTableValueCopy TypeValueTable
s = IO (Maybe TypeValueCopyFunc) -> m (Maybe TypeValueCopyFunc)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe TypeValueCopyFunc) -> m (Maybe TypeValueCopyFunc))
-> IO (Maybe TypeValueCopyFunc) -> m (Maybe TypeValueCopyFunc)
forall a b. (a -> b) -> a -> b
$ TypeValueTable
-> (Ptr TypeValueTable -> IO (Maybe TypeValueCopyFunc))
-> IO (Maybe TypeValueCopyFunc)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TypeValueTable
s ((Ptr TypeValueTable -> IO (Maybe TypeValueCopyFunc))
-> IO (Maybe TypeValueCopyFunc))
-> (Ptr TypeValueTable -> IO (Maybe TypeValueCopyFunc))
-> IO (Maybe TypeValueCopyFunc)
forall a b. (a -> b) -> a -> b
$ \Ptr TypeValueTable
ptr -> do
val <- Ptr (FunPtr C_TypeValueCopyFunc) -> IO (FunPtr C_TypeValueCopyFunc)
forall a. Storable a => Ptr a -> IO a
peek (Ptr TypeValueTable
ptr Ptr TypeValueTable -> Int -> Ptr (FunPtr C_TypeValueCopyFunc)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) :: IO (FunPtr GObject.Callbacks.C_TypeValueCopyFunc)
result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_TypeValueCopyFunc
val' -> do
let val'' :: TypeValueCopyFunc
val'' = FunPtr C_TypeValueCopyFunc -> TypeValueCopyFunc
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
FunPtr C_TypeValueCopyFunc -> GValue -> m GValue
GObject.Callbacks.dynamic_TypeValueCopyFunc FunPtr C_TypeValueCopyFunc
val'
TypeValueCopyFunc -> IO TypeValueCopyFunc
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TypeValueCopyFunc
val''
return result
setTypeValueTableValueCopy :: MonadIO m => TypeValueTable -> FunPtr GObject.Callbacks.C_TypeValueCopyFunc -> m ()
setTypeValueTableValueCopy :: forall (m :: * -> *).
MonadIO m =>
TypeValueTable -> FunPtr C_TypeValueCopyFunc -> m ()
setTypeValueTableValueCopy TypeValueTable
s FunPtr C_TypeValueCopyFunc
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ TypeValueTable -> (Ptr TypeValueTable -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TypeValueTable
s ((Ptr TypeValueTable -> IO ()) -> IO ())
-> (Ptr TypeValueTable -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr TypeValueTable
ptr -> do
Ptr (FunPtr C_TypeValueCopyFunc)
-> FunPtr C_TypeValueCopyFunc -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TypeValueTable
ptr Ptr TypeValueTable -> Int -> Ptr (FunPtr C_TypeValueCopyFunc)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (FunPtr C_TypeValueCopyFunc
val :: FunPtr GObject.Callbacks.C_TypeValueCopyFunc)
clearTypeValueTableValueCopy :: MonadIO m => TypeValueTable -> m ()
clearTypeValueTableValueCopy :: forall (m :: * -> *). MonadIO m => TypeValueTable -> m ()
clearTypeValueTableValueCopy TypeValueTable
s = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ TypeValueTable -> (Ptr TypeValueTable -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TypeValueTable
s ((Ptr TypeValueTable -> IO ()) -> IO ())
-> (Ptr TypeValueTable -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr TypeValueTable
ptr -> do
Ptr (FunPtr C_TypeValueCopyFunc)
-> FunPtr C_TypeValueCopyFunc -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TypeValueTable
ptr Ptr TypeValueTable -> Int -> Ptr (FunPtr C_TypeValueCopyFunc)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (FunPtr C_TypeValueCopyFunc
forall a. FunPtr a
FP.nullFunPtr :: FunPtr GObject.Callbacks.C_TypeValueCopyFunc)
#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_TypeValueCopyFunc)
type AttrTransferTypeConstraint TypeValueTableValueCopyFieldInfo = (~)GObject.Callbacks.TypeValueCopyFunc
type AttrTransferType TypeValueTableValueCopyFieldInfo = (FunPtr GObject.Callbacks.C_TypeValueCopyFunc)
type AttrGetType TypeValueTableValueCopyFieldInfo = Maybe GObject.Callbacks.TypeValueCopyFunc
type AttrLabel TypeValueTableValueCopyFieldInfo = "value_copy"
type AttrOrigin TypeValueTableValueCopyFieldInfo = TypeValueTable
attrGet :: forall o.
AttrBaseTypeConstraint TypeValueTableValueCopyFieldInfo o =>
o -> IO (AttrGetType TypeValueTableValueCopyFieldInfo)
attrGet = o -> IO (AttrGetType TypeValueTableValueCopyFieldInfo)
TypeValueTable -> IO (Maybe TypeValueCopyFunc)
forall (m :: * -> *).
MonadIO m =>
TypeValueTable -> m (Maybe TypeValueCopyFunc)
getTypeValueTableValueCopy
attrSet :: forall o b.
(AttrBaseTypeConstraint TypeValueTableValueCopyFieldInfo o,
AttrSetTypeConstraint TypeValueTableValueCopyFieldInfo b) =>
o -> b -> IO ()
attrSet = o -> b -> IO ()
TypeValueTable -> FunPtr C_TypeValueCopyFunc -> IO ()
forall (m :: * -> *).
MonadIO m =>
TypeValueTable -> FunPtr C_TypeValueCopyFunc -> m ()
setTypeValueTableValueCopy
attrConstruct :: forall o b.
(AttrBaseTypeConstraint TypeValueTableValueCopyFieldInfo o,
AttrSetTypeConstraint TypeValueTableValueCopyFieldInfo b) =>
b -> IO (GValueConstruct o)
attrConstruct = b -> IO (GValueConstruct o)
forall a. HasCallStack => a
undefined
attrClear :: forall o.
AttrBaseTypeConstraint TypeValueTableValueCopyFieldInfo o =>
o -> IO ()
attrClear = o -> IO ()
TypeValueTable -> IO ()
forall (m :: * -> *). MonadIO m => TypeValueTable -> m ()
clearTypeValueTableValueCopy
attrTransfer :: forall o b.
(AttrBaseTypeConstraint TypeValueTableValueCopyFieldInfo o,
AttrTransferTypeConstraint TypeValueTableValueCopyFieldInfo b) =>
Proxy o
-> b -> IO (AttrTransferType TypeValueTableValueCopyFieldInfo)
attrTransfer Proxy o
_ b
v = do
C_TypeValueCopyFunc -> IO (FunPtr C_TypeValueCopyFunc)
GObject.Callbacks.mk_TypeValueCopyFunc (Maybe (Ptr (FunPtr C_TypeValueCopyFunc))
-> TypeValueCopyFunc -> C_TypeValueCopyFunc
GObject.Callbacks.wrap_TypeValueCopyFunc Maybe (Ptr (FunPtr C_TypeValueCopyFunc))
forall a. Maybe a
Nothing b
TypeValueCopyFunc
v)
dbgAttrInfo :: Maybe ResolvedSymbolInfo
dbgAttrInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GObject.Structs.TypeValueTable.valueCopy"
, resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-gobject-2.0.32/docs/GI-GObject-Structs-TypeValueTable.html#g:attr:valueCopy"
})
typeValueTable_valueCopy :: AttrLabelProxy "valueCopy"
typeValueTable_valueCopy :: AttrLabelProxy "valueCopy"
typeValueTable_valueCopy = AttrLabelProxy "valueCopy"
forall (a :: Symbol). AttrLabelProxy a
AttrLabelProxy
#endif
getTypeValueTableValuePeekPointer :: MonadIO m => TypeValueTable -> m (Maybe GObject.Callbacks.TypeValuePeekPointerFunc)
getTypeValueTableValuePeekPointer :: forall (m :: * -> *).
MonadIO m =>
TypeValueTable -> m (Maybe TypeValuePeekPointerFunc)
getTypeValueTableValuePeekPointer TypeValueTable
s = IO (Maybe TypeValuePeekPointerFunc)
-> m (Maybe TypeValuePeekPointerFunc)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe TypeValuePeekPointerFunc)
-> m (Maybe TypeValuePeekPointerFunc))
-> IO (Maybe TypeValuePeekPointerFunc)
-> m (Maybe TypeValuePeekPointerFunc)
forall a b. (a -> b) -> a -> b
$ TypeValueTable
-> (Ptr TypeValueTable -> IO (Maybe TypeValuePeekPointerFunc))
-> IO (Maybe TypeValuePeekPointerFunc)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TypeValueTable
s ((Ptr TypeValueTable -> IO (Maybe TypeValuePeekPointerFunc))
-> IO (Maybe TypeValuePeekPointerFunc))
-> (Ptr TypeValueTable -> IO (Maybe TypeValuePeekPointerFunc))
-> IO (Maybe TypeValuePeekPointerFunc)
forall a b. (a -> b) -> a -> b
$ \Ptr TypeValueTable
ptr -> do
val <- Ptr (FunPtr C_TypeValuePeekPointerFunc)
-> IO (FunPtr C_TypeValuePeekPointerFunc)
forall a. Storable a => Ptr a -> IO a
peek (Ptr TypeValueTable
ptr Ptr TypeValueTable
-> Int -> Ptr (FunPtr C_TypeValuePeekPointerFunc)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) :: IO (FunPtr GObject.Callbacks.C_TypeValuePeekPointerFunc)
result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_TypeValuePeekPointerFunc
val' -> do
let val'' :: TypeValuePeekPointerFunc
val'' = FunPtr C_TypeValuePeekPointerFunc -> TypeValuePeekPointerFunc
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
FunPtr C_TypeValuePeekPointerFunc -> GValue -> m (Ptr ())
GObject.Callbacks.dynamic_TypeValuePeekPointerFunc FunPtr C_TypeValuePeekPointerFunc
val'
TypeValuePeekPointerFunc -> IO TypeValuePeekPointerFunc
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TypeValuePeekPointerFunc
val''
return result
setTypeValueTableValuePeekPointer :: MonadIO m => TypeValueTable -> FunPtr GObject.Callbacks.C_TypeValuePeekPointerFunc -> m ()
setTypeValueTableValuePeekPointer :: forall (m :: * -> *).
MonadIO m =>
TypeValueTable -> FunPtr C_TypeValuePeekPointerFunc -> m ()
setTypeValueTableValuePeekPointer TypeValueTable
s FunPtr C_TypeValuePeekPointerFunc
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ TypeValueTable -> (Ptr TypeValueTable -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TypeValueTable
s ((Ptr TypeValueTable -> IO ()) -> IO ())
-> (Ptr TypeValueTable -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr TypeValueTable
ptr -> do
Ptr (FunPtr C_TypeValuePeekPointerFunc)
-> FunPtr C_TypeValuePeekPointerFunc -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TypeValueTable
ptr Ptr TypeValueTable
-> Int -> Ptr (FunPtr C_TypeValuePeekPointerFunc)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) (FunPtr C_TypeValuePeekPointerFunc
val :: FunPtr GObject.Callbacks.C_TypeValuePeekPointerFunc)
clearTypeValueTableValuePeekPointer :: MonadIO m => TypeValueTable -> m ()
clearTypeValueTableValuePeekPointer :: forall (m :: * -> *). MonadIO m => TypeValueTable -> m ()
clearTypeValueTableValuePeekPointer TypeValueTable
s = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ TypeValueTable -> (Ptr TypeValueTable -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TypeValueTable
s ((Ptr TypeValueTable -> IO ()) -> IO ())
-> (Ptr TypeValueTable -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr TypeValueTable
ptr -> do
Ptr (FunPtr C_TypeValuePeekPointerFunc)
-> FunPtr C_TypeValuePeekPointerFunc -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TypeValueTable
ptr Ptr TypeValueTable
-> Int -> Ptr (FunPtr C_TypeValuePeekPointerFunc)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) (FunPtr C_TypeValuePeekPointerFunc
forall a. FunPtr a
FP.nullFunPtr :: FunPtr GObject.Callbacks.C_TypeValuePeekPointerFunc)
#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_TypeValuePeekPointerFunc)
type AttrTransferTypeConstraint TypeValueTableValuePeekPointerFieldInfo = (~)GObject.Callbacks.TypeValuePeekPointerFunc
type AttrTransferType TypeValueTableValuePeekPointerFieldInfo = (FunPtr GObject.Callbacks.C_TypeValuePeekPointerFunc)
type AttrGetType TypeValueTableValuePeekPointerFieldInfo = Maybe GObject.Callbacks.TypeValuePeekPointerFunc
type AttrLabel TypeValueTableValuePeekPointerFieldInfo = "value_peek_pointer"
type AttrOrigin TypeValueTableValuePeekPointerFieldInfo = TypeValueTable
attrGet :: forall o.
AttrBaseTypeConstraint TypeValueTableValuePeekPointerFieldInfo o =>
o -> IO (AttrGetType TypeValueTableValuePeekPointerFieldInfo)
attrGet = o -> IO (AttrGetType TypeValueTableValuePeekPointerFieldInfo)
TypeValueTable -> IO (Maybe TypeValuePeekPointerFunc)
forall (m :: * -> *).
MonadIO m =>
TypeValueTable -> m (Maybe TypeValuePeekPointerFunc)
getTypeValueTableValuePeekPointer
attrSet :: forall o b.
(AttrBaseTypeConstraint TypeValueTableValuePeekPointerFieldInfo o,
AttrSetTypeConstraint TypeValueTableValuePeekPointerFieldInfo b) =>
o -> b -> IO ()
attrSet = o -> b -> IO ()
TypeValueTable -> FunPtr C_TypeValuePeekPointerFunc -> IO ()
forall (m :: * -> *).
MonadIO m =>
TypeValueTable -> FunPtr C_TypeValuePeekPointerFunc -> m ()
setTypeValueTableValuePeekPointer
attrConstruct :: forall o b.
(AttrBaseTypeConstraint TypeValueTableValuePeekPointerFieldInfo o,
AttrSetTypeConstraint TypeValueTableValuePeekPointerFieldInfo b) =>
b -> IO (GValueConstruct o)
attrConstruct = b -> IO (GValueConstruct o)
forall a. HasCallStack => a
undefined
attrClear :: forall o.
AttrBaseTypeConstraint TypeValueTableValuePeekPointerFieldInfo o =>
o -> IO ()
attrClear = o -> IO ()
TypeValueTable -> IO ()
forall (m :: * -> *). MonadIO m => TypeValueTable -> m ()
clearTypeValueTableValuePeekPointer
attrTransfer :: forall o b.
(AttrBaseTypeConstraint TypeValueTableValuePeekPointerFieldInfo o,
AttrTransferTypeConstraint
TypeValueTableValuePeekPointerFieldInfo b) =>
Proxy o
-> b
-> IO (AttrTransferType TypeValueTableValuePeekPointerFieldInfo)
attrTransfer Proxy o
_ b
v = do
C_TypeValuePeekPointerFunc
-> IO (FunPtr C_TypeValuePeekPointerFunc)
GObject.Callbacks.mk_TypeValuePeekPointerFunc (Maybe (Ptr (FunPtr C_TypeValuePeekPointerFunc))
-> TypeValuePeekPointerFunc -> C_TypeValuePeekPointerFunc
GObject.Callbacks.wrap_TypeValuePeekPointerFunc Maybe (Ptr (FunPtr C_TypeValuePeekPointerFunc))
forall a. Maybe a
Nothing b
TypeValuePeekPointerFunc
v)
dbgAttrInfo :: Maybe ResolvedSymbolInfo
dbgAttrInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GObject.Structs.TypeValueTable.valuePeekPointer"
, resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-gobject-2.0.32/docs/GI-GObject-Structs-TypeValueTable.html#g:attr:valuePeekPointer"
})
typeValueTable_valuePeekPointer :: AttrLabelProxy "valuePeekPointer"
typeValueTable_valuePeekPointer :: AttrLabelProxy "valuePeekPointer"
typeValueTable_valuePeekPointer = AttrLabelProxy "valuePeekPointer"
forall (a :: Symbol). AttrLabelProxy a
AttrLabelProxy
#endif
getTypeValueTableCollectFormat :: MonadIO m => TypeValueTable -> m (Maybe T.Text)
getTypeValueTableCollectFormat :: forall (m :: * -> *). MonadIO m => TypeValueTable -> m (Maybe Text)
getTypeValueTableCollectFormat TypeValueTable
s = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ TypeValueTable
-> (Ptr TypeValueTable -> IO (Maybe Text)) -> IO (Maybe Text)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TypeValueTable
s ((Ptr TypeValueTable -> IO (Maybe Text)) -> IO (Maybe Text))
-> (Ptr TypeValueTable -> IO (Maybe Text)) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \Ptr TypeValueTable
ptr -> do
val <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek (Ptr TypeValueTable
ptr Ptr TypeValueTable -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) :: IO CString
result <- SP.convertIfNonNull val $ \CString
val' -> do
val'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
val'
return val''
return result
setTypeValueTableCollectFormat :: MonadIO m => TypeValueTable -> CString -> m ()
setTypeValueTableCollectFormat :: forall (m :: * -> *).
MonadIO m =>
TypeValueTable -> CString -> m ()
setTypeValueTableCollectFormat TypeValueTable
s CString
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ TypeValueTable -> (Ptr TypeValueTable -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TypeValueTable
s ((Ptr TypeValueTable -> IO ()) -> IO ())
-> (Ptr TypeValueTable -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr TypeValueTable
ptr -> do
Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TypeValueTable
ptr Ptr TypeValueTable -> Int -> Ptr CString
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 = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ TypeValueTable -> (Ptr TypeValueTable -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TypeValueTable
s ((Ptr TypeValueTable -> IO ()) -> IO ())
-> (Ptr TypeValueTable -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr TypeValueTable
ptr -> do
Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TypeValueTable
ptr Ptr TypeValueTable -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) (CString
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 :: forall o.
AttrBaseTypeConstraint TypeValueTableCollectFormatFieldInfo o =>
o -> IO (AttrGetType TypeValueTableCollectFormatFieldInfo)
attrGet = o -> IO (AttrGetType TypeValueTableCollectFormatFieldInfo)
TypeValueTable -> IO (Maybe Text)
forall (m :: * -> *). MonadIO m => TypeValueTable -> m (Maybe Text)
getTypeValueTableCollectFormat
attrSet :: forall o b.
(AttrBaseTypeConstraint TypeValueTableCollectFormatFieldInfo o,
AttrSetTypeConstraint TypeValueTableCollectFormatFieldInfo b) =>
o -> b -> IO ()
attrSet = o -> b -> IO ()
TypeValueTable -> CString -> IO ()
forall (m :: * -> *).
MonadIO m =>
TypeValueTable -> CString -> m ()
setTypeValueTableCollectFormat
attrConstruct :: forall o b.
(AttrBaseTypeConstraint TypeValueTableCollectFormatFieldInfo o,
AttrSetTypeConstraint TypeValueTableCollectFormatFieldInfo b) =>
b -> IO (GValueConstruct o)
attrConstruct = b -> IO (GValueConstruct o)
forall a. HasCallStack => a
undefined
attrClear :: forall o.
AttrBaseTypeConstraint TypeValueTableCollectFormatFieldInfo o =>
o -> IO ()
attrClear = o -> IO ()
TypeValueTable -> IO ()
forall (m :: * -> *). MonadIO m => TypeValueTable -> m ()
clearTypeValueTableCollectFormat
attrTransfer :: forall o b.
(AttrBaseTypeConstraint TypeValueTableCollectFormatFieldInfo o,
AttrTransferTypeConstraint
TypeValueTableCollectFormatFieldInfo b) =>
Proxy o
-> b -> IO (AttrTransferType TypeValueTableCollectFormatFieldInfo)
attrTransfer Proxy o
_ b
v = do
b -> IO b
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return b
v
dbgAttrInfo :: Maybe ResolvedSymbolInfo
dbgAttrInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GObject.Structs.TypeValueTable.collectFormat"
, resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-gobject-2.0.32/docs/GI-GObject-Structs-TypeValueTable.html#g:attr:collectFormat"
})
typeValueTable_collectFormat :: AttrLabelProxy "collectFormat"
typeValueTable_collectFormat :: AttrLabelProxy "collectFormat"
typeValueTable_collectFormat = AttrLabelProxy "collectFormat"
forall (a :: Symbol). AttrLabelProxy a
AttrLabelProxy
#endif
getTypeValueTableCollectValue :: MonadIO m => TypeValueTable -> m (Maybe GObject.Callbacks.TypeValueCollectFunc)
getTypeValueTableCollectValue :: forall (m :: * -> *).
MonadIO m =>
TypeValueTable -> m (Maybe TypeValueCollectFunc)
getTypeValueTableCollectValue TypeValueTable
s = IO (Maybe TypeValueCollectFunc) -> m (Maybe TypeValueCollectFunc)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe TypeValueCollectFunc) -> m (Maybe TypeValueCollectFunc))
-> IO (Maybe TypeValueCollectFunc)
-> m (Maybe TypeValueCollectFunc)
forall a b. (a -> b) -> a -> b
$ TypeValueTable
-> (Ptr TypeValueTable -> IO (Maybe TypeValueCollectFunc))
-> IO (Maybe TypeValueCollectFunc)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TypeValueTable
s ((Ptr TypeValueTable -> IO (Maybe TypeValueCollectFunc))
-> IO (Maybe TypeValueCollectFunc))
-> (Ptr TypeValueTable -> IO (Maybe TypeValueCollectFunc))
-> IO (Maybe TypeValueCollectFunc)
forall a b. (a -> b) -> a -> b
$ \Ptr TypeValueTable
ptr -> do
val <- Ptr (FunPtr C_TypeValueCollectFunc)
-> IO (FunPtr C_TypeValueCollectFunc)
forall a. Storable a => Ptr a -> IO a
peek (Ptr TypeValueTable
ptr Ptr TypeValueTable -> Int -> Ptr (FunPtr C_TypeValueCollectFunc)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
40) :: IO (FunPtr GObject.Callbacks.C_TypeValueCollectFunc)
result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_TypeValueCollectFunc
val' -> do
let val'' :: TypeValueCollectFunc
val'' = FunPtr C_TypeValueCollectFunc -> TypeValueCollectFunc
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
FunPtr C_TypeValueCollectFunc
-> GValue -> [TypeCValue] -> Word32 -> m (Maybe Text)
GObject.Callbacks.dynamic_TypeValueCollectFunc FunPtr C_TypeValueCollectFunc
val'
TypeValueCollectFunc -> IO TypeValueCollectFunc
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TypeValueCollectFunc
val''
return result
setTypeValueTableCollectValue :: MonadIO m => TypeValueTable -> FunPtr GObject.Callbacks.C_TypeValueCollectFunc -> m ()
setTypeValueTableCollectValue :: forall (m :: * -> *).
MonadIO m =>
TypeValueTable -> FunPtr C_TypeValueCollectFunc -> m ()
setTypeValueTableCollectValue TypeValueTable
s FunPtr C_TypeValueCollectFunc
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ TypeValueTable -> (Ptr TypeValueTable -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TypeValueTable
s ((Ptr TypeValueTable -> IO ()) -> IO ())
-> (Ptr TypeValueTable -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr TypeValueTable
ptr -> do
Ptr (FunPtr C_TypeValueCollectFunc)
-> FunPtr C_TypeValueCollectFunc -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TypeValueTable
ptr Ptr TypeValueTable -> Int -> Ptr (FunPtr C_TypeValueCollectFunc)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
40) (FunPtr C_TypeValueCollectFunc
val :: FunPtr GObject.Callbacks.C_TypeValueCollectFunc)
clearTypeValueTableCollectValue :: MonadIO m => TypeValueTable -> m ()
clearTypeValueTableCollectValue :: forall (m :: * -> *). MonadIO m => TypeValueTable -> m ()
clearTypeValueTableCollectValue TypeValueTable
s = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ TypeValueTable -> (Ptr TypeValueTable -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TypeValueTable
s ((Ptr TypeValueTable -> IO ()) -> IO ())
-> (Ptr TypeValueTable -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr TypeValueTable
ptr -> do
Ptr (FunPtr C_TypeValueCollectFunc)
-> FunPtr C_TypeValueCollectFunc -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TypeValueTable
ptr Ptr TypeValueTable -> Int -> Ptr (FunPtr C_TypeValueCollectFunc)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
40) (FunPtr C_TypeValueCollectFunc
forall a. FunPtr a
FP.nullFunPtr :: FunPtr GObject.Callbacks.C_TypeValueCollectFunc)
#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_TypeValueCollectFunc)
type AttrTransferTypeConstraint TypeValueTableCollectValueFieldInfo = (~)GObject.Callbacks.TypeValueCollectFunc
type AttrTransferType TypeValueTableCollectValueFieldInfo = (FunPtr GObject.Callbacks.C_TypeValueCollectFunc)
type AttrGetType TypeValueTableCollectValueFieldInfo = Maybe GObject.Callbacks.TypeValueCollectFunc
type AttrLabel TypeValueTableCollectValueFieldInfo = "collect_value"
type AttrOrigin TypeValueTableCollectValueFieldInfo = TypeValueTable
attrGet :: forall o.
AttrBaseTypeConstraint TypeValueTableCollectValueFieldInfo o =>
o -> IO (AttrGetType TypeValueTableCollectValueFieldInfo)
attrGet = o -> IO (AttrGetType TypeValueTableCollectValueFieldInfo)
TypeValueTable -> IO (Maybe TypeValueCollectFunc)
forall (m :: * -> *).
MonadIO m =>
TypeValueTable -> m (Maybe TypeValueCollectFunc)
getTypeValueTableCollectValue
attrSet :: forall o b.
(AttrBaseTypeConstraint TypeValueTableCollectValueFieldInfo o,
AttrSetTypeConstraint TypeValueTableCollectValueFieldInfo b) =>
o -> b -> IO ()
attrSet = o -> b -> IO ()
TypeValueTable -> FunPtr C_TypeValueCollectFunc -> IO ()
forall (m :: * -> *).
MonadIO m =>
TypeValueTable -> FunPtr C_TypeValueCollectFunc -> m ()
setTypeValueTableCollectValue
attrConstruct :: forall o b.
(AttrBaseTypeConstraint TypeValueTableCollectValueFieldInfo o,
AttrSetTypeConstraint TypeValueTableCollectValueFieldInfo b) =>
b -> IO (GValueConstruct o)
attrConstruct = b -> IO (GValueConstruct o)
forall a. HasCallStack => a
undefined
attrClear :: forall o.
AttrBaseTypeConstraint TypeValueTableCollectValueFieldInfo o =>
o -> IO ()
attrClear = o -> IO ()
TypeValueTable -> IO ()
forall (m :: * -> *). MonadIO m => TypeValueTable -> m ()
clearTypeValueTableCollectValue
attrTransfer :: forall o b.
(AttrBaseTypeConstraint TypeValueTableCollectValueFieldInfo o,
AttrTransferTypeConstraint
TypeValueTableCollectValueFieldInfo b) =>
Proxy o
-> b -> IO (AttrTransferType TypeValueTableCollectValueFieldInfo)
attrTransfer Proxy o
_ b
v = do
C_TypeValueCollectFunc -> IO (FunPtr C_TypeValueCollectFunc)
GObject.Callbacks.mk_TypeValueCollectFunc (Maybe (Ptr (FunPtr C_TypeValueCollectFunc))
-> TypeValueCollectFunc -> C_TypeValueCollectFunc
GObject.Callbacks.wrap_TypeValueCollectFunc Maybe (Ptr (FunPtr C_TypeValueCollectFunc))
forall a. Maybe a
Nothing b
TypeValueCollectFunc
v)
dbgAttrInfo :: Maybe ResolvedSymbolInfo
dbgAttrInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GObject.Structs.TypeValueTable.collectValue"
, resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-gobject-2.0.32/docs/GI-GObject-Structs-TypeValueTable.html#g:attr:collectValue"
})
typeValueTable_collectValue :: AttrLabelProxy "collectValue"
typeValueTable_collectValue :: AttrLabelProxy "collectValue"
typeValueTable_collectValue = AttrLabelProxy "collectValue"
forall (a :: Symbol). AttrLabelProxy a
AttrLabelProxy
#endif
getTypeValueTableLcopyFormat :: MonadIO m => TypeValueTable -> m (Maybe T.Text)
getTypeValueTableLcopyFormat :: forall (m :: * -> *). MonadIO m => TypeValueTable -> m (Maybe Text)
getTypeValueTableLcopyFormat TypeValueTable
s = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ TypeValueTable
-> (Ptr TypeValueTable -> IO (Maybe Text)) -> IO (Maybe Text)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TypeValueTable
s ((Ptr TypeValueTable -> IO (Maybe Text)) -> IO (Maybe Text))
-> (Ptr TypeValueTable -> IO (Maybe Text)) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \Ptr TypeValueTable
ptr -> do
val <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek (Ptr TypeValueTable
ptr Ptr TypeValueTable -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
48) :: IO CString
result <- SP.convertIfNonNull val $ \CString
val' -> do
val'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
val'
return val''
return result
setTypeValueTableLcopyFormat :: MonadIO m => TypeValueTable -> CString -> m ()
setTypeValueTableLcopyFormat :: forall (m :: * -> *).
MonadIO m =>
TypeValueTable -> CString -> m ()
setTypeValueTableLcopyFormat TypeValueTable
s CString
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ TypeValueTable -> (Ptr TypeValueTable -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TypeValueTable
s ((Ptr TypeValueTable -> IO ()) -> IO ())
-> (Ptr TypeValueTable -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr TypeValueTable
ptr -> do
Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TypeValueTable
ptr Ptr TypeValueTable -> Int -> Ptr CString
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 = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ TypeValueTable -> (Ptr TypeValueTable -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TypeValueTable
s ((Ptr TypeValueTable -> IO ()) -> IO ())
-> (Ptr TypeValueTable -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr TypeValueTable
ptr -> do
Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TypeValueTable
ptr Ptr TypeValueTable -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
48) (CString
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 :: forall o.
AttrBaseTypeConstraint TypeValueTableLcopyFormatFieldInfo o =>
o -> IO (AttrGetType TypeValueTableLcopyFormatFieldInfo)
attrGet = o -> IO (AttrGetType TypeValueTableLcopyFormatFieldInfo)
TypeValueTable -> IO (Maybe Text)
forall (m :: * -> *). MonadIO m => TypeValueTable -> m (Maybe Text)
getTypeValueTableLcopyFormat
attrSet :: forall o b.
(AttrBaseTypeConstraint TypeValueTableLcopyFormatFieldInfo o,
AttrSetTypeConstraint TypeValueTableLcopyFormatFieldInfo b) =>
o -> b -> IO ()
attrSet = o -> b -> IO ()
TypeValueTable -> CString -> IO ()
forall (m :: * -> *).
MonadIO m =>
TypeValueTable -> CString -> m ()
setTypeValueTableLcopyFormat
attrConstruct :: forall o b.
(AttrBaseTypeConstraint TypeValueTableLcopyFormatFieldInfo o,
AttrSetTypeConstraint TypeValueTableLcopyFormatFieldInfo b) =>
b -> IO (GValueConstruct o)
attrConstruct = b -> IO (GValueConstruct o)
forall a. HasCallStack => a
undefined
attrClear :: forall o.
AttrBaseTypeConstraint TypeValueTableLcopyFormatFieldInfo o =>
o -> IO ()
attrClear = o -> IO ()
TypeValueTable -> IO ()
forall (m :: * -> *). MonadIO m => TypeValueTable -> m ()
clearTypeValueTableLcopyFormat
attrTransfer :: forall o b.
(AttrBaseTypeConstraint TypeValueTableLcopyFormatFieldInfo o,
AttrTransferTypeConstraint TypeValueTableLcopyFormatFieldInfo b) =>
Proxy o
-> b -> IO (AttrTransferType TypeValueTableLcopyFormatFieldInfo)
attrTransfer Proxy o
_ b
v = do
b -> IO b
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return b
v
dbgAttrInfo :: Maybe ResolvedSymbolInfo
dbgAttrInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GObject.Structs.TypeValueTable.lcopyFormat"
, resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-gobject-2.0.32/docs/GI-GObject-Structs-TypeValueTable.html#g:attr:lcopyFormat"
})
typeValueTable_lcopyFormat :: AttrLabelProxy "lcopyFormat"
typeValueTable_lcopyFormat :: AttrLabelProxy "lcopyFormat"
typeValueTable_lcopyFormat = AttrLabelProxy "lcopyFormat"
forall (a :: Symbol). AttrLabelProxy a
AttrLabelProxy
#endif
getTypeValueTableLcopyValue :: MonadIO m => TypeValueTable -> m (Maybe GObject.Callbacks.TypeValueLCopyFunc)
getTypeValueTableLcopyValue :: forall (m :: * -> *).
MonadIO m =>
TypeValueTable -> m (Maybe TypeValueCollectFunc)
getTypeValueTableLcopyValue TypeValueTable
s = IO (Maybe TypeValueCollectFunc) -> m (Maybe TypeValueCollectFunc)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe TypeValueCollectFunc) -> m (Maybe TypeValueCollectFunc))
-> IO (Maybe TypeValueCollectFunc)
-> m (Maybe TypeValueCollectFunc)
forall a b. (a -> b) -> a -> b
$ TypeValueTable
-> (Ptr TypeValueTable -> IO (Maybe TypeValueCollectFunc))
-> IO (Maybe TypeValueCollectFunc)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TypeValueTable
s ((Ptr TypeValueTable -> IO (Maybe TypeValueCollectFunc))
-> IO (Maybe TypeValueCollectFunc))
-> (Ptr TypeValueTable -> IO (Maybe TypeValueCollectFunc))
-> IO (Maybe TypeValueCollectFunc)
forall a b. (a -> b) -> a -> b
$ \Ptr TypeValueTable
ptr -> do
val <- Ptr (FunPtr C_TypeValueCollectFunc)
-> IO (FunPtr C_TypeValueCollectFunc)
forall a. Storable a => Ptr a -> IO a
peek (Ptr TypeValueTable
ptr Ptr TypeValueTable -> Int -> Ptr (FunPtr C_TypeValueCollectFunc)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
56) :: IO (FunPtr GObject.Callbacks.C_TypeValueLCopyFunc)
result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_TypeValueCollectFunc
val' -> do
let val'' :: TypeValueCollectFunc
val'' = FunPtr C_TypeValueCollectFunc -> TypeValueCollectFunc
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
FunPtr C_TypeValueCollectFunc
-> GValue -> [TypeCValue] -> Word32 -> m (Maybe Text)
GObject.Callbacks.dynamic_TypeValueLCopyFunc FunPtr C_TypeValueCollectFunc
val'
TypeValueCollectFunc -> IO TypeValueCollectFunc
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TypeValueCollectFunc
val''
return result
setTypeValueTableLcopyValue :: MonadIO m => TypeValueTable -> FunPtr GObject.Callbacks.C_TypeValueLCopyFunc -> m ()
setTypeValueTableLcopyValue :: forall (m :: * -> *).
MonadIO m =>
TypeValueTable -> FunPtr C_TypeValueCollectFunc -> m ()
setTypeValueTableLcopyValue TypeValueTable
s FunPtr C_TypeValueCollectFunc
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ TypeValueTable -> (Ptr TypeValueTable -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TypeValueTable
s ((Ptr TypeValueTable -> IO ()) -> IO ())
-> (Ptr TypeValueTable -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr TypeValueTable
ptr -> do
Ptr (FunPtr C_TypeValueCollectFunc)
-> FunPtr C_TypeValueCollectFunc -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TypeValueTable
ptr Ptr TypeValueTable -> Int -> Ptr (FunPtr C_TypeValueCollectFunc)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
56) (FunPtr C_TypeValueCollectFunc
val :: FunPtr GObject.Callbacks.C_TypeValueLCopyFunc)
clearTypeValueTableLcopyValue :: MonadIO m => TypeValueTable -> m ()
clearTypeValueTableLcopyValue :: forall (m :: * -> *). MonadIO m => TypeValueTable -> m ()
clearTypeValueTableLcopyValue TypeValueTable
s = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ TypeValueTable -> (Ptr TypeValueTable -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TypeValueTable
s ((Ptr TypeValueTable -> IO ()) -> IO ())
-> (Ptr TypeValueTable -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr TypeValueTable
ptr -> do
Ptr (FunPtr C_TypeValueCollectFunc)
-> FunPtr C_TypeValueCollectFunc -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TypeValueTable
ptr Ptr TypeValueTable -> Int -> Ptr (FunPtr C_TypeValueCollectFunc)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
56) (FunPtr C_TypeValueCollectFunc
forall a. FunPtr a
FP.nullFunPtr :: FunPtr GObject.Callbacks.C_TypeValueLCopyFunc)
#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_TypeValueLCopyFunc)
type AttrTransferTypeConstraint TypeValueTableLcopyValueFieldInfo = (~)GObject.Callbacks.TypeValueLCopyFunc
type AttrTransferType TypeValueTableLcopyValueFieldInfo = (FunPtr GObject.Callbacks.C_TypeValueLCopyFunc)
type AttrGetType TypeValueTableLcopyValueFieldInfo = Maybe GObject.Callbacks.TypeValueLCopyFunc
type AttrLabel TypeValueTableLcopyValueFieldInfo = "lcopy_value"
type AttrOrigin TypeValueTableLcopyValueFieldInfo = TypeValueTable
attrGet :: forall o.
AttrBaseTypeConstraint TypeValueTableLcopyValueFieldInfo o =>
o -> IO (AttrGetType TypeValueTableLcopyValueFieldInfo)
attrGet = o -> IO (AttrGetType TypeValueTableLcopyValueFieldInfo)
TypeValueTable -> IO (Maybe TypeValueCollectFunc)
forall (m :: * -> *).
MonadIO m =>
TypeValueTable -> m (Maybe TypeValueCollectFunc)
getTypeValueTableLcopyValue
attrSet :: forall o b.
(AttrBaseTypeConstraint TypeValueTableLcopyValueFieldInfo o,
AttrSetTypeConstraint TypeValueTableLcopyValueFieldInfo b) =>
o -> b -> IO ()
attrSet = o -> b -> IO ()
TypeValueTable -> FunPtr C_TypeValueCollectFunc -> IO ()
forall (m :: * -> *).
MonadIO m =>
TypeValueTable -> FunPtr C_TypeValueCollectFunc -> m ()
setTypeValueTableLcopyValue
attrConstruct :: forall o b.
(AttrBaseTypeConstraint TypeValueTableLcopyValueFieldInfo o,
AttrSetTypeConstraint TypeValueTableLcopyValueFieldInfo b) =>
b -> IO (GValueConstruct o)
attrConstruct = b -> IO (GValueConstruct o)
forall a. HasCallStack => a
undefined
attrClear :: forall o.
AttrBaseTypeConstraint TypeValueTableLcopyValueFieldInfo o =>
o -> IO ()
attrClear = o -> IO ()
TypeValueTable -> IO ()
forall (m :: * -> *). MonadIO m => TypeValueTable -> m ()
clearTypeValueTableLcopyValue
attrTransfer :: forall o b.
(AttrBaseTypeConstraint TypeValueTableLcopyValueFieldInfo o,
AttrTransferTypeConstraint TypeValueTableLcopyValueFieldInfo b) =>
Proxy o
-> b -> IO (AttrTransferType TypeValueTableLcopyValueFieldInfo)
attrTransfer Proxy o
_ b
v = do
C_TypeValueCollectFunc -> IO (FunPtr C_TypeValueCollectFunc)
GObject.Callbacks.mk_TypeValueLCopyFunc (Maybe (Ptr (FunPtr C_TypeValueCollectFunc))
-> TypeValueCollectFunc -> C_TypeValueCollectFunc
GObject.Callbacks.wrap_TypeValueLCopyFunc Maybe (Ptr (FunPtr C_TypeValueCollectFunc))
forall a. Maybe a
Nothing b
TypeValueCollectFunc
v)
dbgAttrInfo :: Maybe ResolvedSymbolInfo
dbgAttrInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GObject.Structs.TypeValueTable.lcopyValue"
, resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-gobject-2.0.32/docs/GI-GObject-Structs-TypeValueTable.html#g:attr:lcopyValue"
})
typeValueTable_lcopyValue :: AttrLabelProxy "lcopyValue"
typeValueTable_lcopyValue :: AttrLabelProxy "lcopyValue"
typeValueTable_lcopyValue = AttrLabelProxy "lcopyValue"
forall (a :: Symbol). AttrLabelProxy a
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 :: TypeValueTable -> p
fromLabel = forall {k} (i :: k) o s. OverloadedMethod i o s => o -> s
forall i o s. OverloadedMethod i o s => o -> s
O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveTypeValueTableMethod t TypeValueTable, O.OverloadedMethod info TypeValueTable p, R.HasField t TypeValueTable p) => R.HasField t TypeValueTable p where
getField :: TypeValueTable -> p
getField = forall {k} (i :: k) o s. OverloadedMethod i o s => o -> s
forall i o s. OverloadedMethod i o s => o -> s
O.overloadedMethod @info
#endif
instance (info ~ ResolveTypeValueTableMethod t TypeValueTable, O.OverloadedMethodInfo info TypeValueTable) => OL.IsLabel t (O.MethodProxy info TypeValueTable) where
#if MIN_VERSION_base(4,10,0)
fromLabel :: MethodProxy info TypeValueTable
fromLabel = MethodProxy info TypeValueTable
forall info obj. MethodProxy info obj
O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif