gtkmm: gtkmm Enums and Flags

gtkmm 3.93.0

Classes | Typedefs | Enumerations | Functions
gtkmm Enums and Flags

## Classes
class | Gtk::ResponseType_Wrapper
| Wrapper for enum ResponseType. More...

## Typedefs
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::PackOptions { Gtk::PackOptions::SHRINK, Gtk::PackOptions::EXPAND_PADDING, Gtk::PackOptions::EXPAND_WIDGET }
| Packing options for adding child widgets to a Box with pack_start() and pack_end(). More...
enum | Gtk::PlacesOpenFlags { Gtk::PlacesOpenFlags::NORMAL = 1 << 0, Gtk::PlacesOpenFlags::NEW_TAB = 1 << 1, Gtk::PlacesOpenFlags::NEW_WINDOW = 1 << 2 }
enum | { Gtk::SpinButton::INPUT_ERROR = -1 }
| Constant to return from a signal handler for the input signal in case of conversion failure. More...
enum | Gtk::License { Gtk::License::UNKNOWN, Gtk::License::CUSTOM, Gtk::License::GPL_2_0, Gtk::License::GPL_3_0, Gtk::License::LGPL_2_1, Gtk::License::LGPL_3_0, Gtk::License::BSD, Gtk::License::MIT_X11, Gtk::License::ARTISTIC, Gtk::License::GPL_2_0_ONLY, Gtk::License::GPL_3_0_ONLY, Gtk::License::LGPL_2_1_ONLY, Gtk::License::LGPL_3_0_ONLY, Gtk::License::AGPL_3_0, Gtk::License::AGPL_3_0_ONLY }
| The type of license for an application. More...
enum | Gtk::Application::InhibitFlags { Gtk::Application::InhibitFlags::LOGOUT = (1 << 0), Gtk::Application::InhibitFlags::SWITCH = (1 << 1), Gtk::Application::InhibitFlags::SUSPEND = (1 << 2), Gtk::Application::InhibitFlags::IDLE = (1 << 3) }
| Types of user actions that may be blocked by Gtk::Application::inhibit(). More...
enum | Gtk::Assistant::PageType { Gtk::Assistant::PageType::CONTENT, Gtk::Assistant::PageType::INTRO, Gtk::Assistant::PageType::CONFIRM, Gtk::Assistant::PageType::SUMMARY, Gtk::Assistant::PageType::PROGRESS, Gtk::Assistant::PageType::CUSTOM }
| An enum for determining the page role inside the Gtk::Assistant. More...
enum | Gtk::Calendar::DisplayOptions { Gtk::Calendar::DisplayOptions::SHOW_HEADING = 1 << 0, Gtk::Calendar::DisplayOptions::SHOW_DAY_NAMES = 1 << 1, Gtk::Calendar::DisplayOptions::NO_MONTH_CHANGE = 1 << 2, Gtk::Calendar::DisplayOptions::SHOW_WEEK_NUMBERS = 1 << 3, Gtk::Calendar::DisplayOptions::SHOW_DETAILS = 1 << 5 }
| These options can be used to influence the display and behaviour of a Gtk::Calendar. More...
enum | Gtk::CellRendererState { Gtk::CellRendererState::SELECTED = 1 << 0, Gtk::CellRendererState::PRELIT = 1 << 1, Gtk::CellRendererState::INSENSITIVE = 1 << 2, Gtk::CellRendererState::SORTED = 1 << 3, Gtk::CellRendererState::FOCUSED = 1 << 4, Gtk::CellRendererState::EXPANDABLE = 1 << 5, Gtk::CellRendererState::EXPANDED = 1 << 6 }
| Tells how a cell is to be rendered. More...
enum | Gtk::CellRendererMode { Gtk::CellRendererMode::INERT, Gtk::CellRendererMode::ACTIVATABLE, Gtk::CellRendererMode::EDITABLE }
| Identifies how the user can interact with a particular cell. More...
enum | Gtk::CellRendererAccel::Mode { Gtk::CellRendererAccel::Mode::GTK, Gtk::CellRendererAccel::Mode::OTHER }
| Determines if the edited accelerators are GTK+ accelerators. More...
enum | Gtk::CssSection::Type { Gtk::CssSection::Type::DOCUMENT, Gtk::CssSection::Type::IMPORT, Gtk::CssSection::Type::COLOR_DEFINITION, Gtk::CssSection::Type::BINDING_SET, Gtk::CssSection::Type::RULESET, Gtk::CssSection::Type::SELECTOR, Gtk::CssSection::Type::DECLARATION, Gtk::CssSection::Type::VALUE, Gtk::CssSection::Type::KEYFRAMES }
| The different types of sections indicate parts of a CSS document as parsed by GTK’s CSS parser. 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 | Gtk::Entry::IconPosition { Gtk::Entry::IconPosition::PRIMARY, Gtk::Entry::IconPosition::SECONDARY }
| Specifies the side of the entry at which an icon is placed. More...
enum | Gtk::AccelFlags { Gtk::AccelFlags::VISIBLE = 1 << 0, Gtk::AccelFlags::LOCKED = 1 << 1, Gtk::AccelFlags::MASK = 0x07 }
| Accelerator flags used with Gtk::AccelGroup::connect(). More...
enum | Gtk::Align { Gtk::Align::FILL, Gtk::Align::START, Gtk::Align::END, Gtk::Align::CENTER, Gtk::Align::BASELINE }
| Controls how a widget deals with extra space in a single (x or y) dimension. More...
enum | Gtk::ArrowType { Gtk::ArrowType::UP, Gtk::ArrowType::DOWN, Gtk::ArrowType::LEFT, Gtk::ArrowType::RIGHT, Gtk::ArrowType::NONE }
| Used to indicate the direction in which an arrow should point. More...
enum | Gtk::ButtonBoxStyle { Gtk::ButtonBoxStyle::SPREAD = 1, Gtk::ButtonBoxStyle::EDGE, Gtk::ButtonBoxStyle::START, Gtk::ButtonBoxStyle::END, Gtk::ButtonBoxStyle::CENTER, Gtk::ButtonBoxStyle::EXPAND }
| Used to dictate the style that a Gtk::ButtonBox uses to layout the buttons it contains. More...
enum | Gtk::DeleteType { Gtk::DeleteType::CHARS, Gtk::DeleteType::WORD_ENDS, Gtk::DeleteType::WORDS, Gtk::DeleteType::DISPLAY_LINES, Gtk::DeleteType::DISPLAY_LINE_ENDS, Gtk::DeleteType::PARAGRAPH_ENDS, Gtk::DeleteType::PARAGRAPHS, Gtk::DeleteType::WHITESPACE }
| See also: Gtk::Entry::signal_delete_from_cursor(). More...
enum | Gtk::DirectionType { Gtk::DirectionType::TAB_FORWARD, Gtk::DirectionType::TAB_BACKWARD, Gtk::DirectionType::UP, Gtk::DirectionType::DOWN, Gtk::DirectionType::LEFT, Gtk::DirectionType::RIGHT }
| Focus movement types. More...
enum | Gtk::IconSize { Gtk::IconSize::INHERIT, Gtk::IconSize::NORMAL, Gtk::IconSize::LARGE }
| Built-in icon sizes. More...
enum | Gtk::TextDirection { Gtk::TextDirection::NONE, Gtk::TextDirection::LTR, Gtk::TextDirection::RTL }
| Reading directions for text. More...
enum | Gtk::Justification { Gtk::Justification::LEFT, Gtk::Justification::RIGHT, Gtk::Justification::CENTER, Gtk::Justification::FILL }
| Used for justifying the text inside a Gtk::Label widget. More...
enum | Gtk::MenuDirectionType { Gtk::MenuDirectionType::PARENT, Gtk::MenuDirectionType::CHILD, Gtk::MenuDirectionType::NEXT, Gtk::MenuDirectionType::PREV }
| An enumeration representing directional movements within a menu. More...
enum | MessageType { Gio::DBus::MessageType::INVALID, Gio::DBus::MessageType::METHOD_CALL, Gio::DBus::MessageType::METHOD_RETURN, Gio::DBus::MessageType::ERROR, Gio::DBus::MessageType::SIGNAL }
| The type of message being displayed in the dialog. More...
enum | Gtk::MovementStep { Gtk::MovementStep::LOGICAL_POSITIONS, Gtk::MovementStep::VISUAL_POSITIONS, Gtk::MovementStep::WORDS, Gtk::MovementStep::DISPLAY_LINES, Gtk::MovementStep::DISPLAY_LINE_ENDS, Gtk::MovementStep::PARAGRAPHS, Gtk::MovementStep::PARAGRAPH_ENDS, Gtk::MovementStep::PAGES, Gtk::MovementStep::BUFFER_ENDS, Gtk::MovementStep::HORIZONTAL_PAGES }
enum | Gtk::Orientation { Gtk::Orientation::HORIZONTAL, Gtk::Orientation::VERTICAL }
| Represents the orientation of widgets and other objects which can be switched between horizontal and vertical orientation on the fly, like Gtk::Toolbar or Gtk::GesturePan. More...
enum | Gtk::CornerType { Gtk::CornerType::TOP_LEFT, Gtk::CornerType::BOTTOM_LEFT, Gtk::CornerType::TOP_RIGHT, Gtk::CornerType::BOTTOM_RIGHT }
| Specifies which corner a child widget should be placed in when packed into a Gtk::ScrolledWindow. More...
enum | Gtk::PackType { Gtk::PackType::START, Gtk::PackType::END }
| Represents the packing location Gtk::Box children. More...
enum | Gtk::PolicyType { Gtk::PolicyType::ALWAYS, Gtk::PolicyType::AUTOMATIC, Gtk::PolicyType::NEVER, Gtk::PolicyType::EXTERNAL }
| Determines how the size should be computed to achieve the one of the visibility mode for the scrollbars. More...
enum | Gtk::PositionType { Gtk::PositionType::LEFT, Gtk::PositionType::RIGHT, Gtk::PositionType::TOP, Gtk::PositionType::BOTTOM }
| Describes which edge of a widget a certain feature is positioned at, e.g. More...
enum | Gtk::ReliefStyle { Gtk::ReliefStyle::NORMAL, Gtk::ReliefStyle::NONE }
| Indicated the relief to be drawn around a Gtk::Button. More...
enum | Gtk::RevealerTransitionType { Gtk::RevealerTransitionType::NONE, Gtk::RevealerTransitionType::CROSSFADE, Gtk::RevealerTransitionType::SLIDE_RIGHT, Gtk::RevealerTransitionType::SLIDE_LEFT, Gtk::RevealerTransitionType::SLIDE_UP, Gtk::RevealerTransitionType::SLIDE_DOWN }
| These enumeration values describe the possible transitions when the child of a Gtk::Revealer widget is shown or hidden. More...
enum | Gtk::ScrollType { Gtk::ScrollType::NONE, Gtk::ScrollType::JUMP, Gtk::ScrollType::STEP_BACKWARD, Gtk::ScrollType::STEP_FORWARD, Gtk::ScrollType::PAGE_BACKWARD, Gtk::ScrollType::PAGE_FORWARD, Gtk::ScrollType::STEP_UP, Gtk::ScrollType::STEP_DOWN, Gtk::ScrollType::PAGE_UP, Gtk::ScrollType::PAGE_DOWN, Gtk::ScrollType::STEP_LEFT, Gtk::ScrollType::STEP_RIGHT, Gtk::ScrollType::PAGE_LEFT, Gtk::ScrollType::PAGE_RIGHT, Gtk::ScrollType::START, Gtk::ScrollType::END }
| Scrolling types. More...
enum | Gtk::SelectionMode { Gtk::SelectionMode::NONE, Gtk::SelectionMode::SINGLE, Gtk::SelectionMode::BROWSE, Gtk::SelectionMode::MULTIPLE }
| Used to control what selections users are allowed to make. More...
enum | Gtk::ShadowType { Gtk::ShadowType::NONE, Gtk::ShadowType::IN, Gtk::ShadowType::OUT, Gtk::ShadowType::ETCHED_IN, Gtk::ShadowType::ETCHED_OUT }
| Used to change the appearance of an outline typically provided by a Gtk::Frame. More...
enum | Gtk::StackTransitionType { Gtk::StackTransitionType::NONE, Gtk::StackTransitionType::CROSSFADE, Gtk::StackTransitionType::SLIDE_RIGHT, Gtk::StackTransitionType::SLIDE_LEFT, Gtk::StackTransitionType::SLIDE_UP, Gtk::StackTransitionType::SLIDE_DOWN, Gtk::StackTransitionType::SLIDE_LEFT_RIGHT, Gtk::StackTransitionType::SLIDE_UP_DOWN, Gtk::StackTransitionType::OVER_UP, Gtk::StackTransitionType::OVER_DOWN, Gtk::StackTransitionType::OVER_LEFT, Gtk::StackTransitionType::OVER_RIGHT, Gtk::StackTransitionType::UNDER_UP, Gtk::StackTransitionType::UNDER_DOWN, Gtk::StackTransitionType::UNDER_LEFT, Gtk::StackTransitionType::UNDER_RIGHT, Gtk::StackTransitionType::OVER_UP_DOWN, Gtk::StackTransitionType::OVER_DOWN_UP, Gtk::StackTransitionType::OVER_LEFT_RIGHT, Gtk::StackTransitionType::OVER_RIGHT_LEFT }
| These enumeration values describe the possible transitions between pages in a Gtk::Stack widget. More...
enum | Gtk::ToolbarStyle { Gtk::ToolbarStyle::ICONS, Gtk::ToolbarStyle::TEXT, Gtk::ToolbarStyle::BOTH, Gtk::ToolbarStyle::BOTH_HORIZ }
| Used to customize the appearance of a Gtk::Toolbar. More...
enum | Gtk::WindowPosition { Gtk::WindowPosition::NONE, Gtk::WindowPosition::CENTER, Gtk::WindowPosition::MOUSE, Gtk::WindowPosition::CENTER_ALWAYS, Gtk::WindowPosition::CENTER_ON_PARENT }
| Window placement can be influenced using this enumeration. More...
enum | Gtk::WindowType { Gtk::WindowType::TOPLEVEL, Gtk::WindowType::POPUP }
| A Gtk::Window can be one of these types. More...
enum | WrapMode { Pango::WrapMode::WORD, Pango::WrapMode::CHAR, Pango::WrapMode::WORD_CHAR }
| Describes a type of line wrapping. More...
enum | Gtk::SortType { Gtk::SortType::ASCENDING, Gtk::SortType::DESCENDING }
| Determines the direction of a sort. More...
enum | Gtk::PageOrientation { Gtk::PageOrientation::PORTRAIT, Gtk::PageOrientation::LANDSCAPE, Gtk::PageOrientation::REVERSE_PORTRAIT, Gtk::PageOrientation::REVERSE_LANDSCAPE }
| See also Gtk::PrintSettings::set_orientation(). More...
enum | Gtk::SensitivityType { Gtk::SensitivityType::AUTO, Gtk::SensitivityType::ON, Gtk::SensitivityType::OFF }
| Determines how GTK+ handles the sensitivity of stepper arrows at the end of range widgets. More...
enum | Gtk::SizeRequestMode { Gtk::SizeRequestMode::HEIGHT_FOR_WIDTH, Gtk::SizeRequestMode::WIDTH_FOR_HEIGHT, Gtk::SizeRequestMode::CONSTANT_SIZE }
| Specifies a preference for height-for-width or width-for-height geometry management. More...
enum | Gtk::StateFlags { Gtk::StateFlags::NORMAL = 0x0, Gtk::StateFlags::ACTIVE = 1 << 0, Gtk::StateFlags::PRELIGHT = 1 << 1, Gtk::StateFlags::SELECTED = 1 << 2, Gtk::StateFlags::INSENSITIVE = 1 << 3, Gtk::StateFlags::INCONSISTENT = 1 << 4, Gtk::StateFlags::FOCUSED = 1 << 5, Gtk::StateFlags::BACKDROP = 1 << 6, Gtk::StateFlags::DIR_LTR = 1 << 7, Gtk::StateFlags::DIR_RTL = 1 << 8, Gtk::StateFlags::LINK = 1 << 9, Gtk::StateFlags::VISITED = 1 << 10, Gtk::StateFlags::CHECKED = 1 << 11, Gtk::StateFlags::DROP_ACTIVE = 1 << 12, Gtk::StateFlags::FOCUS_VISIBLE = 1 << 13 }
| Describes a widget state. More...
enum | Gtk::InputPurpose { Gtk::InputPurpose::FREE_FORM, Gtk::InputPurpose::ALPHA, Gtk::InputPurpose::DIGITS, Gtk::InputPurpose::NUMBER, Gtk::InputPurpose::PHONE, Gtk::InputPurpose::URL, Gtk::InputPurpose::EMAIL, Gtk::InputPurpose::NAME, Gtk::InputPurpose::PASSWORD, Gtk::InputPurpose::PIN }
| Describes primary purpose of the input widget. More...
enum | Gtk::InputHints { Gtk::InputHints::NONE = 0x0, Gtk::InputHints::SPELLCHECK = 1 << 0, Gtk::InputHints::NO_SPELLCHECK = 1 << 1, Gtk::InputHints::WORD_COMPLETION = 1 << 2, Gtk::InputHints::LOWERCASE = 1 << 3, Gtk::InputHints::UPPERCASE_CHARS = 1 << 4, Gtk::InputHints::UPPERCASE_WORDS = 1 << 5, Gtk::InputHints::UPPERCASE_SENTENCES = 1 << 6, Gtk::InputHints::INHIBIT_OSK = 1 << 7, Gtk::InputHints::VERTICAL_WRITING = 1 << 8, Gtk::InputHints::EMOJI = 1 << 9, Gtk::InputHints::NO_EMOJI = 1 << 10 }
| Describes hints that might be taken into account by input methods or applications. More...
enum | Gtk::BaselinePosition { Gtk::BaselinePosition::TOP, Gtk::BaselinePosition::CENTER, Gtk::BaselinePosition::BOTTOM }
| Whenever a container has some form of natural row it may align children in that row along a common typographical baseline. More...
enum | Gtk::PropagationPhase { Gtk::PropagationPhase::NONE, Gtk::PropagationPhase::CAPTURE, Gtk::PropagationPhase::BUBBLE, Gtk::PropagationPhase::TARGET }
| Describes the stage at which events are fed into a Gtk::EventController. More...
enum | Gtk::FileChooser::Action { Gtk::FileChooser::Action::OPEN, Gtk::FileChooser::Action::SAVE, Gtk::FileChooser::Action::SELECT_FOLDER, Gtk::FileChooser::Action::CREATE_FOLDER }
| Describes whether a Gtk::FileChooser is being used to open existing files or to save to a possibly new file. More...
enum | Gtk::FileChooser::Confirmation { Gtk::FileChooser::Confirmation::CONFIRM, Gtk::FileChooser::Confirmation::ACCEPT_FILENAME, Gtk::FileChooser::Confirmation::SELECT_AGAIN }
| Used as a return value of handlers for the Gtk::FileChooser::signal_confirm_overwrite() signal of a Gtk::FileChooser. More...
enum | Gtk::FileFilter::Flags { Gtk::FileFilter::Flags::FILENAME = 1 << 0, Gtk::FileFilter::Flags::URI = 1 << 1, Gtk::FileFilter::Flags::DISPLAY_NAME = 1 << 2, Gtk::FileFilter::Flags::MIME_TYPE = 1 << 3 }
| These flags indicate what parts of a Gtk::FileFilterInfo struct are filled or need to be filled. More...
enum | Gtk::FontChooser::Level { Gtk::FontChooser::Level::FONT, Gtk::FontChooser::Level::FACE, Gtk::FontChooser::Level::FAMILY }
| This enumeration specifies the granularity of font selection that is desired in a font chooser. More...
enum | Gtk::EventSequenceState { Gtk::EventSequenceState::NONE, Gtk::EventSequenceState::CLAIMED, Gtk::EventSequenceState::DENIED }
| Describes the state of a Gdk::EventSequence in a Gtk::Gesture. More...
enum | Gtk::PanDirection { Gtk::PanDirection::LEFT, Gtk::PanDirection::RIGHT, Gtk::PanDirection::UP, Gtk::PanDirection::DOWN }
| Describes the panning direction of a Gtk::GesturePan. More...
enum | Gtk::IconLookupFlags { Gtk::IconLookupFlags::NO_SVG = 1 << 0, Gtk::IconLookupFlags::FORCE_SVG = 1 << 1, Gtk::IconLookupFlags::USE_BUILTIN = 1 << 2, Gtk::IconLookupFlags::GENERIC_FALLBACK = 1 << 3, Gtk::IconLookupFlags::FORCE_SIZE = 1 << 4, Gtk::IconLookupFlags::FORCE_REGULAR = 1 << 5, Gtk::IconLookupFlags::FORCE_SYMBOLIC = 1 << 6, Gtk::IconLookupFlags::DIR_LTR = 1 << 7, Gtk::IconLookupFlags::DIR_RTL = 1 << 8 }
| Used to specify options for Gtk::IconTheme::lookup_icon() More...
enum | Gtk::IconView::DropPosition { Gtk::IconView::DropPosition::NO_DROP, Gtk::IconView::DropPosition::DROP_INTO, Gtk::IconView::DropPosition::DROP_LEFT, Gtk::IconView::DropPosition::DROP_RIGHT, Gtk::IconView::DropPosition::DROP_ABOVE, Gtk::IconView::DropPosition::DROP_BELOW }
| An enum for determining where a dropped item goes. More...
enum | Gtk::Image::Type { Gtk::Image::Type::EMPTY, Gtk::Image::Type::ICON_NAME, Gtk::Image::Type::GICON, Gtk::Image::Type::SURFACE, Gtk::Image::Type::TEXTURE }
| Describes the image data representation used by a Gtk::Image. More...
enum | Gtk::LevelBar::Mode { Gtk::LevelBar::Mode::CONTINUOUS, Gtk::LevelBar::Mode::DISCRETE }
| Describes how Gtk::LevelBar contents should be rendered. More...
enum | Gtk::PackDirection { Gtk::PackDirection::LTR, Gtk::PackDirection::RTL, Gtk::PackDirection::TTB, Gtk::PackDirection::BTT }
| Determines how widgets should be packed inside menubars and menuitems contained in menubars. More...
enum | Gtk::ButtonsType { Gtk::ButtonsType::NONE, Gtk::ButtonsType::OK, Gtk::ButtonsType::CLOSE, Gtk::ButtonsType::CANCEL, Gtk::ButtonsType::YES_NO, Gtk::ButtonsType::OK_CANCEL }
| Prebuilt sets of buttons for the dialog. More...
enum | Gtk::ButtonRole { Gtk::ButtonRole::NORMAL, Gtk::ButtonRole::CHECK, Gtk::ButtonRole::RADIO }
| The role specifies the desired appearance of a Gtk::ModelButton. More...
enum | Gtk::Unit { Gtk::Unit::NONE, Gtk::Unit::POINTS, Gtk::Unit::INCH, Gtk::Unit::MM }
| See also Gtk::PrintSettings::set_paper_width(). More...
enum | Gtk::Popover::Constraint { Gtk::Popover::Constraint::NONE, Gtk::Popover::Constraint::WINDOW }
| Describes constraints to positioning of popovers. More...
enum | Gtk::PrintStatus { Gtk::PrintStatus::INITIAL, Gtk::PrintStatus::PREPARING, Gtk::PrintStatus::GENERATING_DATA, Gtk::PrintStatus::SENDING_DATA, Gtk::PrintStatus::PENDING, Gtk::PrintStatus::PENDING_ISSUE, Gtk::PrintStatus::PRINTING, Gtk::PrintStatus::FINISHED, Gtk::PrintStatus::FINISHED_ABORTED }
| The status gives a rough indication of the completion of a running print operation. More...
enum | Gtk::PrintOperation::Result { Gtk::PrintOperation::Result::ERROR, Gtk::PrintOperation::Result::APPLY, Gtk::PrintOperation::Result::CANCEL, Gtk::PrintOperation::Result::IN_PROGRESS }
| A value of this type is returned by Gtk::PrintOperation::run(). More...
enum | Gtk::PrintOperation::Action { Gtk::PrintOperation::Action::PRINT_DIALOG, Gtk::PrintOperation::Action::PRINT, Gtk::PrintOperation::Action::PREVIEW, Gtk::PrintOperation::Action::EXPORT }
| The action parameter to Gtk::PrintOperation::run() determines what action the print operation should perform. More...
enum | Gtk::PrintDuplex { Gtk::PrintDuplex::SIMPLEX, Gtk::PrintDuplex::HORIZONTAL, Gtk::PrintDuplex::VERTICAL }
| See also Gtk::PrintSettings::set_duplex(). More...
enum | Gtk::PrintQuality { Gtk::PrintQuality::LOW, Gtk::PrintQuality::NORMAL, Gtk::PrintQuality::HIGH, Gtk::PrintQuality::DRAFT }
| See also Gtk::PrintSettings::set_quality(). More...
enum | Gtk::PrintPages { Gtk::PrintPages::ALL, Gtk::PrintPages::CURRENT, Gtk::PrintPages::RANGES, Gtk::PrintPages::SELECTION }
| See also Gtk::PrintJob::set_pages() More...
enum | Gtk::PageSet { Gtk::PageSet::ALL, Gtk::PageSet::EVEN, Gtk::PageSet::ODD }
| See also Gtk::PrintJob::set_page_set(). More...
enum | Gtk::NumberUpLayout { Gtk::NumberUpLayout::LEFT_TO_RIGHT_TOP_TO_BOTTOM, Gtk::NumberUpLayout::LEFT_TO_RIGHT_BOTTOM_TO_TOP, Gtk::NumberUpLayout::RIGHT_TO_LEFT_TOP_TO_BOTTOM, Gtk::NumberUpLayout::RIGHT_TO_LEFT_BOTTOM_TO_TOP, Gtk::NumberUpLayout::TOP_TO_BOTTOM_LEFT_TO_RIGHT, Gtk::NumberUpLayout::TOP_TO_BOTTOM_RIGHT_TO_LEFT, Gtk::NumberUpLayout::BOTTOM_TO_TOP_LEFT_TO_RIGHT, Gtk::NumberUpLayout::BOTTOM_TO_TOP_RIGHT_TO_LEFT }
| Used to determine the layout of pages on a sheet when printing multiple pages per sheet. More...
enum | Gtk::Scrollable::Policy { Gtk::Scrollable::Policy::MINIMUM, Gtk::Scrollable::Policy::NATURAL }
| Defines the policy to be used in a scrollable widget when updating the scrolled window adjustments in a given orientation. More...
enum | Gtk::ShortcutType { Gtk::ShortcutType::ACCELERATOR, Gtk::ShortcutType::GESTURE_PINCH, Gtk::ShortcutType::GESTURE_STRETCH, Gtk::ShortcutType::GESTURE_ROTATE_CLOCKWISE, Gtk::ShortcutType::GESTURE_ROTATE_COUNTERCLOCKWISE, Gtk::ShortcutType::GESTURE_TWO_FINGER_SWIPE_LEFT, Gtk::ShortcutType::GESTURE_TWO_FINGER_SWIPE_RIGHT, Gtk::ShortcutType::GESTURE, Gtk::ShortcutType::GESTURE_SWIPE_LEFT, Gtk::ShortcutType::GESTURE_SWIPE_RIGHT }
| GtkShortcutType specifies the kind of shortcut that is being described. More...
enum | Gtk::SizeGroup::Mode { Gtk::SizeGroup::Mode::NONE, Gtk::SizeGroup::Mode::HORIZONTAL, Gtk::SizeGroup::Mode::VERTICAL, Gtk::SizeGroup::Mode::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 | Gtk::SpinType { Gtk::SpinType::STEP_FORWARD, Gtk::SpinType::STEP_BACKWARD, Gtk::SpinType::PAGE_FORWARD, Gtk::SpinType::PAGE_BACKWARD, Gtk::SpinType::HOME, Gtk::SpinType::END, Gtk::SpinType::USER_DEFINED }
| The values of the GtkSpinType enumeration are used to specify the change to make in Gtk::SpinButton::spin(). More...
enum | Gtk::SpinButton::UpdatePolicy { Gtk::SpinButton::UpdatePolicy::ALWAYS, Gtk::SpinButton::UpdatePolicy::IF_VALID }
| The spin button update policy determines whether the spin button displays values even if they are outside the bounds of its adjustment. More...
enum | Gtk::TextSearchFlags { Gtk::TextSearchFlags::VISIBLE_ONLY = 1 << 0, Gtk::TextSearchFlags::TEXT_ONLY = 1 << 1, Gtk::TextSearchFlags::CASE_INSENSITIVE = 1 << 2 }
| Flags affecting how a search is done. More...
enum | Gtk::TextWindowType { Gtk::TextWindowType::PRIVATE, Gtk::TextWindowType::WIDGET, Gtk::TextWindowType::TEXT, Gtk::TextWindowType::LEFT, Gtk::TextWindowType::RIGHT, Gtk::TextWindowType::TOP, Gtk::TextWindowType::BOTTOM }
| Used to reference the parts of Gtk::TextView. More...
enum | Gtk::TreeModel::Flags { Gtk::TreeModel::Flags::ITERS_PERSIST = 1 << 0, Gtk::TreeModel::Flags::LIST_ONLY = 1 << 1 }
| These flags indicate various properties of a Gtk::TreeModel. More...
enum | Gtk::TreeView::DropPosition { Gtk::TreeView::DropPosition::BEFORE, Gtk::TreeView::DropPosition::AFTER, Gtk::TreeView::DropPosition::INTO_OR_BEFORE, Gtk::TreeView::DropPosition::INTO_OR_AFTER }
| An enum for determining where a dropped row goes. More...
enum | Gtk::TreeView::GridLines { Gtk::TreeView::GridLines::NONE, Gtk::TreeView::GridLines::HORIZONTAL, Gtk::TreeView::GridLines::VERTICAL, Gtk::TreeView::GridLines::BOTH }
| Used to indicate which grid lines to draw in a tree view. More...
enum | Gtk::TreeViewColumn::Sizing { Gtk::TreeViewColumn::Sizing::GROW_ONLY, Gtk::TreeViewColumn::Sizing::AUTOSIZE, Gtk::TreeViewColumn::Sizing::FIXED }
| The sizing method the column uses to determine its width. More...
enum | Gtk::DestDefaults { Gtk::DestDefaults::MOTION = 1 << 0, Gtk::DestDefaults::HIGHLIGHT = 1 << 1, Gtk::DestDefaults::DROP = 1 << 2, Gtk::DestDefaults::ALL = 0x07 }
| The Gtk::DestDefaults enumeration specifies the various types of action that will be taken on behalf of the user for a drag destination site. More...
enum | Gtk::DragResult { Gtk::DragResult::SUCCESS, Gtk::DragResult::NO_TARGET, Gtk::DragResult::USER_CANCELLED, Gtk::DragResult::TIMEOUT_EXPIRED, Gtk::DragResult::GRAB_BROKEN, Gtk::DragResult::ERROR }
| Gives an indication why a drag operation failed. More...
enum | Gtk::PrintCapabilities { Gtk::PrintCapabilities::PAGE_SET = 1 << 0, Gtk::PrintCapabilities::COPIES = 1 << 1, Gtk::PrintCapabilities::COLLATE = 1 << 2, Gtk::PrintCapabilities::REVERSE = 1 << 3, Gtk::PrintCapabilities::SCALE = 1 << 4, Gtk::PrintCapabilities::GENERATE_PDF = 1 << 5, Gtk::PrintCapabilities::GENERATE_PS = 1 << 6, Gtk::PrintCapabilities::PREVIEW = 1 << 7, Gtk::PrintCapabilities::NUMBER_UP = 1 << 8, Gtk::PrintCapabilities::NUMBER_UP_LAYOUT = 1 << 9 }
| An enum for specifying which features the print dialog should offer. 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)
Calendar::DisplayOptions | Gtk::operator| (Calendar::DisplayOptions lhs, Calendar::DisplayOptions rhs)
Calendar::DisplayOptions | Gtk::operator& (Calendar::DisplayOptions lhs, Calendar::DisplayOptions rhs)
Calendar::DisplayOptions | Gtk::operator^ (Calendar::DisplayOptions lhs, Calendar::DisplayOptions rhs)
Calendar::DisplayOptions | Gtk::operator~ (Calendar::DisplayOptions flags)
Calendar::DisplayOptions& | Gtk::operator|= (Calendar::DisplayOptions& lhs, Calendar::DisplayOptions rhs)
Calendar::DisplayOptions& | Gtk::operator&= (Calendar::DisplayOptions& lhs, Calendar::DisplayOptions rhs)
Calendar::DisplayOptions& | Gtk::operator^= (Calendar::DisplayOptions& lhs, Calendar::DisplayOptions 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)
AccelFlags | Gtk::operator| (AccelFlags lhs, AccelFlags rhs)
AccelFlags | Gtk::operator& (AccelFlags lhs, AccelFlags rhs)
AccelFlags | Gtk::operator^ (AccelFlags lhs, AccelFlags rhs)
AccelFlags | Gtk::operator~ (AccelFlags flags)
AccelFlags& | Gtk::operator|= (AccelFlags& lhs, AccelFlags rhs)
AccelFlags& | Gtk::operator&= (AccelFlags& lhs, AccelFlags rhs)
AccelFlags& | Gtk::operator^= (AccelFlags& lhs, AccelFlags rhs)
PlacesOpenFlags | Gtk::operator| (PlacesOpenFlags lhs, PlacesOpenFlags rhs)
PlacesOpenFlags | Gtk::operator& (PlacesOpenFlags lhs, PlacesOpenFlags rhs)
PlacesOpenFlags | Gtk::operator^ (PlacesOpenFlags lhs, PlacesOpenFlags rhs)
PlacesOpenFlags | Gtk::operator~ (PlacesOpenFlags flags)
PlacesOpenFlags& | Gtk::operator|= (PlacesOpenFlags& lhs, PlacesOpenFlags rhs)
PlacesOpenFlags& | Gtk::operator&= (PlacesOpenFlags& lhs, PlacesOpenFlags rhs)
PlacesOpenFlags& | Gtk::operator^= (PlacesOpenFlags& lhs, PlacesOpenFlags 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)
FileFilter::Flags | Gtk::operator| (FileFilter::Flags lhs, FileFilter::Flags rhs)
FileFilter::Flags | Gtk::operator& (FileFilter::Flags lhs, FileFilter::Flags rhs)
FileFilter::Flags | Gtk::operator^ (FileFilter::Flags lhs, FileFilter::Flags rhs)
FileFilter::Flags | Gtk::operator~ (FileFilter::Flags flags)
FileFilter::Flags& | Gtk::operator|= (FileFilter::Flags& lhs, FileFilter::Flags rhs)
FileFilter::Flags& | Gtk::operator&= (FileFilter::Flags& lhs, FileFilter::Flags rhs)
FileFilter::Flags& | Gtk::operator^= (FileFilter::Flags& lhs, FileFilter::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)
TextSearchFlags | Gtk::operator| (TextSearchFlags lhs, TextSearchFlags rhs)
TextSearchFlags | Gtk::operator& (TextSearchFlags lhs, TextSearchFlags rhs)
TextSearchFlags | Gtk::operator^ (TextSearchFlags lhs, TextSearchFlags rhs)
TextSearchFlags | Gtk::operator~ (TextSearchFlags flags)
TextSearchFlags& | Gtk::operator|= (TextSearchFlags& lhs, TextSearchFlags rhs)
TextSearchFlags& | Gtk::operator&= (TextSearchFlags& lhs, TextSearchFlags rhs)
TextSearchFlags& | Gtk::operator^= (TextSearchFlags& lhs, TextSearchFlags rhs)
TreeModel::Flags | Gtk::operator| (TreeModel::Flags lhs, TreeModel::Flags rhs)
TreeModel::Flags | Gtk::operator& (TreeModel::Flags lhs, TreeModel::Flags rhs)
TreeModel::Flags | Gtk::operator^ (TreeModel::Flags lhs, TreeModel::Flags rhs)
TreeModel::Flags | Gtk::operator~ (TreeModel::Flags flags)
TreeModel::Flags& | Gtk::operator|= (TreeModel::Flags& lhs, TreeModel::Flags rhs)
TreeModel::Flags& | Gtk::operator&= (TreeModel::Flags& lhs, TreeModel::Flags rhs)
TreeModel::Flags& | Gtk::operator^= (TreeModel::Flags& lhs, TreeModel::Flags rhs)
DestDefaults | Gtk::operator| (DestDefaults lhs, DestDefaults rhs)
DestDefaults | Gtk::operator& (DestDefaults lhs, DestDefaults rhs)
DestDefaults | Gtk::operator^ (DestDefaults lhs, DestDefaults rhs)
DestDefaults | Gtk::operator~ (DestDefaults flags)
DestDefaults& | Gtk::operator|= (DestDefaults& lhs, DestDefaults rhs)
DestDefaults& | Gtk::operator&= (DestDefaults& lhs, DestDefaults rhs)
DestDefaults& | Gtk::operator^= (DestDefaults& lhs, DestDefaults rhs)
PrintCapabilities | Gtk::operator| (PrintCapabilities lhs, PrintCapabilities rhs)
PrintCapabilities | Gtk::operator& (PrintCapabilities lhs, PrintCapabilities rhs)
PrintCapabilities | Gtk::operator^ (PrintCapabilities lhs, PrintCapabilities rhs)
PrintCapabilities | Gtk::operator~ (PrintCapabilities flags)
PrintCapabilities& | Gtk::operator|= (PrintCapabilities& lhs, PrintCapabilities rhs)
PrintCapabilities& | Gtk::operator&= (PrintCapabilities& lhs, PrintCapabilities rhs)
PrintCapabilities& | Gtk::operator^= (PrintCapabilities& lhs, PrintCapabilities rhs)

## Detailed Description

## Typedef Documentation

## ◆ ResponseType

using Gtk::ResponseType = typedef ResponseType_Wrapper::ResponseType

ResponseType 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 |

## ◆ AccelFlags

enum Gtk::AccelFlags
| strong

Accelerator flags used with Gtk::AccelGroup::connect().

Bitwise operators:
  `AccelFlags operator|(AccelFlags, AccelFlags)`
  `AccelFlags operator&(AccelFlags, AccelFlags)`
  `AccelFlags operator^(AccelFlags, AccelFlags)`
  `AccelFlags operator~(AccelFlags)`
  `AccelFlags& operator|=(AccelFlags&, AccelFlags)`
  `AccelFlags& operator&=(AccelFlags&, AccelFlags)`
  `AccelFlags& operator^=(AccelFlags&, AccelFlags)`

Enumerator
VISIBLE | Accelerator is visible.
LOCKED | Accelerator not removable.
MASK | Mask.

## ◆ 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.
CREATE_FOLDER | Indicates a mode for creating a new folder. The file chooser will let the user name an existing or new folder.

## ◆ Action [2/2]

enum Gtk::PrintOperation::Action
| strong

The action parameter to Gtk::PrintOperation::run() determines what action the print operation should perform.

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 (x or y) dimension.

Alignment only matters if the widget receives a “too large” allocation, for example if you packed the widget with the Gtk::Widget::property_expand() flag 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 for it is optional for containers and widgets, and it is only supported for vertical alignment. When its not supported by a child or a container it is treated as GTK_ALIGN_FILL.

Enumerator
FILL | Stretch to fill all space if possible, center if no meaningful way to stretch. The text is placed is distributed across the label.
START | Snap to left or top side, leaving space on right or bottom. Scroll to start. The child is packed into the start of the box. Buttons are grouped towards the start of the box, (on the left for a HBox, or the top for a VBox).
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 box. Buttons are grouped towards the end of the box, (on the right for a HBox, or the bottom for a VBox).
CENTER | Center natural width of widget inside the allocation. Center the baseline. Windows should be placed in the center of the screen. The text is placed in the center of the label. Buttons are centered in the box. Since gtkmm 2.12:
BASELINE | Align the widget according to the baseline. Since gtkmm 3.10:

## ◆ 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 units. No buttons at all. The sequence is handled, but not grabbed. Events are not delivered automatically. No special behaviour suggested. Do not wrap lines; just make the text area wider. No influence is made on placement. No outline. No selection is possible. No scrolling. No transition. No relief. No direction. Since gtkmm 2.10: Those can be manually fed through Gtk::EventController::handle_event(). This should only be used when full control about when, or whether the controller handles the event is needed.

