{-# 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 ,
noContainerClass ,
#if defined(ENABLE_OVERLOADING)
ResolveContainerClassMethod ,
#endif
clearContainerClassAdd ,
#if defined(ENABLE_OVERLOADING)
containerClass_add ,
#endif
getContainerClassAdd ,
setContainerClassAdd ,
clearContainerClassChildType ,
#if defined(ENABLE_OVERLOADING)
containerClass_childType ,
#endif
getContainerClassChildType ,
setContainerClassChildType ,
clearContainerClassForall ,
#if defined(ENABLE_OVERLOADING)
containerClass_forall ,
#endif
getContainerClassForall ,
setContainerClassForall ,
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 ,
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.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GI.Gtk.Callbacks as Gtk.Callbacks
import {-# SOURCE #-} qualified GI.Gtk.Structs.WidgetClass as Gtk.WidgetClass
newtype ContainerClass = ContainerClass (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 WrappedPtr ContainerClass where
wrappedPtrCalloc :: IO (Ptr ContainerClass)
wrappedPtrCalloc = Int -> IO (Ptr ContainerClass)
forall a. Int -> IO (Ptr a)
callocBytes 568
wrappedPtrCopy :: ContainerClass -> IO ContainerClass
wrappedPtrCopy = \p :: ContainerClass
p -> ContainerClass
-> (Ptr ContainerClass -> IO ContainerClass) -> IO ContainerClass
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ContainerClass
p (Int -> Ptr ContainerClass -> IO (Ptr ContainerClass)
forall a. WrappedPtr a => Int -> Ptr a -> IO (Ptr a)
copyBytes 568 (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, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr ContainerClass -> ContainerClass
ContainerClass)
wrappedPtrFree :: Maybe (GDestroyNotify ContainerClass)
wrappedPtrFree = GDestroyNotify ContainerClass
-> Maybe (GDestroyNotify ContainerClass)
forall a. a -> Maybe a
Just GDestroyNotify ContainerClass
forall a. FunPtr (Ptr a -> IO ())
ptr_to_g_free
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. WrappedPtr a => IO (Ptr a)
wrappedPtrCalloc 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, WrappedPtr 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 _ attrs :: [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
noContainerClass :: Maybe ContainerClass
noContainerClass :: Maybe ContainerClass
noContainerClass = Maybe ContainerClass
forall a. Maybe a
Nothing
getContainerClassParentClass :: MonadIO m => ContainerClass -> m Gtk.WidgetClass.WidgetClass
getContainerClassParentClass :: ContainerClass -> m WidgetClass
getContainerClassParentClass s :: 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 :: 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` 0 :: (Ptr Gtk.WidgetClass.WidgetClass)
WidgetClass
val' <- ((ManagedPtr WidgetClass -> WidgetClass)
-> Ptr WidgetClass -> IO WidgetClass
forall a.
(HasCallStack, WrappedPtr 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
getContainerClassAdd :: MonadIO m => ContainerClass -> m (Maybe Gtk.Callbacks.ContainerClassAddFieldCallback)
getContainerClassAdd :: ContainerClass -> m (Maybe ContainerClassAddFieldCallback)
getContainerClassAdd s :: 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 :: 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` 456) :: 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
$ \val' :: 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
setContainerClassAdd :: MonadIO m => ContainerClass -> FunPtr Gtk.Callbacks.C_ContainerClassAddFieldCallback -> m ()
setContainerClassAdd :: ContainerClass -> FunPtr C_ContainerClassAddFieldCallback -> m ()
setContainerClassAdd s :: ContainerClass
s val :: 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 :: 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` 456) (FunPtr C_ContainerClassAddFieldCallback
val :: FunPtr Gtk.Callbacks.C_ContainerClassAddFieldCallback)
clearContainerClassAdd :: MonadIO m => ContainerClass -> m ()
clearContainerClassAdd :: ContainerClass -> m ()
clearContainerClassAdd s :: 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 :: 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` 456) (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
getContainerClassRemove :: MonadIO m => ContainerClass -> m (Maybe Gtk.Callbacks.ContainerClassRemoveFieldCallback)
getContainerClassRemove :: ContainerClass -> m (Maybe ContainerClassAddFieldCallback)
getContainerClassRemove s :: 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 :: 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` 464) :: 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
$ \val' :: 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
setContainerClassRemove :: MonadIO m => ContainerClass -> FunPtr Gtk.Callbacks.C_ContainerClassRemoveFieldCallback -> m ()
setContainerClassRemove :: ContainerClass -> FunPtr C_ContainerClassAddFieldCallback -> m ()
setContainerClassRemove s :: ContainerClass
s val :: 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 :: 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` 464) (FunPtr C_ContainerClassAddFieldCallback
val :: FunPtr Gtk.Callbacks.C_ContainerClassRemoveFieldCallback)
clearContainerClassRemove :: MonadIO m => ContainerClass -> m ()
clearContainerClassRemove :: ContainerClass -> m ()
clearContainerClassRemove s :: 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 :: 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` 464) (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
getContainerClassForall :: MonadIO m => ContainerClass -> m (Maybe Gtk.Callbacks.ContainerClassForallFieldCallback_WithClosures)
getContainerClassForall :: ContainerClass
-> m (Maybe ContainerClassForallFieldCallback_WithClosures)
getContainerClassForall s :: 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 :: 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` 472) :: 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
$ \val' :: 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 -> 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
setContainerClassForall :: MonadIO m => ContainerClass -> FunPtr Gtk.Callbacks.C_ContainerClassForallFieldCallback -> m ()
setContainerClassForall :: ContainerClass
-> FunPtr C_ContainerClassForallFieldCallback -> m ()
setContainerClassForall s :: ContainerClass
s val :: 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 :: 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` 472) (FunPtr C_ContainerClassForallFieldCallback
val :: FunPtr Gtk.Callbacks.C_ContainerClassForallFieldCallback)
clearContainerClassForall :: MonadIO m => ContainerClass -> m ()
clearContainerClassForall :: ContainerClass -> m ()
clearContainerClassForall s :: 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 :: 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` 472) (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
getContainerClassSetFocusChild :: MonadIO m => ContainerClass -> m (Maybe Gtk.Callbacks.ContainerClassSetFocusChildFieldCallback)
getContainerClassSetFocusChild :: ContainerClass -> m (Maybe ContainerClassAddFieldCallback)
getContainerClassSetFocusChild s :: 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 :: 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` 480) :: IO (FunPtr Gtk.Callbacks.C_ContainerClassSetFocusChildFieldCallback)
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
$ \val' :: 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_ContainerClassSetFocusChildFieldCallback 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
setContainerClassSetFocusChild :: MonadIO m => ContainerClass -> FunPtr Gtk.Callbacks.C_ContainerClassSetFocusChildFieldCallback -> m ()
setContainerClassSetFocusChild :: ContainerClass -> FunPtr C_ContainerClassAddFieldCallback -> m ()
setContainerClassSetFocusChild s :: ContainerClass
s val :: 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 :: 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` 480) (FunPtr C_ContainerClassAddFieldCallback
val :: FunPtr Gtk.Callbacks.C_ContainerClassSetFocusChildFieldCallback)
clearContainerClassSetFocusChild :: MonadIO m => ContainerClass -> m ()
clearContainerClassSetFocusChild :: ContainerClass -> m ()
clearContainerClassSetFocusChild s :: 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 :: 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` 480) (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
getContainerClassChildType :: MonadIO m => ContainerClass -> m (Maybe Gtk.Callbacks.ContainerClassChildTypeFieldCallback)
getContainerClassChildType :: ContainerClass -> m (Maybe ContainerClassChildTypeFieldCallback)
getContainerClassChildType s :: 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 :: 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` 488) :: 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
$ \val' :: 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
setContainerClassChildType :: MonadIO m => ContainerClass -> FunPtr Gtk.Callbacks.C_ContainerClassChildTypeFieldCallback -> m ()
setContainerClassChildType :: ContainerClass
-> FunPtr C_ContainerClassChildTypeFieldCallback -> m ()
setContainerClassChildType s :: ContainerClass
s val :: 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 :: 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` 488) (FunPtr C_ContainerClassChildTypeFieldCallback
val :: FunPtr Gtk.Callbacks.C_ContainerClassChildTypeFieldCallback)
clearContainerClassChildType :: MonadIO m => ContainerClass -> m ()
clearContainerClassChildType :: ContainerClass -> m ()
clearContainerClassChildType s :: 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 :: 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` 488) (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
getContainerClassGetPathForChild :: MonadIO m => ContainerClass -> m (Maybe Gtk.Callbacks.ContainerClassGetPathForChildFieldCallback)
getContainerClassGetPathForChild :: ContainerClass
-> m (Maybe ContainerClassGetPathForChildFieldCallback)
getContainerClassGetPathForChild s :: 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 :: 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` 496) :: 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
$ \val' :: 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
setContainerClassGetPathForChild :: MonadIO m => ContainerClass -> FunPtr Gtk.Callbacks.C_ContainerClassGetPathForChildFieldCallback -> m ()
setContainerClassGetPathForChild :: ContainerClass
-> FunPtr C_ContainerClassGetPathForChildFieldCallback -> m ()
setContainerClassGetPathForChild s :: ContainerClass
s val :: 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 :: 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` 496) (FunPtr C_ContainerClassGetPathForChildFieldCallback
val :: FunPtr Gtk.Callbacks.C_ContainerClassGetPathForChildFieldCallback)
clearContainerClassGetPathForChild :: MonadIO m => ContainerClass -> m ()
clearContainerClassGetPathForChild :: ContainerClass -> m ()
clearContainerClassGetPathForChild s :: 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 :: 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` 496) (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), '("forall", ContainerClassForallFieldInfo), '("setFocusChild", ContainerClassSetFocusChildFieldInfo), '("childType", ContainerClassChildTypeFieldInfo), '("getPathForChild", ContainerClassGetPathForChildFieldInfo)] :: [(Symbol, *)])
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveContainerClassMethod (t :: Symbol) (o :: *) :: * where
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