glibmm: glibmm Enums and Flags
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) |
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
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::BindingFlags |
Flags to be passed to g_object_bind_property() or g_object_bind_property_full().
This enumeration can be extended at later date.
- 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)
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.
enum Glib::Date::DMY |
enum Glib::FileTest |
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)
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)
enum Glib::IOCondition |
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 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. |
enum Glib::IOFlags |
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)
enum Glib::IOStatus |
enum Glib::KeyFileFlags |
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)
enum Glib::ModuleFlags |
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)
enum Glib::Date::Month |
Enumeration representing a month; values are DATE_JANUARY, DATE_FEBRUARY, etc.
DATE_BAD_MONTH is the invalid value.
enum Glib::NormalizeMode |
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.
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)
Flags specifying compile-time options.
- 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)
Flags specifying match-time options.
- 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 "^" metacharater. |
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. |
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". |
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. |
REGEX_MATCH_PARTIAL_SOFT |
An alias for REGEX_MATCH_PARTIAL. |
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. |
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". |
enum Glib::SeekType |
enum Glib::SpawnFlags |
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)
enum Glib::ThreadPriority |
Thread priorities.
Deprecated:2.32: Thread priorities no longer have any effect.
Enumerator | |
---|---|
THREAD_PRIORITY_LOW |
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. |
enum Glib::TimeType |
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. |
enum Glib::NodeTree::TraverseFlags |
Specifies which nodes are visited during several of the NodeTree methods, including traverse() and find().
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. |
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 http://www.unicode.org/unicode/reports/tr14/.
enum Glib::UnicodeType |
These are the possible character classifications from the Unicode specification.
See http://www.unicode.org/Public/UNIDATA/UnicodeData.html.
enum Glib::UserDirectory |
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.
enum Glib::Date::Weekday |
Function Documentation
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |