glibmm  2.84.0
Enumerations | Functions
glibmm Enums and Flags

Enumerations

enum  Glib::Binding::Flags {
  Glib::Binding::Flags::DEFAULT = 0x0,
  Glib::Binding::Flags::BIDIRECTIONAL = 1 << 0,
  Glib::Binding::Flags::SYNC_CREATE = 1 << 1,
  Glib::Binding::Flags::INVERT_BOOLEAN = 1 << 2
}
 Flags to be passed to g_object_bind_property() or g_object_bind_property_full(). More...
 
enum  Glib::Checksum::Type {
  Glib::Checksum::Type::MD5,
  Glib::Checksum::Type::SHA1,
  Glib::Checksum::Type::SHA256,
  Glib::Checksum::Type::SHA512,
  Glib::Checksum::Type::SHA384
}
 The hashing algorithm to be used by Checksum when performing the digest of some data. More...
 
enum  Glib::Date::Month {
  Glib::Date::Month::BAD_MONTH,
  Glib::Date::Month::JANUARY,
  Glib::Date::Month::FEBRUARY,
  Glib::Date::Month::MARCH,
  Glib::Date::Month::APRIL,
  Glib::Date::Month::MAY,
  Glib::Date::Month::JUNE,
  Glib::Date::Month::JULY,
  Glib::Date::Month::AUGUST,
  Glib::Date::Month::SEPTEMBER,
  Glib::Date::Month::OCTOBER,
  Glib::Date::Month::NOVEMBER,
  Glib::Date::Month::DECEMBER
}
 Enumeration representing a month; values are Glib::Date::JANUARY, Glib::Date::FEBRUARY, etc. More...
 
enum  Glib::Date::Weekday {
  Glib::Date::Weekday::BAD_WEEKDAY,
  Glib::Date::Weekday::MONDAY,
  Glib::Date::Weekday::TUESDAY,
  Glib::Date::Weekday::WEDNESDAY,
  Glib::Date::Weekday::THURSDAY,
  Glib::Date::Weekday::FRIDAY,
  Glib::Date::Weekday::SATURDAY,
  Glib::Date::Weekday::SUNDAY
}
 Enumeration representing a day of the week; Glib::Date::MONDAY, Glib::Date::TUESDAY, etc. More...
 
enum  Glib::Date::DMY {
  Glib::Date::DMY::DAY,
  Glib::Date::DMY::MONTH,
  Glib::Date::DMY::YEAR
}
 This enumeration isn't used in the API, but may be useful if you need to mark a number as a day, month, or year. More...
 
enum  Glib::MainContextFlags {
  Glib::MainContextFlags::NONE = 0x0,
  Glib::MainContextFlags::OWNERLESS_POLLING = 0x1
}
 Flags to pass to Glib::MainContext::new_with_flags() which affect the behaviour of a Glib::MainContext. More...
 
enum  Glib::ParamFlags {
  Glib::ParamFlags::READABLE = 1 << 0,
  Glib::ParamFlags::WRITABLE = 1 << 1,
  Glib::ParamFlags::READWRITE = 0x3,
  Glib::ParamFlags::CONSTRUCT = 1 << 2,
  Glib::ParamFlags::CONSTRUCT_ONLY = 1 << 3,
  Glib::ParamFlags::LAX_VALIDATION = 1 << 4,
  Glib::ParamFlags::STATIC_NAME = 1 << 5,
  Glib::ParamFlags::PRIVATE = 0x20,
  Glib::ParamFlags::STATIC_NICK = 1 << 6,
  Glib::ParamFlags::STATIC_BLURB = 1 << 7,
  Glib::ParamFlags::EXPLICIT_NOTIFY = 1 << 30,
  Glib::ParamFlags::DEPRECATED = (gint)(1u << 31)
}
 Through the ParamFlags flag values, certain aspects of parameters can be configured. More...
 
enum  Glib::FileTest {
  Glib::FileTest::IS_REGULAR = 1 << 0,
  Glib::FileTest::IS_SYMLINK = 1 << 1,
  Glib::FileTest::IS_DIR = 1 << 2,
  Glib::FileTest::IS_EXECUTABLE = 1 << 3,
  Glib::FileTest::EXISTS = 1 << 4
}
 A test to perform on a file using g_file_test(). More...
 
enum  Glib::SeekType {
  Glib::SeekType::CUR,
  Glib::SeekType::SET,
  Glib::SeekType::END
}
 An enumeration specifying the base position for a g_io_channel_seek_position() operation. More...
 
enum  Glib::IOStatus {
  Glib::IOStatus::ERROR,
  Glib::IOStatus::NORMAL,
  Glib::IOStatus::ENDOFFILE,
  Glib::IOStatus::AGAIN
}
 Statuses returned by most of the IOFuncs functions. More...
 
enum  Glib::IOFlags {
  Glib::IOFlags::NONE = 0x0,
  Glib::IOFlags::APPEND = 1 << 0,
  Glib::IOFlags::NONBLOCK = 1 << 1,
  Glib::IOFlags::IS_READABLE = 1 << 2,
  Glib::IOFlags::IS_WRITABLE = 1 << 3,
  Glib::IOFlags::IS_WRITEABLE = 1 << 3,
  Glib::IOFlags::IS_SEEKABLE = 1 << 4,
  Glib::IOFlags::MASK = (1 << 5) - 1,
  Glib::IOFlags::GET_MASK = 0x1f,
  Glib::IOFlags::SET_MASK = 0x3
}
 Specifies properties of a IOChannel. More...
 
enum  Glib::IOCondition {
  Glib::IOCondition::IO_IN = G_IO_IN,
  Glib::IOCondition::IO_OUT = G_IO_OUT,
  Glib::IOCondition::IO_PRI = G_IO_PRI,
  Glib::IOCondition::IO_ERR = G_IO_ERR,
  Glib::IOCondition::IO_HUP = G_IO_HUP,
  Glib::IOCondition::IO_NVAL = G_IO_NVAL
}
 A bitwise combination representing a condition to watch for on an event source. More...
 
enum  Glib::KeyFile::Flags {
  Glib::KeyFile::Flags::NONE = 0x0,
  Glib::KeyFile::Flags::KEEP_COMMENTS = 1 << 0,
  Glib::KeyFile::Flags::KEEP_TRANSLATIONS = 1 << 1
}
 Flags which influence the parsing. More...
 
enum  Glib::Markup::ParseFlags {
  Glib::Markup::ParseFlags::DEFAULT_FLAGS = 0x0,
  Glib::Markup::ParseFlags::DO_NOT_USE_THIS_UNSUPPORTED_FLAG = 1 << 0,
  Glib::Markup::ParseFlags::TREAT_CDATA_AS_TEXT = 1 << 1,
  Glib::Markup::ParseFlags::PREFIX_ERROR_POSITION = 1 << 2,
  Glib::Markup::ParseFlags::IGNORE_QUALIFIED = 1 << 3
}
 Flags that affect the behaviour of the parser. More...
 
enum  Glib::UserDirectory {
  Glib::UserDirectory::DESKTOP,
  Glib::UserDirectory::DOCUMENTS,
  Glib::UserDirectory::DOWNLOAD,
  Glib::UserDirectory::MUSIC,
  Glib::UserDirectory::PICTURES,
  Glib::UserDirectory::PUBLIC_SHARE,
  Glib::UserDirectory::TEMPLATES,
  Glib::UserDirectory::VIDEOS,
  Glib::UserDirectory::N_DIRECTORIES
}
 These are logical ids for special directories which are defined depending on the platform used. More...
 
enum  Glib::FormatSizeFlags {
  Glib::FormatSizeFlags::DEFAULT = 0x0,
  Glib::FormatSizeFlags::LONG_FORMAT = 1 << 0,
  Glib::FormatSizeFlags::IEC_UNITS = 1 << 1,
  Glib::FormatSizeFlags::BITS = 1 << 2,
  Glib::FormatSizeFlags::ONLY_VALUE = 1 << 3,
  Glib::FormatSizeFlags::ONLY_UNIT = 1 << 4
}
 Flags to modify the format of the string returned by g_format_size_full(). More...
 
enum  Glib::Module::Flags {
  Glib::Module::Flags::LAZY = 1 << 0,
  Glib::Module::Flags::LOCAL = 1 << 1,
  Glib::Module::Flags::MASK = 0x03
}
 Flags passed to g_module_open(). More...
 
enum  Glib::NodeTree< T >::TraverseType {
  Glib::NodeTree< T >::TraverseType::IN_ORDER,
  Glib::NodeTree< T >::TraverseType::PRE_ORDER,
  Glib::NodeTree< T >::TraverseType::POST_ORDER,
  Glib::NodeTree< T >::TraverseType::LEVEL_ORDER
}
 Specifies the type of traversal performed by g_tree_traverse(), g_node_traverse() and g_node_find(). More...
 
enum  Glib::NodeTree< T >::TraverseFlags {
  Glib::NodeTree< T >::TraverseFlags::LEAVES = G_TRAVERSE_LEAVES,
  Glib::NodeTree< T >::TraverseFlags::NON_LEAVES = G_TRAVERSE_NON_LEAVES,
  Glib::NodeTree< T >::TraverseFlags::ALL = G_TRAVERSE_ALL,
  Glib::NodeTree< T >::TraverseFlags::MASK = G_TRAVERSE_MASK
}
 Specifies which nodes are visited during several of the NodeTree methods, including traverse() and find(). More...
 
enum  Glib::OptionEntry::Flags {
  Glib::OptionEntry::Flags::NONE = 0x0,
  Glib::OptionEntry::Flags::HIDDEN = 1 << 0,
  Glib::OptionEntry::Flags::IN_MAIN = 1 << 1,
  Glib::OptionEntry::Flags::REVERSE = 1 << 2,
  Glib::OptionEntry::Flags::NO_ARG = 1 << 3,
  Glib::OptionEntry::Flags::FILENAME = 1 << 4,
  Glib::OptionEntry::Flags::OPTIONAL_ARG = 1 << 5,
  Glib::OptionEntry::Flags::NOALIAS = 1 << 6,
  Glib::OptionEntry::Flags::DEPRECATED = 1 << 7
}
 Flags which modify individual options. More...
 
enum  Glib::Regex::CompileFlags {
  Glib::Regex::CompileFlags::DEFAULT = 0x0,
  Glib::Regex::CompileFlags::CASELESS = 1 << 0,
  Glib::Regex::CompileFlags::MULTILINE = 1 << 1,
  Glib::Regex::CompileFlags::DOTALL = 1 << 2,
  Glib::Regex::CompileFlags::EXTENDED = 1 << 3,
  Glib::Regex::CompileFlags::ANCHORED = 1 << 4,
  Glib::Regex::CompileFlags::DOLLAR_ENDONLY = 1 << 5,
  Glib::Regex::CompileFlags::UNGREEDY = 1 << 9,
  Glib::Regex::CompileFlags::RAW = 1 << 11,
  Glib::Regex::CompileFlags::NO_AUTO_CAPTURE = 1 << 12,
  Glib::Regex::CompileFlags::OPTIMIZE = 1 << 13,
  Glib::Regex::CompileFlags::FIRSTLINE = 1 << 18,
  Glib::Regex::CompileFlags::DUPNAMES = 1 << 19,
  Glib::Regex::CompileFlags::NEWLINE_CR = 1 << 20,
  Glib::Regex::CompileFlags::NEWLINE_LF = 1 << 21,
  Glib::Regex::CompileFlags::NEWLINE_CRLF = 0x300000,
  Glib::Regex::CompileFlags::NEWLINE_ANYCRLF = 0x500000,
  Glib::Regex::CompileFlags::BSR_ANYCRLF = 1 << 23,
  Glib::Regex::CompileFlags::JAVASCRIPT_COMPAT = 1 << 25
}
 Flags specifying compile-time options. More...
 
enum  Glib::Regex::MatchFlags {
  Glib::Regex::MatchFlags::DEFAULT = 0x0,
  Glib::Regex::MatchFlags::ANCHORED = 1 << 4,
  Glib::Regex::MatchFlags::NOTBOL = 1 << 7,
  Glib::Regex::MatchFlags::NOTEOL = 1 << 8,
  Glib::Regex::MatchFlags::NOTEMPTY = 1 << 10,
  Glib::Regex::MatchFlags::PARTIAL = 1 << 15,
  Glib::Regex::MatchFlags::NEWLINE_CR = 1 << 20,
  Glib::Regex::MatchFlags::NEWLINE_LF = 1 << 21,
  Glib::Regex::MatchFlags::NEWLINE_CRLF = 0x300000,
  Glib::Regex::MatchFlags::NEWLINE_ANY = 1 << 22,
  Glib::Regex::MatchFlags::NEWLINE_ANYCRLF = 0x500000,
  Glib::Regex::MatchFlags::BSR_ANYCRLF = 1 << 23,
  Glib::Regex::MatchFlags::BSR_ANY = 1 << 24,
  Glib::Regex::MatchFlags::PARTIAL_SOFT = 0x8000,
  Glib::Regex::MatchFlags::PARTIAL_HARD = 1 << 27,
  Glib::Regex::MatchFlags::NOTEMPTY_ATSTART = 1 << 28
}
 Flags specifying match-time options. More...
 
enum  Glib::SpawnFlags {
  Glib::SpawnFlags::DEFAULT = 0x0,
  Glib::SpawnFlags::LEAVE_DESCRIPTORS_OPEN = 1 << 0,
  Glib::SpawnFlags::DO_NOT_REAP_CHILD = 1 << 1,
  Glib::SpawnFlags::SEARCH_PATH = 1 << 2,
  Glib::SpawnFlags::STDOUT_TO_DEV_NULL = 1 << 3,
  Glib::SpawnFlags::STDERR_TO_DEV_NULL = 1 << 4,
  Glib::SpawnFlags::CHILD_INHERITS_STDIN = 1 << 5,
  Glib::SpawnFlags::FILE_AND_ARGV_ZERO = 1 << 6,
  Glib::SpawnFlags::SEARCH_PATH_FROM_ENVP = 1 << 7,
  Glib::SpawnFlags::CLOEXEC_PIPES = 1 << 8,
  Glib::SpawnFlags::CHILD_INHERITS_STDOUT = 1 << 9,
  Glib::SpawnFlags::CHILD_INHERITS_STDERR = 1 << 10,
  Glib::SpawnFlags::STDIN_FROM_DEV_NULL = 1 << 11
}
 Flags passed to g_spawn_sync(), g_spawn_async() and g_spawn_async_with_pipes(). More...
 
enum  Glib::TimeType {
  Glib::TimeType::STANDARD,
  Glib::TimeType::DAYLIGHT,
  Glib::TimeType::UNIVERSAL
}
 Disambiguates a given time in two ways. More...
 
enum  Glib::UnicodeType {
  Glib::UnicodeType::CONTROL,
  Glib::UnicodeType::FORMAT,
  Glib::UnicodeType::UNASSIGNED,
  Glib::UnicodeType::PRIVATE_USE,
  Glib::UnicodeType::SURROGATE,
  Glib::UnicodeType::LOWERCASE_LETTER,
  Glib::UnicodeType::MODIFIER_LETTER,
  Glib::UnicodeType::OTHER_LETTER,
  Glib::UnicodeType::TITLECASE_LETTER,
  Glib::UnicodeType::UPPERCASE_LETTER,
  Glib::UnicodeType::SPACING_MARK,
  Glib::UnicodeType::ENCLOSING_MARK,
  Glib::UnicodeType::NON_SPACING_MARK,
  Glib::UnicodeType::DECIMAL_NUMBER,
  Glib::UnicodeType::LETTER_NUMBER,
  Glib::UnicodeType::OTHER_NUMBER,
  Glib::UnicodeType::CONNECT_PUNCTUATION,
  Glib::UnicodeType::DASH_PUNCTUATION,
  Glib::UnicodeType::CLOSE_PUNCTUATION,
  Glib::UnicodeType::FINAL_PUNCTUATION,
  Glib::UnicodeType::INITIAL_PUNCTUATION,
  Glib::UnicodeType::OTHER_PUNCTUATION,
  Glib::UnicodeType::OPEN_PUNCTUATION,
  Glib::UnicodeType::CURRENCY_SYMBOL,
  Glib::UnicodeType::MODIFIER_SYMBOL,
  Glib::UnicodeType::MATH_SYMBOL,
  Glib::UnicodeType::OTHER_SYMBOL,
  Glib::UnicodeType::LINE_SEPARATOR,
  Glib::UnicodeType::PARAGRAPH_SEPARATOR,
  Glib::UnicodeType::SPACE_SEPARATOR
}
 These are the possible character classifications from the Unicode specification. More...
 
enum  Glib::UnicodeBreakType {
  Glib::UnicodeBreakType::MANDATORY,
  Glib::UnicodeBreakType::CARRIAGE_RETURN,
  Glib::UnicodeBreakType::LINE_FEED,
  Glib::UnicodeBreakType::COMBINING_MARK,
  Glib::UnicodeBreakType::SURROGATE,
  Glib::UnicodeBreakType::ZERO_WIDTH_SPACE,
  Glib::UnicodeBreakType::INSEPARABLE,
  Glib::UnicodeBreakType::NON_BREAKING_GLUE,
  Glib::UnicodeBreakType::CONTINGENT,
  Glib::UnicodeBreakType::SPACE,
  Glib::UnicodeBreakType::AFTER,
  Glib::UnicodeBreakType::BEFORE,
  Glib::UnicodeBreakType::BEFORE_AND_AFTER,
  Glib::UnicodeBreakType::HYPHEN,
  Glib::UnicodeBreakType::NON_STARTER,
  Glib::UnicodeBreakType::OPEN_PUNCTUATION,
  Glib::UnicodeBreakType::CLOSE_PUNCTUATION,
  Glib::UnicodeBreakType::QUOTATION,
  Glib::UnicodeBreakType::EXCLAMATION,
  Glib::UnicodeBreakType::IDEOGRAPHIC,
  Glib::UnicodeBreakType::NUMERIC,
  Glib::UnicodeBreakType::INFIX_SEPARATOR,
  Glib::UnicodeBreakType::SYMBOL,
  Glib::UnicodeBreakType::ALPHABETIC,
  Glib::UnicodeBreakType::PREFIX,
  Glib::UnicodeBreakType::POSTFIX,
  Glib::UnicodeBreakType::COMPLEX_CONTEXT,
  Glib::UnicodeBreakType::AMBIGUOUS,
  Glib::UnicodeBreakType::UNKNOWN,
  Glib::UnicodeBreakType::NEXT_LINE,
  Glib::UnicodeBreakType::WORD_JOINER,
  Glib::UnicodeBreakType::HANGUL_L_JAMO,
  Glib::UnicodeBreakType::HANGUL_V_JAMO,
  Glib::UnicodeBreakType::HANGUL_T_JAMO,
  Glib::UnicodeBreakType::HANGUL_LV_SYLLABLE,
  Glib::UnicodeBreakType::HANGUL_LVT_SYLLABLE,
  Glib::UnicodeBreakType::CLOSE_PARANTHESIS,
  Glib::UnicodeBreakType::CLOSE_PARENTHESIS = CLOSE_PARANTHESIS,
  Glib::UnicodeBreakType::CONDITIONAL_JAPANESE_STARTER,
  Glib::UnicodeBreakType::HEBREW_LETTER,
  Glib::UnicodeBreakType::REGIONAL_INDICATOR,
  Glib::UnicodeBreakType::EMOJI_BASE,
  Glib::UnicodeBreakType::EMOJI_MODIFIER,
  Glib::UnicodeBreakType::ZERO_WIDTH_JOINER,
  Glib::UnicodeBreakType::AKSARA,
  Glib::UnicodeBreakType::AKSARA_PRE_BASE,
  Glib::UnicodeBreakType::AKSARA_START,
  Glib::UnicodeBreakType::VIRAMA_FINAL,
  Glib::UnicodeBreakType::VIRAMA
}
 These are the possible line break classifications. More...
 
enum  Glib::AsciiType {
  Glib::AsciiType::ALNUM = 1 << 0,
  Glib::AsciiType::ALPHA = 1 << 1,
  Glib::AsciiType::CNTRL = 1 << 2,
  Glib::AsciiType::DIGIT = 1 << 3,
  Glib::AsciiType::GRAPH = 1 << 4,
  Glib::AsciiType::LOWER = 1 << 5,
  Glib::AsciiType::PRINT = 1 << 6,
  Glib::AsciiType::PUNCT = 1 << 7,
  Glib::AsciiType::SPACE = 1 << 8,
  Glib::AsciiType::UPPER = 1 << 9,
  Glib::AsciiType::XDIGIT = 1 << 10
}
 
enum  Glib::NormalizeMode {
  Glib::NormalizeMode::DEFAULT,
  Glib::NormalizeMode::NFD = DEFAULT,
  Glib::NormalizeMode::DEFAULT_COMPOSE,
  Glib::NormalizeMode::NFC = DEFAULT_COMPOSE,
  Glib::NormalizeMode::ALL,
  Glib::NormalizeMode::NFKD = ALL,
  Glib::NormalizeMode::ALL_COMPOSE,
  Glib::NormalizeMode::NFKC = ALL_COMPOSE
}
 Defines how a Unicode string is transformed in a canonical form, standardizing such issues as whether a character with an accent is represented as a base character and combining accent or as a single precomposed character. More...
 
enum  Gio::Application::OptionType {
  Gio::Application::OptionType::BOOL,
  Gio::Application::OptionType::STRING,
  Gio::Application::OptionType::INT,
  Gio::Application::OptionType::FILENAME = INT+2,
  Gio::Application::OptionType::STRING_VECTOR,
  Gio::Application::OptionType::FILENAME_VECTOR,
  Gio::Application::OptionType::DOUBLE,
  Gio::Application::OptionType::INT64
}
 The OptionType enum values determine the expected type of a command line option. More...
 

Functions

Binding::Flags Glib::operator| (Binding::Flags lhs, Binding::Flags rhs)
 
Binding::Flags Glib::operator& (Binding::Flags lhs, Binding::Flags rhs)
 
Binding::Flags Glib::operator^ (Binding::Flags lhs, Binding::Flags rhs)
 
Binding::Flags Glib::operator~ (Binding::Flags flags)
 
Binding::Flags& Glib::operator|= (Binding::Flags& lhs, Binding::Flags rhs)
 
Binding::Flags& Glib::operator&= (Binding::Flags& lhs, Binding::Flags rhs)
 
Binding::Flags& Glib::operator^= (Binding::Flags& lhs, Binding::Flags rhs)
 
MainContextFlags Glib::operator| (MainContextFlags lhs, MainContextFlags rhs)
 
MainContextFlags Glib::operator& (MainContextFlags lhs, MainContextFlags rhs)
 
MainContextFlags Glib::operator^ (MainContextFlags lhs, MainContextFlags rhs)
 
MainContextFlags Glib::operator~ (MainContextFlags flags)
 
MainContextFlags& Glib::operator|= (MainContextFlags& lhs, MainContextFlags rhs)
 
MainContextFlags& Glib::operator&= (MainContextFlags& lhs, MainContextFlags rhs)
 
MainContextFlags& Glib::operator^= (MainContextFlags& lhs, MainContextFlags rhs)
 
ParamFlags Glib::operator| (ParamFlags lhs, ParamFlags rhs)
 
ParamFlags Glib::operator& (ParamFlags lhs, ParamFlags rhs)
 
ParamFlags Glib::operator^ (ParamFlags lhs, ParamFlags rhs)
 
ParamFlags Glib::operator~ (ParamFlags flags)
 
ParamFlags& Glib::operator|= (ParamFlags& lhs, ParamFlags rhs)
 
ParamFlags& Glib::operator&= (ParamFlags& lhs, ParamFlags rhs)
 
ParamFlags& Glib::operator^= (ParamFlags& lhs, ParamFlags rhs)
 
FileTest Glib::operator| (FileTest lhs, FileTest rhs)
 
FileTest Glib::operator& (FileTest lhs, FileTest rhs)
 
FileTest Glib::operator^ (FileTest lhs, FileTest rhs)
 
FileTest Glib::operator~ (FileTest flags)
 
FileTest& Glib::operator|= (FileTest& lhs, FileTest rhs)
 
FileTest& Glib::operator&= (FileTest& lhs, FileTest rhs)
 
FileTest& Glib::operator^= (FileTest& lhs, FileTest rhs)
 
IOFlags Glib::operator| (IOFlags lhs, IOFlags rhs)
 
IOFlags Glib::operator& (IOFlags lhs, IOFlags rhs)
 
IOFlags Glib::operator^ (IOFlags lhs, IOFlags rhs)
 
IOFlags Glib::operator~ (IOFlags flags)
 
IOFlags& Glib::operator|= (IOFlags& lhs, IOFlags rhs)
 
IOFlags& Glib::operator&= (IOFlags& lhs, IOFlags rhs)
 
IOFlags& Glib::operator^= (IOFlags& lhs, IOFlags rhs)
 
IOCondition Glib::operator| (IOCondition lhs, IOCondition rhs)
 
IOCondition Glib::operator& (IOCondition lhs, IOCondition rhs)
 
IOCondition Glib::operator^ (IOCondition lhs, IOCondition rhs)
 
IOCondition Glib::operator~ (IOCondition flags)
 
IOCondition& Glib::operator|= (IOCondition& lhs, IOCondition rhs)
 
IOCondition& Glib::operator&= (IOCondition& lhs, IOCondition rhs)
 
IOCondition& Glib::operator^= (IOCondition& lhs, IOCondition rhs)
 
KeyFile::Flags Glib::operator| (KeyFile::Flags lhs, KeyFile::Flags rhs)
 
KeyFile::Flags Glib::operator& (KeyFile::Flags lhs, KeyFile::Flags rhs)
 
KeyFile::Flags Glib::operator^ (KeyFile::Flags lhs, KeyFile::Flags rhs)
 
KeyFile::Flags Glib::operator~ (KeyFile::Flags flags)
 
KeyFile::Flags& Glib::operator|= (KeyFile::Flags& lhs, KeyFile::Flags rhs)
 
KeyFile::Flags& Glib::operator&= (KeyFile::Flags& lhs, KeyFile::Flags rhs)
 
KeyFile::Flags& Glib::operator^= (KeyFile::Flags& lhs, KeyFile::Flags rhs)
 
ParseFlags Glib::Markup::operator| (ParseFlags lhs, ParseFlags rhs)
 
ParseFlags Glib::Markup::operator& (ParseFlags lhs, ParseFlags rhs)
 
ParseFlags Glib::Markup::operator^ (ParseFlags lhs, ParseFlags rhs)
 
ParseFlags Glib::Markup::operator~ (ParseFlags flags)
 
ParseFlags& Glib::Markup::operator|= (ParseFlags& lhs, ParseFlags rhs)
 
ParseFlags& Glib::Markup::operator&= (ParseFlags& lhs, ParseFlags rhs)
 
ParseFlags& Glib::Markup::operator^= (ParseFlags& lhs, ParseFlags rhs)
 
FormatSizeFlags Glib::operator| (FormatSizeFlags lhs, FormatSizeFlags rhs)
 
FormatSizeFlags Glib::operator& (FormatSizeFlags lhs, FormatSizeFlags rhs)
 
FormatSizeFlags Glib::operator^ (FormatSizeFlags lhs, FormatSizeFlags rhs)
 
FormatSizeFlags Glib::operator~ (FormatSizeFlags flags)
 
FormatSizeFlags& Glib::operator|= (FormatSizeFlags& lhs, FormatSizeFlags rhs)
 
FormatSizeFlags& Glib::operator&= (FormatSizeFlags& lhs, FormatSizeFlags rhs)
 
FormatSizeFlags& Glib::operator^= (FormatSizeFlags& lhs, FormatSizeFlags rhs)
 
Module::Flags Glib::operator| (Module::Flags lhs, Module::Flags rhs)
 
Module::Flags Glib::operator& (Module::Flags lhs, Module::Flags rhs)
 
Module::Flags Glib::operator^ (Module::Flags lhs, Module::Flags rhs)
 
Module::Flags Glib::operator~ (Module::Flags flags)
 
Module::Flags& Glib::operator|= (Module::Flags& lhs, Module::Flags rhs)
 
Module::Flags& Glib::operator&= (Module::Flags& lhs, Module::Flags rhs)
 
Module::Flags& Glib::operator^= (Module::Flags& lhs, Module::Flags rhs)
 
OptionEntry::Flags Glib::operator| (OptionEntry::Flags lhs, OptionEntry::Flags rhs)
 
OptionEntry::Flags Glib::operator& (OptionEntry::Flags lhs, OptionEntry::Flags rhs)
 
OptionEntry::Flags Glib::operator^ (OptionEntry::Flags lhs, OptionEntry::Flags rhs)
 
OptionEntry::Flags Glib::operator~ (OptionEntry::Flags flags)
 
OptionEntry::Flags& Glib::operator|= (OptionEntry::Flags& lhs, OptionEntry::Flags rhs)
 
OptionEntry::Flags& Glib::operator&= (OptionEntry::Flags& lhs, OptionEntry::Flags rhs)
 
OptionEntry::Flags& Glib::operator^= (OptionEntry::Flags& lhs, OptionEntry::Flags rhs)
 
Regex::CompileFlags Glib::operator| (Regex::CompileFlags lhs, Regex::CompileFlags rhs)
 
Regex::CompileFlags Glib::operator& (Regex::CompileFlags lhs, Regex::CompileFlags rhs)
 
Regex::CompileFlags Glib::operator^ (Regex::CompileFlags lhs, Regex::CompileFlags rhs)
 
Regex::CompileFlags Glib::operator~ (Regex::CompileFlags flags)
 
Regex::CompileFlags& Glib::operator|= (Regex::CompileFlags& lhs, Regex::CompileFlags rhs)
 
Regex::CompileFlags& Glib::operator&= (Regex::CompileFlags& lhs, Regex::CompileFlags rhs)
 
Regex::CompileFlags& Glib::operator^= (Regex::CompileFlags& lhs, Regex::CompileFlags rhs)
 
Regex::MatchFlags Glib::operator| (Regex::MatchFlags lhs, Regex::MatchFlags rhs)
 
Regex::MatchFlags Glib::operator& (Regex::MatchFlags lhs, Regex::MatchFlags rhs)
 
Regex::MatchFlags Glib::operator^ (Regex::MatchFlags lhs, Regex::MatchFlags rhs)
 
Regex::MatchFlags Glib::operator~ (Regex::MatchFlags flags)
 
Regex::MatchFlags& Glib::operator|= (Regex::MatchFlags& lhs, Regex::MatchFlags rhs)
 
Regex::MatchFlags& Glib::operator&= (Regex::MatchFlags& lhs, Regex::MatchFlags rhs)
 
Regex::MatchFlags& Glib::operator^= (Regex::MatchFlags& lhs, Regex::MatchFlags rhs)
 
SpawnFlags Glib::operator| (SpawnFlags lhs, SpawnFlags rhs)
 
SpawnFlags Glib::operator& (SpawnFlags lhs, SpawnFlags rhs)
 
SpawnFlags Glib::operator^ (SpawnFlags lhs, SpawnFlags rhs)
 
SpawnFlags Glib::operator~ (SpawnFlags flags)
 
SpawnFlags& Glib::operator|= (SpawnFlags& lhs, SpawnFlags rhs)
 
SpawnFlags& Glib::operator&= (SpawnFlags& lhs, SpawnFlags rhs)
 
SpawnFlags& Glib::operator^= (SpawnFlags& lhs, SpawnFlags rhs)
 
AsciiType Glib::operator| (AsciiType lhs, AsciiType rhs)
 
AsciiType Glib::operator& (AsciiType lhs, AsciiType rhs)
 
AsciiType Glib::operator^ (AsciiType lhs, AsciiType rhs)
 
AsciiType Glib::operator~ (AsciiType flags)
 
AsciiType& Glib::operator|= (AsciiType& lhs, AsciiType rhs)
 
AsciiType& Glib::operator&= (AsciiType& lhs, AsciiType rhs)
 
AsciiType& Glib::operator^= (AsciiType& lhs, AsciiType rhs)
 

Detailed Description

Enumeration Type Documentation

enum Glib::AsciiType
strong
Bitwise operators:
AsciiType operator|(AsciiType, AsciiType)
AsciiType operator&(AsciiType, AsciiType)
AsciiType operator^(AsciiType, AsciiType)
AsciiType operator~(AsciiType)
AsciiType& operator|=(AsciiType&, AsciiType)
AsciiType& operator&=(AsciiType&, AsciiType)
AsciiType& operator^=(AsciiType&, AsciiType)
Enumerator
ALNUM 
ALPHA 
CNTRL 
DIGIT 
GRAPH 
LOWER 
PRINT 
PUNCT 
SPACE 
UPPER 
XDIGIT 

Flags specifying compile-time options.

Since glibmm 2.14:
Bitwise operators:
Regex::CompileFlags operator|(Regex::CompileFlags, Regex::CompileFlags)
Regex::CompileFlags operator&(Regex::CompileFlags, Regex::CompileFlags)
Regex::CompileFlags operator^(Regex::CompileFlags, Regex::CompileFlags)
Regex::CompileFlags operator~(Regex::CompileFlags)
Regex::CompileFlags& operator|=(Regex::CompileFlags&, Regex::CompileFlags)
Regex::CompileFlags& operator&=(Regex::CompileFlags&, Regex::CompileFlags)
Regex::CompileFlags& operator^=(Regex::CompileFlags&, Regex::CompileFlags)
Enumerator
DEFAULT 
CASELESS 
MULTILINE 
DOTALL 
EXTENDED 
ANCHORED 
DOLLAR_ENDONLY 
UNGREEDY 
RAW 
NO_AUTO_CAPTURE 
OPTIMIZE 
FIRSTLINE 
DUPNAMES 
NEWLINE_CR 
NEWLINE_LF 
NEWLINE_CRLF 
NEWLINE_ANYCRLF 
BSR_ANYCRLF 
JAVASCRIPT_COMPAT 
enum Glib::Date::DMY
strong

This enumeration isn't used in the API, but may be useful if you need to mark a number as a day, month, or year.

Enumerator
DAY 
MONTH 
YEAR 
enum Glib::FileTest
strong

A test to perform on a file using g_file_test().

Bitwise operators:
FileTest operator|(FileTest, FileTest)
FileTest operator&(FileTest, FileTest)
FileTest operator^(FileTest, FileTest)
FileTest operator~(FileTest)
FileTest& operator|=(FileTest&, FileTest)
FileTest& operator&=(FileTest&, FileTest)
FileTest& operator^=(FileTest&, FileTest)
Enumerator
IS_REGULAR 

true if the file is a regular file (not a directory).

Note that this test will also return true if the tested file is a symlink to a regular file.

IS_SYMLINK 

true if the file is a symlink.

IS_DIR 

true if the file is a directory.

IS_EXECUTABLE 

true if the file is executable.

EXISTS 
enum Glib::Module::Flags
strong
enum Glib::Binding::Flags
strong
enum Glib::KeyFile::Flags
strong
enum Glib::FormatSizeFlags
strong

Flags to modify the format of the string returned by g_format_size_full().

Bitwise operators:
FormatSizeFlags operator|(FormatSizeFlags, FormatSizeFlags)
FormatSizeFlags operator&(FormatSizeFlags, FormatSizeFlags)
FormatSizeFlags operator^(FormatSizeFlags, FormatSizeFlags)
FormatSizeFlags operator~(FormatSizeFlags)
FormatSizeFlags& operator|=(FormatSizeFlags&, FormatSizeFlags)
FormatSizeFlags& operator&=(FormatSizeFlags&, FormatSizeFlags)
FormatSizeFlags& operator^=(FormatSizeFlags&, FormatSizeFlags)
Enumerator
DEFAULT 
LONG_FORMAT 

Include the exact number of bytes as part of the returned string.

For example, "45.6 kB (45,612 bytes)".

IEC_UNITS 

Use IEC (base 1024) units with "KiB"-style suffixes.

IEC units should only be used for reporting things with a strong "power of 2" basis, like RAM sizes or RAID stripe sizes. Network and storage sizes should be reported in the normal SI units.

BITS 

Set the size as a quantity in bits, rather than bytes, and return units in bits.

For example, ‘Mbit’ rather than ‘MB’.

ONLY_VALUE 

Return only value, without unit; this should not be used together with G_FORMAT_SIZE_LONG_FORMAT nor G_FORMAT_SIZE_ONLY_UNIT.

Since glibmm 2.74:
ONLY_UNIT 

Return only unit, without value; this should not be used together with G_FORMAT_SIZE_LONG_FORMAT nor G_FORMAT_SIZE_ONLY_VALUE.

Since glibmm 2.74:
enum Glib::IOCondition
strong

A bitwise combination representing a condition to watch for on an event source.

A bitwise combination representing an I/O condition to watch for on an event source.

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

The flags correspond to those used by the poll() system call on UNIX (see man 2 poll). To test for individual flags, do something like this:

if ((condition & Glib::IOCondition::IO_OUT) == Glib::IOCondition::IO_OUT)
do_some_output();
Enumerator
IO_IN 

There is data to read.

IO_OUT 

Data can be written (without blocking).

IO_PRI 

There is urgent data to read.

IO_ERR 

Error condition.

IO_HUP 

Hung up (the connection has been broken, usually for pipes and sockets).

IO_NVAL 

Invalid request.

The file descriptor is not open.

enum Glib::IOFlags
strong

Specifies properties of a IOChannel.

Some of the flags can only be read with g_io_channel_get_flags(), but not changed with g_io_channel_set_flags().

Bitwise operators:
IOFlags operator|(IOFlags, IOFlags)
IOFlags operator&(IOFlags, IOFlags)
IOFlags operator^(IOFlags, IOFlags)
IOFlags operator~(IOFlags)
IOFlags& operator|=(IOFlags&, IOFlags)
IOFlags& operator&=(IOFlags&, IOFlags)
IOFlags& operator^=(IOFlags&, IOFlags)
Enumerator
NONE 
APPEND 

Turns on append mode, corresponds to O_APPEND (see the documentation of the UNIX open() syscall).

NONBLOCK 

Turns on nonblocking mode, corresponds to O_NONBLOCK/O_NDELAY (see the documentation of the UNIX open() syscall).

IS_READABLE 

Indicates that the io channel is readable.

This flag cannot be changed.

IS_WRITABLE 

Indicates that the io channel is writable.

This flag cannot be changed.

IS_WRITEABLE 

A misspelled version of G_IO_FLAG_IS_WRITABLE that existed before the spelling was fixed in GLib 2.30.

It is kept here for compatibility reasons. Deprecated since 2.30.

IS_SEEKABLE 

Indicates that the io channel is seekable, i.e.

that g_io_channel_seek_position() can be used on it. This flag cannot be changed.

MASK 
GET_MASK 

The mask of the flags that are returned from g_io_channel_get_flags().

SET_MASK 

The mask of the flags that the user can modify with g_io_channel_set_flags().

enum Glib::IOStatus
strong

Statuses returned by most of the IOFuncs functions.

Enumerator
ERROR 
NORMAL 
ENDOFFILE 
AGAIN 

Resource temporarily unavailable.

Flags to pass to Glib::MainContext::new_with_flags() which affect the behaviour of a Glib::MainContext.

Since glibmm 2.72:
Bitwise operators:
MainContextFlags operator|(MainContextFlags, MainContextFlags)
MainContextFlags operator&(MainContextFlags, MainContextFlags)
MainContextFlags operator^(MainContextFlags, MainContextFlags)
MainContextFlags operator~(MainContextFlags)
MainContextFlags& operator|=(MainContextFlags&, MainContextFlags)
MainContextFlags& operator&=(MainContextFlags&, MainContextFlags)
MainContextFlags& operator^=(MainContextFlags&, MainContextFlags)
Enumerator
NONE 
OWNERLESS_POLLING 

Assume that polling for events will free the thread to process other jobs.

That's useful if you're using g_main_context_{prepare,query,check,dispatch} to integrate GMainContext in other event loops.

enum Glib::Date::Month
strong

Enumeration representing a month; values are Glib::Date::JANUARY, Glib::Date::FEBRUARY, etc.

Glib::Date::BAD_MONTH is the invalid value.

Enumerator
BAD_MONTH 
JANUARY 
FEBRUARY 
MARCH 
APRIL 
MAY 
JUNE 
JULY 
AUGUST 
SEPTEMBER 
OCTOBER 
NOVEMBER 
DECEMBER 
enum Glib::NormalizeMode
strong

Defines how a Unicode string is transformed in a canonical form, standardizing such issues as whether a character with an accent is represented as a base character and combining accent or as a single precomposed character.

Unicode strings should generally be normalized before comparing them.

Enumerator
DEFAULT 
NFD 

Another name for Glib::NormalizeMode::DEFAULT.

DEFAULT_COMPOSE 

Like Glib::NormalizeMode::DEFAULT, but with composed forms rather than a maximally decomposed form.

NFC 

Another name for Glib::NormalizeMode::DEFAULT_COMPOSE.

ALL 
NFKD 

Another name for Glib::NormalizeMode::ALL.

ALL_COMPOSE 

Like Glib::NormalizeMode::ALL, but with composed forms rather than a maximally decomposed form.

NFKC 

Another name for Glib::NormalizeMode::ALL_COMPOSE.

The OptionType enum values determine the expected type of a command line option.

If an option expects an extra argument, it can be specified in several ways; with a short option: "-x arg", with a long option: "--name arg" or combined in a single argument: "--name=arg". All option types except OptionType::BOOL expect an extra argument. OptionType::STRING_VECTOR and OptionType::FILENAME_VECTOR accept more than one extra argument.

The descriptions of the enum values show what type of Glib::Variant<> is stored in a Glib::VariantDict.

Since glibmm 2.42:
Enumerator
BOOL 

bool

STRING 

Glib::ustring.

INT 

gint32

FILENAME 

std::string

STRING_VECTOR 

std::vector<Glib::ustring>

FILENAME_VECTOR 

std::vector<std::string>

DOUBLE 

double

INT64 

gint64

enum Glib::ParamFlags
strong

Through the ParamFlags flag values, certain aspects of parameters can be configured.

See also: G_PARAM_STATIC_STRINGS

Bitwise operators:
ParamFlags operator|(ParamFlags, ParamFlags)
ParamFlags operator&(ParamFlags, ParamFlags)
ParamFlags operator^(ParamFlags, ParamFlags)
ParamFlags operator~(ParamFlags)
ParamFlags& operator|=(ParamFlags&, ParamFlags)
ParamFlags& operator&=(ParamFlags&, ParamFlags)
ParamFlags& operator^=(ParamFlags&, ParamFlags)
Enumerator
READABLE 

The parameter is readable.

WRITABLE 

The parameter is writable.

READWRITE 

Alias for Glib::ParamFlags::READABLE | Glib::ParamFlags::WRITABLE.

CONSTRUCT 

The parameter will be set upon object construction.

See G::Object::constructed_vfunc() for more details.

CONSTRUCT_ONLY 

The parameter can only be set upon object construction.

See G::Object::constructed_vfunc() for more details.

