gtkmm 4.10.0

Classes | Typedefs | Enumerations | Functions
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...

## Enumerations
enum | { Gtk::SpinButton::INPUT_ERROR = -1 }
| Constant to return from a signal handler for the input signal in case of conversion failure. More...
enum class | Gtk::License { Gtk::UNKNOWN , Gtk::CUSTOM , Gtk::GPL_2_0 , Gtk::GPL_3_0 , Gtk::LGPL_2_1 , Gtk::LGPL_3_0 , Gtk::BSD , Gtk::MIT_X11 , Gtk::ARTISTIC , Gtk::GPL_2_0_ONLY , Gtk::GPL_3_0_ONLY , Gtk::LGPL_2_1_ONLY , Gtk::LGPL_3_0_ONLY , Gtk::AGPL_3_0 , Gtk::AGPL_3_0_ONLY , Gtk::BSD_3 , Gtk::APACHE_2_0 , Gtk::MPL_2_0 }
| The type of license for an application. More...
enum class | Gtk::Accessible::Role { Gtk::Accessible::ALERT , Gtk::Accessible::ALERT_DIALOG , Gtk::Accessible::BANNER , Gtk::Accessible::BUTTON , Gtk::Accessible::CAPTION , Gtk::Accessible::CELL , Gtk::Accessible::CHECKBOX , Gtk::Accessible::COLUMN_HEADER , Gtk::Accessible::COMBO_BOX , Gtk::Accessible::COMMAND , Gtk::Accessible::COMPOSITE , Gtk::Accessible::DIALOG , Gtk::Accessible::DOCUMENT , Gtk::Accessible::FEED , Gtk::Accessible::FORM , Gtk::Accessible::GENERIC , Gtk::Accessible::GRID , Gtk::Accessible::GRID_CELL , Gtk::Accessible::GROUP , Gtk::Accessible::HEADING , Gtk::Accessible::IMG , Gtk::Accessible::INPUT , Gtk::Accessible::LABEL , Gtk::Accessible::LANDMARK , Gtk::Accessible::LEGEND , Gtk::Accessible::LINK , Gtk::Accessible::LIST , Gtk::Accessible::LIST_BOX , Gtk::Accessible::LIST_ITEM , Gtk::Accessible::LOG , Gtk::Accessible::MAIN , Gtk::Accessible::MARQUEE , Gtk::Accessible::MATH , Gtk::Accessible::METER , Gtk::Accessible::MENU , Gtk::Accessible::MENU_BAR , Gtk::Accessible::MENU_ITEM , Gtk::Accessible::MENU_ITEM_CHECKBOX , Gtk::Accessible::MENU_ITEM_RADIO , Gtk::Accessible::NAVIGATION , Gtk::Accessible::NONE , Gtk::Accessible::NOTE , Gtk::Accessible::OPTION , Gtk::Accessible::PRESENTATION , Gtk::Accessible::PROGRESS_BAR , Gtk::Accessible::RADIO , Gtk::Accessible::RADIO_GROUP , Gtk::Accessible::RANGE , Gtk::Accessible::REGION , Gtk::Accessible::ROW , Gtk::Accessible::ROW_GROUP , Gtk::Accessible::ROW_HEADER , Gtk::Accessible::SCROLLBAR , Gtk::Accessible::SEARCH , Gtk::Accessible::SEARCH_BOX , Gtk::Accessible::SECTION , Gtk::Accessible::SECTION_HEAD , Gtk::Accessible::SELECT , Gtk::Accessible::SEPARATOR , Gtk::Accessible::SLIDER , Gtk::Accessible::SPIN_BUTTON , Gtk::Accessible::STATUS , Gtk::Accessible::STRUCTURE , Gtk::Accessible::SWITCH , Gtk::Accessible::TAB , Gtk::Accessible::TABLE , Gtk::Accessible::TAB_LIST , Gtk::Accessible::TAB_PANEL , Gtk::Accessible::TEXT_BOX , Gtk::Accessible::TIME , Gtk::Accessible::TIMER , Gtk::Accessible::TOOLBAR , Gtk::Accessible::TOOLTIP , Gtk::Accessible::TREE , Gtk::Accessible::TREE_GRID , Gtk::Accessible::TREE_ITEM , Gtk::Accessible::WIDGET , Gtk::Accessible::WINDOW , Gtk::Accessible::TOGGLE_BUTTON }
| The accessible role for a Gtk::Accessible implementation. More...
enum class | Gtk::Accessible::State { Gtk::Accessible::BUSY , Gtk::Accessible::CHECKED , Gtk::Accessible::DISABLED , Gtk::Accessible::EXPANDED , Gtk::Accessible::HIDDEN , Gtk::Accessible::INVALID , Gtk::Accessible::PRESSED , Gtk::Accessible::SELECTED }
| The possible accessible states of a Gtk::Accessible. More...
enum class | Gtk::Accessible::Property { Gtk::Accessible::AUTOCOMPLETE , Gtk::Accessible::DESCRIPTION , Gtk::Accessible::HAS_POPUP , Gtk::Accessible::KEY_SHORTCUTS , Gtk::Accessible::LABEL , Gtk::Accessible::LEVEL , Gtk::Accessible::MODAL , Gtk::Accessible::MULTI_LINE , Gtk::Accessible::MULTI_SELECTABLE , Gtk::Accessible::ORIENTATION , Gtk::Accessible::PLACEHOLDER , Gtk::Accessible::READ_ONLY , Gtk::Accessible::REQUIRED , Gtk::Accessible::ROLE_DESCRIPTION , Gtk::Accessible::SORT , Gtk::Accessible::VALUE_MAX , Gtk::Accessible::VALUE_MIN , Gtk::Accessible::VALUE_NOW , Gtk::Accessible::VALUE_TEXT }
| The possible accessible properties of a Gtk::Accessible. More...
enum class | Gtk::Accessible::Relation { Gtk::Accessible::ACTIVE_DESCENDANT , Gtk::Accessible::COL_COUNT , Gtk::Accessible::COL_INDEX , Gtk::Accessible::COL_INDEX_TEXT , Gtk::Accessible::COL_SPAN , Gtk::Accessible::CONTROLS , Gtk::Accessible::DESCRIBED_BY , Gtk::Accessible::DETAILS , Gtk::Accessible::ERROR_MESSAGE , Gtk::Accessible::FLOW_TO , Gtk::Accessible::LABELLED_BY , Gtk::Accessible::OWNS , Gtk::Accessible::POS_IN_SET , Gtk::Accessible::ROW_COUNT , Gtk::Accessible::ROW_INDEX , Gtk::Accessible::ROW_INDEX_TEXT , Gtk::Accessible::ROW_SPAN , Gtk::Accessible::SET_SIZE }
| The possible accessible relations of a Gtk::Accessible. More...
enum class | Gtk::Accessible::PlatformState { Gtk::Accessible::FOCUSABLE , Gtk::Accessible::FOCUSED , Gtk::Accessible::ACTIVE }
| The various platform states which can be queried using Gtk::Accessible::get_platform_state(). More...
enum class | Gtk::Application::InhibitFlags { Gtk::Application::LOGOUT = (1 << 0) , Gtk::Application::SWITCH = (1 << 1) , Gtk::Application::SUSPEND = (1 << 2) , Gtk::Application::IDLE = (1 << 3) }
| Types of user actions that may be blocked by `Gtk::Application`. More...
enum class | Gtk::Constraint::Attribute { Gtk::Constraint::NONE , Gtk::Constraint::LEFT , Gtk::Constraint::RIGHT , Gtk::Constraint::TOP , Gtk::Constraint::BOTTOM , Gtk::Constraint::START , Gtk::Constraint::END , Gtk::Constraint::WIDTH , Gtk::Constraint::HEIGHT , Gtk::Constraint::CENTER_X , Gtk::Constraint::CENTER_Y , Gtk::Constraint::BASELINE }
| The widget attributes that can be used when creating a Gtk::Constraint. More...
enum class | Gtk::Constraint::Relation { Gtk::Constraint::LE = -1 , Gtk::Constraint::EQ , Gtk::Constraint::GE }
| The relation between two terms of a constraint. More...
enum | Gtk::Constraint::Strength_Wrapper::Strength { Gtk::Constraint::Strength_Wrapper::REQUIRED = 1001001000 , Gtk::Constraint::Strength_Wrapper::STRONG = 1000000000 , Gtk::Constraint::Strength_Wrapper::MEDIUM = 1000 , Gtk::Constraint::Strength_Wrapper::WEAK = 1 }
| The strength of a constraint, expressed as a symbolic constant. More...
enum | Gtk::ResponseType_Wrapper::ResponseType { Gtk::ResponseType_Wrapper::NONE = -1 , Gtk::ResponseType_Wrapper::REJECT = -2 , Gtk::ResponseType_Wrapper::ACCEPT = -3 , Gtk::ResponseType_Wrapper::DELETE_EVENT = -4 , Gtk::ResponseType_Wrapper::OK = -5 , Gtk::ResponseType_Wrapper::CANCEL = -6 , Gtk::ResponseType_Wrapper::CLOSE = -7 , Gtk::ResponseType_Wrapper::YES = -8 , Gtk::ResponseType_Wrapper::NO = -9 , Gtk::ResponseType_Wrapper::APPLY = -10 , Gtk::ResponseType_Wrapper::HELP = -11 }
| Predefined values for use as response ids in Gtk::Dialog::add_button(). More...
enum class | Gtk::Entry::IconPosition { Gtk::Entry::PRIMARY , Gtk::Entry::SECONDARY }
| Specifies the side of the entry at which an icon is placed. More...
enum class | Gtk::Align { Gtk::FILL , Gtk::START , Gtk::END , Gtk::CENTER , Gtk::BASELINE }
| Controls how a widget deals with extra space in a single dimension. More...
enum class | Gtk::ArrowType { Gtk::UP , Gtk::DOWN , Gtk::LEFT , Gtk::RIGHT , Gtk::NONE }
| Used to indicate the direction in which an arrow should point. More...
enum class | Gtk::DeleteType { Gtk::CHARS , Gtk::WORD_ENDS , Gtk::WORDS , Gtk::DISPLAY_LINES , Gtk::DISPLAY_LINE_ENDS , Gtk::PARAGRAPH_ENDS , Gtk::PARAGRAPHS , Gtk::WHITESPACE }
| Passed to various keybinding signals for deleting text. More...
enum class | Gtk::DirectionType { Gtk::TAB_FORWARD , Gtk::TAB_BACKWARD , Gtk::UP , Gtk::DOWN , Gtk::LEFT , Gtk::RIGHT }
| Focus movement types. More...
enum class | Gtk::IconSize { Gtk::INHERIT , Gtk::NORMAL , Gtk::LARGE }
| Built-in icon sizes. More...
enum class | Gtk::TextDirection { Gtk::NONE , Gtk::LTR , Gtk::RTL }
| Reading directions for text. More...
enum class | Gtk::Justification { Gtk::LEFT , Gtk::RIGHT , Gtk::CENTER , Gtk::FILL }
| Used for justifying the text inside a Gtk::Label widget. More...
enum class | Gtk::MessageType { Gtk::INFO , Gtk::WARNING , Gtk::QUESTION , Gtk::ERROR , Gtk::OTHER }
| The type of message being displayed in a Gtk::MessageDialog. More...
enum class | Gtk::MovementStep { Gtk::LOGICAL_POSITIONS , Gtk::VISUAL_POSITIONS , Gtk::WORDS , Gtk::DISPLAY_LINES , Gtk::DISPLAY_LINE_ENDS , Gtk::PARAGRAPHS , Gtk::PARAGRAPH_ENDS , Gtk::PAGES , Gtk::BUFFER_ENDS , Gtk::HORIZONTAL_PAGES }
| Passed as argument to various keybinding signals for moving the cursor position. More...
enum class | Gtk::Orientation { Gtk::HORIZONTAL , Gtk::VERTICAL }
| Represents the orientation of widgets and other objects. More...
enum class | Gtk::Overflow { Gtk::VISIBLE , Gtk::HIDDEN }
| Defines how content overflowing a given area should be handled. More...
enum class | Gtk::CornerType { Gtk::TOP_LEFT , Gtk::BOTTOM_LEFT , Gtk::TOP_RIGHT , Gtk::BOTTOM_RIGHT }
| Specifies which corner a child widget should be placed in when packed into a `GtkScrolledWindow.` More...
enum class | Gtk::PackType { Gtk::START , Gtk::END }
| Represents the packing location of a children in its parent. More...
enum class | Gtk::PickFlags { Gtk::DEFAULT = 0x0 , Gtk::INSENSITIVE = 1 << 0 , Gtk::NON_TARGETABLE = 1 << 1 }
| Flags that influence the behavior of Gtk::Widget::pick(). More...
enum class | Gtk::PolicyType { Gtk::ALWAYS , Gtk::AUTOMATIC , Gtk::NEVER , Gtk::EXTERNAL }
| Determines how the size should be computed to achieve the one of the visibility mode for the scrollbars. More...
enum class | Gtk::PositionType { Gtk::LEFT , Gtk::RIGHT , Gtk::TOP , Gtk::BOTTOM }
| Describes which edge of a widget a certain feature is positioned at. More...
enum class | Gtk::RevealerTransitionType { Gtk::NONE , Gtk::CROSSFADE , Gtk::SLIDE_RIGHT , Gtk::SLIDE_LEFT , Gtk::SLIDE_UP , Gtk::SLIDE_DOWN , Gtk::SWING_RIGHT , Gtk::SWING_LEFT , Gtk::SWING_UP , Gtk::SWING_DOWN }
| These enumeration values describe the possible transitions when the child of a `Gtk::Revealer` widget is shown or hidden. More...
enum class | Gtk::ScrollType { Gtk::NONE , Gtk::JUMP , Gtk::STEP_BACKWARD , Gtk::STEP_FORWARD , Gtk::PAGE_BACKWARD , Gtk::PAGE_FORWARD , Gtk::STEP_UP , Gtk::STEP_DOWN , Gtk::PAGE_UP , Gtk::PAGE_DOWN , Gtk::STEP_LEFT , Gtk::STEP_RIGHT , Gtk::PAGE_LEFT , Gtk::PAGE_RIGHT , Gtk::START , Gtk::END }
| Scrolling types. More...
enum class | Gtk::SelectionMode { Gtk::NONE , Gtk::SINGLE , Gtk::BROWSE , Gtk::MULTIPLE }
| Used to control what selections users are allowed to make. More...
enum class | Gtk::StackTransitionType { Gtk::NONE , Gtk::CROSSFADE , Gtk::SLIDE_RIGHT , Gtk::SLIDE_LEFT , Gtk::SLIDE_UP , Gtk::SLIDE_DOWN , Gtk::SLIDE_LEFT_RIGHT , Gtk::SLIDE_UP_DOWN , Gtk::OVER_UP , Gtk::OVER_DOWN , Gtk::OVER_LEFT , Gtk::OVER_RIGHT , Gtk::UNDER_UP , Gtk::UNDER_DOWN , Gtk::UNDER_LEFT , Gtk::UNDER_RIGHT , Gtk::OVER_UP_DOWN , Gtk::OVER_DOWN_UP , Gtk::OVER_LEFT_RIGHT , Gtk::OVER_RIGHT_LEFT , Gtk::ROTATE_LEFT , Gtk::ROTATE_RIGHT , Gtk::ROTATE_LEFT_RIGHT }
| Possible transitions between pages in a `Gtk::Stack` widget. More...
enum class | Gtk::WrapMode { Gtk::NONE , Gtk::CHAR , Gtk::WORD , Gtk::WORD_CHAR }
| Describes a type of line wrapping. More...
enum class | Gtk::NaturalWrapMode { Gtk::INHERIT , Gtk::NONE , Gtk::WORD }
| Options for selecting a different wrap mode for natural size requests. More...
enum class | Gtk::SortType { Gtk::ASCENDING , Gtk::DESCENDING }
| Determines the direction of a sort. More...
enum class | Gtk::Ordering { Gtk::SMALLER = -1 , Gtk::EQUAL , Gtk::LARGER }
| Describes the way two values can be compared. More...
enum class | Gtk::PageOrientation { Gtk::PORTRAIT , Gtk::LANDSCAPE , Gtk::REVERSE_PORTRAIT , Gtk::REVERSE_LANDSCAPE }
| See also Gtk::PrintSettings::set_orientation(). More...
enum class | Gtk::SensitivityType { Gtk::AUTO , Gtk::ON , Gtk::OFF }
| Determines how GTK handles the sensitivity of various controls, such as combo box buttons. More...
enum class | Gtk::SizeRequestMode { Gtk::HEIGHT_FOR_WIDTH , Gtk::WIDTH_FOR_HEIGHT , Gtk::CONSTANT_SIZE }
| Specifies a preference for height-for-width or width-for-height geometry management. More...
enum class | Gtk::StateFlags { Gtk::NORMAL = 0x0 , Gtk::ACTIVE = 1 << 0 , Gtk::PRELIGHT = 1 << 1 , Gtk::SELECTED = 1 << 2 , Gtk::INSENSITIVE = 1 << 3 , Gtk::INCONSISTENT = 1 << 4 , Gtk::FOCUSED = 1 << 5 , Gtk::BACKDROP = 1 << 6 , Gtk::DIR_LTR = 1 << 7 , Gtk::DIR_RTL = 1 << 8 , Gtk::LINK = 1 << 9 , Gtk::VISITED = 1 << 10 , Gtk::CHECKED = 1 << 11 , Gtk::DROP_ACTIVE = 1 << 12 , Gtk::FOCUS_VISIBLE = 1 << 13 , Gtk::FOCUS_WITHIN = 1 << 14 }
| Describes a widget state. More...
enum class | Gtk::InputPurpose { Gtk::FREE_FORM , Gtk::ALPHA , Gtk::DIGITS , Gtk::NUMBER , Gtk::PHONE , Gtk::URL , Gtk::EMAIL , Gtk::NAME , Gtk::PASSWORD , Gtk::PIN , Gtk::TERMINAL }
| Describes primary purpose of the input widget. More...
enum class | Gtk::InputHints { Gtk::NONE = 0x0 , Gtk::SPELLCHECK = 1 << 0 , Gtk::NO_SPELLCHECK = 1 << 1 , Gtk::WORD_COMPLETION = 1 << 2 , Gtk::LOWERCASE = 1 << 3 , Gtk::UPPERCASE_CHARS = 1 << 4 , Gtk::UPPERCASE_WORDS = 1 << 5 , Gtk::UPPERCASE_SENTENCES = 1 << 6 , Gtk::INHIBIT_OSK = 1 << 7 , Gtk::VERTICAL_WRITING = 1 << 8 , Gtk::EMOJI = 1 << 9 , Gtk::NO_EMOJI = 1 << 10 , Gtk::PRIVATE = 1 << 11 }
| Describes hints that might be taken into account by input methods or applications. More...
enum class | Gtk::BaselinePosition { Gtk::TOP , Gtk::CENTER , Gtk::BOTTOM }
| Baseline position in a row of widgets. More...
enum class | Gtk::ShortcutScope { Gtk::LOCAL , Gtk::MANAGED , Gtk::GLOBAL }
| Describes where Gtk::Shortcuts added to a Gtk::ShortcutController get handled. More...
enum class | Gtk::ContentFit { Gtk::FILL , Gtk::CONTAIN , Gtk::COVER , Gtk::SCALE_DOWN }
| Controls how a content should be made to fit inside an allocation. More...
enum class | Gtk::PropagationPhase { Gtk::NONE , Gtk::CAPTURE , Gtk::BUBBLE , Gtk::TARGET }
| Describes the stage at which events are fed into a Gtk::EventController. More...
enum class | Gtk::PropagationLimit { Gtk::NONE , Gtk::SAME_NATIVE }
| Describes limits of a Gtk::EventController for handling events targeting other widgets. More...
enum class | Gtk::EventControllerScroll::Flags { Gtk::EventControllerScroll::NONE = 0x0 , Gtk::EventControllerScroll::VERTICAL = 1 << 0 , Gtk::EventControllerScroll::HORIZONTAL = 1 << 1 , Gtk::EventControllerScroll::DISCRETE = 1 << 2 , Gtk::EventControllerScroll::KINETIC = 1 << 3 , Gtk::EventControllerScroll::BOTH_AXES = 0x3 }
| Describes the behavior of a `Gtk::EventControllerScroll`. More...
enum class | Gtk::Filter::Match { Gtk::Filter::SOME , Gtk::Filter::NONE , Gtk::Filter::ALL }
| Describes the known strictness of a filter. More...
enum class | Gtk::Filter::Change { Gtk::Filter::DIFFERENT , Gtk::Filter::LESS_STRICT , Gtk::Filter::MORE_STRICT }
| Describes changes in a filter in more detail and allows objects using the filter to optimize refiltering items. More...
enum class | Gtk::FontLevel { Gtk::FAMILY , Gtk::FACE , Gtk::FONT , Gtk::FEATURES }
| The level of granularity for the font selection. More...
enum class | Gtk::EventSequenceState { Gtk::NONE , Gtk::CLAIMED , Gtk::DENIED }
| Describes the state of a Gdk::EventSequence in a Gtk::Gesture. More...
enum class | Gtk::PanDirection { Gtk::LEFT , Gtk::RIGHT , Gtk::UP , Gtk::DOWN }
| Describes the panning direction of a Gtk::GesturePan. More...
enum class | Gtk::IconLookupFlags { Gtk::FORCE_REGULAR = 1 << 0 , Gtk::FORCE_SYMBOLIC = 1 << 1 , Gtk::PRELOAD = 1 << 2 }
| Used to specify options for Gtk::IconTheme::lookup_icon(). More...
enum class | Gtk::Image::Type { Gtk::Image::EMPTY , Gtk::Image::ICON_NAME , Gtk::Image::GICON , Gtk::Image::PAINTABLE }
| Describes the image data representation used by a Gtk::Image. More...
enum class | Gtk::Inscription::Overflow { Gtk::Inscription::CLIP , Gtk::Inscription::ELLIPSIZE_START , Gtk::Inscription::ELLIPSIZE_MIDDLE , Gtk::Inscription::ELLIPSIZE_END }
| The different methods to handle text in Gtk::Inscription when it doesn't fit the available space. More...
enum class | Gtk::LevelBar::Mode { Gtk::LevelBar::CONTINUOUS , Gtk::LevelBar::DISCRETE }
| Describes how Gtk::LevelBar contents should be rendered. More...
enum class | Gtk::PadActionType { Gtk::BUTTON , Gtk::RING , Gtk::STRIP }
| The type of a pad action. More...
enum class | Gtk::Unit { Gtk::NONE , Gtk::POINTS , Gtk::INCH , Gtk::MM }
| See also Gtk::PrintSettings::set_paper_width(). More...
enum class | Gtk::PopoverMenu::Flags { Gtk::PopoverMenu::NESTED = 1 << 0 }
| Flags that affect how popover menus are created from a menu model. More...
enum class | Gtk::PrintStatus { Gtk::INITIAL , Gtk::PREPARING , Gtk::GENERATING_DATA , Gtk::SENDING_DATA , Gtk::PENDING , Gtk::PENDING_ISSUE , Gtk::PRINTING , Gtk::FINISHED , Gtk::FINISHED_ABORTED }
| The status gives a rough indication of the completion of a running print operation. More...
enum class | Gtk::PrintOperation::Result { Gtk::PrintOperation::ERROR , Gtk::PrintOperation::APPLY , Gtk::PrintOperation::CANCEL , Gtk::PrintOperation::IN_PROGRESS }
| The result of a print operation. More...
enum class | Gtk::PrintOperation::Action { Gtk::PrintOperation::PRINT_DIALOG , Gtk::PrintOperation::PRINT , Gtk::PrintOperation::PREVIEW , Gtk::PrintOperation::EXPORT }
| Determines what action the print operation should perform. More...
enum class | Gtk::PrintDuplex { Gtk::SIMPLEX , Gtk::HORIZONTAL , Gtk::VERTICAL }
| See also Gtk::PrintSettings::set_duplex(). More...
enum class | Gtk::PrintQuality { Gtk::LOW , Gtk::NORMAL , Gtk::HIGH , Gtk::DRAFT }
| See also Gtk::PrintSettings::set_quality(). More...
enum class | Gtk::PrintPages { Gtk::ALL , Gtk::CURRENT , Gtk::RANGES , Gtk::SELECTION }
| See also Gtk::PrintJob::set_pages() More...
enum class | Gtk::PageSet { Gtk::ALL , Gtk::EVEN , Gtk::ODD }
| See also Gtk::PrintJob::set_page_set(). More...
enum class | Gtk::NumberUpLayout { Gtk::LEFT_TO_RIGHT_TOP_TO_BOTTOM , Gtk::LEFT_TO_RIGHT_BOTTOM_TO_TOP , Gtk::RIGHT_TO_LEFT_TOP_TO_BOTTOM , Gtk::RIGHT_TO_LEFT_BOTTOM_TO_TOP , Gtk::TOP_TO_BOTTOM_LEFT_TO_RIGHT , Gtk::TOP_TO_BOTTOM_RIGHT_TO_LEFT , Gtk::BOTTOM_TO_TOP_LEFT_TO_RIGHT , Gtk::BOTTOM_TO_TOP_RIGHT_TO_LEFT }
| Used to determine the layout of pages on a sheet when printing multiple pages per sheet. More...
enum class | Gtk::Scrollable::Policy { Gtk::Scrollable::MINIMUM , Gtk::Scrollable::NATURAL }
| Defines the policy to be used in a scrollable widget when updating the scrolled window adjustments in a given orientation. More...
enum class | Gtk::ShortcutAction::Flags { Gtk::ShortcutAction::EXCLUSIVE = 1 << 0 }
| List of flags that can be passed to action activation. More...
enum class | Gtk::ShortcutType { Gtk::ACCELERATOR , Gtk::GESTURE_PINCH , Gtk::GESTURE_STRETCH , Gtk::GESTURE_ROTATE_CLOCKWISE , Gtk::GESTURE_ROTATE_COUNTERCLOCKWISE , Gtk::GESTURE_TWO_FINGER_SWIPE_LEFT , Gtk::GESTURE_TWO_FINGER_SWIPE_RIGHT , Gtk::GESTURE , Gtk::GESTURE_SWIPE_LEFT , Gtk::GESTURE_SWIPE_RIGHT }
| GtkShortcutType specifies the kind of shortcut that is being described. More...
enum class | Gtk::SizeGroup::Mode { Gtk::SizeGroup::NONE , Gtk::SizeGroup::HORIZONTAL , Gtk::SizeGroup::VERTICAL , Gtk::SizeGroup::BOTH }
| The mode of the size group determines the directions in which the size group affects the requested sizes of its component widgets. More...
enum class | Gtk::Sorter::Order { Gtk::Sorter::PARTIAL , Gtk::Sorter::NONE , Gtk::Sorter::TOTAL }
| Describes the type of order that a `Gtk::Sorter` may produce. More...
enum class | Gtk::Sorter::Change { Gtk::Sorter::DIFFERENT , Gtk::Sorter::INVERTED , Gtk::Sorter::LESS_STRICT , Gtk::Sorter::MORE_STRICT }
| Describes changes in a sorter in more detail and allows users to optimize resorting. More...
enum class | Gtk::SpinType { Gtk::STEP_FORWARD , Gtk::STEP_BACKWARD , Gtk::PAGE_FORWARD , Gtk::PAGE_BACKWARD , Gtk::HOME , Gtk::END , Gtk::USER_DEFINED }
| The values of the GtkSpinType enumeration are used to specify the change to make in Gtk::SpinButton::spin(). More...
enum class | Gtk::SpinButton::UpdatePolicy { Gtk::SpinButton::ALWAYS , Gtk::SpinButton::IF_VALID }
| Determines whether the spin button displays values outside the adjustment bounds. More...
enum class | Gtk::StringFilter::MatchMode { Gtk::StringFilter::EXACT , Gtk::StringFilter::SUBSTRING , Gtk::StringFilter::PREFIX }
| Specifies how search strings are matched inside text. More...
enum class | Gtk::Collation { Gtk::NONE , Gtk::UNICODE , Gtk::FILENAME }
| Describes how a Gtk::StringSorter turns strings into sort keys to compare them. More...
enum class | Gtk::TextSearchFlags { Gtk::VISIBLE_ONLY = 1 << 0 , Gtk::TEXT_ONLY = 1 << 1 , Gtk::CASE_INSENSITIVE = 1 << 2 }
| Flags affecting how a search is done. More...
enum class | Gtk::TextWindowType { Gtk::WIDGET = 1 , Gtk::TEXT , Gtk::LEFT , Gtk::RIGHT , Gtk::TOP , Gtk::BOTTOM }
| Used to reference the parts of `Gtk::TextView`. More...
enum class | Gtk::PrintCapabilities { Gtk::PAGE_SET = 1 << 0 , Gtk::COPIES = 1 << 1 , Gtk::COLLATE = 1 << 2 , Gtk::REVERSE = 1 << 3 , Gtk::SCALE = 1 << 4 , Gtk::GENERATE_PDF = 1 << 5 , Gtk::GENERATE_PS = 1 << 6 , Gtk::PREVIEW = 1 << 7 , Gtk::NUMBER_UP = 1 << 8 , Gtk::NUMBER_UP_LAYOUT = 1 << 9 }
| Specifies which features the print dialog should offer. More...
enum class | Gtk::AssistantPage::Type { Gtk::AssistantPage::CONTENT , Gtk::AssistantPage::INTRO , Gtk::AssistantPage::CONFIRM , Gtk::AssistantPage::SUMMARY , Gtk::AssistantPage::PROGRESS , Gtk::AssistantPage::CUSTOM }
| Determines the page role inside a `Gtk::Assistant`. More...
enum class | Gtk::CellRendererState { Gtk::SELECTED = 1 << 0 , Gtk::PRELIT = 1 << 1 , Gtk::INSENSITIVE = 1 << 2 , Gtk::SORTED = 1 << 3 , Gtk::FOCUSED = 1 << 4 , Gtk::EXPANDABLE = 1 << 5 , Gtk::EXPANDED = 1 << 6 }
| Tells how a cell is to be rendered. More...
enum class | Gtk::CellRendererMode { Gtk::INERT , Gtk::ACTIVATABLE , Gtk::EDITABLE }
| Identifies how the user can interact with a particular cell. More...
enum class | Gtk::CellRendererAccel::Mode { Gtk::CellRendererAccel::GTK , Gtk::CellRendererAccel::OTHER }
| The available modes for Gtk::CellRendererAccel::property_accel_mode(). More...
enum class | Gtk::FileChooser::Action { Gtk::FileChooser::OPEN , Gtk::FileChooser::SAVE , Gtk::FileChooser::SELECT_FOLDER }
| Describes whether a `Gtk::FileChooser` is being used to open existing files or to save to a possibly new file. More...
enum class | Gtk::FontChooser::Level { Gtk::FontChooser::FAMILY = 0x0 , Gtk::FontChooser::STYLE = 1 << 0 , Gtk::FontChooser::SIZE = 1 << 1 , Gtk::FontChooser::VARIATIONS = 1 << 2 , Gtk::FontChooser::FEATURES = 1 << 3 }
| Specifies the granularity of font selection that is desired in a `Gtk::FontChooser`. More...
enum class | Gtk::IconView::DropPosition { Gtk::IconView::NO_DROP , Gtk::IconView::DROP_INTO , Gtk::IconView::DROP_LEFT , Gtk::IconView::DROP_RIGHT , Gtk::IconView::DROP_ABOVE , Gtk::IconView::DROP_BELOW }
| An enum for determining where a dropped item goes. More...
enum class | Gtk::ButtonsType { Gtk::NONE , Gtk::OK , Gtk::CLOSE , Gtk::CANCEL , Gtk::YES_NO , Gtk::OK_CANCEL }
| Prebuilt sets of buttons for `Gtk::Dialog`. More...
enum class | Gtk::StyleContext::PrintFlags { Gtk::StyleContext::NONE = 0x0 , Gtk::StyleContext::RECURSE = 1 << 0 , Gtk::StyleContext::SHOW_STYLE = 1 << 1 , Gtk::StyleContext::SHOW_CHANGE = 1 << 2 }
| Flags that modify the behavior of Gtk::StyleContext::to_string(). More...
enum class | Gtk::TreeModel::Flags { Gtk::TreeModel::ITERS_PERSIST = 1 << 0 , Gtk::TreeModel::LIST_ONLY = 1 << 1 }
| These flags indicate various properties of a `Gtk::TreeModel`. More...
enum class | Gtk::TreeView::DropPosition { Gtk::TreeView::BEFORE , Gtk::TreeView::AFTER , Gtk::TreeView::INTO_OR_BEFORE , Gtk::TreeView::INTO_OR_AFTER }
| An enum for determining where a dropped row goes. More...
enum class | Gtk::TreeView::GridLines { Gtk::TreeView::NONE , Gtk::TreeView::HORIZONTAL , Gtk::TreeView::VERTICAL , Gtk::TreeView::BOTH }
| Used to indicate which grid lines to draw in a tree view. More...
enum class | Gtk::TreeViewColumn::Sizing { Gtk::TreeViewColumn::GROW_ONLY , Gtk::TreeViewColumn::AUTOSIZE , Gtk::TreeViewColumn::FIXED }
| The sizing method the column uses to determine its width. 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)
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)
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)
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)
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)
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)
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)
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)
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)

## Detailed Description

## Typedef Documentation

## ◆ ResponseType

using Gtk::ResponseType = typedef ResponseType_Wrapper::ResponseType

ResponseType enumerators are scoped by the wrapper class and can be implicitly converted to int.

## ◆ Strength

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

anonymous enum

Constant to return from a signal handler for the input signal in case of conversion failure.

Enumerator
INPUT_ERROR |

## ◆ Action [1/2]

enum Gtk::FileChooser::Action
| strong

Describes whether a `Gtk::FileChooser` is being used to open existing files or to save to a possibly new file.

Enumerator
OPEN | Indicates open mode. The file chooser will only let the user pick an existing file.
SAVE | Indicates save mode. The file chooser will let the user pick an existing file, or type in a new filename.
SELECT_FOLDER | Indicates an Open mode for selecting folders. The file chooser will let the user pick an existing folder.

## ◆ Action [2/2]

enum Gtk::PrintOperation::Action
| strong

Determines what action the print operation should perform.

A parameter of this typs is passed to Gtk::PrintOperation::run().

Enumerator
PRINT_DIALOG | Show the print dialog.
PRINT | Start to print without showing the print dialog, based on the current print settings.
PREVIEW | Show the print preview.
EXPORT | Export to a file. This requires the export-filename property to be set.

## ◆ Align

enum Gtk::Align
| strong

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 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. Make the content fill the entire allocation, without taking its aspect ratio in consideration. The text is placed is distributed across the label. The resulting content will appear as stretched if its aspect ratio is different from the allocation aspect ratio.
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.

## ◆ ArrowType

enum Gtk::ArrowType
| strong

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

Enumerator
UP | Represents an upward pointing arrow. Panned upwards. Move up.
DOWN | Represents a downward pointing arrow. Panned downwards. Move down.
LEFT | Represents a left pointing arrow. Left side border window. Panned towards the left. The feature is at the left edge. The text is placed at the left edge of the label. Move left.
RIGHT | Represents a right pointing arrow. Right side border window. Panned towards the right. The feature is at the right edge. The text is placed at the right edge of the label. Move right.
NONE | No arrow. No buttons at all. Don't do any collation. No units. The sequence is handled, but not grabbed. Events are handled regardless of what their target is. Events are not delivered. No special behaviour suggested. Try not to wrap the text. Do not wrap lines; just make the text area wider. No selection is possible. No scrolling. No transition. No direction. This mode is the closest to GTK3's behavior but can lead to a wide label leaving lots of empty space below the text.

## ◆ Attribute

enum Gtk::Constraint::Attribute
| 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.

