Main Page Widgets glibmm Namespaces Book

# Enums and Flags

## 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 }
| 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)` More...
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_GET_MASK = 0x0, Glib::IO_FLAG_SET_MASK = 0x1 }
| 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)` More...
enum | Glib::KeyFileFlags { Glib::KEY_FILE_NONE = 0, Glib::KEY_FILE_KEEP_COMMENTS = 1 << 0, Glib::KEY_FILE_KEEP_TRANSLATIONS = 1 << 1 }
| 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)` More...
enum | Glib::Markup::ParseFlags { Glib::Markup::DO_NOT_USE_THIS_UNSUPPORTED_FLAG = 1 << 0, Glib::Markup::TREAT_CDATA_AS_TEXT = 1 << 1 }
| 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)` More...
enum | Glib::ModuleFlags { Glib::MODULE_BIND_LAZY = 1 << 0, Glib::MODULE_BIND_LOCAL = 1 << 1, Glib::MODULE_BIND_MASK = 0x03 }
| 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)` 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 = 0x100000 }
| 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)` 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 = 0x100000, Glib::REGEX_MATCH_NEWLINE_ANY = 1 << 22 }
| 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)` 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 }
| 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)` More...
enum | Glib::ThreadPriority { Glib::THREAD_PRIORITY_LOW, Glib::THREAD_PRIORITY_NORMAL, Glib::THREAD_PRIORITY_HIGH, Glib::THREAD_PRIORITY_URGENT }
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 }
| 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)` More...
enum | Glib::NormalizeMode { Glib::NORMALIZE_DEFAULT, Glib::NORMALIZE_NFD, 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_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

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 |

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

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::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]`