{-# 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#
-- | the /@constructed@/ function is called by @/g_object_new()/@ as the
--  final step of the object creation process.  At the point of the call, all
--  construction properties have been set on the object.  The purpose of this
--  call is to allow for object initialisation steps that can only be performed
--  after construction properties have been set.  /@constructed@/ implementors
--  should chain up to the /@constructed@/ call of their parent class to allow it
--  to complete its initialisation.

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


-- ** dispatchPropertiesChanged #attr:dispatchPropertiesChanged#
-- | emits property change notification for a bunch
--  of properties. Overriding /@dispatchPropertiesChanged@/ should be rarely
--  needed.

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


-- ** dispose #attr:dispose#
-- | the /@dispose@/ function is supposed to drop all references to other
--  objects, but keep the instance otherwise intact, so that client method
--  invocations still work. It may be run multiple times (due to reference
--  loops). Before returning, /@dispose@/ should chain up to the /@dispose@/ method
--  of the parent class.

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


-- ** finalize #attr:finalize#
-- | instance finalization function, should finish the finalization of
--  the instance begun in /@dispose@/ and chain up to the /@finalize@/ method of the
--  parent class.

    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#
-- | the generic getter for all properties of this type. Should be
--  overridden for every type with properties.

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


-- ** notify #attr:notify#
-- | the class closure for the notify signal

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


-- ** setProperty #attr:setProperty#
-- | the generic setter for all properties of this type. Should be
--  overridden for every type with properties. If implementations of
--  /@setProperty@/ don\'t emit property change notification explicitly, this will
--  be done implicitly by the type system. However, if the notify signal is
--  emitted explicitly, the type system will not emit it a second time.

    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 Data.Word as DW
import qualified Data.Int as DI
import qualified Data.Bits as DB
import qualified System.Posix.Types as SPT
import qualified Foreign.C.Types as FCT

-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
#if MIN_VERSION_base(4,18,0)
import qualified GI.GObject.Callbacks as GObject.Callbacks
import {-# SOURCE #-} qualified GI.GObject.Structs.TypeClass as GObject.TypeClass

#else
import qualified GI.GObject.Callbacks as GObject.Callbacks
import {-# SOURCE #-} qualified GI.GObject.Structs.TypeClass as GObject.TypeClass

#endif

-- | Memory-managed wrapper type.
newtype InitiallyUnownedClass = InitiallyUnownedClass (SP.ManagedPtr InitiallyUnownedClass)
    deriving (InitiallyUnownedClass -> InitiallyUnownedClass -> Bool
(InitiallyUnownedClass -> InitiallyUnownedClass -> Bool)
-> (InitiallyUnownedClass -> InitiallyUnownedClass -> Bool)
-> Eq InitiallyUnownedClass
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: InitiallyUnownedClass -> InitiallyUnownedClass -> Bool
== :: InitiallyUnownedClass -> InitiallyUnownedClass -> Bool
$c/= :: InitiallyUnownedClass -> InitiallyUnownedClass -> Bool
/= :: 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 -> InitiallyUnownedClass
-> (Ptr InitiallyUnownedClass -> IO InitiallyUnownedClass)
-> IO InitiallyUnownedClass
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr InitiallyUnownedClass
p (Int -> Ptr InitiallyUnownedClass -> IO (Ptr InitiallyUnownedClass)
forall a. (HasCallStack, CallocPtr a) => Int -> Ptr a -> IO (Ptr a)
copyBytes Int
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, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.wrapPtr ManagedPtr InitiallyUnownedClass -> InitiallyUnownedClass
InitiallyUnownedClass)
    boxedPtrFree :: InitiallyUnownedClass -> IO ()
boxedPtrFree = \InitiallyUnownedClass
x -> InitiallyUnownedClass
-> (Ptr InitiallyUnownedClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
SP.withManagedPtr InitiallyUnownedClass
x Ptr InitiallyUnownedClass -> IO ()
forall a. Ptr a -> IO ()
SP.freeMem
instance CallocPtr InitiallyUnownedClass where
    boxedPtrCalloc :: IO (Ptr InitiallyUnownedClass)
boxedPtrCalloc = Int -> IO (Ptr InitiallyUnownedClass)
forall a. Int -> IO (Ptr a)
callocBytes Int
136


-- | Construct a t'InitiallyUnownedClass' struct initialized to zero.
newZeroInitiallyUnownedClass :: MonadIO m => m InitiallyUnownedClass
newZeroInitiallyUnownedClass :: forall (m :: * -> *). MonadIO m => m InitiallyUnownedClass
newZeroInitiallyUnownedClass = IO InitiallyUnownedClass -> m InitiallyUnownedClass
forall a. IO a -> m a
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. CallocPtr a => IO (Ptr a)
boxedPtrCalloc IO (Ptr InitiallyUnownedClass)
-> (Ptr InitiallyUnownedClass -> IO InitiallyUnownedClass)
-> IO InitiallyUnownedClass
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr InitiallyUnownedClass -> InitiallyUnownedClass)
-> Ptr InitiallyUnownedClass -> IO InitiallyUnownedClass
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
        o <- m InitiallyUnownedClass
forall (m :: * -> *). MonadIO m => m InitiallyUnownedClass
newZeroInitiallyUnownedClass
        GI.Attributes.set o attrs
        return 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 = IO TypeClass -> m TypeClass
forall a. IO a -> m a
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 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` Int
0 :: (Ptr GObject.TypeClass.TypeClass)
    val' <- ((ManagedPtr TypeClass -> TypeClass)
-> Ptr TypeClass -> IO TypeClass
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr TypeClass -> TypeClass
GObject.TypeClass.TypeClass) Ptr TypeClass
val
    return 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 :: forall o.
AttrBaseTypeConstraint
  InitiallyUnownedClassGTypeClassFieldInfo o =>
o -> IO (AttrGetType InitiallyUnownedClassGTypeClassFieldInfo)
attrGet = o -> IO (AttrGetType InitiallyUnownedClassGTypeClassFieldInfo)
InitiallyUnownedClass -> IO TypeClass
forall (m :: * -> *).
MonadIO m =>
InitiallyUnownedClass -> m TypeClass
getInitiallyUnownedClassGTypeClass
    attrSet :: forall o b.
(AttrBaseTypeConstraint InitiallyUnownedClassGTypeClassFieldInfo o,
 AttrSetTypeConstraint
   InitiallyUnownedClassGTypeClassFieldInfo b) =>
o -> b -> IO ()
attrSet = o -> b -> IO ()
forall a. HasCallStack => a
undefined
    attrConstruct :: forall o b.
(AttrBaseTypeConstraint InitiallyUnownedClassGTypeClassFieldInfo o,
 AttrSetTypeConstraint
   InitiallyUnownedClassGTypeClassFieldInfo b) =>
b -> IO (GValueConstruct o)
attrConstruct = b -> IO (GValueConstruct o)
forall a. HasCallStack => a
undefined
    attrClear :: forall o.
AttrBaseTypeConstraint
  InitiallyUnownedClassGTypeClassFieldInfo o =>
o -> IO ()
attrClear = o -> IO ()
forall a. HasCallStack => a
undefined
    attrTransfer :: forall o b.
(AttrBaseTypeConstraint InitiallyUnownedClassGTypeClassFieldInfo o,
 AttrTransferTypeConstraint
   InitiallyUnownedClassGTypeClassFieldInfo b) =>
Proxy o
-> b
-> IO (AttrTransferType InitiallyUnownedClassGTypeClassFieldInfo)
attrTransfer = Proxy o -> b -> IO (Ptr TypeClass)
Proxy o
-> b
-> IO (AttrTransferType InitiallyUnownedClassGTypeClassFieldInfo)
forall a. HasCallStack => a
undefined
    dbgAttrInfo :: Maybe ResolvedSymbolInfo
dbgAttrInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GObject.Structs.InitiallyUnownedClass.gTypeClass"
        , resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-gobject-2.0.32/docs/GI-GObject-Structs-InitiallyUnownedClass.html#g:attr:gTypeClass"
        })

initiallyUnownedClass_gTypeClass :: AttrLabelProxy "gTypeClass"
initiallyUnownedClass_gTypeClass :: AttrLabelProxy "gTypeClass"
initiallyUnownedClass_gTypeClass = AttrLabelProxy "gTypeClass"
forall (a :: Symbol). AttrLabelProxy a
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 = IO (Maybe InitiallyUnownedClassSetPropertyFieldCallback)
-> m (Maybe InitiallyUnownedClassSetPropertyFieldCallback)
forall a. IO a -> m a
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 InitiallyUnownedClass
ptr -> do
    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` Int
24) :: IO (FunPtr GObject.Callbacks.C_InitiallyUnownedClassSetPropertyFieldCallback)
    result <- SP.convertFunPtrIfNonNull 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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return InitiallyUnownedClassSetPropertyFieldCallback
val''
    return 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 = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ 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 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` Int
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 :: forall (m :: * -> *). MonadIO m => InitiallyUnownedClass -> m ()
clearInitiallyUnownedClassSetProperty InitiallyUnownedClass
s = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ 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 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` Int
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 :: forall o.
AttrBaseTypeConstraint
  InitiallyUnownedClassSetPropertyFieldInfo o =>
o -> IO (AttrGetType InitiallyUnownedClassSetPropertyFieldInfo)
attrGet = o -> IO (AttrGetType InitiallyUnownedClassSetPropertyFieldInfo)
InitiallyUnownedClass
-> IO (Maybe InitiallyUnownedClassSetPropertyFieldCallback)
forall (m :: * -> *).
MonadIO m =>
InitiallyUnownedClass
-> m (Maybe InitiallyUnownedClassSetPropertyFieldCallback)
getInitiallyUnownedClassSetProperty
    attrSet :: forall o b.
(AttrBaseTypeConstraint
   InitiallyUnownedClassSetPropertyFieldInfo o,
 AttrSetTypeConstraint
   InitiallyUnownedClassSetPropertyFieldInfo b) =>
o -> b -> IO ()
attrSet = o -> b -> IO ()
InitiallyUnownedClass
-> FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback -> IO ()
forall (m :: * -> *).
MonadIO m =>
InitiallyUnownedClass
-> FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback -> m ()
setInitiallyUnownedClassSetProperty
    attrConstruct :: forall o b.
(AttrBaseTypeConstraint
   InitiallyUnownedClassSetPropertyFieldInfo o,
 AttrSetTypeConstraint
   InitiallyUnownedClassSetPropertyFieldInfo b) =>
b -> IO (GValueConstruct o)
attrConstruct = b -> IO (GValueConstruct o)
forall a. HasCallStack => a
undefined
    attrClear :: forall o.
AttrBaseTypeConstraint
  InitiallyUnownedClassSetPropertyFieldInfo o =>
o -> IO ()
attrClear = o -> IO ()
InitiallyUnownedClass -> IO ()
forall (m :: * -> *). MonadIO m => InitiallyUnownedClass -> m ()
clearInitiallyUnownedClassSetProperty
    attrTransfer :: forall o b.
(AttrBaseTypeConstraint
   InitiallyUnownedClassSetPropertyFieldInfo o,
 AttrTransferTypeConstraint
   InitiallyUnownedClassSetPropertyFieldInfo b) =>
Proxy o
-> b
-> IO (AttrTransferType InitiallyUnownedClassSetPropertyFieldInfo)
attrTransfer Proxy o
_ b
v = do
        C_InitiallyUnownedClassSetPropertyFieldCallback
-> IO (FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback)
GObject.Callbacks.mk_InitiallyUnownedClassSetPropertyFieldCallback (Maybe
  (Ptr (FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback))
-> InitiallyUnownedClassSetPropertyFieldCallback
-> C_InitiallyUnownedClassSetPropertyFieldCallback
GObject.Callbacks.wrap_InitiallyUnownedClassSetPropertyFieldCallback Maybe
  (Ptr (FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback))
forall a. Maybe a
Nothing b
InitiallyUnownedClassSetPropertyFieldCallback
v)
    dbgAttrInfo :: Maybe ResolvedSymbolInfo
dbgAttrInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GObject.Structs.InitiallyUnownedClass.setProperty"
        , resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-gobject-2.0.32/docs/GI-GObject-Structs-InitiallyUnownedClass.html#g:attr:setProperty"
        })

initiallyUnownedClass_setProperty :: AttrLabelProxy "setProperty"
initiallyUnownedClass_setProperty :: AttrLabelProxy "setProperty"
initiallyUnownedClass_setProperty = AttrLabelProxy "setProperty"
forall (a :: Symbol). AttrLabelProxy a
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 = IO (Maybe InitiallyUnownedClassSetPropertyFieldCallback)
-> m (Maybe InitiallyUnownedClassSetPropertyFieldCallback)
forall a. IO a -> m a
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 InitiallyUnownedClass
ptr -> do
    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` Int
32) :: IO (FunPtr GObject.Callbacks.C_InitiallyUnownedClassGetPropertyFieldCallback)
    result <- SP.convertFunPtrIfNonNull 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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return InitiallyUnownedClassSetPropertyFieldCallback
val''
    return 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 = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ 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 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` Int
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 :: forall (m :: * -> *). MonadIO m => InitiallyUnownedClass -> m ()
clearInitiallyUnownedClassGetProperty InitiallyUnownedClass
s = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ 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 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` Int
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 :: forall o.
AttrBaseTypeConstraint
  InitiallyUnownedClassGetPropertyFieldInfo o =>
o -> IO (AttrGetType InitiallyUnownedClassGetPropertyFieldInfo)
attrGet = o -> IO (AttrGetType InitiallyUnownedClassGetPropertyFieldInfo)
InitiallyUnownedClass
-> IO (Maybe InitiallyUnownedClassSetPropertyFieldCallback)
forall (m :: * -> *).
MonadIO m =>
InitiallyUnownedClass
-> m (Maybe InitiallyUnownedClassSetPropertyFieldCallback)
getInitiallyUnownedClassGetProperty
    attrSet :: forall o b.
(AttrBaseTypeConstraint
   InitiallyUnownedClassGetPropertyFieldInfo o,
 AttrSetTypeConstraint
   InitiallyUnownedClassGetPropertyFieldInfo b) =>
o -> b -> IO ()
attrSet = o -> b -> IO ()
InitiallyUnownedClass
-> FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback -> IO ()
forall (m :: * -> *).
MonadIO m =>
InitiallyUnownedClass
-> FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback -> m ()
setInitiallyUnownedClassGetProperty
    attrConstruct :: forall o b.
(AttrBaseTypeConstraint
   InitiallyUnownedClassGetPropertyFieldInfo o,
 AttrSetTypeConstraint
   InitiallyUnownedClassGetPropertyFieldInfo b) =>
b -> IO (GValueConstruct o)
attrConstruct = b -> IO (GValueConstruct o)
forall a. HasCallStack => a
undefined
    attrClear :: forall o.
AttrBaseTypeConstraint
  InitiallyUnownedClassGetPropertyFieldInfo o =>
o -> IO ()
attrClear = o -> IO ()
InitiallyUnownedClass -> IO ()
forall (m :: * -> *). MonadIO m => InitiallyUnownedClass -> m ()
clearInitiallyUnownedClassGetProperty
    attrTransfer :: forall o b.
(AttrBaseTypeConstraint
   InitiallyUnownedClassGetPropertyFieldInfo o,
 AttrTransferTypeConstraint
   InitiallyUnownedClassGetPropertyFieldInfo b) =>
Proxy o
-> b
-> IO (AttrTransferType InitiallyUnownedClassGetPropertyFieldInfo)
attrTransfer Proxy o
_ b
v = do
        C_InitiallyUnownedClassSetPropertyFieldCallback
-> IO (FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback)
GObject.Callbacks.mk_InitiallyUnownedClassGetPropertyFieldCallback (Maybe
  (Ptr (FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback))
-> InitiallyUnownedClassSetPropertyFieldCallback
-> C_InitiallyUnownedClassSetPropertyFieldCallback
GObject.Callbacks.wrap_InitiallyUnownedClassGetPropertyFieldCallback Maybe
  (Ptr (FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback))
forall a. Maybe a
Nothing b
InitiallyUnownedClassSetPropertyFieldCallback
v)
    dbgAttrInfo :: Maybe ResolvedSymbolInfo
dbgAttrInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GObject.Structs.InitiallyUnownedClass.getProperty"
        , resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-gobject-2.0.32/docs/GI-GObject-Structs-InitiallyUnownedClass.html#g:attr:getProperty"
        })

initiallyUnownedClass_getProperty :: AttrLabelProxy "getProperty"
initiallyUnownedClass_getProperty :: AttrLabelProxy "getProperty"
initiallyUnownedClass_getProperty = AttrLabelProxy "getProperty"
forall (a :: Symbol). AttrLabelProxy a
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 = IO (Maybe InitiallyUnownedClassDisposeFieldCallback)
-> m (Maybe InitiallyUnownedClassDisposeFieldCallback)
forall a. IO a -> m a
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 InitiallyUnownedClass
ptr -> do
    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` Int
40) :: IO (FunPtr GObject.Callbacks.C_InitiallyUnownedClassDisposeFieldCallback)
    result <- SP.convertFunPtrIfNonNull 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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return InitiallyUnownedClassDisposeFieldCallback