## ◆ BaselinePosition

enum Gtk::BaselinePosition
| strong

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 `Gtk::BaselinePosition` to select where to put the baseline inside the extra available space.

Enumerator
TOP |
CENTER |
BOTTOM |

## ◆ ButtonsType

enum Gtk::ButtonsType
| strong

Prebuilt sets of buttons for `Gtk::Dialog`.

If none of these choices are appropriate, simply use Gtk::ButtonsType::NONE and 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.

## ◆ CellRendererMode

enum Gtk::CellRendererMode
| strong

Identifies how the user can interact with a particular cell.

Enumerator
INERT | The cell is just for display and cannot be interacted with. Note that this doesn’t mean that eg. the row being drawn can’t be selected – just that a particular element of it cannot be individually modified.
ACTIVATABLE | The cell can be clicked.
EDITABLE | The cell can be edited or otherwise modified.

## ◆ CellRendererState

enum Gtk::CellRendererState
| 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 |
PRELIT | The mouse is hovering over the cell.
INSENSITIVE |
SORTED | The cell is in a sorted row.
FOCUSED |
EXPANDABLE | The cell is in a row that can be expanded.
EXPANDED | The cell is in a row that is expanded.

## ◆ Change [1/2]

enum Gtk::Filter::Change
| 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.

Enumerator
DIFFERENT | The filter change cannot be described with any of the other enumeration values.
LESS_STRICT | The filter is less strict than it was before: All items that it used to return `true` for still return `true`, others now may, too.
MORE_STRICT | The filter is more strict than it was before: All items that it used to return `false` for still return `false`, others now may, too.

## ◆ Change [2/2]

enum Gtk::Sorter::Change
| 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.

## ◆ Collation

enum Gtk::Collation
| strong

Describes how a Gtk::StringSorter turns strings into sort keys to compare them.

Note that the result of sorting will in general depend on the current locale unless the mode is GTK_COLLATION_NONE.

Since gtkmm 4.10:

Enumerator
NONE |
UNICODE | Use glib_utf8_collate_key().
FILENAME | Use glib_utf8_collate_key_for_filename().

## ◆ ContentFit

enum Gtk::ContentFit
| strong

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

Since gtkmm 4.8:

Enumerator
FILL |
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.
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.
SCALE_DOWN | The content is scaled down to fit the allocation, if needed, otherwise its original size is used.

## ◆ CornerType

enum Gtk::CornerType
| strong

Specifies which corner a child widget should be placed in when packed into a `GtkScrolledWindow.`

This is effectively the opposite of where the scroll bars are placed.

Enumerator
TOP_LEFT | Place the scrollbars on the right and bottom of the widget (default behaviour).
BOTTOM_LEFT | Place the scrollbars on the top and right of the widget.
TOP_RIGHT | Place the scrollbars on the left and bottom of the widget.
BOTTOM_RIGHT | Place the scrollbars on the top and left of the widget.

## ◆ DeleteType

enum Gtk::DeleteType
| strong

Passed to various keybinding signals for deleting text.

Enumerator
CHARS | Delete characters.
WORD_ENDS | Delete only the portion of the word to the left/right of cursor if we’re in the middle of a word.
WORDS | Delete words. Move forward or back by words.
DISPLAY_LINES | Delete display-lines. Move up or down lines (wrapped 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.
DISPLAY_LINE_ENDS | Delete only the portion of the display-line to the left/right of cursor. Move to either end of a line.
PARAGRAPH_ENDS | Delete to the end of the paragraph. Move to either end of a paragraph. Like C-k in Emacs (or its reverse).
PARAGRAPHS | Delete entire line. Move up or down paragraphs (newline-ended lines). Like C-k in pico.
WHITESPACE | Delete only whitespace. Like M-\ in Emacs.

## ◆ DirectionType

enum Gtk::DirectionType
| strong

Focus movement types.

Enumerator
TAB_FORWARD | Move forward.
TAB_BACKWARD | Move backward.
UP |
DOWN |
LEFT |
RIGHT |

## ◆ DropPosition [1/2]

enum Gtk::IconView::DropPosition
| strong

An enum for determining where a dropped item goes.

Enumerator
NO_DROP | No drop possible.
DROP_INTO | Dropped item replaces the item.
DROP_LEFT | Dropped item is inserted to the left.
DROP_RIGHT | Dropped item is inserted to the right.
DROP_ABOVE | Dropped item is inserted above.
DROP_BELOW | Dropped item is inserted below.

## ◆ DropPosition [2/2]

enum Gtk::TreeView::DropPosition
| strong

An enum for determining where a dropped row goes.

Enumerator
BEFORE | Dropped row is inserted before.
AFTER | Dropped row is inserted after.
INTO_OR_BEFORE | Dropped row becomes a child or is inserted before.
INTO_OR_AFTER | Dropped row becomes a child or is inserted after.

## ◆ EventSequenceState

enum Gtk::EventSequenceState
| 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.

## ◆ Flags [1/4]

enum Gtk::EventControllerScroll::Flags
| 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 signal_decelerate() after continuous scroll finishes.
BOTH_AXES | Emit scroll on both axes.

## ◆ Flags [2/4]

enum Gtk::PopoverMenu::Flags
| 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.

## ◆ Flags [3/4]

enum Gtk::ShortcutAction::Flags
| 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.

## ◆ Flags [4/4]

enum Gtk::TreeModel::Flags
| 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.

## ◆ FontLevel

enum Gtk::FontLevel
| strong

The level of granularity for the font selection.

Depending on this value, the `Pango::FontDescription` that is returned by Gtk::FontDialogButton::get_font_desc() will have more or less fields set.

Since gtkmm 4.10:

Enumerator
FAMILY | Select a font family.
FACE | Select a font face (i.e. a family and a style).
FONT | Select a font (i.e. a face with a size, and possibly font variations).
FEATURES | Select a font and font features.

## ◆ GridLines

enum Gtk::TreeView::GridLines
| strong

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

Enumerator
NONE | No grid lines.
HORIZONTAL | Horizontal grid lines.
VERTICAL | Vertical grid lines.
BOTH | Horizontal and vertical grid lines.

## ◆ IconLookupFlags

enum Gtk::IconLookupFlags
| 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)`

Enumerator
FORCE_REGULAR | Try to always load regular icons, even when symbolic icon names are given.
FORCE_SYMBOLIC | Try to always load symbolic icons, even when regular icon names are given.
PRELOAD | Starts loading the texture in the background so it is ready when later needed.

## ◆ IconPosition

enum Gtk::Entry::IconPosition
| strong

Specifies the side of the entry at which an icon is placed.

Enumerator
PRIMARY | At the beginning of the entry (depending on the text direction).
SECONDARY | At the end of the entry (depending on the text direction).

## ◆ IconSize

enum Gtk::IconSize
| 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 `Gtk::IconSize` 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. Inherit the minimum size request. In particular, this should be used with Pango::WrapMode::CHAR.
NORMAL | Size similar to text size. Normal quality. State during normal operation.
LARGE | Large size, for example in an icon view.

## ◆ InhibitFlags

enum Gtk::Application::InhibitFlags
| strong

Types of user actions that may be blocked by `Gtk::Application`.

See 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)`

Enumerator
LOGOUT | Inhibit ending the user session by logging out or by shutting down the computer.
SWITCH | Inhibit user switching.
SUSPEND | Inhibit suspending the session or computer.
IDLE | Inhibit the session being marked as idle (and possibly locked).

## ◆ InputHints

enum Gtk::InputHints
| 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)`

Enumerator
NONE |
SPELLCHECK | Suggest checking for typos.
NO_SPELLCHECK | Suggest not checking for typos.
WORD_COMPLETION | Suggest word completion.
LOWERCASE | Suggest to convert all text to lowercase.
UPPERCASE_CHARS | Suggest to capitalize all text.
UPPERCASE_WORDS | Suggest to capitalize the first character of each word.
UPPERCASE_SENTENCES | Suggest to capitalize the first word of each sentence.
INHIBIT_OSK | Suggest to not show an onscreen keyboard (e.g for a calculator that already has all the keys).
VERTICAL_WRITING | The text is vertical.
EMOJI | Suggest offering Emoji support.
NO_EMOJI | Suggest not offering Emoji support.
PRIVATE | Request that the input method should not update personalized data (like typing history).

## ◆ InputPurpose

enum Gtk::InputPurpose
| 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.
EMAIL | 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.

## ◆ Justification

enum Gtk::Justification
| strong

Used for justifying the text inside a Gtk::Label widget.

Enumerator
LEFT |
RIGHT |
CENTER |
FILL |

## ◆ Level

enum Gtk::FontChooser::Level
| strong

Specifies the granularity of font selection that is desired in a `Gtk::FontChooser`.

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)`

Enumerator
FAMILY | Allow selecting a font family.
STYLE | Allow selecting a specific font face.
SIZE | Allow selecting a specific font size.
VARIATIONS | Allow changing OpenType font variation axes.
FEATURES | Allow selecting specific OpenType font features.

## ◆ License

enum Gtk::License
| strong

The type of license for an application.

This enumeration can be expanded at later date.

Enumerator
UNKNOWN | No license specified.
CUSTOM | A license text is going to be specified by the developer.
GPL_2_0 | The GNU General Public License, version 2.0 or later.
GPL_3_0 | The GNU General Public License, version 3.0 or later.
LGPL_2_1 | The GNU Lesser General Public License, version 2.1 or later.
LGPL_3_0 | The GNU Lesser General Public License, version 3.0 or later.
BSD | The BSD standard license.
MIT_X11 | The MIT/X11 standard license.
ARTISTIC | The Artistic License, version 2.0.
GPL_2_0_ONLY | The GNU General Public License, version 2.0 only.
GPL_3_0_ONLY | The GNU General Public License, version 3.0 only.
LGPL_2_1_ONLY | The GNU Lesser General Public License, version 2.1 only.
LGPL_3_0_ONLY | The GNU Lesser General Public License, version 3.0 only.
AGPL_3_0 | The GNU Affero General Public License, version 3.0 or later.
AGPL_3_0_ONLY | The GNU Affero General Public License, version 3.0 only.
BSD_3 | The 3-clause BSD licence.
APACHE_2_0 | The Apache License, version 2.0.
MPL_2_0 | The Mozilla Public License, version 2.0.

## ◆ Match

enum Gtk::Filter::Match
| 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 `true` or `false`.
NONE | The filter does not match any item, Gtk::Filter::match() will always return `false`.
ALL | The filter matches all items, Gtk::Filter::match() will alays return `true`.

## ◆ MatchMode

enum Gtk::StringFilter::MatchMode
| strong

Specifies how search strings are matched inside text.

Enumerator
EXACT | The search string and text must match exactly.
SUBSTRING | The search string must be contained as a substring inside the text.
PREFIX | The text must begin with the search string.

## ◆ MessageType

enum Gtk::MessageType
| strong

The type of message being displayed in a Gtk::MessageDialog.

Enumerator
INFO | Informational message.
WARNING | Non-fatal warning message.
QUESTION | Question requiring a choice.
ERROR | Fatal error message.
OTHER | None of the above.

## ◆ Mode [1/3]

enum Gtk::CellRendererAccel::Mode
| strong

The available modes for Gtk::CellRendererAccel::property_accel_mode().

Enumerator
GTK | GTK accelerators mode.
OTHER | Other accelerator mode.

## ◆ Mode [2/3]

enum Gtk::LevelBar::Mode
| 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.

## ◆ Mode [3/3]

enum Gtk::SizeGroup::Mode
| 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.

## ◆ MovementStep

enum Gtk::MovementStep
| strong

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

Enumerator
LOGICAL_POSITIONS | Move forward or back by graphemes.
VISUAL_POSITIONS | Move left or right by graphemes.
WORDS |
DISPLAY_LINES |
DISPLAY_LINE_ENDS |
PARAGRAPHS |
PARAGRAPH_ENDS |
PAGES | Move by pages.
BUFFER_ENDS | Move to ends of the buffer.
HORIZONTAL_PAGES | Move horizontally by pages.

## ◆ NaturalWrapMode

enum Gtk::NaturalWrapMode
| strong

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

See for example the Gtk::Label::property_natural_wrap_mode() property.

Since gtkmm 4.6:

Enumerator
INHERIT |
NONE |
WORD |

## ◆ NumberUpLayout

enum Gtk::NumberUpLayout
| strong

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

Enumerator
LEFT_TO_RIGHT_TOP_TO_BOTTOM | .
LEFT_TO_RIGHT_BOTTOM_TO_TOP | .
RIGHT_TO_LEFT_TOP_TO_BOTTOM | .
RIGHT_TO_LEFT_BOTTOM_TO_TOP | .
TOP_TO_BOTTOM_LEFT_TO_RIGHT | .
TOP_TO_BOTTOM_RIGHT_TO_LEFT | .
BOTTOM_TO_TOP_LEFT_TO_RIGHT | .
BOTTOM_TO_TOP_RIGHT_TO_LEFT | .

## ◆ Order

enum Gtk::Sorter::Order
| strong

Describes the type of order that a `Gtk::Sorter` may produce.

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.

## ◆ Ordering

enum Gtk::Ordering
| strong

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 `CompareFunc` is allowed to return any integer values. For converting such a value to a `Gtk::Ordering` value, 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.

## ◆ Orientation

enum Gtk::Orientation
| strong

Represents the orientation of widgets and other objects.

Typical examples are Gtk::Box or Gtk::GesturePan.

Enumerator
HORIZONTAL | The element is in horizontal orientation. Horizontal duplex.
VERTICAL | The element is in vertical orientation. Vertical duplex.

## ◆ Overflow [1/2]

enum Gtk::Overflow
| strong

Defines how content overflowing a given area should be handled.

This is used in Gtk::Widget::set_overflow(). The Gtk::Widget::property_overflow() property is modeled after the CSS overflow property, but implements it only partially.

Enumerator
VISIBLE | No change is applied. Content is drawn at the specified position.
HIDDEN | Content is clipped to the bounds of the area. Content outside the area is not drawn and cannot be interacted with.

## ◆ Overflow [2/2]

enum Gtk::Inscription::Overflow
| strong

The different methods to handle text in Gtk::Inscription when it doesn't fit the available space.

Since gtkmm 4.8:

Enumerator
CLIP | Clip the remaining text.
ELLIPSIZE_START | Omit characters at the start of the text.
ELLIPSIZE_MIDDLE | Omit characters at the middle of the text.
ELLIPSIZE_END | Omit characters at the end of the text.

## ◆ PackType

enum Gtk::PackType
| strong

Represents the packing location of a children in its parent.

See Gtk::WindowControls for example.

Enumerator
START |
END |

## ◆ PadActionType

enum Gtk::PadActionType
| strong

The type of a pad action.

Enumerator
BUTTON | Action is triggered by a pad button.
RING | Action is triggered by a pad ring.
STRIP | Action is triggered by a pad strip.

## ◆ PageOrientation

enum Gtk::PageOrientation
| strong

See also Gtk::PrintSettings::set_orientation().

Enumerator
PORTRAIT | Portrait mode.
LANDSCAPE | Landscape mode.
REVERSE_PORTRAIT | Reverse portrait mode.
REVERSE_LANDSCAPE | Reverse landscape mode.

## ◆ PageSet

enum Gtk::PageSet
| strong

See also Gtk::PrintJob::set_page_set().

Enumerator
ALL |
EVEN | Even pages.
ODD | Odd pages.

