About all my projects
Gnome::Gtk4::T-enums

Gnome::Gtk4::T-enums

Class initialization

new

Initialization of a type class is simple and only needed when the standalone functions are used.

method new ( )

Constants

GTK_ACCESSIBLE_VALUE_UNDEFINED

An undefined value. The accessible attribute is either unset, or its value is undefined.

Enumerations

GtkAccessibleAnnouncementPriority

The priority of an accessibility announcement.

  • GTK_ACCESSIBLE_ANNOUNCEMENT_PRIORITY_LOW;

  • GTK_ACCESSIBLE_ANNOUNCEMENT_PRIORITY_MEDIUM;

  • GTK_ACCESSIBLE_ANNOUNCEMENT_PRIORITY_HIGH;

GtkAccessibleAutocomplete

The possible values for the GTK_ACCESSIBLE_PROPERTY_AUTOCOMPLETE accessible property.

  • GTK_ACCESSIBLE_AUTOCOMPLETE_NONE; Automatic suggestions are not displayed.

  • GTK_ACCESSIBLE_AUTOCOMPLETE_INLINE; When a user is providing input, text suggesting one way to complete the provided input may be dynamically inserted after the caret.

  • GTK_ACCESSIBLE_AUTOCOMPLETE_LIST; When a user is providing input, an element containing a collection of values that could complete the provided input may be displayed.

  • GTK_ACCESSIBLE_AUTOCOMPLETE_BOTH; When a user is providing input, an element containing a collection of values that could complete the provided input may be displayed. If displayed, one value in the collection is automatically selected, and the text needed to complete the automatically selected value appears after the caret in the input.

GtkAccessibleInvalidState

The possible values for the GTK_ACCESSIBLE_STATE_INVALID accessible state.

Note that the GTK_ACCESSIBLE_INVALID_FALSE and GTK_ACCESSIBLE_INVALID_TRUE have the same values as False and True.

  • GTK_ACCESSIBLE_INVALID_FALSE; There are no detected errors in the value

  • GTK_ACCESSIBLE_INVALID_TRUE; The value entered by the user has failed validation

  • GTK_ACCESSIBLE_INVALID_GRAMMAR; A grammatical error was detected

  • GTK_ACCESSIBLE_INVALID_SPELLING; A spelling error was detected

GtkAccessibleProperty

The possible accessible properties of a [iface $Accessible].

  • GTK_ACCESSIBLE_PROPERTY_AUTOCOMPLETE; Indicates whether inputting text could trigger display of one or more predictions of the user's intended value for a combobox, searchbox, or textbox and specifies how predictions would be presented if they were made. Value type: [enum $AccessibleAutocomplete]

  • GTK_ACCESSIBLE_PROPERTY_DESCRIPTION; Defines a string value that describes or annotates the current element. Value type: string

  • GTK_ACCESSIBLE_PROPERTY_HAS_POPUP; Indicates the availability and type of interactive popup element, such as menu or dialog, that can be triggered by an element.

  • GTK_ACCESSIBLE_PROPERTY_KEY_SHORTCUTS; Indicates keyboard shortcuts that an author has implemented to activate or give focus to an element. Value type: string

  • GTK_ACCESSIBLE_PROPERTY_LABEL; Defines a string value that labels the current element. Value type: string

  • GTK_ACCESSIBLE_PROPERTY_LEVEL; Defines the hierarchical level of an element within a structure. Value type: integer

  • GTK_ACCESSIBLE_PROPERTY_MODAL; Indicates whether an element is modal when displayed. Value type: boolean

  • GTK_ACCESSIBLE_PROPERTY_MULTI_LINE; Indicates whether a text box accepts multiple lines of input or only a single line. Value type: boolean

  • GTK_ACCESSIBLE_PROPERTY_MULTI_SELECTABLE; Indicates that the user may select more than one item from the current selectable descendants. Value type: boolean

  • GTK_ACCESSIBLE_PROPERTY_ORIENTATION; Indicates whether the element's orientation is horizontal, vertical, or unknown/ambiguous. Value type: [enum $Orientation]

  • GTK_ACCESSIBLE_PROPERTY_PLACEHOLDER; Defines a short hint (a word or short phrase) intended to aid the user with data entry when the control has no value. A hint could be a sample value or a brief description of the expected format. Value type: string

  • GTK_ACCESSIBLE_PROPERTY_READ_ONLY; Indicates that the element is not editable, but is otherwise operable. Value type: boolean

  • GTK_ACCESSIBLE_PROPERTY_REQUIRED; Indicates that user input is required on the element before a form may be submitted. Value type: boolean

  • GTK_ACCESSIBLE_PROPERTY_ROLE_DESCRIPTION; Defines a human-readable, author-localized description for the role of an element. Value type: string

  • GTK_ACCESSIBLE_PROPERTY_SORT; Indicates if items in a table or grid are sorted in ascending or descending order. Value type: [enum $AccessibleSort]

  • GTK_ACCESSIBLE_PROPERTY_VALUE_MAX; Defines the maximum allowed value for a range widget. Value type: double

  • GTK_ACCESSIBLE_PROPERTY_VALUE_MIN; Defines the minimum allowed value for a range widget. Value type: double

  • GTK_ACCESSIBLE_PROPERTY_VALUE_NOW; Defines the current value for a range widget. Value type: double

  • GTK_ACCESSIBLE_PROPERTY_VALUE_TEXT; Defines the human readable text alternative of aria-valuenow for a range widget. Value type: string

GtkAccessibleRelation

The possible accessible relations of a [iface $Accessible].

