CellAreaBox.hs


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

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'.
-}

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

module GI.Gtk.Objects.CellAreaBox
    ( 

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


 -- * Methods
-- ** getSpacing #method:getSpacing#

#if ENABLE_OVERLOADING
    CellAreaBoxGetSpacingMethodInfo         ,
#endif
    cellAreaBoxGetSpacing                   ,


-- ** new #method:new#

    cellAreaBoxNew                          ,


-- ** packEnd #method:packEnd#

#if ENABLE_OVERLOADING
    CellAreaBoxPackEndMethodInfo            ,
#endif
    cellAreaBoxPackEnd                      ,


-- ** packStart #method:packStart#

#if ENABLE_OVERLOADING
    CellAreaBoxPackStartMethodInfo          ,
#endif
    cellAreaBoxPackStart                    ,


-- ** setSpacing #method:setSpacing#

#if ENABLE_OVERLOADING
    CellAreaBoxSetSpacingMethodInfo         ,
#endif
    cellAreaBoxSetSpacing                   ,




 -- * Properties
-- ** spacing #attr:spacing#
{- | The amount of space to reserve between cells.

/Since: 3.0/
-}
#if ENABLE_OVERLOADING
    CellAreaBoxSpacingPropertyInfo          ,
#endif
#if ENABLE_OVERLOADING
    cellAreaBoxSpacing                      ,
#endif
    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.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.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.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

-- | Memory-managed wrapper type.
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
    

-- | Type class for types which can be safely cast to `CellAreaBox`, for instance with `toCellAreaBox`.
class (GObject o, O.IsDescendantOf CellAreaBox o) => IsCellAreaBox o
instance (GObject o, O.IsDescendantOf CellAreaBox o) => IsCellAreaBox o

instance O.HasParentTypes CellAreaBox
type instance O.ParentTypes CellAreaBox = '[Gtk.CellArea.CellArea, GObject.Object.Object, Gtk.Buildable.Buildable, Gtk.CellLayout.CellLayout, Gtk.Orientable.Orientable]

-- | Cast to `CellAreaBox`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toCellAreaBox :: (MonadIO m, IsCellAreaBox o) => o -> m CellAreaBox
toCellAreaBox = liftIO . unsafeCastTo CellAreaBox

-- | A convenience alias for `Nothing` :: `Maybe` `CellAreaBox`.
noCellAreaBox :: Maybe CellAreaBox
noCellAreaBox = Nothing

#if ENABLE_OVERLOADING
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 "getv" o = GObject.Object.ObjectGetvMethodInfo
    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 "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) => OL.IsLabel t (CellAreaBox -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#else
    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif

#endif

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

{- |
Get the value of the “@spacing@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' cellAreaBox #spacing
@
-}
getCellAreaBoxSpacing :: (MonadIO m, IsCellAreaBox o) => o -> m Int32
getCellAreaBoxSpacing obj = liftIO $ B.Properties.getObjectPropertyInt32 obj "spacing"

{- |
Set the value of the “@spacing@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' cellAreaBox [ #spacing 'Data.GI.Base.Attributes.:=' value ]
@
-}
setCellAreaBoxSpacing :: (MonadIO m, IsCellAreaBox o) => o -> Int32 -> m ()
setCellAreaBoxSpacing obj val = liftIO $ B.Properties.setObjectPropertyInt32 obj "spacing" val

{- |
Construct a `GValueConstruct` with valid value for the “@spacing@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructCellAreaBoxSpacing :: (IsCellAreaBox o) => Int32 -> IO (GValueConstruct o)
constructCellAreaBoxSpacing val = B.Properties.constructObjectPropertyInt32 "spacing" val

#if ENABLE_OVERLOADING
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
#endif

#if ENABLE_OVERLOADING
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, *)])
#endif

#if ENABLE_OVERLOADING
cellAreaBoxSpacing :: AttrLabelProxy "spacing"
cellAreaBoxSpacing = AttrLabelProxy

#endif

#if ENABLE_OVERLOADING
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, *)])

#endif

-- 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'

#if ENABLE_OVERLOADING
#endif

-- 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

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

#endif

-- 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 ()

#if ENABLE_OVERLOADING
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

#endif

-- 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 ()

#if ENABLE_OVERLOADING
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

#endif

-- 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 ()

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

#endif