## ◆ BaselinePosition

enum Gtk::BaselinePosition
| strong

Whenever a container has some form of natural row it may align children in that row along a common typographical baseline.

If the amount of verical 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 availible space.

Enumerator
TOP |
CENTER |
BOTTOM |

## ◆ ButtonBoxStyle

enum Gtk::ButtonBoxStyle
| strong

Used to dictate the style that a Gtk::ButtonBox uses to layout the buttons it contains.

Enumerator
SPREAD | Buttons are evenly spread across the box.
EDGE | Buttons are placed at the edges of the box.
START |
END |
CENTER |
EXPAND | Buttons expand to fill the box. This entails giving buttons a "linked" appearance, making button sizes homogeneous, and setting spacing to 0 (same as calling Gtk::Box::set_homogeneous() and Gtk::Box::set_spacing() manually). Since gtkmm 3.12:

## ◆ ButtonRole

enum Gtk::ButtonRole
| strong

The role specifies the desired appearance of a Gtk::ModelButton.

Enumerator
NORMAL |
CHECK | A check button.
RADIO | A radio button.

## ◆ ButtonsType

enum Gtk::ButtonsType
| strong

Prebuilt sets of buttons for the dialog.

If none of these choices are appropriate, simply use Gtk::ButtonsType::NONE then call Gtk::Dialog::add_buttons().

