{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)

The 'GI.Gtk.Objects.CellAreaBox.CellAreaBox' renders cell renderers into a row or a column
depending on its 'GI.Gtk.Enums.Orientation'.

GtkCellAreaBox uses a notion of packing. Packing
refers to adding cell renderers with reference to a particular position
in a 'GI.Gtk.Objects.CellAreaBox.CellAreaBox'. There are two reference positions: the
start and the end of the box.
When the 'GI.Gtk.Objects.CellAreaBox.CellAreaBox' is oriented in the 'GI.Gtk.Enums.OrientationVertical'
orientation, the start is defined as the top of the box and the end is
defined as the bottom. In the 'GI.Gtk.Enums.OrientationHorizontal' orientation
start is defined as the left side and the end is defined as the right
side.

Alignments of @/GtkCellRenderers/@ rendered in adjacent rows can be
configured by configuring the 'GI.Gtk.Objects.CellAreaBox.CellAreaBox' align child cell property
with 'GI.Gtk.Objects.CellArea.cellAreaCellSetProperty' or by specifying the \"align\"
argument to 'GI.Gtk.Objects.CellAreaBox.cellAreaBoxPackStart' and 'GI.Gtk.Objects.CellAreaBox.cellAreaBoxPackEnd'.
-}

module GI.Gtk.Objects.CellAreaBox
    ( 

-- * Exported types
    CellAreaBox(..)                         ,
    IsCellAreaBox                           ,
    toCellAreaBox                           ,
    noCellAreaBox                           ,


 -- * Methods
-- ** getSpacing #method:getSpacing#
    CellAreaBoxGetSpacingMethodInfo         ,
    cellAreaBoxGetSpacing                   ,


-- ** new #method:new#
    cellAreaBoxNew                          ,


-- ** packEnd #method:packEnd#
    CellAreaBoxPackEndMethodInfo            ,
    cellAreaBoxPackEnd                      ,


-- ** packStart #method:packStart#
    CellAreaBoxPackStartMethodInfo          ,
    cellAreaBoxPackStart                    ,


-- ** setSpacing #method:setSpacing#
    CellAreaBoxSetSpacingMethodInfo         ,
    cellAreaBoxSetSpacing                   ,




 -- * Properties
-- ** spacing #attr:spacing#
    CellAreaBoxSpacingPropertyInfo          ,
    cellAreaBoxSpacing                      ,
    constructCellAreaBoxSpacing             ,
    getCellAreaBoxSpacing                   ,
    setCellAreaBoxSpacing                   ,




    ) 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.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
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 GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.CellLayout as Gtk.CellLayout
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Orientable as Gtk.Orientable
import {-# SOURCE #-} qualified GI.Gtk.Objects.CellArea as Gtk.CellArea
import {-# SOURCE #-} qualified GI.Gtk.Objects.CellRenderer as Gtk.CellRenderer

newtype CellAreaBox = CellAreaBox (ManagedPtr CellAreaBox)
foreign import ccall "gtk_cell_area_box_get_type"
    c_gtk_cell_area_box_get_type :: IO GType

instance GObject CellAreaBox where
    gobjectType _ = c_gtk_cell_area_box_get_type
    

class GObject o => IsCellAreaBox o
#if MIN_VERSION_base(4,9,0)
instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError CellAreaBox a) =>
    IsCellAreaBox a
#endif
instance IsCellAreaBox CellAreaBox
instance Gtk.CellArea.IsCellArea CellAreaBox
instance GObject.Object.IsObject CellAreaBox
instance Gtk.Buildable.IsBuildable CellAreaBox
instance Gtk.CellLayout.IsCellLayout CellAreaBox
instance Gtk.Orientable.IsOrientable CellAreaBox

toCellAreaBox :: IsCellAreaBox o => o -> IO CellAreaBox
toCellAreaBox = unsafeCastTo CellAreaBox

noCellAreaBox :: Maybe CellAreaBox
noCellAreaBox = Nothing

type family ResolveCellAreaBoxMethod (t :: Symbol) (o :: *) :: * where
    ResolveCellAreaBoxMethod "activate" o = Gtk.CellArea.CellAreaActivateMethodInfo
    ResolveCellAreaBoxMethod "activateCell" o = Gtk.CellArea.CellAreaActivateCellMethodInfo
    ResolveCellAreaBoxMethod "add" o = Gtk.CellArea.CellAreaAddMethodInfo
    ResolveCellAreaBoxMethod "addAttribute" o = Gtk.CellLayout.CellLayoutAddAttributeMethodInfo
    ResolveCellAreaBoxMethod "addChild" o = Gtk.Buildable.BuildableAddChildMethodInfo
    ResolveCellAreaBoxMethod "addFocusSibling" o = Gtk.CellArea.CellAreaAddFocusSiblingMethodInfo
    ResolveCellAreaBoxMethod "applyAttributes" o = Gtk.CellArea.CellAreaApplyAttributesMethodInfo
    ResolveCellAreaBoxMethod "attributeConnect" o = Gtk.CellArea.CellAreaAttributeConnectMethodInfo
    ResolveCellAreaBoxMethod "attributeDisconnect" o = Gtk.CellArea.CellAreaAttributeDisconnectMethodInfo
    ResolveCellAreaBoxMethod "attributeGetColumn" o = Gtk.CellArea.CellAreaAttributeGetColumnMethodInfo
    ResolveCellAreaBoxMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveCellAreaBoxMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveCellAreaBoxMethod "cellGetProperty" o = Gtk.CellArea.CellAreaCellGetPropertyMethodInfo
    ResolveCellAreaBoxMethod "cellSetProperty" o = Gtk.CellArea.CellAreaCellSetPropertyMethodInfo
    ResolveCellAreaBoxMethod "clear" o = Gtk.CellLayout.CellLayoutClearMethodInfo
    ResolveCellAreaBoxMethod "clearAttributes" o = Gtk.CellLayout.CellLayoutClearAttributesMethodInfo
    ResolveCellAreaBoxMethod "constructChild" o = Gtk.Buildable.BuildableConstructChildMethodInfo
    ResolveCellAreaBoxMethod "copyContext" o = Gtk.CellArea.CellAreaCopyContextMethodInfo
    ResolveCellAreaBoxMethod "createContext" o = Gtk.CellArea.CellAreaCreateContextMethodInfo
    ResolveCellAreaBoxMethod "customFinished" o = Gtk.Buildable.BuildableCustomFinishedMethodInfo
    ResolveCellAreaBoxMethod "customTagEnd" o = Gtk.Buildable.BuildableCustomTagEndMethodInfo
    ResolveCellAreaBoxMethod "customTagStart" o = Gtk.Buildable.BuildableCustomTagStartMethodInfo
    ResolveCellAreaBoxMethod "event" o = Gtk.CellArea.CellAreaEventMethodInfo
    ResolveCellAreaBoxMethod "focus" o = Gtk.CellArea.CellAreaFocusMethodInfo
    ResolveCellAreaBoxMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveCellAreaBoxMethod "foreach" o = Gtk.CellArea.CellAreaForeachMethodInfo
    ResolveCellAreaBoxMethod "foreachAlloc" o = Gtk.CellArea.CellAreaForeachAllocMethodInfo
    ResolveCellAreaBoxMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveCellAreaBoxMethod "hasRenderer" o = Gtk.CellArea.CellAreaHasRendererMethodInfo
    ResolveCellAreaBoxMethod "innerCellArea" o = Gtk.CellArea.CellAreaInnerCellAreaMethodInfo
    ResolveCellAreaBoxMethod "isActivatable" o = Gtk.CellArea.CellAreaIsActivatableMethodInfo
    ResolveCellAreaBoxMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveCellAreaBoxMethod "isFocusSibling" o = Gtk.CellArea.CellAreaIsFocusSiblingMethodInfo
    ResolveCellAreaBoxMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveCellAreaBoxMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveCellAreaBoxMethod "packEnd" o = CellAreaBoxPackEndMethodInfo
    ResolveCellAreaBoxMethod "packStart" o = CellAreaBoxPackStartMethodInfo
    ResolveCellAreaBoxMethod "parserFinished" o = Gtk.Buildable.BuildableParserFinishedMethodInfo
    ResolveCellAreaBoxMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveCellAreaBoxMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveCellAreaBoxMethod "remove" o = Gtk.CellArea.CellAreaRemoveMethodInfo
    ResolveCellAreaBoxMethod "removeFocusSibling" o = Gtk.CellArea.CellAreaRemoveFocusSiblingMethodInfo
    ResolveCellAreaBoxMethod "render" o = Gtk.CellArea.CellAreaRenderMethodInfo
    ResolveCellAreaBoxMethod "reorder" o = Gtk.CellLayout.CellLayoutReorderMethodInfo
    ResolveCellAreaBoxMethod "replaceData" o = GObject.Object.ObjectReplaceDataMethodInfo
    ResolveCellAreaBoxMethod "replaceQdata" o = GObject.Object.ObjectReplaceQdataMethodInfo
    ResolveCellAreaBoxMethod "requestRenderer" o = Gtk.CellArea.CellAreaRequestRendererMethodInfo
    ResolveCellAreaBoxMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveCellAreaBoxMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveCellAreaBoxMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveCellAreaBoxMethod "stopEditing" o = Gtk.CellArea.CellAreaStopEditingMethodInfo
    ResolveCellAreaBoxMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveCellAreaBoxMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveCellAreaBoxMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveCellAreaBoxMethod "getArea" o = Gtk.CellLayout.CellLayoutGetAreaMethodInfo
    ResolveCellAreaBoxMethod "getCellAllocation" o = Gtk.CellArea.CellAreaGetCellAllocationMethodInfo
    ResolveCellAreaBoxMethod "getCellAtPosition" o = Gtk.CellArea.CellAreaGetCellAtPositionMethodInfo
    ResolveCellAreaBoxMethod "getCells" o = Gtk.CellLayout.CellLayoutGetCellsMethodInfo
    ResolveCellAreaBoxMethod "getCurrentPathString" o = Gtk.CellArea.CellAreaGetCurrentPathStringMethodInfo
    ResolveCellAreaBoxMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveCellAreaBoxMethod "getEditWidget" o = Gtk.CellArea.CellAreaGetEditWidgetMethodInfo
    ResolveCellAreaBoxMethod "getEditedCell" o = Gtk.CellArea.CellAreaGetEditedCellMethodInfo
    ResolveCellAreaBoxMethod "getFocusCell" o = Gtk.CellArea.CellAreaGetFocusCellMethodInfo
    ResolveCellAreaBoxMethod "getFocusFromSibling" o = Gtk.CellArea.CellAreaGetFocusFromSiblingMethodInfo
    ResolveCellAreaBoxMethod "getFocusSiblings" o = Gtk.CellArea.CellAreaGetFocusSiblingsMethodInfo
    ResolveCellAreaBoxMethod "getInternalChild" o = Gtk.Buildable.BuildableGetInternalChildMethodInfo
    ResolveCellAreaBoxMethod "getName" o = Gtk.Buildable.BuildableGetNameMethodInfo
    ResolveCellAreaBoxMethod "getOrientation" o = Gtk.Orientable.OrientableGetOrientationMethodInfo
    ResolveCellAreaBoxMethod "getPreferredHeight" o = Gtk.CellArea.CellAreaGetPreferredHeightMethodInfo
    ResolveCellAreaBoxMethod "getPreferredHeightForWidth" o = Gtk.CellArea.CellAreaGetPreferredHeightForWidthMethodInfo
    ResolveCellAreaBoxMethod "getPreferredWidth" o = Gtk.CellArea.CellAreaGetPreferredWidthMethodInfo
    ResolveCellAreaBoxMethod "getPreferredWidthForHeight" o = Gtk.CellArea.CellAreaGetPreferredWidthForHeightMethodInfo
    ResolveCellAreaBoxMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveCellAreaBoxMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveCellAreaBoxMethod "getRequestMode" o = Gtk.CellArea.CellAreaGetRequestModeMethodInfo
    ResolveCellAreaBoxMethod "getSpacing" o = CellAreaBoxGetSpacingMethodInfo
    ResolveCellAreaBoxMethod "setBuildableProperty" o = Gtk.Buildable.BuildableSetBuildablePropertyMethodInfo
    ResolveCellAreaBoxMethod "setCellDataFunc" o = Gtk.CellLayout.CellLayoutSetCellDataFuncMethodInfo
    ResolveCellAreaBoxMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveCellAreaBoxMethod "setFocusCell" o = Gtk.CellArea.CellAreaSetFocusCellMethodInfo
    ResolveCellAreaBoxMethod "setName" o = Gtk.Buildable.BuildableSetNameMethodInfo
    ResolveCellAreaBoxMethod "setOrientation" o = Gtk.Orientable.OrientableSetOrientationMethodInfo
    ResolveCellAreaBoxMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveCellAreaBoxMethod "setSpacing" o = CellAreaBoxSetSpacingMethodInfo
    ResolveCellAreaBoxMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveCellAreaBoxMethod t CellAreaBox, O.MethodInfo info CellAreaBox p) => O.IsLabelProxy t (CellAreaBox -> p) where
    fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolveCellAreaBoxMethod t CellAreaBox, O.MethodInfo info CellAreaBox p) => O.IsLabel t (CellAreaBox -> p) where
    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif

-- VVV Prop "spacing"
   -- Type: TBasicType TInt
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getCellAreaBoxSpacing :: (MonadIO m, IsCellAreaBox o) => o -> m Int32
getCellAreaBoxSpacing obj = liftIO $ getObjectPropertyInt32 obj "spacing"

setCellAreaBoxSpacing :: (MonadIO m, IsCellAreaBox o) => o -> Int32 -> m ()
setCellAreaBoxSpacing obj val = liftIO $ setObjectPropertyInt32 obj "spacing" val

constructCellAreaBoxSpacing :: (IsCellAreaBox o) => Int32 -> IO (GValueConstruct o)
constructCellAreaBoxSpacing val = constructObjectPropertyInt32 "spacing" val

data CellAreaBoxSpacingPropertyInfo
instance AttrInfo CellAreaBoxSpacingPropertyInfo where
    type AttrAllowedOps CellAreaBoxSpacingPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint CellAreaBoxSpacingPropertyInfo = (~) Int32
    type AttrBaseTypeConstraint CellAreaBoxSpacingPropertyInfo = IsCellAreaBox
    type AttrGetType CellAreaBoxSpacingPropertyInfo = Int32
    type AttrLabel CellAreaBoxSpacingPropertyInfo = "spacing"
    type AttrOrigin CellAreaBoxSpacingPropertyInfo = CellAreaBox
    attrGet _ = getCellAreaBoxSpacing
    attrSet _ = setCellAreaBoxSpacing
    attrConstruct _ = constructCellAreaBoxSpacing
    attrClear _ = undefined

instance O.HasAttributeList CellAreaBox
type instance O.AttributeList CellAreaBox = CellAreaBoxAttributeList
type CellAreaBoxAttributeList = ('[ '("editWidget", Gtk.CellArea.CellAreaEditWidgetPropertyInfo), '("editedCell", Gtk.CellArea.CellAreaEditedCellPropertyInfo), '("focusCell", Gtk.CellArea.CellAreaFocusCellPropertyInfo), '("orientation", Gtk.Orientable.OrientableOrientationPropertyInfo), '("spacing", CellAreaBoxSpacingPropertyInfo)] :: [(Symbol, *)])

cellAreaBoxSpacing :: AttrLabelProxy "spacing"
cellAreaBoxSpacing = AttrLabelProxy

type instance O.SignalList CellAreaBox = CellAreaBoxSignalList
type CellAreaBoxSignalList = ('[ '("addEditable", Gtk.CellArea.CellAreaAddEditableSignalInfo), '("applyAttributes", Gtk.CellArea.CellAreaApplyAttributesSignalInfo), '("focusChanged", Gtk.CellArea.CellAreaFocusChangedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("removeEditable", Gtk.CellArea.CellAreaRemoveEditableSignalInfo)] :: [(Symbol, *)])

-- method CellAreaBox::new
-- method type : Constructor
-- Args : []
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "CellAreaBox"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_cell_area_box_new" gtk_cell_area_box_new :: 
    IO (Ptr CellAreaBox)

