{-# LANGUAGE ImplicitParams, RankNTypes, TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- @GtkColumnView@ presents a large dynamic list of items using multiple columns
-- with headers.
-- 
-- @GtkColumnView@ uses the factories of its columns to generate a cell widget for
-- each column, for each visible item and displays them together as the row for
-- this item.
-- 
-- The [ColumnView:showRowSeparators]("GI.Gtk.Objects.ColumnView#g:attr:showRowSeparators") and
-- [ColumnView:showColumnSeparators]("GI.Gtk.Objects.ColumnView#g:attr:showColumnSeparators") properties offer a simple way
-- to display separators between the rows or columns.
-- 
-- @GtkColumnView@ allows the user to select items according to the selection
-- characteristics of the model. For models that allow multiple selected items,
-- it is possible to turn on *rubberband selection*, using
-- [ColumnView:enableRubberband]("GI.Gtk.Objects.ColumnView#g:attr:enableRubberband").
-- 
-- The column view supports sorting that can be customized by the user by
-- clicking on column headers. To set this up, the @GtkSorter@ returned by
-- 'GI.Gtk.Objects.ColumnView.columnViewGetSorter' must be attached to a sort model for the
-- data that the view is showing, and the columns must have sorters attached to
-- them by calling 'GI.Gtk.Objects.ColumnViewColumn.columnViewColumnSetSorter'. The initial sort
-- order can be set with 'GI.Gtk.Objects.ColumnView.columnViewSortByColumn'.
-- 
-- The column view also supports interactive resizing and reordering of
-- columns, via Drag-and-Drop of the column headers. This can be enabled or
-- disabled with the [ColumnView:reorderable]("GI.Gtk.Objects.ColumnView#g:attr:reorderable") and
-- [ColumnViewColumn:resizable]("GI.Gtk.Objects.ColumnViewColumn#g:attr:resizable") properties.
-- 
-- To learn more about the list widget framework, see the
-- <https://docs.gtk.org/gtk4/section-list-widget.html overview>.
-- 
-- = CSS nodes
-- 
-- >columnview[.column-separators][.rich-list][.navigation-sidebar][.data-table]
-- >├── header
-- >│   ├── <column header>
-- >┊   ┊
-- >│   ╰── <column header>
-- >│
-- >├── listview
-- >│
-- >┊
-- >╰── [rubberband]
-- 
-- 
-- @GtkColumnView@ uses a single CSS node named columnview. It may carry the
-- .column-separators style class, when [ColumnView:showColumnSeparators]("GI.Gtk.Objects.ColumnView#g:attr:showColumnSeparators")
-- property is set. Header widgets appear below a node with name header.
-- The rows are contained in a @GtkListView@ widget, so there is a listview
-- node with the same structure as for a standalone @GtkListView@ widget.
-- If [ColumnView:showRowSeparators]("GI.Gtk.Objects.ColumnView#g:attr:showRowSeparators") is set, it will be passed
-- on to the list view, causing its CSS node to carry the .separators style class.
-- For rubberband selection, a node with name rubberband is used.
-- 
-- The main columnview node may also carry style classes to select
-- the style of <https://docs.gtk.org/gtk4/section-list-widget.html#list-styles list presentation>:
-- .rich-list, .navigation-sidebar or .data-table.
-- 
-- = Accessibility
-- 
-- @GtkColumnView@ uses the 'GI.Gtk.Enums.AccessibleRoleTreeGrid' role, header title
-- widgets are using the 'GI.Gtk.Enums.AccessibleRoleColumnHeader' role. The row widgets
-- are using the 'GI.Gtk.Enums.AccessibleRoleRow' role, and individual cells are using
-- the 'GI.Gtk.Enums.AccessibleRoleGridCell' role

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

module GI.Gtk.Objects.ColumnView
    ( 

-- * Exported types
    ColumnView(..)                          ,
    IsColumnView                            ,
    toColumnView                            ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [actionSetEnabled]("GI.Gtk.Objects.Widget#g:method:actionSetEnabled"), [activate]("GI.Gtk.Objects.Widget#g:method:activate"), [activateAction]("GI.Gtk.Objects.Widget#g:method:activateAction"), [activateDefault]("GI.Gtk.Objects.Widget#g:method:activateDefault"), [addController]("GI.Gtk.Objects.Widget#g:method:addController"), [addCssClass]("GI.Gtk.Objects.Widget#g:method:addCssClass"), [addMnemonicLabel]("GI.Gtk.Objects.Widget#g:method:addMnemonicLabel"), [addTickCallback]("GI.Gtk.Objects.Widget#g:method:addTickCallback"), [allocate]("GI.Gtk.Objects.Widget#g:method:allocate"), [appendColumn]("GI.Gtk.Objects.ColumnView#g:method:appendColumn"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [childFocus]("GI.Gtk.Objects.Widget#g:method:childFocus"), [computeBounds]("GI.Gtk.Objects.Widget#g:method:computeBounds"), [computeExpand]("GI.Gtk.Objects.Widget#g:method:computeExpand"), [computePoint]("GI.Gtk.Objects.Widget#g:method:computePoint"), [computeTransform]("GI.Gtk.Objects.Widget#g:method:computeTransform"), [contains]("GI.Gtk.Objects.Widget#g:method:contains"), [createPangoContext]("GI.Gtk.Objects.Widget#g:method:createPangoContext"), [createPangoLayout]("GI.Gtk.Objects.Widget#g:method:createPangoLayout"), [disposeTemplate]("GI.Gtk.Objects.Widget#g:method:disposeTemplate"), [dragCheckThreshold]("GI.Gtk.Objects.Widget#g:method:dragCheckThreshold"), [errorBell]("GI.Gtk.Objects.Widget#g:method:errorBell"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [grabFocus]("GI.Gtk.Objects.Widget#g:method:grabFocus"), [hasCssClass]("GI.Gtk.Objects.Widget#g:method:hasCssClass"), [hasDefault]("GI.Gtk.Objects.Widget#g:method:hasDefault"), [hasFocus]("GI.Gtk.Objects.Widget#g:method:hasFocus"), [hasVisibleFocus]("GI.Gtk.Objects.Widget#g:method:hasVisibleFocus"), [hide]("GI.Gtk.Objects.Widget#g:method:hide"), [inDestruction]("GI.Gtk.Objects.Widget#g:method:inDestruction"), [initTemplate]("GI.Gtk.Objects.Widget#g:method:initTemplate"), [insertActionGroup]("GI.Gtk.Objects.Widget#g:method:insertActionGroup"), [insertAfter]("GI.Gtk.Objects.Widget#g:method:insertAfter"), [insertBefore]("GI.Gtk.Objects.Widget#g:method:insertBefore"), [insertColumn]("GI.Gtk.Objects.ColumnView#g:method:insertColumn"), [isAncestor]("GI.Gtk.Objects.Widget#g:method:isAncestor"), [isDrawable]("GI.Gtk.Objects.Widget#g:method:isDrawable"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [isFocus]("GI.Gtk.Objects.Widget#g:method:isFocus"), [isSensitive]("GI.Gtk.Objects.Widget#g:method:isSensitive"), [isVisible]("GI.Gtk.Objects.Widget#g:method:isVisible"), [keynavFailed]("GI.Gtk.Objects.Widget#g:method:keynavFailed"), [listMnemonicLabels]("GI.Gtk.Objects.Widget#g:method:listMnemonicLabels"), [map]("GI.Gtk.Objects.Widget#g:method:map"), [measure]("GI.Gtk.Objects.Widget#g:method:measure"), [mnemonicActivate]("GI.Gtk.Objects.Widget#g:method:mnemonicActivate"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [observeChildren]("GI.Gtk.Objects.Widget#g:method:observeChildren"), [observeControllers]("GI.Gtk.Objects.Widget#g:method:observeControllers"), [pick]("GI.Gtk.Objects.Widget#g:method:pick"), [queueAllocate]("GI.Gtk.Objects.Widget#g:method:queueAllocate"), [queueDraw]("GI.Gtk.Objects.Widget#g:method:queueDraw"), [queueResize]("GI.Gtk.Objects.Widget#g:method:queueResize"), [realize]("GI.Gtk.Objects.Widget#g:method:realize"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [removeColumn]("GI.Gtk.Objects.ColumnView#g:method:removeColumn"), [removeController]("GI.Gtk.Objects.Widget#g:method:removeController"), [removeCssClass]("GI.Gtk.Objects.Widget#g:method:removeCssClass"), [removeMnemonicLabel]("GI.Gtk.Objects.Widget#g:method:removeMnemonicLabel"), [removeTickCallback]("GI.Gtk.Objects.Widget#g:method:removeTickCallback"), [resetProperty]("GI.Gtk.Interfaces.Accessible#g:method:resetProperty"), [resetRelation]("GI.Gtk.Interfaces.Accessible#g:method:resetRelation"), [resetState]("GI.Gtk.Interfaces.Accessible#g:method:resetState"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [shouldLayout]("GI.Gtk.Objects.Widget#g:method:shouldLayout"), [show]("GI.Gtk.Objects.Widget#g:method:show"), [sizeAllocate]("GI.Gtk.Objects.Widget#g:method:sizeAllocate"), [snapshotChild]("GI.Gtk.Objects.Widget#g:method:snapshotChild"), [sortByColumn]("GI.Gtk.Objects.ColumnView#g:method:sortByColumn"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [translateCoordinates]("GI.Gtk.Objects.Widget#g:method:translateCoordinates"), [triggerTooltipQuery]("GI.Gtk.Objects.Widget#g:method:triggerTooltipQuery"), [unmap]("GI.Gtk.Objects.Widget#g:method:unmap"), [unparent]("GI.Gtk.Objects.Widget#g:method:unparent"), [unrealize]("GI.Gtk.Objects.Widget#g:method:unrealize"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [unsetStateFlags]("GI.Gtk.Objects.Widget#g:method:unsetStateFlags"), [updateProperty]("GI.Gtk.Interfaces.Accessible#g:method:updateProperty"), [updateRelation]("GI.Gtk.Interfaces.Accessible#g:method:updateRelation"), [updateState]("GI.Gtk.Interfaces.Accessible#g:method:updateState"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getAccessibleRole]("GI.Gtk.Interfaces.Accessible#g:method:getAccessibleRole"), [getAllocatedBaseline]("GI.Gtk.Objects.Widget#g:method:getAllocatedBaseline"), [getAllocatedHeight]("GI.Gtk.Objects.Widget#g:method:getAllocatedHeight"), [getAllocatedWidth]("GI.Gtk.Objects.Widget#g:method:getAllocatedWidth"), [getAllocation]("GI.Gtk.Objects.Widget#g:method:getAllocation"), [getAncestor]("GI.Gtk.Objects.Widget#g:method:getAncestor"), [getBorder]("GI.Gtk.Interfaces.Scrollable#g:method:getBorder"), [getBuildableId]("GI.Gtk.Interfaces.Buildable#g:method:getBuildableId"), [getCanFocus]("GI.Gtk.Objects.Widget#g:method:getCanFocus"), [getCanTarget]("GI.Gtk.Objects.Widget#g:method:getCanTarget"), [getChildVisible]("GI.Gtk.Objects.Widget#g:method:getChildVisible"), [getClipboard]("GI.Gtk.Objects.Widget#g:method:getClipboard"), [getColumns]("GI.Gtk.Objects.ColumnView#g:method:getColumns"), [getCssClasses]("GI.Gtk.Objects.Widget#g:method:getCssClasses"), [getCssName]("GI.Gtk.Objects.Widget#g:method:getCssName"), [getCursor]("GI.Gtk.Objects.Widget#g:method:getCursor"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getDirection]("GI.Gtk.Objects.Widget#g:method:getDirection"), [getDisplay]("GI.Gtk.Objects.Widget#g:method:getDisplay"), [getEnableRubberband]("GI.Gtk.Objects.ColumnView#g:method:getEnableRubberband"), [getFirstChild]("GI.Gtk.Objects.Widget#g:method:getFirstChild"), [getFocusChild]("GI.Gtk.Objects.Widget#g:method:getFocusChild"), [getFocusOnClick]("GI.Gtk.Objects.Widget#g:method:getFocusOnClick"), [getFocusable]("GI.Gtk.Objects.Widget#g:method:getFocusable"), [getFontMap]("GI.Gtk.Objects.Widget#g:method:getFontMap"), [getFontOptions]("GI.Gtk.Objects.Widget#g:method:getFontOptions"), [getFrameClock]("GI.Gtk.Objects.Widget#g:method:getFrameClock"), [getHadjustment]("GI.Gtk.Interfaces.Scrollable#g:method:getHadjustment"), [getHalign]("GI.Gtk.Objects.Widget#g:method:getHalign"), [getHasTooltip]("GI.Gtk.Objects.Widget#g:method:getHasTooltip"), [getHeight]("GI.Gtk.Objects.Widget#g:method:getHeight"), [getHexpand]("GI.Gtk.Objects.Widget#g:method:getHexpand"), [getHexpandSet]("GI.Gtk.Objects.Widget#g:method:getHexpandSet"), [getHscrollPolicy]("GI.Gtk.Interfaces.Scrollable#g:method:getHscrollPolicy"), [getLastChild]("GI.Gtk.Objects.Widget#g:method:getLastChild"), [getLayoutManager]("GI.Gtk.Objects.Widget#g:method:getLayoutManager"), [getMapped]("GI.Gtk.Objects.Widget#g:method:getMapped"), [getMarginBottom]("GI.Gtk.Objects.Widget#g:method:getMarginBottom"), [getMarginEnd]("GI.Gtk.Objects.Widget#g:method:getMarginEnd"), [getMarginStart]("GI.Gtk.Objects.Widget#g:method:getMarginStart"), [getMarginTop]("GI.Gtk.Objects.Widget#g:method:getMarginTop"), [getModel]("GI.Gtk.Objects.ColumnView#g:method:getModel"), [getName]("GI.Gtk.Objects.Widget#g:method:getName"), [getNative]("GI.Gtk.Objects.Widget#g:method:getNative"), [getNextSibling]("GI.Gtk.Objects.Widget#g:method:getNextSibling"), [getOpacity]("GI.Gtk.Objects.Widget#g:method:getOpacity"), [getOverflow]("GI.Gtk.Objects.Widget#g:method:getOverflow"), [getPangoContext]("GI.Gtk.Objects.Widget#g:method:getPangoContext"), [getParent]("GI.Gtk.Objects.Widget#g:method:getParent"), [getPreferredSize]("GI.Gtk.Objects.Widget#g:method:getPreferredSize"), [getPrevSibling]("GI.Gtk.Objects.Widget#g:method:getPrevSibling"), [getPrimaryClipboard]("GI.Gtk.Objects.Widget#g:method:getPrimaryClipboard"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getRealized]("GI.Gtk.Objects.Widget#g:method:getRealized"), [getReceivesDefault]("GI.Gtk.Objects.Widget#g:method:getReceivesDefault"), [getReorderable]("GI.Gtk.Objects.ColumnView#g:method:getReorderable"), [getRequestMode]("GI.Gtk.Objects.Widget#g:method:getRequestMode"), [getRoot]("GI.Gtk.Objects.Widget#g:method:getRoot"), [getScaleFactor]("GI.Gtk.Objects.Widget#g:method:getScaleFactor"), [getSensitive]("GI.Gtk.Objects.Widget#g:method:getSensitive"), [getSettings]("GI.Gtk.Objects.Widget#g:method:getSettings"), [getShowColumnSeparators]("GI.Gtk.Objects.ColumnView#g:method:getShowColumnSeparators"), [getShowRowSeparators]("GI.Gtk.Objects.ColumnView#g:method:getShowRowSeparators"), [getSingleClickActivate]("GI.Gtk.Objects.ColumnView#g:method:getSingleClickActivate"), [getSize]("GI.Gtk.Objects.Widget#g:method:getSize"), [getSizeRequest]("GI.Gtk.Objects.Widget#g:method:getSizeRequest"), [getSorter]("GI.Gtk.Objects.ColumnView#g:method:getSorter"), [getStateFlags]("GI.Gtk.Objects.Widget#g:method:getStateFlags"), [getStyleContext]("GI.Gtk.Objects.Widget#g:method:getStyleContext"), [getTemplateChild]("GI.Gtk.Objects.Widget#g:method:getTemplateChild"), [getTooltipMarkup]("GI.Gtk.Objects.Widget#g:method:getTooltipMarkup"), [getTooltipText]("GI.Gtk.Objects.Widget#g:method:getTooltipText"), [getVadjustment]("GI.Gtk.Interfaces.Scrollable#g:method:getVadjustment"), [getValign]("GI.Gtk.Objects.Widget#g:method:getValign"), [getVexpand]("GI.Gtk.Objects.Widget#g:method:getVexpand"), [getVexpandSet]("GI.Gtk.Objects.Widget#g:method:getVexpandSet"), [getVisible]("GI.Gtk.Objects.Widget#g:method:getVisible"), [getVscrollPolicy]("GI.Gtk.Interfaces.Scrollable#g:method:getVscrollPolicy"), [getWidth]("GI.Gtk.Objects.Widget#g:method:getWidth").
-- 
-- ==== Setters
-- [setCanFocus]("GI.Gtk.Objects.Widget#g:method:setCanFocus"), [setCanTarget]("GI.Gtk.Objects.Widget#g:method:setCanTarget"), [setChildVisible]("GI.Gtk.Objects.Widget#g:method:setChildVisible"), [setCssClasses]("GI.Gtk.Objects.Widget#g:method:setCssClasses"), [setCursor]("GI.Gtk.Objects.Widget#g:method:setCursor"), [setCursorFromName]("GI.Gtk.Objects.Widget#g:method:setCursorFromName"), [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setDirection]("GI.Gtk.Objects.Widget#g:method:setDirection"), [setEnableRubberband]("GI.Gtk.Objects.ColumnView#g:method:setEnableRubberband"), [setFocusChild]("GI.Gtk.Objects.Widget#g:method:setFocusChild"), [setFocusOnClick]("GI.Gtk.Objects.Widget#g:method:setFocusOnClick"), [setFocusable]("GI.Gtk.Objects.Widget#g:method:setFocusable"), [setFontMap]("GI.Gtk.Objects.Widget#g:method:setFontMap"), [setFontOptions]("GI.Gtk.Objects.Widget#g:method:setFontOptions"), [setHadjustment]("GI.Gtk.Interfaces.Scrollable#g:method:setHadjustment"), [setHalign]("GI.Gtk.Objects.Widget#g:method:setHalign"), [setHasTooltip]("GI.Gtk.Objects.Widget#g:method:setHasTooltip"), [setHexpand]("GI.Gtk.Objects.Widget#g:method:setHexpand"), [setHexpandSet]("GI.Gtk.Objects.Widget#g:method:setHexpandSet"), [setHscrollPolicy]("GI.Gtk.Interfaces.Scrollable#g:method:setHscrollPolicy"), [setLayoutManager]("GI.Gtk.Objects.Widget#g:method:setLayoutManager"), [setMarginBottom]("GI.Gtk.Objects.Widget#g:method:setMarginBottom"), [setMarginEnd]("GI.Gtk.Objects.Widget#g:method:setMarginEnd"), [setMarginStart]("GI.Gtk.Objects.Widget#g:method:setMarginStart"), [setMarginTop]("GI.Gtk.Objects.Widget#g:method:setMarginTop"), [setModel]("GI.Gtk.Objects.ColumnView#g:method:setModel"), [setName]("GI.Gtk.Objects.Widget#g:method:setName"), [setOpacity]("GI.Gtk.Objects.Widget#g:method:setOpacity"), [setOverflow]("GI.Gtk.Objects.Widget#g:method:setOverflow"), [setParent]("GI.Gtk.Objects.Widget#g:method:setParent"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setReceivesDefault]("GI.Gtk.Objects.Widget#g:method:setReceivesDefault"), [setReorderable]("GI.Gtk.Objects.ColumnView#g:method:setReorderable"), [setSensitive]("GI.Gtk.Objects.Widget#g:method:setSensitive"), [setShowColumnSeparators]("GI.Gtk.Objects.ColumnView#g:method:setShowColumnSeparators"), [setShowRowSeparators]("GI.Gtk.Objects.ColumnView#g:method:setShowRowSeparators"), [setSingleClickActivate]("GI.Gtk.Objects.ColumnView#g:method:setSingleClickActivate"), [setSizeRequest]("GI.Gtk.Objects.Widget#g:method:setSizeRequest"), [setStateFlags]("GI.Gtk.Objects.Widget#g:method:setStateFlags"), [setTooltipMarkup]("GI.Gtk.Objects.Widget#g:method:setTooltipMarkup"), [setTooltipText]("GI.Gtk.Objects.Widget#g:method:setTooltipText"), [setVadjustment]("GI.Gtk.Interfaces.Scrollable#g:method:setVadjustment"), [setValign]("GI.Gtk.Objects.Widget#g:method:setValign"), [setVexpand]("GI.Gtk.Objects.Widget#g:method:setVexpand"), [setVexpandSet]("GI.Gtk.Objects.Widget#g:method:setVexpandSet"), [setVisible]("GI.Gtk.Objects.Widget#g:method:setVisible"), [setVscrollPolicy]("GI.Gtk.Interfaces.Scrollable#g:method:setVscrollPolicy").

#if defined(ENABLE_OVERLOADING)
    ResolveColumnViewMethod                 ,
#endif

-- ** appendColumn #method:appendColumn#

#if defined(ENABLE_OVERLOADING)
    ColumnViewAppendColumnMethodInfo        ,
#endif
    columnViewAppendColumn                  ,


-- ** getColumns #method:getColumns#

#if defined(ENABLE_OVERLOADING)
    ColumnViewGetColumnsMethodInfo          ,
#endif
    columnViewGetColumns                    ,


-- ** getEnableRubberband #method:getEnableRubberband#

#if defined(ENABLE_OVERLOADING)
    ColumnViewGetEnableRubberbandMethodInfo ,
#endif
    columnViewGetEnableRubberband           ,


-- ** getModel #method:getModel#

#if defined(ENABLE_OVERLOADING)
    ColumnViewGetModelMethodInfo            ,
#endif
    columnViewGetModel                      ,


-- ** getReorderable #method:getReorderable#

#if defined(ENABLE_OVERLOADING)
    ColumnViewGetReorderableMethodInfo      ,
#endif
    columnViewGetReorderable                ,


-- ** getShowColumnSeparators #method:getShowColumnSeparators#

#if defined(ENABLE_OVERLOADING)
    ColumnViewGetShowColumnSeparatorsMethodInfo,
#endif
    columnViewGetShowColumnSeparators       ,


-- ** getShowRowSeparators #method:getShowRowSeparators#

#if defined(ENABLE_OVERLOADING)
    ColumnViewGetShowRowSeparatorsMethodInfo,
#endif
    columnViewGetShowRowSeparators          ,


-- ** getSingleClickActivate #method:getSingleClickActivate#

#if defined(ENABLE_OVERLOADING)
    ColumnViewGetSingleClickActivateMethodInfo,
#endif
    columnViewGetSingleClickActivate        ,


-- ** getSorter #method:getSorter#

#if defined(ENABLE_OVERLOADING)
    ColumnViewGetSorterMethodInfo           ,
#endif
    columnViewGetSorter                     ,


-- ** insertColumn #method:insertColumn#

#if defined(ENABLE_OVERLOADING)
    ColumnViewInsertColumnMethodInfo        ,
#endif
    columnViewInsertColumn                  ,


-- ** new #method:new#

    columnViewNew                           ,


-- ** removeColumn #method:removeColumn#

#if defined(ENABLE_OVERLOADING)
    ColumnViewRemoveColumnMethodInfo        ,
#endif
    columnViewRemoveColumn                  ,


-- ** setEnableRubberband #method:setEnableRubberband#

#if defined(ENABLE_OVERLOADING)
    ColumnViewSetEnableRubberbandMethodInfo ,
#endif
    columnViewSetEnableRubberband           ,


-- ** setModel #method:setModel#

#if defined(ENABLE_OVERLOADING)
    ColumnViewSetModelMethodInfo            ,
#endif
    columnViewSetModel                      ,


-- ** setReorderable #method:setReorderable#

#if defined(ENABLE_OVERLOADING)
    ColumnViewSetReorderableMethodInfo      ,
#endif
    columnViewSetReorderable                ,


-- ** setShowColumnSeparators #method:setShowColumnSeparators#

#if defined(ENABLE_OVERLOADING)
    ColumnViewSetShowColumnSeparatorsMethodInfo,
#endif
    columnViewSetShowColumnSeparators       ,


-- ** setShowRowSeparators #method:setShowRowSeparators#

#if defined(ENABLE_OVERLOADING)
    ColumnViewSetShowRowSeparatorsMethodInfo,
#endif
    columnViewSetShowRowSeparators          ,


-- ** setSingleClickActivate #method:setSingleClickActivate#

#if defined(ENABLE_OVERLOADING)
    ColumnViewSetSingleClickActivateMethodInfo,
#endif
    columnViewSetSingleClickActivate        ,


-- ** sortByColumn #method:sortByColumn#

#if defined(ENABLE_OVERLOADING)
    ColumnViewSortByColumnMethodInfo        ,
#endif
    columnViewSortByColumn                  ,




 -- * Properties


-- ** columns #attr:columns#
-- | The list of columns.

#if defined(ENABLE_OVERLOADING)
    ColumnViewColumnsPropertyInfo           ,
#endif
#if defined(ENABLE_OVERLOADING)
    columnViewColumns                       ,
#endif
    getColumnViewColumns                    ,


-- ** enableRubberband #attr:enableRubberband#
-- | Allow rubberband selection.

#if defined(ENABLE_OVERLOADING)
    ColumnViewEnableRubberbandPropertyInfo  ,
#endif
#if defined(ENABLE_OVERLOADING)
    columnViewEnableRubberband              ,
#endif
    constructColumnViewEnableRubberband     ,
    getColumnViewEnableRubberband           ,
    setColumnViewEnableRubberband           ,


-- ** model #attr:model#
-- | Model for the items displayed.

#if defined(ENABLE_OVERLOADING)
    ColumnViewModelPropertyInfo             ,
#endif
    clearColumnViewModel                    ,
#if defined(ENABLE_OVERLOADING)
    columnViewModel                         ,
#endif
    constructColumnViewModel                ,
    getColumnViewModel                      ,
    setColumnViewModel                      ,


-- ** reorderable #attr:reorderable#
-- | Whether columns are reorderable.

#if defined(ENABLE_OVERLOADING)
    ColumnViewReorderablePropertyInfo       ,
#endif
#if defined(ENABLE_OVERLOADING)
    columnViewReorderable                   ,
#endif
    constructColumnViewReorderable          ,
    getColumnViewReorderable                ,
    setColumnViewReorderable                ,


-- ** showColumnSeparators #attr:showColumnSeparators#
-- | Show separators between columns.

#if defined(ENABLE_OVERLOADING)
    ColumnViewShowColumnSeparatorsPropertyInfo,
#endif
#if defined(ENABLE_OVERLOADING)
    columnViewShowColumnSeparators          ,
#endif
    constructColumnViewShowColumnSeparators ,
    getColumnViewShowColumnSeparators       ,
    setColumnViewShowColumnSeparators       ,


-- ** showRowSeparators #attr:showRowSeparators#
-- | Show separators between rows.

#if defined(ENABLE_OVERLOADING)
    ColumnViewShowRowSeparatorsPropertyInfo ,
#endif
#if defined(ENABLE_OVERLOADING)
    columnViewShowRowSeparators             ,
#endif
    constructColumnViewShowRowSeparators    ,
    getColumnViewShowRowSeparators          ,
    setColumnViewShowRowSeparators          ,


-- ** singleClickActivate #attr:singleClickActivate#
-- | Activate rows on single click and select them on hover.

#if defined(ENABLE_OVERLOADING)
    ColumnViewSingleClickActivatePropertyInfo,
#endif
#if defined(ENABLE_OVERLOADING)
    columnViewSingleClickActivate           ,
#endif
    constructColumnViewSingleClickActivate  ,
    getColumnViewSingleClickActivate        ,
    setColumnViewSingleClickActivate        ,


-- ** sorter #attr:sorter#
-- | Sorter with the sorting choices of the user.

#if defined(ENABLE_OVERLOADING)
    ColumnViewSorterPropertyInfo            ,
#endif
#if defined(ENABLE_OVERLOADING)
    columnViewSorter                        ,
#endif
    getColumnViewSorter                     ,




 -- * Signals


-- ** activate #signal:activate#

    ColumnViewActivateCallback              ,
#if defined(ENABLE_OVERLOADING)
    ColumnViewActivateSignalInfo            ,
#endif
    afterColumnViewActivate                 ,
    onColumnViewActivate                    ,




    ) where

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

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R

import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gio.Interfaces.ListModel as Gio.ListModel
import {-# SOURCE #-} qualified GI.Gtk.Enums as Gtk.Enums
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Accessible as Gtk.Accessible
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.ConstraintTarget as Gtk.ConstraintTarget
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Scrollable as Gtk.Scrollable
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.SelectionModel as Gtk.SelectionModel
import {-# SOURCE #-} qualified GI.Gtk.Objects.ColumnViewColumn as Gtk.ColumnViewColumn
import {-# SOURCE #-} qualified GI.Gtk.Objects.Sorter as Gtk.Sorter
import {-# SOURCE #-} qualified GI.Gtk.Objects.Widget as Gtk.Widget

-- | Memory-managed wrapper type.
newtype ColumnView = ColumnView (SP.ManagedPtr ColumnView)
    deriving (ColumnView -> ColumnView -> Bool
(ColumnView -> ColumnView -> Bool)
-> (ColumnView -> ColumnView -> Bool) -> Eq ColumnView
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ColumnView -> ColumnView -> Bool
== :: ColumnView -> ColumnView -> Bool
$c/= :: ColumnView -> ColumnView -> Bool
/= :: ColumnView -> ColumnView -> Bool
Eq)

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

foreign import ccall "gtk_column_view_get_type"
    c_gtk_column_view_get_type :: IO B.Types.GType

instance B.Types.TypedObject ColumnView where
    glibType :: IO GType
glibType = IO GType
c_gtk_column_view_get_type

instance B.Types.GObject ColumnView

-- | Type class for types which can be safely cast to `ColumnView`, for instance with `toColumnView`.
class (SP.GObject o, O.IsDescendantOf ColumnView o) => IsColumnView o
instance (SP.GObject o, O.IsDescendantOf ColumnView o) => IsColumnView o

instance O.HasParentTypes ColumnView
type instance O.ParentTypes ColumnView = '[Gtk.Widget.Widget, GObject.Object.Object, Gtk.Accessible.Accessible, Gtk.Buildable.Buildable, Gtk.ConstraintTarget.ConstraintTarget, Gtk.Scrollable.Scrollable]

-- | Cast to `ColumnView`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toColumnView :: (MIO.MonadIO m, IsColumnView o) => o -> m ColumnView
toColumnView :: forall (m :: * -> *) o.
(MonadIO m, IsColumnView o) =>
o -> m ColumnView
toColumnView = IO ColumnView -> m ColumnView
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO ColumnView -> m ColumnView)
-> (o -> IO ColumnView) -> o -> m ColumnView
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr ColumnView -> ColumnView) -> o -> IO ColumnView
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
 ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr ColumnView -> ColumnView
ColumnView

-- | Convert 'ColumnView' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue (Maybe ColumnView) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_gtk_column_view_get_type
    gvalueSet_ :: Ptr GValue -> Maybe ColumnView -> IO ()
gvalueSet_ Ptr GValue
gv Maybe ColumnView
P.Nothing = Ptr GValue -> Ptr ColumnView -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr ColumnView
forall a. Ptr a
FP.nullPtr :: FP.Ptr ColumnView)
    gvalueSet_ Ptr GValue
gv (P.Just ColumnView
obj) = ColumnView -> (Ptr ColumnView -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr ColumnView
obj (Ptr GValue -> Ptr ColumnView -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe ColumnView)
gvalueGet_ Ptr GValue
gv = do
        Ptr ColumnView
ptr <- Ptr GValue -> IO (Ptr ColumnView)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr ColumnView)
        if Ptr ColumnView
ptr Ptr ColumnView -> Ptr ColumnView -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr ColumnView
forall a. Ptr a
FP.nullPtr
        then ColumnView -> Maybe ColumnView
forall a. a -> Maybe a
P.Just (ColumnView -> Maybe ColumnView)
-> IO ColumnView -> IO (Maybe ColumnView)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr ColumnView -> ColumnView)
-> Ptr ColumnView -> IO ColumnView
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr ColumnView -> ColumnView
ColumnView Ptr ColumnView
ptr
        else Maybe ColumnView -> IO (Maybe ColumnView)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ColumnView
forall a. Maybe a
P.Nothing
        
    

#if defined(ENABLE_OVERLOADING)
type family ResolveColumnViewMethod (t :: Symbol) (o :: *) :: * where
    ResolveColumnViewMethod "actionSetEnabled" o = Gtk.Widget.WidgetActionSetEnabledMethodInfo
    ResolveColumnViewMethod "activate" o = Gtk.Widget.WidgetActivateMethodInfo
    ResolveColumnViewMethod "activateAction" o = Gtk.Widget.WidgetActivateActionMethodInfo
    ResolveColumnViewMethod "activateDefault" o = Gtk.Widget.WidgetActivateDefaultMethodInfo
    ResolveColumnViewMethod "addController" o = Gtk.Widget.WidgetAddControllerMethodInfo
    ResolveColumnViewMethod "addCssClass" o = Gtk.Widget.WidgetAddCssClassMethodInfo
    ResolveColumnViewMethod "addMnemonicLabel" o = Gtk.Widget.WidgetAddMnemonicLabelMethodInfo
    ResolveColumnViewMethod "addTickCallback" o = Gtk.Widget.WidgetAddTickCallbackMethodInfo
    ResolveColumnViewMethod "allocate" o = Gtk.Widget.WidgetAllocateMethodInfo
    ResolveColumnViewMethod "appendColumn" o = ColumnViewAppendColumnMethodInfo
    ResolveColumnViewMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveColumnViewMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveColumnViewMethod "childFocus" o = Gtk.Widget.WidgetChildFocusMethodInfo
    ResolveColumnViewMethod "computeBounds" o = Gtk.Widget.WidgetComputeBoundsMethodInfo
    ResolveColumnViewMethod "computeExpand" o = Gtk.Widget.WidgetComputeExpandMethodInfo
    ResolveColumnViewMethod "computePoint" o = Gtk.Widget.WidgetComputePointMethodInfo
    ResolveColumnViewMethod "computeTransform" o = Gtk.Widget.WidgetComputeTransformMethodInfo
    ResolveColumnViewMethod "contains" o = Gtk.Widget.WidgetContainsMethodInfo
    ResolveColumnViewMethod "createPangoContext" o = Gtk.Widget.WidgetCreatePangoContextMethodInfo
    ResolveColumnViewMethod "createPangoLayout" o = Gtk.Widget.WidgetCreatePangoLayoutMethodInfo
    ResolveColumnViewMethod "disposeTemplate" o = Gtk.Widget.WidgetDisposeTemplateMethodInfo
    ResolveColumnViewMethod "dragCheckThreshold" o = Gtk.Widget.WidgetDragCheckThresholdMethodInfo
    ResolveColumnViewMethod "errorBell" o = Gtk.Widget.WidgetErrorBellMethodInfo
    ResolveColumnViewMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveColumnViewMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveColumnViewMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveColumnViewMethod "grabFocus" o = Gtk.Widget.WidgetGrabFocusMethodInfo
    ResolveColumnViewMethod "hasCssClass" o = Gtk.Widget.WidgetHasCssClassMethodInfo
    ResolveColumnViewMethod "hasDefault" o = Gtk.Widget.WidgetHasDefaultMethodInfo
    ResolveColumnViewMethod "hasFocus" o = Gtk.Widget.WidgetHasFocusMethodInfo
    ResolveColumnViewMethod "hasVisibleFocus" o = Gtk.Widget.WidgetHasVisibleFocusMethodInfo
    ResolveColumnViewMethod "hide" o = Gtk.Widget.WidgetHideMethodInfo
    ResolveColumnViewMethod "inDestruction" o = Gtk.Widget.WidgetInDestructionMethodInfo
    ResolveColumnViewMethod "initTemplate" o = Gtk.Widget.WidgetInitTemplateMethodInfo
    ResolveColumnViewMethod "insertActionGroup" o = Gtk.Widget.WidgetInsertActionGroupMethodInfo
    ResolveColumnViewMethod "insertAfter" o = Gtk.Widget.WidgetInsertAfterMethodInfo
    ResolveColumnViewMethod "insertBefore" o = Gtk.Widget.WidgetInsertBeforeMethodInfo
    ResolveColumnViewMethod "insertColumn" o = ColumnViewInsertColumnMethodInfo
    ResolveColumnViewMethod "isAncestor" o = Gtk.Widget.WidgetIsAncestorMethodInfo
    ResolveColumnViewMethod "isDrawable" o = Gtk.Widget.WidgetIsDrawableMethodInfo
    ResolveColumnViewMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveColumnViewMethod "isFocus" o = Gtk.Widget.WidgetIsFocusMethodInfo
    ResolveColumnViewMethod "isSensitive" o = Gtk.Widget.WidgetIsSensitiveMethodInfo
    ResolveColumnViewMethod "isVisible" o = Gtk.Widget.WidgetIsVisibleMethodInfo
    ResolveColumnViewMethod "keynavFailed" o = Gtk.Widget.WidgetKeynavFailedMethodInfo
    ResolveColumnViewMethod "listMnemonicLabels" o = Gtk.Widget.WidgetListMnemonicLabelsMethodInfo
    ResolveColumnViewMethod "map" o = Gtk.Widget.WidgetMapMethodInfo
    ResolveColumnViewMethod "measure" o = Gtk.Widget.WidgetMeasureMethodInfo
    ResolveColumnViewMethod "mnemonicActivate" o = Gtk.Widget.WidgetMnemonicActivateMethodInfo
    ResolveColumnViewMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveColumnViewMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveColumnViewMethod "observeChildren" o = Gtk.Widget.WidgetObserveChildrenMethodInfo
    ResolveColumnViewMethod "observeControllers" o = Gtk.Widget.WidgetObserveControllersMethodInfo
    ResolveColumnViewMethod "pick" o = Gtk.Widget.WidgetPickMethodInfo
    ResolveColumnViewMethod "queueAllocate" o = Gtk.Widget.WidgetQueueAllocateMethodInfo
    ResolveColumnViewMethod "queueDraw" o = Gtk.Widget.WidgetQueueDrawMethodInfo
    ResolveColumnViewMethod "queueResize" o = Gtk.Widget.WidgetQueueResizeMethodInfo
    ResolveColumnViewMethod "realize" o = Gtk.Widget.WidgetRealizeMethodInfo
    ResolveColumnViewMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveColumnViewMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveColumnViewMethod "removeColumn" o = ColumnViewRemoveColumnMethodInfo
    ResolveColumnViewMethod "removeController" o = Gtk.Widget.WidgetRemoveControllerMethodInfo
    ResolveColumnViewMethod "removeCssClass" o = Gtk.Widget.WidgetRemoveCssClassMethodInfo
    ResolveColumnViewMethod "removeMnemonicLabel" o = Gtk.Widget.WidgetRemoveMnemonicLabelMethodInfo
    ResolveColumnViewMethod "removeTickCallback" o = Gtk.Widget.WidgetRemoveTickCallbackMethodInfo
    ResolveColumnViewMethod "resetProperty" o = Gtk.Accessible.AccessibleResetPropertyMethodInfo
    ResolveColumnViewMethod "resetRelation" o = Gtk.Accessible.AccessibleResetRelationMethodInfo
    ResolveColumnViewMethod "resetState" o = Gtk.Accessible.AccessibleResetStateMethodInfo
    ResolveColumnViewMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveColumnViewMethod "shouldLayout" o = Gtk.Widget.WidgetShouldLayoutMethodInfo
    ResolveColumnViewMethod "show" o = Gtk.Widget.WidgetShowMethodInfo
    ResolveColumnViewMethod "sizeAllocate" o = Gtk.Widget.WidgetSizeAllocateMethodInfo
    ResolveColumnViewMethod "snapshotChild" o = Gtk.Widget.WidgetSnapshotChildMethodInfo
    ResolveColumnViewMethod "sortByColumn" o = ColumnViewSortByColumnMethodInfo
    ResolveColumnViewMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveColumnViewMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveColumnViewMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveColumnViewMethod "translateCoordinates" o = Gtk.Widget.WidgetTranslateCoordinatesMethodInfo
    ResolveColumnViewMethod "triggerTooltipQuery" o = Gtk.Widget.WidgetTriggerTooltipQueryMethodInfo
    ResolveColumnViewMethod "unmap" o = Gtk.Widget.WidgetUnmapMethodInfo
    ResolveColumnViewMethod "unparent" o = Gtk.Widget.WidgetUnparentMethodInfo
    ResolveColumnViewMethod "unrealize" o = Gtk.Widget.WidgetUnrealizeMethodInfo
    ResolveColumnViewMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveColumnViewMethod "unsetStateFlags" o = Gtk.Widget.WidgetUnsetStateFlagsMethodInfo
    ResolveColumnViewMethod "updateProperty" o = Gtk.Accessible.AccessibleUpdatePropertyMethodInfo
    ResolveColumnViewMethod "updateRelation" o = Gtk.Accessible.AccessibleUpdateRelationMethodInfo
    ResolveColumnViewMethod "updateState" o = Gtk.Accessible.AccessibleUpdateStateMethodInfo
    ResolveColumnViewMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveColumnViewMethod "getAccessibleRole" o = Gtk.Accessible.AccessibleGetAccessibleRoleMethodInfo
    ResolveColumnViewMethod "getAllocatedBaseline" o = Gtk.Widget.WidgetGetAllocatedBaselineMethodInfo
    ResolveColumnViewMethod "getAllocatedHeight" o = Gtk.Widget.WidgetGetAllocatedHeightMethodInfo
    ResolveColumnViewMethod "getAllocatedWidth" o = Gtk.Widget.WidgetGetAllocatedWidthMethodInfo
    ResolveColumnViewMethod "getAllocation" o = Gtk.Widget.WidgetGetAllocationMethodInfo
    ResolveColumnViewMethod "getAncestor" o = Gtk.Widget.WidgetGetAncestorMethodInfo
    ResolveColumnViewMethod "getBorder" o = Gtk.Scrollable.ScrollableGetBorderMethodInfo
    ResolveColumnViewMethod "getBuildableId" o = Gtk.Buildable.BuildableGetBuildableIdMethodInfo
    ResolveColumnViewMethod "getCanFocus" o = Gtk.Widget.WidgetGetCanFocusMethodInfo
    ResolveColumnViewMethod "getCanTarget" o = Gtk.Widget.WidgetGetCanTargetMethodInfo
    ResolveColumnViewMethod "getChildVisible" o = Gtk.Widget.WidgetGetChildVisibleMethodInfo
    ResolveColumnViewMethod "getClipboard" o = Gtk.Widget.WidgetGetClipboardMethodInfo
    ResolveColumnViewMethod "getColumns" o = ColumnViewGetColumnsMethodInfo
    ResolveColumnViewMethod "getCssClasses" o = Gtk.Widget.WidgetGetCssClassesMethodInfo
    ResolveColumnViewMethod "getCssName" o = Gtk.Widget.WidgetGetCssNameMethodInfo
    ResolveColumnViewMethod "getCursor" o = Gtk.Widget.WidgetGetCursorMethodInfo
    ResolveColumnViewMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveColumnViewMethod "getDirection" o = Gtk.Widget.WidgetGetDirectionMethodInfo
    ResolveColumnViewMethod "getDisplay" o = Gtk.Widget.WidgetGetDisplayMethodInfo
    ResolveColumnViewMethod "getEnableRubberband" o = ColumnViewGetEnableRubberbandMethodInfo
    ResolveColumnViewMethod "getFirstChild" o = Gtk.Widget.WidgetGetFirstChildMethodInfo
    ResolveColumnViewMethod "getFocusChild" o = Gtk.Widget.WidgetGetFocusChildMethodInfo
    ResolveColumnViewMethod "getFocusOnClick" o = Gtk.Widget.WidgetGetFocusOnClickMethodInfo
    ResolveColumnViewMethod "getFocusable" o = Gtk.Widget.WidgetGetFocusableMethodInfo
    ResolveColumnViewMethod "getFontMap" o = Gtk.Widget.WidgetGetFontMapMethodInfo
    ResolveColumnViewMethod "getFontOptions" o = Gtk.Widget.WidgetGetFontOptionsMethodInfo
    ResolveColumnViewMethod "getFrameClock" o = Gtk.Widget.WidgetGetFrameClockMethodInfo
    ResolveColumnViewMethod "getHadjustment" o = Gtk.Scrollable.ScrollableGetHadjustmentMethodInfo
    ResolveColumnViewMethod "getHalign" o = Gtk.Widget.WidgetGetHalignMethodInfo
    ResolveColumnViewMethod "getHasTooltip" o = Gtk.Widget.WidgetGetHasTooltipMethodInfo
    ResolveColumnViewMethod "getHeight" o = Gtk.Widget.WidgetGetHeightMethodInfo
    ResolveColumnViewMethod "getHexpand" o = Gtk.Widget.WidgetGetHexpandMethodInfo
    ResolveColumnViewMethod "getHexpandSet" o = Gtk.Widget.WidgetGetHexpandSetMethodInfo
    ResolveColumnViewMethod "getHscrollPolicy" o = Gtk.Scrollable.ScrollableGetHscrollPolicyMethodInfo
    ResolveColumnViewMethod "getLastChild" o = Gtk.Widget.WidgetGetLastChildMethodInfo
    ResolveColumnViewMethod "getLayoutManager" o = Gtk.Widget.WidgetGetLayoutManagerMethodInfo
    ResolveColumnViewMethod "getMapped" o = Gtk.Widget.WidgetGetMappedMethodInfo
    ResolveColumnViewMethod "getMarginBottom" o = Gtk.Widget.WidgetGetMarginBottomMethodInfo
    ResolveColumnViewMethod "getMarginEnd" o = Gtk.Widget.WidgetGetMarginEndMethodInfo
    ResolveColumnViewMethod "getMarginStart" o = Gtk.Widget.WidgetGetMarginStartMethodInfo
    ResolveColumnViewMethod "getMarginTop" o = Gtk.Widget.WidgetGetMarginTopMethodInfo
    ResolveColumnViewMethod "getModel" o = ColumnViewGetModelMethodInfo
    ResolveColumnViewMethod "getName" o = Gtk.Widget.WidgetGetNameMethodInfo
    ResolveColumnViewMethod "getNative" o = Gtk.Widget.WidgetGetNativeMethodInfo
    ResolveColumnViewMethod "getNextSibling" o = Gtk.Widget.WidgetGetNextSiblingMethodInfo
    ResolveColumnViewMethod "getOpacity" o = Gtk.Widget.WidgetGetOpacityMethodInfo
    ResolveColumnViewMethod "getOverflow" o = Gtk.Widget.WidgetGetOverflowMethodInfo
    ResolveColumnViewMethod "getPangoContext" o = Gtk.Widget.WidgetGetPangoContextMethodInfo
    ResolveColumnViewMethod "getParent" o = Gtk.Widget.WidgetGetParentMethodInfo
    ResolveColumnViewMethod "getPreferredSize" o = Gtk.Widget.WidgetGetPreferredSizeMethodInfo
    ResolveColumnViewMethod "getPrevSibling" o = Gtk.Widget.WidgetGetPrevSiblingMethodInfo
    ResolveColumnViewMethod "getPrimaryClipboard" o = Gtk.Widget.WidgetGetPrimaryClipboardMethodInfo
    ResolveColumnViewMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveColumnViewMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveColumnViewMethod "getRealized" o = Gtk.Widget.WidgetGetRealizedMethodInfo
    ResolveColumnViewMethod "getReceivesDefault" o = Gtk.Widget.WidgetGetReceivesDefaultMethodInfo
    ResolveColumnViewMethod "getReorderable" o = ColumnViewGetReorderableMethodInfo
    ResolveColumnViewMethod "getRequestMode" o = Gtk.Widget.WidgetGetRequestModeMethodInfo
    ResolveColumnViewMethod "getRoot" o = Gtk.Widget.WidgetGetRootMethodInfo
    ResolveColumnViewMethod "getScaleFactor" o = Gtk.Widget.WidgetGetScaleFactorMethodInfo
    ResolveColumnViewMethod "getSensitive" o = Gtk.Widget.WidgetGetSensitiveMethodInfo
    ResolveColumnViewMethod "getSettings" o = Gtk.Widget.WidgetGetSettingsMethodInfo
    ResolveColumnViewMethod "getShowColumnSeparators" o = ColumnViewGetShowColumnSeparatorsMethodInfo
    ResolveColumnViewMethod "getShowRowSeparators" o = ColumnViewGetShowRowSeparatorsMethodInfo
    ResolveColumnViewMethod "getSingleClickActivate" o = ColumnViewGetSingleClickActivateMethodInfo
    ResolveColumnViewMethod "getSize" o = Gtk.Widget.WidgetGetSizeMethodInfo
    ResolveColumnViewMethod "getSizeRequest" o = Gtk.Widget.WidgetGetSizeRequestMethodInfo
    ResolveColumnViewMethod "getSorter" o = ColumnViewGetSorterMethodInfo
    ResolveColumnViewMethod "getStateFlags" o = Gtk.Widget.WidgetGetStateFlagsMethodInfo
    ResolveColumnViewMethod "getStyleContext" o = Gtk.Widget.WidgetGetStyleContextMethodInfo
    ResolveColumnViewMethod "getTemplateChild" o = Gtk.Widget.WidgetGetTemplateChildMethodInfo
    ResolveColumnViewMethod "getTooltipMarkup" o = Gtk.Widget.WidgetGetTooltipMarkupMethodInfo
    ResolveColumnViewMethod "getTooltipText" o = Gtk.Widget.WidgetGetTooltipTextMethodInfo
    ResolveColumnViewMethod "getVadjustment" o = Gtk.Scrollable.ScrollableGetVadjustmentMethodInfo
    ResolveColumnViewMethod "getValign" o = Gtk.Widget.WidgetGetValignMethodInfo
    ResolveColumnViewMethod "getVexpand" o = Gtk.Widget.WidgetGetVexpandMethodInfo
    ResolveColumnViewMethod "getVexpandSet" o = Gtk.Widget.WidgetGetVexpandSetMethodInfo
    ResolveColumnViewMethod "getVisible" o = Gtk.Widget.WidgetGetVisibleMethodInfo
    ResolveColumnViewMethod "getVscrollPolicy" o = Gtk.Scrollable.ScrollableGetVscrollPolicyMethodInfo
    ResolveColumnViewMethod "getWidth" o = Gtk.Widget.WidgetGetWidthMethodInfo
    ResolveColumnViewMethod "setCanFocus" o = Gtk.Widget.WidgetSetCanFocusMethodInfo
    ResolveColumnViewMethod "setCanTarget" o = Gtk.Widget.WidgetSetCanTargetMethodInfo
    ResolveColumnViewMethod "setChildVisible" o = Gtk.Widget.WidgetSetChildVisibleMethodInfo
    ResolveColumnViewMethod "setCssClasses" o = Gtk.Widget.WidgetSetCssClassesMethodInfo
    ResolveColumnViewMethod "setCursor" o = Gtk.Widget.WidgetSetCursorMethodInfo
    ResolveColumnViewMethod "setCursorFromName" o = Gtk.Widget.WidgetSetCursorFromNameMethodInfo
    ResolveColumnViewMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveColumnViewMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveColumnViewMethod "setDirection" o = Gtk.Widget.WidgetSetDirectionMethodInfo
    ResolveColumnViewMethod "setEnableRubberband" o = ColumnViewSetEnableRubberbandMethodInfo
    ResolveColumnViewMethod "setFocusChild" o = Gtk.Widget.WidgetSetFocusChildMethodInfo
    ResolveColumnViewMethod "setFocusOnClick" o = Gtk.Widget.WidgetSetFocusOnClickMethodInfo
    ResolveColumnViewMethod "setFocusable" o = Gtk.Widget.WidgetSetFocusableMethodInfo
    ResolveColumnViewMethod "setFontMap" o = Gtk.Widget.WidgetSetFontMapMethodInfo
    ResolveColumnViewMethod "setFontOptions" o = Gtk.Widget.WidgetSetFontOptionsMethodInfo
    ResolveColumnViewMethod "setHadjustment" o = Gtk.Scrollable.ScrollableSetHadjustmentMethodInfo
    ResolveColumnViewMethod "setHalign" o = Gtk.Widget.WidgetSetHalignMethodInfo
    ResolveColumnViewMethod "setHasTooltip" o = Gtk.Widget.WidgetSetHasTooltipMethodInfo
    ResolveColumnViewMethod "setHexpand" o = Gtk.Widget.WidgetSetHexpandMethodInfo
    ResolveColumnViewMethod "setHexpandSet" o = Gtk.Widget.WidgetSetHexpandSetMethodInfo
    ResolveColumnViewMethod "setHscrollPolicy" o = Gtk.Scrollable.ScrollableSetHscrollPolicyMethodInfo
    ResolveColumnViewMethod "setLayoutManager" o = Gtk.Widget.WidgetSetLayoutManagerMethodInfo
    ResolveColumnViewMethod "setMarginBottom" o = Gtk.Widget.WidgetSetMarginBottomMethodInfo
    ResolveColumnViewMethod "setMarginEnd" o = Gtk.Widget.WidgetSetMarginEndMethodInfo
    ResolveColumnViewMethod "setMarginStart" o = Gtk.Widget.WidgetSetMarginStartMethodInfo
    ResolveColumnViewMethod "setMarginTop" o = Gtk.Widget.WidgetSetMarginTopMethodInfo
    ResolveColumnViewMethod "setModel" o = ColumnViewSetModelMethodInfo
    ResolveColumnViewMethod "setName" o = Gtk.Widget.WidgetSetNameMethodInfo
    ResolveColumnViewMethod "setOpacity" o = Gtk.Widget.WidgetSetOpacityMethodInfo
    ResolveColumnViewMethod "setOverflow" o = Gtk.Widget.WidgetSetOverflowMethodInfo
    ResolveColumnViewMethod "setParent" o = Gtk.Widget.WidgetSetParentMethodInfo
    ResolveColumnViewMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveColumnViewMethod "setReceivesDefault" o = Gtk.Widget.WidgetSetReceivesDefaultMethodInfo
    ResolveColumnViewMethod "setReorderable" o = ColumnViewSetReorderableMethodInfo
    ResolveColumnViewMethod "setSensitive" o = Gtk.Widget.WidgetSetSensitiveMethodInfo
    ResolveColumnViewMethod "setShowColumnSeparators" o = ColumnViewSetShowColumnSeparatorsMethodInfo
    ResolveColumnViewMethod "setShowRowSeparators" o = ColumnViewSetShowRowSeparatorsMethodInfo
    ResolveColumnViewMethod "setSingleClickActivate" o = ColumnViewSetSingleClickActivateMethodInfo
    ResolveColumnViewMethod "setSizeRequest" o = Gtk.Widget.WidgetSetSizeRequestMethodInfo
    ResolveColumnViewMethod "setStateFlags" o = Gtk.Widget.WidgetSetStateFlagsMethodInfo
    ResolveColumnViewMethod "setTooltipMarkup" o = Gtk.Widget.WidgetSetTooltipMarkupMethodInfo
    ResolveColumnViewMethod "setTooltipText" o = Gtk.Widget.WidgetSetTooltipTextMethodInfo
    ResolveColumnViewMethod "setVadjustment" o = Gtk.Scrollable.ScrollableSetVadjustmentMethodInfo
    ResolveColumnViewMethod "setValign" o = Gtk.Widget.WidgetSetValignMethodInfo
    ResolveColumnViewMethod "setVexpand" o = Gtk.Widget.WidgetSetVexpandMethodInfo
    ResolveColumnViewMethod "setVexpandSet" o = Gtk.Widget.WidgetSetVexpandSetMethodInfo
    ResolveColumnViewMethod "setVisible" o = Gtk.Widget.WidgetSetVisibleMethodInfo
    ResolveColumnViewMethod "setVscrollPolicy" o = Gtk.Scrollable.ScrollableSetVscrollPolicyMethodInfo
    ResolveColumnViewMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveColumnViewMethod t ColumnView, O.OverloadedMethod info ColumnView p) => OL.IsLabel t (ColumnView -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod @info
#else
    fromLabel _ = O.overloadedMethod @info
#endif

#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveColumnViewMethod t ColumnView, O.OverloadedMethod info ColumnView p, R.HasField t ColumnView p) => R.HasField t ColumnView p where
    getField = O.overloadedMethod @info

#endif

instance (info ~ ResolveColumnViewMethod t ColumnView, O.OverloadedMethodInfo info ColumnView) => OL.IsLabel t (O.MethodProxy info ColumnView) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#endif

#endif

-- signal ColumnView::activate
-- | Emitted when a row has been activated by the user, usually via activating
-- the GtkListBase|list.activate-item action.
-- 
-- This allows for a convenient way to handle activation in a columnview.
-- See 'GI.Gtk.Objects.ListItem.listItemSetActivatable' for details on how to use this
-- signal.
type ColumnViewActivateCallback =
    Word32
    -- ^ /@position@/: position of item to activate
    -> IO ()

type C_ColumnViewActivateCallback =
    Ptr ColumnView ->                       -- object
    Word32 ->
    Ptr () ->                               -- user_data
    IO ()

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

wrap_ColumnViewActivateCallback :: 
    GObject a => (a -> ColumnViewActivateCallback) ->
    C_ColumnViewActivateCallback
wrap_ColumnViewActivateCallback :: forall a.
GObject a =>
(a -> ColumnViewActivateCallback) -> C_ColumnViewActivateCallback
wrap_ColumnViewActivateCallback a -> ColumnViewActivateCallback
gi'cb Ptr ColumnView
gi'selfPtr Word32
position Ptr ()
_ = do
    Ptr ColumnView -> (ColumnView -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr ColumnView
gi'selfPtr ((ColumnView -> IO ()) -> IO ()) -> (ColumnView -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ColumnView
gi'self -> a -> ColumnViewActivateCallback
gi'cb (ColumnView -> a
forall a b. Coercible a b => a -> b
Coerce.coerce ColumnView
gi'self)  Word32
position


-- | Connect a signal handler for the [activate](#signal:activate) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' columnView #activate callback
-- @
-- 
-- 
onColumnViewActivate :: (IsColumnView a, MonadIO m) => a -> ((?self :: a) => ColumnViewActivateCallback) -> m SignalHandlerId
onColumnViewActivate :: forall a (m :: * -> *).
(IsColumnView a, MonadIO m) =>
a
-> ((?self::a) => ColumnViewActivateCallback) -> m SignalHandlerId
onColumnViewActivate a
obj (?self::a) => ColumnViewActivateCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ColumnViewActivateCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => ColumnViewActivateCallback
ColumnViewActivateCallback
cb
    let wrapped' :: C_ColumnViewActivateCallback
wrapped' = (a -> ColumnViewActivateCallback) -> C_ColumnViewActivateCallback
forall a.
GObject a =>
(a -> ColumnViewActivateCallback) -> C_ColumnViewActivateCallback
wrap_ColumnViewActivateCallback a -> ColumnViewActivateCallback
wrapped
    FunPtr C_ColumnViewActivateCallback
wrapped'' <- C_ColumnViewActivateCallback
-> IO (FunPtr C_ColumnViewActivateCallback)
mk_ColumnViewActivateCallback C_ColumnViewActivateCallback
wrapped'
    a
-> Text
-> FunPtr C_ColumnViewActivateCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"activate" FunPtr C_ColumnViewActivateCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [activate](#signal:activate) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' columnView #activate callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterColumnViewActivate :: (IsColumnView a, MonadIO m) => a -> ((?self :: a) => ColumnViewActivateCallback) -> m SignalHandlerId
afterColumnViewActivate :: forall a (m :: * -> *).
(IsColumnView a, MonadIO m) =>
a
-> ((?self::a) => ColumnViewActivateCallback) -> m SignalHandlerId
afterColumnViewActivate a
obj (?self::a) => ColumnViewActivateCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ColumnViewActivateCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => ColumnViewActivateCallback
ColumnViewActivateCallback
cb
    let wrapped' :: C_ColumnViewActivateCallback
wrapped' = (a -> ColumnViewActivateCallback) -> C_ColumnViewActivateCallback
forall a.
GObject a =>
(a -> ColumnViewActivateCallback) -> C_ColumnViewActivateCallback
wrap_ColumnViewActivateCallback a -> ColumnViewActivateCallback
wrapped
    FunPtr C_ColumnViewActivateCallback
wrapped'' <- C_ColumnViewActivateCallback
-> IO (FunPtr C_ColumnViewActivateCallback)
mk_ColumnViewActivateCallback C_ColumnViewActivateCallback
wrapped'
    a
-> Text
-> FunPtr C_ColumnViewActivateCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"activate" FunPtr C_ColumnViewActivateCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data ColumnViewActivateSignalInfo
instance SignalInfo ColumnViewActivateSignalInfo where
    type HaskellCallbackType ColumnViewActivateSignalInfo = ColumnViewActivateCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_ColumnViewActivateCallback cb
        cb'' <- mk_ColumnViewActivateCallback cb'
        connectSignalFunPtr obj "activate" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.ColumnView::activate"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-ColumnView.html#g:signal:activate"})

#endif

-- VVV Prop "columns"
   -- Type: TInterface (Name {namespace = "Gio", name = "ListModel"})
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

-- | Get the value of the “@columns@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' columnView #columns
-- @
getColumnViewColumns :: (MonadIO m, IsColumnView o) => o -> m Gio.ListModel.ListModel
getColumnViewColumns :: forall (m :: * -> *) o.
(MonadIO m, IsColumnView o) =>
o -> m ListModel
getColumnViewColumns o
obj = IO ListModel -> m ListModel
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO ListModel -> m ListModel) -> IO ListModel -> m ListModel
forall a b. (a -> b) -> a -> b
$ Text -> IO (Maybe ListModel) -> IO ListModel
forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing Text
"getColumnViewColumns" (IO (Maybe ListModel) -> IO ListModel)
-> IO (Maybe ListModel) -> IO ListModel
forall a b. (a -> b) -> a -> b
$ o
-> String
-> (ManagedPtr ListModel -> ListModel)
-> IO (Maybe ListModel)
forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj String
"columns" ManagedPtr ListModel -> ListModel
Gio.ListModel.ListModel

#if defined(ENABLE_OVERLOADING)
data ColumnViewColumnsPropertyInfo
instance AttrInfo ColumnViewColumnsPropertyInfo where
    type AttrAllowedOps ColumnViewColumnsPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint ColumnViewColumnsPropertyInfo = IsColumnView
    type AttrSetTypeConstraint ColumnViewColumnsPropertyInfo = (~) ()
    type AttrTransferTypeConstraint ColumnViewColumnsPropertyInfo = (~) ()
    type AttrTransferType ColumnViewColumnsPropertyInfo = ()
    type AttrGetType ColumnViewColumnsPropertyInfo = Gio.ListModel.ListModel
    type AttrLabel ColumnViewColumnsPropertyInfo = "columns"
    type AttrOrigin ColumnViewColumnsPropertyInfo = ColumnView
    attrGet = getColumnViewColumns
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.ColumnView.columns"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-ColumnView.html#g:attr:columns"
        })
#endif

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

-- | Get the value of the “@enable-rubberband@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' columnView #enableRubberband
-- @
getColumnViewEnableRubberband :: (MonadIO m, IsColumnView o) => o -> m Bool
getColumnViewEnableRubberband :: forall (m :: * -> *) o. (MonadIO m, IsColumnView o) => o -> m Bool
getColumnViewEnableRubberband o
obj = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"enable-rubberband"

-- | Set the value of the “@enable-rubberband@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' columnView [ #enableRubberband 'Data.GI.Base.Attributes.:=' value ]
-- @
setColumnViewEnableRubberband :: (MonadIO m, IsColumnView o) => o -> Bool -> m ()
setColumnViewEnableRubberband :: forall (m :: * -> *) o.
(MonadIO m, IsColumnView o) =>
o -> Bool -> m ()
setColumnViewEnableRubberband o
obj Bool
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"enable-rubberband" Bool
val

-- | Construct a `GValueConstruct` with valid value for the “@enable-rubberband@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructColumnViewEnableRubberband :: (IsColumnView o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructColumnViewEnableRubberband :: forall o (m :: * -> *).
(IsColumnView o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructColumnViewEnableRubberband Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"enable-rubberband" Bool
val

#if defined(ENABLE_OVERLOADING)
data ColumnViewEnableRubberbandPropertyInfo
instance AttrInfo ColumnViewEnableRubberbandPropertyInfo where
    type AttrAllowedOps ColumnViewEnableRubberbandPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ColumnViewEnableRubberbandPropertyInfo = IsColumnView
    type AttrSetTypeConstraint ColumnViewEnableRubberbandPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint ColumnViewEnableRubberbandPropertyInfo = (~) Bool
    type AttrTransferType ColumnViewEnableRubberbandPropertyInfo = Bool
    type AttrGetType ColumnViewEnableRubberbandPropertyInfo = Bool
    type AttrLabel ColumnViewEnableRubberbandPropertyInfo = "enable-rubberband"
    type AttrOrigin ColumnViewEnableRubberbandPropertyInfo = ColumnView
    attrGet = getColumnViewEnableRubberband
    attrSet = setColumnViewEnableRubberband
    attrTransfer _ v = do
        return v
    attrConstruct = constructColumnViewEnableRubberband
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.ColumnView.enableRubberband"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-ColumnView.html#g:attr:enableRubberband"
        })
#endif

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

-- | Get the value of the “@model@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' columnView #model
-- @
getColumnViewModel :: (MonadIO m, IsColumnView o) => o -> m (Maybe Gtk.SelectionModel.SelectionModel)
getColumnViewModel :: forall (m :: * -> *) o.
(MonadIO m, IsColumnView o) =>
o -> m (Maybe SelectionModel)
getColumnViewModel o
obj = IO (Maybe SelectionModel) -> m (Maybe SelectionModel)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe SelectionModel) -> m (Maybe SelectionModel))
-> IO (Maybe SelectionModel) -> m (Maybe SelectionModel)
forall a b. (a -> b) -> a -> b
$ o
-> String
-> (ManagedPtr SelectionModel -> SelectionModel)
-> IO (Maybe SelectionModel)
forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj String
"model" ManagedPtr SelectionModel -> SelectionModel
Gtk.SelectionModel.SelectionModel

-- | Set the value of the “@model@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' columnView [ #model 'Data.GI.Base.Attributes.:=' value ]
-- @
setColumnViewModel :: (MonadIO m, IsColumnView o, Gtk.SelectionModel.IsSelectionModel a) => o -> a -> m ()
setColumnViewModel :: forall (m :: * -> *) o a.
(MonadIO m, IsColumnView o, IsSelectionModel a) =>
o -> a -> m ()
setColumnViewModel o
obj a
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe a -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"model" (a -> Maybe a
forall a. a -> Maybe a
Just a
val)

-- | Construct a `GValueConstruct` with valid value for the “@model@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructColumnViewModel :: (IsColumnView o, MIO.MonadIO m, Gtk.SelectionModel.IsSelectionModel a) => a -> m (GValueConstruct o)
constructColumnViewModel :: forall o (m :: * -> *) a.
(IsColumnView o, MonadIO m, IsSelectionModel a) =>
a -> m (GValueConstruct o)
constructColumnViewModel a
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe a -> IO (GValueConstruct o)
forall a o.
GObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyObject String
"model" (a -> Maybe a
forall a. a -> Maybe a
P.Just a
val)

-- | Set the value of the “@model@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #model
-- @
clearColumnViewModel :: (MonadIO m, IsColumnView o) => o -> m ()
clearColumnViewModel :: forall (m :: * -> *) o. (MonadIO m, IsColumnView o) => o -> m ()
clearColumnViewModel o
obj = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe SelectionModel -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"model" (Maybe SelectionModel
forall a. Maybe a
Nothing :: Maybe Gtk.SelectionModel.SelectionModel)

#if defined(ENABLE_OVERLOADING)
data ColumnViewModelPropertyInfo
instance AttrInfo ColumnViewModelPropertyInfo where
    type AttrAllowedOps ColumnViewModelPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint ColumnViewModelPropertyInfo = IsColumnView
    type AttrSetTypeConstraint ColumnViewModelPropertyInfo = Gtk.SelectionModel.IsSelectionModel
    type AttrTransferTypeConstraint ColumnViewModelPropertyInfo = Gtk.SelectionModel.IsSelectionModel
    type AttrTransferType ColumnViewModelPropertyInfo = Gtk.SelectionModel.SelectionModel
    type AttrGetType ColumnViewModelPropertyInfo = (Maybe Gtk.SelectionModel.SelectionModel)
    type AttrLabel ColumnViewModelPropertyInfo = "model"
    type AttrOrigin ColumnViewModelPropertyInfo = ColumnView
    attrGet = getColumnViewModel
    attrSet = setColumnViewModel
    attrTransfer _ v = do
        unsafeCastTo Gtk.SelectionModel.SelectionModel v
    attrConstruct = constructColumnViewModel
    attrClear = clearColumnViewModel
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.ColumnView.model"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-ColumnView.html#g:attr:model"
        })
#endif

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

-- | Get the value of the “@reorderable@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' columnView #reorderable
-- @
getColumnViewReorderable :: (MonadIO m, IsColumnView o) => o -> m Bool
getColumnViewReorderable :: forall (m :: * -> *) o. (MonadIO m, IsColumnView o) => o -> m Bool
getColumnViewReorderable o
obj = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"reorderable"

-- | Set the value of the “@reorderable@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' columnView [ #reorderable 'Data.GI.Base.Attributes.:=' value ]
-- @
setColumnViewReorderable :: (MonadIO m, IsColumnView o) => o -> Bool -> m ()
setColumnViewReorderable :: forall (m :: * -> *) o.
(MonadIO m, IsColumnView o) =>
o -> Bool -> m ()
setColumnViewReorderable o
obj Bool
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"reorderable" Bool
val

-- | Construct a `GValueConstruct` with valid value for the “@reorderable@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructColumnViewReorderable :: (IsColumnView o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructColumnViewReorderable :: forall o (m :: * -> *).
(IsColumnView o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructColumnViewReorderable Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"reorderable" Bool
val

#if defined(ENABLE_OVERLOADING)
data ColumnViewReorderablePropertyInfo
instance AttrInfo ColumnViewReorderablePropertyInfo where
    type AttrAllowedOps ColumnViewReorderablePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ColumnViewReorderablePropertyInfo = IsColumnView
    type AttrSetTypeConstraint ColumnViewReorderablePropertyInfo = (~) Bool
    type AttrTransferTypeConstraint ColumnViewReorderablePropertyInfo = (~) Bool
    type AttrTransferType ColumnViewReorderablePropertyInfo = Bool
    type AttrGetType ColumnViewReorderablePropertyInfo = Bool
    type AttrLabel ColumnViewReorderablePropertyInfo = "reorderable"
    type AttrOrigin ColumnViewReorderablePropertyInfo = ColumnView
    attrGet = getColumnViewReorderable
    attrSet = setColumnViewReorderable
    attrTransfer _ v = do
        return v
    attrConstruct = constructColumnViewReorderable
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.ColumnView.reorderable"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-ColumnView.html#g:attr:reorderable"
        })
#endif

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

-- | Get the value of the “@show-column-separators@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' columnView #showColumnSeparators
-- @
getColumnViewShowColumnSeparators :: (MonadIO m, IsColumnView o) => o -> m Bool
getColumnViewShowColumnSeparators :: forall (m :: * -> *) o. (MonadIO m, IsColumnView o) => o -> m Bool
getColumnViewShowColumnSeparators o
obj = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"show-column-separators"

-- | Set the value of the “@show-column-separators@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' columnView [ #showColumnSeparators 'Data.GI.Base.Attributes.:=' value ]
-- @
setColumnViewShowColumnSeparators :: (MonadIO m, IsColumnView o) => o -> Bool -> m ()
setColumnViewShowColumnSeparators :: forall (m :: * -> *) o.
(MonadIO m, IsColumnView o) =>
o -> Bool -> m ()
setColumnViewShowColumnSeparators o
obj Bool
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"show-column-separators" Bool
val

-- | Construct a `GValueConstruct` with valid value for the “@show-column-separators@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructColumnViewShowColumnSeparators :: (IsColumnView o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructColumnViewShowColumnSeparators :: forall o (m :: * -> *).
(IsColumnView o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructColumnViewShowColumnSeparators Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"show-column-separators" Bool
val

#if defined(ENABLE_OVERLOADING)
data ColumnViewShowColumnSeparatorsPropertyInfo
instance AttrInfo ColumnViewShowColumnSeparatorsPropertyInfo where
    type AttrAllowedOps ColumnViewShowColumnSeparatorsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ColumnViewShowColumnSeparatorsPropertyInfo = IsColumnView
    type AttrSetTypeConstraint ColumnViewShowColumnSeparatorsPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint ColumnViewShowColumnSeparatorsPropertyInfo = (~) Bool
    type AttrTransferType ColumnViewShowColumnSeparatorsPropertyInfo = Bool
    type AttrGetType ColumnViewShowColumnSeparatorsPropertyInfo = Bool
    type AttrLabel ColumnViewShowColumnSeparatorsPropertyInfo = "show-column-separators"
    type AttrOrigin ColumnViewShowColumnSeparatorsPropertyInfo = ColumnView
    attrGet = getColumnViewShowColumnSeparators
    attrSet = setColumnViewShowColumnSeparators
    attrTransfer _ v = do
        return v
    attrConstruct = constructColumnViewShowColumnSeparators
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.ColumnView.showColumnSeparators"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-ColumnView.html#g:attr:showColumnSeparators"
        })
#endif

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

-- | Get the value of the “@show-row-separators@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' columnView #showRowSeparators
-- @
getColumnViewShowRowSeparators :: (MonadIO m, IsColumnView o) => o -> m Bool
getColumnViewShowRowSeparators :: forall (m :: * -> *) o. (MonadIO m, IsColumnView o) => o -> m Bool
getColumnViewShowRowSeparators o
obj = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"show-row-separators"

-- | Set the value of the “@show-row-separators@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' columnView [ #showRowSeparators 'Data.GI.Base.Attributes.:=' value ]
-- @
setColumnViewShowRowSeparators :: (MonadIO m, IsColumnView o) => o -> Bool -> m ()
setColumnViewShowRowSeparators :: forall (m :: * -> *) o.
(MonadIO m, IsColumnView o) =>
o -> Bool -> m ()
setColumnViewShowRowSeparators o
obj Bool
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"show-row-separators" Bool
val

-- | Construct a `GValueConstruct` with valid value for the “@show-row-separators@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructColumnViewShowRowSeparators :: (IsColumnView o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructColumnViewShowRowSeparators :: forall o (m :: * -> *).
(IsColumnView o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructColumnViewShowRowSeparators Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"show-row-separators" Bool
val

#if defined(ENABLE_OVERLOADING)
data ColumnViewShowRowSeparatorsPropertyInfo
instance AttrInfo ColumnViewShowRowSeparatorsPropertyInfo where
    type AttrAllowedOps ColumnViewShowRowSeparatorsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ColumnViewShowRowSeparatorsPropertyInfo = IsColumnView
    type AttrSetTypeConstraint ColumnViewShowRowSeparatorsPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint ColumnViewShowRowSeparatorsPropertyInfo = (~) Bool
    type AttrTransferType ColumnViewShowRowSeparatorsPropertyInfo = Bool
    type AttrGetType ColumnViewShowRowSeparatorsPropertyInfo = Bool
    type AttrLabel ColumnViewShowRowSeparatorsPropertyInfo = "show-row-separators"
    type AttrOrigin ColumnViewShowRowSeparatorsPropertyInfo = ColumnView
    attrGet = getColumnViewShowRowSeparators
    attrSet = setColumnViewShowRowSeparators
    attrTransfer _ v = do
        return v
    attrConstruct = constructColumnViewShowRowSeparators
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.ColumnView.showRowSeparators"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-ColumnView.html#g:attr:showRowSeparators"
        })
#endif

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

-- | Get the value of the “@single-click-activate@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' columnView #singleClickActivate
-- @
getColumnViewSingleClickActivate :: (MonadIO m, IsColumnView o) => o -> m Bool
getColumnViewSingleClickActivate :: forall (m :: * -> *) o. (MonadIO m, IsColumnView o) => o -> m Bool
getColumnViewSingleClickActivate o
obj = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"single-click-activate"

-- | Set the value of the “@single-click-activate@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' columnView [ #singleClickActivate 'Data.GI.Base.Attributes.:=' value ]
-- @
setColumnViewSingleClickActivate :: (MonadIO m, IsColumnView o) => o -> Bool -> m ()
setColumnViewSingleClickActivate :: forall (m :: * -> *) o.
(MonadIO m, IsColumnView o) =>
o -> Bool -> m ()
setColumnViewSingleClickActivate o
obj Bool
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"single-click-activate" Bool
val

-- | Construct a `GValueConstruct` with valid value for the “@single-click-activate@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructColumnViewSingleClickActivate :: (IsColumnView o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructColumnViewSingleClickActivate :: forall o (m :: * -> *).
(IsColumnView o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructColumnViewSingleClickActivate Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"single-click-activate" Bool
val

#if defined(ENABLE_OVERLOADING)
data ColumnViewSingleClickActivatePropertyInfo
instance AttrInfo ColumnViewSingleClickActivatePropertyInfo where
    type AttrAllowedOps ColumnViewSingleClickActivatePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ColumnViewSingleClickActivatePropertyInfo = IsColumnView
    type AttrSetTypeConstraint ColumnViewSingleClickActivatePropertyInfo = (~) Bool
    type AttrTransferTypeConstraint ColumnViewSingleClickActivatePropertyInfo = (~) Bool
    type AttrTransferType ColumnViewSingleClickActivatePropertyInfo = Bool
    type AttrGetType ColumnViewSingleClickActivatePropertyInfo = Bool
    type AttrLabel ColumnViewSingleClickActivatePropertyInfo = "single-click-activate"
    type AttrOrigin ColumnViewSingleClickActivatePropertyInfo = ColumnView
    attrGet = getColumnViewSingleClickActivate
    attrSet = setColumnViewSingleClickActivate
    attrTransfer _ v = do
        return v
    attrConstruct = constructColumnViewSingleClickActivate
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.ColumnView.singleClickActivate"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-ColumnView.html#g:attr:singleClickActivate"
        })
#endif

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

-- | Get the value of the “@sorter@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' columnView #sorter
-- @
getColumnViewSorter :: (MonadIO m, IsColumnView o) => o -> m (Maybe Gtk.Sorter.Sorter)
getColumnViewSorter :: forall (m :: * -> *) o.
(MonadIO m, IsColumnView o) =>
o -> m (Maybe Sorter)
getColumnViewSorter o
obj = IO (Maybe Sorter) -> m (Maybe Sorter)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe Sorter) -> m (Maybe Sorter))
-> IO (Maybe Sorter) -> m (Maybe Sorter)
forall a b. (a -> b) -> a -> b
$ o -> String -> (ManagedPtr Sorter -> Sorter) -> IO (Maybe Sorter)
forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj String
"sorter" ManagedPtr Sorter -> Sorter
Gtk.Sorter.Sorter

#if defined(ENABLE_OVERLOADING)
data ColumnViewSorterPropertyInfo
instance AttrInfo ColumnViewSorterPropertyInfo where
    type AttrAllowedOps ColumnViewSorterPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint ColumnViewSorterPropertyInfo = IsColumnView
    type AttrSetTypeConstraint ColumnViewSorterPropertyInfo = (~) ()
    type AttrTransferTypeConstraint ColumnViewSorterPropertyInfo = (~) ()
    type AttrTransferType ColumnViewSorterPropertyInfo = ()
    type AttrGetType ColumnViewSorterPropertyInfo = (Maybe Gtk.Sorter.Sorter)
    type AttrLabel ColumnViewSorterPropertyInfo = "sorter"
    type AttrOrigin ColumnViewSorterPropertyInfo = ColumnView
    attrGet = getColumnViewSorter
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.ColumnView.sorter"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-ColumnView.html#g:attr:sorter"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList ColumnView
type instance O.AttributeList ColumnView = ColumnViewAttributeList
type ColumnViewAttributeList = ('[ '("accessibleRole", Gtk.Accessible.AccessibleAccessibleRolePropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("canTarget", Gtk.Widget.WidgetCanTargetPropertyInfo), '("columns", ColumnViewColumnsPropertyInfo), '("cssClasses", Gtk.Widget.WidgetCssClassesPropertyInfo), '("cssName", Gtk.Widget.WidgetCssNamePropertyInfo), '("cursor", Gtk.Widget.WidgetCursorPropertyInfo), '("enableRubberband", ColumnViewEnableRubberbandPropertyInfo), '("focusOnClick", Gtk.Widget.WidgetFocusOnClickPropertyInfo), '("focusable", Gtk.Widget.WidgetFocusablePropertyInfo), '("hadjustment", Gtk.Scrollable.ScrollableHadjustmentPropertyInfo), '("halign", Gtk.Widget.WidgetHalignPropertyInfo), '("hasDefault", Gtk.Widget.WidgetHasDefaultPropertyInfo), '("hasFocus", Gtk.Widget.WidgetHasFocusPropertyInfo), '("hasTooltip", Gtk.Widget.WidgetHasTooltipPropertyInfo), '("heightRequest", Gtk.Widget.WidgetHeightRequestPropertyInfo), '("hexpand", Gtk.Widget.WidgetHexpandPropertyInfo), '("hexpandSet", Gtk.Widget.WidgetHexpandSetPropertyInfo), '("hscrollPolicy", Gtk.Scrollable.ScrollableHscrollPolicyPropertyInfo), '("layoutManager", Gtk.Widget.WidgetLayoutManagerPropertyInfo), '("marginBottom", Gtk.Widget.WidgetMarginBottomPropertyInfo), '("marginEnd", Gtk.Widget.WidgetMarginEndPropertyInfo), '("marginStart", Gtk.Widget.WidgetMarginStartPropertyInfo), '("marginTop", Gtk.Widget.WidgetMarginTopPropertyInfo), '("model", ColumnViewModelPropertyInfo), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("overflow", Gtk.Widget.WidgetOverflowPropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("reorderable", ColumnViewReorderablePropertyInfo), '("root", Gtk.Widget.WidgetRootPropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("showColumnSeparators", ColumnViewShowColumnSeparatorsPropertyInfo), '("showRowSeparators", ColumnViewShowRowSeparatorsPropertyInfo), '("singleClickActivate", ColumnViewSingleClickActivatePropertyInfo), '("sorter", ColumnViewSorterPropertyInfo), '("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)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
columnViewColumns :: AttrLabelProxy "columns"
columnViewColumns = AttrLabelProxy

columnViewEnableRubberband :: AttrLabelProxy "enableRubberband"
columnViewEnableRubberband = AttrLabelProxy

columnViewModel :: AttrLabelProxy "model"
columnViewModel = AttrLabelProxy

columnViewReorderable :: AttrLabelProxy "reorderable"
columnViewReorderable = AttrLabelProxy

columnViewShowColumnSeparators :: AttrLabelProxy "showColumnSeparators"
columnViewShowColumnSeparators = AttrLabelProxy

columnViewShowRowSeparators :: AttrLabelProxy "showRowSeparators"
columnViewShowRowSeparators = AttrLabelProxy

columnViewSingleClickActivate :: AttrLabelProxy "singleClickActivate"
columnViewSingleClickActivate = AttrLabelProxy

columnViewSorter :: AttrLabelProxy "sorter"
columnViewSorter = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList ColumnView = ColumnViewSignalList
type ColumnViewSignalList = ('[ '("activate", ColumnViewActivateSignalInfo), '("destroy", Gtk.Widget.WidgetDestroySignalInfo), '("directionChanged", Gtk.Widget.WidgetDirectionChangedSignalInfo), '("hide", Gtk.Widget.WidgetHideSignalInfo), '("keynavFailed", Gtk.Widget.WidgetKeynavFailedSignalInfo), '("map", Gtk.Widget.WidgetMapSignalInfo), '("mnemonicActivate", Gtk.Widget.WidgetMnemonicActivateSignalInfo), '("moveFocus", Gtk.Widget.WidgetMoveFocusSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("queryTooltip", Gtk.Widget.WidgetQueryTooltipSignalInfo), '("realize", Gtk.Widget.WidgetRealizeSignalInfo), '("show", Gtk.Widget.WidgetShowSignalInfo), '("stateFlagsChanged", Gtk.Widget.WidgetStateFlagsChangedSignalInfo), '("unmap", Gtk.Widget.WidgetUnmapSignalInfo), '("unrealize", Gtk.Widget.WidgetUnrealizeSignalInfo)] :: [(Symbol, *)])

#endif

-- method ColumnView::new
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "model"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "SelectionModel" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the list model to use"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gtk" , name = "ColumnView" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_column_view_new" gtk_column_view_new :: 
    Ptr Gtk.SelectionModel.SelectionModel -> -- model : TInterface (Name {namespace = "Gtk", name = "SelectionModel"})
    IO (Ptr ColumnView)

-- | Creates a new @GtkColumnView@.
-- 
-- You most likely want to call 'GI.Gtk.Objects.ColumnView.columnViewAppendColumn'
-- to add columns next.
columnViewNew ::
    (B.CallStack.HasCallStack, MonadIO m, Gtk.SelectionModel.IsSelectionModel a) =>
    Maybe (a)
    -- ^ /@model@/: the list model to use
    -> m ColumnView
    -- ^ __Returns:__ a new @GtkColumnView@
columnViewNew :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSelectionModel a) =>
Maybe a -> m ColumnView
columnViewNew Maybe a
model = IO ColumnView -> m ColumnView
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ColumnView -> m ColumnView) -> IO ColumnView -> m ColumnView
forall a b. (a -> b) -> a -> b
$ do
    Ptr SelectionModel
maybeModel <- case Maybe a
model of
        Maybe a
Nothing -> Ptr SelectionModel -> IO (Ptr SelectionModel)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr SelectionModel
forall a. Ptr a
nullPtr
        Just a
jModel -> do
            Ptr SelectionModel
jModel' <- a -> IO (Ptr SelectionModel)
forall a b. (HasCallStack, GObject a) => a -> IO (Ptr b)
B.ManagedPtr.disownObject a
jModel
            Ptr SelectionModel -> IO (Ptr SelectionModel)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr SelectionModel
jModel'
    Ptr ColumnView
result <- Ptr SelectionModel -> IO (Ptr ColumnView)
gtk_column_view_new Ptr SelectionModel
maybeModel
    Text -> Ptr ColumnView -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"columnViewNew" Ptr ColumnView
result
    ColumnView
result' <- ((ManagedPtr ColumnView -> ColumnView)
-> Ptr ColumnView -> IO ColumnView
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr ColumnView -> ColumnView
ColumnView) Ptr ColumnView
result
    Maybe a -> (a -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe a
model a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    ColumnView -> IO ColumnView
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ColumnView
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method ColumnView::append_column
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "ColumnView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkColumnView`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "column"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "ColumnViewColumn" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "a `GtkColumnViewColumn` that hasn't been added to a\n  `GtkColumnView` yet"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_column_view_append_column" gtk_column_view_append_column :: 
    Ptr ColumnView ->                       -- self : TInterface (Name {namespace = "Gtk", name = "ColumnView"})
    Ptr Gtk.ColumnViewColumn.ColumnViewColumn -> -- column : TInterface (Name {namespace = "Gtk", name = "ColumnViewColumn"})
    IO ()

-- | Appends the /@column@/ to the end of the columns in /@self@/.
columnViewAppendColumn ::
    (B.CallStack.HasCallStack, MonadIO m, IsColumnView a, Gtk.ColumnViewColumn.IsColumnViewColumn b) =>
    a
    -- ^ /@self@/: a @GtkColumnView@
    -> b
    -- ^ /@column@/: a @GtkColumnViewColumn@ that hasn\'t been added to a
    --   @GtkColumnView@ yet
    -> m ()
columnViewAppendColumn :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsColumnView a, IsColumnViewColumn b) =>
a -> b -> m ()
columnViewAppendColumn a
self b
column = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr ColumnView
self' <- a -> IO (Ptr ColumnView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr ColumnViewColumn
column' <- b -> IO (Ptr ColumnViewColumn)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
column
    Ptr ColumnView -> Ptr ColumnViewColumn -> IO ()