val''
    return 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 = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ 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 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` Int
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 :: forall (m :: * -> *). MonadIO m => InitiallyUnownedClass -> m ()
clearInitiallyUnownedClassDispose InitiallyUnownedClass
s = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ 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 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` Int
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 :: forall o.
AttrBaseTypeConstraint InitiallyUnownedClassDisposeFieldInfo o =>
o -> IO (AttrGetType InitiallyUnownedClassDisposeFieldInfo)
attrGet = o -> IO (AttrGetType InitiallyUnownedClassDisposeFieldInfo)
InitiallyUnownedClass
-> IO (Maybe InitiallyUnownedClassDisposeFieldCallback)
forall (m :: * -> *).
MonadIO m =>
InitiallyUnownedClass
-> m (Maybe InitiallyUnownedClassDisposeFieldCallback)
getInitiallyUnownedClassDispose
    attrSet :: forall o b.
(AttrBaseTypeConstraint InitiallyUnownedClassDisposeFieldInfo o,
 AttrSetTypeConstraint InitiallyUnownedClassDisposeFieldInfo b) =>
o -> b -> IO ()
attrSet = o -> b -> IO ()
InitiallyUnownedClass
-> FunPtr C_InitiallyUnownedClassDisposeFieldCallback -> IO ()
forall (m :: * -> *).
MonadIO m =>
InitiallyUnownedClass
-> FunPtr C_InitiallyUnownedClassDisposeFieldCallback -> m ()
setInitiallyUnownedClassDispose
    attrConstruct :: forall o b.
(AttrBaseTypeConstraint InitiallyUnownedClassDisposeFieldInfo o,
 AttrSetTypeConstraint InitiallyUnownedClassDisposeFieldInfo b) =>
b -> IO (GValueConstruct o)
attrConstruct = b -> IO (GValueConstruct o)
forall a. HasCallStack => a
undefined
    attrClear :: forall o.
AttrBaseTypeConstraint InitiallyUnownedClassDisposeFieldInfo o =>
o -> IO ()
attrClear = o -> IO ()
InitiallyUnownedClass -> IO ()
forall (m :: * -> *). MonadIO m => InitiallyUnownedClass -> m ()
clearInitiallyUnownedClassDispose
    attrTransfer :: forall o b.
(AttrBaseTypeConstraint InitiallyUnownedClassDisposeFieldInfo o,
 AttrTransferTypeConstraint
   InitiallyUnownedClassDisposeFieldInfo b) =>
Proxy o
-> b -> IO (AttrTransferType InitiallyUnownedClassDisposeFieldInfo)
attrTransfer Proxy o
_ b
v = do
        C_InitiallyUnownedClassDisposeFieldCallback
-> IO (FunPtr C_InitiallyUnownedClassDisposeFieldCallback)
GObject.Callbacks.mk_InitiallyUnownedClassDisposeFieldCallback (Maybe (Ptr (FunPtr C_InitiallyUnownedClassDisposeFieldCallback))
-> InitiallyUnownedClassDisposeFieldCallback
-> C_InitiallyUnownedClassDisposeFieldCallback
GObject.Callbacks.wrap_InitiallyUnownedClassDisposeFieldCallback Maybe (Ptr (FunPtr C_InitiallyUnownedClassDisposeFieldCallback))
forall a. Maybe a
Nothing b
InitiallyUnownedClassDisposeFieldCallback
v)
    dbgAttrInfo :: Maybe ResolvedSymbolInfo
dbgAttrInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GObject.Structs.InitiallyUnownedClass.dispose"
        , resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-gobject-2.0.32/docs/GI-GObject-Structs-InitiallyUnownedClass.html#g:attr:dispose"
        })

initiallyUnownedClass_dispose :: AttrLabelProxy "dispose"
initiallyUnownedClass_dispose :: AttrLabelProxy "dispose"
initiallyUnownedClass_dispose = AttrLabelProxy "dispose"
forall (a :: Symbol). AttrLabelProxy a
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 = IO (Maybe InitiallyUnownedClassDisposeFieldCallback)
-> m (Maybe InitiallyUnownedClassDisposeFieldCallback)
forall a. IO a -> m a
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 InitiallyUnownedClass
ptr -> do
    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` Int
48) :: IO (FunPtr GObject.Callbacks.C_InitiallyUnownedClassFinalizeFieldCallback)
    result <- SP.convertFunPtrIfNonNull 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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return InitiallyUnownedClassDisposeFieldCallback
val''
    return 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 = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ 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 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` Int
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 :: forall (m :: * -> *). MonadIO m => InitiallyUnownedClass -> m ()
clearInitiallyUnownedClassFinalize InitiallyUnownedClass
s = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ 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 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` Int
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 :: forall o.
AttrBaseTypeConstraint InitiallyUnownedClassFinalizeFieldInfo o =>
o -> IO (AttrGetType InitiallyUnownedClassFinalizeFieldInfo)
attrGet = o -> IO (AttrGetType InitiallyUnownedClassFinalizeFieldInfo)
InitiallyUnownedClass
-> IO (Maybe InitiallyUnownedClassDisposeFieldCallback)
forall (m :: * -> *).
MonadIO m =>
InitiallyUnownedClass
-> m (Maybe InitiallyUnownedClassDisposeFieldCallback)
getInitiallyUnownedClassFinalize
    attrSet :: forall o b.
(AttrBaseTypeConstraint InitiallyUnownedClassFinalizeFieldInfo o,
 AttrSetTypeConstraint InitiallyUnownedClassFinalizeFieldInfo b) =>
o -> b -> IO ()
attrSet = o -> b -> IO ()
InitiallyUnownedClass
-> FunPtr C_InitiallyUnownedClassDisposeFieldCallback -> IO ()
forall (m :: * -> *).
MonadIO m =>
InitiallyUnownedClass
-> FunPtr C_InitiallyUnownedClassDisposeFieldCallback -> m ()
setInitiallyUnownedClassFinalize
    attrConstruct :: forall o b.
(AttrBaseTypeConstraint InitiallyUnownedClassFinalizeFieldInfo o,
 AttrSetTypeConstraint InitiallyUnownedClassFinalizeFieldInfo b) =>
b -> IO (GValueConstruct o)
attrConstruct = b -> IO (GValueConstruct o)
forall a. HasCallStack => a
undefined
    attrClear :: forall o.
AttrBaseTypeConstraint InitiallyUnownedClassFinalizeFieldInfo o =>
o -> IO ()
attrClear = o -> IO ()
InitiallyUnownedClass -> IO ()
forall (m :: * -> *). MonadIO m => InitiallyUnownedClass -> m ()
clearInitiallyUnownedClassFinalize
    attrTransfer :: forall o b.
(AttrBaseTypeConstraint InitiallyUnownedClassFinalizeFieldInfo o,
 AttrTransferTypeConstraint
   InitiallyUnownedClassFinalizeFieldInfo b) =>
Proxy o
-> b
-> IO (AttrTransferType InitiallyUnownedClassFinalizeFieldInfo)
attrTransfer Proxy o
_ b
v = do
        C_InitiallyUnownedClassDisposeFieldCallback
-> IO (FunPtr C_InitiallyUnownedClassDisposeFieldCallback)
GObject.Callbacks.mk_InitiallyUnownedClassFinalizeFieldCallback (Maybe (Ptr (FunPtr C_InitiallyUnownedClassDisposeFieldCallback))
-> InitiallyUnownedClassDisposeFieldCallback
-> C_InitiallyUnownedClassDisposeFieldCallback
GObject.Callbacks.wrap_InitiallyUnownedClassFinalizeFieldCallback Maybe (Ptr (FunPtr C_InitiallyUnownedClassDisposeFieldCallback))
forall a. Maybe a
Nothing b
InitiallyUnownedClassDisposeFieldCallback
v)
    dbgAttrInfo :: Maybe ResolvedSymbolInfo
dbgAttrInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GObject.Structs.InitiallyUnownedClass.finalize"
        , resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-gobject-2.0.32/docs/GI-GObject-Structs-InitiallyUnownedClass.html#g:attr:finalize"
        })

initiallyUnownedClass_finalize :: AttrLabelProxy "finalize"
initiallyUnownedClass_finalize :: AttrLabelProxy "finalize"
initiallyUnownedClass_finalize = AttrLabelProxy "finalize"
forall (a :: Symbol). AttrLabelProxy a
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 = IO
  (Maybe InitiallyUnownedClassDispatchPropertiesChangedFieldCallback)
-> m (Maybe
        InitiallyUnownedClassDispatchPropertiesChangedFieldCallback)
forall a. IO a -> m a
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 InitiallyUnownedClass
ptr -> do
    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` Int
56) :: IO (FunPtr GObject.Callbacks.C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback)
    result <- SP.convertFunPtrIfNonNull 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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return InitiallyUnownedClassDispatchPropertiesChangedFieldCallback
val''
    return 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 = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ 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 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` Int
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 :: forall (m :: * -> *). MonadIO m => InitiallyUnownedClass -> m ()
clearInitiallyUnownedClassDispatchPropertiesChanged InitiallyUnownedClass
s = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ 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 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` Int
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 :: forall o.
AttrBaseTypeConstraint
  InitiallyUnownedClassDispatchPropertiesChangedFieldInfo o =>
o
-> IO
     (AttrGetType
        InitiallyUnownedClassDispatchPropertiesChangedFieldInfo)
attrGet = o
-> IO
     (AttrGetType
        InitiallyUnownedClassDispatchPropertiesChangedFieldInfo)
InitiallyUnownedClass
-> IO
     (Maybe InitiallyUnownedClassDispatchPropertiesChangedFieldCallback)
forall (m :: * -> *).
MonadIO m =>
InitiallyUnownedClass
-> m (Maybe
        InitiallyUnownedClassDispatchPropertiesChangedFieldCallback)
getInitiallyUnownedClassDispatchPropertiesChanged
    attrSet :: forall o b.
(AttrBaseTypeConstraint
   InitiallyUnownedClassDispatchPropertiesChangedFieldInfo o,
 AttrSetTypeConstraint
   InitiallyUnownedClassDispatchPropertiesChangedFieldInfo b) =>
