glibmm  2.68.0
Enumerations | Functions
glibmm Enums and Flags

Enumerations

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::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  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...
 
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::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::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 an I/O 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::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
}
 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::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
}
 Flags which modify individual options. More...
 
enum  Glib::Regex::CompileFlags {
  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::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
}
 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::CONDITIONAL_JAPANESE_STARTER,
  Glib::UnicodeBreakType::HEBREW_LETTER,
  Glib::UnicodeBreakType::REGIONAL_INDICATOR,
  Glib::UnicodeBreakType::EMOJI_BASE,
  Glib::UnicodeBreakType::EMOJI_MODIFIER,
  Glib::UnicodeBreakType::ZERO_WIDTH_JOINER
}
 These are the possible line break classifications. More...
 
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...
 

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::FlagsGlib::operator|= (Binding::Flags& lhs, Binding::Flags rhs)
 
Binding::FlagsGlib::operator&= (Binding::Flags& lhs, Binding::Flags rhs)
 
Binding::FlagsGlib::operator^= (Binding::Flags& lhs, Binding::Flags 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)
 
ParamFlagsGlib::operator|= (ParamFlags& lhs, ParamFlags rhs)
 
ParamFlagsGlib::operator&= (ParamFlags& lhs, ParamFlags rhs)
 
ParamFlagsGlib::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)
 
FileTestGlib::operator|= (FileTest& lhs, FileTest rhs)
 
FileTestGlib::operator&= (FileTest& lhs, FileTest rhs)
 
FileTestGlib::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)
 
IOFlagsGlib::operator|= (IOFlags& lhs, IOFlags rhs)
 
IOFlagsGlib::operator&= (IOFlags& lhs, IOFlags rhs)
 
IOFlagsGlib::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)
 
IOConditionGlib::operator|= (IOCondition& lhs, IOCondition rhs)
 
IOConditionGlib::operator&= (IOCondition& lhs, IOCondition rhs)
 
IOConditionGlib::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::FlagsGlib::operator|= (KeyFile::Flags& lhs, KeyFile::Flags rhs)
 
KeyFile::FlagsGlib::operator&= (KeyFile::Flags& lhs, KeyFile::Flags rhs)
 
KeyFile::FlagsGlib::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)
 
ParseFlagsGlib::Markup::operator|= (ParseFlags& lhs, ParseFlags rhs)
 
ParseFlagsGlib::Markup::operator&= (ParseFlags& lhs, ParseFlags rhs)
 
ParseFlagsGlib::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)
 
FormatSizeFlagsGlib::operator|= (FormatSizeFlags& lhs, FormatSizeFlags rhs)
 
FormatSizeFlagsGlib::operator&= (FormatSizeFlags& lhs, FormatSizeFlags rhs)
 
FormatSizeFlagsGlib::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::FlagsGlib::operator|= (Module::Flags& lhs, Module::Flags rhs)
 
Module::FlagsGlib::operator&= (Module::Flags& lhs, Module::Flags rhs)
 
Module::FlagsGlib::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::FlagsGlib::operator|= (OptionEntry::Flags& lhs, OptionEntry::Flags rhs)
 
OptionEntry::FlagsGlib::operator&= (OptionEntry::Flags& lhs, OptionEntry::Flags rhs)
 
OptionEntry::FlagsGlib::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::CompileFlagsGlib::operator|= (Regex::CompileFlags& lhs, Regex::CompileFlags rhs)
 
Regex::CompileFlagsGlib::operator&= (Regex::CompileFlags& lhs, Regex::CompileFlags rhs)
 
Regex::CompileFlagsGlib::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::MatchFlagsGlib::operator|= (Regex::MatchFlags& lhs, Regex::MatchFlags rhs)
 
Regex::MatchFlagsGlib::operator&= (Regex::MatchFlags& lhs, Regex::MatchFlags rhs)
 
Regex::MatchFlagsGlib::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)
 
SpawnFlagsGlib::operator|= (SpawnFlags& lhs, SpawnFlags rhs)
 
SpawnFlagsGlib::operator&= (SpawnFlags& lhs, SpawnFlags rhs)
 
SpawnFlagsGlib::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)
 
AsciiTypeGlib::operator|= (AsciiType& lhs, AsciiType rhs)
 
AsciiTypeGlib::operator&= (AsciiType& lhs, AsciiType rhs)
 
AsciiTypeGlib::operator^= (AsciiType& lhs, AsciiType rhs)
 

Detailed Description

Enumeration Type Documentation

◆ AsciiType

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 

◆ CompileFlags

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
CASELESS 

Changes behaviour so that it is compatible with JavaScript rather than PCRE.

Since glibmm 2.34:
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 

◆ DMY

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 

A year.

MONTH 
YEAR 

◆ FileTest

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

It may or may not be a regular file.

IS_SYMLINK 
IS_DIR 
IS_EXECUTABLE 
EXISTS 

◆ Flags [1/4]

enum Glib::Binding::Flags
strong

Flags to be passed to g_object_bind_property() or g_object_bind_property_full().

This enumeration can be extended at later date.

Since glibmm 2.44:
Bitwise operators:
Binding::Flags operator|(Binding::Flags, Binding::Flags)
Binding::Flags operator&(Binding::Flags, Binding::Flags)
Binding::Flags operator^(Binding::Flags, Binding::Flags)
Binding::Flags operator~(Binding::Flags)
Binding::Flags& operator|=(Binding::Flags&, Binding::Flags)
Binding::Flags& operator&=(Binding::Flags&, Binding::Flags)
Binding::Flags& operator^=(Binding::Flags&, Binding::Flags)
Enumerator
DEFAULT 

If the two properties being bound are booleans, setting one to true will result in the other being set to false and vice versa.

This flag will only work for boolean properties, and cannot be used when passing custom transformation functions to g_object_bind_property_full().

BIDIRECTIONAL 
SYNC_CREATE 
INVERT_BOOLEAN 

◆ Flags [2/4]

enum Glib::KeyFile::Flags
strong

Flags which influence the parsing.

Bitwise operators:
KeyFile::Flags operator|(KeyFile::Flags, KeyFile::Flags)
KeyFile::Flags operator&(KeyFile::Flags, KeyFile::Flags)
KeyFile::Flags operator^(KeyFile::Flags, KeyFile::Flags)
KeyFile::Flags operator~(KeyFile::Flags)
KeyFile::Flags& operator|=(KeyFile::Flags&, KeyFile::Flags)
KeyFile::Flags& operator&=(KeyFile::Flags&, KeyFile::Flags)
KeyFile::Flags& operator^=(KeyFile::Flags&, KeyFile::Flags)
Enumerator
NONE 

Use this flag if you plan to write the (possibly modified) contents of the key file back to a file; otherwise only the translations for the current language will be written back.

KEEP_COMMENTS 
KEEP_TRANSLATIONS 

◆ Flags [3/4]

enum Glib::Module::Flags
strong

◆ Flags [4/4]

Flags which modify individual options.

Bitwise operators:
OptionEntry::Flags operator|(OptionEntry::Flags, OptionEntry::Flags)
OptionEntry::Flags operator&(OptionEntry::Flags, OptionEntry::Flags)
OptionEntry::Flags operator^(OptionEntry::Flags, OptionEntry::Flags)
OptionEntry::Flags operator~(OptionEntry::Flags)
OptionEntry::Flags& operator|=(OptionEntry::Flags&, OptionEntry::Flags)
OptionEntry::Flags& operator&=(OptionEntry::Flags&, OptionEntry::Flags)
OptionEntry::Flags& operator^=(OptionEntry::Flags&, OptionEntry::Flags)
Enumerator
NONE 

This flag turns off the automatic conflict resolution which prefixes long option names with groupname- if there is a conflict.

This option should only be used in situations where aliasing is necessary to model some legacy commandline interface. It is not safe to use this option, unless all option groups are under your direct control.

Since glibmm 2.8:
HIDDEN 
IN_MAIN 
REVERSE 
NO_ARG 
FILENAME 
OPTIONAL_ARG 
NOALIAS 

◆ FormatSizeFlags

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 

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

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

LONG_FORMAT 
IEC_UNITS 
BITS 

◆ IOCondition

enum Glib::IOCondition
strong

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

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

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();
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)
Enumerator
IO_IN 

Invalid request.

The file descriptor is not open.

IO_OUT 
IO_PRI 
IO_ERR 
IO_HUP 
IO_NVAL 

◆ IOFlags

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
APPEND 

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

NONBLOCK 
IS_READABLE 
IS_WRITABLE 
IS_WRITEABLE 
IS_SEEKABLE 
MASK 
GET_MASK 
SET_MASK 

◆ IOStatus