Accessible relations can be references to other widgets, integers or strings.

  • GTK_ACCESSIBLE_RELATION_ACTIVE_DESCENDANT; Identifies the currently active element when focus is on a composite widget, combobox, textbox, group, or application. Value type: reference

  • GTK_ACCESSIBLE_RELATION_COL_COUNT; Defines the total number of columns in a table, grid, or treegrid. Value type: integer

  • GTK_ACCESSIBLE_RELATION_COL_INDEX; Defines an element's column index or position with respect to the total number of columns within a table, grid, or treegrid. Value type: integer

  • GTK_ACCESSIBLE_RELATION_COL_INDEX_TEXT; Defines a human readable text alternative of GTK_ACCESSIBLE_RELATION_COL_INDEX. Value type: string

  • GTK_ACCESSIBLE_RELATION_COL_SPAN; Defines the number of columns spanned by a cell or gridcell within a table, grid, or treegrid. Value type: integer

  • GTK_ACCESSIBLE_RELATION_CONTROLS; Identifies the element (or elements) whose contents or presence are controlled by the current element. Value type: reference

  • GTK_ACCESSIBLE_RELATION_DESCRIBED_BY; Identifies the element (or elements) that describes the object. Value type: reference

  • GTK_ACCESSIBLE_RELATION_DETAILS; Identifies the element (or elements) that provide additional information related to the object. Value type: reference

  • GTK_ACCESSIBLE_RELATION_ERROR_MESSAGE; Identifies the element that provides an error message for an object. Value type: reference

  • GTK_ACCESSIBLE_RELATION_FLOW_TO; Identifies the next element (or elements) in an alternate reading order of content which, at the user's discretion, allows assistive technology to override the general default of reading in document source order. Value type: reference

  • GTK_ACCESSIBLE_RELATION_LABELLED_BY; Identifies the element (or elements) that labels the current element. Value type: reference

  • GTK_ACCESSIBLE_RELATION_OWNS; Identifies an element (or elements) in order to define a visual, functional, or contextual parent/child relationship between elements where the widget hierarchy cannot be used to represent the relationship. Value type: reference

  • GTK_ACCESSIBLE_RELATION_POS_IN_SET; Defines an element's number or position in the current set of listitems or treeitems. Value type: integer

  • GTK_ACCESSIBLE_RELATION_ROW_COUNT; Defines the total number of rows in a table, grid, or treegrid. Value type: integer

  • GTK_ACCESSIBLE_RELATION_ROW_INDEX; Defines an element's row index or position with respect to the total number of rows within a table, grid, or treegrid. Value type: integer

  • GTK_ACCESSIBLE_RELATION_ROW_INDEX_TEXT; Defines a human readable text alternative of aria-rowindex. Value type: string

  • GTK_ACCESSIBLE_RELATION_ROW_SPAN; Defines the number of rows spanned by a cell or gridcell within a table, grid, or treegrid. Value type: integer

  • GTK_ACCESSIBLE_RELATION_SET_SIZE; Defines the number of items in the current set of listitems or treeitems. Value type: integer

GtkAccessibleRole

The accessible role for a [iface $Accessible] implementation.

Abstract roles are only used as part of the ontology; application developers must not use abstract roles in their code.

  • GTK_ACCESSIBLE_ROLE_ALERT; An element with important, and usually time-sensitive, information

  • GTK_ACCESSIBLE_ROLE_ALERT_DIALOG; A type of dialog that contains an alert message

  • GTK_ACCESSIBLE_ROLE_BANNER; Unused

  • GTK_ACCESSIBLE_ROLE_BUTTON; An input element that allows for user-triggered actions when clicked or pressed

  • GTK_ACCESSIBLE_ROLE_CAPTION; Unused

  • GTK_ACCESSIBLE_ROLE_CELL; Unused

  • GTK_ACCESSIBLE_ROLE_CHECKBOX; A checkable input element that has three possible values: true, false, or mixed

  • GTK_ACCESSIBLE_ROLE_COLUMN_HEADER; A header in a columned list.

  • GTK_ACCESSIBLE_ROLE_COMBO_BOX; An input that controls another element, such as a list or a grid, that can dynamically pop up to help the user set the value of the input

  • GTK_ACCESSIBLE_ROLE_COMMAND; Abstract role.

  • GTK_ACCESSIBLE_ROLE_COMPOSITE; Abstract role.

  • GTK_ACCESSIBLE_ROLE_DIALOG; A dialog is a window that is designed to interrupt the current processing of an application in order to prompt the user to enter information or require a response.

  • GTK_ACCESSIBLE_ROLE_DOCUMENT; Content that assistive technology users may want to browse in a reading mode.

  • GTK_ACCESSIBLE_ROLE_FEED; Unused

  • GTK_ACCESSIBLE_ROLE_FORM; Unused

  • GTK_ACCESSIBLE_ROLE_GENERIC; A nameless container that has no semantic meaning of its own. This is the role that GTK uses by default for widgets.

  • GTK_ACCESSIBLE_ROLE_GRID; A grid of items.

  • GTK_ACCESSIBLE_ROLE_GRID_CELL; An item in a grid or tree grid.

  • GTK_ACCESSIBLE_ROLE_GROUP; An element that groups multiple related widgets. GTK uses this role for various containers, like Gnome::Gtk4::HeaderBar or Gnome::Gtk4::Notebook.

  • GTK_ACCESSIBLE_ROLE_HEADING; Unused

  • GTK_ACCESSIBLE_ROLE_IMG; An image.

  • GTK_ACCESSIBLE_ROLE_INPUT; Abstract role.

  • GTK_ACCESSIBLE_ROLE_LABEL; A visible name or caption for a user interface component.

  • GTK_ACCESSIBLE_ROLE_LANDMARK; Abstract role.

  • GTK_ACCESSIBLE_ROLE_LEGEND; Unused

  • GTK_ACCESSIBLE_ROLE_LINK; A clickable link.

  • GTK_ACCESSIBLE_ROLE_LIST; A list of items.

  • GTK_ACCESSIBLE_ROLE_LIST_BOX; Unused.

  • GTK_ACCESSIBLE_ROLE_LIST_ITEM; An item in a list.

  • GTK_ACCESSIBLE_ROLE_LOG; Unused

  • GTK_ACCESSIBLE_ROLE_MAIN; Unused

  • GTK_ACCESSIBLE_ROLE_MARQUEE; Unused

  • GTK_ACCESSIBLE_ROLE_MATH; Unused

  • GTK_ACCESSIBLE_ROLE_METER; An element that represents a value within a known range.

  • GTK_ACCESSIBLE_ROLE_MENU; A menu.

  • GTK_ACCESSIBLE_ROLE_MENU_BAR; A menubar.

  • GTK_ACCESSIBLE_ROLE_MENU_ITEM; An item in a menu.

  • GTK_ACCESSIBLE_ROLE_MENU_ITEM_CHECKBOX; A check item in a menu.

  • GTK_ACCESSIBLE_ROLE_MENU_ITEM_RADIO; A radio item in a menu.

  • GTK_ACCESSIBLE_ROLE_NAVIGATION; Unused

  • GTK_ACCESSIBLE_ROLE_NONE; An element that is not represented to accessibility technologies. This role is synonymous to $GTK-ACCESSIBLE-ROLE-PRESENTATION.

  • GTK_ACCESSIBLE_ROLE_NOTE; Unused

  • GTK_ACCESSIBLE_ROLE_OPTION; Unused

  • GTK_ACCESSIBLE_ROLE_PRESENTATION; An element that is not represented to accessibility technologies. This role is synonymous to $GTK-ACCESSIBLE-ROLE-NONE.

  • GTK_ACCESSIBLE_ROLE_PROGRESS_BAR; An element that displays the progress status for tasks that take a long time.

  • GTK_ACCESSIBLE_ROLE_RADIO; A checkable input in a group of radio roles, only one of which can be checked at a time.

  • GTK_ACCESSIBLE_ROLE_RADIO_GROUP; Unused

  • GTK_ACCESSIBLE_ROLE_RANGE; Abstract role.

  • GTK_ACCESSIBLE_ROLE_REGION; Unused

  • GTK_ACCESSIBLE_ROLE_ROW; A row in a columned list.

  • GTK_ACCESSIBLE_ROLE_ROW_GROUP; Unused

  • GTK_ACCESSIBLE_ROLE_ROW_HEADER; Unused

  • GTK_ACCESSIBLE_ROLE_SCROLLBAR; A graphical object that controls the scrolling of content within a viewing area, regardless of whether the content is fully displayed within the viewing area.

  • GTK_ACCESSIBLE_ROLE_SEARCH; Unused

  • GTK_ACCESSIBLE_ROLE_SEARCH_BOX; A type of textbox intended for specifying search criteria.

  • GTK_ACCESSIBLE_ROLE_SECTION; Abstract role.

  • GTK_ACCESSIBLE_ROLE_SECTION_HEAD; Abstract role.

  • GTK_ACCESSIBLE_ROLE_SELECT; Abstract role.

  • GTK_ACCESSIBLE_ROLE_SEPARATOR; A divider that separates and distinguishes sections of content or groups of menuitems.

  • GTK_ACCESSIBLE_ROLE_SLIDER; A user input where the user selects a value from within a given range.

  • GTK_ACCESSIBLE_ROLE_SPIN_BUTTON; A form of range that expects the user to select from among discrete choices.

  • GTK_ACCESSIBLE_ROLE_STATUS; Unused

  • GTK_ACCESSIBLE_ROLE_STRUCTURE; Abstract role.

  • GTK_ACCESSIBLE_ROLE_SWITCH; A type of checkbox that represents on/off values, as opposed to checked/unchecked values.

  • GTK_ACCESSIBLE_ROLE_TAB; An item in a list of tab used for switching pages.

  • GTK_ACCESSIBLE_ROLE_TABLE; Unused

  • GTK_ACCESSIBLE_ROLE_TAB_LIST; A list of tabs for switching pages.

  • GTK_ACCESSIBLE_ROLE_TAB_PANEL; A page in a notebook or stack.

  • GTK_ACCESSIBLE_ROLE_TEXT_BOX; A type of input that allows free-form text as its value.

  • GTK_ACCESSIBLE_ROLE_TIME; Unused

  • GTK_ACCESSIBLE_ROLE_TIMER; Unused

  • GTK_ACCESSIBLE_ROLE_TOOLBAR; Unused

  • GTK_ACCESSIBLE_ROLE_TOOLTIP; Unused

  • GTK_ACCESSIBLE_ROLE_TREE; Unused

  • GTK_ACCESSIBLE_ROLE_TREE_GRID; A treeview-like, columned list.

  • GTK_ACCESSIBLE_ROLE_TREE_ITEM; Unused

  • GTK_ACCESSIBLE_ROLE_WIDGET; Abstract role for interactive components of a graphical user interface

  • GTK_ACCESSIBLE_ROLE_WINDOW; Abstract role for windows.

  • GTK_ACCESSIBLE_ROLE_TOGGLE_BUTTON; A type of push button which stays pressed until depressed by a second activation.

  • GTK_ACCESSIBLE_ROLE_APPLICATION; A toplevel element of a graphical user interface.

