{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- Base class for containers.

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

module GI.Gtk.Structs.ContainerClass
    ( 

-- * Exported types
    ContainerClass(..)                      ,
    newZeroContainerClass                   ,


 -- * Methods
-- ** Overloaded methods #method:Overloaded methods#

#if defined(ENABLE_OVERLOADING)
    ResolveContainerClassMethod             ,
#endif


-- ** findChildProperty #method:findChildProperty#

#if defined(ENABLE_OVERLOADING)
    ContainerClassFindChildPropertyMethodInfo,
#endif
    containerClassFindChildProperty         ,


-- ** handleBorderWidth #method:handleBorderWidth#

#if defined(ENABLE_OVERLOADING)
    ContainerClassHandleBorderWidthMethodInfo,
#endif
    containerClassHandleBorderWidth         ,


-- ** installChildProperty #method:installChildProperty#

#if defined(ENABLE_OVERLOADING)
    ContainerClassInstallChildPropertyMethodInfo,
#endif
    containerClassInstallChildProperty      ,




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

    clearContainerClassAdd                  ,
#if defined(ENABLE_OVERLOADING)
    containerClass_add                      ,
#endif
    getContainerClassAdd                    ,
    setContainerClassAdd                    ,


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

    clearContainerClassCheckResize          ,
#if defined(ENABLE_OVERLOADING)
    containerClass_checkResize              ,
#endif
    getContainerClassCheckResize            ,
    setContainerClassCheckResize            ,


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

    clearContainerClassChildType            ,
#if defined(ENABLE_OVERLOADING)
    containerClass_childType                ,
#endif
    getContainerClassChildType              ,
    setContainerClassChildType              ,


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

    clearContainerClassCompositeName        ,
#if defined(ENABLE_OVERLOADING)
    containerClass_compositeName            ,
#endif
    getContainerClassCompositeName          ,
    setContainerClassCompositeName          ,


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

    clearContainerClassForall               ,
#if defined(ENABLE_OVERLOADING)
    containerClass_forall                   ,
#endif
    getContainerClassForall                 ,
    setContainerClassForall                 ,


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

    clearContainerClassGetChildProperty     ,
#if defined(ENABLE_OVERLOADING)
    containerClass_getChildProperty         ,
#endif
    getContainerClassGetChildProperty       ,
    setContainerClassGetChildProperty       ,


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

    clearContainerClassGetPathForChild      ,
#if defined(ENABLE_OVERLOADING)
    containerClass_getPathForChild          ,
#endif
    getContainerClassGetPathForChild        ,
    setContainerClassGetPathForChild        ,


-- ** parentClass #attr:parentClass#
-- | The parent class.

#if defined(ENABLE_OVERLOADING)
    containerClass_parentClass              ,
#endif
    getContainerClassParentClass            ,


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

    clearContainerClassRemove               ,
#if defined(ENABLE_OVERLOADING)
    containerClass_remove                   ,
#endif
    getContainerClassRemove                 ,
    setContainerClassRemove                 ,


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

    clearContainerClassSetChildProperty     ,
#if defined(ENABLE_OVERLOADING)
    containerClass_setChildProperty         ,
#endif
    getContainerClassSetChildProperty       ,
    setContainerClassSetChildProperty       ,


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

    clearContainerClassSetFocusChild        ,
#if defined(ENABLE_OVERLOADING)
    containerClass_setFocusChild            ,
#endif
    getContainerClassSetFocusChild          ,
    setContainerClassSetFocusChild          ,




    ) 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 GI.Gtk.Callbacks as Gtk.Callbacks
import {-# SOURCE #-} qualified GI.Gtk.Structs.WidgetClass as Gtk.WidgetClass

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

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

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


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

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


-- | Get the value of the “@parent_class@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' containerClass #parentClass
-- @
getContainerClassParentClass :: MonadIO m => ContainerClass -> m Gtk.WidgetClass.WidgetClass
getContainerClassParentClass :: ContainerClass -> m WidgetClass
getContainerClassParentClass ContainerClass
s = IO WidgetClass -> m WidgetClass
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO WidgetClass -> m WidgetClass)
-> IO WidgetClass -> m WidgetClass
forall a b. (a -> b) -> a -> b
$ ContainerClass
-> (Ptr ContainerClass -> IO WidgetClass) -> IO WidgetClass
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ContainerClass
s ((Ptr ContainerClass -> IO WidgetClass) -> IO WidgetClass)
-> (Ptr ContainerClass -> IO WidgetClass) -> IO WidgetClass
forall a b. (a -> b) -> a -> b
$ \Ptr ContainerClass
ptr -> do
    let val :: Ptr WidgetClass
val = Ptr ContainerClass
ptr Ptr ContainerClass -> Int -> Ptr WidgetClass
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0 :: (Ptr Gtk.WidgetClass.WidgetClass)
    WidgetClass
val' <- ((ManagedPtr WidgetClass -> WidgetClass)
-> Ptr WidgetClass -> IO WidgetClass
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr WidgetClass -> WidgetClass
Gtk.WidgetClass.WidgetClass) Ptr WidgetClass
val
    WidgetClass -> IO WidgetClass
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClass
val'

#if defined(ENABLE_OVERLOADING)
data ContainerClassParentClassFieldInfo
instance AttrInfo ContainerClassParentClassFieldInfo where
    type AttrBaseTypeConstraint ContainerClassParentClassFieldInfo = (~) ContainerClass
    type AttrAllowedOps ContainerClassParentClassFieldInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint ContainerClassParentClassFieldInfo = (~) (Ptr Gtk.WidgetClass.WidgetClass)
    type AttrTransferTypeConstraint ContainerClassParentClassFieldInfo = (~)(Ptr Gtk.WidgetClass.WidgetClass)
    type AttrTransferType ContainerClassParentClassFieldInfo = (Ptr Gtk.WidgetClass.WidgetClass)
    type AttrGetType ContainerClassParentClassFieldInfo = Gtk.WidgetClass.WidgetClass
    type AttrLabel ContainerClassParentClassFieldInfo = "parent_class"
    type AttrOrigin ContainerClassParentClassFieldInfo = ContainerClass
    attrGet = getContainerClassParentClass
    attrSet = undefined
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer = undefined

containerClass_parentClass :: AttrLabelProxy "parentClass"
containerClass_parentClass = AttrLabelProxy

#endif


-- | Get the value of the “@add@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' containerClass #add
-- @
getContainerClassAdd :: MonadIO m => ContainerClass -> m (Maybe Gtk.Callbacks.ContainerClassAddFieldCallback)
getContainerClassAdd :: ContainerClass -> m (Maybe ContainerClassAddFieldCallback)
getContainerClassAdd ContainerClass
s = IO (Maybe ContainerClassAddFieldCallback)
-> m (Maybe ContainerClassAddFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe ContainerClassAddFieldCallback)
 -> m (Maybe ContainerClassAddFieldCallback))
-> IO (Maybe ContainerClassAddFieldCallback)
-> m (Maybe ContainerClassAddFieldCallback)
forall a b. (a -> b) -> a -> b
$ ContainerClass
-> (Ptr ContainerClass
    -> IO (Maybe ContainerClassAddFieldCallback))
