glibmm: glibmm Enums and Flags

glibmm 2.32.1

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

Classes | Enumerations | Functions
glibmm Enums and Flags

## Classes
class | ChecksumType
| CHECKSUM_MD5: Use the MD5 hashing algorithm CHECKSUM_SHA1: Use the SHA-1 hashing algorithm CHECKSUM_SHA256: Use the SHA-256 hashing algorithm More...

## Enumerations
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 }
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 }
enum | Glib::Date::DMY { Glib::Date::DAY, Glib::Date::MONTH, Glib::Date::YEAR }
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 }
enum | Glib::SeekType { Glib::SEEK_TYPE_CUR, Glib::SEEK_TYPE_SET, Glib::SEEK_TYPE_END }
enum | Glib::IOStatus { Glib::IO_STATUS_ERROR, Glib::IO_STATUS_NORMAL, Glib::IO_STATUS_EOF, Glib::IO_STATUS_AGAIN }
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_WRITEABLE = 1 << 3, Glib::IO_FLAG_IS_WRITABLE = 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 }
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 an I/O 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 }
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 }
| There are no flags right now. More...
enum | Glib::ModuleFlags { Glib::MODULE_BIND_LAZY = 1 << 0, Glib::MODULE_BIND_LOCAL = 1 << 1, Glib::MODULE_BIND_MASK = 0x03 }
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::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_DUPNAMES = 1 << 19, Glib::REGEX_NEWLINE_CR = 1 << 20, Glib::REGEX_NEWLINE_LF = 1 << 21, Glib::REGEX_NEWLINE_CRLF = 0x300000 }
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 }
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 }
enum | Glib::ThreadPriority { Glib::THREAD_PRIORITY_LOW, Glib::THREAD_PRIORITY_NORMAL, Glib::THREAD_PRIORITY_HIGH, Glib::THREAD_PRIORITY_URGENT }
enum | Glib::TimeType { Glib::TIME_TYPE_STANDARD, Glib::TIME_TYPE_DAYLIGHT, Glib::TIME_TYPE_UNIVERSAL }
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 }
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 }
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::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 }

## 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::Date::DMY

Enumerator:

  DAY |
  MONTH |
  YEAR |

enum Glib::FileTest

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 |
  FILE_TEST_IS_SYMLINK |
  FILE_TEST_IS_DIR |
  FILE_TEST_IS_EXECUTABLE |
  FILE_TEST_EXISTS |

enum Glib::IOCondition

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

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 |
  IO_OUT |
  IO_PRI |
  IO_ERR |
  IO_HUP |
  IO_NVAL |

enum Glib::IOFlags

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 |
  IO_FLAG_NONBLOCK |
  IO_FLAG_IS_READABLE |
  IO_FLAG_IS_WRITEABLE |
  IO_FLAG_IS_WRITABLE |
  IO_FLAG_IS_SEEKABLE |
  IO_FLAG_MASK |
  IO_FLAG_GET_MASK |
  IO_FLAG_SET_MASK |

enum Glib::IOStatus

Enumerator:

  IO_STATUS_ERROR |
  IO_STATUS_NORMAL |
  IO_STATUS_EOF |
  IO_STATUS_AGAIN |

enum Glib::KeyFileFlags

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

enum Glib::ModuleFlags

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

enum Glib::Date::Month

Enumerator:

  BAD_MONTH |
  JANUARY |
  FEBRUARY |
  MARCH |
  APRIL |
  MAY |
  JUNE |
  JULY |
  AUGUST |
  SEPTEMBER |
  OCTOBER |
  NOVEMBER |
  DECEMBER |

enum Glib::NormalizeMode

Enumerator:

  NORMALIZE_DEFAULT |
  NORMALIZE_NFD |
  NORMALIZE_DEFAULT_COMPOSE |
  NORMALIZE_NFC |
  NORMALIZE_ALL |
  NORMALIZE_NFKD |
  NORMALIZE_ALL_COMPOSE |
  NORMALIZE_NFKC |

enum Glib::Markup::ParseFlags

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

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 | Flag you should not use.
  TREAT_CDATA_AS_TEXT |
  PREFIX_ERROR_POSITION |

enum Glib::RegexCompileFlags

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 |
  REGEX_MULTILINE |
  REGEX_DOTALL |
  REGEX_EXTENDED |
  REGEX_ANCHORED |
  REGEX_DOLLAR_ENDONLY |
  REGEX_UNGREEDY |
  REGEX_RAW |
  REGEX_NO_AUTO_CAPTURE |
  REGEX_OPTIMIZE |
  REGEX_DUPNAMES |
  REGEX_NEWLINE_CR |
  REGEX_NEWLINE_LF |
  REGEX_NEWLINE_CRLF |

enum Glib::RegexMatchFlags

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 |
  REGEX_MATCH_NOTBOL |
  REGEX_MATCH_NOTEOL |
  REGEX_MATCH_NOTEMPTY |
  REGEX_MATCH_PARTIAL |
  REGEX_MATCH_NEWLINE_CR |
  REGEX_MATCH_NEWLINE_LF |
  REGEX_MATCH_NEWLINE_CRLF |
  REGEX_MATCH_NEWLINE_ANY |

enum Glib::SeekType

Enumerator:

  SEEK_TYPE_CUR |
  SEEK_TYPE_SET |
  SEEK_TYPE_END |

enum Glib::SpawnFlags

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 |
  SPAWN_DO_NOT_REAP_CHILD |
  SPAWN_SEARCH_PATH |
  SPAWN_STDOUT_TO_DEV_NULL |
  SPAWN_STDERR_TO_DEV_NULL |
  SPAWN_CHILD_INHERITS_STDIN |
  SPAWN_FILE_AND_ARGV_ZERO |

enum Glib::ThreadPriority

Deprecated:
  Thread priorities no longer have any effect.

Enumerator:

  THREAD_PRIORITY_LOW | A priority lower than normal.
  THREAD_PRIORITY_NORMAL | The default priority.
  THREAD_PRIORITY_HIGH | A priority higher than normal.
  THREAD_PRIORITY_URGENT | The highest priority.

enum Glib::TimeType

Enumerator:

  TIME_TYPE_STANDARD |
  TIME_TYPE_DAYLIGHT |
  TIME_TYPE_UNIVERSAL |

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

Enumerator:

  UNICODE_BREAK_MANDATORY |
  UNICODE_BREAK_CARRIAGE_RETURN |
  UNICODE_BREAK_LINE_FEED |
  UNICODE_BREAK_COMBINING_MARK |
  UNICODE_BREAK_SURROGATE |
  UNICODE_BREAK_ZERO_WIDTH_SPACE |
  UNICODE_BREAK_INSEPARABLE |
  UNICODE_BREAK_NON_BREAKING_GLUE |
  UNICODE_BREAK_CONTINGENT |
  UNICODE_BREAK_SPACE |
  UNICODE_BREAK_AFTER |
  UNICODE_BREAK_BEFORE |
  UNICODE_BREAK_BEFORE_AND_AFTER |
  UNICODE_BREAK_HYPHEN |
  UNICODE_BREAK_NON_STARTER |
  UNICODE_BREAK_OPEN_PUNCTUATION |
  UNICODE_BREAK_CLOSE_PUNCTUATION |
  UNICODE_BREAK_QUOTATION |
  UNICODE_BREAK_EXCLAMATION |
  UNICODE_BREAK_IDEOGRAPHIC |
  UNICODE_BREAK_NUMERIC |
  UNICODE_BREAK_INFIX_SEPARATOR |
  UNICODE_BREAK_SYMBOL |
  UNICODE_BREAK_ALPHABETIC |
  UNICODE_BREAK_PREFIX |
  UNICODE_BREAK_POSTFIX |
  UNICODE_BREAK_COMPLEX_CONTEXT |
  UNICODE_BREAK_AMBIGUOUS |
  UNICODE_BREAK_UNKNOWN |
  UNICODE_BREAK_NEXT_LINE |
  UNICODE_BREAK_WORD_JOINER |
  UNICODE_BREAK_HANGUL_L_JAMO |
  UNICODE_BREAK_HANGUL_V_JAMO |
  UNICODE_BREAK_HANGUL_T_JAMO |
  UNICODE_BREAK_HANGUL_LV_SYLLABLE |
  UNICODE_BREAK_HANGUL_LVT_SYLLABLE |
  UNICODE_BREAK_CLOSE_PARANTHESIS |
  UNICODE_BREAK_CONDITIONAL_JAPANESE_STARTER |
  UNICODE_BREAK_HEBREW_LETTER |

enum Glib::UnicodeType

Enumerator:

  UNICODE_CONTROL |
  UNICODE_FORMAT |
  UNICODE_UNASSIGNED |
  UNICODE_PRIVATE_USE |
  UNICODE_SURROGATE |
  UNICODE_LOWERCASE_LETTER |
  UNICODE_MODIFIER_LETTER |
  UNICODE_OTHER_LETTER |
  UNICODE_TITLECASE_LETTER |
  UNICODE_UPPERCASE_LETTER |
  UNICODE_SPACING_MARK |
  UNICODE_ENCLOSING_MARK |
  UNICODE_NON_SPACING_MARK |
  UNICODE_DECIMAL_NUMBER |
  UNICODE_LETTER_NUMBER |
  UNICODE_OTHER_NUMBER |
  UNICODE_CONNECT_PUNCTUATION |
  UNICODE_DASH_PUNCTUATION |
  UNICODE_CLOSE_PUNCTUATION |
  UNICODE_FINAL_PUNCTUATION |
  UNICODE_INITIAL_PUNCTUATION |
  UNICODE_OTHER_PUNCTUATION |
  UNICODE_OPEN_PUNCTUATION |
  UNICODE_CURRENCY_SYMBOL |
  UNICODE_MODIFIER_SYMBOL |
  UNICODE_MATH_SYMBOL |
  UNICODE_OTHER_SYMBOL |
  UNICODE_LINE_SEPARATOR |
  UNICODE_PARAGRAPH_SEPARATOR |
  UNICODE_SPACE_SEPARATOR |

enum Glib::Date::Weekday

Enumerator:

  BAD_WEEKDAY |
  MONDAY |
  TUESDAY |
  WEDNESDAY |
  THURSDAY |
  FRIDAY |
  SATURDAY |
  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

RegexMatchFlags Glib::operator& | ( | RegexMatchFlags | lhs,
|  | RegexMatchFlags | rhs
| ) |  |
| inline

IOCondition Glib::operator& | ( | IOCondition | lhs,
|  | IOCondition | rhs
| ) |  |
| inline

AsciiType Glib::operator& | ( | AsciiType | lhs,
|  | AsciiType | rhs
| ) |  |
| inline

ParseFlags Glib::Markup::operator& | ( | ParseFlags | lhs,
|  | ParseFlags | 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

RegexMatchFlags& Glib::operator&= | ( | RegexMatchFlags & | lhs,
|  | RegexMatchFlags | rhs
| ) |  |
| inline

IOCondition& Glib::operator&= | ( | IOCondition & | lhs,
|  | IOCondition | rhs
| ) |  |
| inline

AsciiType& Glib::operator&= | ( | AsciiType & | lhs,
|  | AsciiType | rhs
| ) |  |
| inline

ParseFlags& Glib::Markup::operator&= | ( | ParseFlags & | lhs,
|  | ParseFlags | 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

RegexMatchFlags Glib::operator^ | ( | RegexMatchFlags | lhs,
|  | RegexMatchFlags | rhs
| ) |  |
| inline

IOCondition Glib::operator^ | ( | IOCondition | lhs,
|  | IOCondition | rhs
| ) |  |
| inline

AsciiType Glib::operator^ | ( | AsciiType | lhs,
|  | AsciiType | rhs
| ) |  |
| inline

ParseFlags Glib::Markup::operator^ | ( | ParseFlags | lhs,
|  | ParseFlags | 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

RegexMatchFlags& Glib::operator^= | ( | RegexMatchFlags & | lhs,
|  | RegexMatchFlags | rhs
| ) |  |
| inline

IOCondition& Glib::operator^= | ( | IOCondition & | lhs,
|  | IOCondition | rhs
| ) |  |
| inline

AsciiType& Glib::operator^= | ( | AsciiType & | lhs,
|  | AsciiType | rhs
| ) |  |
| inline

ParseFlags& Glib::Markup::operator^= | ( | ParseFlags & | lhs,
|  | ParseFlags | 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

RegexMatchFlags Glib::operator| | ( | RegexMatchFlags | lhs,
|  | RegexMatchFlags | rhs
| ) |  |
| inline

IOCondition Glib::operator| | ( | IOCondition | lhs,
|  | IOCondition | rhs
| ) |  |
| inline

AsciiType Glib::operator| | ( | AsciiType | lhs,
|  | AsciiType | rhs
| ) |  |
| inline

ParseFlags Glib::Markup::operator| | ( | ParseFlags | lhs,
|  | ParseFlags | 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

RegexMatchFlags& Glib::operator|= | ( | RegexMatchFlags & | lhs,
|  | RegexMatchFlags | rhs
| ) |  |
| inline

IOCondition& Glib::operator|= | ( | IOCondition & | lhs,
|  | IOCondition | rhs
| ) |  |
| inline

AsciiType& Glib::operator|= | ( | AsciiType & | lhs,
|  | AsciiType | rhs
| ) |  |
| inline

ParseFlags& Glib::Markup::operator|= | ( | ParseFlags & | lhs,
|  | ParseFlags | 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

RegexMatchFlags Glib::operator~ | ( | RegexMatchFlags | flags | ) |
| inline

IOCondition Glib::operator~ | ( | IOCondition | flags | ) |
| inline

AsciiType Glib::operator~ | ( | AsciiType | flags | ) |
| inline

ParseFlags Glib::Markup::operator~ | ( | ParseFlags | flags | ) |
| inline