This is the role that GTK uses by default for windows.

  • GTK_ACCESSIBLE_ROLE_PARAGRAPH; A paragraph of content.

  • GTK_ACCESSIBLE_ROLE_BLOCK_QUOTE; A section of content that is quoted from another source.

  • GTK_ACCESSIBLE_ROLE_ARTICLE; A section of a page that consists of a composition that forms an independent part of a document, page, or site.

  • GTK_ACCESSIBLE_ROLE_COMMENT; A comment contains content expressing reaction to other content.

  • GTK_ACCESSIBLE_ROLE_TERMINAL; A virtual terminal.

GtkAccessibleSort

The possible values for the GTK_ACCESSIBLE_PROPERTY_SORT accessible property.

  • GTK_ACCESSIBLE_SORT_NONE; There is no defined sort applied to the column.

  • GTK_ACCESSIBLE_SORT_ASCENDING; Items are sorted in ascending order by this column.

  • GTK_ACCESSIBLE_SORT_DESCENDING; Items are sorted in descending order by this column.

  • GTK_ACCESSIBLE_SORT_OTHER; A sort algorithm other than ascending or descending has been applied.

GtkAccessibleState

The possible accessible states of a [iface $Accessible].

  • GTK_ACCESSIBLE_STATE_BUSY; A “busy” state. This state has boolean values

  • GTK_ACCESSIBLE_STATE_CHECKED; A “checked” state; indicates the current state of a Gnome::Gtk4::CheckButton. Value type: [enum $AccessibleTristate]

  • GTK_ACCESSIBLE_STATE_DISABLED; A “disabled” state; corresponds to the [property $Widget:sensitive] property. It indicates a UI element that is perceivable, but not editable or operable. Value type: boolean

  • GTK_ACCESSIBLE_STATE_EXPANDED; An “expanded” state; corresponds to the [property $Expander:expanded] property. Value type: boolean or undefined

  • GTK_ACCESSIBLE_STATE_HIDDEN; A “hidden” state; corresponds to the [property $Widget:visible] property. You can use this state explicitly on UI elements that should not be exposed to an assistive technology. Value type: boolean See also: GTK_ACCESSIBLE_STATE_DISABLED

  • GTK_ACCESSIBLE_STATE_INVALID; An “invalid” state; set when a widget is showing an error. Value type: [enum $AccessibleInvalidState]

  • GTK_ACCESSIBLE_STATE_PRESSED; A “pressed” state; indicates the current state of a Gnome::Gtk4::ToggleButton. Value type: [enum $AccessibleTristate] enumeration

  • GTK_ACCESSIBLE_STATE_SELECTED; A “selected” state; set when a widget is selected. Value type: boolean or undefined

  • GTK_ACCESSIBLE_STATE_VISITED; Indicates that a widget with the GTK_ACCESSIBLE_ROLE_LINK has been visited. Value type: boolean.

GtkAccessibleTristate

The possible values for the GTK_ACCESSIBLE_STATE_PRESSED accessible state.

Note that the GTK_ACCESSIBLE_TRISTATE_FALSE and GTK_ACCESSIBLE_TRISTATE_TRUE have the same values as False and True.

  • GTK_ACCESSIBLE_TRISTATE_FALSE; The state is false

  • GTK_ACCESSIBLE_TRISTATE_TRUE; The state is true

  • GTK_ACCESSIBLE_TRISTATE_MIXED; The state is mixed

GtkAlign

