glibmm  2.74.0
Enumerations | Functions
glibmm Enums and Flags

Enumerations

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

No special options set.

Since glibmm 2.74:
Since glibmm 2.74:
CASELESS 

Letters in the pattern match both upper- and lowercase letters.

This option can be changed within a pattern by a "(?i)" option setting.

MULTILINE 

By default, GRegex treats the strings as consisting of a single line of characters (even if it actually contains newlines).

The "start of line" metacharacter ("^") matches only at the start of the string, while the "end of line" metacharacter ("$") matches only at the end of the string, or before a terminating newline (unless Glib::Regex::CompileFlags::DOLLAR_ENDONLY is set). When Glib::Regex::CompileFlags::MULTILINE is set, the "start of line" and "end of line" constructs match immediately following or immediately before any newline in the string, respectively, as well as at the very start and end. This can be changed within a pattern by a "(?m)" option setting.

DOTALL 

A dot metacharacter (".") in the pattern matches all characters, including newlines.

Without it, newlines are excluded. This option can be changed within a pattern by a ("?s") option setting.

EXTENDED 

Whitespace data characters in the pattern are totally ignored except when escaped or inside a character class.

Whitespace does not include the VT character (code 11). In addition, characters between an unescaped "#" outside a character class and the next newline character, inclusive, are also ignored. This can be changed within a pattern by a "(?x)" option setting.

ANCHORED 

The pattern is forced to be "anchored", that is, it is constrained to match only at the first matching point in the string that is being searched.

This effect can also be achieved by appropriate constructs in the pattern itself such as the "^" metacharacter.

DOLLAR_ENDONLY 

A dollar metacharacter ("$") in the pattern matches only at the end of the string.

Without this option, a dollar also matches immediately before the final character if it is a newline (but not before any other newlines). This option is ignored if Glib::Regex::CompileFlags::MULTILINE is set.

UNGREEDY 

Inverts the "greediness" of the quantifiers so that they are not greedy by default, but become greedy if followed by "?".

It can also be set by a "(?U)" option setting within the pattern.

RAW 

Usually strings must be valid UTF-8 strings, using this flag they are considered as a raw sequence of bytes.

NO_AUTO_CAPTURE 

Disables the use of numbered capturing parentheses in the pattern.

Any opening parenthesis that is not followed by "?" behaves as if it were followed by "?:" but named parentheses can still be used for capturing (and they acquire numbers in the usual way).

OPTIMIZE 

Since 2.74 and the port to pcre2, requests JIT compilation, which, if the just-in-time compiler is available, further processes a compiled pattern into machine code that executes much faster.

However, it comes at the cost of extra processing before the match is performed, so it is most beneficial to use this when the same compiled pattern is used for matching many times. Before 2.74 this option used the built-in non-JIT optimizations in pcre1.

FIRSTLINE 

Limits an unanchored pattern to match before (or at) the first newline.

Since glibmm 2.34:
DUPNAMES 

Names used to identify capturing subpatterns need not be unique.

This can be helpful for certain types of pattern when it is known that only one instance of the named subpattern can ever be matched.

NEWLINE_CR 

Usually any newline character or character sequence is recognized.

Overrides the newline definition set when creating a new Regex, setting the '\r' character as line terminator.

If this option is set, the only recognized newline character is '\r'.

NEWLINE_LF 

Usually any newline character or character sequence is recognized.

Overrides the newline definition set when creating a new Regex, setting the '\n' character as line terminator.

If this option is set, the only recognized newline character is '\n'.

NEWLINE_CRLF 

Usually any newline character or character sequence is recognized.

Overrides the newline definition set when creating a new Regex, setting the '\r\n' characters sequence as line terminator.

If this option is set, the only recognized newline character sequence is '\r\n'.

NEWLINE_ANYCRLF 

Usually any newline character or character sequence is recognized.

Overrides the newline definition set when creating a new Regex; any '\r', '\n', or '\r\n' character sequence is recognized as a newline.

If this option is set, the only recognized newline character sequences are '\r', '\n', and '\r\n'.

Since glibmm 2.34:
Since glibmm 2.34:
BSR_ANYCRLF 

Usually any newline character or character sequence is recognised.

Overrides the newline definition for "\\R" set when creating a new Regex; only '\r', '\n', or '\r\n' character sequences are recognized as a newline by "\\R".

If this option is set, then "\\R" only recognizes the newline characters '\r', '\n' and '\r\n'.

