@gtkx/ffi 0.1.45 → 0.1.46

package/dist/generated/gtk/icon-view.d.ts

@@ -12,85 +12,549 @@ import * as GObject from "../gobject/index.js";
 import * as Gdk from "../gdk/index.js";
 import { Widget } from "./widget.js";
 export declare class IconView extends Widget {
+    /**
+     * Creates a new `GtkIconView` widget
+     */
     constructor(...args: unknown[]);
+    /**
+     * Creates a new `GtkIconView` widget using the
+     * specified `area` to layout cells inside the icons.
+     * @param area - the `GtkCellArea` to use to layout cells
+     */
     static viewNewWithArea(area: CellArea): IconView;
+    /**
+     * Creates a new `GtkIconView` widget with the model @model.
+     * @param model - The model.
+     */
     static viewNewWithModel(model: TreeModel): IconView;
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Creates a `GdkPaintable` representation of the item at @path.
+     * This image is used for a drag icon.
+     * @param path - a `GtkTreePath` in @icon_view
+     */
     createDragIcon(path: TreePath): Gdk.Paintable | null;
+    /**
+     * Turns `icon_view` into a drop destination for automatic DND. Calling this
+     * method sets `GtkIconView`:reorderable to %FALSE.
+     * @param formats - the formats that the drag will support
+     * @param actions - the bitmask of possible actions for a drag to this
+     */
     enableModelDragDest(formats: Gdk.ContentFormats, actions: Gdk.DragAction): void;
+    /**
+     * Turns `icon_view` into a drag source for automatic DND. Calling this
+     * method sets `GtkIconView`:reorderable to %FALSE.
+     * @param startButtonMask - Mask of allowed buttons to start drag
+     * @param formats - the formats that the drag will support
+     * @param actions - the bitmask of possible actions for a drag from this
+     */
     enableModelDragSource(startButtonMask: Gdk.ModifierType, formats: Gdk.ContentFormats, actions: Gdk.DragAction): void;
+    /**
+     * Gets the setting set by gtk_icon_view_set_activate_on_single_click().
+     */
     getActivateOnSingleClick(): boolean;
+    /**
+     * Fills the bounding rectangle in widget coordinates for the cell specified by
+     * `path` and @cell. If `cell` is %NULL the main cell area is used.
+     *
+     * This function is only valid if `icon_view` is realized.
+     * @param path - a `GtkTreePath`
+     * @param cell - a `GtkCellRenderer`
+     * @param rect - rectangle to fill with cell rect
+     */
     getCellRect(path: TreePath, rect: Ref<Gdk.Rectangle>, cell?: CellRenderer | null): boolean;
+    /**
+     * Returns the value of the ::column-spacing property.
+     */
     getColumnSpacing(): number;
+    /**
+     * Returns the value of the ::columns property.
+     */
     getColumns(): number;
+    /**
+     * Determines the destination item for a given position.
+     * @param dragX - the position to determine the destination item for
+     * @param dragY - the position to determine the destination item for
+     * @param path - Return location for the path of the item
+     * @param pos - Return location for the drop position
+     */
     getDestItemAtPos(dragX: number, dragY: number, path?: Ref<TreePath> | null, pos?: Ref<IconViewDropPosition> | null): boolean;
+    /**
+     * Gets information about the item that is highlighted for feedback.
+     * @param path - Return location for the path of
+     * @param pos - Return location for the drop position
+     */
     getDragDestItem(path?: Ref<TreePath> | null, pos?: Ref<IconViewDropPosition> | null): void;
+    /**
+     * Gets the path and cell for the icon at the given position.
+     * @param x - The x position to be identified
+     * @param y - The y position to be identified
+     * @param path - Return location for the path
+     * @param cell - Return location for the renderer
+     */
     getItemAtPos(x: number, y: number, path?: Ref<TreePath> | null, cell?: Ref<CellRenderer> | null): boolean;
+    /**
+     * Gets the column in which the item `path` is currently
+     * displayed. Column numbers start at 0.
+     * @param path - the `GtkTreePath` of the item
+     */
     getItemColumn(path: TreePath): number;
+    /**
+     * Returns the value of the ::item-orientation property which determines
+     * whether the labels are drawn beside the icons instead of below.
+     */
     getItemOrientation(): Orientation;
+    /**
+     * Returns the value of the ::item-padding property.
+     */
     getItemPadding(): number;
+    /**
+     * Gets the row in which the item `path` is currently
+     * displayed. Row numbers start at 0.
+     * @param path - the `GtkTreePath` of the item
+     */
     getItemRow(path: TreePath): number;
+    /**
+     * Returns the value of the ::item-width property.
+     */
     getItemWidth(): number;
+    /**
+     * Returns the value of the ::margin property.
+     */
     getMargin(): number;
+    /**
+     * Returns the column with markup text for @icon_view.
+     */
     getMarkupColumn(): number;
+    /**
+     * Returns the model the `GtkIconView` is based on.  Returns %NULL if the
+     * model is unset.
+     */
     getModel(): TreeModel | null;
+    /**
+     * Gets the path for the icon at the given position.
+     * @param x - The x position to be identified
+     * @param y - The y position to be identified
+     */
     getPathAtPos(x: number, y: number): TreePath | null;
+    /**
+     * Returns the column with pixbufs for @icon_view.
+     */
     getPixbufColumn(): number;
+    /**
+     * Retrieves whether the user can reorder the list via drag-and-drop.
+     * See gtk_icon_view_set_reorderable().
+     */
     getReorderable(): boolean;
+    /**
+     * Returns the value of the ::row-spacing property.
+     */
     getRowSpacing(): number;
+    /**
+     * Creates a list of paths of all selected items. Additionally, if you are
+     * planning on modifying the model after calling this function, you may
+     * want to convert the returned list into a list of `GtkTreeRowReferences`.
+     * To do this, you can use gtk_tree_row_reference_new().
+     *
+     * To free the return value, use `g_list_free_full`:
+     *
+     * ```c
+     * GtkWidget *icon_view = gtk_icon_view_new ();
+     * // Use icon_view
+     *
+     * GList *list = gtk_icon_view_get_selected_items (GTK_ICON_VIEW (icon_view));
+     *
+     * // use list
+     *
+     * g_list_free_full (list, (GDestroyNotify) gtk_tree_path_free);
+     * ```
+     */
     getSelectedItems(): TreePath[];
+    /**
+     * Gets the selection mode of the @icon_view.
+     */
     getSelectionMode(): SelectionMode;
+    /**
+     * Returns the value of the ::spacing property.
+     */
     getSpacing(): number;
+    /**
+     * Returns the column with text for @icon_view.
+     */
     getTextColumn(): number;
+    /**
+     * Returns the column of @icon_view’s model which is being used for
+     * displaying tooltips on @icon_view’s rows.
+     */
     getTooltipColumn(): number;
+    /**
+     * This function is supposed to be used in a `GtkWidget::query-tooltip`
+     * signal handler for `GtkIconView`. The @x, `y` and `keyboard_tip` values
+     * which are received in the signal handler, should be passed to this
+     * function without modification.
+     *
+     * The return value indicates whether there is an icon view item at the given
+     * coordinates (%TRUE) or not (%FALSE) for mouse tooltips. For keyboard
+     * tooltips the item returned will be the cursor item. When %TRUE, then any of
+     * @model, `path` and `iter` which have been provided will be set to point to
+     * that row and the corresponding model.
+     * @param x - the x coordinate (relative to widget coordinates)
+     * @param y - the y coordinate (relative to widget coordinates)
+     * @param keyboardTip - whether this is a keyboard tooltip or not
+     * @param model - a pointer to receive a `GtkTreeModel`
+     * @param path - a pointer to receive a `GtkTreePath`
+     * @param iter - a pointer to receive a `GtkTreeIter`
+     */
     getTooltipContext(x: number, y: number, keyboardTip: boolean, model?: Ref<TreeModel> | null, path?: Ref<TreePath> | null, iter?: Ref<TreeIter> | null): boolean;
+    /**
+     * Sets `start_path` and `end_path` to be the first and last visible path.
+     * Note that there may be invisible paths in between.
+     *
+     * Both paths should be freed with gtk_tree_path_free() after use.
+     * @param startPath - Return location for start of region
+     * @param endPath - Return location for end of region
+     */
     getVisibleRange(startPath?: Ref<TreePath> | null, endPath?: Ref<TreePath> | null): boolean;
+    /**
+     * Activates the item determined by @path.
+     * @param path - The `GtkTreePath` to be activated
+     */
     itemActivated(path: TreePath): void;
+    /**
+     * Returns %TRUE if the icon pointed to by `path` is currently
+     * selected. If `path` does not point to a valid location, %FALSE is returned.
+     * @param path - A `GtkTreePath` to check selection on.
+     */
     pathIsSelected(path: TreePath): boolean;
+    /**
+     * Moves the alignments of `icon_view` to the position specified by @path.
+     * `row_align` determines where the row is placed, and `col_align` determines
+     * where `column` is placed.  Both are expected to be between 0.0 and 1.0.
+     * 0.0 means left/top alignment, 1.0 means right/bottom alignment, 0.5 means
+     * center.
+     *
+     * If `use_align` is %FALSE, then the alignment arguments are ignored, and the
+     * tree does the minimum amount of work to scroll the item onto the screen.
+     * This means that the item will be scrolled to the edge closest to its current
+     * position.  If the item is currently visible on the screen, nothing is done.
+     *
+     * This function only works if the model is set, and `path` is a valid row on
+     * the model. If the model changes before the `icon_view` is realized, the
+     * centered path will be modified to reflect this change.
+     * @param path - The path of the item to move to.
+     * @param useAlign - whether to use alignment arguments, or %FALSE.
+     * @param rowAlign - The vertical alignment of the item specified by @path.
+     * @param colAlign - The horizontal alignment of the item specified by @path.
+     */
     scrollToPath(path: TreePath, useAlign: boolean, rowAlign: number, colAlign: number): void;
+    /**
+     * Selects all the icons. `icon_view` must has its selection mode set
+     * to %GTK_SELECTION_MULTIPLE.
+     */
     selectAll(): void;
+    /**
+     * Selects the row at @path.
+     * @param path - The `GtkTreePath` to be selected.
+     */
     selectPath(path: TreePath): void;
+    /**
+     * Calls a function for each selected icon. Note that the model or
+     * selection cannot be modified from within this function.
+     * @param func - The function to call for each selected icon.
+     * @param data - User data to pass to the function.
+     */
     selectedForeach(func: (...args: unknown[]) => unknown, data?: number | null): void;
+    /**
+     * Causes the `GtkIconView`::item-activated signal to be emitted on
+     * a single click instead of a double click.
+     * @param single - %TRUE to emit item-activated on a single click
+     */
     setActivateOnSingleClick(single: boolean): void;
+    /**
+     * Sets the ::column-spacing property which specifies the space
+     * which is inserted between the columns of the icon view.
+     * @param columnSpacing - the column spacing
+     */
     setColumnSpacing(columnSpacing: number): void;
+    /**
+     * Sets the ::columns property which determines in how
+     * many columns the icons are arranged. If `columns` is
+     * -1, the number of columns will be chosen automatically
+     * to fill the available area.
+     * @param columns - the number of columns
+     */
     setColumns(columns: number): void;
+    /**
+     * Sets the item that is highlighted for feedback.
+     * @param path - The path of the item to highlight
+     * @param pos - Specifies where to drop, relative to the item
+     */
     setDragDestItem(pos: IconViewDropPosition, path?: TreePath | null): void;
+    /**
+     * Sets the ::item-orientation property which determines whether the labels
+     * are drawn beside the icons instead of below.
+     * @param orientation - the relative position of texts and icons
+     */
     setItemOrientation(orientation: Orientation): void;
+    /**
+     * Sets the `GtkIconView`:item-padding property which specifies the padding
+     * around each of the icon view’s items.
+     * @param itemPadding - the item padding
+     */
     setItemPadding(itemPadding: number): void;
+    /**
+     * Sets the ::item-width property which specifies the width
+     * to use for each item. If it is set to -1, the icon view will
+     * automatically determine a suitable item size.
+     * @param itemWidth - the width for each item
+     */
     setItemWidth(itemWidth: number): void;
+    /**
+     * Sets the ::margin property which specifies the space
+     * which is inserted at the top, bottom, left and right
+     * of the icon view.
+     * @param margin - the margin
+     */
     setMargin(margin: number): void;
+    /**
+     * Sets the column with markup information for `icon_view` to be
+     * @column. The markup column must be of type `G_TYPE_STRING`.
+     * If the markup column is set to something, it overrides
+     * the text column set by gtk_icon_view_set_text_column().
+     * @param column - A column in the currently used model, or -1 to display no text
+     */
     setMarkupColumn(column: number): void;
+    /**
+     * Sets the model for a `GtkIconView`.
+     * If the `icon_view` already has a model set, it will remove
+     * it before setting the new model.  If `model` is %NULL, then
+     * it will unset the old model.
+     * @param model - The model.
+     */
     setModel(model?: TreeModel | null): void;
+    /**
+     * Sets the column with pixbufs for `icon_view` to be @column. The pixbuf
+     * column must be of type `GDK_TYPE_PIXBUF`
+     * @param column - A column in the currently used model, or -1 to disable
+     */
     setPixbufColumn(column: number): void;
+    /**
+     * This function is a convenience function to allow you to reorder models that
+     * support the `GtkTreeDragSourceIface` and the `GtkTreeDragDestIface`. Both
+     * `GtkTreeStore` and `GtkListStore` support these. If `reorderable` is %TRUE, then
+     * the user can reorder the model by dragging and dropping rows.  The
+     * developer can listen to these changes by connecting to the model's
+     * row_inserted and row_deleted signals. The reordering is implemented by setting up
+     * the icon view as a drag source and destination. Therefore, drag and
+     * drop can not be used in a reorderable view for any other purpose.
+     *
+     * This function does not give you any degree of control over the order -- any
+     * reordering is allowed.  If more control is needed, you should probably
+     * handle drag and drop manually.
+     * @param reorderable - %TRUE, if the list of items can be reordered.
+     */
     setReorderable(reorderable: boolean): void;
+    /**
+     * Sets the ::row-spacing property which specifies the space
+     * which is inserted between the rows of the icon view.
+     * @param rowSpacing - the row spacing
+     */
     setRowSpacing(rowSpacing: number): void;
+    /**
+     * Sets the selection mode of the @icon_view.
+     * @param mode - The selection mode
+     */
     setSelectionMode(mode: SelectionMode): void;
+    /**
+     * Sets the ::spacing property which specifies the space
+     * which is inserted between the cells (i.e. the icon and
+     * the text) of an item.
+     * @param spacing - the spacing
+     */
     setSpacing(spacing: number): void;
+    /**
+     * Sets the column with text for `icon_view` to be @column. The text
+     * column must be of type `G_TYPE_STRING`.
+     * @param column - A column in the currently used model, or -1 to display no text
+     */
     setTextColumn(column: number): void;
+    /**
+     * Sets the tip area of `tooltip` to the area which `cell` occupies in
+     * the item pointed to by @path. See also gtk_tooltip_set_tip_area().
+     *
+     * See also gtk_icon_view_set_tooltip_column() for a simpler alternative.
+     * @param tooltip - a `GtkTooltip`
+     * @param path - a `GtkTreePath`
+     * @param cell - a `GtkCellRenderer`
+     */
     setTooltipCell(tooltip: Tooltip, path: TreePath, cell?: CellRenderer | null): void;
+    /**
+     * If you only plan to have simple (text-only) tooltips on full items, you
+     * can use this function to have `GtkIconView` handle these automatically
+     * for you. `column` should be set to the column in @icon_view’s model
+     * containing the tooltip texts, or -1 to disable this feature.
+     *
+     * When enabled, `GtkWidget:has-tooltip` will be set to %TRUE and
+     * `icon_view` will connect a `GtkWidget::query-tooltip` signal handler.
+     *
+     * Note that the signal handler sets the text with gtk_tooltip_set_markup(),
+     * so &, <, etc have to be escaped in the text.
+     * @param column - an integer, which is a valid column number for @icon_view’s model
+     */
     setTooltipColumn(column: number): void;
+    /**
+     * Sets the tip area of `tooltip` to be the area covered by the item at @path.
+     * See also gtk_icon_view_set_tooltip_column() for a simpler alternative.
+     * See also gtk_tooltip_set_tip_area().
+     * @param tooltip - a `GtkTooltip`
+     * @param path - a `GtkTreePath`
+     */
     setTooltipItem(tooltip: Tooltip, path: TreePath): void;
+    /**
+     * Unselects all the icons.
+     */
     unselectAll(): void;
+    /**
+     * Unselects the row at @path.
+     * @param path - The `GtkTreePath` to be unselected.
+     */
     unselectPath(path: TreePath): void;
+    /**
+     * Undoes the effect of gtk_icon_view_enable_model_drag_dest(). Calling this
+     * method sets `GtkIconView`:reorderable to %FALSE.
+     */
     unsetModelDragDest(): void;
+    /**
+     * Undoes the effect of gtk_icon_view_enable_model_drag_source(). Calling this
+     * method sets `GtkIconView`:reorderable to %FALSE.
+     */
     unsetModelDragSource(): void;
+    /**
+     * Adds an attribute mapping to the list in @cell_layout.
+     *
+     * The `column` is the column of the model to get a value from, and the
+     * `attribute` is the property on `cell` to be set from that value. So for
+     * example if column 2 of the model contains strings, you could have the
+     * “text” attribute of a `GtkCellRendererText` get its values from column 2.
+     * In this context "attribute" and "property" are used interchangeably.
+     * @param cell - a `GtkCellRenderer`
+     * @param attribute - a property on the renderer
+     * @param column - the column position on the model to get the attribute from
+     */
     addAttribute(cell: CellRenderer, attribute: string, column: number): void;
+    /**
+     * Unsets all the mappings on all renderers on `cell_layout` and
+     * removes all renderers from @cell_layout.
+     */
     clear(): void;
+    /**
+     * Clears all existing attributes previously set with
+     * gtk_cell_layout_set_attributes().
+     * @param cell - a `GtkCellRenderer` to clear the attribute mapping on
+     */
     clearAttributes(cell: CellRenderer): void;
+    /**
+     * Returns the underlying `GtkCellArea` which might be `cell_layout` if called on a `GtkCellArea` or might be %NULL if no `GtkCellArea`
+     * is used by @cell_layout.
+     */
     getArea(): CellArea | null;
+    /**
+     * Returns the cell renderers which have been added to @cell_layout.
+     */
     getCells(): CellRenderer[];
+    /**
+     * Adds the `cell` to the end of @cell_layout. If `expand` is %FALSE, then the
+     * `cell` is allocated no more space than it needs. Any unused space is
+     * divided evenly between cells for which `expand` is %TRUE.
+     *
+     * Note that reusing the same cell renderer is not supported.
+     * @param cell - a `GtkCellRenderer`
+     * @param expand - %TRUE if `cell` is to be given extra space allocated to @cell_layout
+     */
     packEnd(cell: CellRenderer, expand: boolean): void;
+    /**
+     * Packs the `cell` into the beginning of @cell_layout. If `expand` is %FALSE,
+     * then the `cell` is allocated no more space than it needs. Any unused space
+     * is divided evenly between cells for which `expand` is %TRUE.
+     *
+     * Note that reusing the same cell renderer is not supported.
+     * @param cell - a `GtkCellRenderer`
+     * @param expand - %TRUE if `cell` is to be given extra space allocated to @cell_layout
+     */
     packStart(cell: CellRenderer, expand: boolean): void;
+    /**
+     * Re-inserts `cell` at @position.
+     *
+     * Note that `cell` has already to be packed into `cell_layout` for this to function properly.
+     * @param cell - a `GtkCellRenderer` to reorder
+     * @param position - new position to insert `cell` at
+     */
     reorder(cell: CellRenderer, position: number): void;
+    /**
+     * Sets the `GtkCellLayout`DataFunc to use for @cell_layout.
+     *
+     * This function is used instead of the standard attributes mapping
+     * for setting the column value, and should set the value of @cell_layout’s
+     * cell renderer(s) as appropriate.
+     *
+     * `func` may be %NULL to remove a previously set function.
+     * @param cell - a `GtkCellRenderer`
+     * @param func - the `GtkCellLayout`DataFunc to use
+     * @param funcData - user data for @func
+     * @param destroy - destroy notify for @func_data
+     */
     setCellDataFunc(cell: CellRenderer, destroy: () => void, func?: (...args: unknown[]) => unknown | null, funcData?: number | null): void;
+    /**
+     * Returns the size of a non-scrolling border around the
+     * outside of the scrollable.
+     *
+     * An example for this would be treeview headers. GTK can use
+     * this information to display overlaid graphics, like the
+     * overshoot indication, at the right position.
+     * @param border - return location for the results
+     */
     getBorder(border: Ref<Border>): boolean;
+    /**
+     * Retrieves the `GtkAdjustment` used for horizontal scrolling.
+     */
     getHadjustment(): Adjustment | null;
+    /**
+     * Gets the horizontal `GtkScrollablePolicy`.
+     */
     getHscrollPolicy(): ScrollablePolicy;
+    /**
+     * Retrieves the `GtkAdjustment` used for vertical scrolling.
+     */
     getVadjustment(): Adjustment | null;
+    /**
+     * Gets the vertical `GtkScrollablePolicy`.
+     */
     getVscrollPolicy(): ScrollablePolicy;
+    /**
+     * Sets the horizontal adjustment of the `GtkScrollable`.
+     * @param hadjustment - a `GtkAdjustment`
+     */
     setHadjustment(hadjustment?: Adjustment | null): void;
+    /**
+     * Sets the `GtkScrollablePolicy`.
+     *
+     * The policy determines whether horizontal scrolling should start
+     * below the minimum width or below the natural width.
+     * @param policy - the horizontal `GtkScrollablePolicy`
+     */
     setHscrollPolicy(policy: ScrollablePolicy): void;
+    /**
+     * Sets the vertical adjustment of the `GtkScrollable`.
+     * @param vadjustment - a `GtkAdjustment`
+     */
     setVadjustment(vadjustment?: Adjustment | null): void;
+    /**
+     * Sets the `GtkScrollablePolicy`.
+     *
+     * The policy determines whether vertical scrolling should start
+     * below the minimum height or below the natural height.
+     * @param policy - the vertical `GtkScrollablePolicy`
+     */
     setVscrollPolicy(policy: ScrollablePolicy): void;
     connect(signal: "activate-cursor-item", handler: (self: IconView) => boolean, after?: boolean): number;
     connect(signal: "item-activated", handler: (self: IconView, path: TreePath) => void, after?: boolean): number;