## ◆ PanDirection

enum Gtk::PanDirection
| strong

Describes the panning direction of a Gtk::GesturePan.

Enumerator
LEFT |
RIGHT |
UP |
DOWN |

## ◆ PickFlags

enum Gtk::PickFlags
| 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 | Include widgets that are insensitive. The cell is drawn in an insensitive manner. Widget is insensitive.
NON_TARGETABLE | Include widgets that are marked as non-targetable. See Gtk::Widget::property_can_target().

## ◆ PlatformState

enum Gtk::Accessible::PlatformState
| strong

The various platform states which can be queried using Gtk::Accessible::get_platform_state().

Since gtkmm 4.10:

Enumerator
FOCUSABLE | Whether the accessible can be focused.
FOCUSED | Whether the accessible has focus.
ACTIVE | Whether the accessible is active.

## ◆ Policy

enum Gtk::Scrollable::Policy
| 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.

## ◆ PolicyType

enum Gtk::PolicyType
| 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.

## ◆ PositionType

enum Gtk::PositionType
| strong

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

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

Enumerator
LEFT |
RIGHT |
TOP | The feature is at the top edge. Top border window. Align the baseline at the top.
BOTTOM | The feature is at the bottom edge. Bottom border window. Align the baseline at the bottom.

## ◆ PrintCapabilities

enum Gtk::PrintCapabilities
| strong

Specifies 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)`

Enumerator
PAGE_SET | Print dialog will offer printing even/odd pages.
COPIES | Print dialog will allow to print multiple copies.
COLLATE | Print dialog will allow to collate multiple copies.
REVERSE | Print dialog will allow to print pages in reverse order.
SCALE | Print dialog will allow to scale the output.
GENERATE_PDF | The program will send the document to the printer in PDF format.
GENERATE_PS | The program will send the document to the printer in Postscript format.
PREVIEW | Print dialog will offer a preview.
NUMBER_UP | Print dialog will offer printing multiple pages per sheet.
NUMBER_UP_LAYOUT | Print dialog will allow to rearrange pages when printing multiple pages per sheet.

## ◆ PrintDuplex

enum Gtk::PrintDuplex
| strong

See also Gtk::PrintSettings::set_duplex().

Enumerator
SIMPLEX | No duplex.
HORIZONTAL |
VERTICAL |

## ◆ PrintFlags

enum Gtk::StyleContext::PrintFlags
| 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)`

Enumerator
NONE | Default value.
RECURSE | Print the entire tree of CSS nodes starting at the style context's node.
SHOW_STYLE | Show the values of the CSS properties for each node.
SHOW_CHANGE | Show information about what changes affect the styles.

## ◆ PrintPages

enum Gtk::PrintPages
| strong

See also Gtk::PrintJob::set_pages()

Enumerator
ALL | All pages.
CURRENT | Current page.
RANGES | Range of pages.
SELECTION | Selected pages.

## ◆ PrintQuality

enum Gtk::PrintQuality
| strong

See also Gtk::PrintSettings::set_quality().

Enumerator
LOW | Low quality.
NORMAL |
HIGH | High quality.
DRAFT | Draft quality.

## ◆ PrintStatus

enum Gtk::PrintStatus
| strong

The status gives a rough indication of the completion of a running print operation.

Enumerator
INITIAL | The printing has not started yet; this status is set initially, and while the print dialog is shown.
PREPARING | This status is set while the begin-print signal is emitted and during pagination.
GENERATING_DATA | This status is set while the pages are being rendered.
SENDING_DATA | The print job is being sent off to the printer.
PENDING | The print job has been sent to the printer, but is not printed for some reason, e.g. the printer may be stopped.
PENDING_ISSUE | Some problem has occurred during printing, e.g. a paper jam.
PRINTING | The printer is processing the print job.
FINISHED | The printing has been completed successfully.
FINISHED_ABORTED | The printing has been aborted.

## ◆ PropagationLimit

enum Gtk::PropagationLimit
| 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).

## ◆ PropagationPhase

enum Gtk::PropagationPhase
| strong

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

Enumerator
NONE |
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.
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.
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.

## ◆ Property

enum Gtk::Accessible::Property
| 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. 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.

## ◆ Relation [1/2]

enum Gtk::Accessible::Relation
| 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.

## ◆ Relation [2/2]

enum Gtk::Constraint::Relation
| strong

The relation between two terms of a constraint.

Enumerator
LE | Less than, or equal.
EQ | Equal.
GE | Greater than, or equal.

## ◆ ResponseType

enum Gtk::ResponseType_Wrapper::ResponseType

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.

Enumerator
NONE | Returned if an action widget has no response id, or if the dialog gets programmatically hidden or destroyed.
REJECT | Generic response id, not used by GTK dialogs.
ACCEPT | Generic response id, not used by GTK dialogs.
DELETE_EVENT | Returned if the dialog is deleted.
OK | Returned by OK buttons in GTK dialogs.
CANCEL | Returned by Cancel buttons in GTK dialogs.
CLOSE | Returned by Close buttons in GTK dialogs.
YES | Returned by Yes buttons in GTK dialogs.
NO | Returned by No buttons in GTK dialogs.
APPLY | Returned by Apply buttons in GTK dialogs.
HELP | Returned by Help buttons in GTK dialogs.

## ◆ Result

enum Gtk::PrintOperation::Result
| strong

The result of a print operation.

A value of this type is returned by Gtk::PrintOperation::run().

Enumerator
ERROR | An error has occurred.
APPLY | The print settings should be stored.
CANCEL | The print operation has been canceled, the print settings should not be stored.
IN_PROGRESS | The print operation is not complete yet. This value will only be returned when running asynchronously.

## ◆ RevealerTransitionType

enum Gtk::RevealerTransitionType
| strong

These enumeration values describe the possible transitions when the child of a `Gtk::Revealer` widget is shown or hidden.

Enumerator
NONE |
CROSSFADE | Fade in. A cross-fade.
SLIDE_RIGHT | Slide in from the left. Slide from left to right.
SLIDE_LEFT | Slide in from the right. Slide from right to left.
SLIDE_UP | Slide in from the bottom. Slide from bottom up.
SLIDE_DOWN | Slide in from the top. Slide from top down.
SWING_RIGHT | Floop in from the left.
SWING_LEFT | Floop in from the right.
SWING_UP | Floop in from the bottom.
SWING_DOWN | Floop in from the top.

## ◆ Role

enum Gtk::Accessible::Role
| 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: `true`, `false`, or `mixed`.
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.
TOGGLE_BUTTON | A type of push button which stays pressed until depressed by a second activation. Since gtkmm 4.10:

## ◆ ScrollType

enum Gtk::ScrollType
| strong

Scrolling types.

Enumerator
NONE |
JUMP | Jump to new location.
STEP_BACKWARD | Step backward. Decrement by the adjustments step increment.
STEP_FORWARD | Step forward. Increment by the adjustments step increment.
PAGE_BACKWARD | Page backward. Decrement by the adjustments page increment.
PAGE_FORWARD | Page forward. Increment by the adjustments page increment.
STEP_UP | Step up.
STEP_DOWN | Step down.
PAGE_UP | Page up.
PAGE_DOWN | Page down.
STEP_LEFT | Step to the left.
STEP_RIGHT | Step to the right.
PAGE_LEFT | Page to the left.
PAGE_RIGHT | Page to the right.
START |
END |

## ◆ SelectionMode

enum Gtk::SelectionMode
| 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.

## ◆ SensitivityType

enum Gtk::SensitivityType
| strong

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

Enumerator
AUTO | The control is made insensitive if no action can be triggered.
ON | The control is always sensitive.
OFF | The control is always insensitive.

## ◆ ShortcutScope

enum Gtk::ShortcutScope
| 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.

## ◆ ShortcutType

enum Gtk::ShortcutType
| 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 GtkShortcutsShortcut: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 GtkShortcutsShortcut: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.

## ◆ SizeRequestMode

enum Gtk::SizeRequestMode
| strong

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

Enumerator
HEIGHT_FOR_WIDTH | Prefer height-for-width geometry management.
WIDTH_FOR_HEIGHT | Prefer width-for-height geometry management.
CONSTANT_SIZE | Don’t trade height-for-width or width-for-height.

## ◆ Sizing

enum Gtk::TreeViewColumn::Sizing
| 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.

Enumerator
GROW_ONLY | Columns only get bigger in reaction to changes in the model.
AUTOSIZE | Columns resize to be the optimal size every time the model changes.
FIXED | Columns are a fixed numbers of pixels wide.

## ◆ SortType

enum Gtk::SortType
| strong

Determines the direction of a sort.

Enumerator
ASCENDING | Sorting is in ascending order.
DESCENDING | Sorting is in descending order.

## ◆ SpinType

enum Gtk::SpinType
| 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.

## ◆ StackTransitionType

enum Gtk::StackTransitionType
| strong

Possible transitions between pages in a `Gtk::Stack` widget.

New values may be added to this enumeration over time.

Enumerator
NONE |
CROSSFADE |
SLIDE_RIGHT |
SLIDE_LEFT |
SLIDE_UP |
SLIDE_DOWN |
SLIDE_LEFT_RIGHT | Slide from left or right according to the children order.
SLIDE_UP_DOWN | Slide from top down or bottom up according to the order.
OVER_UP | Cover the old page by sliding up.
OVER_DOWN | Cover the old page by sliding down.
OVER_LEFT | Cover the old page by sliding to the left.
OVER_RIGHT | Cover the old page by sliding to the right.
UNDER_UP | Uncover the new page by sliding up.
UNDER_DOWN | Uncover the new page by sliding down.
UNDER_LEFT | Uncover the new page by sliding to the left.
UNDER_RIGHT | Uncover the new page by sliding to the right.
OVER_UP_DOWN | Cover the old page sliding up or uncover the new page sliding down, according to order.
OVER_DOWN_UP | Cover the old page sliding down or uncover the new page sliding up, according to order.
OVER_LEFT_RIGHT | Cover the old page sliding left or uncover the new page sliding right, according to order.
OVER_RIGHT_LEFT | Cover the old page sliding right or uncover the new page sliding left, according to order.
ROTATE_LEFT | Pretend the pages are sides of a cube and rotate that cube to the left.
ROTATE_RIGHT | Pretend the pages are sides of a cube and rotate that cube to the right.
ROTATE_LEFT_RIGHT | Pretend the pages are sides of a cube and rotate that cube to the left or right according to the children order.

