{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- The GtkTreeViewColumn object represents a visible column in a t'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.

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

module GI.Gtk.Objects.TreeViewColumn
    ( 

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


 -- * Methods
-- ** Overloaded methods #method:Overloaded methods#

#if defined(ENABLE_OVERLOADING)
    ResolveTreeViewColumnMethod             ,
#endif


-- ** addAttribute #method:addAttribute#

#if defined(ENABLE_OVERLOADING)
    TreeViewColumnAddAttributeMethodInfo    ,
#endif
    treeViewColumnAddAttribute              ,


-- ** cellGetPosition #method:cellGetPosition#

#if defined(ENABLE_OVERLOADING)
    TreeViewColumnCellGetPositionMethodInfo ,
#endif
    treeViewColumnCellGetPosition           ,


-- ** cellGetSize #method:cellGetSize#

#if defined(ENABLE_OVERLOADING)
    TreeViewColumnCellGetSizeMethodInfo     ,
#endif
    treeViewColumnCellGetSize               ,


-- ** cellIsVisible #method:cellIsVisible#

#if defined(ENABLE_OVERLOADING)
    TreeViewColumnCellIsVisibleMethodInfo   ,
#endif
    treeViewColumnCellIsVisible             ,


-- ** cellSetCellData #method:cellSetCellData#

#if defined(ENABLE_OVERLOADING)
    TreeViewColumnCellSetCellDataMethodInfo ,
#endif
    treeViewColumnCellSetCellData           ,


-- ** clear #method:clear#

#if defined(ENABLE_OVERLOADING)
    TreeViewColumnClearMethodInfo           ,
#endif
    treeViewColumnClear                     ,


-- ** clearAttributes #method:clearAttributes#

#if defined(ENABLE_OVERLOADING)
    TreeViewColumnClearAttributesMethodInfo ,
#endif
    treeViewColumnClearAttributes           ,


-- ** clicked #method:clicked#

#if defined(ENABLE_OVERLOADING)
    TreeViewColumnClickedMethodInfo         ,
#endif
    treeViewColumnClicked                   ,


-- ** focusCell #method:focusCell#

#if defined(ENABLE_OVERLOADING)
    TreeViewColumnFocusCellMethodInfo       ,
#endif
    treeViewColumnFocusCell                 ,


-- ** getAlignment #method:getAlignment#

#if defined(ENABLE_OVERLOADING)
    TreeViewColumnGetAlignmentMethodInfo    ,
#endif
    treeViewColumnGetAlignment              ,


-- ** getButton #method:getButton#

#if defined(ENABLE_OVERLOADING)
    TreeViewColumnGetButtonMethodInfo       ,
#endif
    treeViewColumnGetButton                 ,


-- ** getClickable #method:getClickable#

#if defined(ENABLE_OVERLOADING)
    TreeViewColumnGetClickableMethodInfo    ,
#endif
    treeViewColumnGetClickable              ,


-- ** getExpand #method:getExpand#

#if defined(ENABLE_OVERLOADING)
    TreeViewColumnGetExpandMethodInfo       ,
#endif
    treeViewColumnGetExpand                 ,


-- ** getFixedWidth #method:getFixedWidth#

#if defined(ENABLE_OVERLOADING)
    TreeViewColumnGetFixedWidthMethodInfo   ,
#endif
    treeViewColumnGetFixedWidth             ,


-- ** getMaxWidth #method:getMaxWidth#

#if defined(ENABLE_OVERLOADING)
    TreeViewColumnGetMaxWidthMethodInfo     ,
#endif
    treeViewColumnGetMaxWidth               ,


-- ** getMinWidth #method:getMinWidth#

#if defined(ENABLE_OVERLOADING)
    TreeViewColumnGetMinWidthMethodInfo     ,
#endif
    treeViewColumnGetMinWidth               ,


-- ** getReorderable #method:getReorderable#

#if defined(ENABLE_OVERLOADING)
    TreeViewColumnGetReorderableMethodInfo  ,
#endif
    treeViewColumnGetReorderable            ,


-- ** getResizable #method:getResizable#

#if defined(ENABLE_OVERLOADING)
    TreeViewColumnGetResizableMethodInfo    ,
#endif
    treeViewColumnGetResizable              ,


-- ** getSizing #method:getSizing#

#if defined(ENABLE_OVERLOADING)
    TreeViewColumnGetSizingMethodInfo       ,
#endif
    treeViewColumnGetSizing                 ,


-- ** getSortColumnId #method:getSortColumnId#

#if defined(ENABLE_OVERLOADING)
    TreeViewColumnGetSortColumnIdMethodInfo ,
#endif
    treeViewColumnGetSortColumnId           ,


-- ** getSortIndicator #method:getSortIndicator#

#if defined(ENABLE_OVERLOADING)
    TreeViewColumnGetSortIndicatorMethodInfo,
#endif
    treeViewColumnGetSortIndicator          ,


-- ** getSortOrder #method:getSortOrder#

#if defined(ENABLE_OVERLOADING)
    TreeViewColumnGetSortOrderMethodInfo    ,
#endif
    treeViewColumnGetSortOrder              ,


-- ** getSpacing #method:getSpacing#

#if defined(ENABLE_OVERLOADING)
    TreeViewColumnGetSpacingMethodInfo      ,
#endif
    treeViewColumnGetSpacing                ,


-- ** getTitle #method:getTitle#

#if defined(ENABLE_OVERLOADING)
    TreeViewColumnGetTitleMethodInfo        ,
#endif
    treeViewColumnGetTitle                  ,


-- ** getTreeView #method:getTreeView#

#if defined(ENABLE_OVERLOADING)
    TreeViewColumnGetTreeViewMethodInfo     ,
#endif
    treeViewColumnGetTreeView               ,


-- ** getVisible #method:getVisible#

#if defined(ENABLE_OVERLOADING)
    TreeViewColumnGetVisibleMethodInfo      ,
#endif
    treeViewColumnGetVisible                ,


-- ** getWidget #method:getWidget#

#if defined(ENABLE_OVERLOADING)
    TreeViewColumnGetWidgetMethodInfo       ,
#endif
    treeViewColumnGetWidget                 ,


-- ** getWidth #method:getWidth#

#if defined(ENABLE_OVERLOADING)
    TreeViewColumnGetWidthMethodInfo        ,
#endif
    treeViewColumnGetWidth                  ,


-- ** getXOffset #method:getXOffset#

#if defined(ENABLE_OVERLOADING)
    TreeViewColumnGetXOffsetMethodInfo      ,
#endif
    treeViewColumnGetXOffset                ,


-- ** new #method:new#

    treeViewColumnNew                       ,


-- ** newWithArea #method:newWithArea#

    treeViewColumnNewWithArea               ,


-- ** packEnd #method:packEnd#

#if defined(ENABLE_OVERLOADING)
    TreeViewColumnPackEndMethodInfo         ,
#endif
    treeViewColumnPackEnd                   ,


-- ** packStart #method:packStart#

#if defined(ENABLE_OVERLOADING)
    TreeViewColumnPackStartMethodInfo       ,
#endif
    treeViewColumnPackStart                 ,


-- ** queueResize #method:queueResize#

#if defined(ENABLE_OVERLOADING)
    TreeViewColumnQueueResizeMethodInfo     ,
#endif
    treeViewColumnQueueResize               ,


-- ** setAlignment #method:setAlignment#

#if defined(ENABLE_OVERLOADING)
    TreeViewColumnSetAlignmentMethodInfo    ,
#endif
    treeViewColumnSetAlignment              ,


-- ** setCellDataFunc #method:setCellDataFunc#

#if defined(ENABLE_OVERLOADING)
    TreeViewColumnSetCellDataFuncMethodInfo ,
#endif
    treeViewColumnSetCellDataFunc           ,


-- ** setClickable #method:setClickable#

#if defined(ENABLE_OVERLOADING)
    TreeViewColumnSetClickableMethodInfo    ,
#endif
    treeViewColumnSetClickable              ,


-- ** setExpand #method:setExpand#

#if defined(ENABLE_OVERLOADING)
    TreeViewColumnSetExpandMethodInfo       ,
#endif
    treeViewColumnSetExpand                 ,


-- ** setFixedWidth #method:setFixedWidth#

#if defined(ENABLE_OVERLOADING)
    TreeViewColumnSetFixedWidthMethodInfo   ,
#endif
    treeViewColumnSetFixedWidth             ,


-- ** setMaxWidth #method:setMaxWidth#

#if defined(ENABLE_OVERLOADING)
    TreeViewColumnSetMaxWidthMethodInfo     ,
#endif
    treeViewColumnSetMaxWidth               ,


-- ** setMinWidth #method:setMinWidth#

#if defined(ENABLE_OVERLOADING)
    TreeViewColumnSetMinWidthMethodInfo     ,
#endif
    treeViewColumnSetMinWidth               ,


-- ** setReorderable #method:setReorderable#

#if defined(ENABLE_OVERLOADING)
    TreeViewColumnSetReorderableMethodInfo  ,
#endif
    treeViewColumnSetReorderable            ,


-- ** setResizable #method:setResizable#

#if defined(ENABLE_OVERLOADING)
    TreeViewColumnSetResizableMethodInfo    ,
#endif
    treeViewColumnSetResizable              ,


-- ** setSizing #method:setSizing#

#if defined(ENABLE_OVERLOADING)
    TreeViewColumnSetSizingMethodInfo       ,
#endif
    treeViewColumnSetSizing                 ,


-- ** setSortColumnId #method:setSortColumnId#

#if defined(ENABLE_OVERLOADING)
    TreeViewColumnSetSortColumnIdMethodInfo ,
#endif
    treeViewColumnSetSortColumnId           ,


-- ** setSortIndicator #method:setSortIndicator#

#if defined(ENABLE_OVERLOADING)
    TreeViewColumnSetSortIndicatorMethodInfo,
#endif
    treeViewColumnSetSortIndicator          ,


-- ** setSortOrder #method:setSortOrder#

#if defined(ENABLE_OVERLOADING)
    TreeViewColumnSetSortOrderMethodInfo    ,
#endif
    treeViewColumnSetSortOrder              ,


-- ** setSpacing #method:setSpacing#

#if defined(ENABLE_OVERLOADING)
    TreeViewColumnSetSpacingMethodInfo      ,
#endif
    treeViewColumnSetSpacing                ,


-- ** setTitle #method:setTitle#

#if defined(ENABLE_OVERLOADING)
    TreeViewColumnSetTitleMethodInfo        ,
#endif
    treeViewColumnSetTitle                  ,


-- ** setVisible #method:setVisible#

#if defined(ENABLE_OVERLOADING)
    TreeViewColumnSetVisibleMethodInfo      ,
#endif
    treeViewColumnSetVisible                ,


-- ** setWidget #method:setWidget#

#if defined(ENABLE_OVERLOADING)
    TreeViewColumnSetWidgetMethodInfo       ,
#endif
    treeViewColumnSetWidget                 ,




 -- * Properties
-- ** alignment #attr:alignment#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    TreeViewColumnAlignmentPropertyInfo     ,
#endif
    constructTreeViewColumnAlignment        ,
    getTreeViewColumnAlignment              ,
    setTreeViewColumnAlignment              ,
#if defined(ENABLE_OVERLOADING)
    treeViewColumnAlignment                 ,
#endif


-- ** cellArea #attr:cellArea#
-- | The t'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 t'GI.Gtk.Objects.CellAreaBox.CellAreaBox' will be used.
-- 
-- /Since: 3.0/

#if defined(ENABLE_OVERLOADING)
    TreeViewColumnCellAreaPropertyInfo      ,
#endif
    constructTreeViewColumnCellArea         ,
    getTreeViewColumnCellArea               ,
#if defined(ENABLE_OVERLOADING)
    treeViewColumnCellArea                  ,
#endif


-- ** clickable #attr:clickable#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    TreeViewColumnClickablePropertyInfo     ,
#endif
    constructTreeViewColumnClickable        ,
    getTreeViewColumnClickable              ,
    setTreeViewColumnClickable              ,
#if defined(ENABLE_OVERLOADING)
    treeViewColumnClickable                 ,
#endif


-- ** expand #attr:expand#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    TreeViewColumnExpandPropertyInfo        ,
#endif
    constructTreeViewColumnExpand           ,
    getTreeViewColumnExpand                 ,
    setTreeViewColumnExpand                 ,
#if defined(ENABLE_OVERLOADING)
    treeViewColumnExpand                    ,
#endif


-- ** fixedWidth #attr:fixedWidth#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    TreeViewColumnFixedWidthPropertyInfo    ,
#endif
    constructTreeViewColumnFixedWidth       ,
    getTreeViewColumnFixedWidth             ,
    setTreeViewColumnFixedWidth             ,
#if defined(ENABLE_OVERLOADING)
    treeViewColumnFixedWidth                ,
#endif


-- ** maxWidth #attr:maxWidth#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    TreeViewColumnMaxWidthPropertyInfo      ,
#endif
    constructTreeViewColumnMaxWidth         ,
    getTreeViewColumnMaxWidth               ,
    setTreeViewColumnMaxWidth               ,
#if defined(ENABLE_OVERLOADING)
    treeViewColumnMaxWidth                  ,
#endif


-- ** minWidth #attr:minWidth#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    TreeViewColumnMinWidthPropertyInfo      ,
#endif
    constructTreeViewColumnMinWidth         ,
    getTreeViewColumnMinWidth               ,
    setTreeViewColumnMinWidth               ,
#if defined(ENABLE_OVERLOADING)
    treeViewColumnMinWidth                  ,
#endif


-- ** reorderable #attr:reorderable#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    TreeViewColumnReorderablePropertyInfo   ,
#endif
    constructTreeViewColumnReorderable      ,
    getTreeViewColumnReorderable            ,
    setTreeViewColumnReorderable            ,
#if defined(ENABLE_OVERLOADING)
    treeViewColumnReorderable               ,
#endif


-- ** resizable #attr:resizable#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    TreeViewColumnResizablePropertyInfo     ,
#endif
    constructTreeViewColumnResizable        ,
    getTreeViewColumnResizable              ,
    setTreeViewColumnResizable              ,
#if defined(ENABLE_OVERLOADING)
    treeViewColumnResizable                 ,
#endif


-- ** sizing #attr:sizing#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    TreeViewColumnSizingPropertyInfo        ,
#endif
    constructTreeViewColumnSizing           ,
    getTreeViewColumnSizing                 ,
    setTreeViewColumnSizing                 ,
#if defined(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 defined(ENABLE_OVERLOADING)
    TreeViewColumnSortColumnIdPropertyInfo  ,
#endif
    constructTreeViewColumnSortColumnId     ,
    getTreeViewColumnSortColumnId           ,
    setTreeViewColumnSortColumnId           ,
#if defined(ENABLE_OVERLOADING)
    treeViewColumnSortColumnId              ,
#endif


-- ** sortIndicator #attr:sortIndicator#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    TreeViewColumnSortIndicatorPropertyInfo ,
#endif
    constructTreeViewColumnSortIndicator    ,
    getTreeViewColumnSortIndicator          ,
    setTreeViewColumnSortIndicator          ,
#if defined(ENABLE_OVERLOADING)
    treeViewColumnSortIndicator             ,
#endif


-- ** sortOrder #attr:sortOrder#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    TreeViewColumnSortOrderPropertyInfo     ,
#endif
    constructTreeViewColumnSortOrder        ,
    getTreeViewColumnSortOrder              ,
    setTreeViewColumnSortOrder              ,
#if defined(ENABLE_OVERLOADING)
    treeViewColumnSortOrder                 ,
#endif


-- ** spacing #attr:spacing#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    TreeViewColumnSpacingPropertyInfo       ,
#endif
    constructTreeViewColumnSpacing          ,
    getTreeViewColumnSpacing                ,
    setTreeViewColumnSpacing                ,
#if defined(ENABLE_OVERLOADING)
    treeViewColumnSpacing                   ,
#endif


-- ** title #attr:title#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    TreeViewColumnTitlePropertyInfo         ,
#endif
    constructTreeViewColumnTitle            ,
    getTreeViewColumnTitle                  ,
    setTreeViewColumnTitle                  ,
#if defined(ENABLE_OVERLOADING)
    treeViewColumnTitle                     ,
#endif


-- ** visible #attr:visible#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    TreeViewColumnVisiblePropertyInfo       ,
#endif
    constructTreeViewColumnVisible          ,
    getTreeViewColumnVisible                ,
    setTreeViewColumnVisible                ,
#if defined(ENABLE_OVERLOADING)
    treeViewColumnVisible                   ,
#endif


-- ** widget #attr:widget#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    TreeViewColumnWidgetPropertyInfo        ,
#endif
    clearTreeViewColumnWidget               ,
    constructTreeViewColumnWidget           ,
    getTreeViewColumnWidget                 ,
    setTreeViewColumnWidget                 ,
#if defined(ENABLE_OVERLOADING)
    treeViewColumnWidget                    ,
#endif


-- ** width #attr:width#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    TreeViewColumnWidthPropertyInfo         ,
#endif
    getTreeViewColumnWidth                  ,
#if defined(ENABLE_OVERLOADING)
    treeViewColumnWidth                     ,
#endif


-- ** xOffset #attr:xOffset#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    TreeViewColumnXOffsetPropertyInfo       ,
#endif
    getTreeViewColumnXOffset                ,
#if defined(ENABLE_OVERLOADING)
    treeViewColumnXOffset                   ,
#endif




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

    C_TreeViewColumnClickedCallback         ,
    TreeViewColumnClickedCallback           ,
#if defined(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.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
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 (SP.ManagedPtr TreeViewColumn)
    deriving (TreeViewColumn -> TreeViewColumn -> Bool
(TreeViewColumn -> TreeViewColumn -> Bool)
-> (TreeViewColumn -> TreeViewColumn -> Bool) -> Eq TreeViewColumn
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TreeViewColumn -> TreeViewColumn -> Bool
$c/= :: TreeViewColumn -> TreeViewColumn -> Bool
== :: TreeViewColumn -> TreeViewColumn -> Bool
$c== :: TreeViewColumn -> TreeViewColumn -> Bool
Eq)

instance SP.ManagedPtrNewtype TreeViewColumn where
    toManagedPtr :: TreeViewColumn -> ManagedPtr TreeViewColumn
toManagedPtr (TreeViewColumn ManagedPtr TreeViewColumn
p) = ManagedPtr TreeViewColumn
p

foreign import ccall "gtk_tree_view_column_get_type"
    c_gtk_tree_view_column_get_type :: IO B.Types.GType

instance B.Types.TypedObject TreeViewColumn where
    glibType :: IO GType
glibType = IO GType
c_gtk_tree_view_column_get_type

instance B.Types.GObject TreeViewColumn

-- | Convert 'TreeViewColumn' to and from 'Data.GI.Base.GValue.GValue' with 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue TreeViewColumn where
    toGValue :: TreeViewColumn -> IO GValue
toGValue TreeViewColumn
o = do
        GType
gtype <- IO GType
c_gtk_tree_view_column_get_type
        TreeViewColumn -> (Ptr TreeViewColumn -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr TreeViewColumn
o (GType
-> (GValue -> Ptr TreeViewColumn -> IO ())
-> Ptr TreeViewColumn
-> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr TreeViewColumn -> IO ()
forall a. GObject a => GValue -> Ptr a -> IO ()
B.GValue.set_object)
        
    fromGValue :: GValue -> IO TreeViewColumn
fromGValue GValue
gv = do
        Ptr TreeViewColumn
ptr <- GValue -> IO (Ptr TreeViewColumn)
forall b. GObject b => GValue -> IO (Ptr b)
B.GValue.get_object GValue
gv :: IO (Ptr TreeViewColumn)
        (ManagedPtr TreeViewColumn -> TreeViewColumn)
-> Ptr TreeViewColumn -> IO TreeViewColumn
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr TreeViewColumn -> TreeViewColumn
TreeViewColumn Ptr TreeViewColumn
ptr
        
    

-- | Type class for types which can be safely cast to `TreeViewColumn`, for instance with `toTreeViewColumn`.
class (SP.GObject o, O.IsDescendantOf TreeViewColumn o) => IsTreeViewColumn o
instance (SP.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 :: o -> m TreeViewColumn
toTreeViewColumn = IO TreeViewColumn -> m TreeViewColumn
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TreeViewColumn -> m TreeViewColumn)
-> (o -> IO TreeViewColumn) -> o -> m TreeViewColumn
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr TreeViewColumn -> TreeViewColumn)
-> o -> IO TreeViewColumn
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
 ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
unsafeCastTo ManagedPtr TreeViewColumn -> TreeViewColumn
TreeViewColumn

#if defined(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 "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    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 @info
#else
    fromLabel _ = O.overloadedMethod @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 :: Maybe (IO ())
noTreeViewColumnClickedCallback = Maybe (IO ())
forall a. Maybe a
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 :: IO () -> m (GClosure C_TreeViewColumnClickedCallback)
genClosure_TreeViewColumnClicked IO ()
cb = IO (GClosure C_TreeViewColumnClickedCallback)
-> m (GClosure C_TreeViewColumnClickedCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_TreeViewColumnClickedCallback)
 -> m (GClosure C_TreeViewColumnClickedCallback))
-> IO (GClosure C_TreeViewColumnClickedCallback)
-> m (GClosure C_TreeViewColumnClickedCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TreeViewColumnClickedCallback
cb' = IO () -> C_TreeViewColumnClickedCallback
wrap_TreeViewColumnClickedCallback IO ()
cb
    C_TreeViewColumnClickedCallback
-> IO (FunPtr C_TreeViewColumnClickedCallback)
mk_TreeViewColumnClickedCallback C_TreeViewColumnClickedCallback
cb' IO (FunPtr C_TreeViewColumnClickedCallback)
-> (FunPtr C_TreeViewColumnClickedCallback
    -> IO (GClosure C_TreeViewColumnClickedCallback))
-> IO (GClosure C_TreeViewColumnClickedCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_TreeViewColumnClickedCallback
-> IO (GClosure C_TreeViewColumnClickedCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


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


-- | Connect a signal handler for the [clicked](#signal: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 :: a -> IO () -> m SignalHandlerId
onTreeViewColumnClicked a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TreeViewColumnClickedCallback
cb' = IO () -> C_TreeViewColumnClickedCallback
wrap_TreeViewColumnClickedCallback IO ()
cb
    FunPtr C_TreeViewColumnClickedCallback
cb'' <- C_TreeViewColumnClickedCallback
-> IO (FunPtr C_TreeViewColumnClickedCallback)
mk_TreeViewColumnClickedCallback C_TreeViewColumnClickedCallback
cb'
    a
-> Text
-> FunPtr C_TreeViewColumnClickedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"clicked" FunPtr C_TreeViewColumnClickedCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [clicked](#signal: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 :: a -> IO () -> m SignalHandlerId
afterTreeViewColumnClicked a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TreeViewColumnClickedCallback
cb' = IO () -> C_TreeViewColumnClickedCallback
wrap_TreeViewColumnClickedCallback IO ()
cb
    FunPtr C_TreeViewColumnClickedCallback
cb'' <- C_TreeViewColumnClickedCallback
-> IO (FunPtr C_TreeViewColumnClickedCallback)
mk_TreeViewColumnClickedCallback C_TreeViewColumnClickedCallback
cb'
    a
-> Text
-> FunPtr C_TreeViewColumnClickedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"clicked" FunPtr C_TreeViewColumnClickedCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


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

#endif

-- 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 :: o -> m Float
getTreeViewColumnAlignment o
obj = IO Float -> m Float
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Float
forall a. GObject a => a -> String -> IO Float
B.Properties.getObjectPropertyFloat o
obj String
"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 :: o -> Float -> m ()
setTreeViewColumnAlignment o
obj Float
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Float -> IO ()
forall a. GObject a => a -> String -> Float -> IO ()
B.Properties.setObjectPropertyFloat o
obj String
"alignment" Float
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, MIO.MonadIO m) => Float -> m (GValueConstruct o)
constructTreeViewColumnAlignment :: Float -> m (GValueConstruct o)
constructTreeViewColumnAlignment Float
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Float -> IO (GValueConstruct o)
forall o. String -> Float -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyFloat String
"alignment" Float
val

#if defined(ENABLE_OVERLOADING)
data TreeViewColumnAlignmentPropertyInfo
instance AttrInfo TreeViewColumnAlignmentPropertyInfo where
    type AttrAllowedOps TreeViewColumnAlignmentPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TreeViewColumnAlignmentPropertyInfo = IsTreeViewColumn
    type AttrSetTypeConstraint TreeViewColumnAlignmentPropertyInfo = (~) Float
    type AttrTransferTypeConstraint TreeViewColumnAlignmentPropertyInfo = (~) Float
    type AttrTransferType TreeViewColumnAlignmentPropertyInfo = Float
    type AttrGetType TreeViewColumnAlignmentPropertyInfo = Float
    type AttrLabel TreeViewColumnAlignmentPropertyInfo = "alignment"
    type AttrOrigin TreeViewColumnAlignmentPropertyInfo = TreeViewColumn
    attrGet = getTreeViewColumnAlignment
    attrSet = setTreeViewColumnAlignment
    attrTransfer _ v = do
        return v
    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 :: o -> m (Maybe CellArea)
getTreeViewColumnCellArea o
obj = IO (Maybe CellArea) -> m (Maybe CellArea)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe CellArea) -> m (Maybe CellArea))
-> IO (Maybe CellArea) -> m (Maybe CellArea)
forall a b. (a -> b) -> a -> b
$ o
-> String
-> (ManagedPtr CellArea -> CellArea)
-> IO (Maybe CellArea)
forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj String
"cell-area" ManagedPtr CellArea -> CellArea
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, MIO.MonadIO m, Gtk.CellArea.IsCellArea a) => a -> m (GValueConstruct o)
constructTreeViewColumnCellArea :: a -> m (GValueConstruct o)
constructTreeViewColumnCellArea a
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe a -> IO (GValueConstruct o)
forall a o.
GObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyObject String
"cell-area" (a -> Maybe a
forall a. a -> Maybe a
P.Just a
val)

#if defined(ENABLE_OVERLOADING)
data TreeViewColumnCellAreaPropertyInfo
instance AttrInfo TreeViewColumnCellAreaPropertyInfo where
    type AttrAllowedOps TreeViewColumnCellAreaPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint TreeViewColumnCellAreaPropertyInfo = IsTreeViewColumn
    type AttrSetTypeConstraint TreeViewColumnCellAreaPropertyInfo = Gtk.CellArea.IsCellArea
    type AttrTransferTypeConstraint TreeViewColumnCellAreaPropertyInfo = Gtk.CellArea.IsCellArea
    type AttrTransferType TreeViewColumnCellAreaPropertyInfo = Gtk.CellArea.CellArea
    type AttrGetType TreeViewColumnCellAreaPropertyInfo = (Maybe Gtk.CellArea.CellArea)
    type AttrLabel TreeViewColumnCellAreaPropertyInfo = "cell-area"
    type AttrOrigin TreeViewColumnCellAreaPropertyInfo = TreeViewColumn
    attrGet = getTreeViewColumnCellArea
    attrSet = undefined
    attrTransfer _ v = do
        unsafeCastTo Gtk.CellArea.CellArea v
    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 :: o -> m Bool
getTreeViewColumnClickable o
obj = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"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 :: o -> Bool -> m ()
setTreeViewColumnClickable o
obj Bool
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"clickable" Bool
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, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructTreeViewColumnClickable :: Bool -> m (GValueConstruct o)
constructTreeViewColumnClickable Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"clickable" Bool
val

#if defined(ENABLE_OVERLOADING)
data TreeViewColumnClickablePropertyInfo
instance AttrInfo TreeViewColumnClickablePropertyInfo where
    type AttrAllowedOps TreeViewColumnClickablePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TreeViewColumnClickablePropertyInfo = IsTreeViewColumn
    type AttrSetTypeConstraint TreeViewColumnClickablePropertyInfo = (~) Bool
    type AttrTransferTypeConstraint TreeViewColumnClickablePropertyInfo = (~) Bool
    type AttrTransferType TreeViewColumnClickablePropertyInfo = Bool
    type AttrGetType TreeViewColumnClickablePropertyInfo = Bool
    type AttrLabel TreeViewColumnClickablePropertyInfo = "clickable"
    type AttrOrigin TreeViewColumnClickablePropertyInfo = TreeViewColumn
    attrGet = getTreeViewColumnClickable
    attrSet = setTreeViewColumnClickable
    attrTransfer _ v = do
        return v
    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 :: o -> m Bool
getTreeViewColumnExpand o
obj = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"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 :: o -> Bool -> m ()
setTreeViewColumnExpand o
obj Bool
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"expand" Bool
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, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructTreeViewColumnExpand :: Bool -> m (GValueConstruct o)
constructTreeViewColumnExpand Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"expand" Bool
val

#if defined(ENABLE_OVERLOADING)
data TreeViewColumnExpandPropertyInfo
instance AttrInfo TreeViewColumnExpandPropertyInfo where
    type AttrAllowedOps TreeViewColumnExpandPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TreeViewColumnExpandPropertyInfo = IsTreeViewColumn
    type AttrSetTypeConstraint TreeViewColumnExpandPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint TreeViewColumnExpandPropertyInfo = (~) Bool
    type AttrTransferType TreeViewColumnExpandPropertyInfo = Bool
    type AttrGetType TreeViewColumnExpandPropertyInfo = Bool
    type AttrLabel TreeViewColumnExpandPropertyInfo = "expand"
    type AttrOrigin TreeViewColumnExpandPropertyInfo = TreeViewColumn
    attrGet = getTreeViewColumnExpand
    attrSet = setTreeViewColumnExpand
    attrTransfer _ v = do
        return v
    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 :: o -> m Int32
getTreeViewColumnFixedWidth o
obj = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Int32
forall a. GObject a => a -> String -> IO Int32
B.Properties.getObjectPropertyInt32 o
obj String
"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 :: o -> Int32 -> m ()
setTreeViewColumnFixedWidth o
obj Int32
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Int32 -> IO ()
forall a. GObject a => a -> String -> Int32 -> IO ()
B.Properties.setObjectPropertyInt32 o
obj String
"fixed-width" Int32
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, MIO.MonadIO m) => Int32 -> m (GValueConstruct o)
constructTreeViewColumnFixedWidth :: Int32 -> m (GValueConstruct o)
constructTreeViewColumnFixedWidth Int32
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Int32 -> IO (GValueConstruct o)
forall o. String -> Int32 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyInt32 String
"fixed-width" Int32
val

#if defined(ENABLE_OVERLOADING)
data TreeViewColumnFixedWidthPropertyInfo
instance AttrInfo TreeViewColumnFixedWidthPropertyInfo where
    type AttrAllowedOps TreeViewColumnFixedWidthPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TreeViewColumnFixedWidthPropertyInfo = IsTreeViewColumn
    type AttrSetTypeConstraint TreeViewColumnFixedWidthPropertyInfo = (~) Int32
    type AttrTransferTypeConstraint TreeViewColumnFixedWidthPropertyInfo = (~) Int32
    type AttrTransferType TreeViewColumnFixedWidthPropertyInfo = Int32
    type AttrGetType TreeViewColumnFixedWidthPropertyInfo = Int32
    type AttrLabel TreeViewColumnFixedWidthPropertyInfo = "fixed-width"
    type AttrOrigin TreeViewColumnFixedWidthPropertyInfo = TreeViewColumn
    attrGet = getTreeViewColumnFixedWidth
    attrSet = setTreeViewColumnFixedWidth
    attrTransfer _ v = do
        return v
    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 :: o -> m Int32
getTreeViewColumnMaxWidth o
obj = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Int32
forall a. GObject a => a -> String -> IO Int32
B.Properties.getObjectPropertyInt32 o
obj String
"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 :: o -> Int32 -> m ()
setTreeViewColumnMaxWidth o
obj Int32
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Int32 -> IO ()
forall a. GObject a => a -> String -> Int32 -> IO ()
B.Properties.setObjectPropertyInt32 o
obj String
"max-width" Int32
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, MIO.MonadIO m) => Int32 -> m (GValueConstruct o)
constructTreeViewColumnMaxWidth :: Int32 -> m (GValueConstruct o)
constructTreeViewColumnMaxWidth Int32
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Int32 -> IO (GValueConstruct o)
forall o. String -> Int32 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyInt32 String
"max-width" Int32
val

#if defined(ENABLE_OVERLOADING)
data TreeViewColumnMaxWidthPropertyInfo
instance AttrInfo TreeViewColumnMaxWidthPropertyInfo where
    type AttrAllowedOps TreeViewColumnMaxWidthPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TreeViewColumnMaxWidthPropertyInfo = IsTreeViewColumn
    type AttrSetTypeConstraint TreeViewColumnMaxWidthPropertyInfo = (~) Int32
    type AttrTransferTypeConstraint TreeViewColumnMaxWidthPropertyInfo = (~) Int32
    type AttrTransferType TreeViewColumnMaxWidthPropertyInfo = Int32
    type AttrGetType TreeViewColumnMaxWidthPropertyInfo = Int32
    type AttrLabel TreeViewColumnMaxWidthPropertyInfo = "max-width"
    type AttrOrigin TreeViewColumnMaxWidthPropertyInfo = TreeViewColumn
    attrGet = getTreeViewColumnMaxWidth
    attrSet = setTreeViewColumnMaxWidth
    attrTransfer _ v = do
        return v
    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 :: o -> m Int32
getTreeViewColumnMinWidth o
obj = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Int32
forall a. GObject a => a -> String -> IO Int32
B.Properties.getObjectPropertyInt32 o
obj String
"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 :: o -> Int32 -> m ()
setTreeViewColumnMinWidth o
obj Int32
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Int32 -> IO ()
forall a. GObject a => a -> String -> Int32 -> IO ()
B.Properties.setObjectPropertyInt32 o
obj String
"min-width" Int32
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, MIO.MonadIO m) => Int32 -> m (GValueConstruct o)
constructTreeViewColumnMinWidth :: Int32 -> m (GValueConstruct o)
constructTreeViewColumnMinWidth Int32
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Int32 -> IO (GValueConstruct o)
forall o. String -> Int32 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyInt32 String
"min-width" Int32
val

#if defined(ENABLE_OVERLOADING)
data TreeViewColumnMinWidthPropertyInfo
instance AttrInfo TreeViewColumnMinWidthPropertyInfo where
    type AttrAllowedOps TreeViewColumnMinWidthPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TreeViewColumnMinWidthPropertyInfo = IsTreeViewColumn
    type AttrSetTypeConstraint TreeViewColumnMinWidthPropertyInfo = (~) Int32
    type AttrTransferTypeConstraint TreeViewColumnMinWidthPropertyInfo = (~) Int32
    type AttrTransferType TreeViewColumnMinWidthPropertyInfo = Int32
    type AttrGetType TreeViewColumnMinWidthPropertyInfo = Int32
    type AttrLabel TreeViewColumnMinWidthPropertyInfo = "min-width"
    type AttrOrigin TreeViewColumnMinWidthPropertyInfo = TreeViewColumn
    attrGet = getTreeViewColumnMinWidth
    attrSet = setTreeViewColumnMinWidth
    attrTransfer _ v = do
        return v
    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 :: o -> m Bool
getTreeViewColumnReorderable o
obj = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"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 :: o -> Bool -> m ()
setTreeViewColumnReorderable o
obj Bool
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"reorderable" Bool
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, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructTreeViewColumnReorderable :: Bool -> m (GValueConstruct o)
constructTreeViewColumnReorderable Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"reorderable" Bool
val

#if defined(ENABLE_OVERLOADING)
data TreeViewColumnReorderablePropertyInfo
instance AttrInfo TreeViewColumnReorderablePropertyInfo where
    type AttrAllowedOps TreeViewColumnReorderablePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TreeViewColumnReorderablePropertyInfo = IsTreeViewColumn
    type AttrSetTypeConstraint TreeViewColumnReorderablePropertyInfo = (~) Bool
    type AttrTransferTypeConstraint TreeViewColumnReorderablePropertyInfo = (~) Bool
    type AttrTransferType TreeViewColumnReorderablePropertyInfo = Bool
    type AttrGetType TreeViewColumnReorderablePropertyInfo = Bool
    type AttrLabel TreeViewColumnReorderablePropertyInfo = "reorderable"
    type AttrOrigin TreeViewColumnReorderablePropertyInfo = TreeViewColumn
    attrGet = getTreeViewColumnReorderable
    attrSet = setTreeViewColumnReorderable
    attrTransfer _ v = do
        return v
    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 :: o -> m Bool
getTreeViewColumnResizable o
obj = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"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 :: o -> Bool -> m ()
setTreeViewColumnResizable o
obj Bool
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"resizable" Bool
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, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructTreeViewColumnResizable :: Bool -> m (GValueConstruct o)
constructTreeViewColumnResizable Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"resizable" Bool
val

#if defined(ENABLE_OVERLOADING)
data TreeViewColumnResizablePropertyInfo
instance AttrInfo TreeViewColumnResizablePropertyInfo where
    type AttrAllowedOps TreeViewColumnResizablePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TreeViewColumnResizablePropertyInfo = IsTreeViewColumn
    type AttrSetTypeConstraint TreeViewColumnResizablePropertyInfo = (~) Bool
    type AttrTransferTypeConstraint TreeViewColumnResizablePropertyInfo = (~) Bool
    type AttrTransferType TreeViewColumnResizablePropertyInfo = Bool
    type AttrGetType TreeViewColumnResizablePropertyInfo = Bool
    type AttrLabel TreeViewColumnResizablePropertyInfo = "resizable"
    type AttrOrigin TreeViewColumnResizablePropertyInfo = TreeViewColumn
    attrGet = getTreeViewColumnResizable
    attrSet = setTreeViewColumnResizable
    attrTransfer _ v = do
        return v
    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 :: o -> m TreeViewColumnSizing
getTreeViewColumnSizing o
obj = IO TreeViewColumnSizing -> m TreeViewColumnSizing
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TreeViewColumnSizing -> m TreeViewColumnSizing)
-> IO TreeViewColumnSizing -> m TreeViewColumnSizing
forall a b. (a -> b) -> a -> b
$ o -> String -> IO TreeViewColumnSizing
forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
B.Properties.getObjectPropertyEnum o
obj String
"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 :: o -> TreeViewColumnSizing -> m ()
setTreeViewColumnSizing o
obj TreeViewColumnSizing
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> TreeViewColumnSizing -> IO ()
forall a b.
(GObject a, Enum b, BoxedEnum b) =>
a -> String -> b -> IO ()
B.Properties.setObjectPropertyEnum o
obj String
"sizing" TreeViewColumnSizing
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, MIO.MonadIO m) => Gtk.Enums.TreeViewColumnSizing -> m (GValueConstruct o)
constructTreeViewColumnSizing :: TreeViewColumnSizing -> m (GValueConstruct o)
constructTreeViewColumnSizing TreeViewColumnSizing
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> TreeViewColumnSizing -> IO (GValueConstruct o)
forall a o.
(Enum a, BoxedEnum a) =>
String -> a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyEnum String
"sizing" TreeViewColumnSizing
val

#if defined(ENABLE_OVERLOADING)
data TreeViewColumnSizingPropertyInfo
instance AttrInfo TreeViewColumnSizingPropertyInfo where
    type AttrAllowedOps TreeViewColumnSizingPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TreeViewColumnSizingPropertyInfo = IsTreeViewColumn
    type AttrSetTypeConstraint TreeViewColumnSizingPropertyInfo = (~) Gtk.Enums.TreeViewColumnSizing
    type AttrTransferTypeConstraint TreeViewColumnSizingPropertyInfo = (~) Gtk.Enums.TreeViewColumnSizing
    type AttrTransferType TreeViewColumnSizingPropertyInfo = Gtk.Enums.TreeViewColumnSizing
    type AttrGetType TreeViewColumnSizingPropertyInfo = Gtk.Enums.TreeViewColumnSizing
    type AttrLabel TreeViewColumnSizingPropertyInfo = "sizing"
    type AttrOrigin TreeViewColumnSizingPropertyInfo = TreeViewColumn
    attrGet = getTreeViewColumnSizing
    attrSet = setTreeViewColumnSizing
    attrTransfer _ v = do
        return v
    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 :: o -> m Int32
getTreeViewColumnSortColumnId o
obj = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Int32
forall a. GObject a => a -> String -> IO Int32
B.Properties.getObjectPropertyInt32 o
obj String
"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 :: o -> Int32 -> m ()
setTreeViewColumnSortColumnId o
obj Int32
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Int32 -> IO ()
forall a. GObject a => a -> String -> Int32 -> IO ()
B.Properties.setObjectPropertyInt32 o
obj String
"sort-column-id" Int32
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, MIO.MonadIO m) => Int32 -> m (GValueConstruct o)
constructTreeViewColumnSortColumnId :: Int32 -> m (GValueConstruct o)
constructTreeViewColumnSortColumnId Int32
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Int32 -> IO (GValueConstruct o)
forall o. String -> Int32 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyInt32 String
"sort-column-id" Int32
val

#if defined(ENABLE_OVERLOADING)
data TreeViewColumnSortColumnIdPropertyInfo
instance AttrInfo TreeViewColumnSortColumnIdPropertyInfo where
    type AttrAllowedOps TreeViewColumnSortColumnIdPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TreeViewColumnSortColumnIdPropertyInfo = IsTreeViewColumn
    type AttrSetTypeConstraint TreeViewColumnSortColumnIdPropertyInfo = (~) Int32
    type AttrTransferTypeConstraint TreeViewColumnSortColumnIdPropertyInfo = (~) Int32
    type AttrTransferType TreeViewColumnSortColumnIdPropertyInfo = Int32
    type AttrGetType TreeViewColumnSortColumnIdPropertyInfo = Int32
    type AttrLabel TreeViewColumnSortColumnIdPropertyInfo = "sort-column-id"
    type AttrOrigin TreeViewColumnSortColumnIdPropertyInfo = TreeViewColumn
    attrGet = getTreeViewColumnSortColumnId
    attrSet = setTreeViewColumnSortColumnId
    attrTransfer _ v = do
        return v
    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 :: o -> m Bool
getTreeViewColumnSortIndicator o
obj = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"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 :: o -> Bool -> m ()
setTreeViewColumnSortIndicator o
obj Bool
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"sort-indicator" Bool
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, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructTreeViewColumnSortIndicator :: Bool -> m (GValueConstruct o)
constructTreeViewColumnSortIndicator Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"sort-indicator" Bool
val

#if defined(ENABLE_OVERLOADING)
data TreeViewColumnSortIndicatorPropertyInfo
instance AttrInfo TreeViewColumnSortIndicatorPropertyInfo where
    type AttrAllowedOps TreeViewColumnSortIndicatorPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TreeViewColumnSortIndicatorPropertyInfo = IsTreeViewColumn
    type AttrSetTypeConstraint TreeViewColumnSortIndicatorPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint TreeViewColumnSortIndicatorPropertyInfo = (~) Bool
    type AttrTransferType TreeViewColumnSortIndicatorPropertyInfo = Bool
    type AttrGetType TreeViewColumnSortIndicatorPropertyInfo = Bool
    type AttrLabel TreeViewColumnSortIndicatorPropertyInfo = "sort-indicator"
    type AttrOrigin TreeViewColumnSortIndicatorPropertyInfo = TreeViewColumn
    attrGet = getTreeViewColumnSortIndicator
    attrSet = setTreeViewColumnSortIndicator
    attrTransfer _ v = do
        return v
    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 :: o -> m SortType
getTreeViewColumnSortOrder o
obj = IO SortType -> m SortType
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SortType -> m SortType) -> IO SortType -> m SortType
forall a b. (a -> b) -> a -> b
$ o -> String -> IO SortType
forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
B.Properties.getObjectPropertyEnum o
obj String
"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 :: o -> SortType -> m ()
setTreeViewColumnSortOrder o
obj SortType
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> SortType -> IO ()
forall a b.
(GObject a, Enum b, BoxedEnum b) =>
a -> String -> b -> IO ()
B.Properties.setObjectPropertyEnum o
obj String
"sort-order" SortType
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, MIO.MonadIO m) => Gtk.Enums.SortType -> m (GValueConstruct o)
constructTreeViewColumnSortOrder :: SortType -> m (GValueConstruct o)
constructTreeViewColumnSortOrder SortType
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> SortType -> IO (GValueConstruct o)
forall a o.
(Enum a, BoxedEnum a) =>
String -> a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyEnum String
"sort-order" SortType
val

#if defined(ENABLE_OVERLOADING)
data TreeViewColumnSortOrderPropertyInfo
instance AttrInfo TreeViewColumnSortOrderPropertyInfo where
    type AttrAllowedOps TreeViewColumnSortOrderPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TreeViewColumnSortOrderPropertyInfo = IsTreeViewColumn
    type AttrSetTypeConstraint TreeViewColumnSortOrderPropertyInfo = (~) Gtk.Enums.SortType
    type AttrTransferTypeConstraint TreeViewColumnSortOrderPropertyInfo = (~) Gtk.Enums.SortType
    type AttrTransferType TreeViewColumnSortOrderPropertyInfo = Gtk.Enums.SortType
    type AttrGetType TreeViewColumnSortOrderPropertyInfo = Gtk.Enums.SortType
    type AttrLabel TreeViewColumnSortOrderPropertyInfo = "sort-order"
    type AttrOrigin TreeViewColumnSortOrderPropertyInfo = TreeViewColumn
    attrGet = getTreeViewColumnSortOrder
    attrSet = setTreeViewColumnSortOrder
    attrTransfer _ v = do
        return v
    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 :: o -> m Int32
getTreeViewColumnSpacing o
obj = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Int32
forall a. GObject a => a -> String -> IO Int32
B.Properties.getObjectPropertyInt32 o
obj String
"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 :: o -> Int32 -> m ()
setTreeViewColumnSpacing o
obj Int32
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Int32 -> IO ()
forall a. GObject a => a -> String -> Int32 -> IO ()
B.Properties.setObjectPropertyInt32 o
obj String
"spacing" Int32
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, MIO.MonadIO m) => Int32 -> m (GValueConstruct o)
constructTreeViewColumnSpacing :: Int32 -> m (GValueConstruct o)
constructTreeViewColumnSpacing Int32
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Int32 -> IO (GValueConstruct o)
forall o. String -> Int32 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyInt32 String
"spacing" Int32
val

#if defined(ENABLE_OVERLOADING)
data TreeViewColumnSpacingPropertyInfo
instance AttrInfo TreeViewColumnSpacingPropertyInfo where
    type AttrAllowedOps TreeViewColumnSpacingPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TreeViewColumnSpacingPropertyInfo = IsTreeViewColumn
    type AttrSetTypeConstraint TreeViewColumnSpacingPropertyInfo = (~) Int32
    type AttrTransferTypeConstraint TreeViewColumnSpacingPropertyInfo = (~) Int32
    type AttrTransferType TreeViewColumnSpacingPropertyInfo = Int32
    type AttrGetType TreeViewColumnSpacingPropertyInfo = Int32
    type AttrLabel TreeViewColumnSpacingPropertyInfo = "spacing"
    type AttrOrigin TreeViewColumnSpacingPropertyInfo = TreeViewColumn
    attrGet = getTreeViewColumnSpacing
    attrSet = setTreeViewColumnSpacing
    attrTransfer _ v = do
        return v
    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 :: o -> m Text
getTreeViewColumnTitle o
obj = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ Text -> IO (Maybe Text) -> IO Text
forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing Text
"getTreeViewColumnTitle" (IO (Maybe Text) -> IO Text) -> IO (Maybe Text) -> IO Text
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe Text)
forall a. GObject a => a -> String -> IO (Maybe Text)
B.Properties.getObjectPropertyString o
obj String
"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 :: o -> Text -> m ()
setTreeViewColumnTitle o
obj Text
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"title" (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
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, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
constructTreeViewColumnTitle :: Text -> m (GValueConstruct o)
constructTreeViewColumnTitle Text
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe Text -> IO (GValueConstruct o)
forall o. String -> Maybe Text -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyString String
"title" (Text -> Maybe Text
forall a. a -> Maybe a
P.Just Text
val)

#if defined(ENABLE_OVERLOADING)
data TreeViewColumnTitlePropertyInfo
instance AttrInfo TreeViewColumnTitlePropertyInfo where
    type AttrAllowedOps TreeViewColumnTitlePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TreeViewColumnTitlePropertyInfo = IsTreeViewColumn
    type AttrSetTypeConstraint TreeViewColumnTitlePropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint TreeViewColumnTitlePropertyInfo = (~) T.Text
    type AttrTransferType TreeViewColumnTitlePropertyInfo = T.Text
    type AttrGetType TreeViewColumnTitlePropertyInfo = T.Text
    type AttrLabel TreeViewColumnTitlePropertyInfo = "title"
    type AttrOrigin TreeViewColumnTitlePropertyInfo = TreeViewColumn
    attrGet = getTreeViewColumnTitle
    attrSet = setTreeViewColumnTitle
    attrTransfer _ v = do
        return v
    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 :: o -> m Bool
getTreeViewColumnVisible o
obj = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"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 :: o -> Bool -> m ()
setTreeViewColumnVisible o
obj Bool
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"visible" Bool
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, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructTreeViewColumnVisible :: Bool -> m (GValueConstruct o)
constructTreeViewColumnVisible Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"visible" Bool
val

#if defined(ENABLE_OVERLOADING)
data TreeViewColumnVisiblePropertyInfo
instance AttrInfo TreeViewColumnVisiblePropertyInfo where
    type AttrAllowedOps TreeViewColumnVisiblePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TreeViewColumnVisiblePropertyInfo = IsTreeViewColumn
    type AttrSetTypeConstraint TreeViewColumnVisiblePropertyInfo = (~) Bool
    type AttrTransferTypeConstraint TreeViewColumnVisiblePropertyInfo = (~) Bool
    type AttrTransferType TreeViewColumnVisiblePropertyInfo = Bool
    type AttrGetType TreeViewColumnVisiblePropertyInfo = Bool
    type AttrLabel TreeViewColumnVisiblePropertyInfo = "visible"
    type AttrOrigin TreeViewColumnVisiblePropertyInfo = TreeViewColumn
    attrGet = getTreeViewColumnVisible
    attrSet = setTreeViewColumnVisible
    attrTransfer _ v = do
        return v
    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 :: o -> m (Maybe Widget)
getTreeViewColumnWidget o
obj = IO (Maybe Widget) -> m (Maybe Widget)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Widget) -> m (Maybe Widget))
-> IO (Maybe Widget) -> m (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ o -> String -> (ManagedPtr Widget -> Widget) -> IO (Maybe Widget)
forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj String
"widget" ManagedPtr Widget -> 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 :: o -> a -> m ()
setTreeViewColumnWidget o
obj a
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe a -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"widget" (a -> Maybe a
forall a. a -> Maybe a
Just a
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, MIO.MonadIO m, Gtk.Widget.IsWidget a) => a -> m (GValueConstruct o)
constructTreeViewColumnWidget :: a -> m (GValueConstruct o)
constructTreeViewColumnWidget a
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe a -> IO (GValueConstruct o)
forall a o.
GObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyObject String
"widget" (a -> Maybe a
forall a. a -> Maybe a
P.Just a
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 :: o -> m ()
clearTreeViewColumnWidget o
obj = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Widget -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"widget" (Maybe Widget
forall a. Maybe a
Nothing :: Maybe Gtk.Widget.Widget)

#if defined(ENABLE_OVERLOADING)
data TreeViewColumnWidgetPropertyInfo
instance AttrInfo TreeViewColumnWidgetPropertyInfo where
    type AttrAllowedOps TreeViewColumnWidgetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint TreeViewColumnWidgetPropertyInfo = IsTreeViewColumn
    type AttrSetTypeConstraint TreeViewColumnWidgetPropertyInfo = Gtk.Widget.IsWidget
    type AttrTransferTypeConstraint TreeViewColumnWidgetPropertyInfo = Gtk.Widget.IsWidget
    type AttrTransferType TreeViewColumnWidgetPropertyInfo = Gtk.Widget.Widget
    type AttrGetType TreeViewColumnWidgetPropertyInfo = (Maybe Gtk.Widget.Widget)
    type AttrLabel TreeViewColumnWidgetPropertyInfo = "widget"
    type AttrOrigin TreeViewColumnWidgetPropertyInfo = TreeViewColumn
    attrGet = getTreeViewColumnWidget
    attrSet = setTreeViewColumnWidget
    attrTransfer _ v = do
        unsafeCastTo Gtk.Widget.Widget v
    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 :: o -> m Int32
getTreeViewColumnWidth o
obj = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Int32
forall a. GObject a => a -> String -> IO Int32
B.Properties.getObjectPropertyInt32 o
obj String
"width"

#if defined(ENABLE_OVERLOADING)
data TreeViewColumnWidthPropertyInfo
instance AttrInfo TreeViewColumnWidthPropertyInfo where
    type AttrAllowedOps TreeViewColumnWidthPropertyInfo = '[ 'AttrGet]
    type AttrBaseTypeConstraint TreeViewColumnWidthPropertyInfo = IsTreeViewColumn
    type AttrSetTypeConstraint TreeViewColumnWidthPropertyInfo = (~) ()
    type AttrTransferTypeConstraint TreeViewColumnWidthPropertyInfo = (~) ()
    type AttrTransferType TreeViewColumnWidthPropertyInfo = ()
    type AttrGetType TreeViewColumnWidthPropertyInfo = Int32
    type AttrLabel TreeViewColumnWidthPropertyInfo = "width"
    type AttrOrigin TreeViewColumnWidthPropertyInfo = TreeViewColumn
    attrGet = getTreeViewColumnWidth
    attrSet = undefined
    attrTransfer _ = 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 :: o -> m Int32
getTreeViewColumnXOffset o
obj = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Int32
forall a. GObject a => a -> String -> IO Int32
B.Properties.getObjectPropertyInt32 o
obj String
"x-offset"

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

#if defined(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 defined(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 defined(ENABLE_OVERLOADING)
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 t'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'.
treeViewColumnNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m TreeViewColumn
    -- ^ __Returns:__ A newly created t'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'.
treeViewColumnNew :: m TreeViewColumn
treeViewColumnNew  = IO TreeViewColumn -> m TreeViewColumn
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TreeViewColumn -> m TreeViewColumn)
-> IO TreeViewColumn -> m TreeViewColumn
forall a b. (a -> b) -> a -> b
$ do
    Ptr TreeViewColumn
result <- IO (Ptr TreeViewColumn)
gtk_tree_view_column_new
    Text -> Ptr TreeViewColumn -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"treeViewColumnNew" Ptr TreeViewColumn
result
    TreeViewColumn
result' <- ((ManagedPtr TreeViewColumn -> TreeViewColumn)
-> Ptr TreeViewColumn -> IO TreeViewColumn
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr TreeViewColumn -> TreeViewColumn
TreeViewColumn) Ptr TreeViewColumn
result
    TreeViewColumn -> IO TreeViewColumn
forall (m :: * -> *) a. Monad m => a -> m a
return TreeViewColumn
result'

#if defined(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 t'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 t'GI.Gtk.Objects.CellArea.CellArea' that the newly created column should use to layout cells.
    -> m TreeViewColumn
    -- ^ __Returns:__ A newly created t'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'.
treeViewColumnNewWithArea :: a -> m TreeViewColumn
treeViewColumnNewWithArea a
area = IO TreeViewColumn -> m TreeViewColumn
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TreeViewColumn -> m TreeViewColumn)
-> IO TreeViewColumn -> m TreeViewColumn
forall a b. (a -> b) -> a -> b
$ do
    Ptr CellArea
area' <- a -> IO (Ptr CellArea)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
area
    Ptr TreeViewColumn
result <- Ptr CellArea -> IO (Ptr TreeViewColumn)
gtk_tree_view_column_new_with_area Ptr CellArea
area'
    Text -> Ptr TreeViewColumn -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"treeViewColumnNewWithArea" Ptr TreeViewColumn
result
    TreeViewColumn
result' <- ((ManagedPtr TreeViewColumn -> TreeViewColumn)
-> Ptr TreeViewColumn -> IO TreeViewColumn
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr TreeViewColumn -> TreeViewColumn
TreeViewColumn) Ptr TreeViewColumn
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
area
    TreeViewColumn -> IO TreeViewColumn
forall (m :: * -> *) a. Monad m => a -> m a
return TreeViewColumn
result'

#if defined(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 t'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 t'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'.
    -> b
    -- ^ /@cellRenderer@/: the t'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 :: a -> b -> Text -> Int32 -> m ()
treeViewColumnAddAttribute a
treeColumn b
cellRenderer Text
attribute Int32
column = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr TreeViewColumn
treeColumn' <- a -> IO (Ptr TreeViewColumn)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
treeColumn
    Ptr CellRenderer
cellRenderer' <- b -> IO (Ptr CellRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
cellRenderer
    CString
attribute' <- Text -> IO CString
textToCString Text
attribute
    Ptr TreeViewColumn -> Ptr CellRenderer -> CString -> Int32 -> IO ()
gtk_tree_view_column_add_attribute Ptr TreeViewColumn
treeColumn' Ptr CellRenderer
cellRenderer' CString
attribute' Int32
column
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
treeColumn
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
cellRenderer
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
attribute'
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(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
-- 'P.False' is returned.
treeViewColumnCellGetPosition ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a, Gtk.CellRenderer.IsCellRenderer b) =>
    a
    -- ^ /@treeColumn@/: a t'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'
    -> b
    -- ^ /@cellRenderer@/: a t'GI.Gtk.Objects.CellRenderer.CellRenderer'
    -> m ((Bool, Int32, Int32))
    -- ^ __Returns:__ 'P.True' if /@cell@/ belongs to /@treeColumn@/.
treeViewColumnCellGetPosition :: a -> b -> m (Bool, Int32, Int32)
treeViewColumnCellGetPosition a
treeColumn b
cellRenderer = IO (Bool, Int32, Int32) -> m (Bool, Int32, Int32)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Int32, Int32) -> m (Bool, Int32, Int32))
-> IO (Bool, Int32, Int32) -> m (Bool, Int32, Int32)
forall a b. (a -> b) -> a -> b
$ do
    Ptr TreeViewColumn
treeColumn' <- a -> IO (Ptr TreeViewColumn)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
treeColumn
    Ptr CellRenderer
cellRenderer' <- b -> IO (Ptr CellRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
cellRenderer
    Ptr Int32
xOffset <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
    Ptr Int32
width <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
    CInt
result <- Ptr TreeViewColumn
-> Ptr CellRenderer -> Ptr Int32 -> Ptr Int32 -> IO CInt
gtk_tree_view_column_cell_get_position Ptr TreeViewColumn
treeColumn' Ptr CellRenderer
cellRenderer' Ptr Int32
xOffset Ptr Int32
width
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    Int32
xOffset' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
xOffset
    Int32
width' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
width
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
treeColumn
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
cellRenderer
    Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
xOffset
    Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
width
    (Bool, Int32, Int32) -> IO (Bool, Int32, Int32)
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Int32
xOffset', Int32
width')

#if defined(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 t'GI.Gtk.Objects.TreeView.TreeView'.
treeViewColumnCellGetSize ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a
    -- ^ /@treeColumn@/: A t'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'.
    -> Maybe (Gdk.Rectangle.Rectangle)
    -- ^ /@cellArea@/: The area a cell in the column will be allocated, or 'P.Nothing'
    -> m ((Int32, Int32, Int32, Int32))
treeViewColumnCellGetSize :: a -> Maybe Rectangle -> m (Int32, Int32, Int32, Int32)
treeViewColumnCellGetSize a
treeColumn Maybe Rectangle
cellArea = IO (Int32, Int32, Int32, Int32) -> m (Int32, Int32, Int32, Int32)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Int32, Int32, Int32, Int32) -> m (Int32, Int32, Int32, Int32))
-> IO (Int32, Int32, Int32, Int32)
-> m (Int32, Int32, Int32, Int32)
forall a b. (a -> b) -> a -> b
$ do
    Ptr TreeViewColumn
treeColumn' <- a -> IO (Ptr TreeViewColumn)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
treeColumn
    Ptr Rectangle
maybeCellArea <- case Maybe Rectangle
cellArea of
        Maybe Rectangle
Nothing -> Ptr Rectangle -> IO (Ptr Rectangle)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Rectangle
forall a. Ptr a
nullPtr
        Just Rectangle
jCellArea -> do
            Ptr Rectangle
jCellArea' <- Rectangle -> IO (Ptr Rectangle)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rectangle
jCellArea
            Ptr Rectangle -> IO (Ptr Rectangle)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Rectangle
jCellArea'
    Ptr Int32
xOffset <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
    Ptr Int32
yOffset <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
    Ptr Int32
width <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
    Ptr Int32
height <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
    Ptr TreeViewColumn
-> Ptr Rectangle
-> Ptr Int32
-> Ptr Int32
-> Ptr Int32
-> Ptr Int32
-> IO ()
gtk_tree_view_column_cell_get_size Ptr TreeViewColumn
treeColumn' Ptr Rectangle
maybeCellArea Ptr Int32
xOffset Ptr Int32
yOffset Ptr Int32
width Ptr Int32
height
    Int32
xOffset' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
xOffset
    Int32
yOffset' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
yOffset
    Int32
width' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
width
    Int32
height' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
height
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
treeColumn
    Maybe Rectangle -> (Rectangle -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe Rectangle
cellArea Rectangle -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
xOffset
    Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
yOffset
    Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
width
    Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
height
    (Int32, Int32, Int32, Int32) -> IO (Int32, Int32, Int32, Int32)
forall (m :: * -> *) a. Monad m => a -> m a
return (Int32
xOffset', Int32
yOffset', Int32
width', Int32
height')

#if defined(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 'P.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 t'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'
    -> m Bool
    -- ^ __Returns:__ 'P.True', if any of the cells packed into the /@treeColumn@/ are currently visible
treeViewColumnCellIsVisible :: a -> m Bool
treeViewColumnCellIsVisible a
treeColumn = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr TreeViewColumn
treeColumn' <- a -> IO (Ptr TreeViewColumn)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
treeColumn
    CInt
result <- Ptr TreeViewColumn -> IO CInt
gtk_tree_view_column_cell_is_visible Ptr TreeViewColumn
treeColumn'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
treeColumn
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(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 t'GI.Gtk.Objects.TreeView.TreeView'.
treeViewColumnCellSetCellData ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a, Gtk.TreeModel.IsTreeModel b) =>
    a
    -- ^ /@treeColumn@/: A t'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'.
    -> b
    -- ^ /@treeModel@/: The t'GI.Gtk.Interfaces.TreeModel.TreeModel' to to get the cell renderers attributes from.
    -> Gtk.TreeIter.TreeIter
    -- ^ /@iter@/: The t'GI.Gtk.Structs.TreeIter.TreeIter' to to get the cell renderer’s attributes from.
    -> Bool
    -- ^ /@isExpander@/: 'P.True', if the row has children
    -> Bool
    -- ^ /@isExpanded@/: 'P.True', if the row has visible children
    -> m ()
treeViewColumnCellSetCellData :: a -> b -> TreeIter -> Bool -> Bool -> m ()
treeViewColumnCellSetCellData a
treeColumn b
treeModel TreeIter
iter Bool
isExpander Bool
isExpanded = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr TreeViewColumn
treeColumn' <- a -> IO (Ptr TreeViewColumn)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
treeColumn
    Ptr TreeModel
treeModel' <- b -> IO (Ptr TreeModel)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
treeModel
    Ptr TreeIter
iter' <- TreeIter -> IO (Ptr TreeIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TreeIter
iter
    let isExpander' :: CInt
isExpander' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
isExpander
    let isExpanded' :: CInt
isExpanded' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
isExpanded
    Ptr TreeViewColumn
-> Ptr TreeModel -> Ptr TreeIter -> CInt -> CInt -> IO ()
gtk_tree_view_column_cell_set_cell_data Ptr TreeViewColumn
treeColumn' Ptr TreeModel
treeModel' Ptr TreeIter
iter' CInt
isExpander' CInt
isExpanded'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
treeColumn
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
treeModel
    TreeIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TreeIter
iter
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(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 t'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'
    -> m ()
treeViewColumnClear :: a -> m ()
treeViewColumnClear a
treeColumn = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr TreeViewColumn
treeColumn' <- a -> IO (Ptr TreeViewColumn)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
treeColumn
    Ptr TreeViewColumn -> IO ()
gtk_tree_view_column_clear Ptr TreeViewColumn
treeColumn'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
treeColumn
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(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 t'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'
    -> b
    -- ^ /@cellRenderer@/: a t'GI.Gtk.Objects.CellRenderer.CellRenderer' to clear the attribute mapping on.
    -> m ()
treeViewColumnClearAttributes :: a -> b -> m ()
treeViewColumnClearAttributes a
treeColumn b
cellRenderer = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr TreeViewColumn
treeColumn' <- a -> IO (Ptr TreeViewColumn)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
treeColumn
    Ptr CellRenderer
cellRenderer' <- b -> IO (Ptr CellRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
cellRenderer
    Ptr TreeViewColumn -> Ptr CellRenderer -> IO ()
gtk_tree_view_column_clear_attributes Ptr TreeViewColumn
treeColumn' Ptr CellRenderer
cellRenderer'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
treeColumn
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
cellRenderer
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(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 t'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'
    -> m ()
treeViewColumnClicked :: a -> m ()
treeViewColumnClicked a
treeColumn = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr TreeViewColumn
treeColumn' <- a -> IO (Ptr TreeViewColumn)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
treeColumn
    Ptr TreeViewColumn -> IO ()
gtk_tree_view_column_clicked Ptr TreeViewColumn
treeColumn'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
treeColumn
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(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 t'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'
    -> b
    -- ^ /@cell@/: A t'GI.Gtk.Objects.CellRenderer.CellRenderer'
    -> m ()
treeViewColumnFocusCell :: a -> b -> m ()
treeViewColumnFocusCell a
treeColumn b
cell = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr TreeViewColumn
treeColumn' <- a -> IO (Ptr TreeViewColumn)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
treeColumn
    Ptr CellRenderer
cell' <- b -> IO (Ptr CellRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
cell
    Ptr TreeViewColumn -> Ptr CellRenderer -> IO ()
gtk_tree_view_column_focus_cell Ptr TreeViewColumn
treeColumn' Ptr CellRenderer
cell'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
treeColumn
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
cell
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(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 t'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'.
    -> m Float
    -- ^ __Returns:__ The current alignent of /@treeColumn@/.
treeViewColumnGetAlignment :: a -> m Float
treeViewColumnGetAlignment a
treeColumn = IO Float -> m Float
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ do
    Ptr TreeViewColumn
treeColumn' <- a -> IO (Ptr TreeViewColumn)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
treeColumn
    CFloat
result <- Ptr TreeViewColumn -> IO CFloat
gtk_tree_view_column_get_alignment Ptr TreeViewColumn
treeColumn'
    let result' :: Float
result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
treeColumn
    Float -> IO Float
forall (m :: * -> *) a. Monad m => a -> m a
return Float
result'

#if defined(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 t'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'
    -> m Gtk.Widget.Widget
    -- ^ __Returns:__ The button for the column header.
treeViewColumnGetButton :: a -> m Widget
treeViewColumnGetButton a
treeColumn = IO Widget -> m Widget
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Widget -> m Widget) -> IO Widget -> m Widget
forall a b. (a -> b) -> a -> b
$ do
    Ptr TreeViewColumn
treeColumn' <- a -> IO (Ptr TreeViewColumn)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
treeColumn
    Ptr Widget
result <- Ptr TreeViewColumn -> IO (Ptr Widget)
gtk_tree_view_column_get_button Ptr TreeViewColumn
treeColumn'
    Text -> Ptr Widget -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"treeViewColumnGetButton" Ptr Widget
result
    Widget
result' <- ((ManagedPtr Widget -> Widget) -> Ptr Widget -> IO Widget
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Widget -> Widget
Gtk.Widget.Widget) Ptr Widget
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
treeColumn
    Widget -> IO Widget
forall (m :: * -> *) a. Monad m => a -> m a
return Widget
result'

#if defined(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 'P.True' if the user can click on the header for the column.
treeViewColumnGetClickable ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a
    -- ^ /@treeColumn@/: a t'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if user can click the column header.
treeViewColumnGetClickable :: a -> m Bool
treeViewColumnGetClickable a
treeColumn = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr TreeViewColumn
treeColumn' <- a -> IO (Ptr TreeViewColumn)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
treeColumn
    CInt
result <- Ptr TreeViewColumn -> IO CInt
gtk_tree_view_column_get_clickable Ptr TreeViewColumn
treeColumn'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
treeColumn
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(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 'P.True' if the column expands to fill available space.
-- 
-- /Since: 2.4/
treeViewColumnGetExpand ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a
    -- ^ /@treeColumn@/: A t'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'.
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the column expands to fill available space.
treeViewColumnGetExpand :: a -> m Bool
treeViewColumnGetExpand a
treeColumn = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr TreeViewColumn
treeColumn' <- a -> IO (Ptr TreeViewColumn)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
treeColumn
    CInt
result <- Ptr TreeViewColumn -> IO CInt
gtk_tree_view_column_get_expand Ptr TreeViewColumn
treeColumn'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
treeColumn
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(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 t'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'.
    -> m Int32
    -- ^ __Returns:__ The fixed width of the column.
treeViewColumnGetFixedWidth :: a -> m Int32
treeViewColumnGetFixedWidth a
treeColumn = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
    Ptr TreeViewColumn
treeColumn' <- a -> IO (Ptr TreeViewColumn)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
treeColumn
    Int32
result <- Ptr TreeViewColumn -> IO Int32
gtk_tree_view_column_get_fixed_width Ptr TreeViewColumn
treeColumn'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
treeColumn
    Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result

#if defined(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 t'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'.
    -> m Int32
    -- ^ __Returns:__ The maximum width of the /@treeColumn@/.
treeViewColumnGetMaxWidth :: a -> m Int32
treeViewColumnGetMaxWidth a
treeColumn = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
    Ptr TreeViewColumn
treeColumn' <- a -> IO (Ptr TreeViewColumn)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
treeColumn
    Int32
result <- Ptr TreeViewColumn -> IO Int32
gtk_tree_view_column_get_max_width Ptr TreeViewColumn
treeColumn'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
treeColumn
    Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result

#if defined(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 t'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'.
    -> m Int32
    -- ^ __Returns:__ The minimum width of the /@treeColumn@/.
treeViewColumnGetMinWidth :: a -> m Int32
treeViewColumnGetMinWidth a
treeColumn = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
    Ptr TreeViewColumn
treeColumn' <- a -> IO (Ptr TreeViewColumn)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
treeColumn
    Int32
result <- Ptr TreeViewColumn -> IO Int32
gtk_tree_view_column_get_min_width Ptr TreeViewColumn
treeColumn'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
treeColumn
    Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result

#if defined(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 'P.True' if the /@treeColumn@/ can be reordered by the user.
treeViewColumnGetReorderable ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a
    -- ^ /@treeColumn@/: A t'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the /@treeColumn@/ can be reordered by the user.
treeViewColumnGetReorderable :: a -> m Bool
treeViewColumnGetReorderable a
treeColumn = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr TreeViewColumn
treeColumn' <- a -> IO (Ptr TreeViewColumn)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
treeColumn
    CInt
result <- Ptr TreeViewColumn -> IO CInt
gtk_tree_view_column_get_reorderable Ptr TreeViewColumn
treeColumn'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
treeColumn
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(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 'P.True' if the /@treeColumn@/ can be resized by the end user.
treeViewColumnGetResizable ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a
    -- ^ /@treeColumn@/: A t'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'
    -> m Bool
    -- ^ __Returns:__ 'P.True', if the /@treeColumn@/ can be resized.
treeViewColumnGetResizable :: a -> m Bool
treeViewColumnGetResizable a
treeColumn = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr TreeViewColumn
treeColumn' <- a -> IO (Ptr TreeViewColumn)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
treeColumn
    CInt
result <- Ptr TreeViewColumn -> IO CInt
gtk_tree_view_column_get_resizable Ptr TreeViewColumn
treeColumn'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
treeColumn
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(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 t'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'.
    -> m Gtk.Enums.TreeViewColumnSizing
    -- ^ __Returns:__ The type of /@treeColumn@/.
treeViewColumnGetSizing :: a -> m TreeViewColumnSizing
treeViewColumnGetSizing a
treeColumn = IO TreeViewColumnSizing -> m TreeViewColumnSizing
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TreeViewColumnSizing -> m TreeViewColumnSizing)
-> IO TreeViewColumnSizing -> m TreeViewColumnSizing
forall a b. (a -> b) -> a -> b
$ do
    Ptr TreeViewColumn
treeColumn' <- a -> IO (Ptr TreeViewColumn)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
treeColumn
    CUInt
result <- Ptr TreeViewColumn -> IO CUInt
gtk_tree_view_column_get_sizing Ptr TreeViewColumn
treeColumn'
    let result' :: TreeViewColumnSizing
result' = (Int -> TreeViewColumnSizing
forall a. Enum a => Int -> a
toEnum (Int -> TreeViewColumnSizing)
-> (CUInt -> Int) -> CUInt -> TreeViewColumnSizing
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
treeColumn
    TreeViewColumnSizing -> IO TreeViewColumnSizing
forall (m :: * -> *) a. Monad m => a -> m a
return TreeViewColumnSizing
result'

#if defined(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 t'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 :: a -> m Int32
treeViewColumnGetSortColumnId a
treeColumn = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
    Ptr TreeViewColumn
treeColumn' <- a -> IO (Ptr TreeViewColumn)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
treeColumn
    Int32
result <- Ptr TreeViewColumn -> IO Int32
gtk_tree_view_column_get_sort_column_id Ptr TreeViewColumn
treeColumn'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
treeColumn
    Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result

#if defined(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 t'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'
    -> m Bool
    -- ^ __Returns:__ whether the sort indicator arrow is displayed
treeViewColumnGetSortIndicator :: a -> m Bool
treeViewColumnGetSortIndicator a
treeColumn = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr TreeViewColumn
treeColumn' <- a -> IO (Ptr TreeViewColumn)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
treeColumn
    CInt
result <- Ptr TreeViewColumn -> IO CInt
gtk_tree_view_column_get_sort_indicator Ptr TreeViewColumn
treeColumn'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
treeColumn
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(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 t'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'
    -> m Gtk.Enums.SortType
    -- ^ __Returns:__ the sort order the sort indicator is indicating
treeViewColumnGetSortOrder :: a -> m SortType
treeViewColumnGetSortOrder a
treeColumn = IO SortType -> m SortType
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SortType -> m SortType) -> IO SortType -> m SortType
forall a b. (a -> b) -> a -> b
$ do
    Ptr TreeViewColumn
treeColumn' <- a -> IO (Ptr TreeViewColumn)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
treeColumn
    CUInt
result <- Ptr TreeViewColumn -> IO CUInt
gtk_tree_view_column_get_sort_order Ptr TreeViewColumn
treeColumn'
    let result' :: SortType
result' = (Int -> SortType
forall a. Enum a => Int -> a
toEnum (Int -> SortType) -> (CUInt -> Int) -> CUInt -> SortType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
treeColumn
    SortType -> IO SortType
forall (m :: * -> *) a. Monad m => a -> m a
return SortType
result'

#if defined(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 t'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'.
    -> m Int32
    -- ^ __Returns:__ the spacing of /@treeColumn@/.
treeViewColumnGetSpacing :: a -> m Int32
treeViewColumnGetSpacing a
treeColumn = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
    Ptr TreeViewColumn
treeColumn' <- a -> IO (Ptr TreeViewColumn)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
treeColumn
    Int32
result <- Ptr TreeViewColumn -> IO Int32
gtk_tree_view_column_get_spacing Ptr TreeViewColumn
treeColumn'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
treeColumn
    Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result

#if defined(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 t'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'.
    -> m T.Text
    -- ^ __Returns:__ the title of the column. This string should not be
    -- modified or freed.
treeViewColumnGetTitle :: a -> m Text
treeViewColumnGetTitle a
treeColumn = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    Ptr TreeViewColumn
treeColumn' <- a -> IO (Ptr TreeViewColumn)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
treeColumn
    CString
result <- Ptr TreeViewColumn -> IO CString
gtk_tree_view_column_get_title Ptr TreeViewColumn
treeColumn'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"treeViewColumnGetTitle" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
treeColumn
    Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(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 t'GI.Gtk.Objects.TreeView.TreeView' wherein /@treeColumn@/ has been inserted.
-- If /@column@/ is currently not inserted in any tree view, 'P.Nothing' is
-- returned.
-- 
-- /Since: 2.12/
treeViewColumnGetTreeView ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a
    -- ^ /@treeColumn@/: A t'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'
    -> m (Maybe Gtk.Widget.Widget)
    -- ^ __Returns:__ The tree view wherein /@column@/ has
    --     been inserted if any, 'P.Nothing' otherwise.
treeViewColumnGetTreeView :: a -> m (Maybe Widget)
treeViewColumnGetTreeView a
treeColumn = IO (Maybe Widget) -> m (Maybe Widget)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Widget) -> m (Maybe Widget))
-> IO (Maybe Widget) -> m (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ do
    Ptr TreeViewColumn
treeColumn' <- a -> IO (Ptr TreeViewColumn)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
treeColumn
    Ptr Widget
result <- Ptr TreeViewColumn -> IO (Ptr Widget)
gtk_tree_view_column_get_tree_view Ptr TreeViewColumn
treeColumn'
    Maybe Widget
maybeResult <- Ptr Widget -> (Ptr Widget -> IO Widget) -> IO (Maybe Widget)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Widget
result ((Ptr Widget -> IO Widget) -> IO (Maybe Widget))
-> (Ptr Widget -> IO Widget) -> IO (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ \Ptr Widget
result' -> do
        Widget
result'' <- ((ManagedPtr Widget -> Widget) -> Ptr Widget -> IO Widget
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Widget -> Widget
Gtk.Widget.Widget) Ptr Widget
result'
        Widget -> IO Widget
forall (m :: * -> *) a. Monad m => a -> m a
return Widget
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
treeColumn
    Maybe Widget -> IO (Maybe Widget)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Widget
maybeResult

#if defined(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 'P.True' if /@treeColumn@/ is visible.
treeViewColumnGetVisible ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a
    -- ^ /@treeColumn@/: A t'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 :: a -> m Bool
treeViewColumnGetVisible a
treeColumn = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr TreeViewColumn
treeColumn' <- a -> IO (Ptr TreeViewColumn)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
treeColumn
    CInt
result <- Ptr TreeViewColumn -> IO CInt
gtk_tree_view_column_get_visible Ptr TreeViewColumn
treeColumn'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
treeColumn
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(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 t'GI.Gtk.Objects.Widget.Widget' in the button on the column header.
-- If a custom widget has not been set then 'P.Nothing' is returned.
treeViewColumnGetWidget ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a) =>
    a
    -- ^ /@treeColumn@/: A t'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'.
    -> m (Maybe Gtk.Widget.Widget)
    -- ^ __Returns:__ The t'GI.Gtk.Objects.Widget.Widget' in the column
    --     header, or 'P.Nothing'
treeViewColumnGetWidget :: a -> m (Maybe Widget)
treeViewColumnGetWidget a
treeColumn = IO (Maybe Widget) -> m (Maybe Widget)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Widget) -> m (Maybe Widget))
-> IO (Maybe Widget) -> m (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ do
    Ptr TreeViewColumn
treeColumn' <- a -> IO (Ptr TreeViewColumn)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
treeColumn
    Ptr Widget
result <- Ptr TreeViewColumn -> IO (Ptr Widget)
gtk_tree_view_column_get_widget Ptr TreeViewColumn
treeColumn'
    Maybe Widget
maybeResult <- Ptr Widget -> (Ptr Widget -> IO Widget) -> IO (Maybe Widget)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Widget
result ((Ptr Widget -> IO Widget) -> IO (Maybe Widget))
-> (Ptr Widget -> IO Widget) -> IO (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ \Ptr Widget
result' -> do
        Widget
result'' <- ((ManagedPtr Widget -> Widget) -> Ptr Widget -> IO Widget
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Widget -> Widget
Gtk.Widget.Widget) Ptr Widget
result'
        Widget -> IO Widget
forall (m :: * -> *) a. Monad m => a -> m a
return Widget
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
treeColumn
    Maybe Widget -> IO (Maybe Widget)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Widget
maybeResult

#if defined(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 t'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'.
    -> m Int32
    -- ^ __Returns:__ The current width of /@treeColumn@/.
treeViewColumnGetWidth :: a -> m Int32
treeViewColumnGetWidth a
treeColumn = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
    Ptr TreeViewColumn
treeColumn' <- a -> IO (Ptr TreeViewColumn)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
treeColumn
    Int32
result <- Ptr TreeViewColumn -> IO Int32
gtk_tree_view_column_get_width Ptr TreeViewColumn
treeColumn'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
treeColumn
    Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result

#if defined(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 t'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'.
    -> m Int32
    -- ^ __Returns:__ The current X offset of /@treeColumn@/.
treeViewColumnGetXOffset :: a -> m Int32
treeViewColumnGetXOffset a
treeColumn = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
    Ptr TreeViewColumn
treeColumn' <- a -> IO (Ptr TreeViewColumn)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
treeColumn
    Int32
result <- Ptr TreeViewColumn -> IO Int32
gtk_tree_view_column_get_x_offset Ptr TreeViewColumn
treeColumn'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
treeColumn
    Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result

#if defined(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 'P.False', then the /@cell@/
-- is allocated no more space than it needs. Any unused space is divided
-- evenly between cells for which /@expand@/ is 'P.True'.
treeViewColumnPackEnd ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a, Gtk.CellRenderer.IsCellRenderer b) =>
    a
    -- ^ /@treeColumn@/: A t'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'.
    -> b
    -- ^ /@cell@/: The t'GI.Gtk.Objects.CellRenderer.CellRenderer'.
    -> Bool
    -- ^ /@expand@/: 'P.True' if /@cell@/ is to be given extra space allocated to /@treeColumn@/.
    -> m ()
treeViewColumnPackEnd :: a -> b -> Bool -> m ()
treeViewColumnPackEnd a
treeColumn b
cell Bool
expand = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr TreeViewColumn
treeColumn' <- a -> IO (Ptr TreeViewColumn)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
treeColumn
    Ptr CellRenderer
cell' <- b -> IO (Ptr CellRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
cell
    let expand' :: CInt
expand' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
expand
    Ptr TreeViewColumn -> Ptr CellRenderer -> CInt -> IO ()
gtk_tree_view_column_pack_end Ptr TreeViewColumn
treeColumn' Ptr CellRenderer
cell' CInt
expand'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
treeColumn
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
cell
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(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 'P.False', then
-- the /@cell@/ is allocated no more space than it needs. Any unused space is divided
-- evenly between cells for which /@expand@/ is 'P.True'.
treeViewColumnPackStart ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a, Gtk.CellRenderer.IsCellRenderer b) =>
    a
    -- ^ /@treeColumn@/: A t'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'.
    -> b
    -- ^ /@cell@/: The t'GI.Gtk.Objects.CellRenderer.CellRenderer'.
    -> Bool
    -- ^ /@expand@/: 'P.True' if /@cell@/ is to be given extra space allocated to /@treeColumn@/.
    -> m ()
treeViewColumnPackStart :: a -> b -> Bool -> m ()
treeViewColumnPackStart a
treeColumn b
cell Bool
expand = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr TreeViewColumn
treeColumn' <- a -> IO (Ptr TreeViewColumn)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
treeColumn
    Ptr CellRenderer
cell' <- b -> IO (Ptr CellRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
cell
    let expand' :: CInt
expand' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
expand
    Ptr TreeViewColumn -> Ptr CellRenderer -> CInt -> IO ()
gtk_tree_view_column_pack_start Ptr TreeViewColumn
treeColumn' Ptr CellRenderer
cell' CInt
expand'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
treeColumn
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
cell
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(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 t'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'
    -> m ()
treeViewColumnQueueResize :: a -> m ()
treeViewColumnQueueResize a
treeColumn = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr TreeViewColumn
treeColumn' <- a -> IO (Ptr TreeViewColumn)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
treeColumn
    Ptr TreeViewColumn -> IO ()
gtk_tree_view_column_queue_resize Ptr TreeViewColumn
treeColumn'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
treeColumn
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(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 t'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'.
    -> Float
    -- ^ /@xalign@/: The alignment, which is between [0.0 and 1.0] inclusive.
    -> m ()
treeViewColumnSetAlignment :: a -> Float -> m ()
treeViewColumnSetAlignment a
treeColumn Float
xalign = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr TreeViewColumn
treeColumn' <- a -> IO (Ptr TreeViewColumn)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
treeColumn
    let xalign' :: CFloat
xalign' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
xalign
    Ptr TreeViewColumn -> CFloat -> IO ()
gtk_tree_view_column_set_alignment Ptr TreeViewColumn
treeColumn' CFloat
xalign'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
treeColumn
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(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 t'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 'P.Nothing' to remove an
-- older one.
treeViewColumnSetCellDataFunc ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeViewColumn a, Gtk.CellRenderer.IsCellRenderer b) =>
    a
    -- ^ /@treeColumn@/: A t'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'
    -> b
    -- ^ /@cellRenderer@/: A t'GI.Gtk.Objects.CellRenderer.CellRenderer'
    -> Maybe (Gtk.Callbacks.TreeCellDataFunc)
    -- ^ /@func@/: The t'GI.Gtk.Callbacks.TreeCellDataFunc' to use.
    -> m ()
treeViewColumnSetCellDataFunc :: a -> b -> Maybe TreeCellDataFunc -> m ()
treeViewColumnSetCellDataFunc a
treeColumn b
cellRenderer Maybe TreeCellDataFunc
func = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr TreeViewColumn
treeColumn' <- a -> IO (Ptr TreeViewColumn)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
treeColumn
    Ptr CellRenderer
cellRenderer' <- b -> IO (Ptr CellRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
cellRenderer
    FunPtr C_TreeCellDataFunc
maybeFunc <- case Maybe TreeCellDataFunc
func of
        Maybe TreeCellDataFunc
Nothing -> FunPtr C_TreeCellDataFunc -> IO (FunPtr C_TreeCellDataFunc)
forall (m :: * -> *) a. Monad m => a -> m a
return (Ptr Any -> FunPtr C_TreeCellDataFunc
forall a b. Ptr a -> FunPtr b
castPtrToFunPtr Ptr Any
forall a. Ptr a
nullPtr)
        Just TreeCellDataFunc
jFunc -> do
            FunPtr C_TreeCellDataFunc
jFunc' <- C_TreeCellDataFunc -> IO (FunPtr C_TreeCellDataFunc)
Gtk.Callbacks.mk_TreeCellDataFunc (Maybe (Ptr (FunPtr C_TreeCellDataFunc))
-> TreeCellDataFunc_WithClosures -> C_TreeCellDataFunc
Gtk.Callbacks.wrap_TreeCellDataFunc Maybe (Ptr (FunPtr C_TreeCellDataFunc))
forall a. Maybe a
Nothing (TreeCellDataFunc -> TreeCellDataFunc_WithClosures
Gtk.Callbacks.drop_closures_TreeCellDataFunc TreeCellDataFunc
jFunc))
            FunPtr C_TreeCellDataFunc -> IO (FunPtr C_TreeCellDataFunc)
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_TreeCellDataFunc
jFunc'
    let funcData :: Ptr ()
funcData = FunPtr C_TreeCellDataFunc -> Ptr ()
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_TreeCellDataFunc
maybeFunc
    let destroy :: FunPtr (Ptr a -> IO ())
destroy = FunPtr (Ptr a -> IO ())
forall a. FunPtr (Ptr a -> IO ())
safeFreeFunPtrPtr
    Ptr TreeViewColumn
-> Ptr CellRenderer
-> FunPtr C_TreeCellDataFunc
-> Ptr ()
-> FunPtr C_DestroyNotify
-> IO ()
gtk_tree_view_column_set_cell_data_func Ptr TreeViewColumn
treeColumn' Ptr CellRenderer
cellRenderer' FunPtr C_TreeCellDataFunc
maybeFunc Ptr ()
funcData FunPtr C_DestroyNotify
forall a. FunPtr (Ptr a -> IO ())
destroy
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
treeColumn
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
cellRenderer
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(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 'P.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 t'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'.
    -> Bool
    -- ^ /@clickable@/: 'P.True' if the header is active.
    -> m ()
treeViewColumnSetClickable :: a -> Bool -> m ()
treeViewColumnSetClickable a
treeColumn Bool
clickable = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr TreeViewColumn
treeColumn' <- a -> IO (Ptr TreeViewColumn)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
treeColumn
    let clickable' :: CInt
clickable' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
clickable
    Ptr TreeViewColumn -> CInt -> IO ()
gtk_tree_view_column_set_clickable Ptr TreeViewColumn
treeColumn' CInt
clickable'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
treeColumn
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(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 'P.True'.  If no column has this
-- option set, then the last column gets all extra space.  By default, every
-- column is created with this 'P.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 t'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'.
    -> Bool
    -- ^ /@expand@/: 'P.True' if the column should expand to fill available space.
    -> m ()
treeViewColumnSetExpand :: a -> Bool -> m ()
treeViewColumnSetExpand a
treeColumn Bool
expand = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr TreeViewColumn
treeColumn' <- a -> IO (Ptr TreeViewColumn)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
treeColumn
    let expand' :: CInt
expand' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
expand
    Ptr TreeViewColumn -> CInt -> IO ()
gtk_tree_view_column_set_expand Ptr TreeViewColumn
treeColumn' CInt
expand'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
treeColumn
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(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 t'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'.
    -> Int32
    -- ^ /@fixedWidth@/: The new fixed width, in pixels, or -1.
    -> m ()
treeViewColumnSetFixedWidth :: a -> Int32 -> m ()
treeViewColumnSetFixedWidth a
treeColumn Int32
fixedWidth = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr TreeViewColumn
treeColumn' <- a -> IO (Ptr TreeViewColumn)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
treeColumn
    Ptr TreeViewColumn -> Int32 -> IO ()
gtk_tree_view_column_set_fixed_width Ptr TreeViewColumn
treeColumn' Int32
fixedWidth
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
treeColumn
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(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 t'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'.
    -> Int32
    -- ^ /@maxWidth@/: The maximum width of the column in pixels, or -1.
    -> m ()
treeViewColumnSetMaxWidth :: a -> Int32 -> m ()
treeViewColumnSetMaxWidth a
treeColumn Int32
maxWidth = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr TreeViewColumn
treeColumn' <- a -> IO (Ptr TreeViewColumn)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
treeColumn
    Ptr TreeViewColumn -> Int32 -> IO ()
gtk_tree_view_column_set_max_width Ptr TreeViewColumn
treeColumn' Int32
maxWidth
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
treeColumn
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(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 t'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'.
    -> Int32
    -- ^ /@minWidth@/: The minimum width of the column in pixels, or -1.
    -> m ()
treeViewColumnSetMinWidth :: a -> Int32 -> m ()
treeViewColumnSetMinWidth a
treeColumn Int32
minWidth = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr TreeViewColumn
treeColumn' <- a -> IO (Ptr TreeViewColumn)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
treeColumn
    Ptr TreeViewColumn -> Int32 -> IO ()
gtk_tree_view_column_set_min_width Ptr TreeViewColumn
treeColumn' Int32
minWidth
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
treeColumn
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(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 'P.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 t'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'
    -> Bool
    -- ^ /@reorderable@/: 'P.True', if the column can be reordered.
    -> m ()
treeViewColumnSetReorderable :: a -> Bool -> m ()
treeViewColumnSetReorderable a
treeColumn Bool
reorderable = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr TreeViewColumn
treeColumn' <- a -> IO (Ptr TreeViewColumn)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
treeColumn
    let reorderable' :: CInt
reorderable' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
reorderable
    Ptr TreeViewColumn -> CInt -> IO ()
gtk_tree_view_column_set_reorderable Ptr TreeViewColumn
treeColumn' CInt
reorderable'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
treeColumn
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(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 'P.True', then the user can explicitly resize the column by
-- grabbing the outer edge of the column button.  If resizable is 'P.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 t'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'
    -> Bool
    -- ^ /@resizable@/: 'P.True', if the column can be resized
    -> m ()
treeViewColumnSetResizable :: a -> Bool -> m ()
treeViewColumnSetResizable a
treeColumn Bool
resizable = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr TreeViewColumn
treeColumn' <- a -> IO (Ptr TreeViewColumn)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
treeColumn
    let resizable' :: CInt
resizable' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
resizable
    Ptr TreeViewColumn -> CInt -> IO ()
gtk_tree_view_column_set_resizable Ptr TreeViewColumn
treeColumn' CInt
resizable'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
treeColumn
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(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 t'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'.
    -> Gtk.Enums.TreeViewColumnSizing
    -- ^ /@type@/: The t'GI.Gtk.Enums.TreeViewColumnSizing'.
    -> m ()
treeViewColumnSetSizing :: a -> TreeViewColumnSizing -> m ()
treeViewColumnSetSizing a
treeColumn TreeViewColumnSizing
type_ = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr TreeViewColumn
treeColumn' <- a -> IO (Ptr TreeViewColumn)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
treeColumn
    let type_' :: CUInt
type_' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (TreeViewColumnSizing -> Int) -> TreeViewColumnSizing -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TreeViewColumnSizing -> Int
forall a. Enum a => a -> Int
fromEnum) TreeViewColumnSizing
type_
    Ptr TreeViewColumn -> CUInt -> IO ()
gtk_tree_view_column_set_sizing Ptr TreeViewColumn
treeColumn' CUInt
type_'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
treeColumn
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(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 t'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'
    -> Int32
    -- ^ /@sortColumnId@/: The /@sortColumnId@/ of the model to sort on.
    -> m ()
treeViewColumnSetSortColumnId :: a -> Int32 -> m ()
treeViewColumnSetSortColumnId a
treeColumn Int32
sortColumnId = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr TreeViewColumn
treeColumn' <- a -> IO (Ptr TreeViewColumn)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
treeColumn
    Ptr TreeViewColumn -> Int32 -> IO ()
gtk_tree_view_column_set_sort_column_id Ptr TreeViewColumn
treeColumn' Int32
sortColumnId
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
treeColumn
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(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 'P.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 t'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'
    -> Bool
    -- ^ /@setting@/: 'P.True' to display an indicator that the column is sorted
    -> m ()
treeViewColumnSetSortIndicator :: a -> Bool -> m ()
treeViewColumnSetSortIndicator a
treeColumn Bool
setting = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr TreeViewColumn
treeColumn' <- a -> IO (Ptr TreeViewColumn)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
treeColumn
    let setting' :: CInt
setting' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
setting
    Ptr TreeViewColumn -> CInt -> IO ()
gtk_tree_view_column_set_sort_indicator Ptr TreeViewColumn
treeColumn' CInt
setting'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
treeColumn
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(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 t'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'
    -> Gtk.Enums.SortType
    -- ^ /@order@/: sort order that the sort indicator should indicate
    -> m ()
treeViewColumnSetSortOrder :: a -> SortType -> m ()
treeViewColumnSetSortOrder a
treeColumn SortType
order = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr TreeViewColumn
treeColumn' <- a -> IO (Ptr TreeViewColumn)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
treeColumn
    let order' :: CUInt
order' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (SortType -> Int) -> SortType -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SortType -> Int
forall a. Enum a => a -> Int
fromEnum) SortType
order
    Ptr TreeViewColumn -> CUInt -> IO ()
gtk_tree_view_column_set_sort_order Ptr TreeViewColumn
treeColumn' CUInt
order'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
treeColumn
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(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 t'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'.
    -> Int32
    -- ^ /@spacing@/: distance between cell renderers in pixels.
    -> m ()
treeViewColumnSetSpacing :: a -> Int32 -> m ()
treeViewColumnSetSpacing a
treeColumn Int32
spacing = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr TreeViewColumn
treeColumn' <- a -> IO (Ptr TreeViewColumn)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
treeColumn
    Ptr TreeViewColumn -> Int32 -> IO ()
gtk_tree_view_column_set_spacing Ptr TreeViewColumn
treeColumn' Int32
spacing
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
treeColumn
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(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 t'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'.
    -> T.Text
    -- ^ /@title@/: The title of the /@treeColumn@/.
    -> m ()
treeViewColumnSetTitle :: a -> Text -> m ()
treeViewColumnSetTitle a
treeColumn Text
title = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr TreeViewColumn
treeColumn' <- a -> IO (Ptr TreeViewColumn)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
treeColumn
    CString
title' <- Text -> IO CString
textToCString Text
title
    Ptr TreeViewColumn -> CString -> IO ()
gtk_tree_view_column_set_title Ptr TreeViewColumn
treeColumn' CString
title'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
treeColumn
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
title'
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(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 t'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'.
    -> Bool
    -- ^ /@visible@/: 'P.True' if the /@treeColumn@/ is visible.
    -> m ()
treeViewColumnSetVisible :: a -> Bool -> m ()
treeViewColumnSetVisible a
treeColumn Bool
visible = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr TreeViewColumn
treeColumn' <- a -> IO (Ptr TreeViewColumn)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
treeColumn
    let visible' :: CInt
visible' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
visible
    Ptr TreeViewColumn -> CInt -> IO ()
gtk_tree_view_column_set_visible Ptr TreeViewColumn
treeColumn' CInt
visible'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
treeColumn
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(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 'P.Nothing', then the
-- header button is set with a t'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 t'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn'.
    -> Maybe (b)
    -- ^ /@widget@/: A child t'GI.Gtk.Objects.Widget.Widget', or 'P.Nothing'.
    -> m ()
treeViewColumnSetWidget :: a -> Maybe b -> m ()
treeViewColumnSetWidget a
treeColumn Maybe b
widget = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr TreeViewColumn
treeColumn' <- a -> IO (Ptr TreeViewColumn)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
treeColumn
    Ptr Widget
maybeWidget <- case Maybe b
widget of
        Maybe b
Nothing -> Ptr Widget -> IO (Ptr Widget)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
forall a. Ptr a
nullPtr
        Just b
jWidget -> do
            Ptr Widget
jWidget' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jWidget
            Ptr Widget -> IO (Ptr Widget)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
jWidget'
    Ptr TreeViewColumn -> Ptr Widget -> IO ()
gtk_tree_view_column_set_widget Ptr TreeViewColumn
treeColumn' Ptr Widget
maybeWidget
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
treeColumn
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
widget b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(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