{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- The class structure for the GInitiallyUnowned type.

#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.GObject.Structs.InitiallyUnownedClass
    ( 

-- * Exported types
    InitiallyUnownedClass(..)               ,
    newZeroInitiallyUnownedClass            ,


 -- * Methods

#if defined(ENABLE_OVERLOADING)
    ResolveInitiallyUnownedClassMethod      ,
#endif



 -- * Properties


-- ** constructed #attr:constructed#
-- | /No description available in the introspection data./

    clearInitiallyUnownedClassConstructed   ,
    getInitiallyUnownedClassConstructed     ,
#if defined(ENABLE_OVERLOADING)
    initiallyUnownedClass_constructed       ,
#endif
    setInitiallyUnownedClassConstructed     ,


-- ** dispatchPropertiesChanged #attr:dispatchPropertiesChanged#
-- | /No description available in the introspection data./

    clearInitiallyUnownedClassDispatchPropertiesChanged,
    getInitiallyUnownedClassDispatchPropertiesChanged,
#if defined(ENABLE_OVERLOADING)
    initiallyUnownedClass_dispatchPropertiesChanged,
#endif
    setInitiallyUnownedClassDispatchPropertiesChanged,


-- ** dispose #attr:dispose#
-- | /No description available in the introspection data./

    clearInitiallyUnownedClassDispose       ,
    getInitiallyUnownedClassDispose         ,
#if defined(ENABLE_OVERLOADING)
    initiallyUnownedClass_dispose           ,
#endif
    setInitiallyUnownedClassDispose         ,


-- ** finalize #attr:finalize#
-- | /No description available in the introspection data./

    clearInitiallyUnownedClassFinalize      ,
    getInitiallyUnownedClassFinalize        ,
#if defined(ENABLE_OVERLOADING)
    initiallyUnownedClass_finalize          ,
#endif
    setInitiallyUnownedClassFinalize        ,


-- ** gTypeClass #attr:gTypeClass#
-- | the parent class

    getInitiallyUnownedClassGTypeClass      ,
#if defined(ENABLE_OVERLOADING)
    initiallyUnownedClass_gTypeClass        ,
#endif


-- ** getProperty #attr:getProperty#
-- | /No description available in the introspection data./

    clearInitiallyUnownedClassGetProperty   ,
    getInitiallyUnownedClassGetProperty     ,
#if defined(ENABLE_OVERLOADING)
    initiallyUnownedClass_getProperty       ,
#endif
    setInitiallyUnownedClassGetProperty     ,


-- ** notify #attr:notify#
-- | /No description available in the introspection data./

    clearInitiallyUnownedClassNotify        ,
    getInitiallyUnownedClassNotify          ,
#if defined(ENABLE_OVERLOADING)
    initiallyUnownedClass_notify            ,
#endif
    setInitiallyUnownedClassNotify          ,


-- ** setProperty #attr:setProperty#
-- | /No description available in the introspection data./

    clearInitiallyUnownedClassSetProperty   ,
    getInitiallyUnownedClassSetProperty     ,
#if defined(ENABLE_OVERLOADING)
    initiallyUnownedClass_setProperty       ,
#endif
    setInitiallyUnownedClassSetProperty     ,




    ) 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

-- | Memory-managed wrapper type.
newtype InitiallyUnownedClass = InitiallyUnownedClass (SP.ManagedPtr InitiallyUnownedClass)
    deriving (InitiallyUnownedClass -> InitiallyUnownedClass -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: InitiallyUnownedClass -> InitiallyUnownedClass -> Bool
$c/= :: InitiallyUnownedClass -> InitiallyUnownedClass -> Bool
== :: InitiallyUnownedClass -> InitiallyUnownedClass -> Bool
$c== :: InitiallyUnownedClass -> InitiallyUnownedClass -> Bool
Eq)

instance SP.ManagedPtrNewtype InitiallyUnownedClass where
    toManagedPtr :: InitiallyUnownedClass -> ManagedPtr InitiallyUnownedClass
toManagedPtr (InitiallyUnownedClass ManagedPtr InitiallyUnownedClass
p) = ManagedPtr InitiallyUnownedClass
p

instance BoxedPtr InitiallyUnownedClass where
    boxedPtrCopy :: InitiallyUnownedClass -> IO InitiallyUnownedClass
boxedPtrCopy = \InitiallyUnownedClass
p -> forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr InitiallyUnownedClass
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 InitiallyUnownedClass -> InitiallyUnownedClass
InitiallyUnownedClass)
    boxedPtrFree :: InitiallyUnownedClass -> IO ()
boxedPtrFree = \InitiallyUnownedClass
x -> forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
SP.withManagedPtr InitiallyUnownedClass
x forall a. Ptr a -> IO ()
SP.freeMem
instance CallocPtr InitiallyUnownedClass where
    boxedPtrCalloc :: IO (Ptr InitiallyUnownedClass)
boxedPtrCalloc = forall a. Int -> IO (Ptr a)
callocBytes Int
68


-- | Construct a `InitiallyUnownedClass` struct initialized to zero.
newZeroInitiallyUnownedClass :: MonadIO m => m InitiallyUnownedClass
newZeroInitiallyUnownedClass :: forall (m :: * -> *). MonadIO m => m InitiallyUnownedClass
newZeroInitiallyUnownedClass = 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 InitiallyUnownedClass -> InitiallyUnownedClass
InitiallyUnownedClass

instance tag ~ 'AttrSet => Constructible InitiallyUnownedClass tag where
    new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr InitiallyUnownedClass -> InitiallyUnownedClass)
-> [AttrOp InitiallyUnownedClass tag] -> m InitiallyUnownedClass
new ManagedPtr InitiallyUnownedClass -> InitiallyUnownedClass
_ [AttrOp InitiallyUnownedClass tag]
attrs = do
        InitiallyUnownedClass
o <- forall (m :: * -> *). MonadIO m => m InitiallyUnownedClass
newZeroInitiallyUnownedClass
        forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set InitiallyUnownedClass
o [AttrOp InitiallyUnownedClass tag]
attrs
        forall (m :: * -> *) a. Monad m => a -> m a
return InitiallyUnownedClass
o


-- | Get the value of the “@g_type_class@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' initiallyUnownedClass #gTypeClass
-- @
getInitiallyUnownedClassGTypeClass :: MonadIO m => InitiallyUnownedClass -> m GObject.TypeClass.TypeClass
getInitiallyUnownedClassGTypeClass :: forall (m :: * -> *).
MonadIO m =>
InitiallyUnownedClass -> m TypeClass
getInitiallyUnownedClassGTypeClass InitiallyUnownedClass
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 InitiallyUnownedClass
s forall a b. (a -> b) -> a -> b
$ \Ptr InitiallyUnownedClass
ptr -> do
    let val :: Ptr TypeClass
val = Ptr InitiallyUnownedClass
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 InitiallyUnownedClassGTypeClassFieldInfo
instance AttrInfo InitiallyUnownedClassGTypeClassFieldInfo where
    type AttrBaseTypeConstraint InitiallyUnownedClassGTypeClassFieldInfo = (~) InitiallyUnownedClass
    type AttrAllowedOps InitiallyUnownedClassGTypeClassFieldInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint InitiallyUnownedClassGTypeClassFieldInfo = (~) (Ptr GObject.TypeClass.TypeClass)
    type AttrTransferTypeConstraint InitiallyUnownedClassGTypeClassFieldInfo = (~)(Ptr GObject.TypeClass.TypeClass)
    type AttrTransferType InitiallyUnownedClassGTypeClassFieldInfo = (Ptr GObject.TypeClass.TypeClass)
    type AttrGetType InitiallyUnownedClassGTypeClassFieldInfo = GObject.TypeClass.TypeClass
    type AttrLabel InitiallyUnownedClassGTypeClassFieldInfo = "g_type_class"
    type AttrOrigin InitiallyUnownedClassGTypeClassFieldInfo = InitiallyUnownedClass
    attrGet = getInitiallyUnownedClassGTypeClass
    attrSet = undefined
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GObject.Structs.InitiallyUnownedClass.gTypeClass"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.28/docs/GI-GObject-Structs-InitiallyUnownedClass.html#g:attr:gTypeClass"
        })

initiallyUnownedClass_gTypeClass :: AttrLabelProxy "gTypeClass"
initiallyUnownedClass_gTypeClass = AttrLabelProxy

#endif


-- | Get the value of the “@set_property@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' initiallyUnownedClass #setProperty
-- @
getInitiallyUnownedClassSetProperty :: MonadIO m => InitiallyUnownedClass -> m (Maybe GObject.Callbacks.InitiallyUnownedClassSetPropertyFieldCallback)
getInitiallyUnownedClassSetProperty :: forall (m :: * -> *).
MonadIO m =>
InitiallyUnownedClass
-> m (Maybe InitiallyUnownedClassSetPropertyFieldCallback)
getInitiallyUnownedClassSetProperty InitiallyUnownedClass
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 InitiallyUnownedClass
s forall a b. (a -> b) -> a -> b
$ \Ptr InitiallyUnownedClass
ptr -> do
    FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr InitiallyUnownedClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
12) :: IO (FunPtr GObject.Callbacks.C_InitiallyUnownedClassSetPropertyFieldCallback)
    Maybe InitiallyUnownedClassSetPropertyFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback
val' -> do
        let val'' :: InitiallyUnownedClassSetPropertyFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback
-> a -> Word32 -> GValue -> GParamSpec -> m ()
GObject.Callbacks.dynamic_InitiallyUnownedClassSetPropertyFieldCallback FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback
val'
        forall (m :: * -> *) a. Monad m => a -> m a
return InitiallyUnownedClassSetPropertyFieldCallback
val''
    forall (m :: * -> *) a. Monad m => a -> m a
return Maybe InitiallyUnownedClassSetPropertyFieldCallback
result

-- | Set the value of the “@set_property@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' initiallyUnownedClass [ #setProperty 'Data.GI.Base.Attributes.:=' value ]
-- @
setInitiallyUnownedClassSetProperty :: MonadIO m => InitiallyUnownedClass -> FunPtr GObject.Callbacks.C_InitiallyUnownedClassSetPropertyFieldCallback -> m ()
setInitiallyUnownedClassSetProperty :: forall (m :: * -> *).
MonadIO m =>
InitiallyUnownedClass
-> FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback -> m ()
setInitiallyUnownedClassSetProperty InitiallyUnownedClass
s FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback
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 InitiallyUnownedClass
s forall a b. (a -> b) -> a -> b
$ \Ptr InitiallyUnownedClass
ptr -> do
    forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr InitiallyUnownedClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
12) (FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback
val :: FunPtr GObject.Callbacks.C_InitiallyUnownedClassSetPropertyFieldCallback)

-- | Set the value of the “@set_property@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #setProperty
-- @
clearInitiallyUnownedClassSetProperty :: MonadIO m => InitiallyUnownedClass -> m ()
clearInitiallyUnownedClassSetProperty :: forall (m :: * -> *). MonadIO m => InitiallyUnownedClass -> m ()
clearInitiallyUnownedClassSetProperty InitiallyUnownedClass
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 InitiallyUnownedClass
s forall a b. (a -> b) -> a -> b
$ \Ptr InitiallyUnownedClass
ptr -> do
    forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr InitiallyUnownedClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
12) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr GObject.Callbacks.C_InitiallyUnownedClassSetPropertyFieldCallback)

#if defined(ENABLE_OVERLOADING)
data InitiallyUnownedClassSetPropertyFieldInfo
instance AttrInfo InitiallyUnownedClassSetPropertyFieldInfo where
    type AttrBaseTypeConstraint InitiallyUnownedClassSetPropertyFieldInfo = (~) InitiallyUnownedClass
    type AttrAllowedOps InitiallyUnownedClassSetPropertyFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint InitiallyUnownedClassSetPropertyFieldInfo = (~) (FunPtr GObject.Callbacks.C_InitiallyUnownedClassSetPropertyFieldCallback)
    type AttrTransferTypeConstraint InitiallyUnownedClassSetPropertyFieldInfo = (~)GObject.Callbacks.InitiallyUnownedClassSetPropertyFieldCallback
    type AttrTransferType InitiallyUnownedClassSetPropertyFieldInfo = (FunPtr GObject.Callbacks.C_InitiallyUnownedClassSetPropertyFieldCallback)
    type AttrGetType InitiallyUnownedClassSetPropertyFieldInfo = Maybe GObject.Callbacks.InitiallyUnownedClassSetPropertyFieldCallback
    type AttrLabel InitiallyUnownedClassSetPropertyFieldInfo = "set_property"
    type AttrOrigin InitiallyUnownedClassSetPropertyFieldInfo = InitiallyUnownedClass
    attrGet = getInitiallyUnownedClassSetProperty
    attrSet = setInitiallyUnownedClassSetProperty
    attrConstruct = undefined
    attrClear = clearInitiallyUnownedClassSetProperty
    attrTransfer _ v = do
        GObject.Callbacks.mk_InitiallyUnownedClassSetPropertyFieldCallback (GObject.Callbacks.wrap_InitiallyUnownedClassSetPropertyFieldCallback Nothing v)
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GObject.Structs.InitiallyUnownedClass.setProperty"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.28/docs/GI-GObject-Structs-InitiallyUnownedClass.html#g:attr:setProperty"
        })

initiallyUnownedClass_setProperty :: AttrLabelProxy "setProperty"
initiallyUnownedClass_setProperty = AttrLabelProxy

#endif


-- | Get the value of the “@get_property@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' initiallyUnownedClass #getProperty
-- @
getInitiallyUnownedClassGetProperty :: MonadIO m => InitiallyUnownedClass -> m (Maybe GObject.Callbacks.InitiallyUnownedClassGetPropertyFieldCallback)
getInitiallyUnownedClassGetProperty :: forall (m :: * -> *).
MonadIO m =>
InitiallyUnownedClass
-> m (Maybe InitiallyUnownedClassSetPropertyFieldCallback)
getInitiallyUnownedClassGetProperty InitiallyUnownedClass
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 InitiallyUnownedClass
s forall a b. (a -> b) -> a -> b
$ \Ptr InitiallyUnownedClass
ptr -> do
    FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr InitiallyUnownedClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) :: IO (FunPtr GObject.Callbacks.C_InitiallyUnownedClassGetPropertyFieldCallback)
    Maybe InitiallyUnownedClassSetPropertyFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback
val' -> do
        let val'' :: InitiallyUnownedClassSetPropertyFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback
-> a -> Word32 -> GValue -> GParamSpec -> m ()
GObject.Callbacks.dynamic_InitiallyUnownedClassGetPropertyFieldCallback FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback
val'
        forall (m :: * -> *) a. Monad m => a -> m a
return InitiallyUnownedClassSetPropertyFieldCallback
val''
    forall (m :: * -> *) a. Monad m => a -> m a
return Maybe InitiallyUnownedClassSetPropertyFieldCallback
result

-- | Set the value of the “@get_property@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' initiallyUnownedClass [ #getProperty 'Data.GI.Base.Attributes.:=' value ]
-- @
setInitiallyUnownedClassGetProperty :: MonadIO m => InitiallyUnownedClass -> FunPtr GObject.Callbacks.C_InitiallyUnownedClassGetPropertyFieldCallback -> m ()
setInitiallyUnownedClassGetProperty :: forall (m :: * -> *).
MonadIO m =>
InitiallyUnownedClass
-> FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback -> m ()
setInitiallyUnownedClassGetProperty InitiallyUnownedClass
s FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback
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 InitiallyUnownedClass
s forall a b. (a -> b) -> a -> b
$ \Ptr InitiallyUnownedClass
ptr -> do
    forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr InitiallyUnownedClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback
val :: FunPtr GObject.Callbacks.C_InitiallyUnownedClassGetPropertyFieldCallback)

-- | Set the value of the “@get_property@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #getProperty
-- @
clearInitiallyUnownedClassGetProperty :: MonadIO m => InitiallyUnownedClass -> m ()
clearInitiallyUnownedClassGetProperty :: forall (m :: * -> *). MonadIO m => InitiallyUnownedClass -> m ()
clearInitiallyUnownedClassGetProperty InitiallyUnownedClass
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 InitiallyUnownedClass
s forall a b. (a -> b) -> a -> b
$ \Ptr InitiallyUnownedClass
ptr -> do
    forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr InitiallyUnownedClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr GObject.Callbacks.C_InitiallyUnownedClassGetPropertyFieldCallback)

#if defined(ENABLE_OVERLOADING)
data InitiallyUnownedClassGetPropertyFieldInfo
instance AttrInfo InitiallyUnownedClassGetPropertyFieldInfo where
    type AttrBaseTypeConstraint InitiallyUnownedClassGetPropertyFieldInfo = (~) InitiallyUnownedClass
    type AttrAllowedOps InitiallyUnownedClassGetPropertyFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint InitiallyUnownedClassGetPropertyFieldInfo = (~) (FunPtr GObject.Callbacks.C_InitiallyUnownedClassGetPropertyFieldCallback)
    type AttrTransferTypeConstraint InitiallyUnownedClassGetPropertyFieldInfo = (~)GObject.Callbacks.InitiallyUnownedClassGetPropertyFieldCallback
    type AttrTransferType InitiallyUnownedClassGetPropertyFieldInfo = (FunPtr GObject.Callbacks.C_InitiallyUnownedClassGetPropertyFieldCallback)
    type AttrGetType InitiallyUnownedClassGetPropertyFieldInfo = Maybe GObject.Callbacks.InitiallyUnownedClassGetPropertyFieldCallback
    type AttrLabel InitiallyUnownedClassGetPropertyFieldInfo = "get_property"
    type AttrOrigin InitiallyUnownedClassGetPropertyFieldInfo = InitiallyUnownedClass
    attrGet = getInitiallyUnownedClassGetProperty
    attrSet = setInitiallyUnownedClassGetProperty
    attrConstruct = undefined
    attrClear = clearInitiallyUnownedClassGetProperty
    attrTransfer _ v = do
        GObject.Callbacks.mk_InitiallyUnownedClassGetPropertyFieldCallback (GObject.Callbacks.wrap_InitiallyUnownedClassGetPropertyFieldCallback Nothing v)
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GObject.Structs.InitiallyUnownedClass.getProperty"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.28/docs/GI-GObject-Structs-InitiallyUnownedClass.html#g:attr:getProperty"
        })

initiallyUnownedClass_getProperty :: AttrLabelProxy "getProperty"
initiallyUnownedClass_getProperty = AttrLabelProxy

#endif


-- | Get the value of the “@dispose@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' initiallyUnownedClass #dispose
-- @
getInitiallyUnownedClassDispose :: MonadIO m => InitiallyUnownedClass -> m (Maybe GObject.Callbacks.InitiallyUnownedClassDisposeFieldCallback)
getInitiallyUnownedClassDispose :: forall (m :: * -> *).
MonadIO m =>
InitiallyUnownedClass
-> m (Maybe InitiallyUnownedClassDisposeFieldCallback)
getInitiallyUnownedClassDispose InitiallyUnownedClass
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 InitiallyUnownedClass
s forall a b. (a -> b) -> a -> b
$ \Ptr InitiallyUnownedClass
ptr -> do
    FunPtr C_InitiallyUnownedClassDisposeFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr InitiallyUnownedClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
20) :: IO (FunPtr GObject.Callbacks.C_InitiallyUnownedClassDisposeFieldCallback)
    Maybe InitiallyUnownedClassDisposeFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_InitiallyUnownedClassDisposeFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_InitiallyUnownedClassDisposeFieldCallback
val' -> do
        let val'' :: InitiallyUnownedClassDisposeFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
FunPtr C_InitiallyUnownedClassDisposeFieldCallback -> a -> m ()
GObject.Callbacks.dynamic_InitiallyUnownedClassDisposeFieldCallback FunPtr C_InitiallyUnownedClassDisposeFieldCallback
val'
        forall (m :: * -> *) a. Monad m => a -> m a
return InitiallyUnownedClassDisposeFieldCallback
val''
    forall (m :: * -> *) a. Monad m => a -> m a
return Maybe InitiallyUnownedClassDisposeFieldCallback
result

-- | Set the value of the “@dispose@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' initiallyUnownedClass [ #dispose 'Data.GI.Base.Attributes.:=' value ]
-- @
setInitiallyUnownedClassDispose :: MonadIO m => InitiallyUnownedClass -> FunPtr GObject.Callbacks.C_InitiallyUnownedClassDisposeFieldCallback -> m ()
setInitiallyUnownedClassDispose :: forall (m :: * -> *).
MonadIO m =>
InitiallyUnownedClass
-> FunPtr C_InitiallyUnownedClassDisposeFieldCallback -> m ()
setInitiallyUnownedClassDispose InitiallyUnownedClass
s FunPtr C_InitiallyUnownedClassDisposeFieldCallback
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 InitiallyUnownedClass
s forall a b. (a -> b) -> a -> b
$ \Ptr InitiallyUnownedClass
ptr -> do
    forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr InitiallyUnownedClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
20) (FunPtr C_InitiallyUnownedClassDisposeFieldCallback
val :: FunPtr GObject.Callbacks.C_InitiallyUnownedClassDisposeFieldCallback)

-- | Set the value of the “@dispose@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #dispose
-- @
clearInitiallyUnownedClassDispose :: MonadIO m => InitiallyUnownedClass -> m ()
clearInitiallyUnownedClassDispose :: forall (m :: * -> *). MonadIO m => InitiallyUnownedClass -> m ()
clearInitiallyUnownedClassDispose InitiallyUnownedClass
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 InitiallyUnownedClass
s forall a b. (a -> b) -> a -> b
$ \Ptr InitiallyUnownedClass
ptr -> do
    forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr InitiallyUnownedClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
20) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr GObject.Callbacks.C_InitiallyUnownedClassDisposeFieldCallback)

#if defined(ENABLE_OVERLOADING)
data InitiallyUnownedClassDisposeFieldInfo
instance AttrInfo InitiallyUnownedClassDisposeFieldInfo where
    type AttrBaseTypeConstraint InitiallyUnownedClassDisposeFieldInfo = (~) InitiallyUnownedClass
    type AttrAllowedOps InitiallyUnownedClassDisposeFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint InitiallyUnownedClassDisposeFieldInfo = (~) (FunPtr GObject.Callbacks.C_InitiallyUnownedClassDisposeFieldCallback)
    type AttrTransferTypeConstraint InitiallyUnownedClassDisposeFieldInfo = (~)GObject.Callbacks.InitiallyUnownedClassDisposeFieldCallback
    type AttrTransferType InitiallyUnownedClassDisposeFieldInfo = (FunPtr GObject.Callbacks.C_InitiallyUnownedClassDisposeFieldCallback)
    type AttrGetType InitiallyUnownedClassDisposeFieldInfo = Maybe GObject.Callbacks.InitiallyUnownedClassDisposeFieldCallback
    type AttrLabel InitiallyUnownedClassDisposeFieldInfo = "dispose"
    type AttrOrigin InitiallyUnownedClassDisposeFieldInfo = InitiallyUnownedClass
    attrGet = getInitiallyUnownedClassDispose
    attrSet = setInitiallyUnownedClassDispose
    attrConstruct = undefined
    attrClear = clearInitiallyUnownedClassDispose
    attrTransfer _ v = do
        GObject.Callbacks.mk_InitiallyUnownedClassDisposeFieldCallback (GObject.Callbacks.wrap_InitiallyUnownedClassDisposeFieldCallback Nothing v)
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GObject.Structs.InitiallyUnownedClass.dispose"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.28/docs/GI-GObject-Structs-InitiallyUnownedClass.html#g:attr:dispose"
        })

initiallyUnownedClass_dispose :: AttrLabelProxy "dispose"
initiallyUnownedClass_dispose = AttrLabelProxy

#endif


-- | Get the value of the “@finalize@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' initiallyUnownedClass #finalize
-- @
getInitiallyUnownedClassFinalize :: MonadIO m => InitiallyUnownedClass -> m (Maybe GObject.Callbacks.InitiallyUnownedClassFinalizeFieldCallback)
getInitiallyUnownedClassFinalize :: forall (m :: * -> *).
MonadIO m =>
InitiallyUnownedClass
-> m (Maybe InitiallyUnownedClassDisposeFieldCallback)
getInitiallyUnownedClassFinalize InitiallyUnownedClass
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 InitiallyUnownedClass
s forall a b. (a -> b) -> a -> b
$ \Ptr InitiallyUnownedClass
ptr -> do
    FunPtr C_InitiallyUnownedClassDisposeFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr InitiallyUnownedClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) :: IO (FunPtr GObject.Callbacks.C_InitiallyUnownedClassFinalizeFieldCallback)
    Maybe InitiallyUnownedClassDisposeFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_InitiallyUnownedClassDisposeFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_InitiallyUnownedClassDisposeFieldCallback
val' -> do
        let val'' :: InitiallyUnownedClassDisposeFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
FunPtr C_InitiallyUnownedClassDisposeFieldCallback -> a -> m ()
GObject.Callbacks.dynamic_InitiallyUnownedClassFinalizeFieldCallback FunPtr C_InitiallyUnownedClassDisposeFieldCallback
val'
        forall (m :: * -> *) a. Monad m => a -> m a
return InitiallyUnownedClassDisposeFieldCallback
val''
    forall (m :: * -> *) a. Monad m => a -> m a
return Maybe InitiallyUnownedClassDisposeFieldCallback
result

-- | Set the value of the “@finalize@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' initiallyUnownedClass [ #finalize 'Data.GI.Base.Attributes.:=' value ]
-- @
setInitiallyUnownedClassFinalize :: MonadIO m => InitiallyUnownedClass -> FunPtr GObject.Callbacks.C_InitiallyUnownedClassFinalizeFieldCallback -> m ()
setInitiallyUnownedClassFinalize :: forall (m :: * -> *).
MonadIO m =>
InitiallyUnownedClass
-> FunPtr C_InitiallyUnownedClassDisposeFieldCallback -> m ()
setInitiallyUnownedClassFinalize InitiallyUnownedClass
s FunPtr C_InitiallyUnownedClassDisposeFieldCallback
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 InitiallyUnownedClass
s forall a b. (a -> b) -> a -> b
$ \Ptr InitiallyUnownedClass
ptr -> do
    forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr InitiallyUnownedClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) (FunPtr C_InitiallyUnownedClassDisposeFieldCallback
val :: FunPtr GObject.Callbacks.C_InitiallyUnownedClassFinalizeFieldCallback)

-- | Set the value of the “@finalize@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #finalize
-- @
clearInitiallyUnownedClassFinalize :: MonadIO m => InitiallyUnownedClass -> m ()
clearInitiallyUnownedClassFinalize :: forall (m :: * -> *). MonadIO m => InitiallyUnownedClass -> m ()
clearInitiallyUnownedClassFinalize InitiallyUnownedClass
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 InitiallyUnownedClass
s forall a b. (a -> b) -> a -> b
$ \Ptr InitiallyUnownedClass
ptr -> do
    forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr InitiallyUnownedClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr GObject.Callbacks.C_InitiallyUnownedClassFinalizeFieldCallback)

#if defined(ENABLE_OVERLOADING)
data InitiallyUnownedClassFinalizeFieldInfo
instance AttrInfo InitiallyUnownedClassFinalizeFieldInfo where
    type AttrBaseTypeConstraint InitiallyUnownedClassFinalizeFieldInfo = (~) InitiallyUnownedClass
    type AttrAllowedOps InitiallyUnownedClassFinalizeFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint InitiallyUnownedClassFinalizeFieldInfo = (~) (FunPtr GObject.Callbacks.C_InitiallyUnownedClassFinalizeFieldCallback)
    type AttrTransferTypeConstraint InitiallyUnownedClassFinalizeFieldInfo = (~)GObject.Callbacks.InitiallyUnownedClassFinalizeFieldCallback
    type AttrTransferType InitiallyUnownedClassFinalizeFieldInfo = (FunPtr GObject.Callbacks.C_InitiallyUnownedClassFinalizeFieldCallback)
    type AttrGetType InitiallyUnownedClassFinalizeFieldInfo = Maybe GObject.Callbacks.InitiallyUnownedClassFinalizeFieldCallback
    type AttrLabel InitiallyUnownedClassFinalizeFieldInfo = "finalize"
    type AttrOrigin InitiallyUnownedClassFinalizeFieldInfo = InitiallyUnownedClass
    attrGet = getInitiallyUnownedClassFinalize
    attrSet = setInitiallyUnownedClassFinalize
    attrConstruct = undefined
    attrClear = clearInitiallyUnownedClassFinalize
    attrTransfer _ v = do
        GObject.Callbacks.mk_InitiallyUnownedClassFinalizeFieldCallback (GObject.Callbacks.wrap_InitiallyUnownedClassFinalizeFieldCallback Nothing v)
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GObject.Structs.InitiallyUnownedClass.finalize"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.28/docs/GI-GObject-Structs-InitiallyUnownedClass.html#g:attr:finalize"
        })

initiallyUnownedClass_finalize :: AttrLabelProxy "finalize"
initiallyUnownedClass_finalize = AttrLabelProxy

#endif


-- | Get the value of the “@dispatch_properties_changed@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' initiallyUnownedClass #dispatchPropertiesChanged
-- @
getInitiallyUnownedClassDispatchPropertiesChanged :: MonadIO m => InitiallyUnownedClass -> m (Maybe GObject.Callbacks.InitiallyUnownedClassDispatchPropertiesChangedFieldCallback)
getInitiallyUnownedClassDispatchPropertiesChanged :: forall (m :: * -> *).
MonadIO m =>
InitiallyUnownedClass
-> m (Maybe
        InitiallyUnownedClassDispatchPropertiesChangedFieldCallback)
getInitiallyUnownedClassDispatchPropertiesChanged InitiallyUnownedClass
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 InitiallyUnownedClass
s forall a b. (a -> b) -> a -> b
$ \Ptr InitiallyUnownedClass
ptr -> do
    FunPtr
  C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr InitiallyUnownedClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
28) :: IO (FunPtr GObject.Callbacks.C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback)
    Maybe InitiallyUnownedClassDispatchPropertiesChangedFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr
  C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr
  C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback
val' -> do
        let val'' :: InitiallyUnownedClassDispatchPropertiesChangedFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
FunPtr
  C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback
-> a -> Word32 -> GParamSpec -> m ()
GObject.Callbacks.dynamic_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback FunPtr
  C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback
val'
        forall (m :: * -> *) a. Monad m => a -> m a
return InitiallyUnownedClassDispatchPropertiesChangedFieldCallback
val''
    forall (m :: * -> *) a. Monad m => a -> m a
return Maybe InitiallyUnownedClassDispatchPropertiesChangedFieldCallback
result

-- | Set the value of the “@dispatch_properties_changed@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' initiallyUnownedClass [ #dispatchPropertiesChanged 'Data.GI.Base.Attributes.:=' value ]
-- @
setInitiallyUnownedClassDispatchPropertiesChanged :: MonadIO m => InitiallyUnownedClass -> FunPtr GObject.Callbacks.C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback -> m ()
setInitiallyUnownedClassDispatchPropertiesChanged :: forall (m :: * -> *).
MonadIO m =>
InitiallyUnownedClass
-> FunPtr
     C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback
-> m ()
setInitiallyUnownedClassDispatchPropertiesChanged InitiallyUnownedClass
s FunPtr
  C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback
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 InitiallyUnownedClass
s forall a b. (a -> b) -> a -> b
$ \Ptr InitiallyUnownedClass
ptr -> do
    forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr InitiallyUnownedClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
28) (FunPtr
  C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback
val :: FunPtr GObject.Callbacks.C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback)

-- | Set the value of the “@dispatch_properties_changed@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #dispatchPropertiesChanged
-- @
clearInitiallyUnownedClassDispatchPropertiesChanged :: MonadIO m => InitiallyUnownedClass -> m ()
clearInitiallyUnownedClassDispatchPropertiesChanged :: forall (m :: * -> *). MonadIO m => InitiallyUnownedClass -> m ()
clearInitiallyUnownedClassDispatchPropertiesChanged InitiallyUnownedClass
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 InitiallyUnownedClass
s forall a b. (a -> b) -> a -> b
$ \Ptr InitiallyUnownedClass
ptr -> do
    forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr InitiallyUnownedClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
28) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr GObject.Callbacks.C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback)

#if defined(ENABLE_OVERLOADING)
data InitiallyUnownedClassDispatchPropertiesChangedFieldInfo
instance AttrInfo InitiallyUnownedClassDispatchPropertiesChangedFieldInfo where
    type AttrBaseTypeConstraint InitiallyUnownedClassDispatchPropertiesChangedFieldInfo = (~) InitiallyUnownedClass
    type AttrAllowedOps InitiallyUnownedClassDispatchPropertiesChangedFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint InitiallyUnownedClassDispatchPropertiesChangedFieldInfo = (~) (FunPtr GObject.Callbacks.C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback)
    type AttrTransferTypeConstraint InitiallyUnownedClassDispatchPropertiesChangedFieldInfo = (~)GObject.Callbacks.InitiallyUnownedClassDispatchPropertiesChangedFieldCallback
    type AttrTransferType InitiallyUnownedClassDispatchPropertiesChangedFieldInfo = (FunPtr GObject.Callbacks.C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback)
    type AttrGetType InitiallyUnownedClassDispatchPropertiesChangedFieldInfo = Maybe GObject.Callbacks.InitiallyUnownedClassDispatchPropertiesChangedFieldCallback
    type AttrLabel InitiallyUnownedClassDispatchPropertiesChangedFieldInfo = "dispatch_properties_changed"
    type AttrOrigin InitiallyUnownedClassDispatchPropertiesChangedFieldInfo = InitiallyUnownedClass
    attrGet = getInitiallyUnownedClassDispatchPropertiesChanged
    attrSet = setInitiallyUnownedClassDispatchPropertiesChanged
    attrConstruct = undefined
    attrClear = clearInitiallyUnownedClassDispatchPropertiesChanged
    attrTransfer _ v = do
        GObject.Callbacks.mk_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback (GObject.Callbacks.wrap_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback Nothing v)
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GObject.Structs.InitiallyUnownedClass.dispatchPropertiesChanged"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.28/docs/GI-GObject-Structs-InitiallyUnownedClass.html#g:attr:dispatchPropertiesChanged"
        })

initiallyUnownedClass_dispatchPropertiesChanged :: AttrLabelProxy "dispatchPropertiesChanged"
initiallyUnownedClass_dispatchPropertiesChanged = AttrLabelProxy

#endif


-- | Get the value of the “@notify@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' initiallyUnownedClass #notify
-- @
getInitiallyUnownedClassNotify :: MonadIO m => InitiallyUnownedClass -> m (Maybe GObject.Callbacks.InitiallyUnownedClassNotifyFieldCallback)
getInitiallyUnownedClassNotify :: forall (m :: * -> *).
MonadIO m =>
InitiallyUnownedClass
-> m (Maybe InitiallyUnownedClassNotifyFieldCallback)
getInitiallyUnownedClassNotify InitiallyUnownedClass
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 InitiallyUnownedClass
s forall a b. (a -> b) -> a -> b
$ \Ptr InitiallyUnownedClass
ptr -> do
    FunPtr C_InitiallyUnownedClassNotifyFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr InitiallyUnownedClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) :: IO (FunPtr GObject.Callbacks.C_InitiallyUnownedClassNotifyFieldCallback)
    Maybe InitiallyUnownedClassNotifyFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_InitiallyUnownedClassNotifyFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_InitiallyUnownedClassNotifyFieldCallback
val' -> do
        let val'' :: InitiallyUnownedClassNotifyFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
FunPtr C_InitiallyUnownedClassNotifyFieldCallback
-> a -> GParamSpec -> m ()
GObject.Callbacks.dynamic_InitiallyUnownedClassNotifyFieldCallback FunPtr C_InitiallyUnownedClassNotifyFieldCallback
val'
        forall (m :: * -> *) a. Monad m => a -> m a
return InitiallyUnownedClassNotifyFieldCallback
val''
    forall (m :: * -> *) a. Monad m => a -> m a
return Maybe InitiallyUnownedClassNotifyFieldCallback
result

-- | Set the value of the “@notify@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' initiallyUnownedClass [ #notify 'Data.GI.Base.Attributes.:=' value ]
-- @
setInitiallyUnownedClassNotify :: MonadIO m => InitiallyUnownedClass -> FunPtr GObject.Callbacks.C_InitiallyUnownedClassNotifyFieldCallback -> m ()
setInitiallyUnownedClassNotify :: forall (m :: * -> *).
MonadIO m =>
InitiallyUnownedClass
-> FunPtr C_InitiallyUnownedClassNotifyFieldCallback -> m ()
setInitiallyUnownedClassNotify InitiallyUnownedClass
s FunPtr C_InitiallyUnownedClassNotifyFieldCallback
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 InitiallyUnownedClass
s forall a b. (a -> b) -> a -> b
$ \Ptr InitiallyUnownedClass
ptr -> do
    forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr InitiallyUnownedClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) (FunPtr C_InitiallyUnownedClassNotifyFieldCallback
val :: FunPtr GObject.Callbacks.C_InitiallyUnownedClassNotifyFieldCallback)

-- | Set the value of the “@notify@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #notify
-- @
clearInitiallyUnownedClassNotify :: MonadIO m => InitiallyUnownedClass -> m ()
clearInitiallyUnownedClassNotify :: forall (m :: * -> *). MonadIO m => InitiallyUnownedClass -> m ()
clearInitiallyUnownedClassNotify InitiallyUnownedClass
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 InitiallyUnownedClass
s forall a b. (a -> b) -> a -> b
$ \Ptr InitiallyUnownedClass
ptr -> do
    forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr InitiallyUnownedClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr GObject.Callbacks.C_InitiallyUnownedClassNotifyFieldCallback)

#if defined(ENABLE_OVERLOADING)
data InitiallyUnownedClassNotifyFieldInfo
instance AttrInfo InitiallyUnownedClassNotifyFieldInfo where
    type AttrBaseTypeConstraint InitiallyUnownedClassNotifyFieldInfo = (~) InitiallyUnownedClass
    type AttrAllowedOps InitiallyUnownedClassNotifyFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint InitiallyUnownedClassNotifyFieldInfo = (~) (FunPtr GObject.Callbacks.C_InitiallyUnownedClassNotifyFieldCallback)
    type AttrTransferTypeConstraint InitiallyUnownedClassNotifyFieldInfo = (~)GObject.Callbacks.InitiallyUnownedClassNotifyFieldCallback
    type AttrTransferType InitiallyUnownedClassNotifyFieldInfo = (FunPtr GObject.Callbacks.C_InitiallyUnownedClassNotifyFieldCallback)
    type AttrGetType InitiallyUnownedClassNotifyFieldInfo = Maybe GObject.Callbacks.InitiallyUnownedClassNotifyFieldCallback
    type AttrLabel InitiallyUnownedClassNotifyFieldInfo = "notify"
    type AttrOrigin InitiallyUnownedClassNotifyFieldInfo = InitiallyUnownedClass
    attrGet = getInitiallyUnownedClassNotify
    attrSet = setInitiallyUnownedClassNotify
    attrConstruct = undefined
    attrClear = clearInitiallyUnownedClassNotify
    attrTransfer _ v = do
        GObject.Callbacks.mk_InitiallyUnownedClassNotifyFieldCallback (GObject.Callbacks.wrap_InitiallyUnownedClassNotifyFieldCallback Nothing v)
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GObject.Structs.InitiallyUnownedClass.notify"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.28/docs/GI-GObject-Structs-InitiallyUnownedClass.html#g:attr:notify"
        })

initiallyUnownedClass_notify :: AttrLabelProxy "notify"
initiallyUnownedClass_notify = AttrLabelProxy

#endif


-- | Get the value of the “@constructed@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' initiallyUnownedClass #constructed
-- @
getInitiallyUnownedClassConstructed :: MonadIO m => InitiallyUnownedClass -> m (Maybe GObject.Callbacks.InitiallyUnownedClassConstructedFieldCallback)
getInitiallyUnownedClassConstructed :: forall (m :: * -> *).
MonadIO m =>
InitiallyUnownedClass
-> m (Maybe InitiallyUnownedClassDisposeFieldCallback)
getInitiallyUnownedClassConstructed InitiallyUnownedClass
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 InitiallyUnownedClass
s forall a b. (a -> b) -> a -> b
$ \Ptr InitiallyUnownedClass
ptr -> do
    FunPtr C_InitiallyUnownedClassDisposeFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr InitiallyUnownedClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
36) :: IO (FunPtr GObject.Callbacks.C_InitiallyUnownedClassConstructedFieldCallback)
    Maybe InitiallyUnownedClassDisposeFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_InitiallyUnownedClassDisposeFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_InitiallyUnownedClassDisposeFieldCallback
val' -> do
        let val'' :: InitiallyUnownedClassDisposeFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