## ◆ State

enum Gtk::Accessible::State
| 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. 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. Value type: boolean or undefined.
HIDDEN | A “hidden” state; corresponds to the Gtk::Widget::property_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.
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.

## ◆ StateFlags

enum Gtk::StateFlags
| 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 | Widget is selected. The cell is currently selected, and probably has a selection colored background to render to.
INSENSITIVE |
INCONSISTENT | Widget is inconsistent.
FOCUSED | Widget has the keyboard focus. The cell is in the focus row.
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.

## ◆ Strength

enum Gtk::Constraint::Strength_Wrapper::Strength

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.

## ◆ TextDirection

enum Gtk::TextDirection
| strong

Reading directions for text.

Enumerator
NONE |
LTR | Left to right text direction.
RTL | Right to left text direction.

## ◆ TextSearchFlags

enum Gtk::TextSearchFlags
| 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)`

Enumerator
VISIBLE_ONLY | Search only visible data. A search match may have invisible text interspersed.
TEXT_ONLY | Search only text. A match may have paintables or child widgets mixed inside the matched range.
CASE_INSENSITIVE | The text will be matched regardless of what case it is in.

## ◆ TextWindowType

enum Gtk::TextWindowType
| 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 |

## ◆ Type [1/2]

enum Gtk::AssistantPage::Type
| strong

Determines the page role inside a `Gtk::Assistant`.

The role is 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().

## ◆ Type [2/2]

enum Gtk::Image::Type
| 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; for instance, 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`.

## ◆ Unit

enum Gtk::Unit
| strong

See also Gtk::PrintSettings::set_paper_width().

Enumerator
NONE |
POINTS | Dimensions in points.
INCH | Dimensions in inches.
MM | Dimensions in millimeters.

## ◆ UpdatePolicy

enum Gtk::SpinButton::UpdatePolicy
| strong

Determines whether the spin button displays values outside the adjustment bounds.

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.

## ◆ WrapMode

enum Gtk::WrapMode
| strong

Describes a type of line wrapping.

Enumerator
NONE |
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()).
WORD | Wrap text, breaking lines in between words. Attempt to wrap at word boundaries. This is useful in particular when using Pango::WrapMode::WORD_CHAR as the wrap mode.
WORD_CHAR | Wrap text, breaking lines in between words, or if that is not enough, also between graphemes.

## Function Documentation

## ◆ operator&() [1/14]

Application::InhibitFlags Gtk::operator& | ( | Application::InhibitFlags | lhs,
|  | Application::InhibitFlags | rhs
| ) |  |
| inline

## ◆ operator&() [2/14]

CellRendererState Gtk::operator& | ( | CellRendererState | lhs,
|  | CellRendererState | rhs
| ) |  |
| inline

## ◆ operator&() [3/14]

EventControllerScroll::Flags Gtk::operator& | ( | EventControllerScroll::Flags | lhs,
|  | EventControllerScroll::Flags | rhs
| ) |  |
| inline

## ◆ operator&() [4/14]

FontChooser::Level Gtk::operator& | ( | FontChooser::Level | lhs,
|  | FontChooser::Level | rhs
| ) |  |
| inline

## ◆ operator&() [5/14]

IconLookupFlags Gtk::operator& | ( | IconLookupFlags | lhs,
|  | IconLookupFlags | rhs
| ) |  |
| inline

## ◆ operator&() [6/14]

InputHints Gtk::operator& | ( | InputHints | lhs,
|  | InputHints | rhs
| ) |  |
| inline

## ◆ operator&() [7/14]

PickFlags Gtk::operator& | ( | PickFlags | lhs,
|  | PickFlags | rhs
| ) |  |
| inline

## ◆ operator&() [8/14]

PopoverMenu::Flags Gtk::operator& | ( | PopoverMenu::Flags | lhs,
|  | PopoverMenu::Flags | rhs
| ) |  |
| inline

## ◆ operator&() [9/14]

PrintCapabilities Gtk::operator& | ( | PrintCapabilities | lhs,
|  | PrintCapabilities | rhs
| ) |  |
| inline

## ◆ operator&() [10/14]

ShortcutAction::Flags Gtk::operator& | ( | ShortcutAction::Flags | lhs,
|  | ShortcutAction::Flags | rhs
| ) |  |
| inline

## ◆ operator&() [11/14]

StateFlags Gtk::operator& | ( | StateFlags | lhs,
|  | StateFlags | rhs
| ) |  |
| inline

## ◆ operator&() [12/14]

StyleContext::PrintFlags Gtk::operator& | ( | StyleContext::PrintFlags | lhs,
|  | StyleContext::PrintFlags | rhs
| ) |  |
| inline

## ◆ operator&() [13/14]

TextSearchFlags Gtk::operator& | ( | TextSearchFlags | lhs,
|  | TextSearchFlags | rhs
| ) |  |
| inline

## ◆ operator&() [14/14]

TreeModel::Flags Gtk::operator& | ( | TreeModel::Flags | lhs,
|  | TreeModel::Flags | rhs
| ) |  |
| inline

## ◆ operator&=() [1/14]

Application::InhibitFlags& Gtk::operator&= | ( | Application::InhibitFlags & | lhs,
|  | Application::InhibitFlags | rhs
| ) |  |
| inline

## ◆ operator&=() [2/14]

CellRendererState& Gtk::operator&= | ( | CellRendererState & | lhs,
|  | CellRendererState | rhs
| ) |  |
| inline

## ◆ operator&=() [3/14]

EventControllerScroll::Flags& Gtk::operator&= | ( | EventControllerScroll::Flags & | lhs,
|  | EventControllerScroll::Flags | rhs
| ) |  |
| inline

## ◆ operator&=() [4/14]

FontChooser::Level& Gtk::operator&= | ( | FontChooser::Level & | lhs,
|  | FontChooser::Level | rhs
| ) |  |
| inline

## ◆ operator&=() [5/14]

IconLookupFlags& Gtk::operator&= | ( | IconLookupFlags & | lhs,
|  | IconLookupFlags | rhs
| ) |  |
| inline

## ◆ operator&=() [6/14]

InputHints& Gtk::operator&= | ( | InputHints & | lhs,
|  | InputHints | rhs
| ) |  |
| inline

## ◆ operator&=() [7/14]

PickFlags& Gtk::operator&= | ( | PickFlags & | lhs,
|  | PickFlags | rhs
| ) |  |
| inline

## ◆ operator&=() [8/14]

PopoverMenu::Flags& Gtk::operator&= | ( | PopoverMenu::Flags & | lhs,
|  | PopoverMenu::Flags | rhs
| ) |  |
| inline

## ◆ operator&=() [9/14]

PrintCapabilities& Gtk::operator&= | ( | PrintCapabilities & | lhs,
|  | PrintCapabilities | rhs
| ) |  |
| inline

## ◆ operator&=() [10/14]

ShortcutAction::Flags& Gtk::operator&= | ( | ShortcutAction::Flags & | lhs,
|  | ShortcutAction::Flags | rhs
| ) |  |
| inline

## ◆ operator&=() [11/14]

StateFlags& Gtk::operator&= | ( | StateFlags & | lhs,
|  | StateFlags | rhs
| ) |  |
| inline

## ◆ operator&=() [12/14]

StyleContext::PrintFlags& Gtk::operator&= | ( | StyleContext::PrintFlags & | lhs,
|  | StyleContext::PrintFlags | rhs
| ) |  |
| inline

## ◆ operator&=() [13/14]

TextSearchFlags& Gtk::operator&= | ( | TextSearchFlags & | lhs,
|  | TextSearchFlags | rhs
| ) |  |
| inline

## ◆ operator&=() [14/14]

TreeModel::Flags& Gtk::operator&= | ( | TreeModel::Flags & | lhs,
|  | TreeModel::Flags | rhs
| ) |  |
| inline

## ◆ operator^() [1/14]

Application::InhibitFlags Gtk::operator^ | ( | Application::InhibitFlags | lhs,
|  | Application::InhibitFlags | rhs
| ) |  |
| inline

## ◆ operator^() [2/14]

CellRendererState Gtk::operator^ | ( | CellRendererState | lhs,
|  | CellRendererState | rhs
| ) |  |
| inline

## ◆ operator^() [3/14]

EventControllerScroll::Flags Gtk::operator^ | ( | EventControllerScroll::Flags | lhs,
|  | EventControllerScroll::Flags | rhs
| ) |  |
| inline

## ◆ operator^() [4/14]

FontChooser::Level Gtk::operator^ | ( | FontChooser::Level | lhs,
|  | FontChooser::Level | rhs
| ) |  |
| inline

## ◆ operator^() [5/14]

IconLookupFlags Gtk::operator^ | ( | IconLookupFlags | lhs,
|  | IconLookupFlags | rhs
| ) |  |
| inline

## ◆ operator^() [6/14]

InputHints Gtk::operator^ | ( | InputHints | lhs,
|  | InputHints | rhs
| ) |  |
| inline

## ◆ operator^() [7/14]

PickFlags Gtk::operator^ | ( | PickFlags | lhs,
|  | PickFlags | rhs
| ) |  |
| inline

## ◆ operator^() [8/14]

PopoverMenu::Flags Gtk::operator^ | ( | PopoverMenu::Flags | lhs,
|  | PopoverMenu::Flags | rhs
| ) |  |
| inline

## ◆ operator^() [9/14]

PrintCapabilities Gtk::operator^ | ( | PrintCapabilities | lhs,
|  | PrintCapabilities | rhs
| ) |  |
| inline

## ◆ operator^() [10/14]

ShortcutAction::Flags Gtk::operator^ | ( | ShortcutAction::Flags | lhs,
|  | ShortcutAction::Flags | rhs
| ) |  |
| inline

## ◆ operator^() [11/14]

StateFlags Gtk::operator^ | ( | StateFlags | lhs,
|  | StateFlags | rhs
| ) |  |
| inline

## ◆ operator^() [12/14]

StyleContext::PrintFlags Gtk::operator^ | ( | StyleContext::PrintFlags | lhs,
|  | StyleContext::PrintFlags | rhs
| ) |  |
| inline

## ◆ operator^() [13/14]

TextSearchFlags Gtk::operator^ | ( | TextSearchFlags | lhs,
|  | TextSearchFlags | rhs
| ) |  |
| inline

## ◆ operator^() [14/14]

