glibmm: glibmm Enums and Flags

Enumerations

Functions

BindingFlags Glib::operator| (BindingFlags lhs, BindingFlags rhs)
 
BindingFlags Glib::operator& (BindingFlags lhs, BindingFlags rhs)
 
BindingFlags Glib::operator^ (BindingFlags lhs, BindingFlags rhs)
 
BindingFlags Glib::operator~ (BindingFlags flags)
 
BindingFlags& Glib::operator|= (BindingFlags& lhs, BindingFlags rhs)
 
BindingFlags& Glib::operator&= (BindingFlags& lhs, BindingFlags rhs)
 
BindingFlags& Glib::operator^= (BindingFlags& lhs, BindingFlags rhs)
 
ParamFlags Glib::operator| (ParamFlags lhs, ParamFlags rhs)
 
ParamFlags Glib::operator& (ParamFlags lhs, ParamFlags rhs)
 
ParamFlags Glib::operator^ (ParamFlags lhs, ParamFlags rhs)
 
ParamFlags Glib::operator~ (ParamFlags flags)
 
ParamFlags& Glib::operator|= (ParamFlags& lhs, ParamFlags rhs)
 
ParamFlags& Glib::operator&= (ParamFlags& lhs, ParamFlags rhs)
 
ParamFlags& Glib::operator^= (ParamFlags& lhs, ParamFlags rhs)
 
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)
 
FormatSizeFlags Glib::operator| (FormatSizeFlags lhs, FormatSizeFlags rhs)
 
FormatSizeFlags Glib::operator& (FormatSizeFlags lhs, FormatSizeFlags rhs)
 
FormatSizeFlags Glib::operator^ (FormatSizeFlags lhs, FormatSizeFlags rhs)
 
FormatSizeFlags Glib::operator~ (FormatSizeFlags flags)
 
FormatSizeFlags& Glib::operator|= (FormatSizeFlags& lhs, FormatSizeFlags rhs)
 
FormatSizeFlags& Glib::operator&= (FormatSizeFlags& lhs, FormatSizeFlags rhs)
 
FormatSizeFlags& Glib::operator^= (FormatSizeFlags& lhs, FormatSizeFlags 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

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 

Flags to be passed to g_object_bind_property() or g_object_bind_property_full().

This enumeration can be extended at later date.

Since glibmm 2.44:
Bitwise operators:
BindingFlags operator|(BindingFlags, BindingFlags)

BindingFlags operator&(BindingFlags, BindingFlags)

BindingFlags operator^(BindingFlags, BindingFlags)

BindingFlags operator~(BindingFlags)

BindingFlags& operator|=(BindingFlags&, BindingFlags)

BindingFlags& operator&=(BindingFlags&, BindingFlags)

BindingFlags& operator^=(BindingFlags&, BindingFlags)

Enumerator
BINDING_DEFAULT 

The default binding; if the source property changes, the target property is updated with its value.

BINDING_BIDIRECTIONAL 

Bidirectional binding; if either the property of the source or the property of the target changes, the other is updated.

BINDING_SYNC_CREATE 

Synchronize the values of the source and target properties when creating the binding; the direction of the synchronization is always from the source to the target.

BINDING_INVERT_BOOLEAN 

If the two properties being bound are booleans, setting one to true will result in the other being set to false and vice versa.

This flag will only work for boolean properties, and cannot be used when passing custom transformation functions to g_object_bind_property_full().

The hashing algorithm to be used by Checksum when performing the digest of some data.

Note that the ChecksumType enumeration may be extended at a later date to include new hashing algorithm types.

Since glibmm 2.16:
Enumerator
CHECKSUM_MD5 

Use the MD5 hashing algorithm.

CHECKSUM_SHA1 

Use the SHA-1 hashing algorithm.

CHECKSUM_SHA256 

Use the SHA-256 hashing algorithm.

CHECKSUM_SHA512 

Use the SHA-512 hashing algorithm (Since: 2.36).

CHECKSUM_SHA384 

Use the SHA-384 hashing algorithm (Since: 2.51).

This enumeration isn't used in the API, but may be useful if you need to mark a number as a day, month, or year.

Enumerator
DAY 

A day.

MONTH 

A month.

YEAR 

A year.

A test to perform on a file using g_file_test().

Bitwise operators:
FileTest operator|(FileTest, FileTest)

FileTest operator&(FileTest, FileTest)

FileTest operator^(FileTest, FileTest)

FileTest operator~(FileTest)

FileTest& operator|=(FileTest&, FileTest)

FileTest& operator&=(FileTest&, FileTest)

FileTest& operator^=(FileTest&, FileTest)

Enumerator
FILE_TEST_IS_REGULAR 

true if the file is a regular file (not a directory).

Note that this test will also return true if the tested file is a symlink to a regular file.

FILE_TEST_IS_SYMLINK 

true if the file is a symlink.

FILE_TEST_IS_DIR 

true if the file is a directory.

FILE_TEST_IS_EXECUTABLE 

true if the file is executable.

FILE_TEST_EXISTS 

true if the file exists.

It may or may not be a regular file.

Flags to modify the format of the string returned by g_format_size_full().

Bitwise operators:
FormatSizeFlags operator|(FormatSizeFlags, FormatSizeFlags)

FormatSizeFlags operator&(FormatSizeFlags, FormatSizeFlags)

FormatSizeFlags operator^(FormatSizeFlags, FormatSizeFlags)

FormatSizeFlags operator~(FormatSizeFlags)

FormatSizeFlags& operator|=(FormatSizeFlags&, FormatSizeFlags)

FormatSizeFlags& operator&=(FormatSizeFlags&, FormatSizeFlags)

FormatSizeFlags& operator^=(FormatSizeFlags&, FormatSizeFlags)

Enumerator
FORMAT_SIZE_DEFAULT 

Behave the same as g_format_size().

FORMAT_SIZE_LONG_FORMAT 

Include the exact number of bytes as part of the returned string.

For example, "45.6 kB (45,612 bytes)".

FORMAT_SIZE_IEC_UNITS 

Use IEC (base 1024) units with "KiB"-style suffixes.

IEC units should only be used for reporting things with a strong "power of 2" basis, like RAM sizes or RAID stripe sizes. Network and storage sizes should be reported in the normal SI units.

FORMAT_SIZE_BITS 

Set the size as a quantity in bits, rather than bytes, and return units in bits.

For example, ‘Mb’ rather than ‘MB’.

A bitwise combination representing a condition to watch for on an event source.

Bitwise operators:
IOCondition operator|(IOCondition, IOCondition)

IOCondition operator&(IOCondition, IOCondition)

IOCondition operator^(IOCondition, IOCondition)

IOCondition operator~(IOCondition)

IOCondition& operator|=(IOCondition&, IOCondition)

IOCondition& operator&=(IOCondition&, IOCondition)

IOCondition& operator^=(IOCondition&, IOCondition)

Enumerator
IO_IN 

A bitwise combination representing an I/O condition to watch for on an event source.

The flags correspond to those used by the poll() system call on UNIX (see man 2 poll). To test for individual flags, do something like this:

if((condition & Glib::IO_OUT) != 0)
do_some_output();

There is data to read.

IO_OUT 

Data can be written (without blocking).

IO_PRI 

There is urgent data to read.

IO_ERR 

Error condition.

IO_HUP 

Hung up (the connection has been broken, usually for pipes and sockets).

IO_NVAL 

Invalid request.

The file descriptor is not open.

Specifies properties of a IOChannel.

Some of the flags can only be read with g_io_channel_get_flags(), but not changed with g_io_channel_set_flags().

Bitwise operators:
IOFlags operator|(IOFlags, IOFlags)

IOFlags operator&(IOFlags, IOFlags)

IOFlags operator^(IOFlags, IOFlags)

IOFlags operator~(IOFlags)

IOFlags& operator|=(IOFlags&, IOFlags)

IOFlags& operator&=(IOFlags&, IOFlags)

IOFlags& operator^=(IOFlags&, IOFlags)

Enumerator
IO_FLAG_APPEND 

Turns on append mode, corresponds to O_APPEND (see the documentation of the UNIX open() syscall).

IO_FLAG_NONBLOCK 

Turns on nonblocking mode, corresponds to O_NONBLOCK/O_NDELAY (see the documentation of the UNIX open() syscall).

IO_FLAG_IS_READABLE 

Indicates that the io channel is readable.

This flag cannot be changed.

IO_FLAG_IS_WRITABLE 

Indicates that the io channel is writable.

This flag cannot be changed.

IO_FLAG_IS_WRITEABLE 

A misspelled version of G_IO_FLAG_IS_WRITABLE that existed before the spelling was fixed in GLib 2.30.

It is kept here for compatibility reasons. Deprecated since 2.30.

IO_FLAG_IS_SEEKABLE 

Indicates that the io channel is seekable, i.e.

that g_io_channel_seek_position() can be used on it. This flag cannot be changed.

IO_FLAG_MASK 

The mask that specifies all the valid flags.

IO_FLAG_GET_MASK 

The mask of the flags that are returned from g_io_channel_get_flags().

IO_FLAG_SET_MASK 

The mask of the flags that the user can modify with g_io_channel_set_flags().

Stati returned by most of the IOFuncs functions.

Enumerator
IO_STATUS_ERROR 

An error occurred.

IO_STATUS_NORMAL 

Success.

IO_STATUS_EOF 

End of file.

IO_STATUS_AGAIN 

Resource temporarily unavailable.

Flags which influence the parsing.

Bitwise operators:
KeyFileFlags operator|(KeyFileFlags, KeyFileFlags)

KeyFileFlags operator&(KeyFileFlags, KeyFileFlags)

KeyFileFlags operator^(KeyFileFlags, KeyFileFlags)

KeyFileFlags operator~(KeyFileFlags)

KeyFileFlags& operator|=(KeyFileFlags&, KeyFileFlags)

KeyFileFlags& operator&=(KeyFileFlags&, KeyFileFlags)

KeyFileFlags& operator^=(KeyFileFlags&, KeyFileFlags)

Enumerator
KEY_FILE_NONE 

No flags, default behaviour.

KEY_FILE_KEEP_COMMENTS 

Use this flag if you plan to write the (possibly modified) contents of the key file back to a file; otherwise all comments will be lost when the key file is written back.

KEY_FILE_KEEP_TRANSLATIONS 

Use this flag if you plan to write the (possibly modified) contents of the key file back to a file; otherwise only the translations for the current language will be written back.

Flags passed to g_module_open().

Note that these flags are not supported on all platforms.

Bitwise operators:
ModuleFlags operator|(ModuleFlags, ModuleFlags)

ModuleFlags operator&(ModuleFlags, ModuleFlags)

ModuleFlags operator^(ModuleFlags, ModuleFlags)

ModuleFlags operator~(ModuleFlags)

ModuleFlags& operator|=(ModuleFlags&, ModuleFlags)

ModuleFlags& operator&=(ModuleFlags&, ModuleFlags)

ModuleFlags& operator^=(ModuleFlags&, ModuleFlags)

Enumerator
MODULE_BIND_LAZY 

Specifies that symbols are only resolved when needed.

The default action is to bind all symbols when the module is loaded.

MODULE_BIND_LOCAL 

Specifies that symbols in the module should not be added to the global name space.

The default action on most platforms is to place symbols in the module in the global name space, which may cause conflicts with existing symbols.

MODULE_BIND_MASK 

Mask for all flags.

Enumeration representing a month; values are DATE_JANUARY, DATE_FEBRUARY, etc.

DATE_BAD_MONTH is the invalid value.

Enumerator
BAD_MONTH 

Invalid value.

JANUARY 

January.

FEBRUARY 

February.

MARCH 

March.

APRIL 

April.

MAY 

May.

JUNE 

June.

JULY 

July.

AUGUST 

August.

SEPTEMBER 

September.

OCTOBER 

October.

NOVEMBER 

November.

DECEMBER 

December.

Defines how a Unicode string is transformed in a canonical form, standardizing such issues as whether a character with an accent is represented as a base character and combining accent or as a single precomposed character.

Unicode strings should generally be normalized before comparing them.

Enumerator
NORMALIZE_DEFAULT 

Standardize differences that do not affect the text content, such as the above-mentioned accent representation.

NORMALIZE_NFD 

Another name for NORMALIZE_DEFAULT.

NORMALIZE_DEFAULT_COMPOSE 

Like NORMALIZE_DEFAULT, but with composed forms rather than a maximally decomposed form.

NORMALIZE_NFC 

Another name for NORMALIZE_DEFAULT_COMPOSE.

NORMALIZE_ALL 

Beyond NORMALIZE_DEFAULT also standardize the "compatibility" characters in Unicode, such as SUPERSCRIPT THREE to the standard forms (in this case DIGIT THREE).

Formatting information may be lost but for most text operations such characters should be considered the same.

NORMALIZE_NFKD 

Another name for NORMALIZE_ALL.

NORMALIZE_ALL_COMPOSE 

Like NORMALIZE_ALL, but with composed forms rather than a maximally decomposed form.

NORMALIZE_NFKC 

Another name for NORMALIZE_ALL_COMPOSE.

The OptionType enum values determine the expected type of a command line option.

If an option expects an extra argument, it can be specified in several ways; with a short option: "-x arg", with a long option: "--name arg" or combined in a single argument: "--name=arg". All option types except OPTION_TYPE_BOOL expect an extra argument. OPTION_TYPE_STRING_VECTOR and OPTION_TYPE_FILENAME_VECTOR accept more than one extra argument.

The descriptions of the enum values show what type of Glib::Variant<> is stored in a Glib::VariantDict.

Since glibmm 2.42:
Enumerator
OPTION_TYPE_BOOL 

bool

OPTION_TYPE_STRING 

Glib::ustring.

OPTION_TYPE_INT 

gint32

OPTION_TYPE_FILENAME 

std::string

OPTION_TYPE_STRING_VECTOR 

std::vector<Glib::ustring>

OPTION_TYPE_FILENAME_VECTOR 

std::vector<std::string>

OPTION_TYPE_DOUBLE 

double

OPTION_TYPE_INT64 

gint64

Through the ParamFlags flag values, certain aspects of parameters can be configured.

See also G_PARAM_STATIC_STRINGS.

Bitwise operators:
ParamFlags operator|(ParamFlags, ParamFlags)

ParamFlags operator&(ParamFlags, ParamFlags)

ParamFlags operator^(ParamFlags, ParamFlags)

ParamFlags operator~(ParamFlags)

ParamFlags& operator|=(ParamFlags&, ParamFlags)

ParamFlags& operator&=(ParamFlags&, ParamFlags)

ParamFlags& operator^=(ParamFlags&, ParamFlags)

Enumerator
PARAM_READABLE 

The parameter is readable.

PARAM_WRITABLE 

The parameter is writable.

PARAM_READWRITE 

Alias for PARAM_READABLE | PARAM_WRITABLE.

PARAM_CONSTRUCT 

The parameter will be set upon object construction.

PARAM_CONSTRUCT_ONLY 

The parameter can only be set upon object construction.

PARAM_LAX_VALIDATION 

Upon parameter conversion (see g_param_value_convert()) strict validation is not required.

PARAM_STATIC_NAME 

The string used as name when constructing the parameter is guaranteed to remain valid and unmodified for the lifetime of the parameter.

Since glibmm 2.8:
PARAM_PRIVATE 

Internal.

PARAM_STATIC_NICK 

The string used as nick when constructing the parameter is guaranteed to remain valid and unmmodified for the lifetime of the parameter.

Since glibmm 2.8:
PARAM_STATIC_BLURB 

The string used as blurb when constructing the parameter is guaranteed to remain valid and unmodified for the lifetime of the parameter.

Since glibmm 2.8:
PARAM_EXPLICIT_NOTIFY 

Calls to g_object_set_property() for this property will not automatically result in a "notify" signal being emitted: the implementation must call g_object_notify() themselves in case the property actually changes.

Since glibmm 2.42:
PARAM_DEPRECATED 

The parameter is deprecated and will be removed in a future version.

A warning will be generated if it is used while running with G_ENABLE_DIAGNOSTIC=1.

Since glibmm 2.26:

Flags that affect the behaviour of the parser.

Bitwise operators:
ParseFlags operator|(ParseFlags, ParseFlags)

ParseFlags operator&(ParseFlags, ParseFlags)

ParseFlags operator^(ParseFlags, ParseFlags)

ParseFlags operator~(ParseFlags)

ParseFlags& operator|=(ParseFlags&, ParseFlags)

ParseFlags& operator&=(ParseFlags&, ParseFlags)

ParseFlags& operator^=(ParseFlags&, ParseFlags)

Enumerator
DO_NOT_USE_THIS_UNSUPPORTED_FLAG 

There are no flags right now.

Pass Glib::Markup::ParseFlags(0) for the flags argument to all functions (this should be the default argument anyway).

Flag you should not use.

Flag you should not use.

TREAT_CDATA_AS_TEXT 

When this flag is set, CDATA marked sections are not passed literally to the passthrough function of the parser.

Instead, the content of the section (without the <![CDATA[ and ]]>) is passed to the text function. This flag was added in GLib 2.12.

PREFIX_ERROR_POSITION 

Normally errors caught by GMarkup itself have line/column information prefixed to them to let the caller know the location of the error.

When this flag is set the location information is also prefixed to errors generated by the MarkupParser implementation functions.

IGNORE_QUALIFIED 

Ignore (don't report) qualified attributes and tags, along with their contents.

A qualified attribute or tag is one that contains ':' in its name (ie: is in another namespace).

Since glibmm 2.40:

Flags specifying compile-time options.

Since glibmm 2.14:
Bitwise operators:
RegexCompileFlags operator|(RegexCompileFlags, RegexCompileFlags)

RegexCompileFlags operator&(RegexCompileFlags, RegexCompileFlags)

RegexCompileFlags operator^(RegexCompileFlags, RegexCompileFlags)

RegexCompileFlags operator~(RegexCompileFlags)

RegexCompileFlags& operator|=(RegexCompileFlags&, RegexCompileFlags)

RegexCompileFlags& operator&=(RegexCompileFlags&, RegexCompileFlags)

RegexCompileFlags& operator^=(RegexCompileFlags&, RegexCompileFlags)

Enumerator
REGEX_CASELESS 

Letters in the pattern match both upper- and lowercase letters.

This option can be changed within a pattern by a "(?i)" option setting.

REGEX_MULTILINE 

By default, GRegex treats the strings as consisting of a single line of characters (even if it actually contains newlines).

The "start of line" metacharacter ("^") matches only at the start of the string, while the "end of line" metacharacter ("$") matches only at the end of the string, or before a terminating newline (unless REGEX_DOLLAR_ENDONLY is set). When REGEX_MULTILINE is set, the "start of line" and "end of line" constructs match immediately following or immediately before any newline in the string, respectively, as well as at the very start and end. This can be changed within a pattern by a "(?m)" option setting.

REGEX_DOTALL 

A dot metacharacter (".") in the pattern matches all characters, including newlines.

Without it, newlines are excluded. This option can be changed within a pattern by a ("?s") option setting.

REGEX_EXTENDED 

Whitespace data characters in the pattern are totally ignored except when escaped or inside a character class.

Whitespace does not include the VT character (code 11). In addition, characters between an unescaped "#" outside a character class and the next newline character, inclusive, are also ignored. This can be changed within a pattern by a "(?x)" option setting.

REGEX_ANCHORED 

The pattern is forced to be "anchored", that is, it is constrained to match only at the first matching point in the string that is being searched.

This effect can also be achieved by appropriate constructs in the pattern itself such as the "^" metacharacter.

REGEX_DOLLAR_ENDONLY 

A dollar metacharacter ("$") in the pattern matches only at the end of the string.

Without this option, a dollar also matches immediately before the final character if it is a newline (but not before any other newlines). This option is ignored if REGEX_MULTILINE is set.

REGEX_UNGREEDY 

Inverts the "greediness" of the quantifiers so that they are not greedy by default, but become greedy if followed by "?".

It can also be set by a "(?U)" option setting within the pattern.

REGEX_RAW 

Usually strings must be valid UTF-8 strings, using this flag they are considered as a raw sequence of bytes.

REGEX_NO_AUTO_CAPTURE 

Disables the use of numbered capturing parentheses in the pattern.

Any opening parenthesis that is not followed by "?" behaves as if it were followed by "?:" but named parentheses can still be used for capturing (and they acquire numbers in the usual way).

REGEX_OPTIMIZE 

Optimize the regular expression.

If the pattern will be used many times, then it may be worth the effort to optimize it to improve the speed of matches.

REGEX_FIRSTLINE 

Limits an unanchored pattern to match before (or at) the first newline.

Since glibmm 2.34:
REGEX_DUPNAMES 

Names used to identify capturing subpatterns need not be unique.

This can be helpful for certain types of pattern when it is known that only one instance of the named subpattern can ever be matched.

REGEX_NEWLINE_CR 

Usually any newline character or character sequence is recognized.

If this option is set, the only recognized newline character is '\r'.

REGEX_NEWLINE_LF 

Usually any newline character or character sequence is recognized.

If this option is set, the only recognized newline character is '\n'.

REGEX_NEWLINE_CRLF 

Usually any newline character or character sequence is recognized.

If this option is set, the only recognized newline character sequence is '\r\n'.

REGEX_NEWLINE_ANYCRLF 

Usually any newline character or character sequence is recognized.

If this option is set, the only recognized newline character sequences are '\r', '\n', and '\r\n'.

Since glibmm 2.34:
REGEX_BSR_ANYCRLF 

Usually any newline character or character sequence is recognised.

If this option is set, then "\\R" only recognizes the newline characters '\r', '\n' and '\r\n'.

Since glibmm 2.34:
REGEX_JAVASCRIPT_COMPAT 

Changes behaviour so that it is compatible with JavaScript rather than PCRE.

Since glibmm 2.34:

Flags specifying match-time options.

Since glibmm 2.14:
Bitwise operators:
RegexMatchFlags operator|(RegexMatchFlags, RegexMatchFlags)

RegexMatchFlags operator&(RegexMatchFlags, RegexMatchFlags)

RegexMatchFlags operator^(RegexMatchFlags, RegexMatchFlags)

RegexMatchFlags operator~(RegexMatchFlags)

RegexMatchFlags& operator|=(RegexMatchFlags&, RegexMatchFlags)

RegexMatchFlags& operator&=(RegexMatchFlags&, RegexMatchFlags)

RegexMatchFlags& operator^=(RegexMatchFlags&, RegexMatchFlags)

Enumerator
REGEX_MATCH_ANCHORED 

The pattern is forced to be "anchored", that is, it is constrained to match only at the first matching point in the string that is being searched.

This effect can also be achieved by appropriate constructs in the pattern itself such as the "^" metacharacter.

REGEX_MATCH_NOTBOL 

Specifies that first character of the string is not the beginning of a line, so the circumflex metacharacter should not match before it.

Setting this without REGEX_MULTILINE (at compile time) causes circumflex never to match. This option affects only the behaviour of the circumflex metacharacter, it does not affect "\\A".

REGEX_MATCH_NOTEOL 

Specifies that the end of the subject string is not the end of a line, so the dollar metacharacter should not match it nor (except in multiline mode) a newline immediately before it.

Setting this without REGEX_MULTILINE (at compile time) causes dollar never to match. This option affects only the behaviour of the dollar metacharacter, it does not affect "\\Z" or "\\z".

REGEX_MATCH_NOTEMPTY 

An empty string is not considered to be a valid match if this option is set.

If there are alternatives in the pattern, they are tried. If all the alternatives match the empty string, the entire match fails. For example, if the pattern "a?b?" is applied to a string not beginning with "a" or "b", it matches the empty string at the start of the string. With this flag set, this match is not valid, so GRegex searches further into the string for occurrences of "a" or "b".

REGEX_MATCH_PARTIAL 

Turns on the partial matching feature, for more documentation on partial matching see g_match_info_is_partial_match().

REGEX_MATCH_NEWLINE_CR 

Overrides the newline definition set when creating a new Regex, setting the '\r' character as line terminator.

REGEX_MATCH_NEWLINE_LF 

Overrides the newline definition set when creating a new Regex, setting the '\n' character as line terminator.

REGEX_MATCH_NEWLINE_CRLF 

Overrides the newline definition set when creating a new Regex, setting the '\r\n' characters sequence as line terminator.

REGEX_MATCH_NEWLINE_ANY 

Overrides the newline definition set when creating a new Regex, any Unicode newline sequence is recognised as a newline.

These are '\r', '\n' and '\rn', and the single characters U+000B LINE TABULATION, U+000C FORM FEED (FF), U+0085 NEXT LINE (NEL), U+2028 LINE SEPARATOR and U+2029 PARAGRAPH SEPARATOR.

REGEX_MATCH_NEWLINE_ANYCRLF 

Overrides the newline definition set when creating a new Regex; any '\r', '\n', or '\r\n' character sequence is recognized as a newline.

Since glibmm 2.34:
REGEX_MATCH_BSR_ANYCRLF 

Overrides the newline definition for "\\R" set when creating a new Regex; only '\r', '\n', or '\r\n' character sequences are recognized as a newline by "\\R".

Since glibmm 2.34:
REGEX_MATCH_BSR_ANY 

Overrides the newline definition for "\\R" set when creating a new Regex; any Unicode newline character or character sequence are recognized as a newline by "\\R".

These are '\r', '\n' and '\rn', and the single characters U+000B LINE TABULATION, U+000C FORM FEED (FF), U+0085 NEXT LINE (NEL), U+2028 LINE SEPARATOR and U+2029 PARAGRAPH SEPARATOR.

Since glibmm 2.34:
REGEX_MATCH_PARTIAL_SOFT 

An alias for REGEX_MATCH_PARTIAL.

Since glibmm 2.34:
REGEX_MATCH_PARTIAL_HARD 

Turns on the partial matching feature.

In contrast to to REGEX_MATCH_PARTIAL_SOFT, this stops matching as soon as a partial match is found, without continuing to search for a possible complete match. See g_match_info_is_partial_match() for more information.

Since glibmm 2.34:
REGEX_MATCH_NOTEMPTY_ATSTART 

Like REGEX_MATCH_NOTEMPTY, but only applied to the start of the matched string.

For anchored patterns this can only happen for pattern containing "\\K".

Since glibmm 2.34:

An enumeration specifying the base position for a g_io_channel_seek_position() operation.

Enumerator
SEEK_TYPE_CUR 

The current position in the file.

SEEK_TYPE_SET 

The start of the file.

SEEK_TYPE_END 

The end of the file.

Flags passed to g_spawn_sync(), g_spawn_async() and g_spawn_async_with_pipes().

Bitwise operators:
SpawnFlags operator|(SpawnFlags, SpawnFlags)

SpawnFlags operator&(SpawnFlags, SpawnFlags)

SpawnFlags operator^(SpawnFlags, SpawnFlags)

SpawnFlags operator~(SpawnFlags)

SpawnFlags& operator|=(SpawnFlags&, SpawnFlags)

SpawnFlags& operator&=(SpawnFlags&, SpawnFlags)

SpawnFlags& operator^=(SpawnFlags&, SpawnFlags)

Enumerator
SPAWN_DEFAULT 

No flags, default behaviour.

SPAWN_LEAVE_DESCRIPTORS_OPEN 

The parent's open file descriptors will be inherited by the child; otherwise all descriptors except stdin, stdout and stderr will be closed before calling exec() in the child.

SPAWN_DO_NOT_REAP_CHILD 

The child will not be automatically reaped; you must use g_child_watch_add() yourself (or call waitpid() or handle SIGCHLD yourself), or the child will become a zombie.

SPAWN_SEARCH_PATH 

argv[0] need not be an absolute path, it will be looked for in the user's PATH.

SPAWN_STDOUT_TO_DEV_NULL 

The child's standard output will be discarded, instead of going to the same location as the parent's standard output.

SPAWN_STDERR_TO_DEV_NULL 

The child's standard error will be discarded.

SPAWN_CHILD_INHERITS_STDIN 

The child will inherit the parent's standard input (by default, the child's standard input is attached to /dev/null).

SPAWN_FILE_AND_ARGV_ZERO 

The first element of argv is the file to execute, while the remaining elements are the actual argument vector to pass to the file.

Normally g_spawn_async_with_pipes() uses argv[0] as the file to execute, and passes all of argv to the child.

SPAWN_SEARCH_PATH_FROM_ENVP 

If argv[0] is not an abolute path, it will be looked for in the PATH from the passed child environment.

Since glibmm 2.34:
SPAWN_CLOEXEC_PIPES 

Create all pipes with the O_CLOEXEC flag set.

Since glibmm 2.40:

Thread priorities.

Deprecated:2.32: Thread priorities no longer have any effect.

Enumerator
THREAD_PRIORITY_LOW 
Deprecated:
Thread priorities no longer have any effect.

A priority lower than normal.

A priority lower than normal.

THREAD_PRIORITY_NORMAL 

The default priority.

The default priority.

THREAD_PRIORITY_HIGH 

A priority higher than normal.

A priority higher than normal.

THREAD_PRIORITY_URGENT 

The highest priority.

The highest priority.

Disambiguates a given time in two ways.

First, specifies if the given time is in universal or local time.

Second, if the time is in local time, specifies if it is local standard time or local daylight time. This is important for the case where the same local time occurs twice (during daylight savings time transitions, for example).

Enumerator
TIME_TYPE_STANDARD 

The time is in local standard time.

TIME_TYPE_DAYLIGHT 

The time is in local daylight time.

TIME_TYPE_UNIVERSAL 

The time is in UTC.

template <typename T >
enum Glib::NodeTree::TraverseFlags

Specifies which nodes are visited during several of the NodeTree methods, including traverse() and find().

Enumerator
TRAVERSE_LEAVES 

Only leaf nodes should be visited.

TRAVERSE_NON_LEAVES 

Only non-leaf nodes should be visited.

TRAVERSE_ALL 

All nodes should be visited.

TRAVERSE_MASK 

A mask of all traverse flags.

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.

These are the possible line break classifications.

Since new unicode versions may add new types here, applications should be ready to handle unknown values. They may be regarded as UNICODE_BREAK_UNKNOWN.

See Unicode Line Breaking Algorithm.

Enumerator
UNICODE_BREAK_MANDATORY 

Mandatory Break (BK).

UNICODE_BREAK_CARRIAGE_RETURN 

Carriage Return (CR).

UNICODE_BREAK_LINE_FEED 

Line Feed (LF).

UNICODE_BREAK_COMBINING_MARK 

Attached Characters and Combining Marks (CM).

UNICODE_BREAK_SURROGATE 

Surrogates (SG).

UNICODE_BREAK_ZERO_WIDTH_SPACE 

Zero Width Space (ZW).

UNICODE_BREAK_INSEPARABLE 

Inseparable (IN).

UNICODE_BREAK_NON_BREAKING_GLUE 

Non-breaking ("Glue") (GL).

UNICODE_BREAK_CONTINGENT 

Contingent Break Opportunity (CB).

UNICODE_BREAK_SPACE 

Space (SP).

UNICODE_BREAK_AFTER 

Break Opportunity After (BA).

UNICODE_BREAK_BEFORE 

Break Opportunity Before (BB).

UNICODE_BREAK_BEFORE_AND_AFTER 

Break Opportunity Before and After (B2).

UNICODE_BREAK_HYPHEN 

Hyphen (HY).

UNICODE_BREAK_NON_STARTER 

Nonstarter (NS).

UNICODE_BREAK_OPEN_PUNCTUATION 

Opening Punctuation (OP).

UNICODE_BREAK_CLOSE_PUNCTUATION 

Closing Punctuation (CL).

UNICODE_BREAK_QUOTATION 

Ambiguous Quotation (QU).

UNICODE_BREAK_EXCLAMATION 

Exclamation/Interrogation (EX).

UNICODE_BREAK_IDEOGRAPHIC 

Ideographic (ID).

UNICODE_BREAK_NUMERIC 

Numeric (NU).

UNICODE_BREAK_INFIX_SEPARATOR 

Infix Separator (Numeric) (IS).

UNICODE_BREAK_SYMBOL 

Symbols Allowing Break After (SY).

UNICODE_BREAK_ALPHABETIC 

Ordinary Alphabetic and Symbol Characters (AL).

UNICODE_BREAK_PREFIX 

Prefix (Numeric) (PR).

UNICODE_BREAK_POSTFIX 

Postfix (Numeric) (PO).

UNICODE_BREAK_COMPLEX_CONTEXT 

Complex Content Dependent (South East Asian) (SA).

UNICODE_BREAK_AMBIGUOUS 

Ambiguous (Alphabetic or Ideographic) (AI).

UNICODE_BREAK_UNKNOWN 

Unknown (XX).

UNICODE_BREAK_NEXT_LINE 

Next Line (NL).

UNICODE_BREAK_WORD_JOINER 

Word Joiner (WJ).

UNICODE_BREAK_HANGUL_L_JAMO 

Hangul L Jamo (JL).

UNICODE_BREAK_HANGUL_V_JAMO 

Hangul V Jamo (JV).

UNICODE_BREAK_HANGUL_T_JAMO 

Hangul T Jamo (JT).

UNICODE_BREAK_HANGUL_LV_SYLLABLE 

Hangul LV Syllable (H2).

UNICODE_BREAK_HANGUL_LVT_SYLLABLE 

Hangul LVT Syllable (H3).

UNICODE_BREAK_CLOSE_PARANTHESIS 

Closing Parenthesis (CP).

Since glibmm 2.28:
UNICODE_BREAK_CONDITIONAL_JAPANESE_STARTER 

Conditional Japanese Starter (CJ).

Since glibmm 2.32:
UNICODE_BREAK_HEBREW_LETTER 

Hebrew Letter (HL).

Since glibmm 2.32:
UNICODE_BREAK_REGIONAL_INDICATOR 

Regional Indicator (RI).

Since glibmm 2.36:
UNICODE_BREAK_EMOJI_BASE 

Emoji Base (EB).

Since glibmm 2.50:
UNICODE_BREAK_EMOJI_MODIFIER 

Emoji Modifier (EM).

Since glibmm 2.50:
UNICODE_BREAK_ZERO_WIDTH_JOINER 

Zero Width Joiner (ZWJ).

Since glibmm 2.50:

These are the possible character classifications from the Unicode specification.

See Unicode Character Database.

Enumerator
UNICODE_CONTROL 

General category "Other, Control" (Cc).

UNICODE_FORMAT 

General category "Other, Format" (Cf).

UNICODE_UNASSIGNED 

General category "Other, Not Assigned" (Cn).

UNICODE_PRIVATE_USE 

General category "Other, Private Use" (Co).

UNICODE_SURROGATE 

General category "Other, Surrogate" (Cs).

UNICODE_LOWERCASE_LETTER 

General category "Letter, Lowercase" (Ll).

UNICODE_MODIFIER_LETTER 

General category "Letter, Modifier" (Lm).

UNICODE_OTHER_LETTER 

General category "Letter, Other" (Lo).

UNICODE_TITLECASE_LETTER 

General category "Letter, Titlecase" (Lt).

UNICODE_UPPERCASE_LETTER 

General category "Letter, Uppercase" (Lu).

UNICODE_SPACING_MARK 

General category "Mark, Spacing" (Mc).

UNICODE_ENCLOSING_MARK 

General category "Mark, Enclosing" (Me).

UNICODE_NON_SPACING_MARK 

General category "Mark, Nonspacing" (Mn).

UNICODE_DECIMAL_NUMBER 

General category "Number, Decimal Digit" (Nd).

UNICODE_LETTER_NUMBER 

General category "Number, Letter" (Nl).

UNICODE_OTHER_NUMBER 

General category "Number, Other" (No).

UNICODE_CONNECT_PUNCTUATION 

General category "Punctuation, Connector" (Pc).

UNICODE_DASH_PUNCTUATION 

General category "Punctuation, Dash" (Pd).

UNICODE_CLOSE_PUNCTUATION 

General category "Punctuation, Close" (Pe).

UNICODE_FINAL_PUNCTUATION 

General category "Punctuation, Final quote" (Pf).

UNICODE_INITIAL_PUNCTUATION 

General category "Punctuation, Initial quote" (Pi).

UNICODE_OTHER_PUNCTUATION 

General category "Punctuation, Other" (Po).

UNICODE_OPEN_PUNCTUATION 

General category "Punctuation, Open" (Ps).

UNICODE_CURRENCY_SYMBOL 

General category "Symbol, Currency" (Sc).

UNICODE_MODIFIER_SYMBOL 

General category "Symbol, Modifier" (Sk).

UNICODE_MATH_SYMBOL 

General category "Symbol, Math" (Sm).

UNICODE_OTHER_SYMBOL 

General category "Symbol, Other" (So).

UNICODE_LINE_SEPARATOR 

General category "Separator, Line" (Zl).

UNICODE_PARAGRAPH_SEPARATOR 

General category "Separator, Paragraph" (Zp).

UNICODE_SPACE_SEPARATOR 

General category "Separator, Space" (Zs).

These are logical ids for special directories which are defined depending on the platform used.

You should use g_get_user_special_dir() to retrieve the full path associated to the logical id.

The UserDirectory enumeration can be extended at later date. Not every platform has a directory for every logical id in this enumeration.

Since glibmm 2.14:
Enumerator
USER_DIRECTORY_DESKTOP 

The user's Desktop directory.

USER_DIRECTORY_DOCUMENTS 

The user's Documents directory.

USER_DIRECTORY_DOWNLOAD 

The user's Downloads directory.

USER_DIRECTORY_MUSIC 

The user's Music directory.

USER_DIRECTORY_PICTURES 

The user's Pictures directory.

USER_DIRECTORY_PUBLIC_SHARE 

The user's shared directory.

USER_DIRECTORY_TEMPLATES 

The user's Templates directory.

USER_DIRECTORY_VIDEOS 

The user's Movies directory.

USER_N_DIRECTORIES 

The number of enum values.

Enumeration representing a day of the week; DATE_MONDAY, DATE_TUESDAY, etc.

DATE_BAD_WEEKDAY is an invalid weekday.

Enumerator
BAD_WEEKDAY 

Invalid value.

MONDAY 

Monday.

TUESDAY 

Tuesday.

WEDNESDAY 

Wednesday.

THURSDAY 

Thursday.

FRIDAY 

Friday.

SATURDAY 

Saturday.

SUNDAY 

Sunday.

Function Documentation

ModuleFlags Glib::operator& ( ModuleFlags  lhs,
ModuleFlags  rhs 
)
inline
KeyFileFlags Glib::operator& ( KeyFileFlags  lhs,
KeyFileFlags  rhs 
)
inline
FileTest Glib::operator& ( FileTest  lhs,
FileTest  rhs 
)
inline
BindingFlags Glib::operator& ( BindingFlags  lhs,
BindingFlags  rhs 
)
inline
SpawnFlags Glib::operator& ( SpawnFlags  lhs,
SpawnFlags  rhs 
)
inline
ParamFlags Glib::operator& ( ParamFlags  lhs,
ParamFlags  rhs 
)
inline
FormatSizeFlags Glib::operator& ( FormatSizeFlags  lhs,
FormatSizeFlags  rhs 
)
inline
IOFlags Glib::operator& ( IOFlags  lhs,
IOFlags  rhs 
)
inline
RegexCompileFlags Glib::operator& ( RegexCompileFlags  lhs,
RegexCompileFlags  rhs 
)
inline
ParseFlags Glib::Markup::operator& ( ParseFlags  lhs,
ParseFlags  rhs 
)
inline
IOCondition Glib::operator& ( IOCondition  lhs,
IOCondition  rhs 
)
inline
RegexMatchFlags Glib::operator& ( RegexMatchFlags  lhs,
RegexMatchFlags  rhs 
)
inline
AsciiType Glib::operator& ( AsciiType  lhs,
AsciiType  rhs 
)
inline
ModuleFlags& Glib::operator&= ( ModuleFlags lhs,
ModuleFlags  rhs 
)
inline
KeyFileFlags& Glib::operator&= ( KeyFileFlags lhs,
KeyFileFlags  rhs 
)
inline
FileTest& Glib::operator&= ( FileTest lhs,
FileTest  rhs 
)
inline
BindingFlags& Glib::operator&= ( BindingFlags lhs,
BindingFlags  rhs 
)
inline
SpawnFlags& Glib::operator&= ( SpawnFlags lhs,
SpawnFlags  rhs 
)
inline
ParamFlags& Glib::operator&= ( ParamFlags lhs,
ParamFlags  rhs 
)
inline
FormatSizeFlags& Glib::operator&= ( FormatSizeFlags lhs,
FormatSizeFlags  rhs 
)
inline
IOFlags& Glib::operator&= ( IOFlags lhs,
IOFlags  rhs 
)
inline
RegexCompileFlags& Glib::operator&= ( RegexCompileFlags lhs,
RegexCompileFlags  rhs 
)
inline
ParseFlags& Glib::Markup::operator&= ( ParseFlags lhs,
ParseFlags  rhs 
)
inline
IOCondition& Glib::operator&= ( IOCondition lhs,
IOCondition  rhs 
)
inline
RegexMatchFlags& Glib::operator&= ( RegexMatchFlags lhs,
RegexMatchFlags  rhs 
)
inline
AsciiType& Glib::operator&= ( AsciiType lhs,
AsciiType  rhs 
)
inline
ModuleFlags Glib::operator^ ( ModuleFlags  lhs,
ModuleFlags  rhs 
)
inline
KeyFileFlags Glib::operator^ ( KeyFileFlags  lhs,
KeyFileFlags  rhs 
)
inline
FileTest Glib::operator^ ( FileTest  lhs,
FileTest  rhs 
)
inline
BindingFlags Glib::operator^ ( BindingFlags  lhs,
BindingFlags  rhs 
)
inline
SpawnFlags Glib::operator^ ( SpawnFlags  lhs,
SpawnFlags  rhs 
)
inline
ParamFlags Glib::operator^ ( ParamFlags  lhs,
ParamFlags  rhs 
)
inline
FormatSizeFlags Glib::operator^ ( FormatSizeFlags  lhs,
FormatSizeFlags  rhs 
)
inline
IOFlags Glib::operator^ ( IOFlags  lhs,
IOFlags  rhs 
)
inline
RegexCompileFlags Glib::operator^ ( RegexCompileFlags  lhs,
RegexCompileFlags  rhs 
)
inline
ParseFlags Glib::Markup::operator^ ( ParseFlags  lhs,
ParseFlags  rhs 
)
inline
IOCondition Glib::operator^ ( IOCondition  lhs,
IOCondition  rhs 
)
inline
RegexMatchFlags Glib::operator^ ( RegexMatchFlags  lhs,
RegexMatchFlags  rhs 
)
inline
AsciiType Glib::operator^ ( AsciiType  lhs,
AsciiType  rhs 
)
inline
ModuleFlags& Glib::operator^= ( ModuleFlags lhs,
ModuleFlags  rhs 
)
inline
KeyFileFlags& Glib::operator^= ( KeyFileFlags lhs,
KeyFileFlags  rhs 
)
inline
FileTest& Glib::operator^= ( FileTest lhs,
FileTest  rhs 
)
inline
BindingFlags& Glib::operator^= ( BindingFlags lhs,
BindingFlags  rhs 
)
inline
SpawnFlags& Glib::operator^= ( SpawnFlags lhs,
SpawnFlags  rhs 
)
inline
ParamFlags& Glib::operator^= ( ParamFlags lhs,
ParamFlags  rhs 
)
inline
FormatSizeFlags& Glib::operator^= ( FormatSizeFlags lhs,
FormatSizeFlags  rhs 
)
inline
IOFlags& Glib::operator^= ( IOFlags lhs,
IOFlags  rhs 
)
inline
RegexCompileFlags& Glib::operator^= ( RegexCompileFlags lhs,
RegexCompileFlags  rhs 
)
inline
ParseFlags& Glib::Markup::operator^= ( ParseFlags lhs,
ParseFlags  rhs 
)
inline
IOCondition& Glib::operator^= ( IOCondition lhs,
IOCondition  rhs 
)
inline
RegexMatchFlags& Glib::operator^= ( RegexMatchFlags lhs,
RegexMatchFlags  rhs 
)
inline
AsciiType& Glib::operator^= ( AsciiType lhs,
AsciiType  rhs 
)
inline
ModuleFlags Glib::operator| ( ModuleFlags  lhs,
ModuleFlags  rhs 
)
inline
KeyFileFlags Glib::operator| ( KeyFileFlags  lhs,
KeyFileFlags  rhs 
)
inline
FileTest Glib::operator| ( FileTest  lhs,
FileTest  rhs 
)
inline
BindingFlags Glib::operator| ( BindingFlags  lhs,
BindingFlags  rhs 
)
inline
SpawnFlags Glib::operator| ( SpawnFlags  lhs,
SpawnFlags  rhs 
)
inline
ParamFlags Glib::operator| ( ParamFlags  lhs,
ParamFlags  rhs 
)
inline
FormatSizeFlags Glib::operator| ( FormatSizeFlags  lhs,
FormatSizeFlags  rhs 
)
inline
IOFlags Glib::operator| ( IOFlags  lhs,
IOFlags  rhs 
)
inline
RegexCompileFlags Glib::operator| ( RegexCompileFlags  lhs,
RegexCompileFlags  rhs 
)
inline
ParseFlags Glib::Markup::operator| ( ParseFlags  lhs,
ParseFlags  rhs 
)
inline
IOCondition Glib::operator| ( IOCondition  lhs,
IOCondition  rhs 
)
inline
RegexMatchFlags Glib::operator| ( RegexMatchFlags  lhs,
RegexMatchFlags  rhs 
)
inline
AsciiType Glib::operator| ( AsciiType  lhs,
AsciiType  rhs 
)
inline
ModuleFlags& Glib::operator|= ( ModuleFlags lhs,
ModuleFlags  rhs 
)
inline
KeyFileFlags& Glib::operator|= ( KeyFileFlags lhs,
KeyFileFlags  rhs 
)
inline
FileTest& Glib::operator|= ( FileTest lhs,
FileTest  rhs 
)
inline
BindingFlags& Glib::operator|= ( BindingFlags lhs,
BindingFlags  rhs 
)
inline
SpawnFlags& Glib::operator|= ( SpawnFlags lhs,
SpawnFlags  rhs 
)
inline
ParamFlags& Glib::operator|= ( ParamFlags lhs,
ParamFlags  rhs 
)
inline
FormatSizeFlags& Glib::operator|= ( FormatSizeFlags lhs,
FormatSizeFlags  rhs 
)
inline
IOFlags& Glib::operator|= ( IOFlags lhs,
IOFlags  rhs 
)
inline
RegexCompileFlags& Glib::operator|= ( RegexCompileFlags lhs,
RegexCompileFlags  rhs 
)
inline
ParseFlags& Glib::Markup::operator|= ( ParseFlags lhs,
ParseFlags  rhs 
)
inline
IOCondition& Glib::operator|= ( IOCondition lhs,
IOCondition  rhs 
)
inline
RegexMatchFlags& Glib::operator|= ( RegexMatchFlags lhs,
RegexMatchFlags  rhs 
)
inline
AsciiType& Glib::operator|= ( AsciiType lhs,
AsciiType  rhs 
)
inline
ModuleFlags Glib::operator~ ( ModuleFlags  flags)
inline
KeyFileFlags Glib::operator~ ( KeyFileFlags  flags)
inline
FileTest Glib::operator~ ( FileTest  flags)
inline
BindingFlags Glib::operator~ ( BindingFlags  flags)
inline
SpawnFlags Glib::operator~ ( SpawnFlags  flags)
inline
ParamFlags Glib::operator~ ( ParamFlags  flags)
inline
FormatSizeFlags Glib::operator~ ( FormatSizeFlags  flags)
inline
IOFlags Glib::operator~ ( IOFlags  flags)
inline
RegexCompileFlags Glib::operator~ ( RegexCompileFlags  flags)
inline
ParseFlags Glib::Markup::operator~ ( ParseFlags  flags)
inline
IOCondition Glib::operator~ ( IOCondition  flags)
inline
RegexMatchFlags Glib::operator~ ( RegexMatchFlags  flags)
inline
AsciiType Glib::operator~ ( AsciiType  flags)
inline