Controls how a widget deals with extra space in a single dimension.

Alignment only matters if the widget receives a “too large” allocation, for example if you packed the widget with the hexpand defined in Gnome::Gtk4::Widget property inside a Gnome::Gtk4::Box, then the widget might get extra space. If you have for example a 16x16 icon inside a 32x32 space, the icon could be scaled and stretched, it could be centered, or it could be positioned to one side of the space.

Note that in horizontal context GTK_ALIGN_START and GTK_ALIGN_END are interpreted relative to text direction.

Baseline support is optional for containers and widgets, and is only available for vertical alignment. GTK_ALIGN_BASELINE_CENTER and GTK_ALIGN_BASELINE_FILL are treated similar to GTK_ALIGN_CENTER and GTK_ALIGN_FILL, except that it positions the widget to line up the baselines, where that is supported.

  • GTK_ALIGN_FILL; stretch to fill all space if possible, center if no meaningful way to stretch

  • GTK_ALIGN_START; snap to left or top side, leaving space on right or bottom

  • GTK_ALIGN_END; snap to right or bottom side, leaving space on left or top

  • GTK_ALIGN_CENTER; center natural width of widget inside the allocation

  • GTK_ALIGN_BASELINE_FILL; a different name for GTK_ALIGN_BASELINE.

  • GTK_ALIGN_BASELINE; align the widget according to the baseline.

  • GTK_ALIGN_BASELINE_CENTER; stretch to fill all space, but align the baseline.

GtkArrowType

Used to indicate the direction in which an arrow should point.

  • GTK_ARROW_UP; Represents an upward pointing arrow.

  • GTK_ARROW_DOWN; Represents a downward pointing arrow.

  • GTK_ARROW_LEFT; Represents a left pointing arrow.

  • GTK_ARROW_RIGHT; Represents a right pointing arrow.

  • GTK_ARROW_NONE; No arrow.

GtkBaselinePosition

Baseline position in a row of widgets.

Whenever a container has some form of natural row it may align children in that row along a common typographical baseline. If the amount of vertical space in the row is taller than the total requested height of the baseline-aligned children then it can use a enumeration GtkBaselinePosition defined in Gnome::Gtk4::T-enums to select where to put the baseline inside the extra available space.

  • GTK_BASELINE_POSITION_TOP; Align the baseline at the top

  • GTK_BASELINE_POSITION_CENTER; Center the baseline

  • GTK_BASELINE_POSITION_BOTTOM; Align the baseline at the bottom

GtkBorderStyle

Describes how the border of a UI element should be rendered.

  • GTK_BORDER_STYLE_NONE; No visible border

  • GTK_BORDER_STYLE_HIDDEN; Same as GTK_BORDER_STYLE_NONE

  • GTK_BORDER_STYLE_SOLID; A single line segment

  • GTK_BORDER_STYLE_INSET; Looks as if the content is sunken into the canvas

  • GTK_BORDER_STYLE_OUTSET; Looks as if the content is coming out of the canvas

  • GTK_BORDER_STYLE_DOTTED; A series of round dots

  • GTK_BORDER_STYLE_DASHED; A series of square-ended dashes

  • GTK_BORDER_STYLE_DOUBLE; Two parallel lines with some space between them

  • GTK_BORDER_STYLE_GROOVE; Looks as if it were carved in the canvas

  • GTK_BORDER_STYLE_RIDGE; Looks as if it were coming out of the canvas

GtkConstraintAttribute

The widget attributes that can be used when creating a Gnome::Gtk4::Constraint.

  • GTK_CONSTRAINT_ATTRIBUTE_NONE; No attribute, used for constant relations

  • GTK_CONSTRAINT_ATTRIBUTE_LEFT; The left edge of a widget, regardless of text direction

  • GTK_CONSTRAINT_ATTRIBUTE_RIGHT; The right edge of a widget, regardless of text direction

  • GTK_CONSTRAINT_ATTRIBUTE_TOP; The top edge of a widget

  • GTK_CONSTRAINT_ATTRIBUTE_BOTTOM; The bottom edge of a widget

  • GTK_CONSTRAINT_ATTRIBUTE_START; The leading edge of a widget, depending on text direction; equivalent to GTK_CONSTRAINT_ATTRIBUTE_LEFT for LTR languages, and GTK_CONSTRAINT_ATTRIBUTE_RIGHT for RTL ones

  • GTK_CONSTRAINT_ATTRIBUTE_END; The trailing edge of a widget, depending on text direction; equivalent to GTK_CONSTRAINT_ATTRIBUTE_RIGHT for LTR languages, and GTK_CONSTRAINT_ATTRIBUTE_LEFT for RTL ones

  • GTK_CONSTRAINT_ATTRIBUTE_WIDTH; The width of a widget

  • GTK_CONSTRAINT_ATTRIBUTE_HEIGHT; The height of a widget

  • GTK_CONSTRAINT_ATTRIBUTE_CENTER_X; The center of a widget, on the horizontal axis

  • GTK_CONSTRAINT_ATTRIBUTE_CENTER_Y; The center of a widget, on the vertical axis

  • GTK_CONSTRAINT_ATTRIBUTE_BASELINE; The baseline of a widget

GtkConstraintRelation

The relation between two terms of a constraint.

  • GTK_CONSTRAINT_RELATION_LE; Less than, or equal

  • GTK_CONSTRAINT_RELATION_EQ; Equal

  • GTK_CONSTRAINT_RELATION_GE; Greater than, or equal

GtkConstraintStrength

The strength of a constraint, expressed as a symbolic constant.

The strength of a Gnome::Gtk4::Constraint can be expressed with any positive integer; the values of this enumeration can be used for readability.

  • GTK_CONSTRAINT_STRENGTH_REQUIRED; The constraint is required towards solving the layout

  • GTK_CONSTRAINT_STRENGTH_STRONG; A strong constraint

  • GTK_CONSTRAINT_STRENGTH_MEDIUM; A medium constraint

  • GTK_CONSTRAINT_STRENGTH_WEAK; A weak constraint

GtkConstraintVflParserError

Domain for VFL parsing errors.

  • GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_SYMBOL; Invalid or unknown symbol

  • GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_ATTRIBUTE; Invalid or unknown attribute

  • GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_VIEW; Invalid or unknown view

  • GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_METRIC; Invalid or unknown metric

  • GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_PRIORITY; Invalid or unknown priority

  • GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_RELATION; Invalid or unknown relation

GtkContentFit

