glibmm: glibmm Enums and Flags

glibmm 2.37.7

- Main Page
- Related Pages
- Modules
- Namespaces
- Classes
- Examples

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 }
| 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_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 to`NONBLOCK`/`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_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() 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:

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