LAX_VALIDATION 

Upon parameter conversion (see g_param_value_convert()) strict validation is not required.

STATIC_NAME 

The string used as name when constructing the parameter is guaranteed to remain valid and unmodified for the lifetime of the parameter.

Since glibmm 2.8:
PRIVATE 
STATIC_NICK 

The string used as nick when constructing the parameter is guaranteed to remain valid and unmmodified for the lifetime of the parameter.

Since glibmm 2.8:
STATIC_BLURB 

The string used as blurb when constructing the parameter is guaranteed to remain valid and unmodified for the lifetime of the parameter.

Since glibmm 2.8:
EXPLICIT_NOTIFY 

Calls to g_object_set_property() for this property will not automatically result in a "notify" signal being emitted: the implementation must call g_object_notify() themselves in case the property actually changes.

Since glibmm 2.42:
DEPRECATED 

Flags that affect the behaviour of the parser.

Bitwise operators:
ParseFlags operator|(ParseFlags, ParseFlags)
ParseFlags operator&(ParseFlags, ParseFlags)
ParseFlags operator^(ParseFlags, ParseFlags)
ParseFlags operator~(ParseFlags)
ParseFlags& operator|=(ParseFlags&, ParseFlags)
ParseFlags& operator&=(ParseFlags&, ParseFlags)
ParseFlags& operator^=(ParseFlags&, ParseFlags)
Enumerator
DEFAULT_FLAGS 
DO_NOT_USE_THIS_UNSUPPORTED_FLAG 

Flag you should not use.

TREAT_CDATA_AS_TEXT 

When this flag is set, CDATA marked sections are not passed literally to the passthrough function of the parser.

Instead, the content of the section (without the <![CDATA[ and ]]>) is passed to the text function. This flag was added in GLib 2.12.

PREFIX_ERROR_POSITION 

Normally errors caught by GMarkup itself have line/column information prefixed to them to let the caller know the location of the error.

When this flag is set the location information is also prefixed to errors generated by the MarkupParser implementation functions.

IGNORE_QUALIFIED 

Ignore (don't report) qualified attributes and tags, along with their contents.

A qualified attribute or tag is one that contains ':' in its name (ie: is in another namespace).

Since glibmm 2.40:
enum Glib::SeekType
strong

An enumeration specifying the base position for a g_io_channel_seek_position() operation.

Enumerator
CUR 

The current position in the file.

SET 
END 

The end of the file.

enum Glib::SpawnFlags
strong

Flags passed to g_spawn_sync(), g_spawn_async() and g_spawn_async_with_pipes().

Bitwise operators:
SpawnFlags operator|(SpawnFlags, SpawnFlags)
SpawnFlags operator&(SpawnFlags, SpawnFlags)
SpawnFlags operator^(SpawnFlags, SpawnFlags)
SpawnFlags operator~(SpawnFlags)
SpawnFlags& operator|=(SpawnFlags&, SpawnFlags)
SpawnFlags& operator&=(SpawnFlags&, SpawnFlags)
SpawnFlags& operator^=(SpawnFlags&, SpawnFlags)
Enumerator
DEFAULT 
LEAVE_DESCRIPTORS_OPEN 

The parent's open file descriptors will be inherited by the child; otherwise all descriptors except stdin, stdout and stderr will be closed before calling exec() in the child.

DO_NOT_REAP_CHILD 

The child will not be automatically reaped; you must use g_child_watch_add() yourself (or call waitpid() or handle SIGCHLD yourself), or the child will become a zombie.

SEARCH_PATH 

argv[0] need not be an absolute path, it will be looked for in the user's PATH.

STDOUT_TO_DEV_NULL 

The child's standard output will be discarded, instead of going to the same location as the parent's standard output.

STDERR_TO_DEV_NULL 

The child's standard error will be discarded.

CHILD_INHERITS_STDIN 

The child will inherit the parent's standard input (by default, the child's standard input is attached to /dev/null).

FILE_AND_ARGV_ZERO 

The first element of argv is the file to execute, while the remaining elements are the actual argument vector to pass to the file.

Normally g_spawn_async_with_pipes() uses argv[0] as the file to execute, and passes all of argv to the child.

SEARCH_PATH_FROM_ENVP 
CLOEXEC_PIPES 

Create all pipes with the O_CLOEXEC flag set.

Since glibmm 2.40:
CHILD_INHERITS_STDOUT 

The child will inherit the parent's standard output.

Since glibmm 2.74:
CHILD_INHERITS_STDERR 

The child will inherit the parent's standard error.

Since glibmm 2.74:
STDIN_FROM_DEV_NULL 

The child's standard input is attached to /dev/null.

Since glibmm 2.74:
enum Glib::TimeType
strong

Disambiguates a given time in two ways.

First, specifies if the given time is in universal or local time.

Second, if the time is in local time, specifies if it is local standard time or local daylight time. This is important for the case where the same local time occurs twice (during daylight savings time transitions, for example).

Enumerator
STANDARD 

The time is in local standard time.

DAYLIGHT 

The time is in local daylight time.

UNIVERSAL 

The time is in UTC.

template <typename T >
enum Glib::NodeTree::TraverseFlags
strong

Specifies which nodes are visited during several of the NodeTree methods, including traverse() and find().

Enumerator
LEAVES 

Only leaf nodes should be visited.

NON_LEAVES 

Only non-leaf nodes should be visited.

ALL 

All nodes should be visited.

MASK 

A mask of all traverse flags.

template <typename T >
enum Glib::NodeTree::TraverseType
strong

Specifies the type of traversal performed by g_tree_traverse(), g_node_traverse() and g_node_find().

The different orders are illustrated here:

  • In order: A, B, C, D, E, F, G, H, I <picture> <source srcset="Sorted_binary_tree_inorder-dark.svg" media="(prefers-color-scheme: dark)">
    Sorted binary tree, in-order traversal
    </picture>
  • Pre order: F, B, A, D, C, E, G, I, H <picture> <source srcset="Sorted_binary_tree_preorder-dark.svg" media="(prefers-color-scheme: dark)">
    Sorted binary tree, pre-order traversal
    </picture>
  • Post order: A, C, E, D, B, H, I, G, F <picture> <source srcset="Sorted_binary_tree_postorder-dark.svg" media="(prefers-color-scheme: dark)">
    Sorted binary tree, post-order traversal
    </picture>
  • Level order: F, B, G, A, D, I, C, E, H <picture> <source srcset="Sorted_binary_tree_breadth-first_traversal-dark.svg" media="(prefers-color-scheme: dark)">
    Sorted binary tree, breadth-first level order traversal
    </picture>
Enumerator
IN_ORDER 
PRE_ORDER 
POST_ORDER 
LEVEL_ORDER 
enum Glib::Checksum::Type
strong

The hashing algorithm to be used by Checksum when performing the digest of some data.

Note that the Glib::Checksum::Type enumeration may be extended at a later date to include new hashing algorithm types.

Since glibmm 2.16:
Enumerator
MD5 
SHA1 
SHA256 
SHA512 
SHA384 

These are the possible line break classifications.

Since new Unicode versions may add new types here, applications should be ready to handle unknown values. They may be regarded as Glib::UnicodeBreakType::UNKNOWN.

See Unicode Line Breaking Algorithm.

Enumerator
MANDATORY 

Mandatory Break (BK).

CARRIAGE_RETURN 

Carriage Return (CR).

LINE_FEED 

Line Feed (LF).

COMBINING_MARK 

Attached Characters and Combining Marks (CM).

SURROGATE 
ZERO_WIDTH_SPACE 

Zero Width Space (ZW).

INSEPARABLE 

Inseparable (IN).

NON_BREAKING_GLUE 

Non-breaking ("Glue") (GL).

CONTINGENT 

Contingent Break Opportunity (CB).

SPACE 

Space (SP).

AFTER 

Break Opportunity After (BA).

BEFORE 

Break Opportunity Before (BB).

BEFORE_AND_AFTER 

Break Opportunity Before and After (B2).

HYPHEN 

Hyphen (HY).

NON_STARTER 

Nonstarter (NS).

OPEN_PUNCTUATION 
CLOSE_PUNCTUATION 
QUOTATION 

Ambiguous Quotation (QU).

EXCLAMATION 

Exclamation/Interrogation (EX).

IDEOGRAPHIC 

Ideographic (ID).

NUMERIC 

Numeric (NU).

INFIX_SEPARATOR 

Infix Separator (Numeric) (IS).

SYMBOL 

Symbols Allowing Break After (SY).

ALPHABETIC 

Ordinary Alphabetic and Symbol Characters (AL).

PREFIX 

Prefix (Numeric) (PR).

POSTFIX 

Postfix (Numeric) (PO).

COMPLEX_CONTEXT 

Complex Content Dependent (South East Asian) (SA).

AMBIGUOUS 

Ambiguous (Alphabetic or Ideographic) (AI).

UNKNOWN 
NEXT_LINE 

Next Line (NL).

WORD_JOINER 

Word Joiner (WJ).

HANGUL_L_JAMO 

Hangul L Jamo (JL).

HANGUL_V_JAMO 

Hangul V Jamo (JV).

HANGUL_T_JAMO 

Hangul T Jamo (JT).

HANGUL_LV_SYLLABLE 

Hangul LV Syllable (H2).

HANGUL_LVT_SYLLABLE 

Hangul LVT Syllable (H3).

CLOSE_PARANTHESIS 

Closing Parenthesis (CP).

Since glibmm 2.28:
Deprecated: 2.70: Use Glib::UnicodeBreakType::CLOSE_PARENTHESIS instead.
CLOSE_PARENTHESIS 

Closing Parenthesis (CP).

Since glibmm 2.70:
CONDITIONAL_JAPANESE_STARTER 

Conditional Japanese Starter (CJ).

Since glibmm 2.32:
HEBREW_LETTER 

Hebrew Letter (HL).

Since glibmm 2.32:
REGIONAL_INDICATOR 

Regional Indicator (RI).

Since glibmm 2.36:
EMOJI_BASE 

Emoji Base (EB).

Since glibmm 2.50:
EMOJI_MODIFIER 

Emoji Modifier (EM).

Since glibmm 2.50:
ZERO_WIDTH_JOINER 

Zero Width Joiner (ZWJ).

Since glibmm 2.50:
AKSARA 

Aksara (AK).

Since glibmm 2.80:
AKSARA_PRE_BASE 

Aksara Pre-Base (AP).

Since glibmm 2.80:
AKSARA_START 

Aksara Start (AS).

Since glibmm 2.80:
VIRAMA_FINAL 

Virama Final (VF).

Since glibmm 2.80:
VIRAMA 

Virama (VI).

Since glibmm 2.80:
enum Glib::UnicodeType
strong

These are the possible character classifications from the Unicode specification.

See Unicode Character Database.

Enumerator
CONTROL 

General category "Other, Control" (Cc).

FORMAT 

General category "Other, Format" (Cf).

UNASSIGNED 

General category "Other, Not Assigned" (Cn).

PRIVATE_USE 

General category "Other, Private Use" (Co).

SURROGATE 

General category "Other, Surrogate" (Cs).

Surrogates (SG).

LOWERCASE_LETTER 

General category "Letter, Lowercase" (Ll).

MODIFIER_LETTER 

General category "Letter, Modifier" (Lm).

OTHER_LETTER 

General category "Letter, Other" (Lo).

TITLECASE_LETTER 

General category "Letter, Titlecase" (Lt).

UPPERCASE_LETTER 

General category "Letter, Uppercase" (Lu).

SPACING_MARK 

General category "Mark, Spacing" (Mc).

ENCLOSING_MARK 

General category "Mark, Enclosing" (Me).

NON_SPACING_MARK 

General category "Mark, Nonspacing" (Mn).

DECIMAL_NUMBER 

General category "Number, Decimal Digit" (Nd).

LETTER_NUMBER 

General category "Number, Letter" (Nl).

OTHER_NUMBER 

General category "Number, Other" (No).

CONNECT_PUNCTUATION 

General category "Punctuation, Connector" (Pc).

DASH_PUNCTUATION 

General category "Punctuation, Dash" (Pd).

CLOSE_PUNCTUATION 

General category "Punctuation, Close" (Pe).

Closing Punctuation (CL).

FINAL_PUNCTUATION 

General category "Punctuation, Final quote" (Pf).

INITIAL_PUNCTUATION 

General category "Punctuation, Initial quote" (Pi).

OTHER_PUNCTUATION 

General category "Punctuation, Other" (Po).

OPEN_PUNCTUATION 

General category "Punctuation, Open" (Ps).

Opening Punctuation (OP).

CURRENCY_SYMBOL 

General category "Symbol, Currency" (Sc).

MODIFIER_SYMBOL 

General category "Symbol, Modifier" (Sk).

MATH_SYMBOL 

General category "Symbol, Math" (Sm).

OTHER_SYMBOL 

General category "Symbol, Other" (So).

LINE_SEPARATOR 

General category "Separator, Line" (Zl).

PARAGRAPH_SEPARATOR 

General category "Separator, Paragraph" (Zp).

SPACE_SEPARATOR 

General category "Separator, Space" (Zs).

enum Glib::UserDirectory
strong

These are logical ids for special directories which are defined depending on the platform used.

You should use g_get_user_special_dir() to retrieve the full path associated to the logical id.

The UserDirectory enumeration can be extended at later date. Not every platform has a directory for every logical id in this enumeration.

Since glibmm 2.14:
Enumerator
DESKTOP 

The user's Desktop directory.

DOCUMENTS 

The user's Documents directory.

DOWNLOAD 

The user's Downloads directory.

MUSIC 

The user's Music directory.

PICTURES 

The user's Pictures directory.

PUBLIC_SHARE 

The user's shared directory.

TEMPLATES 

The user's Templates directory.

VIDEOS 

The user's Movies directory.

N_DIRECTORIES 

The number of enum values.

enum Glib::Date::Weekday
strong

Enumeration representing a day of the week; Glib::Date::MONDAY, Glib::Date::TUESDAY, etc.

Glib::Date::BAD_WEEKDAY is an invalid weekday.

Enumerator
BAD_WEEKDAY 
MONDAY 
TUESDAY 
WEDNESDAY 
THURSDAY 
FRIDAY 
SATURDAY 
SUNDAY 

Function Documentation

