gi-gtk-3.0.28: GI/Gtk/Objects/TreeViewColumn.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 GtkTreeViewColumn object represents a visible column in a 'GI.Gtk.Objects.TreeView.TreeView' widget.
It allows to set properties of the column header, and functions as a holding pen for
the cell renderers which determine how the data in the column is displayed.

Please refer to the [tree widget conceptual overview][TreeWidget]
for an overview of all the objects and data types related to the tree widget and how
they work together.
-}

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

module GI.Gtk.Objects.TreeViewColumn
    ( 

-- * Exported types
    TreeViewColumn(..)                      ,
    IsTreeViewColumn                        ,
    toTreeViewColumn                        ,
    noTreeViewColumn                        ,


 -- * Methods
-- ** addAttribute #method:addAttribute#

#if ENABLE_OVERLOADING
    TreeViewColumnAddAttributeMethodInfo    ,
#endif
    treeViewColumnAddAttribute              ,


-- ** cellGetPosition #method:cellGetPosition#

#if ENABLE_OVERLOADING
    TreeViewColumnCellGetPositionMethodInfo ,
#endif
    treeViewColumnCellGetPosition           ,


-- ** cellGetSize #method:cellGetSize#

#if ENABLE_OVERLOADING
    TreeViewColumnCellGetSizeMethodInfo     ,
#endif
    treeViewColumnCellGetSize               ,


-- ** cellIsVisible #method:cellIsVisible#

#if ENABLE_OVERLOADING
    TreeViewColumnCellIsVisibleMethodInfo   ,
#endif
    treeViewColumnCellIsVisible             ,


-- ** cellSetCellData #method:cellSetCellData#

#if ENABLE_OVERLOADING
    TreeViewColumnCellSetCellDataMethodInfo ,
#endif
    treeViewColumnCellSetCellData           ,


-- ** clear #method:clear#

#if ENABLE_OVERLOADING
    TreeViewColumnClearMethodInfo           ,
#endif
    treeViewColumnClear                     ,


-- ** clearAttributes #method:clearAttributes#

#if ENABLE_OVERLOADING
    TreeViewColumnClearAttributesMethodInfo ,
#endif
    treeViewColumnClearAttributes           ,


-- ** clicked #method:clicked#

#if ENABLE_OVERLOADING
    TreeViewColumnClickedMethodInfo         ,
#endif
    treeViewColumnClicked                   ,


-- ** focusCell #method:focusCell#

#if ENABLE_OVERLOADING
    TreeViewColumnFocusCellMethodInfo       ,
#endif
    treeViewColumnFocusCell                 ,


-- ** getAlignment #method:getAlignment#

#if ENABLE_OVERLOADING
    TreeViewColumnGetAlignmentMethodInfo    ,
#endif
    treeViewColumnGetAlignment              ,


-- ** getButton #method:getButton#

#if ENABLE_OVERLOADING
    TreeViewColumnGetButtonMethodInfo       ,
#endif
    treeViewColumnGetButton                 ,


-- ** getClickable #method:getClickable#

#if ENABLE_OVERLOADING
    TreeViewColumnGetClickableMethodInfo    ,
#endif
    treeViewColumnGetClickable              ,


-- ** getExpand #method:getExpand#

#if ENABLE_OVERLOADING
    TreeViewColumnGetExpandMethodInfo       ,
#endif
    treeViewColumnGetExpand                 ,


-- ** getFixedWidth #method:getFixedWidth#

#if ENABLE_OVERLOADING
    TreeViewColumnGetFixedWidthMethodInfo   ,
#endif
    treeViewColumnGetFixedWidth             ,


-- ** getMaxWidth #method:getMaxWidth#

#if ENABLE_OVERLOADING
    TreeViewColumnGetMaxWidthMethodInfo     ,
#endif
    treeViewColumnGetMaxWidth               ,


-- ** getMinWidth #method:getMinWidth#

#if ENABLE_OVERLOADING
    TreeViewColumnGetMinWidthMethodInfo     ,
#endif
    treeViewColumnGetMinWidth               ,


-- ** getReorderable #method:getReorderable#

#if ENABLE_OVERLOADING
    TreeViewColumnGetReorderableMethodInfo  ,
#endif
    treeViewColumnGetReorderable            ,


-- ** getResizable #method:getResizable#

#if ENABLE_OVERLOADING
    TreeViewColumnGetResizableMethodInfo    ,
#endif
    treeViewColumnGetResizable              ,


-- ** getSizing #method:getSizing#

#if ENABLE_OVERLOADING
    TreeViewColumnGetSizingMethodInfo       ,
#endif
    treeViewColumnGetSizing                 ,


-- ** getSortColumnId #method:getSortColumnId#

#if ENABLE_OVERLOADING
    TreeViewColumnGetSortColumnIdMethodInfo ,
#endif
    treeViewColumnGetSortColumnId           ,


-- ** getSortIndicator #method:getSortIndicator#

#if ENABLE_OVERLOADING
    TreeViewColumnGetSortIndicatorMethodInfo,
#endif
    treeViewColumnGetSortIndicator          ,


-- ** getSortOrder #method:getSortOrder#

#if ENABLE_OVERLOADING
    TreeViewColumnGetSortOrderMethodInfo    ,
#endif
    treeViewColumnGetSortOrder              ,


-- ** getSpacing #method:getSpacing#

#if ENABLE_OVERLOADING
    TreeViewColumnGetSpacingMethodInfo      ,
#endif
    treeViewColumnGetSpacing                ,


-- ** getTitle #method:getTitle#

#if ENABLE_OVERLOADING
    TreeViewColumnGetTitleMethodInfo        ,
#endif
    treeViewColumnGetTitle                  ,


-- ** getTreeView #method:getTreeView#

#if ENABLE_OVERLOADING
    TreeViewColumnGetTreeViewMethodInfo     ,
#endif
    treeViewColumnGetTreeView               ,


-- ** getVisible #method:getVisible#

#if ENABLE_OVERLOADING
    TreeViewColumnGetVisibleMethodInfo      ,
#endif
    treeViewColumnGetVisible                ,


-- ** getWidget #method:getWidget#

#if ENABLE_OVERLOADING
    TreeViewColumnGetWidgetMethodInfo       ,
#endif
    treeViewColumnGetWidget                 ,


-- ** getWidth #method:getWidth#

#if ENABLE_OVERLOADING
    TreeViewColumnGetWidthMethodInfo        ,
#endif
    treeViewColumnGetWidth                  ,


-- ** getXOffset #method:getXOffset#

#if ENABLE_OVERLOADING
    TreeViewColumnGetXOffsetMethodInfo      ,
#endif
    treeViewColumnGetXOffset                ,


-- ** new #method:new#

    treeViewColumnNew                       ,


-- ** newWithArea #method:newWithArea#

    treeViewColumnNewWithArea               ,


-- ** packEnd #method:packEnd#

#if ENABLE_OVERLOADING
    TreeViewColumnPackEndMethodInfo         ,
#endif
    treeViewColumnPackEnd                   ,


-- ** packStart #method:packStart#

#if ENABLE_OVERLOADING
    TreeViewColumnPackStartMethodInfo       ,
#endif
    treeViewColumnPackStart                 ,


-- ** queueResize #method:queueResize#

#if ENABLE_OVERLOADING
    TreeViewColumnQueueResizeMethodInfo     ,
#endif
    treeViewColumnQueueResize               ,


-- ** setAlignment #method:setAlignment#

#if ENABLE_OVERLOADING
    TreeViewColumnSetAlignmentMethodInfo    ,
#endif
    treeViewColumnSetAlignment              ,


-- ** setCellDataFunc #method:setCellDataFunc#

#if ENABLE_OVERLOADING
    TreeViewColumnSetCellDataFuncMethodInfo ,
#endif
    treeViewColumnSetCellDataFunc           ,


-- ** setClickable #method:setClickable#

#if ENABLE_OVERLOADING
    TreeViewColumnSetClickableMethodInfo    ,
#endif
    treeViewColumnSetClickable              ,


-- ** setExpand #method:setExpand#

#if ENABLE_OVERLOADING
    TreeViewColumnSetExpandMethodInfo       ,
#endif
    treeViewColumnSetExpand                 ,


-- ** setFixedWidth #method:setFixedWidth#

#if ENABLE_OVERLOADING
    TreeViewColumnSetFixedWidthMethodInfo   ,
#endif
    treeViewColumnSetFixedWidth             ,


-- ** setMaxWidth #method:setMaxWidth#

#if ENABLE_OVERLOADING
    TreeViewColumnSetMaxWidthMethodInfo     ,
#endif
    treeViewColumnSetMaxWidth               ,


-- ** setMinWidth #method:setMinWidth#

#if ENABLE_OVERLOADING
    TreeViewColumnSetMinWidthMethodInfo     ,
#endif
    treeViewColumnSetMinWidth               ,


-- ** setReorderable #method:setReorderable#

#if ENABLE_OVERLOADING
    TreeViewColumnSetReorderableMethodInfo  ,
#endif
    treeViewColumnSetReorderable            ,


-- ** setResizable #method:setResizable#

#if ENABLE_OVERLOADING
    TreeViewColumnSetResizableMethodInfo    ,
#endif
    treeViewColumnSetResizable              ,


-- ** setSizing #method:setSizing#

#if ENABLE_OVERLOADING
    TreeViewColumnSetSizingMethodInfo       ,
#endif
    treeViewColumnSetSizing                 ,


-- ** setSortColumnId #method:setSortColumnId#

#if ENABLE_OVERLOADING
    TreeViewColumnSetSortColumnIdMethodInfo ,
#endif
    treeViewColumnSetSortColumnId           ,


-- ** setSortIndicator #method:setSortIndicator#

#if ENABLE_OVERLOADING
    TreeViewColumnSetSortIndicatorMethodInfo,
#endif
    treeViewColumnSetSortIndicator          ,


-- ** setSortOrder #method:setSortOrder#

#if ENABLE_OVERLOADING
    TreeViewColumnSetSortOrderMethodInfo    ,
#endif
    treeViewColumnSetSortOrder              ,


-- ** setSpacing #method:setSpacing#

#if ENABLE_OVERLOADING
    TreeViewColumnSetSpacingMethodInfo      ,
#endif
    treeViewColumnSetSpacing                ,


-- ** setTitle #method:setTitle#

#if ENABLE_OVERLOADING
    TreeViewColumnSetTitleMethodInfo        ,
#endif
    treeViewColumnSetTitle                  ,


-- ** setVisible #method:setVisible#

#if ENABLE_OVERLOADING
    TreeViewColumnSetVisibleMethodInfo      ,
#endif
    treeViewColumnSetVisible                ,


-- ** setWidget #method:setWidget#

#if ENABLE_OVERLOADING
    TreeViewColumnSetWidgetMethodInfo       ,
#endif
    treeViewColumnSetWidget                 ,




 -- * Properties
-- ** alignment #attr:alignment#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    TreeViewColumnAlignmentPropertyInfo     ,
#endif
    constructTreeViewColumnAlignment        ,
    getTreeViewColumnAlignment              ,
    setTreeViewColumnAlignment              ,
#if ENABLE_OVERLOADING
    treeViewColumnAlignment                 ,
#endif


-- ** cellArea #attr:cellArea#
{- | The 'GI.Gtk.Objects.CellArea.CellArea' used to layout cell renderers for this column.

If no area is specified when creating the tree view column with 'GI.Gtk.Objects.TreeViewColumn.treeViewColumnNewWithArea'
a horizontally oriented 'GI.Gtk.Objects.CellAreaBox.CellAreaBox' will be used.

/Since: 3.0/
-}
#if ENABLE_OVERLOADING
    TreeViewColumnCellAreaPropertyInfo      ,
#endif
    constructTreeViewColumnCellArea         ,
    getTreeViewColumnCellArea               ,
#if ENABLE_OVERLOADING
    treeViewColumnCellArea                  ,
#endif


-- ** clickable #attr:clickable#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    TreeViewColumnClickablePropertyInfo     ,
#endif
    constructTreeViewColumnClickable        ,
    getTreeViewColumnClickable              ,
    setTreeViewColumnClickable              ,
#if ENABLE_OVERLOADING
    treeViewColumnClickable                 ,
#endif


-- ** expand #attr:expand#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    TreeViewColumnExpandPropertyInfo        ,
#endif
    constructTreeViewColumnExpand           ,
    getTreeViewColumnExpand                 ,
    setTreeViewColumnExpand                 ,
#if ENABLE_OVERLOADING
    treeViewColumnExpand                    ,
#endif


-- ** fixedWidth #attr:fixedWidth#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    TreeViewColumnFixedWidthPropertyInfo    ,
#endif
    constructTreeViewColumnFixedWidth       ,
    getTreeViewColumnFixedWidth             ,
    setTreeViewColumnFixedWidth             ,
#if ENABLE_OVERLOADING
    treeViewColumnFixedWidth                ,
#endif


-- ** maxWidth #attr:maxWidth#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    TreeViewColumnMaxWidthPropertyInfo      ,
#endif
    constructTreeViewColumnMaxWidth         ,
    getTreeViewColumnMaxWidth               ,
    setTreeViewColumnMaxWidth               ,
#if ENABLE_OVERLOADING
    treeViewColumnMaxWidth                  ,
#endif


-- ** minWidth #attr:minWidth#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    TreeViewColumnMinWidthPropertyInfo      ,
#endif
    constructTreeViewColumnMinWidth         ,
    getTreeViewColumnMinWidth               ,
    setTreeViewColumnMinWidth               ,
#if ENABLE_OVERLOADING
    treeViewColumnMinWidth                  ,
#endif


-- ** reorderable #attr:reorderable#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    TreeViewColumnReorderablePropertyInfo   ,
#endif
    constructTreeViewColumnReorderable      ,
    getTreeViewColumnReorderable            ,
    setTreeViewColumnReorderable            ,
#if ENABLE_OVERLOADING
    treeViewColumnReorderable               ,
#endif


-- ** resizable #attr:resizable#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    TreeViewColumnResizablePropertyInfo     ,
#endif
    constructTreeViewColumnResizable        ,
    getTreeViewColumnResizable              ,
    setTreeViewColumnResizable              ,
#if ENABLE_OVERLOADING
    treeViewColumnResizable                 ,
#endif


-- ** sizing #attr:sizing#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    TreeViewColumnSizingPropertyInfo        ,
#endif
    constructTreeViewColumnSizing           ,
    getTreeViewColumnSizing                 ,
    setTreeViewColumnSizing                 ,
#if ENABLE_OVERLOADING
    treeViewColumnSizing                    ,
#endif


-- ** sortColumnId #attr:sortColumnId#
{- | Logical sort column ID this column sorts on when selected for sorting. Setting the sort column ID makes the column header
clickable. Set to -1 to make the column unsortable.

/Since: 2.18/
-}
#if ENABLE_OVERLOADING
    TreeViewColumnSortColumnIdPropertyInfo  ,
#endif
    constructTreeViewColumnSortColumnId     ,
    getTreeViewColumnSortColumnId           ,
    setTreeViewColumnSortColumnId           ,
#if ENABLE_OVERLOADING
    treeViewColumnSortColumnId              ,
#endif


-- ** sortIndicator #attr:sortIndicator#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    TreeViewColumnSortIndicatorPropertyInfo ,
#endif
    constructTreeViewColumnSortIndicator    ,
    getTreeViewColumnSortIndicator          ,
    setTreeViewColumnSortIndicator          ,
#if ENABLE_OVERLOADING
    treeViewColumnSortIndicator             ,
#endif


-- ** sortOrder #attr:sortOrder#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    TreeViewColumnSortOrderPropertyInfo     ,
#endif
    constructTreeViewColumnSortOrder        ,
    getTreeViewColumnSortOrder              ,
    setTreeViewColumnSortOrder              ,
#if ENABLE_OVERLOADING
    treeViewColumnSortOrder                 ,
#endif


-- ** spacing #attr:spacing#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    TreeViewColumnSpacingPropertyInfo       ,
#endif
    constructTreeViewColumnSpacing          ,
    getTreeViewColumnSpacing                ,
    setTreeViewColumnSpacing                ,
#if ENABLE_OVERLOADING
    treeViewColumnSpacing                   ,
#endif


-- ** title #attr:title#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    TreeViewColumnTitlePropertyInfo         ,
#endif
    constructTreeViewColumnTitle            ,
    getTreeViewColumnTitle                  ,
    setTreeViewColumnTitle                  ,
#if ENABLE_OVERLOADING
    treeViewColumnTitle                     ,
#endif


-- ** visible #attr:visible#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    TreeViewColumnVisiblePropertyInfo       ,
#endif
    constructTreeViewColumnVisible          ,
    getTreeViewColumnVisible                ,
    setTreeViewColumnVisible                ,
#if ENABLE_OVERLOADING
    treeViewColumnVisible                   ,
#endif


-- ** widget #attr:widget#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    TreeViewColumnWidgetPropertyInfo        ,
#endif
    clearTreeViewColumnWidget               ,
    constructTreeViewColumnWidget           ,
    getTreeViewColumnWidget                 ,
    setTreeViewColumnWidget                 ,
#if ENABLE_OVERLOADING
    treeViewColumnWidget                    ,
#endif


-- ** width #attr:width#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    TreeViewColumnWidthPropertyInfo         ,
#endif
    getTreeViewColumnWidth                  ,
#if ENABLE_OVERLOADING
    treeViewColumnWidth                     ,
#endif


-- ** xOffset #attr:xOffset#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    TreeViewColumnXOffsetPropertyInfo       ,
#endif
    getTreeViewColumnXOffset                ,
#if ENABLE_OVERLOADING
    treeViewColumnXOffset                   ,
#endif




 -- * Signals
-- ** clicked #signal:clicked#

    C_TreeViewColumnClickedCallback         ,
    TreeViewColumnClickedCallback           ,
#if ENABLE_OVERLOADING
    TreeViewColumnClickedSignalInfo         ,
#endif
    afterTreeViewColumnClicked              ,
    genClosure_TreeViewColumnClicked        ,
    mk_TreeViewColumnClickedCallback        ,
    noTreeViewColumnClickedCallback         ,
    onTreeViewColumnClicked                 ,
    wrap_TreeViewColumnClickedCallback      ,




    ) 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.GLib.Callbacks as GLib.Callbacks
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gdk.Structs.Rectangle as Gdk.Rectangle
import qualified GI.Gtk.Callbacks as Gtk.Callbacks
import {-# SOURCE #-} qualified GI.Gtk.Enums as Gtk.Enums
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.TreeModel as Gtk.TreeModel
import {-# SOURCE #-} qualified GI.Gtk.Objects.CellArea as Gtk.CellArea
import {-# SOURCE #-} qualified GI.Gtk.Objects.CellRenderer as Gtk.CellRenderer
import {-# SOURCE #-} qualified GI.Gtk.Objects.Widget as Gtk.Widget
import {-# SOURCE #-} qualified GI.Gtk.Structs.TreeIter as Gtk.TreeIter

-- | Memory-managed wrapper type.
newtype TreeViewColumn = TreeViewColumn (ManagedPtr TreeViewColumn)
foreign import ccall "gtk_tree_view_column_get_type"
    c_gtk_tree_view_column_get_type :: IO GType

instance GObject TreeViewColumn where
    gobjectType = c_gtk_tree_view_column_get_type
    

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

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

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

-- | A convenience alias for `Nothing` :: `Maybe` `TreeViewColumn`.
noTreeViewColumn :: Maybe TreeViewColumn
noTreeViewColumn = Nothing

#if ENABLE_OVERLOADING
type family ResolveTreeViewColumnMethod (t :: Symbol) (o :: *) :: * where
    ResolveTreeViewColumnMethod "addAttribute" o = TreeViewColumnAddAttributeMethodInfo
    ResolveTreeViewColumnMethod "addChild" o = Gtk.Buildable.BuildableAddChildMethodInfo
    ResolveTreeViewColumnMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveTreeViewColumnMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveTreeViewColumnMethod "cellGetPosition" o = TreeViewColumnCellGetPositionMethodInfo
    ResolveTreeViewColumnMethod "cellGetSize" o = TreeViewColumnCellGetSizeMethodInfo
    ResolveTreeViewColumnMethod "cellIsVisible" o = TreeViewColumnCellIsVisibleMethodInfo
    ResolveTreeViewColumnMethod "cellSetCellData" o = TreeViewColumnCellSetCellDataMethodInfo
    ResolveTreeViewColumnMethod "clear" o = TreeViewColumnClearMethodInfo
    ResolveTreeViewColumnMethod "clearAttributes" o = TreeViewColumnClearAttributesMethodInfo
    ResolveTreeViewColumnMethod "clicked" o = TreeViewColumnClickedMethodInfo
    ResolveTreeViewColumnMethod "constructChild" o = Gtk.Buildable.BuildableConstructChildMethodInfo
    ResolveTreeViewColumnMethod "customFinished" o = Gtk.Buildable.BuildableCustomFinishedMethodInfo
    ResolveTreeViewColumnMethod "customTagEnd" o = Gtk.Buildable.BuildableCustomTagEndMethodInfo
    ResolveTreeViewColumnMethod "customTagStart" o = Gtk.Buildable.BuildableCustomTagStartMethodInfo
    ResolveTreeViewColumnMethod "focusCell" o = TreeViewColumnFocusCellMethodInfo
    ResolveTreeViewColumnMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveTreeViewColumnMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveTreeViewColumnMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveTreeViewColumnMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveTreeViewColumnMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveTreeViewColumnMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveTreeViewColumnMethod "packEnd" o = TreeViewColumnPackEndMethodInfo
    ResolveTreeViewColumnMethod "packStart" o = TreeViewColumnPackStartMethodInfo
    ResolveTreeViewColumnMethod "parserFinished" o = Gtk.Buildable.BuildableParserFinishedMethodInfo
    ResolveTreeViewColumnMethod "queueResize" o = TreeViewColumnQueueResizeMethodInfo
    ResolveTreeViewColumnMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveTreeViewColumnMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveTreeViewColumnMethod "reorder" o = Gtk.CellLayout.CellLayoutReorderMethodInfo
    ResolveTreeViewColumnMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveTreeViewColumnMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveTreeViewColumnMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveTreeViewColumnMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveTreeViewColumnMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveTreeViewColumnMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveTreeViewColumnMethod "getAlignment" o = TreeViewColumnGetAlignmentMethodInfo
    ResolveTreeViewColumnMethod "getArea" o = Gtk.CellLayout.CellLayoutGetAreaMethodInfo
    ResolveTreeViewColumnMethod "getButton" o = TreeViewColumnGetButtonMethodInfo
    ResolveTreeViewColumnMethod "getCells" o = Gtk.CellLayout.CellLayoutGetCellsMethodInfo
    ResolveTreeViewColumnMethod "getClickable" o = TreeViewColumnGetClickableMethodInfo
    ResolveTreeViewColumnMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveTreeViewColumnMethod "getExpand" o = TreeViewColumnGetExpandMethodInfo
    ResolveTreeViewColumnMethod "getFixedWidth" o = TreeViewColumnGetFixedWidthMethodInfo
    ResolveTreeViewColumnMethod "getInternalChild" o = Gtk.Buildable.BuildableGetInternalChildMethodInfo
    ResolveTreeViewColumnMethod "getMaxWidth" o = TreeViewColumnGetMaxWidthMethodInfo
    ResolveTreeViewColumnMethod "getMinWidth" o = TreeViewColumnGetMinWidthMethodInfo
    ResolveTreeViewColumnMethod "getName" o = Gtk.Buildable.BuildableGetNameMethodInfo
    ResolveTreeViewColumnMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveTreeViewColumnMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveTreeViewColumnMethod "getReorderable" o = TreeViewColumnGetReorderableMethodInfo
    ResolveTreeViewColumnMethod "getResizable" o = TreeViewColumnGetResizableMethodInfo
    ResolveTreeViewColumnMethod "getSizing" o = TreeViewColumnGetSizingMethodInfo
    ResolveTreeViewColumnMethod "getSortColumnId" o = TreeViewColumnGetSortColumnIdMethodInfo
    ResolveTreeViewColumnMethod "getSortIndicator" o = TreeViewColumnGetSortIndicatorMethodInfo
    ResolveTreeViewColumnMethod "getSortOrder" o = TreeViewColumnGetSortOrderMethodInfo
    ResolveTreeViewColumnMethod "getSpacing" o = TreeViewColumnGetSpacingMethodInfo
    ResolveTreeViewColumnMethod "getTitle" o = TreeViewColumnGetTitleMethodInfo
    ResolveTreeViewColumnMethod "getTreeView" o = TreeViewColumnGetTreeViewMethodInfo
    ResolveTreeViewColumnMethod "getVisible" o = TreeViewColumnGetVisibleMethodInfo
    ResolveTreeViewColumnMethod "getWidget" o = TreeViewColumnGetWidgetMethodInfo
    ResolveTreeViewColumnMethod "getWidth" o = TreeViewColumnGetWidthMethodInfo
    ResolveTreeViewColumnMethod "getXOffset" o = TreeViewColumnGetXOffsetMethodInfo
    ResolveTreeViewColumnMethod "setAlignment" o = TreeViewColumnSetAlignmentMethodInfo
    ResolveTreeViewColumnMethod "setBuildableProperty" o = Gtk.Buildable.BuildableSetBuildablePropertyMethodInfo
    ResolveTreeViewColumnMethod "setCellDataFunc" o = TreeViewColumnSetCellDataFuncMethodInfo
    ResolveTreeViewColumnMethod "setClickable" o = TreeViewColumnSetClickableMethodInfo
    ResolveTreeViewColumnMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveTreeViewColumnMethod "setExpand" o = TreeViewColumnSetExpandMethodInfo
    ResolveTreeViewColumnMethod "setFixedWidth" o = TreeViewColumnSetFixedWidthMethodInfo
    ResolveTreeViewColumnMethod "setMaxWidth" o = TreeViewColumnSetMaxWidthMethodInfo
    ResolveTreeViewColumnMethod "setMinWidth" o = TreeViewColumnSetMinWidthMethodInfo
    ResolveTreeViewColumnMethod "setName" o = Gtk.Buildable.BuildableSetNameMethodInfo
    ResolveTreeViewColumnMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveTreeViewColumnMethod "setReorderable" o = TreeViewColumnSetReorderableMethodInfo
    ResolveTreeViewColumnMethod "setResizable" o = TreeViewColumnSetResizableMethodInfo
    ResolveTreeViewColumnMethod "setSizing" o = TreeViewColumnSetSizingMethodInfo
    ResolveTreeViewColumnMethod "setSortColumnId" o = TreeViewColumnSetSortColumnIdMethodInfo
    ResolveTreeViewColumnMethod "setSortIndicator" o = TreeViewColumnSetSortIndicatorMethodInfo
    ResolveTreeViewColumnMethod "setSortOrder" o = TreeViewColumnSetSortOrderMethodInfo
    ResolveTreeViewColumnMethod "setSpacing" o = TreeViewColumnSetSpacingMethodInfo
    ResolveTreeViewColumnMethod "setTitle" o = TreeViewColumnSetTitleMethodInfo
    ResolveTreeViewColumnMethod "setVisible" o = TreeViewColumnSetVisibleMethodInfo
    ResolveTreeViewColumnMethod "setWidget" o = TreeViewColumnSetWidgetMethodInfo
    ResolveTreeViewColumnMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveTreeViewColumnMethod t TreeViewColumn, O.MethodInfo info TreeViewColumn p) => OL.IsLabel t (TreeViewColumn -> 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

-- signal TreeViewColumn::clicked
{- |
/No description available in the introspection data./
-}
type TreeViewColumnClickedCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TreeViewColumnClickedCallback`@.
noTreeViewColumnClickedCallback :: Maybe TreeViewColumnClickedCallback
noTreeViewColumnClickedCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_TreeViewColumnClickedCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_TreeViewColumnClickedCallback`.
foreign import ccall "wrapper"
    mk_TreeViewColumnClickedCallback :: C_TreeViewColumnClickedCallback -> IO (FunPtr C_TreeViewColumnClickedCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_TreeViewColumnClicked :: MonadIO m => TreeViewColumnClickedCallback -> m (GClosure C_TreeViewColumnClickedCallback)
genClosure_TreeViewColumnClicked cb = liftIO $ do
    let cb' = wrap_TreeViewColumnClickedCallback cb
    mk_TreeViewColumnClickedCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `TreeViewColumnClickedCallback` into a `C_TreeViewColumnClickedCallback`.
wrap_TreeViewColumnClickedCallback ::
    TreeViewColumnClickedCallback ->
    C_TreeViewColumnClickedCallback
wrap_TreeViewColumnClickedCallback _cb _ _ = do
    _cb 


{- |
Connect a signal handler for the “@clicked@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' treeViewColumn #clicked callback
@
-}
onTreeViewColumnClicked :: (IsTreeViewColumn a, MonadIO m) => a -> TreeViewColumnClickedCallback -> m SignalHandlerId
onTreeViewColumnClicked obj cb = liftIO $ do
    let cb' = wrap_TreeViewColumnClickedCallback cb
    cb'' <- mk_TreeViewColumnClickedCallback cb'
    connectSignalFunPtr obj "clicked" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@clicked@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' treeViewColumn #clicked callback
@
-}
afterTreeViewColumnClicked :: (IsTreeViewColumn a, MonadIO m) => a -> TreeViewColumnClickedCallback -> m SignalHandlerId
afterTreeViewColumnClicked obj cb = liftIO $ do
    let cb' = wrap_TreeViewColumnClickedCallback cb
    cb'' <- mk_TreeViewColumnClickedCallback cb'
    connectSignalFunPtr obj "clicked" cb'' SignalConnectAfter


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

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

@
'Data.GI.Base.Attributes.get' treeViewColumn #alignment
@
-}
getTreeViewColumnAlignment :: (MonadIO m, IsTreeViewColumn o) => o -> m Float
getTreeViewColumnAlignment obj = liftIO $ B.Properties.getObjectPropertyFloat obj "alignment"

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

@
'Data.GI.Base.Attributes.set' treeViewColumn [ #alignment 'Data.GI.Base.Attributes.:=' value ]
@
-}
setTreeViewColumnAlignment :: (MonadIO m, IsTreeViewColumn o) => o -> Float -> m ()
setTreeViewColumnAlignment obj val = liftIO $ B.Properties.setObjectPropertyFloat obj "alignment" val

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

#if ENABLE_OVERLOADING
data TreeViewColumnAlignmentPropertyInfo
instance AttrInfo TreeViewColumnAlignmentPropertyInfo where
    type AttrAllowedOps TreeViewColumnAlignmentPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint TreeViewColumnAlignmentPropertyInfo = (~) Float
    type AttrBaseTypeConstraint TreeViewColumnAlignmentPropertyInfo = IsTreeViewColumn
    type AttrGetType TreeViewColumnAlignmentPropertyInfo = Float
    type AttrLabel TreeViewColumnAlignmentPropertyInfo = "alignment"
    type AttrOrigin TreeViewColumnAlignmentPropertyInfo = TreeViewColumn
    attrGet _ = getTreeViewColumnAlignment
    attrSet _ = setTreeViewColumnAlignment
    attrConstruct _ = constructTreeViewColumnAlignment
    attrClear _ = undefined
#endif

-- VVV Prop "cell-area"
   -- Type: TInterface (Name {namespace = "Gtk", name = "CellArea"})
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Nothing,Nothing)

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

@
'Data.GI.Base.Attributes.get' treeViewColumn #cellArea
@
-}
getTreeViewColumnCellArea :: (MonadIO m, IsTreeViewColumn o) => o -> m (Maybe Gtk.CellArea.CellArea)
getTreeViewColumnCellArea obj = liftIO $ B.Properties.getObjectPropertyObject obj "cell-area" Gtk.CellArea.CellArea

{- |
Construct a `GValueConstruct` with valid value for the “@cell-area@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructTreeViewColumnCellArea :: (IsTreeViewColumn o, Gtk.CellArea.IsCellArea a) => a -> IO (GValueConstruct o)
constructTreeViewColumnCellArea val = B.Properties.constructObjectPropertyObject "cell-area" (Just val)

#if ENABLE_OVERLOADING
data TreeViewColumnCellAreaPropertyInfo
instance AttrInfo TreeViewColumnCellAreaPropertyInfo where
    type AttrAllowedOps TreeViewColumnCellAreaPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint TreeViewColumnCellAreaPropertyInfo = Gtk.CellArea.IsCellArea
    type AttrBaseTypeConstraint TreeViewColumnCellAreaPropertyInfo = IsTreeViewColumn
    type AttrGetType TreeViewColumnCellAreaPropertyInfo = (Maybe Gtk.CellArea.CellArea)
    type AttrLabel TreeViewColumnCellAreaPropertyInfo = "cell-area"
    type AttrOrigin TreeViewColumnCellAreaPropertyInfo = TreeViewColumn
    attrGet _ = getTreeViewColumnCellArea
    attrSet _ = undefined
    attrConstruct _ = constructTreeViewColumnCellArea
    attrClear _ = undefined
#endif

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

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

@
'Data.GI.Base.Attributes.get' treeViewColumn #clickable
@
-}
getTreeViewColumnClickable :: (MonadIO m, IsTreeViewColumn o) => o -> m Bool
getTreeViewColumnClickable obj = liftIO $ B.Properties.getObjectPropertyBool obj "clickable"

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

@
'Data.GI.Base.Attributes.set' treeViewColumn [ #clickable 'Data.GI.Base.Attributes.:=' value ]
@
-}
setTreeViewColumnClickable :: (MonadIO m, IsTreeViewColumn o) => o -> Bool -> m ()
setTreeViewColumnClickable obj val = liftIO $ B.Properties.setObjectPropertyBool obj "clickable" val

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

#if ENABLE_OVERLOADING
data TreeViewColumnClickablePropertyInfo
instance AttrInfo TreeViewColumnClickablePropertyInfo where
    type AttrAllowedOps TreeViewColumnClickablePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint TreeViewColumnClickablePropertyInfo = (~) Bool
    type AttrBaseTypeConstraint TreeViewColumnClickablePropertyInfo = IsTreeViewColumn
    type AttrGetType TreeViewColumnClickablePropertyInfo = Bool
    type AttrLabel TreeViewColumnClickablePropertyInfo = "clickable"
    type AttrOrigin TreeViewColumnClickablePropertyInfo = TreeViewColumn
    attrGet _ = getTreeViewColumnClickable
    attrSet _ = setTreeViewColumnClickable
    attrConstruct _ = constructTreeViewColumnClickable
    attrClear _ = undefined
#endif

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

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

@
'Data.GI.Base.Attributes.get' treeViewColumn #expand
@
-}
getTreeViewColumnExpand :: (MonadIO m, IsTreeViewColumn o) => o -> m Bool
getTreeViewColumnExpand obj = liftIO $ B.Properties.getObjectPropertyBool obj "expand"

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

@
'Data.GI.Base.Attributes.set' treeViewColumn [ #expand 'Data.GI.Base.Attributes.:=' value ]
@
-}
setTreeViewColumnExpand :: (MonadIO m, IsTreeViewColumn o) => o -> Bool -> m ()
setTreeViewColumnExpand obj val = liftIO $ B.Properties.setObjectPropertyBool obj "expand" val

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

#if ENABLE_OVERLOADING
data TreeViewColumnExpandPropertyInfo
instance AttrInfo TreeViewColumnExpandPropertyInfo where
    type AttrAllowedOps TreeViewColumnExpandPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint TreeViewColumnExpandPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint TreeViewColumnExpandPropertyInfo = IsTreeViewColumn
    type AttrGetType TreeViewColumnExpandPropertyInfo = Bool
    type AttrLabel TreeViewColumnExpandPropertyInfo = "expand"
    type AttrOrigin TreeViewColumnExpandPropertyInfo = TreeViewColumn
    attrGet _ = getTreeViewColumnExpand
    attrSet _ = setTreeViewColumnExpand
    attrConstruct _ = constructTreeViewColumnExpand
    attrClear _ = undefined
#endif

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

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

@
'Data.GI.Base.Attributes.get' treeViewColumn #fixedWidth
@
-}
getTreeViewColumnFixedWidth :: (MonadIO m, IsTreeViewColumn o) => o -> m Int32
getTreeViewColumnFixedWidth obj = liftIO $ B.Properties.getObjectPropertyInt32 obj "fixed-width"

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