> Please note that Gtk::ButtonsType::OK, Gtk::ButtonsType::YES_NO and Gtk::ButtonsType::OK_CANCEL are discouraged by the GNOME Human Interface Guidelines.

Enumerator
NONE |
OK | An OK button.
CLOSE | A Close button.
CANCEL | A Cancel button.
YES_NO | Yes and No buttons.
OK_CANCEL | OK and Cancel buttons.

## ◆ 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 | The cell is currently selected, and probably has a selection colored background to render to. Widget is selected.
PRELIT | The mouse is hovering over the cell.
INSENSITIVE | The cell is drawn in an insensitive manner. Widget is insensitive.
SORTED | The cell is in a sorted row.
FOCUSED | The cell is in the focus row. Widget has the keyboard focus.
EXPANDABLE | The cell is in a row that can be expanded. Since gtkmm 3.4:
EXPANDED | The cell is in a row that is expanded. Since gtkmm 3.4:

## ◆ Confirmation

enum Gtk::FileChooser::Confirmation
| strong

Used as a return value of handlers for the Gtk::FileChooser::signal_confirm_overwrite() signal of a Gtk::FileChooser.

This value determines whether the file chooser will present the stock confirmation dialog, accept the user’s choice of a filename, or let the user choose another filename.

Enumerator
CONFIRM | The file chooser will present its stock dialog to confirm about overwriting an existing file.
ACCEPT_FILENAME | The file chooser will terminate and accept the user’s choice of a file name.
SELECT_AGAIN | The file chooser will continue running, so as to let the user select another file name.

## ◆ Constraint

enum Gtk::Popover::Constraint
| strong

Describes constraints to positioning of popovers.

More values may be added to this enumeration in the future.

Enumerator
NONE | Don't constrain the popover position beyond what is imposed by the implementation.
WINDOW | Constrain the popover to the boundaries of the window that it is attached to.

## ◆ CornerType

enum Gtk::CornerType
| strong

Specifies which corner a child widget should be placed in when packed into a Gtk::ScrolledWindow.

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

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

See also: Gtk::Entry::signal_delete_from_cursor().

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

## ◆ DestDefaults

enum Gtk::DestDefaults
| strong

The Gtk::DestDefaults enumeration specifies the various types of action that will be taken on behalf of the user for a drag destination site.

Bitwise operators:
  `DestDefaults operator|(DestDefaults, DestDefaults)`
  `DestDefaults operator&(DestDefaults, DestDefaults)`
  `DestDefaults operator^(DestDefaults, DestDefaults)`
  `DestDefaults operator~(DestDefaults)`
  `DestDefaults& operator|=(DestDefaults&, DestDefaults)`
  `DestDefaults& operator&=(DestDefaults&, DestDefaults)`
  `DestDefaults& operator^=(DestDefaults&, DestDefaults)`

Enumerator
MOTION | If set for a widget, GTK+, during a drag over this widget will check if the drag matches this widget’s list of possible formats and actions. GTK+ will then call gdk_drag_status() as appropriate.
HIGHLIGHT | If set for a widget, GTK+ will draw a highlight on this widget as long as a drag is over this widget and the widget drag format and action are acceptable.
DROP | If set for a widget, when a drop occurs, GTK+ will will check if the drag matches this widget’s list of possible formats and actions. If so, GTK+ will call gtk_drag_get_data() on behalf of the widget. Whether or not the drop is successful, GTK+ will call gtk_drag_finish(). If the action was a move, then if the drag was successful, then `true` will be passed for the delete parameter to gtk_drag_finish().
ALL |

## ◆ DirectionType

enum Gtk::DirectionType
| strong

Focus movement types.

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

## ◆ DisplayOptions

enum Gtk::Calendar::DisplayOptions
| strong

These options can be used to influence the display and behaviour of a Gtk::Calendar.

Bitwise operators:
  `Calendar::DisplayOptions operator|(Calendar::DisplayOptions, Calendar::DisplayOptions)`
  `Calendar::DisplayOptions operator&(Calendar::DisplayOptions, Calendar::DisplayOptions)`
  `Calendar::DisplayOptions operator^(Calendar::DisplayOptions, Calendar::DisplayOptions)`
  `Calendar::DisplayOptions operator~(Calendar::DisplayOptions)`
  `Calendar::DisplayOptions& operator|=(Calendar::DisplayOptions&, Calendar::DisplayOptions)`
  `Calendar::DisplayOptions& operator&=(Calendar::DisplayOptions&, Calendar::DisplayOptions)`
  `Calendar::DisplayOptions& operator^=(Calendar::DisplayOptions&, Calendar::DisplayOptions)`

Enumerator
SHOW_HEADING | Specifies that the month and year should be displayed.
SHOW_DAY_NAMES | Specifies that three letter day descriptions should be present.
NO_MONTH_CHANGE | Prevents the user from switching months with the calendar.
SHOW_WEEK_NUMBERS | Displays each week numbers of the current year, down the left side of the calendar.
SHOW_DETAILS | Just show an indicator, not the full details text when details are provided. See Gtk::Calendar::set_detail_func().

## ◆ DragResult

enum Gtk::DragResult
| strong

Gives an indication why a drag operation failed.

The value can by obtained by connecting to the Gtk::Widget::signal_drag_failed() signal.

Enumerator
SUCCESS | The drag operation was successful.
NO_TARGET | No suitable drag target.
USER_CANCELLED | The user cancelled the drag operation.
TIMEOUT_EXPIRED | The drag operation timed out.
GRAB_BROKEN | The pointer or keyboard grab used for the drag operation was broken.
ERROR |

## ◆ 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 | Droppped 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/2]

enum Gtk::FileFilter::Flags
| strong

These flags indicate what parts of a Gtk::FileFilterInfo struct are filled or need to be filled.

