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

    -- | Copyright  : Will Thompson and Iñaki García Etxebarria
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria
    --
    -- @GtkIconView@ is a widget which displays data in a grid of icons.
    --
    -- \<picture>
    --   \<source srcset=\"icon-view-dark.png\" media=\"(prefers-color-scheme: dark)\">
    --   \<img alt=\"An example GtkIconView\" src=\"icon-view.png\">
    -- \<\/picture>
    --
    -- @GtkIconView@ provides an alternative view on a @GtkTreeModel@.
    -- It displays the model as a grid of icons with labels. Like
    -- t'GI.Gtk.Objects.TreeView.TreeView', it allows to select one or multiple items
    -- (depending on the selection mode, see 'GI.Gtk.Objects.IconView.iconViewSetSelectionMode').
    -- In addition to selection with the arrow keys, @GtkIconView@ supports
    -- rubberband selection, which is controlled by dragging the pointer.
    --
    -- Note that if the tree model is backed by an actual tree store (as
    -- opposed to a flat list where the mapping to icons is obvious),
    -- @GtkIconView@ will only display the first level of the tree and
    -- ignore the tree’s branches.
    --
    -- == CSS nodes
    --
    --
    --
    -- >iconview.view
    -- >╰── [rubberband]
    --
    --
    -- @GtkIconView@ has a single CSS node with name iconview and style class .view.
    -- For rubberband selection, a subnode with name rubberband is used.

    #if !defined(__HADDOCK_VERSION__)
    #define ENABLE_OVERLOADING
    #endif

    module GI.Gtk.Objects.IconView
        (

    -- * Exported types
        IconView(..)                            ,
        IsIconView                              ,
        toIconView                              ,

     -- * 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"), [addAttribute]("GI.Gtk.Interfaces.CellLayout#g:method:addAttribute"), [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"), [announce]("GI.Gtk.Interfaces.Accessible#g:method:announce"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [childFocus]("GI.Gtk.Objects.Widget#g:method:childFocus"), [clear]("GI.Gtk.Interfaces.CellLayout#g:method:clear"), [clearAttributes]("GI.Gtk.Interfaces.CellLayout#g:method:clearAttributes"), [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"), [createDragIcon]("GI.Gtk.Objects.IconView#g:method:createDragIcon"), [createPangoContext]("GI.Gtk.Objects.Widget#g:method:createPangoContext"), [createPangoLayout]("GI.Gtk.Objects.Widget#g:method:createPangoLayout"), [disposeTemplate]("GI.Gtk.Objects.Widget#g:method:disposeTemplate"), [dragCheckThreshold]("GI.Gtk.Objects.Widget#g:method:dragCheckThreshold"), [enableModelDragDest]("GI.Gtk.Objects.IconView#g:method:enableModelDragDest"), [enableModelDragSource]("GI.Gtk.Objects.IconView#g:method:enableModelDragSource"), [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"), [itemActivated]("GI.Gtk.Objects.IconView#g:method:itemActivated"), [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"), [packEnd]("GI.Gtk.Interfaces.CellLayout#g:method:packEnd"), [packStart]("GI.Gtk.Interfaces.CellLayout#g:method:packStart"), [pathIsSelected]("GI.Gtk.Objects.IconView#g:method:pathIsSelected"), [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"), [reorder]("GI.Gtk.Interfaces.CellLayout#g:method:reorder"), [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"), [scrollToPath]("GI.Gtk.Objects.IconView#g:method:scrollToPath"), [selectAll]("GI.Gtk.Objects.IconView#g:method:selectAll"), [selectPath]("GI.Gtk.Objects.IconView#g:method:selectPath"), [selectedForeach]("GI.Gtk.Objects.IconView#g:method:selectedForeach"), [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"), [unselectAll]("GI.Gtk.Objects.IconView#g:method:unselectAll"), [unselectPath]("GI.Gtk.Objects.IconView#g:method:unselectPath"), [unsetModelDragDest]("GI.Gtk.Objects.IconView#g:method:unsetModelDragDest"), [unsetModelDragSource]("GI.Gtk.Objects.IconView#g:method:unsetModelDragSource"), [unsetStateFlags]("GI.Gtk.Objects.Widget#g:method:unsetStateFlags"), [updateNextAccessibleSibling]("GI.Gtk.Interfaces.Accessible#g:method:updateNextAccessibleSibling"), [updatePlatformState]("GI.Gtk.Interfaces.Accessible#g:method:updatePlatformState"), [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
    -- [getAccessibleId]("GI.Gtk.Interfaces.Accessible#g:method:getAccessibleId"), [getAccessibleParent]("GI.Gtk.Interfaces.Accessible#g:method:getAccessibleParent"), [getAccessibleRole]("GI.Gtk.Interfaces.Accessible#g:method:getAccessibleRole"), [getActivateOnSingleClick]("GI.Gtk.Objects.IconView#g:method:getActivateOnSingleClick"), [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"), [getArea]("GI.Gtk.Interfaces.CellLayout#g:method:getArea"), [getAtContext]("GI.Gtk.Interfaces.Accessible#g:method:getAtContext"), [getBaseline]("GI.Gtk.Objects.Widget#g:method:getBaseline"), [getBorder]("GI.Gtk.Interfaces.Scrollable#g:method:getBorder"), [getBounds]("GI.Gtk.Interfaces.Accessible#g:method:getBounds"), [getBuildableId]("GI.Gtk.Interfaces.Buildable#g:method:getBuildableId"), [getCanFocus]("GI.Gtk.Objects.Widget#g:method:getCanFocus"), [getCanTarget]("GI.Gtk.Objects.Widget#g:method:getCanTarget"), [getCellRect]("GI.Gtk.Objects.IconView#g:method:getCellRect"), [getCells]("GI.Gtk.Interfaces.CellLayout#g:method:getCells"), [getChildVisible]("GI.Gtk.Objects.Widget#g:method:getChildVisible"), [getClipboard]("GI.Gtk.Objects.Widget#g:method:getClipboard"), [getColor]("GI.Gtk.Objects.Widget#g:method:getColor"), [getColumnSpacing]("GI.Gtk.Objects.IconView#g:method:getColumnSpacing"), [getColumns]("GI.Gtk.Objects.IconView#g:method:getColumns"), [getCssClasses]("GI.Gtk.Objects.Widget#g:method:getCssClasses"), [getCssName]("GI.Gtk.Objects.Widget#g:method:getCssName"), [getCursor]("GI.Gtk.Objects.IconView#g:method:getCursor"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getDestItemAtPos]("GI.Gtk.Objects.IconView#g:method:getDestItemAtPos"), [getDirection]("GI.Gtk.Objects.Widget#g:method:getDirection"), [getDisplay]("GI.Gtk.Objects.Widget#g:method:getDisplay"), [getDragDestItem]("GI.Gtk.Objects.IconView#g:method:getDragDestItem"), [getFirstAccessibleChild]("GI.Gtk.Interfaces.Accessible#g:method:getFirstAccessibleChild"), [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"), [getItemAtPos]("GI.Gtk.Objects.IconView#g:method:getItemAtPos"), [getItemColumn]("GI.Gtk.Objects.IconView#g:method:getItemColumn"), [getItemOrientation]("GI.Gtk.Objects.IconView#g:method:getItemOrientation"), [getItemPadding]("GI.Gtk.Objects.IconView#g:method:getItemPadding"), [getItemRow]("GI.Gtk.Objects.IconView#g:method:getItemRow"), [getItemWidth]("GI.Gtk.Objects.IconView#g:method:getItemWidth"), [getLastChild]("GI.Gtk.Objects.Widget#g:method:getLastChild"), [getLayoutManager]("GI.Gtk.Objects.Widget#g:method:getLayoutManager"), [getLimitEvents]("GI.Gtk.Objects.Widget#g:method:getLimitEvents"), [getMapped]("GI.Gtk.Objects.Widget#g:method:getMapped"), [getMargin]("GI.Gtk.Objects.IconView#g:method:getMargin"), [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"), [getMarkupColumn]("GI.Gtk.Objects.IconView#g:method:getMarkupColumn"), [getModel]("GI.Gtk.Objects.IconView#g:method:getModel"), [getName]("GI.Gtk.Objects.Widget#g:method:getName"), [getNative]("GI.Gtk.Objects.Widget#g:method:getNative"), [getNextAccessibleSibling]("GI.Gtk.Interfaces.Accessible#g:method:getNextAccessibleSibling"), [getNextSibling]("GI.Gtk.Objects.Widget#g:method:getNextSibling"), [getOpacity]("GI.Gtk.Objects.Widget#g:method:getOpacity"), [getOverflow]("GI.Gtk.Objects.Widget#g:method:getOverflow"), [getPangoContext]("GI.Gtk.Objects.Widget#g:method:getPangoContext"), [getParent]("GI.Gtk.Objects.Widget#g:method:getParent"), [getPathAtPos]("GI.Gtk.Objects.IconView#g:method:getPathAtPos"), [getPixbufColumn]("GI.Gtk.Objects.IconView#g:method:getPixbufColumn"), [getPlatformState]("GI.Gtk.Interfaces.Accessible#g:method:getPlatformState"), [getPreferredSize]("GI.Gtk.Objects.Widget#g:method:getPreferredSize"), [getPrevSibling]("GI.Gtk.Objects.Widget#g:method:getPrevSibling"), [getPrimaryClipboard]("GI.Gtk.Objects.Widget#g:method:getPrimaryClipboard"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getRealized]("GI.Gtk.Objects.Widget#g:method:getRealized"), [getReceivesDefault]("GI.Gtk.Objects.Widget#g:method:getReceivesDefault"), [getReorderable]("GI.Gtk.Objects.IconView#g:method:getReorderable"), [getRequestMode]("GI.Gtk.Objects.Widget#g:method:getRequestMode"), [getRoot]("GI.Gtk.Objects.Widget#g:method:getRoot"), [getRowSpacing]("GI.Gtk.Objects.IconView#g:method:getRowSpacing"), [getScaleFactor]("GI.Gtk.Objects.Widget#g:method:getScaleFactor"), [getSelectedItems]("GI.Gtk.Objects.IconView#g:method:getSelectedItems"), [getSelectionMode]("GI.Gtk.Objects.IconView#g:method:getSelectionMode"), [getSensitive]("GI.Gtk.Objects.Widget#g:method:getSensitive"), [getSettings]("GI.Gtk.Objects.Widget#g:method:getSettings"), [getSize]("GI.Gtk.Objects.Widget#g:method:getSize"), [getSizeRequest]("GI.Gtk.Objects.Widget#g:method:getSizeRequest"), [getSpacing]("GI.Gtk.Objects.IconView#g:method:getSpacing"), [getStateFlags]("GI.Gtk.Objects.Widget#g:method:getStateFlags"), [getStyleContext]("GI.Gtk.Objects.Widget#g:method:getStyleContext"), [getTemplateChild]("GI.Gtk.Objects.Widget#g:method:getTemplateChild"), [getTextColumn]("GI.Gtk.Objects.IconView#g:method:getTextColumn"), [getTooltipColumn]("GI.Gtk.Objects.IconView#g:method:getTooltipColumn"), [getTooltipContext]("GI.Gtk.Objects.IconView#g:method:getTooltipContext"), [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"), [getVisibleRange]("GI.Gtk.Objects.IconView#g:method:getVisibleRange"), [getVscrollPolicy]("GI.Gtk.Interfaces.Scrollable#g:method:getVscrollPolicy"), [getWidth]("GI.Gtk.Objects.Widget#g:method:getWidth").
    --
    -- ==== Setters
    -- [setAccessibleParent]("GI.Gtk.Interfaces.Accessible#g:method:setAccessibleParent"), [setActivateOnSingleClick]("GI.Gtk.Objects.IconView#g:method:setActivateOnSingleClick"), [setCanFocus]("GI.Gtk.Objects.Widget#g:method:setCanFocus"), [setCanTarget]("GI.Gtk.Objects.Widget#g:method:setCanTarget"), [setCellDataFunc]("GI.Gtk.Interfaces.CellLayout#g:method:setCellDataFunc"), [setChildVisible]("GI.Gtk.Objects.Widget#g:method:setChildVisible"), [setColumnSpacing]("GI.Gtk.Objects.IconView#g:method:setColumnSpacing"), [setColumns]("GI.Gtk.Objects.IconView#g:method:setColumns"), [setCssClasses]("GI.Gtk.Objects.Widget#g:method:setCssClasses"), [setCursor]("GI.Gtk.Objects.IconView#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"), [setDragDestItem]("GI.Gtk.Objects.IconView#g:method:setDragDestItem"), [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"), [setItemOrientation]("GI.Gtk.Objects.IconView#g:method:setItemOrientation"), [setItemPadding]("GI.Gtk.Objects.IconView#g:method:setItemPadding"), [setItemWidth]("GI.Gtk.Objects.IconView#g:method:setItemWidth"), [setLayoutManager]("GI.Gtk.Objects.Widget#g:method:setLayoutManager"), [setLimitEvents]("GI.Gtk.Objects.Widget#g:method:setLimitEvents"), [setMargin]("GI.Gtk.Objects.IconView#g:method:setMargin"), [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"), [setMarkupColumn]("GI.Gtk.Objects.IconView#g:method:setMarkupColumn"), [setModel]("GI.Gtk.Objects.IconView#g:method:setModel"), [setName]("GI.Gtk.Objects.Widget#g:method:setName"), [setOpacity]("GI.Gtk.Objects.Widget#g:method:setOpacity"), [setOverflow]("GI.Gtk.Objects.Widget#g:method:setOverflow"), [setParent]("GI.Gtk.Objects.Widget#g:method:setParent"), [setPixbufColumn]("GI.Gtk.Objects.IconView#g:method:setPixbufColumn"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setReceivesDefault]("GI.Gtk.Objects.Widget#g:method:setReceivesDefault"), [setReorderable]("GI.Gtk.Objects.IconView#g:method:setReorderable"), [setRowSpacing]("GI.Gtk.Objects.IconView#g:method:setRowSpacing"), [setSelectionMode]("GI.Gtk.Objects.IconView#g:method:setSelectionMode"), [setSensitive]("GI.Gtk.Objects.Widget#g:method:setSensitive"), [setSizeRequest]("GI.Gtk.Objects.Widget#g:method:setSizeRequest"), [setSpacing]("GI.Gtk.Objects.IconView#g:method:setSpacing"), [setStateFlags]("GI.Gtk.Objects.Widget#g:method:setStateFlags"), [setTextColumn]("GI.Gtk.Objects.IconView#g:method:setTextColumn"), [setTooltipCell]("GI.Gtk.Objects.IconView#g:method:setTooltipCell"), [setTooltipColumn]("GI.Gtk.Objects.IconView#g:method:setTooltipColumn"), [setTooltipItem]("GI.Gtk.Objects.IconView#g:method:setTooltipItem"), [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)
        ResolveIconViewMethod                   ,
    #endif

    -- ** createDragIcon #method:createDragIcon#

    #if defined(ENABLE_OVERLOADING)
        IconViewCreateDragIconMethodInfo        ,
    #endif
        iconViewCreateDragIcon                  ,

    -- ** enableModelDragDest #method:enableModelDragDest#

    #if defined(ENABLE_OVERLOADING)
        IconViewEnableModelDragDestMethodInfo   ,
    #endif
        iconViewEnableModelDragDest             ,

    -- ** enableModelDragSource #method:enableModelDragSource#

    #if defined(ENABLE_OVERLOADING)
        IconViewEnableModelDragSourceMethodInfo ,
    #endif
        iconViewEnableModelDragSource           ,

    -- ** getActivateOnSingleClick #method:getActivateOnSingleClick#

    #if defined(ENABLE_OVERLOADING)
        IconViewGetActivateOnSingleClickMethodInfo,
    #endif
        iconViewGetActivateOnSingleClick        ,

    -- ** getCellRect #method:getCellRect#

    #if defined(ENABLE_OVERLOADING)
        IconViewGetCellRectMethodInfo           ,
    #endif
        iconViewGetCellRect                     ,

    -- ** getColumnSpacing #method:getColumnSpacing#

    #if defined(ENABLE_OVERLOADING)
        IconViewGetColumnSpacingMethodInfo      ,
    #endif
        iconViewGetColumnSpacing                ,

    -- ** getColumns #method:getColumns#

    #if defined(ENABLE_OVERLOADING)
        IconViewGetColumnsMethodInfo            ,
    #endif
        iconViewGetColumns                      ,

    -- ** getCursor #method:getCursor#

    #if defined(ENABLE_OVERLOADING)
        IconViewGetCursorMethodInfo             ,
    #endif
        iconViewGetCursor                       ,

    -- ** getDestItemAtPos #method:getDestItemAtPos#

    #if defined(ENABLE_OVERLOADING)
        IconViewGetDestItemAtPosMethodInfo      ,
    #endif
        iconViewGetDestItemAtPos                ,

    -- ** getDragDestItem #method:getDragDestItem#

    #if defined(ENABLE_OVERLOADING)
        IconViewGetDragDestItemMethodInfo       ,
    #endif
        iconViewGetDragDestItem                 ,

    -- ** getItemAtPos #method:getItemAtPos#

    #if defined(ENABLE_OVERLOADING)
        IconViewGetItemAtPosMethodInfo          ,
    #endif
        iconViewGetItemAtPos                    ,

    -- ** getItemColumn #method:getItemColumn#

    #if defined(ENABLE_OVERLOADING)
        IconViewGetItemColumnMethodInfo         ,
    #endif
        iconViewGetItemColumn                   ,

    -- ** getItemOrientation #method:getItemOrientation#

    #if defined(ENABLE_OVERLOADING)
        IconViewGetItemOrientationMethodInfo    ,
    #endif
        iconViewGetItemOrientation              ,

    -- ** getItemPadding #method:getItemPadding#

    #if defined(ENABLE_OVERLOADING)
        IconViewGetItemPaddingMethodInfo        ,
    #endif
        iconViewGetItemPadding                  ,

    -- ** getItemRow #method:getItemRow#

    #if defined(ENABLE_OVERLOADING)
        IconViewGetItemRowMethodInfo            ,
    #endif
        iconViewGetItemRow                      ,

    -- ** getItemWidth #method:getItemWidth#

    #if defined(ENABLE_OVERLOADING)
        IconViewGetItemWidthMethodInfo          ,
    #endif
        iconViewGetItemWidth                    ,

    -- ** getMargin #method:getMargin#

    #if defined(ENABLE_OVERLOADING)
        IconViewGetMarginMethodInfo             ,
    #endif
        iconViewGetMargin                       ,

    -- ** getMarkupColumn #method:getMarkupColumn#

    #if defined(ENABLE_OVERLOADING)
        IconViewGetMarkupColumnMethodInfo       ,
    #endif
        iconViewGetMarkupColumn                 ,

    -- ** getModel #method:getModel#

    #if defined(ENABLE_OVERLOADING)
        IconViewGetModelMethodInfo              ,
    #endif
        iconViewGetModel                        ,

    -- ** getPathAtPos #method:getPathAtPos#

    #if defined(ENABLE_OVERLOADING)
        IconViewGetPathAtPosMethodInfo          ,
    #endif
        iconViewGetPathAtPos                    ,

    -- ** getPixbufColumn #method:getPixbufColumn#

    #if defined(ENABLE_OVERLOADING)
        IconViewGetPixbufColumnMethodInfo       ,
    #endif
        iconViewGetPixbufColumn                 ,

    -- ** getReorderable #method:getReorderable#

    #if defined(ENABLE_OVERLOADING)
        IconViewGetReorderableMethodInfo        ,
    #endif
        iconViewGetReorderable                  ,

    -- ** getRowSpacing #method:getRowSpacing#

    #if defined(ENABLE_OVERLOADING)
        IconViewGetRowSpacingMethodInfo         ,
    #endif
        iconViewGetRowSpacing                   ,

    -- ** getSelectedItems #method:getSelectedItems#

    #if defined(ENABLE_OVERLOADING)
        IconViewGetSelectedItemsMethodInfo      ,
    #endif
        iconViewGetSelectedItems                ,

    -- ** getSelectionMode #method:getSelectionMode#

    #if defined(ENABLE_OVERLOADING)
        IconViewGetSelectionModeMethodInfo      ,
    #endif
        iconViewGetSelectionMode                ,

    -- ** getSpacing #method:getSpacing#

    #if defined(ENABLE_OVERLOADING)
        IconViewGetSpacingMethodInfo            ,
    #endif
        iconViewGetSpacing                      ,

    -- ** getTextColumn #method:getTextColumn#

    #if defined(ENABLE_OVERLOADING)
        IconViewGetTextColumnMethodInfo         ,
    #endif
        iconViewGetTextColumn                   ,

    -- ** getTooltipColumn #method:getTooltipColumn#

    #if defined(ENABLE_OVERLOADING)
        IconViewGetTooltipColumnMethodInfo      ,
    #endif
        iconViewGetTooltipColumn                ,

    -- ** getTooltipContext #method:getTooltipContext#

    #if defined(ENABLE_OVERLOADING)
        IconViewGetTooltipContextMethodInfo     ,
    #endif
        iconViewGetTooltipContext               ,

    -- ** getVisibleRange #method:getVisibleRange#

    #if defined(ENABLE_OVERLOADING)
        IconViewGetVisibleRangeMethodInfo       ,
    #endif
        iconViewGetVisibleRange                 ,

    -- ** itemActivated #method:itemActivated#

    #if defined(ENABLE_OVERLOADING)
        IconViewItemActivatedMethodInfo         ,
    #endif
        iconViewItemActivated                   ,

    -- ** new #method:new#

        iconViewNew                             ,

    -- ** newWithArea #method:newWithArea#

        iconViewNewWithArea                     ,

    -- ** newWithModel #method:newWithModel#

        iconViewNewWithModel                    ,

    -- ** pathIsSelected #method:pathIsSelected#

    #if defined(ENABLE_OVERLOADING)
        IconViewPathIsSelectedMethodInfo        ,
    #endif
        iconViewPathIsSelected                  ,

    -- ** scrollToPath #method:scrollToPath#

    #if defined(ENABLE_OVERLOADING)
        IconViewScrollToPathMethodInfo          ,
    #endif
        iconViewScrollToPath                    ,

    -- ** selectAll #method:selectAll#

    #if defined(ENABLE_OVERLOADING)
        IconViewSelectAllMethodInfo             ,
    #endif
        iconViewSelectAll                       ,

    -- ** selectPath #method:selectPath#

    #if defined(ENABLE_OVERLOADING)
        IconViewSelectPathMethodInfo            ,
    #endif
        iconViewSelectPath                      ,

    -- ** selectedForeach #method:selectedForeach#

    #if defined(ENABLE_OVERLOADING)
        IconViewSelectedForeachMethodInfo       ,
    #endif
        iconViewSelectedForeach                 ,

    -- ** setActivateOnSingleClick #method:setActivateOnSingleClick#

    #if defined(ENABLE_OVERLOADING)
        IconViewSetActivateOnSingleClickMethodInfo,
    #endif
        iconViewSetActivateOnSingleClick        ,

    -- ** setColumnSpacing #method:setColumnSpacing#

    #if defined(ENABLE_OVERLOADING)
        IconViewSetColumnSpacingMethodInfo      ,
    #endif
        iconViewSetColumnSpacing                ,

    -- ** setColumns #method:setColumns#

    #if defined(ENABLE_OVERLOADING)
        IconViewSetColumnsMethodInfo            ,
    #endif
        iconViewSetColumns                      ,

    -- ** setCursor #method:setCursor#

    #if defined(ENABLE_OVERLOADING)
        IconViewSetCursorMethodInfo             ,
    #endif
        iconViewSetCursor                       ,

    -- ** setDragDestItem #method:setDragDestItem#

    #if defined(ENABLE_OVERLOADING)
        IconViewSetDragDestItemMethodInfo       ,
    #endif
        iconViewSetDragDestItem                 ,

    -- ** setItemOrientation #method:setItemOrientation#

    #if defined(ENABLE_OVERLOADING)
        IconViewSetItemOrientationMethodInfo    ,
    #endif
        iconViewSetItemOrientation              ,

    -- ** setItemPadding #method:setItemPadding#

    #if defined(ENABLE_OVERLOADING)
        IconViewSetItemPaddingMethodInfo        ,
    #endif
        iconViewSetItemPadding                  ,

    -- ** setItemWidth #method:setItemWidth#

    #if defined(ENABLE_OVERLOADING)
        IconViewSetItemWidthMethodInfo          ,
    #endif
        iconViewSetItemWidth                    ,

    -- ** setMargin #method:setMargin#

    #if defined(ENABLE_OVERLOADING)
        IconViewSetMarginMethodInfo             ,
    #endif
        iconViewSetMargin                       ,

    -- ** setMarkupColumn #method:setMarkupColumn#

    #if defined(ENABLE_OVERLOADING)
        IconViewSetMarkupColumnMethodInfo       ,
    #endif
        iconViewSetMarkupColumn                 ,

    -- ** setModel #method:setModel#

    #if defined(ENABLE_OVERLOADING)
        IconViewSetModelMethodInfo              ,
    #endif
        iconViewSetModel                        ,

    -- ** setPixbufColumn #method:setPixbufColumn#

    #if defined(ENABLE_OVERLOADING)
        IconViewSetPixbufColumnMethodInfo       ,
    #endif
        iconViewSetPixbufColumn                 ,

    -- ** setReorderable #method:setReorderable#

    #if defined(ENABLE_OVERLOADING)
        IconViewSetReorderableMethodInfo        ,
    #endif
        iconViewSetReorderable                  ,

    -- ** setRowSpacing #method:setRowSpacing#

    #if defined(ENABLE_OVERLOADING)
        IconViewSetRowSpacingMethodInfo         ,
    #endif
        iconViewSetRowSpacing                   ,

    -- ** setSelectionMode #method:setSelectionMode#

    #if defined(ENABLE_OVERLOADING)
        IconViewSetSelectionModeMethodInfo      ,
    #endif
        iconViewSetSelectionMode                ,

    -- ** setSpacing #method:setSpacing#

    #if defined(ENABLE_OVERLOADING)
        IconViewSetSpacingMethodInfo            ,
    #endif
        iconViewSetSpacing                      ,

    -- ** setTextColumn #method:setTextColumn#

    #if defined(ENABLE_OVERLOADING)
        IconViewSetTextColumnMethodInfo         ,
    #endif
        iconViewSetTextColumn                   ,

    -- ** setTooltipCell #method:setTooltipCell#

    #if defined(ENABLE_OVERLOADING)
        IconViewSetTooltipCellMethodInfo        ,
    #endif
        iconViewSetTooltipCell                  ,

    -- ** setTooltipColumn #method:setTooltipColumn#

    #if defined(ENABLE_OVERLOADING)
        IconViewSetTooltipColumnMethodInfo      ,
    #endif
        iconViewSetTooltipColumn                ,

    -- ** setTooltipItem #method:setTooltipItem#

    #if defined(ENABLE_OVERLOADING)
        IconViewSetTooltipItemMethodInfo        ,
    #endif
        iconViewSetTooltipItem                  ,

    -- ** unselectAll #method:unselectAll#

    #if defined(ENABLE_OVERLOADING)
        IconViewUnselectAllMethodInfo           ,
    #endif
        iconViewUnselectAll                     ,

    -- ** unselectPath #method:unselectPath#

    #if defined(ENABLE_OVERLOADING)
        IconViewUnselectPathMethodInfo          ,
    #endif
        iconViewUnselectPath                    ,

    -- ** unsetModelDragDest #method:unsetModelDragDest#

    #if defined(ENABLE_OVERLOADING)
        IconViewUnsetModelDragDestMethodInfo    ,
    #endif
        iconViewUnsetModelDragDest              ,

    -- ** unsetModelDragSource #method:unsetModelDragSource#

    #if defined(ENABLE_OVERLOADING)
        IconViewUnsetModelDragSourceMethodInfo  ,
    #endif
        iconViewUnsetModelDragSource            ,

     -- * Properties

    -- ** activateOnSingleClick #attr:activateOnSingleClick#
    -- | The activate-on-single-click property specifies whether the \"item-activated\" signal
    -- will be emitted after a single click.

    #if defined(ENABLE_OVERLOADING)
        IconViewActivateOnSingleClickPropertyInfo,
    #endif
        constructIconViewActivateOnSingleClick  ,
        getIconViewActivateOnSingleClick        ,
    #if defined(ENABLE_OVERLOADING)
        iconViewActivateOnSingleClick           ,
    #endif
        setIconViewActivateOnSingleClick        ,

    -- ** cellArea #attr:cellArea#
    -- | The @GtkCellArea@ used to layout cell renderers for this view.
    --
    -- If no area is specified when creating the icon view with 'GI.Gtk.Objects.IconView.iconViewNewWithArea'
    -- a @GtkCellAreaBox@ will be used.

    #if defined(ENABLE_OVERLOADING)
        IconViewCellAreaPropertyInfo            ,
    #endif
        constructIconViewCellArea               ,
        getIconViewCellArea                     ,
    #if defined(ENABLE_OVERLOADING)
        iconViewCellArea                        ,
    #endif

    -- ** columnSpacing #attr:columnSpacing#
    -- | The column-spacing property specifies the space which is inserted between
    -- the columns of the icon view.

    #if defined(ENABLE_OVERLOADING)
        IconViewColumnSpacingPropertyInfo       ,
    #endif
        constructIconViewColumnSpacing          ,
        getIconViewColumnSpacing                ,
    #if defined(ENABLE_OVERLOADING)
        iconViewColumnSpacing                   ,
    #endif
        setIconViewColumnSpacing                ,

    -- ** columns #attr:columns#
    -- | The columns property contains the number of the columns in which the
    -- items should be displayed. If it is -1, the number of columns will
    -- be chosen automatically to fill the available area.

    #if defined(ENABLE_OVERLOADING)
        IconViewColumnsPropertyInfo             ,
    #endif
        constructIconViewColumns                ,
        getIconViewColumns                      ,
    #if defined(ENABLE_OVERLOADING)
        iconViewColumns                         ,
    #endif
        setIconViewColumns                      ,

    -- ** itemOrientation #attr:itemOrientation#
    -- | The item-orientation property specifies how the cells (i.e. the icon and
    -- the text) of the item are positioned relative to each other.

    #if defined(ENABLE_OVERLOADING)
        IconViewItemOrientationPropertyInfo     ,
    #endif
        constructIconViewItemOrientation        ,
        getIconViewItemOrientation              ,
    #if defined(ENABLE_OVERLOADING)
        iconViewItemOrientation                 ,
    #endif
        setIconViewItemOrientation              ,

    -- ** itemPadding #attr:itemPadding#
    -- | The item-padding property specifies the padding around each
    -- of the icon view\'s item.

    #if defined(ENABLE_OVERLOADING)
        IconViewItemPaddingPropertyInfo         ,
    #endif
        constructIconViewItemPadding            ,
        getIconViewItemPadding                  ,
    #if defined(ENABLE_OVERLOADING)
        iconViewItemPadding                     ,
    #endif
        setIconViewItemPadding                  ,

    -- ** itemWidth #attr:itemWidth#
    -- | The item-width property specifies the width to use for each item.
    -- If it is set to -1, the icon view will automatically determine a
    -- suitable item size.

    #if defined(ENABLE_OVERLOADING)
        IconViewItemWidthPropertyInfo           ,
    #endif
        constructIconViewItemWidth              ,
        getIconViewItemWidth                    ,
    #if defined(ENABLE_OVERLOADING)
        iconViewItemWidth                       ,
    #endif
        setIconViewItemWidth                    ,

    -- ** margin #attr:margin#
    -- | The margin property specifies the space which is inserted
    -- at the edges of the icon view.

    #if defined(ENABLE_OVERLOADING)
        IconViewMarginPropertyInfo              ,
    #endif
        constructIconViewMargin                 ,
        getIconViewMargin                       ,
    #if defined(ENABLE_OVERLOADING)
        iconViewMargin                          ,
    #endif
        setIconViewMargin                       ,

    -- ** markupColumn #attr:markupColumn#
    -- | The [markupColumn](#g:signal:markupColumn) property contains the number of the model column
    -- containing markup information to be displayed. The markup column must be
    -- of type @G_TYPE_STRING@. If this property and the :text-column property
    -- are both set to column numbers, it overrides the text column.
    -- If both are set to -1, no texts are displayed.

    #if defined(ENABLE_OVERLOADING)
        IconViewMarkupColumnPropertyInfo        ,
    #endif
        constructIconViewMarkupColumn           ,
        getIconViewMarkupColumn                 ,
    #if defined(ENABLE_OVERLOADING)
        iconViewMarkupColumn                    ,
    #endif
        setIconViewMarkupColumn                 ,

    -- ** model #attr:model#
    -- | The model of the icon view.

    #if defined(ENABLE_OVERLOADING)
        IconViewModelPropertyInfo               ,
    #endif
        clearIconViewModel                      ,
        constructIconViewModel                  ,
        getIconViewModel                        ,
    #if defined(ENABLE_OVERLOADING)
        iconViewModel                           ,
    #endif
        setIconViewModel                        ,

    -- ** pixbufColumn #attr:pixbufColumn#
    -- | The [pixbufColumn](#g:signal:pixbufColumn) property contains the number of the model column
    -- containing the pixbufs which are displayed. The pixbuf column must be
    -- of type @GDK_TYPE_PIXBUF@. Setting this property to -1 turns off the
    -- display of pixbufs.

    #if defined(ENABLE_OVERLOADING)
        IconViewPixbufColumnPropertyInfo        ,
    #endif
        constructIconViewPixbufColumn           ,
        getIconViewPixbufColumn                 ,
    #if defined(ENABLE_OVERLOADING)
        iconViewPixbufColumn                    ,
    #endif
        setIconViewPixbufColumn                 ,

    -- ** reorderable #attr:reorderable#
    -- | The reorderable property specifies if the items can be reordered
    -- by DND.

    #if defined(ENABLE_OVERLOADING)
        IconViewReorderablePropertyInfo         ,
    #endif
        constructIconViewReorderable            ,
        getIconViewReorderable                  ,
    #if defined(ENABLE_OVERLOADING)
        iconViewReorderable                     ,
    #endif
        setIconViewReorderable                  ,

    -- ** rowSpacing #attr:rowSpacing#
    -- | The row-spacing property specifies the space which is inserted between
    -- the rows of the icon view.

    #if defined(ENABLE_OVERLOADING)
        IconViewRowSpacingPropertyInfo          ,
    #endif
        constructIconViewRowSpacing             ,
        getIconViewRowSpacing                   ,
    #if defined(ENABLE_OVERLOADING)
        iconViewRowSpacing                      ,
    #endif
        setIconViewRowSpacing                   ,

    -- ** selectionMode #attr:selectionMode#
    -- | The [selectionMode](#g:signal:selectionMode) property specifies the selection mode of
    -- icon view. If the mode is 'GI.Gtk.Enums.SelectionModeMultiple', rubberband selection
    -- is enabled, for the other modes, only keyboard selection is possible.

    #if defined(ENABLE_OVERLOADING)
        IconViewSelectionModePropertyInfo       ,
    #endif
        constructIconViewSelectionMode          ,
        getIconViewSelectionMode                ,
    #if defined(ENABLE_OVERLOADING)
        iconViewSelectionMode                   ,
    #endif
        setIconViewSelectionMode                ,

    -- ** spacing #attr:spacing#
    -- | The spacing property specifies the space which is inserted between
    -- the cells (i.e. the icon and the text) of an item.

    #if defined(ENABLE_OVERLOADING)
        IconViewSpacingPropertyInfo             ,
    #endif
        constructIconViewSpacing                ,
        getIconViewSpacing                      ,
    #if defined(ENABLE_OVERLOADING)
        iconViewSpacing                         ,
    #endif
        setIconViewSpacing                      ,

    -- ** textColumn #attr:textColumn#
    -- | The [textColumn](#g:signal:textColumn) property contains the number of the model column
    -- containing the texts which are displayed. The text column must be
    -- of type @G_TYPE_STRING@. If this property and the :markup-column
    -- property are both set to -1, no texts are displayed.

    #if defined(ENABLE_OVERLOADING)
        IconViewTextColumnPropertyInfo          ,
    #endif
        constructIconViewTextColumn             ,
        getIconViewTextColumn                   ,
    #if defined(ENABLE_OVERLOADING)
        iconViewTextColumn                      ,
    #endif
        setIconViewTextColumn                   ,

    -- ** tooltipColumn #attr:tooltipColumn#
    -- | The column of the icon view model which is being used for displaying
    -- tooltips on it\'s rows.

    #if defined(ENABLE_OVERLOADING)
        IconViewTooltipColumnPropertyInfo       ,
    #endif
        constructIconViewTooltipColumn          ,
        getIconViewTooltipColumn                ,
    #if defined(ENABLE_OVERLOADING)
        iconViewTooltipColumn                   ,
    #endif
        setIconViewTooltipColumn                ,

     -- * Signals

    -- ** activateCursorItem #signal:activateCursorItem#

        IconViewActivateCursorItemCallback      ,
    #if defined(ENABLE_OVERLOADING)
        IconViewActivateCursorItemSignalInfo    ,
    #endif
        afterIconViewActivateCursorItem         ,
        onIconViewActivateCursorItem            ,

    -- ** itemActivated #signal:itemActivated#

        IconViewItemActivatedCallback           ,
    #if defined(ENABLE_OVERLOADING)
        IconViewItemActivatedSignalInfo         ,
    #endif
        afterIconViewItemActivated              ,
        onIconViewItemActivated                 ,

    -- ** moveCursor #signal:moveCursor#

        IconViewMoveCursorCallback              ,
    #if defined(ENABLE_OVERLOADING)
        IconViewMoveCursorSignalInfo            ,
    #endif
        afterIconViewMoveCursor                 ,
        onIconViewMoveCursor                    ,

    -- ** selectAll #signal:selectAll#

        IconViewSelectAllCallback               ,
    #if defined(ENABLE_OVERLOADING)
        IconViewSelectAllSignalInfo             ,
    #endif
        afterIconViewSelectAll                  ,
        onIconViewSelectAll                     ,

    -- ** selectCursorItem #signal:selectCursorItem#

        IconViewSelectCursorItemCallback        ,
    #if defined(ENABLE_OVERLOADING)
        IconViewSelectCursorItemSignalInfo      ,
    #endif
        afterIconViewSelectCursorItem           ,
        onIconViewSelectCursorItem              ,

    -- ** selectionChanged #signal:selectionChanged#

        IconViewSelectionChangedCallback        ,
    #if defined(ENABLE_OVERLOADING)
        IconViewSelectionChangedSignalInfo      ,
    #endif
        afterIconViewSelectionChanged           ,
        onIconViewSelectionChanged              ,

    -- ** toggleCursorItem #signal:toggleCursorItem#

        IconViewToggleCursorItemCallback        ,
    #if defined(ENABLE_OVERLOADING)
        IconViewToggleCursorItemSignalInfo      ,
    #endif
        afterIconViewToggleCursorItem           ,
        onIconViewToggleCursorItem              ,

    -- ** unselectAll #signal:unselectAll#

        IconViewUnselectAllCallback             ,
    #if defined(ENABLE_OVERLOADING)
        IconViewUnselectAllSignalInfo           ,
    #endif
        afterIconViewUnselectAll                ,
        onIconViewUnselectAll                   ,

        ) where

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

    import qualified Data.GI.Base.Attributes as GI.Attributes
    import qualified Data.GI.Base.BasicTypes as B.Types
    import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
    import qualified Data.GI.Base.GArray as B.GArray
    import qualified Data.GI.Base.GClosure as B.GClosure
    import qualified Data.GI.Base.GError as B.GError
    import qualified Data.GI.Base.GHashTable as B.GHT
    import qualified Data.GI.Base.GVariant as B.GVariant
    import qualified Data.GI.Base.GValue as B.GValue
    import qualified Data.GI.Base.GParamSpec as B.GParamSpec
    import qualified Data.GI.Base.CallStack as B.CallStack
    import qualified Data.GI.Base.Properties as B.Properties
    import qualified Data.GI.Base.Signals as B.Signals
    import qualified Control.Monad.IO.Class as MIO
    import qualified Data.Coerce as Coerce
    import qualified Data.Text as T
    import qualified Data.Kind as DK
    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 Data.Word as DW
    import qualified Data.Int as DI
    import qualified System.Posix.Types as SPT
    import qualified Foreign.C.Types as FCT

    -- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
    #if MIN_VERSION_base(4,18,0)
    import qualified GI.Cairo.Structs.Context as Cairo.Context
    import qualified GI.Cairo.Structs.FontOptions as Cairo.FontOptions
    import qualified GI.GLib.Callbacks as GLib.Callbacks
    import qualified GI.GLib.Structs.Bytes as GLib.Bytes
    import qualified GI.GObject.Objects.Object as GObject.Object
    import qualified GI.Gdk.Flags as Gdk.Flags
    import qualified GI.Gdk.Interfaces.Paintable as Gdk.Paintable
    import qualified GI.Gdk.Objects.Clipboard as Gdk.Clipboard
    import qualified GI.Gdk.Objects.Cursor as Gdk.Cursor
    import qualified GI.Gdk.Objects.Device as Gdk.Device
    import qualified GI.Gdk.Objects.Display as Gdk.Display
    import qualified GI.Gdk.Objects.Event as Gdk.Event
    import qualified GI.Gdk.Objects.FrameClock as Gdk.FrameClock
    import qualified GI.Gdk.Objects.Snapshot as Gdk.Snapshot
    import qualified GI.Gdk.Objects.Surface as Gdk.Surface
    import qualified GI.Gdk.Objects.Texture as Gdk.Texture
    import qualified GI.Gdk.Structs.ContentFormats as Gdk.ContentFormats
    import qualified GI.Gdk.Structs.RGBA as Gdk.RGBA
    import qualified GI.Gdk.Structs.Rectangle as Gdk.Rectangle
    import qualified GI.Gio.Interfaces.ActionGroup as Gio.ActionGroup
    import qualified GI.Gio.Interfaces.Icon as Gio.Icon
    import qualified GI.Gio.Interfaces.ListModel as Gio.ListModel
    import qualified GI.Graphene.Structs.Matrix as Graphene.Matrix
    import qualified GI.Graphene.Structs.Point as Graphene.Point
    import qualified GI.Graphene.Structs.Point3D as Graphene.Point3D
    import qualified GI.Graphene.Structs.Rect as Graphene.Rect
    import qualified GI.Graphene.Structs.Size as Graphene.Size
    import qualified GI.Graphene.Structs.Vec3 as Graphene.Vec3
    import qualified GI.Graphene.Structs.Vec4 as Graphene.Vec4
    import qualified GI.Gsk.Enums as Gsk.Enums
    import qualified GI.Gsk.Flags as Gsk.Flags
    import qualified GI.Gsk.Objects.GLShader as Gsk.GLShader
    import qualified GI.Gsk.Objects.RenderNode as Gsk.RenderNode
    import qualified GI.Gsk.Objects.Renderer as Gsk.Renderer
    import qualified GI.Gsk.Structs.ColorStop as Gsk.ColorStop
    import qualified GI.Gsk.Structs.ComponentTransfer as Gsk.ComponentTransfer
    import qualified GI.Gsk.Structs.Path as Gsk.Path
    import qualified GI.Gsk.Structs.RoundedRect as Gsk.RoundedRect
    import qualified GI.Gsk.Structs.Shadow as Gsk.Shadow
    import qualified GI.Gsk.Structs.Stroke as Gsk.Stroke
    import qualified GI.Gsk.Structs.Transform as Gsk.Transform
    import qualified GI.Gtk.Callbacks as Gtk.Callbacks
    import {-# SOURCE #-} qualified GI.Gtk.Enums as Gtk.Enums
    import {-# SOURCE #-} qualified GI.Gtk.Flags as Gtk.Flags
    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.CellEditable as Gtk.CellEditable
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.CellLayout as Gtk.CellLayout
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.ConstraintTarget as Gtk.ConstraintTarget
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Native as Gtk.Native
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Root as Gtk.Root
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Scrollable as Gtk.Scrollable
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.StyleProvider as Gtk.StyleProvider
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.TreeModel as Gtk.TreeModel
    import {-# SOURCE #-} qualified GI.Gtk.Objects.ATContext as Gtk.ATContext
    import {-# SOURCE #-} qualified GI.Gtk.Objects.Adjustment as Gtk.Adjustment
    import {-# SOURCE #-} qualified GI.Gtk.Objects.CellArea as Gtk.CellArea
    import {-# SOURCE #-} qualified GI.Gtk.Objects.CellAreaContext as Gtk.CellAreaContext
    import {-# SOURCE #-} qualified GI.Gtk.Objects.CellRenderer as Gtk.CellRenderer
    import {-# SOURCE #-} qualified GI.Gtk.Objects.EventController as Gtk.EventController
    import {-# SOURCE #-} qualified GI.Gtk.Objects.LayoutChild as Gtk.LayoutChild
    import {-# SOURCE #-} qualified GI.Gtk.Objects.LayoutManager as Gtk.LayoutManager
    import {-# SOURCE #-} qualified GI.Gtk.Objects.Settings as Gtk.Settings
    import {-# SOURCE #-} qualified GI.Gtk.Objects.Snapshot as Gtk.Snapshot
    import {-# SOURCE #-} qualified GI.Gtk.Objects.StyleContext as Gtk.StyleContext
    import {-# SOURCE #-} qualified GI.Gtk.Objects.Tooltip as Gtk.Tooltip
    import {-# SOURCE #-} qualified GI.Gtk.Objects.Widget as Gtk.Widget
    import {-# SOURCE #-} qualified GI.Gtk.Structs.Border as Gtk.Border
    import {-# SOURCE #-} qualified GI.Gtk.Structs.Requisition as Gtk.Requisition
    import {-# SOURCE #-} qualified GI.Gtk.Structs.TreeIter as Gtk.TreeIter
    import {-# SOURCE #-} qualified GI.Gtk.Structs.TreePath as Gtk.TreePath
    import qualified GI.Pango.Enums as Pango.Enums
    import qualified GI.Pango.Objects.Context as Pango.Context
    import qualified GI.Pango.Objects.FontMap as Pango.FontMap
    import qualified GI.Pango.Objects.Layout as Pango.Layout

    #else
    import qualified GI.GObject.Objects.Object as GObject.Object
    import qualified GI.Gdk.Flags as Gdk.Flags
    import qualified GI.Gdk.Interfaces.Paintable as Gdk.Paintable
    import qualified GI.Gdk.Structs.ContentFormats as Gdk.ContentFormats
    import qualified GI.Gdk.Structs.Rectangle as Gdk.Rectangle
    import qualified GI.Gtk.Callbacks as Gtk.Callbacks
    import {-# SOURCE #-} qualified GI.Gtk.Enums as Gtk.Enums
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Accessible as Gtk.Accessible
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.CellLayout as Gtk.CellLayout
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.ConstraintTarget as Gtk.ConstraintTarget
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Scrollable as Gtk.Scrollable
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.TreeModel as Gtk.TreeModel
    import {-# SOURCE #-} qualified GI.Gtk.Objects.CellArea as Gtk.CellArea
    import {-# SOURCE #-} qualified GI.Gtk.Objects.CellRenderer as Gtk.CellRenderer
    import {-# SOURCE #-} qualified GI.Gtk.Objects.Tooltip as Gtk.Tooltip
    import {-# SOURCE #-} qualified GI.Gtk.Objects.Widget as Gtk.Widget
    import {-# SOURCE #-} qualified GI.Gtk.Structs.TreeIter as Gtk.TreeIter
    import {-# SOURCE #-} qualified GI.Gtk.Structs.TreePath as Gtk.TreePath

    #endif

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

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

    foreign import ccall "gtk_icon_view_get_type"
        c_gtk_icon_view_get_type :: IO B.Types.GType

    instance B.Types.TypedObject IconView where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_icon_view_get_type

    instance B.Types.GObject IconView

    -- | Type class for types which can be safely cast to t'IconView', for instance with `toIconView`.
    class (SP.GObject o, O.IsDescendantOf IconView o) => IsIconView o
    instance (SP.GObject o, O.IsDescendantOf IconView o) => IsIconView o

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

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

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

    #if defined(ENABLE_OVERLOADING)
    type family ResolveIconViewMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
        ResolveIconViewMethod "actionSetEnabled" o = Gtk.Widget.WidgetActionSetEnabledMethodInfo
        ResolveIconViewMethod "activate" o = Gtk.Widget.WidgetActivateMethodInfo
        ResolveIconViewMethod "activateAction" o = Gtk.Widget.WidgetActivateActionMethodInfo
        ResolveIconViewMethod "activateDefault" o = Gtk.Widget.WidgetActivateDefaultMethodInfo
        ResolveIconViewMethod "addAttribute" o = Gtk.CellLayout.CellLayoutAddAttributeMethodInfo
        ResolveIconViewMethod "addController" o = Gtk.Widget.WidgetAddControllerMethodInfo
        ResolveIconViewMethod "addCssClass" o = Gtk.Widget.WidgetAddCssClassMethodInfo
        ResolveIconViewMethod "addMnemonicLabel" o = Gtk.Widget.WidgetAddMnemonicLabelMethodInfo
        ResolveIconViewMethod "addTickCallback" o = Gtk.Widget.WidgetAddTickCallbackMethodInfo
        ResolveIconViewMethod "allocate" o = Gtk.Widget.WidgetAllocateMethodInfo
        ResolveIconViewMethod "announce" o = Gtk.Accessible.AccessibleAnnounceMethodInfo
        ResolveIconViewMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
        ResolveIconViewMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
        ResolveIconViewMethod "childFocus" o = Gtk.Widget.WidgetChildFocusMethodInfo
        ResolveIconViewMethod "clear" o = Gtk.CellLayout.CellLayoutClearMethodInfo
        ResolveIconViewMethod "clearAttributes" o = Gtk.CellLayout.CellLayoutClearAttributesMethodInfo
        ResolveIconViewMethod "computeBounds" o = Gtk.Widget.WidgetComputeBoundsMethodInfo
        ResolveIconViewMethod "computeExpand" o = Gtk.Widget.WidgetComputeExpandMethodInfo
        ResolveIconViewMethod "computePoint" o = Gtk.Widget.WidgetComputePointMethodInfo
        ResolveIconViewMethod "computeTransform" o = Gtk.Widget.WidgetComputeTransformMethodInfo
        ResolveIconViewMethod "contains" o = Gtk.Widget.WidgetContainsMethodInfo
        ResolveIconViewMethod "createDragIcon" o = IconViewCreateDragIconMethodInfo
        ResolveIconViewMethod "createPangoContext" o = Gtk.Widget.WidgetCreatePangoContextMethodInfo
        ResolveIconViewMethod "createPangoLayout" o = Gtk.Widget.WidgetCreatePangoLayoutMethodInfo
        ResolveIconViewMethod "disposeTemplate" o = Gtk.Widget.WidgetDisposeTemplateMethodInfo
        ResolveIconViewMethod "dragCheckThreshold" o = Gtk.Widget.WidgetDragCheckThresholdMethodInfo
        ResolveIconViewMethod "enableModelDragDest" o = IconViewEnableModelDragDestMethodInfo
        ResolveIconViewMethod "enableModelDragSource" o = IconViewEnableModelDragSourceMethodInfo
        ResolveIconViewMethod "errorBell" o = Gtk.Widget.WidgetErrorBellMethodInfo
        ResolveIconViewMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
        ResolveIconViewMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
        ResolveIconViewMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
        ResolveIconViewMethod "grabFocus" o = Gtk.Widget.WidgetGrabFocusMethodInfo
        ResolveIconViewMethod "hasCssClass" o = Gtk.Widget.WidgetHasCssClassMethodInfo
        ResolveIconViewMethod "hasDefault" o = Gtk.Widget.WidgetHasDefaultMethodInfo
        ResolveIconViewMethod "hasFocus" o = Gtk.Widget.WidgetHasFocusMethodInfo
        ResolveIconViewMethod "hasVisibleFocus" o = Gtk.Widget.WidgetHasVisibleFocusMethodInfo
        ResolveIconViewMethod "hide" o = Gtk.Widget.WidgetHideMethodInfo
        ResolveIconViewMethod "inDestruction" o = Gtk.Widget.WidgetInDestructionMethodInfo
        ResolveIconViewMethod "initTemplate" o = Gtk.Widget.WidgetInitTemplateMethodInfo
        ResolveIconViewMethod "insertActionGroup" o = Gtk.Widget.WidgetInsertActionGroupMethodInfo
        ResolveIconViewMethod "insertAfter" o = Gtk.Widget.WidgetInsertAfterMethodInfo
        ResolveIconViewMethod "insertBefore" o = Gtk.Widget.WidgetInsertBeforeMethodInfo
        ResolveIconViewMethod "isAncestor" o = Gtk.Widget.WidgetIsAncestorMethodInfo
        ResolveIconViewMethod "isDrawable" o = Gtk.Widget.WidgetIsDrawableMethodInfo
        ResolveIconViewMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
        ResolveIconViewMethod "isFocus" o = Gtk.Widget.WidgetIsFocusMethodInfo
        ResolveIconViewMethod "isSensitive" o = Gtk.Widget.WidgetIsSensitiveMethodInfo
        ResolveIconViewMethod "isVisible" o = Gtk.Widget.WidgetIsVisibleMethodInfo
        ResolveIconViewMethod "itemActivated" o = IconViewItemActivatedMethodInfo
        ResolveIconViewMethod "keynavFailed" o = Gtk.Widget.WidgetKeynavFailedMethodInfo
        ResolveIconViewMethod "listMnemonicLabels" o = Gtk.Widget.WidgetListMnemonicLabelsMethodInfo
        ResolveIconViewMethod "map" o = Gtk.Widget.WidgetMapMethodInfo
        ResolveIconViewMethod "measure" o = Gtk.Widget.WidgetMeasureMethodInfo
        ResolveIconViewMethod "mnemonicActivate" o = Gtk.Widget.WidgetMnemonicActivateMethodInfo
        ResolveIconViewMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
        ResolveIconViewMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
        ResolveIconViewMethod "observeChildren" o = Gtk.Widget.WidgetObserveChildrenMethodInfo
        ResolveIconViewMethod "observeControllers" o = Gtk.Widget.WidgetObserveControllersMethodInfo
        ResolveIconViewMethod "packEnd" o = Gtk.CellLayout.CellLayoutPackEndMethodInfo
        ResolveIconViewMethod "packStart" o = Gtk.CellLayout.CellLayoutPackStartMethodInfo
        ResolveIconViewMethod "pathIsSelected" o = IconViewPathIsSelectedMethodInfo
        ResolveIconViewMethod "pick" o = Gtk.Widget.WidgetPickMethodInfo
        ResolveIconViewMethod "queueAllocate" o = Gtk.Widget.WidgetQueueAllocateMethodInfo
        ResolveIconViewMethod "queueDraw" o = Gtk.Widget.WidgetQueueDrawMethodInfo
        ResolveIconViewMethod "queueResize" o = Gtk.Widget.WidgetQueueResizeMethodInfo
        ResolveIconViewMethod "realize" o = Gtk.Widget.WidgetRealizeMethodInfo
        ResolveIconViewMethod "ref" o = GObject.Object.ObjectRefMethodInfo
        ResolveIconViewMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
        ResolveIconViewMethod "removeController" o = Gtk.Widget.WidgetRemoveControllerMethodInfo
        ResolveIconViewMethod "removeCssClass" o = Gtk.Widget.WidgetRemoveCssClassMethodInfo
        ResolveIconViewMethod "removeMnemonicLabel" o = Gtk.Widget.WidgetRemoveMnemonicLabelMethodInfo
        ResolveIconViewMethod "removeTickCallback" o = Gtk.Widget.WidgetRemoveTickCallbackMethodInfo
        ResolveIconViewMethod "reorder" o = Gtk.CellLayout.CellLayoutReorderMethodInfo
        ResolveIconViewMethod "resetProperty" o = Gtk.Accessible.AccessibleResetPropertyMethodInfo
        ResolveIconViewMethod "resetRelation" o = Gtk.Accessible.AccessibleResetRelationMethodInfo
        ResolveIconViewMethod "resetState" o = Gtk.Accessible.AccessibleResetStateMethodInfo
        ResolveIconViewMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
        ResolveIconViewMethod "scrollToPath" o = IconViewScrollToPathMethodInfo
        ResolveIconViewMethod "selectAll" o = IconViewSelectAllMethodInfo
        ResolveIconViewMethod "selectPath" o = IconViewSelectPathMethodInfo
        ResolveIconViewMethod "selectedForeach" o = IconViewSelectedForeachMethodInfo
        ResolveIconViewMethod "shouldLayout" o = Gtk.Widget.WidgetShouldLayoutMethodInfo
        ResolveIconViewMethod "show" o = Gtk.Widget.WidgetShowMethodInfo
        ResolveIconViewMethod "sizeAllocate" o = Gtk.Widget.WidgetSizeAllocateMethodInfo
        ResolveIconViewMethod "snapshotChild" o = Gtk.Widget.WidgetSnapshotChildMethodInfo
        ResolveIconViewMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
        ResolveIconViewMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
        ResolveIconViewMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
        ResolveIconViewMethod "translateCoordinates" o = Gtk.Widget.WidgetTranslateCoordinatesMethodInfo
        ResolveIconViewMethod "triggerTooltipQuery" o = Gtk.Widget.WidgetTriggerTooltipQueryMethodInfo
        ResolveIconViewMethod "unmap" o = Gtk.Widget.WidgetUnmapMethodInfo
        ResolveIconViewMethod "unparent" o = Gtk.Widget.WidgetUnparentMethodInfo
        ResolveIconViewMethod "unrealize" o = Gtk.Widget.WidgetUnrealizeMethodInfo
        ResolveIconViewMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
        ResolveIconViewMethod "unselectAll" o = IconViewUnselectAllMethodInfo
        ResolveIconViewMethod "unselectPath" o = IconViewUnselectPathMethodInfo
        ResolveIconViewMethod "unsetModelDragDest" o = IconViewUnsetModelDragDestMethodInfo
        ResolveIconViewMethod "unsetModelDragSource" o = IconViewUnsetModelDragSourceMethodInfo
        ResolveIconViewMethod "unsetStateFlags" o = Gtk.Widget.WidgetUnsetStateFlagsMethodInfo
        ResolveIconViewMethod "updateNextAccessibleSibling" o = Gtk.Accessible.AccessibleUpdateNextAccessibleSiblingMethodInfo
        ResolveIconViewMethod "updatePlatformState" o = Gtk.Accessible.AccessibleUpdatePlatformStateMethodInfo
        ResolveIconViewMethod "updateProperty" o = Gtk.Accessible.AccessibleUpdatePropertyMethodInfo
        ResolveIconViewMethod "updateRelation" o = Gtk.Accessible.AccessibleUpdateRelationMethodInfo
        ResolveIconViewMethod "updateState" o = Gtk.Accessible.AccessibleUpdateStateMethodInfo
        ResolveIconViewMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
        ResolveIconViewMethod "getAccessibleId" o = Gtk.Accessible.AccessibleGetAccessibleIdMethodInfo
        ResolveIconViewMethod "getAccessibleParent" o = Gtk.Accessible.AccessibleGetAccessibleParentMethodInfo
        ResolveIconViewMethod "getAccessibleRole" o = Gtk.Accessible.AccessibleGetAccessibleRoleMethodInfo
        ResolveIconViewMethod "getActivateOnSingleClick" o = IconViewGetActivateOnSingleClickMethodInfo
        ResolveIconViewMethod "getAllocatedBaseline" o = Gtk.Widget.WidgetGetAllocatedBaselineMethodInfo
        ResolveIconViewMethod "getAllocatedHeight" o = Gtk.Widget.WidgetGetAllocatedHeightMethodInfo
        ResolveIconViewMethod "getAllocatedWidth" o = Gtk.Widget.WidgetGetAllocatedWidthMethodInfo
        ResolveIconViewMethod "getAllocation" o = Gtk.Widget.WidgetGetAllocationMethodInfo
        ResolveIconViewMethod "getAncestor" o = Gtk.Widget.WidgetGetAncestorMethodInfo
        ResolveIconViewMethod "getArea" o = Gtk.CellLayout.CellLayoutGetAreaMethodInfo
        ResolveIconViewMethod "getAtContext" o = Gtk.Accessible.AccessibleGetAtContextMethodInfo
        ResolveIconViewMethod "getBaseline" o = Gtk.Widget.WidgetGetBaselineMethodInfo
        ResolveIconViewMethod "getBorder" o = Gtk.Scrollable.ScrollableGetBorderMethodInfo
        ResolveIconViewMethod "getBounds" o = Gtk.Accessible.AccessibleGetBoundsMethodInfo
        ResolveIconViewMethod "getBuildableId" o = Gtk.Buildable.BuildableGetBuildableIdMethodInfo
        ResolveIconViewMethod "getCanFocus" o = Gtk.Widget.WidgetGetCanFocusMethodInfo
        ResolveIconViewMethod "getCanTarget" o = Gtk.Widget.WidgetGetCanTargetMethodInfo
        ResolveIconViewMethod "getCellRect" o = IconViewGetCellRectMethodInfo
        ResolveIconViewMethod "getCells" o = Gtk.CellLayout.CellLayoutGetCellsMethodInfo
        ResolveIconViewMethod "getChildVisible" o = Gtk.Widget.WidgetGetChildVisibleMethodInfo
        ResolveIconViewMethod "getClipboard" o = Gtk.Widget.WidgetGetClipboardMethodInfo
        ResolveIconViewMethod "getColor" o = Gtk.Widget.WidgetGetColorMethodInfo
        ResolveIconViewMethod "getColumnSpacing" o = IconViewGetColumnSpacingMethodInfo
        ResolveIconViewMethod "getColumns" o = IconViewGetColumnsMethodInfo
        ResolveIconViewMethod "getCssClasses" o = Gtk.Widget.WidgetGetCssClassesMethodInfo
        ResolveIconViewMethod "getCssName" o = Gtk.Widget.WidgetGetCssNameMethodInfo
        ResolveIconViewMethod "getCursor" o = IconViewGetCursorMethodInfo
        ResolveIconViewMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
        ResolveIconViewMethod "getDestItemAtPos" o = IconViewGetDestItemAtPosMethodInfo
        ResolveIconViewMethod "getDirection" o = Gtk.Widget.WidgetGetDirectionMethodInfo
        ResolveIconViewMethod "getDisplay" o = Gtk.Widget.WidgetGetDisplayMethodInfo
        ResolveIconViewMethod "getDragDestItem" o = IconViewGetDragDestItemMethodInfo
        ResolveIconViewMethod "getFirstAccessibleChild" o = Gtk.Accessible.AccessibleGetFirstAccessibleChildMethodInfo
        ResolveIconViewMethod "getFirstChild" o = Gtk.Widget.WidgetGetFirstChildMethodInfo
        ResolveIconViewMethod "getFocusChild" o = Gtk.Widget.WidgetGetFocusChildMethodInfo
        ResolveIconViewMethod "getFocusOnClick" o = Gtk.Widget.WidgetGetFocusOnClickMethodInfo
        ResolveIconViewMethod "getFocusable" o = Gtk.Widget.WidgetGetFocusableMethodInfo
        ResolveIconViewMethod "getFontMap" o = Gtk.Widget.WidgetGetFontMapMethodInfo
        ResolveIconViewMethod "getFontOptions" o = Gtk.Widget.WidgetGetFontOptionsMethodInfo
        ResolveIconViewMethod "getFrameClock" o = Gtk.Widget.WidgetGetFrameClockMethodInfo
        ResolveIconViewMethod "getHadjustment" o = Gtk.Scrollable.ScrollableGetHadjustmentMethodInfo
        ResolveIconViewMethod "getHalign" o = Gtk.Widget.WidgetGetHalignMethodInfo
        ResolveIconViewMethod "getHasTooltip" o = Gtk.Widget.WidgetGetHasTooltipMethodInfo
        ResolveIconViewMethod "getHeight" o = Gtk.Widget.WidgetGetHeightMethodInfo
        ResolveIconViewMethod "getHexpand" o = Gtk.Widget.WidgetGetHexpandMethodInfo
        ResolveIconViewMethod "getHexpandSet" o = Gtk.Widget.WidgetGetHexpandSetMethodInfo
        ResolveIconViewMethod "getHscrollPolicy" o = Gtk.Scrollable.ScrollableGetHscrollPolicyMethodInfo
        ResolveIconViewMethod "getItemAtPos" o = IconViewGetItemAtPosMethodInfo
        ResolveIconViewMethod "getItemColumn" o = IconViewGetItemColumnMethodInfo
        ResolveIconViewMethod "getItemOrientation" o = IconViewGetItemOrientationMethodInfo
        ResolveIconViewMethod "getItemPadding" o = IconViewGetItemPaddingMethodInfo
        ResolveIconViewMethod "getItemRow" o = IconViewGetItemRowMethodInfo
        ResolveIconViewMethod "getItemWidth" o = IconViewGetItemWidthMethodInfo
        ResolveIconViewMethod "getLastChild" o = Gtk.Widget.WidgetGetLastChildMethodInfo
        ResolveIconViewMethod "getLayoutManager" o = Gtk.Widget.WidgetGetLayoutManagerMethodInfo
        ResolveIconViewMethod "getLimitEvents" o = Gtk.Widget.WidgetGetLimitEventsMethodInfo
        ResolveIconViewMethod "getMapped" o = Gtk.Widget.WidgetGetMappedMethodInfo
        ResolveIconViewMethod "getMargin" o = IconViewGetMarginMethodInfo
        ResolveIconViewMethod "getMarginBottom" o = Gtk.Widget.WidgetGetMarginBottomMethodInfo
        ResolveIconViewMethod "getMarginEnd" o = Gtk.Widget.WidgetGetMarginEndMethodInfo
        ResolveIconViewMethod "getMarginStart" o = Gtk.Widget.WidgetGetMarginStartMethodInfo
        ResolveIconViewMethod "getMarginTop" o = Gtk.Widget.WidgetGetMarginTopMethodInfo
        ResolveIconViewMethod "getMarkupColumn" o = IconViewGetMarkupColumnMethodInfo
        ResolveIconViewMethod "getModel" o = IconViewGetModelMethodInfo
        ResolveIconViewMethod "getName" o = Gtk.Widget.WidgetGetNameMethodInfo
        ResolveIconViewMethod "getNative" o = Gtk.Widget.WidgetGetNativeMethodInfo
        ResolveIconViewMethod "getNextAccessibleSibling" o = Gtk.Accessible.AccessibleGetNextAccessibleSiblingMethodInfo
        ResolveIconViewMethod "getNextSibling" o = Gtk.Widget.WidgetGetNextSiblingMethodInfo
        ResolveIconViewMethod "getOpacity" o = Gtk.Widget.WidgetGetOpacityMethodInfo
        ResolveIconViewMethod "getOverflow" o = Gtk.Widget.WidgetGetOverflowMethodInfo
        ResolveIconViewMethod "getPangoContext" o = Gtk.Widget.WidgetGetPangoContextMethodInfo
        ResolveIconViewMethod "getParent" o = Gtk.Widget.WidgetGetParentMethodInfo
        ResolveIconViewMethod "getPathAtPos" o = IconViewGetPathAtPosMethodInfo
        ResolveIconViewMethod "getPixbufColumn" o = IconViewGetPixbufColumnMethodInfo
        ResolveIconViewMethod "getPlatformState" o = Gtk.Accessible.AccessibleGetPlatformStateMethodInfo
        ResolveIconViewMethod "getPreferredSize" o = Gtk.Widget.WidgetGetPreferredSizeMethodInfo
        ResolveIconViewMethod "getPrevSibling" o = Gtk.Widget.WidgetGetPrevSiblingMethodInfo
        ResolveIconViewMethod "getPrimaryClipboard" o = Gtk.Widget.WidgetGetPrimaryClipboardMethodInfo
        ResolveIconViewMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
        ResolveIconViewMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
        ResolveIconViewMethod "getRealized" o = Gtk.Widget.WidgetGetRealizedMethodInfo
        ResolveIconViewMethod "getReceivesDefault" o = Gtk.Widget.WidgetGetReceivesDefaultMethodInfo
        ResolveIconViewMethod "getReorderable" o = IconViewGetReorderableMethodInfo
        ResolveIconViewMethod "getRequestMode" o = Gtk.Widget.WidgetGetRequestModeMethodInfo
        ResolveIconViewMethod "getRoot" o = Gtk.Widget.WidgetGetRootMethodInfo
        ResolveIconViewMethod "getRowSpacing" o = IconViewGetRowSpacingMethodInfo
        ResolveIconViewMethod "getScaleFactor" o = Gtk.Widget.WidgetGetScaleFactorMethodInfo
        ResolveIconViewMethod "getSelectedItems" o = IconViewGetSelectedItemsMethodInfo
        ResolveIconViewMethod "getSelectionMode" o = IconViewGetSelectionModeMethodInfo
        ResolveIconViewMethod "getSensitive" o = Gtk.Widget.WidgetGetSensitiveMethodInfo
        ResolveIconViewMethod "getSettings" o = Gtk.Widget.WidgetGetSettingsMethodInfo
        ResolveIconViewMethod "getSize" o = Gtk.Widget.WidgetGetSizeMethodInfo
        ResolveIconViewMethod "getSizeRequest" o = Gtk.Widget.WidgetGetSizeRequestMethodInfo
        ResolveIconViewMethod "getSpacing" o = IconViewGetSpacingMethodInfo
        ResolveIconViewMethod "getStateFlags" o = Gtk.Widget.WidgetGetStateFlagsMethodInfo
        ResolveIconViewMethod "getStyleContext" o = Gtk.Widget.WidgetGetStyleContextMethodInfo
        ResolveIconViewMethod "getTemplateChild" o = Gtk.Widget.WidgetGetTemplateChildMethodInfo
        ResolveIconViewMethod "getTextColumn" o = IconViewGetTextColumnMethodInfo
        ResolveIconViewMethod "getTooltipColumn" o = IconViewGetTooltipColumnMethodInfo
        ResolveIconViewMethod "getTooltipContext" o = IconViewGetTooltipContextMethodInfo
        ResolveIconViewMethod "getTooltipMarkup" o = Gtk.Widget.WidgetGetTooltipMarkupMethodInfo
        ResolveIconViewMethod "getTooltipText" o = Gtk.Widget.WidgetGetTooltipTextMethodInfo
        ResolveIconViewMethod "getVadjustment" o = Gtk.Scrollable.ScrollableGetVadjustmentMethodInfo
        ResolveIconViewMethod "getValign" o = Gtk.Widget.WidgetGetValignMethodInfo
        ResolveIconViewMethod "getVexpand" o = Gtk.Widget.WidgetGetVexpandMethodInfo
        ResolveIconViewMethod "getVexpandSet" o = Gtk.Widget.WidgetGetVexpandSetMethodInfo
        ResolveIconViewMethod "getVisible" o = Gtk.Widget.WidgetGetVisibleMethodInfo
        ResolveIconViewMethod "getVisibleRange" o = IconViewGetVisibleRangeMethodInfo
        ResolveIconViewMethod "getVscrollPolicy" o = Gtk.Scrollable.ScrollableGetVscrollPolicyMethodInfo
        ResolveIconViewMethod "getWidth" o = Gtk.Widget.WidgetGetWidthMethodInfo
        ResolveIconViewMethod "setAccessibleParent" o = Gtk.Accessible.AccessibleSetAccessibleParentMethodInfo
        ResolveIconViewMethod "setActivateOnSingleClick" o = IconViewSetActivateOnSingleClickMethodInfo
        ResolveIconViewMethod "setCanFocus" o = Gtk.Widget.WidgetSetCanFocusMethodInfo
        ResolveIconViewMethod "setCanTarget" o = Gtk.Widget.WidgetSetCanTargetMethodInfo
        ResolveIconViewMethod "setCellDataFunc" o = Gtk.CellLayout.CellLayoutSetCellDataFuncMethodInfo
        ResolveIconViewMethod "setChildVisible" o = Gtk.Widget.WidgetSetChildVisibleMethodInfo
        ResolveIconViewMethod "setColumnSpacing" o = IconViewSetColumnSpacingMethodInfo
        ResolveIconViewMethod "setColumns" o = IconViewSetColumnsMethodInfo
        ResolveIconViewMethod "setCssClasses" o = Gtk.Widget.WidgetSetCssClassesMethodInfo
        ResolveIconViewMethod "setCursor" o = IconViewSetCursorMethodInfo
        ResolveIconViewMethod "setCursorFromName" o = Gtk.Widget.WidgetSetCursorFromNameMethodInfo
        ResolveIconViewMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
        ResolveIconViewMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
        ResolveIconViewMethod "setDirection" o = Gtk.Widget.WidgetSetDirectionMethodInfo
        ResolveIconViewMethod "setDragDestItem" o = IconViewSetDragDestItemMethodInfo
        ResolveIconViewMethod "setFocusChild" o = Gtk.Widget.WidgetSetFocusChildMethodInfo
        ResolveIconViewMethod "setFocusOnClick" o = Gtk.Widget.WidgetSetFocusOnClickMethodInfo
        ResolveIconViewMethod "setFocusable" o = Gtk.Widget.WidgetSetFocusableMethodInfo
        ResolveIconViewMethod "setFontMap" o = Gtk.Widget.WidgetSetFontMapMethodInfo
        ResolveIconViewMethod "setFontOptions" o = Gtk.Widget.WidgetSetFontOptionsMethodInfo
        ResolveIconViewMethod "setHadjustment" o = Gtk.Scrollable.ScrollableSetHadjustmentMethodInfo
        ResolveIconViewMethod "setHalign" o = Gtk.Widget.WidgetSetHalignMethodInfo
        ResolveIconViewMethod "setHasTooltip" o = Gtk.Widget.WidgetSetHasTooltipMethodInfo
        ResolveIconViewMethod "setHexpand" o = Gtk.Widget.WidgetSetHexpandMethodInfo
        ResolveIconViewMethod "setHexpandSet" o = Gtk.Widget.WidgetSetHexpandSetMethodInfo
        ResolveIconViewMethod "setHscrollPolicy" o = Gtk.Scrollable.ScrollableSetHscrollPolicyMethodInfo
        ResolveIconViewMethod "setItemOrientation" o = IconViewSetItemOrientationMethodInfo
        ResolveIconViewMethod "setItemPadding" o = IconViewSetItemPaddingMethodInfo
        ResolveIconViewMethod "setItemWidth" o = IconViewSetItemWidthMethodInfo
        ResolveIconViewMethod "setLayoutManager" o = Gtk.Widget.WidgetSetLayoutManagerMethodInfo
        ResolveIconViewMethod "setLimitEvents" o = Gtk.Widget.WidgetSetLimitEventsMethodInfo
        ResolveIconViewMethod "setMargin" o = IconViewSetMarginMethodInfo
        ResolveIconViewMethod "setMarginBottom" o = Gtk.Widget.WidgetSetMarginBottomMethodInfo
        ResolveIconViewMethod "setMarginEnd" o = Gtk.Widget.WidgetSetMarginEndMethodInfo
        ResolveIconViewMethod "setMarginStart" o = Gtk.Widget.WidgetSetMarginStartMethodInfo
        ResolveIconViewMethod "setMarginTop" o = Gtk.Widget.WidgetSetMarginTopMethodInfo
        ResolveIconViewMethod "setMarkupColumn" o = IconViewSetMarkupColumnMethodInfo
        ResolveIconViewMethod "setModel" o = IconViewSetModelMethodInfo
        ResolveIconViewMethod "setName" o = Gtk.Widget.WidgetSetNameMethodInfo
        ResolveIconViewMethod "setOpacity" o = Gtk.Widget.WidgetSetOpacityMethodInfo
        ResolveIconViewMethod "setOverflow" o = Gtk.Widget.WidgetSetOverflowMethodInfo
        ResolveIconViewMethod "setParent" o = Gtk.Widget.WidgetSetParentMethodInfo
        ResolveIconViewMethod "setPixbufColumn" o = IconViewSetPixbufColumnMethodInfo
        ResolveIconViewMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
        ResolveIconViewMethod "setReceivesDefault" o = Gtk.Widget.WidgetSetReceivesDefaultMethodInfo
        ResolveIconViewMethod "setReorderable" o = IconViewSetReorderableMethodInfo
        ResolveIconViewMethod "setRowSpacing" o = IconViewSetRowSpacingMethodInfo
        ResolveIconViewMethod "setSelectionMode" o = IconViewSetSelectionModeMethodInfo
        ResolveIconViewMethod "setSensitive" o = Gtk.Widget.WidgetSetSensitiveMethodInfo
        ResolveIconViewMethod "setSizeRequest" o = Gtk.Widget.WidgetSetSizeRequestMethodInfo
        ResolveIconViewMethod "setSpacing" o = IconViewSetSpacingMethodInfo
        ResolveIconViewMethod "setStateFlags" o = Gtk.Widget.WidgetSetStateFlagsMethodInfo
        ResolveIconViewMethod "setTextColumn" o = IconViewSetTextColumnMethodInfo
        ResolveIconViewMethod "setTooltipCell" o = IconViewSetTooltipCellMethodInfo
        ResolveIconViewMethod "setTooltipColumn" o = IconViewSetTooltipColumnMethodInfo
        ResolveIconViewMethod "setTooltipItem" o = IconViewSetTooltipItemMethodInfo
        ResolveIconViewMethod "setTooltipMarkup" o = Gtk.Widget.WidgetSetTooltipMarkupMethodInfo
        ResolveIconViewMethod "setTooltipText" o = Gtk.Widget.WidgetSetTooltipTextMethodInfo
        ResolveIconViewMethod "setVadjustment" o = Gtk.Scrollable.ScrollableSetVadjustmentMethodInfo
        ResolveIconViewMethod "setValign" o = Gtk.Widget.WidgetSetValignMethodInfo
        ResolveIconViewMethod "setVexpand" o = Gtk.Widget.WidgetSetVexpandMethodInfo
        ResolveIconViewMethod "setVexpandSet" o = Gtk.Widget.WidgetSetVexpandSetMethodInfo
        ResolveIconViewMethod "setVisible" o = Gtk.Widget.WidgetSetVisibleMethodInfo
        ResolveIconViewMethod "setVscrollPolicy" o = Gtk.Scrollable.ScrollableSetVscrollPolicyMethodInfo
        ResolveIconViewMethod l o = O.MethodResolutionFailed l o

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

    #endif

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

    #endif

    -- signal IconView::activate-cursor-item
    -- | A [keybinding signal]t'GI.Gtk.Objects.SignalAction.SignalAction'
    -- which gets emitted when the user activates the currently
    -- focused item.
    --
    -- Applications should not connect to it, but may emit it with
    -- @/g_signal_emit_by_name()/@ if they need to control activation
    -- programmatically.
    --
    -- The default bindings for this signal are Space, Return and Enter.
    type IconViewActivateCursorItemCallback =
        IO Bool
        -- ^ __Returns:__ whether the item was activated

    type C_IconViewActivateCursorItemCallback =
        Ptr IconView ->                         -- object
        Ptr () ->                               -- user_data
        IO CInt

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

    wrap_IconViewActivateCursorItemCallback ::
        GObject a => (a -> IconViewActivateCursorItemCallback) ->
        C_IconViewActivateCursorItemCallback
    wrap_IconViewActivateCursorItemCallback :: forall a.
    GObject a =>
    (a -> IconViewActivateCursorItemCallback)
    -> C_IconViewActivateCursorItemCallback
    wrap_IconViewActivateCursorItemCallback a -> IconViewActivateCursorItemCallback
    gi'cb Ptr IconView
    gi'selfPtr Ptr ()
    _ = do
        result <- Ptr IconView
    -> (IconView -> IconViewActivateCursorItemCallback)
    -> IconViewActivateCursorItemCallback
    forall o b.
    (HasCallStack, GObject o) =>
    Ptr o -> (o -> IO b) -> IO b
    B.ManagedPtr.withNewObject Ptr IconView
    gi'selfPtr ((IconView -> IconViewActivateCursorItemCallback)
     -> IconViewActivateCursorItemCallback)
    -> (IconView -> IconViewActivateCursorItemCallback)
    -> IconViewActivateCursorItemCallback
    forall a b. (a -> b) -> a -> b
    $ \IconView
    gi'self -> a -> IconViewActivateCursorItemCallback
    gi'cb (IconView -> a
    forall a b. Coercible a b => a -> b
    Coerce.coerce IconView
    gi'self)
        let result' = (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    P.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
    P.fromEnum) Bool
    result
        return result'

    -- | Connect a signal handler for the [activateCursorItem](#signal:activateCursorItem) 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' iconView #activateCursorItem callback
    -- @
    --
    --
    onIconViewActivateCursorItem :: (IsIconView a, MonadIO m) => a -> ((?self :: a) => IconViewActivateCursorItemCallback) -> m SignalHandlerId
    onIconViewActivateCursorItem :: forall a (m :: * -> *).
    (IsIconView a, MonadIO m) =>
    a
    -> ((?self::a) => IconViewActivateCursorItemCallback)
    -> m SignalHandlerId
    onIconViewActivateCursorItem a
    obj (?self::a) => IconViewActivateCursorItemCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> IconViewActivateCursorItemCallback
    wrapped a
    self = let ?self = a
    ?self::a
    self in IconViewActivateCursorItemCallback
    (?self::a) => IconViewActivateCursorItemCallback
    cb
        let wrapped' :: C_IconViewActivateCursorItemCallback
    wrapped' = (a -> IconViewActivateCursorItemCallback)
    -> C_IconViewActivateCursorItemCallback
    forall a.
    GObject a =>
    (a -> IconViewActivateCursorItemCallback)
    -> C_IconViewActivateCursorItemCallback
    wrap_IconViewActivateCursorItemCallback a -> IconViewActivateCursorItemCallback
    wrapped
        wrapped'' <- C_IconViewActivateCursorItemCallback
    -> IO (FunPtr C_IconViewActivateCursorItemCallback)
    mk_IconViewActivateCursorItemCallback C_IconViewActivateCursorItemCallback
    wrapped'
        connectSignalFunPtr obj "activate-cursor-item" wrapped'' SignalConnectBefore Nothing

    -- | Connect a signal handler for the [activateCursorItem](#signal:activateCursorItem) 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' iconView #activateCursorItem callback
    -- @
    --
    --
    --
    -- By default the object invoking the signal is not passed to the callback.
    -- If you need to access it, you can use the implit @?self@ parameter.
    -- Note that this requires activating the @ImplicitParams@ GHC extension.
    --
    afterIconViewActivateCursorItem :: (IsIconView a, MonadIO m) => a -> ((?self :: a) => IconViewActivateCursorItemCallback) -> m SignalHandlerId
    afterIconViewActivateCursorItem :: forall a (m :: * -> *).
    (IsIconView a, MonadIO m) =>
    a
    -> ((?self::a) => IconViewActivateCursorItemCallback)
    -> m SignalHandlerId
    afterIconViewActivateCursorItem a
    obj (?self::a) => IconViewActivateCursorItemCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> IconViewActivateCursorItemCallback
    wrapped a
    self = let ?self = a
    ?self::a
    self in IconViewActivateCursorItemCallback
    (?self::a) => IconViewActivateCursorItemCallback
    cb
        let wrapped' :: C_IconViewActivateCursorItemCallback
    wrapped' = (a -> IconViewActivateCursorItemCallback)
    -> C_IconViewActivateCursorItemCallback
    forall a.
    GObject a =>
    (a -> IconViewActivateCursorItemCallback)
    -> C_IconViewActivateCursorItemCallback
    wrap_IconViewActivateCursorItemCallback a -> IconViewActivateCursorItemCallback
    wrapped
        wrapped'' <- C_IconViewActivateCursorItemCallback
    -> IO (FunPtr C_IconViewActivateCursorItemCallback)
    mk_IconViewActivateCursorItemCallback C_IconViewActivateCursorItemCallback
    wrapped'
        connectSignalFunPtr obj "activate-cursor-item" wrapped'' SignalConnectAfter Nothing

    #if defined(ENABLE_OVERLOADING)
    data IconViewActivateCursorItemSignalInfo
    instance SignalInfo IconViewActivateCursorItemSignalInfo where
        type HaskellCallbackType IconViewActivateCursorItemSignalInfo = IconViewActivateCursorItemCallback
        connectSignal obj cb connectMode detail = do
            let cb' = wrap_IconViewActivateCursorItemCallback cb
            cb'' <- mk_IconViewActivateCursorItemCallback cb'
            connectSignalFunPtr obj "activate-cursor-item" cb'' connectMode detail
        dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView::activate-cursor-item"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#g:signal:activateCursorItem"})

    #endif

    -- signal IconView::item-activated
    -- | The [itemActivated](#g:signal:itemActivated) signal is emitted when the method
    -- 'GI.Gtk.Objects.IconView.iconViewItemActivated' is called, when the user double
    -- clicks an item with the \"activate-on-single-click\" property set
    -- to 'P.False', or when the user single clicks an item when the
    -- \"activate-on-single-click\" property set to 'P.True'. It is also
    -- emitted when a non-editable item is selected and one of the keys:
    -- Space, Return or Enter is pressed.
    type IconViewItemActivatedCallback =
        Gtk.TreePath.TreePath
        -- ^ /@path@/: the @GtkTreePath@ for the activated item
        -> IO ()

    type C_IconViewItemActivatedCallback =
        Ptr IconView ->                         -- object
        Ptr Gtk.TreePath.TreePath ->
        Ptr () ->                               -- user_data
        IO ()

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

    wrap_IconViewItemActivatedCallback ::
        GObject a => (a -> IconViewItemActivatedCallback) ->
        C_IconViewItemActivatedCallback
    wrap_IconViewItemActivatedCallback :: forall a.
    GObject a =>
    (a -> IconViewItemActivatedCallback)
    -> C_IconViewItemActivatedCallback
    wrap_IconViewItemActivatedCallback a -> IconViewItemActivatedCallback
    gi'cb Ptr IconView
    gi'selfPtr Ptr TreePath
    path Ptr ()
    _ = do
        Ptr TreePath -> IconViewItemActivatedCallback -> IO ()
    forall a b.
    (HasCallStack, ManagedPtrNewtype a) =>
    Ptr a -> (a -> IO b) -> IO b
    B.ManagedPtr.withTransient  Ptr TreePath
    path (IconViewItemActivatedCallback -> IO ())
    -> IconViewItemActivatedCallback -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \TreePath
    path' -> do
            Ptr IconView -> (IconView -> IO ()) -> IO ()
    forall o b.
    (HasCallStack, GObject o) =>
    Ptr o -> (o -> IO b) -> IO b
    B.ManagedPtr.withNewObject Ptr IconView
    gi'selfPtr ((IconView -> IO ()) -> IO ()) -> (IconView -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \IconView
    gi'self -> a -> IconViewItemActivatedCallback
    gi'cb (IconView -> a
    forall a b. Coercible a b => a -> b
    Coerce.coerce IconView
    gi'self)  TreePath
    path'

    -- | Connect a signal handler for the [itemActivated](#signal:itemActivated) 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' iconView #itemActivated callback
    -- @
    --
    --
    onIconViewItemActivated :: (IsIconView a, MonadIO m) => a -> ((?self :: a) => IconViewItemActivatedCallback) -> m SignalHandlerId
    onIconViewItemActivated :: forall a (m :: * -> *).
    (IsIconView a, MonadIO m) =>
    a
    -> ((?self::a) => IconViewItemActivatedCallback)
    -> m SignalHandlerId
    onIconViewItemActivated a
    obj (?self::a) => IconViewItemActivatedCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> IconViewItemActivatedCallback
    wrapped a
    self = let ?self = a
    ?self::a
    self in (?self::a) => IconViewItemActivatedCallback
    IconViewItemActivatedCallback
    cb
        let wrapped' :: C_IconViewItemActivatedCallback
    wrapped' = (a -> IconViewItemActivatedCallback)
    -> C_IconViewItemActivatedCallback
    forall a.
    GObject a =>
    (a -> IconViewItemActivatedCallback)
    -> C_IconViewItemActivatedCallback
    wrap_IconViewItemActivatedCallback a -> IconViewItemActivatedCallback
    wrapped
        wrapped'' <- C_IconViewItemActivatedCallback
    -> IO (FunPtr C_IconViewItemActivatedCallback)
    mk_IconViewItemActivatedCallback C_IconViewItemActivatedCallback
    wrapped'
        connectSignalFunPtr obj "item-activated" wrapped'' SignalConnectBefore Nothing

    -- | Connect a signal handler for the [itemActivated](#signal:itemActivated) 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' iconView #itemActivated callback
    -- @
    --
    --
    --
    -- By default the object invoking the signal is not passed to the callback.
    -- If you need to access it, you can use the implit @?self@ parameter.
    -- Note that this requires activating the @ImplicitParams@ GHC extension.
    --
    afterIconViewItemActivated :: (IsIconView a, MonadIO m) => a -> ((?self :: a) => IconViewItemActivatedCallback) -> m SignalHandlerId
    afterIconViewItemActivated :: forall a (m :: * -> *).
    (IsIconView a, MonadIO m) =>
    a
    -> ((?self::a) => IconViewItemActivatedCallback)
    -> m SignalHandlerId
    afterIconViewItemActivated a
    obj (?self::a) => IconViewItemActivatedCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> IconViewItemActivatedCallback
    wrapped a
    self = let ?self = a
    ?self::a
    self in (?self::a) => IconViewItemActivatedCallback
    IconViewItemActivatedCallback
    cb
        let wrapped' :: C_IconViewItemActivatedCallback
    wrapped' = (a -> IconViewItemActivatedCallback)
    -> C_IconViewItemActivatedCallback
    forall a.
    GObject a =>
    (a -> IconViewItemActivatedCallback)
    -> C_IconViewItemActivatedCallback
    wrap_IconViewItemActivatedCallback a -> IconViewItemActivatedCallback
    wrapped
        wrapped'' <- C_IconViewItemActivatedCallback
    -> IO (FunPtr C_IconViewItemActivatedCallback)
    mk_IconViewItemActivatedCallback C_IconViewItemActivatedCallback
    wrapped'
        connectSignalFunPtr obj "item-activated" wrapped'' SignalConnectAfter Nothing

    #if defined(ENABLE_OVERLOADING)
    data IconViewItemActivatedSignalInfo
    instance SignalInfo IconViewItemActivatedSignalInfo where
        type HaskellCallbackType IconViewItemActivatedSignalInfo = IconViewItemActivatedCallback
        connectSignal obj cb connectMode detail = do
            let cb' = wrap_IconViewItemActivatedCallback cb
            cb'' <- mk_IconViewItemActivatedCallback cb'
            connectSignalFunPtr obj "item-activated" cb'' connectMode detail
        dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView::item-activated"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#g:signal:itemActivated"})

    #endif

    -- signal IconView::move-cursor
    -- | The [moveCursor](#g:signal:moveCursor) signal is a
    -- [keybinding signal]t'GI.Gtk.Objects.SignalAction.SignalAction'
    -- which gets emitted when the user initiates a cursor movement.
    --
    -- Applications should not connect to it, but may emit it with
    -- @/g_signal_emit_by_name()/@ if they need to control the cursor
    -- programmatically.
    --
    -- The default bindings for this signal include
    -- * Arrow keys which move by individual steps
    -- * Home\/End keys which move to the first\/last item
    -- * PageUp\/PageDown which move by \"pages\"
    --   All of these will extend the selection when combined with
    --   the Shift modifier.
    type IconViewMoveCursorCallback =
        Gtk.Enums.MovementStep
        -- ^ /@step@/: the granularity of the move, as a @GtkMovementStep@
        -> Int32
        -- ^ /@count@/: the number of /@step@/ units to move
        -> Bool
        -- ^ /@extend@/: whether to extend the selection
        -> Bool
        -- ^ /@modify@/: whether to modify the selection
        -> IO Bool
        -- ^ __Returns:__ whether the cursor was moved

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

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

    wrap_IconViewMoveCursorCallback ::
        GObject a => (a -> IconViewMoveCursorCallback) ->
        C_IconViewMoveCursorCallback
    wrap_IconViewMoveCursorCallback :: forall a.
    GObject a =>
    (a -> IconViewMoveCursorCallback) -> C_IconViewMoveCursorCallback
    wrap_IconViewMoveCursorCallback a -> IconViewMoveCursorCallback
    gi'cb Ptr IconView
    gi'selfPtr CUInt
    step Int32
    count CInt
    extend CInt
    modify Ptr ()
    _ = do
        let step' :: MovementStep
    step' = (Int -> MovementStep
    forall a. Enum a => Int -> a
    toEnum (Int -> MovementStep) -> (CUInt -> Int) -> CUInt -> MovementStep
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . CUInt -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral) CUInt
    step
        let extend' :: Bool
    extend' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    extend
        let modify' :: Bool
    modify' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    modify
        result <- Ptr IconView
    -> (IconView -> IconViewActivateCursorItemCallback)
    -> IconViewActivateCursorItemCallback
    forall o b.
    (HasCallStack, GObject o) =>
    Ptr o -> (o -> IO b) -> IO b
    B.ManagedPtr.withNewObject Ptr IconView
    gi'selfPtr ((IconView -> IconViewActivateCursorItemCallback)
     -> IconViewActivateCursorItemCallback)
    -> (IconView -> IconViewActivateCursorItemCallback)
    -> IconViewActivateCursorItemCallback
    forall a b. (a -> b) -> a -> b
    $ \IconView
    gi'self -> a -> IconViewMoveCursorCallback
    gi'cb (IconView -> a
    forall a b. Coercible a b => a -> b
    Coerce.coerce IconView
    gi'self)  MovementStep
    step' Int32
    count Bool
    extend' Bool
    modify'
        let result' = (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    P.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
    P.fromEnum) Bool
    result
        return result'

    -- | Connect a signal handler for the [moveCursor](#signal:moveCursor) 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' iconView #moveCursor callback
    -- @
    --
    --
    onIconViewMoveCursor :: (IsIconView a, MonadIO m) => a -> ((?self :: a) => IconViewMoveCursorCallback) -> m SignalHandlerId
    onIconViewMoveCursor :: forall a (m :: * -> *).
    (IsIconView a, MonadIO m) =>
    a
    -> ((?self::a) => IconViewMoveCursorCallback) -> m SignalHandlerId
    onIconViewMoveCursor a
    obj (?self::a) => IconViewMoveCursorCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> IconViewMoveCursorCallback
    wrapped a
    self = let ?self = a
    ?self::a
    self in (?self::a) => IconViewMoveCursorCallback
    IconViewMoveCursorCallback
    cb
        let wrapped' :: C_IconViewMoveCursorCallback
    wrapped' = (a -> IconViewMoveCursorCallback) -> C_IconViewMoveCursorCallback
    forall a.
    GObject a =>
    (a -> IconViewMoveCursorCallback) -> C_IconViewMoveCursorCallback
    wrap_IconViewMoveCursorCallback a -> IconViewMoveCursorCallback
    wrapped
        wrapped'' <- C_IconViewMoveCursorCallback
    -> IO (FunPtr C_IconViewMoveCursorCallback)
    mk_IconViewMoveCursorCallback C_IconViewMoveCursorCallback
    wrapped'
        connectSignalFunPtr obj "move-cursor" wrapped'' SignalConnectBefore Nothing

    -- | Connect a signal handler for the [moveCursor](#signal:moveCursor) 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' iconView #moveCursor callback
    -- @
    --
    --
    --
    -- By default the object invoking the signal is not passed to the callback.
    -- If you need to access it, you can use the implit @?self@ parameter.
    -- Note that this requires activating the @ImplicitParams@ GHC extension.
    --
    afterIconViewMoveCursor :: (IsIconView a, MonadIO m) => a -> ((?self :: a) => IconViewMoveCursorCallback) -> m SignalHandlerId
    afterIconViewMoveCursor :: forall a (m :: * -> *).
    (IsIconView a, MonadIO m) =>
    a
    -> ((?self::a) => IconViewMoveCursorCallback) -> m SignalHandlerId
    afterIconViewMoveCursor a
    obj (?self::a) => IconViewMoveCursorCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> IconViewMoveCursorCallback
    wrapped a
    self = let ?self = a
    ?self::a
    self in (?self::a) => IconViewMoveCursorCallback
    IconViewMoveCursorCallback
    cb
        let wrapped' :: C_IconViewMoveCursorCallback
    wrapped' = (a -> IconViewMoveCursorCallback) -> C_IconViewMoveCursorCallback
    forall a.
    GObject a =>
    (a -> IconViewMoveCursorCallback) -> C_IconViewMoveCursorCallback
    wrap_IconViewMoveCursorCallback a -> IconViewMoveCursorCallback
    wrapped
        wrapped'' <- C_IconViewMoveCursorCallback
    -> IO (FunPtr C_IconViewMoveCursorCallback)
    mk_IconViewMoveCursorCallback C_IconViewMoveCursorCallback
    wrapped'
        connectSignalFunPtr obj "move-cursor" wrapped'' SignalConnectAfter Nothing

    #if defined(ENABLE_OVERLOADING)
    data IconViewMoveCursorSignalInfo
    instance SignalInfo IconViewMoveCursorSignalInfo where
        type HaskellCallbackType IconViewMoveCursorSignalInfo = IconViewMoveCursorCallback
        connectSignal obj cb connectMode detail = do
            let cb' = wrap_IconViewMoveCursorCallback cb
            cb'' <- mk_IconViewMoveCursorCallback cb'
            connectSignalFunPtr obj "move-cursor" cb'' connectMode detail
        dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView::move-cursor"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#g:signal:moveCursor"})

    #endif

    -- signal IconView::select-all
    -- | A [keybinding signal]t'GI.Gtk.Objects.SignalAction.SignalAction'
    -- which gets emitted when the user selects all items.
    --
    -- Applications should not connect to it, but may emit it with
    -- @/g_signal_emit_by_name()/@ if they need to control selection
    -- programmatically.
    --
    -- The default binding for this signal is Ctrl-a.
    type IconViewSelectAllCallback =
        IO ()

    type C_IconViewSelectAllCallback =
        Ptr IconView ->                         -- object
        Ptr () ->                               -- user_data
        IO ()

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

    wrap_IconViewSelectAllCallback ::
        GObject a => (a -> IconViewSelectAllCallback) ->
        C_IconViewSelectAllCallback
    wrap_IconViewSelectAllCallback :: forall a. GObject a => (a -> IO ()) -> C_IconViewSelectAllCallback
    wrap_IconViewSelectAllCallback a -> IO ()
    gi'cb Ptr IconView
    gi'selfPtr Ptr ()
    _ = do
        Ptr IconView -> (IconView -> IO ()) -> IO ()
    forall o b.
    (HasCallStack, GObject o) =>
    Ptr o -> (o -> IO b) -> IO b
    B.ManagedPtr.withNewObject Ptr IconView
    gi'selfPtr ((IconView -> IO ()) -> IO ()) -> (IconView -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \IconView
    gi'self -> a -> IO ()
    gi'cb (IconView -> a
    forall a b. Coercible a b => a -> b
    Coerce.coerce IconView
    gi'self)

    -- | Connect a signal handler for the [selectAll](#signal:selectAll) 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' iconView #selectAll callback
    -- @
    --
    --
    onIconViewSelectAll :: (IsIconView a, MonadIO m) => a -> ((?self :: a) => IconViewSelectAllCallback) -> m SignalHandlerId
    onIconViewSelectAll :: forall a (m :: * -> *).
    (IsIconView a, MonadIO m) =>
    a -> ((?self::a) => IO ()) -> m SignalHandlerId
    onIconViewSelectAll a
    obj (?self::a) => IO ()
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> IO ()
    wrapped a
    self = let ?self = a
    ?self::a
    self in IO ()
    (?self::a) => IO ()
    cb
        let wrapped' :: C_IconViewSelectAllCallback
    wrapped' = (a -> IO ()) -> C_IconViewSelectAllCallback
    forall a. GObject a => (a -> IO ()) -> C_IconViewSelectAllCallback
    wrap_IconViewSelectAllCallback a -> IO ()
    wrapped
        wrapped'' <- C_IconViewSelectAllCallback
    -> IO (FunPtr C_IconViewSelectAllCallback)
    mk_IconViewSelectAllCallback C_IconViewSelectAllCallback
    wrapped'
        connectSignalFunPtr obj "select-all" wrapped'' SignalConnectBefore Nothing

    -- | Connect a signal handler for the [selectAll](#signal:selectAll) 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' iconView #selectAll callback
    -- @
    --
    --
    --
    -- By default the object invoking the signal is not passed to the callback.
    -- If you need to access it, you can use the implit @?self@ parameter.
    -- Note that this requires activating the @ImplicitParams@ GHC extension.
    --
    afterIconViewSelectAll :: (IsIconView a, MonadIO m) => a -> ((?self :: a) => IconViewSelectAllCallback) -> m SignalHandlerId
    afterIconViewSelectAll :: forall a (m :: * -> *).
    (IsIconView a, MonadIO m) =>
    a -> ((?self::a) => IO ()) -> m SignalHandlerId
    afterIconViewSelectAll a
    obj (?self::a) => IO ()
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> IO ()
    wrapped a
    self = let ?self = a
    ?self::a
    self in IO ()
    (?self::a) => IO ()
    cb
        let wrapped' :: C_IconViewSelectAllCallback
    wrapped' = (a -> IO ()) -> C_IconViewSelectAllCallback
    forall a. GObject a => (a -> IO ()) -> C_IconViewSelectAllCallback
    wrap_IconViewSelectAllCallback a -> IO ()
    wrapped
        wrapped'' <- C_IconViewSelectAllCallback
    -> IO (FunPtr C_IconViewSelectAllCallback)
    mk_IconViewSelectAllCallback C_IconViewSelectAllCallback
    wrapped'
        connectSignalFunPtr obj "select-all" wrapped'' SignalConnectAfter Nothing

    #if defined(ENABLE_OVERLOADING)
    data IconViewSelectAllSignalInfo
    instance SignalInfo IconViewSelectAllSignalInfo where
        type HaskellCallbackType IconViewSelectAllSignalInfo = IconViewSelectAllCallback
        connectSignal obj cb connectMode detail = do
            let cb' = wrap_IconViewSelectAllCallback cb
            cb'' <- mk_IconViewSelectAllCallback cb'
            connectSignalFunPtr obj "select-all" cb'' connectMode detail
        dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView::select-all"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#g:signal:selectAll"})

    #endif

    -- signal IconView::select-cursor-item
    -- | A [keybinding signal]t'GI.Gtk.Objects.SignalAction.SignalAction'
    -- which gets emitted when the user selects the item that is currently
    -- focused.
    --
    -- Applications should not connect to it, but may emit it with
    -- @/g_signal_emit_by_name()/@ if they need to control selection
    -- programmatically.
    --
    -- There is no default binding for this signal.
    type IconViewSelectCursorItemCallback =
        IO ()

    type C_IconViewSelectCursorItemCallback =
        Ptr IconView ->                         -- object
        Ptr () ->                               -- user_data
        IO ()

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

    wrap_IconViewSelectCursorItemCallback ::
        GObject a => (a -> IconViewSelectCursorItemCallback) ->
        C_IconViewSelectCursorItemCallback
    wrap_IconViewSelectCursorItemCallback :: forall a. GObject a => (a -> IO ()) -> C_IconViewSelectAllCallback
    wrap_IconViewSelectCursorItemCallback a -> IO ()
    gi'cb Ptr IconView
    gi'selfPtr Ptr ()
    _ = do
        Ptr IconView -> (IconView -> IO ()) -> IO ()
    forall o b.
    (HasCallStack, GObject o) =>
    Ptr o -> (o -> IO b) -> IO b
    B.ManagedPtr.withNewObject Ptr IconView
    gi'selfPtr ((IconView -> IO ()) -> IO ()) -> (IconView -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \IconView
    gi'self -> a -> IO ()
    gi'cb (IconView -> a
    forall a b. Coercible a b => a -> b
    Coerce.coerce IconView
    gi'self)

    -- | Connect a signal handler for the [selectCursorItem](#signal:selectCursorItem) 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' iconView #selectCursorItem callback
    -- @
    --
    --
    onIconViewSelectCursorItem :: (IsIconView a, MonadIO m) => a -> ((?self :: a) => IconViewSelectCursorItemCallback) -> m SignalHandlerId
    onIconViewSelectCursorItem :: forall a (m :: * -> *).
    (IsIconView a, MonadIO m) =>
    a -> ((?self::a) => IO ()) -> m SignalHandlerId
    onIconViewSelectCursorItem a
    obj (?self::a) => IO ()
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> IO ()
    wrapped a
    self = let ?self = a
    ?self::a
    self in IO ()
    (?self::a) => IO ()
    cb
        let wrapped' :: C_IconViewSelectAllCallback
    wrapped' = (a -> IO ()) -> C_IconViewSelectAllCallback
    forall a. GObject a => (a -> IO ()) -> C_IconViewSelectAllCallback
    wrap_IconViewSelectCursorItemCallback a -> IO ()
    wrapped
        wrapped'' <- C_IconViewSelectAllCallback
    -> IO (FunPtr C_IconViewSelectAllCallback)
    mk_IconViewSelectCursorItemCallback C_IconViewSelectAllCallback
    wrapped'
        connectSignalFunPtr obj "select-cursor-item" wrapped'' SignalConnectBefore Nothing

    -- | Connect a signal handler for the [selectCursorItem](#signal:selectCursorItem) 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' iconView #selectCursorItem callback
    -- @
    --
    --
    --
    -- By default the object invoking the signal is not passed to the callback.
    -- If you need to access it, you can use the implit @?self@ parameter.
    -- Note that this requires activating the @ImplicitParams@ GHC extension.
    --
    afterIconViewSelectCursorItem :: (IsIconView a, MonadIO m) => a -> ((?self :: a) => IconViewSelectCursorItemCallback) -> m SignalHandlerId
    afterIconViewSelectCursorItem :: forall a (m :: * -> *).
    (IsIconView a, MonadIO m) =>
    a -> ((?self::a) => IO ()) -> m SignalHandlerId
    afterIconViewSelectCursorItem a
    obj (?self::a) => IO ()
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> IO ()
    wrapped a
    self = let ?self = a
    ?self::a
    self in IO ()
    (?self::a) => IO ()
    cb
        let wrapped' :: C_IconViewSelectAllCallback
    wrapped' = (a -> IO ()) -> C_IconViewSelectAllCallback
    forall a. GObject a => (a -> IO ()) -> C_IconViewSelectAllCallback
    wrap_IconViewSelectCursorItemCallback a -> IO ()
    wrapped
        wrapped'' <- C_IconViewSelectAllCallback
    -> IO (FunPtr C_IconViewSelectAllCallback)
    mk_IconViewSelectCursorItemCallback C_IconViewSelectAllCallback
    wrapped'
        connectSignalFunPtr obj "select-cursor-item" wrapped'' SignalConnectAfter Nothing

    #if defined(ENABLE_OVERLOADING)
    data IconViewSelectCursorItemSignalInfo
    instance SignalInfo IconViewSelectCursorItemSignalInfo where
        type HaskellCallbackType IconViewSelectCursorItemSignalInfo = IconViewSelectCursorItemCallback
        connectSignal obj cb connectMode detail = do
            let cb' = wrap_IconViewSelectCursorItemCallback cb
            cb'' <- mk_IconViewSelectCursorItemCallback cb'
            connectSignalFunPtr obj "select-cursor-item" cb'' connectMode detail
        dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView::select-cursor-item"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#g:signal:selectCursorItem"})

    #endif

    -- signal IconView::selection-changed
    -- | The [selectionChanged](#g:signal:selectionChanged) signal is emitted when the selection
    -- (i.e. the set of selected items) changes.
    type IconViewSelectionChangedCallback =
        IO ()

    type C_IconViewSelectionChangedCallback =
        Ptr IconView ->                         -- object
        Ptr () ->                               -- user_data
        IO ()

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

    wrap_IconViewSelectionChangedCallback ::
        GObject a => (a -> IconViewSelectionChangedCallback) ->
        C_IconViewSelectionChangedCallback
    wrap_IconViewSelectionChangedCallback :: forall a. GObject a => (a -> IO ()) -> C_IconViewSelectAllCallback
    wrap_IconViewSelectionChangedCallback a -> IO ()
    gi'cb Ptr IconView
    gi'selfPtr Ptr ()
    _ = do
        Ptr IconView -> (IconView -> IO ()) -> IO ()
    forall o b.
    (HasCallStack, GObject o) =>
    Ptr o -> (o -> IO b) -> IO b
    B.ManagedPtr.withNewObject Ptr IconView
    gi'selfPtr ((IconView -> IO ()) -> IO ()) -> (IconView -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \IconView
    gi'self -> a -> IO ()
    gi'cb (IconView -> a
    forall a b. Coercible a b => a -> b
    Coerce.coerce IconView
    gi'self)

    -- | Connect a signal handler for the [selectionChanged](#signal:selectionChanged) 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' iconView #selectionChanged callback
    -- @
    --
    --
    onIconViewSelectionChanged :: (IsIconView a, MonadIO m) => a -> ((?self :: a) => IconViewSelectionChangedCallback) -> m SignalHandlerId
    onIconViewSelectionChanged :: forall a (m :: * -> *).
    (IsIconView a, MonadIO m) =>
    a -> ((?self::a) => IO ()) -> m SignalHandlerId
    onIconViewSelectionChanged a
    obj (?self::a) => IO ()
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> IO ()
    wrapped a
    self = let ?self = a
    ?self::a
    self in IO ()
    (?self::a) => IO ()
    cb
        let wrapped' :: C_IconViewSelectAllCallback
    wrapped' = (a -> IO ()) -> C_IconViewSelectAllCallback
    forall a. GObject a => (a -> IO ()) -> C_IconViewSelectAllCallback
    wrap_IconViewSelectionChangedCallback a -> IO ()
    wrapped
        wrapped'' <- C_IconViewSelectAllCallback
    -> IO (FunPtr C_IconViewSelectAllCallback)
    mk_IconViewSelectionChangedCallback C_IconViewSelectAllCallback
    wrapped'
        connectSignalFunPtr obj "selection-changed" wrapped'' SignalConnectBefore Nothing

    -- | Connect a signal handler for the [selectionChanged](#signal:selectionChanged) 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' iconView #selectionChanged callback
    -- @
    --
    --
    --
    -- By default the object invoking the signal is not passed to the callback.
    -- If you need to access it, you can use the implit @?self@ parameter.
    -- Note that this requires activating the @ImplicitParams@ GHC extension.
    --
    afterIconViewSelectionChanged :: (IsIconView a, MonadIO m) => a -> ((?self :: a) => IconViewSelectionChangedCallback) -> m SignalHandlerId
    afterIconViewSelectionChanged :: forall a (m :: * -> *).
    (IsIconView a, MonadIO m) =>
    a -> ((?self::a) => IO ()) -> m SignalHandlerId
    afterIconViewSelectionChanged a
    obj (?self::a) => IO ()
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> IO ()
    wrapped a
    self = let ?self = a
    ?self::a
    self in IO ()
    (?self::a) => IO ()
    cb
        let wrapped' :: C_IconViewSelectAllCallback
    wrapped' = (a -> IO ()) -> C_IconViewSelectAllCallback
    forall a. GObject a => (a -> IO ()) -> C_IconViewSelectAllCallback
    wrap_IconViewSelectionChangedCallback a -> IO ()
    wrapped
        wrapped'' <- C_IconViewSelectAllCallback
    -> IO (FunPtr C_IconViewSelectAllCallback)
    mk_IconViewSelectionChangedCallback C_IconViewSelectAllCallback
    wrapped'
        connectSignalFunPtr obj "selection-changed" wrapped'' SignalConnectAfter Nothing

    #if defined(ENABLE_OVERLOADING)
    data IconViewSelectionChangedSignalInfo
    instance SignalInfo IconViewSelectionChangedSignalInfo where
        type HaskellCallbackType IconViewSelectionChangedSignalInfo = IconViewSelectionChangedCallback
        connectSignal obj cb connectMode detail = do
            let cb' = wrap_IconViewSelectionChangedCallback cb
            cb'' <- mk_IconViewSelectionChangedCallback cb'
            connectSignalFunPtr obj "selection-changed" cb'' connectMode detail
        dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView::selection-changed"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#g:signal:selectionChanged"})

    #endif

    -- signal IconView::toggle-cursor-item
    -- | A [keybinding signal]t'GI.Gtk.Objects.SignalAction.SignalAction'
    -- which gets emitted when the user toggles whether the currently
    -- focused item is selected or not. The exact effect of this
    -- depend on the selection mode.
    --
    -- Applications should not connect to it, but may emit it with
    -- @/g_signal_emit_by_name()/@ if they need to control selection
    -- programmatically.
    --
    -- There is no default binding for this signal is Ctrl-Space.
    type IconViewToggleCursorItemCallback =
        IO ()

    type C_IconViewToggleCursorItemCallback =
        Ptr IconView ->                         -- object
        Ptr () ->                               -- user_data
        IO ()

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

    wrap_IconViewToggleCursorItemCallback ::
        GObject a => (a -> IconViewToggleCursorItemCallback) ->
        C_IconViewToggleCursorItemCallback
    wrap_IconViewToggleCursorItemCallback :: forall a. GObject a => (a -> IO ()) -> C_IconViewSelectAllCallback
    wrap_IconViewToggleCursorItemCallback a -> IO ()
    gi'cb Ptr IconView
    gi'selfPtr Ptr ()
    _ = do
        Ptr IconView -> (IconView -> IO ()) -> IO ()
    forall o b.
    (HasCallStack, GObject o) =>
    Ptr o -> (o -> IO b) -> IO b
    B.ManagedPtr.withNewObject Ptr IconView
    gi'selfPtr ((IconView -> IO ()) -> IO ()) -> (IconView -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \IconView
    gi'self -> a -> IO ()
    gi'cb (IconView -> a
    forall a b. Coercible a b => a -> b
    Coerce.coerce IconView
    gi'self)

    -- | Connect a signal handler for the [toggleCursorItem](#signal:toggleCursorItem) 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' iconView #toggleCursorItem callback
    -- @
    --
    --
    onIconViewToggleCursorItem :: (IsIconView a, MonadIO m) => a -> ((?self :: a) => IconViewToggleCursorItemCallback) -> m SignalHandlerId
    onIconViewToggleCursorItem :: forall a (m :: * -> *).
    (IsIconView a, MonadIO m) =>
    a -> ((?self::a) => IO ()) -> m SignalHandlerId
    onIconViewToggleCursorItem a
    obj (?self::a) => IO ()
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> IO ()
    wrapped a
    self = let ?self = a
    ?self::a
    self in IO ()
    (?self::a) => IO ()
    cb
        let wrapped' :: C_IconViewSelectAllCallback
    wrapped' = (a -> IO ()) -> C_IconViewSelectAllCallback
    forall a. GObject a => (a -> IO ()) -> C_IconViewSelectAllCallback
    wrap_IconViewToggleCursorItemCallback a -> IO ()
    wrapped
        wrapped'' <- C_IconViewSelectAllCallback
    -> IO (FunPtr C_IconViewSelectAllCallback)
    mk_IconViewToggleCursorItemCallback C_IconViewSelectAllCallback
    wrapped'
        connectSignalFunPtr obj "toggle-cursor-item" wrapped'' SignalConnectBefore Nothing

    -- | Connect a signal handler for the [toggleCursorItem](#signal:toggleCursorItem) 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' iconView #toggleCursorItem callback
    -- @
    --
    --
    --
    -- By default the object invoking the signal is not passed to the callback.
    -- If you need to access it, you can use the implit @?self@ parameter.
    -- Note that this requires activating the @ImplicitParams@ GHC extension.
    --
    afterIconViewToggleCursorItem :: (IsIconView a, MonadIO m) => a -> ((?self :: a) => IconViewToggleCursorItemCallback) -> m SignalHandlerId
    afterIconViewToggleCursorItem :: forall a (m :: * -> *).
    (IsIconView a, MonadIO m) =>
    a -> ((?self::a) => IO ()) -> m SignalHandlerId
    afterIconViewToggleCursorItem a
    obj (?self::a) => IO ()
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> IO ()
    wrapped a
    self = let ?self = a
    ?self::a
    self in IO ()
    (?self::a) => IO ()
    cb
        let wrapped' :: C_IconViewSelectAllCallback
    wrapped' = (a -> IO ()) -> C_IconViewSelectAllCallback
    forall a. GObject a => (a -> IO ()) -> C_IconViewSelectAllCallback
    wrap_IconViewToggleCursorItemCallback a -> IO ()
    wrapped
        wrapped'' <- C_IconViewSelectAllCallback
    -> IO (FunPtr C_IconViewSelectAllCallback)
    mk_IconViewToggleCursorItemCallback C_IconViewSelectAllCallback
    wrapped'
        connectSignalFunPtr obj "toggle-cursor-item" wrapped'' SignalConnectAfter Nothing

    #if defined(ENABLE_OVERLOADING)
    data IconViewToggleCursorItemSignalInfo
    instance SignalInfo IconViewToggleCursorItemSignalInfo where
        type HaskellCallbackType IconViewToggleCursorItemSignalInfo = IconViewToggleCursorItemCallback
        connectSignal obj cb connectMode detail = do
            let cb' = wrap_IconViewToggleCursorItemCallback cb
            cb'' <- mk_IconViewToggleCursorItemCallback cb'
            connectSignalFunPtr obj "toggle-cursor-item" cb'' connectMode detail
        dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView::toggle-cursor-item"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#g:signal:toggleCursorItem"})

    #endif

    -- signal IconView::unselect-all
    -- | A [keybinding signal]t'GI.Gtk.Objects.SignalAction.SignalAction'
    -- which gets emitted when the user unselects all items.
    --
    -- Applications should not connect to it, but may emit it with
    -- @/g_signal_emit_by_name()/@ if they need to control selection
    -- programmatically.
    --
    -- The default binding for this signal is Ctrl-Shift-a.
    type IconViewUnselectAllCallback =
        IO ()

    type C_IconViewUnselectAllCallback =
        Ptr IconView ->                         -- object
        Ptr () ->                               -- user_data
        IO ()

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

    wrap_IconViewUnselectAllCallback ::
        GObject a => (a -> IconViewUnselectAllCallback) ->
        C_IconViewUnselectAllCallback
    wrap_IconViewUnselectAllCallback :: forall a. GObject a => (a -> IO ()) -> C_IconViewSelectAllCallback
    wrap_IconViewUnselectAllCallback a -> IO ()
    gi'cb Ptr IconView
    gi'selfPtr Ptr ()
    _ = do
        Ptr IconView -> (IconView -> IO ()) -> IO ()
    forall o b.
    (HasCallStack, GObject o) =>
    Ptr o -> (o -> IO b) -> IO b
    B.ManagedPtr.withNewObject Ptr IconView
    gi'selfPtr ((IconView -> IO ()) -> IO ()) -> (IconView -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \IconView
    gi'self -> a -> IO ()
    gi'cb (IconView -> a
    forall a b. Coercible a b => a -> b
    Coerce.coerce IconView
    gi'self)

    -- | Connect a signal handler for the [unselectAll](#signal:unselectAll) 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' iconView #unselectAll callback
    -- @
    --
    --
    onIconViewUnselectAll :: (IsIconView a, MonadIO m) => a -> ((?self :: a) => IconViewUnselectAllCallback) -> m SignalHandlerId
    onIconViewUnselectAll :: forall a (m :: * -> *).
    (IsIconView a, MonadIO m) =>
    a -> ((?self::a) => IO ()) -> m SignalHandlerId
    onIconViewUnselectAll a
    obj (?self::a) => IO ()
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> IO ()
    wrapped a
    self = let ?self = a
    ?self::a
    self in IO ()
    (?self::a) => IO ()
    cb
        let wrapped' :: C_IconViewSelectAllCallback
    wrapped' = (a -> IO ()) -> C_IconViewSelectAllCallback
    forall a. GObject a => (a -> IO ()) -> C_IconViewSelectAllCallback
    wrap_IconViewUnselectAllCallback a -> IO ()
    wrapped
        wrapped'' <- C_IconViewSelectAllCallback
    -> IO (FunPtr C_IconViewSelectAllCallback)
    mk_IconViewUnselectAllCallback C_IconViewSelectAllCallback
    wrapped'
        connectSignalFunPtr obj "unselect-all" wrapped'' SignalConnectBefore Nothing

    -- | Connect a signal handler for the [unselectAll](#signal:unselectAll) 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' iconView #unselectAll callback
    -- @
    --
    --
    --
    -- By default the object invoking the signal is not passed to the callback.
    -- If you need to access it, you can use the implit @?self@ parameter.
    -- Note that this requires activating the @ImplicitParams@ GHC extension.
    --
    afterIconViewUnselectAll :: (IsIconView a, MonadIO m) => a -> ((?self :: a) => IconViewUnselectAllCallback) -> m SignalHandlerId
    afterIconViewUnselectAll :: forall a (m :: * -> *).
    (IsIconView a, MonadIO m) =>
    a -> ((?self::a) => IO ()) -> m SignalHandlerId
    afterIconViewUnselectAll a
    obj (?self::a) => IO ()
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> IO ()
    wrapped a
    self = let ?self = a
    ?self::a
    self in IO ()
    (?self::a) => IO ()
    cb
        let wrapped' :: C_IconViewSelectAllCallback
    wrapped' = (a -> IO ()) -> C_IconViewSelectAllCallback
    forall a. GObject a => (a -> IO ()) -> C_IconViewSelectAllCallback
    wrap_IconViewUnselectAllCallback a -> IO ()
    wrapped
        wrapped'' <- C_IconViewSelectAllCallback
    -> IO (FunPtr C_IconViewSelectAllCallback)
    mk_IconViewUnselectAllCallback C_IconViewSelectAllCallback
    wrapped'
        connectSignalFunPtr obj "unselect-all" wrapped'' SignalConnectAfter Nothing

    #if defined(ENABLE_OVERLOADING)
    data IconViewUnselectAllSignalInfo
    instance SignalInfo IconViewUnselectAllSignalInfo where
        type HaskellCallbackType IconViewUnselectAllSignalInfo = IconViewUnselectAllCallback
        connectSignal obj cb connectMode detail = do
            let cb' = wrap_IconViewUnselectAllCallback cb
            cb'' <- mk_IconViewUnselectAllCallback cb'
            connectSignalFunPtr obj "unselect-all" cb'' connectMode detail
        dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView::unselect-all"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#g:signal:unselectAll"})

    #endif

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

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

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

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

    #if defined(ENABLE_OVERLOADING)
    data IconViewActivateOnSingleClickPropertyInfo
    instance AttrInfo IconViewActivateOnSingleClickPropertyInfo where
        type AttrAllowedOps IconViewActivateOnSingleClickPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
        type AttrBaseTypeConstraint IconViewActivateOnSingleClickPropertyInfo = IsIconView
        type AttrSetTypeConstraint IconViewActivateOnSingleClickPropertyInfo = (~) Bool
        type AttrTransferTypeConstraint IconViewActivateOnSingleClickPropertyInfo = (~) Bool
        type AttrTransferType IconViewActivateOnSingleClickPropertyInfo = Bool
        type AttrGetType IconViewActivateOnSingleClickPropertyInfo = Bool
        type AttrLabel IconViewActivateOnSingleClickPropertyInfo = "activate-on-single-click"
        type AttrOrigin IconViewActivateOnSingleClickPropertyInfo = IconView
        attrGet = getIconViewActivateOnSingleClick
        attrSet = setIconViewActivateOnSingleClick
        attrPut = setIconViewActivateOnSingleClick
        attrTransfer _ v = do
            return v
        attrConstruct = constructIconViewActivateOnSingleClick
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.activateOnSingleClick"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#g:attr:activateOnSingleClick"
            })
    #endif

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

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

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

    #if defined(ENABLE_OVERLOADING)
    data IconViewCellAreaPropertyInfo
    instance AttrInfo IconViewCellAreaPropertyInfo where
        type AttrAllowedOps IconViewCellAreaPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrBaseTypeConstraint IconViewCellAreaPropertyInfo = IsIconView
        type AttrSetTypeConstraint IconViewCellAreaPropertyInfo = Gtk.CellArea.IsCellArea
        type AttrTransferTypeConstraint IconViewCellAreaPropertyInfo = Gtk.CellArea.IsCellArea
        type AttrTransferType IconViewCellAreaPropertyInfo = Gtk.CellArea.CellArea
        type AttrGetType IconViewCellAreaPropertyInfo = (Maybe Gtk.CellArea.CellArea)
        type AttrLabel IconViewCellAreaPropertyInfo = "cell-area"
        type AttrOrigin IconViewCellAreaPropertyInfo = IconView
        attrGet = getIconViewCellArea
        attrSet = undefined
        attrPut = undefined
        attrTransfer _ v = do
            unsafeCastTo Gtk.CellArea.CellArea v
        attrConstruct = constructIconViewCellArea
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.cellArea"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#g:attr:cellArea"
            })
    #endif

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

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

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

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

    #if defined(ENABLE_OVERLOADING)
    data IconViewColumnSpacingPropertyInfo
    instance AttrInfo IconViewColumnSpacingPropertyInfo where
        type AttrAllowedOps IconViewColumnSpacingPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
        type AttrBaseTypeConstraint IconViewColumnSpacingPropertyInfo = IsIconView
        type AttrSetTypeConstraint IconViewColumnSpacingPropertyInfo = (~) Int32
        type AttrTransferTypeConstraint IconViewColumnSpacingPropertyInfo = (~) Int32
        type AttrTransferType IconViewColumnSpacingPropertyInfo = Int32
        type AttrGetType IconViewColumnSpacingPropertyInfo = Int32
        type AttrLabel IconViewColumnSpacingPropertyInfo = "column-spacing"
        type AttrOrigin IconViewColumnSpacingPropertyInfo = IconView
        attrGet = getIconViewColumnSpacing
        attrSet = setIconViewColumnSpacing
        attrPut = setIconViewColumnSpacing
        attrTransfer _ v = do
            return v
        attrConstruct = constructIconViewColumnSpacing
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.columnSpacing"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#g:attr:columnSpacing"
            })
    #endif

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

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

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

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

    #if defined(ENABLE_OVERLOADING)
    data IconViewColumnsPropertyInfo
    instance AttrInfo IconViewColumnsPropertyInfo where
        type AttrAllowedOps IconViewColumnsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
        type AttrBaseTypeConstraint IconViewColumnsPropertyInfo = IsIconView
        type AttrSetTypeConstraint IconViewColumnsPropertyInfo = (~) Int32
        type AttrTransferTypeConstraint IconViewColumnsPropertyInfo = (~) Int32
        type AttrTransferType IconViewColumnsPropertyInfo = Int32
        type AttrGetType IconViewColumnsPropertyInfo = Int32
        type AttrLabel IconViewColumnsPropertyInfo = "columns"
        type AttrOrigin IconViewColumnsPropertyInfo = IconView
        attrGet = getIconViewColumns
        attrSet = setIconViewColumns
        attrPut = setIconViewColumns
        attrTransfer _ v = do
            return v
        attrConstruct = constructIconViewColumns
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.columns"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#g:attr:columns"
            })
    #endif

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

    -- | Get the value of the “@item-orientation@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' iconView #itemOrientation
    -- @
    getIconViewItemOrientation :: (MonadIO m, IsIconView o) => o -> m Gtk.Enums.Orientation
    getIconViewItemOrientation :: forall (m :: * -> *) o.
    (MonadIO m, IsIconView o) =>
    o -> m Orientation
    getIconViewItemOrientation o
    obj = IO Orientation -> m Orientation
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO Orientation -> m Orientation)
    -> IO Orientation -> m Orientation
    forall a b. (a -> b) -> a -> b
    $ o -> String -> IO Orientation
    forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
    B.Properties.getObjectPropertyEnum o
    obj String
    "item-orientation"

    -- | Set the value of the “@item-orientation@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' iconView [ #itemOrientation 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setIconViewItemOrientation :: (MonadIO m, IsIconView o) => o -> Gtk.Enums.Orientation -> m ()
    setIconViewItemOrientation :: forall (m :: * -> *) o.
    (MonadIO m, IsIconView o) =>
    o -> Orientation -> m ()
    setIconViewItemOrientation o
    obj Orientation
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        o -> String -> Orientation -> IO ()
    forall a b.
    (GObject a, Enum b, BoxedEnum b) =>
    a -> String -> b -> IO ()
    B.Properties.setObjectPropertyEnum o
    obj String
    "item-orientation" Orientation
    val

    -- | Construct a t'GValueConstruct' with valid value for the “@item-orientation@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    constructIconViewItemOrientation :: (IsIconView o, MIO.MonadIO m) => Gtk.Enums.Orientation -> m (GValueConstruct o)
    constructIconViewItemOrientation :: forall o (m :: * -> *).
    (IsIconView o, MonadIO m) =>
    Orientation -> m (GValueConstruct o)
    constructIconViewItemOrientation Orientation
    val = IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ do
        IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a. IO a -> IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
    -> IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> Orientation -> IO (GValueConstruct o)
    forall a o.
    (Enum a, BoxedEnum a) =>
    String -> a -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyEnum String
    "item-orientation" Orientation
    val

    #if defined(ENABLE_OVERLOADING)
    data IconViewItemOrientationPropertyInfo
    instance AttrInfo IconViewItemOrientationPropertyInfo where
        type AttrAllowedOps IconViewItemOrientationPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
        type AttrBaseTypeConstraint IconViewItemOrientationPropertyInfo = IsIconView
        type AttrSetTypeConstraint IconViewItemOrientationPropertyInfo = (~) Gtk.Enums.Orientation
        type AttrTransferTypeConstraint IconViewItemOrientationPropertyInfo = (~) Gtk.Enums.Orientation
        type AttrTransferType IconViewItemOrientationPropertyInfo = Gtk.Enums.Orientation
        type AttrGetType IconViewItemOrientationPropertyInfo = Gtk.Enums.Orientation
        type AttrLabel IconViewItemOrientationPropertyInfo = "item-orientation"
        type AttrOrigin IconViewItemOrientationPropertyInfo = IconView
        attrGet = getIconViewItemOrientation
        attrSet = setIconViewItemOrientation
        attrPut = setIconViewItemOrientation
        attrTransfer _ v = do
            return v
        attrConstruct = constructIconViewItemOrientation
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.itemOrientation"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#g:attr:itemOrientation"
            })
    #endif

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

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

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

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

    #if defined(ENABLE_OVERLOADING)
    data IconViewItemPaddingPropertyInfo
    instance AttrInfo IconViewItemPaddingPropertyInfo where
        type AttrAllowedOps IconViewItemPaddingPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
        type AttrBaseTypeConstraint IconViewItemPaddingPropertyInfo = IsIconView
        type AttrSetTypeConstraint IconViewItemPaddingPropertyInfo = (~) Int32
        type AttrTransferTypeConstraint IconViewItemPaddingPropertyInfo = (~) Int32
        type AttrTransferType IconViewItemPaddingPropertyInfo = Int32
        type AttrGetType IconViewItemPaddingPropertyInfo = Int32
        type AttrLabel IconViewItemPaddingPropertyInfo = "item-padding"
        type AttrOrigin IconViewItemPaddingPropertyInfo = IconView
        attrGet = getIconViewItemPadding
        attrSet = setIconViewItemPadding
        attrPut = setIconViewItemPadding
        attrTransfer _ v = do
            return v
        attrConstruct = constructIconViewItemPadding
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.itemPadding"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#g:attr:itemPadding"
            })
    #endif

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

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

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

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

    #if defined(ENABLE_OVERLOADING)
    data IconViewItemWidthPropertyInfo
    instance AttrInfo IconViewItemWidthPropertyInfo where
        type AttrAllowedOps IconViewItemWidthPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
        type AttrBaseTypeConstraint IconViewItemWidthPropertyInfo = IsIconView
        type AttrSetTypeConstraint IconViewItemWidthPropertyInfo = (~) Int32
        type AttrTransferTypeConstraint IconViewItemWidthPropertyInfo = (~) Int32
        type AttrTransferType IconViewItemWidthPropertyInfo = Int32
        type AttrGetType IconViewItemWidthPropertyInfo = Int32
        type AttrLabel IconViewItemWidthPropertyInfo = "item-width"
        type AttrOrigin IconViewItemWidthPropertyInfo = IconView
        attrGet = getIconViewItemWidth
        attrSet = setIconViewItemWidth
        attrPut = setIconViewItemWidth
        attrTransfer _ v = do
            return v
        attrConstruct = constructIconViewItemWidth
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.itemWidth"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#g:attr:itemWidth"
            })
    #endif

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

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

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

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

    #if defined(ENABLE_OVERLOADING)
    data IconViewMarginPropertyInfo
    instance AttrInfo IconViewMarginPropertyInfo where
        type AttrAllowedOps IconViewMarginPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
        type AttrBaseTypeConstraint IconViewMarginPropertyInfo = IsIconView
        type AttrSetTypeConstraint IconViewMarginPropertyInfo = (~) Int32
        type AttrTransferTypeConstraint IconViewMarginPropertyInfo = (~) Int32
        type AttrTransferType IconViewMarginPropertyInfo = Int32
        type AttrGetType IconViewMarginPropertyInfo = Int32
        type AttrLabel IconViewMarginPropertyInfo = "margin"
        type AttrOrigin IconViewMarginPropertyInfo = IconView
        attrGet = getIconViewMargin
        attrSet = setIconViewMargin
        attrPut = setIconViewMargin
        attrTransfer _ v = do
            return v
        attrConstruct = constructIconViewMargin
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.margin"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#g:attr:margin"
            })
    #endif

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

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

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

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

    #if defined(ENABLE_OVERLOADING)
    data IconViewMarkupColumnPropertyInfo
    instance AttrInfo IconViewMarkupColumnPropertyInfo where
        type AttrAllowedOps IconViewMarkupColumnPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
        type AttrBaseTypeConstraint IconViewMarkupColumnPropertyInfo = IsIconView
        type AttrSetTypeConstraint IconViewMarkupColumnPropertyInfo = (~) Int32
        type AttrTransferTypeConstraint IconViewMarkupColumnPropertyInfo = (~) Int32
        type AttrTransferType IconViewMarkupColumnPropertyInfo = Int32
        type AttrGetType IconViewMarkupColumnPropertyInfo = Int32
        type AttrLabel IconViewMarkupColumnPropertyInfo = "markup-column"
        type AttrOrigin IconViewMarkupColumnPropertyInfo = IconView
        attrGet = getIconViewMarkupColumn
        attrSet = setIconViewMarkupColumn
        attrPut = setIconViewMarkupColumn
        attrTransfer _ v = do
            return v
        attrConstruct = constructIconViewMarkupColumn
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.markupColumn"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#g:attr:markupColumn"
            })
    #endif

    -- VVV Prop "model"
       -- Type: TInterface (Name {namespace = "Gtk", name = "TreeModel"})
       -- 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' iconView #model
    -- @
    getIconViewModel :: (MonadIO m, IsIconView o) => o -> m (Maybe Gtk.TreeModel.TreeModel)
    getIconViewModel :: forall (m :: * -> *) o.
    (MonadIO m, IsIconView o) =>
    o -> m (Maybe TreeModel)
    getIconViewModel o
    obj = IO (Maybe TreeModel) -> m (Maybe TreeModel)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (Maybe TreeModel) -> m (Maybe TreeModel))
    -> IO (Maybe TreeModel) -> m (Maybe TreeModel)
    forall a b. (a -> b) -> a -> b
    $ o
    -> String
    -> (ManagedPtr TreeModel -> TreeModel)
    -> IO (Maybe TreeModel)
    forall a b.
    (GObject a, GObject b) =>
    a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
    B.Properties.getObjectPropertyObject o
    obj String
    "model" ManagedPtr TreeModel -> TreeModel
    Gtk.TreeModel.TreeModel

    -- | 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' iconView [ #model 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setIconViewModel :: (MonadIO m, IsIconView o, Gtk.TreeModel.IsTreeModel a) => o -> a -> m ()
    setIconViewModel :: forall (m :: * -> *) o a.
    (MonadIO m, IsIconView o, IsTreeModel a) =>
    o -> a -> m ()
    setIconViewModel o
    obj a
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        o -> String -> Maybe a -> IO ()
    forall a b.
    (GObject a, GObject b) =>
    a -> String -> Maybe b -> IO ()
    B.Properties.setObjectPropertyObject o
    obj String
    "model" (a -> Maybe a
    forall a. a -> Maybe a
    Just a
    val)

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

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

    #if defined(ENABLE_OVERLOADING)
    data IconViewModelPropertyInfo
    instance AttrInfo IconViewModelPropertyInfo where
        type AttrAllowedOps IconViewModelPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrBaseTypeConstraint IconViewModelPropertyInfo = IsIconView
        type AttrSetTypeConstraint IconViewModelPropertyInfo = Gtk.TreeModel.IsTreeModel
        type AttrTransferTypeConstraint IconViewModelPropertyInfo = Gtk.TreeModel.IsTreeModel
        type AttrTransferType IconViewModelPropertyInfo = Gtk.TreeModel.TreeModel
        type AttrGetType IconViewModelPropertyInfo = (Maybe Gtk.TreeModel.TreeModel)
        type AttrLabel IconViewModelPropertyInfo = "model"
        type AttrOrigin IconViewModelPropertyInfo = IconView
        attrGet = getIconViewModel
        attrSet = setIconViewModel
        attrPut = undefined
        attrTransfer _ v = do
            unsafeCastTo Gtk.TreeModel.TreeModel v
        attrConstruct = constructIconViewModel
        attrClear = clearIconViewModel
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.model"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#g:attr:model"
            })
    #endif

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

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

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

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

    #if defined(ENABLE_OVERLOADING)
    data IconViewPixbufColumnPropertyInfo
    instance AttrInfo IconViewPixbufColumnPropertyInfo where
        type AttrAllowedOps IconViewPixbufColumnPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
        type AttrBaseTypeConstraint IconViewPixbufColumnPropertyInfo = IsIconView
        type AttrSetTypeConstraint IconViewPixbufColumnPropertyInfo = (~) Int32
        type AttrTransferTypeConstraint IconViewPixbufColumnPropertyInfo = (~) Int32
        type AttrTransferType IconViewPixbufColumnPropertyInfo = Int32
        type AttrGetType IconViewPixbufColumnPropertyInfo = Int32
        type AttrLabel IconViewPixbufColumnPropertyInfo = "pixbuf-column"
        type AttrOrigin IconViewPixbufColumnPropertyInfo = IconView
        attrGet = getIconViewPixbufColumn
        attrSet = setIconViewPixbufColumn
        attrPut = setIconViewPixbufColumn
        attrTransfer _ v = do
            return v
        attrConstruct = constructIconViewPixbufColumn
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.pixbufColumn"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#g:attr:pixbufColumn"
            })
    #endif

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

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

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

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

    #if defined(ENABLE_OVERLOADING)
    data IconViewReorderablePropertyInfo
    instance AttrInfo IconViewReorderablePropertyInfo where
        type AttrAllowedOps IconViewReorderablePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
        type AttrBaseTypeConstraint IconViewReorderablePropertyInfo = IsIconView
        type AttrSetTypeConstraint IconViewReorderablePropertyInfo = (~) Bool
        type AttrTransferTypeConstraint IconViewReorderablePropertyInfo = (~) Bool
        type AttrTransferType IconViewReorderablePropertyInfo = Bool
        type AttrGetType IconViewReorderablePropertyInfo = Bool
        type AttrLabel IconViewReorderablePropertyInfo = "reorderable"
        type AttrOrigin IconViewReorderablePropertyInfo = IconView
        attrGet = getIconViewReorderable
        attrSet = setIconViewReorderable
        attrPut = setIconViewReorderable
        attrTransfer _ v = do
            return v
        attrConstruct = constructIconViewReorderable
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.reorderable"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#g:attr:reorderable"
            })
    #endif

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

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

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

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

    #if defined(ENABLE_OVERLOADING)
    data IconViewRowSpacingPropertyInfo
    instance AttrInfo IconViewRowSpacingPropertyInfo where
        type AttrAllowedOps IconViewRowSpacingPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
        type AttrBaseTypeConstraint IconViewRowSpacingPropertyInfo = IsIconView
        type AttrSetTypeConstraint IconViewRowSpacingPropertyInfo = (~) Int32
        type AttrTransferTypeConstraint IconViewRowSpacingPropertyInfo = (~) Int32
        type AttrTransferType IconViewRowSpacingPropertyInfo = Int32
        type AttrGetType IconViewRowSpacingPropertyInfo = Int32
        type AttrLabel IconViewRowSpacingPropertyInfo = "row-spacing"
        type AttrOrigin IconViewRowSpacingPropertyInfo = IconView
        attrGet = getIconViewRowSpacing
        attrSet = setIconViewRowSpacing
        attrPut = setIconViewRowSpacing
        attrTransfer _ v = do
            return v
        attrConstruct = constructIconViewRowSpacing
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.rowSpacing"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#g:attr:rowSpacing"
            })
    #endif

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

    -- | Get the value of the “@selection-mode@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' iconView #selectionMode
    -- @
    getIconViewSelectionMode :: (MonadIO m, IsIconView o) => o -> m Gtk.Enums.SelectionMode
    getIconViewSelectionMode :: forall (m :: * -> *) o.
    (MonadIO m, IsIconView o) =>
    o -> m SelectionMode
    getIconViewSelectionMode o
    obj = IO SelectionMode -> m SelectionMode
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO SelectionMode -> m SelectionMode)
    -> IO SelectionMode -> m SelectionMode
    forall a b. (a -> b) -> a -> b
    $ o -> String -> IO SelectionMode
    forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
    B.Properties.getObjectPropertyEnum o
    obj String
    "selection-mode"

    -- | Set the value of the “@selection-mode@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' iconView [ #selectionMode 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setIconViewSelectionMode :: (MonadIO m, IsIconView o) => o -> Gtk.Enums.SelectionMode -> m ()
    setIconViewSelectionMode :: forall (m :: * -> *) o.
    (MonadIO m, IsIconView o) =>
    o -> SelectionMode -> m ()
    setIconViewSelectionMode o
    obj SelectionMode
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        o -> String -> SelectionMode -> IO ()
    forall a b.
    (GObject a, Enum b, BoxedEnum b) =>
    a -> String -> b -> IO ()
    B.Properties.setObjectPropertyEnum o
    obj String
    "selection-mode" SelectionMode
    val

    -- | Construct a t'GValueConstruct' with valid value for the “@selection-mode@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    constructIconViewSelectionMode :: (IsIconView o, MIO.MonadIO m) => Gtk.Enums.SelectionMode -> m (GValueConstruct o)
    constructIconViewSelectionMode :: forall o (m :: * -> *).
    (IsIconView o, MonadIO m) =>
    SelectionMode -> m (GValueConstruct o)
    constructIconViewSelectionMode SelectionMode
    val = IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ do
        IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a. IO a -> IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
    -> IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> SelectionMode -> IO (GValueConstruct o)
    forall a o.
    (Enum a, BoxedEnum a) =>
    String -> a -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyEnum String
    "selection-mode" SelectionMode
    val

    #if defined(ENABLE_OVERLOADING)
    data IconViewSelectionModePropertyInfo
    instance AttrInfo IconViewSelectionModePropertyInfo where
        type AttrAllowedOps IconViewSelectionModePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
        type AttrBaseTypeConstraint IconViewSelectionModePropertyInfo = IsIconView
        type AttrSetTypeConstraint IconViewSelectionModePropertyInfo = (~) Gtk.Enums.SelectionMode
        type AttrTransferTypeConstraint IconViewSelectionModePropertyInfo = (~) Gtk.Enums.SelectionMode
        type AttrTransferType IconViewSelectionModePropertyInfo = Gtk.Enums.SelectionMode
        type AttrGetType IconViewSelectionModePropertyInfo = Gtk.Enums.SelectionMode
        type AttrLabel IconViewSelectionModePropertyInfo = "selection-mode"
        type AttrOrigin IconViewSelectionModePropertyInfo = IconView
        attrGet = getIconViewSelectionMode
        attrSet = setIconViewSelectionMode
        attrPut = setIconViewSelectionMode
        attrTransfer _ v = do
            return v
        attrConstruct = constructIconViewSelectionMode
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.selectionMode"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#g:attr:selectionMode"
            })
    #endif

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

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

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

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

    #if defined(ENABLE_OVERLOADING)
    data IconViewSpacingPropertyInfo
    instance AttrInfo IconViewSpacingPropertyInfo where
        type AttrAllowedOps IconViewSpacingPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
        type AttrBaseTypeConstraint IconViewSpacingPropertyInfo = IsIconView
        type AttrSetTypeConstraint IconViewSpacingPropertyInfo = (~) Int32
        type AttrTransferTypeConstraint IconViewSpacingPropertyInfo = (~) Int32
        type AttrTransferType IconViewSpacingPropertyInfo = Int32
        type AttrGetType IconViewSpacingPropertyInfo = Int32
        type AttrLabel IconViewSpacingPropertyInfo = "spacing"
        type AttrOrigin IconViewSpacingPropertyInfo = IconView
        attrGet = getIconViewSpacing
        attrSet = setIconViewSpacing
        attrPut = setIconViewSpacing
        attrTransfer _ v = do
            return v
        attrConstruct = constructIconViewSpacing
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.spacing"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#g:attr:spacing"
            })
    #endif

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

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

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

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

    #if defined(ENABLE_OVERLOADING)
    data IconViewTextColumnPropertyInfo
    instance AttrInfo IconViewTextColumnPropertyInfo where
        type AttrAllowedOps IconViewTextColumnPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
        type AttrBaseTypeConstraint IconViewTextColumnPropertyInfo = IsIconView
        type AttrSetTypeConstraint IconViewTextColumnPropertyInfo = (~) Int32
        type AttrTransferTypeConstraint IconViewTextColumnPropertyInfo = (~) Int32
        type AttrTransferType IconViewTextColumnPropertyInfo = Int32
        type AttrGetType IconViewTextColumnPropertyInfo = Int32
        type AttrLabel IconViewTextColumnPropertyInfo = "text-column"
        type AttrOrigin IconViewTextColumnPropertyInfo = IconView
        attrGet = getIconViewTextColumn
        attrSet = setIconViewTextColumn
        attrPut = setIconViewTextColumn
        attrTransfer _ v = do
            return v
        attrConstruct = constructIconViewTextColumn
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.textColumn"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#g:attr:textColumn"
            })
    #endif

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

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

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

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

    #if defined(ENABLE_OVERLOADING)
    data IconViewTooltipColumnPropertyInfo
    instance AttrInfo IconViewTooltipColumnPropertyInfo where
        type AttrAllowedOps IconViewTooltipColumnPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
        type AttrBaseTypeConstraint IconViewTooltipColumnPropertyInfo = IsIconView
        type AttrSetTypeConstraint IconViewTooltipColumnPropertyInfo = (~) Int32
        type AttrTransferTypeConstraint IconViewTooltipColumnPropertyInfo = (~) Int32
        type AttrTransferType IconViewTooltipColumnPropertyInfo = Int32
        type AttrGetType IconViewTooltipColumnPropertyInfo = Int32
        type AttrLabel IconViewTooltipColumnPropertyInfo = "tooltip-column"
        type AttrOrigin IconViewTooltipColumnPropertyInfo = IconView
        attrGet = getIconViewTooltipColumn
        attrSet = setIconViewTooltipColumn
        attrPut = setIconViewTooltipColumn
        attrTransfer _ v = do
            return v
        attrConstruct = constructIconViewTooltipColumn
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.tooltipColumn"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#g:attr:tooltipColumn"
            })
    #endif

    #if defined(ENABLE_OVERLOADING)
    instance O.HasAttributeList IconView
    type instance O.AttributeList IconView = IconViewAttributeList
    type IconViewAttributeList = ('[ '("accessibleRole", Gtk.Accessible.AccessibleAccessibleRolePropertyInfo), '("activateOnSingleClick", IconViewActivateOnSingleClickPropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("canTarget", Gtk.Widget.WidgetCanTargetPropertyInfo), '("cellArea", IconViewCellAreaPropertyInfo), '("columnSpacing", IconViewColumnSpacingPropertyInfo), '("columns", IconViewColumnsPropertyInfo), '("cssClasses", Gtk.Widget.WidgetCssClassesPropertyInfo), '("cssName", Gtk.Widget.WidgetCssNamePropertyInfo), '("cursor", Gtk.Widget.WidgetCursorPropertyInfo), '("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), '("itemOrientation", IconViewItemOrientationPropertyInfo), '("itemPadding", IconViewItemPaddingPropertyInfo), '("itemWidth", IconViewItemWidthPropertyInfo), '("layoutManager", Gtk.Widget.WidgetLayoutManagerPropertyInfo), '("limitEvents", Gtk.Widget.WidgetLimitEventsPropertyInfo), '("margin", IconViewMarginPropertyInfo), '("marginBottom", Gtk.Widget.WidgetMarginBottomPropertyInfo), '("marginEnd", Gtk.Widget.WidgetMarginEndPropertyInfo), '("marginStart", Gtk.Widget.WidgetMarginStartPropertyInfo), '("marginTop", Gtk.Widget.WidgetMarginTopPropertyInfo), '("markupColumn", IconViewMarkupColumnPropertyInfo), '("model", IconViewModelPropertyInfo), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("overflow", Gtk.Widget.WidgetOverflowPropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("pixbufColumn", IconViewPixbufColumnPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("reorderable", IconViewReorderablePropertyInfo), '("root", Gtk.Widget.WidgetRootPropertyInfo), '("rowSpacing", IconViewRowSpacingPropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("selectionMode", IconViewSelectionModePropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("spacing", IconViewSpacingPropertyInfo), '("textColumn", IconViewTextColumnPropertyInfo), '("tooltipColumn", IconViewTooltipColumnPropertyInfo), '("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, DK.Type)])
    #endif

    #if defined(ENABLE_OVERLOADING)
    iconViewActivateOnSingleClick :: AttrLabelProxy "activateOnSingleClick"
    iconViewActivateOnSingleClick = AttrLabelProxy

    iconViewCellArea :: AttrLabelProxy "cellArea"
    iconViewCellArea = AttrLabelProxy

    iconViewColumnSpacing :: AttrLabelProxy "columnSpacing"
    iconViewColumnSpacing = AttrLabelProxy

    iconViewColumns :: AttrLabelProxy "columns"
    iconViewColumns = AttrLabelProxy

    iconViewItemOrientation :: AttrLabelProxy "itemOrientation"
    iconViewItemOrientation = AttrLabelProxy

    iconViewItemPadding :: AttrLabelProxy "itemPadding"
    iconViewItemPadding = AttrLabelProxy

    iconViewItemWidth :: AttrLabelProxy "itemWidth"
    iconViewItemWidth = AttrLabelProxy

    iconViewMargin :: AttrLabelProxy "margin"
    iconViewMargin = AttrLabelProxy

    iconViewMarkupColumn :: AttrLabelProxy "markupColumn"
    iconViewMarkupColumn = AttrLabelProxy

    iconViewModel :: AttrLabelProxy "model"
    iconViewModel = AttrLabelProxy

    iconViewPixbufColumn :: AttrLabelProxy "pixbufColumn"
    iconViewPixbufColumn = AttrLabelProxy

    iconViewReorderable :: AttrLabelProxy "reorderable"
    iconViewReorderable = AttrLabelProxy

    iconViewRowSpacing :: AttrLabelProxy "rowSpacing"
    iconViewRowSpacing = AttrLabelProxy

    iconViewSelectionMode :: AttrLabelProxy "selectionMode"
    iconViewSelectionMode = AttrLabelProxy

    iconViewSpacing :: AttrLabelProxy "spacing"
    iconViewSpacing = AttrLabelProxy

    iconViewTextColumn :: AttrLabelProxy "textColumn"
    iconViewTextColumn = AttrLabelProxy

    iconViewTooltipColumn :: AttrLabelProxy "tooltipColumn"
    iconViewTooltipColumn = AttrLabelProxy

    #endif

    #if defined(ENABLE_OVERLOADING)
    type instance O.SignalList IconView = IconViewSignalList
    type IconViewSignalList = ('[ '("activateCursorItem", IconViewActivateCursorItemSignalInfo), '("destroy", Gtk.Widget.WidgetDestroySignalInfo), '("directionChanged", Gtk.Widget.WidgetDirectionChangedSignalInfo), '("hide", Gtk.Widget.WidgetHideSignalInfo), '("itemActivated", IconViewItemActivatedSignalInfo), '("keynavFailed", Gtk.Widget.WidgetKeynavFailedSignalInfo), '("map", Gtk.Widget.WidgetMapSignalInfo), '("mnemonicActivate", Gtk.Widget.WidgetMnemonicActivateSignalInfo), '("moveCursor", IconViewMoveCursorSignalInfo), '("moveFocus", Gtk.Widget.WidgetMoveFocusSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("queryTooltip", Gtk.Widget.WidgetQueryTooltipSignalInfo), '("realize", Gtk.Widget.WidgetRealizeSignalInfo), '("selectAll", IconViewSelectAllSignalInfo), '("selectCursorItem", IconViewSelectCursorItemSignalInfo), '("selectionChanged", IconViewSelectionChangedSignalInfo), '("show", Gtk.Widget.WidgetShowSignalInfo), '("stateFlagsChanged", Gtk.Widget.WidgetStateFlagsChangedSignalInfo), '("toggleCursorItem", IconViewToggleCursorItemSignalInfo), '("unmap", Gtk.Widget.WidgetUnmapSignalInfo), '("unrealize", Gtk.Widget.WidgetUnrealizeSignalInfo), '("unselectAll", IconViewUnselectAllSignalInfo)] :: [(Symbol, DK.Type)])

    #endif

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

    foreign import ccall "gtk_icon_view_new" gtk_icon_view_new ::
        IO (Ptr IconView)

    {-# DEPRECATED iconViewNew ["(Since version 4.10)","Use t'GI.Gtk.Objects.GridView.GridView' instead"] #-}
    -- | Creates a new @GtkIconView@ widget
    iconViewNew ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        m IconView
        -- ^ __Returns:__ A newly created @GtkIconView@ widget
    iconViewNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m IconView
    iconViewNew  = IO IconView -> m IconView
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO IconView -> m IconView) -> IO IconView -> m IconView
    forall a b. (a -> b) -> a -> b
    $ do
        result <- IO (Ptr IconView)
    gtk_icon_view_new
        checkUnexpectedReturnNULL "iconViewNew" result
        result' <- (newObject IconView) result
        return result'

    #if defined(ENABLE_OVERLOADING)
    #endif

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

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

    {-# DEPRECATED iconViewNewWithArea ["(Since version 4.10)","Use t'GI.Gtk.Objects.GridView.GridView' instead"] #-}
    -- | Creates a new @GtkIconView@ widget using the
    -- specified /@area@/ to layout cells inside the icons.
    iconViewNewWithArea ::
        (B.CallStack.HasCallStack, MonadIO m, Gtk.CellArea.IsCellArea a) =>
        a
        -- ^ /@area@/: the @GtkCellArea@ to use to layout cells
        -> m IconView
        -- ^ __Returns:__ A newly created @GtkIconView@ widget
    iconViewNewWithArea :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsCellArea a) =>
    a -> m IconView
    iconViewNewWithArea a
    area = IO IconView -> m IconView
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO IconView -> m IconView) -> IO IconView -> m IconView
    forall a b. (a -> b) -> a -> b
    $ do
        area' <- a -> IO (Ptr CellArea)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    area
        result <- gtk_icon_view_new_with_area area'
        checkUnexpectedReturnNULL "iconViewNewWithArea" result
        result' <- (newObject IconView) result
        touchManagedPtr area
        return result'

    #if defined(ENABLE_OVERLOADING)
    #endif

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

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

    {-# DEPRECATED iconViewNewWithModel ["(Since version 4.10)","Use t'GI.Gtk.Objects.GridView.GridView' instead"] #-}
    -- | Creates a new @GtkIconView@ widget with the model /@model@/.
    iconViewNewWithModel ::
        (B.CallStack.HasCallStack, MonadIO m, Gtk.TreeModel.IsTreeModel a) =>
        a
        -- ^ /@model@/: The model.
        -> m IconView
        -- ^ __Returns:__ A newly created @GtkIconView@ widget.
    iconViewNewWithModel :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsTreeModel a) =>
    a -> m IconView
    iconViewNewWithModel a
    model = IO IconView -> m IconView
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO IconView -> m IconView) -> IO IconView -> m IconView
    forall a b. (a -> b) -> a -> b
    $ do
        model' <- a -> IO (Ptr TreeModel)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    model
        result <- gtk_icon_view_new_with_model model'
        checkUnexpectedReturnNULL "iconViewNewWithModel" result
        result' <- (newObject IconView) result
        touchManagedPtr model
        return result'

    #if defined(ENABLE_OVERLOADING)
    #endif

    -- method IconView::create_drag_icon
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "icon_view"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "IconView" }
    --           , argCType = Just "GtkIconView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkIconView`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "path"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreePath" }
    --           , argCType = Just "GtkTreePath*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkTreePath` in @icon_view"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Gdk" , name = "Paintable" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_icon_view_create_drag_icon" gtk_icon_view_create_drag_icon ::
        Ptr IconView ->                         -- icon_view : TInterface (Name {namespace = "Gtk", name = "IconView"})
        Ptr Gtk.TreePath.TreePath ->            -- path : TInterface (Name {namespace = "Gtk", name = "TreePath"})
        IO (Ptr Gdk.Paintable.Paintable)

    {-# DEPRECATED iconViewCreateDragIcon ["(Since version 4.10)","Use t'GI.Gtk.Objects.GridView.GridView' instead"] #-}
    -- | Creates a @GdkPaintable@ representation of the item at /@path@/.
    -- This image is used for a drag icon.
    iconViewCreateDragIcon ::
        (B.CallStack.HasCallStack, MonadIO m, IsIconView a) =>
        a
        -- ^ /@iconView@/: a @GtkIconView@
        -> Gtk.TreePath.TreePath
        -- ^ /@path@/: a @GtkTreePath@ in /@iconView@/
        -> m (Maybe Gdk.Paintable.Paintable)
        -- ^ __Returns:__ a newly-allocated @GdkPaintable@ of the drag icon.
    iconViewCreateDragIcon :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsIconView a) =>
    a -> TreePath -> m (Maybe Paintable)
    iconViewCreateDragIcon a
    iconView TreePath
    path = IO (Maybe Paintable) -> m (Maybe Paintable)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe Paintable) -> m (Maybe Paintable))
    -> IO (Maybe Paintable) -> m (Maybe Paintable)
    forall a b. (a -> b) -> a -> b
    $ do
        iconView' <- a -> IO (Ptr IconView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    iconView
        path' <- unsafeManagedPtrGetPtr path
        result <- gtk_icon_view_create_drag_icon iconView' path'
        maybeResult <- convertIfNonNull result $ \Ptr Paintable
    result' -> do
            result'' <- ((ManagedPtr Paintable -> Paintable)
    -> Ptr Paintable -> IO Paintable
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    wrapObject ManagedPtr Paintable -> Paintable
    Gdk.Paintable.Paintable) Ptr Paintable
    result'
            return result''
        touchManagedPtr iconView
        touchManagedPtr path
        return maybeResult

    #if defined(ENABLE_OVERLOADING)
    data IconViewCreateDragIconMethodInfo
    instance (signature ~ (Gtk.TreePath.TreePath -> m (Maybe Gdk.Paintable.Paintable)), MonadIO m, IsIconView a) => O.OverloadedMethod IconViewCreateDragIconMethodInfo a signature where
        overloadedMethod = iconViewCreateDragIcon

    instance O.OverloadedMethodInfo IconViewCreateDragIconMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.iconViewCreateDragIcon",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#v:iconViewCreateDragIcon"
            })

    #endif

    -- method IconView::enable_model_drag_dest
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "icon_view"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "IconView" }
    --           , argCType = Just "GtkIconView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkIconView`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "formats"
    --           , argType =
    --               TInterface Name { namespace = "Gdk" , name = "ContentFormats" }
    --           , argCType = Just "GdkContentFormats*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the formats that the drag will support"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "actions"
    --           , argType =
    --               TInterface Name { namespace = "Gdk" , name = "DragAction" }
    --           , argCType = Just "GdkDragAction"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "the bitmask of possible actions for a drag to this\n   widget"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_icon_view_enable_model_drag_dest" gtk_icon_view_enable_model_drag_dest ::
        Ptr IconView ->                         -- icon_view : TInterface (Name {namespace = "Gtk", name = "IconView"})
        Ptr Gdk.ContentFormats.ContentFormats -> -- formats : TInterface (Name {namespace = "Gdk", name = "ContentFormats"})
        CUInt ->                                -- actions : TInterface (Name {namespace = "Gdk", name = "DragAction"})
        IO ()

    {-# DEPRECATED iconViewEnableModelDragDest ["(Since version 4.10)","Use t'GI.Gtk.Objects.GridView.GridView' instead"] #-}
    -- | Turns /@iconView@/ into a drop destination for automatic DND. Calling this
    -- method sets @GtkIconView@:reorderable to 'P.False'.
    iconViewEnableModelDragDest ::
        (B.CallStack.HasCallStack, MonadIO m, IsIconView a) =>
        a
        -- ^ /@iconView@/: a @GtkIconView@
        -> Gdk.ContentFormats.ContentFormats
        -- ^ /@formats@/: the formats that the drag will support
        -> [Gdk.Flags.DragAction]
        -- ^ /@actions@/: the bitmask of possible actions for a drag to this
        --    widget
        -> m ()
    iconViewEnableModelDragDest :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsIconView a) =>
    a -> ContentFormats -> [DragAction] -> m ()
    iconViewEnableModelDragDest a
    iconView ContentFormats
    formats [DragAction]
    actions = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        iconView' <- a -> IO (Ptr IconView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    iconView
        formats' <- unsafeManagedPtrGetPtr formats
        let actions' = [DragAction] -> CUInt
    forall b a. (Num b, IsGFlag a) => [a] -> b
    gflagsToWord [DragAction]
    actions
        gtk_icon_view_enable_model_drag_dest iconView' formats' actions'
        touchManagedPtr iconView
        touchManagedPtr formats
        return ()

    #if defined(ENABLE_OVERLOADING)
    data IconViewEnableModelDragDestMethodInfo
    instance (signature ~ (Gdk.ContentFormats.ContentFormats -> [Gdk.Flags.DragAction] -> m ()), MonadIO m, IsIconView a) => O.OverloadedMethod IconViewEnableModelDragDestMethodInfo a signature where
        overloadedMethod = iconViewEnableModelDragDest

    instance O.OverloadedMethodInfo IconViewEnableModelDragDestMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.iconViewEnableModelDragDest",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#v:iconViewEnableModelDragDest"
            })

    #endif

    -- method IconView::enable_model_drag_source
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "icon_view"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "IconView" }
    --           , argCType = Just "GtkIconView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkIconView`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "start_button_mask"
    --           , argType =
    --               TInterface Name { namespace = "Gdk" , name = "ModifierType" }
    --           , argCType = Just "GdkModifierType"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "Mask of allowed buttons to start drag"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "formats"
    --           , argType =
    --               TInterface Name { namespace = "Gdk" , name = "ContentFormats" }
    --           , argCType = Just "GdkContentFormats*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the formats that the drag will support"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "actions"
    --           , argType =
    --               TInterface Name { namespace = "Gdk" , name = "DragAction" }
    --           , argCType = Just "GdkDragAction"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "the bitmask of possible actions for a drag from this\n   widget"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_icon_view_enable_model_drag_source" gtk_icon_view_enable_model_drag_source ::
        Ptr IconView ->                         -- icon_view : TInterface (Name {namespace = "Gtk", name = "IconView"})
        CUInt ->                                -- start_button_mask : TInterface (Name {namespace = "Gdk", name = "ModifierType"})
        Ptr Gdk.ContentFormats.ContentFormats -> -- formats : TInterface (Name {namespace = "Gdk", name = "ContentFormats"})
        CUInt ->                                -- actions : TInterface (Name {namespace = "Gdk", name = "DragAction"})
        IO ()

    {-# DEPRECATED iconViewEnableModelDragSource ["(Since version 4.10)","Use t'GI.Gtk.Objects.GridView.GridView' instead"] #-}
    -- | Turns /@iconView@/ into a drag source for automatic DND. Calling this
    -- method sets @GtkIconView@:reorderable to 'P.False'.
    iconViewEnableModelDragSource ::
        (B.CallStack.HasCallStack, MonadIO m, IsIconView a) =>
        a
        -- ^ /@iconView@/: a @GtkIconView@
        -> [Gdk.Flags.ModifierType]
        -- ^ /@startButtonMask@/: Mask of allowed buttons to start drag
        -> Gdk.ContentFormats.ContentFormats
        -- ^ /@formats@/: the formats that the drag will support
        -> [Gdk.Flags.DragAction]
        -- ^ /@actions@/: the bitmask of possible actions for a drag from this
        --    widget
        -> m ()
    iconViewEnableModelDragSource :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsIconView a) =>
    a -> [ModifierType] -> ContentFormats -> [DragAction] -> m ()
    iconViewEnableModelDragSource a
    iconView [ModifierType]
    startButtonMask ContentFormats
    formats [DragAction]
    actions = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        iconView' <- a -> IO (Ptr IconView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    iconView
        let startButtonMask' = [ModifierType] -> CUInt
    forall b a. (Num b, IsGFlag a) => [a] -> b
    gflagsToWord [ModifierType]
    startButtonMask
        formats' <- unsafeManagedPtrGetPtr formats
        let actions' = [DragAction] -> CUInt
    forall b a. (Num b, IsGFlag a) => [a] -> b
    gflagsToWord [DragAction]
    actions
        gtk_icon_view_enable_model_drag_source iconView' startButtonMask' formats' actions'
        touchManagedPtr iconView
        touchManagedPtr formats
        return ()

    #if defined(ENABLE_OVERLOADING)
    data IconViewEnableModelDragSourceMethodInfo
    instance (signature ~ ([Gdk.Flags.ModifierType] -> Gdk.ContentFormats.ContentFormats -> [Gdk.Flags.DragAction] -> m ()), MonadIO m, IsIconView a) => O.OverloadedMethod IconViewEnableModelDragSourceMethodInfo a signature where
        overloadedMethod = iconViewEnableModelDragSource

    instance O.OverloadedMethodInfo IconViewEnableModelDragSourceMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.iconViewEnableModelDragSource",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#v:iconViewEnableModelDragSource"
            })

    #endif

    -- method IconView::get_activate_on_single_click
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "icon_view"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "IconView" }
    --           , argCType = Just "GtkIconView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkIconView`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TBoolean)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_icon_view_get_activate_on_single_click" gtk_icon_view_get_activate_on_single_click ::
        Ptr IconView ->                         -- icon_view : TInterface (Name {namespace = "Gtk", name = "IconView"})
        IO CInt

    {-# DEPRECATED iconViewGetActivateOnSingleClick ["(Since version 4.10)","Use t'GI.Gtk.Objects.GridView.GridView' instead"] #-}
    -- | Gets the setting set by 'GI.Gtk.Objects.IconView.iconViewSetActivateOnSingleClick'.
    iconViewGetActivateOnSingleClick ::
        (B.CallStack.HasCallStack, MonadIO m, IsIconView a) =>
        a
        -- ^ /@iconView@/: a @GtkIconView@
        -> m Bool
        -- ^ __Returns:__ 'P.True' if item-activated will be emitted on a single click
    iconViewGetActivateOnSingleClick :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsIconView a) =>
    a -> m Bool
    iconViewGetActivateOnSingleClick a
    iconView = IconViewActivateCursorItemCallback -> m Bool
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IconViewActivateCursorItemCallback -> m Bool)
    -> IconViewActivateCursorItemCallback -> m Bool
    forall a b. (a -> b) -> a -> b
    $ do
        iconView' <- a -> IO (Ptr IconView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    iconView
        result <- gtk_icon_view_get_activate_on_single_click iconView'
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        touchManagedPtr iconView
        return result'

    #if defined(ENABLE_OVERLOADING)
    data IconViewGetActivateOnSingleClickMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsIconView a) => O.OverloadedMethod IconViewGetActivateOnSingleClickMethodInfo a signature where
        overloadedMethod = iconViewGetActivateOnSingleClick

    instance O.OverloadedMethodInfo IconViewGetActivateOnSingleClickMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.iconViewGetActivateOnSingleClick",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#v:iconViewGetActivateOnSingleClick"
            })

    #endif

    -- method IconView::get_cell_rect
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "icon_view"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "IconView" }
    --           , argCType = Just "GtkIconView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkIconView`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "path"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreePath" }
    --           , argCType = Just "GtkTreePath*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkTreePath`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "cell"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "CellRenderer" }
    --           , argCType = Just "GtkCellRenderer*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkCellRenderer`"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "rect"
    --           , argType =
    --               TInterface Name { namespace = "Gdk" , name = "Rectangle" }
    --           , argCType = Just "GdkRectangle*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "rectangle to fill with cell rect"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = True
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TBoolean)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_icon_view_get_cell_rect" gtk_icon_view_get_cell_rect ::
        Ptr IconView ->                         -- icon_view : TInterface (Name {namespace = "Gtk", name = "IconView"})
        Ptr Gtk.TreePath.TreePath ->            -- path : TInterface (Name {namespace = "Gtk", name = "TreePath"})
        Ptr Gtk.CellRenderer.CellRenderer ->    -- cell : TInterface (Name {namespace = "Gtk", name = "CellRenderer"})
        Ptr Gdk.Rectangle.Rectangle ->          -- rect : TInterface (Name {namespace = "Gdk", name = "Rectangle"})
        IO CInt

    {-# DEPRECATED iconViewGetCellRect ["(Since version 4.10)","Use t'GI.Gtk.Objects.GridView.GridView' instead"] #-}
    -- | Fills the bounding rectangle in widget coordinates for the cell specified by
    -- /@path@/ and /@cell@/. If /@cell@/ is 'P.Nothing' the main cell area is used.
    --
    -- This function is only valid if /@iconView@/ is realized.
    iconViewGetCellRect ::
        (B.CallStack.HasCallStack, MonadIO m, IsIconView a, Gtk.CellRenderer.IsCellRenderer b) =>
        a
        -- ^ /@iconView@/: a @GtkIconView@
        -> Gtk.TreePath.TreePath
        -- ^ /@path@/: a @GtkTreePath@
        -> Maybe (b)
        -- ^ /@cell@/: a @GtkCellRenderer@
        -> m ((Bool, Gdk.Rectangle.Rectangle))
        -- ^ __Returns:__ 'P.False' if there is no such item, 'P.True' otherwise
    iconViewGetCellRect :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsIconView a, IsCellRenderer b) =>
    a -> TreePath -> Maybe b -> m (Bool, Rectangle)
    iconViewGetCellRect a
    iconView TreePath
    path Maybe b
    cell = IO (Bool, Rectangle) -> m (Bool, Rectangle)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Bool, Rectangle) -> m (Bool, Rectangle))
    -> IO (Bool, Rectangle) -> m (Bool, Rectangle)
    forall a b. (a -> b) -> a -> b
    $ do
        iconView' <- a -> IO (Ptr IconView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    iconView
        path' <- unsafeManagedPtrGetPtr path
        maybeCell <- case cell of
            Maybe b
    Nothing -> Ptr CellRenderer -> IO (Ptr CellRenderer)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr CellRenderer
    forall a. Ptr a
    FP.nullPtr
            Just b
    jCell -> do
                jCell' <- b -> IO (Ptr CellRenderer)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr b
    jCell
                return jCell'
        rect <- SP.callocBoxedBytes 16 :: IO (Ptr Gdk.Rectangle.Rectangle)
        result <- gtk_icon_view_get_cell_rect iconView' path' maybeCell rect
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        rect' <- (wrapBoxed Gdk.Rectangle.Rectangle) rect
        touchManagedPtr iconView
        touchManagedPtr path
        whenJust cell touchManagedPtr
        return (result', rect')

    #if defined(ENABLE_OVERLOADING)
    data IconViewGetCellRectMethodInfo
    instance (signature ~ (Gtk.TreePath.TreePath -> Maybe (b) -> m ((Bool, Gdk.Rectangle.Rectangle))), MonadIO m, IsIconView a, Gtk.CellRenderer.IsCellRenderer b) => O.OverloadedMethod IconViewGetCellRectMethodInfo a signature where
        overloadedMethod = iconViewGetCellRect

    instance O.OverloadedMethodInfo IconViewGetCellRectMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.iconViewGetCellRect",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#v:iconViewGetCellRect"
            })

    #endif

    -- method IconView::get_column_spacing
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "icon_view"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "IconView" }
    --           , argCType = Just "GtkIconView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkIconView`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TInt)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_icon_view_get_column_spacing" gtk_icon_view_get_column_spacing ::
        Ptr IconView ->                         -- icon_view : TInterface (Name {namespace = "Gtk", name = "IconView"})
        IO Int32

    {-# DEPRECATED iconViewGetColumnSpacing ["(Since version 4.10)","Use t'GI.Gtk.Objects.GridView.GridView' instead"] #-}
    -- | Returns the value of the [columnSpacing](#g:signal:columnSpacing) property.
    iconViewGetColumnSpacing ::
        (B.CallStack.HasCallStack, MonadIO m, IsIconView a) =>
        a
        -- ^ /@iconView@/: a @GtkIconView@
        -> m Int32
        -- ^ __Returns:__ the space between columns
    iconViewGetColumnSpacing :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsIconView a) =>
    a -> m Int32
    iconViewGetColumnSpacing a
    iconView = IO Int32 -> m Int32
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
    forall a b. (a -> b) -> a -> b
    $ do
        iconView' <- a -> IO (Ptr IconView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    iconView
        result <- gtk_icon_view_get_column_spacing iconView'
        touchManagedPtr iconView
        return result

    #if defined(ENABLE_OVERLOADING)
    data IconViewGetColumnSpacingMethodInfo
    instance (signature ~ (m Int32), MonadIO m, IsIconView a) => O.OverloadedMethod IconViewGetColumnSpacingMethodInfo a signature where
        overloadedMethod = iconViewGetColumnSpacing

    instance O.OverloadedMethodInfo IconViewGetColumnSpacingMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.iconViewGetColumnSpacing",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#v:iconViewGetColumnSpacing"
            })

    #endif

    -- method IconView::get_columns
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "icon_view"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "IconView" }
    --           , argCType = Just "GtkIconView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkIconView`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TInt)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_icon_view_get_columns" gtk_icon_view_get_columns ::
        Ptr IconView ->                         -- icon_view : TInterface (Name {namespace = "Gtk", name = "IconView"})
        IO Int32

    {-# DEPRECATED iconViewGetColumns ["(Since version 4.10)","Use t'GI.Gtk.Objects.GridView.GridView' instead"] #-}
    -- | Returns the value of the [columns](#g:signal:columns) property.
    iconViewGetColumns ::
        (B.CallStack.HasCallStack, MonadIO m, IsIconView a) =>
        a
        -- ^ /@iconView@/: a @GtkIconView@
        -> m Int32
        -- ^ __Returns:__ the number of columns, or -1
    iconViewGetColumns :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsIconView a) =>
    a -> m Int32
    iconViewGetColumns a
    iconView = IO Int32 -> m Int32
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
    forall a b. (a -> b) -> a -> b
    $ do
        iconView' <- a -> IO (Ptr IconView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    iconView
        result <- gtk_icon_view_get_columns iconView'
        touchManagedPtr iconView
        return result

    #if defined(ENABLE_OVERLOADING)
    data IconViewGetColumnsMethodInfo
    instance (signature ~ (m Int32), MonadIO m, IsIconView a) => O.OverloadedMethod IconViewGetColumnsMethodInfo a signature where
        overloadedMethod = iconViewGetColumns

    instance O.OverloadedMethodInfo IconViewGetColumnsMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.iconViewGetColumns",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#v:iconViewGetColumns"
            })

    #endif

    -- method IconView::get_cursor
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "icon_view"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "IconView" }
    --           , argCType = Just "GtkIconView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `GtkIconView`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "path"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreePath" }
    --           , argCType = Just "GtkTreePath**"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "Return location for the current\n  cursor path"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       , Arg
    --           { argCName = "cell"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "CellRenderer" }
    --           , argCType = Just "GtkCellRenderer**"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "Return location the current\n  focus cell"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TBoolean)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_icon_view_get_cursor" gtk_icon_view_get_cursor ::
        Ptr IconView ->                         -- icon_view : TInterface (Name {namespace = "Gtk", name = "IconView"})
        Ptr (Ptr Gtk.TreePath.TreePath) ->      -- path : TInterface (Name {namespace = "Gtk", name = "TreePath"})
        Ptr (Ptr Gtk.CellRenderer.CellRenderer) -> -- cell : TInterface (Name {namespace = "Gtk", name = "CellRenderer"})
        IO CInt

    {-# DEPRECATED iconViewGetCursor ["(Since version 4.10)","Use t'GI.Gtk.Objects.GridView.GridView' instead"] #-}
    -- | Fills in /@path@/ and /@cell@/ with the current cursor path and cell.
    -- If the cursor isn’t currently set, then */@path@/ will be 'P.Nothing'.
    -- If no cell currently has focus, then */@cell@/ will be 'P.Nothing'.
    --
    -- The returned @GtkTreePath@ must be freed with 'GI.Gtk.Structs.TreePath.treePathFree'.
    iconViewGetCursor ::
        (B.CallStack.HasCallStack, MonadIO m, IsIconView a) =>
        a
        -- ^ /@iconView@/: A @GtkIconView@
        -> m ((Bool, Gtk.TreePath.TreePath, Gtk.CellRenderer.CellRenderer))
        -- ^ __Returns:__ 'P.True' if the cursor is set.
    iconViewGetCursor :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsIconView a) =>
    a -> m (Bool, TreePath, CellRenderer)
    iconViewGetCursor a
    iconView = IO (Bool, TreePath, CellRenderer)
    -> m (Bool, TreePath, CellRenderer)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Bool, TreePath, CellRenderer)
     -> m (Bool, TreePath, CellRenderer))
    -> IO (Bool, TreePath, CellRenderer)
    -> m (Bool, TreePath, CellRenderer)
    forall a b. (a -> b) -> a -> b
    $ do
        iconView' <- a -> IO (Ptr IconView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    iconView
        path <- callocMem :: IO (Ptr (Ptr Gtk.TreePath.TreePath))
        cell <- callocMem :: IO (Ptr (Ptr Gtk.CellRenderer.CellRenderer))
        result <- gtk_icon_view_get_cursor iconView' path cell
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        path' <- peek path
        path'' <- (wrapBoxed Gtk.TreePath.TreePath) path'
        cell' <- peek cell
        cell'' <- (newObject Gtk.CellRenderer.CellRenderer) cell'
        touchManagedPtr iconView
        freeMem path
        freeMem cell
        return (result', path'', cell'')

    #if defined(ENABLE_OVERLOADING)
    data IconViewGetCursorMethodInfo
    instance (signature ~ (m ((Bool, Gtk.TreePath.TreePath, Gtk.CellRenderer.CellRenderer))), MonadIO m, IsIconView a) => O.OverloadedMethod IconViewGetCursorMethodInfo a signature where
        overloadedMethod = iconViewGetCursor

    instance O.OverloadedMethodInfo IconViewGetCursorMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.iconViewGetCursor",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#v:iconViewGetCursor"
            })

    #endif

    -- method IconView::get_dest_item_at_pos
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "icon_view"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "IconView" }
    --           , argCType = Just "GtkIconView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkIconView`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "drag_x"
    --           , argType = TBasicType TInt
    --           , argCType = Just "int"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "the position to determine the destination item for"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "drag_y"
    --           , argType = TBasicType TInt
    --           , argCType = Just "int"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "the position to determine the destination item for"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "path"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreePath" }
    --           , argCType = Just "GtkTreePath**"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "Return location for the path of the item"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       , Arg
    --           { argCName = "pos"
    --           , argType =
    --               TInterface
    --                 Name { namespace = "Gtk" , name = "IconViewDropPosition" }
    --           , argCType = Just "GtkIconViewDropPosition*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "Return location for the drop position"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TBoolean)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_icon_view_get_dest_item_at_pos" gtk_icon_view_get_dest_item_at_pos ::
        Ptr IconView ->                         -- icon_view : TInterface (Name {namespace = "Gtk", name = "IconView"})
        Int32 ->                                -- drag_x : TBasicType TInt
        Int32 ->                                -- drag_y : TBasicType TInt
        Ptr (Ptr Gtk.TreePath.TreePath) ->      -- path : TInterface (Name {namespace = "Gtk", name = "TreePath"})
        Ptr CUInt ->                            -- pos : TInterface (Name {namespace = "Gtk", name = "IconViewDropPosition"})
        IO CInt

    {-# DEPRECATED iconViewGetDestItemAtPos ["(Since version 4.10)","Use t'GI.Gtk.Objects.GridView.GridView' instead"] #-}
    -- | Determines the destination item for a given position.
    iconViewGetDestItemAtPos ::
        (B.CallStack.HasCallStack, MonadIO m, IsIconView a) =>
        a
        -- ^ /@iconView@/: a @GtkIconView@
        -> Int32
        -- ^ /@dragX@/: the position to determine the destination item for
        -> Int32
        -- ^ /@dragY@/: the position to determine the destination item for
        -> m ((Bool, Gtk.TreePath.TreePath, Gtk.Enums.IconViewDropPosition))
        -- ^ __Returns:__ whether there is an item at the given position.
    iconViewGetDestItemAtPos :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsIconView a) =>
    a -> Int32 -> Int32 -> m (Bool, TreePath, IconViewDropPosition)
    iconViewGetDestItemAtPos a
    iconView Int32
    dragX Int32
    dragY = IO (Bool, TreePath, IconViewDropPosition)
    -> m (Bool, TreePath, IconViewDropPosition)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Bool, TreePath, IconViewDropPosition)
     -> m (Bool, TreePath, IconViewDropPosition))
    -> IO (Bool, TreePath, IconViewDropPosition)
    -> m (Bool, TreePath, IconViewDropPosition)
    forall a b. (a -> b) -> a -> b
    $ do
        iconView' <- a -> IO (Ptr IconView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    iconView
        path <- callocMem :: IO (Ptr (Ptr Gtk.TreePath.TreePath))
        pos <- allocMem :: IO (Ptr CUInt)
        result <- gtk_icon_view_get_dest_item_at_pos iconView' dragX dragY path pos
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        path' <- peek path
        path'' <- (wrapBoxed Gtk.TreePath.TreePath) path'
        pos' <- peek pos
        let pos'' = (Int -> IconViewDropPosition
    forall a. Enum a => Int -> a
    toEnum (Int -> IconViewDropPosition)
    -> (CUInt -> Int) -> CUInt -> IconViewDropPosition
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . CUInt -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral) CUInt
    pos'
        touchManagedPtr iconView
        freeMem path
        freeMem pos
        return (result', path'', pos'')

    #if defined(ENABLE_OVERLOADING)
    data IconViewGetDestItemAtPosMethodInfo
    instance (signature ~ (Int32 -> Int32 -> m ((Bool, Gtk.TreePath.TreePath, Gtk.Enums.IconViewDropPosition))), MonadIO m, IsIconView a) => O.OverloadedMethod IconViewGetDestItemAtPosMethodInfo a signature where
        overloadedMethod = iconViewGetDestItemAtPos

    instance O.OverloadedMethodInfo IconViewGetDestItemAtPosMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.iconViewGetDestItemAtPos",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#v:iconViewGetDestItemAtPos"
            })

    #endif

    -- method IconView::get_drag_dest_item
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "icon_view"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "IconView" }
    --           , argCType = Just "GtkIconView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkIconView`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "path"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreePath" }
    --           , argCType = Just "GtkTreePath**"
    --           , direction = DirectionOut
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "Return location for the path of\n  the highlighted item"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       , Arg
    --           { argCName = "pos"
    --           , argType =
    --               TInterface
    --                 Name { namespace = "Gtk" , name = "IconViewDropPosition" }
    --           , argCType = Just "GtkIconViewDropPosition*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "Return location for the drop position"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_icon_view_get_drag_dest_item" gtk_icon_view_get_drag_dest_item ::
        Ptr IconView ->                         -- icon_view : TInterface (Name {namespace = "Gtk", name = "IconView"})
        Ptr (Ptr Gtk.TreePath.TreePath) ->      -- path : TInterface (Name {namespace = "Gtk", name = "TreePath"})
        Ptr CUInt ->                            -- pos : TInterface (Name {namespace = "Gtk", name = "IconViewDropPosition"})
        IO ()

    {-# DEPRECATED iconViewGetDragDestItem ["(Since version 4.10)","Use t'GI.Gtk.Objects.GridView.GridView' instead"] #-}
    -- | Gets information about the item that is highlighted for feedback.
    iconViewGetDragDestItem ::
        (B.CallStack.HasCallStack, MonadIO m, IsIconView a) =>
        a
        -- ^ /@iconView@/: a @GtkIconView@
        -> m ((Maybe Gtk.TreePath.TreePath, Gtk.Enums.IconViewDropPosition))
    iconViewGetDragDestItem :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsIconView a) =>
    a -> m (Maybe TreePath, IconViewDropPosition)
    iconViewGetDragDestItem a
    iconView = IO (Maybe TreePath, IconViewDropPosition)
    -> m (Maybe TreePath, IconViewDropPosition)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe TreePath, IconViewDropPosition)
     -> m (Maybe TreePath, IconViewDropPosition))
    -> IO (Maybe TreePath, IconViewDropPosition)
    -> m (Maybe TreePath, IconViewDropPosition)
    forall a b. (a -> b) -> a -> b
    $ do
        iconView' <- a -> IO (Ptr IconView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    iconView
        path <- callocMem :: IO (Ptr (Ptr Gtk.TreePath.TreePath))
        pos <- allocMem :: IO (Ptr CUInt)
        gtk_icon_view_get_drag_dest_item iconView' path pos
        path' <- peek path
        maybePath' <- convertIfNonNull path' $ \Ptr TreePath
    path'' -> do
            path''' <- ((ManagedPtr TreePath -> TreePath) -> Ptr TreePath -> IO TreePath
    forall a.
    (HasCallStack, GBoxed a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    wrapBoxed ManagedPtr TreePath -> TreePath
    Gtk.TreePath.TreePath) Ptr TreePath
    path''
            return path'''
        pos' <- peek pos
        let pos'' = (Int -> IconViewDropPosition
    forall a. Enum a => Int -> a
    toEnum (Int -> IconViewDropPosition)
    -> (CUInt -> Int) -> CUInt -> IconViewDropPosition
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . CUInt -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral) CUInt
    pos'
        touchManagedPtr iconView
        freeMem path
        freeMem pos
        return (maybePath', pos'')

    #if defined(ENABLE_OVERLOADING)
    data IconViewGetDragDestItemMethodInfo
    instance (signature ~ (m ((Maybe Gtk.TreePath.TreePath, Gtk.Enums.IconViewDropPosition))), MonadIO m, IsIconView a) => O.OverloadedMethod IconViewGetDragDestItemMethodInfo a signature where
        overloadedMethod = iconViewGetDragDestItem

    instance O.OverloadedMethodInfo IconViewGetDragDestItemMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.iconViewGetDragDestItem",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#v:iconViewGetDragDestItem"
            })

    #endif

    -- method IconView::get_item_at_pos
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "icon_view"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "IconView" }
    --           , argCType = Just "GtkIconView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `GtkIconView`." , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "x"
    --           , argType = TBasicType TInt
    --           , argCType = Just "int"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "The x position to be identified"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "y"
    --           , argType = TBasicType TInt
    --           , argCType = Just "int"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "The y position to be identified"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "path"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreePath" }
    --           , argCType = Just "GtkTreePath**"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "Return location for the path"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       , Arg
    --           { argCName = "cell"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "CellRenderer" }
    --           , argCType = Just "GtkCellRenderer**"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "Return location for the renderer\n  responsible for the cell at (@x, @y)"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TBoolean)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_icon_view_get_item_at_pos" gtk_icon_view_get_item_at_pos ::
        Ptr IconView ->                         -- icon_view : TInterface (Name {namespace = "Gtk", name = "IconView"})
        Int32 ->                                -- x : TBasicType TInt
        Int32 ->                                -- y : TBasicType TInt
        Ptr (Ptr Gtk.TreePath.TreePath) ->      -- path : TInterface (Name {namespace = "Gtk", name = "TreePath"})
        Ptr (Ptr Gtk.CellRenderer.CellRenderer) -> -- cell : TInterface (Name {namespace = "Gtk", name = "CellRenderer"})
        IO CInt

    {-# DEPRECATED iconViewGetItemAtPos ["(Since version 4.10)","Use t'GI.Gtk.Objects.GridView.GridView' instead"] #-}
    -- | Gets the path and cell for the icon at the given position.
    iconViewGetItemAtPos ::
        (B.CallStack.HasCallStack, MonadIO m, IsIconView a) =>
        a
        -- ^ /@iconView@/: A @GtkIconView@.
        -> Int32
        -- ^ /@x@/: The x position to be identified
        -> Int32
        -- ^ /@y@/: The y position to be identified
        -> m ((Bool, Gtk.TreePath.TreePath, Gtk.CellRenderer.CellRenderer))
        -- ^ __Returns:__ 'P.True' if an item exists at the specified position
    iconViewGetItemAtPos :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsIconView a) =>
    a -> Int32 -> Int32 -> m (Bool, TreePath, CellRenderer)
    iconViewGetItemAtPos a
    iconView Int32
    x Int32
    y = IO (Bool, TreePath, CellRenderer)
    -> m (Bool, TreePath, CellRenderer)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Bool, TreePath, CellRenderer)
     -> m (Bool, TreePath, CellRenderer))
    -> IO (Bool, TreePath, CellRenderer)
    -> m (Bool, TreePath, CellRenderer)
    forall a b. (a -> b) -> a -> b
    $ do
        iconView' <- a -> IO (Ptr IconView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    iconView
        path <- callocMem :: IO (Ptr (Ptr Gtk.TreePath.TreePath))
        cell <- callocMem :: IO (Ptr (Ptr Gtk.CellRenderer.CellRenderer))
        result <- gtk_icon_view_get_item_at_pos iconView' x y path cell
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        path' <- peek path
        path'' <- (wrapBoxed Gtk.TreePath.TreePath) path'
        cell' <- peek cell
        cell'' <- (newObject Gtk.CellRenderer.CellRenderer) cell'
        touchManagedPtr iconView
        freeMem path
        freeMem cell
        return (result', path'', cell'')

    #if defined(ENABLE_OVERLOADING)
    data IconViewGetItemAtPosMethodInfo
    instance (signature ~ (Int32 -> Int32 -> m ((Bool, Gtk.TreePath.TreePath, Gtk.CellRenderer.CellRenderer))), MonadIO m, IsIconView a) => O.OverloadedMethod IconViewGetItemAtPosMethodInfo a signature where
        overloadedMethod = iconViewGetItemAtPos

    instance O.OverloadedMethodInfo IconViewGetItemAtPosMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.iconViewGetItemAtPos",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#v:iconViewGetItemAtPos"
            })

    #endif

    -- method IconView::get_item_column
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "icon_view"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "IconView" }
    --           , argCType = Just "GtkIconView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkIconView`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "path"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreePath" }
    --           , argCType = Just "GtkTreePath*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the `GtkTreePath` of the item"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TInt)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_icon_view_get_item_column" gtk_icon_view_get_item_column ::
        Ptr IconView ->                         -- icon_view : TInterface (Name {namespace = "Gtk", name = "IconView"})
        Ptr Gtk.TreePath.TreePath ->            -- path : TInterface (Name {namespace = "Gtk", name = "TreePath"})
        IO Int32

    {-# DEPRECATED iconViewGetItemColumn ["(Since version 4.10)","Use t'GI.Gtk.Objects.GridView.GridView' instead"] #-}
    -- | Gets the column in which the item /@path@/ is currently
    -- displayed. Column numbers start at 0.
    iconViewGetItemColumn ::
        (B.CallStack.HasCallStack, MonadIO m, IsIconView a) =>
        a
        -- ^ /@iconView@/: a @GtkIconView@
        -> Gtk.TreePath.TreePath
        -- ^ /@path@/: the @GtkTreePath@ of the item
        -> m Int32
        -- ^ __Returns:__ The column in which the item is displayed
    iconViewGetItemColumn :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsIconView a) =>
    a -> TreePath -> m Int32
    iconViewGetItemColumn a
    iconView TreePath
    path = IO Int32 -> m Int32
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
    forall a b. (a -> b) -> a -> b
    $ do
        iconView' <- a -> IO (Ptr IconView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    iconView
        path' <- unsafeManagedPtrGetPtr path
        result <- gtk_icon_view_get_item_column iconView' path'
        touchManagedPtr iconView
        touchManagedPtr path
        return result

    #if defined(ENABLE_OVERLOADING)
    data IconViewGetItemColumnMethodInfo
    instance (signature ~ (Gtk.TreePath.TreePath -> m Int32), MonadIO m, IsIconView a) => O.OverloadedMethod IconViewGetItemColumnMethodInfo a signature where
        overloadedMethod = iconViewGetItemColumn

    instance O.OverloadedMethodInfo IconViewGetItemColumnMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.iconViewGetItemColumn",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#v:iconViewGetItemColumn"
            })

    #endif

    -- method IconView::get_item_orientation
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "icon_view"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "IconView" }
    --           , argCType = Just "GtkIconView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkIconView`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Gtk" , name = "Orientation" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_icon_view_get_item_orientation" gtk_icon_view_get_item_orientation ::
        Ptr IconView ->                         -- icon_view : TInterface (Name {namespace = "Gtk", name = "IconView"})
        IO CUInt

    {-# DEPRECATED iconViewGetItemOrientation ["(Since version 4.10)","Use t'GI.Gtk.Objects.GridView.GridView' instead"] #-}
    -- | Returns the value of the [itemOrientation](#g:signal:itemOrientation) property which determines
    -- whether the labels are drawn beside the icons instead of below.
    iconViewGetItemOrientation ::
        (B.CallStack.HasCallStack, MonadIO m, IsIconView a) =>
        a
        -- ^ /@iconView@/: a @GtkIconView@
        -> m Gtk.Enums.Orientation
        -- ^ __Returns:__ the relative position of texts and icons
    iconViewGetItemOrientation :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsIconView a) =>
    a -> m Orientation
    iconViewGetItemOrientation a
    iconView = IO Orientation -> m Orientation
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Orientation -> m Orientation)
    -> IO Orientation -> m Orientation
    forall a b. (a -> b) -> a -> b
    $ do
        iconView' <- a -> IO (Ptr IconView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    iconView
        result <- gtk_icon_view_get_item_orientation iconView'
        let result' = (Int -> Orientation
    forall a. Enum a => Int -> a
    toEnum (Int -> Orientation) -> (CUInt -> Int) -> CUInt -> Orientation
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . CUInt -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral) CUInt
    result
        touchManagedPtr iconView
        return result'

    #if defined(ENABLE_OVERLOADING)
    data IconViewGetItemOrientationMethodInfo
    instance (signature ~ (m Gtk.Enums.Orientation), MonadIO m, IsIconView a) => O.OverloadedMethod IconViewGetItemOrientationMethodInfo a signature where
        overloadedMethod = iconViewGetItemOrientation

    instance O.OverloadedMethodInfo IconViewGetItemOrientationMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.iconViewGetItemOrientation",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#v:iconViewGetItemOrientation"
            })

    #endif

    -- method IconView::get_item_padding
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "icon_view"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "IconView" }
    --           , argCType = Just "GtkIconView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkIconView`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TInt)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_icon_view_get_item_padding" gtk_icon_view_get_item_padding ::
        Ptr IconView ->                         -- icon_view : TInterface (Name {namespace = "Gtk", name = "IconView"})
        IO Int32

    {-# DEPRECATED iconViewGetItemPadding ["(Since version 4.10)","Use t'GI.Gtk.Objects.GridView.GridView' instead"] #-}
    -- | Returns the value of the [itemPadding](#g:signal:itemPadding) property.
    iconViewGetItemPadding ::
        (B.CallStack.HasCallStack, MonadIO m, IsIconView a) =>
        a
        -- ^ /@iconView@/: a @GtkIconView@
        -> m Int32
        -- ^ __Returns:__ the padding around items
    iconViewGetItemPadding :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsIconView a) =>
    a -> m Int32
    iconViewGetItemPadding a
    iconView = IO Int32 -> m Int32
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
    forall a b. (a -> b) -> a -> b
    $ do
        iconView' <- a -> IO (Ptr IconView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    iconView
        result <- gtk_icon_view_get_item_padding iconView'
        touchManagedPtr iconView
        return result

    #if defined(ENABLE_OVERLOADING)
    data IconViewGetItemPaddingMethodInfo
    instance (signature ~ (m Int32), MonadIO m, IsIconView a) => O.OverloadedMethod IconViewGetItemPaddingMethodInfo a signature where
        overloadedMethod = iconViewGetItemPadding

    instance O.OverloadedMethodInfo IconViewGetItemPaddingMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.iconViewGetItemPadding",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#v:iconViewGetItemPadding"
            })

    #endif

    -- method IconView::get_item_row
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "icon_view"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "IconView" }
    --           , argCType = Just "GtkIconView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkIconView`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "path"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreePath" }
    --           , argCType = Just "GtkTreePath*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the `GtkTreePath` of the item"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TInt)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_icon_view_get_item_row" gtk_icon_view_get_item_row ::
        Ptr IconView ->                         -- icon_view : TInterface (Name {namespace = "Gtk", name = "IconView"})
        Ptr Gtk.TreePath.TreePath ->            -- path : TInterface (Name {namespace = "Gtk", name = "TreePath"})
        IO Int32

    {-# DEPRECATED iconViewGetItemRow ["(Since version 4.10)","Use t'GI.Gtk.Objects.GridView.GridView' instead"] #-}
    -- | Gets the row in which the item /@path@/ is currently
    -- displayed. Row numbers start at 0.
    iconViewGetItemRow ::
        (B.CallStack.HasCallStack, MonadIO m, IsIconView a) =>
        a
        -- ^ /@iconView@/: a @GtkIconView@
        -> Gtk.TreePath.TreePath
        -- ^ /@path@/: the @GtkTreePath@ of the item
        -> m Int32
        -- ^ __Returns:__ The row in which the item is displayed
    iconViewGetItemRow :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsIconView a) =>
    a -> TreePath -> m Int32
    iconViewGetItemRow a
    iconView TreePath
    path = IO Int32 -> m Int32
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
    forall a b. (a -> b) -> a -> b
    $ do
        iconView' <- a -> IO (Ptr IconView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    iconView
        path' <- unsafeManagedPtrGetPtr path
        result <- gtk_icon_view_get_item_row iconView' path'
        touchManagedPtr iconView
        touchManagedPtr path
        return result

    #if defined(ENABLE_OVERLOADING)
    data IconViewGetItemRowMethodInfo
    instance (signature ~ (Gtk.TreePath.TreePath -> m Int32), MonadIO m, IsIconView a) => O.OverloadedMethod IconViewGetItemRowMethodInfo a signature where
        overloadedMethod = iconViewGetItemRow

    instance O.OverloadedMethodInfo IconViewGetItemRowMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.iconViewGetItemRow",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#v:iconViewGetItemRow"
            })

    #endif

    -- method IconView::get_item_width
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "icon_view"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "IconView" }
    --           , argCType = Just "GtkIconView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkIconView`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TInt)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_icon_view_get_item_width" gtk_icon_view_get_item_width ::
        Ptr IconView ->                         -- icon_view : TInterface (Name {namespace = "Gtk", name = "IconView"})
        IO Int32

    {-# DEPRECATED iconViewGetItemWidth ["(Since version 4.10)","Use t'GI.Gtk.Objects.GridView.GridView' instead"] #-}
    -- | Returns the value of the [itemWidth](#g:signal:itemWidth) property.
    iconViewGetItemWidth ::
        (B.CallStack.HasCallStack, MonadIO m, IsIconView a) =>
        a
        -- ^ /@iconView@/: a @GtkIconView@
        -> m Int32
        -- ^ __Returns:__ the width of a single item, or -1
    iconViewGetItemWidth :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsIconView a) =>
    a -> m Int32
    iconViewGetItemWidth a
    iconView = IO Int32 -> m Int32
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
    forall a b. (a -> b) -> a -> b
    $ do
        iconView' <- a -> IO (Ptr IconView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    iconView
        result <- gtk_icon_view_get_item_width iconView'
        touchManagedPtr iconView
        return result

    #if defined(ENABLE_OVERLOADING)
    data IconViewGetItemWidthMethodInfo
    instance (signature ~ (m Int32), MonadIO m, IsIconView a) => O.OverloadedMethod IconViewGetItemWidthMethodInfo a signature where
        overloadedMethod = iconViewGetItemWidth

    instance O.OverloadedMethodInfo IconViewGetItemWidthMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.iconViewGetItemWidth",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#v:iconViewGetItemWidth"
            })

    #endif

    -- method IconView::get_margin
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "icon_view"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "IconView" }
    --           , argCType = Just "GtkIconView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkIconView`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TInt)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_icon_view_get_margin" gtk_icon_view_get_margin ::
        Ptr IconView ->                         -- icon_view : TInterface (Name {namespace = "Gtk", name = "IconView"})
        IO Int32

    {-# DEPRECATED iconViewGetMargin ["(Since version 4.10)","Use t'GI.Gtk.Objects.GridView.GridView' instead"] #-}
    -- | Returns the value of the [margin](#g:signal:margin) property.
    iconViewGetMargin ::
        (B.CallStack.HasCallStack, MonadIO m, IsIconView a) =>
        a
        -- ^ /@iconView@/: a @GtkIconView@
        -> m Int32
        -- ^ __Returns:__ the space at the borders
    iconViewGetMargin :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsIconView a) =>
    a -> m Int32
    iconViewGetMargin a
    iconView = IO Int32 -> m Int32
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
    forall a b. (a -> b) -> a -> b
    $ do
        iconView' <- a -> IO (Ptr IconView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    iconView
        result <- gtk_icon_view_get_margin iconView'
        touchManagedPtr iconView
        return result

    #if defined(ENABLE_OVERLOADING)
    data IconViewGetMarginMethodInfo
    instance (signature ~ (m Int32), MonadIO m, IsIconView a) => O.OverloadedMethod IconViewGetMarginMethodInfo a signature where
        overloadedMethod = iconViewGetMargin

    instance O.OverloadedMethodInfo IconViewGetMarginMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.iconViewGetMargin",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#v:iconViewGetMargin"
            })

    #endif

    -- method IconView::get_markup_column
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "icon_view"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "IconView" }
    --           , argCType = Just "GtkIconView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `GtkIconView`." , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TInt)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_icon_view_get_markup_column" gtk_icon_view_get_markup_column ::
        Ptr IconView ->                         -- icon_view : TInterface (Name {namespace = "Gtk", name = "IconView"})
        IO Int32

    {-# DEPRECATED iconViewGetMarkupColumn ["(Since version 4.10)","Use t'GI.Gtk.Objects.GridView.GridView' instead"] #-}
    -- | Returns the column with markup text for /@iconView@/.
    iconViewGetMarkupColumn ::
        (B.CallStack.HasCallStack, MonadIO m, IsIconView a) =>
        a
        -- ^ /@iconView@/: A @GtkIconView@.
        -> m Int32
        -- ^ __Returns:__ the markup column, or -1 if it’s unset.
    iconViewGetMarkupColumn :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsIconView a) =>
    a -> m Int32
    iconViewGetMarkupColumn a
    iconView = IO Int32 -> m Int32
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
    forall a b. (a -> b) -> a -> b
    $ do
        iconView' <- a -> IO (Ptr IconView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    iconView
        result <- gtk_icon_view_get_markup_column iconView'
        touchManagedPtr iconView
        return result

    #if defined(ENABLE_OVERLOADING)
    data IconViewGetMarkupColumnMethodInfo
    instance (signature ~ (m Int32), MonadIO m, IsIconView a) => O.OverloadedMethod IconViewGetMarkupColumnMethodInfo a signature where
        overloadedMethod = iconViewGetMarkupColumn

    instance O.OverloadedMethodInfo IconViewGetMarkupColumnMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.iconViewGetMarkupColumn",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#v:iconViewGetMarkupColumn"
            })

    #endif

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

    foreign import ccall "gtk_icon_view_get_model" gtk_icon_view_get_model ::
        Ptr IconView ->                         -- icon_view : TInterface (Name {namespace = "Gtk", name = "IconView"})
        IO (Ptr Gtk.TreeModel.TreeModel)

    {-# DEPRECATED iconViewGetModel ["(Since version 4.10)","Use t'GI.Gtk.Objects.GridView.GridView' instead"] #-}
    -- | Returns the model the @GtkIconView@ is based on.  Returns 'P.Nothing' if the
    -- model is unset.
    iconViewGetModel ::
        (B.CallStack.HasCallStack, MonadIO m, IsIconView a) =>
        a
        -- ^ /@iconView@/: a @GtkIconView@
        -> m (Maybe Gtk.TreeModel.TreeModel)
        -- ^ __Returns:__ The currently used @GtkTreeModel@
    iconViewGetModel :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsIconView a) =>
    a -> m (Maybe TreeModel)
    iconViewGetModel a
    iconView = IO (Maybe TreeModel) -> m (Maybe TreeModel)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe TreeModel) -> m (Maybe TreeModel))
    -> IO (Maybe TreeModel) -> m (Maybe TreeModel)
    forall a b. (a -> b) -> a -> b
    $ do
        iconView' <- a -> IO (Ptr IconView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    iconView
        result <- gtk_icon_view_get_model iconView'
        maybeResult <- convertIfNonNull result $ \Ptr TreeModel
    result' -> do
            result'' <- ((ManagedPtr TreeModel -> TreeModel)
    -> Ptr TreeModel -> IO TreeModel
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    newObject ManagedPtr TreeModel -> TreeModel
    Gtk.TreeModel.TreeModel) Ptr TreeModel
    result'
            return result''
        touchManagedPtr iconView
        return maybeResult

    #if defined(ENABLE_OVERLOADING)
    data IconViewGetModelMethodInfo
    instance (signature ~ (m (Maybe Gtk.TreeModel.TreeModel)), MonadIO m, IsIconView a) => O.OverloadedMethod IconViewGetModelMethodInfo a signature where
        overloadedMethod = iconViewGetModel

    instance O.OverloadedMethodInfo IconViewGetModelMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.iconViewGetModel",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#v:iconViewGetModel"
            })

    #endif

    -- method IconView::get_path_at_pos
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "icon_view"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "IconView" }
    --           , argCType = Just "GtkIconView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `GtkIconView`." , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "x"
    --           , argType = TBasicType TInt
    --           , argCType = Just "int"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "The x position to be identified"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "y"
    --           , argType = TBasicType TInt
    --           , argCType = Just "int"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "The y position to be identified"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Gtk" , name = "TreePath" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_icon_view_get_path_at_pos" gtk_icon_view_get_path_at_pos ::
        Ptr IconView ->                         -- icon_view : TInterface (Name {namespace = "Gtk", name = "IconView"})
        Int32 ->                                -- x : TBasicType TInt
        Int32 ->                                -- y : TBasicType TInt
        IO (Ptr Gtk.TreePath.TreePath)

    {-# DEPRECATED iconViewGetPathAtPos ["(Since version 4.10)","Use t'GI.Gtk.Objects.GridView.GridView' instead"] #-}
    -- | Gets the path for the icon at the given position.
    iconViewGetPathAtPos ::
        (B.CallStack.HasCallStack, MonadIO m, IsIconView a) =>
        a
        -- ^ /@iconView@/: A @GtkIconView@.
        -> Int32
        -- ^ /@x@/: The x position to be identified
        -> Int32
        -- ^ /@y@/: The y position to be identified
        -> m (Maybe Gtk.TreePath.TreePath)
        -- ^ __Returns:__ The @GtkTreePath@ corresponding
        -- to the icon or 'P.Nothing' if no icon exists at that position.
    iconViewGetPathAtPos :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsIconView a) =>
    a -> Int32 -> Int32 -> m (Maybe TreePath)
    iconViewGetPathAtPos a
    iconView Int32
    x Int32
    y = IO (Maybe TreePath) -> m (Maybe TreePath)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe TreePath) -> m (Maybe TreePath))
    -> IO (Maybe TreePath) -> m (Maybe TreePath)
    forall a b. (a -> b) -> a -> b
    $ do
        iconView' <- a -> IO (Ptr IconView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    iconView
        result <- gtk_icon_view_get_path_at_pos iconView' x y
        maybeResult <- convertIfNonNull result $ \Ptr TreePath
    result' -> do
            result'' <- ((ManagedPtr TreePath -> TreePath) -> Ptr TreePath -> IO TreePath
    forall a.
    (HasCallStack, GBoxed a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    wrapBoxed ManagedPtr TreePath -> TreePath
    Gtk.TreePath.TreePath) Ptr TreePath
    result'
            return result''
        touchManagedPtr iconView
        return maybeResult

    #if defined(ENABLE_OVERLOADING)
    data IconViewGetPathAtPosMethodInfo
    instance (signature ~ (Int32 -> Int32 -> m (Maybe Gtk.TreePath.TreePath)), MonadIO m, IsIconView a) => O.OverloadedMethod IconViewGetPathAtPosMethodInfo a signature where
        overloadedMethod = iconViewGetPathAtPos

    instance O.OverloadedMethodInfo IconViewGetPathAtPosMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.iconViewGetPathAtPos",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#v:iconViewGetPathAtPos"
            })

    #endif

    -- method IconView::get_pixbuf_column
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "icon_view"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "IconView" }
    --           , argCType = Just "GtkIconView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `GtkIconView`." , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TInt)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_icon_view_get_pixbuf_column" gtk_icon_view_get_pixbuf_column ::
        Ptr IconView ->                         -- icon_view : TInterface (Name {namespace = "Gtk", name = "IconView"})
        IO Int32

    {-# DEPRECATED iconViewGetPixbufColumn ["(Since version 4.10)","Use t'GI.Gtk.Objects.GridView.GridView' instead"] #-}
    -- | Returns the column with pixbufs for /@iconView@/.
    iconViewGetPixbufColumn ::
        (B.CallStack.HasCallStack, MonadIO m, IsIconView a) =>
        a
        -- ^ /@iconView@/: A @GtkIconView@.
        -> m Int32
        -- ^ __Returns:__ the pixbuf column, or -1 if it’s unset.
    iconViewGetPixbufColumn :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsIconView a) =>
    a -> m Int32
    iconViewGetPixbufColumn a
    iconView = IO Int32 -> m Int32
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
    forall a b. (a -> b) -> a -> b
    $ do
        iconView' <- a -> IO (Ptr IconView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    iconView
        result <- gtk_icon_view_get_pixbuf_column iconView'
        touchManagedPtr iconView
        return result

    #if defined(ENABLE_OVERLOADING)
    data IconViewGetPixbufColumnMethodInfo
    instance (signature ~ (m Int32), MonadIO m, IsIconView a) => O.OverloadedMethod IconViewGetPixbufColumnMethodInfo a signature where
        overloadedMethod = iconViewGetPixbufColumn

    instance O.OverloadedMethodInfo IconViewGetPixbufColumnMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.iconViewGetPixbufColumn",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#v:iconViewGetPixbufColumn"
            })

    #endif

    -- method IconView::get_reorderable
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "icon_view"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "IconView" }
    --           , argCType = Just "GtkIconView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkIconView`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TBoolean)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_icon_view_get_reorderable" gtk_icon_view_get_reorderable ::
        Ptr IconView ->                         -- icon_view : TInterface (Name {namespace = "Gtk", name = "IconView"})
        IO CInt

    {-# DEPRECATED iconViewGetReorderable ["(Since version 4.10)","Use t'GI.Gtk.Objects.GridView.GridView' instead"] #-}
    -- | Retrieves whether the user can reorder the list via drag-and-drop.
    -- See 'GI.Gtk.Objects.IconView.iconViewSetReorderable'.
    iconViewGetReorderable ::
        (B.CallStack.HasCallStack, MonadIO m, IsIconView a) =>
        a
        -- ^ /@iconView@/: a @GtkIconView@
        -> m Bool
        -- ^ __Returns:__ 'P.True' if the list can be reordered.
    iconViewGetReorderable :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsIconView a) =>
    a -> m Bool
    iconViewGetReorderable a
    iconView = IconViewActivateCursorItemCallback -> m Bool
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IconViewActivateCursorItemCallback -> m Bool)
    -> IconViewActivateCursorItemCallback -> m Bool
    forall a b. (a -> b) -> a -> b
    $ do
        iconView' <- a -> IO (Ptr IconView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    iconView
        result <- gtk_icon_view_get_reorderable iconView'
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        touchManagedPtr iconView
        return result'

    #if defined(ENABLE_OVERLOADING)
    data IconViewGetReorderableMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsIconView a) => O.OverloadedMethod IconViewGetReorderableMethodInfo a signature where
        overloadedMethod = iconViewGetReorderable

    instance O.OverloadedMethodInfo IconViewGetReorderableMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.iconViewGetReorderable",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#v:iconViewGetReorderable"
            })

    #endif

    -- method IconView::get_row_spacing
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "icon_view"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "IconView" }
    --           , argCType = Just "GtkIconView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkIconView`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TInt)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_icon_view_get_row_spacing" gtk_icon_view_get_row_spacing ::
        Ptr IconView ->                         -- icon_view : TInterface (Name {namespace = "Gtk", name = "IconView"})
        IO Int32

    {-# DEPRECATED iconViewGetRowSpacing ["(Since version 4.10)","Use t'GI.Gtk.Objects.GridView.GridView' instead"] #-}
    -- | Returns the value of the [rowSpacing](#g:signal:rowSpacing) property.
    iconViewGetRowSpacing ::
        (B.CallStack.HasCallStack, MonadIO m, IsIconView a) =>
        a
        -- ^ /@iconView@/: a @GtkIconView@
        -> m Int32
        -- ^ __Returns:__ the space between rows
    iconViewGetRowSpacing :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsIconView a) =>
    a -> m Int32
    iconViewGetRowSpacing a
    iconView = IO Int32 -> m Int32
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
    forall a b. (a -> b) -> a -> b
    $ do
        iconView' <- a -> IO (Ptr IconView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    iconView
        result <- gtk_icon_view_get_row_spacing iconView'
        touchManagedPtr iconView
        return result

    #if defined(ENABLE_OVERLOADING)
    data IconViewGetRowSpacingMethodInfo
    instance (signature ~ (m Int32), MonadIO m, IsIconView a) => O.OverloadedMethod IconViewGetRowSpacingMethodInfo a signature where
        overloadedMethod = iconViewGetRowSpacing

    instance O.OverloadedMethodInfo IconViewGetRowSpacingMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.iconViewGetRowSpacing",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#v:iconViewGetRowSpacing"
            })

    #endif

    -- method IconView::get_selected_items
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "icon_view"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "IconView" }
    --           , argCType = Just "GtkIconView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `GtkIconView`." , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just
    --               (TGList
    --                  (TInterface Name { namespace = "Gtk" , name = "TreePath" }))
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_icon_view_get_selected_items" gtk_icon_view_get_selected_items ::
        Ptr IconView ->                         -- icon_view : TInterface (Name {namespace = "Gtk", name = "IconView"})
        IO (Ptr (GList (Ptr Gtk.TreePath.TreePath)))

    {-# DEPRECATED iconViewGetSelectedItems ["(Since version 4.10)","Use t'GI.Gtk.Objects.GridView.GridView' instead"] #-}
    -- | Creates a list of paths of all selected items. Additionally, if you are
    -- planning on modifying the model after calling this function, you may
    -- want to convert the returned list into a list of @GtkTreeRowReferences@.
    -- To do this, you can use 'GI.Gtk.Structs.TreeRowReference.treeRowReferenceNew'.
    --
    -- To free the return value, use @g_list_free_full@:
    --
    --
    -- === /c code/
    -- >GtkWidget *icon_view = gtk_icon_view_new ();
    -- >// Use icon_view
    -- >
    -- >GList *list = gtk_icon_view_get_selected_items (GTK_ICON_VIEW (icon_view));
    -- >
    -- >// use list
    -- >
    -- >g_list_free_full (list, (GDestroyNotify) gtk_tree_path_free);
    iconViewGetSelectedItems ::
        (B.CallStack.HasCallStack, MonadIO m, IsIconView a) =>
        a
        -- ^ /@iconView@/: A @GtkIconView@.
        -> m [Gtk.TreePath.TreePath]
        -- ^ __Returns:__ A @GList@ containing a @GtkTreePath@ for each selected row.
    iconViewGetSelectedItems :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsIconView a) =>
    a -> m [TreePath]
    iconViewGetSelectedItems a
    iconView = IO [TreePath] -> m [TreePath]
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO [TreePath] -> m [TreePath]) -> IO [TreePath] -> m [TreePath]
    forall a b. (a -> b) -> a -> b
    $ do
        iconView' <- a -> IO (Ptr IconView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    iconView
        result <- gtk_icon_view_get_selected_items iconView'
        result' <- unpackGList result
        result'' <- mapM (wrapBoxed Gtk.TreePath.TreePath) result'
        g_list_free result
        touchManagedPtr iconView
        return result''

    #if defined(ENABLE_OVERLOADING)
    data IconViewGetSelectedItemsMethodInfo
    instance (signature ~ (m [Gtk.TreePath.TreePath]), MonadIO m, IsIconView a) => O.OverloadedMethod IconViewGetSelectedItemsMethodInfo a signature where
        overloadedMethod = iconViewGetSelectedItems

    instance O.OverloadedMethodInfo IconViewGetSelectedItemsMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.iconViewGetSelectedItems",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#v:iconViewGetSelectedItems"
            })

    #endif

    -- method IconView::get_selection_mode
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "icon_view"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "IconView" }
    --           , argCType = Just "GtkIconView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `GtkIconView`." , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just
    --               (TInterface Name { namespace = "Gtk" , name = "SelectionMode" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_icon_view_get_selection_mode" gtk_icon_view_get_selection_mode ::
        Ptr IconView ->                         -- icon_view : TInterface (Name {namespace = "Gtk", name = "IconView"})
        IO CUInt

    {-# DEPRECATED iconViewGetSelectionMode ["(Since version 4.10)","Use t'GI.Gtk.Objects.GridView.GridView' instead"] #-}
    -- | Gets the selection mode of the /@iconView@/.
    iconViewGetSelectionMode ::
        (B.CallStack.HasCallStack, MonadIO m, IsIconView a) =>
        a
        -- ^ /@iconView@/: A @GtkIconView@.
        -> m Gtk.Enums.SelectionMode
        -- ^ __Returns:__ the current selection mode
    iconViewGetSelectionMode :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsIconView a) =>
    a -> m SelectionMode
    iconViewGetSelectionMode a
    iconView = IO SelectionMode -> m SelectionMode
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SelectionMode -> m SelectionMode)
    -> IO SelectionMode -> m SelectionMode
    forall a b. (a -> b) -> a -> b
    $ do
        iconView' <- a -> IO (Ptr IconView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    iconView
        result <- gtk_icon_view_get_selection_mode iconView'
        let result' = (Int -> SelectionMode
    forall a. Enum a => Int -> a
    toEnum (Int -> SelectionMode) -> (CUInt -> Int) -> CUInt -> SelectionMode
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . CUInt -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral) CUInt
    result
        touchManagedPtr iconView
        return result'

    #if defined(ENABLE_OVERLOADING)
    data IconViewGetSelectionModeMethodInfo
    instance (signature ~ (m Gtk.Enums.SelectionMode), MonadIO m, IsIconView a) => O.OverloadedMethod IconViewGetSelectionModeMethodInfo a signature where
        overloadedMethod = iconViewGetSelectionMode

    instance O.OverloadedMethodInfo IconViewGetSelectionModeMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.iconViewGetSelectionMode",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#v:iconViewGetSelectionMode"
            })

    #endif

    -- method IconView::get_spacing
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "icon_view"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "IconView" }
    --           , argCType = Just "GtkIconView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkIconView`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TInt)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_icon_view_get_spacing" gtk_icon_view_get_spacing ::
        Ptr IconView ->                         -- icon_view : TInterface (Name {namespace = "Gtk", name = "IconView"})
        IO Int32

    {-# DEPRECATED iconViewGetSpacing ["(Since version 4.10)","Use t'GI.Gtk.Objects.GridView.GridView' instead"] #-}
    -- | Returns the value of the [spacing](#g:signal:spacing) property.
    iconViewGetSpacing ::
        (B.CallStack.HasCallStack, MonadIO m, IsIconView a) =>
        a
        -- ^ /@iconView@/: a @GtkIconView@
        -> m Int32
        -- ^ __Returns:__ the space between cells
    iconViewGetSpacing :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsIconView a) =>
    a -> m Int32
    iconViewGetSpacing a
    iconView = IO Int32 -> m Int32
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
    forall a b. (a -> b) -> a -> b
    $ do
        iconView' <- a -> IO (Ptr IconView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    iconView
        result <- gtk_icon_view_get_spacing iconView'
        touchManagedPtr iconView
        return result

    #if defined(ENABLE_OVERLOADING)
    data IconViewGetSpacingMethodInfo
    instance (signature ~ (m Int32), MonadIO m, IsIconView a) => O.OverloadedMethod IconViewGetSpacingMethodInfo a signature where
        overloadedMethod = iconViewGetSpacing

    instance O.OverloadedMethodInfo IconViewGetSpacingMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.iconViewGetSpacing",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#v:iconViewGetSpacing"
            })

    #endif

    -- method IconView::get_text_column
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "icon_view"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "IconView" }
    --           , argCType = Just "GtkIconView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `GtkIconView`." , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TInt)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_icon_view_get_text_column" gtk_icon_view_get_text_column ::
        Ptr IconView ->                         -- icon_view : TInterface (Name {namespace = "Gtk", name = "IconView"})
        IO Int32

    {-# DEPRECATED iconViewGetTextColumn ["(Since version 4.10)","Use t'GI.Gtk.Objects.GridView.GridView' instead"] #-}
    -- | Returns the column with text for /@iconView@/.
    iconViewGetTextColumn ::
        (B.CallStack.HasCallStack, MonadIO m, IsIconView a) =>
        a
        -- ^ /@iconView@/: A @GtkIconView@.
        -> m Int32
        -- ^ __Returns:__ the text column, or -1 if it’s unset.
    iconViewGetTextColumn :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsIconView a) =>
    a -> m Int32
    iconViewGetTextColumn a
    iconView = IO Int32 -> m Int32
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
    forall a b. (a -> b) -> a -> b
    $ do
        iconView' <- a -> IO (Ptr IconView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    iconView
        result <- gtk_icon_view_get_text_column iconView'
        touchManagedPtr iconView
        return result

    #if defined(ENABLE_OVERLOADING)
    data IconViewGetTextColumnMethodInfo
    instance (signature ~ (m Int32), MonadIO m, IsIconView a) => O.OverloadedMethod IconViewGetTextColumnMethodInfo a signature where
        overloadedMethod = iconViewGetTextColumn

    instance O.OverloadedMethodInfo IconViewGetTextColumnMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.iconViewGetTextColumn",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#v:iconViewGetTextColumn"
            })

    #endif

    -- method IconView::get_tooltip_column
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "icon_view"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "IconView" }
    --           , argCType = Just "GtkIconView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkIconView`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TInt)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_icon_view_get_tooltip_column" gtk_icon_view_get_tooltip_column ::
        Ptr IconView ->                         -- icon_view : TInterface (Name {namespace = "Gtk", name = "IconView"})
        IO Int32

    {-# DEPRECATED iconViewGetTooltipColumn ["(Since version 4.10)","Use t'GI.Gtk.Objects.GridView.GridView' instead"] #-}
    -- | Returns the column of /@iconView@/’s model which is being used for
    -- displaying tooltips on /@iconView@/’s rows.
    iconViewGetTooltipColumn ::
        (B.CallStack.HasCallStack, MonadIO m, IsIconView a) =>
        a
        -- ^ /@iconView@/: a @GtkIconView@
        -> m Int32
        -- ^ __Returns:__ the index of the tooltip column that is currently being
        -- used, or -1 if this is disabled.
    iconViewGetTooltipColumn :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsIconView a) =>
    a -> m Int32
    iconViewGetTooltipColumn a
    iconView = IO Int32 -> m Int32
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
    forall a b. (a -> b) -> a -> b
    $ do
        iconView' <- a -> IO (Ptr IconView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    iconView
        result <- gtk_icon_view_get_tooltip_column iconView'
        touchManagedPtr iconView
        return result

    #if defined(ENABLE_OVERLOADING)
    data IconViewGetTooltipColumnMethodInfo
    instance (signature ~ (m Int32), MonadIO m, IsIconView a) => O.OverloadedMethod IconViewGetTooltipColumnMethodInfo a signature where
        overloadedMethod = iconViewGetTooltipColumn

    instance O.OverloadedMethodInfo IconViewGetTooltipColumnMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.iconViewGetTooltipColumn",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#v:iconViewGetTooltipColumn"
            })

    #endif

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

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

    {-# DEPRECATED iconViewGetTooltipContext ["(Since version 4.10)","Use t'GI.Gtk.Objects.GridView.GridView' instead"] #-}
    -- | This function is supposed to be used in a @GtkWidget::query-tooltip@
    -- signal handler for @GtkIconView@. The /@x@/, /@y@/ and /@keyboardTip@/ values
    -- which are received in the signal handler, should be passed to this
    -- function without modification.
    --
    -- The return value indicates whether there is an icon view item at the given
    -- coordinates ('P.True') or not ('P.False') for mouse tooltips. For keyboard
    -- tooltips the item returned will be the cursor item. When 'P.True', then any of
    -- /@model@/, /@path@/ and /@iter@/ which have been provided will be set to point to
    -- that row and the corresponding model.
    iconViewGetTooltipContext ::
        (B.CallStack.HasCallStack, MonadIO m, IsIconView a) =>
        a
        -- ^ /@iconView@/: an @GtkIconView@
        -> Int32
        -- ^ /@x@/: the x coordinate (relative to widget coordinates)
        -> Int32
        -- ^ /@y@/: the y coordinate (relative to widget coordinates)
        -> Bool
        -- ^ /@keyboardTip@/: whether this is a keyboard tooltip or not
        -> m ((Bool, Gtk.TreeModel.TreeModel, Gtk.TreePath.TreePath, Gtk.TreeIter.TreeIter))
        -- ^ __Returns:__ whether or not the given tooltip context points to an item
    iconViewGetTooltipContext :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsIconView a) =>
    a
    -> Int32
    -> Int32
    -> Bool
    -> m (Bool, TreeModel, TreePath, TreeIter)
    iconViewGetTooltipContext a
    iconView Int32
    x Int32
    y Bool
    keyboardTip = IO (Bool, TreeModel, TreePath, TreeIter)
    -> m (Bool, TreeModel, TreePath, TreeIter)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Bool, TreeModel, TreePath, TreeIter)
     -> m (Bool, TreeModel, TreePath, TreeIter))
    -> IO (Bool, TreeModel, TreePath, TreeIter)
    -> m (Bool, TreeModel, TreePath, TreeIter)
    forall a b. (a -> b) -> a -> b
    $ do
        iconView' <- a -> IO (Ptr IconView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    iconView
        let keyboardTip' = (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    P.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
    P.fromEnum) Bool
    keyboardTip
        model <- callocMem :: IO (Ptr (Ptr Gtk.TreeModel.TreeModel))
        path <- callocMem :: IO (Ptr (Ptr Gtk.TreePath.TreePath))
        iter <- SP.callocBoxedBytes 32 :: IO (Ptr Gtk.TreeIter.TreeIter)
        result <- gtk_icon_view_get_tooltip_context iconView' x y keyboardTip' model path iter
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        model' <- peek model
        model'' <- (newObject Gtk.TreeModel.TreeModel) model'
        path' <- peek path
        path'' <- (wrapBoxed Gtk.TreePath.TreePath) path'
        iter' <- (wrapBoxed Gtk.TreeIter.TreeIter) iter
        touchManagedPtr iconView
        freeMem model
        freeMem path
        return (result', model'', path'', iter')

    #if defined(ENABLE_OVERLOADING)
    data IconViewGetTooltipContextMethodInfo
    instance (signature ~ (Int32 -> Int32 -> Bool -> m ((Bool, Gtk.TreeModel.TreeModel, Gtk.TreePath.TreePath, Gtk.TreeIter.TreeIter))), MonadIO m, IsIconView a) => O.OverloadedMethod IconViewGetTooltipContextMethodInfo a signature where
        overloadedMethod = iconViewGetTooltipContext

    instance O.OverloadedMethodInfo IconViewGetTooltipContextMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.iconViewGetTooltipContext",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#v:iconViewGetTooltipContext"
            })

    #endif

    -- method IconView::get_visible_range
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "icon_view"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "IconView" }
    --           , argCType = Just "GtkIconView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `GtkIconView`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "start_path"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreePath" }
    --           , argCType = Just "GtkTreePath**"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "Return location for start of region"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       , Arg
    --           { argCName = "end_path"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreePath" }
    --           , argCType = Just "GtkTreePath**"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "Return location for end of region"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TBoolean)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_icon_view_get_visible_range" gtk_icon_view_get_visible_range ::
        Ptr IconView ->                         -- icon_view : TInterface (Name {namespace = "Gtk", name = "IconView"})
        Ptr (Ptr Gtk.TreePath.TreePath) ->      -- start_path : TInterface (Name {namespace = "Gtk", name = "TreePath"})
        Ptr (Ptr Gtk.TreePath.TreePath) ->      -- end_path : TInterface (Name {namespace = "Gtk", name = "TreePath"})
        IO CInt

    {-# DEPRECATED iconViewGetVisibleRange ["(Since version 4.10)","Use t'GI.Gtk.Objects.GridView.GridView' instead"] #-}
    -- | Sets /@startPath@/ and /@endPath@/ to be the first and last visible path.
    -- Note that there may be invisible paths in between.
    --
    -- Both paths should be freed with 'GI.Gtk.Structs.TreePath.treePathFree' after use.
    iconViewGetVisibleRange ::
        (B.CallStack.HasCallStack, MonadIO m, IsIconView a) =>
        a
        -- ^ /@iconView@/: A @GtkIconView@
        -> m ((Bool, Gtk.TreePath.TreePath, Gtk.TreePath.TreePath))
        -- ^ __Returns:__ 'P.True', if valid paths were placed in /@startPath@/ and /@endPath@/
    iconViewGetVisibleRange :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsIconView a) =>
    a -> m (Bool, TreePath, TreePath)
    iconViewGetVisibleRange a
    iconView = IO (Bool, TreePath, TreePath) -> m (Bool, TreePath, TreePath)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Bool, TreePath, TreePath) -> m (Bool, TreePath, TreePath))
    -> IO (Bool, TreePath, TreePath) -> m (Bool, TreePath, TreePath)
    forall a b. (a -> b) -> a -> b
    $ do
        iconView' <- a -> IO (Ptr IconView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    iconView
        startPath <- callocMem :: IO (Ptr (Ptr Gtk.TreePath.TreePath))
        endPath <- callocMem :: IO (Ptr (Ptr Gtk.TreePath.TreePath))
        result <- gtk_icon_view_get_visible_range iconView' startPath endPath
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        startPath' <- peek startPath
        startPath'' <- (wrapBoxed Gtk.TreePath.TreePath) startPath'
        endPath' <- peek endPath
        endPath'' <- (wrapBoxed Gtk.TreePath.TreePath) endPath'
        touchManagedPtr iconView
        freeMem startPath
        freeMem endPath
        return (result', startPath'', endPath'')

    #if defined(ENABLE_OVERLOADING)
    data IconViewGetVisibleRangeMethodInfo
    instance (signature ~ (m ((Bool, Gtk.TreePath.TreePath, Gtk.TreePath.TreePath))), MonadIO m, IsIconView a) => O.OverloadedMethod IconViewGetVisibleRangeMethodInfo a signature where
        overloadedMethod = iconViewGetVisibleRange

    instance O.OverloadedMethodInfo IconViewGetVisibleRangeMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.iconViewGetVisibleRange",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#v:iconViewGetVisibleRange"
            })

    #endif

    -- method IconView::item_activated
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "icon_view"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "IconView" }
    --           , argCType = Just "GtkIconView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `GtkIconView`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "path"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreePath" }
    --           , argCType = Just "GtkTreePath*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "The `GtkTreePath` to be activated"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_icon_view_item_activated" gtk_icon_view_item_activated ::
        Ptr IconView ->                         -- icon_view : TInterface (Name {namespace = "Gtk", name = "IconView"})
        Ptr Gtk.TreePath.TreePath ->            -- path : TInterface (Name {namespace = "Gtk", name = "TreePath"})
        IO ()

    {-# DEPRECATED iconViewItemActivated ["(Since version 4.10)","Use t'GI.Gtk.Objects.GridView.GridView' instead"] #-}
    -- | Activates the item determined by /@path@/.
    iconViewItemActivated ::
        (B.CallStack.HasCallStack, MonadIO m, IsIconView a) =>
        a
        -- ^ /@iconView@/: A @GtkIconView@
        -> Gtk.TreePath.TreePath
        -- ^ /@path@/: The @GtkTreePath@ to be activated
        -> m ()
    iconViewItemActivated :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsIconView a) =>
    a -> TreePath -> m ()
    iconViewItemActivated a
    iconView TreePath
    path = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        iconView' <- a -> IO (Ptr IconView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    iconView
        path' <- unsafeManagedPtrGetPtr path
        gtk_icon_view_item_activated iconView' path'
        touchManagedPtr iconView
        touchManagedPtr path
        return ()

    #if defined(ENABLE_OVERLOADING)
    data IconViewItemActivatedMethodInfo
    instance (signature ~ (Gtk.TreePath.TreePath -> m ()), MonadIO m, IsIconView a) => O.OverloadedMethod IconViewItemActivatedMethodInfo a signature where
        overloadedMethod = iconViewItemActivated

    instance O.OverloadedMethodInfo IconViewItemActivatedMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.iconViewItemActivated",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#v:iconViewItemActivated"
            })

    #endif

    -- method IconView::path_is_selected
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "icon_view"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "IconView" }
    --           , argCType = Just "GtkIconView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `GtkIconView`." , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "path"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreePath" }
    --           , argCType = Just "GtkTreePath*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `GtkTreePath` to check selection on."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TBoolean)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_icon_view_path_is_selected" gtk_icon_view_path_is_selected ::
        Ptr IconView ->                         -- icon_view : TInterface (Name {namespace = "Gtk", name = "IconView"})
        Ptr Gtk.TreePath.TreePath ->            -- path : TInterface (Name {namespace = "Gtk", name = "TreePath"})
        IO CInt

    {-# DEPRECATED iconViewPathIsSelected ["(Since version 4.10)","Use t'GI.Gtk.Objects.GridView.GridView' instead"] #-}
    -- | Returns 'P.True' if the icon pointed to by /@path@/ is currently
    -- selected. If /@path@/ does not point to a valid location, 'P.False' is returned.
    iconViewPathIsSelected ::
        (B.CallStack.HasCallStack, MonadIO m, IsIconView a) =>
        a
        -- ^ /@iconView@/: A @GtkIconView@.
        -> Gtk.TreePath.TreePath
        -- ^ /@path@/: A @GtkTreePath@ to check selection on.
        -> m Bool
        -- ^ __Returns:__ 'P.True' if /@path@/ is selected.
    iconViewPathIsSelected :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsIconView a) =>
    a -> TreePath -> m Bool
    iconViewPathIsSelected a
    iconView TreePath
    path = IconViewActivateCursorItemCallback -> m Bool
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IconViewActivateCursorItemCallback -> m Bool)
    -> IconViewActivateCursorItemCallback -> m Bool
    forall a b. (a -> b) -> a -> b
    $ do
        iconView' <- a -> IO (Ptr IconView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    iconView
        path' <- unsafeManagedPtrGetPtr path
        result <- gtk_icon_view_path_is_selected iconView' path'
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        touchManagedPtr iconView
        touchManagedPtr path
        return result'

    #if defined(ENABLE_OVERLOADING)
    data IconViewPathIsSelectedMethodInfo
    instance (signature ~ (Gtk.TreePath.TreePath -> m Bool), MonadIO m, IsIconView a) => O.OverloadedMethod IconViewPathIsSelectedMethodInfo a signature where
        overloadedMethod = iconViewPathIsSelected

    instance O.OverloadedMethodInfo IconViewPathIsSelectedMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.iconViewPathIsSelected",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#v:iconViewPathIsSelected"
            })

    #endif

    -- method IconView::scroll_to_path
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "icon_view"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "IconView" }
    --           , argCType = Just "GtkIconView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `GtkIconView`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "path"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreePath" }
    --           , argCType = Just "GtkTreePath*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "The path of the item to move to."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "use_align"
    --           , argType = TBasicType TBoolean
    --           , argCType = Just "gboolean"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "whether to use alignment arguments, or %FALSE."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "row_align"
    --           , argType = TBasicType TFloat
    --           , argCType = Just "float"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "The vertical alignment of the item specified by @path."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "col_align"
    --           , argType = TBasicType TFloat
    --           , argCType = Just "float"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "The horizontal alignment of the item specified by @path."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_icon_view_scroll_to_path" gtk_icon_view_scroll_to_path ::
        Ptr IconView ->                         -- icon_view : TInterface (Name {namespace = "Gtk", name = "IconView"})
        Ptr Gtk.TreePath.TreePath ->            -- path : TInterface (Name {namespace = "Gtk", name = "TreePath"})
        CInt ->                                 -- use_align : TBasicType TBoolean
        CFloat ->                               -- row_align : TBasicType TFloat
        CFloat ->                               -- col_align : TBasicType TFloat
        IO ()

    {-# DEPRECATED iconViewScrollToPath ["(Since version 4.10)","Use t'GI.Gtk.Objects.GridView.GridView' instead"] #-}
    -- | Moves the alignments of /@iconView@/ to the position specified by /@path@/.
    -- /@rowAlign@/ determines where the row is placed, and /@colAlign@/ determines
    -- where /@column@/ is placed.  Both are expected to be between 0.0 and 1.0.
    -- 0.0 means left\/top alignment, 1.0 means right\/bottom alignment, 0.5 means
    -- center.
    --
    -- If /@useAlign@/ is 'P.False', then the alignment arguments are ignored, and the
    -- tree does the minimum amount of work to scroll the item onto the screen.
    -- This means that the item will be scrolled to the edge closest to its current
    -- position.  If the item is currently visible on the screen, nothing is done.
    --
    -- This function only works if the model is set, and /@path@/ is a valid row on
    -- the model. If the model changes before the /@iconView@/ is realized, the
    -- centered path will be modified to reflect this change.
    iconViewScrollToPath ::
        (B.CallStack.HasCallStack, MonadIO m, IsIconView a) =>
        a
        -- ^ /@iconView@/: A @GtkIconView@
        -> Gtk.TreePath.TreePath
        -- ^ /@path@/: The path of the item to move to.
        -> Bool
        -- ^ /@useAlign@/: whether to use alignment arguments, or 'P.False'.
        -> Float
        -- ^ /@rowAlign@/: The vertical alignment of the item specified by /@path@/.
        -> Float
        -- ^ /@colAlign@/: The horizontal alignment of the item specified by /@path@/.
        -> m ()
    iconViewScrollToPath :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsIconView a) =>
    a -> TreePath -> Bool -> Float -> Float -> m ()
    iconViewScrollToPath a
    iconView TreePath
    path Bool
    useAlign Float
    rowAlign Float
    colAlign = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        iconView' <- a -> IO (Ptr IconView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    iconView
        path' <- unsafeManagedPtrGetPtr path
        let useAlign' = (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    P.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
    P.fromEnum) Bool
    useAlign
        let rowAlign' = Float -> CFloat
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Float
    rowAlign
        let colAlign' = Float -> CFloat
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Float
    colAlign
        gtk_icon_view_scroll_to_path iconView' path' useAlign' rowAlign' colAlign'
        touchManagedPtr iconView
        touchManagedPtr path
        return ()

    #if defined(ENABLE_OVERLOADING)
    data IconViewScrollToPathMethodInfo
    instance (signature ~ (Gtk.TreePath.TreePath -> Bool -> Float -> Float -> m ()), MonadIO m, IsIconView a) => O.OverloadedMethod IconViewScrollToPathMethodInfo a signature where
        overloadedMethod = iconViewScrollToPath

    instance O.OverloadedMethodInfo IconViewScrollToPathMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.iconViewScrollToPath",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#v:iconViewScrollToPath"
            })

    #endif

    -- method IconView::select_all
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "icon_view"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "IconView" }
    --           , argCType = Just "GtkIconView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `GtkIconView`." , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_icon_view_select_all" gtk_icon_view_select_all ::
        Ptr IconView ->                         -- icon_view : TInterface (Name {namespace = "Gtk", name = "IconView"})
        IO ()

    {-# DEPRECATED iconViewSelectAll ["(Since version 4.10)","Use t'GI.Gtk.Objects.GridView.GridView' instead"] #-}
    -- | Selects all the icons. /@iconView@/ must has its selection mode set
    -- to 'GI.Gtk.Enums.SelectionModeMultiple'.
    iconViewSelectAll ::
        (B.CallStack.HasCallStack, MonadIO m, IsIconView a) =>
        a
        -- ^ /@iconView@/: A @GtkIconView@.
        -> m ()
    iconViewSelectAll :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsIconView a) =>
    a -> m ()
    iconViewSelectAll a
    iconView = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        iconView' <- a -> IO (Ptr IconView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    iconView
        gtk_icon_view_select_all iconView'
        touchManagedPtr iconView
        return ()

    #if defined(ENABLE_OVERLOADING)
    data IconViewSelectAllMethodInfo
    instance (signature ~ (m ()), MonadIO m, IsIconView a) => O.OverloadedMethod IconViewSelectAllMethodInfo a signature where
        overloadedMethod = iconViewSelectAll

    instance O.OverloadedMethodInfo IconViewSelectAllMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.iconViewSelectAll",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#v:iconViewSelectAll"
            })

    #endif

    -- method IconView::select_path
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "icon_view"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "IconView" }
    --           , argCType = Just "GtkIconView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `GtkIconView`." , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "path"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreePath" }
    --           , argCType = Just "GtkTreePath*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "The `GtkTreePath` to be selected."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_icon_view_select_path" gtk_icon_view_select_path ::
        Ptr IconView ->                         -- icon_view : TInterface (Name {namespace = "Gtk", name = "IconView"})
        Ptr Gtk.TreePath.TreePath ->            -- path : TInterface (Name {namespace = "Gtk", name = "TreePath"})
        IO ()

    {-# DEPRECATED iconViewSelectPath ["(Since version 4.10)","Use t'GI.Gtk.Objects.GridView.GridView' instead"] #-}
    -- | Selects the row at /@path@/.
    iconViewSelectPath ::
        (B.CallStack.HasCallStack, MonadIO m, IsIconView a) =>
        a
        -- ^ /@iconView@/: A @GtkIconView@.
        -> Gtk.TreePath.TreePath
        -- ^ /@path@/: The @GtkTreePath@ to be selected.
        -> m ()
    iconViewSelectPath :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsIconView a) =>
    a -> TreePath -> m ()
    iconViewSelectPath a
    iconView TreePath
    path = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        iconView' <- a -> IO (Ptr IconView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    iconView
        path' <- unsafeManagedPtrGetPtr path
        gtk_icon_view_select_path iconView' path'
        touchManagedPtr iconView
        touchManagedPtr path
        return ()

    #if defined(ENABLE_OVERLOADING)
    data IconViewSelectPathMethodInfo
    instance (signature ~ (Gtk.TreePath.TreePath -> m ()), MonadIO m, IsIconView a) => O.OverloadedMethod IconViewSelectPathMethodInfo a signature where
        overloadedMethod = iconViewSelectPath

    instance O.OverloadedMethodInfo IconViewSelectPathMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.iconViewSelectPath",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#v:iconViewSelectPath"
            })

    #endif

    -- method IconView::selected_foreach
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "icon_view"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "IconView" }
    --           , argCType = Just "GtkIconView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `GtkIconView`." , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "func"
    --           , argType =
    --               TInterface
    --                 Name { namespace = "Gtk" , name = "IconViewForeachFunc" }
    --           , argCType = Just "GtkIconViewForeachFunc"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "The function to call for each selected icon."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeCall
    --           , argClosure = 2
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "data"
    --           , argType = TBasicType TPtr
    --           , argCType = Just "gpointer"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "User data to pass to the function."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_icon_view_selected_foreach" gtk_icon_view_selected_foreach ::
        Ptr IconView ->                         -- icon_view : TInterface (Name {namespace = "Gtk", name = "IconView"})
        FunPtr Gtk.Callbacks.C_IconViewForeachFunc -> -- func : TInterface (Name {namespace = "Gtk", name = "IconViewForeachFunc"})
        Ptr () ->                               -- data : TBasicType TPtr
        IO ()

    {-# DEPRECATED iconViewSelectedForeach ["(Since version 4.10)","Use t'GI.Gtk.Objects.GridView.GridView' instead"] #-}
    -- | Calls a function for each selected icon. Note that the model or
    -- selection cannot be modified from within this function.
    iconViewSelectedForeach ::
        (B.CallStack.HasCallStack, MonadIO m, IsIconView a) =>
        a
        -- ^ /@iconView@/: A @GtkIconView@.
        -> Gtk.Callbacks.IconViewForeachFunc
        -- ^ /@func@/: The function to call for each selected icon.
        -> m ()
    iconViewSelectedForeach :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsIconView a) =>
    a -> IconViewForeachFunc -> m ()
    iconViewSelectedForeach a
    iconView IconViewForeachFunc
    func = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        iconView' <- a -> IO (Ptr IconView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    iconView
        func' <- Gtk.Callbacks.mk_IconViewForeachFunc (Gtk.Callbacks.wrap_IconViewForeachFunc Nothing (Gtk.Callbacks.drop_closures_IconViewForeachFunc func))
        let data_ = Ptr a
    forall a. Ptr a
    nullPtr
        gtk_icon_view_selected_foreach iconView' func' data_
        safeFreeFunPtr $ castFunPtrToPtr func'
        touchManagedPtr iconView
        return ()

    #if defined(ENABLE_OVERLOADING)
    data IconViewSelectedForeachMethodInfo
    instance (signature ~ (Gtk.Callbacks.IconViewForeachFunc -> m ()), MonadIO m, IsIconView a) => O.OverloadedMethod IconViewSelectedForeachMethodInfo a signature where
        overloadedMethod = iconViewSelectedForeach

    instance O.OverloadedMethodInfo IconViewSelectedForeachMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.iconViewSelectedForeach",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#v:iconViewSelectedForeach"
            })

    #endif

    -- method IconView::set_activate_on_single_click
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "icon_view"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "IconView" }
    --           , argCType = Just "GtkIconView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkIconView`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "single"
    --           , argType = TBasicType TBoolean
    --           , argCType = Just "gboolean"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "%TRUE to emit item-activated on a single click"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_icon_view_set_activate_on_single_click" gtk_icon_view_set_activate_on_single_click ::
        Ptr IconView ->                         -- icon_view : TInterface (Name {namespace = "Gtk", name = "IconView"})
        CInt ->                                 -- single : TBasicType TBoolean
        IO ()

    {-# DEPRECATED iconViewSetActivateOnSingleClick ["(Since version 4.10)","Use t'GI.Gtk.Objects.GridView.GridView' instead"] #-}
    -- | Causes the @GtkIconView@[itemActivated](#g:signal:itemActivated) signal to be emitted on
    -- a single click instead of a double click.
    iconViewSetActivateOnSingleClick ::
        (B.CallStack.HasCallStack, MonadIO m, IsIconView a) =>
        a
        -- ^ /@iconView@/: a @GtkIconView@
        -> Bool
        -- ^ /@single@/: 'P.True' to emit item-activated on a single click
        -> m ()
    iconViewSetActivateOnSingleClick :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsIconView a) =>
    a -> Bool -> m ()
    iconViewSetActivateOnSingleClick a
    iconView Bool
    single = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        iconView' <- a -> IO (Ptr IconView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    iconView
        let single' = (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    P.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
    P.fromEnum) Bool
    single
        gtk_icon_view_set_activate_on_single_click iconView' single'
        touchManagedPtr iconView
        return ()

    #if defined(ENABLE_OVERLOADING)
    data IconViewSetActivateOnSingleClickMethodInfo
    instance (signature ~ (Bool -> m ()), MonadIO m, IsIconView a) => O.OverloadedMethod IconViewSetActivateOnSingleClickMethodInfo a signature where
        overloadedMethod = iconViewSetActivateOnSingleClick

    instance O.OverloadedMethodInfo IconViewSetActivateOnSingleClickMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.iconViewSetActivateOnSingleClick",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#v:iconViewSetActivateOnSingleClick"
            })

    #endif

    -- method IconView::set_column_spacing
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "icon_view"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "IconView" }
    --           , argCType = Just "GtkIconView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkIconView`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "column_spacing"
    --           , argType = TBasicType TInt
    --           , argCType = Just "int"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the column spacing" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_icon_view_set_column_spacing" gtk_icon_view_set_column_spacing ::
        Ptr IconView ->                         -- icon_view : TInterface (Name {namespace = "Gtk", name = "IconView"})
        Int32 ->                                -- column_spacing : TBasicType TInt
        IO ()

    {-# DEPRECATED iconViewSetColumnSpacing ["(Since version 4.10)","Use t'GI.Gtk.Objects.GridView.GridView' instead"] #-}
    -- | Sets the [columnSpacing](#g:signal:columnSpacing) property which specifies the space
    -- which is inserted between the columns of the icon view.
    iconViewSetColumnSpacing ::
        (B.CallStack.HasCallStack, MonadIO m, IsIconView a) =>
        a
        -- ^ /@iconView@/: a @GtkIconView@
        -> Int32
        -- ^ /@columnSpacing@/: the column spacing
        -> m ()
    iconViewSetColumnSpacing :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsIconView a) =>
    a -> Int32 -> m ()
    iconViewSetColumnSpacing a
    iconView Int32
    columnSpacing = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        iconView' <- a -> IO (Ptr IconView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    iconView
        gtk_icon_view_set_column_spacing iconView' columnSpacing
        touchManagedPtr iconView
        return ()

    #if defined(ENABLE_OVERLOADING)
    data IconViewSetColumnSpacingMethodInfo
    instance (signature ~ (Int32 -> m ()), MonadIO m, IsIconView a) => O.OverloadedMethod IconViewSetColumnSpacingMethodInfo a signature where
        overloadedMethod = iconViewSetColumnSpacing

    instance O.OverloadedMethodInfo IconViewSetColumnSpacingMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.iconViewSetColumnSpacing",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#v:iconViewSetColumnSpacing"
            })

    #endif

    -- method IconView::set_columns
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "icon_view"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "IconView" }
    --           , argCType = Just "GtkIconView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkIconView`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "columns"
    --           , argType = TBasicType TInt
    --           , argCType = Just "int"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the number of columns"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_icon_view_set_columns" gtk_icon_view_set_columns ::
        Ptr IconView ->                         -- icon_view : TInterface (Name {namespace = "Gtk", name = "IconView"})
        Int32 ->                                -- columns : TBasicType TInt
        IO ()

    {-# DEPRECATED iconViewSetColumns ["(Since version 4.10)","Use t'GI.Gtk.Objects.GridView.GridView' instead"] #-}
    -- | Sets the [columns](#g:signal:columns) property which determines in how
    -- many columns the icons are arranged. If /@columns@/ is
    -- -1, the number of columns will be chosen automatically
    -- to fill the available area.
    iconViewSetColumns ::
        (B.CallStack.HasCallStack, MonadIO m, IsIconView a) =>
        a
        -- ^ /@iconView@/: a @GtkIconView@
        -> Int32
        -- ^ /@columns@/: the number of columns
        -> m ()
    iconViewSetColumns :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsIconView a) =>
    a -> Int32 -> m ()
    iconViewSetColumns a
    iconView Int32
    columns = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        iconView' <- a -> IO (Ptr IconView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    iconView
        gtk_icon_view_set_columns iconView' columns
        touchManagedPtr iconView
        return ()

    #if defined(ENABLE_OVERLOADING)
    data IconViewSetColumnsMethodInfo
    instance (signature ~ (Int32 -> m ()), MonadIO m, IsIconView a) => O.OverloadedMethod IconViewSetColumnsMethodInfo a signature where
        overloadedMethod = iconViewSetColumns

    instance O.OverloadedMethodInfo IconViewSetColumnsMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.iconViewSetColumns",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#v:iconViewSetColumns"
            })

    #endif

    -- method IconView::set_cursor
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "icon_view"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "IconView" }
    --           , argCType = Just "GtkIconView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `GtkIconView`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "path"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreePath" }
    --           , argCType = Just "GtkTreePath*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `GtkTreePath`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "cell"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "CellRenderer" }
    --           , argCType = Just "GtkCellRenderer*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "One of the cell renderers of @icon_view"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "start_editing"
    --           , argType = TBasicType TBoolean
    --           , argCType = Just "gboolean"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "%TRUE if the specified cell should start being edited."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_icon_view_set_cursor" gtk_icon_view_set_cursor ::
        Ptr IconView ->                         -- icon_view : TInterface (Name {namespace = "Gtk", name = "IconView"})
        Ptr Gtk.TreePath.TreePath ->            -- path : TInterface (Name {namespace = "Gtk", name = "TreePath"})
        Ptr Gtk.CellRenderer.CellRenderer ->    -- cell : TInterface (Name {namespace = "Gtk", name = "CellRenderer"})
        CInt ->                                 -- start_editing : TBasicType TBoolean
        IO ()

    {-# DEPRECATED iconViewSetCursor ["(Since version 4.10)","Use t'GI.Gtk.Objects.GridView.GridView' instead"] #-}
    -- | Sets the current keyboard focus to be at /@path@/, and selects it.  This is
    -- useful when you want to focus the user’s attention on a particular item.
    -- If /@cell@/ is not 'P.Nothing', then focus is given to the cell specified by
    -- it. Additionally, if /@startEditing@/ is 'P.True', then editing should be
    -- started in the specified cell.
    --
    -- This function is often followed by @gtk_widget_grab_focus
    -- (icon_view)@ in order to give keyboard focus to the widget.
    -- Please note that editing can only happen when the widget is realized.
    iconViewSetCursor ::
        (B.CallStack.HasCallStack, MonadIO m, IsIconView a, Gtk.CellRenderer.IsCellRenderer b) =>
        a
        -- ^ /@iconView@/: A @GtkIconView@
        -> Gtk.TreePath.TreePath
        -- ^ /@path@/: A @GtkTreePath@
        -> Maybe (b)
        -- ^ /@cell@/: One of the cell renderers of /@iconView@/
        -> Bool
        -- ^ /@startEditing@/: 'P.True' if the specified cell should start being edited.
        -> m ()
    iconViewSetCursor :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsIconView a, IsCellRenderer b) =>
    a -> TreePath -> Maybe b -> Bool -> m ()
    iconViewSetCursor a
    iconView TreePath
    path Maybe b
    cell Bool
    startEditing = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        iconView' <- a -> IO (Ptr IconView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    iconView
        path' <- unsafeManagedPtrGetPtr path
        maybeCell <- case cell of
            Maybe b
    Nothing -> Ptr CellRenderer -> IO (Ptr CellRenderer)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr CellRenderer
    forall a. Ptr a
    FP.nullPtr
            Just b
    jCell -> do
                jCell' <- b -> IO (Ptr CellRenderer)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr b
    jCell
                return jCell'
        let startEditing' = (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    P.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
    P.fromEnum) Bool
    startEditing
        gtk_icon_view_set_cursor iconView' path' maybeCell startEditing'
        touchManagedPtr iconView
        touchManagedPtr path
        whenJust cell touchManagedPtr
        return ()

    #if defined(ENABLE_OVERLOADING)
    data IconViewSetCursorMethodInfo
    instance (signature ~ (Gtk.TreePath.TreePath -> Maybe (b) -> Bool -> m ()), MonadIO m, IsIconView a, Gtk.CellRenderer.IsCellRenderer b) => O.OverloadedMethod IconViewSetCursorMethodInfo a signature where
        overloadedMethod = iconViewSetCursor

    instance O.OverloadedMethodInfo IconViewSetCursorMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.iconViewSetCursor",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#v:iconViewSetCursor"
            })

    #endif

    -- method IconView::set_drag_dest_item
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "icon_view"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "IconView" }
    --           , argCType = Just "GtkIconView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkIconView`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "path"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreePath" }
    --           , argCType = Just "GtkTreePath*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "The path of the item to highlight"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "pos"
    --           , argType =
    --               TInterface
    --                 Name { namespace = "Gtk" , name = "IconViewDropPosition" }
    --           , argCType = Just "GtkIconViewDropPosition"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "Specifies where to drop, relative to the item"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_icon_view_set_drag_dest_item" gtk_icon_view_set_drag_dest_item ::
        Ptr IconView ->                         -- icon_view : TInterface (Name {namespace = "Gtk", name = "IconView"})
        Ptr Gtk.TreePath.TreePath ->            -- path : TInterface (Name {namespace = "Gtk", name = "TreePath"})
        CUInt ->                                -- pos : TInterface (Name {namespace = "Gtk", name = "IconViewDropPosition"})
        IO ()

    {-# DEPRECATED iconViewSetDragDestItem ["(Since version 4.10)","Use t'GI.Gtk.Objects.GridView.GridView' instead"] #-}
    -- | Sets the item that is highlighted for feedback.
    iconViewSetDragDestItem ::
        (B.CallStack.HasCallStack, MonadIO m, IsIconView a) =>
        a
        -- ^ /@iconView@/: a @GtkIconView@
        -> Maybe (Gtk.TreePath.TreePath)
        -- ^ /@path@/: The path of the item to highlight
        -> Gtk.Enums.IconViewDropPosition
        -- ^ /@pos@/: Specifies where to drop, relative to the item
        -> m ()
    iconViewSetDragDestItem :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsIconView a) =>
    a -> Maybe TreePath -> IconViewDropPosition -> m ()
    iconViewSetDragDestItem a
    iconView Maybe TreePath
    path IconViewDropPosition
    pos = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        iconView' <- a -> IO (Ptr IconView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    iconView
        maybePath <- case path of
            Maybe TreePath
    Nothing -> Ptr TreePath -> IO (Ptr TreePath)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr TreePath
    forall a. Ptr a
    FP.nullPtr
            Just TreePath
    jPath -> do
                jPath' <- TreePath -> IO (Ptr TreePath)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr TreePath
    jPath
                return jPath'
        let pos' = (Int -> CUInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> CUInt)
    -> (IconViewDropPosition -> Int) -> IconViewDropPosition -> CUInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . IconViewDropPosition -> Int
    forall a. Enum a => a -> Int
    fromEnum) IconViewDropPosition
    pos
        gtk_icon_view_set_drag_dest_item iconView' maybePath pos'
        touchManagedPtr iconView
        whenJust path touchManagedPtr
        return ()

    #if defined(ENABLE_OVERLOADING)
    data IconViewSetDragDestItemMethodInfo
    instance (signature ~ (Maybe (Gtk.TreePath.TreePath) -> Gtk.Enums.IconViewDropPosition -> m ()), MonadIO m, IsIconView a) => O.OverloadedMethod IconViewSetDragDestItemMethodInfo a signature where
        overloadedMethod = iconViewSetDragDestItem

    instance O.OverloadedMethodInfo IconViewSetDragDestItemMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.iconViewSetDragDestItem",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#v:iconViewSetDragDestItem"
            })

    #endif

    -- method IconView::set_item_orientation
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "icon_view"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "IconView" }
    --           , argCType = Just "GtkIconView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkIconView`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "orientation"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "Orientation" }
    --           , argCType = Just "GtkOrientation"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the relative position of texts and icons"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_icon_view_set_item_orientation" gtk_icon_view_set_item_orientation ::
        Ptr IconView ->                         -- icon_view : TInterface (Name {namespace = "Gtk", name = "IconView"})
        CUInt ->                                -- orientation : TInterface (Name {namespace = "Gtk", name = "Orientation"})
        IO ()

    {-# DEPRECATED iconViewSetItemOrientation ["(Since version 4.10)","Use t'GI.Gtk.Objects.GridView.GridView' instead"] #-}
    -- | Sets the [itemOrientation](#g:signal:itemOrientation) property which determines whether the labels
    -- are drawn beside the icons instead of below.
    iconViewSetItemOrientation ::
        (B.CallStack.HasCallStack, MonadIO m, IsIconView a) =>
        a
        -- ^ /@iconView@/: a @GtkIconView@
        -> Gtk.Enums.Orientation
        -- ^ /@orientation@/: the relative position of texts and icons
        -> m ()
    iconViewSetItemOrientation :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsIconView a) =>
    a -> Orientation -> m ()
    iconViewSetItemOrientation a
    iconView Orientation
    orientation = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        iconView' <- a -> IO (Ptr IconView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    iconView
        let orientation' = (Int -> CUInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> CUInt) -> (Orientation -> Int) -> Orientation -> CUInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Orientation -> Int
    forall a. Enum a => a -> Int
    fromEnum) Orientation
    orientation
        gtk_icon_view_set_item_orientation iconView' orientation'
        touchManagedPtr iconView
        return ()

    #if defined(ENABLE_OVERLOADING)
    data IconViewSetItemOrientationMethodInfo
    instance (signature ~ (Gtk.Enums.Orientation -> m ()), MonadIO m, IsIconView a) => O.OverloadedMethod IconViewSetItemOrientationMethodInfo a signature where
        overloadedMethod = iconViewSetItemOrientation

    instance O.OverloadedMethodInfo IconViewSetItemOrientationMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.iconViewSetItemOrientation",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#v:iconViewSetItemOrientation"
            })

    #endif

    -- method IconView::set_item_padding
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "icon_view"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "IconView" }
    --           , argCType = Just "GtkIconView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkIconView`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "item_padding"
    --           , argType = TBasicType TInt
    --           , argCType = Just "int"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the item padding" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_icon_view_set_item_padding" gtk_icon_view_set_item_padding ::
        Ptr IconView ->                         -- icon_view : TInterface (Name {namespace = "Gtk", name = "IconView"})
        Int32 ->                                -- item_padding : TBasicType TInt
        IO ()

    {-# DEPRECATED iconViewSetItemPadding ["(Since version 4.10)","Use t'GI.Gtk.Objects.GridView.GridView' instead"] #-}
    -- | Sets the @GtkIconView@:item-padding property which specifies the padding
    -- around each of the icon view’s items.
    iconViewSetItemPadding ::
        (B.CallStack.HasCallStack, MonadIO m, IsIconView a) =>
        a
        -- ^ /@iconView@/: a @GtkIconView@
        -> Int32
        -- ^ /@itemPadding@/: the item padding
        -> m ()
    iconViewSetItemPadding :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsIconView a) =>
    a -> Int32 -> m ()
    iconViewSetItemPadding a
    iconView Int32
    itemPadding = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        iconView' <- a -> IO (Ptr IconView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    iconView
        gtk_icon_view_set_item_padding iconView' itemPadding
        touchManagedPtr iconView
        return ()

    #if defined(ENABLE_OVERLOADING)
    data IconViewSetItemPaddingMethodInfo
    instance (signature ~ (Int32 -> m ()), MonadIO m, IsIconView a) => O.OverloadedMethod IconViewSetItemPaddingMethodInfo a signature where
        overloadedMethod = iconViewSetItemPadding

    instance O.OverloadedMethodInfo IconViewSetItemPaddingMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.iconViewSetItemPadding",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#v:iconViewSetItemPadding"
            })

    #endif

    -- method IconView::set_item_width
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "icon_view"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "IconView" }
    --           , argCType = Just "GtkIconView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkIconView`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "item_width"
    --           , argType = TBasicType TInt
    --           , argCType = Just "int"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the width for each item"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_icon_view_set_item_width" gtk_icon_view_set_item_width ::
        Ptr IconView ->                         -- icon_view : TInterface (Name {namespace = "Gtk", name = "IconView"})
        Int32 ->                                -- item_width : TBasicType TInt
        IO ()

    {-# DEPRECATED iconViewSetItemWidth ["(Since version 4.10)","Use t'GI.Gtk.Objects.GridView.GridView' instead"] #-}
    -- | Sets the [itemWidth](#g:signal:itemWidth) property which specifies the width
    -- to use for each item. If it is set to -1, the icon view will
    -- automatically determine a suitable item size.
    iconViewSetItemWidth ::
        (B.CallStack.HasCallStack, MonadIO m, IsIconView a) =>
        a
        -- ^ /@iconView@/: a @GtkIconView@
        -> Int32
        -- ^ /@itemWidth@/: the width for each item
        -> m ()
    iconViewSetItemWidth :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsIconView a) =>
    a -> Int32 -> m ()
    iconViewSetItemWidth a
    iconView Int32
    itemWidth = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        iconView' <- a -> IO (Ptr IconView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    iconView
        gtk_icon_view_set_item_width iconView' itemWidth
        touchManagedPtr iconView
        return ()

    #if defined(ENABLE_OVERLOADING)
    data IconViewSetItemWidthMethodInfo
    instance (signature ~ (Int32 -> m ()), MonadIO m, IsIconView a) => O.OverloadedMethod IconViewSetItemWidthMethodInfo a signature where
        overloadedMethod = iconViewSetItemWidth

    instance O.OverloadedMethodInfo IconViewSetItemWidthMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.iconViewSetItemWidth",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#v:iconViewSetItemWidth"
            })

    #endif

    -- method IconView::set_margin
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "icon_view"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "IconView" }
    --           , argCType = Just "GtkIconView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkIconView`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "margin"
    --           , argType = TBasicType TInt
    --           , argCType = Just "int"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the margin" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_icon_view_set_margin" gtk_icon_view_set_margin ::
        Ptr IconView ->                         -- icon_view : TInterface (Name {namespace = "Gtk", name = "IconView"})
        Int32 ->                                -- margin : TBasicType TInt
        IO ()

    {-# DEPRECATED iconViewSetMargin ["(Since version 4.10)","Use t'GI.Gtk.Objects.GridView.GridView' instead"] #-}
    -- | Sets the [margin](#g:signal:margin) property which specifies the space
    -- which is inserted at the top, bottom, left and right
    -- of the icon view.
    iconViewSetMargin ::
        (B.CallStack.HasCallStack, MonadIO m, IsIconView a) =>
        a
        -- ^ /@iconView@/: a @GtkIconView@
        -> Int32
        -- ^ /@margin@/: the margin
        -> m ()
    iconViewSetMargin :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsIconView a) =>
    a -> Int32 -> m ()
    iconViewSetMargin a
    iconView Int32
    margin = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        iconView' <- a -> IO (Ptr IconView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    iconView
        gtk_icon_view_set_margin iconView' margin
        touchManagedPtr iconView
        return ()

    #if defined(ENABLE_OVERLOADING)
    data IconViewSetMarginMethodInfo
    instance (signature ~ (Int32 -> m ()), MonadIO m, IsIconView a) => O.OverloadedMethod IconViewSetMarginMethodInfo a signature where
        overloadedMethod = iconViewSetMargin

    instance O.OverloadedMethodInfo IconViewSetMarginMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.iconViewSetMargin",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#v:iconViewSetMargin"
            })

    #endif

    -- method IconView::set_markup_column
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "icon_view"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "IconView" }
    --           , argCType = Just "GtkIconView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `GtkIconView`." , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "column"
    --           , argType = TBasicType TInt
    --           , argCType = Just "int"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "A column in the currently used model, or -1 to display no text"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_icon_view_set_markup_column" gtk_icon_view_set_markup_column ::
        Ptr IconView ->                         -- icon_view : TInterface (Name {namespace = "Gtk", name = "IconView"})
        Int32 ->                                -- column : TBasicType TInt
        IO ()

    {-# DEPRECATED iconViewSetMarkupColumn ["(Since version 4.10)","Use t'GI.Gtk.Objects.GridView.GridView' instead"] #-}
    -- | Sets the column with markup information for /@iconView@/ to be
    -- /@column@/. The markup column must be of type @G_TYPE_STRING@.
    -- If the markup column is set to something, it overrides
    -- the text column set by 'GI.Gtk.Objects.IconView.iconViewSetTextColumn'.
    iconViewSetMarkupColumn ::
        (B.CallStack.HasCallStack, MonadIO m, IsIconView a) =>
        a
        -- ^ /@iconView@/: A @GtkIconView@.
        -> Int32
        -- ^ /@column@/: A column in the currently used model, or -1 to display no text
        -> m ()
    iconViewSetMarkupColumn :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsIconView a) =>
    a -> Int32 -> m ()
    iconViewSetMarkupColumn a
    iconView Int32
    column = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        iconView' <- a -> IO (Ptr IconView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    iconView
        gtk_icon_view_set_markup_column iconView' column
        touchManagedPtr iconView
        return ()

    #if defined(ENABLE_OVERLOADING)
    data IconViewSetMarkupColumnMethodInfo
    instance (signature ~ (Int32 -> m ()), MonadIO m, IsIconView a) => O.OverloadedMethod IconViewSetMarkupColumnMethodInfo a signature where
        overloadedMethod = iconViewSetMarkupColumn

    instance O.OverloadedMethodInfo IconViewSetMarkupColumnMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.iconViewSetMarkupColumn",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#v:iconViewSetMarkupColumn"
            })

    #endif

    -- method IconView::set_model
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "icon_view"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "IconView" }
    --           , argCType = Just "GtkIconView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `GtkIconView`." , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "model"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreeModel" }
    --           , argCType = Just "GtkTreeModel*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "The model." , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

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

    {-# DEPRECATED iconViewSetModel ["(Since version 4.10)","Use t'GI.Gtk.Objects.GridView.GridView' instead"] #-}
    -- | Sets the model for a @GtkIconView@.
    -- If the /@iconView@/ already has a model set, it will remove
    -- it before setting the new model.  If /@model@/ is 'P.Nothing', then
    -- it will unset the old model.
    iconViewSetModel ::
        (B.CallStack.HasCallStack, MonadIO m, IsIconView a, Gtk.TreeModel.IsTreeModel b) =>
        a
        -- ^ /@iconView@/: A @GtkIconView@.
        -> Maybe (b)
        -- ^ /@model@/: The model.
        -> m ()
    iconViewSetModel :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsIconView a, IsTreeModel b) =>
    a -> Maybe b -> m ()
    iconViewSetModel a
    iconView Maybe b
    model = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        iconView' <- a -> IO (Ptr IconView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    iconView
        maybeModel <- case model of
            Maybe b
    Nothing -> Ptr TreeModel -> IO (Ptr TreeModel)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr TreeModel
    forall a. Ptr a
    FP.nullPtr
            Just b
    jModel -> do
                jModel' <- b -> IO (Ptr TreeModel)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr b
    jModel
                return jModel'
        gtk_icon_view_set_model iconView' maybeModel
        touchManagedPtr iconView
        whenJust model touchManagedPtr
        return ()

    #if defined(ENABLE_OVERLOADING)
    data IconViewSetModelMethodInfo
    instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsIconView a, Gtk.TreeModel.IsTreeModel b) => O.OverloadedMethod IconViewSetModelMethodInfo a signature where
        overloadedMethod = iconViewSetModel

    instance O.OverloadedMethodInfo IconViewSetModelMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.iconViewSetModel",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#v:iconViewSetModel"
            })

    #endif

    -- method IconView::set_pixbuf_column
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "icon_view"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "IconView" }
    --           , argCType = Just "GtkIconView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `GtkIconView`." , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "column"
    --           , argType = TBasicType TInt
    --           , argCType = Just "int"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "A column in the currently used model, or -1 to disable"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_icon_view_set_pixbuf_column" gtk_icon_view_set_pixbuf_column ::
        Ptr IconView ->                         -- icon_view : TInterface (Name {namespace = "Gtk", name = "IconView"})
        Int32 ->                                -- column : TBasicType TInt
        IO ()

    {-# DEPRECATED iconViewSetPixbufColumn ["(Since version 4.10)","Use t'GI.Gtk.Objects.GridView.GridView' instead"] #-}
    -- | Sets the column with pixbufs for /@iconView@/ to be /@column@/. The pixbuf
    -- column must be of type @GDK_TYPE_PIXBUF@
    iconViewSetPixbufColumn ::
        (B.CallStack.HasCallStack, MonadIO m, IsIconView a) =>
        a
        -- ^ /@iconView@/: A @GtkIconView@.
        -> Int32
        -- ^ /@column@/: A column in the currently used model, or -1 to disable
        -> m ()
    iconViewSetPixbufColumn :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsIconView a) =>
    a -> Int32 -> m ()
    iconViewSetPixbufColumn a
    iconView Int32
    column = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        iconView' <- a -> IO (Ptr IconView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    iconView
        gtk_icon_view_set_pixbuf_column iconView' column
        touchManagedPtr iconView
        return ()

    #if defined(ENABLE_OVERLOADING)
    data IconViewSetPixbufColumnMethodInfo
    instance (signature ~ (Int32 -> m ()), MonadIO m, IsIconView a) => O.OverloadedMethod IconViewSetPixbufColumnMethodInfo a signature where
        overloadedMethod = iconViewSetPixbufColumn

    instance O.OverloadedMethodInfo IconViewSetPixbufColumnMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.iconViewSetPixbufColumn",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#v:iconViewSetPixbufColumn"
            })

    #endif

    -- method IconView::set_reorderable
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "icon_view"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "IconView" }
    --           , argCType = Just "GtkIconView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `GtkIconView`." , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "reorderable"
    --           , argType = TBasicType TBoolean
    --           , argCType = Just "gboolean"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "%TRUE, if the list of items can be reordered."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

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

    {-# DEPRECATED iconViewSetReorderable ["(Since version 4.10)","Use t'GI.Gtk.Objects.GridView.GridView' instead"] #-}
    -- | This function is a convenience function to allow you to reorder models that
    -- support the @GtkTreeDragSourceIface@ and the @GtkTreeDragDestIface@. Both
    -- @GtkTreeStore@ and @GtkListStore@ support these. If /@reorderable@/ is 'P.True', then
    -- the user can reorder the model by dragging and dropping rows.  The
    -- developer can listen to these changes by connecting to the model\'s
    -- row_inserted and row_deleted signals. The reordering is implemented by setting up
    -- the icon view as a drag source and destination. Therefore, drag and
    -- drop can not be used in a reorderable view for any other purpose.
    --
    -- This function does not give you any degree of control over the order -- any
    -- reordering is allowed.  If more control is needed, you should probably
    -- handle drag and drop manually.
    iconViewSetReorderable ::
        (B.CallStack.HasCallStack, MonadIO m, IsIconView a) =>
        a
        -- ^ /@iconView@/: A @GtkIconView@.
        -> Bool
        -- ^ /@reorderable@/: 'P.True', if the list of items can be reordered.
        -> m ()
    iconViewSetReorderable :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsIconView a) =>
    a -> Bool -> m ()
    iconViewSetReorderable a
    iconView Bool
    reorderable = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        iconView' <- a -> IO (Ptr IconView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    iconView
        let reorderable' = (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    P.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
    P.fromEnum) Bool
    reorderable
        gtk_icon_view_set_reorderable iconView' reorderable'
        touchManagedPtr iconView
        return ()

    #if defined(ENABLE_OVERLOADING)
    data IconViewSetReorderableMethodInfo
    instance (signature ~ (Bool -> m ()), MonadIO m, IsIconView a) => O.OverloadedMethod IconViewSetReorderableMethodInfo a signature where
        overloadedMethod = iconViewSetReorderable

    instance O.OverloadedMethodInfo IconViewSetReorderableMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.iconViewSetReorderable",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#v:iconViewSetReorderable"
            })

    #endif

    -- method IconView::set_row_spacing
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "icon_view"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "IconView" }
    --           , argCType = Just "GtkIconView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkIconView`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "row_spacing"
    --           , argType = TBasicType TInt
    --           , argCType = Just "int"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the row spacing" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_icon_view_set_row_spacing" gtk_icon_view_set_row_spacing ::
        Ptr IconView ->                         -- icon_view : TInterface (Name {namespace = "Gtk", name = "IconView"})
        Int32 ->                                -- row_spacing : TBasicType TInt
        IO ()

    {-# DEPRECATED iconViewSetRowSpacing ["(Since version 4.10)","Use t'GI.Gtk.Objects.GridView.GridView' instead"] #-}
    -- | Sets the [rowSpacing](#g:signal:rowSpacing) property which specifies the space
    -- which is inserted between the rows of the icon view.
    iconViewSetRowSpacing ::
        (B.CallStack.HasCallStack, MonadIO m, IsIconView a) =>
        a
        -- ^ /@iconView@/: a @GtkIconView@
        -> Int32
        -- ^ /@rowSpacing@/: the row spacing
        -> m ()
    iconViewSetRowSpacing :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsIconView a) =>
    a -> Int32 -> m ()
    iconViewSetRowSpacing a
    iconView Int32
    rowSpacing = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        iconView' <- a -> IO (Ptr IconView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    iconView
        gtk_icon_view_set_row_spacing iconView' rowSpacing
        touchManagedPtr iconView
        return ()

    #if defined(ENABLE_OVERLOADING)
    data IconViewSetRowSpacingMethodInfo
    instance (signature ~ (Int32 -> m ()), MonadIO m, IsIconView a) => O.OverloadedMethod IconViewSetRowSpacingMethodInfo a signature where
        overloadedMethod = iconViewSetRowSpacing

    instance O.OverloadedMethodInfo IconViewSetRowSpacingMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.iconViewSetRowSpacing",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#v:iconViewSetRowSpacing"
            })

    #endif

    -- method IconView::set_selection_mode
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "icon_view"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "IconView" }
    --           , argCType = Just "GtkIconView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `GtkIconView`." , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "mode"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "SelectionMode" }
    --           , argCType = Just "GtkSelectionMode"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "The selection mode" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_icon_view_set_selection_mode" gtk_icon_view_set_selection_mode ::
        Ptr IconView ->                         -- icon_view : TInterface (Name {namespace = "Gtk", name = "IconView"})
        CUInt ->                                -- mode : TInterface (Name {namespace = "Gtk", name = "SelectionMode"})
        IO ()

    {-# DEPRECATED iconViewSetSelectionMode ["(Since version 4.10)","Use t'GI.Gtk.Objects.GridView.GridView' instead"] #-}
    -- | Sets the selection mode of the /@iconView@/.
    iconViewSetSelectionMode ::
        (B.CallStack.HasCallStack, MonadIO m, IsIconView a) =>
        a
        -- ^ /@iconView@/: A @GtkIconView@.
        -> Gtk.Enums.SelectionMode
        -- ^ /@mode@/: The selection mode
        -> m ()
    iconViewSetSelectionMode :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsIconView a) =>
    a -> SelectionMode -> m ()
    iconViewSetSelectionMode a
    iconView SelectionMode
    mode = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        iconView' <- a -> IO (Ptr IconView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    iconView
        let mode' = (Int -> CUInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> CUInt) -> (SelectionMode -> Int) -> SelectionMode -> CUInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . SelectionMode -> Int
    forall a. Enum a => a -> Int
    fromEnum) SelectionMode
    mode
        gtk_icon_view_set_selection_mode iconView' mode'
        touchManagedPtr iconView
        return ()

    #if defined(ENABLE_OVERLOADING)
    data IconViewSetSelectionModeMethodInfo
    instance (signature ~ (Gtk.Enums.SelectionMode -> m ()), MonadIO m, IsIconView a) => O.OverloadedMethod IconViewSetSelectionModeMethodInfo a signature where
        overloadedMethod = iconViewSetSelectionMode

    instance O.OverloadedMethodInfo IconViewSetSelectionModeMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.iconViewSetSelectionMode",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#v:iconViewSetSelectionMode"
            })

    #endif

    -- method IconView::set_spacing
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "icon_view"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "IconView" }
    --           , argCType = Just "GtkIconView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkIconView`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "spacing"
    --           , argType = TBasicType TInt
    --           , argCType = Just "int"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the spacing" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

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

    {-# DEPRECATED iconViewSetSpacing ["(Since version 4.10)","Use t'GI.Gtk.Objects.GridView.GridView' instead"] #-}
    -- | Sets the [spacing](#g:signal:spacing) property which specifies the space
    -- which is inserted between the cells (i.e. the icon and
    -- the text) of an item.
    iconViewSetSpacing ::
        (B.CallStack.HasCallStack, MonadIO m, IsIconView a) =>
        a
        -- ^ /@iconView@/: a @GtkIconView@
        -> Int32
        -- ^ /@spacing@/: the spacing
        -> m ()
    iconViewSetSpacing :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsIconView a) =>
    a -> Int32 -> m ()
    iconViewSetSpacing a
    iconView Int32
    spacing = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        iconView' <- a -> IO (Ptr IconView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    iconView
        gtk_icon_view_set_spacing iconView' spacing
        touchManagedPtr iconView
        return ()

    #if defined(ENABLE_OVERLOADING)
    data IconViewSetSpacingMethodInfo
    instance (signature ~ (Int32 -> m ()), MonadIO m, IsIconView a) => O.OverloadedMethod IconViewSetSpacingMethodInfo a signature where
        overloadedMethod = iconViewSetSpacing

    instance O.OverloadedMethodInfo IconViewSetSpacingMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.iconViewSetSpacing",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#v:iconViewSetSpacing"
            })

    #endif

    -- method IconView::set_text_column
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "icon_view"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "IconView" }
    --           , argCType = Just "GtkIconView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `GtkIconView`." , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "column"
    --           , argType = TBasicType TInt
    --           , argCType = Just "int"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "A column in the currently used model, or -1 to display no text"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_icon_view_set_text_column" gtk_icon_view_set_text_column ::
        Ptr IconView ->                         -- icon_view : TInterface (Name {namespace = "Gtk", name = "IconView"})
        Int32 ->                                -- column : TBasicType TInt
        IO ()

    {-# DEPRECATED iconViewSetTextColumn ["(Since version 4.10)","Use t'GI.Gtk.Objects.GridView.GridView' instead"] #-}
    -- | Sets the column with text for /@iconView@/ to be /@column@/. The text
    -- column must be of type @G_TYPE_STRING@.
    iconViewSetTextColumn ::
        (B.CallStack.HasCallStack, MonadIO m, IsIconView a) =>
        a
        -- ^ /@iconView@/: A @GtkIconView@.
        -> Int32
        -- ^ /@column@/: A column in the currently used model, or -1 to display no text
        -> m ()
    iconViewSetTextColumn :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsIconView a) =>
    a -> Int32 -> m ()
    iconViewSetTextColumn a
    iconView Int32
    column = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        iconView' <- a -> IO (Ptr IconView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    iconView
        gtk_icon_view_set_text_column iconView' column
        touchManagedPtr iconView
        return ()

    #if defined(ENABLE_OVERLOADING)
    data IconViewSetTextColumnMethodInfo
    instance (signature ~ (Int32 -> m ()), MonadIO m, IsIconView a) => O.OverloadedMethod IconViewSetTextColumnMethodInfo a signature where
        overloadedMethod = iconViewSetTextColumn

    instance O.OverloadedMethodInfo IconViewSetTextColumnMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.iconViewSetTextColumn",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#v:iconViewSetTextColumn"
            })

    #endif

    -- method IconView::set_tooltip_cell
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "icon_view"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "IconView" }
    --           , argCType = Just "GtkIconView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkIconView`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "tooltip"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "Tooltip" }
    --           , argCType = Just "GtkTooltip*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkTooltip`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "path"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreePath" }
    --           , argCType = Just "GtkTreePath*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkTreePath`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "cell"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "CellRenderer" }
    --           , argCType = Just "GtkCellRenderer*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkCellRenderer`"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_icon_view_set_tooltip_cell" gtk_icon_view_set_tooltip_cell ::
        Ptr IconView ->                         -- icon_view : TInterface (Name {namespace = "Gtk", name = "IconView"})
        Ptr Gtk.Tooltip.Tooltip ->              -- tooltip : TInterface (Name {namespace = "Gtk", name = "Tooltip"})
        Ptr Gtk.TreePath.TreePath ->            -- path : TInterface (Name {namespace = "Gtk", name = "TreePath"})
        Ptr Gtk.CellRenderer.CellRenderer ->    -- cell : TInterface (Name {namespace = "Gtk", name = "CellRenderer"})
        IO ()

    {-# DEPRECATED iconViewSetTooltipCell ["(Since version 4.10)","Use t'GI.Gtk.Objects.GridView.GridView' instead"] #-}
    -- | Sets the tip area of /@tooltip@/ to the area which /@cell@/ occupies in
    -- the item pointed to by /@path@/. See also 'GI.Gtk.Objects.Tooltip.tooltipSetTipArea'.
    --
    -- See also 'GI.Gtk.Objects.IconView.iconViewSetTooltipColumn' for a simpler alternative.
    iconViewSetTooltipCell ::
        (B.CallStack.HasCallStack, MonadIO m, IsIconView a, Gtk.Tooltip.IsTooltip b, Gtk.CellRenderer.IsCellRenderer c) =>
        a
        -- ^ /@iconView@/: a @GtkIconView@
        -> b
        -- ^ /@tooltip@/: a @GtkTooltip@
        -> Gtk.TreePath.TreePath
        -- ^ /@path@/: a @GtkTreePath@
        -> Maybe (c)
        -- ^ /@cell@/: a @GtkCellRenderer@
        -> m ()
    iconViewSetTooltipCell :: forall (m :: * -> *) a b c.
    (HasCallStack, MonadIO m, IsIconView a, IsTooltip b,
     IsCellRenderer c) =>
    a -> b -> TreePath -> Maybe c -> m ()
    iconViewSetTooltipCell a
    iconView b
    tooltip TreePath
    path Maybe c
    cell = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        iconView' <- a -> IO (Ptr IconView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    iconView
        tooltip' <- unsafeManagedPtrCastPtr tooltip
        path' <- unsafeManagedPtrGetPtr path
        maybeCell <- case cell of
            Maybe c
    Nothing -> Ptr CellRenderer -> IO (Ptr CellRenderer)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr CellRenderer
    forall a. Ptr a
    FP.nullPtr
            Just c
    jCell -> do
                jCell' <- c -> IO (Ptr CellRenderer)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr c
    jCell
                return jCell'
        gtk_icon_view_set_tooltip_cell iconView' tooltip' path' maybeCell
        touchManagedPtr iconView
        touchManagedPtr tooltip
        touchManagedPtr path
        whenJust cell touchManagedPtr
        return ()

    #if defined(ENABLE_OVERLOADING)
    data IconViewSetTooltipCellMethodInfo
    instance (signature ~ (b -> Gtk.TreePath.TreePath -> Maybe (c) -> m ()), MonadIO m, IsIconView a, Gtk.Tooltip.IsTooltip b, Gtk.CellRenderer.IsCellRenderer c) => O.OverloadedMethod IconViewSetTooltipCellMethodInfo a signature where
        overloadedMethod = iconViewSetTooltipCell

    instance O.OverloadedMethodInfo IconViewSetTooltipCellMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.iconViewSetTooltipCell",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#v:iconViewSetTooltipCell"
            })

    #endif

    -- method IconView::set_tooltip_column
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "icon_view"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "IconView" }
    --           , argCType = Just "GtkIconView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkIconView`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "column"
    --           , argType = TBasicType TInt
    --           , argCType = Just "int"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "an integer, which is a valid column number for @icon_view\8217s model"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_icon_view_set_tooltip_column" gtk_icon_view_set_tooltip_column ::
        Ptr IconView ->                         -- icon_view : TInterface (Name {namespace = "Gtk", name = "IconView"})
        Int32 ->                                -- column : TBasicType TInt
        IO ()

    {-# DEPRECATED iconViewSetTooltipColumn ["(Since version 4.10)","Use t'GI.Gtk.Objects.GridView.GridView' instead"] #-}
    -- | If you only plan to have simple (text-only) tooltips on full items, you
    -- can use this function to have @GtkIconView@ handle these automatically
    -- for you. /@column@/ should be set to the column in /@iconView@/’s model
    -- containing the tooltip texts, or -1 to disable this feature.
    --
    -- When enabled, @GtkWidget:has-tooltip@ will be set to 'P.True' and
    -- /@iconView@/ will connect a @GtkWidget::query-tooltip@ signal handler.
    --
    -- Note that the signal handler sets the text with 'GI.Gtk.Objects.Tooltip.tooltipSetMarkup',
    -- so &, \<, etc have to be escaped in the text.
    iconViewSetTooltipColumn ::
        (B.CallStack.HasCallStack, MonadIO m, IsIconView a) =>
        a
        -- ^ /@iconView@/: a @GtkIconView@
        -> Int32
        -- ^ /@column@/: an integer, which is a valid column number for /@iconView@/’s model
        -> m ()
    iconViewSetTooltipColumn :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsIconView a) =>
    a -> Int32 -> m ()
    iconViewSetTooltipColumn a
    iconView Int32
    column = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        iconView' <- a -> IO (Ptr IconView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    iconView
        gtk_icon_view_set_tooltip_column iconView' column
        touchManagedPtr iconView
        return ()

    #if defined(ENABLE_OVERLOADING)
    data IconViewSetTooltipColumnMethodInfo
    instance (signature ~ (Int32 -> m ()), MonadIO m, IsIconView a) => O.OverloadedMethod IconViewSetTooltipColumnMethodInfo a signature where
        overloadedMethod = iconViewSetTooltipColumn

    instance O.OverloadedMethodInfo IconViewSetTooltipColumnMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.iconViewSetTooltipColumn",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#v:iconViewSetTooltipColumn"
            })

    #endif

    -- method IconView::set_tooltip_item
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "icon_view"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "IconView" }
    --           , argCType = Just "GtkIconView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkIconView`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "tooltip"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "Tooltip" }
    --           , argCType = Just "GtkTooltip*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkTooltip`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "path"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreePath" }
    --           , argCType = Just "GtkTreePath*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkTreePath`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_icon_view_set_tooltip_item" gtk_icon_view_set_tooltip_item ::
        Ptr IconView ->                         -- icon_view : TInterface (Name {namespace = "Gtk", name = "IconView"})
        Ptr Gtk.Tooltip.Tooltip ->              -- tooltip : TInterface (Name {namespace = "Gtk", name = "Tooltip"})
        Ptr Gtk.TreePath.TreePath ->            -- path : TInterface (Name {namespace = "Gtk", name = "TreePath"})
        IO ()

    {-# DEPRECATED iconViewSetTooltipItem ["(Since version 4.10)","Use t'GI.Gtk.Objects.GridView.GridView' instead"] #-}
    -- | Sets the tip area of /@tooltip@/ to be the area covered by the item at /@path@/.
    -- See also 'GI.Gtk.Objects.IconView.iconViewSetTooltipColumn' for a simpler alternative.
    -- See also 'GI.Gtk.Objects.Tooltip.tooltipSetTipArea'.
    iconViewSetTooltipItem ::
        (B.CallStack.HasCallStack, MonadIO m, IsIconView a, Gtk.Tooltip.IsTooltip b) =>
        a
        -- ^ /@iconView@/: a @GtkIconView@
        -> b
        -- ^ /@tooltip@/: a @GtkTooltip@
        -> Gtk.TreePath.TreePath
        -- ^ /@path@/: a @GtkTreePath@
        -> m ()
    iconViewSetTooltipItem :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsIconView a, IsTooltip b) =>
    a -> b -> TreePath -> m ()
    iconViewSetTooltipItem a
    iconView b
    tooltip TreePath
    path = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        iconView' <- a -> IO (Ptr IconView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    iconView
        tooltip' <- unsafeManagedPtrCastPtr tooltip
        path' <- unsafeManagedPtrGetPtr path
        gtk_icon_view_set_tooltip_item iconView' tooltip' path'
        touchManagedPtr iconView
        touchManagedPtr tooltip
        touchManagedPtr path
        return ()

    #if defined(ENABLE_OVERLOADING)
    data IconViewSetTooltipItemMethodInfo
    instance (signature ~ (b -> Gtk.TreePath.TreePath -> m ()), MonadIO m, IsIconView a, Gtk.Tooltip.IsTooltip b) => O.OverloadedMethod IconViewSetTooltipItemMethodInfo a signature where
        overloadedMethod = iconViewSetTooltipItem

    instance O.OverloadedMethodInfo IconViewSetTooltipItemMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.iconViewSetTooltipItem",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#v:iconViewSetTooltipItem"
            })

    #endif

    -- method IconView::unselect_all
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "icon_view"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "IconView" }
    --           , argCType = Just "GtkIconView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `GtkIconView`." , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_icon_view_unselect_all" gtk_icon_view_unselect_all ::
        Ptr IconView ->                         -- icon_view : TInterface (Name {namespace = "Gtk", name = "IconView"})
        IO ()

    {-# DEPRECATED iconViewUnselectAll ["(Since version 4.10)","Use t'GI.Gtk.Objects.GridView.GridView' instead"] #-}
    -- | Unselects all the icons.
    iconViewUnselectAll ::
        (B.CallStack.HasCallStack, MonadIO m, IsIconView a) =>
        a
        -- ^ /@iconView@/: A @GtkIconView@.
        -> m ()
    iconViewUnselectAll :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsIconView a) =>
    a -> m ()
    iconViewUnselectAll a
    iconView = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        iconView' <- a -> IO (Ptr IconView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    iconView
        gtk_icon_view_unselect_all iconView'
        touchManagedPtr iconView
        return ()

    #if defined(ENABLE_OVERLOADING)
    data IconViewUnselectAllMethodInfo
    instance (signature ~ (m ()), MonadIO m, IsIconView a) => O.OverloadedMethod IconViewUnselectAllMethodInfo a signature where
        overloadedMethod = iconViewUnselectAll

    instance O.OverloadedMethodInfo IconViewUnselectAllMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.iconViewUnselectAll",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#v:iconViewUnselectAll"
            })

    #endif

    -- method IconView::unselect_path
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "icon_view"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "IconView" }
    --           , argCType = Just "GtkIconView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `GtkIconView`." , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "path"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "TreePath" }
    --           , argCType = Just "GtkTreePath*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "The `GtkTreePath` to be unselected."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_icon_view_unselect_path" gtk_icon_view_unselect_path ::
        Ptr IconView ->                         -- icon_view : TInterface (Name {namespace = "Gtk", name = "IconView"})
        Ptr Gtk.TreePath.TreePath ->            -- path : TInterface (Name {namespace = "Gtk", name = "TreePath"})
        IO ()

    {-# DEPRECATED iconViewUnselectPath ["(Since version 4.10)","Use t'GI.Gtk.Objects.GridView.GridView' instead"] #-}
    -- | Unselects the row at /@path@/.
    iconViewUnselectPath ::
        (B.CallStack.HasCallStack, MonadIO m, IsIconView a) =>
        a
        -- ^ /@iconView@/: A @GtkIconView@.
        -> Gtk.TreePath.TreePath
        -- ^ /@path@/: The @GtkTreePath@ to be unselected.
        -> m ()
    iconViewUnselectPath :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsIconView a) =>
    a -> TreePath -> m ()
    iconViewUnselectPath a
    iconView TreePath
    path = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        iconView' <- a -> IO (Ptr IconView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    iconView
        path' <- unsafeManagedPtrGetPtr path
        gtk_icon_view_unselect_path iconView' path'
        touchManagedPtr iconView
        touchManagedPtr path
        return ()

    #if defined(ENABLE_OVERLOADING)
    data IconViewUnselectPathMethodInfo
    instance (signature ~ (Gtk.TreePath.TreePath -> m ()), MonadIO m, IsIconView a) => O.OverloadedMethod IconViewUnselectPathMethodInfo a signature where
        overloadedMethod = iconViewUnselectPath

    instance O.OverloadedMethodInfo IconViewUnselectPathMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.iconViewUnselectPath",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#v:iconViewUnselectPath"
            })

    #endif

    -- method IconView::unset_model_drag_dest
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "icon_view"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "IconView" }
    --           , argCType = Just "GtkIconView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkIconView`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_icon_view_unset_model_drag_dest" gtk_icon_view_unset_model_drag_dest ::
        Ptr IconView ->                         -- icon_view : TInterface (Name {namespace = "Gtk", name = "IconView"})
        IO ()

    {-# DEPRECATED iconViewUnsetModelDragDest ["(Since version 4.10)","Use t'GI.Gtk.Objects.GridView.GridView' instead"] #-}
    -- | Undoes the effect of 'GI.Gtk.Objects.IconView.iconViewEnableModelDragDest'. Calling this
    -- method sets @GtkIconView@:reorderable to 'P.False'.
    iconViewUnsetModelDragDest ::
        (B.CallStack.HasCallStack, MonadIO m, IsIconView a) =>
        a
        -- ^ /@iconView@/: a @GtkIconView@
        -> m ()
    iconViewUnsetModelDragDest :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsIconView a) =>
    a -> m ()
    iconViewUnsetModelDragDest a
    iconView = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        iconView' <- a -> IO (Ptr IconView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    iconView
        gtk_icon_view_unset_model_drag_dest iconView'
        touchManagedPtr iconView
        return ()

    #if defined(ENABLE_OVERLOADING)
    data IconViewUnsetModelDragDestMethodInfo
    instance (signature ~ (m ()), MonadIO m, IsIconView a) => O.OverloadedMethod IconViewUnsetModelDragDestMethodInfo a signature where
        overloadedMethod = iconViewUnsetModelDragDest

    instance O.OverloadedMethodInfo IconViewUnsetModelDragDestMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.iconViewUnsetModelDragDest",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#v:iconViewUnsetModelDragDest"
            })

    #endif

    -- method IconView::unset_model_drag_source
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "icon_view"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "IconView" }
    --           , argCType = Just "GtkIconView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GtkIconView`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_icon_view_unset_model_drag_source" gtk_icon_view_unset_model_drag_source ::
        Ptr IconView ->                         -- icon_view : TInterface (Name {namespace = "Gtk", name = "IconView"})
        IO ()

    {-# DEPRECATED iconViewUnsetModelDragSource ["(Since version 4.10)","Use t'GI.Gtk.Objects.GridView.GridView' instead"] #-}
    -- | Undoes the effect of 'GI.Gtk.Objects.IconView.iconViewEnableModelDragSource'. Calling this
    -- method sets @GtkIconView@:reorderable to 'P.False'.
    iconViewUnsetModelDragSource ::
        (B.CallStack.HasCallStack, MonadIO m, IsIconView a) =>
        a
        -- ^ /@iconView@/: a @GtkIconView@
        -> m ()
    iconViewUnsetModelDragSource :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsIconView a) =>
    a -> m ()
    iconViewUnsetModelDragSource a
    iconView = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        iconView' <- a -> IO (Ptr IconView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    iconView
        gtk_icon_view_unset_model_drag_source iconView'
        touchManagedPtr iconView
        return ()

    #if defined(ENABLE_OVERLOADING)
    data IconViewUnsetModelDragSourceMethodInfo
    instance (signature ~ (m ()), MonadIO m, IsIconView a) => O.OverloadedMethod IconViewUnsetModelDragSourceMethodInfo a signature where
        overloadedMethod = iconViewUnsetModelDragSource

    instance O.OverloadedMethodInfo IconViewUnsetModelDragSourceMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.IconView.iconViewUnsetModelDragSource",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-IconView.html#v:iconViewUnsetModelDragSource"
            })

    #endif