{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- GtkGridView is a widget to present a view into a large dynamic grid of items.
-- 
-- GtkGridView uses its factory to generate one child widget for each visible item
-- and shows them in a grid. The orientation of the grid view determines if the
-- grid reflows vertically or horizontally.
-- 
-- GtkGridView 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
-- t'GI.Gtk.Objects.GridView.GridView':@/enable-rubberband/@.
-- 
-- To learn more about the list widget framework, see the <https://developer.gnome.org/gtk4/stable/#ListWidget overview>.
-- 
-- = CSS nodes
-- 
-- 
-- === /plain code/
-- >
-- >gridview
-- >├── child
-- >│
-- >├── child
-- >│
-- >┊
-- >╰── [rubberband]
-- 
-- 
-- GtkGridView uses a single CSS node with name gridview. Each child
-- uses a single CSS node with name child. For rubberband selection,
-- a subnode with name rubberband is used.
-- 
-- = Accessibility
-- 
-- GtkGridView uses the @/GTK_ACCESSIBLE_ROLE_GRID/@ role, and the items
-- use the @/GTK_ACCESSIBLE_ROLE_GRID_CELL/@ role.

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

module GI.Gtk.Objects.GridView
    ( 

-- * Exported types
    GridView(..)                            ,
    IsGridView                              ,
    toGridView                              ,


 -- * 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"), [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"), [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"), [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"), [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"), [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"), [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.GridView#g:method:getEnableRubberband"), [getFactory]("GI.Gtk.Objects.GridView#g:method:getFactory"), [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"), [getMaxColumns]("GI.Gtk.Objects.GridView#g:method:getMaxColumns"), [getMinColumns]("GI.Gtk.Objects.GridView#g:method:getMinColumns"), [getModel]("GI.Gtk.Objects.GridView#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"), [getOrientation]("GI.Gtk.Interfaces.Orientable#g:method:getOrientation"), [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"), [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"), [getSingleClickActivate]("GI.Gtk.Objects.GridView#g:method:getSingleClickActivate"), [getSize]("GI.Gtk.Objects.Widget#g:method:getSize"), [getSizeRequest]("GI.Gtk.Objects.Widget#g:method:getSizeRequest"), [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.GridView#g:method:setEnableRubberband"), [setFactory]("GI.Gtk.Objects.GridView#g:method:setFactory"), [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"), [setMaxColumns]("GI.Gtk.Objects.GridView#g:method:setMaxColumns"), [setMinColumns]("GI.Gtk.Objects.GridView#g:method:setMinColumns"), [setModel]("GI.Gtk.Objects.GridView#g:method:setModel"), [setName]("GI.Gtk.Objects.Widget#g:method:setName"), [setOpacity]("GI.Gtk.Objects.Widget#g:method:setOpacity"), [setOrientation]("GI.Gtk.Interfaces.Orientable#g:method:setOrientation"), [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"), [setSensitive]("GI.Gtk.Objects.Widget#g:method:setSensitive"), [setSingleClickActivate]("GI.Gtk.Objects.GridView#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)
    ResolveGridViewMethod                   ,
#endif

-- ** getEnableRubberband #method:getEnableRubberband#

#if defined(ENABLE_OVERLOADING)
    GridViewGetEnableRubberbandMethodInfo   ,
#endif
    gridViewGetEnableRubberband             ,


-- ** getFactory #method:getFactory#

#if defined(ENABLE_OVERLOADING)
    GridViewGetFactoryMethodInfo            ,
#endif
    gridViewGetFactory                      ,


-- ** getMaxColumns #method:getMaxColumns#

#if defined(ENABLE_OVERLOADING)
    GridViewGetMaxColumnsMethodInfo         ,
#endif
    gridViewGetMaxColumns                   ,


-- ** getMinColumns #method:getMinColumns#

#if defined(ENABLE_OVERLOADING)
    GridViewGetMinColumnsMethodInfo         ,
#endif
    gridViewGetMinColumns                   ,


-- ** getModel #method:getModel#

#if defined(ENABLE_OVERLOADING)
    GridViewGetModelMethodInfo              ,
#endif
    gridViewGetModel                        ,


-- ** getSingleClickActivate #method:getSingleClickActivate#

#if defined(ENABLE_OVERLOADING)
    GridViewGetSingleClickActivateMethodInfo,
#endif
    gridViewGetSingleClickActivate          ,


-- ** new #method:new#

    gridViewNew                             ,


-- ** setEnableRubberband #method:setEnableRubberband#

#if defined(ENABLE_OVERLOADING)
    GridViewSetEnableRubberbandMethodInfo   ,
#endif
    gridViewSetEnableRubberband             ,


-- ** setFactory #method:setFactory#

#if defined(ENABLE_OVERLOADING)
    GridViewSetFactoryMethodInfo            ,
#endif
    gridViewSetFactory                      ,


-- ** setMaxColumns #method:setMaxColumns#

#if defined(ENABLE_OVERLOADING)
    GridViewSetMaxColumnsMethodInfo         ,
#endif
    gridViewSetMaxColumns                   ,


-- ** setMinColumns #method:setMinColumns#

#if defined(ENABLE_OVERLOADING)
    GridViewSetMinColumnsMethodInfo         ,
#endif
    gridViewSetMinColumns                   ,


-- ** setModel #method:setModel#

#if defined(ENABLE_OVERLOADING)
    GridViewSetModelMethodInfo              ,
#endif
    gridViewSetModel                        ,


-- ** setSingleClickActivate #method:setSingleClickActivate#

#if defined(ENABLE_OVERLOADING)
    GridViewSetSingleClickActivateMethodInfo,
#endif
    gridViewSetSingleClickActivate          ,




 -- * Properties


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

#if defined(ENABLE_OVERLOADING)
    GridViewEnableRubberbandPropertyInfo    ,
#endif
    constructGridViewEnableRubberband       ,
    getGridViewEnableRubberband             ,
#if defined(ENABLE_OVERLOADING)
    gridViewEnableRubberband                ,
#endif
    setGridViewEnableRubberband             ,


-- ** factory #attr:factory#
-- | Factory for populating list items

#if defined(ENABLE_OVERLOADING)
    GridViewFactoryPropertyInfo             ,
#endif
    clearGridViewFactory                    ,
    constructGridViewFactory                ,
    getGridViewFactory                      ,
#if defined(ENABLE_OVERLOADING)
    gridViewFactory                         ,
#endif
    setGridViewFactory                      ,


-- ** maxColumns #attr:maxColumns#
-- | Maximum number of columns per row
-- 
-- If this number is smaller than GtkGridView:min-columns, that value
-- is used instead.

#if defined(ENABLE_OVERLOADING)
    GridViewMaxColumnsPropertyInfo          ,
#endif
    constructGridViewMaxColumns             ,
    getGridViewMaxColumns                   ,
#if defined(ENABLE_OVERLOADING)
    gridViewMaxColumns                      ,
#endif
    setGridViewMaxColumns                   ,


-- ** minColumns #attr:minColumns#
-- | Minimum number of columns per row

#if defined(ENABLE_OVERLOADING)
    GridViewMinColumnsPropertyInfo          ,
#endif
    constructGridViewMinColumns             ,
    getGridViewMinColumns                   ,
#if defined(ENABLE_OVERLOADING)
    gridViewMinColumns                      ,
#endif
    setGridViewMinColumns                   ,


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

#if defined(ENABLE_OVERLOADING)
    GridViewModelPropertyInfo               ,
#endif
    clearGridViewModel                      ,
    constructGridViewModel                  ,
    getGridViewModel                        ,
#if defined(ENABLE_OVERLOADING)
    gridViewModel                           ,
#endif
    setGridViewModel                        ,


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

#if defined(ENABLE_OVERLOADING)
    GridViewSingleClickActivatePropertyInfo ,
#endif
    constructGridViewSingleClickActivate    ,
    getGridViewSingleClickActivate          ,
#if defined(ENABLE_OVERLOADING)
    gridViewSingleClickActivate             ,
#endif
    setGridViewSingleClickActivate          ,




 -- * Signals


-- ** activate #signal:activate#

    C_GridViewActivateCallback              ,
    GridViewActivateCallback                ,
#if defined(ENABLE_OVERLOADING)
    GridViewActivateSignalInfo              ,
#endif
    afterGridViewActivate                   ,
    genClosure_GridViewActivate             ,
    mk_GridViewActivateCallback             ,
    noGridViewActivateCallback              ,
    onGridViewActivate                      ,
    wrap_GridViewActivateCallback           ,




    ) where

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

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

import qualified GI.GObject.Objects.Object as GObject.Object
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.Orientable as Gtk.Orientable
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.ListBase as Gtk.ListBase
import {-# SOURCE #-} qualified GI.Gtk.Objects.ListItemFactory as Gtk.ListItemFactory
import {-# SOURCE #-} qualified GI.Gtk.Objects.Widget as Gtk.Widget

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

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

foreign import ccall "gtk_grid_view_get_type"
    c_gtk_grid_view_get_type :: IO B.Types.GType

instance B.Types.TypedObject GridView where
    glibType :: IO GType
glibType = IO GType
c_gtk_grid_view_get_type

instance B.Types.GObject GridView

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

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

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

-- | Convert 'GridView' 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 GridView) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_gtk_grid_view_get_type
    gvalueSet_ :: Ptr GValue -> Maybe GridView -> IO ()
gvalueSet_ Ptr GValue
gv Maybe GridView
P.Nothing = Ptr GValue -> Ptr GridView -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr GridView
forall a. Ptr a
FP.nullPtr :: FP.Ptr GridView)
    gvalueSet_ Ptr GValue
gv (P.Just GridView
obj) = GridView -> (Ptr GridView -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr GridView
obj (Ptr GValue -> Ptr GridView -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe GridView)
gvalueGet_ Ptr GValue
gv = do
        Ptr GridView
ptr <- Ptr GValue -> IO (Ptr GridView)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr GridView)
        if Ptr GridView
ptr Ptr GridView -> Ptr GridView -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr GridView
forall a. Ptr a
FP.nullPtr
        then GridView -> Maybe GridView
forall a. a -> Maybe a
P.Just (GridView -> Maybe GridView) -> IO GridView -> IO (Maybe GridView)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr GridView -> GridView) -> Ptr GridView -> IO GridView
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr GridView -> GridView
GridView Ptr GridView
ptr
        else Maybe GridView -> IO (Maybe GridView)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe GridView
forall a. Maybe a
P.Nothing
        
    

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

instance (info ~ ResolveGridViewMethod t GridView, O.OverloadedMethod info GridView p) => OL.IsLabel t (GridView -> 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 ~ ResolveGridViewMethod t GridView, O.OverloadedMethod info GridView p, R.HasField t GridView p) => R.HasField t GridView p where
    getField = O.overloadedMethod @info

#endif

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

#endif

-- signal GridView::activate
-- | The [activate](#g:signal:activate) signal is emitted when a cell has been activated by the user,
-- usually via activating the GtkGridView|list.activate-item action.
-- 
-- This allows for a convenient way to handle activation in a gridview.
-- See GtkListItem:activatable for details on how to use this signal.
type GridViewActivateCallback =
    Word32
    -- ^ /@position@/: position of item to activate
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `GridViewActivateCallback`@.
noGridViewActivateCallback :: Maybe GridViewActivateCallback
noGridViewActivateCallback :: Maybe GridViewActivateCallback
noGridViewActivateCallback = Maybe GridViewActivateCallback
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_GridViewActivate :: MonadIO m => GridViewActivateCallback -> m (GClosure C_GridViewActivateCallback)
genClosure_GridViewActivate :: forall (m :: * -> *).
MonadIO m =>
GridViewActivateCallback -> m (GClosure C_GridViewActivateCallback)
genClosure_GridViewActivate GridViewActivateCallback
cb = IO (GClosure C_GridViewActivateCallback)
-> m (GClosure C_GridViewActivateCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_GridViewActivateCallback)
 -> m (GClosure C_GridViewActivateCallback))