enum Glib::IOStatus
strong

Statuses returned by most of the IOFuncs functions.

Enumerator
ERROR 

Resource temporarily unavailable.

NORMAL 
ENDOFFILE 
AGAIN 

◆ MatchFlags

Flags specifying match-time options.

Since glibmm 2.14:
Bitwise operators:
Regex::MatchFlags operator|(Regex::MatchFlags, Regex::MatchFlags)
Regex::MatchFlags operator&(Regex::MatchFlags, Regex::MatchFlags)
Regex::MatchFlags operator^(Regex::MatchFlags, Regex::MatchFlags)
Regex::MatchFlags operator~(Regex::MatchFlags)
Regex::MatchFlags& operator|=(Regex::MatchFlags&, Regex::MatchFlags)
Regex::MatchFlags& operator&=(Regex::MatchFlags&, Regex::MatchFlags)
Regex::MatchFlags& operator^=(Regex::MatchFlags&, Regex::MatchFlags)
Enumerator
ANCHORED 

Like Glib::Regex::MatchFlags::NOTEMPTY, but only applied to the start of the matched string.

For anchored patterns this can only happen for pattern containing "\\K".

Since glibmm 2.34:
NOTBOL 
NOTEOL 
NOTEMPTY 
PARTIAL 
NEWLINE_CR 
NEWLINE_LF 
NEWLINE_CRLF 
NEWLINE_ANY 
NEWLINE_ANYCRLF 
BSR_ANYCRLF 
BSR_ANY 
PARTIAL_SOFT 
PARTIAL_HARD 
NOTEMPTY_ATSTART 

◆ Month

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 

December.

JANUARY 
FEBRUARY 
MARCH 
APRIL 
MAY 
JUNE 
JULY 
AUGUST 
SEPTEMBER 
OCTOBER 
NOVEMBER 
DECEMBER 

◆ NormalizeMode

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 

Another name for Glib::NormalizeMode::ALL_COMPOSE.

NFD 
DEFAULT_COMPOSE 
NFC 
ALL 
NFKD 
ALL_COMPOSE 
NFKC 

◆ OptionType

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

◆ ParamFlags

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 deprecated and will be removed in a future version.

A warning will be generated if it is used while running with G_ENABLE_DIAGNOSTIC=1.

Since glibmm 2.26:
WRITABLE 
READWRITE 
CONSTRUCT 
CONSTRUCT_ONLY 
LAX_VALIDATION 
STATIC_NAME 
PRIVATE 
STATIC_NICK 
STATIC_BLURB 
EXPLICIT_NOTIFY 
DEPRECATED 

◆ ParseFlags

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
DO_NOT_USE_THIS_UNSUPPORTED_FLAG 

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:
TREAT_CDATA_AS_TEXT 
PREFIX_ERROR_POSITION 
IGNORE_QUALIFIED 

◆ SeekType

enum Glib::SeekType
strong

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

Enumerator
CUR 

The end of the file.

SET 
END 

◆ SpawnFlags

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 

Create all pipes with the O_CLOEXEC flag set.

Since glibmm 2.40:
LEAVE_DESCRIPTORS_OPEN 
DO_NOT_REAP_CHILD 
SEARCH_PATH 
STDOUT_TO_DEV_NULL 
STDERR_TO_DEV_NULL 
CHILD_INHERITS_STDIN 
FILE_AND_ARGV_ZERO 
SEARCH_PATH_FROM_ENVP 
CLOEXEC_PIPES 

◆ TimeType

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

DAYLIGHT 
UNIVERSAL 

◆ TraverseFlags

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.

◆ TraverseType

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
  • Pre order: F, B, A, D, C, E, G, I, H
  • Post order: A, C, E, D, B, H, I, G, F
  • Level order: F, B, G, A, D, I, C, E, H
Enumerator
IN_ORDER 

Is not implemented for [balanced binary trees][glib-Balanced-Binary-Trees].

For [n-ary trees][glib-N-ary-Trees], it vists the root node first, then its children, then its grandchildren, and so on. Note that this is less efficient than the other orders.

PRE_ORDER 
POST_ORDER 
LEVEL_ORDER 

◆ Type

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 

Use the SHA-384 hashing algorithm (Since: 2.51).

SHA1 
SHA256 
SHA512 
SHA384 

◆ UnicodeBreakType

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 

Zero Width Joiner (ZWJ).

