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

    -- | Copyright  : Will Thompson and Iñaki García Etxebarria
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria
    --
    -- Presents a large dynamic list of items.
    --
    -- @GtkListView@ uses its factory to generate one row widget for each visible
    -- item and shows them in a linear display, either vertically or horizontally.
    --
    -- The [ListView:showSeparators]("GI.Gtk.Objects.ListView#g:attr:showSeparators") property offers a simple way to
    -- display separators between the rows.
    --
    -- @GtkListView@ allows the user to select items according to the selection
    -- characteristics of the model. For models that allow multiple selected items,
    -- it is possible to turn on _rubberband selection_, using
    -- [ListView:enableRubberband]("GI.Gtk.Objects.ListView#g:attr:enableRubberband").
    --
    -- If you need multiple columns with headers, see t'GI.Gtk.Objects.ColumnView.ColumnView'.
    --
    -- To learn more about the list widget framework, see the
    -- <https://docs.gtk.org/gtk4/section-list-widget.html overview>.
    --
    -- An example of using @GtkListView@:
    --
    -- === /c code/
    -- >static void
    -- >setup_listitem_cb (GtkListItemFactory *factory,
    -- >                   GtkListItem        *list_item)
    -- >{
    -- >  GtkWidget *image;
    -- >
    -- >  image = gtk_image_new ();
    -- >  gtk_image_set_icon_size (GTK_IMAGE (image), GTK_ICON_SIZE_LARGE);
    -- >  gtk_list_item_set_child (list_item, image);
    -- >}
    -- >
    -- >static void
    -- >bind_listitem_cb (GtkListItemFactory *factory,
    -- >                  GtkListItem        *list_item)
    -- >{
    -- >  GtkWidget *image;
    -- >  GAppInfo *app_info;
    -- >
    -- >  image = gtk_list_item_get_child (list_item);
    -- >  app_info = gtk_list_item_get_item (list_item);
    -- >  gtk_image_set_from_gicon (GTK_IMAGE (image), g_app_info_get_icon (app_info));
    -- >}
    -- >
    -- >static void
    -- >activate_cb (GtkListView  *list,
    -- >             guint         position,
    -- >             gpointer      unused)
    -- >{
    -- >  GAppInfo *app_info;
    -- >
    -- >  app_info = g_list_model_get_item (G_LIST_MODEL (gtk_list_view_get_model (list)), position);
    -- >  g_app_info_launch (app_info, NULL, NULL, NULL);
    -- >  g_object_unref (app_info);
    -- >}
    -- >
    -- >...
    -- >
    -- >  model = create_application_list ();
    -- >
    -- >  factory = gtk_signal_list_item_factory_new ();
    -- >  g_signal_connect (factory, "setup", G_CALLBACK (setup_listitem_cb), NULL);
    -- >  g_signal_connect (factory, "bind", G_CALLBACK (bind_listitem_cb), NULL);
    -- >
    -- >  list = gtk_list_view_new (GTK_SELECTION_MODEL (gtk_single_selection_new (model)), factory);
    -- >
    -- >  g_signal_connect (list, "activate", G_CALLBACK (activate_cb), NULL);
    -- >
    -- >  gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (sw), list);
    --
    --
    -- = Actions
    --
    -- @GtkListView@ defines a set of built-in actions:
    --
    -- * @list.activate-item@ activates the item at given position by emitting
    --   the [ListView::activate]("GI.Gtk.Objects.ListView#g:signal:activate") signal.
    --
    --
    -- = CSS nodes
    --
    --
    --
    -- >listview[.separators][.rich-list][.navigation-sidebar][.data-table]
    -- >├── row[.activatable]
    -- >│
    -- >├── row[.activatable]
    -- >│
    -- >┊
    -- >╰── [rubberband]
    --
    --
    -- @GtkListView@ uses a single CSS node named @listview@. It may carry the
    -- @.separators@ style class, when [ListView:showSeparators]("GI.Gtk.Objects.ListView#g:attr:showSeparators")
    -- property is set. Each child widget uses a single CSS node named @row@.
    -- If the [ListItem:activatable]("GI.Gtk.Objects.ListItem#g:attr:activatable") property is set, the
    -- corresponding row will have the @.activatable@ style class. For
    -- rubberband selection, a node with name @rubberband@ is used.
    --
    -- The main listview node may also carry style classes to select
    -- the style of <https://docs.gtk.org/gtk4/section-list-widget.html#list-styles list presentation>:
    -- .rich-list, .navigation-sidebar or .data-table.
    --
    -- = Accessibility
    --
    -- @GtkListView@ uses the 'GI.Gtk.Enums.AccessibleRoleList' role, and the list
    -- items use the 'GI.Gtk.Enums.AccessibleRoleListItem' role.

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

    module GI.Gtk.Objects.ListView
        (

    -- * Exported types
        ListView(..)                            ,
        IsListView                              ,
        toListView                              ,

     -- * Methods
    -- |
    --
    --  === __Click to display all available methods, including inherited ones__
    -- ==== Methods
    -- [actionSetEnabled]("GI.Gtk.Objects.Widget#g:method:actionSetEnabled"), [activate]("GI.Gtk.Objects.Widget#g:method:activate"), [activateAction]("GI.Gtk.Objects.Widget#g:method:activateAction"), [activateDefault]("GI.Gtk.Objects.Widget#g:method:activateDefault"), [addController]("GI.Gtk.Objects.Widget#g:method:addController"), [addCssClass]("GI.Gtk.Objects.Widget#g:method:addCssClass"), [addMnemonicLabel]("GI.Gtk.Objects.Widget#g:method:addMnemonicLabel"), [addTickCallback]("GI.Gtk.Objects.Widget#g:method:addTickCallback"), [allocate]("GI.Gtk.Objects.Widget#g:method:allocate"), [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"), [computeBounds]("GI.Gtk.Objects.Widget#g:method:computeBounds"), [computeExpand]("GI.Gtk.Objects.Widget#g:method:computeExpand"), [computePoint]("GI.Gtk.Objects.Widget#g:method:computePoint"), [computeTransform]("GI.Gtk.Objects.Widget#g:method:computeTransform"), [contains]("GI.Gtk.Objects.Widget#g:method:contains"), [createPangoContext]("GI.Gtk.Objects.Widget#g:method:createPangoContext"), [createPangoLayout]("GI.Gtk.Objects.Widget#g:method:createPangoLayout"), [disposeTemplate]("GI.Gtk.Objects.Widget#g:method:disposeTemplate"), [dragCheckThreshold]("GI.Gtk.Objects.Widget#g:method:dragCheckThreshold"), [errorBell]("GI.Gtk.Objects.Widget#g:method:errorBell"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [grabFocus]("GI.Gtk.Objects.Widget#g:method:grabFocus"), [hasCssClass]("GI.Gtk.Objects.Widget#g:method:hasCssClass"), [hasDefault]("GI.Gtk.Objects.Widget#g:method:hasDefault"), [hasFocus]("GI.Gtk.Objects.Widget#g:method:hasFocus"), [hasVisibleFocus]("GI.Gtk.Objects.Widget#g:method:hasVisibleFocus"), [hide]("GI.Gtk.Objects.Widget#g:method:hide"), [inDestruction]("GI.Gtk.Objects.Widget#g:method:inDestruction"), [initTemplate]("GI.Gtk.Objects.Widget#g:method:initTemplate"), [insertActionGroup]("GI.Gtk.Objects.Widget#g:method:insertActionGroup"), [insertAfter]("GI.Gtk.Objects.Widget#g:method:insertAfter"), [insertBefore]("GI.Gtk.Objects.Widget#g:method:insertBefore"), [isAncestor]("GI.Gtk.Objects.Widget#g:method:isAncestor"), [isDrawable]("GI.Gtk.Objects.Widget#g:method:isDrawable"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [isFocus]("GI.Gtk.Objects.Widget#g:method:isFocus"), [isSensitive]("GI.Gtk.Objects.Widget#g:method:isSensitive"), [isVisible]("GI.Gtk.Objects.Widget#g:method:isVisible"), [keynavFailed]("GI.Gtk.Objects.Widget#g:method:keynavFailed"), [listMnemonicLabels]("GI.Gtk.Objects.Widget#g:method:listMnemonicLabels"), [map]("GI.Gtk.Objects.Widget#g:method:map"), [measure]("GI.Gtk.Objects.Widget#g:method:measure"), [mnemonicActivate]("GI.Gtk.Objects.Widget#g:method:mnemonicActivate"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [observeChildren]("GI.Gtk.Objects.Widget#g:method:observeChildren"), [observeControllers]("GI.Gtk.Objects.Widget#g:method:observeControllers"), [pick]("GI.Gtk.Objects.Widget#g:method:pick"), [queueAllocate]("GI.Gtk.Objects.Widget#g:method:queueAllocate"), [queueDraw]("GI.Gtk.Objects.Widget#g:method:queueDraw"), [queueResize]("GI.Gtk.Objects.Widget#g:method:queueResize"), [realize]("GI.Gtk.Objects.Widget#g:method:realize"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [removeController]("GI.Gtk.Objects.Widget#g:method:removeController"), [removeCssClass]("GI.Gtk.Objects.Widget#g:method:removeCssClass"), [removeMnemonicLabel]("GI.Gtk.Objects.Widget#g:method:removeMnemonicLabel"), [removeTickCallback]("GI.Gtk.Objects.Widget#g:method:removeTickCallback"), [resetProperty]("GI.Gtk.Interfaces.Accessible#g:method:resetProperty"), [resetRelation]("GI.Gtk.Interfaces.Accessible#g:method:resetRelation"), [resetState]("GI.Gtk.Interfaces.Accessible#g:method:resetState"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [scrollTo]("GI.Gtk.Objects.ListView#g:method:scrollTo"), [shouldLayout]("GI.Gtk.Objects.Widget#g:method:shouldLayout"), [show]("GI.Gtk.Objects.Widget#g:method:show"), [sizeAllocate]("GI.Gtk.Objects.Widget#g:method:sizeAllocate"), [snapshotChild]("GI.Gtk.Objects.Widget#g:method:snapshotChild"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [translateCoordinates]("GI.Gtk.Objects.Widget#g:method:translateCoordinates"), [triggerTooltipQuery]("GI.Gtk.Objects.Widget#g:method:triggerTooltipQuery"), [unmap]("GI.Gtk.Objects.Widget#g:method:unmap"), [unparent]("GI.Gtk.Objects.Widget#g:method:unparent"), [unrealize]("GI.Gtk.Objects.Widget#g:method:unrealize"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [unsetStateFlags]("GI.Gtk.Objects.Widget#g:method:unsetStateFlags"), [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"), [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"), [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"), [getChildVisible]("GI.Gtk.Objects.Widget#g:method:getChildVisible"), [getClipboard]("GI.Gtk.Objects.Widget#g:method:getClipboard"), [getColor]("GI.Gtk.Objects.Widget#g:method:getColor"), [getCssClasses]("GI.Gtk.Objects.Widget#g:method:getCssClasses"), [getCssName]("GI.Gtk.Objects.Widget#g:method:getCssName"), [getCursor]("GI.Gtk.Objects.Widget#g:method:getCursor"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getDirection]("GI.Gtk.Objects.Widget#g:method:getDirection"), [getDisplay]("GI.Gtk.Objects.Widget#g:method:getDisplay"), [getEnableRubberband]("GI.Gtk.Objects.ListView#g:method:getEnableRubberband"), [getFactory]("GI.Gtk.Objects.ListView#g:method:getFactory"), [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"), [getHeaderFactory]("GI.Gtk.Objects.ListView#g:method:getHeaderFactory"), [getHeight]("GI.Gtk.Objects.Widget#g:method:getHeight"), [getHexpand]("GI.Gtk.Objects.Widget#g:method:getHexpand"), [getHexpandSet]("GI.Gtk.Objects.Widget#g:method:getHexpandSet"), [getHscrollPolicy]("GI.Gtk.Interfaces.Scrollable#g:method:getHscrollPolicy"), [getLastChild]("GI.Gtk.Objects.Widget#g:method:getLastChild"), [getLayoutManager]("GI.Gtk.Objects.Widget#g:method:getLayoutManager"), [getLimitEvents]("GI.Gtk.Objects.Widget#g:method:getLimitEvents"), [getMapped]("GI.Gtk.Objects.Widget#g:method:getMapped"), [getMarginBottom]("GI.Gtk.Objects.Widget#g:method:getMarginBottom"), [getMarginEnd]("GI.Gtk.Objects.Widget#g:method:getMarginEnd"), [getMarginStart]("GI.Gtk.Objects.Widget#g:method:getMarginStart"), [getMarginTop]("GI.Gtk.Objects.Widget#g:method:getMarginTop"), [getModel]("GI.Gtk.Objects.ListView#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"), [getOrientation]("GI.Gtk.Interfaces.Orientable#g:method:getOrientation"), [getOverflow]("GI.Gtk.Objects.Widget#g:method:getOverflow"), [getPangoContext]("GI.Gtk.Objects.Widget#g:method:getPangoContext"), [getParent]("GI.Gtk.Objects.Widget#g:method:getParent"), [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"), [getRequestMode]("GI.Gtk.Objects.Widget#g:method:getRequestMode"), [getRoot]("GI.Gtk.Objects.Widget#g:method:getRoot"), [getScaleFactor]("GI.Gtk.Objects.Widget#g:method:getScaleFactor"), [getSensitive]("GI.Gtk.Objects.Widget#g:method:getSensitive"), [getSettings]("GI.Gtk.Objects.Widget#g:method:getSettings"), [getShowSeparators]("GI.Gtk.Objects.ListView#g:method:getShowSeparators"), [getSingleClickActivate]("GI.Gtk.Objects.ListView#g:method:getSingleClickActivate"), [getSize]("GI.Gtk.Objects.Widget#g:method:getSize"), [getSizeRequest]("GI.Gtk.Objects.Widget#g:method:getSizeRequest"), [getStateFlags]("GI.Gtk.Objects.Widget#g:method:getStateFlags"), [getStyleContext]("GI.Gtk.Objects.Widget#g:method:getStyleContext"), [getTabBehavior]("GI.Gtk.Objects.ListView#g:method:getTabBehavior"), [getTemplateChild]("GI.Gtk.Objects.Widget#g:method:getTemplateChild"), [getTooltipMarkup]("GI.Gtk.Objects.Widget#g:method:getTooltipMarkup"), [getTooltipText]("GI.Gtk.Objects.Widget#g:method:getTooltipText"), [getVadjustment]("GI.Gtk.Interfaces.Scrollable#g:method:getVadjustment"), [getValign]("GI.Gtk.Objects.Widget#g:method:getValign"), [getVexpand]("GI.Gtk.Objects.Widget#g:method:getVexpand"), [getVexpandSet]("GI.Gtk.Objects.Widget#g:method:getVexpandSet"), [getVisible]("GI.Gtk.Objects.Widget#g:method:getVisible"), [getVscrollPolicy]("GI.Gtk.Interfaces.Scrollable#g:method:getVscrollPolicy"), [getWidth]("GI.Gtk.Objects.Widget#g:method:getWidth").
    --
    -- ==== Setters
    -- [setAccessibleParent]("GI.Gtk.Interfaces.Accessible#g:method:setAccessibleParent"), [setCanFocus]("GI.Gtk.Objects.Widget#g:method:setCanFocus"), [setCanTarget]("GI.Gtk.Objects.Widget#g:method:setCanTarget"), [setChildVisible]("GI.Gtk.Objects.Widget#g:method:setChildVisible"), [setCssClasses]("GI.Gtk.Objects.Widget#g:method:setCssClasses"), [setCursor]("GI.Gtk.Objects.Widget#g:method:setCursor"), [setCursorFromName]("GI.Gtk.Objects.Widget#g:method:setCursorFromName"), [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setDirection]("GI.Gtk.Objects.Widget#g:method:setDirection"), [setEnableRubberband]("GI.Gtk.Objects.ListView#g:method:setEnableRubberband"), [setFactory]("GI.Gtk.Objects.ListView#g:method:setFactory"), [setFocusChild]("GI.Gtk.Objects.Widget#g:method:setFocusChild"), [setFocusOnClick]("GI.Gtk.Objects.Widget#g:method:setFocusOnClick"), [setFocusable]("GI.Gtk.Objects.Widget#g:method:setFocusable"), [setFontMap]("GI.Gtk.Objects.Widget#g:method:setFontMap"), [setFontOptions]("GI.Gtk.Objects.Widget#g:method:setFontOptions"), [setHadjustment]("GI.Gtk.Interfaces.Scrollable#g:method:setHadjustment"), [setHalign]("GI.Gtk.Objects.Widget#g:method:setHalign"), [setHasTooltip]("GI.Gtk.Objects.Widget#g:method:setHasTooltip"), [setHeaderFactory]("GI.Gtk.Objects.ListView#g:method:setHeaderFactory"), [setHexpand]("GI.Gtk.Objects.Widget#g:method:setHexpand"), [setHexpandSet]("GI.Gtk.Objects.Widget#g:method:setHexpandSet"), [setHscrollPolicy]("GI.Gtk.Interfaces.Scrollable#g:method:setHscrollPolicy"), [setLayoutManager]("GI.Gtk.Objects.Widget#g:method:setLayoutManager"), [setLimitEvents]("GI.Gtk.Objects.Widget#g:method:setLimitEvents"), [setMarginBottom]("GI.Gtk.Objects.Widget#g:method:setMarginBottom"), [setMarginEnd]("GI.Gtk.Objects.Widget#g:method:setMarginEnd"), [setMarginStart]("GI.Gtk.Objects.Widget#g:method:setMarginStart"), [setMarginTop]("GI.Gtk.Objects.Widget#g:method:setMarginTop"), [setModel]("GI.Gtk.Objects.ListView#g:method:setModel"), [setName]("GI.Gtk.Objects.Widget#g:method:setName"), [setOpacity]("GI.Gtk.Objects.Widget#g:method:setOpacity"), [setOrientation]("GI.Gtk.Interfaces.Orientable#g:method:setOrientation"), [setOverflow]("GI.Gtk.Objects.Widget#g:method:setOverflow"), [setParent]("GI.Gtk.Objects.Widget#g:method:setParent"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setReceivesDefault]("GI.Gtk.Objects.Widget#g:method:setReceivesDefault"), [setSensitive]("GI.Gtk.Objects.Widget#g:method:setSensitive"), [setShowSeparators]("GI.Gtk.Objects.ListView#g:method:setShowSeparators"), [setSingleClickActivate]("GI.Gtk.Objects.ListView#g:method:setSingleClickActivate"), [setSizeRequest]("GI.Gtk.Objects.Widget#g:method:setSizeRequest"), [setStateFlags]("GI.Gtk.Objects.Widget#g:method:setStateFlags"), [setTabBehavior]("GI.Gtk.Objects.ListView#g:method:setTabBehavior"), [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)
        ResolveListViewMethod                   ,
    #endif

    -- ** getEnableRubberband #method:getEnableRubberband#

    #if defined(ENABLE_OVERLOADING)
        ListViewGetEnableRubberbandMethodInfo   ,
    #endif
        listViewGetEnableRubberband             ,

    -- ** getFactory #method:getFactory#

    #if defined(ENABLE_OVERLOADING)
        ListViewGetFactoryMethodInfo            ,
    #endif
        listViewGetFactory                      ,

    -- ** getHeaderFactory #method:getHeaderFactory#

    #if defined(ENABLE_OVERLOADING)
        ListViewGetHeaderFactoryMethodInfo      ,
    #endif
        listViewGetHeaderFactory                ,

    -- ** getModel #method:getModel#

    #if defined(ENABLE_OVERLOADING)
        ListViewGetModelMethodInfo              ,
    #endif
        listViewGetModel                        ,

    -- ** getShowSeparators #method:getShowSeparators#

    #if defined(ENABLE_OVERLOADING)
        ListViewGetShowSeparatorsMethodInfo     ,
    #endif
        listViewGetShowSeparators               ,

    -- ** getSingleClickActivate #method:getSingleClickActivate#

    #if defined(ENABLE_OVERLOADING)
        ListViewGetSingleClickActivateMethodInfo,
    #endif
        listViewGetSingleClickActivate          ,

    -- ** getTabBehavior #method:getTabBehavior#

    #if defined(ENABLE_OVERLOADING)
        ListViewGetTabBehaviorMethodInfo        ,
    #endif
        listViewGetTabBehavior                  ,

    -- ** new #method:new#

        listViewNew                             ,

    -- ** scrollTo #method:scrollTo#

    #if defined(ENABLE_OVERLOADING)
        ListViewScrollToMethodInfo              ,
    #endif
        listViewScrollTo                        ,

    -- ** setEnableRubberband #method:setEnableRubberband#

    #if defined(ENABLE_OVERLOADING)
        ListViewSetEnableRubberbandMethodInfo   ,
    #endif
        listViewSetEnableRubberband             ,

    -- ** setFactory #method:setFactory#

    #if defined(ENABLE_OVERLOADING)
        ListViewSetFactoryMethodInfo            ,
    #endif
        listViewSetFactory                      ,

    -- ** setHeaderFactory #method:setHeaderFactory#

    #if defined(ENABLE_OVERLOADING)
        ListViewSetHeaderFactoryMethodInfo      ,
    #endif
        listViewSetHeaderFactory                ,

    -- ** setModel #method:setModel#

    #if defined(ENABLE_OVERLOADING)
        ListViewSetModelMethodInfo              ,
    #endif
        listViewSetModel                        ,

    -- ** setShowSeparators #method:setShowSeparators#

    #if defined(ENABLE_OVERLOADING)
        ListViewSetShowSeparatorsMethodInfo     ,
    #endif
        listViewSetShowSeparators               ,

    -- ** setSingleClickActivate #method:setSingleClickActivate#

    #if defined(ENABLE_OVERLOADING)
        ListViewSetSingleClickActivateMethodInfo,
    #endif
        listViewSetSingleClickActivate          ,

    -- ** setTabBehavior #method:setTabBehavior#

    #if defined(ENABLE_OVERLOADING)
        ListViewSetTabBehaviorMethodInfo        ,
    #endif
        listViewSetTabBehavior                  ,

     -- * Properties

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

    #if defined(ENABLE_OVERLOADING)
        ListViewEnableRubberbandPropertyInfo    ,
    #endif
        constructListViewEnableRubberband       ,
        getListViewEnableRubberband             ,
    #if defined(ENABLE_OVERLOADING)
        listViewEnableRubberband                ,
    #endif
        setListViewEnableRubberband             ,

    -- ** factory #attr:factory#
    -- | Factory for populating list items.
    --
    -- The factory must be for configuring t'GI.Gtk.Objects.ListItem.ListItem' objects.

    #if defined(ENABLE_OVERLOADING)
        ListViewFactoryPropertyInfo             ,
    #endif
        clearListViewFactory                    ,
        constructListViewFactory                ,
        getListViewFactory                      ,
    #if defined(ENABLE_OVERLOADING)
        listViewFactory                         ,
    #endif
        setListViewFactory                      ,

    -- ** headerFactory #attr:headerFactory#
    -- | Factory for creating header widgets.
    --
    -- The factory must be for configuring t'GI.Gtk.Objects.ListHeader.ListHeader' objects.
    --
    -- /Since: 4.12/

    #if defined(ENABLE_OVERLOADING)
        ListViewHeaderFactoryPropertyInfo       ,
    #endif
        clearListViewHeaderFactory              ,
        constructListViewHeaderFactory          ,
        getListViewHeaderFactory                ,
    #if defined(ENABLE_OVERLOADING)
        listViewHeaderFactory                   ,
    #endif
        setListViewHeaderFactory                ,

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

    #if defined(ENABLE_OVERLOADING)
        ListViewModelPropertyInfo               ,
    #endif
        clearListViewModel                      ,
        constructListViewModel                  ,
        getListViewModel                        ,
    #if defined(ENABLE_OVERLOADING)
        listViewModel                           ,
    #endif
        setListViewModel                        ,

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

    #if defined(ENABLE_OVERLOADING)
        ListViewShowSeparatorsPropertyInfo      ,
    #endif
        constructListViewShowSeparators         ,
        getListViewShowSeparators               ,
    #if defined(ENABLE_OVERLOADING)
        listViewShowSeparators                  ,
    #endif
        setListViewShowSeparators               ,

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

    #if defined(ENABLE_OVERLOADING)
        ListViewSingleClickActivatePropertyInfo ,
    #endif
        constructListViewSingleClickActivate    ,
        getListViewSingleClickActivate          ,
    #if defined(ENABLE_OVERLOADING)
        listViewSingleClickActivate             ,
    #endif
        setListViewSingleClickActivate          ,

    -- ** tabBehavior #attr:tabBehavior#
    -- | Behavior of the \<kbd>Tab\<\/kbd> key
    --
    -- /Since: 4.12/

    #if defined(ENABLE_OVERLOADING)
        ListViewTabBehaviorPropertyInfo         ,
    #endif
        constructListViewTabBehavior            ,
        getListViewTabBehavior                  ,
    #if defined(ENABLE_OVERLOADING)
        listViewTabBehavior                     ,
    #endif
        setListViewTabBehavior                  ,

     -- * Signals

    -- ** activate #signal:activate#

        ListViewActivateCallback                ,
    #if defined(ENABLE_OVERLOADING)
        ListViewActivateSignalInfo              ,
    #endif
        afterListViewActivate                   ,
        onListViewActivate                      ,

        ) 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.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.ConstraintTarget as Gtk.ConstraintTarget
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Native as Gtk.Native
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Orientable as Gtk.Orientable
    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.SelectionModel as Gtk.SelectionModel
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.StyleProvider as Gtk.StyleProvider
    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.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.ListBase as Gtk.ListBase
    import {-# SOURCE #-} qualified GI.Gtk.Objects.ListItemFactory as Gtk.ListItemFactory
    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.Bitset as Gtk.Bitset
    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.ScrollInfo as Gtk.ScrollInfo
    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 {-# 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.ConstraintTarget as Gtk.ConstraintTarget
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Orientable as Gtk.Orientable
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Scrollable as Gtk.Scrollable
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.SelectionModel as Gtk.SelectionModel
    import {-# SOURCE #-} qualified GI.Gtk.Objects.ListBase as Gtk.ListBase
    import {-# SOURCE #-} qualified GI.Gtk.Objects.ListItemFactory as Gtk.ListItemFactory
    import {-# SOURCE #-} qualified GI.Gtk.Objects.Widget as Gtk.Widget
    import {-# SOURCE #-} qualified GI.Gtk.Structs.ScrollInfo as Gtk.ScrollInfo

    #endif

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

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

    foreign import ccall "gtk_list_view_get_type"
        c_gtk_list_view_get_type :: IO B.Types.GType

    instance B.Types.TypedObject ListView where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_list_view_get_type

    instance B.Types.GObject ListView

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

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

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

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

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

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

    #endif

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

    #endif

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

    type C_ListViewActivateCallback =
        Ptr ListView ->                         -- object
        Word32 ->
        Ptr () ->                               -- user_data
        IO ()

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

    wrap_ListViewActivateCallback ::
        GObject a => (a -> ListViewActivateCallback) ->
        C_ListViewActivateCallback
    wrap_ListViewActivateCallback :: forall a.
    GObject a =>
    (a -> ListViewActivateCallback) -> C_ListViewActivateCallback
    wrap_ListViewActivateCallback a -> ListViewActivateCallback
    gi'cb Ptr ListView
    gi'selfPtr Word32
    position Ptr ()
    _ = do
        Ptr ListView -> (ListView -> IO ()) -> IO ()
    forall o b.
    (HasCallStack, GObject o) =>
    Ptr o -> (o -> IO b) -> IO b
    B.ManagedPtr.withNewObject Ptr ListView
    gi'selfPtr ((ListView -> IO ()) -> IO ()) -> (ListView -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \ListView
    gi'self -> a -> ListViewActivateCallback
    gi'cb (ListView -> a
    forall a b. Coercible a b => a -> b
    Coerce.coerce ListView
    gi'self)  Word32
    position

    -- | Connect a signal handler for the [activate](#signal:activate) signal, to be run before the default handler.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Signals.on' listView #activate callback
    -- @
    --
    --
    onListViewActivate :: (IsListView a, MonadIO m) => a -> ((?self :: a) => ListViewActivateCallback) -> m SignalHandlerId
    onListViewActivate :: forall a (m :: * -> *).
    (IsListView a, MonadIO m) =>
    a -> ((?self::a) => ListViewActivateCallback) -> m SignalHandlerId
    onListViewActivate a
    obj (?self::a) => ListViewActivateCallback
    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 -> ListViewActivateCallback
    wrapped a
    self = let ?self = a
    ?self::a
    self in (?self::a) => ListViewActivateCallback
    ListViewActivateCallback
    cb
        let wrapped' :: C_ListViewActivateCallback
    wrapped' = (a -> ListViewActivateCallback) -> C_ListViewActivateCallback
    forall a.
    GObject a =>
    (a -> ListViewActivateCallback) -> C_ListViewActivateCallback
    wrap_ListViewActivateCallback a -> ListViewActivateCallback
    wrapped
        wrapped'' <- C_ListViewActivateCallback
    -> IO (FunPtr C_ListViewActivateCallback)
    mk_ListViewActivateCallback C_ListViewActivateCallback
    wrapped'
        connectSignalFunPtr obj "activate" wrapped'' SignalConnectBefore Nothing

    -- | Connect a signal handler for the [activate](#signal:activate) signal, to be run after the default handler.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Signals.after' listView #activate callback
    -- @
    --
    --
    --
    -- By default the object invoking the signal is not passed to the callback.
    -- If you need to access it, you can use the implit @?self@ parameter.
    -- Note that this requires activating the @ImplicitParams@ GHC extension.
    --
    afterListViewActivate :: (IsListView a, MonadIO m) => a -> ((?self :: a) => ListViewActivateCallback) -> m SignalHandlerId
    afterListViewActivate :: forall a (m :: * -> *).
    (IsListView a, MonadIO m) =>
    a -> ((?self::a) => ListViewActivateCallback) -> m SignalHandlerId
    afterListViewActivate a
    obj (?self::a) => ListViewActivateCallback
    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 -> ListViewActivateCallback
    wrapped a
    self = let ?self = a
    ?self::a
    self in (?self::a) => ListViewActivateCallback
    ListViewActivateCallback
    cb
        let wrapped' :: C_ListViewActivateCallback
    wrapped' = (a -> ListViewActivateCallback) -> C_ListViewActivateCallback
    forall a.
    GObject a =>
    (a -> ListViewActivateCallback) -> C_ListViewActivateCallback
    wrap_ListViewActivateCallback a -> ListViewActivateCallback
    wrapped
        wrapped'' <- C_ListViewActivateCallback
    -> IO (FunPtr C_ListViewActivateCallback)
    mk_ListViewActivateCallback C_ListViewActivateCallback
    wrapped'
        connectSignalFunPtr obj "activate" wrapped'' SignalConnectAfter Nothing

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

    #endif

    --- XXX Duplicated object with different types:
      --- Name {namespace = "Gtk", name = "ListBase"} -> Property {propName = "orientation", propType = TInterface (Name {namespace = "Gtk", name = "Orientation"}), propFlags = [PropertyReadable,PropertyWritable], propReadNullable = Nothing, propWriteNullable = Nothing, propSetter = Nothing, propGetter = Nothing, propTransfer = TransferNothing, propDoc = Documentation {rawDocText = Just "The orientation of the list. See GtkOrientable:orientation\nfor details.", sinceVersion = Nothing}, propDeprecated = Nothing}
      --- Name {namespace = "Gtk", name = "Orientable"} -> Property {propName = "orientation", propType = TInterface (Name {namespace = "Gtk", name = "Orientation"}), propFlags = [PropertyReadable,PropertyWritable], propReadNullable = Just False, propWriteNullable = Just False, propSetter = Just "set_orientation", propGetter = Just "get_orientation", propTransfer = TransferNothing, propDoc = Documentation {rawDocText = Just "The orientation of the orientable.", sinceVersion = Nothing}, propDeprecated = Nothing}
    -- VVV Prop "enable-rubberband"
       -- Type: TBasicType TBoolean
       -- Flags: [PropertyReadable,PropertyWritable]
       -- Nullable: (Just False,Just False)

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

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

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

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

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

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

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

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

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

    #if defined(ENABLE_OVERLOADING)
    data ListViewFactoryPropertyInfo
    instance AttrInfo ListViewFactoryPropertyInfo where
        type AttrAllowedOps ListViewFactoryPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrBaseTypeConstraint ListViewFactoryPropertyInfo = IsListView
        type AttrSetTypeConstraint ListViewFactoryPropertyInfo = Gtk.ListItemFactory.IsListItemFactory
        type AttrTransferTypeConstraint ListViewFactoryPropertyInfo = Gtk.ListItemFactory.IsListItemFactory
        type AttrTransferType ListViewFactoryPropertyInfo = Gtk.ListItemFactory.ListItemFactory
        type AttrGetType ListViewFactoryPropertyInfo = (Maybe Gtk.ListItemFactory.ListItemFactory)
        type AttrLabel ListViewFactoryPropertyInfo = "factory"
        type AttrOrigin ListViewFactoryPropertyInfo = ListView
        attrGet = getListViewFactory
        attrSet = setListViewFactory
        attrPut = undefined
        attrTransfer _ v = do
            unsafeCastTo Gtk.ListItemFactory.ListItemFactory v
        attrConstruct = constructListViewFactory
        attrClear = clearListViewFactory
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.ListView.factory"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-ListView.html#g:attr:factory"
            })
    #endif

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

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

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

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

    -- | Set the value of the “@header-factory@” property to `Nothing`.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.clear' #headerFactory
    -- @
    clearListViewHeaderFactory :: (MonadIO m, IsListView o) => o -> m ()
    clearListViewHeaderFactory :: forall (m :: * -> *) o. (MonadIO m, IsListView o) => o -> m ()
    clearListViewHeaderFactory 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 ListItemFactory -> IO ()
    forall a b.
    (GObject a, GObject b) =>
    a -> String -> Maybe b -> IO ()
    B.Properties.setObjectPropertyObject o
    obj String
    "header-factory" (Maybe ListItemFactory
    forall a. Maybe a
    Nothing :: Maybe Gtk.ListItemFactory.ListItemFactory)

    #if defined(ENABLE_OVERLOADING)
    data ListViewHeaderFactoryPropertyInfo
    instance AttrInfo ListViewHeaderFactoryPropertyInfo where
        type AttrAllowedOps ListViewHeaderFactoryPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrBaseTypeConstraint ListViewHeaderFactoryPropertyInfo = IsListView
        type AttrSetTypeConstraint ListViewHeaderFactoryPropertyInfo = Gtk.ListItemFactory.IsListItemFactory
        type AttrTransferTypeConstraint ListViewHeaderFactoryPropertyInfo = Gtk.ListItemFactory.IsListItemFactory
        type AttrTransferType ListViewHeaderFactoryPropertyInfo = Gtk.ListItemFactory.ListItemFactory
        type AttrGetType ListViewHeaderFactoryPropertyInfo = (Maybe Gtk.ListItemFactory.ListItemFactory)
        type AttrLabel ListViewHeaderFactoryPropertyInfo = "header-factory"
        type AttrOrigin ListViewHeaderFactoryPropertyInfo = ListView
        attrGet = getListViewHeaderFactory
        attrSet = setListViewHeaderFactory
        attrPut = undefined
        attrTransfer _ v = do
            unsafeCastTo Gtk.ListItemFactory.ListItemFactory v
        attrConstruct = constructListViewHeaderFactory
        attrClear = clearListViewHeaderFactory
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.ListView.headerFactory"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-ListView.html#g:attr:headerFactory"
            })
    #endif

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

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

    -- | Set the value of the “@model@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' listView [ #model 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setListViewModel :: (MonadIO m, IsListView o, Gtk.SelectionModel.IsSelectionModel a) => o -> a -> m ()
    setListViewModel :: forall (m :: * -> *) o a.
    (MonadIO m, IsListView o, IsSelectionModel a) =>
    o -> a -> m ()
    setListViewModel 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`.
    constructListViewModel :: (IsListView o, MIO.MonadIO m, Gtk.SelectionModel.IsSelectionModel a) => a -> m (GValueConstruct o)
    constructListViewModel :: forall o (m :: * -> *) a.
    (IsListView o, MonadIO m, IsSelectionModel a) =>
    a -> m (GValueConstruct o)
    constructListViewModel 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
    -- @
    clearListViewModel :: (MonadIO m, IsListView o) => o -> m ()
    clearListViewModel :: forall (m :: * -> *) o. (MonadIO m, IsListView o) => o -> m ()
    clearListViewModel o
    obj = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ o -> String -> Maybe SelectionModel -> IO ()
    forall a b.
    (GObject a, GObject b) =>
    a -> String -> Maybe b -> IO ()
    B.Properties.setObjectPropertyObject o
    obj String
    "model" (Maybe SelectionModel
    forall a. Maybe a
    Nothing :: Maybe Gtk.SelectionModel.SelectionModel)

    #if defined(ENABLE_OVERLOADING)
    data ListViewModelPropertyInfo
    instance AttrInfo ListViewModelPropertyInfo where
        type AttrAllowedOps ListViewModelPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrBaseTypeConstraint ListViewModelPropertyInfo = IsListView
        type AttrSetTypeConstraint ListViewModelPropertyInfo = Gtk.SelectionModel.IsSelectionModel
        type AttrTransferTypeConstraint ListViewModelPropertyInfo = Gtk.SelectionModel.IsSelectionModel
        type AttrTransferType ListViewModelPropertyInfo = Gtk.SelectionModel.SelectionModel
        type AttrGetType ListViewModelPropertyInfo = (Maybe Gtk.SelectionModel.SelectionModel)
        type AttrLabel ListViewModelPropertyInfo = "model"
        type AttrOrigin ListViewModelPropertyInfo = ListView
        attrGet = getListViewModel
        attrSet = setListViewModel
        attrPut = undefined
        attrTransfer _ v = do
            unsafeCastTo Gtk.SelectionModel.SelectionModel v
        attrConstruct = constructListViewModel
        attrClear = clearListViewModel
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.ListView.model"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-ListView.html#g:attr:model"
            })
    #endif

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

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

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

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

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

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

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

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

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

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

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

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

    -- | Set the value of the “@tab-behavior@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' listView [ #tabBehavior 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setListViewTabBehavior :: (MonadIO m, IsListView o) => o -> Gtk.Enums.ListTabBehavior -> m ()
    setListViewTabBehavior :: forall (m :: * -> *) o.
    (MonadIO m, IsListView o) =>
    o -> ListTabBehavior -> m ()
    setListViewTabBehavior o
    obj ListTabBehavior
    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 -> ListTabBehavior -> IO ()
    forall a b.
    (GObject a, Enum b, BoxedEnum b) =>
    a -> String -> b -> IO ()
    B.Properties.setObjectPropertyEnum o
    obj String
    "tab-behavior" ListTabBehavior
    val

    -- | Construct a t'GValueConstruct' with valid value for the “@tab-behavior@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    constructListViewTabBehavior :: (IsListView o, MIO.MonadIO m) => Gtk.Enums.ListTabBehavior -> m (GValueConstruct o)
    constructListViewTabBehavior :: forall o (m :: * -> *).
    (IsListView o, MonadIO m) =>
    ListTabBehavior -> m (GValueConstruct o)
    constructListViewTabBehavior ListTabBehavior
    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 -> ListTabBehavior -> IO (GValueConstruct o)
    forall a o.
    (Enum a, BoxedEnum a) =>
    String -> a -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyEnum String
    "tab-behavior" ListTabBehavior
    val

    #if defined(ENABLE_OVERLOADING)
    data ListViewTabBehaviorPropertyInfo
    instance AttrInfo ListViewTabBehaviorPropertyInfo where
        type AttrAllowedOps ListViewTabBehaviorPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
        type AttrBaseTypeConstraint ListViewTabBehaviorPropertyInfo = IsListView
        type AttrSetTypeConstraint ListViewTabBehaviorPropertyInfo = (~) Gtk.Enums.ListTabBehavior
        type AttrTransferTypeConstraint ListViewTabBehaviorPropertyInfo = (~) Gtk.Enums.ListTabBehavior
        type AttrTransferType ListViewTabBehaviorPropertyInfo = Gtk.Enums.ListTabBehavior
        type AttrGetType ListViewTabBehaviorPropertyInfo = Gtk.Enums.ListTabBehavior
        type AttrLabel ListViewTabBehaviorPropertyInfo = "tab-behavior"
        type AttrOrigin ListViewTabBehaviorPropertyInfo = ListView
        attrGet = getListViewTabBehavior
        attrSet = setListViewTabBehavior
        attrPut = setListViewTabBehavior
        attrTransfer _ v = do
            return v
        attrConstruct = constructListViewTabBehavior
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.ListView.tabBehavior"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-ListView.html#g:attr:tabBehavior"
            })
    #endif

    #if defined(ENABLE_OVERLOADING)
    instance O.HasAttributeList ListView
    type instance O.AttributeList ListView = ListViewAttributeList
    type ListViewAttributeList = ('[ '("accessibleRole", Gtk.Accessible.AccessibleAccessibleRolePropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("canTarget", Gtk.Widget.WidgetCanTargetPropertyInfo), '("cssClasses", Gtk.Widget.WidgetCssClassesPropertyInfo), '("cssName", Gtk.Widget.WidgetCssNamePropertyInfo), '("cursor", Gtk.Widget.WidgetCursorPropertyInfo), '("enableRubberband", ListViewEnableRubberbandPropertyInfo), '("factory", ListViewFactoryPropertyInfo), '("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), '("headerFactory", ListViewHeaderFactoryPropertyInfo), '("heightRequest", Gtk.Widget.WidgetHeightRequestPropertyInfo), '("hexpand", Gtk.Widget.WidgetHexpandPropertyInfo), '("hexpandSet", Gtk.Widget.WidgetHexpandSetPropertyInfo), '("hscrollPolicy", Gtk.Scrollable.ScrollableHscrollPolicyPropertyInfo), '("layoutManager", Gtk.Widget.WidgetLayoutManagerPropertyInfo), '("limitEvents", Gtk.Widget.WidgetLimitEventsPropertyInfo), '("marginBottom", Gtk.Widget.WidgetMarginBottomPropertyInfo), '("marginEnd", Gtk.Widget.WidgetMarginEndPropertyInfo), '("marginStart", Gtk.Widget.WidgetMarginStartPropertyInfo), '("marginTop", Gtk.Widget.WidgetMarginTopPropertyInfo), '("model", ListViewModelPropertyInfo), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("orientation", Gtk.ListBase.ListBaseOrientationPropertyInfo), '("overflow", Gtk.Widget.WidgetOverflowPropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("root", Gtk.Widget.WidgetRootPropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("showSeparators", ListViewShowSeparatorsPropertyInfo), '("singleClickActivate", ListViewSingleClickActivatePropertyInfo), '("tabBehavior", ListViewTabBehaviorPropertyInfo), '("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)
    listViewEnableRubberband :: AttrLabelProxy "enableRubberband"
    listViewEnableRubberband = AttrLabelProxy

    listViewFactory :: AttrLabelProxy "factory"
    listViewFactory = AttrLabelProxy

    listViewHeaderFactory :: AttrLabelProxy "headerFactory"
    listViewHeaderFactory = AttrLabelProxy

    listViewModel :: AttrLabelProxy "model"
    listViewModel = AttrLabelProxy

    listViewShowSeparators :: AttrLabelProxy "showSeparators"
    listViewShowSeparators = AttrLabelProxy

    listViewSingleClickActivate :: AttrLabelProxy "singleClickActivate"
    listViewSingleClickActivate = AttrLabelProxy

    listViewTabBehavior :: AttrLabelProxy "tabBehavior"
    listViewTabBehavior = AttrLabelProxy

    #endif

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

    #endif

    -- method ListView::new
    -- method type : Constructor
    -- Args: [ Arg
    --           { argCName = "model"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "SelectionModel" }
    --           , argCType = Just "GtkSelectionModel*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the model to use" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       , Arg
    --           { argCName = "factory"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "ListItemFactory" }
    --           , argCType = Just "GtkListItemFactory*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "The factory to populate items with"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Gtk" , name = "ListView" })
    -- throws : False
    -- Skip return : False

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

    -- | Creates a new @GtkListView@ that uses the given /@factory@/ for
    -- mapping items to widgets.
    --
    -- The function takes ownership of the
    -- arguments, so you can write code like
    --
    -- === /c code/
    -- >list_view = gtk_list_view_new (create_model (),
    -- >  gtk_builder_list_item_factory_new_from_resource ("/resource.ui"));
    listViewNew ::
        (B.CallStack.HasCallStack, MonadIO m, Gtk.SelectionModel.IsSelectionModel a, Gtk.ListItemFactory.IsListItemFactory b) =>
        Maybe (a)
        -- ^ /@model@/: the model to use
        -> Maybe (b)
        -- ^ /@factory@/: The factory to populate items with
        -> m ListView
        -- ^ __Returns:__ a new @GtkListView@ using the given /@model@/ and /@factory@/
    listViewNew :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsSelectionModel a,
     IsListItemFactory b) =>
    Maybe a -> Maybe b -> m ListView
    listViewNew Maybe a
    model Maybe b
    factory = IO ListView -> m ListView
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO ListView -> m ListView) -> IO ListView -> m ListView
    forall a b. (a -> b) -> a -> b
    $ do
        maybeModel <- case Maybe a
    model of
            Maybe a
    Nothing -> Ptr SelectionModel -> IO (Ptr SelectionModel)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr SelectionModel
    forall a. Ptr a
    FP.nullPtr
            Just a
    jModel -> do
                jModel' <- a -> IO (Ptr SelectionModel)
    forall a b. (HasCallStack, GObject a) => a -> IO (Ptr b)
    B.ManagedPtr.disownObject a
    jModel
                return jModel'
        maybeFactory <- case factory of
            Maybe b
    Nothing -> Ptr ListItemFactory -> IO (Ptr ListItemFactory)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr ListItemFactory
    forall a. Ptr a
    FP.nullPtr
            Just b
    jFactory -> do
                jFactory' <- b -> IO (Ptr ListItemFactory)
    forall a b. (HasCallStack, GObject a) => a -> IO (Ptr b)
    B.ManagedPtr.disownObject b
    jFactory
                return jFactory'
        result <- gtk_list_view_new maybeModel maybeFactory
        checkUnexpectedReturnNULL "listViewNew" result
        result' <- (newObject ListView) result
        whenJust model touchManagedPtr
        whenJust factory touchManagedPtr
        return result'

    #if defined(ENABLE_OVERLOADING)
    #endif

    -- method ListView::get_enable_rubberband
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "ListView" }
    --           , argCType = Just "GtkListView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a listview" , 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_list_view_get_enable_rubberband" gtk_list_view_get_enable_rubberband ::
        Ptr ListView ->                         -- self : TInterface (Name {namespace = "Gtk", name = "ListView"})
        IO CInt

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

    #if defined(ENABLE_OVERLOADING)
    data ListViewGetEnableRubberbandMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsListView a) => O.OverloadedMethod ListViewGetEnableRubberbandMethodInfo a signature where
        overloadedMethod = listViewGetEnableRubberband

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

    #endif

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

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

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

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

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

    #endif

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

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

    -- | Gets the factory that\'s currently used to populate section headers.
    --
    -- /Since: 4.12/
    listViewGetHeaderFactory ::
        (B.CallStack.HasCallStack, MonadIO m, IsListView a) =>
        a
        -- ^ /@self@/: a listview
        -> m (Maybe Gtk.ListItemFactory.ListItemFactory)
        -- ^ __Returns:__ The factory in use
    listViewGetHeaderFactory :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsListView a) =>
    a -> m (Maybe ListItemFactory)
    listViewGetHeaderFactory a
    self = IO (Maybe ListItemFactory) -> m (Maybe ListItemFactory)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe ListItemFactory) -> m (Maybe ListItemFactory))
    -> IO (Maybe ListItemFactory) -> m (Maybe ListItemFactory)
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- a -> IO (Ptr ListView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        result <- gtk_list_view_get_header_factory self'
        maybeResult <- convertIfNonNull result $ \Ptr ListItemFactory
    result' -> do
            result'' <- ((ManagedPtr ListItemFactory -> ListItemFactory)
    -> Ptr ListItemFactory -> IO ListItemFactory
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    newObject ManagedPtr ListItemFactory -> ListItemFactory
    Gtk.ListItemFactory.ListItemFactory) Ptr ListItemFactory
    result'
            return result''
        touchManagedPtr self
        return maybeResult

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

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

    #endif

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

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

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

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

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

    #endif

    -- method ListView::get_show_separators
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "ListView" }
    --           , argCType = Just "GtkListView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a listview" , 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_list_view_get_show_separators" gtk_list_view_get_show_separators ::
        Ptr ListView ->                         -- self : TInterface (Name {namespace = "Gtk", name = "ListView"})
        IO CInt

    -- | Returns whether the listview should show separators
    -- between rows.
    listViewGetShowSeparators ::
        (B.CallStack.HasCallStack, MonadIO m, IsListView a) =>
        a
        -- ^ /@self@/: a listview
        -> m Bool
        -- ^ __Returns:__ true if the listview shows separators
    listViewGetShowSeparators :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsListView a) =>
    a -> m Bool
    listViewGetShowSeparators a
    self = IO Bool -> m Bool
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- a -> IO (Ptr ListView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        result <- gtk_list_view_get_show_separators self'
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        touchManagedPtr self
        return result'

    #if defined(ENABLE_OVERLOADING)
    data ListViewGetShowSeparatorsMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsListView a) => O.OverloadedMethod ListViewGetShowSeparatorsMethodInfo a signature where
        overloadedMethod = listViewGetShowSeparators

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

    #endif

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

    -- | Returns whether rows will be activated on single click and
    -- selected on hover.
    listViewGetSingleClickActivate ::
        (B.CallStack.HasCallStack, MonadIO m, IsListView a) =>
        a
        -- ^ /@self@/: a listview
        -> m Bool
        -- ^ __Returns:__ true if rows are activated on single click
    listViewGetSingleClickActivate :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsListView a) =>
    a -> m Bool
    listViewGetSingleClickActivate a
    self = IO Bool -> m Bool
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- a -> IO (Ptr ListView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        result <- gtk_list_view_get_single_click_activate self'
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        touchManagedPtr self
        return result'

    #if defined(ENABLE_OVERLOADING)
    data ListViewGetSingleClickActivateMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsListView a) => O.OverloadedMethod ListViewGetSingleClickActivateMethodInfo a signature where
        overloadedMethod = listViewGetSingleClickActivate

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

    #endif

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

    foreign import ccall "gtk_list_view_get_tab_behavior" gtk_list_view_get_tab_behavior ::
        Ptr ListView ->                         -- self : TInterface (Name {namespace = "Gtk", name = "ListView"})
        IO CUInt

    -- | Gets the behavior set for the \<kbd>Tab\<\/kbd> key.
    --
    -- /Since: 4.12/
    listViewGetTabBehavior ::
        (B.CallStack.HasCallStack, MonadIO m, IsListView a) =>
        a
        -- ^ /@self@/: a listview
        -> m Gtk.Enums.ListTabBehavior
        -- ^ __Returns:__ The behavior of the \<kbd>Tab\<\/kbd> key
    listViewGetTabBehavior :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsListView a) =>
    a -> m ListTabBehavior
    listViewGetTabBehavior a
    self = IO ListTabBehavior -> m ListTabBehavior
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO ListTabBehavior -> m ListTabBehavior)
    -> IO ListTabBehavior -> m ListTabBehavior
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- a -> IO (Ptr ListView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        result <- gtk_list_view_get_tab_behavior self'
        let result' = (Int -> ListTabBehavior
    forall a. Enum a => Int -> a
    toEnum (Int -> ListTabBehavior)
    -> (CUInt -> Int) -> CUInt -> ListTabBehavior
    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 self
        return result'

    #if defined(ENABLE_OVERLOADING)
    data ListViewGetTabBehaviorMethodInfo
    instance (signature ~ (m Gtk.Enums.ListTabBehavior), MonadIO m, IsListView a) => O.OverloadedMethod ListViewGetTabBehaviorMethodInfo a signature where
        overloadedMethod = listViewGetTabBehavior

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

    #endif

    -- method ListView::scroll_to
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "ListView" }
    --           , argCType = Just "GtkListView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a listview" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "pos"
    --           , argType = TBasicType TUInt
    --           , argCType = Just "guint"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "position of the item. Must be less than the number of\n  items in the view."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "flags"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "ListScrollFlags" }
    --           , argCType = Just "GtkListScrollFlags"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "actions to perform" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "scroll"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "ScrollInfo" }
    --           , argCType = Just "GtkScrollInfo*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "details of how to perform\n  the scroll operation or %NULL to scroll into view"
    --                 , 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_list_view_scroll_to" gtk_list_view_scroll_to ::
        Ptr ListView ->                         -- self : TInterface (Name {namespace = "Gtk", name = "ListView"})
        Word32 ->                               -- pos : TBasicType TUInt
        CUInt ->                                -- flags : TInterface (Name {namespace = "Gtk", name = "ListScrollFlags"})
        Ptr Gtk.ScrollInfo.ScrollInfo ->        -- scroll : TInterface (Name {namespace = "Gtk", name = "ScrollInfo"})
        IO ()

    -- | Scrolls to the item at the given position and performs the actions
    -- specified in /@flags@/.
    --
    -- This function works no matter if the listview is shown or focused.
    -- If it isn\'t, then the changes will take effect once that happens.
    --
    -- /Since: 4.12/
    listViewScrollTo ::
        (B.CallStack.HasCallStack, MonadIO m, IsListView a) =>
        a
        -- ^ /@self@/: a listview
        -> Word32
        -- ^ /@pos@/: position of the item. Must be less than the number of
        --   items in the view.
        -> [Gtk.Flags.ListScrollFlags]
        -- ^ /@flags@/: actions to perform
        -> Maybe (Gtk.ScrollInfo.ScrollInfo)
        -- ^ /@scroll@/: details of how to perform
        --   the scroll operation or 'P.Nothing' to scroll into view
        -> m ()
    listViewScrollTo :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsListView a) =>
    a -> Word32 -> [ListScrollFlags] -> Maybe ScrollInfo -> m ()
    listViewScrollTo a
    self Word32
    pos [ListScrollFlags]
    flags Maybe ScrollInfo
    scroll = 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
        self' <- a -> IO (Ptr ListView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        let flags' = [ListScrollFlags] -> CUInt
    forall b a. (Num b, IsGFlag a) => [a] -> b
    gflagsToWord [ListScrollFlags]
    flags
        maybeScroll <- case scroll of
            Maybe ScrollInfo
    Nothing -> Ptr ScrollInfo -> IO (Ptr ScrollInfo)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr ScrollInfo
    forall a. Ptr a
    FP.nullPtr
            Just ScrollInfo
    jScroll -> do
                jScroll' <- ScrollInfo -> IO (Ptr ScrollInfo)
    forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
    B.ManagedPtr.disownBoxed ScrollInfo
    jScroll
                return jScroll'
        gtk_list_view_scroll_to self' pos flags' maybeScroll
        touchManagedPtr self
        whenJust scroll touchManagedPtr
        return ()

    #if defined(ENABLE_OVERLOADING)
    data ListViewScrollToMethodInfo
    instance (signature ~ (Word32 -> [Gtk.Flags.ListScrollFlags] -> Maybe (Gtk.ScrollInfo.ScrollInfo) -> m ()), MonadIO m, IsListView a) => O.OverloadedMethod ListViewScrollToMethodInfo a signature where
        overloadedMethod = listViewScrollTo

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

    #endif

    -- method ListView::set_enable_rubberband
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "ListView" }
    --           , argCType = Just "GtkListView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a listview" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "enable_rubberband"
    --           , argType = TBasicType TBoolean
    --           , argCType = Just "gboolean"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "whether to enable rubberband selection"
    --                 , 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_list_view_set_enable_rubberband" gtk_list_view_set_enable_rubberband ::
        Ptr ListView ->                         -- self : TInterface (Name {namespace = "Gtk", name = "ListView"})
        CInt ->                                 -- enable_rubberband : TBasicType TBoolean
        IO ()

    -- | Sets whether selections can be changed by dragging with the mouse.
    listViewSetEnableRubberband ::
        (B.CallStack.HasCallStack, MonadIO m, IsListView a) =>
        a
        -- ^ /@self@/: a listview
        -> Bool
        -- ^ /@enableRubberband@/: whether to enable rubberband selection
        -> m ()
    listViewSetEnableRubberband :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsListView a) =>
    a -> Bool -> m ()
    listViewSetEnableRubberband a
    self Bool
    enableRubberband = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- a -> IO (Ptr ListView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        let enableRubberband' = (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
    enableRubberband
        gtk_list_view_set_enable_rubberband self' enableRubberband'
        touchManagedPtr self
        return ()

    #if defined(ENABLE_OVERLOADING)
    data ListViewSetEnableRubberbandMethodInfo
    instance (signature ~ (Bool -> m ()), MonadIO m, IsListView a) => O.OverloadedMethod ListViewSetEnableRubberbandMethodInfo a signature where
        overloadedMethod = listViewSetEnableRubberband

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

    #endif

    -- method ListView::set_factory
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "ListView" }
    --           , argCType = Just "GtkListView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a listview" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "factory"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "ListItemFactory" }
    --           , argCType = Just "GtkListItemFactory*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the factory to use" , 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_list_view_set_factory" gtk_list_view_set_factory ::
        Ptr ListView ->                         -- self : TInterface (Name {namespace = "Gtk", name = "ListView"})
        Ptr Gtk.ListItemFactory.ListItemFactory -> -- factory : TInterface (Name {namespace = "Gtk", name = "ListItemFactory"})
        IO ()

    -- | Sets the @GtkListItemFactory@ to use for populating list items.
    listViewSetFactory ::
        (B.CallStack.HasCallStack, MonadIO m, IsListView a, Gtk.ListItemFactory.IsListItemFactory b) =>
        a
        -- ^ /@self@/: a listview
        -> Maybe (b)
        -- ^ /@factory@/: the factory to use
        -> m ()
    listViewSetFactory :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsListView a, IsListItemFactory b) =>
    a -> Maybe b -> m ()
    listViewSetFactory a
    self Maybe b
    factory = 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
        self' <- a -> IO (Ptr ListView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        maybeFactory <- case factory of
            Maybe b
    Nothing -> Ptr ListItemFactory -> IO (Ptr ListItemFactory)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr ListItemFactory
    forall a. Ptr a
    FP.nullPtr
            Just b
    jFactory -> do
                jFactory' <- b -> IO (Ptr ListItemFactory)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr b
    jFactory
                return jFactory'
        gtk_list_view_set_factory self' maybeFactory
        touchManagedPtr self
        whenJust factory touchManagedPtr
        return ()

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

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

    #endif

    -- method ListView::set_header_factory
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "ListView" }
    --           , argCType = Just "GtkListView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a listview" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "factory"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "ListItemFactory" }
    --           , argCType = Just "GtkListItemFactory*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the factory to use" , 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_list_view_set_header_factory" gtk_list_view_set_header_factory ::
        Ptr ListView ->                         -- self : TInterface (Name {namespace = "Gtk", name = "ListView"})
        Ptr Gtk.ListItemFactory.ListItemFactory -> -- factory : TInterface (Name {namespace = "Gtk", name = "ListItemFactory"})
        IO ()

    -- | Sets the @GtkListItemFactory@ to use for populating the
    -- t'GI.Gtk.Objects.ListHeader.ListHeader' objects used in section headers.
    --
    -- If this factory is set to @NULL@, the list will not show
    -- section headers.
    --
    -- /Since: 4.12/
    listViewSetHeaderFactory ::
        (B.CallStack.HasCallStack, MonadIO m, IsListView a, Gtk.ListItemFactory.IsListItemFactory b) =>
        a
        -- ^ /@self@/: a listview
        -> Maybe (b)
        -- ^ /@factory@/: the factory to use
        -> m ()
    listViewSetHeaderFactory :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsListView a, IsListItemFactory b) =>
    a -> Maybe b -> m ()
    listViewSetHeaderFactory a
    self Maybe b
    factory = 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
        self' <- a -> IO (Ptr ListView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        maybeFactory <- case factory of
            Maybe b
    Nothing -> Ptr ListItemFactory -> IO (Ptr ListItemFactory)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr ListItemFactory
    forall a. Ptr a
    FP.nullPtr
            Just b
    jFactory -> do
                jFactory' <- b -> IO (Ptr ListItemFactory)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr b
    jFactory
                return jFactory'
        gtk_list_view_set_header_factory self' maybeFactory
        touchManagedPtr self
        whenJust factory touchManagedPtr
        return ()

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

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

    #endif

    -- method ListView::set_model
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "ListView" }
    --           , argCType = Just "GtkListView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a listview" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "model"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "SelectionModel" }
    --           , argCType = Just "GtkSelectionModel*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the model to use" , 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_list_view_set_model" gtk_list_view_set_model ::
        Ptr ListView ->                         -- self : TInterface (Name {namespace = "Gtk", name = "ListView"})
        Ptr Gtk.SelectionModel.SelectionModel -> -- model : TInterface (Name {namespace = "Gtk", name = "SelectionModel"})
        IO ()

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

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

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

    #endif

    -- method ListView::set_show_separators
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "ListView" }
    --           , argCType = Just "GtkListView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a listview" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "show_separators"
    --           , argType = TBasicType TBoolean
    --           , argCType = Just "gboolean"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "whether to show separators"
    --                 , 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_list_view_set_show_separators" gtk_list_view_set_show_separators ::
        Ptr ListView ->                         -- self : TInterface (Name {namespace = "Gtk", name = "ListView"})
        CInt ->                                 -- show_separators : TBasicType TBoolean
        IO ()

    -- | Sets whether the listview should show separators
    -- between rows.
    listViewSetShowSeparators ::
        (B.CallStack.HasCallStack, MonadIO m, IsListView a) =>
        a
        -- ^ /@self@/: a listview
        -> Bool
        -- ^ /@showSeparators@/: whether to show separators
        -> m ()
    listViewSetShowSeparators :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsListView a) =>
    a -> Bool -> m ()
    listViewSetShowSeparators a
    self Bool
    showSeparators = 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
        self' <- a -> IO (Ptr ListView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        let showSeparators' = (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
    showSeparators
        gtk_list_view_set_show_separators self' showSeparators'
        touchManagedPtr self
        return ()

    #if defined(ENABLE_OVERLOADING)
    data ListViewSetShowSeparatorsMethodInfo
    instance (signature ~ (Bool -> m ()), MonadIO m, IsListView a) => O.OverloadedMethod ListViewSetShowSeparatorsMethodInfo a signature where
        overloadedMethod = listViewSetShowSeparators

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

    #endif

    -- method ListView::set_single_click_activate
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "ListView" }
    --           , argCType = Just "GtkListView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a listview" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "single_click_activate"
    --           , argType = TBasicType TBoolean
    --           , argCType = Just "gboolean"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "whether to activate items on 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_list_view_set_single_click_activate" gtk_list_view_set_single_click_activate ::
        Ptr ListView ->                         -- self : TInterface (Name {namespace = "Gtk", name = "ListView"})
        CInt ->                                 -- single_click_activate : TBasicType TBoolean
        IO ()

    -- | Sets whether rows should be activated on single click and
    -- selected on hover.
    listViewSetSingleClickActivate ::
        (B.CallStack.HasCallStack, MonadIO m, IsListView a) =>
        a
        -- ^ /@self@/: a listview
        -> Bool
        -- ^ /@singleClickActivate@/: whether to activate items on single click
        -> m ()
    listViewSetSingleClickActivate :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsListView a) =>
    a -> Bool -> m ()
    listViewSetSingleClickActivate a
    self Bool
    singleClickActivate = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- a -> IO (Ptr ListView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        let singleClickActivate' = (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
    singleClickActivate
        gtk_list_view_set_single_click_activate self' singleClickActivate'
        touchManagedPtr self
        return ()

    #if defined(ENABLE_OVERLOADING)
    data ListViewSetSingleClickActivateMethodInfo
    instance (signature ~ (Bool -> m ()), MonadIO m, IsListView a) => O.OverloadedMethod ListViewSetSingleClickActivateMethodInfo a signature where
        overloadedMethod = listViewSetSingleClickActivate

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

    #endif

    -- method ListView::set_tab_behavior
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "ListView" }
    --           , argCType = Just "GtkListView*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a listview" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "tab_behavior"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "ListTabBehavior" }
    --           , argCType = Just "GtkListTabBehavior"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "The desired tab behavior"
    --                 , 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_list_view_set_tab_behavior" gtk_list_view_set_tab_behavior ::
        Ptr ListView ->                         -- self : TInterface (Name {namespace = "Gtk", name = "ListView"})
        CUInt ->                                -- tab_behavior : TInterface (Name {namespace = "Gtk", name = "ListTabBehavior"})
        IO ()

    -- | Sets the \<kbd>Tab\<\/kbd> key behavior.
    --
    -- This influences how the \<kbd>Tab\<\/kbd> and
    -- \<kbd>Shift\<\/kbd>+\<kbd>Tab\<\/kbd> keys move the
    -- focus in the listview.
    --
    -- /Since: 4.12/
    listViewSetTabBehavior ::
        (B.CallStack.HasCallStack, MonadIO m, IsListView a) =>
        a
        -- ^ /@self@/: a listview
        -> Gtk.Enums.ListTabBehavior
        -- ^ /@tabBehavior@/: The desired tab behavior
        -> m ()
    listViewSetTabBehavior :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsListView a) =>
    a -> ListTabBehavior -> m ()
    listViewSetTabBehavior a
    self ListTabBehavior
    tabBehavior = 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
        self' <- a -> IO (Ptr ListView)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        let tabBehavior' = (Int -> CUInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> CUInt)
    -> (ListTabBehavior -> Int) -> ListTabBehavior -> CUInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ListTabBehavior -> Int
    forall a. Enum a => a -> Int
    fromEnum) ListTabBehavior
    tabBehavior
        gtk_list_view_set_tab_behavior self' tabBehavior'
        touchManagedPtr self
        return ()

    #if defined(ENABLE_OVERLOADING)
    data ListViewSetTabBehaviorMethodInfo
    instance (signature ~ (Gtk.Enums.ListTabBehavior -> m ()), MonadIO m, IsListView a) => O.OverloadedMethod ListViewSetTabBehaviorMethodInfo a signature where
        overloadedMethod = listViewSetTabBehavior

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

    #endif