Controls how a content should be made to fit inside an allocation.

  • GTK_CONTENT_FIT_FILL; Make the content fill the entire allocation, without taking its aspect ratio in consideration. The resulting content will appear as stretched if its aspect ratio is different from the allocation aspect ratio.

  • GTK_CONTENT_FIT_CONTAIN; Scale the content to fit the allocation, while taking its aspect ratio in consideration. The resulting content will appear as letterboxed if its aspect ratio is different from the allocation aspect ratio.

  • GTK_CONTENT_FIT_COVER; Cover the entire allocation, while taking the content aspect ratio in consideration. The resulting content will appear as clipped if its aspect ratio is different from the allocation aspect ratio.

  • GTK_CONTENT_FIT_SCALE_DOWN; The content is scaled down to fit the allocation, if needed, otherwise its original size is used.

GtkDeleteType

Passed to various keybinding signals for deleting text.

  • GTK_DELETE_CHARS; Delete characters.

  • GTK_DELETE_WORD_ENDS; Delete only the portion of the word to the left/right of cursor if we’re in the middle of a word.

  • GTK_DELETE_WORDS; Delete words.

  • GTK_DELETE_DISPLAY_LINES; Delete display-lines. Display-lines refers to the visible lines, with respect to the current line breaks. As opposed to paragraphs, which are defined by line breaks in the input.

  • GTK_DELETE_DISPLAY_LINE_ENDS; Delete only the portion of the display-line to the left/right of cursor.

  • GTK_DELETE_PARAGRAPH_ENDS; Delete to the end of the paragraph. Like C-k in Emacs (or its reverse).

  • GTK_DELETE_PARAGRAPHS; Delete entire line. Like C-k in pico.

  • GTK_DELETE_WHITESPACE; Delete only whitespace. Like M-\ in Emacs.

GtkDirectionType

Focus movement types.

  • GTK_DIR_TAB_FORWARD; Move forward.

  • GTK_DIR_TAB_BACKWARD; Move backward.

  • GTK_DIR_UP; Move up.

  • GTK_DIR_DOWN; Move down.

  • GTK_DIR_LEFT; Move left.

  • GTK_DIR_RIGHT; Move right.

GtkEventSequenceState

Describes the state of a Gnome::Gdk4::N-EventSequence in a Gnome::Gtk4::Gesture.

  • GTK_EVENT_SEQUENCE_NONE; The sequence is handled, but not grabbed.

  • GTK_EVENT_SEQUENCE_CLAIMED; The sequence is handled and grabbed.

  • GTK_EVENT_SEQUENCE_DENIED; The sequence is denied.

GtkIconSize

Built-in icon sizes.

Icon sizes default to being inherited. Where they cannot be inherited, text size is the default.

All widgets which use enumeration GtkIconSize defined in Gnome::Gtk4::T-enums set the normal-icons or large-icons style classes correspondingly, and let themes determine the actual size to be used with the `-gtk-icon-size` CSS property.

  • GTK_ICON_SIZE_INHERIT; Keep the size of the parent element

  • GTK_ICON_SIZE_NORMAL; Size similar to text size

  • GTK_ICON_SIZE_LARGE; Large size, for example in an icon view

GtkInputPurpose

Describes primary purpose of the input widget.

This information is useful for on-screen keyboards and similar input methods to decide which keys should be presented to the user.

Note that the purpose is not meant to impose a totally strict rule about allowed characters, and does not replace input validation. It is fine for an on-screen keyboard to let the user override the character set restriction that is expressed by the purpose. The application is expected to validate the entry contents, even if it specified a purpose.

The difference between GTK_INPUT_PURPOSE_DIGITS and GTK_INPUT_PURPOSE_NUMBER is that the former accepts only digits while the latter also some punctuation (like commas or points, plus, minus) and “e” or “E” as in 3.14E+000.

This enumeration may be extended in the future; input methods should interpret unknown values as “free form”.

  • GTK_INPUT_PURPOSE_FREE_FORM; Allow any character

  • GTK_INPUT_PURPOSE_ALPHA; Allow only alphabetic characters

  • GTK_INPUT_PURPOSE_DIGITS; Allow only digits

  • GTK_INPUT_PURPOSE_NUMBER; Edited field expects numbers

  • GTK_INPUT_PURPOSE_PHONE; Edited field expects phone number

  • GTK_INPUT_PURPOSE_URL; Edited field expects URL

  • GTK_INPUT_PURPOSE_EMAIL; Edited field expects email address

  • GTK_INPUT_PURPOSE_NAME; Edited field expects the name of a person

  • GTK_INPUT_PURPOSE_PASSWORD; Like GTK_INPUT_PURPOSE_FREE_FORM, but characters are hidden

  • GTK_INPUT_PURPOSE_PIN; Like GTK_INPUT_PURPOSE_DIGITS, but characters are hidden

  • GTK_INPUT_PURPOSE_TERMINAL; Allow any character, in addition to control codes

GtkJustification

Used for justifying the text inside a Gnome::Gtk4::Label widget.

  • GTK_JUSTIFY_LEFT; The text is placed at the left edge of the label.

  • GTK_JUSTIFY_RIGHT; The text is placed at the right edge of the label.

  • GTK_JUSTIFY_CENTER; The text is placed in the center of the label.

  • GTK_JUSTIFY_FILL; The text is placed is distributed across the label.

GtkLevelBarMode

Describes how Gnome::Gtk4::LevelBar contents should be rendered.

Note that this enumeration could be extended with additional modes in the future.

  • GTK_LEVEL_BAR_MODE_CONTINUOUS; the bar has a continuous mode

  • GTK_LEVEL_BAR_MODE_DISCRETE; the bar has a discrete mode

GtkListTabBehavior

Used to configure the focus behavior in the GTK_DIR_TAB_FORWARD and GTK_DIR_TAB_BACKWARD direction, like the <kbd>Tab</kbd> key in a Gnome::Gtk4::ListView.

  • GTK_LIST_TAB_ALL; Cycle through all focusable items of the list

  • GTK_LIST_TAB_ITEM; Cycle through a single list element, then move focus out of the list. Moving focus between items needs to be done with the arrow keys.

  • GTK_LIST_TAB_CELL; Cycle only through a single cell, then move focus out of the list. Moving focus between cells needs to be done with the arrow keys. This is only relevant for cell-based widgets like Gnome::Gtk4::ColumnView, otherwise it behaves like GTK_LIST_TAB_ITEM.

GtkMessageType

The type of message being displayed in a Gnome::Gtk4::MessageDialog.

  • GTK_MESSAGE_INFO; Informational message

  • GTK_MESSAGE_WARNING; Non-fatal warning message

  • GTK_MESSAGE_QUESTION; Question requiring a choice

  • GTK_MESSAGE_ERROR; Fatal error message

  • GTK_MESSAGE_OTHER; None of the above

GtkMovementStep

Passed as argument to various keybinding signals for moving the cursor position.

  • GTK_MOVEMENT_LOGICAL_POSITIONS; Move forward or back by graphemes

  • GTK_MOVEMENT_VISUAL_POSITIONS; Move left or right by graphemes

  • GTK_MOVEMENT_WORDS; Move forward or back by words

  • GTK_MOVEMENT_DISPLAY_LINES; Move up or down lines (wrapped lines)

  • GTK_MOVEMENT_DISPLAY_LINE_ENDS; Move to either end of a line

  • GTK_MOVEMENT_PARAGRAPHS; Move up or down paragraphs (newline-ended lines)

  • GTK_MOVEMENT_PARAGRAPH_ENDS; Move to either end of a paragraph

  • GTK_MOVEMENT_PAGES; Move by pages

  • GTK_MOVEMENT_BUFFER_ENDS; Move to ends of the buffer

  • GTK_MOVEMENT_HORIZONTAL_PAGES; Move horizontally by pages

GtkNaturalWrapMode

Options for selecting a different wrap mode for natural size requests.

See for example the natural-wrap-mode defined in Gnome::Gtk4::Label property.

  • GTK_NATURAL_WRAP_INHERIT; Inherit the minimum size request. In particular, this should be used with PANGO_WRAP_CHAR.

  • GTK_NATURAL_WRAP_NONE; Try not to wrap the text. This mode is the closest to GTK3's behavior but can lead to a wide label leaving lots of empty space below the text.

  • GTK_NATURAL_WRAP_WORD; Attempt to wrap at word boundaries. This is useful in particular when using PANGO_WRAP_WORD_CHAR as the wrap mode.

GtkNumberUpLayout

Used to determine the layout of pages on a sheet when printing multiple pages per sheet.

  • GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_TOP_TO_BOTTOM; =for image :src<asset_files/images/layout-lrtb.png> :width<30%> :class<inline>

  • GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_BOTTOM_TO_TOP; =for image :src<asset_files/images/layout-lrbt.png> :width<30%> :class<inline>

  • GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_TOP_TO_BOTTOM; =for image :src<asset_files/images/layout-rltb.png> :width<30%> :class<inline>

  • GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_BOTTOM_TO_TOP; =for image :src<asset_files/images/layout-rlbt.png> :width<30%> :class<inline>

  • GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_LEFT_TO_RIGHT; =for image :src<asset_files/images/layout-tblr.png> :width<30%> :class<inline>

  • GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_RIGHT_TO_LEFT; =for image :src<asset_files/images/layout-tbrl.png> :width<30%> :class<inline>

  • GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_LEFT_TO_RIGHT; =for image :src<asset_files/images/layout-btlr.png> :width<30%> :class<inline>

  • GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_RIGHT_TO_LEFT; =for image :src<asset_files/images/layout-btrl.png> :width<30%> :class<inline>

GtkOrdering

Describes the way two values can be compared.

These values can be used with a [callback $GLib.CompareFunc]. However, a Gnome::Glib::T-types is allowed to return any integer values. For converting such a value to a enumeration GtkOrdering defined in Gnome::Gtk4::T-enums value, use .Ordering.from-cmpfunc().

  • GTK_ORDERING_SMALLER; the first value is smaller than the second

  • GTK_ORDERING_EQUAL; the two values are equal

  • GTK_ORDERING_LARGER; the first value is larger than the second

GtkOrientation

Represents the orientation of widgets and other objects.

Typical examples are Gnome::Gtk4::Box or Gnome::Gtk4::GesturePan.

  • GTK_ORIENTATION_HORIZONTAL; The element is in horizontal orientation.

  • GTK_ORIENTATION_VERTICAL; The element is in vertical orientation.

GtkOverflow

Defines how content overflowing a given area should be handled.

This is used in .set-overflow() in class Gnome::Gtk4::Widget. The overflow defined in Gnome::Gtk4::Widget property is modeled after the CSS overflow property, but implements it only partially.

  • GTK_OVERFLOW_VISIBLE; No change is applied. Content is drawn at the specified position.

  • GTK_OVERFLOW_HIDDEN; Content is clipped to the bounds of the area. Content outside the area is not drawn and cannot be interacted with.

GtkPackType

Represents the packing location of a children in its parent.

See Gnome::Gtk4::WindowControls for example.

  • GTK_PACK_START; The child is packed into the start of the widget

  • GTK_PACK_END; The child is packed into the end of the widget

GtkPageOrientation

See also gtk_print_settings_set_orientation().

  • GTK_PAGE_ORIENTATION_PORTRAIT; Portrait mode.

  • GTK_PAGE_ORIENTATION_LANDSCAPE; Landscape mode.

  • GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT; Reverse portrait mode.

  • GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE; Reverse landscape mode.

GtkPageSet

See also gtk_print_job_set_page_set().

  • GTK_PAGE_SET_ALL; All pages.

  • GTK_PAGE_SET_EVEN; Even pages.

  • GTK_PAGE_SET_ODD; Odd pages.

GtkPanDirection

Describes the panning direction of a Gnome::Gtk4::GesturePan.

  • GTK_PAN_DIRECTION_LEFT; panned towards the left

  • GTK_PAN_DIRECTION_RIGHT; panned towards the right

  • GTK_PAN_DIRECTION_UP; panned upwards

  • GTK_PAN_DIRECTION_DOWN; panned downwards

GtkPositionType

Describes which edge of a widget a certain feature is positioned at.

For examples, see the tabs of a Gnome::Gtk4::Notebook, or the label of a Gnome::Gtk4::Scale.

  • GTK_POS_LEFT; The feature is at the left edge.

  • GTK_POS_RIGHT; The feature is at the right edge.

  • GTK_POS_TOP; The feature is at the top edge.

  • GTK_POS_BOTTOM; The feature is at the bottom edge.

GtkPrintDuplex

See also gtk_print_settings_set_duplex().

  • GTK_PRINT_DUPLEX_SIMPLEX; No duplex.

  • GTK_PRINT_DUPLEX_HORIZONTAL; Horizontal duplex.

  • GTK_PRINT_DUPLEX_VERTICAL; Vertical duplex.

GtkPrintPages

See also gtk_print_job_set_pages()

  • GTK_PRINT_PAGES_ALL; All pages.

  • GTK_PRINT_PAGES_CURRENT; Current page.

  • GTK_PRINT_PAGES_RANGES; Range of pages.

  • GTK_PRINT_PAGES_SELECTION; Selected pages.

GtkPrintQuality

See also gtk_print_settings_set_quality().

  • GTK_PRINT_QUALITY_LOW; Low quality.

  • GTK_PRINT_QUALITY_NORMAL; Normal quality.

  • GTK_PRINT_QUALITY_HIGH; High quality.

  • GTK_PRINT_QUALITY_DRAFT; Draft quality.

GtkPropagationLimit

