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

Detailed Description

Enumeration Type Documentation

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

enum Glib::Regex::CompileFlags

strong

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]

enum Glib::OptionEntry::Flags

strong

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:

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

enum Glib::MainContextFlags

strong

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

enum Glib::Regex::MatchFlags

strong

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

enum Gio::Application::OptionType

strong

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

enum Glib::Markup::ParseFlags

strong

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

enum Glib::UnicodeBreakType

strong

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