{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gtk.Structs.ContainerClass
(
ContainerClass(..) ,
newZeroContainerClass ,
#if defined(ENABLE_OVERLOADING)
ResolveContainerClassMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
ContainerClassFindChildPropertyMethodInfo,
#endif
containerClassFindChildProperty ,
#if defined(ENABLE_OVERLOADING)
ContainerClassHandleBorderWidthMethodInfo,
#endif
containerClassHandleBorderWidth ,
#if defined(ENABLE_OVERLOADING)
ContainerClassInstallChildPropertyMethodInfo,
#endif
containerClassInstallChildProperty ,
clearContainerClassAdd ,
#if defined(ENABLE_OVERLOADING)
containerClass_add ,
#endif
getContainerClassAdd ,
setContainerClassAdd ,
clearContainerClassCheckResize ,
#if defined(ENABLE_OVERLOADING)
containerClass_checkResize ,
#endif
getContainerClassCheckResize ,
setContainerClassCheckResize ,
clearContainerClassChildType ,
#if defined(ENABLE_OVERLOADING)
containerClass_childType ,
#endif
getContainerClassChildType ,
setContainerClassChildType ,
clearContainerClassCompositeName ,
#if defined(ENABLE_OVERLOADING)
containerClass_compositeName ,
#endif
getContainerClassCompositeName ,
setContainerClassCompositeName ,
clearContainerClassForall ,
#if defined(ENABLE_OVERLOADING)
containerClass_forall ,
#endif
getContainerClassForall ,
setContainerClassForall ,
clearContainerClassGetChildProperty ,
#if defined(ENABLE_OVERLOADING)
containerClass_getChildProperty ,
#endif
getContainerClassGetChildProperty ,
setContainerClassGetChildProperty ,
clearContainerClassGetPathForChild ,
#if defined(ENABLE_OVERLOADING)
containerClass_getPathForChild ,
#endif
getContainerClassGetPathForChild ,
setContainerClassGetPathForChild ,
#if defined(ENABLE_OVERLOADING)
containerClass_parentClass ,
#endif
getContainerClassParentClass ,
clearContainerClassRemove ,
#if defined(ENABLE_OVERLOADING)
containerClass_remove ,
#endif
getContainerClassRemove ,
setContainerClassRemove ,
clearContainerClassSetChildProperty ,
#if defined(ENABLE_OVERLOADING)
containerClass_setChildProperty ,
#endif
getContainerClassSetChildProperty ,
setContainerClassSetChildProperty ,
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.GHashTable as B.GHT
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.Kind as DK
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R
import qualified GI.Gtk.Callbacks as Gtk.Callbacks
import {-# SOURCE #-} qualified GI.Gtk.Structs.WidgetClass as Gtk.WidgetClass
newtype ContainerClass = ContainerClass (SP.ManagedPtr ContainerClass)
deriving (ContainerClass -> ContainerClass -> Bool
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 -> forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr ContainerClass
p (forall a. (HasCallStack, CallocPtr a) => Int -> Ptr a -> IO (Ptr a)
copyBytes Int
976 forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.wrapPtr ManagedPtr ContainerClass -> ContainerClass
ContainerClass)
boxedPtrFree :: ContainerClass -> IO ()
boxedPtrFree = \ContainerClass
x -> forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
SP.withManagedPtr ContainerClass
x forall a. Ptr a -> IO ()
SP.freeMem
instance CallocPtr ContainerClass where
boxedPtrCalloc :: IO (Ptr ContainerClass)
boxedPtrCalloc = forall a. Int -> IO (Ptr a)
callocBytes Int
976
newZeroContainerClass :: MonadIO m => m ContainerClass
newZeroContainerClass :: forall (m :: * -> *). MonadIO m => m ContainerClass
newZeroContainerClass = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a. CallocPtr a => IO (Ptr a)
boxedPtrCalloc forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr ContainerClass -> ContainerClass
ContainerClass
instance tag ~ 'AttrSet => Constructible ContainerClass tag where
new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr ContainerClass -> ContainerClass)
-> [AttrOp ContainerClass tag] -> m ContainerClass
new ManagedPtr ContainerClass -> ContainerClass
_ [AttrOp ContainerClass tag]
attrs = do
ContainerClass
o <- forall (m :: * -> *). MonadIO m => m ContainerClass
newZeroContainerClass
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set ContainerClass
o [AttrOp ContainerClass tag]
attrs
forall (m :: * -> *) a. Monad m => a -> m a
return ContainerClass
o
getContainerClassParentClass :: MonadIO m => ContainerClass -> m Gtk.WidgetClass.WidgetClass
getContainerClassParentClass :: forall (m :: * -> *). MonadIO m => ContainerClass -> m WidgetClass
getContainerClassParentClass ContainerClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ContainerClass
s forall a b. (a -> b) -> a -> b
$ \Ptr ContainerClass
ptr -> do
let val :: Ptr WidgetClass
val = Ptr ContainerClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0 :: (Ptr Gtk.WidgetClass.WidgetClass)
WidgetClass
val' <- (forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr WidgetClass -> WidgetClass
Gtk.WidgetClass.WidgetClass) Ptr WidgetClass
val
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
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.ContainerClass.parentClass"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-ContainerClass.html#g:attr:parentClass"
})
containerClass_parentClass :: AttrLabelProxy "parentClass"
containerClass_parentClass = AttrLabelProxy
#endif
getContainerClassAdd :: MonadIO m => ContainerClass -> m (Maybe Gtk.Callbacks.ContainerClassAddFieldCallback)
getContainerClassAdd :: forall (m :: * -> *).
MonadIO m =>
ContainerClass -> m (Maybe ContainerClassAddFieldCallback)
getContainerClassAdd ContainerClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ContainerClass
s forall a b. (a -> b) -> a -> b
$ \Ptr ContainerClass
ptr -> do
FunPtr C_ContainerClassAddFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr ContainerClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
824) :: IO (FunPtr Gtk.Callbacks.C_ContainerClassAddFieldCallback)
Maybe ContainerClassAddFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_ContainerClassAddFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_ContainerClassAddFieldCallback
val' -> do
let val'' :: ContainerClassAddFieldCallback
val'' = 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'
forall (m :: * -> *) a. Monad m => a -> m a
return ContainerClassAddFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ContainerClassAddFieldCallback
result
setContainerClassAdd :: MonadIO m => ContainerClass -> FunPtr Gtk.Callbacks.C_ContainerClassAddFieldCallback -> m ()
setContainerClassAdd :: forall (m :: * -> *).
MonadIO m =>
ContainerClass -> FunPtr C_ContainerClassAddFieldCallback -> m ()
setContainerClassAdd ContainerClass
s FunPtr C_ContainerClassAddFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ContainerClass
s forall a b. (a -> b) -> a -> b
$ \Ptr ContainerClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ContainerClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
824) (FunPtr C_ContainerClassAddFieldCallback
val :: FunPtr Gtk.Callbacks.C_ContainerClassAddFieldCallback)
clearContainerClassAdd :: MonadIO m => ContainerClass -> m ()
clearContainerClassAdd :: forall (m :: * -> *). MonadIO m => ContainerClass -> m ()
clearContainerClassAdd ContainerClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ContainerClass
s forall a b. (a -> b) -> a -> b
$ \Ptr ContainerClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ContainerClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
824) (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)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.ContainerClass.add"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-ContainerClass.html#g:attr:add"
})
containerClass_add :: AttrLabelProxy "add"
containerClass_add = AttrLabelProxy
#endif
getContainerClassRemove :: MonadIO m => ContainerClass -> m (Maybe Gtk.Callbacks.ContainerClassRemoveFieldCallback)
getContainerClassRemove :: forall (m :: * -> *).
MonadIO m =>
ContainerClass -> m (Maybe ContainerClassAddFieldCallback)
getContainerClassRemove ContainerClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ContainerClass
s forall a b. (a -> b) -> a -> b
$ \Ptr ContainerClass
ptr -> do
FunPtr C_ContainerClassAddFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr ContainerClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
832) :: IO (FunPtr Gtk.Callbacks.C_ContainerClassRemoveFieldCallback)
Maybe ContainerClassAddFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_ContainerClassAddFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_ContainerClassAddFieldCallback
val' -> do
let val'' :: ContainerClassAddFieldCallback
val'' = 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'
forall (m :: * -> *) a. Monad m => a -> m a
return ContainerClassAddFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ContainerClassAddFieldCallback
result
setContainerClassRemove :: MonadIO m => ContainerClass -> FunPtr Gtk.Callbacks.C_ContainerClassRemoveFieldCallback -> m ()
setContainerClassRemove :: forall (m :: * -> *).
MonadIO m =>
ContainerClass -> FunPtr C_ContainerClassAddFieldCallback -> m ()
setContainerClassRemove ContainerClass
s FunPtr C_ContainerClassAddFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ContainerClass
s forall a b. (a -> b) -> a -> b
$ \Ptr ContainerClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ContainerClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
832) (FunPtr C_ContainerClassAddFieldCallback
val :: FunPtr Gtk.Callbacks.C_ContainerClassRemoveFieldCallback)
clearContainerClassRemove :: MonadIO m => ContainerClass -> m ()
clearContainerClassRemove :: forall (m :: * -> *). MonadIO m => ContainerClass -> m ()
clearContainerClassRemove ContainerClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ContainerClass
s forall a b. (a -> b) -> a -> b
$ \Ptr ContainerClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ContainerClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
832) (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)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.ContainerClass.remove"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-ContainerClass.html#g:attr:remove"
})
containerClass_remove :: AttrLabelProxy "remove"
containerClass_remove = AttrLabelProxy
#endif
getContainerClassCheckResize :: MonadIO m => ContainerClass -> m (Maybe Gtk.Callbacks.ContainerClassCheckResizeFieldCallback)
getContainerClassCheckResize :: forall (m :: * -> *).
MonadIO m =>
ContainerClass -> m (Maybe ContainerClassCheckResizeFieldCallback)
getContainerClassCheckResize ContainerClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ContainerClass
s forall a b. (a -> b) -> a -> b
$ \Ptr ContainerClass
ptr -> do
FunPtr C_ContainerClassCheckResizeFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr ContainerClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
840) :: IO (FunPtr Gtk.Callbacks.C_ContainerClassCheckResizeFieldCallback)
Maybe ContainerClassCheckResizeFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_ContainerClassCheckResizeFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_ContainerClassCheckResizeFieldCallback
val' -> do
let val'' :: ContainerClassCheckResizeFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsContainer a) =>
FunPtr C_ContainerClassCheckResizeFieldCallback -> a -> m ()
Gtk.Callbacks.dynamic_ContainerClassCheckResizeFieldCallback FunPtr C_ContainerClassCheckResizeFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return ContainerClassCheckResizeFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ContainerClassCheckResizeFieldCallback
result
setContainerClassCheckResize :: MonadIO m => ContainerClass -> FunPtr Gtk.Callbacks.C_ContainerClassCheckResizeFieldCallback -> m ()
setContainerClassCheckResize :: forall (m :: * -> *).
MonadIO m =>
ContainerClass
-> FunPtr C_ContainerClassCheckResizeFieldCallback -> m ()
setContainerClassCheckResize ContainerClass
s FunPtr C_ContainerClassCheckResizeFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ContainerClass
s forall a b. (a -> b) -> a -> b
$ \Ptr ContainerClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ContainerClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
840) (FunPtr C_ContainerClassCheckResizeFieldCallback
val :: FunPtr Gtk.Callbacks.C_ContainerClassCheckResizeFieldCallback)
clearContainerClassCheckResize :: MonadIO m => ContainerClass -> m ()
clearContainerClassCheckResize :: forall (m :: * -> *). MonadIO m => ContainerClass -> m ()
clearContainerClassCheckResize ContainerClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ContainerClass
s forall a b. (a -> b) -> a -> b
$ \Ptr ContainerClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ContainerClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
840) (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)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.ContainerClass.checkResize"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-ContainerClass.html#g:attr:checkResize"
})
containerClass_checkResize :: AttrLabelProxy "checkResize"
containerClass_checkResize = AttrLabelProxy
#endif
getContainerClassForall :: MonadIO m => ContainerClass -> m (Maybe Gtk.Callbacks.ContainerClassForallFieldCallback_WithClosures)
getContainerClassForall :: forall (m :: * -> *).
MonadIO m =>
ContainerClass
-> m (Maybe ContainerClassForallFieldCallback_WithClosures)
getContainerClassForall ContainerClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ContainerClass
s forall a b. (a -> b) -> a -> b
$ \Ptr ContainerClass
ptr -> do
FunPtr C_ContainerClassForallFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr ContainerClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
848) :: IO (FunPtr Gtk.Callbacks.C_ContainerClassForallFieldCallback)
Maybe ContainerClassForallFieldCallback_WithClosures
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_ContainerClassForallFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_ContainerClassForallFieldCallback
val' -> do
let val'' :: ContainerClassForallFieldCallback_WithClosures
val'' = 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'
forall (m :: * -> *) a. Monad m => a -> m a
return ContainerClassForallFieldCallback_WithClosures
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ContainerClassForallFieldCallback_WithClosures
result
setContainerClassForall :: MonadIO m => ContainerClass -> FunPtr Gtk.Callbacks.C_ContainerClassForallFieldCallback -> m ()
setContainerClassForall :: forall (m :: * -> *).
MonadIO m =>
ContainerClass
-> FunPtr C_ContainerClassForallFieldCallback -> m ()
setContainerClassForall ContainerClass
s FunPtr C_ContainerClassForallFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ContainerClass
s forall a b. (a -> b) -> a -> b
$ \Ptr ContainerClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ContainerClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
848) (FunPtr C_ContainerClassForallFieldCallback
val :: FunPtr Gtk.Callbacks.C_ContainerClassForallFieldCallback)
clearContainerClassForall :: MonadIO m => ContainerClass -> m ()
clearContainerClassForall :: forall (m :: * -> *). MonadIO m => ContainerClass -> m ()
clearContainerClassForall ContainerClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ContainerClass
s forall a b. (a -> b) -> a -> b
$ \Ptr ContainerClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ContainerClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
848) (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)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.ContainerClass.forall"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-ContainerClass.html#g:attr:forall"
})
containerClass_forall :: AttrLabelProxy "forall"
containerClass_forall = AttrLabelProxy
#endif
getContainerClassSetFocusChild :: MonadIO m => ContainerClass -> m (Maybe Gtk.Callbacks.ContainerClassSetFocusChildFieldCallback)
getContainerClassSetFocusChild :: forall (m :: * -> *).
MonadIO m =>
ContainerClass
-> m (Maybe ContainerClassSetFocusChildFieldCallback)
getContainerClassSetFocusChild ContainerClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ContainerClass
s forall a b. (a -> b) -> a -> b
$ \Ptr ContainerClass
ptr -> do
FunPtr C_ContainerClassAddFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr ContainerClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
856) :: IO (FunPtr Gtk.Callbacks.C_ContainerClassSetFocusChildFieldCallback)
Maybe ContainerClassSetFocusChildFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_ContainerClassAddFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_ContainerClassAddFieldCallback
val' -> do
let val'' :: ContainerClassSetFocusChildFieldCallback
val'' = 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'
forall (m :: * -> *) a. Monad m => a -> m a
return ContainerClassSetFocusChildFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ContainerClassSetFocusChildFieldCallback
result
setContainerClassSetFocusChild :: MonadIO m => ContainerClass -> FunPtr Gtk.Callbacks.C_ContainerClassSetFocusChildFieldCallback -> m ()
setContainerClassSetFocusChild :: forall (m :: * -> *).
MonadIO m =>
ContainerClass -> FunPtr C_ContainerClassAddFieldCallback -> m ()
setContainerClassSetFocusChild ContainerClass
s FunPtr C_ContainerClassAddFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ContainerClass
s forall a b. (a -> b) -> a -> b
$ \Ptr ContainerClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ContainerClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
856) (FunPtr C_ContainerClassAddFieldCallback
val :: FunPtr Gtk.Callbacks.C_ContainerClassSetFocusChildFieldCallback)
clearContainerClassSetFocusChild :: MonadIO m => ContainerClass -> m ()
clearContainerClassSetFocusChild :: forall (m :: * -> *). MonadIO m => ContainerClass -> m ()
clearContainerClassSetFocusChild ContainerClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ContainerClass
s forall a b. (a -> b) -> a -> b
$ \Ptr ContainerClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ContainerClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
856) (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)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.ContainerClass.setFocusChild"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-ContainerClass.html#g:attr:setFocusChild"
})
containerClass_setFocusChild :: AttrLabelProxy "setFocusChild"
containerClass_setFocusChild = AttrLabelProxy
#endif
getContainerClassChildType :: MonadIO m => ContainerClass -> m (Maybe Gtk.Callbacks.ContainerClassChildTypeFieldCallback)
getContainerClassChildType :: forall (m :: * -> *).
MonadIO m =>
ContainerClass -> m (Maybe ContainerClassChildTypeFieldCallback)
getContainerClassChildType ContainerClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ContainerClass
s forall a b. (a -> b) -> a -> b
$ \Ptr ContainerClass
ptr -> do
FunPtr C_ContainerClassChildTypeFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr ContainerClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
864) :: IO (FunPtr Gtk.Callbacks.C_ContainerClassChildTypeFieldCallback)
Maybe ContainerClassChildTypeFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_ContainerClassChildTypeFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_ContainerClassChildTypeFieldCallback
val' -> do
let val'' :: ContainerClassChildTypeFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsContainer a) =>
FunPtr C_ContainerClassChildTypeFieldCallback -> a -> m GType
Gtk.Callbacks.dynamic_ContainerClassChildTypeFieldCallback FunPtr C_ContainerClassChildTypeFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return ContainerClassChildTypeFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ContainerClassChildTypeFieldCallback
result
setContainerClassChildType :: MonadIO m => ContainerClass -> FunPtr Gtk.Callbacks.C_ContainerClassChildTypeFieldCallback -> m ()
setContainerClassChildType :: forall (m :: * -> *).
MonadIO m =>
ContainerClass
-> FunPtr C_ContainerClassChildTypeFieldCallback -> m ()
setContainerClassChildType ContainerClass
s FunPtr C_ContainerClassChildTypeFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ContainerClass
s forall a b. (a -> b) -> a -> b
$ \Ptr ContainerClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ContainerClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
864) (FunPtr C_ContainerClassChildTypeFieldCallback
val :: FunPtr Gtk.Callbacks.C_ContainerClassChildTypeFieldCallback)
clearContainerClassChildType :: MonadIO m => ContainerClass -> m ()
clearContainerClassChildType :: forall (m :: * -> *). MonadIO m => ContainerClass -> m ()
clearContainerClassChildType ContainerClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ContainerClass
s forall a b. (a -> b) -> a -> b
$ \Ptr ContainerClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ContainerClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
864) (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)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.ContainerClass.childType"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-ContainerClass.html#g:attr:childType"
})
containerClass_childType :: AttrLabelProxy "childType"
containerClass_childType = AttrLabelProxy
#endif
getContainerClassCompositeName :: MonadIO m => ContainerClass -> m (Maybe Gtk.Callbacks.ContainerClassCompositeNameFieldCallback)
getContainerClassCompositeName :: forall (m :: * -> *).
MonadIO m =>
ContainerClass
-> m (Maybe ContainerClassCompositeNameFieldCallback)
getContainerClassCompositeName ContainerClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ContainerClass
s forall a b. (a -> b) -> a -> b
$ \Ptr ContainerClass
ptr -> do
FunPtr C_ContainerClassCompositeNameFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr ContainerClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
872) :: IO (FunPtr Gtk.Callbacks.C_ContainerClassCompositeNameFieldCallback)
Maybe ContainerClassCompositeNameFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_ContainerClassCompositeNameFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_ContainerClassCompositeNameFieldCallback
val' -> do
let val'' :: ContainerClassCompositeNameFieldCallback
val'' = 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'
forall (m :: * -> *) a. Monad m => a -> m a
return ContainerClassCompositeNameFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ContainerClassCompositeNameFieldCallback
result
setContainerClassCompositeName :: MonadIO m => ContainerClass -> FunPtr Gtk.Callbacks.C_ContainerClassCompositeNameFieldCallback -> m ()
setContainerClassCompositeName :: forall (m :: * -> *).
MonadIO m =>
ContainerClass
-> FunPtr C_ContainerClassCompositeNameFieldCallback -> m ()
setContainerClassCompositeName ContainerClass
s FunPtr C_ContainerClassCompositeNameFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ContainerClass
s forall a b. (a -> b) -> a -> b
$ \Ptr ContainerClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ContainerClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
872) (FunPtr C_ContainerClassCompositeNameFieldCallback
val :: FunPtr Gtk.Callbacks.C_ContainerClassCompositeNameFieldCallback)
clearContainerClassCompositeName :: MonadIO m => ContainerClass -> m ()
clearContainerClassCompositeName :: forall (m :: * -> *). MonadIO m => ContainerClass -> m ()
clearContainerClassCompositeName ContainerClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ContainerClass
s forall a b. (a -> b) -> a -> b
$ \Ptr ContainerClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ContainerClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
872) (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)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.ContainerClass.compositeName"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-ContainerClass.html#g:attr:compositeName"
})
containerClass_compositeName :: AttrLabelProxy "compositeName"
containerClass_compositeName = AttrLabelProxy
#endif
getContainerClassSetChildProperty :: MonadIO m => ContainerClass -> m (Maybe Gtk.Callbacks.ContainerClassSetChildPropertyFieldCallback)
getContainerClassSetChildProperty :: forall (m :: * -> *).
MonadIO m =>
ContainerClass
-> m (Maybe ContainerClassSetChildPropertyFieldCallback)
getContainerClassSetChildProperty ContainerClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ContainerClass
s forall a b. (a -> b) -> a -> b
$ \Ptr ContainerClass
ptr -> do
FunPtr C_ContainerClassSetChildPropertyFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr ContainerClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
880) :: IO (FunPtr Gtk.Callbacks.C_ContainerClassSetChildPropertyFieldCallback)
Maybe ContainerClassSetChildPropertyFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_ContainerClassSetChildPropertyFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_ContainerClassSetChildPropertyFieldCallback
val' -> do
let val'' :: ContainerClassSetChildPropertyFieldCallback
val'' = 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'
forall (m :: * -> *) a. Monad m => a -> m a
return ContainerClassSetChildPropertyFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ContainerClassSetChildPropertyFieldCallback
result
setContainerClassSetChildProperty :: MonadIO m => ContainerClass -> FunPtr Gtk.Callbacks.C_ContainerClassSetChildPropertyFieldCallback -> m ()
setContainerClassSetChildProperty :: forall (m :: * -> *).
MonadIO m =>
ContainerClass
-> FunPtr C_ContainerClassSetChildPropertyFieldCallback -> m ()
setContainerClassSetChildProperty ContainerClass
s FunPtr C_ContainerClassSetChildPropertyFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ContainerClass
s forall a b. (a -> b) -> a -> b
$ \Ptr ContainerClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ContainerClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
880) (FunPtr C_ContainerClassSetChildPropertyFieldCallback
val :: FunPtr Gtk.Callbacks.C_ContainerClassSetChildPropertyFieldCallback)
clearContainerClassSetChildProperty :: MonadIO m => ContainerClass -> m ()
clearContainerClassSetChildProperty :: forall (m :: * -> *). MonadIO m => ContainerClass -> m ()
clearContainerClassSetChildProperty ContainerClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ContainerClass
s forall a b. (a -> b) -> a -> b
$ \Ptr ContainerClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ContainerClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
880) (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)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.ContainerClass.setChildProperty"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-ContainerClass.html#g:attr:setChildProperty"
})
containerClass_setChildProperty :: AttrLabelProxy "setChildProperty"
containerClass_setChildProperty = AttrLabelProxy
#endif
getContainerClassGetChildProperty :: MonadIO m => ContainerClass -> m (Maybe Gtk.Callbacks.ContainerClassGetChildPropertyFieldCallback)
getContainerClassGetChildProperty :: forall (m :: * -> *).
MonadIO m =>
ContainerClass
-> m (Maybe ContainerClassSetChildPropertyFieldCallback)
getContainerClassGetChildProperty ContainerClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ContainerClass
s forall a b. (a -> b) -> a -> b
$ \Ptr ContainerClass
ptr -> do
FunPtr C_ContainerClassSetChildPropertyFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr ContainerClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
888) :: IO (FunPtr Gtk.Callbacks.C_ContainerClassGetChildPropertyFieldCallback)
Maybe ContainerClassSetChildPropertyFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_ContainerClassSetChildPropertyFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_ContainerClassSetChildPropertyFieldCallback
val' -> do
let val'' :: ContainerClassSetChildPropertyFieldCallback
val'' = 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'
forall (m :: * -> *) a. Monad m => a -> m a
return ContainerClassSetChildPropertyFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ContainerClassSetChildPropertyFieldCallback
result
setContainerClassGetChildProperty :: MonadIO m => ContainerClass -> FunPtr Gtk.Callbacks.C_ContainerClassGetChildPropertyFieldCallback -> m ()
setContainerClassGetChildProperty :: forall (m :: * -> *).
MonadIO m =>
ContainerClass
-> FunPtr C_ContainerClassSetChildPropertyFieldCallback -> m ()
setContainerClassGetChildProperty ContainerClass
s FunPtr C_ContainerClassSetChildPropertyFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ContainerClass
s forall a b. (a -> b) -> a -> b
$ \Ptr ContainerClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ContainerClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
888) (FunPtr C_ContainerClassSetChildPropertyFieldCallback
val :: FunPtr Gtk.Callbacks.C_ContainerClassGetChildPropertyFieldCallback)
clearContainerClassGetChildProperty :: MonadIO m => ContainerClass -> m ()
clearContainerClassGetChildProperty :: forall (m :: * -> *). MonadIO m => ContainerClass -> m ()
clearContainerClassGetChildProperty ContainerClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ContainerClass
s forall a b. (a -> b) -> a -> b
$ \Ptr ContainerClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ContainerClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
888) (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)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.ContainerClass.getChildProperty"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-ContainerClass.html#g:attr:getChildProperty"
})
containerClass_getChildProperty :: AttrLabelProxy "getChildProperty"
containerClass_getChildProperty = AttrLabelProxy
#endif
getContainerClassGetPathForChild :: MonadIO m => ContainerClass -> m (Maybe Gtk.Callbacks.ContainerClassGetPathForChildFieldCallback)
getContainerClassGetPathForChild :: forall (m :: * -> *).
MonadIO m =>
ContainerClass
-> m (Maybe ContainerClassGetPathForChildFieldCallback)
getContainerClassGetPathForChild ContainerClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ContainerClass
s forall a b. (a -> b) -> a -> b
$ \Ptr ContainerClass
ptr -> do
FunPtr C_ContainerClassGetPathForChildFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr ContainerClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
896) :: IO (FunPtr Gtk.Callbacks.C_ContainerClassGetPathForChildFieldCallback)
Maybe ContainerClassGetPathForChildFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_ContainerClassGetPathForChildFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_ContainerClassGetPathForChildFieldCallback
val' -> do
let val'' :: ContainerClassGetPathForChildFieldCallback
val'' = 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'
forall (m :: * -> *) a. Monad m => a -> m a
return ContainerClassGetPathForChildFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ContainerClassGetPathForChildFieldCallback
result
setContainerClassGetPathForChild :: MonadIO m => ContainerClass -> FunPtr Gtk.Callbacks.C_ContainerClassGetPathForChildFieldCallback -> m ()
setContainerClassGetPathForChild :: forall (m :: * -> *).
MonadIO m =>
ContainerClass
-> FunPtr C_ContainerClassGetPathForChildFieldCallback -> m ()
setContainerClassGetPathForChild ContainerClass
s FunPtr C_ContainerClassGetPathForChildFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ContainerClass
s forall a b. (a -> b) -> a -> b
$ \Ptr ContainerClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ContainerClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
896) (FunPtr C_ContainerClassGetPathForChildFieldCallback
val :: FunPtr Gtk.Callbacks.C_ContainerClassGetPathForChildFieldCallback)
clearContainerClassGetPathForChild :: MonadIO m => ContainerClass -> m ()
clearContainerClassGetPathForChild :: forall (m :: * -> *). MonadIO m => ContainerClass -> m ()
clearContainerClassGetPathForChild ContainerClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ContainerClass
s forall a b. (a -> b) -> a -> b
$ \Ptr ContainerClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ContainerClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
896) (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)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.ContainerClass.getPathForChild"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-ContainerClass.html#g:attr:getPathForChild"
})
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, DK.Type)])
#endif
foreign import ccall "gtk_container_class_find_child_property" gtk_container_class_find_child_property ::
Ptr ContainerClass ->
CString ->
IO (Ptr GParamSpec)
containerClassFindChildProperty ::
(B.CallStack.HasCallStack, MonadIO m) =>
ContainerClass
-> T.Text
-> m (Maybe GParamSpec)
containerClassFindChildProperty :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
ContainerClass -> Text -> m (Maybe GParamSpec)
containerClassFindChildProperty ContainerClass
cclass Text
propertyName = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr ContainerClass
cclass' <- 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 <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr GParamSpec
result forall a b. (a -> b) -> a -> b
$ \Ptr GParamSpec
result' -> do
GParamSpec
result'' <- Ptr GParamSpec -> IO GParamSpec
B.GParamSpec.newGParamSpecFromPtr Ptr GParamSpec
result'
forall (m :: * -> *) a. Monad m => a -> m a
return GParamSpec
result''
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr ContainerClass
cclass
forall a. Ptr a -> IO ()
freeMem CString
propertyName'
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.OverloadedMethod ContainerClassFindChildPropertyMethodInfo ContainerClass signature where
overloadedMethod = containerClassFindChildProperty
instance O.OverloadedMethodInfo ContainerClassFindChildPropertyMethodInfo ContainerClass where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.ContainerClass.containerClassFindChildProperty",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-ContainerClass.html#v:containerClassFindChildProperty"
})
#endif
foreign import ccall "gtk_container_class_handle_border_width" gtk_container_class_handle_border_width ::
Ptr ContainerClass ->
IO ()
containerClassHandleBorderWidth ::
(B.CallStack.HasCallStack, MonadIO m) =>
ContainerClass
-> m ()
containerClassHandleBorderWidth :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
ContainerClass -> m ()
containerClassHandleBorderWidth ContainerClass
klass = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr ContainerClass
klass' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr ContainerClass
klass
Ptr ContainerClass -> IO ()
gtk_container_class_handle_border_width Ptr ContainerClass
klass'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr ContainerClass
klass
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ContainerClassHandleBorderWidthMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod ContainerClassHandleBorderWidthMethodInfo ContainerClass signature where
overloadedMethod = containerClassHandleBorderWidth
instance O.OverloadedMethodInfo ContainerClassHandleBorderWidthMethodInfo ContainerClass where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.ContainerClass.containerClassHandleBorderWidth",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-ContainerClass.html#v:containerClassHandleBorderWidth"
})
#endif
foreign import ccall "gtk_container_class_install_child_property" gtk_container_class_install_child_property ::
Ptr ContainerClass ->
Word32 ->
Ptr GParamSpec ->
IO ()
containerClassInstallChildProperty ::
(B.CallStack.HasCallStack, MonadIO m) =>
ContainerClass
-> Word32
-> GParamSpec
-> m ()
containerClassInstallChildProperty :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
ContainerClass -> Word32 -> GParamSpec -> m ()
containerClassInstallChildProperty ContainerClass
cclass Word32
propertyId GParamSpec
pspec = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr ContainerClass
cclass' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr ContainerClass
cclass
Ptr GParamSpec
pspec' <- 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'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr ContainerClass
cclass
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GParamSpec
pspec
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ContainerClassInstallChildPropertyMethodInfo
instance (signature ~ (Word32 -> GParamSpec -> m ()), MonadIO m) => O.OverloadedMethod ContainerClassInstallChildPropertyMethodInfo ContainerClass signature where
overloadedMethod = containerClassInstallChildProperty
instance O.OverloadedMethodInfo ContainerClassInstallChildPropertyMethodInfo ContainerClass where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.ContainerClass.containerClassInstallChildProperty",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-ContainerClass.html#v:containerClassInstallChildProperty"
})
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveContainerClassMethod (t :: Symbol) (o :: DK.Type) :: DK.Type 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.OverloadedMethod 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
#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveContainerClassMethod t ContainerClass, O.OverloadedMethod info ContainerClass p, R.HasField t ContainerClass p) => R.HasField t ContainerClass p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveContainerClassMethod t ContainerClass, O.OverloadedMethodInfo info ContainerClass) => OL.IsLabel t (O.MethodProxy info ContainerClass) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif