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

Widget that displays any object that implements the 'GI.Gtk.Interfaces.TreeModel.TreeModel' interface.

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.

Several different coordinate systems are exposed in the GtkTreeView API.
These are:

<<https://developer.gnome.org/gtk3/stable/tree-view-coordinates.png>>

Coordinate systems in GtkTreeView API:

* Widget coordinates: Coordinates relative to the widget (usually @widget->window@).
* Bin window coordinates: Coordinates relative to the window that GtkTreeView renders to.
* Tree coordinates: Coordinates relative to the entire scrollable area of GtkTreeView. These
coordinates start at (0, 0) for row 0 of the tree.


Several functions are available for converting between the different
coordinate systems.  The most common translations are between widget and bin
window coordinates and between bin window and tree coordinates. For the
former you can use 'GI.Gtk.Objects.TreeView.treeViewConvertWidgetToBinWindowCoords'
(and vice versa), for the latter 'GI.Gtk.Objects.TreeView.treeViewConvertBinWindowToTreeCoords'
(and vice versa).

= GtkTreeView as GtkBuildable

The GtkTreeView implementation of the GtkBuildable interface accepts
'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn' objects as \<child> elements and exposes the internal
'GI.Gtk.Objects.TreeSelection.TreeSelection' in UI definitions.

An example of a UI definition fragment with GtkTreeView:
>
><object class="GtkTreeView" id="treeview">
>  <property name="model">liststore1</property>
>  <child>
>    <object class="GtkTreeViewColumn" id="test-column">
>      <property name="title">Test</property>
>      <child>
>        <object class="GtkCellRendererText" id="test-renderer"/>
>        <attributes>
>          <attribute name="text">1</attribute>
>        </attributes>
>      </child>
>    </object>
>  </child>
>  <child internal-child="selection">
>    <object class="GtkTreeSelection" id="selection">
>      <signal name="changed" handler="on_treeview_selection_changed"/>
>    </object>
>  </child>
></object>


= CSS nodes


=== /plain code/
>
>treeview.view
>├── header
>│   ├── <column header>
>┊   ┊
>│   ╰── <column header>
>│
>╰── [rubberband]


GtkTreeView has a main CSS node with name treeview and style class .view.
It has a subnode with name header, which is the parent for all the column
header widgets\' CSS nodes.
For rubberband selection, a subnode with name rubberband is used.
-}

module GI.Gtk.Objects.TreeView
    ( 

-- * Exported types
    TreeView(..)                            ,
    IsTreeView                              ,
    toTreeView                              ,
    noTreeView                              ,


 -- * Methods
-- ** appendColumn #method:appendColumn#
    TreeViewAppendColumnMethodInfo          ,
    treeViewAppendColumn                    ,


-- ** collapseAll #method:collapseAll#
    TreeViewCollapseAllMethodInfo           ,
    treeViewCollapseAll                     ,


-- ** collapseRow #method:collapseRow#
    TreeViewCollapseRowMethodInfo           ,
    treeViewCollapseRow                     ,


-- ** columnsAutosize #method:columnsAutosize#
    TreeViewColumnsAutosizeMethodInfo       ,
    treeViewColumnsAutosize                 ,


-- ** convertBinWindowToTreeCoords #method:convertBinWindowToTreeCoords#
    TreeViewConvertBinWindowToTreeCoordsMethodInfo,
    treeViewConvertBinWindowToTreeCoords    ,


-- ** convertBinWindowToWidgetCoords #method:convertBinWindowToWidgetCoords#
    TreeViewConvertBinWindowToWidgetCoordsMethodInfo,
    treeViewConvertBinWindowToWidgetCoords  ,


-- ** convertTreeToBinWindowCoords #method:convertTreeToBinWindowCoords#
    TreeViewConvertTreeToBinWindowCoordsMethodInfo,
    treeViewConvertTreeToBinWindowCoords    ,


-- ** convertTreeToWidgetCoords #method:convertTreeToWidgetCoords#
    TreeViewConvertTreeToWidgetCoordsMethodInfo,
    treeViewConvertTreeToWidgetCoords       ,


-- ** convertWidgetToBinWindowCoords #method:convertWidgetToBinWindowCoords#
    TreeViewConvertWidgetToBinWindowCoordsMethodInfo,
    treeViewConvertWidgetToBinWindowCoords  ,


-- ** convertWidgetToTreeCoords #method:convertWidgetToTreeCoords#
    TreeViewConvertWidgetToTreeCoordsMethodInfo,
    treeViewConvertWidgetToTreeCoords       ,


-- ** createRowDragIcon #method:createRowDragIcon#
    TreeViewCreateRowDragIconMethodInfo     ,
    treeViewCreateRowDragIcon               ,


-- ** enableModelDragDest #method:enableModelDragDest#
    TreeViewEnableModelDragDestMethodInfo   ,
    treeViewEnableModelDragDest             ,


-- ** enableModelDragSource #method:enableModelDragSource#
    TreeViewEnableModelDragSourceMethodInfo ,
    treeViewEnableModelDragSource           ,


-- ** expandAll #method:expandAll#
    TreeViewExpandAllMethodInfo             ,
    treeViewExpandAll                       ,


-- ** expandRow #method:expandRow#
    TreeViewExpandRowMethodInfo             ,
    treeViewExpandRow                       ,


-- ** expandToPath #method:expandToPath#
    TreeViewExpandToPathMethodInfo          ,
    treeViewExpandToPath                    ,


-- ** getActivateOnSingleClick #method:getActivateOnSingleClick#
    TreeViewGetActivateOnSingleClickMethodInfo,
    treeViewGetActivateOnSingleClick        ,


-- ** getBackgroundArea #method:getBackgroundArea#
    TreeViewGetBackgroundAreaMethodInfo     ,
    treeViewGetBackgroundArea               ,


-- ** getBinWindow #method:getBinWindow#
    TreeViewGetBinWindowMethodInfo          ,
    treeViewGetBinWindow                    ,


-- ** getCellArea #method:getCellArea#
    TreeViewGetCellAreaMethodInfo           ,
    treeViewGetCellArea                     ,


-- ** getColumn #method:getColumn#
    TreeViewGetColumnMethodInfo             ,
    treeViewGetColumn                       ,


-- ** getColumns #method:getColumns#
    TreeViewGetColumnsMethodInfo            ,
    treeViewGetColumns                      ,


-- ** getCursor #method:getCursor#
    TreeViewGetCursorMethodInfo             ,
    treeViewGetCursor                       ,


-- ** getDestRowAtPos #method:getDestRowAtPos#
    TreeViewGetDestRowAtPosMethodInfo       ,
    treeViewGetDestRowAtPos                 ,


-- ** getDragDestRow #method:getDragDestRow#
    TreeViewGetDragDestRowMethodInfo        ,
    treeViewGetDragDestRow                  ,


-- ** getEnableSearch #method:getEnableSearch#
    TreeViewGetEnableSearchMethodInfo       ,
    treeViewGetEnableSearch                 ,


-- ** getEnableTreeLines #method:getEnableTreeLines#
    TreeViewGetEnableTreeLinesMethodInfo    ,
    treeViewGetEnableTreeLines              ,


-- ** getExpanderColumn #method:getExpanderColumn#
    TreeViewGetExpanderColumnMethodInfo     ,
    treeViewGetExpanderColumn               ,


-- ** getFixedHeightMode #method:getFixedHeightMode#
    TreeViewGetFixedHeightModeMethodInfo    ,
    treeViewGetFixedHeightMode              ,


-- ** getGridLines #method:getGridLines#
    TreeViewGetGridLinesMethodInfo          ,
    treeViewGetGridLines                    ,


-- ** getHadjustment #method:getHadjustment#
    TreeViewGetHadjustmentMethodInfo        ,
    treeViewGetHadjustment                  ,


-- ** getHeadersClickable #method:getHeadersClickable#
    TreeViewGetHeadersClickableMethodInfo   ,
    treeViewGetHeadersClickable             ,


-- ** getHeadersVisible #method:getHeadersVisible#
    TreeViewGetHeadersVisibleMethodInfo     ,
    treeViewGetHeadersVisible               ,


-- ** getHoverExpand #method:getHoverExpand#
    TreeViewGetHoverExpandMethodInfo        ,
    treeViewGetHoverExpand                  ,


-- ** getHoverSelection #method:getHoverSelection#
    TreeViewGetHoverSelectionMethodInfo     ,
    treeViewGetHoverSelection               ,


-- ** getLevelIndentation #method:getLevelIndentation#
    TreeViewGetLevelIndentationMethodInfo   ,
    treeViewGetLevelIndentation             ,


-- ** getModel #method:getModel#
    TreeViewGetModelMethodInfo              ,
    treeViewGetModel                        ,


-- ** getNColumns #method:getNColumns#
    TreeViewGetNColumnsMethodInfo           ,
    treeViewGetNColumns                     ,


-- ** getPathAtPos #method:getPathAtPos#
    TreeViewGetPathAtPosMethodInfo          ,
    treeViewGetPathAtPos                    ,


-- ** getReorderable #method:getReorderable#
    TreeViewGetReorderableMethodInfo        ,
    treeViewGetReorderable                  ,


-- ** getRubberBanding #method:getRubberBanding#
    TreeViewGetRubberBandingMethodInfo      ,
    treeViewGetRubberBanding                ,


-- ** getRulesHint #method:getRulesHint#
    TreeViewGetRulesHintMethodInfo          ,
    treeViewGetRulesHint                    ,


-- ** getSearchColumn #method:getSearchColumn#
    TreeViewGetSearchColumnMethodInfo       ,
    treeViewGetSearchColumn                 ,


-- ** getSearchEntry #method:getSearchEntry#
    TreeViewGetSearchEntryMethodInfo        ,
    treeViewGetSearchEntry                  ,


-- ** getSelection #method:getSelection#
    TreeViewGetSelectionMethodInfo          ,
    treeViewGetSelection                    ,


-- ** getShowExpanders #method:getShowExpanders#
    TreeViewGetShowExpandersMethodInfo      ,
    treeViewGetShowExpanders                ,


-- ** getTooltipColumn #method:getTooltipColumn#
    TreeViewGetTooltipColumnMethodInfo      ,
    treeViewGetTooltipColumn                ,


-- ** getTooltipContext #method:getTooltipContext#
    TreeViewGetTooltipContextMethodInfo     ,
    treeViewGetTooltipContext               ,


-- ** getVadjustment #method:getVadjustment#
    TreeViewGetVadjustmentMethodInfo        ,
    treeViewGetVadjustment                  ,


-- ** getVisibleRange #method:getVisibleRange#
    TreeViewGetVisibleRangeMethodInfo       ,
    treeViewGetVisibleRange                 ,


-- ** getVisibleRect #method:getVisibleRect#
    TreeViewGetVisibleRectMethodInfo        ,
    treeViewGetVisibleRect                  ,


-- ** insertColumn #method:insertColumn#
    TreeViewInsertColumnMethodInfo          ,
    treeViewInsertColumn                    ,


-- ** insertColumnWithDataFunc #method:insertColumnWithDataFunc#
    TreeViewInsertColumnWithDataFuncMethodInfo,
    treeViewInsertColumnWithDataFunc        ,


-- ** isBlankAtPos #method:isBlankAtPos#
    TreeViewIsBlankAtPosMethodInfo          ,
    treeViewIsBlankAtPos                    ,


-- ** isRubberBandingActive #method:isRubberBandingActive#
    TreeViewIsRubberBandingActiveMethodInfo ,
    treeViewIsRubberBandingActive           ,


-- ** mapExpandedRows #method:mapExpandedRows#
    TreeViewMapExpandedRowsMethodInfo       ,
    treeViewMapExpandedRows                 ,


-- ** moveColumnAfter #method:moveColumnAfter#
    TreeViewMoveColumnAfterMethodInfo       ,
    treeViewMoveColumnAfter                 ,


-- ** new #method:new#
    treeViewNew                             ,


-- ** newWithModel #method:newWithModel#
    treeViewNewWithModel                    ,


-- ** removeColumn #method:removeColumn#
    TreeViewRemoveColumnMethodInfo          ,
    treeViewRemoveColumn                    ,


-- ** rowActivated #method:rowActivated#
    TreeViewRowActivatedMethodInfo          ,
    treeViewRowActivated                    ,


-- ** rowExpanded #method:rowExpanded#
    TreeViewRowExpandedMethodInfo           ,
    treeViewRowExpanded                     ,


-- ** scrollToCell #method:scrollToCell#
    TreeViewScrollToCellMethodInfo          ,
    treeViewScrollToCell                    ,


-- ** scrollToPoint #method:scrollToPoint#
    TreeViewScrollToPointMethodInfo         ,
    treeViewScrollToPoint                   ,


-- ** setActivateOnSingleClick #method:setActivateOnSingleClick#
    TreeViewSetActivateOnSingleClickMethodInfo,
    treeViewSetActivateOnSingleClick        ,


-- ** setColumnDragFunction #method:setColumnDragFunction#
    TreeViewSetColumnDragFunctionMethodInfo ,
    treeViewSetColumnDragFunction           ,


-- ** setCursor #method:setCursor#
    TreeViewSetCursorMethodInfo             ,
    treeViewSetCursor                       ,


-- ** setCursorOnCell #method:setCursorOnCell#
    TreeViewSetCursorOnCellMethodInfo       ,
    treeViewSetCursorOnCell                 ,


-- ** setDestroyCountFunc #method:setDestroyCountFunc#
    TreeViewSetDestroyCountFuncMethodInfo   ,
    treeViewSetDestroyCountFunc             ,


-- ** setDragDestRow #method:setDragDestRow#
    TreeViewSetDragDestRowMethodInfo        ,
    treeViewSetDragDestRow                  ,


-- ** setEnableSearch #method:setEnableSearch#
    TreeViewSetEnableSearchMethodInfo       ,
    treeViewSetEnableSearch                 ,


-- ** setEnableTreeLines #method:setEnableTreeLines#
    TreeViewSetEnableTreeLinesMethodInfo    ,
    treeViewSetEnableTreeLines              ,


-- ** setExpanderColumn #method:setExpanderColumn#
    TreeViewSetExpanderColumnMethodInfo     ,
    treeViewSetExpanderColumn               ,


-- ** setFixedHeightMode #method:setFixedHeightMode#
    TreeViewSetFixedHeightModeMethodInfo    ,
    treeViewSetFixedHeightMode              ,


-- ** setGridLines #method:setGridLines#
    TreeViewSetGridLinesMethodInfo          ,
    treeViewSetGridLines                    ,


-- ** setHadjustment #method:setHadjustment#
    TreeViewSetHadjustmentMethodInfo        ,
    treeViewSetHadjustment                  ,


-- ** setHeadersClickable #method:setHeadersClickable#
    TreeViewSetHeadersClickableMethodInfo   ,
    treeViewSetHeadersClickable             ,


-- ** setHeadersVisible #method:setHeadersVisible#
    TreeViewSetHeadersVisibleMethodInfo     ,
    treeViewSetHeadersVisible               ,


-- ** setHoverExpand #method:setHoverExpand#
    TreeViewSetHoverExpandMethodInfo        ,
    treeViewSetHoverExpand                  ,


-- ** setHoverSelection #method:setHoverSelection#
    TreeViewSetHoverSelectionMethodInfo     ,
    treeViewSetHoverSelection               ,


-- ** setLevelIndentation #method:setLevelIndentation#
    TreeViewSetLevelIndentationMethodInfo   ,
    treeViewSetLevelIndentation             ,


-- ** setModel #method:setModel#
    TreeViewSetModelMethodInfo              ,
    treeViewSetModel                        ,


-- ** setReorderable #method:setReorderable#
    TreeViewSetReorderableMethodInfo        ,
    treeViewSetReorderable                  ,


-- ** setRowSeparatorFunc #method:setRowSeparatorFunc#
    TreeViewSetRowSeparatorFuncMethodInfo   ,
    treeViewSetRowSeparatorFunc             ,


-- ** setRubberBanding #method:setRubberBanding#
    TreeViewSetRubberBandingMethodInfo      ,
    treeViewSetRubberBanding                ,


-- ** setRulesHint #method:setRulesHint#
    TreeViewSetRulesHintMethodInfo          ,
    treeViewSetRulesHint                    ,


-- ** setSearchColumn #method:setSearchColumn#
    TreeViewSetSearchColumnMethodInfo       ,
    treeViewSetSearchColumn                 ,


-- ** setSearchEntry #method:setSearchEntry#
    TreeViewSetSearchEntryMethodInfo        ,
    treeViewSetSearchEntry                  ,


-- ** setSearchEqualFunc #method:setSearchEqualFunc#
    TreeViewSetSearchEqualFuncMethodInfo    ,
    treeViewSetSearchEqualFunc              ,


-- ** setSearchPositionFunc #method:setSearchPositionFunc#
    TreeViewSetSearchPositionFuncMethodInfo ,
    treeViewSetSearchPositionFunc           ,


-- ** setShowExpanders #method:setShowExpanders#
    TreeViewSetShowExpandersMethodInfo      ,
    treeViewSetShowExpanders                ,


-- ** setTooltipCell #method:setTooltipCell#
    TreeViewSetTooltipCellMethodInfo        ,
    treeViewSetTooltipCell                  ,


-- ** setTooltipColumn #method:setTooltipColumn#
    TreeViewSetTooltipColumnMethodInfo      ,
    treeViewSetTooltipColumn                ,


-- ** setTooltipRow #method:setTooltipRow#
    TreeViewSetTooltipRowMethodInfo         ,
    treeViewSetTooltipRow                   ,


-- ** setVadjustment #method:setVadjustment#
    TreeViewSetVadjustmentMethodInfo        ,
    treeViewSetVadjustment                  ,


-- ** unsetRowsDragDest #method:unsetRowsDragDest#
    TreeViewUnsetRowsDragDestMethodInfo     ,
    treeViewUnsetRowsDragDest               ,


-- ** unsetRowsDragSource #method:unsetRowsDragSource#
    TreeViewUnsetRowsDragSourceMethodInfo   ,
    treeViewUnsetRowsDragSource             ,




 -- * Properties
-- ** activateOnSingleClick #attr:activateOnSingleClick#
    TreeViewActivateOnSingleClickPropertyInfo,
    constructTreeViewActivateOnSingleClick  ,
    getTreeViewActivateOnSingleClick        ,
    setTreeViewActivateOnSingleClick        ,
    treeViewActivateOnSingleClick           ,


-- ** enableGridLines #attr:enableGridLines#
    TreeViewEnableGridLinesPropertyInfo     ,
    constructTreeViewEnableGridLines        ,
    getTreeViewEnableGridLines              ,
    setTreeViewEnableGridLines              ,
    treeViewEnableGridLines                 ,


-- ** enableSearch #attr:enableSearch#
    TreeViewEnableSearchPropertyInfo        ,
    constructTreeViewEnableSearch           ,
    getTreeViewEnableSearch                 ,
    setTreeViewEnableSearch                 ,
    treeViewEnableSearch                    ,


-- ** enableTreeLines #attr:enableTreeLines#
    TreeViewEnableTreeLinesPropertyInfo     ,
    constructTreeViewEnableTreeLines        ,
    getTreeViewEnableTreeLines              ,
    setTreeViewEnableTreeLines              ,
    treeViewEnableTreeLines                 ,


-- ** expanderColumn #attr:expanderColumn#
    TreeViewExpanderColumnPropertyInfo      ,
    constructTreeViewExpanderColumn         ,
    getTreeViewExpanderColumn               ,
    setTreeViewExpanderColumn               ,
    treeViewExpanderColumn                  ,


-- ** fixedHeightMode #attr:fixedHeightMode#
    TreeViewFixedHeightModePropertyInfo     ,
    constructTreeViewFixedHeightMode        ,
    getTreeViewFixedHeightMode              ,
    setTreeViewFixedHeightMode              ,
    treeViewFixedHeightMode                 ,


-- ** headersClickable #attr:headersClickable#
    TreeViewHeadersClickablePropertyInfo    ,
    constructTreeViewHeadersClickable       ,
    getTreeViewHeadersClickable             ,
    setTreeViewHeadersClickable             ,
    treeViewHeadersClickable                ,


-- ** headersVisible #attr:headersVisible#
    TreeViewHeadersVisiblePropertyInfo      ,
    constructTreeViewHeadersVisible         ,
    getTreeViewHeadersVisible               ,
    setTreeViewHeadersVisible               ,
    treeViewHeadersVisible                  ,


-- ** hoverExpand #attr:hoverExpand#
    TreeViewHoverExpandPropertyInfo         ,
    constructTreeViewHoverExpand            ,
    getTreeViewHoverExpand                  ,
    setTreeViewHoverExpand                  ,
    treeViewHoverExpand                     ,


-- ** hoverSelection #attr:hoverSelection#
    TreeViewHoverSelectionPropertyInfo      ,
    constructTreeViewHoverSelection         ,
    getTreeViewHoverSelection               ,
    setTreeViewHoverSelection               ,
    treeViewHoverSelection                  ,


-- ** levelIndentation #attr:levelIndentation#
    TreeViewLevelIndentationPropertyInfo    ,
    constructTreeViewLevelIndentation       ,
    getTreeViewLevelIndentation             ,
    setTreeViewLevelIndentation             ,
    treeViewLevelIndentation                ,


-- ** model #attr:model#
    TreeViewModelPropertyInfo               ,
    clearTreeViewModel                      ,
    constructTreeViewModel                  ,
    getTreeViewModel                        ,
    setTreeViewModel                        ,
    treeViewModel                           ,


-- ** reorderable #attr:reorderable#
    TreeViewReorderablePropertyInfo         ,
    constructTreeViewReorderable            ,
    getTreeViewReorderable                  ,
    setTreeViewReorderable                  ,
    treeViewReorderable                     ,


-- ** rubberBanding #attr:rubberBanding#
    TreeViewRubberBandingPropertyInfo       ,
    constructTreeViewRubberBanding          ,
    getTreeViewRubberBanding                ,
    setTreeViewRubberBanding                ,
    treeViewRubberBanding                   ,


-- ** rulesHint #attr:rulesHint#
    TreeViewRulesHintPropertyInfo           ,
    constructTreeViewRulesHint              ,
    getTreeViewRulesHint                    ,
    setTreeViewRulesHint                    ,
    treeViewRulesHint                       ,


-- ** searchColumn #attr:searchColumn#
    TreeViewSearchColumnPropertyInfo        ,
    constructTreeViewSearchColumn           ,
    getTreeViewSearchColumn                 ,
    setTreeViewSearchColumn                 ,
    treeViewSearchColumn                    ,


-- ** showExpanders #attr:showExpanders#
    TreeViewShowExpandersPropertyInfo       ,
    constructTreeViewShowExpanders          ,
    getTreeViewShowExpanders                ,
    setTreeViewShowExpanders                ,
    treeViewShowExpanders                   ,


-- ** tooltipColumn #attr:tooltipColumn#
    TreeViewTooltipColumnPropertyInfo       ,
    constructTreeViewTooltipColumn          ,
    getTreeViewTooltipColumn                ,
    setTreeViewTooltipColumn                ,
    treeViewTooltipColumn                   ,




 -- * Signals
-- ** columnsChanged #signal:columnsChanged#
    C_TreeViewColumnsChangedCallback        ,
    TreeViewColumnsChangedCallback          ,
    TreeViewColumnsChangedSignalInfo        ,
    afterTreeViewColumnsChanged             ,
    genClosure_TreeViewColumnsChanged       ,
    mk_TreeViewColumnsChangedCallback       ,
    noTreeViewColumnsChangedCallback        ,
    onTreeViewColumnsChanged                ,
    wrap_TreeViewColumnsChangedCallback     ,


-- ** cursorChanged #signal:cursorChanged#
    C_TreeViewCursorChangedCallback         ,
    TreeViewCursorChangedCallback           ,
    TreeViewCursorChangedSignalInfo         ,
    afterTreeViewCursorChanged              ,
    genClosure_TreeViewCursorChanged        ,
    mk_TreeViewCursorChangedCallback        ,
    noTreeViewCursorChangedCallback         ,
    onTreeViewCursorChanged                 ,
    wrap_TreeViewCursorChangedCallback      ,


-- ** expandCollapseCursorRow #signal:expandCollapseCursorRow#
    C_TreeViewExpandCollapseCursorRowCallback,
    TreeViewExpandCollapseCursorRowCallback ,
    TreeViewExpandCollapseCursorRowSignalInfo,
    afterTreeViewExpandCollapseCursorRow    ,
    genClosure_TreeViewExpandCollapseCursorRow,
    mk_TreeViewExpandCollapseCursorRowCallback,
    noTreeViewExpandCollapseCursorRowCallback,
    onTreeViewExpandCollapseCursorRow       ,
    wrap_TreeViewExpandCollapseCursorRowCallback,


-- ** moveCursor #signal:moveCursor#
    C_TreeViewMoveCursorCallback            ,
    TreeViewMoveCursorCallback              ,
    TreeViewMoveCursorSignalInfo            ,
    afterTreeViewMoveCursor                 ,
    genClosure_TreeViewMoveCursor           ,
    mk_TreeViewMoveCursorCallback           ,
    noTreeViewMoveCursorCallback            ,
    onTreeViewMoveCursor                    ,
    wrap_TreeViewMoveCursorCallback         ,


-- ** rowActivated #signal:rowActivated#
    C_TreeViewRowActivatedCallback          ,
    TreeViewRowActivatedCallback            ,
    TreeViewRowActivatedSignalInfo          ,
    afterTreeViewRowActivated               ,
    genClosure_TreeViewRowActivated         ,
    mk_TreeViewRowActivatedCallback         ,
    noTreeViewRowActivatedCallback          ,
    onTreeViewRowActivated                  ,
    wrap_TreeViewRowActivatedCallback       ,


-- ** rowCollapsed #signal:rowCollapsed#
    C_TreeViewRowCollapsedCallback          ,
    TreeViewRowCollapsedCallback            ,
    TreeViewRowCollapsedSignalInfo          ,
    afterTreeViewRowCollapsed               ,
    genClosure_TreeViewRowCollapsed         ,
    mk_TreeViewRowCollapsedCallback         ,
    noTreeViewRowCollapsedCallback          ,
    onTreeViewRowCollapsed                  ,
    wrap_TreeViewRowCollapsedCallback       ,


-- ** rowExpanded #signal:rowExpanded#
    C_TreeViewRowExpandedCallback           ,
    TreeViewRowExpandedCallback             ,
    TreeViewRowExpandedSignalInfo           ,
    afterTreeViewRowExpanded                ,
    genClosure_TreeViewRowExpanded          ,
    mk_TreeViewRowExpandedCallback          ,
    noTreeViewRowExpandedCallback           ,
    onTreeViewRowExpanded                   ,
    wrap_TreeViewRowExpandedCallback        ,


-- ** selectAll #signal:selectAll#
    C_TreeViewSelectAllCallback             ,
    TreeViewSelectAllCallback               ,
    TreeViewSelectAllSignalInfo             ,
    afterTreeViewSelectAll                  ,
    genClosure_TreeViewSelectAll            ,
    mk_TreeViewSelectAllCallback            ,
    noTreeViewSelectAllCallback             ,
    onTreeViewSelectAll                     ,
    wrap_TreeViewSelectAllCallback          ,


-- ** selectCursorParent #signal:selectCursorParent#
    C_TreeViewSelectCursorParentCallback    ,
    TreeViewSelectCursorParentCallback      ,
    TreeViewSelectCursorParentSignalInfo    ,
    afterTreeViewSelectCursorParent         ,
    genClosure_TreeViewSelectCursorParent   ,
    mk_TreeViewSelectCursorParentCallback   ,
    noTreeViewSelectCursorParentCallback    ,
    onTreeViewSelectCursorParent            ,
    wrap_TreeViewSelectCursorParentCallback ,


-- ** selectCursorRow #signal:selectCursorRow#
    C_TreeViewSelectCursorRowCallback       ,
    TreeViewSelectCursorRowCallback         ,
    TreeViewSelectCursorRowSignalInfo       ,
    afterTreeViewSelectCursorRow            ,
    genClosure_TreeViewSelectCursorRow      ,
    mk_TreeViewSelectCursorRowCallback      ,
    noTreeViewSelectCursorRowCallback       ,
    onTreeViewSelectCursorRow               ,
    wrap_TreeViewSelectCursorRowCallback    ,


-- ** startInteractiveSearch #signal:startInteractiveSearch#
    C_TreeViewStartInteractiveSearchCallback,
    TreeViewStartInteractiveSearchCallback  ,
    TreeViewStartInteractiveSearchSignalInfo,
    afterTreeViewStartInteractiveSearch     ,
    genClosure_TreeViewStartInteractiveSearch,
    mk_TreeViewStartInteractiveSearchCallback,
    noTreeViewStartInteractiveSearchCallback,
    onTreeViewStartInteractiveSearch        ,
    wrap_TreeViewStartInteractiveSearchCallback,


-- ** testCollapseRow #signal:testCollapseRow#
    C_TreeViewTestCollapseRowCallback       ,
    TreeViewTestCollapseRowCallback         ,
    TreeViewTestCollapseRowSignalInfo       ,
    afterTreeViewTestCollapseRow            ,
    genClosure_TreeViewTestCollapseRow      ,
    mk_TreeViewTestCollapseRowCallback      ,
    noTreeViewTestCollapseRowCallback       ,
    onTreeViewTestCollapseRow               ,
    wrap_TreeViewTestCollapseRowCallback    ,


-- ** testExpandRow #signal:testExpandRow#
    C_TreeViewTestExpandRowCallback         ,
    TreeViewTestExpandRowCallback           ,
    TreeViewTestExpandRowSignalInfo         ,
    afterTreeViewTestExpandRow              ,
    genClosure_TreeViewTestExpandRow        ,
    mk_TreeViewTestExpandRowCallback        ,
    noTreeViewTestExpandRowCallback         ,
    onTreeViewTestExpandRow                 ,
    wrap_TreeViewTestExpandRowCallback      ,


-- ** toggleCursorRow #signal:toggleCursorRow#
    C_TreeViewToggleCursorRowCallback       ,
    TreeViewToggleCursorRowCallback         ,
    TreeViewToggleCursorRowSignalInfo       ,
    afterTreeViewToggleCursorRow            ,
    genClosure_TreeViewToggleCursorRow      ,
    mk_TreeViewToggleCursorRowCallback      ,
    noTreeViewToggleCursorRowCallback       ,
    onTreeViewToggleCursorRow               ,
    wrap_TreeViewToggleCursorRowCallback    ,


-- ** unselectAll #signal:unselectAll#
    C_TreeViewUnselectAllCallback           ,
    TreeViewUnselectAllCallback             ,
    TreeViewUnselectAllSignalInfo           ,
    afterTreeViewUnselectAll                ,
    genClosure_TreeViewUnselectAll          ,
    mk_TreeViewUnselectAllCallback          ,
    noTreeViewUnselectAllCallback           ,
    onTreeViewUnselectAll                   ,
    wrap_TreeViewUnselectAllCallback        ,




    ) where

import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP

import qualified GI.Atk.Interfaces.ImplementorIface as Atk.ImplementorIface
import qualified GI.Cairo.Structs.Surface as Cairo.Surface
import qualified GI.GLib.Callbacks as GLib.Callbacks
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gdk.Flags as Gdk.Flags
import qualified GI.Gdk.Objects.Window as Gdk.Window
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.Scrollable as Gtk.Scrollable
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.TreeModel as Gtk.TreeModel
import {-# SOURCE #-} qualified GI.Gtk.Objects.Adjustment as Gtk.Adjustment
import {-# SOURCE #-} qualified GI.Gtk.Objects.CellRenderer as Gtk.CellRenderer
import {-# SOURCE #-} qualified GI.Gtk.Objects.Container as Gtk.Container
import {-# SOURCE #-} qualified GI.Gtk.Objects.Entry as Gtk.Entry
import {-# SOURCE #-} qualified GI.Gtk.Objects.Tooltip as Gtk.Tooltip
import {-# SOURCE #-} qualified GI.Gtk.Objects.TreeSelection as Gtk.TreeSelection
import {-# SOURCE #-} qualified GI.Gtk.Objects.TreeViewColumn as Gtk.TreeViewColumn
import {-# SOURCE #-} qualified GI.Gtk.Objects.Widget as Gtk.Widget
import {-# SOURCE #-} qualified GI.Gtk.Structs.TargetEntry as Gtk.TargetEntry
import {-# SOURCE #-} qualified GI.Gtk.Structs.TreeIter as Gtk.TreeIter
import {-# SOURCE #-} qualified GI.Gtk.Structs.TreePath as Gtk.TreePath

newtype TreeView = TreeView (ManagedPtr TreeView)
foreign import ccall "gtk_tree_view_get_type"
    c_gtk_tree_view_get_type :: IO GType

instance GObject TreeView where
    gobjectType _ = c_gtk_tree_view_get_type
    

class GObject o => IsTreeView o
#if MIN_VERSION_base(4,9,0)
instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError TreeView a) =>
    IsTreeView a
#endif
instance IsTreeView TreeView
instance Gtk.Container.IsContainer TreeView
instance Gtk.Widget.IsWidget TreeView
instance GObject.Object.IsObject TreeView
instance Atk.ImplementorIface.IsImplementorIface TreeView
instance Gtk.Buildable.IsBuildable TreeView
instance Gtk.Scrollable.IsScrollable TreeView

toTreeView :: IsTreeView o => o -> IO TreeView
toTreeView = unsafeCastTo TreeView

noTreeView :: Maybe TreeView
noTreeView = Nothing

type family ResolveTreeViewMethod (t :: Symbol) (o :: *) :: * where
    ResolveTreeViewMethod "activate" o = Gtk.Widget.WidgetActivateMethodInfo
    ResolveTreeViewMethod "add" o = Gtk.Container.ContainerAddMethodInfo
    ResolveTreeViewMethod "addAccelerator" o = Gtk.Widget.WidgetAddAcceleratorMethodInfo
    ResolveTreeViewMethod "addChild" o = Gtk.Buildable.BuildableAddChildMethodInfo
    ResolveTreeViewMethod "addDeviceEvents" o = Gtk.Widget.WidgetAddDeviceEventsMethodInfo
    ResolveTreeViewMethod "addEvents" o = Gtk.Widget.WidgetAddEventsMethodInfo
    ResolveTreeViewMethod "addMnemonicLabel" o = Gtk.Widget.WidgetAddMnemonicLabelMethodInfo
    ResolveTreeViewMethod "addTickCallback" o = Gtk.Widget.WidgetAddTickCallbackMethodInfo
    ResolveTreeViewMethod "appendColumn" o = TreeViewAppendColumnMethodInfo
    ResolveTreeViewMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveTreeViewMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveTreeViewMethod "canActivateAccel" o = Gtk.Widget.WidgetCanActivateAccelMethodInfo
    ResolveTreeViewMethod "checkResize" o = Gtk.Container.ContainerCheckResizeMethodInfo
    ResolveTreeViewMethod "childFocus" o = Gtk.Widget.WidgetChildFocusMethodInfo
    ResolveTreeViewMethod "childGetProperty" o = Gtk.Container.ContainerChildGetPropertyMethodInfo
    ResolveTreeViewMethod "childNotify" o = Gtk.Container.ContainerChildNotifyMethodInfo
    ResolveTreeViewMethod "childNotifyByPspec" o = Gtk.Container.ContainerChildNotifyByPspecMethodInfo
    ResolveTreeViewMethod "childSetProperty" o = Gtk.Container.ContainerChildSetPropertyMethodInfo
    ResolveTreeViewMethod "childType" o = Gtk.Container.ContainerChildTypeMethodInfo
    ResolveTreeViewMethod "classPath" o = Gtk.Widget.WidgetClassPathMethodInfo
    ResolveTreeViewMethod "collapseAll" o = TreeViewCollapseAllMethodInfo
    ResolveTreeViewMethod "collapseRow" o = TreeViewCollapseRowMethodInfo
    ResolveTreeViewMethod "columnsAutosize" o = TreeViewColumnsAutosizeMethodInfo
    ResolveTreeViewMethod "computeExpand" o = Gtk.Widget.WidgetComputeExpandMethodInfo
    ResolveTreeViewMethod "constructChild" o = Gtk.Buildable.BuildableConstructChildMethodInfo
    ResolveTreeViewMethod "convertBinWindowToTreeCoords" o = TreeViewConvertBinWindowToTreeCoordsMethodInfo
    ResolveTreeViewMethod "convertBinWindowToWidgetCoords" o = TreeViewConvertBinWindowToWidgetCoordsMethodInfo
    ResolveTreeViewMethod "convertTreeToBinWindowCoords" o = TreeViewConvertTreeToBinWindowCoordsMethodInfo
    ResolveTreeViewMethod "convertTreeToWidgetCoords" o = TreeViewConvertTreeToWidgetCoordsMethodInfo
    ResolveTreeViewMethod "convertWidgetToBinWindowCoords" o = TreeViewConvertWidgetToBinWindowCoordsMethodInfo
    ResolveTreeViewMethod "convertWidgetToTreeCoords" o = TreeViewConvertWidgetToTreeCoordsMethodInfo
    ResolveTreeViewMethod "createPangoContext" o = Gtk.Widget.WidgetCreatePangoContextMethodInfo
    ResolveTreeViewMethod "createPangoLayout" o = Gtk.Widget.WidgetCreatePangoLayoutMethodInfo
    ResolveTreeViewMethod "createRowDragIcon" o = TreeViewCreateRowDragIconMethodInfo
    ResolveTreeViewMethod "customFinished" o = Gtk.Buildable.BuildableCustomFinishedMethodInfo
    ResolveTreeViewMethod "customTagEnd" o = Gtk.Buildable.BuildableCustomTagEndMethodInfo
    ResolveTreeViewMethod "customTagStart" o = Gtk.Buildable.BuildableCustomTagStartMethodInfo
    ResolveTreeViewMethod "destroy" o = Gtk.Widget.WidgetDestroyMethodInfo
    ResolveTreeViewMethod "destroyed" o = Gtk.Widget.WidgetDestroyedMethodInfo
    ResolveTreeViewMethod "deviceIsShadowed" o = Gtk.Widget.WidgetDeviceIsShadowedMethodInfo
    ResolveTreeViewMethod "dragBegin" o = Gtk.Widget.WidgetDragBeginMethodInfo
    ResolveTreeViewMethod "dragBeginWithCoordinates" o = Gtk.Widget.WidgetDragBeginWithCoordinatesMethodInfo
    ResolveTreeViewMethod "dragCheckThreshold" o = Gtk.Widget.WidgetDragCheckThresholdMethodInfo
    ResolveTreeViewMethod "dragDestAddImageTargets" o = Gtk.Widget.WidgetDragDestAddImageTargetsMethodInfo
    ResolveTreeViewMethod "dragDestAddTextTargets" o = Gtk.Widget.WidgetDragDestAddTextTargetsMethodInfo
    ResolveTreeViewMethod "dragDestAddUriTargets" o = Gtk.Widget.WidgetDragDestAddUriTargetsMethodInfo
    ResolveTreeViewMethod "dragDestFindTarget" o = Gtk.Widget.WidgetDragDestFindTargetMethodInfo
    ResolveTreeViewMethod "dragDestGetTargetList" o = Gtk.Widget.WidgetDragDestGetTargetListMethodInfo
    ResolveTreeViewMethod "dragDestGetTrackMotion" o = Gtk.Widget.WidgetDragDestGetTrackMotionMethodInfo
    ResolveTreeViewMethod "dragDestSet" o = Gtk.Widget.WidgetDragDestSetMethodInfo
    ResolveTreeViewMethod "dragDestSetProxy" o = Gtk.Widget.WidgetDragDestSetProxyMethodInfo
    ResolveTreeViewMethod "dragDestSetTargetList" o = Gtk.Widget.WidgetDragDestSetTargetListMethodInfo
    ResolveTreeViewMethod "dragDestSetTrackMotion" o = Gtk.Widget.WidgetDragDestSetTrackMotionMethodInfo
    ResolveTreeViewMethod "dragDestUnset" o = Gtk.Widget.WidgetDragDestUnsetMethodInfo
    ResolveTreeViewMethod "dragGetData" o = Gtk.Widget.WidgetDragGetDataMethodInfo
    ResolveTreeViewMethod "dragHighlight" o = Gtk.Widget.WidgetDragHighlightMethodInfo
    ResolveTreeViewMethod "dragSourceAddImageTargets" o = Gtk.Widget.WidgetDragSourceAddImageTargetsMethodInfo
    ResolveTreeViewMethod "dragSourceAddTextTargets" o = Gtk.Widget.WidgetDragSourceAddTextTargetsMethodInfo
    ResolveTreeViewMethod "dragSourceAddUriTargets" o = Gtk.Widget.WidgetDragSourceAddUriTargetsMethodInfo
    ResolveTreeViewMethod "dragSourceGetTargetList" o = Gtk.Widget.WidgetDragSourceGetTargetListMethodInfo
    ResolveTreeViewMethod "dragSourceSet" o = Gtk.Widget.WidgetDragSourceSetMethodInfo
    ResolveTreeViewMethod "dragSourceSetIconGicon" o = Gtk.Widget.WidgetDragSourceSetIconGiconMethodInfo
    ResolveTreeViewMethod "dragSourceSetIconName" o = Gtk.Widget.WidgetDragSourceSetIconNameMethodInfo
    ResolveTreeViewMethod "dragSourceSetIconPixbuf" o = Gtk.Widget.WidgetDragSourceSetIconPixbufMethodInfo
    ResolveTreeViewMethod "dragSourceSetIconStock" o = Gtk.Widget.WidgetDragSourceSetIconStockMethodInfo
    ResolveTreeViewMethod "dragSourceSetTargetList" o = Gtk.Widget.WidgetDragSourceSetTargetListMethodInfo
    ResolveTreeViewMethod "dragSourceUnset" o = Gtk.Widget.WidgetDragSourceUnsetMethodInfo
    ResolveTreeViewMethod "dragUnhighlight" o = Gtk.Widget.WidgetDragUnhighlightMethodInfo
    ResolveTreeViewMethod "draw" o = Gtk.Widget.WidgetDrawMethodInfo
    ResolveTreeViewMethod "enableModelDragDest" o = TreeViewEnableModelDragDestMethodInfo
    ResolveTreeViewMethod "enableModelDragSource" o = TreeViewEnableModelDragSourceMethodInfo
    ResolveTreeViewMethod "ensureStyle" o = Gtk.Widget.WidgetEnsureStyleMethodInfo
    ResolveTreeViewMethod "errorBell" o = Gtk.Widget.WidgetErrorBellMethodInfo
    ResolveTreeViewMethod "event" o = Gtk.Widget.WidgetEventMethodInfo
    ResolveTreeViewMethod "expandAll" o = TreeViewExpandAllMethodInfo
    ResolveTreeViewMethod "expandRow" o = TreeViewExpandRowMethodInfo
    ResolveTreeViewMethod "expandToPath" o = TreeViewExpandToPathMethodInfo
    ResolveTreeViewMethod "forall" o = Gtk.Container.ContainerForallMethodInfo
    ResolveTreeViewMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveTreeViewMethod "foreach" o = Gtk.Container.ContainerForeachMethodInfo
    ResolveTreeViewMethod "freezeChildNotify" o = Gtk.Widget.WidgetFreezeChildNotifyMethodInfo
    ResolveTreeViewMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveTreeViewMethod "grabAdd" o = Gtk.Widget.WidgetGrabAddMethodInfo
    ResolveTreeViewMethod "grabDefault" o = Gtk.Widget.WidgetGrabDefaultMethodInfo
    ResolveTreeViewMethod "grabFocus" o = Gtk.Widget.WidgetGrabFocusMethodInfo
    ResolveTreeViewMethod "grabRemove" o = Gtk.Widget.WidgetGrabRemoveMethodInfo
    ResolveTreeViewMethod "hasDefault" o = Gtk.Widget.WidgetHasDefaultMethodInfo
    ResolveTreeViewMethod "hasFocus" o = Gtk.Widget.WidgetHasFocusMethodInfo
    ResolveTreeViewMethod "hasGrab" o = Gtk.Widget.WidgetHasGrabMethodInfo
    ResolveTreeViewMethod "hasRcStyle" o = Gtk.Widget.WidgetHasRcStyleMethodInfo
    ResolveTreeViewMethod "hasScreen" o = Gtk.Widget.WidgetHasScreenMethodInfo
    ResolveTreeViewMethod "hasVisibleFocus" o = Gtk.Widget.WidgetHasVisibleFocusMethodInfo
    ResolveTreeViewMethod "hide" o = Gtk.Widget.WidgetHideMethodInfo
    ResolveTreeViewMethod "hideOnDelete" o = Gtk.Widget.WidgetHideOnDeleteMethodInfo
    ResolveTreeViewMethod "inDestruction" o = Gtk.Widget.WidgetInDestructionMethodInfo
    ResolveTreeViewMethod "initTemplate" o = Gtk.Widget.WidgetInitTemplateMethodInfo
    ResolveTreeViewMethod "inputShapeCombineRegion" o = Gtk.Widget.WidgetInputShapeCombineRegionMethodInfo
    ResolveTreeViewMethod "insertActionGroup" o = Gtk.Widget.WidgetInsertActionGroupMethodInfo
    ResolveTreeViewMethod "insertColumn" o = TreeViewInsertColumnMethodInfo
    ResolveTreeViewMethod "insertColumnWithDataFunc" o = TreeViewInsertColumnWithDataFuncMethodInfo
    ResolveTreeViewMethod "intersect" o = Gtk.Widget.WidgetIntersectMethodInfo
    ResolveTreeViewMethod "isAncestor" o = Gtk.Widget.WidgetIsAncestorMethodInfo
    ResolveTreeViewMethod "isBlankAtPos" o = TreeViewIsBlankAtPosMethodInfo
    ResolveTreeViewMethod "isComposited" o = Gtk.Widget.WidgetIsCompositedMethodInfo
    ResolveTreeViewMethod "isDrawable" o = Gtk.Widget.WidgetIsDrawableMethodInfo
    ResolveTreeViewMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveTreeViewMethod "isFocus" o = Gtk.Widget.WidgetIsFocusMethodInfo
    ResolveTreeViewMethod "isRubberBandingActive" o = TreeViewIsRubberBandingActiveMethodInfo
    ResolveTreeViewMethod "isSensitive" o = Gtk.Widget.WidgetIsSensitiveMethodInfo
    ResolveTreeViewMethod "isToplevel" o = Gtk.Widget.WidgetIsToplevelMethodInfo
    ResolveTreeViewMethod "isVisible" o = Gtk.Widget.WidgetIsVisibleMethodInfo
    ResolveTreeViewMethod "keynavFailed" o = Gtk.Widget.WidgetKeynavFailedMethodInfo
    ResolveTreeViewMethod "listAccelClosures" o = Gtk.Widget.WidgetListAccelClosuresMethodInfo
    ResolveTreeViewMethod "listActionPrefixes" o = Gtk.Widget.WidgetListActionPrefixesMethodInfo
    ResolveTreeViewMethod "listMnemonicLabels" o = Gtk.Widget.WidgetListMnemonicLabelsMethodInfo
    ResolveTreeViewMethod "map" o = Gtk.Widget.WidgetMapMethodInfo
    ResolveTreeViewMethod "mapExpandedRows" o = TreeViewMapExpandedRowsMethodInfo
    ResolveTreeViewMethod "mnemonicActivate" o = Gtk.Widget.WidgetMnemonicActivateMethodInfo
    ResolveTreeViewMethod "modifyBase" o = Gtk.Widget.WidgetModifyBaseMethodInfo
    ResolveTreeViewMethod "modifyBg" o = Gtk.Widget.WidgetModifyBgMethodInfo
    ResolveTreeViewMethod "modifyCursor" o = Gtk.Widget.WidgetModifyCursorMethodInfo
    ResolveTreeViewMethod "modifyFg" o = Gtk.Widget.WidgetModifyFgMethodInfo
    ResolveTreeViewMethod "modifyFont" o = Gtk.Widget.WidgetModifyFontMethodInfo
    ResolveTreeViewMethod "modifyStyle" o = Gtk.Widget.WidgetModifyStyleMethodInfo
    ResolveTreeViewMethod "modifyText" o = Gtk.Widget.WidgetModifyTextMethodInfo
    ResolveTreeViewMethod "moveColumnAfter" o = TreeViewMoveColumnAfterMethodInfo
    ResolveTreeViewMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveTreeViewMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveTreeViewMethod "overrideBackgroundColor" o = Gtk.Widget.WidgetOverrideBackgroundColorMethodInfo
    ResolveTreeViewMethod "overrideColor" o = Gtk.Widget.WidgetOverrideColorMethodInfo
    ResolveTreeViewMethod "overrideCursor" o = Gtk.Widget.WidgetOverrideCursorMethodInfo
    ResolveTreeViewMethod "overrideFont" o = Gtk.Widget.WidgetOverrideFontMethodInfo
    ResolveTreeViewMethod "overrideSymbolicColor" o = Gtk.Widget.WidgetOverrideSymbolicColorMethodInfo
    ResolveTreeViewMethod "parserFinished" o = Gtk.Buildable.BuildableParserFinishedMethodInfo
    ResolveTreeViewMethod "path" o = Gtk.Widget.WidgetPathMethodInfo
    ResolveTreeViewMethod "propagateDraw" o = Gtk.Container.ContainerPropagateDrawMethodInfo
    ResolveTreeViewMethod "queueAllocate" o = Gtk.Widget.WidgetQueueAllocateMethodInfo
    ResolveTreeViewMethod "queueComputeExpand" o = Gtk.Widget.WidgetQueueComputeExpandMethodInfo
    ResolveTreeViewMethod "queueDraw" o = Gtk.Widget.WidgetQueueDrawMethodInfo
    ResolveTreeViewMethod "queueDrawArea" o = Gtk.Widget.WidgetQueueDrawAreaMethodInfo
    ResolveTreeViewMethod "queueDrawRegion" o = Gtk.Widget.WidgetQueueDrawRegionMethodInfo
    ResolveTreeViewMethod "queueResize" o = Gtk.Widget.WidgetQueueResizeMethodInfo
    ResolveTreeViewMethod "queueResizeNoRedraw" o = Gtk.Widget.WidgetQueueResizeNoRedrawMethodInfo
    ResolveTreeViewMethod "realize" o = Gtk.Widget.WidgetRealizeMethodInfo
    ResolveTreeViewMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveTreeViewMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveTreeViewMethod "regionIntersect" o = Gtk.Widget.WidgetRegionIntersectMethodInfo
    ResolveTreeViewMethod "registerWindow" o = Gtk.Widget.WidgetRegisterWindowMethodInfo
    ResolveTreeViewMethod "remove" o = Gtk.Container.ContainerRemoveMethodInfo
    ResolveTreeViewMethod "removeAccelerator" o = Gtk.Widget.WidgetRemoveAcceleratorMethodInfo
    ResolveTreeViewMethod "removeColumn" o = TreeViewRemoveColumnMethodInfo
    ResolveTreeViewMethod "removeMnemonicLabel" o = Gtk.Widget.WidgetRemoveMnemonicLabelMethodInfo
    ResolveTreeViewMethod "removeTickCallback" o = Gtk.Widget.WidgetRemoveTickCallbackMethodInfo
    ResolveTreeViewMethod "renderIcon" o = Gtk.Widget.WidgetRenderIconMethodInfo
    ResolveTreeViewMethod "renderIconPixbuf" o = Gtk.Widget.WidgetRenderIconPixbufMethodInfo
    ResolveTreeViewMethod "reparent" o = Gtk.Widget.WidgetReparentMethodInfo
    ResolveTreeViewMethod "replaceData" o = GObject.Object.ObjectReplaceDataMethodInfo
    ResolveTreeViewMethod "replaceQdata" o = GObject.Object.ObjectReplaceQdataMethodInfo
    ResolveTreeViewMethod "resetRcStyles" o = Gtk.Widget.WidgetResetRcStylesMethodInfo
    ResolveTreeViewMethod "resetStyle" o = Gtk.Widget.WidgetResetStyleMethodInfo
    ResolveTreeViewMethod "resizeChildren" o = Gtk.Container.ContainerResizeChildrenMethodInfo
    ResolveTreeViewMethod "rowActivated" o = TreeViewRowActivatedMethodInfo
    ResolveTreeViewMethod "rowExpanded" o = TreeViewRowExpandedMethodInfo
    ResolveTreeViewMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveTreeViewMethod "scrollToCell" o = TreeViewScrollToCellMethodInfo
    ResolveTreeViewMethod "scrollToPoint" o = TreeViewScrollToPointMethodInfo
    ResolveTreeViewMethod "sendExpose" o = Gtk.Widget.WidgetSendExposeMethodInfo
    ResolveTreeViewMethod "sendFocusChange" o = Gtk.Widget.WidgetSendFocusChangeMethodInfo
    ResolveTreeViewMethod "shapeCombineRegion" o = Gtk.Widget.WidgetShapeCombineRegionMethodInfo
    ResolveTreeViewMethod "show" o = Gtk.Widget.WidgetShowMethodInfo
    ResolveTreeViewMethod "showAll" o = Gtk.Widget.WidgetShowAllMethodInfo
    ResolveTreeViewMethod "showNow" o = Gtk.Widget.WidgetShowNowMethodInfo
    ResolveTreeViewMethod "sizeAllocate" o = Gtk.Widget.WidgetSizeAllocateMethodInfo
    ResolveTreeViewMethod "sizeAllocateWithBaseline" o = Gtk.Widget.WidgetSizeAllocateWithBaselineMethodInfo
    ResolveTreeViewMethod "sizeRequest" o = Gtk.Widget.WidgetSizeRequestMethodInfo
    ResolveTreeViewMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveTreeViewMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveTreeViewMethod "styleAttach" o = Gtk.Widget.WidgetStyleAttachMethodInfo
    ResolveTreeViewMethod "styleGetProperty" o = Gtk.Widget.WidgetStyleGetPropertyMethodInfo
    ResolveTreeViewMethod "thawChildNotify" o = Gtk.Widget.WidgetThawChildNotifyMethodInfo
    ResolveTreeViewMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveTreeViewMethod "translateCoordinates" o = Gtk.Widget.WidgetTranslateCoordinatesMethodInfo
    ResolveTreeViewMethod "triggerTooltipQuery" o = Gtk.Widget.WidgetTriggerTooltipQueryMethodInfo
    ResolveTreeViewMethod "unmap" o = Gtk.Widget.WidgetUnmapMethodInfo
    ResolveTreeViewMethod "unparent" o = Gtk.Widget.WidgetUnparentMethodInfo
    ResolveTreeViewMethod "unrealize" o = Gtk.Widget.WidgetUnrealizeMethodInfo
    ResolveTreeViewMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveTreeViewMethod "unregisterWindow" o = Gtk.Widget.WidgetUnregisterWindowMethodInfo
    ResolveTreeViewMethod "unsetFocusChain" o = Gtk.Container.ContainerUnsetFocusChainMethodInfo
    ResolveTreeViewMethod "unsetRowsDragDest" o = TreeViewUnsetRowsDragDestMethodInfo
    ResolveTreeViewMethod "unsetRowsDragSource" o = TreeViewUnsetRowsDragSourceMethodInfo
    ResolveTreeViewMethod "unsetStateFlags" o = Gtk.Widget.WidgetUnsetStateFlagsMethodInfo
    ResolveTreeViewMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveTreeViewMethod "getAccessible" o = Gtk.Widget.WidgetGetAccessibleMethodInfo
    ResolveTreeViewMethod "getActionGroup" o = Gtk.Widget.WidgetGetActionGroupMethodInfo
    ResolveTreeViewMethod "getActivateOnSingleClick" o = TreeViewGetActivateOnSingleClickMethodInfo
    ResolveTreeViewMethod "getAllocatedBaseline" o = Gtk.Widget.WidgetGetAllocatedBaselineMethodInfo
    ResolveTreeViewMethod "getAllocatedHeight" o = Gtk.Widget.WidgetGetAllocatedHeightMethodInfo
    ResolveTreeViewMethod "getAllocatedSize" o = Gtk.Widget.WidgetGetAllocatedSizeMethodInfo
    ResolveTreeViewMethod "getAllocatedWidth" o = Gtk.Widget.WidgetGetAllocatedWidthMethodInfo
    ResolveTreeViewMethod "getAllocation" o = Gtk.Widget.WidgetGetAllocationMethodInfo
    ResolveTreeViewMethod "getAncestor" o = Gtk.Widget.WidgetGetAncestorMethodInfo
    ResolveTreeViewMethod "getAppPaintable" o = Gtk.Widget.WidgetGetAppPaintableMethodInfo
    ResolveTreeViewMethod "getBackgroundArea" o = TreeViewGetBackgroundAreaMethodInfo
    ResolveTreeViewMethod "getBinWindow" o = TreeViewGetBinWindowMethodInfo
    ResolveTreeViewMethod "getBorder" o = Gtk.Scrollable.ScrollableGetBorderMethodInfo
    ResolveTreeViewMethod "getBorderWidth" o = Gtk.Container.ContainerGetBorderWidthMethodInfo
    ResolveTreeViewMethod "getCanDefault" o = Gtk.Widget.WidgetGetCanDefaultMethodInfo
    ResolveTreeViewMethod "getCanFocus" o = Gtk.Widget.WidgetGetCanFocusMethodInfo
    ResolveTreeViewMethod "getCellArea" o = TreeViewGetCellAreaMethodInfo
    ResolveTreeViewMethod "getChildRequisition" o = Gtk.Widget.WidgetGetChildRequisitionMethodInfo
    ResolveTreeViewMethod "getChildVisible" o = Gtk.Widget.WidgetGetChildVisibleMethodInfo
    ResolveTreeViewMethod "getChildren" o = Gtk.Container.ContainerGetChildrenMethodInfo
    ResolveTreeViewMethod "getClip" o = Gtk.Widget.WidgetGetClipMethodInfo
    ResolveTreeViewMethod "getClipboard" o = Gtk.Widget.WidgetGetClipboardMethodInfo
    ResolveTreeViewMethod "getColumn" o = TreeViewGetColumnMethodInfo
    ResolveTreeViewMethod "getColumns" o = TreeViewGetColumnsMethodInfo
    ResolveTreeViewMethod "getCompositeName" o = Gtk.Widget.WidgetGetCompositeNameMethodInfo
    ResolveTreeViewMethod "getCursor" o = TreeViewGetCursorMethodInfo
    ResolveTreeViewMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveTreeViewMethod "getDestRowAtPos" o = TreeViewGetDestRowAtPosMethodInfo
    ResolveTreeViewMethod "getDeviceEnabled" o = Gtk.Widget.WidgetGetDeviceEnabledMethodInfo
    ResolveTreeViewMethod "getDeviceEvents" o = Gtk.Widget.WidgetGetDeviceEventsMethodInfo
    ResolveTreeViewMethod "getDirection" o = Gtk.Widget.WidgetGetDirectionMethodInfo
    ResolveTreeViewMethod "getDisplay" o = Gtk.Widget.WidgetGetDisplayMethodInfo
    ResolveTreeViewMethod "getDoubleBuffered" o = Gtk.Widget.WidgetGetDoubleBufferedMethodInfo
    ResolveTreeViewMethod "getDragDestRow" o = TreeViewGetDragDestRowMethodInfo
    ResolveTreeViewMethod "getEnableSearch" o = TreeViewGetEnableSearchMethodInfo
    ResolveTreeViewMethod "getEnableTreeLines" o = TreeViewGetEnableTreeLinesMethodInfo
    ResolveTreeViewMethod "getEvents" o = Gtk.Widget.WidgetGetEventsMethodInfo
    ResolveTreeViewMethod "getExpanderColumn" o = TreeViewGetExpanderColumnMethodInfo
    ResolveTreeViewMethod "getFixedHeightMode" o = TreeViewGetFixedHeightModeMethodInfo
    ResolveTreeViewMethod "getFocusChain" o = Gtk.Container.ContainerGetFocusChainMethodInfo
    ResolveTreeViewMethod "getFocusChild" o = Gtk.Container.ContainerGetFocusChildMethodInfo
    ResolveTreeViewMethod "getFocusHadjustment" o = Gtk.Container.ContainerGetFocusHadjustmentMethodInfo
    ResolveTreeViewMethod "getFocusOnClick" o = Gtk.Widget.WidgetGetFocusOnClickMethodInfo
    ResolveTreeViewMethod "getFocusVadjustment" o = Gtk.Container.ContainerGetFocusVadjustmentMethodInfo
    ResolveTreeViewMethod "getFontMap" o = Gtk.Widget.WidgetGetFontMapMethodInfo
    ResolveTreeViewMethod "getFontOptions" o = Gtk.Widget.WidgetGetFontOptionsMethodInfo
    ResolveTreeViewMethod "getFrameClock" o = Gtk.Widget.WidgetGetFrameClockMethodInfo
    ResolveTreeViewMethod "getGridLines" o = TreeViewGetGridLinesMethodInfo
    ResolveTreeViewMethod "getHadjustment" o = TreeViewGetHadjustmentMethodInfo
    ResolveTreeViewMethod "getHalign" o = Gtk.Widget.WidgetGetHalignMethodInfo
    ResolveTreeViewMethod "getHasTooltip" o = Gtk.Widget.WidgetGetHasTooltipMethodInfo
    ResolveTreeViewMethod "getHasWindow" o = Gtk.Widget.WidgetGetHasWindowMethodInfo
    ResolveTreeViewMethod "getHeadersClickable" o = TreeViewGetHeadersClickableMethodInfo
    ResolveTreeViewMethod "getHeadersVisible" o = TreeViewGetHeadersVisibleMethodInfo
    ResolveTreeViewMethod "getHexpand" o = Gtk.Widget.WidgetGetHexpandMethodInfo
    ResolveTreeViewMethod "getHexpandSet" o = Gtk.Widget.WidgetGetHexpandSetMethodInfo
    ResolveTreeViewMethod "getHoverExpand" o = TreeViewGetHoverExpandMethodInfo
    ResolveTreeViewMethod "getHoverSelection" o = TreeViewGetHoverSelectionMethodInfo
    ResolveTreeViewMethod "getHscrollPolicy" o = Gtk.Scrollable.ScrollableGetHscrollPolicyMethodInfo
    ResolveTreeViewMethod "getInternalChild" o = Gtk.Buildable.BuildableGetInternalChildMethodInfo
    ResolveTreeViewMethod "getLevelIndentation" o = TreeViewGetLevelIndentationMethodInfo
    ResolveTreeViewMethod "getMapped" o = Gtk.Widget.WidgetGetMappedMethodInfo
    ResolveTreeViewMethod "getMarginBottom" o = Gtk.Widget.WidgetGetMarginBottomMethodInfo
    ResolveTreeViewMethod "getMarginEnd" o = Gtk.Widget.WidgetGetMarginEndMethodInfo
    ResolveTreeViewMethod "getMarginLeft" o = Gtk.Widget.WidgetGetMarginLeftMethodInfo
    ResolveTreeViewMethod "getMarginRight" o = Gtk.Widget.WidgetGetMarginRightMethodInfo
    ResolveTreeViewMethod "getMarginStart" o = Gtk.Widget.WidgetGetMarginStartMethodInfo
    ResolveTreeViewMethod "getMarginTop" o = Gtk.Widget.WidgetGetMarginTopMethodInfo
    ResolveTreeViewMethod "getModel" o = TreeViewGetModelMethodInfo
    ResolveTreeViewMethod "getModifierMask" o = Gtk.Widget.WidgetGetModifierMaskMethodInfo
    ResolveTreeViewMethod "getModifierStyle" o = Gtk.Widget.WidgetGetModifierStyleMethodInfo
    ResolveTreeViewMethod "getNColumns" o = TreeViewGetNColumnsMethodInfo
    ResolveTreeViewMethod "getName" o = Gtk.Widget.WidgetGetNameMethodInfo
    ResolveTreeViewMethod "getNoShowAll" o = Gtk.Widget.WidgetGetNoShowAllMethodInfo
    ResolveTreeViewMethod "getOpacity" o = Gtk.Widget.WidgetGetOpacityMethodInfo
    ResolveTreeViewMethod "getPangoContext" o = Gtk.Widget.WidgetGetPangoContextMethodInfo
    ResolveTreeViewMethod "getParent" o = Gtk.Widget.WidgetGetParentMethodInfo
    ResolveTreeViewMethod "getParentWindow" o = Gtk.Widget.WidgetGetParentWindowMethodInfo
    ResolveTreeViewMethod "getPath" o = Gtk.Widget.WidgetGetPathMethodInfo
    ResolveTreeViewMethod "getPathAtPos" o = TreeViewGetPathAtPosMethodInfo
    ResolveTreeViewMethod "getPathForChild" o = Gtk.Container.ContainerGetPathForChildMethodInfo
    ResolveTreeViewMethod "getPointer" o = Gtk.Widget.WidgetGetPointerMethodInfo
    ResolveTreeViewMethod "getPreferredHeight" o = Gtk.Widget.WidgetGetPreferredHeightMethodInfo
    ResolveTreeViewMethod "getPreferredHeightAndBaselineForWidth" o = Gtk.Widget.WidgetGetPreferredHeightAndBaselineForWidthMethodInfo
    ResolveTreeViewMethod "getPreferredHeightForWidth" o = Gtk.Widget.WidgetGetPreferredHeightForWidthMethodInfo
    ResolveTreeViewMethod "getPreferredSize" o = Gtk.Widget.WidgetGetPreferredSizeMethodInfo
    ResolveTreeViewMethod "getPreferredWidth" o = Gtk.Widget.WidgetGetPreferredWidthMethodInfo
    ResolveTreeViewMethod "getPreferredWidthForHeight" o = Gtk.Widget.WidgetGetPreferredWidthForHeightMethodInfo
    ResolveTreeViewMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveTreeViewMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveTreeViewMethod "getRealized" o = Gtk.Widget.WidgetGetRealizedMethodInfo
    ResolveTreeViewMethod "getReceivesDefault" o = Gtk.Widget.WidgetGetReceivesDefaultMethodInfo
    ResolveTreeViewMethod "getReorderable" o = TreeViewGetReorderableMethodInfo
    ResolveTreeViewMethod "getRequestMode" o = Gtk.Widget.WidgetGetRequestModeMethodInfo
    ResolveTreeViewMethod "getRequisition" o = Gtk.Widget.WidgetGetRequisitionMethodInfo
    ResolveTreeViewMethod "getResizeMode" o = Gtk.Container.ContainerGetResizeModeMethodInfo
    ResolveTreeViewMethod "getRootWindow" o = Gtk.Widget.WidgetGetRootWindowMethodInfo
    ResolveTreeViewMethod "getRubberBanding" o = TreeViewGetRubberBandingMethodInfo
    ResolveTreeViewMethod "getRulesHint" o = TreeViewGetRulesHintMethodInfo
    ResolveTreeViewMethod "getScaleFactor" o = Gtk.Widget.WidgetGetScaleFactorMethodInfo
    ResolveTreeViewMethod "getScreen" o = Gtk.Widget.WidgetGetScreenMethodInfo
    ResolveTreeViewMethod "getSearchColumn" o = TreeViewGetSearchColumnMethodInfo
    ResolveTreeViewMethod "getSearchEntry" o = TreeViewGetSearchEntryMethodInfo
    ResolveTreeViewMethod "getSelection" o = TreeViewGetSelectionMethodInfo
    ResolveTreeViewMethod "getSensitive" o = Gtk.Widget.WidgetGetSensitiveMethodInfo
    ResolveTreeViewMethod "getSettings" o = Gtk.Widget.WidgetGetSettingsMethodInfo
    ResolveTreeViewMethod "getShowExpanders" o = TreeViewGetShowExpandersMethodInfo
    ResolveTreeViewMethod "getSizeRequest" o = Gtk.Widget.WidgetGetSizeRequestMethodInfo
    ResolveTreeViewMethod "getState" o = Gtk.Widget.WidgetGetStateMethodInfo
    ResolveTreeViewMethod "getStateFlags" o = Gtk.Widget.WidgetGetStateFlagsMethodInfo
    ResolveTreeViewMethod "getStyle" o = Gtk.Widget.WidgetGetStyleMethodInfo
    ResolveTreeViewMethod "getStyleContext" o = Gtk.Widget.WidgetGetStyleContextMethodInfo
    ResolveTreeViewMethod "getSupportMultidevice" o = Gtk.Widget.WidgetGetSupportMultideviceMethodInfo
    ResolveTreeViewMethod "getTemplateChild" o = Gtk.Widget.WidgetGetTemplateChildMethodInfo
    ResolveTreeViewMethod "getTooltipColumn" o = TreeViewGetTooltipColumnMethodInfo
    ResolveTreeViewMethod "getTooltipContext" o = TreeViewGetTooltipContextMethodInfo
    ResolveTreeViewMethod "getTooltipMarkup" o = Gtk.Widget.WidgetGetTooltipMarkupMethodInfo
    ResolveTreeViewMethod "getTooltipText" o = Gtk.Widget.WidgetGetTooltipTextMethodInfo
    ResolveTreeViewMethod "getTooltipWindow" o = Gtk.Widget.WidgetGetTooltipWindowMethodInfo
    ResolveTreeViewMethod "getToplevel" o = Gtk.Widget.WidgetGetToplevelMethodInfo
    ResolveTreeViewMethod "getVadjustment" o = TreeViewGetVadjustmentMethodInfo
    ResolveTreeViewMethod "getValign" o = Gtk.Widget.WidgetGetValignMethodInfo
    ResolveTreeViewMethod "getValignWithBaseline" o = Gtk.Widget.WidgetGetValignWithBaselineMethodInfo
    ResolveTreeViewMethod "getVexpand" o = Gtk.Widget.WidgetGetVexpandMethodInfo
    ResolveTreeViewMethod "getVexpandSet" o = Gtk.Widget.WidgetGetVexpandSetMethodInfo
    ResolveTreeViewMethod "getVisible" o = Gtk.Widget.WidgetGetVisibleMethodInfo
    ResolveTreeViewMethod "getVisibleRange" o = TreeViewGetVisibleRangeMethodInfo
    ResolveTreeViewMethod "getVisibleRect" o = TreeViewGetVisibleRectMethodInfo
    ResolveTreeViewMethod "getVisual" o = Gtk.Widget.WidgetGetVisualMethodInfo
    ResolveTreeViewMethod "getVscrollPolicy" o = Gtk.Scrollable.ScrollableGetVscrollPolicyMethodInfo
    ResolveTreeViewMethod "getWindow" o = Gtk.Widget.WidgetGetWindowMethodInfo
    ResolveTreeViewMethod "setAccelPath" o = Gtk.Widget.WidgetSetAccelPathMethodInfo
    ResolveTreeViewMethod "setActivateOnSingleClick" o = TreeViewSetActivateOnSingleClickMethodInfo
    ResolveTreeViewMethod "setAllocation" o = Gtk.Widget.WidgetSetAllocationMethodInfo
    ResolveTreeViewMethod "setAppPaintable" o = Gtk.Widget.WidgetSetAppPaintableMethodInfo
    ResolveTreeViewMethod "setBorderWidth" o = Gtk.Container.ContainerSetBorderWidthMethodInfo
    ResolveTreeViewMethod "setBuildableProperty" o = Gtk.Buildable.BuildableSetBuildablePropertyMethodInfo
    ResolveTreeViewMethod "setCanDefault" o = Gtk.Widget.WidgetSetCanDefaultMethodInfo
    ResolveTreeViewMethod "setCanFocus" o = Gtk.Widget.WidgetSetCanFocusMethodInfo
    ResolveTreeViewMethod "setChildVisible" o = Gtk.Widget.WidgetSetChildVisibleMethodInfo
    ResolveTreeViewMethod "setClip" o = Gtk.Widget.WidgetSetClipMethodInfo
    ResolveTreeViewMethod "setColumnDragFunction" o = TreeViewSetColumnDragFunctionMethodInfo
    ResolveTreeViewMethod "setCompositeName" o = Gtk.Widget.WidgetSetCompositeNameMethodInfo
    ResolveTreeViewMethod "setCursor" o = TreeViewSetCursorMethodInfo
    ResolveTreeViewMethod "setCursorOnCell" o = TreeViewSetCursorOnCellMethodInfo
    ResolveTreeViewMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveTreeViewMethod "setDestroyCountFunc" o = TreeViewSetDestroyCountFuncMethodInfo
    ResolveTreeViewMethod "setDeviceEnabled" o = Gtk.Widget.WidgetSetDeviceEnabledMethodInfo
    ResolveTreeViewMethod "setDeviceEvents" o = Gtk.Widget.WidgetSetDeviceEventsMethodInfo
    ResolveTreeViewMethod "setDirection" o = Gtk.Widget.WidgetSetDirectionMethodInfo
    ResolveTreeViewMethod "setDoubleBuffered" o = Gtk.Widget.WidgetSetDoubleBufferedMethodInfo
    ResolveTreeViewMethod "setDragDestRow" o = TreeViewSetDragDestRowMethodInfo
    ResolveTreeViewMethod "setEnableSearch" o = TreeViewSetEnableSearchMethodInfo
    ResolveTreeViewMethod "setEnableTreeLines" o = TreeViewSetEnableTreeLinesMethodInfo
    ResolveTreeViewMethod "setEvents" o = Gtk.Widget.WidgetSetEventsMethodInfo
    ResolveTreeViewMethod "setExpanderColumn" o = TreeViewSetExpanderColumnMethodInfo
    ResolveTreeViewMethod "setFixedHeightMode" o = TreeViewSetFixedHeightModeMethodInfo
    ResolveTreeViewMethod "setFocusChain" o = Gtk.Container.ContainerSetFocusChainMethodInfo
    ResolveTreeViewMethod "setFocusChild" o = Gtk.Container.ContainerSetFocusChildMethodInfo
    ResolveTreeViewMethod "setFocusHadjustment" o = Gtk.Container.ContainerSetFocusHadjustmentMethodInfo
    ResolveTreeViewMethod "setFocusOnClick" o = Gtk.Widget.WidgetSetFocusOnClickMethodInfo
    ResolveTreeViewMethod "setFocusVadjustment" o = Gtk.Container.ContainerSetFocusVadjustmentMethodInfo
    ResolveTreeViewMethod "setFontMap" o = Gtk.Widget.WidgetSetFontMapMethodInfo
    ResolveTreeViewMethod "setFontOptions" o = Gtk.Widget.WidgetSetFontOptionsMethodInfo
    ResolveTreeViewMethod "setGridLines" o = TreeViewSetGridLinesMethodInfo
    ResolveTreeViewMethod "setHadjustment" o = TreeViewSetHadjustmentMethodInfo
    ResolveTreeViewMethod "setHalign" o = Gtk.Widget.WidgetSetHalignMethodInfo
    ResolveTreeViewMethod "setHasTooltip" o = Gtk.Widget.WidgetSetHasTooltipMethodInfo
    ResolveTreeViewMethod "setHasWindow" o = Gtk.Widget.WidgetSetHasWindowMethodInfo
    ResolveTreeViewMethod "setHeadersClickable" o = TreeViewSetHeadersClickableMethodInfo
    ResolveTreeViewMethod "setHeadersVisible" o = TreeViewSetHeadersVisibleMethodInfo
    ResolveTreeViewMethod "setHexpand" o = Gtk.Widget.WidgetSetHexpandMethodInfo
    ResolveTreeViewMethod "setHexpandSet" o = Gtk.Widget.WidgetSetHexpandSetMethodInfo
    ResolveTreeViewMethod "setHoverExpand" o = TreeViewSetHoverExpandMethodInfo
    ResolveTreeViewMethod "setHoverSelection" o = TreeViewSetHoverSelectionMethodInfo
    ResolveTreeViewMethod "setHscrollPolicy" o = Gtk.Scrollable.ScrollableSetHscrollPolicyMethodInfo
    ResolveTreeViewMethod "setLevelIndentation" o = TreeViewSetLevelIndentationMethodInfo
    ResolveTreeViewMethod "setMapped" o = Gtk.Widget.WidgetSetMappedMethodInfo
    ResolveTreeViewMethod "setMarginBottom" o = Gtk.Widget.WidgetSetMarginBottomMethodInfo
    ResolveTreeViewMethod "setMarginEnd" o = Gtk.Widget.WidgetSetMarginEndMethodInfo
    ResolveTreeViewMethod "setMarginLeft" o = Gtk.Widget.WidgetSetMarginLeftMethodInfo
    ResolveTreeViewMethod "setMarginRight" o = Gtk.Widget.WidgetSetMarginRightMethodInfo
    ResolveTreeViewMethod "setMarginStart" o = Gtk.Widget.WidgetSetMarginStartMethodInfo
    ResolveTreeViewMethod "setMarginTop" o = Gtk.Widget.WidgetSetMarginTopMethodInfo
    ResolveTreeViewMethod "setModel" o = TreeViewSetModelMethodInfo
    ResolveTreeViewMethod "setName" o = Gtk.Widget.WidgetSetNameMethodInfo
    ResolveTreeViewMethod "setNoShowAll" o = Gtk.Widget.WidgetSetNoShowAllMethodInfo
    ResolveTreeViewMethod "setOpacity" o = Gtk.Widget.WidgetSetOpacityMethodInfo
    ResolveTreeViewMethod "setParent" o = Gtk.Widget.WidgetSetParentMethodInfo
    ResolveTreeViewMethod "setParentWindow" o = Gtk.Widget.WidgetSetParentWindowMethodInfo
    ResolveTreeViewMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveTreeViewMethod "setRealized" o = Gtk.Widget.WidgetSetRealizedMethodInfo
    ResolveTreeViewMethod "setReallocateRedraws" o = Gtk.Container.ContainerSetReallocateRedrawsMethodInfo
    ResolveTreeViewMethod "setReceivesDefault" o = Gtk.Widget.WidgetSetReceivesDefaultMethodInfo
    ResolveTreeViewMethod "setRedrawOnAllocate" o = Gtk.Widget.WidgetSetRedrawOnAllocateMethodInfo
    ResolveTreeViewMethod "setReorderable" o = TreeViewSetReorderableMethodInfo
    ResolveTreeViewMethod "setResizeMode" o = Gtk.Container.ContainerSetResizeModeMethodInfo
    ResolveTreeViewMethod "setRowSeparatorFunc" o = TreeViewSetRowSeparatorFuncMethodInfo
    ResolveTreeViewMethod "setRubberBanding" o = TreeViewSetRubberBandingMethodInfo
    ResolveTreeViewMethod "setRulesHint" o = TreeViewSetRulesHintMethodInfo
    ResolveTreeViewMethod "setSearchColumn" o = TreeViewSetSearchColumnMethodInfo
    ResolveTreeViewMethod "setSearchEntry" o = TreeViewSetSearchEntryMethodInfo
    ResolveTreeViewMethod "setSearchEqualFunc" o = TreeViewSetSearchEqualFuncMethodInfo
    ResolveTreeViewMethod "setSearchPositionFunc" o = TreeViewSetSearchPositionFuncMethodInfo
    ResolveTreeViewMethod "setSensitive" o = Gtk.Widget.WidgetSetSensitiveMethodInfo
    ResolveTreeViewMethod "setShowExpanders" o = TreeViewSetShowExpandersMethodInfo
    ResolveTreeViewMethod "setSizeRequest" o = Gtk.Widget.WidgetSetSizeRequestMethodInfo
    ResolveTreeViewMethod "setState" o = Gtk.Widget.WidgetSetStateMethodInfo
    ResolveTreeViewMethod "setStateFlags" o = Gtk.Widget.WidgetSetStateFlagsMethodInfo
    ResolveTreeViewMethod "setStyle" o = Gtk.Widget.WidgetSetStyleMethodInfo
    ResolveTreeViewMethod "setSupportMultidevice" o = Gtk.Widget.WidgetSetSupportMultideviceMethodInfo
    ResolveTreeViewMethod "setTooltipCell" o = TreeViewSetTooltipCellMethodInfo
    ResolveTreeViewMethod "setTooltipColumn" o = TreeViewSetTooltipColumnMethodInfo
    ResolveTreeViewMethod "setTooltipMarkup" o = Gtk.Widget.WidgetSetTooltipMarkupMethodInfo
    ResolveTreeViewMethod "setTooltipRow" o = TreeViewSetTooltipRowMethodInfo
    ResolveTreeViewMethod "setTooltipText" o = Gtk.Widget.WidgetSetTooltipTextMethodInfo
    ResolveTreeViewMethod "setTooltipWindow" o = Gtk.Widget.WidgetSetTooltipWindowMethodInfo
    ResolveTreeViewMethod "setVadjustment" o = TreeViewSetVadjustmentMethodInfo
    ResolveTreeViewMethod "setValign" o = Gtk.Widget.WidgetSetValignMethodInfo
    ResolveTreeViewMethod "setVexpand" o = Gtk.Widget.WidgetSetVexpandMethodInfo
    ResolveTreeViewMethod "setVexpandSet" o = Gtk.Widget.WidgetSetVexpandSetMethodInfo
    ResolveTreeViewMethod "setVisible" o = Gtk.Widget.WidgetSetVisibleMethodInfo
    ResolveTreeViewMethod "setVisual" o = Gtk.Widget.WidgetSetVisualMethodInfo
    ResolveTreeViewMethod "setVscrollPolicy" o = Gtk.Scrollable.ScrollableSetVscrollPolicyMethodInfo
    ResolveTreeViewMethod "setWindow" o = Gtk.Widget.WidgetSetWindowMethodInfo
    ResolveTreeViewMethod l o = O.MethodResolutionFailed l o

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

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

-- signal TreeView::columns-changed
type TreeViewColumnsChangedCallback =
    IO ()

noTreeViewColumnsChangedCallback :: Maybe TreeViewColumnsChangedCallback
noTreeViewColumnsChangedCallback = Nothing

type C_TreeViewColumnsChangedCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_TreeViewColumnsChangedCallback :: C_TreeViewColumnsChangedCallback -> IO (FunPtr C_TreeViewColumnsChangedCallback)

genClosure_TreeViewColumnsChanged :: TreeViewColumnsChangedCallback -> IO Closure
genClosure_TreeViewColumnsChanged cb = do
    let cb' = wrap_TreeViewColumnsChangedCallback cb
    mk_TreeViewColumnsChangedCallback cb' >>= newCClosure


wrap_TreeViewColumnsChangedCallback ::
    TreeViewColumnsChangedCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
wrap_TreeViewColumnsChangedCallback _cb _ _ = do
    _cb 


onTreeViewColumnsChanged :: (GObject a, MonadIO m) => a -> TreeViewColumnsChangedCallback -> m SignalHandlerId
onTreeViewColumnsChanged obj cb = liftIO $ connectTreeViewColumnsChanged obj cb SignalConnectBefore
afterTreeViewColumnsChanged :: (GObject a, MonadIO m) => a -> TreeViewColumnsChangedCallback -> m SignalHandlerId
afterTreeViewColumnsChanged obj cb = connectTreeViewColumnsChanged obj cb SignalConnectAfter

connectTreeViewColumnsChanged :: (GObject a, MonadIO m) =>
                                 a -> TreeViewColumnsChangedCallback -> SignalConnectMode -> m SignalHandlerId
connectTreeViewColumnsChanged obj cb after = liftIO $ do
    let cb' = wrap_TreeViewColumnsChangedCallback cb
    cb'' <- mk_TreeViewColumnsChangedCallback cb'
    connectSignalFunPtr obj "columns-changed" cb'' after

-- signal TreeView::cursor-changed
type TreeViewCursorChangedCallback =
    IO ()

noTreeViewCursorChangedCallback :: Maybe TreeViewCursorChangedCallback
noTreeViewCursorChangedCallback = Nothing

type C_TreeViewCursorChangedCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_TreeViewCursorChangedCallback :: C_TreeViewCursorChangedCallback -> IO (FunPtr C_TreeViewCursorChangedCallback)

genClosure_TreeViewCursorChanged :: TreeViewCursorChangedCallback -> IO Closure
genClosure_TreeViewCursorChanged cb = do
    let cb' = wrap_TreeViewCursorChangedCallback cb
    mk_TreeViewCursorChangedCallback cb' >>= newCClosure


wrap_TreeViewCursorChangedCallback ::
    TreeViewCursorChangedCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
wrap_TreeViewCursorChangedCallback _cb _ _ = do
    _cb 


onTreeViewCursorChanged :: (GObject a, MonadIO m) => a -> TreeViewCursorChangedCallback -> m SignalHandlerId
onTreeViewCursorChanged obj cb = liftIO $ connectTreeViewCursorChanged obj cb SignalConnectBefore
afterTreeViewCursorChanged :: (GObject a, MonadIO m) => a -> TreeViewCursorChangedCallback -> m SignalHandlerId
afterTreeViewCursorChanged obj cb = connectTreeViewCursorChanged obj cb SignalConnectAfter

connectTreeViewCursorChanged :: (GObject a, MonadIO m) =>
                                a -> TreeViewCursorChangedCallback -> SignalConnectMode -> m SignalHandlerId
connectTreeViewCursorChanged obj cb after = liftIO $ do
    let cb' = wrap_TreeViewCursorChangedCallback cb
    cb'' <- mk_TreeViewCursorChangedCallback cb'
    connectSignalFunPtr obj "cursor-changed" cb'' after

-- signal TreeView::expand-collapse-cursor-row
type TreeViewExpandCollapseCursorRowCallback =
    Bool ->
    Bool ->
    Bool ->
    IO Bool

noTreeViewExpandCollapseCursorRowCallback :: Maybe TreeViewExpandCollapseCursorRowCallback
noTreeViewExpandCollapseCursorRowCallback = Nothing

type C_TreeViewExpandCollapseCursorRowCallback =
    Ptr () ->                               -- object
    CInt ->
    CInt ->
    CInt ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mk_TreeViewExpandCollapseCursorRowCallback :: C_TreeViewExpandCollapseCursorRowCallback -> IO (FunPtr C_TreeViewExpandCollapseCursorRowCallback)

genClosure_TreeViewExpandCollapseCursorRow :: TreeViewExpandCollapseCursorRowCallback -> IO Closure
genClosure_TreeViewExpandCollapseCursorRow cb = do
    let cb' = wrap_TreeViewExpandCollapseCursorRowCallback cb
    mk_TreeViewExpandCollapseCursorRowCallback cb' >>= newCClosure


wrap_TreeViewExpandCollapseCursorRowCallback ::
    TreeViewExpandCollapseCursorRowCallback ->
    Ptr () ->
    CInt ->
    CInt ->
    CInt ->
    Ptr () ->
    IO CInt
wrap_TreeViewExpandCollapseCursorRowCallback _cb _ object p0 p1 _ = do
    let object' = (/= 0) object
    let p0' = (/= 0) p0
    let p1' = (/= 0) p1
    result <- _cb  object' p0' p1'
    let result' = (fromIntegral . fromEnum) result
    return result'


onTreeViewExpandCollapseCursorRow :: (GObject a, MonadIO m) => a -> TreeViewExpandCollapseCursorRowCallback -> m SignalHandlerId
onTreeViewExpandCollapseCursorRow obj cb = liftIO $ connectTreeViewExpandCollapseCursorRow obj cb SignalConnectBefore
afterTreeViewExpandCollapseCursorRow :: (GObject a, MonadIO m) => a -> TreeViewExpandCollapseCursorRowCallback -> m SignalHandlerId
afterTreeViewExpandCollapseCursorRow obj cb = connectTreeViewExpandCollapseCursorRow obj cb SignalConnectAfter

connectTreeViewExpandCollapseCursorRow :: (GObject a, MonadIO m) =>
                                          a -> TreeViewExpandCollapseCursorRowCallback -> SignalConnectMode -> m SignalHandlerId
connectTreeViewExpandCollapseCursorRow obj cb after = liftIO $ do
    let cb' = wrap_TreeViewExpandCollapseCursorRowCallback cb
    cb'' <- mk_TreeViewExpandCollapseCursorRowCallback cb'
    connectSignalFunPtr obj "expand-collapse-cursor-row" cb'' after

-- signal TreeView::move-cursor
type TreeViewMoveCursorCallback =
    Gtk.Enums.MovementStep ->
    Int32 ->
    IO Bool

noTreeViewMoveCursorCallback :: Maybe TreeViewMoveCursorCallback
noTreeViewMoveCursorCallback = Nothing

type C_TreeViewMoveCursorCallback =
    Ptr () ->                               -- object
    CUInt ->
    Int32 ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mk_TreeViewMoveCursorCallback :: C_TreeViewMoveCursorCallback -> IO (FunPtr C_TreeViewMoveCursorCallback)

genClosure_TreeViewMoveCursor :: TreeViewMoveCursorCallback -> IO Closure
genClosure_TreeViewMoveCursor cb = do
    let cb' = wrap_TreeViewMoveCursorCallback cb
    mk_TreeViewMoveCursorCallback cb' >>= newCClosure


wrap_TreeViewMoveCursorCallback ::
    TreeViewMoveCursorCallback ->
    Ptr () ->
    CUInt ->
    Int32 ->
    Ptr () ->
    IO CInt
wrap_TreeViewMoveCursorCallback _cb _ step direction _ = do
    let step' = (toEnum . fromIntegral) step
    result <- _cb  step' direction
    let result' = (fromIntegral . fromEnum) result
    return result'


onTreeViewMoveCursor :: (GObject a, MonadIO m) => a -> TreeViewMoveCursorCallback -> m SignalHandlerId
onTreeViewMoveCursor obj cb = liftIO $ connectTreeViewMoveCursor obj cb SignalConnectBefore
afterTreeViewMoveCursor :: (GObject a, MonadIO m) => a -> TreeViewMoveCursorCallback -> m SignalHandlerId
afterTreeViewMoveCursor obj cb = connectTreeViewMoveCursor obj cb SignalConnectAfter

connectTreeViewMoveCursor :: (GObject a, MonadIO m) =>
                             a -> TreeViewMoveCursorCallback -> SignalConnectMode -> m SignalHandlerId
connectTreeViewMoveCursor obj cb after = liftIO $ do
    let cb' = wrap_TreeViewMoveCursorCallback cb
    cb'' <- mk_TreeViewMoveCursorCallback cb'
    connectSignalFunPtr obj "move-cursor" cb'' after

-- signal TreeView::row-activated
type TreeViewRowActivatedCallback =
    Gtk.TreePath.TreePath ->
    Gtk.TreeViewColumn.TreeViewColumn ->
    IO ()

noTreeViewRowActivatedCallback :: Maybe TreeViewRowActivatedCallback
noTreeViewRowActivatedCallback = Nothing

type C_TreeViewRowActivatedCallback =
    Ptr () ->                               -- object
    Ptr Gtk.TreePath.TreePath ->
    Ptr Gtk.TreeViewColumn.TreeViewColumn ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_TreeViewRowActivatedCallback :: C_TreeViewRowActivatedCallback -> IO (FunPtr C_TreeViewRowActivatedCallback)

genClosure_TreeViewRowActivated :: TreeViewRowActivatedCallback -> IO Closure
genClosure_TreeViewRowActivated cb = do
    let cb' = wrap_TreeViewRowActivatedCallback cb
    mk_TreeViewRowActivatedCallback cb' >>= newCClosure


wrap_TreeViewRowActivatedCallback ::
    TreeViewRowActivatedCallback ->
    Ptr () ->
    Ptr Gtk.TreePath.TreePath ->
    Ptr Gtk.TreeViewColumn.TreeViewColumn ->
    Ptr () ->
    IO ()
wrap_TreeViewRowActivatedCallback _cb _ path column _ = do
    path' <- (newBoxed Gtk.TreePath.TreePath) path
    column' <- (newObject Gtk.TreeViewColumn.TreeViewColumn) column
    _cb  path' column'


onTreeViewRowActivated :: (GObject a, MonadIO m) => a -> TreeViewRowActivatedCallback -> m SignalHandlerId
onTreeViewRowActivated obj cb = liftIO $ connectTreeViewRowActivated obj cb SignalConnectBefore
afterTreeViewRowActivated :: (GObject a, MonadIO m) => a -> TreeViewRowActivatedCallback -> m SignalHandlerId
afterTreeViewRowActivated obj cb = connectTreeViewRowActivated obj cb SignalConnectAfter

connectTreeViewRowActivated :: (GObject a, MonadIO m) =>
                               a -> TreeViewRowActivatedCallback -> SignalConnectMode -> m SignalHandlerId
connectTreeViewRowActivated obj cb after = liftIO $ do
    let cb' = wrap_TreeViewRowActivatedCallback cb
    cb'' <- mk_TreeViewRowActivatedCallback cb'
    connectSignalFunPtr obj "row-activated" cb'' after

-- signal TreeView::row-collapsed
type TreeViewRowCollapsedCallback =
    Gtk.TreeIter.TreeIter ->
    Gtk.TreePath.TreePath ->
    IO ()

noTreeViewRowCollapsedCallback :: Maybe TreeViewRowCollapsedCallback
noTreeViewRowCollapsedCallback = Nothing

type C_TreeViewRowCollapsedCallback =
    Ptr () ->                               -- object
    Ptr Gtk.TreeIter.TreeIter ->
    Ptr Gtk.TreePath.TreePath ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_TreeViewRowCollapsedCallback :: C_TreeViewRowCollapsedCallback -> IO (FunPtr C_TreeViewRowCollapsedCallback)

genClosure_TreeViewRowCollapsed :: TreeViewRowCollapsedCallback -> IO Closure
genClosure_TreeViewRowCollapsed cb = do
    let cb' = wrap_TreeViewRowCollapsedCallback cb
    mk_TreeViewRowCollapsedCallback cb' >>= newCClosure


wrap_TreeViewRowCollapsedCallback ::
    TreeViewRowCollapsedCallback ->
    Ptr () ->
    Ptr Gtk.TreeIter.TreeIter ->
    Ptr Gtk.TreePath.TreePath ->
    Ptr () ->
    IO ()
wrap_TreeViewRowCollapsedCallback _cb _ iter path _ = do
    iter' <- (newBoxed Gtk.TreeIter.TreeIter) iter
    path' <- (newBoxed Gtk.TreePath.TreePath) path
    _cb  iter' path'


onTreeViewRowCollapsed :: (GObject a, MonadIO m) => a -> TreeViewRowCollapsedCallback -> m SignalHandlerId
onTreeViewRowCollapsed obj cb = liftIO $ connectTreeViewRowCollapsed obj cb SignalConnectBefore
afterTreeViewRowCollapsed :: (GObject a, MonadIO m) => a -> TreeViewRowCollapsedCallback -> m SignalHandlerId
afterTreeViewRowCollapsed obj cb = connectTreeViewRowCollapsed obj cb SignalConnectAfter

connectTreeViewRowCollapsed :: (GObject a, MonadIO m) =>
                               a -> TreeViewRowCollapsedCallback -> SignalConnectMode -> m SignalHandlerId
connectTreeViewRowCollapsed obj cb after = liftIO $ do
    let cb' = wrap_TreeViewRowCollapsedCallback cb
    cb'' <- mk_TreeViewRowCollapsedCallback cb'
    connectSignalFunPtr obj "row-collapsed" cb'' after

-- signal TreeView::row-expanded
type TreeViewRowExpandedCallback =
    Gtk.TreeIter.TreeIter ->
    Gtk.TreePath.TreePath ->
    IO ()

noTreeViewRowExpandedCallback :: Maybe TreeViewRowExpandedCallback
noTreeViewRowExpandedCallback = Nothing

type C_TreeViewRowExpandedCallback =
    Ptr () ->                               -- object
    Ptr Gtk.TreeIter.TreeIter ->
    Ptr Gtk.TreePath.TreePath ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_TreeViewRowExpandedCallback :: C_TreeViewRowExpandedCallback -> IO (FunPtr C_TreeViewRowExpandedCallback)

genClosure_TreeViewRowExpanded :: TreeViewRowExpandedCallback -> IO Closure
genClosure_TreeViewRowExpanded cb = do
    let cb' = wrap_TreeViewRowExpandedCallback cb
    mk_TreeViewRowExpandedCallback cb' >>= newCClosure


wrap_TreeViewRowExpandedCallback ::
    TreeViewRowExpandedCallback ->
    Ptr () ->
    Ptr Gtk.TreeIter.TreeIter ->
    Ptr Gtk.TreePath.TreePath ->
    Ptr () ->
    IO ()
wrap_TreeViewRowExpandedCallback _cb _ iter path _ = do
    iter' <- (newBoxed Gtk.TreeIter.TreeIter) iter
    path' <- (newBoxed Gtk.TreePath.TreePath) path
    _cb  iter' path'


onTreeViewRowExpanded :: (GObject a, MonadIO m) => a -> TreeViewRowExpandedCallback -> m SignalHandlerId
onTreeViewRowExpanded obj cb = liftIO $ connectTreeViewRowExpanded obj cb SignalConnectBefore
afterTreeViewRowExpanded :: (GObject a, MonadIO m) => a -> TreeViewRowExpandedCallback -> m SignalHandlerId
afterTreeViewRowExpanded obj cb = connectTreeViewRowExpanded obj cb SignalConnectAfter

connectTreeViewRowExpanded :: (GObject a, MonadIO m) =>
                              a -> TreeViewRowExpandedCallback -> SignalConnectMode -> m SignalHandlerId
connectTreeViewRowExpanded obj cb after = liftIO $ do
    let cb' = wrap_TreeViewRowExpandedCallback cb
    cb'' <- mk_TreeViewRowExpandedCallback cb'
    connectSignalFunPtr obj "row-expanded" cb'' after

-- signal TreeView::select-all
type TreeViewSelectAllCallback =
    IO Bool

noTreeViewSelectAllCallback :: Maybe TreeViewSelectAllCallback
noTreeViewSelectAllCallback = Nothing

type C_TreeViewSelectAllCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mk_TreeViewSelectAllCallback :: C_TreeViewSelectAllCallback -> IO (FunPtr C_TreeViewSelectAllCallback)

genClosure_TreeViewSelectAll :: TreeViewSelectAllCallback -> IO Closure
genClosure_TreeViewSelectAll cb = do
    let cb' = wrap_TreeViewSelectAllCallback cb
    mk_TreeViewSelectAllCallback cb' >>= newCClosure


wrap_TreeViewSelectAllCallback ::
    TreeViewSelectAllCallback ->
    Ptr () ->
    Ptr () ->
    IO CInt
wrap_TreeViewSelectAllCallback _cb _ _ = do
    result <- _cb 
    let result' = (fromIntegral . fromEnum) result
    return result'


onTreeViewSelectAll :: (GObject a, MonadIO m) => a -> TreeViewSelectAllCallback -> m SignalHandlerId
onTreeViewSelectAll obj cb = liftIO $ connectTreeViewSelectAll obj cb SignalConnectBefore
afterTreeViewSelectAll :: (GObject a, MonadIO m) => a -> TreeViewSelectAllCallback -> m SignalHandlerId
afterTreeViewSelectAll obj cb = connectTreeViewSelectAll obj cb SignalConnectAfter

connectTreeViewSelectAll :: (GObject a, MonadIO m) =>
                            a -> TreeViewSelectAllCallback -> SignalConnectMode -> m SignalHandlerId
connectTreeViewSelectAll obj cb after = liftIO $ do
    let cb' = wrap_TreeViewSelectAllCallback cb
    cb'' <- mk_TreeViewSelectAllCallback cb'
    connectSignalFunPtr obj "select-all" cb'' after

-- signal TreeView::select-cursor-parent
type TreeViewSelectCursorParentCallback =
    IO Bool

noTreeViewSelectCursorParentCallback :: Maybe TreeViewSelectCursorParentCallback
noTreeViewSelectCursorParentCallback = Nothing

type C_TreeViewSelectCursorParentCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mk_TreeViewSelectCursorParentCallback :: C_TreeViewSelectCursorParentCallback -> IO (FunPtr C_TreeViewSelectCursorParentCallback)

genClosure_TreeViewSelectCursorParent :: TreeViewSelectCursorParentCallback -> IO Closure
genClosure_TreeViewSelectCursorParent cb = do
    let cb' = wrap_TreeViewSelectCursorParentCallback cb
    mk_TreeViewSelectCursorParentCallback cb' >>= newCClosure


wrap_TreeViewSelectCursorParentCallback ::
    TreeViewSelectCursorParentCallback ->
    Ptr () ->
    Ptr () ->
    IO CInt
wrap_TreeViewSelectCursorParentCallback _cb _ _ = do
    result <- _cb 
    let result' = (fromIntegral . fromEnum) result
    return result'


onTreeViewSelectCursorParent :: (GObject a, MonadIO m) => a -> TreeViewSelectCursorParentCallback -> m SignalHandlerId
onTreeViewSelectCursorParent obj cb = liftIO $ connectTreeViewSelectCursorParent obj cb SignalConnectBefore
afterTreeViewSelectCursorParent :: (GObject a, MonadIO m) => a -> TreeViewSelectCursorParentCallback -> m SignalHandlerId
afterTreeViewSelectCursorParent obj cb = connectTreeViewSelectCursorParent obj cb SignalConnectAfter

connectTreeViewSelectCursorParent :: (GObject a, MonadIO m) =>
                                     a -> TreeViewSelectCursorParentCallback -> SignalConnectMode -> m SignalHandlerId
connectTreeViewSelectCursorParent obj cb after = liftIO $ do
    let cb' = wrap_TreeViewSelectCursorParentCallback cb
    cb'' <- mk_TreeViewSelectCursorParentCallback cb'
    connectSignalFunPtr obj "select-cursor-parent" cb'' after

-- signal TreeView::select-cursor-row
type TreeViewSelectCursorRowCallback =
    Bool ->
    IO Bool

noTreeViewSelectCursorRowCallback :: Maybe TreeViewSelectCursorRowCallback
noTreeViewSelectCursorRowCallback = Nothing

type C_TreeViewSelectCursorRowCallback =
    Ptr () ->                               -- object
    CInt ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mk_TreeViewSelectCursorRowCallback :: C_TreeViewSelectCursorRowCallback -> IO (FunPtr C_TreeViewSelectCursorRowCallback)

genClosure_TreeViewSelectCursorRow :: TreeViewSelectCursorRowCallback -> IO Closure
genClosure_TreeViewSelectCursorRow cb = do
    let cb' = wrap_TreeViewSelectCursorRowCallback cb
    mk_TreeViewSelectCursorRowCallback cb' >>= newCClosure


wrap_TreeViewSelectCursorRowCallback ::
    TreeViewSelectCursorRowCallback ->
    Ptr () ->
    CInt ->
    Ptr () ->
    IO CInt
wrap_TreeViewSelectCursorRowCallback _cb _ object _ = do
    let object' = (/= 0) object
    result <- _cb  object'
    let result' = (fromIntegral . fromEnum) result
    return result'


onTreeViewSelectCursorRow :: (GObject a, MonadIO m) => a -> TreeViewSelectCursorRowCallback -> m SignalHandlerId
onTreeViewSelectCursorRow obj cb = liftIO $ connectTreeViewSelectCursorRow obj cb SignalConnectBefore
afterTreeViewSelectCursorRow :: (GObject a, MonadIO m) => a -> TreeViewSelectCursorRowCallback -> m SignalHandlerId
afterTreeViewSelectCursorRow obj cb = connectTreeViewSelectCursorRow obj cb SignalConnectAfter

connectTreeViewSelectCursorRow :: (GObject a, MonadIO m) =>
                                  a -> TreeViewSelectCursorRowCallback -> SignalConnectMode -> m SignalHandlerId
connectTreeViewSelectCursorRow obj cb after = liftIO $ do
    let cb' = wrap_TreeViewSelectCursorRowCallback cb
    cb'' <- mk_TreeViewSelectCursorRowCallback cb'
    connectSignalFunPtr obj "select-cursor-row" cb'' after

-- signal TreeView::start-interactive-search
type TreeViewStartInteractiveSearchCallback =
    IO Bool

noTreeViewStartInteractiveSearchCallback :: Maybe TreeViewStartInteractiveSearchCallback
noTreeViewStartInteractiveSearchCallback = Nothing

type C_TreeViewStartInteractiveSearchCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mk_TreeViewStartInteractiveSearchCallback :: C_TreeViewStartInteractiveSearchCallback -> IO (FunPtr C_TreeViewStartInteractiveSearchCallback)

genClosure_TreeViewStartInteractiveSearch :: TreeViewStartInteractiveSearchCallback -> IO Closure
genClosure_TreeViewStartInteractiveSearch cb = do
    let cb' = wrap_TreeViewStartInteractiveSearchCallback cb
    mk_TreeViewStartInteractiveSearchCallback cb' >>= newCClosure


wrap_TreeViewStartInteractiveSearchCallback ::
    TreeViewStartInteractiveSearchCallback ->
    Ptr () ->
    Ptr () ->
    IO CInt
wrap_TreeViewStartInteractiveSearchCallback _cb _ _ = do
    result <- _cb 
    let result' = (fromIntegral . fromEnum) result
    return result'


onTreeViewStartInteractiveSearch :: (GObject a, MonadIO m) => a -> TreeViewStartInteractiveSearchCallback -> m SignalHandlerId
onTreeViewStartInteractiveSearch obj cb = liftIO $ connectTreeViewStartInteractiveSearch obj cb SignalConnectBefore
afterTreeViewStartInteractiveSearch :: (GObject a, MonadIO m) => a -> TreeViewStartInteractiveSearchCallback -> m SignalHandlerId
afterTreeViewStartInteractiveSearch obj cb = connectTreeViewStartInteractiveSearch obj cb SignalConnectAfter

connectTreeViewStartInteractiveSearch :: (GObject a, MonadIO m) =>
                                         a -> TreeViewStartInteractiveSearchCallback -> SignalConnectMode -> m SignalHandlerId
connectTreeViewStartInteractiveSearch obj cb after = liftIO $ do
    let cb' = wrap_TreeViewStartInteractiveSearchCallback cb
    cb'' <- mk_TreeViewStartInteractiveSearchCallback cb'
    connectSignalFunPtr obj "start-interactive-search" cb'' after

-- signal TreeView::test-collapse-row
type TreeViewTestCollapseRowCallback =
    Gtk.TreeIter.TreeIter ->
    Gtk.TreePath.TreePath ->
    IO Bool

noTreeViewTestCollapseRowCallback :: Maybe TreeViewTestCollapseRowCallback
noTreeViewTestCollapseRowCallback = Nothing

type C_TreeViewTestCollapseRowCallback =
    Ptr () ->                               -- object
    Ptr Gtk.TreeIter.TreeIter ->
    Ptr Gtk.TreePath.TreePath ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mk_TreeViewTestCollapseRowCallback :: C_TreeViewTestCollapseRowCallback -> IO (FunPtr C_TreeViewTestCollapseRowCallback)

genClosure_TreeViewTestCollapseRow :: TreeViewTestCollapseRowCallback -> IO Closure
genClosure_TreeViewTestCollapseRow cb = do
    let cb' = wrap_TreeViewTestCollapseRowCallback cb
    mk_TreeViewTestCollapseRowCallback cb' >>= newCClosure


wrap_TreeViewTestCollapseRowCallback ::
    TreeViewTestCollapseRowCallback ->
    Ptr () ->
    Ptr Gtk.TreeIter.TreeIter ->
    Ptr Gtk.TreePath.TreePath ->
    Ptr () ->
    IO CInt
wrap_TreeViewTestCollapseRowCallback _cb _ iter path _ = do
    iter' <- (newBoxed Gtk.TreeIter.TreeIter) iter
    path' <- (newBoxed Gtk.TreePath.TreePath) path
    result <- _cb  iter' path'
    let result' = (fromIntegral . fromEnum) result
    return result'


onTreeViewTestCollapseRow :: (GObject a, MonadIO m) => a -> TreeViewTestCollapseRowCallback -> m SignalHandlerId
onTreeViewTestCollapseRow obj cb = liftIO $ connectTreeViewTestCollapseRow obj cb SignalConnectBefore
afterTreeViewTestCollapseRow :: (GObject a, MonadIO m) => a -> TreeViewTestCollapseRowCallback -> m SignalHandlerId
afterTreeViewTestCollapseRow obj cb = connectTreeViewTestCollapseRow obj cb SignalConnectAfter

connectTreeViewTestCollapseRow :: (GObject a, MonadIO m) =>
                                  a -> TreeViewTestCollapseRowCallback -> SignalConnectMode -> m SignalHandlerId
connectTreeViewTestCollapseRow obj cb after = liftIO $ do
    let cb' = wrap_TreeViewTestCollapseRowCallback cb
    cb'' <- mk_TreeViewTestCollapseRowCallback cb'
    connectSignalFunPtr obj "test-collapse-row" cb'' after

-- signal TreeView::test-expand-row
type TreeViewTestExpandRowCallback =
    Gtk.TreeIter.TreeIter ->
    Gtk.TreePath.TreePath ->
    IO Bool

noTreeViewTestExpandRowCallback :: Maybe TreeViewTestExpandRowCallback
noTreeViewTestExpandRowCallback = Nothing

type C_TreeViewTestExpandRowCallback =
    Ptr () ->                               -- object
    Ptr Gtk.TreeIter.TreeIter ->
    Ptr Gtk.TreePath.TreePath ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mk_TreeViewTestExpandRowCallback :: C_TreeViewTestExpandRowCallback -> IO (FunPtr C_TreeViewTestExpandRowCallback)

genClosure_TreeViewTestExpandRow :: TreeViewTestExpandRowCallback -> IO Closure
genClosure_TreeViewTestExpandRow cb = do
    let cb' = wrap_TreeViewTestExpandRowCallback cb
    mk_TreeViewTestExpandRowCallback cb' >>= newCClosure


wrap_TreeViewTestExpandRowCallback ::
    TreeViewTestExpandRowCallback ->
    Ptr () ->
    Ptr Gtk.TreeIter.TreeIter ->
    Ptr Gtk.TreePath.TreePath ->
    Ptr () ->
    IO CInt
wrap_TreeViewTestExpandRowCallback _cb _ iter path _ = do
    iter' <- (newBoxed Gtk.TreeIter.TreeIter) iter
    path' <- (newBoxed Gtk.TreePath.TreePath) path
    result <- _cb  iter' path'
    let result' = (fromIntegral . fromEnum) result
    return result'


onTreeViewTestExpandRow :: (GObject a, MonadIO m) => a -> TreeViewTestExpandRowCallback -> m SignalHandlerId
onTreeViewTestExpandRow obj cb = liftIO $ connectTreeViewTestExpandRow obj cb SignalConnectBefore
afterTreeViewTestExpandRow :: (GObject a, MonadIO m) => a -> TreeViewTestExpandRowCallback -> m SignalHandlerId
afterTreeViewTestExpandRow obj cb = connectTreeViewTestExpandRow obj cb SignalConnectAfter

connectTreeViewTestExpandRow :: (GObject a, MonadIO m) =>
                                a -> TreeViewTestExpandRowCallback -> SignalConnectMode -> m SignalHandlerId
connectTreeViewTestExpandRow obj cb after = liftIO $ do
    let cb' = wrap_TreeViewTestExpandRowCallback cb
    cb'' <- mk_TreeViewTestExpandRowCallback cb'
    connectSignalFunPtr obj "test-expand-row" cb'' after

-- signal TreeView::toggle-cursor-row
type TreeViewToggleCursorRowCallback =
    IO Bool

noTreeViewToggleCursorRowCallback :: Maybe TreeViewToggleCursorRowCallback
noTreeViewToggleCursorRowCallback = Nothing

type C_TreeViewToggleCursorRowCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mk_TreeViewToggleCursorRowCallback :: C_TreeViewToggleCursorRowCallback -> IO (FunPtr C_TreeViewToggleCursorRowCallback)

genClosure_TreeViewToggleCursorRow :: TreeViewToggleCursorRowCallback -> IO Closure
genClosure_TreeViewToggleCursorRow cb = do
    let cb' = wrap_TreeViewToggleCursorRowCallback cb
    mk_TreeViewToggleCursorRowCallback cb' >>= newCClosure


wrap_TreeViewToggleCursorRowCallback ::
    TreeViewToggleCursorRowCallback ->
    Ptr () ->
    Ptr () ->
    IO CInt
wrap_TreeViewToggleCursorRowCallback _cb _ _ = do
    result <- _cb 
    let result' = (fromIntegral . fromEnum) result
    return result'


onTreeViewToggleCursorRow :: (GObject a, MonadIO m) => a -> TreeViewToggleCursorRowCallback -> m SignalHandlerId
onTreeViewToggleCursorRow obj cb = liftIO $ connectTreeViewToggleCursorRow obj cb SignalConnectBefore
afterTreeViewToggleCursorRow :: (GObject a, MonadIO m) => a -> TreeViewToggleCursorRowCallback -> m SignalHandlerId
afterTreeViewToggleCursorRow obj cb = connectTreeViewToggleCursorRow obj cb SignalConnectAfter

connectTreeViewToggleCursorRow :: (GObject a, MonadIO m) =>
                                  a -> TreeViewToggleCursorRowCallback -> SignalConnectMode -> m SignalHandlerId
connectTreeViewToggleCursorRow obj cb after = liftIO $ do
    let cb' = wrap_TreeViewToggleCursorRowCallback cb
    cb'' <- mk_TreeViewToggleCursorRowCallback cb'
    connectSignalFunPtr obj "toggle-cursor-row" cb'' after

-- signal TreeView::unselect-all
type TreeViewUnselectAllCallback =
    IO Bool

noTreeViewUnselectAllCallback :: Maybe TreeViewUnselectAllCallback
noTreeViewUnselectAllCallback = Nothing

type C_TreeViewUnselectAllCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mk_TreeViewUnselectAllCallback :: C_TreeViewUnselectAllCallback -> IO (FunPtr C_TreeViewUnselectAllCallback)

genClosure_TreeViewUnselectAll :: TreeViewUnselectAllCallback -> IO Closure
genClosure_TreeViewUnselectAll cb = do
    let cb' = wrap_TreeViewUnselectAllCallback cb
    mk_TreeViewUnselectAllCallback cb' >>= newCClosure


wrap_TreeViewUnselectAllCallback ::
    TreeViewUnselectAllCallback ->
    Ptr () ->
    Ptr () ->
    IO CInt
wrap_TreeViewUnselectAllCallback _cb _ _ = do
    result <- _cb 
    let result' = (fromIntegral . fromEnum) result
    return result'


onTreeViewUnselectAll :: (GObject a, MonadIO m) => a -> TreeViewUnselectAllCallback -> m SignalHandlerId
onTreeViewUnselectAll obj cb = liftIO $ connectTreeViewUnselectAll obj cb SignalConnectBefore
afterTreeViewUnselectAll :: (GObject a, MonadIO m) => a -> TreeViewUnselectAllCallback -> m SignalHandlerId
afterTreeViewUnselectAll obj cb = connectTreeViewUnselectAll obj cb SignalConnectAfter

connectTreeViewUnselectAll :: (GObject a, MonadIO m) =>
                              a -> TreeViewUnselectAllCallback -> SignalConnectMode -> m SignalHandlerId
connectTreeViewUnselectAll obj cb after = liftIO $ do
    let cb' = wrap_TreeViewUnselectAllCallback cb
    cb'' <- mk_TreeViewUnselectAllCallback cb'
    connectSignalFunPtr obj "unselect-all" cb'' after

-- VVV Prop "activate-on-single-click"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getTreeViewActivateOnSingleClick :: (MonadIO m, IsTreeView o) => o -> m Bool
getTreeViewActivateOnSingleClick obj = liftIO $ getObjectPropertyBool obj "activate-on-single-click"

setTreeViewActivateOnSingleClick :: (MonadIO m, IsTreeView o) => o -> Bool -> m ()
setTreeViewActivateOnSingleClick obj val = liftIO $ setObjectPropertyBool obj "activate-on-single-click" val

constructTreeViewActivateOnSingleClick :: (IsTreeView o) => Bool -> IO (GValueConstruct o)
constructTreeViewActivateOnSingleClick val = constructObjectPropertyBool "activate-on-single-click" val

data TreeViewActivateOnSingleClickPropertyInfo
instance AttrInfo TreeViewActivateOnSingleClickPropertyInfo where
    type AttrAllowedOps TreeViewActivateOnSingleClickPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint TreeViewActivateOnSingleClickPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint TreeViewActivateOnSingleClickPropertyInfo = IsTreeView
    type AttrGetType TreeViewActivateOnSingleClickPropertyInfo = Bool
    type AttrLabel TreeViewActivateOnSingleClickPropertyInfo = "activate-on-single-click"
    type AttrOrigin TreeViewActivateOnSingleClickPropertyInfo = TreeView
    attrGet _ = getTreeViewActivateOnSingleClick
    attrSet _ = setTreeViewActivateOnSingleClick
    attrConstruct _ = constructTreeViewActivateOnSingleClick
    attrClear _ = undefined

-- VVV Prop "enable-grid-lines"
   -- Type: TInterface (Name {namespace = "Gtk", name = "TreeViewGridLines"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

getTreeViewEnableGridLines :: (MonadIO m, IsTreeView o) => o -> m Gtk.Enums.TreeViewGridLines
getTreeViewEnableGridLines obj = liftIO $ getObjectPropertyEnum obj "enable-grid-lines"

setTreeViewEnableGridLines :: (MonadIO m, IsTreeView o) => o -> Gtk.Enums.TreeViewGridLines -> m ()
setTreeViewEnableGridLines obj val = liftIO $ setObjectPropertyEnum obj "enable-grid-lines" val

constructTreeViewEnableGridLines :: (IsTreeView o) => Gtk.Enums.TreeViewGridLines -> IO (GValueConstruct o)
constructTreeViewEnableGridLines val = constructObjectPropertyEnum "enable-grid-lines" val

data TreeViewEnableGridLinesPropertyInfo
instance AttrInfo TreeViewEnableGridLinesPropertyInfo where
    type AttrAllowedOps TreeViewEnableGridLinesPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint TreeViewEnableGridLinesPropertyInfo = (~) Gtk.Enums.TreeViewGridLines
    type AttrBaseTypeConstraint TreeViewEnableGridLinesPropertyInfo = IsTreeView
    type AttrGetType TreeViewEnableGridLinesPropertyInfo = Gtk.Enums.TreeViewGridLines
    type AttrLabel TreeViewEnableGridLinesPropertyInfo = "enable-grid-lines"
    type AttrOrigin TreeViewEnableGridLinesPropertyInfo = TreeView
    attrGet _ = getTreeViewEnableGridLines
    attrSet _ = setTreeViewEnableGridLines
    attrConstruct _ = constructTreeViewEnableGridLines
    attrClear _ = undefined

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

getTreeViewEnableSearch :: (MonadIO m, IsTreeView o) => o -> m Bool
getTreeViewEnableSearch obj = liftIO $ getObjectPropertyBool obj "enable-search"

setTreeViewEnableSearch :: (MonadIO m, IsTreeView o) => o -> Bool -> m ()
setTreeViewEnableSearch obj val = liftIO $ setObjectPropertyBool obj "enable-search" val

constructTreeViewEnableSearch :: (IsTreeView o) => Bool -> IO (GValueConstruct o)
constructTreeViewEnableSearch val = constructObjectPropertyBool "enable-search" val

data TreeViewEnableSearchPropertyInfo
instance AttrInfo TreeViewEnableSearchPropertyInfo where
    type AttrAllowedOps TreeViewEnableSearchPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint TreeViewEnableSearchPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint TreeViewEnableSearchPropertyInfo = IsTreeView
    type AttrGetType TreeViewEnableSearchPropertyInfo = Bool
    type AttrLabel TreeViewEnableSearchPropertyInfo = "enable-search"
    type AttrOrigin TreeViewEnableSearchPropertyInfo = TreeView
    attrGet _ = getTreeViewEnableSearch
    attrSet _ = setTreeViewEnableSearch
    attrConstruct _ = constructTreeViewEnableSearch
    attrClear _ = undefined

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

getTreeViewEnableTreeLines :: (MonadIO m, IsTreeView o) => o -> m Bool
getTreeViewEnableTreeLines obj = liftIO $ getObjectPropertyBool obj "enable-tree-lines"

setTreeViewEnableTreeLines :: (MonadIO m, IsTreeView o) => o -> Bool -> m ()
setTreeViewEnableTreeLines obj val = liftIO $ setObjectPropertyBool obj "enable-tree-lines" val

constructTreeViewEnableTreeLines :: (IsTreeView o) => Bool -> IO (GValueConstruct o)
constructTreeViewEnableTreeLines val = constructObjectPropertyBool "enable-tree-lines" val

data TreeViewEnableTreeLinesPropertyInfo
instance AttrInfo TreeViewEnableTreeLinesPropertyInfo where
    type AttrAllowedOps TreeViewEnableTreeLinesPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint TreeViewEnableTreeLinesPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint TreeViewEnableTreeLinesPropertyInfo = IsTreeView
    type AttrGetType TreeViewEnableTreeLinesPropertyInfo = Bool
    type AttrLabel TreeViewEnableTreeLinesPropertyInfo = "enable-tree-lines"
    type AttrOrigin TreeViewEnableTreeLinesPropertyInfo = TreeView
    attrGet _ = getTreeViewEnableTreeLines
    attrSet _ = setTreeViewEnableTreeLines
    attrConstruct _ = constructTreeViewEnableTreeLines
    attrClear _ = undefined

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

getTreeViewExpanderColumn :: (MonadIO m, IsTreeView o) => o -> m Gtk.TreeViewColumn.TreeViewColumn
getTreeViewExpanderColumn obj = liftIO $ checkUnexpectedNothing "getTreeViewExpanderColumn" $ getObjectPropertyObject obj "expander-column" Gtk.TreeViewColumn.TreeViewColumn

setTreeViewExpanderColumn :: (MonadIO m, IsTreeView o, Gtk.TreeViewColumn.IsTreeViewColumn a) => o -> a -> m ()
setTreeViewExpanderColumn obj val = liftIO $ setObjectPropertyObject obj "expander-column" (Just val)

constructTreeViewExpanderColumn :: (IsTreeView o, Gtk.TreeViewColumn.IsTreeViewColumn a) => a -> IO (GValueConstruct o)
constructTreeViewExpanderColumn val = constructObjectPropertyObject "expander-column" (Just val)

data TreeViewExpanderColumnPropertyInfo
instance AttrInfo TreeViewExpanderColumnPropertyInfo where
    type AttrAllowedOps TreeViewExpanderColumnPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint TreeViewExpanderColumnPropertyInfo = Gtk.TreeViewColumn.IsTreeViewColumn
    type AttrBaseTypeConstraint TreeViewExpanderColumnPropertyInfo = IsTreeView
    type AttrGetType TreeViewExpanderColumnPropertyInfo = Gtk.TreeViewColumn.TreeViewColumn
    type AttrLabel TreeViewExpanderColumnPropertyInfo = "expander-column"
    type AttrOrigin TreeViewExpanderColumnPropertyInfo = TreeView
    attrGet _ = getTreeViewExpanderColumn
    attrSet _ = setTreeViewExpanderColumn
    attrConstruct _ = constructTreeViewExpanderColumn
    attrClear _ = undefined

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

getTreeViewFixedHeightMode :: (MonadIO m, IsTreeView o) => o -> m Bool
getTreeViewFixedHeightMode obj = liftIO $ getObjectPropertyBool obj "fixed-height-mode"

setTreeViewFixedHeightMode :: (MonadIO m, IsTreeView o) => o -> Bool -> m ()
setTreeViewFixedHeightMode obj val = liftIO $ setObjectPropertyBool obj "fixed-height-mode" val

constructTreeViewFixedHeightMode :: (IsTreeView o) => Bool -> IO (GValueConstruct o)
constructTreeViewFixedHeightMode val = constructObjectPropertyBool "fixed-height-mode" val

data TreeViewFixedHeightModePropertyInfo
instance AttrInfo TreeViewFixedHeightModePropertyInfo where
    type AttrAllowedOps TreeViewFixedHeightModePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint TreeViewFixedHeightModePropertyInfo = (~) Bool
    type AttrBaseTypeConstraint TreeViewFixedHeightModePropertyInfo = IsTreeView
    type AttrGetType TreeViewFixedHeightModePropertyInfo = Bool
    type AttrLabel TreeViewFixedHeightModePropertyInfo = "fixed-height-mode"
    type AttrOrigin TreeViewFixedHeightModePropertyInfo = TreeView
    attrGet _ = getTreeViewFixedHeightMode
    attrSet _ = setTreeViewFixedHeightMode
    attrConstruct _ = constructTreeViewFixedHeightMode
    attrClear _ = undefined

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

getTreeViewHeadersClickable :: (MonadIO m, IsTreeView o) => o -> m Bool
getTreeViewHeadersClickable obj = liftIO $ getObjectPropertyBool obj "headers-clickable"

setTreeViewHeadersClickable :: (MonadIO m, IsTreeView o) => o -> Bool -> m ()
setTreeViewHeadersClickable obj val = liftIO $ setObjectPropertyBool obj "headers-clickable" val

constructTreeViewHeadersClickable :: (IsTreeView o) => Bool -> IO (GValueConstruct o)
constructTreeViewHeadersClickable val = constructObjectPropertyBool "headers-clickable" val

data TreeViewHeadersClickablePropertyInfo
instance AttrInfo TreeViewHeadersClickablePropertyInfo where
    type AttrAllowedOps TreeViewHeadersClickablePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint TreeViewHeadersClickablePropertyInfo = (~) Bool
    type AttrBaseTypeConstraint TreeViewHeadersClickablePropertyInfo = IsTreeView
    type AttrGetType TreeViewHeadersClickablePropertyInfo = Bool
    type AttrLabel TreeViewHeadersClickablePropertyInfo = "headers-clickable"
    type AttrOrigin TreeViewHeadersClickablePropertyInfo = TreeView
    attrGet _ = getTreeViewHeadersClickable
    attrSet _ = setTreeViewHeadersClickable
    attrConstruct _ = constructTreeViewHeadersClickable
    attrClear _ = undefined

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

getTreeViewHeadersVisible :: (MonadIO m, IsTreeView o) => o -> m Bool
getTreeViewHeadersVisible obj = liftIO $ getObjectPropertyBool obj "headers-visible"

setTreeViewHeadersVisible :: (MonadIO m, IsTreeView o) => o -> Bool -> m ()
setTreeViewHeadersVisible obj val = liftIO $ setObjectPropertyBool obj "headers-visible" val

constructTreeViewHeadersVisible :: (IsTreeView o) => Bool -> IO (GValueConstruct o)
constructTreeViewHeadersVisible val = constructObjectPropertyBool "headers-visible" val

data TreeViewHeadersVisiblePropertyInfo
instance AttrInfo TreeViewHeadersVisiblePropertyInfo where
    type AttrAllowedOps TreeViewHeadersVisiblePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint TreeViewHeadersVisiblePropertyInfo = (~) Bool
    type AttrBaseTypeConstraint TreeViewHeadersVisiblePropertyInfo = IsTreeView
    type AttrGetType TreeViewHeadersVisiblePropertyInfo = Bool
    type AttrLabel TreeViewHeadersVisiblePropertyInfo = "headers-visible"
    type AttrOrigin TreeViewHeadersVisiblePropertyInfo = TreeView
    attrGet _ = getTreeViewHeadersVisible
    attrSet _ = setTreeViewHeadersVisible
    attrConstruct _ = constructTreeViewHeadersVisible
    attrClear _ = undefined

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

getTreeViewHoverExpand :: (MonadIO m, IsTreeView o) => o -> m Bool
getTreeViewHoverExpand obj = liftIO $ getObjectPropertyBool obj "hover-expand"

setTreeViewHoverExpand :: (MonadIO m, IsTreeView o) => o -> Bool -> m ()
setTreeViewHoverExpand obj val = liftIO $ setObjectPropertyBool obj "hover-expand" val

constructTreeViewHoverExpand :: (IsTreeView o) => Bool -> IO (GValueConstruct o)
constructTreeViewHoverExpand val = constructObjectPropertyBool "hover-expand" val

data TreeViewHoverExpandPropertyInfo
instance AttrInfo TreeViewHoverExpandPropertyInfo where
    type AttrAllowedOps TreeViewHoverExpandPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint TreeViewHoverExpandPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint TreeViewHoverExpandPropertyInfo = IsTreeView
    type AttrGetType TreeViewHoverExpandPropertyInfo = Bool
    type AttrLabel TreeViewHoverExpandPropertyInfo = "hover-expand"
    type AttrOrigin TreeViewHoverExpandPropertyInfo = TreeView
    attrGet _ = getTreeViewHoverExpand
    attrSet _ = setTreeViewHoverExpand
    attrConstruct _ = constructTreeViewHoverExpand
    attrClear _ = undefined

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

getTreeViewHoverSelection :: (MonadIO m, IsTreeView o) => o -> m Bool
getTreeViewHoverSelection obj = liftIO $ getObjectPropertyBool obj "hover-selection"

setTreeViewHoverSelection :: (MonadIO m, IsTreeView o) => o -> Bool -> m ()
setTreeViewHoverSelection obj val = liftIO $ setObjectPropertyBool obj "hover-selection" val

constructTreeViewHoverSelection :: (IsTreeView o) => Bool -> IO (GValueConstruct o)
constructTreeViewHoverSelection val = constructObjectPropertyBool "hover-selection" val

data TreeViewHoverSelectionPropertyInfo
instance AttrInfo TreeViewHoverSelectionPropertyInfo where
    type AttrAllowedOps TreeViewHoverSelectionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint TreeViewHoverSelectionPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint TreeViewHoverSelectionPropertyInfo = IsTreeView
    type AttrGetType TreeViewHoverSelectionPropertyInfo = Bool
    type AttrLabel TreeViewHoverSelectionPropertyInfo = "hover-selection"
    type AttrOrigin TreeViewHoverSelectionPropertyInfo = TreeView
    attrGet _ = getTreeViewHoverSelection
    attrSet _ = setTreeViewHoverSelection
    attrConstruct _ = constructTreeViewHoverSelection
    attrClear _ = undefined

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

getTreeViewLevelIndentation :: (MonadIO m, IsTreeView o) => o -> m Int32
getTreeViewLevelIndentation obj = liftIO $ getObjectPropertyInt32 obj "level-indentation"

setTreeViewLevelIndentation :: (MonadIO m, IsTreeView o) => o -> Int32 -> m ()
setTreeViewLevelIndentation obj val = liftIO $ setObjectPropertyInt32 obj "level-indentation" val

constructTreeViewLevelIndentation :: (IsTreeView o) => Int32 -> IO (GValueConstruct o)
constructTreeViewLevelIndentation val = constructObjectPropertyInt32 "level-indentation" val

data TreeViewLevelIndentationPropertyInfo
instance AttrInfo TreeViewLevelIndentationPropertyInfo where
    type AttrAllowedOps TreeViewLevelIndentationPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint TreeViewLevelIndentationPropertyInfo = (~) Int32
    type AttrBaseTypeConstraint TreeViewLevelIndentationPropertyInfo = IsTreeView
    type AttrGetType TreeViewLevelIndentationPropertyInfo = Int32
    type AttrLabel TreeViewLevelIndentationPropertyInfo = "level-indentation"
    type AttrOrigin TreeViewLevelIndentationPropertyInfo = TreeView
    attrGet _ = getTreeViewLevelIndentation
    attrSet _ = setTreeViewLevelIndentation
    attrConstruct _ = constructTreeViewLevelIndentation
    attrClear _ = undefined

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

getTreeViewModel :: (MonadIO m, IsTreeView o) => o -> m (Maybe Gtk.TreeModel.TreeModel)
getTreeViewModel obj = liftIO $ getObjectPropertyObject obj "model" Gtk.TreeModel.TreeModel

setTreeViewModel :: (MonadIO m, IsTreeView o, Gtk.TreeModel.IsTreeModel a) => o -> a -> m ()
setTreeViewModel obj val = liftIO $ setObjectPropertyObject obj "model" (Just val)

constructTreeViewModel :: (IsTreeView o, Gtk.TreeModel.IsTreeModel a) => a -> IO (GValueConstruct o)
constructTreeViewModel val = constructObjectPropertyObject "model" (Just val)

clearTreeViewModel :: (MonadIO m, IsTreeView o) => o -> m ()
clearTreeViewModel obj = liftIO $ setObjectPropertyObject obj "model" (Nothing :: Maybe Gtk.TreeModel.TreeModel)

data TreeViewModelPropertyInfo
instance AttrInfo TreeViewModelPropertyInfo where
    type AttrAllowedOps TreeViewModelPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint TreeViewModelPropertyInfo = Gtk.TreeModel.IsTreeModel
    type AttrBaseTypeConstraint TreeViewModelPropertyInfo = IsTreeView
    type AttrGetType TreeViewModelPropertyInfo = (Maybe Gtk.TreeModel.TreeModel)
    type AttrLabel TreeViewModelPropertyInfo = "model"
    type AttrOrigin TreeViewModelPropertyInfo = TreeView
    attrGet _ = getTreeViewModel
    attrSet _ = setTreeViewModel
    attrConstruct _ = constructTreeViewModel
    attrClear _ = clearTreeViewModel

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

getTreeViewReorderable :: (MonadIO m, IsTreeView o) => o -> m Bool
getTreeViewReorderable obj = liftIO $ getObjectPropertyBool obj "reorderable"

setTreeViewReorderable :: (MonadIO m, IsTreeView o) => o -> Bool -> m ()
setTreeViewReorderable obj val = liftIO $ setObjectPropertyBool obj "reorderable" val

constructTreeViewReorderable :: (IsTreeView o) => Bool -> IO (GValueConstruct o)
constructTreeViewReorderable val = constructObjectPropertyBool "reorderable" val

data TreeViewReorderablePropertyInfo
instance AttrInfo TreeViewReorderablePropertyInfo where
    type AttrAllowedOps TreeViewReorderablePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint TreeViewReorderablePropertyInfo = (~) Bool
    type AttrBaseTypeConstraint TreeViewReorderablePropertyInfo = IsTreeView
    type AttrGetType TreeViewReorderablePropertyInfo = Bool
    type AttrLabel TreeViewReorderablePropertyInfo = "reorderable"
    type AttrOrigin TreeViewReorderablePropertyInfo = TreeView
    attrGet _ = getTreeViewReorderable
    attrSet _ = setTreeViewReorderable
    attrConstruct _ = constructTreeViewReorderable
    attrClear _ = undefined

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

getTreeViewRubberBanding :: (MonadIO m, IsTreeView o) => o -> m Bool
getTreeViewRubberBanding obj = liftIO $ getObjectPropertyBool obj "rubber-banding"

setTreeViewRubberBanding :: (MonadIO m, IsTreeView o) => o -> Bool -> m ()
setTreeViewRubberBanding obj val = liftIO $ setObjectPropertyBool obj "rubber-banding" val

constructTreeViewRubberBanding :: (IsTreeView o) => Bool -> IO (GValueConstruct o)
constructTreeViewRubberBanding val = constructObjectPropertyBool "rubber-banding" val

data TreeViewRubberBandingPropertyInfo
instance AttrInfo TreeViewRubberBandingPropertyInfo where
    type AttrAllowedOps TreeViewRubberBandingPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint TreeViewRubberBandingPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint TreeViewRubberBandingPropertyInfo = IsTreeView
    type AttrGetType TreeViewRubberBandingPropertyInfo = Bool
    type AttrLabel TreeViewRubberBandingPropertyInfo = "rubber-banding"
    type AttrOrigin TreeViewRubberBandingPropertyInfo = TreeView
    attrGet _ = getTreeViewRubberBanding
    attrSet _ = setTreeViewRubberBanding
    attrConstruct _ = constructTreeViewRubberBanding
    attrClear _ = undefined

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

getTreeViewRulesHint :: (MonadIO m, IsTreeView o) => o -> m Bool
getTreeViewRulesHint obj = liftIO $ getObjectPropertyBool obj "rules-hint"

setTreeViewRulesHint :: (MonadIO m, IsTreeView o) => o -> Bool -> m ()
setTreeViewRulesHint obj val = liftIO $ setObjectPropertyBool obj "rules-hint" val

constructTreeViewRulesHint :: (IsTreeView o) => Bool -> IO (GValueConstruct o)
constructTreeViewRulesHint val = constructObjectPropertyBool "rules-hint" val

data TreeViewRulesHintPropertyInfo
instance AttrInfo TreeViewRulesHintPropertyInfo where
    type AttrAllowedOps TreeViewRulesHintPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint TreeViewRulesHintPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint TreeViewRulesHintPropertyInfo = IsTreeView
    type AttrGetType TreeViewRulesHintPropertyInfo = Bool
    type AttrLabel TreeViewRulesHintPropertyInfo = "rules-hint"
    type AttrOrigin TreeViewRulesHintPropertyInfo = TreeView
    attrGet _ = getTreeViewRulesHint
    attrSet _ = setTreeViewRulesHint
    attrConstruct _ = constructTreeViewRulesHint
    attrClear _ = undefined

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

getTreeViewSearchColumn :: (MonadIO m, IsTreeView o) => o -> m Int32
getTreeViewSearchColumn obj = liftIO $ getObjectPropertyInt32 obj "search-column"

setTreeViewSearchColumn :: (MonadIO m, IsTreeView o) => o -> Int32 -> m ()
setTreeViewSearchColumn obj val = liftIO $ setObjectPropertyInt32 obj "search-column" val

constructTreeViewSearchColumn :: (IsTreeView o) => Int32 -> IO (GValueConstruct o)
constructTreeViewSearchColumn val = constructObjectPropertyInt32 "search-column" val

data TreeViewSearchColumnPropertyInfo
instance AttrInfo TreeViewSearchColumnPropertyInfo where
    type AttrAllowedOps TreeViewSearchColumnPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint TreeViewSearchColumnPropertyInfo = (~) Int32
    type AttrBaseTypeConstraint TreeViewSearchColumnPropertyInfo = IsTreeView
    type AttrGetType TreeViewSearchColumnPropertyInfo = Int32
    type AttrLabel TreeViewSearchColumnPropertyInfo = "search-column"
    type AttrOrigin TreeViewSearchColumnPropertyInfo = TreeView
    attrGet _ = getTreeViewSearchColumn
    attrSet _ = setTreeViewSearchColumn
    attrConstruct _ = constructTreeViewSearchColumn
    attrClear _ = undefined

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

getTreeViewShowExpanders :: (MonadIO m, IsTreeView o) => o -> m Bool
getTreeViewShowExpanders obj = liftIO $ getObjectPropertyBool obj "show-expanders"

setTreeViewShowExpanders :: (MonadIO m, IsTreeView o) => o -> Bool -> m ()
setTreeViewShowExpanders obj val = liftIO $ setObjectPropertyBool obj "show-expanders" val

constructTreeViewShowExpanders :: (IsTreeView o) => Bool -> IO (GValueConstruct o)
constructTreeViewShowExpanders val = constructObjectPropertyBool "show-expanders" val

data TreeViewShowExpandersPropertyInfo
instance AttrInfo TreeViewShowExpandersPropertyInfo where
    type AttrAllowedOps TreeViewShowExpandersPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint TreeViewShowExpandersPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint TreeViewShowExpandersPropertyInfo = IsTreeView
    type AttrGetType TreeViewShowExpandersPropertyInfo = Bool
    type AttrLabel TreeViewShowExpandersPropertyInfo = "show-expanders"
    type AttrOrigin TreeViewShowExpandersPropertyInfo = TreeView
    attrGet _ = getTreeViewShowExpanders
    attrSet _ = setTreeViewShowExpanders
    attrConstruct _ = constructTreeViewShowExpanders
    attrClear _ = undefined

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

getTreeViewTooltipColumn :: (MonadIO m, IsTreeView o) => o -> m Int32
getTreeViewTooltipColumn obj = liftIO $ getObjectPropertyInt32 obj "tooltip-column"

setTreeViewTooltipColumn :: (MonadIO m, IsTreeView o) => o -> Int32 -> m ()
setTreeViewTooltipColumn obj val = liftIO $ setObjectPropertyInt32 obj "tooltip-column" val

constructTreeViewTooltipColumn :: (IsTreeView o) => Int32 -> IO (GValueConstruct o)
constructTreeViewTooltipColumn val = constructObjectPropertyInt32 "tooltip-column" val

data TreeViewTooltipColumnPropertyInfo
instance AttrInfo TreeViewTooltipColumnPropertyInfo where
    type AttrAllowedOps TreeViewTooltipColumnPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint TreeViewTooltipColumnPropertyInfo = (~) Int32
    type AttrBaseTypeConstraint TreeViewTooltipColumnPropertyInfo = IsTreeView
    type AttrGetType TreeViewTooltipColumnPropertyInfo = Int32
    type AttrLabel TreeViewTooltipColumnPropertyInfo = "tooltip-column"
    type AttrOrigin TreeViewTooltipColumnPropertyInfo = TreeView
    attrGet _ = getTreeViewTooltipColumn
    attrSet _ = setTreeViewTooltipColumn
    attrConstruct _ = constructTreeViewTooltipColumn
    attrClear _ = undefined

instance O.HasAttributeList TreeView
type instance O.AttributeList TreeView = TreeViewAttributeList
type TreeViewAttributeList = ('[ '("activateOnSingleClick", TreeViewActivateOnSingleClickPropertyInfo), '("appPaintable", Gtk.Widget.WidgetAppPaintablePropertyInfo), '("borderWidth", Gtk.Container.ContainerBorderWidthPropertyInfo), '("canDefault", Gtk.Widget.WidgetCanDefaultPropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("child", Gtk.Container.ContainerChildPropertyInfo), '("compositeChild", Gtk.Widget.WidgetCompositeChildPropertyInfo), '("doubleBuffered", Gtk.Widget.WidgetDoubleBufferedPropertyInfo), '("enableGridLines", TreeViewEnableGridLinesPropertyInfo), '("enableSearch", TreeViewEnableSearchPropertyInfo), '("enableTreeLines", TreeViewEnableTreeLinesPropertyInfo), '("events", Gtk.Widget.WidgetEventsPropertyInfo), '("expand", Gtk.Widget.WidgetExpandPropertyInfo), '("expanderColumn", TreeViewExpanderColumnPropertyInfo), '("fixedHeightMode", TreeViewFixedHeightModePropertyInfo), '("focusOnClick", Gtk.Widget.WidgetFocusOnClickPropertyInfo), '("hadjustment", Gtk.Scrollable.ScrollableHadjustmentPropertyInfo), '("halign", Gtk.Widget.WidgetHalignPropertyInfo), '("hasDefault", Gtk.Widget.WidgetHasDefaultPropertyInfo), '("hasFocus", Gtk.Widget.WidgetHasFocusPropertyInfo), '("hasTooltip", Gtk.Widget.WidgetHasTooltipPropertyInfo), '("headersClickable", TreeViewHeadersClickablePropertyInfo), '("headersVisible", TreeViewHeadersVisiblePropertyInfo), '("heightRequest", Gtk.Widget.WidgetHeightRequestPropertyInfo), '("hexpand", Gtk.Widget.WidgetHexpandPropertyInfo), '("hexpandSet", Gtk.Widget.WidgetHexpandSetPropertyInfo), '("hoverExpand", TreeViewHoverExpandPropertyInfo), '("hoverSelection", TreeViewHoverSelectionPropertyInfo), '("hscrollPolicy", Gtk.Scrollable.ScrollableHscrollPolicyPropertyInfo), '("isFocus", Gtk.Widget.WidgetIsFocusPropertyInfo), '("levelIndentation", TreeViewLevelIndentationPropertyInfo), '("margin", Gtk.Widget.WidgetMarginPropertyInfo), '("marginBottom", Gtk.Widget.WidgetMarginBottomPropertyInfo), '("marginEnd", Gtk.Widget.WidgetMarginEndPropertyInfo), '("marginLeft", Gtk.Widget.WidgetMarginLeftPropertyInfo), '("marginRight", Gtk.Widget.WidgetMarginRightPropertyInfo), '("marginStart", Gtk.Widget.WidgetMarginStartPropertyInfo), '("marginTop", Gtk.Widget.WidgetMarginTopPropertyInfo), '("model", TreeViewModelPropertyInfo), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("noShowAll", Gtk.Widget.WidgetNoShowAllPropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("reorderable", TreeViewReorderablePropertyInfo), '("resizeMode", Gtk.Container.ContainerResizeModePropertyInfo), '("rubberBanding", TreeViewRubberBandingPropertyInfo), '("rulesHint", TreeViewRulesHintPropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("searchColumn", TreeViewSearchColumnPropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("showExpanders", TreeViewShowExpandersPropertyInfo), '("style", Gtk.Widget.WidgetStylePropertyInfo), '("tooltipColumn", TreeViewTooltipColumnPropertyInfo), '("tooltipMarkup", Gtk.Widget.WidgetTooltipMarkupPropertyInfo), '("tooltipText", Gtk.Widget.WidgetTooltipTextPropertyInfo), '("vadjustment", Gtk.Scrollable.ScrollableVadjustmentPropertyInfo), '("valign", Gtk.Widget.WidgetValignPropertyInfo), '("vexpand", Gtk.Widget.WidgetVexpandPropertyInfo), '("vexpandSet", Gtk.Widget.WidgetVexpandSetPropertyInfo), '("visible", Gtk.Widget.WidgetVisiblePropertyInfo), '("vscrollPolicy", Gtk.Scrollable.ScrollableVscrollPolicyPropertyInfo), '("widthRequest", Gtk.Widget.WidgetWidthRequestPropertyInfo), '("window", Gtk.Widget.WidgetWindowPropertyInfo)] :: [(Symbol, *)])

treeViewActivateOnSingleClick :: AttrLabelProxy "activateOnSingleClick"
treeViewActivateOnSingleClick = AttrLabelProxy

treeViewEnableGridLines :: AttrLabelProxy "enableGridLines"
treeViewEnableGridLines = AttrLabelProxy

treeViewEnableSearch :: AttrLabelProxy "enableSearch"
treeViewEnableSearch = AttrLabelProxy

treeViewEnableTreeLines :: AttrLabelProxy "enableTreeLines"
treeViewEnableTreeLines = AttrLabelProxy

treeViewExpanderColumn :: AttrLabelProxy "expanderColumn"
treeViewExpanderColumn = AttrLabelProxy

treeViewFixedHeightMode :: AttrLabelProxy "fixedHeightMode"
treeViewFixedHeightMode = AttrLabelProxy

treeViewHeadersClickable :: AttrLabelProxy "headersClickable"
treeViewHeadersClickable = AttrLabelProxy

treeViewHeadersVisible :: AttrLabelProxy "headersVisible"
treeViewHeadersVisible = AttrLabelProxy

treeViewHoverExpand :: AttrLabelProxy "hoverExpand"
treeViewHoverExpand = AttrLabelProxy

treeViewHoverSelection :: AttrLabelProxy "hoverSelection"
treeViewHoverSelection = AttrLabelProxy

treeViewLevelIndentation :: AttrLabelProxy "levelIndentation"
treeViewLevelIndentation = AttrLabelProxy

treeViewModel :: AttrLabelProxy "model"
treeViewModel = AttrLabelProxy

treeViewReorderable :: AttrLabelProxy "reorderable"
treeViewReorderable = AttrLabelProxy

treeViewRubberBanding :: AttrLabelProxy "rubberBanding"
treeViewRubberBanding = AttrLabelProxy

treeViewRulesHint :: AttrLabelProxy "rulesHint"
treeViewRulesHint = AttrLabelProxy

treeViewSearchColumn :: AttrLabelProxy "searchColumn"
treeViewSearchColumn = AttrLabelProxy

treeViewShowExpanders :: AttrLabelProxy "showExpanders"
treeViewShowExpanders = AttrLabelProxy

treeViewTooltipColumn :: AttrLabelProxy "tooltipColumn"
treeViewTooltipColumn = AttrLabelProxy

data TreeViewColumnsChangedSignalInfo
instance SignalInfo TreeViewColumnsChangedSignalInfo where
    type HaskellCallbackType TreeViewColumnsChangedSignalInfo = TreeViewColumnsChangedCallback
    connectSignal _ = connectTreeViewColumnsChanged

data TreeViewCursorChangedSignalInfo
instance SignalInfo TreeViewCursorChangedSignalInfo where
    type HaskellCallbackType TreeViewCursorChangedSignalInfo = TreeViewCursorChangedCallback
    connectSignal _ = connectTreeViewCursorChanged

data TreeViewExpandCollapseCursorRowSignalInfo
instance SignalInfo TreeViewExpandCollapseCursorRowSignalInfo where
    type HaskellCallbackType TreeViewExpandCollapseCursorRowSignalInfo = TreeViewExpandCollapseCursorRowCallback
    connectSignal _ = connectTreeViewExpandCollapseCursorRow

data TreeViewMoveCursorSignalInfo
instance SignalInfo TreeViewMoveCursorSignalInfo where
    type HaskellCallbackType TreeViewMoveCursorSignalInfo = TreeViewMoveCursorCallback
    connectSignal _ = connectTreeViewMoveCursor

data TreeViewRowActivatedSignalInfo
instance SignalInfo TreeViewRowActivatedSignalInfo where
    type HaskellCallbackType TreeViewRowActivatedSignalInfo = TreeViewRowActivatedCallback
    connectSignal _ = connectTreeViewRowActivated

data TreeViewRowCollapsedSignalInfo
instance SignalInfo TreeViewRowCollapsedSignalInfo where
    type HaskellCallbackType TreeViewRowCollapsedSignalInfo = TreeViewRowCollapsedCallback
    connectSignal _ = connectTreeViewRowCollapsed

data TreeViewRowExpandedSignalInfo
instance SignalInfo TreeViewRowExpandedSignalInfo where
    type HaskellCallbackType TreeViewRowExpandedSignalInfo = TreeViewRowExpandedCallback
    connectSignal _ = connectTreeViewRowExpanded

data TreeViewSelectAllSignalInfo
instance SignalInfo TreeViewSelectAllSignalInfo where
    type HaskellCallbackType TreeViewSelectAllSignalInfo = TreeViewSelectAllCallback
    connectSignal _ = connectTreeViewSelectAll

data TreeViewSelectCursorParentSignalInfo
instance SignalInfo TreeViewSelectCursorParentSignalInfo where
    type HaskellCallbackType TreeViewSelectCursorParentSignalInfo = TreeViewSelectCursorParentCallback
    connectSignal _ = connectTreeViewSelectCursorParent

data TreeViewSelectCursorRowSignalInfo
instance SignalInfo TreeViewSelectCursorRowSignalInfo where
    type HaskellCallbackType TreeViewSelectCursorRowSignalInfo = TreeViewSelectCursorRowCallback
    connectSignal _ = connectTreeViewSelectCursorRow

data TreeViewStartInteractiveSearchSignalInfo
instance SignalInfo TreeViewStartInteractiveSearchSignalInfo where
    type HaskellCallbackType TreeViewStartInteractiveSearchSignalInfo = TreeViewStartInteractiveSearchCallback
    connectSignal _ = connectTreeViewStartInteractiveSearch

data TreeViewTestCollapseRowSignalInfo
instance SignalInfo TreeViewTestCollapseRowSignalInfo where
    type HaskellCallbackType TreeViewTestCollapseRowSignalInfo = TreeViewTestCollapseRowCallback
    connectSignal _ = connectTreeViewTestCollapseRow

data TreeViewTestExpandRowSignalInfo
instance SignalInfo TreeViewTestExpandRowSignalInfo where
    type HaskellCallbackType TreeViewTestExpandRowSignalInfo = TreeViewTestExpandRowCallback
    connectSignal _ = connectTreeViewTestExpandRow

data TreeViewToggleCursorRowSignalInfo
instance SignalInfo TreeViewToggleCursorRowSignalInfo where
    type HaskellCallbackType TreeViewToggleCursorRowSignalInfo = TreeViewToggleCursorRowCallback
    connectSignal _ = connectTreeViewToggleCursorRow

data TreeViewUnselectAllSignalInfo
instance SignalInfo TreeViewUnselectAllSignalInfo where
    type HaskellCallbackType TreeViewUnselectAllSignalInfo = TreeViewUnselectAllCallback
    connectSignal _ = connectTreeViewUnselectAll

type instance O.SignalList TreeView = TreeViewSignalList
type TreeViewSignalList = ('[ '("accelClosuresChanged", Gtk.Widget.WidgetAccelClosuresChangedSignalInfo), '("add", Gtk.Container.ContainerAddSignalInfo), '("buttonPressEvent", Gtk.Widget.WidgetButtonPressEventSignalInfo), '("buttonReleaseEvent", Gtk.Widget.WidgetButtonReleaseEventSignalInfo), '("canActivateAccel", Gtk.Widget.WidgetCanActivateAccelSignalInfo), '("checkResize", Gtk.Container.ContainerCheckResizeSignalInfo), '("childNotify", Gtk.Widget.WidgetChildNotifySignalInfo), '("columnsChanged", TreeViewColumnsChangedSignalInfo), '("compositedChanged", Gtk.Widget.WidgetCompositedChangedSignalInfo), '("configureEvent", Gtk.Widget.WidgetConfigureEventSignalInfo), '("cursorChanged", TreeViewCursorChangedSignalInfo), '("damageEvent", Gtk.Widget.WidgetDamageEventSignalInfo), '("deleteEvent", Gtk.Widget.WidgetDeleteEventSignalInfo), '("destroy", Gtk.Widget.WidgetDestroySignalInfo), '("destroyEvent", Gtk.Widget.WidgetDestroyEventSignalInfo), '("directionChanged", Gtk.Widget.WidgetDirectionChangedSignalInfo), '("dragBegin", Gtk.Widget.WidgetDragBeginSignalInfo), '("dragDataDelete", Gtk.Widget.WidgetDragDataDeleteSignalInfo), '("dragDataGet", Gtk.Widget.WidgetDragDataGetSignalInfo), '("dragDataReceived", Gtk.Widget.WidgetDragDataReceivedSignalInfo), '("dragDrop", Gtk.Widget.WidgetDragDropSignalInfo), '("dragEnd", Gtk.Widget.WidgetDragEndSignalInfo), '("dragFailed", Gtk.Widget.WidgetDragFailedSignalInfo), '("dragLeave", Gtk.Widget.WidgetDragLeaveSignalInfo), '("dragMotion", Gtk.Widget.WidgetDragMotionSignalInfo), '("draw", Gtk.Widget.WidgetDrawSignalInfo), '("enterNotifyEvent", Gtk.Widget.WidgetEnterNotifyEventSignalInfo), '("event", Gtk.Widget.WidgetEventSignalInfo), '("eventAfter", Gtk.Widget.WidgetEventAfterSignalInfo), '("expandCollapseCursorRow", TreeViewExpandCollapseCursorRowSignalInfo), '("focus", Gtk.Widget.WidgetFocusSignalInfo), '("focusInEvent", Gtk.Widget.WidgetFocusInEventSignalInfo), '("focusOutEvent", Gtk.Widget.WidgetFocusOutEventSignalInfo), '("grabBrokenEvent", Gtk.Widget.WidgetGrabBrokenEventSignalInfo), '("grabFocus", Gtk.Widget.WidgetGrabFocusSignalInfo), '("grabNotify", Gtk.Widget.WidgetGrabNotifySignalInfo), '("hide", Gtk.Widget.WidgetHideSignalInfo), '("hierarchyChanged", Gtk.Widget.WidgetHierarchyChangedSignalInfo), '("keyPressEvent", Gtk.Widget.WidgetKeyPressEventSignalInfo), '("keyReleaseEvent", Gtk.Widget.WidgetKeyReleaseEventSignalInfo), '("keynavFailed", Gtk.Widget.WidgetKeynavFailedSignalInfo), '("leaveNotifyEvent", Gtk.Widget.WidgetLeaveNotifyEventSignalInfo), '("map", Gtk.Widget.WidgetMapSignalInfo), '("mapEvent", Gtk.Widget.WidgetMapEventSignalInfo), '("mnemonicActivate", Gtk.Widget.WidgetMnemonicActivateSignalInfo), '("motionNotifyEvent", Gtk.Widget.WidgetMotionNotifyEventSignalInfo), '("moveCursor", TreeViewMoveCursorSignalInfo), '("moveFocus", Gtk.Widget.WidgetMoveFocusSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("parentSet", Gtk.Widget.WidgetParentSetSignalInfo), '("popupMenu", Gtk.Widget.WidgetPopupMenuSignalInfo), '("propertyNotifyEvent", Gtk.Widget.WidgetPropertyNotifyEventSignalInfo), '("proximityInEvent", Gtk.Widget.WidgetProximityInEventSignalInfo), '("proximityOutEvent", Gtk.Widget.WidgetProximityOutEventSignalInfo), '("queryTooltip", Gtk.Widget.WidgetQueryTooltipSignalInfo), '("realize", Gtk.Widget.WidgetRealizeSignalInfo), '("remove", Gtk.Container.ContainerRemoveSignalInfo), '("rowActivated", TreeViewRowActivatedSignalInfo), '("rowCollapsed", TreeViewRowCollapsedSignalInfo), '("rowExpanded", TreeViewRowExpandedSignalInfo), '("screenChanged", Gtk.Widget.WidgetScreenChangedSignalInfo), '("scrollEvent", Gtk.Widget.WidgetScrollEventSignalInfo), '("selectAll", TreeViewSelectAllSignalInfo), '("selectCursorParent", TreeViewSelectCursorParentSignalInfo), '("selectCursorRow", TreeViewSelectCursorRowSignalInfo), '("selectionClearEvent", Gtk.Widget.WidgetSelectionClearEventSignalInfo), '("selectionGet", Gtk.Widget.WidgetSelectionGetSignalInfo), '("selectionNotifyEvent", Gtk.Widget.WidgetSelectionNotifyEventSignalInfo), '("selectionReceived", Gtk.Widget.WidgetSelectionReceivedSignalInfo), '("selectionRequestEvent", Gtk.Widget.WidgetSelectionRequestEventSignalInfo), '("setFocusChild", Gtk.Container.ContainerSetFocusChildSignalInfo), '("show", Gtk.Widget.WidgetShowSignalInfo), '("showHelp", Gtk.Widget.WidgetShowHelpSignalInfo), '("sizeAllocate", Gtk.Widget.WidgetSizeAllocateSignalInfo), '("startInteractiveSearch", TreeViewStartInteractiveSearchSignalInfo), '("stateChanged", Gtk.Widget.WidgetStateChangedSignalInfo), '("stateFlagsChanged", Gtk.Widget.WidgetStateFlagsChangedSignalInfo), '("styleSet", Gtk.Widget.WidgetStyleSetSignalInfo), '("styleUpdated", Gtk.Widget.WidgetStyleUpdatedSignalInfo), '("testCollapseRow", TreeViewTestCollapseRowSignalInfo), '("testExpandRow", TreeViewTestExpandRowSignalInfo), '("toggleCursorRow", TreeViewToggleCursorRowSignalInfo), '("touchEvent", Gtk.Widget.WidgetTouchEventSignalInfo), '("unmap", Gtk.Widget.WidgetUnmapSignalInfo), '("unmapEvent", Gtk.Widget.WidgetUnmapEventSignalInfo), '("unrealize", Gtk.Widget.WidgetUnrealizeSignalInfo), '("unselectAll", TreeViewUnselectAllSignalInfo), '("visibilityNotifyEvent", Gtk.Widget.WidgetVisibilityNotifyEventSignalInfo), '("windowStateEvent", Gtk.Widget.WidgetWindowStateEventSignalInfo)] :: [(Symbol, *)])

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

foreign import ccall "gtk_tree_view_new" gtk_tree_view_new :: 
    IO (Ptr TreeView)

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

-- method TreeView::new_with_model
-- method type : Constructor
-- Args : [Arg {argCName = "model", argType = TInterface (Name {namespace = "Gtk", name = "TreeModel"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the model.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "TreeView"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_tree_view_new_with_model" gtk_tree_view_new_with_model :: 
    Ptr Gtk.TreeModel.TreeModel ->          -- model : TInterface (Name {namespace = "Gtk", name = "TreeModel"})
    IO (Ptr TreeView)

{- |
Creates a new 'GI.Gtk.Objects.TreeView.TreeView' widget with the model initialized to /@model@/.
-}
treeViewNewWithModel ::
    (B.CallStack.HasCallStack, MonadIO m, Gtk.TreeModel.IsTreeModel a) =>
    a
    {- ^ /@model@/: the model. -}
    -> m TreeView
    {- ^ __Returns:__ A newly created 'GI.Gtk.Objects.TreeView.TreeView' widget. -}
treeViewNewWithModel model = liftIO $ do
    model' <- unsafeManagedPtrCastPtr model
    result <- gtk_tree_view_new_with_model model'
    checkUnexpectedReturnNULL "treeViewNewWithModel" result
    result' <- (newObject TreeView) result
    touchManagedPtr model
    return result'

-- method TreeView::append_column
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeView.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "column", argType = TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The #GtkTreeViewColumn to add.", 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_append_column" gtk_tree_view_append_column :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    Ptr Gtk.TreeViewColumn.TreeViewColumn -> -- column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
    IO Int32

{- |
Appends /@column@/ to the list of columns. If /@treeView@/ has “fixed_height”
mode enabled, then /@column@/ must have its “sizing” property set to be
GTK_TREE_VIEW_COLUMN_FIXED.
-}
treeViewAppendColumn ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a, Gtk.TreeViewColumn.IsTreeViewColumn b) =>
    a
    {- ^ /@treeView@/: A 'GI.Gtk.Objects.TreeView.TreeView'. -}
    -> b
    {- ^ /@column@/: The 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn' to add. -}
    -> m Int32
    {- ^ __Returns:__ The number of columns in /@treeView@/ after appending. -}
treeViewAppendColumn treeView column = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    column' <- unsafeManagedPtrCastPtr column
    result <- gtk_tree_view_append_column treeView' column'
    touchManagedPtr treeView
    touchManagedPtr column
    return result

data TreeViewAppendColumnMethodInfo
instance (signature ~ (b -> m Int32), MonadIO m, IsTreeView a, Gtk.TreeViewColumn.IsTreeViewColumn b) => O.MethodInfo TreeViewAppendColumnMethodInfo a signature where
    overloadedMethod _ = treeViewAppendColumn

-- method TreeView::collapse_all
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeView.", 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_collapse_all" gtk_tree_view_collapse_all :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    IO ()

{- |
Recursively collapses all visible, expanded nodes in /@treeView@/.
-}
treeViewCollapseAll ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: A 'GI.Gtk.Objects.TreeView.TreeView'. -}
    -> m ()
treeViewCollapseAll treeView = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    gtk_tree_view_collapse_all treeView'
    touchManagedPtr treeView
    return ()

data TreeViewCollapseAllMethodInfo
instance (signature ~ (m ()), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewCollapseAllMethodInfo a signature where
    overloadedMethod _ = treeViewCollapseAll

-- method TreeView::collapse_row
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTreeView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TInterface (Name {namespace = "Gtk", name = "TreePath"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "path to a row in the @tree_view", 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_collapse_row" gtk_tree_view_collapse_row :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    Ptr Gtk.TreePath.TreePath ->            -- path : TInterface (Name {namespace = "Gtk", name = "TreePath"})
    IO CInt

{- |
Collapses a row (hides its child rows, if they exist).
-}
treeViewCollapseRow ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: a 'GI.Gtk.Objects.TreeView.TreeView' -}
    -> Gtk.TreePath.TreePath
    {- ^ /@path@/: path to a row in the /@treeView@/ -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the row was collapsed. -}
treeViewCollapseRow treeView path = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    path' <- unsafeManagedPtrGetPtr path
    result <- gtk_tree_view_collapse_row treeView' path'
    let result' = (/= 0) result
    touchManagedPtr treeView
    touchManagedPtr path
    return result'

data TreeViewCollapseRowMethodInfo
instance (signature ~ (Gtk.TreePath.TreePath -> m Bool), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewCollapseRowMethodInfo a signature where
    overloadedMethod _ = treeViewCollapseRow

-- method TreeView::columns_autosize
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeView.", 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_columns_autosize" gtk_tree_view_columns_autosize :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    IO ()

{- |
Resizes all columns to their optimal width. Only works after the
treeview has been realized.
-}
treeViewColumnsAutosize ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: A 'GI.Gtk.Objects.TreeView.TreeView'. -}
    -> m ()
treeViewColumnsAutosize treeView = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    gtk_tree_view_columns_autosize treeView'
    touchManagedPtr treeView
    return ()

data TreeViewColumnsAutosizeMethodInfo
instance (signature ~ (m ()), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewColumnsAutosizeMethodInfo a signature where
    overloadedMethod _ = treeViewColumnsAutosize

-- method TreeView::convert_bin_window_to_tree_coords
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTreeView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "bx", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "X coordinate relative to bin_window", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "by", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Y coordinate relative to bin_window", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tx", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for tree X coordinate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "ty", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for tree Y coordinate", 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_convert_bin_window_to_tree_coords" gtk_tree_view_convert_bin_window_to_tree_coords :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    Int32 ->                                -- bx : TBasicType TInt
    Int32 ->                                -- by : TBasicType TInt
    Ptr Int32 ->                            -- tx : TBasicType TInt
    Ptr Int32 ->                            -- ty : TBasicType TInt
    IO ()

{- |
Converts bin_window coordinates to coordinates for the
tree (the full scrollable area of the tree).

@since 2.12
-}
treeViewConvertBinWindowToTreeCoords ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: a 'GI.Gtk.Objects.TreeView.TreeView' -}
    -> Int32
    {- ^ /@bx@/: X coordinate relative to bin_window -}
    -> Int32
    {- ^ /@by@/: Y coordinate relative to bin_window -}
    -> m (Int32,Int32)
treeViewConvertBinWindowToTreeCoords treeView bx by = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    tx <- allocMem :: IO (Ptr Int32)
    ty <- allocMem :: IO (Ptr Int32)
    gtk_tree_view_convert_bin_window_to_tree_coords treeView' bx by tx ty
    tx' <- peek tx
    ty' <- peek ty
    touchManagedPtr treeView
    freeMem tx
    freeMem ty
    return (tx', ty')

data TreeViewConvertBinWindowToTreeCoordsMethodInfo
instance (signature ~ (Int32 -> Int32 -> m (Int32,Int32)), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewConvertBinWindowToTreeCoordsMethodInfo a signature where
    overloadedMethod _ = treeViewConvertBinWindowToTreeCoords

-- method TreeView::convert_bin_window_to_widget_coords
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTreeView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "bx", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "bin_window X coordinate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "by", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "bin_window Y coordinate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "wx", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for widget X coordinate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "wy", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for widget Y coordinate", 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_convert_bin_window_to_widget_coords" gtk_tree_view_convert_bin_window_to_widget_coords :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    Int32 ->                                -- bx : TBasicType TInt
    Int32 ->                                -- by : TBasicType TInt
    Ptr Int32 ->                            -- wx : TBasicType TInt
    Ptr Int32 ->                            -- wy : TBasicType TInt
    IO ()

{- |
Converts bin_window coordinates (see 'GI.Gtk.Objects.TreeView.treeViewGetBinWindow')
to widget relative coordinates.

@since 2.12
-}
treeViewConvertBinWindowToWidgetCoords ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: a 'GI.Gtk.Objects.TreeView.TreeView' -}
    -> Int32
    {- ^ /@bx@/: bin_window X coordinate -}
    -> Int32
    {- ^ /@by@/: bin_window Y coordinate -}
    -> m (Int32,Int32)
treeViewConvertBinWindowToWidgetCoords treeView bx by = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    wx <- allocMem :: IO (Ptr Int32)
    wy <- allocMem :: IO (Ptr Int32)
    gtk_tree_view_convert_bin_window_to_widget_coords treeView' bx by wx wy
    wx' <- peek wx
    wy' <- peek wy
    touchManagedPtr treeView
    freeMem wx
    freeMem wy
    return (wx', wy')

data TreeViewConvertBinWindowToWidgetCoordsMethodInfo
instance (signature ~ (Int32 -> Int32 -> m (Int32,Int32)), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewConvertBinWindowToWidgetCoordsMethodInfo a signature where
    overloadedMethod _ = treeViewConvertBinWindowToWidgetCoords

-- method TreeView::convert_tree_to_bin_window_coords
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTreeView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tx", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "tree X coordinate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "ty", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "tree Y coordinate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "bx", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for X coordinate relative to bin_window", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "by", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for Y coordinate relative to bin_window", 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_convert_tree_to_bin_window_coords" gtk_tree_view_convert_tree_to_bin_window_coords :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    Int32 ->                                -- tx : TBasicType TInt
    Int32 ->                                -- ty : TBasicType TInt
    Ptr Int32 ->                            -- bx : TBasicType TInt
    Ptr Int32 ->                            -- by : TBasicType TInt
    IO ()

{- |
Converts tree coordinates (coordinates in full scrollable area of the tree)
to bin_window coordinates.

@since 2.12
-}
treeViewConvertTreeToBinWindowCoords ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: a 'GI.Gtk.Objects.TreeView.TreeView' -}
    -> Int32
    {- ^ /@tx@/: tree X coordinate -}
    -> Int32
    {- ^ /@ty@/: tree Y coordinate -}
    -> m (Int32,Int32)
treeViewConvertTreeToBinWindowCoords treeView tx ty = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    bx <- allocMem :: IO (Ptr Int32)
    by <- allocMem :: IO (Ptr Int32)
    gtk_tree_view_convert_tree_to_bin_window_coords treeView' tx ty bx by
    bx' <- peek bx
    by' <- peek by
    touchManagedPtr treeView
    freeMem bx
    freeMem by
    return (bx', by')

data TreeViewConvertTreeToBinWindowCoordsMethodInfo
instance (signature ~ (Int32 -> Int32 -> m (Int32,Int32)), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewConvertTreeToBinWindowCoordsMethodInfo a signature where
    overloadedMethod _ = treeViewConvertTreeToBinWindowCoords

-- method TreeView::convert_tree_to_widget_coords
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTreeView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tx", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "X coordinate relative to the tree", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "ty", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Y coordinate relative to the tree", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "wx", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for widget X coordinate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "wy", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for widget Y coordinate", 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_convert_tree_to_widget_coords" gtk_tree_view_convert_tree_to_widget_coords :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    Int32 ->                                -- tx : TBasicType TInt
    Int32 ->                                -- ty : TBasicType TInt
    Ptr Int32 ->                            -- wx : TBasicType TInt
    Ptr Int32 ->                            -- wy : TBasicType TInt
    IO ()

{- |
Converts tree coordinates (coordinates in full scrollable area of the tree)
to widget coordinates.

@since 2.12
-}
treeViewConvertTreeToWidgetCoords ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: a 'GI.Gtk.Objects.TreeView.TreeView' -}
    -> Int32
    {- ^ /@tx@/: X coordinate relative to the tree -}
    -> Int32
    {- ^ /@ty@/: Y coordinate relative to the tree -}
    -> m (Int32,Int32)
treeViewConvertTreeToWidgetCoords treeView tx ty = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    wx <- allocMem :: IO (Ptr Int32)
    wy <- allocMem :: IO (Ptr Int32)
    gtk_tree_view_convert_tree_to_widget_coords treeView' tx ty wx wy
    wx' <- peek wx
    wy' <- peek wy
    touchManagedPtr treeView
    freeMem wx
    freeMem wy
    return (wx', wy')

data TreeViewConvertTreeToWidgetCoordsMethodInfo
instance (signature ~ (Int32 -> Int32 -> m (Int32,Int32)), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewConvertTreeToWidgetCoordsMethodInfo a signature where
    overloadedMethod _ = treeViewConvertTreeToWidgetCoords

-- method TreeView::convert_widget_to_bin_window_coords
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTreeView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "wx", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "X coordinate relative to the widget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "wy", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Y coordinate relative to the widget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "bx", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for bin_window X coordinate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "by", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for bin_window Y coordinate", 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_convert_widget_to_bin_window_coords" gtk_tree_view_convert_widget_to_bin_window_coords :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    Int32 ->                                -- wx : TBasicType TInt
    Int32 ->                                -- wy : TBasicType TInt
    Ptr Int32 ->                            -- bx : TBasicType TInt
    Ptr Int32 ->                            -- by : TBasicType TInt
    IO ()

{- |
Converts widget coordinates to coordinates for the bin_window
(see 'GI.Gtk.Objects.TreeView.treeViewGetBinWindow').

@since 2.12
-}
treeViewConvertWidgetToBinWindowCoords ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: a 'GI.Gtk.Objects.TreeView.TreeView' -}
    -> Int32
    {- ^ /@wx@/: X coordinate relative to the widget -}
    -> Int32
    {- ^ /@wy@/: Y coordinate relative to the widget -}
    -> m (Int32,Int32)
treeViewConvertWidgetToBinWindowCoords treeView wx wy = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    bx <- allocMem :: IO (Ptr Int32)
    by <- allocMem :: IO (Ptr Int32)
    gtk_tree_view_convert_widget_to_bin_window_coords treeView' wx wy bx by
    bx' <- peek bx
    by' <- peek by
    touchManagedPtr treeView
    freeMem bx
    freeMem by
    return (bx', by')

data TreeViewConvertWidgetToBinWindowCoordsMethodInfo
instance (signature ~ (Int32 -> Int32 -> m (Int32,Int32)), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewConvertWidgetToBinWindowCoordsMethodInfo a signature where
    overloadedMethod _ = treeViewConvertWidgetToBinWindowCoords

-- method TreeView::convert_widget_to_tree_coords
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTreeView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "wx", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "X coordinate relative to the widget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "wy", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Y coordinate relative to the widget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tx", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for tree X coordinate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "ty", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for tree Y coordinate", 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_convert_widget_to_tree_coords" gtk_tree_view_convert_widget_to_tree_coords :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    Int32 ->                                -- wx : TBasicType TInt
    Int32 ->                                -- wy : TBasicType TInt
    Ptr Int32 ->                            -- tx : TBasicType TInt
    Ptr Int32 ->                            -- ty : TBasicType TInt
    IO ()

{- |
Converts widget coordinates to coordinates for the
tree (the full scrollable area of the tree).

@since 2.12
-}
treeViewConvertWidgetToTreeCoords ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: a 'GI.Gtk.Objects.TreeView.TreeView' -}
    -> Int32
    {- ^ /@wx@/: X coordinate relative to the widget -}
    -> Int32
    {- ^ /@wy@/: Y coordinate relative to the widget -}
    -> m (Int32,Int32)
treeViewConvertWidgetToTreeCoords treeView wx wy = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    tx <- allocMem :: IO (Ptr Int32)
    ty <- allocMem :: IO (Ptr Int32)
    gtk_tree_view_convert_widget_to_tree_coords treeView' wx wy tx ty
    tx' <- peek tx
    ty' <- peek ty
    touchManagedPtr treeView
    freeMem tx
    freeMem ty
    return (tx', ty')

data TreeViewConvertWidgetToTreeCoordsMethodInfo
instance (signature ~ (Int32 -> Int32 -> m (Int32,Int32)), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewConvertWidgetToTreeCoordsMethodInfo a signature where
    overloadedMethod _ = treeViewConvertWidgetToTreeCoords

-- method TreeView::create_row_drag_icon
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTreeView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TInterface (Name {namespace = "Gtk", name = "TreePath"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTreePath in @tree_view", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "cairo", name = "Surface"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_tree_view_create_row_drag_icon" gtk_tree_view_create_row_drag_icon :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    Ptr Gtk.TreePath.TreePath ->            -- path : TInterface (Name {namespace = "Gtk", name = "TreePath"})
    IO (Ptr Cairo.Surface.Surface)

{- |
Creates a 'GI.Cairo.Structs.Surface.Surface' representation of the row at /@path@/.
This image is used for a drag icon.
-}
treeViewCreateRowDragIcon ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: a 'GI.Gtk.Objects.TreeView.TreeView' -}
    -> Gtk.TreePath.TreePath
    {- ^ /@path@/: a 'GI.Gtk.Structs.TreePath.TreePath' in /@treeView@/ -}
    -> m Cairo.Surface.Surface
    {- ^ __Returns:__ a newly-allocated surface of the drag icon. -}
treeViewCreateRowDragIcon treeView path = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    path' <- unsafeManagedPtrGetPtr path
    result <- gtk_tree_view_create_row_drag_icon treeView' path'
    checkUnexpectedReturnNULL "treeViewCreateRowDragIcon" result
    result' <- (wrapBoxed Cairo.Surface.Surface) result
    touchManagedPtr treeView
    touchManagedPtr path
    return result'

data TreeViewCreateRowDragIconMethodInfo
instance (signature ~ (Gtk.TreePath.TreePath -> m Cairo.Surface.Surface), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewCreateRowDragIconMethodInfo a signature where
    overloadedMethod _ = treeViewCreateRowDragIcon

-- method TreeView::enable_model_drag_dest
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTreeView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "targets", argType = TCArray False (-1) 2 (TInterface (Name {namespace = "Gtk", name = "TargetEntry"})), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the table of targets that\n          the drag will support", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_targets", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of items in @targets", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "actions", argType = TInterface (Name {namespace = "Gdk", name = "DragAction"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the bitmask of possible actions for a drag from this\n   widget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : [Arg {argCName = "n_targets", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of items in @targets", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_tree_view_enable_model_drag_dest" gtk_tree_view_enable_model_drag_dest :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    Ptr Gtk.TargetEntry.TargetEntry ->      -- targets : TCArray False (-1) 2 (TInterface (Name {namespace = "Gtk", name = "TargetEntry"}))
    Int32 ->                                -- n_targets : TBasicType TInt
    CUInt ->                                -- actions : TInterface (Name {namespace = "Gdk", name = "DragAction"})
    IO ()

{- |
Turns /@treeView@/ into a drop destination for automatic DND. Calling
this method sets 'GI.Gtk.Objects.TreeView.TreeView':@/reorderable/@ to 'False'.
-}
treeViewEnableModelDragDest ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: a 'GI.Gtk.Objects.TreeView.TreeView' -}
    -> [Gtk.TargetEntry.TargetEntry]
    {- ^ /@targets@/: the table of targets that
          the drag will support -}
    -> [Gdk.Flags.DragAction]
    {- ^ /@actions@/: the bitmask of possible actions for a drag from this
   widget -}
    -> m ()
treeViewEnableModelDragDest treeView targets actions = liftIO $ do
    let nTargets = fromIntegral $ length targets
    treeView' <- unsafeManagedPtrCastPtr treeView
    targets' <- mapM unsafeManagedPtrGetPtr targets
    targets'' <- packBlockArray 16 targets'
    let actions' = gflagsToWord actions
    gtk_tree_view_enable_model_drag_dest treeView' targets'' nTargets actions'
    touchManagedPtr treeView
    mapM_ touchManagedPtr targets
    freeMem targets''
    return ()

data TreeViewEnableModelDragDestMethodInfo
instance (signature ~ ([Gtk.TargetEntry.TargetEntry] -> [Gdk.Flags.DragAction] -> m ()), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewEnableModelDragDestMethodInfo a signature where
    overloadedMethod _ = treeViewEnableModelDragDest

-- method TreeView::enable_model_drag_source
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTreeView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start_button_mask", argType = TInterface (Name {namespace = "Gdk", name = "ModifierType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Mask of allowed buttons to start drag", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "targets", argType = TCArray False (-1) 3 (TInterface (Name {namespace = "Gtk", name = "TargetEntry"})), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the table of targets that the drag will support", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_targets", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of items in @targets", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "actions", argType = TInterface (Name {namespace = "Gdk", name = "DragAction"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the bitmask of possible actions for a drag from this\n   widget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : [Arg {argCName = "n_targets", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of items in @targets", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_tree_view_enable_model_drag_source" gtk_tree_view_enable_model_drag_source :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    CUInt ->                                -- start_button_mask : TInterface (Name {namespace = "Gdk", name = "ModifierType"})
    Ptr Gtk.TargetEntry.TargetEntry ->      -- targets : TCArray False (-1) 3 (TInterface (Name {namespace = "Gtk", name = "TargetEntry"}))
    Int32 ->                                -- n_targets : TBasicType TInt
    CUInt ->                                -- actions : TInterface (Name {namespace = "Gdk", name = "DragAction"})
    IO ()

{- |
Turns /@treeView@/ into a drag source for automatic DND. Calling this
method sets 'GI.Gtk.Objects.TreeView.TreeView':@/reorderable/@ to 'False'.
-}
treeViewEnableModelDragSource ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: a 'GI.Gtk.Objects.TreeView.TreeView' -}
    -> [Gdk.Flags.ModifierType]
    {- ^ /@startButtonMask@/: Mask of allowed buttons to start drag -}
    -> [Gtk.TargetEntry.TargetEntry]
    {- ^ /@targets@/: the table of targets that the drag will support -}
    -> [Gdk.Flags.DragAction]
    {- ^ /@actions@/: the bitmask of possible actions for a drag from this
   widget -}
    -> m ()
treeViewEnableModelDragSource treeView startButtonMask targets actions = liftIO $ do
    let nTargets = fromIntegral $ length targets
    treeView' <- unsafeManagedPtrCastPtr treeView
    let startButtonMask' = gflagsToWord startButtonMask
    targets' <- mapM unsafeManagedPtrGetPtr targets
    targets'' <- packBlockArray 16 targets'
    let actions' = gflagsToWord actions
    gtk_tree_view_enable_model_drag_source treeView' startButtonMask' targets'' nTargets actions'
    touchManagedPtr treeView
    mapM_ touchManagedPtr targets
    freeMem targets''
    return ()

data TreeViewEnableModelDragSourceMethodInfo
instance (signature ~ ([Gdk.Flags.ModifierType] -> [Gtk.TargetEntry.TargetEntry] -> [Gdk.Flags.DragAction] -> m ()), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewEnableModelDragSourceMethodInfo a signature where
    overloadedMethod _ = treeViewEnableModelDragSource

-- method TreeView::expand_all
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeView.", 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_expand_all" gtk_tree_view_expand_all :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    IO ()

{- |
Recursively expands all nodes in the /@treeView@/.
-}
treeViewExpandAll ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: A 'GI.Gtk.Objects.TreeView.TreeView'. -}
    -> m ()
treeViewExpandAll treeView = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    gtk_tree_view_expand_all treeView'
    touchManagedPtr treeView
    return ()

data TreeViewExpandAllMethodInfo
instance (signature ~ (m ()), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewExpandAllMethodInfo a signature where
    overloadedMethod _ = treeViewExpandAll

-- method TreeView::expand_row
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTreeView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TInterface (Name {namespace = "Gtk", name = "TreePath"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "path to a row", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "open_all", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether to recursively expand, or just expand immediate children", 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_expand_row" gtk_tree_view_expand_row :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    Ptr Gtk.TreePath.TreePath ->            -- path : TInterface (Name {namespace = "Gtk", name = "TreePath"})
    CInt ->                                 -- open_all : TBasicType TBoolean
    IO CInt

{- |
Opens the row so its children are visible.
-}
treeViewExpandRow ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: a 'GI.Gtk.Objects.TreeView.TreeView' -}
    -> Gtk.TreePath.TreePath
    {- ^ /@path@/: path to a row -}
    -> Bool
    {- ^ /@openAll@/: whether to recursively expand, or just expand immediate children -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the row existed and had children -}
treeViewExpandRow treeView path openAll = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    path' <- unsafeManagedPtrGetPtr path
    let openAll' = (fromIntegral . fromEnum) openAll
    result <- gtk_tree_view_expand_row treeView' path' openAll'
    let result' = (/= 0) result
    touchManagedPtr treeView
    touchManagedPtr path
    return result'

data TreeViewExpandRowMethodInfo
instance (signature ~ (Gtk.TreePath.TreePath -> Bool -> m Bool), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewExpandRowMethodInfo a signature where
    overloadedMethod _ = treeViewExpandRow

-- method TreeView::expand_to_path
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeView.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TInterface (Name {namespace = "Gtk", name = "TreePath"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "path to a row.", 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_expand_to_path" gtk_tree_view_expand_to_path :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    Ptr Gtk.TreePath.TreePath ->            -- path : TInterface (Name {namespace = "Gtk", name = "TreePath"})
    IO ()

{- |
Expands the row at /@path@/. This will also expand all parent rows of
/@path@/ as necessary.

@since 2.2
-}
treeViewExpandToPath ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: A 'GI.Gtk.Objects.TreeView.TreeView'. -}
    -> Gtk.TreePath.TreePath
    {- ^ /@path@/: path to a row. -}
    -> m ()
treeViewExpandToPath treeView path = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    path' <- unsafeManagedPtrGetPtr path
    gtk_tree_view_expand_to_path treeView' path'
    touchManagedPtr treeView
    touchManagedPtr path
    return ()

data TreeViewExpandToPathMethodInfo
instance (signature ~ (Gtk.TreePath.TreePath -> m ()), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewExpandToPathMethodInfo a signature where
    overloadedMethod _ = treeViewExpandToPath

-- method TreeView::get_activate_on_single_click
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTreeView", 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_get_activate_on_single_click" gtk_tree_view_get_activate_on_single_click :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    IO CInt

{- |
Gets the setting set by 'GI.Gtk.Objects.TreeView.treeViewSetActivateOnSingleClick'.

@since 3.8
-}
treeViewGetActivateOnSingleClick ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: a 'GI.Gtk.Objects.TreeView.TreeView' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if row-activated will be emitted on a single click -}
treeViewGetActivateOnSingleClick treeView = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    result <- gtk_tree_view_get_activate_on_single_click treeView'
    let result' = (/= 0) result
    touchManagedPtr treeView
    return result'

data TreeViewGetActivateOnSingleClickMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewGetActivateOnSingleClickMethodInfo a signature where
    overloadedMethod _ = treeViewGetActivateOnSingleClick

-- method TreeView::get_background_area
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTreeView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TInterface (Name {namespace = "Gtk", name = "TreePath"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GtkTreePath for the row, or %NULL to get only horizontal coordinates", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "column", argType = TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GtkTreeViewColumn for the column, or %NULL to get only vertical coordiantes", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "rect", argType = TInterface (Name {namespace = "Gdk", name = "Rectangle"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "rectangle to fill with cell background rect", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_tree_view_get_background_area" gtk_tree_view_get_background_area :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    Ptr Gtk.TreePath.TreePath ->            -- path : TInterface (Name {namespace = "Gtk", name = "TreePath"})
    Ptr Gtk.TreeViewColumn.TreeViewColumn -> -- column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
    Ptr Gdk.Rectangle.Rectangle ->          -- rect : TInterface (Name {namespace = "Gdk", name = "Rectangle"})
    IO ()

{- |
Fills the bounding rectangle in bin_window coordinates for the cell at the
row specified by /@path@/ and the column specified by /@column@/.  If /@path@/ is
'Nothing', or points to a node not found in the tree, the /@y@/ and /@height@/ fields of
the rectangle will be filled with 0. If /@column@/ is 'Nothing', the /@x@/ and /@width@/
fields will be filled with 0.  The returned rectangle is equivalent to the
/@backgroundArea@/ passed to 'GI.Gtk.Objects.CellRenderer.cellRendererRender'.  These background
areas tile to cover the entire bin window.  Contrast with the /@cellArea@/,
returned by 'GI.Gtk.Objects.TreeView.treeViewGetCellArea', which returns only the cell
itself, excluding surrounding borders and the tree expander area.
-}
treeViewGetBackgroundArea ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a, Gtk.TreeViewColumn.IsTreeViewColumn b) =>
    a
    {- ^ /@treeView@/: a 'GI.Gtk.Objects.TreeView.TreeView' -}
    -> Maybe (Gtk.TreePath.TreePath)
    {- ^ /@path@/: a 'GI.Gtk.Structs.TreePath.TreePath' for the row, or 'Nothing' to get only horizontal coordinates -}
    -> Maybe (b)
    {- ^ /@column@/: a 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn' for the column, or 'Nothing' to get only vertical coordiantes -}
    -> m (Gdk.Rectangle.Rectangle)
treeViewGetBackgroundArea treeView path column = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    maybePath <- case path of
        Nothing -> return nullPtr
        Just jPath -> do
            jPath' <- unsafeManagedPtrGetPtr jPath
            return jPath'
    maybeColumn <- case column of
        Nothing -> return nullPtr
        Just jColumn -> do
            jColumn' <- unsafeManagedPtrCastPtr jColumn
            return jColumn'
    rect <- callocBoxedBytes 16 :: IO (Ptr Gdk.Rectangle.Rectangle)
    gtk_tree_view_get_background_area treeView' maybePath maybeColumn rect
    rect' <- (wrapBoxed Gdk.Rectangle.Rectangle) rect
    touchManagedPtr treeView
    whenJust path touchManagedPtr
    whenJust column touchManagedPtr
    return rect'

data TreeViewGetBackgroundAreaMethodInfo
instance (signature ~ (Maybe (Gtk.TreePath.TreePath) -> Maybe (b) -> m (Gdk.Rectangle.Rectangle)), MonadIO m, IsTreeView a, Gtk.TreeViewColumn.IsTreeViewColumn b) => O.MethodInfo TreeViewGetBackgroundAreaMethodInfo a signature where
    overloadedMethod _ = treeViewGetBackgroundArea

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

foreign import ccall "gtk_tree_view_get_bin_window" gtk_tree_view_get_bin_window :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    IO (Ptr Gdk.Window.Window)

{- |
Returns the window that /@treeView@/ renders to.
This is used primarily to compare to @event->window@
to confirm that the event on /@treeView@/ is on the right window.
-}
treeViewGetBinWindow ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: A 'GI.Gtk.Objects.TreeView.TreeView' -}
    -> m (Maybe Gdk.Window.Window)
    {- ^ __Returns:__ A 'GI.Gdk.Objects.Window.Window', or 'Nothing' when /@treeView@/
hasn’t been realized yet. -}
treeViewGetBinWindow treeView = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    result <- gtk_tree_view_get_bin_window treeView'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (newObject Gdk.Window.Window) result'
        return result''
    touchManagedPtr treeView
    return maybeResult

data TreeViewGetBinWindowMethodInfo
instance (signature ~ (m (Maybe Gdk.Window.Window)), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewGetBinWindowMethodInfo a signature where
    overloadedMethod _ = treeViewGetBinWindow

-- method TreeView::get_cell_area
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTreeView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TInterface (Name {namespace = "Gtk", name = "TreePath"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GtkTreePath for the row, or %NULL to get only horizontal coordinates", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "column", argType = TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GtkTreeViewColumn for the column, or %NULL to get only vertical coordinates", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "rect", argType = TInterface (Name {namespace = "Gdk", name = "Rectangle"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "rectangle to fill with cell rect", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_tree_view_get_cell_area" gtk_tree_view_get_cell_area :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    Ptr Gtk.TreePath.TreePath ->            -- path : TInterface (Name {namespace = "Gtk", name = "TreePath"})
    Ptr Gtk.TreeViewColumn.TreeViewColumn -> -- column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
    Ptr Gdk.Rectangle.Rectangle ->          -- rect : TInterface (Name {namespace = "Gdk", name = "Rectangle"})
    IO ()

{- |
Fills the bounding rectangle in bin_window coordinates for the cell at the
row specified by /@path@/ and the column specified by /@column@/.  If /@path@/ is
'Nothing', or points to a path not currently displayed, the /@y@/ and /@height@/ fields
of the rectangle will be filled with 0. If /@column@/ is 'Nothing', the /@x@/ and /@width@/
fields will be filled with 0.  The sum of all cell rects does not cover the
entire tree; there are extra pixels in between rows, for example. The
returned rectangle is equivalent to the /@cellArea@/ passed to
'GI.Gtk.Objects.CellRenderer.cellRendererRender'.  This function is only valid if /@treeView@/ is
realized.
-}
treeViewGetCellArea ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a, Gtk.TreeViewColumn.IsTreeViewColumn b) =>
    a
    {- ^ /@treeView@/: a 'GI.Gtk.Objects.TreeView.TreeView' -}
    -> Maybe (Gtk.TreePath.TreePath)
    {- ^ /@path@/: a 'GI.Gtk.Structs.TreePath.TreePath' for the row, or 'Nothing' to get only horizontal coordinates -}
    -> Maybe (b)
    {- ^ /@column@/: a 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn' for the column, or 'Nothing' to get only vertical coordinates -}
    -> m (Gdk.Rectangle.Rectangle)
treeViewGetCellArea treeView path column = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    maybePath <- case path of
        Nothing -> return nullPtr
        Just jPath -> do
            jPath' <- unsafeManagedPtrGetPtr jPath
            return jPath'
    maybeColumn <- case column of
        Nothing -> return nullPtr
        Just jColumn -> do
            jColumn' <- unsafeManagedPtrCastPtr jColumn
            return jColumn'
    rect <- callocBoxedBytes 16 :: IO (Ptr Gdk.Rectangle.Rectangle)
    gtk_tree_view_get_cell_area treeView' maybePath maybeColumn rect
    rect' <- (wrapBoxed Gdk.Rectangle.Rectangle) rect
    touchManagedPtr treeView
    whenJust path touchManagedPtr
    whenJust column touchManagedPtr
    return rect'

data TreeViewGetCellAreaMethodInfo
instance (signature ~ (Maybe (Gtk.TreePath.TreePath) -> Maybe (b) -> m (Gdk.Rectangle.Rectangle)), MonadIO m, IsTreeView a, Gtk.TreeViewColumn.IsTreeViewColumn b) => O.MethodInfo TreeViewGetCellAreaMethodInfo a signature where
    overloadedMethod _ = treeViewGetCellArea

-- method TreeView::get_column
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeView.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The position of the column, counting from 0.", 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_get_column" gtk_tree_view_get_column :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    Int32 ->                                -- n : TBasicType TInt
    IO (Ptr Gtk.TreeViewColumn.TreeViewColumn)

{- |
Gets the 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn' at the given position in the @/tree_view/@.
-}
treeViewGetColumn ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: A 'GI.Gtk.Objects.TreeView.TreeView'. -}
    -> Int32
    {- ^ /@n@/: The position of the column, counting from 0. -}
    -> m (Maybe Gtk.TreeViewColumn.TreeViewColumn)
    {- ^ __Returns:__ The 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn', or 'Nothing' if the
position is outside the range of columns. -}
treeViewGetColumn treeView n = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    result <- gtk_tree_view_get_column treeView' n
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (newObject Gtk.TreeViewColumn.TreeViewColumn) result'
        return result''
    touchManagedPtr treeView
    return maybeResult

data TreeViewGetColumnMethodInfo
instance (signature ~ (Int32 -> m (Maybe Gtk.TreeViewColumn.TreeViewColumn)), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewGetColumnMethodInfo a signature where
    overloadedMethod _ = treeViewGetColumn

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

foreign import ccall "gtk_tree_view_get_columns" gtk_tree_view_get_columns :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    IO (Ptr (GList (Ptr Gtk.TreeViewColumn.TreeViewColumn)))

{- |
Returns a 'GI.GLib.Structs.List.List' of all the 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn' s currently in /@treeView@/.
The returned list must be freed with g_list_free ().
-}
treeViewGetColumns ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: A 'GI.Gtk.Objects.TreeView.TreeView' -}
    -> m [Gtk.TreeViewColumn.TreeViewColumn]
    {- ^ __Returns:__ A list of 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn' s -}
treeViewGetColumns treeView = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    result <- gtk_tree_view_get_columns treeView'
    result' <- unpackGList result
    result'' <- mapM (newObject Gtk.TreeViewColumn.TreeViewColumn) result'
    g_list_free result
    touchManagedPtr treeView
    return result''

data TreeViewGetColumnsMethodInfo
instance (signature ~ (m [Gtk.TreeViewColumn.TreeViewColumn]), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewGetColumnsMethodInfo a signature where
    overloadedMethod _ = treeViewGetColumns

-- method TreeView::get_cursor
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TInterface (Name {namespace = "Gtk", name = "TreePath"}), direction = DirectionOut, mayBeNull = True, argDoc = Documentation {rawDocText = Just "A pointer to be\n  filled with the current cursor path, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "focus_column", argType = TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"}), direction = DirectionOut, mayBeNull = True, argDoc = Documentation {rawDocText = Just "A\n  pointer to be filled with the current focus column, 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_get_cursor" gtk_tree_view_get_cursor :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    Ptr (Ptr Gtk.TreePath.TreePath) ->      -- path : TInterface (Name {namespace = "Gtk", name = "TreePath"})
    Ptr (Ptr Gtk.TreeViewColumn.TreeViewColumn) -> -- focus_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
    IO ()

{- |
Fills in /@path@/ and /@focusColumn@/ with the current path and focus column.  If
the cursor isn’t currently set, then */@path@/ will be 'Nothing'.  If no column
currently has focus, then */@focusColumn@/ will be 'Nothing'.

The returned 'GI.Gtk.Structs.TreePath.TreePath' must be freed with 'GI.Gtk.Structs.TreePath.treePathFree' when
you are done with it.
-}
treeViewGetCursor ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: A 'GI.Gtk.Objects.TreeView.TreeView' -}
    -> m ((Maybe Gtk.TreePath.TreePath),(Maybe Gtk.TreeViewColumn.TreeViewColumn))
treeViewGetCursor treeView = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    path <- allocMem :: IO (Ptr (Ptr Gtk.TreePath.TreePath))
    focusColumn <- allocMem :: IO (Ptr (Ptr Gtk.TreeViewColumn.TreeViewColumn))
    gtk_tree_view_get_cursor treeView' path focusColumn
    path' <- peek path
    maybePath' <- convertIfNonNull path' $ \path'' -> do
        path''' <- (wrapBoxed Gtk.TreePath.TreePath) path''
        return path'''
    focusColumn' <- peek focusColumn
    maybeFocusColumn' <- convertIfNonNull focusColumn' $ \focusColumn'' -> do
        focusColumn''' <- (newObject Gtk.TreeViewColumn.TreeViewColumn) focusColumn''
        return focusColumn'''
    touchManagedPtr treeView
    freeMem path
    freeMem focusColumn
    return (maybePath', maybeFocusColumn')

data TreeViewGetCursorMethodInfo
instance (signature ~ (m ((Maybe Gtk.TreePath.TreePath),(Maybe Gtk.TreeViewColumn.TreeViewColumn))), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewGetCursorMethodInfo a signature where
    overloadedMethod _ = treeViewGetCursor

-- method TreeView::get_dest_row_at_pos
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTreeView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "drag_x", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the position to determine the destination row for", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "drag_y", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the position to determine the destination row for", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TInterface (Name {namespace = "Gtk", name = "TreePath"}), direction = DirectionOut, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Return location for the path of\n  the highlighted row, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "pos", argType = TInterface (Name {namespace = "Gtk", name = "TreeViewDropPosition"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Return location for the drop position, or\n  %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_get_dest_row_at_pos" gtk_tree_view_get_dest_row_at_pos :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    Int32 ->                                -- drag_x : TBasicType TInt
    Int32 ->                                -- drag_y : TBasicType TInt
    Ptr (Ptr Gtk.TreePath.TreePath) ->      -- path : TInterface (Name {namespace = "Gtk", name = "TreePath"})
    Ptr CUInt ->                            -- pos : TInterface (Name {namespace = "Gtk", name = "TreeViewDropPosition"})
    IO CInt

{- |
Determines the destination row for a given position.  /@dragX@/ and
/@dragY@/ are expected to be in widget coordinates.  This function is only
meaningful if /@treeView@/ is realized.  Therefore this function will always
return 'False' if /@treeView@/ is not realized or does not have a model.
-}
treeViewGetDestRowAtPos ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: a 'GI.Gtk.Objects.TreeView.TreeView' -}
    -> Int32
    {- ^ /@dragX@/: the position to determine the destination row for -}
    -> Int32
    {- ^ /@dragY@/: the position to determine the destination row for -}
    -> m (Bool,(Maybe Gtk.TreePath.TreePath),Gtk.Enums.TreeViewDropPosition)
    {- ^ __Returns:__ whether there is a row at the given position, 'True' if this
is indeed the case. -}
treeViewGetDestRowAtPos treeView dragX dragY = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    path <- allocMem :: IO (Ptr (Ptr Gtk.TreePath.TreePath))
    pos <- allocMem :: IO (Ptr CUInt)
    result <- gtk_tree_view_get_dest_row_at_pos treeView' dragX dragY path pos
    let result' = (/= 0) result
    path' <- peek path
    maybePath' <- convertIfNonNull path' $ \path'' -> do
        path''' <- (wrapBoxed Gtk.TreePath.TreePath) path''
        return path'''
    pos' <- peek pos
    let pos'' = (toEnum . fromIntegral) pos'
    touchManagedPtr treeView
    freeMem path
    freeMem pos
    return (result', maybePath', pos'')

data TreeViewGetDestRowAtPosMethodInfo
instance (signature ~ (Int32 -> Int32 -> m (Bool,(Maybe Gtk.TreePath.TreePath),Gtk.Enums.TreeViewDropPosition)), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewGetDestRowAtPosMethodInfo a signature where
    overloadedMethod _ = treeViewGetDestRowAtPos

-- method TreeView::get_drag_dest_row
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTreeView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TInterface (Name {namespace = "Gtk", name = "TreePath"}), direction = DirectionOut, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Return location for the path of the highlighted row, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "pos", argType = TInterface (Name {namespace = "Gtk", name = "TreeViewDropPosition"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Return location for the drop position, 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_get_drag_dest_row" gtk_tree_view_get_drag_dest_row :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    Ptr (Ptr Gtk.TreePath.TreePath) ->      -- path : TInterface (Name {namespace = "Gtk", name = "TreePath"})
    Ptr CUInt ->                            -- pos : TInterface (Name {namespace = "Gtk", name = "TreeViewDropPosition"})
    IO ()

{- |
Gets information about the row that is highlighted for feedback.
-}
treeViewGetDragDestRow ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: a 'GI.Gtk.Objects.TreeView.TreeView' -}
    -> m ((Maybe Gtk.TreePath.TreePath),Gtk.Enums.TreeViewDropPosition)
treeViewGetDragDestRow treeView = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    path <- allocMem :: IO (Ptr (Ptr Gtk.TreePath.TreePath))
    pos <- allocMem :: IO (Ptr CUInt)
    gtk_tree_view_get_drag_dest_row treeView' path pos
    path' <- peek path
    maybePath' <- convertIfNonNull path' $ \path'' -> do
        path''' <- (wrapBoxed Gtk.TreePath.TreePath) path''
        return path'''
    pos' <- peek pos
    let pos'' = (toEnum . fromIntegral) pos'
    touchManagedPtr treeView
    freeMem path
    freeMem pos
    return (maybePath', pos'')

data TreeViewGetDragDestRowMethodInfo
instance (signature ~ (m ((Maybe Gtk.TreePath.TreePath),Gtk.Enums.TreeViewDropPosition)), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewGetDragDestRowMethodInfo a signature where
    overloadedMethod _ = treeViewGetDragDestRow

-- method TreeView::get_enable_search
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeView", 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_get_enable_search" gtk_tree_view_get_enable_search :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    IO CInt

{- |
Returns whether or not the tree allows to start interactive searching
by typing in text.
-}
treeViewGetEnableSearch ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: A 'GI.Gtk.Objects.TreeView.TreeView' -}
    -> m Bool
    {- ^ __Returns:__ whether or not to let the user search interactively -}
treeViewGetEnableSearch treeView = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    result <- gtk_tree_view_get_enable_search treeView'
    let result' = (/= 0) result
    touchManagedPtr treeView
    return result'

data TreeViewGetEnableSearchMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewGetEnableSearchMethodInfo a signature where
    overloadedMethod _ = treeViewGetEnableSearch

-- method TreeView::get_enable_tree_lines
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTreeView.", 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_get_enable_tree_lines" gtk_tree_view_get_enable_tree_lines :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    IO CInt

{- |
Returns whether or not tree lines are drawn in /@treeView@/.

@since 2.10
-}
treeViewGetEnableTreeLines ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: a 'GI.Gtk.Objects.TreeView.TreeView'. -}
    -> m Bool
    {- ^ __Returns:__ 'True' if tree lines are drawn in /@treeView@/, 'False'
otherwise. -}
treeViewGetEnableTreeLines treeView = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    result <- gtk_tree_view_get_enable_tree_lines treeView'
    let result' = (/= 0) result
    touchManagedPtr treeView
    return result'

data TreeViewGetEnableTreeLinesMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewGetEnableTreeLinesMethodInfo a signature where
    overloadedMethod _ = treeViewGetEnableTreeLines

-- method TreeView::get_expander_column
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeView", 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_get_expander_column" gtk_tree_view_get_expander_column :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    IO (Ptr Gtk.TreeViewColumn.TreeViewColumn)

{- |
Returns the column that is the current expander column.
This column has the expander arrow drawn next to it.
-}
treeViewGetExpanderColumn ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: A 'GI.Gtk.Objects.TreeView.TreeView' -}
    -> m Gtk.TreeViewColumn.TreeViewColumn
    {- ^ __Returns:__ The expander column. -}
treeViewGetExpanderColumn treeView = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    result <- gtk_tree_view_get_expander_column treeView'
    checkUnexpectedReturnNULL "treeViewGetExpanderColumn" result
    result' <- (newObject Gtk.TreeViewColumn.TreeViewColumn) result
    touchManagedPtr treeView
    return result'

data TreeViewGetExpanderColumnMethodInfo
instance (signature ~ (m Gtk.TreeViewColumn.TreeViewColumn), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewGetExpanderColumnMethodInfo a signature where
    overloadedMethod _ = treeViewGetExpanderColumn

-- method TreeView::get_fixed_height_mode
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTreeView", 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_get_fixed_height_mode" gtk_tree_view_get_fixed_height_mode :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    IO CInt

{- |
Returns whether fixed height mode is turned on for /@treeView@/.

@since 2.6
-}
treeViewGetFixedHeightMode ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: a 'GI.Gtk.Objects.TreeView.TreeView' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if /@treeView@/ is in fixed height mode -}
treeViewGetFixedHeightMode treeView = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    result <- gtk_tree_view_get_fixed_height_mode treeView'
    let result' = (/= 0) result
    touchManagedPtr treeView
    return result'

data TreeViewGetFixedHeightModeMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewGetFixedHeightModeMethodInfo a signature where
    overloadedMethod _ = treeViewGetFixedHeightMode

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

foreign import ccall "gtk_tree_view_get_grid_lines" gtk_tree_view_get_grid_lines :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    IO CUInt

{- |
Returns which grid lines are enabled in /@treeView@/.

@since 2.10
-}
treeViewGetGridLines ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: a 'GI.Gtk.Objects.TreeView.TreeView' -}
    -> m Gtk.Enums.TreeViewGridLines
    {- ^ __Returns:__ a 'GI.Gtk.Enums.TreeViewGridLines' value indicating which grid lines
are enabled. -}
treeViewGetGridLines treeView = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    result <- gtk_tree_view_get_grid_lines treeView'
    let result' = (toEnum . fromIntegral) result
    touchManagedPtr treeView
    return result'

data TreeViewGetGridLinesMethodInfo
instance (signature ~ (m Gtk.Enums.TreeViewGridLines), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewGetGridLinesMethodInfo a signature where
    overloadedMethod _ = treeViewGetGridLines

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

foreign import ccall "gtk_tree_view_get_hadjustment" gtk_tree_view_get_hadjustment :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    IO (Ptr Gtk.Adjustment.Adjustment)

{-# DEPRECATED treeViewGetHadjustment ["(Since version 3.0)","Use 'GI.Gtk.Interfaces.Scrollable.scrollableGetHadjustment'"] #-}
{- |
Gets the 'GI.Gtk.Objects.Adjustment.Adjustment' currently being used for the horizontal aspect.
-}
treeViewGetHadjustment ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: A 'GI.Gtk.Objects.TreeView.TreeView' -}
    -> m Gtk.Adjustment.Adjustment
    {- ^ __Returns:__ A 'GI.Gtk.Objects.Adjustment.Adjustment' object, or 'Nothing'
    if none is currently being used. -}
treeViewGetHadjustment treeView = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    result <- gtk_tree_view_get_hadjustment treeView'
    checkUnexpectedReturnNULL "treeViewGetHadjustment" result
    result' <- (newObject Gtk.Adjustment.Adjustment) result
    touchManagedPtr treeView
    return result'

data TreeViewGetHadjustmentMethodInfo
instance (signature ~ (m Gtk.Adjustment.Adjustment), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewGetHadjustmentMethodInfo a signature where
    overloadedMethod _ = treeViewGetHadjustment

-- method TreeView::get_headers_clickable
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeView.", 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_get_headers_clickable" gtk_tree_view_get_headers_clickable :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    IO CInt

{- |
Returns whether all header columns are clickable.

@since 2.10
-}
treeViewGetHeadersClickable ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: A 'GI.Gtk.Objects.TreeView.TreeView'. -}
    -> m Bool
    {- ^ __Returns:__ 'True' if all header columns are clickable, otherwise 'False' -}
treeViewGetHeadersClickable treeView = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    result <- gtk_tree_view_get_headers_clickable treeView'
    let result' = (/= 0) result
    touchManagedPtr treeView
    return result'

data TreeViewGetHeadersClickableMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewGetHeadersClickableMethodInfo a signature where
    overloadedMethod _ = treeViewGetHeadersClickable

-- method TreeView::get_headers_visible
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeView.", 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_get_headers_visible" gtk_tree_view_get_headers_visible :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    IO CInt

{- |
Returns 'True' if the headers on the /@treeView@/ are visible.
-}
treeViewGetHeadersVisible ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: A 'GI.Gtk.Objects.TreeView.TreeView'. -}
    -> m Bool
    {- ^ __Returns:__ Whether the headers are visible or not. -}
treeViewGetHeadersVisible treeView = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    result <- gtk_tree_view_get_headers_visible treeView'
    let result' = (/= 0) result
    touchManagedPtr treeView
    return result'

data TreeViewGetHeadersVisibleMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewGetHeadersVisibleMethodInfo a signature where
    overloadedMethod _ = treeViewGetHeadersVisible

-- method TreeView::get_hover_expand
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTreeView", 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_get_hover_expand" gtk_tree_view_get_hover_expand :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    IO CInt

{- |
Returns whether hover expansion mode is turned on for /@treeView@/.

@since 2.6
-}
treeViewGetHoverExpand ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: a 'GI.Gtk.Objects.TreeView.TreeView' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if /@treeView@/ is in hover expansion mode -}
treeViewGetHoverExpand treeView = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    result <- gtk_tree_view_get_hover_expand treeView'
    let result' = (/= 0) result
    touchManagedPtr treeView
    return result'

data TreeViewGetHoverExpandMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewGetHoverExpandMethodInfo a signature where
    overloadedMethod _ = treeViewGetHoverExpand

-- method TreeView::get_hover_selection
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTreeView", 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_get_hover_selection" gtk_tree_view_get_hover_selection :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    IO CInt

{- |
Returns whether hover selection mode is turned on for /@treeView@/.

@since 2.6
-}
treeViewGetHoverSelection ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: a 'GI.Gtk.Objects.TreeView.TreeView' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if /@treeView@/ is in hover selection mode -}
treeViewGetHoverSelection treeView = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    result <- gtk_tree_view_get_hover_selection treeView'
    let result' = (/= 0) result
    touchManagedPtr treeView
    return result'

data TreeViewGetHoverSelectionMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewGetHoverSelectionMethodInfo a signature where
    overloadedMethod _ = treeViewGetHoverSelection

-- method TreeView::get_level_indentation
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTreeView.", 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_get_level_indentation" gtk_tree_view_get_level_indentation :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    IO Int32

{- |
Returns the amount, in pixels, of extra indentation for child levels
in /@treeView@/.

@since 2.12
-}
treeViewGetLevelIndentation ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: a 'GI.Gtk.Objects.TreeView.TreeView'. -}
    -> m Int32
    {- ^ __Returns:__ the amount of extra indentation for child levels in
/@treeView@/.  A return value of 0 means that this feature is disabled. -}
treeViewGetLevelIndentation treeView = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    result <- gtk_tree_view_get_level_indentation treeView'
    touchManagedPtr treeView
    return result

data TreeViewGetLevelIndentationMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewGetLevelIndentationMethodInfo a signature where
    overloadedMethod _ = treeViewGetLevelIndentation

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

foreign import ccall "gtk_tree_view_get_model" gtk_tree_view_get_model :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    IO (Ptr Gtk.TreeModel.TreeModel)

{- |
Returns the model the 'GI.Gtk.Objects.TreeView.TreeView' is based on.  Returns 'Nothing' if the
model is unset.
-}
treeViewGetModel ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: a 'GI.Gtk.Objects.TreeView.TreeView' -}
    -> m (Maybe Gtk.TreeModel.TreeModel)
    {- ^ __Returns:__ A 'GI.Gtk.Interfaces.TreeModel.TreeModel', or 'Nothing' if
none is currently being used. -}
treeViewGetModel treeView = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    result <- gtk_tree_view_get_model treeView'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (newObject Gtk.TreeModel.TreeModel) result'
        return result''
    touchManagedPtr treeView
    return maybeResult

data TreeViewGetModelMethodInfo
instance (signature ~ (m (Maybe Gtk.TreeModel.TreeModel)), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewGetModelMethodInfo a signature where
    overloadedMethod _ = treeViewGetModel

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

foreign import ccall "gtk_tree_view_get_n_columns" gtk_tree_view_get_n_columns :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    IO Word32

{- |
Queries the number of columns in the given /@treeView@/.

@since 3.4
-}
treeViewGetNColumns ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: a 'GI.Gtk.Objects.TreeView.TreeView' -}
    -> m Word32
    {- ^ __Returns:__ The number of columns in the /@treeView@/ -}
treeViewGetNColumns treeView = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    result <- gtk_tree_view_get_n_columns treeView'
    touchManagedPtr treeView
    return result

data TreeViewGetNColumnsMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewGetNColumnsMethodInfo a signature where
    overloadedMethod _ = treeViewGetNColumns

-- method TreeView::get_path_at_pos
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeView.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The x position to be identified (relative to bin_window).", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "y", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The y position to be identified (relative to bin_window).", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TInterface (Name {namespace = "Gtk", name = "TreePath"}), direction = DirectionOut, mayBeNull = True, argDoc = Documentation {rawDocText = Just "A pointer to a #GtkTreePath\n  pointer to be filled in, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "column", argType = TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"}), direction = DirectionOut, mayBeNull = True, argDoc = Documentation {rawDocText = Just "A pointer to\n  a #GtkTreeViewColumn pointer to be filled in, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cell_x", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A pointer where the X coordinate\n  relative to the cell can be placed, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "cell_y", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A pointer where the Y coordinate\n  relative to the cell can be placed, or %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_get_path_at_pos" gtk_tree_view_get_path_at_pos :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    Int32 ->                                -- x : TBasicType TInt
    Int32 ->                                -- y : TBasicType TInt
    Ptr (Ptr Gtk.TreePath.TreePath) ->      -- path : TInterface (Name {namespace = "Gtk", name = "TreePath"})
    Ptr (Ptr Gtk.TreeViewColumn.TreeViewColumn) -> -- column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
    Ptr Int32 ->                            -- cell_x : TBasicType TInt
    Ptr Int32 ->                            -- cell_y : TBasicType TInt
    IO CInt

{- |
Finds the path at the point (/@x@/, /@y@/), relative to bin_window coordinates
(please see 'GI.Gtk.Objects.TreeView.treeViewGetBinWindow').
That is, /@x@/ and /@y@/ are relative to an events coordinates. /@x@/ and /@y@/ must
come from an event on the /@treeView@/ only where @event->window ==
gtk_tree_view_get_bin_window ()@. It is primarily for
things like popup menus. If /@path@/ is non-'Nothing', then it will be filled
with the 'GI.Gtk.Structs.TreePath.TreePath' at that point.  This path should be freed with
'GI.Gtk.Structs.TreePath.treePathFree'.  If /@column@/ is non-'Nothing', then it will be filled
with the column at that point.  /@cellX@/ and /@cellY@/ return the coordinates
relative to the cell background (i.e. the /@backgroundArea@/ passed to
'GI.Gtk.Objects.CellRenderer.cellRendererRender').  This function is only meaningful if
/@treeView@/ is realized.  Therefore this function will always return 'False'
if /@treeView@/ is not realized or does not have a model.

For converting widget coordinates (eg. the ones you get from
GtkWidget::query-tooltip), please see
'GI.Gtk.Objects.TreeView.treeViewConvertWidgetToBinWindowCoords'.
-}
treeViewGetPathAtPos ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: A 'GI.Gtk.Objects.TreeView.TreeView'. -}
    -> Int32
    {- ^ /@x@/: The x position to be identified (relative to bin_window). -}
    -> Int32
    {- ^ /@y@/: The y position to be identified (relative to bin_window). -}
    -> m (Bool,(Maybe Gtk.TreePath.TreePath),(Maybe Gtk.TreeViewColumn.TreeViewColumn),Int32,Int32)
    {- ^ __Returns:__ 'True' if a row exists at that coordinate. -}
treeViewGetPathAtPos treeView x y = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    path <- allocMem :: IO (Ptr (Ptr Gtk.TreePath.TreePath))
    column <- allocMem :: IO (Ptr (Ptr Gtk.TreeViewColumn.TreeViewColumn))
    cellX <- allocMem :: IO (Ptr Int32)
    cellY <- allocMem :: IO (Ptr Int32)
    result <- gtk_tree_view_get_path_at_pos treeView' x y path column cellX cellY
    let result' = (/= 0) result
    path' <- peek path
    maybePath' <- convertIfNonNull path' $ \path'' -> do
        path''' <- (wrapBoxed Gtk.TreePath.TreePath) path''
        return path'''
    column' <- peek column
    maybeColumn' <- convertIfNonNull column' $ \column'' -> do
        column''' <- (newObject Gtk.TreeViewColumn.TreeViewColumn) column''
        return column'''
    cellX' <- peek cellX
    cellY' <- peek cellY
    touchManagedPtr treeView
    freeMem path
    freeMem column
    freeMem cellX
    freeMem cellY
    return (result', maybePath', maybeColumn', cellX', cellY')

data TreeViewGetPathAtPosMethodInfo
instance (signature ~ (Int32 -> Int32 -> m (Bool,(Maybe Gtk.TreePath.TreePath),(Maybe Gtk.TreeViewColumn.TreeViewColumn),Int32,Int32)), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewGetPathAtPosMethodInfo a signature where
    overloadedMethod _ = treeViewGetPathAtPos

-- method TreeView::get_reorderable
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTreeView", 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_get_reorderable" gtk_tree_view_get_reorderable :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    IO CInt

{- |
Retrieves whether the user can reorder the tree via drag-and-drop. See
'GI.Gtk.Objects.TreeView.treeViewSetReorderable'.
-}
treeViewGetReorderable ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: a 'GI.Gtk.Objects.TreeView.TreeView' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the tree can be reordered. -}
treeViewGetReorderable treeView = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    result <- gtk_tree_view_get_reorderable treeView'
    let result' = (/= 0) result
    touchManagedPtr treeView
    return result'

data TreeViewGetReorderableMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewGetReorderableMethodInfo a signature where
    overloadedMethod _ = treeViewGetReorderable

-- method TreeView::get_rubber_banding
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTreeView", 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_get_rubber_banding" gtk_tree_view_get_rubber_banding :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    IO CInt

{- |
Returns whether rubber banding is turned on for /@treeView@/.  If the
selection mode is @/GTK_SELECTION_MULTIPLE/@, rubber banding will allow the
user to select multiple rows by dragging the mouse.

@since 2.10
-}
treeViewGetRubberBanding ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: a 'GI.Gtk.Objects.TreeView.TreeView' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if rubber banding in /@treeView@/ is enabled. -}
treeViewGetRubberBanding treeView = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    result <- gtk_tree_view_get_rubber_banding treeView'
    let result' = (/= 0) result
    touchManagedPtr treeView
    return result'

data TreeViewGetRubberBandingMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewGetRubberBandingMethodInfo a signature where
    overloadedMethod _ = treeViewGetRubberBanding

-- method TreeView::get_rules_hint
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTreeView", 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_get_rules_hint" gtk_tree_view_get_rules_hint :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    IO CInt

{-# DEPRECATED treeViewGetRulesHint ["(Since version 3.14)"] #-}
{- |
Gets the setting set by 'GI.Gtk.Objects.TreeView.treeViewSetRulesHint'.
-}
treeViewGetRulesHint ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: a 'GI.Gtk.Objects.TreeView.TreeView' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the hint is set -}
treeViewGetRulesHint treeView = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    result <- gtk_tree_view_get_rules_hint treeView'
    let result' = (/= 0) result
    touchManagedPtr treeView
    return result'

data TreeViewGetRulesHintMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewGetRulesHintMethodInfo a signature where
    overloadedMethod _ = treeViewGetRulesHint

-- method TreeView::get_search_column
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeView", 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_get_search_column" gtk_tree_view_get_search_column :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    IO Int32

{- |
Gets the column searched on by the interactive search code.
-}
treeViewGetSearchColumn ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: A 'GI.Gtk.Objects.TreeView.TreeView' -}
    -> m Int32
    {- ^ __Returns:__ the column the interactive search code searches in. -}
treeViewGetSearchColumn treeView = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    result <- gtk_tree_view_get_search_column treeView'
    touchManagedPtr treeView
    return result

data TreeViewGetSearchColumnMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewGetSearchColumnMethodInfo a signature where
    overloadedMethod _ = treeViewGetSearchColumn

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

foreign import ccall "gtk_tree_view_get_search_entry" gtk_tree_view_get_search_entry :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    IO (Ptr Gtk.Entry.Entry)

{- |
Returns the 'GI.Gtk.Objects.Entry.Entry' which is currently in use as interactive search
entry for /@treeView@/.  In case the built-in entry is being used, 'Nothing'
will be returned.

@since 2.10
-}
treeViewGetSearchEntry ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: A 'GI.Gtk.Objects.TreeView.TreeView' -}
    -> m Gtk.Entry.Entry
    {- ^ __Returns:__ the entry currently in use as search entry. -}
treeViewGetSearchEntry treeView = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    result <- gtk_tree_view_get_search_entry treeView'
    checkUnexpectedReturnNULL "treeViewGetSearchEntry" result
    result' <- (newObject Gtk.Entry.Entry) result
    touchManagedPtr treeView
    return result'

data TreeViewGetSearchEntryMethodInfo
instance (signature ~ (m Gtk.Entry.Entry), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewGetSearchEntryMethodInfo a signature where
    overloadedMethod _ = treeViewGetSearchEntry

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

foreign import ccall "gtk_tree_view_get_selection" gtk_tree_view_get_selection :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    IO (Ptr Gtk.TreeSelection.TreeSelection)

{- |
Gets the 'GI.Gtk.Objects.TreeSelection.TreeSelection' associated with /@treeView@/.
-}
treeViewGetSelection ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: A 'GI.Gtk.Objects.TreeView.TreeView'. -}
    -> m Gtk.TreeSelection.TreeSelection
    {- ^ __Returns:__ A 'GI.Gtk.Objects.TreeSelection.TreeSelection' object. -}
treeViewGetSelection treeView = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    result <- gtk_tree_view_get_selection treeView'
    checkUnexpectedReturnNULL "treeViewGetSelection" result
    result' <- (newObject Gtk.TreeSelection.TreeSelection) result
    touchManagedPtr treeView
    return result'

data TreeViewGetSelectionMethodInfo
instance (signature ~ (m Gtk.TreeSelection.TreeSelection), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewGetSelectionMethodInfo a signature where
    overloadedMethod _ = treeViewGetSelection

-- method TreeView::get_show_expanders
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTreeView.", 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_get_show_expanders" gtk_tree_view_get_show_expanders :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    IO CInt

{- |
Returns whether or not expanders are drawn in /@treeView@/.

@since 2.12
-}
treeViewGetShowExpanders ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: a 'GI.Gtk.Objects.TreeView.TreeView'. -}
    -> m Bool
    {- ^ __Returns:__ 'True' if expanders are drawn in /@treeView@/, 'False'
otherwise. -}
treeViewGetShowExpanders treeView = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    result <- gtk_tree_view_get_show_expanders treeView'
    let result' = (/= 0) result
    touchManagedPtr treeView
    return result'

data TreeViewGetShowExpandersMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewGetShowExpandersMethodInfo a signature where
    overloadedMethod _ = treeViewGetShowExpanders

-- method TreeView::get_tooltip_column
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTreeView", 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_get_tooltip_column" gtk_tree_view_get_tooltip_column :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    IO Int32

{- |
Returns the column of /@treeView@/’s model which is being used for
displaying tooltips on /@treeView@/’s rows.

@since 2.12
-}
treeViewGetTooltipColumn ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: a 'GI.Gtk.Objects.TreeView.TreeView' -}
    -> m Int32
    {- ^ __Returns:__ the index of the tooltip column that is currently being
used, or -1 if this is disabled. -}
treeViewGetTooltipColumn treeView = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    result <- gtk_tree_view_get_tooltip_column treeView'
    touchManagedPtr treeView
    return result

data TreeViewGetTooltipColumnMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewGetTooltipColumnMethodInfo a signature where
    overloadedMethod _ = treeViewGetTooltipColumn

-- method TreeView::get_tooltip_context
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTreeView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x", argType = TBasicType TInt, direction = DirectionInout, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the x coordinate (relative to widget coordinates)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "y", argType = TBasicType TInt, direction = DirectionInout, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the y coordinate (relative to widget coordinates)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "keyboard_tip", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether this is a keyboard tooltip or not", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "model", argType = TInterface (Name {namespace = "Gtk", name = "TreeModel"}), direction = DirectionOut, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a pointer to\n        receive a #GtkTreeModel or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TInterface (Name {namespace = "Gtk", name = "TreePath"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a pointer to receive a #GtkTreePath or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "iter", argType = TInterface (Name {namespace = "Gtk", name = "TreeIter"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a pointer to receive a #GtkTreeIter or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_tree_view_get_tooltip_context" gtk_tree_view_get_tooltip_context :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    Ptr Int32 ->                            -- x : TBasicType TInt
    Ptr Int32 ->                            -- y : TBasicType TInt
    CInt ->                                 -- keyboard_tip : TBasicType TBoolean
    Ptr (Ptr Gtk.TreeModel.TreeModel) ->    -- model : TInterface (Name {namespace = "Gtk", name = "TreeModel"})
    Ptr (Ptr Gtk.TreePath.TreePath) ->      -- path : TInterface (Name {namespace = "Gtk", name = "TreePath"})
    Ptr Gtk.TreeIter.TreeIter ->            -- iter : TInterface (Name {namespace = "Gtk", name = "TreeIter"})
    IO CInt

{- |
This function is supposed to be used in a 'GI.Gtk.Objects.Widget.Widget'::@/query-tooltip/@
signal handler for 'GI.Gtk.Objects.TreeView.TreeView'.  The /@x@/, /@y@/ and /@keyboardTip@/ values
which are received in the signal handler, should be passed to this
function without modification.

The return value indicates whether there is a tree view row at the given
coordinates ('True') or not ('False') for mouse tooltips.  For keyboard
tooltips the row returned will be the cursor row.  When 'True', then any of
/@model@/, /@path@/ and /@iter@/ which have been provided will be set to point to
that row and the corresponding model.  /@x@/ and /@y@/ will always be converted
to be relative to /@treeView@/’s bin_window if /@keyboardTooltip@/ is 'False'.

@since 2.12
-}
treeViewGetTooltipContext ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: a 'GI.Gtk.Objects.TreeView.TreeView' -}
    -> Int32
    {- ^ /@x@/: the x coordinate (relative to widget coordinates) -}
    -> Int32
    {- ^ /@y@/: the y coordinate (relative to widget coordinates) -}
    -> Bool
    {- ^ /@keyboardTip@/: whether this is a keyboard tooltip or not -}
    -> m (Bool,Int32,Int32,(Maybe Gtk.TreeModel.TreeModel),Gtk.TreePath.TreePath,Gtk.TreeIter.TreeIter)
    {- ^ __Returns:__ whether or not the given tooltip context points to a row. -}
treeViewGetTooltipContext treeView x y keyboardTip = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    x' <- allocMem :: IO (Ptr Int32)
    poke x' x
    y' <- allocMem :: IO (Ptr Int32)
    poke y' y
    let keyboardTip' = (fromIntegral . fromEnum) keyboardTip
    model <- allocMem :: IO (Ptr (Ptr Gtk.TreeModel.TreeModel))
    path <- allocMem :: IO (Ptr (Ptr Gtk.TreePath.TreePath))
    iter <- callocBoxedBytes 32 :: IO (Ptr Gtk.TreeIter.TreeIter)
    result <- gtk_tree_view_get_tooltip_context treeView' x' y' keyboardTip' model path iter
    let result' = (/= 0) result
    x'' <- peek x'
    y'' <- peek y'
    model' <- peek model
    maybeModel' <- convertIfNonNull model' $ \model'' -> do
        model''' <- (newObject Gtk.TreeModel.TreeModel) model''
        return model'''
    path' <- peek path
    path'' <- (wrapBoxed Gtk.TreePath.TreePath) path'
    iter' <- (wrapBoxed Gtk.TreeIter.TreeIter) iter
    touchManagedPtr treeView
    freeMem x'
    freeMem y'
    freeMem model
    freeMem path
    return (result', x'', y'', maybeModel', path'', iter')

data TreeViewGetTooltipContextMethodInfo
instance (signature ~ (Int32 -> Int32 -> Bool -> m (Bool,Int32,Int32,(Maybe Gtk.TreeModel.TreeModel),Gtk.TreePath.TreePath,Gtk.TreeIter.TreeIter)), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewGetTooltipContextMethodInfo a signature where
    overloadedMethod _ = treeViewGetTooltipContext

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

foreign import ccall "gtk_tree_view_get_vadjustment" gtk_tree_view_get_vadjustment :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    IO (Ptr Gtk.Adjustment.Adjustment)

{-# DEPRECATED treeViewGetVadjustment ["(Since version 3.0)","Use 'GI.Gtk.Interfaces.Scrollable.scrollableGetVadjustment'"] #-}
{- |
Gets the 'GI.Gtk.Objects.Adjustment.Adjustment' currently being used for the vertical aspect.
-}
treeViewGetVadjustment ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: A 'GI.Gtk.Objects.TreeView.TreeView' -}
    -> m Gtk.Adjustment.Adjustment
    {- ^ __Returns:__ A 'GI.Gtk.Objects.Adjustment.Adjustment' object, or 'Nothing'
    if none is currently being used. -}
treeViewGetVadjustment treeView = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    result <- gtk_tree_view_get_vadjustment treeView'
    checkUnexpectedReturnNULL "treeViewGetVadjustment" result
    result' <- (newObject Gtk.Adjustment.Adjustment) result
    touchManagedPtr treeView
    return result'

data TreeViewGetVadjustmentMethodInfo
instance (signature ~ (m Gtk.Adjustment.Adjustment), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewGetVadjustmentMethodInfo a signature where
    overloadedMethod _ = treeViewGetVadjustment

-- method TreeView::get_visible_range
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start_path", argType = TInterface (Name {namespace = "Gtk", name = "TreePath"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Return location for start of region,\n             or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "end_path", argType = TInterface (Name {namespace = "Gtk", name = "TreePath"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Return location for end of region, or %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_get_visible_range" gtk_tree_view_get_visible_range :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    Ptr (Ptr Gtk.TreePath.TreePath) ->      -- start_path : TInterface (Name {namespace = "Gtk", name = "TreePath"})
    Ptr (Ptr Gtk.TreePath.TreePath) ->      -- end_path : TInterface (Name {namespace = "Gtk", name = "TreePath"})
    IO CInt

{- |
Sets /@startPath@/ and /@endPath@/ to be the first and last visible path.
Note that there may be invisible paths in between.

The paths should be freed with 'GI.Gtk.Structs.TreePath.treePathFree' after use.

@since 2.8
-}
treeViewGetVisibleRange ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: A 'GI.Gtk.Objects.TreeView.TreeView' -}
    -> m (Bool,Gtk.TreePath.TreePath,Gtk.TreePath.TreePath)
    {- ^ __Returns:__ 'True', if valid paths were placed in /@startPath@/ and /@endPath@/. -}
treeViewGetVisibleRange treeView = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    startPath <- allocMem :: IO (Ptr (Ptr Gtk.TreePath.TreePath))
    endPath <- allocMem :: IO (Ptr (Ptr Gtk.TreePath.TreePath))
    result <- gtk_tree_view_get_visible_range treeView' startPath endPath
    let result' = (/= 0) result
    startPath' <- peek startPath
    startPath'' <- (wrapBoxed Gtk.TreePath.TreePath) startPath'
    endPath' <- peek endPath
    endPath'' <- (wrapBoxed Gtk.TreePath.TreePath) endPath'
    touchManagedPtr treeView
    freeMem startPath
    freeMem endPath
    return (result', startPath'', endPath'')

data TreeViewGetVisibleRangeMethodInfo
instance (signature ~ (m (Bool,Gtk.TreePath.TreePath,Gtk.TreePath.TreePath)), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewGetVisibleRangeMethodInfo a signature where
    overloadedMethod _ = treeViewGetVisibleRange

-- method TreeView::get_visible_rect
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTreeView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "visible_rect", argType = TInterface (Name {namespace = "Gdk", name = "Rectangle"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "rectangle to fill", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_tree_view_get_visible_rect" gtk_tree_view_get_visible_rect :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    Ptr Gdk.Rectangle.Rectangle ->          -- visible_rect : TInterface (Name {namespace = "Gdk", name = "Rectangle"})
    IO ()

{- |
Fills /@visibleRect@/ with the currently-visible region of the
buffer, in tree coordinates. Convert to bin_window coordinates with
'GI.Gtk.Objects.TreeView.treeViewConvertTreeToBinWindowCoords'.
Tree coordinates start at 0,0 for row 0 of the tree, and cover the entire
scrollable area of the tree.
-}
treeViewGetVisibleRect ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: a 'GI.Gtk.Objects.TreeView.TreeView' -}
    -> m (Gdk.Rectangle.Rectangle)
treeViewGetVisibleRect treeView = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    visibleRect <- callocBoxedBytes 16 :: IO (Ptr Gdk.Rectangle.Rectangle)
    gtk_tree_view_get_visible_rect treeView' visibleRect
    visibleRect' <- (wrapBoxed Gdk.Rectangle.Rectangle) visibleRect
    touchManagedPtr treeView
    return visibleRect'

data TreeViewGetVisibleRectMethodInfo
instance (signature ~ (m (Gdk.Rectangle.Rectangle)), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewGetVisibleRectMethodInfo a signature where
    overloadedMethod _ = treeViewGetVisibleRect

-- method TreeView::insert_column
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeView.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "column", argType = TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The #GtkTreeViewColumn to be inserted.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "position", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The position to insert @column in.", 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_insert_column" gtk_tree_view_insert_column :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    Ptr Gtk.TreeViewColumn.TreeViewColumn -> -- column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
    Int32 ->                                -- position : TBasicType TInt
    IO Int32

{- |
This inserts the /@column@/ into the /@treeView@/ at /@position@/.  If /@position@/ is
-1, then the column is inserted at the end. If /@treeView@/ has
“fixed_height” mode enabled, then /@column@/ must have its “sizing” property
set to be GTK_TREE_VIEW_COLUMN_FIXED.
-}
treeViewInsertColumn ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a, Gtk.TreeViewColumn.IsTreeViewColumn b) =>
    a
    {- ^ /@treeView@/: A 'GI.Gtk.Objects.TreeView.TreeView'. -}
    -> b
    {- ^ /@column@/: The 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn' to be inserted. -}
    -> Int32
    {- ^ /@position@/: The position to insert /@column@/ in. -}
    -> m Int32
    {- ^ __Returns:__ The number of columns in /@treeView@/ after insertion. -}
treeViewInsertColumn treeView column position = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    column' <- unsafeManagedPtrCastPtr column
    result <- gtk_tree_view_insert_column treeView' column' position
    touchManagedPtr treeView
    touchManagedPtr column
    return result

data TreeViewInsertColumnMethodInfo
instance (signature ~ (b -> Int32 -> m Int32), MonadIO m, IsTreeView a, Gtk.TreeViewColumn.IsTreeViewColumn b) => O.MethodInfo TreeViewInsertColumnMethodInfo a signature where
    overloadedMethod _ = treeViewInsertColumn

-- method TreeView::insert_column_with_data_func
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTreeView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "position", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Position to insert, -1 for append", 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 "column title", 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 "cell renderer for column", 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 = False, argDoc = Documentation {rawDocText = Just "function to set attributes of cell renderer", sinceVersion = Nothing}, argScope = ScopeTypeNotified, argClosure = 5, argDestroy = 6, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "data for @func", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dnotify", argType = TInterface (Name {namespace = "GLib", name = "DestroyNotify"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "destroy notifier for @data", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_tree_view_insert_column_with_data_func" gtk_tree_view_insert_column_with_data_func :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    Int32 ->                                -- position : TBasicType TInt
    CString ->                              -- title : TBasicType TUTF8
    Ptr Gtk.CellRenderer.CellRenderer ->    -- cell : TInterface (Name {namespace = "Gtk", name = "CellRenderer"})
    FunPtr Gtk.Callbacks.C_TreeCellDataFunc -> -- func : TInterface (Name {namespace = "Gtk", name = "TreeCellDataFunc"})
    Ptr () ->                               -- data : TBasicType TPtr
    FunPtr GLib.Callbacks.C_DestroyNotify -> -- dnotify : TInterface (Name {namespace = "GLib", name = "DestroyNotify"})
    IO Int32

{- |
Convenience function that inserts a new column into the 'GI.Gtk.Objects.TreeView.TreeView'
with the given cell renderer and a 'GI.Gtk.Callbacks.TreeCellDataFunc' to set cell renderer
attributes (normally using data from the model). See also
'GI.Gtk.Objects.TreeViewColumn.treeViewColumnSetCellDataFunc', 'GI.Gtk.Objects.TreeViewColumn.treeViewColumnPackStart'.
If /@treeView@/ has “fixed_height” mode enabled, then the new column will have its
“sizing” property set to be GTK_TREE_VIEW_COLUMN_FIXED.
-}
treeViewInsertColumnWithDataFunc ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a, Gtk.CellRenderer.IsCellRenderer b) =>
    a
    {- ^ /@treeView@/: a 'GI.Gtk.Objects.TreeView.TreeView' -}
    -> Int32
    {- ^ /@position@/: Position to insert, -1 for append -}
    -> T.Text
    {- ^ /@title@/: column title -}
    -> b
    {- ^ /@cell@/: cell renderer for column -}
    -> Gtk.Callbacks.TreeCellDataFunc
    {- ^ /@func@/: function to set attributes of cell renderer -}
    -> m Int32
    {- ^ __Returns:__ number of columns in the tree view post-insert -}
treeViewInsertColumnWithDataFunc treeView position title cell func = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    title' <- textToCString title
    cell' <- unsafeManagedPtrCastPtr cell
    func' <- Gtk.Callbacks.mk_TreeCellDataFunc (Gtk.Callbacks.wrap_TreeCellDataFunc Nothing (Gtk.Callbacks.drop_closures_TreeCellDataFunc func))
    let data_ = castFunPtrToPtr func'
    let dnotify = safeFreeFunPtrPtr
    result <- gtk_tree_view_insert_column_with_data_func treeView' position title' cell' func' data_ dnotify
    touchManagedPtr treeView
    touchManagedPtr cell
    freeMem title'
    return result

data TreeViewInsertColumnWithDataFuncMethodInfo
instance (signature ~ (Int32 -> T.Text -> b -> Gtk.Callbacks.TreeCellDataFunc -> m Int32), MonadIO m, IsTreeView a, Gtk.CellRenderer.IsCellRenderer b) => O.MethodInfo TreeViewInsertColumnWithDataFuncMethodInfo a signature where
    overloadedMethod _ = treeViewInsertColumnWithDataFunc

-- method TreeView::is_blank_at_pos
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The x position to be identified (relative to bin_window)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "y", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The y position to be identified (relative to bin_window)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TInterface (Name {namespace = "Gtk", name = "TreePath"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A pointer to a #GtkTreePath pointer to be filled in, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "column", argType = TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A pointer to a #GtkTreeViewColumn pointer to be filled in, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "cell_x", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A pointer where the X coordinate relative to the cell can be placed, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "cell_y", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A pointer where the Y coordinate relative to the cell can be placed, or %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_is_blank_at_pos" gtk_tree_view_is_blank_at_pos :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    Int32 ->                                -- x : TBasicType TInt
    Int32 ->                                -- y : TBasicType TInt
    Ptr (Ptr Gtk.TreePath.TreePath) ->      -- path : TInterface (Name {namespace = "Gtk", name = "TreePath"})
    Ptr (Ptr Gtk.TreeViewColumn.TreeViewColumn) -> -- column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
    Ptr Int32 ->                            -- cell_x : TBasicType TInt
    Ptr Int32 ->                            -- cell_y : TBasicType TInt
    IO CInt

{- |
Determine whether the point (/@x@/, /@y@/) in /@treeView@/ is blank, that is no
cell content nor an expander arrow is drawn at the location. If so, the
location can be considered as the background. You might wish to take
special action on clicks on the background, such as clearing a current
selection, having a custom context menu or starting rubber banding.

The /@x@/ and /@y@/ coordinate that are provided must be relative to bin_window
coordinates.  That is, /@x@/ and /@y@/ must come from an event on /@treeView@/
where @event->window == gtk_tree_view_get_bin_window ()@.

For converting widget coordinates (eg. the ones you get from
GtkWidget::query-tooltip), please see
'GI.Gtk.Objects.TreeView.treeViewConvertWidgetToBinWindowCoords'.

The /@path@/, /@column@/, /@cellX@/ and /@cellY@/ arguments will be filled in
likewise as for 'GI.Gtk.Objects.TreeView.treeViewGetPathAtPos'.  Please see
'GI.Gtk.Objects.TreeView.treeViewGetPathAtPos' for more information.

@since 3.0
-}
treeViewIsBlankAtPos ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: A 'GI.Gtk.Objects.TreeView.TreeView' -}
    -> Int32
    {- ^ /@x@/: The x position to be identified (relative to bin_window) -}
    -> Int32
    {- ^ /@y@/: The y position to be identified (relative to bin_window) -}
    -> m (Bool,Gtk.TreePath.TreePath,Gtk.TreeViewColumn.TreeViewColumn,Int32,Int32)
    {- ^ __Returns:__ 'True' if the area at the given coordinates is blank,
'False' otherwise. -}
treeViewIsBlankAtPos treeView x y = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    path <- allocMem :: IO (Ptr (Ptr Gtk.TreePath.TreePath))
    column <- allocMem :: IO (Ptr (Ptr Gtk.TreeViewColumn.TreeViewColumn))
    cellX <- allocMem :: IO (Ptr Int32)
    cellY <- allocMem :: IO (Ptr Int32)
    result <- gtk_tree_view_is_blank_at_pos treeView' x y path column cellX cellY
    let result' = (/= 0) result
    path' <- peek path
    path'' <- (wrapBoxed Gtk.TreePath.TreePath) path'
    column' <- peek column
    column'' <- (wrapObject Gtk.TreeViewColumn.TreeViewColumn) column'
    cellX' <- peek cellX
    cellY' <- peek cellY
    touchManagedPtr treeView
    freeMem path
    freeMem column
    freeMem cellX
    freeMem cellY
    return (result', path'', column'', cellX', cellY')

data TreeViewIsBlankAtPosMethodInfo
instance (signature ~ (Int32 -> Int32 -> m (Bool,Gtk.TreePath.TreePath,Gtk.TreeViewColumn.TreeViewColumn,Int32,Int32)), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewIsBlankAtPosMethodInfo a signature where
    overloadedMethod _ = treeViewIsBlankAtPos

-- method TreeView::is_rubber_banding_active
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTreeView", 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_is_rubber_banding_active" gtk_tree_view_is_rubber_banding_active :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    IO CInt

{- |
Returns whether a rubber banding operation is currently being done
in /@treeView@/.

@since 2.12
-}
treeViewIsRubberBandingActive ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: a 'GI.Gtk.Objects.TreeView.TreeView' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if a rubber banding operation is currently being
done in /@treeView@/. -}
treeViewIsRubberBandingActive treeView = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    result <- gtk_tree_view_is_rubber_banding_active treeView'
    let result' = (/= 0) result
    touchManagedPtr treeView
    return result'

data TreeViewIsRubberBandingActiveMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewIsRubberBandingActiveMethodInfo a signature where
    overloadedMethod _ = treeViewIsRubberBandingActive

-- method TreeView::map_expanded_rows
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "func", argType = TInterface (Name {namespace = "Gtk", name = "TreeViewMappingFunc"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A function to be called", sinceVersion = Nothing}, argScope = ScopeTypeCall, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "User data to be passed to the function.", 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_map_expanded_rows" gtk_tree_view_map_expanded_rows :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    FunPtr Gtk.Callbacks.C_TreeViewMappingFunc -> -- func : TInterface (Name {namespace = "Gtk", name = "TreeViewMappingFunc"})
    Ptr () ->                               -- data : TBasicType TPtr
    IO ()

{- |
Calls /@func@/ on all expanded rows.
-}
treeViewMapExpandedRows ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: A 'GI.Gtk.Objects.TreeView.TreeView' -}
    -> Gtk.Callbacks.TreeViewMappingFunc
    {- ^ /@func@/: A function to be called -}
    -> m ()
treeViewMapExpandedRows treeView func = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    func' <- Gtk.Callbacks.mk_TreeViewMappingFunc (Gtk.Callbacks.wrap_TreeViewMappingFunc Nothing (Gtk.Callbacks.drop_closures_TreeViewMappingFunc func))
    let data_ = nullPtr
    gtk_tree_view_map_expanded_rows treeView' func' data_
    safeFreeFunPtr $ castFunPtrToPtr func'
    touchManagedPtr treeView
    return ()

data TreeViewMapExpandedRowsMethodInfo
instance (signature ~ (Gtk.Callbacks.TreeViewMappingFunc -> m ()), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewMapExpandedRowsMethodInfo a signature where
    overloadedMethod _ = treeViewMapExpandedRows

-- method TreeView::move_column_after
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "column", argType = TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The #GtkTreeViewColumn to be moved.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "base_column", argType = TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "The #GtkTreeViewColumn to be moved relative to, 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_move_column_after" gtk_tree_view_move_column_after :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    Ptr Gtk.TreeViewColumn.TreeViewColumn -> -- column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
    Ptr Gtk.TreeViewColumn.TreeViewColumn -> -- base_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
    IO ()

{- |
Moves /@column@/ to be after to /@baseColumn@/.  If /@baseColumn@/ is 'Nothing', then
/@column@/ is placed in the first position.
-}
treeViewMoveColumnAfter ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a, Gtk.TreeViewColumn.IsTreeViewColumn b, Gtk.TreeViewColumn.IsTreeViewColumn c) =>
    a
    {- ^ /@treeView@/: A 'GI.Gtk.Objects.TreeView.TreeView' -}
    -> b
    {- ^ /@column@/: The 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn' to be moved. -}
    -> Maybe (c)
    {- ^ /@baseColumn@/: The 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn' to be moved relative to, or 'Nothing'. -}
    -> m ()
treeViewMoveColumnAfter treeView column baseColumn = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    column' <- unsafeManagedPtrCastPtr column
    maybeBaseColumn <- case baseColumn of
        Nothing -> return nullPtr
        Just jBaseColumn -> do
            jBaseColumn' <- unsafeManagedPtrCastPtr jBaseColumn
            return jBaseColumn'
    gtk_tree_view_move_column_after treeView' column' maybeBaseColumn
    touchManagedPtr treeView
    touchManagedPtr column
    whenJust baseColumn touchManagedPtr
    return ()

data TreeViewMoveColumnAfterMethodInfo
instance (signature ~ (b -> Maybe (c) -> m ()), MonadIO m, IsTreeView a, Gtk.TreeViewColumn.IsTreeViewColumn b, Gtk.TreeViewColumn.IsTreeViewColumn c) => O.MethodInfo TreeViewMoveColumnAfterMethodInfo a signature where
    overloadedMethod _ = treeViewMoveColumnAfter

-- method TreeView::remove_column
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeView.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "column", argType = TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The #GtkTreeViewColumn to remove.", 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_remove_column" gtk_tree_view_remove_column :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    Ptr Gtk.TreeViewColumn.TreeViewColumn -> -- column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
    IO Int32

{- |
Removes /@column@/ from /@treeView@/.
-}
treeViewRemoveColumn ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a, Gtk.TreeViewColumn.IsTreeViewColumn b) =>
    a
    {- ^ /@treeView@/: A 'GI.Gtk.Objects.TreeView.TreeView'. -}
    -> b
    {- ^ /@column@/: The 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn' to remove. -}
    -> m Int32
    {- ^ __Returns:__ The number of columns in /@treeView@/ after removing. -}
treeViewRemoveColumn treeView column = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    column' <- unsafeManagedPtrCastPtr column
    result <- gtk_tree_view_remove_column treeView' column'
    touchManagedPtr treeView
    touchManagedPtr column
    return result

data TreeViewRemoveColumnMethodInfo
instance (signature ~ (b -> m Int32), MonadIO m, IsTreeView a, Gtk.TreeViewColumn.IsTreeViewColumn b) => O.MethodInfo TreeViewRemoveColumnMethodInfo a signature where
    overloadedMethod _ = treeViewRemoveColumn

-- method TreeView::row_activated
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TInterface (Name {namespace = "Gtk", name = "TreePath"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The #GtkTreePath to be activated.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "column", argType = TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The #GtkTreeViewColumn to be activated.", 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_row_activated" gtk_tree_view_row_activated :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    Ptr Gtk.TreePath.TreePath ->            -- path : TInterface (Name {namespace = "Gtk", name = "TreePath"})
    Ptr Gtk.TreeViewColumn.TreeViewColumn -> -- column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
    IO ()

{- |
Activates the cell determined by /@path@/ and /@column@/.
-}
treeViewRowActivated ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a, Gtk.TreeViewColumn.IsTreeViewColumn b) =>
    a
    {- ^ /@treeView@/: A 'GI.Gtk.Objects.TreeView.TreeView' -}
    -> Gtk.TreePath.TreePath
    {- ^ /@path@/: The 'GI.Gtk.Structs.TreePath.TreePath' to be activated. -}
    -> b
    {- ^ /@column@/: The 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn' to be activated. -}
    -> m ()
treeViewRowActivated treeView path column = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    path' <- unsafeManagedPtrGetPtr path
    column' <- unsafeManagedPtrCastPtr column
    gtk_tree_view_row_activated treeView' path' column'
    touchManagedPtr treeView
    touchManagedPtr path
    touchManagedPtr column
    return ()

data TreeViewRowActivatedMethodInfo
instance (signature ~ (Gtk.TreePath.TreePath -> b -> m ()), MonadIO m, IsTreeView a, Gtk.TreeViewColumn.IsTreeViewColumn b) => O.MethodInfo TreeViewRowActivatedMethodInfo a signature where
    overloadedMethod _ = treeViewRowActivated

-- method TreeView::row_expanded
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeView.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TInterface (Name {namespace = "Gtk", name = "TreePath"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreePath to test expansion state.", 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_row_expanded" gtk_tree_view_row_expanded :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    Ptr Gtk.TreePath.TreePath ->            -- path : TInterface (Name {namespace = "Gtk", name = "TreePath"})
    IO CInt

{- |
Returns 'True' if the node pointed to by /@path@/ is expanded in /@treeView@/.
-}
treeViewRowExpanded ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: A 'GI.Gtk.Objects.TreeView.TreeView'. -}
    -> Gtk.TreePath.TreePath
    {- ^ /@path@/: A 'GI.Gtk.Structs.TreePath.TreePath' to test expansion state. -}
    -> m Bool
    {- ^ __Returns:__ 'True' if @/path/@ is expanded. -}
treeViewRowExpanded treeView path = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    path' <- unsafeManagedPtrGetPtr path
    result <- gtk_tree_view_row_expanded treeView' path'
    let result' = (/= 0) result
    touchManagedPtr treeView
    touchManagedPtr path
    return result'

data TreeViewRowExpandedMethodInfo
instance (signature ~ (Gtk.TreePath.TreePath -> m Bool), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewRowExpandedMethodInfo a signature where
    overloadedMethod _ = treeViewRowExpanded

-- method TreeView::scroll_to_cell
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeView.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TInterface (Name {namespace = "Gtk", name = "TreePath"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "The path of the row to move to, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "column", argType = TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "The #GtkTreeViewColumn to move horizontally to, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "use_align", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether to use alignment arguments, or %FALSE.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "row_align", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The vertical alignment of the row specified by @path.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "col_align", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The horizontal alignment of the column specified by @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_scroll_to_cell" gtk_tree_view_scroll_to_cell :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    Ptr Gtk.TreePath.TreePath ->            -- path : TInterface (Name {namespace = "Gtk", name = "TreePath"})
    Ptr Gtk.TreeViewColumn.TreeViewColumn -> -- column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
    CInt ->                                 -- use_align : TBasicType TBoolean
    CFloat ->                               -- row_align : TBasicType TFloat
    CFloat ->                               -- col_align : TBasicType TFloat
    IO ()

{- |
Moves the alignments of /@treeView@/ to the position specified by /@column@/ and
/@path@/.  If /@column@/ is 'Nothing', then no horizontal scrolling occurs.  Likewise,
if /@path@/ is 'Nothing' no vertical scrolling occurs.  At a minimum, one of /@column@/
or /@path@/ need to be non-'Nothing'.  /@rowAlign@/ determines where the row is
placed, and /@colAlign@/ determines where /@column@/ is placed.  Both are expected
to be between 0.0 and 1.0. 0.0 means left\/top alignment, 1.0 means
right\/bottom alignment, 0.5 means center.

If /@useAlign@/ is 'False', then the alignment arguments are ignored, and the
tree does the minimum amount of work to scroll the cell onto the screen.
This means that the cell will be scrolled to the edge closest to its current
position.  If the cell is currently visible on the screen, nothing is done.

This function only works if the model is set, and /@path@/ is a valid row on the
model.  If the model changes before the /@treeView@/ is realized, the centered
path will be modified to reflect this change.
-}
treeViewScrollToCell ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a, Gtk.TreeViewColumn.IsTreeViewColumn b) =>
    a
    {- ^ /@treeView@/: A 'GI.Gtk.Objects.TreeView.TreeView'. -}
    -> Maybe (Gtk.TreePath.TreePath)
    {- ^ /@path@/: The path of the row to move to, or 'Nothing'. -}
    -> Maybe (b)
    {- ^ /@column@/: The 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn' to move horizontally to, or 'Nothing'. -}
    -> Bool
    {- ^ /@useAlign@/: whether to use alignment arguments, or 'False'. -}
    -> Float
    {- ^ /@rowAlign@/: The vertical alignment of the row specified by /@path@/. -}
    -> Float
    {- ^ /@colAlign@/: The horizontal alignment of the column specified by /@column@/. -}
    -> m ()
treeViewScrollToCell treeView path column useAlign rowAlign colAlign = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    maybePath <- case path of
        Nothing -> return nullPtr
        Just jPath -> do
            jPath' <- unsafeManagedPtrGetPtr jPath
            return jPath'
    maybeColumn <- case column of
        Nothing -> return nullPtr
        Just jColumn -> do
            jColumn' <- unsafeManagedPtrCastPtr jColumn
            return jColumn'
    let useAlign' = (fromIntegral . fromEnum) useAlign
    let rowAlign' = realToFrac rowAlign
    let colAlign' = realToFrac colAlign
    gtk_tree_view_scroll_to_cell treeView' maybePath maybeColumn useAlign' rowAlign' colAlign'
    touchManagedPtr treeView
    whenJust path touchManagedPtr
    whenJust column touchManagedPtr
    return ()

data TreeViewScrollToCellMethodInfo
instance (signature ~ (Maybe (Gtk.TreePath.TreePath) -> Maybe (b) -> Bool -> Float -> Float -> m ()), MonadIO m, IsTreeView a, Gtk.TreeViewColumn.IsTreeViewColumn b) => O.MethodInfo TreeViewScrollToCellMethodInfo a signature where
    overloadedMethod _ = treeViewScrollToCell

-- method TreeView::scroll_to_point
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTreeView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tree_x", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "X coordinate of new top-left pixel of visible area, or -1", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tree_y", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Y coordinate of new top-left pixel of visible area, 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_scroll_to_point" gtk_tree_view_scroll_to_point :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    Int32 ->                                -- tree_x : TBasicType TInt
    Int32 ->                                -- tree_y : TBasicType TInt
    IO ()

{- |
Scrolls the tree view such that the top-left corner of the visible
area is /@treeX@/, /@treeY@/, where /@treeX@/ and /@treeY@/ are specified
in tree coordinates.  The /@treeView@/ must be realized before
this function is called.  If it isn\'t, you probably want to be
using 'GI.Gtk.Objects.TreeView.treeViewScrollToCell'.

If either /@treeX@/ or /@treeY@/ are -1, then that direction isn’t scrolled.
-}
treeViewScrollToPoint ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: a 'GI.Gtk.Objects.TreeView.TreeView' -}
    -> Int32
    {- ^ /@treeX@/: X coordinate of new top-left pixel of visible area, or -1 -}
    -> Int32
    {- ^ /@treeY@/: Y coordinate of new top-left pixel of visible area, or -1 -}
    -> m ()
treeViewScrollToPoint treeView treeX treeY = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    gtk_tree_view_scroll_to_point treeView' treeX treeY
    touchManagedPtr treeView
    return ()

data TreeViewScrollToPointMethodInfo
instance (signature ~ (Int32 -> Int32 -> m ()), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewScrollToPointMethodInfo a signature where
    overloadedMethod _ = treeViewScrollToPoint

-- method TreeView::set_activate_on_single_click
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTreeView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "single", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE to emit row-activated on a single click", 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_set_activate_on_single_click" gtk_tree_view_set_activate_on_single_click :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    CInt ->                                 -- single : TBasicType TBoolean
    IO ()

{- |
Cause the 'GI.Gtk.Objects.TreeView.TreeView'::@/row-activated/@ signal to be emitted
on a single click instead of a double click.

@since 3.8
-}
treeViewSetActivateOnSingleClick ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: a 'GI.Gtk.Objects.TreeView.TreeView' -}
    -> Bool
    {- ^ /@single@/: 'True' to emit row-activated on a single click -}
    -> m ()
treeViewSetActivateOnSingleClick treeView single = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    let single' = (fromIntegral . fromEnum) single
    gtk_tree_view_set_activate_on_single_click treeView' single'
    touchManagedPtr treeView
    return ()

data TreeViewSetActivateOnSingleClickMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewSetActivateOnSingleClickMethodInfo a signature where
    overloadedMethod _ = treeViewSetActivateOnSingleClick

-- method TreeView::set_column_drag_function
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeView.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "func", argType = TInterface (Name {namespace = "Gtk", name = "TreeViewColumnDropFunc"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "A function to determine which columns are reorderable, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "User data to be passed to @func, or %NULL", 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 = True, argDoc = Documentation {rawDocText = Just "Destroy notifier for @user_data, or %NULL", 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_set_column_drag_function" gtk_tree_view_set_column_drag_function :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    FunPtr Gtk.Callbacks.C_TreeViewColumnDropFunc -> -- func : TInterface (Name {namespace = "Gtk", name = "TreeViewColumnDropFunc"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    FunPtr GLib.Callbacks.C_DestroyNotify -> -- destroy : TInterface (Name {namespace = "GLib", name = "DestroyNotify"})
    IO ()

{- |
Sets a user function for determining where a column may be dropped when
dragged.  This function is called on every column pair in turn at the
beginning of a column drag to determine where a drop can take place.  The
arguments passed to /@func@/ are: the /@treeView@/, the 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn' being
dragged, the two 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn' s determining the drop spot, and
/@userData@/.  If either of the 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn' arguments for the drop spot
are 'Nothing', then they indicate an edge.  If /@func@/ is set to be 'Nothing', then
/@treeView@/ reverts to the default behavior of allowing all columns to be
dropped everywhere.
-}
treeViewSetColumnDragFunction ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: A 'GI.Gtk.Objects.TreeView.TreeView'. -}
    -> Maybe (Gtk.Callbacks.TreeViewColumnDropFunc)
    {- ^ /@func@/: A function to determine which columns are reorderable, or 'Nothing'. -}
    -> m ()
treeViewSetColumnDragFunction treeView func = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    maybeFunc <- case func of
        Nothing -> return (castPtrToFunPtr nullPtr)
        Just jFunc -> do
            jFunc' <- Gtk.Callbacks.mk_TreeViewColumnDropFunc (Gtk.Callbacks.wrap_TreeViewColumnDropFunc Nothing (Gtk.Callbacks.drop_closures_TreeViewColumnDropFunc jFunc))
            return jFunc'
    let userData = castFunPtrToPtr maybeFunc
    let destroy = safeFreeFunPtrPtr
    gtk_tree_view_set_column_drag_function treeView' maybeFunc userData destroy
    touchManagedPtr treeView
    return ()

data TreeViewSetColumnDragFunctionMethodInfo
instance (signature ~ (Maybe (Gtk.Callbacks.TreeViewColumnDropFunc) -> m ()), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewSetColumnDragFunctionMethodInfo a signature where
    overloadedMethod _ = treeViewSetColumnDragFunction

-- method TreeView::set_cursor
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TInterface (Name {namespace = "Gtk", name = "TreePath"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreePath", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "focus_column", argType = TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "A #GtkTreeViewColumn, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start_editing", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE if the specified cell should start being edited.", 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_set_cursor" gtk_tree_view_set_cursor :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    Ptr Gtk.TreePath.TreePath ->            -- path : TInterface (Name {namespace = "Gtk", name = "TreePath"})
    Ptr Gtk.TreeViewColumn.TreeViewColumn -> -- focus_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
    CInt ->                                 -- start_editing : TBasicType TBoolean
    IO ()

{- |
Sets the current keyboard focus to be at /@path@/, and selects it.  This is
useful when you want to focus the user’s attention on a particular row.  If
/@focusColumn@/ is not 'Nothing', then focus is given to the column specified by
it. Additionally, if /@focusColumn@/ is specified, and /@startEditing@/ is
'True', then editing should be started in the specified cell.
This function is often followed by /@gtkWidgetGrabFocus@/ (/@treeView@/)
in order to give keyboard focus to the widget.  Please note that editing
can only happen when the widget is realized.

If /@path@/ is invalid for /@model@/, the current cursor (if any) will be unset
and the function will return without failing.
-}
treeViewSetCursor ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a, Gtk.TreeViewColumn.IsTreeViewColumn b) =>
    a
    {- ^ /@treeView@/: A 'GI.Gtk.Objects.TreeView.TreeView' -}
    -> Gtk.TreePath.TreePath
    {- ^ /@path@/: A 'GI.Gtk.Structs.TreePath.TreePath' -}
    -> Maybe (b)
    {- ^ /@focusColumn@/: A 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn', or 'Nothing' -}
    -> Bool
    {- ^ /@startEditing@/: 'True' if the specified cell should start being edited. -}
    -> m ()
treeViewSetCursor treeView path focusColumn startEditing = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    path' <- unsafeManagedPtrGetPtr path
    maybeFocusColumn <- case focusColumn of
        Nothing -> return nullPtr
        Just jFocusColumn -> do
            jFocusColumn' <- unsafeManagedPtrCastPtr jFocusColumn
            return jFocusColumn'
    let startEditing' = (fromIntegral . fromEnum) startEditing
    gtk_tree_view_set_cursor treeView' path' maybeFocusColumn startEditing'
    touchManagedPtr treeView
    touchManagedPtr path
    whenJust focusColumn touchManagedPtr
    return ()

data TreeViewSetCursorMethodInfo
instance (signature ~ (Gtk.TreePath.TreePath -> Maybe (b) -> Bool -> m ()), MonadIO m, IsTreeView a, Gtk.TreeViewColumn.IsTreeViewColumn b) => O.MethodInfo TreeViewSetCursorMethodInfo a signature where
    overloadedMethod _ = treeViewSetCursor

-- method TreeView::set_cursor_on_cell
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TInterface (Name {namespace = "Gtk", name = "TreePath"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreePath", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "focus_column", argType = TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "A #GtkTreeViewColumn, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "focus_cell", argType = TInterface (Name {namespace = "Gtk", name = "CellRenderer"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "A #GtkCellRenderer, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start_editing", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE if the specified cell should start being edited.", 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_set_cursor_on_cell" gtk_tree_view_set_cursor_on_cell :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    Ptr Gtk.TreePath.TreePath ->            -- path : TInterface (Name {namespace = "Gtk", name = "TreePath"})
    Ptr Gtk.TreeViewColumn.TreeViewColumn -> -- focus_column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
    Ptr Gtk.CellRenderer.CellRenderer ->    -- focus_cell : TInterface (Name {namespace = "Gtk", name = "CellRenderer"})
    CInt ->                                 -- start_editing : TBasicType TBoolean
    IO ()

{- |
Sets the current keyboard focus to be at /@path@/, and selects it.  This is
useful when you want to focus the user’s attention on a particular row.  If
/@focusColumn@/ is not 'Nothing', then focus is given to the column specified by
it. If /@focusColumn@/ and /@focusCell@/ are not 'Nothing', and /@focusColumn@/
contains 2 or more editable or activatable cells, then focus is given to
the cell specified by /@focusCell@/. Additionally, if /@focusColumn@/ is
specified, and /@startEditing@/ is 'True', then editing should be started in
the specified cell.  This function is often followed by
/@gtkWidgetGrabFocus@/ (/@treeView@/) in order to give keyboard focus to the
widget.  Please note that editing can only happen when the widget is
realized.

If /@path@/ is invalid for /@model@/, the current cursor (if any) will be unset
and the function will return without failing.

@since 2.2
-}
treeViewSetCursorOnCell ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a, Gtk.TreeViewColumn.IsTreeViewColumn b, Gtk.CellRenderer.IsCellRenderer c) =>
    a
    {- ^ /@treeView@/: A 'GI.Gtk.Objects.TreeView.TreeView' -}
    -> Gtk.TreePath.TreePath
    {- ^ /@path@/: A 'GI.Gtk.Structs.TreePath.TreePath' -}
    -> Maybe (b)
    {- ^ /@focusColumn@/: A 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn', or 'Nothing' -}
    -> Maybe (c)
    {- ^ /@focusCell@/: A 'GI.Gtk.Objects.CellRenderer.CellRenderer', or 'Nothing' -}
    -> Bool
    {- ^ /@startEditing@/: 'True' if the specified cell should start being edited. -}
    -> m ()
treeViewSetCursorOnCell treeView path focusColumn focusCell startEditing = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    path' <- unsafeManagedPtrGetPtr path
    maybeFocusColumn <- case focusColumn of
        Nothing -> return nullPtr
        Just jFocusColumn -> do
            jFocusColumn' <- unsafeManagedPtrCastPtr jFocusColumn
            return jFocusColumn'
    maybeFocusCell <- case focusCell of
        Nothing -> return nullPtr
        Just jFocusCell -> do
            jFocusCell' <- unsafeManagedPtrCastPtr jFocusCell
            return jFocusCell'
    let startEditing' = (fromIntegral . fromEnum) startEditing
    gtk_tree_view_set_cursor_on_cell treeView' path' maybeFocusColumn maybeFocusCell startEditing'
    touchManagedPtr treeView
    touchManagedPtr path
    whenJust focusColumn touchManagedPtr
    whenJust focusCell touchManagedPtr
    return ()

data TreeViewSetCursorOnCellMethodInfo
instance (signature ~ (Gtk.TreePath.TreePath -> Maybe (b) -> Maybe (c) -> Bool -> m ()), MonadIO m, IsTreeView a, Gtk.TreeViewColumn.IsTreeViewColumn b, Gtk.CellRenderer.IsCellRenderer c) => O.MethodInfo TreeViewSetCursorOnCellMethodInfo a signature where
    overloadedMethod _ = treeViewSetCursorOnCell

-- method TreeView::set_destroy_count_func
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "func", argType = TInterface (Name {namespace = "Gtk", name = "TreeDestroyCountFunc"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Function to be called when a view row is destroyed, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "User data to be passed to @func, or %NULL", 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 = True, argDoc = Documentation {rawDocText = Just "Destroy notifier for @data, or %NULL", 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_set_destroy_count_func" gtk_tree_view_set_destroy_count_func :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    FunPtr Gtk.Callbacks.C_TreeDestroyCountFunc -> -- func : TInterface (Name {namespace = "Gtk", name = "TreeDestroyCountFunc"})
    Ptr () ->                               -- data : TBasicType TPtr
    FunPtr GLib.Callbacks.C_DestroyNotify -> -- destroy : TInterface (Name {namespace = "GLib", name = "DestroyNotify"})
    IO ()

{-# DEPRECATED treeViewSetDestroyCountFunc ["(Since version 3.4)","Accessibility does not need the function anymore."] #-}
{- |
This function should almost never be used.  It is meant for private use by
ATK for determining the number of visible children that are removed when the
user collapses a row, or a row is deleted.
-}
treeViewSetDestroyCountFunc ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: A 'GI.Gtk.Objects.TreeView.TreeView' -}
    -> Maybe (Gtk.Callbacks.TreeDestroyCountFunc)
    {- ^ /@func@/: Function to be called when a view row is destroyed, or 'Nothing' -}
    -> m ()
treeViewSetDestroyCountFunc treeView func = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    maybeFunc <- case func of
        Nothing -> return (castPtrToFunPtr nullPtr)
        Just jFunc -> do
            jFunc' <- Gtk.Callbacks.mk_TreeDestroyCountFunc (Gtk.Callbacks.wrap_TreeDestroyCountFunc Nothing (Gtk.Callbacks.drop_closures_TreeDestroyCountFunc jFunc))
            return jFunc'
    let data_ = castFunPtrToPtr maybeFunc
    let destroy = safeFreeFunPtrPtr
    gtk_tree_view_set_destroy_count_func treeView' maybeFunc data_ destroy
    touchManagedPtr treeView
    return ()

data TreeViewSetDestroyCountFuncMethodInfo
instance (signature ~ (Maybe (Gtk.Callbacks.TreeDestroyCountFunc) -> m ()), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewSetDestroyCountFuncMethodInfo a signature where
    overloadedMethod _ = treeViewSetDestroyCountFunc

-- method TreeView::set_drag_dest_row
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTreeView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TInterface (Name {namespace = "Gtk", name = "TreePath"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "The path of the row to highlight, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pos", argType = TInterface (Name {namespace = "Gtk", name = "TreeViewDropPosition"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Specifies whether to drop before, after or into the row", 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_set_drag_dest_row" gtk_tree_view_set_drag_dest_row :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    Ptr Gtk.TreePath.TreePath ->            -- path : TInterface (Name {namespace = "Gtk", name = "TreePath"})
    CUInt ->                                -- pos : TInterface (Name {namespace = "Gtk", name = "TreeViewDropPosition"})
    IO ()

{- |
Sets the row that is highlighted for feedback.
If /@path@/ is 'Nothing', an existing highlight is removed.
-}
treeViewSetDragDestRow ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: a 'GI.Gtk.Objects.TreeView.TreeView' -}
    -> Maybe (Gtk.TreePath.TreePath)
    {- ^ /@path@/: The path of the row to highlight, or 'Nothing' -}
    -> Gtk.Enums.TreeViewDropPosition
    {- ^ /@pos@/: Specifies whether to drop before, after or into the row -}
    -> m ()
treeViewSetDragDestRow treeView path pos = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    maybePath <- case path of
        Nothing -> return nullPtr
        Just jPath -> do
            jPath' <- unsafeManagedPtrGetPtr jPath
            return jPath'
    let pos' = (fromIntegral . fromEnum) pos
    gtk_tree_view_set_drag_dest_row treeView' maybePath pos'
    touchManagedPtr treeView
    whenJust path touchManagedPtr
    return ()

data TreeViewSetDragDestRowMethodInfo
instance (signature ~ (Maybe (Gtk.TreePath.TreePath) -> Gtk.Enums.TreeViewDropPosition -> m ()), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewSetDragDestRowMethodInfo a signature where
    overloadedMethod _ = treeViewSetDragDestRow

-- method TreeView::set_enable_search
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enable_search", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE, if the user can search interactively", 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_set_enable_search" gtk_tree_view_set_enable_search :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    CInt ->                                 -- enable_search : TBasicType TBoolean
    IO ()

{- |
If /@enableSearch@/ is set, then the user can type in text to search through
the tree interactively (this is sometimes called \"typeahead find\").

Note that even if this is 'False', the user can still initiate a search
using the “start-interactive-search” key binding.
-}
treeViewSetEnableSearch ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: A 'GI.Gtk.Objects.TreeView.TreeView' -}
    -> Bool
    {- ^ /@enableSearch@/: 'True', if the user can search interactively -}
    -> m ()
treeViewSetEnableSearch treeView enableSearch = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    let enableSearch' = (fromIntegral . fromEnum) enableSearch
    gtk_tree_view_set_enable_search treeView' enableSearch'
    touchManagedPtr treeView
    return ()

data TreeViewSetEnableSearchMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewSetEnableSearchMethodInfo a signature where
    overloadedMethod _ = treeViewSetEnableSearch

-- method TreeView::set_enable_tree_lines
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTreeView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE to enable tree line drawing, %FALSE otherwise.", 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_set_enable_tree_lines" gtk_tree_view_set_enable_tree_lines :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    CInt ->                                 -- enabled : TBasicType TBoolean
    IO ()

{- |
Sets whether to draw lines interconnecting the expanders in /@treeView@/.
This does not have any visible effects for lists.

@since 2.10
-}
treeViewSetEnableTreeLines ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: a 'GI.Gtk.Objects.TreeView.TreeView' -}
    -> Bool
    {- ^ /@enabled@/: 'True' to enable tree line drawing, 'False' otherwise. -}
    -> m ()
treeViewSetEnableTreeLines treeView enabled = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    let enabled' = (fromIntegral . fromEnum) enabled
    gtk_tree_view_set_enable_tree_lines treeView' enabled'
    touchManagedPtr treeView
    return ()

data TreeViewSetEnableTreeLinesMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewSetEnableTreeLinesMethodInfo a signature where
    overloadedMethod _ = treeViewSetEnableTreeLines

-- method TreeView::set_expander_column
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "column", argType = TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%NULL, or the column to draw the expander arrow at.", 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_set_expander_column" gtk_tree_view_set_expander_column :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    Ptr Gtk.TreeViewColumn.TreeViewColumn -> -- column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
    IO ()

{- |
Sets the column to draw the expander arrow at. It must be in /@treeView@/.
If /@column@/ is 'Nothing', then the expander arrow is always at the first
visible column.

If you do not want expander arrow to appear in your tree, set the
expander column to a hidden column.
-}
treeViewSetExpanderColumn ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a, Gtk.TreeViewColumn.IsTreeViewColumn b) =>
    a
    {- ^ /@treeView@/: A 'GI.Gtk.Objects.TreeView.TreeView' -}
    -> b
    {- ^ /@column@/: 'Nothing', or the column to draw the expander arrow at. -}
    -> m ()
treeViewSetExpanderColumn treeView column = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    column' <- unsafeManagedPtrCastPtr column
    gtk_tree_view_set_expander_column treeView' column'
    touchManagedPtr treeView
    touchManagedPtr column
    return ()

data TreeViewSetExpanderColumnMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsTreeView a, Gtk.TreeViewColumn.IsTreeViewColumn b) => O.MethodInfo TreeViewSetExpanderColumnMethodInfo a signature where
    overloadedMethod _ = treeViewSetExpanderColumn

-- method TreeView::set_fixed_height_mode
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTreeView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enable", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE to enable fixed height mode", 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_set_fixed_height_mode" gtk_tree_view_set_fixed_height_mode :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    CInt ->                                 -- enable : TBasicType TBoolean
    IO ()

{- |
Enables or disables the fixed height mode of /@treeView@/.
Fixed height mode speeds up 'GI.Gtk.Objects.TreeView.TreeView' by assuming that all
rows have the same height.
Only enable this option if all rows are the same height and all
columns are of type 'GI.Gtk.Enums.TreeViewColumnSizingFixed'.

@since 2.6
-}
treeViewSetFixedHeightMode ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: a 'GI.Gtk.Objects.TreeView.TreeView' -}
    -> Bool
    {- ^ /@enable@/: 'True' to enable fixed height mode -}
    -> m ()
treeViewSetFixedHeightMode treeView enable = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    let enable' = (fromIntegral . fromEnum) enable
    gtk_tree_view_set_fixed_height_mode treeView' enable'
    touchManagedPtr treeView
    return ()

data TreeViewSetFixedHeightModeMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewSetFixedHeightModeMethodInfo a signature where
    overloadedMethod _ = treeViewSetFixedHeightMode

-- method TreeView::set_grid_lines
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTreeView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "grid_lines", argType = TInterface (Name {namespace = "Gtk", name = "TreeViewGridLines"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTreeViewGridLines value indicating which grid lines to\nenable.", 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_set_grid_lines" gtk_tree_view_set_grid_lines :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    CUInt ->                                -- grid_lines : TInterface (Name {namespace = "Gtk", name = "TreeViewGridLines"})
    IO ()

{- |
Sets which grid lines to draw in /@treeView@/.

@since 2.10
-}
treeViewSetGridLines ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: a 'GI.Gtk.Objects.TreeView.TreeView' -}
    -> Gtk.Enums.TreeViewGridLines
    {- ^ /@gridLines@/: a 'GI.Gtk.Enums.TreeViewGridLines' value indicating which grid lines to
enable. -}
    -> m ()
treeViewSetGridLines treeView gridLines = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    let gridLines' = (fromIntegral . fromEnum) gridLines
    gtk_tree_view_set_grid_lines treeView' gridLines'
    touchManagedPtr treeView
    return ()

data TreeViewSetGridLinesMethodInfo
instance (signature ~ (Gtk.Enums.TreeViewGridLines -> m ()), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewSetGridLinesMethodInfo a signature where
    overloadedMethod _ = treeViewSetGridLines

-- method TreeView::set_hadjustment
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "adjustment", argType = TInterface (Name {namespace = "Gtk", name = "Adjustment"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "The #GtkAdjustment to set, 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_set_hadjustment" gtk_tree_view_set_hadjustment :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    Ptr Gtk.Adjustment.Adjustment ->        -- adjustment : TInterface (Name {namespace = "Gtk", name = "Adjustment"})
    IO ()

{-# DEPRECATED treeViewSetHadjustment ["(Since version 3.0)","Use 'GI.Gtk.Interfaces.Scrollable.scrollableSetHadjustment'"] #-}
{- |
Sets the 'GI.Gtk.Objects.Adjustment.Adjustment' for the current horizontal aspect.
-}
treeViewSetHadjustment ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a, Gtk.Adjustment.IsAdjustment b) =>
    a
    {- ^ /@treeView@/: A 'GI.Gtk.Objects.TreeView.TreeView' -}
    -> Maybe (b)
    {- ^ /@adjustment@/: The 'GI.Gtk.Objects.Adjustment.Adjustment' to set, or 'Nothing' -}
    -> m ()
treeViewSetHadjustment treeView adjustment = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    maybeAdjustment <- case adjustment of
        Nothing -> return nullPtr
        Just jAdjustment -> do
            jAdjustment' <- unsafeManagedPtrCastPtr jAdjustment
            return jAdjustment'
    gtk_tree_view_set_hadjustment treeView' maybeAdjustment
    touchManagedPtr treeView
    whenJust adjustment touchManagedPtr
    return ()

data TreeViewSetHadjustmentMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsTreeView a, Gtk.Adjustment.IsAdjustment b) => O.MethodInfo TreeViewSetHadjustmentMethodInfo a signature where
    overloadedMethod _ = treeViewSetHadjustment

-- method TreeView::set_headers_clickable
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeView.", 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 if the columns are clickable.", 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_set_headers_clickable" gtk_tree_view_set_headers_clickable :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    CInt ->                                 -- setting : TBasicType TBoolean
    IO ()

{- |
Allow the column title buttons to be clicked.
-}
treeViewSetHeadersClickable ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: A 'GI.Gtk.Objects.TreeView.TreeView'. -}
    -> Bool
    {- ^ /@setting@/: 'True' if the columns are clickable. -}
    -> m ()
treeViewSetHeadersClickable treeView setting = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    let setting' = (fromIntegral . fromEnum) setting
    gtk_tree_view_set_headers_clickable treeView' setting'
    touchManagedPtr treeView
    return ()

data TreeViewSetHeadersClickableMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewSetHeadersClickableMethodInfo a signature where
    overloadedMethod _ = treeViewSetHeadersClickable

-- method TreeView::set_headers_visible
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeView.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "headers_visible", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE if the headers are 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_set_headers_visible" gtk_tree_view_set_headers_visible :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    CInt ->                                 -- headers_visible : TBasicType TBoolean
    IO ()

{- |
Sets the visibility state of the headers.
-}
treeViewSetHeadersVisible ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: A 'GI.Gtk.Objects.TreeView.TreeView'. -}
    -> Bool
    {- ^ /@headersVisible@/: 'True' if the headers are visible -}
    -> m ()
treeViewSetHeadersVisible treeView headersVisible = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    let headersVisible' = (fromIntegral . fromEnum) headersVisible
    gtk_tree_view_set_headers_visible treeView' headersVisible'
    touchManagedPtr treeView
    return ()

data TreeViewSetHeadersVisibleMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewSetHeadersVisibleMethodInfo a signature where
    overloadedMethod _ = treeViewSetHeadersVisible

-- method TreeView::set_hover_expand
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTreeView", 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 to enable hover selection mode", 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_set_hover_expand" gtk_tree_view_set_hover_expand :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    CInt ->                                 -- expand : TBasicType TBoolean
    IO ()

{- |
Enables or disables the hover expansion mode of /@treeView@/.
Hover expansion makes rows expand or collapse if the pointer
moves over them.

@since 2.6
-}
treeViewSetHoverExpand ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: a 'GI.Gtk.Objects.TreeView.TreeView' -}
    -> Bool
    {- ^ /@expand@/: 'True' to enable hover selection mode -}
    -> m ()
treeViewSetHoverExpand treeView expand = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    let expand' = (fromIntegral . fromEnum) expand
    gtk_tree_view_set_hover_expand treeView' expand'
    touchManagedPtr treeView
    return ()

data TreeViewSetHoverExpandMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewSetHoverExpandMethodInfo a signature where
    overloadedMethod _ = treeViewSetHoverExpand

-- method TreeView::set_hover_selection
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTreeView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "hover", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE to enable hover selection mode", 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_set_hover_selection" gtk_tree_view_set_hover_selection :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    CInt ->                                 -- hover : TBasicType TBoolean
    IO ()

{- |
Enables or disables the hover selection mode of /@treeView@/.
Hover selection makes the selected row follow the pointer.
Currently, this works only for the selection modes
'GI.Gtk.Enums.SelectionModeSingle' and 'GI.Gtk.Enums.SelectionModeBrowse'.

@since 2.6
-}
treeViewSetHoverSelection ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: a 'GI.Gtk.Objects.TreeView.TreeView' -}
    -> Bool
    {- ^ /@hover@/: 'True' to enable hover selection mode -}
    -> m ()
treeViewSetHoverSelection treeView hover = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    let hover' = (fromIntegral . fromEnum) hover
    gtk_tree_view_set_hover_selection treeView' hover'
    touchManagedPtr treeView
    return ()

data TreeViewSetHoverSelectionMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewSetHoverSelectionMethodInfo a signature where
    overloadedMethod _ = treeViewSetHoverSelection

-- method TreeView::set_level_indentation
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTreeView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "indentation", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the amount, in pixels, of extra indentation in @tree_view.", 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_set_level_indentation" gtk_tree_view_set_level_indentation :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    Int32 ->                                -- indentation : TBasicType TInt
    IO ()

{- |
Sets the amount of extra indentation for child levels to use in /@treeView@/
in addition to the default indentation.  The value should be specified in
pixels, a value of 0 disables this feature and in this case only the default
indentation will be used.
This does not have any visible effects for lists.

@since 2.12
-}
treeViewSetLevelIndentation ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: a 'GI.Gtk.Objects.TreeView.TreeView' -}
    -> Int32
    {- ^ /@indentation@/: the amount, in pixels, of extra indentation in /@treeView@/. -}
    -> m ()
treeViewSetLevelIndentation treeView indentation = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    gtk_tree_view_set_level_indentation treeView' indentation
    touchManagedPtr treeView
    return ()

data TreeViewSetLevelIndentationMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewSetLevelIndentationMethodInfo a signature where
    overloadedMethod _ = treeViewSetLevelIndentation

-- method TreeView::set_model
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeView.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "model", argType = TInterface (Name {namespace = "Gtk", name = "TreeModel"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "The model.", 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_set_model" gtk_tree_view_set_model :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    Ptr Gtk.TreeModel.TreeModel ->          -- model : TInterface (Name {namespace = "Gtk", name = "TreeModel"})
    IO ()

{- |
Sets the model for a 'GI.Gtk.Objects.TreeView.TreeView'.  If the /@treeView@/ already has a model
set, it will remove it before setting the new model.  If /@model@/ is 'Nothing',
then it will unset the old model.
-}
treeViewSetModel ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a, Gtk.TreeModel.IsTreeModel b) =>
    a
    {- ^ /@treeView@/: A 'GI.Gtk.Objects.TreeView.TreeView'. -}
    -> Maybe (b)
    {- ^ /@model@/: The model. -}
    -> m ()
treeViewSetModel treeView model = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    maybeModel <- case model of
        Nothing -> return nullPtr
        Just jModel -> do
            jModel' <- unsafeManagedPtrCastPtr jModel
            return jModel'
    gtk_tree_view_set_model treeView' maybeModel
    touchManagedPtr treeView
    whenJust model touchManagedPtr
    return ()

data TreeViewSetModelMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsTreeView a, Gtk.TreeModel.IsTreeModel b) => O.MethodInfo TreeViewSetModelMethodInfo a signature where
    overloadedMethod _ = treeViewSetModel

-- method TreeView::set_reorderable
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeView.", 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 tree 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_set_reorderable" gtk_tree_view_set_reorderable :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    CInt ->                                 -- reorderable : TBasicType TBoolean
    IO ()

{- |
This function is a convenience function to allow you to reorder
models that support the 'GI.Gtk.Structs.TreeDragSourceIface.TreeDragSourceIface' and the
'GI.Gtk.Structs.TreeDragDestIface.TreeDragDestIface'.  Both 'GI.Gtk.Objects.TreeStore.TreeStore' and 'GI.Gtk.Objects.ListStore.ListStore' support
these.  If /@reorderable@/ is 'True', then the user can reorder the
model by dragging and dropping rows. The developer can listen to
these changes by connecting to the model’s 'GI.Gtk.Interfaces.TreeModel.TreeModel'::@/row-inserted/@
and 'GI.Gtk.Interfaces.TreeModel.TreeModel'::@/row-deleted/@ signals. The reordering is implemented
by setting up the tree view as a drag source and destination.
Therefore, drag and drop can not be used in a reorderable view for any
other purpose.

This function does not give you any degree of control over the order -- any
reordering is allowed.  If more control is needed, you should probably
handle drag and drop manually.
-}
treeViewSetReorderable ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: A 'GI.Gtk.Objects.TreeView.TreeView'. -}
    -> Bool
    {- ^ /@reorderable@/: 'True', if the tree can be reordered. -}
    -> m ()
treeViewSetReorderable treeView reorderable = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    let reorderable' = (fromIntegral . fromEnum) reorderable
    gtk_tree_view_set_reorderable treeView' reorderable'
    touchManagedPtr treeView
    return ()

data TreeViewSetReorderableMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewSetReorderableMethodInfo a signature where
    overloadedMethod _ = treeViewSetReorderable

-- method TreeView::set_row_separator_func
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTreeView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "func", argType = TInterface (Name {namespace = "Gtk", name = "TreeViewRowSeparatorFunc"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GtkTreeViewRowSeparatorFunc", sinceVersion = Nothing}, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data to pass to @func, or %NULL", 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 = True, argDoc = Documentation {rawDocText = Just "destroy notifier for @data, or %NULL", 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_set_row_separator_func" gtk_tree_view_set_row_separator_func :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    FunPtr Gtk.Callbacks.C_TreeViewRowSeparatorFunc -> -- func : TInterface (Name {namespace = "Gtk", name = "TreeViewRowSeparatorFunc"})
    Ptr () ->                               -- data : TBasicType TPtr
    FunPtr GLib.Callbacks.C_DestroyNotify -> -- destroy : TInterface (Name {namespace = "GLib", name = "DestroyNotify"})
    IO ()

{- |
Sets the row separator function, which is used to determine
whether a row should be drawn as a separator. If the row separator
function is 'Nothing', no separators are drawn. This is the default value.

@since 2.6
-}
treeViewSetRowSeparatorFunc ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: a 'GI.Gtk.Objects.TreeView.TreeView' -}
    -> Maybe (Gtk.Callbacks.TreeViewRowSeparatorFunc)
    {- ^ /@func@/: a 'GI.Gtk.Callbacks.TreeViewRowSeparatorFunc' -}
    -> m ()
treeViewSetRowSeparatorFunc treeView func = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    maybeFunc <- case func of
        Nothing -> return (castPtrToFunPtr nullPtr)
        Just jFunc -> do
            jFunc' <- Gtk.Callbacks.mk_TreeViewRowSeparatorFunc (Gtk.Callbacks.wrap_TreeViewRowSeparatorFunc Nothing (Gtk.Callbacks.drop_closures_TreeViewRowSeparatorFunc jFunc))
            return jFunc'
    let data_ = castFunPtrToPtr maybeFunc
    let destroy = safeFreeFunPtrPtr
    gtk_tree_view_set_row_separator_func treeView' maybeFunc data_ destroy
    touchManagedPtr treeView
    return ()

data TreeViewSetRowSeparatorFuncMethodInfo
instance (signature ~ (Maybe (Gtk.Callbacks.TreeViewRowSeparatorFunc) -> m ()), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewSetRowSeparatorFuncMethodInfo a signature where
    overloadedMethod _ = treeViewSetRowSeparatorFunc

-- method TreeView::set_rubber_banding
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTreeView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enable", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE to enable rubber banding", 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_set_rubber_banding" gtk_tree_view_set_rubber_banding :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    CInt ->                                 -- enable : TBasicType TBoolean
    IO ()

{- |
Enables or disables rubber banding in /@treeView@/.  If the selection mode
is @/GTK_SELECTION_MULTIPLE/@, rubber banding will allow the user to select
multiple rows by dragging the mouse.

@since 2.10
-}
treeViewSetRubberBanding ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: a 'GI.Gtk.Objects.TreeView.TreeView' -}
    -> Bool
    {- ^ /@enable@/: 'True' to enable rubber banding -}
    -> m ()
treeViewSetRubberBanding treeView enable = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    let enable' = (fromIntegral . fromEnum) enable
    gtk_tree_view_set_rubber_banding treeView' enable'
    touchManagedPtr treeView
    return ()

data TreeViewSetRubberBandingMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewSetRubberBandingMethodInfo a signature where
    overloadedMethod _ = treeViewSetRubberBanding

-- method TreeView::set_rules_hint
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTreeView", 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 if the tree requires reading across rows", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

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

{-# DEPRECATED treeViewSetRulesHint ["(Since version 3.14)"] #-}
{- |
Sets a hint for the theme to draw even\/odd rows in the /@treeView@/
with different colors, also known as \"zebra striping\".

This function tells the GTK+ theme that the user interface for your
application requires users to read across tree rows and associate
cells with one another.

Do not use it just because you prefer the appearance of the ruled
tree; that’s a question for the theme. Some themes will draw tree
rows in alternating colors even when rules are turned off, and
users who prefer that appearance all the time can choose those
themes. You should call this function only as a semantic hint to
the theme engine that your tree makes alternating colors useful
from a functional standpoint (since it has lots of columns,
generally).
-}
treeViewSetRulesHint ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: a 'GI.Gtk.Objects.TreeView.TreeView' -}
    -> Bool
    {- ^ /@setting@/: 'True' if the tree requires reading across rows -}
    -> m ()
treeViewSetRulesHint treeView setting = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    let setting' = (fromIntegral . fromEnum) setting
    gtk_tree_view_set_rules_hint treeView' setting'
    touchManagedPtr treeView
    return ()

data TreeViewSetRulesHintMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewSetRulesHintMethodInfo a signature where
    overloadedMethod _ = treeViewSetRulesHint

-- method TreeView::set_search_column
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeView", 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 of the model to search in, or -1 to disable searching", 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_set_search_column" gtk_tree_view_set_search_column :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    Int32 ->                                -- column : TBasicType TInt
    IO ()

{- |
Sets /@column@/ as the column where the interactive search code should
search in for the current model.

If the search column is set, users can use the “start-interactive-search”
key binding to bring up search popup. The enable-search property controls
whether simply typing text will also start an interactive search.

Note that /@column@/ refers to a column of the current model. The search
column is reset to -1 when the model is changed.
-}
treeViewSetSearchColumn ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: A 'GI.Gtk.Objects.TreeView.TreeView' -}
    -> Int32
    {- ^ /@column@/: the column of the model to search in, or -1 to disable searching -}
    -> m ()
treeViewSetSearchColumn treeView column = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    gtk_tree_view_set_search_column treeView' column
    touchManagedPtr treeView
    return ()

data TreeViewSetSearchColumnMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewSetSearchColumnMethodInfo a signature where
    overloadedMethod _ = treeViewSetSearchColumn

-- method TreeView::set_search_entry
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "entry", argType = TInterface (Name {namespace = "Gtk", name = "Entry"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the entry the interactive search code of @tree_view should use 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_set_search_entry" gtk_tree_view_set_search_entry :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    Ptr Gtk.Entry.Entry ->                  -- entry : TInterface (Name {namespace = "Gtk", name = "Entry"})
    IO ()

{- |
Sets the entry which the interactive search code will use for this
/@treeView@/.  This is useful when you want to provide a search entry
in our interface at all time at a fixed position.  Passing 'Nothing' for
/@entry@/ will make the interactive search code use the built-in popup
entry again.

@since 2.10
-}
treeViewSetSearchEntry ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a, Gtk.Entry.IsEntry b) =>
    a
    {- ^ /@treeView@/: A 'GI.Gtk.Objects.TreeView.TreeView' -}
    -> Maybe (b)
    {- ^ /@entry@/: the entry the interactive search code of /@treeView@/ should use or 'Nothing' -}
    -> m ()
treeViewSetSearchEntry treeView entry = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    maybeEntry <- case entry of
        Nothing -> return nullPtr
        Just jEntry -> do
            jEntry' <- unsafeManagedPtrCastPtr jEntry
            return jEntry'
    gtk_tree_view_set_search_entry treeView' maybeEntry
    touchManagedPtr treeView
    whenJust entry touchManagedPtr
    return ()

data TreeViewSetSearchEntryMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsTreeView a, Gtk.Entry.IsEntry b) => O.MethodInfo TreeViewSetSearchEntryMethodInfo a signature where
    overloadedMethod _ = treeViewSetSearchEntry

-- method TreeView::set_search_equal_func
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "search_equal_func", argType = TInterface (Name {namespace = "Gtk", name = "TreeViewSearchEqualFunc"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the compare function to use during the search", sinceVersion = Nothing}, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "search_user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data to pass to @search_equal_func, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "search_destroy", argType = TInterface (Name {namespace = "GLib", name = "DestroyNotify"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Destroy notifier for @search_user_data, or %NULL", 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_set_search_equal_func" gtk_tree_view_set_search_equal_func :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    FunPtr Gtk.Callbacks.C_TreeViewSearchEqualFunc -> -- search_equal_func : TInterface (Name {namespace = "Gtk", name = "TreeViewSearchEqualFunc"})
    Ptr () ->                               -- search_user_data : TBasicType TPtr
    FunPtr GLib.Callbacks.C_DestroyNotify -> -- search_destroy : TInterface (Name {namespace = "GLib", name = "DestroyNotify"})
    IO ()

{- |
Sets the compare function for the interactive search capabilities; note
that somewhat like @/strcmp()/@ returning 0 for equality
'GI.Gtk.Callbacks.TreeViewSearchEqualFunc' returns 'False' on matches.
-}
treeViewSetSearchEqualFunc ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: A 'GI.Gtk.Objects.TreeView.TreeView' -}
    -> Gtk.Callbacks.TreeViewSearchEqualFunc
    {- ^ /@searchEqualFunc@/: the compare function to use during the search -}
    -> m ()
treeViewSetSearchEqualFunc treeView searchEqualFunc = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    searchEqualFunc' <- Gtk.Callbacks.mk_TreeViewSearchEqualFunc (Gtk.Callbacks.wrap_TreeViewSearchEqualFunc Nothing (Gtk.Callbacks.drop_closures_TreeViewSearchEqualFunc searchEqualFunc))
    let searchUserData = castFunPtrToPtr searchEqualFunc'
    let searchDestroy = safeFreeFunPtrPtr
    gtk_tree_view_set_search_equal_func treeView' searchEqualFunc' searchUserData searchDestroy
    touchManagedPtr treeView
    return ()

data TreeViewSetSearchEqualFuncMethodInfo
instance (signature ~ (Gtk.Callbacks.TreeViewSearchEqualFunc -> m ()), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewSetSearchEqualFuncMethodInfo a signature where
    overloadedMethod _ = treeViewSetSearchEqualFunc

-- method TreeView::set_search_position_func
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "func", argType = TInterface (Name {namespace = "Gtk", name = "TreeViewSearchPositionFunc"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the function to use to position the search dialog, or %NULL\n   to use the default search position function", sinceVersion = Nothing}, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data to pass to @func, or %NULL", 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 = True, argDoc = Documentation {rawDocText = Just "Destroy notifier for @data, or %NULL", 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_set_search_position_func" gtk_tree_view_set_search_position_func :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    FunPtr Gtk.Callbacks.C_TreeViewSearchPositionFunc -> -- func : TInterface (Name {namespace = "Gtk", name = "TreeViewSearchPositionFunc"})
    Ptr () ->                               -- data : TBasicType TPtr
    FunPtr GLib.Callbacks.C_DestroyNotify -> -- destroy : TInterface (Name {namespace = "GLib", name = "DestroyNotify"})
    IO ()

{- |
Sets the function to use when positioning the search dialog.

@since 2.10
-}
treeViewSetSearchPositionFunc ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: A 'GI.Gtk.Objects.TreeView.TreeView' -}
    -> Maybe (Gtk.Callbacks.TreeViewSearchPositionFunc)
    {- ^ /@func@/: the function to use to position the search dialog, or 'Nothing'
   to use the default search position function -}
    -> m ()
treeViewSetSearchPositionFunc treeView func = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    maybeFunc <- case func of
        Nothing -> return (castPtrToFunPtr nullPtr)
        Just jFunc -> do
            jFunc' <- Gtk.Callbacks.mk_TreeViewSearchPositionFunc (Gtk.Callbacks.wrap_TreeViewSearchPositionFunc Nothing (Gtk.Callbacks.drop_closures_TreeViewSearchPositionFunc jFunc))
            return jFunc'
    let data_ = castFunPtrToPtr maybeFunc
    let destroy = safeFreeFunPtrPtr
    gtk_tree_view_set_search_position_func treeView' maybeFunc data_ destroy
    touchManagedPtr treeView
    return ()

data TreeViewSetSearchPositionFuncMethodInfo
instance (signature ~ (Maybe (Gtk.Callbacks.TreeViewSearchPositionFunc) -> m ()), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewSetSearchPositionFuncMethodInfo a signature where
    overloadedMethod _ = treeViewSetSearchPositionFunc

-- method TreeView::set_show_expanders
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTreeView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE to enable expander drawing, %FALSE otherwise.", 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_set_show_expanders" gtk_tree_view_set_show_expanders :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    CInt ->                                 -- enabled : TBasicType TBoolean
    IO ()

{- |
Sets whether to draw and enable expanders and indent child rows in
/@treeView@/.  When disabled there will be no expanders visible in trees
and there will be no way to expand and collapse rows by default.  Also
note that hiding the expanders will disable the default indentation.  You
can set a custom indentation in this case using
'GI.Gtk.Objects.TreeView.treeViewSetLevelIndentation'.
This does not have any visible effects for lists.

@since 2.12
-}
treeViewSetShowExpanders ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: a 'GI.Gtk.Objects.TreeView.TreeView' -}
    -> Bool
    {- ^ /@enabled@/: 'True' to enable expander drawing, 'False' otherwise. -}
    -> m ()
treeViewSetShowExpanders treeView enabled = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    let enabled' = (fromIntegral . fromEnum) enabled
    gtk_tree_view_set_show_expanders treeView' enabled'
    touchManagedPtr treeView
    return ()

data TreeViewSetShowExpandersMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewSetShowExpandersMethodInfo a signature where
    overloadedMethod _ = treeViewSetShowExpanders

-- method TreeView::set_tooltip_cell
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTreeView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tooltip", argType = TInterface (Name {namespace = "Gtk", name = "Tooltip"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTooltip", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TInterface (Name {namespace = "Gtk", name = "TreePath"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GtkTreePath or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "column", argType = TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GtkTreeViewColumn or %NULL", 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 = True, argDoc = Documentation {rawDocText = Just "a #GtkCellRenderer 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_set_tooltip_cell" gtk_tree_view_set_tooltip_cell :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    Ptr Gtk.Tooltip.Tooltip ->              -- tooltip : TInterface (Name {namespace = "Gtk", name = "Tooltip"})
    Ptr Gtk.TreePath.TreePath ->            -- path : TInterface (Name {namespace = "Gtk", name = "TreePath"})
    Ptr Gtk.TreeViewColumn.TreeViewColumn -> -- column : TInterface (Name {namespace = "Gtk", name = "TreeViewColumn"})
    Ptr Gtk.CellRenderer.CellRenderer ->    -- cell : TInterface (Name {namespace = "Gtk", name = "CellRenderer"})
    IO ()

{- |
Sets the tip area of /@tooltip@/ to the area /@path@/, /@column@/ and /@cell@/ have
in common.  For example if /@path@/ is 'Nothing' and /@column@/ is set, the tip
area will be set to the full area covered by /@column@/.  See also
'GI.Gtk.Objects.Tooltip.tooltipSetTipArea'.

Note that if /@path@/ is not specified and /@cell@/ is set and part of a column
containing the expander, the tooltip might not show and hide at the correct
position.  In such cases /@path@/ must be set to the current node under the
mouse cursor for this function to operate correctly.

See also 'GI.Gtk.Objects.TreeView.treeViewSetTooltipColumn' for a simpler alternative.

@since 2.12
-}
treeViewSetTooltipCell ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a, Gtk.Tooltip.IsTooltip b, Gtk.TreeViewColumn.IsTreeViewColumn c, Gtk.CellRenderer.IsCellRenderer d) =>
    a
    {- ^ /@treeView@/: a 'GI.Gtk.Objects.TreeView.TreeView' -}
    -> b
    {- ^ /@tooltip@/: a 'GI.Gtk.Objects.Tooltip.Tooltip' -}
    -> Maybe (Gtk.TreePath.TreePath)
    {- ^ /@path@/: a 'GI.Gtk.Structs.TreePath.TreePath' or 'Nothing' -}
    -> Maybe (c)
    {- ^ /@column@/: a 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn' or 'Nothing' -}
    -> Maybe (d)
    {- ^ /@cell@/: a 'GI.Gtk.Objects.CellRenderer.CellRenderer' or 'Nothing' -}
    -> m ()
treeViewSetTooltipCell treeView tooltip path column cell = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    tooltip' <- unsafeManagedPtrCastPtr tooltip
    maybePath <- case path of
        Nothing -> return nullPtr
        Just jPath -> do
            jPath' <- unsafeManagedPtrGetPtr jPath
            return jPath'
    maybeColumn <- case column of
        Nothing -> return nullPtr
        Just jColumn -> do
            jColumn' <- unsafeManagedPtrCastPtr jColumn
            return jColumn'
    maybeCell <- case cell of
        Nothing -> return nullPtr
        Just jCell -> do
            jCell' <- unsafeManagedPtrCastPtr jCell
            return jCell'
    gtk_tree_view_set_tooltip_cell treeView' tooltip' maybePath maybeColumn maybeCell
    touchManagedPtr treeView
    touchManagedPtr tooltip
    whenJust path touchManagedPtr
    whenJust column touchManagedPtr
    whenJust cell touchManagedPtr
    return ()

data TreeViewSetTooltipCellMethodInfo
instance (signature ~ (b -> Maybe (Gtk.TreePath.TreePath) -> Maybe (c) -> Maybe (d) -> m ()), MonadIO m, IsTreeView a, Gtk.Tooltip.IsTooltip b, Gtk.TreeViewColumn.IsTreeViewColumn c, Gtk.CellRenderer.IsCellRenderer d) => O.MethodInfo TreeViewSetTooltipCellMethodInfo a signature where
    overloadedMethod _ = treeViewSetTooltipCell

-- method TreeView::set_tooltip_column
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTreeView", 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 "an integer, which is a valid column number for @tree_view\8217s model", 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_set_tooltip_column" gtk_tree_view_set_tooltip_column :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    Int32 ->                                -- column : TBasicType TInt
    IO ()

{- |
If you only plan to have simple (text-only) tooltips on full rows, you
can use this function to have 'GI.Gtk.Objects.TreeView.TreeView' handle these automatically
for you. /@column@/ should be set to the column in /@treeView@/’s model
containing the tooltip texts, or -1 to disable this feature.

When enabled, 'GI.Gtk.Objects.Widget.Widget':@/has-tooltip/@ will be set to 'True' and
/@treeView@/ will connect a 'GI.Gtk.Objects.Widget.Widget'::@/query-tooltip/@ signal handler.

Note that the signal handler sets the text with 'GI.Gtk.Objects.Tooltip.tooltipSetMarkup',
so &, \<, etc have to be escaped in the text.

@since 2.12
-}
treeViewSetTooltipColumn ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: a 'GI.Gtk.Objects.TreeView.TreeView' -}
    -> Int32
    {- ^ /@column@/: an integer, which is a valid column number for /@treeView@/’s model -}
    -> m ()
treeViewSetTooltipColumn treeView column = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    gtk_tree_view_set_tooltip_column treeView' column
    touchManagedPtr treeView
    return ()

data TreeViewSetTooltipColumnMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewSetTooltipColumnMethodInfo a signature where
    overloadedMethod _ = treeViewSetTooltipColumn

-- method TreeView::set_tooltip_row
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTreeView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tooltip", argType = TInterface (Name {namespace = "Gtk", name = "Tooltip"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTooltip", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TInterface (Name {namespace = "Gtk", name = "TreePath"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTreePath", 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_set_tooltip_row" gtk_tree_view_set_tooltip_row :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    Ptr Gtk.Tooltip.Tooltip ->              -- tooltip : TInterface (Name {namespace = "Gtk", name = "Tooltip"})
    Ptr Gtk.TreePath.TreePath ->            -- path : TInterface (Name {namespace = "Gtk", name = "TreePath"})
    IO ()

{- |
Sets the tip area of /@tooltip@/ to be the area covered by the row at /@path@/.
See also 'GI.Gtk.Objects.TreeView.treeViewSetTooltipColumn' for a simpler alternative.
See also 'GI.Gtk.Objects.Tooltip.tooltipSetTipArea'.

@since 2.12
-}
treeViewSetTooltipRow ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a, Gtk.Tooltip.IsTooltip b) =>
    a
    {- ^ /@treeView@/: a 'GI.Gtk.Objects.TreeView.TreeView' -}
    -> b
    {- ^ /@tooltip@/: a 'GI.Gtk.Objects.Tooltip.Tooltip' -}
    -> Gtk.TreePath.TreePath
    {- ^ /@path@/: a 'GI.Gtk.Structs.TreePath.TreePath' -}
    -> m ()
treeViewSetTooltipRow treeView tooltip path = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    tooltip' <- unsafeManagedPtrCastPtr tooltip
    path' <- unsafeManagedPtrGetPtr path
    gtk_tree_view_set_tooltip_row treeView' tooltip' path'
    touchManagedPtr treeView
    touchManagedPtr tooltip
    touchManagedPtr path
    return ()

data TreeViewSetTooltipRowMethodInfo
instance (signature ~ (b -> Gtk.TreePath.TreePath -> m ()), MonadIO m, IsTreeView a, Gtk.Tooltip.IsTooltip b) => O.MethodInfo TreeViewSetTooltipRowMethodInfo a signature where
    overloadedMethod _ = treeViewSetTooltipRow

-- method TreeView::set_vadjustment
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "adjustment", argType = TInterface (Name {namespace = "Gtk", name = "Adjustment"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "The #GtkAdjustment to set, 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_set_vadjustment" gtk_tree_view_set_vadjustment :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    Ptr Gtk.Adjustment.Adjustment ->        -- adjustment : TInterface (Name {namespace = "Gtk", name = "Adjustment"})
    IO ()

{-# DEPRECATED treeViewSetVadjustment ["(Since version 3.0)","Use 'GI.Gtk.Interfaces.Scrollable.scrollableSetVadjustment'"] #-}
{- |
Sets the 'GI.Gtk.Objects.Adjustment.Adjustment' for the current vertical aspect.
-}
treeViewSetVadjustment ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a, Gtk.Adjustment.IsAdjustment b) =>
    a
    {- ^ /@treeView@/: A 'GI.Gtk.Objects.TreeView.TreeView' -}
    -> Maybe (b)
    {- ^ /@adjustment@/: The 'GI.Gtk.Objects.Adjustment.Adjustment' to set, or 'Nothing' -}
    -> m ()
treeViewSetVadjustment treeView adjustment = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    maybeAdjustment <- case adjustment of
        Nothing -> return nullPtr
        Just jAdjustment -> do
            jAdjustment' <- unsafeManagedPtrCastPtr jAdjustment
            return jAdjustment'
    gtk_tree_view_set_vadjustment treeView' maybeAdjustment
    touchManagedPtr treeView
    whenJust adjustment touchManagedPtr
    return ()

data TreeViewSetVadjustmentMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsTreeView a, Gtk.Adjustment.IsAdjustment b) => O.MethodInfo TreeViewSetVadjustmentMethodInfo a signature where
    overloadedMethod _ = treeViewSetVadjustment

-- method TreeView::unset_rows_drag_dest
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTreeView", 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_unset_rows_drag_dest" gtk_tree_view_unset_rows_drag_dest :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    IO ()

{- |
Undoes the effect of
'GI.Gtk.Objects.TreeView.treeViewEnableModelDragDest'. Calling this method sets
'GI.Gtk.Objects.TreeView.TreeView':@/reorderable/@ to 'False'.
-}
treeViewUnsetRowsDragDest ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: a 'GI.Gtk.Objects.TreeView.TreeView' -}
    -> m ()
treeViewUnsetRowsDragDest treeView = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    gtk_tree_view_unset_rows_drag_dest treeView'
    touchManagedPtr treeView
    return ()

data TreeViewUnsetRowsDragDestMethodInfo
instance (signature ~ (m ()), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewUnsetRowsDragDestMethodInfo a signature where
    overloadedMethod _ = treeViewUnsetRowsDragDest

-- method TreeView::unset_rows_drag_source
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree_view", argType = TInterface (Name {namespace = "Gtk", name = "TreeView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTreeView", 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_unset_rows_drag_source" gtk_tree_view_unset_rows_drag_source :: 
    Ptr TreeView ->                         -- tree_view : TInterface (Name {namespace = "Gtk", name = "TreeView"})
    IO ()

{- |
Undoes the effect of
'GI.Gtk.Objects.TreeView.treeViewEnableModelDragSource'. Calling this method sets
'GI.Gtk.Objects.TreeView.TreeView':@/reorderable/@ to 'False'.
-}
treeViewUnsetRowsDragSource ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeView a) =>
    a
    {- ^ /@treeView@/: a 'GI.Gtk.Objects.TreeView.TreeView' -}
    -> m ()
treeViewUnsetRowsDragSource treeView = liftIO $ do
    treeView' <- unsafeManagedPtrCastPtr treeView
    gtk_tree_view_unset_rows_drag_source treeView'
    touchManagedPtr treeView
    return ()

data TreeViewUnsetRowsDragSourceMethodInfo
instance (signature ~ (m ()), MonadIO m, IsTreeView a) => O.MethodInfo TreeViewUnsetRowsDragSourceMethodInfo a signature where
    overloadedMethod _ = treeViewUnsetRowsDragSource