glibmm: glibmm Enums and Flags

Enumerations

enum Glib::TraverseType {

Glib::TRAVERSE_IN_ORDER = G_IN_ORDER,

Glib::TRAVERSE_PRE_ORDER = G_PRE_ORDER,

Glib::TRAVERSE_POST_ORDER = G_POST_ORDER,

Glib::TRAVERSE_LEVEL_ORDER = G_LEVEL_ORDER

}
Specifies the type of traveral performed by methods such as NodeTree::_traverse() and NodeTree::find(). More...

enum Glib::NodeTree< T >::TraverseFlags {

Glib::NodeTree< T >::TRAVERSE_LEAVES = G_TRAVERSE_LEAVES,

Glib::NodeTree< T >::TRAVERSE_NON_LEAVES = G_TRAVERSE_NON_LEAVES,

Glib::NodeTree< T >::TRAVERSE_ALL = G_TRAVERSE_ALL,

Glib::NodeTree< T >::TRAVERSE_MASK = G_TRAVERSE_MASK

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

enum Glib::AsciiType {

Glib::ASCII_ALNUM = 1 << 0,

Glib::ASCII_ALPHA = 1 << 1,

Glib::ASCII_CNTRL = 1 << 2,

Glib::ASCII_DIGIT = 1 << 3,

Glib::ASCII_GRAPH = 1 << 4,

Glib::ASCII_LOWER = 1 << 5,

Glib::ASCII_PRINT = 1 << 6,

Glib::ASCII_PUNCT = 1 << 7,

Glib::ASCII_SPACE = 1 << 8,

Glib::ASCII_UPPER = 1 << 9,

Glib::ASCII_XDIGIT = 1 << 10

}
enum Gio::Application::OptionType {

Gio::Application::OPTION_TYPE_BOOL ,

Gio::Application::OPTION_TYPE_STRING ,

Gio::Application::OPTION_TYPE_INT ,

Gio::Application::OPTION_TYPE_FILENAME = OPTION_TYPE_INT+2,

Gio::Application::OPTION_TYPE_STRING_VECTOR ,

Gio::Application::OPTION_TYPE_FILENAME_VECTOR ,

Gio::Application::OPTION_TYPE_DOUBLE ,

Gio::Application::OPTION_TYPE_INT64

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

enum Glib::BindingFlags {

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 Glib::Checksum::ChecksumType {

Glib::Checksum::CHECKSUM_MD5 ,

Glib::Checksum::CHECKSUM_SHA1 ,

Glib::Checksum::CHECKSUM_SHA256 ,

Glib::Checksum::CHECKSUM_SHA512

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

enum 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 DATE_JANUARY, DATE_FEBRUARY, etc. More...

enum 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; DATE_MONDAY, DATE_TUESDAY, etc. More...

enum 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 Glib::FileTest {

Glib::FILE_TEST_IS_REGULAR = 1 << 0,

Glib::FILE_TEST_IS_SYMLINK = 1 << 1,

Glib::FILE_TEST_IS_DIR = 1 << 2,

Glib::FILE_TEST_IS_EXECUTABLE = 1 << 3,

Glib::FILE_TEST_EXISTS = 1 << 4

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

enum Glib::SeekType {

Glib::SEEK_TYPE_CUR ,

Glib::SEEK_TYPE_SET ,

Glib::SEEK_TYPE_END

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

enum Glib::IOStatus {

Glib::IO_STATUS_ERROR ,

Glib::IO_STATUS_NORMAL ,

Glib::IO_STATUS_EOF ,

Glib::IO_STATUS_AGAIN

}
Stati returned by most of the IOFuncs functions. More...

enum Glib::IOFlags {

Glib::IO_FLAG_APPEND = 1 << 0,

Glib::IO_FLAG_NONBLOCK = 1 << 1,

Glib::IO_FLAG_IS_READABLE = 1 << 2,

Glib::IO_FLAG_IS_WRITABLE = 1 << 3,

Glib::IO_FLAG_IS_WRITEABLE = 1 << 3,

Glib::IO_FLAG_IS_SEEKABLE = 1 << 4,

Glib::IO_FLAG_MASK = (1 << 5) - 1,

Glib::IO_FLAG_GET_MASK = 0x1F,

Glib::IO_FLAG_SET_MASK = 0x3

}
Specifies properties of a IOChannel. More...

enum 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 a condition to watch for on an event source. More...

enum Glib::KeyFileFlags {

Glib::KEY_FILE_NONE = 0x0,

Glib::KEY_FILE_KEEP_COMMENTS = 1 << 0,

Glib::KEY_FILE_KEEP_TRANSLATIONS = 1 << 1

}
Flags which influence the parsing. More...

enum Glib::Markup::ParseFlags {

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 Glib::UserDirectory {

Glib::USER_DIRECTORY_DESKTOP ,

Glib::USER_DIRECTORY_DOCUMENTS ,

Glib::USER_DIRECTORY_DOWNLOAD ,

Glib::USER_DIRECTORY_MUSIC ,

Glib::USER_DIRECTORY_PICTURES ,

Glib::USER_DIRECTORY_PUBLIC_SHARE ,

Glib::USER_DIRECTORY_TEMPLATES ,

Glib::USER_DIRECTORY_VIDEOS ,

Glib::USER_N_DIRECTORIES

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

enum Glib::FormatSizeFlags {

Glib::FORMAT_SIZE_DEFAULT = 0x0,

Glib::FORMAT_SIZE_LONG_FORMAT = 1 << 0,

Glib::FORMAT_SIZE_IEC_UNITS = 1 << 1

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

enum Glib::ModuleFlags {

Glib::MODULE_BIND_LAZY = 1 << 0,

Glib::MODULE_BIND_LOCAL = 1 << 1,

Glib::MODULE_BIND_MASK = 0x03

}
Flags passed to g_module_open(). More...

enum Glib::RegexCompileFlags {

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 = 1048576 | 1 << 22,

Glib::REGEX_BSR_ANYCRLF = 1 << 23,

Glib::REGEX_JAVASCRIPT_COMPAT = 1 << 25

}
Flags specifying compile-time options. More...

enum Glib::RegexMatchFlags {

Glib::REGEX_MATCH_ANCHORED = 1 << 4,

Glib::REGEX_MATCH_NOTBOL = 1 << 7,

Glib::REGEX_MATCH_NOTEOL = 1 << 8,

Glib::REGEX_MATCH_NOTEMPTY = 1 << 10,

Glib::REGEX_MATCH_PARTIAL = 1 << 15,

Glib::REGEX_MATCH_NEWLINE_CR = 1 << 20,

Glib::REGEX_MATCH_NEWLINE_LF = 1 << 21,

Glib::REGEX_MATCH_NEWLINE_CRLF = 0x300000,

Glib::REGEX_MATCH_NEWLINE_ANY = 1 << 22,

Glib::REGEX_MATCH_NEWLINE_ANYCRLF = 0x500000,

Glib::REGEX_MATCH_BSR_ANYCRLF = 1 << 23,

Glib::REGEX_MATCH_BSR_ANY = 1 << 24,

Glib::REGEX_MATCH_PARTIAL_SOFT = 0x8000,

Glib::REGEX_MATCH_PARTIAL_HARD = 1 << 27,

Glib::REGEX_MATCH_NOTEMPTY_ATSTART = 1 << 28

}
Flags specifying match-time options. More...

enum Glib::SpawnFlags {

Glib::SPAWN_DEFAULT = 0x0,

Glib::SPAWN_LEAVE_DESCRIPTORS_OPEN = 1 << 0,

Glib::SPAWN_DO_NOT_REAP_CHILD = 1 << 1,

Glib::SPAWN_SEARCH_PATH = 1 << 2,

Glib::SPAWN_STDOUT_TO_DEV_NULL = 1 << 3,

Glib::SPAWN_STDERR_TO_DEV_NULL = 1 << 4,

Glib::SPAWN_CHILD_INHERITS_STDIN = 1 << 5,

Glib::SPAWN_FILE_AND_ARGV_ZERO = 1 << 6,

Glib::SPAWN_SEARCH_PATH_FROM_ENVP = 1 << 7,

Glib::SPAWN_CLOEXEC_PIPES = 1 << 8

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

enum Glib::ThreadPriority {

Glib::THREAD_PRIORITY_LOW ,

Glib::THREAD_PRIORITY_NORMAL ,

Glib::THREAD_PRIORITY_HIGH ,

Glib::THREAD_PRIORITY_URGENT

}
Thread priorities. More...

enum Glib::TimeType {

Glib::TIME_TYPE_STANDARD ,

Glib::TIME_TYPE_DAYLIGHT ,

Glib::TIME_TYPE_UNIVERSAL

}
Disambiguates a given time in two ways. More...

enum Glib::UnicodeType {

Glib::UNICODE_CONTROL ,

Glib::UNICODE_FORMAT ,

Glib::UNICODE_UNASSIGNED ,

Glib::UNICODE_PRIVATE_USE ,

Glib::UNICODE_SURROGATE ,

Glib::UNICODE_LOWERCASE_LETTER ,

Glib::UNICODE_MODIFIER_LETTER ,

Glib::UNICODE_OTHER_LETTER ,

Glib::UNICODE_TITLECASE_LETTER ,

Glib::UNICODE_UPPERCASE_LETTER ,

Glib::UNICODE_SPACING_MARK ,

Glib::UNICODE_ENCLOSING_MARK ,

Glib::UNICODE_NON_SPACING_MARK ,

Glib::UNICODE_DECIMAL_NUMBER ,

Glib::UNICODE_LETTER_NUMBER ,

Glib::UNICODE_OTHER_NUMBER ,

Glib::UNICODE_CONNECT_PUNCTUATION ,

Glib::UNICODE_DASH_PUNCTUATION ,

Glib::UNICODE_CLOSE_PUNCTUATION ,

Glib::UNICODE_FINAL_PUNCTUATION ,

Glib::UNICODE_INITIAL_PUNCTUATION ,

Glib::UNICODE_OTHER_PUNCTUATION ,

Glib::UNICODE_OPEN_PUNCTUATION ,

Glib::UNICODE_CURRENCY_SYMBOL ,

Glib::UNICODE_MODIFIER_SYMBOL ,

Glib::UNICODE_MATH_SYMBOL ,

Glib::UNICODE_OTHER_SYMBOL ,

Glib::UNICODE_LINE_SEPARATOR ,

Glib::UNICODE_PARAGRAPH_SEPARATOR ,

Glib::UNICODE_SPACE_SEPARATOR

}
These are the possible character classifications from the Unicode specification. More...

enum Glib::UnicodeBreakType {

Glib::UNICODE_BREAK_MANDATORY ,

Glib::UNICODE_BREAK_CARRIAGE_RETURN ,

Glib::UNICODE_BREAK_LINE_FEED ,

Glib::UNICODE_BREAK_COMBINING_MARK ,

Glib::UNICODE_BREAK_SURROGATE ,

Glib::UNICODE_BREAK_ZERO_WIDTH_SPACE ,

Glib::UNICODE_BREAK_INSEPARABLE ,

Glib::UNICODE_BREAK_NON_BREAKING_GLUE ,

Glib::UNICODE_BREAK_CONTINGENT ,

Glib::UNICODE_BREAK_SPACE ,

Glib::UNICODE_BREAK_AFTER ,

Glib::UNICODE_BREAK_BEFORE ,

Glib::UNICODE_BREAK_BEFORE_AND_AFTER ,

Glib::UNICODE_BREAK_HYPHEN ,

Glib::UNICODE_BREAK_NON_STARTER ,

Glib::UNICODE_BREAK_OPEN_PUNCTUATION ,

Glib::UNICODE_BREAK_CLOSE_PUNCTUATION ,

Glib::UNICODE_BREAK_QUOTATION ,

Glib::UNICODE_BREAK_EXCLAMATION ,

Glib::UNICODE_BREAK_IDEOGRAPHIC ,

Glib::UNICODE_BREAK_NUMERIC ,

Glib::UNICODE_BREAK_INFIX_SEPARATOR ,

Glib::UNICODE_BREAK_SYMBOL ,

Glib::UNICODE_BREAK_ALPHABETIC ,

Glib::UNICODE_BREAK_PREFIX ,

Glib::UNICODE_BREAK_POSTFIX ,

Glib::UNICODE_BREAK_COMPLEX_CONTEXT ,

Glib::UNICODE_BREAK_AMBIGUOUS ,

Glib::UNICODE_BREAK_UNKNOWN ,

Glib::UNICODE_BREAK_NEXT_LINE ,

Glib::UNICODE_BREAK_WORD_JOINER ,

Glib::UNICODE_BREAK_HANGUL_L_JAMO ,

Glib::UNICODE_BREAK_HANGUL_V_JAMO ,

Glib::UNICODE_BREAK_HANGUL_T_JAMO ,

Glib::UNICODE_BREAK_HANGUL_LV_SYLLABLE ,

Glib::UNICODE_BREAK_HANGUL_LVT_SYLLABLE ,

Glib::UNICODE_BREAK_CLOSE_PARANTHESIS ,

Glib::UNICODE_BREAK_CONDITIONAL_JAPANESE_STARTER ,

Glib::UNICODE_BREAK_HEBREW_LETTER ,

Glib::UNICODE_BREAK_REGIONAL_INDICATOR

}
These are the possible line break classifications. More...

enum Glib::NormalizeMode {

Glib::NORMALIZE_DEFAULT ,

Glib::NORMALIZE_NFD = NORMALIZE_DEFAULT,

Glib::NORMALIZE_DEFAULT_COMPOSE ,

Glib::NORMALIZE_NFC = NORMALIZE_DEFAULT_COMPOSE,

Glib::NORMALIZE_ALL ,

Glib::NORMALIZE_NFKD = NORMALIZE_ALL,

Glib::NORMALIZE_ALL_COMPOSE ,

Glib::NORMALIZE_NFKC = NORMALIZE_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

BindingFlags Glib::operator| (BindingFlags lhs, BindingFlags rhs)
BindingFlags Glib::operator& (BindingFlags lhs, BindingFlags rhs)
BindingFlags Glib::operator^ (BindingFlags lhs, BindingFlags rhs)
BindingFlags Glib::operator~ (BindingFlags flags)
BindingFlags& Glib::operator|= (BindingFlags& lhs, BindingFlags rhs)
BindingFlags& Glib::operator&= (BindingFlags& lhs, BindingFlags rhs)
BindingFlags& Glib::operator^= (BindingFlags& lhs, BindingFlags 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)
KeyFileFlags Glib::operator| (KeyFileFlags lhs, KeyFileFlags rhs)
KeyFileFlags Glib::operator& (KeyFileFlags lhs, KeyFileFlags rhs)
KeyFileFlags Glib::operator^ (KeyFileFlags lhs, KeyFileFlags rhs)
KeyFileFlags Glib::operator~ (KeyFileFlags flags)
KeyFileFlags& Glib::operator|= (KeyFileFlags& lhs, KeyFileFlags rhs)
KeyFileFlags& Glib::operator&= (KeyFileFlags& lhs, KeyFileFlags rhs)
KeyFileFlags& Glib::operator^= (KeyFileFlags& lhs, KeyFileFlags 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)
ModuleFlags Glib::operator| (ModuleFlags lhs, ModuleFlags rhs)
ModuleFlags Glib::operator& (ModuleFlags lhs, ModuleFlags rhs)
ModuleFlags Glib::operator^ (ModuleFlags lhs, ModuleFlags rhs)
ModuleFlags Glib::operator~ (ModuleFlags flags)
ModuleFlags& Glib::operator|= (ModuleFlags& lhs, ModuleFlags rhs)
ModuleFlags& Glib::operator&= (ModuleFlags& lhs, ModuleFlags rhs)
ModuleFlags& Glib::operator^= (ModuleFlags& lhs, ModuleFlags rhs)
RegexCompileFlags Glib::operator| (RegexCompileFlags lhs, RegexCompileFlags rhs)
RegexCompileFlags Glib::operator& (RegexCompileFlags lhs, RegexCompileFlags rhs)
RegexCompileFlags Glib::operator^ (RegexCompileFlags lhs, RegexCompileFlags rhs)
RegexCompileFlags Glib::operator~ (RegexCompileFlags flags)
RegexCompileFlags& Glib::operator|= (RegexCompileFlags& lhs, RegexCompileFlags rhs)
RegexCompileFlags& Glib::operator&= (RegexCompileFlags& lhs, RegexCompileFlags rhs)
RegexCompileFlags& Glib::operator^= (RegexCompileFlags& lhs, RegexCompileFlags rhs)
RegexMatchFlags Glib::operator| (RegexMatchFlags lhs, RegexMatchFlags rhs)
RegexMatchFlags Glib::operator& (RegexMatchFlags lhs, RegexMatchFlags rhs)
RegexMatchFlags Glib::operator^ (RegexMatchFlags lhs, RegexMatchFlags rhs)
RegexMatchFlags Glib::operator~ (RegexMatchFlags flags)
RegexMatchFlags& Glib::operator|= (RegexMatchFlags& lhs, RegexMatchFlags rhs)
RegexMatchFlags& Glib::operator&= (RegexMatchFlags& lhs, RegexMatchFlags rhs)
RegexMatchFlags& Glib::operator^= (RegexMatchFlags& lhs, RegexMatchFlags 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

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
ASCII_ALNUM
ASCII_ALPHA
ASCII_CNTRL
ASCII_DIGIT
ASCII_GRAPH
ASCII_LOWER
ASCII_PRINT
ASCII_PUNCT
ASCII_SPACE
ASCII_UPPER
ASCII_XDIGIT

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:
BindingFlags operator|(BindingFlags, BindingFlags)

BindingFlags operator&(BindingFlags, BindingFlags)

BindingFlags operator^(BindingFlags, BindingFlags)

BindingFlags operator~(BindingFlags)

BindingFlags& operator|=(BindingFlags&, BindingFlags)

BindingFlags& operator&=(BindingFlags&, BindingFlags)

BindingFlags& operator^=(BindingFlags&, BindingFlags)

Enumerator
BINDING_DEFAULT

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

BINDING_BIDIRECTIONAL

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

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

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

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

Note that the ChecksumType enumeration may be extended at a later date to include new hashing algorithm types.

Since glibmm 2.16:
Enumerator
CHECKSUM_MD5

Use the MD5 hashing algorithm.

CHECKSUM_SHA1

Use the SHA-1 hashing algorithm.

CHECKSUM_SHA256

Use the SHA-256 hashing algorithm.

CHECKSUM_SHA512

Use the SHA-512 hashing algorithm.

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.

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

FILE_TEST_IS_SYMLINK

true if the file is a symlink.

FILE_TEST_IS_DIR

true if the file is a directory.

FILE_TEST_IS_EXECUTABLE

true if the file is executable.

FILE_TEST_EXISTS

true if the file exists.

It may or may not be a regular file.

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
FORMAT_SIZE_DEFAULT

Behave the same as g_format_size().

FORMAT_SIZE_LONG_FORMAT

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

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

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

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

Bitwise operators:
IOCondition operator|(IOCondition, IOCondition)

IOCondition operator&(IOCondition, IOCondition)

IOCondition operator^(IOCondition, IOCondition)

IOCondition operator~(IOCondition)

IOCondition& operator|=(IOCondition&, IOCondition)

IOCondition& operator&=(IOCondition&, IOCondition)

IOCondition& operator^=(IOCondition&, IOCondition)

Enumerator
IO_IN

A bitwise combination representing an I/O 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::IO_OUT ) != 0)
do_some_output();

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.

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
IO_FLAG_APPEND

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

IO_FLAG_NONBLOCK

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

IO_FLAG_IS_READABLE

Indicates that the io channel is readable.

This flag cannot be changed.

IO_FLAG_IS_WRITABLE

Indicates that the io channel is writable.

This flag cannot be changed.

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

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

IO_FLAG_MASK

The mask that specifies all the valid flags.

IO_FLAG_GET_MASK

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

IO_FLAG_SET_MASK

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

Stati returned by most of the IOFuncs functions.

Enumerator
IO_STATUS_ERROR

An error occurred.

IO_STATUS_NORMAL

Success.

IO_STATUS_EOF

End of file.

IO_STATUS_AGAIN

Resource temporarily unavailable.

Flags which influence the parsing.

Bitwise operators:
KeyFileFlags operator|(KeyFileFlags, KeyFileFlags)

KeyFileFlags operator&(KeyFileFlags, KeyFileFlags)

KeyFileFlags operator^(KeyFileFlags, KeyFileFlags)

KeyFileFlags operator~(KeyFileFlags)

KeyFileFlags& operator|=(KeyFileFlags&, KeyFileFlags)

KeyFileFlags& operator&=(KeyFileFlags&, KeyFileFlags)

KeyFileFlags& operator^=(KeyFileFlags&, KeyFileFlags)

Enumerator
KEY_FILE_NONE

No flags, default behaviour.

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

KEY_FILE_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 passed to g_module_open().

Note that these flags are not supported on all platforms.

Bitwise operators:
ModuleFlags operator|(ModuleFlags, ModuleFlags)

ModuleFlags operator&(ModuleFlags, ModuleFlags)

ModuleFlags operator^(ModuleFlags, ModuleFlags)

ModuleFlags operator~(ModuleFlags)

ModuleFlags& operator|=(ModuleFlags&, ModuleFlags)

ModuleFlags& operator&=(ModuleFlags&, ModuleFlags)

ModuleFlags& operator^=(ModuleFlags&, ModuleFlags)

Enumerator
MODULE_BIND_LAZY

Specifies that symbols are only resolved when needed.

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

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

MODULE_BIND_MASK

Mask for all flags.

Enumeration representing a month; values are DATE_JANUARY, DATE_FEBRUARY, etc.

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.

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
NORMALIZE_DEFAULT

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

NORMALIZE_NFD

Another name for NORMALIZE_DEFAULT.

NORMALIZE_DEFAULT_COMPOSE

Like NORMALIZE_DEFAULT, but with composed forms rather than a maximally decomposed form.

NORMALIZE_NFC

Another name for NORMALIZE_DEFAULT_COMPOSE.

NORMALIZE_ALL

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

NORMALIZE_NFKD

Another name for NORMALIZE_ALL.

NORMALIZE_ALL_COMPOSE

Like NORMALIZE_ALL, but with composed forms rather than a maximally decomposed form.

NORMALIZE_NFKC

Another name for NORMALIZE_ALL_COMPOSE.

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

If an option expects an extra argument, it can be specified in several ways; with a short option: "-x arg", with a long option: "--name arg" or combined in a single argument: "--name=arg". All option types except OPTION_TYPE_BOOL expect an extra argument. OPTION_TYPE_STRING_VECTOR and OPTION_TYPE_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
OPTION_TYPE_BOOL

bool

OPTION_TYPE_STRING

Glib::ustring .

OPTION_TYPE_INT

gint32

OPTION_TYPE_FILENAME

std::string

OPTION_TYPE_STRING_VECTOR

std::vector<Glib::ustring>

OPTION_TYPE_FILENAME_VECTOR

std::vector<std::string>

OPTION_TYPE_DOUBLE

double

OPTION_TYPE_INT64

gint64

Flags that affect the behaviour of the parser.

Bitwise operators:
ParseFlags operator|(ParseFlags, ParseFlags)

ParseFlags operator&(ParseFlags, ParseFlags)

ParseFlags operator^(ParseFlags, ParseFlags)

ParseFlags operator~(ParseFlags)

ParseFlags& operator|=(ParseFlags&, ParseFlags)

ParseFlags& operator&=(ParseFlags&, ParseFlags)

ParseFlags& operator^=(ParseFlags&, ParseFlags)

Enumerator
DO_NOT_USE_THIS_UNSUPPORTED_FLAG

There are no flags right now.

Pass Glib::Markup::ParseFlags(0) for the flags argument to all functions (this should be the default argument anyway).

Flag you should not use.

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:

Flags specifying compile-time options.

Since glibmm 2.14:
Bitwise operators:
RegexCompileFlags operator|(RegexCompileFlags, RegexCompileFlags)

RegexCompileFlags operator&(RegexCompileFlags, RegexCompileFlags)

RegexCompileFlags operator^(RegexCompileFlags, RegexCompileFlags)

RegexCompileFlags operator~(RegexCompileFlags)

RegexCompileFlags& operator|=(RegexCompileFlags&, RegexCompileFlags)

RegexCompileFlags& operator&=(RegexCompileFlags&, RegexCompileFlags)

RegexCompileFlags& operator^=(RegexCompileFlags&, RegexCompileFlags)

Enumerator
REGEX_CASELESS

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

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

REGEX_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 REGEX_DOLLAR_ENDONLY is set). When REGEX_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.

REGEX_DOTALL

A dot metacharater (".") 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.

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

REGEX_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 "^" metacharater.

REGEX_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 REGEX_MULTILINE is set.

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

REGEX_RAW

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

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

REGEX_OPTIMIZE

Optimize the regular expression.

If the pattern will be used many times, then it may be worth the effort to optimize it to improve the speed of matches.

REGEX_FIRSTLINE

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

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

REGEX_NEWLINE_CR

Usually any newline character or character sequence is recognized.

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

REGEX_NEWLINE_LF

Usually any newline character or character sequence is recognized.

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

REGEX_NEWLINE_CRLF

Usually any newline character or character sequence is recognized.

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

REGEX_NEWLINE_ANYCRLF

Usually any newline character or character sequence is recognized.

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

Since glibmm 2.34:
REGEX_BSR_ANYCRLF

Usually any newline character or character sequence is recognised.

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

Since glibmm 2.34:
REGEX_JAVASCRIPT_COMPAT

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

Since glibmm 2.34:

Flags specifying match-time options.

Since glibmm 2.14:
Bitwise operators:
RegexMatchFlags operator|(RegexMatchFlags, RegexMatchFlags)

RegexMatchFlags operator&(RegexMatchFlags, RegexMatchFlags)

RegexMatchFlags operator^(RegexMatchFlags, RegexMatchFlags)

RegexMatchFlags operator~(RegexMatchFlags)

RegexMatchFlags& operator|=(RegexMatchFlags&, RegexMatchFlags)

RegexMatchFlags& operator&=(RegexMatchFlags&, RegexMatchFlags)

RegexMatchFlags& operator^=(RegexMatchFlags&, RegexMatchFlags)

Enumerator
REGEX_MATCH_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 "^" metacharater.

REGEX_MATCH_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 REGEX_MULTILINE (at compile time) causes circumflex never to match. This option affects only the behaviour of the circumflex metacharacter, it does not affect "\\A".

REGEX_MATCH_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 REGEX_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".

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

REGEX_MATCH_PARTIAL

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

REGEX_MATCH_NEWLINE_CR

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

REGEX_MATCH_NEWLINE_LF

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

REGEX_MATCH_NEWLINE_CRLF

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

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

REGEX_MATCH_NEWLINE_ANYCRLF

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

Since glibmm 2.34:
REGEX_MATCH_BSR_ANYCRLF

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

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

An alias for REGEX_MATCH_PARTIAL.

Since glibmm 2.34:
REGEX_MATCH_PARTIAL_HARD

Turns on the partial matching feature.

In contrast to to REGEX_MATCH_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:
REGEX_MATCH_NOTEMPTY_ATSTART

Like REGEX_MATCH_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:

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

Enumerator
SEEK_TYPE_CUR

The current position in the file.

SEEK_TYPE_SET

The start of the file.

SEEK_TYPE_END

The end of the file.

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
SPAWN_DEFAULT

No flags, default behaviour.

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

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

SPAWN_SEARCH_PATH

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

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

SPAWN_STDERR_TO_DEV_NULL

The child's standard error will be discarded.

SPAWN_CHILD_INHERITS_STDIN

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

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

SPAWN_SEARCH_PATH_FROM_ENVP

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

Since glibmm 2.34:
SPAWN_CLOEXEC_PIPES

Create all pipes with the O_CLOEXEC flag set.

Since glibmm 2.40:

Thread priorities.

Deprecated:2.32: Thread priorities no longer have any effect.

Enumerator
THREAD_PRIORITY_LOW
Deprecated:
Thread priorities no longer have any effect.

A priority lower than normal.

A priority lower than normal.

THREAD_PRIORITY_NORMAL

The default priority.

The default priority.

THREAD_PRIORITY_HIGH

A priority higher than normal.

A priority higher than normal.

THREAD_PRIORITY_URGENT

The highest priority.

The highest priority.

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
TIME_TYPE_STANDARD

The time is in local standard time.

TIME_TYPE_DAYLIGHT

The time is in local daylight time.

TIME_TYPE_UNIVERSAL

The time is in UTC.

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

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

Enumerator
TRAVERSE_LEAVES

Only leaf nodes should be visited.

TRAVERSE_NON_LEAVES

Only non-leaf nodes should be visited.

TRAVERSE_ALL

All nodes should be visited.

TRAVERSE_MASK

A mask of all traverse flags.

Specifies the type of traveral performed by methods such as NodeTree::_traverse() and NodeTree::find() .

Enumerator
TRAVERSE_IN_ORDER

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

TRAVERSE_PRE_ORDER

Visits a node, then its children.

TRAVERSE_POST_ORDER

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

TRAVERSE_LEVEL_ORDER

For NodeTree , 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. This is not implemented for Glib::Tree.

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

See http://www.unicode.org/unicode/reports/tr14/ .

Enumerator
UNICODE_BREAK_MANDATORY

Mandatory Break (BK).

UNICODE_BREAK_CARRIAGE_RETURN

Carriage Return (CR).

UNICODE_BREAK_LINE_FEED

Line Feed (LF).

UNICODE_BREAK_COMBINING_MARK

Attached Characters and Combining Marks (CM).

UNICODE_BREAK_SURROGATE

Surrogates (SG).

UNICODE_BREAK_ZERO_WIDTH_SPACE

Zero Width Space (ZW).

UNICODE_BREAK_INSEPARABLE

Inseparable (IN).

UNICODE_BREAK_NON_BREAKING_GLUE

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

UNICODE_BREAK_CONTINGENT

Contingent Break Opportunity (CB).

UNICODE_BREAK_SPACE

Space (SP).

UNICODE_BREAK_AFTER

Break Opportunity After (BA).

UNICODE_BREAK_BEFORE

Break Opportunity Before (BB).

UNICODE_BREAK_BEFORE_AND_AFTER

Break Opportunity Before and After (B2).

UNICODE_BREAK_HYPHEN

Hyphen (HY).

UNICODE_BREAK_NON_STARTER

Nonstarter (NS).

UNICODE_BREAK_OPEN_PUNCTUATION

Opening Punctuation (OP).

UNICODE_BREAK_CLOSE_PUNCTUATION

Closing Punctuation (CL).

UNICODE_BREAK_QUOTATION

Ambiguous Quotation (QU).

UNICODE_BREAK_EXCLAMATION

Exclamation/Interrogation (EX).

UNICODE_BREAK_IDEOGRAPHIC

Ideographic (ID).

UNICODE_BREAK_NUMERIC

Numeric (NU).

UNICODE_BREAK_INFIX_SEPARATOR

Infix Separator (Numeric) (IS).

UNICODE_BREAK_SYMBOL

Symbols Allowing Break After (SY).

UNICODE_BREAK_ALPHABETIC

Ordinary Alphabetic and Symbol Characters (AL).

UNICODE_BREAK_PREFIX

Prefix (Numeric) (PR).

UNICODE_BREAK_POSTFIX

Postfix (Numeric) (PO).

UNICODE_BREAK_COMPLEX_CONTEXT

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

UNICODE_BREAK_AMBIGUOUS

Ambiguous (Alphabetic or Ideographic) (AI).

UNICODE_BREAK_UNKNOWN

Unknown (XX).

UNICODE_BREAK_NEXT_LINE

Next Line (NL).

UNICODE_BREAK_WORD_JOINER

Word Joiner (WJ).

UNICODE_BREAK_HANGUL_L_JAMO

Hangul L Jamo (JL).

UNICODE_BREAK_HANGUL_V_JAMO

Hangul V Jamo (JV).

UNICODE_BREAK_HANGUL_T_JAMO

Hangul T Jamo (JT).

UNICODE_BREAK_HANGUL_LV_SYLLABLE

Hangul LV Syllable (H2).

UNICODE_BREAK_HANGUL_LVT_SYLLABLE

Hangul LVT Syllable (H3).

UNICODE_BREAK_CLOSE_PARANTHESIS

Closing Parenthesis (CP).

Since glibmm 2.28:
UNICODE_BREAK_CONDITIONAL_JAPANESE_STARTER

Conditional Japanese Starter (CJ).

Since glibmm 2.32:
UNICODE_BREAK_HEBREW_LETTER

Hebrew Letter (HL).

Since glibmm 2.32:
UNICODE_BREAK_REGIONAL_INDICATOR

Regional Indicator (RI).

Since glibmm 2.36:

These are the possible character classifications from the Unicode specification.

See http://www.unicode.org/Public/UNIDATA/UnicodeData.html .

Enumerator
UNICODE_CONTROL

General category "Other, Control" (Cc).

UNICODE_FORMAT

General category "Other, Format" (Cf).

UNICODE_UNASSIGNED

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

UNICODE_PRIVATE_USE

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

UNICODE_SURROGATE

General category "Other, Surrogate" (Cs).

UNICODE_LOWERCASE_LETTER

General category "Letter, Lowercase" (Ll).

UNICODE_MODIFIER_LETTER

General category "Letter, Modifier" (Lm).

UNICODE_OTHER_LETTER

General category "Letter, Other" (Lo).

UNICODE_TITLECASE_LETTER

General category "Letter, Titlecase" (Lt).

UNICODE_UPPERCASE_LETTER

General category "Letter, Uppercase" (Lu).

UNICODE_SPACING_MARK

General category "Mark, Spacing" (Mc).

UNICODE_ENCLOSING_MARK

General category "Mark, Enclosing" (Me).

UNICODE_NON_SPACING_MARK

General category "Mark, Nonspacing" (Mn).

UNICODE_DECIMAL_NUMBER

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

UNICODE_LETTER_NUMBER

General category "Number, Letter" (Nl).

UNICODE_OTHER_NUMBER

General category "Number, Other" (No).

UNICODE_CONNECT_PUNCTUATION

General category "Punctuation, Connector" (Pc).

UNICODE_DASH_PUNCTUATION

General category "Punctuation, Dash" (Pd).

UNICODE_CLOSE_PUNCTUATION

General category "Punctuation, Close" (Pe).

UNICODE_FINAL_PUNCTUATION

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

UNICODE_INITIAL_PUNCTUATION

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

UNICODE_OTHER_PUNCTUATION

General category "Punctuation, Other" (Po).

UNICODE_OPEN_PUNCTUATION

General category "Punctuation, Open" (Ps).

UNICODE_CURRENCY_SYMBOL

General category "Symbol, Currency" (Sc).

UNICODE_MODIFIER_SYMBOL

General category "Symbol, Modifier" (Sk).

UNICODE_MATH_SYMBOL

General category "Symbol, Math" (Sm).

UNICODE_OTHER_SYMBOL

General category "Symbol, Other" (So).

UNICODE_LINE_SEPARATOR

General category "Separator, Line" (Zl).

UNICODE_PARAGRAPH_SEPARATOR

General category "Separator, Paragraph" (Zp).

UNICODE_SPACE_SEPARATOR

General category "Separator, Space" (Zs).

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
USER_DIRECTORY_DESKTOP

The user's Desktop directory.

USER_DIRECTORY_DOCUMENTS

The user's Documents directory.

USER_DIRECTORY_DOWNLOAD

The user's Downloads directory.

USER_DIRECTORY_MUSIC

The user's Music directory.

USER_DIRECTORY_PICTURES

The user's Pictures directory.

USER_DIRECTORY_PUBLIC_SHARE

The user's shared directory.

USER_DIRECTORY_TEMPLATES

The user's Templates directory.

USER_DIRECTORY_VIDEOS

The user's Movies directory.

USER_N_DIRECTORIES

The number of enum values.

Enumeration representing a day of the week; DATE_MONDAY, DATE_TUESDAY, etc.

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

ModuleFlags Glib::operator& ( ModuleFlags lhs ,
ModuleFlags rhs
)
inline
KeyFileFlags Glib::operator& ( KeyFileFlags lhs ,
KeyFileFlags rhs
)
inline
FileTest Glib::operator& ( FileTest lhs ,
FileTest rhs
)
inline
BindingFlags Glib::operator& ( BindingFlags lhs ,
BindingFlags rhs
)
inline
SpawnFlags Glib::operator& ( SpawnFlags lhs ,
SpawnFlags rhs
)
inline
FormatSizeFlags Glib::operator& ( FormatSizeFlags lhs ,
FormatSizeFlags rhs
)
inline
IOFlags Glib::operator& ( IOFlags lhs ,
IOFlags rhs
)
inline
RegexCompileFlags Glib::operator& ( RegexCompileFlags lhs ,
RegexCompileFlags rhs
)
inline
ParseFlags Glib::Markup::operator& ( ParseFlags lhs ,
ParseFlags rhs
)
inline
IOCondition Glib::operator& ( IOCondition lhs ,
IOCondition rhs
)
inline
RegexMatchFlags Glib::operator& ( RegexMatchFlags lhs ,
RegexMatchFlags rhs
)
inline
AsciiType Glib::operator& ( AsciiType lhs ,
AsciiType rhs
)
inline
ModuleFlags& Glib::operator&= ( ModuleFlags & lhs ,
ModuleFlags rhs
)
inline
KeyFileFlags& Glib::operator&= ( KeyFileFlags & lhs ,
KeyFileFlags rhs
)
inline
FileTest& Glib::operator&= ( FileTest & lhs ,
FileTest rhs
)
inline
BindingFlags& Glib::operator&= ( BindingFlags & lhs ,
BindingFlags rhs
)
inline
SpawnFlags& Glib::operator&= ( SpawnFlags & lhs ,
SpawnFlags rhs
)
inline
FormatSizeFlags& Glib::operator&= ( FormatSizeFlags & lhs ,
FormatSizeFlags rhs
)
inline
IOFlags& Glib::operator&= ( IOFlags & lhs ,
IOFlags rhs
)
inline
RegexCompileFlags& Glib::operator&= ( RegexCompileFlags & lhs ,
RegexCompileFlags rhs
)
inline
ParseFlags& Glib::Markup::operator&= ( ParseFlags & lhs ,
ParseFlags rhs
)
inline
IOCondition& Glib::operator&= ( IOCondition & lhs ,
IOCondition rhs
)
inline
RegexMatchFlags& Glib::operator&= ( RegexMatchFlags & lhs ,
RegexMatchFlags rhs
)
inline
AsciiType& Glib::operator&= ( AsciiType & lhs ,
AsciiType rhs
)
inline
ModuleFlags Glib::operator^ ( ModuleFlags lhs ,
ModuleFlags rhs
)
inline
KeyFileFlags Glib::operator^ ( KeyFileFlags lhs ,
KeyFileFlags rhs
)
inline
FileTest Glib::operator^ ( FileTest lhs ,
FileTest rhs
)
inline
BindingFlags Glib::operator^ ( BindingFlags lhs ,
BindingFlags rhs
)
inline
SpawnFlags Glib::operator^ ( SpawnFlags lhs ,
SpawnFlags rhs
)
inline
FormatSizeFlags Glib::operator^ ( FormatSizeFlags lhs ,
FormatSizeFlags rhs
)
inline
IOFlags Glib::operator^ ( IOFlags lhs ,
IOFlags rhs
)
inline
RegexCompileFlags Glib::operator^ ( RegexCompileFlags lhs ,
RegexCompileFlags rhs
)
inline
ParseFlags Glib::Markup::operator^ ( ParseFlags lhs ,
ParseFlags rhs
)
inline
IOCondition Glib::operator^ ( IOCondition lhs ,
IOCondition rhs
)
inline
RegexMatchFlags Glib::operator^ ( RegexMatchFlags lhs ,
RegexMatchFlags rhs
)
inline
AsciiType Glib::operator^ ( AsciiType lhs ,
AsciiType rhs
)
inline
ModuleFlags& Glib::operator^= ( ModuleFlags & lhs ,
ModuleFlags rhs
)
inline
KeyFileFlags& Glib::operator^= ( KeyFileFlags & lhs ,
KeyFileFlags rhs
)
inline
FileTest& Glib::operator^= ( FileTest & lhs ,
FileTest rhs
)
inline
BindingFlags& Glib::operator^= ( BindingFlags & lhs ,
BindingFlags rhs
)
inline
SpawnFlags& Glib::operator^= ( SpawnFlags & lhs ,
SpawnFlags rhs
)
inline
FormatSizeFlags& Glib::operator^= ( FormatSizeFlags & lhs ,
FormatSizeFlags rhs
)
inline
IOFlags& Glib::operator^= ( IOFlags & lhs ,
IOFlags rhs
)
inline
RegexCompileFlags& Glib::operator^= ( RegexCompileFlags & lhs ,
RegexCompileFlags rhs
)
inline
ParseFlags& Glib::Markup::operator^= ( ParseFlags & lhs ,
ParseFlags rhs
)
inline
IOCondition& Glib::operator^= ( IOCondition & lhs ,
IOCondition rhs
)
inline
RegexMatchFlags& Glib::operator^= ( RegexMatchFlags & lhs ,
RegexMatchFlags rhs
)
inline
AsciiType& Glib::operator^= ( AsciiType & lhs ,
AsciiType rhs
)
inline
ModuleFlags Glib::operator| ( ModuleFlags lhs ,
ModuleFlags rhs
)
inline
KeyFileFlags Glib::operator| ( KeyFileFlags lhs ,
KeyFileFlags rhs
)
inline
FileTest Glib::operator| ( FileTest lhs ,
FileTest rhs
)
inline
BindingFlags Glib::operator| ( BindingFlags lhs ,
BindingFlags rhs
)
inline
SpawnFlags Glib::operator| ( SpawnFlags lhs ,
SpawnFlags rhs
)
inline
FormatSizeFlags Glib::operator| ( FormatSizeFlags lhs ,
FormatSizeFlags rhs
)
inline
IOFlags Glib::operator| ( IOFlags lhs ,
IOFlags rhs
)
inline
RegexCompileFlags Glib::operator| ( RegexCompileFlags lhs ,
RegexCompileFlags rhs
)
inline
ParseFlags Glib::Markup::operator| ( ParseFlags lhs ,
ParseFlags rhs
)
inline
IOCondition Glib::operator| ( IOCondition lhs ,
IOCondition rhs
)
inline
RegexMatchFlags Glib::operator| ( RegexMatchFlags lhs ,
RegexMatchFlags rhs
)
inline
AsciiType Glib::operator| ( AsciiType lhs ,
AsciiType rhs
)
inline
ModuleFlags& Glib::operator|= ( ModuleFlags & lhs ,
ModuleFlags rhs
)
inline
KeyFileFlags& Glib::operator|= ( KeyFileFlags & lhs ,
KeyFileFlags rhs
)
inline
FileTest& Glib::operator|= ( FileTest & lhs ,
FileTest rhs
)
inline
BindingFlags& Glib::operator|= ( BindingFlags & lhs ,
BindingFlags rhs
)
inline
SpawnFlags& Glib::operator|= ( SpawnFlags & lhs ,
SpawnFlags rhs
)
inline
FormatSizeFlags& Glib::operator|= ( FormatSizeFlags & lhs ,
FormatSizeFlags rhs
)
inline
IOFlags& Glib::operator|= ( IOFlags & lhs ,
IOFlags rhs
)
inline
RegexCompileFlags& Glib::operator|= ( RegexCompileFlags & lhs ,
RegexCompileFlags rhs
)
inline
ParseFlags& Glib::Markup::operator|= ( ParseFlags & lhs ,
ParseFlags rhs
)
inline
IOCondition& Glib::operator|= ( IOCondition & lhs ,
IOCondition rhs
)
inline
RegexMatchFlags& Glib::operator|= ( RegexMatchFlags & lhs ,
RegexMatchFlags rhs
)
inline
AsciiType& Glib::operator|= ( AsciiType & lhs ,
AsciiType rhs
)
inline
ModuleFlags Glib::operator~ ( ModuleFlags flags )
inline
KeyFileFlags Glib::operator~ ( KeyFileFlags flags )
inline
FileTest Glib::operator~ ( FileTest flags )
inline
BindingFlags Glib::operator~ ( BindingFlags flags )
inline
SpawnFlags Glib::operator~ ( SpawnFlags flags )
inline
FormatSizeFlags Glib::operator~ ( FormatSizeFlags flags )
inline
IOFlags Glib::operator~ ( IOFlags flags )
inline
RegexCompileFlags Glib::operator~ ( RegexCompileFlags flags )
inline
ParseFlags Glib::Markup::operator~ ( ParseFlags flags )
inline
IOCondition Glib::operator~ ( IOCondition flags )
inline
RegexMatchFlags Glib::operator~ ( RegexMatchFlags flags )
inline
AsciiType Glib::operator~ ( AsciiType flags )
inline