{- |
Creates a new 'GI.Gtk.Objects.CellAreaBox.CellAreaBox'.

@since 3.0
-}
cellAreaBoxNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m CellAreaBox
    {- ^ __Returns:__ a newly created 'GI.Gtk.Objects.CellAreaBox.CellAreaBox' -}
cellAreaBoxNew  = liftIO $ do
    result <- gtk_cell_area_box_new
    checkUnexpectedReturnNULL "cellAreaBoxNew" result
    result' <- (newObject CellAreaBox) result
    return result'

-- method CellAreaBox::get_spacing
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "box", argType = TInterface (Name {namespace = "Gtk", name = "CellAreaBox"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkCellAreaBox", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_cell_area_box_get_spacing" gtk_cell_area_box_get_spacing :: 
    Ptr CellAreaBox ->                      -- box : TInterface (Name {namespace = "Gtk", name = "CellAreaBox"})
    IO Int32

{- |
Gets the spacing added between cell renderers.

@since 3.0
-}
cellAreaBoxGetSpacing ::
    (B.CallStack.HasCallStack, MonadIO m, IsCellAreaBox a) =>
    a
    {- ^ /@box@/: a 'GI.Gtk.Objects.CellAreaBox.CellAreaBox' -}
    -> m Int32
    {- ^ __Returns:__ the space added between cell renderers in /@box@/. -}
cellAreaBoxGetSpacing box = liftIO $ do
    box' <- unsafeManagedPtrCastPtr box
    result <- gtk_cell_area_box_get_spacing box'
    touchManagedPtr box
    return result

data CellAreaBoxGetSpacingMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsCellAreaBox a) => O.MethodInfo CellAreaBoxGetSpacingMethodInfo a signature where
    overloadedMethod _ = cellAreaBoxGetSpacing

-- method CellAreaBox::pack_end
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "box", argType = TInterface (Name {namespace = "Gtk", name = "CellAreaBox"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkCellAreaBox", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "renderer", argType = TInterface (Name {namespace = "Gtk", name = "CellRenderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GtkCellRenderer to add", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "expand", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether @renderer should receive extra space when the area receives\nmore than its natural size", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "align", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether @renderer should be aligned in adjacent rows", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fixed", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether @renderer should have the same size in all rows", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_cell_area_box_pack_end" gtk_cell_area_box_pack_end :: 
    Ptr CellAreaBox ->                      -- box : TInterface (Name {namespace = "Gtk", name = "CellAreaBox"})
    Ptr Gtk.CellRenderer.CellRenderer ->    -- renderer : TInterface (Name {namespace = "Gtk", name = "CellRenderer"})
    CInt ->                                 -- expand : TBasicType TBoolean
    CInt ->                                 -- align : TBasicType TBoolean
    CInt ->                                 -- fixed : TBasicType TBoolean
    IO ()

{- |
Adds /@renderer@/ to /@box@/, packed with reference to the end of /@box@/.

The /@renderer@/ is packed after (away from end of) any other
'GI.Gtk.Objects.CellRenderer.CellRenderer' packed with reference to the end of /@box@/.

@since 3.0
-}
cellAreaBoxPackEnd ::
    (B.CallStack.HasCallStack, MonadIO m, IsCellAreaBox a, Gtk.CellRenderer.IsCellRenderer b) =>
    a
    {- ^ /@box@/: a 'GI.Gtk.Objects.CellAreaBox.CellAreaBox' -}
    -> b
    {- ^ /@renderer@/: the 'GI.Gtk.Objects.CellRenderer.CellRenderer' to add -}
    -> Bool
    {- ^ /@expand@/: whether /@renderer@/ should receive extra space when the area receives
more than its natural size -}
    -> Bool
    {- ^ /@align@/: whether /@renderer@/ should be aligned in adjacent rows -}
    -> Bool
    {- ^ /@fixed@/: whether /@renderer@/ should have the same size in all rows -}
    -> m ()
cellAreaBoxPackEnd box renderer expand align fixed = liftIO $ do
    box' <- unsafeManagedPtrCastPtr box
    renderer' <- unsafeManagedPtrCastPtr renderer
    let expand' = (fromIntegral . fromEnum) expand
    let align' = (fromIntegral . fromEnum) align
    let fixed' = (fromIntegral . fromEnum) fixed
    gtk_cell_area_box_pack_end box' renderer' expand' align' fixed'
    touchManagedPtr box
    touchManagedPtr renderer
    return ()

data CellAreaBoxPackEndMethodInfo
instance (signature ~ (b -> Bool -> Bool -> Bool -> m ()), MonadIO m, IsCellAreaBox a, Gtk.CellRenderer.IsCellRenderer b) => O.MethodInfo CellAreaBoxPackEndMethodInfo a signature where
    overloadedMethod _ = cellAreaBoxPackEnd

-- method CellAreaBox::pack_start
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "box", argType = TInterface (Name {namespace = "Gtk", name = "CellAreaBox"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkCellAreaBox", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "renderer", argType = TInterface (Name {namespace = "Gtk", name = "CellRenderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GtkCellRenderer to add", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "expand", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether @renderer should receive extra space when the area receives\nmore than its natural size", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "align", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether @renderer should be aligned in adjacent rows", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fixed", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether @renderer should have the same size in all rows", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_cell_area_box_pack_start" gtk_cell_area_box_pack_start :: 
    Ptr CellAreaBox ->                      -- box : TInterface (Name {namespace = "Gtk", name = "CellAreaBox"})
    Ptr Gtk.CellRenderer.CellRenderer ->    -- renderer : TInterface (Name {namespace = "Gtk", name = "CellRenderer"})
    CInt ->                                 -- expand : TBasicType TBoolean
    CInt ->                                 -- align : TBasicType TBoolean
    CInt ->                                 -- fixed : TBasicType TBoolean
    IO ()

{- |
Adds /@renderer@/ to /@box@/, packed with reference to the start of /@box@/.

The /@renderer@/ is packed after any other 'GI.Gtk.Objects.CellRenderer.CellRenderer' packed
with reference to the start of /@box@/.

@since 3.0
-}
cellAreaBoxPackStart ::
    (B.CallStack.HasCallStack, MonadIO m, IsCellAreaBox a, Gtk.CellRenderer.IsCellRenderer b) =>
    a
    {- ^ /@box@/: a 'GI.Gtk.Objects.CellAreaBox.CellAreaBox' -}
    -> b
    {- ^ /@renderer@/: the 'GI.Gtk.Objects.CellRenderer.CellRenderer' to add -}
    -> Bool
    {- ^ /@expand@/: whether /@renderer@/ should receive extra space when the area receives
more than its natural size -}
    -> Bool
    {- ^ /@align@/: whether /@renderer@/ should be aligned in adjacent rows -}
    -> Bool
    {- ^ /@fixed@/: whether /@renderer@/ should have the same size in all rows -}
    -> m ()
cellAreaBoxPackStart box renderer expand align fixed = liftIO $ do
    box' <- unsafeManagedPtrCastPtr box
    renderer' <- unsafeManagedPtrCastPtr renderer
    let expand' = (fromIntegral . fromEnum) expand
    let align' = (fromIntegral . fromEnum) align
    let fixed' = (fromIntegral . fromEnum) fixed
    gtk_cell_area_box_pack_start box' renderer' expand' align' fixed'
    touchManagedPtr box
    touchManagedPtr renderer
    return ()

data CellAreaBoxPackStartMethodInfo
instance (signature ~ (b -> Bool -> Bool -> Bool -> m ()), MonadIO m, IsCellAreaBox a, Gtk.CellRenderer.IsCellRenderer b) => O.MethodInfo CellAreaBoxPackStartMethodInfo a signature where
    overloadedMethod _ = cellAreaBoxPackStart

-- method CellAreaBox::set_spacing
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "box", argType = TInterface (Name {namespace = "Gtk", name = "CellAreaBox"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkCellAreaBox", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "spacing", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the space to add between #GtkCellRenderers", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_cell_area_box_set_spacing" gtk_cell_area_box_set_spacing :: 
    Ptr CellAreaBox ->                      -- box : TInterface (Name {namespace = "Gtk", name = "CellAreaBox"})
    Int32 ->                                -- spacing : TBasicType TInt
    IO ()

{- |
Sets the spacing to add between cell renderers in /@box@/.

@since 3.0
-}
cellAreaBoxSetSpacing ::
    (B.CallStack.HasCallStack, MonadIO m, IsCellAreaBox a) =>
    a
    {- ^ /@box@/: a 'GI.Gtk.Objects.CellAreaBox.CellAreaBox' -}
    -> Int32
    {- ^ /@spacing@/: the space to add between @/GtkCellRenderers/@ -}
    -> m ()
cellAreaBoxSetSpacing box spacing = liftIO $ do
    box' <- unsafeManagedPtrCastPtr box
    gtk_cell_area_box_set_spacing box' spacing
    touchManagedPtr box
    return ()

data CellAreaBoxSetSpacingMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m, IsCellAreaBox a) => O.MethodInfo CellAreaBoxSetSpacingMethodInfo a signature where
    overloadedMethod _ = cellAreaBoxSetSpacing