gtkmm: gtkmm Enums and Flags
Classes | |
class | Gtk::Constraint::Strength_Wrapper |
Wrapper for enum Strength. More... | |
class | Gtk::ResponseType_Wrapper |
Wrapper for enum ResponseType. More... | |
Typedefs | |
using | Gtk::Constraint::Strength = Strength_Wrapper::Strength |
Strength enumerators are scoped by the wrapper class and can be implicitly converted to int. More... | |
using | Gtk::ResponseType = ResponseType_Wrapper::ResponseType |
ResponseType enumerators are scoped by the wrapper class and can be implicitly converted to int. More... | |
Functions | |
Application::InhibitFlags | Gtk::operator| (Application::InhibitFlags lhs, Application::InhibitFlags rhs) |
Application::InhibitFlags | Gtk::operator& (Application::InhibitFlags lhs, Application::InhibitFlags rhs) |
Application::InhibitFlags | Gtk::operator^ (Application::InhibitFlags lhs, Application::InhibitFlags rhs) |
Application::InhibitFlags | Gtk::operator~ (Application::InhibitFlags flags) |
Application::InhibitFlags& | Gtk::operator|= (Application::InhibitFlags& lhs, Application::InhibitFlags rhs) |
Application::InhibitFlags& | Gtk::operator&= (Application::InhibitFlags& lhs, Application::InhibitFlags rhs) |
Application::InhibitFlags& | Gtk::operator^= (Application::InhibitFlags& lhs, Application::InhibitFlags rhs) |
CellRendererState | Gtk::operator| (CellRendererState lhs, CellRendererState rhs) |
CellRendererState | Gtk::operator& (CellRendererState lhs, CellRendererState rhs) |
CellRendererState | Gtk::operator^ (CellRendererState lhs, CellRendererState rhs) |
CellRendererState | Gtk::operator~ (CellRendererState flags) |
CellRendererState& | Gtk::operator|= (CellRendererState& lhs, CellRendererState rhs) |
CellRendererState& | Gtk::operator&= (CellRendererState& lhs, CellRendererState rhs) |
CellRendererState& | Gtk::operator^= (CellRendererState& lhs, CellRendererState rhs) |
PickFlags | Gtk::operator| (PickFlags lhs, PickFlags rhs) |
PickFlags | Gtk::operator& (PickFlags lhs, PickFlags rhs) |
PickFlags | Gtk::operator^ (PickFlags lhs, PickFlags rhs) |
PickFlags | Gtk::operator~ (PickFlags flags) |
PickFlags& | Gtk::operator|= (PickFlags& lhs, PickFlags rhs) |
PickFlags& | Gtk::operator&= (PickFlags& lhs, PickFlags rhs) |
PickFlags& | Gtk::operator^= (PickFlags& lhs, PickFlags rhs) |
StateFlags | Gtk::operator| (StateFlags lhs, StateFlags rhs) |
StateFlags | Gtk::operator& (StateFlags lhs, StateFlags rhs) |
StateFlags | Gtk::operator^ (StateFlags lhs, StateFlags rhs) |
StateFlags | Gtk::operator~ (StateFlags flags) |
StateFlags& | Gtk::operator|= (StateFlags& lhs, StateFlags rhs) |
StateFlags& | Gtk::operator&= (StateFlags& lhs, StateFlags rhs) |
StateFlags& | Gtk::operator^= (StateFlags& lhs, StateFlags rhs) |
InputHints | Gtk::operator| (InputHints lhs, InputHints rhs) |
InputHints | Gtk::operator& (InputHints lhs, InputHints rhs) |
InputHints | Gtk::operator^ (InputHints lhs, InputHints rhs) |
InputHints | Gtk::operator~ (InputHints flags) |
InputHints& | Gtk::operator|= (InputHints& lhs, InputHints rhs) |
InputHints& | Gtk::operator&= (InputHints& lhs, InputHints rhs) |
InputHints& | Gtk::operator^= (InputHints& lhs, InputHints rhs) |
EventControllerScroll::Flags | Gtk::operator| (EventControllerScroll::Flags lhs, EventControllerScroll::Flags rhs) |
EventControllerScroll::Flags | Gtk::operator& (EventControllerScroll::Flags lhs, EventControllerScroll::Flags rhs) |
EventControllerScroll::Flags | Gtk::operator^ (EventControllerScroll::Flags lhs, EventControllerScroll::Flags rhs) |
EventControllerScroll::Flags | Gtk::operator~ (EventControllerScroll::Flags flags) |
EventControllerScroll::Flags& | Gtk::operator|= (EventControllerScroll::Flags& lhs, EventControllerScroll::Flags rhs) |
EventControllerScroll::Flags& | Gtk::operator&= (EventControllerScroll::Flags& lhs, EventControllerScroll::Flags rhs) |
EventControllerScroll::Flags& | Gtk::operator^= (EventControllerScroll::Flags& lhs, EventControllerScroll::Flags rhs) |
FontChooser::Level | Gtk::operator| (FontChooser::Level lhs, FontChooser::Level rhs) |
FontChooser::Level | Gtk::operator& (FontChooser::Level lhs, FontChooser::Level rhs) |
FontChooser::Level | Gtk::operator^ (FontChooser::Level lhs, FontChooser::Level rhs) |
FontChooser::Level | Gtk::operator~ (FontChooser::Level flags) |
FontChooser::Level& | Gtk::operator|= (FontChooser::Level& lhs, FontChooser::Level rhs) |
FontChooser::Level& | Gtk::operator&= (FontChooser::Level& lhs, FontChooser::Level rhs) |
FontChooser::Level& | Gtk::operator^= (FontChooser::Level& lhs, FontChooser::Level rhs) |
IconLookupFlags | Gtk::operator| (IconLookupFlags lhs, IconLookupFlags rhs) |
IconLookupFlags | Gtk::operator& (IconLookupFlags lhs, IconLookupFlags rhs) |
IconLookupFlags | Gtk::operator^ (IconLookupFlags lhs, IconLookupFlags rhs) |
IconLookupFlags | Gtk::operator~ (IconLookupFlags flags) |
IconLookupFlags& | Gtk::operator|= (IconLookupFlags& lhs, IconLookupFlags rhs) |
IconLookupFlags& | Gtk::operator&= (IconLookupFlags& lhs, IconLookupFlags rhs) |
IconLookupFlags& | Gtk::operator^= (IconLookupFlags& lhs, IconLookupFlags rhs) |
PopoverMenu::Flags | Gtk::operator| (PopoverMenu::Flags lhs, PopoverMenu::Flags rhs) |
PopoverMenu::Flags | Gtk::operator& (PopoverMenu::Flags lhs, PopoverMenu::Flags rhs) |
PopoverMenu::Flags | Gtk::operator^ (PopoverMenu::Flags lhs, PopoverMenu::Flags rhs) |
PopoverMenu::Flags | Gtk::operator~ (PopoverMenu::Flags flags) |
PopoverMenu::Flags& | Gtk::operator|= (PopoverMenu::Flags& lhs, PopoverMenu::Flags rhs) |
PopoverMenu::Flags& | Gtk::operator&= (PopoverMenu::Flags& lhs, PopoverMenu::Flags rhs) |
PopoverMenu::Flags& | Gtk::operator^= (PopoverMenu::Flags& lhs, PopoverMenu::Flags rhs) |
ShortcutAction::Flags | Gtk::operator| (ShortcutAction::Flags lhs, ShortcutAction::Flags rhs) |
ShortcutAction::Flags | Gtk::operator& (ShortcutAction::Flags lhs, ShortcutAction::Flags rhs) |
ShortcutAction::Flags | Gtk::operator^ (ShortcutAction::Flags lhs, ShortcutAction::Flags rhs) |
ShortcutAction::Flags | Gtk::operator~ (ShortcutAction::Flags flags) |
ShortcutAction::Flags& | Gtk::operator|= (ShortcutAction::Flags& lhs, ShortcutAction::Flags rhs) |
ShortcutAction::Flags& | Gtk::operator&= (ShortcutAction::Flags& lhs, ShortcutAction::Flags rhs) |
ShortcutAction::Flags& | Gtk::operator^= (ShortcutAction::Flags& lhs, ShortcutAction::Flags rhs) |
StyleContext::PrintFlags | Gtk::operator| (StyleContext::PrintFlags lhs, StyleContext::PrintFlags rhs) |
StyleContext::PrintFlags | Gtk::operator& (StyleContext::PrintFlags lhs, StyleContext::PrintFlags rhs) |
StyleContext::PrintFlags | Gtk::operator^ (StyleContext::PrintFlags lhs, StyleContext::PrintFlags rhs) |
StyleContext::PrintFlags | Gtk::operator~ (StyleContext::PrintFlags flags) |
StyleContext::PrintFlags& | Gtk::operator|= (StyleContext::PrintFlags& lhs, StyleContext::PrintFlags rhs) |
StyleContext::PrintFlags& | Gtk::operator&= (StyleContext::PrintFlags& lhs, StyleContext::PrintFlags rhs) |
StyleContext::PrintFlags& | Gtk::operator^= (StyleContext::PrintFlags& lhs, StyleContext::PrintFlags rhs) |
TextSearchFlags | Gtk::operator| (TextSearchFlags lhs, TextSearchFlags rhs) |
TextSearchFlags | Gtk::operator& (TextSearchFlags lhs, TextSearchFlags rhs) |
TextSearchFlags | Gtk::operator^ (TextSearchFlags lhs, TextSearchFlags rhs) |
TextSearchFlags | Gtk::operator~ (TextSearchFlags flags) |
TextSearchFlags& | Gtk::operator|= (TextSearchFlags& lhs, TextSearchFlags rhs) |
TextSearchFlags& | Gtk::operator&= (TextSearchFlags& lhs, TextSearchFlags rhs) |
TextSearchFlags& | Gtk::operator^= (TextSearchFlags& lhs, TextSearchFlags rhs) |
TreeModel::Flags | Gtk::operator| (TreeModel::Flags lhs, TreeModel::Flags rhs) |
TreeModel::Flags | Gtk::operator& (TreeModel::Flags lhs, TreeModel::Flags rhs) |
TreeModel::Flags | Gtk::operator^ (TreeModel::Flags lhs, TreeModel::Flags rhs) |
TreeModel::Flags | Gtk::operator~ (TreeModel::Flags flags) |
TreeModel::Flags& | Gtk::operator|= (TreeModel::Flags& lhs, TreeModel::Flags rhs) |
TreeModel::Flags& | Gtk::operator&= (TreeModel::Flags& lhs, TreeModel::Flags rhs) |
TreeModel::Flags& | Gtk::operator^= (TreeModel::Flags& lhs, TreeModel::Flags rhs) |
PrintCapabilities | Gtk::operator| (PrintCapabilities lhs, PrintCapabilities rhs) |
PrintCapabilities | Gtk::operator& (PrintCapabilities lhs, PrintCapabilities rhs) |
PrintCapabilities | Gtk::operator^ (PrintCapabilities lhs, PrintCapabilities rhs) |
PrintCapabilities | Gtk::operator~ (PrintCapabilities flags) |
PrintCapabilities& | Gtk::operator|= (PrintCapabilities& lhs, PrintCapabilities rhs) |
PrintCapabilities& | Gtk::operator&= (PrintCapabilities& lhs, PrintCapabilities rhs) |
PrintCapabilities& | Gtk::operator^= (PrintCapabilities& lhs, PrintCapabilities rhs) |
Detailed Description
Typedef Documentation
using Gtk::ResponseType = typedef ResponseType_Wrapper::ResponseType |
ResponseType enumerators are scoped by the wrapper class and can be implicitly converted to int.
using Gtk::Constraint::Strength = Strength_Wrapper::Strength |
Strength enumerators are scoped by the wrapper class and can be implicitly converted to int.
Enumeration Type Documentation
anonymous enum |
|
strong |
Describes whether a Gtk::FileChooser is being used to open existing files or to save to a possibly new file.
|
strong |
The action parameter to Gtk::PrintOperation::run() determines what action the print operation should perform.
|
strong |
Controls how a widget deals with extra space in a single (x or y) dimension.
Alignment only matters if the widget receives a “too large” allocation, for example if you packed the widget with the Gtk::Widget::property_hexpand() property inside a Gtk::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.
Gtk::Align::BASELINE support is optional for containers and widgets, and it is only supported for vertical alignment. When it's not supported by a child or a container it is treated as Gtk::Align::FILL.
Enumerator | |
---|---|
FILL |
Stretch to fill all space if possible, center if no meaningful way to stretch. The text is placed is distributed across the label. |
START |
Snap to left or top side, leaving space on right or bottom. Scroll to start. The child is packed into the start of the widget. |
END |
Snap to right or bottom side, leaving space on left or top. Go to the adjustments upper bound. Scroll to end. The child is packed into the end of the widget. |
CENTER |
Center natural width of widget inside the allocation. Center the baseline. The text is placed in the center of the label. |
BASELINE |
Align the widget according to the baseline. See Gtk::Widget. |
|
strong |
Used to indicate the direction in which an arrow should point.
|
strong |
The widget attributes that can be used when creating a Gtk::Constraint.
Enumerator | |
---|---|
NONE |
No attribute, used for constant relations. |
LEFT |
The left edge of a widget, regardless of text direction. |
RIGHT |
The right edge of a widget, regardless of text direction. |
TOP |
The top edge of a widget. |
BOTTOM |
The bottom edge of a widget. |
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. |
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. |
WIDTH |
The width of a widget. |
HEIGHT |
The height of a widget. |
CENTER_X |
The center of a widget, on the horizontal axis. |
CENTER_Y |
The center of a widget, on the vertical axis. |
BASELINE |
The baseline of a widget. |
|
strong |
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 Gtk::BaselinePosition to select where to put the baseline inside the extra available space.
Enumerator | |
---|---|
TOP | |
CENTER | |
BOTTOM |
|
strong |
Prebuilt sets of buttons for the dialog.
If none of these choices are appropriate, simply use Gtk::ButtonsType::NONE then call Gtk::Dialog::add_buttons().
Please note that Gtk::ButtonsType::OK, Gtk::ButtonsType::YES_NO and Gtk::ButtonsType::OK_CANCEL are discouraged by the GNOME Human Interface Guidelines.
Enumerator | |
---|---|
NONE | |
OK |
An OK button. |
CLOSE |
A Close button. |
CANCEL |
A Cancel button. |
YES_NO |
Yes and No buttons. |
OK_CANCEL |
OK and Cancel buttons. |
|
strong |
Identifies how the user can interact with a particular cell.
|
strong |
Tells how a cell is to be rendered.
- Bitwise operators:
CellRendererState operator|(CellRendererState, CellRendererState)
CellRendererState operator&(CellRendererState, CellRendererState)
CellRendererState operator^(CellRendererState, CellRendererState)
CellRendererState operator~(CellRendererState)
CellRendererState& operator|=(CellRendererState&, CellRendererState)
CellRendererState& operator&=(CellRendererState&, CellRendererState)
CellRendererState& operator^=(CellRendererState&, CellRendererState)
Enumerator | |
---|---|
SELECTED |
The cell is currently selected, and probably has a selection colored background to render to. Widget is selected. |
PRELIT |
The mouse is hovering over the cell. |
INSENSITIVE |
The cell is drawn in an insensitive manner. Widget is insensitive. Include widgets that are insensitive. |
SORTED |
The cell is in a sorted row. |
FOCUSED |
The cell is in the focus row. Widget has the keyboard focus. |
EXPANDABLE |
The cell is in a row that can be expanded. |
EXPANDED |
The cell is in a row that is expanded. |
|
strong |
Describes changes in a sorter in more detail and allows users to optimize resorting.
Enumerator | |
---|---|
DIFFERENT |
The sorter change cannot be described by any of the other enumeration values. |
INVERTED |
The sort order was inverted. Comparisons that returned Gtk::Ordering::SMALLER now return Gtk::Ordering::LARGER and vice versa. Other comparisons return the same values as before. |
LESS_STRICT |
The sorter is less strict: Comparisons may now return Gtk::Ordering::EQUAL that did not do so before. |
MORE_STRICT |
The sorter is more strict: Comparisons that did return Gtk::Ordering::EQUAL may not do so anymore. |
|
strong |
Describes changes in a filter in more detail and allows objects using the filter to optimize refiltering items.
If you are writing an implementation and are not sure which value to pass, Gtk::Filter::Change::DIFFERENT is always a correct choice.
|
strong |
Specifies which corner a child widget should be placed in when packed into a Gtk::ScrolledWindow.
This is effectively the opposite of where the scroll bars are placed.
|
strong |
See also: Gtk::Entry::signal_delete_from_cursor().
|
strong |
|
strong |
An enum for determining where a dropped item goes.
|
strong |
|
strong |
Describes the state of a Gdk::EventSequence in a Gtk::Gesture.
Enumerator | |
---|---|
NONE | |
CLAIMED |
The sequence is handled and grabbed. |
DENIED |
The sequence is denied. |
|
strong |
Flags that affect how popover menus are created from a menu model.
- Bitwise operators:
PopoverMenu::Flags operator|(PopoverMenu::Flags, PopoverMenu::Flags)
PopoverMenu::Flags operator&(PopoverMenu::Flags, PopoverMenu::Flags)
PopoverMenu::Flags operator^(PopoverMenu::Flags, PopoverMenu::Flags)
PopoverMenu::Flags operator~(PopoverMenu::Flags)
PopoverMenu::Flags& operator|=(PopoverMenu::Flags&, PopoverMenu::Flags)
PopoverMenu::Flags& operator&=(PopoverMenu::Flags&, PopoverMenu::Flags)
PopoverMenu::Flags& operator^=(PopoverMenu::Flags&, PopoverMenu::Flags)
Enumerator | |
---|---|
NESTED |
Create submenus as nested popovers. Without this flag, submenus are created as sliding pages that replace the main menu. |
|
strong |
Describes the behavior of a Gtk::EventControllerScroll.
- Bitwise operators:
EventControllerScroll::Flags operator|(EventControllerScroll::Flags, EventControllerScroll::Flags)
EventControllerScroll::Flags operator&(EventControllerScroll::Flags, EventControllerScroll::Flags)
EventControllerScroll::Flags operator^(EventControllerScroll::Flags, EventControllerScroll::Flags)
EventControllerScroll::Flags operator~(EventControllerScroll::Flags)
EventControllerScroll::Flags& operator|=(EventControllerScroll::Flags&, EventControllerScroll::Flags)
EventControllerScroll::Flags& operator&=(EventControllerScroll::Flags&, EventControllerScroll::Flags)
EventControllerScroll::Flags& operator^=(EventControllerScroll::Flags&, EventControllerScroll::Flags)
Enumerator | |
---|---|
NONE |
Don't emit scroll. |
VERTICAL |
Emit scroll with vertical deltas. |
HORIZONTAL |
Emit scroll with horizontal deltas. |
DISCRETE |
Only emit deltas that are multiples of 1. |
KINETIC |
Emit Gtk::EventControllerScroll::signal_decelerate() after continuous scroll finishes. |
BOTH_AXES |
Emit scroll on both axes. |
|
strong |
These flags indicate various properties of a Gtk::TreeModel.
They are returned by Gtk::TreeModel::get_flags(), and must be static for the lifetime of the object. A more complete description of Gtk::TreeModel::Flags::ITERS_PERSIST can be found in the overview of this section.
- Bitwise operators:
TreeModel::Flags operator|(TreeModel::Flags, TreeModel::Flags)
TreeModel::Flags operator&(TreeModel::Flags, TreeModel::Flags)
TreeModel::Flags operator^(TreeModel::Flags, TreeModel::Flags)
TreeModel::Flags operator~(TreeModel::Flags)
TreeModel::Flags& operator|=(TreeModel::Flags&, TreeModel::Flags)
TreeModel::Flags& operator&=(TreeModel::Flags&, TreeModel::Flags)
TreeModel::Flags& operator^=(TreeModel::Flags&, TreeModel::Flags)
Enumerator | |
---|---|
ITERS_PERSIST |
Iterators survive all signals emitted by the tree. |
LIST_ONLY |
The model is a list only, and never has children. |
|
strong |
List of flags that can be passed to action activation.
More flags may be added in the future.
- Bitwise operators:
ShortcutAction::Flags operator|(ShortcutAction::Flags, ShortcutAction::Flags)
ShortcutAction::Flags operator&(ShortcutAction::Flags, ShortcutAction::Flags)
ShortcutAction::Flags operator^(ShortcutAction::Flags, ShortcutAction::Flags)
ShortcutAction::Flags operator~(ShortcutAction::Flags)
ShortcutAction::Flags& operator|=(ShortcutAction::Flags&, ShortcutAction::Flags)
ShortcutAction::Flags& operator&=(ShortcutAction::Flags&, ShortcutAction::Flags)
ShortcutAction::Flags& operator^=(ShortcutAction::Flags&, ShortcutAction::Flags)
Enumerator | |
---|---|
EXCLUSIVE |
The action is the only action that can be activated. If this flag is not set, a future activation may select a different action. |
|
strong |
|
strong |
Used to specify options for Gtk::IconTheme::lookup_icon()
- Bitwise operators:
IconLookupFlags operator|(IconLookupFlags, IconLookupFlags)
IconLookupFlags operator&(IconLookupFlags, IconLookupFlags)
IconLookupFlags operator^(IconLookupFlags, IconLookupFlags)
IconLookupFlags operator~(IconLookupFlags)
IconLookupFlags& operator|=(IconLookupFlags&, IconLookupFlags)
IconLookupFlags& operator&=(IconLookupFlags&, IconLookupFlags)
IconLookupFlags& operator^=(IconLookupFlags&, IconLookupFlags)
|
strong |
|
strong |
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 | |
---|---|
INHERIT |
Keep the size of the parent element. |
NORMAL |
Size similar to text size. Normal quality. State during normal operation. |
LARGE |
Large size, for example in an icon view. |
|
strong |
Types of user actions that may be blocked by Gtk::Application::inhibit().
- Bitwise operators:
Application::InhibitFlags operator|(Application::InhibitFlags, Application::InhibitFlags)
Application::InhibitFlags operator&(Application::InhibitFlags, Application::InhibitFlags)
Application::InhibitFlags operator^(Application::InhibitFlags, Application::InhibitFlags)
Application::InhibitFlags operator~(Application::InhibitFlags)
Application::InhibitFlags& operator|=(Application::InhibitFlags&, Application::InhibitFlags)
Application::InhibitFlags& operator&=(Application::InhibitFlags&, Application::InhibitFlags)
Application::InhibitFlags& operator^=(Application::InhibitFlags&, Application::InhibitFlags)
|
strong |
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 Gtk::InputPurpose of the entry.
Some common sense is expected when using these flags - mixing Gtk::InputHints::LOWERCASE with any of the uppercase hints makes no sense.
This enumeration may be extended in the future; input methods should ignore unknown values.
- Bitwise operators:
InputHints operator|(InputHints, InputHints)
InputHints operator&(InputHints, InputHints)
InputHints operator^(InputHints, InputHints)
InputHints operator~(InputHints)
InputHints& operator|=(InputHints&, InputHints)
InputHints& operator&=(InputHints&, InputHints)
InputHints& operator^=(InputHints&, InputHints)
|
strong |
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::InputPurpose::DIGITS and Gtk::InputPurpose::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”.
Enumerator | |
---|---|
FREE_FORM |
Allow any character. |
ALPHA |
Allow only alphabetic characters. |
DIGITS |
Allow only digits. |
NUMBER |
Edited field expects numbers. |
PHONE |
Edited field expects phone number. |
URL |
Edited field expects URL. |
Edited field expects email address. | |
NAME |
Edited field expects the name of a person. |
PASSWORD |
Like Gtk::InputPurpose::FREE_FORM, but characters are hidden. |
PIN |
Like Gtk::InputPurpose::DIGITS, but characters are hidden. |
TERMINAL |
Allow any character, in addition to control codes. |
|
strong |
Used for justifying the text inside a Gtk::Label widget.
Enumerator | |
---|---|
LEFT | |
RIGHT | |
CENTER | |
FILL |
|
strong |
This enumeration specifies the granularity of font selection that is desired in a font chooser.
This enumeration may be extended in the future; applications should ignore unknown values.
- Bitwise operators:
FontChooser::Level operator|(FontChooser::Level, FontChooser::Level)
FontChooser::Level operator&(FontChooser::Level, FontChooser::Level)
FontChooser::Level operator^(FontChooser::Level, FontChooser::Level)
FontChooser::Level operator~(FontChooser::Level)
FontChooser::Level& operator|=(FontChooser::Level&, FontChooser::Level)
FontChooser::Level& operator&=(FontChooser::Level&, FontChooser::Level)
FontChooser::Level& operator^=(FontChooser::Level&, FontChooser::Level)
|
strong |
The type of license for an application.
This enumeration can be expanded at later date.
|
strong |
Describes the known strictness of a filter.
Note that for filters where the strictness is not known, Gtk::Filter::Match::SOME is always an acceptable value, even if a filter does match all or no items.
Enumerator | |
---|---|
SOME |
The filter matches some items, Gtk::Filter::match() may return |
NONE |
The filter does not match any item, Gtk::Filter::match() will always return |
ALL |
The filter matches all items, Gtk::Filter::match() will alays return |
|
strong |
|
strong |
|
strong |
The mode of the size group determines the directions in which the size group affects the requested sizes of its component widgets.
Enumerator | |
---|---|
NONE |
Group has no effect. |
HORIZONTAL |
Group affects horizontal requisition. |
VERTICAL |
Group affects vertical requisition. |
BOTH |
Group affects both horizontal and vertical requisition. |
|
strong |
Describes how Gtk::LevelBar contents should be rendered.
Note that this enumeration could be extended with additional modes in the future.
Enumerator | |
---|---|
CONTINUOUS |
The bar has a continuous mode. |
DISCRETE |
The bar has a discrete mode. |
|
strong |
|
strong |
Used to determine the layout of pages on a sheet when printing multiple pages per sheet.
|
strong |
Describes the type of order that a Gtk::Sorter may describe.
Enumerator | |
---|---|
PARTIAL |
A partial order. Any Gtk::Ordering is possible. |
NONE |
No order, all elements are considered equal. Gtk::Sorter::compare() will only return Gtk::Ordering::EQUAL. |
TOTAL |
A total order. Gtk::Sorter::compare() will only return Gtk::Ordering::EQUAL if an item is compared with itself. Two different items will never cause this value to be returned. |
|
strong |
Describes the way two values can be compared.
These values can be used with a CompareFunc. However, a CompareFunc is allowed to return any integer values. For converting such a value to a Gtk::Ordering, use gtk_ordering_from_cmpfunc().
Enumerator | |
---|---|
SMALLER |
The first value is smaller than the second. |
EQUAL |
The two values are equal. |
LARGER |
The first value is larger than the second. |
|
strong |
Represents the orientation of widgets and other objects which can be switched between horizontal and vertical orientation on the fly, like Gtk::Box or Gtk::GesturePan.
Enumerator | |
---|---|
HORIZONTAL |
The element is in horizontal orientation. Horizontal duplex. |
VERTICAL |
The element is in vertical orientation. Vertical duplex. |
|
strong |
Defines how content overflowing a given area should be handled, such as with Gtk::Widget::set_overflow().
This property is modeled after the CSS overflow property, but implements it only partially.
|
strong |
Represents the packing location of a children in its parent.
See Gtk::WindowControls for example.
Enumerator | |
---|---|
START | |
END |
|
strong |
|
strong |
See also Gtk::PrintSettings::set_orientation().
Enumerator | |
---|---|
PORTRAIT |
Portrait mode. |
LANDSCAPE |
Landscape mode. |
REVERSE_PORTRAIT |
Reverse portrait mode. |
REVERSE_LANDSCAPE |
Reverse landscape mode. |
|
strong |
See also Gtk::PrintJob::set_page_set().
Enumerator | |
---|---|
ALL | |
EVEN |
Even pages. |
ODD |
Odd pages. |
|
strong |
Describes the panning direction of a Gtk::GesturePan.
Enumerator | |
---|---|
LEFT | |
RIGHT | |
UP | |
DOWN |
|
strong |
Flags that influence the behavior of Gtk::Widget::pick()
- Bitwise operators:
PickFlags operator|(PickFlags, PickFlags)
PickFlags operator&(PickFlags, PickFlags)
PickFlags operator^(PickFlags, PickFlags)
PickFlags operator~(PickFlags)
PickFlags& operator|=(PickFlags&, PickFlags)
PickFlags& operator&=(PickFlags&, PickFlags)
PickFlags& operator^=(PickFlags&, PickFlags)
Enumerator | |
---|---|
DEFAULT |
The default behavior, include widgets that are receiving events. |
INSENSITIVE | |
NON_TARGETABLE |
Include widgets that are marked as non-targetable. |
|
strong |
Defines the policy to be used in a scrollable widget when updating the scrolled window adjustments in a given orientation.
Enumerator | |
---|---|
MINIMUM |
Scrollable adjustments are based on the minimum size. |
NATURAL |
Scrollable adjustments are based on the natural size. |
|
strong |
Determines how the size should be computed to achieve the one of the visibility mode for the scrollbars.
Enumerator | |
---|---|
ALWAYS |
The scrollbar is always visible. The view size is independent of the content. |
AUTOMATIC |
The scrollbar will appear and disappear as necessary. For example, when all of a Gtk::TreeView can not be seen. |
NEVER |
The scrollbar should never appear. In this mode the content determines the size. |
EXTERNAL |
Don't show a scrollbar, but don't force the size to follow the content. This can be used e.g. to make multiple scrolled windows share a scrollbar. |
|
strong |
Describes which edge of a widget a certain feature is positioned at, e.g.
the tabs of a Gtk::Notebook, or the label of a Gtk::Scale.
|
strong |
An enum for specifying which features the print dialog should offer.
If neither Gtk::PrintCapabilities::GENERATE_PDF nor Gtk::PrintCapabilities::GENERATE_PS is specified, GTK+ assumes that all formats are supported.
- Bitwise operators:
PrintCapabilities operator|(PrintCapabilities, PrintCapabilities)
PrintCapabilities operator&(PrintCapabilities, PrintCapabilities)
PrintCapabilities operator^(PrintCapabilities, PrintCapabilities)
PrintCapabilities operator~(PrintCapabilities)
PrintCapabilities& operator|=(PrintCapabilities&, PrintCapabilities)
PrintCapabilities& operator&=(PrintCapabilities&, PrintCapabilities)
PrintCapabilities& operator^=(PrintCapabilities&, PrintCapabilities)
|
strong |
See also Gtk::PrintSettings::set_duplex().
Enumerator | |
---|---|
SIMPLEX |
No duplex. |
HORIZONTAL | |
VERTICAL |
|
strong |
Flags that modify the behavior of Gtk::StyleContext::to_string().
New values may be added to this enumeration.
- Bitwise operators:
StyleContext::PrintFlags operator|(StyleContext::PrintFlags, StyleContext::PrintFlags)
StyleContext::PrintFlags operator&(StyleContext::PrintFlags, StyleContext::PrintFlags)
StyleContext::PrintFlags operator^(StyleContext::PrintFlags, StyleContext::PrintFlags)
StyleContext::PrintFlags operator~(StyleContext::PrintFlags)
StyleContext::PrintFlags& operator|=(StyleContext::PrintFlags&, StyleContext::PrintFlags)
StyleContext::PrintFlags& operator&=(StyleContext::PrintFlags&, StyleContext::PrintFlags)
StyleContext::PrintFlags& operator^=(StyleContext::PrintFlags&, StyleContext::PrintFlags)
|
strong |
See also Gtk::PrintJob::set_pages()
Enumerator | |
---|---|
ALL |
All pages. |
CURRENT |
Current page. |
RANGES |
Range of pages. |
SELECTION |
Selected pages. |
|
strong |
See also Gtk::PrintSettings::set_quality().
Enumerator | |
---|---|
LOW |
Low quality. |
NORMAL | |
HIGH |
High quality. |
DRAFT |
Draft quality. |
|
strong |
The status gives a rough indication of the completion of a running print operation.
|
strong |
Describes limits of a Gtk::EventController for handling events targeting other widgets.
Enumerator | |
---|---|
NONE | |
SAME_NATIVE |
Events are only handled if their target is in the same Gtk::Native as the event controllers widget. Note that some event types have two targets (origin and destination). |
|
strong |
Describes the stage at which events are fed into a Gtk::EventController.
|
strong |
The possible accessible properties of a Gtk::Accessible.
Enumerator | |
---|---|
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: Gtk::AccessibleAutocomplete. |
DESCRIPTION |
Defines a string value that describes or annotates the current element. Value type: string. |
HAS_POPUP |
Indicates the availability and type of interactive popup element, such as menu or dialog, that can be triggered by an element. |
KEY_SHORTCUTS |
Indicates keyboard shortcuts that an author has implemented to activate or give focus to an element. Value type: string. |
LABEL | |
LEVEL |
Defines the hierarchical level of an element within a structure. Value type: integer. |
MODAL |
Indicates whether an element is modal when displayed. Value type: boolean. |
MULTI_LINE |
Indicates whether a text box accepts multiple lines of input or only a single line. Value type: boolean. |
MULTI_SELECTABLE |
Indicates that the user may select more than one item from the current selectable descendants. Value type: boolean. |
ORIENTATION |
Indicates whether the element's orientation is horizontal, vertical, or unknown/ambiguous. Value type: Gtk::Orientation. |
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. |
READ_ONLY |
Indicates that the element is not editable, but is otherwise operable. Value type: boolean. |
REQUIRED |
Indicates that user input is required on the element before a form may be submitted. Value type: boolean. |
ROLE_DESCRIPTION |
Defines a human-readable, author-localized description for the role of an element. Value type: string. |
SORT |
Indicates if items in a table or grid are sorted in ascending or descending order. Possible property values are in the Gtk::AccessibleSort enumeration. Value type: Gtk::AccessibleSort. |
VALUE_MAX |
Defines the maximum allowed value for a range widget. Value type: double. |
VALUE_MIN |
Defines the minimum allowed value for a range widget. Value type: double. |
VALUE_NOW |
Defines the current value for a range widget. Value type: double. |
VALUE_TEXT |
Defines the human readable text alternative of aria-valuenow for a range widget. Value type: string. |
|
strong |
|
strong |
The possible accessible relations of a Gtk::Accessible.
Accessible relations can be references to other widgets, integers or strings.
Enumerator | |
---|---|
ACTIVE_DESCENDANT |
Identifies the currently active element when focus is on a composite widget, combobox, textbox, group, or application. Value type: reference. |
COL_COUNT |
Defines the total number of columns in a table, grid, or treegrid. Value type: integer. |
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. |
COL_INDEX_TEXT |
Defines a human readable text alternative of Gtk::Accessible::Relation::COL_INDEX. Value type: string. |
COL_SPAN |
Defines the number of columns spanned by a cell or gridcell within a table, grid, or treegrid. Value type: integer. |
CONTROLS |
Identifies the element (or elements) whose contents or presence are controlled by the current element. Value type: reference. |
DESCRIBED_BY |
Identifies the element (or elements) that describes the object. Value type: reference. |
DETAILS |
Identifies the element (or elements) that provide additional information related to the object. Value type: reference. |
ERROR_MESSAGE |
Identifies the element that provides an error message for an object. Value type: reference. |
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. |
LABELLED_BY |
Identifies the element (or elements) that labels the current element. Value type: reference. |
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. |
POS_IN_SET |
Defines an element's number or position in the current set of listitems or treeitems. Value type: integer. |
ROW_COUNT |
Defines the total number of rows in a table, grid, or treegrid. Value type: integer. |
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. |
ROW_INDEX_TEXT |
Defines a human readable text alternative of aria-rowindex. Value type: string. |
ROW_SPAN |
Defines the number of rows spanned by a cell or gridcell within a table, grid, or treegrid. Value type: integer. |
SET_SIZE |
Defines the number of items in the current set of listitems or treeitems. Value type: integer. |
Predefined values for use as response ids in Gtk::Dialog::add_button().
All predefined values are negative; GTK leaves values of 0 or greater for application-defined response ids.
|
strong |
A value of this type is returned by Gtk::PrintOperation::run().
|
strong |
These enumeration values describe the possible transitions when the child of a Gtk::Revealer widget is shown or hidden.
|
strong |
The accessible role for a Gtk::Accessible implementation.
Abstract roles are only used as part of the ontology; application developers must not use abstract roles in their code.
Enumerator | |
---|---|
ALERT |
An element with important, and usually time-sensitive, information. |
ALERT_DIALOG |
A type of dialog that contains an alert message. |
BANNER |
Unused. |
BUTTON |
An input element that allows for user-triggered actions when clicked or pressed. |
CAPTION |
Unused. |
CELL |
Unused. |
CHECKBOX |
A checkable input element that has three possible values: |
COLUMN_HEADER |
A header in a columned list. |
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. |
COMMAND |
Abstract role. |
COMPOSITE |
Abstract 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. |
DOCUMENT |
Unused. |
FEED |
Unused. |
FORM |
Unused. |
GENERIC |
Unused. |
GRID |
A grid of items. |
GRID_CELL |
An item in a grid or tree grid. |
GROUP |
An element that groups multiple widgets. GTK uses this role for various containers, like Gtk::Box, Gtk::Viewport, and Gtk::HeaderBar. |
HEADING |
Unused. |
IMG |
An image. |
INPUT |
Abstract role. |
LABEL |
A visible name or caption for a user interface component. Defines a string value that labels the current element. Value type: string. |
LANDMARK |
Abstract role. |
LEGEND |
Unused. |
LINK |
A clickable link. |
LIST |
A list of items. |
LIST_BOX |
Unused. |
LIST_ITEM |
An item in a list. |
LOG |
Unused. |
MAIN |
Unused. |
MARQUEE |
Unused. |
MATH |
Unused. |
METER |
An element that represents a value within a known range. |
MENU |
A menu. |
MENU_BAR |
A menubar. |
MENU_ITEM |
An item in a menu. |
MENU_ITEM_CHECKBOX |
A check item in a menu. |
MENU_ITEM_RADIO |
A radio item in a menu. |
NAVIGATION |
Unused. |
NONE |
An element that is not represented to accessibility technologies. |
NOTE |
Unused. |
OPTION |
Unused. |
PRESENTATION |
An element that is not represented to accessibility technologies. |
PROGRESS_BAR |
An element that displays the progress status for tasks that take a long time. |
RADIO |
A checkable input in a group of radio roles, only one of which can be checked at a time. |
RADIO_GROUP |
Unused. |
RANGE |
Abstract role. |
REGION |
Unused. |
ROW |
A row in a columned list. |
ROW_GROUP |
Unused. |
ROW_HEADER |
Unused. |
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. |
SEARCH |
Unused. |
SEARCH_BOX |
A type of textbox intended for specifying search criteria. |
SECTION |
Abstract role. |
SECTION_HEAD |
Abstract role. |
SELECT |
Abstract role. |
SEPARATOR |
A divider that separates and distinguishes sections of content or groups of menuitems. |
SLIDER |
A user input where the user selects a value from within a given range. |
SPIN_BUTTON |
A form of range that expects the user to select from among discrete choices. |
STATUS |
Unused. |
STRUCTURE |
Abstract role. |
SWITCH |
A type of checkbox that represents on/off values, as opposed to checked/unchecked values. |
TAB |
An item in a list of tab used for switching pages. |
TABLE |
Unused. |
TAB_LIST |
A list of tabs for switching pages. |
TAB_PANEL |
A page in a notebook or stack. |
TEXT_BOX |
A type of input that allows free-form text as its value. |
TIME |
Unused. |
TIMER |
Unused. |
TOOLBAR |
Unused. |
TOOLTIP |
Unused. |
TREE |
Unused. |
TREE_GRID |
A treeview-like, columned list. |
TREE_ITEM |
Unused. |
WIDGET |
An interactive component of a graphical user interface. This is the role that GTK uses by default for widgets. |
WINDOW |
An application window. |
|
strong |
Scrolling types.
|
strong |
Used to control what selections users are allowed to make.
Enumerator | |
---|---|
NONE | |
SINGLE |
Zero or one element may be selected. |
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::SelectionMode::BROWSE. What is really enforced is that the user can’t deselect a currently selected element except by selecting another element. |
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. |
|
strong |
|
strong |
Describes where Gtk::Shortcuts added to a Gtk::ShortcutController get handled.
Enumerator | |
---|---|
LOCAL |
Shortcuts are handled inside the widget the controller belongs to. |
MANAGED |
Shortcuts are handled by the first ancestor that is a Gtk::ShortcutManager. |
GLOBAL |
Shortcuts are handled by the root widget. |
|
strong |
GtkShortcutType specifies the kind of shortcut that is being described.
More values may be added to this enumeration over time.
Enumerator | |
---|---|
ACCELERATOR |
The shortcut is a keyboard accelerator. The Gtk::ShortcutsShortcut::property_accelerator() property will be used. |
GESTURE_PINCH |
The shortcut is a pinch gesture. GTK+ provides an icon and subtitle. |
GESTURE_STRETCH |
The shortcut is a stretch gesture. GTK+ provides an icon and subtitle. |
GESTURE_ROTATE_CLOCKWISE |
The shortcut is a clockwise rotation gesture. GTK+ provides an icon and subtitle. |
GESTURE_ROTATE_COUNTERCLOCKWISE |
The shortcut is a counterclockwise rotation gesture. GTK+ provides an icon and subtitle. |
GESTURE_TWO_FINGER_SWIPE_LEFT |
The shortcut is a two-finger swipe gesture. GTK+ provides an icon and subtitle. |
GESTURE_TWO_FINGER_SWIPE_RIGHT |
The shortcut is a two-finger swipe gesture. GTK+ provides an icon and subtitle. |
GESTURE |
The shortcut is a gesture. The Gtk::ShortcutsShortcut::property_icon() property will be used. |
GESTURE_SWIPE_LEFT |
The shortcut is a swipe gesture. GTK+ provides an icon and subtitle. |
GESTURE_SWIPE_RIGHT |
The shortcut is a swipe gesture. GTK+ provides an icon and subtitle. |
|
strong |
|
strong |
The sizing method the column uses to determine its width.
Please note that Gtk::TreeViewColumn::Sizing::AUTOSIZE are inefficient for large views, and can make columns appear choppy.
|
strong |
|
strong |
The values of the GtkSpinType enumeration are used to specify the change to make in Gtk::SpinButton::spin().
Enumerator | |
---|---|
STEP_FORWARD | |
STEP_BACKWARD | |
PAGE_FORWARD | |
PAGE_BACKWARD | |
HOME |
Go to the adjustments lower bound. |
END | |
USER_DEFINED |
Change by a specified amount. |
|
strong |
These enumeration values describe the possible transitions between pages in a Gtk::Stack widget.
New values may be added to this enumeration over time.
|
strong |
The possible accessible states of a Gtk::Accessible.
Enumerator | |
---|---|
BUSY |
A “busy” state. This state has boolean values. |
CHECKED |
A “checked” state; indicates the current state of a Gtk::CheckButton. Value type: Gtk::AccessibleTristate. |
DISABLED |
A “disabled” state; corresponds to the Gtk::Widget::property_sensitive() property on Gtk::Widget. It indicates a UI element that is perceivable, but not editable or operable. Value type: boolean. |
EXPANDED |
An “expanded” state; corresponds to the Gtk::Expander::property_expanded() property on Gtk::Expander. Value type: boolean or undefined. |
HIDDEN |
A “hidden” state; corresponds to the Gtk::Widget::property_visible() property on Gtk::Widget. 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. |
INVALID |
An “invalid” state; set when a widget is showing an error. Value type: Gtk::AccessibleInvalidState. |
PRESSED |
A “pressed” state; indicates the current state of a Gtk::ToggleButton. Value type: Gtk::AccessibleTristate enumeration. |
SELECTED |
A “selected” state; set when a widget is selected. Value type: boolean or undefined. |
|
strong |
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.
- Bitwise operators:
StateFlags operator|(StateFlags, StateFlags)
StateFlags operator&(StateFlags, StateFlags)
StateFlags operator^(StateFlags, StateFlags)
StateFlags operator~(StateFlags)
StateFlags& operator|=(StateFlags&, StateFlags)
StateFlags& operator&=(StateFlags&, StateFlags)
StateFlags& operator^=(StateFlags&, StateFlags)
Enumerator | |
---|---|
NORMAL | |
ACTIVE |
Widget is active. |
PRELIGHT |
Widget has a mouse pointer over it. |
SELECTED | |
INSENSITIVE | |
INCONSISTENT |
Widget is inconsistent. |
FOCUSED | |
BACKDROP |
Widget is in a background toplevel window. |
DIR_LTR |
Widget is in left-to-right text direction. |
DIR_RTL |
Widget is in right-to-left text direction. |
LINK |
Widget is a link. |
VISITED |
The location the widget points to has already been visited. |
CHECKED |
Widget is checked. |
DROP_ACTIVE |
Widget is highlighted as a drop target for DND. |
FOCUS_VISIBLE |
Widget has the visible focus. |
FOCUS_WITHIN |
Widget contains the keyboard focus. |
The strength of a constraint, expressed as a symbolic constant.
The strength of a Gtk::Constraint can be expressed with any positive integer; the values of this enumeration can be used for readability.
Enumerator | |
---|---|
REQUIRED |
The constraint is required towards solving the layout. |
STRONG |
A strong constraint. |
MEDIUM |
A medium constraint. |
WEAK |
A weak constraint. |
|
strong |
|
strong |
Flags affecting how a search is done.
If neither Gtk::TextSearchFlags::VISIBLE_ONLY nor Gtk::TextSearchFlags::TEXT_ONLY are enabled, the match must be exact; the special 0xFFFC character will match embedded paintables or child widgets.
- Bitwise operators:
TextSearchFlags operator|(TextSearchFlags, TextSearchFlags)
TextSearchFlags operator&(TextSearchFlags, TextSearchFlags)
TextSearchFlags operator^(TextSearchFlags, TextSearchFlags)
TextSearchFlags operator~(TextSearchFlags)
TextSearchFlags& operator|=(TextSearchFlags&, TextSearchFlags)
TextSearchFlags& operator&=(TextSearchFlags&, TextSearchFlags)
TextSearchFlags& operator^=(TextSearchFlags&, TextSearchFlags)
|
strong |
Used to reference the parts of Gtk::TextView.
Enumerator | |
---|---|
WIDGET |
Window that floats over scrolling areas. |
TEXT |
Scrollable text window. |
LEFT | |
RIGHT | |
TOP | |
BOTTOM |
|
strong |
Describes the image data representation used by a Gtk::Image.
If you want to get the image from the widget, you can only get the currently-stored representation. e.g. if the Gtk::Image::get_storage_type() returns Gtk::Image::Type::PAINTABLE, then you can call Gtk::Image::get_paintable(). For empty images, you can request any storage type (call any of the "get" functions), but they will all return nullptr
values.
Enumerator | |
---|---|
EMPTY |
There is no image displayed by the widget. |
ICON_NAME |
The widget contains a named icon. |
GICON |
The widget contains a Gio::Icon. |
PAINTABLE |
The widget contains a Gdk::Paintable. |
|
strong |
An enum for determining the page role inside the Gtk::Assistant.
It's used to handle buttons sensitivity and visibility.
Note that an assistant needs to end its page flow with a page of type Gtk::AssistantPage::Type::CONFIRM, Gtk::AssistantPage::Type::SUMMARY or Gtk::AssistantPage::Type::PROGRESS to be correct.
The Cancel button will only be shown if the page isn’t “committed”. See Gtk::Assistant::commit() for details.
Enumerator | |
---|---|
CONTENT |
The page has regular contents. Both the Back and forward buttons will be shown. |
INTRO |
The page contains an introduction to the assistant task. Only the Forward button will be shown if there is a next page. |
CONFIRM |
The page lets the user confirm or deny the changes. The Back and Apply buttons will be shown. |
SUMMARY |
The page informs the user of the changes done. Only the Close button will be shown. |
PROGRESS |
Used for tasks that take a long time to complete, blocks the assistant until the page is marked as complete. Only the back button will be shown. |
CUSTOM |
Used for when other page types are not appropriate. No buttons will be shown, and the application must add its own buttons through Gtk::Assistant::add_action_widget(). |
|
strong |
See also Gtk::PrintSettings::set_paper_width().
Enumerator | |
---|---|
NONE | |
POINTS |
Dimensions in points. |
INCH |
Dimensions in inches. |
MM |
Dimensions in millimeters. |
|
strong |
The spin button update policy determines whether the spin button displays values even if they are outside the bounds of its adjustment.
See Gtk::SpinButton::set_update_policy().
Enumerator | |
---|---|
ALWAYS |
When refreshing your Gtk::SpinButton, the value is always displayed. |
IF_VALID |
When refreshing your Gtk::SpinButton, the value is only displayed if it is valid within the bounds of the spin button's adjustment. |
Function Documentation
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |