{-# 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 GObject type.
-- 
-- 
-- === /C code/
-- >
-- >// Example of implementing a singleton using a constructor.
-- >static MySingleton *the_singleton = NULL;
-- >
-- >static GObject*
-- >my_singleton_constructor (GType                  type,
-- >                          guint                  n_construct_params,
-- >                          GObjectConstructParam *construct_params)
-- >{
-- >  GObject *object;
-- >  
-- >  if (!the_singleton)
-- >    {
-- >      object = G_OBJECT_CLASS (parent_class)->constructor (type,
-- >                                                           n_construct_params,
-- >                                                           construct_params);
-- >      the_singleton = MY_SINGLETON (object);
-- >    }
-- >  else
-- >    object = g_object_ref (G_OBJECT (the_singleton));
-- >
-- >  return object;
-- >}
-- 

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

module GI.GObject.Structs.ObjectClass
    ( 

-- * Exported types
    ObjectClass(..)                         ,
    newZeroObjectClass                      ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [findProperty]("GI.GObject.Structs.ObjectClass#g:method:findProperty"), [installProperty]("GI.GObject.Structs.ObjectClass#g:method:installProperty"), [overrideProperty]("GI.GObject.Structs.ObjectClass#g:method:overrideProperty").
-- 
-- ==== Getters
-- /None/.
-- 
-- ==== Setters
-- /None/.

#if defined(ENABLE_OVERLOADING)
    ResolveObjectClassMethod                ,
#endif

-- ** findProperty #method:findProperty#

#if defined(ENABLE_OVERLOADING)
    ObjectClassFindPropertyMethodInfo       ,
#endif
    objectClassFindProperty                 ,


-- ** installProperty #method:installProperty#

#if defined(ENABLE_OVERLOADING)
    ObjectClassInstallPropertyMethodInfo    ,
#endif
    objectClassInstallProperty              ,


-- ** overrideProperty #method:overrideProperty#

#if defined(ENABLE_OVERLOADING)
    ObjectClassOverridePropertyMethodInfo   ,
#endif
    objectClassOverrideProperty             ,




 -- * Properties


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

    clearObjectClassConstructed             ,
    getObjectClassConstructed               ,
#if defined(ENABLE_OVERLOADING)
    objectClass_constructed                 ,
#endif
    setObjectClassConstructed               ,


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

    clearObjectClassDispatchPropertiesChanged,
    getObjectClassDispatchPropertiesChanged ,
#if defined(ENABLE_OVERLOADING)
    objectClass_dispatchPropertiesChanged   ,
#endif
    setObjectClassDispatchPropertiesChanged ,


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

    clearObjectClassDispose                 ,
    getObjectClassDispose                   ,
#if defined(ENABLE_OVERLOADING)
    objectClass_dispose                     ,
#endif
    setObjectClassDispose                   ,


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

    clearObjectClassFinalize                ,
    getObjectClassFinalize                  ,
#if defined(ENABLE_OVERLOADING)
    objectClass_finalize                    ,
#endif
    setObjectClassFinalize                  ,


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

    getObjectClassGTypeClass                ,
#if defined(ENABLE_OVERLOADING)
    objectClass_gTypeClass                  ,
#endif


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

    clearObjectClassGetProperty             ,
    getObjectClassGetProperty               ,
#if defined(ENABLE_OVERLOADING)
    objectClass_getProperty                 ,
#endif
    setObjectClassGetProperty               ,


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

    clearObjectClassNotify                  ,
    getObjectClassNotify                    ,
#if defined(ENABLE_OVERLOADING)
    objectClass_notify                      ,
#endif
    setObjectClassNotify                    ,


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

    clearObjectClassSetProperty             ,
    getObjectClassSetProperty               ,
#if defined(ENABLE_OVERLOADING)
    objectClass_setProperty                 ,
#endif
    setObjectClassSetProperty               ,




    ) where

import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.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.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 GHC.Records as R

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

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

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

instance BoxedPtr ObjectClass where
    boxedPtrCopy :: ObjectClass -> IO ObjectClass
boxedPtrCopy = \ObjectClass
p -> ObjectClass
-> (Ptr ObjectClass -> IO ObjectClass) -> IO ObjectClass
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr ObjectClass
p (Int -> Ptr ObjectClass -> IO (Ptr ObjectClass)
forall a. (HasCallStack, CallocPtr a) => Int -> Ptr a -> IO (Ptr a)
copyBytes Int
136 (Ptr ObjectClass -> IO (Ptr ObjectClass))
-> (Ptr ObjectClass -> IO ObjectClass)
-> Ptr ObjectClass
-> IO ObjectClass
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (ManagedPtr ObjectClass -> ObjectClass)
-> Ptr ObjectClass -> IO ObjectClass
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.wrapPtr ManagedPtr ObjectClass -> ObjectClass
ObjectClass)
    boxedPtrFree :: ObjectClass -> IO ()
boxedPtrFree = \ObjectClass
x -> ObjectClass -> (Ptr ObjectClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
SP.withManagedPtr ObjectClass
x Ptr ObjectClass -> IO ()
forall a. Ptr a -> IO ()
SP.freeMem
instance CallocPtr ObjectClass where
    boxedPtrCalloc :: IO (Ptr ObjectClass)
boxedPtrCalloc = Int -> IO (Ptr ObjectClass)
forall a. Int -> IO (Ptr a)
callocBytes Int
136


-- | Construct a `ObjectClass` struct initialized to zero.
newZeroObjectClass :: MonadIO m => m ObjectClass
newZeroObjectClass :: forall (m :: * -> *). MonadIO m => m ObjectClass
newZeroObjectClass = IO ObjectClass -> m ObjectClass
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ObjectClass -> m ObjectClass)
-> IO ObjectClass -> m ObjectClass
forall a b. (a -> b) -> a -> b
$ IO (Ptr ObjectClass)
forall a. CallocPtr a => IO (Ptr a)
boxedPtrCalloc IO (Ptr ObjectClass)
-> (Ptr ObjectClass -> IO ObjectClass) -> IO ObjectClass
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr ObjectClass -> ObjectClass)
-> Ptr ObjectClass -> IO ObjectClass
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr ObjectClass -> ObjectClass
ObjectClass

instance tag ~ 'AttrSet => Constructible ObjectClass tag where
    new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr ObjectClass -> ObjectClass)
-> [AttrOp ObjectClass tag] -> m ObjectClass
new ManagedPtr ObjectClass -> ObjectClass
_ [AttrOp ObjectClass tag]
attrs = do
        ObjectClass
o <- m ObjectClass
forall (m :: * -> *). MonadIO m => m ObjectClass
newZeroObjectClass
        ObjectClass -> [AttrOp ObjectClass 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set ObjectClass
o [AttrOp ObjectClass tag]
[AttrOp ObjectClass 'AttrSet]
attrs
        ObjectClass -> m ObjectClass
forall (m :: * -> *) a. Monad m => a -> m a
return ObjectClass
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' objectClass #gTypeClass
-- @
getObjectClassGTypeClass :: MonadIO m => ObjectClass -> m GObject.TypeClass.TypeClass
getObjectClassGTypeClass :: forall (m :: * -> *). MonadIO m => ObjectClass -> m TypeClass
getObjectClassGTypeClass ObjectClass
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
$ ObjectClass -> (Ptr ObjectClass -> IO TypeClass) -> IO TypeClass
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO TypeClass) -> IO TypeClass)
-> (Ptr ObjectClass -> IO TypeClass) -> IO TypeClass
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
    let val :: Ptr TypeClass
val = Ptr ObjectClass
ptr Ptr ObjectClass -> Int -> Ptr TypeClass
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0 :: (Ptr GObject.TypeClass.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
    TypeClass -> IO TypeClass
forall (m :: * -> *) a. Monad m => a -> m a
return TypeClass
val'

#if defined(ENABLE_OVERLOADING)
data ObjectClassGTypeClassFieldInfo
instance AttrInfo ObjectClassGTypeClassFieldInfo where
    type AttrBaseTypeConstraint ObjectClassGTypeClassFieldInfo = (~) ObjectClass
    type AttrAllowedOps ObjectClassGTypeClassFieldInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint ObjectClassGTypeClassFieldInfo = (~) (Ptr GObject.TypeClass.TypeClass)
    type AttrTransferTypeConstraint ObjectClassGTypeClassFieldInfo = (~)(Ptr GObject.TypeClass.TypeClass)
    type AttrTransferType ObjectClassGTypeClassFieldInfo = (Ptr GObject.TypeClass.TypeClass)
    type AttrGetType ObjectClassGTypeClassFieldInfo = GObject.TypeClass.TypeClass
    type AttrLabel ObjectClassGTypeClassFieldInfo = "g_type_class"
    type AttrOrigin ObjectClassGTypeClassFieldInfo = ObjectClass
    attrGet = getObjectClassGTypeClass
    attrSet = undefined
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer = undefined

objectClass_gTypeClass :: AttrLabelProxy "gTypeClass"
objectClass_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' objectClass #setProperty
-- @
getObjectClassSetProperty :: MonadIO m => ObjectClass -> m (Maybe GObject.Callbacks.ObjectClassSetPropertyFieldCallback)
getObjectClassSetProperty :: forall (m :: * -> *).
MonadIO m =>
ObjectClass -> m (Maybe ObjectClassSetPropertyFieldCallback)
getObjectClassSetProperty ObjectClass
s = IO (Maybe ObjectClassSetPropertyFieldCallback)
-> m (Maybe ObjectClassSetPropertyFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe ObjectClassSetPropertyFieldCallback)
 -> m (Maybe ObjectClassSetPropertyFieldCallback))
-> IO (Maybe ObjectClassSetPropertyFieldCallback)
-> m (Maybe ObjectClassSetPropertyFieldCallback)
forall a b. (a -> b) -> a -> b
$ ObjectClass
-> (Ptr ObjectClass
    -> IO (Maybe ObjectClassSetPropertyFieldCallback))
-> IO (Maybe ObjectClassSetPropertyFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass
  -> IO (Maybe ObjectClassSetPropertyFieldCallback))
 -> IO (Maybe ObjectClassSetPropertyFieldCallback))
-> (Ptr ObjectClass
    -> IO (Maybe ObjectClassSetPropertyFieldCallback))
