{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.GObject.Structs.ObjectClass
(
ObjectClass(..) ,
newZeroObjectClass ,
#if defined(ENABLE_OVERLOADING)
ResolveObjectClassMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
ObjectClassFindPropertyMethodInfo ,
#endif
objectClassFindProperty ,
#if defined(ENABLE_OVERLOADING)
ObjectClassInstallPropertyMethodInfo ,
#endif
objectClassInstallProperty ,
#if defined(ENABLE_OVERLOADING)
ObjectClassOverridePropertyMethodInfo ,
#endif
objectClassOverrideProperty ,
clearObjectClassConstructed ,
getObjectClassConstructed ,
#if defined(ENABLE_OVERLOADING)
objectClass_constructed ,
#endif
setObjectClassConstructed ,
clearObjectClassDispatchPropertiesChanged,
getObjectClassDispatchPropertiesChanged ,
#if defined(ENABLE_OVERLOADING)
objectClass_dispatchPropertiesChanged ,
#endif
setObjectClassDispatchPropertiesChanged ,
clearObjectClassDispose ,
getObjectClassDispose ,
#if defined(ENABLE_OVERLOADING)
objectClass_dispose ,
#endif
setObjectClassDispose ,
clearObjectClassFinalize ,
getObjectClassFinalize ,
#if defined(ENABLE_OVERLOADING)
objectClass_finalize ,
#endif
setObjectClassFinalize ,
getObjectClassGTypeClass ,
#if defined(ENABLE_OVERLOADING)
objectClass_gTypeClass ,
#endif
clearObjectClassGetProperty ,
getObjectClassGetProperty ,
#if defined(ENABLE_OVERLOADING)
objectClass_getProperty ,
#endif
setObjectClassGetProperty ,
clearObjectClassNotify ,
getObjectClassNotify ,
#if defined(ENABLE_OVERLOADING)
objectClass_notify ,
#endif
setObjectClassNotify ,
clearObjectClassSetProperty ,
getObjectClassSetProperty ,
#if defined(ENABLE_OVERLOADING)
objectClass_setProperty ,
#endif
setObjectClassSetProperty ,
) 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
import {-# SOURCE #-} qualified GI.GObject.Structs.TypeClass as GObject.TypeClass
newtype ObjectClass = ObjectClass (SP.ManagedPtr ObjectClass)
deriving (ObjectClass -> ObjectClass -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ObjectClass -> ObjectClass -> Bool
$c/= :: ObjectClass -> ObjectClass -> Bool
== :: ObjectClass -> ObjectClass -> Bool
$c== :: ObjectClass -> ObjectClass -> Bool
Eq)
instance SP.ManagedPtrNewtype ObjectClass where
toManagedPtr :: ObjectClass -> ManagedPtr ObjectClass
toManagedPtr (ObjectClass ManagedPtr ObjectClass
p) = ManagedPtr ObjectClass
p
instance BoxedPtr ObjectClass where
boxedPtrCopy :: ObjectClass -> IO ObjectClass
boxedPtrCopy = \ObjectClass
p -> forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr ObjectClass
p (forall a. (HasCallStack, CallocPtr a) => Int -> Ptr a -> IO (Ptr a)
copyBytes Int
68 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 ObjectClass -> ObjectClass
ObjectClass)
boxedPtrFree :: ObjectClass -> IO ()
boxedPtrFree = \ObjectClass
x -> forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
SP.withManagedPtr ObjectClass
x forall a. Ptr a -> IO ()
SP.freeMem
instance CallocPtr ObjectClass where
boxedPtrCalloc :: IO (Ptr ObjectClass)
boxedPtrCalloc = forall a. Int -> IO (Ptr a)
callocBytes Int
68
newZeroObjectClass :: MonadIO m => m ObjectClass
newZeroObjectClass :: forall (m :: * -> *). MonadIO m => m ObjectClass
newZeroObjectClass = 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 ObjectClass -> ObjectClass
ObjectClass
instance tag ~ 'AttrSet => Constructible ObjectClass tag where
new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr ObjectClass -> ObjectClass)
-> [AttrOp ObjectClass tag] -> m ObjectClass
new ManagedPtr ObjectClass -> ObjectClass
_ [AttrOp ObjectClass tag]
attrs = do
ObjectClass
o <- forall (m :: * -> *). MonadIO m => m ObjectClass
newZeroObjectClass
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set ObjectClass
o [AttrOp ObjectClass tag]
attrs
forall (m :: * -> *) a. Monad m => a -> m a
return ObjectClass
o
getObjectClassGTypeClass :: MonadIO m => ObjectClass -> m GObject.TypeClass.TypeClass
getObjectClassGTypeClass :: forall (m :: * -> *). MonadIO m => ObjectClass -> m TypeClass
getObjectClassGTypeClass ObjectClass
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 ObjectClass
s forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
let val :: Ptr TypeClass
val = Ptr ObjectClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0 :: (Ptr GObject.TypeClass.TypeClass)
TypeClass
val' <- (forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr TypeClass -> TypeClass
GObject.TypeClass.TypeClass) Ptr TypeClass
val
forall (m :: * -> *) a. Monad m => a -> m a
return TypeClass
val'
#if defined(ENABLE_OVERLOADING)
data ObjectClassGTypeClassFieldInfo
instance AttrInfo ObjectClassGTypeClassFieldInfo where
type AttrBaseTypeConstraint ObjectClassGTypeClassFieldInfo = (~) ObjectClass
type AttrAllowedOps ObjectClassGTypeClassFieldInfo = '[ 'AttrGet]
type AttrSetTypeConstraint ObjectClassGTypeClassFieldInfo = (~) (Ptr GObject.TypeClass.TypeClass)
type AttrTransferTypeConstraint ObjectClassGTypeClassFieldInfo = (~)(Ptr GObject.TypeClass.TypeClass)
type AttrTransferType ObjectClassGTypeClassFieldInfo = (Ptr GObject.TypeClass.TypeClass)
type AttrGetType ObjectClassGTypeClassFieldInfo = GObject.TypeClass.TypeClass
type AttrLabel ObjectClassGTypeClassFieldInfo = "g_type_class"
type AttrOrigin ObjectClassGTypeClassFieldInfo = ObjectClass
attrGet = getObjectClassGTypeClass
attrSet = undefined
attrConstruct = undefined
attrClear = undefined
attrTransfer = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GObject.Structs.ObjectClass.gTypeClass"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.28/docs/GI-GObject-Structs-ObjectClass.html#g:attr:gTypeClass"
})
objectClass_gTypeClass :: AttrLabelProxy "gTypeClass"
objectClass_gTypeClass = AttrLabelProxy
#endif
getObjectClassSetProperty :: MonadIO m => ObjectClass -> m (Maybe GObject.Callbacks.ObjectClassSetPropertyFieldCallback)
getObjectClassSetProperty :: forall (m :: * -> *).
MonadIO m =>
ObjectClass -> m (Maybe ObjectClassSetPropertyFieldCallback)
getObjectClassSetProperty ObjectClass
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 ObjectClass
s forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
FunPtr C_ObjectClassSetPropertyFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr ObjectClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
12) :: IO (FunPtr GObject.Callbacks.C_ObjectClassSetPropertyFieldCallback)
Maybe ObjectClassSetPropertyFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_ObjectClassSetPropertyFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_ObjectClassSetPropertyFieldCallback
val' -> do
let val'' :: ObjectClassSetPropertyFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
FunPtr C_ObjectClassSetPropertyFieldCallback
-> a -> Word32 -> GValue -> GParamSpec -> m ()
GObject.Callbacks.dynamic_ObjectClassSetPropertyFieldCallback FunPtr C_ObjectClassSetPropertyFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return ObjectClassSetPropertyFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ObjectClassSetPropertyFieldCallback
result
setObjectClassSetProperty :: MonadIO m => ObjectClass -> FunPtr GObject.Callbacks.C_ObjectClassSetPropertyFieldCallback -> m ()
setObjectClassSetProperty :: forall (m :: * -> *).
MonadIO m =>
ObjectClass -> FunPtr C_ObjectClassSetPropertyFieldCallback -> m ()
setObjectClassSetProperty ObjectClass
s FunPtr C_ObjectClassSetPropertyFieldCallback
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 ObjectClass
s forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
12) (FunPtr C_ObjectClassSetPropertyFieldCallback
val :: FunPtr GObject.Callbacks.C_ObjectClassSetPropertyFieldCallback)
clearObjectClassSetProperty :: MonadIO m => ObjectClass -> m ()
clearObjectClassSetProperty :: forall (m :: * -> *). MonadIO m => ObjectClass -> m ()
clearObjectClassSetProperty ObjectClass
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 ObjectClass
s forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
12) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr GObject.Callbacks.C_ObjectClassSetPropertyFieldCallback)
#if defined(ENABLE_OVERLOADING)
data ObjectClassSetPropertyFieldInfo
instance AttrInfo ObjectClassSetPropertyFieldInfo where
type AttrBaseTypeConstraint ObjectClassSetPropertyFieldInfo = (~) ObjectClass
type AttrAllowedOps ObjectClassSetPropertyFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint ObjectClassSetPropertyFieldInfo = (~) (FunPtr GObject.Callbacks.C_ObjectClassSetPropertyFieldCallback)
type AttrTransferTypeConstraint ObjectClassSetPropertyFieldInfo = (~)GObject.Callbacks.ObjectClassSetPropertyFieldCallback
type AttrTransferType ObjectClassSetPropertyFieldInfo = (FunPtr GObject.Callbacks.C_ObjectClassSetPropertyFieldCallback)
type AttrGetType ObjectClassSetPropertyFieldInfo = Maybe GObject.Callbacks.ObjectClassSetPropertyFieldCallback
type AttrLabel ObjectClassSetPropertyFieldInfo = "set_property"
type AttrOrigin ObjectClassSetPropertyFieldInfo = ObjectClass
attrGet = getObjectClassSetProperty
attrSet = setObjectClassSetProperty
attrConstruct = undefined
attrClear = clearObjectClassSetProperty
attrTransfer _ v = do
GObject.Callbacks.mk_ObjectClassSetPropertyFieldCallback (GObject.Callbacks.wrap_ObjectClassSetPropertyFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GObject.Structs.ObjectClass.setProperty"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.28/docs/GI-GObject-Structs-ObjectClass.html#g:attr:setProperty"
})
objectClass_setProperty :: AttrLabelProxy "setProperty"
objectClass_setProperty = AttrLabelProxy
#endif
getObjectClassGetProperty :: MonadIO m => ObjectClass -> m (Maybe GObject.Callbacks.ObjectClassGetPropertyFieldCallback)
getObjectClassGetProperty :: forall (m :: * -> *).
MonadIO m =>
ObjectClass -> m (Maybe ObjectClassSetPropertyFieldCallback)
getObjectClassGetProperty ObjectClass
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 ObjectClass
s forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
FunPtr C_ObjectClassSetPropertyFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr ObjectClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) :: IO (FunPtr GObject.Callbacks.C_ObjectClassGetPropertyFieldCallback)
Maybe ObjectClassSetPropertyFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_ObjectClassSetPropertyFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_ObjectClassSetPropertyFieldCallback
val' -> do
let val'' :: ObjectClassSetPropertyFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
FunPtr C_ObjectClassSetPropertyFieldCallback
-> a -> Word32 -> GValue -> GParamSpec -> m ()
GObject.Callbacks.dynamic_ObjectClassGetPropertyFieldCallback FunPtr C_ObjectClassSetPropertyFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return ObjectClassSetPropertyFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ObjectClassSetPropertyFieldCallback
result
setObjectClassGetProperty :: MonadIO m => ObjectClass -> FunPtr GObject.Callbacks.C_ObjectClassGetPropertyFieldCallback -> m ()
setObjectClassGetProperty :: forall (m :: * -> *).
MonadIO m =>
ObjectClass -> FunPtr C_ObjectClassSetPropertyFieldCallback -> m ()
setObjectClassGetProperty ObjectClass
s FunPtr C_ObjectClassSetPropertyFieldCallback
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 ObjectClass
s forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (FunPtr C_ObjectClassSetPropertyFieldCallback
val :: FunPtr GObject.Callbacks.C_ObjectClassGetPropertyFieldCallback)
clearObjectClassGetProperty :: MonadIO m => ObjectClass -> m ()
clearObjectClassGetProperty :: forall (m :: * -> *). MonadIO m => ObjectClass -> m ()
clearObjectClassGetProperty ObjectClass
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 ObjectClass
s forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr GObject.Callbacks.C_ObjectClassGetPropertyFieldCallback)
#if defined(ENABLE_OVERLOADING)
data ObjectClassGetPropertyFieldInfo
instance AttrInfo ObjectClassGetPropertyFieldInfo where
type AttrBaseTypeConstraint ObjectClassGetPropertyFieldInfo = (~) ObjectClass
type AttrAllowedOps ObjectClassGetPropertyFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint ObjectClassGetPropertyFieldInfo = (~) (FunPtr GObject.Callbacks.C_ObjectClassGetPropertyFieldCallback)
type AttrTransferTypeConstraint ObjectClassGetPropertyFieldInfo = (~)GObject.Callbacks.ObjectClassGetPropertyFieldCallback
type AttrTransferType ObjectClassGetPropertyFieldInfo = (FunPtr GObject.Callbacks.C_ObjectClassGetPropertyFieldCallback)
type AttrGetType ObjectClassGetPropertyFieldInfo = Maybe GObject.Callbacks.ObjectClassGetPropertyFieldCallback
type AttrLabel ObjectClassGetPropertyFieldInfo = "get_property"
type AttrOrigin ObjectClassGetPropertyFieldInfo = ObjectClass
attrGet = getObjectClassGetProperty
attrSet = setObjectClassGetProperty
attrConstruct = undefined
attrClear = clearObjectClassGetProperty
attrTransfer _ v = do
GObject.Callbacks.mk_ObjectClassGetPropertyFieldCallback (GObject.Callbacks.wrap_ObjectClassGetPropertyFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GObject.Structs.ObjectClass.getProperty"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.28/docs/GI-GObject-Structs-ObjectClass.html#g:attr:getProperty"
})
objectClass_getProperty :: AttrLabelProxy "getProperty"
objectClass_getProperty = AttrLabelProxy
#endif
getObjectClassDispose :: MonadIO m => ObjectClass -> m (Maybe GObject.Callbacks.ObjectClassDisposeFieldCallback)
getObjectClassDispose :: forall (m :: * -> *).
MonadIO m =>
ObjectClass -> m (Maybe ObjectClassDisposeFieldCallback)
getObjectClassDispose ObjectClass
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 ObjectClass
s forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
FunPtr C_ObjectClassDisposeFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr ObjectClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
20) :: IO (FunPtr GObject.Callbacks.C_ObjectClassDisposeFieldCallback)
Maybe ObjectClassDisposeFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_ObjectClassDisposeFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_ObjectClassDisposeFieldCallback
val' -> do
let val'' :: ObjectClassDisposeFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
FunPtr C_ObjectClassDisposeFieldCallback -> a -> m ()
GObject.Callbacks.dynamic_ObjectClassDisposeFieldCallback FunPtr C_ObjectClassDisposeFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return ObjectClassDisposeFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ObjectClassDisposeFieldCallback
result
setObjectClassDispose :: MonadIO m => ObjectClass -> FunPtr GObject.Callbacks.C_ObjectClassDisposeFieldCallback -> m ()
setObjectClassDispose :: forall (m :: * -> *).
MonadIO m =>
ObjectClass -> FunPtr C_ObjectClassDisposeFieldCallback -> m ()
setObjectClassDispose ObjectClass
s FunPtr C_ObjectClassDisposeFieldCallback
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 ObjectClass
s forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
20) (FunPtr C_ObjectClassDisposeFieldCallback
val :: FunPtr GObject.Callbacks.C_ObjectClassDisposeFieldCallback)
clearObjectClassDispose :: MonadIO m => ObjectClass -> m ()
clearObjectClassDispose :: forall (m :: * -> *). MonadIO m => ObjectClass -> m ()
clearObjectClassDispose ObjectClass
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 ObjectClass
s forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
20) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr GObject.Callbacks.C_ObjectClassDisposeFieldCallback)
#if defined(ENABLE_OVERLOADING)
data ObjectClassDisposeFieldInfo
instance AttrInfo ObjectClassDisposeFieldInfo where
type AttrBaseTypeConstraint ObjectClassDisposeFieldInfo = (~) ObjectClass
type AttrAllowedOps ObjectClassDisposeFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint ObjectClassDisposeFieldInfo = (~) (FunPtr GObject.Callbacks.C_ObjectClassDisposeFieldCallback)
type AttrTransferTypeConstraint ObjectClassDisposeFieldInfo = (~)GObject.Callbacks.ObjectClassDisposeFieldCallback
type AttrTransferType ObjectClassDisposeFieldInfo = (FunPtr GObject.Callbacks.C_ObjectClassDisposeFieldCallback)
type AttrGetType ObjectClassDisposeFieldInfo = Maybe GObject.Callbacks.ObjectClassDisposeFieldCallback
type AttrLabel ObjectClassDisposeFieldInfo = "dispose"
type AttrOrigin ObjectClassDisposeFieldInfo = ObjectClass
attrGet = getObjectClassDispose
attrSet = setObjectClassDispose
attrConstruct = undefined
attrClear = clearObjectClassDispose
attrTransfer _ v = do
GObject.Callbacks.mk_ObjectClassDisposeFieldCallback (GObject.Callbacks.wrap_ObjectClassDisposeFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GObject.Structs.ObjectClass.dispose"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.28/docs/GI-GObject-Structs-ObjectClass.html#g:attr:dispose"
})
objectClass_dispose :: AttrLabelProxy "dispose"
objectClass_dispose = AttrLabelProxy
#endif
getObjectClassFinalize :: MonadIO m => ObjectClass -> m (Maybe GObject.Callbacks.ObjectClassFinalizeFieldCallback)
getObjectClassFinalize :: forall (m :: * -> *).
MonadIO m =>
ObjectClass -> m (Maybe ObjectClassDisposeFieldCallback)
getObjectClassFinalize ObjectClass
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 ObjectClass
s forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
FunPtr C_ObjectClassDisposeFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr ObjectClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) :: IO (FunPtr GObject.Callbacks.C_ObjectClassFinalizeFieldCallback)
Maybe ObjectClassDisposeFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_ObjectClassDisposeFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_ObjectClassDisposeFieldCallback
val' -> do
let val'' :: ObjectClassDisposeFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
FunPtr C_ObjectClassDisposeFieldCallback -> a -> m ()
GObject.Callbacks.dynamic_ObjectClassFinalizeFieldCallback FunPtr C_ObjectClassDisposeFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return ObjectClassDisposeFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ObjectClassDisposeFieldCallback
result
setObjectClassFinalize :: MonadIO m => ObjectClass -> FunPtr GObject.Callbacks.C_ObjectClassFinalizeFieldCallback -> m ()
setObjectClassFinalize :: forall (m :: * -> *).
MonadIO m =>
ObjectClass -> FunPtr C_ObjectClassDisposeFieldCallback -> m ()
setObjectClassFinalize ObjectClass
s FunPtr C_ObjectClassDisposeFieldCallback
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 ObjectClass
s forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) (FunPtr C_ObjectClassDisposeFieldCallback
val :: FunPtr GObject.Callbacks.C_ObjectClassFinalizeFieldCallback)
clearObjectClassFinalize :: MonadIO m => ObjectClass -> m ()
clearObjectClassFinalize :: forall (m :: * -> *). MonadIO m => ObjectClass -> m ()
clearObjectClassFinalize ObjectClass
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 ObjectClass
s forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr GObject.Callbacks.C_ObjectClassFinalizeFieldCallback)
#if defined(ENABLE_OVERLOADING)
data ObjectClassFinalizeFieldInfo
instance AttrInfo ObjectClassFinalizeFieldInfo where
type AttrBaseTypeConstraint ObjectClassFinalizeFieldInfo = (~) ObjectClass
type AttrAllowedOps ObjectClassFinalizeFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint ObjectClassFinalizeFieldInfo = (~) (FunPtr GObject.Callbacks.C_ObjectClassFinalizeFieldCallback)
type AttrTransferTypeConstraint ObjectClassFinalizeFieldInfo = (~)GObject.Callbacks.ObjectClassFinalizeFieldCallback
type AttrTransferType ObjectClassFinalizeFieldInfo = (FunPtr GObject.Callbacks.C_ObjectClassFinalizeFieldCallback)
type AttrGetType ObjectClassFinalizeFieldInfo = Maybe GObject.Callbacks.ObjectClassFinalizeFieldCallback
type AttrLabel ObjectClassFinalizeFieldInfo = "finalize"
type AttrOrigin ObjectClassFinalizeFieldInfo = ObjectClass
attrGet = getObjectClassFinalize
attrSet = setObjectClassFinalize
attrConstruct = undefined
attrClear = clearObjectClassFinalize
attrTransfer _ v = do
GObject.Callbacks.mk_ObjectClassFinalizeFieldCallback (GObject.Callbacks.wrap_ObjectClassFinalizeFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GObject.Structs.ObjectClass.finalize"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.28/docs/GI-GObject-Structs-ObjectClass.html#g:attr:finalize"
})
objectClass_finalize :: AttrLabelProxy "finalize"
objectClass_finalize = AttrLabelProxy
#endif
getObjectClassDispatchPropertiesChanged :: MonadIO m => ObjectClass -> m (Maybe GObject.Callbacks.ObjectClassDispatchPropertiesChangedFieldCallback)
getObjectClassDispatchPropertiesChanged :: forall (m :: * -> *).
MonadIO m =>
ObjectClass
-> m (Maybe ObjectClassDispatchPropertiesChangedFieldCallback)
getObjectClassDispatchPropertiesChanged ObjectClass
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 ObjectClass
s forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
FunPtr C_ObjectClassDispatchPropertiesChangedFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr ObjectClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
28) :: IO (FunPtr GObject.Callbacks.C_ObjectClassDispatchPropertiesChangedFieldCallback)
Maybe ObjectClassDispatchPropertiesChangedFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_ObjectClassDispatchPropertiesChangedFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_ObjectClassDispatchPropertiesChangedFieldCallback
val' -> do
let val'' :: ObjectClassDispatchPropertiesChangedFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
FunPtr C_ObjectClassDispatchPropertiesChangedFieldCallback
-> a -> Word32 -> GParamSpec -> m ()
GObject.Callbacks.dynamic_ObjectClassDispatchPropertiesChangedFieldCallback FunPtr C_ObjectClassDispatchPropertiesChangedFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return ObjectClassDispatchPropertiesChangedFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ObjectClassDispatchPropertiesChangedFieldCallback
result
setObjectClassDispatchPropertiesChanged :: MonadIO m => ObjectClass -> FunPtr GObject.Callbacks.C_ObjectClassDispatchPropertiesChangedFieldCallback -> m ()
setObjectClassDispatchPropertiesChanged :: forall (m :: * -> *).
MonadIO m =>
ObjectClass
-> FunPtr C_ObjectClassDispatchPropertiesChangedFieldCallback
-> m ()
setObjectClassDispatchPropertiesChanged ObjectClass
s FunPtr C_ObjectClassDispatchPropertiesChangedFieldCallback
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 ObjectClass
s forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
28) (FunPtr C_ObjectClassDispatchPropertiesChangedFieldCallback
val :: FunPtr GObject.Callbacks.C_ObjectClassDispatchPropertiesChangedFieldCallback)
clearObjectClassDispatchPropertiesChanged :: MonadIO m => ObjectClass -> m ()
clearObjectClassDispatchPropertiesChanged :: forall (m :: * -> *). MonadIO m => ObjectClass -> m ()
clearObjectClassDispatchPropertiesChanged ObjectClass
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 ObjectClass
s forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
28) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr GObject.Callbacks.C_ObjectClassDispatchPropertiesChangedFieldCallback)
#if defined(ENABLE_OVERLOADING)
data ObjectClassDispatchPropertiesChangedFieldInfo
instance AttrInfo ObjectClassDispatchPropertiesChangedFieldInfo where
type AttrBaseTypeConstraint ObjectClassDispatchPropertiesChangedFieldInfo = (~) ObjectClass
type AttrAllowedOps ObjectClassDispatchPropertiesChangedFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint ObjectClassDispatchPropertiesChangedFieldInfo = (~) (FunPtr GObject.Callbacks.C_ObjectClassDispatchPropertiesChangedFieldCallback)
type AttrTransferTypeConstraint ObjectClassDispatchPropertiesChangedFieldInfo = (~)GObject.Callbacks.ObjectClassDispatchPropertiesChangedFieldCallback
type AttrTransferType ObjectClassDispatchPropertiesChangedFieldInfo = (FunPtr GObject.Callbacks.C_ObjectClassDispatchPropertiesChangedFieldCallback)
type AttrGetType ObjectClassDispatchPropertiesChangedFieldInfo = Maybe GObject.Callbacks.ObjectClassDispatchPropertiesChangedFieldCallback
type AttrLabel ObjectClassDispatchPropertiesChangedFieldInfo = "dispatch_properties_changed"
type AttrOrigin ObjectClassDispatchPropertiesChangedFieldInfo = ObjectClass
attrGet = getObjectClassDispatchPropertiesChanged
attrSet = setObjectClassDispatchPropertiesChanged
attrConstruct = undefined
attrClear = clearObjectClassDispatchPropertiesChanged
attrTransfer _ v = do
GObject.Callbacks.mk_ObjectClassDispatchPropertiesChangedFieldCallback (GObject.Callbacks.wrap_ObjectClassDispatchPropertiesChangedFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GObject.Structs.ObjectClass.dispatchPropertiesChanged"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.28/docs/GI-GObject-Structs-ObjectClass.html#g:attr:dispatchPropertiesChanged"
})
objectClass_dispatchPropertiesChanged :: AttrLabelProxy "dispatchPropertiesChanged"
objectClass_dispatchPropertiesChanged = AttrLabelProxy
#endif
getObjectClassNotify :: MonadIO m => ObjectClass -> m (Maybe GObject.Callbacks.ObjectClassNotifyFieldCallback)
getObjectClassNotify :: forall (m :: * -> *).
MonadIO m =>
ObjectClass -> m (Maybe ObjectClassNotifyFieldCallback)
getObjectClassNotify ObjectClass
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 ObjectClass
s forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
FunPtr C_ObjectClassNotifyFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr ObjectClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) :: IO (FunPtr GObject.Callbacks.C_ObjectClassNotifyFieldCallback)
Maybe ObjectClassNotifyFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_ObjectClassNotifyFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_ObjectClassNotifyFieldCallback
val' -> do
let val'' :: ObjectClassNotifyFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
FunPtr C_ObjectClassNotifyFieldCallback -> a -> GParamSpec -> m ()
GObject.Callbacks.dynamic_ObjectClassNotifyFieldCallback FunPtr C_ObjectClassNotifyFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return ObjectClassNotifyFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ObjectClassNotifyFieldCallback
result
setObjectClassNotify :: MonadIO m => ObjectClass -> FunPtr GObject.Callbacks.C_ObjectClassNotifyFieldCallback -> m ()
setObjectClassNotify :: forall (m :: * -> *).
MonadIO m =>
ObjectClass -> FunPtr C_ObjectClassNotifyFieldCallback -> m ()
setObjectClassNotify ObjectClass
s FunPtr C_ObjectClassNotifyFieldCallback
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 ObjectClass
s forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) (FunPtr C_ObjectClassNotifyFieldCallback
val :: FunPtr GObject.Callbacks.C_ObjectClassNotifyFieldCallback)
clearObjectClassNotify :: MonadIO m => ObjectClass -> m ()
clearObjectClassNotify :: forall (m :: * -> *). MonadIO m => ObjectClass -> m ()
clearObjectClassNotify ObjectClass
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 ObjectClass
s forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr GObject.Callbacks.C_ObjectClassNotifyFieldCallback)
#if defined(ENABLE_OVERLOADING)
data ObjectClassNotifyFieldInfo
instance AttrInfo ObjectClassNotifyFieldInfo where
type AttrBaseTypeConstraint ObjectClassNotifyFieldInfo = (~) ObjectClass
type AttrAllowedOps ObjectClassNotifyFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint ObjectClassNotifyFieldInfo = (~) (FunPtr GObject.Callbacks.C_ObjectClassNotifyFieldCallback)
type AttrTransferTypeConstraint ObjectClassNotifyFieldInfo = (~)GObject.Callbacks.ObjectClassNotifyFieldCallback
type AttrTransferType ObjectClassNotifyFieldInfo = (FunPtr GObject.Callbacks.C_ObjectClassNotifyFieldCallback)
type AttrGetType ObjectClassNotifyFieldInfo = Maybe GObject.Callbacks.ObjectClassNotifyFieldCallback
type AttrLabel ObjectClassNotifyFieldInfo = "notify"
type AttrOrigin ObjectClassNotifyFieldInfo = ObjectClass
attrGet = getObjectClassNotify
attrSet = setObjectClassNotify
attrConstruct = undefined
attrClear = clearObjectClassNotify
attrTransfer _ v = do
GObject.Callbacks.mk_ObjectClassNotifyFieldCallback (GObject.Callbacks.wrap_ObjectClassNotifyFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GObject.Structs.ObjectClass.notify"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.28/docs/GI-GObject-Structs-ObjectClass.html#g:attr:notify"
})
objectClass_notify :: AttrLabelProxy "notify"
objectClass_notify = AttrLabelProxy
#endif
getObjectClassConstructed :: MonadIO m => ObjectClass -> m (Maybe GObject.Callbacks.ObjectClassConstructedFieldCallback)
getObjectClassConstructed :: forall (m :: * -> *).
MonadIO m =>
ObjectClass -> m (Maybe ObjectClassDisposeFieldCallback)
getObjectClassConstructed ObjectClass
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 ObjectClass
s forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
FunPtr C_ObjectClassDisposeFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr ObjectClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
36) :: IO (FunPtr GObject.Callbacks.C_ObjectClassConstructedFieldCallback)
Maybe ObjectClassDisposeFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_ObjectClassDisposeFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_ObjectClassDisposeFieldCallback
val' -> do
let val'' :: ObjectClassDisposeFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
FunPtr C_ObjectClassDisposeFieldCallback -> a -> m ()
GObject.Callbacks.dynamic_ObjectClassConstructedFieldCallback FunPtr C_ObjectClassDisposeFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return ObjectClassDisposeFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ObjectClassDisposeFieldCallback
result
setObjectClassConstructed :: MonadIO m => ObjectClass -> FunPtr GObject.Callbacks.C_ObjectClassConstructedFieldCallback -> m ()
setObjectClassConstructed :: forall (m :: * -> *).
MonadIO m =>
ObjectClass -> FunPtr C_ObjectClassDisposeFieldCallback -> m ()
setObjectClassConstructed ObjectClass
s FunPtr C_ObjectClassDisposeFieldCallback
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 ObjectClass
s forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
36) (FunPtr C_ObjectClassDisposeFieldCallback
val :: FunPtr GObject.Callbacks.C_ObjectClassConstructedFieldCallback)
clearObjectClassConstructed :: MonadIO m => ObjectClass -> m ()
clearObjectClassConstructed :: forall (m :: * -> *). MonadIO m => ObjectClass -> m ()
clearObjectClassConstructed ObjectClass
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 ObjectClass
s forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
36) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr GObject.Callbacks.C_ObjectClassConstructedFieldCallback)
#if defined(ENABLE_OVERLOADING)
data ObjectClassConstructedFieldInfo
instance AttrInfo ObjectClassConstructedFieldInfo where
type AttrBaseTypeConstraint ObjectClassConstructedFieldInfo = (~) ObjectClass
type AttrAllowedOps ObjectClassConstructedFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint ObjectClassConstructedFieldInfo = (~) (FunPtr GObject.Callbacks.C_ObjectClassConstructedFieldCallback)
type AttrTransferTypeConstraint ObjectClassConstructedFieldInfo = (~)GObject.Callbacks.ObjectClassConstructedFieldCallback
type AttrTransferType ObjectClassConstructedFieldInfo = (FunPtr GObject.Callbacks.C_ObjectClassConstructedFieldCallback)
type AttrGetType ObjectClassConstructedFieldInfo = Maybe GObject.Callbacks.ObjectClassConstructedFieldCallback
type AttrLabel ObjectClassConstructedFieldInfo = "constructed"
type AttrOrigin ObjectClassConstructedFieldInfo = ObjectClass
attrGet = getObjectClassConstructed
attrSet = setObjectClassConstructed
attrConstruct = undefined
attrClear = clearObjectClassConstructed
attrTransfer _ v = do
GObject.Callbacks.mk_ObjectClassConstructedFieldCallback (GObject.Callbacks.wrap_ObjectClassConstructedFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GObject.Structs.ObjectClass.constructed"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.28/docs/GI-GObject-Structs-ObjectClass.html#g:attr:constructed"
})
objectClass_constructed :: AttrLabelProxy "constructed"
objectClass_constructed = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList ObjectClass
type instance O.AttributeList ObjectClass = ObjectClassAttributeList
type ObjectClassAttributeList = ('[ '("gTypeClass", ObjectClassGTypeClassFieldInfo), '("setProperty", ObjectClassSetPropertyFieldInfo), '("getProperty", ObjectClassGetPropertyFieldInfo), '("dispose", ObjectClassDisposeFieldInfo), '("finalize", ObjectClassFinalizeFieldInfo), '("dispatchPropertiesChanged", ObjectClassDispatchPropertiesChangedFieldInfo), '("notify", ObjectClassNotifyFieldInfo), '("constructed", ObjectClassConstructedFieldInfo)] :: [(Symbol, DK.Type)])
#endif
foreign import ccall "g_object_class_find_property" g_object_class_find_property ::
Ptr ObjectClass ->
CString ->
IO (Ptr GParamSpec)
objectClassFindProperty ::
(B.CallStack.HasCallStack, MonadIO m) =>
ObjectClass
-> T.Text
-> m GParamSpec
objectClassFindProperty :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
ObjectClass -> Text -> m GParamSpec
objectClassFindProperty ObjectClass
oclass Text
propertyName = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr ObjectClass
oclass' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr ObjectClass
oclass
CString
propertyName' <- Text -> IO CString
textToCString Text
propertyName
Ptr GParamSpec
result <- Ptr ObjectClass -> CString -> IO (Ptr GParamSpec)
g_object_class_find_property Ptr ObjectClass
oclass' CString
propertyName'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"objectClassFindProperty" Ptr GParamSpec
result
GParamSpec
result' <- Ptr GParamSpec -> IO GParamSpec
B.GParamSpec.newGParamSpecFromPtr Ptr GParamSpec
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr ObjectClass
oclass
forall a. Ptr a -> IO ()
freeMem CString
propertyName'
forall (m :: * -> *) a. Monad m => a -> m a
return GParamSpec
result'
#if defined(ENABLE_OVERLOADING)
data ObjectClassFindPropertyMethodInfo
instance (signature ~ (T.Text -> m GParamSpec), MonadIO m) => O.OverloadedMethod ObjectClassFindPropertyMethodInfo ObjectClass signature where
overloadedMethod = objectClassFindProperty
instance O.OverloadedMethodInfo ObjectClassFindPropertyMethodInfo ObjectClass where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GObject.Structs.ObjectClass.objectClassFindProperty",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.28/docs/GI-GObject-Structs-ObjectClass.html#v:objectClassFindProperty"
})
#endif
foreign import ccall "g_object_class_install_property" g_object_class_install_property ::
Ptr ObjectClass ->
Word32 ->
Ptr GParamSpec ->
IO ()
objectClassInstallProperty ::
(B.CallStack.HasCallStack, MonadIO m) =>
ObjectClass
-> Word32
-> GParamSpec
-> m ()
objectClassInstallProperty :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
ObjectClass -> Word32 -> GParamSpec -> m ()
objectClassInstallProperty ObjectClass
oclass Word32
propertyId GParamSpec
pspec = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr ObjectClass
oclass' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr ObjectClass
oclass
Ptr GParamSpec
pspec' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GParamSpec
pspec
Ptr ObjectClass -> Word32 -> Ptr GParamSpec -> IO ()
g_object_class_install_property Ptr ObjectClass
oclass' Word32
propertyId Ptr GParamSpec
pspec'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr ObjectClass
oclass
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GParamSpec
pspec
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ObjectClassInstallPropertyMethodInfo
instance (signature ~ (Word32 -> GParamSpec -> m ()), MonadIO m) => O.OverloadedMethod ObjectClassInstallPropertyMethodInfo ObjectClass signature where
overloadedMethod = objectClassInstallProperty
instance O.OverloadedMethodInfo ObjectClassInstallPropertyMethodInfo ObjectClass where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GObject.Structs.ObjectClass.objectClassInstallProperty",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.28/docs/GI-GObject-Structs-ObjectClass.html#v:objectClassInstallProperty"
})
#endif
foreign import ccall "g_object_class_override_property" g_object_class_override_property ::
Ptr ObjectClass ->
Word32 ->
CString ->
IO ()
objectClassOverrideProperty ::
(B.CallStack.HasCallStack, MonadIO m) =>
ObjectClass
-> Word32
-> T.Text
-> m ()
objectClassOverrideProperty :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
ObjectClass -> Word32 -> Text -> m ()
objectClassOverrideProperty ObjectClass
oclass Word32
propertyId Text
name = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr ObjectClass
oclass' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr ObjectClass
oclass
CString
name' <- Text -> IO CString
textToCString Text
name
Ptr ObjectClass -> Word32 -> CString -> IO ()
g_object_class_override_property Ptr ObjectClass
oclass' Word32
propertyId CString
name'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr ObjectClass
oclass
forall a. Ptr a -> IO ()
freeMem CString
name'
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ObjectClassOverridePropertyMethodInfo
instance (signature ~ (Word32 -> T.Text -> m ()), MonadIO m) => O.OverloadedMethod ObjectClassOverridePropertyMethodInfo ObjectClass signature where
overloadedMethod = objectClassOverrideProperty
instance O.OverloadedMethodInfo ObjectClassOverridePropertyMethodInfo ObjectClass where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GObject.Structs.ObjectClass.objectClassOverrideProperty",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.28/docs/GI-GObject-Structs-ObjectClass.html#v:objectClassOverrideProperty"
})
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveObjectClassMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveObjectClassMethod "findProperty" o = ObjectClassFindPropertyMethodInfo
ResolveObjectClassMethod "installProperty" o = ObjectClassInstallPropertyMethodInfo
ResolveObjectClassMethod "overrideProperty" o = ObjectClassOverridePropertyMethodInfo
ResolveObjectClassMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveObjectClassMethod t ObjectClass, O.OverloadedMethod info ObjectClass p) => OL.IsLabel t (ObjectClass -> 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 ~ ResolveObjectClassMethod t ObjectClass, O.OverloadedMethod info ObjectClass p, R.HasField t ObjectClass p) => R.HasField t ObjectClass p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveObjectClassMethod t ObjectClass, O.OverloadedMethodInfo info ObjectClass) => OL.IsLabel t (O.MethodProxy info ObjectClass) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif