{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- 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            ,
    noInitiallyUnownedClass                 ,


 -- * Methods
-- ** Overloaded methods #method:Overloaded 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.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
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 Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL

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 (ManagedPtr InitiallyUnownedClass)
    deriving (InitiallyUnownedClass -> InitiallyUnownedClass -> Bool
(InitiallyUnownedClass -> InitiallyUnownedClass -> Bool)
-> (InitiallyUnownedClass -> InitiallyUnownedClass -> Bool)
-> Eq InitiallyUnownedClass
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 WrappedPtr InitiallyUnownedClass where
    wrappedPtrCalloc :: IO (Ptr InitiallyUnownedClass)
wrappedPtrCalloc = Int -> IO (Ptr InitiallyUnownedClass)
forall a. Int -> IO (Ptr a)
callocBytes 136
    wrappedPtrCopy :: InitiallyUnownedClass -> IO InitiallyUnownedClass
wrappedPtrCopy = \p :: InitiallyUnownedClass
p -> InitiallyUnownedClass
-> (Ptr InitiallyUnownedClass -> IO InitiallyUnownedClass)
-> IO InitiallyUnownedClass
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr InitiallyUnownedClass
p (Int -> Ptr InitiallyUnownedClass -> IO (Ptr InitiallyUnownedClass)
forall a. WrappedPtr a => Int -> Ptr a -> IO (Ptr a)
copyBytes 136 (Ptr InitiallyUnownedClass -> IO (Ptr InitiallyUnownedClass))
-> (Ptr InitiallyUnownedClass -> IO InitiallyUnownedClass)
-> Ptr InitiallyUnownedClass
-> IO InitiallyUnownedClass
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (ManagedPtr InitiallyUnownedClass -> InitiallyUnownedClass)
-> Ptr InitiallyUnownedClass -> IO InitiallyUnownedClass
forall a.
(HasCallStack, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr InitiallyUnownedClass -> InitiallyUnownedClass
InitiallyUnownedClass)
    wrappedPtrFree :: Maybe (GDestroyNotify InitiallyUnownedClass)
wrappedPtrFree = GDestroyNotify InitiallyUnownedClass
-> Maybe (GDestroyNotify InitiallyUnownedClass)
forall a. a -> Maybe a
Just GDestroyNotify InitiallyUnownedClass
forall a. FunPtr (Ptr a -> IO ())
ptr_to_g_free

-- | Construct a `InitiallyUnownedClass` struct initialized to zero.
newZeroInitiallyUnownedClass :: MonadIO m => m InitiallyUnownedClass
newZeroInitiallyUnownedClass :: m InitiallyUnownedClass
newZeroInitiallyUnownedClass = IO InitiallyUnownedClass -> m InitiallyUnownedClass
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO InitiallyUnownedClass -> m InitiallyUnownedClass)
-> IO InitiallyUnownedClass -> m InitiallyUnownedClass
forall a b. (a -> b) -> a -> b
$ IO (Ptr InitiallyUnownedClass)
forall a. WrappedPtr a => IO (Ptr a)
wrappedPtrCalloc IO (Ptr InitiallyUnownedClass)
-> (Ptr InitiallyUnownedClass -> IO InitiallyUnownedClass)
-> IO InitiallyUnownedClass
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr InitiallyUnownedClass -> InitiallyUnownedClass)
-> Ptr InitiallyUnownedClass -> IO InitiallyUnownedClass
forall a.
(HasCallStack, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr InitiallyUnownedClass -> InitiallyUnownedClass
InitiallyUnownedClass

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


-- | A convenience alias for `Nothing` :: `Maybe` `InitiallyUnownedClass`.
noInitiallyUnownedClass :: Maybe InitiallyUnownedClass
noInitiallyUnownedClass :: Maybe InitiallyUnownedClass
noInitiallyUnownedClass = Maybe InitiallyUnownedClass
forall a. Maybe a
Nothing

-- | 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 :: InitiallyUnownedClass -> m TypeClass
getInitiallyUnownedClassGTypeClass s :: InitiallyUnownedClass
s = IO TypeClass -> m TypeClass
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TypeClass -> m TypeClass) -> IO TypeClass -> m TypeClass
forall a b. (a -> b) -> a -> b
$ InitiallyUnownedClass
-> (Ptr InitiallyUnownedClass -> IO TypeClass) -> IO TypeClass
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr InitiallyUnownedClass
s ((Ptr InitiallyUnownedClass -> IO TypeClass) -> IO TypeClass)
-> (Ptr InitiallyUnownedClass -> IO TypeClass) -> IO TypeClass
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr InitiallyUnownedClass
ptr -> do
    let val :: Ptr TypeClass
val = Ptr InitiallyUnownedClass
ptr Ptr InitiallyUnownedClass -> Int -> Ptr TypeClass
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0 :: (Ptr GObject.TypeClass.TypeClass)
    TypeClass
val' <- ((ManagedPtr TypeClass -> TypeClass)
-> Ptr TypeClass -> IO TypeClass
forall a.
(HasCallStack, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr TypeClass -> TypeClass
GObject.TypeClass.TypeClass) Ptr TypeClass
val
    TypeClass -> IO TypeClass
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

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 :: InitiallyUnownedClass
-> m (Maybe InitiallyUnownedClassSetPropertyFieldCallback)
getInitiallyUnownedClassSetProperty s :: InitiallyUnownedClass
s = IO (Maybe InitiallyUnownedClassSetPropertyFieldCallback)
-> m (Maybe InitiallyUnownedClassSetPropertyFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe InitiallyUnownedClassSetPropertyFieldCallback)
 -> m (Maybe InitiallyUnownedClassSetPropertyFieldCallback))