TreeModel::Flags Gtk::operator^ | ( | TreeModel::Flags | lhs,
|  | TreeModel::Flags | rhs
| ) |  |
| inline

## ◆ operator^=() [1/14]

Application::InhibitFlags& Gtk::operator^= | ( | Application::InhibitFlags & | lhs,
|  | Application::InhibitFlags | rhs
| ) |  |
| inline

## ◆ operator^=() [2/14]

CellRendererState& Gtk::operator^= | ( | CellRendererState & | lhs,
|  | CellRendererState | rhs
| ) |  |
| inline

## ◆ operator^=() [3/14]

EventControllerScroll::Flags& Gtk::operator^= | ( | EventControllerScroll::Flags & | lhs,
|  | EventControllerScroll::Flags | rhs
| ) |  |
| inline

## ◆ operator^=() [4/14]

FontChooser::Level& Gtk::operator^= | ( | FontChooser::Level & | lhs,
|  | FontChooser::Level | rhs
| ) |  |
| inline

## ◆ operator^=() [5/14]

IconLookupFlags& Gtk::operator^= | ( | IconLookupFlags & | lhs,
|  | IconLookupFlags | rhs
| ) |  |
| inline

## ◆ operator^=() [6/14]

InputHints& Gtk::operator^= | ( | InputHints & | lhs,
|  | InputHints | rhs
| ) |  |
| inline

## ◆ operator^=() [7/14]

PickFlags& Gtk::operator^= | ( | PickFlags & | lhs,
|  | PickFlags | rhs
| ) |  |
| inline

## ◆ operator^=() [8/14]

PopoverMenu::Flags& Gtk::operator^= | ( | PopoverMenu::Flags & | lhs,
|  | PopoverMenu::Flags | rhs
| ) |  |
| inline

## ◆ operator^=() [9/14]

PrintCapabilities& Gtk::operator^= | ( | PrintCapabilities & | lhs,
|  | PrintCapabilities | rhs
| ) |  |
| inline

## ◆ operator^=() [10/14]

ShortcutAction::Flags& Gtk::operator^= | ( | ShortcutAction::Flags & | lhs,
|  | ShortcutAction::Flags | rhs
| ) |  |
| inline

## ◆ operator^=() [11/14]

StateFlags& Gtk::operator^= | ( | StateFlags & | lhs,
|  | StateFlags | rhs
| ) |  |
| inline

## ◆ operator^=() [12/14]

StyleContext::PrintFlags& Gtk::operator^= | ( | StyleContext::PrintFlags & | lhs,
|  | StyleContext::PrintFlags | rhs
| ) |  |
| inline

## ◆ operator^=() [13/14]

TextSearchFlags& Gtk::operator^= | ( | TextSearchFlags & | lhs,
|  | TextSearchFlags | rhs
| ) |  |
| inline

## ◆ operator^=() [14/14]

TreeModel::Flags& Gtk::operator^= | ( | TreeModel::Flags & | lhs,
|  | TreeModel::Flags | rhs
| ) |  |
| inline

## ◆ operator|() [1/14]

Application::InhibitFlags Gtk::operator| | ( | Application::InhibitFlags | lhs,
|  | Application::InhibitFlags | rhs
| ) |  |
| inline

## ◆ operator|() [2/14]

CellRendererState Gtk::operator| | ( | CellRendererState | lhs,
|  | CellRendererState | rhs
| ) |  |
| inline

## ◆ operator|() [3/14]

EventControllerScroll::Flags Gtk::operator| | ( | EventControllerScroll::Flags | lhs,
|  | EventControllerScroll::Flags | rhs
| ) |  |
| inline

## ◆ operator|() [4/14]

FontChooser::Level Gtk::operator| | ( | FontChooser::Level | lhs,
|  | FontChooser::Level | rhs
| ) |  |
| inline

## ◆ operator|() [5/14]

IconLookupFlags Gtk::operator| | ( | IconLookupFlags | lhs,
|  | IconLookupFlags | rhs
| ) |  |
| inline

## ◆ operator|() [6/14]

InputHints Gtk::operator| | ( | InputHints | lhs,
|  | InputHints | rhs
| ) |  |
| inline

## ◆ operator|() [7/14]

PickFlags Gtk::operator| | ( | PickFlags | lhs,
|  | PickFlags | rhs
| ) |  |
| inline

## ◆ operator|() [8/14]

PopoverMenu::Flags Gtk::operator| | ( | PopoverMenu::Flags | lhs,
|  | PopoverMenu::Flags | rhs
| ) |  |
| inline

## ◆ operator|() [9/14]

PrintCapabilities Gtk::operator| | ( | PrintCapabilities | lhs,
|  | PrintCapabilities | rhs
| ) |  |
| inline

## ◆ operator|() [10/14]

ShortcutAction::Flags Gtk::operator| | ( | ShortcutAction::Flags | lhs,
|  | ShortcutAction::Flags | rhs
| ) |  |
| inline

## ◆ operator|() [11/14]

StateFlags Gtk::operator| | ( | StateFlags | lhs,
|  | StateFlags | rhs
| ) |  |
| inline

## ◆ operator|() [12/14]

StyleContext::PrintFlags Gtk::operator| | ( | StyleContext::PrintFlags | lhs,
|  | StyleContext::PrintFlags | rhs
| ) |  |
| inline

## ◆ operator|() [13/14]

TextSearchFlags Gtk::operator| | ( | TextSearchFlags | lhs,
|  | TextSearchFlags | rhs
| ) |  |
| inline

## ◆ operator|() [14/14]

TreeModel::Flags Gtk::operator| | ( | TreeModel::Flags | lhs,
|  | TreeModel::Flags | rhs
| ) |  |
| inline

## ◆ operator|=() [1/14]

Application::InhibitFlags& Gtk::operator|= | ( | Application::InhibitFlags & | lhs,
|  | Application::InhibitFlags | rhs
| ) |  |
| inline

## ◆ operator|=() [2/14]

CellRendererState& Gtk::operator|= | ( | CellRendererState & | lhs,
|  | CellRendererState | rhs
| ) |  |
| inline

## ◆ operator|=() [3/14]

EventControllerScroll::Flags& Gtk::operator|= | ( | EventControllerScroll::Flags & | lhs,
|  | EventControllerScroll::Flags | rhs
| ) |  |
| inline

## ◆ operator|=() [4/14]

FontChooser::Level& Gtk::operator|= | ( | FontChooser::Level & | lhs,
|  | FontChooser::Level | rhs
| ) |  |
| inline

## ◆ operator|=() [5/14]

IconLookupFlags& Gtk::operator|= | ( | IconLookupFlags & | lhs,
|  | IconLookupFlags | rhs
| ) |  |
| inline

## ◆ operator|=() [6/14]

InputHints& Gtk::operator|= | ( | InputHints & | lhs,
|  | InputHints | rhs
| ) |  |
| inline

## ◆ operator|=() [7/14]

PickFlags& Gtk::operator|= | ( | PickFlags & | lhs,
|  | PickFlags | rhs
| ) |  |
| inline

## ◆ operator|=() [8/14]

PopoverMenu::Flags& Gtk::operator|= | ( | PopoverMenu::Flags & | lhs,
|  | PopoverMenu::Flags | rhs
| ) |  |
| inline

## ◆ operator|=() [9/14]

PrintCapabilities& Gtk::operator|= | ( | PrintCapabilities & | lhs,
|  | PrintCapabilities | rhs
| ) |  |
| inline

## ◆ operator|=() [10/14]

ShortcutAction::Flags& Gtk::operator|= | ( | ShortcutAction::Flags & | lhs,
|  | ShortcutAction::Flags | rhs
| ) |  |
| inline

## ◆ operator|=() [11/14]

StateFlags& Gtk::operator|= | ( | StateFlags & | lhs,
|  | StateFlags | rhs
| ) |  |
| inline

## ◆ operator|=() [12/14]

StyleContext::PrintFlags& Gtk::operator|= | ( | StyleContext::PrintFlags & | lhs,
|  | StyleContext::PrintFlags | rhs
| ) |  |
| inline

## ◆ operator|=() [13/14]

TextSearchFlags& Gtk::operator|= | ( | TextSearchFlags & | lhs,
|  | TextSearchFlags | rhs
| ) |  |
| inline

## ◆ operator|=() [14/14]

TreeModel::Flags& Gtk::operator|= | ( | TreeModel::Flags & | lhs,
|  | TreeModel::Flags | rhs
| ) |  |
| inline

## ◆ operator~() [1/14]

Application::InhibitFlags Gtk::operator~ | ( | Application::InhibitFlags | flags | ) |
| inline

## ◆ operator~() [2/14]

CellRendererState Gtk::operator~ | ( | CellRendererState | flags | ) |
| inline

## ◆ operator~() [3/14]

EventControllerScroll::Flags Gtk::operator~ | ( | EventControllerScroll::Flags | flags | ) |
| inline

## ◆ operator~() [4/14]

FontChooser::Level Gtk::operator~ | ( | FontChooser::Level | flags | ) |
| inline

## ◆ operator~() [5/14]

IconLookupFlags Gtk::operator~ | ( | IconLookupFlags | flags | ) |
| inline

## ◆ operator~() [6/14]

InputHints Gtk::operator~ | ( | InputHints | flags | ) |
| inline

## ◆ operator~() [7/14]

PickFlags Gtk::operator~ | ( | PickFlags | flags | ) |
| inline

## ◆ operator~() [8/14]

PopoverMenu::Flags Gtk::operator~ | ( | PopoverMenu::Flags | flags | ) |
| inline

## ◆ operator~() [9/14]

PrintCapabilities Gtk::operator~ | ( | PrintCapabilities | flags | ) |
| inline

## ◆ operator~() [10/14]

ShortcutAction::Flags Gtk::operator~ | ( | ShortcutAction::Flags | flags | ) |
| inline

## ◆ operator~() [11/14]

StateFlags Gtk::operator~ | ( | StateFlags | flags | ) |
| inline

## ◆ operator~() [12/14]

StyleContext::PrintFlags Gtk::operator~ | ( | StyleContext::PrintFlags | flags | ) |
| inline

## ◆ operator~() [13/14]

TextSearchFlags Gtk::operator~ | ( | TextSearchFlags | flags | ) |
| inline

## ◆ operator~() [14/14]

TreeModel::Flags Gtk::operator~ | ( | TreeModel::Flags | flags | ) |
| inline