Package-level declarations
Types
The GtkAboutDialog
offers a simple way to display information about a program.
GtkAccessible
is an interface for describing UI elements for Assistive Technologies.
The priority of an accessibility announcement.
The possible values for the %GTK_ACCESSIBLE_PROPERTY_AUTOCOMPLETE accessible property.
The possible values for the %GTK_ACCESSIBLE_STATE_INVALID accessible state.
A boxed type which wraps a list of references to GtkAccessible objects.
The various platform states which can be queried using method@Gtk.Accessible.get_platform_state.
The possible accessible properties of a iface@Accessible.
This interface describes ranged controls, e.g. controls which have a single value within an allowed range and that can optionally be changed by the user.
The possible accessible relations of a iface@Accessible.
The accessible role for a iface@Accessible implementation.
The possible values for the %GTK_ACCESSIBLE_PROPERTY_SORT accessible property.
The possible accessible states of a iface@Accessible.
An interface for accessible objects containing formatted text.
The type of contents change operation.
The granularity for queries about the text contents of a iface@Gtk.AccessibleText implementation.
A range inside the text of an accessible object.
The possible values for the %GTK_ACCESSIBLE_STATE_PRESSED accessible state.
The GtkActionable
interface provides a convenient way of associating widgets with actions.
A GtkShortcutAction
that calls gtk_widget_activate().
GtkAdjustment
is a model for a numeric value.
A GtkAlertDialog
object collects the arguments that are needed to present a message to the user.
A GtkShortcutTrigger
that combines two triggers.
GtkAnyFilter
matches an item when at least one of its filters matches.
GtkAppChooser
is an interface for widgets which allow the user to choose an application.
The GtkAppChooserButton
lets the user select an application.
GtkAppChooserDialog
shows a GtkAppChooserWidget
inside a GtkDialog
.
GtkAppChooserWidget
is a widget for selecting applications.
GtkApplication
is a high-level API for writing applications.
Types of user actions that may be blocked by GtkApplication
.
GtkApplicationWindow
is a GtkWindow
subclass that integrates with GtkApplication
.
GtkAspectFrame
preserves the aspect ratio of its child.
GtkAssistantPage
is an auxiliary object used by `GtkAssistant.
Type of callback used to calculate the next page in a GtkAssistant
.
Determines the page role inside a GtkAssistant
.
Baseline position in a row of widgets.
GtkBinLayout
is a GtkLayoutManager
subclass useful for create "bins" of widgets.
An opaque, stack-allocated struct for iterating over the elements of a GtkBitset
.
GtkBookmarkList
is a list model that wraps GBookmarkFile
.
GtkBoolFilter
evaluates a boolean GtkExpression
to determine whether to include items.
Describes how the border of a UI element should be rendered.
The GtkBox
widget arranges child widgets into a single row or column.
GtkBoxLayout
is a layout manager that arranges children in a single row or column.
An opaque context struct for GtkBuildableParser
.
A sub-parser for GtkBuildable
implementations.
The list of flags that can be passed to gtk_builder_create_closure().
A GtkBuilderScope
implementation for the C language.
Error codes that identify various errors that can occur while using GtkBuilder
.
GtkBuilderListItemFactory
is a GtkListItemFactory
that creates widgets by instantiating GtkBuilder
UI templates.
GtkBuilderScope
is an interface to provide language binding support to GtkBuilder
.
The GtkButton
widget is generally used to trigger a callback function that is called when the button is pressed.
Prebuilt sets of buttons for GtkDialog
.
A GtkShortcutAction
that invokes a callback.
A variant of GtkClosureExpression
using a C closure.
The type of the callback functions used for iterating over the cell renderers and their allocated areas inside a GtkCellArea
, see gtk_cell_area_foreach_alloc().
An abstract class for laying out GtkCellRenderer
s
A cell area that renders GtkCellRenderers into a row or a column
Stores geometrical information for a series of rows in a GtkCellArea
The type of the callback functions used for iterating over the cell renderers of a GtkCellArea
, see gtk_cell_area_foreach().
Interface for widgets that can be used for editing cells
An interface for packing cells
A function which should set the value of @cell_layout’s cell renderer(s) as appropriate.
An object for rendering a single cell
Renders a keyboard accelerator in a cell
The available modes for property@Gtk.CellRendererAccel:accel-mode.
Renders a combobox in a cell
Identifies how the user can interact with a particular cell.
Renders a pixbuf in a cell
Renders numbers as progress bars
Renders a spin button in a cell
Renders a spinning animation in a cell
Tells how a cell is to be rendered.
Renders text in a cell
Renders a toggle button in a cell
A widget displaying a single row of a GtkTreeModel
GtkCenterBox
arranges three children in a row, keeping the middle child centered as well as possible.
GtkCenterLayout
is a layout manager that manages up to three children.
A GtkCheckButton
places a label next to an indicator.
An expression using a custom GClosure
to compute the value from its parameters.
The GtkColorButton
allows to open a color chooser dialog to change the color.
GtkColorChooser
is an interface that is implemented by widgets for choosing colors.
A dialog for choosing a color.
The GtkColorChooserWidget
widget lets the user select a color.
A GtkColorDialog
object collects the arguments that are needed to present a color chooser dialog to the user, such as a title for the dialog and whether it should be modal.
The GtkColorDialogButton
is a wrapped around a class@Gtk.ColorDialog and allows to open a color chooser dialog to change the color.
GtkColumnView
presents a large dynamic list of items using multiple columns with headers.
GtkColumnViewCell
is used by class@Gtk.ColumnViewColumn to represent items in a cell in class@Gtk.ColumnView.
GtkColumnViewColumn
represents the columns being added to a GtkColumnView
.
GtkColumnViewRow
is used by class@Gtk.ColumnView to allow configuring how rows are displayed.
GtkColumnViewSorter
is a sorter implementation that is geared towards the needs of GtkColumnView
.
A GtkComboBox
is a widget that allows the user to choose from a list of valid choices.
A GtkComboBoxText
is a simple variant of GtkComboBox
for text-only use cases.
A constant value in a GtkExpression
.
GtkConstraint
describes a constraint between attributes of two widgets, expressed as a linear equation.
The widget attributes that can be used when creating a class@Constraint.
A GtkConstraintGuide
is an invisible layout element in a GtkConstraintLayout
.
A layout manager using constraints to describe relations between widgets.
GtkLayoutChild
subclass for children in a GtkConstraintLayout
.
The relation between two terms of a constraint.
The strength of a constraint, expressed as a symbolic constant.
The GtkConstraintTarget
interface is implemented by objects that can be used as source or target in GtkConstraint
s.
Domain for VFL parsing errors.
Controls how a content should be made to fit inside an allocation.
Specifies which corner a child widget should be placed in when packed into a GtkScrolledWindow.
A description of a location inside a CSS stream.
Errors that can occur while parsing CSS.
Warnings that can occur while parsing CSS.
GtkCssProvider
is an object implementing the GtkStyleProvider
interface for CSS.
Defines a part of a CSS document.
A CSS style change.
GtkCustomFilter
determines whether to include items with a callback.
User function that is called to determine if the @item should be matched.
GtkCustomSorter
is a GtkSorter
implementation that sorts via a callback function.
Flags to use with gtk_set_debug_flags().
Passed to various keybinding signals for deleting text.
Error codes in the GTK_DIALOG_ERROR
domain that can be returned by async dialog functions.
Flags used to influence dialog construction.
Focus movement types.
GtkDirectoryList
is a list model that wraps g_file_enumerate_children_async().
GtkDragSource
is an event controller to initiate Drag-And-Drop operations.
GtkDrawingArea
is a widget that allows drawing with cairo.
Whenever @drawing_area needs to redraw, this function will be called.
GtkDropControllerMotion
is an event controller tracking the pointer during Drag-and-Drop operations.
GtkDropTarget
is an event controller to receive Drag-and-Drop operations.
GtkDropTargetAsync
is an event controller to receive Drag-and-Drop operations, asynchronously.
A GtkEditableLabel
is a label that allows users to edit the text by switching to an “edit mode”.
The identifiers for iface@Gtk.Editable properties.
The GtkEmojiChooser
is used by text widgets such as GtkEntry
or GtkTextView
to let users insert Emoji characters.
GtkEntry
is a single line text entry widget.
A GtkEntryBuffer
hold the text displayed in a GtkText
widget.
GtkEntryCompletion
is an auxiliary object to provide completion functionality for GtkEntry
.
A function which decides whether the row indicated by @iter matches a given @key, and should be displayed as a possible completion for @key.
Specifies the side of the entry at which an icon is placed.
GtkEventController
is the base class for event controllers.
GtkEventControllerFocus
is an event controller to keep track of keyboard focus.
GtkEventControllerKey
is an event controller that provides access to key events.
GtkEventControllerLegacy
is an event controller that provides raw access to the event stream.
GtkEventControllerMotion
is an event controller tracking the pointer position.
GtkEventControllerScroll
is an event controller that handles scroll events.
Describes the behavior of a GtkEventControllerScroll
.
Describes the state of a struct@Gdk.EventSequence in a class@Gesture.
GtkEveryFilter
matches an item when each of its filters matches.
GtkExpression
provides a way to describe references to values.
Callback called by gtk_expression_watch() when the expression value changes.
An opaque structure representing a watched GtkExpression
.
GtkFileChooser
is an interface that can be implemented by file selection widgets.
Describes whether a GtkFileChooser
is being used to open existing files or to save to a possibly new file.
GtkFileChooserDialog
is a dialog suitable for use with “File Open” or “File Save” commands.
These identify the various errors that can occur while calling GtkFileChooser
functions.
GtkFileChooserNative
is an abstraction of a dialog suitable for use with “File Open” or “File Save as” commands.
GtkFileChooserWidget
is a widget for choosing files.
A GtkFileDialog
object collects the arguments that are needed to present a file chooser dialog to the user, such as a title for the dialog and whether it should be modal.
GtkFileFilter
filters files by name or mime type.
A GtkFileLauncher
object collects the arguments that are needed to open a file with an application.
Describes changes in a filter in more detail and allows objects using the filter to optimize refiltering items.
GtkFilterListModel
is a list model that filters the elements of the underlying model according to a GtkFilter
.
Describes the known strictness of a filter.
GtkFixedLayout
is a layout manager which can place child widgets at fixed positions.
GtkLayoutChild
subclass for children in a GtkFixedLayout
.
GtkFlattenListModel
is a list model that concatenates other list models.
A GtkFlowBox
puts child widgets in reflowing grid.
GtkFlowBoxChild
is the kind of widget that can be added to a GtkFlowBox
.
Called for flow boxes that are bound to a GListModel
.
A function that will be called whenever a child changes or is added.
A function used by gtk_flow_box_selected_foreach().
A function to compare two children to determine which should come first.
The GtkFontButton
allows to open a font chooser dialog to change the font.
GtkFontChooser
is an interface that can be implemented by widgets for choosing fonts.
The GtkFontChooserDialog
widget is a dialog for selecting a font.
Specifies the granularity of font selection that is desired in a GtkFontChooser
.
The GtkFontChooserWidget
widget lets the user select a font.
A GtkFontDialog
object collects the arguments that are needed to present a font chooser dialog to the user, such as a title for the dialog and whether it should be modal.
The GtkFontDialogButton
is wrapped around a class@Gtk.FontDialog and allows to open a font chooser dialog to change the font.
The type of function that is used for deciding what fonts get shown in a GtkFontChooser
.
Values for the property@Gtk.Settings:gtk-font-rendering setting that influence how GTK renders fonts.
GtkGesture
is the base class for gesture recognition.
GtkGestureClick
is a GtkGesture
implementation for clicks.
GtkGestureDrag
is a GtkGesture
implementation for drags.
GtkGestureLongPress
is a GtkGesture
for long presses.
GtkGesturePan
is a GtkGesture
for pan gestures.
GtkGestureRotate
is a GtkGesture
for 2-finger rotations.
GtkGestureSingle
is a GtkGestures
subclass optimized for singe-touch and mouse gestures.
GtkGestureStylus
is a GtkGesture
specific to stylus input.
GtkGestureSwipe
is a GtkGesture
for swipe gestures.
GtkGestureZoom
is a GtkGesture
for 2-finger pinch/zoom gestures.
A widget that allows to bypass gsk rendering for its child by passing the content directly to the compositor.
Represents the state of graphics offloading.
GtkGrid
is a container which arranges its child widgets in rows and columns.
GtkGridLayout
is a layout manager which arranges child widgets in rows and columns.
GtkLayoutChild
subclass for children in a GtkGridLayout
.
Used to specify options for gtk_icon_theme_lookup_icon().
Contains information found when looking up an icon in GtkIconTheme
.
Error codes for GtkIconTheme
operations.
GtkIconView
is a widget which displays data in a grid of icons.
An enum for determining where a dropped item goes.
A function used by gtk_icon_view_selected_foreach() to map all selected rows.
GtkIMContextSimple
is an input method supporting table-based input methods.
GtkIMMulticontext
is an input method context supporting multiple, switchable input methods.
Describes hints that might be taken into account by input methods or applications.
Describes primary purpose of the input widget.
GtkInscription
is a widget to show text in a predefined area.
The different methods to handle text in #GtkInscription when it doesn't fit the available space.
Used for justifying the text inside a class@Label widget.
A GtkShortcutTrigger
that triggers when a specific keyval and modifiers are pressed.
The GtkLabel
widget displays a small amount of text.
GtkLayoutChild
is the base class for objects that are meant to hold layout properties.
Layout managers are delegate classes that handle the preferred size and the allocation of a widget.
GtkLevelBar
is a widget that can be used as a level indicator.
Describes how class@LevelBar contents should be rendered.
A GtkLinkButton
is a button with a hyperlink.
GtkListBase
is the abstract base class for GTK's list widgets.
Called for list boxes that are bound to a GListModel
with gtk_list_box_bind_model() for each item that gets added to the model.
Will be called whenever the row changes or is added and lets you control if the row should be visible or not.
A function used by gtk_list_box_selected_foreach().
GtkListBoxRow
is the kind of widget that can be added to a GtkListBox
.
Compare two rows to determine which should be first.
Whenever @row changes or which row is before @row changes this is called, which lets you update the header on @row.
GtkListHeader
is used by list widgets to represent the headers they display.
A GtkListItemFactory
creates widgets for the items taken from a GListModel
.
List of actions to perform when scrolling to items in a list widget.
A list-like data structure that can be used with the class@Gtk.TreeView.
Used to configure the focus behavior in the GTK_DIR_TAB_FORWARD
and GTK_DIR_TAB_BACKWARD
direction, like the Tab key in a class@Gtk.ListView.
GtkLockButton
is a widget to obtain and revoke authorizations needed to operate the controls.
A GtkMapListModel
maps the items in a list model to different items.
User function that is called to map an @item of the original model to an item expected by the map model.
GtkMediaControls
is a widget to show controls for a video.
GtkMediaFile
implements GtkMediaStream
for files.
GtkMediaStream
is the integration point for media playback inside GTK.
The GtkMenuButton
widget is used to display a popup when clicked.
User-provided callback function to create a popup for a GtkMenuButton
on demand.
GtkMessageDialog
presents a dialog with some message text.
The type of message being displayed in a class@MessageDialog.
A GtkShortcutAction
that calls gtk_widget_mnemonic_activate().
A GtkShortcutTrigger
that triggers when a specific mnemonic is pressed.
GtkMountOperation
is an implementation of GMountOperation
.
Passed as argument to various keybinding signals for moving the cursor position.
GtkMultiFilter
is the base class for filters that combine multiple filters.
GtkMultiSelection
is a GtkSelectionModel
that allows selecting multiple elements.
GtkMultiSorter
combines multiple sorters by trying them in turn.
A GtkShortcutAction
that activates an action by name.
Native dialogs are platform dialogs that don't use GtkDialog
.
Options for selecting a different wrap mode for natural size requests.
A GtkShortcutTrigger
that never triggers.
GtkNoSelection
is a GtkSelectionModel
that does not allow selecting anything.
GtkNotebookPage
is an auxiliary object used by GtkNotebook
.
The parameter used in the action signals of GtkNotebook
.
A GtkShortcutAction
that does nothing.
Used to determine the layout of pages on a sheet when printing multiple pages per sheet.
GtkNumericSorter
is a GtkSorter
that compares numbers.
A GObject
value in a GtkExpression
.
The GtkOrientable
interface is implemented by all widgets that can be oriented horizontally or vertically.
Represents the orientation of widgets and other objects.
GtkOverlayLayout
is the layout manager used by class@Gtk.Overlay.
GtkLayoutChild
subclass for children in a GtkOverlayLayout
.
Struct defining a pad action entry.
The type of a pad action.
GtkPadController
is an event controller for the pads found in drawing tablets.
See also gtk_print_settings_set_orientation().
The type of function that is passed to gtk_print_run_page_setup_dialog_async().
GtkPageSetupUnixDialog
implements a page setup dialog for platforms which don’t provide a native page setup dialog, like Unix.
Describes the panning direction of a class@GesturePan.
A widget with two panes, arranged either horizontally or vertically.
A GParamSpec
for properties holding a GtkExpression
.
GtkPasswordEntry
is an entry that has been tailored for entering secrets.
A GtkEntryBuffer
that locks the underlying memory to prevent it from being swapped to disk.
Flags that influence the behavior of method@Widget.pick.
Determines how the size should be computed to achieve the one of the visibility mode for the scrollbars.
GtkPopover
is a bubble-like context popup.
GtkPopoverMenu
is a subclass of GtkPopover
that implements menu behavior.
GtkPopoverMenuBar
presents a horizontal bar of items that pop up popover menus when clicked.
Flags that affect how class@Gtk.PopoverMenu widgets built from a class@Gio.MenuModel are created and displayed.
Describes which edge of a widget a certain feature is positioned at.
A print backend.
Specifies which features the print dialog should offer.
A GtkPrintContext
encapsulates context information that is required when drawing pages for printing.
A GtkPrintDialog
object collects the arguments that are needed to present a print dialog to the user, such as a title for the dialog and whether it should be modal.
See also gtk_print_settings_set_duplex().
The type of function passed to gtk_enumerate_printers().
Error codes that identify various errors that can occur while using the GTK printing support.
The type of callback that is passed to gtk_print_job_send().
GtkPrintOperation
is the high-level, portable printing API.
Determines what action the print operation should perform.
GtkPrintOperationPreview
is the interface that is used to implement print preview.
The result of a print operation.
See also gtk_print_job_set_pages()
See also gtk_print_settings_set_quality().
A GtkPrintSettings
object represents the settings of a print dialog in a system-independent way.
Function called by method@Gtk.PrintSettings.foreach on every key/value pair inside a class@Gtk.PrintSettings.
A GtkPrintSetup
is an auxiliary object for printing that allows decoupling the setup from the printing.
The status gives a rough indication of the completion of a running print operation.
GtkPrintUnixDialog
implements a print dialog for platforms which don’t provide a native print dialog, like Unix.
GtkProgressBar
is typically used to display the progress of a long running operation.
Describes limits of a class@EventController for handling events targeting other widgets.
Describes the stage at which events are fed into a class@EventController.
A GObject
property value in a GtkExpression
.
GtkRange
is the common base class for widgets which visualize an adjustment.
Meta-data to be passed to gtk_recent_manager_add_full() when registering a recently used resource.
GtkRecentInfo
contains the metadata associated with an item in the recently used files list.
GtkRecentManager
manages and looks up recently used files.
Error codes for GtkRecentManager
operations
Represents a request of a screen object in a given orientation. These are primarily used in container implementations when allocating a natural size for children calling. See func@distribute_natural_allocation.
A GtkRequisition
represents the desired size of a widget. See class.Widget.html#height-for-width-geometry-management for more information.
Predefined values for use as response ids in gtk_dialog_add_button().
These enumeration values describe the possible transitions when the child of a GtkRevealer
widget is shown or hidden.
GtkScaleButton
provides a button which pops up a scale widget.
Function that formats the value of a scale.
GtkScrollable
is an interface for widgets with native scrolling ability.
Defines the policy to be used in a scrollable widget when updating the scrolled window adjustments in a given orientation.
The GtkScrollbar
widget is a horizontal or vertical scrollbar.
GtkScrolledWindow
is a container that makes its child scrollable.
The GtkScrollInfo
can be used to provide more accurate data on how a scroll operation should be performed.
Passed as argument to various keybinding signals.
Scrolling types.
GtkSearchEntry
is an entry widget that has been tailored for use as a search entry.
GtkSectionModel
is an interface that adds support for sections to list models.
GtkSelectionFilterModel
is a list model that presents the selection from a GtkSelectionModel
.
Used to control what selections users are allowed to make.
GtkSelectionModel
is an interface that add support for selection to list models.
Determines how GTK handles the sensitivity of various controls, such as combo box buttons.
GtkSeparator
is a horizontal or vertical separator widget.
GtkSettings
provides a mechanism to share global settings between applications.
GtkShortcutAction
encodes an action that can be triggered by a keyboard shortcut.
List of flags that can be passed to action activation.
GtkShortcutController
is an event controller that manages shortcuts.
Prototype for shortcuts based on user callbacks.
GtkShortcutLabel
displays a single keyboard shortcut or gesture.
The GtkShortcutManager
interface is used to implement shortcut scopes.
Describes where class@Shortcuts added to a class@ShortcutController get handled.
A GtkShortcutsGroup
represents a group of related keyboard shortcuts or gestures.
A GtkShortcutsSection
collects all the keyboard shortcuts and gestures for a major application mode.
A GtkShortcutsShortcut
represents a single keyboard shortcut or gesture with a short text.
A GtkShortcutsWindow
shows information about the keyboard shortcuts and gestures of an application.
GtkShortcutTrigger
tracks how a GtkShortcut
should be activated.
GtkShortcutType specifies the kind of shortcut that is being described.
A GtkShortcut
Action that emits a signal.
GtkSignalListItemFactory
is a GtkListItemFactory
that emits signals to manage listitems.
GtkSingleSelection
is a GtkSelectionModel
that allows selecting a single item.
The mode of the size group determines the directions in which the size group affects the requested sizes of its component widgets.
Specifies a preference for height-for-width or width-for-height geometry management.
GtkSliceListModel
is a list model that presents a slice of another model.
Describes changes in a sorter in more detail and allows users to optimize resorting.
Describes the type of order that a GtkSorter
may produce.
A GListModel
that sorts the elements of an underlying model according to a GtkSorter
.
A GtkSpinButton
is an ideal way to allow the user to set the value of some attribute.
Determines whether the spin button displays values outside the adjustment bounds.
GtkStackPage
is an auxiliary class used by GtkStack
.
A GtkStackSidebar
uses a sidebar to switch between GtkStack
pages.
The GtkStackSwitcher
shows a row of buttons to switch between GtkStack
pages.
Possible transitions between pages in a GtkStack
widget.
Describes a widget state.
GtkStringFilter
determines whether to include items by comparing strings to a fixed search term.
Specifies how search strings are matched inside text.
GtkStringList
is a list model that wraps an array of strings.
GtkStringObject
is the type of items in a GtkStringList
.
GtkStringSorter
is a GtkSorter
that compares strings.
GtkStyleContext
stores styling information affecting a widget.
Flags that modify the behavior of gtk_style_context_to_string().
GtkStyleProvider
is an interface for style information used by GtkStyleContext
.
GtkSwitch
is a "light switch" that has two states: on or off.
The indexes of colors passed to symbolic color rendering, such as vfunc@Gtk.SymbolicPaintable.snapshot_symbolic.
GtkSymbolicPaintable
is an interface that support symbolic colors in paintables.
Values that can be passed to the vfunc@Gtk.Widget.system_setting_changed vfunc.
The GtkText
widget is a single-line text entry widget.
Stores text and attributes for display in a GtkTextView
.
A notification callback used by method@Gtk.TextBuffer.add_commit_notify.
Values for callback@Gtk.TextBufferCommitNotify to denote the point of the notification.
The predicate function used by gtk_text_iter_forward_find_char() and gtk_text_iter_backward_find_char().
A GtkTextChildAnchor
is a spot in a GtkTextBuffer
where child widgets can be “anchored”.
Reading directions for text.
Granularity types that extend the text selection. Use the GtkTextView::extend-selection
signal to customize the selection.
Flags affecting how a search is done.
The collection of tags in a GtkTextBuffer
A function used with gtk_text_tag_table_foreach(), to iterate over every GtkTextTag
inside a GtkTextTagTable
.
A widget that displays the contents of a class@Gtk.TextBuffer.
Used to reference the layers of GtkTextView
for the purpose of customized drawing with the ::snapshot_layer vfunc.
Used to reference the parts of GtkTextView
.
Callback type for adding a function to update animations. See gtk_widget_add_tick_callback().
A GtkToggleButton
is a button which remains “pressed-in” when clicked.
A function to set the properties of a cell instead of just using the straight mapping between the cell and the model.
Interface for Drag-and-Drop destinations in GtkTreeView
.
Interface for Drag-and-Drop destinations in GtkTreeView
.
GtkTreeExpander
is a widget that provides an expander for a list.
The GtkTreeIter
is the primary structure for accessing a GtkTreeModel
. Models are expected to put a unique integer in the @stamp member, and put model-specific data in the three @user_data members.
A GtkTreeIterCompareFunc should return a negative integer, zero, or a positive integer if @a sorts before @b, @a sorts with @b, or @a sorts after @b respectively.
GtkTreeListModel
is a list model that can create child models on demand.
Prototype of the function called to create new child models when gtk_tree_list_row_set_expanded() is called.
GtkTreeListRow
is used by GtkTreeListModel
to represent items.
GtkTreeListRowSorter
is a special-purpose sorter that will apply a given sorter to the levels in a tree.
A GtkTreeModel
which hides parts of an underlying tree model
A function which calculates display values from raw values in the model. It must fill @value with the display value for the column @column in the row indicated by @iter.
A function which decides whether the row indicated by @iter is visible.
These flags indicate various properties of a GtkTreeModel
.
Type of the callback passed to gtk_tree_model_foreach() to iterate over the rows in a tree model.
A GtkTreeModel which makes an underlying tree model sortable
A GtkTreeRowReference tracks model changes so that it always refers to the same row (a GtkTreePath
refers to a position, not a fixed row). Create a new GtkTreeRowReference with gtk_tree_row_reference_new().
The selection object for GtkTreeView
A function used by gtk_tree_selection_selected_foreach() to map all selected rows. It will be called on every selected row in the view.
A function used by gtk_tree_selection_set_select_function() to filter whether or not a row may be selected. It is called whenever a row's state might change.
The interface for sortable models used by GtkTreeView
A tree-like data structure that can be used with the class@Gtk.TreeView.
A widget for displaying both trees and lists
A visible column in a class@Gtk.TreeView widget
Function type for determining whether @column can be dropped in a particular spot (as determined by @prev_column and @next_column). In left to right locales, @prev_column is on the left of the potential drop spot, and @next_column is on the right. In right to left mode, this is reversed. This function should return true if the spot is a valid drop spot. Please note that returning true does not actually indicate that the column drop was made, but is meant only to indicate a possible drop spot to the user.
The sizing method the column uses to determine its width. Please note that %GTK_TREE_VIEW_COLUMN_AUTOSIZE are inefficient for large views, and can make columns appear choppy.
An enum for determining where a dropped row goes.
Used to indicate which grid lines to draw in a tree view.
Function used for gtk_tree_view_map_expanded_rows().
Function type for determining whether the row pointed to by @iter should be rendered as a separator. A common way to implement this is to have a boolean column in the model, whose values the GtkTreeViewRowSeparatorFunc
returns.
A function used for checking whether a row in @model matches a search key string entered by the user. Note the return value is reversed from what you would normally expect, though it has some similarity to strcmp() returning 0 for equal strings.
A GtkUriLauncher
object collects the arguments that are needed to open a uri with an application.
GtkViewport
implements scrollability for widgets that lack their own scrolling capabilities.
GtkVolumeButton
is a GtkScaleButton
subclass tailored for volume control.
The base class for all widgets.
The type of the callback functions used for activating actions installed with gtk_widget_class_install_action().
GtkWidgetPaintable
is a GdkPaintable
that displays the contents of a widget.
GtkWindowControls
shows window frame controls.
GtkWindowGroup
makes group of windows behave like separate applications.
GtkWindowHandle
is a titlebar area widget.