-> IO (Maybe ObjectClassSetPropertyFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
    FunPtr C_ObjectClassSetPropertyFieldCallback
val <- Ptr (FunPtr C_ObjectClassSetPropertyFieldCallback)
-> IO (FunPtr C_ObjectClassSetPropertyFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr ObjectClass
ptr Ptr ObjectClass
-> Int -> Ptr (FunPtr C_ObjectClassSetPropertyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) :: IO (FunPtr GObject.Callbacks.C_ObjectClassSetPropertyFieldCallback)
    Maybe ObjectClassSetPropertyFieldCallback
result <- FunPtr C_ObjectClassSetPropertyFieldCallback
-> (FunPtr C_ObjectClassSetPropertyFieldCallback
    -> IO ObjectClassSetPropertyFieldCallback)
-> IO (Maybe ObjectClassSetPropertyFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_ObjectClassSetPropertyFieldCallback
val ((FunPtr C_ObjectClassSetPropertyFieldCallback
  -> IO ObjectClassSetPropertyFieldCallback)
 -> IO (Maybe ObjectClassSetPropertyFieldCallback))
-> (FunPtr C_ObjectClassSetPropertyFieldCallback
    -> IO ObjectClassSetPropertyFieldCallback)
-> IO (Maybe ObjectClassSetPropertyFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_ObjectClassSetPropertyFieldCallback
val' -> do
        let val'' :: ObjectClassSetPropertyFieldCallback
val'' = FunPtr C_ObjectClassSetPropertyFieldCallback
-> ObjectClassSetPropertyFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
FunPtr C_ObjectClassSetPropertyFieldCallback
-> a -> Word32 -> GValue -> GParamSpec -> m ()
GObject.Callbacks.dynamic_ObjectClassSetPropertyFieldCallback FunPtr C_ObjectClassSetPropertyFieldCallback
val'
        ObjectClassSetPropertyFieldCallback
-> IO ObjectClassSetPropertyFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return ObjectClassSetPropertyFieldCallback
val''
    Maybe ObjectClassSetPropertyFieldCallback
-> IO (Maybe ObjectClassSetPropertyFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ObjectClassSetPropertyFieldCallback
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' objectClass [ #setProperty 'Data.GI.Base.Attributes.:=' value ]
-- @
setObjectClassSetProperty :: MonadIO m => ObjectClass -> FunPtr GObject.Callbacks.C_ObjectClassSetPropertyFieldCallback -> m ()
setObjectClassSetProperty :: forall (m :: * -> *).
MonadIO m =>
ObjectClass -> FunPtr C_ObjectClassSetPropertyFieldCallback -> m ()
setObjectClassSetProperty ObjectClass
s FunPtr C_ObjectClassSetPropertyFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ObjectClass -> (Ptr ObjectClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO ()) -> IO ())
-> (Ptr ObjectClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
    Ptr (FunPtr C_ObjectClassSetPropertyFieldCallback)
-> FunPtr C_ObjectClassSetPropertyFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr Ptr ObjectClass
-> Int -> Ptr (FunPtr C_ObjectClassSetPropertyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) (FunPtr C_ObjectClassSetPropertyFieldCallback
val :: FunPtr GObject.Callbacks.C_ObjectClassSetPropertyFieldCallback)

-- | 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
-- @
clearObjectClassSetProperty :: MonadIO m => ObjectClass -> m ()
clearObjectClassSetProperty :: forall (m :: * -> *). MonadIO m => ObjectClass -> m ()
clearObjectClassSetProperty ObjectClass
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ObjectClass -> (Ptr ObjectClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO ()) -> IO ())
-> (Ptr ObjectClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
    Ptr (FunPtr C_ObjectClassSetPropertyFieldCallback)
-> FunPtr C_ObjectClassSetPropertyFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr Ptr ObjectClass
-> Int -> Ptr (FunPtr C_ObjectClassSetPropertyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) (FunPtr C_ObjectClassSetPropertyFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr GObject.Callbacks.C_ObjectClassSetPropertyFieldCallback)

#if defined(ENABLE_OVERLOADING)
data ObjectClassSetPropertyFieldInfo
instance AttrInfo ObjectClassSetPropertyFieldInfo where
    type AttrBaseTypeConstraint ObjectClassSetPropertyFieldInfo = (~) ObjectClass
    type AttrAllowedOps ObjectClassSetPropertyFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ObjectClassSetPropertyFieldInfo = (~) (FunPtr GObject.Callbacks.C_ObjectClassSetPropertyFieldCallback)
    type AttrTransferTypeConstraint ObjectClassSetPropertyFieldInfo = (~)GObject.Callbacks.ObjectClassSetPropertyFieldCallback
    type AttrTransferType ObjectClassSetPropertyFieldInfo = (FunPtr GObject.Callbacks.C_ObjectClassSetPropertyFieldCallback)
    type AttrGetType ObjectClassSetPropertyFieldInfo = Maybe GObject.Callbacks.ObjectClassSetPropertyFieldCallback
    type AttrLabel ObjectClassSetPropertyFieldInfo = "set_property"
    type AttrOrigin ObjectClassSetPropertyFieldInfo = ObjectClass
    attrGet = getObjectClassSetProperty
    attrSet = setObjectClassSetProperty
    attrConstruct = undefined
    attrClear = clearObjectClassSetProperty
    attrTransfer _ v = do
        GObject.Callbacks.mk_ObjectClassSetPropertyFieldCallback (GObject.Callbacks.wrap_ObjectClassSetPropertyFieldCallback Nothing v)

objectClass_setProperty :: AttrLabelProxy "setProperty"
objectClass_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' objectClass #getProperty
-- @
getObjectClassGetProperty :: MonadIO m => ObjectClass -> m (Maybe GObject.Callbacks.ObjectClassGetPropertyFieldCallback)
getObjectClassGetProperty :: forall (m :: * -> *).
MonadIO m =>
ObjectClass -> m (Maybe ObjectClassSetPropertyFieldCallback)
getObjectClassGetProperty ObjectClass
s = IO (Maybe ObjectClassSetPropertyFieldCallback)
-> m (Maybe ObjectClassSetPropertyFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe ObjectClassSetPropertyFieldCallback)
 -> m (Maybe ObjectClassSetPropertyFieldCallback))
-> IO (Maybe ObjectClassSetPropertyFieldCallback)
-> m (Maybe ObjectClassSetPropertyFieldCallback)
forall a b. (a -> b) -> a -> b
$ ObjectClass
-> (Ptr ObjectClass
    -> IO (Maybe ObjectClassSetPropertyFieldCallback))
-> IO (Maybe ObjectClassSetPropertyFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass
  -> IO (Maybe ObjectClassSetPropertyFieldCallback))
 -> IO (Maybe ObjectClassSetPropertyFieldCallback))
-> (Ptr ObjectClass
    -> IO (Maybe ObjectClassSetPropertyFieldCallback))
-> IO (Maybe ObjectClassSetPropertyFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
    FunPtr C_ObjectClassSetPropertyFieldCallback
val <- Ptr (FunPtr C_ObjectClassSetPropertyFieldCallback)
-> IO (FunPtr C_ObjectClassSetPropertyFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr ObjectClass
ptr Ptr ObjectClass
-> Int -> Ptr (FunPtr C_ObjectClassSetPropertyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) :: IO (FunPtr GObject.Callbacks.C_ObjectClassGetPropertyFieldCallback)
    Maybe ObjectClassSetPropertyFieldCallback
result <- FunPtr C_ObjectClassSetPropertyFieldCallback
-> (FunPtr C_ObjectClassSetPropertyFieldCallback
    -> IO ObjectClassSetPropertyFieldCallback)
-> IO (Maybe ObjectClassSetPropertyFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_ObjectClassSetPropertyFieldCallback
val ((FunPtr C_ObjectClassSetPropertyFieldCallback
  -> IO ObjectClassSetPropertyFieldCallback)
 -> IO (Maybe ObjectClassSetPropertyFieldCallback))
-> (FunPtr C_ObjectClassSetPropertyFieldCallback
    -> IO ObjectClassSetPropertyFieldCallback)
-> IO (Maybe ObjectClassSetPropertyFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_ObjectClassSetPropertyFieldCallback
val' -> do
        let val'' :: ObjectClassSetPropertyFieldCallback
val'' = FunPtr C_ObjectClassSetPropertyFieldCallback
-> ObjectClassSetPropertyFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
FunPtr C_ObjectClassSetPropertyFieldCallback
-> a -> Word32 -> GValue -> GParamSpec -> m ()
GObject.Callbacks.dynamic_ObjectClassGetPropertyFieldCallback FunPtr C_ObjectClassSetPropertyFieldCallback
val'
        ObjectClassSetPropertyFieldCallback
-> IO ObjectClassSetPropertyFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return ObjectClassSetPropertyFieldCallback
val''
    Maybe ObjectClassSetPropertyFieldCallback
-> IO (Maybe ObjectClassSetPropertyFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ObjectClassSetPropertyFieldCallback
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' objectClass [ #getProperty 'Data.GI.Base.Attributes.:=' value ]
-- @
setObjectClassGetProperty :: MonadIO m => ObjectClass -> FunPtr GObject.Callbacks.C_ObjectClassGetPropertyFieldCallback -> m ()
setObjectClassGetProperty :: forall (m :: * -> *).
MonadIO m =>
ObjectClass -> FunPtr C_ObjectClassSetPropertyFieldCallback -> m ()
setObjectClassGetProperty ObjectClass
s FunPtr C_ObjectClassSetPropertyFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ObjectClass -> (Ptr ObjectClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO ()) -> IO ())
-> (Ptr ObjectClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
    Ptr (FunPtr C_ObjectClassSetPropertyFieldCallback)
-> FunPtr C_ObjectClassSetPropertyFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr Ptr ObjectClass
-> Int -> Ptr (FunPtr C_ObjectClassSetPropertyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) (FunPtr C_ObjectClassSetPropertyFieldCallback
val :: FunPtr GObject.Callbacks.C_ObjectClassGetPropertyFieldCallback)

-- | 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
-- @
clearObjectClassGetProperty :: MonadIO m => ObjectClass -> m ()
clearObjectClassGetProperty :: forall (m :: * -> *). MonadIO m => ObjectClass -> m ()
clearObjectClassGetProperty ObjectClass
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ObjectClass -> (Ptr ObjectClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO ()) -> IO ())
-> (Ptr ObjectClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
    Ptr (FunPtr C_ObjectClassSetPropertyFieldCallback)
-> FunPtr C_ObjectClassSetPropertyFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr Ptr ObjectClass
-> Int -> Ptr (FunPtr C_ObjectClassSetPropertyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) (FunPtr C_ObjectClassSetPropertyFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr GObject.Callbacks.C_ObjectClassGetPropertyFieldCallback)

#if defined(ENABLE_OVERLOADING)
data ObjectClassGetPropertyFieldInfo
instance AttrInfo ObjectClassGetPropertyFieldInfo where
    type AttrBaseTypeConstraint ObjectClassGetPropertyFieldInfo = (~) ObjectClass
    type AttrAllowedOps ObjectClassGetPropertyFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ObjectClassGetPropertyFieldInfo = (~) (FunPtr GObject.Callbacks.C_ObjectClassGetPropertyFieldCallback)
    type AttrTransferTypeConstraint ObjectClassGetPropertyFieldInfo = (~)GObject.Callbacks.ObjectClassGetPropertyFieldCallback
    type AttrTransferType ObjectClassGetPropertyFieldInfo = (FunPtr GObject.Callbacks.C_ObjectClassGetPropertyFieldCallback)
    type AttrGetType ObjectClassGetPropertyFieldInfo = Maybe GObject.Callbacks.ObjectClassGetPropertyFieldCallback
    type AttrLabel ObjectClassGetPropertyFieldInfo = "get_property"
    type AttrOrigin ObjectClassGetPropertyFieldInfo = ObjectClass
    attrGet = getObjectClassGetProperty
    attrSet = setObjectClassGetProperty
    attrConstruct = undefined
    attrClear = clearObjectClassGetProperty
    attrTransfer _ v = do
        GObject.Callbacks.mk_ObjectClassGetPropertyFieldCallback (GObject.Callbacks.wrap_ObjectClassGetPropertyFieldCallback Nothing v)

objectClass_getProperty :: AttrLabelProxy "getProperty"
objectClass_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' objectClass #dispose
-- @
getObjectClassDispose :: MonadIO m => ObjectClass -> m (Maybe GObject.Callbacks.ObjectClassDisposeFieldCallback)
getObjectClassDispose :: forall (m :: * -> *).
MonadIO m =>
ObjectClass -> m (Maybe ObjectClassDisposeFieldCallback)
getObjectClassDispose ObjectClass
s = IO (Maybe ObjectClassDisposeFieldCallback)
-> m (Maybe ObjectClassDisposeFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe ObjectClassDisposeFieldCallback)
 -> m (Maybe ObjectClassDisposeFieldCallback))
-> IO (Maybe ObjectClassDisposeFieldCallback)
-> m (Maybe ObjectClassDisposeFieldCallback)
forall a b. (a -> b) -> a -> b
$ ObjectClass
-> (Ptr ObjectClass -> IO (Maybe ObjectClassDisposeFieldCallback))
-> IO (Maybe ObjectClassDisposeFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO (Maybe ObjectClassDisposeFieldCallback))
 -> IO (Maybe ObjectClassDisposeFieldCallback))
-> (Ptr ObjectClass -> IO (Maybe ObjectClassDisposeFieldCallback))
-> IO (Maybe ObjectClassDisposeFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
    FunPtr C_ObjectClassDisposeFieldCallback
val <- Ptr (FunPtr C_ObjectClassDisposeFieldCallback)
-> IO (FunPtr C_ObjectClassDisposeFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr ObjectClass
ptr Ptr ObjectClass
-> Int -> Ptr (FunPtr C_ObjectClassDisposeFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
40) :: IO (FunPtr GObject.Callbacks.C_ObjectClassDisposeFieldCallback)
    Maybe ObjectClassDisposeFieldCallback
result <- FunPtr C_ObjectClassDisposeFieldCallback
-> (FunPtr C_ObjectClassDisposeFieldCallback
    -> IO ObjectClassDisposeFieldCallback)
-> IO (Maybe ObjectClassDisposeFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_ObjectClassDisposeFieldCallback
val ((FunPtr C_ObjectClassDisposeFieldCallback
  -> IO ObjectClassDisposeFieldCallback)
 -> IO (Maybe ObjectClassDisposeFieldCallback))
-> (FunPtr C_ObjectClassDisposeFieldCallback
    -> IO ObjectClassDisposeFieldCallback)
-> IO (Maybe ObjectClassDisposeFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_ObjectClassDisposeFieldCallback
val' -> do
        let val'' :: ObjectClassDisposeFieldCallback
val'' = FunPtr C_ObjectClassDisposeFieldCallback
-> ObjectClassDisposeFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
FunPtr C_ObjectClassDisposeFieldCallback -> a -> m ()
GObject.Callbacks.dynamic_ObjectClassDisposeFieldCallback FunPtr C_ObjectClassDisposeFieldCallback
val'
        ObjectClassDisposeFieldCallback
-> IO ObjectClassDisposeFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return ObjectClassDisposeFieldCallback
val''
    Maybe ObjectClassDisposeFieldCallback
-> IO (Maybe ObjectClassDisposeFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ObjectClassDisposeFieldCallback
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' objectClass [ #dispose 'Data.GI.Base.Attributes.:=' value ]
-- @
setObjectClassDispose :: MonadIO m => ObjectClass -> FunPtr GObject.Callbacks.C_ObjectClassDisposeFieldCallback -> m ()
setObjectClassDispose :: forall (m :: * -> *).
MonadIO m =>
ObjectClass -> FunPtr C_ObjectClassDisposeFieldCallback -> m ()
setObjectClassDispose ObjectClass
s FunPtr C_ObjectClassDisposeFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ObjectClass -> (Ptr ObjectClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO ()) -> IO ())
-> (Ptr ObjectClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
    Ptr (FunPtr C_ObjectClassDisposeFieldCallback)
-> FunPtr C_ObjectClassDisposeFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr Ptr ObjectClass
-> Int -> Ptr (FunPtr C_ObjectClassDisposeFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
40) (FunPtr C_ObjectClassDisposeFieldCallback
val :: FunPtr GObject.Callbacks.C_ObjectClassDisposeFieldCallback)

-- | 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
-- @
clearObjectClassDispose :: MonadIO m => ObjectClass -> m ()
clearObjectClassDispose :: forall (m :: * -> *). MonadIO m => ObjectClass -> m ()
clearObjectClassDispose ObjectClass
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ObjectClass -> (Ptr ObjectClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO ()) -> IO ())
-> (Ptr ObjectClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
    Ptr (FunPtr C_ObjectClassDisposeFieldCallback)
-> FunPtr C_ObjectClassDisposeFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr Ptr ObjectClass
-> Int -> Ptr (FunPtr C_ObjectClassDisposeFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
40) (FunPtr C_ObjectClassDisposeFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr GObject.Callbacks.C_ObjectClassDisposeFieldCallback)

#if defined(ENABLE_OVERLOADING)
data ObjectClassDisposeFieldInfo
instance AttrInfo ObjectClassDisposeFieldInfo where
    type AttrBaseTypeConstraint ObjectClassDisposeFieldInfo = (~) ObjectClass
    type AttrAllowedOps ObjectClassDisposeFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ObjectClassDisposeFieldInfo = (~) (FunPtr GObject.Callbacks.C_ObjectClassDisposeFieldCallback)
    type AttrTransferTypeConstraint ObjectClassDisposeFieldInfo = (~)GObject.Callbacks.ObjectClassDisposeFieldCallback
    type AttrTransferType ObjectClassDisposeFieldInfo = (FunPtr GObject.Callbacks.C_ObjectClassDisposeFieldCallback)
    type AttrGetType ObjectClassDisposeFieldInfo = Maybe GObject.Callbacks.ObjectClassDisposeFieldCallback
    type AttrLabel ObjectClassDisposeFieldInfo = "dispose"
    type AttrOrigin ObjectClassDisposeFieldInfo = ObjectClass
    attrGet = getObjectClassDispose
    attrSet = setObjectClassDispose
    attrConstruct = undefined
    attrClear = clearObjectClassDispose
    attrTransfer _ v = do
        GObject.Callbacks.mk_ObjectClassDisposeFieldCallback (GObject.Callbacks.wrap_ObjectClassDisposeFieldCallback Nothing v)

objectClass_dispose :: AttrLabelProxy "dispose"
objectClass_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' objectClass #finalize
-- @
getObjectClassFinalize :: MonadIO m => ObjectClass -> m (Maybe GObject.Callbacks.ObjectClassFinalizeFieldCallback)
getObjectClassFinalize :: forall (m :: * -> *).
MonadIO m =>
ObjectClass -> m (Maybe ObjectClassDisposeFieldCallback)
getObjectClassFinalize ObjectClass
s = IO (Maybe ObjectClassDisposeFieldCallback)
-> m (Maybe ObjectClassDisposeFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe ObjectClassDisposeFieldCallback)
 -> m (Maybe ObjectClassDisposeFieldCallback))
-> IO (Maybe ObjectClassDisposeFieldCallback)
-> m (Maybe ObjectClassDisposeFieldCallback)
forall a b. (a -> b) -> a -> b
$ ObjectClass
-> (Ptr ObjectClass -> IO (Maybe ObjectClassDisposeFieldCallback))
-> IO (Maybe ObjectClassDisposeFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO (Maybe ObjectClassDisposeFieldCallback))
 -> IO (Maybe ObjectClassDisposeFieldCallback))
-> (Ptr ObjectClass -> IO (Maybe ObjectClassDisposeFieldCallback))
-> IO (Maybe ObjectClassDisposeFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
    FunPtr C_ObjectClassDisposeFieldCallback
val <- Ptr (FunPtr C_ObjectClassDisposeFieldCallback)
-> IO (FunPtr C_ObjectClassDisposeFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr ObjectClass
ptr Ptr ObjectClass
-> Int -> Ptr (FunPtr C_ObjectClassDisposeFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
48) :: IO (FunPtr GObject.Callbacks.C_ObjectClassFinalizeFieldCallback)
    Maybe ObjectClassDisposeFieldCallback
result <- FunPtr C_ObjectClassDisposeFieldCallback
-> (FunPtr C_ObjectClassDisposeFieldCallback
    -> IO ObjectClassDisposeFieldCallback)
-> IO (Maybe ObjectClassDisposeFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_ObjectClassDisposeFieldCallback
val ((FunPtr C_ObjectClassDisposeFieldCallback
  -> IO ObjectClassDisposeFieldCallback)
 -> IO (Maybe ObjectClassDisposeFieldCallback))
-> (FunPtr C_ObjectClassDisposeFieldCallback
    -> IO ObjectClassDisposeFieldCallback)
-> IO (Maybe ObjectClassDisposeFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_ObjectClassDisposeFieldCallback
val' -> do
        let val'' :: ObjectClassDisposeFieldCallback
val'' = FunPtr C_ObjectClassDisposeFieldCallback
-> ObjectClassDisposeFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
FunPtr C_ObjectClassDisposeFieldCallback -> a -> m ()
GObject.Callbacks.dynamic_ObjectClassFinalizeFieldCallback FunPtr C_ObjectClassDisposeFieldCallback
val'
        ObjectClassDisposeFieldCallback
-> IO ObjectClassDisposeFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return ObjectClassDisposeFieldCallback
val''
    Maybe ObjectClassDisposeFieldCallback
-> IO (Maybe ObjectClassDisposeFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ObjectClassDisposeFieldCallback
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' objectClass [ #finalize 'Data.GI.Base.Attributes.:=' value ]
-- @
setObjectClassFinalize :: MonadIO m => ObjectClass -> FunPtr GObject.Callbacks.C_ObjectClassFinalizeFieldCallback -> m ()
setObjectClassFinalize :: forall (m :: * -> *).
MonadIO m =>
ObjectClass -> FunPtr C_ObjectClassDisposeFieldCallback -> m ()
setObjectClassFinalize ObjectClass
s FunPtr C_ObjectClassDisposeFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ObjectClass -> (Ptr ObjectClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO ()) -> IO ())
-> (Ptr ObjectClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
    Ptr (FunPtr C_ObjectClassDisposeFieldCallback)
-> FunPtr C_ObjectClassDisposeFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr Ptr ObjectClass
-> Int -> Ptr (FunPtr C_ObjectClassDisposeFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
48) (FunPtr C_ObjectClassDisposeFieldCallback
val :: FunPtr GObject.Callbacks.C_ObjectClassFinalizeFieldCallback)

-- | 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
-- @
clearObjectClassFinalize :: MonadIO m => ObjectClass -> m ()
clearObjectClassFinalize :: forall (m :: * -> *). MonadIO m => ObjectClass -> m ()
clearObjectClassFinalize ObjectClass
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ObjectClass -> (Ptr ObjectClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO ()) -> IO ())
-> (Ptr ObjectClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
    Ptr (FunPtr C_ObjectClassDisposeFieldCallback)
-> FunPtr C_ObjectClassDisposeFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr Ptr ObjectClass
-> Int -> Ptr (FunPtr C_ObjectClassDisposeFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
48) (FunPtr C_ObjectClassDisposeFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr GObject.Callbacks.C_ObjectClassFinalizeFieldCallback)

#if defined(ENABLE_OVERLOADING)
data ObjectClassFinalizeFieldInfo
instance AttrInfo ObjectClassFinalizeFieldInfo where
    type AttrBaseTypeConstraint ObjectClassFinalizeFieldInfo = (~) ObjectClass
    type AttrAllowedOps ObjectClassFinalizeFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ObjectClassFinalizeFieldInfo = (~) (FunPtr GObject.Callbacks.C_ObjectClassFinalizeFieldCallback)
    type AttrTransferTypeConstraint ObjectClassFinalizeFieldInfo = (~)GObject.Callbacks.ObjectClassFinalizeFieldCallback
    type AttrTransferType ObjectClassFinalizeFieldInfo = (FunPtr GObject.Callbacks.C_ObjectClassFinalizeFieldCallback)
    type AttrGetType ObjectClassFinalizeFieldInfo = Maybe GObject.Callbacks.ObjectClassFinalizeFieldCallback
    type AttrLabel ObjectClassFinalizeFieldInfo = "finalize"
    type AttrOrigin ObjectClassFinalizeFieldInfo = ObjectClass
    attrGet = getObjectClassFinalize
    attrSet = setObjectClassFinalize
    attrConstruct = undefined
    attrClear = clearObjectClassFinalize
    attrTransfer _ v = do
        GObject.Callbacks.mk_ObjectClassFinalizeFieldCallback (GObject.Callbacks.wrap_ObjectClassFinalizeFieldCallback Nothing v)

objectClass_finalize :: AttrLabelProxy "finalize"
objectClass_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' objectClass #dispatchPropertiesChanged
-- @
getObjectClassDispatchPropertiesChanged :: MonadIO m => ObjectClass -> m (Maybe GObject.Callbacks.ObjectClassDispatchPropertiesChangedFieldCallback)
getObjectClassDispatchPropertiesChanged :: forall (m :: * -> *).
MonadIO m =>
ObjectClass
-> m (Maybe ObjectClassDispatchPropertiesChangedFieldCallback)
getObjectClassDispatchPropertiesChanged ObjectClass
s = IO (Maybe ObjectClassDispatchPropertiesChangedFieldCallback)
-> m (Maybe ObjectClassDispatchPropertiesChangedFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe ObjectClassDispatchPropertiesChangedFieldCallback)
 -> m (Maybe ObjectClassDispatchPropertiesChangedFieldCallback))
-> IO (Maybe ObjectClassDispatchPropertiesChangedFieldCallback)
-> m (Maybe ObjectClassDispatchPropertiesChangedFieldCallback)
forall a b. (a -> b) -> a -> b
$ ObjectClass
-> (Ptr ObjectClass
    -> IO (Maybe ObjectClassDispatchPropertiesChangedFieldCallback))
-> IO (Maybe ObjectClassDispatchPropertiesChangedFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass
  -> IO (Maybe ObjectClassDispatchPropertiesChangedFieldCallback))
 -> IO (Maybe ObjectClassDispatchPropertiesChangedFieldCallback))
-> (Ptr ObjectClass
    -> IO (Maybe ObjectClassDispatchPropertiesChangedFieldCallback))
-> IO (Maybe ObjectClassDispatchPropertiesChangedFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
    FunPtr C_ObjectClassDispatchPropertiesChangedFieldCallback
val <- Ptr (FunPtr C_ObjectClassDispatchPropertiesChangedFieldCallback)
-> IO (FunPtr C_ObjectClassDispatchPropertiesChangedFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr ObjectClass
ptr Ptr ObjectClass
-> Int
-> Ptr (FunPtr C_ObjectClassDispatchPropertiesChangedFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
56) :: IO (FunPtr GObject.Callbacks.C_ObjectClassDispatchPropertiesChangedFieldCallback)
    Maybe ObjectClassDispatchPropertiesChangedFieldCallback
result <- FunPtr C_ObjectClassDispatchPropertiesChangedFieldCallback
-> (FunPtr C_ObjectClassDispatchPropertiesChangedFieldCallback
    -> IO ObjectClassDispatchPropertiesChangedFieldCallback)
-> IO (Maybe ObjectClassDispatchPropertiesChangedFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_ObjectClassDispatchPropertiesChangedFieldCallback
val ((FunPtr C_ObjectClassDispatchPropertiesChangedFieldCallback
  -> IO ObjectClassDispatchPropertiesChangedFieldCallback)
 -> IO (Maybe ObjectClassDispatchPropertiesChangedFieldCallback))
-> (FunPtr C_ObjectClassDispatchPropertiesChangedFieldCallback
    -> IO ObjectClassDispatchPropertiesChangedFieldCallback)
-> IO (Maybe ObjectClassDispatchPropertiesChangedFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_ObjectClassDispatchPropertiesChangedFieldCallback
val' -> do
        let val'' :: ObjectClassDispatchPropertiesChangedFieldCallback
val'' = FunPtr C_ObjectClassDispatchPropertiesChangedFieldCallback
-> ObjectClassDispatchPropertiesChangedFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
FunPtr C_ObjectClassDispatchPropertiesChangedFieldCallback
-> a -> Word32 -> GParamSpec -> m ()
GObject.Callbacks.dynamic_ObjectClassDispatchPropertiesChangedFieldCallback FunPtr C_ObjectClassDispatchPropertiesChangedFieldCallback
val'
        ObjectClassDispatchPropertiesChangedFieldCallback
-> IO ObjectClassDispatchPropertiesChangedFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return ObjectClassDispatchPropertiesChangedFieldCallback
val''
    Maybe ObjectClassDispatchPropertiesChangedFieldCallback
-> IO (Maybe ObjectClassDispatchPropertiesChangedFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ObjectClassDispatchPropertiesChangedFieldCallback
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' objectClass [ #dispatchPropertiesChanged 'Data.GI.Base.Attributes.:=' value ]
-- @
setObjectClassDispatchPropertiesChanged :: MonadIO m => ObjectClass -> FunPtr GObject.Callbacks.C_ObjectClassDispatchPropertiesChangedFieldCallback -> m ()
setObjectClassDispatchPropertiesChanged :: forall (m :: * -> *).
MonadIO m =>
ObjectClass
-> FunPtr C_ObjectClassDispatchPropertiesChangedFieldCallback
-> m ()
setObjectClassDispatchPropertiesChanged ObjectClass
s FunPtr C_ObjectClassDispatchPropertiesChangedFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ObjectClass -> (Ptr ObjectClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO ()) -> IO ())
-> (Ptr ObjectClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
    Ptr (FunPtr C_ObjectClassDispatchPropertiesChangedFieldCallback)
-> FunPtr C_ObjectClassDispatchPropertiesChangedFieldCallback
-> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr Ptr ObjectClass
-> Int
-> Ptr (FunPtr C_ObjectClassDispatchPropertiesChangedFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
56) (FunPtr C_ObjectClassDispatchPropertiesChangedFieldCallback
val :: FunPtr GObject.Callbacks.C_ObjectClassDispatchPropertiesChangedFieldCallback)

-- | 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
-- @
clearObjectClassDispatchPropertiesChanged :: MonadIO m => ObjectClass -> m ()
clearObjectClassDispatchPropertiesChanged :: forall (m :: * -> *). MonadIO m => ObjectClass -> m ()
clearObjectClassDispatchPropertiesChanged ObjectClass
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ObjectClass -> (Ptr ObjectClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO ()) -> IO ())
-> (Ptr ObjectClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
    Ptr (FunPtr C_ObjectClassDispatchPropertiesChangedFieldCallback)
-> FunPtr C_ObjectClassDispatchPropertiesChangedFieldCallback
-> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr Ptr ObjectClass
-> Int
-> Ptr (FunPtr C_ObjectClassDispatchPropertiesChangedFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
56) (FunPtr C_ObjectClassDispatchPropertiesChangedFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr GObject.Callbacks.C_ObjectClassDispatchPropertiesChangedFieldCallback)

#if defined(ENABLE_OVERLOADING)
data ObjectClassDispatchPropertiesChangedFieldInfo
instance AttrInfo ObjectClassDispatchPropertiesChangedFieldInfo where
    type AttrBaseTypeConstraint ObjectClassDispatchPropertiesChangedFieldInfo = (~) ObjectClass
    type AttrAllowedOps ObjectClassDispatchPropertiesChangedFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ObjectClassDispatchPropertiesChangedFieldInfo = (~) (FunPtr GObject.Callbacks.C_ObjectClassDispatchPropertiesChangedFieldCallback)
    type AttrTransferTypeConstraint ObjectClassDispatchPropertiesChangedFieldInfo = (~)GObject.Callbacks.ObjectClassDispatchPropertiesChangedFieldCallback
    type AttrTransferType ObjectClassDispatchPropertiesChangedFieldInfo = (FunPtr GObject.Callbacks.C_ObjectClassDispatchPropertiesChangedFieldCallback)
    type AttrGetType ObjectClassDispatchPropertiesChangedFieldInfo = Maybe GObject.Callbacks.ObjectClassDispatchPropertiesChangedFieldCallback
    type AttrLabel ObjectClassDispatchPropertiesChangedFieldInfo = "dispatch_properties_changed"
    type AttrOrigin ObjectClassDispatchPropertiesChangedFieldInfo = ObjectClass
    attrGet = getObjectClassDispatchPropertiesChanged
    attrSet = setObjectClassDispatchPropertiesChanged
    attrConstruct = undefined
    attrClear = clearObjectClassDispatchPropertiesChanged
    attrTransfer _ v = do
        GObject.Callbacks.mk_ObjectClassDispatchPropertiesChangedFieldCallback (GObject.Callbacks.wrap_ObjectClassDispatchPropertiesChangedFieldCallback Nothing v)

objectClass_dispatchPropertiesChanged :: AttrLabelProxy "dispatchPropertiesChanged"
objectClass_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' objectClass #notify
-- @
getObjectClassNotify :: MonadIO m => ObjectClass -> m (Maybe GObject.Callbacks.ObjectClassNotifyFieldCallback)
getObjectClassNotify :: forall (m :: * -> *).
MonadIO m =>
ObjectClass -> m (Maybe ObjectClassNotifyFieldCallback)
getObjectClassNotify ObjectClass
s = IO (Maybe ObjectClassNotifyFieldCallback)
-> m (Maybe ObjectClassNotifyFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe ObjectClassNotifyFieldCallback)
 -> m (Maybe ObjectClassNotifyFieldCallback))
-> IO (Maybe ObjectClassNotifyFieldCallback)
-> m (Maybe ObjectClassNotifyFieldCallback)
forall a b. (a -> b) -> a -> b
$ ObjectClass
-> (Ptr ObjectClass -> IO (Maybe ObjectClassNotifyFieldCallback))
-> IO (Maybe ObjectClassNotifyFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO (Maybe ObjectClassNotifyFieldCallback))
 -> IO (Maybe ObjectClassNotifyFieldCallback))
-> (Ptr ObjectClass -> IO (Maybe ObjectClassNotifyFieldCallback))
-> IO (Maybe ObjectClassNotifyFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
    FunPtr C_ObjectClassNotifyFieldCallback
val <- Ptr (FunPtr C_ObjectClassNotifyFieldCallback)
-> IO (FunPtr C_ObjectClassNotifyFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr ObjectClass
ptr Ptr ObjectClass
-> Int -> Ptr (FunPtr C_ObjectClassNotifyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
64) :: IO (FunPtr GObject.Callbacks.C_ObjectClassNotifyFieldCallback)
    Maybe ObjectClassNotifyFieldCallback
result <- FunPtr C_ObjectClassNotifyFieldCallback
-> (FunPtr C_ObjectClassNotifyFieldCallback
    -> IO ObjectClassNotifyFieldCallback)
-> IO (Maybe ObjectClassNotifyFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_ObjectClassNotifyFieldCallback
val ((FunPtr C_ObjectClassNotifyFieldCallback
  -> IO ObjectClassNotifyFieldCallback)
 -> IO (Maybe ObjectClassNotifyFieldCallback))
-> (FunPtr C_ObjectClassNotifyFieldCallback
    -> IO ObjectClassNotifyFieldCallback)
-> IO (Maybe ObjectClassNotifyFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_ObjectClassNotifyFieldCallback
val' -> do
        let val'' :: ObjectClassNotifyFieldCallback
val'' = FunPtr C_ObjectClassNotifyFieldCallback
-> ObjectClassNotifyFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
FunPtr C_ObjectClassNotifyFieldCallback -> a -> GParamSpec -> m ()
GObject.Callbacks.dynamic_ObjectClassNotifyFieldCallback FunPtr C_ObjectClassNotifyFieldCallback
val'
        ObjectClassNotifyFieldCallback -> IO ObjectClassNotifyFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return ObjectClassNotifyFieldCallback
val''
    Maybe ObjectClassNotifyFieldCallback
-> IO (Maybe ObjectClassNotifyFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ObjectClassNotifyFieldCallback
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' objectClass [ #notify 'Data.GI.Base.Attributes.:=' value ]
-- @
setObjectClassNotify :: MonadIO m => ObjectClass -> FunPtr GObject.Callbacks.C_ObjectClassNotifyFieldCallback -> m ()
setObjectClassNotify :: forall (m :: * -> *).
MonadIO m =>
ObjectClass -> FunPtr C_ObjectClassNotifyFieldCallback -> m ()
setObjectClassNotify ObjectClass
s FunPtr C_ObjectClassNotifyFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ObjectClass -> (Ptr ObjectClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO ()) -> IO ())
-> (Ptr ObjectClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
    Ptr (FunPtr C_ObjectClassNotifyFieldCallback)
-> FunPtr C_ObjectClassNotifyFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr Ptr ObjectClass
-> Int -> Ptr (FunPtr C_ObjectClassNotifyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
64) (FunPtr C_ObjectClassNotifyFieldCallback
val :: FunPtr GObject.Callbacks.C_ObjectClassNotifyFieldCallback)

-- | 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
-- @
clearObjectClassNotify :: MonadIO m => ObjectClass -> m ()
clearObjectClassNotify :: forall (m :: * -> *). MonadIO m => ObjectClass -> m ()
clearObjectClassNotify ObjectClass
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ObjectClass -> (Ptr ObjectClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO ()) -> IO ())
-> (Ptr ObjectClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
    Ptr (FunPtr C_ObjectClassNotifyFieldCallback)
-> FunPtr C_ObjectClassNotifyFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr Ptr ObjectClass
-> Int -> Ptr (FunPtr C_ObjectClassNotifyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
64) (FunPtr C_ObjectClassNotifyFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr GObject.Callbacks.C_ObjectClassNotifyFieldCallback)

#if defined(ENABLE_OVERLOADING)
data ObjectClassNotifyFieldInfo
instance AttrInfo ObjectClassNotifyFieldInfo where
    type AttrBaseTypeConstraint ObjectClassNotifyFieldInfo = (~) ObjectClass
    type AttrAllowedOps ObjectClassNotifyFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ObjectClassNotifyFieldInfo = (~) (FunPtr GObject.Callbacks.C_ObjectClassNotifyFieldCallback)
    type AttrTransferTypeConstraint ObjectClassNotifyFieldInfo = (~)GObject.Callbacks.ObjectClassNotifyFieldCallback
    type AttrTransferType ObjectClassNotifyFieldInfo = (FunPtr GObject.Callbacks.C_ObjectClassNotifyFieldCallback)
    type AttrGetType ObjectClassNotifyFieldInfo = Maybe GObject.Callbacks.ObjectClassNotifyFieldCallback
    type AttrLabel ObjectClassNotifyFieldInfo = "notify"
    type AttrOrigin ObjectClassNotifyFieldInfo = ObjectClass
    attrGet = getObjectClassNotify
    attrSet = setObjectClassNotify
    attrConstruct = undefined
    attrClear = clearObjectClassNotify
    attrTransfer _ v = do
        GObject.Callbacks.mk_ObjectClassNotifyFieldCallback (GObject.Callbacks.wrap_ObjectClassNotifyFieldCallback Nothing v)

objectClass_notify :: AttrLabelProxy "notify"
objectClass_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' objectClass #constructed
-- @
getObjectClassConstructed :: MonadIO m => ObjectClass -> m (Maybe GObject.Callbacks.ObjectClassConstructedFieldCallback)
getObjectClassConstructed :: forall (m :: * -> *).
MonadIO m =>
ObjectClass -> m (Maybe ObjectClassDisposeFieldCallback)
getObjectClassConstructed ObjectClass
s = IO (Maybe ObjectClassDisposeFieldCallback)
-> m (Maybe ObjectClassDisposeFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe ObjectClassDisposeFieldCallback)
 -> m (Maybe ObjectClassDisposeFieldCallback))
-> IO (Maybe ObjectClassDisposeFieldCallback)
-> m (Maybe ObjectClassDisposeFieldCallback)
forall a b. (a -> b) -> a -> b
$ ObjectClass
-> (Ptr ObjectClass -> IO (Maybe ObjectClassDisposeFieldCallback))
-> IO (Maybe ObjectClassDisposeFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO (Maybe ObjectClassDisposeFieldCallback))
 -> IO (Maybe ObjectClassDisposeFieldCallback))
-> (Ptr ObjectClass -> IO (Maybe ObjectClassDisposeFieldCallback))
-> IO (Maybe ObjectClassDisposeFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
    FunPtr C_ObjectClassDisposeFieldCallback
val <- Ptr (FunPtr C_ObjectClassDisposeFieldCallback)
-> IO (FunPtr C_ObjectClassDisposeFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr ObjectClass
ptr Ptr ObjectClass
-> Int -> Ptr (FunPtr C_ObjectClassDisposeFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
72) :: IO (FunPtr GObject.Callbacks.C_ObjectClassConstructedFieldCallback)
    Maybe ObjectClassDisposeFieldCallback
result <- FunPtr C_ObjectClassDisposeFieldCallback
-> (FunPtr C_ObjectClassDisposeFieldCallback
    -> IO ObjectClassDisposeFieldCallback)
-> IO (Maybe ObjectClassDisposeFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_ObjectClassDisposeFieldCallback
val ((FunPtr C_ObjectClassDisposeFieldCallback
  -> IO ObjectClassDisposeFieldCallback)
 -> IO (Maybe ObjectClassDisposeFieldCallback))
-> (FunPtr C_ObjectClassDisposeFieldCallback
    -> IO ObjectClassDisposeFieldCallback)
-> IO (Maybe ObjectClassDisposeFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_ObjectClassDisposeFieldCallback
val' -> do
        let val'' :: ObjectClassDisposeFieldCallback
val'' = FunPtr C_ObjectClassDisposeFieldCallback
-> ObjectClassDisposeFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
FunPtr C_ObjectClassDisposeFieldCallback -> a -> m ()
GObject.Callbacks.dynamic_ObjectClassConstructedFieldCallback FunPtr C_ObjectClassDisposeFieldCallback
val'
        ObjectClassDisposeFieldCallback
-> IO ObjectClassDisposeFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return ObjectClassDisposeFieldCallback
val''
    Maybe ObjectClassDisposeFieldCallback
-> IO (Maybe ObjectClassDisposeFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ObjectClassDisposeFieldCallback
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' objectClass [ #constructed 'Data.GI.Base.Attributes.:=' value ]
-- @
setObjectClassConstructed :: MonadIO m => ObjectClass -> FunPtr GObject.Callbacks.C_ObjectClassConstructedFieldCallback -> m ()
setObjectClassConstructed :: forall (m :: * -> *).
MonadIO m =>
ObjectClass -> FunPtr C_ObjectClassDisposeFieldCallback -> m ()
setObjectClassConstructed ObjectClass
s FunPtr C_ObjectClassDisposeFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ObjectClass -> (Ptr ObjectClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO ()) -> IO ())
-> (Ptr ObjectClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
    Ptr (FunPtr C_ObjectClassDisposeFieldCallback)
-> FunPtr C_ObjectClassDisposeFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr Ptr ObjectClass
-> Int -> Ptr (FunPtr C_ObjectClassDisposeFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
72) (FunPtr C_ObjectClassDisposeFieldCallback
val :: FunPtr GObject.Callbacks.C_ObjectClassConstructedFieldCallback)

-- | 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
-- @
clearObjectClassConstructed :: MonadIO m => ObjectClass -> m ()
clearObjectClassConstructed :: forall (m :: * -> *). MonadIO m => ObjectClass -> m ()
clearObjectClassConstructed ObjectClass
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ObjectClass -> (Ptr ObjectClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO ()) -> IO ())
-> (Ptr ObjectClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
    Ptr (FunPtr C_ObjectClassDisposeFieldCallback)
-> FunPtr C_ObjectClassDisposeFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr Ptr ObjectClass
-> Int -> Ptr (FunPtr C_ObjectClassDisposeFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
72) (FunPtr C_ObjectClassDisposeFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr GObject.Callbacks.C_ObjectClassConstructedFieldCallback)

#if defined(ENABLE_OVERLOADING)
data ObjectClassConstructedFieldInfo
instance AttrInfo ObjectClassConstructedFieldInfo where
    type AttrBaseTypeConstraint ObjectClassConstructedFieldInfo = (~) ObjectClass
    type AttrAllowedOps ObjectClassConstructedFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ObjectClassConstructedFieldInfo = (~) (FunPtr GObject.Callbacks.C_ObjectClassConstructedFieldCallback)
    type AttrTransferTypeConstraint ObjectClassConstructedFieldInfo = (~)GObject.Callbacks.ObjectClassConstructedFieldCallback
    type AttrTransferType ObjectClassConstructedFieldInfo = (FunPtr GObject.Callbacks.C_ObjectClassConstructedFieldCallback)
    type AttrGetType ObjectClassConstructedFieldInfo = Maybe GObject.Callbacks.ObjectClassConstructedFieldCallback
    type AttrLabel ObjectClassConstructedFieldInfo = "constructed"
    type AttrOrigin ObjectClassConstructedFieldInfo = ObjectClass
    attrGet = getObjectClassConstructed
    attrSet = setObjectClassConstructed
    attrConstruct = undefined
    attrClear = clearObjectClassConstructed
    attrTransfer _ v = do
        GObject.Callbacks.mk_ObjectClassConstructedFieldCallback (GObject.Callbacks.wrap_ObjectClassConstructedFieldCallback Nothing v)

objectClass_constructed :: AttrLabelProxy "constructed"
objectClass_constructed = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList ObjectClass
type instance O.AttributeList ObjectClass = ObjectClassAttributeList
type ObjectClassAttributeList = ('[ '("gTypeClass", ObjectClassGTypeClassFieldInfo), '("setProperty", ObjectClassSetPropertyFieldInfo), '("getProperty", ObjectClassGetPropertyFieldInfo), '("dispose", ObjectClassDisposeFieldInfo), '("finalize", ObjectClassFinalizeFieldInfo), '("dispatchPropertiesChanged", ObjectClassDispatchPropertiesChangedFieldInfo), '("notify", ObjectClassNotifyFieldInfo), '("constructed", ObjectClassConstructedFieldInfo)] :: [(Symbol, *)])
#endif

-- method ObjectClass::find_property
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "oclass"
--           , argType =
--               TInterface Name { namespace = "GObject" , name = "ObjectClass" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GObjectClass" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "property_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the name of the property to look up"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just TParamSpec
-- throws : False
-- Skip return : False

foreign import ccall "g_object_class_find_property" g_object_class_find_property :: 
    Ptr ObjectClass ->                      -- oclass : TInterface (Name {namespace = "GObject", name = "ObjectClass"})
    CString ->                              -- property_name : TBasicType TUTF8
    IO (Ptr GParamSpec)

-- | Looks up the t'GI.GObject.Objects.ParamSpec.ParamSpec' for a property of a class.
objectClassFindProperty ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    ObjectClass
    -- ^ /@oclass@/: a t'GI.GObject.Structs.ObjectClass.ObjectClass'
    -> T.Text
    -- ^ /@propertyName@/: the name of the property to look up
    -> m GParamSpec
    -- ^ __Returns:__ the t'GI.GObject.Objects.ParamSpec.ParamSpec' for the property, or
    --          'P.Nothing' if the class doesn\'t have a property of that name
objectClassFindProperty :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
ObjectClass -> Text -> m GParamSpec
objectClassFindProperty ObjectClass
oclass Text
propertyName = IO GParamSpec -> m GParamSpec
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GParamSpec -> m GParamSpec) -> IO GParamSpec -> m GParamSpec
forall a b. (a -> b) -> a -> b
$ do
    Ptr ObjectClass
oclass' <- ObjectClass -> IO (Ptr ObjectClass)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr ObjectClass
oclass
    CString
propertyName' <- Text -> IO CString
textToCString Text
propertyName
    Ptr GParamSpec
result <- Ptr ObjectClass -> CString -> IO (Ptr GParamSpec)
g_object_class_find_property Ptr ObjectClass
oclass' CString
propertyName'
    Text -> Ptr GParamSpec -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"objectClassFindProperty" Ptr GParamSpec
result
    GParamSpec
result' <- Ptr GParamSpec -> IO GParamSpec
B.GParamSpec.newGParamSpecFromPtr Ptr GParamSpec
result
    ObjectClass -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr ObjectClass
oclass
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
propertyName'
    GParamSpec -> IO GParamSpec
forall (m :: * -> *) a. Monad m => a -> m a
return GParamSpec
result'

#if defined(ENABLE_OVERLOADING)
data ObjectClassFindPropertyMethodInfo
instance (signature ~ (T.Text -> m GParamSpec), MonadIO m) => O.OverloadedMethod ObjectClassFindPropertyMethodInfo ObjectClass signature where
    overloadedMethod = objectClassFindProperty

instance O.OverloadedMethodInfo ObjectClassFindPropertyMethodInfo ObjectClass where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.GObject.Structs.ObjectClass.objectClassFindProperty",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gobject-2.0.26/docs/GI-GObject-Structs-ObjectClass.html#v:objectClassFindProperty"
        }


#endif

-- XXX Could not generate method ObjectClass::install_properties
-- Not implemented: Don't know how to pack C array of type TCArray False (-1) 1 TParamSpec
-- method ObjectClass::install_property
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "oclass"
--           , argType =
--               TInterface Name { namespace = "GObject" , name = "ObjectClass" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GObjectClass" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "property_id"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the id for the new property"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "pspec"
--           , argType = TParamSpec
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #GParamSpec for the new property"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_object_class_install_property" g_object_class_install_property :: 
    Ptr ObjectClass ->                      -- oclass : TInterface (Name {namespace = "GObject", name = "ObjectClass"})
    Word32 ->                               -- property_id : TBasicType TUInt
    Ptr GParamSpec ->                       -- pspec : TParamSpec
    IO ()

-- | Installs a new property.
-- 
-- All properties should be installed during the class initializer.  It
-- is possible to install properties after that, but doing so is not
-- recommend, and specifically, is not guaranteed to be thread-safe vs.
-- use of properties on the same type on other threads.
-- 
-- Note that it is possible to redefine a property in a derived class,
-- by installing a property with the same name. This can be useful at times,
-- e.g. to change the range of allowed values or the default value.
objectClassInstallProperty ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    ObjectClass
    -- ^ /@oclass@/: a t'GI.GObject.Structs.ObjectClass.ObjectClass'
    -> Word32
    -- ^ /@propertyId@/: the id for the new property
    -> GParamSpec
    -- ^ /@pspec@/: the t'GI.GObject.Objects.ParamSpec.ParamSpec' for the new property
    -> m ()
objectClassInstallProperty :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
ObjectClass -> Word32 -> GParamSpec -> m ()
objectClassInstallProperty ObjectClass
oclass Word32
propertyId GParamSpec
pspec = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr ObjectClass
oclass' <- ObjectClass -> IO (Ptr ObjectClass)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr ObjectClass
oclass
    Ptr GParamSpec
pspec' <- GParamSpec -> IO (Ptr GParamSpec)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GParamSpec
pspec
    Ptr ObjectClass -> Word32 -> Ptr GParamSpec -> IO ()
g_object_class_install_property Ptr ObjectClass
oclass' Word32
propertyId Ptr GParamSpec
pspec'
    ObjectClass -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr ObjectClass
oclass
    GParamSpec -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GParamSpec
pspec
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ObjectClassInstallPropertyMethodInfo
instance (signature ~ (Word32 -> GParamSpec -> m ()), MonadIO m) => O.OverloadedMethod ObjectClassInstallPropertyMethodInfo ObjectClass signature where
    overloadedMethod = objectClassInstallProperty

instance O.OverloadedMethodInfo ObjectClassInstallPropertyMethodInfo ObjectClass where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.GObject.Structs.ObjectClass.objectClassInstallProperty",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gobject-2.0.26/docs/GI-GObject-Structs-ObjectClass.html#v:objectClassInstallProperty"
        }


#endif

-- XXX Could not generate method ObjectClass::list_properties
-- Not implemented: unpackCArray : Don't know how to unpack C Array of type TParamSpec
-- method ObjectClass::override_property
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "oclass"
--           , argType =
--               TInterface Name { namespace = "GObject" , name = "ObjectClass" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GObjectClass" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "property_id"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the new property ID"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the name of a property registered in a parent class or\n in an interface of this class."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_object_class_override_property" g_object_class_override_property :: 
    Ptr ObjectClass ->                      -- oclass : TInterface (Name {namespace = "GObject", name = "ObjectClass"})
    Word32 ->                               -- property_id : TBasicType TUInt
    CString ->                              -- name : TBasicType TUTF8
    IO ()

-- | Registers /@propertyId@/ as referring to a property with the name
-- /@name@/ in a parent class or in an interface implemented by /@oclass@/.
-- This allows this class to \"override\" a property implementation in
-- a parent class or to provide the implementation of a property from
-- an interface.
-- 
-- Internally, overriding is implemented by creating a property of type
-- t'GI.GObject.Objects.ParamSpecOverride.ParamSpecOverride'; generally operations that query the properties of
-- the object class, such as 'GI.GObject.Structs.ObjectClass.objectClassFindProperty' or
-- 'GI.GObject.Structs.ObjectClass.objectClassListProperties' will return the overridden
-- property. However, in one case, the /@constructProperties@/ argument of
-- the /@constructor@/ virtual function, the t'GI.GObject.Objects.ParamSpecOverride.ParamSpecOverride' is passed
-- instead, so that the /@paramId@/ field of the t'GI.GObject.Objects.ParamSpec.ParamSpec' will be
-- correct.  For virtually all uses, this makes no difference. If you
-- need to get the overridden property, you can call
-- 'GI.GObject.Objects.ParamSpec.paramSpecGetRedirectTarget'.
-- 
-- /Since: 2.4/
objectClassOverrideProperty ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    ObjectClass
    -- ^ /@oclass@/: a t'GI.GObject.Structs.ObjectClass.ObjectClass'
    -> Word32
    -- ^ /@propertyId@/: the new property ID
    -> T.Text
    -- ^ /@name@/: the name of a property registered in a parent class or
    --  in an interface of this class.
    -> m ()
objectClassOverrideProperty :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
ObjectClass -> Word32 -> Text -> m ()
objectClassOverrideProperty ObjectClass
oclass Word32
propertyId Text
name = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr ObjectClass
oclass' <- ObjectClass -> IO (Ptr ObjectClass)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr ObjectClass
oclass
    CString
name' <- Text -> IO CString
textToCString Text
name
    Ptr ObjectClass -> Word32 -> CString -> IO ()
g_object_class_override_property Ptr ObjectClass
oclass' Word32
propertyId CString
name'
    ObjectClass -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr ObjectClass
oclass
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ObjectClassOverridePropertyMethodInfo
instance (signature ~ (Word32 -> T.Text -> m ()), MonadIO m) => O.OverloadedMethod ObjectClassOverridePropertyMethodInfo ObjectClass signature where
    overloadedMethod = objectClassOverrideProperty

instance O.OverloadedMethodInfo ObjectClassOverridePropertyMethodInfo ObjectClass where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.GObject.Structs.ObjectClass.objectClassOverrideProperty",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gobject-2.0.26/docs/GI-GObject-Structs-ObjectClass.html#v:objectClassOverrideProperty"
        }


#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveObjectClassMethod (t :: Symbol) (o :: *) :: * where
    ResolveObjectClassMethod "findProperty" o = ObjectClassFindPropertyMethodInfo
    ResolveObjectClassMethod "installProperty" o = ObjectClassInstallPropertyMethodInfo
    ResolveObjectClassMethod "overrideProperty" o = ObjectClassOverridePropertyMethodInfo
    ResolveObjectClassMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveObjectClassMethod t ObjectClass, O.OverloadedMethod info ObjectClass p) => OL.IsLabel t (ObjectClass -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod @info
#else
    fromLabel _ = O.overloadedMethod @info
#endif

#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveObjectClassMethod t ObjectClass, O.OverloadedMethod info ObjectClass p, R.HasField t ObjectClass p) => R.HasField t ObjectClass p where
    getField = O.overloadedMethod @info

#endif

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

#endif