{-# 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
#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.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 (Eq)
instance WrappedPtr ContainerClass where
wrappedPtrCalloc = callocBytes 488
wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 488 >=> wrapPtr ContainerClass)
wrappedPtrFree = Just ptr_to_g_free
newZeroContainerClass :: MonadIO m => m ContainerClass
newZeroContainerClass = liftIO $ wrappedPtrCalloc >>= wrapPtr ContainerClass
instance tag ~ 'AttrSet => Constructible ContainerClass tag where
new _ attrs = do
o <- newZeroContainerClass
GI.Attributes.set o attrs
return o
noContainerClass :: Maybe ContainerClass
noContainerClass = Nothing
getContainerClassParentClass :: MonadIO m => ContainerClass -> m Gtk.WidgetClass.WidgetClass
getContainerClassParentClass s = liftIO $ withManagedPtr s $ \ptr -> do
let val = ptr `plusPtr` 0 :: (Ptr Gtk.WidgetClass.WidgetClass)
val' <- (newPtr Gtk.WidgetClass.WidgetClass) val
return 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 s = liftIO $ withManagedPtr s $ \ptr -> do
val <- peek (ptr `plusPtr` 412) :: IO (FunPtr Gtk.Callbacks.C_ContainerClassAddFieldCallback)
result <- SP.convertFunPtrIfNonNull val $ \val' -> do
let val'' = Gtk.Callbacks.dynamic_ContainerClassAddFieldCallback val'
return val''
return result
setContainerClassAdd :: MonadIO m => ContainerClass -> FunPtr Gtk.Callbacks.C_ContainerClassAddFieldCallback -> m ()
setContainerClassAdd s val = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 412) (val :: FunPtr Gtk.Callbacks.C_ContainerClassAddFieldCallback)
clearContainerClassAdd :: MonadIO m => ContainerClass -> m ()
clearContainerClassAdd s = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 412) (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 s = liftIO $ withManagedPtr s $ \ptr -> do
val <- peek (ptr `plusPtr` 416) :: IO (FunPtr Gtk.Callbacks.C_ContainerClassRemoveFieldCallback)
result <- SP.convertFunPtrIfNonNull val $ \val' -> do
let val'' = Gtk.Callbacks.dynamic_ContainerClassRemoveFieldCallback val'
return val''
return result
setContainerClassRemove :: MonadIO m => ContainerClass -> FunPtr Gtk.Callbacks.C_ContainerClassRemoveFieldCallback -> m ()
setContainerClassRemove s val = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 416) (val :: FunPtr Gtk.Callbacks.C_ContainerClassRemoveFieldCallback)
clearContainerClassRemove :: MonadIO m => ContainerClass -> m ()
clearContainerClassRemove s = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 416) (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
getContainerClassCheckResize :: MonadIO m => ContainerClass -> m (Maybe Gtk.Callbacks.ContainerClassCheckResizeFieldCallback)
getContainerClassCheckResize s = liftIO $ withManagedPtr s $ \ptr -> do
val <- peek (ptr `plusPtr` 420) :: IO (FunPtr Gtk.Callbacks.C_ContainerClassCheckResizeFieldCallback)
result <- SP.convertFunPtrIfNonNull val $ \val' -> do
let val'' = Gtk.Callbacks.dynamic_ContainerClassCheckResizeFieldCallback val'
return val''
return result
setContainerClassCheckResize :: MonadIO m => ContainerClass -> FunPtr Gtk.Callbacks.C_ContainerClassCheckResizeFieldCallback -> m ()
setContainerClassCheckResize s val = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 420) (val :: FunPtr Gtk.Callbacks.C_ContainerClassCheckResizeFieldCallback)
clearContainerClassCheckResize :: MonadIO m => ContainerClass -> m ()
clearContainerClassCheckResize s = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 420) (FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_ContainerClassCheckResizeFieldCallback)
#if defined(ENABLE_OVERLOADING)
data ContainerClassCheckResizeFieldInfo
instance AttrInfo ContainerClassCheckResizeFieldInfo where
type AttrBaseTypeConstraint ContainerClassCheckResizeFieldInfo = (~) ContainerClass
type AttrAllowedOps ContainerClassCheckResizeFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint ContainerClassCheckResizeFieldInfo = (~) (FunPtr Gtk.Callbacks.C_ContainerClassCheckResizeFieldCallback)
type AttrTransferTypeConstraint ContainerClassCheckResizeFieldInfo = (~)Gtk.Callbacks.ContainerClassCheckResizeFieldCallback
type AttrTransferType ContainerClassCheckResizeFieldInfo = (FunPtr Gtk.Callbacks.C_ContainerClassCheckResizeFieldCallback)
type AttrGetType ContainerClassCheckResizeFieldInfo = Maybe Gtk.Callbacks.ContainerClassCheckResizeFieldCallback
type AttrLabel ContainerClassCheckResizeFieldInfo = "check_resize"
type AttrOrigin ContainerClassCheckResizeFieldInfo = ContainerClass
attrGet = getContainerClassCheckResize
attrSet = setContainerClassCheckResize
attrConstruct = undefined
attrClear = clearContainerClassCheckResize
attrTransfer _ v = do
Gtk.Callbacks.mk_ContainerClassCheckResizeFieldCallback (Gtk.Callbacks.wrap_ContainerClassCheckResizeFieldCallback Nothing v)
containerClass_checkResize :: AttrLabelProxy "checkResize"
containerClass_checkResize = AttrLabelProxy
#endif
getContainerClassForall :: MonadIO m => ContainerClass -> m (Maybe Gtk.Callbacks.ContainerClassForallFieldCallback_WithClosures)
getContainerClassForall s = liftIO $ withManagedPtr s $ \ptr -> do
val <- peek (ptr `plusPtr` 424) :: IO (FunPtr Gtk.Callbacks.C_ContainerClassForallFieldCallback)
result <- SP.convertFunPtrIfNonNull val $ \val' -> do
let val'' = Gtk.Callbacks.dynamic_ContainerClassForallFieldCallback val'
return val''
return result
setContainerClassForall :: MonadIO m => ContainerClass -> FunPtr Gtk.Callbacks.C_ContainerClassForallFieldCallback -> m ()
setContainerClassForall s val = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 424) (val :: FunPtr Gtk.Callbacks.C_ContainerClassForallFieldCallback)
clearContainerClassForall :: MonadIO m => ContainerClass -> m ()
clearContainerClassForall s = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 424) (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 s = liftIO $ withManagedPtr s $ \ptr -> do
val <- peek (ptr `plusPtr` 428) :: IO (FunPtr Gtk.Callbacks.C_ContainerClassSetFocusChildFieldCallback)
result <- SP.convertFunPtrIfNonNull val $ \val' -> do
let val'' = Gtk.Callbacks.dynamic_ContainerClassSetFocusChildFieldCallback val'
return val''
return result
setContainerClassSetFocusChild :: MonadIO m => ContainerClass -> FunPtr Gtk.Callbacks.C_ContainerClassSetFocusChildFieldCallback -> m ()
setContainerClassSetFocusChild s val = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 428) (val :: FunPtr Gtk.Callbacks.C_ContainerClassSetFocusChildFieldCallback)
clearContainerClassSetFocusChild :: MonadIO m => ContainerClass -> m ()
clearContainerClassSetFocusChild s = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 428) (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 s = liftIO $ withManagedPtr s $ \ptr -> do
val <- peek (ptr `plusPtr` 432) :: IO (FunPtr Gtk.Callbacks.C_ContainerClassChildTypeFieldCallback)
result <- SP.convertFunPtrIfNonNull val $ \val' -> do
let val'' = Gtk.Callbacks.dynamic_ContainerClassChildTypeFieldCallback val'
return val''
return result
setContainerClassChildType :: MonadIO m => ContainerClass -> FunPtr Gtk.Callbacks.C_ContainerClassChildTypeFieldCallback -> m ()
setContainerClassChildType s val = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 432) (val :: FunPtr Gtk.Callbacks.C_ContainerClassChildTypeFieldCallback)
clearContainerClassChildType :: MonadIO m => ContainerClass -> m ()
clearContainerClassChildType s = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 432) (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
getContainerClassCompositeName :: MonadIO m => ContainerClass -> m (Maybe Gtk.Callbacks.ContainerClassCompositeNameFieldCallback)
getContainerClassCompositeName s = liftIO $ withManagedPtr s $ \ptr -> do
val <- peek (ptr `plusPtr` 436) :: IO (FunPtr Gtk.Callbacks.C_ContainerClassCompositeNameFieldCallback)
result <- SP.convertFunPtrIfNonNull val $ \val' -> do
let val'' = Gtk.Callbacks.dynamic_ContainerClassCompositeNameFieldCallback val'
return val''
return result
setContainerClassCompositeName :: MonadIO m => ContainerClass -> FunPtr Gtk.Callbacks.C_ContainerClassCompositeNameFieldCallback -> m ()
setContainerClassCompositeName s val = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 436) (val :: FunPtr Gtk.Callbacks.C_ContainerClassCompositeNameFieldCallback)
clearContainerClassCompositeName :: MonadIO m => ContainerClass -> m ()
clearContainerClassCompositeName s = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 436) (FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_ContainerClassCompositeNameFieldCallback)
#if defined(ENABLE_OVERLOADING)
data ContainerClassCompositeNameFieldInfo
instance AttrInfo ContainerClassCompositeNameFieldInfo where
type AttrBaseTypeConstraint ContainerClassCompositeNameFieldInfo = (~) ContainerClass
type AttrAllowedOps ContainerClassCompositeNameFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint ContainerClassCompositeNameFieldInfo = (~) (FunPtr Gtk.Callbacks.C_ContainerClassCompositeNameFieldCallback)
type AttrTransferTypeConstraint ContainerClassCompositeNameFieldInfo = (~)Gtk.Callbacks.ContainerClassCompositeNameFieldCallback
type AttrTransferType ContainerClassCompositeNameFieldInfo = (FunPtr Gtk.Callbacks.C_ContainerClassCompositeNameFieldCallback)
type AttrGetType ContainerClassCompositeNameFieldInfo = Maybe Gtk.Callbacks.ContainerClassCompositeNameFieldCallback
type AttrLabel ContainerClassCompositeNameFieldInfo = "composite_name"
type AttrOrigin ContainerClassCompositeNameFieldInfo = ContainerClass
attrGet = getContainerClassCompositeName
attrSet = setContainerClassCompositeName
attrConstruct = undefined
attrClear = clearContainerClassCompositeName
attrTransfer _ v = do
Gtk.Callbacks.mk_ContainerClassCompositeNameFieldCallback (Gtk.Callbacks.wrap_ContainerClassCompositeNameFieldCallback Nothing v)
containerClass_compositeName :: AttrLabelProxy "compositeName"
containerClass_compositeName = AttrLabelProxy
#endif
getContainerClassSetChildProperty :: MonadIO m => ContainerClass -> m (Maybe Gtk.Callbacks.ContainerClassSetChildPropertyFieldCallback)
getContainerClassSetChildProperty s = liftIO $ withManagedPtr s $ \ptr -> do
val <- peek (ptr `plusPtr` 440) :: IO (FunPtr Gtk.Callbacks.C_ContainerClassSetChildPropertyFieldCallback)
result <- SP.convertFunPtrIfNonNull val $ \val' -> do
let val'' = Gtk.Callbacks.dynamic_ContainerClassSetChildPropertyFieldCallback val'
return val''
return result
setContainerClassSetChildProperty :: MonadIO m => ContainerClass -> FunPtr Gtk.Callbacks.C_ContainerClassSetChildPropertyFieldCallback -> m ()
setContainerClassSetChildProperty s val = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 440) (val :: FunPtr Gtk.Callbacks.C_ContainerClassSetChildPropertyFieldCallback)
clearContainerClassSetChildProperty :: MonadIO m => ContainerClass -> m ()
clearContainerClassSetChildProperty s = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 440) (FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_ContainerClassSetChildPropertyFieldCallback)
#if defined(ENABLE_OVERLOADING)
data ContainerClassSetChildPropertyFieldInfo
instance AttrInfo ContainerClassSetChildPropertyFieldInfo where
type AttrBaseTypeConstraint ContainerClassSetChildPropertyFieldInfo = (~) ContainerClass
type AttrAllowedOps ContainerClassSetChildPropertyFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint ContainerClassSetChildPropertyFieldInfo = (~) (FunPtr Gtk.Callbacks.C_ContainerClassSetChildPropertyFieldCallback)
type AttrTransferTypeConstraint ContainerClassSetChildPropertyFieldInfo = (~)Gtk.Callbacks.ContainerClassSetChildPropertyFieldCallback
type AttrTransferType ContainerClassSetChildPropertyFieldInfo = (FunPtr Gtk.Callbacks.C_ContainerClassSetChildPropertyFieldCallback)
type AttrGetType ContainerClassSetChildPropertyFieldInfo = Maybe Gtk.Callbacks.ContainerClassSetChildPropertyFieldCallback
type AttrLabel ContainerClassSetChildPropertyFieldInfo = "set_child_property"
type AttrOrigin ContainerClassSetChildPropertyFieldInfo = ContainerClass
attrGet = getContainerClassSetChildProperty
attrSet = setContainerClassSetChildProperty
attrConstruct = undefined
attrClear = clearContainerClassSetChildProperty
attrTransfer _ v = do
Gtk.Callbacks.mk_ContainerClassSetChildPropertyFieldCallback (Gtk.Callbacks.wrap_ContainerClassSetChildPropertyFieldCallback Nothing v)
containerClass_setChildProperty :: AttrLabelProxy "setChildProperty"
containerClass_setChildProperty = AttrLabelProxy
#endif
getContainerClassGetChildProperty :: MonadIO m => ContainerClass -> m (Maybe Gtk.Callbacks.ContainerClassGetChildPropertyFieldCallback)
getContainerClassGetChildProperty s = liftIO $ withManagedPtr s $ \ptr -> do
val <- peek (ptr `plusPtr` 444) :: IO (FunPtr Gtk.Callbacks.C_ContainerClassGetChildPropertyFieldCallback)
result <- SP.convertFunPtrIfNonNull val $ \val' -> do
let val'' = Gtk.Callbacks.dynamic_ContainerClassGetChildPropertyFieldCallback val'
return val''
return result
setContainerClassGetChildProperty :: MonadIO m => ContainerClass -> FunPtr Gtk.Callbacks.C_ContainerClassGetChildPropertyFieldCallback -> m ()
setContainerClassGetChildProperty s val = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 444) (val :: FunPtr Gtk.Callbacks.C_ContainerClassGetChildPropertyFieldCallback)
clearContainerClassGetChildProperty :: MonadIO m => ContainerClass -> m ()
clearContainerClassGetChildProperty s = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 444) (FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_ContainerClassGetChildPropertyFieldCallback)
#if defined(ENABLE_OVERLOADING)
data ContainerClassGetChildPropertyFieldInfo
instance AttrInfo ContainerClassGetChildPropertyFieldInfo where
type AttrBaseTypeConstraint ContainerClassGetChildPropertyFieldInfo = (~) ContainerClass
type AttrAllowedOps ContainerClassGetChildPropertyFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint ContainerClassGetChildPropertyFieldInfo = (~) (FunPtr Gtk.Callbacks.C_ContainerClassGetChildPropertyFieldCallback)
type AttrTransferTypeConstraint ContainerClassGetChildPropertyFieldInfo = (~)Gtk.Callbacks.ContainerClassGetChildPropertyFieldCallback
type AttrTransferType ContainerClassGetChildPropertyFieldInfo = (FunPtr Gtk.Callbacks.C_ContainerClassGetChildPropertyFieldCallback)
type AttrGetType ContainerClassGetChildPropertyFieldInfo = Maybe Gtk.Callbacks.ContainerClassGetChildPropertyFieldCallback
type AttrLabel ContainerClassGetChildPropertyFieldInfo = "get_child_property"
type AttrOrigin ContainerClassGetChildPropertyFieldInfo = ContainerClass
attrGet = getContainerClassGetChildProperty
attrSet = setContainerClassGetChildProperty
attrConstruct = undefined
attrClear = clearContainerClassGetChildProperty
attrTransfer _ v = do
Gtk.Callbacks.mk_ContainerClassGetChildPropertyFieldCallback (Gtk.Callbacks.wrap_ContainerClassGetChildPropertyFieldCallback Nothing v)
containerClass_getChildProperty :: AttrLabelProxy "getChildProperty"
containerClass_getChildProperty = AttrLabelProxy
#endif
getContainerClassGetPathForChild :: MonadIO m => ContainerClass -> m (Maybe Gtk.Callbacks.ContainerClassGetPathForChildFieldCallback)
getContainerClassGetPathForChild s = liftIO $ withManagedPtr s $ \ptr -> do
val <- peek (ptr `plusPtr` 448) :: IO (FunPtr Gtk.Callbacks.C_ContainerClassGetPathForChildFieldCallback)
result <- SP.convertFunPtrIfNonNull val $ \val' -> do
let val'' = Gtk.Callbacks.dynamic_ContainerClassGetPathForChildFieldCallback val'
return val''
return result
setContainerClassGetPathForChild :: MonadIO m => ContainerClass -> FunPtr Gtk.Callbacks.C_ContainerClassGetPathForChildFieldCallback -> m ()
setContainerClassGetPathForChild s val = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 448) (val :: FunPtr Gtk.Callbacks.C_ContainerClassGetPathForChildFieldCallback)
clearContainerClassGetPathForChild :: MonadIO m => ContainerClass -> m ()
clearContainerClassGetPathForChild s = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 448) (FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_ContainerClassGetPathForChildFieldCallback)
#if defined(ENABLE_OVERLOADING)
data ContainerClassGetPathForChildFieldInfo
instance AttrInfo ContainerClassGetPathForChildFieldInfo where
type AttrBaseTypeConstraint ContainerClassGetPathForChildFieldInfo = (~) ContainerClass
type AttrAllowedOps ContainerClassGetPathForChildFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint ContainerClassGetPathForChildFieldInfo = (~) (FunPtr Gtk.Callbacks.C_ContainerClassGetPathForChildFieldCallback)
type AttrTransferTypeConstraint ContainerClassGetPathForChildFieldInfo = (~)Gtk.Callbacks.ContainerClassGetPathForChildFieldCallback
type AttrTransferType ContainerClassGetPathForChildFieldInfo = (FunPtr Gtk.Callbacks.C_ContainerClassGetPathForChildFieldCallback)
type AttrGetType ContainerClassGetPathForChildFieldInfo = Maybe Gtk.Callbacks.ContainerClassGetPathForChildFieldCallback
type AttrLabel ContainerClassGetPathForChildFieldInfo = "get_path_for_child"
type AttrOrigin ContainerClassGetPathForChildFieldInfo = ContainerClass
attrGet = getContainerClassGetPathForChild
attrSet = setContainerClassGetPathForChild
attrConstruct = undefined
attrClear = clearContainerClassGetPathForChild
attrTransfer _ v = do
Gtk.Callbacks.mk_ContainerClassGetPathForChildFieldCallback (Gtk.Callbacks.wrap_ContainerClassGetPathForChildFieldCallback Nothing v)
containerClass_getPathForChild :: AttrLabelProxy "getPathForChild"
containerClass_getPathForChild = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList ContainerClass
type instance O.AttributeList ContainerClass = ContainerClassAttributeList
type ContainerClassAttributeList = ('[ '("parentClass", ContainerClassParentClassFieldInfo), '("add", ContainerClassAddFieldInfo), '("remove", ContainerClassRemoveFieldInfo), '("checkResize", ContainerClassCheckResizeFieldInfo), '("forall", ContainerClassForallFieldInfo), '("setFocusChild", ContainerClassSetFocusChildFieldInfo), '("childType", ContainerClassChildTypeFieldInfo), '("compositeName", ContainerClassCompositeNameFieldInfo), '("setChildProperty", ContainerClassSetChildPropertyFieldInfo), '("getChildProperty", ContainerClassGetChildPropertyFieldInfo), '("getPathForChild", ContainerClassGetPathForChildFieldInfo)] :: [(Symbol, *)])
#endif
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 cclass propertyName = liftIO $ do
cclass' <- unsafeManagedPtrGetPtr cclass
propertyName' <- textToCString propertyName
result <- gtk_container_class_find_child_property cclass' propertyName'
maybeResult <- convertIfNonNull result $ \result' -> do
result'' <- B.GParamSpec.newGParamSpecFromPtr result'
return result''
touchManagedPtr cclass
freeMem propertyName'
return maybeResult
#if defined(ENABLE_OVERLOADING)
data ContainerClassFindChildPropertyMethodInfo
instance (signature ~ (T.Text -> m (Maybe GParamSpec)), MonadIO m) => O.MethodInfo ContainerClassFindChildPropertyMethodInfo ContainerClass signature where
overloadedMethod = containerClassFindChildProperty
#endif
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 klass = liftIO $ do
klass' <- unsafeManagedPtrGetPtr klass
gtk_container_class_handle_border_width klass'
touchManagedPtr klass
return ()
#if defined(ENABLE_OVERLOADING)
data ContainerClassHandleBorderWidthMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo ContainerClassHandleBorderWidthMethodInfo ContainerClass signature where
overloadedMethod = 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 cclass propertyId pspec = liftIO $ do
cclass' <- unsafeManagedPtrGetPtr cclass
pspec' <- unsafeManagedPtrGetPtr pspec
gtk_container_class_install_child_property cclass' propertyId pspec'
touchManagedPtr cclass
touchManagedPtr pspec
return ()
#if defined(ENABLE_OVERLOADING)
data ContainerClassInstallChildPropertyMethodInfo
instance (signature ~ (Word32 -> GParamSpec -> m ()), MonadIO m) => O.MethodInfo ContainerClassInstallChildPropertyMethodInfo ContainerClass signature where
overloadedMethod = containerClassInstallChildProperty
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveContainerClassMethod (t :: Symbol) (o :: *) :: * where
ResolveContainerClassMethod "findChildProperty" o = ContainerClassFindChildPropertyMethodInfo
ResolveContainerClassMethod "handleBorderWidth" o = ContainerClassHandleBorderWidthMethodInfo
ResolveContainerClassMethod "installChildProperty" o = ContainerClassInstallChildPropertyMethodInfo
ResolveContainerClassMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveContainerClassMethod t ContainerClass, O.MethodInfo info ContainerClass p) => OL.IsLabel t (ContainerClass -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#endif