Since glibmm 2.34:
Since glibmm 2.34:
JAVASCRIPT_COMPAT 

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

Since GLib 2.74 this is no longer supported, as libpcre2 does not support it.

Since glibmm 2.34:
Deprecated: 2.74.

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

MONTH 

A month.

YEAR 

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

true if the file exists.

It may or may not be a regular file.

◆ 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 

The default binding; if the source property changes, the target property is updated with its value.

BIDIRECTIONAL 

Bidirectional binding; if either the property of the source or the property of the target changes, the other is updated.

SYNC_CREATE 

Synchronize the values of the source and target properties when creating the binding; the direction of the synchronization is always from the source to the target.

INVERT_BOOLEAN 

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

◆ 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 

No flags, default behaviour.

KEEP_COMMENTS 

Use this flag if you plan to write the (possibly modified) contents of the key file back to a file; otherwise all comments will be lost when the key file is written back.

KEEP_TRANSLATIONS 

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.

◆ Flags [3/4]

enum Glib::Module::Flags
strong

Flags passed to g_module_open().

Note that these flags are not supported on all platforms.

Bitwise operators:
Module::Flags operator|(Module::Flags, Module::Flags)
Module::Flags operator&(Module::Flags, Module::Flags)
Module::Flags operator^(Module::Flags, Module::Flags)
Module::Flags operator~(Module::Flags)
Module::Flags& operator|=(Module::Flags&, Module::Flags)
Module::Flags& operator&=(Module::Flags&, Module::Flags)
Module::Flags& operator^=(Module::Flags&, Module::Flags)
Enumerator
LAZY 

Specifies that symbols are only resolved when needed.

The default action is to bind all symbols when the module is loaded.

LOCAL 

Specifies that symbols in the module should not be added to the global name space.

The default action on most platforms is to place symbols in the module in the global name space, which may cause conflicts with existing symbols.

MASK 

Mask for all flags.

◆ 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 

No flags.

Since glibmm 2.42:
HIDDEN 

The option doesn't appear in --help output.

IN_MAIN 

The option appears in the main section of the --help output, even if it is defined in a group.

REVERSE 

For options of the G_OPTION_ARG_NONE kind, this flag indicates that the sense of the option is reversed.

i.e. false will be stored into the argument rather than true.

NO_ARG 

For options of the G_OPTION_ARG_CALLBACK kind, this flag indicates that the callback does not take any argument (like a G_OPTION_ARG_NONE option).

Since glibmm 2.8:
FILENAME 

For options of the G_OPTION_ARG_CALLBACK kind, this flag indicates that the argument should be passed to the callback in the GLib filename encoding rather than UTF-8.

Since glibmm 2.8:
OPTIONAL_ARG 

For options of the G_OPTION_ARG_CALLBACK kind, this flag indicates that the argument supply is optional.

If no argument is given then data of OptionParseFunc will be set to nullptr.

Since glibmm 2.8:
NOALIAS 

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:

◆ 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 

Behave the same as g_format_size().

Standardize differences that do not affect the text content, such as the above-mentioned accent representation.

No flags, default behaviour.

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, ‘Mb’ 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:

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

do_some_output();
@ IO_OUT
Data can be written (without blocking).
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 

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.

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

The mask that specifies all the valid flags.

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

◆ IOStatus

enum Glib::IOStatus
strong

Statuses returned by most of the IOFuncs functions.

Enumerator
ERROR 

An error occurred.

NORMAL 

Success.

ENDOFFILE 

End of file.

AGAIN 

Resource temporarily unavailable.

◆ MainContextFlags

Flags to pass to g_main_context_new_with_flags() which affect the behaviour of a 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 

Default behaviour.

No special flags set.

Since glibmm 2.74:
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.

◆ 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
DEFAULT 
ANCHORED 
NOTBOL 

Specifies that first character of the string is not the beginning of a line, so the circumflex metacharacter should not match before it.

Setting this without Glib::Regex::CompileFlags::MULTILINE (at compile time) causes circumflex never to match. This option affects only the behaviour of the circumflex metacharacter, it does not affect "\\A".

NOTEOL 

Specifies that the end of the subject string is not the end of a line, so the dollar metacharacter should not match it nor (except in multiline mode) a newline immediately before it.

Setting this without Glib::Regex::CompileFlags::MULTILINE (at compile time) causes dollar never to match. This option affects only the behaviour of the dollar metacharacter, it does not affect "\\Z" or "\\z".