Bitwise operators:
  `FileFilter::Flags operator|(FileFilter::Flags, FileFilter::Flags)`
  `FileFilter::Flags operator&(FileFilter::Flags, FileFilter::Flags)`
  `FileFilter::Flags operator^(FileFilter::Flags, FileFilter::Flags)`
  `FileFilter::Flags operator~(FileFilter::Flags)`
  `FileFilter::Flags& operator|=(FileFilter::Flags&, FileFilter::Flags)`
  `FileFilter::Flags& operator&=(FileFilter::Flags&, FileFilter::Flags)`
  `FileFilter::Flags& operator^=(FileFilter::Flags&, FileFilter::Flags)`

Enumerator
FILENAME | The filename of the file being tested.
URI | The URI for the file being tested.
DISPLAY_NAME | The string that will be used to display the file in the file chooser.
MIME_TYPE | The mime type of the file.

## ◆ Flags [2/2]

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.

## ◆ 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
NO_SVG | Never get SVG icons, even if gdk-pixbuf supports them. Cannot be used together with Gtk::IconLookupFlags::FORCE_SVG.
FORCE_SVG | Get SVG icons, even if gdk-pixbuf doesn’t support them. Cannot be used together with Gtk::IconLookupFlags::NO_SVG.
USE_BUILTIN | When passed to Gtk::IconTheme::lookup_icon() includes builtin icons as well as files. For a builtin icon, Gtk::IconInfo::get_filename() is `nullptr` and you need to call gtk_icon_info_get_builtin_pixbuf().
GENERIC_FALLBACK | Try to shorten icon name at '-' characters before looking at inherited themes. This flag is only supported in functions that take a single icon name. For more general fallback, see Gtk::IconTheme::choose_icon(). Since gtkmm 2.12:
FORCE_SIZE | Always get the icon scaled to the requested size. Since gtkmm 2.14:
FORCE_REGULAR | Try to always load regular icons, even when symbolic icon names are given. Since gtkmm 3.14:
FORCE_SYMBOLIC | Try to always load symbolic icons, even when regular icon names are given. Since gtkmm 3.14:
DIR_LTR |
DIR_RTL |

## ◆ 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 GtkIconSize set the normal-icons or large-icons style classes correspondingly, and let themes determine the actual size to be used with the -gtk-icon-size CSS property.

Enumerator
INHERIT | Keep the size of the parent element.
NORMAL | Size similar to text size. Normal quality. A plain button. State during normal operation. Draw a normal relief.
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::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_INPUT_HINT_LOWERCASE with any of the uppercase hints makes no sense.

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

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. Since gtkmm 3.18:
EMOJI | Suggest offering Emoji support. {3,22,20}
NO_EMOJI | Suggest not offering Emoji support. {3,22,20}

## ◆ 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_INPUT_PURPOSE_DIGITS and GTK_INPUT_PURPOSE_NUMBER is that the former accepts only digits while the latter also some punctuation (like commas or points, plus, minus) and “e” or “E” as in 3.14E+000.

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

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_INPUT_PURPOSE_FREE_FORM, but characters are hidden.
PIN | Like GTK_INPUT_PURPOSE_DIGITS, but characters are hidden.

## ◆ Justification

enum Gtk::Justification
| strong

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

(See also Gtk::Alignment).

Enumerator
LEFT |
RIGHT |
CENTER |
FILL |

## ◆ Level

enum Gtk::FontChooser::Level
| strong

This enumeration specifies the granularity of font selection that is desired in a font chooser.

Enumerator
FONT | Select an individual font, including a size. An example would be: "Arial Bold 11".
FACE | Select a font face, without a size. An example would be: "Arial Bold".
FAMILY | Select a font family, without specifying the face. An example would be: "Arial".

## ◆ 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.

## ◆ MenuDirectionType

enum Gtk::MenuDirectionType
| strong

An enumeration representing directional movements within a menu.

Enumerator
PARENT | To the parent menu shell.
CHILD | To the submenu, if any, associated with the item.
NEXT | To the next menu item.
PREV | To the previous menu item.

## ◆ Mode [1/3]

enum Gtk::CellRendererAccel::Mode
| strong

Determines if the edited accelerators are GTK+ accelerators.

If they are, consumed modifiers are suppressed, only accelerators accepted by GTK+ are allowed, and the accelerators are rendered in the same way as they are in menus.

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

## ◆ Mode [2/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.

## ◆ Mode [3/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.

## ◆ MovementStep

enum Gtk::MovementStep
| strong

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.

## ◆ 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 | .

## ◆ Orientation

enum Gtk::Orientation
| strong

Represents the orientation of widgets and other objects which can be switched between horizontal and vertical orientation on the fly, like Gtk::Toolbar or Gtk::GesturePan.

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

## ◆ PackDirection

enum Gtk::PackDirection
| strong

Determines how widgets should be packed inside menubars and menuitems contained in menubars.

Enumerator
LTR |
RTL |
TTB | Widgets are packed top-to-bottom.
BTT | Widgets are packed bottom-to-top.

## ◆ PackOptions

enum Gtk::PackOptions
| strong

Packing options for adding child widgets to a Box with pack_start() and pack_end().

Enumerator
SHRINK | Space is contracted to the child widget size.
EXPAND_PADDING | Space is expanded, with extra space filled with padding.
EXPAND_WIDGET | Space is expanded, with extra space filled by increasing the child widget size.

## ◆ PackType

enum Gtk::PackType
| strong

Represents the packing location Gtk::Box children.

(See: Gtk::VBox, Gtk::HBox, and Gtk::ButtonBox).

Enumerator
START |
END |

## ◆ 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.

## ◆ PageType

enum Gtk::Assistant::PageType
| strong

An enum for determining the page role inside the Gtk::Assistant.

It's used to handle buttons sensitivity and visibility.

Note that an assistant needs to end its page flow with a page of type Gtk::Assistant::PageType::CONFIRM, Gtk::Assistant::PageType::SUMMARY or Gtk::Assistant::PageType::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().

## ◆ PanDirection

enum Gtk::PanDirection
| strong

Describes the panning direction of a Gtk::GesturePan.

Enumerator
LEFT |
RIGHT |
UP |
DOWN |

## ◆ PlacesOpenFlags

enum Gtk::PlacesOpenFlags
| strong

Bitwise operators:
  `PlacesOpenFlags operator|(PlacesOpenFlags, PlacesOpenFlags)`
  `PlacesOpenFlags operator&(PlacesOpenFlags, PlacesOpenFlags)`
  `PlacesOpenFlags operator^(PlacesOpenFlags, PlacesOpenFlags)`
  `PlacesOpenFlags operator~(PlacesOpenFlags)`
  `PlacesOpenFlags& operator|=(PlacesOpenFlags&, PlacesOpenFlags)`
  `PlacesOpenFlags& operator&=(PlacesOpenFlags&, PlacesOpenFlags)`
  `PlacesOpenFlags& operator^=(PlacesOpenFlags&, PlacesOpenFlags)`

Enumerator
NORMAL |
NEW_TAB |
NEW_WINDOW |

## ◆ 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, e.g.

the tabs of a Gtk::Notebook, the handle of a Gtk::HandleBox 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

An enum for specifying which features the print dialog should offer.

If neither Gtk::PrintCapabilities::GENERATE_PDF nor Gtk::PrintCapabilities::GENERATE_PS is specified, GTK+ assumes that all formats are supported.

Bitwise operators:
  `PrintCapabilities operator|(PrintCapabilities, PrintCapabilities)`
  `PrintCapabilities operator&(PrintCapabilities, PrintCapabilities)`
  `PrintCapabilities operator^(PrintCapabilities, PrintCapabilities)`
  `PrintCapabilities operator~(PrintCapabilities)`
  `PrintCapabilities& operator|=(PrintCapabilities&, PrintCapabilities)`
  `PrintCapabilities& operator&=(PrintCapabilities&, PrintCapabilities)`
  `PrintCapabilities& operator^=(PrintCapabilities&, PrintCapabilities)`

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. Since gtkmm 2.12:
NUMBER_UP_LAYOUT | Print dialog will allow to rearrange pages when printing multiple pages per sheet. Since gtkmm 2.14:

## ◆ PrintDuplex

enum Gtk::PrintDuplex
| strong

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

Enumerator
SIMPLEX | No duplex.
HORIZONTAL |
VERTICAL |

## ◆ PrintPages