o -> b -> IO ()
attrSet = o -> b -> IO ()
InitiallyUnownedClass
-> FunPtr
     C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback
-> IO ()
forall (m :: * -> *).
MonadIO m =>
InitiallyUnownedClass
-> FunPtr
     C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback
-> m ()
setInitiallyUnownedClassDispatchPropertiesChanged
    attrConstruct :: forall o b.
(AttrBaseTypeConstraint
   InitiallyUnownedClassDispatchPropertiesChangedFieldInfo o,
 AttrSetTypeConstraint
   InitiallyUnownedClassDispatchPropertiesChangedFieldInfo b) =>
b -> IO (GValueConstruct o)
attrConstruct = b -> IO (GValueConstruct o)
forall a. HasCallStack => a
undefined
    attrClear :: forall o.
AttrBaseTypeConstraint
  InitiallyUnownedClassDispatchPropertiesChangedFieldInfo o =>
o -> IO ()
attrClear = o -> IO ()
InitiallyUnownedClass -> IO ()
forall (m :: * -> *). MonadIO m => InitiallyUnownedClass -> m ()
clearInitiallyUnownedClassDispatchPropertiesChanged
    attrTransfer :: forall o b.
(AttrBaseTypeConstraint
   InitiallyUnownedClassDispatchPropertiesChangedFieldInfo o,
 AttrTransferTypeConstraint
   InitiallyUnownedClassDispatchPropertiesChangedFieldInfo b) =>
Proxy o
-> b
-> IO
     (AttrTransferType
        InitiallyUnownedClassDispatchPropertiesChangedFieldInfo)
attrTransfer Proxy o
_ b
v = do
        C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback
-> IO
     (FunPtr
        C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback)
GObject.Callbacks.mk_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback (Maybe
  (Ptr
     (FunPtr
        C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback))
-> InitiallyUnownedClassDispatchPropertiesChangedFieldCallback
-> C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback
GObject.Callbacks.wrap_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback Maybe
  (Ptr
     (FunPtr
        C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback))
forall a. Maybe a
Nothing b
InitiallyUnownedClassDispatchPropertiesChangedFieldCallback
v)
    dbgAttrInfo :: Maybe ResolvedSymbolInfo
dbgAttrInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GObject.Structs.InitiallyUnownedClass.dispatchPropertiesChanged"
        , resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-gobject-2.0.32/docs/GI-GObject-Structs-InitiallyUnownedClass.html#g:attr:dispatchPropertiesChanged"
        })