gtk_column_view_append_column Ptr ColumnView
self' Ptr ColumnViewColumn
column'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
column
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ColumnViewAppendColumnMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsColumnView a, Gtk.ColumnViewColumn.IsColumnViewColumn b) => O.OverloadedMethod ColumnViewAppendColumnMethodInfo a signature where
    overloadedMethod = columnViewAppendColumn

instance O.OverloadedMethodInfo ColumnViewAppendColumnMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.ColumnView.columnViewAppendColumn",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-ColumnView.html#v:columnViewAppendColumn"
        })


#endif

-- method ColumnView::get_columns
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "ColumnView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkColumnView`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gio" , name = "ListModel" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_column_view_get_columns" gtk_column_view_get_columns :: 
    Ptr ColumnView ->                       -- self : TInterface (Name {namespace = "Gtk", name = "ColumnView"})
    IO (Ptr Gio.ListModel.ListModel)

-- | Gets the list of columns in this column view.
-- 
-- This list is constant over the lifetime of /@self@/ and can be used to
-- monitor changes to the columns of /@self@/ by connecting to the
-- [itemsChanged](#g:signal:itemsChanged) signal.
columnViewGetColumns ::
    (B.CallStack.HasCallStack, MonadIO m, IsColumnView a) =>
    a
    -- ^ /@self@/: a @GtkColumnView@
    -> m Gio.ListModel.ListModel
    -- ^ __Returns:__ The list managing the columns
columnViewGetColumns :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsColumnView a) =>
a -> m ListModel
columnViewGetColumns a
self = IO ListModel -> m ListModel
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ListModel -> m ListModel) -> IO ListModel -> m ListModel
forall a b. (a -> b) -> a -> b
$ do
    Ptr ColumnView
