glibmm: Enums and Flags

# 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_SEEKABLE = 1 << 4,
Glib::IO_FLAG_MASK = (1 << 5) - 1,
Glib::IO_FLAG_GET_MASK = 0x1F,
Glib::IO_FLAG_SET_MASK = 0x3
}

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::TraverseFlags {
Glib::NodeTree::TRAVERSE_LEAVES = G_TRAVERSE_LEAVES,
Glib::NodeTree::TRAVERSE_NON_LEAVES = G_TRAVERSE_NON_LEAVES,
Glib::NodeTree::TRAVERSE_ALL = G_TRAVERSE_ALL,
Glib::NodeTree::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
}

| Specifies the priority of a thread. 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_COMBINING_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
}

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

## 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`[inherited]`

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::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_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`[inherited]`

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

Specifies the priority of a thread.

Note:
  It is not guaranteed, that threads with different priorities really behave accordingly. On some systems (e.g. Linux) only `root` can increase priorities. On other systems (e.g. Solaris) there doesn't seem to be different scheduling for different priorities. All in all try to avoid being dependent on priorities.

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.

template <typename T >

enum Glib::NodeTree::TraverseFlags`[inherited]`

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 |

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_COMBINING_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`[inherited]`

Enumerator:

  BAD_WEEKDAY |
  MONDAY |
  TUESDAY |
  WEDNESDAY |
  THURSDAY |
  FRIDAY |
  SATURDAY |
  SUNDAY |

## Function Documentation

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

SpawnFlags Glib::operator& | ( | SpawnFlags | lhs,
|  | SpawnFlags | rhs |
| ) |  |  | `[inline]`

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

RegexCompileFlags Glib::operator& | ( | RegexCompileFlags | lhs,
|  | RegexCompileFlags | rhs |
| ) |  |  | `[inline]`

ModuleFlags Glib::operator& | ( | ModuleFlags | lhs,
|  | ModuleFlags | rhs |
| ) |  |  | `[inline]`

ParseFlags Glib::Markup::operator& | ( | ParseFlags | lhs,
|  | ParseFlags | rhs |
| ) |  |  | `[inline]`

KeyFileFlags Glib::operator& | ( | KeyFileFlags | lhs,
|  | KeyFileFlags | rhs |
| ) |  |  | `[inline]`

IOFlags Glib::operator& | ( | IOFlags | lhs,
|  | IOFlags | rhs |
| ) |  |  | `[inline]`

FileTest Glib::operator& | ( | FileTest | lhs,
|  | FileTest | rhs |
| ) |  |  | `[inline]`

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

SpawnFlags& Glib::operator&= | ( | SpawnFlags & | lhs,
|  | SpawnFlags | rhs |
| ) |  |  | `[inline]`

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

RegexCompileFlags& Glib::operator&= | ( | RegexCompileFlags & | lhs,
|  | RegexCompileFlags | rhs |
| ) |  |  | `[inline]`

ModuleFlags& Glib::operator&= | ( | ModuleFlags & | lhs,
|  | ModuleFlags | rhs |
| ) |  |  | `[inline]`

ParseFlags& Glib::Markup::operator&= | ( | ParseFlags & | lhs,
|  | ParseFlags | rhs |
| ) |  |  | `[inline]`

KeyFileFlags& Glib::operator&= | ( | KeyFileFlags & | lhs,
|  | KeyFileFlags | rhs |
| ) |  |  | `[inline]`

IOFlags& Glib::operator&= | ( | IOFlags & | lhs,
|  | IOFlags | rhs |
| ) |  |  | `[inline]`

FileTest& Glib::operator&= | ( | FileTest & | lhs,
|  | FileTest | rhs |
| ) |  |  | `[inline]`

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

SpawnFlags Glib::operator^ | ( | SpawnFlags | lhs,
|  | SpawnFlags | rhs |
| ) |  |  | `[inline]`

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

RegexCompileFlags Glib::operator^ | ( | RegexCompileFlags | lhs,
|  | RegexCompileFlags | rhs |
| ) |  |  | `[inline]`

ModuleFlags Glib::operator^ | ( | ModuleFlags | lhs,
|  | ModuleFlags | rhs |
| ) |  |  | `[inline]`

ParseFlags Glib::Markup::operator^ | ( | ParseFlags | lhs,
|  | ParseFlags | rhs |
| ) |  |  | `[inline]`

KeyFileFlags Glib::operator^ | ( | KeyFileFlags | lhs,
|  | KeyFileFlags | rhs |
| ) |  |  | `[inline]`

IOFlags Glib::operator^ | ( | IOFlags | lhs,
|  | IOFlags | rhs |
| ) |  |  | `[inline]`

FileTest Glib::operator^ | ( | FileTest | lhs,
|  | FileTest | rhs |
| ) |  |  | `[inline]`

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

SpawnFlags& Glib::operator^= | ( | SpawnFlags & | lhs,
|  | SpawnFlags | rhs |
| ) |  |  | `[inline]`

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

RegexCompileFlags& Glib::operator^= | ( | RegexCompileFlags & | lhs,
|  | RegexCompileFlags | rhs |
| ) |  |  | `[inline]`

ModuleFlags& Glib::operator^= | ( | ModuleFlags & | lhs,
|  | ModuleFlags | rhs |
| ) |  |  | `[inline]`

ParseFlags& Glib::Markup::operator^= | ( | ParseFlags & | lhs,
|  | ParseFlags | rhs |
| ) |  |  | `[inline]`

KeyFileFlags& Glib::operator^= | ( | KeyFileFlags & | lhs,
|  | KeyFileFlags | rhs |
| ) |  |  | `[inline]`

IOFlags& Glib::operator^= | ( | IOFlags & | lhs,
|  | IOFlags | rhs |
| ) |  |  | `[inline]`

FileTest& Glib::operator^= | ( | FileTest & | lhs,
|  | FileTest | rhs |
| ) |  |  | `[inline]`

AsciiType Glib::operator| | ( | AsciiType | lhs,
|  | AsciiType | rhs |
| ) |  |  | `[inline]`

SpawnFlags Glib::operator| | ( | SpawnFlags | lhs,
|  | SpawnFlags | rhs |
| ) |  |  | `[inline]`

RegexMatchFlags Glib::operator| | ( | RegexMatchFlags | lhs,
|  | RegexMatchFlags | rhs |
| ) |  |  | `[inline]`

RegexCompileFlags Glib::operator| | ( | RegexCompileFlags | lhs,
|  | RegexCompileFlags | rhs |
| ) |  |  | `[inline]`

ModuleFlags Glib::operator| | ( | ModuleFlags | lhs,
|  | ModuleFlags | rhs |
| ) |  |  | `[inline]`

ParseFlags Glib::Markup::operator| | ( | ParseFlags | lhs,
|  | ParseFlags | rhs |
| ) |  |  | `[inline]`

KeyFileFlags Glib::operator| | ( | KeyFileFlags | lhs,
|  | KeyFileFlags | rhs |
| ) |  |  | `[inline]`

IOFlags Glib::operator| | ( | IOFlags | lhs,
|  | IOFlags | rhs |
| ) |  |  | `[inline]`

FileTest Glib::operator| | ( | FileTest | lhs,
|  | FileTest | rhs |
| ) |  |  | `[inline]`

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

SpawnFlags& Glib::operator|= | ( | SpawnFlags & | lhs,
|  | SpawnFlags | rhs |
| ) |  |  | `[inline]`

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

RegexCompileFlags& Glib::operator|= | ( | RegexCompileFlags & | lhs,
|  | RegexCompileFlags | rhs |
| ) |  |  | `[inline]`

ModuleFlags& Glib::operator|= | ( | ModuleFlags & | lhs,
|  | ModuleFlags | rhs |
| ) |  |  | `[inline]`

ParseFlags& Glib::Markup::operator|= | ( | ParseFlags & | lhs,
|  | ParseFlags | rhs |
| ) |  |  | `[inline]`

KeyFileFlags& Glib::operator|= | ( | KeyFileFlags & | lhs,
|  | KeyFileFlags | rhs |
| ) |  |  | `[inline]`

IOFlags& Glib::operator|= | ( | IOFlags & | lhs,
|  | IOFlags | rhs |
| ) |  |  | `[inline]`

FileTest& Glib::operator|= | ( | FileTest & | lhs,
|  | FileTest | rhs |
| ) |  |  | `[inline]`

AsciiType Glib::operator~ | ( | AsciiType | flags | ) | `[inline]`

SpawnFlags Glib::operator~ | ( | SpawnFlags | flags | ) | `[inline]`

RegexMatchFlags Glib::operator~ | ( | RegexMatchFlags | flags | ) | `[inline]`

RegexCompileFlags Glib::operator~ | ( | RegexCompileFlags | flags | ) | `[inline]`

ModuleFlags Glib::operator~ | ( | ModuleFlags | flags | ) | `[inline]`

ParseFlags Glib::Markup::operator~ | ( | ParseFlags | flags | ) | `[inline]`

KeyFileFlags Glib::operator~ | ( | KeyFileFlags | flags | ) | `[inline]`

IOFlags Glib::operator~ | ( | IOFlags | flags | ) | `[inline]`

FileTest Glib::operator~ | ( | FileTest | flags | ) | `[inline]`