Since glibmm 2.50:
CARRIAGE_RETURN 
LINE_FEED 
COMBINING_MARK 
SURROGATE 
ZERO_WIDTH_SPACE 
INSEPARABLE 
NON_BREAKING_GLUE 
CONTINGENT 
SPACE 
AFTER 
BEFORE 
BEFORE_AND_AFTER 
HYPHEN 
NON_STARTER 
OPEN_PUNCTUATION 
CLOSE_PUNCTUATION 
QUOTATION 
EXCLAMATION 
IDEOGRAPHIC 
NUMERIC 
INFIX_SEPARATOR 
SYMBOL 
ALPHABETIC 
PREFIX 
POSTFIX 
COMPLEX_CONTEXT 
AMBIGUOUS 
UNKNOWN 
NEXT_LINE 
WORD_JOINER 
HANGUL_L_JAMO 
HANGUL_V_JAMO 
HANGUL_T_JAMO 
HANGUL_LV_SYLLABLE 
HANGUL_LVT_SYLLABLE 
CLOSE_PARANTHESIS 
CONDITIONAL_JAPANESE_STARTER 
HEBREW_LETTER 
REGIONAL_INDICATOR 
EMOJI_BASE 
EMOJI_MODIFIER 
ZERO_WIDTH_JOINER 

◆ UnicodeType

enum Glib::UnicodeType
strong

These are the possible character classifications from the Unicode specification.

See Unicode Character Database.

Enumerator
CONTROL 

General category "Separator, Space" (Zs).

FORMAT 
UNASSIGNED 
PRIVATE_USE 
SURROGATE 
LOWERCASE_LETTER 
MODIFIER_LETTER 
OTHER_LETTER 
TITLECASE_LETTER 
UPPERCASE_LETTER 
SPACING_MARK 
ENCLOSING_MARK 
NON_SPACING_MARK 
DECIMAL_NUMBER 
LETTER_NUMBER 
OTHER_NUMBER 
CONNECT_PUNCTUATION 
DASH_PUNCTUATION 
CLOSE_PUNCTUATION 
FINAL_PUNCTUATION 
INITIAL_PUNCTUATION 
OTHER_PUNCTUATION 
OPEN_PUNCTUATION 
CURRENCY_SYMBOL 
MODIFIER_SYMBOL 
MATH_SYMBOL 
OTHER_SYMBOL 
LINE_SEPARATOR 
PARAGRAPH_SEPARATOR 
SPACE_SEPARATOR 

◆ UserDirectory

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 number of enum values.

DOCUMENTS 
DOWNLOAD 
MUSIC 
PICTURES 
PUBLIC_SHARE 
TEMPLATES 
VIDEOS 
N_DIRECTORIES 

◆ Weekday

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 

Sunday.

MONDAY 
TUESDAY 
WEDNESDAY 
THURSDAY 
FRIDAY 
SATURDAY 
SUNDAY 

Function Documentation

◆ operator&() [1/14]

AsciiType Glib::operator& ( AsciiType  lhs,
AsciiType  rhs 
)
inline

◆ operator&() [2/14]

Binding::Flags Glib::operator& ( Binding::Flags  lhs,
Binding::Flags  rhs 
)
inline

◆ operator&() [3/14]

FileTest Glib::operator& ( FileTest  lhs,
FileTest  rhs 
)
inline

◆ operator&() [4/14]

FormatSizeFlags Glib::operator& ( FormatSizeFlags  lhs,
FormatSizeFlags  rhs 
)
inline

◆ operator&() [5/14]

IOCondition Glib::operator& ( IOCondition  lhs,
IOCondition  rhs 
)
inline

◆ operator&() [6/14]

IOFlags Glib::operator& ( IOFlags  lhs,
IOFlags  rhs 
)
inline

◆ operator&() [7/14]

KeyFile::Flags Glib::operator& ( KeyFile::Flags  lhs,
KeyFile::Flags  rhs 
)
inline

◆ operator&() [8/14]

Module::Flags Glib::operator& ( Module::Flags  lhs,
Module::Flags  rhs 
)
inline

◆ operator&() [9/14]

OptionEntry::Flags Glib::operator& ( OptionEntry::Flags  lhs,
OptionEntry::Flags  rhs 
)
inline

◆ operator&() [10/14]

ParamFlags Glib::operator& ( ParamFlags  lhs,
ParamFlags  rhs 
)
inline

◆ operator&() [11/14]

ParseFlags Glib::Markup::operator& ( ParseFlags  lhs,
ParseFlags  rhs 
)
inline

◆ operator&() [12/14]

Regex::CompileFlags Glib::operator& ( Regex::CompileFlags  lhs,
Regex::CompileFlags  rhs 
)
inline

◆ operator&() [13/14]

Regex::MatchFlags Glib::operator& ( Regex::MatchFlags  lhs,
Regex::MatchFlags  rhs 
)
inline

◆ operator&() [14/14]

SpawnFlags Glib::operator& ( SpawnFlags  lhs,
SpawnFlags  rhs 
)
inline

◆ operator&=() [1/14]

AsciiType& Glib::operator&= ( AsciiType lhs,
AsciiType  rhs 
)
inline

◆ operator&=() [2/14]

Binding::Flags& Glib::operator&= ( Binding::Flags lhs,
Binding::Flags  rhs 
)
inline

◆ operator&=() [3/14]

FileTest& Glib::operator&= ( FileTest lhs,
FileTest  rhs 
)
inline

◆ operator&=() [4/14]

FormatSizeFlags& Glib::operator&= ( FormatSizeFlags lhs,
FormatSizeFlags  rhs 
)
inline

◆ operator&=() [5/14]

IOCondition& Glib::operator&= ( IOCondition lhs,
IOCondition  rhs 
)
inline

◆ operator&=() [6/14]

IOFlags& Glib::operator&= ( IOFlags lhs,
IOFlags  rhs 
)
inline

◆ operator&=() [7/14]

KeyFile::Flags& Glib::operator&= ( KeyFile::Flags lhs,
KeyFile::Flags  rhs 
)
inline

◆ operator&=() [8/14]

Module::Flags& Glib::operator&= ( Module::Flags lhs,
Module::Flags  rhs 
)
inline

◆ operator&=() [9/14]

OptionEntry::Flags& Glib::operator&= ( OptionEntry::Flags lhs,
OptionEntry::Flags  rhs 
)
inline

◆ operator&=() [10/14]

ParamFlags& Glib::operator&= ( ParamFlags lhs,
ParamFlags  rhs 
)
inline

◆ operator&=() [11/14]

ParseFlags& Glib::Markup::operator&= ( ParseFlags lhs,
ParseFlags  rhs 
)
inline

◆ operator&=() [12/14]

Regex::CompileFlags& Glib::operator&= ( Regex::CompileFlags lhs,
Regex::CompileFlags  rhs 
)
inline

◆ operator&=() [13/14]

Regex::MatchFlags& Glib::operator&= ( Regex::MatchFlags lhs,
Regex::MatchFlags  rhs 
)
inline

◆ operator&=() [14/14]

SpawnFlags& Glib::operator&= ( SpawnFlags lhs,
SpawnFlags  rhs 
)
inline

◆ operator^() [1/14]

AsciiType Glib::operator^ ( AsciiType  lhs,
AsciiType  rhs 
)
inline

◆ operator^() [2/14]

Binding::Flags Glib::operator^ ( Binding::Flags  lhs,
Binding::Flags  rhs 
)
inline

◆ operator^() [3/14]

FileTest Glib::operator^ ( FileTest  lhs,
FileTest  rhs 
)
inline

◆ operator^() [4/14]

FormatSizeFlags Glib::operator^ ( FormatSizeFlags  lhs,
FormatSizeFlags  rhs 
)
inline

◆ operator^() [5/14]

IOCondition Glib::operator^ ( IOCondition  lhs,
IOCondition  rhs 
)
inline

◆ operator^() [6/14]

IOFlags Glib::operator^ ( IOFlags  lhs,
IOFlags  rhs 
)
inline

◆ operator^() [7/14]

KeyFile::Flags Glib::operator^ ( KeyFile::Flags  lhs,
KeyFile::Flags  rhs 
)
inline

◆ operator^() [8/14]

Module::Flags Glib::operator^ ( Module::Flags  lhs,
Module::Flags  rhs 
)
inline

◆ operator^() [9/14]

OptionEntry::Flags Glib::operator^ ( OptionEntry::Flags  lhs,
OptionEntry::Flags  rhs 
)
inline

◆ operator^() [10/14]

ParamFlags Glib::operator^ ( ParamFlags  lhs,
ParamFlags  rhs 
)
inline

◆ operator^() [11/14]