@
'Data.GI.Base.Attributes.set' treeViewColumn [ #fixedWidth 'Data.GI.Base.Attributes.:=' value ]
@
-}
setTreeViewColumnFixedWidth :: (MonadIO m, IsTreeViewColumn o) => o -> Int32 -> m ()
setTreeViewColumnFixedWidth obj val = liftIO $ B.Properties.setObjectPropertyInt32 obj "fixed-width" val

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

#if ENABLE_OVERLOADING
data TreeViewColumnFixedWidthPropertyInfo
instance AttrInfo TreeViewColumnFixedWidthPropertyInfo where
    type AttrAllowedOps TreeViewColumnFixedWidthPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint TreeViewColumnFixedWidthPropertyInfo = (~) Int32
    type AttrBaseTypeConstraint TreeViewColumnFixedWidthPropertyInfo = IsTreeViewColumn
    type AttrGetType TreeViewColumnFixedWidthPropertyInfo = Int32
    type AttrLabel TreeViewColumnFixedWidthPropertyInfo = "fixed-width"
    type AttrOrigin TreeViewColumnFixedWidthPropertyInfo = TreeViewColumn
    attrGet _ = getTreeViewColumnFixedWidth
    attrSet _ = setTreeViewColumnFixedWidth
    attrConstruct _ = constructTreeViewColumnFixedWidth
    attrClear _ = undefined
