Go to the source code of this file.
Macros | |
| #define | GTK_UNIT_PIXEL GTK_UNIT_NONE |
| #define | GTK_ACCESSIBLE_VALUE_UNDEFINED (-1) |
Functions | |
| static GtkOrdering | gtk_ordering_from_cmpfunc (int cmpfunc_result) |
Macro Definition Documentation
◆ GTK_ACCESSIBLE_VALUE_UNDEFINED
| #define GTK_ACCESSIBLE_VALUE_UNDEFINED (-1) |
GTK_ACCESSIBLE_VALUE_UNDEFINED:
An undefined value. The accessible attribute is either unset, or its value is undefined.
Definition at line 1582 of file gtkenums.h.
◆ GTK_UNIT_PIXEL
| #define GTK_UNIT_PIXEL GTK_UNIT_NONE |
Definition at line 766 of file gtkenums.h.
Enumeration Type Documentation
◆ GtkAccessibleAnnouncementPriority
GtkAccessibleAnnouncementPriority: @GTK_ACCESSIBLE_ANNOUNCEMENT_PRIORITY_LOW: The announcement is low priority, and might be read only on the user's request. @GTK_ACCESSIBLE_ANNOUNCEMENT_PRIORITY_MEDIUM: The announcement is of medium priority, and is usually spoken at the next opportunity, such as at the end of speaking the current sentence or when the user pauses typing. @GTK_ACCESSIBLE_ANNOUNCEMENT_PRIORITY_HIGH: The announcement is of high priority, and is usually spoken immediately. Because an interruption might disorient users or cause them to not complete their current task, authors SHOULD NOT use high priority announcements unless the interruption is imperative. An example would be a notification about a critical battery power level.
The priority of an accessibility announcement.
Since: 4.14
| Enumerator | |
|---|---|
| GTK_ACCESSIBLE_ANNOUNCEMENT_PRIORITY_LOW | |
| GTK_ACCESSIBLE_ANNOUNCEMENT_PRIORITY_MEDIUM | |
| GTK_ACCESSIBLE_ANNOUNCEMENT_PRIORITY_HIGH | |
Definition at line 1840 of file gtkenums.h.
◆ GtkAccessibleAutocomplete
GtkAccessibleAutocomplete: @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.
The possible values for the GTK_ACCESSIBLE_PROPERTY_AUTOCOMPLETE accessible property.
| Enumerator | |
|---|---|
| GTK_ACCESSIBLE_AUTOCOMPLETE_NONE | |
| GTK_ACCESSIBLE_AUTOCOMPLETE_INLINE | |
| GTK_ACCESSIBLE_AUTOCOMPLETE_LIST | |
| GTK_ACCESSIBLE_AUTOCOMPLETE_BOTH | |
Definition at line 1797 of file gtkenums.h.
◆ GtkAccessibleInvalidState
GtkAccessibleInvalidState: @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
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.
| Enumerator | |
|---|---|
| GTK_ACCESSIBLE_INVALID_FALSE | |
| GTK_ACCESSIBLE_INVALID_TRUE | |
| GTK_ACCESSIBLE_INVALID_GRAMMAR | |
| GTK_ACCESSIBLE_INVALID_SPELLING | |
Definition at line 1772 of file gtkenums.h.
◆ GtkAccessibleProperty
| enum :a GtkAccessibleProperty |
GtkAccessibleProperty: @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
The possible accessible properties of a [iface@Accessible]. GTK_ACCESSIBLE_PROPERTY_HELP_TEXT:
Defines a string value that provides a description of non-standard keyboard interactions of the current element. Value type: string
Since: 4.16
gtk_test_accessible_assert_property: @accessible: a GtkAccessible
...: the value of
Definition at line 1644 of file gtkenums.h.
◆ GtkAccessibleRelation
GtkAccessibleRelation: @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 (or elements) that provide 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
The possible accessible relations of a [iface@Accessible].
Accessible relations can be references to other widgets, integers or strings.
Definition at line 1718 of file gtkenums.h.
◆ GtkAccessibleRole
| enum GtkAccessibleRole |
GtkAccessibleRole: @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 [class.nosp@m.@Gtk.nosp@m..Head.nosp@m.erBa.nosp@m.r] or [class.nosp@m.@Gtk.nosp@m..Note.nosp@m.book]. @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.
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_TOGGLE_BUTTON:
A type of push button which stays pressed until depressed by a second activation.
Since: 4.10 GTK_ACCESSIBLE_ROLE_APPLICATION:
A toplevel element of a graphical user interface.
This is the role that GTK uses by default for windows.
Since: 4.12 GTK_ACCESSIBLE_ROLE_PARAGRAPH:
A paragraph of content.
Since: 4.14 GTK_ACCESSIBLE_ROLE_BLOCK_QUOTE:
A section of content that is quoted from another source.
Since: 4.14 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.
Since: 4.14 GTK_ACCESSIBLE_ROLE_COMMENT:
A comment contains content expressing reaction to other content.
Since: 4.14 GTK_ACCESSIBLE_ROLE_TERMINAL:
A virtual terminal.
Since: 4.14
Definition at line 1442 of file gtkenums.h.
◆ GtkAccessibleSort
| enum GtkAccessibleSort |
GtkAccessibleSort: @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.
The possible values for the GTK_ACCESSIBLE_PROPERTY_SORT accessible property.
| Enumerator | |
|---|---|
| GTK_ACCESSIBLE_SORT_NONE | |
| GTK_ACCESSIBLE_SORT_ASCENDING | |
| GTK_ACCESSIBLE_SORT_DESCENDING | |
| GTK_ACCESSIBLE_SORT_OTHER | |
Definition at line 1815 of file gtkenums.h.
◆ GtkAccessibleState
| enum GtkAccessibleState |
GtkAccessibleState: @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 [class@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 [class@ToggleButton]. Value type: [enum@AccessibleTristate] enumeration @GTK_ACCESSIBLE_STATE_SELECTED: A “selected” state; set when a widget is selected. Value type: boolean or undefined
The possible accessible states of a [iface@Accessible]. GTK_ACCESSIBLE_STATE_VISITED:
Indicates that a widget with the GTK_ACCESSIBLE_ROLE_LINK has been visited. Value type: boolean.
Since: 4.12
Definition at line 1564 of file gtkenums.h.
◆ GtkAccessibleTristate
GtkAccessibleTristate: @GTK_ACCESSIBLE_TRISTATE_FALSE: The state is false @GTK_ACCESSIBLE_TRISTATE_TRUE: The state is true @GTK_ACCESSIBLE_TRISTATE_MIXED: The state is mixed
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.
| Enumerator | |
|---|---|
| GTK_ACCESSIBLE_TRISTATE_FALSE | |
| GTK_ACCESSIBLE_TRISTATE_TRUE | |
| GTK_ACCESSIBLE_TRISTATE_MIXED | |
Definition at line 1752 of file gtkenums.h.
◆ GtkAlign
| enum GtkAlign |
GtkAlign: @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
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 [prope.nosp@m.rty@.nosp@m.Gtk.W.nosp@m.idge.nosp@m.t:hexpand] property inside a [class@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_BASELINE:
align the widget according to the baseline.
Deprecated: 4.12: Use GTK_ALIGN_BASELINE_FILL instead GTK_ALIGN_BASELINE_FILL:
a different name for GTK_ALIGN_BASELINE.
Since: 4.12 GTK_ALIGN_BASELINE_CENTER:
stretch to fill all space, but align the baseline.
Since: 4.12
| Enumerator | |
|---|---|
| GTK_ALIGN_FILL | |
| GTK_ALIGN_START | |
| GTK_ALIGN_END | |
| GTK_ALIGN_CENTER | |
| GDK_AVAILABLE_ENUMERATOR_IN_4_12 | |
| GDK_DEPRECATED_ENUMERATOR_IN_4_12_FOR | |
| GDK_AVAILABLE_ENUMERATOR_IN_4_12 | |
Definition at line 83 of file gtkenums.h.
◆ GtkArrowType
| enum GtkArrowType |
GtkArrowType: @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.
Used to indicate the direction in which an arrow should point.
| Enumerator | |
|---|---|
| GTK_ARROW_UP | |
| GTK_ARROW_DOWN | |
| GTK_ARROW_LEFT | |
| GTK_ARROW_RIGHT | |
| GTK_ARROW_NONE | |
Definition at line 104 of file gtkenums.h.
◆ GtkBaselinePosition
| enum GtkBaselinePosition |
GtkBaselinePosition: @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
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 GtkBaselinePosition to select where to put the baseline inside the extra available space.
| Enumerator | |
|---|---|
| GTK_BASELINE_POSITION_TOP | |
| GTK_BASELINE_POSITION_CENTER | |
| GTK_BASELINE_POSITION_BOTTOM | |
Definition at line 128 of file gtkenums.h.
◆ GtkBorderStyle
| enum GtkBorderStyle |
GtkBorderStyle: @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
Describes how the border of a UI element should be rendered.
Definition at line 892 of file gtkenums.h.
◆ GtkConstraintAttribute
GtkConstraintAttribute: @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
The widget attributes that can be used when creating a [class@Constraint].
Definition at line 1183 of file gtkenums.h.
◆ GtkConstraintRelation
GtkConstraintRelation: @GTK_CONSTRAINT_RELATION_EQ: Equal @GTK_CONSTRAINT_RELATION_LE: Less than, or equal @GTK_CONSTRAINT_RELATION_GE: Greater than, or equal
The relation between two terms of a constraint.
| Enumerator | |
|---|---|
| GTK_CONSTRAINT_RELATION_LE | |
| GTK_CONSTRAINT_RELATION_EQ | |
| GTK_CONSTRAINT_RELATION_GE | |
Definition at line 1132 of file gtkenums.h.
◆ GtkConstraintStrength
GtkConstraintStrength: @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
The strength of a constraint, expressed as a symbolic constant.
The strength of a [class@Constraint] can be expressed with any positive integer; the values of this enumeration can be used for readability.
| Enumerator | |
|---|---|
| GTK_CONSTRAINT_STRENGTH_REQUIRED | |
| GTK_CONSTRAINT_STRENGTH_STRONG | |
| GTK_CONSTRAINT_STRENGTH_MEDIUM | |
| GTK_CONSTRAINT_STRENGTH_WEAK | |
Definition at line 1150 of file gtkenums.h.
◆ GtkConstraintVflParserError
GtkConstraintVflParserError: @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
Domain for VFL parsing errors.
Definition at line 1209 of file gtkenums.h.
◆ GtkContentFit
| enum GtkContentFit |
GtkContentFit: @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.
Controls how a content should be made to fit inside an allocation.
Since: 4.8
| Enumerator | |
|---|---|
| GTK_CONTENT_FIT_FILL | |
| GTK_CONTENT_FIT_CONTAIN | |
| GTK_CONTENT_FIT_COVER | |
| GTK_CONTENT_FIT_SCALE_DOWN | |
Definition at line 156 of file gtkenums.h.
◆ GtkDeleteType
| enum GtkDeleteType |
GtkDeleteType: @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.
Passed to various keybinding signals for deleting text.
| Enumerator | |
|---|---|
| GTK_DELETE_CHARS | |
| GTK_DELETE_WORD_ENDS | |
| GTK_DELETE_WORDS | |
| GTK_DELETE_DISPLAY_LINES | |
| GTK_DELETE_DISPLAY_LINE_ENDS | |
| GTK_DELETE_PARAGRAPH_ENDS | |
| GTK_DELETE_PARAGRAPHS | |
| GTK_DELETE_WHITESPACE | |
Definition at line 183 of file gtkenums.h.
◆ GtkDirectionType
| enum GtkDirectionType |
GtkDirectionType: @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.
Focus movement types.
| Enumerator | |
|---|---|
| GTK_DIR_TAB_FORWARD | |
| GTK_DIR_TAB_BACKWARD | |
| GTK_DIR_UP | |
| GTK_DIR_DOWN | |
| GTK_DIR_LEFT | |
| GTK_DIR_RIGHT | |
Definition at line 207 of file gtkenums.h.
◆ GtkEventSequenceState
GtkEventSequenceState: @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.
Describes the state of a [struc.nosp@m.t@Gd.nosp@m.k.Eve.nosp@m.ntSe.nosp@m.quenc.nosp@m.e] in a [class@Gesture].
| Enumerator | |
|---|---|
| GTK_EVENT_SEQUENCE_NONE | |
| GTK_EVENT_SEQUENCE_CLAIMED | |
| GTK_EVENT_SEQUENCE_DENIED | |
Definition at line 1067 of file gtkenums.h.
◆ GtkFontRendering
| enum GtkFontRendering |
GtkFontRendering: @GTK_FONT_RENDERING_AUTOMATIC: Set up font rendering automatically, taking factors like screen resolution and scale into account @GTK_FONT_RENDERING_MANUAL: Follow low-level font-related settings when configuring font rendering
Values for the [prope.nosp@m.rty@.nosp@m.Gtk.S.nosp@m.etti.nosp@m.ngs:gtk-font-rendering] setting that influence how GTK renders fonts.
Since: 4.16
| Enumerator | |
|---|---|
| GTK_FONT_RENDERING_AUTOMATIC | |
| GTK_FONT_RENDERING_MANUAL | |
Definition at line 1878 of file gtkenums.h.
◆ GtkIconSize
| enum GtkIconSize |
GtkIconSize: @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
Built-in icon sizes.
Icon sizes default to being inherited. Where they cannot be inherited, text size is the default.
All widgets which use GtkIconSize 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.
| Enumerator | |
|---|---|
| GTK_ICON_SIZE_INHERIT | |
| GTK_ICON_SIZE_NORMAL | |
| GTK_ICON_SIZE_LARGE | |
Definition at line 233 of file gtkenums.h.
◆ GtkInputHints
| enum GtkInputHints |
GtkInputHints: @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)
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.
Definition at line 1001 of file gtkenums.h.
◆ GtkInputPurpose
| enum GtkInputPurpose |
GtkInputPurpose: @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
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”.
Definition at line 954 of file gtkenums.h.
◆ GtkJustification
| enum GtkJustification |
GtkJustification: @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.
Used for justifying the text inside a [class@Label] widget.
| Enumerator | |
|---|---|
| GTK_JUSTIFY_LEFT | |
| GTK_JUSTIFY_RIGHT | |
| GTK_JUSTIFY_CENTER | |
| GTK_JUSTIFY_FILL | |
Definition at line 282 of file gtkenums.h.
◆ GtkLevelBarMode
| enum GtkLevelBarMode |
GtkLevelBarMode: @GTK_LEVEL_BAR_MODE_CONTINUOUS: the bar has a continuous mode @GTK_LEVEL_BAR_MODE_DISCRETE: the bar has a discrete mode
Describes how [class@LevelBar] contents should be rendered.
Note that this enumeration could be extended with additional modes in the future.
| Enumerator | |
|---|---|
| GTK_LEVEL_BAR_MODE_CONTINUOUS | |
| GTK_LEVEL_BAR_MODE_DISCRETE | |
Definition at line 915 of file gtkenums.h.
◆ GtkListScrollFlags
| enum GtkListScrollFlags |
GtkListScrollFlags: @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.
List of actions to perform when scrolling to items in a list widget.
Since: 4.12
| Enumerator | |
|---|---|
| GTK_LIST_SCROLL_NONE | |
| GTK_LIST_SCROLL_FOCUS | |
| GTK_LIST_SCROLL_SELECT | |
Definition at line 327 of file gtkenums.h.
◆ GtkListTabBehavior
| enum GtkListTabBehavior |
GtkListTabBehavior: @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 GtkColumnView, otherwise it behaves like GTK_LIST_TAB_ITEM.
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.nosp@m.@Gtk.nosp@m..List.nosp@m.View].
Since: 4.12
| Enumerator | |
|---|---|
| GTK_LIST_TAB_ALL | |
| GTK_LIST_TAB_ITEM | |
| GTK_LIST_TAB_CELL | |
Definition at line 308 of file gtkenums.h.
◆ GtkMessageType
| enum GtkMessageType |
GtkMessageType: @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
The type of message being displayed in a [class@MessageDialog].
| Enumerator | |
|---|---|
| GTK_MESSAGE_INFO | |
| GTK_MESSAGE_WARNING | |
| GTK_MESSAGE_QUESTION | |
| GTK_MESSAGE_ERROR | |
| GTK_MESSAGE_OTHER | |
Definition at line 343 of file gtkenums.h.
◆ GtkMovementStep
| enum GtkMovementStep |
GtkMovementStep: @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
Passed as argument to various keybinding signals for moving the cursor position.
Definition at line 368 of file gtkenums.h.
◆ GtkNaturalWrapMode
| enum GtkNaturalWrapMode |
GtkNaturalWrapMode: @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.
Options for selecting a different wrap mode for natural size requests.
See for example the [prope.nosp@m.rty@.nosp@m.Gtk.L.nosp@m.abel:natural-wrap-mode] property.
Since: 4.6
| Enumerator | |
|---|---|
| GTK_NATURAL_WRAP_INHERIT | |
| GTK_NATURAL_WRAP_NONE | |
| GTK_NATURAL_WRAP_WORD | |
Definition at line 400 of file gtkenums.h.
◆ GtkNumberUpLayout
| enum GtkNumberUpLayout |
GtkNumberUpLayout: @GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_TOP_TO_BOTTOM: 
@GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_BOTTOM_TO_TOP: 
@GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_TOP_TO_BOTTOM: 
@GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_BOTTOM_TO_TOP: 
@GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_LEFT_TO_RIGHT: 
@GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_RIGHT_TO_LEFT: 
@GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_LEFT_TO_RIGHT: 
@GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_RIGHT_TO_LEFT: 
Used to determine the layout of pages on a sheet when printing multiple pages per sheet.
Definition at line 644 of file gtkenums.h.
◆ GtkOrdering
| enum GtkOrdering |
GtkOrdering: @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
Describes the way two values can be compared.
These values can be used with a [callb.nosp@m.ack@.nosp@m.GLib..nosp@m.Comp.nosp@m.areFu.nosp@m.nc]. However, a GCompareFunc is allowed to return any integer values. For converting such a value to a GtkOrdering value, use [func@.nosp@m.Gtk..nosp@m.Order.nosp@m.ing..nosp@m.from_.nosp@m.cmpf.nosp@m.unc].
| Enumerator | |
|---|---|
| GTK_ORDERING_SMALLER | |
| GTK_ORDERING_EQUAL | |
| GTK_ORDERING_LARGER | |
Definition at line 669 of file gtkenums.h.
◆ GtkOrientation
| enum GtkOrientation |
GtkOrientation: @GTK_ORIENTATION_HORIZONTAL: The element is in horizontal orientation. @GTK_ORIENTATION_VERTICAL: The element is in vertical orientation.
Represents the orientation of widgets and other objects.
Typical examples are [class@Box] or [class@GesturePan].
| Enumerator | |
|---|---|
| GTK_ORIENTATION_HORIZONTAL | |
| GTK_ORIENTATION_VERTICAL | |
Definition at line 437 of file gtkenums.h.
◆ GtkOverflow
| enum GtkOverflow |
GtkOverflow: @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.
Defines how content overflowing a given area should be handled.
This is used in [metho.nosp@m.d@Gt.nosp@m.k.Wid.nosp@m.get..nosp@m.set_o.nosp@m.verf.nosp@m.low]. The [prope.nosp@m.rty@.nosp@m.Gtk.W.nosp@m.idge.nosp@m.t:overflow] property is modeled after the CSS overflow property, but implements it only partially.
| Enumerator | |
|---|---|
| GTK_OVERFLOW_VISIBLE | |
| GTK_OVERFLOW_HIDDEN | |
Definition at line 456 of file gtkenums.h.
◆ GtkPackType
| enum GtkPackType |
GtkPackType: @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
Represents the packing location of a children in its parent.
See [class@WindowControls] for example.
| Enumerator | |
|---|---|
| GTK_PACK_START | |
| GTK_PACK_END | |
Definition at line 471 of file gtkenums.h.
◆ GtkPageOrientation
| enum GtkPageOrientation |
GtkPageOrientation: @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.
See also gtk_print_settings_set_orientation().
| Enumerator | |
|---|---|
| GTK_PAGE_ORIENTATION_PORTRAIT | |
| GTK_PAGE_ORIENTATION_LANDSCAPE | |
| GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT | |
| GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE | |
Definition at line 708 of file gtkenums.h.
◆ GtkPageSet
| enum GtkPageSet |
GtkPageSet: @GTK_PAGE_SET_ALL: All pages. @GTK_PAGE_SET_EVEN: Even pages. @GTK_PAGE_SET_ODD: Odd pages.
See also gtk_print_job_set_page_set().
| Enumerator | |
|---|---|
| GTK_PAGE_SET_ALL | |
| GTK_PAGE_SET_EVEN | |
| GTK_PAGE_SET_ODD | |
Definition at line 623 of file gtkenums.h.
◆ GtkPanDirection
| enum GtkPanDirection |
GtkPanDirection: @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
Describes the panning direction of a [class@GesturePan].
| Enumerator | |
|---|---|
| GTK_PAN_DIRECTION_LEFT | |
| GTK_PAN_DIRECTION_RIGHT | |
| GTK_PAN_DIRECTION_UP | |
| GTK_PAN_DIRECTION_DOWN | |
Definition at line 1083 of file gtkenums.h.
◆ GtkPickFlags
| enum GtkPickFlags |
GtkPickFlags: @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]
Flags that influence the behavior of [metho.nosp@m.d@Wi.nosp@m.dget..nosp@m.pick].
| Enumerator | |
|---|---|
| GTK_PICK_DEFAULT | |
| GTK_PICK_INSENSITIVE | |
| GTK_PICK_NON_TARGETABLE | |
Definition at line 1118 of file gtkenums.h.
◆ GtkPopoverMenuFlags
| enum GtkPopoverMenuFlags |
GtkPopoverMenuFlags: @GTK_POPOVER_MENU_NESTED: Submenus are presented as traditional, nested popovers.
Flags that affect how [class.nosp@m.@Gtk.nosp@m..Popo.nosp@m.verM.nosp@m.enu] widgets built from a [class.nosp@m.@Gio.nosp@m..Menu.nosp@m.Mode.nosp@m.l] are created and displayed. GTK_POPOVER_MENU_SLIDING:
Submenus are presented as sliding submenus that replace the main menu.
Since: 4.14
| Enumerator | |
|---|---|
| GTK_POPOVER_MENU_SLIDING | |
| GTK_POPOVER_MENU_NESTED | |
Definition at line 1861 of file gtkenums.h.
◆ GtkPositionType
| enum GtkPositionType |
GtkPositionType: @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.
Describes which edge of a widget a certain feature is positioned at.
For examples, see the tabs of a [class@Notebook], or the label of a [class@Scale].
| Enumerator | |
|---|---|
| GTK_POS_LEFT | |
| GTK_POS_RIGHT | |
| GTK_POS_TOP | |
| GTK_POS_BOTTOM | |
Definition at line 489 of file gtkenums.h.
◆ GtkPrintDuplex
| enum GtkPrintDuplex |
GtkPrintDuplex: @GTK_PRINT_DUPLEX_SIMPLEX: No duplex. @GTK_PRINT_DUPLEX_HORIZONTAL: Horizontal duplex. @GTK_PRINT_DUPLEX_VERTICAL: Vertical duplex.
See also gtk_print_settings_set_duplex().
| Enumerator | |
|---|---|
| GTK_PRINT_DUPLEX_SIMPLEX | |
| GTK_PRINT_DUPLEX_HORIZONTAL | |
| GTK_PRINT_DUPLEX_VERTICAL | |
Definition at line 741 of file gtkenums.h.
◆ GtkPrintPages
| enum GtkPrintPages |
GtkPrintPages: @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.
See also gtk_print_job_set_pages()
| Enumerator | |
|---|---|
| GTK_PRINT_PAGES_ALL | |
| GTK_PRINT_PAGES_CURRENT | |
| GTK_PRINT_PAGES_RANGES | |
| GTK_PRINT_PAGES_SELECTION | |
Definition at line 607 of file gtkenums.h.
◆ GtkPrintQuality
| enum GtkPrintQuality |
GtkPrintQuality: @GTK_PRINT_QUALITY_LOW: Low quality. @GTK_PRINT_QUALITY_NORMAL: Normal quality. @GTK_PRINT_QUALITY_HIGH: High quality. @GTK_PRINT_QUALITY_DRAFT: Draft quality.
See also gtk_print_settings_set_quality().
| Enumerator | |
|---|---|
| GTK_PRINT_QUALITY_LOW | |
| GTK_PRINT_QUALITY_NORMAL | |
| GTK_PRINT_QUALITY_HIGH | |
| GTK_PRINT_QUALITY_DRAFT | |
Definition at line 725 of file gtkenums.h.
◆ GtkPropagationLimit
| enum GtkPropagationLimit |
GtkPropagationLimit: @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).
Describes limits of a [class@EventController] for handling events targeting other widgets.
| Enumerator | |
|---|---|
| GTK_LIMIT_NONE | |
| GTK_LIMIT_SAME_NATIVE | |
Definition at line 1053 of file gtkenums.h.
◆ GtkPropagationPhase
| enum GtkPropagationPhase |
GtkPropagationPhase: @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.
Describes the stage at which events are fed into a [class@EventController].
| Enumerator | |
|---|---|
| GTK_PHASE_NONE | |
| GTK_PHASE_CAPTURE | |
| GTK_PHASE_BUBBLE | |
| GTK_PHASE_TARGET | |
Definition at line 1034 of file gtkenums.h.
◆ GtkScrollablePolicy
| enum GtkScrollablePolicy |
GtkScrollablePolicy: @GTK_SCROLL_MINIMUM: Scrollable adjustments are based on the minimum size @GTK_SCROLL_NATURAL: Scrollable adjustments are based on the natural size
Defines the policy to be used in a scrollable widget when updating the scrolled window adjustments in a given orientation.
| Enumerator | |
|---|---|
| GTK_SCROLL_MINIMUM | |
| GTK_SCROLL_NATURAL | |
Definition at line 826 of file gtkenums.h.
◆ GtkScrollStep
| enum GtkScrollStep |
GtkScrollStep: @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.
Passed as argument to various keybinding signals.
| Enumerator | |
|---|---|
| GTK_SCROLL_STEPS | |
| GTK_SCROLL_PAGES | |
| GTK_SCROLL_ENDS | |
| GTK_SCROLL_HORIZONTAL_STEPS | |
| GTK_SCROLL_HORIZONTAL_PAGES | |
| GTK_SCROLL_HORIZONTAL_ENDS | |
Definition at line 418 of file gtkenums.h.
◆ GtkScrollType
| enum GtkScrollType |
GtkScrollType: @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.
Scrolling types.
Definition at line 518 of file gtkenums.h.
◆ GtkSelectionMode
| enum GtkSelectionMode |
GtkSelectionMode: @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.
Used to control what selections users are allowed to make.
| Enumerator | |
|---|---|
| GTK_SELECTION_NONE | |
| GTK_SELECTION_SINGLE | |
| GTK_SELECTION_BROWSE | |
| GTK_SELECTION_MULTIPLE | |
Definition at line 555 of file gtkenums.h.
◆ GtkSensitivityType
| enum GtkSensitivityType |
GtkSensitivityType: @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
Determines how GTK handles the sensitivity of various controls, such as combo box buttons.
| Enumerator | |
|---|---|
| GTK_SENSITIVITY_AUTO | |
| GTK_SENSITIVITY_ON | |
| GTK_SENSITIVITY_OFF | |
Definition at line 250 of file gtkenums.h.
◆ GtkShortcutScope
| enum GtkShortcutScope |
GtkShortcutScope: @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.
Describes where [class@Shortcut]s added to a [class@ShortcutController] get handled.
| Enumerator | |
|---|---|
| GTK_SHORTCUT_SCOPE_LOCAL | |
| GTK_SHORTCUT_SCOPE_MANAGED | |
| GTK_SHORTCUT_SCOPE_GLOBAL | |
Definition at line 1103 of file gtkenums.h.
◆ GtkSizeGroupMode
| enum GtkSizeGroupMode |
GtkSizeGroupMode: @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
The mode of the size group determines the directions in which the size group affects the requested sizes of its component widgets.
| Enumerator | |
|---|---|
| GTK_SIZE_GROUP_NONE | |
| GTK_SIZE_GROUP_HORIZONTAL | |
| GTK_SIZE_GROUP_VERTICAL | |
| GTK_SIZE_GROUP_BOTH | |
Definition at line 795 of file gtkenums.h.
◆ GtkSizeRequestMode
| enum GtkSizeRequestMode |
GtkSizeRequestMode: @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
Specifies a preference for height-for-width or width-for-height geometry management.
| Enumerator | |
|---|---|
| GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH | |
| GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT | |
| GTK_SIZE_REQUEST_CONSTANT_SIZE | |
Definition at line 811 of file gtkenums.h.
◆ GtkSortType
| enum GtkSortType |
GtkSortType: @GTK_SORT_ASCENDING: Sorting is in ascending order. @GTK_SORT_DESCENDING: Sorting is in descending order.
Determines the direction of a sort.
| Enumerator | |
|---|---|
| GTK_SORT_ASCENDING | |
| GTK_SORT_DESCENDING | |
Definition at line 592 of file gtkenums.h.
◆ GtkStateFlags
| enum GtkStateFlags |
GtkStateFlags: @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
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.
Definition at line 857 of file gtkenums.h.
◆ GtkSymbolicColor
| enum GtkSymbolicColor |
GtkSymbolicColor: @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
The indexes of colors passed to symbolic color rendering, such as [vfunc.nosp@m.@Gtk.nosp@m..Symb.nosp@m.olic.nosp@m.Paint.nosp@m.able.nosp@m..snap.nosp@m.shot.nosp@m._symb.nosp@m.olic].
More values may be added over time.
Since: 4.6
| Enumerator | |
|---|---|
| GTK_SYMBOLIC_COLOR_FOREGROUND | |
| GTK_SYMBOLIC_COLOR_ERROR | |
| GTK_SYMBOLIC_COLOR_WARNING | |
| GTK_SYMBOLIC_COLOR_SUCCESS | |
Definition at line 1265 of file gtkenums.h.
◆ GtkSystemSetting
| enum GtkSystemSetting |
GtkSystemSetting: @GTK_SYSTEM_SETTING_DPI: the [prope.nosp@m.rty@.nosp@m.Gtk.S.nosp@m.etti.nosp@m.ngs:gtk-xft-dpi] setting has changed @GTK_SYSTEM_SETTING_FONT_NAME: The [prope.nosp@m.rty@.nosp@m.Gtk.S.nosp@m.etti.nosp@m.ngs:gtk-font-name] 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 [prope.nosp@m.rty@.nosp@m.Gtk.S.nosp@m.etti.nosp@m.ngs:gtk-xft-antialias], [prope.nosp@m.rty@.nosp@m.Gtk.S.nosp@m.etti.nosp@m.ngs:gtk-xft-hinting], [prope.nosp@m.rty@.nosp@m.Gtk.S.nosp@m.etti.nosp@m.ngs:gtk-xft-hintstyle], [prope.nosp@m.rty@.nosp@m.Gtk.S.nosp@m.etti.nosp@m.ngs:gtk-xft-rgba] or [prope.nosp@m.rty@.nosp@m.Gtk.S.nosp@m.etti.nosp@m.ngs:gtk-fontconfig-timestamp] 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
Values that can be passed to the [vfunc.nosp@m.@Gtk.nosp@m..Widg.nosp@m.et.s.nosp@m.ystem.nosp@m._set.nosp@m.ting_.nosp@m.chan.nosp@m.ged] vfunc.
The values indicate which system setting has changed. Widgets may need to drop caches, or react otherwise.
Most of the values correspond to [class@Settings] properties.
More values may be added over time.
| Enumerator | |
|---|---|
| GTK_SYSTEM_SETTING_DPI | |
| GTK_SYSTEM_SETTING_FONT_NAME | |
| GTK_SYSTEM_SETTING_FONT_CONFIG | |
| GTK_SYSTEM_SETTING_DISPLAY | |
| GTK_SYSTEM_SETTING_ICON_THEME | |
Definition at line 1243 of file gtkenums.h.
◆ GtkTextBufferNotifyFlags
GtkTextBufferNotifyFlags: @GTK_TEXT_BUFFER_NOTIFY_BEFORE_INSERT: Be notified before text is inserted into the underlying buffer. @GTK_TEXT_BUFFER_NOTIFY_AFTER_INSERT: Be notified after text has been inserted into the underlying buffer. @GTK_TEXT_BUFFER_NOTIFY_BEFORE_DELETE: Be notified before text is deleted from the underlying buffer. @GTK_TEXT_BUFFER_NOTIFY_AFTER_DELETE: Be notified after text has been deleted from the underlying buffer.
Values for [callb.nosp@m.ack@.nosp@m.Gtk.T.nosp@m.extB.nosp@m.uffer.nosp@m.Comm.nosp@m.itNot.nosp@m.ify] to denote the point of the notification.
Since: 4.16
| Enumerator | |
|---|---|
| GTK_TEXT_BUFFER_NOTIFY_BEFORE_INSERT | |
| GTK_TEXT_BUFFER_NOTIFY_AFTER_INSERT | |
| GTK_TEXT_BUFFER_NOTIFY_BEFORE_DELETE | |
| GTK_TEXT_BUFFER_NOTIFY_AFTER_DELETE | |
Definition at line 1899 of file gtkenums.h.
◆ GtkTextDirection
| enum GtkTextDirection |
GtkTextDirection: @GTK_TEXT_DIR_NONE: No direction. @GTK_TEXT_DIR_LTR: Left to right text direction. @GTK_TEXT_DIR_RTL: Right to left text direction.
Reading directions for text.
| Enumerator | |
|---|---|
| GTK_TEXT_DIR_NONE | |
| GTK_TEXT_DIR_LTR | |
| GTK_TEXT_DIR_RTL | |
Definition at line 266 of file gtkenums.h.
◆ GtkTreeViewGridLines
| enum GtkTreeViewGridLines |
GtkTreeViewGridLines: @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.
Used to indicate which grid lines to draw in a tree view.
| Enumerator | |
|---|---|
| GTK_TREE_VIEW_GRID_LINES_NONE | |
| GTK_TREE_VIEW_GRID_LINES_HORIZONTAL | |
| GTK_TREE_VIEW_GRID_LINES_VERTICAL | |
| GTK_TREE_VIEW_GRID_LINES_BOTH | |
Definition at line 777 of file gtkenums.h.
◆ GtkUnit
| enum GtkUnit |
GtkUnit: @GTK_UNIT_NONE: No units. @GTK_UNIT_POINTS: Dimensions in points. @GTK_UNIT_INCH: Dimensions in inches. @GTK_UNIT_MM: Dimensions in millimeters
See also gtk_print_settings_set_paper_width().
| Enumerator | |
|---|---|
| GTK_UNIT_NONE | |
| GTK_UNIT_POINTS | |
| GTK_UNIT_INCH | |
| GTK_UNIT_MM | |
Definition at line 758 of file gtkenums.h.
◆ GtkWrapMode
| enum GtkWrapMode |
GtkWrapMode: @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
Describes a type of line wrapping.
| Enumerator | |
|---|---|
| GTK_WRAP_NONE | |
| GTK_WRAP_CHAR | |
| GTK_WRAP_WORD | |
| GTK_WRAP_WORD_CHAR | |
Definition at line 577 of file gtkenums.h.
Function Documentation
◆ gtk_ordering_from_cmpfunc()
|
inlinestatic |
gtk_ordering_from_cmpfunc: (skip) @cmpfunc_result: Result of a comparison function
Converts the result of a GCompareFunc like strcmp() to a GtkOrdering value.
Returns: the corresponding GtkOrdering
Definition at line 693 of file gtkenums.h.