-> IO (GClosure C_GridViewActivateCallback)
-> m (GClosure C_GridViewActivateCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_GridViewActivateCallback
cb' = GridViewActivateCallback -> C_GridViewActivateCallback
wrap_GridViewActivateCallback GridViewActivateCallback
cb
    C_GridViewActivateCallback
-> IO (FunPtr C_GridViewActivateCallback)
mk_GridViewActivateCallback C_GridViewActivateCallback
cb' IO (FunPtr C_GridViewActivateCallback)
-> (FunPtr C_GridViewActivateCallback
    -> IO (GClosure C_GridViewActivateCallback))
-> IO (GClosure C_GridViewActivateCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_GridViewActivateCallback
-> IO (GClosure C_GridViewActivateCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `GridViewActivateCallback` into a `C_GridViewActivateCallback`.
wrap_GridViewActivateCallback ::
    GridViewActivateCallback ->
    C_GridViewActivateCallback
wrap_GridViewActivateCallback :: GridViewActivateCallback -> C_GridViewActivateCallback
wrap_GridViewActivateCallback GridViewActivateCallback
_cb Ptr ()
_ Word32
position Ptr ()
_ = do
    GridViewActivateCallback
_cb  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' gridView #activate callback
-- @
-- 
-- 
onGridViewActivate :: (IsGridView a, MonadIO m) => a -> GridViewActivateCallback -> m SignalHandlerId
onGridViewActivate :: forall a (m :: * -> *).
(IsGridView a, MonadIO m) =>
a -> GridViewActivateCallback -> m SignalHandlerId
onGridViewActivate a
obj GridViewActivateCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_GridViewActivateCallback
cb' = GridViewActivateCallback -> C_GridViewActivateCallback
wrap_GridViewActivateCallback GridViewActivateCallback
cb
    FunPtr C_GridViewActivateCallback
cb'' <- C_GridViewActivateCallback
-> IO (FunPtr C_GridViewActivateCallback)
mk_GridViewActivateCallback C_GridViewActivateCallback
cb'
    a
-> Text
-> FunPtr C_GridViewActivateCallback
-> 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_GridViewActivateCallback
cb'' 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' gridView #activate callback
-- @
-- 
-- 
afterGridViewActivate :: (IsGridView a, MonadIO m) => a -> GridViewActivateCallback -> m SignalHandlerId
afterGridViewActivate :: forall a (m :: * -> *).
(IsGridView a, MonadIO m) =>
a -> GridViewActivateCallback -> m SignalHandlerId
afterGridViewActivate a
obj GridViewActivateCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_GridViewActivateCallback
cb' = GridViewActivateCallback -> C_GridViewActivateCallback
wrap_GridViewActivateCallback GridViewActivateCallback
cb
    FunPtr C_GridViewActivateCallback
cb'' <- C_GridViewActivateCallback
-> IO (FunPtr C_GridViewActivateCallback)
mk_GridViewActivateCallback C_GridViewActivateCallback
cb'
    a
-> Text
-> FunPtr C_GridViewActivateCallback
-> 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_GridViewActivateCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data GridViewActivateSignalInfo
instance SignalInfo GridViewActivateSignalInfo where
    type HaskellCallbackType GridViewActivateSignalInfo = GridViewActivateCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_GridViewActivateCallback cb
        cb'' <- mk_GridViewActivateCallback cb'
        connectSignalFunPtr obj "activate" cb'' connectMode detail

#endif

--- XXX Duplicated object with different types:
  --- Name {namespace = "Gtk", name = "ListBase"} -> Property {propName = "orientation", propType = TInterface (Name {namespace = "Gtk", name = "Orientation"}), propFlags = [PropertyReadable,PropertyWritable], propReadNullable = Nothing, propWriteNullable = Nothing, propTransfer = TransferNothing, propDoc = Documentation {rawDocText = Just "The orientation of the list. See GtkOrientable:orientation\nfor details.", sinceVersion = Nothing}, propDeprecated = Nothing}
  --- Name {namespace = "Gtk", name = "Orientable"} -> Property {propName = "orientation", propType = TInterface (Name {namespace = "Gtk", name = "Orientation"}), propFlags = [PropertyReadable,PropertyWritable], propReadNullable = Just False, propWriteNullable = Just False, propTransfer = TransferNothing, propDoc = Documentation {rawDocText = Just "The orientation of the orientable.", sinceVersion = Nothing}, propDeprecated = Nothing}
-- 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' gridView #enableRubberband
-- @
getGridViewEnableRubberband :: (MonadIO m, IsGridView o) => o -> m Bool
getGridViewEnableRubberband :: forall (m :: * -> *) o. (MonadIO m, IsGridView o) => o -> m Bool
getGridViewEnableRubberband o
obj = IO Bool -> m Bool
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' gridView [ #enableRubberband 'Data.GI.Base.Attributes.:=' value ]
-- @
setGridViewEnableRubberband :: (MonadIO m, IsGridView o) => o -> Bool -> m ()
setGridViewEnableRubberband :: forall (m :: * -> *) o.
(MonadIO m, IsGridView o) =>
o -> Bool -> m ()
setGridViewEnableRubberband o
obj Bool
val = IO () -> m ()
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`.
constructGridViewEnableRubberband :: (IsGridView o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructGridViewEnableRubberband :: forall o (m :: * -> *).
(IsGridView o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructGridViewEnableRubberband Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
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 GridViewEnableRubberbandPropertyInfo
instance AttrInfo GridViewEnableRubberbandPropertyInfo where
    type AttrAllowedOps GridViewEnableRubberbandPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint GridViewEnableRubberbandPropertyInfo = IsGridView
    type AttrSetTypeConstraint GridViewEnableRubberbandPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint GridViewEnableRubberbandPropertyInfo = (~) Bool
    type AttrTransferType GridViewEnableRubberbandPropertyInfo = Bool
    type AttrGetType GridViewEnableRubberbandPropertyInfo = Bool
    type AttrLabel GridViewEnableRubberbandPropertyInfo = "enable-rubberband"
    type AttrOrigin GridViewEnableRubberbandPropertyInfo = GridView
    attrGet = getGridViewEnableRubberband
    attrSet = setGridViewEnableRubberband
    attrTransfer _ v = do
        return v
    attrConstruct = constructGridViewEnableRubberband
    attrClear = undefined
#endif

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

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

-- | Set the value of the “@factory@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' gridView [ #factory 'Data.GI.Base.Attributes.:=' value ]
-- @
setGridViewFactory :: (MonadIO m, IsGridView o, Gtk.ListItemFactory.IsListItemFactory a) => o -> a -> m ()
setGridViewFactory :: forall (m :: * -> *) o a.
(MonadIO m, IsGridView o, IsListItemFactory a) =>
o -> a -> m ()
setGridViewFactory o
obj a
val = IO () -> m ()
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
"factory" (a -> Maybe a
forall a. a -> Maybe a
Just a
val)

-- | Construct a `GValueConstruct` with valid value for the “@factory@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructGridViewFactory :: (IsGridView o, MIO.MonadIO m, Gtk.ListItemFactory.IsListItemFactory a) => a -> m (GValueConstruct o)
constructGridViewFactory :: forall o (m :: * -> *) a.
(IsGridView o, MonadIO m, IsListItemFactory a) =>
a -> m (GValueConstruct o)
constructGridViewFactory a
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
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
"factory" (a -> Maybe a
forall a. a -> Maybe a
P.Just a
val)

-- | Set the value of the “@factory@” 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' #factory
-- @
clearGridViewFactory :: (MonadIO m, IsGridView o) => o -> m ()
clearGridViewFactory :: forall (m :: * -> *) o. (MonadIO m, IsGridView o) => o -> m ()
clearGridViewFactory o
obj = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe ListItemFactory -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"factory" (Maybe ListItemFactory
forall a. Maybe a
Nothing :: Maybe Gtk.ListItemFactory.ListItemFactory)

#if defined(ENABLE_OVERLOADING)
data GridViewFactoryPropertyInfo
instance AttrInfo GridViewFactoryPropertyInfo where
    type AttrAllowedOps GridViewFactoryPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint GridViewFactoryPropertyInfo = IsGridView
    type AttrSetTypeConstraint GridViewFactoryPropertyInfo = Gtk.ListItemFactory.IsListItemFactory
    type AttrTransferTypeConstraint GridViewFactoryPropertyInfo = Gtk.ListItemFactory.IsListItemFactory
    type AttrTransferType GridViewFactoryPropertyInfo = Gtk.ListItemFactory.ListItemFactory
    type AttrGetType GridViewFactoryPropertyInfo = (Maybe Gtk.ListItemFactory.ListItemFactory)
    type AttrLabel GridViewFactoryPropertyInfo = "factory"
    type AttrOrigin GridViewFactoryPropertyInfo = GridView
    attrGet = getGridViewFactory
    attrSet = setGridViewFactory
    attrTransfer _ v = do
        unsafeCastTo Gtk.ListItemFactory.ListItemFactory v
    attrConstruct = constructGridViewFactory
    attrClear = clearGridViewFactory
#endif

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

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

-- | Set the value of the “@max-columns@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' gridView [ #maxColumns 'Data.GI.Base.Attributes.:=' value ]
-- @
setGridViewMaxColumns :: (MonadIO m, IsGridView o) => o -> Word32 -> m ()
setGridViewMaxColumns :: forall (m :: * -> *) o.
(MonadIO m, IsGridView o) =>
o -> Word32 -> m ()
setGridViewMaxColumns o
obj Word32
val = IO () -> m ()
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 -> GridViewActivateCallback
forall a. GObject a => a -> String -> GridViewActivateCallback
B.Properties.setObjectPropertyUInt32 o
obj String
"max-columns" Word32
val

-- | Construct a `GValueConstruct` with valid value for the “@max-columns@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructGridViewMaxColumns :: (IsGridView o, MIO.MonadIO m) => Word32 -> m (GValueConstruct o)
constructGridViewMaxColumns :: forall o (m :: * -> *).
(IsGridView o, MonadIO m) =>
Word32 -> m (GValueConstruct o)
constructGridViewMaxColumns Word32
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
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 -> Word32 -> IO (GValueConstruct o)
forall o. String -> Word32 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyUInt32 String
"max-columns" Word32
val

#if defined(ENABLE_OVERLOADING)
data GridViewMaxColumnsPropertyInfo
instance AttrInfo GridViewMaxColumnsPropertyInfo where
    type AttrAllowedOps GridViewMaxColumnsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint GridViewMaxColumnsPropertyInfo = IsGridView
    type AttrSetTypeConstraint GridViewMaxColumnsPropertyInfo = (~) Word32
    type AttrTransferTypeConstraint GridViewMaxColumnsPropertyInfo = (~) Word32
    type AttrTransferType GridViewMaxColumnsPropertyInfo = Word32
    type AttrGetType GridViewMaxColumnsPropertyInfo = Word32
    type AttrLabel GridViewMaxColumnsPropertyInfo = "max-columns"
    type AttrOrigin GridViewMaxColumnsPropertyInfo = GridView
    attrGet = getGridViewMaxColumns
    attrSet = setGridViewMaxColumns
    attrTransfer _ v = do
        return v
    attrConstruct = constructGridViewMaxColumns
    attrClear = undefined
#endif

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

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

-- | Set the value of the “@min-columns@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' gridView [ #minColumns 'Data.GI.Base.Attributes.:=' value ]
-- @
setGridViewMinColumns :: (MonadIO m, IsGridView o) => o -> Word32 -> m ()
setGridViewMinColumns :: forall (m :: * -> *) o.
(MonadIO m, IsGridView o) =>
o -> Word32 -> m ()
setGridViewMinColumns o
obj Word32
val = IO () -> m ()
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 -> GridViewActivateCallback
forall a. GObject a => a -> String -> GridViewActivateCallback
B.Properties.setObjectPropertyUInt32 o
obj String
"min-columns" Word32
val

-- | Construct a `GValueConstruct` with valid value for the “@min-columns@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructGridViewMinColumns :: (IsGridView o, MIO.MonadIO m) => Word32 -> m (GValueConstruct o)
constructGridViewMinColumns :: forall o (m :: * -> *).
(IsGridView o, MonadIO m) =>
Word32 -> m (GValueConstruct o)
constructGridViewMinColumns Word32
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
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 -> Word32 -> IO (GValueConstruct o)
forall o. String -> Word32 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyUInt32 String
"min-columns" Word32
val

#if defined(ENABLE_OVERLOADING)
data GridViewMinColumnsPropertyInfo
instance AttrInfo GridViewMinColumnsPropertyInfo where
    type AttrAllowedOps GridViewMinColumnsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint GridViewMinColumnsPropertyInfo = IsGridView
    type AttrSetTypeConstraint GridViewMinColumnsPropertyInfo = (~) Word32
    type AttrTransferTypeConstraint GridViewMinColumnsPropertyInfo = (~) Word32
    type AttrTransferType GridViewMinColumnsPropertyInfo = Word32
    type AttrGetType GridViewMinColumnsPropertyInfo = Word32
    type AttrLabel GridViewMinColumnsPropertyInfo = "min-columns"
    type AttrOrigin GridViewMinColumnsPropertyInfo = GridView
    attrGet = getGridViewMinColumns
    attrSet = setGridViewMinColumns
    attrTransfer _ v = do
        return v
    attrConstruct = constructGridViewMinColumns
    attrClear = undefined
#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' gridView #model
-- @
getGridViewModel :: (MonadIO m, IsGridView o) => o -> m (Maybe Gtk.SelectionModel.SelectionModel)
getGridViewModel :: forall (m :: * -> *) o.
(MonadIO m, IsGridView o) =>
o -> m (Maybe SelectionModel)
getGridViewModel o
obj = IO (Maybe SelectionModel) -> m (Maybe SelectionModel)
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' gridView [ #model 'Data.GI.Base.Attributes.:=' value ]
-- @
setGridViewModel :: (MonadIO m, IsGridView o, Gtk.SelectionModel.IsSelectionModel a) => o -> a -> m ()
setGridViewModel :: forall (m :: * -> *) o a.
(MonadIO m, IsGridView o, IsSelectionModel a) =>
o -> a -> m ()
setGridViewModel o
obj a
val = IO () -> m ()
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`.
constructGridViewModel :: (IsGridView o, MIO.MonadIO m, Gtk.SelectionModel.IsSelectionModel a) => a -> m (GValueConstruct o)
constructGridViewModel :: forall o (m :: * -> *) a.
(IsGridView o, MonadIO m, IsSelectionModel a) =>
a -> m (GValueConstruct o)
constructGridViewModel a
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
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
-- @
clearGridViewModel :: (MonadIO m, IsGridView o) => o -> m ()
clearGridViewModel :: forall (m :: * -> *) o. (MonadIO m, IsGridView o) => o -> m ()
clearGridViewModel o
obj = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe 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 GridViewModelPropertyInfo
instance AttrInfo GridViewModelPropertyInfo where
    type AttrAllowedOps GridViewModelPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint GridViewModelPropertyInfo = IsGridView
    type AttrSetTypeConstraint GridViewModelPropertyInfo = Gtk.SelectionModel.IsSelectionModel
    type AttrTransferTypeConstraint GridViewModelPropertyInfo = Gtk.SelectionModel.IsSelectionModel
    type AttrTransferType GridViewModelPropertyInfo = Gtk.SelectionModel.SelectionModel
    type AttrGetType GridViewModelPropertyInfo = (Maybe Gtk.SelectionModel.SelectionModel)
    type AttrLabel GridViewModelPropertyInfo = "model"
    type AttrOrigin GridViewModelPropertyInfo = GridView
    attrGet = getGridViewModel
    attrSet = setGridViewModel
    attrTransfer _ v = do
        unsafeCastTo Gtk.SelectionModel.SelectionModel v
    attrConstruct = constructGridViewModel
    attrClear = clearGridViewModel
#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' gridView #singleClickActivate
-- @
getGridViewSingleClickActivate :: (MonadIO m, IsGridView o) => o -> m Bool
getGridViewSingleClickActivate :: forall (m :: * -> *) o. (MonadIO m, IsGridView o) => o -> m Bool
getGridViewSingleClickActivate o
obj = IO Bool -> m Bool
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' gridView [ #singleClickActivate 'Data.GI.Base.Attributes.:=' value ]
-- @
setGridViewSingleClickActivate :: (MonadIO m, IsGridView o) => o -> Bool -> m ()
setGridViewSingleClickActivate :: forall (m :: * -> *) o.
(MonadIO m, IsGridView o) =>
o -> Bool -> m ()
setGridViewSingleClickActivate o
obj Bool
val = IO () -> m ()
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`.
constructGridViewSingleClickActivate :: (IsGridView o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructGridViewSingleClickActivate :: forall o (m :: * -> *).
(IsGridView o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructGridViewSingleClickActivate Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
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 GridViewSingleClickActivatePropertyInfo
instance AttrInfo GridViewSingleClickActivatePropertyInfo where
    type AttrAllowedOps GridViewSingleClickActivatePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint GridViewSingleClickActivatePropertyInfo = IsGridView
    type AttrSetTypeConstraint GridViewSingleClickActivatePropertyInfo = (~) Bool
    type AttrTransferTypeConstraint GridViewSingleClickActivatePropertyInfo = (~) Bool
    type AttrTransferType GridViewSingleClickActivatePropertyInfo = Bool
    type AttrGetType GridViewSingleClickActivatePropertyInfo = Bool
    type AttrLabel GridViewSingleClickActivatePropertyInfo = "single-click-activate"
    type AttrOrigin GridViewSingleClickActivatePropertyInfo = GridView
    attrGet = getGridViewSingleClickActivate
    attrSet = setGridViewSingleClickActivate
    attrTransfer _ v = do
        return v
    attrConstruct = constructGridViewSingleClickActivate
    attrClear = undefined
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList GridView
type instance O.AttributeList GridView = GridViewAttributeList
type GridViewAttributeList = ('[ '("accessibleRole", Gtk.Accessible.AccessibleAccessibleRolePropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("canTarget", Gtk.Widget.WidgetCanTargetPropertyInfo), '("cssClasses", Gtk.Widget.WidgetCssClassesPropertyInfo), '("cssName", Gtk.Widget.WidgetCssNamePropertyInfo), '("cursor", Gtk.Widget.WidgetCursorPropertyInfo), '("enableRubberband", GridViewEnableRubberbandPropertyInfo), '("factory", GridViewFactoryPropertyInfo), '("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), '("maxColumns", GridViewMaxColumnsPropertyInfo), '("minColumns", GridViewMinColumnsPropertyInfo), '("model", GridViewModelPropertyInfo), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("orientation", Gtk.ListBase.ListBaseOrientationPropertyInfo), '("overflow", Gtk.Widget.WidgetOverflowPropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("root", Gtk.Widget.WidgetRootPropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("singleClickActivate", GridViewSingleClickActivatePropertyInfo), '("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)
gridViewEnableRubberband :: AttrLabelProxy "enableRubberband"
gridViewEnableRubberband = AttrLabelProxy

gridViewFactory :: AttrLabelProxy "factory"
gridViewFactory = AttrLabelProxy

gridViewMaxColumns :: AttrLabelProxy "maxColumns"
gridViewMaxColumns = AttrLabelProxy

gridViewMinColumns :: AttrLabelProxy "minColumns"
gridViewMinColumns = AttrLabelProxy

gridViewModel :: AttrLabelProxy "model"
gridViewModel = AttrLabelProxy

gridViewSingleClickActivate :: AttrLabelProxy "singleClickActivate"
gridViewSingleClickActivate = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList GridView = GridViewSignalList
type GridViewSignalList = ('[ '("activate", GridViewActivateSignalInfo), '("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 GridView::new
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "model"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "SelectionModel" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the model to use, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "factory"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "ListItemFactory" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The factory to populate items with, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gtk" , name = "GridView" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_grid_view_new" gtk_grid_view_new :: 
    Ptr Gtk.SelectionModel.SelectionModel -> -- model : TInterface (Name {namespace = "Gtk", name = "SelectionModel"})
    Ptr Gtk.ListItemFactory.ListItemFactory -> -- factory : TInterface (Name {namespace = "Gtk", name = "ListItemFactory"})
    IO (Ptr GridView)

-- | Creates a new t'GI.Gtk.Objects.GridView.GridView' that uses the given /@factory@/ for
-- mapping items to widgets.
-- 
-- The function takes ownership of the
-- arguments, so you can write code like
-- \`\`@
--   grid_view = gtk_grid_view_new (create_model (),
--     gtk_builder_list_item_factory_new_from_resource (\"\/resource.ui\"));
-- @\`\`
gridViewNew ::
    (B.CallStack.HasCallStack, MonadIO m, Gtk.SelectionModel.IsSelectionModel a, Gtk.ListItemFactory.IsListItemFactory b) =>
    Maybe (a)
    -- ^ /@model@/: the model to use, or 'P.Nothing'
    -> Maybe (b)
    -- ^ /@factory@/: The factory to populate items with, or 'P.Nothing'
    -> m GridView
    -- ^ __Returns:__ a new t'GI.Gtk.Objects.GridView.GridView' using the given /@model@/ and /@factory@/
gridViewNew :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsSelectionModel a,
 IsListItemFactory b) =>
Maybe a -> Maybe b -> m GridView
gridViewNew Maybe a
model Maybe b
factory = IO GridView -> m GridView
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GridView -> m GridView) -> IO GridView -> m GridView
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 (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 (m :: * -> *) a. Monad m => a -> m a
return Ptr SelectionModel
jModel'
    Ptr ListItemFactory
maybeFactory <- case Maybe b
factory of
        Maybe b
Nothing -> Ptr ListItemFactory -> IO (Ptr ListItemFactory)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ListItemFactory
forall a. Ptr a
nullPtr
        Just b
jFactory -> do
            Ptr ListItemFactory
jFactory' <- b -> IO (Ptr ListItemFactory)
forall a b. (HasCallStack, GObject a) => a -> IO (Ptr b)
B.ManagedPtr.disownObject b
jFactory
            Ptr ListItemFactory -> IO (Ptr ListItemFactory)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ListItemFactory
jFactory'
    Ptr GridView
result <- Ptr SelectionModel -> Ptr ListItemFactory -> IO (Ptr GridView)
gtk_grid_view_new Ptr SelectionModel
maybeModel Ptr ListItemFactory
maybeFactory
    Text -> Ptr GridView -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"gridViewNew" Ptr GridView
result
    GridView
result' <- ((ManagedPtr GridView -> GridView) -> Ptr GridView -> IO GridView
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr GridView -> GridView
GridView) Ptr GridView
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
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
factory b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    GridView -> IO GridView
forall (m :: * -> *) a. Monad m => a -> m a
return GridView
result'

#if defined(ENABLE_OVERLOADING)
#endif

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

-- | Returns whether rows can be selected by dragging with the mouse.
gridViewGetEnableRubberband ::
    (B.CallStack.HasCallStack, MonadIO m, IsGridView a) =>
    a
    -- ^ /@self@/: a t'GI.Gtk.Objects.GridView.GridView'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if rubberband selection is enabled
gridViewGetEnableRubberband :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsGridView a) =>
a -> m Bool
gridViewGetEnableRubberband a
self = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr GridView
self' <- a -> IO (Ptr GridView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr GridView -> IO CInt
gtk_grid_view_get_enable_rubberband Ptr GridView
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 (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data GridViewGetEnableRubberbandMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsGridView a) => O.OverloadedMethod GridViewGetEnableRubberbandMethodInfo a signature where
    overloadedMethod = gridViewGetEnableRubberband

instance O.OverloadedMethodInfo GridViewGetEnableRubberbandMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Objects.GridView.gridViewGetEnableRubberband",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Objects-GridView.html#v:gridViewGetEnableRubberband"
        }


#endif

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

foreign import ccall "gtk_grid_view_get_factory" gtk_grid_view_get_factory :: 
    Ptr GridView ->                         -- self : TInterface (Name {namespace = "Gtk", name = "GridView"})
    IO (Ptr Gtk.ListItemFactory.ListItemFactory)

-- | Gets the factory that\'s currently used to populate list items.
gridViewGetFactory ::
    (B.CallStack.HasCallStack, MonadIO m, IsGridView a) =>
    a
    -- ^ /@self@/: a t'GI.Gtk.Objects.GridView.GridView'
    -> m (Maybe Gtk.ListItemFactory.ListItemFactory)
    -- ^ __Returns:__ The factory in use
gridViewGetFactory :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsGridView a) =>
a -> m (Maybe ListItemFactory)
gridViewGetFactory a
self = IO (Maybe ListItemFactory) -> m (Maybe ListItemFactory)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe ListItemFactory) -> m (Maybe ListItemFactory))
-> IO (Maybe ListItemFactory) -> m (Maybe ListItemFactory)
forall a b. (a -> b) -> a -> b
$ do
    Ptr GridView
self' <- a -> IO (Ptr GridView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr ListItemFactory
result <- Ptr GridView -> IO (Ptr ListItemFactory)
gtk_grid_view_get_factory Ptr GridView
self'
    Maybe ListItemFactory
maybeResult <- Ptr ListItemFactory
-> (Ptr ListItemFactory -> IO ListItemFactory)
-> IO (Maybe ListItemFactory)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr ListItemFactory
result ((Ptr ListItemFactory -> IO ListItemFactory)
 -> IO (Maybe ListItemFactory))
-> (Ptr ListItemFactory -> IO ListItemFactory)
-> IO (Maybe ListItemFactory)
forall a b. (a -> b) -> a -> b
$ \Ptr ListItemFactory
result' -> do
        ListItemFactory
result'' <- ((ManagedPtr ListItemFactory -> ListItemFactory)
-> Ptr ListItemFactory -> IO ListItemFactory
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr ListItemFactory -> ListItemFactory
Gtk.ListItemFactory.ListItemFactory) Ptr ListItemFactory
result'
        ListItemFactory -> IO ListItemFactory
forall (m :: * -> *) a. Monad m => a -> m a
return ListItemFactory
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe ListItemFactory -> IO (Maybe ListItemFactory)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ListItemFactory
maybeResult

#if defined(ENABLE_OVERLOADING)
data GridViewGetFactoryMethodInfo
instance (signature ~ (m (Maybe Gtk.ListItemFactory.ListItemFactory)), MonadIO m, IsGridView a) => O.OverloadedMethod GridViewGetFactoryMethodInfo a signature where
    overloadedMethod = gridViewGetFactory

instance O.OverloadedMethodInfo GridViewGetFactoryMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Objects.GridView.gridViewGetFactory",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Objects-GridView.html#v:gridViewGetFactory"
        }


#endif

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

foreign import ccall "gtk_grid_view_get_max_columns" gtk_grid_view_get_max_columns :: 
    Ptr GridView ->                         -- self : TInterface (Name {namespace = "Gtk", name = "GridView"})
    IO Word32

-- | Gets the maximum number of columns that the grid will use.
gridViewGetMaxColumns ::
    (B.CallStack.HasCallStack, MonadIO m, IsGridView a) =>
    a
    -- ^ /@self@/: a t'GI.Gtk.Objects.GridView.GridView'
    -> m Word32
    -- ^ __Returns:__ The maximum number of columns
gridViewGetMaxColumns :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsGridView a) =>
a -> m Word32
gridViewGetMaxColumns a
self = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
    Ptr GridView
self' <- a -> IO (Ptr GridView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Word32
result <- Ptr GridView -> IO Word32
gtk_grid_view_get_max_columns Ptr GridView
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result

#if defined(ENABLE_OVERLOADING)
data GridViewGetMaxColumnsMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsGridView a) => O.OverloadedMethod GridViewGetMaxColumnsMethodInfo a signature where
    overloadedMethod = gridViewGetMaxColumns

instance O.OverloadedMethodInfo GridViewGetMaxColumnsMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Objects.GridView.gridViewGetMaxColumns",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Objects-GridView.html#v:gridViewGetMaxColumns"
        }


#endif

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

foreign import ccall "gtk_grid_view_get_min_columns" gtk_grid_view_get_min_columns :: 
    Ptr GridView ->                         -- self : TInterface (Name {namespace = "Gtk", name = "GridView"})
    IO Word32

-- | Gets the minimum number of columns that the grid will use.
gridViewGetMinColumns ::
    (B.CallStack.HasCallStack, MonadIO m, IsGridView a) =>
    a
    -- ^ /@self@/: a t'GI.Gtk.Objects.GridView.GridView'
    -> m Word32
    -- ^ __Returns:__ The minimum number of columns
gridViewGetMinColumns :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsGridView a) =>
a -> m Word32
gridViewGetMinColumns a
self = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
    Ptr GridView
self' <- a -> IO (Ptr GridView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Word32
result <- Ptr GridView -> IO Word32
gtk_grid_view_get_min_columns Ptr GridView
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result

#if defined(ENABLE_OVERLOADING)
data GridViewGetMinColumnsMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsGridView a) => O.OverloadedMethod GridViewGetMinColumnsMethodInfo a signature where
    overloadedMethod = gridViewGetMinColumns

instance O.OverloadedMethodInfo GridViewGetMinColumnsMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Objects.GridView.gridViewGetMinColumns",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Objects-GridView.html#v:gridViewGetMinColumns"
        }


#endif

-- method GridView::get_model
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "GridView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkGridView" , 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_grid_view_get_model" gtk_grid_view_get_model :: 
    Ptr GridView ->                         -- self : TInterface (Name {namespace = "Gtk", name = "GridView"})
    IO (Ptr Gtk.SelectionModel.SelectionModel)

-- | Gets the model that\'s currently used to read the items displayed.
gridViewGetModel ::
    (B.CallStack.HasCallStack, MonadIO m, IsGridView a) =>
    a
    -- ^ /@self@/: a t'GI.Gtk.Objects.GridView.GridView'
    -> m (Maybe Gtk.SelectionModel.SelectionModel)
    -- ^ __Returns:__ The model in use
gridViewGetModel :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsGridView a) =>
a -> m (Maybe SelectionModel)
gridViewGetModel a
self = IO (Maybe SelectionModel) -> m (Maybe SelectionModel)
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 GridView
self' <- a -> IO (Ptr GridView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr SelectionModel
result <- Ptr GridView -> IO (Ptr SelectionModel)
gtk_grid_view_get_model Ptr GridView
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 (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 (m :: * -> *) a. Monad m => a -> m a
return Maybe SelectionModel
maybeResult

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

instance O.OverloadedMethodInfo GridViewGetModelMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Objects.GridView.gridViewGetModel",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Objects-GridView.html#v:gridViewGetModel"
        }


#endif

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

-- | Returns whether items will be activated on single click and
-- selected on hover.
gridViewGetSingleClickActivate ::
    (B.CallStack.HasCallStack, MonadIO m, IsGridView a) =>
    a
    -- ^ /@self@/: a t'GI.Gtk.Objects.ListView.ListView'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if items are activated on single click
gridViewGetSingleClickActivate :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsGridView a) =>
a -> m Bool
gridViewGetSingleClickActivate a
self = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr GridView
self' <- a -> IO (Ptr GridView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr GridView -> IO CInt
gtk_grid_view_get_single_click_activate Ptr GridView
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 (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data GridViewGetSingleClickActivateMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsGridView a) => O.OverloadedMethod GridViewGetSingleClickActivateMethodInfo a signature where
    overloadedMethod = gridViewGetSingleClickActivate

instance O.OverloadedMethodInfo GridViewGetSingleClickActivateMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Objects.GridView.gridViewGetSingleClickActivate",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Objects-GridView.html#v:gridViewGetSingleClickActivate"
        }


#endif

-- method GridView::set_enable_rubberband
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "GridView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkGridView" , 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_grid_view_set_enable_rubberband" gtk_grid_view_set_enable_rubberband :: 
    Ptr GridView ->                         -- self : TInterface (Name {namespace = "Gtk", name = "GridView"})
    CInt ->                                 -- enable_rubberband : TBasicType TBoolean
    IO ()

-- | Sets whether selections can be changed by dragging with the mouse.
gridViewSetEnableRubberband ::
    (B.CallStack.HasCallStack, MonadIO m, IsGridView a) =>
    a
    -- ^ /@self@/: a t'GI.Gtk.Objects.GridView.GridView'
    -> Bool
    -- ^ /@enableRubberband@/: 'P.True' to enable rubberband selection
    -> m ()
gridViewSetEnableRubberband :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsGridView a) =>
a -> Bool -> m ()
gridViewSetEnableRubberband a
self Bool
enableRubberband = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr GridView
self' <- a -> IO (Ptr GridView)
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 GridView -> CInt -> IO ()
gtk_grid_view_set_enable_rubberband Ptr GridView
self' CInt
enableRubberband'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data GridViewSetEnableRubberbandMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsGridView a) => O.OverloadedMethod GridViewSetEnableRubberbandMethodInfo a signature where
    overloadedMethod = gridViewSetEnableRubberband

instance O.OverloadedMethodInfo GridViewSetEnableRubberbandMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Objects.GridView.gridViewSetEnableRubberband",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Objects-GridView.html#v:gridViewSetEnableRubberband"
        }


#endif

-- method GridView::set_factory
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "GridView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkGridView" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "factory"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "ListItemFactory" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the factory to use or %NULL for none"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_grid_view_set_factory" gtk_grid_view_set_factory :: 
    Ptr GridView ->                         -- self : TInterface (Name {namespace = "Gtk", name = "GridView"})
    Ptr Gtk.ListItemFactory.ListItemFactory -> -- factory : TInterface (Name {namespace = "Gtk", name = "ListItemFactory"})
    IO ()

-- | Sets the t'GI.Gtk.Objects.ListItemFactory.ListItemFactory' to use for populating list items.
gridViewSetFactory ::
    (B.CallStack.HasCallStack, MonadIO m, IsGridView a, Gtk.ListItemFactory.IsListItemFactory b) =>
    a
    -- ^ /@self@/: a t'GI.Gtk.Objects.GridView.GridView'
    -> Maybe (b)
    -- ^ /@factory@/: the factory to use or 'P.Nothing' for none
    -> m ()
gridViewSetFactory :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsGridView a, IsListItemFactory b) =>
a -> Maybe b -> m ()
gridViewSetFactory a
self Maybe b
factory = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr GridView
self' <- a -> IO (Ptr GridView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr ListItemFactory
maybeFactory <- case Maybe b
factory of
        Maybe b
Nothing -> Ptr ListItemFactory -> IO (Ptr ListItemFactory)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ListItemFactory
forall a. Ptr a
nullPtr
        Just b
jFactory -> do
            Ptr ListItemFactory
jFactory' <- b -> IO (Ptr ListItemFactory)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jFactory
            Ptr ListItemFactory -> IO (Ptr ListItemFactory)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ListItemFactory
jFactory'
    Ptr GridView -> Ptr ListItemFactory -> IO ()
gtk_grid_view_set_factory Ptr GridView
self' Ptr ListItemFactory
maybeFactory
    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
factory b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data GridViewSetFactoryMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsGridView a, Gtk.ListItemFactory.IsListItemFactory b) => O.OverloadedMethod GridViewSetFactoryMethodInfo a signature where
    overloadedMethod = gridViewSetFactory

instance O.OverloadedMethodInfo GridViewSetFactoryMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Objects.GridView.gridViewSetFactory",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Objects-GridView.html#v:gridViewSetFactory"
        }


#endif

-- method GridView::set_max_columns
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "GridView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkGridView" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "max_columns"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The maximum number of columns"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_grid_view_set_max_columns" gtk_grid_view_set_max_columns :: 
    Ptr GridView ->                         -- self : TInterface (Name {namespace = "Gtk", name = "GridView"})
    Word32 ->                               -- max_columns : TBasicType TUInt
    IO ()

-- | Sets the maximum number of columns to use. This number must be at least 1.
-- 
-- If /@maxColumns@/ is smaller than the minimum set via
-- 'GI.Gtk.Objects.GridView.gridViewSetMinColumns', that value is used instead.
gridViewSetMaxColumns ::
    (B.CallStack.HasCallStack, MonadIO m, IsGridView a) =>
    a
    -- ^ /@self@/: a t'GI.Gtk.Objects.GridView.GridView'
    -> Word32
    -- ^ /@maxColumns@/: The maximum number of columns
    -> m ()
gridViewSetMaxColumns :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsGridView a) =>
a -> Word32 -> m ()
gridViewSetMaxColumns a
self Word32
maxColumns = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr GridView
self' <- a -> IO (Ptr GridView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr GridView -> GridViewActivateCallback
gtk_grid_view_set_max_columns Ptr GridView
self' Word32
maxColumns
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data GridViewSetMaxColumnsMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsGridView a) => O.OverloadedMethod GridViewSetMaxColumnsMethodInfo a signature where
    overloadedMethod = gridViewSetMaxColumns

instance O.OverloadedMethodInfo GridViewSetMaxColumnsMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Objects.GridView.gridViewSetMaxColumns",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Objects-GridView.html#v:gridViewSetMaxColumns"
        }


#endif

-- method GridView::set_min_columns
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "GridView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkGridView" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "min_columns"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The minimum number of columns"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_grid_view_set_min_columns" gtk_grid_view_set_min_columns :: 
    Ptr GridView ->                         -- self : TInterface (Name {namespace = "Gtk", name = "GridView"})
    Word32 ->                               -- min_columns : TBasicType TUInt
    IO ()

-- | Sets the minimum number of columns to use. This number must be at least 1.
-- 
-- If /@minColumns@/ is smaller than the minimum set via
-- 'GI.Gtk.Objects.GridView.gridViewSetMaxColumns', that value is ignored.
gridViewSetMinColumns ::
    (B.CallStack.HasCallStack, MonadIO m, IsGridView a) =>
    a
    -- ^ /@self@/: a t'GI.Gtk.Objects.GridView.GridView'
    -> Word32
    -- ^ /@minColumns@/: The minimum number of columns
    -> m ()
gridViewSetMinColumns :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsGridView a) =>
a -> Word32 -> m ()
gridViewSetMinColumns a
self Word32
minColumns = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr GridView
self' <- a -> IO (Ptr GridView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr GridView -> GridViewActivateCallback
gtk_grid_view_set_min_columns Ptr GridView
self' Word32
minColumns
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data GridViewSetMinColumnsMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsGridView a) => O.OverloadedMethod GridViewSetMinColumnsMethodInfo a signature where
    overloadedMethod = gridViewSetMinColumns

instance O.OverloadedMethodInfo GridViewSetMinColumnsMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Objects.GridView.gridViewSetMinColumns",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Objects-GridView.html#v:gridViewSetMinColumns"
        }


#endif

-- method GridView::set_model
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "GridView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkGridView" , 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 or %NULL for none"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

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

-- | Sets the t'GI.Gtk.Interfaces.SelectionModel.SelectionModel' to use for
gridViewSetModel ::
    (B.CallStack.HasCallStack, MonadIO m, IsGridView a, Gtk.SelectionModel.IsSelectionModel b) =>
    a
    -- ^ /@self@/: a t'GI.Gtk.Objects.GridView.GridView'
    -> Maybe (b)
    -- ^ /@model@/: the model to use or 'P.Nothing' for none
    -> m ()
gridViewSetModel :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsGridView a, IsSelectionModel b) =>
a -> Maybe b -> m ()
gridViewSetModel a
self Maybe b
model = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr GridView
self' <- a -> IO (Ptr GridView)
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 (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 (m :: * -> *) a. Monad m => a -> m a
return Ptr SelectionModel
jModel'
    Ptr GridView -> Ptr SelectionModel -> IO ()
gtk_grid_view_set_model Ptr GridView
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 (m :: * -> *) a. Monad m => a -> m a
return ()

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

instance O.OverloadedMethodInfo GridViewSetModelMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Objects.GridView.gridViewSetModel",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Objects-GridView.html#v:gridViewSetModel"
        }


#endif

-- method GridView::set_single_click_activate
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "GridView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkGridView" , 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_grid_view_set_single_click_activate" gtk_grid_view_set_single_click_activate :: 
    Ptr GridView ->                         -- self : TInterface (Name {namespace = "Gtk", name = "GridView"})
    CInt ->                                 -- single_click_activate : TBasicType TBoolean
    IO ()

-- | Sets whether items should be activated on single click and
-- selected on hover.
gridViewSetSingleClickActivate ::
    (B.CallStack.HasCallStack, MonadIO m, IsGridView a) =>
    a
    -- ^ /@self@/: a t'GI.Gtk.Objects.GridView.GridView'
    -> Bool
    -- ^ /@singleClickActivate@/: 'P.True' to activate items on single click
    -> m ()
gridViewSetSingleClickActivate :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsGridView a) =>
a -> Bool -> m ()
gridViewSetSingleClickActivate a
self Bool
singleClickActivate = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr GridView
self' <- a -> IO (Ptr GridView)
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 GridView -> CInt -> IO ()
gtk_grid_view_set_single_click_activate Ptr GridView
self' CInt
singleClickActivate'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data GridViewSetSingleClickActivateMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsGridView a) => O.OverloadedMethod GridViewSetSingleClickActivateMethodInfo a signature where
    overloadedMethod = gridViewSetSingleClickActivate

instance O.OverloadedMethodInfo GridViewSetSingleClickActivateMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Objects.GridView.gridViewSetSingleClickActivate",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Objects-GridView.html#v:gridViewSetSingleClickActivate"
        }


#endif