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

enum Glib::AsciiType

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

enum Glib::Checksum::ChecksumType

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.

enum Glib::Date::DMY

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.

enum Glib::FileTest

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.

enum Glib::IOCondition

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.

enum Glib::IOFlags

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 APPEND(see the documentation of the UNIX open()syscall).
IO_FLAG_NONBLOCK	turns on nonblocking mode, corresponds toNONBLOCK/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
IO_FLAG_IS_SEEKABLE	indicates that the io channel is seekable,i.e. that g_io_channel_seek_position() canbe 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().

enum Glib::IOStatus

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.

enum Glib::KeyFileFlags

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.

enum Glib::ModuleFlags

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.

enum Glib::Date::Month

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.

enum Glib::NormalizeMode

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.

enum Glib::Markup::ParseFlags

Flags that affect the behaviour of the parser.

Bitwise operators:

ParseFlags operator|(ParseFlags, ParseFlags)

ParseFlags operator&(ParseFlags, ParseFlags)

ParseFlags operator^(ParseFlags, ParseFlags)

ParseFlags operator~(ParseFlags)

ParseFlags& operator|=(ParseFlags&, ParseFlags)

ParseFlags& operator&=(ParseFlags&, ParseFlags)

ParseFlags& operator^=(ParseFlags&, ParseFlags)

Enumerator
DO_NOT_USE_THIS_UNSUPPORTED_FLAG	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.

enum Glib::RegexCompileFlags

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:

enum Glib::RegexMatchFlags

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:

enum Glib::SeekType

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.

enum Glib::SpawnFlags

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 beinherited by the child; otherwise all descriptors except stdin/stdout/stderrwill be closed before calling exec() in the child.
SPAWN_DO_NOT_REAP_CHILD	the child will not be automatically reaped; youmust 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
SPAWN_STDERR_TO_DEV_NULL
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 isthe file to execute, while the remaining elements are the actual argumentvector to pass to the file. Normally g_spawn_async_with_pipes() usesargv[0] as the file to execute, and passes all ofargv 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:

enum Glib::ThreadPriority

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.

enum Glib::TimeType

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.

enum Glib::TraverseType

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.

enum Glib::UnicodeBreakType

These are the possible line break classifications.

Since new unicode versions may add new types here, applications should be ready to handle unknown values. They may be regarded as 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:

enum Glib::UnicodeType

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

enum Glib::Date::Weekday

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