-> IO (Maybe ContainerClassAddFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ContainerClass
s ((Ptr ContainerClass -> IO (Maybe ContainerClassAddFieldCallback))
 -> IO (Maybe ContainerClassAddFieldCallback))
-> (Ptr ContainerClass
    -> IO (Maybe ContainerClassAddFieldCallback))
-> IO (Maybe ContainerClassAddFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr ContainerClass
ptr -> do
    FunPtr C_ContainerClassAddFieldCallback
val <- Ptr (FunPtr C_ContainerClassAddFieldCallback)
-> IO (FunPtr C_ContainerClassAddFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr ContainerClass
ptr Ptr ContainerClass
-> Int -> Ptr (FunPtr C_ContainerClassAddFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
824) :: IO (FunPtr Gtk.Callbacks.C_ContainerClassAddFieldCallback)
    Maybe ContainerClassAddFieldCallback
result <- FunPtr C_ContainerClassAddFieldCallback
-> (FunPtr C_ContainerClassAddFieldCallback
    -> IO ContainerClassAddFieldCallback)
-> IO (Maybe ContainerClassAddFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_ContainerClassAddFieldCallback
val ((FunPtr C_ContainerClassAddFieldCallback
  -> IO ContainerClassAddFieldCallback)
 -> IO (Maybe ContainerClassAddFieldCallback))
-> (FunPtr C_ContainerClassAddFieldCallback
    -> IO ContainerClassAddFieldCallback)
-> IO (Maybe ContainerClassAddFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_ContainerClassAddFieldCallback
val' -> do
        let val'' :: ContainerClassAddFieldCallback
val'' = FunPtr C_ContainerClassAddFieldCallback
-> ContainerClassAddFieldCallback
forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsContainer a, IsWidget b) =>
FunPtr C_ContainerClassAddFieldCallback -> a -> b -> m ()
Gtk.Callbacks.dynamic_ContainerClassAddFieldCallback FunPtr C_ContainerClassAddFieldCallback
val'
        ContainerClassAddFieldCallback -> IO ContainerClassAddFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return ContainerClassAddFieldCallback
val''
    Maybe ContainerClassAddFieldCallback
-> IO (Maybe ContainerClassAddFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ContainerClassAddFieldCallback
result

-- | Set the value of the “@add@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' containerClass [ #add 'Data.GI.Base.Attributes.:=' value ]
-- @
setContainerClassAdd :: MonadIO m => ContainerClass -> FunPtr Gtk.Callbacks.C_ContainerClassAddFieldCallback -> m ()
setContainerClassAdd :: ContainerClass -> FunPtr C_ContainerClassAddFieldCallback -> m ()
setContainerClassAdd ContainerClass
s FunPtr C_ContainerClassAddFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ContainerClass -> (Ptr ContainerClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ContainerClass
s ((Ptr ContainerClass -> IO ()) -> IO ())
-> (Ptr ContainerClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ContainerClass
ptr -> do
    Ptr (FunPtr C_ContainerClassAddFieldCallback)
-> FunPtr C_ContainerClassAddFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ContainerClass
ptr Ptr ContainerClass
-> Int -> Ptr (FunPtr C_ContainerClassAddFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
824) (FunPtr C_ContainerClassAddFieldCallback
val :: FunPtr Gtk.Callbacks.C_ContainerClassAddFieldCallback)

-- | Set the value of the “@add@” 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' #add
-- @
clearContainerClassAdd :: MonadIO m => ContainerClass -> m ()
clearContainerClassAdd :: ContainerClass -> m ()
clearContainerClassAdd ContainerClass
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ContainerClass -> (Ptr ContainerClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ContainerClass
s ((Ptr ContainerClass -> IO ()) -> IO ())
-> (Ptr ContainerClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ContainerClass
ptr -> do
    Ptr (FunPtr C_ContainerClassAddFieldCallback)
-> FunPtr C_ContainerClassAddFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ContainerClass
ptr Ptr ContainerClass
-> Int -> Ptr (FunPtr C_ContainerClassAddFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
824) (FunPtr C_ContainerClassAddFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_ContainerClassAddFieldCallback)

#if defined(ENABLE_OVERLOADING)
data ContainerClassAddFieldInfo
instance AttrInfo ContainerClassAddFieldInfo where
    type AttrBaseTypeConstraint ContainerClassAddFieldInfo = (~) ContainerClass
    type AttrAllowedOps ContainerClassAddFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ContainerClassAddFieldInfo = (~) (FunPtr Gtk.Callbacks.C_ContainerClassAddFieldCallback)
    type AttrTransferTypeConstraint ContainerClassAddFieldInfo = (~)Gtk.Callbacks.ContainerClassAddFieldCallback
    type AttrTransferType ContainerClassAddFieldInfo = (FunPtr Gtk.Callbacks.C_ContainerClassAddFieldCallback)
    type AttrGetType ContainerClassAddFieldInfo = Maybe Gtk.Callbacks.ContainerClassAddFieldCallback
    type AttrLabel ContainerClassAddFieldInfo = "add"
    type AttrOrigin ContainerClassAddFieldInfo = ContainerClass
    attrGet = getContainerClassAdd
    attrSet = setContainerClassAdd
    attrConstruct = undefined
    attrClear = clearContainerClassAdd
    attrTransfer _ v = do
        Gtk.Callbacks.mk_ContainerClassAddFieldCallback (Gtk.Callbacks.wrap_ContainerClassAddFieldCallback Nothing v)

containerClass_add :: AttrLabelProxy "add"
containerClass_add = AttrLabelProxy

#endif


-- | Get the value of the “@remove@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' containerClass #remove
-- @
getContainerClassRemove :: MonadIO m => ContainerClass -> m (Maybe Gtk.Callbacks.ContainerClassRemoveFieldCallback)
getContainerClassRemove :: ContainerClass -> m (Maybe ContainerClassAddFieldCallback)
getContainerClassRemove ContainerClass
s = IO (Maybe ContainerClassAddFieldCallback)
-> m (Maybe ContainerClassAddFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe ContainerClassAddFieldCallback)
 -> m (Maybe ContainerClassAddFieldCallback))
-> IO (Maybe ContainerClassAddFieldCallback)
-> m (Maybe ContainerClassAddFieldCallback)
forall a b. (a -> b) -> a -> b
$ ContainerClass
-> (Ptr ContainerClass
    -> IO (Maybe ContainerClassAddFieldCallback))
-> IO (Maybe ContainerClassAddFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ContainerClass
s ((Ptr ContainerClass -> IO (Maybe ContainerClassAddFieldCallback))
 -> IO (Maybe ContainerClassAddFieldCallback))
-> (Ptr ContainerClass
    -> IO (Maybe ContainerClassAddFieldCallback))
-> IO (Maybe ContainerClassAddFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr ContainerClass
ptr -> do
    FunPtr C_ContainerClassAddFieldCallback
val <- Ptr (FunPtr C_ContainerClassAddFieldCallback)
-> IO (FunPtr C_ContainerClassAddFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr ContainerClass
ptr Ptr ContainerClass
-> Int -> Ptr (FunPtr C_ContainerClassAddFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
832) :: IO (FunPtr Gtk.Callbacks.C_ContainerClassRemoveFieldCallback)
    Maybe ContainerClassAddFieldCallback
result <- FunPtr C_ContainerClassAddFieldCallback
-> (FunPtr C_ContainerClassAddFieldCallback
    -> IO ContainerClassAddFieldCallback)
-> IO (Maybe ContainerClassAddFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_ContainerClassAddFieldCallback
val ((FunPtr C_ContainerClassAddFieldCallback
  -> IO ContainerClassAddFieldCallback)
 -> IO (Maybe ContainerClassAddFieldCallback))
-> (FunPtr C_ContainerClassAddFieldCallback
    -> IO ContainerClassAddFieldCallback)
-> IO (Maybe ContainerClassAddFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_ContainerClassAddFieldCallback
val' -> do
        let val'' :: ContainerClassAddFieldCallback
val'' = FunPtr C_ContainerClassAddFieldCallback
-> ContainerClassAddFieldCallback
forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsContainer a, IsWidget b) =>
FunPtr C_ContainerClassAddFieldCallback -> a -> b -> m ()
Gtk.Callbacks.dynamic_ContainerClassRemoveFieldCallback FunPtr C_ContainerClassAddFieldCallback
val'
        ContainerClassAddFieldCallback -> IO ContainerClassAddFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return ContainerClassAddFieldCallback
val''
    Maybe ContainerClassAddFieldCallback
-> IO (Maybe ContainerClassAddFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ContainerClassAddFieldCallback
result

-- | Set the value of the “@remove@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' containerClass [ #remove 'Data.GI.Base.Attributes.:=' value ]
-- @
setContainerClassRemove :: MonadIO m => ContainerClass -> FunPtr Gtk.Callbacks.C_ContainerClassRemoveFieldCallback -> m ()
setContainerClassRemove :: ContainerClass -> FunPtr C_ContainerClassAddFieldCallback -> m ()
setContainerClassRemove ContainerClass
s FunPtr C_ContainerClassAddFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ContainerClass -> (Ptr ContainerClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ContainerClass
s ((Ptr ContainerClass -> IO ()) -> IO ())
-> (Ptr ContainerClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ContainerClass
ptr -> do
    Ptr (FunPtr C_ContainerClassAddFieldCallback)
-> FunPtr C_ContainerClassAddFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ContainerClass
ptr Ptr ContainerClass
-> Int -> Ptr (FunPtr C_ContainerClassAddFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
832) (FunPtr C_ContainerClassAddFieldCallback
val :: FunPtr Gtk.Callbacks.C_ContainerClassRemoveFieldCallback)

-- | Set the value of the “@remove@” 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' #remove
-- @
clearContainerClassRemove :: MonadIO m => ContainerClass -> m ()
clearContainerClassRemove :: ContainerClass -> m ()
clearContainerClassRemove ContainerClass
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ContainerClass -> (Ptr ContainerClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ContainerClass
s ((Ptr ContainerClass -> IO ()) -> IO ())
-> (Ptr ContainerClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ContainerClass
ptr -> do
    Ptr (FunPtr C_ContainerClassAddFieldCallback)
-> FunPtr C_ContainerClassAddFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ContainerClass
ptr Ptr ContainerClass
-> Int -> Ptr (FunPtr C_ContainerClassAddFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
832) (FunPtr C_ContainerClassAddFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_ContainerClassRemoveFieldCallback)

#if defined(ENABLE_OVERLOADING)
data ContainerClassRemoveFieldInfo
instance AttrInfo ContainerClassRemoveFieldInfo where
    type AttrBaseTypeConstraint ContainerClassRemoveFieldInfo = (~) ContainerClass
    type AttrAllowedOps ContainerClassRemoveFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ContainerClassRemoveFieldInfo = (~) (FunPtr Gtk.Callbacks.C_ContainerClassRemoveFieldCallback)
    type AttrTransferTypeConstraint ContainerClassRemoveFieldInfo = (~)Gtk.Callbacks.ContainerClassRemoveFieldCallback
    type AttrTransferType ContainerClassRemoveFieldInfo = (FunPtr Gtk.Callbacks.C_ContainerClassRemoveFieldCallback)
    type AttrGetType ContainerClassRemoveFieldInfo = Maybe Gtk.Callbacks.ContainerClassRemoveFieldCallback
    type AttrLabel ContainerClassRemoveFieldInfo = "remove"
    type AttrOrigin ContainerClassRemoveFieldInfo = ContainerClass
    attrGet = getContainerClassRemove
    attrSet = setContainerClassRemove
    attrConstruct = undefined
    attrClear = clearContainerClassRemove
    attrTransfer _ v = do
        Gtk.Callbacks.mk_ContainerClassRemoveFieldCallback (Gtk.Callbacks.wrap_ContainerClassRemoveFieldCallback Nothing v)

containerClass_remove :: AttrLabelProxy "remove"
containerClass_remove = AttrLabelProxy

#endif


-- | Get the value of the “@check_resize@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' containerClass #checkResize
-- @
getContainerClassCheckResize :: MonadIO m => ContainerClass -> m (Maybe Gtk.Callbacks.ContainerClassCheckResizeFieldCallback)
getContainerClassCheckResize :: ContainerClass -> m (Maybe ContainerClassCheckResizeFieldCallback)
getContainerClassCheckResize ContainerClass
s = IO (Maybe ContainerClassCheckResizeFieldCallback)
-> m (Maybe ContainerClassCheckResizeFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe ContainerClassCheckResizeFieldCallback)
 -> m (Maybe ContainerClassCheckResizeFieldCallback))
-> IO (Maybe ContainerClassCheckResizeFieldCallback)
-> m (Maybe ContainerClassCheckResizeFieldCallback)
forall a b. (a -> b) -> a -> b
$ ContainerClass
-> (Ptr ContainerClass
    -> IO (Maybe ContainerClassCheckResizeFieldCallback))
-> IO (Maybe ContainerClassCheckResizeFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ContainerClass
s ((Ptr ContainerClass
  -> IO (Maybe ContainerClassCheckResizeFieldCallback))
 -> IO (Maybe ContainerClassCheckResizeFieldCallback))
-> (Ptr ContainerClass
    -> IO (Maybe ContainerClassCheckResizeFieldCallback))
-> IO (Maybe ContainerClassCheckResizeFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr ContainerClass
ptr -> do
    FunPtr C_ContainerClassCheckResizeFieldCallback
val <- Ptr (FunPtr C_ContainerClassCheckResizeFieldCallback)
-> IO (FunPtr C_ContainerClassCheckResizeFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr ContainerClass
ptr Ptr ContainerClass
-> Int -> Ptr (FunPtr C_ContainerClassCheckResizeFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
840) :: IO (FunPtr Gtk.Callbacks.C_ContainerClassCheckResizeFieldCallback)
    Maybe ContainerClassCheckResizeFieldCallback
result <- FunPtr C_ContainerClassCheckResizeFieldCallback
-> (FunPtr C_ContainerClassCheckResizeFieldCallback
    -> IO ContainerClassCheckResizeFieldCallback)
-> IO (Maybe ContainerClassCheckResizeFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_ContainerClassCheckResizeFieldCallback
val ((FunPtr C_ContainerClassCheckResizeFieldCallback
  -> IO ContainerClassCheckResizeFieldCallback)
 -> IO (Maybe ContainerClassCheckResizeFieldCallback))
-> (FunPtr C_ContainerClassCheckResizeFieldCallback
    -> IO ContainerClassCheckResizeFieldCallback)
-> IO (Maybe ContainerClassCheckResizeFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_ContainerClassCheckResizeFieldCallback
val' -> do
        let val'' :: ContainerClassCheckResizeFieldCallback
val'' = FunPtr C_ContainerClassCheckResizeFieldCallback
-> ContainerClassCheckResizeFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsContainer a) =>
FunPtr C_ContainerClassCheckResizeFieldCallback -> a -> m ()
Gtk.Callbacks.dynamic_ContainerClassCheckResizeFieldCallback FunPtr C_ContainerClassCheckResizeFieldCallback
val'
        ContainerClassCheckResizeFieldCallback
-> IO ContainerClassCheckResizeFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return ContainerClassCheckResizeFieldCallback
val''
    Maybe ContainerClassCheckResizeFieldCallback
-> IO (Maybe ContainerClassCheckResizeFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ContainerClassCheckResizeFieldCallback
result

-- | Set the value of the “@check_resize@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' containerClass [ #checkResize 'Data.GI.Base.Attributes.:=' value ]
-- @
setContainerClassCheckResize :: MonadIO m => ContainerClass -> FunPtr Gtk.Callbacks.C_ContainerClassCheckResizeFieldCallback -> m ()
setContainerClassCheckResize :: ContainerClass
-> FunPtr C_ContainerClassCheckResizeFieldCallback -> m ()
setContainerClassCheckResize ContainerClass
s FunPtr C_ContainerClassCheckResizeFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ContainerClass -> (Ptr ContainerClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ContainerClass
s ((Ptr ContainerClass -> IO ()) -> IO ())
-> (Ptr ContainerClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ContainerClass
ptr -> do
    Ptr (FunPtr C_ContainerClassCheckResizeFieldCallback)
-> FunPtr C_ContainerClassCheckResizeFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ContainerClass
ptr Ptr ContainerClass
-> Int -> Ptr (FunPtr C_ContainerClassCheckResizeFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
840) (FunPtr C_ContainerClassCheckResizeFieldCallback
val :: FunPtr Gtk.Callbacks.C_ContainerClassCheckResizeFieldCallback)

-- | Set the value of the “@check_resize@” 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' #checkResize
-- @
clearContainerClassCheckResize :: MonadIO m => ContainerClass -> m ()
clearContainerClassCheckResize :: ContainerClass -> m ()
clearContainerClassCheckResize ContainerClass
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ContainerClass -> (Ptr ContainerClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ContainerClass
s ((Ptr ContainerClass -> IO ()) -> IO ())
-> (Ptr ContainerClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ContainerClass
ptr -> do
    Ptr (FunPtr C_ContainerClassCheckResizeFieldCallback)
-> FunPtr C_ContainerClassCheckResizeFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ContainerClass
ptr Ptr ContainerClass
-> Int -> Ptr (FunPtr C_ContainerClassCheckResizeFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
840) (FunPtr C_ContainerClassCheckResizeFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_ContainerClassCheckResizeFieldCallback)

#if defined(ENABLE_OVERLOADING)
data ContainerClassCheckResizeFieldInfo
instance AttrInfo ContainerClassCheckResizeFieldInfo where
    type AttrBaseTypeConstraint ContainerClassCheckResizeFieldInfo = (~) ContainerClass
    type AttrAllowedOps ContainerClassCheckResizeFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ContainerClassCheckResizeFieldInfo = (~) (FunPtr Gtk.Callbacks.C_ContainerClassCheckResizeFieldCallback)
    type AttrTransferTypeConstraint ContainerClassCheckResizeFieldInfo = (~)Gtk.Callbacks.ContainerClassCheckResizeFieldCallback
    type AttrTransferType ContainerClassCheckResizeFieldInfo = (FunPtr Gtk.Callbacks.C_ContainerClassCheckResizeFieldCallback)
    type AttrGetType ContainerClassCheckResizeFieldInfo = Maybe Gtk.Callbacks.ContainerClassCheckResizeFieldCallback
    type AttrLabel ContainerClassCheckResizeFieldInfo = "check_resize"
    type AttrOrigin ContainerClassCheckResizeFieldInfo = ContainerClass
    attrGet = getContainerClassCheckResize
    attrSet = setContainerClassCheckResize
    attrConstruct = undefined
    attrClear = clearContainerClassCheckResize
    attrTransfer _ v = do
        Gtk.Callbacks.mk_ContainerClassCheckResizeFieldCallback (Gtk.Callbacks.wrap_ContainerClassCheckResizeFieldCallback Nothing v)

containerClass_checkResize :: AttrLabelProxy "checkResize"
containerClass_checkResize = AttrLabelProxy

#endif


-- | Get the value of the “@forall@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' containerClass #forall
-- @
getContainerClassForall :: MonadIO m => ContainerClass -> m (Maybe Gtk.Callbacks.ContainerClassForallFieldCallback_WithClosures)
getContainerClassForall :: ContainerClass
-> m (Maybe ContainerClassForallFieldCallback_WithClosures)
getContainerClassForall ContainerClass
s = IO (Maybe ContainerClassForallFieldCallback_WithClosures)
-> m (Maybe ContainerClassForallFieldCallback_WithClosures)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe ContainerClassForallFieldCallback_WithClosures)
 -> m (Maybe ContainerClassForallFieldCallback_WithClosures))
-> IO (Maybe ContainerClassForallFieldCallback_WithClosures)
-> m (Maybe ContainerClassForallFieldCallback_WithClosures)
forall a b. (a -> b) -> a -> b
$ ContainerClass
-> (Ptr ContainerClass
    -> IO (Maybe ContainerClassForallFieldCallback_WithClosures))
-> IO (Maybe ContainerClassForallFieldCallback_WithClosures)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ContainerClass
s ((Ptr ContainerClass
  -> IO (Maybe ContainerClassForallFieldCallback_WithClosures))
 -> IO (Maybe ContainerClassForallFieldCallback_WithClosures))
-> (Ptr ContainerClass
    -> IO (Maybe ContainerClassForallFieldCallback_WithClosures))
-> IO (Maybe ContainerClassForallFieldCallback_WithClosures)
forall a b. (a -> b) -> a -> b
$ \Ptr ContainerClass
ptr -> do
    FunPtr C_ContainerClassForallFieldCallback
val <- Ptr (FunPtr C_ContainerClassForallFieldCallback)
-> IO (FunPtr C_ContainerClassForallFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr ContainerClass
ptr Ptr ContainerClass
-> Int -> Ptr (FunPtr C_ContainerClassForallFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
848) :: IO (FunPtr Gtk.Callbacks.C_ContainerClassForallFieldCallback)
    Maybe ContainerClassForallFieldCallback_WithClosures
result <- FunPtr C_ContainerClassForallFieldCallback
-> (FunPtr C_ContainerClassForallFieldCallback
    -> IO ContainerClassForallFieldCallback_WithClosures)
-> IO (Maybe ContainerClassForallFieldCallback_WithClosures)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_ContainerClassForallFieldCallback
val ((FunPtr C_ContainerClassForallFieldCallback
  -> IO ContainerClassForallFieldCallback_WithClosures)
 -> IO (Maybe ContainerClassForallFieldCallback_WithClosures))
-> (FunPtr C_ContainerClassForallFieldCallback
    -> IO ContainerClassForallFieldCallback_WithClosures)
-> IO (Maybe ContainerClassForallFieldCallback_WithClosures)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_ContainerClassForallFieldCallback
val' -> do
        let val'' :: ContainerClassForallFieldCallback_WithClosures
val'' = FunPtr C_ContainerClassForallFieldCallback
-> ContainerClassForallFieldCallback_WithClosures
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsContainer a) =>
FunPtr C_ContainerClassForallFieldCallback
-> a -> Bool -> Callback_WithClosures -> Ptr () -> m ()
Gtk.Callbacks.dynamic_ContainerClassForallFieldCallback FunPtr C_ContainerClassForallFieldCallback
val'
        ContainerClassForallFieldCallback_WithClosures
-> IO ContainerClassForallFieldCallback_WithClosures
forall (m :: * -> *) a. Monad m => a -> m a
return ContainerClassForallFieldCallback_WithClosures
val''
    Maybe ContainerClassForallFieldCallback_WithClosures
-> IO (Maybe ContainerClassForallFieldCallback_WithClosures)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ContainerClassForallFieldCallback_WithClosures
result

-- | Set the value of the “@forall@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' containerClass [ #forall 'Data.GI.Base.Attributes.:=' value ]
-- @
setContainerClassForall :: MonadIO m => ContainerClass -> FunPtr Gtk.Callbacks.C_ContainerClassForallFieldCallback -> m ()
setContainerClassForall :: ContainerClass
-> FunPtr C_ContainerClassForallFieldCallback -> m ()
setContainerClassForall ContainerClass
s FunPtr C_ContainerClassForallFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ContainerClass -> (Ptr ContainerClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ContainerClass
s ((Ptr ContainerClass -> IO ()) -> IO ())
-> (Ptr ContainerClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ContainerClass
ptr -> do
    Ptr (FunPtr C_ContainerClassForallFieldCallback)
-> FunPtr C_ContainerClassForallFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ContainerClass
ptr Ptr ContainerClass
-> Int -> Ptr (FunPtr C_ContainerClassForallFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
848) (FunPtr C_ContainerClassForallFieldCallback
val :: FunPtr Gtk.Callbacks.C_ContainerClassForallFieldCallback)

-- | Set the value of the “@forall@” 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' #forall
-- @
clearContainerClassForall :: MonadIO m => ContainerClass -> m ()
clearContainerClassForall :: ContainerClass -> m ()
clearContainerClassForall ContainerClass
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ContainerClass -> (Ptr ContainerClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ContainerClass
s ((Ptr ContainerClass -> IO ()) -> IO ())
-> (Ptr ContainerClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ContainerClass
ptr -> do
    Ptr (FunPtr C_ContainerClassForallFieldCallback)
-> FunPtr C_ContainerClassForallFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ContainerClass
ptr Ptr ContainerClass
-> Int -> Ptr (FunPtr C_ContainerClassForallFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
848) (FunPtr C_ContainerClassForallFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_ContainerClassForallFieldCallback)

#if defined(ENABLE_OVERLOADING)
data ContainerClassForallFieldInfo
instance AttrInfo ContainerClassForallFieldInfo where
    type AttrBaseTypeConstraint ContainerClassForallFieldInfo = (~) ContainerClass
    type AttrAllowedOps ContainerClassForallFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ContainerClassForallFieldInfo = (~) (FunPtr Gtk.Callbacks.C_ContainerClassForallFieldCallback)
    type AttrTransferTypeConstraint ContainerClassForallFieldInfo = (~)Gtk.Callbacks.ContainerClassForallFieldCallback_WithClosures
    type AttrTransferType ContainerClassForallFieldInfo = (FunPtr Gtk.Callbacks.C_ContainerClassForallFieldCallback)
    type AttrGetType ContainerClassForallFieldInfo = Maybe Gtk.Callbacks.ContainerClassForallFieldCallback_WithClosures
    type AttrLabel ContainerClassForallFieldInfo = "forall"
    type AttrOrigin ContainerClassForallFieldInfo = ContainerClass
    attrGet = getContainerClassForall
    attrSet = setContainerClassForall
    attrConstruct = undefined
    attrClear = clearContainerClassForall
    attrTransfer _ v = do
        Gtk.Callbacks.mk_ContainerClassForallFieldCallback (Gtk.Callbacks.wrap_ContainerClassForallFieldCallback Nothing v)

containerClass_forall :: AttrLabelProxy "forall"
containerClass_forall = AttrLabelProxy

#endif


-- | Get the value of the “@set_focus_child@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' containerClass #setFocusChild
-- @
getContainerClassSetFocusChild :: MonadIO m => ContainerClass -> m (Maybe Gtk.Callbacks.ContainerClassSetFocusChildFieldCallback)
getContainerClassSetFocusChild :: ContainerClass
-> m (Maybe ContainerClassSetFocusChildFieldCallback)
getContainerClassSetFocusChild ContainerClass
s = IO (Maybe ContainerClassSetFocusChildFieldCallback)
-> m (Maybe ContainerClassSetFocusChildFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe ContainerClassSetFocusChildFieldCallback)
 -> m (Maybe ContainerClassSetFocusChildFieldCallback))
-> IO (Maybe ContainerClassSetFocusChildFieldCallback)
-> m (Maybe ContainerClassSetFocusChildFieldCallback)
forall a b. (a -> b) -> a -> b
$ ContainerClass
-> (Ptr ContainerClass
    -> IO (Maybe ContainerClassSetFocusChildFieldCallback))
-> IO (Maybe ContainerClassSetFocusChildFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ContainerClass
s ((Ptr ContainerClass
  -> IO (Maybe ContainerClassSetFocusChildFieldCallback))
 -> IO (Maybe ContainerClassSetFocusChildFieldCallback))
-> (Ptr ContainerClass
    -> IO (Maybe ContainerClassSetFocusChildFieldCallback))
-> IO (Maybe ContainerClassSetFocusChildFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr ContainerClass
ptr -> do
    FunPtr C_ContainerClassAddFieldCallback
val <- Ptr (FunPtr C_ContainerClassAddFieldCallback)
-> IO (FunPtr C_ContainerClassAddFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr ContainerClass
ptr Ptr ContainerClass
-> Int -> Ptr (FunPtr C_ContainerClassAddFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
856) :: IO (FunPtr Gtk.Callbacks.C_ContainerClassSetFocusChildFieldCallback)
    Maybe ContainerClassSetFocusChildFieldCallback
result <- FunPtr C_ContainerClassAddFieldCallback
-> (FunPtr C_ContainerClassAddFieldCallback
    -> IO ContainerClassSetFocusChildFieldCallback)
-> IO (Maybe ContainerClassSetFocusChildFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_ContainerClassAddFieldCallback
val ((FunPtr C_ContainerClassAddFieldCallback
  -> IO ContainerClassSetFocusChildFieldCallback)
 -> IO (Maybe ContainerClassSetFocusChildFieldCallback))
-> (FunPtr C_ContainerClassAddFieldCallback
    -> IO ContainerClassSetFocusChildFieldCallback)
-> IO (Maybe ContainerClassSetFocusChildFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_ContainerClassAddFieldCallback
val' -> do
        let val'' :: ContainerClassSetFocusChildFieldCallback
val'' = FunPtr C_ContainerClassAddFieldCallback
-> ContainerClassSetFocusChildFieldCallback
forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsContainer a, IsWidget b) =>
FunPtr C_ContainerClassAddFieldCallback -> a -> Maybe b -> m ()
Gtk.Callbacks.dynamic_ContainerClassSetFocusChildFieldCallback FunPtr C_ContainerClassAddFieldCallback
val'
        ContainerClassSetFocusChildFieldCallback
-> IO ContainerClassSetFocusChildFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return ContainerClassSetFocusChildFieldCallback
val''
    Maybe ContainerClassSetFocusChildFieldCallback
-> IO (Maybe ContainerClassSetFocusChildFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ContainerClassSetFocusChildFieldCallback
result

-- | Set the value of the “@set_focus_child@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' containerClass [ #setFocusChild 'Data.GI.Base.Attributes.:=' value ]
-- @
setContainerClassSetFocusChild :: MonadIO m => ContainerClass -> FunPtr Gtk.Callbacks.C_ContainerClassSetFocusChildFieldCallback -> m ()
setContainerClassSetFocusChild :: ContainerClass -> FunPtr C_ContainerClassAddFieldCallback -> m ()
setContainerClassSetFocusChild ContainerClass
s FunPtr C_ContainerClassAddFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ContainerClass -> (Ptr ContainerClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ContainerClass
s ((Ptr ContainerClass -> IO ()) -> IO ())
-> (Ptr ContainerClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ContainerClass
ptr -> do
    Ptr (FunPtr C_ContainerClassAddFieldCallback)
-> FunPtr C_ContainerClassAddFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ContainerClass
ptr Ptr ContainerClass
-> Int -> Ptr (FunPtr C_ContainerClassAddFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
856) (FunPtr C_ContainerClassAddFieldCallback
val :: FunPtr Gtk.Callbacks.C_ContainerClassSetFocusChildFieldCallback)

-- | Set the value of the “@set_focus_child@” 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' #setFocusChild
-- @
clearContainerClassSetFocusChild :: MonadIO m => ContainerClass -> m ()
clearContainerClassSetFocusChild :: ContainerClass -> m ()
clearContainerClassSetFocusChild ContainerClass
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ContainerClass -> (Ptr ContainerClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ContainerClass
s ((Ptr ContainerClass -> IO ()) -> IO ())
-> (Ptr ContainerClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ContainerClass
ptr -> do
    Ptr (FunPtr C_ContainerClassAddFieldCallback)
-> FunPtr C_ContainerClassAddFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ContainerClass
ptr Ptr ContainerClass
-> Int -> Ptr (FunPtr C_ContainerClassAddFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
856) (FunPtr C_ContainerClassAddFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_ContainerClassSetFocusChildFieldCallback)

#if defined(ENABLE_OVERLOADING)
data ContainerClassSetFocusChildFieldInfo
instance AttrInfo ContainerClassSetFocusChildFieldInfo where
    type AttrBaseTypeConstraint ContainerClassSetFocusChildFieldInfo = (~) ContainerClass
    type AttrAllowedOps ContainerClassSetFocusChildFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ContainerClassSetFocusChildFieldInfo = (~) (FunPtr Gtk.Callbacks.C_ContainerClassSetFocusChildFieldCallback)
    type AttrTransferTypeConstraint ContainerClassSetFocusChildFieldInfo = (~)Gtk.Callbacks.ContainerClassSetFocusChildFieldCallback
    type AttrTransferType ContainerClassSetFocusChildFieldInfo = (FunPtr Gtk.Callbacks.C_ContainerClassSetFocusChildFieldCallback)
    type AttrGetType ContainerClassSetFocusChildFieldInfo = Maybe Gtk.Callbacks.ContainerClassSetFocusChildFieldCallback
    type AttrLabel ContainerClassSetFocusChildFieldInfo = "set_focus_child"
    type AttrOrigin ContainerClassSetFocusChildFieldInfo = ContainerClass
    attrGet = getContainerClassSetFocusChild
    attrSet = setContainerClassSetFocusChild
    attrConstruct = undefined
    attrClear = clearContainerClassSetFocusChild
    attrTransfer _ v = do
        Gtk.Callbacks.mk_ContainerClassSetFocusChildFieldCallback (Gtk.Callbacks.wrap_ContainerClassSetFocusChildFieldCallback Nothing v)

containerClass_setFocusChild :: AttrLabelProxy "setFocusChild"
containerClass_setFocusChild = AttrLabelProxy

#endif


-- | Get the value of the “@child_type@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' containerClass #childType
-- @
getContainerClassChildType :: MonadIO m => ContainerClass -> m (Maybe Gtk.Callbacks.ContainerClassChildTypeFieldCallback)
getContainerClassChildType :: ContainerClass -> m (Maybe ContainerClassChildTypeFieldCallback)
getContainerClassChildType ContainerClass
s = IO (Maybe ContainerClassChildTypeFieldCallback)
-> m (Maybe ContainerClassChildTypeFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe ContainerClassChildTypeFieldCallback)
 -> m (Maybe ContainerClassChildTypeFieldCallback))
-> IO (Maybe ContainerClassChildTypeFieldCallback)
-> m (Maybe ContainerClassChildTypeFieldCallback)
forall a b. (a -> b) -> a -> b
$ ContainerClass
-> (Ptr ContainerClass
    -> IO (Maybe ContainerClassChildTypeFieldCallback))
-> IO (Maybe ContainerClassChildTypeFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ContainerClass
s ((Ptr ContainerClass
  -> IO (Maybe ContainerClassChildTypeFieldCallback))
 -> IO (Maybe ContainerClassChildTypeFieldCallback))
-> (Ptr ContainerClass
    -> IO (Maybe ContainerClassChildTypeFieldCallback))
-> IO (Maybe ContainerClassChildTypeFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr ContainerClass
ptr -> do
    FunPtr C_ContainerClassChildTypeFieldCallback
val <- Ptr (FunPtr C_ContainerClassChildTypeFieldCallback)
-> IO (FunPtr C_ContainerClassChildTypeFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr ContainerClass
ptr Ptr ContainerClass
-> Int -> Ptr (FunPtr C_ContainerClassChildTypeFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
864) :: IO (FunPtr Gtk.Callbacks.C_ContainerClassChildTypeFieldCallback)
    Maybe ContainerClassChildTypeFieldCallback
result <- FunPtr C_ContainerClassChildTypeFieldCallback
-> (FunPtr C_ContainerClassChildTypeFieldCallback
    -> IO ContainerClassChildTypeFieldCallback)
-> IO (Maybe ContainerClassChildTypeFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_ContainerClassChildTypeFieldCallback
val ((FunPtr C_ContainerClassChildTypeFieldCallback
  -> IO ContainerClassChildTypeFieldCallback)
 -> IO (Maybe ContainerClassChildTypeFieldCallback))
-> (FunPtr C_ContainerClassChildTypeFieldCallback
    -> IO ContainerClassChildTypeFieldCallback)
-> IO (Maybe ContainerClassChildTypeFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_ContainerClassChildTypeFieldCallback
val' -> do
        let val'' :: ContainerClassChildTypeFieldCallback
val'' = FunPtr C_ContainerClassChildTypeFieldCallback
-> ContainerClassChildTypeFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsContainer a) =>
FunPtr C_ContainerClassChildTypeFieldCallback -> a -> m GType
Gtk.Callbacks.dynamic_ContainerClassChildTypeFieldCallback FunPtr C_ContainerClassChildTypeFieldCallback
val'
        ContainerClassChildTypeFieldCallback
-> IO ContainerClassChildTypeFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return ContainerClassChildTypeFieldCallback
val''
    Maybe ContainerClassChildTypeFieldCallback
-> IO (Maybe ContainerClassChildTypeFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ContainerClassChildTypeFieldCallback
result

-- | Set the value of the “@child_type@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' containerClass [ #childType 'Data.GI.Base.Attributes.:=' value ]
-- @
setContainerClassChildType :: MonadIO m => ContainerClass -> FunPtr Gtk.Callbacks.C_ContainerClassChildTypeFieldCallback -> m ()
setContainerClassChildType :: ContainerClass
-> FunPtr C_ContainerClassChildTypeFieldCallback -> m ()
setContainerClassChildType ContainerClass
s FunPtr C_ContainerClassChildTypeFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ContainerClass -> (Ptr ContainerClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ContainerClass
s ((Ptr ContainerClass -> IO ()) -> IO ())
-> (Ptr ContainerClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ContainerClass
ptr -> do
    Ptr (FunPtr C_ContainerClassChildTypeFieldCallback)
-> FunPtr C_ContainerClassChildTypeFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ContainerClass
ptr Ptr ContainerClass
-> Int -> Ptr (FunPtr C_ContainerClassChildTypeFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
864) (FunPtr C_ContainerClassChildTypeFieldCallback
val :: FunPtr Gtk.Callbacks.C_ContainerClassChildTypeFieldCallback)

-- | Set the value of the “@child_type@” 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' #childType
-- @
clearContainerClassChildType :: MonadIO m => ContainerClass -> m ()
clearContainerClassChildType :: ContainerClass -> m ()
clearContainerClassChildType ContainerClass
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ContainerClass -> (Ptr ContainerClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ContainerClass
s ((Ptr ContainerClass -> IO ()) -> IO ())
-> (Ptr ContainerClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ContainerClass
ptr -> do
    Ptr (FunPtr C_ContainerClassChildTypeFieldCallback)
-> FunPtr C_ContainerClassChildTypeFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ContainerClass
ptr Ptr ContainerClass
-> Int -> Ptr (FunPtr C_ContainerClassChildTypeFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
864) (FunPtr C_ContainerClassChildTypeFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_ContainerClassChildTypeFieldCallback)

#if defined(ENABLE_OVERLOADING)
data ContainerClassChildTypeFieldInfo
instance AttrInfo ContainerClassChildTypeFieldInfo where
    type AttrBaseTypeConstraint ContainerClassChildTypeFieldInfo = (~) ContainerClass
    type AttrAllowedOps ContainerClassChildTypeFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ContainerClassChildTypeFieldInfo = (~) (FunPtr Gtk.Callbacks.C_ContainerClassChildTypeFieldCallback)
    type AttrTransferTypeConstraint ContainerClassChildTypeFieldInfo = (~)Gtk.Callbacks.ContainerClassChildTypeFieldCallback
    type AttrTransferType ContainerClassChildTypeFieldInfo = (FunPtr Gtk.Callbacks.C_ContainerClassChildTypeFieldCallback)
    type AttrGetType ContainerClassChildTypeFieldInfo = Maybe Gtk.Callbacks.ContainerClassChildTypeFieldCallback
    type AttrLabel ContainerClassChildTypeFieldInfo = "child_type"
    type AttrOrigin ContainerClassChildTypeFieldInfo = ContainerClass
    attrGet = getContainerClassChildType
    attrSet = setContainerClassChildType
    attrConstruct = undefined
    attrClear = clearContainerClassChildType
    attrTransfer _ v = do
        Gtk.Callbacks.mk_ContainerClassChildTypeFieldCallback (Gtk.Callbacks.wrap_ContainerClassChildTypeFieldCallback Nothing v)

containerClass_childType :: AttrLabelProxy "childType"
containerClass_childType = AttrLabelProxy

#endif


-- | Get the value of the “@composite_name@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' containerClass #compositeName
-- @
getContainerClassCompositeName :: MonadIO m => ContainerClass -> m (Maybe Gtk.Callbacks.ContainerClassCompositeNameFieldCallback)
getContainerClassCompositeName :: ContainerClass
-> m (Maybe ContainerClassCompositeNameFieldCallback)
getContainerClassCompositeName ContainerClass
s = IO (Maybe ContainerClassCompositeNameFieldCallback)
-> m (Maybe ContainerClassCompositeNameFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe ContainerClassCompositeNameFieldCallback)
 -> m (Maybe ContainerClassCompositeNameFieldCallback))
-> IO (Maybe ContainerClassCompositeNameFieldCallback)
-> m (Maybe ContainerClassCompositeNameFieldCallback)
forall a b. (a -> b) -> a -> b
$ ContainerClass
-> (Ptr ContainerClass
    -> IO (Maybe ContainerClassCompositeNameFieldCallback))
-> IO (Maybe ContainerClassCompositeNameFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ContainerClass
s ((Ptr ContainerClass
  -> IO (Maybe ContainerClassCompositeNameFieldCallback))
 -> IO (Maybe ContainerClassCompositeNameFieldCallback))
-> (Ptr ContainerClass
    -> IO (Maybe ContainerClassCompositeNameFieldCallback))
-> IO (Maybe ContainerClassCompositeNameFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr ContainerClass
ptr -> do
    FunPtr C_ContainerClassCompositeNameFieldCallback
val <- Ptr (FunPtr C_ContainerClassCompositeNameFieldCallback)
-> IO (FunPtr C_ContainerClassCompositeNameFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr ContainerClass
ptr Ptr ContainerClass
-> Int -> Ptr (FunPtr C_ContainerClassCompositeNameFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
872) :: IO (FunPtr Gtk.Callbacks.C_ContainerClassCompositeNameFieldCallback)
    Maybe ContainerClassCompositeNameFieldCallback
result <- FunPtr C_ContainerClassCompositeNameFieldCallback
-> (FunPtr C_ContainerClassCompositeNameFieldCallback
    -> IO ContainerClassCompositeNameFieldCallback)
-> IO (Maybe ContainerClassCompositeNameFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_ContainerClassCompositeNameFieldCallback
val ((FunPtr C_ContainerClassCompositeNameFieldCallback
  -> IO ContainerClassCompositeNameFieldCallback)
 -> IO (Maybe ContainerClassCompositeNameFieldCallback))
-> (FunPtr C_ContainerClassCompositeNameFieldCallback
    -> IO ContainerClassCompositeNameFieldCallback)
-> IO (Maybe ContainerClassCompositeNameFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_ContainerClassCompositeNameFieldCallback
val' -> do
        let val'' :: ContainerClassCompositeNameFieldCallback
val'' = FunPtr C_ContainerClassCompositeNameFieldCallback
-> ContainerClassCompositeNameFieldCallback
forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsContainer a, IsWidget b) =>
FunPtr C_ContainerClassCompositeNameFieldCallback
-> a -> b -> m Text
Gtk.Callbacks.dynamic_ContainerClassCompositeNameFieldCallback FunPtr C_ContainerClassCompositeNameFieldCallback
val'
        ContainerClassCompositeNameFieldCallback
-> IO ContainerClassCompositeNameFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return ContainerClassCompositeNameFieldCallback
val''
    Maybe ContainerClassCompositeNameFieldCallback
-> IO (Maybe ContainerClassCompositeNameFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ContainerClassCompositeNameFieldCallback
result

-- | Set the value of the “@composite_name@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' containerClass [ #compositeName 'Data.GI.Base.Attributes.:=' value ]
-- @
setContainerClassCompositeName :: MonadIO m => ContainerClass -> FunPtr Gtk.Callbacks.C_ContainerClassCompositeNameFieldCallback -> m ()
setContainerClassCompositeName :: ContainerClass
-> FunPtr C_ContainerClassCompositeNameFieldCallback -> m ()
setContainerClassCompositeName ContainerClass
s FunPtr C_ContainerClassCompositeNameFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ContainerClass -> (Ptr ContainerClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ContainerClass
s ((Ptr ContainerClass -> IO ()) -> IO ())
-> (Ptr ContainerClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ContainerClass
ptr -> do
    Ptr (FunPtr C_ContainerClassCompositeNameFieldCallback)
-> FunPtr C_ContainerClassCompositeNameFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ContainerClass
ptr Ptr ContainerClass
-> Int -> Ptr (FunPtr C_ContainerClassCompositeNameFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
872) (FunPtr C_ContainerClassCompositeNameFieldCallback
val :: FunPtr Gtk.Callbacks.C_ContainerClassCompositeNameFieldCallback)

-- | Set the value of the “@composite_name@” 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' #compositeName
-- @
clearContainerClassCompositeName :: MonadIO m => ContainerClass -> m ()
clearContainerClassCompositeName :: ContainerClass -> m ()
clearContainerClassCompositeName ContainerClass
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ContainerClass -> (Ptr ContainerClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ContainerClass
s ((Ptr ContainerClass -> IO ()) -> IO ())
-> (Ptr ContainerClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ContainerClass
ptr -> do
    Ptr (FunPtr C_ContainerClassCompositeNameFieldCallback)
-> FunPtr C_ContainerClassCompositeNameFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ContainerClass
ptr Ptr ContainerClass
-> Int -> Ptr (FunPtr C_ContainerClassCompositeNameFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
872) (FunPtr C_ContainerClassCompositeNameFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_ContainerClassCompositeNameFieldCallback)

#if defined(ENABLE_OVERLOADING)
data ContainerClassCompositeNameFieldInfo
instance AttrInfo ContainerClassCompositeNameFieldInfo where
    type AttrBaseTypeConstraint ContainerClassCompositeNameFieldInfo = (~) ContainerClass
    type AttrAllowedOps ContainerClassCompositeNameFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ContainerClassCompositeNameFieldInfo = (~) (FunPtr Gtk.Callbacks.C_ContainerClassCompositeNameFieldCallback)
    type AttrTransferTypeConstraint ContainerClassCompositeNameFieldInfo = (~)Gtk.Callbacks.ContainerClassCompositeNameFieldCallback
    type AttrTransferType ContainerClassCompositeNameFieldInfo = (FunPtr Gtk.Callbacks.C_ContainerClassCompositeNameFieldCallback)
    type AttrGetType ContainerClassCompositeNameFieldInfo = Maybe Gtk.Callbacks.ContainerClassCompositeNameFieldCallback
    type AttrLabel ContainerClassCompositeNameFieldInfo = "composite_name"
    type AttrOrigin ContainerClassCompositeNameFieldInfo = ContainerClass
    attrGet = getContainerClassCompositeName
    attrSet = setContainerClassCompositeName
    attrConstruct = undefined
    attrClear = clearContainerClassCompositeName
    attrTransfer _ v = do
        Gtk.Callbacks.mk_ContainerClassCompositeNameFieldCallback (Gtk.Callbacks.wrap_ContainerClassCompositeNameFieldCallback Nothing v)

containerClass_compositeName :: AttrLabelProxy "compositeName"
containerClass_compositeName = AttrLabelProxy

#endif


-- | Get the value of the “@set_child_property@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' containerClass #setChildProperty
-- @
getContainerClassSetChildProperty :: MonadIO m => ContainerClass -> m (Maybe Gtk.Callbacks.ContainerClassSetChildPropertyFieldCallback)
getContainerClassSetChildProperty :: ContainerClass
-> m (Maybe ContainerClassSetChildPropertyFieldCallback)
getContainerClassSetChildProperty ContainerClass
s = IO (Maybe ContainerClassSetChildPropertyFieldCallback)
-> m (Maybe ContainerClassSetChildPropertyFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe ContainerClassSetChildPropertyFieldCallback)
 -> m (Maybe ContainerClassSetChildPropertyFieldCallback))
-> IO (Maybe ContainerClassSetChildPropertyFieldCallback)
-> m (Maybe ContainerClassSetChildPropertyFieldCallback)
forall a b. (a -> b) -> a -> b
$ ContainerClass
-> (Ptr ContainerClass
    -> IO (Maybe ContainerClassSetChildPropertyFieldCallback))
-> IO (Maybe ContainerClassSetChildPropertyFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ContainerClass
s ((Ptr ContainerClass
  -> IO (Maybe ContainerClassSetChildPropertyFieldCallback))
 -> IO (Maybe ContainerClassSetChildPropertyFieldCallback))
-> (Ptr ContainerClass
    -> IO (Maybe ContainerClassSetChildPropertyFieldCallback))
-> IO (Maybe ContainerClassSetChildPropertyFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr ContainerClass
ptr -> do
    FunPtr C_ContainerClassSetChildPropertyFieldCallback
val <- Ptr (FunPtr C_ContainerClassSetChildPropertyFieldCallback)
-> IO (FunPtr C_ContainerClassSetChildPropertyFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr ContainerClass
ptr Ptr ContainerClass
-> Int
-> Ptr (FunPtr C_ContainerClassSetChildPropertyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
880) :: IO (FunPtr Gtk.Callbacks.C_ContainerClassSetChildPropertyFieldCallback)
    Maybe ContainerClassSetChildPropertyFieldCallback
result <- FunPtr C_ContainerClassSetChildPropertyFieldCallback
-> (FunPtr C_ContainerClassSetChildPropertyFieldCallback
    -> IO ContainerClassSetChildPropertyFieldCallback)
-> IO (Maybe ContainerClassSetChildPropertyFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_ContainerClassSetChildPropertyFieldCallback
val ((FunPtr C_ContainerClassSetChildPropertyFieldCallback
  -> IO ContainerClassSetChildPropertyFieldCallback)
 -> IO (Maybe ContainerClassSetChildPropertyFieldCallback))
-> (FunPtr C_ContainerClassSetChildPropertyFieldCallback
    -> IO ContainerClassSetChildPropertyFieldCallback)
-> IO (Maybe ContainerClassSetChildPropertyFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_ContainerClassSetChildPropertyFieldCallback
val' -> do
        let val'' :: ContainerClassSetChildPropertyFieldCallback
val'' = FunPtr C_ContainerClassSetChildPropertyFieldCallback
-> ContainerClassSetChildPropertyFieldCallback
forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsContainer a, IsWidget b) =>
FunPtr C_ContainerClassSetChildPropertyFieldCallback
-> a -> b -> Word32 -> GValue -> GParamSpec -> m ()
Gtk.Callbacks.dynamic_ContainerClassSetChildPropertyFieldCallback FunPtr C_ContainerClassSetChildPropertyFieldCallback
val'
        ContainerClassSetChildPropertyFieldCallback
-> IO ContainerClassSetChildPropertyFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return ContainerClassSetChildPropertyFieldCallback
val''
    Maybe ContainerClassSetChildPropertyFieldCallback
-> IO (Maybe ContainerClassSetChildPropertyFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ContainerClassSetChildPropertyFieldCallback
result

-- | Set the value of the “@set_child_property@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' containerClass [ #setChildProperty 'Data.GI.Base.Attributes.:=' value ]
-- @
setContainerClassSetChildProperty :: MonadIO m => ContainerClass -> FunPtr Gtk.Callbacks.C_ContainerClassSetChildPropertyFieldCallback -> m ()
setContainerClassSetChildProperty :: ContainerClass
-> FunPtr C_ContainerClassSetChildPropertyFieldCallback -> m ()
setContainerClassSetChildProperty ContainerClass
s FunPtr C_ContainerClassSetChildPropertyFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ContainerClass -> (Ptr ContainerClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ContainerClass
s ((Ptr ContainerClass -> IO ()) -> IO ())
-> (Ptr ContainerClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ContainerClass
ptr -> do
    Ptr (FunPtr C_ContainerClassSetChildPropertyFieldCallback)
-> FunPtr C_ContainerClassSetChildPropertyFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ContainerClass
ptr Ptr ContainerClass
-> Int
-> Ptr (FunPtr C_ContainerClassSetChildPropertyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
880) (FunPtr C_ContainerClassSetChildPropertyFieldCallback
val :: FunPtr Gtk.Callbacks.C_ContainerClassSetChildPropertyFieldCallback)

-- | Set the value of the “@set_child_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' #setChildProperty
-- @
clearContainerClassSetChildProperty :: MonadIO m => ContainerClass -> m ()
clearContainerClassSetChildProperty :: ContainerClass -> m ()
clearContainerClassSetChildProperty ContainerClass
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ContainerClass -> (Ptr ContainerClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ContainerClass
s ((Ptr ContainerClass -> IO ()) -> IO ())
-> (Ptr ContainerClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ContainerClass
ptr -> do
    Ptr (FunPtr C_ContainerClassSetChildPropertyFieldCallback)
-> FunPtr C_ContainerClassSetChildPropertyFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ContainerClass
ptr Ptr ContainerClass
-> Int
-> Ptr (FunPtr C_ContainerClassSetChildPropertyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
880) (FunPtr C_ContainerClassSetChildPropertyFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_ContainerClassSetChildPropertyFieldCallback)

#if defined(ENABLE_OVERLOADING)
data ContainerClassSetChildPropertyFieldInfo
instance AttrInfo ContainerClassSetChildPropertyFieldInfo where
    type AttrBaseTypeConstraint ContainerClassSetChildPropertyFieldInfo = (~) ContainerClass
    type AttrAllowedOps ContainerClassSetChildPropertyFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ContainerClassSetChildPropertyFieldInfo = (~) (FunPtr Gtk.Callbacks.C_ContainerClassSetChildPropertyFieldCallback)
    type AttrTransferTypeConstraint ContainerClassSetChildPropertyFieldInfo = (~)Gtk.Callbacks.ContainerClassSetChildPropertyFieldCallback
    type AttrTransferType ContainerClassSetChildPropertyFieldInfo = (FunPtr Gtk.Callbacks.C_ContainerClassSetChildPropertyFieldCallback)
    type AttrGetType ContainerClassSetChildPropertyFieldInfo = Maybe Gtk.Callbacks.ContainerClassSetChildPropertyFieldCallback
    type AttrLabel ContainerClassSetChildPropertyFieldInfo = "set_child_property"
    type AttrOrigin ContainerClassSetChildPropertyFieldInfo = ContainerClass
    attrGet = getContainerClassSetChildProperty
    attrSet = setContainerClassSetChildProperty
    attrConstruct = undefined
    attrClear = clearContainerClassSetChildProperty
    attrTransfer _ v = do
        Gtk.Callbacks.mk_ContainerClassSetChildPropertyFieldCallback (Gtk.Callbacks.wrap_ContainerClassSetChildPropertyFieldCallback Nothing v)

containerClass_setChildProperty :: AttrLabelProxy "setChildProperty"
containerClass_setChildProperty = AttrLabelProxy

#endif


-- | Get the value of the “@get_child_property@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' containerClass #getChildProperty
-- @
getContainerClassGetChildProperty :: MonadIO m => ContainerClass -> m (Maybe Gtk.Callbacks.ContainerClassGetChildPropertyFieldCallback)
getContainerClassGetChildProperty :: ContainerClass
-> m (Maybe ContainerClassSetChildPropertyFieldCallback)
getContainerClassGetChildProperty ContainerClass
s = IO (Maybe ContainerClassSetChildPropertyFieldCallback)
-> m (Maybe ContainerClassSetChildPropertyFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe ContainerClassSetChildPropertyFieldCallback)
 -> m (Maybe ContainerClassSetChildPropertyFieldCallback))
-> IO (Maybe ContainerClassSetChildPropertyFieldCallback)
-> m (Maybe ContainerClassSetChildPropertyFieldCallback)
forall a b. (a -> b) -> a -> b
$ ContainerClass
-> (Ptr ContainerClass
    -> IO (Maybe ContainerClassSetChildPropertyFieldCallback))
-> IO (Maybe ContainerClassSetChildPropertyFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ContainerClass
s ((Ptr ContainerClass
  -> IO (Maybe ContainerClassSetChildPropertyFieldCallback))
 -> IO (Maybe ContainerClassSetChildPropertyFieldCallback))
-> (Ptr ContainerClass
    -> IO (Maybe ContainerClassSetChildPropertyFieldCallback))
-> IO (Maybe ContainerClassSetChildPropertyFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr ContainerClass
ptr -> do
    FunPtr C_ContainerClassSetChildPropertyFieldCallback
val <- Ptr (FunPtr C_ContainerClassSetChildPropertyFieldCallback)
-> IO (FunPtr C_ContainerClassSetChildPropertyFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr ContainerClass
ptr Ptr ContainerClass
-> Int
-> Ptr (FunPtr C_ContainerClassSetChildPropertyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
888) :: IO (FunPtr Gtk.Callbacks.C_ContainerClassGetChildPropertyFieldCallback)
    Maybe ContainerClassSetChildPropertyFieldCallback
result <- FunPtr C_ContainerClassSetChildPropertyFieldCallback
-> (FunPtr C_ContainerClassSetChildPropertyFieldCallback
    -> IO ContainerClassSetChildPropertyFieldCallback)
-> IO (Maybe ContainerClassSetChildPropertyFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_ContainerClassSetChildPropertyFieldCallback
val ((FunPtr C_ContainerClassSetChildPropertyFieldCallback
  -> IO ContainerClassSetChildPropertyFieldCallback)
 -> IO (Maybe ContainerClassSetChildPropertyFieldCallback))
-> (FunPtr C_ContainerClassSetChildPropertyFieldCallback
    -> IO ContainerClassSetChildPropertyFieldCallback)
-> IO (Maybe ContainerClassSetChildPropertyFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_ContainerClassSetChildPropertyFieldCallback
val' -> do
        let val'' :: ContainerClassSetChildPropertyFieldCallback
val'' = FunPtr C_ContainerClassSetChildPropertyFieldCallback
-> ContainerClassSetChildPropertyFieldCallback
forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsContainer a, IsWidget b) =>
FunPtr C_ContainerClassSetChildPropertyFieldCallback
-> a -> b -> Word32 -> GValue -> GParamSpec -> m ()
Gtk.Callbacks.dynamic_ContainerClassGetChildPropertyFieldCallback FunPtr C_ContainerClassSetChildPropertyFieldCallback
val'
        ContainerClassSetChildPropertyFieldCallback
-> IO ContainerClassSetChildPropertyFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return ContainerClassSetChildPropertyFieldCallback
val''
    Maybe ContainerClassSetChildPropertyFieldCallback
-> IO (Maybe ContainerClassSetChildPropertyFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ContainerClassSetChildPropertyFieldCallback
result

-- | Set the value of the “@get_child_property@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' containerClass [ #getChildProperty 'Data.GI.Base.Attributes.:=' value ]
-- @
setContainerClassGetChildProperty :: MonadIO m => ContainerClass -> FunPtr Gtk.Callbacks.C_ContainerClassGetChildPropertyFieldCallback -> m ()
setContainerClassGetChildProperty :: ContainerClass
-> FunPtr C_ContainerClassSetChildPropertyFieldCallback -> m ()
setContainerClassGetChildProperty ContainerClass
s FunPtr C_ContainerClassSetChildPropertyFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ContainerClass -> (Ptr ContainerClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ContainerClass
s ((Ptr ContainerClass -> IO ()) -> IO ())
-> (Ptr ContainerClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ContainerClass
ptr -> do
    Ptr (FunPtr C_ContainerClassSetChildPropertyFieldCallback)
-> FunPtr C_ContainerClassSetChildPropertyFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ContainerClass
ptr Ptr ContainerClass
-> Int
-> Ptr (FunPtr C_ContainerClassSetChildPropertyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
888) (FunPtr C_ContainerClassSetChildPropertyFieldCallback
val :: FunPtr Gtk.Callbacks.C_ContainerClassGetChildPropertyFieldCallback)

-- | Set the value of the “@get_child_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' #getChildProperty
-- @
clearContainerClassGetChildProperty :: MonadIO m => ContainerClass -> m ()
clearContainerClassGetChildProperty :: ContainerClass -> m ()
clearContainerClassGetChildProperty ContainerClass
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ContainerClass -> (Ptr ContainerClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ContainerClass
s ((Ptr ContainerClass -> IO ()) -> IO ())
-> (Ptr ContainerClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ContainerClass
ptr -> do
    Ptr (FunPtr C_ContainerClassSetChildPropertyFieldCallback)
-> FunPtr C_ContainerClassSetChildPropertyFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ContainerClass
ptr Ptr ContainerClass
-> Int
-> Ptr (FunPtr C_ContainerClassSetChildPropertyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
888) (FunPtr C_ContainerClassSetChildPropertyFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_ContainerClassGetChildPropertyFieldCallback)

#if defined(ENABLE_OVERLOADING)
data ContainerClassGetChildPropertyFieldInfo
instance AttrInfo ContainerClassGetChildPropertyFieldInfo where
    type AttrBaseTypeConstraint ContainerClassGetChildPropertyFieldInfo = (~) ContainerClass
    type AttrAllowedOps ContainerClassGetChildPropertyFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ContainerClassGetChildPropertyFieldInfo = (~) (FunPtr Gtk.Callbacks.C_ContainerClassGetChildPropertyFieldCallback)
    type AttrTransferTypeConstraint ContainerClassGetChildPropertyFieldInfo = (~)Gtk.Callbacks.ContainerClassGetChildPropertyFieldCallback
    type AttrTransferType ContainerClassGetChildPropertyFieldInfo = (FunPtr Gtk.Callbacks.C_ContainerClassGetChildPropertyFieldCallback)
    type AttrGetType ContainerClassGetChildPropertyFieldInfo = Maybe Gtk.Callbacks.ContainerClassGetChildPropertyFieldCallback
    type AttrLabel ContainerClassGetChildPropertyFieldInfo = "get_child_property"
    type AttrOrigin ContainerClassGetChildPropertyFieldInfo = ContainerClass
    attrGet = getContainerClassGetChildProperty
    attrSet = setContainerClassGetChildProperty
    attrConstruct = undefined
    attrClear = clearContainerClassGetChildProperty
    attrTransfer _ v = do
        Gtk.Callbacks.mk_ContainerClassGetChildPropertyFieldCallback (Gtk.Callbacks.wrap_ContainerClassGetChildPropertyFieldCallback Nothing v)

containerClass_getChildProperty :: AttrLabelProxy "getChildProperty"
containerClass_getChildProperty = AttrLabelProxy

#endif


-- | Get the value of the “@get_path_for_child@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' containerClass #getPathForChild
-- @
getContainerClassGetPathForChild :: MonadIO m => ContainerClass -> m (Maybe Gtk.Callbacks.ContainerClassGetPathForChildFieldCallback)
getContainerClassGetPathForChild :: ContainerClass
-> m (Maybe ContainerClassGetPathForChildFieldCallback)
getContainerClassGetPathForChild ContainerClass
s = IO (Maybe ContainerClassGetPathForChildFieldCallback)
-> m (Maybe ContainerClassGetPathForChildFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe ContainerClassGetPathForChildFieldCallback)
 -> m (Maybe ContainerClassGetPathForChildFieldCallback))
-> IO (Maybe ContainerClassGetPathForChildFieldCallback)
-> m (Maybe ContainerClassGetPathForChildFieldCallback)
forall a b. (a -> b) -> a -> b
$ ContainerClass
-> (Ptr ContainerClass
    -> IO (Maybe ContainerClassGetPathForChildFieldCallback))
-> IO (Maybe ContainerClassGetPathForChildFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ContainerClass
s ((Ptr ContainerClass
  -> IO (Maybe ContainerClassGetPathForChildFieldCallback))
 -> IO (Maybe ContainerClassGetPathForChildFieldCallback))
-> (Ptr ContainerClass
    -> IO (Maybe ContainerClassGetPathForChildFieldCallback))
-> IO (Maybe ContainerClassGetPathForChildFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr ContainerClass
ptr -> do
    FunPtr C_ContainerClassGetPathForChildFieldCallback
val <- Ptr (FunPtr C_ContainerClassGetPathForChildFieldCallback)
-> IO (FunPtr C_ContainerClassGetPathForChildFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr ContainerClass
ptr Ptr ContainerClass
-> Int -> Ptr (FunPtr C_ContainerClassGetPathForChildFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
896) :: IO (FunPtr Gtk.Callbacks.C_ContainerClassGetPathForChildFieldCallback)
    Maybe ContainerClassGetPathForChildFieldCallback
result <- FunPtr C_ContainerClassGetPathForChildFieldCallback
-> (FunPtr C_ContainerClassGetPathForChildFieldCallback
    -> IO ContainerClassGetPathForChildFieldCallback)
-> IO (Maybe ContainerClassGetPathForChildFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_ContainerClassGetPathForChildFieldCallback
val ((FunPtr C_ContainerClassGetPathForChildFieldCallback
  -> IO ContainerClassGetPathForChildFieldCallback)
 -> IO (Maybe ContainerClassGetPathForChildFieldCallback))
-> (FunPtr C_ContainerClassGetPathForChildFieldCallback
    -> IO ContainerClassGetPathForChildFieldCallback)
-> IO (Maybe ContainerClassGetPathForChildFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_ContainerClassGetPathForChildFieldCallback
val' -> do
        let val'' :: ContainerClassGetPathForChildFieldCallback
val'' = FunPtr C_ContainerClassGetPathForChildFieldCallback
-> ContainerClassGetPathForChildFieldCallback
forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsContainer a, IsWidget b) =>
FunPtr C_ContainerClassGetPathForChildFieldCallback
-> a -> b -> m WidgetPath
Gtk.Callbacks.dynamic_ContainerClassGetPathForChildFieldCallback FunPtr C_ContainerClassGetPathForChildFieldCallback
val'
        ContainerClassGetPathForChildFieldCallback
-> IO ContainerClassGetPathForChildFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return ContainerClassGetPathForChildFieldCallback
val''
    Maybe ContainerClassGetPathForChildFieldCallback
-> IO (Maybe ContainerClassGetPathForChildFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ContainerClassGetPathForChildFieldCallback
result

-- | Set the value of the “@get_path_for_child@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' containerClass [ #getPathForChild 'Data.GI.Base.Attributes.:=' value ]
-- @
setContainerClassGetPathForChild :: MonadIO m => ContainerClass -> FunPtr Gtk.Callbacks.C_ContainerClassGetPathForChildFieldCallback -> m ()
setContainerClassGetPathForChild :: ContainerClass
-> FunPtr C_ContainerClassGetPathForChildFieldCallback -> m ()
setContainerClassGetPathForChild ContainerClass
s FunPtr C_ContainerClassGetPathForChildFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ContainerClass -> (Ptr ContainerClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ContainerClass
s ((Ptr ContainerClass -> IO ()) -> IO ())
-> (Ptr ContainerClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ContainerClass
ptr -> do
    Ptr (FunPtr C_ContainerClassGetPathForChildFieldCallback)
-> FunPtr C_ContainerClassGetPathForChildFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ContainerClass
ptr Ptr ContainerClass
-> Int -> Ptr (FunPtr C_ContainerClassGetPathForChildFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
896) (FunPtr C_ContainerClassGetPathForChildFieldCallback
val :: FunPtr Gtk.Callbacks.C_ContainerClassGetPathForChildFieldCallback)

-- | Set the value of the “@get_path_for_child@” 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' #getPathForChild
-- @
clearContainerClassGetPathForChild :: MonadIO m => ContainerClass -> m ()
clearContainerClassGetPathForChild :: ContainerClass -> m ()
clearContainerClassGetPathForChild ContainerClass
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ContainerClass -> (Ptr ContainerClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ContainerClass
s ((Ptr ContainerClass -> IO ()) -> IO ())
-> (Ptr ContainerClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ContainerClass
ptr -> do
    Ptr (FunPtr C_ContainerClassGetPathForChildFieldCallback)
-> FunPtr C_ContainerClassGetPathForChildFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ContainerClass
ptr Ptr ContainerClass
-> Int -> Ptr (FunPtr C_ContainerClassGetPathForChildFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
896) (FunPtr C_ContainerClassGetPathForChildFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_ContainerClassGetPathForChildFieldCallback)

#if defined(ENABLE_OVERLOADING)
data ContainerClassGetPathForChildFieldInfo
instance AttrInfo ContainerClassGetPathForChildFieldInfo where
    type AttrBaseTypeConstraint ContainerClassGetPathForChildFieldInfo = (~) ContainerClass
    type AttrAllowedOps ContainerClassGetPathForChildFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ContainerClassGetPathForChildFieldInfo = (~) (FunPtr Gtk.Callbacks.C_ContainerClassGetPathForChildFieldCallback)
    type AttrTransferTypeConstraint ContainerClassGetPathForChildFieldInfo = (~)Gtk.Callbacks.ContainerClassGetPathForChildFieldCallback
    type AttrTransferType ContainerClassGetPathForChildFieldInfo = (FunPtr Gtk.Callbacks.C_ContainerClassGetPathForChildFieldCallback)
    type AttrGetType ContainerClassGetPathForChildFieldInfo = Maybe Gtk.Callbacks.ContainerClassGetPathForChildFieldCallback
    type AttrLabel ContainerClassGetPathForChildFieldInfo = "get_path_for_child"
    type AttrOrigin ContainerClassGetPathForChildFieldInfo = ContainerClass
    attrGet = getContainerClassGetPathForChild
    attrSet = setContainerClassGetPathForChild
    attrConstruct = undefined
    attrClear = clearContainerClassGetPathForChild
    attrTransfer _ v = do
        Gtk.Callbacks.mk_ContainerClassGetPathForChildFieldCallback (Gtk.Callbacks.wrap_ContainerClassGetPathForChildFieldCallback Nothing v)

containerClass_getPathForChild :: AttrLabelProxy "getPathForChild"
containerClass_getPathForChild = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList ContainerClass
type instance O.AttributeList ContainerClass = ContainerClassAttributeList
type ContainerClassAttributeList = ('[ '("parentClass", ContainerClassParentClassFieldInfo), '("add", ContainerClassAddFieldInfo), '("remove", ContainerClassRemoveFieldInfo), '("checkResize", ContainerClassCheckResizeFieldInfo), '("forall", ContainerClassForallFieldInfo), '("setFocusChild", ContainerClassSetFocusChildFieldInfo), '("childType", ContainerClassChildTypeFieldInfo), '("compositeName", ContainerClassCompositeNameFieldInfo), '("setChildProperty", ContainerClassSetChildPropertyFieldInfo), '("getChildProperty", ContainerClassGetChildPropertyFieldInfo), '("getPathForChild", ContainerClassGetPathForChildFieldInfo)] :: [(Symbol, *)])
#endif

-- method ContainerClass::find_child_property
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "cclass"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "ContainerClass" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkContainerClass"
--                 , 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 child property to find"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just TParamSpec
-- throws : False
-- Skip return : False

foreign import ccall "gtk_container_class_find_child_property" gtk_container_class_find_child_property :: 
    Ptr ContainerClass ->                   -- cclass : TInterface (Name {namespace = "Gtk", name = "ContainerClass"})
    CString ->                              -- property_name : TBasicType TUTF8
    IO (Ptr GParamSpec)

-- | Finds a child property of a container class by name.
containerClassFindChildProperty ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    ContainerClass
    -- ^ /@cclass@/: a t'GI.Gtk.Structs.ContainerClass.ContainerClass'
    -> T.Text
    -- ^ /@propertyName@/: the name of the child property to find
    -> m (Maybe GParamSpec)
    -- ^ __Returns:__ the t'GI.GObject.Objects.ParamSpec.ParamSpec' of the child
    --     property or 'P.Nothing' if /@class@/ has no child property with that
    --     name.
containerClassFindChildProperty :: ContainerClass -> Text -> m (Maybe GParamSpec)
containerClassFindChildProperty ContainerClass
cclass Text
propertyName = IO (Maybe GParamSpec) -> m (Maybe GParamSpec)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe GParamSpec) -> m (Maybe GParamSpec))
-> IO (Maybe GParamSpec) -> m (Maybe GParamSpec)
forall a b. (a -> b) -> a -> b
$ do
    Ptr ContainerClass
cclass' <- ContainerClass -> IO (Ptr ContainerClass)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr ContainerClass
cclass
    CString
propertyName' <- Text -> IO CString
textToCString Text
propertyName
    Ptr GParamSpec
result <- Ptr ContainerClass -> CString -> IO (Ptr GParamSpec)
gtk_container_class_find_child_property Ptr ContainerClass
cclass' CString
propertyName'
    Maybe GParamSpec
maybeResult <- Ptr GParamSpec
-> (Ptr GParamSpec -> IO GParamSpec) -> IO (Maybe GParamSpec)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr GParamSpec
result ((Ptr GParamSpec -> IO GParamSpec) -> IO (Maybe GParamSpec))
-> (Ptr GParamSpec -> IO GParamSpec) -> IO (Maybe GParamSpec)
forall a b. (a -> b) -> a -> b
$ \Ptr GParamSpec
result' -> do
        GParamSpec
result'' <- Ptr GParamSpec -> IO GParamSpec
B.GParamSpec.newGParamSpecFromPtr Ptr GParamSpec
result'
        GParamSpec -> IO GParamSpec
forall (m :: * -> *) a. Monad m => a -> m a
return GParamSpec
result''
    ContainerClass -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr ContainerClass
cclass
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
propertyName'
    Maybe GParamSpec -> IO (Maybe GParamSpec)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe GParamSpec
maybeResult

#if defined(ENABLE_OVERLOADING)
data ContainerClassFindChildPropertyMethodInfo
instance (signature ~ (T.Text -> m (Maybe GParamSpec)), MonadIO m) => O.MethodInfo ContainerClassFindChildPropertyMethodInfo ContainerClass signature where
    overloadedMethod = containerClassFindChildProperty

#endif

-- method ContainerClass::handle_border_width
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "klass"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "ContainerClass" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the class struct of a #GtkContainer subclass"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_container_class_handle_border_width" gtk_container_class_handle_border_width :: 
    Ptr ContainerClass ->                   -- klass : TInterface (Name {namespace = "Gtk", name = "ContainerClass"})
    IO ()

-- | Modifies a subclass of t'GI.Gtk.Structs.ContainerClass.ContainerClass' to automatically add and
-- remove the border-width setting on GtkContainer.  This allows the
-- subclass to ignore the border width in its size request and
-- allocate methods. The intent is for a subclass to invoke this
-- in its class_init function.
-- 
-- 'GI.Gtk.Structs.ContainerClass.containerClassHandleBorderWidth' is necessary because it
-- would break API too badly to make this behavior the default. So
-- subclasses must “opt in” to the parent class handling border_width
-- for them.
containerClassHandleBorderWidth ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    ContainerClass
    -- ^ /@klass@/: the class struct of a t'GI.Gtk.Objects.Container.Container' subclass
    -> m ()
containerClassHandleBorderWidth :: ContainerClass -> m ()
containerClassHandleBorderWidth ContainerClass
klass = 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 ContainerClass
klass' <- ContainerClass -> IO (Ptr ContainerClass)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr ContainerClass
klass
    Ptr ContainerClass -> IO ()
gtk_container_class_handle_border_width Ptr ContainerClass
klass'
    ContainerClass -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr ContainerClass
klass
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ContainerClassHandleBorderWidthMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo ContainerClassHandleBorderWidthMethodInfo ContainerClass signature where
    overloadedMethod = containerClassHandleBorderWidth

#endif

-- XXX Could not generate method ContainerClass::install_child_properties
-- Not implemented: Don't know how to pack C array of type TCArray False (-1) 1 TParamSpec
-- method ContainerClass::install_child_property
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "cclass"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "ContainerClass" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkContainerClass"
--                 , 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 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 property"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_container_class_install_child_property" gtk_container_class_install_child_property :: 
    Ptr ContainerClass ->                   -- cclass : TInterface (Name {namespace = "Gtk", name = "ContainerClass"})
    Word32 ->                               -- property_id : TBasicType TUInt
    Ptr GParamSpec ->                       -- pspec : TParamSpec
    IO ()

-- | Installs a child property on a container class.
containerClassInstallChildProperty ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    ContainerClass
    -- ^ /@cclass@/: a t'GI.Gtk.Structs.ContainerClass.ContainerClass'
    -> Word32
    -- ^ /@propertyId@/: the id for the property
    -> GParamSpec
    -- ^ /@pspec@/: the t'GI.GObject.Objects.ParamSpec.ParamSpec' for the property
    -> m ()
containerClassInstallChildProperty :: ContainerClass -> Word32 -> GParamSpec -> m ()
containerClassInstallChildProperty ContainerClass
cclass 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 ContainerClass
cclass' <- ContainerClass -> IO (Ptr ContainerClass)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr ContainerClass
cclass
    Ptr GParamSpec
pspec' <- GParamSpec -> IO (Ptr GParamSpec)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GParamSpec
pspec
    Ptr ContainerClass -> Word32 -> Ptr GParamSpec -> IO ()
gtk_container_class_install_child_property Ptr ContainerClass
cclass' Word32
propertyId Ptr GParamSpec
pspec'
    ContainerClass -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr ContainerClass
cclass
    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 ContainerClassInstallChildPropertyMethodInfo
instance (signature ~ (Word32 -> GParamSpec -> m ()), MonadIO m) => O.MethodInfo ContainerClassInstallChildPropertyMethodInfo ContainerClass signature where
    overloadedMethod = containerClassInstallChildProperty

#endif

-- XXX Could not generate method ContainerClass::list_child_properties
-- Not implemented: unpackCArray : Don't know how to unpack C Array of type TParamSpec
#if defined(ENABLE_OVERLOADING)
type family ResolveContainerClassMethod (t :: Symbol) (o :: *) :: * where
    ResolveContainerClassMethod "findChildProperty" o = ContainerClassFindChildPropertyMethodInfo
    ResolveContainerClassMethod "handleBorderWidth" o = ContainerClassHandleBorderWidthMethodInfo
    ResolveContainerClassMethod "installChildProperty" o = ContainerClassInstallChildPropertyMethodInfo
    ResolveContainerClassMethod l o = O.MethodResolutionFailed l o

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

#endif