@gtkx/react 0.18.9 → 0.20.0

package/src/generated/jsx.ts

@@ -26,6 +26,13 @@ export interface WidgetProps {
     canTarget?: boolean;
     /** A list of css classes applied to this widget. */
     cssClasses?: string[];
+    /**
+     * The name of this widget in the CSS tree.
+     *
+     * This property is meant to be set by widget implementations,
+     * typically in their instance init function.
+     */
+    cssName?: string;
     /** The cursor used by `widget`. */
     cursor?: Gdk.Cursor | null;
     /**
@@ -303,8 +310,6 @@ export interface WidgetProps {
      * detail strings for the notify signal.
      */
     onNotify?: ((pspec: GObject.ParamSpec, self: Gtk.Widget) => void) | null;
-    /** When set to true, the widget will grab focus. Useful for focusing a widget when a condition becomes true. */
-    grabFocus?: boolean;
     /** Children elements (child widgets or event controllers). */
     children?: ReactNode;
 }
@@ -1320,6 +1325,12 @@ export interface GtkAppChooserButtonProps extends WidgetProps {
      * a `GtkAppChooserDialog`.
      */
     showDialogItem?: boolean;
+    /**
+     * The content type of the `GtkAppChooser` object.
+     *
+     * See `GContentType` for more information about content types.
+     */
+    contentType?: string;
     /**
      * Emitted to when the button is activated.
      *
@@ -1341,12 +1352,25 @@ export interface GtkAppChooserButtonProps extends WidgetProps {
 
 /** Props for the {@link GtkAppChooserDialog} widget. */
 export interface GtkAppChooserDialogProps extends GtkDialogProps {
+    /**
+     * The GFile used by the `GtkAppChooserDialog`.
+     *
+     * The dialog's `GtkAppChooserWidget` content type will
+     * be guessed from the file, if present.
+     */
+    gfile?: Gio.File;
     /**
      * The text to show at the top of the dialog.
      *
      * The string may contain Pango markup.
      */
     heading?: string;
+    /**
+     * The content type of the `GtkAppChooser` object.
+     *
+     * See `GContentType` for more information about content types.
+     */
+    contentType?: string;
     ref?: Ref<Gtk.AppChooserDialog>;
 }
 
@@ -1392,6 +1416,12 @@ export interface GtkAppChooserWidgetProps extends WidgetProps {
      * among the other applications.
      */
     showRecommended?: boolean;
+    /**
+     * The content type of the `GtkAppChooser` object.
+     *
+     * See `GContentType` for more information about content types.
+     */
+    contentType?: string;
     /**
      * Emitted when an application item is activated from the widget's list.
      *
@@ -1483,6 +1513,14 @@ export interface GtkAspectFrameProps extends WidgetProps {
 
 /** Props for the {@link GtkAssistant} widget. */
 export interface GtkAssistantProps extends GtkWindowProps {
+    /**
+     * %TRUE if the assistant uses a `GtkHeaderBar` for action buttons
+     * instead of the action-area.
+     *
+     * For technical reasons, this property is declared as an integer
+     * property, but you should only set it to %TRUE or %FALSE.
+     */
+    useHeaderBar?: number;
     /**
      * Emitted when the apply button is clicked.
      *
@@ -1928,6 +1966,30 @@ export interface AdwCarouselIndicatorLinesProps extends WidgetProps {
 
 /** Props for the {@link GtkCellView} widget. */
 export interface GtkCellViewProps extends WidgetProps {
+    /**
+     * The `GtkCellArea` rendering cells
+     *
+     * If no area is specified when creating the cell view with gtk_cell_view_new_with_context()
+     * a horizontally oriented `GtkCellArea`Box will be used.
+     *
+     * since 3.0
+     */
+    cellArea?: Gtk.CellArea;
+    /**
+     * The `GtkCellAreaContext` used to compute the geometry of the cell view.
+     *
+     * A group of cell views can be assigned the same context in order to
+     * ensure the sizes and cell alignments match across all the views with
+     * the same context.
+     *
+     * `GtkComboBox` menus uses this to assign the same context to all cell views
+     * in the menu items for a single menu (each submenu creates its own
+     * context since the size of each submenu does not depend on parent
+     * or sibling menus).
+     *
+     * since 3.0
+     */
+    cellAreaContext?: Gtk.CellAreaContext;
     /**
      * Whether all cells should be draw as sensitive for this view regardless
      * of the actual cell properties (used to make menus with submenus appear
@@ -2377,6 +2439,8 @@ export interface GtkComboBoxProps extends WidgetProps {
      * {@link ComboBox.has-entry} is %TRUE.
      */
     entryTextColumn?: number;
+    /** Whether the combo box has an entry. */
+    hasEntry?: boolean;
     /** The `has-frame` property controls whether a frame is drawn around the entry. */
     hasFrame?: boolean;
     /**
@@ -2533,6 +2597,7 @@ export interface AdwComboRowProps extends AdwActionRowProps {
 
 /** Props for the {@link GtkSourceCompletionCell} widget. */
 export interface GtkSourceCompletionCellProps extends WidgetProps {
+    column?: GtkSource.CompletionColumn;
     markup?: string;
     paintable?: Gdk.Paintable;
     text?: string | null;
@@ -2616,6 +2681,27 @@ export interface AdwDialogProps extends WidgetProps {
 
 /** Props for the {@link GtkDialog} widget. */
 export interface GtkDialogProps extends GtkWindowProps {
+    /**
+     * %TRUE if the dialog uses a headerbar for action buttons
+     * instead of the action-area.
+     *
+     * For technical reasons, this property is declared as an integer
+     * property, but you should only set it to %TRUE or %FALSE.
+     *
+     * ## Creating a dialog with headerbar
+     *
+     * Builtin `GtkDialog` subclasses such as {@link ColorChooserDialog}
+     * set this property according to platform conventions (using the
+     * {@link Settings.gtk-dialogs-use-header} setting).
+     *
+     * Here is how you can achieve the same:
+     *
+     * ```c
+     * g_object_get (settings, "gtk-dialogs-use-header", &header, NULL);
+     * dialog = g_object_new (GTK_TYPE_DIALOG, header, TRUE, NULL);
+     * ```
+     */
+    useHeaderBar?: number;
     /**
      * Emitted when an action widget is clicked.
      *
@@ -3892,6 +3978,10 @@ export interface GtkGridViewProps extends GtkListBaseProps {
 
 /** Props for the {@link GtkSourceGutter} widget. */
 export interface GtkSourceGutterProps extends WidgetProps {
+    /** The #GtkSourceView of the gutter. */
+    view?: GtkSource.View;
+    /** The text window type on which the window is placed. */
+    windowType?: Gtk.TextWindowType;
     ref?: Ref<GtkSource.Gutter>;
 }
 
@@ -4073,6 +4163,13 @@ export interface GtkIconViewProps extends WidgetProps {
      * will be emitted after a single click.
      */
     activateOnSingleClick?: boolean;
+    /**
+     * The `GtkCellArea` used to layout cell renderers for this view.
+     *
+     * If no area is specified when creating the icon view with gtk_icon_view_new_with_area()
+     * a `GtkCellAreaBox` will be used.
+     */
+    cellArea?: Gtk.CellArea;
     /**
      * The column-spacing property specifies the space which is inserted between
      * the columns of the icon view.
@@ -4653,6 +4750,12 @@ export interface GtkLabelProps extends WidgetProps {
 
 /** Props for the {@link AdwLayoutSlot} widget. */
 export interface AdwLayoutSlotProps extends WidgetProps {
+    /**
+     * The slot ID.
+     *
+     * See {@link MultiLayoutViewset_child}.
+     */
+    id?: string;
     ref?: Ref<Adw.LayoutSlot>;
 }
 
@@ -5119,6 +5222,8 @@ export interface AdwMessageDialogProps extends GtkWindowProps {
 
 /** Props for the {@link GtkMessageDialog} widget. */
 export interface GtkMessageDialogProps extends GtkDialogProps {
+    /** Set of buttons to display on the dialog. */
+    buttons?: Gtk.ButtonsType;
     /** The type of the message. */
     messageType?: Gtk.MessageType;
     /** The secondary text of the message dialog. */
@@ -7167,6 +7272,7 @@ export interface GtkSourceStyleSchemeChooserWidgetProps extends WidgetProps {
 
 /** Props for the {@link GtkSourceStyleSchemePreview} widget. */
 export interface GtkSourceStyleSchemePreviewProps extends WidgetProps {
+    scheme: GtkSource.StyleScheme;
     selected?: boolean;
     /** The name of the action with which this widget should be associated. */
     actionName?: string;
@@ -8935,6 +9041,13 @@ export interface GtkVolumeButtonProps extends GtkScaleButtonProps {
 
 /** Props for the {@link WebKitWebView} widget. */
 export interface WebKitWebViewProps extends WebKitWebViewBaseProps {
+    /**
+     * The #WebKitAutomationBrowsingContextPresentation of #WebKitWebView. This should only be used when
+     * creating a new #WebKitWebView as a response to #WebKitAutomationSession::create-web-view
+     * signal request. If the new WebView was added to a new tab of current browsing context window
+     * %WEBKIT_AUTOMATION_BROWSING_CONTEXT_PRESENTATION_TAB should be used.
+     */
+    automationPresentationType?: WebKit.AutomationBrowsingContextPresentation;
     /**
      * Capture state of the camera device. Whenever the user grants a media-request sent by the web
      * page, requesting video capture capabilities (`navigator.mediaDevices.getUserMedia({video:
@@ -8949,6 +9062,19 @@ export interface WebKitWebViewProps extends WebKitWebViewBaseProps {
      * application.
      */
     cameraCaptureState?: WebKit.MediaCaptureState;
+    /**
+     * The default Content-Security-Policy used by the webview as if it were set
+     * by an HTTP header.
+     *
+     * This applies to all content loaded including through navigation or via the various
+     * webkit_web_view_load_\* APIs. However do note that many WebKit APIs bypass
+     * Content-Security-Policy in general such as #WebKitUserContentManager and
+     * webkit_web_view_run_javascript().
+     *
+     * Policies are additive so if a website sets its own policy it still applies
+     * on top of the policy set here.
+     */
+    defaultContentSecurityPolicy?: string;
     /**
      * Capture state of the display device. Whenever the user grants a media-request sent by the web
      * page, requesting screencasting capabilities (`navigator.mediaDevices.getDisplayMedia() this
@@ -8968,6 +9094,19 @@ export interface WebKitWebViewProps extends WebKitWebViewBaseProps {
      * information see webkit_web_view_set_editable().
      */
     editable?: boolean;
+    /**
+     * Whether the #WebKitWebView is controlled by automation tools (e.g. WebDriver, Selenium). This is
+     * required for views returned as a response to #WebKitAutomationSession::create-web-view signal,
+     * alongside any view you want to control during an automation session.
+     *
+     * As a %G_PARAM_CONSTRUCT_ONLY, you need to set it during construction and it can't be modified.
+     *
+     * If #WebKitWebView:related-view is also passed during construction, #WebKitWebView:is-controlled-by-automation
+     * ignores its own parameter and inherits directly from the related view #WebKitWebView:is-controlled-by-automation
+     * property. This is the recommended way when creating new views as a response to the #WebKitWebView::create
+     * signal. For example, as response to JavaScript `window.open()` calls during an automation session.
+     */
+    isControlledByAutomation?: boolean;
     /**
      * Whether the #WebKitWebView audio is muted. When %TRUE, audio is silenced.
      * It may still be playing, i.e. #WebKitWebView:is-playing-audio may be %TRUE.
@@ -8987,8 +9126,32 @@ export interface WebKitWebViewProps extends WebKitWebViewBaseProps {
      * application.
      */
     microphoneCaptureState?: WebKit.MediaCaptureState;
+    /** The #WebKitNetworkSession of the view */
+    networkSession?: WebKit.NetworkSession;
+    /**
+     * The related #WebKitWebView used when creating the view to share the
+     * same web process and network session. This property is not readable
+     * because the related web view is only valid during the object construction.
+     */
+    relatedView?: WebKit.WebView;
     /** The #WebKitSettings of the view. */
     settings?: WebKit.Settings;
+    /** The #WebKitUserContentManager of the view. */
+    userContentManager?: WebKit.UserContentManager;
+    /** The #WebKitWebContext of the view. */
+    webContext?: WebKit.WebContext;
+    /**
+     * This configures `web_view` to treat the content as a WebExtension.
+     *
+     * Note that this refers to the web standard [WebExtensions](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions)
+     * and not WebKitWebExtensions.
+     *
+     * In practice this limits the Content-Security-Policies that are allowed to be set. Some details can be found in
+     * [Chrome's documentation](https://developer.chrome.com/docs/extensions/mv3/intro/mv3-migration/#content-security-policy).
+     */
+    webExtensionMode?: WebKit.WebExtensionMode;
+    /** The #WebKitWebsitePolicies for the view. */
+    websitePolicies?: WebKit.WebsitePolicies;
     /**
      * The zoom level of the #WebKitWebView content.
      * See webkit_web_view_set_zoom_level() for more details.
@@ -9740,6 +9903,8 @@ export interface GtkDropControllerMotionProps extends EventControllerBaseProps {
 export interface GtkDropTargetProps extends EventControllerBaseProps {
     /** The `GdkDragActions` that this drop target supports. */
     actions?: Gdk.DragAction;
+    /** The `GdkContentFormats` that determine the supported data formats. */
+    formats?: Gdk.ContentFormats;
     /**
      * Whether the drop data should be preloaded when the pointer is only
      * hovering over the widget but has not been released.
@@ -9984,6 +10149,11 @@ export interface GtkEventControllerScrollProps extends EventControllerBaseProps
 
 /** Props for the {@link GtkGesture} controller element. */
 export interface GtkGestureProps extends EventControllerBaseProps {
+    /**
+     * The number of touch points that trigger
+     * recognition on this gesture.
+     */
+    nPoints?: number;
     /**
      * Emitted when the gesture is recognized.
      *
@@ -10168,6 +10338,10 @@ export interface GtkGestureZoomProps extends GtkGestureProps {
 
 /** Props for the {@link GtkPadController} controller element. */
 export interface GtkPadControllerProps extends EventControllerBaseProps {
+    /** The action group of the controller. */
+    actionGroup?: Gio.ActionGroup;
+    /** The pad of the controller. */
+    pad?: Gdk.Device;
     ref?: Ref<Gtk.PadController>;
 }
 
@@ -10175,6 +10349,8 @@ export interface GtkPadControllerProps extends EventControllerBaseProps {
 export interface GtkShortcutControllerProps extends EventControllerBaseProps {
     /** The modifiers that need to be pressed to allow mnemonics activation. */
     mnemonicModifiers?: Gdk.ModifierType;
+    /** A list model to take shortcuts from. */
+    model?: Gio.ListModel;
     /** What scope the shortcuts will be handled in. */
     scope?: Gtk.ShortcutScope;
     /**
@@ -12399,73 +12575,6 @@ export const GtkColorChooserWidget = "GtkColorChooserWidget" as const;
  * it gets the .color style class.
  */
 export const GtkColorDialogButton = "GtkColorDialogButton" as const;
-/**
- * Presents a large dynamic list of items using multiple columns with headers.
- *
- * `GtkColumnView` uses the factories of its columns to generate a cell widget for
- * each column, for each visible item and displays them together as the row for
- * this item.
- *
- * The {@link Gtk.ColumnView.show-row-separators} and
- * {@link Gtk.ColumnView.show-column-separators} properties offer a simple way
- * to display separators between the rows or columns.
- *
- * `GtkColumnView` allows the user to select items according to the selection
- * characteristics of the model. For models that allow multiple selected items,
- * it is possible to turn on *rubberband selection*, using
- * {@link Gtk.ColumnView.enable-rubberband}.
- *
- * The column view supports sorting that can be customized by the user by
- * clicking on column headers. To set this up, the `GtkSorter` returned by
- * {@link Gtk.ColumnView.get_sorter} must be attached to a sort model for the
- * data that the view is showing, and the columns must have sorters attached to
- * them by calling {@link Gtk.ColumnViewColumn.set_sorter}. The initial sort
- * order can be set with {@link Gtk.ColumnView.sort_by_column}.
- *
- * The column view also supports interactive resizing and reordering of
- * columns, via Drag-and-Drop of the column headers. This can be enabled or
- * disabled with the {@link Gtk.ColumnView.reorderable} and
- * {@link Gtk.ColumnViewColumn.resizable} properties.
- *
- * To learn more about the list widget framework, see the
- * overview.
- *
- * # CSS nodes
- *
- * ```
- * columnview[.column-separators][.rich-list][.navigation-sidebar][.data-table]
- * ├── header
- * │   ├── <column header>
- * ┊   ┊
- * │   ╰── <column header>
- * │
- * ├── listview
- * │
- * ┊
- * ╰── [rubberband]
- * ```
- *
- * `GtkColumnView` uses a single CSS node named columnview. It may carry the
- * .column-separators style class, when {@link Gtk.ColumnView.show-column-separators}
- * property is set. Header widgets appear below a node with name header.
- * The rows are contained in a `GtkListView` widget, so there is a listview
- * node with the same structure as for a standalone `GtkListView` widget.
- * If {@link Gtk.ColumnView.show-row-separators} is set, it will be passed
- * on to the list view, causing its CSS node to carry the .separators style class.
- * For rubberband selection, a node with name rubberband is used.
- *
- * The main columnview node may also carry style classes to select
- * the style of list presentation:
- * .rich-list, .navigation-sidebar or .data-table.
- *
- * # Accessibility
- *
- * `GtkColumnView` uses the {@link Gtk.AccessibleRole.tree_grid} role, header title
- * widgets are using the {@link Gtk.AccessibleRole.column_header} role. The row widgets
- * are using the {@link Gtk.AccessibleRole.row} role, and individual cells are using
- * the {@link Gtk.AccessibleRole.grid_cell} role
- */
-export const GtkColumnView = "GtkColumnView" as const;
 /**
  * A `GtkComboBox` is a widget that allows the user to choose from a list of
  * valid choices.
@@ -12587,53 +12696,6 @@ export const GtkComboBox = "GtkComboBox" as const;
  * children, and the .linked class to the node of its internal box.
  */
 export const GtkComboBoxText = "GtkComboBoxText" as const;
-/**
- * A {@link Gtk.ListBoxRow} used to choose from a list of items.
- *
- * ![combo-row](https://gnome.pages.gitlab.gnome.org/libadwaita/doc/1-latest/combo-row.png)
- *
- * The `AdwComboRow` widget allows the user to choose from a list of valid
- * choices. The row displays the selected choice. When activated, the row
- * displays a popover which allows the user to make a new choice.
- *
- * Example of an `AdwComboRow` UI definition:
- * ```xml
- * <object class="AdwComboRow">
- *   <property name="title" translatable="yes">Combo Row</property>
- *   <property name="model">
- *     <object class="GtkStringList">
- *       <items>
- *         <item translatable="yes">Foo</item>
- *         <item translatable="yes">Bar</item>
- *         <item translatable="yes">Baz</item>
- *       </items>
- *     </object>
- *   </property>
- * </object>
- * ```
- *
- * The {@link ComboRow.selected} and {@link ComboRow.selected-item}
- * properties can be used to keep track of the selected item and react to their
- * changes.
- *
- * `AdwComboRow` mirrors {@link Gtk.DropDown}, see that widget for details.
- *
- * `AdwComboRow` is {@link Gtk.ListBoxRow.activatable} if a model is set.
- *
- * ## CSS nodes
- *
- * `AdwComboRow` has a main CSS node with name `row` and the `.combo` style
- * class.
- *
- * Its popover has the node named `popover` with the `.menu` style class, it
- * contains a {@link Gtk.ScrolledWindow}, which in turn contains a
- * {@link Gtk.ListView}, both are accessible via their regular nodes.
- *
- * ## Accessibility
- *
- * `AdwComboRow` uses the `GTK_ACCESSIBLE_ROLE_COMBO_BOX` role.
- */
-export const AdwComboRow = "AdwComboRow" as const;
 /**
  * Widget for single cell of completion proposal.
  *
@@ -12925,64 +12987,6 @@ export const GtkDragIcon = "GtkDragIcon" as const;
  * creating your own `GtkWidget` subclass.
  */
 export const GtkDrawingArea = "GtkDrawingArea" as const;
-/**
- * Allows the user to choose an item from a list of options.
- *
- * ![An example GtkDropDown](https://docs.gtk.org/gtk4/drop-down.png)
- *
- * The `GtkDropDown` displays the [selected]{@link Gtk.DropDown.selected}
- * choice.
- *
- * The options are given to `GtkDropDown` in the form of `GListModel`
- * and how the individual options are represented is determined by
- * a {@link Gtk.ListItemFactory}. The default factory displays simple strings,
- * and adds a checkmark to the selected item in the popup.
- *
- * To set your own factory, use {@link Gtk.DropDown.set_factory}. It is
- * possible to use a separate factory for the items in the popup, with
- * {@link Gtk.DropDown.set_list_factory}.
- *
- * `GtkDropDown` knows how to obtain strings from the items in a
- * {@link Gtk.StringList}; for other models, you have to provide an expression
- * to find the strings via {@link Gtk.DropDown.set_expression}.
- *
- * `GtkDropDown` can optionally allow search in the popup, which is
- * useful if the list of options is long. To enable the search entry,
- * use {@link Gtk.DropDown.set_enable_search}.
- *
- * Here is a UI definition example for `GtkDropDown` with a simple model:
- *
- * ```xml
- * <object class="GtkDropDown">
- *   <property name="model">
- *     <object class="GtkStringList">
- *       <items>
- *         <item translatable="yes">Factory</item>
- *         <item translatable="yes">Home</item>
- *         <item translatable="yes">Subway</item>
- *       </items>
- *     </object>
- *   </property>
- * </object>
- * ```
- *
- * If a `GtkDropDown` is created in this manner, or with
- * {@link Gtk.DropDown.new_from_strings}, for instance, the object returned from
- * {@link Gtk.DropDown.get_selected_item} will be a {@link Gtk.StringObject}.
- *
- * To learn more about the list widget framework, see the
- * overview.
- *
- * ## CSS nodes
- *
- * `GtkDropDown` has a single CSS node with name dropdown,
- * with the button and popover nodes as children.
- *
- * ## Accessibility
- *
- * `GtkDropDown` uses the {@link Gtk.AccessibleRole.combo_box} role.
- */
-export const GtkDropDown = "GtkDropDown" as const;
 /**
  * Allows users to edit the displayed text by switching to an “edit mode”.
  *
@@ -14054,51 +14058,6 @@ export const GtkGraphicsOffload = "GtkGraphicsOffload" as const;
  * Starting from GTK 4.12, `GtkGrid` uses the {@link Gtk.AccessibleRole.generic} role.
  */
 export const GtkGrid = "GtkGrid" as const;
-/**
- * Presents a large dynamic grid of items.
- *
- * `GtkGridView` uses its factory to generate one child widget for each
- * visible item and shows them in a grid. The orientation of the grid view
- * determines if the grid reflows vertically or horizontally.
- *
- * `GtkGridView` allows the user to select items according to the selection
- * characteristics of the model. For models that allow multiple selected items,
- * it is possible to turn on _rubberband selection_, using
- * {@link Gtk.GridView.enable-rubberband}.
- *
- * To learn more about the list widget framework, see the
- * overview.
- *
- * # Actions
- *
- * `GtkGridView` defines a set of built-in actions:
- *
- * - `list.activate-item` activates the item at given position by emitting the
- *   the {@link Gtk.GridView.:activate} signal.
- *
- * # CSS nodes
- *
- * ```
- * gridview
- * ├── child[.activatable]
- * │
- * ├── child[.activatable]
- * │
- * ┊
- * ╰── [rubberband]
- * ```
- *
- * `GtkGridView` uses a single CSS node with name `gridview`. Each child uses
- * a single CSS node with name `child`. If the {@link Gtk.ListItem.activatable}
- * property is set, the corresponding row will have the `.activatable` style
- * class. For rubberband selection, a subnode with name `rubberband` is used.
- *
- * # Accessibility
- *
- * `GtkGridView` uses the {@link Gtk.AccessibleRole.grid} role, and the items
- * use the {@link Gtk.AccessibleRole.grid_cell} role.
- */
-export const GtkGridView = "GtkGridView" as const;
 /**
  * Gutter object for {@link View}.
  *
@@ -15059,113 +15018,6 @@ export const GtkListBox = "GtkListBox" as const;
  * when necessary.
  */
 export const GtkListBoxRow = "GtkListBoxRow" as const;
-/**
- * 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 {@link Gtk.ListView.show-separators} 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
- * {@link Gtk.ListView.enable-rubberband}.
- *
- * If you need multiple columns with headers, see {@link Gtk.ColumnView}.
- *
- * To learn more about the list widget framework, see the
- * overview.
- *
- * An example of using `GtkListView`:
- * ```c
- * 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 {@link Gtk.ListView.: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 {@link Gtk.ListView.show-separators}
- * property is set. Each child widget uses a single CSS node named `row`.
- * If the {@link Gtk.ListItem.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 list presentation:
- * .rich-list, .navigation-sidebar or .data-table.
- *
- * # Accessibility
- *
- * `GtkListView` uses the {@link Gtk.AccessibleRole.list} role, and the list
- * items use the {@link Gtk.AccessibleRole.list_item} role.
- */
-export const GtkListView = "GtkListView" as const;
 /**
  * `GtkLockButton` is a widget to obtain and revoke authorizations
  * needed to operate the controls.