ParseFlags Glib::Markup::operator^ ( ParseFlags  lhs,
ParseFlags  rhs 
)
inline

◆ operator^() [12/14]

Regex::CompileFlags Glib::operator^ ( Regex::CompileFlags  lhs,
Regex::CompileFlags  rhs 
)
inline

◆ operator^() [13/14]

Regex::MatchFlags Glib::operator^ ( Regex::MatchFlags  lhs,
Regex::MatchFlags  rhs 
)
inline

◆ operator^() [14/14]

SpawnFlags Glib::operator^ ( SpawnFlags  lhs,
SpawnFlags  rhs 
)
inline

◆ operator^=() [1/14]

AsciiType& Glib::operator^= ( AsciiType lhs,
AsciiType  rhs 
)
inline

◆ operator^=() [2/14]

Binding::Flags& Glib::operator^= ( Binding::Flags lhs,
Binding::Flags  rhs 
)
inline

◆ operator^=() [3/14]

FileTest& Glib::operator^= ( FileTest lhs,
FileTest  rhs 
)
inline

◆ operator^=() [4/14]

FormatSizeFlags& Glib::operator^= ( FormatSizeFlags lhs,
FormatSizeFlags  rhs 
)
inline

◆ operator^=() [5/14]

IOCondition& Glib::operator^= ( IOCondition lhs,
IOCondition  rhs 
)
inline

◆ operator^=() [6/14]

IOFlags& Glib::operator^= ( IOFlags lhs,
IOFlags  rhs 
)
inline

◆ operator^=() [7/14]

KeyFile::Flags& Glib::operator^= ( KeyFile::Flags lhs,
KeyFile::Flags  rhs 
)
inline

◆ operator^=() [8/14]

Module::Flags& Glib::operator^= ( Module::Flags lhs,
Module::Flags  rhs 
)
inline

◆ operator^=() [9/14]

OptionEntry::Flags& Glib::operator^= ( OptionEntry::Flags lhs,
OptionEntry::Flags  rhs 
)
inline

◆ operator^=() [10/14]

ParamFlags& Glib::operator^= ( ParamFlags lhs,
ParamFlags  rhs 
)
inline

◆ operator^=() [11/14]

ParseFlags& Glib::Markup::operator^= ( ParseFlags lhs,
ParseFlags  rhs 
)
inline

◆ operator^=() [12/14]

Regex::CompileFlags& Glib::operator^= ( Regex::CompileFlags lhs,
Regex::CompileFlags  rhs 
)
inline

◆ operator^=() [13/14]

Regex::MatchFlags& Glib::operator^= ( Regex::MatchFlags lhs,
Regex::MatchFlags  rhs 
)
inline

◆ operator^=() [14/14]

SpawnFlags& Glib::operator^= ( SpawnFlags lhs,
SpawnFlags  rhs 
)
inline

◆ operator|() [1/14]

AsciiType Glib::operator| ( AsciiType  lhs,
AsciiType  rhs 
)
inline

◆ operator|() [2/14]

Binding::Flags Glib::operator| ( Binding::Flags  lhs,
Binding::Flags  rhs 
)
inline

◆ operator|() [3/14]

FileTest Glib::operator| ( FileTest  lhs,
FileTest  rhs 
)
inline

◆ operator|() [4/14]

FormatSizeFlags Glib::operator| ( FormatSizeFlags  lhs,
FormatSizeFlags  rhs 
)
inline

◆ operator|() [5/14]

IOCondition Glib::operator| ( IOCondition  lhs,
IOCondition  rhs 
)
inline

◆ operator|() [6/14]

IOFlags Glib::operator| ( IOFlags  lhs,
IOFlags  rhs 
)
inline

◆ operator|() [7/14]

KeyFile::Flags Glib::operator| ( KeyFile::Flags  lhs,
KeyFile::Flags  rhs 
)
inline

◆ operator|() [8/14]

Module::Flags Glib::operator| ( Module::Flags  lhs,
Module::Flags  rhs 
)
inline

◆ operator|() [9/14]

OptionEntry::Flags Glib::operator| ( OptionEntry::Flags  lhs,
OptionEntry::Flags  rhs 
)
inline

◆ operator|() [10/14]

ParamFlags Glib::operator| ( ParamFlags  lhs,
ParamFlags  rhs 
)
inline

◆ operator|() [11/14]