Describes limits of a Gnome::Gtk4::EventController for handling events targeting other widgets.

  • GTK_LIMIT_NONE; Events are handled regardless of what their target is.

  • GTK_LIMIT_SAME_NATIVE; Events are only handled if their target is in the same [iface $Native] as the event controllers widget. Note that some event types have two targets (origin and destination).

GtkPropagationPhase

Describes the stage at which events are fed into a Gnome::Gtk4::EventController.

  • GTK_PHASE_NONE; Events are not delivered.

  • GTK_PHASE_CAPTURE; Events are delivered in the capture phase. The capture phase happens before the bubble phase, runs from the toplevel down to the event widget. This option should only be used on containers that might possibly handle events before their children do.

  • GTK_PHASE_BUBBLE; Events are delivered in the bubble phase. The bubble phase happens after the capture phase, and before the default handlers are run. This phase runs from the event widget, up to the toplevel.

  • GTK_PHASE_TARGET; Events are delivered in the default widget event handlers, note that widget implementations must chain up on button, motion, touch and grab broken handlers for controllers in this phase to be run.

GtkScrollStep

Passed as argument to various keybinding signals.

  • GTK_SCROLL_STEPS; Scroll in steps.

  • GTK_SCROLL_PAGES; Scroll by pages.

  • GTK_SCROLL_ENDS; Scroll to ends.

  • GTK_SCROLL_HORIZONTAL_STEPS; Scroll in horizontal steps.

  • GTK_SCROLL_HORIZONTAL_PAGES; Scroll by horizontal pages.

  • GTK_SCROLL_HORIZONTAL_ENDS; Scroll to the horizontal ends.

GtkScrollType

Scrolling types.

  • GTK_SCROLL_NONE; No scrolling.

  • GTK_SCROLL_JUMP; Jump to new location.

  • GTK_SCROLL_STEP_BACKWARD; Step backward.

  • GTK_SCROLL_STEP_FORWARD; Step forward.

  • GTK_SCROLL_PAGE_BACKWARD; Page backward.

  • GTK_SCROLL_PAGE_FORWARD; Page forward.

  • GTK_SCROLL_STEP_UP; Step up.

  • GTK_SCROLL_STEP_DOWN; Step down.

  • GTK_SCROLL_PAGE_UP; Page up.

  • GTK_SCROLL_PAGE_DOWN; Page down.

  • GTK_SCROLL_STEP_LEFT; Step to the left.

  • GTK_SCROLL_STEP_RIGHT; Step to the right.

  • GTK_SCROLL_PAGE_LEFT; Page to the left.

  • GTK_SCROLL_PAGE_RIGHT; Page to the right.

  • GTK_SCROLL_START; Scroll to start.

  • GTK_SCROLL_END; Scroll to end.

GtkScrollablePolicy

Defines the policy to be used in a scrollable widget when updating the scrolled window adjustments in a given orientation.

  • GTK_SCROLL_MINIMUM; Scrollable adjustments are based on the minimum size

  • GTK_SCROLL_NATURAL; Scrollable adjustments are based on the natural size

GtkSelectionMode

Used to control what selections users are allowed to make.

  • GTK_SELECTION_NONE; No selection is possible.

  • GTK_SELECTION_SINGLE; Zero or one element may be selected.

  • GTK_SELECTION_BROWSE; Exactly one element is selected. In some circumstances, such as initially or during a search operation, it’s possible for no element to be selected with GTK_SELECTION_BROWSE. What is really enforced is that the user can’t deselect a currently selected element except by selecting another element.

  • GTK_SELECTION_MULTIPLE; Any number of elements may be selected. The Ctrl key may be used to enlarge the selection, and Shift key to select between the focus and the child pointed to. Some widgets may also allow Click-drag to select a range of elements.

GtkSensitivityType

Determines how GTK handles the sensitivity of various controls, such as combo box buttons.

  • GTK_SENSITIVITY_AUTO; The control is made insensitive if no action can be triggered

  • GTK_SENSITIVITY_ON; The control is always sensitive

  • GTK_SENSITIVITY_OFF; The control is always insensitive

GtkShortcutScope

Describes where Gnome::Gtk4::Shortcuts added to a Gnome::Gtk4::ShortcutController get handled.

  • GTK_SHORTCUT_SCOPE_LOCAL; Shortcuts are handled inside the widget the controller belongs to.

  • GTK_SHORTCUT_SCOPE_MANAGED; Shortcuts are handled by the first ancestor that is a [iface $ShortcutManager]

  • GTK_SHORTCUT_SCOPE_GLOBAL; Shortcuts are handled by the root widget.

GtkSizeGroupMode

The mode of the size group determines the directions in which the size group affects the requested sizes of its component widgets.

  • GTK_SIZE_GROUP_NONE; group has no effect

  • GTK_SIZE_GROUP_HORIZONTAL; group affects horizontal requisition

  • GTK_SIZE_GROUP_VERTICAL; group affects vertical requisition

  • GTK_SIZE_GROUP_BOTH; group affects both horizontal and vertical requisition

GtkSizeRequestMode

Specifies a preference for height-for-width or width-for-height geometry management.

  • GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH; Prefer height-for-width geometry management

  • GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT; Prefer width-for-height geometry management

  • GTK_SIZE_REQUEST_CONSTANT_SIZE; Don’t trade height-for-width or width-for-height

GtkSortType

Determines the direction of a sort.

  • GTK_SORT_ASCENDING; Sorting is in ascending order.

  • GTK_SORT_DESCENDING; Sorting is in descending order.

GtkSymbolicColor

The indexes of colors passed to symbolic color rendering, such as [vfunc $Gtk.SymbolicPaintable.snapshot_symbolic].

More values may be added over time.

  • GTK_SYMBOLIC_COLOR_FOREGROUND; The default foreground color

  • GTK_SYMBOLIC_COLOR_ERROR; Indication color for errors

  • GTK_SYMBOLIC_COLOR_WARNING; Indication color for warnings

  • GTK_SYMBOLIC_COLOR_SUCCESS; Indication color for success

GtkSystemSetting

Values that can be passed to the [vfunc $Gtk.Widget.system_setting_changed] vfunc.

The values indicate which system setting has changed. Widgets may need to drop caches, or react otherwise.

Most of the values correspond to Gnome::Gtk4::Settings properties.