self' <- a -> IO (Ptr ColumnView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr ListModel
result <- Ptr ColumnView -> IO (Ptr ListModel)
gtk_column_view_get_columns Ptr ColumnView
self'
    Text -> Ptr ListModel -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"columnViewGetColumns" Ptr ListModel
result
    ListModel
result' <- ((ManagedPtr ListModel -> ListModel)
-> Ptr ListModel -> IO ListModel
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr ListModel -> ListModel
Gio.ListModel.ListModel) Ptr ListModel
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    ListModel -> IO ListModel
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ListModel
result'

#if defined(ENABLE_OVERLOADING)
data ColumnViewGetColumnsMethodInfo
instance (signature ~ (m Gio.ListModel.ListModel), MonadIO m, IsColumnView a) => O.OverloadedMethod ColumnViewGetColumnsMethodInfo a signature where
    overloadedMethod = columnViewGetColumns

instance O.OverloadedMethodInfo ColumnViewGetColumnsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.ColumnView.columnViewGetColumns",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-ColumnView.html#v:columnViewGetColumns"
        })


#endif

-- method ColumnView::get_enable_rubberband
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "ColumnView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkColumnView`" , 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_column_view_get_enable_rubberband" gtk_column_view_get_enable_rubberband :: 
    Ptr ColumnView ->                       -- self : TInterface (Name {namespace = "Gtk", name = "ColumnView"})
    IO CInt