enum Gtk::PrintPages
| strong

See also Gtk::PrintJob::set_pages()

Enumerator
ALL | All pages. If set, specifies that all default actions should be taken.
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.

## ◆ 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.

## ◆ ReliefStyle

enum Gtk::ReliefStyle
| strong

Indicated the relief to be drawn around a Gtk::Button.

Enumerator
NORMAL |
NONE |

## ◆ 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

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.

## ◆ 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 stepper arrows at the end of range widgets.

Enumerator
AUTO | The arrow is made insensitive if the thumb is at the end.
ON | The arrow is always sensitive.
OFF | The arrow is always insensitive.

## ◆ ShadowType

enum Gtk::ShadowType
| strong

Used to change the appearance of an outline typically provided by a Gtk::Frame.

Note that many themes do not differentiate the appearance of the various shadow types: Either their is no visible shadow ( GTK_SHADOW_NONE), or there is (any other value).

Enumerator
NONE |
IN | The outline is bevelled inwards.
OUT | The outline is bevelled outwards like a button.
ETCHED_IN | The outline has a sunken 3d appearance.
ETCHED_OUT | The outline has a raised 3d appearance.

## ◆ 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 Gtk::ShortcutsShortcut::property_accelerator() property will be used.
GESTURE_PINCH | The shortcut is a pinch gesture. GTK+ provides an icon and subtitle.
GESTURE_STRETCH | The shortcut is a stretch gesture. GTK+ provides an icon and subtitle.
GESTURE_ROTATE_CLOCKWISE | The shortcut is a clockwise rotation gesture. GTK+ provides an icon and subtitle.
GESTURE_ROTATE_COUNTERCLOCKWISE | The shortcut is a counterclockwise rotation gesture. GTK+ provides an icon and subtitle.
GESTURE_TWO_FINGER_SWIPE_LEFT | The shortcut is a two-finger swipe gesture. GTK+ provides an icon and subtitle.
GESTURE_TWO_FINGER_SWIPE_RIGHT | The shortcut is a two-finger swipe gesture. GTK+ provides an icon and subtitle.
GESTURE | The shortcut is a gesture. The Gtk::ShortcutsShortcut::property_icon() property will be used.
GESTURE_SWIPE_LEFT | The shortcut is a swipe gesture. GTK+ provides an icon and subtitle.
GESTURE_SWIPE_RIGHT | The shortcut is a swipe gesture. GTK+ provides an icon and subtitle.

## ◆ 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_TREE_VIEW_COLUMN_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 everytime 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

These enumeration values describe the 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.

## ◆ 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 |
INSENSITIVE |
INCONSISTENT | Widget is inconsistent.
FOCUSED |
BACKDROP | Widget is in a background toplevel window.
DIR_LTR | Widget is in left-to-right text direction. Try to load a variant of the icon for left-to-right text direction. Since gtkmm 3.14:
DIR_RTL | Widget is in right-to-left text direction. Try to load a variant of the icon for right-to-left text direction. Since gtkmm 3.14:
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.

## ◆ TextDirection

enum Gtk::TextDirection
| strong

Reading directions for text.

Enumerator
NONE |
LTR | Left to right text direction. Widgets are packed left-to-right.
RTL | Right to left text direction. Widgets are packed right-to-left.

## ◆ 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 textures 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 textures 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
PRIVATE | Private value, used internally.
WIDGET | Window that floats over scrolling areas.
TEXT |
LEFT |
RIGHT |
TOP |
BOTTOM |

## ◆ ToolbarStyle

enum Gtk::ToolbarStyle
| strong

Used to customize the appearance of a Gtk::Toolbar.

Note that setting the toolbar style overrides the user’s preferences for the default toolbar style. Note that if the button has only a label set and GTK_TOOLBAR_ICONS is used, the label will be visible, and vice versa.

Enumerator
ICONS | Buttons display only icons in the toolbar.
TEXT | Buttons display only text labels in the toolbar. Scrollable text window.
BOTH | Buttons display text and icons in the toolbar.
BOTH_HORIZ | Buttons display icons and text alongside each other, rather than vertically stacked.

## ◆ Type [1/2]

enum Gtk::CssSection::Type
| strong

The different types of sections indicate parts of a CSS document as parsed by GTK’s CSS parser.

They are oriented towards the CSS Grammar, but may contain extensions.

More types might be added in the future as the parser incorporates more features.

Enumerator
DOCUMENT | The section describes a complete document. This section time is the only one where Gtk::CssSection::get_parent() might return `nullptr`.
IMPORT | The section defines an import rule.
COLOR_DEFINITION | The section defines a color. This is a GTK extension to CSS.
BINDING_SET | The section defines a binding set. This is a GTK extension to CSS.
RULESET | The section defines a CSS ruleset.
SELECTOR | The section defines a CSS selector.
DECLARATION | The section defines the declaration of a CSS variable.
VALUE | The section defines the value of a CSS declaration.
KEYFRAMES | The section defines keyframes. See CSS Animations for details. Since gtkmm 3.6:

## ◆ 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. e.g. if the Gtk::Image::get_storage_type() returns Gtk::Image::Type::SURFACE, then you can call Gtk::Image::get_surface(). 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. This image type was added in GTK+ 2.6.
GICON | The widget contains a Gio::Icon. This image type was added in GTK+ 2.14.
SURFACE | The widget contains a #cairo_surface_t. This image type was added in GTK+ 3.10.
TEXTURE | The widget contains a Gdk::Texture. This image type was added in GTK+ 3.94.

## ◆ 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

The spin button update policy determines whether the spin button displays values even if they are outside the bounds of its adjustment.

See Gtk::SpinButton::set_update_policy().

Enumerator
ALWAYS | When refreshing your Gtk::SpinButton, the value is always displayed.
IF_VALID | When refreshing your Gtk::SpinButton, the value is only displayed if it is valid within the bounds of the spin button's adjustment.

## ◆ WindowPosition

enum Gtk::WindowPosition
| strong

Window placement can be influenced using this enumeration.

Note that using Gtk::WindowPosition::CENTER_ALWAYS is almost always a bad idea. It won’t necessarily work well with all window managers or on all windowing systems.

Enumerator
NONE |
CENTER |
MOUSE | Windows should be placed at the current mouse position.
CENTER_ALWAYS | Keep window centered as it changes size, etc.
CENTER_ON_PARENT | Center the window on its transient parent (see Gtk::Window::set_transient_for()).

## ◆ WindowType

enum Gtk::WindowType
| strong

A Gtk::Window can be one of these types.

Most things you’d consider a “window” should have type Gtk::WindowType::TOPLEVEL; windows with this type are managed by the window manager and have a frame by default (call Gtk::Window::set_decorated() to toggle the frame). Windows with type Gtk::WindowType::POPUP are ignored by the window manager; window manager keybindings won’t work on them, the window manager won’t decorate the window with a frame, many GTK+ features that rely on the window manager will not work (e.g. maximization/minimization). Gtk::WindowType::POPUP is used to implement widgets such as Gtk::Menu or tooltips that you normally don’t think of as windows per se. Nearly all windows should be Gtk::WindowType::TOPLEVEL. In particular, do not use Gtk::WindowType::POPUP just to turn off the window borders; use Gtk::Window::set_decorated() for that.

Enumerator
TOPLEVEL | A regular window, such as a dialog.
POPUP | A special window such as a tooltip.

## Function Documentation

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Calendar::DisplayOptions Gtk::operator& | ( | Calendar::DisplayOptions | lhs,
|  | Calendar::DisplayOptions | rhs
| ) |  |
| inline

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Calendar::DisplayOptions Gtk::operator^ | ( | Calendar::DisplayOptions | lhs,
|  | Calendar::DisplayOptions | rhs
| ) |  |
| inline

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Calendar::DisplayOptions Gtk::operator| | ( | Calendar::DisplayOptions | lhs,
|  | Calendar::DisplayOptions | rhs
| ) |  |
| inline

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Calendar::DisplayOptions Gtk::operator~ | ( | Calendar::DisplayOptions | flags | ) |
| inline

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

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

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

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

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

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

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

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

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

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