GNOME.org

glibmm: 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_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

}
 
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

}
 
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

}
 
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_FIRSTLINE 
REGEX_DUPNAMES 
REGEX_NEWLINE_CR 
REGEX_NEWLINE_LF 
REGEX_NEWLINE_CRLF 
REGEX_NEWLINE_ANYCRLF 
REGEX_BSR_ANYCRLF 
REGEX_JAVASCRIPT_COMPAT 
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 
REGEX_MATCH_NEWLINE_ANYCRLF 
REGEX_MATCH_BSR_ANYCRLF 
REGEX_MATCH_BSR_ANY 
REGEX_MATCH_PARTIAL_SOFT 
REGEX_MATCH_PARTIAL_HARD 
REGEX_MATCH_NOTEMPTY_ATSTART 
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 
SPAWN_SEARCH_PATH_FROM_ENVP 
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
FileTest Glib::operator& ( FileTest  lhs,
FileTest  rhs 
)
inline
KeyFileFlags Glib::operator& ( KeyFileFlags  lhs,
KeyFileFlags  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
FileTest& Glib::operator&= ( FileTest &  lhs,
FileTest  rhs 
)
inline
KeyFileFlags& Glib::operator&= ( KeyFileFlags &  lhs,
KeyFileFlags  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
FileTest Glib::operator^ ( FileTest  lhs,
FileTest  rhs 
)
inline
KeyFileFlags Glib::operator^ ( KeyFileFlags  lhs,
KeyFileFlags  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
FileTest& Glib::operator^= ( FileTest &  lhs,
FileTest  rhs 
)
inline
KeyFileFlags& Glib::operator^= ( KeyFileFlags &  lhs,
KeyFileFlags  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
FileTest Glib::operator| ( FileTest  lhs,
FileTest  rhs 
)
inline
KeyFileFlags Glib::operator| ( KeyFileFlags  lhs,
KeyFileFlags  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
FileTest& Glib::operator|= ( FileTest &  lhs,
FileTest  rhs 
)
inline
KeyFileFlags& Glib::operator|= ( KeyFileFlags &  lhs,
KeyFileFlags  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
FileTest Glib::operator~ ( FileTest  flags)
inline
KeyFileFlags Glib::operator~ ( KeyFileFlags  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