-- | Returns whether rows can be selected by dragging with the mouse.
columnViewGetEnableRubberband ::
    (B.CallStack.HasCallStack, MonadIO m, IsColumnView a) =>
    a
    -- ^ /@self@/: a @GtkColumnView@
    -> m Bool
    -- ^ __Returns:__ 'P.True' if rubberband selection is enabled
columnViewGetEnableRubberband :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsColumnView a) =>
a -> m Bool
columnViewGetEnableRubberband a
self = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr ColumnView
self' <- a -> IO (Ptr ColumnView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr ColumnView -> IO CInt
gtk_column_view_get_enable_rubberband Ptr ColumnView
self'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data ColumnViewGetEnableRubberbandMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsColumnView a) => O.OverloadedMethod ColumnViewGetEnableRubberbandMethodInfo a signature where
    overloadedMethod = columnViewGetEnableRubberband

instance O.OverloadedMethodInfo ColumnViewGetEnableRubberbandMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.ColumnView.columnViewGetEnableRubberband",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-ColumnView.html#v:columnViewGetEnableRubberband"
        })


#endif

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

foreign import ccall "gtk_column_view_get_model" gtk_column_view_get_model :: 
    Ptr ColumnView ->                       -- self : TInterface (Name {namespace = "Gtk", name = "ColumnView"})
    IO (Ptr Gtk.SelectionModel.SelectionModel)

-- | Gets the model that\'s currently used to read the items displayed.
columnViewGetModel ::
    (B.CallStack.HasCallStack, MonadIO m, IsColumnView a) =>
    a
    -- ^ /@self@/: a @GtkColumnView@
    -> m (Maybe Gtk.SelectionModel.SelectionModel)
    -- ^ __Returns:__ The model in use
columnViewGetModel :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsColumnView a) =>
a -> m (Maybe SelectionModel)
columnViewGetModel a
self = IO (Maybe SelectionModel) -> m (Maybe SelectionModel)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe SelectionModel) -> m (Maybe SelectionModel))
-> IO (Maybe SelectionModel) -> m (Maybe SelectionModel)
forall a b. (a -> b) -> a -> b
$ do
    Ptr ColumnView
self' <- a -> IO (Ptr ColumnView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr SelectionModel
result <- Ptr ColumnView -> IO (Ptr SelectionModel)
gtk_column_view_get_model Ptr ColumnView
self'
    Maybe SelectionModel
maybeResult <- Ptr SelectionModel
-> (Ptr SelectionModel -> IO SelectionModel)
-> IO (Maybe SelectionModel)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr SelectionModel
result ((Ptr SelectionModel -> IO SelectionModel)
 -> IO (Maybe SelectionModel))