More values may be added over time.

  • GTK_SYSTEM_SETTING_DPI; the gtk-xft-dpi defined in Gnome::Gtk4::Settings setting has changed

  • GTK_SYSTEM_SETTING_FONT_NAME; The gtk-font-name defined in Gnome::Gtk4::Settings setting has changed

  • GTK_SYSTEM_SETTING_FONT_CONFIG; The font configuration has changed in a way that requires text to be redrawn. This can be any of the gtk-xft-antialias defined in Gnome::Gtk4::Settings, gtk-xft-hinting defined in Gnome::Gtk4::Settings, gtk-xft-hintstyle defined in Gnome::Gtk4::Settings, gtk-xft-rgba defined in Gnome::Gtk4::Settings or gtk-fontconfig-timestamp defined in Gnome::Gtk4::Settings settings

  • GTK_SYSTEM_SETTING_DISPLAY; The display has changed

  • GTK_SYSTEM_SETTING_ICON_THEME; The icon theme has changed in a way that requires icons to be looked up again

GtkTextDirection

Reading directions for text.

  • GTK_TEXT_DIR_NONE; No direction.

  • GTK_TEXT_DIR_LTR; Left to right text direction.

  • GTK_TEXT_DIR_RTL; Right to left text direction.

GtkTreeViewGridLines

Used to indicate which grid lines to draw in a tree view.

  • GTK_TREE_VIEW_GRID_LINES_NONE; No grid lines.

  • GTK_TREE_VIEW_GRID_LINES_HORIZONTAL; Horizontal grid lines.

  • GTK_TREE_VIEW_GRID_LINES_VERTICAL; Vertical grid lines.

  • GTK_TREE_VIEW_GRID_LINES_BOTH; Horizontal and vertical grid lines.

GtkUnit

See also gtk_print_settings_set_paper_width().

  • GTK_UNIT_NONE; No units.

  • GTK_UNIT_POINTS; Dimensions in points.

  • GTK_UNIT_INCH; Dimensions in inches.

  • GTK_UNIT_MM; Dimensions in millimeters

GtkWrapMode

Describes a type of line wrapping.

  • GTK_WRAP_NONE; do not wrap lines; just make the text area wider

  • GTK_WRAP_CHAR; wrap text, breaking lines anywhere the cursor can appear (between characters, usually - if you want to be technical, between graphemes, see pango_get_log_attrs())

  • GTK_WRAP_WORD; wrap text, breaking lines in between words

  • GTK_WRAP_WORD_CHAR; wrap text, breaking lines in between words, or if that is not enough, also between graphemes

Bitfields

GtkInputHints

Describes hints that might be taken into account by input methods or applications.

Note that input methods may already tailor their behaviour according to the [enum $InputPurpose] of the entry.

Some common sense is expected when using these flags - mixing GTK_INPUT_HINT_LOWERCASE with any of the uppercase hints makes no sense.

This enumeration may be extended in the future; input methods should ignore unknown values.

  • GTK_INPUT_HINT_NONE; No special behaviour suggested

  • GTK_INPUT_HINT_SPELLCHECK; Suggest checking for typos

  • GTK_INPUT_HINT_NO_SPELLCHECK; Suggest not checking for typos

  • GTK_INPUT_HINT_WORD_COMPLETION; Suggest word completion

  • GTK_INPUT_HINT_LOWERCASE; Suggest to convert all text to lowercase

  • GTK_INPUT_HINT_UPPERCASE_CHARS; Suggest to capitalize all text

  • GTK_INPUT_HINT_UPPERCASE_WORDS; Suggest to capitalize the first character of each word

  • GTK_INPUT_HINT_UPPERCASE_SENTENCES; Suggest to capitalize the first word of each sentence

  • GTK_INPUT_HINT_INHIBIT_OSK; Suggest to not show an onscreen keyboard (e.g for a calculator that already has all the keys).

  • GTK_INPUT_HINT_VERTICAL_WRITING; The text is vertical

  • GTK_INPUT_HINT_EMOJI; Suggest offering Emoji support

  • GTK_INPUT_HINT_NO_EMOJI; Suggest not offering Emoji support

  • GTK_INPUT_HINT_PRIVATE; Request that the input method should not update personalized data (like typing history)

GtkListScrollFlags

List of actions to perform when scrolling to items in a list widget.

  • GTK_LIST_SCROLL_NONE; Don't do anything extra

  • GTK_LIST_SCROLL_FOCUS; Focus the target item

  • GTK_LIST_SCROLL_SELECT; Select the target item and unselect all other items.

GtkPickFlags

Flags that influence the behavior of [method $Widget.pick].

  • GTK_PICK_DEFAULT; The default behavior, include widgets that are receiving events

  • GTK_PICK_INSENSITIVE; Include widgets that are insensitive

  • GTK_PICK_NON_TARGETABLE; Include widgets that are marked as non-targetable. See [property $Widget:can-target]

GtkPopoverMenuFlags

Flags that affect how Gnome::Gtk4::PopoverMenu widgets built from a Gnome::Gtk4::enums are created and displayed.

  • GTK_POPOVER_MENU_SLIDING; Submenus are presented as sliding submenus that replace the main menu.

  • GTK_POPOVER_MENU_NESTED; Submenus are presented as traditional, nested popovers.

GtkStateFlags

Describes a widget state.

Widget states are used to match the widget against CSS pseudo-classes. Note that GTK extends the regular CSS classes and sometimes uses different names.

  • GTK_STATE_FLAG_NORMAL; State during normal operation

  • GTK_STATE_FLAG_ACTIVE; Widget is active

  • GTK_STATE_FLAG_PRELIGHT; Widget has a mouse pointer over it

  • GTK_STATE_FLAG_SELECTED; Widget is selected

  • GTK_STATE_FLAG_INSENSITIVE; Widget is insensitive

  • GTK_STATE_FLAG_INCONSISTENT; Widget is inconsistent

  • GTK_STATE_FLAG_FOCUSED; Widget has the keyboard focus

  • GTK_STATE_FLAG_BACKDROP; Widget is in a background toplevel window

  • GTK_STATE_FLAG_DIR_LTR; Widget is in left-to-right text direction

  • GTK_STATE_FLAG_DIR_RTL; Widget is in right-to-left text direction

  • GTK_STATE_FLAG_LINK; Widget is a link

  • GTK_STATE_FLAG_VISITED; The location the widget points to has already been visited

  • GTK_STATE_FLAG_CHECKED; Widget is checked

  • GTK_STATE_FLAG_DROP_ACTIVE; Widget is highlighted as a drop target for DND

  • GTK_STATE_FLAG_FOCUS_VISIBLE; Widget has the visible focus

  • GTK_STATE_FLAG_FOCUS_WITHIN; Widget contains the keyboard focus

Standalone Functions

ordering-from-cmpfunc

Converts the result of a Gnome::Glib::T-types like strcmp() to a enumeration GtkOrdering defined in Gnome::Gtk4::T-enums value.

method ordering-from-cmpfunc ( Int() $cmpfunc-result --> GtkOrdering )

  • $cmpfunc-result; Result of a comparison function.

Return value; the corresponding enumeration GtkOrdering defined in Gnome::Gtk4::T-enums.