FunPtr C_InitiallyUnownedClassDisposeFieldCallback -> a -> m ()
GObject.Callbacks.dynamic_InitiallyUnownedClassConstructedFieldCallback FunPtr C_InitiallyUnownedClassDisposeFieldCallback
val'
        forall (m :: * -> *) a. Monad m => a -> m a
return InitiallyUnownedClassDisposeFieldCallback
val''
    forall (m :: * -> *) a. Monad m => a -> m a
return Maybe InitiallyUnownedClassDisposeFieldCallback
result

-- | Set the value of the “@constructed@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' initiallyUnownedClass [ #constructed 'Data.GI.Base.Attributes.:=' value ]
-- @
setInitiallyUnownedClassConstructed :: MonadIO m => InitiallyUnownedClass -> FunPtr GObject.Callbacks.C_InitiallyUnownedClassConstructedFieldCallback -> m ()
setInitiallyUnownedClassConstructed :: forall (m :: * -> *).
MonadIO m =>
InitiallyUnownedClass
-> FunPtr C_InitiallyUnownedClassDisposeFieldCallback -> m ()
setInitiallyUnownedClassConstructed InitiallyUnownedClass
s FunPtr C_InitiallyUnownedClassDisposeFieldCallback
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 InitiallyUnownedClass
s forall a b. (a -> b) -> a -> b
$ \Ptr InitiallyUnownedClass
ptr -> do
    forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr InitiallyUnownedClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
36) (FunPtr C_InitiallyUnownedClassDisposeFieldCallback
val :: FunPtr GObject.Callbacks.C_InitiallyUnownedClassConstructedFieldCallback)

-- | Set the value of the “@constructed@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #constructed
-- @
clearInitiallyUnownedClassConstructed :: MonadIO m => InitiallyUnownedClass -> m ()
clearInitiallyUnownedClassConstructed :: forall (m :: * -> *). MonadIO m => InitiallyUnownedClass -> m ()
clearInitiallyUnownedClassConstructed InitiallyUnownedClass
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 InitiallyUnownedClass
s forall a b. (a -> b) -> a -> b
$ \Ptr InitiallyUnownedClass
ptr -> do
    forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr InitiallyUnownedClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
36) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr GObject.Callbacks.C_InitiallyUnownedClassConstructedFieldCallback)

#if defined(ENABLE_OVERLOADING)
data InitiallyUnownedClassConstructedFieldInfo
instance AttrInfo InitiallyUnownedClassConstructedFieldInfo where
    type AttrBaseTypeConstraint InitiallyUnownedClassConstructedFieldInfo = (~) InitiallyUnownedClass
    type AttrAllowedOps InitiallyUnownedClassConstructedFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint InitiallyUnownedClassConstructedFieldInfo = (~) (FunPtr GObject.Callbacks.C_InitiallyUnownedClassConstructedFieldCallback)
    type AttrTransferTypeConstraint InitiallyUnownedClassConstructedFieldInfo = (~)GObject.Callbacks.InitiallyUnownedClassConstructedFieldCallback
    type AttrTransferType InitiallyUnownedClassConstructedFieldInfo = (FunPtr GObject.Callbacks.C_InitiallyUnownedClassConstructedFieldCallback)
    type AttrGetType InitiallyUnownedClassConstructedFieldInfo = Maybe GObject.Callbacks.InitiallyUnownedClassConstructedFieldCallback
    type AttrLabel InitiallyUnownedClassConstructedFieldInfo = "constructed"
    type AttrOrigin InitiallyUnownedClassConstructedFieldInfo = InitiallyUnownedClass
    attrGet = getInitiallyUnownedClassConstructed
    attrSet = setInitiallyUnownedClassConstructed
    attrConstruct = undefined
    attrClear = clearInitiallyUnownedClassConstructed
    attrTransfer _ v = do
        GObject.Callbacks.mk_InitiallyUnownedClassConstructedFieldCallback (GObject.Callbacks.wrap_InitiallyUnownedClassConstructedFieldCallback Nothing v)
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GObject.Structs.InitiallyUnownedClass.constructed"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.28/docs/GI-GObject-Structs-InitiallyUnownedClass.html#g:attr:constructed"
        })

initiallyUnownedClass_constructed :: AttrLabelProxy "constructed"
initiallyUnownedClass_constructed = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList InitiallyUnownedClass
type instance O.AttributeList InitiallyUnownedClass = InitiallyUnownedClassAttributeList
type InitiallyUnownedClassAttributeList = ('[ '("gTypeClass", InitiallyUnownedClassGTypeClassFieldInfo), '("setProperty", InitiallyUnownedClassSetPropertyFieldInfo), '("getProperty", InitiallyUnownedClassGetPropertyFieldInfo), '("dispose", InitiallyUnownedClassDisposeFieldInfo), '("finalize", InitiallyUnownedClassFinalizeFieldInfo), '("dispatchPropertiesChanged", InitiallyUnownedClassDispatchPropertiesChangedFieldInfo), '("notify", InitiallyUnownedClassNotifyFieldInfo), '("constructed", InitiallyUnownedClassConstructedFieldInfo)] :: [(Symbol, DK.Type)])
#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveInitiallyUnownedClassMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolveInitiallyUnownedClassMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveInitiallyUnownedClassMethod t InitiallyUnownedClass, O.OverloadedMethod info InitiallyUnownedClass p) => OL.IsLabel t (InitiallyUnownedClass -> 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 ~ ResolveInitiallyUnownedClassMethod t InitiallyUnownedClass, O.OverloadedMethod info InitiallyUnownedClass p, R.HasField t InitiallyUnownedClass p) => R.HasField t InitiallyUnownedClass p where
    getField = O.overloadedMethod @info

#endif

instance (info ~ ResolveInitiallyUnownedClassMethod t InitiallyUnownedClass, O.OverloadedMethodInfo info InitiallyUnownedClass) => OL.IsLabel t (O.MethodProxy info InitiallyUnownedClass) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#endif

#endif