-> (Ptr SelectionModel -> IO SelectionModel)
-> IO (Maybe SelectionModel)
forall a b. (a -> b) -> a -> b
$ \Ptr SelectionModel
result' -> do
        SelectionModel
result'' <- ((ManagedPtr SelectionModel -> SelectionModel)
-> Ptr SelectionModel -> IO SelectionModel
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr SelectionModel -> SelectionModel
Gtk.SelectionModel.SelectionModel) Ptr SelectionModel
result'
        SelectionModel -> IO SelectionModel
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return SelectionModel
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe SelectionModel -> IO (Maybe SelectionModel)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe SelectionModel
maybeResult

#if defined(ENABLE_OVERLOADING)
data ColumnViewGetModelMethodInfo
instance (signature ~ (m (Maybe Gtk.SelectionModel.SelectionModel)), MonadIO m, IsColumnView a) => O.OverloadedMethod ColumnViewGetModelMethodInfo a signature where
    overloadedMethod = columnViewGetModel

instance O.OverloadedMethodInfo ColumnViewGetModelMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.ColumnView.columnViewGetModel",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-ColumnView.html#v:columnViewGetModel"
        })


#endif

-- method ColumnView::get_reorderable
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "ColumnView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkColumnView`" , 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_column_view_get_reorderable" gtk_column_view_get_reorderable :: 
    Ptr ColumnView ->                       -- self : TInterface (Name {namespace = "Gtk", name = "ColumnView"})
    IO CInt

-- | Returns whether columns are reorderable.
columnViewGetReorderable ::
    (B.CallStack.HasCallStack, MonadIO m, IsColumnView a) =>
    a
    -- ^ /@self@/: a @GtkColumnView@
    -> m Bool
    -- ^ __Returns:__ 'P.True' if columns are reorderable
columnViewGetReorderable :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsColumnView a) =>
a -> m Bool
columnViewGetReorderable a
self = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr ColumnView
self' <- a -> IO (Ptr ColumnView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr ColumnView -> IO CInt
gtk_column_view_get_reorderable Ptr ColumnView
self'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data ColumnViewGetReorderableMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsColumnView a) => O.OverloadedMethod ColumnViewGetReorderableMethodInfo a signature where
    overloadedMethod = columnViewGetReorderable

instance O.OverloadedMethodInfo ColumnViewGetReorderableMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.ColumnView.columnViewGetReorderable",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-ColumnView.html#v:columnViewGetReorderable"
        })


#endif

-- method ColumnView::get_show_column_separators
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "ColumnView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkColumnView`" , 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_column_view_get_show_column_separators" gtk_column_view_get_show_column_separators :: 
    Ptr ColumnView ->                       -- self : TInterface (Name {namespace = "Gtk", name = "ColumnView"})
    IO CInt

-- | Returns whether the list should show separators
-- between columns.
columnViewGetShowColumnSeparators ::
    (B.CallStack.HasCallStack, MonadIO m, IsColumnView a) =>
    a
    -- ^ /@self@/: a @GtkColumnView@
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the list shows column separators
columnViewGetShowColumnSeparators :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsColumnView a) =>
a -> m Bool
columnViewGetShowColumnSeparators a
self = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr ColumnView
self' <- a -> IO (Ptr ColumnView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr ColumnView -> IO CInt
gtk_column_view_get_show_column_separators Ptr ColumnView
self'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data ColumnViewGetShowColumnSeparatorsMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsColumnView a) => O.OverloadedMethod ColumnViewGetShowColumnSeparatorsMethodInfo a signature where
    overloadedMethod = columnViewGetShowColumnSeparators

instance O.OverloadedMethodInfo ColumnViewGetShowColumnSeparatorsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.ColumnView.columnViewGetShowColumnSeparators",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-ColumnView.html#v:columnViewGetShowColumnSeparators"
        })


#endif

-- method ColumnView::get_show_row_separators
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "ColumnView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkColumnView`" , 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_column_view_get_show_row_separators" gtk_column_view_get_show_row_separators :: 
    Ptr ColumnView ->                       -- self : TInterface (Name {namespace = "Gtk", name = "ColumnView"})
    IO CInt

-- | Returns whether the list should show separators
-- between rows.
columnViewGetShowRowSeparators ::
    (B.CallStack.HasCallStack, MonadIO m, IsColumnView a) =>
    a
    -- ^ /@self@/: a @GtkColumnView@
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the list shows separators
columnViewGetShowRowSeparators :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsColumnView a) =>
a -> m Bool
columnViewGetShowRowSeparators a
self = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr ColumnView
self' <- a -> IO (Ptr ColumnView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr ColumnView -> IO CInt
gtk_column_view_get_show_row_separators Ptr ColumnView
self'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data ColumnViewGetShowRowSeparatorsMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsColumnView a) => O.OverloadedMethod ColumnViewGetShowRowSeparatorsMethodInfo a signature where
    overloadedMethod = columnViewGetShowRowSeparators

instance O.OverloadedMethodInfo ColumnViewGetShowRowSeparatorsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.ColumnView.columnViewGetShowRowSeparators",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-ColumnView.html#v:columnViewGetShowRowSeparators"
        })


#endif

-- method ColumnView::get_single_click_activate
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "ColumnView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkColumnView`" , 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_column_view_get_single_click_activate" gtk_column_view_get_single_click_activate :: 
    Ptr ColumnView ->                       -- self : TInterface (Name {namespace = "Gtk", name = "ColumnView"})
    IO CInt

-- | Returns whether rows will be activated on single click and
-- selected on hover.
columnViewGetSingleClickActivate ::
    (B.CallStack.HasCallStack, MonadIO m, IsColumnView a) =>
    a
    -- ^ /@self@/: a @GtkColumnView@
    -> m Bool
    -- ^ __Returns:__ 'P.True' if rows are activated on single click
columnViewGetSingleClickActivate :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsColumnView a) =>
a -> m Bool
columnViewGetSingleClickActivate a
self = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr ColumnView
self' <- a -> IO (Ptr ColumnView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr ColumnView -> IO CInt
gtk_column_view_get_single_click_activate Ptr ColumnView
self'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data ColumnViewGetSingleClickActivateMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsColumnView a) => O.OverloadedMethod ColumnViewGetSingleClickActivateMethodInfo a signature where
    overloadedMethod = columnViewGetSingleClickActivate

instance O.OverloadedMethodInfo ColumnViewGetSingleClickActivateMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.ColumnView.columnViewGetSingleClickActivate",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-ColumnView.html#v:columnViewGetSingleClickActivate"
        })


#endif

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

foreign import ccall "gtk_column_view_get_sorter" gtk_column_view_get_sorter :: 
    Ptr ColumnView ->                       -- self : TInterface (Name {namespace = "Gtk", name = "ColumnView"})
    IO (Ptr Gtk.Sorter.Sorter)

-- | Returns a special sorter that reflects the users sorting
-- choices in the column view.
-- 
-- To allow users to customizable sorting by clicking on column
-- headers, this sorter needs to be set on the sort model underneath
-- the model that is displayed by the view.
-- 
-- See 'GI.Gtk.Objects.ColumnViewColumn.columnViewColumnSetSorter' for setting up
-- per-column sorting.
-- 
-- Here is an example:
-- 
-- === /c code/
-- >gtk_column_view_column_set_sorter (column, sorter);
-- >gtk_column_view_append_column (view, column);
-- >sorter = g_object_ref (gtk_column_view_get_sorter (view)));
-- >model = gtk_sort_list_model_new (store, sorter);
-- >selection = gtk_no_selection_new (model);
-- >gtk_column_view_set_model (view, selection);
columnViewGetSorter ::
    (B.CallStack.HasCallStack, MonadIO m, IsColumnView a) =>
    a
    -- ^ /@self@/: a @GtkColumnView@
    -> m (Maybe Gtk.Sorter.Sorter)
    -- ^ __Returns:__ the @GtkSorter@ of /@self@/
columnViewGetSorter :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsColumnView a) =>
a -> m (Maybe Sorter)
columnViewGetSorter a
self = IO (Maybe Sorter) -> m (Maybe Sorter)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Sorter) -> m (Maybe Sorter))
-> IO (Maybe Sorter) -> m (Maybe Sorter)
forall a b. (a -> b) -> a -> b
$ do
    Ptr ColumnView
self' <- a -> IO (Ptr ColumnView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Sorter
result <- Ptr ColumnView -> IO (Ptr Sorter)
gtk_column_view_get_sorter Ptr ColumnView
self'
    Maybe Sorter
maybeResult <- Ptr Sorter -> (Ptr Sorter -> IO Sorter) -> IO (Maybe Sorter)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Sorter
result ((Ptr Sorter -> IO Sorter) -> IO (Maybe Sorter))
-> (Ptr Sorter -> IO Sorter) -> IO (Maybe Sorter)
forall a b. (a -> b) -> a -> b
$ \Ptr Sorter
result' -> do
        Sorter
result'' <- ((ManagedPtr Sorter -> Sorter) -> Ptr Sorter -> IO Sorter
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Sorter -> Sorter
Gtk.Sorter.Sorter) Ptr Sorter
result'
        Sorter -> IO Sorter
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Sorter
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe Sorter -> IO (Maybe Sorter)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Sorter
maybeResult

#if defined(ENABLE_OVERLOADING)
data ColumnViewGetSorterMethodInfo
instance (signature ~ (m (Maybe Gtk.Sorter.Sorter)), MonadIO m, IsColumnView a) => O.OverloadedMethod ColumnViewGetSorterMethodInfo a signature where
    overloadedMethod = columnViewGetSorter

instance O.OverloadedMethodInfo ColumnViewGetSorterMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.ColumnView.columnViewGetSorter",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-ColumnView.html#v:columnViewGetSorter"
        })


#endif

-- method ColumnView::insert_column
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "ColumnView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkColumnView`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "position"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the position to insert @column at"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "column"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "ColumnViewColumn" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the `GtkColumnViewColumn` to insert"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_column_view_insert_column" gtk_column_view_insert_column :: 
    Ptr ColumnView ->                       -- self : TInterface (Name {namespace = "Gtk", name = "ColumnView"})
    Word32 ->                               -- position : TBasicType TUInt
    Ptr Gtk.ColumnViewColumn.ColumnViewColumn -> -- column : TInterface (Name {namespace = "Gtk", name = "ColumnViewColumn"})
    IO ()

-- | Inserts a column at the given position in the columns of /@self@/.
-- 
-- If /@column@/ is already a column of /@self@/, it will be repositioned.
columnViewInsertColumn ::
    (B.CallStack.HasCallStack, MonadIO m, IsColumnView a, Gtk.ColumnViewColumn.IsColumnViewColumn b) =>
    a
    -- ^ /@self@/: a @GtkColumnView@
    -> Word32
    -- ^ /@position@/: the position to insert /@column@/ at
    -> b
    -- ^ /@column@/: the @GtkColumnViewColumn@ to insert
    -> m ()
columnViewInsertColumn :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsColumnView a, IsColumnViewColumn b) =>
a -> Word32 -> b -> m ()
columnViewInsertColumn a
self Word32
position b
column = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr ColumnView
self' <- a -> IO (Ptr ColumnView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr ColumnViewColumn
column' <- b -> IO (Ptr ColumnViewColumn)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
column
    Ptr ColumnView -> Word32 -> Ptr ColumnViewColumn -> IO ()
gtk_column_view_insert_column Ptr ColumnView
self' Word32
position Ptr ColumnViewColumn
column'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
column
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ColumnViewInsertColumnMethodInfo
instance (signature ~ (Word32 -> b -> m ()), MonadIO m, IsColumnView a, Gtk.ColumnViewColumn.IsColumnViewColumn b) => O.OverloadedMethod ColumnViewInsertColumnMethodInfo a signature where
    overloadedMethod = columnViewInsertColumn

instance O.OverloadedMethodInfo ColumnViewInsertColumnMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.ColumnView.columnViewInsertColumn",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-ColumnView.html#v:columnViewInsertColumn"
        })


#endif