-> IO (Maybe InitiallyUnownedClassSetPropertyFieldCallback)
-> m (Maybe InitiallyUnownedClassSetPropertyFieldCallback)
forall a b. (a -> b) -> a -> b
$ InitiallyUnownedClass
-> (Ptr InitiallyUnownedClass
    -> IO (Maybe InitiallyUnownedClassSetPropertyFieldCallback))
-> IO (Maybe InitiallyUnownedClassSetPropertyFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr InitiallyUnownedClass
s ((Ptr InitiallyUnownedClass
  -> IO (Maybe InitiallyUnownedClassSetPropertyFieldCallback))
 -> IO (Maybe InitiallyUnownedClassSetPropertyFieldCallback))
-> (Ptr InitiallyUnownedClass
    -> IO (Maybe InitiallyUnownedClassSetPropertyFieldCallback))
-> IO (Maybe InitiallyUnownedClassSetPropertyFieldCallback)
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr InitiallyUnownedClass
ptr -> do
    FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback
val <- Ptr (FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback)
-> IO (FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr InitiallyUnownedClass
ptr Ptr InitiallyUnownedClass
-> Int
-> Ptr (FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 24) :: IO (FunPtr GObject.Callbacks.C_InitiallyUnownedClassSetPropertyFieldCallback)
    Maybe InitiallyUnownedClassSetPropertyFieldCallback
result <- FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback
-> (FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback
    -> IO InitiallyUnownedClassSetPropertyFieldCallback)
-> IO (Maybe InitiallyUnownedClassSetPropertyFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback
val ((FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback
  -> IO InitiallyUnownedClassSetPropertyFieldCallback)
 -> IO (Maybe InitiallyUnownedClassSetPropertyFieldCallback))
-> (FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback
    -> IO InitiallyUnownedClassSetPropertyFieldCallback)
-> IO (Maybe InitiallyUnownedClassSetPropertyFieldCallback)
forall a b. (a -> b) -> a -> b
$ \val' :: FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback
val' -> do
        let val'' :: InitiallyUnownedClassSetPropertyFieldCallback
val'' = FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback
-> InitiallyUnownedClassSetPropertyFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback
-> a -> Word32 -> GValue -> GParamSpec -> m ()
GObject.Callbacks.dynamic_InitiallyUnownedClassSetPropertyFieldCallback FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback
val'
        InitiallyUnownedClassSetPropertyFieldCallback
-> IO InitiallyUnownedClassSetPropertyFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return InitiallyUnownedClassSetPropertyFieldCallback
val''
    Maybe InitiallyUnownedClassSetPropertyFieldCallback
-> IO (Maybe InitiallyUnownedClassSetPropertyFieldCallback)
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 :: InitiallyUnownedClass
-> FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback -> m ()
setInitiallyUnownedClassSetProperty s :: InitiallyUnownedClass
s val :: FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ InitiallyUnownedClass
-> (Ptr InitiallyUnownedClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr InitiallyUnownedClass
s ((Ptr InitiallyUnownedClass -> IO ()) -> IO ())
-> (Ptr InitiallyUnownedClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr InitiallyUnownedClass
ptr -> do
    Ptr (FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback)
-> FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr InitiallyUnownedClass
ptr Ptr InitiallyUnownedClass
-> Int
-> Ptr (FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 24) (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 :: InitiallyUnownedClass -> m ()
clearInitiallyUnownedClassSetProperty s :: InitiallyUnownedClass
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ InitiallyUnownedClass
-> (Ptr InitiallyUnownedClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr InitiallyUnownedClass
s ((Ptr InitiallyUnownedClass -> IO ()) -> IO ())
-> (Ptr InitiallyUnownedClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr InitiallyUnownedClass
ptr -> do
    Ptr (FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback)
-> FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr InitiallyUnownedClass
ptr Ptr InitiallyUnownedClass
-> Int
-> Ptr (FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 24) (FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback
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)

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 :: InitiallyUnownedClass
-> m (Maybe InitiallyUnownedClassSetPropertyFieldCallback)
getInitiallyUnownedClassGetProperty s :: InitiallyUnownedClass
s = IO (Maybe InitiallyUnownedClassSetPropertyFieldCallback)
-> m (Maybe InitiallyUnownedClassSetPropertyFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe InitiallyUnownedClassSetPropertyFieldCallback)
 -> m (Maybe InitiallyUnownedClassSetPropertyFieldCallback))
-> IO (Maybe InitiallyUnownedClassSetPropertyFieldCallback)
-> m (Maybe InitiallyUnownedClassSetPropertyFieldCallback)
forall a b. (a -> b) -> a -> b
$ InitiallyUnownedClass
-> (Ptr InitiallyUnownedClass
    -> IO (Maybe InitiallyUnownedClassSetPropertyFieldCallback))
-> IO (Maybe InitiallyUnownedClassSetPropertyFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr InitiallyUnownedClass
s ((Ptr InitiallyUnownedClass
  -> IO (Maybe InitiallyUnownedClassSetPropertyFieldCallback))
 -> IO (Maybe InitiallyUnownedClassSetPropertyFieldCallback))
-> (Ptr InitiallyUnownedClass
    -> IO (Maybe InitiallyUnownedClassSetPropertyFieldCallback))
-> IO (Maybe InitiallyUnownedClassSetPropertyFieldCallback)
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr InitiallyUnownedClass
ptr -> do
    FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback
val <- Ptr (FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback)
-> IO (FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr InitiallyUnownedClass
ptr Ptr InitiallyUnownedClass
-> Int
-> Ptr (FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 32) :: IO (FunPtr GObject.Callbacks.C_InitiallyUnownedClassGetPropertyFieldCallback)
    Maybe InitiallyUnownedClassSetPropertyFieldCallback
result <- FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback
-> (FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback
    -> IO InitiallyUnownedClassSetPropertyFieldCallback)
-> IO (Maybe InitiallyUnownedClassSetPropertyFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback
val ((FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback
  -> IO InitiallyUnownedClassSetPropertyFieldCallback)
 -> IO (Maybe InitiallyUnownedClassSetPropertyFieldCallback))
-> (FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback
    -> IO InitiallyUnownedClassSetPropertyFieldCallback)
-> IO (Maybe InitiallyUnownedClassSetPropertyFieldCallback)
forall a b. (a -> b) -> a -> b
$ \val' :: FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback
val' -> do
        let val'' :: InitiallyUnownedClassSetPropertyFieldCallback
val'' = FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback
-> InitiallyUnownedClassSetPropertyFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback
-> a -> Word32 -> GValue -> GParamSpec -> m ()
GObject.Callbacks.dynamic_InitiallyUnownedClassGetPropertyFieldCallback FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback
val'
        InitiallyUnownedClassSetPropertyFieldCallback
-> IO InitiallyUnownedClassSetPropertyFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return InitiallyUnownedClassSetPropertyFieldCallback
val''
    Maybe InitiallyUnownedClassSetPropertyFieldCallback
-> IO (Maybe InitiallyUnownedClassSetPropertyFieldCallback)
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 :: InitiallyUnownedClass
-> FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback -> m ()
setInitiallyUnownedClassGetProperty s :: InitiallyUnownedClass
s val :: FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ InitiallyUnownedClass
-> (Ptr InitiallyUnownedClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr InitiallyUnownedClass
s ((Ptr InitiallyUnownedClass -> IO ()) -> IO ())
-> (Ptr InitiallyUnownedClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr InitiallyUnownedClass
ptr -> do
    Ptr (FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback)
-> FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr InitiallyUnownedClass
ptr Ptr InitiallyUnownedClass
-> Int
-> Ptr (FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 32) (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 :: InitiallyUnownedClass -> m ()
clearInitiallyUnownedClassGetProperty s :: InitiallyUnownedClass
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ InitiallyUnownedClass
-> (Ptr InitiallyUnownedClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr InitiallyUnownedClass
s ((Ptr InitiallyUnownedClass -> IO ()) -> IO ())
-> (Ptr InitiallyUnownedClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr InitiallyUnownedClass
ptr -> do
    Ptr (FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback)
-> FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr InitiallyUnownedClass
ptr Ptr InitiallyUnownedClass
-> Int
-> Ptr (FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 32) (FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback
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)

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 :: InitiallyUnownedClass
-> m (Maybe InitiallyUnownedClassDisposeFieldCallback)
getInitiallyUnownedClassDispose s :: InitiallyUnownedClass
s = IO (Maybe InitiallyUnownedClassDisposeFieldCallback)
-> m (Maybe InitiallyUnownedClassDisposeFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe InitiallyUnownedClassDisposeFieldCallback)
 -> m (Maybe InitiallyUnownedClassDisposeFieldCallback))
-> IO (Maybe InitiallyUnownedClassDisposeFieldCallback)
-> m (Maybe InitiallyUnownedClassDisposeFieldCallback)
forall a b. (a -> b) -> a -> b
$ InitiallyUnownedClass
-> (Ptr InitiallyUnownedClass
    -> IO (Maybe InitiallyUnownedClassDisposeFieldCallback))
-> IO (Maybe InitiallyUnownedClassDisposeFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr InitiallyUnownedClass
s ((Ptr InitiallyUnownedClass
  -> IO (Maybe InitiallyUnownedClassDisposeFieldCallback))
 -> IO (Maybe InitiallyUnownedClassDisposeFieldCallback))
-> (Ptr InitiallyUnownedClass
    -> IO (Maybe InitiallyUnownedClassDisposeFieldCallback))
-> IO (Maybe InitiallyUnownedClassDisposeFieldCallback)
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr InitiallyUnownedClass
ptr -> do
    FunPtr C_InitiallyUnownedClassDisposeFieldCallback
val <- Ptr (FunPtr C_InitiallyUnownedClassDisposeFieldCallback)
-> IO (FunPtr C_InitiallyUnownedClassDisposeFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr InitiallyUnownedClass
ptr Ptr InitiallyUnownedClass
-> Int -> Ptr (FunPtr C_InitiallyUnownedClassDisposeFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 40) :: IO (FunPtr GObject.Callbacks.C_InitiallyUnownedClassDisposeFieldCallback)
    Maybe InitiallyUnownedClassDisposeFieldCallback
result <- FunPtr C_InitiallyUnownedClassDisposeFieldCallback
-> (FunPtr C_InitiallyUnownedClassDisposeFieldCallback
    -> IO InitiallyUnownedClassDisposeFieldCallback)
-> IO (Maybe InitiallyUnownedClassDisposeFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_InitiallyUnownedClassDisposeFieldCallback
val ((FunPtr C_InitiallyUnownedClassDisposeFieldCallback
  -> IO InitiallyUnownedClassDisposeFieldCallback)
 -> IO (Maybe InitiallyUnownedClassDisposeFieldCallback))
-> (FunPtr C_InitiallyUnownedClassDisposeFieldCallback
    -> IO InitiallyUnownedClassDisposeFieldCallback)
-> IO (Maybe InitiallyUnownedClassDisposeFieldCallback)
forall a b. (a -> b) -> a -> b
$ \val' :: FunPtr C_InitiallyUnownedClassDisposeFieldCallback
val' -> do
        let val'' :: InitiallyUnownedClassDisposeFieldCallback
val'' = FunPtr C_InitiallyUnownedClassDisposeFieldCallback
-> InitiallyUnownedClassDisposeFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
FunPtr C_InitiallyUnownedClassDisposeFieldCallback -> a -> m ()
GObject.Callbacks.dynamic_InitiallyUnownedClassDisposeFieldCallback FunPtr C_InitiallyUnownedClassDisposeFieldCallback
val'
        InitiallyUnownedClassDisposeFieldCallback
-> IO InitiallyUnownedClassDisposeFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return InitiallyUnownedClassDisposeFieldCallback
val''
    Maybe InitiallyUnownedClassDisposeFieldCallback
-> IO (Maybe InitiallyUnownedClassDisposeFieldCallback)
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 :: InitiallyUnownedClass
-> FunPtr C_InitiallyUnownedClassDisposeFieldCallback -> m ()
setInitiallyUnownedClassDispose s :: InitiallyUnownedClass
s val :: FunPtr C_InitiallyUnownedClassDisposeFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ InitiallyUnownedClass
-> (Ptr InitiallyUnownedClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr InitiallyUnownedClass
s ((Ptr InitiallyUnownedClass -> IO ()) -> IO ())
-> (Ptr InitiallyUnownedClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr InitiallyUnownedClass
ptr -> do
    Ptr (FunPtr C_InitiallyUnownedClassDisposeFieldCallback)
-> FunPtr C_InitiallyUnownedClassDisposeFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr InitiallyUnownedClass
ptr Ptr InitiallyUnownedClass
-> Int -> Ptr (FunPtr C_InitiallyUnownedClassDisposeFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 40) (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 :: InitiallyUnownedClass -> m ()
clearInitiallyUnownedClassDispose s :: InitiallyUnownedClass
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ InitiallyUnownedClass
-> (Ptr InitiallyUnownedClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr InitiallyUnownedClass
s ((Ptr InitiallyUnownedClass -> IO ()) -> IO ())
-> (Ptr InitiallyUnownedClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr InitiallyUnownedClass
ptr -> do
    Ptr (FunPtr C_InitiallyUnownedClassDisposeFieldCallback)
-> FunPtr C_InitiallyUnownedClassDisposeFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr InitiallyUnownedClass
ptr Ptr InitiallyUnownedClass
-> Int -> Ptr (FunPtr C_InitiallyUnownedClassDisposeFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 40) (FunPtr C_InitiallyUnownedClassDisposeFieldCallback
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)

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 :: InitiallyUnownedClass
-> m (Maybe InitiallyUnownedClassDisposeFieldCallback)
getInitiallyUnownedClassFinalize s :: InitiallyUnownedClass
s = IO (Maybe InitiallyUnownedClassDisposeFieldCallback)
-> m (Maybe InitiallyUnownedClassDisposeFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe InitiallyUnownedClassDisposeFieldCallback)
 -> m (Maybe InitiallyUnownedClassDisposeFieldCallback))
-> IO (Maybe InitiallyUnownedClassDisposeFieldCallback)
-> m (Maybe InitiallyUnownedClassDisposeFieldCallback)
forall a b. (a -> b) -> a -> b
$ InitiallyUnownedClass
-> (Ptr InitiallyUnownedClass
    -> IO (Maybe InitiallyUnownedClassDisposeFieldCallback))
-> IO (Maybe InitiallyUnownedClassDisposeFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr InitiallyUnownedClass
s ((Ptr InitiallyUnownedClass
  -> IO (Maybe InitiallyUnownedClassDisposeFieldCallback))
 -> IO (Maybe InitiallyUnownedClassDisposeFieldCallback))
-> (Ptr InitiallyUnownedClass
    -> IO (Maybe InitiallyUnownedClassDisposeFieldCallback))
-> IO (Maybe InitiallyUnownedClassDisposeFieldCallback)
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr InitiallyUnownedClass
ptr -> do
    FunPtr C_InitiallyUnownedClassDisposeFieldCallback
val <- Ptr (FunPtr C_InitiallyUnownedClassDisposeFieldCallback)
-> IO (FunPtr C_InitiallyUnownedClassDisposeFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr InitiallyUnownedClass
ptr Ptr InitiallyUnownedClass
-> Int -> Ptr (FunPtr C_InitiallyUnownedClassDisposeFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 48) :: IO (FunPtr GObject.Callbacks.C_InitiallyUnownedClassFinalizeFieldCallback)
    Maybe InitiallyUnownedClassDisposeFieldCallback
result <- FunPtr C_InitiallyUnownedClassDisposeFieldCallback
-> (FunPtr C_InitiallyUnownedClassDisposeFieldCallback
    -> IO InitiallyUnownedClassDisposeFieldCallback)
-> IO (Maybe InitiallyUnownedClassDisposeFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_InitiallyUnownedClassDisposeFieldCallback
val ((FunPtr C_InitiallyUnownedClassDisposeFieldCallback
  -> IO InitiallyUnownedClassDisposeFieldCallback)
 -> IO (Maybe InitiallyUnownedClassDisposeFieldCallback))
-> (FunPtr C_InitiallyUnownedClassDisposeFieldCallback
    -> IO InitiallyUnownedClassDisposeFieldCallback)
-> IO (Maybe InitiallyUnownedClassDisposeFieldCallback)
forall a b. (a -> b) -> a -> b
$ \val' :: FunPtr C_InitiallyUnownedClassDisposeFieldCallback
val' -> do
        let val'' :: InitiallyUnownedClassDisposeFieldCallback
val'' = FunPtr C_InitiallyUnownedClassDisposeFieldCallback
-> InitiallyUnownedClassDisposeFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
FunPtr C_InitiallyUnownedClassDisposeFieldCallback -> a -> m ()
GObject.Callbacks.dynamic_InitiallyUnownedClassFinalizeFieldCallback FunPtr C_InitiallyUnownedClassDisposeFieldCallback
val'
        InitiallyUnownedClassDisposeFieldCallback
-> IO InitiallyUnownedClassDisposeFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return InitiallyUnownedClassDisposeFieldCallback
val''
    Maybe InitiallyUnownedClassDisposeFieldCallback
-> IO (Maybe InitiallyUnownedClassDisposeFieldCallback)
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 :: InitiallyUnownedClass
-> FunPtr C_InitiallyUnownedClassDisposeFieldCallback -> m ()
setInitiallyUnownedClassFinalize s :: InitiallyUnownedClass
s val :: FunPtr C_InitiallyUnownedClassDisposeFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ InitiallyUnownedClass
-> (Ptr InitiallyUnownedClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr InitiallyUnownedClass
s ((Ptr InitiallyUnownedClass -> IO ()) -> IO ())
-> (Ptr InitiallyUnownedClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr InitiallyUnownedClass
ptr -> do
    Ptr (FunPtr C_InitiallyUnownedClassDisposeFieldCallback)
-> FunPtr C_InitiallyUnownedClassDisposeFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr InitiallyUnownedClass
ptr Ptr InitiallyUnownedClass
-> Int -> Ptr (FunPtr C_InitiallyUnownedClassDisposeFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 48) (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 :: InitiallyUnownedClass -> m ()
clearInitiallyUnownedClassFinalize s :: InitiallyUnownedClass
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ InitiallyUnownedClass
-> (Ptr InitiallyUnownedClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr InitiallyUnownedClass
s ((Ptr InitiallyUnownedClass -> IO ()) -> IO ())
-> (Ptr InitiallyUnownedClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr InitiallyUnownedClass
ptr -> do
    Ptr (FunPtr C_InitiallyUnownedClassDisposeFieldCallback)
-> FunPtr C_InitiallyUnownedClassDisposeFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr InitiallyUnownedClass
ptr Ptr InitiallyUnownedClass
-> Int -> Ptr (FunPtr C_InitiallyUnownedClassDisposeFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 48) (FunPtr C_InitiallyUnownedClassDisposeFieldCallback
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)

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 :: InitiallyUnownedClass
-> m (Maybe
        InitiallyUnownedClassDispatchPropertiesChangedFieldCallback)
getInitiallyUnownedClassDispatchPropertiesChanged s :: InitiallyUnownedClass
s = IO
  (Maybe InitiallyUnownedClassDispatchPropertiesChangedFieldCallback)
-> m (Maybe
        InitiallyUnownedClassDispatchPropertiesChangedFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO
   (Maybe InitiallyUnownedClassDispatchPropertiesChangedFieldCallback)
 -> m (Maybe
         InitiallyUnownedClassDispatchPropertiesChangedFieldCallback))
-> IO
     (Maybe InitiallyUnownedClassDispatchPropertiesChangedFieldCallback)
-> m (Maybe
        InitiallyUnownedClassDispatchPropertiesChangedFieldCallback)
forall a b. (a -> b) -> a -> b
$ InitiallyUnownedClass
-> (Ptr InitiallyUnownedClass
    -> IO
         (Maybe
            InitiallyUnownedClassDispatchPropertiesChangedFieldCallback))
-> IO
     (Maybe InitiallyUnownedClassDispatchPropertiesChangedFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr InitiallyUnownedClass
s ((Ptr InitiallyUnownedClass
  -> IO
       (Maybe
          InitiallyUnownedClassDispatchPropertiesChangedFieldCallback))
 -> IO
      (Maybe
         InitiallyUnownedClassDispatchPropertiesChangedFieldCallback))
-> (Ptr InitiallyUnownedClass
    -> IO
         (Maybe
            InitiallyUnownedClassDispatchPropertiesChangedFieldCallback))
-> IO
     (Maybe InitiallyUnownedClassDispatchPropertiesChangedFieldCallback)
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr InitiallyUnownedClass
ptr -> do
    FunPtr
  C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback
val <- Ptr
  (FunPtr
     C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback)
-> IO
     (FunPtr
        C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr InitiallyUnownedClass
ptr Ptr InitiallyUnownedClass
-> Int
-> Ptr
     (FunPtr
        C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 56) :: IO (FunPtr GObject.Callbacks.C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback)
    Maybe InitiallyUnownedClassDispatchPropertiesChangedFieldCallback
result <- FunPtr
  C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback
-> (FunPtr
      C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback
    -> IO InitiallyUnownedClassDispatchPropertiesChangedFieldCallback)
-> IO
     (Maybe InitiallyUnownedClassDispatchPropertiesChangedFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr
  C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback
val ((FunPtr
    C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback
  -> IO InitiallyUnownedClassDispatchPropertiesChangedFieldCallback)
 -> IO
      (Maybe
         InitiallyUnownedClassDispatchPropertiesChangedFieldCallback))
-> (FunPtr
      C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback
    -> IO InitiallyUnownedClassDispatchPropertiesChangedFieldCallback)
-> IO
     (Maybe InitiallyUnownedClassDispatchPropertiesChangedFieldCallback)
forall a b. (a -> b) -> a -> b
$ \val' :: FunPtr
  C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback
val' -> do
        let val'' :: InitiallyUnownedClassDispatchPropertiesChangedFieldCallback
val'' = FunPtr
  C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback
-> InitiallyUnownedClassDispatchPropertiesChangedFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
FunPtr
  C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback
-> a -> Word32 -> GParamSpec -> m ()
GObject.Callbacks.dynamic_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback FunPtr
  C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback
val'
        InitiallyUnownedClassDispatchPropertiesChangedFieldCallback
-> IO InitiallyUnownedClassDispatchPropertiesChangedFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return InitiallyUnownedClassDispatchPropertiesChangedFieldCallback
val''
    Maybe InitiallyUnownedClassDispatchPropertiesChangedFieldCallback
-> IO
     (Maybe InitiallyUnownedClassDispatchPropertiesChangedFieldCallback)
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 :: InitiallyUnownedClass
-> FunPtr
     C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback
-> m ()
setInitiallyUnownedClassDispatchPropertiesChanged s :: InitiallyUnownedClass
s val :: FunPtr
  C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ InitiallyUnownedClass
-> (Ptr InitiallyUnownedClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr InitiallyUnownedClass
s ((Ptr InitiallyUnownedClass -> IO ()) -> IO ())
-> (Ptr InitiallyUnownedClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr InitiallyUnownedClass
ptr -> do
    Ptr
  (FunPtr
     C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback)
-> FunPtr
     C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback
-> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr InitiallyUnownedClass
ptr Ptr InitiallyUnownedClass
-> Int
-> Ptr
     (FunPtr
        C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 56) (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 :: InitiallyUnownedClass -> m ()
clearInitiallyUnownedClassDispatchPropertiesChanged s :: InitiallyUnownedClass
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ InitiallyUnownedClass
-> (Ptr InitiallyUnownedClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr InitiallyUnownedClass
s ((Ptr InitiallyUnownedClass -> IO ()) -> IO ())
-> (Ptr InitiallyUnownedClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr InitiallyUnownedClass
ptr -> do
    Ptr
  (FunPtr
     C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback)
-> FunPtr
     C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback
-> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr InitiallyUnownedClass
ptr Ptr InitiallyUnownedClass
-> Int
-> Ptr
     (FunPtr
        C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 56) (FunPtr
  C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback
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)

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 :: InitiallyUnownedClass
-> m (Maybe InitiallyUnownedClassNotifyFieldCallback)
getInitiallyUnownedClassNotify s :: InitiallyUnownedClass
s = IO (Maybe InitiallyUnownedClassNotifyFieldCallback)
-> m (Maybe InitiallyUnownedClassNotifyFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe InitiallyUnownedClassNotifyFieldCallback)
 -> m (Maybe InitiallyUnownedClassNotifyFieldCallback))
-> IO (Maybe InitiallyUnownedClassNotifyFieldCallback)
-> m (Maybe InitiallyUnownedClassNotifyFieldCallback)
forall a b. (a -> b) -> a -> b
$ InitiallyUnownedClass
-> (Ptr InitiallyUnownedClass
    -> IO (Maybe InitiallyUnownedClassNotifyFieldCallback))
-> IO (Maybe InitiallyUnownedClassNotifyFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr InitiallyUnownedClass
s ((Ptr InitiallyUnownedClass
  -> IO (Maybe InitiallyUnownedClassNotifyFieldCallback))
 -> IO (Maybe InitiallyUnownedClassNotifyFieldCallback))
-> (Ptr InitiallyUnownedClass
    -> IO (Maybe InitiallyUnownedClassNotifyFieldCallback))
-> IO (Maybe InitiallyUnownedClassNotifyFieldCallback)
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr InitiallyUnownedClass
ptr -> do
    FunPtr C_InitiallyUnownedClassNotifyFieldCallback
val <- Ptr (FunPtr C_InitiallyUnownedClassNotifyFieldCallback)
-> IO (FunPtr C_InitiallyUnownedClassNotifyFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr InitiallyUnownedClass
ptr Ptr InitiallyUnownedClass
-> Int -> Ptr (FunPtr C_InitiallyUnownedClassNotifyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 64) :: IO (FunPtr GObject.Callbacks.C_InitiallyUnownedClassNotifyFieldCallback)
    Maybe InitiallyUnownedClassNotifyFieldCallback
result <- FunPtr C_InitiallyUnownedClassNotifyFieldCallback
-> (FunPtr C_InitiallyUnownedClassNotifyFieldCallback
    -> IO InitiallyUnownedClassNotifyFieldCallback)
-> IO (Maybe InitiallyUnownedClassNotifyFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_InitiallyUnownedClassNotifyFieldCallback
val ((FunPtr C_InitiallyUnownedClassNotifyFieldCallback
  -> IO InitiallyUnownedClassNotifyFieldCallback)
 -> IO (Maybe InitiallyUnownedClassNotifyFieldCallback))
-> (FunPtr C_InitiallyUnownedClassNotifyFieldCallback
    -> IO InitiallyUnownedClassNotifyFieldCallback)
-> IO (Maybe InitiallyUnownedClassNotifyFieldCallback)
forall a b. (a -> b) -> a -> b
$ \val' :: FunPtr C_InitiallyUnownedClassNotifyFieldCallback
val' -> do
        let val'' :: InitiallyUnownedClassNotifyFieldCallback
val'' = FunPtr C_InitiallyUnownedClassNotifyFieldCallback
-> InitiallyUnownedClassNotifyFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
FunPtr C_InitiallyUnownedClassNotifyFieldCallback
-> a -> GParamSpec -> m ()
GObject.Callbacks.dynamic_InitiallyUnownedClassNotifyFieldCallback FunPtr C_InitiallyUnownedClassNotifyFieldCallback
val'
        InitiallyUnownedClassNotifyFieldCallback
-> IO InitiallyUnownedClassNotifyFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return InitiallyUnownedClassNotifyFieldCallback
val''
    Maybe InitiallyUnownedClassNotifyFieldCallback
-> IO (Maybe InitiallyUnownedClassNotifyFieldCallback)
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 :: InitiallyUnownedClass
-> FunPtr C_InitiallyUnownedClassNotifyFieldCallback -> m ()
setInitiallyUnownedClassNotify s :: InitiallyUnownedClass
s val :: FunPtr C_InitiallyUnownedClassNotifyFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ InitiallyUnownedClass
-> (Ptr InitiallyUnownedClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr InitiallyUnownedClass
s ((Ptr InitiallyUnownedClass -> IO ()) -> IO ())
-> (Ptr InitiallyUnownedClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr InitiallyUnownedClass
ptr -> do
    Ptr (FunPtr C_InitiallyUnownedClassNotifyFieldCallback)
-> FunPtr C_InitiallyUnownedClassNotifyFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr InitiallyUnownedClass
ptr Ptr InitiallyUnownedClass
-> Int -> Ptr (FunPtr C_InitiallyUnownedClassNotifyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 64) (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 :: InitiallyUnownedClass -> m ()
clearInitiallyUnownedClassNotify s :: InitiallyUnownedClass
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ InitiallyUnownedClass
-> (Ptr InitiallyUnownedClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr InitiallyUnownedClass
s ((Ptr InitiallyUnownedClass -> IO ()) -> IO ())
-> (Ptr InitiallyUnownedClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr InitiallyUnownedClass
ptr -> do
    Ptr (FunPtr C_InitiallyUnownedClassNotifyFieldCallback)
-> FunPtr C_InitiallyUnownedClassNotifyFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr InitiallyUnownedClass
ptr Ptr InitiallyUnownedClass
-> Int -> Ptr (FunPtr C_InitiallyUnownedClassNotifyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 64) (FunPtr C_InitiallyUnownedClassNotifyFieldCallback
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)

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 :: InitiallyUnownedClass
-> m (Maybe InitiallyUnownedClassDisposeFieldCallback)
getInitiallyUnownedClassConstructed s :: InitiallyUnownedClass
s = IO (Maybe InitiallyUnownedClassDisposeFieldCallback)
-> m (Maybe InitiallyUnownedClassDisposeFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe InitiallyUnownedClassDisposeFieldCallback)
 -> m (Maybe InitiallyUnownedClassDisposeFieldCallback))
-> IO (Maybe InitiallyUnownedClassDisposeFieldCallback)
-> m (Maybe InitiallyUnownedClassDisposeFieldCallback)
forall a b. (a -> b) -> a -> b
$ InitiallyUnownedClass
-> (Ptr InitiallyUnownedClass
    -> IO (Maybe InitiallyUnownedClassDisposeFieldCallback))
-> IO (Maybe InitiallyUnownedClassDisposeFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr InitiallyUnownedClass
s ((Ptr InitiallyUnownedClass
  -> IO (Maybe InitiallyUnownedClassDisposeFieldCallback))
 -> IO (Maybe InitiallyUnownedClassDisposeFieldCallback))
-> (Ptr InitiallyUnownedClass
    -> IO (Maybe InitiallyUnownedClassDisposeFieldCallback))
-> IO (Maybe InitiallyUnownedClassDisposeFieldCallback)
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr InitiallyUnownedClass
ptr -> do
    FunPtr C_InitiallyUnownedClassDisposeFieldCallback
val <- Ptr (FunPtr C_InitiallyUnownedClassDisposeFieldCallback)
-> IO (FunPtr C_InitiallyUnownedClassDisposeFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr InitiallyUnownedClass
ptr Ptr InitiallyUnownedClass
-> Int -> Ptr (FunPtr C_InitiallyUnownedClassDisposeFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 72) :: IO (FunPtr GObject.Callbacks.C_InitiallyUnownedClassConstructedFieldCallback)
    Maybe InitiallyUnownedClassDisposeFieldCallback
result <- FunPtr C_InitiallyUnownedClassDisposeFieldCallback
-> (FunPtr C_InitiallyUnownedClassDisposeFieldCallback
    -> IO InitiallyUnownedClassDisposeFieldCallback)
-> IO (Maybe InitiallyUnownedClassDisposeFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_InitiallyUnownedClassDisposeFieldCallback
val ((FunPtr C_InitiallyUnownedClassDisposeFieldCallback
  -> IO InitiallyUnownedClassDisposeFieldCallback)
 -> IO (Maybe InitiallyUnownedClassDisposeFieldCallback))
-> (FunPtr C_InitiallyUnownedClassDisposeFieldCallback
    -> IO InitiallyUnownedClassDisposeFieldCallback)
-> IO (Maybe InitiallyUnownedClassDisposeFieldCallback)
forall a b. (a -> b) -> a -> b
$ \val' :: FunPtr C_InitiallyUnownedClassDisposeFieldCallback
val' -> do
        let val'' :: InitiallyUnownedClassDisposeFieldCallback
val'' = FunPtr C_InitiallyUnownedClassDisposeFieldCallback
-> InitiallyUnownedClassDisposeFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
FunPtr C_InitiallyUnownedClassDisposeFieldCallback -> a -> m ()
GObject.Callbacks.dynamic_InitiallyUnownedClassConstructedFieldCallback FunPtr C_InitiallyUnownedClassDisposeFieldCallback
val'
        InitiallyUnownedClassDisposeFieldCallback
-> IO InitiallyUnownedClassDisposeFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return InitiallyUnownedClassDisposeFieldCallback
val''
    Maybe InitiallyUnownedClassDisposeFieldCallback
-> IO (Maybe InitiallyUnownedClassDisposeFieldCallback)
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 :: InitiallyUnownedClass
-> FunPtr C_InitiallyUnownedClassDisposeFieldCallback -> m ()
setInitiallyUnownedClassConstructed s :: InitiallyUnownedClass
s val :: FunPtr C_InitiallyUnownedClassDisposeFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ InitiallyUnownedClass
-> (Ptr InitiallyUnownedClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr InitiallyUnownedClass
s ((Ptr InitiallyUnownedClass -> IO ()) -> IO ())
-> (Ptr InitiallyUnownedClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr InitiallyUnownedClass
ptr -> do
    Ptr (FunPtr C_InitiallyUnownedClassDisposeFieldCallback)
-> FunPtr C_InitiallyUnownedClassDisposeFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr InitiallyUnownedClass
ptr Ptr InitiallyUnownedClass
-> Int -> Ptr (FunPtr C_InitiallyUnownedClassDisposeFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 72) (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 :: InitiallyUnownedClass -> m ()
clearInitiallyUnownedClassConstructed s :: InitiallyUnownedClass
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ InitiallyUnownedClass
-> (Ptr InitiallyUnownedClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr InitiallyUnownedClass
s ((Ptr InitiallyUnownedClass -> IO ()) -> IO ())
-> (Ptr InitiallyUnownedClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr InitiallyUnownedClass
ptr -> do
    Ptr (FunPtr C_InitiallyUnownedClassDisposeFieldCallback)
-> FunPtr C_InitiallyUnownedClassDisposeFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr InitiallyUnownedClass
ptr Ptr InitiallyUnownedClass
-> Int -> Ptr (FunPtr C_InitiallyUnownedClassDisposeFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 72) (FunPtr C_InitiallyUnownedClassDisposeFieldCallback
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)

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, *)])
#endif

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

instance (info ~ ResolveInitiallyUnownedClassMethod t InitiallyUnownedClass, O.MethodInfo 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

#endif