initiallyUnownedClass_dispatchPropertiesChanged :: AttrLabelProxy "dispatchPropertiesChanged"
initiallyUnownedClass_dispatchPropertiesChanged :: AttrLabelProxy "dispatchPropertiesChanged"
initiallyUnownedClass_dispatchPropertiesChanged = AttrLabelProxy "dispatchPropertiesChanged"
forall (a :: Symbol). AttrLabelProxy a
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 = IO (Maybe InitiallyUnownedClassNotifyFieldCallback)
-> m (Maybe InitiallyUnownedClassNotifyFieldCallback)
forall a. IO a -> m a
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 InitiallyUnownedClass
ptr -> do
    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` Int
64) :: IO (FunPtr GObject.Callbacks.C_InitiallyUnownedClassNotifyFieldCallback)
    result <- SP.convertFunPtrIfNonNull 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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return InitiallyUnownedClassNotifyFieldCallback
val''
    return 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 = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ 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 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` Int
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 :: forall (m :: * -> *). MonadIO m => InitiallyUnownedClass -> m ()
clearInitiallyUnownedClassNotify InitiallyUnownedClass
s = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ 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 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` Int
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 :: forall o.
AttrBaseTypeConstraint InitiallyUnownedClassNotifyFieldInfo o =>
o -> IO (AttrGetType InitiallyUnownedClassNotifyFieldInfo)
attrGet = o -> IO (AttrGetType InitiallyUnownedClassNotifyFieldInfo)
InitiallyUnownedClass
-> IO (Maybe InitiallyUnownedClassNotifyFieldCallback)
forall (m :: * -> *).
MonadIO m =>
InitiallyUnownedClass
-> m (Maybe InitiallyUnownedClassNotifyFieldCallback)
getInitiallyUnownedClassNotify
    attrSet :: forall o b.
(AttrBaseTypeConstraint InitiallyUnownedClassNotifyFieldInfo o,
 AttrSetTypeConstraint InitiallyUnownedClassNotifyFieldInfo b) =>
o -> b -> IO ()
attrSet = o -> b -> IO ()
InitiallyUnownedClass
-> FunPtr C_InitiallyUnownedClassNotifyFieldCallback -> IO ()
forall (m :: * -> *).
MonadIO m =>
InitiallyUnownedClass
-> FunPtr C_InitiallyUnownedClassNotifyFieldCallback -> m ()
setInitiallyUnownedClassNotify
    attrConstruct :: forall o b.
(AttrBaseTypeConstraint InitiallyUnownedClassNotifyFieldInfo o,
 AttrSetTypeConstraint InitiallyUnownedClassNotifyFieldInfo b) =>
b -> IO (GValueConstruct o)
attrConstruct = b -> IO (GValueConstruct o)
forall a. HasCallStack => a
undefined
    attrClear :: forall o.
AttrBaseTypeConstraint InitiallyUnownedClassNotifyFieldInfo o =>
o -> IO ()
attrClear = o -> IO ()
InitiallyUnownedClass -> IO ()
forall (m :: * -> *). MonadIO m => InitiallyUnownedClass -> m ()
clearInitiallyUnownedClassNotify
    attrTransfer :: forall o b.
(AttrBaseTypeConstraint InitiallyUnownedClassNotifyFieldInfo o,
 AttrTransferTypeConstraint
   InitiallyUnownedClassNotifyFieldInfo b) =>
Proxy o
-> b -> IO (AttrTransferType InitiallyUnownedClassNotifyFieldInfo)
attrTransfer Proxy o
_ b
v = do
        C_InitiallyUnownedClassNotifyFieldCallback
-> IO (FunPtr C_InitiallyUnownedClassNotifyFieldCallback)
GObject.Callbacks.mk_InitiallyUnownedClassNotifyFieldCallback (Maybe (Ptr (FunPtr C_InitiallyUnownedClassNotifyFieldCallback))
-> InitiallyUnownedClassNotifyFieldCallback
-> C_InitiallyUnownedClassNotifyFieldCallback
GObject.Callbacks.wrap_InitiallyUnownedClassNotifyFieldCallback Maybe (Ptr (FunPtr C_InitiallyUnownedClassNotifyFieldCallback))
forall a. Maybe a
Nothing b
InitiallyUnownedClassNotifyFieldCallback
v)
    dbgAttrInfo :: Maybe ResolvedSymbolInfo
dbgAttrInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GObject.Structs.InitiallyUnownedClass.notify"
        , resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-gobject-2.0.32/docs/GI-GObject-Structs-InitiallyUnownedClass.html#g:attr:notify"
        })

initiallyUnownedClass_notify :: AttrLabelProxy "notify"
initiallyUnownedClass_notify :: AttrLabelProxy "notify"
initiallyUnownedClass_notify = AttrLabelProxy "notify"
forall (a :: Symbol). AttrLabelProxy a
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 = IO (Maybe InitiallyUnownedClassDisposeFieldCallback)
-> m (Maybe InitiallyUnownedClassDisposeFieldCallback)
forall a. IO a -> m a
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 InitiallyUnownedClass
ptr -> do
    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` Int