-- method ColumnView::remove_column
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "ColumnView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkColumnView`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "column"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "ColumnViewColumn" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkColumnViewColumn` that's part of @self"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_column_view_remove_column" gtk_column_view_remove_column :: 
    Ptr ColumnView ->                       -- self : TInterface (Name {namespace = "Gtk", name = "ColumnView"})
    Ptr Gtk.ColumnViewColumn.ColumnViewColumn -> -- column : TInterface (Name {namespace = "Gtk", name = "ColumnViewColumn"})
    IO ()

-- | Removes the /@column@/ from the list of columns of /@self@/.
columnViewRemoveColumn ::
    (B.CallStack.HasCallStack, MonadIO m, IsColumnView a, Gtk.ColumnViewColumn.IsColumnViewColumn b) =>
    a
    -- ^ /@self@/: a @GtkColumnView@
    -> b
    -- ^ /@column@/: a @GtkColumnViewColumn@ that\'s part of /@self@/
    -> m ()
columnViewRemoveColumn :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsColumnView a, IsColumnViewColumn b) =>
a -> b -> m ()
columnViewRemoveColumn a
self b
column = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr ColumnView
self' <- a -> IO (Ptr ColumnView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr ColumnViewColumn
column' <- b -> IO (Ptr ColumnViewColumn)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
column
    Ptr ColumnView -> Ptr ColumnViewColumn -> IO ()
gtk_column_view_remove_column Ptr ColumnView
self' Ptr ColumnViewColumn
column'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
column
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ColumnViewRemoveColumnMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsColumnView a, Gtk.ColumnViewColumn.IsColumnViewColumn b) => O.OverloadedMethod ColumnViewRemoveColumnMethodInfo a signature where
    overloadedMethod = columnViewRemoveColumn

instance O.OverloadedMethodInfo ColumnViewRemoveColumnMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.ColumnView.columnViewRemoveColumn",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-ColumnView.html#v:columnViewRemoveColumn"
        })


#endif

-- method ColumnView::set_enable_rubberband
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "ColumnView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkColumnView`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "enable_rubberband"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "%TRUE to enable rubberband selection"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_column_view_set_enable_rubberband" gtk_column_view_set_enable_rubberband :: 
    Ptr ColumnView ->                       -- self : TInterface (Name {namespace = "Gtk", name = "ColumnView"})
    CInt ->                                 -- enable_rubberband : TBasicType TBoolean
    IO ()

-- | Sets whether selections can be changed by dragging with the mouse.
columnViewSetEnableRubberband ::
    (B.CallStack.HasCallStack, MonadIO m, IsColumnView a) =>
    a
    -- ^ /@self@/: a @GtkColumnView@
    -> Bool
    -- ^ /@enableRubberband@/: 'P.True' to enable rubberband selection
    -> m ()
columnViewSetEnableRubberband :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsColumnView a) =>
a -> Bool -> m ()
columnViewSetEnableRubberband a
self Bool
enableRubberband = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr ColumnView
self' <- a -> IO (Ptr ColumnView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let enableRubberband' :: CInt
enableRubberband' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
enableRubberband
    Ptr ColumnView -> CInt -> IO ()
gtk_column_view_set_enable_rubberband Ptr ColumnView
self' CInt
enableRubberband'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ColumnViewSetEnableRubberbandMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsColumnView a) => O.OverloadedMethod ColumnViewSetEnableRubberbandMethodInfo a signature where
    overloadedMethod = columnViewSetEnableRubberband

instance O.OverloadedMethodInfo ColumnViewSetEnableRubberbandMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.ColumnView.columnViewSetEnableRubberband",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-ColumnView.html#v:columnViewSetEnableRubberband"
        })


#endif

-- method ColumnView::set_model
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "ColumnView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkColumnView`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "model"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "SelectionModel" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the model to use" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_column_view_set_model" gtk_column_view_set_model :: 
    Ptr ColumnView ->                       -- self : TInterface (Name {namespace = "Gtk", name = "ColumnView"})
    Ptr Gtk.SelectionModel.SelectionModel -> -- model : TInterface (Name {namespace = "Gtk", name = "SelectionModel"})
    IO ()

-- | Sets the model to use.
-- 
-- This must be a t'GI.Gtk.Interfaces.SelectionModel.SelectionModel'.
columnViewSetModel ::
    (B.CallStack.HasCallStack, MonadIO m, IsColumnView a, Gtk.SelectionModel.IsSelectionModel b) =>
    a
    -- ^ /@self@/: a @GtkColumnView@
    -> Maybe (b)
    -- ^ /@model@/: the model to use
    -> m ()
columnViewSetModel :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsColumnView a, IsSelectionModel b) =>
a -> Maybe b -> m ()
columnViewSetModel a
self Maybe b
model = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr ColumnView
self' <- a -> IO (Ptr ColumnView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr SelectionModel
maybeModel <- case Maybe b
model of
        Maybe b
Nothing -> Ptr SelectionModel -> IO (Ptr SelectionModel)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr SelectionModel
forall a. Ptr a
nullPtr
        Just b
jModel -> do
            Ptr SelectionModel
jModel' <- b -> IO (Ptr SelectionModel)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jModel
            Ptr SelectionModel -> IO (Ptr SelectionModel)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr SelectionModel
jModel'
    Ptr ColumnView -> Ptr SelectionModel -> IO ()
gtk_column_view_set_model Ptr ColumnView
self' Ptr SelectionModel
maybeModel
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
model b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ColumnViewSetModelMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsColumnView a, Gtk.SelectionModel.IsSelectionModel b) => O.OverloadedMethod ColumnViewSetModelMethodInfo a signature where
    overloadedMethod = columnViewSetModel

instance O.OverloadedMethodInfo ColumnViewSetModelMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.ColumnView.columnViewSetModel",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-ColumnView.html#v:columnViewSetModel"
        })


#endif

-- method ColumnView::set_reorderable
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "ColumnView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkColumnView`" , 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 "whether columns should be reorderable"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

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

-- | Sets whether columns should be reorderable by dragging.
columnViewSetReorderable ::
    (B.CallStack.HasCallStack, MonadIO m, IsColumnView a) =>
    a
    -- ^ /@self@/: a @GtkColumnView@
    -> Bool
    -- ^ /@reorderable@/: whether columns should be reorderable
    -> m ()
columnViewSetReorderable :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsColumnView a) =>
a -> Bool -> m ()
columnViewSetReorderable a
self Bool
reorderable = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr ColumnView
self' <- a -> IO (Ptr ColumnView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let reorderable' :: CInt
reorderable' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
reorderable
    Ptr ColumnView -> CInt -> IO ()
gtk_column_view_set_reorderable Ptr ColumnView
self' CInt
reorderable'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ColumnViewSetReorderableMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsColumnView a) => O.OverloadedMethod ColumnViewSetReorderableMethodInfo a signature where
    overloadedMethod = columnViewSetReorderable

instance O.OverloadedMethodInfo ColumnViewSetReorderableMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.ColumnView.columnViewSetReorderable",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-ColumnView.html#v:columnViewSetReorderable"
        })


#endif

-- method ColumnView::set_show_column_separators
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "ColumnView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkColumnView`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "show_column_separators"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "%TRUE to show column separators"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_column_view_set_show_column_separators" gtk_column_view_set_show_column_separators :: 
    Ptr ColumnView ->                       -- self : TInterface (Name {namespace = "Gtk", name = "ColumnView"})
    CInt ->                                 -- show_column_separators : TBasicType TBoolean
    IO ()

-- | Sets whether the list should show separators
-- between columns.
columnViewSetShowColumnSeparators ::
    (B.CallStack.HasCallStack, MonadIO m, IsColumnView a) =>
    a
    -- ^ /@self@/: a @GtkColumnView@
    -> Bool
    -- ^ /@showColumnSeparators@/: 'P.True' to show column separators
    -> m ()
columnViewSetShowColumnSeparators :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsColumnView a) =>
a -> Bool -> m ()
columnViewSetShowColumnSeparators a
self Bool
showColumnSeparators = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr ColumnView
self' <- a -> IO (Ptr ColumnView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let showColumnSeparators' :: CInt
showColumnSeparators' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
showColumnSeparators
    Ptr ColumnView -> CInt -> IO ()
gtk_column_view_set_show_column_separators Ptr ColumnView
self' CInt
showColumnSeparators'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ColumnViewSetShowColumnSeparatorsMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsColumnView a) => O.OverloadedMethod ColumnViewSetShowColumnSeparatorsMethodInfo a signature where
    overloadedMethod = columnViewSetShowColumnSeparators

instance O.OverloadedMethodInfo ColumnViewSetShowColumnSeparatorsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.ColumnView.columnViewSetShowColumnSeparators",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-ColumnView.html#v:columnViewSetShowColumnSeparators"
        })


#endif

-- method ColumnView::set_show_row_separators
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "ColumnView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkColumnView`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "show_row_separators"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "%TRUE to show row separators"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_column_view_set_show_row_separators" gtk_column_view_set_show_row_separators :: 
    Ptr ColumnView ->                       -- self : TInterface (Name {namespace = "Gtk", name = "ColumnView"})
    CInt ->                                 -- show_row_separators : TBasicType TBoolean
    IO ()

-- | Sets whether the list should show separators
-- between rows.
columnViewSetShowRowSeparators ::
    (B.CallStack.HasCallStack, MonadIO m, IsColumnView a) =>
    a
    -- ^ /@self@/: a @GtkColumnView@
    -> Bool
    -- ^ /@showRowSeparators@/: 'P.True' to show row separators
    -> m ()
columnViewSetShowRowSeparators :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsColumnView a) =>
a -> Bool -> m ()
columnViewSetShowRowSeparators a
self Bool
showRowSeparators = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr ColumnView
self' <- a -> IO (Ptr ColumnView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let showRowSeparators' :: CInt
showRowSeparators' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
showRowSeparators
    Ptr ColumnView -> CInt -> IO ()
gtk_column_view_set_show_row_separators Ptr ColumnView
self' CInt
showRowSeparators'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ColumnViewSetShowRowSeparatorsMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsColumnView a) => O.OverloadedMethod ColumnViewSetShowRowSeparatorsMethodInfo a signature where
    overloadedMethod = columnViewSetShowRowSeparators

instance O.OverloadedMethodInfo ColumnViewSetShowRowSeparatorsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.ColumnView.columnViewSetShowRowSeparators",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-ColumnView.html#v:columnViewSetShowRowSeparators"
        })


#endif

-- method ColumnView::set_single_click_activate
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "ColumnView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkColumnView`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "single_click_activate"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "%TRUE to activate items on 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_column_view_set_single_click_activate" gtk_column_view_set_single_click_activate :: 
    Ptr ColumnView ->                       -- self : TInterface (Name {namespace = "Gtk", name = "ColumnView"})
    CInt ->                                 -- single_click_activate : TBasicType TBoolean
    IO ()

-- | Sets whether rows should be activated on single click and
-- selected on hover.
columnViewSetSingleClickActivate ::
    (B.CallStack.HasCallStack, MonadIO m, IsColumnView a) =>
    a
    -- ^ /@self@/: a @GtkColumnView@
    -> Bool
    -- ^ /@singleClickActivate@/: 'P.True' to activate items on single click
    -> m ()
columnViewSetSingleClickActivate :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsColumnView a) =>
a -> Bool -> m ()
columnViewSetSingleClickActivate a
self Bool
singleClickActivate = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr ColumnView
self' <- a -> IO (Ptr ColumnView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let singleClickActivate' :: CInt
singleClickActivate' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
singleClickActivate
    Ptr ColumnView -> CInt -> IO ()
gtk_column_view_set_single_click_activate Ptr ColumnView
self' CInt
singleClickActivate'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ColumnViewSetSingleClickActivateMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsColumnView a) => O.OverloadedMethod ColumnViewSetSingleClickActivateMethodInfo a signature where
    overloadedMethod = columnViewSetSingleClickActivate

instance O.OverloadedMethodInfo ColumnViewSetSingleClickActivateMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.ColumnView.columnViewSetSingleClickActivate",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-ColumnView.html#v:columnViewSetSingleClickActivate"
        })


#endif

-- method ColumnView::sort_by_column
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "ColumnView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkColumnView`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "column"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "ColumnViewColumn" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the `GtkColumnViewColumn` to sort by"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "direction"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "SortType" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the direction to sort in"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_column_view_sort_by_column" gtk_column_view_sort_by_column :: 
    Ptr ColumnView ->                       -- self : TInterface (Name {namespace = "Gtk", name = "ColumnView"})
    Ptr Gtk.ColumnViewColumn.ColumnViewColumn -> -- column : TInterface (Name {namespace = "Gtk", name = "ColumnViewColumn"})
    CUInt ->                                -- direction : TInterface (Name {namespace = "Gtk", name = "SortType"})
    IO ()

-- | Sets the sorting of the view.
-- 
-- This function should be used to set up the initial sorting.
-- At runtime, users can change the sorting of a column view
-- by clicking on the list headers.
-- 
-- This call only has an effect if the sorter returned by
-- 'GI.Gtk.Objects.ColumnView.columnViewGetSorter' is set on a sort model,
-- and 'GI.Gtk.Objects.ColumnViewColumn.columnViewColumnSetSorter' has been called
-- on /@column@/ to associate a sorter with the column.
-- 
-- If /@column@/ is 'P.Nothing', the view will be unsorted.
columnViewSortByColumn ::
    (B.CallStack.HasCallStack, MonadIO m, IsColumnView a, Gtk.ColumnViewColumn.IsColumnViewColumn b) =>
    a
    -- ^ /@self@/: a @GtkColumnView@
    -> Maybe (b)
    -- ^ /@column@/: the @GtkColumnViewColumn@ to sort by
    -> Gtk.Enums.SortType
    -- ^ /@direction@/: the direction to sort in
    -> m ()
columnViewSortByColumn :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsColumnView a, IsColumnViewColumn b) =>
a -> Maybe b -> SortType -> m ()
columnViewSortByColumn a
self Maybe b
column SortType
direction = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr ColumnView
self' <- a -> IO (Ptr ColumnView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr ColumnViewColumn
maybeColumn <- case Maybe b
column of
        Maybe b
Nothing -> Ptr ColumnViewColumn -> IO (Ptr ColumnViewColumn)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ColumnViewColumn
forall a. Ptr a
nullPtr
        Just b
jColumn -> do
            Ptr ColumnViewColumn
jColumn' <- b -> IO (Ptr ColumnViewColumn)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jColumn
            Ptr ColumnViewColumn -> IO (Ptr ColumnViewColumn)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ColumnViewColumn
jColumn'
    let direction' :: CUInt
direction' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (SortType -> Int) -> SortType -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SortType -> Int
forall a. Enum a => a -> Int
fromEnum) SortType
direction
    Ptr ColumnView -> Ptr ColumnViewColumn -> CUInt -> IO ()
gtk_column_view_sort_by_column Ptr ColumnView
self' Ptr ColumnViewColumn
maybeColumn CUInt
direction'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
column b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ColumnViewSortByColumnMethodInfo
instance (signature ~ (Maybe (b) -> Gtk.Enums.SortType -> m ()), MonadIO m, IsColumnView a, Gtk.ColumnViewColumn.IsColumnViewColumn b) => O.OverloadedMethod ColumnViewSortByColumnMethodInfo a signature where
    overloadedMethod = columnViewSortByColumn

instance O.OverloadedMethodInfo ColumnViewSortByColumnMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.ColumnView.columnViewSortByColumn",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-ColumnView.html#v:columnViewSortByColumn"
        })


#endif