MainContextFlags Glib::operator& ( MainContextFlags  lhs,
MainContextFlags  rhs 
)
inline
FileTest Glib::operator& ( FileTest  lhs,
FileTest  rhs 
)
inline
SpawnFlags Glib::operator& ( SpawnFlags  lhs,
SpawnFlags  rhs 
)
inline
FormatSizeFlags Glib::operator& ( FormatSizeFlags  lhs,
FormatSizeFlags  rhs 
)
inline
IOFlags Glib::operator& ( IOFlags  lhs,
IOFlags  rhs 
)
inline
ParamFlags Glib::operator& ( ParamFlags  lhs,
ParamFlags  rhs 
)
inline
OptionEntry::Flags Glib::operator& ( OptionEntry::Flags  lhs,
OptionEntry::Flags  rhs 
)
inline
ParseFlags Glib::Markup::operator& ( ParseFlags  lhs,
ParseFlags  rhs 
)
inline
Module::Flags Glib::operator& ( Module::Flags  lhs,
Module::Flags  rhs 
)
inline
IOCondition Glib::operator& ( IOCondition  lhs,
IOCondition  rhs 
)
inline
AsciiType Glib::operator& ( AsciiType  lhs,
AsciiType  rhs 
)
inline
Binding::Flags Glib::operator& ( Binding::Flags  lhs,
Binding::Flags  rhs 
)
inline
KeyFile::Flags Glib::operator& ( KeyFile::Flags  lhs,
KeyFile::Flags  rhs 
)
inline
Regex::CompileFlags Glib::operator& ( Regex::CompileFlags  lhs,
Regex::CompileFlags  rhs 
)
inline
Regex::MatchFlags Glib::operator& ( Regex::MatchFlags  lhs,
Regex::MatchFlags  rhs 
)
inline
MainContextFlags& Glib::operator&= ( MainContextFlags lhs,
MainContextFlags  rhs 
)
inline
FileTest& Glib::operator&= ( FileTest lhs,
FileTest  rhs 
)
inline
SpawnFlags& Glib::operator&= ( SpawnFlags lhs,
SpawnFlags  rhs 
)
inline
FormatSizeFlags& Glib::operator&= ( FormatSizeFlags lhs,
FormatSizeFlags  rhs 
)
inline
IOFlags& Glib::operator&= ( IOFlags lhs,
IOFlags  rhs 
)
inline
ParamFlags& Glib::operator&= ( ParamFlags lhs,
ParamFlags  rhs 
)
inline
OptionEntry::Flags& Glib::operator&= ( OptionEntry::Flags lhs,
OptionEntry::Flags  rhs 
)
inline
ParseFlags& Glib::Markup::operator&= ( ParseFlags lhs,
ParseFlags  rhs 
)
inline
Module::Flags& Glib::operator&= ( Module::Flags lhs,
Module::Flags  rhs 
)
inline
IOCondition& Glib::operator&= ( IOCondition lhs,
IOCondition  rhs 
)
inline
AsciiType& Glib::operator&= ( AsciiType lhs,
AsciiType  rhs 
)
inline
Binding::Flags& Glib::operator&= ( Binding::Flags lhs,
Binding::Flags  rhs 
)
inline
KeyFile::Flags& Glib::operator&= ( KeyFile::Flags lhs,
KeyFile::Flags  rhs 
)
inline
Regex::CompileFlags& Glib::operator&= ( Regex::CompileFlags lhs,
Regex::CompileFlags  rhs 
)
inline
Regex::MatchFlags& Glib::operator&= ( Regex::MatchFlags lhs,
Regex::MatchFlags  rhs 
)
inline
MainContextFlags Glib::operator^ ( MainContextFlags  lhs,
MainContextFlags  rhs 
)
inline
FileTest Glib::operator^ ( FileTest  lhs,
FileTest  rhs 
)
inline
SpawnFlags Glib::operator^ ( SpawnFlags  lhs,
SpawnFlags  rhs 
)
inline
FormatSizeFlags Glib::operator^ ( FormatSizeFlags  lhs,
FormatSizeFlags  rhs 
)
inline
IOFlags Glib::operator^ ( IOFlags  lhs,
IOFlags  rhs 
)
inline
ParamFlags Glib::operator^ ( ParamFlags  lhs,
ParamFlags  rhs 
)
inline
OptionEntry::Flags Glib::operator^ ( OptionEntry::Flags  lhs,
OptionEntry::Flags  rhs 
)
inline
ParseFlags Glib::Markup::operator^ ( ParseFlags  lhs,
ParseFlags  rhs 
)
inline
Module::Flags Glib::operator^ ( Module::Flags  lhs,
Module::Flags  rhs 
)
inline
IOCondition Glib::operator^ ( IOCondition  lhs,
IOCondition  rhs 
)
inline
AsciiType Glib::operator^ ( AsciiType  lhs,
AsciiType  rhs 
)
inline
Binding::Flags Glib::operator^ ( Binding::Flags  lhs,
Binding::Flags  rhs 
)
inline
KeyFile::Flags Glib::operator^ ( KeyFile::Flags  lhs,
KeyFile::Flags  rhs 
)
inline
Regex::CompileFlags Glib::operator^ ( Regex::CompileFlags  lhs,
Regex::CompileFlags  rhs 
)
inline
Regex::MatchFlags Glib::operator^ ( Regex::MatchFlags  lhs,
Regex::MatchFlags  rhs 
)
inline
MainContextFlags& Glib::operator^= ( MainContextFlags lhs,
MainContextFlags  rhs 
)
inline
FileTest& Glib::operator^= ( FileTest lhs,
FileTest  rhs 
)
inline
SpawnFlags& Glib::operator^= ( SpawnFlags lhs,
SpawnFlags  rhs 
)
inline
FormatSizeFlags& Glib::operator^= ( FormatSizeFlags lhs,
FormatSizeFlags  rhs 
)
inline
IOFlags& Glib::operator^= ( IOFlags lhs,
IOFlags  rhs 
)
inline
ParamFlags& Glib::operator^= ( ParamFlags lhs,
ParamFlags  rhs 
)
inline
OptionEntry::Flags& Glib::operator^= ( OptionEntry::Flags lhs,
OptionEntry::Flags  rhs 
)
inline
ParseFlags& Glib::Markup::operator^= ( ParseFlags lhs,
ParseFlags  rhs 
)
inline
Module::Flags& Glib::operator^= ( Module::Flags lhs,
Module::Flags  rhs 
)
inline
IOCondition& Glib::operator^= ( IOCondition lhs,
IOCondition  rhs 
)
inline
AsciiType& Glib::operator^= ( AsciiType lhs,
AsciiType  rhs 
)
inline
Binding::Flags& Glib::operator^= ( Binding::Flags lhs,
Binding::Flags  rhs 
)
inline
KeyFile::Flags& Glib::operator^= ( KeyFile::Flags lhs,
KeyFile::Flags  rhs 
)
inline
Regex::CompileFlags& Glib::operator^= ( Regex::CompileFlags lhs,
Regex::CompileFlags  rhs 
)
inline
Regex::MatchFlags& Glib::operator^= ( Regex::MatchFlags lhs,
Regex::MatchFlags  rhs 
)
inline
MainContextFlags Glib::operator| ( MainContextFlags  lhs,
MainContextFlags  rhs 
)
inline
FileTest Glib::operator| ( FileTest  lhs,
FileTest  rhs 
)
inline
SpawnFlags Glib::operator| ( SpawnFlags  lhs,
SpawnFlags  rhs 
)
inline
FormatSizeFlags Glib::operator| ( FormatSizeFlags  lhs,
FormatSizeFlags  rhs 
)
inline
IOFlags Glib::operator| ( IOFlags  lhs,
IOFlags  rhs 
)
inline
ParamFlags Glib::operator| ( ParamFlags  lhs,
ParamFlags  rhs 
)
inline
OptionEntry::Flags Glib::operator| ( OptionEntry::Flags  lhs,
OptionEntry::Flags  rhs 
)
inline
ParseFlags Glib::Markup::operator| ( ParseFlags  lhs,
ParseFlags  rhs 
)
inline
Module::Flags Glib::operator| ( Module::Flags  lhs,
Module::Flags  rhs 
)
inline
IOCondition Glib::operator| ( IOCondition  lhs,
IOCondition  rhs 
)
inline
AsciiType Glib::operator| ( AsciiType  lhs,
AsciiType  rhs 
)
inline
Binding::Flags Glib::operator| ( Binding::Flags  lhs,
Binding::Flags  rhs 
)
inline
KeyFile::Flags Glib::operator| ( KeyFile::Flags  lhs,
KeyFile::Flags  rhs 
)
inline
Regex::CompileFlags Glib::operator| ( Regex::CompileFlags  lhs,
Regex::CompileFlags  rhs 
)
inline
Regex::MatchFlags Glib::operator| ( Regex::MatchFlags  lhs,
Regex::MatchFlags  rhs 
)
inline
MainContextFlags& Glib::operator|= ( MainContextFlags lhs,
MainContextFlags  rhs 
)
inline
FileTest& Glib::operator|= ( FileTest lhs,
FileTest  rhs 
)
inline
SpawnFlags& Glib::operator|= ( SpawnFlags lhs,
SpawnFlags  rhs 
)
inline
FormatSizeFlags& Glib::operator|= ( FormatSizeFlags lhs,
FormatSizeFlags  rhs 
)
inline
IOFlags& Glib::operator|= ( IOFlags lhs,
IOFlags  rhs 
)
inline
ParamFlags& Glib::operator|= ( ParamFlags lhs,
ParamFlags  rhs 
)
inline
OptionEntry::Flags& Glib::operator|= ( OptionEntry::Flags lhs,
OptionEntry::Flags  rhs 
)
inline
ParseFlags& Glib::Markup::operator|= ( ParseFlags lhs,
ParseFlags  rhs 
)
inline
Module::Flags& Glib::operator|= ( Module::Flags lhs,
Module::Flags  rhs 
)
inline
IOCondition& Glib::operator|= ( IOCondition lhs,
IOCondition  rhs 
)
inline
AsciiType& Glib::operator|= ( AsciiType lhs,
AsciiType  rhs 
)
inline
Binding::Flags& Glib::operator|= ( Binding::Flags lhs,
Binding::Flags  rhs 
)
inline
KeyFile::Flags& Glib::operator|= ( KeyFile::Flags lhs,
KeyFile::Flags  rhs 
)
inline
Regex::CompileFlags& Glib::operator|= ( Regex::CompileFlags lhs,
Regex::CompileFlags  rhs 
)
inline
Regex::MatchFlags& Glib::operator|= ( Regex::MatchFlags lhs,
Regex::MatchFlags  rhs 
)
inline
MainContextFlags Glib::operator~ ( MainContextFlags  flags)
inline
FileTest Glib::operator~ ( FileTest  flags)
inline
SpawnFlags Glib::operator~ ( SpawnFlags  flags)
inline
FormatSizeFlags Glib::operator~ ( FormatSizeFlags  flags)
inline
IOFlags Glib::operator~ ( IOFlags  flags)
inline
ParamFlags Glib::operator~ ( ParamFlags  flags)
inline
OptionEntry::Flags Glib::operator~ ( OptionEntry::Flags  flags)
inline
ParseFlags Glib::Markup::operator~ ( ParseFlags  flags)
inline
Module::Flags Glib::operator~ ( Module::Flags  flags)
inline
IOCondition Glib::operator~ ( IOCondition  flags)
inline
AsciiType Glib::operator~ ( AsciiType  flags)
inline
Binding::Flags Glib::operator~ ( Binding::Flags  flags)
inline
KeyFile::Flags Glib::operator~ ( KeyFile::Flags  flags)
inline
Regex::CompileFlags Glib::operator~ ( Regex::CompileFlags  flags)
inline
Regex::MatchFlags Glib::operator~ ( Regex::MatchFlags  flags)
inline