72) :: IO (FunPtr GObject.Callbacks.C_InitiallyUnownedClassConstructedFieldCallback)
    result <- SP.convertFunPtrIfNonNull 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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return InitiallyUnownedClassDisposeFieldCallback
val''
    return 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 = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ 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 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` Int
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 :: forall (m :: * -> *). MonadIO m => InitiallyUnownedClass -> m ()
clearInitiallyUnownedClassConstructed InitiallyUnownedClass
s = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ 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 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` Int
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 :: forall o.
AttrBaseTypeConstraint
  InitiallyUnownedClassConstructedFieldInfo o =>
o -> IO (AttrGetType InitiallyUnownedClassConstructedFieldInfo)
attrGet = o -> IO (AttrGetType InitiallyUnownedClassConstructedFieldInfo)
InitiallyUnownedClass
-> IO (Maybe InitiallyUnownedClassDisposeFieldCallback)
forall (m :: * -> *).
MonadIO m =>
InitiallyUnownedClass
-> m (Maybe InitiallyUnownedClassDisposeFieldCallback)
getInitiallyUnownedClassConstructed
    attrSet :: forall o b.
(AttrBaseTypeConstraint
   InitiallyUnownedClassConstructedFieldInfo o,
 AttrSetTypeConstraint
   InitiallyUnownedClassConstructedFieldInfo b) =>
o -> b -> IO ()
attrSet = o -> b -> IO ()
InitiallyUnownedClass
-> FunPtr C_InitiallyUnownedClassDisposeFieldCallback -> IO ()
forall (m :: * -> *).
MonadIO m =>
InitiallyUnownedClass
-> FunPtr C_InitiallyUnownedClassDisposeFieldCallback -> m ()
setInitiallyUnownedClassConstructed
    attrConstruct :: forall o b.
(AttrBaseTypeConstraint
   InitiallyUnownedClassConstructedFieldInfo o,
 AttrSetTypeConstraint
   InitiallyUnownedClassConstructedFieldInfo b) =>
b -> IO (GValueConstruct o)
attrConstruct = b -> IO (GValueConstruct o)
forall a. HasCallStack => a
undefined
    attrClear :: forall o.
AttrBaseTypeConstraint
  InitiallyUnownedClassConstructedFieldInfo o =>
o -> IO ()
attrClear = o -> IO ()
InitiallyUnownedClass -> IO ()
forall (m :: * -> *). MonadIO m => InitiallyUnownedClass -> m ()
clearInitiallyUnownedClassConstructed
    attrTransfer :: forall o b.
(AttrBaseTypeConstraint
   InitiallyUnownedClassConstructedFieldInfo o,
 AttrTransferTypeConstraint
   InitiallyUnownedClassConstructedFieldInfo b) =>
Proxy o
-> b
-> IO (AttrTransferType InitiallyUnownedClassConstructedFieldInfo)
attrTransfer Proxy o
_ b
v = do
        C_InitiallyUnownedClassDisposeFieldCallback
-> IO (FunPtr C_InitiallyUnownedClassDisposeFieldCallback)
GObject.Callbacks.mk_InitiallyUnownedClassConstructedFieldCallback (Maybe (Ptr (FunPtr C_InitiallyUnownedClassDisposeFieldCallback))
-> InitiallyUnownedClassDisposeFieldCallback
-> C_InitiallyUnownedClassDisposeFieldCallback
GObject.Callbacks.wrap_InitiallyUnownedClassConstructedFieldCallback Maybe (Ptr (FunPtr C_InitiallyUnownedClassDisposeFieldCallback))
forall a. Maybe a
Nothing b
InitiallyUnownedClassDisposeFieldCallback
v)
    dbgAttrInfo :: Maybe ResolvedSymbolInfo
dbgAttrInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GObject.Structs.InitiallyUnownedClass.constructed"
        , resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-gobject-2.0.32/docs/GI-GObject-Structs-InitiallyUnownedClass.html#g:attr:constructed"
        })

initiallyUnownedClass_constructed :: AttrLabelProxy "constructed"
initiallyUnownedClass_constructed :: AttrLabelProxy "constructed"
initiallyUnownedClass_constructed = AttrLabelProxy "constructed"
forall (a :: Symbol). AttrLabelProxy a
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 :: InitiallyUnownedClass -> p
fromLabel = forall {k} (i :: k) o s. OverloadedMethod i o s => o -> s
forall i o s. OverloadedMethod i o s => o -> s
O.overloadedMethod @info
#else
    fromLabel _ = O.overloadedMethod @info
#endif

#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveInitiallyUnownedClassMethod t InitiallyUnownedClass, O.OverloadedMethod info InitiallyUnownedClass p, R.HasField t InitiallyUnownedClass p) => R.HasField t InitiallyUnownedClass p where
    getField :: InitiallyUnownedClass -> p
getField = forall {k} (i :: k) o s. OverloadedMethod i o s => o -> s
forall i o s. OverloadedMethod i o s => o -> s
O.overloadedMethod @info

#endif

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

#endif