ParseFlags Glib::Markup::operator| ( ParseFlags  lhs,
ParseFlags  rhs 
)
inline

◆ operator|() [12/14]

Regex::CompileFlags Glib::operator| ( Regex::CompileFlags  lhs,
Regex::CompileFlags  rhs 
)
inline

◆ operator|() [13/14]

Regex::MatchFlags Glib::operator| ( Regex::MatchFlags  lhs,
Regex::MatchFlags  rhs 
)
inline

◆ operator|() [14/14]

SpawnFlags Glib::operator| ( SpawnFlags  lhs,
SpawnFlags  rhs 
)
inline

◆ operator|=() [1/14]

AsciiType& Glib::operator|= ( AsciiType lhs,
AsciiType  rhs 
)
inline

◆ operator|=() [2/14]

Binding::Flags& Glib::operator|= ( Binding::Flags lhs,
Binding::Flags  rhs 
)
inline

◆ operator|=() [3/14]

FileTest& Glib::operator|= ( FileTest lhs,
FileTest  rhs 
)
inline

◆ operator|=() [4/14]

FormatSizeFlags& Glib::operator|= ( FormatSizeFlags lhs,
FormatSizeFlags  rhs 
)
inline

◆ operator|=() [5/14]

IOCondition& Glib::operator|= ( IOCondition lhs,
IOCondition  rhs 
)
inline

◆ operator|=() [6/14]

IOFlags& Glib::operator|= ( IOFlags lhs,
IOFlags  rhs 
)
inline

◆ operator|=() [7/14]

KeyFile::Flags& Glib::operator|= ( KeyFile::Flags lhs,
KeyFile::Flags  rhs 
)
inline

◆ operator|=() [8/14]

Module::Flags& Glib::operator|= ( Module::Flags lhs,
Module::Flags  rhs 
)
inline

◆ operator|=() [9/14]

OptionEntry::Flags& Glib::operator|= ( OptionEntry::Flags lhs,
OptionEntry::Flags  rhs 
)
inline

◆ operator|=() [10/14]

ParamFlags& Glib::operator|= ( ParamFlags lhs,
ParamFlags  rhs 
)
inline

◆ operator|=() [11/14]

ParseFlags& Glib::Markup::operator|= ( ParseFlags lhs,
ParseFlags  rhs 
)
inline

◆ operator|=() [12/14]

Regex::CompileFlags& Glib::operator|= ( Regex::CompileFlags lhs,
Regex::CompileFlags  rhs 
)
inline

◆ operator|=() [13/14]

Regex::MatchFlags& Glib::operator|= ( Regex::MatchFlags lhs,
Regex::MatchFlags  rhs 
)
inline

◆ operator|=() [14/14]

SpawnFlags& Glib::operator|= ( SpawnFlags lhs,
SpawnFlags  rhs 
)
inline

◆ operator~() [1/14]

AsciiType Glib::operator~ ( AsciiType  flags)
inline

◆ operator~() [2/14]

Binding::Flags Glib::operator~ ( Binding::Flags  flags)
inline

◆ operator~() [3/14]

FileTest Glib::operator~ ( FileTest  flags)
inline

◆ operator~() [4/14]

FormatSizeFlags Glib::operator~ ( FormatSizeFlags  flags)
inline

◆ operator~() [5/14]

IOCondition Glib::operator~ ( IOCondition  flags)
inline

◆ operator~() [6/14]

IOFlags Glib::operator~ ( IOFlags  flags)
inline

◆ operator~() [7/14]

KeyFile::Flags Glib::operator~ ( KeyFile::Flags  flags)
inline

◆ operator~() [8/14]

Module::Flags Glib::operator~ ( Module::Flags  flags)
inline

◆ operator~() [9/14]

OptionEntry::Flags Glib::operator~ ( OptionEntry::Flags  flags)
inline

◆ operator~() [10/14]

ParamFlags Glib::operator~ ( ParamFlags  flags)
inline

◆ operator~() [11/14]

ParseFlags Glib::Markup::operator~ ( ParseFlags  flags)
inline

◆ operator~() [12/14]

Regex::CompileFlags Glib::operator~ ( Regex::CompileFlags  flags)
inline

◆ operator~() [13/14]

Regex::MatchFlags Glib::operator~ ( Regex::MatchFlags  flags)
inline

◆ operator~() [14/14]

SpawnFlags Glib::operator~ ( SpawnFlags  flags)
inline