NOTEMPTY 

An empty string is not considered to be a valid match if this option is set.

If there are alternatives in the pattern, they are tried. If all the alternatives match the empty string, the entire match fails. For example, if the pattern "a?b?" is applied to a string not beginning with "a" or "b", it matches the empty string at the start of the string. With this flag set, this match is not valid, so GRegex searches further into the string for occurrences of "a" or "b".

PARTIAL 

Turns on the partial matching feature, for more documentation on partial matching see g_match_info_is_partial_match().

NEWLINE_CR 
NEWLINE_LF 
NEWLINE_CRLF 
NEWLINE_ANY 

Overrides the newline definition set when creating a new Regex, any Unicode newline sequence is recognised as a newline.

These are '\r', '\n' and '\rn', and the single characters U+000B LINE TABULATION, U+000C FORM FEED (FF), U+0085 NEXT LINE (NEL), U+2028 LINE SEPARATOR and U+2029 PARAGRAPH SEPARATOR.

NEWLINE_ANYCRLF 
BSR_ANYCRLF 
BSR_ANY 

Overrides the newline definition for "\\R" set when creating a new Regex; any Unicode newline character or character sequence are recognized as a newline by "\\R".

These are '\r', '\n' and '\rn', and the single characters U+000B LINE TABULATION, U+000C FORM FEED (FF), U+0085 NEXT LINE (NEL), U+2028 LINE SEPARATOR and U+2029 PARAGRAPH SEPARATOR.

Since glibmm 2.34:
PARTIAL_SOFT 

An alias for Glib::Regex::MatchFlags::PARTIAL.

Since glibmm 2.34:
PARTIAL_HARD 

Turns on the partial matching feature.

In contrast to to Glib::Regex::MatchFlags::PARTIAL_SOFT, this stops matching as soon as a partial match is found, without continuing to search for a possible complete match. See g_match_info_is_partial_match() for more information.

Since glibmm 2.34:
NOTEMPTY_ATSTART 

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:

◆ 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 

Invalid value.

JANUARY 

January.

FEBRUARY 

February.

MARCH 

March.

APRIL 

April.

MAY 

May.

JUNE 

June.

JULY 

July.

AUGUST 

August.

SEPTEMBER 

September.

OCTOBER 

October.

NOVEMBER 

November.

DECEMBER 

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

Beyond Glib::NormalizeMode::DEFAULT also standardize the "compatibility" characters in Unicode, such as SUPERSCRIPT THREE to the standard forms (in this case DIGIT THREE).

Formatting information may be lost but for most text operations such characters should be considered the same.

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.

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

WRITABLE 

The parameter is writable.

READWRITE 

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

CONSTRUCT 

The parameter will be set upon object construction.

CONSTRUCT_ONLY 

The parameter can only be set upon object construction.

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 

Internal.

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 

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:

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

No special behaviour.

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

◆ SeekType

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 

The start of the file.

END 

The end of the file.

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

If argv[0] is not an absolute path, it will be looked for in the PATH from the passed child environment.

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

◆ 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 local standard time.

DAYLIGHT 

The time is in local daylight time.

UNIVERSAL 

The time is in UTC.

◆ 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 

Vists a node's left child first, then the node itself, then its right child.

This is the one to use if you want the output sorted according to the compare function.

PRE_ORDER 

Visits a node, then its children.

POST_ORDER 

Visits the node's children, then the node itself.

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

◆ 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 MD5 hashing algorithm.

SHA1 

Use the SHA-1 hashing algorithm.

SHA256 

Use the SHA-256 hashing algorithm.

SHA512 

Use the SHA-512 hashing algorithm (Since: 2.36).

SHA384 

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

◆ 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 

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 

Unknown (XX).

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:

◆ UnicodeType

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

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

◆ 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 

Invalid value.

MONDAY 

Monday.

TUESDAY 

Tuesday.

WEDNESDAY 

Wednesday.

THURSDAY 

Thursday.

FRIDAY 

Friday.

SATURDAY 

Saturday.

SUNDAY 

Sunday.

Function Documentation

◆ operator&() [1/15]

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

◆ operator&() [2/15]

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

◆ operator&() [3/15]

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

◆ operator&() [4/15]

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

◆ operator&() [5/15]

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

◆ operator&() [6/15]

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

◆ operator&() [7/15]

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

◆ operator&() [8/15]

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

◆ operator&() [9/15]

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

◆ operator&() [10/15]

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

◆ operator&() [11/15]

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

◆ operator&() [12/15]

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

◆ operator&() [13/15]

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

◆ operator&() [14/15]

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

◆ operator&() [15/15]

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

◆ operator&=() [1/15]

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

◆ operator&=() [2/15]

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

◆ operator&=() [3/15]

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

◆ operator&=() [4/15]

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

◆ operator&=() [5/15]

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

◆ operator&=() [6/15]

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

◆ operator&=() [7/15]

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

◆ operator&=() [8/15]

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

◆ operator&=() [9/15]

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

◆ operator&=() [10/15]

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

◆ operator&=() [11/15]

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

◆ operator&=() [12/15]

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

◆ operator&=() [13/15]

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

◆ operator&=() [14/15]

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

◆ operator&=() [15/15]

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

◆ operator^() [1/15]

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

◆ operator^() [2/15]

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

◆ operator^() [3/15]

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

◆ operator^() [4/15]

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

◆ operator^() [5/15]

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

◆ operator^() [6/15]

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

◆ operator^() [7/15]

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

◆ operator^() [8/15]

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

◆ operator^() [9/15]

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

◆ operator^() [10/15]

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

◆ operator^() [11/15]

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

◆ operator^() [12/15]

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

◆ operator^() [13/15]

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

◆ operator^() [14/15]

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

◆ operator^() [15/15]

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

◆ operator^=() [1/15]

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

◆ operator^=() [2/15]

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

◆ operator^=() [3/15]

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

◆ operator^=() [4/15]

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

◆ operator^=() [5/15]

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

◆ operator^=() [6/15]

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

◆ operator^=() [7/15]

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

◆ operator^=() [8/15]

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

◆ operator^=() [9/15]

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

◆ operator^=() [10/15]

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

◆ operator^=() [11/15]

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

◆ operator^=() [12/15]

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

◆ operator^=() [13/15]

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

◆ operator^=() [14/15]

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

◆ operator^=() [15/15]

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

◆ operator|() [1/15]

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

◆ operator|() [2/15]

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

◆ operator|() [3/15]

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

◆ operator|() [4/15]

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

◆ operator|() [5/15]

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

◆ operator|() [6/15]

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

◆ operator|() [7/15]

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

◆ operator|() [8/15]

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

◆ operator|() [9/15]

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

◆ operator|() [10/15]

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

◆ operator|() [11/15]

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

◆ operator|() [12/15]

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

◆ operator|() [13/15]

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

◆ operator|() [14/15]

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

◆ operator|() [15/15]

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

◆ operator|=() [1/15]

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

◆ operator|=() [2/15]

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

◆ operator|=() [3/15]

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

◆ operator|=() [4/15]

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

◆ operator|=() [5/15]

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

◆ operator|=() [6/15]

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

◆ operator|=() [7/15]

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

◆ operator|=() [8/15]

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

◆ operator|=() [9/15]

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

◆ operator|=() [10/15]

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

◆ operator|=() [11/15]

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

◆ operator|=() [12/15]

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

◆ operator|=() [13/15]

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

◆ operator|=() [14/15]

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

◆ operator|=() [15/15]

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

◆ operator~() [1/15]

AsciiType Glib::operator~ ( AsciiType  flags)
inline

◆ operator~() [2/15]

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

◆ operator~() [3/15]

FileTest Glib::operator~ ( FileTest  flags)
inline

◆ operator~() [4/15]

FormatSizeFlags Glib::operator~ ( FormatSizeFlags  flags)
inline

◆ operator~() [5/15]

IOCondition Glib::operator~ ( IOCondition  flags)
inline

◆ operator~() [6/15]

IOFlags Glib::operator~ ( IOFlags  flags)
inline

◆ operator~() [7/15]

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

◆ operator~() [8/15]

MainContextFlags Glib::operator~ ( MainContextFlags  flags)
inline

◆ operator~() [9/15]

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

◆ operator~() [10/15]

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

◆ operator~() [11/15]

ParamFlags Glib::operator~ ( ParamFlags  flags)
inline

◆ operator~() [12/15]

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

◆ operator~() [13/15]

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

◆ operator~() [14/15]

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

◆ operator~() [15/15]

SpawnFlags Glib::operator~ ( SpawnFlags  flags)
inline