glibmm  2.39.92
Enumerations | Functions
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  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::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
}
 Deprecated:2.32: Thread priorities no longer have any effect. 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

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

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 T::RUEif 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 notbe a regular file.

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 forpipes 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 A::PPEND(see the documentation of the UNIX open() syscall).

IO_FLAG_NONBLOCK 

turns on nonblocking mode, corresponds toN::ONBLOCK/N::DELAY (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 IO_FLAG_IS_WRITABLEthat existed before the spelling was fixed in GLib 2.30.

It is kepthere for compatibility reasons. Deprecated since 2.30.

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

IO_FLAG_SET_MASK 

the mask of the flags that the user can modifywith 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 iswritten 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 bewritten 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 whenneeded.

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

MODULE_BIND_LOCAL 

specifies that symbols in the module shouldnot be added to the global name space.

The default action on mostplatforms 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 thetext content, such as the above-mentioned accent representation.

NORMALIZE_NFD 

another name for Normalize::DEFAULT.

NORMALIZE_DEFAULT_COMPOSE 

like Normalize::DEFAULT, but withcomposed 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 THREEto the standard forms (in this case DIGIT THREE).

Formattinginformation may be lost but for most text operations suchcharacters should be considered the same.

NORMALIZE_NFKD 

another name for Normalize::ALL.

NORMALIZE_ALL_COMPOSE 

like Normalize::ALL, but with composedforms rather than a maximally decomposed form.

NORMALIZE_NFKC 

another name for Normalize::ALL_COMPOSE.

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 markedsections are not passed literally to the passthrough function ofthe parser.

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

PREFIX_ERROR_POSITION 

Normally errors caught by GMarkupitself have line/column information prefixed to them to let thecaller know the location of the error.

When this flag is set thelocation information is also prefixed to errors generated by theG::MarkupParser implementation functions.

IGNORE_QUALIFIED 

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

A qualifiedattribute or tag is one that contains ':' in its name (ie: is inanother 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- andlowercase letters.

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

REGEX_MULTILINE 

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

The "start of line" metacharacter ("^") matches onlyat the start of the string, while the "end of line" metacharacter("$") matches only at the end of the string, or before a terminatingnewline (unless Regex::DOLLAR_ENDONLY is set). WhenRegex::MULTILINE is set, the "start of line" and "end of line"constructs match immediately following or immediately before anynewline in the string, respectively, as well as at the very startand end. This can be changed within a pattern by a "(?m)" optionsetting.

REGEX_DOTALL 

A dot metacharater (".") in the pattern matches allcharacters, 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 aretotally 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 andthe next newline character, inclusive, are also ignored. This canbe 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 thestring that is being searched.

This effect can also be achieved byappropriate constructs in the pattern itself such as the "^"metacharater.

REGEX_DOLLAR_ENDONLY 

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

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

REGEX_UNGREEDY 

Inverts the "greediness" of the quantifiers so thatthey 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 thisflag they are considered as a raw sequence of bytes.

REGEX_NO_AUTO_CAPTURE 

Disables the use of numbered capturingparentheses in the pattern.

Any opening parenthesis that is notfollowed by "?" behaves as if it were followed by "?:" but namedparentheses can still be used for capturing (and they acquire numbersin the usual way).

REGEX_OPTIMIZE 

Optimize the regular expression.

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

REGEX_FIRSTLINE 

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

Since glibmm 2.34:
REGEX_DUPNAMES 

Names used to identify capturing subpatterns need notbe unique.

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

REGEX_NEWLINE_CR 

Usually any newline character or character sequence isrecognized.

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

REGEX_NEWLINE_LF 

Usually any newline character or character sequence isrecognized.

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

REGEX_NEWLINE_CRLF 

Usually any newline character or character sequence isrecognized.

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

REGEX_NEWLINE_ANYCRLF 

Usually any newline character or character sequenceis recognized.

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

Since glibmm 2.34:
REGEX_BSR_ANYCRLF 

Usually any newline character or character sequenceis recognised.

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

Since glibmm 2.34:
REGEX_JAVASCRIPT_COMPAT 

Changes behaviour so that it is compatible withJavaScript 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 thestring that is being searched.

This effect can also be achieved byappropriate constructs in the pattern itself such as the "^"metacharater.

REGEX_MATCH_NOTBOL 

Specifies that first character of the string isnot the beginning of a line, so the circumflex metacharacter shouldnot match before it.

Setting this without Regex::MULTILINE (atcompile time) causes circumflex never to match. This option affectsonly the behaviour of the circumflex metacharacter, it does notaffect "\\A".

REGEX_MATCH_NOTEOL 

Specifies that the end of the subject string isnot the end of a line, so the dollar metacharacter should not matchit nor (except in multiline mode) a newline immediately before it.Setting this without Regex::MULTILINE (at compile time) causesdollar never to match.

This option affects only the behaviour ofthe dollar metacharacter, it does not affect "\\Z" or "\\z".

REGEX_MATCH_NOTEMPTY 

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

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

REGEX_MATCH_PARTIAL 

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

REGEX_MATCH_NEWLINE_CR 

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

REGEX_MATCH_NEWLINE_LF 

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

REGEX_MATCH_NEWLINE_CRLF 

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

REGEX_MATCH_NEWLINE_ANY 

Overrides the newline definition set whencreating a new Regex, any Unicode newline sequenceis recognised as a newline.

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

REGEX_MATCH_NEWLINE_ANYCRLF 

Overrides the newline definition set whencreating a new Regex; any '\r', '\n', or '\r\n' character sequenceis recognized as a newline.

Since glibmm 2.34:
REGEX_MATCH_BSR_ANYCRLF 

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

Since glibmm 2.34:
REGEX_MATCH_BSR_ANY 

Overrides the newline definition for "\\R" set whencreating a new Regex; any Unicode newline character or character sequenceare recognized as a newline by "\\R".

These are '\r', '\n' and '\rn', and thesingle characters U+000B LINE TABULATION, U+000C FORM FEED (FF),U+0085 NEXT LINE (NEL), U+2028 LINE SEPARATOR andU+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 toto Regex::MATCH_PARTIAL_SOFT, this stops matching as soon as a partial matchis found, without continuing to search for a possible complete match. Seeg_match_info_is_partial_match() for more information.

Since glibmm 2.34:
REGEX_MATCH_NOTEMPTY_ATSTART 

Like Regex::MATCH_NOTEMPTY, but only applied tothe start of the matched string.

For anchoredpatterns 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 willbe 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 handleSIGCHLD yourself), or the child will become a zombie.

SPAWN_SEARCH_PATH 

argv[0] need not be an absolute path, it will belooked 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 standardinput (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 toexecute, while the remaining elements are the actual argument vectorto 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 CLOEXEC flag set.

Since glibmm 2.40:

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

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
SpawnFlags Glib::operator& ( SpawnFlags  lhs,
SpawnFlags  rhs 
)
inline
RegexCompileFlags Glib::operator& ( RegexCompileFlags  lhs,
RegexCompileFlags  rhs 
)
inline
IOFlags Glib::operator& ( IOFlags  lhs,
IOFlags  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
SpawnFlags& Glib::operator&= ( SpawnFlags &  lhs,
SpawnFlags  rhs 
)
inline
RegexCompileFlags& Glib::operator&= ( RegexCompileFlags &  lhs,
RegexCompileFlags  rhs 
)
inline
IOFlags& Glib::operator&= ( IOFlags &  lhs,
IOFlags  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
SpawnFlags Glib::operator^ ( SpawnFlags  lhs,
SpawnFlags  rhs 
)
inline
RegexCompileFlags Glib::operator^ ( RegexCompileFlags  lhs,
RegexCompileFlags  rhs 
)
inline
IOFlags Glib::operator^ ( IOFlags  lhs,
IOFlags  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
SpawnFlags& Glib::operator^= ( SpawnFlags &  lhs,
SpawnFlags  rhs 
)
inline
RegexCompileFlags& Glib::operator^= ( RegexCompileFlags &  lhs,
RegexCompileFlags  rhs 
)
inline
IOFlags& Glib::operator^= ( IOFlags &  lhs,
IOFlags  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
SpawnFlags Glib::operator| ( SpawnFlags  lhs,
SpawnFlags  rhs 
)
inline
RegexCompileFlags Glib::operator| ( RegexCompileFlags  lhs,
RegexCompileFlags  rhs 
)
inline
IOFlags Glib::operator| ( IOFlags  lhs,
IOFlags  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
SpawnFlags& Glib::operator|= ( SpawnFlags &  lhs,
SpawnFlags  rhs 
)
inline
RegexCompileFlags& Glib::operator|= ( RegexCompileFlags &  lhs,
RegexCompileFlags  rhs 
)
inline
IOFlags& Glib::operator|= ( IOFlags &  lhs,
IOFlags  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
SpawnFlags Glib::operator~ ( SpawnFlags  flags)
inline
RegexCompileFlags Glib::operator~ ( RegexCompileFlags  flags)
inline
IOFlags Glib::operator~ ( IOFlags  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