#endif

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

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

@
'Data.GI.Base.Attributes.get' treeViewColumn #maxWidth
@
-}
getTreeViewColumnMaxWidth :: (MonadIO m, IsTreeViewColumn o) => o -> m Int32
getTreeViewColumnMaxWidth obj = liftIO $ B.Properties.getObjectPropertyInt32 obj "max-width"

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

@
'Data.GI.Base.Attributes.set' treeViewColumn [ #maxWidth 'Data.GI.Base.Attributes.:=' value ]
@
-}
setTreeViewColumnMaxWidth :: (MonadIO m, IsTreeViewColumn o) => o -> Int32 -> m ()
setTreeViewColumnMaxWidth obj val = liftIO $ B.Properties.setObjectPropertyInt32 obj "max-width" val

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

#if ENABLE_OVERLOADING
data TreeViewColumnMaxWidthPropertyInfo
instance AttrInfo TreeViewColumnMaxWidthPropertyInfo where
    type AttrAllowedOps TreeViewColumnMaxWidthPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint TreeViewColumnMaxWidthPropertyInfo = (~) Int32
    type AttrBaseTypeConstraint TreeViewColumnMaxWidthPropertyInfo = IsTreeViewColumn
    type AttrGetType TreeViewColumnMaxWidthPropertyInfo = Int32
    type AttrLabel TreeViewColumnMaxWidthPropertyInfo = "max-width"
    type AttrOrigin TreeViewColumnMaxWidthPropertyInfo = TreeViewColumn
    attrGet _ = getTreeViewColumnMaxWidth
    attrSet _ = setTreeViewColumnMaxWidth
    attrConstruct _ = constructTreeViewColumnMaxWidth
    attrClear _ = undefined
#endif

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

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

@
'Data.GI.Base.Attributes.get' treeViewColumn #minWidth
@
-}
getTreeViewColumnMinWidth :: (MonadIO m, IsTreeViewColumn o) => o -> m Int32
getTreeViewColumnMinWidth obj = liftIO $ B.Properties.getObjectPropertyInt32 obj "min-width"

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

@
'Data.GI.Base.Attributes.set' treeViewColumn [ #minWidth 'Data.GI.Base.Attributes.:=' value ]
@
-}
setTreeViewColumnMinWidth :: (MonadIO m, IsTreeViewColumn o) => o -> Int32 -> m ()
setTreeViewColumnMinWidth obj val = liftIO $ B.Properties.setObjectPropertyInt32 obj "min-width" val

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

#if ENABLE_OVERLOADING
data TreeViewColumnMinWidthPropertyInfo
instance AttrInfo TreeViewColumnMinWidthPropertyInfo where
    type AttrAllowedOps TreeViewColumnMinWidthPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint TreeViewColumnMinWidthPropertyInfo = (~) Int32
    type AttrBaseTypeConstraint TreeViewColumnMinWidthPropertyInfo = IsTreeViewColumn
    type AttrGetType TreeViewColumnMinWidthPropertyInfo = Int32
    type AttrLabel TreeViewColumnMinWidthPropertyInfo = "min-width"
    type AttrOrigin TreeViewColumnMinWidthPropertyInfo = TreeViewColumn
    attrGet _ = getTreeViewColumnMinWidth
    attrSet _ = setTreeViewColumnMinWidth
    attrConstruct _ = constructTreeViewColumnMinWidth
    attrClear _ = undefined
#endif

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

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

@
'Data.GI.Base.Attributes.get' treeViewColumn #reorderable
@
-}
getTreeViewColumnReorderable :: (MonadIO m, IsTreeViewColumn o) => o -> m Bool
getTreeViewColumnReorderable obj = liftIO $ B.Properties.getObjectPropertyBool obj "reorderable"

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

@
'Data.GI.Base.Attributes.set' treeViewColumn [ #reorderable 'Data.GI.Base.Attributes.:=' value ]
@
-}
setTreeViewColumnReorderable :: (MonadIO m, IsTreeViewColumn o) => o -> Bool -> m ()
setTreeViewColumnReorderable obj val = liftIO $ B.Properties.setObjectPropertyBool obj "reorderable" val

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

#if ENABLE_OVERLOADING
data TreeViewColumnReorderablePropertyInfo
instance AttrInfo TreeViewColumnReorderablePropertyInfo where
    type AttrAllowedOps TreeViewColumnReorderablePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint TreeViewColumnReorderablePropertyInfo = (~) Bool
    type AttrBaseTypeConstraint TreeViewColumnReorderablePropertyInfo = IsTreeViewColumn
    type AttrGetType TreeViewColumnReorderablePropertyInfo = Bool
    type AttrLabel TreeViewColumnReorderablePropertyInfo = "reorderable"
    type AttrOrigin TreeViewColumnReorderablePropertyInfo = TreeViewColumn
    attrGet _ = getTreeViewColumnReorderable
    attrSet _ = setTreeViewColumnReorderable
    attrConstruct _ = constructTreeViewColumnReorderable
    attrClear _ = undefined
#endif

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

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

@
'Data.GI.Base.Attributes.get' treeViewColumn #resizable
@
-}
getTreeViewColumnResizable :: (MonadIO m, IsTreeViewColumn o) => o -> m Bool
getTreeViewColumnResizable obj = liftIO $ B.Properties.getObjectPropertyBool obj "resizable"

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

@
'Data.GI.Base.Attributes.set' treeViewColumn [ #resizable 'Data.GI.Base.Attributes.:=' value ]
@
-}
setTreeViewColumnResizable :: (MonadIO m, IsTreeViewColumn o) => o -> Bool -> m ()
setTreeViewColumnResizable obj val = liftIO $ B.Properties.setObjectPropertyBool obj "resizable" val

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

#if ENABLE_OVERLOADING
data TreeViewColumnResizablePropertyInfo
instance AttrInfo TreeViewColumnResizablePropertyInfo where
    type AttrAllowedOps TreeViewColumnResizablePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint TreeViewColumnResizablePropertyInfo = (~) Bool
    type AttrBaseTypeConstraint TreeViewColumnResizablePropertyInfo = IsTreeViewColumn
    type AttrGetType TreeViewColumnResizablePropertyInfo = Bool
    type AttrLabel TreeViewColumnResizablePropertyInfo = "resizable"
    type AttrOrigin TreeViewColumnResizablePropertyInfo = TreeViewColumn
    attrGet _ = getTreeViewColumnResizable
    attrSet _ = setTreeViewColumnResizable
    attrConstruct _ = constructTreeViewColumnResizable
    attrClear _ = undefined
#endif

-- VVV Prop "sizing"
   -- Type: TInterface (Name {namespace = "Gtk", name = "TreeViewColumnSizing"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

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

@
'Data.GI.Base.Attributes.get' treeViewColumn #sizing
@
-}
getTreeViewColumnSizing :: (MonadIO m, IsTreeViewColumn o) => o -> m Gtk.Enums.TreeViewColumnSizing
getTreeViewColumnSizing obj = liftIO $ B.Properties.getObjectPropertyEnum obj "sizing"

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

@
'Data.GI.Base.Attributes.set' treeViewColumn [ #sizing 'Data.GI.Base.Attributes.:=' value ]
@
-}
setTreeViewColumnSizing :: (MonadIO m, IsTreeViewColumn o) => o -> Gtk.Enums.TreeViewColumnSizing -> m ()
setTreeViewColumnSizing obj val = liftIO $ B.Properties.setObjectPropertyEnum obj "sizing" val

{- |
Construct a `GValueConstruct` with valid value for the “@sizing@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructTreeViewColumnSizing :: (IsTreeViewColumn o) => Gtk.Enums.TreeViewColumnSizing -> IO (GValueConstruct o)
constructTreeViewColumnSizing val = B.Properties.constructObjectPropertyEnum "sizing" val

#if ENABLE_OVERLOADING
data TreeViewColumnSizingPropertyInfo
instance AttrInfo TreeViewColumnSizingPropertyInfo where
    type AttrAllowedOps TreeViewColumnSizingPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint TreeViewColumnSizingPropertyInfo = (~) Gtk.Enums.TreeViewColumnSizing
    type AttrBaseTypeConstraint TreeViewColumnSizingPropertyInfo = IsTreeViewColumn
    type AttrGetType TreeViewColumnSizingPropertyInfo = Gtk.Enums.TreeViewColumnSizing
    type AttrLabel TreeViewColumnSizingPropertyInfo = "sizing"
    type AttrOrigin TreeViewColumnSizingPropertyInfo = TreeViewColumn
    attrGet _ = getTreeViewColumnSizing
    attrSet _ = setTreeViewColumnSizing
    attrConstruct _ = constructTreeViewColumnSizing
    attrClear _ = undefined
#endif

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

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

@
'Data.GI.Base.Attributes.get' treeViewColumn #sortColumnId
@
-}
getTreeViewColumnSortColumnId :: (MonadIO m, IsTreeViewColumn o) => o -> m Int32
getTreeViewColumnSortColumnId obj = liftIO $ B.Properties.getObjectPropertyInt32 obj "sort-column-id"

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

@
'Data.GI.Base.Attributes.set' treeViewColumn [ #sortColumnId 'Data.GI.Base.Attributes.:=' value ]
@
-}
setTreeViewColumnSortColumnId :: (MonadIO m, IsTreeViewColumn o) => o -> Int32 -> m ()
setTreeViewColumnSortColumnId obj val = liftIO $ B.Properties.setObjectPropertyInt32 obj "sort-column-id" val

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

#if ENABLE_OVERLOADING
data TreeViewColumnSortColumnIdPropertyInfo
instance AttrInfo TreeViewColumnSortColumnIdPropertyInfo where
    type AttrAllowedOps TreeViewColumnSortColumnIdPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint TreeViewColumnSortColumnIdPropertyInfo = (~) Int32
    type AttrBaseTypeConstraint TreeViewColumnSortColumnIdPropertyInfo = IsTreeViewColumn
    type AttrGetType TreeViewColumnSortColumnIdPropertyInfo = Int32
    type AttrLabel TreeViewColumnSortColumnIdPropertyInfo = "sort-column-id"
    type AttrOrigin TreeViewColumnSortColumnIdPropertyInfo = TreeViewColumn
    attrGet _ = getTreeViewColumnSortColumnId
    attrSet _ = setTreeViewColumnSortColumnId
    attrConstruct _ = constructTreeViewColumnSortColumnId
    attrClear _ = undefined
#endif

-- VVV Prop "sort-indicator"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

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

@
'Data.GI.Base.Attributes.get' treeViewColumn #sortIndicator
@
-}
getTreeViewColumnSortIndicator :: (MonadIO m, IsTreeViewColumn o) => o -> m Bool
getTreeViewColumnSortIndicator obj = liftIO $ B.Properties.getObjectPropertyBool obj "sort-indicator"

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

@
'Data.GI.Base.Attributes.set' treeViewColumn [ #sortIndicator 'Data.GI.Base.Attributes.:=' value ]
@
-}
setTreeViewColumnSortIndicator :: (MonadIO m, IsTreeViewColumn o) => o -> Bool -> m ()
setTreeViewColumnSortIndicator obj val = liftIO $ B.Properties.setObjectPropertyBool obj "sort-indicator" val

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

#if ENABLE_OVERLOADING
data TreeViewColumnSortIndicatorPropertyInfo
instance AttrInfo TreeViewColumnSortIndicatorPropertyInfo where
    type AttrAllowedOps TreeViewColumnSortIndicatorPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint TreeViewColumnSortIndicatorPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint TreeViewColumnSortIndicatorPropertyInfo = IsTreeViewColumn
    type AttrGetType TreeViewColumnSortIndicatorPropertyInfo = Bool
    type AttrLabel TreeViewColumnSortIndicatorPropertyInfo = "sort-indicator"
    type AttrOrigin TreeViewColumnSortIndicatorPropertyInfo = TreeViewColumn
    attrGet _ = getTreeViewColumnSortIndicator
    attrSet _ = setTreeViewColumnSortIndicator
    attrConstruct _ = constructTreeViewColumnSortIndicator
    attrClear _ = undefined
#endif

-- VVV Prop "sort-order"
   -- Type: TInterface (Name {namespace = "Gtk", name = "SortType"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

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

@
'Data.GI.Base.Attributes.get' treeViewColumn #sortOrder
@
-}
getTreeViewColumnSortOrder :: (MonadIO m, IsTreeViewColumn o) => o -> m Gtk.Enums.SortType
getTreeViewColumnSortOrder obj = liftIO $ B.Properties.getObjectPropertyEnum obj "sort-order"

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

@
'Data.GI.Base.Attributes.set' treeViewColumn [ #sortOrder 'Data.GI.Base.Attributes.:=' value ]
@
-}
setTreeViewColumnSortOrder :: (MonadIO m, IsTreeViewColumn o) => o -> Gtk.Enums.SortType -> m ()
setTreeViewColumnSortOrder obj val = liftIO $ B.Properties.setObjectPropertyEnum obj "sort-order" val

{- |
Construct a `GValueConstruct` with valid value for the “@sort-order@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructTreeViewColumnSortOrder :: (IsTreeViewColumn o) => Gtk.Enums.SortType -> IO (GValueConstruct o)
constructTreeViewColumnSortOrder val = B.Properties.constructObjectPropertyEnum "sort-order" val

#if ENABLE_OVERLOADING
data TreeViewColumnSortOrderPropertyInfo
instance AttrInfo TreeViewColumnSortOrderPropertyInfo where
    type AttrAllowedOps TreeViewColumnSortOrderPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint TreeViewColumnSortOrderPropertyInfo = (~) Gtk.Enums.SortType
    type AttrBaseTypeConstraint TreeViewColumnSortOrderPropertyInfo = IsTreeViewColumn
    type AttrGetType TreeViewColumnSortOrderPropertyInfo = Gtk.Enums.SortType
    type AttrLabel TreeViewColumnSortOrderPropertyInfo = "sort-order"
    type AttrOrigin TreeViewColumnSortOrderPropertyInfo = TreeViewColumn
    attrGet _ = getTreeViewColumnSortOrder
    attrSet _ = setTreeViewColumnSortOrder
    attrConstruct _ = constructTreeViewColumnSortOrder
    attrClear _ = undefined
#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' treeViewColumn #spacing
@
-}
getTreeViewColumnSpacing :: (MonadIO m, IsTreeViewColumn o) => o -> m Int32
getTreeViewColumnSpacing 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' treeViewColumn [ #spacing 'Data.GI.Base.Attributes.:=' value ]
@
-}
setTreeViewColumnSpacing :: (MonadIO m, IsTreeViewColumn o) => o -> Int32 -> m ()
setTreeViewColumnSpacing 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`.
-}
constructTreeViewColumnSpacing :: (IsTreeViewColumn o) => Int32 -> IO (GValueConstruct o)
constructTreeViewColumnSpacing val = B.Properties.constructObjectPropertyInt32 "spacing" val

#if ENABLE_OVERLOADING
data TreeViewColumnSpacingPropertyInfo
instance AttrInfo TreeViewColumnSpacingPropertyInfo where
    type AttrAllowedOps TreeViewColumnSpacingPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint TreeViewColumnSpacingPropertyInfo = (~) Int32
    type AttrBaseTypeConstraint TreeViewColumnSpacingPropertyInfo = IsTreeViewColumn
    type AttrGetType TreeViewColumnSpacingPropertyInfo = Int32
    type AttrLabel TreeViewColumnSpacingPropertyInfo = "spacing"
    type AttrOrigin TreeViewColumnSpacingPropertyInfo = TreeViewColumn
    attrGet _ = getTreeViewColumnSpacing
    attrSet _ = setTreeViewColumnSpacing
    attrConstruct _ = constructTreeViewColumnSpacing
    attrClear _ = undefined
#endif

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

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

@
'Data.GI.Base.Attributes.get' treeViewColumn #title
@
-}
getTreeViewColumnTitle :: (MonadIO m, IsTreeViewColumn o) => o -> m T.Text
getTreeViewColumnTitle obj = liftIO $ checkUnexpectedNothing "getTreeViewColumnTitle" $ B.Properties.getObjectPropertyString obj "title"

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

@
'Data.GI.Base.Attributes.set' treeViewColumn [ #title 'Data.GI.Base.Attributes.:=' value ]
@
-}
setTreeViewColumnTitle :: (MonadIO m, IsTreeViewColumn o) => o -> T.Text -> m ()
setTreeViewColumnTitle obj val = liftIO $ B.Properties.setObjectPropertyString obj "title" (Just val)

{- |
Construct a `GValueConstruct` with valid value for the “@title@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructTreeViewColumnTitle :: (IsTreeViewColumn o) => T.Text -> IO (GValueConstruct o)
constructTreeViewColumnTitle val = B.Properties.constructObjectPropertyString "title" (Just val)

#if ENABLE_OVERLOADING
data TreeViewColumnTitlePropertyInfo
instance AttrInfo TreeViewColumnTitlePropertyInfo where
    type AttrAllowedOps TreeViewColumnTitlePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint TreeViewColumnTitlePropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint TreeViewColumnTitlePropertyInfo = IsTreeViewColumn
    type AttrGetType TreeViewColumnTitlePropertyInfo = T.Text
    type AttrLabel TreeViewColumnTitlePropertyInfo = "title"
    type AttrOrigin TreeViewColumnTitlePropertyInfo = TreeViewColumn
    attrGet _ = getTreeViewColumnTitle
    attrSet _ = setTreeViewColumnTitle
    attrConstruct _ = constructTreeViewColumnTitle
    attrClear _ = undefined
#endif

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

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

@
'Data.GI.Base.Attributes.get' treeViewColumn #visible
@
-}
getTreeViewColumnVisible :: (MonadIO m, IsTreeViewColumn o) => o -> m Bool
getTreeViewColumnVisible obj = liftIO $ B.Properties.getObjectPropertyBool obj "visible"

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

@
'Data.GI.Base.Attributes.set' treeViewColumn [ #visible 'Data.GI.Base.Attributes.:=' value ]
@
-}
setTreeViewColumnVisible :: (MonadIO m, IsTreeViewColumn o) => o -> Bool -> m ()
setTreeViewColumnVisible obj val = liftIO $ B.Properties.setObjectPropertyBool obj "visible" val

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

#if ENABLE_OVERLOADING
data TreeViewColumnVisiblePropertyInfo
instance AttrInfo TreeViewColumnVisiblePropertyInfo where
    type AttrAllowedOps TreeViewColumnVisiblePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint TreeViewColumnVisiblePropertyInfo = (~) Bool
    type AttrBaseTypeConstraint TreeViewColumnVisiblePropertyInfo = IsTreeViewColumn
    type AttrGetType TreeViewColumnVisiblePropertyInfo = Bool
    type AttrLabel TreeViewColumnVisiblePropertyInfo = "visible"
    type AttrOrigin TreeViewColumnVisiblePropertyInfo = TreeViewColumn
    attrGet _ = getTreeViewColumnVisible
    attrSet _ = setTreeViewColumnVisible
    attrConstruct _ = constructTreeViewColumnVisible
    attrClear _ = undefined
#endif

-- VVV Prop "widget"
   -- Type: TInterface (Name {namespace = "Gtk", name = "Widget"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just True,Just True)

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

@
'Data.GI.Base.Attributes.get' treeViewColumn #widget
@
-}
getTreeViewColumnWidget :: (MonadIO m, IsTreeViewColumn o) => o -> m (Maybe Gtk.Widget.Widget)
getTreeViewColumnWidget obj = liftIO $ B.Properties.getObjectPropertyObject obj "widget" Gtk.Widget.Widget

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

@
'Data.GI.Base.Attributes.set' treeViewColumn [ #widget 'Data.GI.Base.Attributes.:=' value ]
@
-}
setTreeViewColumnWidget :: (MonadIO m, IsTreeViewColumn o, Gtk.Widget.IsWidget a) => o -> a -> m ()
setTreeViewColumnWidget obj val = liftIO $ B.Properties.setObjectPropertyObject obj "widget" (Just val)

{- |
Construct a `GValueConstruct` with valid value for the “@widget@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructTreeViewColumnWidget :: (IsTreeViewColumn o, Gtk.Widget.IsWidget a) => a -> IO (GValueConstruct o)
constructTreeViewColumnWidget val = B.Properties.constructObjectPropertyObject "widget" (Just val)

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

@
'Data.GI.Base.Attributes.clear' #widget
@
-}
clearTreeViewColumnWidget :: (MonadIO m, IsTreeViewColumn o) => o -> m ()
clearTreeViewColumnWidget obj = liftIO $ B.Properties.setObjectPropertyObject obj "widget" (Nothing :: Maybe Gtk.Widget.Widget)

#if ENABLE_OVERLOADING
data TreeViewColumnWidgetPropertyInfo
instance AttrInfo TreeViewColumnWidgetPropertyInfo where
    type AttrAllowedOps TreeViewColumnWidgetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint TreeViewColumnWidgetPropertyInfo = Gtk.Widget.IsWidget
    type AttrBaseTypeConstraint TreeViewColumnWidgetPropertyInfo = IsTreeViewColumn
    type AttrGetType TreeViewColumnWidgetPropertyInfo = (Maybe Gtk.Widget.Widget)
    type AttrLabel TreeViewColumnWidgetPropertyInfo = "widget"
    type AttrOrigin TreeViewColumnWidgetPropertyInfo = TreeViewColumn
    attrGet _ = getTreeViewColumnWidget
    attrSet _ = setTreeViewColumnWidget
    attrConstruct _ = constructTreeViewColumnWidget
    attrClear _ = clearTreeViewColumnWidget
#endif

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

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

@
'Data.GI.Base.Attributes.get' treeViewColumn #width
@
-}
getTreeViewColumnWidth :: (MonadIO m, IsTreeViewColumn o) => o -> m Int32
getTreeViewColumnWidth obj = liftIO $ B.Properties.getObjectPropertyInt32 obj "width"

#if ENABLE_OVERLOADING
data TreeViewColumnWidthPropertyInfo
instance AttrInfo TreeViewColumnWidthPropertyInfo where
    type AttrAllowedOps TreeViewColumnWidthPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint TreeViewColumnWidthPropertyInfo = (~) ()
    type AttrBaseTypeConstraint TreeViewColumnWidthPropertyInfo = IsTreeViewColumn
    type AttrGetType TreeViewColumnWidthPropertyInfo = Int32
    type AttrLabel TreeViewColumnWidthPropertyInfo = "width"
    type AttrOrigin TreeViewColumnWidthPropertyInfo = TreeViewColumn
    attrGet _ = getTreeViewColumnWidth
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined
#endif

-- VVV Prop "x-offset"
   -- Type: TBasicType TInt
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

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

@
'Data.GI.Base.Attributes.get' treeViewColumn #xOffset
@
-}
getTreeViewColumnXOffset :: (MonadIO m, IsTreeViewColumn o) => o -> m Int32
getTreeViewColumnXOffset obj = liftIO $ B.Properties.getObjectPropertyInt32 obj "x-offset"

#if ENABLE_OVERLOADING
data TreeViewColumnXOffsetPropertyInfo
instance AttrInfo TreeViewColumnXOffsetPropertyInfo where
    type AttrAllowedOps TreeViewColumnXOffsetPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint TreeViewColumnXOffsetPropertyInfo = (~) ()
    type AttrBaseTypeConstraint TreeViewColumnXOffsetPropertyInfo = IsTreeViewColumn
    type AttrGetType TreeViewColumnXOffsetPropertyInfo = Int32
    type AttrLabel TreeViewColumnXOffsetPropertyInfo = "x-offset"
    type AttrOrigin TreeViewColumnXOffsetPropertyInfo = TreeViewColumn
    attrGet _ = getTreeViewColumnXOffset
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined
#endif

#if ENABLE_OVERLOADING
instance O.HasAttributeList TreeViewColumn
type instance O.AttributeList TreeViewColumn = TreeViewColumnAttributeList
type TreeViewColumnAttributeList = ('[ '("alignment", TreeViewColumnAlignmentPropertyInfo), '("cellArea", TreeViewColumnCellAreaPropertyInfo), '("clickable", TreeViewColumnClickablePropertyInfo), '("expand", TreeViewColumnExpandPropertyInfo), '("fixedWidth", TreeViewColumnFixedWidthPropertyInfo), '("maxWidth", TreeViewColumnMaxWidthPropertyInfo), '("minWidth", TreeViewColumnMinWidthPropertyInfo), '("reorderable", TreeViewColumnReorderablePropertyInfo), '("resizable", TreeViewColumnResizablePropertyInfo), '("sizing", TreeViewColumnSizingPropertyInfo), '("sortColumnId", TreeViewColumnSortColumnIdPropertyInfo), '("sortIndicator", TreeViewColumnSortIndicatorPropertyInfo), '("sortOrder", TreeViewColumnSortOrderPropertyInfo), '("spacing", TreeViewColumnSpacingPropertyInfo), '("title", TreeViewColumnTitlePropertyInfo), '("visible", TreeViewColumnVisiblePropertyInfo), '("widget", TreeViewColumnWidgetPropertyInfo), '("width", TreeViewColumnWidthPropertyInfo), '("xOffset", TreeViewColumnXOffsetPropertyInfo)] :: [(Symbol, *)])
#endif

#if ENABLE_OVERLOADING
treeViewColumnAlignment :: AttrLabelProxy "alignment"
treeViewColumnAlignment = AttrLabelProxy

treeViewColumnCellArea :: AttrLabelProxy "cellArea"
treeViewColumnCellArea = AttrLabelProxy

treeViewColumnClickable :: AttrLabelProxy "clickable"
treeViewColumnClickable = AttrLabelProxy

treeViewColumnExpand :: AttrLabelProxy "expand"
treeViewColumnExpand = AttrLabelProxy

treeViewColumnFixedWidth :: AttrLabelProxy "fixedWidth"
treeViewColumnFixedWidth = AttrLabelProxy

treeViewColumnMaxWidth :: AttrLabelProxy "maxWidth"
treeViewColumnMaxWidth = AttrLabelProxy

treeViewColumnMinWidth :: AttrLabelProxy "minWidth"
treeViewColumnMinWidth = AttrLabelProxy

treeViewColumnReorderable :: AttrLabelProxy "reorderable"
treeViewColumnReorderable = AttrLabelProxy

treeViewColumnResizable :: AttrLabelProxy "resizable"
treeViewColumnResizable = AttrLabelProxy

treeViewColumnSizing :: AttrLabelProxy "sizing"
treeViewColumnSizing = AttrLabelProxy

treeViewColumnSortColumnId :: AttrLabelProxy "sortColumnId"
treeViewColumnSortColumnId = AttrLabelProxy

treeViewColumnSortIndicator :: AttrLabelProxy "sortIndicator"
treeViewColumnSortIndicator = AttrLabelProxy

treeViewColumnSortOrder :: AttrLabelProxy "sortOrder"
treeViewColumnSortOrder = AttrLabelProxy

treeViewColumnSpacing :: AttrLabelProxy "spacing"
treeViewColumnSpacing = AttrLabelProxy

treeViewColumnTitle :: AttrLabelProxy "title"
treeViewColumnTitle = AttrLabelProxy

treeViewColumnVisible :: AttrLabelProxy "visible"
treeViewColumnVisible = AttrLabelProxy

treeViewColumnWidget :: AttrLabelProxy "widget"
treeViewColumnWidget = AttrLabelProxy

treeViewColumnWidth :: AttrLabelProxy "width"
treeViewColumnWidth = AttrLabelProxy

treeViewColumnXOffset :: AttrLabelProxy "xOffset"
treeViewColumnXOffset = AttrLabelProxy

#endif

#if ENABLE_OVERLOADING
data TreeViewColumnClickedSignalInfo
instance SignalInfo TreeViewColumnClickedSignalInfo where
    type HaskellCallbackType TreeViewColumnClickedSignalInfo = TreeViewColumnClickedCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_TreeViewColumnClickedCallback cb
        cb'' <- mk_TreeViewColumnClickedCallback cb'
        connectSignalFunPtr obj "clicked" cb'' connectMode

type instance O.SignalList TreeViewColumn = TreeViewColumnSignalList
type TreeViewColumnSignalList = ('[ '("clicked", TreeViewColumnClickedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

#endif

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

foreign import ccall "gtk_tree_view_column_new" gtk_tree_view_column_new :: 
    IO (Ptr TreeViewColumn)

{- |
Creates a new 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'.
-}
treeViewColumnNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m TreeViewColumn
    {- ^ __Returns:__ A newly created 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'. -}
treeViewColumnNew  = liftIO $ do
    result <- gtk_tree_view_column_new
    checkUnexpectedReturnNULL "treeViewColumnNew" result
    result' <- (newObject TreeViewColumn) result
    return result'

#if ENABLE_OVERLOADING
#endif

-- method TreeViewColumn::new_with_area
-- method type : Constructor
-- Args : [Arg {argCName = "area", argType = TInterface (Name {namespace = "Gtk", name = "CellArea"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GtkCellArea that the newly created column should use to layout cells.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_tree_view_column_new_with_area" gtk_tree_view_column_new_with_area :: 
    Ptr Gtk.CellArea.CellArea ->            -- area : TInterface (Name {namespace = "Gtk", name = "CellArea"})
    IO (Ptr TreeViewColumn)

{- |
Creates a new 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn' using /@area@/ to render its cells.

/Since: 3.0/
-}
treeViewColumnNewWithArea ::
    (B.CallStack.HasCallStack, MonadIO m, Gtk.CellArea.IsCellArea a) =>
    a
    {- ^ /@area@/: the 'GI.Gtk.Objects.CellArea.CellArea' that the newly created column should use to layout cells. -}
    -> m TreeViewColumn
    {- ^ __Returns:__ A newly created 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'. -}
treeViewColumnNewWithArea area = liftIO $ do
    area' <- unsafeManagedPtrCastPtr area
    result <- gtk_tree_view_column_new_with_area area'
    checkUnexpectedReturnNULL "treeViewColumnNewWithArea" result
    result' <- (newObject TreeViewColumn) result
    touchManagedPtr area
    return result'

#if ENABLE_OVERLOADING
#endif

-- method TreeViewColumn::add_attribute
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_column", argType = TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeViewColumn.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cell_renderer", argType = TInterface (Name {namespace = "Gtk", name = "CellRenderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GtkCellRenderer to set attributes on", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "An attribute on the renderer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "column", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The column position on the model to get the attribute from.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_tree_view_column_add_attribute" gtk_tree_view_column_add_attribute :: 
    Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
    Ptr Gtk.CellRenderer.CellRenderer ->    -- cell_renderer : TInterface (Name {namespace = "Gtk", name = "CellRenderer"})
    CString ->                              -- attribute : TBasicType TUTF8
    Int32 ->                                -- column : TBasicType TInt
    IO ()

{- |
Adds an attribute mapping to the list in /@treeColumn@/.  The /@column@/ is the
column of the model to get a value from, and the /@attribute@/ is the
parameter on /@cellRenderer@/ to be set from the value. So for example
if column 2 of the model contains strings, you could have the
“text” attribute of a 'GI.Gtk.Objects.CellRendererText.CellRendererText' get its values from
column 2.
-}
treeViewColumnAddAttribute ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a, Gtk.CellRenderer.IsCellRenderer b) =>
    a
    {- ^ /@treeColumn@/: A 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'. -}
    -> b
    {- ^ /@cellRenderer@/: the 'GI.Gtk.Objects.CellRenderer.CellRenderer' to set attributes on -}
    -> T.Text
    {- ^ /@attribute@/: An attribute on the renderer -}
    -> Int32
    {- ^ /@column@/: The column position on the model to get the attribute from. -}
    -> m ()
treeViewColumnAddAttribute treeColumn cellRenderer attribute column = liftIO $ do
    treeColumn' <- unsafeManagedPtrCastPtr treeColumn
    cellRenderer' <- unsafeManagedPtrCastPtr cellRenderer
    attribute' <- textToCString attribute
    gtk_tree_view_column_add_attribute treeColumn' cellRenderer' attribute' column
    touchManagedPtr treeColumn
    touchManagedPtr cellRenderer
    freeMem attribute'
    return ()

#if ENABLE_OVERLOADING
data TreeViewColumnAddAttributeMethodInfo
instance (signature ~ (b -> T.Text -> Int32 -> m ()), MonadIO m, IsTreeViewColumn a, Gtk.CellRenderer.IsCellRenderer b) => O.MethodInfo TreeViewColumnAddAttributeMethodInfo a signature where
    overloadedMethod _ = treeViewColumnAddAttribute

#endif

-- method TreeViewColumn::cell_get_position
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_column", argType = TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTreeViewColumn", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cell_renderer", argType = TInterface (Name {namespace = "Gtk", name = "CellRenderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkCellRenderer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x_offset", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for the horizontal\n           position of @cell within @tree_column, may be %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "width", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for the width of @cell,\n        may be %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_tree_view_column_cell_get_position" gtk_tree_view_column_cell_get_position :: 
    Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
    Ptr Gtk.CellRenderer.CellRenderer ->    -- cell_renderer : TInterface (Name {namespace = "Gtk", name = "CellRenderer"})
    Ptr Int32 ->                            -- x_offset : TBasicType TInt
    Ptr Int32 ->                            -- width : TBasicType TInt
    IO CInt

{- |
Obtains the horizontal position and size of a cell in a column. If the
cell is not found in the column, /@startPos@/ and /@width@/ are not changed and
'False' is returned.
-}
treeViewColumnCellGetPosition ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a, Gtk.CellRenderer.IsCellRenderer b) =>
    a
    {- ^ /@treeColumn@/: a 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn' -}
    -> b
    {- ^ /@cellRenderer@/: a 'GI.Gtk.Objects.CellRenderer.CellRenderer' -}
    -> m ((Bool, Int32, Int32))
    {- ^ __Returns:__ 'True' if /@cell@/ belongs to /@treeColumn@/. -}
treeViewColumnCellGetPosition treeColumn cellRenderer = liftIO $ do
    treeColumn' <- unsafeManagedPtrCastPtr treeColumn
    cellRenderer' <- unsafeManagedPtrCastPtr cellRenderer
    xOffset <- allocMem :: IO (Ptr Int32)
    width <- allocMem :: IO (Ptr Int32)
    result <- gtk_tree_view_column_cell_get_position treeColumn' cellRenderer' xOffset width
    let result' = (/= 0) result
    xOffset' <- peek xOffset
    width' <- peek width
    touchManagedPtr treeColumn
    touchManagedPtr cellRenderer
    freeMem xOffset
    freeMem width
    return (result', xOffset', width')

#if ENABLE_OVERLOADING
data TreeViewColumnCellGetPositionMethodInfo
instance (signature ~ (b -> m ((Bool, Int32, Int32))), MonadIO m, IsTreeViewColumn a, Gtk.CellRenderer.IsCellRenderer b) => O.MethodInfo TreeViewColumnCellGetPositionMethodInfo a signature where
    overloadedMethod _ = treeViewColumnCellGetPosition

#endif

-- method TreeViewColumn::cell_get_size
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_column", argType = TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeViewColumn.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cell_area", argType = TInterface (Name {namespace = "Gdk", name = "Rectangle"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "The area a cell in the column will be allocated, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x_offset", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to return x offset of a cell relative to @cell_area, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "y_offset", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to return y offset of a cell relative to @cell_area, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "width", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to return width needed to render a cell, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "height", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to return height needed to render a cell, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_tree_view_column_cell_get_size" gtk_tree_view_column_cell_get_size :: 
    Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
    Ptr Gdk.Rectangle.Rectangle ->          -- cell_area : TInterface (Name {namespace = "Gdk", name = "Rectangle"})
    Ptr Int32 ->                            -- x_offset : TBasicType TInt
    Ptr Int32 ->                            -- y_offset : TBasicType TInt
    Ptr Int32 ->                            -- width : TBasicType TInt
    Ptr Int32 ->                            -- height : TBasicType TInt
    IO ()

{- |
Obtains the width and height needed to render the column.  This is used
primarily by the 'GI.Gtk.Objects.TreeView.TreeView'.
-}
treeViewColumnCellGetSize ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a
    {- ^ /@treeColumn@/: A 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'. -}
    -> Maybe (Gdk.Rectangle.Rectangle)
    {- ^ /@cellArea@/: The area a cell in the column will be allocated, or 'Nothing' -}
    -> m ((Int32, Int32, Int32, Int32))
treeViewColumnCellGetSize treeColumn cellArea = liftIO $ do
    treeColumn' <- unsafeManagedPtrCastPtr treeColumn
    maybeCellArea <- case cellArea of
        Nothing -> return nullPtr
        Just jCellArea -> do
            jCellArea' <- unsafeManagedPtrGetPtr jCellArea
            return jCellArea'
    xOffset <- allocMem :: IO (Ptr Int32)
    yOffset <- allocMem :: IO (Ptr Int32)
    width <- allocMem :: IO (Ptr Int32)
    height <- allocMem :: IO (Ptr Int32)
    gtk_tree_view_column_cell_get_size treeColumn' maybeCellArea xOffset yOffset width height
    xOffset' <- peek xOffset
    yOffset' <- peek yOffset
    width' <- peek width
    height' <- peek height
    touchManagedPtr treeColumn
    whenJust cellArea touchManagedPtr
    freeMem xOffset
    freeMem yOffset
    freeMem width
    freeMem height
    return (xOffset', yOffset', width', height')

#if ENABLE_OVERLOADING
data TreeViewColumnCellGetSizeMethodInfo
instance (signature ~ (Maybe (Gdk.Rectangle.Rectangle) -> m ((Int32, Int32, Int32, Int32))), MonadIO m, IsTreeViewColumn a) => O.MethodInfo TreeViewColumnCellGetSizeMethodInfo a signature where
    overloadedMethod _ = treeViewColumnCellGetSize

#endif

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

foreign import ccall "gtk_tree_view_column_cell_is_visible" gtk_tree_view_column_cell_is_visible :: 
    Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
    IO CInt

{- |
Returns 'True' if any of the cells packed into the /@treeColumn@/ are visible.
For this to be meaningful, you must first initialize the cells with
'GI.Gtk.Objects.TreeViewColumn.treeViewColumnCellSetCellData'
-}
treeViewColumnCellIsVisible ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a
    {- ^ /@treeColumn@/: A 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn' -}
    -> m Bool
    {- ^ __Returns:__ 'True', if any of the cells packed into the /@treeColumn@/ are currently visible -}
treeViewColumnCellIsVisible treeColumn = liftIO $ do
    treeColumn' <- unsafeManagedPtrCastPtr treeColumn
    result <- gtk_tree_view_column_cell_is_visible treeColumn'
    let result' = (/= 0) result
    touchManagedPtr treeColumn
    return result'

#if ENABLE_OVERLOADING
data TreeViewColumnCellIsVisibleMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTreeViewColumn a) => O.MethodInfo TreeViewColumnCellIsVisibleMethodInfo a signature where
    overloadedMethod _ = treeViewColumnCellIsVisible

#endif

-- method TreeViewColumn::cell_set_cell_data
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_column", argType = TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeViewColumn.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tree_model", argType = TInterface (Name {namespace = "Gtk", name = "TreeModel"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The #GtkTreeModel to to get the cell renderers attributes from.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "iter", argType = TInterface (Name {namespace = "Gtk", name = "TreeIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The #GtkTreeIter to to get the cell renderer\8217s attributes from.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "is_expander", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE, if the row has children", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "is_expanded", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE, if the row has visible children", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_tree_view_column_cell_set_cell_data" gtk_tree_view_column_cell_set_cell_data :: 
    Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
    Ptr Gtk.TreeModel.TreeModel ->          -- tree_model : TInterface (Name {namespace = "Gtk", name = "TreeModel"})
    Ptr Gtk.TreeIter.TreeIter ->            -- iter : TInterface (Name {namespace = "Gtk", name = "TreeIter"})
    CInt ->                                 -- is_expander : TBasicType TBoolean
    CInt ->                                 -- is_expanded : TBasicType TBoolean
    IO ()

{- |
Sets the cell renderer based on the /@treeModel@/ and /@iter@/.  That is, for
every attribute mapping in /@treeColumn@/, it will get a value from the set
column on the /@iter@/, and use that value to set the attribute on the cell
renderer.  This is used primarily by the 'GI.Gtk.Objects.TreeView.TreeView'.
-}
treeViewColumnCellSetCellData ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a, Gtk.TreeModel.IsTreeModel b) =>
    a
    {- ^ /@treeColumn@/: A 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'. -}
    -> b
    {- ^ /@treeModel@/: The 'GI.Gtk.Interfaces.TreeModel.TreeModel' to to get the cell renderers attributes from. -}
    -> Gtk.TreeIter.TreeIter
    {- ^ /@iter@/: The 'GI.Gtk.Structs.TreeIter.TreeIter' to to get the cell renderer’s attributes from. -}
    -> Bool
    {- ^ /@isExpander@/: 'True', if the row has children -}
    -> Bool
    {- ^ /@isExpanded@/: 'True', if the row has visible children -}
    -> m ()
treeViewColumnCellSetCellData treeColumn treeModel iter isExpander isExpanded = liftIO $ do
    treeColumn' <- unsafeManagedPtrCastPtr treeColumn
    treeModel' <- unsafeManagedPtrCastPtr treeModel
    iter' <- unsafeManagedPtrGetPtr iter
    let isExpander' = (fromIntegral . fromEnum) isExpander
    let isExpanded' = (fromIntegral . fromEnum) isExpanded
    gtk_tree_view_column_cell_set_cell_data treeColumn' treeModel' iter' isExpander' isExpanded'
    touchManagedPtr treeColumn
    touchManagedPtr treeModel
    touchManagedPtr iter
    return ()

#if ENABLE_OVERLOADING
data TreeViewColumnCellSetCellDataMethodInfo
instance (signature ~ (b -> Gtk.TreeIter.TreeIter -> Bool -> Bool -> m ()), MonadIO m, IsTreeViewColumn a, Gtk.TreeModel.IsTreeModel b) => O.MethodInfo TreeViewColumnCellSetCellDataMethodInfo a signature where
    overloadedMethod _ = treeViewColumnCellSetCellData

#endif

-- method TreeViewColumn::clear
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_column", argType = TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeViewColumn", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_tree_view_column_clear" gtk_tree_view_column_clear :: 
    Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
    IO ()

{- |
Unsets all the mappings on all renderers on the /@treeColumn@/.
-}
treeViewColumnClear ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a
    {- ^ /@treeColumn@/: A 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn' -}
    -> m ()
treeViewColumnClear treeColumn = liftIO $ do
    treeColumn' <- unsafeManagedPtrCastPtr treeColumn
    gtk_tree_view_column_clear treeColumn'
    touchManagedPtr treeColumn
    return ()

#if ENABLE_OVERLOADING
data TreeViewColumnClearMethodInfo
instance (signature ~ (m ()), MonadIO m, IsTreeViewColumn a) => O.MethodInfo TreeViewColumnClearMethodInfo a signature where
    overloadedMethod _ = treeViewColumnClear

#endif

-- method TreeViewColumn::clear_attributes
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_column", argType = TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTreeViewColumn", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cell_renderer", argType = TInterface (Name {namespace = "Gtk", name = "CellRenderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkCellRenderer to clear the attribute mapping on.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_tree_view_column_clear_attributes" gtk_tree_view_column_clear_attributes :: 
    Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
    Ptr Gtk.CellRenderer.CellRenderer ->    -- cell_renderer : TInterface (Name {namespace = "Gtk", name = "CellRenderer"})
    IO ()

{- |
Clears all existing attributes previously set with
@/gtk_tree_view_column_set_attributes()/@.
-}
treeViewColumnClearAttributes ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a, Gtk.CellRenderer.IsCellRenderer b) =>
    a
    {- ^ /@treeColumn@/: a 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn' -}
    -> b
    {- ^ /@cellRenderer@/: a 'GI.Gtk.Objects.CellRenderer.CellRenderer' to clear the attribute mapping on. -}
    -> m ()
treeViewColumnClearAttributes treeColumn cellRenderer = liftIO $ do
    treeColumn' <- unsafeManagedPtrCastPtr treeColumn
    cellRenderer' <- unsafeManagedPtrCastPtr cellRenderer
    gtk_tree_view_column_clear_attributes treeColumn' cellRenderer'
    touchManagedPtr treeColumn
    touchManagedPtr cellRenderer
    return ()

#if ENABLE_OVERLOADING
data TreeViewColumnClearAttributesMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsTreeViewColumn a, Gtk.CellRenderer.IsCellRenderer b) => O.MethodInfo TreeViewColumnClearAttributesMethodInfo a signature where
    overloadedMethod _ = treeViewColumnClearAttributes

#endif

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

foreign import ccall "gtk_tree_view_column_clicked" gtk_tree_view_column_clicked :: 
    Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
    IO ()

{- |
Emits the “clicked” signal on the column.  This function will only work if
/@treeColumn@/ is clickable.
-}
treeViewColumnClicked ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a
    {- ^ /@treeColumn@/: a 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn' -}
    -> m ()
treeViewColumnClicked treeColumn = liftIO $ do
    treeColumn' <- unsafeManagedPtrCastPtr treeColumn
    gtk_tree_view_column_clicked treeColumn'
    touchManagedPtr treeColumn
    return ()

#if ENABLE_OVERLOADING
data TreeViewColumnClickedMethodInfo
instance (signature ~ (m ()), MonadIO m, IsTreeViewColumn a) => O.MethodInfo TreeViewColumnClickedMethodInfo a signature where
    overloadedMethod _ = treeViewColumnClicked

#endif

-- method TreeViewColumn::focus_cell
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_column", argType = TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeViewColumn", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cell", argType = TInterface (Name {namespace = "Gtk", name = "CellRenderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkCellRenderer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_tree_view_column_focus_cell" gtk_tree_view_column_focus_cell :: 
    Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
    Ptr Gtk.CellRenderer.CellRenderer ->    -- cell : TInterface (Name {namespace = "Gtk", name = "CellRenderer"})
    IO ()

{- |
Sets the current keyboard focus to be at /@cell@/, if the column contains
2 or more editable and activatable cells.

/Since: 2.2/
-}
treeViewColumnFocusCell ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a, Gtk.CellRenderer.IsCellRenderer b) =>
    a
    {- ^ /@treeColumn@/: A 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn' -}
    -> b
    {- ^ /@cell@/: A 'GI.Gtk.Objects.CellRenderer.CellRenderer' -}
    -> m ()
treeViewColumnFocusCell treeColumn cell = liftIO $ do
    treeColumn' <- unsafeManagedPtrCastPtr treeColumn
    cell' <- unsafeManagedPtrCastPtr cell
    gtk_tree_view_column_focus_cell treeColumn' cell'
    touchManagedPtr treeColumn
    touchManagedPtr cell
    return ()

#if ENABLE_OVERLOADING
data TreeViewColumnFocusCellMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsTreeViewColumn a, Gtk.CellRenderer.IsCellRenderer b) => O.MethodInfo TreeViewColumnFocusCellMethodInfo a signature where
    overloadedMethod _ = treeViewColumnFocusCell

#endif

-- method TreeViewColumn::get_alignment
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_column", argType = TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeViewColumn.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TFloat)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_tree_view_column_get_alignment" gtk_tree_view_column_get_alignment :: 
    Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
    IO CFloat

{- |
Returns the current x alignment of /@treeColumn@/.  This value can range
between 0.0 and 1.0.
-}
treeViewColumnGetAlignment ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a
    {- ^ /@treeColumn@/: A 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'. -}
    -> m Float
    {- ^ __Returns:__ The current alignent of /@treeColumn@/. -}
treeViewColumnGetAlignment treeColumn = liftIO $ do
    treeColumn' <- unsafeManagedPtrCastPtr treeColumn
    result <- gtk_tree_view_column_get_alignment treeColumn'
    let result' = realToFrac result
    touchManagedPtr treeColumn
    return result'

#if ENABLE_OVERLOADING
data TreeViewColumnGetAlignmentMethodInfo
instance (signature ~ (m Float), MonadIO m, IsTreeViewColumn a) => O.MethodInfo TreeViewColumnGetAlignmentMethodInfo a signature where
    overloadedMethod _ = treeViewColumnGetAlignment

#endif

-- method TreeViewColumn::get_button
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_column", argType = TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeViewColumn", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "Widget"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_tree_view_column_get_button" gtk_tree_view_column_get_button :: 
    Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
    IO (Ptr Gtk.Widget.Widget)

{- |
Returns the button used in the treeview column header

/Since: 3.0/
-}
treeViewColumnGetButton ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a
    {- ^ /@treeColumn@/: A 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn' -}
    -> m Gtk.Widget.Widget
    {- ^ __Returns:__ The button for the column header. -}
treeViewColumnGetButton treeColumn = liftIO $ do
    treeColumn' <- unsafeManagedPtrCastPtr treeColumn
    result <- gtk_tree_view_column_get_button treeColumn'
    checkUnexpectedReturnNULL "treeViewColumnGetButton" result
    result' <- (newObject Gtk.Widget.Widget) result
    touchManagedPtr treeColumn
    return result'

#if ENABLE_OVERLOADING
data TreeViewColumnGetButtonMethodInfo
instance (signature ~ (m Gtk.Widget.Widget), MonadIO m, IsTreeViewColumn a) => O.MethodInfo TreeViewColumnGetButtonMethodInfo a signature where
    overloadedMethod _ = treeViewColumnGetButton

#endif

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

foreign import ccall "gtk_tree_view_column_get_clickable" gtk_tree_view_column_get_clickable :: 
    Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
    IO CInt

{- |
Returns 'True' if the user can click on the header for the column.
-}
treeViewColumnGetClickable ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a
    {- ^ /@treeColumn@/: a 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if user can click the column header. -}
treeViewColumnGetClickable treeColumn = liftIO $ do
    treeColumn' <- unsafeManagedPtrCastPtr treeColumn
    result <- gtk_tree_view_column_get_clickable treeColumn'
    let result' = (/= 0) result
    touchManagedPtr treeColumn
    return result'

#if ENABLE_OVERLOADING
data TreeViewColumnGetClickableMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTreeViewColumn a) => O.MethodInfo TreeViewColumnGetClickableMethodInfo a signature where
    overloadedMethod _ = treeViewColumnGetClickable

#endif

-- method TreeViewColumn::get_expand
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_column", argType = TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeViewColumn.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_tree_view_column_get_expand" gtk_tree_view_column_get_expand :: 
    Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
    IO CInt

{- |
Returns 'True' if the column expands to fill available space.

/Since: 2.4/
-}
treeViewColumnGetExpand ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a
    {- ^ /@treeColumn@/: A 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'. -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the column expands to fill available space. -}
treeViewColumnGetExpand treeColumn = liftIO $ do
    treeColumn' <- unsafeManagedPtrCastPtr treeColumn
    result <- gtk_tree_view_column_get_expand treeColumn'
    let result' = (/= 0) result
    touchManagedPtr treeColumn
    return result'

#if ENABLE_OVERLOADING
data TreeViewColumnGetExpandMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTreeViewColumn a) => O.MethodInfo TreeViewColumnGetExpandMethodInfo a signature where
    overloadedMethod _ = treeViewColumnGetExpand

#endif

-- method TreeViewColumn::get_fixed_width
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_column", argType = TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeViewColumn.", 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_tree_view_column_get_fixed_width" gtk_tree_view_column_get_fixed_width :: 
    Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
    IO Int32

{- |
Gets the fixed width of the column.  This may not be the actual displayed
width of the column; for that, use 'GI.Gtk.Objects.TreeViewColumn.treeViewColumnGetWidth'.
-}
treeViewColumnGetFixedWidth ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a
    {- ^ /@treeColumn@/: A 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'. -}
    -> m Int32
    {- ^ __Returns:__ The fixed width of the column. -}
treeViewColumnGetFixedWidth treeColumn = liftIO $ do
    treeColumn' <- unsafeManagedPtrCastPtr treeColumn
    result <- gtk_tree_view_column_get_fixed_width treeColumn'
    touchManagedPtr treeColumn
    return result

#if ENABLE_OVERLOADING
data TreeViewColumnGetFixedWidthMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsTreeViewColumn a) => O.MethodInfo TreeViewColumnGetFixedWidthMethodInfo a signature where
    overloadedMethod _ = treeViewColumnGetFixedWidth

#endif

-- method TreeViewColumn::get_max_width
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_column", argType = TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeViewColumn.", 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_tree_view_column_get_max_width" gtk_tree_view_column_get_max_width :: 
    Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
    IO Int32

{- |
Returns the maximum width in pixels of the /@treeColumn@/, or -1 if no maximum
width is set.
-}
treeViewColumnGetMaxWidth ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a
    {- ^ /@treeColumn@/: A 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'. -}
    -> m Int32
    {- ^ __Returns:__ The maximum width of the /@treeColumn@/. -}
treeViewColumnGetMaxWidth treeColumn = liftIO $ do
    treeColumn' <- unsafeManagedPtrCastPtr treeColumn
    result <- gtk_tree_view_column_get_max_width treeColumn'
    touchManagedPtr treeColumn
    return result

#if ENABLE_OVERLOADING
data TreeViewColumnGetMaxWidthMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsTreeViewColumn a) => O.MethodInfo TreeViewColumnGetMaxWidthMethodInfo a signature where
    overloadedMethod _ = treeViewColumnGetMaxWidth

#endif

-- method TreeViewColumn::get_min_width
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_column", argType = TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeViewColumn.", 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_tree_view_column_get_min_width" gtk_tree_view_column_get_min_width :: 
    Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
    IO Int32

{- |
Returns the minimum width in pixels of the /@treeColumn@/, or -1 if no minimum
width is set.
-}
treeViewColumnGetMinWidth ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a
    {- ^ /@treeColumn@/: A 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'. -}
    -> m Int32
    {- ^ __Returns:__ The minimum width of the /@treeColumn@/. -}
treeViewColumnGetMinWidth treeColumn = liftIO $ do
    treeColumn' <- unsafeManagedPtrCastPtr treeColumn
    result <- gtk_tree_view_column_get_min_width treeColumn'
    touchManagedPtr treeColumn
    return result

#if ENABLE_OVERLOADING
data TreeViewColumnGetMinWidthMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsTreeViewColumn a) => O.MethodInfo TreeViewColumnGetMinWidthMethodInfo a signature where
    overloadedMethod _ = treeViewColumnGetMinWidth

#endif

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

foreign import ccall "gtk_tree_view_column_get_reorderable" gtk_tree_view_column_get_reorderable :: 
    Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
    IO CInt

{- |
Returns 'True' if the /@treeColumn@/ can be reordered by the user.
-}
treeViewColumnGetReorderable ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a
    {- ^ /@treeColumn@/: A 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the /@treeColumn@/ can be reordered by the user. -}
treeViewColumnGetReorderable treeColumn = liftIO $ do
    treeColumn' <- unsafeManagedPtrCastPtr treeColumn
    result <- gtk_tree_view_column_get_reorderable treeColumn'
    let result' = (/= 0) result
    touchManagedPtr treeColumn
    return result'

#if ENABLE_OVERLOADING
data TreeViewColumnGetReorderableMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTreeViewColumn a) => O.MethodInfo TreeViewColumnGetReorderableMethodInfo a signature where
    overloadedMethod _ = treeViewColumnGetReorderable

#endif

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

foreign import ccall "gtk_tree_view_column_get_resizable" gtk_tree_view_column_get_resizable :: 
    Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
    IO CInt

{- |
Returns 'True' if the /@treeColumn@/ can be resized by the end user.
-}
treeViewColumnGetResizable ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a
    {- ^ /@treeColumn@/: A 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn' -}
    -> m Bool
    {- ^ __Returns:__ 'True', if the /@treeColumn@/ can be resized. -}
treeViewColumnGetResizable treeColumn = liftIO $ do
    treeColumn' <- unsafeManagedPtrCastPtr treeColumn
    result <- gtk_tree_view_column_get_resizable treeColumn'
    let result' = (/= 0) result
    touchManagedPtr treeColumn
    return result'

#if ENABLE_OVERLOADING
data TreeViewColumnGetResizableMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTreeViewColumn a) => O.MethodInfo TreeViewColumnGetResizableMethodInfo a signature where
    overloadedMethod _ = treeViewColumnGetResizable

#endif

-- method TreeViewColumn::get_sizing
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_column", argType = TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeViewColumn.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "TreeViewColumnSizing"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_tree_view_column_get_sizing" gtk_tree_view_column_get_sizing :: 
    Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
    IO CUInt

{- |
Returns the current type of /@treeColumn@/.
-}
treeViewColumnGetSizing ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a
    {- ^ /@treeColumn@/: A 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'. -}
    -> m Gtk.Enums.TreeViewColumnSizing
    {- ^ __Returns:__ The type of /@treeColumn@/. -}
treeViewColumnGetSizing treeColumn = liftIO $ do
    treeColumn' <- unsafeManagedPtrCastPtr treeColumn
    result <- gtk_tree_view_column_get_sizing treeColumn'
    let result' = (toEnum . fromIntegral) result
    touchManagedPtr treeColumn
    return result'

#if ENABLE_OVERLOADING
data TreeViewColumnGetSizingMethodInfo
instance (signature ~ (m Gtk.Enums.TreeViewColumnSizing), MonadIO m, IsTreeViewColumn a) => O.MethodInfo TreeViewColumnGetSizingMethodInfo a signature where
    overloadedMethod _ = treeViewColumnGetSizing

#endif

-- method TreeViewColumn::get_sort_column_id
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_column", argType = TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTreeViewColumn", 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_tree_view_column_get_sort_column_id" gtk_tree_view_column_get_sort_column_id :: 
    Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
    IO Int32

{- |
Gets the logical /@sortColumnId@/ that the model sorts on when this
column is selected for sorting.
See 'GI.Gtk.Objects.TreeViewColumn.treeViewColumnSetSortColumnId'.
-}
treeViewColumnGetSortColumnId ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a
    {- ^ /@treeColumn@/: a 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn' -}
    -> m Int32
    {- ^ __Returns:__ the current /@sortColumnId@/ for this column, or -1 if
              this column can’t be used for sorting. -}
treeViewColumnGetSortColumnId treeColumn = liftIO $ do
    treeColumn' <- unsafeManagedPtrCastPtr treeColumn
    result <- gtk_tree_view_column_get_sort_column_id treeColumn'
    touchManagedPtr treeColumn
    return result

#if ENABLE_OVERLOADING
data TreeViewColumnGetSortColumnIdMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsTreeViewColumn a) => O.MethodInfo TreeViewColumnGetSortColumnIdMethodInfo a signature where
    overloadedMethod _ = treeViewColumnGetSortColumnId

#endif

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

foreign import ccall "gtk_tree_view_column_get_sort_indicator" gtk_tree_view_column_get_sort_indicator :: 
    Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
    IO CInt

{- |
Gets the value set by 'GI.Gtk.Objects.TreeViewColumn.treeViewColumnSetSortIndicator'.
-}
treeViewColumnGetSortIndicator ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a
    {- ^ /@treeColumn@/: a 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn' -}
    -> m Bool
    {- ^ __Returns:__ whether the sort indicator arrow is displayed -}
treeViewColumnGetSortIndicator treeColumn = liftIO $ do
    treeColumn' <- unsafeManagedPtrCastPtr treeColumn
    result <- gtk_tree_view_column_get_sort_indicator treeColumn'
    let result' = (/= 0) result
    touchManagedPtr treeColumn
    return result'

#if ENABLE_OVERLOADING
data TreeViewColumnGetSortIndicatorMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTreeViewColumn a) => O.MethodInfo TreeViewColumnGetSortIndicatorMethodInfo a signature where
    overloadedMethod _ = treeViewColumnGetSortIndicator

#endif

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

foreign import ccall "gtk_tree_view_column_get_sort_order" gtk_tree_view_column_get_sort_order :: 
    Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
    IO CUInt

{- |
Gets the value set by 'GI.Gtk.Objects.TreeViewColumn.treeViewColumnSetSortOrder'.
-}
treeViewColumnGetSortOrder ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a
    {- ^ /@treeColumn@/: a 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn' -}
    -> m Gtk.Enums.SortType
    {- ^ __Returns:__ the sort order the sort indicator is indicating -}
treeViewColumnGetSortOrder treeColumn = liftIO $ do
    treeColumn' <- unsafeManagedPtrCastPtr treeColumn
    result <- gtk_tree_view_column_get_sort_order treeColumn'
    let result' = (toEnum . fromIntegral) result
    touchManagedPtr treeColumn
    return result'

#if ENABLE_OVERLOADING
data TreeViewColumnGetSortOrderMethodInfo
instance (signature ~ (m Gtk.Enums.SortType), MonadIO m, IsTreeViewColumn a) => O.MethodInfo TreeViewColumnGetSortOrderMethodInfo a signature where
    overloadedMethod _ = treeViewColumnGetSortOrder

#endif

-- method TreeViewColumn::get_spacing
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_column", argType = TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeViewColumn.", 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_tree_view_column_get_spacing" gtk_tree_view_column_get_spacing :: 
    Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
    IO Int32

{- |
Returns the spacing of /@treeColumn@/.
-}
treeViewColumnGetSpacing ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a
    {- ^ /@treeColumn@/: A 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'. -}
    -> m Int32
    {- ^ __Returns:__ the spacing of /@treeColumn@/. -}
treeViewColumnGetSpacing treeColumn = liftIO $ do
    treeColumn' <- unsafeManagedPtrCastPtr treeColumn
    result <- gtk_tree_view_column_get_spacing treeColumn'
    touchManagedPtr treeColumn
    return result

#if ENABLE_OVERLOADING
data TreeViewColumnGetSpacingMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsTreeViewColumn a) => O.MethodInfo TreeViewColumnGetSpacingMethodInfo a signature where
    overloadedMethod _ = treeViewColumnGetSpacing

#endif

-- method TreeViewColumn::get_title
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_column", argType = TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeViewColumn.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_tree_view_column_get_title" gtk_tree_view_column_get_title :: 
    Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
    IO CString

{- |
Returns the title of the widget.
-}
treeViewColumnGetTitle ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a
    {- ^ /@treeColumn@/: A 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'. -}
    -> m T.Text
    {- ^ __Returns:__ the title of the column. This string should not be
modified or freed. -}
treeViewColumnGetTitle treeColumn = liftIO $ do
    treeColumn' <- unsafeManagedPtrCastPtr treeColumn
    result <- gtk_tree_view_column_get_title treeColumn'
    checkUnexpectedReturnNULL "treeViewColumnGetTitle" result
    result' <- cstringToText result
    touchManagedPtr treeColumn
    return result'

#if ENABLE_OVERLOADING
data TreeViewColumnGetTitleMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsTreeViewColumn a) => O.MethodInfo TreeViewColumnGetTitleMethodInfo a signature where
    overloadedMethod _ = treeViewColumnGetTitle

#endif

-- method TreeViewColumn::get_tree_view
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_column", argType = TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeViewColumn", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "Widget"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_tree_view_column_get_tree_view" gtk_tree_view_column_get_tree_view :: 
    Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
    IO (Ptr Gtk.Widget.Widget)

{- |
Returns the 'GI.Gtk.Objects.TreeView.TreeView' wherein /@treeColumn@/ has been inserted.
If /@column@/ is currently not inserted in any tree view, 'Nothing' is
returned.

/Since: 2.12/
-}
treeViewColumnGetTreeView ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a
    {- ^ /@treeColumn@/: A 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn' -}
    -> m (Maybe Gtk.Widget.Widget)
    {- ^ __Returns:__ The tree view wherein /@column@/ has
    been inserted if any, 'Nothing' otherwise. -}
treeViewColumnGetTreeView treeColumn = liftIO $ do
    treeColumn' <- unsafeManagedPtrCastPtr treeColumn
    result <- gtk_tree_view_column_get_tree_view treeColumn'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (newObject Gtk.Widget.Widget) result'
        return result''
    touchManagedPtr treeColumn
    return maybeResult

#if ENABLE_OVERLOADING
data TreeViewColumnGetTreeViewMethodInfo
instance (signature ~ (m (Maybe Gtk.Widget.Widget)), MonadIO m, IsTreeViewColumn a) => O.MethodInfo TreeViewColumnGetTreeViewMethodInfo a signature where
    overloadedMethod _ = treeViewColumnGetTreeView

#endif

-- method TreeViewColumn::get_visible
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_column", argType = TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeViewColumn.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_tree_view_column_get_visible" gtk_tree_view_column_get_visible :: 
    Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
    IO CInt

{- |
Returns 'True' if /@treeColumn@/ is visible.
-}
treeViewColumnGetVisible ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a
    {- ^ /@treeColumn@/: A 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'. -}
    -> m Bool
    {- ^ __Returns:__ whether the column is visible or not.  If it is visible, then
the tree will show the column. -}
treeViewColumnGetVisible treeColumn = liftIO $ do
    treeColumn' <- unsafeManagedPtrCastPtr treeColumn
    result <- gtk_tree_view_column_get_visible treeColumn'
    let result' = (/= 0) result
    touchManagedPtr treeColumn
    return result'

#if ENABLE_OVERLOADING
data TreeViewColumnGetVisibleMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTreeViewColumn a) => O.MethodInfo TreeViewColumnGetVisibleMethodInfo a signature where
    overloadedMethod _ = treeViewColumnGetVisible

#endif

-- method TreeViewColumn::get_widget
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_column", argType = TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeViewColumn.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "Widget"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_tree_view_column_get_widget" gtk_tree_view_column_get_widget :: 
    Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
    IO (Ptr Gtk.Widget.Widget)

{- |
Returns the 'GI.Gtk.Objects.Widget.Widget' in the button on the column header.
If a custom widget has not been set then 'Nothing' is returned.
-}
treeViewColumnGetWidget ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a
    {- ^ /@treeColumn@/: A 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'. -}
    -> m (Maybe Gtk.Widget.Widget)
    {- ^ __Returns:__ The 'GI.Gtk.Objects.Widget.Widget' in the column
    header, or 'Nothing' -}
treeViewColumnGetWidget treeColumn = liftIO $ do
    treeColumn' <- unsafeManagedPtrCastPtr treeColumn
    result <- gtk_tree_view_column_get_widget treeColumn'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (newObject Gtk.Widget.Widget) result'
        return result''
    touchManagedPtr treeColumn
    return maybeResult

#if ENABLE_OVERLOADING
data TreeViewColumnGetWidgetMethodInfo
instance (signature ~ (m (Maybe Gtk.Widget.Widget)), MonadIO m, IsTreeViewColumn a) => O.MethodInfo TreeViewColumnGetWidgetMethodInfo a signature where
    overloadedMethod _ = treeViewColumnGetWidget

#endif

-- method TreeViewColumn::get_width
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_column", argType = TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeViewColumn.", 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_tree_view_column_get_width" gtk_tree_view_column_get_width :: 
    Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
    IO Int32

{- |
Returns the current size of /@treeColumn@/ in pixels.
-}
treeViewColumnGetWidth ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a
    {- ^ /@treeColumn@/: A 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'. -}
    -> m Int32
    {- ^ __Returns:__ The current width of /@treeColumn@/. -}
treeViewColumnGetWidth treeColumn = liftIO $ do
    treeColumn' <- unsafeManagedPtrCastPtr treeColumn
    result <- gtk_tree_view_column_get_width treeColumn'
    touchManagedPtr treeColumn
    return result

#if ENABLE_OVERLOADING
data TreeViewColumnGetWidthMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsTreeViewColumn a) => O.MethodInfo TreeViewColumnGetWidthMethodInfo a signature where
    overloadedMethod _ = treeViewColumnGetWidth

#endif

-- method TreeViewColumn::get_x_offset
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_column", argType = TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeViewColumn.", 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_tree_view_column_get_x_offset" gtk_tree_view_column_get_x_offset :: 
    Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
    IO Int32

{- |
Returns the current X offset of /@treeColumn@/ in pixels.

/Since: 3.2/
-}
treeViewColumnGetXOffset ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a
    {- ^ /@treeColumn@/: A 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'. -}
    -> m Int32
    {- ^ __Returns:__ The current X offset of /@treeColumn@/. -}
treeViewColumnGetXOffset treeColumn = liftIO $ do
    treeColumn' <- unsafeManagedPtrCastPtr treeColumn
    result <- gtk_tree_view_column_get_x_offset treeColumn'
    touchManagedPtr treeColumn
    return result

#if ENABLE_OVERLOADING
data TreeViewColumnGetXOffsetMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsTreeViewColumn a) => O.MethodInfo TreeViewColumnGetXOffsetMethodInfo a signature where
    overloadedMethod _ = treeViewColumnGetXOffset

#endif

-- method TreeViewColumn::pack_end
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_column", argType = TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeViewColumn.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cell", argType = TInterface (Name {namespace = "Gtk", name = "CellRenderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The #GtkCellRenderer.", 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 "%TRUE if @cell is to be given extra space allocated to @tree_column.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_tree_view_column_pack_end" gtk_tree_view_column_pack_end :: 
    Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
    Ptr Gtk.CellRenderer.CellRenderer ->    -- cell : TInterface (Name {namespace = "Gtk", name = "CellRenderer"})
    CInt ->                                 -- expand : TBasicType TBoolean
    IO ()

{- |
Adds the /@cell@/ to end of the column. If /@expand@/ is 'False', then the /@cell@/
is allocated no more space than it needs. Any unused space is divided
evenly between cells for which /@expand@/ is 'True'.
-}
treeViewColumnPackEnd ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a, Gtk.CellRenderer.IsCellRenderer b) =>
    a
    {- ^ /@treeColumn@/: A 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'. -}
    -> b
    {- ^ /@cell@/: The 'GI.Gtk.Objects.CellRenderer.CellRenderer'. -}
    -> Bool
    {- ^ /@expand@/: 'True' if /@cell@/ is to be given extra space allocated to /@treeColumn@/. -}
    -> m ()
treeViewColumnPackEnd treeColumn cell expand = liftIO $ do
    treeColumn' <- unsafeManagedPtrCastPtr treeColumn
    cell' <- unsafeManagedPtrCastPtr cell
    let expand' = (fromIntegral . fromEnum) expand
    gtk_tree_view_column_pack_end treeColumn' cell' expand'
    touchManagedPtr treeColumn
    touchManagedPtr cell
    return ()

#if ENABLE_OVERLOADING
data TreeViewColumnPackEndMethodInfo
instance (signature ~ (b -> Bool -> m ()), MonadIO m, IsTreeViewColumn a, Gtk.CellRenderer.IsCellRenderer b) => O.MethodInfo TreeViewColumnPackEndMethodInfo a signature where
    overloadedMethod _ = treeViewColumnPackEnd

#endif

-- method TreeViewColumn::pack_start
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_column", argType = TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeViewColumn.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cell", argType = TInterface (Name {namespace = "Gtk", name = "CellRenderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The #GtkCellRenderer.", 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 "%TRUE if @cell is to be given extra space allocated to @tree_column.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_tree_view_column_pack_start" gtk_tree_view_column_pack_start :: 
    Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
    Ptr Gtk.CellRenderer.CellRenderer ->    -- cell : TInterface (Name {namespace = "Gtk", name = "CellRenderer"})
    CInt ->                                 -- expand : TBasicType TBoolean
    IO ()

{- |
Packs the /@cell@/ into the beginning of the column. If /@expand@/ is 'False', then
the /@cell@/ is allocated no more space than it needs. Any unused space is divided
evenly between cells for which /@expand@/ is 'True'.
-}
treeViewColumnPackStart ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a, Gtk.CellRenderer.IsCellRenderer b) =>
    a
    {- ^ /@treeColumn@/: A 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'. -}
    -> b
    {- ^ /@cell@/: The 'GI.Gtk.Objects.CellRenderer.CellRenderer'. -}
    -> Bool
    {- ^ /@expand@/: 'True' if /@cell@/ is to be given extra space allocated to /@treeColumn@/. -}
    -> m ()
treeViewColumnPackStart treeColumn cell expand = liftIO $ do
    treeColumn' <- unsafeManagedPtrCastPtr treeColumn
    cell' <- unsafeManagedPtrCastPtr cell
    let expand' = (fromIntegral . fromEnum) expand
    gtk_tree_view_column_pack_start treeColumn' cell' expand'
    touchManagedPtr treeColumn
    touchManagedPtr cell
    return ()

#if ENABLE_OVERLOADING
data TreeViewColumnPackStartMethodInfo
instance (signature ~ (b -> Bool -> m ()), MonadIO m, IsTreeViewColumn a, Gtk.CellRenderer.IsCellRenderer b) => O.MethodInfo TreeViewColumnPackStartMethodInfo a signature where
    overloadedMethod _ = treeViewColumnPackStart

#endif

-- method TreeViewColumn::queue_resize
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_column", argType = TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeViewColumn", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_tree_view_column_queue_resize" gtk_tree_view_column_queue_resize :: 
    Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
    IO ()

{- |
Flags the column, and the cell renderers added to this column, to have
their sizes renegotiated.

/Since: 2.8/
-}
treeViewColumnQueueResize ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a
    {- ^ /@treeColumn@/: A 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn' -}
    -> m ()
treeViewColumnQueueResize treeColumn = liftIO $ do
    treeColumn' <- unsafeManagedPtrCastPtr treeColumn
    gtk_tree_view_column_queue_resize treeColumn'
    touchManagedPtr treeColumn
    return ()

#if ENABLE_OVERLOADING
data TreeViewColumnQueueResizeMethodInfo
instance (signature ~ (m ()), MonadIO m, IsTreeViewColumn a) => O.MethodInfo TreeViewColumnQueueResizeMethodInfo a signature where
    overloadedMethod _ = treeViewColumnQueueResize

#endif

-- method TreeViewColumn::set_alignment
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_column", argType = TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeViewColumn.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "xalign", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The alignment, which is between [0.0 and 1.0] inclusive.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_tree_view_column_set_alignment" gtk_tree_view_column_set_alignment :: 
    Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
    CFloat ->                               -- xalign : TBasicType TFloat
    IO ()

{- |
Sets the alignment of the title or custom widget inside the column header.
The alignment determines its location inside the button -- 0.0 for left, 0.5
for center, 1.0 for right.
-}
treeViewColumnSetAlignment ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a
    {- ^ /@treeColumn@/: A 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'. -}
    -> Float
    {- ^ /@xalign@/: The alignment, which is between [0.0 and 1.0] inclusive. -}
    -> m ()
treeViewColumnSetAlignment treeColumn xalign = liftIO $ do
    treeColumn' <- unsafeManagedPtrCastPtr treeColumn
    let xalign' = realToFrac xalign
    gtk_tree_view_column_set_alignment treeColumn' xalign'
    touchManagedPtr treeColumn
    return ()

#if ENABLE_OVERLOADING
data TreeViewColumnSetAlignmentMethodInfo
instance (signature ~ (Float -> m ()), MonadIO m, IsTreeViewColumn a) => O.MethodInfo TreeViewColumnSetAlignmentMethodInfo a signature where
    overloadedMethod _ = treeViewColumnSetAlignment

#endif

-- method TreeViewColumn::set_cell_data_func
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_column", argType = TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeViewColumn", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cell_renderer", argType = TInterface (Name {namespace = "Gtk", name = "CellRenderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkCellRenderer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "func", argType = TInterface (Name {namespace = "Gtk", name = "TreeCellDataFunc"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "The #GtkTreeCellDataFunc to use.", sinceVersion = Nothing}, argScope = ScopeTypeNotified, argClosure = 3, argDestroy = 4, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "func_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "The user data for @func.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "destroy", argType = TInterface (Name {namespace = "GLib", name = "DestroyNotify"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The destroy notification for @func_data", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_tree_view_column_set_cell_data_func" gtk_tree_view_column_set_cell_data_func :: 
    Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
    Ptr Gtk.CellRenderer.CellRenderer ->    -- cell_renderer : TInterface (Name {namespace = "Gtk", name = "CellRenderer"})
    FunPtr Gtk.Callbacks.C_TreeCellDataFunc -> -- func : TInterface (Name {namespace = "Gtk", name = "TreeCellDataFunc"})
    Ptr () ->                               -- func_data : TBasicType TPtr
    FunPtr GLib.Callbacks.C_DestroyNotify -> -- destroy : TInterface (Name {namespace = "GLib", name = "DestroyNotify"})
    IO ()

{- |
Sets the 'GI.Gtk.Callbacks.TreeCellDataFunc' to use for the column.  This
function is used instead of the standard attributes mapping for
setting the column value, and should set the value of /@treeColumn@/\'s
cell renderer as appropriate.  /@func@/ may be 'Nothing' to remove an
older one.
-}
treeViewColumnSetCellDataFunc ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a, Gtk.CellRenderer.IsCellRenderer b) =>
    a
    {- ^ /@treeColumn@/: A 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn' -}
    -> b
    {- ^ /@cellRenderer@/: A 'GI.Gtk.Objects.CellRenderer.CellRenderer' -}
    -> Maybe (Gtk.Callbacks.TreeCellDataFunc)
    {- ^ /@func@/: The 'GI.Gtk.Callbacks.TreeCellDataFunc' to use. -}
    -> m ()
treeViewColumnSetCellDataFunc treeColumn cellRenderer func = liftIO $ do
    treeColumn' <- unsafeManagedPtrCastPtr treeColumn
    cellRenderer' <- unsafeManagedPtrCastPtr cellRenderer
    maybeFunc <- case func of
        Nothing -> return (castPtrToFunPtr nullPtr)
        Just jFunc -> do
            jFunc' <- Gtk.Callbacks.mk_TreeCellDataFunc (Gtk.Callbacks.wrap_TreeCellDataFunc Nothing (Gtk.Callbacks.drop_closures_TreeCellDataFunc jFunc))
            return jFunc'
    let funcData = castFunPtrToPtr maybeFunc
    let destroy = safeFreeFunPtrPtr
    gtk_tree_view_column_set_cell_data_func treeColumn' cellRenderer' maybeFunc funcData destroy
    touchManagedPtr treeColumn
    touchManagedPtr cellRenderer
    return ()

#if ENABLE_OVERLOADING
data TreeViewColumnSetCellDataFuncMethodInfo
instance (signature ~ (b -> Maybe (Gtk.Callbacks.TreeCellDataFunc) -> m ()), MonadIO m, IsTreeViewColumn a, Gtk.CellRenderer.IsCellRenderer b) => O.MethodInfo TreeViewColumnSetCellDataFuncMethodInfo a signature where
    overloadedMethod _ = treeViewColumnSetCellDataFunc

#endif

-- method TreeViewColumn::set_clickable
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_column", argType = TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeViewColumn.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "clickable", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE if the header is active.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_tree_view_column_set_clickable" gtk_tree_view_column_set_clickable :: 
    Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
    CInt ->                                 -- clickable : TBasicType TBoolean
    IO ()

{- |
Sets the header to be active if /@clickable@/ is 'True'.  When the header is
active, then it can take keyboard focus, and can be clicked.
-}
treeViewColumnSetClickable ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a
    {- ^ /@treeColumn@/: A 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'. -}
    -> Bool
    {- ^ /@clickable@/: 'True' if the header is active. -}
    -> m ()
treeViewColumnSetClickable treeColumn clickable = liftIO $ do
    treeColumn' <- unsafeManagedPtrCastPtr treeColumn
    let clickable' = (fromIntegral . fromEnum) clickable
    gtk_tree_view_column_set_clickable treeColumn' clickable'
    touchManagedPtr treeColumn
    return ()

#if ENABLE_OVERLOADING
data TreeViewColumnSetClickableMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTreeViewColumn a) => O.MethodInfo TreeViewColumnSetClickableMethodInfo a signature where
    overloadedMethod _ = treeViewColumnSetClickable

#endif

-- method TreeViewColumn::set_expand
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_column", argType = TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeViewColumn.", 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 "%TRUE if the column should expand to fill available space.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_tree_view_column_set_expand" gtk_tree_view_column_set_expand :: 
    Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
    CInt ->                                 -- expand : TBasicType TBoolean
    IO ()

{- |
Sets the column to take available extra space.  This space is shared equally
amongst all columns that have the expand set to 'True'.  If no column has this
option set, then the last column gets all extra space.  By default, every
column is created with this 'False'.

Along with “fixed-width”, the “expand” property changes when the column is
resized by the user.

/Since: 2.4/
-}
treeViewColumnSetExpand ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a
    {- ^ /@treeColumn@/: A 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'. -}
    -> Bool
    {- ^ /@expand@/: 'True' if the column should expand to fill available space. -}
    -> m ()
treeViewColumnSetExpand treeColumn expand = liftIO $ do
    treeColumn' <- unsafeManagedPtrCastPtr treeColumn
    let expand' = (fromIntegral . fromEnum) expand
    gtk_tree_view_column_set_expand treeColumn' expand'
    touchManagedPtr treeColumn
    return ()

#if ENABLE_OVERLOADING
data TreeViewColumnSetExpandMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTreeViewColumn a) => O.MethodInfo TreeViewColumnSetExpandMethodInfo a signature where
    overloadedMethod _ = treeViewColumnSetExpand

#endif

-- method TreeViewColumn::set_fixed_width
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_column", argType = TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeViewColumn.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fixed_width", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The new fixed width, in pixels, or -1.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_tree_view_column_set_fixed_width" gtk_tree_view_column_set_fixed_width :: 
    Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
    Int32 ->                                -- fixed_width : TBasicType TInt
    IO ()

{- |
If /@fixedWidth@/ is not -1, sets the fixed width of /@treeColumn@/; otherwise
unsets it.  The effective value of /@fixedWidth@/ is clamped between the
minimum and maximum width of the column; however, the value stored in the
“fixed-width” property is not clamped.  If the column sizing is
@/GTK_TREE_VIEW_COLUMN_GROW_ONLY/@ or @/GTK_TREE_VIEW_COLUMN_AUTOSIZE/@, setting
a fixed width overrides the automatically calculated width.  Note that
/@fixedWidth@/ is only a hint to GTK+; the width actually allocated to the
column may be greater or less than requested.

Along with “expand”, the “fixed-width” property changes when the column is
resized by the user.
-}
treeViewColumnSetFixedWidth ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a
    {- ^ /@treeColumn@/: A 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'. -}
    -> Int32
    {- ^ /@fixedWidth@/: The new fixed width, in pixels, or -1. -}
    -> m ()
treeViewColumnSetFixedWidth treeColumn fixedWidth = liftIO $ do
    treeColumn' <- unsafeManagedPtrCastPtr treeColumn
    gtk_tree_view_column_set_fixed_width treeColumn' fixedWidth
    touchManagedPtr treeColumn
    return ()

#if ENABLE_OVERLOADING
data TreeViewColumnSetFixedWidthMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m, IsTreeViewColumn a) => O.MethodInfo TreeViewColumnSetFixedWidthMethodInfo a signature where
    overloadedMethod _ = treeViewColumnSetFixedWidth

#endif

-- method TreeViewColumn::set_max_width
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_column", argType = TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeViewColumn.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "max_width", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The maximum width of the column in pixels, or -1.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_tree_view_column_set_max_width" gtk_tree_view_column_set_max_width :: 
    Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
    Int32 ->                                -- max_width : TBasicType TInt
    IO ()

{- |
Sets the maximum width of the /@treeColumn@/.  If /@maxWidth@/ is -1, then the
maximum width is unset.  Note, the column can actually be wider than max
width if it’s the last column in a view.  In this case, the column expands to
fill any extra space.
-}
treeViewColumnSetMaxWidth ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a
    {- ^ /@treeColumn@/: A 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'. -}
    -> Int32
    {- ^ /@maxWidth@/: The maximum width of the column in pixels, or -1. -}
    -> m ()
treeViewColumnSetMaxWidth treeColumn maxWidth = liftIO $ do
    treeColumn' <- unsafeManagedPtrCastPtr treeColumn
    gtk_tree_view_column_set_max_width treeColumn' maxWidth
    touchManagedPtr treeColumn
    return ()

#if ENABLE_OVERLOADING
data TreeViewColumnSetMaxWidthMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m, IsTreeViewColumn a) => O.MethodInfo TreeViewColumnSetMaxWidthMethodInfo a signature where
    overloadedMethod _ = treeViewColumnSetMaxWidth

#endif

-- method TreeViewColumn::set_min_width
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_column", argType = TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeViewColumn.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "min_width", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The minimum width of the column in pixels, or -1.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_tree_view_column_set_min_width" gtk_tree_view_column_set_min_width :: 
    Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
    Int32 ->                                -- min_width : TBasicType TInt
    IO ()

{- |
Sets the minimum width of the /@treeColumn@/.  If /@minWidth@/ is -1, then the
minimum width is unset.
-}
treeViewColumnSetMinWidth ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a
    {- ^ /@treeColumn@/: A 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'. -}
    -> Int32
    {- ^ /@minWidth@/: The minimum width of the column in pixels, or -1. -}
    -> m ()
treeViewColumnSetMinWidth treeColumn minWidth = liftIO $ do
    treeColumn' <- unsafeManagedPtrCastPtr treeColumn
    gtk_tree_view_column_set_min_width treeColumn' minWidth
    touchManagedPtr treeColumn
    return ()

#if ENABLE_OVERLOADING
data TreeViewColumnSetMinWidthMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m, IsTreeViewColumn a) => O.MethodInfo TreeViewColumnSetMinWidthMethodInfo a signature where
    overloadedMethod _ = treeViewColumnSetMinWidth

#endif

-- method TreeViewColumn::set_reorderable
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_column", argType = TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeViewColumn", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "reorderable", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE, if the column can be reordered.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_tree_view_column_set_reorderable" gtk_tree_view_column_set_reorderable :: 
    Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
    CInt ->                                 -- reorderable : TBasicType TBoolean
    IO ()

{- |
If /@reorderable@/ is 'True', then the column can be reordered by the end user
dragging the header.
-}
treeViewColumnSetReorderable ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a
    {- ^ /@treeColumn@/: A 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn' -}
    -> Bool
    {- ^ /@reorderable@/: 'True', if the column can be reordered. -}
    -> m ()
treeViewColumnSetReorderable treeColumn reorderable = liftIO $ do
    treeColumn' <- unsafeManagedPtrCastPtr treeColumn
    let reorderable' = (fromIntegral . fromEnum) reorderable
    gtk_tree_view_column_set_reorderable treeColumn' reorderable'
    touchManagedPtr treeColumn
    return ()

#if ENABLE_OVERLOADING
data TreeViewColumnSetReorderableMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTreeViewColumn a) => O.MethodInfo TreeViewColumnSetReorderableMethodInfo a signature where
    overloadedMethod _ = treeViewColumnSetReorderable

#endif

-- method TreeViewColumn::set_resizable
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_column", argType = TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeViewColumn", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "resizable", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE, if the column can be resized", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_tree_view_column_set_resizable" gtk_tree_view_column_set_resizable :: 
    Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
    CInt ->                                 -- resizable : TBasicType TBoolean
    IO ()

{- |
If /@resizable@/ is 'True', then the user can explicitly resize the column by
grabbing the outer edge of the column button.  If resizable is 'True' and
sizing mode of the column is @/GTK_TREE_VIEW_COLUMN_AUTOSIZE/@, then the sizing
mode is changed to @/GTK_TREE_VIEW_COLUMN_GROW_ONLY/@.
-}
treeViewColumnSetResizable ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a
    {- ^ /@treeColumn@/: A 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn' -}
    -> Bool
    {- ^ /@resizable@/: 'True', if the column can be resized -}
    -> m ()
treeViewColumnSetResizable treeColumn resizable = liftIO $ do
    treeColumn' <- unsafeManagedPtrCastPtr treeColumn
    let resizable' = (fromIntegral . fromEnum) resizable
    gtk_tree_view_column_set_resizable treeColumn' resizable'
    touchManagedPtr treeColumn
    return ()

#if ENABLE_OVERLOADING
data TreeViewColumnSetResizableMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTreeViewColumn a) => O.MethodInfo TreeViewColumnSetResizableMethodInfo a signature where
    overloadedMethod _ = treeViewColumnSetResizable

#endif

-- method TreeViewColumn::set_sizing
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_column", argType = TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeViewColumn.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TInterface (Name {namespace = "Gtk", name = "TreeViewColumnSizing"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The #GtkTreeViewColumnSizing.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_tree_view_column_set_sizing" gtk_tree_view_column_set_sizing :: 
    Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
    CUInt ->                                -- type : TInterface (Name {namespace = "Gtk", name = "TreeViewColumnSizing"})
    IO ()

{- |
Sets the growth behavior of /@treeColumn@/ to /@type@/.
-}
treeViewColumnSetSizing ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a
    {- ^ /@treeColumn@/: A 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'. -}
    -> Gtk.Enums.TreeViewColumnSizing
    {- ^ /@type@/: The 'GI.Gtk.Enums.TreeViewColumnSizing'. -}
    -> m ()
treeViewColumnSetSizing treeColumn type_ = liftIO $ do
    treeColumn' <- unsafeManagedPtrCastPtr treeColumn
    let type_' = (fromIntegral . fromEnum) type_
    gtk_tree_view_column_set_sizing treeColumn' type_'
    touchManagedPtr treeColumn
    return ()

#if ENABLE_OVERLOADING
data TreeViewColumnSetSizingMethodInfo
instance (signature ~ (Gtk.Enums.TreeViewColumnSizing -> m ()), MonadIO m, IsTreeViewColumn a) => O.MethodInfo TreeViewColumnSetSizingMethodInfo a signature where
    overloadedMethod _ = treeViewColumnSetSizing

#endif

-- method TreeViewColumn::set_sort_column_id
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_column", argType = TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTreeViewColumn", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "sort_column_id", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The @sort_column_id of the model to sort on.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_tree_view_column_set_sort_column_id" gtk_tree_view_column_set_sort_column_id :: 
    Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
    Int32 ->                                -- sort_column_id : TBasicType TInt
    IO ()

{- |
Sets the logical /@sortColumnId@/ that this column sorts on when this column
is selected for sorting.  Doing so makes the column header clickable.
-}
treeViewColumnSetSortColumnId ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a
    {- ^ /@treeColumn@/: a 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn' -}
    -> Int32
    {- ^ /@sortColumnId@/: The /@sortColumnId@/ of the model to sort on. -}
    -> m ()
treeViewColumnSetSortColumnId treeColumn sortColumnId = liftIO $ do
    treeColumn' <- unsafeManagedPtrCastPtr treeColumn
    gtk_tree_view_column_set_sort_column_id treeColumn' sortColumnId
    touchManagedPtr treeColumn
    return ()

#if ENABLE_OVERLOADING
data TreeViewColumnSetSortColumnIdMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m, IsTreeViewColumn a) => O.MethodInfo TreeViewColumnSetSortColumnIdMethodInfo a signature where
    overloadedMethod _ = treeViewColumnSetSortColumnId

#endif

-- method TreeViewColumn::set_sort_indicator
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_column", argType = TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTreeViewColumn", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "setting", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE to display an indicator that the column is sorted", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_tree_view_column_set_sort_indicator" gtk_tree_view_column_set_sort_indicator :: 
    Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
    CInt ->                                 -- setting : TBasicType TBoolean
    IO ()

{- |
Call this function with a /@setting@/ of 'True' to display an arrow in
the header button indicating the column is sorted. Call
'GI.Gtk.Objects.TreeViewColumn.treeViewColumnSetSortOrder' to change the direction of
the arrow.
-}
treeViewColumnSetSortIndicator ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a
    {- ^ /@treeColumn@/: a 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn' -}
    -> Bool
    {- ^ /@setting@/: 'True' to display an indicator that the column is sorted -}
    -> m ()
treeViewColumnSetSortIndicator treeColumn setting = liftIO $ do
    treeColumn' <- unsafeManagedPtrCastPtr treeColumn
    let setting' = (fromIntegral . fromEnum) setting
    gtk_tree_view_column_set_sort_indicator treeColumn' setting'
    touchManagedPtr treeColumn
    return ()

#if ENABLE_OVERLOADING
data TreeViewColumnSetSortIndicatorMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTreeViewColumn a) => O.MethodInfo TreeViewColumnSetSortIndicatorMethodInfo a signature where
    overloadedMethod _ = treeViewColumnSetSortIndicator

#endif

-- method TreeViewColumn::set_sort_order
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_column", argType = TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTreeViewColumn", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "order", argType = TInterface (Name {namespace = "Gtk", name = "SortType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "sort order that the sort indicator should indicate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_tree_view_column_set_sort_order" gtk_tree_view_column_set_sort_order :: 
    Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
    CUInt ->                                -- order : TInterface (Name {namespace = "Gtk", name = "SortType"})
    IO ()

{- |
Changes the appearance of the sort indicator.

This does not actually sort the model.  Use
'GI.Gtk.Objects.TreeViewColumn.treeViewColumnSetSortColumnId' if you want automatic sorting
support.  This function is primarily for custom sorting behavior, and should
be used in conjunction with 'GI.Gtk.Interfaces.TreeSortable.treeSortableSetSortColumnId' to do
that. For custom models, the mechanism will vary.

The sort indicator changes direction to indicate normal sort or reverse sort.
Note that you must have the sort indicator enabled to see anything when
calling this function; see 'GI.Gtk.Objects.TreeViewColumn.treeViewColumnSetSortIndicator'.
-}
treeViewColumnSetSortOrder ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a
    {- ^ /@treeColumn@/: a 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn' -}
    -> Gtk.Enums.SortType
    {- ^ /@order@/: sort order that the sort indicator should indicate -}
    -> m ()
treeViewColumnSetSortOrder treeColumn order = liftIO $ do
    treeColumn' <- unsafeManagedPtrCastPtr treeColumn
    let order' = (fromIntegral . fromEnum) order
    gtk_tree_view_column_set_sort_order treeColumn' order'
    touchManagedPtr treeColumn
    return ()

#if ENABLE_OVERLOADING
data TreeViewColumnSetSortOrderMethodInfo
instance (signature ~ (Gtk.Enums.SortType -> m ()), MonadIO m, IsTreeViewColumn a) => O.MethodInfo TreeViewColumnSetSortOrderMethodInfo a signature where
    overloadedMethod _ = treeViewColumnSetSortOrder

#endif

-- method TreeViewColumn::set_spacing
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_column", argType = TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeViewColumn.", 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 "distance between cell renderers in pixels.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

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

{- |
Sets the spacing field of /@treeColumn@/, which is the number of pixels to
place between cell renderers packed into it.
-}
treeViewColumnSetSpacing ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a
    {- ^ /@treeColumn@/: A 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'. -}
    -> Int32
    {- ^ /@spacing@/: distance between cell renderers in pixels. -}
    -> m ()
treeViewColumnSetSpacing treeColumn spacing = liftIO $ do
    treeColumn' <- unsafeManagedPtrCastPtr treeColumn
    gtk_tree_view_column_set_spacing treeColumn' spacing
    touchManagedPtr treeColumn
    return ()

#if ENABLE_OVERLOADING
data TreeViewColumnSetSpacingMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m, IsTreeViewColumn a) => O.MethodInfo TreeViewColumnSetSpacingMethodInfo a signature where
    overloadedMethod _ = treeViewColumnSetSpacing

#endif

-- method TreeViewColumn::set_title
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_column", argType = TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeViewColumn.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "title", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The title of the @tree_column.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_tree_view_column_set_title" gtk_tree_view_column_set_title :: 
    Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
    CString ->                              -- title : TBasicType TUTF8
    IO ()

{- |
Sets the title of the /@treeColumn@/.  If a custom widget has been set, then
this value is ignored.
-}
treeViewColumnSetTitle ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a
    {- ^ /@treeColumn@/: A 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'. -}
    -> T.Text
    {- ^ /@title@/: The title of the /@treeColumn@/. -}
    -> m ()
treeViewColumnSetTitle treeColumn title = liftIO $ do
    treeColumn' <- unsafeManagedPtrCastPtr treeColumn
    title' <- textToCString title
    gtk_tree_view_column_set_title treeColumn' title'
    touchManagedPtr treeColumn
    freeMem title'
    return ()

#if ENABLE_OVERLOADING
data TreeViewColumnSetTitleMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsTreeViewColumn a) => O.MethodInfo TreeViewColumnSetTitleMethodInfo a signature where
    overloadedMethod _ = treeViewColumnSetTitle

#endif

-- method TreeViewColumn::set_visible
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_column", argType = TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeViewColumn.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "visible", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE if the @tree_column is visible.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_tree_view_column_set_visible" gtk_tree_view_column_set_visible :: 
    Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
    CInt ->                                 -- visible : TBasicType TBoolean
    IO ()

{- |
Sets the visibility of /@treeColumn@/.
-}
treeViewColumnSetVisible ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a
    {- ^ /@treeColumn@/: A 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'. -}
    -> Bool
    {- ^ /@visible@/: 'True' if the /@treeColumn@/ is visible. -}
    -> m ()
treeViewColumnSetVisible treeColumn visible = liftIO $ do
    treeColumn' <- unsafeManagedPtrCastPtr treeColumn
    let visible' = (fromIntegral . fromEnum) visible
    gtk_tree_view_column_set_visible treeColumn' visible'
    touchManagedPtr treeColumn
    return ()

#if ENABLE_OVERLOADING
data TreeViewColumnSetVisibleMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTreeViewColumn a) => O.MethodInfo TreeViewColumnSetVisibleMethodInfo a signature where
    overloadedMethod _ = treeViewColumnSetVisible

#endif

-- method TreeViewColumn::set_widget
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_column", argType = TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeViewColumn.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "A child #GtkWidget, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_tree_view_column_set_widget" gtk_tree_view_column_set_widget :: 
    Ptr TreeViewColumn ->                   -- tree_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
    Ptr Gtk.Widget.Widget ->                -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

{- |
Sets the widget in the header to be /@widget@/.  If widget is 'Nothing', then the
header button is set with a 'GI.Gtk.Objects.Label.Label' set to the title of /@treeColumn@/.
-}
treeViewColumnSetWidget ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a, Gtk.Widget.IsWidget b) =>
    a
    {- ^ /@treeColumn@/: A 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'. -}
    -> Maybe (b)
    {- ^ /@widget@/: A child 'GI.Gtk.Objects.Widget.Widget', or 'Nothing'. -}
    -> m ()
treeViewColumnSetWidget treeColumn widget = liftIO $ do
    treeColumn' <- unsafeManagedPtrCastPtr treeColumn
    maybeWidget <- case widget of
        Nothing -> return nullPtr
        Just jWidget -> do
            jWidget' <- unsafeManagedPtrCastPtr jWidget
            return jWidget'
    gtk_tree_view_column_set_widget treeColumn' maybeWidget
    touchManagedPtr treeColumn
    whenJust widget touchManagedPtr
    return ()

#if ENABLE_OVERLOADING
data TreeViewColumnSetWidgetMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsTreeViewColumn a, Gtk.Widget.IsWidget b) => O.MethodInfo TreeViewColumnSetWidgetMethodInfo a signature where
    overloadedMethod _ = treeViewColumnSetWidget

#endif